Exemple de sortie écran :
 A :
+7.000 +0.000 +0.000 +0.000 +0.000 +0.000 
+0.000 +2.000 +0.000 +0.000 +0.000 +0.000 
+0.000 +0.000 +5.000 +0.000 +0.000 +0.000 
+0.000 +0.000 +0.000 +4.000 +0.000 +0.000 
+0.000 +0.000 +0.000 +0.000 +1.000 +0.000 
+0.000 +0.000 +0.000 +0.000 +0.000 +9.000 
 U :
+1.000 -1.000 +2.000 +6.000 
-6.000 -2.000 -3.000 +5.000 
-7.000 -2.000 +2.000 -8.000 
+3.000 -9.000 +6.000 +5.000 
+6.000 -2.000 +7.000 +4.000 
+4.000 +5.000 -1.000 +9.000 
 Press return to continue. 
 ------------------------------------ 
 Q :
+0.04303 -0.05435 +0.12785 +0.19490 
-0.25820 -0.01566 -0.28114 +0.49580 
-0.30123 -0.00403 +0.29573 +0.02885 
+0.12910 -0.41935 +0.00816 +0.08845 
+0.25820 -0.15521 +0.46932 -0.12136 
+0.17213 +0.16708 +0.08800 +0.14616 
 R :
 +23.23790 +6.32587 +2.49592 +28.83221 
 +0.00000 +23.40904 -13.36188 +2.24747 
 +0.00000 -0.00000 +9.12307 -0.10222 
 -0.00000 -0.00000 +0.00000 +25.11259 
 Press return to continue. 
 ------------------------------------ 
 U :
+1.000 -1.000 +2.000 +6.000 
-6.000 -2.000 -3.000 +5.000 
-7.000 -2.000 +2.000 -8.000 
+3.000 -9.000 +6.000 +5.000 
+6.000 -2.000 +7.000 +4.000 
+4.000 +5.000 -1.000 +9.000 
 U = Q * R :
+1.000 -1.000 +2.000 +6.000 
-6.000 -2.000 -3.000 +5.000 
-7.000 -2.000 +2.000 -8.000 
+3.000 -9.000 +6.000 +5.000 
+6.000 -2.000 +7.000 +4.000 
+4.000 +5.000 -1.000 +9.000 
 Press return to continue
 Press X to stop

Mathc matrices/c20r
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00e.c */
void fun(void)
double a[R2*C2]={ 2,0,
 0,3};
double u[R2*C1]={ 1,
 1};
double v[R2*C1]={ 3,
 2}; 
double **A = ca_A_mR(a,i_mR(R2,C2));
double **U = ca_A_mR(u,i_mR(R2,C1));
double **V = ca_A_mR(v,i_mR(R2,C1));
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" U :");
 p_mR(U,S3,P0,C6);
 printf(" V :");
 p_mR(V,S3,P0,C6);
 printf(" d(U,V) = ||U-V|| = (<U-V,U-V>)^1/2 \n\n");
 printf(" d(U,V) = %.3f = sqrt(11.)\n", dist_Diag_R(A,U,V));
 printf(" d(V,U) = %.3f = %.3f \n\n", dist_Diag_R(A,V,U), 
 sqrt(11.)); 
 f_mR(A);
 f_mR(U);
 f_mR(V);
/* ------------------------------------ */
int main(void)
 fun();
 stop();
 return 0;
/* ------------------------------------ */

Exemple de sortie écran :
 A :
 +2 +0 
 +0 +3 
 U :
 +1 
 +1 
 V :
 +3 
 +2 
 d(U,V) = ||U-V|| = (<U-V,U-V>)^1/2 
 d(U,V) = 3.317 = sqrt(11.)
 d(V,U) = 3.317 = 3.317 
 Press return to continue.

Mathc matrices/c20s
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00f.c */
void fun(void)
double a[R2*C2]={ 2,0,
 0,3};
double u[R2*C1]={ 1,
 1}; 
double v[R2*C1]={ 3,
 2}; 
double k = 3;
double **A = ca_A_mR(a,i_mR(R2,C2));
double **U = ca_A_mR(u,i_mR(R2,C1));
double **V = ca_A_mR(v,i_mR(R2,C1));
double **kV = smul_mR(k,V,i_mR(R2,C1));
double **UmnskV = sub_mR(U,kV,i_mR(R2,C1));
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" U :");
 p_mR(U,S3,P0,C6);
 printf(" V :");
 p_mR(V,S3,P0,C6);
 printf(" kV :");
 p_mR(kV,S3,P0,C6); 
 printf(" U-kV :");
 p_mR(UmnskV,S3,P0,C6); 
 printf(" ||U-kV|| = sqrt(%.0f) \n\n", 
 dot_Diag_R(A,UmnskV,UmnskV));
 f_mR(A);
 f_mR(U);
 f_mR(V);
 f_mR(kV);
 f_mR(UmnskV); 
/* ------------------------------------ */
int main(void)
 fun();
 stop();
 return 0;
/* ------------------------------------ */

