Differentes operations sur les matrices (puissance,determinant...)

Soyez le premier à donner votre avis sur cette source.

Vue 21 705 fois - Téléchargée 980 fois

Description

Ce programme vous permettra d'effectuer des calculs sur des matrices.
Les calculs sont les suivants :

- recherche de pints cols
- calcul du determinant de la matrice
- calcul de l'inverse de la matrice
- calcul de la puissance de la matrice

Source / Exemple :


#include <stdio.h>
#include <conio.h>

            /*Prototypes des fonctins*/

void saisie_mat(float[10][10],int*,int*);
void affich_mat(float[10][10],int,int);
void point_col(float[10][10],int,int);
void puiss_carre(float[10][10],float[10][10],int,int);
void transfert(float[10][10],float[10][10],int,int);
void puissance(float[10][10],int,int);
void transp_mat(float[10][10],float[10][10]);
void det_aux(float[10][10],float[10][10],int,int);
float expo(int);
float determinant(float[10][10],int);
void multi_R(float,float[10][10],float[10][10]);
void coffacteur(float[10][10],float[10][10],int);
void inverse(float[10][10],float[10][10],int);
int test(float[10][10],int);
int test_point_col(float[10][10],int,int);

/******************************************************************************/

/*Cette fonction permet a l utilisateur de saisir la matrice*/

void saisie_mat(float m[10][10],int *l,int *c)
{ int i,j;
do
{
clrscr();
printf("\t\t\t** Saisie de la matrice  **\n\n");
printf(" Nombre de lignes de la matrice (max 10): ");
scanf("%d",l);
if(*l>10){printf("Erreur !");getch();}
}while(*l>10);

do
{
printf(" Nombre de colonnes de la matrice (max 10):");
scanf("%d",c);
if(*c>10){printf("Erreur !\n");getch();}
}while(*c>10);

printf("\n\n");

for(i=0;i<*l;i++)
{
	for(j=0;j<*c;j++)
   {
   printf("  Element(%d,%d) : ",i,j);
   scanf("%f",&m[i][j]);
   }
   printf("\n");
}
}

/*******************************************************************************/

/*Cette fonction permet d'afficher la matrice*/

void affich_mat(float m[10][10],int l,int c)
{int i,j;
clrscr();
printf("\t\t\t**  Affichage de la matrice  **\n\n\n");

for(i=0;i<l;i++)
{
	for(j=0;j<c;j++)
   {
   printf("\t%.2f",m[i][j]);
   }
   printf("\n\n");
}
getch();
}

/******************************************************************************/

/*Fonction de test d'egalité totle d'une ligne (sert pour les points cols)*/

int test_point_col(float m[10][10],int l,int c)
{
int j,cpt=0;

for(j=1;j<c;j++)
{
if(m[l][j-1]==m[l][j]){cpt++;}
}

if(cpt==c-1)return 0;else return 1;

}

/******************************************************************************/

/*Cette fonction permet de trouver les points cols d'une matrice
 c'est a dire les points qui sont a la fois un maximum sur leur
 ligne et un minimum sur leur colonne*/

void point_col(float m[10][10],int l,int c)
{int i,j,max_l=0,min_c=0,k,x,t=0;
clrscr();
printf("\t\t\t**  Points-cols de la matrice  **\n\n\n");

for(i=0;i<l;i++)
{
	for(j=0;j<c;j++)
   {

   	for(k=0;k<c;k++)
      {
            if(m[i][j]>m[i][k]){max_l=1;}else{if(m[i][j]<m[i][k]){max_l=0;k=10;}}

      }

      for(x=0;x<l;x++)
      {
      		if(m[i][j]<m[x][j]){min_c=1;}else{if(m[i][j]>m[x][j]){min_c=0;x=10;}}

      }

     if((max_l==1)&&(min_c==1)&&(test_point_col(m,i,c)==1)){printf("Ligne : %d ; Colonne : %d ==> Valeur du point-col : %.2f\n\n",i,j,m[i][j]);t++;}
   }

}
if(t==0)printf("\n\nAucun point-col");getch();
}

/*******************************************************************************/

/*Cette fonction transert les elements d'un tableau dans un autre tableau*/

void transfert(float t1[10][10],float t2[10][10],int l,int c)
{
int i,j;

for(i=0;i<l;i++)
{
	for(j=0;j<c;j++)
   {
   t2[i][j]=t1[i][j];
   }
}
}

/******************************************************************************/

/*Cette calcul le carre de la matrice*/

void puiss_carre(float m[10][10],float ca[10][10],int l,int c)
{int i,j,k;
float tot;
for(i=0;i<l;i++)
{
	for(j=0;j<c;j++)
   {
     tot=0;
   	for(k=0;k<c;k++)
      {
      tot=tot+(m[i][k]*m[k][j]);
      }

    ca[i][j]=tot;
   }
}
}

/*****************************************************************************/

/*Cette fonction calcule et affiche la puissance d'une matrice*/

