What is the difference between using a polynomial object and np.polyval to evaluate a polynomial in NumPy?

I am working with polynomials in NumPy and I am wondering about the difference between using a polynomial object and the np.polyval function to evaluate a polynomial at a specific value. For example, what is the difference between these two code snippets:

equation = np.poly1d(coeff_list)
x = equation(z)

x = (np.polyval(equation, z))

Here, the equation is a polynomial object obtained by using the np.poly1d function and z is the value at which we want to evaluate the polynomial. Both code snippets will give me the same result, but I am curious about the underlying differences.

Can anyone explain the difference between these two approaches? Is one approach preferred over the other in certain situations? Thanks!

poly1d is a class, so eq is an instance of that class:

In [8]: eq = np.poly1d([1,2,3])

In [9]: type(eq)
Out[9]: numpy.poly1d

eq has a __call__ method (it's a callable), so can be used as:

In [10]: eq(np.arange(5))
Out[10]: array([ 3,  6, 11, 18, 27])

polyval is a function, whose code is readily readable from the doc page:

Calling it with a poly1d instance is the same as calling it with the same list of coefficients (plus a 0):

In [11]: np.polyval(eq, np.arange(5))
Out[11]: array([ 3,  6, 11, 18, 27])

In [12]: np.polyval([0,1,2,3], np.arange(5))
Out[12]: array([ 3,  6, 11, 18, 27])

That's because if you iterate on eq you get its coefficients:

In [13]: list(eq)
Out[13]: [1, 2, 3]

I can't offhand find the code for poly1d; but I suspect it's fairly straight forward python. It may even evaluate the polynomial in the same way as polyval. Direct use of eq(x) is slightly faster, but that may more the result of levels of function calls than real evaluation differences.

The note about "numpy.polynomial is preferred" applies to both polyval and poly1d. It may be preferred if you want to do fancy stuff with polynomials, or more general types, but for simple evaluation with a list of coefficients, I don't see much advantage.

Here's the code for polyval:

def polyval(p, x):
    p = NX.asarray(p)
    if isinstance(x, poly1d):
        y = 0
    else:
        x = NX.asanyarray(x)
        y = NX.zeros_like(x)
    for pv in p:
        y = y * x + pv
    return y

edit

The call method of poly1d is actually a call to polyval:

def __call__(self, val):
    return polyval(self.coeffs, val)

This is all in the np.lib.polynomial.py file