From deefbf9682f0884145d9e12021ffc1a7c329817b Mon Sep 17 00:00:00 2001
From: Persson-dev <sim16.prib@gmail.com>
Date: Fri, 2 Feb 2024 11:11:27 +0100
Subject: [PATCH] it works lol

---
 src/main.cpp | 302 ++++++++++++++++++++++++++-------------------------
 1 file changed, 157 insertions(+), 145 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index fd295bc..0290855 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,166 +1,178 @@
+#include <algorithm>
+#include <cmath>
 #include <iostream>
 #include <vector>
-#include <algorithm>
 
 template <typename T>
-class Matrix
-{
-private:
-    std::size_t m_Lignes;
-    std::size_t m_Colonnes;
-    std::size_t m_Dimension;
-    std::vector<T> m_Data;
+static bool EqualZero(T var) {
+	return std::abs(var) < std::pow(10, -17);
+}
 
-public:
-    Matrix(std::size_t lignes, std::size_t colonnes) : m_Lignes(lignes), m_Colonnes(colonnes), m_Dimension(lignes * colonnes)
-    {
-        m_Data.resize(m_Dimension);
-    }
-    ~Matrix() {}
+template <typename T>
+class Matrix {
+  private:
+	std::size_t m_Lignes;
+	std::size_t m_Colonnes;
+	std::size_t m_Dimension;
+	std::vector<T> m_Data;
 
-    void Print() const
-    {
-        for (size_t i = 0; i < m_Lignes; ++i)
-        {
-            std::cout << "[ ";
-            for (size_t j = 0; j < m_Colonnes; ++j)
-            {
-                std::size_t indice = i * m_Lignes + j;
-                std::cout << at(i, j) << " ";
-            }
-            std::cout << "]";
-            std::cout << std::endl;
-        }
-    }
-    void Insert()
-    {
-        for (size_t i = 0; i < m_Lignes; ++i)
-        {
-            for (size_t j = 0; j < m_Colonnes; ++j)
-            {
-                std::cin >> at(i, j);
-            }
-            std::cout << std::endl;
-        }
-    }
+  public:
+	Matrix(std::size_t lignes, std::size_t colonnes) : m_Lignes(lignes), m_Colonnes(colonnes), m_Dimension(lignes * colonnes) {
+		m_Data.resize(m_Dimension);
+	}
+	~Matrix() {}
 
-    /*
-    void DivideLine(T div, std::size_t line){
-        for (size_t i = 0; i < count; i++)
-        {
-            
-        }
-        
-    }
-    */
+	void Print() const {
+		for (size_t i = 0; i < m_Lignes; ++i) {
+			std::cout << "[ ";
+			for (size_t j = 0; j < m_Colonnes; ++j) {
+				std::size_t indice = i * m_Lignes + j;
+				std::cout << at(i, j) << " ";
+			}
+			std::cout << "]";
+			std::cout << std::endl;
+		}
+	}
 
-    void GaussJordan()
-    {
-        int r = -1;
-        for (std::size_t j = 0; j < m_Colonnes; ++j)
-        {
-            std::size_t k = 0;
-            // Rechercher
-            for (std::size_t i = r + 1; i < m_Lignes; ++i)
-            {
-                if (at(i, j) > at(k, j))
-                {
-                    k = i;
-                }
-            }
-            Matrix<float> mat_pivot(1, 1);
-            mat_pivot.at(0, 0) = at(k, j);
-            if (at(k, j) != 0)
-            {
-                ++r;
-                // Diviser
-                for (std::size_t z = 0; z < m_Colonnes; ++z)
-                {
-                    at(k, z) /= mat_pivot.at(0, 0);
-                }
-                if (k != r)
-                {
-                    // Echanger
-                    for (std::size_t z = 0; z < m_Colonnes; ++z)
-                    {
-                        std::swap(at(k, z), at(r, z));
-                    }
-                }
-                for (std::size_t i = 0; i < m_Lignes; ++i)
-                {
-                    if (i != r)
-                    {
-                        //Soustraire
-                        for (std::size_t z = 0; z < m_Colonnes; ++z)
-                        {
-                            at(i, z) -= at(r, z) * at(i, j);
-                        }
-                    }
-                }
-            }
-        }
-    }
+	void PrintDebug() {
+#ifndef NDEBUG
+		Print();
+		std::cout << "\n";
+#endif
+	}
 
-    T &operator[](std::size_t indice)
-    {
-        return at(indice);
-    }
+	void Insert() {
+		for (size_t i = 0; i < m_Lignes; ++i) {
+			for (size_t j = 0; j < m_Colonnes; ++j) {
+				std::cin >> at(i, j);
+			}
+			std::cout << std::endl;
+		}
+	}
 
-    T &at(std::size_t ligne, std::size_t colonne)
-    {
-        return m_Data[ligne * m_Lignes + colonne];
-    }
+	/*
+	void DivideLine(T div, std::size_t line){
+		for (size_t i = 0; i < count; i++)
+		{
 
-    T at(std::size_t ligne, std::size_t colonne) const
-    {
-        return m_Data[ligne * m_Lignes + colonne];
-    }
+		}
 
-    /*std::vector<T>::iterator begin() {
-        return m_Data.begin();
-    }
+	}
+	*/
 
-    std::vector<T>::iterator end() {
-        return m_Data.end();
-    }*/
+	void GaussJordan() {
+		int r = -1;
+		for (std::size_t j = 0; j < m_Colonnes; j++) {
+			std::size_t indice_ligne_maximum = r + 1;
+
+			// Recherche maximum
+			for (std::size_t i = r + 1; i < m_Lignes; i++) {
+				if (std::abs(at(i, j)) > std::abs(at(indice_ligne_maximum, j)))
+					indice_ligne_maximum = i;
+			}
+
+			std::cout << "l'indice du maximum est : " << indice_ligne_maximum << "\n\n";
+
+			// Si A[k,j]≠0 alors    (A[k,j] désigne la valeur de la ligne k et de la colonne j)
+			if (!EqualZero(at(indice_ligne_maximum, j))) {
+				r++;
+
+				std::cout << "On divise la ligne " << indice_ligne_maximum << " par " << at(indice_ligne_maximum, j) << "\n";
+				// Diviser la ligne k par A[k,j]  (On normalise la ligne de pivot de façon que le
+				// pivot prenne la valeur 1)
+				for (int l = m_Colonnes - 1; l >= 0; l--) {
+					at(indice_ligne_maximum, l) /= at(indice_ligne_maximum, j);
+				}
+
+				PrintDebug();
+
+				// Si k≠r alors
+				if (indice_ligne_maximum != r) {
+					// Échanger les lignes k et r  (On place la ligne du pivot en position r)
+					std::cout << "On échange les lignes " << indice_ligne_maximum << " et " << r << '\n';
+					for (std::size_t k = 0; k < m_Colonnes; k++) {
+						std::swap(at(indice_ligne_maximum, k), at(r, k));
+					}
+				}
+
+				PrintDebug();
+
+				// Pour i de 1 jusqu'à n               (On simplifie les autres lignes)
+				for (std::size_t i = 0; i < m_Lignes; i++) {
+					// Si i≠r alors
+					if (i != r) {
+						// Soustraire à la ligne i la ligne r multipliée par A[i,j] (de façon à
+						// annuler A[i,j])
+						std::cout << "On soustrait à la ligne " << i << " la ligne " << r << " multipliée par " << at(i, j) << "\n";
+						for (int k = m_Colonnes - 1; k >= 0; k--) {
+							at(i, k) -= at(r, k) * at(i, j);
+							std::cout << "On soustrait à (" << i << "," << k << ")  ,  [ (" << r << "," << k << ") = " << at(r, k)
+									  << " ] * [ (" << i << "," << j << ") = " << at(i, j) << " ]\n";
+							PrintDebug();
+						}
+					}
+				}
+			}
+		}
+	}
+
+	T& operator[](std::size_t indice) {
+		return at(indice);
+	}
+
+	T& at(std::size_t ligne, std::size_t colonne) {
+		return m_Data[ligne * m_Lignes + colonne];
+	}
+
+	T at(std::size_t ligne, std::size_t colonne) const {
+		return m_Data[ligne * m_Lignes + colonne];
+	}
+
+	/*std::vector<T>::iterator begin() {
+		return m_Data.begin();
+	}
+
+	std::vector<T>::iterator end() {
+		return m_Data.end();
+	}*/
 };
 
-/*
-void test()
-{
-    Matrix<float> mat(2, 2);
-    mat.at(0, 0) = 4;
-    mat.at(0, 1) = 3;
-    mat.at(1, 0) = 2;
-    mat.at(1, 1) = 1;
+void test() {
+	Matrix<float> mat(3, 3);
+	mat.at(0, 0) = mat.at(2, 0) = 1;
+	mat.at(0, 1) = mat.at(2, 1) = 2;
+	mat.at(0, 2) = mat.at(2, 2) = 3;
 
-    mat.Print();
-    mat.GaussJordan();
-    mat.Print();
+	mat.at(1, 0) = 4;
+	mat.at(1, 1) = 5;
+	mat.at(1, 2) = 6;
+
+	mat.Print();
+	mat.GaussJordan();
+	std::cout << "\nResultat :\n";
+	mat.Print();
 }
-*/
 
-int main(int argc, char **argv)
-{
-    //test();
-    
-    std::cout << "hello world!" << std::endl;
-    std::cout << "Quelle est le nombre de lignes de votre matrice ?" << std::endl;
-    std::size_t lignes;
-    std::cin >> lignes;
-    std::cout << "Quelle est le nombre de colonnes de votre matrice ?" << std::endl;
-    std::size_t colonnes;
-    std::cin >> colonnes;
-    std::size_t dimension = lignes * colonnes;
-    std::cout << "Rentrez les coefficients de la matrice" << std::endl;
-    Matrix<float> mat(lignes, colonnes);
+int main(int argc, char** argv) {
+	test();
 
-    mat.Insert();
+	std::cout << "hello world!" << std::endl;
+	std::cout << "Quelle est le nombre de lignes de votre matrice ?" << std::endl;
+	std::size_t lignes;
+	std::cin >> lignes;
+	std::cout << "Quelle est le nombre de colonnes de votre matrice ?" << std::endl;
+	std::size_t colonnes;
+	std::cin >> colonnes;
+	std::size_t dimension = lignes * colonnes;
+	std::cout << "Rentrez les coefficients de la matrice" << std::endl;
+	Matrix<float> mat(lignes, colonnes);
 
-    mat.Print();
-    mat.GaussJordan();
-    std::cout << std::endl;
-    mat.Print();
-    
-    return 0;
+	mat.Insert();
+
+	mat.Print();
+	mat.GaussJordan();
+	std::cout << std::endl;
+	mat.Print();
+
+	return 0;
 }