caca

.vscode/c_cpp_properties.json

@@ -3,7 +3,8 @@
         {
             "name": "Pivot",
             "cppStandard": "c++20",
-            "includePath": ["include"]
+            "includePath": ["include"],
+            "compileCommands": "${workspaceFolder}/.vscode/compile_commands.json"
         }
     ],
     "version": 4

.vscode/launch.json

@@ -7,8 +7,8 @@
         {
             "type": "xmake",
             "request": "launch",
-            "name": "Debug XMake target",
+            "name": "Debug random kernel",
-            "target": "Pivot",
+            "target": "test_random_kernel",
             "cwd": "${workspaceFolder}/matricies",
         }
     ]

.vscode/settings.json

@@ -44,6 +44,23 @@
         "stdexcept": "cpp",
         "streambuf": "cpp",
         "cinttypes": "cpp",
-        "typeinfo": "cpp"
+        "typeinfo": "cpp",
+        "codecvt": "cpp",
+        "condition_variable": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "ratio": "cpp",
+        "fstream": "cpp",
+        "future": "cpp",
+        "iomanip": "cpp",
+        "mutex": "cpp",
+        "semaphore": "cpp",
+        "sstream": "cpp",
+        "stop_token": "cpp",
+        "thread": "cpp",
+        "chrono": "cpp",
+        "optional": "cpp",
+        "ranges": "cpp",
+        "span": "cpp"
     }
 }

imgui.ini

