Spaces:
Build error
Build error
| # NumPy static imports for Cython | |
| # | |
| # If any of the PyArray_* functions are called, import_array must be | |
| # called first. | |
| # | |
| # This also defines backwards-compatibility buffer acquisition | |
| # code for use in Python 2.x (or Python <= 2.5 when NumPy starts | |
| # implementing PEP-3118 directly). | |
| # | |
| # Because of laziness, the format string of the buffer is statically | |
| # allocated. Increase the size if this is not enough, or submit a | |
| # patch to do this properly. | |
| # | |
| # Author: Dag Sverre Seljebotn | |
| # | |
| DEF _buffer_format_string_len = 255 | |
| cimport cpython.buffer as pybuf | |
| from cpython.ref cimport Py_INCREF | |
| from cpython.mem cimport PyObject_Malloc, PyObject_Free | |
| from cpython.object cimport PyObject, PyTypeObject | |
| from cpython.type cimport type | |
| cimport libc.stdio as stdio | |
| cdef extern from "Python.h": | |
| ctypedef int Py_intptr_t | |
| cdef extern from "numpy/arrayobject.h": | |
| ctypedef Py_intptr_t npy_intp | |
| ctypedef size_t npy_uintp | |
| cdef enum NPY_TYPES: | |
| NPY_BOOL | |
| NPY_BYTE | |
| NPY_UBYTE | |
| NPY_SHORT | |
| NPY_USHORT | |
| NPY_INT | |
| NPY_UINT | |
| NPY_LONG | |
| NPY_ULONG | |
| NPY_LONGLONG | |
| NPY_ULONGLONG | |
| NPY_FLOAT | |
| NPY_DOUBLE | |
| NPY_LONGDOUBLE | |
| NPY_CFLOAT | |
| NPY_CDOUBLE | |
| NPY_CLONGDOUBLE | |
| NPY_OBJECT | |
| NPY_STRING | |
| NPY_UNICODE | |
| NPY_VOID | |
| NPY_DATETIME | |
| NPY_TIMEDELTA | |
| NPY_NTYPES | |
| NPY_NOTYPE | |
| NPY_INT8 | |
| NPY_INT16 | |
| NPY_INT32 | |
| NPY_INT64 | |
| NPY_INT128 | |
| NPY_INT256 | |
| NPY_UINT8 | |
| NPY_UINT16 | |
| NPY_UINT32 | |
| NPY_UINT64 | |
| NPY_UINT128 | |
| NPY_UINT256 | |
| NPY_FLOAT16 | |
| NPY_FLOAT32 | |
| NPY_FLOAT64 | |
| NPY_FLOAT80 | |
| NPY_FLOAT96 | |
| NPY_FLOAT128 | |
| NPY_FLOAT256 | |
| NPY_COMPLEX32 | |
| NPY_COMPLEX64 | |
| NPY_COMPLEX128 | |
| NPY_COMPLEX160 | |
| NPY_COMPLEX192 | |
| NPY_COMPLEX256 | |
| NPY_COMPLEX512 | |
| NPY_INTP | |
| ctypedef enum NPY_ORDER: | |
| NPY_ANYORDER | |
| NPY_CORDER | |
| NPY_FORTRANORDER | |
| NPY_KEEPORDER | |
| ctypedef enum NPY_CASTING: | |
| NPY_NO_CASTING | |
| NPY_EQUIV_CASTING | |
| NPY_SAFE_CASTING | |
| NPY_SAME_KIND_CASTING | |
| NPY_UNSAFE_CASTING | |
| ctypedef enum NPY_CLIPMODE: | |
| NPY_CLIP | |
| NPY_WRAP | |
| NPY_RAISE | |
| ctypedef enum NPY_SCALARKIND: | |
| NPY_NOSCALAR, | |
| NPY_BOOL_SCALAR, | |
| NPY_INTPOS_SCALAR, | |
| NPY_INTNEG_SCALAR, | |
| NPY_FLOAT_SCALAR, | |
| NPY_COMPLEX_SCALAR, | |
| NPY_OBJECT_SCALAR | |
| ctypedef enum NPY_SORTKIND: | |
| NPY_QUICKSORT | |
| NPY_HEAPSORT | |
| NPY_MERGESORT | |
| ctypedef enum NPY_SEARCHSIDE: | |
| NPY_SEARCHLEFT | |
| NPY_SEARCHRIGHT | |
| enum: | |
| # DEPRECATED since NumPy 1.7 ! Do not use in new code! | |
| NPY_C_CONTIGUOUS | |
| NPY_F_CONTIGUOUS | |
| NPY_CONTIGUOUS | |
| NPY_FORTRAN | |
| NPY_OWNDATA | |
| NPY_FORCECAST | |
| NPY_ENSURECOPY | |
| NPY_ENSUREARRAY | |
| NPY_ELEMENTSTRIDES | |
| NPY_ALIGNED | |
| NPY_NOTSWAPPED | |
| NPY_WRITEABLE | |
| NPY_UPDATEIFCOPY | |
| NPY_ARR_HAS_DESCR | |
| NPY_BEHAVED | |
| NPY_BEHAVED_NS | |
| NPY_CARRAY | |
| NPY_CARRAY_RO | |
| NPY_FARRAY | |
| NPY_FARRAY_RO | |
| NPY_DEFAULT | |
| NPY_IN_ARRAY | |
| NPY_OUT_ARRAY | |
| NPY_INOUT_ARRAY | |
| NPY_IN_FARRAY | |
| NPY_OUT_FARRAY | |
| NPY_INOUT_FARRAY | |
| NPY_UPDATE_ALL | |
| enum: | |
| # Added in NumPy 1.7 to replace the deprecated enums above. | |
| NPY_ARRAY_C_CONTIGUOUS | |
| NPY_ARRAY_F_CONTIGUOUS | |
| NPY_ARRAY_OWNDATA | |
| NPY_ARRAY_FORCECAST | |
| NPY_ARRAY_ENSURECOPY | |
| NPY_ARRAY_ENSUREARRAY | |
| NPY_ARRAY_ELEMENTSTRIDES | |
| NPY_ARRAY_ALIGNED | |
| NPY_ARRAY_NOTSWAPPED | |
| NPY_ARRAY_WRITEABLE | |
| NPY_ARRAY_UPDATEIFCOPY | |
| NPY_ARRAY_BEHAVED | |
| NPY_ARRAY_BEHAVED_NS | |
| NPY_ARRAY_CARRAY | |
| NPY_ARRAY_CARRAY_RO | |
| NPY_ARRAY_FARRAY | |
| NPY_ARRAY_FARRAY_RO | |
| NPY_ARRAY_DEFAULT | |
| NPY_ARRAY_IN_ARRAY | |
| NPY_ARRAY_OUT_ARRAY | |
| NPY_ARRAY_INOUT_ARRAY | |
| NPY_ARRAY_IN_FARRAY | |
| NPY_ARRAY_OUT_FARRAY | |
| NPY_ARRAY_INOUT_FARRAY | |
| NPY_ARRAY_UPDATE_ALL | |
| cdef enum: | |
| NPY_MAXDIMS | |
| npy_intp NPY_MAX_ELSIZE | |
| ctypedef void (*PyArray_VectorUnaryFunc)(void *, void *, npy_intp, void *, void *) | |
| ctypedef struct PyArray_ArrayDescr: | |
| # shape is a tuple, but Cython doesn't support "tuple shape" | |
| # inside a non-PyObject declaration, so we have to declare it | |
| # as just a PyObject*. | |
| PyObject* shape | |
| ctypedef struct PyArray_Descr: | |
| pass | |
| ctypedef class numpy.dtype [object PyArray_Descr, check_size ignore]: | |
| # Use PyDataType_* macros when possible, however there are no macros | |
| # for accessing some of the fields, so some are defined. | |
| cdef PyTypeObject* typeobj | |
| cdef char kind | |
| cdef char type | |
| # Numpy sometimes mutates this without warning (e.g. it'll | |
| # sometimes change "|" to "<" in shared dtype objects on | |
| # little-endian machines). If this matters to you, use | |
| # PyArray_IsNativeByteOrder(dtype.byteorder) instead of | |
| # directly accessing this field. | |
| cdef char byteorder | |
| cdef char flags | |
| cdef int type_num | |
| cdef int itemsize "elsize" | |
| cdef int alignment | |
| cdef dict fields | |
| cdef tuple names | |
| # Use PyDataType_HASSUBARRAY to test whether this field is | |
| # valid (the pointer can be NULL). Most users should access | |
| # this field via the inline helper method PyDataType_SHAPE. | |
| cdef PyArray_ArrayDescr* subarray | |
| ctypedef class numpy.flatiter [object PyArrayIterObject, check_size ignore]: | |
| # Use through macros | |
| pass | |
| ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]: | |
| # Use through macros | |
| pass | |
| ctypedef struct PyArrayObject: | |
| # For use in situations where ndarray can't replace PyArrayObject*, | |
| # like PyArrayObject**. | |
| pass | |
| ctypedef class numpy.ndarray [object PyArrayObject, check_size ignore]: | |
| cdef __cythonbufferdefaults__ = {"mode": "strided"} | |
| cdef: | |
| # Only taking a few of the most commonly used and stable fields. | |
| # One should use PyArray_* macros instead to access the C fields. | |
| char *data | |
| int ndim "nd" | |
| npy_intp *shape "dimensions" | |
| npy_intp *strides | |
| dtype descr # deprecated since NumPy 1.7 ! | |
| PyObject* base | |
| # Note: This syntax (function definition in pxd files) is an | |
| # experimental exception made for __getbuffer__ and __releasebuffer__ | |
| # -- the details of this may change. | |
| def __getbuffer__(ndarray self, Py_buffer* info, int flags): | |
| # This implementation of getbuffer is geared towards Cython | |
| # requirements, and does not yet fulfill the PEP. | |
| # In particular strided access is always provided regardless | |
| # of flags | |
| cdef int i, ndim | |
| cdef int endian_detector = 1 | |
| cdef bint little_endian = ((<char*>&endian_detector)[0] != 0) | |
| ndim = PyArray_NDIM(self) | |
| if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) | |
| and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): | |
| raise ValueError(u"ndarray is not C contiguous") | |
| if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) | |
| and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): | |
| raise ValueError(u"ndarray is not Fortran contiguous") | |
| info.buf = PyArray_DATA(self) | |
| info.ndim = ndim | |
| if sizeof(npy_intp) != sizeof(Py_ssize_t): | |
| # Allocate new buffer for strides and shape info. | |
| # This is allocated as one block, strides first. | |
| info.strides = <Py_ssize_t*>PyObject_Malloc(sizeof(Py_ssize_t) * 2 * <size_t>ndim) | |
| info.shape = info.strides + ndim | |
| for i in range(ndim): | |
| info.strides[i] = PyArray_STRIDES(self)[i] | |
| info.shape[i] = PyArray_DIMS(self)[i] | |
| else: | |
| info.strides = <Py_ssize_t*>PyArray_STRIDES(self) | |
| info.shape = <Py_ssize_t*>PyArray_DIMS(self) | |
| info.suboffsets = NULL | |
| info.itemsize = PyArray_ITEMSIZE(self) | |
| info.readonly = not PyArray_ISWRITEABLE(self) | |
| cdef int t | |
| cdef char* f = NULL | |
| cdef dtype descr = <dtype>PyArray_DESCR(self) | |
| cdef int offset | |
| info.obj = self | |
| if not PyDataType_HASFIELDS(descr): | |
| t = descr.type_num | |
| if ((descr.byteorder == c'>' and little_endian) or | |
| (descr.byteorder == c'<' and not little_endian)): | |
| raise ValueError(u"Non-native byte order not supported") | |
| if t == NPY_BYTE: f = "b" | |
| elif t == NPY_UBYTE: f = "B" | |
| elif t == NPY_SHORT: f = "h" | |
| elif t == NPY_USHORT: f = "H" | |
| elif t == NPY_INT: f = "i" | |
| elif t == NPY_UINT: f = "I" | |
| elif t == NPY_LONG: f = "l" | |
| elif t == NPY_ULONG: f = "L" | |
| elif t == NPY_LONGLONG: f = "q" | |
| elif t == NPY_ULONGLONG: f = "Q" | |
| elif t == NPY_FLOAT: f = "f" | |
| elif t == NPY_DOUBLE: f = "d" | |
| elif t == NPY_LONGDOUBLE: f = "g" | |
| elif t == NPY_CFLOAT: f = "Zf" | |
| elif t == NPY_CDOUBLE: f = "Zd" | |
| elif t == NPY_CLONGDOUBLE: f = "Zg" | |
| elif t == NPY_OBJECT: f = "O" | |
| else: | |
| raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) | |
| info.format = f | |
| return | |
| else: | |
| info.format = <char*>PyObject_Malloc(_buffer_format_string_len) | |
| info.format[0] = c'^' # Native data types, manual alignment | |
| offset = 0 | |
| f = _util_dtypestring(descr, info.format + 1, | |
| info.format + _buffer_format_string_len, | |
| &offset) | |
| f[0] = c'\0' # Terminate format string | |
| def __releasebuffer__(ndarray self, Py_buffer* info): | |
| if PyArray_HASFIELDS(self): | |
| PyObject_Free(info.format) | |
| if sizeof(npy_intp) != sizeof(Py_ssize_t): | |
| PyObject_Free(info.strides) | |
| # info.shape was stored after info.strides in the same block | |
| ctypedef unsigned char npy_bool | |
| ctypedef signed char npy_byte | |
| ctypedef signed short npy_short | |
| ctypedef signed int npy_int | |
| ctypedef signed long npy_long | |
| ctypedef signed long long npy_longlong | |
| ctypedef unsigned char npy_ubyte | |
| ctypedef unsigned short npy_ushort | |
| ctypedef unsigned int npy_uint | |
| ctypedef unsigned long npy_ulong | |
| ctypedef unsigned long long npy_ulonglong | |
| ctypedef float npy_float | |
| ctypedef double npy_double | |
| ctypedef long double npy_longdouble | |
| ctypedef signed char npy_int8 | |
| ctypedef signed short npy_int16 | |
| ctypedef signed int npy_int32 | |
| ctypedef signed long long npy_int64 | |
| ctypedef signed long long npy_int96 | |
| ctypedef signed long long npy_int128 | |
| ctypedef unsigned char npy_uint8 | |
| ctypedef unsigned short npy_uint16 | |
| ctypedef unsigned int npy_uint32 | |
| ctypedef unsigned long long npy_uint64 | |
| ctypedef unsigned long long npy_uint96 | |
| ctypedef unsigned long long npy_uint128 | |
| ctypedef float npy_float32 | |
| ctypedef double npy_float64 | |
| ctypedef long double npy_float80 | |
| ctypedef long double npy_float96 | |
| ctypedef long double npy_float128 | |
| ctypedef struct npy_cfloat: | |
| double real | |
| double imag | |
| ctypedef struct npy_cdouble: | |
| double real | |
| double imag | |
| ctypedef struct npy_clongdouble: | |
| long double real | |
| long double imag | |
| ctypedef struct npy_complex64: | |
| float real | |
| float imag | |
| ctypedef struct npy_complex128: | |
| double real | |
| double imag | |
| ctypedef struct npy_complex160: | |
| long double real | |
| long double imag | |
| ctypedef struct npy_complex192: | |
| long double real | |
| long double imag | |
| ctypedef struct npy_complex256: | |
| long double real | |
| long double imag | |
| ctypedef struct PyArray_Dims: | |
| npy_intp *ptr | |
| int len | |
| int _import_array() except -1 | |
| # | |
| # Macros from ndarrayobject.h | |
| # | |
| bint PyArray_CHKFLAGS(ndarray m, int flags) | |
| bint PyArray_IS_C_CONTIGUOUS(ndarray arr) | |
| bint PyArray_IS_F_CONTIGUOUS(ndarray arr) | |
| bint PyArray_ISCONTIGUOUS(ndarray m) | |
| bint PyArray_ISWRITEABLE(ndarray m) | |
| bint PyArray_ISALIGNED(ndarray m) | |
| int PyArray_NDIM(ndarray) | |
| bint PyArray_ISONESEGMENT(ndarray) | |
| bint PyArray_ISFORTRAN(ndarray) | |
| int PyArray_FORTRANIF(ndarray) | |
| void* PyArray_DATA(ndarray) | |
| char* PyArray_BYTES(ndarray) | |
| npy_intp* PyArray_DIMS(ndarray) | |
| npy_intp* PyArray_STRIDES(ndarray) | |
| npy_intp PyArray_DIM(ndarray, size_t) | |
| npy_intp PyArray_STRIDE(ndarray, size_t) | |
| PyObject *PyArray_BASE(ndarray) # returns borrowed reference! | |
| PyArray_Descr *PyArray_DESCR(ndarray) # returns borrowed reference to dtype! | |
| int PyArray_FLAGS(ndarray) | |
| npy_intp PyArray_ITEMSIZE(ndarray) | |
| int PyArray_TYPE(ndarray arr) | |
| object PyArray_GETITEM(ndarray arr, void *itemptr) | |
| int PyArray_SETITEM(ndarray arr, void *itemptr, object obj) | |
| bint PyTypeNum_ISBOOL(int) | |
| bint PyTypeNum_ISUNSIGNED(int) | |
| bint PyTypeNum_ISSIGNED(int) | |
| bint PyTypeNum_ISINTEGER(int) | |
| bint PyTypeNum_ISFLOAT(int) | |
| bint PyTypeNum_ISNUMBER(int) | |
| bint PyTypeNum_ISSTRING(int) | |
| bint PyTypeNum_ISCOMPLEX(int) | |
| bint PyTypeNum_ISPYTHON(int) | |
| bint PyTypeNum_ISFLEXIBLE(int) | |
| bint PyTypeNum_ISUSERDEF(int) | |
| bint PyTypeNum_ISEXTENDED(int) | |
| bint PyTypeNum_ISOBJECT(int) | |
| bint PyDataType_ISBOOL(dtype) | |
| bint PyDataType_ISUNSIGNED(dtype) | |
| bint PyDataType_ISSIGNED(dtype) | |
| bint PyDataType_ISINTEGER(dtype) | |
| bint PyDataType_ISFLOAT(dtype) | |
| bint PyDataType_ISNUMBER(dtype) | |
| bint PyDataType_ISSTRING(dtype) | |
| bint PyDataType_ISCOMPLEX(dtype) | |
| bint PyDataType_ISPYTHON(dtype) | |
| bint PyDataType_ISFLEXIBLE(dtype) | |
| bint PyDataType_ISUSERDEF(dtype) | |
| bint PyDataType_ISEXTENDED(dtype) | |
| bint PyDataType_ISOBJECT(dtype) | |
| bint PyDataType_HASFIELDS(dtype) | |
| bint PyDataType_HASSUBARRAY(dtype) | |
| bint PyArray_ISBOOL(ndarray) | |
| bint PyArray_ISUNSIGNED(ndarray) | |
| bint PyArray_ISSIGNED(ndarray) | |
| bint PyArray_ISINTEGER(ndarray) | |
| bint PyArray_ISFLOAT(ndarray) | |
| bint PyArray_ISNUMBER(ndarray) | |
| bint PyArray_ISSTRING(ndarray) | |
| bint PyArray_ISCOMPLEX(ndarray) | |
| bint PyArray_ISPYTHON(ndarray) | |
| bint PyArray_ISFLEXIBLE(ndarray) | |
| bint PyArray_ISUSERDEF(ndarray) | |
| bint PyArray_ISEXTENDED(ndarray) | |
| bint PyArray_ISOBJECT(ndarray) | |
| bint PyArray_HASFIELDS(ndarray) | |
| bint PyArray_ISVARIABLE(ndarray) | |
| bint PyArray_SAFEALIGNEDCOPY(ndarray) | |
| bint PyArray_ISNBO(char) # works on ndarray.byteorder | |
| bint PyArray_IsNativeByteOrder(char) # works on ndarray.byteorder | |
| bint PyArray_ISNOTSWAPPED(ndarray) | |
| bint PyArray_ISBYTESWAPPED(ndarray) | |
| bint PyArray_FLAGSWAP(ndarray, int) | |
| bint PyArray_ISCARRAY(ndarray) | |
| bint PyArray_ISCARRAY_RO(ndarray) | |
| bint PyArray_ISFARRAY(ndarray) | |
| bint PyArray_ISFARRAY_RO(ndarray) | |
| bint PyArray_ISBEHAVED(ndarray) | |
| bint PyArray_ISBEHAVED_RO(ndarray) | |
| bint PyDataType_ISNOTSWAPPED(dtype) | |
| bint PyDataType_ISBYTESWAPPED(dtype) | |
| bint PyArray_DescrCheck(object) | |
| bint PyArray_Check(object) | |
| bint PyArray_CheckExact(object) | |
| # Cannot be supported due to out arg: | |
| # bint PyArray_HasArrayInterfaceType(object, dtype, object, object&) | |
| # bint PyArray_HasArrayInterface(op, out) | |
| bint PyArray_IsZeroDim(object) | |
| # Cannot be supported due to ## ## in macro: | |
| # bint PyArray_IsScalar(object, verbatim work) | |
| bint PyArray_CheckScalar(object) | |
| bint PyArray_IsPythonNumber(object) | |
| bint PyArray_IsPythonScalar(object) | |
| bint PyArray_IsAnyScalar(object) | |
| bint PyArray_CheckAnyScalar(object) | |
| ndarray PyArray_GETCONTIGUOUS(ndarray) | |
| bint PyArray_SAMESHAPE(ndarray, ndarray) | |
| npy_intp PyArray_SIZE(ndarray) | |
| npy_intp PyArray_NBYTES(ndarray) | |
| object PyArray_FROM_O(object) | |
| object PyArray_FROM_OF(object m, int flags) | |
| object PyArray_FROM_OT(object m, int type) | |
| object PyArray_FROM_OTF(object m, int type, int flags) | |
| object PyArray_FROMANY(object m, int type, int min, int max, int flags) | |
| object PyArray_ZEROS(int nd, npy_intp* dims, int type, int fortran) | |
| object PyArray_EMPTY(int nd, npy_intp* dims, int type, int fortran) | |
| void PyArray_FILLWBYTE(object, int val) | |
| npy_intp PyArray_REFCOUNT(object) | |
| object PyArray_ContiguousFromAny(op, int, int min_depth, int max_depth) | |
| unsigned char PyArray_EquivArrTypes(ndarray a1, ndarray a2) | |
| bint PyArray_EquivByteorders(int b1, int b2) | |
| object PyArray_SimpleNew(int nd, npy_intp* dims, int typenum) | |
| object PyArray_SimpleNewFromData(int nd, npy_intp* dims, int typenum, void* data) | |
| #object PyArray_SimpleNewFromDescr(int nd, npy_intp* dims, dtype descr) | |
| object PyArray_ToScalar(void* data, ndarray arr) | |
| void* PyArray_GETPTR1(ndarray m, npy_intp i) | |
| void* PyArray_GETPTR2(ndarray m, npy_intp i, npy_intp j) | |
| void* PyArray_GETPTR3(ndarray m, npy_intp i, npy_intp j, npy_intp k) | |
| void* PyArray_GETPTR4(ndarray m, npy_intp i, npy_intp j, npy_intp k, npy_intp l) | |
| void PyArray_XDECREF_ERR(ndarray) | |
| # Cannot be supported due to out arg | |
| # void PyArray_DESCR_REPLACE(descr) | |
| object PyArray_Copy(ndarray) | |
| object PyArray_FromObject(object op, int type, int min_depth, int max_depth) | |
| object PyArray_ContiguousFromObject(object op, int type, int min_depth, int max_depth) | |
| object PyArray_CopyFromObject(object op, int type, int min_depth, int max_depth) | |
| object PyArray_Cast(ndarray mp, int type_num) | |
| object PyArray_Take(ndarray ap, object items, int axis) | |
| object PyArray_Put(ndarray ap, object items, object values) | |
| void PyArray_ITER_RESET(flatiter it) nogil | |
| void PyArray_ITER_NEXT(flatiter it) nogil | |
| void PyArray_ITER_GOTO(flatiter it, npy_intp* destination) nogil | |
| void PyArray_ITER_GOTO1D(flatiter it, npy_intp ind) nogil | |
| void* PyArray_ITER_DATA(flatiter it) nogil | |
| bint PyArray_ITER_NOTDONE(flatiter it) nogil | |
| void PyArray_MultiIter_RESET(broadcast multi) nogil | |
| void PyArray_MultiIter_NEXT(broadcast multi) nogil | |
| void PyArray_MultiIter_GOTO(broadcast multi, npy_intp dest) nogil | |
| void PyArray_MultiIter_GOTO1D(broadcast multi, npy_intp ind) nogil | |
| void* PyArray_MultiIter_DATA(broadcast multi, npy_intp i) nogil | |
| void PyArray_MultiIter_NEXTi(broadcast multi, npy_intp i) nogil | |
| bint PyArray_MultiIter_NOTDONE(broadcast multi) nogil | |
| # Functions from __multiarray_api.h | |
| # Functions taking dtype and returning object/ndarray are disabled | |
| # for now as they steal dtype references. I'm conservative and disable | |
| # more than is probably needed until it can be checked further. | |
| int PyArray_SetNumericOps (object) | |
| object PyArray_GetNumericOps () | |
| int PyArray_INCREF (ndarray) | |
| int PyArray_XDECREF (ndarray) | |
| void PyArray_SetStringFunction (object, int) | |
| dtype PyArray_DescrFromType (int) | |
| object PyArray_TypeObjectFromType (int) | |
| char * PyArray_Zero (ndarray) | |
| char * PyArray_One (ndarray) | |
| #object PyArray_CastToType (ndarray, dtype, int) | |
| int PyArray_CastTo (ndarray, ndarray) | |
| int PyArray_CastAnyTo (ndarray, ndarray) | |
| int PyArray_CanCastSafely (int, int) | |
| npy_bool PyArray_CanCastTo (dtype, dtype) | |
| int PyArray_ObjectType (object, int) | |
| dtype PyArray_DescrFromObject (object, dtype) | |
| #ndarray* PyArray_ConvertToCommonType (object, int *) | |
| dtype PyArray_DescrFromScalar (object) | |
| dtype PyArray_DescrFromTypeObject (object) | |
| npy_intp PyArray_Size (object) | |
| #object PyArray_Scalar (void *, dtype, object) | |
| #object PyArray_FromScalar (object, dtype) | |
| void PyArray_ScalarAsCtype (object, void *) | |
| #int PyArray_CastScalarToCtype (object, void *, dtype) | |
| #int PyArray_CastScalarDirect (object, dtype, void *, int) | |
| object PyArray_ScalarFromObject (object) | |
| #PyArray_VectorUnaryFunc * PyArray_GetCastFunc (dtype, int) | |
| object PyArray_FromDims (int, int *, int) | |
| #object PyArray_FromDimsAndDataAndDescr (int, int *, dtype, char *) | |
| #object PyArray_FromAny (object, dtype, int, int, int, object) | |
| object PyArray_EnsureArray (object) | |
| object PyArray_EnsureAnyArray (object) | |
| #object PyArray_FromFile (stdio.FILE *, dtype, npy_intp, char *) | |
| #object PyArray_FromString (char *, npy_intp, dtype, npy_intp, char *) | |
| #object PyArray_FromBuffer (object, dtype, npy_intp, npy_intp) | |
| #object PyArray_FromIter (object, dtype, npy_intp) | |
| object PyArray_Return (ndarray) | |
| #object PyArray_GetField (ndarray, dtype, int) | |
| #int PyArray_SetField (ndarray, dtype, int, object) | |
| object PyArray_Byteswap (ndarray, npy_bool) | |
| object PyArray_Resize (ndarray, PyArray_Dims *, int, NPY_ORDER) | |
| int PyArray_MoveInto (ndarray, ndarray) | |
| int PyArray_CopyInto (ndarray, ndarray) | |
| int PyArray_CopyAnyInto (ndarray, ndarray) | |
| int PyArray_CopyObject (ndarray, object) | |
| object PyArray_NewCopy (ndarray, NPY_ORDER) | |
| object PyArray_ToList (ndarray) | |
| object PyArray_ToString (ndarray, NPY_ORDER) | |
| int PyArray_ToFile (ndarray, stdio.FILE *, char *, char *) | |
| int PyArray_Dump (object, object, int) | |
| object PyArray_Dumps (object, int) | |
| int PyArray_ValidType (int) | |
| void PyArray_UpdateFlags (ndarray, int) | |
| object PyArray_New (type, int, npy_intp *, int, npy_intp *, void *, int, int, object) | |
| #object PyArray_NewFromDescr (type, dtype, int, npy_intp *, npy_intp *, void *, int, object) | |
| #dtype PyArray_DescrNew (dtype) | |
| dtype PyArray_DescrNewFromType (int) | |
| double PyArray_GetPriority (object, double) | |
| object PyArray_IterNew (object) | |
| object PyArray_MultiIterNew (int, ...) | |
| int PyArray_PyIntAsInt (object) | |
| npy_intp PyArray_PyIntAsIntp (object) | |
| int PyArray_Broadcast (broadcast) | |
| void PyArray_FillObjectArray (ndarray, object) | |
| int PyArray_FillWithScalar (ndarray, object) | |
| npy_bool PyArray_CheckStrides (int, int, npy_intp, npy_intp, npy_intp *, npy_intp *) | |
| dtype PyArray_DescrNewByteorder (dtype, char) | |
| object PyArray_IterAllButAxis (object, int *) | |
| #object PyArray_CheckFromAny (object, dtype, int, int, int, object) | |
| #object PyArray_FromArray (ndarray, dtype, int) | |
| object PyArray_FromInterface (object) | |
| object PyArray_FromStructInterface (object) | |
| #object PyArray_FromArrayAttr (object, dtype, object) | |
| #NPY_SCALARKIND PyArray_ScalarKind (int, ndarray*) | |
| int PyArray_CanCoerceScalar (int, int, NPY_SCALARKIND) | |
| object PyArray_NewFlagsObject (object) | |
| npy_bool PyArray_CanCastScalar (type, type) | |
| #int PyArray_CompareUCS4 (npy_ucs4 *, npy_ucs4 *, register size_t) | |
| int PyArray_RemoveSmallest (broadcast) | |
| int PyArray_ElementStrides (object) | |
| void PyArray_Item_INCREF (char *, dtype) | |
| void PyArray_Item_XDECREF (char *, dtype) | |
| object PyArray_FieldNames (object) | |
| object PyArray_Transpose (ndarray, PyArray_Dims *) | |
| object PyArray_TakeFrom (ndarray, object, int, ndarray, NPY_CLIPMODE) | |
| object PyArray_PutTo (ndarray, object, object, NPY_CLIPMODE) | |
| object PyArray_PutMask (ndarray, object, object) | |
| object PyArray_Repeat (ndarray, object, int) | |
| object PyArray_Choose (ndarray, object, ndarray, NPY_CLIPMODE) | |
| int PyArray_Sort (ndarray, int, NPY_SORTKIND) | |
| object PyArray_ArgSort (ndarray, int, NPY_SORTKIND) | |
| object PyArray_SearchSorted (ndarray, object, NPY_SEARCHSIDE, PyObject*) | |
| object PyArray_ArgMax (ndarray, int, ndarray) | |
| object PyArray_ArgMin (ndarray, int, ndarray) | |
| object PyArray_Reshape (ndarray, object) | |
| object PyArray_Newshape (ndarray, PyArray_Dims *, NPY_ORDER) | |
| object PyArray_Squeeze (ndarray) | |
| #object PyArray_View (ndarray, dtype, type) | |
| object PyArray_SwapAxes (ndarray, int, int) | |
| object PyArray_Max (ndarray, int, ndarray) | |
| object PyArray_Min (ndarray, int, ndarray) | |
| object PyArray_Ptp (ndarray, int, ndarray) | |
| object PyArray_Mean (ndarray, int, int, ndarray) | |
| object PyArray_Trace (ndarray, int, int, int, int, ndarray) | |
| object PyArray_Diagonal (ndarray, int, int, int) | |
| object PyArray_Clip (ndarray, object, object, ndarray) | |
| object PyArray_Conjugate (ndarray, ndarray) | |
| object PyArray_Nonzero (ndarray) | |
| object PyArray_Std (ndarray, int, int, ndarray, int) | |
| object PyArray_Sum (ndarray, int, int, ndarray) | |
| object PyArray_CumSum (ndarray, int, int, ndarray) | |
| object PyArray_Prod (ndarray, int, int, ndarray) | |
| object PyArray_CumProd (ndarray, int, int, ndarray) | |
| object PyArray_All (ndarray, int, ndarray) | |
| object PyArray_Any (ndarray, int, ndarray) | |
| object PyArray_Compress (ndarray, object, int, ndarray) | |
| object PyArray_Flatten (ndarray, NPY_ORDER) | |
| object PyArray_Ravel (ndarray, NPY_ORDER) | |
| npy_intp PyArray_MultiplyList (npy_intp *, int) | |
| int PyArray_MultiplyIntList (int *, int) | |
| void * PyArray_GetPtr (ndarray, npy_intp*) | |
| int PyArray_CompareLists (npy_intp *, npy_intp *, int) | |
| #int PyArray_AsCArray (object*, void *, npy_intp *, int, dtype) | |
| #int PyArray_As1D (object*, char **, int *, int) | |
| #int PyArray_As2D (object*, char ***, int *, int *, int) | |
| int PyArray_Free (object, void *) | |
| #int PyArray_Converter (object, object*) | |
| int PyArray_IntpFromSequence (object, npy_intp *, int) | |
| object PyArray_Concatenate (object, int) | |
| object PyArray_InnerProduct (object, object) | |
| object PyArray_MatrixProduct (object, object) | |
| object PyArray_CopyAndTranspose (object) | |
| object PyArray_Correlate (object, object, int) | |
| int PyArray_TypestrConvert (int, int) | |
| #int PyArray_DescrConverter (object, dtype*) | |
| #int PyArray_DescrConverter2 (object, dtype*) | |
| int PyArray_IntpConverter (object, PyArray_Dims *) | |
| #int PyArray_BufferConverter (object, chunk) | |
| int PyArray_AxisConverter (object, int *) | |
| int PyArray_BoolConverter (object, npy_bool *) | |
| int PyArray_ByteorderConverter (object, char *) | |
| int PyArray_OrderConverter (object, NPY_ORDER *) | |
| unsigned char PyArray_EquivTypes (dtype, dtype) | |
| #object PyArray_Zeros (int, npy_intp *, dtype, int) | |
| #object PyArray_Empty (int, npy_intp *, dtype, int) | |
| object PyArray_Where (object, object, object) | |
| object PyArray_Arange (double, double, double, int) | |
| #object PyArray_ArangeObj (object, object, object, dtype) | |
| int PyArray_SortkindConverter (object, NPY_SORTKIND *) | |
| object PyArray_LexSort (object, int) | |
| object PyArray_Round (ndarray, int, ndarray) | |
| unsigned char PyArray_EquivTypenums (int, int) | |
| int PyArray_RegisterDataType (dtype) | |
| int PyArray_RegisterCastFunc (dtype, int, PyArray_VectorUnaryFunc *) | |
| int PyArray_RegisterCanCast (dtype, int, NPY_SCALARKIND) | |
| #void PyArray_InitArrFuncs (PyArray_ArrFuncs *) | |
| object PyArray_IntTupleFromIntp (int, npy_intp *) | |
| int PyArray_TypeNumFromName (char *) | |
| int PyArray_ClipmodeConverter (object, NPY_CLIPMODE *) | |
| #int PyArray_OutputConverter (object, ndarray*) | |
| object PyArray_BroadcastToShape (object, npy_intp *, int) | |
| void _PyArray_SigintHandler (int) | |
| void* _PyArray_GetSigintBuf () | |
| #int PyArray_DescrAlignConverter (object, dtype*) | |
| #int PyArray_DescrAlignConverter2 (object, dtype*) | |
| int PyArray_SearchsideConverter (object, void *) | |
| object PyArray_CheckAxis (ndarray, int *, int) | |
| npy_intp PyArray_OverflowMultiplyList (npy_intp *, int) | |
| int PyArray_CompareString (char *, char *, size_t) | |
| int PyArray_SetBaseObject(ndarray, base) # NOTE: steals a reference to base! Use "set_array_base()" instead. | |
| # Typedefs that matches the runtime dtype objects in | |
| # the numpy module. | |
| # The ones that are commented out needs an IFDEF function | |
| # in Cython to enable them only on the right systems. | |
| ctypedef npy_int8 int8_t | |
| ctypedef npy_int16 int16_t | |
| ctypedef npy_int32 int32_t | |
| ctypedef npy_int64 int64_t | |
| #ctypedef npy_int96 int96_t | |
| #ctypedef npy_int128 int128_t | |
| ctypedef npy_uint8 uint8_t | |
| ctypedef npy_uint16 uint16_t | |
| ctypedef npy_uint32 uint32_t | |
| ctypedef npy_uint64 uint64_t | |
| #ctypedef npy_uint96 uint96_t | |
| #ctypedef npy_uint128 uint128_t | |
| ctypedef npy_float32 float32_t | |
| ctypedef npy_float64 float64_t | |
| #ctypedef npy_float80 float80_t | |
| #ctypedef npy_float128 float128_t | |
| ctypedef float complex complex64_t | |
| ctypedef double complex complex128_t | |
| # The int types are mapped a bit surprising -- | |
| # numpy.int corresponds to 'l' and numpy.long to 'q' | |
| ctypedef npy_long int_t | |
| ctypedef npy_longlong long_t | |
| ctypedef npy_longlong longlong_t | |
| ctypedef npy_ulong uint_t | |
| ctypedef npy_ulonglong ulong_t | |
| ctypedef npy_ulonglong ulonglong_t | |
| ctypedef npy_intp intp_t | |
| ctypedef npy_uintp uintp_t | |
| ctypedef npy_double float_t | |
| ctypedef npy_double double_t | |
| ctypedef npy_longdouble longdouble_t | |
| ctypedef npy_cfloat cfloat_t | |
| ctypedef npy_cdouble cdouble_t | |
| ctypedef npy_clongdouble clongdouble_t | |
| ctypedef npy_cdouble complex_t | |
| cdef inline object PyArray_MultiIterNew1(a): | |
| return PyArray_MultiIterNew(1, <void*>a) | |
| cdef inline object PyArray_MultiIterNew2(a, b): | |
| return PyArray_MultiIterNew(2, <void*>a, <void*>b) | |
| cdef inline object PyArray_MultiIterNew3(a, b, c): | |
| return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c) | |
| cdef inline object PyArray_MultiIterNew4(a, b, c, d): | |
| return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d) | |
| cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): | |
| return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e) | |
| cdef inline tuple PyDataType_SHAPE(dtype d): | |
| if PyDataType_HASSUBARRAY(d): | |
| return <tuple>d.subarray.shape | |
| else: | |
| return () | |
| cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: | |
| # Recursive utility function used in __getbuffer__ to get format | |
| # string. The new location in the format string is returned. | |
| cdef dtype child | |
| cdef int endian_detector = 1 | |
| cdef bint little_endian = ((<char*>&endian_detector)[0] != 0) | |
| cdef tuple fields | |
| for childname in descr.names: | |
| fields = descr.fields[childname] | |
| child, new_offset = fields | |
| if (end - f) - <int>(new_offset - offset[0]) < 15: | |
| raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") | |
| if ((child.byteorder == c'>' and little_endian) or | |
| (child.byteorder == c'<' and not little_endian)): | |
| raise ValueError(u"Non-native byte order not supported") | |
| # One could encode it in the format string and have Cython | |
| # complain instead, BUT: < and > in format strings also imply | |
| # standardized sizes for datatypes, and we rely on native in | |
| # order to avoid reencoding data types based on their size. | |
| # | |
| # A proper PEP 3118 exporter for other clients than Cython | |
| # must deal properly with this! | |
| # Output padding bytes | |
| while offset[0] < new_offset: | |
| f[0] = 120 # "x"; pad byte | |
| f += 1 | |
| offset[0] += 1 | |
| offset[0] += child.itemsize | |
| if not PyDataType_HASFIELDS(child): | |
| t = child.type_num | |
| if end - f < 5: | |
| raise RuntimeError(u"Format string allocated too short.") | |
| # Until ticket #99 is fixed, use integers to avoid warnings | |
| if t == NPY_BYTE: f[0] = 98 #"b" | |
| elif t == NPY_UBYTE: f[0] = 66 #"B" | |
| elif t == NPY_SHORT: f[0] = 104 #"h" | |
| elif t == NPY_USHORT: f[0] = 72 #"H" | |
| elif t == NPY_INT: f[0] = 105 #"i" | |
| elif t == NPY_UINT: f[0] = 73 #"I" | |
| elif t == NPY_LONG: f[0] = 108 #"l" | |
| elif t == NPY_ULONG: f[0] = 76 #"L" | |
| elif t == NPY_LONGLONG: f[0] = 113 #"q" | |
| elif t == NPY_ULONGLONG: f[0] = 81 #"Q" | |
| elif t == NPY_FLOAT: f[0] = 102 #"f" | |
| elif t == NPY_DOUBLE: f[0] = 100 #"d" | |
| elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" | |
| elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf | |
| elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd | |
| elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg | |
| elif t == NPY_OBJECT: f[0] = 79 #"O" | |
| else: | |
| raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) | |
| f += 1 | |
| else: | |
| # Cython ignores struct boundary information ("T{...}"), | |
| # so don't output it | |
| f = _util_dtypestring(child, f, end, offset) | |
| return f | |
| # | |
| # ufunc API | |
| # | |
| cdef extern from "numpy/ufuncobject.h": | |
| ctypedef void (*PyUFuncGenericFunction) (char **, npy_intp *, npy_intp *, void *) | |
| ctypedef class numpy.ufunc [object PyUFuncObject, check_size ignore]: | |
| cdef: | |
| int nin, nout, nargs | |
| int identity | |
| PyUFuncGenericFunction *functions | |
| void **data | |
| int ntypes | |
| int check_return | |
| char *name | |
| char *types | |
| char *doc | |
| void *ptr | |
| PyObject *obj | |
| PyObject *userloops | |
| cdef enum: | |
| PyUFunc_Zero | |
| PyUFunc_One | |
| PyUFunc_None | |
| UFUNC_ERR_IGNORE | |
| UFUNC_ERR_WARN | |
| UFUNC_ERR_RAISE | |
| UFUNC_ERR_CALL | |
| UFUNC_ERR_PRINT | |
| UFUNC_ERR_LOG | |
| UFUNC_MASK_DIVIDEBYZERO | |
| UFUNC_MASK_OVERFLOW | |
| UFUNC_MASK_UNDERFLOW | |
| UFUNC_MASK_INVALID | |
| UFUNC_SHIFT_DIVIDEBYZERO | |
| UFUNC_SHIFT_OVERFLOW | |
| UFUNC_SHIFT_UNDERFLOW | |
| UFUNC_SHIFT_INVALID | |
| UFUNC_FPE_DIVIDEBYZERO | |
| UFUNC_FPE_OVERFLOW | |
| UFUNC_FPE_UNDERFLOW | |
| UFUNC_FPE_INVALID | |
| UFUNC_ERR_DEFAULT | |
| UFUNC_ERR_DEFAULT2 | |
| object PyUFunc_FromFuncAndData(PyUFuncGenericFunction *, | |
| void **, char *, int, int, int, int, char *, char *, int) | |
| int PyUFunc_RegisterLoopForType(ufunc, int, | |
| PyUFuncGenericFunction, int *, void *) | |
| int PyUFunc_GenericFunction \ | |
| (ufunc, PyObject *, PyObject *, PyArrayObject **) | |
| void PyUFunc_f_f_As_d_d \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_d_d \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_f_f \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_g_g \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_F_F_As_D_D \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_F_F \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_D_D \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_G_G \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_O_O \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_ff_f_As_dd_d \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_ff_f \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_dd_d \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_gg_g \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_FF_F_As_DD_D \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_DD_D \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_FF_F \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_GG_G \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_OO_O \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_O_O_method \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_OO_O_method \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| void PyUFunc_On_Om \ | |
| (char **, npy_intp *, npy_intp *, void *) | |
| int PyUFunc_GetPyValues \ | |
| (char *, int *, int *, PyObject **) | |
| int PyUFunc_checkfperr \ | |
| (int, PyObject *, int *) | |
| void PyUFunc_clearfperr() | |
| int PyUFunc_getfperr() | |
| int PyUFunc_handlefperr \ | |
| (int, PyObject *, int, int *) | |
| int PyUFunc_ReplaceLoopBySignature \ | |
| (ufunc, PyUFuncGenericFunction, int *, PyUFuncGenericFunction *) | |
| object PyUFunc_FromFuncAndDataAndSignature \ | |
| (PyUFuncGenericFunction *, void **, char *, int, int, int, | |
| int, char *, char *, int, char *) | |
| int _import_umath() except -1 | |
| cdef inline void set_array_base(ndarray arr, object base): | |
| Py_INCREF(base) # important to do this before stealing the reference below! | |
| PyArray_SetBaseObject(arr, base) | |
| cdef inline object get_array_base(ndarray arr): | |
| base = PyArray_BASE(arr) | |
| if base is NULL: | |
| return None | |
| return <object>base | |
| # Versions of the import_* functions which are more suitable for | |
| # Cython code. | |
| cdef inline int import_array() except -1: | |
| try: | |
| _import_array() | |
| except Exception: | |
| raise ImportError("numpy.core.multiarray failed to import") | |
| cdef inline int import_umath() except -1: | |
| try: | |
| _import_umath() | |
| except Exception: | |
| raise ImportError("numpy.core.umath failed to import") | |
| cdef inline int import_ufunc() except -1: | |
| try: | |
| _import_umath() | |
| except Exception: | |
| raise ImportError("numpy.core.umath failed to import") | |