Mathc matrices/c31e
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : d03a.c */
int main(void)
double a[9]={
 -2., -2., 3.,
 0., -2., -2.,
 0., 0., 1.}; 
double inva[9]={
 -1./2., 1./2., 5./2., 
 0., -1./2.,-1., 
 0., 0., 1.};
double **A = ca_A_mR(a, i_mR(R3,C3));
double **invA = ca_A_mR(inva,i_mR(R3,C3));
double **AinvA = i_mR(R3,C3);
 printf(" A : ");
 p_mR(A,5,0,6);
 printf(" invA : ");
 p_mR(invA,5,3,6);
 printf(" A*invA : ");
 mul_mR(A,invA,AinvA);
 p_mR(AinvA,5,3,6);
 printf("\n\n\n Press return to continue");
 f_mR(A);
 f_mR(invA);
 f_mR(AinvA);
 getchar();
 return 0;
/* ------------------------------------ */
Il faut jouer le jeu pour comprendre ce travail. Copier le système de matrice et remplacer au fur et à mesure les lettres par leurs valeurs.
Le fichier c permet simplement de vérifier le résultat.
 La méthode de calcul :
 a) Ecrire sur un papier au crayon ce système de matrices
 -2 -2 3 a b c 1 0 0 
 0 -2 -2 * 0 d e = 0 1 0 
 0 0 1 0 0 f 0 0 1 
 « Remplacer chaque lettre aux fur et à mesure. »
 b) Inverser les coefficients de la diagonale :
 -> a= -1/2
 -> d= -1/2
 -> f= 1
 c) Calculer le produit scalaire des r* lignes par les c* colonnes :
 1) r1*c2 => -2b + 1 = 0 => b=1/2 
 -2 -2 3 -1/2 b c 1 0 0 
 0 -2 -2 * 0 -1/2 e = 0 1 0 
 0 0 1 0 0 1 0 0 1

2) r2*c3 => -2e - 2 = 0 => e= -1
 -2 -2 3 -1/2 1/2 c 1 0 0 
 0 -2 -2 * 0 -1/2 e = 0 1 0 
 0 0 1 0 0 1 0 0 1

3) r1*c3 => -2c + 2 + 3 = 0 => c= 5/2 
 -2 -2 3 -1/2 1/2 c 1 0 0 
 0 -2 -2 * 0 -1/2 -1 = 0 1 0 
 0 0 1 0 0 1 0 0 1 
 4) c= 5/2 
 -2 -2 3 -1/2 1/2 5/2 1 0 0 
 0 -2 -2 * 0 -1/2 -1 = 0 1 0 
 0 0 1 0 0 1 0 0 1

d) Le résultat :
 -2 -2 3 -1/2 1/2 5/2 1 0 0 
 0 -2 -2 * 0 -1/2 -1 = 0 1 0 
 0 0 1 0 0 1 0 0 1

Mathc matrices/c31f
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : d04a.c */
int main(void)
double a[16]={
 1., -2., -2., 3.,
 0., 1., 1., 3.,
 0., 0., 3., 1.,
 0., 0., 0., 3.

double inva[16]={
 1., 2., 0., -3., 
 0., 1., -1./3., -8./9., 
 0., 0., 1./3., -1./9., 
 0., 0., 0., 1./3. };
double **A = ca_A_mR(a, i_mR(R4,C4));
double **invA = ca_A_mR(inva,i_mR(R4,C4));
double **AinvA = i_mR(R4,C4);
 printf(" A : ");
 p_mR(A,5,0,6);
 printf(" invA : ");
 p_mR(invA,5,3,6);
 printf(" A*invA : ");
 mul_mR(A,invA,AinvA);
 p_mR(AinvA,5,3,6);
 printf("\n\n\n Press return to continue");
 f_mR(A);
 f_mR(invA);
 f_mR(AinvA);
 getchar();
 return 0;
/* ------------------------------------ */
Il faut jouer le jeu pour comprendre ce travail. Copier le système de matrice et remplacer au fur et à mesure les lettres par leurs valeurs.
Le fichier c permet simplement de vérifier le résultat.
 La méthode de calcul :
 a) Ecrire sur un papier au crayon ce système de matrices
 1 -2 -2 3 a b c d 1 0 0 0 
 0 1 1 3 0 e f g = 0 1 0 0 
 0 0 3 1 * 0 0 h i 0 0 1 0 
 0 0 0 3 0 0 0 j 0 0 0 1 
 « Remplacer chaque lettre aux fur et à mesure. »
 b) Inverser les coefficients de la diagonale :
 -> a= 1
 -> e= 1
 -> h= 1/3
 -> j= 1/3
 c) Calculer le produit scalaire des r* lignes par les c* colonnes :
 r1*c2 => b - 2 = 0 => b= 2 
 r2*c3 => f + 1/3 = 0 => f= -1/3 
 r1*c3 => c + 2/3 - 2/3 = 0 => c= 0 
 r3*c4 => 3i + 1/3 = 0 => i= -1/9 
 r2*c4 => g - 1/9 + 1 = 0 => g= -8/9 
 r1*c4 => d + 16/9 + 2/9 + 1 = 0 => d= -3 
 d) Le résultat :
 1 -2 -2 3 1 2 0 -3 1 0 0 0 
 0 1 1 3 0 1 -1/3 -8/9 = 0 1 0 0 
 0 0 3 1 * 0 0 1/3 -1/9 0 0 1 0 
 0 0 0 3 0 0 0 1/3 0 0 0 1

