static PyObject *build_array(const std::pair<Iterator, Iterator> &range) {
size_t sz = (npy_intp)std::distance(range.first, range.second);
npy_intp fdims[] = {(npy_intp)sz};
PyObject *array = (PyObject*)PyArray_SimpleNew(1, fdims, NPY_OBJECT);
try {
size_t i = 0;
for (Iterator it = range.first; it != range.second; it++, i++) {
PyObject **ref = (PyObject **)PyArray_GETPTR1((PyArrayObject*)array, i);
PyObject *newobj = as_python_string(*it);
Py_XDECREF(*ref);
*ref = newobj;
}
}
catch (...) {
size_t i = 0;
for (i = 0; i < sz; i++) {
PyObject **ref = (PyObject **)PyArray_GETPTR1((PyArrayObject*)array, i);
Py_XDECREF(*ref);
*ref = Py_None;
Py_XINCREF(*ref);
}
Py_XDECREF(array);
array = NULL;
std::rethrow_exception(std::current_exception());
}
return array;
}
/**
* Update all branch counts associated with a given leaf
*/
void dtnode :: modify_count(double val, int leaf)
{
// Is this leaf under one of our interior children?
for(uint i = 0; i < ichildren.size(); i++)
{
if(leaf <= maxind[i])
{
// Update edge and sum
(*((double*)PyArray_GETPTR1(this->edges,i))) += val;
edgesum += val;
// Recursively update child cts
(*(ichildren[i])).modify_count(val,leaf);
return;
}
}
// No, this leaf must be one of our leaves
// Get leaf edge index
int ei = ichildren.size() + (leaf - leafstart);
// Update edge and sum
(*((double*)PyArray_GETPTR1(edges,ei))) += val;
edgesum += val;
return;
}
PyObject* marching_cubes_func(PyObject* lower, PyObject* upper,
int numx, int numy, int numz, PyObject* f, double isovalue)
{
std::vector<double> vertices;
std::vector<size_t> polygons;
// Copy the lower and upper coordinates to a C array.
double lower_[3];
double upper_[3];
for(int i=0; i<3; ++i)
{
PyObject* l = PySequence_GetItem(lower, i);
if(l == NULL)
throw std::runtime_error("error");
PyObject* u = PySequence_GetItem(upper, i);
if(u == NULL)
{
Py_DECREF(l);
throw std::runtime_error("error");
}
lower_[i] = PyFloat_AsDouble(l);
upper_[i] = PyFloat_AsDouble(u);
Py_DECREF(l);
Py_DECREF(u);
if(lower_[i]==-1.0 || upper_[i]==-1.0)
{
if(PyErr_Occurred())
throw std::runtime_error("error");
}
}
// Marching cubes.
mc::marching_cubes<double>(lower_, upper_, numx, numy, numz, PythonToCFunc(f), isovalue, vertices, polygons);
// Copy the result to two Python ndarrays.
npy_intp size_vertices = vertices.size();
npy_intp size_polygons = polygons.size();
PyArrayObject* verticesarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_vertices, PyArray_DOUBLE));
PyArrayObject* polygonsarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_polygons, PyArray_ULONG));
std::vector<double>::const_iterator it = vertices.begin();
for(int i=0; it!=vertices.end(); ++i, ++it)
*reinterpret_cast<double*>(PyArray_GETPTR1(verticesarr, i)) = *it;
std::vector<size_t>::const_iterator it2 = polygons.begin();
for(int i=0; it2!=polygons.end(); ++i, ++it2)
*reinterpret_cast<unsigned long*>(PyArray_GETPTR1(polygonsarr, i)) = *it2;
PyObject* res = Py_BuildValue("(O,O)", verticesarr, polygonsarr);
Py_XDECREF(verticesarr);
Py_XDECREF(polygonsarr);
return res;
}
int
PyAubio_PyCvecToCCvec (PyObject *input, cvec_t *i) {
if (PyObject_TypeCheck (input, &Py_cvecType)) {
Py_cvec * in = (Py_cvec *)input;
i->norm = (smpl_t *) PyArray_GETPTR1 ((PyArrayObject *)(in->norm), 0);
i->phas = (smpl_t *) PyArray_GETPTR1 ((PyArrayObject *)(in->phas), 0);
i->length = ((Py_cvec*)input)->length;
return 1;
} else {
PyErr_SetString (PyExc_ValueError, "input array should be aubio.cvec");
return 0;
}
}
int APPLY_SPECIFIC(doublecop)(PyArrayObject *x,
PyArrayObject **out) {
Py_XDECREF(*out);
*out = (PyArrayObject *)PyArray_NewLikeArray(
inp, NPY_ANYORDER, NULL, 0);
if (*out == NULL)
return -1;
for (npy_intp i = 0; i < PyArray_DIM(x, 0); i++) {
*(DTYPE_OUTPUT_0 *)PyArray_GETPTR1(*out, i) =
(*(DTYPE_INPUT_0 *)PyArray_GETPTR1(x, i)) * 2;
}
return 0;
}
PyObject* getAngles(PyObject *self, PyObject *args) {
/*
** Inputs:
** interger of search radius (in pixels)
** Modifies:
** nothing
** Outputs:
** 1D numpy array containing correlation values of angle (x-axis)
*/
Py_Initialize();
int radius;
if (!PyArg_ParseTuple(args, "i", &radius))
return NULL;
struct item *head = NULL;
head = getAnglesList(radius, head);
int numangles = list_length(head);
npy_intp outdims[1] = {numangles};
import_array(); // this is required to use PyArray_New() and PyArray_SimpleNew()
PyArrayObject *output;
output = (PyArrayObject *) PyArray_SimpleNew(1, outdims, NPY_DOUBLE);
struct item *current;
int i=0;
for(current=head; current!=NULL; current=current->next) {
*(double *) PyArray_GETPTR1(output, i) = current->angle;
i++;
}
delete_list(head);
return PyArray_Return(output);
}
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;
}
inline string_array_output_iterator &operator++() {
PyObject *s = as_python_string(output);
PyObject **ref = (PyObject **)PyArray_GETPTR1((PyArrayObject*)array, i);
Py_XDECREF(*ref);
*ref = s;
i++;
return *this;
}
/* Checks if two boxes are near-neighbours by looking at their integer
coordinates. */
static PyObject *
are_near_neighbours (PyObject *self, PyObject *args)
{
PyArrayObject *c0, *c1;
int i, *p0, *p1;
if (!PyArg_ParseTuple(args, "O!O!",
&PyArray_Type, &c0,
&PyArray_Type, &c1))
return NULL;
if (c0->nd != 1) {
PyErr_SetString(PyExc_ValueError,
"c0 must have dimension 1.");
return NULL;
}
if (c1->nd != 1) {
PyErr_SetString(PyExc_ValueError,
"c1 must have dimension 1.");
return NULL;
}
if (c0->dimensions[0] != 3) {
PyErr_SetString(PyExc_ValueError,
"c0 must have shape (3,).");
return NULL;
}
if (c1->dimensions[0] != 3) {
PyErr_SetString(PyExc_ValueError,
"c1 must have shape (3,).");
return NULL;
}
for (i = 0; i < 3; i++) {
p0 = (int *) PyArray_GETPTR1 (c0, i);
p1 = (int *) PyArray_GETPTR1 (c1, i);
if (*p0 - *p1 > 1 || *p1 - *p0 > 1) Py_RETURN_FALSE;
}
Py_RETURN_TRUE;
}
/**
* Calculate the log of the (uncollapsed) P(w|z) expression
* (used for the y-sampling step)
*/
double dtnode :: calc_logpwz()
{
// Calculate for this node
double logpwz = lgamma(orig_edgesum) - lgamma(edgesum);
for(uint ei = 0; ei < PyArray_DIM(edges,0); ei++)
{
logpwz += lgamma(*((double*)PyArray_GETPTR1(edges,ei))) -
lgamma(*((double*)PyArray_GETPTR1(orig_edges,ei)));
}
// Calculate for all interior children
for(uint i = 0; i < ichildren.size(); i++)
{
dtnode* child = dynamic_cast<dtnode*>(this->ichildren[i]);
logpwz += (*child).calc_logpwz();
}
return logpwz;
}
// get index into counts for the given row
int
cptindex1(PyArrayObject *row, int *offsets, int num_parents) {
register int i,ind=0;
for (i=0; i<num_parents; i++) {
ind += *((int*)PyArray_GETPTR1(row, i+1)) * offsets[i];
}
return ind;
}
static inline int findIndex(PyObject *arr, int value, int size){
//returns index of first occurrence of value in 1D array object, -1 if not
//found
int i;
for (i=0;i<size;i++){
if (*((int*)PyArray_GETPTR1(arr,i)) == value){
return i;
}
}
return -1;
}
// calculate the loglikelihood of data
double
_loglikelihood(CPT *cpt, PyArrayObject *lnfac) {
register int j,k;
double score = 0.0;
// score is calculated as follows:
// 1) add log((ri-1)!)
// 2) subtract log((Nij + ri -1)!)
// 3) add sum of log(Nijk!)
score += cpt->qi * *((double*)PyArray_GETPTR1(lnfac, cpt->ri - 1));
for (j=0; j<cpt->qi; j++) {
score -= *((double*)PyArray_GETPTR1(lnfac, cpt->counts[j][0] + cpt->ri - 1));
for (k=0; k<cpt->ri; k++) {
score += *((double*)PyArray_GETPTR1(lnfac, cpt->counts[j][k+1]));
}
}
return score;
}
static PyObject *PyLWPR_G_n_pruned(PyLWPR *self, void *closure) {
int i;
PyArrayObject *matout;
npy_intp len = self->model.nOut;
matout = (PyArrayObject *) PyArray_SimpleNew(1, &len, NPY_INT);
for (i=0;i<len;i++) {
*((int *) PyArray_GETPTR1(matout, i)) = self->model.sub[i].n_pruned;
}
return PyArray_Return(matout);
}
/*==========================================================================*/
PyObject *calculate(PyObject *self, PyObject *args)
{
long i, j;
KD kd;
int nReps=0, bPeriodic=0, bEwald=0;
float fSoft;
int nPos;
PyObject *kdobj, *acc, *pot, *pos;
PARTICLE *testParticles;
PyArg_ParseTuple(args, "OOOOdi", &kdobj, &pos, &acc, &pot, &fSoft, &nPos);
kd = PyCObject_AsVoidPtr(kdobj);
if (kd == NULL) return NULL;
testParticles = (PARTICLE *)malloc(nPos*sizeof(PARTICLE));
assert(testParticles != NULL);
for (i=0; i< nPos; i++) {
for (j=0; j < 3; j++) {
testParticles[i].r[j] =
(float)*((double *)PyArray_GETPTR2(pos, i, j));
testParticles[i].a[j] = 0;
}
testParticles[i].fMass = 0;
testParticles[i].fPot = 0;
testParticles[i].fSoft = fSoft;
testParticles[i].iOrder = i;
}
Py_BEGIN_ALLOW_THREADS
kdGravWalk(kd, nReps, bPeriodic && bEwald, testParticles, nPos);
Py_END_ALLOW_THREADS
for (i=0; i < nPos; i++) {
PyArray_SETITEM(pot, PyArray_GETPTR1(pot,i), PyFloat_FromDouble(testParticles[i].fPot));
for (j=0; j < 3; j++) {
PyArray_SETITEM(acc, PyArray_GETPTR2(acc, i, j),
PyFloat_FromDouble(testParticles[i].a[j]));
}
}
Py_DECREF(kd);
/*
Py_DECREF(pos);
Py_DECREF(pot);
Py_DECREF(acc);
*/
Py_INCREF(Py_None);
return Py_None;
}
/**
* Do a report on multinodes
*/
void dtnode :: report()
{
vector<node*> multi = get_multinodes();
for(uint mi = 0; mi < multi.size(); mi++)
{
multinode* mu = dynamic_cast<multinode*>(ichildren[mi]);
double e = *((double*)PyArray_GETPTR1(edges,mi));
printf("Edge = %f\n",e);
printf("Multinode %d, y = %d (of %d variants)\n",
mi,(*mu).get_y(),(*mu).num_variants());
}
}
fvec_t *
PyAubio_ArrayToCFvec (PyObject *input) {
PyObject *array;
fvec_t *vec;
if (input == NULL) {
PyErr_SetString (PyExc_ValueError, "input array is not a python object");
goto fail;
}
// parsing input object into a Py_fvec
if (PyArray_Check(input)) {
// we got an array, convert it to an fvec
if (PyArray_NDIM (input) == 0) {
PyErr_SetString (PyExc_ValueError, "input array is a scalar");
goto fail;
} else if (PyArray_NDIM (input) > 1) {
PyErr_SetString (PyExc_ValueError,
"input array has more than one dimensions");
goto fail;
}
if (!PyArray_ISFLOAT (input)) {
PyErr_SetString (PyExc_ValueError, "input array should be float");
goto fail;
} else if (PyArray_TYPE (input) != AUBIO_NPY_SMPL) {
PyErr_SetString (PyExc_ValueError, "input array should be float32");
goto fail;
} else {
// input data type is float32, nothing else to do
array = input;
}
// vec = new_fvec (vec->length);
// no need to really allocate fvec, just its struct member
vec = (fvec_t *)malloc(sizeof(fvec_t));
vec->length = PyArray_SIZE (array);
vec->data = (smpl_t *) PyArray_GETPTR1 (array, 0);
} else if (PyObject_TypeCheck (input, &PyList_Type)) {
PyErr_SetString (PyExc_ValueError, "does not convert from list yet");
return NULL;
} else {
PyErr_SetString (PyExc_ValueError, "can only accept vector of float as input");
return NULL;
}
return vec;
fail:
return NULL;
}
PyObject* marching_cubes(PyArrayObject* arr, double isovalue)
{
if(PyArray_NDIM(arr) != 3)
throw std::runtime_error("Only three-dimensional arrays are supported.");
// Prepare data.
npy_intp* shape = PyArray_DIMS(arr);
long lower[3] = {0,0,0};
long upper[3] = {shape[0]-1, shape[1]-1, shape[2]-1};
long numx = upper[0] - lower[0] + 1;
long numy = upper[1] - lower[1] + 1;
long numz = upper[2] - lower[2] + 1;
std::vector<double> vertices;
std::vector<size_t> polygons;
// Marching cubes.
mc::marching_cubes<long>(lower, upper, numx, numy, numz, PyArrayToCFunc(arr), isovalue,
vertices, polygons);
// Copy the result to two Python ndarrays.
npy_intp size_vertices = vertices.size();
npy_intp size_polygons = polygons.size();
PyArrayObject* verticesarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_vertices, PyArray_DOUBLE));
PyArrayObject* polygonsarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_polygons, PyArray_ULONG));
std::vector<double>::const_iterator it = vertices.begin();
for(int i=0; it!=vertices.end(); ++i, ++it)
*reinterpret_cast<double*>(PyArray_GETPTR1(verticesarr, i)) = *it;
std::vector<size_t>::const_iterator it2 = polygons.begin();
for(int i=0; it2!=polygons.end(); ++i, ++it2)
*reinterpret_cast<unsigned long*>(PyArray_GETPTR1(polygonsarr, i)) = *it2;
PyObject* res = Py_BuildValue("(O,O)", verticesarr, polygonsarr);
Py_XDECREF(verticesarr);
Py_XDECREF(polygonsarr);
return res;
}
PyObject *
replace_data(PyObject *self, PyObject *args) {
int pycpt;
PyArrayObject *oldrow, *newrow;
if (!PyArg_ParseTuple(args, "iO!O!", &pycpt, &PyArray_Type, &oldrow, &PyArray_Type, &newrow)) {
return NULL;
}
CPT *cpt = (CPT*) pycpt;
int old_index = cptindex1(oldrow, cpt->offsets, cpt->num_parents);
int new_index = cptindex1(newrow, cpt->offsets, cpt->num_parents);
int oldval = *((int*)PyArray_GETPTR1(oldrow, 0));
int newval = *((int*)PyArray_GETPTR1(newrow, 0));
cpt->counts[old_index][0]--;
cpt->counts[new_index][0]++;
cpt->counts[old_index][oldval+1]--;
cpt->counts[new_index][newval+1]++;
Py_RETURN_NONE;
}
/**
* Calculate topic-word term of Gibbs sampling eqn
*/
double dtnode :: calc_wordterm(double val, int leaf)
{
// Is this leaf under one of our interior children?
double newval;
for(uint i = 0; i < ichildren.size(); i++)
{
if(leaf <= maxind[i])
{
// Update value
newval = ((*((double*)PyArray_GETPTR1(this->edges,i)))
/ this->edgesum);
// Recurisively mult value by child
return (*(this->ichildren[i])).calc_wordterm(newval*val,leaf);
}
}
// No, this leaf must be one of our leaves
// Get leaf edge index
int ei = ichildren.size() + (leaf - this->leafstart);
// Update value
newval = (*((double*)PyArray_GETPTR1(this->edges,ei))) / this->edgesum;
return (val * newval);
}
static PyObject *build_array(const Container &container) {
size_t sz = (size_t)container.size();
npy_intp fdims[] = {(npy_intp)sz};
PyObject *array = (PyObject*)PyArray_SimpleNew(1, fdims, NPY_OBJECT);
try {
for (size_t i = 0; i < container.size(); i++) {
PyObject **ref = (PyObject **)PyArray_GETPTR1((PyArrayObject*)array, i);
PyObject *newobj = as_python_string(container[i]);
Py_XDECREF(*ref);
*ref = newobj;
}
}
catch (...) {
for (size_t i = 0; i < sz; i++) {
PyObject **ref = (PyObject **)PyArray_GETPTR1((PyArrayObject*)array, i);
Py_XDECREF(*ref);
*ref = Py_None;
Py_XINCREF(*ref);
}
Py_XDECREF(array);
std::rethrow_exception(std::current_exception());
}
return array;
}
void create_contiguous_input_lengths( PyArrayObject * input_lengths_arr,
int ** input_lengths )
{
npy_int num_elements = PyArray_DIMS( input_lengths_arr )[0];
*input_lengths = (int *) calloc( num_elements, sizeof(int) );
if ( NULL == (*input_lengths) )
return;
for( npy_int elem_idx = 0; elem_idx < num_elements; ++elem_idx )
{
(*input_lengths)[elem_idx] = *( (npy_int *) PyArray_GETPTR1( input_lengths_arr, elem_idx ) );
}
}
int PyAsap_SetIntFromArray(set<int> &to, PyObject *from)
{
to.clear();
PyArrayObject *array = (PyArrayObject *) PyArray_ContiguousFromObject(from, NPY_INT, 1, 1);
if (array == NULL)
{
PyErr_SetString(PyExc_TypeError,
"Not compatible with 1D array of integers.");
return -1;
};
for (int i = 0; i < PyArray_DIM(array, 0); i++)
to.insert(*((int *)PyArray_GETPTR1(array, i)));
CHECKREF(array);
Py_DECREF(array);
return 0;
}
/*==========================================================================*/
PyObject *treeinit(PyObject *self, PyObject *args)
{
int nBucket, nbodies, nTreeBitsLo=14, nTreebitsHi=18;
int i, j;
KD kd = (KD)malloc(sizeof(struct kdContext));
PyObject *pos; // Nx3 Numpy array of positions
PyObject *mass; // Nx1 Numpy array of masses
double dTheta=0.7 * 2.0/sqrt(3.0);
float fPeriod[3], fTemp, fSoft;
for (i=0; i<3; i++) fPeriod[i] = 1.0;
if (!PyArg_ParseTuple(args, "OOiif", &pos, &mass, &nBucket, &nbodies, &fSoft))
return NULL;
/*nbodies = PyArray_DIM(mass, 0);*/
kdInitialize(kd, nbodies, nBucket, dTheta, nTreeBitsLo, nTreebitsHi, fPeriod);
/*
** Allocate particles.
*/
kd->pStorePRIVATE = (PARTICLE *)malloc(nbodies*kd->iParticleSize);
assert(kd->pStorePRIVATE != NULL);
Py_BEGIN_ALLOW_THREADS
for (i=0; i < nbodies; i++)
{
for (j=0; j < 3; j++) {
fTemp = (float)*((double *)PyArray_GETPTR2(pos, i, j));
kd->pStorePRIVATE[i].r[j] = fTemp;
kd->pStorePRIVATE[i].a[j] = 0;
}
fTemp = (float)*((double *)PyArray_GETPTR1(mass, i));
kd->pStorePRIVATE[i].fMass = fTemp;
kd->pStorePRIVATE[i].fPot = 0;
kd->pStorePRIVATE[i].fSoft = fSoft;
}
kdTreeBuild(kd, nBucket);
Py_END_ALLOW_THREADS
return PyCObject_FromVoidPtr((void *)kd, NULL);
}
static PyObject *mandelbrot(PyObject *self, PyObject *args) {
PyArrayObject *result;
PyArrayObject *x_coords;
PyArrayObject *y_coords;
unsigned int size;
int x,y;
if(!PyArg_ParseTuple(args, "O!(O!O!)I", &PyArray_Type, &result, &PyArray_Type, &x_coords, &PyArray_Type, &y_coords, &size))
return NULL;
#pragma omp parallel for private(y)
for(x = 0; x < size; x++) {
for(y = 0; y < size; y++) {
*(char *)(PyArray_GETPTR2(result, y, x)) = solve(*(float *)(PyArray_GETPTR1(x_coords, x)), *(float *)(PyArray_GETPTR1(y_coords, y)));
}
}
return Py_BuildValue("i",1);
}
int APPLY_SPECIFIC(conv_desc)(PyArrayObject *filt_shp,
cudnnConvolutionDescriptor_t *desc) {
cudnnStatus_t err;
int pad[3] = {PAD_0, PAD_1, PAD_2};
int strides[3] = {SUB_0, SUB_1, SUB_2};
int upscale[3] = {1, 1, 1};
#if BORDER_MODE == 0
pad[0] = *(npy_int64 *)PyArray_GETPTR1(filt_shp, 2) - 1;
pad[1] = *(npy_int64 *)PyArray_GETPTR1(filt_shp, 3) - 1;
#if NB_DIMS > 2
pad[2] = *(npy_int64 *)PyArray_GETPTR1(filt_shp, 4) - 1;
#endif
#elif BORDER_MODE == 2
pad[0] = *(npy_int64 *)PyArray_GETPTR1(filt_shp, 2) / 2;
pad[1] = *(npy_int64 *)PyArray_GETPTR1(filt_shp, 3) / 2;
#if NB_DIMS > 2
pad[2] = *(npy_int64 *)PyArray_GETPTR1(filt_shp, 4) / 2;
#endif
#endif
if (PyArray_DIM(filt_shp, 0) - 2 != NB_DIMS) {
PyErr_Format(PyExc_ValueError, "Filter shape has too many dimensions: "
"expected %d, got %lld.", NB_DIMS,
(long long)PyArray_DIM(filt_shp, 0));
return -1;
}
err = cudnnCreateConvolutionDescriptor(desc);
if (err != CUDNN_STATUS_SUCCESS) {
PyErr_Format(PyExc_MemoryError, "could not allocate convolution "
"descriptor: %s", cudnnGetErrorString(err));
return -1;
}
err = cudnnSetConvolutionNdDescriptor(*desc, NB_DIMS, pad, strides,
upscale, CONV_MODE, PRECISION);
return 0;
}
static PyObject *PyCMOR_axis(PyObject * self, PyObject * args)
{
signal(signal_to_catch, signal_handler);
int ierr, axis_id, n = 0;
char *name;
char *units;
char *interval;
int length;
char type;
void *coord_vals;
void *cell_bounds;
int cell_bounds_ndim;
char *tmpstr = NULL;
PyObject *coords_obj, *bounds_obj;
PyArrayObject *coords = NULL, *bounds = NULL;
/************************************************************************/
/* HUGE assumtion here is that the data is contiguous! */
/************************************************************************/
if (!PyArg_ParseTuple
(args, "ssiOcOis", &name, &units, &length, &coords_obj, &type,
&bounds_obj, &cell_bounds_ndim, &interval))
return NULL;
if (coords_obj == Py_None) {
coord_vals = NULL;
} else {
coords =
(PyArrayObject *) PyArray_ContiguousFromObject(coords_obj,
NPY_NOTYPE, 1, 0);
if (PyArray_NDIM(coords) != 1) {
printf("ok we need to pass contiguous flattened arrays only!\n");
return NULL;
}
if (type != 'c') {
coord_vals = (void *)PyArray_DATA(coords);
n = cell_bounds_ndim;
} else {
tmpstr =
(char *)malloc(sizeof(char) * length * (cell_bounds_ndim + 1));
for (ierr = 0; ierr < length; ierr++) {
coord_vals = (void *)PyArray_GETPTR1(coords, ierr);
strncpy(&tmpstr[ierr * (cell_bounds_ndim + 1)],
coord_vals, cell_bounds_ndim);
tmpstr[ierr * (cell_bounds_ndim + 1) + cell_bounds_ndim] = '\0';
}
coord_vals = &tmpstr[0];
n = cell_bounds_ndim + 1;
for (ierr = 0; ierr < length; ierr++) {
}
}
}
if (bounds_obj == Py_None) {
cell_bounds = NULL;
} else {
bounds =
(PyArrayObject *) PyArray_ContiguousFromObject(bounds_obj,
NPY_NOTYPE, 1, 0);
if (PyArray_NDIM(bounds) != 1) {
printf("ok we need to pass contiguous flattened arrays only!\n");
return NULL;
}
cell_bounds = (void *)PyArray_DATA(bounds);
}
ierr =
cmor_axis(&axis_id, name, units, length, coord_vals, type,
cell_bounds, n, interval);
if (coords != NULL) {
Py_DECREF(coords);
}
if (bounds != NULL) {
Py_DECREF(bounds);
}
if (type == 'c') {
free(tmpstr);
}
if (ierr != 0 || raise_exception) {
raise_exception = 0;
PyErr_Format(CMORError, exception_message, "axis");
return NULL;
}
return (Py_BuildValue("i", axis_id));
}
static PyObject * uberseg_direct(PyObject* self, PyObject* args) {
int dmin=0,d=0,x=0,y=0,k=0,imin=0;
PyObject* seg = NULL;
PyObject* weight = NULL;
int Nx;
int Ny;
int object_number;
PyObject* obj_inds_x = NULL;
PyObject* obj_inds_y = NULL;
int Ninds;
int *ptrx,*ptry,*ptrs;
float *ptrw;
int dx;
if (!PyArg_ParseTuple(args, (char*)"OOiiiOOi", &seg, &weight, &Nx, &Ny, &object_number, &obj_inds_x, &obj_inds_y, &Ninds)) {
return NULL;
}
for(x=0;x<Nx;++x) {
for(y=0;y<Ny;++y) {
//shortcuts
ptrs = (int*)PyArray_GETPTR2(seg,x,y);
if(*ptrs == object_number)
continue;
if(*ptrs > 0 && *ptrs != object_number) {
ptrw = (float*)PyArray_GETPTR2(weight,x,y);
*ptrw = 0.0;
continue;
}
//must do direct search
imin = -1;
for(k=0;k<Ninds;++k) {
ptrx = (int*)PyArray_GETPTR1(obj_inds_x,k);
ptry = (int*)PyArray_GETPTR1(obj_inds_y,k);
dx = x-(*ptrx);
d = dx*dx;
dx = y-(*ptry);
d += dx*dx;
if(d < dmin || imin == -1) {
dmin = d;
imin = k;
}
}
if(imin == -1) {
continue;
}
ptrx = (int*)PyArray_GETPTR1(obj_inds_x,imin);
ptry = (int*)PyArray_GETPTR1(obj_inds_y,imin);
ptrs = (int*)PyArray_GETPTR2(seg,*ptrx,*ptry);
if(*ptrs != object_number) {
ptrw = (float*)PyArray_GETPTR2(weight,x,y);
*ptrw = 0.0;
}
}
}
Py_INCREF(Py_None);
return Py_None;
}
PyObject* PackOut( IData *GS, double *ICs,
int state, double *stats, double hlast, int idid ) {
int i, j;
int numEvents = 0;
/* Python objects to be returned at end of integration */
PyObject *OutObj = NULL; /* Overall PyTuple output object */
PyObject *TimeOut = NULL; /* Trajectory times */
PyObject *PointsOut = NULL; /* Trajectory points */
PyObject *StatsOut = NULL; /* */
PyObject *EventPointsOutTuple = NULL;
PyObject *EventTimesOutTuple = NULL;
PyObject *AuxOut = NULL;
assert(GS);
if( state == FAILURE ) {
Py_INCREF(Py_None);
return Py_None;
}
_init_numpy();
EventPointsOutTuple = PyTuple_New(GS->nEvents);
assert(EventPointsOutTuple);
EventTimesOutTuple = PyTuple_New(GS->nEvents);
assert(EventTimesOutTuple);
/* Copy out points */
npy_intp p_dims[2] = {GS->phaseDim, GS->pointsIdx};
PointsOut = PyArray_SimpleNew(2, p_dims, NPY_DOUBLE);
assert(PointsOut);
/* WARNING -- modified the order of the dimensions here! */
for(i = 0; i < GS->pointsIdx; i++) {
for(j = 0; j < GS->phaseDim; j++) {
*((double *) PyArray_GETPTR2((PyArrayObject *)PointsOut, j, i)) = GS->gPoints[i][j];
}
}
/* Copy out times */
npy_intp t_dims[1] = {GS->timeIdx};
TimeOut = PyArray_SimpleNew(1, t_dims, NPY_DOUBLE);
assert(TimeOut);
for( i = 0; i < GS->timeIdx; i++ ) {
*((double *) PyArray_GETPTR1((PyArrayObject *)TimeOut, i)) = GS->gTimeV[i];
}
/* Copy out auxilliary points */
npy_intp au_dims[2] = {GS->nAuxVars, GS->pointsIdx};
if( GS->nAuxVars > 0 && GS->calcAux == 1 ) {
/* WARNING: The order of the dimensions
is switched here! */
AuxOut = PyArray_SimpleNew(2, au_dims, NPY_DOUBLE);
assert(AuxOut);
for( i = 0; i < GS->pointsIdx; i++ ) {
for( j = 0; j < GS->nAuxVars; j++ ) {
*((double *) PyArray_GETPTR2((PyArrayObject *)AuxOut, j, i)) = GS->gAuxPoints[i][j];
}
}
}
/* Allocate and copy out integration stats */
/* Number of stats different between Radau, Dopri */
npy_intp s_dims[1] = {7};
StatsOut = PyArray_SimpleNewFromData(1, s_dims, NPY_DOUBLE, stats);
assert(StatsOut);
/* Setup the tuple for the event points and times (separate from trajectory).
Must remember to keep the reference count for Py_None up to date*/
for( i = 0; i < GS->nEvents; i++ ) {
PyTuple_SetItem(EventPointsOutTuple, i, Py_None);
Py_INCREF(Py_None);
PyTuple_SetItem(EventTimesOutTuple, i, Py_None);
Py_INCREF(Py_None);
}
/* Count the number of events for which something was caught */
numEvents = 0;
for( i = 0; i < GS->haveActive; i++ ) {
if( GS->gCheckableEventCounts[i] > 0 ) {
numEvents++;
}
}
/* Only allocate memory for events if something was caught */
if( numEvents > 0 ) {
/* Lower reference count for Py_None from INCREFs in initialization of
OutTuples above. Decrease by 2*numevents) */
for( i = 0; i < numEvents; i++ ) {
Py_DECREF(Py_None);
Py_DECREF(Py_None);
}
for( i = 0; i < GS->haveActive; i++ ) {
if( GS->gCheckableEventCounts[i] > 0 ) {
int k, l;
/* Get the number of points caught for this event, and which one (in list
of all active and nonactive events) it is */
int EvtCt = GS->gCheckableEventCounts[i], EvtIdx = GS->gCheckableEvents[i];
npy_intp et_dims[1] = {EvtCt};
npy_intp ep_dims[2] = {GS->phaseDim, EvtCt};
/* Copy the event times, points into a python array */
PyObject *e_times = PyArray_SimpleNewFromData(1, et_dims, NPY_DOUBLE, GS->gEventTimes[i]);
assert(e_times);
PyObject *e_points = PyArray_SimpleNew(2, ep_dims, NPY_DOUBLE);
assert(e_points);
for( k = 0; k < EvtCt; k++ ) {
for( l = 0; l < GS->phaseDim; l++ ) {
*((double *) PyArray_GETPTR2((PyArrayObject *)e_points, l, k)) = GS->gEventPoints[i][l][k];
}
}
/* The returned python tuple has slots for all events, not just active
ones, which is why we insert into the tuple at position EvtIdx */
PyTuple_SetItem(EventPointsOutTuple, EvtIdx, e_points);
PyTuple_SetItem(EventTimesOutTuple, EvtIdx, e_times);
}
}
}
/* Pack points, times, stats, events, etc. into a 7 tuple */
OutObj = PyTuple_New(8);
assert(OutObj);
PyTuple_SetItem(OutObj, 0, (PyObject *)TimeOut);
PyTuple_SetItem(OutObj, 1, (PyObject *)PointsOut);
if( GS->nAuxVars > 0 && GS->calcAux == 1) {
PyTuple_SetItem(OutObj, 2, (PyObject *)AuxOut);
}
else {
PyTuple_SetItem(OutObj, 2, Py_None);
Py_INCREF(Py_None);
}
PyTuple_SetItem(OutObj, 3, (PyObject *)StatsOut);
PyTuple_SetItem(OutObj, 4, PyFloat_FromDouble(hlast));
PyTuple_SetItem(OutObj, 5, PyFloat_FromDouble((double)idid));
PyTuple_SetItem(OutObj, 6, EventTimesOutTuple);
PyTuple_SetItem(OutObj, 7, EventPointsOutTuple);
return OutObj;
}
static PyObject * uberseg_tree(PyObject* self, PyObject* args) {
int x=0,y=0,k=0,segmin=0;
float dmin=0,r=0,dx=0,d=0;
float pos[2],fac=0;
PyObject* seg = NULL;
PyObject* weight = NULL;
int Nx;
int Ny;
int object_number;
PyObject* obj_inds_x = NULL;
PyObject* obj_inds_y = NULL;
int Ninds;
int *ptrx,*ptry,*ptrs;
float *ptrw;
struct mytype *obj = NULL;
struct fast3tree *tree = NULL;
struct fast3tree_results *res = NULL;
if (!PyArg_ParseTuple(args, (char*)"OOiiiOOi", &seg, &weight, &Nx, &Ny, &object_number, &obj_inds_x, &obj_inds_y, &Ninds)) {
return NULL;
}
obj = (struct mytype *)malloc(sizeof(struct mytype)*Ninds);
if(obj == NULL) exit(1);
for(k=0;k<Ninds;++k) {
ptrx = (int*)PyArray_GETPTR1(obj_inds_x,k);
ptry = (int*)PyArray_GETPTR1(obj_inds_y,k);
ptrs = (int*)PyArray_GETPTR2(seg,*ptrx,*ptry);
obj[k].idx = k;
obj[k].seg = *ptrs;
obj[k].pos[0] = (float)(*ptrx);
obj[k].pos[1] = (float)(*ptry);
}
tree = fast3tree_init(Ninds,obj);
if(tree == NULL) exit(1);
res = fast3tree_results_init();
if(res == NULL) exit(1);
float maxr = 1.1*sqrt(Nx*Nx+Ny*Ny);
for(x=0;x<Nx;++x) {
for(y=0;y<Ny;++y) {
//shortcuts
ptrs = (int*)PyArray_GETPTR2(seg,x,y);
if(*ptrs == object_number)
continue;
if(*ptrs > 0 && *ptrs != object_number) {
ptrw = (float*)PyArray_GETPTR2(weight,x,y);
*ptrw = 0.0;
continue;
}
//must do search
pos[0] = (float)x;
pos[1] = (float)y;
r = fast3tree_find_next_closest_distance(tree,res,pos);
fac = 1.0/1.1;
do {
fac *= 1.1;
fast3tree_results_clear(res);
fast3tree_find_sphere(tree,res,pos,r*fac);
} while(res->num_points == 0 && r*fac <= maxr);
segmin = -1;
for(k=0;k<res->num_points;++k) {
dx = res->points[k]->pos[0]-x;
d = dx*dx;
dx = res->points[k]->pos[1]-y;
d += dx*dx;
if(segmin == -1 || d < dmin) {
segmin = res->points[k]->seg;
dmin = d;
}
}
if(segmin == -1) {
continue;
}
if(segmin != object_number) {
ptrw = (float*)PyArray_GETPTR2(weight,x,y);
*ptrw = 0.0;
}
}
}
free(obj);
fast3tree_free(&tree);
fast3tree_results_free(res);
Py_INCREF(Py_None);
return Py_None;
}