Polynomial Functions
Polynomial operations across power, Chebyshev, Legendre, Hermite, HermiteE, and Laguerre bases with fitting, evaluation, calculus, arithmetic, and conversion utilities.
polyval
Evaluate power series polynomial
y = polyval(x, c)
polyval2d
Evaluate 2-D power series polynomial
z = polyval2d(x, y, c)
polyval3d
Evaluate 3-D power series polynomial
w = polyval3d(x, y, z, c)
polyder
Power series derivative
dc = polyder(c)
polyint
Power series integral
ic = polyint(c)
polymul
Multiply two power series polynomials
c = polymul(c1, c2)
polydiv
Divide two power series polynomials
[q, r] = polydiv(c1, c2)
polyadd
Add two power series polynomials
c = polyadd(c1, c2)
polysub
Subtract two power series polynomials
c = polysub(c1, c2)
polypow
Raise power series polynomial to a power
c = polypow(c, n)
polyroots
Find power series polynomial roots
r = polyroots(c)
polyfromroots
Construct power series from roots
c = polyfromroots(r)
polycompanion
Power series companion matrix
C = polycompanion(c)
polyvander
Power series Vandermonde matrix
V = polyvander(x, deg)
polyfit
Least-squares power series fit
c = polyfit(x, y, deg)
roots
Polynomial roots (M-Code convention)
r = roots(p)
poly
Polynomial from roots (M-Code convention)
p = poly(r)
conv
Convolution / polynomial multiplication (M-Code convention)
w = conv(u, v)
deconv
Deconvolution / polynomial division (M-Code convention)
[q, r] = deconv(b, a)
chebval
Evaluate Chebyshev polynomial
y = chebval(x, c)
chebval2d
Evaluate 2-D Chebyshev polynomial
z = chebval2d(x, y, c)
chebder
Chebyshev derivative
dc = chebder(c)
chebint
Chebyshev integral
ic = chebint(c)
chebmul
Multiply two Chebyshev polynomials
c = chebmul(c1, c2)
chebdiv
Divide two Chebyshev polynomials
[q, r] = chebdiv(c1, c2)
chebadd
Add two Chebyshev polynomials
c = chebadd(c1, c2)
chebsub
Subtract two Chebyshev polynomials
c = chebsub(c1, c2)
chebpow
Raise Chebyshev polynomial to a power
c = chebpow(c, n)
chebroots
Find Chebyshev polynomial roots
r = chebroots(c)
chebfromroots
Construct Chebyshev polynomial from roots
c = chebfromroots(r)
chebcompanion
Chebyshev companion matrix
C = chebcompanion(c)
chebvander
Chebyshev Vandermonde matrix
V = chebvander(x, deg)
chebfit
Least-squares Chebyshev fit
c = chebfit(x, y, deg)
cheb2poly
Convert Chebyshev to power series
p = cheb2poly(c)
legval
Evaluate Legendre polynomial
y = legval(x, c)
legder
Legendre derivative
dc = legder(c)
legint
Legendre integral
ic = legint(c)
legmul
Multiply two Legendre polynomials
c = legmul(c1, c2)
legdiv
Divide two Legendre polynomials
[q, r] = legdiv(c1, c2)
legadd
Add two Legendre polynomials
c = legadd(c1, c2)
legsub
Subtract two Legendre polynomials
c = legsub(c1, c2)
legpow
Raise Legendre polynomial to a power
c = legpow(c, n)
legroots
Find Legendre polynomial roots
r = legroots(c)
legfromroots
Construct Legendre polynomial from roots
c = legfromroots(r)
legcompanion
Legendre companion matrix
C = legcompanion(c)
legvander
Legendre Vandermonde matrix
V = legvander(x, deg)
legfit
Least-squares Legendre fit
c = legfit(x, y, deg)
leg2poly
Convert Legendre to power series
p = leg2poly(c)
hermval
Evaluate Hermite polynomial
y = hermval(x, c)
hermder
Hermite derivative
dc = hermder(c)
hermint
Hermite integral
ic = hermint(c)
hermmul
Multiply two Hermite polynomials
c = hermmul(c1, c2)
hermdiv
Divide two Hermite polynomials
[q, r] = hermdiv(c1, c2)
hermadd
Add two Hermite polynomials
c = hermadd(c1, c2)
hermsub
Subtract two Hermite polynomials
c = hermsub(c1, c2)
hermpow
Raise Hermite polynomial to a power
c = hermpow(c, n)
hermroots
Find Hermite polynomial roots
r = hermroots(c)
hermfromroots
Construct Hermite polynomial from roots
c = hermfromroots(r)
hermcompanion
Hermite companion matrix
C = hermcompanion(c)
hermvander
Hermite Vandermonde matrix
V = hermvander(x, deg)
hermfit
Least-squares Hermite fit
c = hermfit(x, y, deg)
herm2poly
Convert Hermite to power series
p = herm2poly(c)
hermeval
Evaluate probabilist's Hermite polynomial
y = hermeval(x, c)
hermeder
HermiteE derivative
dc = hermeder(c)
hermeint
HermiteE integral
ic = hermeint(c)
hermemul
Multiply two HermiteE polynomials
c = hermemul(c1, c2)
hermediv
Divide two HermiteE polynomials
[q, r] = hermediv(c1, c2)
hermeadd
Add two HermiteE polynomials
c = hermeadd(c1, c2)
hermesub
Subtract two HermiteE polynomials
c = hermesub(c1, c2)
hermepow
Raise HermiteE polynomial to a power
c = hermepow(c, n)
hermeroots
Find HermiteE polynomial roots
r = hermeroots(c)
hermefromroots
Construct HermiteE polynomial from roots
c = hermefromroots(r)
hermecompanion
HermiteE companion matrix
C = hermecompanion(c)
hermevander
HermiteE Vandermonde matrix
V = hermevander(x, deg)
hermefit
Least-squares HermiteE fit
c = hermefit(x, y, deg)
herme2poly
Convert HermiteE to power series
p = herme2poly(c)
lagval
Evaluate Laguerre polynomial
y = lagval(x, c)
lagder
Laguerre derivative
dc = lagder(c)
lagint
Laguerre integral
ic = lagint(c)
lagmul
Multiply two Laguerre polynomials
c = lagmul(c1, c2)
lagdiv
Divide two Laguerre polynomials
[q, r] = lagdiv(c1, c2)
lagadd
Add two Laguerre polynomials
c = lagadd(c1, c2)
lagsub
Subtract two Laguerre polynomials
c = lagsub(c1, c2)
lagpow
Raise Laguerre polynomial to a power
c = lagpow(c, n)
lagroots
Find Laguerre polynomial roots
r = lagroots(c)
lagfromroots
Construct Laguerre polynomial from roots
c = lagfromroots(r)
lagcompanion
Laguerre companion matrix
C = lagcompanion(c)
lagvander
Laguerre Vandermonde matrix
V = lagvander(x, deg)
lagfit
Least-squares Laguerre fit
c = lagfit(x, y, deg)
lag2poly
Convert Laguerre to power series
p = lag2poly(c)
poly2cheb
Convert power series to Chebyshev
cc = poly2cheb(c)
poly2leg
Convert power series to Legendre
lc = poly2leg(c)
poly2herm
Convert power series to Hermite
hc = poly2herm(c)
poly2herme
Convert power series to HermiteE
hc = poly2herme(c)
poly2lag
Convert power series to Laguerre
lc = poly2lag(c)
trimcoef
Remove small trailing coefficients
ct = trimcoef(c)
trimseq
Remove trailing zeros
ct = trimseq(c)
getdomain
Get domain from data points
d = getdomain(x)
mapdomain
Map values between domains
y = mapdomain(x, old, new)
mapparms
Get linear mapping parameters
[off, scl] = mapparms(old, new)