OPÉRATIONS SUR MATRICES C++

//------------------------------------------------------------ Fichier: matrice.h ------------------------------------------------------------

#ifndef MATRICE_H_INCLUDED
#define MATRICE_H_INCLUDED


class matrice
{
    public:

        // constructeur:
        matrice();

        // méthodes:
        std::string acc(const unsigned int &);
        int entier();
        double reel();
        void couleur();// pour appliquer la couleur utilisée dans l'affichage des matrices.
        void couleur_fin();
        int demande(const std::string & , const bool &);// demande d'un entier en fonction des restrictions liées à une fonction.
        void saisie(const std::string & , std::vector<std::vector<double> > &);// saisie dans un tableau de matrice.
        void addition(const std::vector<std::vector<double> > & , const std::vector<std::vector<double> > & , std::vector<std::vector<double> > & , const int &);// addition/soustraction de matrices, variable operateur: 1=addition , 2=soustraction.
        void transpose(const std::vector<std::vector<double> > & , std::vector<std::vector<double> > &);// transposition d'une matrice.
        void produit_nb(std::vector<std::vector<double> > & , const double &);// multiplication d'une matrice par un nombre.
        void produit_mat(const std::vector<std::vector<double> > & , const std::vector<std::vector<double> > & , std::vector<std::vector<double> > &);// réalisation du produit matriciel ordinaire.
        double determinant_carre(const std::vector<std::vector<double> > &);// déterminant d'une matrice carrée via la méthode de Leibniz.
        double inversion(std::vector<std::vector<double> > &);// inversion d'une matrice (carrée).
        void affiche(const std::string &, std::vector<std::vector<double> > &);

};

#endif

//----------------------------------------------------------------------------------------------------------------------------------------------

//------------------------------------------------------------ Fichier: matrice.cpp ------------------------------------------------------------

#include <iostream>
#include <vector>
#include <sstream>
#include <cmath>

#ifdef _WIN32// si système windows...
#include <windows.h>// pour la coloration.
#endif

#include "matrice.h"


//-- CONSTRUCTEUR --

matrice::matrice(){}

//--FIN DU CONSTRUCTEUR --

//-- METHODES --


#ifdef _WIN32// si système windows...
void matrice::couleur()
{
    HANDLE hConsole;
    hConsole=GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_INTENSITY);
}

void matrice::couleur_fin()
{
    HANDLE hConsole;
    hConsole=GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
}

// ces 2 fonctions ci-dessus nécessite windows.h

std::string matrice::acc(const unsigned int & choix)// demande d'accent.
{
    if(choix==1){return "\x85";}// a accent grave.
    if(choix==2){return "\x82";}// e accent aigu.
    if(choix==3){return "\x88";}// e accent circonflexe.
    if(choix==4){return "n""\xA7";}// caractère numéro.
}

#elif linux// si système linux...
void matrice::couleur()
{
    std::cout<<"\033[31m";
}

void matrice::couleur_fin()
{
    std::cout<<"\033[0m";
}

std::string matrice::acc(const unsigned int & choix)
{
    if(choix==1){return "à";}// a accent grave.
    if(choix==2){return "é";}// e accent aigu.
    if(choix==3){return "ê";}// e accent circonflexe.
    if(choix==4){return "n°";}// caractère numéro.
}

#else// pour les autres...
void matrice::couleur(){}
void matrice::couleur_fin(){}

std::string matrice::acc(const unsigned int & choix)
{
    if(choix==1){return "a";}// a accent grave.
    if(choix==2 || choix==3){return "e";}// e accent aigu et e accent circonflexe.
    if(choix==4){return "- ";}// caractère numéro.
}

#endif




