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

reformat

Browse Source
This commit is contained in:
Morph01
2024-02-08 10:36:19 +01:00
parent 3644a0aae2
commit 014b102e4a
3 changed files with 237 additions and 239 deletions
Download Patch File Download Diff File Expand all files Collapse all files

211
src/Matrix.cpp Normal file
View File

@@ -0,0 +1,211 @@
#include <algorithm>
#include <cmath>
#include <fstream>
#include <iostream>
#include "Matrix.h"
Matrix::Matrix(const std::string& fileNameInput) {
Load(fileNameInput);
}
Matrix::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::Matrix(std::size_t lignes, std::size_t colonnes, std::initializer_list<long double>&& initList) :
m_Lignes(lignes), m_Colonnes(colonnes), m_Dimension(lignes * colonnes) {
m_Data = initList;
m_Data.resize(m_Dimension);
}
Matrix::~Matrix() {}
Matrix Matrix::operator*(const Matrix& other) const {
if (m_Colonnes != other.m_Lignes) {
std::cerr << "Mutiplication impossible car la dimensions des matrices est incompatible" << std::endl;
}
Matrix result(m_Lignes, other.m_Colonnes);
for (std::size_t i = 0; i < m_Lignes; ++i) {
for (std::size_t j = 0; j < other.m_Colonnes; ++j) {
long double sum = 0;
for (std::size_t k = 0; k < m_Colonnes; k++) {
sum += at(i, k) * other.at(k, j);
}
result.at(i, j) = sum;
}
}
return result;
}
static bool IsEqualZero(long double var) {
return std::abs(var) < std::pow(10, -5);
}
void Matrix::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 Matrix::PrintDebug() {
#ifndef NDEBUG
Print();
std::cout << "\n";
#endif
}
void Matrix::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;
}
}
void Matrix::Save(const std::string& fileName) {
std::ofstream out{fileName};
if (!out) {
std::cerr << "Impossible de sauvegarder la matrice !\n";
return;
}
out << m_Lignes << " " << m_Colonnes << "\n";
for (std::size_t i = 0; i < m_Lignes; i++) {
for (std::size_t j = 0; j < m_Colonnes; j++) {
out << at(i, j) << " ";
}
out << "\n";
}
}
void Matrix::Load(const std::string& filename) {
std::ifstream in{filename};
if (!in) {
std::cerr << "Impossible de charger la matrice !\n";
return;
}
in >> m_Lignes >> m_Colonnes;
m_Data.resize(m_Lignes * m_Colonnes);
for (std::size_t i = 0; i < m_Lignes; i++) {
for (std::size_t j = 0; j < m_Colonnes; j++) {
in >> at(i, j);
}
}
}
void Matrix::Transpose() {
for (std::size_t i = 0; i < m_Lignes; i++) {
for (std::size_t j = i; j < m_Colonnes; j++) {
std::swap(at(i, j), at(j, i));
}
}
}
void Matrix::Identity() {
for (std::size_t i = 0; i < m_Lignes; i++) {
for (std::size_t j = i; j < m_Colonnes; j++) {
if (i != j) {
at(i, j) = 0;
} else {
at(i, j) = 1;
}
}
}
}
bool Matrix::IsInversed() const {
for (std::size_t i = 0; i < m_Lignes; ++i) {
std::size_t j;
for (j = 0; j < m_Colonnes; ++j) {
if (!IsEqualZero(at(i, j))) {
break;
}
return false;
}
}
return true;
}
void Matrix::GaussNonJordan(bool reduite) {
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 (at(indice_ligne_maximum, j) != 0) {
r++;
// 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));
}
}
// Pour i de 1 jusqu'à n (On simplifie les autres lignes)
for (std::size_t i = (reduite ? 0 : j); 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])
for (int k = m_Colonnes - 1; k >= 0; k--) {
long double pivot = at(r, j);
long double anul = at(i, j);
at(i, k) = at(i, k) * pivot - at(r, k) * anul;
}
}
}
}
}
}
void Matrix::GaussJordan(bool reduite) {
for (std::size_t i = 0; i < m_Lignes; i++) {
int k = -1;
for (std::size_t j = 0; j < m_Colonnes; j++) {
if (at(i, j) != 0) {
k = j;
break;
}
}
// ligne de 0
if (k == -1)
break;
// on divise la ligne par (i, k)
long double annul = at(i, k);
for (int j = 0; j < m_Colonnes; j++) {
at(i, j) /= annul;
}
}
}
long double& Matrix::operator[](std::size_t indice) {
return m_Data[indice];
}
long double& Matrix::at(std::size_t ligne, std::size_t colonne) {
return m_Data[ligne * m_Lignes + colonne];
}
long double Matrix::at(std::size_t ligne, std::size_t colonne) const {
return m_Data[ligne * m_Lignes + colonne];
}

