Fix the incorrect output error.

Implement epsilon (but doesn't work correctly for now).
Start making the correct implementation of I/O.

.gitignore

@@ -1,34 +0,0 @@
-*.vscode
-# Prerequisites
-*.d
-CMakeLists.txt
-.idea
-# Compiled Object files
-*.slo
-*.lo
-*.o
-*.obj
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
-
-# Fortran module files
-*.mod
-*.smod
-
-# Compiled Static libraries
-*.lai
-*.la
-*.a
-*.lib
-
-# Executables
-*.exe
-*.out
-*.app

CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.29)
+project(SimplexTASK)
+
+set(CMAKE_CXX_STANDARD 20)
+
+add_executable(SimplexTASK main.cpp
+        simplex.cpp
+        tools/matrix.cpp
+        tools/math.cpp
+        tools/elimination.cpp
+)

Makefile

@@ -1,67 +0,0 @@
-GXX := g++ -std=c++20
-flags := -Wall -fsanitize=address
-TOOLS := tools
-BUILD := build
-
-build:
-	mkdir -p $(BUILD)
-	$(GXX) -c $(flags) $(TOOLS)/elimination.cpp -o $(BUILD)/elimination.obj
-	$(GXX) -c $(flags) $(TOOLS)/math.cpp -o $(BUILD)/math.obj
-	$(GXX) -c $(flags) $(TOOLS)/matrix.cpp -o $(BUILD)/matrix.obj
-	$(GXX) -c $(flags) simplex.cpp -o $(BUILD)/simplex.obj
-	$(GXX) -c $(flags) main.cpp -o $(BUILD)/main.obj
-
-	$(GXX) $(BUILD)/*.obj $(flags) -o simplex.out
-
-$(BUILD)/elimination.obj: $(TOOLS)/elimination.cpp
-	$(GXX) -c $(flags) $(TOOLS)/elimination.cpp -o $(BUILD)/elimination.obj
-
-$(BUILD)/math.obj: $(TOOLS)/math.cpp
-	$(GXX) -c $(flags) $(TOOLS)/math.cpp -o $(BUILD)/math.obj
-
-$(BUILD)/matrix.obj: $(TOOLS)/matrix.cpp
-	$(GXX) -c $(flags) $(TOOLS)/matrix.cpp -o $(BUILD)/matrix.obj
-
-$(BUILD)/simplex.obj: simplex.cpp
-	$(GXX) -c $(flags) simplex.cpp -o $(BUILD)/simplex.obj
-
-$(BUILD)/main.obj: main.cpp
-	$(GXX) -c $(flags) main.cpp -o $(BUILD)/main.obj
-
-simplex.out: $(BUILD)/elimination.obj $(BUILD)/math.obj $(BUILD)/matrix.obj $(BUILD)/simplex.obj $(BUILD)/main.obj
-	$(GXX) $(BUILD)/*.obj $(flags) -o simplex.out
-
-test: simplex.out
-	./simplex.out
-
-clean:
-	rm -rf $(BUILD)
-	rm -rf simplex.out
-
-rebuild:
-	rm -rf $(BUILD)
-	rm -rf simplex.out
-
-	mkdir -p $(BUILD)
-	$(GXX) -c $(flags) $(TOOLS)/elimination.cpp -o $(BUILD)/elimination.obj
-	$(GXX) -c $(flags) $(TOOLS)/math.cpp -o $(BUILD)/math.obj
-	$(GXX) -c $(flags) $(TOOLS)/matrix.cpp -o $(BUILD)/matrix.obj
-	$(GXX) -c $(flags) simplex.cpp -o $(BUILD)/simplex.obj
-	$(GXX) -c $(flags) main.cpp -o $(BUILD)/main.obj
-
-	$(GXX) $(BUILD)/*.obj $(flags) -o simplex.out
-
-	$(BUILD)/elimination.obj: $(TOOLS)/elimination.cpp
-	$(GXX) -c $(flags) $(TOOLS)/elimination.cpp -o $(BUILD)/elimination.obj
-
-	$(BUILD)/math.obj: $(TOOLS)/math.cpp
-	$(GXX) -c $(flags) $(TOOLS)/math.cpp -o $(BUILD)/math.obj
-
-	$(BUILD)/matrix.obj: $(TOOLS)/matrix.cpp
-	$(GXX) -c $(flags) $(TOOLS)/matrix.cpp -o $(BUILD)/matrix.obj
-
-	$(BUILD)/simplex.obj: simplex.cpp
-	$(GXX) -c $(flags) simplex.cpp -o $(BUILD)/simplex.obj
-
-	$(BUILD)/main.obj: main.cpp
-	$(GXX) -c $(flags) main.cpp -o $(BUILD)/main.obj

Makefile.txt

@@ -0,0 +1,35 @@
+GXX := g++ -std=c++20
+flags := -Wall -fsanitize=address
+TOOLS := tools
+BUILD := build
+
+build:
+	mkdir $(BUILD)
+	$(GXX) -c $(flags) $(TOOLS)/elimination.cpp -o $(BUILD)/elimination.obj
+	$(GXX) -c $(flags) $(TOOLS)/math.cpp -o $(BUILD)/math.obj
+	$(GXX) -c $(flags) $(TOOLS)/matrix.cpp -o $(BUILD)/matrix.obj
+	$(GXX) -c $(flags) simplex.cpp -o $(BUILD)/simplex.obj
+	$(GXX) -c $(flags) main.cpp -o $(BUILD)/main.obj
+
+	$(GXX) $(BUILD)/*.obj $(flags) -o simplex.out
+
+$(BUILD)/elimination.obj: $(TOOLS)/elimination.cpp
+	$(GXX) -c $(flags) $(TOOLS)/elimination.cpp -o $(BUILD)/elimination.obj
+
+$(BUILD)/math.obj: $(TOOLS)/math.cpp
+	$(GXX) -c $(flags) $(TOOLS)/math.cpp -o $(BUILD)/math.obj
+
+$(BUILD)/matrix.obj: $(TOOLS)/matrix.cpp
+	$(GXX) -c $(flags) $(TOOLS)/matrix.cpp -o $(BUILD)/matrix.obj
+
+$(BUILD)/simplex.obj: simplex.cpp
+	$(GXX) -c $(flags) simplex.cpp -o $(BUILD)/simplex.obj
+
+$(BUILD)/main.obj: main.cpp
+	$(GXX) -c $(flags) main.cpp -o $(BUILD)/main.obj
+
+$(BUILD)/simplex.out: $(BUILD)/elimination.obj $(BUILD)/math.obj $(BUILD)/matrix.obj $(BUILD)/simplex.obj $(BUILD)/main.obj
+	$(GXX) $(BUILD)/*.obj $(flags) -o simplex.out
+
+clean:
+	rm -rf $(BUILD)

README.md

@@ -1,7 +0,0 @@
-<h1> Instructions for installing </h1>
-<h2>1. Clone the repository.</h2>
-  <code>git clone https://github.com/emil28092005/SimplexTASK/</code>
-<h2>2. Build the project (install Make if not present on your system): </h2>
-  <code>make build</code>
-<h2>3. Run tests via the following command: </h2>
-  <code>make test</code>

main.cpp

@@ -1,410 +1,58 @@
 #include <iostream>
-#include <functional>
 #include "tools/matrix.h"
 #include "tools/math.h"
 #include "simplex.h"
 
-void _printInitialInputs(Vector &C, Matrix &A, Vector &b, double eps, bool maximize)
+void manualInput() {
-{
+    int ZLength;
-    std::cout << "Running for the following inputs:" << std::endl
+    std::cout << "Write how many x's the objective function has:" << std::endl;
-              << std::endl;
+    std::cin >> ZLength;
-    std::cout << "epsilon: " << eps << std::endl;
+    Vector Z = {};
-    if (maximize)
-    {
-        std::cout << "Maximize" << std::endl;
-    }
-    else
-    {
-        std::cout << "Minimize" << std::endl;
-    }
-    std::cout << "z = ";
-    bool previousIsZero = true;
-    bool lastNonZero = false;
-    for (int i = 0; i < C.size(); i++)
-    {
-        bool isNegative = false;
-        
-        for (int k = i; k < C.size(); k++)
-        {
-            if (C[k] == 0)
-            {
-                lastNonZero = true;
-            } else{
-                lastNonZero = false;
-                break;
-            }
-                
-        }
-
-        if (!previousIsZero && !lastNonZero){
-            std::cout << " + ";
-        }
-
-        if (C[i] != 0){
-            if (C[i] != 1) {
-                if (C[i] < 0){
-                    isNegative = true;
-                    std::cout << "(";
-                }
-                std::cout << C[i] << " * ";
-            }
-            std::cout << "x" << i + 1;
-            if (isNegative){
-                std::cout << ")";
-            }
-            previousIsZero = false;
-        }else {
-            previousIsZero = true;
-        }
-
-    }
-    std::cout << std::endl
-              << "subject to the constrains:" << std::endl;
-    std::cout << std::endl;
-    for (int i = 0; i < b.size(); i++)
-    {
-        bool previousIsZero = true;
-        bool lastNonZero = false;
-
-        for (int j = 0; j < A.getColumns(); j++)
-        {
-            bool isNegative = false;
-
-            for (int k = j; k < A[i].size(); k++)
-            {
-                if (A[i][k] == 0)
-                {
-                    lastNonZero = true;
-                } else{
-                    lastNonZero = false;
-                    break;
-                }
-                
-            }
-
-            if (!previousIsZero && !lastNonZero){
-                std::cout << " + ";
-            }
-
-            if (A[i][j] != 0) { 
-                if (A[i][j] != 1) {
-                    if (A[i][j] < 0) {
-                        isNegative = true;
-                        std::cout << "(";
-                    }
-                    std::cout << A[i][j] << " * ";
-                }
-                std::cout << "x" << j + 1;
-                if (isNegative) {
-                    std::cout << ")";
-                }
-                previousIsZero = false;
-                
-            }else {
-                previousIsZero = true;
-            }
-        }
-        std::cout << " <= " << b[i] << std::endl;
-    }
 }
+void printInitialInputs(Vector C, Matrix A, Vector b) {
 
-int printResult(Result result)
-{
-    if (result.state == unsolvable)
-    {
-        std::cout << "The method is not applicable!" << std::endl;
-    }else if (result.state == unbounded ) {
-        std::cout << "Unbounded problem!" << std::endl;
-    }
-    else
-    {
-        std::cout << "SOLVED!" << std::endl;
-        std::cout << "Decision variables: [";
-
-        for (int i = 0; i < result.solution.size(); i++)
-        {
-            std::cout << result.solution[i];
-            if (i != result.solution.size() - 1)
-            {
-                std::cout << ", ";
-            }
-        }
-        std::cout << "]";
-        std::cout << std::endl;
-        if (result.maximize)
-        {
-            std::cout << "Maximum ";
-        }
-        else
-        {
-            std::cout << "Minimum ";
-        }
-        std::cout << "objective function value: " << result.objective_function_value << std::endl;
-    }
-    return 0;
 }
+int main() {
+    // TODO: Initially should be positive
+    std::string doManual = "";
+    std::cout << "Enable manual input? (y/n)" << std::endl;
+    std::cin >> doManual ;
+    if (doManual == "y" or doManual == "Y") {
+        manualInput();
+    } else if (doManual == "n"){
 
-bool check_eq(double a, double b, double relativeEpsilon = 0.0001)
+    }
-{
-    double diff = std::abs(a - b);
-    a = std::abs(a);
-    b = std::abs(b);
-    double largest = (b > a) ? b : a;
 
-    return diff <= largest * relativeEpsilon;
+    Vector C = {5, 4, 0, 0, 0, 0};
-}
 
-int TEST_GENERAL_CASE()
-{
-    std::cout << "----------------------------RUNNING_TEST_GENERAL_CASE----------------------------" << std::endl;
-    Vector C = {5, 4};
     Matrix A = {
-        {6, 4},
+             {6, 4, 1, 0, 0, 0},
-        {1, 2},
+             {1, 2, 0, 1, 0, 0},
-        {-1, 1},
+             {-1, 1, 0, 0, 1, 0},
-        {0, 1}};
+             {0, 1, 0, 0, 0, 1}
+                };
+
     Vector b = {24, 6, 1, 2};
-    _printInitialInputs(C, A, b, 0.01, true);
-    auto result = simplex(C, A, b);
 
-    if (!(result.state == bounded))
+    //Matrix test = {{1, -1, -2}, {1, 1, -2}, {1, -1, 2}};
-    {
+
-        std::string state_name;
+    //showMatrix(test);
-        switch (result.state)
+    
-        {
+
-        case unsolvable:
+    Result result = Simplex(C, A, b, 0.1, true);
-            state_name = "unsolvable";
+    if(result.state == bounded) {
-            break;
+
-        case unbounded:
+        if(result.solution == nullptr) {
-            state_name = "unbounded";
+            // TODO: error
-            break;
-        default:
-            state_name = "bounded";
-            break;
         }
-        std::cout << "Incorrect state type. Expected bounded. Got " << state_name << std::endl;
+        std::cout << *result.solution << std::endl;
-        return 0;
+        std::cout << result.objective_fucntion_value << std::endl;
+
+        delete result.solution;
     }
-
+    //std::cout << "asdasd" << std::endl;
-    if (!check_eq(result.objective_function_value, 21))
-    {
-        std::cout << "Incorrect objective function value. Expected 21. Got "
-                  << result.objective_function_value << std::endl;
-        return 0;
-    }
-
-    if (!(check_eq(result.solution[0], 3) && check_eq(result.solution[1], 1.5)))
-    {
-        std::cout << "Incorrect desire variables. Expected 3 and 1.5. Got "
-                  << result.solution;
-        return 0;
-    }
-
-    printResult(result);
-    return 1;
-}
-
-int TEST_MINIMIZE_CASE()
-{
-    std::cout << "----------------------------RUNNING_TEST_MINIMIZE_CASE----------------------------" << std::endl;
-    Vector C = {-2, 2, -6};
-    Matrix A = {
-        {2, 1, -2},
-        {1, 2, 4},
-        {1, -1, 2}};
-    Vector b = {24, 23, 10};
-    _printInitialInputs(C, A, b, 0.01, false);
-    auto result = simplex(C, A, b, 0.01, false);
-
-    if (!(result.state == bounded))
-    {
-        std::string state_name;
-        switch (result.state)
-        {
-        case unsolvable:
-            state_name = "unsolvable";
-            break;
-        case unbounded:
-            state_name = "unbounded";
-            break;
-        default:
-            state_name = "bounded";
-            break;
-        }
-        std::cout << "Incorrect state type. Expected bounded. Got " << state_name << std::endl;
-        return 0;
-    }
-
-    if (!check_eq(result.objective_function_value, -30.75))
-    {
-        std::cout << "Incorrect objective function value. Expected -30.75. Got "
-                  << result.objective_function_value << std::endl;
-        return 0;
-    }
-
-    if (!(check_eq(result.solution[0], 0) && check_eq(result.solution[1], 0.75) && check_eq(result.solution[2], 5.375)))
-    {
-        std::cout << "Incorrect desire variables. Expected 3 and 1.5. Got "
-                  << result.solution;
-        return 0;
-    }
-
-    printResult(result);
-
-    return 1;
-}
-
-int TEST_WITH_SLACK_CASE()
-{
-    std::cout << "----------------------------RUNNING_TEST_WITH_SLACK_CASE----------------------------" << std::endl;
-
-    Vector C = {2, -1, 0, -1};
-    Matrix A = {
-        {1, -2, 1, 0},
-        {-2, -1, 0, -2},
-        {3, 2, 0, 1}};
-    Vector b = {10, 18, 36};
-
-    _printInitialInputs(C, A, b, 0.01, true);
-
-    auto result = simplex(C, A, b);
-
-    if (!(result.state == bounded))
-    {
-        std::string state_name;
-        switch (result.state)
-        {
-        case unsolvable:
-            state_name = "unsolvable";
-            break;
-        case unbounded:
-            state_name = "unbounded";
-            break;
-        default:
-            state_name = "bounded";
-            break;
-        }
-        std::cout << "Incorrect state type. Expected bounded. Got " << state_name << std::endl;
-        return 0;
-    }
-
-    if (result.objective_function_value != 22.25)
-    {
-        std::cout << "Incorrect objective function value. Expected 22.25. Got "
-                  << result.objective_function_value << std::endl;
-        return 0;
-    }
-
-    if (!((result.solution[0] == 11.5) || (result.solution[1] == 0.75) ||
-          (result.solution[2] == 0) || (result.solution[3] == 0)))
-    {
-        std::cout << "Incorrect desire variables. Expected 11.5, 0.75, 0, and 0. Got "
-                  << result.solution;
-        return 0;
-    }
-
-    printResult(result);
-
-    return 1;
-}
-
-int TEST_UNBOUNDED_CASE()
-{
-    std::cout << "----------------------------RUNNING_TEST_UNBOUNDED_CASE----------------------------" << std::endl;
-
-    Vector C = {2, 1};
-    Matrix A = {
-        {1, -1},
-        {2, 0}};
-    Vector b = {10, 40};
-
-    _printInitialInputs(C, A, b, 0.01, true);
-
-    auto result = simplex(C, A, b);
-
-    if (!(result.state == unbounded))
-    {
-        std::string state_name;
-        switch (result.state)
-        {
-        case unsolvable:
-            state_name = "unsolvable";
-            break;
-        case unbounded:
-            state_name = "unbounded";
-            break;
-        default:
-            state_name = "bounded";
-            break;
-        }
-        std::cout << "Incorrect state type. Expected unbounded. Got " << state_name << std::endl;
-        return 0;
-    }
-
-    printResult(result);
-
-    return 1;
-}
-
-int TEST_UNSOLVABLE_CASE()
-{
-    std::cout << "----------------------------RUNNING_TEST_UNSOLVABLE_CASE----------------------------" << std::endl;
-
-    Vector C = {5, 4, 0, -5, 13};
-    Matrix A = {
-        {6, 4, 1, 3, 4},
-        {1, 2, 0, 0, 2},
-        {-1, 0, 0, 10, 0},
-        {0, 1, 1, -5, 1}};
-    Vector b = {-24, 6, 1, 2};
-
-    _printInitialInputs(C, A, b, 0.01, true);
-
-    auto result = simplex(C, A, b);
-
-    if (!(result.state == unsolvable))
-    {
-        std::string state_name;
-        switch (result.state)
-        {
-        case unsolvable:
-            state_name = "unsolvable";
-            break;
-        case unbounded:
-            state_name = "unbounded";
-            break;
-        default:
-            state_name = "bounded";
-            break;
-        }
-        std::cout << "Incorrect state type. Expected unsolvable. Got " << state_name << std::endl;
-        return 0;
-    }
-
-    printResult(result);
-
-    return 1;
-}
-
-int main()
-{
-    std::vector<std::function<int(void)>> tests = {
-        TEST_GENERAL_CASE,
-        TEST_MINIMIZE_CASE,
-        TEST_WITH_SLACK_CASE,
-        TEST_UNBOUNDED_CASE,
-        TEST_UNSOLVABLE_CASE};
-
-    int counter = 0;
-
-    for (auto &test : tests)
-    {
-        counter += test();
-    }
-
-    std::cout << "----------------------------RESULTS----------------------------" << std::endl;
-    std::cout << "Total number of tests: " << tests.size() << std::endl;
-    std::cout << "Total number of passed tests: " << counter << std::endl;
 
     return 0;
 }
+
+

simplex.cpp

@@ -4,141 +4,226 @@
 #include "tools/math.h"
 #include "tools/elimination.h"
 
-enum solver_state
+enum solver_state {
-{
 	unbounded,
-	bounded,
+	bounded
-	unsolvable
 };
 
-struct Result
+struct Result {
-{
 	solver_state state;
-	Vector solution;
+	Vector *solution;
 	double objective_function_value;
-	bool maximize;
 };
 
-void _stopIterating(Matrix &generalMatrix, Vector &C, std::vector<int> &basicVars, solver_state state, Result &result)
-{
-	DestroyMatrix destroyedGeneralMatrix = disassembleGeneralMatrix(generalMatrix);
-	Matrix _A = destroyedGeneralMatrix.A;
-	Vector _C = destroyedGeneralMatrix.C;
-	Vector _b = destroyedGeneralMatrix.b;
 
-	result.state = state;
-	if (state == bounded)
-	{
-		result.solution = Vector(C.size());
-		for (int i = 0; i < C.size(); i++)
-		{
-			result.solution[i] = 0;
-		}
-		for (size_t i = 1; i < basicVars.size(); i++)
-		{
-			if (basicVars[i] < C.size())
-			{
-				result.solution[basicVars[i]] = _b[i];
-			}
-		}
 
-		result.objective_function_value = _b[0];
+Result Simplex(Vector C, Matrix A, Vector b, double eps = 0.01, bool maximize=true) {
+	if (maximize == true) {
+		for (int i = 0; i < C.size(); i++) {
+		    C[i] = -C[i];
+		    }
 	}
-	else
+ 	Result result{};
-	{
+  	Matrix generalMatrix = createGeneralMatrix(A, C, b);
-		result.solution = Vector({0});
+	std::cout << "Before:" << std::endl;
-		result.objective_function_value = 0;
+	showMatrix(generalMatrix);
-	}
-}
-
-/*
-	Implementation of the Simplex method.
-*/
-Result simplex(Vector &C, Matrix &A, Vector &b, double eps = 0.01, bool maximize = true)
-{
-
-	if (maximize == true)
-	{
-		for (int i = 0; i < C.size(); i++)
-		{
-			C[i] = -C[i];
-		}
-	}
-	Result result{};
-	result.maximize = maximize;
-
-	Matrix generalMatrix = createGeneralMatrix(A, C, b);
-	std::cout << generalMatrix;
 	std::vector<int> basicVars(generalMatrix.getRows());
 	basicVars[0] = -1;
 
-	for (int i = 0; i < b.size(); ++i)
+	for (size_t i = 1; i < basicVars.size(); i++) {
-	{
-		if (b[i] < 0)
-		{
-			_stopIterating(generalMatrix, C, basicVars, unsolvable, result);
-			return result;
-		}
-	}
-
-	for (size_t i = 1; i < basicVars.size(); i++)
-	{
 		basicVars[i] = static_cast<int>(basicVars.size()) + i;
 	}
 	int iterationCount = 0;
-	while (true)
+	while (true) {
-	{
+		//3
-		// 3
 		iterationCount++;
+		std::cout << "Iteration: ";
+		std::cout << iterationCount << std::endl;
 		int pivot_column_index = 0;
+		if (maximize) {
 
-		pivot_column_index = min_index(generalMatrix[0]);
+			pivot_column_index = min_index(generalMatrix[0]);
 
-		if (generalMatrix[0][pivot_column_index] >= 0)
+			if (generalMatrix[0][pivot_column_index] >= 0) {
-		{
+				DestroyMatrix destroyedGeneralMatrix = disassembleGeneralMatrix(generalMatrix);
-			_stopIterating(generalMatrix, C, basicVars, bounded, result);
+				Matrix _A = destroyedGeneralMatrix.A;
-			if (!maximize)
+				Vector _C = destroyedGeneralMatrix.C;
-			{
+				Vector _b = destroyedGeneralMatrix.b;
-				result.objective_function_value = -result.objective_function_value;
+
+				result.state = bounded;
+				result.solution = new Vector(C.size());
+				for (int i = 0; i < C.size(); i++) {
+					result.solution->operator[](i) = 0;
+				}
+				for (size_t i = 1; i < basicVars.size(); i++) {
+					if (basicVars[i] <= C.size()) {
+						result.solution->operator[](basicVars[i]) = _b[i];
+					}
+				}
+				result.objective_function_value = _C[_C.size()];
+				return result;
 			}
-			return result;
 		}
 
-		// 4
+		if (maximize == false) {
-		Vector ratio_vector(generalMatrix.getRows());
+			pivot_column_index = max_index(generalMatrix[0]);
-		for (int i = 1; i < generalMatrix.getRows(); i++)
+
-		{
+			if (generalMatrix[0][pivot_column_index] < 0) {
-			if (generalMatrix[i][pivot_column_index] != 0)
+				DestroyMatrix destroyedGeneralMatrix = disassembleGeneralMatrix(generalMatrix);
-			{
+				Matrix _A = destroyedGeneralMatrix.A;
-				ratio_vector[i] = generalMatrix[i][generalMatrix.getColumns() - 1] / generalMatrix[i][pivot_column_index];
+				Vector _C = destroyedGeneralMatrix.C;
-				if (std::abs(ratio_vector[i]) < eps)
+				Vector _b = destroyedGeneralMatrix.b;
-				{
+
-					ratio_vector[i] = 0;
+				result.state = bounded;
+				result.solution = new Vector(C.size());
+				for (int i = 0; i < C.size(); i++) {
+					result.solution->operator[](i) = 0;
 				}
+				for (size_t i = 1; i < basicVars.size(); i++) {
+					if (basicVars[i] <= C.size()) {
+						result.solution->operator[](basicVars[i]) = _b[i];
+					}
+				}
+				result.objective_function_value = _C[_C.size()];
+				return result;
 			}
-			else
+		}
-			{
+
-				ratio_vector[i] = 0;
+
-			}
+		//4
+		Vector ratio_vector(generalMatrix.getRows());
+		for (int i = 1; i < generalMatrix.getRows(); i++) {
+			if (generalMatrix[i][pivot_column_index] != 0) {
+            	ratio_vector[i] = generalMatrix[i][generalMatrix.getColumns() - 1] / generalMatrix[i][pivot_column_index];
+        	} else {
+            	ratio_vector[i] = 0;
+        	}
 		}
 		ratio_vector[0] = 0;
 
 		int pivot_row_index = min_index_positive(ratio_vector);
 
-		// No leaving variable exists
-		if (pivot_row_index == -1)
-		{
-			_stopIterating(generalMatrix, C, basicVars, unbounded, result);
-			return result;
-		}
-
 		basicVars[pivot_row_index] = pivot_column_index;
 
-		// 5
+		//5
 		elimination(generalMatrix, pivot_row_index, pivot_column_index);
-		std::cout << "Iteration " << iterationCount << " " << std::endl;
+		std::cout << "After:" << std::endl;
-		;
+		showMatrix(generalMatrix);
-		std::cout << generalMatrix;
+
+		if (maximize) {
+			bool thereIsNegative = false;
+			for (int j = 0; j < generalMatrix.getColumns()-1; ++j) {
+				if (generalMatrix[0][j] < 0) {
+					thereIsNegative = true;
+				}
+			}
+			if (thereIsNegative) {
+				for (int j = 0; j < generalMatrix.getColumns()-1; ++j) {
+					if (generalMatrix[0][j] > 0) {
+						if (generalMatrix[0][j] < (eps * (-1))) {
+							showMatrix(generalMatrix);
+							std::cout << generalMatrix[0][j] << std::endl;
+							return result;
+						}
+					}
+				}
+			}
+		}
+		if (maximize == false) {
+			bool thereIsPositive = false;
+			for (int j = 0; j < generalMatrix.getColumns()-1; ++j) {
+				if (generalMatrix[0][j] > 0) {
+					thereIsPositive = true;
+				}
+			}
+			if (thereIsPositive) {
+				for (int j = 0; j < generalMatrix.getColumns()-1; ++j) {
+					if (generalMatrix[0][j] > 0) {
+						if (generalMatrix[0][j] < eps) {
+							showMatrix(generalMatrix);
+							std::cout << generalMatrix[0][j] << std::endl;
+							return result;
+						}
+					}
+				}
+			}
+		}
+
+
+
 	}
+
 	return result;
+
+	/*
+	Result result;
+	std::vector<int> basicVars(A.getColumns() - A.getRows());
+	basicVars[0] = -1;
+
+	for (int i = 1; i < basicVars.size(); i++) {
+		basicVars[i] = static_cast<int>(basicVars.size()) + i;
+	}
+
+	int kc = 0;
+	double temp = A[0][0];
+	for (int j = 0; j< A.getColumns(); j++) {
+		if (A[0][j] < temp) {
+			temp = A[0][j];
+			kc = j;
+		}
+	}
+
+	if (A[0][kc] >= 0) {
+		result.state = unbounded;
+		result.solution = new Vector(C.getRows());
+		for (int i = 0; i < C.getRows(); i++) {
+			result.solution->operator[](i) = 0;
+		}
+		for (int i = 1; i < basicVars.size(); i++) {
+			if (basicVars[i] <= C.getRows()) {
+				(*result.solution)[basicVars[i]] = b.getRows() - 1;
+			}
+		}
+		result.objective_fucntion_value = b[0];
+
+	}
+	*/
 }
+
+/*
+Function_name(C, A, b, eps = eps_default)
+
+Input:
+- C: A vector of coefficients of the objective function
+- A: A matrix of coefficients of the constraint functions
+- b: A vector of right-hand side values
+- eps: Approximation accuracy (optional, default = eps_default)
+
+Steps:
+1. Print the optimization problem:
+   - max (or min) z = C[0] * x1 + C[1] * x2 + ... + C[n] * xn
+   - subject to the constraints:
+     - A[0] * x <= b[0]
+     - A[1] * x <= b[1]
+     - ...
+     - A[m] * x <= b[m]
+
+2. Initialize:
+   - Form the initial tableau by introducing slack variables to convert inequalities into equalities.
+
+3. Iteratively apply the Simplex method:
+   - Step 1: Identify the entering variable (most negative coefficient in the objective row).
+   - Step 2: Identify the leaving variable (smallest positive ratio of RHS to pivot column).
+   - Step 3: Perform pivot operations to update the tableau.
+
+4. Check for optimality or unboundedness:
+   - If all coefficients in the objective function row are non-negative, the solution is optimal.
+   - If no leaving variable exists, the problem is unbounded.
+
+5. Return:
+   - solver_state: {solved, unbounded}
+   - x*: Optimal vector of decision variables (if solved)
+   - z: Maximum (or minimum) value of the objective function (if solved)
+
+End Function
+*/

simplex.h

@@ -4,23 +4,17 @@
 #include <vector>
 #include "tools/matrix.h"
 
-enum solver_state
+enum solver_state {
-{
   unbounded,
-  bounded,
+  bounded
-  unsolvable
 };
 
-struct Result
+struct Result {
-{
   solver_state state;
-  Vector solution;
+  Vector *solution;
-  double objective_function_value;
+  double objective_fucntion_value;
-  bool maximize;
 };
 
-void _printInitialInputs(Vector &C, Matrix &A, Vector &b);
+Result Simplex(Vector C, Matrix A, Vector b, double eps = 0.01, bool maximize = true);
-void _stopIterating(Matrix &generalMatrix, std::vector<int> &basicVars, Result &result);
-Result simplex(Vector &C, Matrix &A, Vector &b, double eps = 0.01, bool maximize = true);
 
 #endif // SIMPLEX_H

tools/elimination.cpp

@@ -1,10 +1,9 @@
 #include "elimination.h"
 #include "math.h"
 
-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(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)
+FracturedMatrix& FracturedMatrix::operator=(const FracturedMatrix& other) {
-{
     A = other.A;
     C = other.C;
     b = other.b;
@@ -13,29 +12,24 @@ FracturedMatrix &FracturedMatrix::operator=(const FracturedMatrix &other)
     return *this;
 }
 
-DestroyMatrix disassembleGeneralMatrix(Matrix &generalMatrix)
+DestroyMatrix disassembleGeneralMatrix(Matrix& generalMatrix) {
-{
     int rows = generalMatrix.getRows();
     int cols = generalMatrix.getColumns();
 
     Matrix A(rows - 1, cols - 1);
     Vector C(cols - 1);
-    Vector b(rows);
+    Vector b(rows - 1);
 
-    for (int j = 0; j < cols - 1; ++j)
+    for (int j = 0; j < cols - 1; ++j) {
-    {
         C[j] = generalMatrix[0][j];
     }
 
-    for (int i = 0; i < rows; ++i)
+    for (int i = 1; i < rows; ++i) {
-    {
+        b[i - 1] = generalMatrix[i - 1][cols - 1];
-        b[i] = generalMatrix[i][cols - 1];
     }
 
-    for (int i = 1; i < rows; ++i)
+    for (int i = 1; i < rows; ++i) {
-    {
+        for (int j = 0; j < cols - 1; ++j) {
-        for (int j = 0; j < cols - 1; ++j)
-        {
             A[i - 1][j] = generalMatrix[i][j];
         }
     }
@@ -43,76 +37,46 @@ DestroyMatrix disassembleGeneralMatrix(Matrix &generalMatrix)
     return {A, C, b};
 }
 
-Matrix createGeneralMatrix(Matrix &A, Vector &C, Vector &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++) {
-    int m = A.getRows() + 1;
+        generalMatrix[0][i] = C[i];
-    int n = A.getColumns() + A.getRows() + 1;
-    Matrix generalMatrix(m, n);
-
-    for (int i = 0; i < n; i++)
-    {
-        if (i < C.size())
-        {
-            generalMatrix[0][i] = C[i];
-        }
-        else
-        {
-            generalMatrix[0][i] = 0;
-        }
     }
 
-    // For objective function (j=0) the value is set to zero one step before
+    // For objective function (j=0) the value is set to zero automatically
-    for (int j = 1; j < m; j++)
+    for (int j = 1; j < A.getRows() + 1; j++) {
-    {
+        generalMatrix[j][A.getColumns()] = b[j-1];
-        generalMatrix[j][n - 1] = b[j - 1];
     }
 
-    int k = 0;
+    for (int i = 0; i < A.getRows(); i++) {
-    for (int i = 0; i < m - 1; i++)
+        for (int j = 0; j < A.getColumns(); j++) {
-    {
+            generalMatrix[i + 1][j] = A[i][j];
-        for (int j = 0; j < n - 1; j++)
-        {
-            if (j < A.getColumns())
-            {
-                generalMatrix[i + 1][j] = A[i][j];
-            }
-            else
-            {
-                generalMatrix[i + 1][j] = 0;
-            }
         }
-
-        generalMatrix[i + 1][A.getColumns() + k] = 1;
-        ++k;
     }
 
     return generalMatrix;
 }
 
-void elimination(Matrix &generalMatrix, int pivot_row_index, int pivot_column_index)
+void elimination(Matrix& generalMatrix, int pivot_row_index, int pivot_column_index) {
-{
 
     int rows = generalMatrix.getRows();
     int cols = generalMatrix.getColumns();
 
     double pivotElement = generalMatrix[pivot_row_index][pivot_column_index];
 
-    for (int j = 0; j < cols; ++j)
+    for (int j = 0; j < cols; ++j) {
-    {
         generalMatrix[pivot_row_index][j] /= pivotElement;
     }
 
-    for (int i = 0; i < rows; ++i)
+    for (int i = 0; i < rows; ++i) {
-    {
         if (i == pivot_row_index) 
             continue;
 
         double pivotColumnCoefficient = generalMatrix[i][pivot_column_index];
 
-        for (int j = 0; j < cols; ++j)
+        for (int j = 0; j < cols; ++j) {
-        {
             generalMatrix[i][j] -= pivotColumnCoefficient * generalMatrix[pivot_row_index][j];
         }
     }
 }
+

tools/elimination.h

@@ -3,28 +3,28 @@
 
 #include "matrix.h"
 
-struct FracturedMatrix
+
-{
+struct FracturedMatrix {
 	Matrix A;
 	Vector C;
 	Vector b;
 	int pivot_column_index;
 	int pivot_row_index;
 	FracturedMatrix() = default;
-	FracturedMatrix(const FracturedMatrix &other);
+	FracturedMatrix(const FracturedMatrix& other);
 	FracturedMatrix(Matrix A, Vector C, Vector b, int pivot_column_index, int pivot_row_index);
-	FracturedMatrix &operator=(const FracturedMatrix &other);
+	FracturedMatrix& operator=(const FracturedMatrix& other);
 };
 
-struct DestroyMatrix
+struct DestroyMatrix {
-{
+    Matrix A;
-	Matrix A;
+    Vector C;
-	Vector C;
+    Vector b;
-	Vector b;
 };
 
-DestroyMatrix disassembleGeneralMatrix(Matrix &generalMatrix);
+DestroyMatrix disassembleGeneralMatrix(Matrix& generalMatrix);
-void elimination(Matrix &, int pivot_row_index, int pivot_column_index);
+void elimination(Matrix&, int pivot_row_index, int pivot_column_index);
-Matrix createGeneralMatrix(Matrix &A, Vector &C, Vector &b);
+Matrix createGeneralMatrix(Matrix& A, Vector& C, Vector& b);
 
-#endif // ELIMINATION_H
+
+#endif //ELIMINATION_H

tools/math.cpp

@@ -1,50 +1,38 @@
 #include "math.h"
 
-double min(Vector vector)
+double min(Vector vector) {
-{
     double temp = vector[0];
-    for (int j = 0; j < vector.size(); j++)
+    for (int j = 0; j < vector.size(); j++) {
-    {
+        if (vector[j] < temp) {
-        if (vector[j] < temp)
-        {
             temp = vector[j];
         }
     }
     return temp;
 }
 
-double max(Vector vector)
+double max(Vector vector) {
-{
     double temp = vector[0];
-    for (int j = 0; j < vector.size(); j++)
+    for (int j = 0; j < vector.size(); j++) {
-    {
+        if (vector[j] > temp) {
-        if (vector[j] > temp)
-        {
             temp = vector[j];
         }
     }
     return temp;
 }
 
-int min_index_positive(Vector vector)
+int min_index_positive(Vector vector) {
-{
     int i = 0;
-    while (i < vector.size() && vector[i] <= 0)
+    while (i < vector.size() && vector[i] <= 0) {
-    {
         ++i;
     }
-    if (i >= vector.size())
+    if (i >= vector.size()) {
-    {
+        throw std::runtime_error("No positive min found");
-        // No positive value found -> iterations stop
-        return -1;
     }
     int temp_index = i;
     double temp = vector[i];
 
-    for (int j = i + 1; j < vector.size(); j++)
+    for (int j = i + 1; j < vector.size(); j++) {
-    {
+        if (vector[j] < temp && vector[j] > 0) {
-        if (vector[j] < temp && vector[j] > 0)
-        {
             temp_index = j;
             temp = vector[j];
         }
@@ -52,14 +40,11 @@ int min_index_positive(Vector vector)
     return temp_index;
 }
 
-int min_index(Vector vector)
+int min_index(Vector vector) {
-{
     int temp_index = 0;
     double temp = vector[0];
-    for (int j = 0; j < vector.size(); j++)
+    for (int j = 0; j < vector.size(); j++) {
-    {
+        if (vector[j] < temp) {
-        if (vector[j] < temp)
-        {
             temp_index = j;
             temp = vector[j];
         }
@@ -67,14 +52,11 @@ int min_index(Vector vector)
     return temp_index;
 }
 
-int max_index(Vector vector)
+int max_index(Vector vector) {
-{
     int temp_index = 0;
     double temp = vector[0];
-    for (int j = 0; j < vector.size(); j++)
+    for (int j = 0; j < vector.size(); j++) {
-    {
+        if (vector[j] > temp) {
-        if (vector[j] > temp)
-        {
             temp_index = j;
             temp = vector[j];
         }
@@ -82,40 +64,31 @@ int max_index(Vector vector)
     return temp_index;
 }
 
-double min(std::vector<double> array)
+double min(std::vector<double> array) {
-{
     double temp = array[0];
-    for (size_t i = 1; i < array.size(); i++)
+    for (size_t i = 1; i < array.size(); i++) {
-    {
+        if (array[i] < temp) {
-        if (array[i] < temp)
-        {
             temp = array[i];
         }
     }
     return temp;
 }
 
-double max(std::vector<double> array)
+double max(std::vector<double> array) {
-{
     double temp = array[0];
-    for (size_t i = 1; i < array.size(); i++)
+    for (size_t i = 1; i < array.size(); i++) {
-    {
+        if (array[i] > temp) {
-        if (array[i] > temp)
-        {
             temp = array[i];
         }
     }
     return temp;
 }
 
-int min_index(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++)
+    for (size_t i = 1; i < array.size(); i++) {
-    {
+        if (array[i] < temp) {
-        if (array[i] < temp)
-        {
             temp_index = i;
             temp = array[i];
         }
@@ -123,14 +96,12 @@ int min_index(std::vector<double> array)
     return temp_index;
 }
 
-int max_index(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++)
+    for (size_t i = 1; i < array.size(); i++) {
-    {
+        if (array[i] > temp) {
-        if (array[i] > temp)
-        {
             temp_index = i;
             temp = array[i];
         }

tools/matrix.cpp

@@ -1,175 +1,184 @@
 #include "matrix.h"
 
-Vector::Vector(int n)
+void showMatrix(Matrix matrix) {
-{
+  int maxNumberLength = 1;
+  for (size_t y = 0; y < matrix.getRows(); y++) {
+    for (size_t x = 0; x < matrix.getColumns(); x++) {
+      if (std::to_string(matrix[y][x]).length() > maxNumberLength) {
+        maxNumberLength = std::to_string(matrix[y][x]).length();
+      }
+    }
+  }
+  //std::cout << maxNumberLength << std::endl;
+  std::cout << std::endl;
+  for (size_t y = 0; y < matrix.getRows(); y++) {
+    std::string row = "";
+    for (size_t x = 0; x < matrix.getColumns(); x++) {
+      std::string strNumber = std::to_string(matrix[y][x]);
+      bool spaceRight = true;
+      while (strNumber.length() < maxNumberLength) {
+        if (spaceRight) {
+          strNumber += " ";
+        }
+        else {
+          strNumber = " " + strNumber;
+        }
+        spaceRight = !spaceRight;
+        strNumber = "" + strNumber;
+
+      }
+      if (matrix[y][x] == 0) {
+        row += "[\033[0m" + strNumber + "\033[0m] ";
+      }
+      else if(matrix[y][x] > 0) {
+        row += "[\033[32m" + strNumber + "\033[0m] ";
+      }else {
+        row += "[\033[31m" + strNumber + "\033[0m] ";
+      }
+
+    }
+    std::cout << row << std::endl;
+  }
+  std::cout << std::endl;
+}
+
+Vector::Vector(int n) {
   rows = n;
   columns = 1;
   vector.resize(n);
 }
 
-Vector::Vector(const Vector &other)
+Vector::Vector(const Vector& other) {
-{
   rows = other.rows;
   columns = other.columns;
   vector = other.vector;
 }
 
-Vector::Vector(std::initializer_list<double> init)
+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)
+  for (size_t i = 0; i < init.size(); ++i) {
-  {
     vector[i] = *it++;
   }
 }
 
-int Vector::size() const
+int Vector::size() const {
-{
   return rows;
 }
 
-double &Vector::operator[](int row)
+double& Vector::operator[](int row) {
-{
   return vector[row];
 }
 
-Vector &Vector::operator=(const Vector &other)
+Vector& Vector::operator=(const Vector& other) {
-{
   rows = other.rows;
   columns = other.columns;
   vector = other.vector;
   return *this;
 }
 
-Vector Vector::operator+(Vector &other)
+Vector Vector::operator+(Vector& other) {
-{
+  if (rows != other.rows) {
-  if (rows != other.rows)
-  {
     throw std::runtime_error("Error: the dimensional problem occurred");
   }
   Vector result(rows);
-  for (int i = 0; i < rows; ++i)
+  for (int i = 0; i < rows; ++i) {
-  {
     result[i] = vector[i] + other[i];
   }
 
   return result;
 }
 
-Vector Vector::operator-(Vector &other)
+Vector Vector::operator-(Vector& other) {
-{
+  if (rows != other.rows) {
-  if (rows != other.rows)
-  {
     throw std::runtime_error("Error: the dimensional problem occurred");
   }
   Vector result(rows);
-  for (int i = 0; i < rows; ++i)
+  for (int i = 0; i < rows; ++i) {
-  {
     result[i] = vector[i] - other[i];
   }
 
   return result;
 }
 
-std::istream &operator>>(std::istream &cin, Vector &vectorObj)
+std::istream& operator>>(std::istream& cin, Vector& vectorObj) {
-{
+  for (int i = 0; i < vectorObj.rows; ++i) {
-  for (int i = 0; i < vectorObj.rows; ++i)
-  {
     cin >> vectorObj[i];
   }
   return cin;
 }
 
-std::ostream &operator<<(std::ostream &cout, Vector &vectorObj)
+std::ostream& operator<<(std::ostream& cout, Vector& vectorObj) {
-{
+  for (int i = 0; i < vectorObj.rows; ++i) {
-  for (int i = 0; i < vectorObj.rows; ++i)
+    if (i == vectorObj.rows - 1) {
-  {
-    if (i == vectorObj.rows - 1)
-    {
       cout << vectorObj[i] << std::endl;
     }
-    else
+    else {
-    {
       cout << vectorObj[i] << ' ';
     }
   }
   return cout;
 }
 
-Matrix::Matrix(int n, int m)
+Matrix::Matrix(int n, int m) {
-{
   rows = n;
   columns = m;
   matrix.resize(n, Vector(m));
-  for (auto &row : matrix)
+  for (auto& row : matrix) {
-  {
     row = Vector(m);
   }
 }
 
-Matrix::Matrix(const Matrix &other)
+Matrix::Matrix(const Matrix& other) {
-{
   rows = other.rows;
   columns = other.columns;
   matrix = other.matrix;
 }
 
-Matrix::Matrix(std::initializer_list<std::vector<double>> init)
+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 i = 0; i < rows; ++i) {
-  {
+    for (int j = 0; j < columns; ++j) {
-    for (int j = 0; j < columns; ++j)
-    {
       matrix[i][j] = it->operator[](j);
     }
     ++it;
   }
 }
 
-int Matrix::getRows() const
+int Matrix::getRows() const {
-{
   return rows;
 }
 
-int Matrix::getColumns() const
+int Matrix::getColumns() const {
-{
   return columns;
 }
 
-Vector &Matrix::operator[](int row)
+Vector& Matrix::operator[](int row) {
-{
   return matrix[row];
 }
 
-Matrix &Matrix::operator=(const Matrix &other)
+Matrix& Matrix::operator=(const Matrix& other) {
-{
   rows = other.rows;
   columns = other.columns;
   matrix = other.matrix;
   return *this;
 }
 
-Matrix Matrix::operator+(Matrix &other) const
+Matrix Matrix::operator+(Matrix& other) const {
-{
+  if (rows != other.rows || columns != other.columns) {
-  if (rows != other.rows || columns != other.columns)
-  {
     throw std::runtime_error("Error: the dimensional problem occurred");
   }
   Matrix result(rows, columns);
-  for (int i = 0; i < rows; ++i)
+  for (int i = 0; i < rows; ++i) {
-  {
+    for (int j = 0; j < columns; ++j) {
-    for (int j = 0; j < columns; ++j)
-    {
       auto x = matrix[i];
       auto y = other[i];
       result[i][j] = x[j] + y[j];
@@ -179,17 +188,13 @@ Matrix Matrix::operator+(Matrix &other) const
   return result;
 }
 
-Matrix Matrix::operator-(Matrix &other) const
+Matrix Matrix::operator-(Matrix& other) const {
-{
+  if (rows != other.rows || columns != other.columns) {
-  if (rows != other.rows || columns != other.columns)
-  {
     throw std::runtime_error("Error: the dimensional problem occurred");
   }
   Matrix result(rows, columns);
-  for (int i = 0; i < rows; ++i)
+  for (int i = 0; i < rows; ++i) {
-  {
+    for (int j = 0; j < columns; ++j) {
-    for (int j = 0; j < columns; ++j)
-    {
       auto x = matrix[i];
       auto y = other[i];
       result[i][j] = x[j] - y[j];
@@ -199,21 +204,16 @@ Matrix Matrix::operator-(Matrix &other) const
   return result;
 }
 
-Matrix Matrix::operator*(Matrix &other) const
+Matrix Matrix::operator*(Matrix& other) const {
-{
+  if (columns != other.rows) {
-  if (columns != other.rows)
-  {
     throw std::runtime_error("Error: the dimensional problem occurred");
   }
 
   Matrix result(rows, other.columns);
-  for (int i = 0; i < rows; ++i)
+  for (int i = 0; i < rows; ++i) {
-  {
+    for (int j = 0; j < other.columns; ++j) {
-    for (int j = 0; j < other.columns; ++j)
-    {
       result[i][j] = 0;
-      for (int k = 0; k < columns; ++k)
+      for (int k = 0; k < columns; ++k) {
-      {
         auto x = matrix[i];
         auto y = other[k];
         result[i][j] += x[k] * y[j];
@@ -224,19 +224,15 @@ Matrix Matrix::operator*(Matrix &other) const
   return result;
 }
 
-Vector Matrix::operator*(Vector other) const
+Vector Matrix::operator*(Vector other) const {
-{
+  if (columns != other.size()) {
-  if (columns != other.size())
-  {
     throw std::runtime_error("Error: the dimensional problem occurred");
   }
 
   Vector result(rows);
-  for (int i = 0; i < rows; ++i)
+  for (int i = 0; i < rows; ++i) {
-  {
     result[i] = 0;
-    for (int k = 0; k < columns; ++k)
+    for (int k = 0; k < columns; ++k) {
-    {
       auto x = matrix[i];
       result[i] += x[k] * other[k];
     }
@@ -245,13 +241,10 @@ Vector Matrix::operator*(Vector other) const
   return result;
 }
 
-Matrix Matrix::transpose() const
+Matrix Matrix::transpose() const {
-{
   Matrix result(columns, rows);
-  for (int i = 0; i < rows; ++i)
+  for (int i = 0; i < rows; ++i) {
-  {
+    for (int j = 0; j < columns; ++j) {
-    for (int j = 0; j < columns; ++j)
-    {
       auto x = matrix[i];
       result[j][i] = x[j];
     }
@@ -260,69 +253,25 @@ Matrix Matrix::transpose() const
   return result;
 }
 
-std::istream &operator>>(std::istream &cin, Matrix &matrixObj)
+std::istream& operator>>(std::istream& cin, Matrix& matrixObj) {
-{
+  for (int i = 0; i < matrixObj.rows; ++i) {
-  for (int i = 0; i < matrixObj.rows; ++i)
+    for (int j = 0; j < matrixObj.columns; ++j) {
-  {
-    for (int j = 0; j < matrixObj.columns; ++j)
-    {
       cin >> matrixObj[i][j];
     }
   }
   return cin;
 }
 
-std::ostream &operator<<(std::ostream &cout, Matrix &matrixObj)
+std::ostream& operator<<(std::ostream& cout, Matrix& matrixObj) {
-{
+  for (int i = 0; i < matrixObj.rows; ++i) {
-  size_t maxNumberLength = 1;
+    for (int j = 0; j < matrixObj.columns; ++j) {
-  for (int y = 0; y < matrixObj.getRows(); y++)
+      if (j == matrixObj.columns - 1) {
-  {
+        cout << matrixObj[i][j] << std::endl;
-    for (int x = 0; x < matrixObj.getColumns(); x++)
+      }
-    {
+      else {
-      if (std::to_string(matrixObj[y][x]).length() > maxNumberLength)
+        cout << matrixObj[i][j] << ' ';
-      {
-        maxNumberLength = std::to_string(matrixObj[y][x]).length();
       }
     }
   }
-  // std::cout << maxNumberLength << std::endl;
-  std::cout << std::endl;
-  for (int y = 0; y < matrixObj.getRows(); y++)
-  {
-    std::string row = "";
-    for (int x = 0; x < matrixObj.getColumns(); x++)
-    {
-      std::string strNumber = std::to_string(matrixObj[y][x]);
-      bool spaceRight = true;
-      while (strNumber.length() < maxNumberLength)
-      {
-        if (spaceRight)
-        {
-          strNumber += " ";
-        }
-        else
-        {
-          strNumber = " " + strNumber;
-        }
-        spaceRight = !spaceRight;
-        strNumber = "" + strNumber;
-      }
-      if (matrixObj[y][x] == 0)
-      {
-        row += "[\033[0m" + strNumber + "\033[0m] ";
-      }
-      else if (matrixObj[y][x] > 0)
-      {
-        row += "[\033[32m" + strNumber + "\033[0m] ";
-      }
-      else
-      {
-        row += "[\033[31m" + strNumber + "\033[0m] ";
-      }
-    }
-    std::cout << row << std::endl;
-  }
-  std::cout << std::endl;
-
   return cout;
 }

tools/matrix.h

@@ -6,12 +6,12 @@
 #include <vector>
 
 /**
- * Vector is a class to represent
+* Vector is a class to represent
- * a column vector with n rows.
+* a column vector with n rows.
- */
+*/
 
-class Vector
+
-{
+class Vector {
 protected:
 	// Number of rows in vector
 	int rows;
@@ -19,41 +19,39 @@ protected:
 	int columns;
 	// Matrix representation as vector of vectors of integers
 	std::vector<double> vector;
-
 public:
 	Vector(int n);
 
-	Vector(const Vector &other);
+	Vector(const Vector& other);
 
 	Vector(std::initializer_list<double>);
 
 	/* Getter for the number of rows */
 	int size() const;
 
-	double &operator[](int row);
+	double& operator[](int row);
 
-	Vector &operator=(const Vector &other);
+	Vector& operator=(const Vector& other);
 
-	Vector operator+(Vector &other);
+	Vector operator+(Vector& other);
 
-	Vector operator-(Vector &other);
+	Vector operator-(Vector& other);
 
 	/* Input operator reads element of vector */
-	friend std::istream &operator>>(std::istream &cin, Vector &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)
+	* in a row separated with a space (no space at the end of the line)
-	 */
+	*/
-	friend std::ostream &operator<<(std::ostream &cout, Vector &vectorObj);
+	friend std::ostream& operator<<(std::ostream& cout, Vector& vectorObj);
 };
 
 /**
- * Class Matrix represents
+* Class Matrix represents
- * a matrix of size n x m
+* a matrix of size n x m
- * of type integer.
+* of type integer.
- */
+*/
-class Matrix
+class Matrix {
-{
 protected:
 	// Number of rows in matrix
 	int rows;
@@ -61,11 +59,10 @@ protected:
 	int columns;
 	// Matrix representation as vector of vectors of integers
 	std::vector<Vector> matrix;
-
 public:
 	Matrix(int n, int m);
 
-	Matrix(const Matrix &other);
+	Matrix(const Matrix& other);
 
 	Matrix(std::initializer_list<std::vector<double>>);
 
@@ -75,15 +72,15 @@ public:
 	/* Getter for the number of columns */
 	int getColumns() const;
 
-	Vector &operator[](int row);
+	Vector& operator[](int row);
 
-	Matrix &operator=(const Matrix &other);
+	Matrix& operator=(const Matrix& other);
 
-	Matrix operator+(Matrix &other) const;
+	Matrix operator+(Matrix& other) const;
 
-	Matrix operator-(Matrix &other) const;
+	Matrix operator-(Matrix& other) const;
 
-	Matrix operator*(Matrix &other) const;
+	Matrix operator*(Matrix& other) const;
 
 	/* Matrix-Vector multiplication */
 	Vector operator*(Vector other) const;
@@ -92,12 +89,14 @@ public:
 	Matrix transpose() const;
 
 	/* Input operator reads element of matrix row by row */
-	friend std::istream &operator>>(std::istream &cin, Matrix &matrixObj);
+	friend std::istream& operator>>(std::istream& cin, Matrix& matrixObj);
 
 	/* Output operator prints elements of the matrix
-	 * row by row separated with a space (no space at the end of each line)
+	* row by row separated with a space (no space at the end of each line)
-	 */
+	*/
-	friend std::ostream &operator<<(std::ostream &cout, Matrix &matrixObj);
+	friend std::ostream& operator<<(std::ostream& cout, Matrix& matrixObj);
 };
 
-#endif // TOOLS_MATRIX_H
+void showMatrix(Matrix);
+
+#endif  // TOOLS_MATRIX_H