int matrice::entier()// demande d'un entier.
{
    std::string saisie;
    std::string verif;

    bool good=1;
    bool trouble=0;
    int num;

    do
    {
        if(good==0)
        {
            std::cout<<std::endl;
            couleur();
            std::cout<<"->";
            couleur_fin();
            std::cout<<" Saisie incorrecte, ressaisissez: ";
        }

        std::cin>>saisie;

        std::istringstream iss(saisie);// conversion du type string en type double.
        iss>>num;
        if(iss.fail())// lorsqu'on insère uniquement des caractère lettre, le passage dans un type numérique ==> 0 , ce qui ne déclenche aucune erreur par la suite, d'où l'instauration du iss.fail().
        {
            good=0;
            trouble=1;
        }
        else// le cas où il n'y a pas que des caractères lettre, mais des caractères numériques suivit de lettres puis à nouveau de chiffres.
        {
            std::ostringstream oss;
            oss<<num;
            verif=oss.str();

            if(verif.size() < saisie.size())// lors du passage dans la variable num, les caractères autres que numérique sont enlevés (ainsi que ce qu'il y a après), par conséquent la taille des 2 strings en est différente.
            {
                good=0;
                trouble=1;
            }
            else{good=1;}
        }

        if(good==1 && trouble==1)
        {
            std::cout<<"-> OK!"<<std::endl;
        }

    }while(good==0);

    return num;
}




double matrice::reel()// demande d'un réel (utile pour le facteur multiplicateur...)
{
    std::string saisie;
    std::string verif;

    size_t found;
    bool good=1;
    bool trouble=0;
    double num;

    do
    {
        if(good==0)
        {
            std::cout<<std::endl;
            couleur();
            std::cout<<"->";
            couleur_fin();
            std::cout<<" Saisie incorrecte, ressaisissez: ";
        }

        std::cin>>saisie;

        found=saisie.find_first_of(",");
        while (found!=std::string::npos)
        {
            saisie[found]='.';// les virgules françaises seront automatiquement transformées en point.
            found=saisie.find_first_of(",",found+1);
        }

        std::istringstream iss(saisie);// conversion du type string en type double.
        iss>>num;
        if(iss.fail())
        {
            good=0;
            trouble=1;
        }
        else
        {
            std::ostringstream oss;
            oss<<num;
            verif=oss.str();

            if(verif.size() < saisie.size())
            {
                good=0;
                trouble=1;
            }
            else{good=1;}
        }

        if(good==1 && trouble==1)
        {
            std::cout<<"-> OK!"<<std::endl;
        }

    }while(good==0);

    return num;
}




int matrice::demande(const std::string &indic , const bool &stop)// demande d'un entier en fonction des restrictions liées à une fonction.
{
    int z;
    bool good=1;
    std::cout<<indic;
    do
    {
        z=entier();
        if((stop==0 && z<1) || (stop==1 && z<2))
        {
            std::cout<<std::endl;
            couleur();
            std::cout<<"->";
            couleur_fin();
            std::cout<<" La valeur minimum est "<<stop+1<<" , ressaisissez: ";
            if(good==1){good=0;}
        }
    }while((stop==0 && z<1) || (stop==1 && z<2));

    if(good==0){std::cout<<std::endl;}

    return z;
}




