Mathc matrices/c22q
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00j.c */
void fun(int r,int rn)
double **A = r_mR(i_mR(r+rn,r+rn),9.);
double **U = r_mR(i_mR(r+rn,r),9.);
double **Q = i_mR(r+rn,r);
double **R = i_mR(r,r);
double **QR = i_mR(r+rn,r);
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" U : r > c ");
 p_mR(U,S3,P0,C6);
 stop();
 clrscrn(); 
 QR_Au_mR(A,U,Q,R);
 printf(" Q :");
 p_mR(Q,S10,P4,C6);
 printf(" R :");
 p_mR(R,S10,P4,C6);
 stop();
 clrscrn();
 printf(" U :");
 p_mR(U,S7,P2,C6);
 printf(" U = Q * R :"); 
 mul_mR(Q,R, QR);
 p_mR(QR,S7,P2,C6); 
 f_mR(A);
 f_mR(U);
 f_mR(Q);
 f_mR(R);
 f_mR(QR);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R2)+R2,rp_I(R2));
} while(stop_w());
 return 0;
/* ------------------------------------ */
Nous calculons la QR décomposion du vecteur u. Avec u un vecteur qui a plus de lignes que de colonnes

Exemple de sortie écran :
 A :
-5.000 -9.000 -7.000 -3.000 -1.000 
+4.000 -9.000 -7.000 +8.000 +8.000 
+4.000 -7.000 -1.000 -9.000 +6.000 
+6.000 -9.000 -9.000 -1.000 +2.000 
-5.000 +2.000 +6.000 -5.000 -3.000 
 U : r > c 
-1.000 +6.000 -9.000 -5.000 
+6.000 -9.000 -9.000 -5.000 
+6.000 +2.000 -5.000 +8.000 
+8.000 -1.000 +4.000 +4.000 
+2.000 +2.000 -3.000 -1.000 
 Press return to continue. 
 Q :
-0.00496 +0.04939 -0.06866 -0.02938 
+0.02978 -0.04189 -0.03607 -0.15335 
+0.02978 +0.06178 -0.01176 +0.18196 
+0.03970 +0.04781 +0.05988 +0.04454 
+0.00993 +0.03316 -0.01365 -0.00134 
 R :
+221.50930 -152.99045 -121.55270 +56.89564 
 +0.00000 +106.11278 +4.95322 -36.17388 
 -0.00000 +0.00000 +143.43084 +21.99662 
 -0.00000 +0.00000 +0.00000 +48.35789 
 Press return to continue. 
 U :
-1.000 +6.000 -9.000 -5.000 
+6.000 -9.000 -9.000 -5.000 
+6.000 +2.000 -5.000 +8.000 
+8.000 -1.000 +4.000 +4.000 
+2.000 +2.000 -3.000 -1.000 
 U = Q * R :
-1.000 +6.000 -9.000 -5.000 
+6.000 -9.000 -9.000 -5.000 
+6.000 +2.000 -5.000 +8.000 
+8.000 -1.000 +4.000 +4.000 
+2.000 +2.000 -3.000 -1.000 
 Press return to continue
 Press X to stop

Mathc matrices/c22s
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00k.c */
void fun(int r)
double **T = r_mR(i_mR(r,r),9.);
double **A = i_mR(r,r);
double **U = rsymmetric_mR(i_mR(r,r),9.);
double **EigsValue = i_mR(r,C1);
 clrscrn();
 r_Q_uv_mR(T,A); 
 printf(" A : If A is an orthonormal matrix\n");
 printf(" A_t*A = ID \n");
 p_mR(A,S5,P3,C6); 
 printf(" U :");
 p_mR(U,S5,P3,C6); 
 eigs_value_Au_mR(A,U,EigsValue);
 printf(" EigsValue 1: <u,v> = v^t (A^t*A) u");
 p_mR(EigsValue,S13,P4,C1);
 f_mR(A);
 f_mR(U);
 f_mR(EigsValue);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R3)+R1);
} while(stop_w());
 return 0;
/* ------------------------------------ */
Nous calculons les valeurs propres du vecteur u. 
A est une matrice orthnormale. Donc A_t*A égal la matrice identitée. 
On se retrouve donc avec le produit scalaire standard. 
Avec une matrice aléatoire cela ne fonctionne pas. Il faut trouver un autre algorithme.
 Exemple de sortie écran :
 A : If A is an orthonormal matrix
 A_t*A = ID 
