Problème produit matriciel c++

Fermé
clanu Messages postés 1 Date d'inscription dimanche 27 mai 2012 Statut Membre Dernière intervention 27 mai 2012 - 27 mai 2012 à 23:18
Bonjour,

Je débute en c++ et suis étudiant, j'ai à réaliser un programme utilisant la méthode de décomposition de matrice de Cholesky LLt.
Le problème est au niveau des boucles for de l'algorithme (donc fonction algo_cholesky) où je veux faire des produits de deux matrices mais j'ai l'erreur suivante :
invalid operands of types int* and int* to binary operator *

J'en déduis que c'est à cause du fait que mes matrices sont en int** mais même en ayant testé autre chose ça ne fonctionne pas :/

Mon code entier est (vous pouvez vous servir pour les autres fonctions si ça vous intéresse ;) )


#include <iostream>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <string>
using namespace std;



//*************Déclaration d'une matrice******************//
int **allouer_matrice (int ligne, int colonne)
{
int i;

int **matrice = new int *[ligne];


for(i=0;i<ligne;i++)
{
matrice [i]= new int [colonne];

}
if(matrice == NULL)
{
exit(EXIT_FAILURE);
}
return matrice;
}


//************Remplir une matrice **********************//

void remplir_matrice (int ligne, int colonne, int **matrice)
{
int i,j;

for(i=0;i<ligne;i++)
{
for(j=0;j<colonne;j++)
{
cout<<"Rentrez la valeur de m "<<i+1<<","<<j+1<<" = ";
cin >> matrice [i][j];
}
}
}

//*****************Affichage matrice *******************//

void afficher_Matrice(int ligne,int colonne,int **matrice)
{
int i,j;

for(i=0;i<ligne;i++)
{
for(j=0;j<colonne;j++)
{
cout<< matrice [i][j]<<"\t";
}
cout<< endl;

}
cout<<"\n"<<endl;
}

//*****************Matrice Nulle *************************//

void matrice_nulle (int ligne, int colonne, int **matrice)
{
int i,j;

for(i=0;i<ligne;i++)
{
for(j=0;j<colonne;j++)
{
matrice [i][j]=0;
}
}
}

//*****************Désallocation mémoire matrice **********//

void vider_matrice(int **matrice)
{
delete[] matrice;
}


//***************Transposer une matrice********************//

void transposer_matrice(int **matrice1, int **matrice2, int ligne, int colonne)
{
int i,j ;

for(i=0; i<ligne; i++)
{
for(j=0; j<colonne; j++)
{
matrice2[j][i] = matrice1[i][j];
}
}
}


//***************Algorithme de Cholesky ********************//

void algo_cholesky(int ligne, int colonne, int **matrice_A)
{
int i,j, **matrice_L, **matrice_Lt, L_kj, L_kj_L_ij;
matrice_L=allouer_matrice(ligne, colonne);
matrice_Lt=allouer_matrice(ligne, colonne);
matrice_nulle(ligne, colonne, matrice_L);
matrice_nulle(ligne, colonne, matrice_Lt);
cout<<"La matrice L avant remplissage est \n"<<endl;
afficher_Matrice(ligne, colonne, matrice_L);
L_kj=0;
L_kj_L_ij=0;
for (i=0 ; i<ligne ; i++)
{
L_kj+=matrice_L[i] * matrice_L[i];
matrice_L [i][j] = sqrt( matrice_A[i][j]- L_kj);

for (j=1; j<colonne; j++)
{
L_kj_L_ij+=matrice_L[i]* matrice_L[j];
matrice_L [j][i]= (matrice_A[j][i] -L_kj_L_ij )/matrice_L[i][i];

}
}

transposer_matrice(matrice_L, matrice_Lt, ligne, colonne);
cout<<"La matrice L est \n"<<endl;
afficher_Matrice(ligne, colonne, matrice_L);
cout<<"La matrice Lt est \n"<< endl;
afficher_Matrice(ligne, colonne, matrice_Lt);
}
//*****************Programme Principale********************//
int main()

{
int lignes, colonnes;

cout<<"Tapez le nombre de ligne de la matrice" << endl;
cin >> lignes;
cout<<"Tapez le nombre de colonnes de la matrice" << endl;
cin >> colonnes;

int **matrices1= NULL;
//int **matrices2= NULL;

matrices1 = allouer_matrice (lignes, colonnes);
remplir_matrice (lignes, colonnes, matrices1);
cout<< "\nLa matrice obtenue est la suivante :"<<endl;

afficher_Matrice(lignes, colonnes, matrices1);

//int v;
//cout<<"Desirez vous vider la memoire allouee a la matrice?"<< endl;
//cout<<"OUI : 1 \nNON : 0"<<endl;
// cin >> v;
//if (v == 1) vider_matrice (matrices);
//else cout<<"Les donnees sont conservees, attention a la memoire !"<<endl;

algo_cholesky(lignes,colonnes,matrices1);


}


Voilà si quelqu'un a une idée pour sortir de cette impasse qui me bloque (et m'énerve passablement).

Merci d'avance !