Equana

Function Reference

Docs/Numerical Arrays (NumPy)

Numerical Arrays (NumPy)

NumPy-inspired numerical array library for WebAssembly.

np.testing.assert_

Assert a condition is true.

np.testing.assert_(val, msg?)

np.testing.assert_allclose

Assert that two arrays are element-wise equal within tolerance.

np.testing.assert_allclose(actual, desired, rtol?, atol?, equal_nan?, err_msg?, _verbose?)

np.testing.assert_almost_equal

Assert that two values are equal up to specified decimal places.

np.testing.assert_almost_equal(actual, desired, decimal?, err_msg?, verbose?)

np.testing.assert_approx_equal

Assert values are equal to specified significant figures.

np.testing.assert_approx_equal(actual, desired, significant?, err_msg?, verbose?)

np.testing.assert_array_almost_equal

Assert arrays are element-wise equal up to decimal places.

np.testing.assert_array_almost_equal(x, y, decimal?, err_msg?, verbose?)

np.testing.assert_array_compare

Assert arrays satisfy a custom comparison.

np.testing.assert_array_compare(comparison, x, y, header?, precision?)

np.testing.assert_array_equal

Assert that two arrays are element-wise equal.

np.testing.assert_array_equal(x, y, err_msg?, verbose?)

np.testing.assert_array_less

Assert that all elements of x are strictly less than those of y.

np.testing.assert_array_less(x, y, err_msg?, verbose?)

np.testing.assert_array_max_ulp

Assert arrays differ by at most `maxulp` ULPs.

np.testing.assert_array_max_ulp(a, b, maxulp?, dtype?)

np.testing.assert_equal

Assert that two objects are equal.

np.testing.assert_equal(actual, desired, err_msg?, verbose?)

np.testing.assert_no_warnings

Assert that a function emits no warnings.

np.testing.assert_no_warnings(func, args)

np.testing.assert_raises

Assert that a callable raises the specified exception.

np.testing.assert_raises(exception_class, callable, args)

np.testing.assert_raises_regex

Assert exception is raised with matching message.

np.testing.assert_raises_regex(exception_class, expected_regexp, callable, args)

np.testing.assert_string_equal

Assert that two strings are equal.

np.testing.assert_string_equal(actual, desired)

np.testing.assert_warns

Assert that a function emits a warning.

np.testing.assert_warns(warning_class, callable, args)

np.testing.measure

Measure execution time of a code block.

np.testing.measure(code, times?)

np.testing.print_assert_equal

Print comparison result for debugging.

np.testing.print_assert_equal(test_string, actual, desired)

Calculate the absolute value element-wise.

Add arguments element-wise.

Test whether all array elements along a given axis evaluate to True.

np.all(a, axis?, keepdims?)

Returns True if two arrays are element-wise equal within a tolerance.

np.allclose(a, b, rtol?, atol?, equal_nan?)

Return the angle of the complex argument.

np.angle(z, deg?)

Test whether any array element along a given axis evaluates to True.

np.any(a, axis?, keepdims?)

Append values to the end of an array.

np.append(arr, values, axis?)

np.applyAlongAxis

Apply a function to 1-D slices along the given axis.

np.applyAlongAxis(func1d, axis, arr, args)

np.applyOverAxes

Apply a function repeatedly over multiple axes.

np.applyOverAxes(func, arr, axes)

Create an NDArray with evenly spaced values within a given interval.

np.arange(start, end?, step?)

Trigonometric inverse cosine, element-wise.

Inverse hyperbolic cosine, element-wise.

Inverse sine, element-wise.

Inverse hyperbolic sine element-wise.

Trigonometric inverse tangent, element-wise.

Element-wise arc tangent of x1/x2 choosing the quadrant correctly.

np.arctan2(x1, x2)

Inverse hyperbolic tangent element-wise.

Returns the indices of the maximum values along an axis.

np.argmax(a, axis?, keepdims?)

Returns the indices of the minimum values along an axis.

np.argmin(a, axis?, keepdims?)

np.argpartition

Returns the indices that would partition an array.

np.argpartition(a, kth, axis?)

Returns the indices that would sort an array.

np.argsort(a, axis?, kind?)

Find the indices of array elements that are non-zero, grouped by element.

np.argwhere(arr)

Create an NDArray from a nested array or flat array with shape.

np.array(data, shape?, options?)

np.array2string

Return a string representation of an array.

np.array2string(arr, options?)

True if two arrays have the same shape and elements, False otherwise.

np.array_equal(a1, a2, equal_nan?)

Returns True if input arrays are shape consistent and all elements equal.

np.array_equiv(a1, a2)

Split an array into multiple sub-arrays as views.

np.array_split(arr, indices_or_sections, axis?)

Return the string representation of an array (with dtype info).

np.arrayRepr(arr, options?)

Return a string representation of an array (no dtype).

np.arrayStr(arr, options?)

Convert input to a list of 1D coefficient arrays.

np.as_series(alist, trim?)

Convert the input to an array, passing through ndarrays unchanged.

np.asanyarray(a, options?)

Convert the input to an array.

np.asarray(a, dtype?)

np.asarray_chkfinite

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

np.asarray_chkfinite(a, options?)

np.ascontiguousarray

Return a contiguous array (ndim >= 1) in memory (C order).

np.ascontiguousarray(a, options?)

np.asfortranarray

Return a contiguous array (ndim >= 1) in memory (Fortran order).

np.asfortranarray(a, options?)

Cast an array to a specified type.

np.astype(a, dtype, copy?)

Convert inputs to arrays with at least one dimension.

np.atleast_1d(arrs)

View inputs as arrays with at least two dimensions.

np.atleast_2d(arrs)

View inputs as arrays with at least three dimensions.

np.atleast_3d(arrs)

Compute the weighted average along the specified axis.

np.average(a, axis?, weights?, keepdims?)

Return the Bartlett window.

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

np.baseRepr(num, base?, padding?)

np.baseReprArray

Convert an array of numbers to base-N representations.

np.baseReprArray(arr, base?, padding?)