Mathc matrices/c31g
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : d05a.c */
int main(void)
double a[25]={
 -2., 3., -2., -2., 3.,
 0., 3., 1., 1., 1.,
 0., 0., -2., 1., 1.,
 0., 0., 0., 1., -2.,
 0., 0., 0., 0., 1.

double inva[25]={
 -1./2., 1./2., 3./4., -9./4., -17./4.,
 0., 1./3., 1./6., -1./2., -3./2.,
 0., 0., -1./2., 1./2., 3./2.,
 0., 0., 0., 1., 2., 
 0., 0., 0., 0., 1. };
double **A = ca_A_mR(a, i_mR(R5,C5));
double **invA = ca_A_mR(inva,i_mR(R5,C5));
double **AinvA = i_mR(R5,C5);
 printf(" A : ");
 p_mR(A,5,0,6);
 printf(" invA : ");
 p_mR(invA,5,3,6);
 printf(" A*invA : ");
 mul_mR(A,invA,AinvA);
 p_mR(AinvA,5,3,6);
 printf("\n\n\n Press return to continue");
 f_mR(A);
 f_mR(invA);
 f_mR(AinvA);
 getchar();
 return 0;
/* ------------------------------------ */
Il faut jouer le jeu pour comprendre ce travail. Copier le système de matrice et remplacer au fur et à mesure les lettres par leurs valeurs.
Le fichier c permet simplement de vérifier le résultat.
 La méthode de calcul :
 a) Ecrire sur un papier au crayon ce système de matrices
 -2 3 -2 -2 3 a b c d e 1 0 0 0 0
 0 3 1 1 1 0 f g h i = 0 1 0 0 0
 0 0 -2 1 1 * 0 0 j k l 0 0 1 0 0
 0 0 0 1 -2 0 0 0 m n 0 0 0 1 0
 0 0 0 0 1 0 0 0 0 o 0 0 0 0 1
 « Remplacer chaque lettre aux fur et à mesure. »
 b) Inverser les coefficients de la diagonale :
 -> a= -1/2 
 -> f= 1/3 
 -> j= -1/2
 -> m= 1 
 -> o= 1
 c) Calculer le produit scalaire des r* lignes par les c* colonnes :
 r1*c2 => -2b + 1 = 0 => b= 1/2
 r2*c3 => 3g - 1/2 = 0 => g= 1/6
 r1*c3 => -2c + 1/2 + 1 = 0 => c= 3/4 
 r3*c4 => -2k + 1 = 0 => k= 1/2 
 r2*c4 => 3h + 1/2 + 1 = 0 => h= -1/2 
 r1*c4 => -2d - 3/2 - 1 - 2 = 0 => d= -9/4 
 r4*c5 => n - 2 = 0 => n= 2 
 r3*c5 => -2l + 2 + 1 = 0 => l= 3/2
 r2*c5 => 3i + 3/2 + 2 + 1 = 0 => i= -3/2
 r1*c5 => -2e - 9/2 - 3 - 4 + 3 = 0 => e= -17/4 
 d) Le résultat :
 -2 3 -2 -2 3 -1/2 1/2 3/4 -9/4 -17/4 1 0 0 0 0
 0 3 1 1 1 0 1/3 1/6 -1/2 -3/2 = 0 1 0 0 0
 0 0 -2 1 1 * 0 0 -1/2 1/2 3/2 0 0 1 0 0
 0 0 0 1 -2 0 0 0 1 2 0 0 0 1 0
 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1

Mathc matrices/a32
Application
Le but de ce travail est de créer des systèmes dont on connait le résultat par avance. :
Exemples d'applications :

Mathc matrices/c32a
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c01a.c */
int main(void)
time_t t;
 srand(time(&t));
double ta[R2*C3]={ 1,0, 1,
 0,1, 2};
double **T = ca_A_mR(ta,i_mR(R2,C3));
double **A = r_mR(i_mR(R2,C2),999.); 
double **AT = mul_mR(A,T,i_mR(R2,C3)); 
double **Ab = gj_TP_mR(c_mR(AT,i_Abr_Ac_bc_mR(R2,C2,C1))); 
 clrscrn();
 printf(" Find a matrice, that has this reduced row-echelon form :\n\n"
 " Ab : ");
 p_mR(T,S5,P0,C6);
 stop();
 clrscrn(); 
 printf(" If :\n\n A = r_mR(i_mR(R2,C2),999.)");
 p_mR(A,S5,P0,C6); 
 printf(" And :\n\n T :");
 p_mR(T,S5,P0,C6); 
 printf(" I suggest this matrix : A*T = Ab\n\n" 
 " Ab : ");
 p_mR(AT,S5,P0,C6);
 stop(); 
 clrscrn(); 
 printf("\n With the Gauss Jordan function :\n\n Ab :");
 p_mR(Ab,S10,P5,C7);
 stop();
 f_mR(Ab);
 f_mR(A);
 f_mR(T);
 f_mR(AT);
 return 0;
/* ------------------------------------ */
Le but de ce travail est de créer des systèmes dont on connait le résultat par avance.
 La méthode de calcul :
 Find a matrice, that has this reduced row-echelon form :
 Ab : 
 +1 +0 +1 
 +0 +1 +2 
 Press return to continue. 
 If :
 A = r_mR(i_mR(R2,C2),999.)
 +479 -154 
 -501 +992 
 And :
 T :
 +1 +0 +1 
 +0 +1 +2 
 I suggest this matrix : A*T = Ab
 Ab : 
 +479 -154 +171 
 -501 +992 +1483 
 Press return to continue. 
 With the Gauss Jordan function :
 Ab :
 +1.00000 +0.00000 +1.00000 
 +0.00000 +1.00000 +2.00000 
 Press return to continue.