numpy
2.0.0
|
00001 /* 00002 * DON'T INCLUDE THIS DIRECTLY. 00003 */ 00004 00005 #ifndef NPY_NDARRAYOBJECT_H 00006 #define NPY_NDARRAYOBJECT_H 00007 #ifdef __cplusplus 00008 #define CONFUSE_EMACS { 00009 #define CONFUSE_EMACS2 } 00010 extern "C" CONFUSE_EMACS 00011 #undef CONFUSE_EMACS 00012 #undef CONFUSE_EMACS2 00013 /* ... otherwise a semi-smart identer (like emacs) tries to indent 00014 everything when you're typing */ 00015 #endif 00016 00017 #include <Python.h> 00018 #include "ndarraytypes.h" 00019 00020 /* Includes the "function" C-API -- these are all stored in a 00021 list of pointers --- one for each file 00022 The two lists are concatenated into one in multiarray. 00023 00024 They are available as import_array() 00025 */ 00026 00027 #include "__multiarray_api.h" 00028 00029 00030 /* C-API that requires previous API to be defined */ 00031 00032 #define PyArray_DescrCheck(op) (((PyObject*)(op))->ob_type==&PyArrayDescr_Type) 00033 00034 #define PyArray_Check(op) PyObject_TypeCheck(op, &PyArray_Type) 00035 #define PyArray_CheckExact(op) (((PyObject*)(op))->ob_type == &PyArray_Type) 00036 00037 #define PyArray_HasArrayInterfaceType(op, type, context, out) \ 00038 ((((out)=PyArray_FromStructInterface(op)) != Py_NotImplemented) || \ 00039 (((out)=PyArray_FromInterface(op)) != Py_NotImplemented) || \ 00040 (((out)=PyArray_FromArrayAttr(op, type, context)) != \ 00041 Py_NotImplemented)) 00042 00043 #define PyArray_HasArrayInterface(op, out) \ 00044 PyArray_HasArrayInterfaceType(op, NULL, NULL, out) 00045 00046 #define PyArray_IsZeroDim(op) (PyArray_Check(op) && \ 00047 (PyArray_NDIM((PyArrayObject *)op) == 0)) 00048 00049 #define PyArray_IsScalar(obj, cls) \ 00050 (PyObject_TypeCheck(obj, &Py##cls##ArrType_Type)) 00051 00052 #define PyArray_CheckScalar(m) (PyArray_IsScalar(m, Generic) || \ 00053 PyArray_IsZeroDim(m)) 00054 #if PY_MAJOR_VERSION >= 3 00055 #define PyArray_IsPythonNumber(obj) \ 00056 (PyFloat_Check(obj) || PyComplex_Check(obj) || \ 00057 PyLong_Check(obj) || PyBool_Check(obj)) 00058 #define PyArray_IsIntegerScalar(obj) (PyLong_Check(obj) \ 00059 || PyArray_IsScalar((obj), Integer)) 00060 #define PyArray_IsPythonScalar(obj) \ 00061 (PyArray_IsPythonNumber(obj) || PyBytes_Check(obj) || \ 00062 PyUnicode_Check(obj)) 00063 #else 00064 #define PyArray_IsPythonNumber(obj) \ 00065 (PyInt_Check(obj) || PyFloat_Check(obj) || PyComplex_Check(obj) || \ 00066 PyLong_Check(obj) || PyBool_Check(obj)) 00067 #define PyArray_IsIntegerScalar(obj) (PyInt_Check(obj) \ 00068 || PyLong_Check(obj) \ 00069 || PyArray_IsScalar((obj), Integer)) 00070 #define PyArray_IsPythonScalar(obj) \ 00071 (PyArray_IsPythonNumber(obj) || PyString_Check(obj) || \ 00072 PyUnicode_Check(obj)) 00073 #endif 00074 00075 #define PyArray_IsAnyScalar(obj) \ 00076 (PyArray_IsScalar(obj, Generic) || PyArray_IsPythonScalar(obj)) 00077 00078 #define PyArray_CheckAnyScalar(obj) (PyArray_IsPythonScalar(obj) || \ 00079 PyArray_CheckScalar(obj)) 00080 00081 00082 #define PyArray_GETCONTIGUOUS(m) (PyArray_ISCONTIGUOUS(m) ? \ 00083 Py_INCREF(m), (m) : \ 00084 (PyArrayObject *)(PyArray_Copy(m))) 00085 00086 #define PyArray_SAMESHAPE(a1,a2) ((PyArray_NDIM(a1) == PyArray_NDIM(a2)) && \ 00087 PyArray_CompareLists(PyArray_DIMS(a1), \ 00088 PyArray_DIMS(a2), \ 00089 PyArray_NDIM(a1))) 00090 00091 #define PyArray_SIZE(m) PyArray_MultiplyList(PyArray_DIMS(m), PyArray_NDIM(m)) 00092 #define PyArray_NBYTES(m) (PyArray_ITEMSIZE(m) * PyArray_SIZE(m)) 00093 #define PyArray_FROM_O(m) PyArray_FromAny(m, NULL, 0, 0, 0, NULL) 00094 00095 #define PyArray_FROM_OF(m,flags) PyArray_CheckFromAny(m, NULL, 0, 0, flags, \ 00096 NULL) 00097 00098 #define PyArray_FROM_OT(m,type) PyArray_FromAny(m, \ 00099 PyArray_DescrFromType(type), 0, 0, 0, NULL) 00100 00101 #define PyArray_FROM_OTF(m, type, flags) \ 00102 PyArray_FromAny(m, PyArray_DescrFromType(type), 0, 0, \ 00103 (((flags) & NPY_ARRAY_ENSURECOPY) ? \ 00104 ((flags) | NPY_ARRAY_DEFAULT) : (flags)), NULL) 00105 00106 #define PyArray_FROMANY(m, type, min, max, flags) \ 00107 PyArray_FromAny(m, PyArray_DescrFromType(type), min, max, \ 00108 (((flags) & NPY_ARRAY_ENSURECOPY) ? \ 00109 (flags) | NPY_ARRAY_DEFAULT : (flags)), NULL) 00110 00111 #define PyArray_ZEROS(m, dims, type, is_f_order) \ 00112 PyArray_Zeros(m, dims, PyArray_DescrFromType(type), is_f_order) 00113 00114 #define PyArray_EMPTY(m, dims, type, is_f_order) \ 00115 PyArray_Empty(m, dims, PyArray_DescrFromType(type), is_f_order) 00116 00117 #define PyArray_FILLWBYTE(obj, val) memset(PyArray_DATA(obj), val, \ 00118 PyArray_NBYTES(obj)) 00119 #ifndef PYPY_VERSION 00120 #define PyArray_REFCOUNT(obj) (((PyObject *)(obj))->ob_refcnt) 00121 #define NPY_REFCOUNT PyArray_REFCOUNT 00122 #endif 00123 #define NPY_MAX_ELSIZE (2 * NPY_SIZEOF_LONGDOUBLE) 00124 00125 #define PyArray_ContiguousFromAny(op, type, min_depth, max_depth) \ 00126 PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \ 00127 max_depth, NPY_ARRAY_DEFAULT, NULL) 00128 00129 #define PyArray_EquivArrTypes(a1, a2) \ 00130 PyArray_EquivTypes(PyArray_DESCR(a1), PyArray_DESCR(a2)) 00131 00132 #define PyArray_EquivByteorders(b1, b2) \ 00133 (((b1) == (b2)) || (PyArray_ISNBO(b1) == PyArray_ISNBO(b2))) 00134 00135 #define PyArray_SimpleNew(nd, dims, typenum) \ 00136 PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, NULL, 0, 0, NULL) 00137 00138 #define PyArray_SimpleNewFromData(nd, dims, typenum, data) \ 00139 PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, \ 00140 data, 0, NPY_ARRAY_CARRAY, NULL) 00141 00142 #define PyArray_SimpleNewFromDescr(nd, dims, descr) \ 00143 PyArray_NewFromDescr(&PyArray_Type, descr, nd, dims, \ 00144 NULL, NULL, 0, NULL) 00145 00146 #define PyArray_ToScalar(data, arr) \ 00147 PyArray_Scalar(data, PyArray_DESCR(arr), (PyObject *)arr) 00148 00149 00150 /* These might be faster without the dereferencing of obj 00151 going on inside -- of course an optimizing compiler should 00152 inline the constants inside a for loop making it a moot point 00153 */ 00154 00155 #define PyArray_GETPTR1(obj, i) ((void *)(PyArray_BYTES(obj) + \ 00156 (i)*PyArray_STRIDES(obj)[0])) 00157 00158 #define PyArray_GETPTR2(obj, i, j) ((void *)(PyArray_BYTES(obj) + \ 00159 (i)*PyArray_STRIDES(obj)[0] + \ 00160 (j)*PyArray_STRIDES(obj)[1])) 00161 00162 #define PyArray_GETPTR3(obj, i, j, k) ((void *)(PyArray_BYTES(obj) + \ 00163 (i)*PyArray_STRIDES(obj)[0] + \ 00164 (j)*PyArray_STRIDES(obj)[1] + \ 00165 (k)*PyArray_STRIDES(obj)[2])) 00166 00167 #define PyArray_GETPTR4(obj, i, j, k, l) ((void *)(PyArray_BYTES(obj) + \ 00168 (i)*PyArray_STRIDES(obj)[0] + \ 00169 (j)*PyArray_STRIDES(obj)[1] + \ 00170 (k)*PyArray_STRIDES(obj)[2] + \ 00171 (l)*PyArray_STRIDES(obj)[3])) 00172 00173 static NPY_INLINE void 00174 PyArray_XDECREF_ERR(PyArrayObject *arr) 00175 { 00176 if (arr != NULL) { 00177 if (PyArray_FLAGS(arr) & NPY_ARRAY_UPDATEIFCOPY) { 00178 PyArrayObject *base = (PyArrayObject *)PyArray_BASE(arr); 00179 PyArray_ENABLEFLAGS(base, NPY_ARRAY_WRITEABLE); 00180 PyArray_CLEARFLAGS(arr, NPY_ARRAY_UPDATEIFCOPY); 00181 } 00182 Py_DECREF(arr); 00183 } 00184 } 00185 00186 #define PyArray_DESCR_REPLACE(descr) do { \ 00187 PyArray_Descr *_new_; \ 00188 _new_ = PyArray_DescrNew(descr); \ 00189 Py_XDECREF(descr); \ 00190 descr = _new_; \ 00191 } while(0) 00192 00193 /* Copy should always return contiguous array */ 00194 #define PyArray_Copy(obj) PyArray_NewCopy(obj, NPY_CORDER) 00195 00196 #define PyArray_FromObject(op, type, min_depth, max_depth) \ 00197 PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \ 00198 max_depth, NPY_ARRAY_BEHAVED | \ 00199 NPY_ARRAY_ENSUREARRAY, NULL) 00200 00201 #define PyArray_ContiguousFromObject(op, type, min_depth, max_depth) \ 00202 PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \ 00203 max_depth, NPY_ARRAY_DEFAULT | \ 00204 NPY_ARRAY_ENSUREARRAY, NULL) 00205 00206 #define PyArray_CopyFromObject(op, type, min_depth, max_depth) \ 00207 PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \ 00208 max_depth, NPY_ARRAY_ENSURECOPY | \ 00209 NPY_ARRAY_DEFAULT | \ 00210 NPY_ARRAY_ENSUREARRAY, NULL) 00211 00212 #define PyArray_Cast(mp, type_num) \ 00213 PyArray_CastToType(mp, PyArray_DescrFromType(type_num), 0) 00214 00215 #define PyArray_Take(ap, items, axis) \ 00216 PyArray_TakeFrom(ap, items, axis, NULL, NPY_RAISE) 00217 00218 #define PyArray_Put(ap, items, values) \ 00219 PyArray_PutTo(ap, items, values, NPY_RAISE) 00220 00221 /* Compatibility with old Numeric stuff -- don't use in new code */ 00222 00223 #define PyArray_FromDimsAndData(nd, d, type, data) \ 00224 PyArray_FromDimsAndDataAndDescr(nd, d, PyArray_DescrFromType(type), \ 00225 data) 00226 00227 00228 /* 00229 Check to see if this key in the dictionary is the "title" 00230 entry of the tuple (i.e. a duplicate dictionary entry in the fields 00231 dict. 00232 */ 00233 00234 #define NPY_TITLE_KEY(key, value) ((PyTuple_GET_SIZE((value))==3) && \ 00235 (PyTuple_GET_ITEM((value), 2) == (key))) 00236 00237 00238 #define DEPRECATE(msg) PyErr_WarnEx(PyExc_DeprecationWarning,msg,1) 00239 #define DEPRECATE_FUTUREWARNING(msg) PyErr_WarnEx(PyExc_FutureWarning,msg,1) 00240 00241 00242 #ifdef __cplusplus 00243 } 00244 #endif 00245 00246 00247 #endif /* NPY_NDARRAYOBJECT_H */