numpy  2.0.0
include/numpy/ndarrayobject.h
Go to the documentation of this file.
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 */