exercice méthode de jacobi c++

**minimoack** · 19/03/2014, 09h56

Bonjour,

j'ai un exercice à faire en C++. j'ai commencé, mais je suis bloquée avec la méthode de jacobi. je ne comprends pas trop, est-ce que quelqu'un pourrait m'expliquer svp?

L'objectif de cette séance est d'implémenter en C++ le début d'une classe « matrice » : les champs qui définissent chaque matrice, deux constructeurs, une méthode d'affichage, ainsi qu'une méthode permettant de résoudre, avec la méthode de Jacobi, un système d'équations linéaires.

Les champs de la classe « matrice »
Chaque matrice est définie par : ses dimensions et un tableau contenant les éléments de la matrice.
Constructeurs

Pour pouvoir facilement tester vos programmes sur des petites matrices, il vous faut au moins un constructeur prenant en paramètre un tableau contenant tous les éléments de la matrice. Ainsi, pour tester vos programmes sur la matrice ci-contre, vous devriez pouvoir écrire des lignes de code qui ressemblent à :
double T[9] = {10,-1,0,-1,10,-2,0,1,-10} ;
matrice * A = new matrice(3,3,T) ;

Méthodes de base
Il est pratique d'avoir des méthodes pour lire un élément de la matrice et modifier un élément de la matrice, appelées par exemple get et set. Il est aussi recommandé d'avoir une méthode permettant un affichage simple, ligne par ligne, d'une matrice de petite taille.

Méthode de Jacobi
Pour résoudre un système d'équations linéaires de la forme Ax=b, où A est une matrice carrée de dimension n, b un vecteur de taille n, on calcule une suite récurrente définie par :
r^(k+1) = D^(-1) * ( b - (L+U) * r^(k))

Écrivez une méthode, prenant en paramètre le vecteur b (un vecteur est une matrice n × 1), permettant de calculer simplement cette suite : il suffit d'exprimer le terme r(k+1)j en fonction des r(k)ij, des Aij et des bj.

Comme pour la méthode de la sécante vue en TDs, il faut deux variables, contenant la valeur courante du vecteur r et la valeur suivante, soit par exemple rcour et rsuiv ; alors la i-ème composante de r est mise à jours comme suit :
rsuiv(i) = (b(i) - sum{0 <= m < n} à {m <> i} (A(im) * rcour(m))) / A(ii)

J'ai fait:

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
Matrices.h
#pragma once
#include <iostream>
using namespace std;
class Matrices
{
private : 
	// Dimensions de la matrice
	int nbLignes, nbColonnes;
	//Tableau de valeurs
	double * tab;
public :
	//Destructeur
	~Matrices(void);
	//Constructeur
	Matrices(int=0, int=0, double * =NULL);
	//Constructeur par recopie
	Matrices(const Matrices &);
	void Afficher();
	int getLigne();
	int getColonne();
	double getTableau();
	void setTableau(int, double);
	double getValeur(int, int);
	void setValeur(int, int, double);
};

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
Matrices.cpp
#include "StdAfx.h"
#include "Matrices.h"
#include <iostream>
#include <math.h>
using namespace std;
 
Matrices::~Matrices()
	{ delete[] tab; }
 
Matrices::Matrices(int l, int c, double t[])
{
	nbLignes = l;
	nbColonnes = c;
	tab = newdouble[nbLignes*nbColonnes];
	for (int i = 0; i < nbLignes*nbColonnes; i++)
	{
		tab[i] = t[i];
	}
}
 
//Constructeur par recopie
Matrices::Matrices(const Matrices &m)
{
	nbLignes = m.nbLignes;    
	nbColonnes = m.nbColonnes;    
	tab = newdouble [nbLignes*nbColonnes];     
	for (int i = 0; i < nbLignes*nbColonnes; i++)     
	{
		tab[i] = m.tab[i];    
	}
}
 
void Matrices ::  Afficher()
{
	int compteur = 1;
	cout<<"Voici la matrice : "<<endl;
	for (int i = 0; i < nbColonnes*nbLignes; i++)
	{
		if (compteur == nbColonnes+1)
		{
			cout<<"\n";
			cout<<tab[i]<<" ";
			compteur = 2;
		}
		else
		{
		cout<<tab[i]<<" ";
		compteur++;
		}
	}
	cout<<"\n";
}
 
int Matrices :: getLigne()
{
	return nbLignes;
}
 
int Matrices :: getColonne()
{
	return nbColonnes;
}
 
double Matrices :: getTableau()
{
	return *tab;
}
 
void setTableau(int i, double n)
{
	if ((i >= 0) && (i < nbLignes))
		{ tab[i] = n; }
	else
		{ cout<<"erreur sur l'indice" ; }
}
 
double getValeur(int ligne, int colonne)
{
     if ((ligne >= 0) && (ligne < nbLignes) && (colonne >= 0) && (colonne < nbColonnes))
     {
         return tab[((ligne - 1) * nbColonnes) + (colonne - 1)];
     }
     else
     {   cout<<"erreur"; }
}
 
void setValeur(int ligne, int colonne, double valeur)
{
     if ((ligne >= 0) && (ligne < nbLignes) && (colonne >= 0) && (colonne < nbColonnes)) 
     {
          tab[((ligne - 1) * nbColonnes) + (colonne - 1)] = valeur;
     }
     else
     {   cout<<"erreur"; }
}

Donc voilà, je bugg totalement sur la méthode de jacobi... je ne comprends pas du tout ce que je dois faire... il me semble que je dois récupérer la matrice diagonale, supérieure à la diagonale, et inférieure à la diagonale... mais je ne sais pas comment faire... tableau ? matrice? et puis que va renvoyer la fonction ? un vecteur ou un tableau?
Je suis perdue...
Merciiiii ...

EDIT : en fait, c'est un exercice en deux parties, la première étant le début de l'implémentation de Matrices, c'est-à-dire le code que j'ai mis, et que j'ai déjà rendu à mon prof... La deuxième partie est la création de la méthode de jacobi, pour laquelle je galère

**Davidbrcz** · 19/03/2014, 11h11

Ce juste des maths : l’Idée de la méthode part de la recherche d'un point fixe d'une fonction vectorielle puis on decompose la matrice du système pour ensuite créer une suite de vecteur convergent vers la solution.

Tout est explique la : https://fr.wikipedia.org/wiki/M%C3%A9thode_de_Jacobi

Edit : je laisse les autres faire les remarques sur le C++ en lui meme.

**minimoack** · 19/03/2014, 11h20

Merci bien, mais j'ai déjà visité la page wikipedia, et plein d'autres expliquant le fonctionnement de la méthode de jacobi, et j'ai même trouvé des codes en C++, mais avec plein de variables globales incompréhensibles... Je ne poste pas sur un forum sans avoir fait des recherches préalablement.
Je ne comprends pas comment je peux coder ça, c'est tout. est ce que je dois garder mon tableau à une dimension? passer à 2 dimensions? comment récupérer les matrices diagonales supérieures et inférieures? faut-il récupérer juste les valeurs ou il faut mettre des zéros? ...

**Kalkalfoufounne** · 19/03/2014, 11h30

Envoyé par Davidbrcz

Ce juste des maths : l’Idée de la méthode part de la recherche d'un point fixe d'une fonction vectorielle puis on la matrice du système décomposition d'une matrice pour ensuite créer une suite de vecteur convergent vers la solution.

Tout est explique la : https://fr.wikipedia.org/wiki/M%C3%A9thode_de_Jacobi

Edit : je laisse les autres faire les remarques sur le C++ en lui meme.

Bonjour Davidbrcz,
Je ne suis pas habitué à manipuler des matrices protocolaires de NIVEAU 2! Et mon niveau en mathématique approxime celui du niveau de la mer c'est à dire 0.
J'aimerai donc également que vous nous postiez une solution rapide et plausible à rendre à notre cher et tendre professeur de Mathematique.
Cordialement,
Kalkalfoufounne.

**ternel** · 19/03/2014, 11h32

Pour l'instant, je n'ai pas compris le calcul à appliquer, mais ça ressemble à une boucle de calcul.

Par contre, j'ai un gros soucis avec ton code:

Tout d'abord, un pragma once implique que le code que tu nous donne est un en-tête.
Le using namespace std; est alors une grave faute. En effet, tout fichier incluant ton en-tête verra une pollution de son environnement.
C'est à bannir absolument.

Aucun using dans un en-tête, sauf à l'intérieur de la déclaration d'une classe.

Ne pas s'y conformer n'est pas profondément dramatique en soi, mais finira par poser des problèmes extrêmement difficile à résoudre, surtout que celui qui les aura n'y pensera pas.

