Discussion :

[fred2703]

Salut à tous,
je suis débutant et j'ai un problème avec ma boucle.
je vous l'écris tout de suite avec un exemple ce sera plus simple:

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
M=[[6.0,0.0,-1.0,0.0,0.0],[12.0,0.0,0.0,-2.0,0.0],[6.0,2.0,-2.0,-1.0,0.0],[0.0,0.0,0.0,1.0,1.0]]
nblignes= len (M)
nbcolonnes= len (M[0])
lignes_faites=[]
 
def pivot(i,j):      
    i=0
    j=0
    pivoti=0
    pivotj=0
    pivotij= M[i][j]
    trouver=False
    while i<nblignes and not i in lignes_faites and trouver==False :
        if M[i][j]==0 and j<nbcolonnes-1:
            j=j+1
        elif j==nbcolonnes-1:
            i=i+1
        else:
            pivoti=i
            pivotj=j
            pivotij= M[pivoti][pivotj] #retourne le pivot
            lignes_faites.append(i)
            trouver==True       
    else:
        for j in range (nbcolonnes):
             M[pivoti][j]=M[pivoti][j]/float(pivotij) 
        for i in range(nblignes): 
            y=M[i][pivotj]
            if y!=0 and not i==pivoti:
                for j in range (nbcolonnes):
                    M[i][j]=M[i][j]-(M[pivoti][j]*y)
        trouver=False #à priori sert à rien ...
        i=i+1 #à priori sert à rien ...
        j=0 #à priori sert à rien ...
        pivoti=0 #à priori sert à rien ...
        pivotj=0#à priori sert à rien ...
 
 
for i in range (nblignes):
    for j in range (nbcolonnes):
        pivot(i,j)
print M

si je lance mon programme voila la réponse:

Code :

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

[[1.0, 0.0, -0.16666666666666666, 0.0, 0.0], [0.0, 0.0, 2.0, -2.0, 0.0], [0.0, 2.0, -1.0, -1.0, 0.0], [0.0, 0.0, 0.0, 1.0, 1.0]]

C'est un bon début, mais c'est que la moitié de ce que je dois réaliser malheureusement

J'aimerais qu'il puisse retourner ce résultat dans ma fonction pour obtenir une matrice davantage simplifiée.

L'idée c'est qu'il doit trouver un pivot !=0 par ligne et, qui n'est pas dans la même colonne que le pivot de la ligne précédente. Toutes les autres valeurs de la colonne où il y a le pivot, doivent devenir ==0 par une astuce mathématique.

Ne faite pas attention à la dernière ligne et la dernière colonne qui sont là pour autres chose. Il faut donc ne pas en tenir compte.

si qq un peut m'aider, je lui serai reconnaissant.

[josmiley]

je comprendrai mieux avec un exemple input/output ...

[Loenix]

Bonsoir,

Je commence à avoir du mal a me concentrer (la journée a été longue) mais la... vous me facilité pas la tache ^^. J'aimerai vous aider, mais je n'ai pas vraiment compris ce que vous désiriez faire...

Je n'ai donc pas très bien compris mais je pense savoir comment règler votre soucis, vous avez voulu mélanger plusieurs variables :

Vous dites :

Code :

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

trouver=False #à priori sert à rien ...

Pourquoi il sert à rien ? Il a pour but d'apres ce que j'ai vu de faire la fonction situé sous la boucle "while" :

Code :

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

while i<nblignes and not i in lignes_faites and trouver==False :

Les "à priori sert à rien ..." en bas de votre deuxieme fonction ne serve en effet à rien puisque la condition du while (précédement affiché) n'est plus vérifier après etre passé dans le "else". C'est normal, vous rédefinissez vos i et j en leurs faisant parcourir toutes les colonnes :

Code :

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

1
2
3
for j in range (nbcolonnes):
             M[pivoti][j]=M[pivoti][j]/float(pivotij) 
        for i in range(nblignes):

Donc la ou il y a marqué "Sert a rien", faites un print de vos variables, elles auront forcement la valeur maximale (ici 3 pour le nombre de colonne), et donc forcement lorsque le while va reverifier si les conditions sont bonnes pour éxécuter ses fonctions, il voit que :
i > nblignes donc il recommence a ne pas faire la suite...

