From 1935a4471504ba004502cde8cb8848942db48957 Mon Sep 17 00:00:00 2001 From: lafrite Date: Wed, 15 Jan 2014 17:04:24 +0100 Subject: [PATCH] clean directory --- calculus.py | 409 --------------------------------------------- expression.py.back | 115 ------------- expression.py_back | 191 --------------------- 3 files changed, 715 deletions(-) delete mode 100644 calculus.py delete mode 100644 expression.py.back delete mode 100644 expression.py_back diff --git a/calculus.py b/calculus.py deleted file mode 100644 index 19d2fcc..0000000 --- a/calculus.py +++ /dev/null @@ -1,409 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 - - -from generic import Stack -from fraction import Fraction - -def str2tokens(exp): - """Convert an expression into a list of tokens - - :param exp: The expression - :returns: the list of tokens - - >>> str2tokens("1 + 2") - [1, '+', 2] - - """ - tokens = exp.split(" ") - - for (i,t) in enumerate(tokens): - try: - tokens[i] = int(t) - except ValueError: - pass - - return tokens - -def infixToPostfix(infixTokens): - """Transform an infix list of tokens into postfix tokens - - :param infixTokens: an infix list of tokens - :returns: the corresponding postfix list of tokens - - :Example: - - >>> infixToPostfix([1, "+", 2]) - [1, 2, '+'] - - >>> infixToPostfix([1, "*", 2, "+", 3]) - [1, 2, '*', 3, '+'] - """ - - priority = {"*" : 3, "/": 3, "+": 2, "-":2, "(": 1} - - opStack = Stack() - postfixList = [] - - #infixTokens = infixExp.split(" ") - - for token in infixTokens: - if token == "(": - opStack.push(token) - elif token == ")": - topToken = opStack.pop() - while topToken != "(": - postfixList.append(topToken) - topToken = opStack.pop() - elif isOperation(token): - # On doit ajouter la condition == str sinon python ne veut pas tester l'appartenance à la chaine de caractère. - while (not opStack.isEmpty()) and (priority[opStack.peek()] >= priority[token]): - postfixList.append(opStack.pop()) - opStack.push(token) - else: - postfixList.append(token) - - while not opStack.isEmpty(): - postfixList.append(opStack.pop()) - - return postfixList - -def computePostfix(postfixTokens): - """Compute a postfix list of tokens - - :param postfixTokens: a postfix list of tokens - :returns: the result of the calculus - - """ - #print(postfixToInfix(postfixExp)) - # where to save numbers or - operandeStack = Stack() - - #tokenList = postfixExp.split(" ") - - for (i,token) in enumerate(postfixTokens): - if isOperation(token): - op2 = operandeStack.pop() - op1 = operandeStack.pop() - res = doMath(token, op1, op2) - operandeStack.push(res) - - #print("Operation: {op1} {op} {op2}".format(op1 = op1, op = token, op2 = op2)) - #print(operandeStack) - #print(postfixTokens[i+1:]) - newPostfix = " ".join(operandeStack + postfixTokens[i+1:]) - #print(postfixToInfix(newPostfix)) - - else: - operandeStack.push(token) - - return operandeStack.pop() - -def computePostfixBis(postfixTokens): - """Compute a postfix list of tokens like a good student - - :param postfixTokens: a postfix list of tokens - :returns: the result of the expression - - """ - # where to save numbers or - operandeStack = Stack() - - #tokenList = postfixExp.split(" ") - tokenList = postfixTokens.copy() - - steps = [] - - steps = [] - - # On fait le calcul jusqu'à n'avoir plus qu'un élément - while len(tokenList) > 1: - tmpTokenList = [] - # on va chercher les motifs du genre A B + pour les calculer - while len(tokenList) > 2: - if isNumber(tokenList[0]) and isNumber(tokenList[1]) and isOperation(tokenList[2]): - # 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 - - steps += expand_list(tmpTokenList) - - tokenList = steps[-1].copy() - - - return steps - -def isNumber(exp): - """Check if the expression can be a number - - :param exp: an expression - :returns: True if the expression can be a number and false otherwise - - """ - return type(exp) == int or type(exp) == Fraction - -def isOperation(exp): - """Check if the expression is an opération in "+-*/" - - :param exp: an expression - :returns: boolean - - """ - return (type(exp) == str and exp in "+-*/") - - -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 - - """ - operations = {"+": "__add__", "-": "__sub__", "*": "__mul__"} - if op == "/": - ans = [Fraction(op1, op2)] - ans += ans[0].simplify() - return ans - else: - return getattr(op1,operations[op])(op2) - - - -def postfixToInfix(postfixTokens): - """Transforms postfix list of tokens into infix string - - :param postfixTokens: a postfix list of tokens - :returns: the corresponding infix string - - """ - operandeStack = Stack() - - #print(postfixTokens) - - #tokenList = postfixExp.split(" ") - - for (i,token) in enumerate(postfixTokens): - if isOperation(token): - op2 = operandeStack.pop() - if needPar(op2, token, "after"): - op2 = "( " + str(op2) + " )" - op1 = operandeStack.pop() - if needPar(op1, token, "before"): - op1 = "( " + str(op1) + " )" - res = "{op1} {op} {op2}".format(op1 = op1, op = token, op2 = op2) - - operandeStack.push(res) - - else: - operandeStack.push(token) - - return operandeStack.pop() - -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 - """ - - priority = {"*" : 3, "/": 3, "+": 2, "-":2} - - if isNumber(operande) and operande < 0: - 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 - #debug_var("stand_alone",stand_alone) - #debug_var("operande", type(operande)) - minor_priority = priority[get_main_op(operande)] < 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 - -def get_main_op(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 - - """ - - priority = {"*" : 3, "/": 3, "+": 2, "-":2} - - parStack = Stack() - #tokenList = exp.split(" ") - - 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 isOperation(token) and parStack.isEmpty(): - main_op.append(token) - - return min(main_op, key = lambda s: priority[s]) - - -def expand_list(list_list): - """Expand list of list - - :param list: the list to expande - :returns: list of expanded lists - - :Example: - - >>> expand_list([1,2,[3,4],5,[6,7,8]]) - [[1, 2, 3, 5, 6], [1, 2, 4, 5, 7], [1, 2, 4, 5, 8]] - >>> expand_list([1,2,4,5,6,7,8]) - [[1, 2, 4, 5, 6, 7, 8]] - - """ - list_in_list = [i for i in list_list if type(i) == list].copy() - - try: - nbr_ans_list = max([len(i) for i in list_in_list]) - - ans = [list_list.copy() for i in range(nbr_ans_list)] - for (i,l) in enumerate(ans): - for (j,e) in enumerate(l): - if type(e) == list: - ans[i][j] = e[min(i,len(e)-1)] - # S'il n'y a pas eut d'étapes intermédiaires (2e exemple) - except ValueError: - ans = [list_list] - - return ans - -def print_steps(steps): - """Juste print a list - - :param steps: @todo - :returns: @todo - - """ - print("{first} \t = {sec}".format(first = str_from_postfix(steps[0]), sec = str_from_postfix(steps[1]))) - for i in steps[2:]: - print("\t\t = {i}".format(i=str_from_postfix(i))) - - -def str_from_postfix(postfix): - """Return the string representing the expression - - :param postfix: a postfix ordered list of tokens - :returns: the corresponding string expression - - """ - infix = postfixToInfix(postfix) - return infix - - -def debug_var(name, var): - """print the name of the variable and the value - - :param name: the name of the variable - :param var: the variable we want information - """ - print(name, ": ", var) - - -def test(exp): - """Make various test on an expression - - """ - print("-------------") - print("Expression ",exp) - tokens = str2tokens(exp) - postfix = infixToPostfix(tokens) - #print("Postfix " , postfix) - #print(computePostfix(postfix)) - #print("Bis") - steps = [postfix] - steps += computePostfixBis(postfix) - print_steps(steps) - #print(postfixToInfix(postfix)) - #print(get_main_op(exp)) - - -if __name__ == '__main__': - exp = "1 + 3 * 5" - test(exp) - - #exp = "2 * 3 * 3 * 5" - #test(exp) - - #exp = "2 * 3 + 3 * 5" - #test(exp) - - #exp = "2 * ( 3 + 4 ) + 3 * 5" - #test(exp) - # - #exp = "2 * ( 3 + 4 ) + ( 3 - 4 ) * 5" - #test(exp) - # - #exp = "2 * ( 2 - ( 3 + 4 ) ) + ( 3 - 4 ) * 5" - #test(exp) - # - #exp = "2 * ( 2 - ( 3 + 4 ) ) + 5 * ( 3 - 4 )" - #test(exp) - # - #exp = "2 + 5 * ( 3 - 4 )" - #test(exp) - # - #exp = "( 2 + 5 ) * ( 3 - 4 )" - #test(exp) - # - #exp = "( 2 + 5 ) * ( 3 * 4 )" - #test(exp) - - #exp = "( 2 + 5 - 1 ) / ( 3 * 4 )" - #test(exp) - - exp = "( 2 + 5 ) / ( 3 * 4 ) + 1 / 12" - test(exp) - - exp = "( 2 + 5 ) / ( 3 * 4 ) + 1 / 2" - test(exp) - - exp = "( 2 + 5 ) / ( 3 * 4 ) + 1 / 12 + 5 * 5" - test(exp) - - #print(expand_list([1,2,['a','b','c'], 3, ['d','e']])) - - ## Ce denier pose un soucis. Pour le faire marcher il faudrai implémenter le calcul avec les fractions - #exp = "( 2 + 5 ) / 3 * 4" - #test(exp) - import doctest - doctest.testmod() - - -# ----------------------------- -# 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 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