/* return the offchip (ovd, length) NumPy array with shape (offcount,2) */
static PyObject* pm_get_offchip(PyObject *self, PyObject *args)
{
PyArrayObject *py_offchip;
npy_intp shape[2];
int i;
long long *tmp;
if (!loaded(0)) {
PyErr_Format(PyExc_ValueError, "pm not Loaded!");
return NULL;
}
shape[0] = offcount;
shape[1] = 2;
if (!PyArg_ParseTuple(args,""))
return NULL;
py_offchip = (PyArrayObject *) PyArray_SimpleNew(2,shape,NPY_LONGLONG);
if (!py_offchip)
goto err_alloc;
for (i = 0; i < offcount; i++) {
tmp = (long long *) PyArray_GETPTR2(py_offchip, i, 0);
if(!tmp)
goto err;
*tmp = (long long) offchip[i].ovd;
tmp = (long long *) PyArray_GETPTR2(py_offchip, i, 1);
if(!tmp)
goto err;
*tmp = (long long) offchip[i].plen;
}
free(offchip);
return (PyObject *) py_offchip;
err:
PyArray_free(py_offchip);
err_alloc:
PyErr_Format(PyExc_ValueError, "pm_get_preemption Error");
cleanup();
return NULL;
}
NPY_NO_EXPORT PyObject *
arr_interp(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwdict)
{
PyObject *fp, *xp, *x;
PyObject *left = NULL, *right = NULL;
PyArrayObject *afp = NULL, *axp = NULL, *ax = NULL, *af = NULL;
npy_intp i, lenx, lenxp;
npy_double lval, rval;
const npy_double *dy, *dx, *dz;
npy_double *dres, *slopes = NULL;
static char *kwlist[] = {"x", "xp", "fp", "left", "right", NULL};
NPY_BEGIN_THREADS_DEF;
if (!PyArg_ParseTupleAndKeywords(args, kwdict, "OOO|OO", kwlist,
&x, &xp, &fp, &left, &right)) {
return NULL;
}
afp = (PyArrayObject *)PyArray_ContiguousFromAny(fp, NPY_DOUBLE, 1, 1);
if (afp == NULL) {
return NULL;
}
axp = (PyArrayObject *)PyArray_ContiguousFromAny(xp, NPY_DOUBLE, 1, 1);
if (axp == NULL) {
goto fail;
}
ax = (PyArrayObject *)PyArray_ContiguousFromAny(x, NPY_DOUBLE, 1, 0);
if (ax == NULL) {
goto fail;
}
lenxp = PyArray_SIZE(axp);
if (lenxp == 0) {
PyErr_SetString(PyExc_ValueError,
"array of sample points is empty");
goto fail;
}
if (PyArray_SIZE(afp) != lenxp) {
PyErr_SetString(PyExc_ValueError,
"fp and xp are not of the same length.");
goto fail;
}
af = (PyArrayObject *)PyArray_SimpleNew(PyArray_NDIM(ax),
PyArray_DIMS(ax), NPY_DOUBLE);
if (af == NULL) {
goto fail;
}
lenx = PyArray_SIZE(ax);
dy = (const npy_double *)PyArray_DATA(afp);
dx = (const npy_double *)PyArray_DATA(axp);
dz = (const npy_double *)PyArray_DATA(ax);
dres = (npy_double *)PyArray_DATA(af);
/* Get left and right fill values. */
if ((left == NULL) || (left == Py_None)) {
lval = dy[0];
}
else {
lval = PyFloat_AsDouble(left);
if ((lval == -1) && PyErr_Occurred()) {
goto fail;
}
}
if ((right == NULL) || (right == Py_None)) {
rval = dy[lenxp - 1];
}
else {
rval = PyFloat_AsDouble(right);
if ((rval == -1) && PyErr_Occurred()) {
goto fail;
}
}
/* binary_search_with_guess needs at least a 3 item long array */
if (lenxp == 1) {
const npy_double xp_val = dx[0];
const npy_double fp_val = dy[0];
NPY_BEGIN_THREADS_THRESHOLDED(lenx);
for (i = 0; i < lenx; ++i) {
const npy_double x_val = dz[i];
dres[i] = (x_val < xp_val) ? lval :
((x_val > xp_val) ? rval : fp_val);
}
NPY_END_THREADS;
}
else {
npy_intp j = 0;
/* only pre-calculate slopes if there are relatively few of them. */
if (lenxp <= lenx) {
slopes = PyArray_malloc((lenxp - 1) * sizeof(npy_double));
if (slopes == NULL) {
goto fail;
}
}
NPY_BEGIN_THREADS;
if (slopes != NULL) {
for (i = 0; i < lenxp - 1; ++i) {
slopes[i] = (dy[i+1] - dy[i]) / (dx[i+1] - dx[i]);
}
}
for (i = 0; i < lenx; ++i) {
const npy_double x_val = dz[i];
if (npy_isnan(x_val)) {
dres[i] = x_val;
continue;
}
j = binary_search_with_guess(x_val, dx, lenxp, j);
if (j == -1) {
dres[i] = lval;
}
else if (j == lenxp) {
dres[i] = rval;
}
else if (j == lenxp - 1) {
dres[i] = dy[j];
}
else {
const npy_double slope = (slopes != NULL) ? slopes[j] :
(dy[j+1] - dy[j]) / (dx[j+1] - dx[j]);
dres[i] = slope*(x_val - dx[j]) + dy[j];
}
}
NPY_END_THREADS;
}
PyArray_free(slopes);
Py_DECREF(afp);
Py_DECREF(axp);
Py_DECREF(ax);
return (PyObject *)af;
fail:
Py_XDECREF(afp);
Py_XDECREF(axp);
Py_XDECREF(ax);
Py_XDECREF(af);
return NULL;
}
static PyObject *
ufunc_frompyfunc(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *NPY_UNUSED(kwds)) {
/* Keywords are ignored for now */
PyObject *function, *pyname = NULL;
int nin, nout, i, nargs;
PyUFunc_PyFuncData *fdata;
PyUFuncObject *self;
char *fname, *str, *types, *doc;
Py_ssize_t fname_len = -1;
void * ptr, **data;
int offset[2];
if (!PyArg_ParseTuple(args, "Oii:frompyfunc", &function, &nin, &nout)) {
return NULL;
}
if (!PyCallable_Check(function)) {
PyErr_SetString(PyExc_TypeError, "function must be callable");
return NULL;
}
nargs = nin + nout;
pyname = PyObject_GetAttrString(function, "__name__");
if (pyname) {
(void) PyString_AsStringAndSize(pyname, &fname, &fname_len);
}
if (PyErr_Occurred()) {
fname = "?";
fname_len = 1;
PyErr_Clear();
}
/*
* ptr will be assigned to self->ptr, holds a pointer for enough memory for
* self->data[0] (fdata)
* self->data
* self->name
* self->types
*
* To be safest, all of these need their memory aligned on void * pointers
* Therefore, we may need to allocate extra space.
*/
offset[0] = sizeof(PyUFunc_PyFuncData);
i = (sizeof(PyUFunc_PyFuncData) % sizeof(void *));
if (i) {
offset[0] += (sizeof(void *) - i);
}
offset[1] = nargs;
i = (nargs % sizeof(void *));
if (i) {
offset[1] += (sizeof(void *)-i);
}
ptr = PyArray_malloc(offset[0] + offset[1] + sizeof(void *) +
(fname_len + 14));
if (ptr == NULL) {
Py_XDECREF(pyname);
return PyErr_NoMemory();
}
fdata = (PyUFunc_PyFuncData *)(ptr);
fdata->callable = function;
fdata->nin = nin;
fdata->nout = nout;
data = (void **)(((char *)ptr) + offset[0]);
data[0] = (void *)fdata;
types = (char *)data + sizeof(void *);
for (i = 0; i < nargs; i++) {
types[i] = NPY_OBJECT;
}
str = types + offset[1];
memcpy(str, fname, fname_len);
memcpy(str+fname_len, " (vectorized)", 14);
Py_XDECREF(pyname);
/* Do a better job someday */
doc = "dynamic ufunc based on a python function";
self = (PyUFuncObject *)PyUFunc_FromFuncAndData(
(PyUFuncGenericFunction *)pyfunc_functions, data,
types, /* ntypes */ 1, nin, nout, PyUFunc_None,
str, doc, /* unused */ 0);
if (self == NULL) {
PyArray_free(ptr);
return NULL;
}
Py_INCREF(function);
self->obj = function;
self->ptr = ptr;
self->type_resolver = &object_ufunc_type_resolver;
self->legacy_inner_loop_selector = &object_ufunc_loop_selector;
return (PyObject *)self;
}
PyObject *
ufunc_fromfunc(PyObject *NPY_UNUSED(dummy), PyObject *args) {
// unsigned long func_address; // unused
int nin, nout;
int nfuncs, ntypes, ndata;
PyObject *func_list;
PyObject *type_list;
PyObject *data_list;
PyObject *func_obj;
PyObject *type_obj;
PyObject *data_obj;
PyObject *object=NULL; /* object to hold on to while ufunc is alive */
PyObject *dispatcher = NULL;
int i, j;
int custom_dtype = 0;
PyUFuncGenericFunction *funcs;
int *types;
void **data;
PyObject *ufunc;
if (!PyArg_ParseTuple(args, "O!O!iiO|OO", &PyList_Type, &func_list,
&PyList_Type, &type_list,
&nin, &nout, &data_list,
&dispatcher,
&object)) {
return NULL;
}
if (dispatcher == Py_None)
dispatcher = NULL;
nfuncs = PyList_Size(func_list);
ntypes = PyList_Size(type_list);
if (ntypes != nfuncs) {
PyErr_SetString(PyExc_TypeError, "length of types list must be same as length of function pointer list");
return NULL;
}
ndata = PyList_Size(data_list);
if (ndata != nfuncs) {
PyErr_SetString(PyExc_TypeError, "length of data pointer list must be same as length of function pointer list");
return NULL;
}
funcs = PyArray_malloc(nfuncs * sizeof(PyUFuncGenericFunction));
if (funcs == NULL) {
return NULL;
}
/* build function pointer array */
for (i = 0; i < nfuncs; i++) {
func_obj = PyList_GetItem(func_list, i);
/* Function pointers are passed in as long objects.
Is there a better way to do this? */
if (PyLong_Check(func_obj)) {
funcs[i] = (PyUFuncGenericFunction)PyLong_AsVoidPtr(func_obj);
}
else {
PyErr_SetString(PyExc_TypeError, "function pointer must be long object, or None");
return NULL;
}
}
types = PyArray_malloc(nfuncs * (nin+nout) * sizeof(int));
if (types == NULL) {
return NULL;
}
/* build function signatures array */
for (i = 0; i < nfuncs; i++) {
type_obj = PyList_GetItem(type_list, i);
if (!type_obj)
return NULL;
for (j = 0; j < (nin+nout); j++) {
int dtype_num;
PyObject *dtype_num_obj = PyList_GetItem(type_obj, j);
if (!dtype_num_obj)
return NULL;
SENTRY_VALID_LONG(
types[i*(nin+nout) + j] = PyLong_AsLong(dtype_num_obj)
);
dtype_num = PyLong_AsLong(PyList_GetItem(type_obj, j));
SENTRY_VALID_LONG(dtype_num);
if (dtype_num >= NPY_USERDEF) {
custom_dtype = dtype_num;
}
}
}
data = PyArray_malloc(nfuncs * sizeof(void *));
if (data == NULL) {
return NULL;
}
/* build function data pointers array */
for (i = 0; i < nfuncs; i++) {
if (PyList_Check(data_list)) {
data_obj = PyList_GetItem(data_list, i);
if (PyLong_Check(data_obj)) {
data[i] = PyLong_AsVoidPtr(data_obj);
}
else if (data_obj == Py_None) {
data[i] = NULL;
}
else {
PyErr_SetString(PyExc_TypeError, "data pointer must be long object, or None");
return NULL;
}
}
else if (data_list == Py_None) {
data[i] = NULL;
}
else {
PyErr_SetString(PyExc_TypeError, "data pointers argument must be a list of void pointers, or None");
return NULL;
}
}
if (!custom_dtype) {
char *char_types = PyArray_malloc(nfuncs * (nin+nout) * sizeof(char));
for (i = 0; i < nfuncs; i++) {
for (j = 0; j < (nin+nout); j++) {
char_types[i*(nin+nout) + j] = (char)types[i*(nin+nout) + j];
}
}
PyArray_free(types);
ufunc = PyDynUFunc_FromFuncAndData((PyUFuncGenericFunction*) funcs,
data,
(char*) char_types,
nfuncs,
nin,
nout,
PyUFunc_None,
"ufunc", (char*)
"ufunc", object,
dispatcher);
}
else {
ufunc = PyDynUFunc_FromFuncAndData(0, 0, 0, 0,
nin,
nout,
PyUFunc_None,
"ufunc",
(char*) "ufunc",
object,
dispatcher);
PyUFunc_RegisterLoopForType((PyUFuncObject*)ufunc,
custom_dtype,
funcs[0],
types,
0);
PyArray_free(funcs);
PyArray_free(types);
PyArray_free(data);
}
return ufunc;
}
/*
* This is the 'busday_offset' function exposed for calling
* from Python.
*/
NPY_NO_EXPORT PyObject *
array_busday_offset(PyObject *NPY_UNUSED(self),
PyObject *args, PyObject *kwds)
{
char *kwlist[] = {"dates", "offsets", "roll",
"weekmask", "holidays", "busdaycal", "out", NULL};
PyObject *dates_in = NULL, *offsets_in = NULL, *out_in = NULL;
PyArrayObject *dates = NULL, *offsets = NULL, *out = NULL, *ret;
NPY_BUSDAY_ROLL roll = NPY_BUSDAY_RAISE;
npy_bool weekmask[7] = {2, 1, 1, 1, 1, 0, 0};
NpyBusDayCalendar *busdaycal = NULL;
int i, busdays_in_weekmask;
npy_holidayslist holidays = {NULL, NULL};
int allocated_holidays = 1;
if (!PyArg_ParseTupleAndKeywords(args, kwds,
"OO|O&O&O&O!O:busday_offset", kwlist,
&dates_in,
&offsets_in,
&PyArray_BusDayRollConverter, &roll,
&PyArray_WeekMaskConverter, &weekmask[0],
&PyArray_HolidaysConverter, &holidays,
&NpyBusDayCalendar_Type, &busdaycal,
&out_in)) {
goto fail;
}
/* Make sure only one of the weekmask/holidays and busdaycal is supplied */
if (busdaycal != NULL) {
if (weekmask[0] != 2 || holidays.begin != NULL) {
PyErr_SetString(PyExc_ValueError,
"Cannot supply both the weekmask/holidays and the "
"busdaycal parameters to busday_offset()");
goto fail;
}
/* Indicate that the holidays weren't allocated by us */
allocated_holidays = 0;
/* Copy the private normalized weekmask/holidays data */
holidays = busdaycal->holidays;
busdays_in_weekmask = busdaycal->busdays_in_weekmask;
memcpy(weekmask, busdaycal->weekmask, 7);
}
else {
/*
* Fix up the weekmask from the uninitialized
* signal value to a proper default.
*/
if (weekmask[0] == 2) {
weekmask[0] = 1;
}
/* Count the number of business days in a week */
busdays_in_weekmask = 0;
for (i = 0; i < 7; ++i) {
busdays_in_weekmask += weekmask[i];
}
/* The holidays list must be normalized before using it */
normalize_holidays_list(&holidays, weekmask);
}
/* Make 'dates' into an array */
if (PyArray_Check(dates_in)) {
dates = (PyArrayObject *)dates_in;
Py_INCREF(dates);
}
else {
PyArray_Descr *datetime_dtype;
/* Use the datetime dtype with generic units so it fills it in */
datetime_dtype = PyArray_DescrFromType(NPY_DATETIME);
if (datetime_dtype == NULL) {
goto fail;
}
/* This steals the datetime_dtype reference */
dates = (PyArrayObject *)PyArray_FromAny(dates_in, datetime_dtype,
0, 0, 0, dates_in);
if (dates == NULL) {
goto fail;
}
}
/* Make 'offsets' into an array */
offsets = (PyArrayObject *)PyArray_FromAny(offsets_in,
PyArray_DescrFromType(NPY_INT64),
0, 0, 0, offsets_in);
if (offsets == NULL) {
goto fail;
}
/* Make sure 'out' is an array if it's provided */
if (out_in != NULL) {
if (!PyArray_Check(out_in)) {
PyErr_SetString(PyExc_ValueError,
"busday_offset: must provide a NumPy array for 'out'");
goto fail;
}
out = (PyArrayObject *)out_in;
}
ret = business_day_offset(dates, offsets, out, roll,
weekmask, busdays_in_weekmask,
holidays.begin, holidays.end);
Py_DECREF(dates);
Py_DECREF(offsets);
if (allocated_holidays && holidays.begin != NULL) {
PyArray_free(holidays.begin);
}
return out == NULL ? PyArray_Return(ret) : (PyObject *)ret;
fail:
Py_XDECREF(dates);
Py_XDECREF(offsets);
if (allocated_holidays && holidays.begin != NULL) {
PyArray_free(holidays.begin);
}
return NULL;
}