Polinomios con numpy

En este ejemplo vemos como realizar operaciones con polinomios. Lo haremos de dos formas:

• ✍🏼 Primero de forma manual, implementando nosotros las operaciones.
• 🔧 Después usando las funciones que nos ofrece numpy.

En muchas ocasiones Python nos ofrece todo lo que necesitamos sin tener que implementarlo nosotros. Pero es muy interesante entender como funcionan las cosas, intentando implementarlo nosotros aunque luego usemos un paquete externo.

Empecemos viendo que es un polinomio. Un polinomio tiene la siguiente forma: 5x^3 + 3x^2 + 10x + 4. Tiene los siguientes componentes:

• ❓ La variable independiente. En nuestro caso usamos x como es común.
• 🧮 Unos coeficientes. En nuestro caso 5, 3, 10, 4. Como puedes ver cada uno acompaña a una potencia de x. Un coeficiente puede ser cero.
• 🌡️ El grado. Se refiere al máximo exponente. En nuestro caso el grado es 3.

Podemos expresar nuestro polinomio en Python de la siguiente manera. Una simple list con los coeficientes. Los ordenamos de menor a mayor grado.

p = [4, 10, 3, 5]

Es decir, asumimos que el primer índice p[0] corresponde al mínimo grado, es decir, al término x^0.

Ahora que sabemos que es un polinomio y cómo representarlo en Python, podemos definir las siguientes operaciones:

• ➕ Sumar. Suma dos polinomios p y q.
• ➖ Restar. Resta dos polinomios p y q.
• ✖️ Multiplicar. Multiplica dos polinomios p y q.
• 🧮 Evaluar en un punto. Reemplaza la x de p por un valor concreto.

Empecemos con la suma y la resta.

from itertools import zip_longest

def suma(p, q):
    return [pp+qq for pp, qq in zip_longest(p, q, fillvalue=0)]

def resta(p, q):
    return [pp-qq for pp, qq in zip_longest(p, q, fillvalue=0)]

Es importante notar que usamos zip_longest en vez de zip ya que el segundo asume que ambas list tienen la misma longitud. En el caso de los polinomios esto no es el caso. Se pueden sumar polinomios con diferente grado.

La multiplicación tiene algo mas de miga. Consiste en tomar cada término del primero y multiplicarlo por todos los términos del segundo, sumando el resultado.

def multiplica(p, q):
    grado = len(p) + len(q) - 2
    resultado = [0] * (grado + 1)

    for i, pp in enumerate(p):
        for j, qq in enumerate(q):
            resultado[i + j] += pp * qq

    return resultado

Evaluar un polinomio en un punto es simplemente reemplazar x por un valor determinado y hacer las operaciones. Hay diferentes formas de hacerlo. Esto es el método de Horner, bastante eficiente.

def evalua(p, x):
    resultado = 0
    for coef in reversed(p):
        resultado = resultado * x + coef
    return resultado

Ahora usemos nuestras funciones. Definimos dos polinomios:

• p: Con el valor x^3 + 3.
• q: Con el valor 5x^2 + x + 2.

p = [3, 0, 1]
q = [2, 1, 5]

➕ Los sumamos. El resultado se interpreta como 6 + x + 5x^2.

print(suma(p, q))
# [6, 1, 5]

➖ Los restamos.

print(resta(p, q))
# [-4, -1, 1]

✖️ Los multiplicamos

print(multiplica(p, q))
# [5, 1, 17, 3, 6]

🧮 Y evaluamos p en el punto 5.

print(evalua(p, 5))
# 76

Aunque como decimos es importante entender como funcionan las cosas, en la práctica puede ser mejor usar paquetes que ofrecen estas funciones ya implementadas. Y en muchos casos optimizadas.

Para esto podemos usar numpy y sus funciones. No hay necesidad de reinventar la rueda. Como puedes ver ofrece funciones para hacer todo. El resultado es el mismo.

import numpy as np

p = [1, 0, 3]
q = [5, 1, 2]

print(np.polynomial.polynomial.polyadd(p, q))
print(np.polynomial.polynomial.polysub(p, q))
print(np.polynomial.polynomial.polymul(p, q))
print(np.polynomial.polynomial.polyval(5, p))

✏️ Ejercicios:

• Escriba una función que dados dos polinomios p y q realice su división, indicando su cociente y residuo.