252
src/Matrix.h
View File

@@ -1,256 +1,48 @@
#pragma once #pragma once
#include <algorithm> #include <string>
#include <cmath>
#include <fstream>
#include <iostream>
#include <vector> #include <vector>
template <typename T>
static bool EqualZero(T var) {
return std::abs(var) < std::pow(10, -5);
}
template <typename T>
class Matrix { class Matrix {
private: private:
std::size_t m_Lignes; std::size_t m_Lignes;
std::size_t m_Colonnes; std::size_t m_Colonnes;
std::size_t m_Dimension; std::size_t m_Dimension;
std::vector<T> m_Data; std::vector<long double> m_Data;
public: public:
Matrix(const std::string& fileNameInput) { Matrix(const std::string& fileNameInput);
Load(fileNameInput); Matrix(std::size_t lignes, std::size_t colonnes);
} Matrix(std::size_t lignes, std::size_t colonnes, std::initializer_list<long double>&& initList);
Matrix(std::size_t lignes, std::size_t colonnes) : m_Lignes(lignes), m_Colonnes(colonnes), m_Dimension(lignes * colonnes) { ~Matrix();
m_Data.resize(m_Dimension);
}
Matrix(std::size_t lignes, std::size_t colonnes, std::initializer_list<T>&& initList) :
m_Lignes(lignes), m_Colonnes(colonnes), m_Dimension(lignes * colonnes) {
m_Data = initList;
m_Data.resize(m_Dimension);
}
~Matrix() {}
Matrix operator*(const Matrix& other) const { Matrix operator*(const Matrix& other) const;
if (m_Colonnes != other.m_Lignes) {
std::cerr << "Mutiplication impossible car la dimensions des matrices est incompatible" << std::endl;
}
Matrix result(m_Lignes, other.m_Colonnes); void GaussNonJordan(bool reduite);
for (std::size_t i = 0; i < m_Lignes; ++i) { void GaussJordan(bool reduite);
for (std::size_t j = 0; j < other.m_Colonnes; ++j) {
T sum = 0;
for (std::size_t k = 0; k < m_Colonnes; k++) {
sum += at(i, k) * other.at(k, j);
}
result.at(i, j) = sum;
}
}
return result;
}
void Print() const { 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 PrintDebug() { void PrintDebug();
#ifndef NDEBUG
Print();
std::cout << "\n";
#endif
}
void Insert() { 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;
}
}
void Save(const std::string& fileName) { void Save(const std::string& fileName);
std::ofstream out{fileName};
if (!out) {
std::cerr << "Impossible de sauvegarder la matrice !\n";
return;
}
out << m_Lignes << " " << m_Colonnes << "\n";
for (std::size_t i = 0; i < m_Lignes; i++) {
for (std::size_t j = 0; j < m_Colonnes; j++) {
out << at(i, j) << " ";
}
out << "\n";
}
}
void Load(const std::string& filename) { void Load(const std::string& filename);
std::ifstream in{filename};
if (!in) {
std::cerr << "Impossible de charger la matrice !\n";
return;
}
in >> m_Lignes >> m_Colonnes;
m_Data.resize(m_Lignes * m_Colonnes);
for (std::size_t i = 0; i < m_Lignes; i++) {
for (std::size_t j = 0; j < m_Colonnes; j++) {
in >> at(i, j);
}
}
}
void Transpose() { void Transpose();
for (std::size_t i = 0; i < m_Lignes; i++) {
for (std::size_t j = i; j < m_Colonnes; j++) {
std::swap(at(i, j), at(j, i));
}
}
}
void Identity() { void Identity();
for (std::size_t i = 0; i < m_Lignes; i++) {
for (std::size_t j = i; j < m_Colonnes; j++) {
if (i != j) {
at(i, j) = 0;
} else {
at(i, j) = 1;
}
}
}
}
bool IsInverse(const Matrix& mat, const Matrix& aug) const { bool IsInversed() const;
Matrix result = mat * aug;
for (std::size_t i = 0; i < m_Lignes; ++i) { long double& operator[](std::size_t indice);
for (std::size_t j = 0; j < m_Colonnes; ++j) {
if ((i == j && !EqualZero(result.at(i, j) - 1.0)) || (i != j && EqualZero(result.at(i, j)))) {
return false;
}
}
}
return true;
}
Matrix GaussNonJordan(bool reduite, bool augmentee) { long double& at(std::size_t ligne, std::size_t colonne);
Matrix<float> aug = Matrix(m_Lignes, m_Colonnes);
if (augmentee) {
std::size_t choix;
std::cout
<< "Entrez 1 pour rentrer la matrice augmentee que je vous voulez ou 2 pour la matrice augmentee Id pour trouver "
"l'inverse si elle existe."
<< std::endl;
std::cin >> choix;
while (choix != 1 && choix != 2) {
std::cout
<< "Entrez 1 pour rentrer la matrice augmentee que je vous voulez ou 2 pour la matrice augmentee Id pour trouver "
"l'inverse si elle existe."
<< std::endl;
std::cin >> choix;
}
if (choix == 1) {
std::cout << "Rentrez les coefficients de la matrice" << std::endl;
aug.Insert();
} else {
aug.Identity();
}
}
aug.Print();
int r = -1;
for (std::size_t j = 0; j < m_Colonnes; j++) {
std::size_t indice_ligne_maximum = r + 1;
// Recherche maximum long double at(std::size_t ligne, std::size_t colonne) const;
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 (at(indice_ligne_maximum, j) != 0) {
r++;
// 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));
// matrice augmentee
std::swap(aug.at(indice_ligne_maximum, k), aug.at(r, k));
}
}
// Pour i de 1 jusqu'à n (On simplifie les autres lignes)
for (std::size_t i = (reduite ? 0 : j); 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])
T anulid = at(i, j);
for (int k = m_Colonnes - 1; k >= 0; k--) {
T pivot = at(r, j);
T anul = at(i, j);
at(i, k) = at(i, k) * pivot - at(r, k) * anul;
// matrice augmentee
aug.at(i, k) = aug.at(i, k) * pivot - aug.at(r, k) * anulid;
}
}
}
}
}
return (aug);
}
Matrix GaussJordan(bool reduite, bool augmentee) {
Matrix<float> aug = GaussNonJordan(reduite, augmentee);
for (std::size_t i = 0; i < m_Lignes; i++) {
int k = -1;
int kaugmentee = -1;
for (std::size_t j = 0; j < m_Colonnes; j++) {
if (at(i, j) != 0) {
k = j;
break;
}
}
// ligne de 0
if (k == -1)
break;
// on divise la ligne par (i, k)
T annul = at(i, k);
for (int j = 0; j < m_Colonnes; j++) {
at(i, j) /= annul;
// augmentee
aug.at(i, j) /= annul;
}
}
return aug;
}
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];
}
}; };
static bool IsEqualZero(long double var);