Base Conversion Functions

np.binaryRepr(num, width?)

np.binaryReprArray

Convert an array of numbers to binary representations.

np.binaryReprArray(arr, width?)

Count number of occurrences of each value in array of non-negative ints.

np.bincount(x, weights?, minlength?)

Compute the bit-wise AND of two arrays element-wise.

np.bitwise_and(x1, x2)

np.bitwise_count

Computes the number of 1-bits in the absolute value of x.

np.bitwise_count(x)

Compute the bit-wise OR of two arrays element-wise.

np.bitwise_or(x1, x2)

Compute the bit-wise XOR of two arrays element-wise.

np.bitwise_xor(x1, x2)

Return the Blackman window.

Assemble an nd-array from nested lists of blocks.

np.block(arrays)

np.broadcastArrays

Broadcast any number of arrays against each other.

np.broadcastArrays(arrays)

np.broadcastShapes

Compute the broadcast shape for two shapes.

np.broadcastShapes(shape1, shape2)

np.broadcastShapesMulti

Compute the broadcast shape for multiple shapes.

np.broadcastShapesMulti(shapes)

Broadcast an array to a target shape.

np.broadcastTo(arr, targetShape)

np.buildIndexSpecs

Build IndexSpec array from parsed indices for C interop.

np.buildIndexSpecs(indices, shape)

Return random bytes.

np.bytes(length)

Returns true if cast between data types can occur according to the casting rule.

np.can_cast(from, to, casting?)

Return the cube-root of an array, element-wise.

Return the ceiling of the input, element-wise.

Convert Chebyshev coefficients to power series.

np.cheb2poly(c)

Add two Chebyshev polynomials.

np.chebadd(c1, c2)

np.chebcompanion

Generate Chebyshev companion matrix.

np.chebcompanion(c)

Chebyshev derivative.

np.chebder(c, m?)

Divide two Chebyshev polynomials.

np.chebdiv(c1, c2)

Chebyshev least squares fit.

np.chebfit(x, y, deg, rcond?, full?, w?)

np.chebfromroots

Construct Chebyshev polynomial from roots.

np.chebfromroots(roots)

Chebyshev integral.

np.chebint(c, m?, k?, lbnd?)

np.chebinterpolate

Interpolate a function using Chebyshev polynomials.

np.chebinterpolate(func, deg, domain?)

Multiply two Chebyshev polynomials.

np.chebmul(c1, c2)

Raise Chebyshev polynomial to a power.

np.chebpow(c, pow, maxpower?)

Find Chebyshev polynomial roots.

np.chebroots(c)

Subtract two Chebyshev polynomials.

np.chebsub(c1, c2)

Evaluate Chebyshev polynomial using Clenshaw's algorithm.

np.chebval(x, c)

Evaluate 2D Chebyshev polynomial.

np.chebval2d(x, y, c)

Chebyshev Vandermonde matrix.

np.chebvander(x, deg)

Generates a random sample from a given array or range.

np.choice(a, size?, replace?, p?)

Cholesky decomposition.

np.cholesky(a, upper?)

Construct an array from an index array and a set of arrays to choose from.

np.choose(indices, choices, mode?)

Clip (limit) the values in an array.

np.clip(a, a_min, a_max)

np.column_stack

Stack 1-D arrays as columns into a 2-D array.

np.column_stack(tup)

Determine common type following standard coercion rules.

np.common_type(dtypes)

Get common type for multiple dtypes.

np.commonType(dtypes)

np.compare_chararrays

Compare two string arrays element-wise.

np.compare_chararrays(x1, x2)

Return selected slices of an array along given axis.

np.compress(condition, arr, axis?)

np.computeBroadcastStrides

Compute the strides needed to broadcast an array to a target shape.

np.computeBroadcastStrides(arr, targetShape)

np.computeResultShape

Compute the result shape from index specifications.

np.computeResultShape(specs, shape)

Join a sequence of arrays along an existing axis.

np.concatenate(arrays, axis?, dtype?)

Compute the condition number of a matrix.

np.configureWasm

Configure WASM loading before initialization.

np.configureWasm(config)

Return the complex conjugate, element-wise.

np.conjugate(x)

Returns the discrete, linear convolution of two one-dimensional sequences.

np.convolve(a, v, mode?)

Return a copy of an array.

Change the sign of x1 to that of x2, element-wise.

np.copysign(x1, x2)

Copy values from one array to another, broadcasting as necessary.

np.copyto(dst, src, _casting?, where?)

Return Pearson product-moment correlation coefficients.

np.corrcoef(x, y?, rowvar?)

Cross-correlation of two 1-dimensional sequences.

np.correlate(a, v, mode?)

Cosine element-wise.

Hyperbolic cosine, element-wise.

np.countNonzero

Count the number of nonzero elements in an array.

np.countNonzero(arr)

Estimate a covariance matrix.

np.cov(m, y?, rowvar?, bias?, ddof?)

Return the cross product of two (arrays of) vectors.

np.cross(a, b, axisa?, axisb?, axisc?, axis?)

Return the cumulative product of elements along a given axis.

np.cumprod(a, axis?, dtype?)

Return the cumulative sum of the elements along a given axis.

np.cumsum(a, axis?, dtype?)

np.cumulative_prod

Return the cumulative product of array elements.

np.cumulative_prod(x, axis?, dtype?, _include_initial?)

np.cumulative_sum

Return the cumulative sum of array elements.

np.cumulative_sum(x, axis?, dtype?, _include_initial?)

Decode bytes to strings using specified encoding.

np.decode(a, encoding?)

Construct a new Generator with the given BitGenerator.

np.default_rng(seed?, options?)

Convert angles from radians to degrees.

Return a new array with sub-arrays along an axis deleted.

np.deleteArr(arr, obj, axis?)

np.descrToDtype

Parse NPY descriptor string to DType.

np.descrToDtype(descr)

Compute the determinant of an array.

Extract a diagonal or construct a diagonal array.

np.diag_indices

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

np.diag_indices(n, ndim?)

np.diag_indices_from

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

