From 47d43849d030006f6176f4fe144d53b6081e723f Mon Sep 17 00:00:00 2001 From: Benjamin Bertrand Date: Sat, 13 Feb 2016 07:04:08 +0300 Subject: [PATCH] autopep8 on all files but operator.py --- pymath/calculus/abstract_polynom.py | 113 ++++++++++-------- pymath/calculus/arithmetic.py | 41 +++---- pymath/calculus/explicable.py | 11 +- pymath/calculus/expression.py | 109 +++++++++++------- pymath/calculus/fraction.py | 165 +++++++++++++++++---------- pymath/calculus/generic.py | 73 +++++++----- pymath/calculus/polynom.py | 76 ++++++------ pymath/calculus/polynomDeg2.py | 64 +++++++---- pymath/calculus/random_expression.py | 48 +++++--- pymath/calculus/render.py | 21 ++-- pymath/calculus/str2tokens.py | 36 +++--- pymath/stat/dataset.py | 59 +++++----- pymath/stat/number_tools.py | 2 - pymath/stat/random_generator.py | 32 +++--- pymath/stat/weightedDataset.py | 52 +++++---- 15 files changed, 536 insertions(+), 366 deletions(-) diff --git a/pymath/calculus/abstract_polynom.py b/pymath/calculus/abstract_polynom.py index b0ffaf0..efe860a 100644 --- a/pymath/calculus/abstract_polynom.py +++ b/pymath/calculus/abstract_polynom.py @@ -5,13 +5,15 @@ from .explicable import Explicable from .expression import Expression from .operator import op from .generic import spe_zip, expand_list, isNumber, transpose_fill, flatten_list, isPolynom, isNumerand -from .render import txt,tex +from .render import txt, tex from itertools import chain from functools import wraps + def power_cache(fun): """Decorator which cache calculated powers of polynoms """ - cache = {} + cache = {} + @wraps(fun) def cached_fun(self, power): #print("cache -> ", cache) @@ -23,11 +25,12 @@ def power_cache(fun): return poly_powered return cached_fun + class AbstractPolynom(Explicable): """The mathematic definition of a polynom. It will be the parent class of Polynom (classical polynoms) and later of SquareRoot polynoms""" - def __init__(self, coefs = [1], letter = "x", name = "P"): + def __init__(self, coefs=[1], letter="x", name="P"): """Initiate the polynom :param coef: coefficients of the polynom (ascending degree sorted) @@ -86,7 +89,7 @@ class AbstractPolynom(Explicable): """ self._coef = [] for coef in l_coef: - if type(coef) == list and len(coef)==1: + if isinstance(coef, list) and len(coef) == 1: self._coef.append(coef[0]) else: self._coef.append(coef) @@ -114,7 +117,7 @@ class AbstractPolynom(Explicable): >>> AbstractPolynom([1]).is_monom() 1 """ - if len([i for i in self._coef if i != 0])==1: + if len([i for i in self._coef if i != 0]) == 1: return 1 else: return 0 @@ -126,7 +129,7 @@ class AbstractPolynom(Explicable): return str(Expression(self.postfix_tokens)) def __repr__(self): - return "< " + str(self.__class__) + " " + str(self._coef) + ">" + return "< " + str(self.__class__) + " " + str(self._coef) + ">" def __txt__(self): return txt(self.postfix_tokens) @@ -156,15 +159,16 @@ class AbstractPolynom(Explicable): ['x', 2, '^'] """ - ans =[] + ans = [] if a == [0]: pass elif i == 0: ans = a elif i == 1: - ans = a * (a!=[1]) + [self._letter] + [op.mul] * (a!=[1]) + ans = a * (a != [1]) + [self._letter] + [op.mul] * (a != [1]) else: - ans = a * (a!=[1]) + [self._letter, i, op.pw] + [op.mul] * (a!=[1]) + ans = a * (a != [1]) + [self._letter, i, + op.pw] + [op.mul] * (a != [1]) return ans @@ -208,20 +212,21 @@ class AbstractPolynom(Explicable): """ if self == 0: return [0] - # TODO: Faudrait factoriser un peu tout ça..! |dim. déc. 21 16:02:34 CET 2014 + # TODO: Faudrait factoriser un peu tout ça..! |dim. déc. 21 16:02:34 + # CET 2014 postfix = [] - for (i,a) in list(enumerate(self._coef))[::-1]: + for (i, a) in list(enumerate(self._coef))[::-1]: operator = [op.add] operator_sub1 = [] - if type(a) == Expression: + if isinstance(a, Expression): # case coef is an arithmetic expression - c = self.coef_postfix(a.postfix_tokens,i) + c = self.coef_postfix(a.postfix_tokens, i) if c != []: postfix.append(c) if len(postfix) > 1: postfix += operator - elif type(a) == list: + elif isinstance(a, list): # case need to repeat the x^i for b in a: operator = [op.add] @@ -240,7 +245,7 @@ class AbstractPolynom(Explicable): operator = [op.sub] else: b = [b] - c = self.coef_postfix(b,i) + c = self.coef_postfix(b, i) if c != []: postfix.append(c) if len(postfix) > 1: @@ -264,7 +269,7 @@ class AbstractPolynom(Explicable): else: a = [a] - c = self.coef_postfix(a,i) + c = self.coef_postfix(a, i) if c != []: postfix.append(c) if len(postfix) > 1: @@ -285,11 +290,12 @@ class AbstractPolynom(Explicable): """ if isNumber(other) and not isPolynom(other): - return AbstractPolynom([other], letter = self._letter) + return AbstractPolynom([other], letter=self._letter) elif isPolynom(other): return other else: - raise ValueError(type(other) + " can't be converted into a polynom") + raise ValueError(type(other) + + " can't be converted into a polynom") def reduce(self): """Compute coefficients which have same degree @@ -316,14 +322,15 @@ class AbstractPolynom(Explicable): [< [[1, 2], [3, 4, 5], 6]>, < [< [1, 2, '+'] >, < [3, 4, '+', 5, '+'] >, 6]>, < [3, < [7, 5, '+'] >, 6]>] """ - # TODO: It doesn't not compute quick enough |ven. févr. 27 18:04:01 CET 2015 + # TODO: It doesn't not compute quick enough |ven. févr. 27 18:04:01 CET + # 2015 # gather steps for every coefficients coefs_steps = [] for coef in self._coef: coef_steps = [] - if type(coef) ==list: + if isinstance(coef, list): # Simplify each element before adding them s = [] for c in coef: @@ -339,7 +346,7 @@ class AbstractPolynom(Explicable): coef_steps += s # Convert last element into postfix addition. - postfix_add = self.postfix_add([i for i in last if i!=0]) + postfix_add = self.postfix_add([i for i in last if i != 0]) # Convert it to an expression coef_exp = Expression(postfix_add) @@ -393,12 +400,13 @@ class AbstractPolynom(Explicable): >>> AbstractPolynom.postfix_add([]) [0] """ - if not type(numbers) == list: + if not isinstance(numbers, list): return [numbers] elif numbers == []: return [0] else: - ans = [[a, op.add] if i!=0 else [a] for (i,a) in enumerate(numbers)] + ans = [[a, op.add] if i != 0 else [a] + for (i, a) in enumerate(numbers)] return list(chain.from_iterable(ans)) def __eq__(self, other): @@ -428,9 +436,10 @@ class AbstractPolynom(Explicable): o_poly = self.conv2poly(other) n_coef = spe_zip(self._coef, o_poly._coef) - p = AbstractPolynom(n_coef, letter = self._letter) + p = AbstractPolynom(n_coef, letter=self._letter) - ini_step = [Expression(self.postfix_tokens + o_poly.postfix_tokens + [op.add])] + ini_step = [Expression(self.postfix_tokens + + o_poly.postfix_tokens + [op.add])] ans = p.simplify() ans.steps = ini_step + ans.steps return ans @@ -450,7 +459,8 @@ class AbstractPolynom(Explicable): [< [3, 'x', 2, '^', '*', 2, 'x', '*', '+', 1, '+', '-'] >] """ ini_step = [Expression(self.postfix_tokens + [op.sub1])] - ans = AbstractPolynom([-i for i in self._coef], letter = self._letter).simplify() + ans = AbstractPolynom([-i for i in self._coef], + letter=self._letter).simplify() ans.steps = ini_step + ans.steps return ans @@ -473,7 +483,8 @@ class AbstractPolynom(Explicable): [< [3, 'x', 2, '^', '*', 2, 'x', '*', '+', 1, '+', 6, 'x', 2, '^', '*', 5, 'x', '*', '+', 4, '+', '-'] >, < [3, 'x', 2, '^', '*', 2, 'x', '*', '+', 1, '+', 6, 'x', 2, '^', '*', '-', 5, 'x', '*', '-', 4, '-', '+'] >, < [[1, -4], [2, -5], [3, -6]]>, < [< [1, -4, '+'] >, < [2, -5, '+'] >, < [3, -6, '+'] >]>] """ o_poly = self.conv2poly(other) - ini_step = [Expression(self.postfix_tokens + o_poly.postfix_tokens + [op.sub])] + ini_step = [Expression(self.postfix_tokens + + o_poly.postfix_tokens + [op.sub])] o_poly = -o_poly #ini_step += o_poly.steps @@ -518,28 +529,29 @@ class AbstractPolynom(Explicable): """ o_poly = self.conv2poly(other) - coefs = [0]*(self.degree + o_poly.degree + 1) - for (i,a) in enumerate(self._coef): - for (j,b) in enumerate(o_poly._coef): + coefs = [0] * (self.degree + o_poly.degree + 1) + for (i, a) in enumerate(self._coef): + for (j, b) in enumerate(o_poly._coef): if a == 0 or b == 0: elem = 0 - elif a==1: + elif a == 1: elem = b - elif b==1: + elif b == 1: elem = a else: elem = Expression([a, b, op.mul]) - if coefs[i+j]==0: - coefs[i+j] = elem + if coefs[i + j] == 0: + coefs[i + j] = elem elif elem != 0: - if type(coefs[i+j]) == list: - coefs[i+j] += [elem] + if isinstance(coefs[i + j], list): + coefs[i + j] += [elem] else: - coefs[i+j] = [coefs[i+j] , elem] + coefs[i + j] = [coefs[i + j], elem] - p = AbstractPolynom(coefs, letter = self._letter) - ini_step = [Expression(self.postfix_tokens + o_poly.postfix_tokens + [op.mul])] + p = AbstractPolynom(coefs, letter=self._letter) + ini_step = [Expression(self.postfix_tokens + + o_poly.postfix_tokens + [op.mul])] ans = p.simplify() ans.steps = [ini_step] + ans.steps @@ -573,25 +585,30 @@ class AbstractPolynom(Explicable): """ if not type(power): - raise ValueError("Can't raise {obj} to {pw} power".format(obj = self.__class__, pw = str(power))) + raise ValueError( + "Can't raise {obj} to {pw} power".format( + obj=self.__class__, pw=str(power))) ini_step = [Expression(self.postfix_tokens + [power, op.pw])] if self.is_monom(): if self._coef[self.degree] == 1: - coefs = [0]*self.degree*power + [1] - p = AbstractPolynom(coefs, letter = self._letter) + coefs = [0] * self.degree * power + [1] + p = AbstractPolynom(coefs, letter=self._letter) ans = p else: - coefs = [0]*self.degree*power + [Expression([self._coef[self.degree] , power, op.pw])] - p = AbstractPolynom(coefs, letter = self._letter) + coefs = [0] * self.degree * power + \ + [Expression([self._coef[self.degree], power, op.pw])] + p = AbstractPolynom(coefs, letter=self._letter) ans = p.simplify() else: if power == 2: ans = self * self else: - # TODO: faudrait changer ça c'est pas très sérieux |ven. févr. 27 22:08:00 CET 2015 - raise AttributeError("__pw__ not implemented yet when power is greatter than 2") + # TODO: faudrait changer ça c'est pas très sérieux |ven. févr. + # 27 22:08:00 CET 2015 + raise AttributeError( + "__pw__ not implemented yet when power is greatter than 2") ans.steps = ini_step + ans.steps return ans @@ -600,13 +617,13 @@ class AbstractPolynom(Explicable): return self.__pow__(power) if __name__ == '__main__': - P = AbstractPolynom([[1,2],[3,4,5],6]) + P = AbstractPolynom([[1, 2], [3, 4, 5], 6]) Q = P.reduce() for i in Q.explain(): print(i) #import doctest - #doctest.testmod() + # doctest.testmod() # ----------------------------- diff --git a/pymath/calculus/arithmetic.py b/pymath/calculus/arithmetic.py index 5508139..2ba5e27 100644 --- a/pymath/calculus/arithmetic.py +++ b/pymath/calculus/arithmetic.py @@ -4,32 +4,33 @@ __all__ = ['gcd'] + 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 - """ - pos_a, _a = (a >= 0), abs(a) - pos_b, _b = (b >= 0), abs(b) + """ + pos_a, _a = (a >= 0), abs(a) + pos_b, _b = (b >= 0), abs(b) - gcd_sgn = (-1 + 2*(pos_a or pos_b)) + gcd_sgn = (-1 + 2 * (pos_a or pos_b)) - if _a > _b: - c = _a % _b - else: - c = _b % _a + if _a > _b: + c = _a % _b + else: + c = _b % _a - if c == 0: - return gcd_sgn * min(_a,_b) - elif _a == 1: - return gcd_sgn * _b - elif _b == 1: - return gcd_sgn * _a - else: - return gcd_sgn * gcd(min(_a,_b), c) + if c == 0: + return gcd_sgn * min(_a, _b) + elif _a == 1: + return gcd_sgn * _b + elif _b == 1: + return gcd_sgn * _a + else: + return gcd_sgn * gcd(min(_a, _b), c) if __name__ == '__main__': print(gcd(3, 15)) diff --git a/pymath/calculus/explicable.py b/pymath/calculus/explicable.py index fe5c6c0..dca1f96 100644 --- a/pymath/calculus/explicable.py +++ b/pymath/calculus/explicable.py @@ -3,6 +3,7 @@ from .render import txt, tex + class Renderable(object): """ A Renderable object is an object which can work with Render class. It means that it has to have attribute postfix_tokens. @@ -23,7 +24,7 @@ class Renderable(object): cls.set_render(cls.DEFAULT_RENDER) @classmethod - def tmp_render(cls, render = tex): + def tmp_render(cls, render=tex): """ Create a container in which Expression render is temporary modify The default temporary render is Expression in order to perform calculus inside numbers @@ -56,6 +57,7 @@ class Renderable(object): """ class TmpRenderEnv(object): + def __enter__(self): self.old_render = Renderable.get_render() Renderable.set_render(render) @@ -72,7 +74,6 @@ class Renderable(object): return False - class Explicable(Renderable): """ An Explicable object is an object which can be explicable! @@ -82,10 +83,11 @@ class Explicable(Renderable): * explain: Generator which return steps which leed to himself """ + def __init__(self, *args, **kwargs): self.steps = [] - def explain(self, noself = True): + def explain(self, noself=True): """ Generate and render steps which leed to itself :param noself: does explain return self @@ -126,9 +128,6 @@ class Explicable(Renderable): return False - - - # ----------------------------- # Reglages pour 'vim' # vim:set autoindent expandtab tabstop=4 shiftwidth=4: diff --git a/pymath/calculus/expression.py b/pymath/calculus/expression.py index 87f9f5c..d02d23e 100644 --- a/pymath/calculus/expression.py +++ b/pymath/calculus/expression.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # encoding: utf-8 -#debuging +# debuging #from debug.tools import report from .generic import Stack, flatten_list, expand_list, isNumber, isOperator, isNumerand @@ -13,13 +13,16 @@ from .random_expression import RdExpression __all__ = ['Expression'] + class Fake_int(int, Explicable): isNumber = True + def __init__(self, val): super(Fake_int, self).__init__(val) self._val = val self.postfix_tokens = [self] self.steps = [] + def simplify(self): return Fake_int(self._val) @@ -28,7 +31,7 @@ class Expression(Explicable): """A calculus expression. Today it can andle only expression with numbers later it will be able to manipulate unknown""" @classmethod - def random(self, form="", conditions=[], val_min = -10, val_max=10): + def random(self, form="", conditions=[], val_min=-10, val_max=10): """Create a random expression from form and with conditions :param form: the form of the expression (/!\ variables need to be in brackets {}) @@ -41,7 +44,7 @@ class Expression(Explicable): return Expression(random_generator(val_min, val_max)) @classmethod - def tmp_render(cls, render = lambda _,x:Expression(x)): + def tmp_render(cls, render=lambda _, x: Expression(x)): """ Same ad tmp_render for Renderable but default render is Expression >>> exp = Expression("2*3/5") @@ -87,44 +90,56 @@ class Expression(Explicable): """ expression = object.__new__(cls) - if type(exp) == str: + if isinstance(exp, str): expression.postfix_tokens = str2tokens(exp) - elif type(exp) == list: - # Ici on ne peut convertir les "+" en opérateur que s'ils sont d'arité 2. - exp_mod_op = [op.get_op(i) if op.can_be_operator(i) else i for i in exp] - expression.postfix_tokens = flatten_list([tok.postfix_tokens if Expression.isExpression(tok) else tok for tok in exp_mod_op]) + elif isinstance(exp, list): + # Ici on ne peut convertir les "+" en opérateur que s'ils sont + # d'arité 2. + exp_mod_op = [ + op.get_op(i) if op.can_be_operator(i) else i for i in exp] + expression.postfix_tokens = flatten_list( + [tok.postfix_tokens if Expression.isExpression(tok) else tok for tok in exp_mod_op]) - elif type(exp) == Expression: + elif isinstance(exp, Expression): return exp elif isNumerand(exp): expression.postfix_tokens = [exp] else: - raise ValueError("Can't build Expression with {} object".format(type(exp))) + raise ValueError( + "Can't build Expression with {} object".format( + type(exp))) if len(expression.postfix_tokens) == 1: token = expression.postfix_tokens[0] - if type(token) == Fake_int or type(token) == int: + if isinstance(token, Fake_int) or isinstance(token, int): return Fake_int(token) elif hasattr(token, 'simplify') and hasattr(token, 'explain'): ans = expression.postfix_tokens[0] return ans - elif type(token) == str: + elif isinstance(token, str): # TODO: Pourquoi ne pas créer directement un polynom ici? |jeu. févr. 26 18:59:24 CET 2015 - # On crée un faux str en ajoutant la méthode simplify et simplified et la caractérisique isNumber - simplify = lambda x:[x] + # On crée un faux str en ajoutant la méthode simplify et + # simplified et la caractérisique isNumber + simplify = lambda x: [x] is_polynom = True - methods_attr = {'simplify':simplify, '_isPolynom': is_polynom, 'postfix_tokens': [token]} - fake_token = type('fake_str', (str,Explicable, ), methods_attr)(token) + methods_attr = { + 'simplify': simplify, + '_isPolynom': is_polynom, + 'postfix_tokens': [token]} + fake_token = type( + 'fake_str', (str, Explicable, ), methods_attr)(token) return fake_token else: - raise ValueError("Unknow token type in Expression: {}".format(type(token))) + raise ValueError( + "Unknow token type in Expression: {}".format( + type(token))) else: expression._isExpression = 1 @@ -139,7 +154,8 @@ class Expression(Explicable): return self.STR_RENDER(self.postfix_tokens) def __repr__(self): - return " ".join(["<", str(self.__class__) , str(self.postfix_tokens), ">"]) + return " ".join(["<", str(self.__class__), + str(self.postfix_tokens), ">"]) def simplify(self): """ Compute entirely the expression and return the result with .steps attribute """ @@ -157,9 +173,10 @@ class Expression(Explicable): tmpTokenList = [] while len(tokenList) > 2: - # on va chercher les motifs du genre A B +, quand l'operateur est d'arité 2, pour les calculer + # on va chercher les motifs du genre A B +, quand l'operateur est + # d'arité 2, pour les calculer if isNumerand(tokenList[0]) and isNumerand(tokenList[1]) \ - and isOperator(tokenList[2]) and tokenList[2].arity == 2 : + and isOperator(tokenList[2]) and tokenList[2].arity == 2: # S'il y a une opération à faire op1 = tokenList[0] @@ -170,7 +187,8 @@ class Expression(Explicable): tmpTokenList.append(res) - # Comme on vient de faire le calcul, on peut détruire aussi les deux prochains termes + # Comme on vient de faire le calcul, on peut détruire aussi les + # deux prochains termes del tokenList[0:3] # Et les motifs du gens A -, quand l'operateur est d'arité 1 @@ -185,7 +203,8 @@ class Expression(Explicable): tmpTokenList.append(res) - # Comme on vient de faire le calcul, on peut détruire aussi les deux prochains termes + # Comme on vient de faire le calcul, on peut détruire aussi les + # deux prochains termes del tokenList[0:2] else: @@ -194,7 +213,7 @@ class Expression(Explicable): del tokenList[0] if len(tokenList) == 2 and isNumerand(tokenList[0]) \ - and isOperator(tokenList[1]) and tokenList[1].arity == 1: + and isOperator(tokenList[1]) and tokenList[1].arity == 1: # S'il reste deux éléments dont un operation d'arité 1 op1 = tokenList[0] operator = tokenList[1] @@ -203,7 +222,8 @@ class Expression(Explicable): tmpTokenList.append(res) - # Comme on vient de faire le calcul, on peut détruire aussi les deux prochains termes + # Comme on vient de faire le calcul, on peut détruire aussi les + # deux prochains termes del tokenList[0:2] tmpTokenList += tokenList @@ -239,8 +259,8 @@ class Expression(Explicable): try: other._isExpression except AttributeError: - return 0 - return 1 + return 0 + return 1 # ----------- # Expression act as container from self.postfix_tokens @@ -255,17 +275,23 @@ class Expression(Explicable): # Some math manipulations def operate(self, other, operator): - if type(other) == Expression: - return Expression(self.postfix_tokens + other.postfix_tokens + [operator]) - elif type(other) == list: + if isinstance(other, Expression): + return Expression( + self.postfix_tokens + + other.postfix_tokens + + [operator]) + elif isinstance(other, list): return Expression(self.postfix_tokens + other + [operator]) else: return Expression(self.postfix_tokens + [other] + [operator]) def roperate(self, other, operator): - if type(other) == Expression: - return Expression(other.postfix_tokens + self.postfix_tokens + [operator]) - elif type(other) == list: + if isinstance(other, Expression): + return Expression( + other.postfix_tokens + + self.postfix_tokens + + [operator]) + elif isinstance(other, list): return Expression(other + self.postfix_tokens + [operator]) else: return Expression([other] + self.postfix_tokens + [operator]) @@ -358,7 +384,7 @@ def untest(exp): b = a.simplify() for i in b.explain(): - #print(type(i)) + # print(type(i)) print(i) #print(type(a.simplified()), ":", a.simplified()) @@ -371,27 +397,26 @@ if __name__ == '__main__': Ar = A.simplify() for i in Ar.explain(): print(i) - #print("------------") - #for i in Ar.explain(): + # print("------------") + # for i in Ar.explain(): # print(i) - #print(type(Ar)) + # print(type(Ar)) - - #print('\n-----------') + # print('\n-----------') #A = Expression("-6 / 3 + 10 / -5") #Ar = A.simplify() - #for i in Ar.explain(): + # for i in Ar.explain(): # print(i) - #print('\n-----------') + # print('\n-----------') #A = Expression("1/3 + 4/6") #Ar = A.simplify() - #for i in Ar.explain(): + # for i in Ar.explain(): # print(i) #import doctest - #doctest.testmod() + # doctest.testmod() # ----------------------------- # Reglages pour 'vim' diff --git a/pymath/calculus/fraction.py b/pymath/calculus/fraction.py index e1dace7..adceb34 100644 --- a/pymath/calculus/fraction.py +++ b/pymath/calculus/fraction.py @@ -12,10 +12,11 @@ from copy import copy __all__ = ['Fraction'] + class Fraction(Explicable): """Fractions!""" - def __init__(self, num, denom = 1): + def __init__(self, num, denom=1): """To initiate a fraction we need a numerator and a denominator :param num: the numerator @@ -61,7 +62,7 @@ class Fraction(Explicable): if self._num == 0: return Expression([0]) - elif type(self._num) == Fraction or type(self._denom) == Fraction: + elif isinstance(self._num, Fraction) or isinstance(self._denom, Fraction): return self._num / self._denom elif self._denom < 0: @@ -76,8 +77,14 @@ class Fraction(Explicable): return Expression([n_frac]) elif gcd_ != 1: - n_frac = Fraction(self._num // gcd_ , self._denom // gcd_) - ini_step += [Expression([n_frac._num, gcd_, op.mul, n_frac._denom, gcd_, op.mul, op.div ])] + n_frac = Fraction(self._num // gcd_, self._denom // gcd_) + ini_step += [Expression([n_frac._num, + gcd_, + op.mul, + n_frac._denom, + gcd_, + op.mul, + op.div])] n_frac.steps = ini_step + n_frac.steps return n_frac @@ -103,7 +110,8 @@ class Fraction(Explicable): return str(Expression(self.postfix_tokens)) def __repr__(self): - return "< Fraction {num} / {denom}>".format(num=self._num, denom = self._denom) + return "< Fraction {num} / {denom}>".format( + num=self._num, denom=self._denom) def __txt__(self): old_render = Expression.get_render() @@ -126,8 +134,8 @@ class Fraction(Explicable): def convert2fraction(self, other): """ Convert a other into a fraction """ - if type(other) == Fraction: - #cool + if isinstance(other, Fraction): + # cool number = other else: number = Fraction(other) @@ -188,10 +196,25 @@ class Fraction(Explicable): coef1 = number._denom // gcd_denom coef2 = self._denom // gcd_denom - exp = Expression([self._num, coef1, op.mul, self._denom, coef1, op.mul, op.div, number._num, coef2, op.mul, number._denom, coef2, op.mul, op.div,op.add]) + exp = Expression([self._num, + coef1, + op.mul, + self._denom, + coef1, + op.mul, + op.div, + number._num, + coef2, + op.mul, + number._denom, + coef2, + op.mul, + op.div, + op.add]) ans = exp.simplify() - ini_step = Expression(self.postfix_tokens + number.postfix_tokens + [op.add]) + ini_step = Expression(self.postfix_tokens + + number.postfix_tokens + [op.add]) ans.steps = [ini_step] + ans.steps return ans @@ -240,9 +263,24 @@ class Fraction(Explicable): coef1 = number._denom // gcd_denom coef2 = self._denom // gcd_denom - exp = Expression([self._num, coef1, op.mul, self._denom, coef1, op.mul, op.div, number._num, coef2, op.mul, number._denom, coef2, op.mul, op.div,op.sub]) + exp = Expression([self._num, + coef1, + op.mul, + self._denom, + coef1, + op.mul, + op.div, + number._num, + coef2, + op.mul, + number._denom, + coef2, + op.mul, + op.div, + op.sub]) - ini_step = Expression(self.postfix_tokens + number.postfix_tokens + [op.sub]) + ini_step = Expression(self.postfix_tokens + + number.postfix_tokens + [op.sub]) ans = exp.simplify() ans.steps = [ini_step] + ans.steps return ans @@ -273,7 +311,7 @@ class Fraction(Explicable): """ f = Fraction(-self._num, self._denom) - ans = f.simplify() + ans = f.simplify() return ans @@ -313,13 +351,14 @@ class Fraction(Explicable): elif other == 1: return copy(self) - # TODO: Changer dans le cas où il y a trop de 1 |dim. déc. 28 10:44:10 CET 2014 + # TODO: Changer dans le cas où il y a trop de 1 |dim. déc. 28 10:44:10 + # CET 2014 - elif type(other) == int: + elif isinstance(other, int): gcd1 = gcd(other, self._denom) if gcd1 != 1: - num = [self._num, int(other/gcd1), op.mul, gcd1,op.mul] - denom = [int(self._denom/gcd1), gcd1, op.mul] + num = [self._num, int(other / gcd1), op.mul, gcd1, op.mul] + denom = [int(self._denom / gcd1), gcd1, op.mul] else: num = [self._num, other, op.mul] denom = [self._denom] @@ -332,24 +371,29 @@ class Fraction(Explicable): gcd1 = gcd(self._num, number._denom) if gcd1 != 1: - num1 = [int(self._num/ gcd1), gcd1, op.mul] - denom2 = [int(number._denom/ gcd1), gcd1, op.mul] + num1 = [int(self._num / gcd1), gcd1, op.mul] + denom2 = [int(number._denom / gcd1), gcd1, op.mul] else: num1 = [self._num] denom2 = [number._denom] gcd2 = gcd(self._denom, number._num) if gcd2 != 1: - num2 = [int(number._num/ gcd2), gcd2, op.mul] - denom1 = [int(self._denom/ gcd2), gcd2, op.mul] + num2 = [int(number._num / gcd2), gcd2, op.mul] + denom1 = [int(self._denom / gcd2), gcd2, op.mul] else: num2 = [number._num] denom1 = [self._denom] + exp = Expression(num1 + + num2 + + [op.mul] + + denom1 + + denom2 + + [op.mul, op.div]) - exp = Expression(num1 + num2 + [ op.mul] + denom1 + denom2 + [op.mul, op.div]) - - ini_step = Expression(self.postfix_tokens + number.postfix_tokens + [op.mul]) + ini_step = Expression(self.postfix_tokens + + number.postfix_tokens + [op.mul]) ans = exp.simplify() ans.steps = [ini_step] + ans.steps return ans @@ -381,7 +425,8 @@ class Fraction(Explicable): number = self.convert2fraction(other) - ini_step = Expression(self.postfix_tokens + number.postfix_tokens + [op.div]) + ini_step = Expression(self.postfix_tokens + + number.postfix_tokens + [op.div]) number = Fraction(number._denom, number._num) ans = self * number @@ -421,8 +466,10 @@ class Fraction(Explicable): < [27, 8, '*', 8, 8, '*', '/'] > """ - if not type(power) == int: - raise ValueError("Can't raise fraction to power {}".format(str(power))) + if not isinstance(power, int): + raise ValueError( + "Can't raise fraction to power {}".format( + str(power))) if power == 0: return Expression([1]) @@ -430,7 +477,8 @@ class Fraction(Explicable): return copy(self) else: ini_step = Expression(self.postfix_tokens + [power, op.pw]) - exp = Expression([self._num, power, op.pw, self._denom, power, op.pw, op.div]) + exp = Expression( + [self._num, power, op.pw, self._denom, power, op.pw, op.div]) ans = exp.simplify() ans.steps = [ini_step] + ans.steps @@ -485,71 +533,70 @@ class Fraction(Explicable): return Fraction(self._num, self._denom) - if __name__ == '__main__': f = Fraction(1, 12) g = Fraction(6, 12) for i in g.simplify().explain(): - print("g = ",i) - h = Fraction(1,-5) - t = Fraction(10,3) + print("g = ", i) + h = Fraction(1, -5) + t = Fraction(10, 3) print("---------") for i in (0 + h).explain(): - print('0 + h = ',i) - #print("---------") + print('0 + h = ', i) + # print("---------") #print(str(f) , "+", str(t)) - #for i in (f + t): + # for i in (f + t): # print(i) - #print("---------") + # print("---------") #print(str(f) , "+", str(g)) - #for i in (f + g): + # for i in (f + g): # print(i) - #print("---------") + # print("---------") #print(str(f) , "-", str(g)) - #for i in (f - g): + # for i in (f - g): # print(i) - #print("---------") + # print("---------") #print(str(f) , "*", str(g)) - #for i in (f * g): + # for i in (f * g): # print(i) - #print("---------") + # print("---------") #print(str(h) , "+", str(t)) - #for i in (h + t): + # for i in (h + t): # print(i) - #print("---------") + # print("---------") #print(str(h) , "-", str(t)) - #for i in (h - t): + # for i in (h - t): # print(i) - #print("---------") + # print("---------") #print(str(h) , "*", str(t)) - #for i in (h * t): + # for i in (h * t): # print(i) - #print("---------") + # print("---------") #print("-", str(h) ) - #for i in (-h): + # for i in (-h): # print(i) - #print("---------") + # print("---------") #print(str(h) , "/", str(t)) - #for i in (h / t): + # for i in (h / t): # print(i) - #print("---------") + # print("---------") #print(str(h) , "+", str(0)) - #for i in (h + 0): + # for i in (h + 0): # print(i) - #print("---------") + # print("---------") #print(str(h) , "*", str(1)) - #for i in (h * 1): + # for i in (h * 1): # print(i) - #print("---------") + # print("---------") #print(str(h) , "*", str(0)) - #for i in (h * 0): + # for i in (h * 0): # print(i) - #print("---------") + # print("---------") #print(str(h) , "*", str(4)) - #for i in (h * 4): + # for i in (h * 4): # print(i) - #print(f.simplify()) + # print(f.simplify()) import doctest doctest.testmod() diff --git a/pymath/calculus/generic.py b/pymath/calculus/generic.py index 98b7780..d000f01 100644 --- a/pymath/calculus/generic.py +++ b/pymath/calculus/generic.py @@ -4,6 +4,7 @@ from itertools import zip_longest + class Stack(object): """Docstring for Stack """ @@ -24,7 +25,7 @@ class Stack(object): """ return self.items == [] - def push(self, item): + def push(self, item): """Push an item in the stack """ @@ -37,7 +38,7 @@ class Stack(object): """ return self.items.pop() - def peek(self, posi = 0): + 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 @@ -54,6 +55,7 @@ class Stack(object): def __add__(self, addList): return self.items + addList + def flatten_list(a, result=None): """Flattens a nested list. @@ -71,6 +73,7 @@ def flatten_list(a, result=None): return result + def first_elem(ll): """Get the first element in imbricates lists # TODO: Fonction pourrie mais j'ai pas le temps de faire mieux! |mar. janv. 28 22:32:22 CET 2014 @@ -93,13 +96,14 @@ def first_elem(ll): """ if hasattr(ll, '__contains__'): - if len(ll) == 1 and type(ll) == str: + if len(ll) == 1 and isinstance(ll, str): return ll[0] else: return first_elem(ll[0]) else: return ll + def last_elem(ll): """Get the last element in imbricates lists # TODO: Fonction pourrie mais j'ai pas le temps de faire mieux! |mar. janv. 28 22:32:22 CET 2014 @@ -122,7 +126,7 @@ def last_elem(ll): """ if hasattr(ll, '__contains__'): - if len(ll) == 1 and type(ll) == str: + if len(ll) == 1 and isinstance(ll, str): return ll[-1] else: return last_elem(ll[-1]) @@ -139,22 +143,23 @@ def expand_list(list_list): [[1, 2, 4, 5, 6, 7, 8]] """ - list_in_list = [i for i in list_list if type(i) == list].copy() + list_in_list = [i for i in list_list if isinstance(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)] + for (i, l) in enumerate(ans): + for (j, e) in enumerate(l): + if isinstance(e, list): + ans[i][j] = e[min(i, len(e) - 1)] # S'il n'y a pas de liste dans la liste (2e exemple) except ValueError: ans = [list_list] return ans + def add_in_dict(dict1, dict2): """Merge dictionary keys and add the content from dict1 and dict2 @@ -172,7 +177,7 @@ def add_in_dict(dict1, dict2): """ new_dict = {} new_dict.update(dict1) - for (k,v) in dict2.items(): + for (k, v) in dict2.items(): if k in new_dict.keys(): new_dict[k] += v else: @@ -180,7 +185,8 @@ def add_in_dict(dict1, dict2): return new_dict -def remove_in_dict(d, value = 0): + +def remove_in_dict(d, value=0): """ In a dictionary, remove keys which have certain value :param d: the dictionary @@ -193,14 +199,15 @@ def remove_in_dict(d, value = 0): True """ new_dict = {} - for (k,v) in d.items(): + for (k, v) in d.items(): if v != value: new_dict[k] = v return new_dict -def convolution_dict(D1, D2, op = lambda x,y:x*y,\ - op_key = lambda x,y: x + y, \ - commutative = True, op_twice = lambda x,y: x + y): + +def convolution_dict(D1, D2, op=lambda x, y: x * y, + op_key=lambda x, y: x + y, + commutative=True, op_twice=lambda x, y: x + y): """Convolution of two dictionaries :param D1: First dictionary @@ -226,21 +233,22 @@ def convolution_dict(D1, D2, op = lambda x,y:x*y,\ for k1 in sorted(D1.keys()): for k2 in sorted(D2.keys()): - if op_key(k1,k2) in new_dict.keys(): - key = op_key(k1,k2) - new_dict[key] = op_twice(new_dict[key], op(D1[k1],D2[k2])) + if op_key(k1, k2) in new_dict.keys(): + key = op_key(k1, k2) + new_dict[key] = op_twice(new_dict[key], op(D1[k1], D2[k2])) - elif op_key(k2,k1) in new_dict.keys() and commutative: - key = op_key(k2,k1) - new_dict[key] = op_twice(new_dict[key], op(D1[k1],D2[k2])) + elif op_key(k2, k1) in new_dict.keys() and commutative: + key = op_key(k2, k1) + new_dict[key] = op_twice(new_dict[key], op(D1[k1], D2[k2])) else: - key = op_key(k1,k2) - new_dict[key] = op(D1[k1],D2[k2]) + key = op_key(k1, k2) + new_dict[key] = op(D1[k1], D2[k2]) return new_dict -def spe_zip(l1,l2): + +def spe_zip(l1, l2): """Zip two lists, if a list is longer, only it's element are taken >>> spe_zip([1,2], [3,4]) @@ -248,16 +256,17 @@ def spe_zip(l1,l2): >>> spe_zip([1,2], [3,4,5]) [[1, 3], [2, 4], 5] """ - tmp = list(zip_longest(l1,l2)) + tmp = list(zip_longest(l1, l2)) ans = [] for i in tmp: if None in i: - j = [a for a in i if a != None][-1] + j = [a for a in i if a is not None][-1] else: j = list(i) ans.append(j) return ans + def transpose_fill(list_lists): """Transpose a list of list and if inside list have not the same length, fill with last token @@ -277,6 +286,7 @@ def transpose_fill(list_lists): yield col + def isOperator(exp): """Check if the expression is an opération in "+-*/:^" @@ -285,13 +295,14 @@ def isOperator(exp): """ - #return (type(exp) == str and exp in "+-*/:^") + # return (type(exp) == str and exp in "+-*/:^") try: exp.isOperator except AttributeError: return 0 return 1 + def isNumber(exp): """Check if the expression can be a number @@ -302,11 +313,12 @@ def isNumber(exp): try: exp.isNumber except AttributeError: - if type(exp) == int: + if isinstance(exp, int): return 1 else: return 0 - return 1 + return 1 + def isPolynom(exp): """Check if the expression can be a polynom @@ -328,7 +340,8 @@ def isPolynom(exp): exp._isPolynom except AttributeError: return 0 - return 1 + return 1 + def isNumerand(exp): """Check is the expression is something we can compute with diff --git a/pymath/calculus/polynom.py b/pymath/calculus/polynom.py index c59d5eb..c0d43d2 100644 --- a/pymath/calculus/polynom.py +++ b/pymath/calculus/polynom.py @@ -13,17 +13,18 @@ import inspect __all__ = ["Polynom"] + def polynom_factory(func): """ Decorator which specify the type of polynom that the function returns """ @wraps(func) def wrapper(*args, **kwrds): P = func(*args, **kwrds) - if issubclass(type(P),AbstractPolynom) and P.degree == 2: + if issubclass(type(P), AbstractPolynom) and P.degree == 2: from .polynomDeg2 import Polynom_deg2 new_P = Polynom_deg2(poly=P) new_P.steps = P.steps return new_P - elif issubclass(type(P),AbstractPolynom): + elif issubclass(type(P), AbstractPolynom): new_P = Polynom(poly=P) new_P.steps = P.steps return new_P @@ -31,6 +32,7 @@ def polynom_factory(func): return P return wrapper + class Polynom(AbstractPolynom): """Polynom view as a function. @@ -47,7 +49,13 @@ class Polynom(AbstractPolynom): """ @classmethod - def random(self, coefs_form=[], conditions=[], letter = "x", degree = 0, name = "P"): + def random( + self, + coefs_form=[], + conditions=[], + letter="x", + degree=0, + name="P"): """ Create a random polynom from coefs_form and conditions :param coefs_form: list of forms (one by coef) (ascending degree sorted) @@ -71,18 +79,18 @@ class Polynom(AbstractPolynom): """ if (degree > 0 and degree < 26): # Générer assez de lettre pour les coefs - coefs_name = map(chr, range(97, 98+degree)) + coefs_name = map(chr, range(97, 98 + degree)) coefs_form = ["{" + i + "}" for i in coefs_name][::-1] form = str(coefs_form) # On créé les valeurs toutes concaténées dans un string coefs = RdExpression(form, conditions)() # On "parse" ce string pour créer les coefs - coefs = [eval(i) if type(i)==str else i for i in eval(coefs)] + coefs = [eval(i) if isinstance(i, str) else i for i in eval(coefs)] # Création du polynom - return Polynom(coefs = coefs, letter = letter, name = name) + return Polynom(coefs=coefs, letter=letter, name=name) - def __init__(self, coefs = [1], letter = "x", name = "P", poly = 0): + def __init__(self, coefs=[1], letter="x", name="P", poly=0): """Initiate the polynom :param coef: coefficients of the polynom (ascending degree sorted) @@ -138,10 +146,11 @@ class Polynom(AbstractPolynom): 3 h^{ 2 } + 8 h + 6 >>> R = P(Q) """ - #if isNumerand(value) or Expression.isExpression(value): + # if isNumerand(value) or Expression.isExpression(value): # postfix_exp = [value if i==self._letter else i for i in self.postfix_tokens] - #else: - postfix_exp = [Expression(value) if i==self._letter else i for i in self.postfix_tokens] + # else: + postfix_exp = [ + Expression(value) if i == self._letter else i for i in self.postfix_tokens] return Expression(postfix_exp).simplify() @@ -160,7 +169,7 @@ class Polynom(AbstractPolynom): 6 x + 2 """ derv_coefs = [] - for (i,c) in enumerate(self._coef): + for (i, c) in enumerate(self._coef): derv_coefs += [Expression([i, c, op.mul])] ans = Polynom(derv_coefs[1:]).simplify() @@ -169,8 +178,8 @@ class Polynom(AbstractPolynom): # Decorate methods which may return Polynoms methods_list = ["__add__", "__call__", "__mul__", "__neg__", "__pow__", - "__radd__", "__rmul__", "__rsub__", "__sub__", "derivate", - "reduce", "simplify", "random"] + "__radd__", "__rmul__", "__rsub__", "__sub__", "derivate", + "reduce", "simplify", "random"] for name, func in inspect.getmembers(Polynom): if name in methods_list: setattr(Polynom, name, polynom_factory(func)) @@ -178,7 +187,7 @@ for name, func in inspect.getmembers(Polynom): if __name__ == '__main__': #from .fraction import Fraction - #with Expression.tmp_render(txt): + # with Expression.tmp_render(txt): # p = Polynom([1, 2, 3]) # q = Polynom([4, 5, 6]) # for i in (p*q).explain(): @@ -194,27 +203,28 @@ if __name__ == '__main__': # print(p-q) # for i in p-q: # print(i) - #Polynom.random(degree = 2, conditions=["{b**2-4*a*c}>0"]) # Polynom deg 2 with positive Delta (ax^2 + bx + c) + # Polynom.random(degree = 2, conditions=["{b**2-4*a*c}>0"]) # Polynom deg + # 2 with positive Delta (ax^2 + bx + c) #import doctest - #doctest.testmod(optionflags=doctest.ELLIPSIS) + # doctest.testmod(optionflags=doctest.ELLIPSIS) -# while True: -# P = Polynom.random(degree = 2) -# e = Expression.random("{a}/{b}") -# try: -# P(e) -# except RuntimeError: -# print(" P -> " + str(P)) -# print(" e -> " + str(e)) -# -# import sys -# sys.setrecursionlimit(100) + # while True: + # P = Polynom.random(degree = 2) + # e = Expression.random("{a}/{b}") + # try: + # P(e) + # except RuntimeError: + # print(" P -> " + str(P)) + # print(" e -> " + str(e)) + # + # import sys + # sys.setrecursionlimit(100) from .fraction import Fraction from itertools import permutations - P = Polynom([-5,6,-4]) - f = Fraction(2,5) + P = Polynom([-5, 6, -4]) + f = Fraction(2, 5) P(f) try: P(f) @@ -222,15 +232,15 @@ if __name__ == '__main__': print(e) print("-----------------\n") - f = Fraction(2,15) - print(str(P).replace('x','('+str(f)+')'),"= ", P(f)) + f = Fraction(2, 15) + print(str(P).replace('x', '(' + str(f) + ')'), "= ", P(f)) print("-----------------\n") - f = Fraction(2,3) + f = Fraction(2, 3) print(P(f)) #coefs_p = [[(i-2),(j-2)] for i,j in permutations(range(20),2)] #fractions = [Fraction(i,j) for i,j in coefs_p if j!=0] - #for f in fractions: + # for f in fractions: # try: # P(f) # #print("ok f -> " + str(f)) diff --git a/pymath/calculus/polynomDeg2.py b/pymath/calculus/polynomDeg2.py index 9773f47..c059e67 100644 --- a/pymath/calculus/polynomDeg2.py +++ b/pymath/calculus/polynomDeg2.py @@ -8,10 +8,11 @@ from .operator import op from .random_expression import RdExpression from sympy import sqrt, latex -#from sympy.fractions import Fraction as sp.Fraction +# from sympy.fractions import Fraction as sp.Fraction __all__ = ["Polynom_deg2"] + class Polynom_deg2(Polynom): """ Degree 2 polynoms @@ -19,7 +20,15 @@ class Polynom_deg2(Polynom): """ @classmethod - def random(self, coefs_form = ["{c}", "{b}", "{a}"], conditions = [], letter = "x", name = "P"): + def random( + self, + coefs_form=[ + "{c}", + "{b}", + "{a}"], + conditions=[], + letter="x", + name="P"): """ Create a 2nd degree poly from coefs_form ans conditions :param coefs_form: list of forms (one by coef) (ascending degree sorted) @@ -28,27 +37,32 @@ class Polynom_deg2(Polynom): """ if len(coefs_form) != 3: - raise ValueError("Polynom_deg2 have to be degree 2 polynoms, they need 3 coefficients, {} are given".format(len(coefs_form))) + raise ValueError( + "Polynom_deg2 have to be degree 2 polynoms, they need 3 coefficients, {} are given".format( + len(coefs_form))) form = str(coefs_form) # On créé les valeurs toutes concaténées dans un string coefs = RdExpression(form, conditions)() # On "parse" ce string pour créer les coefs - coefs = [eval(i) if type(i)==str else i for i in eval(coefs)] + coefs = [eval(i) if isinstance(i, str) else i for i in eval(coefs)] # Création du polynom - return Polynom_deg2(coefs = coefs, letter = letter, name = name) + return Polynom_deg2(coefs=coefs, letter=letter, name=name) - def __init__(self, coefs = [0, 0, 1], letter = "x", name = "P", poly = 0): + def __init__(self, coefs=[0, 0, 1], letter="x", name="P", poly=0): if poly: coefs = poly._coef letter = poly._letter name = poly.name if len(coefs) < 3 or len(coefs) > 4: - raise ValueError("Polynom_deg2 have to be degree 2 polynoms, they need 3 coefficients, {} are given".format(len(coefs))) + raise ValueError( + "Polynom_deg2 have to be degree 2 polynoms, they need 3 coefficients, {} are given".format( + len(coefs))) if coefs[2] == 0: - raise ValueError("Polynom_deg2 have to be degree 2 polynoms, coefficient of x^2 can't be 0") - Polynom.__init__(self, coefs, letter, name = name) + raise ValueError( + "Polynom_deg2 have to be degree 2 polynoms, coefficient of x^2 can't be 0") + Polynom.__init__(self, coefs, letter, name=name) @property def a(self): @@ -78,7 +92,8 @@ class Polynom_deg2(Polynom): -8 """ - return Expression([self.b, 2, op.pw, 4, self.a, self.c, op.mul, op.mul, op.sub]).simplify() + return Expression([self.b, 2, op.pw, 4, self.a, + self.c, op.mul, op.mul, op.sub]).simplify() @property def alpha(self): @@ -94,7 +109,8 @@ class Polynom_deg2(Polynom): \\frac{ -1 \\times 2 }{ 3 \\times 2 } \\frac{ -1 }{ 3 } """ - return Expression([self.b, op.sub1, 2, self.a, op.mul, op.div]).simplify() + return Expression([self.b, op.sub1, 2, self.a, + op.mul, op.div]).simplify() @property def beta(self): @@ -124,7 +140,7 @@ class Polynom_deg2(Polynom): """ return self(self.alpha) - def roots(self, after_coma = 2): + def roots(self, after_coma=2): """ Compute roots of the polynom /!\ Can't manage nice rendering because of sqrt. @@ -146,9 +162,10 @@ class Polynom_deg2(Polynom): ['-2 - \\\\sqrt{3}', '-2 + \\\\sqrt{3}'] """ if self.delta > 0: - self._roots = [latex((-self.b - sqrt(self.delta))/(2*self.a)), latex((-self.b + sqrt(self.delta))/(2*self.a))] + self._roots = [latex((-self.b - sqrt(self.delta)) / (2 * self.a)), + latex((-self.b + sqrt(self.delta)) / (2 * self.a))] elif self.delta == 0: - self._roots = [Fraction(-self.b,2*self.a).simplify()] + self._roots = [Fraction(-self.b, 2 * self.a).simplify()] else: self._roots = [] return self._roots @@ -156,11 +173,12 @@ class Polynom_deg2(Polynom): def tbl_sgn_header(self): """ Return header of the sign line for tkzTabLine""" if self.delta > 0: - return "{$-\\infty$, $" + str(min(self.roots())) + "$ , $" + str( max(self.roots())) + "$ , $+\\infty$}" + return "{$-\\infty$, $" + str(min(self.roots())) + \ + "$ , $" + str(max(self.roots())) + "$ , $+\\infty$}" elif self.delta == 0: - return "{$-\\infty$, $" + str(self.roots()[0]) + "$ , $+\\infty$}" + return "{$-\\infty$, $" + str(self.roots()[0]) + "$ , $+\\infty$}" else: - return "{$-\\infty$, $+\\infty$}" + return "{$-\\infty$, $+\\infty$}" def tbl_sgn(self): """ Return the sign line for tkzTabLine @@ -200,7 +218,7 @@ class Polynom_deg2(Polynom): else: return "\\tkzTabLine{, -,}" - def tbl_variation(self, limits = False): + def tbl_variation(self, limits=False): """Return the variation line for tkzTabVar :param limit: Display or not limits in tabular @@ -215,9 +233,11 @@ class Polynom_deg2(Polynom): beta = self.beta if limits: if self.a > 0: - return "\\tkzTabVar{+/{$+\\infty$}, -/{$" + str(beta) + "$}, +/{$+\\infty$}}" + return "\\tkzTabVar{+/{$+\\infty$}, -/{$" + \ + str(beta) + "$}, +/{$+\\infty$}}" else: - return "\\tkzTabVar{-/{$-\\infty$}, +/{$" + str(beta) + "$}, -/{$-\\infty$}}" + return "\\tkzTabVar{-/{$-\\infty$}, +/{$" + \ + str(beta) + "$}, -/{$-\\infty$}}" else: if self.a > 0: return "\\tkzTabVar{+/{}, -/{$" + str(beta) + "$}, +/{}}" @@ -227,7 +247,7 @@ class Polynom_deg2(Polynom): if __name__ == '__main__': #from .render import txt - #with Expression.tmp_render(txt): + # with Expression.tmp_render(txt): # P = Polynom_deg2([2, 3, 4]) # print(P) @@ -242,8 +262,6 @@ if __name__ == '__main__': doctest.testmod() - - # ----------------------------- # Reglages pour 'vim' # vim:set autoindent expandtab tabstop=4 shiftwidth=4: diff --git a/pymath/calculus/random_expression.py b/pymath/calculus/random_expression.py index 304e8cd..82d5c45 100644 --- a/pymath/calculus/random_expression.py +++ b/pymath/calculus/random_expression.py @@ -8,11 +8,13 @@ from .generic import flatten_list from .arithmetic import gcd -def random_str(form, conditions = [], val_min = -10, val_max = 10): + +def random_str(form, conditions=[], val_min=-10, val_max=10): """ Create a random string using RdExpression class """ random_str_generator = RdExpression(form, conditions) return random_str_generator(val_min, val_max) + class RdExpression(object): """ @@ -20,7 +22,7 @@ class RdExpression(object): """ - def __init__(self, form, conditions = []): + def __init__(self, form, conditions=[]): """Initiate the generator :param form: the form of the expression (/!\ variables need to be in brackets {}) @@ -39,16 +41,18 @@ class RdExpression(object): :returns: set for elements which have to be replaced """ - #pattern = "\{(.*?)\}" #select inside {} non greedy way + # pattern = "\{(.*?)\}" #select inside {} non greedy way #varia_form = re.findall(pattern, self._form) # TODO: Bug with varia with spaces |dim. nov. 23 10:44:34 CET 2014 - varia_form = flatten_list([eval(str(i[0])) for i in pyparsing.nestedExpr('{','}').searchString(self._form)]) + varia_form = flatten_list([eval(str(i[0])) for i in pyparsing.nestedExpr( + '{', '}').searchString(self._form)]) varia_form = set(varia_form) varia_cond = set() for c in self._conditions: - c_varia_cond = flatten_list([eval(str(i[0])) for i in pyparsing.nestedExpr('{','}').searchString(c)]) + c_varia_cond = flatten_list( + [eval(str(i[0])) for i in pyparsing.nestedExpr('{', '}').searchString(c)]) varia_cond = varia_cond | set(c_varia_cond) self._2replaced = varia_cond | varia_form @@ -81,11 +85,11 @@ class RdExpression(object): new_form = form while "_" in new_form: i += 1 - new_form = new_form.replace("_", "{"+chr(i)+"}",1) + new_form = new_form.replace("_", "{" + chr(i) + "}", 1) return new_form - def __call__(self, val_min = -10, val_max = 10): + def __call__(self, val_min=-10, val_max=10): """RdExpression once it is initiate act like a function which create random expressions. :param val_min: minimum value random generation @@ -95,7 +99,7 @@ class RdExpression(object): """ return self.raw_str(val_min, val_max) - def raw_str(self, val_min = -10, val_max = 10): + def raw_str(self, val_min=-10, val_max=10): """Return raw string (don't use Expression for rendering or parsing) :param val_min: minimum value random generation @@ -112,7 +116,7 @@ class RdExpression(object): return exp - def gene_varia(self, val_min = -10, val_max = 10): + def gene_varia(self, val_min=-10, val_max=10): """Randomly generates variables/letters Varia can't be equal to 0 @@ -123,7 +127,6 @@ class RdExpression(object): while self._gene_varia[l] == 0: self._gene_varia[l] = randint(val_min, val_max) - for e in self._2replaced: self._gene_2replaced[e] = eval(e, globals(), self._gene_varia) @@ -133,18 +136,22 @@ class RdExpression(object): """ if self._conditions != []: - return eval(" and ".join(self._conditions).format(**self._gene_2replaced)) + return eval( + " and ".join( + self._conditions).format( + **self._gene_2replaced)) else: return True + def desc_rdExp(rdExp): print("--------------------") - print("form: ",rdExp._form) - print("Conditions: ",rdExp._conditions) + print("form: ", rdExp._form) + print("Conditions: ", rdExp._conditions) print("Letters: ", rdExp._letters) print("2replaced: ", rdExp._2replaced) print("Call : ", rdExp()) - print("type: ",type(rdExp())) + print("type: ", type(rdExp())) print("Gene varia: ", rdExp._gene_varia) print("Gene 2replaced: ", rdExp._gene_2replaced) print('') @@ -156,18 +163,25 @@ if __name__ == '__main__': print(random_str(form, cond)) form = "{a+a*10}*4 + {a} + 2*{b}" - cond = ["{a} + {b} in [1, 2, 3, 4, 5]", "abs({a}) not in [1]", "{b} not in [1]", "gcd({a},{b}) == 1"] + cond = [ + "{a} + {b} in [1, 2, 3, 4, 5]", + "abs({a}) not in [1]", + "{b} not in [1]", + "gcd({a},{b}) == 1"] print(random_str(form, cond)) form = "{a+a*10}*4 + {a} + 2*{b}" - cond = ["{a-b} + {b} in list(range(20))", "abs({a}) not in [1]", "{b} not in [1]", "gcd({a},{b}) == 1"] + cond = [ + "{a-b} + {b} in list(range(20))", + "abs({a}) not in [1]", + "{b} not in [1]", + "gcd({a},{b}) == 1"] print(random_str(form, cond)) import doctest doctest.testmod() - # ----------------------------- # Reglages pour 'vim' # vim:set autoindent expandtab tabstop=4 shiftwidth=4: diff --git a/pymath/calculus/render.py b/pymath/calculus/render.py index 138124a..786b995 100644 --- a/pymath/calculus/render.py +++ b/pymath/calculus/render.py @@ -1,10 +1,11 @@ #!/usr/bin/env python # encoding: utf-8 -from .generic import Stack,isOperator +from .generic import Stack, isOperator __all__ = ['txt', 'tex', 'p2i'] + class Render(object): """ Create functions which know how to render postfix tokens lists """ @@ -15,7 +16,6 @@ class Render(object): """ self.render = render - def __call__(self, postfix_tokens): """Make the object acting like a function @@ -45,6 +45,7 @@ class Render(object): else: return operandeStack.pop() + def txt_render(token): def render(*args): try: @@ -54,6 +55,8 @@ def txt_render(token): return render txt = Render(txt_render) + + def tex_render(token): def render(*args): try: @@ -63,6 +66,7 @@ def tex_render(token): return render tex = Render(tex_render) + def p2i_render(token): def render(*args): try: @@ -78,18 +82,17 @@ if __name__ == '__main__': from pymath import Polynom from pymath import Expression from pymath import Fraction - coefs_p = [[(i-2),(j-2)] for i,j in permutations(range(5),2)] - coefs_q = [[2*(i-2),2*(j-2)] for i,j in permutations(range(5),2)] + coefs_p = [[(i - 2), (j - 2)] for i, j in permutations(range(5), 2)] + coefs_q = [[2 * (i - 2), 2 * (j - 2)] + for i, j in permutations(range(5), 2)] l_p = [Polynom(i) for i in coefs_p] - l_q = [Fraction(i,j) for i,j in coefs_q if j!=0] - operations = [Expression([l_p[i],l_q[j],op.mul]) for i,j in permutations(range(len(l_q)),2)] + l_q = [Fraction(i, j) for i, j in coefs_q if j != 0] + operations = [Expression([l_p[i], l_q[j], op.mul]) + for i, j in permutations(range(len(l_q)), 2)] for i in operations: print(i) - - - # ----------------------------- # Reglages pour 'vim' # vim:set autoindent expandtab tabstop=4 shiftwidth=4: diff --git a/pymath/calculus/str2tokens.py b/pymath/calculus/str2tokens.py index 60316be..fd7713d 100644 --- a/pymath/calculus/str2tokens.py +++ b/pymath/calculus/str2tokens.py @@ -4,6 +4,7 @@ from .generic import Stack, isOperator, isNumber, isPolynom from .operator import op + def str2tokens(exp): """ Parse the string into tokens then turn it into postfix form @@ -19,6 +20,7 @@ def str2tokens(exp): return post_tokens + def str2in_tokens(exp): """ Parse the expression, ie tranform a string into a list of tokens @@ -37,14 +39,14 @@ def str2in_tokens(exp): for character in exp: if character.isdigit(): # for "big" numbers (like 2345) - if type(tokens[-1]) == int: + if isinstance(tokens[-1], int): if tokens[-1] > 0: - tokens[-1] = tokens[-1]*10 + int(character) + tokens[-1] = tokens[-1] * 10 + int(character) else: - tokens[-1] = tokens[-1]*10 - int(character) + tokens[-1] = tokens[-1] * 10 - int(character) - - # Special case for "-" at the begining of an expression or before "(" + # Special case for "-" at the begining of an expression or before + # "(" elif tokens[-1] == "-" and \ str(tokens[-2]) in " (+-*/:": tokens[-1] = - int(character) @@ -72,7 +74,7 @@ def str2in_tokens(exp): or isPolynom(tokens[-1]): tokens.append("*") from pymath.calculus.polynom import Polynom - tokens.append(Polynom([0,1], letter = character)) + tokens.append(Polynom([0, 1], letter=character)) elif character == ".": raise ValueError("No float number please") @@ -83,7 +85,6 @@ def str2in_tokens(exp): return tokens[1:] - def in2post_fix(infix_tokens): """ From the infix_tokens list compute the corresponding postfix_tokens list @@ -105,7 +106,7 @@ def in2post_fix(infix_tokens): arity_Stack = Stack() arity_Stack.push(0) - for (pos_token,token) in enumerate(infix_tokens): + for (pos_token, token) in enumerate(infix_tokens): # Pour voir ce qu'il se passe dans cette procédure #print(str(postfix_tokens), " | ", str(opStack), " | ", str(infix_tokens[(pos_token+1):]), " | ", str(arity_Stack)) @@ -129,9 +130,11 @@ def in2post_fix(infix_tokens): else: arity = arity_Stack.pop() token_op = op.get_op(token, arity + 1) - # Reset arity to 0 in case there is other operators (the real operation would be "-op.arity + 1") + # Reset arity to 0 in case there is other operators (the real + # operation would be "-op.arity + 1") arity_Stack.push(0) - while (not opStack.isEmpty()) and opStack.peek().priority >= token_op.priority: + while (not opStack.isEmpty()) and opStack.peek( + ).priority >= token_op.priority: next_op = opStack.pop() postfix_tokens.append(next_op) @@ -142,29 +145,30 @@ def in2post_fix(infix_tokens): arity = arity_Stack.pop() arity_Stack.push(arity + 1) - ## Pour voir ce qu'il se passe dans cette procédure + # Pour voir ce qu'il se passe dans cette procédure #print(str(postfix_tokens), " | ", str(opStack), " | ", str(infix_tokens[(pos_token+1):]), " | ", str(arity_Stack)) while not opStack.isEmpty(): next_op = opStack.pop() postfix_tokens.append(next_op) - ## Pour voir ce qu'il se passe dans cette procédure + # Pour voir ce qu'il se passe dans cette procédure #print(str(postfix_tokens), " | ", str(opStack), " | ", str(infix_tokens[(pos_token+1):]), " | ", str(arity_Stack)) if arity_Stack.peek() != 1: - raise ValueError("Unvalid expression. The arity Stack is ", str(arity_Stack)) + raise ValueError( + "Unvalid expression. The arity Stack is ", + str(arity_Stack)) return postfix_tokens - if __name__ == '__main__': #a, s, m, d, p = Operator("+"), Operator("-"), Operator("*"), Operator("/"), Operator("^") #in_tokens = str2in_tokens("2+3*4") #print("\t in_tokens :" + str(in_tokens)) # - #print(in2post_fix(in_tokens)) + # print(in2post_fix(in_tokens)) #print(in2post_fix([op.par, 2, op.add, 5, op.sub, 1, ')', op.div, op.par, 3, op.mul, 4, ')'])) #print(in2post_fix([op.sub1, op.par, op.sub1, 2, ')'])) @@ -179,7 +183,7 @@ if __name__ == '__main__': print(str2tokens('x(2+1)+4')) print("\n------") #import doctest - #doctest.testmod() + # doctest.testmod() # ----------------------------- diff --git a/pymath/stat/dataset.py b/pymath/stat/dataset.py index 4d6b8f6..59de98e 100644 --- a/pymath/stat/dataset.py +++ b/pymath/stat/dataset.py @@ -7,12 +7,14 @@ # # -# TODO: Rendre toutes les réponses Explicable!! |mar. janv. 12 09:41:00 EAT 2016 +# TODO: Rendre toutes les réponses Explicable!! |mar. janv. 12 09:41:00 +# EAT 2016 from math import sqrt, ceil from .number_tools import number_factory from .random_generator import random_generator + class Dataset(list): """ A dataset (a list) with statistics and latex rendering methods @@ -30,11 +32,11 @@ class Dataset(list): """ @classmethod - def random(cls, length, data_name = "Valeurs", \ - distrib = "gauss", rd_args = (0,1), \ - nbr_format = lambda x:round(x,2), \ - v_min = None, v_max = None, \ - exact_mean = None): + def random(cls, length, data_name="Valeurs", + distrib="gauss", rd_args=(0, 1), + nbr_format=lambda x: round(x, 2), + v_min=None, v_max=None, + exact_mean=None): """ Generate a random list of value :param length: length of the dataset @@ -45,15 +47,15 @@ class Dataset(list): :param v_max: maximum accepted value :param exact_mean: if set, the last generated number will be create in order that the computed mean is exacly equal to "exact_mean" """ - data = random_generator(length,\ - distrib, rd_args, \ - nbr_format, \ - v_min, v_max, \ - exact_mean) + data = random_generator(length, + distrib, rd_args, + nbr_format, + v_min, v_max, + exact_mean) - return cls(data, data_name = data_name) + return cls(data, data_name=data_name) - def __init__(self, data = [], data_name = "Valeurs"): + def __init__(self, data=[], data_name="Valeurs"): """ Create a numeric data set @@ -86,7 +88,7 @@ class Dataset(list): @number_factory def mean(self): - return self.sum()/self.effectif_total() + return self.sum() / self.effectif_total() @number_factory def deviation(self): @@ -96,7 +98,7 @@ class Dataset(list): @number_factory def variance(self): - return self.deviation()/self.effectif_total() + return self.deviation() / self.effectif_total() @number_factory def sd(self): @@ -113,10 +115,15 @@ class Dataset(list): >>> w.quartiles() (0, 2.5, 5.5, 8.5, 11) """ - return (min(self) , self.quartile(1) , self.quartile(2) , self.quartile(3), max(self)) + return ( + min(self), + self.quartile(1), + self.quartile(2), + self.quartile(3), + max(self)) @number_factory - def quartile(self, quartile = 1): + def quartile(self, quartile=1): """ Calcul un quartile de la série. @@ -145,11 +152,11 @@ class Dataset(list): # -1 to match with list indexing position = self.posi_quartile(quartile) - 1 if position.is_integer(): - return (self[int(position)] + self[int(position)+1])/2 + return (self[int(position)] + self[int(position) + 1]) / 2 else: return self[ceil(position)] - def posi_quartile(self, quartile = 1): + def posi_quartile(self, quartile=1): """ Calcul la position du quartile @@ -162,20 +169,22 @@ class Dataset(list): # -------------------------- # Rendu latex - def tabular_latex(self, nbr_lines = 1): + def tabular_latex(self, nbr_lines=1): """ Latex code to display dataset as a tabular """ d_per_line = self.effectif_total() // nbr_lines d_last_line = self.effectif_total() % d_per_line - splited_data = [self[x:x+d_per_line] for x in range(0, self.effectif_total(), d_per_line)] + splited_data = [self[x:x + d_per_line] + for x in range(0, self.effectif_total(), d_per_line)] # On ajoute les éléments manquant pour la dernière line if d_last_line: - splited_data[-1] += [' ']*(d_per_line - d_last_line) + splited_data[-1] += [' '] * (d_per_line - d_last_line) # Construction du tableau - latex = "\\begin{{tabular}}{{|c|*{{{nbr_col}}}{{c|}}}} \n".format(nbr_col = d_per_line) + latex = "\\begin{{tabular}}{{|c|*{{{nbr_col}}}{{c|}}}} \n".format( + nbr_col=d_per_line) latex += "\t\t \hline \n" - d_lines = [' & '.join(map(str,l)) for l in splited_data] + d_lines = [' & '.join(map(str, l)) for l in splited_data] latex += " \\\\ \n \\hline \n".join(d_lines) latex += " \\\\ \n \\hline \n" @@ -184,9 +193,7 @@ class Dataset(list): return latex - # ----------------------------- # Reglages pour 'vim' # vim:set autoindent expandtab tabstop=4 shiftwidth=4: # cursor: 16 del - diff --git a/pymath/stat/number_tools.py b/pymath/stat/number_tools.py index 0a44c0b..3c40b81 100644 --- a/pymath/stat/number_tools.py +++ b/pymath/stat/number_tools.py @@ -19,9 +19,7 @@ def number_factory(fun): return wrapper - # ----------------------------- # Reglages pour 'vim' # vim:set autoindent expandtab tabstop=4 shiftwidth=4: # cursor: 16 del - diff --git a/pymath/stat/random_generator.py b/pymath/stat/random_generator.py index fa17c3b..10aaae3 100644 --- a/pymath/stat/random_generator.py +++ b/pymath/stat/random_generator.py @@ -4,11 +4,11 @@ from random import randint, uniform, gauss, choice -def random_generator(length,\ - distrib = gauss, rd_args = (0,1), \ - nbr_format = lambda x:round(x,2), \ - v_min = None, v_max = None, \ - exact_mean = None): +def random_generator(length, + distrib=gauss, rd_args=(0, 1), + nbr_format=lambda x: round(x, 2), + v_min=None, v_max=None, + exact_mean=None): """ Generate a random list of value :param length: length of the dataset @@ -28,22 +28,26 @@ def random_generator(length,\ """ # if exact_mean is set, we create automaticaly only length-1 value - if exact_mean != None: + if exact_mean is not None: length = length - 1 # build function to test created values - if v_min == None: + if v_min is None: v1 = lambda x: True else: v1 = lambda x: x >= v_min - if v_max == None: + if v_max is None: v2 = lambda x: True else: v2 = lambda x: x <= v_max - validate = lambda x : v1(x) and v2(x) + validate = lambda x: v1(x) and v2(x) # get distrib function - distribs = {"gauss": gauss, "uniform": uniform, "randint":randint, "choice":choice} + distribs = { + "gauss": gauss, + "uniform": uniform, + "randint": randint, + "choice": choice} try: distrib(*rd_args) except TypeError: @@ -59,10 +63,11 @@ def random_generator(length,\ data.append(v) # Build last value - if exact_mean != None: - last_v = nbr_format((length+1) * exact_mean - sum(data)) + if exact_mean is not None: + last_v = nbr_format((length + 1) * exact_mean - sum(data)) if not validate(last_v): - raise ValueError("Can't build the last value. Conflict between v_min/v_max and exact_mean") + raise ValueError( + "Can't build the last value. Conflict between v_min/v_max and exact_mean") data.append(last_v) return data @@ -71,4 +76,3 @@ def random_generator(length,\ # Reglages pour 'vim' # vim:set autoindent expandtab tabstop=4 shiftwidth=4: # cursor: 16 del - diff --git a/pymath/stat/weightedDataset.py b/pymath/stat/weightedDataset.py index 60057d6..4c45fa3 100644 --- a/pymath/stat/weightedDataset.py +++ b/pymath/stat/weightedDataset.py @@ -35,7 +35,12 @@ class WeightedDataset(dict): """ - def __init__(self, datas = [], data_name = "Valeurs", weights = [], weight_name = "Effectifs"): + def __init__( + self, + datas=[], + data_name="Valeurs", + weights=[], + weight_name="Effectifs"): """ Initiate the WeightedDataset """ @@ -45,14 +50,14 @@ class WeightedDataset(dict): if len(datas) != len(weights): raise ValueError("Datas and weights should have same length") else: - weightedDatas = {i[0]:i[1] for i in zip(datas, weights)} + weightedDatas = {i[0]: i[1] for i in zip(datas, weights)} dict.__init__(self, weightedDatas) self.data_name = data_name self.weight_name = weight_name - def add_data(self, data, weight = 1): + def add_data(self, data, weight=1): try: self[data] += weight except KeyError: @@ -68,21 +73,21 @@ class WeightedDataset(dict): @number_factory def sum(self): """ Not really a sum but the sum of the product of key and values """ - return sum([k*v for (k,v) in self.items()]) + return sum([k * v for (k, v) in self.items()]) @number_factory def mean(self): - return self.sum()/self.effectif_total() + return self.sum() / self.effectif_total() @number_factory def deviation(self): """ Compute the deviation (not normalized) """ mean = self.mean() - return sum([v*(k - mean)**2 for (k,v) in self.items()]) + return sum([v * (k - mean)**2 for (k, v) in self.items()]) @number_factory def variance(self): - return self.deviation()/self.effectif_total() + return self.deviation() / self.effectif_total() @number_factory def sd(self): @@ -103,10 +108,14 @@ class WeightedDataset(dict): (1, 3, 4, 5, 5) """ - return (min(self.keys()) , self.quartile(1) , self.quartile(2) , self.quartile(3), max(self.keys())) + return (min(self.keys()), + self.quartile(1), + self.quartile(2), + self.quartile(3), + max(self.keys())) @number_factory - def quartile(self, quartile = 1): + def quartile(self, quartile=1): """ Calcul un quartile de la série. @@ -134,13 +143,14 @@ class WeightedDataset(dict): """ # -1 to match with list indexing position = self.posi_quartile(quartile) - 1 - expanded_values = flatten_list([v*[k] for (k,v) in self.items()]) + expanded_values = flatten_list([v * [k] for (k, v) in self.items()]) if position.is_integer(): - return (expanded_values[int(position)] + expanded_values[int(position)+1])/2 + return (expanded_values[int(position)] + + expanded_values[int(position) + 1]) / 2 else: return expanded_values[ceil(position)] - def posi_quartile(self, quartile = 1): + def posi_quartile(self, quartile=1): """ Calcul la position du quartile @@ -150,21 +160,22 @@ class WeightedDataset(dict): """ return quartile * self.effectif_total() / 4 - # -------------------------- # Rendu latex def tabular_latex(self): """ Latex code to display dataset as a tabular """ - latex = "\\begin{{tabular}}{{|c|*{{{nbr_col}}}{{c|}}}} \n".format(nbr_col = len(self.keys())) + latex = "\\begin{{tabular}}{{|c|*{{{nbr_col}}}{{c|}}}} \n".format( + nbr_col=len(self.keys())) latex += "\t \hline \n" - data_line = "\t {data_name} ".format(data_name = self.data_name) - weight_line = "\t {weight_name} ".format(weight_name = self.weight_name) + data_line = "\t {data_name} ".format(data_name=self.data_name) + weight_line = "\t {weight_name} ".format(weight_name=self.weight_name) - # TODO: Il faudra trouver une solution pour le formatage des données |sam. janv. 9 13:14:26 EAT 2016 - for (v,e) in self.items(): - data_line += "& {val} ".format(val = v) - weight_line += "& {eff} ".format(eff = e) + # TODO: Il faudra trouver une solution pour le formatage des données + # |sam. janv. 9 13:14:26 EAT 2016 + for (v, e) in self.items(): + data_line += "& {val} ".format(val=v) + weight_line += "& {eff} ".format(eff=e) latex += data_line + "\\\\ \n \t \\hline \n" latex += weight_line + "\\\\ \n \t \\hline \n" @@ -177,4 +188,3 @@ class WeightedDataset(dict): # Reglages pour 'vim' # vim:set autoindent expandtab tabstop=4 shiftwidth=4: # cursor: 16 del -