13
src/main.cpp
View File

@@ -1,13 +1,14 @@
#include "Matrix.h" #include "Matrix.h"
#include <iostream>
void test() { void test() {
Matrix<float> mat{"matrice5x5.mat"}; Matrix mat{"matrice5x5.mat"};
mat.Print(); mat.Print();
// mat.Save("matrice3x3.mat"); // mat.Save("matrice3x3.mat");
std::cout << "sdfdjiofoseifheoiefhoig\n"; std::cout << "sdfdjiofoseifheoiefhoig\n";
mat.Print(); mat.Print();
mat = {"matrice5x5.mat"}; mat = {"matrice5x5.mat"};
mat.GaussJordan(false, true); mat.GaussJordan(false);
std::cout << "\nResultat :\n"; std::cout << "\nResultat :\n";
mat.Print(); mat.Print();
mat.Transpose(); mat.Transpose();
@@ -24,17 +25,11 @@ void prompt() {
std::cin >> colonnes; std::cin >> colonnes;
std::size_t dimension = lignes * colonnes; std::size_t dimension = lignes * colonnes;
std::cout << "Rentrez les coefficients de la matrice" << std::endl; std::cout << "Rentrez les coefficients de la matrice" << std::endl;
Matrix<float> mat(lignes, colonnes); Matrix mat(lignes, colonnes);
mat.Insert(); mat.Insert();
mat.Print(); mat.Print();
Matrix<float> aug = mat.GaussJordan(true, true);
std::cout << std::endl;
std::cout << "Matrice echelonnee reduite" << std::endl;
mat.Print();
std::cout << "Matrice augmentee" << std::endl;
aug.Print();
} }
int main(int argc, char** argv) { int main(int argc, char** argv) {