558 lines
17 KiB
Python
558 lines
17 KiB
Python
#!/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
|