résolution systeme linéaire Ax=B

**flo62** · 30/12/2007, 23h13

Bonjour à tous,

Voila je dois coder la méthode de gauss et de jordan pour la résolution de systéme linéaire Ax=B. Pour rappel, le but de ces deux méthodes est de réduire la matrice A (initialement aléatoire) à une matrice plus facile à résoudre. Pour gauss, la matrice devra être supérieure (= uniquement des zéros dans la partie inférieure) tandis que pour Jordan , elle devra être diagonale (= des zéros dans la partie inférieure et supérieure). Ce qui me pose un probléme, c'est plus la réduction des matrices que la résolution . J'ai réussi à faire la méthode de Gauss, enfin je pense que ça marche mais par contre pour Jordan j'ai plus de mal, soit j'ai une matrice inférieure, soit supérieur mais j'arrive pas à avoir les deux. Je pense qu'à partir de Gauss, on devrait pouvoir arriver à jordan.
Voici l'algo de Gauss :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
 
 
void gauss(double **A,double **V,int n) {
  double **X;
  double x[19],p,s;int i,j,k;
  double tmp;
  double c;
  int y;
 
	for(i=0;i<n;i++){
		if(i<n-1){  //  permet d'éviter de sortir du tableau  lor d'une eventuelle permutation 
		if (A[i][i]==0){  
		//permutation de deux lignes pour éviter un pivot nul
				 for(y=0;y<n;y++){
						tmp = A[i][y];
						A[i][y] =A[i+1][y];
						A[i+1][y] =tmp;
 
						tmp = V[i][0];
						V[i][0] = V[i+1][0];
						V[i+1][0] = tmp;
					}
				}
			}
 
			p= A[i][i];
			for(j=i+1;j<n;j++){ 
				  if (p !=0){		 // évite un pivot nul et donc la division par zéro	
					 c=A[j][i]/p;
				  }else{ 
			  	     c=0;
			 	  }
				for(k=i;k<n;k++){
					A[j][k]=A[j][k] - c * A[i][k];
				}
				V[j][0]=V[j][0] - c * V[i][0];
			}
		}
 
    affiche_matrice(A,n);
 
}

merci d'avance

Flo62

**siegfried64** · 30/12/2007, 23h41

Envoyé par flo62

Ce qui me pose un probléme, c'est plus la réduction des matrices que la résolution . J'ai réussi à faire la méthode de Gauss, enfin je pense que ça marche mais par contre pour Jordan j'ai plus de mal, soit j'ai une matrice inférieure, soit supérieur mais j'arrive pas à avoir les deux.

Evidemment, il faut d'abord vérifier si la matrice est diagonalisable, ce qui n'est pas le cas pour toute les matrices.

**flo62** · 31/12/2007, 00h02

merci, mais comment vérifie t on cela car je n'ai pas du tout penser a faire cette vérification .

merci

**c-candide** · 31/12/2007, 00h50

Envoyé par siegfried64

Evidemment, il faut d'abord vérifier si la matrice est diagonalisable

Vraiment n'importe quoi.

**flo62** · 31/12/2007, 01h18

En même temp, dans le projet que je dois faire, il parle pas du tout de çà et en plus je l'ai pa vue en cour donc bon je pense que ce n'est pas essentiel . Je préfére résoudre mon probléme par rapport à la méthode de Jordan et voir ma méthode de Gauss si elle est correctement implémentée .

merci d'avance

Flo62

**Heimdall** · 31/12/2007, 17h51

C'est le déterminant qui doit être non nul qu'il faut vérifier.

**flo62** · 31/12/2007, 18h10

ok mais j'aimerais savoir si ma version pour la méthode de gauss est valable et comment je pourrais implémenter la méthode de jordan ?

merci

flo62

**Pacorabanix** · 31/12/2007, 18h14

Envoyé par Heimdall

C'est le déterminant qui doit être non nul qu'il faut vérifier.

pourquoi, pour qu'une matrice soit diagonalisable oO ? Le déterminant non nul permet de savoir si la matrice est inversible, ce qui permet de savoir si la méthode de Gauss peut etre appliquée. (c-à-d s'il y a une unique solution au problème, il peut y en avoir aucune, il peut y en avoir une infinité)

**Pacorabanix** · 31/12/2007, 18h18

voir : http://fr.wikipedia.org/wiki/%C3%89l...e_Gauss-Jordan

