Exemple de sortie écran :
 u :
 +4 
 -4 
 -5 
 v :
 -5 
 -6 
 -6 
 Vector component of u along v 
 projuv : [ (<u,v> / ||v||^2) * v ]
-1.753 
-2.103 
-2.103 
 Press return to continue
 Press X return to stop

Mathc matrices/c05k
Installer et compiler ces fichiers dans votre répertoire de travail.
/* Save as : c05k.c */
void fun(int r)
double **u = r_mR(i_mR(r,C1),9.);
double **v = r_mR(i_mR(r,C1),9.);
double **projuv = i_mR(r,C1);
double **umnsprojuv = i_mR(r,C1);
 clrscrn();
 printf(" u :");
 p_mR(u,S3,P0,C6);
 printf(" v :");
 p_mR(v,S3,P0,C6);
 proj_uv_mR(u,v,projuv);
 printf(" Vector component of u along v \n\n"); 
 printf(" projuv : [ (<u,v> / ||v||^2) * v ]");
 p_mR(projuv,S3,P3,C6);
 stop();
 clrscrn();
 printf(" Vector component of (u-projuv) is orthogonal to v \n\n");
 printf(" u - projuv :");
 sub_mR(u,projuv,umnsprojuv);
 p_mR(umnsprojuv,S3,P3,C6);
 printf(" <v,u-projuv> = %.6f \n\n", dot_uv_R(v,umnsprojuv));
 f_mR(u);
 f_mR(v);
 f_mR(projuv);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R3)+R2);
} while(stop_w());
 return 0;
/* ------------------------------------ */
 Nous vérifions une des propriétés du projeté de u sur v : <v,u-projuv> = -0.000000

Exemple de sortie écran :
 u :
 +4 
 -3 
 +8 
 -4 
 v :
 +3 
 -3 
 -3 
 +6 
 Vector component of u along v 
 projuv : [ (<u,v> / ||v||^2) * v ]
-1.286 
+1.286 
+1.286 
-2.571 
 Press return to continue. 
 -------------------------------
 Vector component of (u-projuv) is orthogonal to v 
 u - projuv :
+5.286 
-4.286 
+6.714 
-1.429 
 <v,u-projuv> = 0.000000 
 Press return to continue
 Press X return to stop

Mathc matrices/c05l
 Présentation de la fonction orth_uv_mR();
/* ------------------------------------ */
double **orth_uv_mR(
double **U,
double **Q,
int Normal /* YES = 1 NO = 0 */
double **u = i_mR(rsize_R(U),C1);
double **v = i_mR(rsize_R(U),C1);
double **q = i_mR(rsize_R(U),C1);
double **projuv = i_mR(rsize_R(U),C1);
double **tq = i_mR(rsize_R(U),C1);
int c_U; 
int c_Q;
 c_c_mR(U,C1, Q,C1); 
 for( c_U = C2; c_U < U[C_SIZE][C0]; c_U++)
 c_c_mR(U,c_U, u,C1);
 c_c_mR(U,c_U, q,C1);
 for( c_Q = C1; c_Q < c_U; c_Q++)
 c_c_mR(Q,c_Q, v,C1); 
 proj_uv_mR(u,v, projuv); /* [<u,v> / ||v||^2] * v */ 
 sub_mR(q, projuv, tq); 
 c_mR( tq, q); 
 c_c_mR(q,C1, Q,c_Q);

if(Normal) Normalize_uv_mR(Q); 
 f_mR(u);
 f_mR(v);
 f_mR(q); 
 f_mR(projuv); 
 f_mR(tq);
 return(Q);
/* ------------------------------------ */
 L'algorithme de Gram-Schmidt

U = {u1,u2,u3,u4} Une base de U donnée dans l'exercice.
 V = {v1,v2,v3} La base orthonormale, calculée par l'algorithme de Gram-Schmidt.
 <u2.v1>
 Le projeté de u2 sur v1 = --------- v1
 |v1||**2

a) v1 = u1
 <u2.v1>
 b) v2 = u2 - --------- v1
 ||v1||**2

<u3.v1> <u3.v2>
 c) v3 = u3 - --------- v1 - --------- v2
 ||v1||**2 ||v2||**2

<u4.v1> <u4.v2> <u4.v3>
 c) v4 = u4 - --------- v1 - --------- v2 - --------- v3
 ||v1||**2 ||v2||**2 ||v3||**2

Il faut ensuite normaliser les vecteurs v pour obtenir une base orthonormale. 
 "

