ProjetMAM/Pivot
Archived
4
1
Fork 0
Code Issues Pull Requests Actions Releases 2 Activity

solver rework + refactor

Browse Source
This commit is contained in:
Simon Pribylski
2024-03-06 21:24:15 +01:00
parent 259750a794
commit 99624d1b00
10 changed files with 191 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/Gauss.h
View File

@@ -15,6 +15,6 @@ namespace Gauss {
* \param reduite Mets des 0 au dessus des pivots * \param reduite Mets des 0 au dessus des pivots
* \param normalise Mets les pivots à 1 * \param normalise Mets les pivots à 1
*/ */
void GaussJordan(Matrix& mat, bool reduite, bool normalise); void GaussJordan(Matrix& a_Matrix, bool a_Reduite, bool a_Normalise);
} // namespace Gauss } // namespace Gauss

64
include/Matrix.h
View File

@@ -30,11 +30,11 @@ class Matrix {
Matrix() : m_Raws(0), m_Columns(0) {} Matrix() : m_Raws(0), m_Columns(0) {}
/** /**
* \brief Construit une matrice de taille donnée * \brief Construit une matrice de taille donnée remplit de données aléatoires (et peut-être invalides !)
* \param raws Le nombre de lignes * \param a_Raws Le nombre de lignes
* \param columns Le nombre de colonne * \param a_Columns Le nombre de colonne
*/ */
Matrix(std::size_t raws, std::size_t columns); Matrix(std::size_t a_Raws, std::size_t a_Columns);
/** /**
* \brief Construit une matrice de taille donnée avec des éléments donnés.\n * \brief Construit une matrice de taille donnée avec des éléments donnés.\n
@@ -42,11 +42,11 @@ class Matrix {
* \code Matrix(2, 2, {1, 2, 3, 4}) \endcode construit la matrice \n * \code Matrix(2, 2, {1, 2, 3, 4}) \endcode construit la matrice \n
* [1, 2]\n * [1, 2]\n
* [3, 4] * [3, 4]
* \param raws Le nombre de lignes * \param a_Raws Le nombre de lignes
* \param columns Le nombre de colonne * \param a_Columns Le nombre de colonne
* \param initList Les élements à mettre * \param a_Elements Les élements à mettre
*/ */
Matrix(std::size_t raws, std::size_t columns, std::initializer_list<Element>&& initList); Matrix(std::size_t a_Raws, std::size_t a_Columns, std::initializer_list<Element>&& a_Elements);
~Matrix() {} ~Matrix() {}
@@ -67,51 +67,51 @@ class Matrix {
/** /**
* \brief Augmente la matrice actuelle avec une autre * \brief Augmente la matrice actuelle avec une autre
* \param right Une matrice avec le bon nombre de lignes * \param a_Right Une matrice avec le bon nombre de lignes
* \pre GetRawCount() = right.GetRawCount() * \pre Les deux matrices doivent avoir le même nombre de lignes
*/ */
void Augment(const Matrix& right); void Augment(const Matrix& a_Right);
/** /**
* \brief Retourne la sous-matrice spécifiée * \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 a_RawOrigin 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 a_ColumnOrigin L'indice de la première colonne de la matrice à récupérer
* \param raw Le nombre de lignes de la sous-matrice * \param a_RawCount Le nombre de lignes de la sous-matrice
* \param column Le nombre de colonnes de la sous-matrice * \param a_ColumnCount Le nombre de colonnes de la sous-matrice
* \pre raw_origin + raw <= GetRawCount() * \pre a_RawOrigin + a_RawCount <= GetRawCount()
* \pre column_origin + column <= GetColumnCount() * \pre a_ColumnOrigin + a_ColumnCount <= GetColumnCount()
*/ */
Matrix SubMatrix(std::size_t raw_origin, std::size_t column_origin, std::size_t raw, std::size_t column) const; Matrix SubMatrix(std::size_t a_RawOrigin, std::size_t a_ColumnOrigin, std::size_t a_RawCount, std::size_t a_ColumnCount) const;
Matrix operator+(const Matrix& other) const; Matrix operator+(const Matrix& a_Other) const;
Matrix operator-(const Matrix& other) const; Matrix operator-(const Matrix& a_Other) const;
bool operator==(const Matrix& other) const; bool operator==(const Matrix& a_Other) const;
/** /**
* \brief Effectue un produit matriciel * \brief Effectue un produit matriciel
*/ */
Matrix operator*(const Matrix& other) const; Matrix operator*(const Matrix& a_Other) const;
/** /**
* \brief Retourne l'élément à l'indice recherché * \brief Retourne l'élément à l'indice recherché
* \param raw L'indice de la ligne * \param a_Raw L'indice de la ligne
* \param column L'indice de la colonne * \param a_Column L'indice de la colonne
*/ */
Element& at(std::size_t raw, std::size_t column); Element& at(std::size_t a_Raw, std::size_t a_Column);
/** /**
* \brief Retourne l'élément à l'indice recherché (version constante) * \brief Retourne l'élément à l'indice recherché (version constante)
* \param raw L'indice de la ligne * \param a_Raw L'indice de la ligne
* \param column L'indice de la colonne * \param a_Column L'indice de la colonne
*/ */
Element at(std::size_t raw, std::size_t column) const; Element at(std::size_t a_Raw, std::size_t a_Column) const;
/** /**
* \brief Construit une matrice identité de taille donnée * \brief Construit une matrice identité de taille donnée
* \param size La taille de la matrice carrée * \param a_Size La taille de la matrice carrée
*/ */
static Matrix Identity(std::size_t size); static Matrix Identity(std::size_t a_Size);
/** /**
* \brief Construit une matrice colonne à partir de données existantes.\n * \brief Construit une matrice colonne à partir de données existantes.\n
@@ -121,7 +121,7 @@ class Matrix {
* \endcode * \endcode
* construit une matrice de 4 lignes et 1 colonne de coordonnées (1, 2, 3, 4) * construit une matrice de 4 lignes et 1 colonne de coordonnées (1, 2, 3, 4)
*/ */
static Matrix ColumnVector(std::initializer_list<Element>&&); static Matrix ColumnVector(std::initializer_list<Element>&& a_Elements);
/** /**
* \brief Construit une matrice ligne à partir de données existantes.\n * \brief Construit une matrice ligne à partir de données existantes.\n
@@ -131,7 +131,7 @@ class Matrix {
* \endcode * \endcode
* construit une matrice de 1 ligne et 4 colonnes de coordonnées (1, 2, 3, 4) * construit une matrice de 1 ligne et 4 colonnes de coordonnées (1, 2, 3, 4)
*/ */
static Matrix RawVector(std::initializer_list<Element>&&); static Matrix RawVector(std::initializer_list<Element>&& a_Elements);
}; };
template <typename T> template <typename T>

