Problème de "methode d'elimination de Gauss"

Version imprimable

salut tous le monde
je veux résoudre un systeme
A x = b
en utilisant la méthode de Gauss
et voici donc le code qui permet la diagonalisation de la matriece A

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
for(k=0;k<mb->l - 1;k++)
    {
        for(i=k+1;i<mb->l;i++)
        {
            if(mA->t[k][k] < e)
            {
                fctErreur("Systeme considere comme non inversible");
            }
            v = mA->t[i][k] / mA->t[k][k] ;
            for(j=k+1;j<mb->l;j++)
            {
                mA->t[i][j] -= v * mA->t[k][j] ;
                mb->t[i][0] -= v * mb->t[k][0] ;
            }
 
        }
    }

mA et mb sont des pointeurs sur des "matrice"

Code:

1
2
3
4
5
6
7
struct matrice
{
    float **t;//tableau de pointeur
 
    int l,c;//nombre de lignes et colonnes
//....
}

et ce code ne me donne pas le bon résultat :bug:
pouvez-vous m'aider
:merci:

Voici un code Java envoyé par Pseudocode.
Tu n'as qu'à le traduire en C++, (c'est immédiat)

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
 
/**
 * Structure et Operations sur une matrice
 * 
 * @author Xavier PHILIPPEAU
 *  
 */
public class Matrix {
 
	// les données de la matrice ordonnnée en [x=colonne][y=ligne]
	public double value[][];
 
	// les dimensions de la matrice
	public final int rows, cols;
 
	// constructeur de matrice quelconque (vide)
	public Matrix(int cols, int rows) {
		this.cols = cols;
		this.rows = rows;
		this.value = new double[this.cols][this.rows];
	}
 
	// constructeur de matrice carré (pré-remplies)
	public Matrix(int size, double[][] squarearray) {
		this.cols = size;
		this.rows = size;
		this.value = squarearray;
	}
 
	/**
	 * inversion par pivot de Gauss
	 *
	 * @return l'inverse de la matrice (ou null si non inversible)
	 */
	public Matrix inverse() {
 
		//Une matrice ne peut etre inversée que si elle est carrée.
		if (this.rows != this.cols) {
			System.err.println("Inversion : La matrice n'est pas carré !!");
			return null;
		}
 
		// Création de la matrice de travail T = [ this | Identité ]
		Matrix T = new Matrix(this.cols * 2, this.cols);
		for (int y = 0; y < this.rows; y++) {
			for (int x = 0; x < this.cols; x++) {
				T.value[x][y] = this.value[x][y];
				if (x == y)	T.value[this.cols + x][y] = 1;
			}
		}
 
		// Pour chaque ligne de la matrice T
		for (int x = 0; x < T.rows; x++) {
 
			// Cherche la ligne avec le pivot max (en valeur absolue)
			int bestline = x;
			double pivot = T.value[x][bestline];
			for (int y = x + 1; y < T.rows; y++) {
				if (Math.abs(T.value[x][y]) > Math.abs(pivot)) {
					bestline = y;
					pivot = T.value[x][bestline];
				}
			}
 
			if (pivot == 0) {
				System.err.println("Inversion : Le pivot est nul,inversion impossible !!");
				return null;
			}
 
			// Echange des lignes (si necessaire)
			if (bestline != x) {
				double tmp;
				for (int t = 0; t < T.cols; t++) {
					tmp = T.value[t][x]; T.value[t][x] = T.value[t][bestline]; T.value[t][bestline] = tmp;
				}
			}
 
			// Normalisation de la ligne du pivot
			for (int t = 0; t < T.cols; t++) T.value[t][x] /= pivot;
 
			// elimination des autres lignes
			for (int y = 0; y < T.rows; y++) {
				if (y==x) continue;
				double coef = T.value[x][y];
				for (int t = 0; t < T.cols; t++) T.value[t][y] -= coef * T.value[t][x];
			}
		}
 
		// recupere la partie droite de T qui contient l'inverse de la matrice
		// (la partie gauche devrait contenir l'identité)
		Matrix inverse = new Matrix(this.cols,this.rows);
		for (int y = 0; y < this.rows; y++)
			for (int x = 0; x < this.cols; x++)
				inverse.value[x][y] = T.value[this.cols+x][y];
 
		return inverse;
	}
 
	/**
	 * Multiplication de la matrice par un vecteur
	 *
	 * @param X le vecteur
	 * @return le vecteur résultat: this[][] * X[]
	 */
	public double[] multiply(double[] X) {
		double[] Y = new double[this.rows];
		for (int y = 0; y < this.rows; y++)
			for (int x = 0; x < this.cols; x++)
				Y[y] += this.value[x][y]*X[x];
		return Y;
	}	
 
}

11/11/2007, 23h24
pseudocode

Hum... mon code n'est pas vraiment un modele d'optimisation. :P

Concernant le PO, a mon avis il manque:
1. l'inversion de lignes au cas ou le pivot est nul
2. la normalisation de la ligne du pivot
3. la soustraction avec TOUTES les autres lignes de la matrice
12/11/2007, 17h53
FR119492

Salut !

Première question: est-ce un exercice ou bien as-tu vraiment besoin de la solution d'un ou plusieurs systèmes linéaires?

Dans ce dernier cas, pas besoin de réinventer la roue: tu trouveras tout ce dont tu as besoin sur le site www.netlib.org (c'est gratuit!). Je te recommande en particulier les bibliothèques LinPack, LAPack et Slatec.

Bonne chance.
Jean-Marc Blanc
12/11/2007, 20h28
H-bil

Salut

Citation:

Envoyé par pseudocode

Concernant le PO, a mon avis il manque:
1. l'inversion de lignes au cas ou le pivot est nul

pour le momoent mon programme ne doit pas traiter les matrice avec pivot naturel null
si une matrice a dans une etape un pivot naturel null je quitte la foction

Citation:

Envoyé par pseudocode

2. la normalisation de la ligne du pivot
3. la soustraction avec TOUTES les autres lignes de la matrice

la j'ai pas compris :oops:
comment dois-je ajouter cela à ma foction ?
et ce que c'est à cause de cela que mon programme donne un resultat d'elimination et une solution fausses

car pour le systeme Ax=b
http://mwt.e-technik.uni-ulm.de/worl..._fr/img506.gif
mon programme donne apres gausse :

2 -5 4
0 0.5 -1
0 0 1

-3
8
37

et donne comme solution

38.5
16
37

8O

Citation:

Envoyé par FR119492

Première question: est-ce un exercice ou bien as-tu vraiment besoin de la solution d'un ou plusieurs systèmes linéaires?

c'est un exercice :D
12/11/2007, 21h16
Zavonen

Citation:

mon programme donne apres gausse :

2 -5 4
0 0.5 -1
0 0 1

-3
8
37

d'accord pour la matrice mais quid du 8 et du 37 dans le second membre ?
Et puis, s'il te plaît, soit sympa; c'est Gauss!