np.diag_indices_from(arr)

Create a 2D array with the flattened input as a diagonal.

np.diagflat(v, k?, options?)

Return specified diagonals from a 2D array.

np.diagonal(arr, offset?, axis1?, axis2?)

Calculate the n-th discrete difference along the given axis.

np.diff(a, n?, axis?)

Return the indices of the bins to which each value in input array belongs.

np.digitize(x, bins, right?)

Divide arguments element-wise (true division).

np.divide(x1, x2)

Return element-wise quotient and remainder simultaneously.

np.divmod(x1, x2)

Dot product of two arrays.

Split array into multiple sub-arrays along the 3rd axis (depth).

np.dsplit(arr, indices_or_sections)

Stack arrays in sequence along the third axis (depth-wise).

np.dtypeAlignment

Get natural alignment for a dtype (for C struct compatibility).

np.dtypeAlignment(dtype)

np.dtypeFromString

Convert string dtype name to DType enum.

np.dtypeFromString(name)

Get the size of a dtype in bytes.

np.dtypeSize(dtype)

np.dtypeToDescr

Convert DType to NPY descriptor string.

np.dtypeToDescr(dtype)

np.dtypeToString

Get dtype string name.

np.dtypeToString(dtype)

np.dtypeToTypedArrayConstructor

Get the TypedArray constructor for a given dtype.

np.dtypeToTypedArrayConstructor(dtype)

Compute the differences between consecutive elements of an array.

np.ediff1d(arr, options?)

Compute eigenvalues and right eigenvectors of a general matrix.

Compute eigenvalues and eigenvectors of a Hermitian/symmetric matrix.

np.eigh(a, _UPLO?)

Compute eigenvalues only.

Compute eigenvalues of a Hermitian/symmetric matrix.

np.eigvalsh(a, UPLO?)

Evaluates the Einstein summation convention on the operands.

np.einsum(subscripts, operands)

Evaluates the lowest cost contraction order for an einsum expression.

np.einsum_path(subscripts, operands)

Create a new NDArray without initializing values.

np.empty(shape, options?)

Create an uninitialized array with the same shape and type as a given array.

np.empty_like(a)

Encode strings to bytes using specified encoding.

np.encode(a, _encoding?)

Return true for each element if the string ends with suffix.

np.endswith(a, suffix, start?, end?)

Return (x1 == x2) element-wise.

np.equal(x1, x2)

Calculate the exponential of all elements in the input array.

Calculate 2**x for all elements in the array.

Expand the shape of an array by inserting a new axis.

np.expand_dims(a, axis)

np.expandEllipsis

Expand ellipsis and validate index dimensions.

np.expandEllipsis(indices, ndim)

Return element-wise copy with tabs expanded to spaces.

np.expandtabs(a, tabsize?)

Calculate exp(x) - 1 for all elements in the array.

Return elements of an array that satisfy some condition.

np.extract(condition, arr)

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

np.eye(N, M?, k?, options?)

Compute the one-dimensional discrete Fourier Transform.

np.fft(a, n?, axis?, norm?)

Compute the 2-dimensional discrete Fourier Transform.

np.fft2(a, s?, axes?, norm?)

Return the Discrete Fourier Transform sample frequencies.

np.fftfreq(n, d?)

Compute the N-dimensional discrete Fourier Transform.

np.fftn(a, s?, axes?, norm?)

Shift the zero-frequency component to the center of the spectrum.

np.fftshift(x, axes?)

np.fill_diagonal

Fill the main diagonal of the given array of any dimensionality.

np.fill_diagonal(a, val, wrap?)

np.find_duplicate

Find duplicate elements in a list.

np.find_duplicate(list)

Return flat indices of nonzero elements.

np.flatnonzero(arr)

Return a copy of the array collapsed into one dimension.

Reverse the order of elements in an array along the given axis.

np.flip(arr, axis?)

Reverse the order of elements along axis 1 (left/right).

Reverse the order of elements along axis 0 (up/down).

First array elements raised to powers from second array, element-wise.

np.float_power(x1, x2)

Return the floor of the input, element-wise.

np.floor_divide

Return the largest integer smaller or equal to the division of the inputs.

np.floor_divide(x1, x2)

Element-wise maximum (ignores NaN).

np.fmax(x1, x2)

Element-wise minimum (ignores NaN).

np.fmin(x1, x2)

Returns element-wise remainder of floor_divide (C-style modulo).

np.fmod(x1, x2)

np.formatFloatPositional

Format a float in positional notation.

np.formatFloatPositional(value, precision?, _unique?, fractional?, trim?, sign?, padLeft?, padRight?)

np.formatFloatScientific

Format a float in scientific notation.

np.formatFloatScientific(value, precision?, _unique?, trim?, sign?, padLeft?, expDigits?)

Format a number according to printf-style format string.

np.formatValue(value, fmt)

Decompose the elements of x into mantissa and twos exponent.

np.fromBaseRepr

Convert a base-N string to a number.

np.fromBaseRepr(str, base?)

np.fromBinaryRepr

Convert a binary string to a number.

np.fromBinaryRepr(binary, twosComplement?, width?)

Interpret a buffer as a 1-dimensional array.

np.frombuffer(buffer, options?)

Construct an array from data in a binary file.

np.fromfile(file, options?)

np.fromfunction

Construct an array by executing a function over each coordinate.

np.fromfunction(func, shape, options?)

Create a 1D array from an iterable object.

np.fromiter(iter, options?)

Create a ufunc-like wrapper from a JavaScript function.

np.frompyfunc(func, nin, nout, identity?)

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

np.fromregex(file, regexp, dtype?, options?)

Create a 1D array from text data in a string.

np.fromstring(string, sep?, count?, options?)

Create a new NDArray filled with a constant value.

np.full(shape, fillValue, options?)

Create an array filled with a value, with the same shape and type as a given array.

np.full_like(a, fillValue)

Returns the greatest common divisor of |x1| and |x2|.

Load data from a text file with handling for missing values.

np.genfromtxt(file, options?)

