Mathc matrices/c23b
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00b.c */
void fun(int r)
double **A = r_mR(i_mR(r,r ),99.);
double **B = r_mR(i_mR(r,r ),99.);
double **AmnsB = i_mR(r,r );
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" B :");
 p_mR(B,S3,P0,C6);
 sub_mR(A,B,AmnsB);
 printf(" d(A,B) = ||u-v||^(1/2) \n\n");
 printf(" d(A,B) = %.4f norm_TR_R(AmnsB)\n", norm_TR_R(AmnsB));
 printf(" d(B,A) = %.4f dist_TR_R(A,B)\n", dist_TR_R(A,B));
 printf(" d(A,B) = %.4f dist_TR_R(B,A)\n\n", dist_TR_R(B,A));
 f_mR(A);
 f_mR(B);
 f_mR(AmnsB);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R3)+R2);
} while(stop_w());
 return 0;
/* ------------------------------------ */
Nous calculons la distance entre les deux matrices.

Exemple de sortie écran :
 A :
+26 -1 +26 +54 +94 
-11 +10 +94 +12 -21 
+88 -67 +26 -99 +10 
-27 +60 +38 +24 +56 
+84 -35 +62 -79 +60 
 B :
-65 +98 +66 -19 -97 
-99 +44 +96 -23 -95 
+88 -33 -5 -81 -43 
+24 -69 +8 -49 +68 
+18 -73 -29 -53 +96 
 d(A,B) = ||u-v||^(1/2) 
 d(A,B) = 352.158 norm_traceAtB_R(AmnsB)
 d(B,A) = 352.158 dist_traceAtB_R(A,B)
 d(A,B) = 352.158 dist_traceAtB_R(B,A)
 Press return to continue
 Press X to stop

Mathc matrices/c23c
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00c.c */
void fun(int r)
double **A = r_mR(i_mR(r,r ),9.);
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" <A,A> = ||A||^2 \n\n");
 printf(" (A.A)^(1/2) = %.4f \n", pow(dot_TR_R(A,A),(1./2.)));
 printf(" ||A|| = %.4f \n\n", norm_TR_R(A));
 f_mR(A);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R3)+R2);
} while(stop_w());
 return 0;
/* ------------------------------------ */
Nous calculons la norme.

Exemple de sortie écran :
 A :
 -3 +6 +6 -7 -1 
 +2 +4 -5 -9 +8 
 +6 -3 -9 -1 -5 
 -1 +6 -1 +6 +8 
 -1 -9 -9 +2 +2 
 <A,A> = ||A||^2 
 (A.A)^(1/2) = 27.964 
 ||A|| = 27.964 
 Press return to continue
 Press X to stop

Mathc matrices/c23d
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00d.c */
void fun(int r)
double **A = r_mR(i_mR(r,r ),99.);
double **B = r_mR(i_mR(r,r ),99.);
double **AmnsB = i_mR(r,r);
double **AplB = i_mR(r,r);
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" B :");
 p_mR(B,S3,P0,C6);
 add_mR(A,B,AplB); 
 sub_mR(A,B,AmnsB);
 printf(" 2||u||^2 + 2||v||^2 = %.4f \n\n", 
 2 * pow(norm_TR_R(A),2.)
 + 2 * pow(norm_TR_R(B),2.) );
 printf(" ||u + v||^2 + ||u - v||^2 = %.4f \n\n", 
 pow(norm_TR_R(AplB),2.) 
 + pow(norm_TR_R(AmnsB),2.) );
 f_mR(A);
 f_mR(B);
 f_mR(AplB);
 f_mR(AmnsB);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R3)+R2);
} while(stop_w());
 return 0;
/* ------------------------------------ */
Nous vérifions une propriétée du produit scalaire.

Exemple de sortie écran :
 A :
-26 +68 +13 
-77 +69 +22 
-36 +84 -74 
 B :
-81 +28 -95 
+17 +46 -14 
+62 +25 +1 
 2||u||^2 + 2||v||^2 = 107824.0000 
 ||u + v||^2 + ||u - v||^2 = 107824.0000 
 Press return to continue
 Press X to stop

Mathc matrices/c23e
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00d.c */
void fun(int r)
double **A = r_mR(i_mR(r,r ),9.);
double **n_A = i_mR(r,r);
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 smul_mR(1./norm_TR_R(A),A,n_A); 
 printf(" n_A = (1/||A||) A :");
 p_mR(n_A,S3,P4,C6); 
 printf(" ||n_A|| = %.4f \n\n", norm_TR_R(n_A));
 f_mR(A);
 f_mR(n_A);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R3)+R2);
} while(stop_w());
 return 0;
