add build system

tools/elimination.cpp

@@ -1,28 +1,24 @@
 #include "elimination.h"
-#include "matrix.h"
 #include "math.h"
 
-struct FracturedMatrix {
-    Matrix A;
-    ColumnVector C;
-    ColumnVector b;
-    int pivot_column_index;
-    int pivot_row_index;
-};
-
-struct DestroyMatrix {
-    Matrix A;
-    ColumnVector C;
-    ColumnVector b;
-};
+FracturedMatrix::FracturedMatrix(const FracturedMatrix& other) : A(other.A), C(other.C), b(other.b), pivot_column_index(other.pivot_column_index), pivot_row_index(other.pivot_row_index) {}
+FracturedMatrix::FracturedMatrix(Matrix A, Vector C, Vector b, int pivot_column_index, int pivot_row_index) : A(A), C(C), b(b), pivot_column_index(pivot_column_index), pivot_row_index(pivot_row_index) {}
+FracturedMatrix& FracturedMatrix::operator=(const FracturedMatrix& other) {
+    A = other.A;
+    C = other.C;
+    b = other.b;
+    pivot_column_index = other.pivot_column_index;
+    pivot_row_index = other.pivot_row_index;
+    return *this;
+}
 
 DestroyMatrix destroyGeneralMatrix(Matrix& generalMatrix) {
     int rows = generalMatrix.getRows();
     int cols = generalMatrix.getColumns();
 
     Matrix A(rows - 1, cols - 1);
-    ColumnVector C(cols - 1);
-    ColumnVector b(rows - 1);
+    Vector C(cols - 1);
+    Vector b(rows - 1);
 
     for (int j = 0; j < cols - 1; ++j) {
         C[j] = generalMatrix[0][j];
@@ -41,7 +37,7 @@ DestroyMatrix destroyGeneralMatrix(Matrix& generalMatrix) {
     return {A, C, b};
 }
 
-Matrix createGeneralMatrix(Matrix& A, ColumnVector& C, ColumnVector& b) {
+Matrix createGeneralMatrix(Matrix& A, Vector& C, Vector& b) {
     Matrix generalMatrix(A.getRows() + 1, A.getColumns() + 1);
     for (int i = 0; i < A.getColumns(); i++) {
         generalMatrix[0][i] = C[i];
@@ -60,7 +56,7 @@ Matrix createGeneralMatrix(Matrix& A, ColumnVector& C, ColumnVector& b) {
     return generalMatrix;
 }
 
-FracturedMatrix elimination(Matrix A, ColumnVector C, ColumnVector b, int pivot_column_index, int pivot_row_index) {
+FracturedMatrix elimination(Matrix A, Vector C, Vector b, int pivot_column_index, int pivot_row_index) {
     Matrix generalMatrix = createGeneralMatrix(A, C, b);
 
     int rows = generalMatrix.getRows();
@@ -87,7 +83,7 @@ FracturedMatrix elimination(Matrix A, ColumnVector C, ColumnVector b, int pivot_
 
     pivot_column_index = max_index(destroyedMatrix.C);
     
-    ColumnVector ratio_vector(A.getRows());
+    Vector ratio_vector(A.getRows());
 
     for (int i = 0; i < A.getRows(); i++) {
         if (A[i][pivot_column_index] != 0) {
@@ -99,8 +95,8 @@ FracturedMatrix elimination(Matrix A, ColumnVector C, ColumnVector b, int pivot_
         }
     }
 
-    int pivot_row_index = min_index(ratio_vector);
+    pivot_row_index = min_index(ratio_vector);
 
     return {A, C, b, pivot_column_index, pivot_row_index};
-
+}
 

tools/elimination.h

@@ -1,13 +1,30 @@
 #ifndef ELIMINATION_H
 #define ELIMINATION_H
 
+#include "matrix.h"
 
 
-class Elimination {
-    public:
-    Matrix elimination(Matrix A, ColumnVector C, ColumnVector b, double eps);
+struct FracturedMatrix {
+	Matrix A;
+	Vector C;
+	Vector b;
+	int pivot_column_index;
+	int pivot_row_index;
+	FracturedMatrix();
+	FracturedMatrix(const FracturedMatrix& other);
+	FracturedMatrix(Matrix A, Vector C, Vector b, int pivot_column_index, int pivot_row_index);
+	FracturedMatrix& operator=(const FracturedMatrix& other);
 };
 
+struct DestroyMatrix {
+    Matrix A;
+    Vector C;
+    Vector b;
+};
+
+DestroyMatrix destroyGeneralMatrix(Matrix& generalMatrix);
+FracturedMatrix elimination(Matrix A, Vector C, Vector b, int pivot_column_index, int pivot_row_index);
+Matrix createGeneralMatrix(Matrix& A, Vector& C, Vector& b);
 
 
 #endif //ELIMINATION_H

tools/math.cpp

@@ -1,45 +1,44 @@
 #include "math.h"
-#include "matrix.h"
 
-double min(ColumnVector columnVector) {
-    double temp = columnVector[0];
-    for (int j = 0; j < columnVector.getColumns(); j++) {
-        if (columnVector[j] < temp) {
-            temp = columnVector[j];
+double min(Vector vector) {
+    double temp = vector[0];
+    for (int j = 0; j < vector.size(); j++) {
+        if (vector[j] < temp) {
+            temp = vector[j];
         }
     }
     return temp;
 }
 
-double max(ColumnVector columnVector) {
-    double temp = columnVector[0];
-    for (int j = 0; j < columnVector.getColumns(); j++) {
-        if (columnVector[j] > temp) {
-            temp = columnVector[j];
+double max(Vector vector) {
+    double temp = vector[0];
+    for (int j = 0; j < vector.size(); j++) {
+        if (vector[j] > temp) {
+            temp = vector[j];
         }
     }
     return temp;
 }
 
-int min_index(ColumnVector columnVector) {
+int min_index(Vector vector) {
     int temp_index = 0;
-    double temp = columnVector[0];
-    for (int j = 0; j < columnVector.getColumns(); j++) {
-        if (columnVector[j] < temp) {
+    double temp = vector[0];
+    for (int j = 0; j < vector.size(); j++) {
+        if (vector[j] < temp) {
             temp_index = j;
-            temp = columnVector[j];
+            temp = vector[j];
         }
     }
     return temp_index;
 }
 
-int max_index(ColumnVector columnVector) {
+int max_index(Vector vector) {
     int temp_index = 0;
-    double temp = columnVector[0];
-    for (int j = 0; j < columnVector.getColumns(); j++) {
-        if (columnVector[j] > temp) {
+    double temp = vector[0];
+    for (int j = 0; j < vector.size(); j++) {
+        if (vector[j] > temp) {
             temp_index = j;
-            temp = columnVector[j];
+            temp = vector[j];
         }
     }
     return temp_index;

tools/math.h

@@ -2,11 +2,12 @@
 #define MATH_H
 
 #include <vector>
+#include "matrix.h"
 
-double min(ColumnVector columnVector);
-double max(ColumnVector columnVector);
-int min_index(ColumnVector columnVector);
-int max_index(ColumnVector columnVector);
+double min(Vector vector);
+double max(Vector vector);
+int min_index(Vector vector);
+int max_index(Vector vector);
 double min(std::vector<double> array);
 double max(std::vector<double> array);
 int min_index(std::vector<double> array);

tools/matrix.cpp

@@ -1,68 +1,76 @@
 #include "matrix.h"
 
-ColumnVector::ColumnVector(int n) {
+Vector::Vector(int n) {
   rows = n;
   columns = 1;
-  columnVector.resize(n);
+  vector.resize(n);
 }
 
-ColumnVector::ColumnVector(const ColumnVector& other) {
+Vector::Vector(const Vector& other) {
   rows = other.rows;
   columns = other.columns;
-  columnVector = other.columnVector;
+  vector = other.vector;
 }
 
-int ColumnVector::getRows() const {
+Vector::Vector(std::initializer_list<double> init) {
+  rows = init.size();
+  columns = 1;
+  vector = std::vector<double>(rows);
+
+  auto it = init.begin();
+  
+  for (size_t i = 0; i < init.size(); ++i) {
+    vector[i] = *it++;
+  }
+}
+
+int Vector::size() const {
   return rows;
 }
 
-int ColumnVector::getColumns() const {
-  return columns;
+double& Vector::operator[](int row) {
+  return vector[row];
 }
 
-double& ColumnVector::operator[](int row) {
-  return columnVector[row];
-}
-
-ColumnVector& ColumnVector::operator=(const ColumnVector& other) {
+Vector& Vector::operator=(const Vector& other) {
   rows = other.rows;
   columns = other.columns;
-  columnVector = other.columnVector;
+  vector = other.vector;
   return *this;
 }
 
-ColumnVector ColumnVector::operator+(ColumnVector& other) {
+Vector Vector::operator+(Vector& other) {
   if (rows != other.rows) {
     throw std::runtime_error("Error: the dimensional problem occurred");
   }
-  ColumnVector result(rows);
+  Vector result(rows);
   for (int i = 0; i < rows; ++i) {
-    result[i] = columnVector[i] + other[i];
+    result[i] = vector[i] + other[i];
   }
 
   return result;
 }
 
-ColumnVector ColumnVector::operator-(ColumnVector& other) {
+Vector Vector::operator-(Vector& other) {
   if (rows != other.rows) {
     throw std::runtime_error("Error: the dimensional problem occurred");
   }
-  ColumnVector result(rows);
+  Vector result(rows);
   for (int i = 0; i < rows; ++i) {
-    result[i] = columnVector[i] - other[i];
+    result[i] = vector[i] - other[i];
   }
 
   return result;
 }
 
-std::istream& operator>>(std::istream& cin, ColumnVector& vectorObj) {
+std::istream& operator>>(std::istream& cin, Vector& vectorObj) {
   for (int i = 0; i < vectorObj.rows; ++i) {
     cin >> vectorObj[i];
   }
   return cin;
 }
 
-std::ostream& operator<<(std::ostream& cout, ColumnVector& vectorObj) {
+std::ostream& operator<<(std::ostream& cout, Vector& vectorObj) {
   for (int i = 0; i < vectorObj.rows; ++i) {
     if (i == vectorObj.rows - 1) {
       cout << vectorObj[i] << std::endl;
@@ -77,9 +85,9 @@ std::ostream& operator<<(std::ostream& cout, ColumnVector& vectorObj) {
 Matrix::Matrix(int n, int m) {
   rows = n;
   columns = m;
-  matrix.resize(n, ColumnVector(m));
+  matrix.resize(n, Vector(m));
   for (auto& row : matrix) {
-    row = ColumnVector(m);
+    row = Vector(m);
   }
 }
 
@@ -89,6 +97,20 @@ Matrix::Matrix(const Matrix& other) {
   matrix = other.matrix;
 }
 
+Matrix::Matrix(std::initializer_list<std::vector<double>> init) {
+  rows = init.size();
+  auto it = init.begin();
+  columns = it->size();
+  matrix = std::vector<Vector>(rows, Vector(columns));
+
+  for (int i = 0; i < rows; ++i) {
+    for (int j = 0; j < columns; ++j) {
+      matrix[i][j] = it->operator[](j);
+    }
+    ++it;
+  }
+}
+
 int Matrix::getRows() const {
   return rows;
 }
@@ -97,7 +119,7 @@ int Matrix::getColumns() const {
   return columns;
 }
 
-ColumnVector& Matrix::operator[](int row) {
+Vector& Matrix::operator[](int row) {
   return matrix[row];
 }
 
@@ -160,12 +182,12 @@ Matrix Matrix::operator*(Matrix& other) const {
   return result;
 }
 
-ColumnVector Matrix::operator*(ColumnVector other) const {
-  if (columns != other.getRows()) {
+Vector Matrix::operator*(Vector other) const {
+  if (columns != other.size()) {
     throw std::runtime_error("Error: the dimensional problem occurred");
   }
 
-  ColumnVector result(rows);
+  Vector result(rows);
   for (int i = 0; i < rows; ++i) {
     result[i] = 0;
     for (int k = 0; k < columns; ++k) {

tools/matrix.h

@@ -6,43 +6,42 @@
 #include <vector>
 
 /**
-* ColumnVector is a class to represent
+* Vector is a class to represent
 * a column vector with n rows.
 */
-class ColumnVector {
+class Vector {
 protected:
 	// Number of rows in vector
 	int rows;
 	// Number of columns in vector
 	int columns;
 	// Matrix representation as vector of vectors of integers
-	std::vector<double> columnVector;
+	std::vector<double> vector;
 public:
-	ColumnVector(int n);
+	Vector(int n);
 
-	ColumnVector(const ColumnVector& other);
+	Vector(const Vector& other);
+
+	Vector(std::initializer_list<double>);
 
 	/* Getter for the number of rows */
-	int getRows() const;
-
-	/* Getter for the number of columns */
-	int getColumns() const;
+	int size() const;
 
 	double& operator[](int row);
 
-	ColumnVector& operator=(const ColumnVector& other);
+	Vector& operator=(const Vector& other);
 
-	ColumnVector operator+(ColumnVector& other);
+	Vector operator+(Vector& other);
 
-	ColumnVector operator-(ColumnVector& other);
+	Vector operator-(Vector& other);
 
 	/* Input operator reads element of vector */
-	friend std::istream& operator>>(std::istream& cin, ColumnVector& vectorObj);
+	friend std::istream& operator>>(std::istream& cin, Vector& vectorObj);
 
 	/* Output operator prints elements of the vector
 	* in a row separated with a space (no space at the end of the line)
 	*/
-	friend std::ostream& operator<<(std::ostream& cout, ColumnVector& vectorObj);
+	friend std::ostream& operator<<(std::ostream& cout, Vector& vectorObj);
 };
 
 /**
@@ -57,19 +56,21 @@ protected:
 	// Number of columns in matrix
 	int columns;
 	// Matrix representation as vector of vectors of integers
-	std::vector<ColumnVector> matrix;
+	std::vector<Vector> matrix;
 public:
 	Matrix(int n, int m);
 
 	Matrix(const Matrix& other);
 
+	Matrix(std::initializer_list<std::vector<double>>);
+
 	/* Getter for the number of rows */
 	int getRows() const;
 
 	/* Getter for the number of columns */
 	int getColumns() const;
 
-	ColumnVector& operator[](int row);
+	Vector& operator[](int row);
 
 	Matrix& operator=(const Matrix& other);
 
@@ -80,7 +81,7 @@ public:
 	Matrix operator*(Matrix& other) const;
 
 	/* Matrix-Vector multiplication */
-	ColumnVector operator*(ColumnVector other) const;
+	Vector operator*(Vector other) const;
 
 	/* Produces transposed version of the matrix */
 	Matrix transpose() const;