apparemment Jordan et Gauss, c'est la meme chose. de plus ça m'a rappelé qu'il ne FAUT PAS utiliser le déterminant comme critère pour savoir si c'est inversible ou non, il n'est pas assez efficace. C'est pendannt l'algorithme qu'on peut s'en rendre compte. (Avec l'apparition de zéro sur la diagonale il me semble.)

**Heimdall** · 31/12/2007, 18h25

Envoyé par Pacorabanix

pourquoi, pour qu'une matrice soit diagonalisable oO ? Le déterminant non nul permet de savoir si la matrice est inversible, ce qui permet de savoir si la méthode de Gauss peut etre appliquée. (c-à-d s'il y a une unique solution au problème, il peut y en avoir aucune, il peut y en avoir une infinité)

pour résoudre AX=B il faut inverser la matrice, donc il faut det(A)/=0 c'est ce que je disais.

**Pacorabanix** · 31/12/2007, 18h28

ok, j'avais mal compris ta remarque, autant pour moi

. Ceci dit, pour l'auteur du sujet, je répète que ce test n'a pas vraiment à être fait, car on s'en rend compte pendant l'algorithme. Un calcul de déterminant n'est pas une bonne chose à faire *avant* de réduire la matrice.

**flo62** · 31/12/2007, 18h30

La piéce jointe devrait vous aider à mieux comprendre mon souci.

flo62

**Heimdall** · 31/12/2007, 18h31

Envoyé par Pacorabanix

ok, j'avais mal compris ta remarque, autant pour moi

. Ceci dit, pour l'auteur du sujet, je répète que ce test n'a pas vraiment à être fait, car on s'en rend compte pendant l'algorithme. Un calcul de déterminant n'est pas une bonne chose à faire *avant* de réduire la matrice.

En effet, de toute manière si on cherche l'efficacité il y a des meilleure méthodes que gauss-jordan.

**flo62** · 31/12/2007, 18h35

yes , j'ai juste les 2 méthodes a coder avec les stratégie de choix du pivot comme indiquer dans le pdf joint ci- dessus.

**flo62** · 01/01/2008, 18h23

dite moi si ce ke j'ai fait , vous parait correcte é comment je pourrais faire pour jordan ?

merci

flo62

**diogene** · 01/01/2008, 18h36

Envoyé par flo62

dite moi si ce ke j'ai fait , vous parait correcte é comment je pourrais faire pour jordan ?

merci

flo62

Ce que tu fais n'est pas correct! C'est du jargon SMS contraire aux règles du forum !

**flo62** · 01/01/2008, 18h52

Dite moi si ce que j'ai fait , vous paraît correcte et comment je pourrais faire pour la méthode de Jordan ?

Merci

flo62