Choisissez d'autre nom de variable :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
else:
        for k in range (nbcolonnes):
             M[pivoti][k]=M[pivoti][k]/float(pivotij) 
        for m in range(nblignes): 
            y=M[m][pivotj]
            if y!=0 and not i==pivoti:
                for n in range (nbcolonnes):
                    M[m][n]=M[m][n]-(M[pivoti][n]*y)
        trouver=False
        i=i+1
        j=0 
        pivoti=0 
        pivotj=0

Je ne sais pas si cela résoudra votre probleme, mais peut-etre y verrez-vous plus clair après cette épuration

Bon courage à vous...

Mickael

[fred2703]

ha oui effectivement je comprend mieux pourquoi ça marche pas. Merci de m'avoir déjà éclairer là dessus je vais réfléchir à ce que vous me dites.
Ba à vrai dire c'est assez dur et tordu d'expliquer ce que je dois faire et comme c'est la première fois que je programme, j'ai du mal à être clair dans ce que j'essaye d'expliquer.
merci

[Loenix]

Re bonsoir,

Il n'y à pas de soucis, il est vrai que ce n'est pas toujours évident d'exprimé aux autres une chose qu'on a compris (pour nous c'est évident) ^^. L'important, c'est qu'après vos teste, cela marche, si tel est le cas, n'hésitez à mettre votre code terminé pour ceux qui serait intéressé, et surtout n'oubliez pas le "Résolu".
Sinon, postez à la suite, votre nouveau code avec... votre nouvelle erreur lol.

Bonne chance...

Mickael

[fred2703]

Re-bonsoir, votre méthode m'a déjà bien aidée mais j'ai un petit souci il ne va toujours pas jsq au bout :/

voici mon code :

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
 
M=[[6.0,0.0,-1.0,0.0,0.0],[12.0,0.0,0.0,-2.0,0.0],[6.0,2.0,-2.0,-1.0,0.0],[0.0,0.0,0.0,1.0,1.0]]
nblignes= len (M)
nbcolonnes= len (M[0])
lignes_faites=[]
def pivot(i,j):      
    i=0
    j=0
    pivoti=0
    pivotj=0
    pivotij= M[i][j]
    trouver=False
    if i in lignes_faites:
        i=i+1  
    while i < nblignes and trouver==False and not i in lignes_faites:
        if M[i][j]==0 and j <nbcolonnes:
            j=j+1
        else:
            pivoti=i
            pivotj=j
            pivotij= M[pivoti][pivotj] 
            trouver==True #retourne les variables
            lignes_faites.append(i) #ajoute l'indice de la ligne ou le pivot a été trouvé
 
    else:
        for k in range (nbcolonnes):
             M[pivoti][k]=M[pivoti][k]/float(pivotij) 
        for m in range(nblignes): 
             y=M[m][pivotj]
             if y!=0 and not m==pivoti:
                for k in range (nbcolonnes):
                    M[m][k]=M[m][k]-(M[pivoti][k]*y)
 
 
        trouver=False #re-initialise les variables de départ pour continuer plus loin.
        i=i+1
        j=0
        pivotj=0
        pivotj=0
 
 
for i in range (nblignes):
    for j in range (nbcolonnes):
        pivot(i,j)
print M,lignes_faites

voila la réponse :

Code :

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

[[1.0, 0.0, 0.0, -0.16666666666666666, 0.0], [0.0, 0.0, 1.0, -1.0, 0.0], [0.0, 2.0, 0.0, -2.0, 0.0], [0.0, 0.0, 0.0, 1.0, 1.0]] [0, 1]

comme on peut le voir les lignes_faites sont [0,1]
mais il doit aller jsq à 2 :/ je vois pas où se situe mon problème cette fois pcq je ré-initialise i de cette façons : i=i+1 :/

si qq un peut m'aider à voir plus clair, je lui en serai reconnaissant.

[Loenix]

Bonjour,

Je n'ai pas finis de testé le code mais pour éviter de perdre du temps, si vous passez sur le forum sachez que vous vous êtes trompé en définissant votre variable "trouver" :

Code :

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

trouver == True #retourne les variables

Je pense que ceci serait mieux ^^ (sa doit être une faute d’inattention vue que les autres sont biens initialisés)

Code :

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

trouver =True #retourne les variables

Bon courage...

Mickael

[fred2703]

merci d'avoir relever cette stupide faute

[Loenix]

Bonsoir,

Cela marche-t-il maintenant ?

Mickael

[fred2703]

Malheureusement non

il ne le fait toujourss pas jusqu' au bout pour que j'obtienne la matrice simplifiée suivante:

Code :

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

[[1,0,0,0,1/6],[0,0,1,0,1],[0,1,0,0,1],[0,0,0,1,1]]

il arrive à la moitié du processus, il ne prend pas le 3 ème pivots situés sur la ligne d'indice 2 et après ça il doit encore le faire avec la ligne d'indice 3
Donc dans la lignes[2],il effectue pas le "else", vu qu'il ne divise pas par 2 ou alors c'est qu'il ne prend tout simplement pas le pivot :/
je pense que je vais retravailler le programme autrement.


j'ai oublier de le mentionner mais ça peut peut-être vous aidez à y voir plus clair:
ce que j'essaye de faire c'est la méthode de simplification des matrices de Gauss-Jordan.
Je suis vraiment tout proche mais ça coince là

déjà un grand merci pour votre aide

[nardo47]

Salut,

Je n'ai pas vraiment tout lu, mais quelque chose m'a sauté aux yeux dans ton code.

Code :

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

1
2
3
4
 
def pivot(i,j):      
    i=0
    j=0

De 2 choses l'une :

1. Soit tu positionnes systématiquement i et j dans le corps de ta fonction et dans ce cas tu ne les déclares pas en tant qu'arguments de ta fonction pivot ;
2. Soit tu les gardes en argument et tu ne les positionnes pas dans le corps de ta fonction.

Vu la double boucle for que tu places en fin de script, je pencherais pour la solution n°2, mais c'est à étudier.

Je ne dis pas que ça va résoudre ton problème, mais peut-être que si !

[fred2703]

voila j'ai réussi mon projet , je met ce que j'ai fait maintenant. Un grand merci à vous

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
 #étape 3: Matrice sous forme échelonnée réduite
 
 
lignes_faites=[]
 
def new_matrice(x):                     #cette fonction va transformer la matrice initiale
                                        #sous sa forme échelonnée réduite
 
    for c in range (lgr_ligne):         #parcours chaque colonne 
 
        trouver=False                   #si on trouve le pivot, la variable deviendra 'True' et on
                                        #sortira de la première boucle for pour effectuer les suivantes                                       
 
        for i in range(lgr_matrice):    #parcours chaque ligne de la matrice
 
            if trouver==False and M[i][c]!=0 and not i in lignes_faites: #ensemble des conditions pour trouver 
                                                                         #le pivot de la ligne: pivot différent de 0,
                                                                         #pas déjà pris d'une ligne et la condition boléenne 
                                                                         #pour exécuter la boucle for                                                                     
 
                pivoti=i                #définis la ligne du pivot
                pivotj=c                #définis la colonne du pivot
 
                pivotij= M[pivoti][pivotj] #le pivot de la ligne
 
                trouver=True            #on a trouvé le pivot,on sort de la boucle for
 
                lignes_faites.append(i) #ajoute l'indice de la ligne du pivot pour ne pas rechoisir 
                                        #un pivot dans cette ligne (voir condition)
 
        for k in range (lgr_ligne):     
 
            M[pivoti][k]=M[pivoti][k]/pivotij           #divise chaque élément de la ligne du pivot par son pivot
 
        for m in range (lgr_matrice):
 
            if m!=pivoti :                              #il faut que ce soit les autres lignes que             
                                                        #celle du pivot, qui soient traitées   
 
                y=M[m][pivotj]                          #élément de chaque ligne situé dans la colonne du pivot
                                                        #y est l'élément multiplicateur de la ligne du pivot
 
 
                for k in range (lgr_ligne): 
 
                    M[m][k]=M[m][k]-(M[pivoti][k]*y)    #permet de changer les éléments se trouvant dans la 
                                                        #même colonne que celle du pivot, par 0. Et ce, en remplaçant la 
                                                        #ligne de ces éléments par elle-même moins(y * la ligne du pivot)