static PyObject *simplex(PyObject *self, PyObject *args,
PyObject *kwrds)
{
matrix *c, *h, *b=NULL, *x=NULL, *z=NULL, *y=NULL;
PyObject *G, *A=NULL, *t=NULL;
glp_prob *lp;
glp_smcp *options = NULL;
pysmcp *smcpParm = NULL;
int m, n, p, i, j, k, nnz, nnzmax, *rn=NULL, *cn=NULL;
double *a=NULL, val;
char *kwlist[] = {"c", "G", "h", "A", "b","options", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OOO|OOO!", kwlist, &c,
&G, &h, &A, &b,&smcp_t,&smcpParm)) return NULL;
if ((Matrix_Check(G) && MAT_ID(G) != DOUBLE) ||
(SpMatrix_Check(G) && SP_ID(G) != DOUBLE) ||
(!Matrix_Check(G) && !SpMatrix_Check(G))){
PyErr_SetString(PyExc_TypeError, "G must be a 'd' matrix");
return NULL;
}
if ((m = Matrix_Check(G) ? MAT_NROWS(G) : SP_NROWS(G)) <= 0)
err_p_int("m");
if ((n = Matrix_Check(G) ? MAT_NCOLS(G) : SP_NCOLS(G)) <= 0)
err_p_int("n");
if (!Matrix_Check(h) || h->id != DOUBLE) err_dbl_mtrx("h");
if (h->nrows != m || h->ncols != 1){
PyErr_SetString(PyExc_ValueError, "incompatible dimensions");
return NULL;
}
if (A){
if ((Matrix_Check(A) && MAT_ID(A) != DOUBLE) ||
(SpMatrix_Check(A) && SP_ID(A) != DOUBLE) ||
(!Matrix_Check(A) && !SpMatrix_Check(A))){
PyErr_SetString(PyExc_ValueError, "A must be a dense "
"'d' matrix or a general sparse matrix");
return NULL;
}
if ((p = Matrix_Check(A) ? MAT_NROWS(A) : SP_NROWS(A)) < 0)
err_p_int("p");
if ((Matrix_Check(A) ? MAT_NCOLS(A) : SP_NCOLS(A)) != n){
PyErr_SetString(PyExc_ValueError, "incompatible "
"dimensions");
return NULL;
}
}
else p = 0;
if (b && (!Matrix_Check(b) || b->id != DOUBLE)) err_dbl_mtrx("b");
if ((b && (b->nrows != p || b->ncols != 1)) || (!b && p !=0 )){
PyErr_SetString(PyExc_ValueError, "incompatible dimensions");
return NULL;
}
if(!smcpParm)
{
smcpParm = (pysmcp*)malloc(sizeof(*smcpParm));
glp_init_smcp(&(smcpParm->obj));
}
if(smcpParm)
{
Py_INCREF(smcpParm);
options = &smcpParm->obj;
options->presolve = 1;
}
lp = glp_create_prob();
glp_add_rows(lp, m+p);
glp_add_cols(lp, n);
for (i=0; i<n; i++){
glp_set_obj_coef(lp, i+1, MAT_BUFD(c)[i]);
glp_set_col_bnds(lp, i+1, GLP_FR, 0.0, 0.0);
}
for (i=0; i<m; i++)
glp_set_row_bnds(lp, i+1, GLP_UP, 0.0, MAT_BUFD(h)[i]);
for (i=0; i<p; i++)
glp_set_row_bnds(lp, i+m+1, GLP_FX, MAT_BUFD(b)[i],
MAT_BUFD(b)[i]);
nnzmax = (SpMatrix_Check(G) ? SP_NNZ(G) : m*n ) +
((A && SpMatrix_Check(A)) ? SP_NNZ(A) : p*n);
a = (double *) calloc(nnzmax+1, sizeof(double));
rn = (int *) calloc(nnzmax+1, sizeof(int));
cn = (int *) calloc(nnzmax+1, sizeof(int));
if (!a || !rn || !cn){
free(a); free(rn); free(cn); glp_delete_prob(lp);
return PyErr_NoMemory();
}
nnz = 0;
if (SpMatrix_Check(G)) {
for (j=0; j<n; j++) for (k=SP_COL(G)[j]; k<SP_COL(G)[j+1]; k++)
if ((val = SP_VALD(G)[k]) != 0.0){
a[1+nnz] = val;
rn[1+nnz] = SP_ROW(G)[k]+1;
cn[1+nnz] = j+1;
nnz++;
}
}
else for (j=0; j<n; j++) for (i=0; i<m; i++)
if ((val = MAT_BUFD(G)[i+j*m]) != 0.0){
a[1+nnz] = val;
rn[1+nnz] = i+1;
cn[1+nnz] = j+1;
nnz++;
}
if (A && SpMatrix_Check(A)){
for (j=0; j<n; j++) for (k=SP_COL(A)[j]; k<SP_COL(A)[j+1]; k++)
if ((val = SP_VALD(A)[k]) != 0.0){
a[1+nnz] = val;
rn[1+nnz] = m+SP_ROW(A)[k]+1;
cn[1+nnz] = j+1;
nnz++;
}
}
else for (j=0; j<n; j++) for (i=0; i<p; i++)
if ((val = MAT_BUFD(A)[i+j*p]) != 0.0){
a[1+nnz] = val;
rn[1+nnz] = m+i+1;
cn[1+nnz] = j+1;
nnz++;
}
glp_load_matrix(lp, nnz, rn, cn, a);
free(rn); free(cn); free(a);
if (!(t = PyTuple_New(A ? 4 : 3))){
glp_delete_prob(lp);
return PyErr_NoMemory();
}
switch (glp_simplex(lp,options)){
case 0:
x = (matrix *) Matrix_New(n,1,DOUBLE);
z = (matrix *) Matrix_New(m,1,DOUBLE);
if (A) y = (matrix *) Matrix_New(p,1,DOUBLE);
if (!x || !z || (A && !y)){
Py_XDECREF(x);
Py_XDECREF(z);
Py_XDECREF(y);
Py_XDECREF(t);
Py_XDECREF(smcpParm);
glp_delete_prob(lp);
return PyErr_NoMemory();
}
set_output_string(t,"optimal");
for (i=0; i<n; i++)
MAT_BUFD(x)[i] = glp_get_col_prim(lp, i+1);
PyTuple_SET_ITEM(t, 1, (PyObject *) x);
for (i=0; i<m; i++)
MAT_BUFD(z)[i] = -glp_get_row_dual(lp, i+1);
PyTuple_SET_ITEM(t, 2, (PyObject *) z);
if (A){
for (i=0; i<p; i++)
MAT_BUFD(y)[i] = -glp_get_row_dual(lp, m+i+1);
PyTuple_SET_ITEM(t, 3, (PyObject *) y);
}
Py_XDECREF(smcpParm);
glp_delete_prob(lp);
return (PyObject *) t;
case GLP_EBADB:
set_output_string(t,"incorrect initial basis");
break;
case GLP_ESING:
set_output_string(t,"singular initial basis matrix");
break;
case GLP_ECOND:
set_output_string(t,"ill-conditioned initial basis matrix");
break;
case GLP_EBOUND:
set_output_string(t,"incorrect bounds");
break;
case GLP_EFAIL:
set_output_string(t,"solver failure");
break;
case GLP_EOBJLL:
set_output_string(t,"objective function reached lower limit");
break;
case GLP_EOBJUL:
set_output_string(t,"objective function reached upper limit");
break;
case GLP_EITLIM:
set_output_string(t,"iteration limit exceeded");
break;
case GLP_ETMLIM:
set_output_string(t,"time limit exceeded");
break;
case GLP_ENOPFS:
set_output_string(t,"primal infeasible");
break;
case GLP_ENODFS:
set_output_string(t,"dual infeasible");
break;
default:
set_output_string(t,"unknown");
break;
}
Py_XDECREF(smcpParm);
glp_delete_prob(lp);
PyTuple_SET_ITEM(t, 1, Py_BuildValue(""));
PyTuple_SET_ITEM(t, 2, Py_BuildValue(""));
if (A) PyTuple_SET_ITEM(t, 3, Py_BuildValue(""));
return (PyObject *) t;
}
static PyObject* splinsolve(PyObject *self, PyObject *args,
PyObject *kwrds)
{
spmatrix *A, *B, *X;
matrix *P=NULL;
int n, nnz;
cholmod_sparse *Ac=NULL, *Bc=NULL, *Xc=NULL;
cholmod_factor *L=NULL;
#if PY_MAJOR_VERSION >= 3
int uplo_='L';
#endif
char uplo='L';
char *kwlist[] = {"A", "B", "p", "uplo", NULL};
if (!set_options()) return NULL;
#if PY_MAJOR_VERSION >= 3
if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OO|OC", kwlist, &A,
&B, &P, &uplo_)) return NULL;
uplo = (char) uplo_;
#else
if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OO|Oc", kwlist, &A,
&B, &P, &uplo)) return NULL;
#endif
if (!SpMatrix_Check(A) || SP_NROWS(A) != SP_NCOLS(A))
PY_ERR_TYPE("A is not a square sparse matrix");
n = SP_NROWS(A);
nnz = SP_NNZ(A);
if (!SpMatrix_Check(B) || SP_ID(A) != SP_ID(B))
PY_ERR_TYPE("B must be a sparse matrix of the same type as A");
if (SP_NROWS(B) != n)
PY_ERR(PyExc_ValueError, "incompatible dimensions for B");
if (P) {
if (!Matrix_Check(P) || MAT_ID(P) != INT) err_int_mtrx("p");
if (MAT_LGT(P) != n) err_buf_len("p");
if (!CHOL(check_perm)(P->buffer, n, n, &Common))
PY_ERR(PyExc_ValueError, "not a valid permutation");
}
if (uplo != 'U' && uplo != 'L') err_char("uplo", "'L', 'U'");
if (!(Ac = pack(A, uplo))) return PyErr_NoMemory();
L = CHOL(analyze_p) (Ac, P ? MAT_BUFI(P): NULL, NULL, 0, &Common);
if (Common.status != CHOLMOD_OK){
CHOL(free_factor)(&L, &Common);
CHOL(free_sparse)(&Ac, &Common);
if (Common.status == CHOLMOD_OUT_OF_MEMORY)
return PyErr_NoMemory();
else {
PyErr_SetString(PyExc_ValueError, "symbolic factorization "
"failed");
return NULL;
}
}
CHOL(factorize) (Ac, L, &Common);
CHOL(free_sparse)(&Ac, &Common);
if (Common.status > 0) switch (Common.status) {
case CHOLMOD_NOT_POSDEF:
PyErr_SetObject(PyExc_ArithmeticError, Py_BuildValue("i",
L->minor));
CHOL(free_factor)(&L, &Common);
return NULL;
break;
case CHOLMOD_DSMALL:
/* This never happens unless we change the default value
* of Common.dbound (0.0). */
if (L->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, "");
}
if (L->minor<n) {
CHOL(free_factor)(&L, &Common);
PY_ERR(PyExc_ArithmeticError, "singular matrix");
}
if (!(Bc = create_matrix(B))) {
CHOL(free_factor)(&L, &Common);
return PyErr_NoMemory();
}
Xc = CHOL(spsolve)(0, L, Bc, &Common);
free_matrix(Bc);
CHOL(free_factor)(&L, &Common);
if (Common.status != CHOLMOD_OK){
CHOL(free_sparse)(&Xc, &Common);
if (Common.status == CHOLMOD_OUT_OF_MEMORY)
return PyErr_NoMemory();
else
PY_ERR(PyExc_ValueError, "solve step failed");
}
if (!(X = SpMatrix_New(Xc->nrow, Xc->ncol,
((int_t*)Xc->p)[Xc->ncol], SP_ID(A)))) {
CHOL(free_sparse)(&Xc, &Common);
return PyErr_NoMemory();
}
memcpy(SP_COL(X), (int_t *) Xc->p, (Xc->ncol+1)*sizeof(int_t));
memcpy(SP_ROW(X), (int_t *) Xc->i,
((int_t *) Xc->p)[Xc->ncol]*sizeof(int_t));
memcpy(SP_VAL(X), (double *) 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 = (unsigned char*)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 PyObject* linsolve(PyObject *self, PyObject *args,
PyObject *kwrds)
{
spmatrix *A;
matrix *B, *P=NULL;
int i, n, nnz, oB=0, ldB=0, nrhs=-1;
cholmod_sparse *Ac=NULL;
cholmod_factor *L=NULL;
cholmod_dense *x=NULL, *b=NULL;
void *b_old;
#if PY_MAJOR_VERSION >= 3
int uplo_ = 'L';
#endif
char uplo='L';
char *kwlist[] = {"A", "B", "p", "uplo", "nrhs", "ldB", "offsetB",
NULL};
if (!set_options()) return NULL;
#if PY_MAJOR_VERSION >= 3
if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OO|OCiii", kwlist,
&A, &B, &P, &uplo_, &nrhs, &ldB, &oB)) return NULL;
uplo = (char) uplo_;
#else
if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OO|Ociii", kwlist,
&A, &B, &P, &uplo, &nrhs, &ldB, &oB)) return NULL;
#endif
if (!SpMatrix_Check(A) || SP_NROWS(A) != SP_NCOLS(A))
PY_ERR_TYPE("A is not a sparse matrix");
n = SP_NROWS(A);
nnz = SP_NNZ(A);
if (!Matrix_Check(B) || MAT_ID(B) != SP_ID(A))
PY_ERR_TYPE("B must be a dense matrix of the same numerical "
"type as A");
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");
if (P) {
if (!Matrix_Check(P) || MAT_ID(P) != INT) err_int_mtrx("p");
if (MAT_LGT(P) != n) err_buf_len("p");
if (!CHOL(check_perm)(P->buffer, n, n, &Common))
PY_ERR(PyExc_ValueError, "not a valid permutation");
}
if (uplo != 'U' && uplo != 'L') err_char("uplo", "'L', 'U'");
if (!(Ac = pack(A, uplo))) return PyErr_NoMemory();
L = CHOL(analyze_p)(Ac, P ? MAT_BUFI(P): NULL, NULL, 0, &Common);
if (Common.status != CHOLMOD_OK){
free_matrix(Ac);
CHOL(free_sparse)(&Ac, &Common);
CHOL(free_factor)(&L, &Common);
if (Common.status == CHOLMOD_OUT_OF_MEMORY)
return PyErr_NoMemory();
else {
PyErr_SetString(PyExc_ValueError, "symbolic factorization "
"failed");
return NULL;
}
}
CHOL(factorize) (Ac, L, &Common);
CHOL(free_sparse)(&Ac, &Common);
if (Common.status < 0) {
CHOL(free_factor)(&L, &Common);
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", L->minor));
CHOL(free_factor)(&L, &Common);
return NULL;
break;
case CHOLMOD_DSMALL:
/* This never happens unless we change the default value
* of Common.dbound (0.0). */
if (L->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, "");
}
if (L->minor<n) {
CHOL(free_factor)(&L, &Common);
PY_ERR(PyExc_ArithmeticError, "singular matrix");
}
b = CHOL(allocate_dense)(n, 1, n, (MAT_ID(B) == DOUBLE ?
CHOLMOD_REAL : CHOLMOD_COMPLEX) , &Common);
if (Common.status == CHOLMOD_OUT_OF_MEMORY) {
CHOL(free_factor)(&L, &Common);
CHOL(free_dense)(&b, &Common);
return PyErr_NoMemory();
}
b_old = b->x;
for (i=0; i<nrhs; i++) {
b->x = (unsigned char*)MAT_BUF(B) + (i*ldB + oB)*E_SIZE[MAT_ID(B)];
x = CHOL(solve) (CHOLMOD_A, L, b, &Common);
if (Common.status != CHOLMOD_OK){
PyErr_SetString(PyExc_ValueError, "solve step failed");
CHOL(free_factor)(&L, &Common);
b->x = b_old;
CHOL(free_dense)(&b, &Common);
CHOL(free_dense)(&x, &Common);
return NULL;
}
memcpy(b->x, x->x, SP_NROWS(A)*E_SIZE[MAT_ID(B)]);
CHOL(free_dense)(&x, &Common);
}
b->x = b_old;
CHOL(free_dense)(&b, &Common);
CHOL(free_factor)(&L, &Common);
return Py_BuildValue("");
}
static PyObject* symbolic(PyObject *self, PyObject *args,
PyObject *kwrds)
{
spmatrix *A;
cholmod_sparse *Ac = NULL;
cholmod_factor *L;
matrix *P=NULL;
#if PY_MAJOR_VERSION >= 3
int uplo_='L';
#endif
char uplo='L';
int n;
char *kwlist[] = {"A", "p", "uplo", NULL};
if (!set_options()) return NULL;
#if PY_MAJOR_VERSION >= 3
if (!PyArg_ParseTupleAndKeywords(args, kwrds, "O|OC", kwlist, &A,
&P, &uplo_)) return NULL;
uplo = (char) uplo_;
#else
if (!PyArg_ParseTupleAndKeywords(args, kwrds, "O|Oc", kwlist, &A,
&P, &uplo)) return NULL;
#endif
if (!SpMatrix_Check(A) || SP_NROWS(A) != SP_NCOLS(A))
PY_ERR_TYPE("A is not a square sparse matrix");
n = SP_NROWS(A);
if (P) {
if (!Matrix_Check(P) || MAT_ID(P) != INT) err_int_mtrx("p");
if (MAT_LGT(P) != n) err_buf_len("p");
if (!CHOL(check_perm)(P->buffer, n, n, &Common))
PY_ERR(PyExc_ValueError, "p is not a valid permutation");
}
if (uplo != 'U' && uplo != 'L') err_char("uplo", "'L', 'U'");
if (!(Ac = pack(A, uplo))) return PyErr_NoMemory();
L = CHOL(analyze_p)(Ac, P ? MAT_BUFI(P): NULL, NULL, 0, &Common);
CHOL(free_sparse)(&Ac, &Common);
if (Common.status != CHOLMOD_OK){
if (Common.status == CHOLMOD_OUT_OF_MEMORY)
return PyErr_NoMemory();
else{
PyErr_SetString(PyExc_ValueError, "symbolic factorization "
"failed");
return NULL;
}
}
#if PY_MAJOR_VERSION >= 3
return (PyObject *) PyCapsule_New((void *) L, SP_ID(A)==DOUBLE ?
(uplo == 'L' ? "CHOLMOD FACTOR D L" : "CHOLMOD FACTOR D U") :
(uplo == 'L' ? "CHOLMOD FACTOR Z L" : "CHOLMOD FACTOR Z U"),
(PyCapsule_Destructor) &cvxopt_free_cholmod_factor);
#else
return (PyObject *) PyCObject_FromVoidPtrAndDesc((void *) L,
SP_ID(A)==DOUBLE ?
(uplo == 'L' ? "CHOLMOD FACTOR D L" : "CHOLMOD FACTOR D U") :
(uplo == 'L' ? "CHOLMOD FACTOR Z L" : "CHOLMOD FACTOR Z U"),
cvxopt_free_cholmod_factor);
#endif
}