numpy.divide(x1, x2[, out]) = Divide arguments element-wise. Parameters: x1 : array_like Dividend array. x2 : array_like Divisor array. out : ndarray, optional Array into which the output is placed. Its type is preserved and it must be of the right shape to hold the output. See doc.ufuncs. Returns: y : ndarray or scalar The quotient x1/x2, element-wise. Returns a scalar if both x1 and x2 are scalars. See also seterr Set whether to raise or warn on overflow, underflow and di

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

numpy.testing.assert_array_less(x, y, err_msg='', verbose=True) [source] Raises an AssertionError if two array_like objects are not ordered by less than. Given two array_like objects, check that the shape is equal and all elements of the first object are strictly smaller than those of the second object. An exception is raised at shape mismatch or incorrectly ordered values. Shape mismatch does not raise if an object has zero dimension. In contrast to the standard usage in numpy, NaNs are co

numpy.ma.min(obj, axis=None, out=None, fill_value=None) [source] Return the minimum along a given axis. Parameters: axis : {None, int}, optional Axis along which to operate. By default, axis is None and the flattened input is used. out : array_like, optional Alternative output array in which to place the result. Must be of the same shape and buffer length as the expected output. fill_value : {var}, optional Value used to fill in the masked values. If None, use the output of minimum_fi

MaskedArray.__setslice__(i, j, value) [source] x.__setslice__(i, j, value) <==> x[i:j]=value Set the slice (i,j) of a to value. If value is masked, mask those locations.

numpy.ma.transpose(a, axes=None) [source] Permute the dimensions of an array. This function is exactly equivalent to numpy.transpose. See also numpy.transpose Equivalent function in top-level NumPy module. Examples >>> import numpy.ma as ma >>> x = ma.arange(4).reshape((2,2)) >>> x[1, 1] = ma.masked >>>> x masked_array(data = [[0 1] [2 --]], mask = [[False False] [False True]], fill_value = 999999) >>> ma.transpos

numpy.ma.asanyarray(a, dtype=None) [source] Convert the input to a masked array, conserving subclasses. If a is a subclass of MaskedArray, its class is conserved. No copy is performed if the input is already an ndarray. Parameters: a : array_like Input data, in any form that can be converted to an array. dtype : dtype, optional By default, the data-type is inferred from the input data. order : {?C?, ?F?}, optional Whether to use row-major (?C?) or column-major (?FORTRAN?) memory repre

numpy.ma.innerproduct(a, b) [source] Inner product of two arrays. Ordinary inner product of vectors for 1-D arrays (without complex conjugation), in higher dimensions a sum product over the last axes. Parameters: a, b : array_like If a and b are nonscalar, their last dimensions must match. Returns: out : ndarray out.shape = a.shape[:-1] + b.shape[:-1] Raises: ValueError If the last dimension of a and b has different size. See also tensordot Sum products over arbitrary axes.

numpy.ma.concatenate(arrays, axis=0) [source] Concatenate a sequence of arrays along the given axis. Parameters: arrays : sequence of array_like The arrays must have the same shape, except in the dimension corresponding to axis (the first, by default). axis : int, optional The axis along which the arrays will be joined. Default is 0. Returns: result : MaskedArray The concatenated array with any masked entries preserved. See also numpy.concatenate Equivalent function in the top

MaskedArray.shape Tuple of array dimensions. Notes May be used to ?reshape? the array, as long as this would not require a change in the total number of elements Examples >>> x = np.array([1, 2, 3, 4]) >>> x.shape (4,) >>> y = np.zeros((2, 3, 4)) >>> y.shape (2, 3, 4) >>> y.shape = (3, 8) >>> y array([[ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.]