Von Matlab zu Python - Lösen Sie Funktion

Question

Ich machte eine Matlab-Funktion und ich möchte es in Python konvertieren, um mit meiner Webanwendung zu verwenden.

Ich konvertierte (.m-Datei in .py-Datei) fast alles mit OMPC. Allerdings kann ich die solve() Funktion nicht funktionieren lassen (ich verwende die Sympy-Bibliothek).

Dies ist die Matlab Linie:

SBC = solve(sqrt((xa-x)^(2)+(ya-y)^(2))-sqrt((xb-x)^(2)+(yb-y)^(2))-D12==0,sqrt((xa-x)^(2)+(ya-y)^(2))-sqrt((xc-x)^(2)+(yc-y)^(2))-D13==0,[x,y]); 

Und dies ist die Python Linie, wo x und y Symbole (mit x = Symbol('x') und y = Symbol('y')):

sbc = solve(
      sqrt((xa - x) ** (2) + (ya - y) ** (2)) 
      - sqrt((xb - x) ** (2) + (yb - y) ** (2)) 
      - D12 == 0, 
      sqrt((xa - x) ** (2) + (ya - y) ** (2)) 
      - sqrt((xc - x) ** (2) + (yc - y) ** (2)) 
      - D13 == 0, 
      [x, y] 
     ) 

Mit diesem Python-Code, ich bin bekommen False anstelle eines Ergebnisses (es funktioniert gut mit dem Matlab-Code).

Fehle ich etwas?

EDIT:

Und mit diesem, ich bin immer []:

# -*- coding: utf-8 -*- 

from sympy import * 

def alg(xa=None, ya=None, za=None, Ta=None, xb=None, yb=None, zb=None, Tb=None, xc=None, yc=None, zc=None, Tc=None, xd=None, yd=None, zd=None, Td=None, RSSIA=None, RSSIB=None, RSSIC=None, RSSID=None, txPower=None, n=None): 
    n = 2 
    c = 3 * 10 ** 8 
    TOA12 = Ta - Tb 
    TOA13 = Ta - Tc 
    TOA14 = Ta - Td 

    D12 = TOA12 * c 
    D13 = TOA13 * c 
    D14 = TOA14 * c 
    x, y = symbols('x y') 

    eqs = [sqrt((xa - x) ** (2) + (ya - y) ** (2)) - sqrt((xb - x) ** (2) + (yb - y) ** (2)) - D12, 
    sqrt((xa - x) ** (2) + (ya - y) ** (2)) - sqrt((xc - x) ** (2) + (yc - y) ** (2)) - D13] 

    print solve(eqs, [x, y]) 

alg(3,1,0,21.8898790015,4,6,0,21.8898790005,10,4,0,21.88987900009,9,0.5,0,21.889879000105,23.9,23.85,23.9,23.95,24,1) 

Answer 1

Es gibt nur eine kleine Änderung erforderlich, um es zu arbeiten. Der Grund, warum Sie False erhalten, ist, dass Sie die == 0 in Ihrer Funktionsdefinition verwenden. In der Regel wird angenommen, dass Ihre Funktionen 0 sind. Geben genommen ein Beispiel aus here:

Wenn Sie die Gleichungen lösen wollen x+5y=2, -3x+6y=15 dann würden Sie es tun, wie folgt:

from sympy import * 
x, y = symbols('x y') 
solve([x + 5*y - 2, -3*x + 6*y - 15], [x, y]) 

, die Sie

{x: -3, y: 1} 

Hinweis gibt, dass die Gleichungen in einer Weise übergeben, die sie zu 0 bewerten.

Wenn Sie führen Sie es wie Sie

tat

solve([x + 5*y - 2 == 0, -3*x + 6*y - 15 == 0], [x, y]) 

dann auch False zurückgegeben.

Also für Ihr Beispiel folgenden funktionieren würde:

from sympy import * 

x, y, xa, xb, xc, ya, yb, yc, D12, D13 = symbols('x y xa xb xc ya yb yc D12 D13') 

eqs = [sqrt((xa - x) ** (2) + (ya - y) ** (2)) - sqrt((xb - x) ** (2) + (yb - y) ** (2)) - D12, 
     sqrt((xa - x) ** (2) + (ya - y) ** (2)) - sqrt((xc - x) ** (2) + (yc - y) ** (2)) - D13] 

solve(eqs, [x, y]) 

Leider, das nicht auf meinem privaten Computer läuft durch (mein Python bekommt killed, anscheinend so schwer zu lösen ist), damit ich es gerade getestet

eqs2 = [sqrt(xa - x) - D12, 
     (yc - y) ** (2) - D13] 
solve(eqs2, [x, y]) 

, die gibt Ihnen dann die erwartete Ausgabe:

[(-D12**2 + xa, -sqrt(D13) + yc), (-D12**2 + xa, sqrt(D13) + yc)] 

für eine einfachere Version, das Prinzip zu demonstrieren

Ich hoffe, Sie haben mehr Glück auf Ihrer Maschine, um diese komplizierten Funktionen zu lösen. Aber dieser Beitrag erklärt, warum Sie die False erhalten.

EDIT

Mit Ihrer modifizierten Code, können Sie eine Lösung erhalten, wenn Sie die Genauigkeit Ihrer Parameter D12 und D13 verringern. Hier ist die Lösung, die Sie dann erhalten:

[sqrt((-x + 3)**2 + (-y + 1)**2) - sqrt((-x + 4)**2 + (-y + 6)**2) - 0.3, sqrt((-x + 3)**2 + (-y + 1)**2) - sqrt((-x + 10)**2 + (-y + 4)**2) - 0.42] 
[{x: 6.45543078993649, y: 3.14390310591109}, {x: 6.67962865117349, y: 2.61399193301427}] 

Sind das die gleichen, die Sie für die Matlab-Simulationen erhalten?

Hier ist der modifizierte Code; Bitte beachten Sie, dass ich die Ausgabe erzwingen, in Form eines Lexikons zu sein und drucken auch die Gleichungen (I Runde auf zwei Dezimalstellen, aber es funktioniert auch mit 4; du damit spielen können):

from sympy import * 

def alg(xa=None, ya=None, za=None, Ta=None, xb=None, yb=None, zb=None, Tb=None, xc=None, yc=None, zc=None, Tc=None, xd=None, yd=None, zd=None, Td=None, RSSIA=None, RSSIB=None, RSSIC=None, RSSID=None, txPower=None, n=None): 
    n = 2 
    c = 3 * 10 ** 8 
    TOA12 = Ta - Tb 
    TOA13 = Ta - Tc 
    TOA14 = Ta - Td 

    D12 = round(TOA12 * c, 2) 
    D13 = round(TOA13 * c, 2) 
    # D14 = TOA14 * c 
    # x, y, D12, D13 = symbols('x y D12 D13') 
    x, y = symbols('x y') 

    eqs = [sqrt((xa - x) ** (2) + (ya - y) ** (2)) - sqrt((xb - x) ** (2) + (yb - y) ** (2)) - D12, 
    sqrt((xa - x) ** (2) + (ya - y) ** (2)) - sqrt((xc - x) ** (2) + (yc - y) ** (2)) - D13] 

    print eqs 

    print solve(eqs, x, y, dict=True) 

alg(3,1,0,21.8898790015,4,6,0,21.8898790005,10,4,0,21.88987900009,9,0.5,0,21.889879000105,23.9,23.85,23.9,23.95,24,1)