Discussion :

[RMATH]

Bonjour,
je suis débutante en matlab, j'ai essayé de faire un programme pour résoudre un système linéaire par la méthode du gradient conjugué de Dai-Yuan,
il y a une faute dans la ligne 21 (calcul du gradient) mais je ne vois pas..

voici le programme :

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
 
function [x]= daiyuan(A,B,x1,epsilon,maxiter)
% Méthode de Dai Yuan pour la résolution d'un problème linéaire Ax=B
% Entrée :   A       = la matrice donnée
%             B       = vecteur donné
%             x1      = le point de départ
%            epsilon = tolérance du test d'arret, valeur par défaut 1e-8
%           maxiter = nombre maximum d'itérations, valeur par défaut 100
% Sortie :  x       = solution
% Valeurs par défaut
if nargin < 4, epsilon = 1e-8; end
if nargin < 5, maxiter = 100; end
A = input ('donner la matrice A =')
b = input ('donner le vecteur b =')
x1 = input ('donner le point du départ x1 =')
iter = 1; % Compteur des itérations
g = A*x1-b;
while iter <= maxiter
if norm(g) <= epsilon, break, end
        if iter ==1
          d == -g, a == norm(g)^2/dot(A*d,d), x_ == x1 + d.^a...
          g_ == A*x_- b, p == norm(g_)^2/dot(g_-g,d), d_ == -g_+ d.^p;
        else a == norm(g)^2/dot(A*d,d), x_ == x + d.^a,...
            g_== A*x_-b, p == norm(g_)^2/dot(d,g_-g), d_ == -g_+ d.^p; end
    x == x_;
    g == g_;
    d == d_;
    iter == iter +1; end
if iter > maxiter, warning('nombre maximum d itération atteint'), end

l'algorithme de Dai Yuan (pièce jointe)

Aidez moi s'il vous plait!!

[Caro-Line]

Je n'ai pas cherché à comprendre ton problème, ni à savoir où était la ligne 21 (pas facile à voir comme ça) mais attention le signe == est utilisé uniquement pour la comparaison et j'ai l'impression que tu l'utilises aussi pour l'allocation des variables.
donc plutôt :

Code :

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

1
2
3
4
5
6
7
8
d = -g, a = norm(g)^2/dot(A*d,d), x_ = x1 + d.^a...
          g_ = A*x_- b, p = norm(g_)^2/dot(g_-g,d), d_ = -g_+ d.^p;
        else a = norm(g)^2/dot(A*d,d), x_ = x + d.^a,...
            g_= A*x_-b, p = norm(g_)^2/dot(d,g_-g), d_ = -g_+ d.^p; end
    x = x_;
    g = g_;
    d = d_;
    iter = iter +1;

[RMATH]

Bonjour,
Merci beaucoup pour votre réponse, j'ai réctifié mais il y a toujours le problème...(la ligne colorée en rouge)

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

function [x] = daiyuan(A,b,x1,epsilon,maxiter)
% Méthode de Dai Yuan pour la résolution d'un problème linéaire Ax=B
% Entrée : A       = la matrice donnée
%          B       = vecteur donné
%          x1      = le point de départ
%          epsilon = tolérance du test d'arret, valeur par défaut 1e-8
%          maxiter = nombre maximum d'itérations, valeur par défaut 1000
% Sortie : x       = solution
% Valeurs par défaut
if nargin < 4, epsilon = 1e-8; end
if nargin < 5, maxiter = 1000; end
A = input ('donner la matrice A =')
b = input ('donner le vecteur b =')
x1 = input ('donner le point du départ x1 =')
iter = 1; % Compteur des itérations
g = A*x1-b;
while iter <= maxiter
if norm(g) <= epsilon, break, end
        if iter == 1
          d = -g, a = norm(g)^2/dot(A*d,d), x_ = x1 + d.^a...
          g_ = A*x_- b, p = norm(g_)^2/dot(g_-g,d), d_ = -g_+ d.^p;
        else a = norm(g)^2/dot(A*d,d), x_ = x + d.^a,...
            g_ = A*x_-b, p = norm(g_)^2/dot(d,g_-g), d_ = -g_+ d.^p; end
    x = x_;
    g = g_;
    d = d_;
    iter = iter +1; end
if iter > maxiter, warning('nombre maximum d itération atteint'), end

[RMATH]

