[Numpy-discussion] Polynomial evaluation inconsistencies
Charles R Harris
charlesr.harris at gmail.com
Fri Jun 29 23:10:16 EDT 2018
On Fri, Jun 29, 2018 at 8:21 PM, Maxwell Aifer <maifer at haverford.edu> wrote:
> I noticed some frustrating inconsistencies in the various ways to evaluate
> polynomials using numpy. Numpy has three ways of evaluating polynomials
> (that I know of) and each of them has a different syntax:
> You define a polynomial by a list of coefficients *in order of
> increasing degree*, and then use the class’s call() function.
> Evaluates a polynomial at a point. *First* argument is the polynomial,
> or list of coefficients *in order of decreasing degree*, and the
> *second* argument is the point to evaluate at.
> Also evaluates a polynomial at a point, but has more support for
> vectorization. *First* argument is the point to evaluate at, and
> *second* argument the list of coefficients *in order of increasing
> Not only the order of arguments is changed between different methods, but
> the order of the coefficients is reversed as well, leading to puzzling bugs
> (in my experience). What could be the reason for this madness? As polyval
> is a shameless ripoff of Matlab’s function of the same name
> <https://www.mathworks.com/help/matlab/ref/polyval.html> anyway, why not
> just use matlab’s syntax (polyval([c0, c1, c2...], x)) across the board?
The polynomial package, with its various basis, deals with series, and
especially with the truncated series approximations that are used in
numerical work. Series are universally written in increasing order of the
degree. The Polynomial class is efficient in a single variable, while the
numpy.polynomial.polynomial.polyval function is intended as a building
block and can also deal with multivariate polynomials or multidimensional
arrays of polynomials, or a mix. See the simple implementation of polyval3d
for an example. If you are just dealing with a single variable, use
Polynomial, which will also track scaling and offsets for numerical
stability and is generally much superior to the simple polyval function
from a numerical point of view.
As to the ordering of the degrees, learning that the degree matches the
index is pretty easy and is a more natural fit for the implementation code,
especially as the number of variables increases. I note that Matlab has
ones based indexing, so that was really not an option for them.
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the NumPy-Discussion