bp::list wrapped_sparse_hess_no_repeat(short tape_tag, bpn::ndarray &bpn_x, bpn::ndarray &bpn_options){
size_t tape_stats[STAT_SIZE];
tapestats(tape_tag, tape_stats);
int N = tape_stats[NUM_INDEPENDENTS];
double* x = (double*) nu::data(bpn_x);
int* options = (int*) nu::data(bpn_options);
// int options[2] = {0,0};
int nnz=-1;
unsigned int *rind = NULL;
unsigned int *cind = NULL;
double *values = NULL;
sparse_hess(tape_tag, N, 0, x, &nnz, &rind, &cind, &values, options);
npy_intp ret_nnz = static_cast<npy_intp>(nnz);
bp::object bp_rind ( bp::handle<>(PyArray_SimpleNewFromData(1, &ret_nnz, NPY_UINT, (char*) rind )));
bp::object bp_cind ( bp::handle<>(PyArray_SimpleNewFromData(1, &ret_nnz, NPY_UINT, (char*) cind )));
bp::object bp_values ( bp::handle<>(PyArray_SimpleNewFromData(1, &ret_nnz, NPY_DOUBLE, (char*) values )));
bpn::ndarray ret_rind = boost::python::extract<boost::python::numpy::ndarray>(bp_rind);
bpn::ndarray ret_cind = boost::python::extract<boost::python::numpy::ndarray>(bp_cind);
bpn::ndarray ret_values = boost::python::extract<boost::python::numpy::ndarray>(bp_values);
bp::list retvals;
retvals.append(ret_nnz);
retvals.append(ret_rind);
retvals.append(ret_cind);
retvals.append(ret_values);
return retvals;
}
void HIDDEN gadget_initkernel(PyObject * m) {
fill_koverlap();
npy_intp kline_dims[] = {KLINE_BINS};
PyArrayObject * kline_a = (PyArrayObject *)PyArray_SimpleNewFromData(1, kline_dims, NPY_FLOAT, kline);
PyArrayObject * klinesq_a = (PyArrayObject *)PyArray_SimpleNewFromData(1, kline_dims, NPY_FLOAT, klinesq);
npy_intp koverlap_dims[] = {KOVERLAP_BINS, KOVERLAP_BINS, KOVERLAP_BINS, KOVERLAP_BINS};
PyArrayObject * koverlap_a = (PyArrayObject *)PyArray_SimpleNewFromData(4, koverlap_dims, NPY_FLOAT, koverlap);
generic_functions[0] = PyUFunc_f_f;
generic_functions[1] = PyUFunc_d_d;
koverlap_functions[0] = PyUFunc_ffff_f;
koverlap_functions[1] = PyUFunc_dddd_d;
PyObject * k0_u = PyUFunc_FromFuncAndData(generic_functions,
k0_data, generic_signatures,
2, 1, 1,
PyUFunc_None,
"k0", k0_doc_string, 0);
PyObject * kline_u = PyUFunc_FromFuncAndData(generic_functions,
kline_data, generic_signatures,
2, 1, 1,
PyUFunc_None,
"kline", kline_doc_string, 0);
PyObject * koverlap_u = PyUFunc_FromFuncAndData(koverlap_functions,
koverlap_data, koverlap_signatures,
2, 4, 1, PyUFunc_None,
"koverlap", koverlap_doc_string, 0);
PyModule_AddObject(m, "k0", k0_u);
PyModule_AddObject(m, "kline", kline_u);
PyModule_AddObject(m, "koverlap", koverlap_u);
PyModule_AddObject(m, "akline", (PyObject*)kline_a);
PyModule_AddObject(m, "aklinesq", (PyObject*)klinesq_a);
PyModule_AddObject(m, "akoverlap", (PyObject*)koverlap_a);
}
static PyObject*
SparseMatrix_getCSRrepresentation(SparseMatrix *self,
PyObject *args)
{
PyObject *rowout,*colout,*aout;
int nnz,nr;
npy_intp dims[1];
int_t *rowptr,*colind;
double *a;
a = (double*)self->A.nzval;
rowptr = self->A.rowptr;
colind = self->A.colind;
nr = self->dim[0];
nnz = self->A.nnz;
dims[0] = nr+1;
rowout = PyArray_SimpleNewFromData(1,dims,NPY_INT,
(void*)rowptr);
dims[0] = nnz;
colout = PyArray_SimpleNewFromData(1,dims,NPY_INT,
(void*)colind);
dims[0] = nnz;
aout = PyArray_SimpleNewFromData(1,dims,NPY_DOUBLE,
(void*)a);
return Py_BuildValue("OOO",
rowout,
colout,
aout);
}
PyObject* VideoCapture_get_array(VideoCapture *self)
{
switch(self->camptr->format)
{
case FG_BINARY:
case FG_GRAY:
{
npy_intp dims[2] = {self->camptr->height,self->camptr->width};
return PyArray_SimpleNewFromData(2,dims,NPY_UINT8,self->camptr->ImgPtr);
}
case FG_GRAY16:
{
npy_intp dims[2] = {self->camptr->height,self->camptr->width};
return PyArray_SimpleNewFromData(2,dims,NPY_UINT16,self->camptr->ImgPtr);
}
case FG_COL24:
{
cout << "24 bits!" << endl;
npy_intp dims[3] = {self->camptr->height,self->camptr->width,3};
return PyArray_SimpleNewFromData(3,dims,NPY_UINT8,self->camptr->ImgPtr);
}
default:
{
cout << "VideoCapture.get_array(): Unsupported data type!" << endl;
Py_RETURN_NONE;
}
}
}
void _pylm_callback(PyObject *func, double *p, double *hx, int m, int n, int jacobian) {
int i;
PyObject *args = NULL;
PyObject *result = NULL;
// marshall parameters from c -> python
// construct numpy arrays from c
npy_intp dims_m[1] = {m};
npy_intp dims_n[1] = {n};
PyObject *estimate = PyArray_SimpleNewFromData(1, dims_m, PyArray_DOUBLE, p);
PyObject *measurement = PyArray_SimpleNewFromData(1, dims_n , PyArray_DOUBLE, hx);
args = Py_BuildValue("(OO)", estimate, measurement);
if (!args) {
goto cleanup;
}
// call func
result = PyObject_CallObject(func, args);
if (result == NULL) {
PyErr_Print();
goto cleanup;
}
if(!PyArray_Check(result)){
PyErr_SetString(PyExc_TypeError,
"Return value from callback "
"should be of numpy array type");
goto cleanup;
}
// marshall results from python -> c
npy_intp result_size = PyArray_DIM(result, 0);
if ((!jacobian && (result_size == n)) ||
(jacobian && (result_size == m*n))) {
for (i = 0; i < result_size; i++) {
double *j = PyArray_GETPTR1(result, i);
hx[i] = *j;
}
} else {
PyErr_SetString(PyExc_TypeError,
"Return value from callback "
"should be same size as measurement");
}
cleanup:
Py_XDECREF(args);
Py_XDECREF(estimate);
Py_XDECREF(measurement);
Py_XDECREF(result);
return;
}
/* rle_decode(byte_array, lbrow, lbnpt, mdi) */
static PyObject *rle_decode_py(PyObject *self, PyObject *args)
{
char *bytes_in=NULL;
PyArrayObject *npy_array_out=NULL;
int bytes_in_len;
npy_intp dims[2];
int lbrow, lbnpt, npts;
float mdi;
if (!PyArg_ParseTuple(args, "s#iif", &bytes_in, &bytes_in_len, &lbrow, &lbnpt, &mdi)) return NULL;
// Unpacking algorithm accepts an int - so assert that lbrow*lbnpt does not overflow
if (lbrow > 0 && lbnpt >= INT_MAX / (lbrow+1)) {
PyErr_SetString(PyExc_ValueError, "Resulting unpacked PP field is larger than PP supports.");
return NULL;
} else {
npts = lbnpt*lbrow;
}
// We can't use the macros Py_BEGIN_ALLOW_THREADS / Py_END_ALLOW_THREADS
// because they declare a new scope block, but we want multiple exits.
PyThreadState *_save;
_save = PyEval_SaveThread();
float *dataout = (float*)calloc(npts, sizeof(float));
if (dataout == NULL) {
PyEval_RestoreThread(_save);
PyErr_SetString(PyExc_ValueError, "Unable to allocate memory for wgdos_unpacking.");
return NULL;
}
function func; // function is defined by wgdosstuff.
set_function_name(__func__, &func, 0);
int status = unpack_ppfield(mdi, (bytes_in_len/BYTES_PER_INT_UNPACK_PPFIELD), bytes_in, LBPACK_RLE_PACKED, npts, dataout, &func);
/* Raise an exception if there was a problem with the REL algorithm */
if (status != 0) {
free(dataout);
PyEval_RestoreThread(_save);
PyErr_SetString(PyExc_ValueError, "RLE decode encountered an error.");
return NULL;
}
else {
/* The data came back fine, so make a Numpy array and return it */
dims[0]=lbrow;
dims[1]=lbnpt;
PyEval_RestoreThread(_save);
npy_array_out=(PyArrayObject *) PyArray_SimpleNewFromData(2, dims, NPY_FLOAT, dataout);
if (npy_array_out == NULL) {
PyErr_SetString(PyExc_ValueError, "Failed to make the numpy array for the packed data.");
return NULL;
}
// give ownership of dataout to the Numpy array - Numpy will then deal with memory cleanup.
npy_array_out->flags = npy_array_out->flags | NPY_OWNDATA;
return (PyObject *)npy_array_out;
}
}
static PyObject *__getattro__(PyObject *self, PyObject *attr_name)
{
const char *name = PyString_AsString(attr_name);
pylal_COMPLEX16FrequencySeries *obj = (pylal_COMPLEX16FrequencySeries *) self;
if(!strcmp(name, "name"))
return PyString_FromString(obj->series->name);
if(!strcmp(name, "epoch"))
return pylal_LIGOTimeGPS_new(obj->series->epoch);
if(!strcmp(name, "f0"))
return PyFloat_FromDouble(obj->series->f0);
if(!strcmp(name, "deltaF"))
return PyFloat_FromDouble(obj->series->deltaF);
if(!strcmp(name, "sampleUnits"))
return pylal_LALUnit_new(0, obj->series->sampleUnits);
if(!strcmp(name, "data")) {
npy_intp dims[] = {obj->series->data->length};
PyObject *array = PyArray_SimpleNewFromData(1, dims, NPY_CDOUBLE, obj->series->data->data);
if(!array)
return NULL;
/* incref self to prevent data from disappearing while
* array is still in use, and tell numpy to decref self
* when the array is deallocated */
Py_INCREF(self);
PyArray_SetBaseObject((PyArrayObject *) array, self);
return array;
}
PyErr_SetString(PyExc_AttributeError, name);
return NULL;
}
// Function to extract the node information
PyObject *
px_GetNodes(PyObject *self, PyObject *args)
{
xf_Mesh *Mesh = NULL;
PyObject *np_Coord;
npy_intp dims[2];
// Get the pointer to the xf_Mesh.
if (!PyArg_ParseTuple(args, "n", &Mesh))
return NULL;
// Get dimensions
dims[0] = Mesh->nNode;
dims[1] = Mesh->Dim;
// Error checking
if (Mesh->nNode <= 0) return NULL;
// Make the mesh.
np_Coord = PyArray_SimpleNewFromData( \
2, dims, NPY_DOUBLE, *Mesh->Coord);
// Output (Dim, nNode, Coord).
return Py_BuildValue("iiO", Mesh->Dim, Mesh->nNode, np_Coord);
}
// Function to read the BFaceGroup
PyObject *
px_ElemGroup(PyObject *self, PyObject *args)
{
xf_Mesh *Mesh = NULL;
xf_ElemGroup *EG = NULL;
int i, nElem, nNode, QOrder;
const char *QBasis;
PyObject *Node;
npy_intp dims[2];
// Get the pointer to the xf_BFaceGroup
if (!PyArg_ParseTuple(args, "ni", &Mesh, &i))
return NULL;
// Assign the element group
EG = Mesh->ElemGroup;
// Read the data
nElem = EG[i].nElem;
nNode = EG[i].nNode;
QOrder = EG[i].QOrder;
// Convert the enumeration to a string.
QBasis = xfe_BasisName[EG[i].QBasis];
// Dimensions of the nodes array
dims[0] = nElem;
dims[1] = nNode;
// Read the nodes to a numpy array.
Node = PyArray_SimpleNewFromData( \
2, dims, NPY_INT, *EG[i].Node);
// Output: (nElem, nNode, QOrder, QBasis, Node)
return Py_BuildValue("iiisO", nElem, nNode, QOrder, QBasis, Node);
}
static PyObject*
get_rgb_screen(PyObject *self, PyObject *args) {
int x, y, dx, dy;
int good_args = PyArg_ParseTuple(args, "IIII", &x, &y, &dx, &dy);
if (!good_args) {
return NULL;
}
Display *display = XOpenDisplay(NULL);
Window window = RootWindow(display, DefaultScreen(display));
XImage *img = XGetImage(display, window, x, y, dx, dy, AllPlanes, ZPixmap);
int w = img->width;
int h = img->height;
unsigned char *rgb_arr = (unsigned char*) malloc(4*w*h);
if (rgb_arr == NULL) {
PyErr_NoMemory();
return NULL;
}
npy_intp dims[] = {h, w, 4};
PyObject *np_arr = PyArray_SimpleNewFromData(3, dims, NPY_UINT8, img->data);
return np_arr;
}
/*
Export a fff_matrix to a PyArray, and delete it. This function is a
fff_matrix destructor compatible with any of the following
constructors: fff_matrix_new and fff_matrix_fromPyArray.
*/
PyArrayObject* fff_matrix_toPyArray(fff_matrix* y)
{
PyArrayObject* x;
size_t size1;
size_t size2;
size_t tda;
npy_intp dims[2];
if (y == NULL)
return NULL;
size1 = y->size1;
size2 = y->size2;
tda = y->tda;
dims[0] = (npy_intp) size1;
dims[1] = (npy_intp) size2;
/* If the fff_matrix is contiguous and owner, just pass the
buffer to Python and transfer ownership */
if ((tda == size2) && (y->owner)) {
x = (PyArrayObject*) PyArray_SimpleNewFromData(2, dims, NPY_DOUBLE, (void*)y->data);
x->flags = (x->flags) | NPY_OWNDATA;
}
/* Otherwise, create PyArray from scratch. Note, the input
fff_matrix is necessarily in row-major order. */
else
x = fff_matrix_const_toPyArray(y);
/* Ciao bella */
free(y);
return x;
}
/*
Export a fff_vector to a PyArray, and delete it. This function is a
fff_vector destructor compatible with any either fff_vector_new or
_fff_vector_new_from_buffer.
*/
PyArrayObject* fff_vector_toPyArray(fff_vector* y)
{
PyArrayObject* x;
size_t size;
npy_intp dims[1];
if (y == NULL)
return NULL;
size = y->size;
dims[0] = (npy_intp) size;
/* If the fff_vector is owner (hence contiguous), just pass the
buffer to Python and transfer ownership */
if (y->owner) {
x = (PyArrayObject*) PyArray_SimpleNewFromData(1, dims, NPY_DOUBLE, (void*)y->data);
x->flags = (x->flags) | NPY_OWNDATA;
}
/* Otherwise, create Python array from scratch */
else
x = fff_vector_const_toPyArray(y);
/* Ciao bella */
free(y);
return x;
}
static PyObject* auto_correlations(PyObject* self, PyObject* args)
{
oskar_VisBlock* h = 0;
oskar_Mem* m = 0;
PyObject *capsule = 0;
PyArrayObject *array = 0;
npy_intp dims[4];
if (!PyArg_ParseTuple(args, "O", &capsule)) return 0;
if (!(h = (oskar_VisBlock*) get_handle(capsule, name))) return 0;
/* Check that auto-correlations exist. */
if (!oskar_vis_block_has_auto_correlations(h))
{
PyErr_SetString(PyExc_RuntimeError, "No auto-correlations in block.");
return 0;
}
/* Return an array reference to Python. */
m = oskar_vis_block_auto_correlations(h);
dims[0] = oskar_vis_block_num_times(h);
dims[1] = oskar_vis_block_num_channels(h);
dims[2] = oskar_vis_block_num_stations(h);
dims[3] = oskar_vis_block_num_pols(h);
array = (PyArrayObject*)PyArray_SimpleNewFromData(4, dims,
(oskar_mem_is_double(m) ? NPY_CDOUBLE : NPY_CFLOAT),
oskar_mem_void(m));
return Py_BuildValue("N", array); /* Don't increment refcount. */
}
static PyObject *
creategrid(PyObject *self, PyObject *args)
{
npy_intp dimensions[1];
int i,j, n;
double** input_params;
double* data;
PyObject *input;
PyArrayObject *input_arr, *result;
if (!PyArg_ParseTuple(args, "O", &input))
return NULL;
input_arr = (PyArrayObject *)PyArray_ContiguousFromObject(input, PyArray_DOUBLE, 2, 2);
n=input_arr->dimensions[0];
input_params = (double**)malloc(sizeof(double*)*n);
for (i=0; i<n; i++)
{
input_params[i] = (double *)malloc(sizeof(double)*3);
for (j=0; j<3; j++)
input_params[i][j] = *(double *)(input_arr->data+ i*input_arr->strides[0] + j*input_arr->strides[1]);
}
int size;
data = creategrid_c(n, input_params, &size);
dimensions[0] = size*n;
result = (PyArrayObject *)PyArray_SimpleNewFromData(1, dimensions, PyArray_DOUBLE, (char*)data);
return PyArray_Return(result);
}
PyObject* createNumpyArray(const cv::Mat& mat) const
{
assert(mat.type() == CV_64F && mat.isContinuous() && mat.data != nullptr);
std::array<npy_intp, 2> dims {{ mat.rows-1, mat.cols }};
return PyArray_SimpleNewFromData(dims.size(), std::begin(dims), NPY_FLOAT, reinterpret_cast<void*>(mat.data));
}
static PyObject *premalloced_npy_double_array(double *data, npy_intp len)
{
PyObject *premalloced = premalloced_new(data);
if (!premalloced)
return NULL;
npy_intp dims[1] = {len};
PyArrayObject *out = (PyArrayObject *)
PyArray_SimpleNewFromData(1, dims, NPY_DOUBLE, data);
if (!out)
{
Py_DECREF(premalloced);
return NULL;
}
#ifdef PyArray_BASE
/* FIXME: PyArray_BASE changed from a macro to a getter function in
* Numpy 1.7. When we drop Numpy 1.6 support, remove this #ifdef block. */
PyArray_BASE(out) = premalloced;
#else
if (PyArray_SetBaseObject(out, premalloced))
{
Py_DECREF(out);
return NULL;
}
#endif
return (PyObject *)out;
}
static PyObject *
pixbuf_get_pixels_array(PyObject *self, PyObject *args)
{
/* 1) read in Python pixbuf, get the underlying gdk_pixbuf */
PyGObject *py_pixbuf;
GdkPixbuf *gdk_pixbuf;
PyArrayObject *array;
npy_intp dims[3] = { 0, 0, 3 };
if (!PyArg_ParseTuple(args, "O!:pixbuf_get_pixels_array",
&PyGdkPixbuf_Type, &py_pixbuf))
return NULL;
gdk_pixbuf = GDK_PIXBUF(py_pixbuf->obj);
/* 2) same as pygtk/gtk/gdk.c _wrap_gdk_pixbuf_get_pixels_array()
* with 'self' changed to py_pixbuf
*/
dims[0] = gdk_pixbuf_get_height(gdk_pixbuf);
dims[1] = gdk_pixbuf_get_width(gdk_pixbuf);
if (gdk_pixbuf_get_has_alpha(gdk_pixbuf))
dims[2] = 4;
array = (PyArrayObject *)PyArray_SimpleNewFromData(3, dims, NPY_UBYTE,
(char *)gdk_pixbuf_get_pixels(gdk_pixbuf));
if (array == NULL)
return NULL;
array->strides[0] = gdk_pixbuf_get_rowstride(gdk_pixbuf);
/* the array holds a ref to the pixbuf pixels through this wrapper*/
Py_INCREF(py_pixbuf);
array->base = (PyObject *)py_pixbuf;
return PyArray_Return(array);
}
PyObject *
gdkpixbuf_get_pixels_array(PyObject *pixbuf_pyobject)
{
GdkPixbuf *pixbuf = GDK_PIXBUF(((PyGObject *)pixbuf_pyobject)->obj);
PyArrayObject *array;
npy_intp dims[3] = { 0, 0, 3 };
dims[0] = gdk_pixbuf_get_height(pixbuf);
dims[1] = gdk_pixbuf_get_width(pixbuf);
if (gdk_pixbuf_get_has_alpha(pixbuf))
dims[2] = 4;
guchar *pixels = gdk_pixbuf_get_pixels(pixbuf);
array = (PyArrayObject *)PyArray_SimpleNewFromData(3, dims, NPY_UBYTE,
pixels);
if (array == NULL)
return NULL;
PyArray_STRIDES(array)[0] = gdk_pixbuf_get_rowstride(pixbuf);
// the array holds a ref to the pixbuf pixels through this wrapper
Py_INCREF(pixbuf_pyobject);
#ifdef NPY_1_7_API_VERSION
PyArray_SetBaseObject(array, (PyObject *)pixbuf_pyobject);
#else
array->base = (PyObject *)pixbuf_pyobject;
#endif
return PyArray_Return(array);
}
PyObject* ICoinPackedMatrix::np_getIndices(){
npy_intp dims = this->getNumElements();
_import_array();
PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, PyArray_INT32, this->IgetIndices() );
return Arr;
}
void py_coulomb_set_hubbard_u(PyObject *self, void *p, double *U, int *error)
{
particles_t *py_p;
PyObject *py_U, *r;
npy_intp dims[1];
INIT_ERROR(error);
#ifdef DEBUG
printf("[py_coulomb_set_Hubbard_U] %s %p %p\n",
PyString_AsString(PyObject_Str(self)), U, error);
#endif
f_particles_get_tag(p, (void**) &py_p);
assert(py_p->f90obj == p);
dims[0] = f_particles_get_nel(py_p->f90obj);
py_U = PyArray_SimpleNewFromData(1, dims, NPY_DOUBLE, U);
r = PyObject_CallMethod(self, "set_Hubbard_U", "(OO)", py_p, py_U);
Py_DECREF(py_U);
PASS_PYTHON_ERROR(error, r);
Py_DECREF(r);
}
void py_coulomb_potential_and_field(PyObject *self, void *p, void *nl,
double *q, double *phi, double *epot,
double *E, double *wpot, int *error)
{
particles_t *py_p;
neighbors_t *py_nl;
PyObject *py_q, *py_phi, *py_epot, *py_E, *py_wpot, *r;
int nat;
npy_intp dims[2];
#ifdef DEBUG
printf("[py_coulomb_potential_and_field]\n");
#endif
f_particles_get_tag(p, (void**) &py_p);
assert(py_p->f90obj == p);
nat = data_get_len(py_p->f90data);
f_neighbors_get_tag(nl, (void**) &py_nl);
assert(py_nl->f90obj == nl);
dims[0] = nat;
dims[1] = 3;
py_q = PyArray_SimpleNewFromData(1, dims, NPY_DOUBLE, q);
py_phi = PyArray_SimpleNewFromData(1, dims, NPY_DOUBLE, phi);
py_E = PyArray_SimpleNewFromData(2, dims, NPY_DOUBLE, E);
dims[0] = 1;
py_epot = PyArray_SimpleNewFromData(1, dims, NPY_DOUBLE, epot);
dims[0] = 3;
dims[1] = 3;
py_wpot = PyArray_SimpleNewFromData(2, dims, NPY_DOUBLE, wpot);
r = PyObject_CallMethod(self, "potential_and_field", "(OOOOOOO)", py_p,
py_nl, py_q, py_phi, py_epot, py_E, py_wpot);
Py_DECREF(py_q);
Py_DECREF(py_phi);
Py_DECREF(py_E);
Py_DECREF(py_epot);
Py_DECREF(py_wpot);
PASS_PYTHON_ERROR(error, r);
Py_DECREF(r);
}
static NdArray make(std::vector<double>& ndarray)
{
//FIXME Python expects sizeof(double) == 8.
npy_intp dims[1] = {(npy_intp)ndarray.size()};
//FIXME not sure if dims should be stack allocated
return NdArray{makePyObjectPtr(
PyArray_SimpleNewFromData(1, &dims[0], NPY_DOUBLE,
(void*)(&ndarray[0])))};
}
PyObject* JacobianP(double t, double *x, double *p) {
PyObject *OutObj = NULL;
PyObject *JacPOut = NULL;
double *jactual = NULL, **jtemp = NULL;
int i, n, m;
_init_numpy();
if( (gIData == NULL) || (gIData->isInitBasic == 0)
|| (gIData->hasJacP == 0) || (gIData->paramDim == 0) ) {
Py_INCREF(Py_None);
return Py_None;
}
else if( (gIData->nExtInputs > 0) && (gIData->isInitExtInputs == 0) ) {
Py_INCREF(Py_None);
return Py_None;
}
else {
OutObj = PyTuple_New(1);
assert(OutObj);
n = gIData->phaseDim;
m = gIData->paramDim;
jactual = (double *)PyMem_Malloc(n*m*sizeof(double));
assert(jactual);
jtemp = (double **)PyMem_Malloc(n*sizeof(double *));
assert(jtemp);
for( i = 0; i < n; i++ ) {
jtemp[i] = jactual + m * i;
}
if( gIData->nExtInputs > 0 ) {
FillCurrentExtInputValues( gIData, t );
}
/* Assume jacobianParam is returned in column-major format */
jacobianParam(gIData->phaseDim, gIData->paramDim, t, x, p, jtemp,
gIData->extraSpaceSize, gIData->gExtraSpace,
gIData->nExtInputs, gIData->gCurrentExtInputVals);
PyMem_Free(jtemp);
npy_intp dims[2] = {gIData->paramDim, gIData->phaseDim};
JacPOut = PyArray_SimpleNewFromData(2, dims, NPY_DOUBLE, jactual);
if(JacPOut) {
PyArray_UpdateFlags((PyArrayObject *)JacPOut, NPY_ARRAY_CARRAY | NPY_ARRAY_OWNDATA);
PyTuple_SetItem(OutObj, 0, PyArray_Transpose((PyArrayObject *)JacPOut, NULL));
return OutObj;
} else {
PyMem_Free(jactual);
Py_INCREF(Py_None);
return Py_None;
}
}
}
static PyObject*
SparseMatrix_getSubMatCSRrepresentation(SparseMatrix *self,
PyObject *args)
{
PyObject *rowout,*colout,*aout;
int nnz,nr;
npy_intp dims[1];
int_t *rowptr,*colind;
double *a;
/*rows for submatrix */
int range_start,range_end;
if(!PyArg_ParseTuple(args,
"ii",
&range_start,
&range_end))
return NULL;
assert(range_start >= 0);
assert(range_end <= self->dim[0]);
assert(range_end > range_start);
nr = range_end-range_start;
assert(nr <= self->dim[0]);
rowptr = self->A.rowptr + range_start;
colind = self->A.colind + rowptr[0];
a = (double*)(self->A.nzval) + rowptr[0];
nnz = self->A.rowptr[range_end]-self->A.rowptr[range_start];
dims[0] = nr+1;
rowout = PyArray_SimpleNewFromData(1,dims,NPY_INT,
(void*)rowptr);
dims[0] = nnz;
colout = PyArray_SimpleNewFromData(1,dims,NPY_INT,
(void*)colind);
dims[0] = nnz;
aout = PyArray_SimpleNewFromData(1,dims,NPY_DOUBLE,
(void*)a);
return Py_BuildValue("OOO",
rowout,
colout,
aout);
}
/******************************************************************************
* *
* Itsolvers_Solve -- Invoke linear solver *
* *
* Invoke iterative linear solver 'linsolver', to (approximately) solve the *
* linear system *
* *
* A * x = b *
* *
* to an accuracy of 'tol'. The maximum number of iteration steps taken is *
* 'itmax'. The vectors 'x' and 'y' are given as arrays of double of length *
* 'n'. *
* *
* Returns 0 if the operation was successful, or -1 if an error occured. *
* *
******************************************************************************/
static int
ItSolvers_Solve(PyObject *linsolver, PyObject *A, int n,
double *b, double *x, double tol, int itmax, PyObject *K,
int *info, int *iter, double *relres) {
PyObject *b_arr = NULL;
PyObject *x_arr = NULL;
npy_intp dimensions[1];
PyObject *res;
dimensions[0] = n;
/* create array objects from x and y */
b_arr = PyArray_SimpleNewFromData(1, dimensions, NPY_DOUBLE, (void *)b);
if (b_arr == NULL)
goto fail;
x_arr = PyArray_SimpleNewFromData(1, dimensions, NPY_DOUBLE, (void *)x);
if (x_arr == NULL)
goto fail;
/* Call iterative solver */
if (K == NULL)
res = PyObject_CallFunction(linsolver, "OOOdi", A, b_arr, x_arr, tol, itmax);
else
res = PyObject_CallFunction(linsolver, "OOOdiO", A, b_arr, x_arr, tol, itmax, K);
if (res == NULL)
goto fail;
/* Parse result
Abuse PyArg_ParseTuple to parse res tuple (is this safe?) */
PyArg_ParseTuple(res, "iid", info, iter, relres);
Py_DECREF(res);
/* free array objects */
Py_DECREF(b_arr);
Py_DECREF(x_arr);
return 0;
fail:
Py_XDECREF(b_arr);
Py_XDECREF(x_arr);
return -1;
}
/**
* Create a NumPy wrapper around the given values and marks it as read only
* @param values :: A reference to the array of values that will be wrapped by NumPy
* @param readonly :: If true the array is flagged as read only
* @returns A numpy wrapped array C-array
*/
PyObject * MantidVecHelper::createNumPyArray(const MantidVec & values, bool readonly)
{
npy_intp dims[1] = { static_cast<int>(values.size()) };
PyArrayObject * ndarray =
(PyArrayObject*)(PyArray_SimpleNewFromData(1, dims, NPY_DOUBLE, (void*)const_cast<MantidVec::value_type*>(&(values[0]))));
if( readonly )
{
ndarray->flags &= ~NPY_WRITEABLE;
}
return (PyObject*)ndarray;
}
PyObject *wrapWithNDArray(const ElementType * carray, const int ndims,
Py_intptr_t *dims, const NumpyWrapMode mode)
{
int datatype = NDArrayTypeIndex<ElementType>::typenum;
PyArrayObject *nparray = (PyArrayObject*)
PyArray_SimpleNewFromData(ndims, dims, datatype,
static_cast<void*>(const_cast<ElementType *>(carray)));
if( mode == ReadOnly ) markReadOnly(nparray);
return (PyObject*)nparray;
}
bp::object PyBlobWrap::get_diff() {
npy_intp dims[] = {num(), channels(), height(), width()};
PyObject *obj = PyArray_SimpleNewFromData(4, dims, NPY_FLOAT32,
blob_->mutable_cpu_diff());
PyArray_SetBaseObject(reinterpret_cast<PyArrayObject *>(obj), self_);
Py_INCREF(self_);
bp::handle<> h(obj);
return bp::object(h);
}
/* wgdos_unpack(byte_array, lbrow, lbnpt, mdi) */
static PyObject *wgdos_unpack_py(PyObject *self, PyObject *args)
{
char *bytes_in=NULL;
PyArrayObject *npy_array_out=NULL;
int bytes_in_len;
npy_intp dims[2];
int lbrow, lbnpt, npts;
float mdi;
if (!PyArg_ParseTuple(args, "s#iif", &bytes_in, &bytes_in_len, &lbrow, &lbnpt, &mdi)) return NULL;
// Unpacking algorithm accepts an int - so assert that lbrow*lbnpt does not overflow
if (lbrow > 0 && lbnpt >= INT_MAX / (lbrow+1)) {
PyErr_SetString(PyExc_ValueError, "Resulting unpacked PP field is larger than PP supports.");
return NULL;
} else{
npts = lbnpt*lbrow;
}
/* Do the unpack of the given byte array */
float *dataout = (float*)calloc(npts, sizeof(float));
if (dataout == NULL) {
PyErr_SetString(PyExc_ValueError, "Unable to allocate memory for wgdos_unpacking.");
return NULL;
}
function func; // function is defined by wgdosstuff.
set_function_name(__func__, &func, 0);
int status = unpack_ppfield(mdi, 0, bytes_in, LBPACK_WGDOS_PACKED, npts, dataout, &func);
/* Raise an exception if there was a problem with the WGDOS algorithm */
if (status != 0) {
free(dataout);
PyErr_SetString(PyExc_ValueError, "WGDOS unpack encountered an error.");
return NULL;
}
else {
/* The data came back fine, so make a Numpy array and return it */
dims[0]=lbrow;
dims[1]=lbnpt;
npy_array_out=(PyArrayObject *) PyArray_SimpleNewFromData(2, dims, NPY_FLOAT, dataout);
if (npy_array_out == NULL) {
PyErr_SetString(PyExc_ValueError, "Failed to make the numpy array for the packed data.");
return NULL;
}
// give ownership of dataout to the Numpy array - Numpy will then deal with memory cleanup.
npy_array_out->flags = npy_array_out->flags | NPY_OWNDATA;
return (PyObject *)npy_array_out;
}
}
PyObject* landmarks_to_PyArray( // Convert landmarks array to numpy array
float* landmarks, // in
int num_landmarks) // in
{
const int nd = 2;
npy_intp dims[nd] = { num_landmarks, 2 };
PyObject* retArray = PyArray_SimpleNewFromData(nd, dims, NPY_FLOAT, landmarks);
PyArray_ENABLEFLAGS((PyArrayObject*)retArray, NPY_ARRAY_OWNDATA);
return retArray;
}