NUMPY_API * Get MultiIterator, */

* Get the unbound ArrayMethod which wraps the instances of the ufunc. * Note that this function stores the result on the ufunc and then only * retur

NUMPY_API Get pointer to one of correct type for array */

* Like PyArray_IntpConverter, but leaves `seq` untouched if `None` is passed * rather than treating `None` as `()`. */

NUMPY_API * Useful to pass as converter function for O& processing in * PyArgs_ParseTuple for output arrays */

NUMPY_API * Partition an array in-place */

* The same as PyArray_PrepareOneRawArrayIter, but for three * operands instead of one. Any broadcasting of the three operands * should have already

* Produces the smallest size and lowest kind type to which all * input types can be cast. * * Roughly equivalent to functools.reduce(PyArray_Promot

NUMPY_API * Put values into an array according to a mask. */

NUMPY_API * Put values into an array */

* Small wrapper converting to array just like CPython does. * * We could use our own PyArray_PyIntAsInt function, but it handles floats * different

returns typenum to associate with this type >=NPY_USERDEF. needs the userdecrs table and PyArray_NUMUSER variables defined in arraytypes.inc */ NU

NUMPY_API * Repeat the array. */

NUMPY_API * Resize (reallocate data). Only works if nothing else is referencing this * array and it is contiguous. If refcheck is 0, then the refe

NUMPY_API * Round */

NUMPY_API * ScalarKind * * Returns the scalar kind of a type number, with an * optional tweak based on the scalar value itself. * If no scalar is

NUMPY_API * * Search the sorted array op1 for the location of the items in op2. The * result is an array of indexes, one for each element in op2, s

NUMPY_API Set a subset of bytes from each element of the array steals reference to dtype, must not be NULL */

NUMPY_API *Set internal structure with number functions that all arrays will use */

NUMPY_API * Set the array print function to be a Python function. */

NUMPY_API * * return a new view of the array object with all of its unit-length * dimensions squeezed out if needed, otherwise * return the same a

* Just like PyArray_Squeeze, but allows the caller to select * a subset of the size-one dimensions to squeeze out. */

NUMPY_API * SwapAxes */

NUMPY_API To File */

Like PyArray_ToFile but takes the file as a python object */

NUMPY_API * To List */

NUMPY_API * Trace */

NUMPY_API * Typestr converter */

NUMPY_API * Where */

NUMPY_API Decrement all internal references for object arrays. (or arrays with object fields) The use of this function is strongly discouraged,

NUMPY_API Get pointer to zero of correct type for array. */

NUMPY_API * Allocates zeroed memory for array data. */

* Get possible out argument from kwds, and returns the number of outputs * contained within it: if a tuple, the number of elements in it, 1 otherwise

* Add loop directly to a ufunc from a given ArrayMethod spec. */

* Allows creating of a fairly lightweight wrapper around an existing ufunc * loop. The idea is mainly for units, as this is currently slightly limit

* This function applies the type resolution rules for division. * In particular, there are a number of special cases with datetime: * m8[<A>] / m

* The implementation of the reduction operators with the new iterator * turned into a bit of a long function here, but I think the design * of this

* This function executes all the standard NumPy reduction function * boilerplate code, just calling the appropriate inner loop function where * nece

* Reduceat performs a reduce over an axis using the indices as a guide * * op.reduceat(array,indices) computes * op.reduce(array[indices[i]:indice

* Same as `PyUFunc_ValidateCasting` but only checks output casting. */

Generate a TypeDescription instance for each item in types

* Return 0 if successful */

* Lightweight function fetch a default instance of a DType class. * Note that this version is named `_PyArray_GetDefaultDescr` with an * underscore.

Helper function to get unicode(PyLong).encode('utf8') */

* Check whether the given array is stored contiguously * in memory. And update the passed in ap flags appropriately. * * The traditional rule is th

Finalizes the masked array.

Special hook for ufuncs. Wraps the numpy array and sets the mask according to context.

Performs the operation __dlpack_device__.

Return (self >= other) element-wise. See Also -------- greater_equal