static int
array_ass_slice(PyArrayObject *self, Py_ssize_t ilow,
Py_ssize_t ihigh, PyObject *v) {
int ret;
PyArrayObject *tmp;
if (v == NULL) {
PyErr_SetString(PyExc_ValueError,
"cannot delete array elements");
return -1;
}
if (!PyArray_ISWRITEABLE(self)) {
PyErr_SetString(PyExc_RuntimeError,
"array is not writeable");
return -1;
}
tmp = (PyArrayObject *)array_slice(self, ilow, ihigh);
if (tmp == NULL) {
return -1;
}
ret = PyArray_CopyObject(tmp, v);
Py_DECREF(tmp);
return ret;
}
/* Converts a Python array-like object into a behaved output array. */
static int
NI_ObjectToOutputArray(PyObject *object, PyArrayObject **array)
{
#ifdef HAVE_WRITEBACKIFCOPY
int flags = NPY_ARRAY_BEHAVED_NS | NPY_ARRAY_WRITEBACKIFCOPY;
#else
int flags = NPY_ARRAY_BEHAVED_NS | NPY_ARRAY_UPDATEIFCOPY;
#endif
/*
* This would also be caught by the PyArray_CheckFromAny call, but
* we check it explicitly here to provide a saner error message.
*/
if (PyArray_Check(object) &&
!PyArray_ISWRITEABLE((PyArrayObject *)object)) {
PyErr_SetString(PyExc_ValueError, "output array is read-only.");
return 0;
}
/*
* If the input array is not aligned or is byteswapped, this call
* will create a new aligned, native byte order array, and copy the
* contents of object into it. For an output array, the copy is
* unnecessary, so this could be optimized. It is very easy to not
* do NPY_ARRAY_UPDATEIFCOPY right, so we let NumPy do it for us
* and pay the performance price.
*/
*array = (PyArrayObject *)PyArray_CheckFromAny(object, NULL, 0, 0, flags,
NULL);
return *array != NULL;
}
NPY_NO_EXPORT npy_bool
_IsWriteable(PyArrayObject *ap)
{
PyObject *base=PyArray_BASE(ap);
#if defined(NPY_PY3K)
Py_buffer view;
#else
void *dummy;
Py_ssize_t n;
#endif
/* If we own our own data, then no-problem */
if ((base == NULL) || (PyArray_FLAGS(ap) & NPY_ARRAY_OWNDATA)) {
return NPY_TRUE;
}
/*
* Get to the final base object
* If it is a writeable array, then return TRUE
* If we can find an array object
* or a writeable buffer object as the final base object
* or a string object (for pickling support memory savings).
* - this last could be removed if a proper pickleable
* buffer was added to Python.
*
* MW: I think it would better to disallow switching from READONLY
* to WRITEABLE like this...
*/
while(PyArray_Check(base)) {
if (PyArray_CHKFLAGS((PyArrayObject *)base, NPY_ARRAY_OWNDATA)) {
return (npy_bool) (PyArray_ISWRITEABLE((PyArrayObject *)base));
}
base = PyArray_BASE((PyArrayObject *)base);
}
/*
* here so pickle support works seamlessly
* and unpickled array can be set and reset writeable
* -- could be abused --
*/
if (PyString_Check(base)) {
return NPY_TRUE;
}
#if defined(NPY_PY3K)
if (PyObject_GetBuffer(base, &view, PyBUF_WRITABLE|PyBUF_SIMPLE) < 0) {
PyErr_Clear();
return NPY_FALSE;
}
PyBuffer_Release(&view);
#else
if (PyObject_AsWriteBuffer(base, &dummy, &n) < 0) {
PyErr_Clear();
return NPY_FALSE;
}
#endif
return NPY_TRUE;
}
static PyObject *
index_inc(PyObject *dummy, PyObject *args)
{
PyObject *arg_a, *index=NULL, *inc=NULL;
PyArrayObject *a;
if (!PyArg_ParseTuple(args, "OOO", &arg_a, &index,
&inc)) return NULL;
a = PyArray_FROM_OTF(arg_a, NPY_DOUBLE, NPY_INOUT_ARRAY);
if (a == NULL) return NULL;
if (a->nd == 0) {
PyErr_SetString(PyExc_IndexError, "0-d arrays can't be indexed.");
goto fail;
}
if (!PyArray_ISWRITEABLE(a)) {
PyErr_SetString(PyExc_RuntimeError,
"array is not writeable");
goto fail;
}
//body
PyArrayMapIterObject * mit = (PyArrayMapIterObject *) PyArray_MapIterNew(index, 0, 1);
if (mit == NULL) goto fail;
PyArray_MapIterBind(mit, a);
if (map_inc(mit, inc) != 0)
{
PyErr_SetString(PyExc_RuntimeError, "error during mapping");
goto fail;
}
//endbody
Py_DECREF(mit);
Py_DECREF(a);
Py_DECREF(index);
Py_DECREF(inc);
Py_INCREF(Py_None);
return Py_None;
fail:
Py_XDECREF(mit);
Py_XDECREF(a);
Py_XDECREF(index);
Py_XDECREF(inc);
return NULL;
}
/*
* check if in "alhs @op@ orhs" that alhs is a temporary (refcnt == 1) so we
* can do in-place operations instead of creating a new temporary
* "cannot" is set to true if it cannot be done even with swapped arguments
*/
static int
can_elide_temp(PyArrayObject * alhs, PyObject * orhs, int * cannot)
{
/*
* to be a candidate the array needs to have reference count 1, be an exact
* array of a basic type, own its data and size larger than threshold
*/
if (Py_REFCNT(alhs) != 1 || !PyArray_CheckExact(alhs) ||
!PyArray_ISNUMBER(alhs) ||
!PyArray_CHKFLAGS(alhs, NPY_ARRAY_OWNDATA) ||
!PyArray_ISWRITEABLE(alhs) ||
PyArray_CHKFLAGS(alhs, NPY_ARRAY_UPDATEIFCOPY) ||
PyArray_CHKFLAGS(alhs, NPY_ARRAY_WRITEBACKIFCOPY) ||
PyArray_NBYTES(alhs) < NPY_MIN_ELIDE_BYTES) {
return 0;
}
if (PyArray_CheckExact(orhs) ||
PyArray_CheckAnyScalar(orhs)) {
PyArrayObject * arhs;
/* create array from right hand side */
Py_INCREF(orhs);
arhs = (PyArrayObject *)PyArray_EnsureArray(orhs);
if (arhs == NULL) {
return 0;
}
/*
* if rhs is not a scalar dimensions must match
* TODO: one could allow broadcasting on equal types
*/
if (!(PyArray_NDIM(arhs) == 0 ||
(PyArray_NDIM(arhs) == PyArray_NDIM(alhs) &&
PyArray_CompareLists(PyArray_DIMS(alhs), PyArray_DIMS(arhs),
PyArray_NDIM(arhs))))) {
Py_DECREF(arhs);
return 0;
}
/* must be safe to cast (checks values for scalar in rhs) */
if (PyArray_CanCastArrayTo(arhs, PyArray_DESCR(alhs),
NPY_SAFE_CASTING)) {
Py_DECREF(arhs);
return check_callers(cannot);
}
Py_DECREF(arhs);
}
return 0;
}
/* Converts a Python array-like object into a behaved input/output array. */
static int
NI_ObjectToInputOutputArray(PyObject *object, PyArrayObject **array)
{
/*
* This is also done in NI_ObjectToOutputArray, double checking here
* to provide a more specific error message.
*/
if (PyArray_Check(object) &&
!PyArray_ISWRITEABLE((PyArrayObject *)object)) {
PyErr_SetString(PyExc_ValueError, "input/output array is read-only.");
return 0;
}
return NI_ObjectToOutputArray(object, array);
}
void throw_array_conversion_error(PyObject* object, int flags, int rank_range, PyArray_Descr* descr) {
if (!PyArray_Check(object))
PyErr_Format(PyExc_TypeError, "expected numpy array, got %s", object->ob_type->tp_name);
else if (!PyArray_EquivTypes(PyArray_DESCR((PyArrayObject*)object), descr))
PyErr_Format(PyExc_TypeError, "expected array type %s, got %s", descr->typeobj->tp_name, PyArray_DESCR((PyArrayObject*)object)->typeobj->tp_name);
else if (!PyArray_CHKFLAGS((PyArrayObject*)object,flags)){
if (flags&NPY_ARRAY_WRITEABLE && !PyArray_ISWRITEABLE((PyArrayObject*)object))
PyErr_SetString(PyExc_TypeError, "unwriteable array");
else if (flags&NPY_ARRAY_ALIGNED && !PyArray_ISALIGNED((PyArrayObject*)object))
PyErr_SetString(PyExc_TypeError, "unaligned array");
else if (flags&NPY_ARRAY_C_CONTIGUOUS && !PyArray_ISCONTIGUOUS((PyArrayObject*)object))
PyErr_SetString(PyExc_TypeError, "noncontiguous array");
else
PyErr_SetString(PyExc_TypeError, "unknown array flag mismatch");}
else if (rank_range>=0)
PyErr_Format(PyExc_ValueError, "expected rank %d, got %d", rank_range, PyArray_NDIM((PyArrayObject*)object));
else
PyErr_Format(PyExc_ValueError, "expected rank at least %d, got %d", -rank_range-1, PyArray_NDIM((PyArrayObject*)object));
throw PythonError();
}
NPY_NO_EXPORT int
array_ass_big_item(PyArrayObject *self, intp i, PyObject *v)
{
PyArrayObject *tmp;
char *item;
int ret;
if (v == NULL) {
PyErr_SetString(PyExc_ValueError,
"can't delete array elements");
return -1;
}
if (!PyArray_ISWRITEABLE(self)) {
PyErr_SetString(PyExc_RuntimeError,
"array is not writeable");
return -1;
}
if (self->nd == 0) {
PyErr_SetString(PyExc_IndexError,
"0-d arrays can't be indexed.");
return -1;
}
if (self->nd > 1) {
if((tmp = (PyArrayObject *)array_big_item(self, i)) == NULL) {
return -1;
}
ret = PyArray_CopyObject(tmp, v);
Py_DECREF(tmp);
return ret;
}
if ((item = index2ptr(self, i)) == NULL) {
return -1;
}
if (self->descr->f->setitem(v, item, self) == -1) {
return -1;
}
return 0;
}
/* try elide unary temporary */
NPY_NO_EXPORT int
can_elide_temp_unary(PyArrayObject * m1)
{
int cannot;
if (Py_REFCNT(m1) != 1 || !PyArray_CheckExact(m1) ||
!PyArray_ISNUMBER(m1) ||
!PyArray_CHKFLAGS(m1, NPY_ARRAY_OWNDATA) ||
!PyArray_ISWRITEABLE(m1) ||
PyArray_CHKFLAGS(m1, NPY_ARRAY_UPDATEIFCOPY) ||
PyArray_NBYTES(m1) < NPY_MIN_ELIDE_BYTES) {
return 0;
}
if (check_callers(&cannot)) {
#if NPY_ELIDE_DEBUG != 0
puts("elided temporary in unary op");
#endif
return 1;
}
else {
return 0;
}
}
static int
array_getbuffer(PyObject *obj, Py_buffer *view, int flags)
{
PyArrayObject *self;
_buffer_info_t *info = NULL;
self = (PyArrayObject*)obj;
/* Check whether we can provide the wanted properties */
if ((flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS &&
!PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)) {
PyErr_SetString(PyExc_ValueError, "ndarray is not C-contiguous");
goto fail;
}
if ((flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS &&
!PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)) {
PyErr_SetString(PyExc_ValueError, "ndarray is not Fortran contiguous");
goto fail;
}
if ((flags & PyBUF_ANY_CONTIGUOUS) == PyBUF_ANY_CONTIGUOUS
&& !PyArray_ISONESEGMENT(self)) {
PyErr_SetString(PyExc_ValueError, "ndarray is not contiguous");
goto fail;
}
if ((flags & PyBUF_STRIDES) != PyBUF_STRIDES &&
!PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)) {
/* Non-strided N-dim buffers must be C-contiguous */
PyErr_SetString(PyExc_ValueError, "ndarray is not C-contiguous");
goto fail;
}
if ((flags & PyBUF_WRITEABLE) == PyBUF_WRITEABLE) {
if (PyArray_FailUnlessWriteable(self, "buffer source array") < 0) {
goto fail;
}
}
/*
* If a read-only buffer is requested on a read-write array, we return a
* read-write buffer, which is dubious behavior. But that's why this call
* is guarded by PyArray_ISWRITEABLE rather than (flags &
* PyBUF_WRITEABLE).
*/
if (PyArray_ISWRITEABLE(self)) {
if (array_might_be_written(self) < 0) {
goto fail;
}
}
if (view == NULL) {
PyErr_SetString(PyExc_ValueError, "NULL view in getbuffer");
goto fail;
}
/* Fill in information */
info = _buffer_get_info(obj);
if (info == NULL) {
goto fail;
}
view->buf = PyArray_DATA(self);
view->suboffsets = NULL;
view->itemsize = PyArray_ITEMSIZE(self);
view->readonly = !PyArray_ISWRITEABLE(self);
view->internal = NULL;
view->len = PyArray_NBYTES(self);
if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) {
view->format = info->format;
} else {
view->format = NULL;
}
if ((flags & PyBUF_ND) == PyBUF_ND) {
view->ndim = info->ndim;
view->shape = info->shape;
}
else {
view->ndim = 0;
view->shape = NULL;
}
if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) {
view->strides = info->strides;
}
else {
view->strides = NULL;
}
view->obj = (PyObject*)self;
Py_INCREF(self);
return 0;
fail:
return -1;
}
/*
* Retrieving buffers for ndarray
*/
static int
array_getbuffer(PyObject *obj, Py_buffer *view, int flags)
{
PyArrayObject *self;
_buffer_info_t *info = NULL;
self = (PyArrayObject*)obj;
/* Check whether we can provide the wanted properties */
if ((flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS &&
!PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)) {
PyErr_SetString(PyExc_ValueError, "ndarray is not C-contiguous");
goto fail;
}
if ((flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS &&
!PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)) {
PyErr_SetString(PyExc_ValueError, "ndarray is not Fortran contiguous");
goto fail;
}
if ((flags & PyBUF_ANY_CONTIGUOUS) == PyBUF_ANY_CONTIGUOUS
&& !PyArray_ISONESEGMENT(self)) {
PyErr_SetString(PyExc_ValueError, "ndarray is not contiguous");
goto fail;
}
if ((flags & PyBUF_STRIDES) != PyBUF_STRIDES &&
!PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)) {
/* Non-strided N-dim buffers must be C-contiguous */
PyErr_SetString(PyExc_ValueError, "ndarray is not C-contiguous");
goto fail;
}
if ((flags & PyBUF_WRITEABLE) == PyBUF_WRITEABLE) {
if (PyArray_FailUnlessWriteable(self, "buffer source array") < 0) {
goto fail;
}
}
/*
* If a read-only buffer is requested on a read-write array, we return a
* read-write buffer, which is dubious behavior. But that's why this call
* is guarded by PyArray_ISWRITEABLE rather than (flags &
* PyBUF_WRITEABLE).
*/
if (PyArray_ISWRITEABLE(self)) {
if (array_might_be_written(self) < 0) {
goto fail;
}
}
if (view == NULL) {
PyErr_SetString(PyExc_ValueError, "NULL view in getbuffer");
goto fail;
}
/* Fill in information */
info = _buffer_get_info(obj);
if (info == NULL) {
goto fail;
}
view->buf = PyArray_DATA(self);
view->suboffsets = NULL;
view->itemsize = PyArray_ITEMSIZE(self);
view->readonly = !PyArray_ISWRITEABLE(self);
view->internal = NULL;
view->len = PyArray_NBYTES(self);
if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) {
view->format = info->format;
} else {
view->format = NULL;
}
if ((flags & PyBUF_ND) == PyBUF_ND) {
view->ndim = info->ndim;
view->shape = info->shape;
}
else {
view->ndim = 0;
view->shape = NULL;
}
if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) {
view->strides = info->strides;
#ifdef NPY_RELAXED_STRIDES_CHECKING
/*
* If NPY_RELAXED_STRIDES_CHECKING is on, the array may be
* contiguous, but it won't look that way to Python when it
* tries to determine contiguity by looking at the strides
* (since one of the elements may be -1). In that case, just
* regenerate strides from shape.
*/
if (PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS) &&
!((flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS)) {
Py_ssize_t sd = view->itemsize;
int i;
for (i = view->ndim-1; i >= 0; --i) {
view->strides[i] = sd;
sd *= view->shape[i];
}
}
else if (PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)) {
Py_ssize_t sd = view->itemsize;
int i;
for (i = 0; i < view->ndim; ++i) {
view->strides[i] = sd;
sd *= view->shape[i];
}
}
#endif
}
else {
view->strides = NULL;
}
view->obj = (PyObject*)self;
Py_INCREF(self);
return 0;
fail:
return -1;
}
static int
array_getbuffer(PyObject *obj, Py_buffer *view, int flags)
{
PyArrayObject *self;
_buffer_info_t *info = NULL;
self = (PyArrayObject*)obj;
/* Check whether we can provide the wanted properties */
if ((flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS &&
!PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)) {
PyErr_SetString(PyExc_ValueError, "ndarray is not C-contiguous");
goto fail;
}
if ((flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS &&
!PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)) {
PyErr_SetString(PyExc_ValueError, "ndarray is not Fortran contiguous");
goto fail;
}
if ((flags & PyBUF_ANY_CONTIGUOUS) == PyBUF_ANY_CONTIGUOUS
&& !PyArray_ISONESEGMENT(self)) {
PyErr_SetString(PyExc_ValueError, "ndarray is not contiguous");
goto fail;
}
if ((flags & PyBUF_STRIDES) != PyBUF_STRIDES &&
(flags & PyBUF_ND) == PyBUF_ND &&
!PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)) {
/* Non-strided N-dim buffers must be C-contiguous */
PyErr_SetString(PyExc_ValueError, "ndarray is not C-contiguous");
goto fail;
}
if ((flags & PyBUF_WRITEABLE) == PyBUF_WRITEABLE &&
!PyArray_ISWRITEABLE(self)) {
PyErr_SetString(PyExc_ValueError, "ndarray is not writeable");
goto fail;
}
if (view == NULL) {
PyErr_SetString(PyExc_ValueError, "NULL view in getbuffer");
goto fail;
}
/* Fill in information */
info = _buffer_get_info(obj);
if (info == NULL) {
goto fail;
}
view->buf = PyArray_DATA(self);
view->suboffsets = NULL;
view->itemsize = PyArray_ITEMSIZE(self);
view->readonly = !PyArray_ISWRITEABLE(self);
view->internal = NULL;
view->len = PyArray_NBYTES(self);
if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) {
view->format = info->format;
} else {
view->format = NULL;
}
if ((flags & PyBUF_ND) == PyBUF_ND) {
view->ndim = info->ndim;
view->shape = info->shape;
}
else {
view->ndim = 0;
view->shape = NULL;
}
if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) {
view->strides = info->strides;
}
else {
view->strides = NULL;
}
view->obj = (PyObject*)self;
Py_INCREF(self);
return 0;
fail:
return -1;
}