Exemple de sortie écran :
 A :
 +2 +0 
 +0 +3 
 U :
 +1 
 +1 
 V :
 +3 
 +2 
 kV :
 +9 
 +6 
 U-kV :
 -8 
 -5 
 ||U-kV|| = sqrt(203) 
 Press return to continue.

Mathc matrices/a22
Application
Copier la bibliothèque dans votre répertoire de travail avec les fichiers des parties précédentes :
Dans ce produit scalaire la matrice A est une matrice aléatoire inversible.

La QR décomposition ce passe bien. 
Avec une matrice A orthonormal (c00k.c), on peut calculer les valeurs propres. (A * A_T = Id) 
Avec une matrice A aléatoire cela ce passe mal.
Présentation des fonction intermédiaire :

Mathc matrices/c22b
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00a.c */
void fun(int r)
double **A = r_mR( i_mR(r,r ), 9.);
double **u = r_mR( i_mR(r,C1), 9.);
double **v = r_mR( i_mR(r,C1), 9.);
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" u :");
 p_mR(u,S3,P0,C6);
 printf(" v :");
 p_mR(v,S3,P0,C6);
 printf(" <u,v> = v^t A^t A u \n");
 printf(" <u,v> = %.0f \n", dot_Au_R(A,u,v));
 printf(" <v,u> = %.0f \n", dot_Au_R(A,v,u));
 f_mR(A);
 f_mR(u);
 f_mR(v);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R3)+R1);
} while(stop_w());
 return 0;
/* ------------------------------------ */
Nous calculons le produit scalaire v^t*A^t*A*u avec A une matrice aléatoire.

Exemple de sortie écran :
 A :
 +6 -7 +8 +6 
 -9 -5 -9 -7 
 +8 +8 -5 +4 
 +6 +8 +2 -9 
 u :
 +2 
 +4 
 -1 
 +8 
 v :
 +8 
 +4 
 +6 
 +2 
 <u,v> = v^t A^t A u 
 <u,v> = 19590 
 <v,u> = 19590 
 Press return to continue
 Press X to stop

Mathc matrices/c22d
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 ), 9.);
double **u = r_mR( i_mR(r,C1), 9.);
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" u :");
 p_mR(u,S3,P0,C6);
 printf(" <u,u> = ||u||^2 (u^t*A^t*A*u)\n\n");
 printf(" (<u,u>)^(1/2) = %.3f \n",
 pow(dot_Au_R(A,u,u),(1./2.)));
 printf(" ||u|| = %.3f \n\n",
 norm_Au_R(A,u));
 f_mR(A);
 f_mR(u);
/* ------------------------------------ */
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 :
 -1 -9 -9 -3 
 +4 -5 +8 -7 
 -9 +8 -1 +8 
 +8 -5 -9 -9 
 u :
 +2 
 -3 
 -9 
 -9 
 <u,u> = ||u||^2 (u^t*A^t*A*u)
 (<u,u>)^(1/2) = 257.214 
 ||u|| = 257.214 
 Press return to continue
 Press X to stop

Mathc matrices/c22f
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.);
double **u = r_mR( i_mR(r,C1), 9.);
double **n_u = i_mR(r,C1);
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" u :");
 p_mR(u,S3,P0,C6);
 smul_mR(1./norm_Au_R(A,u),u,n_u); 
 printf(" n_u = (1/||u||) u :");
 p_mR(n_u,3,6,6); 
 printf(" ||n_u|| = %.6f \n\n",norm_Au_R(A,n_u));
 f_mR(A);
 f_mR(u);
 f_mR(n_u);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R2)+R1);
} while(stop_w());
 return 0;
/* ------------------------------------ */
Nous normalisons U.

Exemple de sortie écran :
 A :
 +8 -5 +6 
 -9 -5 -9 
 -5 -5 -3 
 u :
 -7 
 +8 
 +4 
 n_u = (1/||u||) u :
-0.093193 
+0.106506 
+0.053253 
 ||n_u|| = 1.000000 
 Press return to continue
 Press X to stop

Mathc matrices/c22h
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 **u = r_mR(i_mR(r,C1),9.);
double **v = r_mR(i_mR(r,C1),9.);
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" u :");
 p_mR(u,S3,P0,C6);
 printf(" v :");
 p_mR(v,S3,P0,C6);
 printf(" d(u,v) = ||u-v||^(1/2) \n\n");
 printf(" d(u,v) = %.3f \n", dist_Au_R(A,u,v));
 printf(" d(v,u) = %.3f \n\n", dist_Au_R(A,v,u));
 f_mR(A);
 f_mR(u);
 f_mR(v);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R2)+R1);
} while(stop_w());
 return 0;
/* ------------------------------------ */
Nous calculons la distance entre deux vecteurs.
 Exemple de sortie écran :
 A :
 +8 +6 +4 
 -9 +6 -3 
 +6 +4 -3 
 u :
 -5 
 +4 
 -3 
 v :
 +6 
 -3 
 +6 
 d(u,v) = ||u-v||^(1/2) 
 d(u,v) = 187.267 
 d(v,u) = 187.267