#define NPY_NO_DEPRECATED_API NPY_API_VERSION

#define _MULTIARRAYMODULE

#define PY_SSIZE_T_CLEAN

#include <Python.h>

#include <structmember.h>

#include "numpy/arrayobject.h"

#include "numpy/arrayscalars.h"

#include "npy_config.h"

#include "npy_pycompat.h"

#include "common.h"

#include "number.h"

#include "usertypes.h"

#include "arraytypes.h"

#include "scalartypes.h"

#include "arrayobject.h"

#include "convert_datatype.h"

#include "conversion_utils.h"

#include "ctors.h"

#include "dtypemeta.h"

#include "methods.h"

#include "descriptor.h"

#include "iterators.h"

#include "mapping.h"

#include "getset.h"

#include "sequence.h"

#include "npy_buffer.h"

#include "array_assign.h"

#include "alloc.h"

#include "mem_overlap.h"

#include "numpyos.h"

#include "strfuncs.h"

#include "binop_override.h"

#include "array_coercion.h"

NPY_NO_EXPORT npy_intp

PyArray_Size(PyObject *op)

{

if (PyArray_Check(op)) {

return PyArray_SIZE((PyArrayObject *)op);

}

else {

return 0;

}

}

NPY_NO_EXPORT int

PyArray_SetUpdateIfCopyBase(PyArrayObject *arr, PyArrayObject *base)

{

int ret;

/* 2017-Nov -10 1.14 (for PyPy only) */

/* 2018-April-21 1.15 (all Python implementations) */

if (DEPRECATE("PyArray_SetUpdateIfCopyBase is deprecated, use "

"PyArray_SetWritebackIfCopyBase instead, and be sure to call "

"PyArray_ResolveWritebackIfCopy before the array is deallocated, "

"i.e. before the last call to Py_DECREF. If cleaning up from an "

"error, PyArray_DiscardWritebackIfCopy may be called instead to "

"throw away the scratch buffer.") < 0)

return -1;

ret = PyArray_SetWritebackIfCopyBase(arr, base);

if (ret >=0) {

PyArray_ENABLEFLAGS(arr, NPY_ARRAY_UPDATEIFCOPY);

PyArray_CLEARFLAGS(arr, NPY_ARRAY_WRITEBACKIFCOPY);

}

return ret;

}

NPY_NO_EXPORT int

PyArray_SetWritebackIfCopyBase(PyArrayObject *arr, PyArrayObject *base)

{

if (base == NULL) {

PyErr_SetString(PyExc_ValueError,

"Cannot WRITEBACKIFCOPY to NULL array");

return -1;

}

if (PyArray_BASE(arr) != NULL) {

PyErr_SetString(PyExc_ValueError,

"Cannot set array with existing base to WRITEBACKIFCOPY");

goto fail;

}

if (PyArray_FailUnlessWriteable(base, "WRITEBACKIFCOPY base") < 0) {

goto fail;

}

/*

if (PyArray_FLAGS(base) & NPY_ARRAY_WARN_ON_WRITE) {

PyArray_ENABLEFLAGS(arr, NPY_ARRAY_WARN_ON_WRITE);

}

/*

((PyArrayObject_fields *)arr)->base = (PyObject *)base;

PyArray_ENABLEFLAGS(arr, NPY_ARRAY_WRITEBACKIFCOPY);

PyArray_CLEARFLAGS(base, NPY_ARRAY_WRITEABLE);

return 0;

fail:

Py_DECREF(base);

return -1;

}

NPY_NO_EXPORT int

PyArray_SetBaseObject(PyArrayObject *arr, PyObject *obj)

{

if (obj == NULL) {

PyErr_SetString(PyExc_ValueError,

"Cannot set the NumPy array 'base' "

"dependency to NULL after initialization");

return -1;

}

/*

if (PyArray_BASE(arr) != NULL) {

Py_DECREF(obj);

PyErr_SetString(PyExc_ValueError,

"Cannot set the NumPy array 'base' "

"dependency more than once");

return -1;

}

/*

while (PyArray_Check(obj) && (PyObject *)arr != obj) {

PyArrayObject *obj_arr = (PyArrayObject *)obj;

PyObject *tmp;

/* Propagate WARN_ON_WRITE through views. */

if (PyArray_FLAGS(obj_arr) & NPY_ARRAY_WARN_ON_WRITE) {

PyArray_ENABLEFLAGS(arr, NPY_ARRAY_WARN_ON_WRITE);

}

/* If this array owns its own data, stop collapsing */

if (PyArray_CHKFLAGS(obj_arr, NPY_ARRAY_OWNDATA)) {

break;

}

tmp = PyArray_BASE(obj_arr);

/* If there's no base, stop collapsing */

if (tmp == NULL) {

break;

}

/* Stop the collapse new base when the would not be of the same

if (Py_TYPE(tmp) != Py_TYPE(arr)) {

break;

}

Py_INCREF(tmp);

Py_DECREF(obj);

obj = tmp;

}

/* Disallow circular references */

if ((PyObject *)arr == obj) {

Py_DECREF(obj);

PyErr_SetString(PyExc_ValueError,

"Cannot create a circular NumPy array 'base' dependency");

return -1;

}

((PyArrayObject_fields *)arr)->base = obj;

return 0;

}