+0.190 +0.614 +0.026 +0.766 
-0.664 +0.599 -0.328 -0.304 
-0.664 -0.225 +0.635 +0.324 
-0.285 -0.463 -0.699 +0.465 
 U :
-7.000 +2.000 -5.000 -3.000 
+2.000 -1.000 -5.000 -7.000 
-5.000 -5.000 +6.000 -9.000 
-3.000 -7.000 -9.000 +4.000 
 EigsValue 1: <u,v> = v^t (A^t*A) u
 +14.23599 
 -13.10550 
 +7.95822 
 -7.08869 
 Press return to continue
 Press X to stop

Mathc matrices/a23
Application
Copier la bibliothèque dans votre répertoire de travail avec les fichiers des parties précédentes :
Dans l'espace des matrices carrées de dimension n à coefficients réels, le produit scalaire usuel est :
 a b c A B C
 A = d e f B = D E F (A|B) = trace(At B) = (aA + bB + cC) + (dD + eE + fF) + (gG + hH + iI)
 g h i G H I
 a d g
 At = b e h Il suffit de ne calculer que les coefficients de la diagonale pour retrouver les calculs.
 c f i 
Présentation :

Mathc matrices/h23a
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00a.c */
void fun(int r)
double a[R2*C2]={ 2,1,
 1,1};
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(" <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\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));
 fun(rp_I(R3)+R1);
 stop();
 return 0;
/* ------------------------------------ */

Exemple de sortie écran :
 A :
 +2 +1 
 +1 +1 
 U :
 +1 
 +1 
 V :
 +3 
 +2 
 <U,V> = V^t A^t A U 
 <U,V> = 34 
 <V,U> = 34 
 Press return to continue.

Mathc matrices/h23b
Application
Installer ce fichier dans votre répertoire de travail.
/* Save as : dot_trac.h */
/* ------- <A,B> = trace(A^t B) ------- */
double dot_TR_R(
double **A,
double **B
double **At = i_mR(rsize_R(A),csize_R(A) );
double **T_AtB = i_mR(rsize_R(A),csize_R(A) );
double trace;
 transpose_mR(A,At);
 mul_mR(At,B,T_AtB);
 trace = trace_mR(T_AtB);
 f_mR(At);
 f_mR(T_AtB);
 return (trace);
/* ------------------------------------ */
/* ------ ||u|| = (u.u)^(1/2) ------- */
double norm_TR_R(
double **A
 return ( pow( dot_TR_R(A,A),(1./2.)) );
/* ------------------------------------ */
/* ------ d(u,v) = ||u-v||^(1/2) ------- */
double dist_TR_R(
double **A,
double **B
double **AmnsB = i_mR(rsize_R(A),csize_R(A));
double d;
 sub_mR(A,B,AmnsB);
/* d(u,v) = ||u-v||^(1/2) */
 d = norm_TR_R(AmnsB);
 f_mR(AmnsB);
 return (d);
/* ------------------------------------ */
/* ---- <A,B> = A^t B = B^t A --------- */
double **proj_TR_mR(
double **A,
double **B,
double **projAB
 /* <u,v> / ||v||^2 */
double s = dot_TR_R(A,B) / dot_TR_R(B,B);
/* (<u,v>/||v||^2) v */
 smul_mR(s,B,projAB);
 return(projAB); 
/* ------------------------------------ */
/* ------------------------------------ */
 Déclaration des fichiers h.

Mathc matrices/c23a
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 **B = r_mR(i_mR(r,r),9.);
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" B :");
 p_mR(B,S3,P0,C6);
 printf(" <A,B> = trace(A^t*B) = trace(B^t*A) \n\n");
 printf(" <A,B> = %.0f \n\n", dot_TR_R(A,B));
 printf(" <B,A> = %.0f \n\n", dot_TR_R(B,A));
 f_mR(A);
 f_mR(B);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R3)+R2);
} while(stop_w());
 return 0;
/* ------------------------------------ */
Nous calculons le produit scalaire trace(A^t*B).

Exemple de sortie écran :
 A :
 +2 +8 -7 
 +8 -7 -1 
 +2 -9 -3 
 B :
 -3 -7 -1 
 -3 -9 +4 
 -3 -7 -1 
 <A,B> = trace(A^t*B) = trace(B^t*A) 
 <A,B> = 40 
 <B,A> = 40 
 Press return to continue
 Press X to stop