diff options
Diffstat (limited to 'numpy/core/src/arrayobject.c')
| -rw-r--r-- | numpy/core/src/arrayobject.c | 1163 |
1 files changed, 1 insertions, 1162 deletions
diff --git a/numpy/core/src/arrayobject.c b/numpy/core/src/arrayobject.c index e94608160..e831a2242 100644 --- a/numpy/core/src/arrayobject.c +++ b/numpy/core/src/arrayobject.c @@ -31,6 +31,7 @@ maintainer email: oliphant.travis@ieee.org #include "numpy/arrayscalars.h" #include "arrayobject.h" +#include "arraydescr.h" /*NUMPY_API * Get Priority from object @@ -6651,8 +6652,6 @@ array_priority_get(PyArrayObject *self) } } -static PyObject *arraydescr_protocol_typestr_get(PyArray_Descr *); - static PyObject * array_typestr_get(PyArrayObject *self) { @@ -6666,8 +6665,6 @@ array_descr_get(PyArrayObject *self) return (PyObject *)self->descr; } -static PyObject *arraydescr_protocol_descr_get(PyArray_Descr *self); - static PyObject * array_protocol_descr_get(PyArrayObject *self) { @@ -11896,1161 +11893,3 @@ NPY_NO_EXPORT PyTypeObject PyArrayMultiIter_Type = { 0, /* *tp_next */ #endif }; - -/*NUMPY_API*/ -NPY_NO_EXPORT PyArray_Descr * -PyArray_DescrNewFromType(int type_num) -{ - PyArray_Descr *old; - PyArray_Descr *new; - - old = PyArray_DescrFromType(type_num); - new = PyArray_DescrNew(old); - Py_DECREF(old); - return new; -} - -/** Array Descr Objects for dynamic types **/ - -/* - * There are some statically-defined PyArray_Descr objects corresponding - * to the basic built-in types. - * These can and should be DECREF'd and INCREF'd as appropriate, anyway. - * If a mistake is made in reference counting, deallocation on these - * builtins will be attempted leading to problems. - * - * This let's us deal with all PyArray_Descr objects using reference - * counting (regardless of whether they are statically or dynamically - * allocated). - */ - -/*NUMPY_API - * base cannot be NULL - */ -NPY_NO_EXPORT PyArray_Descr * -PyArray_DescrNew(PyArray_Descr *base) -{ - PyArray_Descr *new = PyObject_New(PyArray_Descr, &PyArrayDescr_Type); - - if (new == NULL) { - return NULL; - } - /* Don't copy PyObject_HEAD part */ - memcpy((char *)new + sizeof(PyObject), - (char *)base + sizeof(PyObject), - sizeof(PyArray_Descr) - sizeof(PyObject)); - - if (new->fields == Py_None) { - new->fields = NULL; - } - Py_XINCREF(new->fields); - Py_XINCREF(new->names); - if (new->subarray) { - new->subarray = _pya_malloc(sizeof(PyArray_ArrayDescr)); - memcpy(new->subarray, base->subarray, sizeof(PyArray_ArrayDescr)); - Py_INCREF(new->subarray->shape); - Py_INCREF(new->subarray->base); - } - Py_XINCREF(new->typeobj); - return new; -} - -/* - * should never be called for builtin-types unless - * there is a reference-count problem - */ -static void -arraydescr_dealloc(PyArray_Descr *self) -{ - if (self->fields == Py_None) { - fprintf(stderr, "*** Reference count error detected: \n" \ - "an attempt was made to deallocate %d (%c) ***\n", - self->type_num, self->type); - Py_INCREF(self); - Py_INCREF(self); - return; - } - Py_XDECREF(self->typeobj); - Py_XDECREF(self->names); - Py_XDECREF(self->fields); - if (self->subarray) { - Py_DECREF(self->subarray->shape); - Py_DECREF(self->subarray->base); - _pya_free(self->subarray); - } - self->ob_type->tp_free((PyObject *)self); -} - -/* - * we need to be careful about setting attributes because these - * objects are pointed to by arrays that depend on them for interpreting - * data. Currently no attributes of data-type objects can be set - * directly except names. - */ -static PyMemberDef arraydescr_members[] = { - {"type", - T_OBJECT, offsetof(PyArray_Descr, typeobj), RO, NULL}, - {"kind", - T_CHAR, offsetof(PyArray_Descr, kind), RO, NULL}, - {"char", - T_CHAR, offsetof(PyArray_Descr, type), RO, NULL}, - {"num", - T_INT, offsetof(PyArray_Descr, type_num), RO, NULL}, - {"byteorder", - T_CHAR, offsetof(PyArray_Descr, byteorder), RO, NULL}, - {"itemsize", - T_INT, offsetof(PyArray_Descr, elsize), RO, NULL}, - {"alignment", - T_INT, offsetof(PyArray_Descr, alignment), RO, NULL}, - {"flags", - T_UBYTE, offsetof(PyArray_Descr, hasobject), RO, NULL}, - {NULL, 0, 0, 0, NULL}, -}; - -static PyObject * -arraydescr_subdescr_get(PyArray_Descr *self) -{ - if (self->subarray == NULL) { - Py_INCREF(Py_None); - return Py_None; - } - return Py_BuildValue("OO", (PyObject *)self->subarray->base, - self->subarray->shape); -} - -static PyObject * -arraydescr_protocol_typestr_get(PyArray_Descr *self) -{ - char basic_ = self->kind; - char endian = self->byteorder; - int size = self->elsize; - - if (endian == '=') { - endian = '<'; - if (!PyArray_IsNativeByteOrder(endian)) { - endian = '>'; - } - } - if (self->type_num == PyArray_UNICODE) { - size >>= 2; - } - return PyString_FromFormat("%c%c%d", endian, basic_, size); -} - -static PyObject * -arraydescr_typename_get(PyArray_Descr *self) -{ - int len; - PyTypeObject *typeobj = self->typeobj; - PyObject *res; - char *s; - /* fixme: not reentrant */ - static int prefix_len = 0; - - if (PyTypeNum_ISUSERDEF(self->type_num)) { - s = strrchr(typeobj->tp_name, '.'); - if (s == NULL) { - res = PyString_FromString(typeobj->tp_name); - } - else { - res = PyString_FromStringAndSize(s + 1, strlen(s) - 1); - } - return res; - } - else { - if (prefix_len == 0) { - prefix_len = strlen("numpy."); - } - len = strlen(typeobj->tp_name); - if (*(typeobj->tp_name + (len-1)) == '_') { - len -= 1; - } - len -= prefix_len; - res = PyString_FromStringAndSize(typeobj->tp_name+prefix_len, len); - } - if (PyTypeNum_ISFLEXIBLE(self->type_num) && self->elsize != 0) { - PyObject *p; - p = PyString_FromFormat("%d", self->elsize * 8); - PyString_ConcatAndDel(&res, p); - } - return res; -} - -static PyObject * -arraydescr_base_get(PyArray_Descr *self) -{ - if (self->subarray == NULL) { - Py_INCREF(self); - return (PyObject *)self; - } - Py_INCREF(self->subarray->base); - return (PyObject *)(self->subarray->base); -} - -static PyObject * -arraydescr_shape_get(PyArray_Descr *self) -{ - if (self->subarray == NULL) { - return PyTuple_New(0); - } - if (PyTuple_Check(self->subarray->shape)) { - Py_INCREF(self->subarray->shape); - return (PyObject *)(self->subarray->shape); - } - return Py_BuildValue("(O)", self->subarray->shape); -} - -static PyObject * -arraydescr_protocol_descr_get(PyArray_Descr *self) -{ - PyObject *dobj, *res; - PyObject *_numpy_internal; - - if (self->names == NULL) { - /* get default */ - dobj = PyTuple_New(2); - if (dobj == NULL) { - return NULL; - } - PyTuple_SET_ITEM(dobj, 0, PyString_FromString("")); - PyTuple_SET_ITEM(dobj, 1, arraydescr_protocol_typestr_get(self)); - res = PyList_New(1); - if (res == NULL) { - Py_DECREF(dobj); - return NULL; - } - PyList_SET_ITEM(res, 0, dobj); - return res; - } - - _numpy_internal = PyImport_ImportModule("numpy.core._internal"); - if (_numpy_internal == NULL) { - return NULL; - } - res = PyObject_CallMethod(_numpy_internal, "_array_descr", "O", self); - Py_DECREF(_numpy_internal); - return res; -} - -/* - * returns 1 for a builtin type - * and 2 for a user-defined data-type descriptor - * return 0 if neither (i.e. it's a copy of one) - */ -static PyObject * -arraydescr_isbuiltin_get(PyArray_Descr *self) -{ - long val; - val = 0; - if (self->fields == Py_None) { - val = 1; - } - if (PyTypeNum_ISUSERDEF(self->type_num)) { - val = 2; - } - return PyInt_FromLong(val); -} - -static int -_arraydescr_isnative(PyArray_Descr *self) -{ - if (self->names == NULL) { - return PyArray_ISNBO(self->byteorder); - } - else { - PyObject *key, *value, *title = NULL; - PyArray_Descr *new; - int offset; - Py_ssize_t pos = 0; - while (PyDict_Next(self->fields, &pos, &key, &value)) { - if NPY_TITLE_KEY(key, value) { - continue; - } - if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset, &title)) { - return -1; - } - if (!_arraydescr_isnative(new)) { - return 0; - } - } - } - return 1; -} - -/* - * return Py_True if this data-type descriptor - * has native byteorder if no fields are defined - * - * or if all sub-fields have native-byteorder if - * fields are defined - */ -static PyObject * -arraydescr_isnative_get(PyArray_Descr *self) -{ - PyObject *ret; - int retval; - retval = _arraydescr_isnative(self); - if (retval == -1) { - return NULL; - } - ret = retval ? Py_True : Py_False; - Py_INCREF(ret); - return ret; -} - -static PyObject * -arraydescr_fields_get(PyArray_Descr *self) -{ - if (self->names == NULL) { - Py_INCREF(Py_None); - return Py_None; - } - return PyDictProxy_New(self->fields); -} - -static PyObject * -arraydescr_hasobject_get(PyArray_Descr *self) -{ - PyObject *res; - if (PyDataType_FLAGCHK(self, NPY_ITEM_HASOBJECT)) { - res = Py_True; - } - else { - res = Py_False; - } - Py_INCREF(res); - return res; -} - -static PyObject * -arraydescr_names_get(PyArray_Descr *self) -{ - if (self->names == NULL) { - Py_INCREF(Py_None); - return Py_None; - } - Py_INCREF(self->names); - return self->names; -} - -static int -arraydescr_names_set(PyArray_Descr *self, PyObject *val) -{ - int N = 0; - int i; - PyObject *new_names; - if (self->names == NULL) { - PyErr_SetString(PyExc_ValueError, "there are no fields defined"); - return -1; - } - - N = PyTuple_GET_SIZE(self->names); - if (!PySequence_Check(val) || PyObject_Size((PyObject *)val) != N) { - PyErr_Format(PyExc_ValueError, "must replace all names at once" \ - " with a sequence of length %d", N); - return -1; - } - /* Make sure all entries are strings */ - for (i = 0; i < N; i++) { - PyObject *item; - int valid = 1; - item = PySequence_GetItem(val, i); - valid = PyString_Check(item); - Py_DECREF(item); - if (!valid) { - PyErr_Format(PyExc_ValueError, - "item #%d of names is of type %s and not string", - i, item->ob_type->tp_name); - return -1; - } - } - /* Update dictionary keys in fields */ - new_names = PySequence_Tuple(val); - for (i = 0; i < N; i++) { - PyObject *key; - PyObject *item; - PyObject *new_key; - key = PyTuple_GET_ITEM(self->names, i); - /* Borrowed reference to item */ - item = PyDict_GetItem(self->fields, key); - Py_INCREF(item); /* Hold on to it even through DelItem */ - new_key = PyTuple_GET_ITEM(new_names, i); - PyDict_DelItem(self->fields, key); - PyDict_SetItem(self->fields, new_key, item); - Py_DECREF(item); /* self->fields now holds reference */ - } - - /* Replace names */ - Py_DECREF(self->names); - self->names = new_names; - - return 0; -} - -static PyGetSetDef arraydescr_getsets[] = { - {"subdtype", - (getter)arraydescr_subdescr_get, - NULL, NULL, NULL}, - {"descr", - (getter)arraydescr_protocol_descr_get, - NULL, NULL, NULL}, - {"str", - (getter)arraydescr_protocol_typestr_get, - NULL, NULL, NULL}, - {"name", - (getter)arraydescr_typename_get, - NULL, NULL, NULL}, - {"base", - (getter)arraydescr_base_get, - NULL, NULL, NULL}, - {"shape", - (getter)arraydescr_shape_get, - NULL, NULL, NULL}, - {"isbuiltin", - (getter)arraydescr_isbuiltin_get, - NULL, NULL, NULL}, - {"isnative", - (getter)arraydescr_isnative_get, - NULL, NULL, NULL}, - {"fields", - (getter)arraydescr_fields_get, - NULL, NULL, NULL}, - {"names", - (getter)arraydescr_names_get, - (setter)arraydescr_names_set, - NULL, NULL}, - {"hasobject", - (getter)arraydescr_hasobject_get, - NULL, NULL, NULL}, - {NULL, NULL, NULL, NULL, NULL}, -}; - -static PyObject * -arraydescr_new(PyTypeObject *NPY_UNUSED(subtype), PyObject *args, PyObject *kwds) -{ - PyObject *odescr; - PyArray_Descr *descr, *conv; - Bool align = FALSE; - Bool copy = FALSE; - static char *kwlist[] = {"dtype", "align", "copy", NULL}; - - if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&O&", - kwlist, &odescr, - PyArray_BoolConverter, &align, - PyArray_BoolConverter, ©)) { - return NULL; - } - if (align) { - if (!PyArray_DescrAlignConverter(odescr, &conv)) { - return NULL; - } - } - else if (!PyArray_DescrConverter(odescr, &conv)) { - return NULL; - } - /* Get a new copy of it unless it's already a copy */ - if (copy && conv->fields == Py_None) { - descr = PyArray_DescrNew(conv); - Py_DECREF(conv); - conv = descr; - } - return (PyObject *)conv; -} - - -/* return a tuple of (callable object, args, state). */ -static PyObject * -arraydescr_reduce(PyArray_Descr *self, PyObject *NPY_UNUSED(args)) -{ - /* - * version number of this pickle type. Increment if we need to - * change the format. Be sure to handle the old versions in - * arraydescr_setstate. - */ - const int version = 3; - PyObject *ret, *mod, *obj; - PyObject *state; - char endian; - int elsize, alignment; - - ret = PyTuple_New(3); - if (ret == NULL) { - return NULL; - } - mod = PyImport_ImportModule("numpy.core.multiarray"); - if (mod == NULL) { - Py_DECREF(ret); - return NULL; - } - obj = PyObject_GetAttrString(mod, "dtype"); - Py_DECREF(mod); - if (obj == NULL) { - Py_DECREF(ret); - return NULL; - } - PyTuple_SET_ITEM(ret, 0, obj); - if (PyTypeNum_ISUSERDEF(self->type_num) || - ((self->type_num == PyArray_VOID && - self->typeobj != &PyVoidArrType_Type))) { - obj = (PyObject *)self->typeobj; - Py_INCREF(obj); - } - else { - elsize = self->elsize; - if (self->type_num == PyArray_UNICODE) { - elsize >>= 2; - } - obj = PyString_FromFormat("%c%d",self->kind, elsize); - } - PyTuple_SET_ITEM(ret, 1, Py_BuildValue("(Nii)", obj, 0, 1)); - - /* - * Now return the state which is at least byteorder, - * subarray, and fields - */ - endian = self->byteorder; - if (endian == '=') { - endian = '<'; - if (!PyArray_IsNativeByteOrder(endian)) { - endian = '>'; - } - } - state = PyTuple_New(8); - PyTuple_SET_ITEM(state, 0, PyInt_FromLong(version)); - PyTuple_SET_ITEM(state, 1, PyString_FromFormat("%c", endian)); - PyTuple_SET_ITEM(state, 2, arraydescr_subdescr_get(self)); - if (self->names) { - Py_INCREF(self->names); - Py_INCREF(self->fields); - PyTuple_SET_ITEM(state, 3, self->names); - PyTuple_SET_ITEM(state, 4, self->fields); - } - else { - PyTuple_SET_ITEM(state, 3, Py_None); - PyTuple_SET_ITEM(state, 4, Py_None); - Py_INCREF(Py_None); - Py_INCREF(Py_None); - } - - /* for extended types it also includes elsize and alignment */ - if (PyTypeNum_ISEXTENDED(self->type_num)) { - elsize = self->elsize; - alignment = self->alignment; - } - else { - elsize = -1; - alignment = -1; - } - PyTuple_SET_ITEM(state, 5, PyInt_FromLong(elsize)); - PyTuple_SET_ITEM(state, 6, PyInt_FromLong(alignment)); - PyTuple_SET_ITEM(state, 7, PyInt_FromLong(self->hasobject)); - PyTuple_SET_ITEM(ret, 2, state); - return ret; -} - -/* returns 1 if this data-type has an object portion - used when setting the state because hasobject is not stored. -*/ -static int -_descr_find_object(PyArray_Descr *self) -{ - if (self->hasobject || self->type_num == PyArray_OBJECT || - self->kind == 'O') { - return NPY_OBJECT_DTYPE_FLAGS; - } - if (PyDescr_HASFIELDS(self)) { - PyObject *key, *value, *title = NULL; - PyArray_Descr *new; - int offset; - Py_ssize_t pos = 0; - - while (PyDict_Next(self->fields, &pos, &key, &value)) { - if NPY_TITLE_KEY(key, value) { - continue; - } - if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset, &title)) { - PyErr_Clear(); - return 0; - } - if (_descr_find_object(new)) { - new->hasobject = NPY_OBJECT_DTYPE_FLAGS; - return NPY_OBJECT_DTYPE_FLAGS; - } - } - } - return 0; -} - -/* - * state is at least byteorder, subarray, and fields but could include elsize - * and alignment for EXTENDED arrays - */ -static PyObject * -arraydescr_setstate(PyArray_Descr *self, PyObject *args) -{ - int elsize = -1, alignment = -1; - int version = 3; - char endian; - PyObject *subarray, *fields, *names = NULL; - int incref_names = 1; - int dtypeflags = 0; - - if (self->fields == Py_None) { - Py_INCREF(Py_None); - return Py_None; - } - if (PyTuple_GET_SIZE(args) != 1 || - !(PyTuple_Check(PyTuple_GET_ITEM(args, 0)))) { - PyErr_BadInternalCall(); - return NULL; - } - switch (PyTuple_GET_SIZE(PyTuple_GET_ITEM(args,0))) { - case 8: - if (!PyArg_ParseTuple(args, "(icOOOiii)", &version, &endian, - &subarray, &names, &fields, &elsize, - &alignment, &dtypeflags)) { - return NULL; - } - break; - case 7: - if (!PyArg_ParseTuple(args, "(icOOOii)", &version, &endian, - &subarray, &names, &fields, &elsize, - &alignment)) { - return NULL; - } - break; - case 6: - if (!PyArg_ParseTuple(args, "(icOOii)", &version, - &endian, &subarray, &fields, - &elsize, &alignment)) { - PyErr_Clear(); - } - break; - case 5: - version = 0; - if (!PyArg_ParseTuple(args, "(cOOii)", - &endian, &subarray, &fields, &elsize, - &alignment)) { - return NULL; - } - break; - default: - /* raise an error */ - version = -1; - } - - /* - * If we ever need another pickle format, increment the version - * number. But we should still be able to handle the old versions. - */ - if (version < 0 || version > 3) { - PyErr_Format(PyExc_ValueError, - "can't handle version %d of numpy.dtype pickle", - version); - return NULL; - } - - if (version == 1 || version == 0) { - if (fields != Py_None) { - PyObject *key, *list; - key = PyInt_FromLong(-1); - list = PyDict_GetItem(fields, key); - if (!list) { - return NULL; - } - Py_INCREF(list); - names = list; - PyDict_DelItem(fields, key); - incref_names = 0; - } - else { - names = Py_None; - } - } - - - if ((fields == Py_None && names != Py_None) || - (names == Py_None && fields != Py_None)) { - PyErr_Format(PyExc_ValueError, - "inconsistent fields and names"); - return NULL; - } - - if (endian != '|' && PyArray_IsNativeByteOrder(endian)) { - endian = '='; - } - self->byteorder = endian; - if (self->subarray) { - Py_XDECREF(self->subarray->base); - Py_XDECREF(self->subarray->shape); - _pya_free(self->subarray); - } - self->subarray = NULL; - - if (subarray != Py_None) { - self->subarray = _pya_malloc(sizeof(PyArray_ArrayDescr)); - self->subarray->base = (PyArray_Descr *)PyTuple_GET_ITEM(subarray, 0); - Py_INCREF(self->subarray->base); - self->subarray->shape = PyTuple_GET_ITEM(subarray, 1); - Py_INCREF(self->subarray->shape); - } - - if (fields != Py_None) { - Py_XDECREF(self->fields); - self->fields = fields; - Py_INCREF(fields); - Py_XDECREF(self->names); - self->names = names; - if (incref_names) { - Py_INCREF(names); - } - } - - if (PyTypeNum_ISEXTENDED(self->type_num)) { - self->elsize = elsize; - self->alignment = alignment; - } - - self->hasobject = dtypeflags; - if (version < 3) { - self->hasobject = _descr_find_object(self); - } - Py_INCREF(Py_None); - return Py_None; -} - - - /*NUMPY_API - * returns a copy of the PyArray_Descr structure with the byteorder - * altered: - * no arguments: The byteorder is swapped (in all subfields as well) - * single argument: The byteorder is forced to the given state - * (in all subfields as well) - * - * Valid states: ('big', '>') or ('little' or '<') - * ('native', or '=') - * - * If a descr structure with | is encountered it's own - * byte-order is not changed but any fields are: - * - * - * Deep bytorder change of a data-type descriptor - * *** Leaves reference count of self unchanged --- does not DECREF self *** - */ -NPY_NO_EXPORT PyArray_Descr * -PyArray_DescrNewByteorder(PyArray_Descr *self, char newendian) -{ - PyArray_Descr *new; - char endian; - - new = PyArray_DescrNew(self); - endian = new->byteorder; - if (endian != PyArray_IGNORE) { - if (newendian == PyArray_SWAP) { - /* swap byteorder */ - if PyArray_ISNBO(endian) { - endian = PyArray_OPPBYTE; - } - else { - endian = PyArray_NATBYTE; - } - new->byteorder = endian; - } - else if (newendian != PyArray_IGNORE) { - new->byteorder = newendian; - } - } - if (new->names) { - PyObject *newfields; - PyObject *key, *value; - PyObject *newvalue; - PyObject *old; - PyArray_Descr *newdescr; - Py_ssize_t pos = 0; - int len, i; - - newfields = PyDict_New(); - /* make new dictionary with replaced PyArray_Descr Objects */ - while(PyDict_Next(self->fields, &pos, &key, &value)) { - if NPY_TITLE_KEY(key, value) { - continue; - } - if (!PyString_Check(key) || - !PyTuple_Check(value) || - ((len=PyTuple_GET_SIZE(value)) < 2)) { - continue; - } - old = PyTuple_GET_ITEM(value, 0); - if (!PyArray_DescrCheck(old)) { - continue; - } - newdescr = PyArray_DescrNewByteorder( - (PyArray_Descr *)old, newendian); - if (newdescr == NULL) { - Py_DECREF(newfields); Py_DECREF(new); - return NULL; - } - newvalue = PyTuple_New(len); - PyTuple_SET_ITEM(newvalue, 0, (PyObject *)newdescr); - for (i = 1; i < len; i++) { - old = PyTuple_GET_ITEM(value, i); - Py_INCREF(old); - PyTuple_SET_ITEM(newvalue, i, old); - } - PyDict_SetItem(newfields, key, newvalue); - Py_DECREF(newvalue); - } - Py_DECREF(new->fields); - new->fields = newfields; - } - if (new->subarray) { - Py_DECREF(new->subarray->base); - new->subarray->base = PyArray_DescrNewByteorder - (self->subarray->base, newendian); - } - return new; -} - - -static PyObject * -arraydescr_newbyteorder(PyArray_Descr *self, PyObject *args) -{ - char endian=PyArray_SWAP; - - if (!PyArg_ParseTuple(args, "|O&", PyArray_ByteorderConverter, - &endian)) { - return NULL; - } - return (PyObject *)PyArray_DescrNewByteorder(self, endian); -} - -static PyMethodDef arraydescr_methods[] = { - /* for pickling */ - {"__reduce__", - (PyCFunction)arraydescr_reduce, METH_VARARGS, NULL}, - {"__setstate__", - (PyCFunction)arraydescr_setstate, METH_VARARGS, NULL}, - {"newbyteorder", - (PyCFunction)arraydescr_newbyteorder, METH_VARARGS, NULL}, - {NULL, NULL, 0, NULL} /* sentinel */ -}; - -static PyObject * -arraydescr_str(PyArray_Descr *self) -{ - PyObject *sub; - - if (self->names) { - PyObject *lst; - lst = arraydescr_protocol_descr_get(self); - if (!lst) { - sub = PyString_FromString("<err>"); - PyErr_Clear(); - } - else { - sub = PyObject_Str(lst); - } - Py_XDECREF(lst); - if (self->type_num != PyArray_VOID) { - PyObject *p; - PyObject *t=PyString_FromString("'"); - p = arraydescr_protocol_typestr_get(self); - PyString_Concat(&p, t); - PyString_ConcatAndDel(&t, p); - p = PyString_FromString("("); - PyString_ConcatAndDel(&p, t); - PyString_ConcatAndDel(&p, PyString_FromString(", ")); - PyString_ConcatAndDel(&p, sub); - PyString_ConcatAndDel(&p, PyString_FromString(")")); - sub = p; - } - } - else if (self->subarray) { - PyObject *p; - PyObject *t = PyString_FromString("("); - PyObject *sh; - p = arraydescr_str(self->subarray->base); - if (!self->subarray->base->names && !self->subarray->base->subarray) { - PyObject *t=PyString_FromString("'"); - PyString_Concat(&p, t); - PyString_ConcatAndDel(&t, p); - p = t; - } - PyString_ConcatAndDel(&t, p); - PyString_ConcatAndDel(&t, PyString_FromString(",")); - if (!PyTuple_Check(self->subarray->shape)) { - sh = Py_BuildValue("(O)", self->subarray->shape); - } - else { - sh = self->subarray->shape; - Py_INCREF(sh); - } - PyString_ConcatAndDel(&t, PyObject_Str(sh)); - Py_DECREF(sh); - PyString_ConcatAndDel(&t, PyString_FromString(")")); - sub = t; - } - else if (PyDataType_ISFLEXIBLE(self) || !PyArray_ISNBO(self->byteorder)) { - sub = arraydescr_protocol_typestr_get(self); - } - else { - sub = arraydescr_typename_get(self); - } - return sub; -} - -static PyObject * -arraydescr_repr(PyArray_Descr *self) -{ - PyObject *sub, *s; - s = PyString_FromString("dtype("); - sub = arraydescr_str(self); - if (!self->names && !self->subarray) { - PyObject *t=PyString_FromString("'"); - PyString_Concat(&sub, t); - PyString_ConcatAndDel(&t, sub); - sub = t; - } - PyString_ConcatAndDel(&s, sub); - sub = PyString_FromString(")"); - PyString_ConcatAndDel(&s, sub); - return s; -} - -static PyObject * -arraydescr_richcompare(PyArray_Descr *self, PyObject *other, int cmp_op) -{ - PyArray_Descr *new = NULL; - PyObject *result = Py_NotImplemented; - if (!PyArray_DescrCheck(other)) { - if (PyArray_DescrConverter(other, &new) == PY_FAIL) { - return NULL; - } - } - else { - new = (PyArray_Descr *)other; - Py_INCREF(new); - } - switch (cmp_op) { - case Py_LT: - if (!PyArray_EquivTypes(self, new) && PyArray_CanCastTo(self, new)) { - result = Py_True; - } - else { - result = Py_False; - } - break; - case Py_LE: - if (PyArray_CanCastTo(self, new)) { - result = Py_True; - } - else { - result = Py_False; - } - break; - case Py_EQ: - if (PyArray_EquivTypes(self, new)) { - result = Py_True; - } - else { - result = Py_False; - } - break; - case Py_NE: - if (PyArray_EquivTypes(self, new)) - result = Py_False; - else - result = Py_True; - break; - case Py_GT: - if (!PyArray_EquivTypes(self, new) && PyArray_CanCastTo(new, self)) { - result = Py_True; - } - else { - result = Py_False; - } - break; - case Py_GE: - if (PyArray_CanCastTo(new, self)) { - result = Py_True; - } - else { - result = Py_False; - } - break; - default: - result = Py_NotImplemented; - } - - Py_XDECREF(new); - Py_INCREF(result); - return result; -} - -/************************************************************************* - **************** Implement Mapping Protocol *************************** - *************************************************************************/ - -static Py_ssize_t -descr_length(PyObject *self0) -{ - PyArray_Descr *self = (PyArray_Descr *)self0; - - if (self->names) { - return PyTuple_GET_SIZE(self->names); - } - else { - return 0; - } -} - -static PyObject * -descr_repeat(PyObject *self, Py_ssize_t length) -{ - PyObject *tup; - PyArray_Descr *new; - if (length < 0) { - return PyErr_Format(PyExc_ValueError, - "Array length must be >= 0, not %"INTP_FMT, - length); - } - tup = Py_BuildValue("O" NPY_SSIZE_T_PYFMT, self, length); - if (tup == NULL) { - return NULL; - } - PyArray_DescrConverter(tup, &new); - Py_DECREF(tup); - return (PyObject *)new; -} - -static PyObject * -descr_subscript(PyArray_Descr *self, PyObject *op) -{ - - if (self->names) { - if (PyString_Check(op) || PyUnicode_Check(op)) { - PyObject *obj = PyDict_GetItem(self->fields, op); - if (obj != NULL) { - PyObject *descr = PyTuple_GET_ITEM(obj, 0); - Py_INCREF(descr); - return descr; - } - else { - PyErr_Format(PyExc_KeyError, - "field named \'%s\' not found.", - PyString_AsString(op)); - } - } - else { - PyObject *name; - int value = PyArray_PyIntAsInt(op); - if (!PyErr_Occurred()) { - int size = PyTuple_GET_SIZE(self->names); - if (value < 0) { - value += size; - } - if (value < 0 || value >= size) { - PyErr_Format(PyExc_IndexError, - "0<=index<%d not %d", - size, value); - return NULL; - } - name = PyTuple_GET_ITEM(self->names, value); - return descr_subscript(self, name); - } - } - PyErr_SetString(PyExc_ValueError, - "only integers, strings or unicode values " - "allowed for getting fields."); - } - else { - PyObject *astr; - astr = arraydescr_str(self); - PyErr_Format(PyExc_KeyError, - "there are no fields in dtype %s.", - PyString_AsString(astr)); - Py_DECREF(astr); - } - return NULL; -} - -static PySequenceMethods descr_as_sequence = { - descr_length, - (binaryfunc)NULL, - descr_repeat, - NULL, NULL, - NULL, /* sq_ass_item */ - NULL, /* ssizessizeobjargproc sq_ass_slice */ - 0, /* sq_contains */ - 0, /* sq_inplace_concat */ - 0, /* sq_inplace_repeat */ -}; - -static PyMappingMethods descr_as_mapping = { - descr_length, /* mp_length*/ - (binaryfunc)descr_subscript, /* mp_subscript*/ - (objobjargproc)NULL, /* mp_ass_subscript*/ -}; - -/****************** End of Mapping Protocol ******************************/ - - -NPY_NO_EXPORT PyTypeObject PyArrayDescr_Type = { - PyObject_HEAD_INIT(NULL) - 0, /* ob_size */ - "numpy.dtype", /* tp_name */ - sizeof(PyArray_Descr), /* tp_basicsize */ - 0, /* tp_itemsize */ - /* methods */ - (destructor)arraydescr_dealloc, /* tp_dealloc */ - 0, /* tp_print */ - 0, /* tp_getattr */ - 0, /* tp_setattr */ - 0, /* tp_compare */ - (reprfunc)arraydescr_repr, /* tp_repr */ - 0, /* tp_as_number */ - &descr_as_sequence, /* tp_as_sequence */ - &descr_as_mapping, /* tp_as_mapping */ - 0, /* tp_hash */ - 0, /* tp_call */ - (reprfunc)arraydescr_str, /* tp_str */ - 0, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT, /* tp_flags */ - 0, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - (richcmpfunc)arraydescr_richcompare, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ - arraydescr_methods, /* tp_methods */ - arraydescr_members, /* tp_members */ - arraydescr_getsets, /* tp_getset */ - 0, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - 0, /* tp_init */ - 0, /* tp_alloc */ - arraydescr_new, /* tp_new */ - 0, /* tp_free */ - 0, /* tp_is_gc */ - 0, /* tp_bases */ - 0, /* tp_mro */ - 0, /* tp_cache */ - 0, /* tp_subclasses */ - 0, /* tp_weaklist */ - 0, /* tp_del */ - -#ifdef COUNT_ALLOCS - /* these must be last and never explicitly initialized */ - 0, /* tp_allocs */ - 0, /* tp_frees */ - 0, /* tp_maxalloc */ - 0, /* tp_prev */ - 0, /* *tp_next */ -#endif -}; |