hermeint(c, m=1, k=[], lbnd=0, scl=1, axis=0)
Returns the Hermite_e series coefficients c integrated m times from :None:None:`lbnd` along :None:None:`axis`. At each iteration the resulting series is multiplied by :None:None:`scl` and an integration constant, k, is added. The scaling factor is for use in a linear change of variable. ("Buyer beware": note that, depending on what one is doing, one may want :None:None:`scl` to be the reciprocal of what one might expect; for more information, see the Notes section below.) The argument c is an array of coefficients from low to high degree along each axis, e.g., [1,2,3] represents the series H_0 + 2*H_1 + 3*H_2
while [[1,2],[1,2]] represents 1*H_0(x)*H_0(y) + 1*H_1(x)*H_0(y) + 2*H_0(x)*H_1(y) +
2*H_1(x)*H_1(y)
if axis=0 is x
and axis=1 is y
.
Note that the result of each integration is multiplied by :None:None:`scl`. Why is this important to note? Say one is making a linear change of variable $u = ax + b$
in an integral relative to x. Then $dx = du/a$
, so one will need to set :None:None:`scl` equal to $1/a$
- perhaps not what one would have first thought.
Also note that, in general, the result of integrating a C-series needs to be "reprojected" onto the C-series basis set. Thus, typically, the result of this function is "unintuitive," albeit correct; see Examples section below.
Array of Hermite_e series coefficients. If c is multidimensional the different axis correspond to different variables with the degree in each axis given by the corresponding index.
Order of integration, must be positive. (Default: 1)
Integration constant(s). The value of the first integral at lbnd
is the first value in the list, the value of the second integral at lbnd
is the second value, etc. If k == []
(the default), all constants are set to zero. If m == 1
, a single scalar can be given instead of a list.
The lower bound of the integral. (Default: 0)
Following each integration the result is multiplied by :None:None:`scl` before the integration constant is added. (Default: 1)
Axis over which the integral is taken. (Default: 0).
If m < 0
, len(k) > m
, np.ndim(lbnd) != 0
, or np.ndim(scl) != 0
.
Hermite_e series coefficients of the integral.
Integrate a Hermite_e series.
>>> from numpy.polynomial.hermite_e import hermeint
... hermeint([1, 2, 3]) # integrate once, value 0 at 0. array([1., 1., 1., 1.])
>>> hermeint([1, 2, 3], m=2) # integrate twice, value & deriv 0 at 0 array([-0.25 , 1. , 0.5 , 0.33333333, 0.25 ]) # may vary
>>> hermeint([1, 2, 3], k=1) # integrate once, value 1 at 0. array([2., 1., 1., 1.])
>>> hermeint([1, 2, 3], lbnd=-1) # integrate once, value 0 at -1 array([-1., 1., 1., 1.])
>>> hermeint([1, 2, 3], m=2, k=[1, 2], lbnd=-1) array([ 1.83333333, 0. , 0.5 , 0.33333333, 0.25 ]) # may varySee :
The following pages refer to to this document either explicitly or contain code examples using this.
numpy.polynomial.hermite_e.hermeder
Hover to see nodes names; edges to Self not shown, Caped at 50 nodes.
Using a canvas is more power efficient and can get hundred of nodes ; but does not allow hyperlinks; , arrows or text (beyond on hover)
SVG is more flexible but power hungry; and does not scale well to 50 + nodes.
All aboves nodes referred to, (or are referred from) current nodes; Edges from Self to other have been omitted (or all nodes would be connected to the central node "self" which is not useful). Nodes are colored by the library they belong to, and scaled with the number of references pointing them