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 !
Afficher la suite