Une classe pour pôlynome creux (exercice3)

March 14, 2023

[9]: class PolyCreux:

"""
Classe pour representer et manupuler des polynomes creux
"""
# Dictionnaire des coefficients
__data = {}

# Constructeur (Question 1)
def __init__ (self, poly = {}) :

if isinstance(poly, dict) :
self.__data = {k: v for k,v in poly.items() if v}

elif isinstance(poly, PolyCreux):

self.__data = poly.__data.copy()

elif isinstance(poly, list):

self.__data = {i:poly[i] for i in range(len(poly)) if poly[i]}

else :
raise TypeError("Poly ne peut pas etre de type {}".
↪format(type(poly)))

# Chaine de construction (Question 2)

def __repr__(self):
return "PolyCreux({})".format(self.__data)

# Chaine de construction (Question 3)

def degree(self):
return max(self.__data.keys()) if self.__data else None

# Ajouter des monomes (Question 4)

def ajout_monome(self, monome = {}):
if not monome :

1
 while True :
try :
coeff = float(input("Donner l ecoefficient de monome : "))
exp = int(input("Donner l'indice du coefficient : "))
if coeff !=0 and exp >=0 :
break
except ValueError :
pass

self.__data.update({exp : coeff})
else :
self.__data.update({k:v for k,v in monome.items() if v})

# Evaluer Polynome (Question 5)

def __call__(self, val):
return sum([v * val ** k for k,v in self.__data.items()])

# Addition polynome (Question 6)

def __add__(self, other):
if isinstance(other, PolyCreux):
newPoly = PolyCreux(other)
for k,v in self.__data.items() :
if not k in newPoly.__data :
newPoly.ajout_monome({k:v})
elif other.__data[k] == -v :
newPoly.__data.pop(k)
else :
newPoly.__data[k] += v
return newPoly

else :
raise TypeError("unsupported operand type(s) for +: 'PolyCreux' and␣
↪{}".format(type(other)))

# Multiplication Polynomes (Question 7)

def __mul__(self, other):
if isinstance(other, PolyCreux):
newPoly = PolyCreux()
for k1,v1 in self.__data.items():
for k2,v2 in other.__data.items():
if not k1 + k2 in newPoly.__data :
newPoly.__data[k1 + k2] = v1*v2
elif newPoly.__data[k1 + k2] == -v1*v2 :
newPoly.__data.pop(k1 + k2)
else :

2
 newPoly.__data[k1 + k2] += v1*v2
return newPoly
else :
raise TypeError("unsupported operand type(s) for *: 'PolyCreux' and␣
↪{}".format(type(other)))

# Puissance Polynome (Question 8)

def __pow__(self, other):
if isinstance(other, int):
newPoly = PolyCreux(self)
for i in range(other-1):
newPoly *= newPoly
return newPoly
else :
raise TypeError("unsupported operand type(s) for **: 'PolyCreux'␣
↪and {}".format(type(other)))

# Dérivation polynome (Question 9)

def deriv(self):
newPoly = PolyCreux()
for k,v in self.__data.items() :
if k :
newPoly.ajout_monome({k-1:k*v})
return newPoly

# égalité des polynome (Question 10)

def __eq__(self, other):
if isinstance(other, int):
pass
else :
raise TypeError("unsupported operand type(s) for ==: 'PolyCreux'␣
↪and {}".format(type(other)))

# Representation textuelle d'un polynome (Question 11)

def __str__(self):
if self.__data == {} :
return '0'
str_poly = ''
poly = list(self.__data.items())
poly.sort(reverse=True)
for i, ci in poly:
if ci == 1 :
if i == 0 :
str_poly += '+ 1'
else :

3
 str_poly += '+ X'
elif ci > 0 :
str_poly += '+ ' + str(ci) + 'X'
elif ci == -1 :
if i == 0 :
str_poly += '-1'
else:
str_poly += '- X'
else :
str_poly += str(ci) + 'X '

if i > 1 :
str_poly += '^' + str(i)
if str_poly[:2] == '+ ' :
str_poly = str_poly[2:]
return str_poly

[7]: d1 = {3:2.5, 2:0, 4:0}

p1 = PolyCreux()
p2 = PolyCreux(d1)
p3 = PolyCreux([4,0,4,0,2,0,4,1])

[8]: print("P1 = {} \nP2 = {}\nP3 = {}".format(str(p1), str(p2), str(p3)))

P1 = 0
P2 = 2.5X^3
P3 = X^7+ 4X^6+ 2X^4+ 4X^2+ 4X

[ ]:

[ ]:

[ ]:

[ ]: