Discussion :

[Andrey]

Bonjour , je rélaise un programme sur les déterminants et les valeurs propres . Pour les déterminants , pas de pb ... mais pour les valeurs propres c'est autre chose ...

Voici mon 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
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
program determinant;
 
uses wincrt;
 
type tmat=array[1..10,1..10] of integer;
 
var dim,d:integer;
    det,det2:integer;
    mat:tmat;
    vals:integer;
 
Procedure entree;
var lig,col:integer;
 
    begin
    writeln('Entrez la dimension de la matrice');
    readln(dim);
    writeln('Entrez les composantes ');
    for lig:=1 to dim do begin
    writeln('pour la ligne ',lig);
    for col:=1 to dim do begin
    writeln('colonne ',col, '?');
    readln (mat[lig,col])
    end
    end
    end;
 
 
Procedure afficher (mat:tmat) ;
var lig,col:integer;
 
    begin
    for lig:=1 to dim do
    begin
    writeln;
    for col:=1 to dim do
    write(mat[lig,col]:5)
    end;
    end;
 
 
 
Procedure sous_mat (mdeb:tmat ; var mfin:tmat ; ind,dim:integer);
var col,lig,l:integer;
 
    begin
    l:=0;
    for lig:=1 to dim do begin
    if lig <> ind then begin
    l:=l+1;
    for col:=2 to dim do
    mfin[l,col-1]:=mdeb[lig,col]
    end
    end
    end;
 
 
 
Function detn (m:tmat ; d:integer):integer;
var mprim:tmat;
    lig,signe:integer;
    result:integer;
 
 
    begin
    if d=1 then detn:=m[1,1]
    else begin
    result:=0;
    signe:=-1;
    for lig:=1 to d do begin
    sous_mat (m,mprim,lig,d);
    signe:=-signe;
    result:=result+(signe*m[lig,1]*detn(mprim,d-1))
    end;
    detn:=result
    end;
    end;
 
Function valeurs (var mat:tmat ; d:integer):integer ;
var x,lig,col,propres: integer;
    begin if d=1 then valeurs:=mat[1,1] else begin
    for x:=-1 to 1 do
 
 
    for lig:=1 to dim do begin
    for col:=1 to dim do begin
 
    if lig=col then  mat[lig,col]:=mat[lig,col]-x;
                         end;
                         end;
    det2:=detn(mat,d) ;
 
 
    end;
    if det2=0 then x:=propres
 
 
 
    end;
 
 
 
Begin
 
entree;
      afficher (mat);
      writeln;
      det:=detn(mat,dim);
      writeln;
      writeln('Le determinant est : ' ,det);
      writeln;
      vals:=valeurs(mat,d);
      writeln('les valeurs propres sont : ',vals )
 
 
end.

Sauriez vous me dire ce qui ne va pas dans mon programme ?

[Eric Sigoillot]

Le calcul de valeurs propres d'une matrice n'est pas un exercice simple, loin de là, car il est très souvent complexe d'obtenir ce serait-ce qu'une valeur propre sur une matrice quelconque.

Avant de corriger quoique ce soit, il faudrait nous dire quel algorithme tu as envisagé afin, d'une aprt, de voir si celui-ci est correct, et d'autre part, de voir si sa correspondance en Pascal est correcte.

Je vois déjà que pour le calcul du déterminant tu passes par des comatrices. Pourtant, informatiquement parlant, c'est généralement une réduction de Gauss qui est utilisée car bien plus efficace. La méthode des comatrices n'est pratique qu'à la main...

@++

[Loceka]

Pour les valeurs propres, le plus simple ne serait-il pas de résoudre l'équation Det(Matrice - VP * Identité) ?

J'ai pas le temps de penser à ça aujourd'hui (plus en profondeur en tout cas), mais ça me paraît quand même assez difficile à réaliser en pascal !

[pascal_damien]

Salut,

Juste en passant mais sans entrer dans le détail, il y a une étourderie ici :
vals:=valeurs(mat,d);

Il semble que la variable d n'est pas initialisée, mais qu'elle est par contre testée (en tant que paramètre) dès l'entrée dans la fonction valeurs. La fonction ne peut renvoyer qu'une seule valeur propre alors qu'il peut y'en avoir plus d'une et tu ne renvois une valeur que dans le cas où d = 1.

Un problème plus général, est que tu utilises trop de variables globales qui nuisent à la lisibilité du programme ; il est préférable d'utiliser des paramètres ; ce qui permet de plus de transformer facilement le programme en unité. Tu devrais également essayer d'indenter plus ton code (ça le rend également plus lisible).

PS : je ne fait pas ces remarques pour être désagréable

[forbin]

Bonjour,

Je ne tiens pas non plus à être désagréable, mais quel est ton but Andrey ?

Est-ce de te familiariser avec la programmation par l'intermédiaire d'un algorithme de calcul de vecteurs et valeurs propres, ou bien dois tu avoir une procédure de calcul de valeurs et vecteurs propres dans le cadre d'un projet plus important ?

Si c'est le cas, inutile de "réinventer la roue", personnellement je l'avais récupéré dans

Denis Monasse, Mathématiques et informatique, Paris, Vuibert, 1988, pp.125-26.

je ne l'affiche pas si cela dois contrevenir aux droits d'auteurs.

amicalement,

4BIN

[Andrey]

Merci à vous , ceux qui m'ont répondu .
Pour etre precis , c'est un projet d'info que j'ai à réaliser et je suis trop nul dans cette matière ( et pas très bon ailleurs non plus )

J'ai eu la meme idée en ce qui concerne le fait de résoudre l'equation det ( A - BI ) mais j'ai pas réussi à trouver la syntaxe :-/ , déja que le calcul du déterminant c'est pas moi qui l'ait fait ...

sur ce , si vous pouviez me donner la syntaxe correspondante à ce que je veux faire , merci

[Mayhem555]

Si je peux me permettre...

Résoudre det(A-VP*Identité) ne te mènera pas à grand chose étant donné que c'est un polynome caractéristique donc une équation non linéaire à résoudre. Or pour ce genre de cas, les algorithmes nécessitent tout de même de "localiser" une racine avant de lancer l'algorithme, afin que celui-ci converge vers la racine cherchée...(je parle des algorithmes style Newton (ordre2) ou des évolutions aux ordres supérieurs). Et je ne parle même pas du cas où les racines sont complexes, car là cela demande quelques modifications et précautions.

Il existe un très bon algorithme de recherche des valeurs propres (qui permet de faire converger la matrice de départ vers une matrice diagonale contenant toutes les valeurs propres cherchées). C'est l'algorithme par décomposition QR...elle utilise la même décomposition que celle de la méthode de Householder (pour résoudre les systèmes linéaire).