void puissance(float m[10][10],int l,int c)
{
  float ca[10][10],cb[10][10],tot;
  int i,j,k,v,p;

clrscr();
printf("\t\t\t**  Puissance d'une matrice  **\n\n\n");

if(l!=c)
			{
         printf("\a\tCalcul impossible ! Ce n'est pas une matrice carree !");getch();
         }
         else
         {

printf(" Puissance a laquelle vous desirez elever la matrice : ");
scanf("%d",&p);

if(p==1){affich_mat(m,l,c);}
else
{

puiss_carre(m,ca,l,c);

if(p==2)
{
affich_mat(ca,l,c);
}
else
{

for(v=0;v<p-2;v++)
{
transfert(ca,cb,l,c);

for(i=0;i<l;i++)
{

   for(j=0;j<c;j++)
   {
    tot=0;
         for(k=0;k<c;k++)
      {
      tot=tot+(cb[i][k]*m[k][i]);
      }

    ca[j][i]=tot;
   }
}

}
}

affich_mat(ca,l,c);
}
}
}

/*******************************************************************************/

/*Cette fonction permet de calculer la transposee d'une matrice.
La transposition d'une matrice intervertit ses lignes et ses colonnes.
Si on transpose une matrice n*m on obtient une matrice m*n comme résultat.*/

void transp_mat(float ma[10][10],float mb[10][10])
{
int i,j;

for (i=0;i<10;i++)
{
	for (j=0;j<10;j++)
	{
	mb[j][i]=ma[i][j];
	}
}
}

/*********************************************************************************/

/*Cette fonction nous est utile dans le calcul du determinant, elle supprime dans
  la matrice ma les lignes l et c puis enregistre les resultats dans mb*/

void det_aux(float ma[10][10],float mb[10][10],int l,int c)
{
int i,j,d,e=0;

	for(i=0;i<10;i++)
	{
   d=0;
		if(i!=l)
		{
      for(j=0;j<10;j++)
				if(j!=c)
				{
            mb[e][d]=ma[i][j];
            d++;
				}
			e++;
		}
	}
}

/*******************************************************************************/

/*Cette fonction teste si un entier est multiple de 2,
cette fonction nous sert dans le calcul du determinant*/

float expo(int n)
{
if(!(n%2)){return (1);}
return (-1);
}

/********************************************************************************/

/* Cette fonction calcul le determinant d'une matrice de maniere recursive*/

float determinant(float m[10][10],int l)
{
int i;
float m2[10][10],x=0;

if(l==1){return (m[0][0]);}

for(i=0;i<l;i++)
{
det_aux(m,m2,i,0);
x=x+(expo(i)*m[i][0]*determinant(m2,(l-1)));
}

return (x);
}

/******************************************************************************/

/*Cette fonction sert a multiplier une matrice par un reel 'a'*/

void multi_R(float a,float ma[10][10],float mb[10][10])
{
int i,j;

for(i=0;i<10;i++)
{
	for(j=0;j<10;j++)
   {
	mb[i][j]=ma[i][j]*a;
   }
}
}

/*****************************************************************************/

/*Cette fonction calcule le coffacteur d'une matrice. Le cofacteur d'un element
  a(i,j) noté A(i,j) est calculé de cette maniere : A(i,j)=(-1)^(i+j).M(i,j) */

void coffacteur(float ma[10][10],float mb[10][10],int l)
{
int i,j;
float m2[10][10];

if (l==1)
{
mb[0][0]=1;
}
else
{
for (i=0;i<l;i++)
{
	for (j=0;j<l;j++)
	{
	det_aux(ma,m2,i,j);
	mb[i][j]=expo(i+j)*determinant(m2,(l - 1));
	}
}
}
}

/******************************************************************************/

