Konvertierung von python-numeric-expression in LaTeX

Brauche ich zum konvertieren von Zeichenfolgen, die gültige python-syntax, wie:

'1+2**(x+y)'

und das äquivalent LaTeX:

$1+2^{x+y}$

Habe ich versucht sympy die latex-Funktion, aber es Prozesse, die eigentliche Ausdruck ist, eher als die string-form:

>>> latex(1+2**(x+y))
'$1 + 2^{x + y}$'
>>> latex('1+2**(x+y)')
'$1+2**(x+y)$'

aber auch hierzu benötigt es x und y werden deklariert als Typ "Symbole".

Möchte ich mich etwas mehr straight forward, vorzugsweise machbar mit dem parser aus der compiler-Modul.

>>> compiler.parse('1+2**(x+y)')
Module(None, Stmt([Discard(Add((Const(1), Power((Const(2), Add((Name('x'), Name('y'))))))))]))

Last but not least, warum: ich brauche zu erzeugen, die latex-Schnipsel, so dass ich zeigen kann, die Sie in einer Webseite mit mathjax.

Eine wichtige Unterscheidung ist, dass Sie analysieren, diese Ausdrücke nicht zu bewerten, sondern zu tun, Dokument-layout mit Ihnen. Es ist zu sagen, dass Sie wusste, zu ersetzen, die Klammern um x+y mit Klammern, aber es gibt sicher andere Orte, wo die Klammern würde bewahrt werden müssen. Ich denke, du gehst zu haben, um einige Gründliche Gedanken darüber, was Sie versuchen, zu analysieren, und was sollte es Aussehen, wenn Sie fertig sind. Dann können Sie beginnen, überlegen, wie eine solche Veränderung erreicht werden könnte gegeben, einen passenden parser. Dies wird Ihnen auch helfen zu formulieren, was der parser benötigen, zu tun.

InformationsquelleAutor fccoelho | 2010-10-05

17

Können Sie sympy.latex mit eval:
```
s = "1+2**(x+y)"
sympy.latex(eval(s))   # prints '$1 + {2}^{x + y}$'
```
Haben Sie immer noch deklarieren Sie die Variablen als Symbole, aber wenn das ist wirklich ein problem, es ist viel einfacher zu schreiben, einen parser, um dies zu tun, als alles analysieren und generieren, die latex von Grund auf.
- Dank Tom10. Einfach, aber elegant. Meine ursprüngliche Implementierung ging so etwas wie dieses: s = "1+2**(x+y)" eval('sympy.latex(%s)'%s) nach dem einschalten werden die Variablen in ersten Symbole.
InformationsquelleAutor tom10

Hier ist eine ziemlich lange, aber trotzdem unvollständige Methode, die nicht die sympy in keiner Weise. Es ist genug, um das Beispiel von (-b-sqrt(b**2-4*a*c))/(2*a) die übersetzt wird, zu \frac{ - b - \sqrt{b^{2} - 4 \; a \; c}}{2 \; a} und macht so

Konvertierung von python-numeric-expression in LaTeX

Es schafft im Grunde die AST und Spaziergänge, die Herstellung der latex-Mathematik-das entspricht der AST-Knoten. Was sollte es geben genug von einer Idee, wie Sie erweitern es in den Orten, es fehlt.


import ast

class LatexVisitor(ast.NodeVisitor):

    def prec(self, n):
        return getattr(self, 'prec_'+n.__class__.__name__, getattr(self, 'generic_prec'))(n)

    def visit_Call(self, n):
        func = self.visit(n.func)
        args = ', '.join(map(self.visit, n.args))
        if func == 'sqrt':
            return '\sqrt{%s}' % args
        else:
            return r'\operatorname{%s}\left(%s\right)' % (func, args)

    def prec_Call(self, n):
        return 1000

    def visit_Name(self, n):
        return n.id

    def prec_Name(self, n):
        return 1000

    def visit_UnaryOp(self, n):
        if self.prec(n.op) > self.prec(n.operand):
            return r'%s \left(%s\right)' % (self.visit(n.op), self.visit(n.operand))
        else:
            return r'%s %s' % (self.visit(n.op), self.visit(n.operand))

    def prec_UnaryOp(self, n):
        return self.prec(n.op)

    def visit_BinOp(self, n):
        if self.prec(n.op) > self.prec(n.left):
            left = r'\left(%s\right)' % self.visit(n.left)
        else:
            left = self.visit(n.left)
        if self.prec(n.op) > self.prec(n.right):
            right = r'\left(%s\right)' % self.visit(n.right)
        else:
            right = self.visit(n.right)
        if isinstance(n.op, ast.Div):
            return r'\frac{%s}{%s}' % (self.visit(n.left), self.visit(n.right))
        elif isinstance(n.op, ast.FloorDiv):
            return r'\left\lfloor\frac{%s}{%s}\right\rfloor' % (self.visit(n.left), self.visit(n.right))
        elif isinstance(n.op, ast.Pow):
            return r'%s^{%s}' % (left, self.visit(n.right))
        else:
            return r'%s %s %s' % (left, self.visit(n.op), right)

    def prec_BinOp(self, n):
        return self.prec(n.op)

    def visit_Sub(self, n):
        return '-'

    def prec_Sub(self, n):
        return 300

    def visit_Add(self, n):
        return '+'

    def prec_Add(self, n):
        return 300

    def visit_Mult(self, n):
        return '\\;'

    def prec_Mult(self, n):
        return 400

    def visit_Mod(self, n):
        return '\\bmod'

    def prec_Mod(self, n):
        return 500

    def prec_Pow(self, n):
        return 700

    def prec_Div(self, n):
        return 400

    def prec_FloorDiv(self, n):
        return 400

    def visit_LShift(self, n):
        return '\\operatorname{shiftLeft}'

    def visit_RShift(self, n):
        return '\\operatorname{shiftRight}'

    def visit_BitOr(self, n):
        return '\\operatorname{or}'

    def visit_BitXor(self, n):
        return '\\operatorname{xor}'

    def visit_BitAnd(self, n):
        return '\\operatorname{and}'

    def visit_Invert(self, n):
        return '\\operatorname{invert}'

    def prec_Invert(self, n):
        return 800

    def visit_Not(self, n):
        return '\\neg'

    def prec_Not(self, n):
        return 800

    def visit_UAdd(self, n):
        return '+'

    def prec_UAdd(self, n):
        return 800

    def visit_USub(self, n):
        return '-'

    def prec_USub(self, n):
        return 800
    def visit_Num(self, n):
        return str(n.n)

    def prec_Num(self, n):
        return 1000

    def generic_visit(self, n):
        if isinstance(n, ast.AST):
            return r'' % (n.__class__.__name__, ', '.join(map(self.visit, [getattr(n, f) for f in n._fields])))
        else:
            return str(n)

    def generic_prec(self, n):
        return 0

