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) && \
00046                                (PyArray_NDIM((PyArrayObject *)op) == 0))
00047 
00048 #define PyArray_IsScalar(obj, cls)                                            \
00049         (PyObject_TypeCheck(obj, &Py##cls##ArrType_Type))
00050 
00051 #define PyArray_CheckScalar(m) (PyArray_IsScalar(m, Generic) ||               \
00052                                 PyArray_IsZeroDim(m))
00053 
00054 #define PyArray_IsPythonNumber(obj)                                           \
00055         (PyInt_Check(obj) || PyFloat_Check(obj) || PyComplex_Check(obj) ||    \
00056          PyLong_Check(obj) || PyBool_Check(obj))
00057 
00058 #define PyArray_IsPythonScalar(obj)                                           \
00059         (PyArray_IsPythonNumber(obj) || PyString_Check(obj) ||                \
00060          PyUnicode_Check(obj))
00061 
00062 #define PyArray_IsAnyScalar(obj)                                              \
00063         (PyArray_IsScalar(obj, Generic) || PyArray_IsPythonScalar(obj))
00064 
00065 #define PyArray_CheckAnyScalar(obj) (PyArray_IsPythonScalar(obj) ||           \
00066                                      PyArray_CheckScalar(obj))
00067 
00068 #define PyArray_IsIntegerScalar(obj) (PyInt_Check(obj)                        \
00069               || PyLong_Check(obj)                                            \
00070               || PyArray_IsScalar((obj), Integer))
00071 
00072 
00073 #define PyArray_GETCONTIGUOUS(m) (PyArray_ISCONTIGUOUS(m) ?                   \
00074                                   Py_INCREF(m), (m) :                         \
00075                                   (PyArrayObject *)(PyArray_Copy(m)))
00076 
00077 #define PyArray_SAMESHAPE(a1,a2) ((PyArray_NDIM(a1) == PyArray_NDIM(a2)) &&   \
00078                                   PyArray_CompareLists(PyArray_DIMS(a1),      \
00079                                                        PyArray_DIMS(a2),      \
00080                                                        PyArray_NDIM(a1)))
00081 
00082 #define PyArray_SIZE(m) PyArray_MultiplyList(PyArray_DIMS(m), PyArray_NDIM(m))
00083 #define PyArray_NBYTES(m) (PyArray_ITEMSIZE(m) * PyArray_SIZE(m))
00084 #define PyArray_FROM_O(m) PyArray_FromAny(m, NULL, 0, 0, 0, NULL)
00085 
00086 #define PyArray_FROM_OF(m,flags) PyArray_CheckFromAny(m, NULL, 0, 0, flags,   \
00087                                                       NULL)
00088 
00089 #define PyArray_FROM_OT(m,type) PyArray_FromAny(m,                            \
00090                                 PyArray_DescrFromType(type), 0, 0, 0, NULL);
00091 
00092 #define PyArray_FROM_OTF(m, type, flags) \
00093         PyArray_FromAny(m, PyArray_DescrFromType(type), 0, 0, \
00094                         (((flags) & NPY_ARRAY_ENSURECOPY) ? \
00095                          ((flags) | NPY_ARRAY_DEFAULT) : (flags)), NULL)
00096 
00097 #define PyArray_FROMANY(m, type, min, max, flags) \
00098         PyArray_FromAny(m, PyArray_DescrFromType(type), min, max, \
00099                         (((flags) & NPY_ARRAY_ENSURECOPY) ? \
00100                          (flags) | NPY_ARRAY_DEFAULT : (flags)), NULL)
00101 
00102 #define PyArray_ZEROS(m, dims, type, is_f_order) \
00103         PyArray_Zeros(m, dims, PyArray_DescrFromType(type), is_f_order)
00104 
00105 #define PyArray_EMPTY(m, dims, type, is_f_order) \
00106         PyArray_Empty(m, dims, PyArray_DescrFromType(type), is_f_order)
00107 
00108 #define PyArray_FILLWBYTE(obj, val) memset(PyArray_DATA(obj), val, \
00109                                            PyArray_NBYTES(obj))
00110 
00111 #define PyArray_REFCOUNT(obj) (((PyObject *)(obj))->ob_refcnt)
00112 #define NPY_REFCOUNT PyArray_REFCOUNT
00113 #define NPY_MAX_ELSIZE (2 * NPY_SIZEOF_LONGDOUBLE)
00114 
00115 #define PyArray_ContiguousFromAny(op, type, min_depth, max_depth) \
00116         PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
00117                               max_depth, NPY_ARRAY_DEFAULT, NULL)
00118 
00119 #define PyArray_EquivArrTypes(a1, a2) \
00120         PyArray_EquivTypes(PyArray_DESCR(a1), PyArray_DESCR(a2))
00121 
00122 #define PyArray_EquivByteorders(b1, b2) \
00123         (((b1) == (b2)) || (PyArray_ISNBO(b1) == PyArray_ISNBO(b2)))
00124 
00125 #define PyArray_SimpleNew(nd, dims, typenum) \
00126         PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, NULL, 0, 0, NULL)
00127 
00128 #define PyArray_SimpleNewFromData(nd, dims, typenum, data) \
00129         PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, \
00130                     data, 0, NPY_ARRAY_CARRAY, NULL)
00131 
00132 #define PyArray_SimpleNewFromDescr(nd, dims, descr) \
00133         PyArray_NewFromDescr(&PyArray_Type, descr, nd, dims, \
00134                              NULL, NULL, 0, NULL)
00135 
00136 #define PyArray_ToScalar(data, arr) \
00137         PyArray_Scalar(data, PyArray_DESCR(arr), (PyObject *)arr)
00138 
00139 
00140 /* These might be faster without the dereferencing of obj
00141    going on inside -- of course an optimizing compiler should
00142    inline the constants inside a for loop making it a moot point
00143 */
00144 
00145 #define PyArray_GETPTR1(obj, i) ((void *)(PyArray_BYTES(obj) + \
00146                                          (i)*PyArray_STRIDES(obj)[0]))
00147 
00148 #define PyArray_GETPTR2(obj, i, j) ((void *)(PyArray_BYTES(obj) + \
00149                                             (i)*PyArray_STRIDES(obj)[0] + \
00150                                             (j)*PyArray_STRIDES(obj)[1]))
00151 
00152 #define PyArray_GETPTR3(obj, i, j, k) ((void *)(PyArray_BYTES(obj) + \
00153                                             (i)*PyArray_STRIDES(obj)[0] + \
00154                                             (j)*PyArray_STRIDES(obj)[1] + \
00155                                             (k)*PyArray_STRIDES(obj)[2]))
00156 
00157 #define PyArray_GETPTR4(obj, i, j, k, l) ((void *)(PyArray_BYTES(obj) + \
00158                                             (i)*PyArray_STRIDES(obj)[0] + \
00159                                             (j)*PyArray_STRIDES(obj)[1] + \
00160                                             (k)*PyArray_STRIDES(obj)[2] + \
00161                                             (l)*PyArray_STRIDES(obj)[3]))
00162 
00163 static NPY_INLINE void
00164 PyArray_XDECREF_ERR(PyArrayObject *arr)
00165 {
00166     if (arr != NULL) {
00167         if (PyArray_FLAGS(arr) & NPY_ARRAY_UPDATEIFCOPY) {
00168             PyArrayObject *base = (PyArrayObject *)PyArray_BASE(arr);
00169             PyArray_ENABLEFLAGS(base, NPY_ARRAY_WRITEABLE);
00170             PyArray_CLEARFLAGS(arr, NPY_ARRAY_UPDATEIFCOPY);
00171         }
00172         Py_DECREF(arr);
00173     }
00174 }
00175 
00176 #define PyArray_DESCR_REPLACE(descr) do { \
00177                 PyArray_Descr *_new_; \
00178                 _new_ = PyArray_DescrNew(descr); \
00179                 Py_XDECREF(descr); \
00180                 descr = _new_; \
00181         } while(0)
00182 
00183 /* Copy should always return contiguous array */
00184 #define PyArray_Copy(obj) PyArray_NewCopy(obj, NPY_CORDER)
00185 
00186 #define PyArray_FromObject(op, type, min_depth, max_depth) \
00187         PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
00188                               max_depth, NPY_ARRAY_BEHAVED | \
00189                                          NPY_ARRAY_ENSUREARRAY, NULL)
00190 
00191 #define PyArray_ContiguousFromObject(op, type, min_depth, max_depth) \
00192         PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
00193                               max_depth, NPY_ARRAY_DEFAULT | \
00194                                          NPY_ARRAY_ENSUREARRAY, NULL)
00195 
00196 #define PyArray_CopyFromObject(op, type, min_depth, max_depth) \
00197         PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
00198                         max_depth, NPY_ARRAY_ENSURECOPY | \
00199                                    NPY_ARRAY_DEFAULT | \
00200                                    NPY_ARRAY_ENSUREARRAY, NULL)
00201 
00202 #define PyArray_Cast(mp, type_num)                                            \
00203         PyArray_CastToType(mp, PyArray_DescrFromType(type_num), 0)
00204 
00205 #define PyArray_Take(ap, items, axis)                                         \
00206         PyArray_TakeFrom(ap, items, axis, NULL, NPY_RAISE)
00207 
00208 #define PyArray_Put(ap, items, values)                                        \
00209         PyArray_PutTo(ap, items, values, NPY_RAISE)
00210 
00211 /* Compatibility with old Numeric stuff -- don't use in new code */
00212 
00213 #define PyArray_FromDimsAndData(nd, d, type, data)                            \
00214         PyArray_FromDimsAndDataAndDescr(nd, d, PyArray_DescrFromType(type),   \
00215                                         data)
00216 
00217 
00218 /*
00219    Check to see if this key in the dictionary is the "title"
00220    entry of the tuple (i.e. a duplicate dictionary entry in the fields
00221    dict.
00222 */
00223 
00224 #define NPY_TITLE_KEY(key, value) ((PyTuple_GET_SIZE((value))==3) && \
00225                                    (PyTuple_GET_ITEM((value), 2) == (key)))
00226 
00227 
00228 /* Define python version independent deprecation macro */
00229 
00230 #if PY_VERSION_HEX >= 0x02050000
00231 #define DEPRECATE(msg) PyErr_WarnEx(PyExc_DeprecationWarning,msg,1)
00232 #define DEPRECATE_FUTUREWARNING(msg) PyErr_WarnEx(PyExc_FutureWarning,msg,1)
00233 #else
00234 #define DEPRECATE(msg) PyErr_Warn(PyExc_DeprecationWarning,msg)
00235 #define DEPRECATE_FUTUREWARNING(msg) PyErr_Warn(PyExc_FutureWarning,msg)
00236 #endif
00237 
00238 
00239 #ifdef __cplusplus
00240 }
00241 #endif
00242 
00243 
00244 #endif /* NPY_NDARRAYOBJECT_H */