import re
def get_number(element):
    re_number = re.match("(\d+\.?\d*)", element)

    if re_number:
        return float(re_number.group(1))
    else:
        return 1.0

def getvalues(equation):
    elements = re.findall("([a-z0-9.]+)", equation)
    return [get_number(element) for element in elements]


eqn = []
eqn_no = int(raw_input("Enter the number of equations: "))

for i in range(eqn_no):
    eqn.append(getvalues(str(raw_input("Enter Equation %d: " % (i+1)))))
print "Main Matrix: "
for i in range((eqn_no)):
    for j in range((eqn_no+1)):
        print "\t%f" %(eqn[i][j]),
    print
print
equation=[]
equation=eqn
for k in range((eqn_no-1)):
    for i in range((k+1),eqn_no):
        for j in range((eqn_no+1)):
            if(eqn[i][j]!=0):
                eqn[i][j]=eqn[i][j]-(eqn[k][j]*(equation[i][k]/eqn[k][k]))



    print "Matrix After %d step: " %(k+1)
    for i in range(eqn_no):
            for j in range((eqn_no+1)):
                print "\t%f"%(eqn[i][j]),
                equation[i][j]=eqn[i][j];

            print
    print

Pour entrée:

25x+5y+z=106.8
64x+8y+z=177.2
144x+12y+z=279.2

La sortie est:

Main Matrix: 
    25.000000   5.000000    1.000000    106.800000
    64.000000   8.000000    1.000000    177.200000
    144.000000  12.000000   1.000000    279.200000

Matrix After 1 step: 
    25.000000   5.000000    1.000000    106.800000
    0.000000    8.000000    1.000000    177.200000
    0.000000    12.000000   1.000000    279.200000

Matrix After 2 step: 
    25.000000   5.000000    1.000000    106.800000
    0.000000    8.000000    1.000000    177.200000
    0.000000    0.000000    1.000000    279.200000

Mais ça devrait être comme

Main Matrix: 
    25.000000   5.000000    1.000000    106.800000
    64.000000   8.000000    1.000000    177.200000
    144.000000  12.000000   1.000000    279.200000

Matrix After 1 step: 
    25.000000   5.000000    1.000000    106.800000
    0.000000    -4.80000    -1.56000    -96.208000
    0.000000    -16.8000    -4.76000    -335.968000

Matrix After 2 step: 
    25.000000   5.000000    1.000000    106.800000
    0.000000    -4.80000    -1.56000    -96.208000
    0.000000    0.000000    0.699999    0.759981

Tout d'abord, il s'agit d'un code partiel pour résoudre la racine d'un nombre n d'équations à l'aide de la méthode d'élémination Naive Guass. Quelqu'un a-t-il une idée de pourquoi diable cela se produit-il? Pourquoi les pièces zéro changent et d'autres non? J'ai fait ce code en C ++ et il y fonctionne parfaitement mais ici je suis confronté à de nombreux problèmes. Peut-être que je suis novice en python. J'utilise python 2.7 .....

-3
Ahashan Alam Sojib 16 juil. 2015 à 21:27

2 réponses

Meilleure réponse

Je pense que le problème est l'attribution equation = eqn. Puisque eqn est une liste, c'est un mutable et donc passé comme référence, lorsque vous affectez un mutable, la variable contient en fait un pointeur vers cet objet. Cela signifie que equation et eqn sont la même liste.

Vous devriez

from copy import deepcopy
equation = deepcopy(eqn)

Vous avez besoin de deepcopy au lieu de copy car vous avez une liste de listes, la liste interne doit également être copiée.

3
Oberix 16 juil. 2015 à 18:43

Cette ligne:

equation=eqn

Ne fait pas ce que vous pensez qu'il fait. Essayez plutôt ceci:

import copy
equation=copy.deepcopy(eqn)

L'affectation Python n'est pas une opération de copie, mais plutôt une opération de liaison. La ligne que vous avez signifie " liez le nom equation au même objet auquel eqn est actuellement lié. "

Votre algorithme exige que equation et eqn soient des objets distincts.

1
Robᵩ 16 juil. 2015 à 18:43