lösen dynamische Anzahl von nichtlinearen Gleichungen in Python

Question

Fsolve in Scipy scheint der richtige Kandidat dafür zu sein, ich brauche nur Hilfe Gleichungen dynamisch übergeben. Ich schätze irgendwelche Gedanken im Voraus.

Durch dynamische ich meine Anzahl der Gleichungen von einem Trum zum anderen unterscheiden eine Situation zum Beispiel ich habe:

alpha*x + (1-alpha)*x*y - y = 0 
beta*x + (1- beta)*x*z - z = 0 
A*x + B*y + C*z = D 

und eine andere Situation, ich habe:

alpha*x + (1-alpha)*x*y - y = 0 
beta*x + (1- beta)*x*z - z = 0 
gama*x + (1 -gama)*x*w - w =0 
A*x + B*y + C*z + D*w = E 

alpha, beta, A, B, C, und E sind alle Konstanten. x, y, z, w sind Variablen.

Answer 1

Ich habe Fsolve nicht selbst benutzt, aber laut seiner Dokumentation benötigt es eine aufrufbare Funktion. So etwas behandelt mehrere Funktionen mit unbekannter Anzahl von Variablen. Beachten Sie, dass die Argumente hier korrekt angeordnet sein müssen, aber jede Funktion einfach eine Liste erstellt.

def f1(argList): 
    x = argList[0] 
    return x**2 
def f2(argList): 
    x = argList[0] 
    y = argList[1] 
    return (x+y)**2 
def f3(argList): 
    x = argList[0] 
    return x/3 

fs = [f1,f2,f3] 
args = [3,5] 
for f in fs: 
    print f(args) 

Für fsolve, könnten Sie so etwas wie diese (nicht getestet) versuchen:

def func1(argList, constList): 
    x = argList[0] 
    y = argList[1] 
    alpha = constList[0] 
    return alpha*x + (1-alpha)*x*y - y 
def func2(argList, constList): 
    x = argList[0] 
    y = argList[1] 
    z = argList[2] 
    beta = constList[1] 
    return beta*x + (1- beta)*x*z - z 
def func3(argList, constList): 
    x = argList[0] 
    w = argList[1] ## or, if you want to pass the exact same list to each function, make w argList[4] 
    gamma = constList[2] 
    return gama*x + (1 -gama)*x*w - w 
def func4(argList, constList): 

    return A*x + B*y + C*z + D*w -E ## note that I moved E to the left hand side 


functions = [] 
functions.append((func1, argList1, constList1, args01)) 
# args here can be tailored to fit your function structure 
# Just make sure to align it with the way you call your function: 
# args = [argList, constLit] 
# args0 can be null. 
functions.append((func1, argList2, constList2, args02)) 
functions.append((func1, argList3, constList3, args03)) 
functions.append((func1, argList4, constList4, args04)) 

for func,argList, constList, args0 in functions: ## argList is the (Vector) variable you're solving for. 
    Fsolve(func = func, x0 = ..., args = constList, ...)