résolution systeme linéaire Ax=B

Version imprimable

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:

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

30/12/2007, 23h41
siegfried64

Citation:

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.
31/12/2007, 00h02
flo62

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

merci
31/12/2007, 00h50
c-candide

Citation:

Envoyé par siegfried64

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

Vraiment n'importe quoi.
31/12/2007, 01h18
flo62

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
31/12/2007, 17h51
Heimdall

C'est le déterminant qui doit être non nul qu'il faut vérifier.
31/12/2007, 18h10
flo62

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
31/12/2007, 18h14
Pacorabanix

Citation:

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é)
31/12/2007, 18h18
Pacorabanix

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.)
31/12/2007, 18h25
Heimdall

Citation:

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.
31/12/2007, 18h28
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.
31/12/2007, 18h30
flo62

1 pièce(s) jointe(s)

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

flo62
31/12/2007, 18h31
Heimdall

Citation:

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.
31/12/2007, 18h35
flo62

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.
01/01/2008, 18h23
flo62

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

merci

flo62
01/01/2008, 18h36
diogene

Citation:

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 !:evilred:
01/01/2008, 18h52
flo62

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

Code:

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];
******** }
**** }
}

06/02/2008, 19h39
Thierry Chappuis

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

...pouquoi toutes ces étoiles?

Thierry

Code:

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];
******** }
**** }

06/02/2008, 20h09
souf46

les etoiles s sont des espaces
06/02/2008, 20h12
Thierry Chappuis

no entiendo!
06/02/2008, 21h42
Namtar

flo62 =>

Ton programme semble bon. Sa me rappelle ce que j'ai déjà fais mais je ne suis pas sur non plus.

Par contre je me rappelle bien que l'on choisissait le pivot. Cela permet d'avoir de meilleur résultat.

Je te conseil donc de le rajouter.
07/02/2008, 11h15
Emmanuel Delahaye

Citation:

Envoyé par souf46

les etoiles s sont des espaces

Alors fait les remplacements et poste un code correct entre des balises de code. Et compiles avant, parce que le peu que j'ai vu ne compile pas du tout.