numpy.random.beta()

numpy.random.beta(a, b, size=None) Draw samples from a Beta distribution. The Beta distribution is a special case of the Dirichlet distribution, and is related to the Gamma distribution. It has the probability distribution function where the normalisation, B, is the beta function, It is often seen in Bayesian inference and order statistics. Parameters: a : float Alpha, non-negative. b : float Beta, non-negative. size : int or tuple of ints, optional Output shape. If the given sh

ndarray.partition()

ndarray.partition(kth, axis=-1, kind='introselect', order=None) Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array. All elements smaller than the kth element are moved before this element and all equal or greater are moved behind it. The ordering of the elements in the two partitions is undefined. New in version 1.8.0. Parameters: kth : int or sequence of ints Element index to partition by. The kt

numpy.polynomial.legendre.legadd()

numpy.polynomial.legendre.legadd(c1, c2) [source] Add one Legendre series to another. Returns the sum of two Legendre series c1 + c2. The arguments are sequences of coefficients ordered from lowest order term to highest, i.e., [1,2,3] represents the series P_0 + 2*P_1 + 3*P_2. Parameters: c1, c2 : array_like 1-D arrays of Legendre series coefficients ordered from low to high. Returns: out : ndarray Array representing the Legendre series of their sum. See also legsub, legmul, legdiv

numpy.core.defchararray.isnumeric()

numpy.core.defchararray.isnumeric(a) [source] For each element, return True if there are only numeric characters in the element. Calls unicode.isnumeric element-wise. Numeric characters include digit characters, and all characters that have the Unicode numeric value property, e.g. U+2155, VULGAR FRACTION ONE FIFTH. Parameters: a : array_like, unicode Input array. Returns: out : ndarray, bool Array of booleans of same shape as a. See also unicode.isnumeric

numpy.i0()

numpy.i0(x) [source] Modified Bessel function of the first kind, order 0. Usually denoted . This function does broadcast, but will not ?up-cast? int dtype arguments unless accompanied by at least one float or complex dtype argument (see Raises below). Parameters: x : array_like, dtype float or complex Argument of the Bessel function. Returns: out : ndarray, shape = x.shape, dtype = x.dtype The modified Bessel function evaluated at each of the elements of x. Raises: TypeError: array

numpy.polynomial.legendre.legweight()

numpy.polynomial.legendre.legweight(x) [source] Weight function of the Legendre polynomials. The weight function is and the interval of integration is . The Legendre polynomials are orthogonal, but not normalized, with respect to this weight function. Parameters: x : array_like Values at which the weight function will be computed. Returns: w : ndarray The weight function at x. Notes

ndarray.__divmod__()

ndarray.__divmod__(y) <==> divmod(x, y)

ndarray.min()

ndarray.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

numpy.ma.empty_like()

numpy.ma.empty_like(a, dtype=None, order='K', subok=True) = Return a new array with the same shape and type as a given array. Parameters: a : array_like The shape and data-type of a define these same attributes of the returned array. dtype : data-type, optional Overrides the data type of the result. New in version 1.6.0. order : {?C?, ?F?, ?A?, or ?K?}, optional Overrides the memory layout of the result. ?C? means C-order, ?F? means F-order, ?A? means ?F? if a is Fortran contiguous

numpy.ma.flatnotmasked_contiguous()

numpy.ma.flatnotmasked_contiguous(a) [source] Find contiguous unmasked data in a masked array along the given axis. Parameters: a : narray The input array. Returns: slice_list : list A sorted sequence of slices (start index, end index). See also flatnotmasked_edges, notmasked_contiguous, notmasked_edges, clump_masked, clump_unmasked Notes Only accepts 2-D arrays at most. Examples >>> a = np.ma.arange(10) >>> np.ma.flatnotmasked_contiguous(a) slice(0, 10, None) &