/*Cette fonction sert a calculer l'inverse d'une matrice de la maniere suivante :
  -calcul du cofacteur de ma dans m1;
  -calcul de la transposé de m1 dans m2;
  -on multiplie la transposé par (1/determinant) puis on enregistre dans mb;

  • /
void inverse(float ma[10][10],float mb[10][10],int l) { float m1[10][10],m2[10][10],d; d=(1./determinant(ma,l)); coffacteur(ma,m1,l); transp_mat(m1,m2); multi_R(d,m2,mb); } /*****************************************************************************/ /*Cette fonction verifie si l'inverse d'une matrice est egale a 0, car sinon on peut pas calculer l'inverse d'une matrice.*/ int test(float tab[10][10], int l1) { if(determinant(tab,l1)){return 1;} return 0; } /******************************************************************************/ /*Le menu du programme*/ void main() { int l,c,x=1,q=0; float mat1[10][10],mat2[10][10],r; do { clrscr(); printf("\t\t\t** Les matrices **\n\n\n"); printf("\t1 : Saisie de la matrice.\n\n"); printf("\t2 : Affichage de la matrice.\n\n"); printf("\t3 : Recherche de points-cols.\n\n"); printf("\t4 : Calcul du determinant d'une matrice.\n\n"); printf("\t5 : Calcul de l'inverse d'une matrice.\n\n"); printf("\t6 : Calcul de la puissance d'une matrice.\n\n\n"); printf("\tesc : Quitter.\n\n\n"); printf("\t\tFaites votre choix...\n"); textcolor(12); cprintf("\n\n\n Realise par 2PAC esgi (2pac 4 ever!!)"); switch (getch()) { case '1':saisie_mat(mat1,&l,&c);q++;break; case '2':if(q!=0)affich_mat(mat1,l,c);else printf("\a");break; case '3':if(q!=0)point_col(mat1,l,c);else printf("\a");break; case '4':if(q!=0) { if(l==c) { clrscr();r=determinant(mat1,l);printf("\n\n\tLe determinant de la matrice = %f",r);getch(); } else { printf("\a\n\n\n\t Impossible ! la matrice n'est pas carree !");getch(); } }else{printf("\a");};break; case '5':if(q!=0) { if(l==c) { if (!test(mat1,l)) {printf("\n\n\t\a!! Impossible, le determinant est nul !!");} else { inverse(mat1,mat2,l); affich_mat(mat2,l,c); printf(" Inverse de la matrice \n\n"); } }else{printf("\a");printf("\n\n\n\t Impossible ! la matrice n'est pas carree !");getch();} }else{printf("\a");} break; case '6':if(q!=0)puissance(mat1,l,c);else printf("\a");break; case 27:x=0;break; default:printf("\a"); } } while(x!=0); }

Conclusion :


Si vous avez des questions ou des observations n'hesitez pas !!!!!!!!

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Galett
Messages postés
115
Date d'inscription
jeudi 7 février 2002
Statut
Membre
Dernière intervention
21 mai 2005
-
c'est pas mal tout ça, mais je pense que tu peux améliorer certaines fonctions, genre l'inversion de matrice, à ce que m'a dit un étudiant de licence de maths, la meilleure méthode consiste à créer une fonction qui divise une matrice par une autre(je vois pas trop comment faire) et t'a plus qu'à diviser par la mat identité...
si ça peut t'aider :-)
2PACesgi
Messages postés
3
Date d'inscription
mercredi 8 janvier 2003
Statut
Membre
Dernière intervention
4 juin 2005
-
Je sais pas si je me trompe mais la division de 2 matrices n'est pas possible ou alors si il esxiste une methode j'ai du l'oublier !!! ;-). La maniere dont mon programme calcul l'inverse de la matrice n'est pas des plus simple mais c'est la seule methode que j'ai trouvé. Si tu as plus de renseignements sur le calcul de l'inverse d'une matrice fait moi signe. :-)
Galett
Messages postés
115
Date d'inscription
jeudi 7 février 2002
Statut
Membre
Dernière intervention
21 mai 2005
-
je c que normalement ça n'existe pas, mais c une méthode de calcul surtt pour trouver l'inverse, et on m'a dit que c'était bien plus rapide, je vais demander renseignement :o)
mais sinon à part faire ça en récursif, tu peux aussi poser un système d'équation, et résoudre par pivot de Gauss, mais des probs de précisions apparaissent avec cette méthode...
cs_GoldenEye
Messages postés
527
Date d'inscription
vendredi 14 septembre 2001
Statut
Membre
Dernière intervention
6 octobre 2008
2 -
Le calcul de l'inverse d'une matrice est très coûteux avec ta méthode. Je vais chercher dans mon bazar une solution meilleure
Pour le reste, c'est bien.
tauop
Messages postés
2
Date d'inscription
dimanche 16 février 2003
Statut
Membre
Dernière intervention
12 septembre 2004
-
Salut,

Bon dsl, mais je vais plutot faire des critiques sur ce code :
- pas portable (conio.h sux et ca fait chier sous linux par exemple)
- le code n est pas tres claire (mal indente, out cole etc...). Tu devrais te fixer une norme ou alors lire des codes de projet plus grand (comme les projet GNU et autre). Tu verras que c plus claire.
- la fonction de puissance ne marche pas apparament. I^3 = [[1, 1, 1] [1, 1, 1] [1, 1, 1]] pour ton programme.
- la fonction de cacul de determinant n est pas du out optimisee. tu cree n-1 matrice (n -1, n - 1) a chaque reccursion, ce qui est _enorme_. Il ne faut pas utiliser la formule theorique ici je pense. (j ai trouve un moyen plus rapide de le faire et je le posterais prochainenement sur cppfrance)
- enfin, dommage que tu n ais pas utilise malloc et autre fonction d allocation de memoire pour faire en sorte que l on puisse faire des matrices plus grandes que 10*10....

Sinon merci, ton code a pu me faire rappeler comment calculer le determinant :)

Amicalement,

Tauop

P.S.: Je vais bientot poster mon code sur les matrices mais ce sera en C++ (plus lent mais pratique pour certaines choses)

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.