**souf46** · 06/02/2008, 19h31

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
#include<conio.h>
#include<stdio.h>
*
//Initialisation de la vecteur résultante de la multiplication ------------------------------------------------------------
void iniresmult()
{
*** for (int i=1;i<=n;i++)*************************************** //resmult aura bien N lignes
*** {*** //et P colonnes
*************** vactmult[i]=0;
*** }
}
*
//Initialisation de la vecteur résultante de la multiplication resvect------------------------------------------------------------
void iniresvect()
{
*** for (int i=1;i<=n;i++)
*resvectt[i]=0;
*** }
}
*
*
*
//Calcul de la vecteurdiff -------------------------------------------------------------------------------------------
void difvecteur()
{
Int v[n]
*** for (int i=1;i<=n;i++)
*** {** 
******** for (int i=1;k<=n;i++)
*********** {
*********** **v[i]=v1 [i]- v2 [i]-;
*********** }
*** }
}
*
*
*
/** Fonction calculant la norme d’un vecteur **------------------------------------------------------*/
*
float norme_l2(float x[NMAX],int n)
{
*int i;
*w=0;
*for(i=1;i<=n;i++)
*w += x[i]*x[i];
*w=sqrt(w);
*return(w);
}
*
*
*
//Affichage de la vecteur ---------------------------------------------------------------------------------------
void affresvec()
{
*** printf ("\nProduit vecteur :\n");
*** for (int i=1;i<=n;i++)
*** {
******* for (int j=1;j<=P;j++)
*********** {
*************** printf ("ligne %d,colonne %d : ",i,j);
*************** printf ("%f\n",revectt[i]);
*********** }
*** }
}
*
*
PARTIE 2:
#include <conio.h>
#include <studio.h>
*
*
//Fonctions d'affichage des aproximation de la solution ----------------------------------------------------------------------------
*
void resoudre(){
**** switch(choix){
**** 
**** case 1:
******** printf("\n********************* Methode de Gaus***************************\n");
******** //Calcul de l'aproximation de x par gauss
******** recupTriInf();********************************************** ************* //recuperation de la triangulaire inférieure de A
******** invMatrice(triInf);***************************************** ************* //inversion de la matrice
******** iniresmult();*********************************************** ******** //multiplication de la matrice inversee * bi
******** calcresmult();
******** //affresmult();
*
*
******** break;
**** default:
******** break;
**** }
}
*
// Fonction demandant les saisieetres du systeme a resoudre a l'utilisateur ---------------------------------------------
void saisie()
{
*** int i,k;
**** printf("Veuillez indiquer l'ordre de la matrice A:");
**** scanf("%d", &n);
**** getchar();
**** 
**** u = (float *) malloc (n*sizeof (float));
*
**** printf("Veuillez saisir les elements de la matrice A (la saisie se fera dans l'ordre des lignes)\n");
**** for(i = 1; i <= n; i++)
**** {
******** for(int j = 1; j <= n; j++)
******** {
************* printf("element[%d][%d]= ", i, j);
************* scanf("%f", &a[i][j]);
************* getchar();
******** }
**** }
**** 
**** printf("Veuillez saisir le vecteur U:");
**** for(k = 1; k <= n; k ++)
**** {
******** printf("element[%d]= ", k);
******** scanf("%f", &u[k]);
******** getchar();
**** }
*
**** printf("Veuillez saisir le nombre maximum d'iteration:");
**** scanf("%d", &iter);
**** getchar();
*
**** printf("Veuillez saisir la precision:");
**** scanf("%f", &eps);
**** getchar();
**** 
*
**** printf("*********** Vous avez finit les saisies, verifions les ensemble ***********\n\n");
**** printf("\nAffichage de la matrice A\n");
**** for(i = 1; i <= n; i++)
**** {
******** for(int j = 1; j <= n; j++)
******** {
************* if(j == n)
************* {
****************** printf("%f\n", a[i][j]);
************* }else
************* {
****************** printf("%f ", a[i][j]);
************* }
******** }
**** }
*
**** printf("\nAffichage du vecteur U \n");
**** for(int l = 1; l <= n; l++)
**** {******* 
************* printf("%f\n", u[l]);
**** }
*
**** printf("\nAffichage de iter = %d\n", iter);
**** printf("Affichage de eps = %f\n\n", eps);
**** printf("****** Une fois ces verifications terminees, passons a la resolution! ******\n\n");
*}
*
*/* Fonction d'affichage de la solution et des differents saisieetres de la resolution --------------------------------------*/
void affichsolgenerale()
{
*** int i;
**** float temp[NMAX];
**** float temp2[NMAX];
**** float fin[NMAX];
**** int cc,aaa;
**** for(i=1;i<=n;i++)
**** {
**** * for(int j=1;j<=n;j++)
************* printf("%f* ",a[i][j]);
************* printf(" I* %f\n",u[i]);
************* x[i]=0;
**** *}
**** *//printf("Solution exacte :\n");
**** *printf("\nVoici les n iterations demandees, a chaque fois sont proposees: \n");
**** *printf("Le vecteur X(n) / Err, la norme de la difference entre l'itere X(n) et la solution exacte \n");
**** *printf("et L'Erreur commise sur la solution du systeme... \n\n");
**** *for(i=1;i<=n;i++)
**** *//printf("%f\n",matresmult[i]);
*
**** *for(int o=1; o<=n;o++)
**** *{
**** *temp[o] = matresmult[o];
**** *}
**** *if (choix == 1)
**** *{
**** *jacobi_res(a,u,temp,n,iter,eps);
**** *}
**** *else
**** *{
**** *gauss_res(a,u,temp,n,iter,eps);
**** *}
**** *for(int j=1;j<=(k-1);j++)
**** *{
**** * printf("x(%2d)= (",j);
**** * for(i=1;i<=n;i++)
**** * {
******** * x[i]=t[i][j]-matresmult[i];
******** * printf("%f ",t[i][j]);
******** * temp2[i] = t[i][j];
*
**** * }
**** * iniresmult2();* 
**** * calcmult(a,temp2);
**** * 
**** **for(int dd=1;dd<=n;dd++)
**** * {
**** * erreur[dd]=u[dd]-resmult[dd];
**** * }
**** * printf("*** err= %f",norme_l2(x,n));
*
**** * printf(")erreur= %f\n",norme_l2(erreur,n));
**** * error = norme_l2(erreur,n);
**** * if (error<eps)
**** * {
**** * printf("La precision est atteinte !!\n Appuyer sur une touche pour avoir les resultats attendus\n");
**** * getchar();
**** * break;
**** * }
**** * temps++;
**** *}
**** *printf("\n\nLa solution estimee pour X est donc le dernier itere:\n");
**** *for(i=1;i<=n;i++)
**** *printf("%f\n",t[i][(k-1)]);
**** *printf("\nLe resutat de l'equation avec cette solution etant de :\n");
**** *for (aaa=1;aaa<=n;aaa++)
**** *{
**** *fin[aaa] = t[aaa][(k-1)]; 
**** *}
**** *iniresmult2();
**** *calcmult(a,fin);
**** *for (aaa=1;aaa<=n;aaa++)
**** *{
**** *printf("%f\n",resmult[aaa]); 
**** *}
**** *printf("\n\nLe nombre d'iteration effective ayant ete de :%i\n",(temps+1));
**** *printf("\n******** Taper sur une touche pour quitter l'application *******");
**** *getch();
}
*
//Fonction d'affichage de la matrice inversee ------------------------------------------------------------------------------
void aff(){
printf("Affichage de la matrice Inversee\n");
**** for(int i = 1; i <= n; i++){
******** for(int j = 1; j <= n; j++){
************* if(j == n){
****************** printf("%f\n", inversee[i][j]);******************** **** 
************* }else{
****************** printf("%f ", inversee[i][j]);
************* }
******** }
**** }
}
*
//Affichage de la matrice résultante ---------------------------------------------------------------------------------------
void affresmult()
{
*** printf ("\nProduit matriciel :\n");
*** for (int i=1;i<=n;i++)
*** {
******* for (int j=1;j<=P;j++)
*********** {
*************** printf ("ligne %d,colonne %d : ",i,j);
*************** printf ("%f\n",matresmult[i]);
*********** }
*** }
}
*
//Fonction d'initialisation ------------------------------------------------------------------------------------------------
void init(){
**** printf("\t============================================\n\n");
**** printf("\t******* Projet de c\n\n");
**** printf("\t***** RESOLUTION DE SYSTEME LINEAIRE\n\n");
**** printf("\t********* PAR METHODES ITERATIVES\n\n");
**** printf("\tRealise par :hkm et souf\n\n");
**** printf("\t============================================\n\n\n\n");
**** printf("Choisir la Methode de calcul :\n");
**** 
**** printf("1 Resoudre avec la Methode de Gauss-Seidel\n\n");
**** do{
******** printf("Entrez votre choix (1,2)\n");
******** scanf("%d", &choix);
**** * }
** while(choix != 1 && choix != 2);
** printf("choix: %d\n\n\n", choix);
** saisie(); 
** creatematriceident();*** //Creation de la matrice identite
*
}
*
//Fonction calculant la triangulaire inférieure de la matrice passée en saisieètre ------------------------------------------
void recupTriInf()
{
*** int i,j;
**** for(i = 1; i <= n; i++){
******** for(j = 1; j <= i; j++){
************* printf("a[i](j] = %f\n", a[i][j]);
************* triInf[i][j] = a[i][j];
******** }
**** }
}

