PyObject* multi_axpy(PyObject *self, PyObject *args)
{
PyArrayObject* alpha;
PyArrayObject* x;
PyArrayObject* y;
if (!PyArg_ParseTuple(args, "OOO", &alpha, &x, &y))
return NULL;
int n0 = PyArray_DIMS(x)[0];
int n = PyArray_DIMS(x)[1];
for (int d = 2; d < PyArray_NDIM(x); d++)
n *= PyArray_DIMS(x)[d];
int incx = 1;
int incy = 1;
if (PyArray_DESCR(alpha)->type_num == NPY_DOUBLE)
{
if (PyArray_DESCR(x)->type_num == NPY_CDOUBLE)
n *= 2;
double *ap = DOUBLEP(alpha);
double *xp = DOUBLEP(x);
double *yp = DOUBLEP(y);
for (int i = 0; i < n0; i++)
{
daxpy_(&n, &ap[i],
(void*)xp, &incx,
(void*)yp, &incy);
xp += n;
yp += n;
}
}
else
{
double_complex *ap = COMPLEXP(alpha);
double_complex *xp = COMPLEXP(x);
double_complex *yp = COMPLEXP(y);
for (int i = 0; i < n0; i++)
{
zaxpy_(&n, (void*)(&ap[i]),
(void*)xp, &incx,
(void*)yp, &incy);
xp += n;
yp += n;
}
}
Py_RETURN_NONE;
}
int NCFormat_from_spMatrix(SuperMatrix * A, int m, int n, int nnz,
PyArrayObject * nzvals, PyArrayObject * rowind,
PyArrayObject * colptr, int typenum)
{
int ok = 0;
ok = (PyArray_EquivTypenums(PyArray_DESCR(nzvals)->type_num, typenum) &&
PyArray_EquivTypenums(PyArray_DESCR(rowind)->type_num, NPY_INT) &&
PyArray_EquivTypenums(PyArray_DESCR(colptr)->type_num, NPY_INT) &&
PyArray_NDIM(nzvals) == 1 &&
PyArray_NDIM(rowind) == 1 &&
PyArray_NDIM(colptr) == 1 &&
PyArray_IS_C_CONTIGUOUS(nzvals) &&
PyArray_IS_C_CONTIGUOUS(rowind) &&
PyArray_IS_C_CONTIGUOUS(colptr) &&
nnz <= PyArray_DIM(nzvals, 0) &&
nnz <= PyArray_DIM(rowind, 0) &&
n+1 <= PyArray_DIM(colptr, 0));
if (!ok) {
PyErr_SetString(PyExc_ValueError,
"sparse matrix arrays must be 1-D C-contiguous and of proper "
"sizes and types");
return -1;
}
if (setjmp(_superlu_py_jmpbuf))
return -1;
else {
if (!CHECK_SLU_TYPE(nzvals->descr->type_num)) {
PyErr_SetString(PyExc_TypeError, "Invalid type for array.");
return -1;
}
Create_CompCol_Matrix(nzvals->descr->type_num,
A, m, n, nnz, nzvals->data,
(int *) rowind->data, (int *) colptr->data,
SLU_NC,
NPY_TYPECODE_TO_SLU(nzvals->descr->type_num),
SLU_GE);
}
return 0;
}
/* evaluates if given array is non-empty 1D NumPy with double elements */
int is1DDoubleArray(PyArrayObject* x)
{
if (!(PyArray_NDIM(x) == 1 && PyArray_DIM(x, 0) > 0 &&
PyArray_DESCR(x)->type_num == NPY_DOUBLE)) {
PyErr_SetString(PyExc_ValueError,
"Array(s) must be non-empty 1D array of type Float");
return 0;
} else
return 1;
}
static PyObject *
array_index(PyArrayObject *v)
{
if (!PyArray_ISINTEGER(v) || PyArray_SIZE(v) != 1) {
PyErr_SetString(PyExc_TypeError, "only integer arrays with " \
"one element can be converted to an index");
return NULL;
}
return PyArray_DESCR(v)->f->getitem(PyArray_DATA(v), v);
}
NPY_NO_EXPORT PyObject *
array_int(PyArrayObject *v)
{
PyObject *pv, *pv2;
if (PyArray_SIZE(v) != 1) {
PyErr_SetString(PyExc_TypeError, "only length-1 arrays can be"\
" converted to Python scalars");
return NULL;
}
pv = PyArray_DESCR(v)->f->getitem(PyArray_DATA(v), v);
if (pv == NULL) {
return NULL;
}
if (Py_TYPE(pv)->tp_as_number == 0) {
PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\
"scalar object is not a number");
Py_DECREF(pv);
return NULL;
}
if (Py_TYPE(pv)->tp_as_number->nb_int == 0) {
PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
"scalar number to int");
Py_DECREF(pv);
return NULL;
}
/*
* If we still got an array which can hold references, stop
* because it could point back at 'v'.
*/
if (PyArray_Check(pv) &&
PyDataType_REFCHK(PyArray_DESCR((PyArrayObject *)pv))) {
PyErr_SetString(PyExc_TypeError,
"object array may be self-referencing");
Py_DECREF(pv);
return NULL;
}
pv2 = Py_TYPE(pv)->tp_as_number->nb_int(pv);
Py_DECREF(pv);
return pv2;
}
static PyObject *
array_repr_builtin(PyArrayObject *self, int repr)
{
PyObject *ret;
char *string;
/* max_n initial value is arbitrary, dump_data will extend it */
Py_ssize_t n = 0, max_n = PyArray_NBYTES(self) * 4 + 7;
if ((string = PyArray_malloc(max_n)) == NULL) {
return PyErr_NoMemory();
}
if (dump_data(&string, &n, &max_n, PyArray_DATA(self),
PyArray_NDIM(self), PyArray_DIMS(self),
PyArray_STRIDES(self), self) < 0) {
PyArray_free(string);
return NULL;
}
if (repr) {
if (PyArray_ISEXTENDED(self)) {
ret = PyUString_FromFormat("array(%s, '%c%d')",
string,
PyArray_DESCR(self)->type,
PyArray_DESCR(self)->elsize);
}
else {
ret = PyUString_FromFormat("array(%s, '%c')",
string,
PyArray_DESCR(self)->type);
}
}
else {
ret = PyUString_FromStringAndSize(string, n);
}
PyArray_free(string);
return ret;
}
//initialization of BallTree object
// argument is a single array of size [D,N]
static int
BallTree_init(BallTreeObject *self, PyObject *args, PyObject *kwds){
//we use goto statements : all variables should be declared up front
PyObject *arg=NULL;
PyObject *arr=NULL;
long int leaf_size=20;
static char *kwlist[] = {"x", "leafsize", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|l", kwlist,
&arg,&leaf_size) )
goto fail;
if(leaf_size <= 0){
PyErr_SetString(PyExc_ValueError,
"BallTree : leaf size must be greater than zero");
goto fail;
}
//view this object as an array of doubles,
arr = PyArray_FROM_OTF(arg,NPY_DOUBLE,0);
if(arr==NULL)
goto fail;
//check that it is 2D
if( PyArray_NDIM(arr) != 2)
goto fail;
if(self != NULL){
//create the list of points
self->size = PyArray_DIMS(arr)[0];
self->dim = PyArray_DIMS(arr)[1];
int inc = PyArray_STRIDES(arr)[1]/PyArray_DESCR(arr)->elsize;
self->Points = new std::vector<BallTree_Point*>(self->size);
for(int i=0;i<self->size;i++)
self->Points->at(i) = new BallTree_Point(arr,
(double*)PyArray_GETPTR2(arr,i,0),
inc, PyArray_DIM(arr,1));
self->tree = new BallTree<BallTree_Point>(*(self->Points),
leaf_size);
}
self->data = arr;
//Py_DECREF(arr);
return 0;
fail:
Py_XDECREF(arr);
return -1;
}
/*
* 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;
}
static PyObject * merge(PyObject * self,
PyObject * args, PyObject * kwds) {
static char * kwlist[] = {
"data", "A", "B", "out", NULL
};
PyArrayObject * data, * A, * B, * out;
if(!PyArg_ParseTupleAndKeywords(args, kwds,
"O!O!O!O!", kwlist,
&PyArray_Type, &data,
&PyArray_Type, &A,
&PyArray_Type, &B,
&PyArray_Type, &out)) return NULL;
npy_intp i = 0;
int (*compare)(void *, void *, void*) = PyArray_DESCR(data)->f->compare;
size_t sizeA = PyArray_SIZE(A);
size_t sizeB = PyArray_SIZE(B);
npy_intp * Aptr = PyArray_DATA(A);
npy_intp * Aend = Aptr + sizeA;
npy_intp * Bptr = PyArray_DATA(B);
npy_intp * Bend = Bptr + sizeB;
npy_intp * Optr = PyArray_DATA(out);
#define VA PyArray_GETPTR1(data, *Aptr)
#define VB PyArray_GETPTR1(data, (*Bptr) + sizeA)
Py_BEGIN_ALLOW_THREADS
while(Aptr < Aend|| Bptr < Bend) {
while(Aptr < Aend && (Bptr == Bend || compare(VA, VB, data) <= 0)) {
*Optr = *Aptr;
Aptr++;
Optr++;
//printf("adding from A, i = %ld, k = %ld v = %ld\n", i, k, v);
}
while(Bptr < Bend && (Aptr == Aend || compare(VA, VB, data) >= 0)) {
*Optr = *Bptr + sizeA;
Bptr++;
Optr++;
//printf("adding from B, j = %ld, k = %ld v = %ld\n", j, k, v);
}
}
Py_END_ALLOW_THREADS
Py_INCREF(Py_None);
return Py_None;
}
PyObject* gemm(PyObject *self, PyObject *args)
{
Py_complex alpha;
PyArrayObject* a;
PyArrayObject* b;
Py_complex beta;
PyArrayObject* c;
char transa = 'n';
if (!PyArg_ParseTuple(args, "DOODO|c", &alpha, &a, &b, &beta, &c, &transa))
return NULL;
int m, k, lda, ldb, ldc;
if (transa == 'n')
{
m = PyArray_DIMS(a)[1];
for (int i = 2; i < PyArray_NDIM(a); i++)
m *= PyArray_DIMS(a)[i];
k = PyArray_DIMS(a)[0];
lda = MAX(1, PyArray_STRIDES(a)[0] / PyArray_STRIDES(a)[PyArray_NDIM(a) - 1]);
ldb = MAX(1, PyArray_STRIDES(b)[0] / PyArray_STRIDES(b)[1]);
ldc = MAX(1, PyArray_STRIDES(c)[0] / PyArray_STRIDES(c)[PyArray_NDIM(c) - 1]);
}
else
{
k = PyArray_DIMS(a)[1];
for (int i = 2; i < PyArray_NDIM(a); i++)
k *= PyArray_DIMS(a)[i];
m = PyArray_DIMS(a)[0];
lda = MAX(1, k);
ldb = MAX(1, PyArray_STRIDES(b)[0] / PyArray_STRIDES(b)[PyArray_NDIM(b) - 1]);
ldc = MAX(1, PyArray_STRIDES(c)[0] / PyArray_STRIDES(c)[1]);
}
int n = PyArray_DIMS(b)[0];
if (PyArray_DESCR(a)->type_num == NPY_DOUBLE)
dgemm_(&transa, "n", &m, &n, &k,
&(alpha.real),
DOUBLEP(a), &lda,
DOUBLEP(b), &ldb,
&(beta.real),
DOUBLEP(c), &ldc);
else
zgemm_(&transa, "n", &m, &n, &k,
&alpha,
(void*)COMPLEXP(a), &lda,
(void*)COMPLEXP(b), &ldb,
&beta,
(void*)COMPLEXP(c), &ldc);
Py_RETURN_NONE;
}
/*NUMPY_API
* Min
*/
NPY_NO_EXPORT PyObject *
PyArray_Min(PyArrayObject *ap, int axis, PyArrayObject *out)
{
PyArrayObject *arr;
PyObject *ret;
arr=(PyArrayObject *)PyArray_CheckAxis(ap, &axis, 0);
if (arr == NULL) {
return NULL;
}
ret = PyArray_GenericReduceFunction(arr, n_ops.minimum, axis,
PyArray_DESCR(arr)->type_num, out);
Py_DECREF(arr);
return ret;
}
int checkArray(PyObject *check, const char* name) {
if(check==NULL) {
PyErr_SetString(PyExc_ValueError, "Unspecified array in kdtree");
return 1;
}
PyArray_Descr *descr = PyArray_DESCR(check);
if(descr==NULL || descr->kind!='f' || descr->elsize!=sizeof(T)) {
PyErr_Format(PyExc_TypeError, "Incorrect numpy data type for %s passed to kdtree - must match C %s",name,c_name<T>());
return 1;
}
return 0;
}
int getBitDepth(PyObject *check) {
if(check==NULL) {
return 0;
}
PyArray_Descr *descr = PyArray_DESCR(check);
if(descr!=NULL && descr->kind=='f' && descr->elsize==sizeof(float))
return 32;
else if(descr!=NULL && descr->kind=='f' && descr->elsize==sizeof(double))
return 64;
else
return 0;
}
const char* getTypeDesc( void* arr ) {
PyArray_Descr *desc = PyArray_DESCR( arr );
if( desc != NULL ) {
switch( desc->kind ) {
case 'b' : return " boolean";
case 'i' : return " signed integer";
case 'u' : return " unsigned integer";
case 'f' : return " floating point";
case 'c' : return " complex floating point";
case 'S' : return " 8-bit character string";
case 'U' : return " 32-bit/character unicode string.";
case 'V' : return " arbitrary.";
}
}
return "unknown.";
}
static PyObject *
array_index(PyArrayObject *v)
{
if (!PyArray_ISINTEGER(v) || PyArray_SIZE(v) != 1) {
PyErr_SetString(PyExc_TypeError, "only integer arrays with " \
"one element can be converted to an index");
return NULL;
}
if (PyArray_NDIM(v) != 0) {
if (DEPRECATE("converting an array with ndim > 0 to an index"
" will result in an error in the future") < 0) {
return NULL;
}
}
return PyArray_DESCR(v)->f->getitem(PyArray_DATA(v), v);
}
static PyObject *sps_putdatarow(PyObject *self, PyObject *args)
{
char *spec_version, *array_name;
int ptype, stype;
PyObject *in_src;
PyArrayObject *src;
int no_items;
int in_row;
if (!PyArg_ParseTuple(args, "ssiO", &spec_version, &array_name, &in_row,
&in_src)) {
return NULL;
}
if (!(src = (PyArrayObject*) PyArray_ContiguousFromObject(in_src,
NPY_NOTYPE, 1, 1))) {
struct module_state *st = GETSTATE(self);
PyErr_SetString(st->SPSError, "Input Array is not a 1 dim array");
return NULL;
}
ptype = PyArray_DESCR(src)->type_num;
stype = sps_py2type(ptype);
if (ptype == -1) {
struct module_state *st = GETSTATE(self);
PyErr_SetString(st->SPSError, "Type of data in shared memory not supported");
Py_DECREF(src);
return NULL;
}
no_items = (int) (PyArray_DIMS(src)[0]);
if (SPS_CopyRowToShared(spec_version, array_name, PyArray_DATA(src), stype,
in_row, no_items, NULL)
== -1) {
struct module_state *st = GETSTATE(self);
PyErr_SetString(st->SPSError, "Error copying data to shared memory");
Py_DECREF(src);
return NULL;
}else
Py_DECREF(src);
Py_INCREF(Py_None);
return Py_None;
}
static void
_default_copyswapn(void *dst, npy_intp dstride, void *src,
npy_intp sstride, npy_intp n, int swap, void *arr)
{
npy_intp i;
PyArray_CopySwapFunc *copyswap;
char *dstptr = dst;
char *srcptr = src;
copyswap = PyArray_DESCR(arr)->f->copyswap;
for (i = 0; i < n; i++) {
copyswap(dstptr, srcptr, swap, arr);
dstptr += dstride;
srcptr += sstride;
}
}
void _copyTransform(const PyArrayObject *transMat, RDGeom::Transform3D &trans) {
unsigned int nrows = PyArray_DIM(transMat, 0);
unsigned int ncols = PyArray_DIM(transMat, 1);
if ((nrows != 4) || (ncols != 4)) {
throw_value_error("The transform has to be square matrix, of size 4x4");
}
if (PyArray_DESCR(const_cast<PyArrayObject *>(transMat))->type_num !=
NPY_DOUBLE)
throw_value_error("Only double arrays allowed for transform object ");
unsigned int dSize = nrows * nrows;
const double *inData = reinterpret_cast<const double *>(
PyArray_DATA(const_cast<PyArrayObject *>(transMat)));
double *tData = trans.getData();
memcpy(static_cast<void *>(tData), static_cast<const void *>(inData),
dSize * sizeof(double));
}
/* Fill in the info structure */
static _buffer_info_t*
_buffer_info_new(PyArrayObject *arr)
{
_buffer_info_t *info;
_tmp_string_t fmt = {NULL, 0, 0};
int k;
info = malloc(sizeof(_buffer_info_t));
if (info == NULL) {
goto fail;
}
/* Fill in format */
if (_buffer_format_string(PyArray_DESCR(arr), &fmt, arr, NULL, NULL) != 0) {
free(fmt.s);
goto fail;
}
_append_char(&fmt, '\0');
info->format = fmt.s;
/* Fill in shape and strides */
info->ndim = PyArray_NDIM(arr);
if (info->ndim == 0) {
info->shape = NULL;
info->strides = NULL;
}
else {
info->shape = malloc(sizeof(Py_ssize_t) * PyArray_NDIM(arr) * 2 + 1);
if (info->shape == NULL) {
goto fail;
}
info->strides = info->shape + PyArray_NDIM(arr);
for (k = 0; k < PyArray_NDIM(arr); ++k) {
info->shape[k] = PyArray_DIMS(arr)[k];
info->strides[k] = PyArray_STRIDES(arr)[k];
}
}
return info;
fail:
free(info);
return NULL;
}
PyObject* scal(PyObject *self, PyObject *args)
{
Py_complex alpha;
PyArrayObject* x;
if (!PyArg_ParseTuple(args, "DO", &alpha, &x))
return NULL;
int n = PyArray_DIMS(x)[0];
for (int d = 1; d < PyArray_NDIM(x); d++)
n *= PyArray_DIMS(x)[d];
int incx = 1;
if (PyArray_DESCR(x)->type_num == NPY_DOUBLE)
dscal_(&n, &(alpha.real), DOUBLEP(x), &incx);
else
zscal_(&n, &alpha, (void*)COMPLEXP(x), &incx);
Py_RETURN_NONE;
}
NPY_NO_EXPORT int
_zerofill(PyArrayObject *ret)
{
if (PyDataType_REFCHK(PyArray_DESCR(ret))) {
PyObject *zero = PyInt_FromLong(0);
PyArray_FillObjectArray(ret, zero);
Py_DECREF(zero);
if (PyErr_Occurred()) {
Py_DECREF(ret);
return -1;
}
}
else {
npy_intp n = PyArray_NBYTES(ret);
memset(PyArray_DATA(ret), 0, n);
}
return 0;
}
PyObject* multi_dotu(PyObject *self, PyObject *args)
{
PyArrayObject* a;
PyArrayObject* b;
PyArrayObject* c;
if (!PyArg_ParseTuple(args, "OOO", &a, &b, &c))
return NULL;
int n0 = PyArray_DIMS(a)[0];
int n = PyArray_DIMS(a)[1];
for (int i = 2; i < PyArray_NDIM(a); i++)
n *= PyArray_DIMS(a)[i];
int incx = 1;
int incy = 1;
if (PyArray_DESCR(a)->type_num == NPY_DOUBLE)
{
double *ap = DOUBLEP(a);
double *bp = DOUBLEP(b);
double *cp = DOUBLEP(c);
for (int i = 0; i < n0; i++)
{
cp[i] = ddot_(&n, (void*)ap,
&incx, (void*)bp, &incy);
ap += n;
bp += n;
}
}
else
{
double_complex* ap = COMPLEXP(a);
double_complex* bp = COMPLEXP(b);
double_complex* cp = COMPLEXP(c);
for (int i = 0; i < n0; i++)
{
cp[i] = 0.0;
for (int j = 0; j < n; j++)
cp[i] += ap[j] * bp[j];
ap += n;
bp += n;
}
}
Py_RETURN_NONE;
}
NPY_NO_EXPORT int
_IsAligned(PyArrayObject *ap)
{
unsigned int i;
npy_uintp aligned;
npy_uintp alignment = PyArray_DESCR(ap)->alignment;
/* alignment 1 types should have a efficient alignment for copy loops */
if (PyArray_ISFLEXIBLE(ap) || PyArray_ISSTRING(ap)) {
npy_intp itemsize = PyArray_ITEMSIZE(ap);
/* power of two sizes may be loaded in larger moves */
if (((itemsize & (itemsize - 1)) == 0)) {
alignment = itemsize > NPY_MAX_COPY_ALIGNMENT ?
NPY_MAX_COPY_ALIGNMENT : itemsize;
}
else {
/* if not power of two it will be accessed bytewise */
alignment = 1;
}
}
if (alignment == 1) {
return 1;
}
aligned = (npy_uintp)PyArray_DATA(ap);
for (i = 0; i < PyArray_NDIM(ap); i++) {
#if NPY_RELAXED_STRIDES_CHECKING
/* skip dim == 1 as it is not required to have stride 0 */
if (PyArray_DIM(ap, i) > 1) {
/* if shape[i] == 1, the stride is never used */
aligned |= (npy_uintp)PyArray_STRIDES(ap)[i];
}
else if (PyArray_DIM(ap, i) == 0) {
/* an array with zero elements is always aligned */
return 1;
}
#else /* not NPY_RELAXED_STRIDES_CHECKING */
aligned |= (npy_uintp)PyArray_STRIDES(ap)[i];
#endif /* not NPY_RELAXED_STRIDES_CHECKING */
}
return npy_is_aligned((void *)aligned, alignment);
}
static int
_array_nonzero(PyArrayObject *mp)
{
npy_intp n;
n = PyArray_SIZE(mp);
if (n == 1) {
return PyArray_DESCR(mp)->f->nonzero(PyArray_DATA(mp), mp);
}
else if (n == 0) {
return 0;
}
else {
PyErr_SetString(PyExc_ValueError,
"The truth value of an array " \
"with more than one element is ambiguous. " \
"Use a.any() or a.all()");
return -1;
}
}
/* 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_DESCR(m1)->type_num == NPY_VOID ||
!(PyArray_FLAGS(m1) & NPY_ARRAY_OWNDATA) ||
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;
}
}
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();
}
static int set_vector_from_array(int n, double *dest, PyArrayObject *obj) {
int i;
if (PyArray_DESCR(obj) != PyArray_DescrFromType(NPY_DOUBLE)) {
PyErr_SetString(PyExc_TypeError, "Expected a double precision numpy array.");
return -1;
}
if (PyArray_NDIM(obj) == 1) {
if (PyArray_DIM(obj,0) !=n) {
PyErr_SetString(PyExc_TypeError, "Invalid number of elements.");
return -1;
}
for (i=0;i<n;i++) {
char *data = PyArray_BYTES(obj) + PyArray_STRIDE(obj,0)*i;
dest[i] = *((double *) data);
}
return 0;
}
if (PyArray_NDIM(obj) == 2) {
if (PyArray_DIM(obj,0)==n && PyArray_DIM(obj,1)==1) {
for (i=0;i<n;i++) {
char *data = PyArray_BYTES(obj) + PyArray_STRIDE(obj,0)*i;
dest[i] = *((double *) data);
}
return 0;
}
if (PyArray_DIM(obj,0)==1 && PyArray_DIM(obj,1)==n) {
for (i=0;i<n;i++) {
char *data = PyArray_BYTES(obj) + PyArray_STRIDE(obj,1)*i;
dest[i] = *((double *) data);
}
return 0;
}
PyErr_SetString(PyExc_TypeError, "Invalid number of elements.");
return -1;
}
PyErr_SetString(PyExc_TypeError, "Expected a one-dimensional numpy array.");
return -1;
}
static PyObject * argmerge(PyObject * self,
PyObject * args, PyObject * kwds) {
static char * kwlist[] = {
"data", "A", "B", "out", NULL
};
PyArrayObject * data, * A, * B, * out;
if(!PyArg_ParseTupleAndKeywords(args, kwds,
"O!O!O!O!", kwlist,
&PyArray_Type, &data,
&PyArray_Type, &A,
&PyArray_Type, &B,
&PyArray_Type, &out)) return NULL;
int (*compare)(void *, void *, void*) = PyArray_DESCR(data)->f->compare;
size_t sizeA = PyArray_SIZE(A);
size_t sizeB = PyArray_SIZE(B);
npy_intp * Aptr = PyArray_DATA(A);
npy_intp * Aend = Aptr + sizeA;
npy_intp * Bptr = PyArray_DATA(B);
npy_intp * Bend = Bptr + sizeB;
npy_intp * Optr = PyArray_DATA(out);
#define AVA PyArray_GETPTR1(data, *Aptr)
#define AVB PyArray_GETPTR1(data, *Bptr)
Py_BEGIN_ALLOW_THREADS
while(Aptr < Aend || Bptr < Bend) {
while(Aptr < Aend &&
(Bptr == Bend || compare(AVA, AVB, data) <= 0))
*Optr++ = *Aptr++;
while(Bptr < Bend &&
(Aptr == Aend || compare(AVA, AVB, data) >= 0))
*Optr++ = *Bptr++;
}
Py_END_ALLOW_THREADS
Py_INCREF(Py_None);
return Py_None;
}
/* Array evaluates as "TRUE" if any of the elements are non-zero*/
static int
array_any_nonzero(PyArrayObject *arr)
{
npy_intp counter;
PyArrayIterObject *it;
npy_bool anyTRUE = NPY_FALSE;
it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)arr);
if (it == NULL) {
return anyTRUE;
}
counter = it->size;
while (counter--) {
if (PyArray_DESCR(arr)->f->nonzero(it->dataptr, arr)) {
anyTRUE = NPY_TRUE;
break;
}
PyArray_ITER_NEXT(it);
}
Py_DECREF(it);
return anyTRUE;
}
MatrixXd PyArray_ToMatrixXd(PyObject* array) {
if(PyArray_DESCR(array)->type != PyArray_DescrFromType(NPY_DOUBLE)->type)
throw Exception("Can only handle arrays of double values.");
if(PyArray_NDIM(array) == 1) {
if(PyArray_FLAGS(array) & NPY_F_CONTIGUOUS)
return Map<Matrix<double, Dynamic, Dynamic, ColMajor> >(
reinterpret_cast<double*>(PyArray_DATA(array)),
PyArray_DIM(array, 0), 1);
else if(PyArray_FLAGS(array) & NPY_C_CONTIGUOUS)
return Map<Matrix<double, Dynamic, Dynamic, RowMajor> >(
reinterpret_cast<double*>(PyArray_DATA(array)),
PyArray_DIM(array, 0), 1);
else
throw Exception("Data must be stored in contiguous memory.");
} else if(PyArray_NDIM(array) == 2) {
if(PyArray_FLAGS(array) & NPY_F_CONTIGUOUS)
return Map<Matrix<double, Dynamic, Dynamic, ColMajor> >(
reinterpret_cast<double*>(PyArray_DATA(array)),
PyArray_DIM(array, 0),
PyArray_DIM(array, 1));
else if(PyArray_FLAGS(array) & NPY_C_CONTIGUOUS)
return Map<Matrix<double, Dynamic, Dynamic, RowMajor> >(
reinterpret_cast<double*>(PyArray_DATA(array)),
PyArray_DIM(array, 0),
PyArray_DIM(array, 1));
else
throw Exception("Data must be stored in contiguous memory.");
} else {
throw Exception("Can only handle one- or two-dimensional arrays.");
}
}