Mathc matrices/a195
Application 
formula_1
a) Préparation du système :
double ab[RA*(CA+C1)]={
// x1 x2 x3 x4 b
 +0, +0, -0, -0, 0, //C
 +0, +0, -0, -0, 0, //H
 +0, +0, -0, -0, 0, //O 
b) On commence par la première colonne :
formula_2
double ab[RA*(CA+C1)]={
// x1 x2 x3 x4 b
 +3, +0, -0, -0, 0, //C
 +8, +0, -0, -0, 0, //H
 +0, +0, -0, -0, 0, //O 
c) On continu avec la deuxième colonne :
formula_3
double ab[RA*(CA+C1)]={
// x1 x2 x3 x4 b
 +3, +0, -0, -0, 0, //C
 +8, +0, -0, -0, 0, //H
 +0, +2, -0, -0, 0, //O 
d) Le final nous donnera :
formula_1

double ab[RA*(CA+C1)]={
// x1 x2 x3 x4 b
 +3, +0, -1, -0, 0, //C
 +8, +0, -0, -2, 0, //H
 +0, +2, -2, -1, 0, //O 
Il faut maintenant introduire ce système dans le fichier c00a.c.

Le mouvement Wikimédia
Mathc matrices/a198
Application 
formula_1
a) Préparation du système :
double ab[RA*(CA+C1)]={
// x1 x2 x3 x4 b
 +0, +0, -0, -0, 0, //N
 +0, +0, -0, -0, 0, //H
 +0, +0, -0, -0, 0, //O 
b) On commence par la première colonne :
formula_2
double ab[RA*(CA+C1)]={
// x1 x2 x3 x4 b
 +1, +0, -0, -0, 0, //N
 +3, +0, -0, -0, 0, //H
 +0, +0, -0, -0, 0, //O 
c) On continu avec la deuxième colonne :
formula_3
double ab[RA*(CA+C1)]={
// x1 x2 x3 x4 b
 +1, +0, -0, -0, 0, //N
 +3, +0, -0, -0, 0, //H
 +0, +2, -0, -0, 0, //O 
d) Le final nous donnera :
formula_1