Bonjour,
me voilà!!! je suis hyper contente car j'ai trouvé la faute..
je tiens à remercier caro95470 pour son aide,
voici le programme :

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
 
function [x] = daiyuan(A,b,x1,epsilon,maxiter)
% Méthode de Dai Yuan pour la résolution d'un problème linéaire Ax=B
% Entrée : A       = la matrice donnée
%          B       = vecteur donné
%          x1      = le point de départ
%          epsilon = tolérance du test d'arret, valeur par défaut 1e-8
%          maxiter = nombre maximum d'itérations, valeur par défaut 1000
% Sortie : x       = solution
% Valeurs par défaut
if nargin < 4, epsilon = 1e-8; end
if nargin < 5, maxiter = 1000; end
A = input ('donner la matrice A =')
b = input ('donner le vecteur b =')
x1 = input ('donner le point du départ x1 =')
iter = 1; % Compteur des itérations
g = A*x1-b;
while iter <= maxiter
if norm(g) <= epsilon, break, end
        if iter == 1
          d = -g, a = norm(g)^2/dot(A*d,d), x_ = x1 + d.^a,...
          g_ = A*x_- b, p = norm(g_)^2/dot(g_-g,d), d_ = -g_+ d.^p;
        else a = norm(g)^2/dot(A*d,d), x_ = x + d.^a,...
            g_ = A*x_-b, p = norm(g_)^2/dot(d,g_-g), d_ = -g_+ d.^p; end
    x = x_;
    g = g_;
    d = d_;
    iter = iter +1; end
if iter > maxiter, warning('nombre maximum d itération atteint'), end

Juste pour l'information, si vous changer la variante "p", vous aurez les autres types du gradient conjugué (Fletcher Reeves, Polak Ribière Polyak, Descente conjugué..)
bon courage
merci encore !!

[RMATH]

Bonjour,
me voilà encore, j'ai fait une faute dans mon programme ,
c'est dans le calcul des itérés, j'ai corrigé
voici le programme :

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
 
 
function [x] = daiyuan(A,b,x1,epsilon,maxiter)
% Méthode de Dai Yuan pour la résolution d'un problème linéaire Ax=B
% Entrée : A       = la matrice donnée
%          B       = vecteur donné
%          x1      = le point de départ
%          epsilon = tolérance du test d'arret, valeur par défaut 1e-8
%          maxiter = nombre maximum d'itérations, valeur par défaut 1000
% Sortie : x       = solution
% Valeurs par défaut
if nargin < 4, epsilon = 1e-8; end
if nargin < 5, maxiter = 1000; end
A = input ('donner la matrice A =')
b = input ('donner le vecteur b =')
x1 = input ('donner le point du départ x1 =')
iter = 1; % Compteur des itérations
g = A*x1-b;
while iter <= maxiter
if norm(g) <= epsilon, break, end
        if iter == 1
          d = -g, a = norm(g)^2/dot(A*d,d), x_ = x1 + d*a,...
          g_ = A*x_- b, p = norm(g_)^2/dot(g_-g,d), d_ = -g_+ d*p;
        else a = norm(g)^2/dot(A*d,d), x_ = x + d*a,...
            g_ = A*x_-b, p = norm(g_)^2/dot(d,g_-g), d_ = -g_+ d*p; end
    x = x_;
    g = g_;
    d = d_;
    iter = iter +1; end
if iter > maxiter, warning('nombre maximum d itération atteint'), end

[Caro-Line]

Bonjour,
si je peux me permettre quelques conseils purement sur la programmation :
- Pour rendre la lecture plus agréable mettre une seule instruction par ligne
- Pour ne pas avoir plein d'affichages (à moins que cela ne soit voulu), remplacer les virgules par des point-virgules

Et je te propose donc ce code qui peut aussi optimiser le temps de calcul :

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
function [x] = daiyuan(A,b,x1,epsilon,maxiter)
% Méthode de Dai Yuan pour la résolution d'un problème linéaire Ax=B
% Entrée : A       = la matrice donnée
%          B       = vecteur donné
%          x1      = le point de départ
%          epsilon = tolérance du test d'arret, valeur par défaut 1e-8
%          maxiter = nombre maximum d'itérations, valeur par défaut 1000
% Sortie : x       = solution
% Valeurs par défaut
if nargin < 4
   epsilon = 1e-8; 
end
if nargin < 5
   maxiter = 1000; 
