numpy  2.0.0
include/numpy/ndarrayobject.h File Reference
#include "ndarraytypes.h"
#include "__multiarray_api.h"

Go to the source code of this file.

Defines

#define PyArray_DescrCheck(op)   (((PyObject*)(op))->ob_type==&PyArrayDescr_Type)
#define PyArray_Check(op)   PyObject_TypeCheck(op, &PyArray_Type)
#define PyArray_CheckExact(op)   (((PyObject*)(op))->ob_type == &PyArray_Type)
#define PyArray_HasArrayInterfaceType(op, type, context, out)
#define PyArray_HasArrayInterface(op, out)   PyArray_HasArrayInterfaceType(op, NULL, NULL, out)
#define PyArray_IsZeroDim(op)
#define PyArray_IsScalar(obj, cls)   (PyObject_TypeCheck(obj, &Py##cls##ArrType_Type))
#define PyArray_CheckScalar(m)
#define PyArray_IsPythonNumber(obj)
#define PyArray_IsPythonScalar(obj)
#define PyArray_IsAnyScalar(obj)   (PyArray_IsScalar(obj, Generic) || PyArray_IsPythonScalar(obj))
#define PyArray_CheckAnyScalar(obj)
#define PyArray_IsIntegerScalar(obj)
#define PyArray_GETCONTIGUOUS(m)
#define PyArray_SAMESHAPE(a1, a2)
#define PyArray_SIZE(m)   PyArray_MultiplyList(PyArray_DIMS(m), PyArray_NDIM(m))
#define PyArray_NBYTES(m)   (PyArray_ITEMSIZE(m) * PyArray_SIZE(m))
#define PyArray_FROM_O(m)   PyArray_FromAny(m, NULL, 0, 0, 0, NULL)
#define PyArray_FROM_OF(m, flags)
#define PyArray_FROM_OT(m, type)
#define PyArray_FROM_OTF(m, type, flags)
#define PyArray_FROMANY(m, type, min, max, flags)
#define PyArray_ZEROS(m, dims, type, is_f_order)   PyArray_Zeros(m, dims, PyArray_DescrFromType(type), is_f_order)
#define PyArray_EMPTY(m, dims, type, is_f_order)   PyArray_Empty(m, dims, PyArray_DescrFromType(type), is_f_order)
#define PyArray_FILLWBYTE(obj, val)
#define PyArray_REFCOUNT(obj)   (((PyObject *)(obj))->ob_refcnt)
#define NPY_REFCOUNT   PyArray_REFCOUNT
#define NPY_MAX_ELSIZE   (2 * NPY_SIZEOF_LONGDOUBLE)
#define PyArray_ContiguousFromAny(op, type, min_depth, max_depth)
#define PyArray_EquivArrTypes(a1, a2)   PyArray_EquivTypes(PyArray_DESCR(a1), PyArray_DESCR(a2))
#define PyArray_EquivByteorders(b1, b2)   (((b1) == (b2)) || (PyArray_ISNBO(b1) == PyArray_ISNBO(b2)))
#define PyArray_SimpleNew(nd, dims, typenum)   PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, NULL, 0, 0, NULL)
#define PyArray_SimpleNewFromData(nd, dims, typenum, data)
#define PyArray_SimpleNewFromDescr(nd, dims, descr)
#define PyArray_ToScalar(data, arr)   PyArray_Scalar(data, PyArray_DESCR(arr), (PyObject *)arr)
#define PyArray_GETPTR1(obj, i)
#define PyArray_GETPTR2(obj, i, j)
#define PyArray_GETPTR3(obj, i, j, k)
#define PyArray_GETPTR4(obj, i, j, k, l)
#define PyArray_DESCR_REPLACE(descr)
#define PyArray_Copy(obj)   PyArray_NewCopy(obj, NPY_CORDER)
#define PyArray_FromObject(op, type, min_depth, max_depth)
#define PyArray_ContiguousFromObject(op, type, min_depth, max_depth)
#define PyArray_CopyFromObject(op, type, min_depth, max_depth)
#define PyArray_Cast(mp, type_num)   PyArray_CastToType(mp, PyArray_DescrFromType(type_num), 0)
#define PyArray_Take(ap, items, axis)   PyArray_TakeFrom(ap, items, axis, NULL, NPY_RAISE)
#define PyArray_Put(ap, items, values)   PyArray_PutTo(ap, items, values, NPY_RAISE)
#define PyArray_FromDimsAndData(nd, d, type, data)
#define NPY_TITLE_KEY(key, value)
#define DEPRECATE(msg)   PyErr_Warn(PyExc_DeprecationWarning,msg)
#define DEPRECATE_FUTUREWARNING(msg)   PyErr_Warn(PyExc_FutureWarning,msg)

Functions

static NPY_INLINE void PyArray_XDECREF_ERR (PyArrayObject *arr)

Define Documentation

#define DEPRECATE (   msg)    PyErr_Warn(PyExc_DeprecationWarning,msg)
Define python version independent deprecation macro

Referenced by PyArray_As1D(), and PyArray_FromInterface().

