DIFFERENTES OPERATIONS SUR LES MATRICES (PUISSANCE,DETERMINANT...)

#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);
}