From 9b731b668750550d9ae56db274700ba7de6dd088 Mon Sep 17 00:00:00 2001 From: lafrite Date: Mon, 9 Dec 2013 09:21:54 +0100 Subject: [PATCH] Cleaning --- expression.py.back | 115 --------------------------- expression.py_back | 191 --------------------------------------------- 2 files changed, 306 deletions(-) delete mode 100644 expression.py.back delete mode 100644 expression.py_back diff --git a/expression.py.back b/expression.py.back deleted file mode 100644 index 75c3e4e..0000000 --- a/expression.py.back +++ /dev/null @@ -1,115 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 - -from generic import Stack -from calculus import isNumber, doMath - - -class Expression(object): - """An arithmetic expression""" - - priority = {"*" : 3, "/": 3, "+": 2, "-":2, "(": 1} - - def __init__(self, exp, fix = "infix"): - """Initiate the expression. - - :param exp: the string representing the expression (infx form by default) - :param fix: form of the expression infix (default) - postfix - prefix - - """ - if fix == "infix": - self._exp_infix = exp - self._token_infix = exp.split(" ") - elif fix == "postfix": - self._token_postfix = exp - else: - print("Pas encore fait!") - - def infixToPostfix(self): - """Convert the infix expression into postfix expression. - """ - #@todo importer les exemples - opStack = Stack() - postfixList = [] - - for token in self._token_infix: - if token == "(": - opStack.push(token) - elif token == ")": - topToken = opStack.pop() - while topToken != "(": - postfixList.append(topToken) - topToken = opStack.pop() - elif token in "+-*/": - while (not opStack.isEmpty()) and (self.priority[opStack.peek()] >= self.priority[token]): - postfixList.append(opStack.pop()) - opStack.push(token) - else: - postfixList.append(token) - - while not opStack.isEmpty(): - postfixList.append(opStack.pop()) - - self._token_postfix = postfixList - self._exp_postfix = " ".join(postfixList) - - def computePostfix(self): - """Compute a postfix expression like a good student - - :returns: list of steps to reach the result (postfix form) - - """ - tokenList = self._token_postfix.copy() - tmpTokenList = [] - # on va chercher les motifs du genre A B + pour les calculer - while len(tokenList) > 2: - #print(tokenList[2]) - if isNumber(tokenList[0]) and isNumber(tokenList[1]) and tokenList[2] in "+-*/": - # S'il y a une opération à faire - op1 = tokenList[0] - op2 = tokenList[1] - token = tokenList[2] - res = doMath(token, op1, op2) - - tmpTokenList.append(res) - - # Comme on vient de faire le calcul, on peut détruire aussi les deux prochains termes - del tokenList[0:3] - else: - tmpTokenList.append(tokenList[0]) - - del tokenList[0] - tmpTokenList += tokenList - - if len(tmpTokenList) > 1: - next_steps = Expression(tmpTokenList, fix = "postfix").computePostfix() - else: - next_steps = tmpTokenList - print(self._exp_postfix) - return [self._exp_postfix] + next_steps - - -def test(exp): - """Make various test on an expression - - """ - print("-------------") - print("Expression ",exp) - expression = Expression(exp) - expression.infixToPostfix() - print(expression.computePostfix()) - -if __name__ == '__main__': - exp = "1 + 3 * 5" - test(exp) - - exp = "2 * 3 * 3 * 5" - test(exp) - - exp = "2 * 3 + 3 * 5" - test(exp) - -# ----------------------------- -# Reglages pour 'vim' -# vim:set autoindent expandtab tabstop=4 shiftwidth=4: -# cursor: 16 del diff --git a/expression.py_back b/expression.py_back deleted file mode 100644 index a4d4ee0..0000000 --- a/expression.py_back +++ /dev/null @@ -1,191 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 - - -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} - - def __init__(self, exp): - """ Initiate the expression. - - :param exp: the expression. It can be a string or a list of tokens. It can be infix or postfix expression - """ - self._tokens = {} - self._strings = {} - if type(exp) == list: - fix = self.get_fix(exp) - self._tokens[fix] = exp - elif type(exp) == str: - tokens = self.parseExp(exp) - fix = self.get_fix(tokens) - self._tokens[fix] = tokens - self._strings[fix] = exp - else: - raise ValueError("The expression needs to be a string or a list of token") - - # --------------------- - # String parsing - - # @classmethod ???? - def parseExp(self, exp): - """ Parse the expression, ie tranform a string into a list of tokens - - :param exp: The expression (a string) - :returns: list of token - - """ - return exp.split(" ") - - # --------------------- - # "fix" recognition - - def get_fix(self, tokens): - """ Give the "fix" of an expression - infix -> A + B - prefix -> + A B - postfix -> A B + - - :param exp: the expression (list of token) - :returns: the "fix" (infix, postfix, prefix) - - """ - if tokens[0] in "+-*/": - return "prefix" - elif token[0] not in "+-*/" ans token[1] not in "+-*/": - return "postfix" - else: - return "infix" - - # ---------------------- - # Expressions - tokens getters - - def tokens(self, fix = "infix"): - """Get the list of tokens with the wanted fix - - :param fix: the fix wanted (infix default) - :returns: list of tokens - - """ - # Si ce fix n'a pas encore été enregistré - if fix not in self._tokens: - # Il peut venir de la version string - if fix in self._string: - self._tokens[fix] = self.parseExp(self._string[fix]) - # Sinon il faut le calculer à partir d'une autre forme - else: - fix_transfo = "to" + fix.capitalize() - getattr(self,fix_transfo)() - - return self._tokens[fix] - -##### On en est là,il faudra faire attention à bien vérifier ce que les "to..." enregistre (string ou tokens) - - def string(self, fix = "infix"): - """Get the string with the wanted fix - - :param fix: the fix wanted (infix default) - :returns: the string representing the expression - - """ - # Si ce fix n'a pas encore été enregistré - if fix not in self._string: - # Il peut venir de la version string - if fix in self._tokens: - self._string[fix] = self.parseExp(self._string[fix]) - # Sinon il faut le calculer à partir d'une autre forme - else: - fix_transfo = "to" + fix.capitalize() - getattr(self,fix_transfo)() - - return self._string[fix] - - # ---------------------- - # "fix" tranformations - - def toPostfix(self): - """ Transorm the expression into postfix form using the infix form""" - pass - - def toInfix(self): - """ Tranform the expression into infix form using postfix form""" - pass - - # --------------------- - # Tools for placing parenthesis in infix notation - - def needPar(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 isNumber(operande) and "-" in operande: - return 1 - elif not isNumber(operande): - # Si c'est une grande expression ou un chiffre négatif - stand_alone = get_main_op(operande) - # Si la priorité de l'operande est plus faible que celle de l'opérateur - minor_priority = self.priority[get_main_op(operande)] < self.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 - -# J'aime pas bien cette endroit faudrait que ce soit une méthode qui s'applique uniquement à l'expression en question (self) pas à n'importe quel string, ça serait plus propre. - def get_main_op(exp): - """ Gives the main operation of the expression - - :param exp: the expression - :returns: the main operation (+, -, * or /) or 0 if the expression is only one element - - """ - parStack = Stack() - tokenList = exp.split(" ") - - if len(tokenList) == 1: - # Si l'expression n'est qu'un élément - return 0 - - main_op = [] - - for token in tokenList: - if token == "(": - parStack.push(token) - elif token == ")": - parStack.pop() - elif token in "+-*/" and parStack.isEmpty(): - main_op.append(token) - - return min(main_op, key = lambda s: priority[s]) - - # --------------------- - # Computing the expression - - def compute(self): - """ Recursive method for computing as a student the expression - :returns: list of steps needed to reach the result - - """ - pass - - def doMath(op, op1, op2): - """Compute "op1 op op2" - - :param op: operator - :param op1: first operande - :param op2: second operande - :returns: string representing the result - - """ - return str(eval(op1 + op + op2)) - -# ----------------------------- -# Reglages pour 'vim' -# vim:set autoindent expandtab tabstop=4 shiftwidth=4: -# cursor: 16 del