double ab[RA*(CA+C1)]={
// x1 x2 x3 x4 b
 1, 0, -1, -0, 0, //N
 3, 0, -0, -2, 0, //H
 0, 2, -1, -1, 0, //O 
Il faut maintenant introduire ce système dans le fichier c00a.c.

Mathc matrices/a205
Application 
Dans cet algorithme le pivot choisi est la plus grande valeur absolue qui se trouve dans la matrice A. Pour cela on fait des échanges de lignes et de colonnes. Attention on ne touche pas à b.
Résoudre : Ax = b
Résoudre : A|x1|x2| ... |xn| = b1|b2| ... |bn|
Inverser : A|ID

Mathc matrices/a206
Application 
L'algorithme consiste à vérifier si la matrice A n'est pas singulière. Si elle n'est pas singulière on appelle la fonction gj_TP_mR(Ab); Si la matrice n'est pas carré, on prend une sous matrice de A qui a r lignes et r colonnes ou r est le nombre de lignes de A pour calculer le déterminant. (voir la fonction c_Ab_subArxr_mR(Ab,A);
Résoudre : Ax = b; A[r][c] ... :c > r (matrices avec plus de colonnes que de lignes. Il faudra introduire les variables libres) :
Les variables libres :

Mathc matrices/a207
Application 
Inverser une matrice avec la fonction invgj_mR(A,Inv)
Résoudre : Ax = B avec l'inverse de A
Résoudre : A|x1|x2| ... |xn| = b1|b2| ... |bn| avec l'inverse de A

Mathc matrices/a208
Application 
Le mouvement Wikimédia2/Version imprimable

Mathc matrices/a209
Application
Mathc matrices/a211
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* Save as : c00a.c */
int main(void)
double ab[RA*(CA+Cb)]={
// x1 x2 x3 
 +1, +1, +0, +0, +50, // A
 +0, -1, -1, +0, -40, // B
 +0, +0, +1, +0, +20 -10, // C
 -1, +0, +0, +0, -30 +10 // D 
double **Ab = ca_A_mR(ab,i_Abr_Ac_bc_mR(RA,CA,Cb));
double **A = c_Ab_A_mR(Ab,i_mR(RA,CA));
double **b = c_Ab_b_mR(Ab,i_mR(RA,Cb));
 clrscrn();
 printf(" A :");
 p_mR(A,S5,P0,C7);
 printf(" b :");
 p_mR(b,S5,P0,C7);
 printf(" Ab :");
 p_mR(Ab,S5,P0,C7);
 getchar();
 clrscrn();
 printf(" Copy/Past into the octave window.\n\n");
 p_Octave_mR(Ab,"Ab",P0);
 printf("\n rref(Ab.00000000001)\n\n");
 printf(" gj_TP_mR(Ab) :\n\n"
 " x1 x2 x3 ");
 gj_TP_mR(Ab);
 p_mR(Ab,S5,P0,C7);
 stop();
 f_mR(Ab);
 f_mR(b);
 f_mR(A);
 return 0;
/* ------------------------------------ */

Exemple de sortie écran :
 A :
 +1 +1 +0 +0 
 +0 -1 -1 +0 
 +0 +0 +1 +0 
 -1 +0 +0 +0 
 b :
 +50 
 -40 
 +10 
 -20 
 Ab :
 +1 +1 +0 +0 +50 
 +0 -1 -1 +0 -40 
 +0 +0 +1 +0 +10 
 -1 +0 +0 +0 -20 
 ------------------------------------ 
 Copy/Past into the octave window.
 Ab=[
+1,+1,+0,+0,+50;
+0,-1,-1,+0,-40;
+0,+0,+1,+0,+10;
-1,+0,+0,+0,-20]
 rref(Ab.00000000001)
 gj_TP_mR(Ab) :
 x1 x2 x3 
 +1 +0 +0 +0 +20 
 -0 +1 +0 -0 +30 
 +0 +0 +1 +0 +10 
 +0 +0 +0 +0 +0 
 Press return to continue.

Mathc matrices/a210
Application
En regardant le réseau nous pouvons écrire :
 Entrées = Sortie
 A = x1 + x2 = 50
 B = 40 = x2 + x3
 C = x3 + x4 = 20
 D = 30 = x1 + x4
posons x4 = 10 
 A = x1 + x2 = 50
 B = 40 = x2 + x3
 C = x3 + 10 = 20
 D = 30 = x1 + 10
arrangeons le système
 x1 + x2 = 50
 -x2 - x3 = -40
 x3 = 20 -10
 -x1 = -30 + 10
Soit
 x1 x2 x3
 +x1 +x2 +0 +0 +50 // A
 +0 -x2 -x3 +0 -40 // B
 +0 +0 +x3 +0 +20 -10 // C
 -x1 +0 +0 +0 -30 +10 // D
Le code en langage C :
double ab[RA*(CA+Cb)]={
// x1 x2 x3 
 +1, +1, +0, +0, +50, // A
 +0, -1, -1, +0, -40, // B
 +0, +0, +1, +0, +20 -10, // C
 -1, +0, +0, +0, -30 +10 // D

La solution est donné par la résolution du système :
 x1 x2 x3 
 +1 +0 +0 +0 +20 
 -0 +1 +0 -0 +30 
 +0 +0 +1 +0 +10 
 +0 +0 +0 +0 +0 
 x1 = 20; x2 = 30; x3 = 10;
 avec x4 = 10

Mathc matrices/a212
Application
En regardant le réseau nous pouvons écrire :
 Entrées = Sorties
 A = x1 = 20 + x2
 B = x2 + x3 + x5 = 60
 C = x4 = 20 + x3
 D = 100 = x1 + x4 + x5

posons x2 = 10 et x5 = 30
 A = x1 = 20 + 10
 B = 10 + x3 + 30 = 60
 C = x4 = 20 + x3
 D = 100 = x1 + x4 + 30

arrangeons le système
 x1 = 20 + 10
 x3 = 60 - 10 -30
 x4 - x3 = 20
 -x1 - x4 = -100 + 30
 Soit
 x1 +0 +0 +0 20 + 10 // A
 +0 x3 +0 +0 60 - 10 -30 // B
 +0 -x3 x4 +0 +20 // C
 -x1 +0 -x4 +0 -100 + 30 // D
Le code en langage C :
double ab[RA*(CA+Cb)]={
// x1 x3 x4 
 +1, +0, +0, +0, +20+10, // A
 +0, +1, +0, +0, +60 -10 -30, // B 
 +0, -1, +1, +0, +20, // C
 -1, +0, -1, +0, -100+30, // D

La solution est donné par la résolution du système :
 x1 x3 x4 
 +1 +0 +0 +0 +30 
 +0 +1 +0 +0 +20 
 +0 +0 +1 +0 +40 
 +0 +0 +0 +0 +0 
 x1 = +30; x3 = +20; x4 = +40;
 et x2 = +10; x5 = +30;

Mathc matrices/a213
Application
Installer et compiler ces fichiers dans votre répertoire de travail.
/* Save as : c00a.c */
int main(void)
double ab[RA*(CA+Cb)]={
// x1 x3 x4 
 +1, +0, +0, +0, +20+10, // A
 +0, +1, +0, +0, +60 -10 -30, // B 
 +0, -1, +1, +0, +20, // C
 -1, +0, -1, +0, -100+30, // D 
double **Ab = ca_A_mR(ab,i_Abr_Ac_bc_mR(RA,CA,Cb));
double **A = c_Ab_A_mR(Ab,i_mR(RA,CA));
double **b = c_Ab_b_mR(Ab,i_mR(RA,Cb));
 clrscrn();
 printf(" A :");
 p_mR(A,S5,P0,C7);
 printf(" b :");
 p_mR(b,S5,P0,C7);
 printf(" Ab :");
 p_mR(Ab,S5,P0,C7);
 getchar();
 clrscrn();
 printf(" Copy/Past into the octave window.\n\n");
 p_Octave_mR(Ab,"Ab",P0);
 printf("\n rref(Ab.00000000001)\n\n");
 printf(" gj_TP_mR(Ab) :\n\n"
 " x1 x3 x4 ");
 gj_TP_mR(Ab);
 p_mR(Ab,S5,P0,C7);
 stop();
 f_mR(Ab);
 f_mR(b);
 f_mR(A);
 return 0;
/* ------------------------------------ */

Exemple de sortie écran :
 A :
 +1 +0 +0 +0 
 +0 +1 +0 +0 
 +0 -1 +1 +0 
 -1 +0 -1 +0 
 b :
 +30 
 +20 
 +20 
 -70 
 Ab :
 +1 +0 +0 +0 +30 
 +0 +1 +0 +0 +20 
 +0 -1 +1 +0 +20 
 -1 +0 -1 +0 -70 
 ------------------------------------ 
 Copy/Past into the octave window.
 Ab=[
+1,+0,+0,+0,+30;
+0,+1,+0,+0,+20;
+0,-1,+1,+0,+20;
-1,+0,-1,+0,-70]
 rref(Ab.00000000001)
 gj_TP_mR(Ab) :
 x1 x3 x4 
 +1 +0 +0 +0 +30 
 +0 +1 +0 +0 +20 
 +0 +0 +1 +0 +40 
 +0 +0 +0 +0 +0 
 Press return to continue.

Mathc matrices/a214
Application
En regardant le réseau nous pouvons écrire :
 Entrées = Sorties
 A = x1 = x2 + x3
 B = x2 + x4 = x5 
 C = x5 + x6 = x7
 D = x3 + x7 = x8
 E = x8 = x1 + x4 + x6
 posons x1 = 50; x3 = 20; x5 = 60; x8 = 90; 
 A = 50 = x2 + 20
 B = x2 + x4 = 60 
 C = 60 + x6 = x7
 D = 20 + x7 = 90
 E = 90 = 50 + x4 + x6

arrangeons le système
 -x2 = +20 -50
 +x2 +x4 = +60 
 +x6 -x7 = -60
 +x7 = +90 -20
 -x4 -x6 = +50 -90 
 Soit
// x2 x4 x6 x7
 -x2 +0 +0 +0 +0 = +20 -50
 +x2 +x4 +0 +0 +0 = +60 
 +0 +0 +x6 -x7 +0 = -60
 +0 +0 +0 +x7 +0 = +90 -20
 +0 -x4 -x6 +0 +0 = +50 -90
Le code en langage C :
double ab[RA*(CA+Cb)]={
// x2 x4 x6 x7
 -1, +0, +0, +0, +0, +20 -50,
 +1, +1, +0, +0, +0, +60, 
 +0, +0, +1, -1, +0, -60,
 +0, +0, +0, +1, +0, +90 -20,
 +0, -1, -1, +0, +0, +50 -90