void matrice::saisie(const std::string &nom_mat , std::vector<std::vector<double> > &mat)// saisie dans un tableau de matrice.
{
    std::cout<<std::endl<<"Entrer les valeurs de la matrice "<<nom_mat<<" :";
    int unites,div=0,rajout;
    for(unsigned int j=0;j<mat[0].size();j++)// étant donné que je commence par les colonnes, je suis obligé de choisir une ligne manuellement (chaque ligne ayant le même nombre de colonne, cela ne pose aucun problème, on aurait même pu faire cela partout).
    {
        if(j+1>=10)// début de présentation (... la force de l'esthétisme ...).
        {
            div=0;
            unites=j+1;
            do
            {
                unites=unites/10;
                div++;
            }while(unites>=10);
        }

        std::cout<<std::endl<<"_________________________________";

        if(div>0)
        {
            rajout=0;
            do
            {
                std::cout<<"_";
                rajout++;
            }while(rajout<div);
        }

        std::cout<<std::endl<<"Matrice "<<nom_mat<<"  |          Colonne "<<acc(4)<<j+1<<std::endl;

        std::cout<<"-----------|---------------------";

        if(div>0)
        {
            rajout=0;
            do
            {
                std::cout<<"-";
                rajout++;
            }while(rajout<div);
        }
        std::cout<<std::endl;

        // fin de présentation, ==> insertion.

        std::string saisie;
        std::string verif;

        size_t found;
        bool good=1;

        for(unsigned int i=0;i<mat.size();i++)
        {
            std::cout<<"           | Ligne "<<acc(4)<<i+1<<":   ";
            do
            {
                if(good==0)// en cas d'erreur de saisie...
                {
                    couleur();// on applique la couleur rouge.
                    std::cout<<">RESSAISIR";
                    couleur_fin();// on arrête d'appliquer la couleur.
                    std::cout<<" | Ligne "<<acc(4)<<i+1<<":   ";
                }

                std::cin>>saisie;

                found=saisie.find_first_of(",");
                while (found!=std::string::npos)
                {
                    saisie[found]='.';// les virgules françaises seront automatiquement transformées en point.
                    found=saisie.find_first_of(",",found+1);
                }

                std::istringstream iss(saisie);// conversion du type string en type double.
                iss>>mat[i][j];
                if(iss.fail())// lorsqu'on insère uniquement des caractère lettre, le passage dans un type numérique ==> 0 , ce qui ne déclenche aucune erreur par la suite, d'où l'instauration du iss.fail().
                {
                    good=0;
                }
                else// le cas où il n'y a pas que des caractères lettre, mais des caractères numériques suivit de lettres puis à nouveau de chiffres.
                {
                    std::ostringstream oss;
                    oss<<mat[i][j];
                    verif=oss.str();

                    if(verif.size() < saisie.size())// lors du passage dans la variable num, les caractères autres que numérique sont enlevés (ainsi que ce qu'il y a après), par conséquent la taille des 2 strings en est différente.
                    {
                        good=0;
                    }
                    else{good=1;}
                }

            }while(good==0);
        }
    }
}




void matrice::addition(const std::vector<std::vector<double> > &A , const std::vector<std::vector<double> > &B , std::vector<std::vector<double> > &C , const int &operateur)// addition/soustraction de matrices, variable operateur: 1=addition , 2=soustraction.
{
    for(unsigned int i=0;i<A.size();i++)
    {
        for(unsigned int j=0;j<A[i].size();j++)
        {
            if(operateur==1)
            {
                C[i][j]=A[i][j]+B[i][j];
            }

            if(operateur==2)
            {
                C[i][j]=A[i][j]-B[i][j];
            }
        }
    }
}




void matrice::transpose(const std::vector<std::vector<double> > &A , std::vector<std::vector<double> > &B)// transposition d'une matrice.
{
    for(unsigned int i=0;i<A.size();i++)
    {
        for(unsigned int j=0;j<A[i].size();j++)
        {
            B[j][i]=A[i][j];
        }
    }
}




void matrice::produit_nb(std::vector<std::vector<double> > &A , const double &facteur)// multiplication d'une matrice par un nombre.
{
    for(unsigned int i=0;i<A.size();i++)
    {
        for(unsigned int j=0;j<A[i].size();j++)
        {
            A[i][j]=facteur*A[i][j];
        }
    }
}




void matrice::produit_mat(const std::vector<std::vector<double> > &A , const std::vector<std::vector<double> > &B , std::vector<std::vector<double> > &C)// réalisation du produit matriciel ordinaire.
{
    unsigned int v;
    for(unsigned int i=0;i<C.size();i++)
    {
        for(unsigned int j=0;j<C[i].size();j++)// si vous êtes tentés de prendre A.size() avec B[i].size() au lieu de C.size() avec C[i].size() , vous courrez à l'erreur de segmentation...
        {
            C[i][j]=0;
            v=0;
            do
            {
                C[i][j]=C[i][j]+A[i][v]*B[v][j];
                v++;
            }while(v<B.size());// tant que le nombre de colonne de la matrice A ou le nombre de ligne de la matrice B...(ici le choix a été porté sur le nombre de ligne de la matrice B).
        }
    }
}




