// =============================================================================
int Epetra_NumPyVector::SumIntoMyValues(int blockOffset, PyObject * values,
PyObject * indices)
{
PyArrayObject * myValues = NULL;
PyArrayObject * myIndices = NULL;
int lenValues;
int lenIndices;
int result;
myValues = (PyArrayObject *)
PyArray_ContiguousFromObject(values,PyArray_DOUBLE,0,0);
if (!myValues) goto fail;
myIndices = (PyArrayObject *)
PyArray_ContiguousFromObject(indices,PyArray_INT,0,0);
if (!myIndices) goto fail;
lenValues = (int) PyArray_MultiplyList(myValues->dimensions, myValues->nd );
lenIndices = (int) PyArray_MultiplyList(myIndices->dimensions, myIndices->nd);
if (lenValues != lenIndices)
{
PyErr_Format(PyExc_ValueError,
"Sequence lengths are %d and %d, but must be of same length",
lenValues, lenIndices);
goto fail;
}
result = Epetra_Vector::SumIntoMyValues(lenValues, blockOffset,
(double *) myValues->data,
(int *) myIndices->data);
Py_DECREF(myValues );
Py_DECREF(myIndices);
return result;
fail:
Py_XDECREF(myValues );
Py_XDECREF(myIndices);
return -1;
}
// =============================================================================
int * Epetra_NumPyIntVector::getArray(const Epetra_BlockMap & blockMap,
PyObject * pyObject)
{
// Only build the tmp_array if it does not already exist
if (!tmp_array)
{
// Default dimensions
npy_intp defaultDims[ ] = { blockMap.NumMyPoints() };
// PyObject argument is a bool
if (PyBool_Check(pyObject))
{
tmp_array = (PyArrayObject *)
PyArray_SimpleNew(1,defaultDims,NPY_INT);
}
// PyObject argument is not a bool ... try to build a contiguous
// PyArrayObject from it
else
{
tmp_array = (PyArrayObject *)
PyArray_ContiguousFromObject(pyObject,NPY_INT,0,0);
}
// If any PyArray factory functions fail, clean up and throw a
// PythonException
if (!tmp_array)
{
cleanup();
throw PythonException();
}
int nd = PyArray_NDIM(tmp_array);
npy_intp arraySize = PyArray_MultiplyList(PyArray_DIMS(tmp_array),nd);
if (arraySize != defaultDims[0])
{
PyArrayObject * myArray = (PyArrayObject *)
PyArray_SimpleNew(1,defaultDims,NPY_INT);
if (!myArray)
{
cleanup();
throw PythonException();
}
int * myData = (int *) PyArray_DATA(myArray);
int * tmpData = (int *) PyArray_DATA(tmp_array);
for (int i=0; i<defaultDims[0]; i++)
{
myData[i] = tmpData[i];
}
Py_XDECREF(tmp_array);
tmp_array = myArray;
}
}
return (int*)(PyArray_DATA(tmp_array));
}
static int
fortran_setattr(PyFortranObject *fp, char *name, PyObject *v) {
int i,j,flag;
PyArrayObject *arr = NULL;
for (i=0,j=1;i<fp->len && (j=strcmp(name,fp->defs[i].name));i++);
if (j==0) {
if (fp->defs[i].rank==-1) {
PyErr_SetString(PyExc_AttributeError,"over-writing fortran routine");
return -1;
}
if (fp->defs[i].func!=NULL) { /* is allocatable array */
npy_intp dims[F2PY_MAX_DIMS];
int k;
save_def = &fp->defs[i];
if (v!=Py_None) { /* set new value (reallocate if needed --
see f2py generated code for more
details ) */
for(k=0;k<fp->defs[i].rank;k++) dims[k]=-1;
if ((arr = array_from_pyobj(fp->defs[i].type,dims,fp->defs[i].rank,F2PY_INTENT_IN,v))==NULL)
return -1;
(*(fp->defs[i].func))(&fp->defs[i].rank,arr->dimensions,set_data,&flag);
} else { /* deallocate */
for(k=0;k<fp->defs[i].rank;k++) dims[k]=0;
(*(fp->defs[i].func))(&fp->defs[i].rank,dims,set_data,&flag);
for(k=0;k<fp->defs[i].rank;k++) dims[k]=-1;
}
memcpy(fp->defs[i].dims.d,dims,fp->defs[i].rank*sizeof(npy_intp));
} else { /* not allocatable array */
if ((arr = array_from_pyobj(fp->defs[i].type,fp->defs[i].dims.d,fp->defs[i].rank,F2PY_INTENT_IN,v))==NULL)
return -1;
}
if (fp->defs[i].data!=NULL) { /* copy Python object to Fortran array */
npy_intp s = PyArray_MultiplyList(fp->defs[i].dims.d,arr->nd);
if (s==-1)
s = PyArray_MultiplyList(arr->dimensions,arr->nd);
if (s<0 ||
(memcpy(fp->defs[i].data,arr->data,s*PyArray_ITEMSIZE(arr)))==NULL) {
if ((PyObject*)arr!=v) {
Py_DECREF(arr);
}
return -1;
}
if ((PyObject*)arr!=v) {
Py_DECREF(arr);
}
} else return (fp->defs[i].func==NULL?-1:0);
return 0; /* succesful */
}
if (fp->dict == NULL) {
fp->dict = PyDict_New();
if (fp->dict == NULL)
return -1;
}
if (v == NULL) {
int rv = PyDict_DelItemString(fp->dict, name);
if (rv < 0)
PyErr_SetString(PyExc_AttributeError,"delete non-existing fortran attribute");
return rv;
}
else
return PyDict_SetItemString(fp->dict, name, v);
}
// =============================================================================
int Epetra_NumPySerialDenseVector::getVectorSize(PyObject * pyObject)
{
if (!tmp_array) getArray(pyObject);
return (int) PyArray_MultiplyList(tmp_array->dimensions, tmp_array->nd);
}
/* unravel_index implementation - see add_newdocs.py */
NPY_NO_EXPORT PyObject *
arr_unravel_index(PyObject *self, PyObject *args, PyObject *kwds)
{
PyObject *indices0 = NULL, *ret_tuple = NULL;
PyArrayObject *ret_arr = NULL;
PyArrayObject *indices = NULL;
PyArray_Descr *dtype = NULL;
PyArray_Dims dimensions={0,0};
NPY_ORDER order = NPY_CORDER;
npy_intp unravel_size;
NpyIter *iter = NULL;
int i, ret_ndim;
npy_intp ret_dims[NPY_MAXDIMS], ret_strides[NPY_MAXDIMS];
char *kwlist[] = {"indices", "dims", "order", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&|O&:unravel_index",
kwlist,
&indices0,
PyArray_IntpConverter, &dimensions,
PyArray_OrderConverter, &order)) {
goto fail;
}
if (dimensions.len == 0) {
PyErr_SetString(PyExc_ValueError,
"dims must have at least one value");
goto fail;
}
unravel_size = PyArray_MultiplyList(dimensions.ptr, dimensions.len);
if (!PyArray_Check(indices0)) {
indices = (PyArrayObject*)PyArray_FromAny(indices0,
NULL, 0, 0, 0, NULL);
if (indices == NULL) {
goto fail;
}
}
else {
indices = (PyArrayObject *)indices0;
Py_INCREF(indices);
}
dtype = PyArray_DescrFromType(NPY_INTP);
if (dtype == NULL) {
goto fail;
}
iter = NpyIter_New(indices, NPY_ITER_READONLY|
NPY_ITER_ALIGNED|
NPY_ITER_BUFFERED|
NPY_ITER_ZEROSIZE_OK|
NPY_ITER_DONT_NEGATE_STRIDES|
NPY_ITER_MULTI_INDEX,
NPY_KEEPORDER, NPY_SAME_KIND_CASTING,
dtype);
if (iter == NULL) {
goto fail;
}
/*
* Create the return array with a layout compatible with the indices
* and with a dimension added to the end for the multi-index
*/
ret_ndim = PyArray_NDIM(indices) + 1;
if (NpyIter_GetShape(iter, ret_dims) != NPY_SUCCEED) {
goto fail;
}
ret_dims[ret_ndim-1] = dimensions.len;
if (NpyIter_CreateCompatibleStrides(iter,
dimensions.len*sizeof(npy_intp), ret_strides) != NPY_SUCCEED) {
goto fail;
}
ret_strides[ret_ndim-1] = sizeof(npy_intp);
/* Remove the multi-index and inner loop */
if (NpyIter_RemoveMultiIndex(iter) != NPY_SUCCEED) {
goto fail;
}
if (NpyIter_EnableExternalLoop(iter) != NPY_SUCCEED) {
goto fail;
}
ret_arr = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, dtype,
ret_ndim, ret_dims, ret_strides, NULL, 0, NULL);
dtype = NULL;
if (ret_arr == NULL) {
goto fail;
}
if (order == NPY_CORDER) {
if (NpyIter_GetIterSize(iter) != 0) {
NpyIter_IterNextFunc *iternext;
char **dataptr;
npy_intp *strides;
npy_intp *countptr, count;
npy_intp *coordsptr = (npy_intp *)PyArray_DATA(ret_arr);
iternext = NpyIter_GetIterNext(iter, NULL);
if (iternext == NULL) {
goto fail;
}
dataptr = NpyIter_GetDataPtrArray(iter);
strides = NpyIter_GetInnerStrideArray(iter);
countptr = NpyIter_GetInnerLoopSizePtr(iter);
do {
count = *countptr;
if (unravel_index_loop_corder(dimensions.len, dimensions.ptr,
unravel_size, count, *dataptr, *strides,
coordsptr) != NPY_SUCCEED) {
goto fail;
}
coordsptr += count*dimensions.len;
} while(iternext(iter));
}
}
else if (order == NPY_FORTRANORDER) {
if (NpyIter_GetIterSize(iter) != 0) {
NpyIter_IterNextFunc *iternext;
char **dataptr;
npy_intp *strides;
npy_intp *countptr, count;
npy_intp *coordsptr = (npy_intp *)PyArray_DATA(ret_arr);
iternext = NpyIter_GetIterNext(iter, NULL);
if (iternext == NULL) {
goto fail;
}
dataptr = NpyIter_GetDataPtrArray(iter);
strides = NpyIter_GetInnerStrideArray(iter);
countptr = NpyIter_GetInnerLoopSizePtr(iter);
do {
count = *countptr;
if (unravel_index_loop_forder(dimensions.len, dimensions.ptr,
unravel_size, count, *dataptr, *strides,
coordsptr) != NPY_SUCCEED) {
goto fail;
}
coordsptr += count*dimensions.len;
} while(iternext(iter));
}
}
else {
PyErr_SetString(PyExc_ValueError,
"only 'C' or 'F' order is permitted");
goto fail;
}
/* Now make a tuple of views, one per index */
ret_tuple = PyTuple_New(dimensions.len);
if (ret_tuple == NULL) {
goto fail;
}
for (i = 0; i < dimensions.len; ++i) {
PyArrayObject *view;
view = (PyArrayObject *)PyArray_New(&PyArray_Type, ret_ndim-1,
ret_dims, NPY_INTP,
ret_strides,
PyArray_BYTES(ret_arr) + i*sizeof(npy_intp),
0, NPY_ARRAY_WRITEABLE, NULL);
if (view == NULL) {
goto fail;
}
Py_INCREF(ret_arr);
if (PyArray_SetBaseObject(view, (PyObject *)ret_arr) < 0) {
Py_DECREF(view);
goto fail;
}
PyTuple_SET_ITEM(ret_tuple, i, PyArray_Return(view));
}
Py_DECREF(ret_arr);
Py_XDECREF(indices);
PyDimMem_FREE(dimensions.ptr);
NpyIter_Deallocate(iter);
return ret_tuple;
fail:
Py_XDECREF(ret_tuple);
Py_XDECREF(ret_arr);
Py_XDECREF(dtype);
Py_XDECREF(indices);
PyDimMem_FREE(dimensions.ptr);
NpyIter_Deallocate(iter);
return NULL;
}
// =============================================================================
double * Epetra_NumPyMultiVector::getArray(const Epetra_BlockMap & blockMap,
PyObject * pyObject)
{
// PyObject argument is an int
if (PyInt_Check(pyObject))
{
int numVectors = (int) PyInt_AsLong(pyObject);
npy_intp dimensions[ ] = { numVectors, blockMap.NumMyPoints() };
tmp_array = (PyArrayObject *)
PyArray_SimpleNew(2,dimensions,NPY_DOUBLE);
if (!tmp_array)
{
cleanup();
throw PythonException();
}
// PyObject argument is not an int ... try to build a contiguous PyArrayObject from it
}
else
{
if (!tmp_array)
tmp_array = (PyArrayObject *)
PyArray_ContiguousFromObject(pyObject,NPY_DOUBLE,0,0);
// If this fails, clean up and throw a PythonException
if (!tmp_array)
{
cleanup();
throw PythonException();
}
// If the contiguous PyArrayObject built successfully, make sure it has the correct
// number of dimensions
else
{
int nd = PyArray_NDIM(tmp_array);
npy_intp dimensions[ ] = { 1, blockMap.NumMyPoints() }; // Default dimensions
bool reallocate = false;
npy_intp arraySize = PyArray_MultiplyList(PyArray_DIMS(tmp_array),nd);
if (nd < 2)
{
reallocate = true;
}
else
{
arraySize /= PyArray_DIMS(tmp_array)[0];
if (arraySize != dimensions[1])
{
dimensions[0] = PyArray_DIMS(tmp_array)[0];
reallocate = true;
}
}
// Reallocate the tmp_array if necessary
if (reallocate)
{
PyArrayObject * myArray = (PyArrayObject *)
PyArray_SimpleNew(2,dimensions,NPY_DOUBLE);
if (!myArray)
{
cleanup();
throw PythonException();
}
double * myData = (double *) PyArray_DATA(myArray);
double * tmpData = (double *) PyArray_DATA(tmp_array);
for (int i=0; i<dimensions[0]; i++)
{
for (int j=0; j<arraySize && j<dimensions[1]; j++)
{
myData[i*dimensions[1]+j] = tmpData[i*arraySize+j];
}
}
Py_XDECREF(tmp_array);
tmp_array = myArray;
}
}
}
return (double *) (PyArray_DATA(tmp_array));
}
// =============================================================================
double * Epetra_NumPyVector::getArray(const Epetra_BlockMap & blockMap,
PyObject * pyObject)
{
// Only build the tmp_array if it does not already exist
if (!tmp_array)
{
// Default dimensions
npy_intp defaultDims[ ] = { blockMap.NumMyPoints() };
// PyObject argument is a bool
if (PyBool_Check(pyObject))
{
tmp_array = (PyArrayObject *)
PyArray_SimpleNew(1,defaultDims,PyArray_DOUBLE);
if (tmp_array == NULL)
{
cleanup();
throw PythonException();
}
else
{
if (pyObject == Py_True) // bool zeroOut is True
{
double * data = (double*) tmp_array->data;
for (int i=0; i<defaultDims[0]; ++i) data[i] = 0.0;
}
}
// PyObject argument is not an bool ... try to build a contiguous
// PyArrayObject from it
}
else
{
tmp_array = (PyArrayObject *)
PyArray_ContiguousFromObject(pyObject,PyArray_DOUBLE,0,0);
// If this fails, clean up and throw a PythonException
if (!tmp_array)
{
cleanup();
throw PythonException();
}
// If the contiguous PyArrayObject built successfully, make sure
// it has the correct number of dimensions
else
{
int nd = tmp_array->nd;
npy_intp arraySize = PyArray_MultiplyList(tmp_array->dimensions,nd);
if (arraySize != defaultDims[0])
{
PyArrayObject * myArray = (PyArrayObject *)
PyArray_SimpleNew(1,defaultDims,PyArray_DOUBLE);
double * myData = (double *) myArray->data;
double * tmpData = (double *) tmp_array->data;
for (int i=0; i<defaultDims[0]; i++)
{
myData[i] = tmpData[i];
}
Py_XDECREF(tmp_array);
tmp_array = myArray;
}
}
}
}
return (double*)(tmp_array->data);
}
// =============================================================================
int Epetra_NumPyIntSerialDenseVector::getVectorSize(PyObject * pyObject)
{
if (!tmp_array) getArray(pyObject);
return (int) PyArray_MultiplyList(PyArray_DIMS(tmp_array),
PyArray_NDIM(tmp_array));
}
/*NUMPY_API
* ArgMax
*/
NPY_NO_EXPORT PyObject *
PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out)
{
PyArrayObject *ap = NULL, *rp = NULL;
PyArray_ArgFunc* arg_func;
char *ip;
intp *rptr;
intp i, n, m;
int elsize;
int copyret = 0;
NPY_BEGIN_THREADS_DEF;
if ((ap=(PyAO *)_check_axis(op, &axis, 0)) == NULL) {
return NULL;
}
/*
* We need to permute the array so that axis is placed at the end.
* And all other dimensions are shifted left.
*/
if (axis != ap->nd-1) {
PyArray_Dims newaxes;
intp dims[MAX_DIMS];
int i;
newaxes.ptr = dims;
newaxes.len = ap->nd;
for (i = 0; i < axis; i++) dims[i] = i;
for (i = axis; i < ap->nd - 1; i++) dims[i] = i + 1;
dims[ap->nd - 1] = axis;
op = (PyAO *)PyArray_Transpose(ap, &newaxes);
Py_DECREF(ap);
if (op == NULL) {
return NULL;
}
}
else {
op = ap;
}
/* Will get native-byte order contiguous copy. */
ap = (PyArrayObject *)
PyArray_ContiguousFromAny((PyObject *)op,
op->descr->type_num, 1, 0);
Py_DECREF(op);
if (ap == NULL) {
return NULL;
}
arg_func = ap->descr->f->argmax;
if (arg_func == NULL) {
PyErr_SetString(PyExc_TypeError, "data type not ordered");
goto fail;
}
elsize = ap->descr->elsize;
m = ap->dimensions[ap->nd-1];
if (m == 0) {
PyErr_SetString(PyExc_ValueError,
"attempt to get argmax/argmin "\
"of an empty sequence");
goto fail;
}
if (!out) {
rp = (PyArrayObject *)PyArray_New(ap->ob_type, ap->nd-1,
ap->dimensions, PyArray_INTP,
NULL, NULL, 0, 0,
(PyObject *)ap);
if (rp == NULL) {
goto fail;
}
}
else {
if (PyArray_SIZE(out) !=
PyArray_MultiplyList(ap->dimensions, ap->nd - 1)) {
PyErr_SetString(PyExc_TypeError,
"invalid shape for output array.");
}
rp = (PyArrayObject *)\
PyArray_FromArray(out,
PyArray_DescrFromType(PyArray_INTP),
NPY_CARRAY | NPY_UPDATEIFCOPY);
if (rp == NULL) {
goto fail;
}
if (rp != out) {
copyret = 1;
}
}
NPY_BEGIN_THREADS_DESCR(ap->descr);
n = PyArray_SIZE(ap)/m;
rptr = (intp *)rp->data;
for (ip = ap->data, i = 0; i < n; i++, ip += elsize*m) {
arg_func(ip, m, rptr, ap);
rptr += 1;
}
NPY_END_THREADS_DESCR(ap->descr);
Py_DECREF(ap);
if (copyret) {
PyArrayObject *obj;
obj = (PyArrayObject *)rp->base;
Py_INCREF(obj);
Py_DECREF(rp);
rp = obj;
}
return (PyObject *)rp;
fail:
Py_DECREF(ap);
Py_XDECREF(rp);
return NULL;
}
/*NUMPY_API
* ArgMax
*/
NPY_NO_EXPORT PyObject *
PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out)
{
PyArrayObject *ap = NULL, *rp = NULL;
PyArray_ArgFunc* arg_func;
char *ip;
npy_intp *rptr;
npy_intp i, n, m;
int elsize;
NPY_BEGIN_THREADS_DEF;
if ((ap = (PyArrayObject *)PyArray_CheckAxis(op, &axis, 0)) == NULL) {
return NULL;
}
/*
* We need to permute the array so that axis is placed at the end.
* And all other dimensions are shifted left.
*/
if (axis != PyArray_NDIM(ap)-1) {
PyArray_Dims newaxes;
npy_intp dims[MAX_DIMS];
int j;
newaxes.ptr = dims;
newaxes.len = PyArray_NDIM(ap);
for (j = 0; j < axis; j++) {
dims[j] = j;
}
for (j = axis; j < PyArray_NDIM(ap) - 1; j++) {
dims[j] = j + 1;
}
dims[PyArray_NDIM(ap) - 1] = axis;
op = (PyArrayObject *)PyArray_Transpose(ap, &newaxes);
Py_DECREF(ap);
if (op == NULL) {
return NULL;
}
}
else {
op = ap;
}
/* Will get native-byte order contiguous copy. */
ap = (PyArrayObject *)PyArray_ContiguousFromAny((PyObject *)op,
PyArray_DESCR(op)->type_num, 1, 0);
Py_DECREF(op);
if (ap == NULL) {
return NULL;
}
arg_func = PyArray_DESCR(ap)->f->argmax;
if (arg_func == NULL) {
PyErr_SetString(PyExc_TypeError,
"data type not ordered");
goto fail;
}
elsize = PyArray_DESCR(ap)->elsize;
m = PyArray_DIMS(ap)[PyArray_NDIM(ap)-1];
if (m == 0) {
PyErr_SetString(PyExc_ValueError,
"attempt to get argmax of an empty sequence");
goto fail;
}
if (!out) {
rp = (PyArrayObject *)PyArray_New(Py_TYPE(ap), PyArray_NDIM(ap)-1,
PyArray_DIMS(ap), PyArray_INTP,
NULL, NULL, 0, 0,
(PyObject *)ap);
if (rp == NULL) {
goto fail;
}
}
else {
if (PyArray_SIZE(out) !=
PyArray_MultiplyList(PyArray_DIMS(ap), PyArray_NDIM(ap) - 1)) {
PyErr_SetString(PyExc_TypeError,
"invalid shape for output array.");
}
rp = (PyArrayObject *)PyArray_FromArray(out,
PyArray_DescrFromType(PyArray_INTP),
NPY_ARRAY_CARRAY | NPY_ARRAY_UPDATEIFCOPY);
if (rp == NULL) {
goto fail;
}
}
NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(ap));
n = PyArray_SIZE(ap)/m;
rptr = (npy_intp *)PyArray_DATA(rp);
for (ip = PyArray_DATA(ap), i = 0; i < n; i++, ip += elsize*m) {
arg_func(ip, m, rptr, ap);
rptr += 1;
}
NPY_END_THREADS_DESCR(PyArray_DESCR(ap));
Py_DECREF(ap);
/* Trigger the UPDATEIFCOPY if necessary */
if (out != NULL && out != rp) {
Py_DECREF(rp);
rp = out;
Py_INCREF(rp);
}
return (PyObject *)rp;
fail:
Py_DECREF(ap);
Py_XDECREF(rp);
return NULL;
}
