लेटेक्स गणित अभिव्यक्ति लेटेक्स, वर्बेटिम (कोई रीडरिंग, फैक्टरिंग इत्यादि)

Question

मेरे पास गणित के सभी अभिव्यक्तियों और समीकरणों का इनपुट है, और मैं उन पर प्रत्येक के लिए लेटेक्स प्रस्तुति प्रिंट करना चाहता हूं। अब तक मैंने ऋषि और सिम्पी की कोशिश की है, लेकिन मुश्किल हिस्सा अभिव्यक्तियों में शर्तों को दोबारा नहीं करना है।

तो, अगर मेरी इनपुट इस, कुछ है कि अजगर में eval एड किया जा सकता है:

(C - A*x)/B 

मैं उत्पादन जो कुछ इस तरह हो जाएगा चाहते हैं:

\frac{C - A x}{B} 

क्या मैं डॉन टी इस तरह कुछ चाहिए:

\frac{-(A x - C)}{B} 
\frac{1}{B}(C - A x) 
etc... 

क्या यह हासिल किया जा सकता है? मैं धीरे धीरे आशा खो रहा हूँ ...

---

संपादित करें:

इनपुट भाव, विविध रहे हैं कुछ वर्ग जड़ों से युक्त, नेस्टेड कोष्ठक, घातांक आदि एक सामान्य समाधान के लिए देख रहे हैं।

यहाँ अब तक काम नहीं करता क्या है:

1) ऋषि:

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

\ आप प्रतीक और ऑपरेटर बनाकर ऐसा कर सकते हैं कक्षाएं जो मानक पायथन डेटा मॉडल (http://docs.python.org/2/reference/datamodel.html) को लागू करती हैं। यह अजगर ऑपरेटर वरीयता का उसी क्रम में बातें रखेंगे हालांकि आप कोष्ठक के माध्यम से पुन: व्यवस्थित कर सकते हैं:

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') 

फिर

:

>>> 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

अपनी खुद की पार्सर लिखने के लघु, मैं करने के लिए केवल असली तरीका मानना ​​है कि ऐसा करने के लिए python's built-in compile() function का उपयोग करें और लौटा सार वाक्यविन्यास पेड़ को संसाधित करें।