double matrice::determinant_carre(const std::vector<std::vector<double> > &mat)// déterminant d'une matrice carrée via la méthode de Leibniz.
{
    if(mat.size()==2){return mat[0][0]*mat[1][1]-mat[1][0]*mat[0][1];}

    double det=0,v;
    unsigned int o=0,j;
    int i;

    do
    {
        i=o,j=0,v=1;

        do
        {
            v=v*mat[i][j];
            i++;
            j++;
            if(i>=mat.size()){i=0;}// on remonte après être arrivé en bas de la matrice.
        }while(j<mat[i].size());

        det=det+v;
        o++;
    }while(o<mat.size());

    o=0;
    do
    {
	i=o,j=0,v=1;

    	do
        {
            v=v*mat[i][j];
            i--;
            j++;
            if(i<0){i=mat.size()-1;}// on redescend après être arrivé en haut de la matrice.
        }while(j<mat[i].size());

        det=det-v;
        o++;
    }while(o<mat.size());

    return det;
}




void permutation(std::vector<std::vector<double> > &mat , const unsigned int &ligne1 , const unsigned int &ligne2)// cette fonction est définie afin de permutter les lignes dans le calcul d'inverse via la méthode d'élimination de Gauss-Jordan.
{
    std::vector<double> permut(mat[ligne1].size() , 0);// plus ou moins la même façon de penser que lorsqu'on était dans la fonction de saisie, on choisit n'importe quelle ligne de la matrice (il y a le même nombre de colonne à toute les lignes).

	for(unsigned int j=0;j<mat[ligne1].size();j++)
	{
	    permut[j]=mat[ligne1][j];
	    mat[ligne1][j]=mat[ligne2][j];
	    mat[ligne2][j]=permut[j];
	}
}




double matrice::inversion(std::vector<std::vector<double> > &mat)// inversion d'une matrice (carrée).
{
	double det;
	det=determinant_carre(mat);
	if(det==0)
	{
	    return det;// si le déterminant est égal à 0 ==> pas d'inversion possible, on s'arrête là.
	}
	else
	{
        std::vector<std::vector<double> > matmat;
        matmat.resize(mat.size() , std::vector<double>(2*mat[0].size(),0));

        for(unsigned int i=0;i<mat.size();i++)
        {
            for(unsigned int j=0;j<mat[i].size();j++)
            {
                matmat[i][j]=mat[i][j];
            }
        }

        for(unsigned int i=0;i<matmat.size();i++)
        {
            for(unsigned int j=mat[i].size();j<matmat[i].size();j++)
            {
                if(j-i==mat[i].size())
                {
                    matmat[i][j]=1;
                }
                else{matmat[i][j]=0;}
            }
        }// jusqu'ici on a crée une matrice comportant le double de colonne de la matrice initiale, et on a implémenté des 1 en diagonale dans la deuxième moitié.

        unsigned int ii=0;
        unsigned int iii;
        unsigned int iiii;
        double numb3rs;
        do// début de l'application de l'élimination de Gauss-Jordan.
        {
            if(matmat[ii][ii]==0)
            {
                iii=ii;
                do
                {
                    iii++;
                }while(matmat[iii][ii]==0);

                permutation(matmat,ii,iii);// le terme de la diagonale de la première moitié est égal à zéro, comme on aura besoin de diviser par 0, on permute.
            }

            numb3rs=matmat[ii][ii];

            for(unsigned int j=0;j<matmat[ii].size();j++)
            {
                matmat[ii][j]=matmat[ii][j]/numb3rs;
            }

            iiii=1;
            iii=ii;
            do
            {
                iii++;
                if(iii==matmat.size()){iii=0;}
                iiii++;
                numb3rs=matmat[iii][ii];
                for(unsigned int j=0;j<matmat[iii].size();j++)
                {
                    matmat[iii][j]=matmat[iii][j]-(numb3rs*matmat[ii][j]);
                }
            }while(iiii<matmat.size());

            ii++;

        }while(ii<matmat.size());// fin de l'application de l'élimination de Gauss-Jordan.

	    for(unsigned int i=0;i<matmat.size();i++)// on place la deuxième moitié de la matrice matmat (qui après élimination G-J n'est plus une suite de 1 et de 0) dans la matrice initiale...
        {
	        for(unsigned int j=mat[i].size();j<matmat[i].size();j++)
	        {
        	    mat[i][j-mat[i].size()]=matmat[i][j];
	        }
        }
	}
	return det;
}




