From 80bdd86297df86aef4bdbcf6feb1f9a51677aab6 Mon Sep 17 00:00:00 2001 From: Lafrite Date: Thu, 8 Aug 2013 01:12:11 +0200 Subject: [PATCH] remove tabs --- arithmetic.py | 34 ++-- calculus.py | 444 +++++++++++++++++++++++++------------------------- fraction.py | 275 +++++++++++++++---------------- generic.py | 74 ++++----- 4 files changed, 414 insertions(+), 413 deletions(-) diff --git a/arithmetic.py b/arithmetic.py index f99054e..b559788 100644 --- a/arithmetic.py +++ b/arithmetic.py @@ -3,26 +3,26 @@ def gcd(a, b): - """Compute gcd(a,b) + """Compute gcd(a,b) - :param a: first number - :param b: second number - :returns: the gcd + :param a: first number + :param b: second number + :returns: the gcd - """ - if a > b: - c = a % b - else: - c = b % a + """ + if a > b: + c = a % b + else: + c = b % a - if c == 0: - return min(a,b) - elif a == 1: - return b - elif b == 1: - return a - else: - return gcd(min(a,b), c) + if c == 0: + return min(a,b) + elif a == 1: + return b + elif b == 1: + return a + else: + return gcd(min(a,b), c) # ----------------------------- diff --git a/calculus.py b/calculus.py index ee7d508..5c7d24c 100644 --- a/calculus.py +++ b/calculus.py @@ -7,315 +7,315 @@ from generic import Stack def infixToPostfix(infixExp): - """Transform an infix expression into postfix expression + """Transform an infix expression into postfix expression - :param infixExp: an infix expression (caracters must be separate by a space) - :returns: the corresponding postfix expression + :param infixExp: an infix expression (caracters must be separate by a space) + :returns: the corresponding postfix expression - :Example: + :Example: - >>> infixToPostfix("1 + 2") - '1 2 +' + >>> infixToPostfix("1 + 2") + '1 2 +' - >>> infixToPostfix("1 * 2 + 3") - '1 2 * 3 +' + >>> infixToPostfix("1 * 2 + 3") + '1 2 * 3 +' - """ - priority = {"*" : 3, "/": 3, "+": 2, "-":2, "(": 1} - - opStack = Stack() - postfixList = [] + """ + priority = {"*" : 3, "/": 3, "+": 2, "-":2, "(": 1} + + opStack = Stack() + postfixList = [] - tokenList = infixExp.split(" ") + tokenList = infixExp.split(" ") - for token in tokenList: - 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 (priority[opStack.peek()] >= priority[token]): - postfixList.append(opStack.pop()) - opStack.push(token) - else: - postfixList.append(token) + for token in tokenList: + 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 (priority[opStack.peek()] >= priority[token]): + postfixList.append(opStack.pop()) + opStack.push(token) + else: + postfixList.append(token) - while not opStack.isEmpty(): - postfixList.append(opStack.pop()) + while not opStack.isEmpty(): + postfixList.append(opStack.pop()) - return " ".join(postfixList) + return " ".join(postfixList) def computePostfix(postfixExp): - """Compute a postfix expression + """Compute a postfix expression - :param postfixExp: a postfix expression - :returns: the result of the expression + :param postfixExp: a postfix expression + :returns: the result of the expression - """ - print(postfixToInfix(postfixExp)) - # where to save numbers or - operandeStack = Stack() + """ + print(postfixToInfix(postfixExp)) + # where to save numbers or + operandeStack = Stack() - tokenList = postfixExp.split(" ") + tokenList = postfixExp.split(" ") - for (i,token) in enumerate(tokenList): - if token in "+-*/": - op2 = operandeStack.pop() - op1 = operandeStack.pop() - res = doMath(token, op1, op2) - operandeStack.push(res) + for (i,token) in enumerate(tokenList): + if token in "+-*/": + 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(tokenList[i+1:]) - newPostfix = " ".join(operandeStack + tokenList[i+1:]) - print(postfixToInfix(newPostfix)) + #print("Operation: {op1} {op} {op2}".format(op1 = op1, op = token, op2 = op2)) + #print(operandeStack) + #print(tokenList[i+1:]) + newPostfix = " ".join(operandeStack + tokenList[i+1:]) + print(postfixToInfix(newPostfix)) - else: - operandeStack.push(token) + else: + operandeStack.push(token) - return operandeStack.pop() + return operandeStack.pop() def computePostfixBis(postfixExp): - """Compute a postfix expression like a good student + """Compute a postfix expression like a good student - :param postfixExp: a postfix expression - :returns: the result of the expression + :param postfixExp: a postfix expression + :returns: the result of the expression - """ - print(postfixToInfix(postfixExp)) - # where to save numbers or - operandeStack = Stack() + """ + print(postfixToInfix(postfixExp)) + # where to save numbers or + operandeStack = Stack() - tokenList = postfixExp.split(" ") + tokenList = postfixExp.split(" ") - # 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 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) + # 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 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) + 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]) + # 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 + del tokenList[0] + tmpTokenList += tokenList - tokenList = tmpTokenList.copy() - print(postfixToInfix(" ".join(tokenList))) + tokenList = tmpTokenList.copy() + print(postfixToInfix(" ".join(tokenList))) - return tokenList[0] + return tokenList[0] def isNumber(exp): - """Check if the expression can be a number + """Check if the expression can be a number - :param exp: an expression - :returns: True if the expression can be a number and false otherwise + :param exp: an expression + :returns: True if the expression can be a number and false otherwise - """ - tokenList = exp.split(" ") - if len(tokenList) != 1: - # si l'expression est trop longue pour être un chiffre - return 0 - return exp.isdigit() or (exp[0] == "-" and exp[1:].isdigit()) + """ + tokenList = exp.split(" ") + if len(tokenList) != 1: + # si l'expression est trop longue pour être un chiffre + return 0 + return exp.isdigit() or (exp[0] == "-" and exp[1:].isdigit()) def doMath(op, op1, op2): - """Compute "op1 op op2" + """Compute "op1 op op2" - :param op: operator - :param op1: first operande - :param op2: second operande - :returns: string representing the result + :param op: operator + :param op1: first operande + :param op2: second operande + :returns: string representing the result - """ - return str(eval(op1 + op + op2)) + """ + return str(eval(op1 + op + op2)) def postfixToInfix(postfixExp): - """Transforme postfix expression into infix expression + """Transforme postfix expression into infix expression - :param postfixExp: a postfix expression - :returns: the corresponding infix expression + :param postfixExp: a postfix expression + :returns: the corresponding infix expression - """ - operandeStack = Stack() + """ + operandeStack = Stack() - tokenList = postfixExp.split(" ") + tokenList = postfixExp.split(" ") - for (i,token) in enumerate(tokenList): - if token in "+-*/": - op2 = operandeStack.pop() - if needPar(op2, token, "after"): - op2 = "( " + op2 + " )" - op1 = operandeStack.pop() - if needPar(op1, token, "before"): - op1 = "( " + op1 + " )" - res = "{op1} {op} {op2}".format(op1 = op1, op = token, op2 = op2) + for (i,token) in enumerate(tokenList): + if token in "+-*/": + op2 = operandeStack.pop() + if needPar(op2, token, "after"): + op2 = "( " + op2 + " )" + op1 = operandeStack.pop() + if needPar(op1, token, "before"): + op1 = "( " + op1 + " )" + res = "{op1} {op} {op2}".format(op1 = op1, op = token, op2 = op2) - operandeStack.push(res) + operandeStack.push(res) - else: - operandeStack.push(token) + else: + operandeStack.push(token) - return operandeStack.pop() + return operandeStack.pop() def needPar(operande, operator, posi = "after"): - """Says whether or not the operande needs parenthesis + """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} + :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 "-" 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 = 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") + 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 = 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 + return stand_alone and (minor_priority or special) + else: + return 0 def get_main_op(exp): - """Getting the main operation of the expression + """Getting the main operation of the expression - :param exp: the expression - :returns: the main operation (+, -, * or /) or 0 if the expression is only one element + :param exp: the expression + :returns: the main operation (+, -, * or /) or 0 if the expression is only one element - """ + """ - priority = {"*" : 3, "/": 3, "+": 2, "-":2} + priority = {"*" : 3, "/": 3, "+": 2, "-":2} - parStack = Stack() - tokenList = exp.split(" ") + parStack = Stack() + tokenList = exp.split(" ") - if len(tokenList) == 1: - # Si l'expression n'est qu'un élément - return 0 + if len(tokenList) == 1: + # Si l'expression n'est qu'un élément + return 0 - main_op = [] + 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) + 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]) + return min(main_op, key = lambda s: priority[s]) def expand_list(list_list): - """Expand list of list + """Expand list of list - :param list: the list to expande - :returns: list of expanded lists + :param list: the list to expande + :returns: list of expanded lists - :Example: + :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,[3,4],5,[6,7,8]]) + [[1, 2, 3, 5, 6], [1, 2, 4, 5, 7], [1, 2, 4, 5, 8]] - """ - list_in_list = [i for i in list_list if type(i) == list].copy() - nbr_ans_list = max([len(i) for i in list_in_list]) + """ + list_in_list = [i for i in list_list if type(i) == list].copy() + 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)] + 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)] - return ans + return ans def debug_var(name, var): - """print the name of the variable and the value + """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) + :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 + """Make various test on an expression - """ - print("-------------") - print("Expression ",exp) - postfix = infixToPostfix(exp) - #print("Postfix " , postfix) - #print(computePostfix(postfix)) - #print("Bis") - print(computePostfixBis(postfix)) - #print(postfixToInfix(postfix)) - #print(get_main_op(exp)) + """ + print("-------------") + print("Expression ",exp) + postfix = infixToPostfix(exp) + #print("Postfix " , postfix) + #print(computePostfix(postfix)) + #print("Bis") + print(computePostfixBis(postfix)) + #print(postfixToInfix(postfix)) + #print(get_main_op(exp)) if __name__ == '__main__': - #exp = "1 + 3 * 5" - #test(exp) + #exp = "1 + 3 * 5" + #test(exp) - #exp = "2 * 3 * 3 * 5" - #test(exp) + #exp = "2 * 3 * 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 ) / ( 3 * 4 )" - #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 ) / ( 3 * 4 )" + #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() + #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() # ----------------------------- diff --git a/fraction.py b/fraction.py index c3b173c..b3153f0 100644 --- a/fraction.py +++ b/fraction.py @@ -5,184 +5,185 @@ from calculus import isNumber from arithmetic import gcd class Fraction(object): - """Fractions!""" + """Fractions!""" - def __init__(self, num, denom = 1): - """To initiate a fraction we need a numerator and a denominator + def __init__(self, num, denom = 1): + """To initiate a fraction we need a numerator and a denominator - :param num: the numerator - :param denom: the denominator + :param num: the numerator + :param denom: the denominator - """ - self._num = num - self._denom = denom + """ + self._num = num + self._denom = denom - def simplify(self): - """Simplify the fraction + def simplify(self): + """Simplify the fraction - :returns: steps to simplify the fraction or the fraction if there is nothing to do - """ - steps = [str(self)] + :returns: steps to simplify the fraction or the fraction if there is nothing to do + """ + steps = [str(self)] - if self._denom < 0: - self._num = - self._num - self._denom = - self._denom - steps += [str(self)] + if self._denom < 0: + self._num = - self._num + self._denom = - self._denom + steps += [str(self)] - gcd_ = gcd(abs(self._num), abs(self._denom)) - if self._num == self._denom: - self._num = 1 - self._denom = 1 - steps += [str(self)] - elif gcd_ != 1: + gcd_ = gcd(abs(self._num), abs(self._denom)) + if self._num == self._denom: + self._num = 1 + self._denom = 1 + steps += [str(self)] - self._num, self._denom = self._num // gcd_ , self._denom // gcd_ - steps += ["( {reste1} * {gcd} ) / ( {reste2} * {gcd} )".format(reste1 = self._num, reste2 = self._denom, gcd = gcd_)] - steps += [str(self)] - return steps + elif gcd_ != 1: + self._num, self._denom = self._num // gcd_ , self._denom // gcd_ + steps += ["( {reste1} * {gcd} ) / ( {reste2} * {gcd} )".format(reste1 = self._num, reste2 = self._denom, gcd = gcd_)] + steps += [str(self)] - def __str__(self): - if self._denom == 1: - return str(self._num) - else: - return str(self._num) + " / " + str(self._denom) - - def __add__(self, other): - if type(other) == Fraction: - #cool - number = other - else: - number = Fraction(other) + return steps - steps = ["{frac1} + {frac2}".format(frac1 = self, frac2 = number)] + def __str__(self): + if self._denom == 1: + return str(self._num) + else: + return str(self._num) + " / " + str(self._denom) + + def __add__(self, other): + if type(other) == Fraction: + #cool + number = other + else: + number = Fraction(other) - if self._denom == number._denom: - com_denom = self._denom - num1 = self._num - num2 = number._num + steps = ["{frac1} + {frac2}".format(frac1 = self, frac2 = number)] - else: - gcd_denom = gcd(self._denom, number._denom) - coef1 = number._denom // gcd_denom - coef2 = self._denom // gcd_denom + if self._denom == number._denom: + com_denom = self._denom + num1 = self._num + num2 = number._num - steps += ["( {num1} * {coef1} ) / ( {den1} * {coef1} ) + ( {num2} * {coef2} ) / ( {den2} * {coef2} )".format(num1 = self._num, den1 = self._denom, coef1 = coef1, num2 = number._num, den2 = number._denom, coef2 = coef2)] + else: + gcd_denom = gcd(self._denom, number._denom) + coef1 = number._denom // gcd_denom + coef2 = self._denom // gcd_denom - com_denom = self._denom * coef1 - num1 = self._num * coef1 - num2 = number._num * coef2 + steps += ["( {num1} * {coef1} ) / ( {den1} * {coef1} ) + ( {num2} * {coef2} ) / ( {den2} * {coef2} )".format(num1 = self._num, den1 = self._denom, coef1 = coef1, num2 = number._num, den2 = number._denom, coef2 = coef2)] - steps += ["( {num1} + {num2} ) / {denom}".format(num1 = num1, num2 = num2, denom = com_denom)] + com_denom = self._denom * coef1 + num1 = self._num * coef1 + num2 = number._num * coef2 - num = num1 + num2 + steps += ["( {num1} + {num2} ) / {denom}".format(num1 = num1, num2 = num2, denom = com_denom)] - ans_frac = Fraction(num, com_denom) - steps += ans_frac.simplify() + num = num1 + num2 - return steps + ans_frac = Fraction(num, com_denom) + steps += ans_frac.simplify() - def __sub__(self, other): - if type(other) == Fraction: - #cool - number = other - else: - number = Fraction(other) + return steps - steps = ["{frac1} - {frac2}".format(frac1 = self, frac2 = number)] + def __sub__(self, other): + if type(other) == Fraction: + #cool + number = other + else: + number = Fraction(other) - if self._denom == number._denom: - com_denom = self._denom - num1 = self._num - num2 = number._num + steps = ["{frac1} - {frac2}".format(frac1 = self, frac2 = number)] - else: - gcd_denom = gcd(self._denom, number._denom) - coef1 = number._denom // gcd_denom - coef2 = self._denom // gcd_denom + if self._denom == number._denom: + com_denom = self._denom + num1 = self._num + num2 = number._num - steps += ["( {num1} * {coef1} ) / ( {den1} * {coef1} ) - ( {num2} * {coef2} ) / ( {den2} * {coef2} )".format(num1 = self._num, den1 = self._denom, coef1 = coef1, num2 = number._num, den2 = number._denom, coef2 = coef2)] + else: + gcd_denom = gcd(self._denom, number._denom) + coef1 = number._denom // gcd_denom + coef2 = self._denom // gcd_denom - com_denom = self._denom * coef1 - num1 = self._num * coef1 - num2 = number._num * coef2 + steps += ["( {num1} * {coef1} ) / ( {den1} * {coef1} ) - ( {num2} * {coef2} ) / ( {den2} * {coef2} )".format(num1 = self._num, den1 = self._denom, coef1 = coef1, num2 = number._num, den2 = number._denom, coef2 = coef2)] - steps += ["( {num1} - {num2} ) / {denom}".format(num1 = num1, num2 = num2, denom = com_denom)] + com_denom = self._denom * coef1 + num1 = self._num * coef1 + num2 = number._num * coef2 - num = num1 - num2 + steps += ["( {num1} - {num2} ) / {denom}".format(num1 = num1, num2 = num2, denom = com_denom)] - ans_frac = Fraction(num, com_denom) - steps += ans_frac.simplify() + num = num1 - num2 - return steps - - def __mul__(self, other): - if type(other) == Fraction: - #cool - number = other - else: - number = Fraction(other) + ans_frac = Fraction(num, com_denom) + steps += ans_frac.simplify() - steps = ["( {frac1} ) * ( {frac2} )".format(frac1 = self, frac2 = number)] - steps += ["( {num1} * {num2} ) / ( {denom1} * {denom2} )".format(num1 = self._num, num2 = number._num, denom1 = self._denom, denom2 = number._denom)] + return steps + + def __mul__(self, other): + if type(other) == Fraction: + #cool + number = other + else: + number = Fraction(other) - num = self._num * number._num - denom = self._denom * number._denom + steps = ["( {frac1} ) * ( {frac2} )".format(frac1 = self, frac2 = number)] + steps += ["( {num1} * {num2} ) / ( {denom1} * {denom2} )".format(num1 = self._num, num2 = number._num, denom1 = self._denom, denom2 = number._denom)] - ans_frac = Fraction(num, denom) - steps += ans_frac.simplify() + num = self._num * number._num + denom = self._denom * number._denom - return steps + ans_frac = Fraction(num, denom) + steps += ans_frac.simplify() - def __truediv__(self, other): - if type(other) == Fraction: - #cool - number = other - else: - number = Fraction(other) + return steps - steps = ["( {frac1} ) / ( {frac2} )".format(frac1 = self, frac2 = number)] - number = Fraction(number._denom, number._num) - steps += self * number + def __truediv__(self, other): + if type(other) == Fraction: + #cool + number = other + else: + number = Fraction(other) - return steps + steps = ["( {frac1} ) / ( {frac2} )".format(frac1 = self, frac2 = number)] + number = Fraction(number._denom, number._num) + steps += self * number + + return steps if __name__ == '__main__': - f = Fraction(34, 12) - g = Fraction(1,5) - h = Fraction(-1,5) - t = Fraction(-4,5) - print("---------") - for i in (f - 1): - print(i) - print("---------") - for i in (f + 1): - print(i) - print("---------") - for i in (f + g): - print(i) - print("---------") - for i in (f - g): - print(i) - print("---------") - for i in (f * g): - print(i) - print("---------") - for i in (h + t): - print(i) - print("---------") - for i in (h - t): - print(i) - print("---------") - for i in (h * t): - print(i) - print("---------") - for i in (h / t): - print(i) + f = Fraction(34, 12) + g = Fraction(1,5) + h = Fraction(-1,5) + t = Fraction(-4,5) + print("---------") + for i in (f - 1): + print(i) + print("---------") + for i in (f + 1): + print(i) + print("---------") + for i in (f + g): + print(i) + print("---------") + for i in (f - g): + print(i) + print("---------") + for i in (f * g): + print(i) + print("---------") + for i in (h + t): + print(i) + print("---------") + for i in (h - t): + print(i) + print("---------") + for i in (h * t): + print(i) + print("---------") + for i in (h / t): + print(i) - #print(f.simplify()) + #print(f.simplify()) # ----------------------------- # Reglages pour 'vim' diff --git a/generic.py b/generic.py index f515871..84f337b 100644 --- a/generic.py +++ b/generic.py @@ -3,59 +3,59 @@ class Stack(object): - """Docstring for Stack """ + """Docstring for Stack """ - def __init__(self): - """@todo: to be defined1 """ - self.items = [] + def __init__(self): + """@todo: to be defined1 """ + self.items = [] - def pushFromList(self, list): - """Push the list in the stack + def pushFromList(self, list): + """Push the list in the stack - :param list: a list - """ - for i in list[::-1]: - self.push(i) + :param list: a list + """ + for i in list[::-1]: + self.push(i) - def isEmpty(self): - """ Says if the stack is empty - :returns: @todo + def isEmpty(self): + """ Says if the stack is empty + :returns: @todo - """ - return self.items == [] + """ + return self.items == [] - def push(self, item): - """Push an item in the stack + def push(self, item): + """Push an item in the stack - :param item: @todo - :returns: @todo + :param item: @todo + :returns: @todo - """ - self.items.append(item) + """ + self.items.append(item) - def pop(self): - """Getting the last item and remove it - :returns: last item + def pop(self): + """Getting the last item and remove it + :returns: last item - """ - return self.items.pop() + """ + return self.items.pop() - def peek(self, posi = 0): - """Getting the last item + def peek(self, posi = 0): + """Getting the last item :param posi: which item to peek 0 (last) 1 (the onebefore the last)... - :returns: the item + :returns: the item - """ - return self.items[-1 - posi] + """ + return self.items[-1 - posi] - def __len__(self): - return len(self.items) + def __len__(self): + return len(self.items) - def __str__(self): - return str(self.items) + " -> " + def __str__(self): + return str(self.items) + " -> " - def __add__(self, addList): - return self.items + addList + def __add__(self, addList): + return self.items + addList # ----------------------------- # Reglages pour 'vim'