end
A = input ('donner la matrice A =');
b = input ('donner le vecteur b =');
x1 = input ('donner le point du départ x1 =');
g = A*x1-b;
%Faire ici le calcul pour iter=1 évite de faire maxiter-1 tests dans la boucle.
d = -g;
a = norm(g)^2/dot(A*d,d);
x_ = x1 + d*a;
g_ = A*x_- b;
p = norm(g_)^2/dot(g_-g,d);
d_ = -g_+ d*p;
x = x_;
g = g_;
d = d_;      
%on boucle maintenant à partir du pas 2
for iter = 2:maxiter
   if norm(g) <= epsilon
      break
   end
   a = norm(g)^2/dot(A*d,d);
   x_ = x + d*a;
   g_ = A*x_-b;
   p = norm(g_)^2/dot(d,g_-g);
   d_ = -g_+ d*p;
   x = x_;
   g = g_;
   d = d_;
end
if norm(g) > epsilon %à la fin des itérations la condition n'est toujours pas vraie
   warning('nombre maximum d''itérations atteint');
end

J'espère qu'il n'y a pas de coquilles, je n'ai pas testé, n'ayant aucune idée des valeurs d'entrées qu'il faut mettre.

D'ailleurs question subsidiaire : tu as en entrées de ta fonction les variables A,b et x1 mais elles ne servent à rien puisque tu les écrases dès le début de ton programme en demandant à l'utilisateur de les renseigner

[mr_samurai]

D'ailleurs question subsidiaire : tu as en entrées de ta fonction les variables A,b et x1 mais elles ne servent à rien puisque tu les écrases dès le début de ton programme en demandant à l'utilisateur de les renseigner

Je me disais la même chose .

je vois plutot un code du style :

Code :

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

1
2
3
4
5
6
if nargin == 0 
   % DEMO MODE
   A = input ('donner la matrice A =');
   b = input ('donner le vecteur b =');
   x1 = input ('donner le point du départ x1 =');
end

[RMATH]

Bonjour,
si je peux me permettre quelques conseils purement sur la programmation :
- Pour rendre la lecture plus agréable mettre une seule instruction par ligne
- Pour ne pas avoir plein d'affichages (à moins que cela ne soit voulu), remplacer les virgules par des point-virgules

Bonjour,
Caro95470 merci beaucoup pour tes conseilles et ton aide..
y a plein d’affichages inutiles dans mon programme..merci …

tu as en entrées de ta fonction les variables A,b et x1 mais elles ne servent à rien puisque tu les écrases dès le début de ton programme en demandant à l'utilisateur de les renseigner

Pour ta question, j’ai pas compris comment j’ai écrasé mes variables au début de mon programme..je suis débutante
si tu pourras m’expliquer

J’essaie de résoudre un système linéaire Ax=B par une méthode itérative, comme entrée il faut connaître la matrice A et le vecteur B et le point de départ x1..et on s'arrete si la norme du gradient est inferieur d'un certain epsilon..

Je ne peux pas remplacer la boucle while par for, parce que je ne sais pas quand est ce que le programme s’arrete.. parfois avant le maxiter et parfois non..

merci beaucoup Caro95470

[RMATH]

Je me disais la même chose .

je vois plutot un code du style :

Code :

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

1
2
3
4
5
6
if nargin == 0 
   % DEMO MODE
   A = input ('donner la matrice A =');
   b = input ('donner le vecteur b =');
   x1 = input ('donner le point du départ x1 =');
end

Bonjour,
mr_samurai, merci pour ta réponse, j’ai utilisé le code que tu m’a proposé, merci
pour etre honnete j’ai pas compris pour quoi ?
j’ai lu que la commande nargin sert à controler les variables, comme maxiter et epsilon (valeur par défaut), alors j’ai pas fait ça aux variables A, B et x1 en pensant qu’ils sont donnés exactement..
je serai très reconnaissante si tu pourras m’expliquer un peu (l’utilisation de la commande nargin)
merci beaucoup,

[RMATH]

voici le programme :

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
 
function [x] = daiyuan(A,b,x1,epsilon,maxiter)
% Méthode de Dai Yuan pour la résolution d'un problème linéaire Ax=B
% Entrée : A       = la matrice donnée
%          B       = vecteur donné
%          x1      = le point de départ
%          epsilon = tolérance du test d'arret, valeur par défaut 1e-8
%          maxiter = nombre maximum d'itérations, valeur par défaut 20
% Sortie : x       = solution
if nargin == 0
    % DEMO MODE
    A = input ('donner la matrice A =');
    B = input ('donner le vecteur b =');
   x1 = input ('donner le point du départ x1 =');
