Python: Liste algebraische Vereinfachung

Question

Hallo Ich versuche, die gemeinsame Bedingungen einer Liste, um es zum Beispiel zu vereinfachen, wenn die Liste ich habe, ist:

List=[['1','A1','B1','Kc','Ka'],['1','A1','B1','D2','Kc','Ka'],['-1','A1','B1','D1','Kc','Ka'],['1','A1','B1','D1','KD','Ka'],['-1','B1','D1','C1','Kc','Ka','KF'],['1','B1','D1','F1','Kc','Kz','Kl']]  

gibt es eine Funktion, die mir als ein Ergebnis geben könnte :

List_output=[['A1','B1',[['D1',['ka',[['-1','Kc'],['1','KD']]]],['1','Kc','Ka'],['-1','D2','Kc','Ka']]],['B1,D1'[[ 'C1',[-1,'Kc','Ka','kF']],['F1',['1','Kz','Kl','Kc']]] ]] 

Was ich im Grunde tun möchte, ist und algebraische Reduktion.

A1 B1 Kc Ka + A1 B1 D2 Kc Ka -A1 B1 D1 Kc Ka + A1 B1 D1 KD Ka - B1 D1 C1 Kc Ka KF + B1 D1 F1 Kc Kz Kl

= A1B1 [D1 [- KcKa + KDKa] + D2KcKa + KcKa] + B1D1 [-C1 [KcKaKF] + F1 [KcKzKl]]

Die einzige Voraussetzung für die Vereinfachung ist, dass alle vereinfachten Begriffe von einer Summe oder einem Rest von K abhängen müssen. Mit anderen Worten, alles muss eine Funktion einer linearen Kombination von K sein; [-KcKa + KDKa]; [KcKaKF] = [['- 1', 'Kc', 'Ka'], ['+ 1', 'KD', 'Ka']]; ['+1', 'Kc', 'Ka', 'KF']

Ich versuche, Sympy zu verwenden, aber das Problem, das ich habe, ist, dass die zu reduzierenden Bedingungen von einer Ausrüstung kommen, also weiß ich nie, was die Symbole würden sei und um sympy zu benutzen musst du die symbole deklarieren. Irgendeine Idee, wie ich dieses Problem angehen kann?

Answer 1

Zunächst einmal verwandeln Sie Ihre Liste an einen SymPy Ausdruck:

In [1]: List=[['1','A1','B1','Kc','Ka'],['1','A1','B1','D2','Kc','Ka'],['-1','A1','B1','D1','Kc','Ka'],['1','A1','B1','D1','KD','Ka'],['-1','B1','D1','C1','Kc','Ka','KF'],['1','B1','D1','F1','Kc','Kz','Kl']] 

In [2]: list_add_mul = sympify(List) 

In [4]: expr = Add(*map(lambda x: Mul(*x), list_add_mul)) 

In [5]: expr 
Out[5]: 
A₁⋅B₁⋅D₁⋅KD⋅Ka - A₁⋅B₁⋅D₁⋅Ka⋅Kc + A₁⋅B₁⋅D₂⋅Ka⋅Kc + A₁⋅B₁⋅Ka⋅Kc - B₁⋅C₁⋅D₁⋅KF⋅K 
a⋅Kc + B₁⋅D₁⋅F₁⋅Kc⋅Kl⋅Kz 

Jetzt ausdr ist der SymPy Ausdruck, mit denen Sie arbeiten möchten. Wenn Sie einfach nur einige Werte ersetzen möchten, verwenden Sie .subs:

Denken Sie daran, um die Symbole zu definieren, die Sie verwenden werden:

>>> var("Ka, Kc, Kz") 

Dann können Sie ersetzen:

In [6]: expr.subs({Ka: 25.0, Kc: 7.0, Kz: 3.5}) 
Out[6]: 
25.0⋅A₁⋅B₁⋅D₁⋅KD - 175.0⋅A₁⋅B₁⋅D₁ + 175.0⋅A₁⋅B₁⋅D₂ + 175.0⋅A₁⋅B₁ - 175.0⋅B₁⋅C₁ 
⋅D₁⋅KF + 24.5⋅B₁⋅D₁⋅F₁⋅Kl 

Andernfalls könnten Sie versuchen, eine Substitutionsregel für Ihre Variablen zu definieren. Zum Beispiel legte sie in einem dict:

{ 
    Ka: ... , 
    Kc: ... , 
    KD: ... , 
    KF: ... , 
} 

Sie sollen die Punkte mit einem geeigneten Expressions mit neuen Variablen ersetzen. Diese neuen Variablen sollten die Kombinationen Ihrer Konstanten K darstellen.

Zum Beispiel: c1 = -Kc * Ka + KD * Ka, _c2 = ... _ dann invertieren Sie diese Gleichungen.

In Ihrem Fall scheint es, dass Ihre Ausdrücke nicht richtig umgekehrt werden kann:

>>> solve([Eq(-Kc*Ka + KD*Ka, c1), Eq(Kc*Ka*KF, c2), Eq(-Kc*Ka + KD*Ka, c3), Eq(Kc*Ka*KF, c4)], Ka, Kc, KD, KF) 
[] 

Answer 2

Ich glaube, Sie algebraische Manipulationen wissen, was Sie tun wollen, aber Sie sind heraus bekommen die „K“ Symbole aufgehängt Sympathie? Sympy ist ziemlich gut darin, Variablennamen zu erraten.Sie können nur den Ausdruck konstruieren:

In [1]: import sympy 

In [2]: List=[['1','A1','B1','Kc','Ka'],['1','A1','B1','D2','Kc','Ka'],['-1','A 
    ...: 1','B1','D1','Kc','Ka'],['1','A1','B1','D1','KD','Ka'],['-1','B1','D1', 
    ...: 'C1','Kc','Ka','KF'],['1','B1','D1','F1','Kc','Kz','Kl']]  

In [3]: expression = sympy.Add(*[sympy.Mul(*[sympy.S(y) for y in x]) for x in L 
    ...: ist]) 

In [4]: expression 
Out[4]: A1*B1*D1*KD*Ka - A1*B1*D1*Ka*Kc + A1*B1*D2*Ka*Kc + A1*B1*Ka*Kc - B1*C1*D1*KF*Ka*Kc + B1*D1*F1*Kc*Kl*Kz 

Und dann die Liste der Symbole erhalten:

In [5]: all_symbols = [x for x in expression.atoms() if type(x)==sympy.Symbol] 

In [6]: all_symbols 
Out[6]: [Kc, B1, KF, A1, Kz, Ka, D1, C1, F1, D2, KD, Kl] 

Sobald Sie die Liste der Symbole haben, ist es trivial diejenigen zu ergreifen, die mit einem ‚K‘ beginnen oder nicht:

In [7]: solvefor = [x for x in all_symbols if str(x)[0]!="K"] 

In [8]: solvefor 
Out[8]: [B1, A1, D1, C1, F1, D2] 

In [9]: sympy.horner(expression, wrt=solvefor) 
Out[9]: B1*(A1*(D1*(KD*Ka - Ka*Kc) + D2*Ka*Kc + Ka*Kc) + D1*(-C1*KF*Ka*Kc + F1*Kc*Kl*Kz))