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