add more doc

include/Gauss.h

@@ -0,0 +1,20 @@
+#pragma once
+
+/**
+ * \file Gauss.h
+ * \brief Contient la définition de l'algorithme de Gauss
+ */
+
+class Matrix;
+
+namespace Gauss {
+
+/**
+ * \brief Echelonne une matrice en utilisant l'algorithme de Gauss-Jordan
+ * \param mat La matrice à échelonner
+ * \param reduite Mets des 0 au dessus des pivots
+ * \param normalise Mets les pivots à 1
+ */
+void GaussJordan(Matrix& mat, bool reduite, bool normalise);
+
+}  // namespace Gauss

include/IO.h

@@ -0,0 +1,52 @@
+#pragma once
+
+/**
+ * \file IO.h
+ * \brief Contient des fonctions utiles pour travailler avec les systèmes d'entrée et de sortie
+ */
+
+#include <string>
+
+class Matrix;
+class Vect;
+class VectAffine;
+
+std::ostream& operator<<(std::ostream& stream, const Matrix& mat);
+std::istream& operator>>(std::istream& stream, Matrix& mat);
+
+/**
+ * \brief Charge une matrice à partir d'un fichier
+ * \param fileName Le chemin du fichier à charger
+ * \return Une matrice de taille nulle si une erreur intervient
+ */
+Matrix LoadMatrix(const std::string& fileName);
+
+/**
+ * \brief Sauvegarde une matrice dans un fichier
+ * \param mat La matrice à sauver
+ * \param fileName Le chemin du fichier à écrire
+ */
+void SaveMatrix(const Matrix& mat, const std::string& fileName);
+
+/**
+ * \brief Permet de saisir une matrice à partir de la console
+ */
+Matrix InsertMatrix();
+
+/**
+ * \brief Affiche une matrice dans la console
+ * \param mat La matrice à afficher
+ */
+void Print(const Matrix& mat);
+
+/**
+ * \brief Affiche un espace vectoriel dans la console
+ * \param vect L'espace vectoriel à afficher
+ */
+void Print(const Vect& vect);
+
+/**
+ * \brief Affiche un espace affine dans la console
+ * \param vect L'espace affine à afficher
+ */
+void Print(const VectAffine& vect);

include/Matrix.h

@@ -0,0 +1,113 @@
+#pragma once
+
+/**
+ * \file Matrix.h
+ * \brief Contient la définition d'une matrice
+ */
+
+#include <cmath>
+#include <cstddef>
+#include <string>
+#include <vector>
+
+/**
+ * \class Matrix
+ * \brief Représente une matrice d'éléments
+ */
+class Matrix {
+  public:
+	typedef long double Element;
+
+  private:
+	std::size_t m_Raws;
+	std::size_t m_Columns;
+	std::vector<Element> m_Data;
+
+  public:
+	/**
+	 * \brief Constructeur par défaut. Crée une matrice de taille nulle
+	 */
+	Matrix() : m_Raws(0), m_Columns(0) {}
+
+	/**
+	 * \brief Construit une matrice de taille donnée
+	 * \param raws Le nombre de lignes
+	 * \param columns Le nombre de colonne
+	 */
+	Matrix(std::size_t raws, std::size_t columns);
+
+	/**
+	 * \brief Construit une matrice de taille donnée avec des éléments donnés
+	 * \param raws Le nombre de lignes
+	 * \param columns Le nombre de colonne
+	 * \param initList Les élements à mettre
+	 */
+	Matrix(std::size_t raws, std::size_t columns, std::initializer_list<Element>&& initList);
+
+	~Matrix() {}
+
+	/**
+	 * \brief Retourne le nombre de ligne de la matrice
+	 */
+	std::size_t GetRawCount() const;
+
+	/**
+	 * \brief Retourne le nombre de colonne de la matrice
+	 */
+	std::size_t GetColumnCount() const;
+
+	/**
+	 * \brief Transpose la matrice
+	 */
+	void Transpose();
+
+	/**
+	 * \brief Augmente la matrice actuelle avec une autre
+	 * \param right Une matrice avec le bon nombre de lignes
+	 * \pre GetRawCount() = right.GetRawCount()
+	 */
+	void Augment(const Matrix& right);
+
+	/**
+	 * \brief Retourne la sous-matrice spécifiée
+	 * \param raw_origin L'indice de la première ligne de la matrice à récupérer
+	 * \param column_origin L'indice de la première colonne de la matrice à récupérer
+	 * \param raw Le nombre de lignes de la sous-matrice
+	 * \param column Le nombre de colonnes de la sous-matrice
+	 * \pre raw_origin + raw <= GetRawCount()
+	 * \pre column_origin + column <= GetColumnCount()
+	 */
+	Matrix SubMatrix(std::size_t raw_origin, std::size_t column_origin, std::size_t raw, std::size_t column) const;
+
+	bool operator==(const Matrix& other) const;
+
+	/**
+	 * \brief Effectue un produit matriciel
+	 */
+	Matrix operator*(const Matrix& other) const;
+
+	/**
+	 * \brief Retourne l'élément à l'indice recherché
+	 * \param raw L'indice de la ligne
+	 * \param column L'indice de la colonne
+	 */
+	Element& at(std::size_t raw, std::size_t column);
+
+	/**
+	 * \brief Retourne l'élément à l'indice recherché (version constante)
+	 * \param raw L'indice de la ligne
+	 * \param column L'indice de la colonne
+	 */
+	Element at(std::size_t raw, std::size_t column) const;
+
+	/**
+	 * \brief Construit une matrice identité de taille donnée
+	 * \param size La taille de la matrice carrée
+	 */
+	static Matrix Identity(std::size_t size);
+};
+
+template <typename T>
+bool IsEqualZero(T var) {
+	return std::abs(var) < std::pow(10, -5);
+}