@@ -0,0 +1,16 @@
+[Window][Debug##Default]
+Pos=60,60
+Size=400,400
+
+[Window][Right Top Window]
+Pos=640,0
+Size=640,576
+
+[Window][Bottom Part]
+Pos=0,576
+Size=1280,144
+
+[Window][Left Top Window]
+Pos=0,0
+Size=640,576
+

include/Matrix.h

@@ -10,6 +10,8 @@
 #include <string>
 #include <vector>
 
+#include "NR.h"
+
 /**
  * \class Matrix
  * \brief Représente une matrice d'éléments
@@ -154,6 +156,21 @@ class Matrix {
 };
 
 template <typename T>
-bool IsEqualZero(T var) {
+bool IsEqualZero(const T& var) {
 	return std::abs(var) < std::pow(10, -5);
 }
+
+template <>
+inline bool IsEqualZero(const int& var) {
+	return var == 0;
+}
+
+template <>
+inline bool IsEqualZero(const long& var) {
+	return var == 0;
+}
+
+template <>
+inline bool IsEqualZero(const NR& var) {
+	return var == 0;
+}

include/NR.h

@@ -3,17 +3,20 @@
 #include <iostream>
 
 class NR {
+  public:
+	using Int = long long;
+
   private:
-	int m_Numerator;
+	Int m_Numerator;
-	int m_Denominator;	// has to be > 0, sign is carried by the numerator
+	Int m_Denominator;	// has to be > 0, sign is carried by the numerator
 
   public:
 	NR();
-	NR(int entier);
+	NR(Int entier);
-	NR(int numerator, int denominator);	 // check if denominator != 0
+	NR(Int numerator, Int denominator);	 // check if denominator != 0
 
-	int GetNumerator() const;
+	Int GetNumerator() const;
-	int GetDenominator() const;
+	Int GetDenominator() const;
 
 	bool operator==(const NR& opNR) const;
 	bool operator<(const NR& opNR) const;
@@ -43,5 +46,3 @@ class NR {
   private:
 	void Reduce();
 };
-
-int PGCD(int x, int y);

matricies/plot.tex

@@ -0,0 +1,135 @@
+% GNUPLOT: LaTeX picture with Postscript
+\begingroup
+  \makeatletter
+  \providecommand\color[2][]{%
+    \GenericError{(gnuplot) \space\space\space\@spaces}{%
+      Package color not loaded in conjunction with
+      terminal option `colourtext'%
+    }{See the gnuplot documentation for explanation.%
+    }{Either use 'blacktext' in gnuplot or load the package
+      color.sty in LaTeX.}%
+    \renewcommand\color[2][]{}%
+  }%
+  \providecommand\includegraphics[2][]{%
+    \GenericError{(gnuplot) \space\space\space\@spaces}{%
+      Package graphicx or graphics not loaded%
+    }{See the gnuplot documentation for explanation.%
+    }{The gnuplot epslatex terminal needs graphicx.sty or graphics.sty.}%
+    \renewcommand\includegraphics[2][]{}%
+  }%
+  \providecommand\rotatebox[2]{#2}%
+  \@ifundefined{ifGPcolor}{%
+    \newif\ifGPcolor
+    \GPcolortrue
+  }{}%
+  \@ifundefined{ifGPblacktext}{%
+    \newif\ifGPblacktext
+    \GPblacktexttrue
+  }{}%
+  % define a \g@addto@macro without @ in the name:
+  \let\gplgaddtomacro\g@addto@macro
+  % define empty templates for all commands taking text:
+  \gdef\gplbacktext{}%
+  \gdef\gplfronttext{}%
+  \makeatother
+  \ifGPblacktext
+    % no textcolor at all
+    \def\colorrgb#1{}%
+    \def\colorgray#1{}%
+  \else
+    % gray or color?
+    \ifGPcolor
+      \def\colorrgb#1{\color[rgb]{#1}}%
+      \def\colorgray#1{\color[gray]{#1}}%
+      \expandafter\def\csname LTw\endcsname{\color{white}}%
+      \expandafter\def\csname LTb\endcsname{\color{black}}%
+      \expandafter\def\csname LTa\endcsname{\color{black}}%
+      \expandafter\def\csname LT0\endcsname{\color[rgb]{1,0,0}}%
+      \expandafter\def\csname LT1\endcsname{\color[rgb]{0,1,0}}%
+      \expandafter\def\csname LT2\endcsname{\color[rgb]{0,0,1}}%
+      \expandafter\def\csname LT3\endcsname{\color[rgb]{1,0,1}}%
+      \expandafter\def\csname LT4\endcsname{\color[rgb]{0,1,1}}%
+      \expandafter\def\csname LT5\endcsname{\color[rgb]{1,1,0}}%
+      \expandafter\def\csname LT6\endcsname{\color[rgb]{0,0,0}}%
+      \expandafter\def\csname LT7\endcsname{\color[rgb]{1,0.3,0}}%
+      \expandafter\def\csname LT8\endcsname{\color[rgb]{0.5,0.5,0.5}}%
+    \else
+      % gray
+      \def\colorrgb#1{\color{black}}%
+      \def\colorgray#1{\color[gray]{#1}}%
+      \expandafter\def\csname LTw\endcsname{\color{white}}%
+      \expandafter\def\csname LTb\endcsname{\color{black}}%
+      \expandafter\def\csname LTa\endcsname{\color{black}}%
+      \expandafter\def\csname LT0\endcsname{\color{black}}%
+      \expandafter\def\csname LT1\endcsname{\color{black}}%
+      \expandafter\def\csname LT2\endcsname{\color{black}}%
+      \expandafter\def\csname LT3\endcsname{\color{black}}%
+      \expandafter\def\csname LT4\endcsname{\color{black}}%
+      \expandafter\def\csname LT5\endcsname{\color{black}}%
+      \expandafter\def\csname LT6\endcsname{\color{black}}%
+      \expandafter\def\csname LT7\endcsname{\color{black}}%
+      \expandafter\def\csname LT8\endcsname{\color{black}}%
+    \fi
+  \fi
+    \setlength{\unitlength}{0.0500bp}%
+    \ifx\gptboxheight\undefined%
+      \newlength{\gptboxheight}%
+      \newlength{\gptboxwidth}%
+      \newsavebox{\gptboxtext}%
+    \fi%
+    \setlength{\fboxrule}{0.5pt}%
+    \setlength{\fboxsep}{1pt}%
+    \definecolor{tbcol}{rgb}{1,1,1}%
+\begin{picture}(7200.00,5040.00)%
+    \gplgaddtomacro\gplbacktext{%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(803,554){\makebox(0,0)[r]{\strut{}0}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(803,1141){\makebox(0,0)[r]{\strut{}0.05}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(803,1727){\makebox(0,0)[r]{\strut{}0.1}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(803,2314){\makebox(0,0)[r]{\strut{}0.15}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(803,2901){\makebox(0,0)[r]{\strut{}0.2}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(803,3488){\makebox(0,0)[r]{\strut{}0.25}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(803,4074){\makebox(0,0)[r]{\strut{}0.3}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(803,4661){\makebox(0,0)[r]{\strut{}0.35}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(935,334){\makebox(0,0){\strut{}0}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(1865,334){\makebox(0,0){\strut{}50}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(2795,334){\makebox(0,0){\strut{}100}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(3725,334){\makebox(0,0){\strut{}150}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(4655,334){\makebox(0,0){\strut{}200}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(5585,334){\makebox(0,0){\strut{}250}}%
+      \colorrgb{0.15,0.15,0.15}%%
+      \put(6515,334){\makebox(0,0){\strut{}300}}%
+    }%
+    \gplgaddtomacro\gplfronttext{%
+      \csname LTb\endcsname%%
+      \put(66,2607){\rotatebox{-270}{\makebox(0,0){\strut{}Temps d'exécution (s)}}}%
+      \put(3725,4){\makebox(0,0){\strut{}Taille des matrices}}%
+      \csname LTb\endcsname%%
+      \put(1922,4488){\makebox(0,0)[l]{\strut{}Echelonnage non réduit}}%
+      \csname LTb\endcsname%%
+      \put(1922,4268){\makebox(0,0)[l]{\strut{}Echelonnage réduit}}%
+      \csname LTb\endcsname%%
+      \put(1922,4048){\makebox(0,0)[l]{\strut{}Echelonnage non réduit normalisé}}%
+      \csname LTb\endcsname%%
+      \put(1922,3828){\makebox(0,0)[l]{\strut{}Echelonnage réduit normalisé}}%
+      \csname LTb\endcsname%%
+      \put(3725,4991){\makebox(0,0){/:Bold Echelonnage de matrices}}%
+    }%
+    \gplbacktext
+    \put(0,0){\includegraphics[width={360.00bp},height={252.00bp}]{plot}}%
+    \gplfronttext
+  \end{picture}%
+\endgroup

src/Gauss.cpp

@@ -16,6 +16,10 @@ static void SwapLines(Matrix& mat, std::size_t line1, std::size_t line2) {
 static void DivideLine(Matrix& mat, std::size_t line, Matrix::Element number) {
 	std::transform(std::execution::par_unseq, mat.GetLineIterator(line), mat.GetLineIterator(line + 1), mat.GetLineIterator(line),
 		[number](Matrix::Element e) { return e /= number; });
+
+	/*for (std::size_t i = 0; i < mat.GetColumnCount(); i++) {
+		mat.at(line, i) /= number;
+	}*/
 }
 
 static int FirstNotNullElementIndexOnColumn(Matrix& mat, std::size_t column, std::size_t startLine = 0) {
@@ -38,7 +42,7 @@ static void SimplifyLine(Matrix& mat, std::size_t line, std::size_t pivot_line,
 	});
 }
 
