'' Keine Schleife, die mit der angegebenen Signatur übereinstimmt '' FEHLER beim Versuch, die lineare Gleichung zu lösen

Question

Allright. Also versuche ich, Lösungen für 3 lineare Gleichungen zu erhalten, indem ich eine 3x3-Koeffizientenmatrix (benannt c) und ein abhängiges Wertearray (benannt d) benutze. MEIN CODE:

import numpy as np 

import sympy as sym 

Ax, Ay, By, M0, F, q, L, L1, L2 = sym.symbols('A_x, A_y, B_y, M_0, F, q, L, L_1, L_2') 

p = {'L': 6, 'L_1': 4, 'L_2': 2, 'q': 2000, 'F': 1000, 'M_0': 4000} 

eq_Fx = sym.Eq(Ax - F, 0) 

eq_MB = sym.Eq(-Ay*L + q*L1*(L1/2) + M0, 0) 

eq_MA = sym.Eq(By*L + M0 - L1*q*(L1/2), 0) 

c = np.array([[1, 0, 0], 

[0, p['L'], 0], 

[0, 0, p['L']]]) 

d = np.array([F, 

(p['q']*p['L_1']**2)/2 + p['M_0'], 

(p['q']*p['L_1']**2)/2 - p['M_0']]) 

result = np.linalg.solve(c, d) 

print(result) 

Es stellt sich diese seltsame Fehler, die ich nicht verstehe:

TypeError: No loop matching the specified signature and casting was found for ufunc solve1.

ich darüber hinaus dankbar wäre, wenn jemand auch weiß, was das bedeutet, oder, wie ich es korrigieren kann.

Answer 1

Wenn Sie die Gleichungen symbolisch lösen oder bearbeiten möchten, sollten Sie SymPy verwenden. Wenn Sie eine numerische Lösung wünschen, sollten Sie NumPy verwenden. Wenn Sie mit SymPy-Ausdrücken beginnen und zu NumPy-Funktionen wechseln möchten, sollten Sie lambdify verwenden.

In Ihrem Code haben Sie einige SymPy-Gleichungen erstellt, die Sie jedoch nicht verwenden. Das Problem ist, dass Sie F anstelle von p['F'] in Ihrer Definition von d verwendet haben und ein NumPy-Array mit einem unbewerteten SymPy-Symbol F erstellt haben, mit dem es nicht umgehen kann. Wenn Sie die SymPy-Teile vollständig entfernen, funktioniert Ihr Code immer noch, da Sie ihn überhaupt nicht verwenden, um die Gleichungen oder irgendetwas abzuleiten.

Übrigens, da Ihre Gleichung linear ist, kann SymPy sie genau lösen. So machen Sie das, wenn Sie interessiert sind.

>>> p = {M0: 4000, L1: 4, F: 1000, L: 6, L2: 2, q: 2000} 
>>> solve([eq_Fx.subs(p), eq_MB.subs(p), eq_MA.subs(p)], [Ax, Ay, By]) 
{B_y: 2000, A_x: 1000, A_y: 10000/3} 

Bitte beachte, dass ich p die Symbole mit definierten selbst, nicht Strings, so dass subs sie ersetzen würde.

---

Um tatsächlich die Gleichungen mit SymPy zu erzeugen und wandeln sie in NumPy mit lambdify, Sie so etwas wie

>>> linear_eq_to_matrix([eq_Fx, eq_MB, eq_MA], [Ax, Ay, By]) 
(Matrix([ 
[1, 0, 0], 
[0, -L, 0], 
[0, 0, L]]), Matrix([ 
[    F], 
[-L_1**2*q/2 - M_0], 
[ L_1**2*q/2 - M_0]])) 
>>> C, D = linear_eq_to_matrix([eq_Fx, eq_MB, eq_MA], [Ax, Ay, By]) 
>>> p = {'L': 6, 'L_1': 4, 'L_2': 2, 'q': 2000, 'F': 1000, 'M_0': 4000} 
>>> fC = lambdify([M0, F, q, L, L1, L2], C, 'numpy', dummify=False) 
>>> fC(**p) 
array([[ 1, 0, 0], 
     [ 0, -6, 0], 
     [ 0, 0, 6]]) 
>>> c = fC(**p) 
>>> fD = lambdify([M0, F, q, L, L1, L2], D, 'numpy', dummify=False) 
>>> d = fD(**p) 
>>> import numpy 
>>> np.linalg.solve(c, d) 
array([[ 1000.  ], 
     [ 3333.33333333], 
     [ 2000.  ]]) 

Hier bin ich zu definieren p Strings wieder verwenden können, so dass wir sie nutzen können, als Schlüsselwortargumente zu den lambifizierten Funktionen (andernfalls müssen Sie sie in der Reihenfolge übergeben, wie fC(4000, 1000, 2000, 6, 4, 2)). Das Argument dummify=False ist ebenfalls erforderlich, damit dies funktioniert.

Die Funktion linear_eq_to_matrix wandelt die symbolischen Gleichungen in SymPy-Matrizen um. lambdify können Sie dann diese SymPy-Matrizen mit symbolischen Elementen in numerische NumPy-Arrays konvertieren.

Eine letzte Anmerkung: würden Sie eine Menge Verwirrung für sich vermeiden, wenn Sie bei der Nutzung oder Nichtnutzung von Unterstrichen in Ihrem Symbol und Variablennamen übereinstimmten, zB entweder verwenden

M0 = symbols("M0") 

oder

M_0 = symbols("M_0") 

SymPy wird die 0 als einen Index in jedem Fall drucken.