Create an NDArray with numbers spaced evenly on a geometric scale.

np.geomspace(start, stop, num?, endpoint?, options?)

np.getBitGenerator

Get a BitGenerator class by name.

np.getBitGenerator(name)

Get the domain appropriate for given data points.

np.getdomain(x)

np.getPrintoptions

Get current print options.

np.getPrintoptions()

np.getWasmModule

Get the loaded WASM module synchronously.

np.getWasmModule()

Return the gradient of an N-dimensional array.

np.gradient(f, args)

Return (x1 > x2) element-wise.

np.greater(x1, x2)

np.greater_equal

Return (x1 >= x2) element-wise.

np.greater_equal(x1, x2)

Return the Hamming window.

Return the Hanning window (also known as Hann window).

Compute the Heaviside step function.

np.heaviside(x1, x2)

Convert Hermite coefficients to power series.

np.herm2poly(c)

np.hermadd(c1, c2)

np.hermcompanion

np.hermcompanion(c)

np.hermder(c, m?)

np.hermdiv(c1, c2)

Convert HermiteE coefficients to power series.

np.herme2poly(c)

np.hermeadd(c1, c2)

np.hermecompanion

np.hermecompanion(c)

np.hermeder(c, m?)

np.hermediv(c1, c2)

np.hermefit(x, y, deg, rcond?, full?, w?)

np.hermefromroots

np.hermefromroots(roots)

np.hermeint(c, m?, k?, lbnd?)

np.hermemul(c1, c2)

np.hermepow(c, pow, maxpower?)

np.hermeroots(c)

np.hermesub(c1, c2)

Evaluate HermiteE polynomial.

np.hermeval(x, c)

np.hermevander(x, deg)

np.hermfit(x, y, deg, rcond?, full?, w?)

np.hermfromroots

np.hermfromroots(roots)

np.hermint(c, m?, k?, lbnd?)

np.hermmul(c1, c2)

np.hermpow(c, pow, maxpower?)

np.hermroots(c)

np.hermsub(c1, c2)

Evaluate Hermite polynomial.

np.hermval(x, c)

np.hermvander(x, deg)

Return the hexadecimal representation of a number.

np.hexRepr(num, width?)

Compute the FFT of a signal that has Hermitian symmetry (real spectrum).

np.hfft(a, n?, axis?, norm?)

Compute the histogram of a dataset.

np.histogram(a, bins?, range?, density?, weights?)

Compute the bi-dimensional histogram of two data samples.

np.histogram2d(x, y, bins?, range?, density?, weights?)

np.histogram_bin_edges

Compute histogram bin edges.

np.histogram_bin_edges(a, bins?, range?, weights?)

Compute the multidimensional histogram of some data.

np.histogramdd(sample, bins?, range?, density?, weights?)

Split an array into multiple sub-arrays horizontally (column-wise).

np.hsplit(arr, indices_or_sections)

Stack arrays in sequence horizontally (column-wise).

Given the "legs" of a right triangle, return its hypotenuse.

np.hypot(x1, x2)

Modified Bessel function of the first kind, order 0.

Create a square identity matrix.

np.identity(n, options?)

Compute the one-dimensional inverse discrete Fourier Transform.

np.ifft(a, n?, axis?, norm?)

Compute the 2-dimensional inverse discrete Fourier Transform.

np.ifft2(a, s?, axes?, norm?)

Compute the N-dimensional inverse discrete Fourier Transform.

np.ifftn(a, s?, axes?, norm?)

The inverse of fftshift.

np.ifftshift(x, axes?)

Compute the inverse FFT of a signal that has Hermitian symmetry.

np.ihfft(a, n?, axis?, norm?)

Return the imaginary part of the complex argument.

Test whether each element of ar1 is also present in ar2 (flat version).

np.in1d(ar1, ar2, options?)

Return an array representing the indices of a grid.

np.indices(dimensions, dtype?, sparse?)

Initialize the random module.

np.initRandom()

Inner product of two arrays.

Insert values along the given axis before the given indices.

np.insert(arr, obj, values, axis?)

One-dimensional linear interpolation for monotonically increasing sample points.

np.interp(x, xp, fp, left?, right?)

Find the intersection of two arrays.

np.intersect1d(ar1, ar2, options?)

Compute the (multiplicative) inverse of a matrix.

Compute bit-wise inversion, element-wise.

Compute the inverse of the one-dimensional discrete Fourier Transform for real input.

np.irfft(a, n?, axis?, norm?)

Compute the inverse of the 2-dimensional FFT of real input.

np.irfft2(a, s?, axes?, norm?)

Compute the inverse of the N-dimensional FFT of real input.

np.irfftn(a, s?, axes?, norm?)

Return true for each element if all characters are alphanumeric.

Return true for each element if all characters are alphabetic.

Check if dtype is boolean.

np.isBoolDType(dtype)

Returns a boolean array where two arrays are element-wise equal within tolerance.

np.isclose(a, b, rtol?, atol?, equal_nan?)

Returns a bool array where True if input element is complex (imaginary part != 0).

np.iscomplex(x)

np.isComplexDType

Check if dtype is a complex type.

np.isComplexDType(dtype)

np.iscomplexobj

Check if the array has a complex dtype.

np.iscomplexobj(x)

Return true for each element if all characters are decimal.

np.isdecimal(a)

Return true for each element if all characters are digits (0-9).

Returns a boolean indicating whether the provided dtype is of the specified kind.

np.isdtype(dtype, kind)

Test element-wise for finiteness (not infinity and not NaN).

np.isFloatDType

Check if dtype is a floating point type.

np.isFloatDType(dtype)

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

np.isfortran(a)

Test whether each element of ar1 is also present in ar2.

np.isin(ar1, ar2, options?)

Test element-wise for positive or negative infinity.

np.isIntegerDType

Check if dtype is an integer type (signed or unsigned).

np.isIntegerDType(dtype)

Return true for each element if all cased characters are lowercase

Test element-wise for NaN.

Test element-wise for negative infinity.

Check if running in Node.js environment.

Return true for each element if all characters are numeric.

