static PyObject *
gentype_richcompare(PyObject *self, PyObject *other, int cmp_op)
{
PyObject *arr, *ret;
arr = PyArray_FromScalar(self, NULL);
if (arr == NULL) {
return NULL;
}
ret = Py_TYPE(arr)->tp_richcompare(arr, other, cmp_op);
Py_DECREF(arr);
return ret;
}
/*NUMPY_API*/
NPY_NO_EXPORT intp
PyArray_PyIntAsIntp(PyObject *o)
{
longlong long_value = -1;
PyObject *obj;
static char *msg = "an integer is required";
PyObject *arr;
PyArray_Descr *descr;
intp ret;
if (!o) {
PyErr_SetString(PyExc_TypeError, msg);
return -1;
}
if (PyInt_Check(o)) {
long_value = (longlong) PyInt_AS_LONG(o);
goto finish;
} else if (PyLong_Check(o)) {
long_value = (longlong) PyLong_AsLongLong(o);
goto finish;
}
#if SIZEOF_INTP == SIZEOF_LONG
descr = &LONG_Descr;
#elif SIZEOF_INTP == SIZEOF_INT
descr = &INT_Descr;
#else
descr = &LONGLONG_Descr;
#endif
arr = NULL;
if (PyArray_Check(o)) {
if (PyArray_SIZE(o)!=1 || !PyArray_ISINTEGER(o)) {
PyErr_SetString(PyExc_TypeError, msg);
return -1;
}
Py_INCREF(descr);
arr = PyArray_CastToType((PyArrayObject *)o, descr, 0);
}
else if (PyArray_IsScalar(o, Integer)) {
Py_INCREF(descr);
arr = PyArray_FromScalar(o, descr);
}
if (arr != NULL) {
ret = *((intp *)PyArray_DATA(arr));
Py_DECREF(arr);
return ret;
}
#if (PY_VERSION_HEX >= 0x02050000)
if (PyIndex_Check(o)) {
PyObject* value = PyNumber_Index(o);
if (value == NULL) {
return -1;
}
long_value = (longlong) PyInt_AsSsize_t(value);
goto finish;
}
#endif
#if !defined(NPY_PY3K)
if (Py_TYPE(o)->tp_as_number != NULL && \
Py_TYPE(o)->tp_as_number->nb_long != NULL) {
obj = Py_TYPE(o)->tp_as_number->nb_long(o);
if (obj != NULL) {
long_value = (longlong) PyLong_AsLongLong(obj);
Py_DECREF(obj);
}
}
else
#endif
if (Py_TYPE(o)->tp_as_number != NULL && \
Py_TYPE(o)->tp_as_number->nb_int != NULL) {
obj = Py_TYPE(o)->tp_as_number->nb_int(o);
if (obj != NULL) {
long_value = (longlong) PyLong_AsLongLong(obj);
Py_DECREF(obj);
}
}
else {
PyErr_SetString(PyExc_NotImplementedError,"");
}
finish:
if error_converting(long_value) {
PyErr_SetString(PyExc_TypeError, msg);
return -1;
}
#if (SIZEOF_LONGLONG > SIZEOF_INTP)
if ((long_value < MIN_INTP) || (long_value > MAX_INTP)) {
PyErr_SetString(PyExc_ValueError,
"integer won't fit into a C intp");
return -1;
}
#endif
return (intp) long_value;
}
/*NUMPY_API*/
NPY_NO_EXPORT int
PyArray_CopyObject(PyArrayObject *dest, PyObject *src_object)
{
int ret;
PyArrayObject *src;
PyArray_Descr *dtype = NULL;
int ndim = 0;
npy_intp dims[NPY_MAXDIMS];
Py_INCREF(src_object);
/*
* Special code to mimic Numeric behavior for
* character arrays.
*/
if (dest->descr->type == PyArray_CHARLTR && dest->nd > 0 \
&& PyString_Check(src_object)) {
npy_intp n_new, n_old;
char *new_string;
PyObject *tmp;
n_new = dest->dimensions[dest->nd-1];
n_old = PyString_Size(src_object);
if (n_new > n_old) {
new_string = (char *)malloc(n_new);
memmove(new_string, PyString_AS_STRING(src_object), n_old);
memset(new_string + n_old, ' ', n_new - n_old);
tmp = PyString_FromStringAndSize(new_string, n_new);
free(new_string);
Py_DECREF(src_object);
src_object = tmp;
}
}
/*
* Get either an array object we can copy from, or its parameters
* if there isn't a convenient array available.
*/
if (PyArray_GetArrayParamsFromObject(src_object, PyArray_DESCR(dest),
0, &dtype, &ndim, dims, &src, NULL) < 0) {
Py_DECREF(src_object);
return -1;
}
/* If it's not an array, either assign from a sequence or as a scalar */
if (src == NULL) {
/* If the input is scalar */
if (ndim == 0) {
/* If there's one dest element and src is a Python scalar */
if (PyArray_IsScalar(src_object, Generic)) {
src = (PyArrayObject *)PyArray_FromScalar(src_object, dtype);
if (src == NULL) {
Py_DECREF(src_object);
return -1;
}
}
else {
if (PyArray_SIZE(dest) == 1) {
Py_DECREF(dtype);
return PyArray_DESCR(dest)->f->setitem(src_object,
PyArray_DATA(dest), dest);
}
else {
src = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type,
dtype, 0, NULL, NULL,
NULL, 0, NULL);
if (src == NULL) {
Py_DECREF(src_object);
return -1;
}
if (PyArray_DESCR(src)->f->setitem(src_object,
PyArray_DATA(src), src) < 0) {
Py_DECREF(src_object);
Py_DECREF(src);
return -1;
}
}
}
}
else {
/*
* If there are more than enough dims, use AssignFromSequence
* because it can handle this style of broadcasting.
*/
if (ndim >= PyArray_NDIM(dest)) {
int res;
Py_DECREF(dtype);
res = PyArray_AssignFromSequence(dest, src_object);
Py_DECREF(src_object);
return res;
}
/* Otherwise convert to an array and do an array-based copy */
src = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type,
dtype, ndim, dims, NULL, NULL,
PyArray_ISFORTRAN(dest), NULL);
if (src == NULL) {
Py_DECREF(src_object);
return -1;
}
if (PyArray_AssignFromSequence(src, src_object) < 0) {
Py_DECREF(src);
Py_DECREF(src_object);
return -1;
}
}
}
/* If it's an array, do a move (handling possible overlapping data) */
ret = PyArray_MoveInto(dest, src);
Py_DECREF(src);
Py_DECREF(src_object);
return ret;
}