end
% Valeurs par défaut
if nargin < 4, 
    epsilon = 1e-8; 
end
if nargin < 5,
    maxiter = 20; 
end
iter = 1; % Compteur des itérations
g = A*x1-B;
while iter <= maxiter
if norm(g) <= epsilon, break, 
end
        if iter == 1
          d = -g;
          a = norm(g)^2/dot(A*d,d);
          x_ = x1 + d*a;
          g_ = A*x_- B;
          p = norm(g_)^2/dot(g_-g,d);
          d_ = -g_+ d*p;
        else
            a = norm(g)^2/dot(A*d,d);
            x_ = x + d*a;
            g_ = A*x_-B,
            p = norm(g_)^2/dot(d,g_-g);
            d_ = -g_+ d*p; 
        end
    x = x_;
    g = g_;
    d = d_;
    iter = iter +1, 
end
if iter > maxiter, 
    warning('nombre maximum d itération atteint'),
end

merci pour votre aide

[Caro-Line]

1. Pour les variables d'entrée :
Comment appelles-tu ta fonction ?
L'entête de ta fonction est :

Code :

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

function [x] = daiyuan(A,b,x1,epsilon,maxiter)

Cela veut donc dire que A,b et x1 sont définis quand tu appelles ta fonction.
Or un peu plus bas tu fais :

Code :

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

1
2
3
A = input ('donner la matrice A =');
b = input ('donner le vecteur b =');
x1 = input ('donner le point du départ x1 =');

Donc tu redéfinis les variables A,b et x1 donc ça ne servait à rien de les mettre en entrée.

Tu dois faire un choix :

• soit tu les laisses en entrées et dans ce cas tu supprimes les lignes d'input (ou tu utilises la solution de Mister Samurai)
• soit tu changes l'entête de ta fonction comme ceci :

  Code :

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

  function [x] = daiyuan(epsilon,maxiter)

  et dans ce cas il faudra aussi modifier tes tests de valeur d'entrée ainsi :

  Code :

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

  1
  2
  3
  4
  5
  6
  if nargin < 1
     epsilon = 1e-8; 
  end
  if nargin < 2
     maxiter = 1000; 
  end

2. Le while/for : tu peux mettre le for c'est exactement la même chose, si la condition est atteinte le programme sortira de la boucle for de la même façon qu'elle sort de la boucle while. Je ne vois pas où est le problème.
Le programme que je t'ai proposé fais exactement la même chose que ton programme de départ.
tu n'as qu'à tester les 2 avec les mêmes valeurs de A,b,x1,epsilon et maxiter, tu obtiendras le même résultat. Ce sera juste plus rapide avec mon programme.

PS : pour nargin va regarder l'aide de MATLAB (help nargin ou doc nargin), elle est très complète.
PS2 : est-ce toi qui as fait le programme au départ ou tu l'as récupéré ?

[mr_samurai]

nargin = n arg in, c'est le nombre d'arguments que tu passes à la fonction, n number, arg argument, in entrée.

Ce qui fait : nombre d'arguments en entrée de la fonction

[RMATH]

Bonjour,
Merci beaucoup pour ton aide, tout est clair pour moi maintenant..
J’ai changé l’en tete de la fonction,

Le while/for : tu peux mettre le for c'est exactement la même chose, si la condition est atteinte le programme sortira de la boucle for de la même façon qu'elle sort de la boucle while.

J’ai cru qu’en utilisant la boucle for , le programme ne va pas sortir,
merci beaucoup pour ton aide..

Le programme que je t'ai proposé fais exactement la même chose que ton programme de départ.
tu n'as qu'à tester les 2 avec les mêmes valeurs de A,b,x1,epsilon et maxiter, tu obtiendras le même résultat. Ce sera juste plus rapide avec mon programme.

j’ai utilisé ton programme, oui j’ai eu le meme résultat, en plus ton programme est plus rapide, mais j’arrive pas à avoir le nombre des itérations…
j’ai essayé avec ça :

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
function [x] = daiyuan(epsilon,maxiter)
% Méthode de Dai Yuan pour la résolution d'un problème linéaire Ax=B
% Entrée : A       = la matrice donnée
%          B       = vecteur donné
%          x1      = le point de départ
%          epsilon = tolérance du test d'arret, valeur par défaut 1e-8
%          maxiter = nombre maximum d'itérations, valeur par défaut 20
% Sortie : x       = solution
% Valeurs par défaut
if nargin < 1, 
    epsilon = 1e-8; 
