absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Calculate the absolute value element-wise.

absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Calculate the absolute value element-wise.

add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Add arguments element-wise.

Add documentation to an existing object, typically one defined in C The purpose is to allow easier editing of the docstrings without requiring a re-compile.

Return evenly spaced values within a given interval.

arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Trigonometric inverse cosine, element-wise.

arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Inverse hyperbolic cosine, element-wise.

arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Inverse sine, element-wise.

arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Inverse hyperbolic sine element-wise.

arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Trigonometric inverse tangent, element-wise.

arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Element-wise arc tangent of “x1/x2“ choosing the quadrant correctly.

arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Inverse hyperbolic tangent element-wise.

Create an array.

Convert the input to an array.

Convert the input to an array, checking for NaNs or Infs.

Interpret the input as a matrix.

Return the Bartlett window.

Return a string representation of a number in the given base system.

Return the binary representation of the input number as a string.

bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Compute the bit-wise AND of two arrays element-wise.

invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Compute bit-wise inversion, or bit-wise NOT, element-wise.

bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Compute the bit-wise OR of two arrays element-wise.

bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Compute the bit-wise XOR of two arrays element-wise.

Return the Blackman window.

Build a matrix object from a string, nested sequence, or array.

Broadcast the input shapes into a single shape.

Returns pointers to the end-points of an array.

cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the cube-root of an array, element-wise.

ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the ceiling of the input, element-wise.

conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the complex conjugate, element-wise.

conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the complex conjugate, element-wise.

copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Change the sign of x1 to that of x2, element-wise.

cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Cosine element-wise.

cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Hyperbolic cosine, element-wise.

deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Convert angles from degrees to radians.

degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Convert angles from radians to degrees.

Issues a DeprecationWarning, adds warning to `old_name`'s docstring, rebinds “old_name.__name__“ and returns the new function object.

Deprecates a function and includes the deprecation in its docstring.

Return the indices to access the main diagonal of an array.

Display a message on a device.

divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Divide arguments element-wise.

divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return element-wise quotient and remainder simultaneously.

Return a new array of given shape and type, without initializing entries.

equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return (x1 == x2) element-wise.

exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Calculate the exponential of all elements in the input array.

exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Calculate `2**p` for all `p` in the input array.

expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Calculate “exp(x) - 1“ for all elements in the array.

Return a 2-D array with ones on the diagonal and zeros elsewhere.

fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Compute the absolute values element-wise.

Determine common type following standard coercion rules.

float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) First array elements raised to powers from second array, element-wise.

floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the floor of the input, element-wise.

floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the largest integer smaller or equal to the division of the inputs.

fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Element-wise maximum of array elements.

fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Element-wise minimum of array elements.

fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Returns the element-wise remainder of division.

Format a floating-point scalar as a decimal string in positional notation.

Format a floating-point scalar as a decimal string in scientific notation.

frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Decompose the elements of x into mantissa and twos exponent.

Construct an array by executing a function over each coordinate.

Construct an array from a text file, using regular expression parsing.

Return a new array of given shape and type, filled with `fill_value`.

gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Returns the greatest common divisor of “|x1|“ and “|x2|“ Parameters ---------- x1, x2 : array_like, int Arrays of values.

Load data from a text file, with missing values handled as specified.

Find the wrapper for the array with the highest priority.

Return the size of the buffer used in ufuncs.

Get the current way of handling floating-point errors.

Return the current callback function used on floating-point errors.

Return the directory that contains the NumPy \*.h header files.

Return the current print options.

Return the Hamming window.

Return the Hanning window.

heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Compute the Heaviside step function.

hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Given the "legs" of a right triangle, return its hypotenuse.

Return the identity array.

Return an array representing the indices of a grid.

Get help information for an array, function, class, or module.

invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Compute bit-wise inversion, or bit-wise NOT, element-wise.

isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Test element-wise for finiteness (not infinity and not Not a Number).

Check if the array is Fortran contiguous but *not* C contiguous.

isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Test element-wise for positive or negative infinity.

isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Test element-wise for NaN and return result as a boolean array.

isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Test element-wise for NaT (not a time) and return result as a boolean array.

Returns True if the type of `element` is a scalar type.

Determines whether the given object represents a scalar data-type.

Determine if a class is a subclass of a second class.

Returns True if first argument is a typecode lower/equal in type hierarchy.

Determine if the first argument is a subclass of the second argument.

Check whether or not an object can be iterated over.

Return the Kaiser window.

lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Returns the lowest common multiple of “|x1|“ and “|x2|“ Parameters ---------- x1, x2 : array_like, int Arrays of values.

ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Returns x1 * 2**x2, element-wise.

left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Shift the bits of an integer to the left.

less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the truth value of (x1 < x2) element-wise.

less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the truth value of (x1 <= x2) element-wise.

Load arrays or pickled objects from “.npy“, “.npz“ or pickled files.

Load data from a text file.

log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Natural logarithm, element-wise.

log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the base 10 logarithm of the input array, element-wise.

log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the natural logarithm of one plus the input array, element-wise.

log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Base-2 logarithm of `x`.

logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Logarithm of the sum of exponentiations of the inputs.

logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Logarithm of the sum of exponentiations of the inputs in base-2.

logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Compute the truth value of x1 AND x2 element-wise.

logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Compute the truth value of NOT x element-wise.

logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Compute the truth value of x1 OR x2 element-wise.

logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Compute the truth value of x1 XOR x2, element-wise.

Do a keyword search on docstrings.

Return the indices to access (n, n) arrays, given a masking function.

Interpret the input as a matrix.

matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis]) Matrix product of two arrays.

maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Element-wise maximum of array elements.

Return the scalar type of highest precision of the same kind as the input.

minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Element-wise minimum of array elements.

Return the character for the minimum-size type to which given types can be safely cast.

remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Returns the element-wise remainder of division.

modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the fractional and integral parts of an array, element-wise.

multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Multiply arguments element-wise.

negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Numerical negative, element-wise.

nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the next floating-point value after x1 towards x2, element-wise.

not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return (x1 != x2) element-wise.

Return the scalar dtype or NumPy equivalent of Python type of an object.

Return a new array of given shape and type, filled with ones.

positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Numerical positive, element-wise.

power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) First array elements raised to powers from second array, element-wise.

Context manager for setting print options.

rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Convert angles from radians to degrees.

radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Convert angles from degrees to radians.

Load ASCII data stored in a comma-separated file.

Load ASCII data from a file and return it in a record array.

reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the reciprocal of the argument, element-wise.

remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Returns the element-wise remainder of division.

Return an ndarray of the provided type that satisfies requirements.

right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Shift the bits of an integer to the right.

rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Round elements of the array to the nearest integer.

Protected string evaluation.

Return the string representation of a scalar dtype.

Set the size of the buffer used in ufuncs.

Set how floating-point errors are handled.

Set the floating-point error callback function or log object.

Set printing options.

Set a Python function to be used when pretty printing arrays.

Show libraries and system information on which NumPy was built and is being used Parameters ---------- mode : {`'stdout'`, `'dicts'`}, optional.

Print information about various resources in the system including available intrinsic support and BLAS/LAPACK library in use .

sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Returns an element-wise indication of the sign of a number.

signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Returns element-wise True where signbit is set (less than zero).

sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Trigonometric sine, element-wise.

sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Hyperbolic sine, element-wise.

Print or write to a file the source code for a NumPy object.

spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the distance between x and the nearest adjacent number.

sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the non-negative square-root of an array, element-wise.

square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the element-wise square of the input.

subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Subtract arguments, element-wise.

tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Compute tangent element-wise.

tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Compute hyperbolic tangent element-wise.

An array with ones at and below the given diagonal and zeros elsewhere.

Return the indices for the lower-triangle of an (n, m) array.

Return the indices for the upper-triangle of an (n, m) array.

divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Divide arguments element-wise.

trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Return the truncated value of the input, element-wise.

Return a description for the given data type code.

Print the NumPy arrays in the given dictionary.

Return a new array of given shape and type, filled with zeros.