static
bool Capsule_eq(PyObject *self, PyObject *other) {
if (Py_TYPE(self) == Py_TYPE(other)) {
CapsuleObject *a = (CapsuleObject*)self;
CapsuleObject *b = (CapsuleObject*)other;
void* pa = PyCapsule_GetPointer(a->capsule,
PyCapsule_GetName(a->capsule));
void* pb = PyCapsule_GetPointer(b->capsule,
PyCapsule_GetName(b->capsule));
return pa == pb;
}
return false;
}
static PyObject* diag(PyObject *self, PyObject *args)
{
PyObject *F;
matrix *d=NULL;
cholmod_factor *L;
#if PY_MAJOR_VERSION >= 3
const char *descr;
#else
char *descr;
#endif
int k, strt, incx=1, incy, nrows, ncols;
if (!set_options()) return NULL;
if (!PyArg_ParseTuple(args, "O", &F)) return NULL;
#if PY_MAJOR_VERSION >= 3
if (!PyCapsule_CheckExact(F) || !(descr = PyCapsule_GetName(F)))
err_CO("F");
if (strncmp(descr, "CHOLMOD FACTOR", 14))
PY_ERR_TYPE("F is not a CHOLMOD factor");
L = (cholmod_factor *) PyCapsule_GetPointer(F, descr);
#else
if (!PyCObject_Check(F)) err_CO("F");
descr = PyCObject_GetDesc(F);
if (!descr || strncmp(descr, "CHOLMOD FACTOR", 14))
PY_ERR_TYPE("F is not a CHOLMOD factor");
L = (cholmod_factor *) PyCObject_AsVoidPtr(F);
#endif
/* Check factorization */
if (L->xtype == CHOLMOD_PATTERN || L->minor<L->n || !L->is_ll
|| !L->is_super)
PY_ERR(PyExc_ValueError, "F must be a nonsingular supernodal "
"Cholesky factor");
if (!(d = Matrix_New(L->n,1,L->xtype == CHOLMOD_REAL ? DOUBLE :
COMPLEX))) return PyErr_NoMemory();
strt = 0;
for (k=0; k<L->nsuper; k++){
/* x[L->px[k], .... ,L->px[k+1]-1] is a dense lower-triangular
* nrowx times ncols matrix. We copy its diagonal to
* d[strt, ..., strt+ncols-1] */
ncols = (int)((int_t *) L->super)[k+1] -
((int_t *) L->super)[k];
nrows = (int)((int_t *) L->pi)[k+1] - ((int_t *) L->pi)[k];
incy = nrows+1;
if (MAT_ID(d) == DOUBLE)
dcopy_(&ncols, ((double *) L->x) + ((int_t *) L->px)[k],
&incy, MAT_BUFD(d)+strt, &incx);
else
zcopy_(&ncols, ((double complex *) L->x) + ((int_t *) L->px)[k],
&incy, MAT_BUFZ(d)+strt, &incx);
strt += ncols;
}
return (PyObject *)d;
}
static
PyObject* getPointer(PyObject* self, PyObject* args) {
PyObject* obj;
if (!PyArg_ParseTuple(args, "O", &obj)){
return NULL;
}
void* pointer = PyCapsule_GetPointer(obj, PyCapsule_GetName(obj));
if (!pointer) return NULL;
return PyLong_FromVoidPtr(pointer);
}
static
PyObject* getName(PyObject* self, PyObject* args) {
PyObject* obj;
if (!PyArg_ParseTuple(args, "O", &obj)){
return NULL;
}
const char* name = PyCapsule_GetName(obj);
if (!name) return NULL;
return PyString_FromString(name);
}
static PyObject* capsule_name(PyObject* self, PyObject* args)
{
PyObject *capsule = 0;
if (!PyArg_ParseTuple(args, "O", &capsule)) return 0;
if (!PyCapsule_CheckExact(capsule))
{
PyErr_SetString(PyExc_RuntimeError, "Object is not a PyCapsule.");
return 0;
}
return Py_BuildValue("s", PyCapsule_GetName(capsule));
}
int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
PyObject *d = 0;
PyObject *cobj = 0;
union {
void (*fp)(void);
void *p;
} tmp;
d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
if (!d)
goto bad;
cobj = PyDict_GetItemString(d, funcname);
if (!cobj) {
PyErr_Format(PyExc_ImportError,
"%s does not export expected C function %s",
PyModule_GetName(module), funcname);
goto bad;
}
#if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)
if (!PyCapsule_IsValid(cobj, sig)) {
PyErr_Format(PyExc_TypeError,
"C function %s.%s has wrong signature (expected %s, got %s)",
PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
goto bad;
}
tmp.p = PyCapsule_GetPointer(cobj, sig);
#else
{const char *desc, *s1, *s2;
desc = (const char *)PyCObject_GetDesc(cobj);
if (!desc)
goto bad;
s1 = desc; s2 = sig;
while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
if (*s1 != *s2) {
PyErr_Format(PyExc_TypeError,
"C function %s.%s has wrong signature (expected %s, got %s)",
PyModule_GetName(module), funcname, sig, desc);
goto bad;
}
tmp.p = PyCObject_AsVoidPtr(cobj);}
#endif
*f = tmp.fp;
if (!(*f))
goto bad;
Py_DECREF(d);
return 0;
bad:
Py_XDECREF(d);
return -1;
}
static PyObject* getfactor(PyObject *self, PyObject *args)
{
PyObject *F;
cholmod_factor *Lf;
cholmod_sparse *Ls;
#if PY_MAJOR_VERSION >= 3
const char *descr;
#else
char *descr;
#endif
if (!set_options()) return NULL;
if (!PyArg_ParseTuple(args, "O", &F)) return NULL;
#if PY_MAJOR_VERSION >= 3
if (!PyCapsule_CheckExact(F) || !(descr = PyCapsule_GetName(F)))
err_CO("F");
if (strncmp(descr, "CHOLMOD FACTOR", 14))
PY_ERR_TYPE("F is not a CHOLMOD factor");
Lf = (cholmod_factor *) PyCapsule_GetPointer(F, descr);
#else
if (!PyCObject_Check(F)) err_CO("F");
descr = PyCObject_GetDesc(F);
if (!descr || strncmp(descr, "CHOLMOD FACTOR", 14))
PY_ERR_TYPE("F is not a CHOLMOD factor");
Lf = (cholmod_factor *) PyCObject_AsVoidPtr(F);
#endif
/* Check factorization */
if (Lf->xtype == CHOLMOD_PATTERN)
PY_ERR(PyExc_ValueError, "F must be a numeric Cholesky factor");
if (!(Ls = CHOL(factor_to_sparse)(Lf, &Common)))
return PyErr_NoMemory();
spmatrix *ret = SpMatrix_New(Ls->nrow, Ls->ncol, Ls->nzmax,
(Ls->xtype == CHOLMOD_REAL ? DOUBLE : COMPLEX));
if (!ret) {
CHOL(free_sparse)(&Ls, &Common);
return PyErr_NoMemory();
}
memcpy(SP_COL(ret), Ls->p, (Ls->ncol+1)*sizeof(int_t));
memcpy(SP_ROW(ret), Ls->i, (Ls->nzmax)*sizeof(int_t));
memcpy(SP_VAL(ret), Ls->x, (Ls->nzmax)*E_SIZE[SP_ID(ret)]);
CHOL(free_sparse)(&Ls, &Common);
return (PyObject *)ret;
}
void *
PyCObject_AsVoidPtr(PyObject *self)
{
if (self) {
if (PyCapsule_CheckExact(self)) {
const char *name = PyCapsule_GetName(self);
return (void *)PyCapsule_GetPointer(self, name);
}
if (self->ob_type == &PyCObject_Type)
return ((PyCObject *)self)->cobject;
PyErr_SetString(PyExc_TypeError,
"PyCObject_AsVoidPtr with non-C-object");
}
if (!PyErr_Occurred())
PyErr_SetString(PyExc_TypeError,
"PyCObject_AsVoidPtr called with null pointer");
return NULL;
}
/*
This is called everytime an object is returned from LLVM.
It derserves to be optimized to reduce unnecessary Python object allocation.
The following implements a simple hash function that uses XOR and
right-rotation.
*/
static
long Capsule_hash(CapsuleObject *self) {
const char* name = PyCapsule_GetName(self->capsule);
void *pointer = PyCapsule_GetPointer(self->capsule, name);
unsigned long hash = 0xabcd1234 ^ (unsigned long)pointer;
// The first loop accounts for the different LLVM class name and the
// length of the name.
for(const char* p = name; *p != '\0'; ++p) {
hash ^= *p;
hash = RotR(hash, 11);
}
// The second loop accounts for the pointer identity.
for(int i = 0; i <sizeof(pointer); ++i) {
hash ^= ((unsigned char*)&pointer)[i];
hash = RotR(hash, 11);
}
return hash;
}
static PyObject* numeric(PyObject *self, PyObject *args)
{
spmatrix *A;
PyObject *F;
cholmod_factor *Lc;
cholmod_sparse *Ac = NULL;
char uplo;
#if PY_MAJOR_VERSION >= 3
const char *descr;
#else
char *descr;
#endif
if (!set_options()) return NULL;
if (!PyArg_ParseTuple(args, "OO", &A, &F)) return NULL;
if (!SpMatrix_Check(A) || SP_NROWS(A) != SP_NCOLS(A))
PY_ERR_TYPE("A is not a sparse matrix");
#if PY_MAJOR_VERSION >= 3
if (!PyCapsule_CheckExact(F) || !(descr = PyCapsule_GetName(F)))
err_CO("F");
#else
if (!PyCObject_Check(F)) err_CO("F");
descr = PyCObject_GetDesc(F);
if (!descr) PY_ERR_TYPE("F is not a CHOLMOD factor");
#endif
if (SP_ID(A) == DOUBLE){
if (!strcmp(descr, "CHOLMOD FACTOR D L"))
uplo = 'L';
else if (!strcmp(descr, "CHOLMOD FACTOR D U"))
uplo = 'U';
else
PY_ERR_TYPE("F is not the CHOLMOD factor of a 'd' matrix");
} else {
if (!strcmp(descr, "CHOLMOD FACTOR Z L"))
uplo = 'L';
else if (!strcmp(descr, "CHOLMOD FACTOR Z U"))
uplo = 'U';
else
PY_ERR_TYPE("F is not the CHOLMOD factor of a 'z' matrix");
}
#if PY_MAJOR_VERSION >= 3
Lc = (cholmod_factor *) PyCapsule_GetPointer(F, descr);
#else
Lc = (cholmod_factor *) PyCObject_AsVoidPtr(F);
#endif
if (!(Ac = pack(A, uplo))) return PyErr_NoMemory();
CHOL(factorize) (Ac, Lc, &Common);
CHOL(free_sparse)(&Ac, &Common);
if (Common.status < 0) switch (Common.status) {
case CHOLMOD_OUT_OF_MEMORY:
return PyErr_NoMemory();
default:
PyErr_SetString(PyExc_ValueError, "factorization failed");
return NULL;
}
if (Common.status > 0) switch (Common.status) {
case CHOLMOD_NOT_POSDEF:
PyErr_SetObject(PyExc_ArithmeticError, Py_BuildValue("i",
Lc->minor));
return NULL;
break;
case CHOLMOD_DSMALL:
/* This never happens unless we change the default value
* of Common.dbound (0.0). */
if (Lc->is_ll)
PyErr_Warn(PyExc_RuntimeWarning, "tiny diagonal "\
"elements in L");
else
PyErr_Warn(PyExc_RuntimeWarning, "tiny diagonal "\
"elements in D");
break;
default:
PyErr_Warn(PyExc_UserWarning, "");
}
return Py_BuildValue("");
}
static
PyObject* GetPointer(PyObject* obj){
void *pointer = PyCapsule_GetPointer(obj, PyCapsule_GetName(obj));
if (!pointer) return NULL;
return PyLong_FromVoidPtr(pointer);
}
static
PyObject* GetName(PyObject* obj) {
const char* name = PyCapsule_GetName(obj);
if (!name) return NULL;
return PyString_InternFromString(name);
}
static void free_umfpack_z_numeric(void *F)
{
void *Fptr = PyCapsule_GetPointer(F, PyCapsule_GetName(F));
UMFZ(free_numeric)(&Fptr);
}
static PyObject *Py_GenericFilter(PyObject *obj, PyObject *args)
{
PyArrayObject *input = NULL, *output = NULL, *footprint = NULL;
PyObject *fnc = NULL, *extra_arguments = NULL, *extra_keywords = NULL;
void *func = NULL, *data = NULL;
NI_PythonCallbackData cbdata;
int mode;
PyArray_Dims origin;
double cval;
ccallback_t callback;
static ccallback_signature_t callback_signatures[] = {
{"int (double *, intptr_t, double *, void *)"},
{"int (double *, npy_intp, double *, void *)"},
#if NPY_SIZEOF_INTP == NPY_SIZEOF_SHORT
{"int (double *, short, double *, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_INT
{"int (double *, int, double *, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_LONG
{"int (double *, long, double *, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_LONGLONG
{"int (double *, long long, double *, void *)"},
#endif
{NULL}
};
callback.py_function = NULL;
callback.c_function = NULL;
if (!PyArg_ParseTuple(args, "O&OO&O&idO&OO",
NI_ObjectToInputArray, &input,
&fnc,
NI_ObjectToInputArray, &footprint,
NI_ObjectToOutputArray, &output,
&mode, &cval,
PyArray_IntpConverter, &origin,
&extra_arguments, &extra_keywords)) {
goto exit;
}
if (!_validate_origin(input, origin)) {
goto exit;
}
if (!PyTuple_Check(extra_arguments)) {
PyErr_SetString(PyExc_RuntimeError, "extra_arguments must be a tuple");
goto exit;
}
if (!PyDict_Check(extra_keywords)) {
PyErr_SetString(PyExc_RuntimeError,
"extra_keywords must be a dictionary");
goto exit;
}
if (PyCapsule_CheckExact(fnc) && PyCapsule_GetName(fnc) == NULL) {
func = PyCapsule_GetPointer(fnc, NULL);
data = PyCapsule_GetContext(fnc);
#if PY_VERSION_HEX < 0x03000000
} else if (PyCObject_Check(fnc)) {
/* 'Legacy' low-level callable on Py2 */
func = PyCObject_AsVoidPtr(fnc);
data = PyCObject_GetDesc(fnc);
#endif
} else {
int ret;
ret = ccallback_prepare(&callback, callback_signatures, fnc, CCALLBACK_DEFAULTS);
if (ret == -1) {
goto exit;
}
if (callback.py_function != NULL) {
cbdata.extra_arguments = extra_arguments;
cbdata.extra_keywords = extra_keywords;
callback.info_p = (void*)&cbdata;
func = Py_FilterFunc;
data = (void*)&callback;
}
else {
func = callback.c_function;
data = callback.user_data;
}
}
NI_GenericFilter(input, func, data, footprint, output, (NI_ExtendMode)mode,
cval, origin.ptr);
#ifdef HAVE_WRITEBACKIFCOPY
PyArray_ResolveWritebackIfCopy(output);
#endif
exit:
if (callback.py_function != NULL || callback.c_function != NULL) {
ccallback_release(&callback);
}
Py_XDECREF(input);
Py_XDECREF(output);
Py_XDECREF(footprint);
PyDimMem_FREE(origin.ptr);
return PyErr_Occurred() ? NULL : Py_BuildValue("");
}
static PyObject *Py_GeometricTransform(PyObject *obj, PyObject *args)
{
PyArrayObject *input = NULL, *output = NULL;
PyArrayObject *coordinates = NULL, *matrix = NULL, *shift = NULL;
PyObject *fnc = NULL, *extra_arguments = NULL, *extra_keywords = NULL;
int mode, order;
double cval;
void *func = NULL, *data = NULL;
NI_PythonCallbackData cbdata;
ccallback_t callback;
static ccallback_signature_t callback_signatures[] = {
{"int (intptr_t *, double *, int, int, void *)"},
{"int (npy_intp *, double *, int, int, void *)"},
#if NPY_SIZEOF_INTP == NPY_SIZEOF_SHORT
{"int (short *, double *, int, int, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_INT
{"int (int *, double *, int, int, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_LONG
{"int (long *, double *, int, int, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_LONGLONG
{"int (long long *, double *, int, int, void *)"},
#endif
{NULL}
};
callback.py_function = NULL;
callback.c_function = NULL;
if (!PyArg_ParseTuple(args, "O&OO&O&O&O&iidOO",
NI_ObjectToInputArray, &input,
&fnc,
NI_ObjectToOptionalInputArray, &coordinates,
NI_ObjectToOptionalInputArray, &matrix,
NI_ObjectToOptionalInputArray, &shift,
NI_ObjectToOutputArray, &output,
&order, &mode, &cval,
&extra_arguments, &extra_keywords))
goto exit;
if (fnc != Py_None) {
if (!PyTuple_Check(extra_arguments)) {
PyErr_SetString(PyExc_RuntimeError,
"extra_arguments must be a tuple");
goto exit;
}
if (!PyDict_Check(extra_keywords)) {
PyErr_SetString(PyExc_RuntimeError,
"extra_keywords must be a dictionary");
goto exit;
}
if (PyCapsule_CheckExact(fnc) && PyCapsule_GetName(fnc) == NULL) {
func = PyCapsule_GetPointer(fnc, NULL);
data = PyCapsule_GetContext(fnc);
#if PY_VERSION_HEX < 0x03000000
} else if (PyCObject_Check(fnc)) {
/* 'Legacy' low-level callable on Py2 */
func = PyCObject_AsVoidPtr(fnc);
data = PyCObject_GetDesc(fnc);
#endif
} else {
int ret;
ret = ccallback_prepare(&callback, callback_signatures, fnc, CCALLBACK_DEFAULTS);
if (ret == -1) {
goto exit;
}
if (callback.py_function != NULL) {
cbdata.extra_arguments = extra_arguments;
cbdata.extra_keywords = extra_keywords;
callback.info_p = (void*)&cbdata;
func = Py_Map;
data = (void*)&callback;
}
else {
func = callback.c_function;
data = callback.user_data;
}
}
}
NI_GeometricTransform(input, func, data, matrix, shift, coordinates,
output, order, (NI_ExtendMode)mode, cval);
#ifdef HAVE_WRITEBACKIFCOPY
PyArray_ResolveWritebackIfCopy(output);
#endif
exit:
if (callback.py_function != NULL || callback.c_function != NULL) {
ccallback_release(&callback);
}
Py_XDECREF(input);
Py_XDECREF(output);
Py_XDECREF(coordinates);
Py_XDECREF(matrix);
Py_XDECREF(shift);
return PyErr_Occurred() ? NULL : Py_BuildValue("");
}
static PyObject* spsolve(PyObject *self, PyObject *args,
PyObject *kwrds)
{
spmatrix *B, *X=NULL;
cholmod_sparse *Bc=NULL, *Xc=NULL;
PyObject *F;
cholmod_factor *L;
int n, sys=0;
#if PY_MAJOR_VERSION >= 3
const char *descr;
#else
char *descr;
#endif
char *kwlist[] = {"F", "B", "sys", NULL};
int sysvalues[] = {CHOLMOD_A, CHOLMOD_LDLt, CHOLMOD_LD,
CHOLMOD_DLt, CHOLMOD_L, CHOLMOD_Lt, CHOLMOD_D, CHOLMOD_P,
CHOLMOD_Pt };
if (!set_options()) return NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OO|i", kwlist, &F,
&B, &sys)) return NULL;
#if PY_MAJOR_VERSION >= 3
if (!PyCapsule_CheckExact(F) || !(descr = PyCapsule_GetName(F)))
err_CO("F");
if (strncmp(descr, "CHOLMOD FACTOR", 14))
PY_ERR_TYPE("F is not a CHOLMOD factor");
L = (cholmod_factor *) PyCapsule_GetPointer(F, descr);
#else
if (!PyCObject_Check(F)) err_CO("F");
descr = PyCObject_GetDesc(F);
if (!descr || strncmp(descr, "CHOLMOD FACTOR", 14))
PY_ERR_TYPE("F is not a CHOLMOD factor");
L = (cholmod_factor *) PyCObject_AsVoidPtr(F);
#endif
if (L->xtype == CHOLMOD_PATTERN)
PY_ERR(PyExc_ValueError, "called with symbolic factor");
n = L->n;
if (L->minor<n) PY_ERR(PyExc_ArithmeticError, "singular matrix");
if (sys < 0 || sys > 8)
PY_ERR(PyExc_ValueError, "invalid value for sys");
if (!SpMatrix_Check(B) ||
(SP_ID(B) == DOUBLE && L->xtype == CHOLMOD_COMPLEX) ||
(SP_ID(B) == COMPLEX && L->xtype == CHOLMOD_REAL))
PY_ERR_TYPE("B must a sparse matrix of the same "
"numerical type as F");
if (SP_NROWS(B) != n)
PY_ERR(PyExc_ValueError, "incompatible dimensions for B");
if (!(Bc = create_matrix(B))) return PyErr_NoMemory();
Xc = CHOL(spsolve)(sysvalues[sys], L, Bc, &Common);
free_matrix(Bc);
if (Common.status == CHOLMOD_OUT_OF_MEMORY) return PyErr_NoMemory();
if (Common.status != CHOLMOD_OK)
PY_ERR(PyExc_ValueError, "solve step failed");
if (!(X = SpMatrix_New(Xc->nrow, Xc->ncol,
((int_t*)Xc->p)[Xc->ncol], (L->xtype == CHOLMOD_REAL ? DOUBLE :
COMPLEX)))) {
CHOL(free_sparse)(&Xc, &Common);
return PyErr_NoMemory();
}
memcpy(SP_COL(X), Xc->p, (Xc->ncol+1)*sizeof(int_t));
memcpy(SP_ROW(X), Xc->i, ((int_t *)Xc->p)[Xc->ncol]*sizeof(int_t));
memcpy(SP_VAL(X), Xc->x,
((int_t *) Xc->p)[Xc->ncol]*E_SIZE[SP_ID(X)]);
CHOL(free_sparse)(&Xc, &Common);
return (PyObject *) X;
}
static PyObject* solve(PyObject *self, PyObject *args, PyObject *kwrds)
{
matrix *B;
PyObject *F;
int i, n, oB=0, ldB=0, nrhs=-1, sys=0;
#if PY_MAJOR_VERSION >= 3
const char *descr;
#else
char *descr;
#endif
char *kwlist[] = {"F", "B", "sys", "nrhs", "ldB", "offsetB", NULL};
int sysvalues[] = { CHOLMOD_A, CHOLMOD_LDLt, CHOLMOD_LD,
CHOLMOD_DLt, CHOLMOD_L, CHOLMOD_Lt, CHOLMOD_D, CHOLMOD_P,
CHOLMOD_Pt };
if (!set_options()) return NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OO|iiii", kwlist,
&F, &B, &sys, &nrhs, &ldB, &oB)) return NULL;
#if PY_MAJOR_VERSION >= 3
if (!PyCapsule_CheckExact(F) || !(descr = PyCapsule_GetName(F)))
err_CO("F");
if (strncmp(descr, "CHOLMOD FACTOR", 14))
PY_ERR_TYPE("F is not a CHOLMOD factor");
cholmod_factor *L = (cholmod_factor *) PyCapsule_GetPointer(F, descr);
#else
if (!PyCObject_Check(F)) err_CO("F");
descr = PyCObject_GetDesc(F);
if (!descr || strncmp(descr, "CHOLMOD FACTOR", 14))
PY_ERR_TYPE("F is not a CHOLMOD factor");
cholmod_factor *L = (cholmod_factor *) PyCObject_AsVoidPtr(F);
#endif
if (L->xtype == CHOLMOD_PATTERN)
PY_ERR(PyExc_ValueError, "called with symbolic factor");
n = L->n;
if (L->minor<n) PY_ERR(PyExc_ArithmeticError, "singular matrix");
if (sys < 0 || sys > 8)
PY_ERR(PyExc_ValueError, "invalid value for sys");
if (!Matrix_Check(B) || MAT_ID(B) == INT ||
(MAT_ID(B) == DOUBLE && L->xtype == CHOLMOD_COMPLEX) ||
(MAT_ID(B) == COMPLEX && L->xtype == CHOLMOD_REAL))
PY_ERR_TYPE("B must a dense matrix of the same numerical "
"type as F");
if (nrhs < 0) nrhs = MAT_NCOLS(B);
if (n == 0 || nrhs == 0) return Py_BuildValue("");
if (ldB == 0) ldB = MAX(1,MAT_NROWS(B));
if (ldB < MAX(1,n)) err_ld("ldB");
if (oB < 0) err_nn_int("offsetB");
if (oB + (nrhs-1)*ldB + n > MAT_LGT(B)) err_buf_len("B");
cholmod_dense *x;
cholmod_dense *b = CHOL(allocate_dense)(n, 1, n,
(MAT_ID(B) == DOUBLE ? CHOLMOD_REAL : CHOLMOD_COMPLEX),
&Common);
if (Common.status == CHOLMOD_OUT_OF_MEMORY) return PyErr_NoMemory();
void *b_old = b->x;
for (i=0; i<nrhs; i++){
b->x = MAT_BUF(B) + (i*ldB + oB)*E_SIZE[MAT_ID(B)];
x = CHOL(solve) (sysvalues[sys], L, b, &Common);
if (Common.status != CHOLMOD_OK){
PyErr_SetString(PyExc_ValueError, "solve step failed");
CHOL(free_dense)(&x, &Common);
CHOL(free_dense)(&b, &Common);
return NULL;
}
memcpy(b->x, x->x, n*E_SIZE[MAT_ID(B)]);
CHOL(free_dense)(&x, &Common);
}
b->x = b_old;
CHOL(free_dense)(&b, &Common);
return Py_BuildValue("");
}
static void free_umfpack_d_symbolic(void *F)
{
void *Fptr = PyCapsule_GetPointer(F, PyCapsule_GetName(F));
UMFD(free_symbolic)(&Fptr);
}
static void cvxopt_free_cholmod_factor(void *L)
{
void *Lptr = PyCapsule_GetPointer(L, PyCapsule_GetName(L));
CHOL(free_factor) ((cholmod_factor **) &Lptr, &Common);
}
static void
pyccn_Capsule_Destructor(PyObject *capsule)
{
const char *name;
void *pointer;
enum _pyccn_capsules type;
assert(PyCapsule_CheckExact(capsule));
name = PyCapsule_GetName(capsule);
type = name2type(name);
pointer = PyCapsule_GetPointer(capsule, name);
assert(pointer);
switch (type) {
case CLOSURE:
{
PyObject *py_obj_closure;
struct ccn_closure *p = pointer;
py_obj_closure = PyCapsule_GetContext(capsule);
assert(py_obj_closure);
Py_DECREF(py_obj_closure); /* No longer referencing Closure object */
/* If we store something else, than ourselves, it probably is a bug */
assert(capsule == p->data);
free(p);
}
break;
case CONTENT_OBJECT:
{
struct content_object_data *context;
struct ccn_charbuf *p = pointer;
context = PyCapsule_GetContext(capsule);
if (context) {
if (context->pco)
free(context->pco);
ccn_indexbuf_destroy(&context->comps);
free(context);
}
ccn_charbuf_destroy(&p);
}
break;
case HANDLE:
{
struct ccn *p = pointer;
ccn_disconnect(p);
ccn_destroy(&p);
}
break;
case INTEREST:
{
struct interest_data *context;
struct ccn_charbuf *p = pointer;
context = PyCapsule_GetContext(capsule);
if (context) {
if (context->pi)
free(context->pi);
free(context);
}
ccn_charbuf_destroy(&p);
}
break;
case PKEY_PRIV:
case PKEY_PUB:
{
struct ccn_pkey *p = pointer;
ccn_pubkey_free(p);
}
break;
case EXCLUSION_FILTER:
case KEY_LOCATOR:
case NAME:
case SIGNATURE:
case SIGNED_INFO:
{
struct ccn_charbuf *p = pointer;
ccn_charbuf_destroy(&p);
}
break;
case SIGNING_PARAMS:
{
struct ccn_signing_params *p = pointer;
if (p->template_ccnb)
ccn_charbuf_destroy(&p->template_ccnb);
free(p);
}
break;
default:
debug("Got capsule: %s\n", PyCapsule_GetName(capsule));
panic("Unable to destroy the object: got an unknown capsule");
}
}