np.isnumeric(a)

np.isNumericDType

Check if dtype is numeric (not bool).

np.isNumericDType(dtype)

Test element-wise for positive infinity.

Returns a bool array where True if input element is real (imaginary part == 0).

Check if the array has a non-complex dtype.

np.isrealobj(x)

Check if an element is a scalar type.

np.isscalar(element)

np.isSignedDType

Check if dtype is a signed type.

np.isSignedDType(dtype)

Return true for each element if all characters are whitespace.

np.isStructuredDType

Type guard for structured dtypes.

np.isStructuredDType(dtype)

Return true if first argument is a typecode lower/equal in type hierarchy.

np.issubdtype(arg1, arg2)

Return true for each element if the string is titlecased.

Return true for each element if all cased characters are uppercase

np.isWasmLoaded

Check if the WASM module has been loaded.

np.isWasmLoaded()

Check whether the object is iterable.

Construct an open mesh from multiple sequences.

Return the Kaiser window.

np.kaiser(M, beta)

Kronecker product of two arrays.

Convert Laguerre coefficients to power series.

np.lagadd(c1, c2)

np.lagcompanion

np.lagcompanion(c)

np.lagder(c, m?)

np.lagdiv(c1, c2)

np.lagfit(x, y, deg, rcond?, full?, w?)

np.lagfromroots

np.lagfromroots(roots)

np.lagint(c, m?, k?, lbnd?)

np.lagmul(c1, c2)

np.lagpow(c, pow, maxpower?)

np.lagsub(c1, c2)

Evaluate Laguerre polynomial.

np.lagval(x, c)

np.lagvander(x, deg)

Returns the lowest common multiple of |x1| and |x2|.

Returns x1 * 2^x2, element-wise.

np.ldexp(x1, x2)

Shift the bits of an integer to the left.

np.left_shift(x1, x2)

Convert Legendre coefficients to power series.

Add two Legendre polynomials.

np.legadd(c1, c2)

np.legcompanion

Generate Legendre companion matrix.

np.legcompanion(c)

Legendre derivative.

np.legder(c, m?)

Divide two Legendre polynomials.

np.legdiv(c1, c2)

Legendre least squares fit.

np.legfit(x, y, deg, rcond?, full?, w?)

np.legfromroots

Construct Legendre polynomial from roots.

np.legfromroots(roots)

Legendre integral.

np.legint(c, m?, k?, lbnd?)

Multiply two Legendre polynomials.

np.legmul(c1, c2)

Raise Legendre polynomial to a power.

np.legpow(c, pow, maxpower?)

Find Legendre polynomial roots.

Subtract two Legendre polynomials.

np.legsub(c1, c2)

Evaluate Legendre polynomial using Clenshaw-like algorithm.

np.legval(x, c)

Legendre Vandermonde matrix.

np.legvander(x, deg)

Return (x1 < x2) element-wise.

np.less(x1, x2)

Return (x1 <= x2) element-wise.

np.less_equal(x1, x2)

Perform an indirect stable sort using a sequence of keys.

np.lexsort(keys)

Create an NDArray with evenly spaced numbers over a specified interval.

np.linspace(start, stop, num?, endpoint?, options?)

np.listBitGenerators

List available BitGenerator names.

np.listBitGenerators()

Return element-wise left-justified string of given width.

np.ljust(a, width, fillchar?)

Load an array from a NPY file.

np.load(file, _options?)

Load data from a text file.

np.loadtxt(file, options?)

np.loadWasmModule

Load the WASM module asynchronously.

np.loadWasmModule()

Load arrays from a `.npz` file.

Natural logarithm, element-wise.

Base-10 logarithm, element-wise.

Return the natural logarithm of one plus the input array, element-wise.

Base-2 logarithm of x.

Compute the logarithm of the sum of exponentials of the inputs.

np.logaddexp(x1, x2)

Compute log(2**x1 + 2**x2).

np.logaddexp2(x1, x2)

Compute the truth value of x1 AND x2 element-wise.

np.logical_and(x1, x2)

Compute the truth value of NOT x element-wise.

np.logical_not(x)

Compute the truth value of x1 OR x2 element-wise.

np.logical_or(x1, x2)

Compute the truth value of x1 XOR x2, element-wise.

np.logical_xor(x1, x2)

Create an NDArray with numbers spaced evenly on a log scale.

np.logspace(start, stop, num?, endpoint?, base?, options?)

Return element-wise copy with uppercase characters converted to lowercase.

Return element-wise copy with leading characters removed.

np.lstrip(a, chars?)

Return the least-squares solution to a linear matrix equation.

np.lstsq(a, b, rcond?)

Map x from old domain to new domain.

np.mapdomain(x, old, new_)

Get linear mapping parameters between domains.

np.mapparms(old, new_)

np.mask_indices

Return indices that are non-zero in the mask.

np.mask_indices(n, func, k?)

Matrix multiplication of two arrays.

np.matmul(a, b)

Compute the matrix norm.

np.matrix_norm(x, ord?, keepdims?)

np.matrix_power

Raise a square matrix to the (integer) power n.

np.matrix_power(a, n)

Return matrix rank using SVD method.

np.matrix_rank(A, tol?)

np.matrix_transpose

Transposes the last two dimensions of an array.

np.matrix_transpose(x)

Matrix-vector product.

np.matvec(x1, x2)

Return the maximum of an array or maximum along an axis.

np.max(a, axis?, keepdims?)

Element-wise maximum of array elements (propagates NaN).

np.maximum(x1, x2)

Compute the arithmetic mean along the specified axis.

np.mean(a, axis?, keepdims?, dtype?)

Compute the median along the specified axis.

np.median(a, axis?, keepdims?)

Return coordinate matrices from coordinate vectors.

np.meshgrid(xi)

Return the minimum of an array or minimum along an axis.

np.min(a, axis?, keepdims?)

np.min_scalar_type

Return the minimum scalar type needed to represent the value.

np.min_scalar_type(value)

Element-wise minimum of array elements (propagates NaN).

np.minimum(x1, x2)