end
if nargin < 2,
    maxiter = 20; 
end
A = input ('donner la matrice A =');
B = input ('donner le vecteur b =');
x1 = input ('donner le point du départ x1 =');
g = A*x1-B;
d = -g;
a = norm(g)^2/dot(A*d,d);
x_ = x1 + d*a;
g_ = A*x_- B;
p = norm(g_)^2/dot(g_-g,d);
d_ = -g_+ d*p;
x = x_;
g = g_;
d = d_;
for iter = 2:maxiter
    iter = 2
    if norm(g) <= epsilon, 
        break, 
    end                
    a = norm(g)^2/dot(A*d,d);
    x_ = x + d*a;
    g_ = A*x_-B,
     p = norm(g_)^2/dot(d,g_-g);
    d_ = -g_+ d*p; 
    x = x_;
    g = g_;
    d = d_;
    iter = iter +1,
end
if  norm(g) > epsilon,
    warning('norme du gradient superiuer à epsilon'),
end

mais à chaque fois l’itération =3…

est-ce toi qui as fait le programme au départ ou tu l'as récupéré ?

oui c'est moi.. y a plein de faute..
c’est pour la première fois que je fais de la programmation en matlab, j’ai téléchargé quelques cours (matlab), et j’ai bossé…
comme parfois je comprends mal (par exemple pour l’en-tete de la fonction j’ai cru qu’il faut mettre tout ce qui est intéressant..ensuite controler ce qui change avec nargin…), ...

vous m’avez beaucoup aider, je vous remercie beaucoup..

[RMATH]

nargin = n arg in, c'est le nombre d'arguments que tu passes à la fonction, n number, arg argument, in entrée.

Ce qui fait : nombre d'arguments en entrée de la fonction

Bonjour,
merci beaucoup mr_samurai

[Caro-Line]

Il faut bien que tu comprennes que l'instruction FOR va incrémenter la variable iter de 1 en 1, tu ne dois donc pas la réinstancier dans la boucle.
Si ce que tu veux c'est connaitre sa valeur à la fin (pour savoir par ex si la condition à été atteinte avant maxiter) tu fais simplement après le end de la boucle for :

Code :

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

1
2
3
4
5
if norm(g) > epsilon %à la fin des itérations la condition n'est toujours pas vraie
   warning('nombre maximum d''itérations atteint');
end
%Le nombre d'itérations :
sprintf('Le nombre d''itérations effectuée est : %d',iter);

D'autre part je t'avais mis des commentaires dans le code que je t'avais proposé : essaye d'en mettre toi aussi, ce sera plus facile pour comprendre ton code (que ce soit toi qui le reprenne dans 2 jours ou quelqu'un d'autre), et c'est une bonne habitude à prendre.

[RMATH]

Si ce que tu veux c'est connaitre sa valeur à la fin (pour savoir par ex si la condition à été atteinte avant maxiter) tu fais simplement après le end de la boucle for :

Code :

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

1
2
3
4
5
if norm(g) > epsilon %à la fin des itérations la condition n'est toujours pas vraie
   warning('nombre maximum d''itérations atteint');
end
%Le nombre d'itérations :
sprintf('Le nombre d''itérations effectuée est : %d',iter);

Bonjour,
j'ai essayé pas mal de fois, mais ça ne marche pas... le nombre des itérations ne s'affiche pas ...j'ai du faire une faute

je t'avais mis des commentaires dans le code que je t'avais proposé : essaye d'en mettre toi aussi, ce sera plus facile pour comprendre ton code (que ce soit toi qui le reprenne dans 2 jours ou quelqu'un d'autre), et c'est une bonne habitude à prendre.

merci pour le conseil..
voici le programme :

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
 
function [x] = daiyuan(epsilon,maxiter)
% Méthode de Dai Yuan pour la résolution d'un problème linéaire Ax=B
% Entrée : A       = la matrice donnée
%          B       = vecteur donné
%          x1      = le point de départ
%          epsilon = tolérance du test d'arret, valeur par défaut 1e-8
%          maxiter = nombre maximum d'itérations, valeur par défaut 20
% Sortie : x       = solution
% Valeurs par défaut
if nargin < 1, 
    epsilon = 1e-8; 
