Calcul matriciel en C: multiplication, division, addition et soustraction

Les opérations arithmétiques sur les matrices : addition, soustraction, multiplication et division, puissance, ainsi que le calcul de la transposée, l'inverse et le déterminant.

/*
* www.codeurjava.com Copyright - tous droits réservés
*/
using namespace std;

#include<stdio.h>

#include<stdlib.h>

#include <iostream>

typedef struct matrice
{
int ligne;
int colonne;
float data[99][99];
}matrice;

void afficher_matrice(matrice M){
for(int i = 0; i < M.ligne; i++) {
for(int j = 0; j < M.colonne; j++) {
cout << M.data[i][j] ;
cout << "\t";
}
//retour à la ligne
cout << "\n";
}
cout << "\n";
}

//Additionner A et B
struct matrice addition(matrice A, matrice B)
{
matrice C;
C.ligne = A.ligne;
C.colonne = A.colonne;
if(A.ligne==B.ligne && A.colonne==B.colonne)
{
for (int I = 0; I < A.ligne; I++)
for (int J = 0; J < B.colonne; J++)
{
C.data[I][J] = A.data[I][J] + B.data[I][J];
}
}
else
  printf("Dimensions illegales\n");
return C;
}

//Soustraire B de A
struct matrice soustraction(matrice A, matrice B)
{
matrice C;
C.ligne = A.ligne;
C.colonne = A.colonne;
if(A.ligne==B.ligne && A.colonne==B.colonne)
{
for (int I = 0; I < A.ligne; I++)
for (int J = 0; J < B.colonne; J++)
{
C.data[I][J] = A.data[I][J] + B.data[I][J];
}
}
else
printf("Dimensions illegales\n");
return C;
}

//Produit de A et B
struct matrice produit(matrice A, matrice B)
{
matrice C;
C.ligne = A.ligne;
C.colonne = A.colonne;
for (int I = 0; I < A.ligne; I++)
  for (int J = 0; J < B.colonne; J++)
{
C.data[I][J] = 0;
  for (int K = 0; K < A.colonne; K++)
{
C.data[I][J] += A.data[I][K] * B.data[K][J];
}
}
  return C;
}

//puissance de A
struct matrice puissance(matrice A, int n)
{
matrice C;
C.ligne = A.ligne;
C.colonne = A.colonne;
  for (int I = 0; I < A.ligne; I++)
  for (int J = 0; J < B.colonne; J++)
{
if(A.data[I][J]!=0)
C.data[I][J] = 1;
  for (int K = 0; K < n; K++)
{
C.data[I][J] = C.data[I][J] * A.data[I][J];
}
}
  return C;
}

//Calcul récursif de déterminant
double det(matrice A){
double somme = 0;
int signe;

if(A.ligne==1){//point d'appuis si la taille de la matrice est égale 1
return(A.data[0][0]);
}

for (int i=0;i<A.ligne;i++){
  //trouver le determinant en utilisant le developpement ligne par ligne
//créer une sous matrice qui n'est pas dans la meme ligne et colonne
matrice SM;
SM.ligne = A.ligne-1;
SM.colonne = A.colonne-1;
  for (int a=1;a<A.ligne;a++){
for (int b=0;b<A.ligne;b++){
  if(b<i)
SM.data[a-1][b]=A.data[a][b];
  else if(b>i)
SM.data[a-1][b-1]=A.data[a][b];
}
}
if(i%2==0) //changement de signe est basé sur i
signe=1;
else
signe=-1;
// appel recursif.
somme+=signe*A.data[0][i]*(det(SM));
}
//retourner la valeur final du déterminant
return (somme);
}

//Matrice transposée
matrice transposee(matrice A){
matrice T;
T.ligne = A.colonne;
T.colonne = A.ligne;
for (int i = 0; i < A.ligne; i++)
for (int j = 0; j < A.ligne; j++)
   T.data[j][i] = A.data[i][j];
return T;
}

//Matrice des cofacteurs
matrice coMatrice(matrice A){
matrice T;
T.ligne = A.ligne;
T.colonne = A.colonne;
int signe;

if(A.ligne==1){//point d'appuis si la taille de la matrice est égale 1
  return A;
}

for (int i = 0; i < A.ligne; i++){
for (int j = 0; j < A.colonne; j++){
   //sous matrice
matrice SM;
SM.ligne = A.ligne-1;
SM.colonne = A.ligne-1;
   for (int a=0;a<A.ligne;a++){
for (int b=0;b<A.ligne;b++){
   if(a<i && b<j)
   SM.data[a][b]=A.data[a][b];
   else if(a<i && b>j)
SM.data[a][b-1]=A.data[a][b];
else if(a>i && b<j)
   SM.data[a-1][b]=A.data[a][b];
   else if(a>i && b>j)
SM.data[a-1][b-1]=A.data[a][b];
}
   }
if((i+j)%2==0)
signe = 1;
else
   signe = -1;
if(SM.ligne <= 2 )
T.data[i][j]=signe*(SM.data[0][0]*SM.data[1][1]-SM.data[0][1]*SM.data[1][0]);
else
// appel recursif.
coMatrice(SM);
}
}
return T;
}

//Matrice multipliée par un scalaire
matrice produitScalaire(matrice A, double scalaire)
{
  for (int I = 0; I < A.ligne; I++)
  for (int J = 0; J < A.colonne; J++)
A.data[I][J] = A.data[I][J] * scalaire;
return A;
}

//Matrice inverse A^-1
matrice inverse(matrice A)
{
  return produitScalaire(transposee(coMatrice(A)), 1/det(A));
}

//tester si la matrice est inversible
bool estInversible(matrice A){
/*
A est inversible si A * A^-1 = 1
*/
matrice r = produit (A, inverse(A));
/*
* si le produit donne une matrice identité
* alors A est inversible
*/
for (int i = 0; i < A.ligne ; i++)
  if(r.data[i][i]!=1)
return false;
return true;
}

//Division de A sur B
struct matrice division(matrice A, matrice B)
{
matrice C;
C.ligne = A.ligne;
C.colonne = A.colonne;
  if(A.ligne != A.colonne && estInversible(B))
printf("Dimension illégales ou B est inversible");
  else
  return produit(A,inverse(B));
}

int main(int argc, char *argv[])
{
matrice A,B,C;
A.ligne=3;
A.colonne=3;
for (int i=0; i<A.ligne ;i++)
  for (int j=0; j<A.colonne; j++)
{
printf("A[%d][%d] ",i,j);
scanf("%d",&A.data[i][j]);
}
printf("A = \n");
afficher_matrice(A);

/*
2ème matrice
*/
B.ligne=3;
B.colonne=3;
  for (int i=0; i<B.ligne ;i++)
for (int j=0; j<B.colonne; j++)
{
printf("B[%d][%d] ",i,j);
scanf("%d",&B.data[i][j]);
}
printf("B = \n");
afficher_matrice(B);

//additioin
printf("***********************\n");
printf(" addition \n");
  printf("***********************\n");
C = addition(A,B);
afficher_matrice(C);
//soustraction
  printf("***********************\n");
printf(" soustraction \n");
  printf("***********************\n");
C = soustraction(A,B);
afficher_matrice(C);
//produit
  printf("***********************\n");
printf(" produit \n");
  printf("***********************\n");
C = produit(A,B);
afficher_matrice(C);
//divisioin
  printf("***********************\n");
printf(" divisioin \n");
  printf("***********************\n");
C = division(B,A);
afficher_matrice(C);

return 0;
}