Merge pull request #5 from emil28092005/first_half

Merge simplex and elimination.

main.cpp

@@ -1,85 +1,19 @@
 #include <iostream>
 #include "tools/matrix.h"
 #include "tools/math.h"
-
+#include "simplex.h"
-struct DestroyMatrix {
-    Matrix A;
-    ColumnVector C;
-    ColumnVector b;
-};
-
-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);
-
-    for (int j = 0; j < cols - 1; ++j) {
-        C[j] = generalMatrix[0][j];
-    }
-
-    for (int i = 1; i < rows; ++i) {
-        b[i - 1] = generalMatrix[i - 1][cols - 1];
-    }
-
-    for (int i = 1; i < rows; ++i) {
-        for (int j = 0; j < cols - 1; ++j) {
-            A[i - 1][j] = generalMatrix[i][j];
-        }
-    }
-
-    return {A, C, b};
-}
-
-Matrix createGeneralMatrix(Matrix& A, ColumnVector& C, ColumnVector& b) {
-    Matrix generalMatrix(A.getRows() + 1, A.getColumns() + 1);
-    for (int i = 0; i < A.getColumns(); i++) {
-        generalMatrix[0][i] = C[i];
-    }
-
-    for (int j = 0; j < A.getRows(); j++) {
-        generalMatrix[j][A.getColumns()] = b[j];
-    }
-
-    for (int i = 0; i < A.getRows(); i++) {
-        for (int j = 0; j < A.getColumns(); j++) {
-            generalMatrix[i + 1][j] = A[i][j];
-        }
-    }
-
-    return generalMatrix;
-}
 
 int main() {
-    int n, m;
+    ColumnVector C(6);
-    std::cin >> n;
+    Matrix A(6, 4);
-    std::cin >> m;
+    int Carr[C.getColumns()] = {-5, -4, 0, 0, 0, 0};
-
+    for (int i = 0; i < C.getRows(); ++i) {
-    ColumnVector C(n);
+        C[i] = Carr[i];
-    Matrix A(m - 1, n);
+    }
-    ColumnVector b(m);
+    A = {{6, 4, 1, 0, 0, 0}, {1, 2, 0, 1, 0, 0}, {-1, 1, 0, 0, 1, 0}, {0, 1, 0, 0, 0, 1}};
-    double eps;
+    ColumnVector b(A.getRows());
-    double eps_default;
+    b = {24, 6, 1, 2};
-    std::cin >> C;
+    std::cout << A << std::endl;
-    std::cin >> b;
+    std::cout << C << std::endl;
-    std::cin >> A;
-
-    std::cout << "Вектор C: " << C << std::endl;
-    std::cout << "Вектор b: " << b << std::endl;
-
-    std::cout << "Матрица A: " << A << std::endl;
-
-    Matrix E = createGeneralMatrix(A, C, b);
-    std::cout << "Матрица E: " << E << std::endl;
-
-    DestroyMatrix destroyed = destroyGeneralMatrix(E);
-    std::cout << "Вектор C: " << destroyed.C << std::endl;
-    std::cout << "Вектор b: " << destroyed.b << std::endl;
-
-    std::cout << "Матрица A: " << destroyed.A << std::endl;
-
-
     return 0;
 }

simplex.cpp

@@ -1,6 +1,7 @@
 #include <algorithm>
 #include <iostream>
 #include "tools/matrix.h"