Mathc matrices/c05m
Application ou Pseudo Inverse 
Installer et compiler ces fichiers dans votre répertoire de travail.
/* Save as : c01e.c */
/* ------------------------------------ */
void fun(void)
double tA[RA*CA]={
/* x**0 x**1 x**2 x**3 x**4 */
 1, 1., 1., 1., 1., 
 1, 2., 4., 8., 16., 
 1, 3., 9., 27., 81., 
 1, 4., 16., 64., 256., 
 1, 5., 25., 125., 625. 
double tb[RA*C1]={
/* y */
 -5.,
 8.,
 -7.,
 1.,
 -4.
double **A = ca_A_mR(tA,i_mR(RA,CA));
double **b = ca_A_mR(tb,i_mR(RA,C1));
double **Pinv = i_mR(CA,RA); 
double **Pinvb = i_mR(CA,C1); 
 clrscrn();
 printf(" Fitting a linear Curve to Data :\n\n");
 printf(" A :");
 p_mR(A,S10,P2,C7);
 printf(" b :");
 p_mR(b,S10,P2,C7);
 printf(" Pinv = V * invS_T * U_T ");
 pseudo_Rn_uv_mR(A,Pinv,FACTOR_E); 
 pE_mR(Pinv,S12,P4,C10); 
 printf(" x = Pinv * b "); 
 mul_mR(Pinv,b,Pinvb); 
 p_mR(Pinvb,S10,P4,C10);
 printf(" The Quartic equation Curve to Data : \n\n"
 " s = %+.3f %+.3f*t %+.3f*t**2 %+.3f*t**3 %+.3f*t**4\n\n"
 ,Pinvb[R1][C1],Pinvb[R2][C1],Pinvb[R3][C1],
 Pinvb[R4][C1],Pinvb[R5][C1]); 
 stop(); 
 f_mR(b); 
 f_mR(A); 
 f_mR(Pinv);
 f_mR(Pinvb); 
/* ------------------------------------ */
int main(void)

fun();
 return 0;
/* ------------------------------------ */

Exemple de sortie écran :
 Fitting a linear Curve to Data :
 A :
 +1.00 +1.00 +1.00 +1.00 +1.00 
 +1.00 +2.00 +4.00 +8.00 +16.00 
 +1.00 +3.00 +9.00 +27.00 +81.00 
 +1.00 +4.00 +16.00 +64.00 +256.00 
 +1.00 +5.00 +25.00 +125.00 +625.00 
 b :
 -5.00 
 +8.00 
 -7.00 
 +1.00 
 -4.00 
 Press return to continue. 
 -----------------------------------
 Pinv = V * invS_T * U_T 
 +5.0000 -10.0000 +10.0000 -5.0000 +1.0000 
 -6.4167 +17.8333 -19.5000 +10.1667 -2.0833 
 +2.9583 -9.8333 +12.2500 -6.8333 +1.4583 
 -0.5833 +2.1667 -3.0000 +1.8333 -0.4167 
 +0.0417 -0.1667 +0.2500 -0.1667 +0.0417 
 x = Pinv * b 
 -183.9999 
 +329.7500 
 -191.8750 
 +44.7500 
 -3.6250 
 The Quartic equation Curve to Data : 
 s = -184.000 +329.750*t -191.875*t**2 +44.750*t**3 -3.625*t**4

Mathc matrices/c05n
Installer et compiler ces fichiers dans votre répertoire de travail.
/* Save as : c05n.c */
void fun(int r,int rn)
double **A = r_mR(i_mR(r+rn,r),9.);
double **Q = i_mR(r+rn,r);
double **R = i_mR(r,r);
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P3,C6);
 QR_uv_mR(A,Q,R);
 printf(" Q :");
 p_mR(Q,S3,P5,C6);
 printf(" R :");
 p_mR(R,S10,P5,C6);
 stop();
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P3,C6);
 printf(" A = Q * R :"); 
 mul_mR(Q,R, A);
 p_mR(A,S3,P3,C6); 
 f_mR(A);
 f_mR(Q);
 f_mR(R);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R2)+R2,rp_I(R3));
} while(stop_w());
 return 0;
/* ------------------------------------ */
 Le travail précédent nous conduit à la factorisation QR : QR_uv_mR(A,Q,R);

Exemple de sortie écran :
 A :
-7.000 +2.000 -6.000 
-9.000 +1.000 +8.000 
-8.000 -7.000 +4.000 
+9.000 +4.000 +3.000 
 Q :
-0.42212 +0.51751 -0.56036 
-0.54272 +0.44887 +0.69441 
-0.48242 -0.68784 +0.17652 
+0.54272 +0.23997 +0.41549 
 R :
 +16.58312 +4.16086 -2.11058 
 -0.00000 +7.25860 -1.54550 
 -0.00000 +0.00000 +10.87000 
 Press return to continue. 
 -----------------------------
 A :
-7.000 +2.000 -6.000 
-9.000 +1.000 +8.000 
-8.000 -7.000 +4.000 
+9.000 +4.000 +3.000 
 A = Q * R :
-7.000 +2.000 -6.000 
-9.000 +1.000 +8.000 
-8.000 -7.000 +4.000 
+9.000 +4.000 +3.000 
 Press return to continue
 Press X return to stop

Mathc matrices/e05a
Propriétés
Mathc matrices/cq051
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* Save as : cq1.c */
void fun(int r)
double **Q = r_Q_mR(i_mR(r,r), 9);
 clrscrn();
 printf(" Q : An orthonormal matrix\n\n"
 " det(Q) = 1 or -1\n\n");
 p_mR(Q,S3,P3,C6);
 printf(" det(Q) = %.0f\n\n",det_R(Q)); 
 f_mR(Q);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R3)+R2);
} while(stop_w());
 return 0;
/* ------------------------------------ */
 La création de matrices aléatoires orthogonales : r_Q_mR(U,Q);

Exemple de sortie écran :
 Q : An orthogonal matrix (orthonormal !!)
 det(Q) = 1 or -1
+0.150 +0.082 +0.870 -0.449 +0.108 
+0.600 +0.329 -0.153 +0.133 +0.701 
-0.375 +0.373 -0.375 -0.734 +0.203 
-0.525 -0.481 +0.127 +0.145 +0.675 
-0.450 +0.717 +0.250 +0.469 +0.013 
 det(Q) = -1
 Press return to continue
 Press X to stop