Return the fractional and integral parts of an array, element-wise.

Move axes of an array to new positions.

np.moveaxis(a, source, destination)

Compute the dot product of two or more arrays in a single function call,

np.multi_dot(arrays)

Multiply arguments element-wise.

np.multiply(x1, x2)

Replace NaN with zero and infinity with large finite numbers.

np.nan_to_num(x, nan?, posinf?, neginf?)

Return the indices of the maximum values along an axis, ignoring NaNs.

np.nanargmax(a, axis?, keepdims?)

Return the indices of the minimum values along an axis, ignoring NaNs.

np.nanargmin(a, axis?, keepdims?)

Return the cumulative product of array elements treating NaNs as one.

np.nancumprod(a, axis?, dtype?)

Return the cumulative sum of array elements treating NaNs as zero.

np.nancumsum(a, axis?, dtype?)

Return maximum of an array or maximum along an axis, ignoring any NaNs.

np.nanmax(a, axis?, keepdims?)

Compute the arithmetic mean along the specified axis, ignoring NaNs.

np.nanmean(a, axis?, keepdims?, dtype?)

Compute the median along the specified axis, while ignoring NaNs.

np.nanmedian(a, axis?, keepdims?)

Return minimum of an array or minimum along an axis, ignoring any NaNs.

np.nanmin(a, axis?, keepdims?)

np.nanpercentile

Compute the q-th percentile of the data along the specified axis,

np.nanpercentile(a, q, axis?, interpolation?, keepdims?)

Return the product of array elements over a given axis treating NaNs as one.

np.nanprod(a, axis?, keepdims?, _dtype?)

Compute the q-th quantile of the data along the specified axis,

np.nanquantile(a, q, axis?, interpolation?, keepdims?)

Compute the standard deviation along the specified axis, ignoring NaNs.

np.nanstd(a, axis?, ddof?, keepdims?, dtype?)

Return the sum of array elements over a given axis treating NaNs as zero.

np.nansum(a, axis?, keepdims?, dtype?)

Compute the variance along the specified axis, while ignoring NaNs.

np.nanvar(a, axis?, ddof?, keepdims?, dtype?)

Iterate over array with indices and values.

np.ndenumerate(arr)

Generate all index combinations for a shape.

np.ndindex(shape)

Iterate over array elements.

Numerical negative, element-wise.

Return the next floating-point value after x1 towards x2, element-wise.

np.nextafter(x1, x2)

Find indices of nonzero elements.

np.nonzero(arr)

Matrix or vector norm.

np.norm(x, ord?)

Return (x1 != x2) element-wise.

np.not_equal(x1, x2)

Return the octal representation of a number.

np.octalRepr(num, width?)

Create a new NDArray filled with ones.

np.ones(shape, options?)

Create an array of ones with the same shape and type as a given array.

np.ones_like(a)

Open a memory-mapped file.

np.openMemmap(file, options?)

Compute the outer product of two vectors.

Pack the elements of a binary array into bits in a uint8 array.

np.packbits(a, axis?, bitorder?)

np.pad(arr, pad_width, mode?, constant_values?)

Return a partitioned copy of an array.

np.partition(a, kth, axis?)

Compute the q-th percentile of the data along the specified axis.

np.percentile(a, q, axis?, keepdims?)

Randomly permute a sequence, or return a permuted range.

np.permutation(x, axis?)

np.permute_dims

Permute the dimensions of an array.

np.permute_dims(a, axes?)

Evaluate a piecewise-defined function.

np.piecewise(x, condlist, funclist, args)

Compute the (Moore-Penrose) pseudo-inverse of a matrix.

np.pinv(a, rcond?)

Change elements of an array based on conditional and input values.

np.place(arr, mask, vals)

Find the coefficients of a polynomial with the given sequence of roots.

np.poly(seq_of_zeros)

Convert power series coefficients to Chebyshev coefficients.

np.poly2cheb(pol)

Convert power series to Hermite coefficients.

np.poly2herm(pol)

Convert power series to HermiteE coefficients.

np.poly2herme(pol)

Convert power series to Laguerre coefficients.

np.poly2lag(pol)

Convert power series to Legendre coefficients.

np.poly2leg(pol)

Add two coefficient arrays (power series).

np.polyadd(c1, c2)

np.polycompanion

Generate companion matrix.

np.polycompanion(c)

Polynomial derivative.

np.polyder(c, m?)

Divide two coefficient arrays (power series).

np.polydiv(c1, c2)

Least squares polynomial fit.

np.polyfit(x, y, deg, rcond?, full?, w?)

np.polyfromroots

Construct polynomial from roots.

np.polyfromroots(roots)

Polynomial integral.

np.polyint(c, m?, k?, lbnd?)

Multiply two coefficient arrays (power series).

np.polymul(c1, c2)

Raise polynomial to a non-negative integer power.

np.polypow(c, pow, maxpower?)

Find polynomial roots.

np.polyroots(c)

Subtract two coefficient arrays (power series).

np.polysub(c1, c2)

Evaluate polynomial at x using Horner's method.

np.polyval(x, c)

Evaluate 2D polynomial on x-y pairs.

np.polyval2d(x, y, c)

Evaluate 3D polynomial on x-y-z triples.

np.polyval3d(x, y, z, c)

Generate Vandermonde matrix.

np.polyvander(x, deg)

np.polyvander2d

Generate 2D Vandermonde matrix.

np.polyvander2d(x, y, deg)

Numerical positive (returns a copy).

First array elements raised to powers from second array, element-wise.

np.power(x1, x2)

Return the product of array elements over a given axis.

np.prod(a, axis?, keepdims?, dtype?)

np.promoteTypes

Get result type when combining two dtypes.

np.promoteTypes(dtype1, dtype2)

Range of values (maximum - minimum) along an axis.

np.ptp(a, axis?, keepdims?)

Put values into an array at specified flat indices.

np.put(arr, indices, values, mode?)

np.put_along_axis

Put values into the destination array by matching 1d index and data slices.

np.put_along_axis(arr, indicesArr, values, axis)