35
include/Solver.h
View File

@@ -12,40 +12,33 @@
* \brief Permet d'obtenir différentes propriétés d'une matrice comme l'image ou le noyau * \brief Permet d'obtenir différentes propriétés d'une matrice comme l'image ou le noyau
*/ */
class Solver { class Solver {
private:
Matrix m_Matrix;
public: public:
/** /**
* \brief Initialise le resolveur * \brief Calcule l'image d'une matrice
* \param mat La matrice d'entrée * \param a_Matrix La matrice à traiter
*/
Solver(const Matrix& mat);
~Solver() {}
/**
* \brief Calcule l'image de la matrice d'entrée
* \return L'espace vectoriel correspondant * \return L'espace vectoriel correspondant
*/ */
Vect Image() const; Vect Image(const Matrix& a_Matrix) const;
/** /**
* \brief Calcule le noyau de la matrice d'entrée * \brief Calcule le noyau d'une matrice
* \param a_Matrix La matrice à traiter
* \return L'espace vectoriel correspondant * \return L'espace vectoriel correspondant
*/ */
Vect Kernel() const; Vect Kernel(const Matrix& a_Matrix) const;
/** /**
* \brief Résout le système triangulaire de la forme AX=B, avec X et B, des vecteurs colonne. * \brief Résout le système rectangulaire 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] * \param a_MatrixA La matrice jouant le rôle de A
* \param a_VectorB La matrice colonne jouant le rôle de B
* \return L'espace affine associé * \return L'espace affine associé
*/ */
VectAffine TriangularSystem() const; VectAffine RectangularSystem(const Matrix& a_MatrixA, const Matrix& a_VectorB) const;
/** /**
* \brief Calcule le rang de la matrice * \brief Calcule le rang d'une matrice
* \note Ceci équivaut à \code Image().GetCardinal() \endcode * \param a_Matrix La matrice à traiter
* \note Ceci équivaut à \code Image(a_Matrix).GetCardinal() \endcode
*/ */
std::size_t Rank() const; std::size_t Rank(const Matrix& a_Matrix) const;
}; };