-static void GaussJordanReduced(Matrix& a_Matrix, bool a_Normalise) {
+static void GaussJordanReducedNorma(Matrix& a_Matrix) {
 	int indice_ligne_pivot = -1;
 
 	for (std::size_t j = 0; j < a_Matrix.GetColumnCount(); j++) {
@@ -56,9 +60,7 @@ static void GaussJordanReduced(Matrix& a_Matrix, bool a_Normalise) {
 
 		Matrix::Element pivot = a_Matrix.at(indice_ligne_pivot, j);
 
-		if (a_Normalise) {
 		DivideLine(a_Matrix, indice_ligne_pivot, pivot);
-		}
 
 		auto range = std::views::iota(static_cast<std::size_t>(0), a_Matrix.GetRawCount());
 
@@ -71,7 +73,7 @@ static void GaussJordanReduced(Matrix& a_Matrix, bool a_Normalise) {
 	}
 }
 
-static void GaussJordanTriangular(Matrix& a_Matrix, bool a_Normalise) {
+static void GaussJordanReduced(Matrix& a_Matrix) {
 	int indice_ligne_pivot = -1;
 
 	for (std::size_t j = 0; j < a_Matrix.GetColumnCount(); j++) {
@@ -89,25 +91,85 @@ static void GaussJordanTriangular(Matrix& a_Matrix, bool a_Normalise) {
 
 		Matrix::Element pivot = a_Matrix.at(indice_ligne_pivot, j);
 
-		if (a_Normalise) {
+		auto range = std::views::iota(static_cast<std::size_t>(0), a_Matrix.GetRawCount());
-			DivideLine(a_Matrix, indice_ligne_pivot, pivot);
+
+		// On simplifie les autres lignes
+		std::for_each(std::execution::par_unseq, range.begin(), range.end(), [&a_Matrix, j, indice_ligne_pivot](std::size_t i) {
+			if (i != static_cast<std::size_t>(indice_ligne_pivot)) {
+				SimplifyLine(a_Matrix, i, indice_ligne_pivot, j);
 			}
+		});
+	}
+}
+
+static void GaussJordanTriangular(Matrix& a_Matrix) {
+	int indice_ligne_pivot = -1;
+
+	for (std::size_t j = 0; j < a_Matrix.GetColumnCount(); j++) {
+
+		int indice_ligne_pivot_trouve = FirstNotNullElementIndexOnColumn(a_Matrix, j, indice_ligne_pivot + 1);
+
+		if (indice_ligne_pivot_trouve < 0)	// colonne de 0
+			continue;						// on regarde la prochaine colonne
+
+		indice_ligne_pivot++;
+
+		if (indice_ligne_pivot_trouve != indice_ligne_pivot) {
+			SwapLines(a_Matrix, indice_ligne_pivot_trouve, indice_ligne_pivot);
+		}
+
+		Matrix::Element pivot = a_Matrix.at(indice_ligne_pivot, j);
 
 		auto range = std::views::iota(static_cast<std::size_t>(indice_ligne_pivot + 1), a_Matrix.GetRawCount());
 
 		// On simplifie les autres lignes après la ligne du pivot
 		std::for_each(std::execution::par_unseq, range.begin(), range.end(),
-			[&a_Matrix, indice_ligne_pivot, j](std::size_t i) { 
+			[&a_Matrix, indice_ligne_pivot, j](std::size_t i) { SimplifyLine(a_Matrix, i, indice_ligne_pivot, j); });
-				SimplifyLine(a_Matrix, i, indice_ligne_pivot, j); 
+	}
-			});
+}
+
+static void GaussJordanTriangularNorma(Matrix& a_Matrix) {
+	int indice_ligne_pivot = -1;
+
+	for (std::size_t j = 0; j < a_Matrix.GetColumnCount(); j++) {
+
+		int indice_ligne_pivot_trouve = FirstNotNullElementIndexOnColumn(a_Matrix, j, indice_ligne_pivot + 1);
+
+		if (indice_ligne_pivot_trouve < 0)	// colonne de 0
+			continue;						// on regarde la prochaine colonne
+
+		indice_ligne_pivot++;
+
+		if (indice_ligne_pivot_trouve != indice_ligne_pivot) {
+			SwapLines(a_Matrix, indice_ligne_pivot_trouve, indice_ligne_pivot);
+		}
+
+		Matrix::Element pivot = a_Matrix.at(indice_ligne_pivot, j);
+
+		DivideLine(a_Matrix, indice_ligne_pivot, pivot);
+
+		auto range = std::views::iota(static_cast<std::size_t>(indice_ligne_pivot + 1), a_Matrix.GetRawCount());
+
+		// On simplifie les autres lignes après la ligne du pivot
+		std::for_each(std::execution::par_unseq, range.begin(), range.end(),
+			[&a_Matrix, indice_ligne_pivot, j](std::size_t i) { SimplifyLine(a_Matrix, i, indice_ligne_pivot, j); });
 	}
 }
 
 void GaussJordan(Matrix& a_Matrix, bool a_Reduite, bool a_Normalise) {
-	if (a_Reduite)
+	if (a_Reduite) {
-		GaussJordanReduced(a_Matrix, a_Normalise);
+		if (a_Normalise) {
-	else
+			GaussJordanReducedNorma(a_Matrix);
-		GaussJordanTriangular(a_Matrix, a_Normalise);
+		} else {
+			GaussJordanReduced(a_Matrix);
+		}
+	} else {
+		if (a_Normalise) {
+			GaussJordanTriangularNorma(a_Matrix);
+		} else {
+			GaussJordanTriangular(a_Matrix);
+		}
+	}
 }
 
 }  // namespace Gauss

src/Matrix.cpp

@@ -71,11 +71,7 @@ Matrix Matrix::RawVector(std::initializer_list<Element>&& a_Elements) {
 }
 
 void Matrix::Fill(Element a_Element) {
-	for (std::size_t i = 0; i < m_Raws; i++) {
+	std::fill(GetLineIterator(0), GetLineIterator(m_Raws), a_Element);
-		for (std::size_t j = 0; j < m_Columns; j++) {
-			at(i, j) = a_Element;
-		}
-	}
 }
 
 void Matrix::Augment(const Matrix& a_Right) {
@@ -158,10 +154,12 @@ bool Matrix::operator==(const Matrix& a_Other) const {
 }
 
 Matrix::Element& Matrix::at(std::size_t a_Raw, std::size_t a_Column) {
+	assert(a_Raw < m_Raws && a_Column < m_Columns);
 	return m_Data[a_Raw * m_Columns + a_Column];
 }
 
 Matrix::Element Matrix::at(std::size_t a_Raw, std::size_t a_Column) const {
+	assert(a_Raw < m_Raws && a_Column < m_Columns);
 	return m_Data[a_Raw * m_Columns + a_Column];
 }
 

src/NR.cpp

@@ -3,7 +3,7 @@
 #include <cassert>
 #include <iostream>
 
-int PGCD(int x, int y) {
+NR::Int PGCD(NR::Int x, NR::Int y) {
 	if (x == 0 || y == 0)
 		return 1;
 	else if (x % y == 0)
@@ -14,18 +14,18 @@ int PGCD(int x, int y) {
 
 NR::NR() : m_Numerator(0), m_Denominator(1) {}
 
-NR::NR(int entier) : m_Numerator(entier), m_Denominator(1) {}
+NR::NR(NR::Int entier) : m_Numerator(entier), m_Denominator(1) {}
 
-NR::NR(int numerator, int denominator) :
+NR::NR(NR::Int numerator, NR::Int denominator) :
 	m_Numerator((denominator > 0) ? numerator : -numerator), m_Denominator(std::abs(denominator)) {
-	assert(denominator != 0);
 	Reduce();
 }
 
 void NR::Reduce() {
-	int divisor = PGCD(m_Denominator, m_Numerator);
+	NR::Int divisor = PGCD(m_Denominator, m_Numerator);
 	m_Denominator /= divisor;
 	m_Numerator /= divisor;
+	assert(m_Denominator != 0);
 }
 
 NR NR::Inverse() const {
@@ -33,11 +33,11 @@ NR NR::Inverse() const {
 	return {m_Denominator, m_Numerator};
 }
 
-int NR::GetNumerator() const {
+NR::Int NR::GetNumerator() const {
 	return m_Numerator;
 }
 
-int NR::GetDenominator() const {
+NR::Int NR::GetDenominator() const {
 	return m_Denominator;
 }
 
@@ -66,48 +66,57 @@ bool NR::operator>=(const NR& opNR) const {
 }
 
 std::ostream& operator<<(std::ostream& os, const NR& opNR) {
-	os << opNR.GetNumerator() << "/" << opNR.GetDenominator();
+	os << opNR.GetNumerator();
+	if (opNR.GetDenominator() != 1)
+		os << "/" << opNR.GetDenominator();
 	return os;
 }
 
 std::istream& operator>>(std::istream& is, NR& opNR) {
 	char slash;
-	is >> opNR.m_Numerator >> slash >> opNR.m_Denominator;
+	is >> opNR.m_Numerator >> slash;
+	if (slash != '/') {
+		// on revient un charactère en arrière
+		is.seekg(is.tellg() - static_cast<std::streampos>(1));
+		opNR.m_Denominator = 1;
+	} else {
+		is >> opNR.m_Denominator;
+	}
 	opNR.Reduce();
 	return is;
 }
 
 NR NR::operator+(const NR& opNR) const {
-	int num, den;
+	Int num, den;
 	num = m_Numerator * opNR.GetDenominator();
 	den = m_Denominator * opNR.GetDenominator();
 	num += (opNR.GetNumerator() * m_Denominator);
-	NR result(num, den);
+	NR result(num, num == 0 ? 1 : den);
 	return result;
 }
 
 NR NR::operator-(const NR& opNR) const {
-	int num, den;
+	Int num, den;
 	num = m_Numerator * opNR.GetDenominator();
 	den = m_Denominator * opNR.GetDenominator();
 	num -= (opNR.GetNumerator() * m_Denominator);
-	NR result(num, den);
+	NR result(num, num == 0 ? 1 : den);
 	return result;
 }
 
 NR NR::operator*(const NR& opNR) const {
-	int num, den;
+	Int num, den;
 	num = m_Numerator * opNR.GetNumerator();
 	den = m_Denominator * opNR.GetDenominator();
-	NR result(num, den);
+	NR result(num, num == 0 ? 1 : den);
 	return result;
 }
 
 NR NR::operator/(const NR& opNR) const {
-	int num, den;
+	Int num, den;
 	num = m_Numerator * opNR.GetDenominator();
 	den = m_Denominator * opNR.GetNumerator();
-	NR result(num, den);
+	NR result(num, num == 0 ? 1 : den);
 	return result;
 }
 

src/Solver.cpp

@@ -2,6 +2,15 @@
 
 #include "Gauss.h"
 
+static int FirstNotNullElementIndexOnLine(const Matrix& mat, std::size_t line) {
+	for (std::size_t i = 0; i < mat.GetColumnCount(); i++) {
+		if (!IsEqualZero(mat.at(line, i))) {
+			return i;
+		}
+	}
+	return -1;
+}
+
 Vect Solver::Image(Matrix&& a_Matrix) const {
 	a_Matrix.Transpose();
 	Gauss::GaussJordan(a_Matrix, false, false);
@@ -36,15 +45,21 @@ VectAffine Solver::RectangularSystem(Matrix&& a_MatrixA, const Matrix& a_VectorB
 	Vect noyau = solver.Kernel(std::move(a_MatrixA));
 	Matrix origin = mat.SubMatrix(0, mat.GetColumnCount() - 1, mat.GetRawCount(), 1);
 
-	// on rajoute des 0 si il faut
+	// on calcule le vecteur qui dirige l'espace affine
-
 	Matrix fullOrigin {mat.GetColumnCount() - 1, 1};
 	for (std::size_t i = 0; i < mat.GetRawCount(); i++) {
-		fullOrigin.at(i, 0) = origin.at(i, 0);
+		int pivot_index = FirstNotNullElementIndexOnLine(mat, i);
+		
+		if (static_cast<std::size_t>(pivot_index) == mat.GetColumnCount() - 1) {
+			// on a une ligne du type 0 = n. Aucune solution !
+			return {Matrix {}, Matrix::ColumnVector({0})};
 		}
 
-	for (std::size_t i = mat.GetRawCount(); i < mat.GetColumnCount() - 1; i++) {
+		// ligne entière de 0
-		fullOrigin.at(i, 0) = 0;
+		if (pivot_index < 0)
+			continue;
+
+		fullOrigin.at(pivot_index, 0) = origin.at(i, 0);
 	}
 
 	return {noyau, fullOrigin};

src/Vect.cpp

@@ -14,7 +14,7 @@ static bool IsColumnNull(Matrix& mat, std::size_t column) {
 
 Vect::Vect(Matrix&& a_Matrix) : m_Data(std::move(a_Matrix)) {
 	m_Data.Transpose();
-	Gauss::GaussJordan(m_Data, false, false);
+	Gauss::GaussJordan(m_Data, false, true);
 	m_Data.Transpose();
 	Simplify();
 }

src/gui/PivotGui.cpp

@@ -1,16 +1,59 @@
 #include "PivotGui.h"
 
+#include "Matrix.h"
+#include "Solver.h"
 #include <imgui.h>
+#include <sstream>
 
-std::vector<std::vector<int>> PivotGui::matrixValues;
+static std::string equationsResultImage;
-int PivotGui::matrixSizeX = 4;
+
-int PivotGui::matrixSizeY = 4;
+static Matrix LoadMatrixFromStdVect(const std::vector<std::vector<int>>& data) {
+	Matrix result {data.size(), data.empty() ? 0 : data[0].size()};
+	for (std::size_t i = 0; i < result.GetRawCount(); i++) {
+		for (std::size_t j = 0; j < result.GetColumnCount(); j++) {
+			result.at(i, j) = static_cast<Matrix::Element>(data[i][j]);
+		}
+	}
+	return result;
+}
+
+static std::string ElementToString(Matrix::Element e) {
+	std::stringstream ss;
+	ss << e;
+	return ss.str();
+}
+
+static std::string PrintVect(const Vect& vect) {
+	if (vect.GetCardinal() == 0)
+		return "{0}";
+
+	std::string result = "Vect( ";
+	for (std::size_t i = 0; i < vect.GetCardinal(); i++) {
+		Matrix vector = vect.GetVector(i);
+		result += " (";
+		for (std::size_t j = 0; j < vect.GetDimension(); j++) {
+			result += ElementToString(vector.at(j, 0)) + ", ";
+		}
+		result = result.substr(0, result.size() - 2);
+		result += " ), ";
+	}
+	result = result.substr(0, result.size() - 2);
+	result += "  )";
+	return result;
+}
 
 void PivotGui::Init() {}
 
 void PivotGui::Render() {
 	ImGuiIO& io = ImGui::GetIO();
 
+	static std::vector<std::vector<int>> matrixValues;
+	static int matrixSizeX = 4;
+	static int matrixSizeY = 4;
+	static Solver solver;
+
+	static bool refresh = true;
+
 	// divisions des fenetres
 	ImVec2 topLeftWindowSize(io.DisplaySize.x * 0.5f, io.DisplaySize.y * 0.8f);
 	ImVec2 topRightWindowSize(io.DisplaySize.x * 0.5f, io.DisplaySize.y * 0.8f);
@@ -19,30 +62,39 @@ void PivotGui::Render() {
 	// Begin fenetre top left
 	ImGui::SetNextWindowSize(topLeftWindowSize);
 	ImGui::SetNextWindowPos(ImVec2(0, 0));	// Position at the top-left corner
-    ImGui::Begin("Left Top Window", nullptr, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoScrollbar);
+	ImGui::Begin("Left Top Window", nullptr,
+		ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoScrollbar);
 
 	// Get window position
 	ImVec2 windowPos = ImGui::GetWindowPos();
 
 	ImGui::Text("Matrice initiale:");
 
-    ImGui::InputInt("##RowsMatriceInitiale", &matrixSizeY);
+	if (ImGui::InputInt("##RowsMatriceInitiale", &matrixSizeY))
+		refresh = true;
+	matrixSizeY = std::max(1, matrixSizeY);
 	ImGui::SameLine();
 	ImGui::Text("Lignes");
 
 
-    ImGui::InputInt("##ColumnsMatriceInitiale", &matrixSizeX);
+	if (ImGui::InputInt("##ColumnsMatriceInitiale", &matrixSizeX))
+		refresh = true;
+	matrixSizeX = std::max(1, matrixSizeX);
 	ImGui::SameLine();
 	ImGui::Text("Colonnes");
 
+	ImGui::NewLine();
+
 	ImGui::BeginChild("MatriceInitiale", ImVec2(topLeftWindowSize.x, io.DisplaySize.y * 0.7f), false);
 
 	// Resize matrixValues and initialize new elements to 0
 
+	if (refresh) {
 		matrixValues.resize(matrixSizeY);
 		for (auto& row : matrixValues) {
 			row.resize(matrixSizeX, 0);
 		}
+	}
 
 	for (int y = 0; y < matrixSizeY; y++) {
 		for (int x = 0; x < matrixSizeX; x++) {
@@ -50,13 +102,17 @@ void PivotGui::Render() {
 				ImGui::SameLine();
 			ImGui::PushID(y * matrixSizeX + x);
 			ImGui::PushItemWidth(30);  // Adjust this value to change the cell size
-		   ImGui::InputInt("", &matrixValues[y][x], 0, 0, ImGuiInputTextFlags_CharsDecimal);
+			if (ImGui::InputInt("", &matrixValues[y][x], 0, 0, ImGuiInputTextFlags_CharsDecimal))
+				refresh = true;
 			ImGui::PopItemWidth();
 			ImGui::PopID();
 		}
 	}
 
-    ImGui::Text("Matrice finale:");
+	// Display the equationsResult strings in the GUI if they are not empty
+	if (!equationsResultImage.empty()) {
+		ImGui::TextWrapped(equationsResultImage.c_str());
+	}
 
 	ImGui::EndChild();	// End Matrice initiale
 
@@ -65,30 +121,45 @@ void PivotGui::Render() {
 	// Begin fenetre top right
 	ImGui::SetNextWindowSize(topRightWindowSize);
 	ImGui::SetNextWindowPos(ImVec2(windowPos.x + topLeftWindowSize.x, 0));	// Position at the top-right corner
-    ImGui::Begin("Right Top Window", nullptr, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoScrollbar);
+	ImGui::Begin("Right Top Window", nullptr,
+		ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoScrollbar);
 
 	// rajouter le code pour la partie top right
 
+	static std::string result = "";
+
+	ImGui::TextWrapped(result.c_str());
+
 	ImGui::End();  // End fenetre top right
 
 	// Begin fenetre bas
 	ImGui::SetNextWindowSize(bottomWindowSize);
 	ImGui::SetNextWindowPos(ImVec2(0, io.DisplaySize.y * 0.8f));  // Position at the bottom-left corner
-    ImGui::Begin("Bottom Part", nullptr, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoScrollbar);
+	ImGui::Begin("Bottom Part", nullptr,
+		ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoScrollbar);
 
-    // rajouter des boutons clickables
+	if (refresh) {
-    if (ImGui::Button("Calcul noyeau")) {
+
-        // Code de calcul
+		// Calculate the kernel and image
+		Vect image = solver.Image(LoadMatrixFromStdVect(matrixValues));
+		Matrix linearSystem = image.GetLinearSystem();
+
+		// Store the equationsResult strings in the global variable
+		equationsResultImage = "Equations cartesiennes de l'espace vectoriel (Image):\n";
+		for (size_t i = 0; i < linearSystem.GetRawCount(); ++i) {
+			for (size_t j = 0; j < linearSystem.GetColumnCount(); ++j) {
+				equationsResultImage +=
+					ElementToString(linearSystem.at(i, j)) + "*" + std::string {static_cast<char>('a' + j)} + " + ";
 			}
-    ImGui::SameLine(); // Align buttons horizontally
+			equationsResultImage = equationsResultImage.substr(0, equationsResultImage.size() - 3) + " = 0\n";
-    if (ImGui::Button("Calcul rang")) {
-        // Code de calcul
-    }
-    ImGui::SameLine(); // Align buttons horizontally
-    if (ImGui::Button("Calcul image")) {
-        // Code de calcul
 		}
 
+		result = std::string("Noyau: ") + "\n" + PrintVect(solver.Kernel(LoadMatrixFromStdVect(matrixValues))) + "\n" + "\n" +
+				 "Rang: " + "\n" + std::to_string(solver.Rank(LoadMatrixFromStdVect(matrixValues))) + "\n" + "\n" + "Image: " + "\n" +
+				 PrintVect(image);
+	}
+
+	refresh = false;
 	ImGui::End();  // End fenetre bas
 }
 

src/gui/PivotGui.h

@@ -1,12 +1,9 @@
 #pragma once
-#include <vector>
 
 namespace PivotGui {
 
 void Init();
 void Render();
 void Destroy();
-extern std::vector<std::vector<int>> matrixValues;
+
-extern int matrixSizeX;
-extern int matrixSizeY;
 }  // namespace PivotGui

test/test_assert.h

@@ -6,6 +6,7 @@
  */
 
 #include <iostream>
+#include <stdexcept>
 
 /**
  * \def TEST_SUCCESSFUL
@@ -37,6 +38,5 @@
 	if (!static_cast<bool>(__VA_ARGS__)) {                                                                                            \
 		std::cout << __FILE__ << ":" << __LINE__ << ": " << __FUNCTION_NAME__ << ": Assertion failed !\n";                            \
 		std::cout << "    " << __LINE__ << "  |\t" << #__VA_ARGS__ << std::endl;                                                      \
-		std::exit(TEST_FAILED);                                                                                                       \
+		throw std::runtime_error("Assertion failed !");                                                                               \
 	}
-

test/test_jordan.cpp

@@ -2,6 +2,12 @@
 #include "Matrix.h"
 #include "test_assert.h"
 
+#include <chrono>
+#include <iostream>
+
+static constexpr int MATRIX_MAX_SIZE = 300;
+static constexpr int EXECUTION_COUNT = 1;
+
 struct Test {
 	Matrix mat;
 	Matrix res;
@@ -30,6 +36,22 @@ static const std::vector<Test> TEST_MATRICES = {
     }}}
 };
 
+static unsigned int GetRandomInt() {
+	return rand() % MATRIX_MAX_SIZE + 1;
+}
+
+static Matrix GetRandomMatrix(std::size_t a_Raw, std::size_t a_Column) {
+	Matrix matrix {a_Raw, a_Column};
+
+	for (std::size_t i = 0; i < matrix.GetRawCount(); i++) {
+		for (std::size_t j = 0; j < matrix.GetColumnCount(); j++) {
+			matrix.at(i, j) = GetRandomInt();
+		}
+	}
+
+	return matrix;
+}
+
 void test() {
 	for (Test test : TEST_MATRICES) {
 		Gauss::GaussJordan(test.mat, true, true);
@@ -37,7 +59,26 @@ void test() {
 	}
 }
 
+void gaussTest() {
+    auto start = std::chrono::system_clock::now();
+
+	for (int i = 0; i < EXECUTION_COUNT; i++) {
+		Matrix mat = GetRandomMatrix(500, 500);
+		Gauss::GaussJordan(mat, false, false);
+	}
+
+	auto end = std::chrono::system_clock::now();
+	std::chrono::duration<double> elapsed_seconds = end - start;
+	std::cout << "\tgauss jordan elapsed time : " << elapsed_seconds.count() << "s" << std::endl;
+}
+
+void speedTest() {
+    gaussTest();
+   // gaussColumnTest();
+}
+
 int main(int argc, char** argv) {
 	test();
+	speedTest();
 	return 0;
 }

test/test_plot.cpp

@@ -0,0 +1,109 @@
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <execution>
+#include <future>
+#include <matplot/matplot.h>
+
+#include "Gauss.h"
+#include "Matrix.h"
+#include "Solver.h"
+
+static constexpr int EXECUTION_COUNT = 100;
+static constexpr int MATRIX_MAX_SIZE = 300;
+
+static unsigned int GetRandomInt() {
+	return rand() % MATRIX_MAX_SIZE + 1;
+}
+
+static Matrix GetRandomMatrix(std::size_t a_Raw, std::size_t a_Column) {
+	Matrix matrix {a_Raw, a_Column};
+
+	for (std::size_t i = 0; i < matrix.GetRawCount(); i++) {
+		for (std::size_t j = 0; j < matrix.GetColumnCount(); j++) {
+			matrix.at(i, j) = GetRandomInt();
+		}
+	}
+
+	return matrix;
+}
+
+std::vector<double> GaussJordan(const std::vector<double>& x) {
+	std::vector<double> y;
+
+	std::for_each(x.begin(), x.end(), [&y](double size) {
+		auto start = std::chrono::system_clock::now();
+
+		for (int j = 0; j < EXECUTION_COUNT; j++) {
+			Matrix mat = GetRandomMatrix(size, size);
+			Gauss::GaussJordan(mat, false, false);
+		}
+
+		auto end = std::chrono::system_clock::now();
+		std::chrono::duration<double> elapsed_seconds = end - start;
+		std::cout << "S " << size << "\n";
+		y.push_back(elapsed_seconds.count() / static_cast<double>(EXECUTION_COUNT));
+	});
+
+	return y;
+}
+
+
+std::vector<double> GaussJordanReduite(const std::vector<double>& x) {
+	std::vector<double> y;
+
+	std::for_each(x.begin(), x.end(), [&y](double size) {
+		auto start = std::chrono::system_clock::now();
+
+		for (int j = 0; j < EXECUTION_COUNT; j++) {
+			Matrix mat = GetRandomMatrix(size, size);
+			Gauss::GaussJordan(mat, true, false);
+		}
+
+		auto end = std::chrono::system_clock::now();
+		std::chrono::duration<double> elapsed_seconds = end - start;
+		std::cout << "R " << size << "\n";
+		y.push_back(elapsed_seconds.count() / static_cast<double>(EXECUTION_COUNT));
+	});
+
+	return y;
+}
+
+int main() {
+	srand(time(0));
+
+	int start = 1;
+
+	std::vector<double> x = matplot::linspace(start, MATRIX_MAX_SIZE, MATRIX_MAX_SIZE - start + 1);
+	//std::vector<double> x = {5000};
+	std::vector<double> y, y1, y2, y3;
+
+	// y2.resize(x.size());
+
+	{
+		auto result1 = std::async(std::launch::async, &GaussJordan, x);
+		auto result2 = std::async(std::launch::async, &GaussJordanReduite, x);
+		y = result1.get();
+		y1 = result2.get();
+	}
+
+
+	std::cout << "Fini !\n";
+
+
+	// std::transform(x.begin(), x.end(), y2.begin(), [](double x) { return 1.0 / (100.0 * 100.0) * 0.6 * x * x; });
+
+	matplot::title("Echelonnage de matrices");
+	matplot::xlabel("Taille des matrices");
+	matplot::ylabel("Temps d'exécution (s)");
+
+	matplot::hold(matplot::on);
+	matplot::plot(x, y);
+	matplot::plot(x, y1);
+
+	auto l = matplot::legend({"Echelonnage non réduit", "Echelonnage réduit", "Echelonnage non réduit normalisé", "Echelonnage réduit normalisé"});
+	l->location(matplot::legend::general_alignment::topleft);
+
+	matplot::show();
+	return 0;
+}

test/test_random_kernel.cpp

@@ -6,13 +6,23 @@
 #include <iostream>
 #include <vector>
 
-static constexpr int EXECUTION_COUNT = 100;
+static constexpr int EXECUTION_COUNT = 1000;
 static constexpr int KERNEL_CHECKS = 100;
-static constexpr int MATRIX_MAX_SIZE = 100;
+static constexpr int MATRIX_MAX_SIZE = 9;
 
 static const Solver solver;
 
-static unsigned int GetRandomInt() {
+static int GetRandomInt() {
+	return rand() % 11 - 5;
+}
+
+#define print_time(i)                                                                                                                 \
+	end = std::chrono::system_clock::now();                                                                                           \
+	elapsed_seconds = end - start;                                                                                                    \
+	std::cout << "elapsed time " << i << " : " << elapsed_seconds.count() << "s" << std::endl;                                        \
+	start = std::chrono::system_clock::now()
+
+static unsigned int GetRandomSize() {
 	return rand() % MATRIX_MAX_SIZE + 1;
 }
 
@@ -28,25 +38,35 @@ static Matrix GetRandomMatrix(std::size_t a_Raw, std::size_t a_Column) {
 	return matrix;
 }
 
-static void Test() {
+static bool Test() {
-	Matrix matrix = GetRandomMatrix(GetRandomInt(), GetRandomInt());
+	auto start = std::chrono::system_clock::now();
+	auto begin = start;
+	auto end = start;
+	std::chrono::duration<double> elapsed_seconds = end - start;
 
-	for (std::size_t i = 0; i < matrix.GetRawCount(); i++) {
+	std::cout << "Begin\n";
-		for (std::size_t j = 0; j < matrix.GetColumnCount(); j++) {
+
-			matrix.at(i, j) = GetRandomInt();
+	Matrix matrix = GetRandomMatrix(GetRandomSize(), GetRandomSize());
-		}
+
-	}
+	print_time(1);
 
 	Matrix copy = matrix;
 
 	Vect kernel = solver.Kernel(std::move(copy));
 
+	print_time(2);
+
 	Matrix nullVector {matrix.GetRawCount(), 1};
 	nullVector.Fill(0.0);
 
 	for (std::size_t i = 0; i < kernel.GetCardinal(); i++) {
-		test_assert(matrix * kernel.GetVector(i) == nullVector);
+		Matrix result = matrix * kernel.GetVector(i);
+		if(!(result == nullVector)) {
+			test_assert(false);
 		}
+	}
+
+	print_time(3);
 
 	for (std::size_t i = 0; i < KERNEL_CHECKS; i++) {
 		Matrix vector = GetRandomMatrix(kernel.GetDimension(), 1);
@@ -54,20 +74,40 @@ static void Test() {
 		test_assert(kernel.IsElementOf(vector) == (matrix * vector == nullVector));
 	}
 
-	Vect kernel2 = solver.Kernel(kernel.GetLinearSystem());
+	print_time(4);
+
+	Matrix linearSystem = kernel.GetLinearSystem();
+
+	print_time(5);
+
+	Vect kernel2 = solver.Kernel(std::move(linearSystem));
 
 	test_assert(kernel == kernel2);
+
+	print_time(6);
+
+	elapsed_seconds = end - begin;
+	std::cout << "final elapsed time: " << elapsed_seconds.count() << "s" << std::endl;
+
+	std::cout << "End\n";
+	return true;
 }
 
 int main() {
 	srand(time(0));
 
-	std::vector<std::future<void>> results;
+	std::vector<std::future<bool>> results;
 
 	// appelle la fonction Test() en parallèle
 	for (int i = 0; i < EXECUTION_COUNT; i++) {
 		auto handle = std::async(std::launch::async, &Test);
 		results.push_back(std::move(handle));
+		// Test();
+	}
+
+	for (auto& result : results) {
+		if (!result.get())
+			return EXIT_FAILURE;
 	}
 
 	return EXIT_SUCCESS;

test/test_solver.cpp

@@ -1,3 +1,4 @@
+#include <algorithm>
 #include <filesystem>
 #include <fstream>
 #include <iostream>
@@ -8,18 +9,48 @@
 
 namespace fs = std::filesystem;
 
-void TestRectangular() {
+const static int EXECUTION_COUNT = 10000;
-	Matrix mat2 = {2, 4, {
+static constexpr int MATRIX_MAX_SIZE = 7;
-		1, 1, 1, 1,
-		1, -1, -1, 2
-	}};
 
-	VectAffine aff {Matrix::ColumnVector({0, -1, 1}), Matrix::ColumnVector({3.0 / 2.0, 0, -1.0 / 2.0})};
+static int GetRandomSize() {
+	return rand() % MATRIX_MAX_SIZE + 1;
+}
 
+static int GetRandomInt() {
+	return GetRandomSize();
+}
+
+static Matrix GetRandomMatrix(std::size_t a_Raw, std::size_t a_Column) {
+	Matrix matrix {a_Raw, a_Column};
+
+	std::generate(matrix.GetLineIterator(0), matrix.GetLineIterator(a_Raw), []() { 
+		return GetRandomInt(); 
+	});
+
+	return matrix;
+}
+
+void TestRectangular(const Matrix& system, const Matrix& origin) {
 	Solver solver;
 
-	std::cout << solver.RectangularSystem(std::move(mat2), Matrix::ColumnVector({1, 2})).GetLinearSystem() << std::endl;
+	VectAffine solution = solver.RectangularSystem(std::move(Matrix(system)), origin);
-	std::cout << aff.GetLinearSystem() << std::endl;
+
+	for (std::size_t i = 0; i < solution.GetBase().GetCardinal(); i++) {
+		Matrix vector = solution.GetBase().GetVector(i) + solution.GetOrigin();
+		Matrix product = system * vector;
+		test_assert(product == origin);
+	}
+}
+
+void RandomRectangular() {
+	for (int i = 0; i < EXECUTION_COUNT; i++) {
+
+		Matrix system = GetRandomMatrix(GetRandomSize(), GetRandomSize());
+
+		Matrix origin = GetRandomMatrix(system.GetRawCount(), 1);
+
+		TestRectangular(system, origin);
+	}
 }
 
 void TestKernelImage() {
@@ -41,13 +72,17 @@ void TestKernelImage() {
 
 		Matrix copy = mat;
 
-		test_assert(solver.Image(std::move(copy)) == image);
+		Vect imageCalc = solver.Image(std::move(copy));
-		test_assert(solver.Kernel(std::move(mat)) == noyau);
+		Vect kernelCalc = solver.Kernel(std::move(mat));
+
+		test_assert(imageCalc == image);
+		test_assert(kernelCalc == noyau);
 	}
 }
 
 int main() {
+	srand(time(0));
 	TestKernelImage();
-	TestRectangular();
+	RandomRectangular();
 	return 0;
 }

xmake.lua

@@ -7,10 +7,14 @@ set_languages("c++20")
 set_warnings("all")
 add_includedirs("include")
 
+add_requires("matplotplusplus")
+
 -- Solver Library
 target("Pivot")
     set_kind("static")
     add_files("src/*.cpp")
+    add_cxxflags("-ffast-math")
+    set_optimize("fastest")
     remove_files("src/main.cpp")
 
 
@@ -49,6 +53,7 @@ for _, file in ipairs(os.files("test/test_*.cpp")) do
         set_default(false)
 
         add_deps("Pivot")
+        add_packages("matplotplusplus")
 
         add_tests("compile_and_run")
 end