Chris@87: """ Chris@87: Objects for dealing with Hermite series. Chris@87: Chris@87: This module provides a number of objects (mostly functions) useful for Chris@87: dealing with Hermite series, including a `Hermite` class that Chris@87: encapsulates the usual arithmetic operations. (General information Chris@87: on how this module represents and works with such polynomials is in the Chris@87: docstring for its "parent" sub-package, `numpy.polynomial`). Chris@87: Chris@87: Constants Chris@87: --------- Chris@87: - `hermdomain` -- Hermite series default domain, [-1,1]. Chris@87: - `hermzero` -- Hermite series that evaluates identically to 0. Chris@87: - `hermone` -- Hermite series that evaluates identically to 1. Chris@87: - `hermx` -- Hermite series for the identity map, ``f(x) = x``. Chris@87: Chris@87: Arithmetic Chris@87: ---------- Chris@87: - `hermmulx` -- multiply a Hermite series in ``P_i(x)`` by ``x``. Chris@87: - `hermadd` -- add two Hermite series. Chris@87: - `hermsub` -- subtract one Hermite series from another. Chris@87: - `hermmul` -- multiply two Hermite series. Chris@87: - `hermdiv` -- divide one Hermite series by another. Chris@87: - `hermval` -- evaluate a Hermite series at given points. Chris@87: - `hermval2d` -- evaluate a 2D Hermite series at given points. Chris@87: - `hermval3d` -- evaluate a 3D Hermite series at given points. Chris@87: - `hermgrid2d` -- evaluate a 2D Hermite series on a Cartesian product. Chris@87: - `hermgrid3d` -- evaluate a 3D Hermite series on a Cartesian product. Chris@87: Chris@87: Calculus Chris@87: -------- Chris@87: - `hermder` -- differentiate a Hermite series. Chris@87: - `hermint` -- integrate a Hermite series. Chris@87: Chris@87: Misc Functions Chris@87: -------------- Chris@87: - `hermfromroots` -- create a Hermite series with specified roots. Chris@87: - `hermroots` -- find the roots of a Hermite series. Chris@87: - `hermvander` -- Vandermonde-like matrix for Hermite polynomials. Chris@87: - `hermvander2d` -- Vandermonde-like matrix for 2D power series. Chris@87: - `hermvander3d` -- Vandermonde-like matrix for 3D power series. Chris@87: - `hermgauss` -- Gauss-Hermite quadrature, points and weights. Chris@87: - `hermweight` -- Hermite weight function. Chris@87: - `hermcompanion` -- symmetrized companion matrix in Hermite form. Chris@87: - `hermfit` -- least-squares fit returning a Hermite series. Chris@87: - `hermtrim` -- trim leading coefficients from a Hermite series. Chris@87: - `hermline` -- Hermite series of given straight line. Chris@87: - `herm2poly` -- convert a Hermite series to a polynomial. Chris@87: - `poly2herm` -- convert a polynomial to a Hermite series. Chris@87: Chris@87: Classes Chris@87: ------- Chris@87: - `Hermite` -- A Hermite series class. Chris@87: Chris@87: See also Chris@87: -------- Chris@87: `numpy.polynomial` Chris@87: Chris@87: """ Chris@87: from __future__ import division, absolute_import, print_function Chris@87: Chris@87: import warnings Chris@87: import numpy as np Chris@87: import numpy.linalg as la Chris@87: Chris@87: from . import polyutils as pu Chris@87: from ._polybase import ABCPolyBase Chris@87: Chris@87: __all__ = [ Chris@87: 'hermzero', 'hermone', 'hermx', 'hermdomain', 'hermline', 'hermadd', Chris@87: 'hermsub', 'hermmulx', 'hermmul', 'hermdiv', 'hermpow', 'hermval', Chris@87: 'hermder', 'hermint', 'herm2poly', 'poly2herm', 'hermfromroots', Chris@87: 'hermvander', 'hermfit', 'hermtrim', 'hermroots', 'Hermite', Chris@87: 'hermval2d', 'hermval3d', 'hermgrid2d', 'hermgrid3d', 'hermvander2d', Chris@87: 'hermvander3d', 'hermcompanion', 'hermgauss', 'hermweight'] Chris@87: Chris@87: hermtrim = pu.trimcoef Chris@87: Chris@87: Chris@87: def poly2herm(pol): Chris@87: """ Chris@87: poly2herm(pol) Chris@87: Chris@87: Convert a polynomial to a Hermite series. Chris@87: Chris@87: Convert an array representing the coefficients of a polynomial (relative Chris@87: to the "standard" basis) ordered from lowest degree to highest, to an Chris@87: array of the coefficients of the equivalent Hermite series, ordered Chris@87: from lowest to highest degree. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: pol : array_like Chris@87: 1-D array containing the polynomial coefficients Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: c : ndarray Chris@87: 1-D array containing the coefficients of the equivalent Hermite Chris@87: series. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: herm2poly Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: The easy way to do conversions between polynomial basis sets Chris@87: is to use the convert method of a class instance. Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import poly2herm Chris@87: >>> poly2herm(np.arange(4)) Chris@87: array([ 1. , 2.75 , 0.5 , 0.375]) Chris@87: Chris@87: """ Chris@87: [pol] = pu.as_series([pol]) Chris@87: deg = len(pol) - 1 Chris@87: res = 0 Chris@87: for i in range(deg, -1, -1): Chris@87: res = hermadd(hermmulx(res), pol[i]) Chris@87: return res Chris@87: Chris@87: Chris@87: def herm2poly(c): Chris@87: """ Chris@87: Convert a Hermite series to a polynomial. Chris@87: Chris@87: Convert an array representing the coefficients of a Hermite series, Chris@87: ordered from lowest degree to highest, to an array of the coefficients Chris@87: of the equivalent polynomial (relative to the "standard" basis) ordered Chris@87: from lowest to highest degree. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: c : array_like Chris@87: 1-D array containing the Hermite series coefficients, ordered Chris@87: from lowest order term to highest. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: pol : ndarray Chris@87: 1-D array containing the coefficients of the equivalent polynomial Chris@87: (relative to the "standard" basis) ordered from lowest order term Chris@87: to highest. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: poly2herm Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: The easy way to do conversions between polynomial basis sets Chris@87: is to use the convert method of a class instance. Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import herm2poly Chris@87: >>> herm2poly([ 1. , 2.75 , 0.5 , 0.375]) Chris@87: array([ 0., 1., 2., 3.]) Chris@87: Chris@87: """ Chris@87: from .polynomial import polyadd, polysub, polymulx Chris@87: Chris@87: [c] = pu.as_series([c]) Chris@87: n = len(c) Chris@87: if n == 1: Chris@87: return c Chris@87: if n == 2: Chris@87: c[1] *= 2 Chris@87: return c Chris@87: else: Chris@87: c0 = c[-2] Chris@87: c1 = c[-1] Chris@87: # i is the current degree of c1 Chris@87: for i in range(n - 1, 1, -1): Chris@87: tmp = c0 Chris@87: c0 = polysub(c[i - 2], c1*(2*(i - 1))) Chris@87: c1 = polyadd(tmp, polymulx(c1)*2) Chris@87: return polyadd(c0, polymulx(c1)*2) Chris@87: Chris@87: # Chris@87: # These are constant arrays are of integer type so as to be compatible Chris@87: # with the widest range of other types, such as Decimal. Chris@87: # Chris@87: Chris@87: # Hermite Chris@87: hermdomain = np.array([-1, 1]) Chris@87: Chris@87: # Hermite coefficients representing zero. Chris@87: hermzero = np.array([0]) Chris@87: Chris@87: # Hermite coefficients representing one. Chris@87: hermone = np.array([1]) Chris@87: Chris@87: # Hermite coefficients representing the identity x. Chris@87: hermx = np.array([0, 1/2]) Chris@87: Chris@87: Chris@87: def hermline(off, scl): Chris@87: """ Chris@87: Hermite series whose graph is a straight line. Chris@87: Chris@87: Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: off, scl : scalars Chris@87: The specified line is given by ``off + scl*x``. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: y : ndarray Chris@87: This module's representation of the Hermite series for Chris@87: ``off + scl*x``. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: polyline, chebline Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermline, hermval Chris@87: >>> hermval(0,hermline(3, 2)) Chris@87: 3.0 Chris@87: >>> hermval(1,hermline(3, 2)) Chris@87: 5.0 Chris@87: Chris@87: """ Chris@87: if scl != 0: Chris@87: return np.array([off, scl/2]) Chris@87: else: Chris@87: return np.array([off]) Chris@87: Chris@87: Chris@87: def hermfromroots(roots): Chris@87: """ Chris@87: Generate a Hermite series with given roots. Chris@87: Chris@87: The function returns the coefficients of the polynomial Chris@87: Chris@87: .. math:: p(x) = (x - r_0) * (x - r_1) * ... * (x - r_n), Chris@87: Chris@87: in Hermite form, where the `r_n` are the roots specified in `roots`. Chris@87: If a zero has multiplicity n, then it must appear in `roots` n times. Chris@87: For instance, if 2 is a root of multiplicity three and 3 is a root of Chris@87: multiplicity 2, then `roots` looks something like [2, 2, 2, 3, 3]. The Chris@87: roots can appear in any order. Chris@87: Chris@87: If the returned coefficients are `c`, then Chris@87: Chris@87: .. math:: p(x) = c_0 + c_1 * H_1(x) + ... + c_n * H_n(x) Chris@87: Chris@87: The coefficient of the last term is not generally 1 for monic Chris@87: polynomials in Hermite form. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: roots : array_like Chris@87: Sequence containing the roots. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: out : ndarray Chris@87: 1-D array of coefficients. If all roots are real then `out` is a Chris@87: real array, if some of the roots are complex, then `out` is complex Chris@87: even if all the coefficients in the result are real (see Examples Chris@87: below). Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: polyfromroots, legfromroots, lagfromroots, chebfromroots, Chris@87: hermefromroots. Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermfromroots, hermval Chris@87: >>> coef = hermfromroots((-1, 0, 1)) Chris@87: >>> hermval((-1, 0, 1), coef) Chris@87: array([ 0., 0., 0.]) Chris@87: >>> coef = hermfromroots((-1j, 1j)) Chris@87: >>> hermval((-1j, 1j), coef) Chris@87: array([ 0.+0.j, 0.+0.j]) Chris@87: Chris@87: """ Chris@87: if len(roots) == 0: Chris@87: return np.ones(1) Chris@87: else: Chris@87: [roots] = pu.as_series([roots], trim=False) Chris@87: roots.sort() Chris@87: p = [hermline(-r, 1) for r in roots] Chris@87: n = len(p) Chris@87: while n > 1: Chris@87: m, r = divmod(n, 2) Chris@87: tmp = [hermmul(p[i], p[i+m]) for i in range(m)] Chris@87: if r: Chris@87: tmp[0] = hermmul(tmp[0], p[-1]) Chris@87: p = tmp Chris@87: n = m Chris@87: return p[0] Chris@87: Chris@87: Chris@87: def hermadd(c1, c2): Chris@87: """ Chris@87: Add one Hermite series to another. Chris@87: Chris@87: Returns the sum of two Hermite series `c1` + `c2`. The arguments Chris@87: are sequences of coefficients ordered from lowest order term to Chris@87: highest, i.e., [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: c1, c2 : array_like Chris@87: 1-D arrays of Hermite series coefficients ordered from low to Chris@87: high. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: out : ndarray Chris@87: Array representing the Hermite series of their sum. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermsub, hermmul, hermdiv, hermpow Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: Unlike multiplication, division, etc., the sum of two Hermite series Chris@87: is a Hermite series (without having to "reproject" the result onto Chris@87: the basis set) so addition, just like that of "standard" polynomials, Chris@87: is simply "component-wise." Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermadd Chris@87: >>> hermadd([1, 2, 3], [1, 2, 3, 4]) Chris@87: array([ 2., 4., 6., 4.]) Chris@87: Chris@87: """ Chris@87: # c1, c2 are trimmed copies Chris@87: [c1, c2] = pu.as_series([c1, c2]) Chris@87: if len(c1) > len(c2): Chris@87: c1[:c2.size] += c2 Chris@87: ret = c1 Chris@87: else: Chris@87: c2[:c1.size] += c1 Chris@87: ret = c2 Chris@87: return pu.trimseq(ret) Chris@87: Chris@87: Chris@87: def hermsub(c1, c2): Chris@87: """ Chris@87: Subtract one Hermite series from another. Chris@87: Chris@87: Returns the difference of two Hermite series `c1` - `c2`. The Chris@87: sequences of coefficients are from lowest order term to highest, i.e., Chris@87: [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: c1, c2 : array_like Chris@87: 1-D arrays of Hermite series coefficients ordered from low to Chris@87: high. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: out : ndarray Chris@87: Of Hermite series coefficients representing their difference. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermadd, hermmul, hermdiv, hermpow Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: Unlike multiplication, division, etc., the difference of two Hermite Chris@87: series is a Hermite series (without having to "reproject" the result Chris@87: onto the basis set) so subtraction, just like that of "standard" Chris@87: polynomials, is simply "component-wise." Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermsub Chris@87: >>> hermsub([1, 2, 3, 4], [1, 2, 3]) Chris@87: array([ 0., 0., 0., 4.]) Chris@87: Chris@87: """ Chris@87: # c1, c2 are trimmed copies Chris@87: [c1, c2] = pu.as_series([c1, c2]) Chris@87: if len(c1) > len(c2): Chris@87: c1[:c2.size] -= c2 Chris@87: ret = c1 Chris@87: else: Chris@87: c2 = -c2 Chris@87: c2[:c1.size] += c1 Chris@87: ret = c2 Chris@87: return pu.trimseq(ret) Chris@87: Chris@87: Chris@87: def hermmulx(c): Chris@87: """Multiply a Hermite series by x. Chris@87: Chris@87: Multiply the Hermite series `c` by x, where x is the independent Chris@87: variable. Chris@87: Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: c : array_like Chris@87: 1-D array of Hermite series coefficients ordered from low to Chris@87: high. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: out : ndarray Chris@87: Array representing the result of the multiplication. Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: The multiplication uses the recursion relationship for Hermite Chris@87: polynomials in the form Chris@87: Chris@87: .. math:: Chris@87: Chris@87: xP_i(x) = (P_{i + 1}(x)/2 + i*P_{i - 1}(x)) Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermmulx Chris@87: >>> hermmulx([1, 2, 3]) Chris@87: array([ 2. , 6.5, 1. , 1.5]) Chris@87: Chris@87: """ Chris@87: # c is a trimmed copy Chris@87: [c] = pu.as_series([c]) Chris@87: # The zero series needs special treatment Chris@87: if len(c) == 1 and c[0] == 0: Chris@87: return c Chris@87: Chris@87: prd = np.empty(len(c) + 1, dtype=c.dtype) Chris@87: prd[0] = c[0]*0 Chris@87: prd[1] = c[0]/2 Chris@87: for i in range(1, len(c)): Chris@87: prd[i + 1] = c[i]/2 Chris@87: prd[i - 1] += c[i]*i Chris@87: return prd Chris@87: Chris@87: Chris@87: def hermmul(c1, c2): Chris@87: """ Chris@87: Multiply one Hermite series by another. Chris@87: Chris@87: Returns the product of two Hermite series `c1` * `c2`. The arguments Chris@87: are sequences of coefficients, from lowest order "term" to highest, Chris@87: e.g., [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: c1, c2 : array_like Chris@87: 1-D arrays of Hermite series coefficients ordered from low to Chris@87: high. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: out : ndarray Chris@87: Of Hermite series coefficients representing their product. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermadd, hermsub, hermdiv, hermpow Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: In general, the (polynomial) product of two C-series results in terms Chris@87: that are not in the Hermite polynomial basis set. Thus, to express Chris@87: the product as a Hermite series, it is necessary to "reproject" the Chris@87: product onto said basis set, which may produce "unintuitive" (but Chris@87: correct) results; see Examples section below. Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermmul Chris@87: >>> hermmul([1, 2, 3], [0, 1, 2]) Chris@87: array([ 52., 29., 52., 7., 6.]) Chris@87: Chris@87: """ Chris@87: # s1, s2 are trimmed copies Chris@87: [c1, c2] = pu.as_series([c1, c2]) Chris@87: Chris@87: if len(c1) > len(c2): Chris@87: c = c2 Chris@87: xs = c1 Chris@87: else: Chris@87: c = c1 Chris@87: xs = c2 Chris@87: Chris@87: if len(c) == 1: Chris@87: c0 = c[0]*xs Chris@87: c1 = 0 Chris@87: elif len(c) == 2: Chris@87: c0 = c[0]*xs Chris@87: c1 = c[1]*xs Chris@87: else: Chris@87: nd = len(c) Chris@87: c0 = c[-2]*xs Chris@87: c1 = c[-1]*xs Chris@87: for i in range(3, len(c) + 1): Chris@87: tmp = c0 Chris@87: nd = nd - 1 Chris@87: c0 = hermsub(c[-i]*xs, c1*(2*(nd - 1))) Chris@87: c1 = hermadd(tmp, hermmulx(c1)*2) Chris@87: return hermadd(c0, hermmulx(c1)*2) Chris@87: Chris@87: Chris@87: def hermdiv(c1, c2): Chris@87: """ Chris@87: Divide one Hermite series by another. Chris@87: Chris@87: Returns the quotient-with-remainder of two Hermite series Chris@87: `c1` / `c2`. The arguments are sequences of coefficients from lowest Chris@87: order "term" to highest, e.g., [1,2,3] represents the series Chris@87: ``P_0 + 2*P_1 + 3*P_2``. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: c1, c2 : array_like Chris@87: 1-D arrays of Hermite series coefficients ordered from low to Chris@87: high. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: [quo, rem] : ndarrays Chris@87: Of Hermite series coefficients representing the quotient and Chris@87: remainder. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermadd, hermsub, hermmul, hermpow Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: In general, the (polynomial) division of one Hermite series by another Chris@87: results in quotient and remainder terms that are not in the Hermite Chris@87: polynomial basis set. Thus, to express these results as a Hermite Chris@87: series, it is necessary to "reproject" the results onto the Hermite Chris@87: basis set, which may produce "unintuitive" (but correct) results; see Chris@87: Examples section below. Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermdiv Chris@87: >>> hermdiv([ 52., 29., 52., 7., 6.], [0, 1, 2]) Chris@87: (array([ 1., 2., 3.]), array([ 0.])) Chris@87: >>> hermdiv([ 54., 31., 52., 7., 6.], [0, 1, 2]) Chris@87: (array([ 1., 2., 3.]), array([ 2., 2.])) Chris@87: >>> hermdiv([ 53., 30., 52., 7., 6.], [0, 1, 2]) Chris@87: (array([ 1., 2., 3.]), array([ 1., 1.])) Chris@87: Chris@87: """ Chris@87: # c1, c2 are trimmed copies Chris@87: [c1, c2] = pu.as_series([c1, c2]) Chris@87: if c2[-1] == 0: Chris@87: raise ZeroDivisionError() Chris@87: Chris@87: lc1 = len(c1) Chris@87: lc2 = len(c2) Chris@87: if lc1 < lc2: Chris@87: return c1[:1]*0, c1 Chris@87: elif lc2 == 1: Chris@87: return c1/c2[-1], c1[:1]*0 Chris@87: else: Chris@87: quo = np.empty(lc1 - lc2 + 1, dtype=c1.dtype) Chris@87: rem = c1 Chris@87: for i in range(lc1 - lc2, - 1, -1): Chris@87: p = hermmul([0]*i + [1], c2) Chris@87: q = rem[-1]/p[-1] Chris@87: rem = rem[:-1] - q*p[:-1] Chris@87: quo[i] = q Chris@87: return quo, pu.trimseq(rem) Chris@87: Chris@87: Chris@87: def hermpow(c, pow, maxpower=16): Chris@87: """Raise a Hermite series to a power. Chris@87: Chris@87: Returns the Hermite series `c` raised to the power `pow`. The Chris@87: argument `c` is a sequence of coefficients ordered from low to high. Chris@87: i.e., [1,2,3] is the series ``P_0 + 2*P_1 + 3*P_2.`` Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: c : array_like Chris@87: 1-D array of Hermite series coefficients ordered from low to Chris@87: high. Chris@87: pow : integer Chris@87: Power to which the series will be raised Chris@87: maxpower : integer, optional Chris@87: Maximum power allowed. This is mainly to limit growth of the series Chris@87: to unmanageable size. Default is 16 Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: coef : ndarray Chris@87: Hermite series of power. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermadd, hermsub, hermmul, hermdiv Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermpow Chris@87: >>> hermpow([1, 2, 3], 2) Chris@87: array([ 81., 52., 82., 12., 9.]) Chris@87: Chris@87: """ Chris@87: # c is a trimmed copy Chris@87: [c] = pu.as_series([c]) Chris@87: power = int(pow) Chris@87: if power != pow or power < 0: Chris@87: raise ValueError("Power must be a non-negative integer.") Chris@87: elif maxpower is not None and power > maxpower: Chris@87: raise ValueError("Power is too large") Chris@87: elif power == 0: Chris@87: return np.array([1], dtype=c.dtype) Chris@87: elif power == 1: Chris@87: return c Chris@87: else: Chris@87: # This can be made more efficient by using powers of two Chris@87: # in the usual way. Chris@87: prd = c Chris@87: for i in range(2, power + 1): Chris@87: prd = hermmul(prd, c) Chris@87: return prd Chris@87: Chris@87: Chris@87: def hermder(c, m=1, scl=1, axis=0): Chris@87: """ Chris@87: Differentiate a Hermite series. Chris@87: Chris@87: Returns the Hermite series coefficients `c` differentiated `m` times Chris@87: along `axis`. At each iteration the result is multiplied by `scl` (the Chris@87: scaling factor is for use in a linear change of variable). The argument Chris@87: `c` is an array of coefficients from low to high degree along each Chris@87: axis, e.g., [1,2,3] represents the series ``1*H_0 + 2*H_1 + 3*H_2`` Chris@87: while [[1,2],[1,2]] represents ``1*H_0(x)*H_0(y) + 1*H_1(x)*H_0(y) + Chris@87: 2*H_0(x)*H_1(y) + 2*H_1(x)*H_1(y)`` if axis=0 is ``x`` and axis=1 is Chris@87: ``y``. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: c : array_like Chris@87: Array of Hermite series coefficients. If `c` is multidimensional the Chris@87: different axis correspond to different variables with the degree in Chris@87: each axis given by the corresponding index. Chris@87: m : int, optional Chris@87: Number of derivatives taken, must be non-negative. (Default: 1) Chris@87: scl : scalar, optional Chris@87: Each differentiation is multiplied by `scl`. The end result is Chris@87: multiplication by ``scl**m``. This is for use in a linear change of Chris@87: variable. (Default: 1) Chris@87: axis : int, optional Chris@87: Axis over which the derivative is taken. (Default: 0). Chris@87: Chris@87: .. versionadded:: 1.7.0 Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: der : ndarray Chris@87: Hermite series of the derivative. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermint Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: In general, the result of differentiating a Hermite series does not Chris@87: resemble the same operation on a power series. Thus the result of this Chris@87: function may be "unintuitive," albeit correct; see Examples section Chris@87: below. Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermder Chris@87: >>> hermder([ 1. , 0.5, 0.5, 0.5]) Chris@87: array([ 1., 2., 3.]) Chris@87: >>> hermder([-0.5, 1./2., 1./8., 1./12., 1./16.], m=2) Chris@87: array([ 1., 2., 3.]) Chris@87: Chris@87: """ Chris@87: c = np.array(c, ndmin=1, copy=1) Chris@87: if c.dtype.char in '?bBhHiIlLqQpP': Chris@87: c = c.astype(np.double) Chris@87: cnt, iaxis = [int(t) for t in [m, axis]] Chris@87: Chris@87: if cnt != m: Chris@87: raise ValueError("The order of derivation must be integer") Chris@87: if cnt < 0: Chris@87: raise ValueError("The order of derivation must be non-negative") Chris@87: if iaxis != axis: Chris@87: raise ValueError("The axis must be integer") Chris@87: if not -c.ndim <= iaxis < c.ndim: Chris@87: raise ValueError("The axis is out of range") Chris@87: if iaxis < 0: Chris@87: iaxis += c.ndim Chris@87: Chris@87: if cnt == 0: Chris@87: return c Chris@87: Chris@87: c = np.rollaxis(c, iaxis) Chris@87: n = len(c) Chris@87: if cnt >= n: Chris@87: c = c[:1]*0 Chris@87: else: Chris@87: for i in range(cnt): Chris@87: n = n - 1 Chris@87: c *= scl Chris@87: der = np.empty((n,) + c.shape[1:], dtype=c.dtype) Chris@87: for j in range(n, 0, -1): Chris@87: der[j - 1] = (2*j)*c[j] Chris@87: c = der Chris@87: c = np.rollaxis(c, 0, iaxis + 1) Chris@87: return c Chris@87: Chris@87: Chris@87: def hermint(c, m=1, k=[], lbnd=0, scl=1, axis=0): Chris@87: """ Chris@87: Integrate a Hermite series. Chris@87: Chris@87: Returns the Hermite series coefficients `c` integrated `m` times from Chris@87: `lbnd` along `axis`. At each iteration the resulting series is Chris@87: **multiplied** by `scl` and an integration constant, `k`, is added. Chris@87: The scaling factor is for use in a linear change of variable. ("Buyer Chris@87: beware": note that, depending on what one is doing, one may want `scl` Chris@87: to be the reciprocal of what one might expect; for more information, Chris@87: see the Notes section below.) The argument `c` is an array of Chris@87: coefficients from low to high degree along each axis, e.g., [1,2,3] Chris@87: represents the series ``H_0 + 2*H_1 + 3*H_2`` while [[1,2],[1,2]] Chris@87: represents ``1*H_0(x)*H_0(y) + 1*H_1(x)*H_0(y) + 2*H_0(x)*H_1(y) + Chris@87: 2*H_1(x)*H_1(y)`` if axis=0 is ``x`` and axis=1 is ``y``. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: c : array_like Chris@87: Array of Hermite series coefficients. If c is multidimensional the Chris@87: different axis correspond to different variables with the degree in Chris@87: each axis given by the corresponding index. Chris@87: m : int, optional Chris@87: Order of integration, must be positive. (Default: 1) Chris@87: k : {[], list, scalar}, optional Chris@87: Integration constant(s). The value of the first integral at Chris@87: ``lbnd`` is the first value in the list, the value of the second Chris@87: integral at ``lbnd`` is the second value, etc. If ``k == []`` (the Chris@87: default), all constants are set to zero. If ``m == 1``, a single Chris@87: scalar can be given instead of a list. Chris@87: lbnd : scalar, optional Chris@87: The lower bound of the integral. (Default: 0) Chris@87: scl : scalar, optional Chris@87: Following each integration the result is *multiplied* by `scl` Chris@87: before the integration constant is added. (Default: 1) Chris@87: axis : int, optional Chris@87: Axis over which the integral is taken. (Default: 0). Chris@87: Chris@87: .. versionadded:: 1.7.0 Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: S : ndarray Chris@87: Hermite series coefficients of the integral. Chris@87: Chris@87: Raises Chris@87: ------ Chris@87: ValueError Chris@87: If ``m < 0``, ``len(k) > m``, ``np.isscalar(lbnd) == False``, or Chris@87: ``np.isscalar(scl) == False``. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermder Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: Note that the result of each integration is *multiplied* by `scl`. Chris@87: Why is this important to note? Say one is making a linear change of Chris@87: variable :math:`u = ax + b` in an integral relative to `x`. Then Chris@87: .. math::`dx = du/a`, so one will need to set `scl` equal to Chris@87: :math:`1/a` - perhaps not what one would have first thought. Chris@87: Chris@87: Also note that, in general, the result of integrating a C-series needs Chris@87: to be "reprojected" onto the C-series basis set. Thus, typically, Chris@87: the result of this function is "unintuitive," albeit correct; see Chris@87: Examples section below. Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermint Chris@87: >>> hermint([1,2,3]) # integrate once, value 0 at 0. Chris@87: array([ 1. , 0.5, 0.5, 0.5]) Chris@87: >>> hermint([1,2,3], m=2) # integrate twice, value & deriv 0 at 0 Chris@87: array([-0.5 , 0.5 , 0.125 , 0.08333333, 0.0625 ]) Chris@87: >>> hermint([1,2,3], k=1) # integrate once, value 1 at 0. Chris@87: array([ 2. , 0.5, 0.5, 0.5]) Chris@87: >>> hermint([1,2,3], lbnd=-1) # integrate once, value 0 at -1 Chris@87: array([-2. , 0.5, 0.5, 0.5]) Chris@87: >>> hermint([1,2,3], m=2, k=[1,2], lbnd=-1) Chris@87: array([ 1.66666667, -0.5 , 0.125 , 0.08333333, 0.0625 ]) Chris@87: Chris@87: """ Chris@87: c = np.array(c, ndmin=1, copy=1) Chris@87: if c.dtype.char in '?bBhHiIlLqQpP': Chris@87: c = c.astype(np.double) Chris@87: if not np.iterable(k): Chris@87: k = [k] Chris@87: cnt, iaxis = [int(t) for t in [m, axis]] Chris@87: Chris@87: if cnt != m: Chris@87: raise ValueError("The order of integration must be integer") Chris@87: if cnt < 0: Chris@87: raise ValueError("The order of integration must be non-negative") Chris@87: if len(k) > cnt: Chris@87: raise ValueError("Too many integration constants") Chris@87: if iaxis != axis: Chris@87: raise ValueError("The axis must be integer") Chris@87: if not -c.ndim <= iaxis < c.ndim: Chris@87: raise ValueError("The axis is out of range") Chris@87: if iaxis < 0: Chris@87: iaxis += c.ndim Chris@87: Chris@87: if cnt == 0: Chris@87: return c Chris@87: Chris@87: c = np.rollaxis(c, iaxis) Chris@87: k = list(k) + [0]*(cnt - len(k)) Chris@87: for i in range(cnt): Chris@87: n = len(c) Chris@87: c *= scl Chris@87: if n == 1 and np.all(c[0] == 0): Chris@87: c[0] += k[i] Chris@87: else: Chris@87: tmp = np.empty((n + 1,) + c.shape[1:], dtype=c.dtype) Chris@87: tmp[0] = c[0]*0 Chris@87: tmp[1] = c[0]/2 Chris@87: for j in range(1, n): Chris@87: tmp[j + 1] = c[j]/(2*(j + 1)) Chris@87: tmp[0] += k[i] - hermval(lbnd, tmp) Chris@87: c = tmp Chris@87: c = np.rollaxis(c, 0, iaxis + 1) Chris@87: return c Chris@87: Chris@87: Chris@87: def hermval(x, c, tensor=True): Chris@87: """ Chris@87: Evaluate an Hermite series at points x. Chris@87: Chris@87: If `c` is of length `n + 1`, this function returns the value: Chris@87: Chris@87: .. math:: p(x) = c_0 * H_0(x) + c_1 * H_1(x) + ... + c_n * H_n(x) Chris@87: Chris@87: The parameter `x` is converted to an array only if it is a tuple or a Chris@87: list, otherwise it is treated as a scalar. In either case, either `x` Chris@87: or its elements must support multiplication and addition both with Chris@87: themselves and with the elements of `c`. Chris@87: Chris@87: If `c` is a 1-D array, then `p(x)` will have the same shape as `x`. If Chris@87: `c` is multidimensional, then the shape of the result depends on the Chris@87: value of `tensor`. If `tensor` is true the shape will be c.shape[1:] + Chris@87: x.shape. If `tensor` is false the shape will be c.shape[1:]. Note that Chris@87: scalars have shape (,). Chris@87: Chris@87: Trailing zeros in the coefficients will be used in the evaluation, so Chris@87: they should be avoided if efficiency is a concern. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: x : array_like, compatible object Chris@87: If `x` is a list or tuple, it is converted to an ndarray, otherwise Chris@87: it is left unchanged and treated as a scalar. In either case, `x` Chris@87: or its elements must support addition and multiplication with Chris@87: with themselves and with the elements of `c`. Chris@87: c : array_like Chris@87: Array of coefficients ordered so that the coefficients for terms of Chris@87: degree n are contained in c[n]. If `c` is multidimensional the Chris@87: remaining indices enumerate multiple polynomials. In the two Chris@87: dimensional case the coefficients may be thought of as stored in Chris@87: the columns of `c`. Chris@87: tensor : boolean, optional Chris@87: If True, the shape of the coefficient array is extended with ones Chris@87: on the right, one for each dimension of `x`. Scalars have dimension 0 Chris@87: for this action. The result is that every column of coefficients in Chris@87: `c` is evaluated for every element of `x`. If False, `x` is broadcast Chris@87: over the columns of `c` for the evaluation. This keyword is useful Chris@87: when `c` is multidimensional. The default value is True. Chris@87: Chris@87: .. versionadded:: 1.7.0 Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: values : ndarray, algebra_like Chris@87: The shape of the return value is described above. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermval2d, hermgrid2d, hermval3d, hermgrid3d Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: The evaluation uses Clenshaw recursion, aka synthetic division. Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermval Chris@87: >>> coef = [1,2,3] Chris@87: >>> hermval(1, coef) Chris@87: 11.0 Chris@87: >>> hermval([[1,2],[3,4]], coef) Chris@87: array([[ 11., 51.], Chris@87: [ 115., 203.]]) Chris@87: Chris@87: """ Chris@87: c = np.array(c, ndmin=1, copy=0) Chris@87: if c.dtype.char in '?bBhHiIlLqQpP': Chris@87: c = c.astype(np.double) Chris@87: if isinstance(x, (tuple, list)): Chris@87: x = np.asarray(x) Chris@87: if isinstance(x, np.ndarray) and tensor: Chris@87: c = c.reshape(c.shape + (1,)*x.ndim) Chris@87: Chris@87: x2 = x*2 Chris@87: if len(c) == 1: Chris@87: c0 = c[0] Chris@87: c1 = 0 Chris@87: elif len(c) == 2: Chris@87: c0 = c[0] Chris@87: c1 = c[1] Chris@87: else: Chris@87: nd = len(c) Chris@87: c0 = c[-2] Chris@87: c1 = c[-1] Chris@87: for i in range(3, len(c) + 1): Chris@87: tmp = c0 Chris@87: nd = nd - 1 Chris@87: c0 = c[-i] - c1*(2*(nd - 1)) Chris@87: c1 = tmp + c1*x2 Chris@87: return c0 + c1*x2 Chris@87: Chris@87: Chris@87: def hermval2d(x, y, c): Chris@87: """ Chris@87: Evaluate a 2-D Hermite series at points (x, y). Chris@87: Chris@87: This function returns the values: Chris@87: Chris@87: .. math:: p(x,y) = \\sum_{i,j} c_{i,j} * H_i(x) * H_j(y) Chris@87: Chris@87: The parameters `x` and `y` are converted to arrays only if they are Chris@87: tuples or a lists, otherwise they are treated as a scalars and they Chris@87: must have the same shape after conversion. In either case, either `x` Chris@87: and `y` or their elements must support multiplication and addition both Chris@87: with themselves and with the elements of `c`. Chris@87: Chris@87: If `c` is a 1-D array a one is implicitly appended to its shape to make Chris@87: it 2-D. The shape of the result will be c.shape[2:] + x.shape. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: x, y : array_like, compatible objects Chris@87: The two dimensional series is evaluated at the points `(x, y)`, Chris@87: where `x` and `y` must have the same shape. If `x` or `y` is a list Chris@87: or tuple, it is first converted to an ndarray, otherwise it is left Chris@87: unchanged and if it isn't an ndarray it is treated as a scalar. Chris@87: c : array_like Chris@87: Array of coefficients ordered so that the coefficient of the term Chris@87: of multi-degree i,j is contained in ``c[i,j]``. If `c` has Chris@87: dimension greater than two the remaining indices enumerate multiple Chris@87: sets of coefficients. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: values : ndarray, compatible object Chris@87: The values of the two dimensional polynomial at points formed with Chris@87: pairs of corresponding values from `x` and `y`. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermval, hermgrid2d, hermval3d, hermgrid3d Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: Chris@87: .. versionadded::1.7.0 Chris@87: Chris@87: """ Chris@87: try: Chris@87: x, y = np.array((x, y), copy=0) Chris@87: except: Chris@87: raise ValueError('x, y are incompatible') Chris@87: Chris@87: c = hermval(x, c) Chris@87: c = hermval(y, c, tensor=False) Chris@87: return c Chris@87: Chris@87: Chris@87: def hermgrid2d(x, y, c): Chris@87: """ Chris@87: Evaluate a 2-D Hermite series on the Cartesian product of x and y. Chris@87: Chris@87: This function returns the values: Chris@87: Chris@87: .. math:: p(a,b) = \sum_{i,j} c_{i,j} * H_i(a) * H_j(b) Chris@87: Chris@87: where the points `(a, b)` consist of all pairs formed by taking Chris@87: `a` from `x` and `b` from `y`. The resulting points form a grid with Chris@87: `x` in the first dimension and `y` in the second. Chris@87: Chris@87: The parameters `x` and `y` are converted to arrays only if they are Chris@87: tuples or a lists, otherwise they are treated as a scalars. In either Chris@87: case, either `x` and `y` or their elements must support multiplication Chris@87: and addition both with themselves and with the elements of `c`. Chris@87: Chris@87: If `c` has fewer than two dimensions, ones are implicitly appended to Chris@87: its shape to make it 2-D. The shape of the result will be c.shape[2:] + Chris@87: x.shape. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: x, y : array_like, compatible objects Chris@87: The two dimensional series is evaluated at the points in the Chris@87: Cartesian product of `x` and `y`. If `x` or `y` is a list or Chris@87: tuple, it is first converted to an ndarray, otherwise it is left Chris@87: unchanged and, if it isn't an ndarray, it is treated as a scalar. Chris@87: c : array_like Chris@87: Array of coefficients ordered so that the coefficients for terms of Chris@87: degree i,j are contained in ``c[i,j]``. If `c` has dimension Chris@87: greater than two the remaining indices enumerate multiple sets of Chris@87: coefficients. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: values : ndarray, compatible object Chris@87: The values of the two dimensional polynomial at points in the Cartesian Chris@87: product of `x` and `y`. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermval, hermval2d, hermval3d, hermgrid3d Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: Chris@87: .. versionadded::1.7.0 Chris@87: Chris@87: """ Chris@87: c = hermval(x, c) Chris@87: c = hermval(y, c) Chris@87: return c Chris@87: Chris@87: Chris@87: def hermval3d(x, y, z, c): Chris@87: """ Chris@87: Evaluate a 3-D Hermite series at points (x, y, z). Chris@87: Chris@87: This function returns the values: Chris@87: Chris@87: .. math:: p(x,y,z) = \\sum_{i,j,k} c_{i,j,k} * H_i(x) * H_j(y) * H_k(z) Chris@87: Chris@87: The parameters `x`, `y`, and `z` are converted to arrays only if Chris@87: they are tuples or a lists, otherwise they are treated as a scalars and Chris@87: they must have the same shape after conversion. In either case, either Chris@87: `x`, `y`, and `z` or their elements must support multiplication and Chris@87: addition both with themselves and with the elements of `c`. Chris@87: Chris@87: If `c` has fewer than 3 dimensions, ones are implicitly appended to its Chris@87: shape to make it 3-D. The shape of the result will be c.shape[3:] + Chris@87: x.shape. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: x, y, z : array_like, compatible object Chris@87: The three dimensional series is evaluated at the points Chris@87: `(x, y, z)`, where `x`, `y`, and `z` must have the same shape. If Chris@87: any of `x`, `y`, or `z` is a list or tuple, it is first converted Chris@87: to an ndarray, otherwise it is left unchanged and if it isn't an Chris@87: ndarray it is treated as a scalar. Chris@87: c : array_like Chris@87: Array of coefficients ordered so that the coefficient of the term of Chris@87: multi-degree i,j,k is contained in ``c[i,j,k]``. If `c` has dimension Chris@87: greater than 3 the remaining indices enumerate multiple sets of Chris@87: coefficients. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: values : ndarray, compatible object Chris@87: The values of the multidimensional polynomial on points formed with Chris@87: triples of corresponding values from `x`, `y`, and `z`. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermval, hermval2d, hermgrid2d, hermgrid3d Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: Chris@87: .. versionadded::1.7.0 Chris@87: Chris@87: """ Chris@87: try: Chris@87: x, y, z = np.array((x, y, z), copy=0) Chris@87: except: Chris@87: raise ValueError('x, y, z are incompatible') Chris@87: Chris@87: c = hermval(x, c) Chris@87: c = hermval(y, c, tensor=False) Chris@87: c = hermval(z, c, tensor=False) Chris@87: return c Chris@87: Chris@87: Chris@87: def hermgrid3d(x, y, z, c): Chris@87: """ Chris@87: Evaluate a 3-D Hermite series on the Cartesian product of x, y, and z. Chris@87: Chris@87: This function returns the values: Chris@87: Chris@87: .. math:: p(a,b,c) = \\sum_{i,j,k} c_{i,j,k} * H_i(a) * H_j(b) * H_k(c) Chris@87: Chris@87: where the points `(a, b, c)` consist of all triples formed by taking Chris@87: `a` from `x`, `b` from `y`, and `c` from `z`. The resulting points form Chris@87: a grid with `x` in the first dimension, `y` in the second, and `z` in Chris@87: the third. Chris@87: Chris@87: The parameters `x`, `y`, and `z` are converted to arrays only if they Chris@87: are tuples or a lists, otherwise they are treated as a scalars. In Chris@87: either case, either `x`, `y`, and `z` or their elements must support Chris@87: multiplication and addition both with themselves and with the elements Chris@87: of `c`. Chris@87: Chris@87: If `c` has fewer than three dimensions, ones are implicitly appended to Chris@87: its shape to make it 3-D. The shape of the result will be c.shape[3:] + Chris@87: x.shape + y.shape + z.shape. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: x, y, z : array_like, compatible objects Chris@87: The three dimensional series is evaluated at the points in the Chris@87: Cartesian product of `x`, `y`, and `z`. If `x`,`y`, or `z` is a Chris@87: list or tuple, it is first converted to an ndarray, otherwise it is Chris@87: left unchanged and, if it isn't an ndarray, it is treated as a Chris@87: scalar. Chris@87: c : array_like Chris@87: Array of coefficients ordered so that the coefficients for terms of Chris@87: degree i,j are contained in ``c[i,j]``. If `c` has dimension Chris@87: greater than two the remaining indices enumerate multiple sets of Chris@87: coefficients. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: values : ndarray, compatible object Chris@87: The values of the two dimensional polynomial at points in the Cartesian Chris@87: product of `x` and `y`. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermval, hermval2d, hermgrid2d, hermval3d Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: Chris@87: .. versionadded::1.7.0 Chris@87: Chris@87: """ Chris@87: c = hermval(x, c) Chris@87: c = hermval(y, c) Chris@87: c = hermval(z, c) Chris@87: return c Chris@87: Chris@87: Chris@87: def hermvander(x, deg): Chris@87: """Pseudo-Vandermonde matrix of given degree. Chris@87: Chris@87: Returns the pseudo-Vandermonde matrix of degree `deg` and sample points Chris@87: `x`. The pseudo-Vandermonde matrix is defined by Chris@87: Chris@87: .. math:: V[..., i] = H_i(x), Chris@87: Chris@87: where `0 <= i <= deg`. The leading indices of `V` index the elements of Chris@87: `x` and the last index is the degree of the Hermite polynomial. Chris@87: Chris@87: If `c` is a 1-D array of coefficients of length `n + 1` and `V` is the Chris@87: array ``V = hermvander(x, n)``, then ``np.dot(V, c)`` and Chris@87: ``hermval(x, c)`` are the same up to roundoff. This equivalence is Chris@87: useful both for least squares fitting and for the evaluation of a large Chris@87: number of Hermite series of the same degree and sample points. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: x : array_like Chris@87: Array of points. The dtype is converted to float64 or complex128 Chris@87: depending on whether any of the elements are complex. If `x` is Chris@87: scalar it is converted to a 1-D array. Chris@87: deg : int Chris@87: Degree of the resulting matrix. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: vander : ndarray Chris@87: The pseudo-Vandermonde matrix. The shape of the returned matrix is Chris@87: ``x.shape + (deg + 1,)``, where The last index is the degree of the Chris@87: corresponding Hermite polynomial. The dtype will be the same as Chris@87: the converted `x`. Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermvander Chris@87: >>> x = np.array([-1, 0, 1]) Chris@87: >>> hermvander(x, 3) Chris@87: array([[ 1., -2., 2., 4.], Chris@87: [ 1., 0., -2., -0.], Chris@87: [ 1., 2., 2., -4.]]) Chris@87: Chris@87: """ Chris@87: ideg = int(deg) Chris@87: if ideg != deg: Chris@87: raise ValueError("deg must be integer") Chris@87: if ideg < 0: Chris@87: raise ValueError("deg must be non-negative") Chris@87: Chris@87: x = np.array(x, copy=0, ndmin=1) + 0.0 Chris@87: dims = (ideg + 1,) + x.shape Chris@87: dtyp = x.dtype Chris@87: v = np.empty(dims, dtype=dtyp) Chris@87: v[0] = x*0 + 1 Chris@87: if ideg > 0: Chris@87: x2 = x*2 Chris@87: v[1] = x2 Chris@87: for i in range(2, ideg + 1): Chris@87: v[i] = (v[i-1]*x2 - v[i-2]*(2*(i - 1))) Chris@87: return np.rollaxis(v, 0, v.ndim) Chris@87: Chris@87: Chris@87: def hermvander2d(x, y, deg): Chris@87: """Pseudo-Vandermonde matrix of given degrees. Chris@87: Chris@87: Returns the pseudo-Vandermonde matrix of degrees `deg` and sample Chris@87: points `(x, y)`. The pseudo-Vandermonde matrix is defined by Chris@87: Chris@87: .. math:: V[..., deg[1]*i + j] = H_i(x) * H_j(y), Chris@87: Chris@87: where `0 <= i <= deg[0]` and `0 <= j <= deg[1]`. The leading indices of Chris@87: `V` index the points `(x, y)` and the last index encodes the degrees of Chris@87: the Hermite polynomials. Chris@87: Chris@87: If ``V = hermvander2d(x, y, [xdeg, ydeg])``, then the columns of `V` Chris@87: correspond to the elements of a 2-D coefficient array `c` of shape Chris@87: (xdeg + 1, ydeg + 1) in the order Chris@87: Chris@87: .. math:: c_{00}, c_{01}, c_{02} ... , c_{10}, c_{11}, c_{12} ... Chris@87: Chris@87: and ``np.dot(V, c.flat)`` and ``hermval2d(x, y, c)`` will be the same Chris@87: up to roundoff. This equivalence is useful both for least squares Chris@87: fitting and for the evaluation of a large number of 2-D Hermite Chris@87: series of the same degrees and sample points. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: x, y : array_like Chris@87: Arrays of point coordinates, all of the same shape. The dtypes Chris@87: will be converted to either float64 or complex128 depending on Chris@87: whether any of the elements are complex. Scalars are converted to 1-D Chris@87: arrays. Chris@87: deg : list of ints Chris@87: List of maximum degrees of the form [x_deg, y_deg]. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: vander2d : ndarray Chris@87: The shape of the returned matrix is ``x.shape + (order,)``, where Chris@87: :math:`order = (deg[0]+1)*(deg([1]+1)`. The dtype will be the same Chris@87: as the converted `x` and `y`. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermvander, hermvander3d. hermval2d, hermval3d Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: Chris@87: .. versionadded::1.7.0 Chris@87: Chris@87: """ Chris@87: ideg = [int(d) for d in deg] Chris@87: is_valid = [id == d and id >= 0 for id, d in zip(ideg, deg)] Chris@87: if is_valid != [1, 1]: Chris@87: raise ValueError("degrees must be non-negative integers") Chris@87: degx, degy = ideg Chris@87: x, y = np.array((x, y), copy=0) + 0.0 Chris@87: Chris@87: vx = hermvander(x, degx) Chris@87: vy = hermvander(y, degy) Chris@87: v = vx[..., None]*vy[..., None,:] Chris@87: return v.reshape(v.shape[:-2] + (-1,)) Chris@87: Chris@87: Chris@87: def hermvander3d(x, y, z, deg): Chris@87: """Pseudo-Vandermonde matrix of given degrees. Chris@87: Chris@87: Returns the pseudo-Vandermonde matrix of degrees `deg` and sample Chris@87: points `(x, y, z)`. If `l, m, n` are the given degrees in `x, y, z`, Chris@87: then The pseudo-Vandermonde matrix is defined by Chris@87: Chris@87: .. math:: V[..., (m+1)(n+1)i + (n+1)j + k] = H_i(x)*H_j(y)*H_k(z), Chris@87: Chris@87: where `0 <= i <= l`, `0 <= j <= m`, and `0 <= j <= n`. The leading Chris@87: indices of `V` index the points `(x, y, z)` and the last index encodes Chris@87: the degrees of the Hermite polynomials. Chris@87: Chris@87: If ``V = hermvander3d(x, y, z, [xdeg, ydeg, zdeg])``, then the columns Chris@87: of `V` correspond to the elements of a 3-D coefficient array `c` of Chris@87: shape (xdeg + 1, ydeg + 1, zdeg + 1) in the order Chris@87: Chris@87: .. math:: c_{000}, c_{001}, c_{002},... , c_{010}, c_{011}, c_{012},... Chris@87: Chris@87: and ``np.dot(V, c.flat)`` and ``hermval3d(x, y, z, c)`` will be the Chris@87: same up to roundoff. This equivalence is useful both for least squares Chris@87: fitting and for the evaluation of a large number of 3-D Hermite Chris@87: series of the same degrees and sample points. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: x, y, z : array_like Chris@87: Arrays of point coordinates, all of the same shape. The dtypes will Chris@87: be converted to either float64 or complex128 depending on whether Chris@87: any of the elements are complex. Scalars are converted to 1-D Chris@87: arrays. Chris@87: deg : list of ints Chris@87: List of maximum degrees of the form [x_deg, y_deg, z_deg]. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: vander3d : ndarray Chris@87: The shape of the returned matrix is ``x.shape + (order,)``, where Chris@87: :math:`order = (deg[0]+1)*(deg([1]+1)*(deg[2]+1)`. The dtype will Chris@87: be the same as the converted `x`, `y`, and `z`. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: hermvander, hermvander3d. hermval2d, hermval3d Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: Chris@87: .. versionadded::1.7.0 Chris@87: Chris@87: """ Chris@87: ideg = [int(d) for d in deg] Chris@87: is_valid = [id == d and id >= 0 for id, d in zip(ideg, deg)] Chris@87: if is_valid != [1, 1, 1]: Chris@87: raise ValueError("degrees must be non-negative integers") Chris@87: degx, degy, degz = ideg Chris@87: x, y, z = np.array((x, y, z), copy=0) + 0.0 Chris@87: Chris@87: vx = hermvander(x, degx) Chris@87: vy = hermvander(y, degy) Chris@87: vz = hermvander(z, degz) Chris@87: v = vx[..., None, None]*vy[..., None,:, None]*vz[..., None, None,:] Chris@87: return v.reshape(v.shape[:-3] + (-1,)) Chris@87: Chris@87: Chris@87: def hermfit(x, y, deg, rcond=None, full=False, w=None): Chris@87: """ Chris@87: Least squares fit of Hermite series to data. Chris@87: Chris@87: Return the coefficients of a Hermite series of degree `deg` that is the Chris@87: least squares fit to the data values `y` given at points `x`. If `y` is Chris@87: 1-D the returned coefficients will also be 1-D. If `y` is 2-D multiple Chris@87: fits are done, one for each column of `y`, and the resulting Chris@87: coefficients are stored in the corresponding columns of a 2-D return. Chris@87: The fitted polynomial(s) are in the form Chris@87: Chris@87: .. math:: p(x) = c_0 + c_1 * H_1(x) + ... + c_n * H_n(x), Chris@87: Chris@87: where `n` is `deg`. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: x : array_like, shape (M,) Chris@87: x-coordinates of the M sample points ``(x[i], y[i])``. Chris@87: y : array_like, shape (M,) or (M, K) Chris@87: y-coordinates of the sample points. Several data sets of sample Chris@87: points sharing the same x-coordinates can be fitted at once by Chris@87: passing in a 2D-array that contains one dataset per column. Chris@87: deg : int Chris@87: Degree of the fitting polynomial Chris@87: rcond : float, optional Chris@87: Relative condition number of the fit. Singular values smaller than Chris@87: this relative to the largest singular value will be ignored. The Chris@87: default value is len(x)*eps, where eps is the relative precision of Chris@87: the float type, about 2e-16 in most cases. Chris@87: full : bool, optional Chris@87: Switch determining nature of return value. When it is False (the Chris@87: default) just the coefficients are returned, when True diagnostic Chris@87: information from the singular value decomposition is also returned. Chris@87: w : array_like, shape (`M`,), optional Chris@87: Weights. If not None, the contribution of each point Chris@87: ``(x[i],y[i])`` to the fit is weighted by `w[i]`. Ideally the Chris@87: weights are chosen so that the errors of the products ``w[i]*y[i]`` Chris@87: all have the same variance. The default value is None. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: coef : ndarray, shape (M,) or (M, K) Chris@87: Hermite coefficients ordered from low to high. If `y` was 2-D, Chris@87: the coefficients for the data in column k of `y` are in column Chris@87: `k`. Chris@87: Chris@87: [residuals, rank, singular_values, rcond] : list Chris@87: These values are only returned if `full` = True Chris@87: Chris@87: resid -- sum of squared residuals of the least squares fit Chris@87: rank -- the numerical rank of the scaled Vandermonde matrix Chris@87: sv -- singular values of the scaled Vandermonde matrix Chris@87: rcond -- value of `rcond`. Chris@87: Chris@87: For more details, see `linalg.lstsq`. Chris@87: Chris@87: Warns Chris@87: ----- Chris@87: RankWarning Chris@87: The rank of the coefficient matrix in the least-squares fit is Chris@87: deficient. The warning is only raised if `full` = False. The Chris@87: warnings can be turned off by Chris@87: Chris@87: >>> import warnings Chris@87: >>> warnings.simplefilter('ignore', RankWarning) Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: chebfit, legfit, lagfit, polyfit, hermefit Chris@87: hermval : Evaluates a Hermite series. Chris@87: hermvander : Vandermonde matrix of Hermite series. Chris@87: hermweight : Hermite weight function Chris@87: linalg.lstsq : Computes a least-squares fit from the matrix. Chris@87: scipy.interpolate.UnivariateSpline : Computes spline fits. Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: The solution is the coefficients of the Hermite series `p` that Chris@87: minimizes the sum of the weighted squared errors Chris@87: Chris@87: .. math:: E = \\sum_j w_j^2 * |y_j - p(x_j)|^2, Chris@87: Chris@87: where the :math:`w_j` are the weights. This problem is solved by Chris@87: setting up the (typically) overdetermined matrix equation Chris@87: Chris@87: .. math:: V(x) * c = w * y, Chris@87: Chris@87: where `V` is the weighted pseudo Vandermonde matrix of `x`, `c` are the Chris@87: coefficients to be solved for, `w` are the weights, `y` are the Chris@87: observed values. This equation is then solved using the singular value Chris@87: decomposition of `V`. Chris@87: Chris@87: If some of the singular values of `V` are so small that they are Chris@87: neglected, then a `RankWarning` will be issued. This means that the Chris@87: coefficient values may be poorly determined. Using a lower order fit Chris@87: will usually get rid of the warning. The `rcond` parameter can also be Chris@87: set to a value smaller than its default, but the resulting fit may be Chris@87: spurious and have large contributions from roundoff error. Chris@87: Chris@87: Fits using Hermite series are probably most useful when the data can be Chris@87: approximated by ``sqrt(w(x)) * p(x)``, where `w(x)` is the Hermite Chris@87: weight. In that case the weight ``sqrt(w(x[i])`` should be used Chris@87: together with data values ``y[i]/sqrt(w(x[i])``. The weight function is Chris@87: available as `hermweight`. Chris@87: Chris@87: References Chris@87: ---------- Chris@87: .. [1] Wikipedia, "Curve fitting", Chris@87: http://en.wikipedia.org/wiki/Curve_fitting Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermfit, hermval Chris@87: >>> x = np.linspace(-10, 10) Chris@87: >>> err = np.random.randn(len(x))/10 Chris@87: >>> y = hermval(x, [1, 2, 3]) + err Chris@87: >>> hermfit(x, y, 2) Chris@87: array([ 0.97902637, 1.99849131, 3.00006 ]) Chris@87: Chris@87: """ Chris@87: order = int(deg) + 1 Chris@87: x = np.asarray(x) + 0.0 Chris@87: y = np.asarray(y) + 0.0 Chris@87: Chris@87: # check arguments. Chris@87: if deg < 0: Chris@87: raise ValueError("expected deg >= 0") Chris@87: if x.ndim != 1: Chris@87: raise TypeError("expected 1D vector for x") Chris@87: if x.size == 0: Chris@87: raise TypeError("expected non-empty vector for x") Chris@87: if y.ndim < 1 or y.ndim > 2: Chris@87: raise TypeError("expected 1D or 2D array for y") Chris@87: if len(x) != len(y): Chris@87: raise TypeError("expected x and y to have same length") Chris@87: Chris@87: # set up the least squares matrices in transposed form Chris@87: lhs = hermvander(x, deg).T Chris@87: rhs = y.T Chris@87: if w is not None: Chris@87: w = np.asarray(w) + 0.0 Chris@87: if w.ndim != 1: Chris@87: raise TypeError("expected 1D vector for w") Chris@87: if len(x) != len(w): Chris@87: raise TypeError("expected x and w to have same length") Chris@87: # apply weights. Don't use inplace operations as they Chris@87: # can cause problems with NA. Chris@87: lhs = lhs * w Chris@87: rhs = rhs * w Chris@87: Chris@87: # set rcond Chris@87: if rcond is None: Chris@87: rcond = len(x)*np.finfo(x.dtype).eps Chris@87: Chris@87: # Determine the norms of the design matrix columns. Chris@87: if issubclass(lhs.dtype.type, np.complexfloating): Chris@87: scl = np.sqrt((np.square(lhs.real) + np.square(lhs.imag)).sum(1)) Chris@87: else: Chris@87: scl = np.sqrt(np.square(lhs).sum(1)) Chris@87: scl[scl == 0] = 1 Chris@87: Chris@87: # Solve the least squares problem. Chris@87: c, resids, rank, s = la.lstsq(lhs.T/scl, rhs.T, rcond) Chris@87: c = (c.T/scl).T Chris@87: Chris@87: # warn on rank reduction Chris@87: if rank != order and not full: Chris@87: msg = "The fit may be poorly conditioned" Chris@87: warnings.warn(msg, pu.RankWarning) Chris@87: Chris@87: if full: Chris@87: return c, [resids, rank, s, rcond] Chris@87: else: Chris@87: return c Chris@87: Chris@87: Chris@87: def hermcompanion(c): Chris@87: """Return the scaled companion matrix of c. Chris@87: Chris@87: The basis polynomials are scaled so that the companion matrix is Chris@87: symmetric when `c` is an Hermite basis polynomial. This provides Chris@87: better eigenvalue estimates than the unscaled case and for basis Chris@87: polynomials the eigenvalues are guaranteed to be real if Chris@87: `numpy.linalg.eigvalsh` is used to obtain them. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: c : array_like Chris@87: 1-D array of Hermite series coefficients ordered from low to high Chris@87: degree. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: mat : ndarray Chris@87: Scaled companion matrix of dimensions (deg, deg). Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: Chris@87: .. versionadded::1.7.0 Chris@87: Chris@87: """ Chris@87: # c is a trimmed copy Chris@87: [c] = pu.as_series([c]) Chris@87: if len(c) < 2: Chris@87: raise ValueError('Series must have maximum degree of at least 1.') Chris@87: if len(c) == 2: Chris@87: return np.array([[-.5*c[0]/c[1]]]) Chris@87: Chris@87: n = len(c) - 1 Chris@87: mat = np.zeros((n, n), dtype=c.dtype) Chris@87: scl = np.hstack((1., np.sqrt(2.*np.arange(1, n)))) Chris@87: scl = np.multiply.accumulate(scl) Chris@87: top = mat.reshape(-1)[1::n+1] Chris@87: bot = mat.reshape(-1)[n::n+1] Chris@87: top[...] = np.sqrt(.5*np.arange(1, n)) Chris@87: bot[...] = top Chris@87: mat[:, -1] -= (c[:-1]/c[-1])*(scl/scl[-1])*.5 Chris@87: return mat Chris@87: Chris@87: Chris@87: def hermroots(c): Chris@87: """ Chris@87: Compute the roots of a Hermite series. Chris@87: Chris@87: Return the roots (a.k.a. "zeros") of the polynomial Chris@87: Chris@87: .. math:: p(x) = \\sum_i c[i] * H_i(x). Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: c : 1-D array_like Chris@87: 1-D array of coefficients. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: out : ndarray Chris@87: Array of the roots of the series. If all the roots are real, Chris@87: then `out` is also real, otherwise it is complex. Chris@87: Chris@87: See Also Chris@87: -------- Chris@87: polyroots, legroots, lagroots, chebroots, hermeroots Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: The root estimates are obtained as the eigenvalues of the companion Chris@87: matrix, Roots far from the origin of the complex plane may have large Chris@87: errors due to the numerical instability of the series for such Chris@87: values. Roots with multiplicity greater than 1 will also show larger Chris@87: errors as the value of the series near such points is relatively Chris@87: insensitive to errors in the roots. Isolated roots near the origin can Chris@87: be improved by a few iterations of Newton's method. Chris@87: Chris@87: The Hermite series basis polynomials aren't powers of `x` so the Chris@87: results of this function may seem unintuitive. Chris@87: Chris@87: Examples Chris@87: -------- Chris@87: >>> from numpy.polynomial.hermite import hermroots, hermfromroots Chris@87: >>> coef = hermfromroots([-1, 0, 1]) Chris@87: >>> coef Chris@87: array([ 0. , 0.25 , 0. , 0.125]) Chris@87: >>> hermroots(coef) Chris@87: array([ -1.00000000e+00, -1.38777878e-17, 1.00000000e+00]) Chris@87: Chris@87: """ Chris@87: # c is a trimmed copy Chris@87: [c] = pu.as_series([c]) Chris@87: if len(c) <= 1: Chris@87: return np.array([], dtype=c.dtype) Chris@87: if len(c) == 2: Chris@87: return np.array([-.5*c[0]/c[1]]) Chris@87: Chris@87: m = hermcompanion(c) Chris@87: r = la.eigvals(m) Chris@87: r.sort() Chris@87: return r Chris@87: Chris@87: Chris@87: def hermgauss(deg): Chris@87: """ Chris@87: Gauss-Hermite quadrature. Chris@87: Chris@87: Computes the sample points and weights for Gauss-Hermite quadrature. Chris@87: These sample points and weights will correctly integrate polynomials of Chris@87: degree :math:`2*deg - 1` or less over the interval :math:`[-\inf, \inf]` Chris@87: with the weight function :math:`f(x) = \exp(-x^2)`. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: deg : int Chris@87: Number of sample points and weights. It must be >= 1. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: x : ndarray Chris@87: 1-D ndarray containing the sample points. Chris@87: y : ndarray Chris@87: 1-D ndarray containing the weights. Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: Chris@87: .. versionadded::1.7.0 Chris@87: Chris@87: The results have only been tested up to degree 100, higher degrees may Chris@87: be problematic. The weights are determined by using the fact that Chris@87: Chris@87: .. math:: w_k = c / (H'_n(x_k) * H_{n-1}(x_k)) Chris@87: Chris@87: where :math:`c` is a constant independent of :math:`k` and :math:`x_k` Chris@87: is the k'th root of :math:`H_n`, and then scaling the results to get Chris@87: the right value when integrating 1. Chris@87: Chris@87: """ Chris@87: ideg = int(deg) Chris@87: if ideg != deg or ideg < 1: Chris@87: raise ValueError("deg must be a non-negative integer") Chris@87: Chris@87: # first approximation of roots. We use the fact that the companion Chris@87: # matrix is symmetric in this case in order to obtain better zeros. Chris@87: c = np.array([0]*deg + [1]) Chris@87: m = hermcompanion(c) Chris@87: x = la.eigvals(m) Chris@87: x.sort() Chris@87: Chris@87: # improve roots by one application of Newton Chris@87: dy = hermval(x, c) Chris@87: df = hermval(x, hermder(c)) Chris@87: x -= dy/df Chris@87: Chris@87: # compute the weights. We scale the factor to avoid possible numerical Chris@87: # overflow. Chris@87: fm = hermval(x, c[1:]) Chris@87: fm /= np.abs(fm).max() Chris@87: df /= np.abs(df).max() Chris@87: w = 1/(fm * df) Chris@87: Chris@87: # for Hermite we can also symmetrize Chris@87: w = (w + w[::-1])/2 Chris@87: x = (x - x[::-1])/2 Chris@87: Chris@87: # scale w to get the right value Chris@87: w *= np.sqrt(np.pi) / w.sum() Chris@87: Chris@87: return x, w Chris@87: Chris@87: Chris@87: def hermweight(x): Chris@87: """ Chris@87: Weight function of the Hermite polynomials. Chris@87: Chris@87: The weight function is :math:`\exp(-x^2)` and the interval of Chris@87: integration is :math:`[-\inf, \inf]`. the Hermite polynomials are Chris@87: orthogonal, but not normalized, with respect to this weight function. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: x : array_like Chris@87: Values at which the weight function will be computed. Chris@87: Chris@87: Returns Chris@87: ------- Chris@87: w : ndarray Chris@87: The weight function at `x`. Chris@87: Chris@87: Notes Chris@87: ----- Chris@87: Chris@87: .. versionadded::1.7.0 Chris@87: Chris@87: """ Chris@87: w = np.exp(-x**2) Chris@87: return w Chris@87: Chris@87: Chris@87: # Chris@87: # Hermite series class Chris@87: # Chris@87: Chris@87: class Hermite(ABCPolyBase): Chris@87: """An Hermite series class. Chris@87: Chris@87: The Hermite class provides the standard Python numerical methods Chris@87: '+', '-', '*', '//', '%', 'divmod', '**', and '()' as well as the Chris@87: attributes and methods listed in the `ABCPolyBase` documentation. Chris@87: Chris@87: Parameters Chris@87: ---------- Chris@87: coef : array_like Chris@87: Laguerre coefficients in order of increasing degree, i.e, Chris@87: ``(1, 2, 3)`` gives ``1*H_0(x) + 2*H_1(X) + 3*H_2(x)``. Chris@87: domain : (2,) array_like, optional Chris@87: Domain to use. The interval ``[domain[0], domain[1]]`` is mapped Chris@87: to the interval ``[window[0], window[1]]`` by shifting and scaling. Chris@87: The default value is [-1, 1]. Chris@87: window : (2,) array_like, optional Chris@87: Window, see `domain` for its use. The default value is [-1, 1]. Chris@87: Chris@87: .. versionadded:: 1.6.0 Chris@87: Chris@87: """ Chris@87: # Virtual Functions Chris@87: _add = staticmethod(hermadd) Chris@87: _sub = staticmethod(hermsub) Chris@87: _mul = staticmethod(hermmul) Chris@87: _div = staticmethod(hermdiv) Chris@87: _pow = staticmethod(hermpow) Chris@87: _val = staticmethod(hermval) Chris@87: _int = staticmethod(hermint) Chris@87: _der = staticmethod(hermder) Chris@87: _fit = staticmethod(hermfit) Chris@87: _line = staticmethod(hermline) Chris@87: _roots = staticmethod(hermroots) Chris@87: _fromroots = staticmethod(hermfromroots) Chris@87: Chris@87: # Virtual properties Chris@87: nickname = 'herm' Chris@87: domain = np.array(hermdomain) Chris@87: window = np.array(hermdomain)