static PyObject * _Bas_bspeval(PyObject *self, PyObject *args)
{
int d, mc, nc, nu, dim[2];
double **ctrlmat, **pntmat;
PyObject *input_ctrl, *input_k, *input_u;
PyArrayObject *ctrl, *k, *u, *pnt;
if(!PyArg_ParseTuple(args, "iOOO", &d, &input_ctrl, &input_k, &input_u))
return NULL;
ctrl = (PyArrayObject *) PyArray_ContiguousFromObject(input_ctrl, PyArray_DOUBLE, 2, 2);
if(ctrl == NULL)
return NULL;
k = (PyArrayObject *) PyArray_ContiguousFromObject(input_k, PyArray_DOUBLE, 1, 1);
if(k == NULL)
return NULL;
u = (PyArrayObject *) PyArray_ContiguousFromObject(input_u, PyArray_DOUBLE, 1, 1);
if(u == NULL)
return NULL;
mc = ctrl->dimensions[0];
nc = ctrl->dimensions[1];
nu = u->dimensions[0];
dim[0] = mc;
dim[1] = nu;
pnt = (PyArrayObject *) PyArray_FromDims(2, dim, PyArray_DOUBLE);
ctrlmat = vec2mat(ctrl->data, mc, nc);
pntmat = vec2mat(pnt->data, mc, nu);
_bspeval(d, ctrlmat, mc, nc, (double *)k->data, k->dimensions[0], (double *)u->data, nu, pntmat);
free(pntmat);
free(ctrlmat);
Py_DECREF(ctrl);
Py_DECREF(k);
Py_DECREF(u);
return PyArray_Return(pnt);
}
static PyObject * _Bas_bspdeval(PyObject *self, PyObject *args)
{
int d, mc, nc, n;
npy_intp dim[2];
double u, **ctrlmat, **pntmat;
PyObject *input_ctrl, *input_k;
PyArrayObject *ctrl, *k, *pnt;
if(!PyArg_ParseTuple(args, "iOOdi", &d, &input_ctrl, &input_k, &u, &n))
return NULL;
ctrl = (PyArrayObject *) PyArray_ContiguousFromObject(input_ctrl, PyArray_DOUBLE, 2, 2);
if(ctrl == NULL)
return NULL;
k = (PyArrayObject *) PyArray_ContiguousFromObject(input_k, PyArray_DOUBLE, 1, 1);
if(k == NULL)
return NULL;
mc = ctrl->dimensions[0];
nc = ctrl->dimensions[1];
dim[0] = mc;
dim[1] = n + 1;
pnt = (PyArrayObject *) PyArray_SimpleNew(2, dim, PyArray_DOUBLE);
ctrlmat = vec2mat(ctrl->data, mc, nc);
pntmat = vec2mat(pnt->data, mc, n + 1);
_bspdeval(d, ctrlmat, mc, nc, (double *)k->data, k->dimensions[0], u, n, pntmat);
free(pntmat);
free(ctrlmat);
Py_DECREF(ctrl);
Py_DECREF(k);
return PyArray_Return(pnt);
}
// =============================================================================
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;
}
static PyObject *
_fasttrips_set_bump_wait(PyObject* self, PyObject *args)
{
PyObject *input1, *input2;
if (!PyArg_ParseTuple(args, "OO", &input1, &input2)) {
return NULL;
}
PyArrayObject *pyo;
// bump wait index: trip id, stop sequence, stop id
pyo = (PyArrayObject*)PyArray_ContiguousFromObject(input1, NPY_INT32, 2, 2);
if (pyo == NULL) return NULL;
int* bw_index = (int*)PyArray_DATA(pyo);
int num_bw = PyArray_DIMS(pyo)[0];
assert(3 == PyArray_DIMS(pyo)[1]);
// bump wait data: arrival time
pyo = (PyArrayObject*)PyArray_ContiguousFromObject(input2, NPY_DOUBLE, 1, 1);
if (pyo == NULL) return NULL;
double* bw_times= (double*)PyArray_DATA(pyo);
int num_times = PyArray_DIMS(pyo)[0];
assert(num_times == num_bw);
pathfinder.setBumpWait(bw_index, bw_times, num_bw);
Py_RETURN_NONE;
}
static PyObject * _Bas_bspdegelev(PyObject *self, PyObject *args)
{
int d, mc, nc, nk, t, nh;
npy_intp dim[2];
double **ctrlmat, **icmat;
PyObject *input_ctrl, *input_k;
PyArrayObject *ctrl, *k, *ic, *ik;
if(!PyArg_ParseTuple(args, "iOOi", &d, &input_ctrl, &input_k, &t))
return NULL;
ctrl = (PyArrayObject *) PyArray_ContiguousFromObject(input_ctrl, PyArray_DOUBLE, 2, 2);
if(ctrl == NULL)
return NULL;
k = (PyArrayObject *) PyArray_ContiguousFromObject(input_k, PyArray_DOUBLE, 1, 1);
if(k == NULL)
return NULL;
mc = ctrl->dimensions[0];
nc = ctrl->dimensions[1];
nk = k->dimensions[0];
dim[0] = mc;
dim[1] = nc*(t + 1);
ic = (PyArrayObject *) PyArray_SimpleNew(2, dim, PyArray_DOUBLE);
ctrlmat = vec2mat(ctrl->data, mc, nc);
icmat = vec2mat(ic->data, mc, nc*(t + 1));
dim[0] = (t + 1)*nk;
ik = (PyArrayObject *) PyArray_SimpleNew(1, dim, PyArray_DOUBLE);
_bspdegelev(d, ctrlmat, mc, nc, (double *)k->data, nk, t, &nh, icmat, (double *)ik->data);
free(icmat);
free(ctrlmat);
Py_DECREF(ctrl);
Py_DECREF(k);
return Py_BuildValue("(OOi)", (PyObject *)ic, (PyObject *)ik, nh);
}
static PyObject *
create_graph(PyObject *self, PyObject *args)
{
int id, twoway;
PyObject *input1, *input2, *input3, *input4;
// this is node ids, node xys, edge ids, and edge weights
if (!PyArg_ParseTuple(args, "iOOOOi", &id, &input1, &input2,
&input3, &input4, &twoway))
return NULL;
PyArrayObject *pyo;
pyo = (PyArrayObject*)PyArray_ContiguousFromObject(input1,
NPY_INT32, 1, 1);
if (pyo == NULL) return NULL;
int *nodeids = (int*)PyArray_DATA(pyo);
int numnodes = PyArray_DIMS(pyo)[0];
pyo = (PyArrayObject*)PyArray_ContiguousFromObject(input2,
NPY_FLOAT32, 2, 2);
if (pyo == NULL) return NULL;
float *nodexy = (float*)PyArray_DATA(pyo);
assert(numnodes == PyArray_DIMS(pyo)[0]);
assert(2 == PyArray_DIMS(pyo)[1]);
pyo = (PyArrayObject*)PyArray_ContiguousFromObject(input3,
NPY_INT32, 2, 2);
if (pyo == NULL) return NULL;
int *edges = (int*)PyArray_DATA(pyo);
int numedges = PyArray_DIMS(pyo)[0];
assert(2 == PyArray_DIMS(pyo)[1]);
pyo = (PyArrayObject*)PyArray_ContiguousFromObject(input4,
NPY_FLOAT32, 1, 2);
if (pyo == NULL) return NULL;
float *edgeweights = (float*)PyArray_DATA(pyo);
int numimpedances = 1;
if(PyArray_NDIM(pyo) == 1) assert(numedges == PyArray_DIMS(pyo)[0]);
else {
numimpedances = PyArray_DIMS(pyo)[0];
assert(numedges == PyArray_DIMS(pyo)[1]);
}
if(id>=sas.size()) return NULL;
std::shared_ptr<MTC::accessibility::Accessibility> sa = sas[id];
for(int i = 0 ; i < numimpedances ; i++) {
std::shared_ptr<MTC::accessibility::Graphalg>
ptr(new MTC::accessibility::Graphalg);
sa->ga.push_back(ptr);
sa->ga[i]->Build(nodeids, nodexy, numnodes, edges,
edgeweights+(numedges*i), numedges, twoway);
}
sa->numnodes = sa->ga[0]->numnodes;
Py_RETURN_NONE;
}
/* Process python arguments and call Delaunay implementation method. */
static PyObject*
delaunay(PyObject *self, PyObject *args)
{
PyObject* xarg;
PyObject* yarg;
PyArrayObject* xarray;
PyArrayObject* yarray;
PyObject* ret;
int npoints;
const double* x;
const double* y;
if (!PyArg_ParseTuple(args, "OO", &xarg, &yarg)) {
PyErr_SetString(PyExc_ValueError, "expecting x and y arrays");
return NULL;
}
xarray = (PyArrayObject*)PyArray_ContiguousFromObject(xarg, NPY_DOUBLE,
1, 1);
yarray = (PyArrayObject*)PyArray_ContiguousFromObject(yarg, NPY_DOUBLE,
1, 1);
if (xarray == 0 || yarray == 0 ||
PyArray_DIM(xarray,0) != PyArray_DIM(yarray, 0)) {
Py_XDECREF(xarray);
Py_XDECREF(yarray);
PyErr_SetString(PyExc_ValueError,
"x and y must be 1D arrays of the same length");
return NULL;
}
npoints = PyArray_DIM(xarray, 0);
if (npoints < 3) {
Py_XDECREF(xarray);
Py_XDECREF(yarray);
PyErr_SetString(PyExc_ValueError,
"x and y arrays must have a length of at least 3");
return NULL;
}
x = (const double*)PyArray_DATA(xarray);
y = (const double*)PyArray_DATA(yarray);
if (!at_least_3_unique_points(npoints, x, y)) {
Py_XDECREF(xarray);
Py_XDECREF(yarray);
PyErr_SetString(PyExc_ValueError,
"x and y arrays must consist of at least 3 unique points");
return NULL;
}
ret = delaunay_impl(npoints, x, y, Py_VerboseFlag == 0);
Py_XDECREF(xarray);
Py_XDECREF(yarray);
return ret;
}
static PyObject *
PyCMOR_zfactor(PyObject *self,PyObject *args)
{
int ierr,zvar_id;
int itmp;
int axis_id;
char *name;
char *units;
int ndims;
char type;
int *axes_ids;
void *values,*bounds;
PyObject *axes_obj,*values_obj,*bounds_obj;
PyArrayObject *axes=NULL, *values_array=NULL, *bounds_array=NULL;
/* HUGE assumtion here is that the data is contiguous! */
if (!PyArg_ParseTuple(args,"issiOcOO",&axis_id,&name,&units,&ndims,&axes_obj,&type,&values_obj,&bounds_obj))
return NULL;
if (axes_obj == Py_None) {
axes_ids = NULL;
}
else {
if (ndims>1) {
axes =(PyArrayObject *) PyArray_ContiguousFromObject(axes_obj,PyArray_NOTYPE,1,0);
axes_ids = (void *)axes->data;
}
else {
itmp = (int) PyInt_AsLong(axes_obj);
axes_ids = &itmp;
}
}
if (values_obj == Py_None) {
values = NULL;
}
else {
values_array =(PyArrayObject *) PyArray_ContiguousFromObject(values_obj,PyArray_NOTYPE,1,0);
values = (void *)values_array->data;
}
if (bounds_obj == Py_None) {
bounds = NULL;
}
else {
bounds_array =(PyArrayObject *) PyArray_ContiguousFromObject(bounds_obj,PyArray_NOTYPE,1,0);
bounds = (void *)bounds_array->data;
}
ierr = cmor_zfactor(&zvar_id,axis_id, name, units, ndims, axes_ids, type, values, bounds);
if (axes!=NULL) {Py_DECREF(axes);}
if (values_array!=NULL) {Py_DECREF(values_array);}
if (bounds_array!=NULL) {Py_DECREF(bounds_array);}
if (ierr != 0 ) return NULL;
return Py_BuildValue("i",zvar_id);
}
static PyObject *colfwt(PyObject *self, PyObject *args) {
PyObject *pyX, *pylp, *pyhp, *pylambda;
PyArrayObject *X, *Y, *lp, *hp;
int D, columns, N, pwr, lambda, Coarsest_level = 1;
char *msg;
/* process the parameters */
if (!PyArg_ParseTuple(args, "OOOO", &pyX, &pylp, &pyhp, &pylambda))
return NULL;
/* Make Numeric array from general sequence types (no cost if already Numeric)*/
X = (PyArrayObject *)
PyArray_ContiguousFromObject(pyX, PyArray_DOUBLE, 0, 0);
lp = (PyArrayObject *)
PyArray_ContiguousFromObject(pylp, PyArray_NOTYPE, 0, 0);
hp = (PyArrayObject *)
PyArray_ContiguousFromObject(pyhp, PyArray_NOTYPE, 0, 0);
D = lp->dimensions[0];
if (X -> nd == 2) {
N = X->dimensions[0]; //Rows in matrix
columns = X->dimensions[1];
} else if (X -> nd == 1) {
N = X->dimensions[0]; //Elements in 1d vector
columns = 1;
} else {
msg = "Input array must have dimension 1 or 2";
PyErr_SetString(PyExc_ValueError, msg); //raise ValueError
return NULL;
}
//Make Y a Numeric array same dims as X
Y = (PyArrayObject *) PyArray_FromDims(X -> nd, X -> dimensions, X -> descr -> type_num);
if (PyInt_Check(pylambda)) {
lambda = PyInt_AsLong(pylambda);
pwr = pow(2,lambda);
Coarsest_level = max((int) (N/ (float) pwr), 1);
}
_colfwt ((double *) X -> data, N, columns,
(double *) lp -> data, (double *) hp -> data,
D, Coarsest_level, (double *) Y -> data);
return PyArray_Return(Y);
}
static PyObject *UtilsC_maximization_beta(PyObject *self, PyObject *args){
PyObject *q_Z,*Z_tilde,*graph;
PyArrayObject *q_Zarray,*Z_tildearray,*grapharray;
npy_float64 beta,gamma,Gr,gradientStep;
int j,J,K,k,ni,maxNeighbours,nn,MaxItGrad;
PyArg_ParseTuple(args, "dOOiiOdiid", &beta,&q_Z,&Z_tilde,&J,&K,&graph,&gamma,&maxNeighbours,&MaxItGrad,&gradientStep);
q_Zarray = (PyArrayObject *) PyArray_ContiguousFromObject(q_Z,PyArray_FLOAT64,2,2);
Z_tildearray = (PyArrayObject *) PyArray_ContiguousFromObject(Z_tilde,PyArray_FLOAT64,2,2);
grapharray = (PyArrayObject *) PyArray_ContiguousFromObject(graph,PyArray_INT,2,2);
npy_float64 tmp2[K],Emax,Sum,tmp,Pzmi;
Gr = gamma;
ni = 0;
while( (ni<MaxItGrad) && (fabs(Gr) > eps) ){
Gr = gamma;
for (j=0;j<J;j++){
Emax = 0;
for (k=0;k<K;k++){
tmp2[k] = 0;
nn = 0;
while(GetValueInt(grapharray,j,nn) != -1 && nn<maxNeighbours) {
tmp2[k] += beta * GetValue(Z_tildearray,k,GetValueInt(grapharray,j,nn));
nn++;
}
if (tmp2[k] > Emax) Emax = tmp2[k];
}
Sum = 0;
for (k=0;k<K;k++){
Sum += exp(tmp2[k] - Emax);
}
for (k=0;k<K;k++){
tmp = 0;
nn = 0;
while(GetValueInt(grapharray,j,nn) != -1 && nn<maxNeighbours) {
tmp += GetValue(Z_tildearray,k,GetValueInt(grapharray,j,nn));
nn++;
}
Pzmi = exp(beta * tmp - Emax) / (Sum + eps);
Gr += tmp * ( Pzmi - GetValue(q_Zarray,k,j) );
}
}
beta -= gradientStep*Gr;
ni++;
}
if (eps > beta) beta = 0.01;
Py_DECREF(grapharray);
Py_DECREF(q_Zarray);
Py_DECREF(Z_tildearray);
Py_INCREF(Py_None);
return Py_BuildValue("d", beta);
}
double chiSquare(python::object resArr) {
PyObject *matObj = resArr.ptr();
if (!PyArray_Check(matObj)) {
throw_value_error("Expecting a Numeric array object");
}
PyArrayObject *copy;
copy = (PyArrayObject *)PyArray_ContiguousFromObject(
matObj, ((PyArrayObject *)matObj)->descr->type_num, 2, 2);
long int rows = (long int)((PyArrayObject *)matObj)->dimensions[0];
long int cols = (long int)((PyArrayObject *)matObj)->dimensions[1];
double res = 0.0;
if (((PyArrayObject *)matObj)->descr->type_num == PyArray_DOUBLE) {
double *data = (double *)copy->data;
res = ChiSquare(data, rows, cols);
} else if (((PyArrayObject *)matObj)->descr->type_num == PyArray_FLOAT) {
float *data = (float *)copy->data;
res = ChiSquare(data, rows, cols);
} else if (((PyArrayObject *)matObj)->descr->type_num == PyArray_INT) {
int *data = (int *)copy->data;
res = ChiSquare(data, rows, cols);
} else if (((PyArrayObject *)matObj)->descr->type_num == PyArray_LONG) {
long int *data = (long int *)copy->data;
res = ChiSquare(data, rows, cols);
} else {
throw_value_error(
"Numeric array object of type int or long or float or double");
}
Py_DECREF(copy);
return res;
}
static PyObject *send_array(PyObject *self, PyObject *args) {
PyObject *input;
PyArrayObject *x;
int destination, tag, err;
MPI_Datatype mpi_type;
/* process the parameters */
if (!PyArg_ParseTuple(args, "Oii", &input, &destination, &tag))
return NULL;
/* Make Numeric array from general sequence type (no cost if already Numeric)*/
x = (PyArrayObject *)
PyArray_ContiguousFromObject(input, PyArray_NOTYPE, 0, 0);
/* Input check and determination of MPI type */
mpi_type = type_map(x);
if (!mpi_type) return NULL;
/* call the MPI routine */
err = MPI_Send(x->data, x->dimensions[0], mpi_type, destination, tag,\
MPI_COMM_WORLD);
Py_DECREF(x);
return Py_BuildValue("i", err);
}
static PyObject * _Bas_basisfuns(PyObject *self, PyObject *args)
{
int i, p, ret;
double u;
int dim[2];
PyObject *input_U;
PyArrayObject *N, *U;
ret=-1;
ret = PyArg_ParseTuple(args, "iOdi", &i, &input_U, &u, &p);
if(!ret)
{
//printf("i=%d, u=%g, p=%d, ret=%d\n", i, u, p);
return NULL;
}
U = (PyArrayObject *) PyArray_ContiguousFromObject(input_U, PyArray_DOUBLE, 1, 1);
if(U == NULL)
return NULL;
dim[0] = p+1;
dim[1] = 0;
// N array is p+1 in size
N = (PyArrayObject *) PyArray_FromDims(1, dim, PyArray_DOUBLE);
_basisfuns(i, u, p, (double *)U->data, (double *)N->data);
// printf("*N->data[0]=%g \n", (double *)N->data[0]);
// printf("*N->data[1]=%g \n", (double *)N->data[1]);
//return (PyObject *)N;
// return Py_BuildValue("O", (PyObject *)N );
return PyArray_Return(N);
}
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);
}
static PyObject * computeMean(PyObject *obj, PyObject *args)
{
PyObject *oimage;
PyArrayObject *image;
int status=0;
int numGoodPixels;
float clipmin, clipmax, mean, stddev, minValue, maxValue;
if (!PyArg_ParseTuple(args,"Off:computeMean",&oimage, &clipmin, &clipmax))
return NULL;
image = (PyArrayObject *)PyArray_ContiguousFromObject(oimage, NPY_FLOAT32, 1, 2);
if (!image) return NULL;
mean = 0;
stddev = 0;
numGoodPixels = 0;
minValue = 0;
maxValue = 0;
status = computeMean_((float *)PyArray_DATA(image), PyArray_Size((PyObject*)image),
clipmin, clipmax,
&numGoodPixels, &mean, &stddev, &minValue, &maxValue);
Py_XDECREF(image);
return Py_BuildValue("iffff",numGoodPixels,mean,stddev,minValue,maxValue);
}
static PyObject *send_array(PyObject *self, PyObject *args) {
PyObject *input;
PyArrayObject *x;
int destination, tag, error, count;
MPI_Datatype mpi_type;
/* process the parameters */
if (!PyArg_ParseTuple(args, "Oii", &input, &destination, &tag))
return NULL;
/* Make Numpy array from general sequence type (no cost if already Numpy). */
x = (PyArrayObject *)
PyArray_ContiguousFromObject(input, NPY_NOTYPE, 0, 0);
/* Input check and determination of MPI type */
mpi_type = type_map(x, &count);
if (!mpi_type) return NULL;
/* call the MPI routine */
error = MPI_Send(x->data, count, mpi_type, destination, tag,
MPI_COMM_WORLD);
Py_DECREF(x);
if (error != 0) {
rank_raise_mpi_runtime(error, "MPI_Send");
return NULL;
}
Py_INCREF(Py_None);
return (Py_None);
}
// Static helper functions
// =============================================================================
double * Epetra_NumPySerialDenseVector::getArray(PyObject * pyObject)
{
// If tmp_array is NULL, build a PyArrayObject from the pyObject
if (tmp_array == NULL)
{
// If pyObject is an int, build an array of that length
if (PyInt_Check(pyObject))
{
npy_intp dimensions[ ] = {(npy_intp) PyInt_AsLong(pyObject)};
tmp_array = (PyArrayObject*)
PyArray_SimpleNew(1,dimensions,PyArray_DOUBLE);
}
// Else try to build a contiguous PyArrayObject from the pyObject
else
{
tmp_array = (PyArrayObject *)
PyArray_ContiguousFromObject(pyObject,PyArray_DOUBLE,0,0);
}
}
// If these fail, clean up and throw a PythonException
if (!tmp_array)
{
cleanup();
throw PythonException();
}
return (double*)(tmp_array->data);
}
double infoGain(python::object resArr) {
PyObject *matObj = resArr.ptr();
if (!PyArray_Check(matObj)) {
throw_value_error("Expecting a Numeric array object");
}
PyArrayObject *copy;
copy = (PyArrayObject *)PyArray_ContiguousFromObject(
matObj, PyArray_DESCR((PyArrayObject *)matObj)->type_num, 2, 2);
long int rows = (long int)PyArray_DIM((PyArrayObject *)matObj, 0);
long int cols = (long int)PyArray_DIM((PyArrayObject *)matObj, 1);
double res = 0.0;
if (PyArray_DESCR((PyArrayObject *)matObj)->type_num == NPY_DOUBLE) {
double *data = (double *)PyArray_DATA(copy);
res = InfoEntropyGain(data, rows, cols);
} else if (PyArray_DESCR((PyArrayObject *)matObj)->type_num == NPY_FLOAT) {
float *data = (float *)PyArray_DATA(copy);
res = InfoEntropyGain(data, rows, cols);
} else if (PyArray_DESCR((PyArrayObject *)matObj)->type_num == NPY_INT) {
int *data = (int *)PyArray_DATA(copy);
res = InfoEntropyGain(data, rows, cols);
} else if (PyArray_DESCR((PyArrayObject *)matObj)->type_num == NPY_LONG) {
long int *data = (long int *)PyArray_DATA(copy);
res = InfoEntropyGain(data, rows, cols);
} else {
throw_value_error(
"Numeric array object of type int or long or float or double");
}
Py_DECREF(copy);
return res;
}
int array_pack(void *vr, PyObject *obj, long nitems, PP_types tc)
{
#ifdef HAVE_PY_NUMERIC
PyArrayObject *arr;
PP_numpy_map *entry;
if (tc > 0 && tc < PP_NUM_TYPES) {
entry = tc_to_entry[tc];
} else {
entry = NULL;
}
if (entry == NULL) {
/* XXX set error */
return -1;
}
arr = (PyArrayObject *)
PyArray_ContiguousFromObject(obj, entry->type_num, 0, 0);
if (arr == NULL)
return -1;
memcpy(vr, arr->data, nitems * arr->descr->elsize);
Py_DECREF(arr);
#endif
return 0;}
Py::Object Triangulation::set_mask(const Py::Tuple &args)
{
_VERBOSE("Triangulation::set_mask");
args.verify_length(1);
Py_XDECREF(_mask);
_mask = 0;
if (args[0] != Py::None())
{
_mask = (PyArrayObject*)PyArray_ContiguousFromObject(
args[0].ptr(), PyArray_BOOL, 1, 1);
if (_mask == 0 || PyArray_DIM(_mask,0) != PyArray_DIM(_triangles,0)) {
Py_XDECREF(_mask);
throw Py::ValueError(
"mask must be a 1D array with the same length as the triangles array");
}
}
// Clear derived fields so they are recalculated when needed.
Py_XDECREF(_edges);
_edges = 0;
Py_XDECREF(_neighbors);
_neighbors = 0;
_boundaries.clear();
return Py::None();
}
double infoEntropy(python::object resArr) {
PyObject *matObj = resArr.ptr();
if (!PyArray_Check(matObj)) {
throw_value_error("Expecting a Numeric array object");
}
PyArrayObject *copy;
copy = (PyArrayObject *)PyArray_ContiguousFromObject(
matObj, ((PyArrayObject *)matObj)->descr->type_num, 1, 1);
double res = 0.0;
// we are expecting a 1 dimensional array
long int ncols = (long int)((PyArrayObject *)matObj)->dimensions[0];
CHECK_INVARIANT(ncols > 0, "");
if (((PyArrayObject *)matObj)->descr->type_num == PyArray_DOUBLE) {
double *data = (double *)copy->data;
res = InfoEntropy(data, ncols);
} else if (((PyArrayObject *)matObj)->descr->type_num == PyArray_FLOAT) {
float *data = (float *)copy->data;
res = InfoEntropy(data, ncols);
} else if (((PyArrayObject *)matObj)->descr->type_num == PyArray_INT) {
int *data = (int *)copy->data;
res = InfoEntropy(data, ncols);
} else if (((PyArrayObject *)matObj)->descr->type_num == PyArray_LONG) {
long int *data = (long int *)copy->data;
res = InfoEntropy(data, ncols);
}
Py_DECREF(copy);
return res;
}
//AWMS: FIXME think about non-numeric sequences and whether we should return a cell array instead
static mxArray *makeMxFromSeq(const PyObject *pSrc)
{
mxArray *lRetval = NULL;
mwIndex i;
mwSize lSize;
PyArrayObject *lArray =
(PyArrayObject *) PyArray_ContiguousFromObject(const_cast<PyObject *>(pSrc),
PyArray_CDOUBLE, 0, 0);
if (lArray == NULL) return NULL;
// AWMS: FIXME this is not a particularly intelligent way to set about
// things
// If all imaginary components are 0, this is not a complex array.
lSize = PyArray_SIZE(lArray);
// Get at first imaginary element
const double *lPtr = (const double *)(lArray->data) + 1;
for (i=0; i != lSize; i++, lPtr += 2) {
if (*lPtr != 0.0) break;
}
if (i >= lSize) {
PyArrayObject *lNew = (PyArrayObject *)PyArray_Cast(lArray, PyArray_DOUBLE);
Py_DECREF(lArray);
lArray = lNew;
}
lRetval = makeMxFromNumeric(lArray);
Py_DECREF(lArray);
return lRetval;
}
//numpy wrapper for radial velocity function
static PyObject * RadVel_np(PyObject *self, PyObject *args)
{
//define array object
PyObject * t;
PyArrayObject * array;
PyArrayObject * output;
double e,P,w,K;
//read in object
if (!PyArg_ParseTuple(args, "Odddd", &t, &e, &P, &w, &K))
return NULL;
//convert to contiguous array of doubles - will accept up to 10d arrays
array = (PyArrayObject*) PyArray_ContiguousFromObject(t, PyArray_DOUBLE, 1, 10);
if(array == NULL) return NULL;
//calculate no of data size of array
int n,size=1;
for(n=0;n<array->nd;n++)
size *= array->dimensions[n];
//create output array
output = (PyArrayObject*) PyArray_SimpleNew(array->nd, array->dimensions, PyArray_DOUBLE);
//create data for output array from input array
for(n=0;n<size;n++)
*(((double*)output->data) + n) = Rad_vel(*(((double*)array->data) + n),e,P,w,K);
//must destroy reference to array
Py_DECREF(array);
//return array
return PyArray_Return(output);
}
// REVIEW: the poolSize can be pulled from the numeric array
RDKit::INT_VECT MaxMinPicks(MaxMinPicker *picker, python::object distMat,
int poolSize, int pickSize,
python::object firstPicks, int seed) {
if (pickSize >= poolSize) {
throw ValueErrorException("pickSize must be less than poolSize");
}
if (!PyArray_Check(distMat.ptr())) {
throw ValueErrorException("distance mat argument must be a numpy matrix");
}
PyArrayObject *copy;
copy = (PyArrayObject *)PyArray_ContiguousFromObject(distMat.ptr(),
PyArray_DOUBLE, 1, 1);
double *dMat = (double *)copy->data;
RDKit::INT_VECT firstPickVect;
for (unsigned int i = 0;
i < python::extract<unsigned int>(firstPicks.attr("__len__")()); ++i) {
firstPickVect.push_back(python::extract<int>(firstPicks[i]));
}
RDKit::INT_VECT res =
picker->pick(dMat, poolSize, pickSize, firstPickVect, seed);
Py_DECREF(copy);
return res;
}
static PyObject *
initialize_category(PyObject *self, PyObject *args)
{
int id;
PyObject *input1;
if (!PyArg_ParseTuple(args, "iO", &id, &input1)) return NULL;
std::shared_ptr<MTC::accessibility::Accessibility> sa = sas[0];
PyArrayObject *pyo;
pyo = (PyArrayObject*)PyArray_ContiguousFromObject(input1,
NPY_FLOAT32, 2, 2);
if (pyo == NULL) return NULL;
float *pois = (float*)PyArray_DATA(pyo);
int numpois = PyArray_DIMS(pyo)[0];
assert(2 == PyArray_DIMS(pyo)[1]);
MTC::accessibility::accessibility_vars_t av;
av.resize(sa->numnodes);
for(int i = 0 ; i < numpois ; i++) {
// XXX this should really only respond to node ids and use the xy
// conversion function below
int nodeid = sa->ga[0]->NearestNode(pois[i*2+0],pois[i*2+1],NULL);
//assert(nodeid < sa->ga[0].numpois);
av[nodeid].push_back(nodeid);
}
sa->initializeCategory(id,av);
Py_RETURN_NONE;
}
// Static helper functions
// =============================================================================
double * Epetra_NumPyMultiVector::getArray(PyObject * pyObject)
{
// Try to build a contiguous PyArrayObject from the pyObject
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
{
if (PyArray_NDIM(tmp_array) < 2)
{
PyObject * tuple = Py_BuildValue("(ii)",1,-1);
tmp_array = (PyArrayObject *) PyArray_Reshape(tmp_array,tuple);
Py_DECREF(tuple);
}
}
return (double *) (PyArray_DATA(tmp_array));
}
// =============================================================================
int * Epetra_NumPyMultiVector::getRange(PyObject * range,
const Epetra_MultiVector & source)
{
// Handle the default case (range == NULL), which is to return a
// range of all the Epetra_MultiVector vectors
if (range == NULL)
{
npy_intp dims[ ] = { (npy_intp) source.NumVectors() };
tmp_range = (PyArrayObject *) PyArray_SimpleNew(1,dims,NPY_INT);
if (!tmp_range)
{
cleanup();
throw PythonException();
}
int * data = (int *) PyArray_DATA(tmp_range);
for (int i=0; i<dims[0]; i++) data[i] = i;
}
// Try to create a contiguous array of integers from the PyObject
if (!tmp_range)
tmp_range = (PyArrayObject *)
PyArray_ContiguousFromObject(range,NPY_INT,1,1);
// If this fails, clean up and throw a PythonException
if (!tmp_range)
{
cleanup();
throw PythonException();
}
// Obtain the length and return the array of integers
return (int *) (PyArray_DATA(tmp_range));
}
static PyObject * _Bas_bspbezdecom(PyObject *self, PyObject *args)
{
int i, b, c, d, mc, nc, nk, m;
npy_intp dim[2];
double **ctrlmat, **icmat;
PyObject *input_ctrl, *input_k;
PyArrayObject *ctrl, *k, *ic;
if(!PyArg_ParseTuple(args, "iOO", &d, &input_ctrl, &input_k))
return NULL;
ctrl = (PyArrayObject *) PyArray_ContiguousFromObject(input_ctrl, PyArray_DOUBLE, 2, 2);
if(ctrl == NULL)
return NULL;
k = (PyArrayObject *) PyArray_ContiguousFromObject(input_k, PyArray_DOUBLE, 1, 1);
if(k == NULL)
return NULL;
mc = ctrl->dimensions[0];
nc = ctrl->dimensions[1];
nk = k->dimensions[0];
i = d + 1;
c = 0;
m = nk - d - 1;
while (i < m)
{
b = 1;
while (i < m && *(double *)(k->data + i * k->strides[0]) == *(double *)(k->data + (i + 1) * k->strides[0]))
{
b++;
i++;
}
if(b < d)
c = c + (d - b);
i++;
}
dim[0] = mc;
dim[1] = nc+c;
ic = (PyArrayObject *) PyArray_SimpleNew(2, dim, PyArray_DOUBLE);
ctrlmat = vec2mat(ctrl->data, mc, nc);
icmat = vec2mat(ic->data, mc, nc+c);
_bspbezdecom(d, ctrlmat, mc, nc, (double *)k->data, nk, icmat);
free(icmat);
free(ctrlmat);
Py_DECREF(ctrl);
Py_DECREF(k);
return Py_BuildValue("O", ic);
}
static PyObject *
PyCMOR_variable(PyObject *self,PyObject *args)
{
int ierr,var_id;
char *name;
char *units;
char *comment;
char *positive;
char *original_name;
char *history;
int ndims;
char type;
double missing;
float fmissing;
int imissing;
long lmissing;
double tol;
void *pass_missing=NULL;
int *axes_ids;
PyObject *axes_obj,*missing_obj;
PyArrayObject *axes=NULL;
/* HUGE assumtion here is that the data is contiguous! */
if (!PyArg_ParseTuple(args,"ssiOcOdssss",&name,&units,&ndims,&axes_obj,&type,&missing_obj,&tol,&positive,&original_name,&history,&comment))
return NULL;
axes =(PyArrayObject *) PyArray_ContiguousFromObject(axes_obj,PyArray_NOTYPE,1,0);
if (axes->nd!=1) {
printf("ok we need to pass contiguous flattened arrays only!\n");
return NULL;
}
axes_ids = (int *)axes->data;
if (missing_obj == Py_None) {
pass_missing = NULL;
}
else {
missing = PyFloat_AsDouble(missing_obj);
if (type=='d') pass_missing=&missing;
else if (type=='f') {
fmissing = (float)missing;
pass_missing=&fmissing;
}
else if (type=='l') {
lmissing = (long)missing;
pass_missing=&lmissing;
}
else if (type=='i') {
imissing = (int)missing;
pass_missing=&imissing;
}
}
ierr = cmor_variable(&var_id,name, units, ndims, axes_ids, type, pass_missing, &tol, positive, original_name, history, comment) ;
if (axes!=NULL) {Py_DECREF(axes);}
if (ierr != 0 ) return NULL;
return Py_BuildValue("i",var_id);
}
static PyObject *PyCMOR_grid_mapping(PyObject * self, PyObject * args)
{
signal(signal_to_catch, signal_handler);
int ierr;
PyObject *param_nm_obj, *param_val_obj, *param_un_obj, *tmp;
PyArrayObject *param_val_arr = NULL;
void *param_val;
char *name;
int gid, i, n;
char nms[CMOR_MAX_GRID_ATTRIBUTES][CMOR_MAX_STRING];
char units[CMOR_MAX_GRID_ATTRIBUTES][CMOR_MAX_STRING];
/* HUGE assumtion here is that the data is contiguous! */
if (!PyArg_ParseTuple
(args, "isOOO", &gid, &name, ¶m_nm_obj, ¶m_val_obj,
¶m_un_obj))
return NULL;
param_val_arr =
(PyArrayObject *) PyArray_ContiguousFromObject(param_val_obj,
NPY_NOTYPE, 1, 0);
param_val = PyArray_DATA(param_val_arr);
n = PyList_Size(param_nm_obj);
for (i = 0; i < n; i++) {
tmp = PyList_GetItem(param_nm_obj, i);
#if PY_MAJOR_VERSION >= 3
strcpy(nms[i], PyBytes_AsString(tmp));
#else
strcpy(nms[i], PyString_AsString(tmp));
#endif
//Py_DECREF(tmp); //Not needed get_item does not increase ref
tmp = PyList_GetItem(param_un_obj, i);
#if PY_MAJOR_VERSION >= 3
strcpy(units[i], PyBytes_AsString(tmp));
#else
strcpy(units[i], PyString_AsString(tmp));
#endif
//Py_DECREF(tmp); // Not need get_item does not incref
}
ierr =
cmor_set_grid_mapping(gid, name, n, (char *)nms,
CMOR_MAX_STRING, param_val,
(char *)units, CMOR_MAX_STRING);
if (param_val_arr != NULL) {
Py_DECREF(param_val_arr);
}
if (ierr != 0 || raise_exception) {
raise_exception = 0;
PyErr_Format(CMORError, exception_message, "grid_mapping");
return NULL;
}
return (Py_BuildValue("i", ierr));
}