+#include "tools/math.h"
 
 enum solver_state {
 	unbounded,
@@ -10,10 +11,55 @@ enum solver_state {
 struct Result {
 	solver_state state;
 	ColumnVector *solution;
-	double objective_fucntion_value;
+	double objective_function_value;
 };
 
-Result Simplex(ColumnVector C, Matrix A, ColumnVector b, double eps = 0.01, bool maximize) {
+struct FracturedMatrix {
+	Matrix A;
+	ColumnVector C;
+	ColumnVector b;
+	int pivot_column_index;
+	int pivot_row_index;
+	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(Matrix A, ColumnVector C, ColumnVector 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;
+	}
+};
+
+Result Simplex(ColumnVector C, Matrix A, ColumnVector b, double eps = 0.01, bool maximize=true) {
+
+	std::cout << "C: " << C << std::endl;
+	std::cout << "A: " << A << std::endl;
+    std::cout << "b: " << b << std::endl;
+
+    int n = C.getRows();
+    int m = A.getColumns();
+
+	while (b[0] < eps) {
+		//3
+		int pivot_column_index = 0;
+		pivot_column_index = Math::max_index(C);
+
+		//4
+		ColumnVector ratio_vector(m);
+		for (int i = 0; i < m; i++) {
+			ratio_vector[i] = b[i] / A[i][pivot_column_index];
+		}
+		int pivot_row_index = Math::min_index(ratio_vector);
+
+		//5
+		struct FracturedMatrix fractured_matrix();
+		fractured_matrix = eleminate(A, C, b, pivot_column_index, pivot_row_index);
+	}
+
+	/*
 	Result result;
 	std::vector<int> basicVars(A.getColumns() - A.getRows());
 	basicVars[0] = -1;
@@ -43,7 +89,9 @@ Result Simplex(ColumnVector C, Matrix A, ColumnVector b, double eps = 0.01, bool
 			}
 		}
 		result.objective_fucntion_value = b[0];
+
 	}
+	*/
 }
 
 /*

simplex.h

@@ -0,0 +1,20 @@
+#ifndef SIMPLEX_H
+#define SIMPLEX_H
+
+#include <vector>
+#include "tools/matrix.h"
+
+enum solver_state {
+  unbounded,
+  bounded
+};
+
+struct Result {
+  solver_state state;
+  ColumnVector *solution;
+  double objective_fucntion_value;
+};
+
+Result Simplex(ColumnVector C, Matrix A, ColumnVector b, double eps = 0.01, bool maximize = true);
+
+#endif // SIMPLEX_H

tools/math.cpp

@@ -1,7 +1,7 @@
 #include "math.h"
 #include "matrix.h"
 
-double Math::min(ColumnVector columnVector) {
+double min(ColumnVector columnVector) {
     double temp = columnVector[0];
     for (int j = 0; j < columnVector.getColumns(); j++) {
         if (columnVector[j] < temp) {
@@ -11,7 +11,7 @@ double Math::min(ColumnVector columnVector) {
     return temp;
 }
 
-double Math::max(ColumnVector columnVector) {
+double max(ColumnVector columnVector) {
     double temp = columnVector[0];
     for (int j = 0; j < columnVector.getColumns(); j++) {
         if (columnVector[j] > temp) {
@@ -21,7 +21,7 @@ double Math::max(ColumnVector columnVector) {
     return temp;
 }
 
-int Math::min_index(ColumnVector columnVector) {
+int min_index(ColumnVector columnVector) {
     int temp_index = 0;
     double temp = columnVector[0];
     for (int j = 0; j < columnVector.getColumns(); j++) {
@@ -33,7 +33,7 @@ int Math::min_index(ColumnVector columnVector) {
     return temp_index;
 }
 
-int Math::max_index(ColumnVector columnVector) {
+int max_index(ColumnVector columnVector) {
     int temp_index = 0;
     double temp = columnVector[0];
     for (int j = 0; j < columnVector.getColumns(); j++) {
@@ -45,7 +45,7 @@ int Math::max_index(ColumnVector columnVector) {
     return temp_index;
 }
 
-double Math::min(std::vector<double> array) {
+double min(std::vector<double> array) {
     double temp = array[0];
     for (size_t i = 1; i < array.size(); i++) {
         if (array[i] < temp) {
@@ -55,7 +55,7 @@ double Math::min(std::vector<double> array) {
     return temp;
 }
 
-double Math::max(std::vector<double> array) {
+double max(std::vector<double> array) {
     double temp = array[0];
     for (size_t i = 1; i < array.size(); i++) {
         if (array[i] > temp) {
@@ -65,7 +65,7 @@ double Math::max(std::vector<double> array) {
     return temp;
 }
 
-double Math::min(std::vector<double> array) {
+int min_index(std::vector<double> array) {
     int temp_index = 0;
     double temp = array[0];
     for (size_t i = 1; i < array.size(); i++) {
@@ -77,7 +77,8 @@ double Math::min(std::vector<double> array) {
     return temp_index;
 }
 
-double Math::max(std::vector<double> array) {
+
+int max_index(std::vector<double> array) {
     int temp_index = 0;
     double temp = array[0];
     for (size_t i = 1; i < array.size(); i++) {

tools/math.h

@@ -3,18 +3,13 @@
 
 #include <vector>
 
-class ColumnVector;
+double min(ColumnVector columnVector);
-
+double max(ColumnVector columnVector);
-class Math {
+int min_index(ColumnVector columnVector);
-public:
+int max_index(ColumnVector columnVector);
-    double min(ColumnVector columnVector);
+double min(std::vector<double> array);
-    double max(ColumnVector columnVector);
+double max(std::vector<double> array);
-    static int min_index(ColumnVector columnVector);
+int min_index(std::vector<double> array);
-    static int max_index(ColumnVector columnVector);
+int max_index(std::vector<double> array);
-    double min(std::vector<double> array);
-    double max(std::vector<double> array);
-    int min_index(std::vector<double> array);
-    int max_index(std::vector<double> array);
-};
 
 #endif // MATH_H