numpy.polynomial.legendre.legroots(c) [source] Compute the roots of a Legendre series. Return the roots (a.k.a. ?zeros?) of the polynomial Parameters: c : 1-D array_like 1-D array of coefficients. Returns: out : ndarray Array of the roots of the series. If all the roots are real, then out is also real, otherwise it is complex. See also polyroots, chebroots, lagroots, hermroots, hermeroots Notes The root estimates are obtained as the eigenvalues of the companion matrix, Roots fa

ndarray.__ifloordiv__ x.__ifloordiv__(y) <==> x//y

recarray.put(indices, values, mode='raise') Set a.flat[n] = values[n] for all n in indices. Refer to numpy.put for full documentation. See also numpy.put equivalent function

numpy.polynomial.legendre.legval2d(x, y, c) [source] Evaluate a 2-D Legendre series at points (x, y). This function returns the values: The parameters x and y are converted to arrays only if they are tuples or a lists, otherwise they are treated as a scalars and they must have the same shape after conversion. In either case, either x and y or their elements must support multiplication and addition both with themselves and with the elements of c. If c is a 1-D array a one is implicitly ap

numpy.ma.count_masked(arr, axis=None) [source] Count the number of masked elements along the given axis. Parameters: arr : array_like An array with (possibly) masked elements. axis : int, optional Axis along which to count. If None (default), a flattened version of the array is used. Returns: count : int, ndarray The total number of masked elements (axis=None) or the number of masked elements along each slice of the given axis. See also MaskedArray.count Count non-masked eleme

numpy.polynomial.legendre.legder(c, m=1, scl=1, axis=0) [source] Differentiate a Legendre series. Returns the Legendre series coefficients c differentiated m times along axis. At each iteration the result is multiplied by scl (the scaling factor is for use in a linear change of variable). The argument c is an array of coefficients from low to high degree along each axis, e.g., [1,2,3] represents the series 1*L_0 + 2*L_1 + 3*L_2 while [[1,2],[1,2]] represents 1*L_0(x)*L_0(y) + 1*L_1(x)*L_0(y

record.searchsorted() 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

numpy.sqrt(x[, out]) = Return the positive square-root of an array, element-wise. Parameters: x : array_like The values whose square-roots are required. out : ndarray, optional Alternate array object in which to put the result; if provided, it must have the same shape as x Returns: y : ndarray An array of the same shape as x, containing the positive square-root of each element in x. If any element in x is complex, a complex array is returned (and the square-roots of negative reals

numpy.polynomial.chebyshev.chebfit(x, y, deg, rcond=None, full=False, w=None) [source] Least squares fit of Chebyshev series to data. Return the coefficients of a Legendre series of degree deg that is the least squares fit to the data values y given at points x. If y is 1-D the returned coefficients will also be 1-D. If y is 2-D multiple fits are done, one for each column of y, and the resulting coefficients are stored in the corresponding columns of a 2-D return. The fitted polynomial(s) a

ndarray.__oct__() <==> oct(x)