numpy.isneginf(x, y=None) [source] Test element-wise for negative infinity, return result as bool array. Parameters: x : array_like The input array. y : array_like, optional A boolean array with the same shape and type as x to store the result. Returns: y : ndarray A boolean array with the same dimensions as the input. If second argument is not supplied then a numpy boolean array is returned with values True where the corresponding element of the input is negative infinity and value

numpy.isnan(x[, out]) = Test element-wise for NaN and return result as a boolean array. Parameters: x : array_like Input array. Returns: y : ndarray or bool For scalar input, the result is a new boolean with value True if the input is NaN; otherwise the value is False. For array input, the result is a boolean array of the same dimensions as the input and the values are True if the corresponding element of the input is NaN; otherwise the values are False. See also isinf, isneginf,

numpy.isinf(x[, out]) = Test element-wise for positive or negative infinity. Returns a boolean array of the same shape as x, True where x == +/-inf, otherwise False. Parameters: x : array_like Input values out : array_like, optional An array with the same shape as x to store the result. Returns: y : bool (scalar) or boolean ndarray For scalar input, the result is a new boolean with value True if the input is positive or negative infinity; otherwise the value is False. For array inp

numpy.isfortran(a) [source] Returns True if the array is Fortran contiguous but not C contiguous. This function is obsolete and, because of changes due to relaxed stride checking, its return value for the same array may differ for versions of Numpy >= 1.10 and previous versions. If you only want to check if an array is Fortran contiguous use a.flags.f_contiguous instead. Parameters: a : ndarray Input array. Examples np.array allows to specify whether the array is written in C-contigu

numpy.iscomplexobj(x) [source] Check for a complex type or an array of complex numbers. The type of the input is checked, not the value. Even if the input has an imaginary part equal to zero, iscomplexobj evaluates to True. Parameters: x : any The input can be of any type and shape. Returns: iscomplexobj : bool The return value, True if x is of a complex type or has at least one complex element. See also isrealobj, iscomplex Examples >>> np.iscomplexobj(1) False >>&

numpy.isfinite(x[, out]) = Test element-wise for finiteness (not infinity or not Not a Number). The result is returned as a boolean array. Parameters: x : array_like Input values. 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, bool For scalar input, the result is a new boolean with value True if the input is finite; otherwise the value is False (input is

numpy.iscomplex(x) [source] Returns a bool array, where True if input element is complex. What is tested is whether the input has a non-zero imaginary part, not if the input type is complex. Parameters: x : array_like Input array. Returns: out : ndarray of bools Output array. See also isreal iscomplexobj Return True if x is a complex type or an array of complex numbers. Examples >>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j]) array([ True, False, False, False, False, Tr

numpy.isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False) [source] Returns a boolean array where two arrays are element-wise equal within a tolerance. The tolerance values are positive, typically very small numbers. The relative difference (rtol * abs(b)) and the absolute difference atol are added together to compare against the absolute difference between a and b. Parameters: a, b : array_like Input arrays to compare. rtol : float The relative tolerance parameter (see Notes). atol

numpy.irr(values) [source] Return the Internal Rate of Return (IRR). This is the ?average? periodically compounded rate of return that gives a net present value of 0.0; for a more complete explanation, see Notes below. Parameters: values : array_like, shape(N,) Input cash flows per time period. By convention, net ?deposits? are negative and net ?withdrawals? are positive. Thus, for example, at least the first element of values, which represents the initial investment, will typically be ne

numpy.ipmt(rate, per, nper, pv, fv=0.0, when='end') [source] Compute the interest portion of a payment. Parameters: rate : scalar or array_like of shape(M, ) Rate of interest as decimal (not per cent) per period per : scalar or array_like of shape(M, ) Interest paid against the loan changes during the life or the loan. The per is the payment period to calculate the interest amount. nper : scalar or array_like of shape(M, ) Number of compounding periods pv : scalar or array_like of sh