end
if nargin < 2,
    maxiter = 10000; 
end
A = input ('donner la matrice A =');
B = input ('donner le vecteur b =');
x1 = input ('donner le point du départ x1 =');
% iter =1
% Calcul du gradient en x1
g = A*x1-B;
% on pren la direction du gradient d1 = -g1
d = -g;
% Calucul du pas a1
a = norm(g)^2/dot(A*d,d);
% Première itération x2
x_ = x1 + d*a;
% calcul du gradient en x2
g_ = A*x_- B;
% Calcul de la variante p2 (de Dai Yuan)
p = norm(g_)^2/dot(g_-g,d);
% Calcul de la direction d2
d_ = -g_+ d*p;
x = x_;
g = g_;
d = d_;
% Calcul des iétration à partir de iter =2
for iter = 2:maxiter
    % test d'arret
    if norm(g) <= epsilon, 
        break, 
    end 
    % Calcul du pas ak
    a = norm(g)^2/dot(A*d,d);
    % Calcul de l'itération xk+1
    x_ = x + d*a;
    % Calcul du gradient en xk+1
    g_ = A*x_-B;
    % Calcul de la variante pk+1
     p = norm(g_)^2/dot(d,g_-g);
     % Calcul de la direction dk+1
    d_ = -g_+ d*p; 
    x = x_;
    g = g_;
    d = d_;
end
% Si le test d'arret n'est pa vérifié et ietr>  max
if  norm(g) > epsilon,
    warning('nombre maximum d itération atteint'),
end
% afficher le nombre d'iteration
sprintf('Le nombre d''itérations effectuée est : %d', iter);

merci.

[mr_samurai]

salut,

remplace la derniére ligne :

Code :

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

sprintf('Le nombre d''itérations effectuée est : %d', iter);

par :

Code :

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

fprintf('Le nombre d''itérations effectuée est : %d', iter);

et ça devrait marcher

[RMATH]

Bonjour,
merci beaucoup mr_samurai, ça marche maintenant
hyper contente
merci caro95470 et mr_samurai...
voici le programme :

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
 
function [x] = gradientconjug(epsilon,maxiter)
% Méthode de Dai Yuan pour la résolution d'un problème linéaire Ax=B
% Entrée : A       = la matrice donnée
%          B       = vecteur donné
%          x1      = le point de départ
%          epsilon = tolérance du test d'arret, valeur par défaut 1e-8
%          maxiter = nombre maximum d'itérations, valeur par défaut 20
% Sortie : x       = solution
% Valeurs par défaut
if nargin < 1, 
    epsilon = 1e-8; 
end
if nargin < 2,
    maxiter = 10000; 
end
A = input ('donner la matrice A =');
B = input ('donner le vecteur b =');
x1 = input ('donner le point du départ x1 =');
% iter =1
% Calcul du gradient en x1
g = A*x1-B;
% on pren la direction du gradient d1 = -g1
d = -g;
% Calucul du pas a1
a = norm(g)^2/dot(A*d,d);
% Première itération x2
x_ = x1 + d*a;
% calcul du gradient en x2
g_ = A*x_- B;
% Calcul de la variante p2 (de Dai Yuan)
p = norm(g_)^2/dot(g_-g,d);
% Calcul de la direction d2
d_ = -g_+ d*p;
x = x_;
g = g_;
d = d_;
% Calcul des iétration à partir de iter =2
for iter = 2:maxiter
    % test d'arret
    if norm(g) <= epsilon, 
        break, 
    end 
    % Calcul du pas ak
    a = norm(g)^2/dot(A*d,d);
    % Calcul de l'itération xk+1
    x_ = x + d*a;
    % Calcul du gradient en xk+1
    g_ = A*x_-B;
    % Calcul de la variante pk+1
     p = norm(g_)^2/dot(d,g_-g);
     % Calcul de la direction dk+1
    d_ = -g_+ d*p; 
    x = x_;
    g = g_;
    d = d_;
end
% Si le test d'arret n'est pa vérifié et ietr>  max
if  norm(g) > epsilon,
    warning('nombre maximum d itération atteint'),
end
% afficher le nombre d'iteration
fprintf('Le nombre d''itérations effectuée est : %d', iter);