如何使用python中的面向对象类将符号多项式表达式转换为可收集多项式？

如何解决如何使用python中的面向对象类将符号多项式表达式转换为可收集多项式？

从下面的多项式面向对象类，我们可以得到多项式的符号表达式。

#Classes 和面向对象编程

data = []
files = glob.glob ("*.jpg")
for myFile in files:
    image = cv2.imread (myFile)
    data.append (image)

print('data shape:',np.array(data).shape)

出于绘图目的，我愿意避免以下方法，并直接想将符号表达式转换为多项式类本身中的可排序表达式。

import numpy as np

import matplotlib.pyplot as plt

class Polynomial(object):
    
    def __init__(self,roots,leading_term):
        self.roots = roots
        self.leading_term = leading_term
        self.order = len(roots)

    def __repr__(self):
        string = str(self.leading_term)
        for root in self.roots:
            if root == 0:
                string = string + "x"
            elif root > 0:
                string = string + "(x - {})".format(root)
            else:
                string = string + "(x + {})".format(-root)
        return string

    def __mul__(self,other):
        roots = self.roots + other.roots
        leading_term = self.leading_term * other.leading_term
        return Polynomial(roots,leading_term)

    def explain_to(self,caller):
        print("Hello,{}. {}.".format(caller,self.explanation))
        print("My roots are {}.".format(self.roots))

# Creating a symbolic expression of the polynomial 

>>> p = Polynomial((1,2,-3),2)
>>> print(p)

2(x - 1)(x - 2)(x + 3)

>>> q = Polynomial((1,1,-2),-1)
>>> print(q)

-1(x - 1)(x - 1)x(x + 2) 

解决方法

如果我没猜错，您会想要使用 __call__ 进行类似的操作。 以下是在课堂中使用 __call__ 的方法：

import numpy as np
import matplotlib.pyplot as plt

class Polynomial(object):
    
    def __init__(self,roots,leading_term):
        self.roots = roots
        self.leading_term = leading_term
        self.order = len(roots)

    def __repr__(self):
        string = str(self.leading_term)
        for root in self.roots:
            if root == 0:
                string = string + "x"
            elif root > 0:
                string = string + "(x - {})".format(root)
            else:
                string = string + "(x + {})".format(-root)
        return string
    
    def __call__(self,x):
        res = 1
        res *= self.leading_term
        for root in self.roots:
            res *= (x - root)
        
        return res

    def __mul__(self,other):
        roots = self.roots + other.roots
        leading_term = self.leading_term * other.leading_term
        return Polynomial(roots,leading_term)

    def explain_to(self,caller):
        print("Hello,{}. {}.".format(caller,self.explanation))
        print("My roots are {}.".format(self.roots))

它是这样工作的：

>>> p = Polynomial((1,2,-3),2)
>>> print(p)
2(x - 1)(x - 2)(x + 3)

>>> print(p(0),p(1),p(2),p(3),p(4))
12 0 0 24 84

>>> x = np.linspace(-4,4,100)
>>> fig = plt.figure()
>>> plt.plot(x,p(x),'-')

,

这是一个依赖于 sympy 的解决方案。请注意，不是使用 lambdify，而是提取系数并将其传递给 np.poly1d。因此，可调用函数被向量化并且应该相当高效。

import numpy as np
from sympy import Poly,sympify
from matplotlib import pyplot as plt

poly_string = "2*x**3 + 4"
coeffs = Poly(sympify(poly_string)).all_coeffs()
p_callable = np.poly1d(np.array(coeffs).astype(np.float))

xs = np.linspace(-10,10,100)
ys = p_callable(xs)

plt.plot(xs,ys)

,

你可以纯粹在 numpy (np) 中做到这一点

p = 2*np.poly([1,-3])
q = -1*np.poly([1,1,-2])

x = np.linspace(-5,5,100)

plt.plot(x,np.polyval(p,x),'r--')
plt.plot(x,np.polyval(q,'g--')
plt.grid(); plt.legend("pq"); plt.show()