def py2tex(expr):
    pt = ast.parse(expr)
    return LatexVisitor().visit(pt.body[0].value)

Wow!!! dies ist ziemlich erstaunlich! Danke Geoff! Habe es noch nicht getestet, aber es sollte ein ziemlich nützliches Stück code, wenn es getestet wird gegen eine breitere Vielzahl von Beispielen.
Beachten Sie, dass die \operatorname Befehl benutzt für Funktionsaufrufe erfordert amsmath. Für mathjax müssen Sie die entsprechende Erweiterung pro mathjax.org/resources/docs/?tex.html#amsmath-and-amssymbol
Danke. Es gibt ein problem mit minus ej: "3-(1+2)" -> 3 - 1 + 2. Insert - > elif self.prec(n.op) == self.prec(n.rechts) und isinstance(n.op, ast.Sub): > rechts = r'\left(%s\right)' % self.Besuch(n.rechts) in der zweiten, wenn innerhalb visit_BinOp()
Es ist jetzt eine Bibliothek basierend auf diese Antwort: pypi.python.org/pypi/pytexit.

InformationsquelleAutor Geoff Reedy

10

Können Sie SymPy. Übergeben Sie die Zeichenfolge an die sympify() zuerst die Funktion, die konvertiert es in ein gültiges SymPy-Ausdruck (d.h., erstellen Sie die Symbole für Sie, etc.). Also könnte man tun,
```
>>> latex(sympify('1+2**(x+y)'))
1 + 2^{x + y}
```
S() ist auch eine Verknüpfung zu sympify(), d.h., latex(S('1+2**(x+y)')) auch funktioniert.

InformationsquelleAutor asmeurer
4

Nur eine kleine Korrektur zu Geoff Reedy ausgezeichnete Antwort:
```
class GenerateSymbols(defaultdict):
    def __missing__(self, key):
        self[key] = sympy.Symbol(key)
        return self[key]
```
Bevor es würde nicht fügen Sie das neue Element an das dict. Jetzt können Sie diese mit Ihrem Ausdruck:
```
d= GenerateSymbols()    
eq = '(-b-sqrt(b**2-4*a*c))/(2*a)'
```
und Sie können noch weiter zu vereinfachen, bevor Sie es konvertieren zu LaTeX:
```
sympy.latex(sympy.simplify(eval(eq,d)))
```
erhalten Sie dies:
```
'$- \\frac{b + \\operatorname{sqrt}\\left(- 4 a c + b^{2}\\right)}{2 a}$'
```
- Falls jemand eine Lösung hat, die nicht mit sympy, bitte posten! Ich nicht wollen, haben zu ziehen sympy auf meiner app nur für diese kleine Aufgabe! (Aber ich mus zugeben, dass die Art und Weise besser, dass dabei in Abhängigkeit von Salbei, einige andere CAS-Giganten)
InformationsquelleAutor fccoelho
3

Bauen auf tom10 die Antwort, die Sie definieren können, ein Wörterbuch, das generieren von Symbolen und verwenden Sie, dass beim Aufruf von eval:
```
from collections import defaultdict
class GenerateSymbols(defaultdict):
  def __missing__(self, key):
    return sympy.Symbol(key)
```
Dann, wenn Sie
```
sympy.latex(eval('1+2**(x+y)',GenerateSymbols()))
```
sollten Sie nicht haben, um sorgen über pre-erstellen von Symbolen für die Variablen.
- Danke Geoff, Genial! siehe meinen untenstehenden Anweisungen.
InformationsquelleAutor Geoff Reedy

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.