#define DEPRECATE_FUTUREWARNING (   msg)    PyErr_Warn(PyExc_FutureWarning,msg)
NPY_NDARRAYOBJECT_H
#define NPY_MAX_ELSIZE   (2 * NPY_SIZEOF_LONGDOUBLE)
#define NPY_TITLE_KEY (   key,
  value 
)
Value:
((PyTuple_GET_SIZE((value))==3) && \
                                   (PyTuple_GET_ITEM((value), 2) == (key)))
Check to see if this key in the dictionary is the "title" entry of the tuple (i.e. a duplicate dictionary entry in the fields dict.

Referenced by _check_ones(), array_argsort(), arraydescr_subdescr_get(), and STRING_copyswapn().

#define PyArray_Cast (   mp,
  type_num 
)    PyArray_CastToType(mp, PyArray_DescrFromType(type_num), 0)
#define PyArray_CheckAnyScalar (   obj)
Value:
(PyArray_IsPythonScalar(obj) ||           \
                                     PyArray_CheckScalar(obj))
#define PyArray_CheckExact (   op)    (((PyObject*)(op))->ob_type == &PyArray_Type)

Referenced by _nonzero_indices().

#define PyArray_CheckScalar (   m)
Value:
(PyArray_IsScalar(m, Generic) ||               \
                                PyArray_IsZeroDim(m))
#define PyArray_ContiguousFromAny (   op,
  type,
  min_depth,
  max_depth 
)
Value:
PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
                              max_depth, NPY_ARRAY_DEFAULT, NULL)

Referenced by PyArray_ArgMax(), and PyArray_TakeFrom().

#define PyArray_ContiguousFromObject (   op,
  type,
  min_depth,
  max_depth 
)
Value:
PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
                              max_depth, NPY_ARRAY_DEFAULT | \
                                         NPY_ARRAY_ENSUREARRAY, NULL)
#define PyArray_Copy (   obj)    PyArray_NewCopy(obj, NPY_CORDER)
Copy should always return contiguous array
#define PyArray_CopyFromObject (   op,
  type,
  min_depth,
  max_depth 
)
#define PyArray_DESCR_REPLACE (   descr)
Value:
do { \
                PyArray_Descr *_new_; \
                _new_ = PyArray_DescrNew(descr); \
                Py_XDECREF(descr); \
                descr = _new_; \
        } while(0)

Referenced by _array_from_buffer_3118().

#define PyArray_DescrCheck (   op)    (((PyObject*)(op))->ob_type==&PyArrayDescr_Type)
Includes the "function" C-API -- these are all stored in a

list of pointers --- one for each file The two lists are concatenated into one in multiarray.

They are available as import_array()

C-API that requries previous API to be defined
#define PyArray_EMPTY (   m,
  dims,
  type,
  is_f_order 
)    PyArray_Empty(m, dims, PyArray_DescrFromType(type), is_f_order)
#define PyArray_EquivArrTypes (   a1,
  a2 
)    PyArray_EquivTypes(PyArray_DESCR(a1), PyArray_DESCR(a2))
#define PyArray_EquivByteorders (   b1,
  b2 
)    (((b1) == (b2)) || (PyArray_ISNBO(b1) == PyArray_ISNBO(b2)))
#define PyArray_FILLWBYTE (   obj,
  val 
)
Value:
memset(PyArray_DATA(obj), val, \
                                           PyArray_NBYTES(obj))
#define PyArray_FROM_O (   m)    PyArray_FromAny(m, NULL, 0, 0, 0, NULL)
#define PyArray_FROM_OF (   m,
  flags 
)
Value:
PyArray_CheckFromAny(m, NULL, 0, 0, flags,   \
                                                      NULL)
#define PyArray_FROM_OT (   m,
  type 
)
Value:
PyArray_FromAny(m,                            \
                                PyArray_DescrFromType(type), 0, 0, 0, NULL);
#define PyArray_FROM_OTF (   m,
  type,
  flags 
)
Value:
PyArray_FromAny(m, PyArray_DescrFromType(type), 0, 0, \
                        (((flags) & NPY_ARRAY_ENSURECOPY) ? \
                         ((flags) | NPY_ARRAY_DEFAULT) : (flags)), NULL)
#define PyArray_FROMANY (   m,
  type,
  min,
  max,
  flags 
)
Value:
PyArray_FromAny(m, PyArray_DescrFromType(type), min, max, \
                        (((flags) & NPY_ARRAY_ENSURECOPY) ? \
                         (flags) | NPY_ARRAY_DEFAULT : (flags)), NULL)
#define PyArray_FromDimsAndData (   nd,
  d,
  type,
  data 
)
Value:
Compatibility with old Numeric stuff -- don't use in new code
#define PyArray_FromObject (   op,
  type,
  min_depth,
  max_depth 
)
Value:
PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
                              max_depth, NPY_ARRAY_BEHAVED | \
                                         NPY_ARRAY_ENSUREARRAY, NULL)
#define PyArray_GETCONTIGUOUS (   m)
Value:
(PyArray_ISCONTIGUOUS(m) ?                   \
                                  Py_INCREF(m), (m) :                         \
                                  (PyArrayObject *)(PyArray_Copy(m)))