NPY_NO_EXPORT int

PyArray_CopyObject(PyArrayObject *dest, PyObject *src_object)

{

int ret = 0;

PyArrayObject *view;

PyArray_Descr *dtype = NULL;

int ndim;

npy_intp dims[NPY_MAXDIMS];

coercion_cache_obj *cache = NULL;

/*

ndim = PyArray_DiscoverDTypeAndShape(src_object,

PyArray_NDIM(dest), dims, &cache,

NPY_DTYPE(PyArray_DESCR(dest)), PyArray_DESCR(dest), &dtype);

if (ndim < 0) {

return -1;

}

if (cache != NULL && !(cache->sequence)) {

/* The input is an array or array object, so assign directly */

assert(cache->converted_obj == src_object);

view = (PyArrayObject *)cache->arr_or_sequence;

Py_DECREF(dtype);

ret = PyArray_AssignArray(dest, view, NULL, NPY_UNSAFE_CASTING);

npy_free_coercion_cache(cache);

return ret;

}

/*

if (ndim != PyArray_NDIM(dest) ||

!PyArray_CompareLists(PyArray_DIMS(dest), dims, ndim)) {

/*

assert (ndim <= PyArray_NDIM(dest)); /* would error during discovery */

view = (PyArrayObject *) PyArray_NewFromDescr(

&PyArray_Type, dtype, ndim, dims, NULL, NULL,

PyArray_FLAGS(dest) & NPY_ARRAY_F_CONTIGUOUS, NULL);

if (view == NULL) {

npy_free_coercion_cache(cache);

return -1;

}

}

else {

Py_DECREF(dtype);

view = dest;

}

/* Assign the values to `view` (whichever array that is) */

if (cache == NULL) {

/* single (non-array) item, assign immediately */

if (PyArray_Pack(

PyArray_DESCR(view), PyArray_DATA(view), src_object) < 0) {

goto fail;

}

}

else {

if (PyArray_AssignFromCache(view, cache) < 0) {

goto fail;

}

}

if (view == dest) {

return 0;

}

ret = PyArray_AssignArray(dest, view, NULL, NPY_UNSAFE_CASTING);

Py_DECREF(view);

return ret;

fail:

if (view != dest) {

Py_DECREF(view);

}

return -1;

}

NPY_NO_EXPORT int

PyArray_TypeNumFromName(char const *str)

{

int i;

PyArray_Descr *descr;

for (i = 0; i < NPY_NUMUSERTYPES; i++) {

descr = userdescrs[i];

if (strcmp(descr->typeobj->tp_name, str) == 0) {

return descr->type_num;

}

}

return NPY_NOTYPE;

}

NPY_NO_EXPORT int

