Exemple de sortie écran :
 A : Orthogonal
 +34.0000 -52.5770 +31.0235 
 -62.0000 -117.0067 -2.8444 
 +72.0000 -75.9277 -17.0993 
 b[C0] b[C1] b[C2] :
 +58.0 -40.0 +39.0 
 -49.0 -42.0 -74.0 
 -26.0 -3.0 -5.0 
 Ab :
 +34.0000 -52.5770 +31.0235 +58.0000 -40.0000 +39.0000 
 -62.0000 -117.0067 -2.8444 -49.0000 -42.0000 -74.0000 
 +72.0000 -75.9277 -17.0993 -26.0000 -3.0000 -5.0000 
 gj_TP_mR(Ab) : x[C0] x[C1] x[C2]
 +1.0000 +0.0000 -0.0000 +0.3081 +0.1009 +0.5454 
 +0.0000 +1.0000 +0.0000 +0.2096 +0.3261 +0.3145 
 +0.0000 +0.0000 +1.0000 +1.8871 -0.8474 +1.1924 
 Press return to continue. 
 --------------------------------
 a[0] :
 +3.4000e+01 
 -6.2000e+01 
 +7.2000e+01 
 a[1] :
 -5.2577e+01 
 -1.1701e+02 
 -7.5928e+01 
 a[2] :
 +3.1023e+01 
 -2.8444e+00 
 -1.7099e+01 
 Press return to continue. 
 --------------------------------
 b[0] :
 +58.0000 
 -49.0000 
 -26.0000 
 b[1] :
 -40.0000 
 -42.0000 
 -3.0000 
 b[2] :
 +39.0000 
 -74.0000 
 -5.0000 
 Press return to continue. 
 --------------------------------
 x[C0] :
 +0.3081304 <b[C0],a[0]> / ||a[0||**2
 +0.2096309 <b[C0],a[1]> / ||a[1||**2
 +1.8871285 <b[C0],a[2]> / ||a[2||**2
 x[C1] :
 +0.1009427 <b[C0],a[0]> / ||a[0||**2
 +0.3260652 <b[C0],a[1]> / ||a[1||**2
 -0.8473746 <b[C0],a[2]> / ||a[2||**2
 x[C2] :
 +0.5453653 <b[C0],a[0]> / ||a[0||**2
 +0.3144759 <b[C0],a[1]> / ||a[1||**2
 +1.1923792 <b[C0],a[2]> / ||a[2||**2
 gj_TP_mR(Ab) : x[C0] x[C1] x[C2]
 +1.0000000 +0.0000000 -0.0000000 +0.3081304 +0.1009427 +0.5453653 
 +0.0000000 +1.0000000 +0.0000000 +0.2096309 +0.3260652 +0.3144759 
 +0.0000000 +0.0000000 +1.0000000 +1.8871285 -0.8473746 +1.1923792 
 Press return to continue
 Press X to stop

Mathc matrices/c26h
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* Save as : cq7.c */
void fun(void)
double ta[RA*CA]={
-32.000000000000, +42.738773415448, +7.431481213965, 
-32.000000000000, -9.261226584552, -49.077576438090, 
-43.000000000000, -24.913523222992, +30.992442957488 
double tb[RA*CB]={
 +90.0000, -88.0000, +26.0000, 
 -79.0000, +60.0000, -67.0000, 
 +77.0000, -34.0000, +33.0000 
double **A = ca_A_mR(ta,i_mR(RA,CA));
double **B = ca_A_mR(tb,i_mR(RA,CB));
double **Ab = i_Abr_Ac_bc_mR(RA,CA,CB);
double **b[CB];
double **a[CA];
int c;
 clrscrn();
 printf(" A : Orthogonal");
 p_mR(A,S9,P4,C6);
 printf(" b[C0] b[C1] b[C2] :");
 p_mR(B,S9,P1,C6);
 printf(" Ab :");
 c_A_b_Ab_mR(A,B,Ab);
 p_mR(Ab,S9,P4,C6);
 printf(" gj_TP_mR(Ab) : x[C0] x[C1] x[C2]");
 gj_TP_mR(Ab);
 p_mR(Ab,S9,P4,C6);
 stop();
/* ------------------------------------ */
 for(c=C0; c<CB; c++)
 b[c] = i_mR(RA,C1); 
 c_c_mR(B,(c+C1),b[c],C1); } 
 for(c=C0; c<CA; c++)
 a[c] = i_mR(RA,C1); 
 c_c_mR(A,(c+C1),a[c],C1); } 
/* ------------------------------------ */ 
 clrscrn(); 
 for(c=C0; c<CA; c++)
 printf(" a[%d] :",c); 
 pE_mR(a[c],S12,P4,C6); } 
 stop();
 clrscrn(); 
 for(c=C0; c<CB; c++)
 printf(" b[%d] :",c); 
 p_mR(b[c],S12,P4,C6); } 
 stop();
 clrscrn(); 
 printf(" x[C0] :\n"); 
 for(c=C0; c<CA; c++) 
 printf("%+15.7f <b[C0],a[%d]> / ||a[%d||**2\n",
 dot_uv_R(b[C0],a[c])/
 dot_uv_R(a[c],a[c]), c,c); 
 printf("\n x[C1] :\n"); 
 for(c=C0; c<CA; c++) 
 printf("%+15.7f <b[C0],a[%d]> / ||a[%d||**2\n",
 dot_uv_R(b[C1],a[c])/
 dot_uv_R(a[c],a[c]), c,c); 
 printf("\n x[C2] :\n"); 
 for(c=C0; c<CA; c++) 
 printf("%+15.7f <b[C0],a[%d]> / ||a[%d||**2\n",
 dot_uv_R(b[C2],a[c])/
 dot_uv_R(a[c],a[c]), c,c); 
 printf("\n gj_TP_mR(Ab) :\t\t\t x[C0] x[C1] x[C2]");
 p_mR(Ab,S12,P7,C6); 
 stop();
/* ------------------------------------ */
 for(c=C0; c<CA; c++) 
 f_mR(a[c]); 
 for(c=C0; c<CB; c++) 
 f_mR(b[c]); 
/* ------------------------------------ */ 
 f_mR(Ab);
 f_mR(B);
 f_mR(A);
/* ------------------------------------ */
int main(void)
 fun();
 return 0;
/* ------------------------------------ */
 Résoudre un système d'équation quand A est une matrice orthogonale : 
 Ici B est composé de trois vecteurs.

Exemple de sortie écran :
 A : Orthogonal
 -32.0000 +42.7388 +7.4315 
 -32.0000 -9.2612 -49.0776 
 -43.0000 -24.9135 +30.9924 
 b[C0] b[C1] b[C2] :
 +90.0 -88.0 +26.0 
 -79.0 +60.0 -67.0 
 +77.0 -34.0 +33.0 
 Ab :
 -32.0000 +42.7388 +7.4315 +90.0000 -88.0000 +26.0000 
 -32.0000 -9.2612 -49.0776 -79.0000 +60.0000 -67.0000 
 -43.0000 -24.9135 +30.9924 +77.0000 -34.0000 +33.0000 
 gj_TP_mR(Ab) : x[C0] x[C1] x[C2]
 +1.0000 +0.0000 -0.0000 -0.9400 +0.6051 -0.0275 
 +0.0000 +1.0000 +0.0000 +1.0500 -1.3697 +0.3591 
 +0.0000 +0.0000 +1.0000 +2.0244 -1.3586 +1.3153 
 Press return to continue. 
 --------------------------------
 a[0] :
 -3.2000e+01 
 -3.2000e+01 
 -4.3000e+01 
 a[1] :
 +4.2739e+01 
 -9.2612e+00 
 -2.4914e+01 
 a[2] :
 +7.4315e+00 
 -4.9078e+01 
 +3.0992e+01 
 Press return to continue. 
 b[0] :
 +90.0000 
 -79.0000 
 +77.0000 
 b[1] :
 -88.0000 
 +60.0000 
 -34.0000 
 b[2] :
 +26.0000 
 -67.0000 
 +33.0000 
 Press return to continue. 
 --------------------------------
 x[C0] :
 -0.9399538 <b[C0],a[0]> / ||a[0||**2
 +1.0500299 <b[C0],a[1]> / ||a[1||**2
 +2.0244267 <b[C0],a[2]> / ||a[2||**2
 x[C1] :
 +0.6050808 <b[C0],a[0]> / ||a[0||**2
 -1.3697387 <b[C0],a[1]> / ||a[1||**2
 -1.3586067 <b[C0],a[2]> / ||a[2||**2
 x[C2] :
 -0.0274570 <b[C0],a[0]> / ||a[0||**2
 +0.3590776 <b[C0],a[1]> / ||a[1||**2
 +1.3153283 <b[C0],a[2]> / ||a[2||**2
 gj_TP_mR(Ab) : x[C0] x[C1] x[C2]
 +1.0000000 +0.0000000 -0.0000000 -0.9399538 +0.6050808 -0.0274570 
 +0.0000000 +1.0000000 +0.0000000 +1.0500299 -1.3697387 +0.3590776 
 +0.0000000 +0.0000000 +1.0000000 +2.0244267 -1.3586067 +1.3153283 
 Press return to continue.

Programmation Java Swing/Version imprimable

Programmation JavaFX/Version imprimable
Mathématiques avec Python et Ruby/Sommaire1

Mathématiques avec Python et Ruby/Sommaire2

Mathématiques avec Python et Ruby/Version imprimable1

Mathématiques avec Python et Ruby/Version imprimable2

Mathc matrices/c26i
Fonctions de bases
Mathc matrices/c26j
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : gj_s2.c */
void fun(int r)
double **Ab = r_singular_Ab_mR(i_Abr_Ac_bc_mR(r,r,C1),999);
double **A = c_Ab_A_mR(Ab,i_mR(r,r));
double **b = c_Ab_b_mR(Ab,i_mR(r,C1));
 clrscrn();
 printf(" A :");
 p_mR(A,S8,P0,C7);
 printf(" b :");
 r_mR(b,999.); /* I change the value of b */
 p_mR(b,S8,P0,C7); 
 printf(" Ab :");
 p_mR(c_A_b_Ab_mR(A,b,Ab),S8,P0,C7);
 stop();
 clrscrn();
 printf(" Copy/Past into the octave window.\n\n");
 p_Octave_mR(Ab,"Ab",P0);
 printf("\n rref(Ab.00000000001)\n\n");
 stop();
 clrscrn();
 printf(" gj_mR(Ab) :");
 gj_PP_mR(Ab,YES);
 p_mR(Ab,S10,P4,C7);
 is_system_consistent_mR(Ab);
 f_mR(Ab);
 f_mR(b);
 f_mR(A);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
do
 fun(rp_I(R5)+R1);
} while(stop_w());
 return 0;
/* ------------------------------------ */
 Système d'équations incompatibles ! +0.00000 == +654.00000 et +0.00000 == +526.00000

Exemple de sortie écran :
 A :
 -255 -569 -35 -391 -155 
 +380 +426 +622 -899 -779 
 -497 -429 -509 -655 +20 
 +380 +426 +622 -899 -779 
 +380 +426 +622 -899 -779 
 b :
 +424 
 +80 
 +208 
 +734 
 +606 
 Ab :
 -255 -569 -35 -391 -155 +424 
 +380 +426 +622 -899 -779 +80 
 -497 -429 -509 -655 +20 +208 
 +380 +426 +622 -899 -779 +734 
 +380 +426 +622 -899 -779 +606 
 Press return to continue. 
 Copy/Past into the octave window.
 Ab=[
-255,-569,-35,-391,-155,+424;
+380,+426,+622,-899,-779,+80;
-497,-429,-509,-655,+20,+208;
+380,+426,+622,-899,-779,+734;
+380,+426,+622,-899,-779,+606]
 rref(Ab.00000000001)
 Press return to continue. 
 gj_mR(Ab) :
 +1.00000 +0.00000 +0.00000 +8.74503 +3.88021 -1.38717 
 +0.00000 +1.00000 -0.00000 -2.93820 -1.29837 -0.19161 
 +0.00000 +0.00000 +1.00000 -4.77563 -2.73372 +1.10732 
 +0.00000 +0.00000 +0.00000 -0.00000 +0.00000 +654.00000 
 +0.00000 +0.00000 +0.00000 -0.00000 +0.00000 +526.00000 
 This(ese) row(s) are incompatible.
 row 4; row 5; 
 The system is inconsistent. 
 I prefer to close the program.
 Press return to continue.