42
include/Vect.h
View File

@@ -19,16 +19,16 @@ class Vect {
/** /**
* \brief Construit une base d'un espace vectoriel à partir des colonnes d'une matrice. * \brief Construit une base d'un espace vectoriel à partir des colonnes d'une matrice.
* Les colonnes de 0 sont ignorées * Les colonnes de 0 sont ignorées
* \param mat Une matrice échelonnée. * \param a_Matrix Une matrice échelonnée.
*/ */
Vect(const Matrix& mat); Vect(const Matrix& a_Matrix);
/** /**
* \brief Permet d'obtenir le ieme vecteur de la base * \brief Permet d'obtenir le ieme vecteur de la base
* \param index l'index du vecteur souhaité * \param a_Index l'index du vecteur souhaité
* \return Une matrice colonne * \return Une matrice colonne
*/ */
Matrix GetVector(std::size_t index) const; Matrix GetVector(std::size_t a_Index) const;
/** /**
* \brief Retourne le nombre de coordonnées des vecteurs de la base (leur nombre de colonne) * \brief Retourne le nombre de coordonnées des vecteurs de la base (leur nombre de colonne)
@@ -48,21 +48,23 @@ class Vect {
/** /**
* \brief Concatène la base actuelle avec un nouveau vecteur * \brief Concatène la base actuelle avec un nouveau vecteur
* \param vec Une matrice colonne de taille GetDimension() * \param a_Vector Une matrice colonne de taille GetDimension()
*/ */
void AddVector(const Matrix& vec); void AddVector(const Matrix& a_Vector);
/** /**
* \brief Vérifie si le vecteur spécifié appartient au sous-espace vectoriel * \brief Vérifie si le vecteur spécifié appartient au sous-espace vectoriel
* \param vec Une matrice colonne représentant le vecteur à tester * \param a_Vector Une matrice colonne représentant le vecteur à tester
*/ */
bool IsElementOf(const Matrix& vec) const; bool IsElementOf(const Matrix& a_Vector) const;
bool operator==(const Vect& other) const; bool operator==(const Vect& a_Other) const;
bool operator!=(const Vect& other) const; bool operator!=(const Vect& a_Other) const;
private: private:
void Simplify(); void Simplify();
friend class VectAffine;
}; };
/** /**
@@ -77,10 +79,10 @@ class VectAffine {
public: public:
/** /**
* \brief Construit un espace affine à partir d'un espace vectoriel et d'une origine * \brief Construit un espace affine à partir d'un espace vectoriel et d'une origine
* \param base La base de l'espace vectoriel * \param a_Base La base de l'espace vectoriel
* \param origin Le vecteur d'origine (matrice colonne) * \param a_Origin Le vecteur d'origine (matrice colonne)
*/ */
VectAffine(const Vect& base, const Matrix& origin); VectAffine(const Vect& a_Base, const Matrix& a_Origin);
/** /**
* \brief Retourne l'espace vectoriel correspondant * \brief Retourne l'espace vectoriel correspondant
@@ -99,11 +101,17 @@ class VectAffine {
/** /**
* \brief Vérifie si le vecteur spécifié appartient à l'espace affine * \brief Vérifie si le vecteur spécifié appartient à l'espace affine
* \param vec Une matrice colonne représentant le vecteur à tester * \param a_Vector Une matrice colonne représentant le vecteur à tester
*/ */
bool IsElementOf(const Matrix& vec) const; bool IsElementOf(const Matrix& a_Vector) const;
bool operator==(const VectAffine& vect) const { /**
return m_Origin == vect.GetOrigin() && m_Base == vect.GetBase(); * \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;
bool operator==(const VectAffine& a_VectAffine) const {
return m_Origin == a_VectAffine.GetOrigin() && m_Base == a_VectAffine.GetBase();
}; };
}; };

18
src/Gauss.cpp
View File

@@ -34,12 +34,12 @@ static void SimplifyLine(Matrix& mat, std::size_t line, std::size_t pivot_line,
} }
} }
void GaussJordan(Matrix& mat, bool reduite, bool normalise) { void GaussJordan(Matrix& a_Matrix, bool a_Reduite, bool a_Normalise) {
int indice_ligne_pivot = -1; int indice_ligne_pivot = -1;
for (std::size_t j = 0; j < mat.GetColumnCount(); j++) { for (std::size_t j = 0; j < a_Matrix.GetColumnCount(); j++) {
int indice_ligne_pivot_trouve = FirstNotNullElementIndexOnColumn(mat, j, indice_ligne_pivot + 1); int indice_ligne_pivot_trouve = FirstNotNullElementIndexOnColumn(a_Matrix, j, indice_ligne_pivot + 1);
if (indice_ligne_pivot_trouve < 0) // colonne de 0 if (indice_ligne_pivot_trouve < 0) // colonne de 0
continue; // on regarde la prochaine colonne continue; // on regarde la prochaine colonne
@@ -47,20 +47,20 @@ void GaussJordan(Matrix& mat, bool reduite, bool normalise) {
indice_ligne_pivot++; indice_ligne_pivot++;
if (indice_ligne_pivot_trouve != indice_ligne_pivot) { if (indice_ligne_pivot_trouve != indice_ligne_pivot) {
SwapLines(mat, indice_ligne_pivot_trouve, indice_ligne_pivot); SwapLines(a_Matrix, indice_ligne_pivot_trouve, indice_ligne_pivot);
} }
Matrix::Element pivot = mat.at(indice_ligne_pivot, j); Matrix::Element pivot = a_Matrix.at(indice_ligne_pivot, j);
if (normalise) { if (a_Normalise) {
DivideLine(mat, indice_ligne_pivot, pivot); DivideLine(a_Matrix, indice_ligne_pivot, pivot);
} }
// On simplifie les autres lignes // On simplifie les autres lignes
for (std::size_t i = (reduite ? 0 : j); i < mat.GetRawCount(); i++) { for (std::size_t i = (a_Reduite ? 0 : j); i < a_Matrix.GetRawCount(); i++) {
// Pour les lignes autre que la ligne pivot // Pour les lignes autre que la ligne pivot
if (i != static_cast<std::size_t>(indice_ligne_pivot)) { if (i != static_cast<std::size_t>(indice_ligne_pivot)) {
SimplifyLine(mat, i, indice_ligne_pivot, j); SimplifyLine(a_Matrix, i, indice_ligne_pivot, j);
} }
} }
} }

87
src/Matrix.cpp
View File

@@ -7,29 +7,29 @@
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
Matrix::Matrix(std::size_t lignes, std::size_t colonnes) : m_Raws(lignes), m_Columns(colonnes) { Matrix::Matrix(std::size_t a_Raws, std::size_t a_Columns) : m_Raws(a_Raws), m_Columns(a_Columns) {
m_Data.resize(m_Raws * m_Columns); m_Data.resize(m_Raws * m_Columns);
} }
Matrix::Matrix(std::size_t lignes, std::size_t colonnes, std::initializer_list<Element>&& initList) : Matrix::Matrix(std::size_t a_Raws, std::size_t a_Columns, std::initializer_list<Element>&& a_Elements) :
m_Raws(lignes), m_Columns(colonnes) { m_Raws(a_Raws), m_Columns(a_Columns) {
m_Data = initList; m_Data = a_Elements;
m_Data.resize(m_Raws * m_Columns); m_Data.resize(m_Raws * m_Columns);
} }
Matrix Matrix::operator*(const Matrix& other) const { Matrix Matrix::operator*(const Matrix& a_Other) const {
if (m_Columns != other.m_Raws) { if (m_Columns != a_Other.m_Raws) {
std::cerr << "Mutiplication impossible car la dimensions des matrices est incompatible" << std::endl; std::cerr << "Mutiplication impossible car la dimensions des matrices est incompatible" << std::endl;
return {}; return {};
} }
Matrix result(m_Raws, other.m_Columns); Matrix result(m_Raws, a_Other.m_Columns);
for (std::size_t i = 0; i < m_Raws; ++i) { for (std::size_t i = 0; i < m_Raws; ++i) {
for (std::size_t j = 0; j < other.m_Columns; ++j) { for (std::size_t j = 0; j < a_Other.m_Columns; ++j) {
Element sum = 0; Element sum = 0;
for (std::size_t k = 0; k < m_Columns; k++) { for (std::size_t k = 0; k < m_Columns; k++) {
sum += at(i, k) * other.at(k, j); sum += at(i, k) * a_Other.at(k, j);
} }
result.at(i, j) = sum; result.at(i, j) = sum;
} }
@@ -47,35 +47,35 @@ void Matrix::Transpose() {
*this = result; *this = result;
} }
Matrix Matrix::Identity(std::size_t taille) { Matrix Matrix::Identity(std::size_t a_Size) {
Matrix id {taille, taille}; Matrix id {a_Size, a_Size};
for (std::size_t i = 0; i < taille; i++) { for (std::size_t i = 0; i < a_Size; i++) {
for (std::size_t j = i; j < taille; j++) { for (std::size_t j = i; j < a_Size; j++) {
id.at(i, j) = (i == j); id.at(i, j) = (i == j);
} }
} }
return id; return id;
} }
Matrix Matrix::ColumnVector(std::initializer_list<Element>&& initList) { Matrix Matrix::ColumnVector(std::initializer_list<Element>&& a_Elements) {
Matrix result {initList.size(), 1}; Matrix result {a_Elements.size(), 1};
result.m_Data = initList; result.m_Data = a_Elements;
return result; return result;
} }
Matrix Matrix::RawVector(std::initializer_list<Element>&& initList) { Matrix Matrix::RawVector(std::initializer_list<Element>&& a_Elements) {
Matrix result {1, initList.size()}; Matrix result {1, a_Elements.size()};
result.m_Data = initList; result.m_Data = a_Elements;
return result; return result;
} }
void Matrix::Augment(const Matrix& droite) { void Matrix::Augment(const Matrix& a_Right) {
assert(droite.m_Raws == m_Raws); assert(a_Right.m_Raws == m_Raws);
Matrix temp {m_Raws, m_Columns + droite.m_Columns}; Matrix temp {m_Raws, m_Columns + a_Right.m_Columns};
for (std::size_t i = 0; i < m_Raws; i++) { for (std::size_t i = 0; i < m_Raws; i++) {
for (std::size_t j = 0; j < m_Columns; j++) { for (std::size_t j = 0; j < m_Columns; j++) {
@@ -84,49 +84,49 @@ void Matrix::Augment(const Matrix& droite) {
} }
for (std::size_t i = 0; i < m_Raws; i++) { for (std::size_t i = 0; i < m_Raws; i++) {
for (std::size_t j = 0; j < droite.m_Columns; j++) { for (std::size_t j = 0; j < a_Right.m_Columns; j++) {
temp.at(i, j + m_Columns) = droite.at(i, j); temp.at(i, j + m_Columns) = a_Right.at(i, j);
} }
} }
*this = temp; *this = temp;
} }
Matrix Matrix::operator+(const Matrix& other) const { Matrix Matrix::operator+(const Matrix& a_Other) const {
assert(GetColumnCount() == other.GetColumnCount() && GetRawCount() == other.GetRawCount()); assert(GetColumnCount() == a_Other.GetColumnCount() && GetRawCount() == a_Other.GetRawCount());
Matrix result = *this; Matrix result = *this;
for (std::size_t i = 0; i < GetRawCount(); i++) { for (std::size_t i = 0; i < GetRawCount(); i++) {
for (std::size_t j = 0; j < GetColumnCount(); j++) { for (std::size_t j = 0; j < GetColumnCount(); j++) {
result.at(i, j) += other.at(i, j); result.at(i, j) += a_Other.at(i, j);
} }
} }
return result; return result;
} }
Matrix Matrix::operator-(const Matrix& other) const { Matrix Matrix::operator-(const Matrix& a_Other) const {
assert(GetColumnCount() == other.GetColumnCount() && GetRawCount() == other.GetRawCount()); assert(GetColumnCount() == a_Other.GetColumnCount() && GetRawCount() == a_Other.GetRawCount());
Matrix result = *this; Matrix result = *this;
for (std::size_t i = 0; i < GetRawCount(); i++) { for (std::size_t i = 0; i < GetRawCount(); i++) {
for (std::size_t j = 0; j < GetColumnCount(); j++) { for (std::size_t j = 0; j < GetColumnCount(); j++) {
result.at(i, j) -= other.at(i, j); result.at(i, j) -= a_Other.at(i, j);
} }
} }
return result; return result;
} }
bool Matrix::operator==(const Matrix& other) const { bool Matrix::operator==(const Matrix& a_Other) const {
if (m_Raws != other.m_Raws || m_Columns != other.m_Columns) if (m_Raws != a_Other.m_Raws || m_Columns != a_Other.m_Columns)
return false; return false;
for (std::size_t i = 0; i < m_Raws; i++) { for (std::size_t i = 0; i < m_Raws; i++) {
for (std::size_t j = 0; j < m_Columns; j++) { for (std::size_t j = 0; j < m_Columns; j++) {
if (!IsEqualZero(at(i, j) - other.at(i, j))) if (!IsEqualZero(at(i, j) - a_Other.at(i, j)))
return false; return false;
} }
} }
@@ -134,12 +134,12 @@ bool Matrix::operator==(const Matrix& other) const {
return true; return true;
} }
Matrix::Element& Matrix::at(std::size_t ligne, std::size_t colonne) { Matrix::Element& Matrix::at(std::size_t a_Raw, std::size_t a_Column) {
return m_Data[ligne * m_Columns + colonne]; return m_Data[a_Raw * m_Columns + a_Column];
} }
Matrix::Element Matrix::at(std::size_t ligne, std::size_t colonne) const { Matrix::Element Matrix::at(std::size_t a_Raw, std::size_t a_Column) const {
return m_Data[ligne * m_Columns + colonne]; return m_Data[a_Raw * m_Columns + a_Column];
} }
std::size_t Matrix::GetRawCount() const { std::size_t Matrix::GetRawCount() const {
@@ -150,14 +150,15 @@ std::size_t Matrix::GetColumnCount() const {
return m_Columns; return m_Columns;
} }
Matrix Matrix::SubMatrix(std::size_t origine_ligne, std::size_t origine_colonne, std::size_t ligne, std::size_t colonne) const { Matrix Matrix::SubMatrix(
assert(m_Raws >= origine_ligne + ligne && m_Columns >= origine_colonne + colonne); std::size_t a_RawOrigin, std::size_t a_ColumnOrigin, std::size_t a_RawCount, std::size_t a_ColumnCount) const {
assert(m_Raws >= a_RawOrigin + a_RawCount && m_Columns >= a_ColumnOrigin + a_ColumnCount);
Matrix result {ligne, colonne}; Matrix result {a_RawCount, a_ColumnCount};
for (std::size_t i = 0; i < ligne; i++) { for (std::size_t i = 0; i < result.GetRawCount(); i++) {
for (std::size_t j = 0; j < colonne; j++) { for (std::size_t j = 0; j < result.GetColumnCount(); j++) {
result.at(i, j) = at(i + origine_ligne, j + origine_colonne); result.at(i, j) = at(i + a_RawOrigin, j + a_ColumnOrigin);
} }
} }

27
src/Solver.cpp
View File

@@ -2,10 +2,8 @@
#include "Gauss.h" #include "Gauss.h"
Solver::Solver(const Matrix& mat) : m_Matrix(mat) {} Vect Solver::Image(const Matrix& a_Matrix) const {
Matrix result = a_Matrix;
Vect Solver::Image() const {
Matrix result = m_Matrix;
result.Transpose(); result.Transpose();
Gauss::GaussJordan(result, true, true); Gauss::GaussJordan(result, true, true);
result.Transpose(); result.Transpose();
@@ -13,27 +11,28 @@ Vect Solver::Image() const {
} }
// https://en.wikipedia.org/wiki/Kernel_(linear_algebra)#Computation_by_Gaussian_elimination // https://en.wikipedia.org/wiki/Kernel_(linear_algebra)#Computation_by_Gaussian_elimination
Vect Solver::Kernel() const { Vect Solver::Kernel(const Matrix& a_Matrix) const {
Matrix result = m_Matrix; Matrix result = a_Matrix;
result.Transpose(); result.Transpose();
result.Augment(Matrix::Identity(result.GetRawCount())); result.Augment(Matrix::Identity(result.GetRawCount()));
Gauss::GaussJordan(result, true, true); Gauss::GaussJordan(result, true, true);
result.Transpose(); result.Transpose();
// nombre de colonnes non nulles // nombre de colonnes non nulles
std::size_t origine_colonne = Vect(result.SubMatrix(0, 0, m_Matrix.GetRawCount(), m_Matrix.GetColumnCount())).GetCardinal(); std::size_t origine_colonne = Vect(result.SubMatrix(0, 0, a_Matrix.GetRawCount(), a_Matrix.GetColumnCount())).GetCardinal();
return {result.SubMatrix(m_Matrix.GetRawCount(), origine_colonne, result.GetRawCount() - m_Matrix.GetRawCount(), return {result.SubMatrix(a_Matrix.GetRawCount(), origine_colonne, result.GetRawCount() - a_Matrix.GetRawCount(),
result.GetColumnCount() - origine_colonne)}; result.GetColumnCount() - origine_colonne)};
} }
VectAffine Solver::TriangularSystem() const { VectAffine Solver::RectangularSystem(const Matrix& a_MatrixA, const Matrix& a_VectorB) const {
Matrix mat = m_Matrix; Matrix mat = a_MatrixA;
mat.Augment(a_VectorB);
Gauss::GaussJordan(mat, true, true); Gauss::GaussJordan(mat, true, true);
Solver solver {mat.SubMatrix(0, 0, mat.GetRawCount(), mat.GetColumnCount() - 1)}; Solver solver;
Vect noyau = solver.Kernel(); Vect noyau = solver.Kernel(a_MatrixA);
Matrix origin = mat.SubMatrix(0, mat.GetColumnCount() - 1, mat.GetRawCount(), 1); Matrix origin = mat.SubMatrix(0, mat.GetColumnCount() - 1, mat.GetRawCount(), 1);
// on rajoute des 0 si il faut // on rajoute des 0 si il faut
@@ -50,6 +49,6 @@ VectAffine Solver::TriangularSystem() const {
return {noyau, fullOrigin}; return {noyau, fullOrigin};
} }
std::size_t Solver::Rank() const { std::size_t Solver::Rank(const Matrix& a_Matrix) const {
return Image().GetCardinal(); return Image(a_Matrix).GetCardinal();
} }

44
src/Vect.cpp
View File

@@ -14,7 +14,7 @@ static bool IsColumnNull(Matrix& mat, std::size_t column) {
return true; return true;
} }
Vect::Vect(const Matrix& mat) : m_Data(mat) { Vect::Vect(const Matrix& a_Matrix) : m_Data(a_Matrix) {
Simplify(); Simplify();
} }
@@ -29,50 +29,50 @@ void Vect::Simplify() {
m_Data = mat; m_Data = mat;
} }
Matrix Vect::GetVector(std::size_t index) const { Matrix Vect::GetVector(std::size_t a_Index) const {
return m_Data.SubMatrix(0, index, m_Data.GetRawCount(), 1); return m_Data.SubMatrix(0, a_Index, m_Data.GetRawCount(), 1);
} }
std::size_t Vect::GetCardinal() const { std::size_t Vect::GetCardinal() const {
return m_Data.GetColumnCount(); return m_Data.GetColumnCount();
} }
bool Vect::IsElementOf(const Matrix& vec) const { bool Vect::IsElementOf(const Matrix& a_Vector) const {
Vect base = *this; Vect base = *this;
base.AddVector(vec); base.AddVector(a_Vector);
return base.GetCardinal() == GetCardinal(); return base.GetCardinal() == GetCardinal();
} }
bool Vect::operator==(const Vect& other) const { bool Vect::operator==(const Vect& a_Other) const {
if (GetDimension() != other.GetDimension() || GetCardinal() != other.GetCardinal()) if (GetDimension() != a_Other.GetDimension() || GetCardinal() != a_Other.GetCardinal())
return false; return false;
// on vérifie si chaque vecteur de la deuxième base appartient à l'espace vectoriel engendré par la première base // on vérifie si chaque vecteur de la deuxième base appartient à l'espace vectoriel engendré par la première base
for (std::size_t i = 0; i < GetCardinal(); i++) { for (std::size_t i = 0; i < GetCardinal(); i++) {
if (!IsElementOf(other.GetVector(i))) if (!IsElementOf(a_Other.GetVector(i)))
return false; return false;
} }
return true; return true;
} }
void Vect::AddVector(const Matrix& mat) { void Vect::AddVector(const Matrix& a_Vector) {
m_Data.Augment(mat); m_Data.Augment(a_Vector);
m_Data.Transpose(); m_Data.Transpose();
Gauss::GaussJordan(m_Data, false, false); Gauss::GaussJordan(m_Data, false, false);
m_Data.Transpose(); m_Data.Transpose();
Simplify(); Simplify();
} }
bool Vect::operator!=(const Vect& other) const { bool Vect::operator!=(const Vect& a_Other) const {
return !(*this == other); return !(*this == a_Other);
} }
Matrix Vect::GetLinearSystem() const { Matrix Vect::GetLinearSystem() const {
Matrix vect = m_Data; Matrix vect = m_Data;
vect.Transpose(); vect.Transpose();
Solver solver {vect}; Solver solver;
vect = solver.Kernel().m_Data; vect = solver.Kernel(vect).m_Data;
vect.Transpose(); vect.Transpose();
return vect; return vect;
} }
@@ -81,9 +81,17 @@ std::size_t Vect::GetDimension() const {
return m_Data.GetRawCount(); return m_Data.GetRawCount();
} }
VectAffine::VectAffine(const Vect& base, const Matrix& origine) : VectAffine::VectAffine(const Vect& a_Base, const Matrix& a_Origin) :
m_Base(base), m_Origin(origine.SubMatrix(0, 0, m_Base.GetDimension(), 1)) {} m_Base(a_Base), m_Origin(a_Origin.SubMatrix(0, 0, m_Base.GetDimension(), 1)) {}
bool VectAffine::IsElementOf(const Matrix& vec) const { bool VectAffine::IsElementOf(const Matrix& a_Vector) const {
return m_Base.IsElementOf(vec - m_Origin); return m_Base.IsElementOf(a_Vector - m_Origin);
}
Matrix VectAffine::GetLinearSystem() const {
Matrix result = m_Base.GetLinearSystem();
result.Augment(m_Origin.SubMatrix(0, 0, result.GetRawCount(), 1));
return result;
} }

8
src/main.cpp
View File

@@ -23,10 +23,10 @@ void test() {
Matrix mat2 = LoadMatrix("matrice4x4.mat"); Matrix mat2 = LoadMatrix("matrice4x4.mat");
Print(mat2); Print(mat2);
Solver solver {mat2}; Solver solver;
Vect image = solver.Image(); Vect image = solver.Image(mat2);
Vect noyau = solver.Kernel(); Vect noyau = solver.Kernel(mat2);
std::cout << "\tImage :\n"; std::cout << "\tImage :\n";
Print(image); Print(image);
@@ -38,7 +38,7 @@ void test() {
Print(noyau.GetLinearSystem()); Print(noyau.GetLinearSystem());
std::cout << "\n\n"; std::cout << "\n\n";
Print(solver.TriangularSystem()); // Print(solver.TriangularSystem(mat2));
} }
void prompt() { void prompt() {

27
test/test_solver.cpp
View File

@@ -8,7 +8,21 @@
namespace fs = std::filesystem; namespace fs = std::filesystem;
int main() { void TestRectangular() {
Matrix mat2 = {2, 4, {
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})};
Solver solver;
std::cout << solver.RectangularSystem(mat2, Matrix::ColumnVector({1, 2})).GetLinearSystem() << std::endl;
std::cout << aff.GetLinearSystem() << std::endl;
}
void TestKernelImage() {
std::string path = "test"; std::string path = "test";
for (const auto& entry : fs::directory_iterator(path)) { for (const auto& entry : fs::directory_iterator(path)) {
std::string fileName = entry.path().string(); std::string fileName = entry.path().string();
@@ -23,10 +37,15 @@ int main() {
Vect image {imageMat}; Vect image {imageMat};
Vect noyau {noyauMat}; Vect noyau {noyauMat};
Solver solver {mat}; Solver solver;
assert(solver.Image() == image); assert(solver.Image(mat) == image);
assert(solver.Kernel() == noyau); assert(solver.Kernel(mat) == noyau);
} }
}
int main() {
TestKernelImage();
TestRectangular();
return 0; return 0;
} }