PyArray_ResolveWritebackIfCopy(PyArrayObject * self)

{

PyArrayObject_fields *fa = (PyArrayObject_fields *)self;

if (fa && fa->base) {

if ((fa->flags & NPY_ARRAY_UPDATEIFCOPY) || (fa->flags & NPY_ARRAY_WRITEBACKIFCOPY)) {

/*

int retval = 0;

PyArray_ENABLEFLAGS(((PyArrayObject *)fa->base),

NPY_ARRAY_WRITEABLE);

PyArray_CLEARFLAGS(self, NPY_ARRAY_UPDATEIFCOPY);

PyArray_CLEARFLAGS(self, NPY_ARRAY_WRITEBACKIFCOPY);

retval = PyArray_CopyAnyInto((PyArrayObject *)fa->base, self);

Py_DECREF(fa->base);

fa->base = NULL;

if (retval < 0) {

/* this should never happen, how did the two copies of data

return retval;

}

return 1;

}

}

return 0;

}

static NPY_INLINE void

WARN_IN_DEALLOC(PyObject* warning, const char * msg) {

if (PyErr_WarnEx(warning, msg, 1) < 0) {

PyObject * s;

s = PyUnicode_FromString("array_dealloc");

if (s) {

PyErr_WriteUnraisable(s);

Py_DECREF(s);

}

else {

PyErr_WriteUnraisable(Py_None);

}

}

}

static void

array_dealloc(PyArrayObject *self)

{

PyArrayObject_fields *fa = (PyArrayObject_fields *)self;

if (_buffer_info_free(fa->_buffer_info, (PyObject *)self) < 0) {

PyErr_WriteUnraisable(NULL);

}

if (fa->weakreflist != NULL) {

PyObject_ClearWeakRefs((PyObject *)self);

}

if (fa->base) {

int retval;

if (PyArray_FLAGS(self) & NPY_ARRAY_WRITEBACKIFCOPY)

{

char const * msg = "WRITEBACKIFCOPY detected in array_dealloc. "

" Required call to PyArray_ResolveWritebackIfCopy or "

"PyArray_DiscardWritebackIfCopy is missing.";

/*

Py_INCREF(self);

WARN_IN_DEALLOC(PyExc_RuntimeWarning, msg);

retval = PyArray_ResolveWritebackIfCopy(self);

if (retval < 0)

{

PyErr_Print();

PyErr_Clear();

}

}

if (PyArray_FLAGS(self) & NPY_ARRAY_UPDATEIFCOPY) {

/* DEPRECATED, remove once the flag is removed */

char const * msg = "UPDATEIFCOPY detected in array_dealloc. "

" Required call to PyArray_ResolveWritebackIfCopy or "

"PyArray_DiscardWritebackIfCopy is missing";

/*

Py_INCREF(self);

/* 2017-Nov-10 1.14 */

WARN_IN_DEALLOC(PyExc_DeprecationWarning, msg);

retval = PyArray_ResolveWritebackIfCopy(self);

if (retval < 0)

{

PyErr_Print();

PyErr_Clear();

}

}

/*

Py_XDECREF(fa->base);

}

if ((fa->flags & NPY_ARRAY_OWNDATA) && fa->data) {

/* Free internal references if an Object array */

if (PyDataType_FLAGCHK(fa->descr, NPY_ITEM_REFCOUNT)) {

PyArray_XDECREF(self);

}

npy_free_cache(fa->data, PyArray_NBYTES(self));

}

/* must match allocation in PyArray_NewFromDescr */

npy_free_cache_dim(fa->dimensions, 2 * fa->nd);

Py_DECREF(fa->descr);

Py_TYPE(self)->tp_free((PyObject *)self);

}

NPY_NO_EXPORT void

PyArray_DebugPrint(PyArrayObject *obj)

