diff --git a/expression.py b/expression.py index 389caa8..2739e87 100644 --- a/expression.py +++ b/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) diff --git a/render.py b/render.py index 5931012..d101b66 100644 --- a/render.py +++ b/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)) # -----------------------------