5 Best Ways to Raise a Polynomial to a Power in Python

Rate this post

πŸ’‘ Problem Formulation: In numerous scientific and engineering applications, it’s often necessary to raise a polynomial to a given power, which essentially means multiplying the polynomial by itself a specified number of times. Suppose you have a polynomial P(x) = x + 1 and want to calculate P(x)^3. This article will cover several methods to accomplish this task using Python, producing a new polynomial representing the expanded form of the original polynomial raised to the desired power.

Method 1: Using the sympy library

The sympy library is designed for symbolic mathematics and provides an intuitive API for polynomial operations. You can define polynomials and use the ** operator to raise them to a power, simplifying the result.

Here’s an example:

from sympy import symbols
from sympy.abc import x

# Define polynomial
polynomial = x + 1

# Raise to power 3
result = polynomial**3


x**3 + 3*x**2 + 3*x + 1

This code block demonstrates raising the polynomial x + 1 to the third power using sympy. It defines the polynomial using the symbolic variable x, then calculates the third power, simplifying it into a readable expanded form.

Method 2: Using the numpy library

While numpy is primarily known for numerical operations on arrays, it can also handle polynomial operations using its polynomial class. The numpy.polynomial.polynomial module offers a method to represent and manipulate polynomials efficiently.

Here’s an example:

import numpy as np

# Coefficients of polynomial x + 1
coefficients = np.array([1, 1])

# Polynomial object
poly = np.polynomial.Polynomial(coefficients)

# Raise to power 3 and get the new coefficients
raised_coeffs = np.polynomial.polynomial.polypow(coefficients, 3)


[1. 3. 3. 1.]

In this snippet, the polynomial x + 1 is represented by its coefficients in numpy. Then it uses np.polynomial.polynomial.polypow to raise it to the third power. The output is the array of coefficients representing the expanded polynomial.

Method 3: Implementing Polynomial Multiplication Manually

If you prefer a more hands-on approach or need to implement the logic without external libraries, you can manually perform polynomial multiplication. This requires a nested loop and array manipulations to account for the coefficients and exponents during multiplication.

Here’s an example:

def polynomial_power(coefficients, power):
    result = [1]
    for _ in range(power):
        result = [sum(result[i] * coefficients[j] if i - j >= 0 else 0 
                for j in range(len(coefficients))) 
                for i in range(len(result) + len(coefficients) - 1)]
    return result

coefficients = [1, 1]
result = polynomial_power(coefficients, 3)


[1, 3, 3, 1]

This manual implementation takes a list of coefficients for a polynomial and an integer power, then iteratively multiplies the polynomial by itself to raise it to the specified power. The code outputs the coefficients of the expanded polynomial.

Method 4: Using Itertools for Cartesian Product

The itertools library can be used to generate the cartesian product of sets, which translates to the combination of terms when expanding a polynomial. By combining the itertools and a custom summing function, you can compute the expanded polynomial.

Here’s an example:

from itertools import product

def polynomial_power_itertools(coefficients, power):
    terms = list(product(range(len(coefficients)), repeat=power))
    expanded_terms = [sum(term) for term in terms]
    max_power = max(expanded_terms)
    result = [0] * (max_power + 1)

    for term in terms:
        product_coefficient = 1
        for t in term:
            product_coefficient *= coefficients[t]
        result[sum(term)] += product_coefficient

    return result

coefficients = [1, 1]
result = polynomial_power_itertools(coefficients, 3)


[1, 3, 3, 1]

This code utilizes itertools.product to get all possible combinations of the indices. Each combination corresponds to a particular product of coefficients in the polynomial’s expansion. Then, these products are summed to get the coefficients of the expanded polynomial.

Bonus One-Liner Method 5: Using functools and operator

For a concise and functional approach, Python’s functools and operator modules can reduce the polynomial multiplication to a single line of code. This method appeals to fans of functional programming.

Here’s an example:

from functools import reduce
import operator

coefficients = [1, 1]
result = reduce(operator.mul, [[coefficients, i] for i in range(3)])


[1, 3, 3, 1]

Using functools.reduce and the multiplication operator, this line of code multiplies the polynomial lists to raise to the specified power. It performs the same operation as Method 3 but in a single, albeit more abstract, line.


    Method 1: sympy. High-level and symbolic. Can handle very complex polynomials and algebra, but requires an external library. Method 2: numpy. Numerical and efficient. Good for polynomials that are represented as arrays of coefficients but requires numpy. Method 3: Manual. Hands-on and educational. Doesn’t rely on additional libraries but is less efficient than library solutions. Method 4: itertools. Caters to Cartesian product applications. It can be harder to follow but is very flexible for various polynomial operations. Method 5: functools operator. Concise and functional. This approach is one-liner but less readable and requires some understanding of functional programming concepts.