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)); }