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

Télécharger le projet
Commenter

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 !!!!!!!!
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (2PACesgi)