#!/usr/bin/env python # encoding: utf-8 from .expression import Expression from .operator import op from .generic import spe_zip, expand_list, isNumber, transpose_fill, flatten_list, isPolynom from .render import txt from .random_expression import RdExpression from itertools import chain __all__ = ["Polynom"] def power_cache(fun): """Decorator which cache calculated powers of polynoms """ cache = {} def cached_fun(self, power): #print("cache -> ", cache) if (tuple(self._coef), power) in cache.keys(): return cache[(tuple(self._coef), power)] else: poly_powered = fun(self, power) cache[(tuple(self._coef), power)] = poly_powered return poly_powered return cached_fun class Polynom(object): """Docstring for Polynom. """ @classmethod def random(self, coefs_form=[], conditions=[], letter = "x", degree = 0): """ Create a random polynom from coefs_form and conditions :param coefs_form: list of forms (one by coef) (ascending degree sorted) :param conditions: condition on variables :param letter: the letter for the polynom :param degree: degree of the polynom (can't be used with coefs_form, it will be overwrite) - can't be higher than 26 (number of letters in alphabet) /!\ variables need to be in brackets {} >>> Polynom.random(["{b}", "{a}"]) # doctest:+ELLIPSIS ... >>> Polynom.random(degree = 2) # doctest:+ELLIPSIS ... >>> Polynom.random(degree = 2, conditions=["{b**2-4*a*c}>0"]) # Polynom deg 2 with positive Delta (ax^2 + bx + c) ... >>> Polynom.random(["{c}", "{b}", "{a}"], conditions=["{b**2-4*a*c}>0"]) # Same as above ... """ if (degree > 0 and degree < 26): # Générer assez de lettre pour les coefs coefs_name = map(chr, range(97, 98+degree)) coefs_form = ["{" + i + "}" for i in coefs_name].reverse() 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)] # Création du polynom return Polynom(coef = coefs, letter = letter) def __init__(self, coef = [1], letter = "x" ): """Initiate the polynom :param coef: coefficients of the polynom (ascending degree sorted) 3 possibles type of coefficent: - a : simple "number". [1,2] designate 1 + 2x - [a,b,c]: list of coeficient for same degree. [1,[2,3],4] designate 1 + 2x + 3x + 4x^2 - a: a Expression. [1, Expression("2+3"), 4] designate 1 + (2+3)x + 4x^2 :param letter: the string describing the unknown >>> Polynom([1,2,3]).mainOp '+' >>> Polynom([1]).mainOp '*' >>> Polynom([1,2, 3])._letter 'x' >>> Polynom([1, 2, 3], "y")._letter 'y' """ self.feed_coef(coef) self._letter = letter if self.is_monom(): self.mainOp = "*" else: self.mainOp = "+" self._isPolynom = 1 def __call__(self, value): """ Evaluate the polynom in value :returns: Expression ready to be simplify """ if isNumber(value): postfix_exp = [value if i==self._letter else i for i in self.postfix] else: postfix_exp = [Expression(value) if i==self._letter else i for i in self.postfix] return Expression(postfix_exp) def feed_coef(self, l_coef): """Feed coef of the polynom. Manage differently whether it's a number or an expression :l_coef: list of coef """ self._coef = [] for coef in l_coef: if type(coef) == list and len(coef)==1: self._coef.append(coef[0]) else: self._coef.append(coef) @property def degree(self): """Getting the degree fo the polynom :returns: the degree of the polynom >>> Polynom([1, 2, 3]).degree 2 >>> Polynom([1]).degree 0 """ return len(self._coef) - 1 def is_monom(self): """is the polynom a monom (only one coefficent) :returns: 1 if yes 0 otherwise >>> Polynom([1, 2, 3]).is_monom() 0 >>> Polynom([1]).is_monom() 1 """ if len([i for i in self._coef if i != 0])==1: return 1 else: return 0 def __str__(self): return str(Expression(self.postfix)) def __repr__(self): return "< Polynom " + str(self._coef) + ">" def coef_postfix(self, a, i): """Return the postfix display of a coeficient :param a: value for the coeficient (/!\ as a postfix list) :param i: power :returns: postfix tokens of coef >>> p = Polynom() >>> p.coef_postfix([3],2) [3, 'x', 2, '^', '*'] >>> p.coef_postfix([0],1) [] >>> p.coef_postfix([3],0) [3] >>> p.coef_postfix([3],1) [3, 'x', '*'] >>> p.coef_postfix([1],1) ['x'] >>> p.coef_postfix([1],2) ['x', 2, '^'] """ # TODO: Couille certaine avec txt à qui il fait donner des opérateurs tout beau! |mar. nov. 11 13:08:35 CET 2014 ans =[] if a == [0]: pass elif i == 0: ans = a elif i == 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]) return ans @property def postfix(self): """Return the postfix form of the polynom :returns: the postfix list of polynom's tokens >>> p = Polynom([1, 2]) >>> p.postfix [2, 'x', '*', 1, '+'] >>> p = Polynom([1, -2]) >>> p.postfix [2, 'x', '*', '-', 1, '+'] >>> p = Polynom([1,2,3]) >>> p.postfix [3, 'x', 2, '^', '*', 2, 'x', '*', '+', 1, '+'] >>> p = Polynom([1,[2,3]]) >>> p.postfix [2, 'x', '*', 3, 'x', '*', '+', 1, '+'] >>> p = Polynom([1,[2,-3]]) >>> p.postfix [2, 'x', '*', 3, 'x', '*', '-', 1, '+'] >>> p = Polynom([1,[-2,-3]]) >>> p.postfix [2, 'x', '*', '-', 3, 'x', '*', '-', 1, '+'] >>> from pymath.expression import Expression >>> from pymath.operator import op >>> e = Expression([2,3,op.add]) >>> p = Polynom([1,e]) >>> p.postfix [2, 3, '+', 'x', '*', 1, '+'] """ # 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]: operator = [op.add] operator_sub1 = [] if type(a) == Expression: # case coef is an arithmetic expression c = self.coef_postfix(a.postfix_tokens,i) if c != []: postfix.append(c) if len(postfix) > 1: postfix += operator elif type(a) == list: # case need to repeat the x^i for b in a: operator = [op.add] operator_sub1 = [] if len(postfix) == 0 and isNumber(b) and b < 0: try: b = [(-b)[-1]] except TypeError: b = [-b] operator_sub1 = [op.sub1] elif len(postfix) > 0 and isNumber(b) and b < 0: try: b = [(-b)[-1]] except TypeError: b = [-b] operator = [op.sub] else: b = [b] c = self.coef_postfix(b,i) if c != []: postfix.append(c) if len(postfix) > 1: postfix += operator_sub1 postfix += operator postfix += operator_sub1 elif a != 0: if len(postfix) == 0 and a < 0: try: a = [(-a)[-1]] except TypeError: a = [-a] operator_sub1 = [op.sub1] elif len(postfix) > 0 and a < 0: try: a = [(-a)[-1]] except TypeError: a = [-a] operator = [op.sub] else: a = [a] c = self.coef_postfix(a,i) if c != []: postfix.append(c) if len(postfix) > 1: postfix += operator_sub1 postfix += operator postfix += operator_sub1 return flatten_list(postfix) def conv2poly(self, other): """Convert anything number into a polynom""" if isNumber(other) and not isPolynom(other): return Polynom([other], letter = self._letter) elif isPolynom(other): return other else: raise ValueError(type(other) + " can't be converted into a polynom") def reduce(self): """Compute coefficients which have same degree :returns: new Polynom with numbers coefficients """ steps = [] # gather steps for every coeficients coefs_steps = [] for coef in self._coef: coef_steps = [] if type(coef) == list: # On converti en postfix avec une addition postfix_add = self.postfix_add([i for i in coef if i!=0]) # On converti en Expression coef_exp = Expression(postfix_add) with Expression.tmp_render(): coef_steps = list(coef_exp.simplify()) #print('\t 1.coef_steps -> ', coef_steps) elif type(coef) == Expression: with Expression.tmp_render(): coef_steps = list(coef.simplify()) #print('\t 2.coef_steps -> ', coef_steps) else: try: coef_steps += coef.simplify() except AttributeError: coef_steps = [coef] #print('\t 3.coef_steps -> ', coef_steps) # On ajoute toutes ces étapes coefs_steps.append(coef_steps) #print('\t coefs_steps -> ', coefs_steps) # On retourne la matrice ans = [] for coefs in transpose_fill(coefs_steps): ans.append(Polynom(coefs, self._letter)) return ans @staticmethod def postfix_add(numbers): """Convert a list of numbers into a postfix addition :numbers: list of numbers :returns: Postfix list of succecive attition of number >>> Polynom.postfix_add([1]) [1] >>> Polynom.postfix_add([1, 2]) [1, 2, '+'] >>> Polynom.postfix_add([1, 2, 3]) [1, 2, '+', 3, '+'] >>> Polynom.postfix_add(1) [1] """ if not type(numbers) == list: return [numbers] else: ans = [[a, op.add] if i!=0 else [a] for (i,a) in enumerate(numbers)] return list(chain.from_iterable(ans)) def simplify(self): """Same as reduce """ return self.reduce() def __eq__(self, other): try: o_poly = self.conv2poly(other) return self._coef == o_poly._coef except TypeError: return 0 def __add__(self, other): steps = [] o_poly = self.conv2poly(other) n_coef = spe_zip(self._coef, o_poly._coef) p = Polynom(n_coef, letter = self._letter) steps.append(p) steps += p.simplify() return steps def __radd__(self, other): return self.__add__(other) def __neg__(self): return Polynom([-i for i in self._coef], letter = self._letter) def __sub__(self, other): o_poly = self.conv2poly(other) o_poly = -o_poly return self.__add__(o_poly) def __rsub__(self, other): o_poly = self.conv2poly(other) return o_poly.__sub__(-self) def __mul__(self, other): """ Overload * >>> p = Polynom([1,2]) >>> p*3 [< Polynom [3, < Expression [2, 3, '*']>]>, < Polynom [3, < Expression [2, 3, '*']>]>, < Polynom [3, 6]>] >>> q = Polynom([0,0,4]) >>> q*3 [< Polynom [0, 0, < Expression [4, 3, '*']>]>, < Polynom [0, 0, < Expression [4, 3, '*']>]>, < Polynom [0, 0, 12]>] >>> r = Polynom([0,1]) >>> r*3 [< Polynom [0, 3]>, < Polynom [0, 3]>] >>> p*q [< Polynom [0, 0, 4, < Expression [2, 4, '*']>]>, < Polynom [0, 0, 4, < Expression [2, 4, '*']>]>, < Polynom [0, 0, 4, 8]>] >>> p*r [< Polynom [0, 1, 2]>, < Polynom [0, 1, 2]>] """ steps = [] o_poly = self.conv2poly(other) coefs = [] 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: elem = b elif b==1: elem = a else: elem = Expression([a, b, op.mul]) try: if coefs[i+j]==0: coefs[i+j] = elem elif elem != 0: coefs[i+j] = [coefs[i+j], elem] except IndexError: coefs.append(elem) p = Polynom(coefs, letter = self._letter) steps.append(p) steps += p.simplify() #print("steps -> \n", "\n".join(["\t {}".format(s.postfix) for s in steps])) return steps def __rmul__(self, other): o_poly = self.conv2poly(other) return o_poly.__mul__(self) @power_cache def __pow__(self, power): """ Overload ** >>> p = Polynom([0,0,3]) >>> p**2 [< Polynom [0, 0, 0, 0, < Expression [3, 2, '^']>]>, < Polynom [0, 0, 0, 0, < Expression [3, 2, '^']>]>, < Polynom [0, 0, 0, 0, 9]>, < Polynom [0, 0, 0, 0, 9]>] >>> p = Polynom([1,2]) >>> p**2 [[< Polynom [1, 2]>, < Polynom [1, 2]>, '*'], < Polynom [< Expression [1, 1, '*']>, [< Expression [1, 2, '*']>, < Expression [2, 1, '*']>], < Expression [2, 2, '*']>]>, < Polynom [< Expression [1, 1, '*']>, < Expression [1, 2, '*', 2, 1, '*', '+']>, < Expression [2, 2, '*']>]>, < Polynom [1, < Expression [2, 2, '+']>, 4]>, < Polynom [1, 4, 4]>] >>> p = Polynom([0,0,1]) >>> p**3 [< Polynom [0, 0, 0, 0, 0, 0, 1]>] """ if not type(power): raise ValueError("Can't raise Polynom to {} power".format(str(power))) steps = [] if self.is_monom(): if self._coef[self.degree] == 1: coefs = [0]*self.degree*power + [1] p = Polynom(coefs, letter = self._letter) steps.append(p) else: coefs = [0]*self.degree*power + [Expression([self._coef[self.degree] , power, op.pw])] p = Polynom(coefs, letter = self._letter) steps.append(p) steps += p.simplify() else: if power == 2: return [[self, self, op.mul]] + self * self else: raise AttributeError("__pw__ not implemented yet when power is greatter than 2") return steps def __xor__(self, power): return self.__pow__(power) def test(p,q): print("---------------------") print("---------------------") print("p : ",p) print("q : ",q) print("\n Plus ------") print(p, "+", q) for i in (p + q): #print(repr(i)) #print("\t", str(i.postfix)) print(i) print("\n Moins ------") for i in (p - q): #print(repr(i)) #print("\t", str(i.postfix)) print(i) print("\n Multiplier ------") for i in (p * q): #print(repr(i)) #print("\t", str(i.postfix)) print(i) print("\n Evaluer p ------") for i in p(3).simplify(): print(i) print("\n Evaluer q ------") for i in q(3).simplify(): print(i) if __name__ == '__main__': #from .fraction import Fraction with Expression.tmp_render(txt): p = Polynom([10, -5]) q = Polynom([3, -9]) print(p-q) for i in p-q: print(i) import doctest doctest.testmod() # ----------------------------- # Reglages pour 'vim' # vim:set autoindent expandtab tabstop=4 shiftwidth=4: # cursor: 16 del