Python mathematische Ausdrücke zu Latex, wörtlich (keine Umordnung, Factoring, etc.)

Question

Ich habe eine ganze Reihe von mathematischen Ausdrücke und Gleichungen eingegeben, und ich würde gerne Latex-Darstellung für jeden auf ihnen ausdrucken. Bisher habe ich Sage und Sympathie versucht, aber der schwierige Teil besteht darin, Begriffe in Ausdrücken nicht neu zu ordnen.

Also, wenn meine Eingabe ist dies etwas, das eval -ed in Python sein kann:

(C - A*x)/B 

ich ausgeben wollen, dass so etwas wie dies sein wird:

\frac{C - A x}{B} 

Was ich don 't wollen ist etwas in der Art:

Kann dies erreicht werden? Ich verliere langsam die Hoffnung ...

---

EDIT:

Der Eingang Ausdrücke sind vielfältig, einige Verbindungen mit Quadratwurzeln, verschachtelte Klammern, Exponenten usw. für eine generische Lösung.

Hier ist, was bisher nicht funktioniert:

1) Sage:

sage: var('A B C x y') 
(A, B, C, x, y) 
sage: latex(y == (C - A*x)/B) 
y = -\frac{A x - C}{B} 

2) sympy:

>>> from sympy import * 
>>> x = Symbol('x') 
>>> A = Symbol('A') 
>>> B = Symbol('B') 
>>> C = Symbol('C') 
>>> latex((C - A*x)/B) 
'\\frac{1}{B} \\left(- A x + C\\right)' 

Answer 1

\ Sie können dies tun, indem Symbol und Operator Klassen, die das Standard-Python-Datenmodell implementieren(). Dies hält die Dinge in der gleichen Reihenfolge von Python Operator Vorrang, obwohl Sie über Pars neu anordnen können:

class Symbol(object): 
    def __init__(self, name): 
     self._name = name 

    def __str__(self): 
     return str(self._name) 

    def __div__(self, other): 
     return Div(self, other) 

    def __mul__(self, other): 
     return Mult(self, other) 

    def __add__(self, other): 
     return Add(self, other) 

    def __sub__(self, other): 
     return Sub(self, other) 

    def __rdiv__(self, other): 
     return Div(other, self) 

    def __rmul__(self, other): 
     return Mult(other, self) 

    def __radd__(self, other): 
     return Add(other, self) 

    def __rsub__(self, other): 
     return Sub(other, self) 

class Operation(Symbol): 
    def __init__(self, a, b, op): 
     self._a = a 
     self._b = b 
     self._op = op 

    def __str__(self): 
     return self._op.format(self._a, self._b) 

class Add(Operation): 
    precedence = 0 

    def __init__(self, a, b): 
     super(Add, self).__init__(a, b, "{0} + {1}") 

class Sub(Operation): 
    precedence = 0 
    def __init__(self, a, b): 
     super(Sub, self).__init__(a, b, "{0} - {1}") 

class Mult(Operation): 
    precedence = 1 
    def __init__(self, a, b): 
     if isinstance(a, Operation) and a.precedence < Mult.precedence: 
      a_form = "({0})" 
     else: 
      a_form = "{0}" 
     if isinstance(b, Operation) and b.precedence < Mult.precedence: 
      b_form = "({1})" 
     else: 
      b_form = "{1}" 
     super(Mult, self).__init__(a, b, a_form + " " + b_form) 

class Div(Operation): 
    precedence = 1 
    def __init__(self, a, b): 
     super(Div, self).__init__(a, b, "\\frac{{{0}}}{{{1}}}") 


A = Symbol('A') 
B = Symbol('B') 
C = Symbol('C') 
x = Symbol('x') 

Dann:

>>> print (C - A * x)/(B) 
\frac{C - A x}{B} 
>>> print (C * (A + B)) 
C (A + B) 
>>> print (C * (A + B + A + B + C + x)) 
C (A + B + A + B + C + x) 

Answer 2

Kurz der eigenen Parser zu schreiben, ich glaube, die einzige wirkliche Möglichkeit zu Tun Sie dies, um python's built-in compile() function zu verwenden und den zurückgegebenen abstrakten Syntaxbaum zu verarbeiten.