void nplist_to_C_double_array(PyArrayObject *in_array,
double *out_list,
int N)
{
NpyIter *in_iter;
NpyIter_IterNextFunc *in_iternext;
double **in_ptr;
int itr;
in_iter = NpyIter_New(in_array, NPY_ITER_READONLY,
NPY_KEEPORDER, NPY_NO_CASTING, NULL);
if (in_iter == NULL) goto fail;
in_iternext = NpyIter_GetIterNext(in_iter, NULL);
if (in_iternext == NULL){
NpyIter_Deallocate(in_iter);
goto fail;
}
/* interator pointer to actual numpy data */
in_ptr = (double **) NpyIter_GetDataPtrArray(in_iter);
itr=0;
do {
out_list[itr++] = **in_ptr;
} while(in_iternext(in_iter));
NpyIter_Deallocate(in_iter);
fail:
return NULL;
}
/**
* parseFloatVec3(vec_in, vec_out)
*
* @param[in] vec_in the python array to extract elements from
* @param[out] vec_out float array of the numbers
* @return true if successful, false if not
*
* Convert a python array type to a 3 element float
* vector.
*/
static bool parseFloatVecN(PyArrayObject *vec_in, float *vec_out, int N)
{
/* verify it is a valid vector */
if (not_doublevector(vec_in))
return false;
if (PyArray_DIM(vec_in,0) != N) {
PyErr_Format(PyExc_ValueError, "Vector length incorrect. Received %ld and expected %d", PyArray_DIM(vec_in,0), N);
return false;
}
NpyIter *iter;
NpyIter_IterNextFunc *iternext;
/* create the iterators */
iter = NpyIter_New(vec_in, NPY_ITER_READONLY, NPY_KEEPORDER,
NPY_NO_CASTING, NULL);
if (iter == NULL)
goto fail;
iternext = NpyIter_GetIterNext(iter, NULL);
if (iternext == NULL) {
NpyIter_Deallocate(iter);
goto fail;
}
double ** dataptr = (double **) NpyIter_GetDataPtrArray(iter);
/* iterate over the arrays */
int i = 0;
do {
vec_out[i++] = **dataptr;
} while(iternext(iter) && (i < N));
NpyIter_Deallocate(iter);
return true;
fail:
fprintf(stderr, "Parse fail\r\n");
return false;
}
void Fn::NumpyInput::reset()
{
_io = std::make_shared<IO_double>(_dim,_inputType);
// setup numpy iterator
if (_iter) {
NpyIter_Deallocate(_iter);
_iter = NULL;
}
PyArray_Descr* dtype = PyArray_DescrFromType(NPY_DOUBLE);
_iter = NpyIter_New( (PyArrayObject*)_arr, NPY_ITER_READONLY|
NPY_ITER_EXTERNAL_LOOP|
NPY_ITER_REFS_OK,
NPY_KEEPORDER, NPY_UNSAFE_CASTING, dtype );
Py_DECREF(dtype);
if (_iter == NULL) {
throw std::invalid_argument("An unknown error was encountered. Please contact developers.");
}
_iternext = NpyIter_GetIterNext(_iter, NULL);
if (_iternext == NULL) {
NpyIter_Deallocate(_iter);
throw std::invalid_argument("An unknown error was encountered. Please contact developers.");
}
/* The location of the data pointer which the iterator may update */
_dataptr = NpyIter_GetDataPtrArray(_iter);
/* The location of the stride which the iterator may update */
_strideptr = NpyIter_GetInnerStrideArray(_iter);
/* The location of the inner loop size which the iterator may update */
_innersizeptr = NpyIter_GetInnerLoopSizePtr(_iter);
_count = *_innersizeptr;
_data = *_dataptr;
grab();
}
/* unravel_index implementation - see add_newdocs.py */
NPY_NO_EXPORT PyObject *
arr_unravel_index(PyObject *self, PyObject *args, PyObject *kwds)
{
PyObject *indices0 = NULL, *ret_tuple = NULL;
PyArrayObject *ret_arr = NULL;
PyArrayObject *indices = NULL;
PyArray_Descr *dtype = NULL;
PyArray_Dims dimensions={0,0};
NPY_ORDER order = NPY_CORDER;
npy_intp unravel_size;
NpyIter *iter = NULL;
int i, ret_ndim;
npy_intp ret_dims[NPY_MAXDIMS], ret_strides[NPY_MAXDIMS];
char *kwlist[] = {"indices", "dims", "order", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&|O&:unravel_index",
kwlist,
&indices0,
PyArray_IntpConverter, &dimensions,
PyArray_OrderConverter, &order)) {
goto fail;
}
if (dimensions.len == 0) {
PyErr_SetString(PyExc_ValueError,
"dims must have at least one value");
goto fail;
}
unravel_size = PyArray_MultiplyList(dimensions.ptr, dimensions.len);
if (!PyArray_Check(indices0)) {
indices = (PyArrayObject*)PyArray_FromAny(indices0,
NULL, 0, 0, 0, NULL);
if (indices == NULL) {
goto fail;
}
}
else {
indices = (PyArrayObject *)indices0;
Py_INCREF(indices);
}
dtype = PyArray_DescrFromType(NPY_INTP);
if (dtype == NULL) {
goto fail;
}
iter = NpyIter_New(indices, NPY_ITER_READONLY|
NPY_ITER_ALIGNED|
NPY_ITER_BUFFERED|
NPY_ITER_ZEROSIZE_OK|
NPY_ITER_DONT_NEGATE_STRIDES|
NPY_ITER_MULTI_INDEX,
NPY_KEEPORDER, NPY_SAME_KIND_CASTING,
dtype);
if (iter == NULL) {
goto fail;
}
/*
* Create the return array with a layout compatible with the indices
* and with a dimension added to the end for the multi-index
*/
ret_ndim = PyArray_NDIM(indices) + 1;
if (NpyIter_GetShape(iter, ret_dims) != NPY_SUCCEED) {
goto fail;
}
ret_dims[ret_ndim-1] = dimensions.len;
if (NpyIter_CreateCompatibleStrides(iter,
dimensions.len*sizeof(npy_intp), ret_strides) != NPY_SUCCEED) {
goto fail;
}
ret_strides[ret_ndim-1] = sizeof(npy_intp);
/* Remove the multi-index and inner loop */
if (NpyIter_RemoveMultiIndex(iter) != NPY_SUCCEED) {
goto fail;
}
if (NpyIter_EnableExternalLoop(iter) != NPY_SUCCEED) {
goto fail;
}
ret_arr = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, dtype,
ret_ndim, ret_dims, ret_strides, NULL, 0, NULL);
dtype = NULL;
if (ret_arr == NULL) {
goto fail;
}
if (order == NPY_CORDER) {
if (NpyIter_GetIterSize(iter) != 0) {
NpyIter_IterNextFunc *iternext;
char **dataptr;
npy_intp *strides;
npy_intp *countptr, count;
npy_intp *coordsptr = (npy_intp *)PyArray_DATA(ret_arr);
iternext = NpyIter_GetIterNext(iter, NULL);
if (iternext == NULL) {
goto fail;
}
dataptr = NpyIter_GetDataPtrArray(iter);
strides = NpyIter_GetInnerStrideArray(iter);
countptr = NpyIter_GetInnerLoopSizePtr(iter);
do {
count = *countptr;
if (unravel_index_loop_corder(dimensions.len, dimensions.ptr,
unravel_size, count, *dataptr, *strides,
coordsptr) != NPY_SUCCEED) {
goto fail;
}
coordsptr += count*dimensions.len;
} while(iternext(iter));
}
}
else if (order == NPY_FORTRANORDER) {
if (NpyIter_GetIterSize(iter) != 0) {
NpyIter_IterNextFunc *iternext;
char **dataptr;
npy_intp *strides;
npy_intp *countptr, count;
npy_intp *coordsptr = (npy_intp *)PyArray_DATA(ret_arr);
iternext = NpyIter_GetIterNext(iter, NULL);
if (iternext == NULL) {
goto fail;
}
dataptr = NpyIter_GetDataPtrArray(iter);
strides = NpyIter_GetInnerStrideArray(iter);
countptr = NpyIter_GetInnerLoopSizePtr(iter);
do {
count = *countptr;
if (unravel_index_loop_forder(dimensions.len, dimensions.ptr,
unravel_size, count, *dataptr, *strides,
coordsptr) != NPY_SUCCEED) {
goto fail;
}
coordsptr += count*dimensions.len;
} while(iternext(iter));
}
}
else {
PyErr_SetString(PyExc_ValueError,
"only 'C' or 'F' order is permitted");
goto fail;
}
/* Now make a tuple of views, one per index */
ret_tuple = PyTuple_New(dimensions.len);
if (ret_tuple == NULL) {
goto fail;
}
for (i = 0; i < dimensions.len; ++i) {
PyArrayObject *view;
view = (PyArrayObject *)PyArray_New(&PyArray_Type, ret_ndim-1,
ret_dims, NPY_INTP,
ret_strides,
PyArray_BYTES(ret_arr) + i*sizeof(npy_intp),
0, NPY_ARRAY_WRITEABLE, NULL);
if (view == NULL) {
goto fail;
}
Py_INCREF(ret_arr);
if (PyArray_SetBaseObject(view, (PyObject *)ret_arr) < 0) {
Py_DECREF(view);
goto fail;
}
PyTuple_SET_ITEM(ret_tuple, i, PyArray_Return(view));
}
Py_DECREF(ret_arr);
Py_XDECREF(indices);
PyDimMem_FREE(dimensions.ptr);
NpyIter_Deallocate(iter);
return ret_tuple;
fail:
Py_XDECREF(ret_tuple);
Py_XDECREF(ret_arr);
Py_XDECREF(dtype);
Py_XDECREF(indices);
PyDimMem_FREE(dimensions.ptr);
NpyIter_Deallocate(iter);
return NULL;
}
/*********************
* python interface *
*********************/
static PyObject* eeint(PyObject* self, PyObject* args){
/*** input variables ***/
/* dictionary */
PyObject *in_dict;
PyObject *dictList;
PyObject *dictList_fast;
PyObject *pyStr;
PyObject *item;
/* numpy array */
PyArrayObject *in_array1, *in_array2;
NpyIter *in_iter;
NpyIter_IterNextFunc *in_iternext;
/* C data type for input */
int Ngo, Nao;
int N, itr;
/* basis function variables */
double **in_ptr; // address to numpy pointer
double *center; // gaussian center
double *cef; // contraction coefficients
int *ng; // number of gaussians per AO
double *exp; // gaussian exponents
int *lm_xyz; // angular momentum
/* python output variables */
PyObject *py_out;
PyObject *py_out2;
double *data, *overlap;
double element;
int i, j, k, l;
int s, t, u, v, w;
int mat_dim[4];
/* parse numpy array and two integers as argument */
if (!PyArg_ParseTuple(args, "OO!O!",
&in_dict,
&PyArray_Type, &in_array1,
&PyArray_Type, &in_array2
)) return NULL;
if(in_array1 == NULL) return NULL;
/***********************
* Construct input data *
***********************/
/*** access dict_list data ***/
/* exponents */
pyStr = PyString_FromString("exponents");
dictList = PyDict_GetItem(in_dict, pyStr);
dictList_fast = PySequence_Fast(
dictList, "expected a sequence");
Ngo = PySequence_Size(dictList);
exp = (double*) malloc(Ngo * sizeof(double));
for(i=0;i<Ngo;i++){
item = PySequence_Fast_GET_ITEM(dictList_fast, i);
exp[i] = PyFloat_AsDouble(item);
}
Py_DECREF(dictList_fast);
/* coefficients */
pyStr = PyString_FromString("coefficients");
dictList = PyDict_GetItem(in_dict, pyStr);
dictList_fast = PySequence_Fast(
dictList, "expected a sequence");
cef = (double*) malloc(Ngo * sizeof(double));
for(i=0;i<Ngo;i++){
item = PySequence_Fast_GET_ITEM(dictList_fast, i);
cef[i] = PyFloat_AsDouble(item);
}
Py_DECREF(dictList_fast);
/* number of gaussians per shell */
pyStr = PyString_FromString("n_gaussians");
dictList = PyDict_GetItem(in_dict, pyStr);
dictList_fast = PySequence_Fast(
dictList, "expected a sequence");
Nao = PySequence_Size(dictList);
ng = (int*) malloc(Nao * sizeof(int));
for(i=0;i<Nao;i++){
item = PySequence_Fast_GET_ITEM(dictList_fast, i);
ng[i] = PyFloat_AsDouble(item);
}
Py_DECREF(dictList_fast);
/*** end of dict_list data ***/
/*** create the iterators, necessary to access numpy array ***/
/* center */
in_iter = NpyIter_New(in_array1, NPY_ITER_READONLY,
NPY_KEEPORDER, NPY_NO_CASTING, NULL);
if (in_iter == NULL) goto fail;
in_iternext = NpyIter_GetIterNext(in_iter, NULL);
if (in_iternext == NULL){
NpyIter_Deallocate(in_iter);
goto fail;
}
/* interator pointer to actual numpy data */
in_ptr = (double **) NpyIter_GetDataPtrArray(in_iter);
center = (double*) malloc(3 * Nao * sizeof(double));
itr=0;
do {
center[itr++] = **in_ptr;
} while(in_iternext(in_iter));
NpyIter_Deallocate(in_iter);
/* lm_xyz */
in_iter = NpyIter_New(in_array2, NPY_ITER_READONLY,
NPY_KEEPORDER, NPY_NO_CASTING, NULL);
if (in_iter == NULL) goto fail;
in_iternext = NpyIter_GetIterNext(in_iter, NULL);
if (in_iternext == NULL){
NpyIter_Deallocate(in_iter);
goto fail;
}
/* interator pointer to actual numpy data */
int **in_ptr2 = (int **) NpyIter_GetDataPtrArray(in_iter);
lm_xyz = (int*) malloc(3 * Nao * sizeof(int));
itr=0;
do {
lm_xyz[itr++] = **in_ptr2;
} while(in_iternext(in_iter));
NpyIter_Deallocate(in_iter);
/*** end of numpy input data ***/
/***** end of input data construction *****/
/*******************
* construct output *
*******************/
for(i=0;i<4;i++) mat_dim[i] = Nao;
py_out = (PyArrayObject*)
PyArray_FromDims(4, mat_dim, NPY_DOUBLE);
data = pyvector_to_Carrayptrs(py_out);
/* renormalization */
renormalize(center, exp, cef, ng, lm_xyz, Nao);
/* orthogonalize */
// no effect at the moment, for debug purpose
//py_out2 = (PyArrayObject*)
// PyArray_FromDims(2, mat_dim, NPY_DOUBLE);
//overlap = pyvector_to_Carrayptrs(py_out2);
//orthogonalize(overlap, center, exp, cef, ng, lm_xyz, Nao);
#pragma omp parallel private(i, j, k, l, s, t, u, v, w)\
shared(data)
{
#pragma omp for schedule(dynamic)
for(i=0;i<Nao;i++){
for(j=i;j<Nao;j++){
for(k=0;k<Nao;k++){
for(l=k;l<Nao;l++){
if(l+k >= i+j){
s = l + k*Nao + j*Nao*Nao + i*Nao*Nao*Nao;
element = eeMatrix(center, exp, cef, ng, lm_xyz,
Nao, i, j, k, l);
data[s] = element;
// symmetry for (ij|kl)=(ij|lk)=(ji|kl)=(ji|lk)
t = k + l*Nao + j*Nao*Nao + i*Nao*Nao*Nao; //(ij|lk)
u = l + k*Nao + i*Nao*Nao + j*Nao*Nao*Nao; //(ji|kl)
v = k + l*Nao + i*Nao*Nao + j*Nao*Nao*Nao; //(ji|lk)
data[t] = data[s];
data[u] = data[s];
data[v] = data[s];
// symmetry for (ij|kl)=(kl|ij)=(kl|ji)=(lk|ij)=(lk|ji)
t = j + i*Nao + l*Nao*Nao + k*Nao*Nao*Nao; //(kl|ij)
u = i + j*Nao + l*Nao*Nao + k*Nao*Nao*Nao; //(kl|ji)
v = j + i*Nao + k*Nao*Nao + l*Nao*Nao*Nao; //(lk|ij)
w = i + j*Nao + k*Nao*Nao + l*Nao*Nao*Nao; //(lk|ji)
data[t] = data[s];
data[u] = data[s];
data[v] = data[s];
data[w] = data[s];
}
}
}
}
}
} // end of omp loop
/*********************************
* clean up and return the result *
*********************************/
free(exp);
free(cef);
free(ng);
free(center);
free(lm_xyz);
//free(overlap);
Py_INCREF(py_out);
return Py_BuildValue("O", py_out);
/* in case bad things happen */
fail:
Py_XDECREF(py_out);
return NULL;
} // end of eeint function
/*********************
* python interface *
*********************/
static PyObject* eekernel(PyObject* self, PyObject* args){
/*** input variables ***/
/* dictionary */
PyObject *in_dict;
PyObject *dictList;
PyObject *dictList_fast;
PyObject *pyStr;
PyObject *item;
/* list */
PyObject *in_list;
PyObject *list_fast;
/* numpy array */
PyArrayObject *in_array1, *in_array2, *in_array3;
NpyIter *in_iter;
NpyIter_IterNextFunc *in_iternext;
/* C data type for input */
int Ngo, Nao;
int N, itr;
double *Z;
double *R;
/* basis function variables */
double **in_ptr; // address to numpy pointer
double *center; // gaussian center
double *cef; // contraction coefficients
int *ng; // number of gaussians per AO
double *exp; // gaussian exponents
int *lm_xyz; // angular momentum
/* python output variables */
PyObject *py_out;
PyObject *py_out2;
double *data, *overlap;
int i, j, k;
int mat_dim[3];
/* parse numpy array and two integers as argument */
if (!PyArg_ParseTuple(args, "OO!O!O!O",
&in_dict,
&PyArray_Type, &in_array1,
&PyArray_Type, &in_array2,
&PyArray_Type, &in_array3,
&in_list
)) return NULL;
if(in_array1 == NULL) return NULL;
/***********************
* Construct input data *
***********************/
/*** access dict_list data ***/
/* exponents */
pyStr = PyString_FromString("exponents");
dictList = PyDict_GetItem(in_dict, pyStr);
dictList_fast = PySequence_Fast(
dictList, "expected a sequence");
Ngo = PySequence_Size(dictList);
exp = (double*) malloc(Ngo * sizeof(double));
for(i=0;i<Ngo;i++){
item = PySequence_Fast_GET_ITEM(dictList_fast, i);
exp[i] = PyFloat_AsDouble(item);
}
Py_DECREF(dictList_fast);
/* coefficients */
pyStr = PyString_FromString("coefficients");
dictList = PyDict_GetItem(in_dict, pyStr);
dictList_fast = PySequence_Fast(
dictList, "expected a sequence");
cef = (double*) malloc(Ngo * sizeof(double));
for(i=0;i<Ngo;i++){
item = PySequence_Fast_GET_ITEM(dictList_fast, i);
cef[i] = PyFloat_AsDouble(item);
}
Py_DECREF(dictList_fast);
/* number of gaussians per shell */
pyStr = PyString_FromString("n_gaussians");
dictList = PyDict_GetItem(in_dict, pyStr);
dictList_fast = PySequence_Fast(
dictList, "expected a sequence");
Nao = PySequence_Size(dictList);
ng = (int*) malloc(Nao * sizeof(int));
for(i=0;i<Nao;i++){
item = PySequence_Fast_GET_ITEM(dictList_fast, i);
ng[i] = PyFloat_AsDouble(item);
}
Py_DECREF(dictList_fast);
/*** end of dict_list data ***/
/*** access python list data ***/
list_fast = PySequence_Fast(in_list, "expected a sequence");
N = PySequence_Size(in_list);
Z = (double*) malloc(N * sizeof(double));
for(i=0;i<N;i++){
item = PySequence_Fast_GET_ITEM(list_fast, i);
Z[i] = PyFloat_AsDouble(item);
}
Py_DECREF(list_fast);
/*** end of list input data ***/
/*** create the iterators, necessary to access numpy array ***/
/* center */
in_iter = NpyIter_New(in_array1, NPY_ITER_READONLY,
NPY_KEEPORDER, NPY_NO_CASTING, NULL);
if (in_iter == NULL) goto fail;
in_iternext = NpyIter_GetIterNext(in_iter, NULL);
if (in_iternext == NULL){
NpyIter_Deallocate(in_iter);
goto fail;
}
/* interator pointer to actual numpy data */
in_ptr = (double **) NpyIter_GetDataPtrArray(in_iter);
center = (double*) malloc(3 * Nao * sizeof(double));
itr=0;
do {
center[itr++] = **in_ptr;
} while(in_iternext(in_iter));
NpyIter_Deallocate(in_iter);
/* lm_xyz */
in_iter = NpyIter_New(in_array2, NPY_ITER_READONLY,
NPY_KEEPORDER, NPY_NO_CASTING, NULL);
if (in_iter == NULL) goto fail;
in_iternext = NpyIter_GetIterNext(in_iter, NULL);
if (in_iternext == NULL){
NpyIter_Deallocate(in_iter);
goto fail;
}
/* interator pointer to actual numpy data */
int **in_ptr2 = (int **) NpyIter_GetDataPtrArray(in_iter);
lm_xyz = (int*) malloc(3 * Nao * sizeof(int));
itr=0;
do {
lm_xyz[itr++] = **in_ptr2;
} while(in_iternext(in_iter));
NpyIter_Deallocate(in_iter);
/* R */
in_iter = NpyIter_New(in_array3, NPY_ITER_READONLY,
NPY_KEEPORDER, NPY_NO_CASTING, NULL);
if (in_iter == NULL) goto fail;
in_iternext = NpyIter_GetIterNext(in_iter, NULL);
if (in_iternext == NULL){
NpyIter_Deallocate(in_iter);
goto fail;
}
/* interator pointer to actual numpy data */
in_ptr = (double **) NpyIter_GetDataPtrArray(in_iter);
R = (double*) malloc(3 * N * sizeof(double));
itr=0;
do {
R[itr++] = **in_ptr;
} while(in_iternext(in_iter));
NpyIter_Deallocate(in_iter);
/*** end of numpy input data ***/
/***** end of input data construction *****/
/*******************
* construct output *
*******************/
mat_dim[0] = Nao;
mat_dim[1] = Nao;
mat_dim[2] = N;
py_out = (PyArrayObject*)
PyArray_FromDims(3, mat_dim, NPY_DOUBLE);
data = pyvector_to_Carrayptrs(py_out);
/* renormalization */
renormalize(center, exp, cef, ng, lm_xyz, Nao);
/* orthogonalize */
// no effect at the moment, for debug purpose
//py_out2 = (PyArrayObject*)
// PyArray_FromDims(2, mat_dim, NPY_DOUBLE);
//overlap = pyvector_to_Carrayptrs(py_out2);
//orthogonalize(overlap, center, exp, cef, ng, lm_xyz, Nao);
#pragma omp parallel private(i, j, k) shared(data)
{
#pragma omp for schedule(dynamic)
for(i=0;i<Nao;i++){
for(j=i;j<Nao;j++){
eeKernel(R, Z, center, exp, cef, &data[Nao*N*i + N*j],
ng, lm_xyz, Nao, N, i, j);
if(j!=i){
for(k=0;k<N;k++)
data[i*N+j*Nao*N + k] = data[j*N+i*Nao*N + k];
}
}
}
} // end of omp loop
/*********************************
* clean up and return the result *
*********************************/
free(exp);
free(cef);
free(ng);
free(center);
free(R);
free(Z);
free(overlap);
Py_INCREF(py_out);
return Py_BuildValue("O", py_out);
/* in case bad things happen */
fail:
Py_XDECREF(py_out);
return NULL;
}
/* python interface */
static PyObject* kernel_matrix(PyObject* self, PyObject* args){
/* input variables */
PyArrayObject *in_array;
NpyIter *in_iter;
NpyIter_IterNextFunc *in_iternext;
PyObject *klargs;
PyObject *seq;
PyObject *item;
double *data;
char *kernel = (char*) malloc(20);
double *kerargs;
int rows, columns, len;
/* python output variables */
PyObject *np_matrix;
double *matrix;
double *xi, *xj;
int vec_dim[1];
int mat_dim[2];
int i, j, itr = 0;
/* parse numpy array and two integers as argument */
if (!PyArg_ParseTuple(args, "O!iis|O",
&PyArray_Type, &in_array, // O!, NpArray
&rows, // i
&columns, // i
&kernel, // s, kernel
/* kernel args */ &klargs)) return NULL;
/***********************
* Construct input data *
***********************/
data = (double*) malloc(rows * columns * sizeof(double));
/* create the iterators, necessary to access numpy array */
in_iter = NpyIter_New(in_array, NPY_ITER_READONLY,
NPY_KEEPORDER, NPY_NO_CASTING, NULL);
/* check input status */
if (in_iter == NULL)
goto fail;
in_iternext = NpyIter_GetIterNext(in_iter, NULL);
if (in_iternext == NULL) {
NpyIter_Deallocate(in_iter);
goto fail;
}
/* interator pointer to actual numpy data */
double **in_dataptr = (double **)
NpyIter_GetDataPtrArray(in_iter);
/* iterate over the arrays */
do {
data[itr++] = **in_dataptr;
} while(in_iternext(in_iter));
/* access python list data */
seq = PySequence_Fast(klargs, "expected a sequence");
len = PySequence_Size(klargs);
kerargs = (double*) malloc(len * sizeof(double));
for(i=0;i<len;i++){
item = PySequence_Fast_GET_ITEM(seq, i);
kerargs[i] = PyFloat_AsDouble(item);
}
Py_DECREF(seq);
/***** end of input data construction *****/
/**************************
* construct output matrix *
**************************/
matrix = (double *) malloc(rows * rows * sizeof(double));
mat_dim[0] = rows;
mat_dim[1] = rows;
vec_dim[0] = columns;
#pragma omp parallel private(i,j,xi,xj) shared(matrix)
{
#pragma omp for
for(i=0;i<rows;i++){
for(j=i;j<rows;j++){
xi = (double*) malloc(columns * sizeof(double));
xj = (double*) malloc(columns * sizeof(double));
/* construct callback input numpy arrays*/
getVector(xi, data, i, columns);
getVector(xj, data, j, columns);
matrix[j+rows*i] = kerEval(kernel,kerargs,xi,xj,columns);
if(i!=j) matrix[i+rows*j] = matrix[j+rows*i];
free(xi);
free(xj);
}
}
}
np_matrix = PyArray_SimpleNewFromData(2, mat_dim,
NPY_DOUBLE, matrix);
/***** end of output matrix construction *****/
/*********************************
* clean up and return the result *
*********************************/
Py_INCREF(np_matrix);
return np_matrix;
NpyIter_Deallocate(in_iter);
/* in case bad things happen */
fail:
Py_XDECREF(np_matrix);
return NULL;
free(data);
free(matrix);
}