**Thierry Chappuis** · 06/02/2008, 19h39

Si le but était de poster du code illisible... Bel effort!

...pouquoi toutes ces étoiles?

Thierry

**souf46** · 06/02/2008, 19h55

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
#include<conio.h>
#include<stdio.h>
*
//Initialisation de la vecteur résultante de la multiplication ------------------------------------------------------------
void iniresmult()
{
*** for (int i=1;i<=n;i++)*************************************** //resmult aura bien N lignes
*** {*** //et P colonnes
*************** vactmult[i]=0;
*** }
}
*
//Initialisation de la vecteur résultante de la multiplication resvect------------------------------------------------------------
void iniresvect()
{
*** for (int i=1;i<=n;i++)
*resvectt[i]=0;
*** }
}
*
*
*
//Calcul de la vecteurdiff -------------------------------------------------------------------------------------------
void difvecteur()
{
Int v[n]
*** for (int i=1;i<=n;i++)
*** {** 
******** for (int i=1;k<=n;i++)
*********** {
*********** **v[i]=v1 [i]- v2 [i]-;
*********** }
*** }
}
*
*
*
/** Fonction calculant la norme d’un vecteur **------------------------------------------------------*/
*
float norme_l2(float x[NMAX],int n)
{
*int i;
*w=0;
*for(i=1;i<=n;i++)
*w += x[i]*x[i];
*w=sqrt(w);
*return(w);
}
*
*
*
//Affichage de la vecteur ---------------------------------------------------------------------------------------
void affresvec()
{
*** printf ("\nProduit vecteur :\n");
*** for (int i=1;i<=n;i++)
*** {
******* for (int j=1;j<=P;j++)
*********** {
*************** printf ("ligne %d,colonne %d : ",i,j);
*************** printf ("%f\n",revectt[i]);
*********** }
*** }
}
*
*
PARTIE 2:
#include <conio.h>
#include <studio.h>
*
*
//Fonctions d'affichage des aproximation de la solution ----------------------------------------------------------------------------
*
void resoudre(){
**** switch(choix){
**** 
**** case 1:
******** printf("\n********************* Methode de Gaus***************************\n");
******** //Calcul de l'aproximation de x par gauss
******** recupTriInf();********************************************** ************* //recuperation de la triangulaire inférieure de A
******** invMatrice(triInf);***************************************** ************* //inversion de la matrice
******** iniresmult();*********************************************** ******** //multiplication de la matrice inversee * bi
******** calcresmult();
******** //affresmult();
*
*
******** break;
**** default:
******** break;
**** }
}
*
// Fonction demandant les saisieetres du systeme a resoudre a l'utilisateur ---------------------------------------------
void saisie()
{
*** int i,k;
**** printf("Veuillez indiquer l'ordre de la matrice A:");
**** scanf("%d", &n);
**** getchar();
**** 
**** u = (float *) malloc (n*sizeof (float));
*
**** printf("Veuillez saisir les elements de la matrice A (la saisie se fera dans l'ordre des lignes)\n");
**** for(i = 1; i <= n; i++)
**** {
******** for(int j = 1; j <= n; j++)
******** {
************* printf("element[%d][%d]= ", i, j);
************* scanf("%f", &a[i][j]);
************* getchar();
******** }
**** }
**** 
**** printf("Veuillez saisir le vecteur U:");
**** for(k = 1; k <= n; k ++)
**** {
******** printf("element[%d]= ", k);
******** scanf("%f", &u[k]);
******** getchar();
**** }
*
**** printf("Veuillez saisir le nombre maximum d'iteration:");
**** scanf("%d", &iter);
**** getchar();
*
**** printf("Veuillez saisir la precision:");
**** scanf("%f", &eps);
**** getchar();
**** 
*
**** printf("*********** Vous avez finit les saisies, verifions les ensemble ***********\n\n");
**** printf("\nAffichage de la matrice A\n");
**** for(i = 1; i <= n; i++)
**** {
******** for(int j = 1; j <= n; j++)
******** {
************* if(j == n)
************* {
****************** printf("%f\n", a[i][j]);
************* }else
************* {
****************** printf("%f ", a[i][j]);
************* }
******** }
**** }
*
**** printf("\nAffichage du vecteur U \n");
**** for(int l = 1; l <= n; l++)
**** {******* 
************* printf("%f\n", u[l]);
**** }
*
**** printf("\nAffichage de iter = %d\n", iter);
**** printf("Affichage de eps = %f\n\n", eps);
**** printf("****** Une fois ces verifications terminees, passons a la resolution! ******\n\n");
*}
*
*/* Fonction d'affichage de la solution et des differents saisieetres de la resolution --------------------------------------*/
void affichsolgenerale()
{
*** int i;
**** float temp[NMAX];
**** float temp2[NMAX];
**** float fin[NMAX];
**** int cc,aaa;
**** for(i=1;i<=n;i++)
**** {
**** * for(int j=1;j<=n;j++)
************* printf("%f* ",a[i][j]);
************* printf(" I* %f\n",u[i]);
************* x[i]=0;
**** *}
**** *//printf("Solution exacte :\n");
**** *printf("\nVoici les n iterations demandees, a chaque fois sont proposees: \n");
**** *printf("Le vecteur X(n) / Err, la norme de la difference entre l'itere X(n) et la solution exacte \n");
**** *printf("et L'Erreur commise sur la solution du systeme... \n\n");
**** *for(i=1;i<=n;i++)
**** *//printf("%f\n",matresmult[i]);
*
**** *for(int o=1; o<=n;o++)
**** *{
**** *temp[o] = matresmult[o];
**** *}
**** *if (choix == 1)
**** *{
**** *jacobi_res(a,u,temp,n,iter,eps);
**** *}
**** *else
**** *{
**** *gauss_res(a,u,temp,n,iter,eps);
**** *}
**** *for(int j=1;j<=(k-1);j++)
**** *{
**** * printf("x(%2d)= (",j);
**** * for(i=1;i<=n;i++)
**** * {
******** * x[i]=t[i][j]-matresmult[i];
******** * printf("%f ",t[i][j]);
******** * temp2[i] = t[i][j];
*
**** * }
**** * iniresmult2();* 
**** * calcmult(a,temp2);
**** * 
**** **for(int dd=1;dd<=n;dd++)
**** * {
**** * erreur[dd]=u[dd]-resmult[dd];
**** * }
**** * printf("*** err= %f",norme_l2(x,n));
*
**** * printf(")erreur= %f\n",norme_l2(erreur,n));
**** * error = norme_l2(erreur,n);
**** * if (error<eps)
**** * {
**** * printf("La precision est atteinte !!\n Appuyer sur une touche pour avoir les resultats attendus\n");
**** * getchar();
**** * break;
**** * }
**** * temps++;
**** *}
**** *printf("\n\nLa solution estimee pour X est donc le dernier itere:\n");
**** *for(i=1;i<=n;i++)
**** *printf("%f\n",t[i][(k-1)]);
**** *printf("\nLe resutat de l'equation avec cette solution etant de :\n");
**** *for (aaa=1;aaa<=n;aaa++)
**** *{
**** *fin[aaa] = t[aaa][(k-1)]; 
**** *}
**** *iniresmult2();
**** *calcmult(a,fin);
**** *for (aaa=1;aaa<=n;aaa++)
**** *{
**** *printf("%f\n",resmult[aaa]); 
**** *}
**** *printf("\n\nLe nombre d'iteration effective ayant ete de :%i\n",(temps+1));
**** *printf("\n******** Taper sur une touche pour quitter l'application *******");
**** *getch();
}
*
//Fonction d'affichage de la matrice inversee ------------------------------------------------------------------------------
void aff(){
printf("Affichage de la matrice Inversee\n");
**** for(int i = 1; i <= n; i++){
******** for(int j = 1; j <= n; j++){
************* if(j == n){
****************** printf("%f\n", inversee[i][j]);******************** **** 
************* }else{
****************** printf("%f ", inversee[i][j]);
************* }
******** }
**** }
}
*
//Affichage de la matrice résultante ---------------------------------------------------------------------------------------
void affresmult()
{
*** printf ("\nProduit matriciel :\n");
*** for (int i=1;i<=n;i++)
*** {
******* for (int j=1;j<=P;j++)
*********** {
*************** printf ("ligne %d,colonne %d : ",i,j);
*************** printf ("%f\n",matresmult[i]);
*********** }
*** }
}
*
//Fonction d'initialisation ------------------------------------------------------------------------------------------------
void init(){
**** printf("\t============================================\n\n");
**** printf("\t******* Projet de c\n\n");
**** printf("\t***** RESOLUTION DE SYSTEME LINEAIRE\n\n");
**** printf("\t********* PAR METHODES ITERATIVES\n\n");
**** printf("\tRealise par :hkm et souf\n\n");
**** printf("\t============================================\n\n\n\n");
**** printf("Choisir la Methode de calcul :\n");
**** 
**** printf("1 Resoudre avec la Methode de Gauss-Seidel\n\n");
**** do{
******** printf("Entrez votre choix (1,2)\n");
******** scanf("%d", &choix);
**** * }
** while(choix != 1 && choix != 2);
** printf("choix: %d\n\n\n", choix);
** saisie(); 
** creatematriceident();*** //Creation de la matrice identite
*
}
*
//Fonction calculant la triangulaire inférieure de la matrice passée en saisieètre ------------------------------------------
void recupTriInf()
{
*** int i,j;
**** for(i = 1; i <= n; i++){
******** for(j = 1; j <= i; j++){
************* printf("a[i](j] = %f\n", a[i][j]);
************* triInf[i][j] = a[i][j];
******** }
**** }

résolution systeme linéaire Ax=B

C

Discussions similaires

Partager

Partager