ndarray.getfield(dtype, offset=0) Returns a field of the given array as a certain type. A field is a view of the array data with a given data-type. The values in the view are determined by the given type and the offset into the current array in bytes. The offset needs to be such that the view dtype fits in the array dtype; for example an array of dtype complex128 has 16-byte elements. If taking a view with a 32-bit integer (4 bytes), the offset needs to be between 0 and 12 bytes. Parameters

generic.tolist() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See also The

Hermite.mapparms() [source] Return the mapping parameters. The returned values define a linear map off + scl*x that is applied to the input arguments before the series is evaluated. The map depends on the domain and window; if the current domain is equal to the window the resulting map is the identity. If the coefficients of the series instance are to be used by themselves outside this class, then the linear function must be substituted for the x in the standard representation of the base p

MaskedArray.ptp(axis=None, out=None, fill_value=None) [source] Return (maximum - minimum) along the the given dimension (i.e. peak-to-peak value). Parameters: axis : {None, int}, optional Axis along which to find the peaks. If None (default) the flattened array is used. out : {None, array_like}, optional Alternative output array in which to place the result. It must have the same shape and buffer length as the expected output but the type will be cast if necessary. fill_value : {var},

numpy.polynomial.hermite.hermmulx(c) [source] Multiply a Hermite series by x. Multiply the Hermite series c by x, where x is the independent variable. Parameters: c : array_like 1-D array of Hermite series coefficients ordered from low to high. Returns: out : ndarray Array representing the result of the multiplication. Notes The multiplication uses the recursion relationship for Hermite polynomials in the form xP_i(x) = (P_{i + 1}(x)/2 + i*P_{i - 1}(x)) Examples >>> from

record.setfield()

numpy.fft.fftfreq(n, d=1.0) [source] Return the Discrete Fourier Transform sample frequencies. The returned float array f contains the frequency bin centers in cycles per unit of the sample spacing (with zero at the start). For instance, if the sample spacing is in seconds, then the frequency unit is cycles/second. Given a window length n and a sample spacing d: f = [0, 1, ..., n/2-1, -n/2, ..., -1] / (d*n) if n is even f = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n) if n is o

recarray.min(axis=None, out=None, keepdims=False) Return the minimum along a given axis. Refer to numpy.amin for full documentation. See also numpy.amin equivalent function

Legendre.__call__(arg) [source]

HermiteE.deriv(m=1) [source] Differentiate. Return a series instance of that is the derivative of the current series. Parameters: m : non-negative int Find the derivative of order m. Returns: new_series : series A new series representing the derivative. The domain is the same as the domain of the differentiated series.