/* ------------------------------------ */
Nous normalisons.

Exemple de sortie écran :
 A :
 -5 -4 +6 
 -7 +8 -9 
 -6 -9 -6 
 n_A = (1/||A||) A :
-0.2428 -0.1943 +0.2914 
-0.3400 +0.3885 -0.4371 
-0.2914 -0.4371 -0.2914 
 ||n_A|| = 1.0000 
 Press return to continue
 Press X to stop

Mathc matrices/c23f
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00f.c */
void fun(int r)
double **A = r_mR(i_mR(r,r),99.);
double **B = r_mR(i_mR(r,r),99.);
double **projAB = i_mR(r,r);
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" B :");
 p_mR(B,S3,P0,C6);
 stop();
 clrscrn(); 
 proj_TR_mR(A,B,projAB);
 printf(" vector component of A along B \n\n"); 
 printf(" projAB :");
 p_mR(projAB,S10,P4,C6);
 f_mR(A);
 f_mR(B);
 f_mR(projAB);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R3)+R2);
} while(stop_w());
 return 0;
/* ------------------------------------ */
Nous calculons le projeté de la matrice A sur B.

Exemple de sortie écran :
 A :
 +6 -39 +8 +52 +81 
+74 -11 +78 +11 -26 
+48 +44 +93 +81 +36 
+22 -97 -76 -48 +77 
+36 +94 -99 +56 -92 
 B :
 -1 -88 +28 -35 +80 
 -8 +9 +59 -6 +9 
-33 +31 -88 +97 -37 
-22 +28 -77 +88 +60 
-78 -69 -65 -70 +28 
 Press return to continue. 
 vector component of A along B 
 projAB :
 -0.0468 -4.1207 +1.3111 -1.6389 +3.7461 
 -0.3746 +0.4214 +2.7627 -0.2810 +0.4214 
 -1.5452 +1.4516 -4.1207 +4.5421 -1.7325 
 -1.0302 +1.3111 -3.6056 +4.1207 +2.8095 
 -3.6524 -3.2310 -3.0437 -3.2778 +1.3111 
 Press return to continue
 Press X to stop

Mathc matrices/c23g
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00g.c */
void fun(int r)
double **A = r_mR(i_mR(r,r),99.);
double **B = r_mR(i_mR(r,r),99.);
double **projAB = i_mR(r,r);
double **umnsprojAB = i_mR(r,r);
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" B :");
 p_mR(B,S3,P0,C6);
 stop();
 clrscrn();
 proj_TR_mR(A,B,projAB);
 printf(" vector component of A along B \n\n"); 
 printf(" projAB :");
 p_mR(projAB,S10,P4,C6);
 stop();
 clrscrn();
 printf(" vector component of A orthogonal to B \n\n");
 printf(" A-projAB :");
 sub_mR(A,projAB,umnsprojAB);
 p_mR(umnsprojAB,S10,P4,C6);
 printf(" <B,A-projAB> = %.4f \n\n", dot_TR_R(B,umnsprojAB));
 f_mR(A);
 f_mR(B);
 f_mR(projAB);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R3)+R2);
} while(stop_w());
 return 0;
/* ------------------------------------ */
Une propriétée des produits scalaires.

Exemple de sortie écran :
 A :
-33 +81 +15 
+11 +62 +44 
+85 +23 +60 
 B :
+98 -13 +87 
+38 +35 +66 
+25 +51 +37 
 Press return to continue. 
 vector component of A along B 
 projAB :
 +27.1647 -3.6035 +24.1156 
 +10.5333 +9.7017 +18.2946 
 +6.9298 +14.1367 +10.2561 
 Press return to continue. 
 vector component of A orthogonal to B 
 A-projAB :
 -60.1647 +84.6035 -9.1156 
 +0.4667 +52.2983 +25.7054 
 +78.0702 +8.8633 +49.7439 
 <B,A-projAB> = 0.0000 
 Press return to continue
 Press X to stop

Mathc matrices/a24
Bibliothèque
Dans cet algorithme, le pivot choisi est la plus grande valeur absolue qui se trouve dans la colonne ou se trouve le pivot. Pour cela on fait des échanges de lignes. 
Nous allons voir comment travailler avec les variables libres.
Copier la bibliothèque dans votre répertoire de travail avec les fichiers des parties précédentes :
Exemple pour tester la bibliothèque :