Matrice inverse et determinant en C++

Bonjour,
j'ai un projet sons visual C++ et je manipule les matrices de grandes tailles ( 50 x 50 ) minimum , actuellement j'ai crée une classe matrice.h dans laquelle j'écris mes fonctions;
depuis hier je n'arrive pas à écrire la fonction qui calcule le déterminant d'une matrice carrée ainsi que la matrice inverse d'une matrice donnée.
j'ai copié des codes sur internet et ca ne me donne pas des résultats juste.
pour cela , est ce que quelqu'un pourrait m'aider à trouver un bon code pouvant résoudre mon problème.
je vous prie ,quelqu'un aurait un code écris en C++ qui m'aiderais?
voici le mon code sur la classe matrice; quelqu'un pourrais le corriger


merci d'avance

#ifndef matrice_h
#define matrice_h
//#include <cstdlib>
#include <string>
#include <iostream>
#include <fstream>
//#include <limits>
#include <iomanip>
#include <string>
#include <vector>
#include <windows.h>
#include <stdio.h>
#include <algorithm>

using namespace std;

class Matrice
{
int M;
int N;
vector<float> contenu;
public:
// initialisation de la taille de la matrice à zero
Matrice(){
M=0;
N=0;
}
// declaration d'une matrice
Matrice( int lig,int col, float val=0){
M=lig;
N=col;
contenu.resize(M*N,val);
}

// permet de retourner la talle N de la matrice
int getN(){
return N;
}

// permet de retourner la talle N de la matrice
int getM(){
return M;
}

// declaration de l operateur ()
float operator()(int i,int j)const{
return contenu[i*N+j];
}

// declaration de l operateur recuperant sa valeur
float &operator()(int i,int j){
return contenu[i*N+j];
}

// initialisation des elements d'une matrice
void initialize( int lig,int col, float val=0){
M=lig;
N=col;
contenu.clear();
contenu.resize(M*N,val);
}

// operateur d'addition d une matrice par une autre matrice
Matrice operator+( Matrice mat){
//int K=mat.N;
Matrice out=mat;

for(int i=0;i< contenu.size() ;i++)
{
out.contenu[i]=out.contenu[i]+contenu[i];

}
return out;
}

// operateur de division d une matrice par un element
Matrice operator/( float d ){

Matrice out=*this;

for(int i=0;i< contenu.size() ;i++)
{
out.contenu[i]=out.contenu[i]/d;

}
return out;
}

// operateur de multiplication d une matrice par un element
Matrice operator*( float d ){

Matrice out=*this;

for(int i=0;i< contenu.size() ;i++)
{
out.contenu[i]=out.contenu[i]*d;

}
return out;
}

// operateur d' addition d une matrice par un element
Matrice operator+( float d ){

Matrice out=*this;

for(int i=0;i< contenu.size() ;i++)
{
out.contenu[i]=out.contenu[i]+d;

}
return out;
}

// operateur de soustraction d une matrice par un element
Matrice operator-( float d ){

Matrice out=*this;

for(int i=0;i< contenu.size() ;i++)
{
out.contenu[i]=out.contenu[i]-d;

}
return out;
}

//operateur de multiplication d'une matrice par une autre matrice
Matrice operator*( Matrice mat){
int K=mat.N;
Matrice out(M,K);

for(int i=0;i<M;i++)
{
for(int j=0;j<K;j++)
{
for (int l=0;l<N;l++)
{
out(i,j)=out(i,j)+contenu[i*N+l]*mat(l,j);
}
}

}
return out;
}

// Moyenne d'une matrice

vector<float> moyenne(){
vector<float> out(N);
Matrice mat= transpose();
for(int i=0;i<N;i++)
{
for (int l=0;l<M;l++)
{
out[i]=out[i]+ mat(i,l);
}
out[i]=out[i]/M;
}
return out;
}

// affichage d'une matrice
void afficher(){
for(int i=0;i<M;i++)
{
for(int j=0;j<N;j++)
{
printf("%f\t",contenu[i*N+j]);
}
cout<<endl<<endl;
}
}

// transposer d'une matrice
Matrice transpose(){
Matrice out(N,M);

for(int i=0;i<N;i++)
{
for(int j=0;j<M;j++)
{
out(i,j)=contenu[j*N+i];
}

}
return out;
}

// Matrice identite
Matrice identite(){
Matrice out=*this;


if (M==N){

out.initialize(M,N,0.0);
for (int i=0;i<M;i++)

out.contenu[i*(M+1)]=1.0;
}
return out;
}


float trace() const
{
if (M==N){
float tr=0.0;
for (int i=0;i<N;i++)
tr=tr+contenu[i*(1+N)];

return tr;
}
else
return 0;
}

Matrice inverse(){
if (M!=N)
{
cout<<"inversion de matrices non carrées non implémentées!\n"<<endl;
return *this;
}
Matrice MM,M1,Mi1,Minv;// déclaration de matrices de taille identique à celle à inverser
MM=*this;// copie de la matrice à inverser
M1=MM;

Mi1.initialize(M,N,0) ;//Mi1 est maintenant une matrice identité
Minv=Mi1.identite();
for (int i=0;i<M;i++)
{
for (int j=0;j<M;j++)
{
if (MM.contenu[i*N+i]==0)
{
cout<<"inversion pivot GAUSS impossible : division par 0\n"<<endl;
return *this;
}
M1.contenu[i*N+j]=MM.contenu[i*N+j]/MM.contenu[i*N+i];
Mi1.contenu[i*N+j]=Minv.contenu[i*N+j]/(MM.contenu[i*N+i]);
}
MM=M1;
Minv=Mi1;
for (int k=0;k<M;k++)// mise zéros de la colonne
if (k!=i)
for (int j=0;j<M;j++)
{
M1.contenu[k*N+j]=MM.contenu[k*N+j]-MM.contenu[i*N+j]*MM.contenu[k*N+i];
Mi1.contenu[k*N+j]=Minv.contenu[k*N+j]-Minv.contenu[i*N+j]*MM.contenu[k*N+i];
}
MM=M1;
Minv=Mi1;

}
*this=Minv;
return *this;
}

// matrice de wishart d une matrice
Matrice wishart(){
Matrice out=*this;
vector<float>moy=moyenne();
for(int i=0;i<M;i++)
{
for (int j=0;j<N;j++)
{
out(i,j)=out(i,j)-moy[j];
}

}
return out.transpose()*out;

}

// renvoie la valeur d une matrice de wishart
void Towishart(){
*this = wishart();
}

//Centrer les element d une colonne d une matrice
Matrice centrer(){
Matrice out=*this;
vector<float>moy=moyenne();
for(int i=0;i<M;i++)
{
for (int j=0;j<N;j++)
{
out(i,j)=out(i,j)-moy[j];
}

}
return out;

}

// calcul la somme des elements d une matrice
float somme(){
float som=0;
int val=contenu.size();

for(int i=0;i<val;i++)
{
som=som+contenu[i];
}

return som;
}
};
#endif