include/NR.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <iostream>
+
+class NR {
+  private:
+	int m_Numerator;
+	int m_Denominator;	// has to be > 0, sign is carried by the numerator
+
+  public:
+	NR();
+	NR(int entier);
+	NR(int numerator, int denominator);	 // check if denominator != 0
+
+	int GetNumerator() const;
+	int GetDenominator() const;
+
+	bool operator==(const NR& opNR) const;
+	bool operator<(const NR& opNR) const;
+	bool operator>(const NR& opNR) const;
+
+	bool operator!=(const NR& opNR) const;
+	bool operator<=(const NR& opNR) const;
+	bool operator>=(const NR& opNR) const;
+
+	NR operator+(const NR& opNR) const;
+	NR operator-(const NR& opNR) const;
+	NR operator*(const NR& opNR) const;
+	NR operator/(const NR& opNR) const;
+
+	NR& operator+=(const NR& opNR);
+	NR& operator-=(const NR& opNR);
+	NR& operator*=(const NR& opNR);
+	NR& operator/=(const NR& opNR);
+
+	void Invert();
+
+	friend std::ostream& operator<<(std::ostream& os, const NR& opNR);
+	friend std::istream& operator>>(std::istream& os, NR& opNR);
+
+  private:
+	void Reduce();
+};
+
+int PGCD(int x, int y);

include/Solver.h

@@ -0,0 +1,51 @@
+#pragma once
+
+/**
+ * \file Solver.h
+ * \brief Contient la définition du solutionneur
+ */
+
+#include "Vect.h"
+
+/**
+ * \class Solver
+ * \brief Permet d'obtenir différentes propriétés d'une matrice comme l'image ou le noyau
+ */
+class Solver {
+  private:
+	Matrix m_Matrix;
+
+  public:
+	/**
+	 * \brief Initialise le resolveur
+	 * \param mat La matrice d'entrée
+	 */
+	Solver(const Matrix& mat);
+
+	~Solver() {}
+
+	/**
+	 * \brief Calcule l'image de la matrice d'entrée
+	 * \return L'espace vectoriel correspondant
+	 */
+	Vect Image() const;
+
+	/**
+	 * \brief Calcule le noyau de la matrice d'entrée
+	 * \return L'espace vectoriel correspondant
+	 */
+	Vect Kernel() const;
+
+	/**
+	 * \brief Résout le système triangulaire de la forme AX=B, avec X et B, des vecteurs colonne
+	 * La matrice d'entrée est considéré comme étant la matrice augmenté [A|B]
+	 * \return L'espace affine associé
+	 */
+	VectAffine TriangularSystem() const;
+
+	/**
+	 * \brief Calcule le rang de la matrice
+	 * \note Ceci équivaut à \code Image().GetCardinal() \endcode
+	 */
+	std::size_t Rank() const;
+};

include/Vect.h

@@ -0,0 +1,92 @@
+#pragma once
+
+/**
+ * \file Vect.h
+ * \brief Contient la définition d'un espace affine et d'un espace vectoriel
+ */
+
+#include "Matrix.h"
+
+/**
+ * \class Vect
+ * \brief Représente une base d'un espace vectoriel de dimension finie
+ */
+class Vect {
+  private:
+	Matrix m_Data;
+
+  public:
+	/**
+	 * \brief Construit une base d'un espace vectoriel à partir des colonnes d'une matrice.
+	 * Les colonnes de 0 sont ignorées
+	 * \param mat Une matrice échelonnée.
+	 */
+	Vect(const Matrix& mat);
+
+	/**
+	 * \brief Permet d'obtenir le ieme vecteur de la base
+	 * \param index l'index du vecteur souhaité
+	 * \return Une matrice colonne
+	 */
+	Matrix GetVector(std::size_t index) const;
+
+	/**
+	 * \brief Retourne le nombre de coordonnées des vecteurs de la base (leur nombre de colonne)
+	 */
+	std::size_t GetDimension() const;
+
+	/**
+	 * \brief Retourne le nombre de vecteur de la base
+	 */
+	std::size_t GetCardinal() const;
+
+	/**
+	 * \brief Exprime l'espace vectoriel comme les solutions d'un système linéaire des coordonnées des vecteurs
+	 * \return Une matrice représentant le système linéaire
+	 */
+	Matrix GetLinearSystem() const;
+
+	/**
+	 * \brief Concatène la base actuelle avec un nouveau vecteur
+	 * \param mat Une matrice colonne de taille GetDimension()
+	 */
+	void AddVector(const Matrix& mat);
+
+	bool operator==(const Vect& other) const;
+	bool operator!=(const Vect& other) const;
+
+  private:
+	void Simplify();
+};
+
+/**
+ * \class VectAffine
+ * \brief Représente un espace affine
+ */
+class VectAffine {
+  private:
+	Vect m_Base;
+	Matrix m_Origin;
+
+  public:
+	/**
+	 * \brief Construit un espace affine à partir d'un espace vectoriel et d'une origine
+	 * \param base La base de l'espace vectoriel
+	 * \param origin Le vecteur d'origine (matrice colonne)
+	 */
+	VectAffine(const Vect& base, const Matrix& origin);
+
+	/**
+	 * \brief Retourne l'espace vectoriel correspondant
+	 */
+	const Vect& GetBase() const {
+		return m_Base;
+	}
+
+	/**
+	 * \brief Retourne l'origine de l'espace affine
+	 */
+	const Matrix& GetOrigin() const {
+		return m_Origin;
+	}
+};