{

int i;

PyArrayObject_fields *fobj = (PyArrayObject_fields *)obj;

printf("-------------------------------------------------------\n");

printf(" Dump of NumPy ndarray at address %p\n", obj);

if (obj == NULL) {

printf(" It's NULL!\n");

printf("-------------------------------------------------------\n");

fflush(stdout);

return;

}

printf(" ndim : %d\n", fobj->nd);

printf(" shape :");

for (i = 0; i < fobj->nd; ++i) {

printf(" %" NPY_INTP_FMT, fobj->dimensions[i]);

}

printf("\n");

printf(" dtype : ");

PyObject_Print((PyObject *)fobj->descr, stdout, 0);

printf("\n");

printf(" data : %p\n", fobj->data);

printf(" strides:");

for (i = 0; i < fobj->nd; ++i) {

printf(" %" NPY_INTP_FMT, fobj->strides[i]);

}

printf("\n");

printf(" base : %p\n", fobj->base);

printf(" flags :");

if (fobj->flags & NPY_ARRAY_C_CONTIGUOUS)

printf(" NPY_C_CONTIGUOUS");

if (fobj->flags & NPY_ARRAY_F_CONTIGUOUS)

printf(" NPY_F_CONTIGUOUS");

if (fobj->flags & NPY_ARRAY_OWNDATA)

printf(" NPY_OWNDATA");

if (fobj->flags & NPY_ARRAY_ALIGNED)

printf(" NPY_ALIGNED");

if (fobj->flags & NPY_ARRAY_WRITEABLE)

printf(" NPY_WRITEABLE");

if (fobj->flags & NPY_ARRAY_UPDATEIFCOPY)

printf(" NPY_UPDATEIFCOPY");

if (fobj->flags & NPY_ARRAY_WRITEBACKIFCOPY)

printf(" NPY_WRITEBACKIFCOPY");

printf("\n");

if (fobj->base != NULL && PyArray_Check(fobj->base)) {

printf("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");

printf("Dump of array's BASE:\n");

PyArray_DebugPrint((PyArrayObject *)fobj->base);

printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");

}

printf("-------------------------------------------------------\n");

fflush(stdout);

}

NPY_NO_EXPORT void

PyArray_SetDatetimeParseFunction(PyObject *NPY_UNUSED(op))

{

}

NPY_NO_EXPORT int

PyArray_CompareUCS4(npy_ucs4 const *s1, npy_ucs4 const *s2, size_t len)

{

npy_ucs4 c1, c2;

while(len-- > 0) {

c1 = *s1++;

c2 = *s2++;

if (c1 != c2) {

return (c1 < c2) ? -1 : 1;

}

}

return 0;

}

NPY_NO_EXPORT int

PyArray_CompareString(const char *s1, const char *s2, size_t len)

{

const unsigned char *c1 = (unsigned char *)s1;

const unsigned char *c2 = (unsigned char *)s2;

size_t i;

for(i = 0; i < len; ++i) {

if (c1[i] != c2[i]) {

return (c1[i] > c2[i]) ? 1 : -1;

}

}

return 0;

}

NPY_NO_EXPORT int

array_might_be_written(PyArrayObject *obj)

{

const char *msg =

"Numpy has detected that you (may be) writing to an array with\n"

"overlapping memory from np.broadcast_arrays. If this is intentional\n"

"set the WRITEABLE flag True or make a copy immediately before writing.";

if (PyArray_FLAGS(obj) & NPY_ARRAY_WARN_ON_WRITE) {

if (DEPRECATE(msg) < 0) {

return -1;

}

/* Only warn once per array */

while (1) {

PyArray_CLEARFLAGS(obj, NPY_ARRAY_WARN_ON_WRITE);

if (!PyArray_BASE(obj) || !PyArray_Check(PyArray_BASE(obj))) {

break;

}

obj = (PyArrayObject *)PyArray_BASE(obj);

}

}

return 0;

}

NPY_NO_EXPORT int

PyArray_FailUnlessWriteable(PyArrayObject *obj, const char *name)

