* Add an item to the identity cache. The storage location must not change * unless the cache is cleared. * * @param tb The mapping. * @param key

* Fetches a strided-loop function that supports a boolean mask as additional * (last) operand to the strided-loop. It is otherwise largely identical

* Fills an item based on a coercion cache object. It consumes the cache * object while doing so. * * @param self Array to fill. * @param cache coe

* Assigns a scalar value specified by 'src_dtype' and 'src_data' * to elements of 'dst'. * * dst: The destination array. * src_dtype: The data typ

NUMPY_API*/

NUMPY_API * return 1 if an object is exactly a numpy scalar */

NUMPY_API*/

* This function defines the common DType operator. * * Note that the common DType will not be "object" (unless one of the dtypes * is object), even

* Implementation for np.concatenate * * @param op Sequence of arrays to concatenate * @param axis Axis to concatenate along * @param ret output ar

NUMPY_API * Counts the number of non-zero elements in the array. * * Returns -1 on error. */

NUMPY_API * Diagonal * * In NumPy versions prior to 1.7, this function always returned a copy of * the diagonal array. In 1.7, the code has been

NUMPY_API*/

* Helper to find the target descriptor for multiple arrays given an input * one that may be a DType class (e.g. "U" or "S"). * Works with arrays, si

* Check for an __array__ attribute and call it when it exists. * * .. warning: * If returned, `NotImplemented` is borrowed and must not be De

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

* Get the ndarray subclass with the highest priority */

* Reads values from a sequence of integers and stores them into an array. * * @param seq A sequence created using `PySequence_Fast`. * @param

NUMPY_API * * Same as PyArray_MapIterArray, but: * * If copy_if_overlap != 0, check if `a` has memory overlap with any of the * arrays in `index`

NUMPY_API * This function needs to update the state of the map iterator * and point mit->dataptr to the memory-location of the next object * * Not

NUMPY_API * Move the memory of one array into another, allowing for overlapping data. * * Returns 0 on success, negative on failure. */

NUMPY_API * Get MultiIterator from array of Python objects and any additional * * PyObject **mps - array of PyObjects * int n - number of PyObject

NUMPY_API * * Get New ArrayFlagsObject */

* Creates a new array with the same shape as the provided one, * with possible memory layout order, data type and shape changes. * * prototype - Th

NUMPY_API * Convert an object to FORTRAN / C / ANY / KEEP */

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

* Promotes a list of DTypes with each other in a way that should guarantee * stable results even when changing the order. * * In general this appro

NUMPY_API * Ravel * Returns a contiguous array */

NUMPY_API * * Removes the axes flagged as True from the array, * modifying it in place. If an axis flagged for removal * has a shape entry bigger

NUMPY_API * Reshape */

NUMPY_API * Sort an array in-place */

NUMPY_API * Take */

* Check whether an object has __array_ufunc__ defined on its class and it * is not the default, i.e., the object is not an ndarray, and its * __arra

UFUNC_API*/

UFUNC_API * * On return, if errobj is populated with a non-NULL value, the caller * owns a new reference to errobj. */

UFUNC_API*/

Similar to array_dealloc in arrayobject.c */

Return the next value, or raise StopIteration. Examples -------- >>> x = np.ma.array([3, 2], mask=[0, 1]) >>

hack in keepdims behavior into a function taking an axis

Common implementation for add_library and add_installed_library. Do not use directly

* Apply the __array_wrap__ function with the given array and content. * * Interprets wrap=None and wrap=NULL as intended by _find_array_wrap * * S

* Like ceil(value), but check for overflow. * * Return 0 on success, -1 on failure. In case of failure, set a PyExc_Overflow * exception */

Check that ufuncs don't mishandle refcount of object `1`. Used in a few regression tests.

Implement a forward binary method with a ufunc, e.g., __add__.

Convert a list of indices ``[0, 1, 2]`` into ``"arrays[0][1][2]"``.

* Get the buffer info returning either the old one (passed in) or a new * buffer info which adds holds on to (and thus replaces) the old one. */

* NOTE: for backward compatibility (esp. with PyArg_ParseTuple("s#", ...)) * we do *not* define bf_releasebuffer at all. * * Instead, any extra dat

Helper for calculating broadcast shapes with core dimensions.

Check for a branch cut in a function. Assert that `x0` lies on a branch cut of function `f` and `f` is continuous from the direction `dx

Check if an import library for the Python runtime already exists.

Find mandatory and optional libs in expected paths. Missing optional libraries are silently forgotten.

Check a multi index item getting and simple setting. Parameters ---------- arr : ndarray Array to be indexed, mus

Return commandline representation used to determine if a file needs to be recompiled

Compare mimicked result to indexing result.