JezK
Edit File: multiarray_api.txt
=========== NumPy C-API =========== :: unsigned int PyArray_GetNDArrayCVersion(void ) Included at the very first so not auto-grabbed and thus not labeled. :: int PyArray_SetNumericOps(PyObject *dict) Set internal structure with number functions that all arrays will use :: PyObject * PyArray_GetNumericOps(void ) Get dictionary showing number functions that all arrays will use :: int PyArray_INCREF(PyArrayObject *mp) For object arrays, increment all internal references. :: int PyArray_XDECREF(PyArrayObject *mp) Decrement all internal references for object arrays. (or arrays with object fields) :: void PyArray_SetStringFunction(PyObject *op, int repr) Set the array print function to be a Python function. :: PyArray_Descr * PyArray_DescrFromType(int type) Get the PyArray_Descr structure for a type. :: PyObject * PyArray_TypeObjectFromType(int type) Get a typeobject from a type-number -- can return NULL. New reference :: char * PyArray_Zero(PyArrayObject *arr) Get pointer to zero of correct type for array. :: char * PyArray_One(PyArrayObject *arr) Get pointer to one of correct type for array :: PyObject * PyArray_CastToType(PyArrayObject *arr, PyArray_Descr *dtype, int is_f_order) For backward compatibility Cast an array using typecode structure. steals reference to dtype --- cannot be NULL This function always makes a copy of arr, even if the dtype doesn't change. :: int PyArray_CastTo(PyArrayObject *out, PyArrayObject *mp) Cast to an already created array. :: int PyArray_CastAnyTo(PyArrayObject *out, PyArrayObject *mp) Cast to an already created array. Arrays don't have to be "broadcastable" Only requirement is they have the same number of elements. :: int PyArray_CanCastSafely(int fromtype, int totype) Check the type coercion rules. :: npy_bool PyArray_CanCastTo(PyArray_Descr *from, PyArray_Descr *to) leaves reference count alone --- cannot be NULL PyArray_CanCastTypeTo is equivalent to this, but adds a 'casting' parameter. :: int PyArray_ObjectType(PyObject *op, int minimum_type) Return the typecode of the array a Python object would be converted to Returns the type number the result should have, or NPY_NOTYPE on error. :: PyArray_Descr * PyArray_DescrFromObject(PyObject *op, PyArray_Descr *mintype) new reference -- accepts NULL for mintype :: PyArrayObject ** PyArray_ConvertToCommonType(PyObject *op, int *retn) This function is only used in one place within NumPy and should generally be avoided. It is provided mainly for backward compatibility. The user of the function has to free the returned array with PyDataMem_FREE. :: PyArray_Descr * PyArray_DescrFromScalar(PyObject *sc) Return descr object from array scalar. New reference :: PyArray_Descr * PyArray_DescrFromTypeObject(PyObject *type) :: npy_intp PyArray_Size(PyObject *op) Compute the size of an array (in number of items) :: PyObject * PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base) Get scalar-equivalent to a region of memory described by a descriptor. :: PyObject * PyArray_FromScalar(PyObject *scalar, PyArray_Descr *outcode) Get 0-dim array from scalar 0-dim array from array-scalar object always contains a copy of the data unless outcode is NULL, it is of void type and the referrer does not own it either. steals reference to outcode :: void PyArray_ScalarAsCtype(PyObject *scalar, void *ctypeptr) Convert to c-type no error checking is performed -- ctypeptr must be same type as scalar in case of flexible type, the data is not copied into ctypeptr which is expected to be a pointer to pointer :: int PyArray_CastScalarToCtype(PyObject *scalar, void *ctypeptr, PyArray_Descr *outcode) Cast Scalar to c-type The output buffer must be large-enough to receive the value Even for flexible types which is different from ScalarAsCtype where only a reference for flexible types is returned This may not work right on narrow builds for NumPy unicode scalars. :: int PyArray_CastScalarDirect(PyObject *scalar, PyArray_Descr *indescr, void *ctypeptr, int outtype) Cast Scalar to c-type :: PyObject * PyArray_ScalarFromObject(PyObject *object) Get an Array Scalar From a Python Object Returns NULL if unsuccessful but error is only set if another error occurred. Currently only Numeric-like object supported. :: PyArray_VectorUnaryFunc * PyArray_GetCastFunc(PyArray_Descr *descr, int type_num) Get a cast function to cast from the input descriptor to the output type_number (must be a registered data-type). Returns NULL if un-successful. :: PyObject * PyArray_FromDims(int NPY_UNUSED(nd) , int *NPY_UNUSED(d) , int NPY_UNUSED(type) ) Deprecated, use PyArray_SimpleNew instead. :: PyObject * PyArray_FromDimsAndDataAndDescr(int NPY_UNUSED(nd) , int *NPY_UNUSED(d) , PyArray_Descr *descr, char *NPY_UNUSED(data) ) Deprecated, use PyArray_NewFromDescr instead. :: PyObject * PyArray_FromAny(PyObject *op, PyArray_Descr *newtype, int min_depth, int max_depth, int flags, PyObject *context) Does not check for NPY_ARRAY_ENSURECOPY and NPY_ARRAY_NOTSWAPPED in flags Steals a reference to newtype --- which can be NULL :: PyObject * PyArray_EnsureArray(PyObject *op) This is a quick wrapper around PyArray_FromAny(op, NULL, 0, 0, NPY_ARRAY_ENSUREARRAY, NULL) that special cases Arrays and PyArray_Scalars up front It *steals a reference* to the object It also guarantees that the result is PyArray_Type Because it decrefs op if any conversion needs to take place so it can be used like PyArray_EnsureArray(some_function(...)) :: PyObject * PyArray_EnsureAnyArray(PyObject *op) :: PyObject * PyArray_FromFile(FILE *fp, PyArray_Descr *dtype, npy_intp num, char *sep) Given a ``FILE *`` pointer ``fp``, and a ``PyArray_Descr``, return an array corresponding to the data encoded in that file. The reference to `dtype` is stolen (it is possible that the passed in dtype is not held on to). The number of elements to read is given as ``num``; if it is < 0, then then as many as possible are read. If ``sep`` is NULL or empty, then binary data is assumed, else text data, with ``sep`` as the separator between elements. Whitespace in the separator matches any length of whitespace in the text, and a match for whitespace around the separator is added. For memory-mapped files, use the buffer interface. No more data than necessary is read by this routine. :: PyObject * PyArray_FromString(char *data, npy_intp slen, PyArray_Descr *dtype, npy_intp num, char *sep) Given a pointer to a string ``data``, a string length ``slen``, and a ``PyArray_Descr``, return an array corresponding to the data encoded in that string. If the dtype is NULL, the default array type is used (double). If non-null, the reference is stolen. If ``slen`` is < 0, then the end of string is used for text data. It is an error for ``slen`` to be < 0 for binary data (since embedded NULLs would be the norm). The number of elements to read is given as ``num``; if it is < 0, then then as many as possible are read. If ``sep`` is NULL or empty, then binary data is assumed, else text data, with ``sep`` as the separator between elements. Whitespace in the separator matches any length of whitespace in the text, and a match for whitespace around the separator is added. :: PyObject * PyArray_FromBuffer(PyObject *buf, PyArray_Descr *type, npy_intp count, npy_intp offset) :: PyObject * PyArray_FromIter(PyObject *obj, PyArray_Descr *dtype, npy_intp count) steals a reference to dtype (which cannot be NULL) :: PyObject * PyArray_Return(PyArrayObject *mp) Return either an array or the appropriate Python object if the array is 0d and matches a Python type. steals reference to mp :: PyObject * PyArray_GetField(PyArrayObject *self, PyArray_Descr *typed, int offset) Get a subset of bytes from each element of the array steals reference to typed, must not be NULL :: int PyArray_SetField(PyArrayObject *self, PyArray_Descr *dtype, int offset, PyObject *val) Set a subset of bytes from each element of the array steals reference to dtype, must not be NULL :: PyObject * PyArray_Byteswap(PyArrayObject *self, npy_bool inplace) :: PyObject * PyArray_Resize(PyArrayObject *self, PyArray_Dims *newshape, int refcheck, NPY_ORDER NPY_UNUSED(order) ) Resize (reallocate data). Only works if nothing else is referencing this array and it is contiguous. If refcheck is 0, then the reference count is not checked and assumed to be 1. You still must own this data and have no weak-references and no base object. :: int PyArray_MoveInto(PyArrayObject *dst, PyArrayObject *src) Move the memory of one array into another, allowing for overlapping data. Returns 0 on success, negative on failure. :: int PyArray_CopyInto(PyArrayObject *dst, PyArrayObject *src) Copy an Array into another array. Broadcast to the destination shape if necessary. Returns 0 on success, -1 on failure. :: int PyArray_CopyAnyInto(PyArrayObject *dst, PyArrayObject *src) Copy an Array into another array -- memory must not overlap Does not require src and dest to have "broadcastable" shapes (only the same number of elements). TODO: For NumPy 2.0, this could accept an order parameter which only allows NPY_CORDER and NPY_FORDER. Could also rename this to CopyAsFlat to make the name more intuitive. Returns 0 on success, -1 on error. :: int PyArray_CopyObject(PyArrayObject *dest, PyObject *src_object) :: PyObject * PyArray_NewCopy(PyArrayObject *obj, NPY_ORDER order) Copy an array. :: PyObject * PyArray_ToList(PyArrayObject *self) To List :: PyObject * PyArray_ToString(PyArrayObject *self, NPY_ORDER order) :: int PyArray_ToFile(PyArrayObject *self, FILE *fp, char *sep, char *format) To File :: int PyArray_Dump(PyObject *self, PyObject *file, int protocol) :: PyObject * PyArray_Dumps(PyObject *self, int protocol) :: int PyArray_ValidType(int type) Is the typenum valid? :: void PyArray_UpdateFlags(PyArrayObject *ret, int flagmask) Update Several Flags at once. :: PyObject * PyArray_New(PyTypeObject *subtype, int nd, npy_intp const *dims, int type_num, npy_intp const *strides, void *data, int itemsize, int flags, PyObject *obj) Generic new array creation routine. :: PyObject * PyArray_NewFromDescr(PyTypeObject *subtype, PyArray_Descr *descr, int nd, npy_intp const *dims, npy_intp const *strides, void *data, int flags, PyObject *obj) Generic new array creation routine. steals a reference to descr. On failure or when dtype->subarray is true, dtype will be decrefed. :: PyArray_Descr * PyArray_DescrNew(PyArray_Descr *base) base cannot be NULL :: PyArray_Descr * PyArray_DescrNewFromType(int type_num) :: double PyArray_GetPriority(PyObject *obj, double default_) Get Priority from object :: PyObject * PyArray_IterNew(PyObject *obj) Get Iterator. :: PyObject* PyArray_MultiIterNew(int n, ... ) Get MultiIterator, :: int PyArray_PyIntAsInt(PyObject *o) :: npy_intp PyArray_PyIntAsIntp(PyObject *o) :: int PyArray_Broadcast(PyArrayMultiIterObject *mit) :: void PyArray_FillObjectArray(PyArrayObject *arr, PyObject *obj) Assumes contiguous :: int PyArray_FillWithScalar(PyArrayObject *arr, PyObject *obj) :: npy_bool PyArray_CheckStrides(int elsize, int nd, npy_intp numbytes, npy_intp offset, npy_intp const *dims, npy_intp const *newstrides) :: PyArray_Descr * PyArray_DescrNewByteorder(PyArray_Descr *self, char newendian) returns a copy of the PyArray_Descr structure with the byteorder altered: no arguments: The byteorder is swapped (in all subfields as well) single argument: The byteorder is forced to the given state (in all subfields as well) Valid states: ('big', '>') or ('little' or '<') ('native', or '=') If a descr structure with | is encountered it's own byte-order is not changed but any fields are: Deep bytorder change of a data-type descriptor Leaves reference count of self unchanged --- does not DECREF self *** :: PyObject * PyArray_IterAllButAxis(PyObject *obj, int *inaxis) Get Iterator that iterates over all but one axis (don't use this with PyArray_ITER_GOTO1D). The axis will be over-written if negative with the axis having the smallest stride. :: PyObject * PyArray_CheckFromAny(PyObject *op, PyArray_Descr *descr, int min_depth, int max_depth, int requires, PyObject *context) steals a reference to descr -- accepts NULL :: PyObject * PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags) steals reference to newtype --- acc. NULL :: PyObject * PyArray_FromInterface(PyObject *origin) :: PyObject * PyArray_FromStructInterface(PyObject *input) :: PyObject * PyArray_FromArrayAttr(PyObject *op, PyArray_Descr *typecode, PyObject *context) :: NPY_SCALARKIND PyArray_ScalarKind(int typenum, PyArrayObject **arr) ScalarKind Returns the scalar kind of a type number, with an optional tweak based on the scalar value itself. If no scalar is provided, it returns INTPOS_SCALAR for both signed and unsigned integers, otherwise it checks the sign of any signed integer to choose INTNEG_SCALAR when appropriate. :: int PyArray_CanCoerceScalar(int thistype, int neededtype, NPY_SCALARKIND scalar) Determines whether the data type 'thistype', with scalar kind 'scalar', can be coerced into 'neededtype'. :: PyObject * PyArray_NewFlagsObject(PyObject *obj) Get New ArrayFlagsObject :: npy_bool PyArray_CanCastScalar(PyTypeObject *from, PyTypeObject *to) See if array scalars can be cast. TODO: For NumPy 2.0, add a NPY_CASTING parameter. :: int PyArray_CompareUCS4(npy_ucs4 const *s1, npy_ucs4 const *s2, size_t len) :: int PyArray_RemoveSmallest(PyArrayMultiIterObject *multi) Adjusts previously broadcasted iterators so that the axis with the smallest sum of iterator strides is not iterated over. Returns dimension which is smallest in the range [0,multi->nd). A -1 is returned if multi->nd == 0. don't use with PyArray_ITER_GOTO1D because factors are not adjusted :: int PyArray_ElementStrides(PyObject *obj) :: void PyArray_Item_INCREF(char *data, PyArray_Descr *descr) XINCREF all objects in a single array item. This is complicated for structured datatypes where the position of objects needs to be extracted. The function is execute recursively for each nested field or subarrays dtype such as as `np.dtype([("field1", "O"), ("field2", "f,O", (3,2))])` :: void PyArray_Item_XDECREF(char *data, PyArray_Descr *descr) XDECREF all objects in a single array item. This is complicated for structured datatypes where the position of objects needs to be extracted. The function is execute recursively for each nested field or subarrays dtype such as as `np.dtype([("field1", "O"), ("field2", "f,O", (3,2))])` :: PyObject * PyArray_FieldNames(PyObject *fields) Return the tuple of ordered field names from a dictionary. :: PyObject * PyArray_Transpose(PyArrayObject *ap, PyArray_Dims *permute) Return Transpose. :: PyObject * PyArray_TakeFrom(PyArrayObject *self0, PyObject *indices0, int axis, PyArrayObject *out, NPY_CLIPMODE clipmode) Take :: PyObject * PyArray_PutTo(PyArrayObject *self, PyObject*values0, PyObject *indices0, NPY_CLIPMODE clipmode) Put values into an array :: PyObject * PyArray_PutMask(PyArrayObject *self, PyObject*values0, PyObject*mask0) Put values into an array according to a mask. :: PyObject * PyArray_Repeat(PyArrayObject *aop, PyObject *op, int axis) Repeat the array. :: PyObject * PyArray_Choose(PyArrayObject *ip, PyObject *op, PyArrayObject *out, NPY_CLIPMODE clipmode) :: int PyArray_Sort(PyArrayObject *op, int axis, NPY_SORTKIND which) Sort an array in-place :: PyObject * PyArray_ArgSort(PyArrayObject *op, int axis, NPY_SORTKIND which) ArgSort an array :: PyObject * PyArray_SearchSorted(PyArrayObject *op1, PyObject *op2, NPY_SEARCHSIDE side, PyObject *perm) 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, such that if the item were to be inserted in op1 just before that index the array would still be in sorted order. Parameters ---------- op1 : PyArrayObject * Array to be searched, must be 1-D. op2 : PyObject * Array of items whose insertion indexes in op1 are wanted side : {NPY_SEARCHLEFT, NPY_SEARCHRIGHT} If NPY_SEARCHLEFT, return first valid insertion indexes If NPY_SEARCHRIGHT, return last valid insertion indexes perm : PyObject * Permutation array that sorts op1 (optional) Returns ------- ret : PyObject * New reference to npy_intp array containing indexes where items in op2 could be validly inserted into op1. NULL on error. Notes ----- Binary search is used to find the indexes. :: PyObject * PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out) ArgMax :: PyObject * PyArray_ArgMin(PyArrayObject *op, int axis, PyArrayObject *out) ArgMin :: PyObject * PyArray_Reshape(PyArrayObject *self, PyObject *shape) Reshape :: PyObject * PyArray_Newshape(PyArrayObject *self, PyArray_Dims *newdims, NPY_ORDER order) New shape for an array :: PyObject * PyArray_Squeeze(PyArrayObject *self) return a new view of the array object with all of its unit-length dimensions squeezed out if needed, otherwise return the same array. :: PyObject * PyArray_View(PyArrayObject *self, PyArray_Descr *type, PyTypeObject *pytype) View steals a reference to type -- accepts NULL :: PyObject * PyArray_SwapAxes(PyArrayObject *ap, int a1, int a2) SwapAxes :: PyObject * PyArray_Max(PyArrayObject *ap, int axis, PyArrayObject *out) Max :: PyObject * PyArray_Min(PyArrayObject *ap, int axis, PyArrayObject *out) Min :: PyObject * PyArray_Ptp(PyArrayObject *ap, int axis, PyArrayObject *out) Ptp :: PyObject * PyArray_Mean(PyArrayObject *self, int axis, int rtype, PyArrayObject *out) Mean :: PyObject * PyArray_Trace(PyArrayObject *self, int offset, int axis1, int axis2, int rtype, PyArrayObject *out) Trace :: PyObject * PyArray_Diagonal(PyArrayObject *self, int offset, int axis1, int axis2) 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 updated to compute a view onto 'self', but it still copies this array before returning, as well as setting the internal WARN_ON_WRITE flag. In a future version, it will simply return a view onto self. :: PyObject * PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *out) Clip :: PyObject * PyArray_Conjugate(PyArrayObject *self, PyArrayObject *out) Conjugate :: PyObject * PyArray_Nonzero(PyArrayObject *self) Nonzero TODO: In NumPy 2.0, should make the iteration order a parameter. :: PyObject * PyArray_Std(PyArrayObject *self, int axis, int rtype, PyArrayObject *out, int variance) Set variance to 1 to by-pass square-root calculation and return variance Std :: PyObject * PyArray_Sum(PyArrayObject *self, int axis, int rtype, PyArrayObject *out) Sum :: PyObject * PyArray_CumSum(PyArrayObject *self, int axis, int rtype, PyArrayObject *out) CumSum :: PyObject * PyArray_Prod(PyArrayObject *self, int axis, int rtype, PyArrayObject *out) Prod :: PyObject * PyArray_CumProd(PyArrayObject *self, int axis, int rtype, PyArrayObject *out) CumProd :: PyObject * PyArray_All(PyArrayObject *self, int axis, PyArrayObject *out) All :: PyObject * PyArray_Any(PyArrayObject *self, int axis, PyArrayObject *out) Any :: PyObject * PyArray_Compress(PyArrayObject *self, PyObject *condition, int axis, PyArrayObject *out) Compress :: PyObject * PyArray_Flatten(PyArrayObject *a, NPY_ORDER order) Flatten :: PyObject * PyArray_Ravel(PyArrayObject *arr, NPY_ORDER order) Ravel Returns a contiguous array :: npy_intp PyArray_MultiplyList(npy_intp const *l1, int n) Multiply a List :: int PyArray_MultiplyIntList(int const *l1, int n) Multiply a List of ints :: void * PyArray_GetPtr(PyArrayObject *obj, npy_intp const*ind) Produce a pointer into array :: int PyArray_CompareLists(npy_intp const *l1, npy_intp const *l2, int n) Compare Lists :: int PyArray_AsCArray(PyObject **op, void *ptr, npy_intp *dims, int nd, PyArray_Descr*typedescr) Simulate a C-array steals a reference to typedescr -- can be NULL :: int PyArray_As1D(PyObject **NPY_UNUSED(op) , char **NPY_UNUSED(ptr) , int *NPY_UNUSED(d1) , int NPY_UNUSED(typecode) ) Convert to a 1D C-array :: int PyArray_As2D(PyObject **NPY_UNUSED(op) , char ***NPY_UNUSED(ptr) , int *NPY_UNUSED(d1) , int *NPY_UNUSED(d2) , int NPY_UNUSED(typecode) ) Convert to a 2D C-array :: int PyArray_Free(PyObject *op, void *ptr) Free pointers created if As2D is called :: int PyArray_Converter(PyObject *object, PyObject **address) Useful to pass as converter function for O& processing in PyArgs_ParseTuple. This conversion function can be used with the "O&" argument for PyArg_ParseTuple. It will immediately return an object of array type or will convert to a NPY_ARRAY_CARRAY any other object. If you use PyArray_Converter, you must DECREF the array when finished as you get a new reference to it. :: int PyArray_IntpFromSequence(PyObject *seq, npy_intp *vals, int maxvals) PyArray_IntpFromSequence Returns the number of integers converted or -1 if an error occurred. vals must be large enough to hold maxvals :: PyObject * PyArray_Concatenate(PyObject *op, int axis) Concatenate Concatenate an arbitrary Python sequence into an array. op is a python object supporting the sequence interface. Its elements will be concatenated together to form a single multidimensional array. If axis is NPY_MAXDIMS or bigger, then each sequence object will be flattened before concatenation :: PyObject * PyArray_InnerProduct(PyObject *op1, PyObject *op2) Numeric.innerproduct(a,v) :: PyObject * PyArray_MatrixProduct(PyObject *op1, PyObject *op2) Numeric.matrixproduct(a,v) just like inner product but does the swapaxes stuff on the fly :: PyObject * PyArray_CopyAndTranspose(PyObject *op) Copy and Transpose Could deprecate this function, as there isn't a speed benefit over calling Transpose and then Copy. :: PyObject * PyArray_Correlate(PyObject *op1, PyObject *op2, int mode) Numeric.correlate(a1,a2,mode) :: int PyArray_TypestrConvert(int itemsize, int gentype) Typestr converter :: int PyArray_DescrConverter(PyObject *obj, PyArray_Descr **at) Get typenum from an object -- None goes to NPY_DEFAULT_TYPE This function takes a Python object representing a type and converts it to a the correct PyArray_Descr * structure to describe the type. Many objects can be used to represent a data-type which in NumPy is quite a flexible concept. This is the central code that converts Python objects to Type-descriptor objects that are used throughout numpy. Returns a new reference in *at, but the returned should not be modified as it may be one of the canonical immutable objects or a reference to the input obj. :: int PyArray_DescrConverter2(PyObject *obj, PyArray_Descr **at) Get typenum from an object -- None goes to NULL :: int PyArray_IntpConverter(PyObject *obj, PyArray_Dims *seq) Get intp chunk from sequence This function takes a Python sequence object and allocates and fills in an intp array with the converted values. Remember to free the pointer seq.ptr when done using PyDimMem_FREE(seq.ptr)** :: int PyArray_BufferConverter(PyObject *obj, PyArray_Chunk *buf) Get buffer chunk from object this function takes a Python object which exposes the (single-segment) buffer interface and returns a pointer to the data segment You should increment the reference count by one of buf->base if you will hang on to a reference You only get a borrowed reference to the object. Do not free the memory... :: int PyArray_AxisConverter(PyObject *obj, int *axis) Get axis from an object (possibly None) -- a converter function, See also PyArray_ConvertMultiAxis, which also handles a tuple of axes. :: int PyArray_BoolConverter(PyObject *object, npy_bool *val) Convert an object to true / false :: int PyArray_ByteorderConverter(PyObject *obj, char *endian) Convert object to endian :: int PyArray_OrderConverter(PyObject *object, NPY_ORDER *val) Convert an object to FORTRAN / C / ANY / KEEP :: unsigned char PyArray_EquivTypes(PyArray_Descr *type1, PyArray_Descr *type2) This function returns true if the two typecodes are equivalent (same basic kind and same itemsize). :: PyObject * PyArray_Zeros(int nd, npy_intp const *dims, PyArray_Descr *type, int is_f_order) Zeros steals a reference to type. On failure or when dtype->subarray is true, dtype will be decrefed. accepts NULL type :: PyObject * PyArray_Empty(int nd, npy_intp const *dims, PyArray_Descr *type, int is_f_order) Empty accepts NULL type steals a reference to type :: PyObject * PyArray_Where(PyObject *condition, PyObject *x, PyObject *y) Where :: PyObject * PyArray_Arange(double start, double stop, double step, int type_num) Arange, :: PyObject * PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr *dtype) ArangeObj, this doesn't change the references :: int PyArray_SortkindConverter(PyObject *obj, NPY_SORTKIND *sortkind) Convert object to sort kind :: PyObject * PyArray_LexSort(PyObject *sort_keys, int axis) LexSort an array providing indices that will sort a collection of arrays lexicographically. The first key is sorted on first, followed by the second key -- requires that arg"merge"sort is available for each sort_key Returns an index array that shows the indexes for the lexicographic sort along the given axis. :: PyObject * PyArray_Round(PyArrayObject *a, int decimals, PyArrayObject *out) Round :: unsigned char PyArray_EquivTypenums(int typenum1, int typenum2) :: int PyArray_RegisterDataType(PyArray_Descr *descr) Register Data type Does not change the reference count of descr :: int PyArray_RegisterCastFunc(PyArray_Descr *descr, int totype, PyArray_VectorUnaryFunc *castfunc) Register Casting Function Replaces any function currently stored. :: int PyArray_RegisterCanCast(PyArray_Descr *descr, int totype, NPY_SCALARKIND scalar) Register a type number indicating that a descriptor can be cast to it safely :: void PyArray_InitArrFuncs(PyArray_ArrFuncs *f) Initialize arrfuncs to NULL :: PyObject * PyArray_IntTupleFromIntp(int len, npy_intp const *vals) PyArray_IntTupleFromIntp :: int PyArray_TypeNumFromName(char const *str) :: int PyArray_ClipmodeConverter(PyObject *object, NPY_CLIPMODE *val) Convert an object to NPY_RAISE / NPY_CLIP / NPY_WRAP :: int PyArray_OutputConverter(PyObject *object, PyArrayObject **address) Useful to pass as converter function for O& processing in PyArgs_ParseTuple for output arrays :: PyObject * PyArray_BroadcastToShape(PyObject *obj, npy_intp *dims, int nd) Get Iterator broadcast to a particular shape :: void _PyArray_SigintHandler(int signum) :: void* _PyArray_GetSigintBuf(void ) :: int PyArray_DescrAlignConverter(PyObject *obj, PyArray_Descr **at) Get type-descriptor from an object forcing alignment if possible None goes to DEFAULT type. any object with the .fields attribute and/or .itemsize attribute (if the .fields attribute does not give the total size -- i.e. a partial record naming). If itemsize is given it must be >= size computed from fields The .fields attribute must return a convertible dictionary if present. Result inherits from NPY_VOID. :: int PyArray_DescrAlignConverter2(PyObject *obj, PyArray_Descr **at) Get type-descriptor from an object forcing alignment if possible None goes to NULL. :: int PyArray_SearchsideConverter(PyObject *obj, void *addr) Convert object to searchsorted side :: PyObject * PyArray_CheckAxis(PyArrayObject *arr, int *axis, int flags) PyArray_CheckAxis check that axis is valid convert 0-d arrays to 1-d arrays :: npy_intp PyArray_OverflowMultiplyList(npy_intp const *l1, int n) Multiply a List of Non-negative numbers with over-flow detection. :: int PyArray_CompareString(const char *s1, const char *s2, size_t len) :: PyObject* PyArray_MultiIterFromObjects(PyObject **mps, int n, int nadd, ... ) Get MultiIterator from array of Python objects and any additional PyObject **mps - array of PyObjects int n - number of PyObjects in the array int nadd - number of additional arrays to include in the iterator. Returns a multi-iterator object. :: int PyArray_GetEndianness(void ) :: unsigned int PyArray_GetNDArrayCFeatureVersion(void ) Returns the built-in (at compilation time) C API version :: PyObject * PyArray_Correlate2(PyObject *op1, PyObject *op2, int mode) correlate(a1,a2,mode) This function computes the usual correlation (correlate(a1, a2) != correlate(a2, a1), and conjugate the second argument for complex inputs :: PyObject* PyArray_NeighborhoodIterNew(PyArrayIterObject *x, const npy_intp *bounds, int mode, PyArrayObject*fill) A Neighborhood Iterator object. :: void PyArray_SetDatetimeParseFunction(PyObject *NPY_UNUSED(op) ) This function is scheduled to be removed TO BE REMOVED - NOT USED INTERNALLY. :: void PyArray_DatetimeToDatetimeStruct(npy_datetime NPY_UNUSED(val) , NPY_DATETIMEUNIT NPY_UNUSED(fr) , npy_datetimestruct *result) Fill the datetime struct from the value and resolution unit. TO BE REMOVED - NOT USED INTERNALLY. :: void PyArray_TimedeltaToTimedeltaStruct(npy_timedelta NPY_UNUSED(val) , NPY_DATETIMEUNIT NPY_UNUSED(fr) , npy_timedeltastruct *result) Fill the timedelta struct from the timedelta value and resolution unit. TO BE REMOVED - NOT USED INTERNALLY. :: npy_datetime PyArray_DatetimeStructToDatetime(NPY_DATETIMEUNIT NPY_UNUSED(fr) , npy_datetimestruct *NPY_UNUSED(d) ) Create a datetime value from a filled datetime struct and resolution unit. TO BE REMOVED - NOT USED INTERNALLY. :: npy_datetime PyArray_TimedeltaStructToTimedelta(NPY_DATETIMEUNIT NPY_UNUSED(fr) , npy_timedeltastruct *NPY_UNUSED(d) ) Create a timedelta value from a filled timedelta struct and resolution unit. TO BE REMOVED - NOT USED INTERNALLY. :: NpyIter * NpyIter_New(PyArrayObject *op, npy_uint32 flags, NPY_ORDER order, NPY_CASTING casting, PyArray_Descr*dtype) Allocate a new iterator for one array object. :: NpyIter * NpyIter_MultiNew(int nop, PyArrayObject **op_in, npy_uint32 flags, NPY_ORDER order, NPY_CASTING casting, npy_uint32 *op_flags, PyArray_Descr **op_request_dtypes) Allocate a new iterator for more than one array object, using standard NumPy broadcasting rules and the default buffer size. :: NpyIter * NpyIter_AdvancedNew(int nop, PyArrayObject **op_in, npy_uint32 flags, NPY_ORDER order, NPY_CASTING casting, npy_uint32 *op_flags, PyArray_Descr **op_request_dtypes, int oa_ndim, int **op_axes, npy_intp *itershape, npy_intp buffersize) Allocate a new iterator for multiple array objects, and advanced options for controlling the broadcasting, shape, and buffer size. :: NpyIter * NpyIter_Copy(NpyIter *iter) Makes a copy of the iterator :: int NpyIter_Deallocate(NpyIter *iter) Deallocate an iterator. To correctly work when an error is in progress, we have to check `PyErr_Occurred()`. This is necessary when buffers are not finalized or WritebackIfCopy is used. We could avoid that check by exposing a new function which is passed in whether or not a Python error is already set. :: npy_bool NpyIter_HasDelayedBufAlloc(NpyIter *iter) Whether the buffer allocation is being delayed :: npy_bool NpyIter_HasExternalLoop(NpyIter *iter) Whether the iterator handles the inner loop :: int NpyIter_EnableExternalLoop(NpyIter *iter) Removes the inner loop handling (so HasExternalLoop returns true) :: npy_intp * NpyIter_GetInnerStrideArray(NpyIter *iter) Get the array of strides for the inner loop (when HasExternalLoop is true) This function may be safely called without holding the Python GIL. :: npy_intp * NpyIter_GetInnerLoopSizePtr(NpyIter *iter) Get a pointer to the size of the inner loop (when HasExternalLoop is true) This function may be safely called without holding the Python GIL. :: int NpyIter_Reset(NpyIter *iter, char **errmsg) Resets the iterator to its initial state The use of errmsg is discouraged, it cannot be guaranteed that the GIL will not be grabbed on casting errors even when this is passed. If errmsg is non-NULL, it should point to a variable which will receive the error message, and no Python exception will be set. This is so that the function can be called from code not holding the GIL. Note that cast errors may still lead to the GIL being grabbed temporarily. :: int NpyIter_ResetBasePointers(NpyIter *iter, char **baseptrs, char **errmsg) Resets the iterator to its initial state, with new base data pointers. This function requires great caution. If errmsg is non-NULL, it should point to a variable which will receive the error message, and no Python exception will be set. This is so that the function can be called from code not holding the GIL. Note that cast errors may still lead to the GIL being grabbed temporarily. :: int NpyIter_ResetToIterIndexRange(NpyIter *iter, npy_intp istart, npy_intp iend, char **errmsg) Resets the iterator to a new iterator index range If errmsg is non-NULL, it should point to a variable which will receive the error message, and no Python exception will be set. This is so that the function can be called from code not holding the GIL. Note that cast errors may still lead to the GIL being grabbed temporarily. :: int NpyIter_GetNDim(NpyIter *iter) Gets the number of dimensions being iterated :: int NpyIter_GetNOp(NpyIter *iter) Gets the number of operands being iterated :: NpyIter_IterNextFunc * NpyIter_GetIterNext(NpyIter *iter, char **errmsg) Compute the specialized iteration function for an iterator If errmsg is non-NULL, it should point to a variable which will receive the error message, and no Python exception will be set. This is so that the function can be called from code not holding the GIL. :: npy_intp NpyIter_GetIterSize(NpyIter *iter) Gets the number of elements being iterated :: void NpyIter_GetIterIndexRange(NpyIter *iter, npy_intp *istart, npy_intp *iend) Gets the range of iteration indices being iterated :: npy_intp NpyIter_GetIterIndex(NpyIter *iter) Gets the current iteration index :: int NpyIter_GotoIterIndex(NpyIter *iter, npy_intp iterindex) Sets the iterator position to the specified iterindex, which matches the iteration order of the iterator. Returns NPY_SUCCEED on success, NPY_FAIL on failure. :: npy_bool NpyIter_HasMultiIndex(NpyIter *iter) Whether the iterator is tracking a multi-index :: int NpyIter_GetShape(NpyIter *iter, npy_intp *outshape) Gets the broadcast shape if a multi-index is being tracked by the iterator, otherwise gets the shape of the iteration as Fortran-order (fastest-changing index first). The reason Fortran-order is returned when a multi-index is not enabled is that this is providing a direct view into how the iterator traverses the n-dimensional space. The iterator organizes its memory from fastest index to slowest index, and when a multi-index is enabled, it uses a permutation to recover the original order. Returns NPY_SUCCEED or NPY_FAIL. :: NpyIter_GetMultiIndexFunc * NpyIter_GetGetMultiIndex(NpyIter *iter, char **errmsg) Compute a specialized get_multi_index function for the iterator If errmsg is non-NULL, it should point to a variable which will receive the error message, and no Python exception will be set. This is so that the function can be called from code not holding the GIL. :: int NpyIter_GotoMultiIndex(NpyIter *iter, npy_intp const *multi_index) Sets the iterator to the specified multi-index, which must have the correct number of entries for 'ndim'. It is only valid when NPY_ITER_MULTI_INDEX was passed to the constructor. This operation fails if the multi-index is out of bounds. Returns NPY_SUCCEED on success, NPY_FAIL on failure. :: int NpyIter_RemoveMultiIndex(NpyIter *iter) Removes multi-index support from an iterator. Returns NPY_SUCCEED or NPY_FAIL. :: npy_bool NpyIter_HasIndex(NpyIter *iter) Whether the iterator is tracking an index :: npy_bool NpyIter_IsBuffered(NpyIter *iter) Whether the iterator is buffered :: npy_bool NpyIter_IsGrowInner(NpyIter *iter) Whether the inner loop can grow if buffering is unneeded :: npy_intp NpyIter_GetBufferSize(NpyIter *iter) Gets the size of the buffer, or 0 if buffering is not enabled :: npy_intp * NpyIter_GetIndexPtr(NpyIter *iter) Get a pointer to the index, if it is being tracked :: int NpyIter_GotoIndex(NpyIter *iter, npy_intp flat_index) If the iterator is tracking an index, sets the iterator to the specified index. Returns NPY_SUCCEED on success, NPY_FAIL on failure. :: char ** NpyIter_GetDataPtrArray(NpyIter *iter) Get the array of data pointers (1 per object being iterated) This function may be safely called without holding the Python GIL. :: PyArray_Descr ** NpyIter_GetDescrArray(NpyIter *iter) Get the array of data type pointers (1 per object being iterated) :: PyArrayObject ** NpyIter_GetOperandArray(NpyIter *iter) Get the array of objects being iterated :: PyArrayObject * NpyIter_GetIterView(NpyIter *iter, npy_intp i) Returns a view to the i-th object with the iterator's internal axes :: void NpyIter_GetReadFlags(NpyIter *iter, char *outreadflags) Gets an array of read flags (1 per object being iterated) :: void NpyIter_GetWriteFlags(NpyIter *iter, char *outwriteflags) Gets an array of write flags (1 per object being iterated) :: void NpyIter_DebugPrint(NpyIter *iter) For debugging :: npy_bool NpyIter_IterationNeedsAPI(NpyIter *iter) Whether the iteration loop, and in particular the iternext() function, needs API access. If this is true, the GIL must be retained while iterating. NOTE: Internally (currently), `NpyIter_GetTransferFlags` will additionally provide information on whether floating point errors may be given during casts. The flags only require the API use necessary for buffering though. So an iterate which does not require buffering may indicate `NpyIter_IterationNeedsAPI`, but not include the flag in `NpyIter_GetTransferFlags`. :: void NpyIter_GetInnerFixedStrideArray(NpyIter *iter, npy_intp *out_strides) Get an array of strides which are fixed. Any strides which may change during iteration receive the value NPY_MAX_INTP. Once the iterator is ready to iterate, call this to get the strides which will always be fixed in the inner loop, then choose optimized inner loop functions which take advantage of those fixed strides. This function may be safely called without holding the Python GIL. :: int NpyIter_RemoveAxis(NpyIter *iter, int axis) Removes an axis from iteration. This requires that NPY_ITER_MULTI_INDEX was set for iterator creation, and does not work if buffering is enabled. This function also resets the iterator to its initial state. Returns NPY_SUCCEED or NPY_FAIL. :: npy_intp * NpyIter_GetAxisStrideArray(NpyIter *iter, int axis) Gets the array of strides for the specified axis. If the iterator is tracking a multi-index, gets the strides for the axis specified, otherwise gets the strides for the iteration axis as Fortran order (fastest-changing axis first). Returns NULL if an error occurs. :: npy_bool NpyIter_RequiresBuffering(NpyIter *iter) Whether the iteration could be done with no buffering. :: char ** NpyIter_GetInitialDataPtrArray(NpyIter *iter) Get the array of data pointers (1 per object being iterated), directly into the arrays (never pointing to a buffer), for starting unbuffered iteration. This always returns the addresses for the iterator position as reset to iterator index 0. These pointers are different from the pointers accepted by NpyIter_ResetBasePointers, because the direction along some axes may have been reversed, requiring base offsets. This function may be safely called without holding the Python GIL. :: int NpyIter_CreateCompatibleStrides(NpyIter *iter, npy_intp itemsize, npy_intp *outstrides) Builds a set of strides which are the same as the strides of an output array created using the NPY_ITER_ALLOCATE flag, where NULL was passed for op_axes. This is for data packed contiguously, but not necessarily in C or Fortran order. This should be used together with NpyIter_GetShape and NpyIter_GetNDim. A use case for this function is to match the shape and layout of the iterator and tack on one or more dimensions. For example, in order to generate a vector per input value for a numerical gradient, you pass in ndim*itemsize for itemsize, then add another dimension to the end with size ndim and stride itemsize. To do the Hessian matrix, you do the same thing but add two dimensions, or take advantage of the symmetry and pack it into 1 dimension with a particular encoding. This function may only be called if the iterator is tracking a multi-index and if NPY_ITER_DONT_NEGATE_STRIDES was used to prevent an axis from being iterated in reverse order. If an array is created with this method, simply adding 'itemsize' for each iteration will traverse the new array matching the iterator. Returns NPY_SUCCEED or NPY_FAIL. :: int PyArray_CastingConverter(PyObject *obj, NPY_CASTING *casting) Convert any Python object, *obj*, to an NPY_CASTING enum. :: npy_intp PyArray_CountNonzero(PyArrayObject *self) Counts the number of non-zero elements in the array. Returns -1 on error. :: PyArray_Descr * PyArray_PromoteTypes(PyArray_Descr *type1, PyArray_Descr *type2) Produces the smallest size and lowest kind type to which both input types can be cast. :: PyArray_Descr * PyArray_MinScalarType(PyArrayObject *arr) If arr is a scalar (has 0 dimensions) with a built-in number data type, finds the smallest type size/kind which can still represent its data. Otherwise, returns the array's data type. :: PyArray_Descr * PyArray_ResultType(npy_intp narrs, PyArrayObject *arrs[] , npy_intp ndtypes, PyArray_Descr *descrs[] ) Produces the result type of a bunch of inputs, using the same rules as `np.result_type`. NOTE: This function is expected to through a transitional period or change behaviour. DTypes should always be strictly enforced for 0-D arrays, while "weak DTypes" will be used to represent Python integers, floats, and complex in all cases. (Within this function, these are currently flagged on the array object to work through `np.result_type`, this may change.) Until a time where this transition is complete, we probably cannot add new "weak DTypes" or allow users to create their own. :: npy_bool PyArray_CanCastArrayTo(PyArrayObject *arr, PyArray_Descr *to, NPY_CASTING casting) Returns 1 if the array object may be cast to the given data type using the casting rule, 0 otherwise. This differs from PyArray_CanCastTo in that it handles scalar arrays (0 dimensions) specially, by checking their value. :: npy_bool PyArray_CanCastTypeTo(PyArray_Descr *from, PyArray_Descr *to, NPY_CASTING casting) Returns true if data of type 'from' may be cast to data of type 'to' according to the rule 'casting'. :: PyArrayObject * PyArray_EinsteinSum(char *subscripts, npy_intp nop, PyArrayObject **op_in, PyArray_Descr *dtype, NPY_ORDER order, NPY_CASTING casting, PyArrayObject *out) This function provides summation of array elements according to the Einstein summation convention. For example: - trace(a) -> einsum("ii", a) - transpose(a) -> einsum("ji", a) - multiply(a,b) -> einsum(",", a, b) - inner(a,b) -> einsum("i,i", a, b) - outer(a,b) -> einsum("i,j", a, b) - matvec(a,b) -> einsum("ij,j", a, b) - matmat(a,b) -> einsum("ij,jk", a, b) subscripts: The string of subscripts for einstein summation. nop: The number of operands op_in: The array of operands dtype: Either NULL, or the data type to force the calculation as. order: The order for the calculation/the output axes. casting: What kind of casts should be permitted. out: Either NULL, or an array into which the output should be placed. By default, the labels get placed in alphabetical order at the end of the output. So, if c = einsum("i,j", a, b) then c[i,j] == a[i]*b[j], but if c = einsum("j,i", a, b) then c[i,j] = a[j]*b[i]. Alternatively, you can control the output order or prevent an axis from being summed/force an axis to be summed by providing indices for the output. This allows us to turn 'trace' into 'diag', for example. - diag(a) -> einsum("ii->i", a) - sum(a, axis=0) -> einsum("i...->", a) Subscripts at the beginning and end may be specified by putting an ellipsis "..." in the middle. For example, the function einsum("i...i", a) takes the diagonal of the first and last dimensions of the operand, and einsum("ij...,jk...->ik...") takes the matrix product using the first two indices of each operand instead of the last two. When there is only one operand, no axes being summed, and no output parameter, this function returns a view into the operand instead of making a copy. :: PyObject * PyArray_NewLikeArray(PyArrayObject *prototype, NPY_ORDER order, PyArray_Descr *dtype, int subok) Creates a new array with the same shape as the provided one, with possible memory layout order and data type changes. prototype - The array the new one should be like. order - NPY_CORDER - C-contiguous result. NPY_FORTRANORDER - Fortran-contiguous result. NPY_ANYORDER - Fortran if prototype is Fortran, C otherwise. NPY_KEEPORDER - Keeps the axis ordering of prototype. dtype - If not NULL, overrides the data type of the result. subok - If 1, use the prototype's array subtype, otherwise always create a base-class array. NOTE: If dtype is not NULL, steals the dtype reference. On failure or when dtype->subarray is true, dtype will be decrefed. :: int PyArray_GetArrayParamsFromObject(PyObject *NPY_UNUSED(op) , PyArray_Descr *NPY_UNUSED(requested_dtype) , npy_bool NPY_UNUSED(writeable) , PyArray_Descr **NPY_UNUSED(out_dtype) , int *NPY_UNUSED(out_ndim) , npy_intp *NPY_UNUSED(out_dims) , PyArrayObject **NPY_UNUSED(out_arr) , PyObject *NPY_UNUSED(context) ) :: int PyArray_ConvertClipmodeSequence(PyObject *object, NPY_CLIPMODE *modes, int n) Convert an object to an array of n NPY_CLIPMODE values. This is intended to be used in functions where a different mode could be applied to each axis, like in ravel_multi_index. :: PyObject * PyArray_MatrixProduct2(PyObject *op1, PyObject *op2, PyArrayObject*out) Numeric.matrixproduct2(a,v,out) just like inner product but does the swapaxes stuff on the fly :: npy_bool NpyIter_IsFirstVisit(NpyIter *iter, int iop) Checks to see whether this is the first time the elements of the specified reduction operand which the iterator points at are being seen for the first time. The function returns a reasonable answer for reduction operands and when buffering is disabled. The answer may be incorrect for buffered non-reduction operands. This function is intended to be used in EXTERNAL_LOOP mode only, and will produce some wrong answers when that mode is not enabled. If this function returns true, the caller should also check the inner loop stride of the operand, because if that stride is 0, then only the first element of the innermost external loop is being visited for the first time. WARNING: For performance reasons, 'iop' is not bounds-checked, it is not confirmed that 'iop' is actually a reduction operand, and it is not confirmed that EXTERNAL_LOOP mode is enabled. These checks are the responsibility of the caller, and should be done outside of any inner loops. :: int PyArray_SetBaseObject(PyArrayObject *arr, PyObject *obj) Sets the 'base' attribute of the array. This steals a reference to 'obj'. Returns 0 on success, -1 on failure. :: void PyArray_CreateSortedStridePerm(int ndim, npy_intp const *strides, npy_stride_sort_item *out_strideperm) This function populates the first ndim elements of strideperm with sorted descending by their absolute values. For example, the stride array (4, -2, 12) becomes [(2, 12), (0, 4), (1, -2)]. :: void PyArray_RemoveAxesInPlace(PyArrayObject *arr, const npy_bool *flags) Removes the axes flagged as True from the array, modifying it in place. If an axis flagged for removal has a shape entry bigger than one, this effectively selects index zero for that axis. WARNING: If an axis flagged for removal has a shape equal to zero, the array will point to invalid memory. The caller must validate this! If an axis flagged for removal has a shape larger than one, the aligned flag (and in the future the contiguous flags), may need explicit update. For example, this can be used to remove the reduction axes from a reduction result once its computation is complete. :: void PyArray_DebugPrint(PyArrayObject *obj) Prints the raw data of the ndarray in a form useful for debugging low-level C issues. :: int PyArray_FailUnlessWriteable(PyArrayObject *obj, const char *name) This function does nothing and returns 0 if *obj* is writeable. It raises an exception and returns -1 if *obj* is not writeable. It may also do other house-keeping, such as issuing warnings on arrays which are transitioning to become views. Always call this function at some point before writing to an array. name* is a name for the array, used to give better error messages. It can be something like "assignment destination", "output array", or even just "array". :: int PyArray_SetUpdateIfCopyBase(PyArrayObject *arr, PyArrayObject *base) :: void * PyDataMem_NEW(size_t size) Allocates memory for array data. :: void PyDataMem_FREE(void *ptr) Free memory for array data. :: void * PyDataMem_RENEW(void *ptr, size_t size) Reallocate/resize memory for array data. :: PyDataMem_EventHookFunc * PyDataMem_SetEventHook(PyDataMem_EventHookFunc *newhook, void *user_data, void **old_data) Sets the allocation event hook for numpy array data. Takes a PyDataMem_EventHookFunc *, which has the signature: void hook(void *old, void *new, size_t size, void *user_data). Also takes a void *user_data, and void **old_data. Returns a pointer to the previous hook or NULL. If old_data is non-NULL, the previous user_data pointer will be copied to it. If not NULL, hook will be called at the end of each PyDataMem_NEW/FREE/RENEW: result = PyDataMem_NEW(size) -> (*hook)(NULL, result, size, user_data) PyDataMem_FREE(ptr) -> (*hook)(ptr, NULL, 0, user_data) result = PyDataMem_RENEW(ptr, size) -> (*hook)(ptr, result, size, user_data) When the hook is called, the GIL will be held by the calling thread. The hook should be written to be reentrant, if it performs operations that might cause new allocation events (such as the creation/destruction numpy objects, or creating/destroying Python objects which might cause a gc) Deprecated in 1.23 :: void PyArray_MapIterSwapAxes(PyArrayMapIterObject *mit, PyArrayObject **ret, int getmap) Swap the axes to or from their inserted form. MapIter always puts the advanced (array) indices first in the iteration. But if they are consecutive, will insert/transpose them back before returning. This is stored as `mit->consec != 0` (the place where they are inserted) For assignments, the opposite happens: The values to be assigned are transposed (getmap=1 instead of getmap=0). `getmap=0` and `getmap=1` undo the other operation. :: PyObject * PyArray_MapIterArray(PyArrayObject *a, PyObject *index) Use advanced indexing to iterate an array. :: void PyArray_MapIterNext(PyArrayMapIterObject *mit) This function needs to update the state of the map iterator and point mit->dataptr to the memory-location of the next object Note that this function never handles an extra operand but provides compatibility for an old (exposed) API. :: int PyArray_Partition(PyArrayObject *op, PyArrayObject *ktharray, int axis, NPY_SELECTKIND which) Partition an array in-place :: PyObject * PyArray_ArgPartition(PyArrayObject *op, PyArrayObject *ktharray, int axis, NPY_SELECTKIND which) ArgPartition an array :: int PyArray_SelectkindConverter(PyObject *obj, NPY_SELECTKIND *selectkind) Convert object to select kind :: void * PyDataMem_NEW_ZEROED(size_t nmemb, size_t size) Allocates zeroed memory for array data. :: int PyArray_CheckAnyScalarExact(PyObject *obj) return 1 if an object is exactly a numpy scalar :: PyObject * PyArray_MapIterArrayCopyIfOverlap(PyArrayObject *a, PyObject *index, int copy_if_overlap, PyArrayObject *extra_op) Same as PyArray_MapIterArray, but: If copy_if_overlap != 0, check if `a` has memory overlap with any of the arrays in `index` and with `extra_op`. If yes, make copies as appropriate to avoid problems if `a` is modified during the iteration. `iter->array` may contain a copied array (WRITEBACKIFCOPY set). :: int PyArray_ResolveWritebackIfCopy(PyArrayObject *self) If WRITEBACKIFCOPY and self has data, reset the base WRITEABLE flag, copy the local data to base, release the local data, and set flags appropriately. Return 0 if not relevant, 1 if success, < 0 on failure :: int PyArray_SetWritebackIfCopyBase(PyArrayObject *arr, PyArrayObject *base) Precondition: 'arr' is a copy of 'base' (though possibly with different strides, ordering, etc.). This function sets the WRITEBACKIFCOPY flag and the ->base pointer on 'arr', call PyArray_ResolveWritebackIfCopy to copy any changes back to 'base' before deallocating the array. Steals a reference to 'base'. Returns 0 on success, -1 on failure. :: PyObject * PyDataMem_SetHandler(PyObject *handler) Set a new allocation policy. If the input value is NULL, will reset the policy to the default. Return the previous policy, or return NULL if an error has occurred. We wrap the user-provided functions so they will still call the python and numpy memory management callback hooks. :: PyObject * PyDataMem_GetHandler() Return the policy that will be used to allocate data for the next PyArrayObject. On failure, return NULL.