{

if (!PyArray_ISWRITEABLE(obj)) {

PyErr_Format(PyExc_ValueError, "%s is read-only", name);

return -1;

}

if (array_might_be_written(obj) < 0) {

return -1;

}

return 0;

}

static int

_myunincmp(npy_ucs4 const *s1, npy_ucs4 const *s2, int len1, int len2)

{

npy_ucs4 const *sptr;

npy_ucs4 *s1t = NULL;

npy_ucs4 *s2t = NULL;

int val;

npy_intp size;

int diff;

/* Replace `s1` and `s2` with aligned copies if needed */

if ((npy_intp)s1 % sizeof(npy_ucs4) != 0) {

size = len1*sizeof(npy_ucs4);

s1t = malloc(size);

memcpy(s1t, s1, size);

s1 = s1t;

}

if ((npy_intp)s2 % sizeof(npy_ucs4) != 0) {

size = len2*sizeof(npy_ucs4);

s2t = malloc(size);

memcpy(s2t, s2, size);

s2 = s1t;

}

val = PyArray_CompareUCS4(s1, s2, PyArray_MIN(len1,len2));

if ((val != 0) || (len1 == len2)) {

goto finish;

}

if (len2 > len1) {

sptr = s2+len1;

val = -1;

diff = len2-len1;

}

else {

sptr = s1+len2;

val = 1;

diff=len1-len2;

}

while (diff--) {

if (*sptr != 0) {

goto finish;

}

sptr++;

}

val = 0;

finish:

/* Cleanup the aligned copies */

if (s1t) {

free(s1t);

}

if (s2t) {

free(s2t);

}

return val;

}

static int

_mystrncmp(char const *s1, char const *s2, int len1, int len2)

{

char const *sptr;

int val;

int diff;

val = memcmp(s1, s2, PyArray_MIN(len1, len2));

if ((val != 0) || (len1 == len2)) {

return val;

}

if (len2 > len1) {

sptr = s2 + len1;

val = -1;

diff = len2 - len1;

}

else {

sptr = s1 + len2;

val = 1;

diff = len1 - len2;

}

while (diff--) {

if (*sptr != 0) {

return val;

}

sptr++;

}

return 0; /* Only happens if NULLs are everywhere */

}

#define SMALL_STRING 2048

static void _rstripw(char *s, int n)

{

int i;

for (i = n - 1; i >= 1; i--) { /* Never strip to length 0. */

int c = s[i];

if (!c || NumPyOS_ascii_isspace((int)c)) {

s[i] = 0;

}

else {

break;

}

}

}

static void _unistripw(npy_ucs4 *s, int n)

{

int i;

for (i = n - 1; i >= 1; i--) { /* Never strip to length 0. */

npy_ucs4 c = s[i];

if (!c || NumPyOS_ascii_isspace((int)c)) {

s[i] = 0;

}

else {

break;

}

}

}

static char *

_char_copy_n_strip(char const *original, char *temp, int nc)

{

if (nc > SMALL_STRING) {

temp = malloc(nc);

if (!temp) {

PyErr_NoMemory();

return NULL;

}

}

memcpy(temp, original, nc);

_rstripw(temp, nc);

return temp;

}

static void

_char_release(char *ptr, int nc)

{

if (nc > SMALL_STRING) {

free(ptr);

}

}

static char *

_uni_copy_n_strip(char const *original, char *temp, int nc)

{

if (nc*sizeof(npy_ucs4) > SMALL_STRING) {

temp = malloc(nc*sizeof(npy_ucs4));

if (!temp) {

PyErr_NoMemory();

return NULL;

}

}

memcpy(temp, original, nc*sizeof(npy_ucs4));

_unistripw((npy_ucs4 *)temp, nc);

return temp;

}

static void

_uni_release(char *ptr, int nc)

{

if (nc*sizeof(npy_ucs4) > SMALL_STRING) {

free(ptr);

}

}

#define _rstrip_loop(CMP) { \

void *aptr, *bptr; \

char atemp[SMALL_STRING], btemp[SMALL_STRING]; \