#define PyArray_GETPTR1 (   obj,
 
)
Value:
((void *)(PyArray_BYTES(obj) + \
                                         (i)*PyArray_STRIDES(obj)[0]))
These might be faster without the dereferencing of obj
going on inside -- of course an optimizing compiler should inline the constants inside a for loop making it a moot point
#define PyArray_GETPTR2 (   obj,
  i,
 
)
Value:
((void *)(PyArray_BYTES(obj) + \
                                            (i)*PyArray_STRIDES(obj)[0] + \
                                            (j)*PyArray_STRIDES(obj)[1]))
#define PyArray_GETPTR3 (   obj,
  i,
  j,
 
)
Value:
((void *)(PyArray_BYTES(obj) + \
                                            (i)*PyArray_STRIDES(obj)[0] + \
                                            (j)*PyArray_STRIDES(obj)[1] + \
                                            (k)*PyArray_STRIDES(obj)[2]))
#define PyArray_GETPTR4 (   obj,
  i,
  j,
  k,
 
)
Value:
((void *)(PyArray_BYTES(obj) + \
                                            (i)*PyArray_STRIDES(obj)[0] + \
                                            (j)*PyArray_STRIDES(obj)[1] + \
                                            (k)*PyArray_STRIDES(obj)[2] + \
                                            (l)*PyArray_STRIDES(obj)[3]))
#define PyArray_HasArrayInterface (   op,
  out 
)    PyArray_HasArrayInterfaceType(op, NULL, NULL, out)
#define PyArray_HasArrayInterfaceType (   op,
  type,
  context,
  out 
)
Value:
((((out)=PyArray_FromStructInterface(op)) != Py_NotImplemented) ||    \
         (((out)=PyArray_FromInterface(op)) != Py_NotImplemented) ||          \
         (((out)=PyArray_FromArrayAttr(op, type, context)) !=                 \
          Py_NotImplemented))
#define PyArray_IsAnyScalar (   obj)    (PyArray_IsScalar(obj, Generic) || PyArray_IsPythonScalar(obj))
#define PyArray_IsIntegerScalar (   obj)
Value:
(PyInt_Check(obj)                        \
              || PyLong_Check(obj)                                            \
              || PyArray_IsScalar((obj), Integer))
#define PyArray_IsPythonNumber (   obj)
Value:
(PyInt_Check(obj) || PyFloat_Check(obj) || PyComplex_Check(obj) ||    \
         PyLong_Check(obj) || PyBool_Check(obj))
#define PyArray_IsPythonScalar (   obj)
Value:
(PyArray_IsPythonNumber(obj) || PyString_Check(obj) ||                \
         PyUnicode_Check(obj))
#define PyArray_IsScalar (   obj,
  cls 
)    (PyObject_TypeCheck(obj, &Py##cls##ArrType_Type))
#define PyArray_IsZeroDim (   op)
Value:
(PyArray_Check(op) && \
                               (PyArray_NDIM((PyArrayObject *)op) == 0))

Referenced by array_remainder().

#define PyArray_NBYTES (   m)    (PyArray_ITEMSIZE(m) * PyArray_SIZE(m))
#define PyArray_Put (   ap,
  items,
  values 
)    PyArray_PutTo(ap, items, values, NPY_RAISE)
#define PyArray_REFCOUNT (   obj)    (((PyObject *)(obj))->ob_refcnt)
#define PyArray_SAMESHAPE (   a1,
  a2 
)
Value:
((PyArray_NDIM(a1) == PyArray_NDIM(a2)) &&   \
                                  PyArray_CompareLists(PyArray_DIMS(a1),      \
                                                       PyArray_DIMS(a2),      \
                                                       PyArray_NDIM(a1)))
#define PyArray_SimpleNew (   nd,
  dims,
  typenum 
)    PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, NULL, 0, 0, NULL)

Referenced by copy_object(), and name().

#define PyArray_SimpleNewFromData (   nd,
  dims,
  typenum,
  data 
)
Value:
PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, \
                    data, 0, NPY_ARRAY_CARRAY, NULL)
#define PyArray_SimpleNewFromDescr (   nd,
  dims,
  descr 
)
Value:
PyArray_NewFromDescr(&PyArray_Type, descr, nd, dims, \
                             NULL, NULL, 0, NULL)
#define PyArray_Take (   ap,
  items,
  axis 
)    PyArray_TakeFrom(ap, items, axis, NULL, NPY_RAISE)
#define PyArray_ToScalar (   data,
  arr 
)    PyArray_Scalar(data, PyArray_DESCR(arr), (PyObject *)arr)

Referenced by iter_subscript_int().

#define PyArray_ZEROS (   m,
  dims,
  type,
  is_f_order 
)    PyArray_Zeros(m, dims, PyArray_DescrFromType(type), is_f_order)

Function Documentation

static NPY_INLINE void PyArray_XDECREF_ERR ( PyArrayObject arr) [static]

Referenced by PyArray_TakeFrom().