single_indeterminate_operations.py

"""

This module implements a single indeterminate polynomials class
with some basic operations

Reference: https://en.wikipedia.org/wiki/Polynomial

"""

from __future__ importannotations

fromcollections.abcimportMutableSequence


classPolynomial:
def__init__(self, degree: int, coefficients: MutableSequence[float]) ->None:
"""
 The coefficients should be in order of degree, from smallest to largest.
 >>> p = Polynomial(2, [1, 2, 3])
 >>> p = Polynomial(2, [1, 2, 3, 4])
 Traceback (most recent call last):
 ...
 ValueError: The number of coefficients should be equal to the degree + 1.

 """
iflen(coefficients) !=degree+1:
raiseValueError(
"The number of coefficients should be equal to the degree + 1."
 )

self.coefficients: list[float] =list(coefficients)
self.degree=degree

def__add__(self, polynomial_2: Polynomial) ->Polynomial:
"""
 Polynomial addition
 >>> p = Polynomial(2, [1, 2, 3])
 >>> q = Polynomial(2, [1, 2, 3])
 >>> p + q
 6x^2 + 4x + 2
 """

ifself.degree>polynomial_2.degree:
coefficients=self.coefficients[:]
foriinrange(polynomial_2.degree+1):
coefficients[i] +=polynomial_2.coefficients[i]
returnPolynomial(self.degree, coefficients)
else:
coefficients=polynomial_2.coefficients[:]
foriinrange(self.degree+1):
coefficients[i] +=self.coefficients[i]
returnPolynomial(polynomial_2.degree, coefficients)

def__sub__(self, polynomial_2: Polynomial) ->Polynomial:
"""
 Polynomial subtraction
 >>> p = Polynomial(2, [1, 2, 4])
 >>> q = Polynomial(2, [1, 2, 3])
 >>> p - q
 1x^2
 """
returnself+polynomial_2*Polynomial(0, [-1])

def__neg__(self) ->Polynomial:
"""
 Polynomial negation
 >>> p = Polynomial(2, [1, 2, 3])
 >>> -p
 - 3x^2 - 2x - 1
 """
returnPolynomial(self.degree, [-cforcinself.coefficients])

def__mul__(self, polynomial_2: Polynomial) ->Polynomial:
"""
 Polynomial multiplication
 >>> p = Polynomial(2, [1, 2, 3])
 >>> q = Polynomial(2, [1, 2, 3])
 >>> p * q
 9x^4 + 12x^3 + 10x^2 + 4x + 1
 """
coefficients: list[float] = [0] * (self.degree+polynomial_2.degree+1)
foriinrange(self.degree+1):
forjinrange(polynomial_2.degree+1):
coefficients[i+j] += (
self.coefficients[i] *polynomial_2.coefficients[j]
 )

returnPolynomial(self.degree+polynomial_2.degree, coefficients)

defevaluate(self, substitution: float) ->float:
"""
 Evaluates the polynomial at x.
 >>> p = Polynomial(2, [1, 2, 3])
 >>> p.evaluate(2)
 17
 """
result: int|float=0
foriinrange(self.degree+1):
result+=self.coefficients[i] * (substitution**i)
returnresult

def__str__(self) ->str:
"""
 >>> p = Polynomial(2, [1, 2, 3])
 >>> print(p)
 3x^2 + 2x + 1
 """
polynomial=""
foriinrange(self.degree, -1, -1):
ifself.coefficients[i] ==0:
continue
elifself.coefficients[i] >0:
ifpolynomial:
polynomial+=" + "
else:
polynomial+=" - "

ifi==0:
polynomial+=str(abs(self.coefficients[i]))
elifi==1:
polynomial+=str(abs(self.coefficients[i])) +"x"
else:
polynomial+=str(abs(self.coefficients[i])) +"x^"+str(i)

returnpolynomial

def__repr__(self) ->str:
"""
 >>> p = Polynomial(2, [1, 2, 3])
 >>> p
 3x^2 + 2x + 1
 """
returnself.__str__()

defderivative(self) ->Polynomial:
"""
 Returns the derivative of the polynomial.
 >>> p = Polynomial(2, [1, 2, 3])
 >>> p.derivative()
 6x + 2
 """
coefficients: list[float] = [0] *self.degree
foriinrange(self.degree):
coefficients[i] =self.coefficients[i+1] * (i+1)
returnPolynomial(self.degree-1, coefficients)

defintegral(self, constant: float=0) ->Polynomial:
"""
 Returns the integral of the polynomial.
 >>> p = Polynomial(2, [1, 2, 3])
 >>> p.integral()
 1.0x^3 + 1.0x^2 + 1.0x
 """
coefficients: list[float] = [0] * (self.degree+2)
coefficients[0] =constant
foriinrange(self.degree+1):
coefficients[i+1] =self.coefficients[i] / (i+1)
returnPolynomial(self.degree+1, coefficients)

def__eq__(self, polynomial_2: object) ->bool:
"""
 Checks if two polynomials are equal.
 >>> p = Polynomial(2, [1, 2, 3])
 >>> q = Polynomial(2, [1, 2, 3])
 >>> p == q
 True
 """
ifnotisinstance(polynomial_2, Polynomial):
returnFalse

ifself.degree!=polynomial_2.degree:
returnFalse

foriinrange(self.degree+1):
ifself.coefficients[i] !=polynomial_2.coefficients[i]:
returnFalse

returnTrue

def__ne__(self, polynomial_2: object) ->bool:
"""
 Checks if two polynomials are not equal.
 >>> p = Polynomial(2, [1, 2, 3])
 >>> q = Polynomial(2, [1, 2, 3])
 >>> p != q
 False
 """
returnnotself.__eq__(polynomial_2)