void matrice::affiche(const std::string &nom_mat, std::vector<std::vector<double> > &mat)
{
    int significatif=0;
    std::vector<bool> signe(mat[0].size(),0);//signe du plus long chiffre (par colonne).
    std::vector<double> chiffre(mat[0].size(),0);//plus long chiffre (par colonne).
    bool reel=0;

    for(unsigned int i=0;i<mat.size();i++)
    {
        for(unsigned int j=0;j<mat[i].size();j++)
        {
            if(mat[i][j]==-0){mat[i][j]=0;}// on commence par éliminer ce qui est nuisible à une bonne présentation.

            if(mat[i][j]>=0 && chiffre[j]<mat[i][j])// on répertorie les plus longs chiffres par colonne ainsi que la présence ou non d'un signe associé.
            {
                chiffre[j]=mat[i][j];
                signe[j]=0;
            }

            if(mat[i][j]<0 && chiffre[j]<-1*mat[i][j])
            {
                chiffre[j]=-1*mat[i][j];
                signe[j]=1;
            }

            if(reel==0 && mat[i][j]-floor(mat[i][j])>0.0000000000001)// on détecte si tout les chiffres sont des entier, si ce n'est pas le cas on indiquera le nombre de chiffre significatif.
            {
                reel=1;
            }
        }
    }

    if(reel==1)
    {
        std::cout<<std::endl<<std::endl<<"--> Il existera au moins un nombre qui ne sera pas un entier, choisissez un nombre de chiffre significatif (entre 0 et 10): ";

        do
        {
            significatif=entier();// on indique le nombre de chiffre significatif.
            if(significatif<0 || significatif>10)
            {
                std::cout<<std::endl;
                couleur();
                std::cout<<"->";
                couleur_fin();
                std::cout<<" Choisissez un nombre de chiffre significatif entre 0 et 10: ";
            }
        }while(significatif<0 || significatif>10);
    }

    std::cout<<std::endl<<std::endl<<"===> Matrice "<<nom_mat<<" ("<<mat.size()<<"x"<<mat[0].size()<<"):"<<std::endl<<std::endl;

    couleur();

    for(unsigned int i=0;i<mat.size();i++)
    {
        for(unsigned int j=0;j<mat[i].size();j++)
        {

            if(mat[i][j]>=0)
            {
                std::cout<<" ";
            }

            std::cout.precision(significatif);// le nombre de chiffre significatif va être prit en compte ici.
            std::cout<<std::fixed<<mat[i][j];

            if(j+1<mat[i].size())
            {
                if(chiffre[j]>=10)
                {
                    int div_1=0,div_2=0,rajout=0;
                    double unites;

                    if(mat[i][j]>=10 || mat[i][j]<=-10)
                    {
                        unites=mat[i][j];
                        do
                        {
                            unites=unites/10;
                            div_1++;
                        }while(unites>=10 || unites<=-10);
                    }

                    unites=chiffre[j];
                    do
                    {
                        unites=unites/10;
                        div_2++;
                    }while(unites>=10);

                    rajout=div_2-div_1;

                    int rajoute=0;
                    if(rajout>0)
                    {
                        do
                        {
                            std::cout<<" ";
                            rajoute++;
                        }while(rajoute<rajout);
                    }
                }

                std::cout<<"   |  ";

            }
            else
            {
                std::cout<<std::endl;
            }
        }
    }

    couleur_fin();
}

//--FIN DES METHODES--

//-------------------------------------------------------------------------------------------------------------------------------------------

//------------------------------------------------------------ Fichier: main.cpp ------------------------------------------------------------

#include <iostream>
#include <vector>// rappel même si inutile car déjà dans matrice.cpp
#include "matrice.h"