Change elements of an array based on conditional and input values.

np.putmask(arr, mask, values)

QR decomposition.

Compute the q-th quantile of the data along the specified axis.

np.quantile(a, q, axis?, keepdims?)

Convert angles from degrees to radians.

Random values in a given shape.

Return random integers from low (inclusive) to high (exclusive).

np.randint(low, high?, size?)

Draw samples from a standard normal distribution.

Return random floats in the half-open interval [0.0, 1.0).

np.random(size?)

np.random_integers

Return random integers from low (inclusive) to high (exclusive).

np.random_integers(low, high?, size?)

np.random_sample

Return random floats in the half-open interval [0.0, 1.0).

np.random_sample(size?)

Return random floats in the half-open interval [0.0, 1.0).

Return a contiguous flattened array.

np.ravelMultiIndex

Convert a tuple of coordinate arrays into flat indices.

np.ravelMultiIndex(coords, shape)

Return the real part of the complex argument.

np.real_if_close

If input is complex with all imaginary parts close to zero, return real parts.

np.real_if_close(a, tol?)

Create a record array.

np.recArray(data?, options?)

np.recFromarrays

Create a record array from a list of arrays (columns).

np.recFromarrays(arrayList, options?)

Create a record array from a file.

np.recFromfile(file, dtype, shape?, offset?)

np.recFromrecords

Create a record array from a list of records (rows).

np.recFromrecords(recList, options?)

np.recFromstring

Create a record array from a binary string/buffer.

np.recFromstring(datastring, dtype, shape?, offset?)

Return the reciprocal of the argument, element-wise.

np.reciprocal(x)

Return element-wise remainder of division (Python-style modulo).

np.remainder(x1, x2)

Repeat elements of an array.

np.repeat(arr, repeats, axis?)

np.resetPrintoptions

Reset print options to defaults.

np.resetPrintoptions()

Gives a new shape to an array without changing its data.

np.reshape(a, newshape)

Return a new array with the specified shape.

np.resize(arr, new_shape)

Return the type that results from applying the type promotion rules to the arguments.

np.result_type(dtypes)

Compute the one-dimensional discrete Fourier Transform for real input.

np.rfft(a, n?, axis?, norm?)

Compute the 2-dimensional FFT of a real array.

np.rfft2(a, s?, axes?, norm?)

Return the Discrete Fourier Transform sample frequencies for rfft.

np.rfftfreq(n, d?)

Compute the N-dimensional discrete Fourier Transform for real input.

np.rfftn(a, s?, axes?, norm?)

For each element, return the highest index where substring is found.

np.rfind(a, sub, start?, end?)

Shift the bits of an integer to the right.

np.right_shift(x1, x2)

Like rfind, but raises ValueError if substring is not found.

np.rindex(a, sub, start?, end?)

Round elements of the array to the nearest integer.

Return element-wise right-justified string of given width.

np.rjust(a, width, fillchar?)

Roll array elements along a given axis.

np.roll(arr, shift, axis?)

Roll the specified axis backwards, until it lies in a given position.

np.rollaxis(a, axis, start?)

Find the roots of a polynomial with coefficients given in c.

Rotate an array by 90 degrees in the plane specified by axes.

np.rot90(arr, k?, axes?)