Autre chose, tes constructeurs n'utilisent pas les initialiseurs, perdant en efficacité et propreté. Dans d'autres cas, ça peut même poser des problèmes.
par exemple:

Code :

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

1
2
3
4
//Constructeur par recopie
Matrices::Matrices(const Matrices &other) : nbLignes(other.nbLignes), nbColonnes(other.nbColonnes), tab(new double[other.nbLignes * other.nbColonnes]) {
	for (int i = 0; i < nbLignes*nbColonnes; i++) tab[i] = other.tab[i];
}

Enfin, ta classe devrait s'appeler Matrice (sans pluriel), car c'est ce nom qui servira à déclarer les variables.
Supposons double T[9] = {10,-1,0,-1,10,-2,0,1,-10};.
On préférera certainement
Matrice A(3,3,T); à Matrices A(3,3,T);;

Par ailleurs, on préfèrera Matrice A(3,3,T); à Matrice A = Matrice(3,3,T);, mais c'est une question de style uniquement.

Attention, Matrice A(3,3,T); déclare une variable, tandis que Matrice * A = new Matrice(3,3,T); déclare un pointeur, à détruire manuellement (via un delete), et posant de ce fait de nombreux soucis de suivi.

Pour la résolution pratique, qu'as-tu déjà essayé?
Boileau disait "Ce qui se conçoit bien s'énonce clairement.", il en va de même pour le code.
Comment le ferais-tu sur papier? Pourquoi devrait-ce être différent dans le code?

Pour t'aider, considère le principe suivant:
Si tu n'arrives pas à écrire la solution en code, ça ne peut venir que de trois choses:

la solution papier n'est pas maîtrisée,
la représentation des données est inadaptée,
le code fixe (comme les bibliothèques) n'est pas suffisamment maîtrisée.

PS: je me penche moi-même sur la question.

**Davidbrcz** · 19/03/2014, 11h44

Envoyé par minimoack

Merci bien, mais j'ai déjà visité la page wikipedia, et plein d'autres expliquant le fonctionnement de la méthode de jacobi, et j'ai même trouvé des codes en C++, mais avec plein de variables globales incompréhensibles... Je ne poste pas sur un forum sans avoir fait des recherches préalablement.
Je ne comprends pas comment je peux coder ça, c'est tout. est ce que je dois garder mon tableau à une dimension? passer à 2 dimensions? comment récupérer les matrices diagonales supérieures et inférieures? faut-il récupérer juste les valeurs ou il faut mettre des zéros? ...

La relation de reccurrence est la suivante : $x^{k+1}=D^{-1}(E+F)x^k+D^{-1}b$

Avec Ta matrice = D -(E+F) et D diagonale.
Il suffit de décomposer ta matrice en ta matrice D et E+F, calculer l'inverse de D (qui est une matrice diagonale, donc c'est trivial)
Et ensuite de faire les produit et sommes comme dans la formule (au passage opérations que tu dois implémenter) et il te suffit de boucler jusqu'au critère de convergence voulu.

Qu'est ce qui te bloque ? Car ce sont des maths de petit niveau bac+1.

Je ne suis pas habitué à manipuler des matrices protocolaires de NIVEAU 2!

Ca donne quoi en francais ?

J'aimerai donc également que vous nous postiez une solution rapide et plausible à rendre à notre cher et tendre professeur de Mathematique.

Non. Enfin pas gratuitement. Si je dois faire vos devoirs, autant que ca me rapporte.

**minimoack** · 19/03/2014, 11h51

Merci pour vos conseils, je vais essayer

**Iradrille** · 19/03/2014, 12h00

Envoyé par leternel

Attention, Matrice A(3,3,T); déclare une variable, tandis que Matrice * A = new Matrice(3,3,T); déclare un pointeur, à détruire manuellement (via un delete), et posant de ce fait de nombreux soucis de suivi.

Ça va même plus loin que le "simple" suivi du pointeur. Une matrice à une sémantique de valeur (et une petite taille en mémoire) -> il n'y aura (presque ?) jamais de "new Matrice".

Un autre petit détail, en C++ "tableau" est presque synonyme de "std::vector".

Pour le réel problème du thread, j'ai pas le niveau en maths

J'ai absolument aucune idée comment de : Ax=b, on arrive à r^(k+1) = D^(-1) * ( b - (L+U) * r^(k)). Trop de lettres qui sortent de nulle part ^^".

exercice méthode de jacobi c++

C++

Discussions similaires

Partager

Partager