int main()
{
    std::cout<<">----------------------- OPERATIONS SUR MATRICES -----------------------<"<<std::endl<<std::endl;

    int quitter=0;//pour le "quitter" de fin.
    int choix;
    int Aligne , Acolonne , Bligne , Bcolonne;
    double facteur;
    double det;

    matrice mat;

    do//pour le "quitter" de fin.
    {
        std::cout<<"--------------------  MENU  --------------------"<<std::endl<<std::endl;

        std::cout<<"     1. Addition de 2 matrices"<<std::endl;
        std::cout<<"     2. Soustraction de 2 matrices (A-B)"<<std::endl;
        std::cout<<"     3. Produit de 2 matrices"<<std::endl;
        std::cout<<"     4. Produit d'une matrice par un nombre"<<std::endl;
        std::cout<<"     5. Transpos"<<mat.acc(2)<<"e d'une matrice"<<std::endl;
        std::cout<<"     6. D"<<mat.acc(2)<<"terminant d'une matrice carr"<<mat.acc(2)<<"e"<<std::endl;
        std::cout<<"     7. Inversion d'une matrice"<<std::endl;
        std::cout<<"     8. Division de 2 matrices (A/B)"<<std::endl<<std::endl;
        std::cout<<"     0. ) Quitter ("<<std::endl;

        std::cout<<std::endl<<"-> Choix "<<mat.acc(4);

        do
        {
            choix=mat.entier();
            if(choix<0 || choix>8)
            {
                std::cout<<std::endl;
                mat.couleur();
                std::cout<<"->";
                mat.couleur_fin();
                std::cout<<" Le choix "<<mat.acc(4)<<choix<<" n'existe pas, ressaisissez: ";
            }
        }while(choix<0 || choix>8);

        if(choix==0)
        {
            std::cout<<std::endl<<">------------------------------------------------------------<"<<std::endl<<std::endl;
            return 0;
        }

        std::cout<<std::endl;

        std::vector<std::vector<double> > mat_A;
        std::vector<std::vector<double> > mat_B;
        std::vector<std::vector<double> > mat_C;

        do
        {
            if(choix>=6)
            {
                Aligne=mat.demande("Indiquer le nombre de ligne (>=2) de votre matrice A:   ",1);
                std::cout<<std::endl;
                Acolonne=mat.demande("Indiquer le nombre de colonne (>=2) de votre matrice A: ",1);
            }
            else
            {
                Aligne=mat.demande("Indiquer le nombre de ligne (>=1) de votre matrice A:   ",0);
                std::cout<<std::endl;
                Acolonne=mat.demande("Indiquer le nombre de colonne (>=1) de votre matrice A: ",0);
            }


            if(choix<=3)
            {
                std::cout<<std::endl;
                Bligne=mat.demande("Indiquer le nombre de ligne (>=1) de votre matrice B:   ",0);
                std::cout<<std::endl;
                Bcolonne=mat.demande("Indiquer le nombre de colonne (>=1) de votre matrice B: ",0);

            }

            if(choix==8)
            {
                std::cout<<std::endl;
                Bligne=mat.demande("Indiquer le nombre de ligne (>=2) de votre matrice B:   ",1);
                std::cout<<std::endl;
                Bcolonne=mat.demande("Indiquer le nombre de colonne (>=2) de votre matrice B: ",1);

            }

            if(choix==4)
            {
                std::cout<<std::endl;
                std::cout<<"Indiquer le facteur multiplicateur:                     ";
                facteur=mat.reel();
            }

            if((choix<=2 && (Aligne!=Bligne || Acolonne!=Bcolonne)) || ((choix==3 || choix==8) && Acolonne!=Bligne) || ((choix>=6 && Aligne!=Acolonne) || (choix==8 && Bligne!=Bcolonne)))
            {
                std::cout<<std::endl;
                mat.couleur();
                std::cout<<"->";
                mat.couleur_fin();

                if(choix<=2 && (Aligne!=Bligne || Acolonne!=Bcolonne))
                {
                    std::cout<<" Le nombre de ligne et de colonne de la matrice A doit "<<mat.acc(3)<<"tre "<<mat.acc(2)<<"gal au nombre de ligne et de colonne de la matrice B. Ressaisissez:"<<std::endl<<std::endl;
                }

                if((choix==3 || choix==8) && Acolonne!=Bligne)
                {
                    std::cout<<" Le nombre de colonne de la matrice A doit "<<mat.acc(3)<<"tre "<<mat.acc(2)<<"gal au nombre de ligne de la matrice B. Ressaisissez:"<<std::endl<<std::endl;
                }

                if((choix>=6 && Aligne!=Acolonne) || (choix==8 && Bligne!=Bcolonne))
                {
                    if(choix!=8)
                    {
                        std::cout<<" La matrice doit "<<mat.acc(3)<<"tre carr"<<mat.acc(2)<<"e. Ressaisissez:"<<std::endl<<std::endl;
                    }
                    else
                    {
                        std::cout<<" Les matrices doivent "<<mat.acc(3)<<"tre carr"<<mat.acc(2)<<"es. Ressaisissez:"<<std::endl<<std::endl;
                    }
                }
            }

        }while(((choix==3 || choix==8) && Acolonne!=Bligne) || (choix<=2 && (Aligne!=Bligne || Acolonne!=Bcolonne)) || ((choix>=6 && Aligne!=Acolonne) || (choix==8 && Bligne!=Bcolonne)));


        mat_A.resize(Aligne , std::vector<double>(Acolonne,0));
        mat.saisie("A",mat_A);



        if(choix<=3 || choix==8)
        {

            mat_B.resize(Bligne , std::vector<double>(Bcolonne,0));
            mat.saisie("B",mat_B);
        }


        if(choix<=2)
        {
            mat_C.resize(Aligne , std::vector<double>(Acolonne,0));

            std::string nom="C";
            if(choix==2)
            {
                nom=nom+" (A-B)";
            }

            mat.addition(mat_A,mat_B,mat_C,choix);
            mat.affiche(nom,mat_C);
        }

        if(choix==3)
        {
            mat_C.resize(Aligne , std::vector<double>(Bcolonne,0));


            mat.produit_mat(mat_A,mat_B,mat_C);
            mat.affiche("C",mat_C);
        }

        if(choix==4)
        {
            mat.produit_nb(mat_A,facteur);
            mat.affiche("B",mat_A);
        }

        if(choix==5)
        {
            mat_B.resize(Acolonne , std::vector<double>(Aligne,0));

            mat.transpose(mat_A,mat_B);
            mat.affiche("transposition A",mat_B);
        }

        if(choix==6)
        {
            std::cout<<std::endl<<std::endl<<"Le d"<<mat.acc(2)<<"terminant de la matrice est "<<mat.determinant_carre(mat_A);
        }

        if(choix==7)
        {
            det=mat.inversion(mat_A);
            if(det!=0){mat.affiche("inverse A",mat_A);}
            else
            {
                std::cout<<std::endl<<std::endl<<"Le d"<<mat.acc(2)<<"terminant de la matrice est "<<mat.acc(2)<<"gal "<<mat.acc(1)<<" 0, il est donc impossible de l'inverser."<<std::endl;
            }
        }

        if(choix==8)
        {
            det=mat.inversion(mat_B);

            if(det!=0)
            {
                mat_C.resize(Aligne , std::vector<double>(Bcolonne,0));
                mat.produit_mat(mat_A,mat_B,mat_C);
                mat.affiche("C",mat_C);
            }
            else
            {
                std::cout<<std::endl<<std::endl<<"Le d"<<mat.acc(2)<<"terminant de la matrice B est "<<mat.acc(2)<<"gal "<<mat.acc(1)<<" 0, il est donc impossible de diviser."<<std::endl;
            }
        }

        std::cout<<std::endl<<std::endl<<">------------------------------------------------------------<"<<std::endl;
        std::cout<<std::endl<<"--> Faire un autre calcul de matrice? (1=oui/0=non): ";
        quitter=mat.entier();
        std::cout<<std::endl<<">------------------------------------------------------------<"<<std::endl<<std::endl;

    }while(quitter>0);
    // pas de PAUSE car inutile ici.
    return 0;
}

//-------------------------------------------------------------------------------------------------------------------------------------------