Livre de cuisine/Fougasse d'Aigues Mortes

La fougasse d'Aigues Mortes est un dessert aromatisé à la fleur d'oranger.

Auto-éditer un wikilivre/Auto-référencer/télécharger par ftp

Critères Editions
Mathc matrices/a05
Bibliothèque
Copier la bibliothèque dans votre répertoire de travail avec les fichiers des parties précédentes :
Exemple pour tester la bibliothèque :

Mathc matrices/h05a
Bibliothèque
Installer ce fichier dans votre répertoire de travail.
/* Save as : v_a.h */
/* Standard file */
/* Usefull */
/* Create */
/* Copy */
/* Print */
/* Basic operation */
/* Determinant */
/* Gauss Jordan */
/* Rand */
/* ------------------------------------ */
 Déclaration des fichiers h.

Mathc matrices/h05b
Bibliothèque
Installer ce fichier dans votre répertoire de travail.
/* Save as : vdotu.h */
/* ------- u.v = v^t u ---------------- */
double dot_uv_R(
double **u,
double **v
double **vt = i_mR(R1, rsize_R(v));
double **vtu = i_mR(R1, C1);
double udotv;
 transpose_mR(v,vt);
 mul_mR(vt,u,vtu);
 udotv = vtu[R1][C1];
 f_mR(vt);
 f_mR(vtu);
 return (udotv);
/* ------------------------------------ */
/* ------ ||u|| = (u.u)^(1/2) ------- */
double norm_uv_R(
double **u
 return (pow(dot_uv_R(u,u),(1./2.)));
/* ------------------------------------ */
/* -- d(u,v) = ||u-v|| -- */
double dist_uv_R(
double **u,
double **v
double **umnsv = i_mR(rsize_R(v),csize_R(v));
double d;
 sub_mR(u,v,umnsv);
 d = norm_uv_R(umnsv);
 f_mR(umnsv);
 return (d);
/* ------------------------------------ */
/* (<u,v>/||v||^2) * v */
double **proj_uv_mR(
double **u,
double **v,
double **projuv
 /* <u,v> / ||v||^2 */
double s = dot_uv_R(u,v) / dot_uv_R(v,v);
 smul_mR(s,v,projuv);
 return(projuv); 
/* ------------------------------------ */
double **normalize_uv_mR(
double **U,
double **Q
double **u = i_mR(rsize_R(U),C1);
double **q = i_mR(rsize_R(U),C1); 
int c_U = csize_R(U);
int c;
 for( c = C1; c <= c_U; c++)
 c_c_mR(U,c, u,C1); 
 smul_mR(1./norm_uv_R(u),u,q);
 c_c_mR(q,C1, Q,c); 
 f_mR(u); 
 f_mR(q); 
 return(Q);
/* ------------------------------------ */
double **Normalize_uv_mR(
double **Q
double **u = i_mR(rsize_R(Q),C1);
double **q = i_mR(rsize_R(Q),C1); 
int c_Q = csize_R(Q);
int c;
 for( c = C1; c <= c_Q; c++)
 c_c_mR(Q,c, u,C1); 
 smul_mR(1./norm_uv_R(u),u, q);
 c_c_mR(q,C1, Q,c); 
 f_mR(u); 
 f_mR(q); 
 return(Q);
/* ------------------------------------ */
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);
/* ------------------------------------ */
/* ------------------------------------ */
double **xorth_uv_mR(
double **U,
double **Q
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);
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); 
 sub_mR(q,projuv, v);
 c_mR(v,q); 
 c_c_mR(q,C1, Q,c_Q);

Normalize_uv_mR(Q); 
 f_mR(u);
 f_mR(v);
 f_mR(q); 
 f_mR(projuv); 
 return(Q);
/* ------------------------------------ */
void QR_uv_mR(
double **U,
double **Q,
double **R)
double **Q_T = i_mR(csize_R(Q),rsize_R(Q));
 orth_uv_mR(U,Q,YES); 
 transpose_mR(Q,Q_T);
 mul_mR(Q_T,U, R);
 f_mR(Q_T); 
/* ------------------------------------ */
double **eigs_value_uv_mR(
double **A,
double **EigsValue
int r = rsize_R(A);
double **T = i_mR(r,r);
double **Q = i_mR(r,r);
double **R = i_mR(r,r);
int i;
int rc;
 c_mR(A,T);
 for(i=0;i<LOOP_EIGSUV;i++)
 QR_uv_mR(T,Q,R); 
 mul_mR(R,Q,T);

for(rc=R1;rc<=r;rc++)
 EigsValue[rc][C1] = T[rc][rc];

f_mR(T);
 f_mR(Q);
 f_mR(R); 
 return(EigsValue); 
/* ------------------------------------ */
double **svd_sqrt_uv_mR(
double **A,
double **sqrtA
int r;
int c;
 dif_sizes_mR(A,sqrtA,"svd_sqrt_mR();","(A or sqrtA)");
 for ( r=R1; r<A[R_SIZE][C0]; r++)
 for ( c=C1; c<A[C_SIZE][C0]; c++)
 sqrtA[r][c] = sqrt(A[r][c]);
 return(sqrtA);
/* ------------------------------------ */
double **svd_inv_D_uv_mR(
double **S,
double **invS
int r;
int c;
 dif_sizes_mR(S,invS, "svd_inv_D_uv_mR();","(S,invS)");
 for ( r=R1; r<S[R_SIZE][C0]; r++)
 for ( c=C1; c<S[C_SIZE][C0]; c++)
 if(r==c)
 if(fabs(S[r][c]) < ERROR_E) 
 invS[r][c] = 0;
 else invS[r][c] = (1./S[r][c]);
 else
 invS[r][c] = 0;
 return(invS);
/* ------------------------------------ */
/* ------------------------------------ */
double **svd_value_uv_mR(
double **A,
double **SvdValue)
int rA = rsize_R(A);
int cA = csize_R(A);
double **A_T = i_mR(cA,rA);
double **S = i_mR(cA,cA);
double **SvdValue_2 = i_mR(cA,C1);
 transpose_mR(A,A_T);
 mul_mR(A_T,A, S); 
 eigs_value_uv_mR(S,SvdValue_2);
 svd_sqrt_uv_mR(SvdValue_2,SvdValue);
 f_mR(A_T);
 f_mR(S);
 f_mR(SvdValue_2);
 return(SvdValue); 
/* ------------------------------------ */
 Déclaration des fichiers h.

Mathc matrices/c05a
Application 
Installer et compiler ces fichiers dans votre répertoire de travail.
/* Save as : c00a.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,P0,C6); 
 printf(" Copy/Past into the octave windows \n\n");
 p_Octave_mR(A,"a",P0);
 printf(" [Q, R] = qr (a,0) \n\n");
 stop();
 clrscrn();
 QR_uv_mR(A,Q,R); 
 printf(" Q :");
 p_mR(Q,S10,P4,C6); 
 printf(" R :");
 p_mR(R,S10,P4,C6);
 stop();
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6); 
 printf(" A = Q * R :"); 
 mul_mR(Q,R, A);
 p_mR(A,S10,P4,C6); 
 f_mR(A);
 f_mR(Q);
 f_mR(R);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R3),rp_I(C3));
} while(stop_w());
 return 0;
/* ------------------------------------ */
 La matrice A doit avoir plus de lignes que de colonnes ou être carrée

Exemple de sortie écran :
 A :
 +9, +5, -5, 
 +4, +3, -8, 
 +2, +4, -6, 
 -3, -3, -3, 
 +1, +6, +7, 
 -5, +4, -5 
 Copy/Past into the octave windows 
 a=[
+9,+5,-5;
+4,+3,-8;
+2,+4,-6;
-3,-3,-3;
+1,+6,+7;
-5,+4,-5]
 [Q, R] = qr (a,0) 
 Press return to continue. 
 Q :
 +0.7717 +0.1120 -0.1151 
 +0.3430 +0.1344 -0.4608 
 +0.1715 +0.3391 -0.3319 
 -0.2572 -0.1823 -0.3280 
 +0.0857 +0.6046 +0.6397 
 -0.4287 +0.6750 -0.3840 
 R :
 +11.6619 +5.1450 -4.1160 
 +0.0000 +9.1940 -2.2649 
 -0.0000 +0.0000 +13.6356 
 Press return to continue. 
 -----------------------------------
 A :
 +9 +5 -5 
 +4 +3 -8 
 +2 +4 -6 
 -3 -3 -3 
 +1 +6 +7 
 -5 +4 -5 
 A = Q * R :
 +9.0000 +5.0000 -5.0000 
 +4.0000 +3.0000 -8.0000 
 +2.0000 +4.0000 -6.0000 
 -3.0000 -3.0000 -3.0000 
 +1.0000 +6.0000 +7.0000 
 -5.0000 +4.0000 -5.0000 
 Press return to continue
 Press X to stop