Round to nearest even value (banker's rounding).

Partition each element around the last occurrence of sep.

np.rpartition(a, sep)

Return element-wise copy with trailing characters removed.

np.rstrip(a, chars?)

Return random floats in the half-open interval [0.0, 1.0).

np.sample(size?)

Save an array to a binary file in NPY format.

np.save(file, arr, _options?)

Save an array to a text file.

np.savetxt(file, arr, options?)

Save multiple arrays to a single file in uncompressed `.npz` format.

np.savez(file, args)

np.savez_compressed

Save multiple arrays to a single file in compressed `.npz` format.

np.savez_compressed(file, args)

np.searchsorted

Find indices where elements should be inserted to maintain order.

np.searchsorted(a, v, side?)

Seed the default random generator.

Return an array drawn from elements in choicelist, depending on conditions.

np.select(condlist, choicelist, defaultValue?)

Find the set difference of two arrays.

np.setdiff1d(ar1, ar2, options?)

np.setPrintoptions

Set printing options globally.

np.setPrintoptions(options)

Find the set exclusive-or of two arrays.

np.setxor1d(ar1, ar2, options?)

np.shapesAreBroadcastable

Check if two shapes are broadcast-compatible.

np.shapesAreBroadcastable(shape1, shape2)

Randomly shuffle elements of an array in-place along an axis.

np.shuffle(x, axis?)

Returns element-wise sign: -1, 0, or +1.

Return element-wise True where signbit is set (less than zero).

Trigonometric sine, element-wise.

Return the normalized sinc function: sin(pi*x) / (pi*x).

Hyperbolic sine, element-wise.

Factory function for creating slices with cleaner syntax.

np.slice(start?, stop?, step?)

Compute sign and (natural) logarithm of the determinant.

Solve a linear matrix equation: a @ x = b

Return a sorted copy of an array.

np.sort(a, axis?, kind?)

np.sort_complex

Sort a complex array using the real part first, then the imaginary part.

np.sort_complex(a)

Return the distance between x and the nearest adjacent number.

Split an array into multiple sub-arrays of equal size.

np.split(arr, indices_or_sections, axis?)

Return the non-negative square-root of an array, element-wise.

Return the element-wise square of the input.

Remove axes of length one from array.

np.squeeze(a, axis?)

Join a sequence of arrays along a new axis.

np.stack(arrays, axis?)

Return true for each element if the string starts with prefix.

np.startswith(a, prefix, start?, end?)

Compute the standard deviation along the specified axis.

np.std(a, axis?, ddof?, keepdims?, dtype?)

Return the length of each element.

Return element-wise string concatenation.

np.strAdd(x1, x2)

np.strCapitalize

Return element-wise copy with first character capitalized and rest lowercase.

np.strCapitalize(a)

Return element-wise centered string of given width.

np.strCenter(a, width, fillchar?)

Return the number of non-overlapping occurrences of substring.

np.strCount(a, sub, start?, end?)

Return (x1 == x2) element-wise for string arrays.

np.strEqual(x1, x2)

For each element, return the lowest index where substring is found.

np.strFind(a, sub, start?, end?)

Return (x1 > x2) element-wise for string arrays.

np.strGreater(x1, x2)

np.strGreaterEqual

Return (x1 >= x2) element-wise for string arrays.

np.strGreaterEqual(x1, x2)

Like find, but raises ValueError if substring is not found.

np.strIndex(a, sub, start?, end?)

Return element-wise copy with leading and trailing characters removed.

np.strip(a, chars?)

Return (x1 < x2) element-wise for string arrays.

np.strLess(x1, x2)

np.strLessEqual

Return (x1 <= x2) element-wise for string arrays.

np.strLessEqual(x1, x2)

Return element-wise (a % i), i.e. string formatting.

np.strMod(a, values)

Return element-wise (a * i), string repeated i times.

np.strMultiply(a, i)

Return (x1 != x2) element-wise for string arrays.

np.strNotEqual(x1, x2)

np.strPartition

Partition each element around the first occurrence of sep.

np.strPartition(a, sep)

Return element-wise copy with occurrences of old replaced by new.

np.strReplace(a, old, new_, count?)

Return element-wise sliced strings.

np.strSlice(a, start?, stop?, step?)

Return element-wise titlecased version.

np.strTranslate

Return element-wise translation of string using a translation table.

np.strTranslate(a, table, deletechars?)

np.structDtypeSize

Get byte size for a given dtype.

np.structDtypeSize(dtype)

Subtract arguments, element-wise.

np.subtract(x1, x2)

Sum of array elements over a given axis.

np.sum(a, axis?, keepdims?, dtype?)

Singular Value Decomposition.

np.svd(a, fullMatrices?)

Return singular values only.

Interchange two axes of an array.

np.swapaxes(a, axis1, axis2)

Return element-wise copy with uppercase and lowercase swapped.

Take elements from an array along an axis.

np.take(arr, indices, axis?, mode?)

np.take_along_axis

Take values from the input array by matching 1d index and data slices.

np.take_along_axis(arr, indicesArr, axis)

Take elements from a flattened array.

np.takeFlat(arr, indices, mode?)

Compute tangent element-wise.

Compute hyperbolic tangent element-wise.

Compute tensor dot product along specified axes.

np.tensordot(a, b, axes?)

Compute the 'inverse' of an N-dimensional array.

np.tensorinv(a, ind?)

Solve the tensor equation a x = b for x.

np.tensorsolve(a, b, axes?)

Construct an array by repeating arr the number of times given by reps.

np.tile(arr, reps)

Return the sum along diagonals of the array.

np.trace(a, offset?, axis1?, axis2?)

Reverse or permute the axes of an array.

np.transpose(a, axes?)

Integrate along the given axis using the composite trapezoidal rule.

np.trapezoid(y, x?, dx?, axis?)

Create a 2D array with ones at and below the given diagonal.

np.tri(N, M?, k?, options?)

Lower triangle of an array.

np.tril(arr, k?)

np.tril_indices

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

np.tril_indices(n, k?, m?)

np.tril_indices_from

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

np.tril_indices_from(arr, k?)

Trim the leading and/or trailing zeros from a 1-D array.

np.trim_zeros(arr, trim?)

Remove small trailing coefficients.

np.trimcoef(c, tol?)

Remove trailing zeros from a sequence.

np.trimseq(seq)

Upper triangle of an array.

np.triu(arr, k?)

np.triu_indices

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

np.triu_indices(n, k?, m?)

np.triu_indices_from

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

np.triu_indices_from(arr, k?)

Return the truncated value of the input, element-wise.

np.typedArrayToDType

Infer DType from a TypedArray.

np.typedArrayToDType(arr)

Find the union of two arrays.

np.union1d(ar1, ar2)

Find the unique elements of an array.

np.unique(arr, options?)

Return unique values, indices, inverse, and counts.

np.uniqueAll(arr)

np.uniqueCounts

Return unique values and their counts.

np.uniqueCounts(arr)

Return unique values and indices of first occurrence.

np.uniqueIndex(arr)

np.uniqueInverse

Return unique values and indices to reconstruct original.

np.uniqueInverse(arr)

np.uniqueValues

Return only the unique values (simplified interface).

np.uniqueValues(arr)

Unpack elements of a uint8 array into a binary array.

np.unpackbits(a, axis?, count?, bitorder?)

np.unravelIndex

Convert a flat index into a tuple of coordinate arrays.

np.unravelIndex(indices, shape)

Unpack the array along a given axis.

np.unstack(arr, axis?)

Unwrap by taking the complement of large deltas with respect to the period.

np.unwrap(p, discont?, axis?, period?)

Return element-wise copy with lowercase characters converted to uppercase.

Generate a Vandermonde matrix.

np.vander(x, N?, increasing?, options?)

Compute the variance along the specified axis.

np.variance(a, axis?, ddof?, keepdims?, dtype?)

Compute the dot product of two vectors (flattened inputs).

Compute the vector dot product of two arrays along the last axis.

np.vecdot(x1, x2, axis?)

Vector-matrix product.

np.vecmat(x1, x2)

Compute the vector norm.

np.vector_norm(x, ord?, axis?, keepdims?)

Factory function for creating a Vectorize instance.

np.vectorize(pyfunc, options?)

Split an array into multiple sub-arrays vertically (row-wise).

np.vsplit(arr, indices_or_sections)

Stack arrays in sequence vertically (row-wise).

Return elements chosen from x or y depending on condition.

np.where(condition, x?, y?)

np.withPrintoptions

Execute a function with temporary print options.

np.withPrintoptions(options, fn)

Create a new NDArray filled with zeros.

np.zeros(shape, options?)

Create an array of zeros with the same shape and type as a given array.

np.zeros_like(a)

Return element-wise numeric string left-padded with zeros.

np.zfill(a, width)