Nice render (even with latex! :D) And seems to work
This commit is contained in:
lafrite
parent
c25fee2135
commit
31b433faf5
157
expression.py
157
expression.py
@ -3,12 +3,12 @@
|
||||
|
||||
from generic import Stack, flatten_list, expand_list
|
||||
from fraction import Fraction
|
||||
from render import txt_render, post2in_fix, tex_render
|
||||
|
||||
class Expression(object):
|
||||
"""A calculus expression. Today it can andle only expression with numbers later it will be able to manipulate unknown"""
|
||||
|
||||
PRIORITY = {"*" : 3, "/": 3, "+": 2, "-":2, "(": 1}
|
||||
TEXSYM = {"*" : " \\times ", "+" : " + " , "-" : " - "}
|
||||
|
||||
def __init__(self, exp):
|
||||
""" Initiate the expression
|
||||
@ -162,7 +162,7 @@ class Expression(object):
|
||||
return self._infix_tokens
|
||||
|
||||
elif self._postfix_tokens:
|
||||
self._infix_tokens = self.post2in_fix(self._postfix_tokens)
|
||||
self._infix_tokens = post2in_fix(self._postfix_tokens)
|
||||
return self._infix_tokens
|
||||
|
||||
else:
|
||||
@ -192,55 +192,6 @@ class Expression(object):
|
||||
def postfix_tokens(self, val):
|
||||
self._postfix_tokens = val
|
||||
|
||||
# ----------------------
|
||||
# Latex render
|
||||
|
||||
@classmethod
|
||||
def texRender(cls, postfix_tokens):
|
||||
"""@todo: Docstring for texRender
|
||||
|
||||
:param postfix_tokens: the postfix list of tokens to transform into infix form.
|
||||
:returns: the latex render ready to insert into a maht environment
|
||||
|
||||
>>> Expression.post2in_fix([2, 5, '+', 1, '-', 3, 4, '*', '/'])
|
||||
['( ', 2, '+', 5, '-', 1, ' )', '/', '( ', 3, '*', 4, ' )']
|
||||
"\frac{2 + 5 - 1}{3 \times 4)"
|
||||
>>> Expression.post2in_fix([2])
|
||||
"2"
|
||||
"""
|
||||
operandeStack = Stack()
|
||||
|
||||
for token in postfix_tokens:
|
||||
if cls.isOperator(token):
|
||||
op2 = operandeStack.pop()
|
||||
op1 = operandeStack.pop()
|
||||
|
||||
if token == "/":
|
||||
res = "\\frac{" + str(op1) + "}{" + str(op2) + "}"
|
||||
|
||||
else:
|
||||
if cls.needPar(op2, token, "after"):
|
||||
op2 = "\\left( " + str(op2) + " \\right) "
|
||||
|
||||
if cls.needPar(op1, token, "before"):
|
||||
op2 = "\\left( " + str(op1) + " \\right) "
|
||||
res = str(op1) + cls.TEXSYM[token] + str(op2)
|
||||
|
||||
operandeStack.push(res)
|
||||
|
||||
else:
|
||||
operandeStack.push(token)
|
||||
|
||||
# Manip pour gerer les cas similaires au deuxième exemple
|
||||
infix_tokens = operandeStack.pop()
|
||||
if type(infix_tokens) == list:
|
||||
infix_tokens = flatten_list(infix_tokens)
|
||||
elif cls.isNumber(infix_tokens):
|
||||
infix_tokens = [infix_tokens]
|
||||
|
||||
return infix_tokens
|
||||
|
||||
|
||||
# ----------------------
|
||||
# "fix" tranformations
|
||||
|
||||
@ -278,103 +229,6 @@ class Expression(object):
|
||||
|
||||
return postfixList
|
||||
|
||||
@classmethod
|
||||
def post2in_fix(cls, postfix_tokens):
|
||||
""" From the postfix_tokens list compute the corresponding infix_tokens list
|
||||
|
||||
@param postfix_tokens: the postfix list of tokens to transform into infix form.
|
||||
@return: the corresponding infix list of tokens if postfix_tokens.
|
||||
|
||||
>>> Expression.post2in_fix([2, 5, '+', 1, '-', 3, 4, '*', '/'])
|
||||
['( ', 2, '+', 5, '-', 1, ' )', '/', '( ', 3, '*', 4, ' )']
|
||||
>>> Expression.post2in_fix([2])
|
||||
[2]
|
||||
"""
|
||||
operandeStack = Stack()
|
||||
|
||||
for token in postfix_tokens:
|
||||
if cls.isOperator(token):
|
||||
op2 = operandeStack.pop()
|
||||
|
||||
if cls.needPar(op2, token, "after"):
|
||||
op2 = ["( ", op2, " )"]
|
||||
op1 = operandeStack.pop()
|
||||
|
||||
if cls.needPar(op1, token, "before"):
|
||||
op1 = ["( ", op1, " )"]
|
||||
res = [op1, token, op2]
|
||||
|
||||
operandeStack.push(res)
|
||||
|
||||
else:
|
||||
operandeStack.push(token)
|
||||
|
||||
# Manip pour gerer les cas similaires au deuxième exemple
|
||||
infix_tokens = operandeStack.pop()
|
||||
if type(infix_tokens) == list:
|
||||
infix_tokens = flatten_list(infix_tokens)
|
||||
elif cls.isNumber(infix_tokens):
|
||||
infix_tokens = [infix_tokens]
|
||||
|
||||
return infix_tokens
|
||||
|
||||
# ---------------------
|
||||
# Tools for placing parenthesis in infix notation
|
||||
|
||||
@classmethod
|
||||
def needPar(cls, operande, operator, posi = "after"):
|
||||
"""Says whether or not the operande needs parenthesis
|
||||
|
||||
:param operande: the operande
|
||||
:param operator: the operator
|
||||
:param posi: "after"(default) if the operande will be after the operator, "before" othewise
|
||||
:returns: bollean
|
||||
"""
|
||||
if cls.isNumber(operande) and operande < 0:
|
||||
return 1
|
||||
elif not cls.isNumber(operande):
|
||||
# Si c'est une grande expression ou un chiffre négatif
|
||||
stand_alone = cls.get_main_op(operande)
|
||||
# Si la priorité de l'operande est plus faible que celle de l'opérateur
|
||||
minor_priority = cls.PRIORITY[cls.get_main_op(operande)] < cls.PRIORITY[operator]
|
||||
# Si l'opérateur est -/ pour after ou juste / pour before
|
||||
special = (operator in "-/" and posi == "after") or (operator in "/" and posi == "before")
|
||||
|
||||
return stand_alone and (minor_priority or special)
|
||||
else:
|
||||
return 0
|
||||
|
||||
@classmethod
|
||||
def get_main_op(cls, tokens):
|
||||
"""Getting the main operation of the list of tokens
|
||||
|
||||
:param exp: the list of tokens
|
||||
:returns: the main operation (+, -, * or /) or 0 if the expression is only one element
|
||||
|
||||
"""
|
||||
|
||||
print("tokens: ", tokens)
|
||||
|
||||
parStack = Stack()
|
||||
|
||||
if len(tokens) == 1:
|
||||
# Si l'expression n'est qu'un élément
|
||||
return 0
|
||||
|
||||
main_op = []
|
||||
|
||||
for token in tokens:
|
||||
if token == "(":
|
||||
parStack.push(token)
|
||||
elif token == ")":
|
||||
parStack.pop()
|
||||
elif cls.isOperator(token) and parStack.isEmpty():
|
||||
main_op.append(token)
|
||||
|
||||
print("main_op", main_op)
|
||||
|
||||
return min(main_op, key = lambda s: cls.PRIORITY[s])
|
||||
|
||||
## ---------------------
|
||||
## Computing the expression
|
||||
|
||||
@ -423,15 +277,12 @@ class Expression(object):
|
||||
def test(exp):
|
||||
a = Expression(exp)
|
||||
#for i in a.simplify():
|
||||
for i in a.simplify(render = Expression.texRender):
|
||||
#for i in a.simplify(render = txt_render):
|
||||
for i in a.simplify(render = tex_render):
|
||||
print(i)
|
||||
|
||||
print("\n")
|
||||
|
||||
def render(tokens):
|
||||
post_tokens = Expression.post2in_fix(tokens)
|
||||
return ' '.join([str(t) for t in post_tokens])
|
||||
|
||||
if __name__ == '__main__':
|
||||
exp = "1 + 3 * 5"
|
||||
test(exp)
|
||||
|
||||
59
render.py
59
render.py
@ -16,13 +16,14 @@ class Render(object):
|
||||
|
||||
PRIORITY = {"*" : 3, "/": 3, "+": 2, "-":2, "(": 1}
|
||||
|
||||
def __init__(self, op_infix = {}, op_postfix = {}, other = {}, join = " "):
|
||||
def __init__(self, op_infix = {}, op_postfix = {}, other = {}, join = " ", type_render = {int: str, Fraction: str}):
|
||||
"""Initiate the render
|
||||
|
||||
@param op_infix: the dictionnary of infix operator with how they have to be render
|
||||
@param op_postfix: the dictionnary of postfix operator with how they have to be render
|
||||
@param other: other caracters like parenthesis.
|
||||
@param raw: the caracter for joining the list of tokens (if False then it returns the list of tokens)
|
||||
@param type_render: how to render number (str or tex for fractions for example)
|
||||
"""
|
||||
|
||||
self.op_infix = op_infix
|
||||
@ -31,6 +32,7 @@ class Render(object):
|
||||
# TODO: there may be issues with PRIORITY if a sign does not appear in PRIORITY
|
||||
|
||||
self.join = join
|
||||
self.type_render = type_render
|
||||
|
||||
self.operators = list(self.op_infix.keys()) + list(self.op_postfix.keys()) + list(self.other.keys())
|
||||
|
||||
@ -46,16 +48,15 @@ class Render(object):
|
||||
|
||||
for token in postfix_tokens:
|
||||
if self.isOperator(token):
|
||||
|
||||
op2 = operandeStack.pop()
|
||||
|
||||
if self.needPar(op2, token, "after"):
|
||||
op2 = [self.other["("] , op2 , self.other[")"]]
|
||||
|
||||
op1 = operandeStack.pop()
|
||||
|
||||
if self.needPar(op1, token, "before"):
|
||||
op1 = [self.other["("] , op1 , self.other[")"]]
|
||||
|
||||
|
||||
if token in self.op_infix:
|
||||
res = flist([op1 , self.op_infix[token] , op2])
|
||||
|
||||
@ -70,7 +71,7 @@ class Render(object):
|
||||
else:
|
||||
operandeStack.push(token)
|
||||
|
||||
# Manip pour gerer les cas similaires au deuxième exemple
|
||||
# Manip pour gerer les cas de listes imbriquées dans d'autres listes
|
||||
infix_tokens = operandeStack.pop()
|
||||
if type(infix_tokens) == list or type(infix_tokens) == flist:
|
||||
infix_tokens = flatten_list(infix_tokens)
|
||||
@ -78,10 +79,23 @@ class Render(object):
|
||||
infix_tokens = [infix_tokens]
|
||||
|
||||
if self.join:
|
||||
return self.join.join([str(t) for t in infix_tokens])
|
||||
return self.join.join(flatten_list([self.render_from_type(t) for t in infix_tokens]))
|
||||
else:
|
||||
return infix_tokens
|
||||
|
||||
def render_from_type(self, op):
|
||||
""" If the op is a number, it transforms it with type_render conditions
|
||||
|
||||
:param op: the operator
|
||||
:returns: the op transformed if it's necessary
|
||||
|
||||
"""
|
||||
if self.isNumber(op):
|
||||
return self.type_render[type(op)](op)
|
||||
else:
|
||||
return op
|
||||
|
||||
|
||||
# ---------------------
|
||||
# Tools for placing parenthesis in infix notation
|
||||
|
||||
@ -137,7 +151,8 @@ class Render(object):
|
||||
## ---------------------
|
||||
## Recognize numbers and operators
|
||||
|
||||
def isNumber(self, exp):
|
||||
@staticmethod
|
||||
def isNumber( exp):
|
||||
"""Check if the expression can be a number which means that it is not a operator
|
||||
|
||||
:param exp: an expression
|
||||
@ -167,32 +182,36 @@ txt_infix = {"+": "+", "-": "-", "*": "*", "/" : "/"}
|
||||
txt_postfix = {}
|
||||
txt_other = {"(": "(", ")": ")"}
|
||||
|
||||
txt = Render(txt_infix, txt_postfix, txt_other)
|
||||
txt_render = Render(txt_infix, txt_postfix, txt_other)
|
||||
|
||||
# ------------------------
|
||||
# A infix to postfix list convertor
|
||||
|
||||
i2p_infix = {"+": "+", "-": "-", "*": "*", "/" : "/"}
|
||||
i2p_postfix = {}
|
||||
i2p_other = {"(": "(", ")": ")"}
|
||||
p2i_infix = {"+": "+", "-": "-", "*": "*", "/" : "/"}
|
||||
p2i_postfix = {}
|
||||
p2i_other = {"(": "(", ")": ")"}
|
||||
|
||||
in2post_fix = Render(i2p_infix, i2p_postfix, i2p_other, join = False)
|
||||
post2in_fix = Render(p2i_infix, p2i_postfix, p2i_other, join = False)
|
||||
|
||||
# ------------------------
|
||||
# A latex render
|
||||
|
||||
def texFrac(op1, op2):
|
||||
if op1[0] == "(" and op1[-1] == ")":
|
||||
def texSlash(op1, op2):
|
||||
if not Render.isNumber(op1) and op1[0] == "(" and op1[-1] == ")":
|
||||
op1 = op1[1:-1]
|
||||
if op2[0] == "(" and op2[-1] == ")":
|
||||
if not Render.isNumber(op2) and op2[0] == "(" and op2[-1] == ")":
|
||||
op2 = op2[1:-1]
|
||||
return ["\\frac{" , op1 , "}{" , op2 , "}"]
|
||||
|
||||
tex_infix = {"+": " + ", "-": " - ", "*": " * "}
|
||||
tex_postfix = {"/": texFrac}
|
||||
tex_other = {"(": "(", ")": ")"}
|
||||
def texFrac(frac):
|
||||
return ["\\frac{" , str(frac._num) , "}{" , str(frac._denom) , "}"]
|
||||
|
||||
tex = Render(tex_infix, tex_postfix, tex_other)
|
||||
tex_infix = {"+": " + ", "-": " - ", "*": " * "}
|
||||
tex_postfix = {"/": texSlash}
|
||||
tex_other = {"(": "(", ")": ")"}
|
||||
tex_type_render = {int: str, Fraction: texFrac}
|
||||
|
||||
tex_render = Render(tex_infix, tex_postfix, tex_other, type_render = tex_type_render)
|
||||
|
||||
|
||||
|
||||
@ -202,7 +221,7 @@ if __name__ == '__main__':
|
||||
exp = [2, 5, '+', 1, '-', 3, 4, '*', '/', 3, '+']
|
||||
print(tex(exp))
|
||||
exp = [2, 5, '+', 1, '-', 3, 4, '*', '/', 3, '+']
|
||||
print(in2post_fix(exp))
|
||||
print(post2in_fix(exp))
|
||||
|
||||
|
||||
# -----------------------------
|
||||
|
||||
Loading…
Reference in New Issue
Block a user