while(size--) { \

aptr = stripfunc(iself->dataptr, atemp, N1); \

if (!aptr) return -1; \

bptr = stripfunc(iother->dataptr, btemp, N2); \

if (!bptr) { \

relfunc(aptr, N1); \

return -1; \

} \

val = compfunc(aptr, bptr, N1, N2); \

*dptr = (val CMP 0); \

PyArray_ITER_NEXT(iself); \

PyArray_ITER_NEXT(iother); \

dptr += 1; \

relfunc(aptr, N1); \

relfunc(bptr, N2); \

} \

}

#define _reg_loop(CMP) { \

while(size--) { \

val = compfunc((void *)iself->dataptr, \

(void *)iother->dataptr, \

N1, N2); \

*dptr = (val CMP 0); \

PyArray_ITER_NEXT(iself); \

PyArray_ITER_NEXT(iother); \

dptr += 1; \

} \

}

static int

_compare_strings(PyArrayObject *result, PyArrayMultiIterObject *multi,

int cmp_op, void *func, int rstrip)

{

PyArrayIterObject *iself, *iother;

npy_bool *dptr;

npy_intp size;

int val;

int N1, N2;

int (*compfunc)(void *, void *, int, int);

void (*relfunc)(char *, int);

char* (*stripfunc)(char const *, char *, int);

compfunc = func;

dptr = (npy_bool *)PyArray_DATA(result);

iself = multi->iters[0];

iother = multi->iters[1];

size = multi->size;

N1 = PyArray_DESCR(iself->ao)->elsize;

N2 = PyArray_DESCR(iother->ao)->elsize;

if ((void *)compfunc == (void *)_myunincmp) {

N1 >>= 2;

N2 >>= 2;

stripfunc = _uni_copy_n_strip;

relfunc = _uni_release;

}

else {

stripfunc = _char_copy_n_strip;

relfunc = _char_release;

}

switch (cmp_op) {

case Py_EQ:

if (rstrip) {

_rstrip_loop(==);

} else {

_reg_loop(==);

}

break;

case Py_NE:

if (rstrip) {

_rstrip_loop(!=);

} else {

_reg_loop(!=);

}

break;

case Py_LT:

if (rstrip) {

_rstrip_loop(<);

} else {

_reg_loop(<);

}

break;

case Py_LE:

if (rstrip) {

_rstrip_loop(<=);

} else {

_reg_loop(<=);

}

break;

case Py_GT:

if (rstrip) {

_rstrip_loop(>);

} else {

_reg_loop(>);

}

break;

case Py_GE:

if (rstrip) {

_rstrip_loop(>=);

} else {

_reg_loop(>=);

}

break;

default:

PyErr_SetString(PyExc_RuntimeError, "bad comparison operator");

return -1;

}

return 0;

}

#undef _reg_loop

#undef _rstrip_loop

#undef SMALL_STRING

NPY_NO_EXPORT PyObject *

_strings_richcompare(PyArrayObject *self, PyArrayObject *other, int cmp_op,

int rstrip)

{

PyArrayObject *result;

PyArrayMultiIterObject *mit;

int val;

if (PyArray_TYPE(self) != PyArray_TYPE(other)) {

/*

Py_INCREF(Py_NotImplemented);

return Py_NotImplemented;

}

if (PyArray_ISNOTSWAPPED(self) != PyArray_ISNOTSWAPPED(other)) {

/* Cast `other` to the same byte order as `self` (both unicode here) */

PyArray_Descr* unicode = PyArray_DescrNew(PyArray_DESCR(self));

unicode->elsize = PyArray_DESCR(other)->elsize;

PyObject *new = PyArray_FromAny((PyObject *)other,

unicode, 0, 0, 0, NULL);

if (new == NULL) {

return NULL;

}

other = (PyArrayObject *)new;

}

else {

Py_INCREF(other);

}

/* Broad-cast the arrays to a common shape */

mit = (PyArrayMultiIterObject *)PyArray_MultiIterNew(2, self, other);

Py_DECREF(other);