summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat (limited to 'dev-python/cvxopt/files/cvxopt-1.1.6-glpk.patch')
-rw-r--r--dev-python/cvxopt/files/cvxopt-1.1.6-glpk.patch889
1 files changed, 889 insertions, 0 deletions
diff --git a/dev-python/cvxopt/files/cvxopt-1.1.6-glpk.patch b/dev-python/cvxopt/files/cvxopt-1.1.6-glpk.patch
new file mode 100644
index 00000000000..2887ccd0220
--- /dev/null
+++ b/dev-python/cvxopt/files/cvxopt-1.1.6-glpk.patch
@@ -0,0 +1,889 @@
+--- src/C/glpk.c.orig 2013-07-31 12:05:27.089955661 -0600
++++ src/C/glpk.c 2013-07-31 12:13:40.702115730 -0600
+@@ -22,6 +22,8 @@
+ #include "cvxopt.h"
+ #include "misc.h"
+ #include "glpk.h"
++#include <float.h>
++#include <limits.h>
+
+ PyDoc_STRVAR(glpk__doc__,
+ "Interface to the simplex and mixed integer LP algorithms in GLPK.\n\n"
+@@ -36,62 +38,15 @@ PyDoc_STRVAR(glpk__doc__,
+
+ static PyObject *glpk_module;
+
+-typedef struct {
+- char name[20];
+- int idx;
+- char type;
+-} param_tuple;
+-
+-static const param_tuple GLPK_PARAM_LIST[] = {
+- {"LPX_K_MSGLEV", LPX_K_MSGLEV, 'i'},
+- {"LPX_K_SCALE", LPX_K_SCALE, 'i'},
+- {"LPX_K_DUAL", LPX_K_DUAL, 'i'},
+- {"LPX_K_PRICE", LPX_K_PRICE, 'i'},
+- {"LPX_K_RELAX", LPX_K_RELAX, 'f'},
+- {"LPX_K_TOLBND", LPX_K_TOLBND, 'f'},
+- {"LPX_K_TOLDJ", LPX_K_TOLDJ, 'f'},
+- {"LPX_K_TOLPIV", LPX_K_TOLPIV, 'f'},
+- {"LPX_K_ROUND", LPX_K_ROUND, 'i'},
+- {"LPX_K_OBJLL", LPX_K_OBJLL, 'f'},
+- {"LPX_K_OBJUL", LPX_K_OBJUL, 'f'},
+- {"LPX_K_ITLIM", LPX_K_ITLIM, 'i'},
+- {"LPX_K_ITCNT", LPX_K_ITCNT, 'i'},
+- {"LPX_K_TMLIM", LPX_K_TMLIM, 'f'},
+- {"LPX_K_OUTFRQ", LPX_K_OUTFRQ, 'i'},
+- {"LPX_K_OUTDLY", LPX_K_OUTDLY, 'f'},
+- {"LPX_K_BRANCH", LPX_K_BRANCH, 'i'},
+- {"LPX_K_BTRACK", LPX_K_BTRACK, 'i'},
+- {"LPX_K_TOLINT", LPX_K_TOLINT, 'f'},
+- {"LPX_K_TOLOBJ", LPX_K_TOLOBJ, 'f'},
+- {"LPX_K_MPSINFO", LPX_K_MPSINFO, 'i'},
+- {"LPX_K_MPSOBJ", LPX_K_MPSOBJ, 'i'},
+- {"LPX_K_MPSORIG", LPX_K_MPSORIG, 'i'},
+- {"LPX_K_MPSWIDE", LPX_K_MPSWIDE, 'i'},
+- {"LPX_K_MPSFREE", LPX_K_MPSFREE, 'i'},
+- {"LPX_K_MPSSKIP", LPX_K_MPSSKIP, 'i'},
+- {"LPX_K_LPTORIG", LPX_K_LPTORIG, 'i'},
+- {"LPX_K_PRESOL", LPX_K_PRESOL, 'i'},
+-}; /* 28 paramaters */
+-
+-
+ #if PY_MAJOR_VERSION >= 3
+-static int get_param_idx(const char *str, int *idx, char *type)
++#define PYINT_CHECK(value) PyLong_Check(value)
++#define PYINT_AS_LONG(value) PyLong_AS_LONG(value)
++#define PYSTRING_FROMSTRING(str) PyUnicode_FromString(str)
+ #else
+-static int get_param_idx(char *str, int *idx, char *type)
++#define PYINT_CHECK(value) PyInt_Check(value)
++#define PYINT_AS_LONG(value) PyInt_AS_LONG(value)
++#define PYSTRING_FROMSTRING(str) PyString_FromString(str)
+ #endif
+-{
+- int i;
+-
+- for (i=0; i<28; i++) {
+- if (!strcmp(GLPK_PARAM_LIST[i].name, str)) {
+- *idx = GLPK_PARAM_LIST[i].idx;
+- *type = GLPK_PARAM_LIST[i].type;
+- return 1;
+- }
+- }
+- return 0;
+-}
+-
+
+ static char doc_simplex[] =
+ "Solves a linear program using GLPK.\n\n"
+@@ -127,11 +82,12 @@ static PyObject *simplex(PyObject *self,
+ {
+ matrix *c, *h, *b=NULL, *x=NULL, *z=NULL, *y=NULL;
+ PyObject *G, *A=NULL, *t=NULL, *param, *key, *value;
+- LPX *lp;
+- int m, n, p, i, j, k, nnz, nnzmax, *rn=NULL, *cn=NULL, param_id;
++ glp_prob *lp;
++ glp_smcp smcp;
++ int m, n, p, i, j, k, nnz, nnzmax, *rn=NULL, *cn=NULL;
+ int_t pos=0;
+ double *a=NULL, val;
+- char param_type, err_str[100];
++ char err_str[100];
+ #if PY_MAJOR_VERSION >= 3
+ const char *keystr;
+ #else
+@@ -183,18 +139,18 @@ static PyObject *simplex(PyObject *self,
+ return NULL;
+ }
+
+- lp = lpx_create_prob();
+- lpx_add_rows(lp, m+p);
+- lpx_add_cols(lp, n);
++ lp = glp_create_prob();
++ glp_add_rows(lp, m+p);
++ glp_add_cols(lp, n);
+
+ for (i=0; i<n; i++){
+- lpx_set_obj_coef(lp, i+1, MAT_BUFD(c)[i]);
+- lpx_set_col_bnds(lp, i+1, LPX_FR, 0.0, 0.0);
++ 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++)
+- lpx_set_row_bnds(lp, i+1, LPX_UP, 0.0, MAT_BUFD(h)[i]);
++ glp_set_row_bnds(lp, i+1, GLP_UP, 0.0, MAT_BUFD(h)[i]);
+ for (i=0; i<p; i++)
+- lpx_set_row_bnds(lp, i+m+1, LPX_FX, MAT_BUFD(b)[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 ) +
+@@ -203,7 +159,7 @@ static PyObject *simplex(PyObject *self,
+ rn = (int *) calloc(nnzmax+1, sizeof(int));
+ cn = (int *) calloc(nnzmax+1, sizeof(int));
+ if (!a || !rn || !cn){
+- free(a); free(rn); free(cn); lpx_delete_prob(lp);
++ free(a); free(rn); free(cn); glp_delete_prob(lp);
+ return PyErr_NoMemory();
+ }
+
+@@ -242,84 +198,155 @@ static PyObject *simplex(PyObject *self,
+ nnz++;
+ }
+
+- lpx_load_matrix(lp, nnz, rn, cn, a);
++ glp_load_matrix(lp, nnz, rn, cn, a);
+ free(rn); free(cn); free(a);
+
+ if (!(t = PyTuple_New(A ? 4 : 3))){
+- lpx_delete_prob(lp);
++ glp_delete_prob(lp);
+ return PyErr_NoMemory();
+ }
+
+ if (!(param = PyObject_GetAttrString(glpk_module, "options"))
+ || !PyDict_Check(param)){
+- lpx_delete_prob(lp);
++ glp_delete_prob(lp);
+ PyErr_SetString(PyExc_AttributeError,
+ "missing glpk.options dictionary");
+ return NULL;
+ }
+
+- while (PyDict_Next(param, &pos, &key, &value))
++ glp_init_smcp(&smcp);
++ while (PyDict_Next(param, &pos, &key, &value)){
+ #if PY_MAJOR_VERSION >= 3
+- if ((PyUnicode_Check(key)) &&
+- get_param_idx(_PyUnicode_AsString(key), &param_id,
+- &param_type)){
++ if (PyUnicode_Check(key)){
+ keystr = _PyUnicode_AsString(key);
+ #else
+- if ((keystr = PyString_AsString(key)) && get_param_idx(keystr,
+- &param_id, &param_type)){
+-#endif
+- if (param_type == 'i'){
+-#if PY_MAJOR_VERSION >= 3
+- if (!PyLong_Check(value)){
+-#else
+- if (!PyInt_Check(value)){
+-#endif
+- sprintf(err_str, "invalid value for integer "
+- "GLPK parameter: %-.20s", keystr);
+- PyErr_SetString(PyExc_ValueError, err_str);
+- lpx_delete_prob(lp);
+- Py_DECREF(param);
+- return NULL;
+- }
+- if (!strcmp("LPX_K_PRESOL", keystr) &&
+-#if PY_MAJOR_VERSION >= 3
+- PyLong_AS_LONG(value) != 1){
+-#else
+- PyInt_AS_LONG(value) != 1){
++ if ((keystr = PyString_AsString(key))){
+ #endif
++ if (!strcmp("LPX_K_MSGLEV", keystr)){
++ switch (PYINT_AS_LONG(value)){
++ case 0: smcp.msg_lev = GLP_MSG_OFF; break;
++ case 1: smcp.msg_lev = GLP_MSG_ERR; break;
++ case 2: smcp.msg_lev = GLP_MSG_ON; break;
++ case 3: smcp.msg_lev = GLP_MSG_ALL; break;
++ default: goto error;
++ }
++ } else if (!strcmp("LPX_K_SCALE", keystr)){
++ switch(PYINT_AS_LONG(value)){
++ case 0: glp_unscale_prob(lp); break;
++ case 1: glp_scale_prob(lp, GLP_SF_EQ); break;
++ case 2: glp_scale_prob(lp, GLP_SF_GM); break;
++ case 3: glp_scale_prob(lp, GLP_SF_GM | GLP_SF_EQ); break;
++ default: goto error;
++ }
++ } else if (!strcmp("LPX_K_DUAL", keystr)){
++ switch(PYINT_AS_LONG(value)){
++ case 0: smcp.meth = GLP_PRIMAL; break;
++ case 1: smcp.meth = GLP_DUAL; break;
++ default: goto error;
++ }
++ } else if (!strcmp("LPX_K_PRICE", keystr)){
++ switch(PYINT_AS_LONG(value)){
++ case 0: smcp.pricing = GLP_PT_STD; break;
++ case 1: smcp.pricing = GLP_PT_PSE; break;
++ default: goto error;
++ }
++ } else if (!strcmp("LPX_K_RELAX", keystr)){
++ double relax = PyFloat_AsDouble(value);
++ if (relax < 0.0 || relax > 1.0)
++ goto error;
++ smcp.r_test = (relax == 0.0) ? GLP_RT_STD : GLP_RT_HAR;
++ } else if (!strcmp("LPX_K_TOLBND", keystr)){
++ smcp.tol_bnd = PyFloat_AsDouble(value);
++ if (smcp.tol_bnd < DBL_EPSILON || smcp.tol_bnd > 0.001)
++ goto error;
++ } else if (!strcmp("LPX_K_TOLDJ", keystr)){
++ smcp.tol_dj = PyFloat_AsDouble(value);
++ if (smcp.tol_dj < DBL_EPSILON || smcp.tol_dj > 0.001)
++ goto error;
++ } else if (!strcmp("LPX_K_TOLPIV", keystr)){
++ smcp.tol_piv = PyFloat_AsDouble(value);
++ if (smcp.tol_piv < DBL_EPSILON || smcp.tol_piv > 0.001)
++ goto error;
++ } else if (!strcmp("LPX_K_ROUND", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_OBJLL", keystr)){
++ smcp.obj_ll = PyFloat_AsDouble(value);
++ } else if (!strcmp("LPX_K_OBJUL", keystr)){
++ smcp.obj_ul = PyFloat_AsDouble(value);
++ } else if (!strcmp("LPX_K_ITLIM", keystr)){
++ smcp.it_lim = PYINT_AS_LONG(value);
++ if (smcp.it_lim < 0)
++ smcp.it_lim = INT_MAX;
++ } else if (!strcmp("LPX_K_ITCNT", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_TMLIM", keystr)){
++ smcp.tm_lim = (int)(PyFloat_AsDouble(value) * 1000.0);
++ if (smcp.tm_lim < 0)
++ smcp.tm_lim = INT_MAX;
++ } else if (!strcmp("LPX_K_OUTFRQ", keystr)){
++ smcp.out_frq = PYINT_AS_LONG(value);
++ if (smcp.out_frq <= 0)
++ goto error;
++ } else if (!strcmp("LPX_K_OUTDLY", keystr)){
++ smcp.out_dly = (int)(PyFloat_AsDouble(value) * 1000.0);
++ } else if (!strcmp("LPX_K_BRANCH", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_BTRACK", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_TOLINT", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_TOLOBJ", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_MPSINFO", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_MPSOBJ", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_MPSORIG", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_MPSWIDE", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_MPSFREE", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_MPSSKIP", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_LPTORIG", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_PRESOL", keystr)){
++ if (PYINT_AS_LONG(value) != 1)
+ PyErr_Warn(PyExc_UserWarning, "ignoring value of "
+ "GLPK parameter 'LPX_K_PRESOL'");
++ } else if (!strcmp("LPX_K_BINARIZE", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_USECUTS", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_BFTYPE", keystr)){
++ glp_bfcp bfcp;
++
++ glp_get_bfcp(lp, &bfcp);
++ switch(PYINT_AS_LONG(value)){
++ case 1: bfcp.type = GLP_BF_FT; break;
++ case 2: bfcp.type = GLP_BF_BG; break;
++ case 3: bfcp.type = GLP_BF_GR; break;
++ default: goto error;
+ }
+- else lpx_set_int_parm(lp, param_id,
+-#if PY_MAJOR_VERSION >= 3
+- PyLong_AS_LONG(value));
+-#else
+- PyInt_AS_LONG(value));
+-#endif
+- }
+- else {
+-#if PY_MAJOR_VERSION >= 3
+- if (!PyLong_Check(value) && !PyFloat_Check(value)){
+-#else
+- if (!PyInt_Check(value) && !PyFloat_Check(value)){
+-#endif
+- sprintf(err_str, "invalid value for floating point "
+- "GLPK parameter: %-.20s", keystr);
+- PyErr_SetString(PyExc_ValueError, err_str);
+- lpx_delete_prob(lp);
+- Py_DECREF(param);
+- return NULL;
+- }
+- lpx_set_real_parm(lp, param_id,
+- PyFloat_AsDouble(value));
++ glp_set_bfcp(lp, &bfcp);
++ } else if (!strcmp("LPX_K_MIPGAP", keystr)){
++ /* Ignored */
++ } else {
++ sprintf(err_str, "unknown GLPK parameter: %-.20s", keystr);
++ PyErr_SetString(PyExc_ValueError, err_str);
++ glp_delete_prob(lp);
++ Py_DECREF(param);
++ return NULL;
+ }
++ }
+ }
+- lpx_set_int_parm(lp, LPX_K_PRESOL, 1);
++ smcp.presolve = GLP_ON;
+ Py_DECREF(param);
+
+- switch (lpx_simplex(lp)){
++ switch (glp_simplex(lp, &smcp)){
+
+- case LPX_E_OK:
++ case 0:
+
+ x = (matrix *) Matrix_New(n,1,DOUBLE);
+ z = (matrix *) Matrix_New(m,1,DOUBLE);
+@@ -329,71 +356,61 @@ static PyObject *simplex(PyObject *self,
+ Py_XDECREF(z);
+ Py_XDECREF(y);
+ Py_XDECREF(t);
+- lpx_delete_prob(lp);
++ glp_delete_prob(lp);
+ return PyErr_NoMemory();
+ }
+
+- PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+- PyUnicode_FromString("optimal"));
+-#else
+- PyString_FromString("optimal"));
+-#endif
++ PyTuple_SET_ITEM(t, 0, (PyObject *)PYSTRING_FROMSTRING("optimal"));
+
+ for (i=0; i<n; i++)
+- MAT_BUFD(x)[i] = lpx_get_col_prim(lp, i+1);
++ 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] = -lpx_get_row_dual(lp, i+1);
++ 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] = -lpx_get_row_dual(lp, m+i+1);
++ MAT_BUFD(y)[i] = -glp_get_row_dual(lp, m+i+1);
+ PyTuple_SET_ITEM(t, 3, (PyObject *) y);
+ }
+
+- lpx_delete_prob(lp);
++ glp_delete_prob(lp);
+ return (PyObject *) t;
+
+- case LPX_E_NOPFS:
++ case GLP_ENOPFS:
+
+ PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+- PyUnicode_FromString("primal infeasible"));
+-#else
+- PyString_FromString("primal infeasible"));
+-#endif
++ PYSTRING_FROMSTRING("primal infeasible"));
+ break;
+
+- case LPX_E_NODFS:
++ case GLP_ENODFS:
+
+ PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+- PyUnicode_FromString("dual infeasible"));
+-#else
+- PyString_FromString("dual infeasible"));
+-#endif
++ PYSTRING_FROMSTRING("dual infeasible"));
+ break;
+
+ default:
+
+ PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+- PyUnicode_FromString("unknown"));
+-#else
+- PyString_FromString("unknown"));
+-#endif
++ PYSTRING_FROMSTRING("unknown"));
+ }
+
+- lpx_delete_prob(lp);
++ 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;
++
++error:
++ sprintf(err_str, "invalid value for GLPK parameter: %-.20s", keystr);
++ PyErr_SetString(PyExc_ValueError, err_str);
++ glp_delete_prob(lp);
++ Py_DECREF(param);
++ return NULL;
+ }
+
+
+@@ -428,11 +445,12 @@ static PyObject *integer(PyObject *self,
+ matrix *c, *h, *b=NULL, *x=NULL;
+ PyObject *G, *A=NULL, *IntSet=NULL, *BinSet = NULL;
+ PyObject *t=NULL, *param, *key, *value;
+- LPX *lp;
+- int m, n, p, i, j, k, nnz, nnzmax, *rn=NULL, *cn=NULL, param_id;
++ glp_prob *lp;
++ glp_iocp iocp;
++ int m, n, p, i, j, k, nnz, nnzmax, *rn=NULL, *cn=NULL;
+ int_t pos=0;
+ double *a=NULL, val;
+- char param_type, err_str[100];
++ char err_str[100];
+ #if PY_MAJOR_VERSION >= 3
+ const char *keystr;
+ #else
+@@ -490,18 +508,18 @@ static PyObject *integer(PyObject *self,
+ if ((BinSet) && (!PyAnySet_Check(BinSet)))
+ PY_ERR_TYPE("invalid binary index set");
+
+- lp = lpx_create_prob();
+- lpx_add_rows(lp, m+p);
+- lpx_add_cols(lp, n);
++ lp = glp_create_prob();
++ glp_add_rows(lp, m+p);
++ glp_add_cols(lp, n);
+
+ for (i=0; i<n; i++){
+- lpx_set_obj_coef(lp, i+1, MAT_BUFD(c)[i]);
+- lpx_set_col_bnds(lp, i+1, LPX_FR, 0.0, 0.0);
++ 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++)
+- lpx_set_row_bnds(lp, i+1, LPX_UP, 0.0, MAT_BUFD(h)[i]);
++ glp_set_row_bnds(lp, i+1, GLP_UP, 0.0, MAT_BUFD(h)[i]);
+ for (i=0; i<p; i++)
+- lpx_set_row_bnds(lp, i+m+1, LPX_FX, MAT_BUFD(b)[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 ) +
+@@ -510,7 +528,7 @@ static PyObject *integer(PyObject *self,
+ rn = (int *) calloc(nnzmax+1, sizeof(int));
+ cn = (int *) calloc(nnzmax+1, sizeof(int));
+ if (!a || !rn || !cn){
+- free(a); free(rn); free(cn); lpx_delete_prob(lp);
++ free(a); free(rn); free(cn); glp_delete_prob(lp);
+ return PyErr_NoMemory();
+ }
+
+@@ -549,77 +567,152 @@ static PyObject *integer(PyObject *self,
+ nnz++;
+ }
+
+- lpx_load_matrix(lp, nnz, rn, cn, a);
++ glp_load_matrix(lp, nnz, rn, cn, a);
+ free(rn); free(cn); free(a);
+
+ if (!(t = PyTuple_New(2))) {
+- lpx_delete_prob(lp);
++ glp_delete_prob(lp);
+ return PyErr_NoMemory();
+ }
+
+ if (!(param = PyObject_GetAttrString(glpk_module, "options"))
+ || !PyDict_Check(param)){
+- lpx_delete_prob(lp);
++ glp_delete_prob(lp);
+ PyErr_SetString(PyExc_AttributeError,
+ "missing glpk.options dictionary");
+ return NULL;
+ }
+
+- while (PyDict_Next(param, &pos, &key, &value))
+-#if PY_MAJOR_VERSION >= 3
+- if ((PyUnicode_Check(key)) && (keystr = PyUnicode_AS_DATA(key))
+- && get_param_idx(keystr, &param_id, &param_type)){
+-#else
+- if ((keystr = PyString_AsString(key)) && get_param_idx(keystr,
+- &param_id, &param_type)){
+-#endif
+- if (param_type == 'i'){
+-#if PY_MAJOR_VERSION >= 3
+- if (!PyLong_Check(value)){
+-#else
+- if (!PyInt_Check(value)){
+-#endif
+- sprintf(err_str, "invalid value for integer "
+- "GLPK parameter: %-.20s", keystr);
+- PyErr_SetString(PyExc_ValueError, err_str);
+- lpx_delete_prob(lp);
+- Py_DECREF(param);
+- return NULL;
+- }
+- if (!strcmp("LPX_K_PRESOL", keystr) &&
++ glp_init_iocp(&iocp);
++ while (PyDict_Next(param, &pos, &key, &value)) {
+ #if PY_MAJOR_VERSION >= 3
+- PyLong_AS_LONG(value) != 1){
++ if ((PyUnicode_Check(key)) && (keystr = PyUnicode_AS_DATA(key))){
+ #else
+- PyInt_AS_LONG(value) != 1){
++ if ((keystr = PyString_AsString(key))){
+ #endif
++ if (!strcmp("LPX_K_MSGLEV", keystr)){
++ switch (PYINT_AS_LONG(value)){
++ case 0: iocp.msg_lev = GLP_MSG_OFF; break;
++ case 1: iocp.msg_lev = GLP_MSG_ERR; break;
++ case 2: iocp.msg_lev = GLP_MSG_ON; break;
++ case 3: iocp.msg_lev = GLP_MSG_ALL; break;
++ default: goto error;
++ }
++ } else if (!strcmp("LPX_K_SCALE", keystr)){
++ switch(PYINT_AS_LONG(value)){
++ case 0: glp_unscale_prob(lp); break;
++ case 1: glp_scale_prob(lp, GLP_SF_EQ); break;
++ case 2: glp_scale_prob(lp, GLP_SF_GM); break;
++ case 3: glp_scale_prob(lp, GLP_SF_GM | GLP_SF_EQ); break;
++ default: goto error;
++ }
++ } else if (!strcmp("LPX_K_DUAL", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_PRICE", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_RELAX", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_TOLBND", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_TOLDJ", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_TOLPIV", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_ROUND", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_OBJLL", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_OBJUL", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_ITLIM", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_ITCNT", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_TMLIM", keystr)){
++ iocp.tm_lim = (int)(PyFloat_AsDouble(value) * 1000.0);
++ if (iocp.tm_lim < 0)
++ iocp.tm_lim = INT_MAX;
++ } else if (!strcmp("LPX_K_OUTFRQ", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_OUTDLY", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_BRANCH", keystr)){
++ switch(PYINT_AS_LONG(value)){
++ case 0: iocp.br_tech = GLP_BR_FFV; break;
++ case 1: iocp.br_tech = GLP_BR_LFV; break;
++ case 2: iocp.br_tech = GLP_BR_DTH; break;
++ case 3: iocp.br_tech = GLP_BR_MFV; break;
++ default: goto error;
++ }
++ } else if (!strcmp("LPX_K_BTRACK", keystr)){
++ switch(PYINT_AS_LONG(value)){
++ case 0: iocp.bt_tech = GLP_BT_DFS; break;
++ case 1: iocp.bt_tech = GLP_BT_BFS; break;
++ case 2: iocp.bt_tech = GLP_BT_BPH; break;
++ case 3: iocp.bt_tech = GLP_BT_BLB; break;
++ default: goto error;
++ }
++ } else if (!strcmp("LPX_K_TOLINT", keystr)){
++ iocp.tol_int = PyFloat_AsDouble(value);
++ if (iocp.tol_int < DBL_EPSILON || iocp.tol_int > 0.001)
++ goto error;
++ } else if (!strcmp("LPX_K_TOLOBJ", keystr)){
++ iocp.tol_obj = PyFloat_AsDouble(value);
++ if (iocp.tol_obj < DBL_EPSILON || iocp.tol_obj > 0.001)
++ goto error;
++ } else if (!strcmp("LPX_K_MPSINFO", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_MPSOBJ", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_MPSORIG", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_MPSWIDE", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_MPSFREE", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_MPSSKIP", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_LPTORIG", keystr)){
++ /* Ignored */
++ } else if (!strcmp("LPX_K_PRESOL", keystr)){
++ if (PYINT_AS_LONG(value) != 1)
+ PyErr_Warn(PyExc_UserWarning, "ignoring value of "
+ "GLPK parameter 'LPX_K_PRESOL'");
++ } else if (!strcmp("LPX_K_BINARIZE", keystr)){
++ iocp.binarize = (PYINT_AS_LONG(value) == 0) ? GLP_OFF : GLP_ON;
++ } else if (!strcmp("LPX_K_USECUTS", keystr)){
++ int cuts = PYINT_AS_LONG(value);
++ if (cuts & ~0xFF)
++ goto error;
++ iocp.cov_cuts = (cuts & 1) ? GLP_ON : GLP_OFF;
++ iocp.clq_cuts = (cuts & 2) ? GLP_ON : GLP_OFF;
++ iocp.gmi_cuts = (cuts & 4) ? GLP_ON : GLP_OFF;
++ iocp.mir_cuts = (cuts & 8) ? GLP_ON : GLP_OFF;
++ } else if (!strcmp("LPX_K_BFTYPE", keystr)){
++ glp_bfcp bfcp;
++
++ glp_get_bfcp(lp, &bfcp);
++ switch(PYINT_AS_LONG(value)){
++ case 1: bfcp.type = GLP_BF_FT; break;
++ case 2: bfcp.type = GLP_BF_BG; break;
++ case 3: bfcp.type = GLP_BF_GR; break;
++ default: goto error;
+ }
+- else
+-#if PY_MAJOR_VERSION >= 3
+- lpx_set_int_parm(lp, param_id, PyLong_AS_LONG(value));
+-#else
+- lpx_set_int_parm(lp, param_id, PyInt_AS_LONG(value));
+-#endif
+- }
+- else {
+-#if PY_MAJOR_VERSION >= 3
+- if (!PyLong_Check(value) && !PyFloat_Check(value)){
+-#else
+- if (!PyInt_Check(value) && !PyFloat_Check(value)){
+-#endif
+- sprintf(err_str, "invalid value for floating point "
+- "GLPK parameter: %-.20s", keystr);
+- PyErr_SetString(PyExc_ValueError, err_str);
+- lpx_delete_prob(lp);
+- Py_DECREF(param);
+- return NULL;
+- }
+- lpx_set_real_parm(lp, param_id,
+- PyFloat_AsDouble(value));
++ glp_set_bfcp(lp, &bfcp);
++ } else if (!strcmp("LPX_K_MIPGAP", keystr)){
++ iocp.mip_gap = PyFloat_AsDouble(value);
++ if (iocp.mip_gap < 0.0)
++ goto error;
++ } else {
++ sprintf(err_str, "unknown GLPK parameter: %-.20s", keystr);
++ PyErr_SetString(PyExc_ValueError, err_str);
++ glp_delete_prob(lp);
++ Py_DECREF(param);
++ return NULL;
+ }
++ }
+ }
+- lpx_set_int_parm(lp, LPX_K_PRESOL, 1);
++ iocp.presolve = GLP_ON;
+ Py_DECREF(param);
+
+ if (IntSet) {
+@@ -628,22 +721,14 @@ static PyObject *integer(PyObject *self,
+ for (i=0; i<PySet_GET_SIZE(IntSet); i++) {
+
+ PyObject *tmp = PySequence_Fast_GET_ITEM(iter, i);
+-#if PY_MAJOR_VERSION >= 3
+- if (!PyLong_Check(tmp)) {
+-#else
+- if (!PyInt_Check(tmp)) {
+-#endif
+- lpx_delete_prob(lp);
++ if (!PYINT_CHECK(tmp)) {
++ glp_delete_prob(lp);
+ Py_DECREF(iter);
+ PY_ERR_TYPE("non-integer element in I");
+ }
+-#if PY_MAJOR_VERSION >= 3
+- int k = PyLong_AS_LONG(tmp);
+-#else
+- int k = PyInt_AS_LONG(tmp);
+-#endif
++ int k = PYINT_AS_LONG(tmp);
+ if ((k < 0) || (k >= n)) {
+- lpx_delete_prob(lp);
++ glp_delete_prob(lp);
+ Py_DECREF(iter);
+ PY_ERR(PyExc_IndexError, "index element out of range in I");
+ }
+@@ -659,22 +744,14 @@ static PyObject *integer(PyObject *self,
+ for (i=0; i<PySet_GET_SIZE(BinSet); i++) {
+
+ PyObject *tmp = PySequence_Fast_GET_ITEM(iter, i);
+-#if PY_MAJOR_VERSION >= 3
+- if (!PyLong_Check(tmp)) {
+-#else
+- if (!PyInt_Check(tmp)) {
+-#endif
+- lpx_delete_prob(lp);
++ if (!PYINT_CHECK(tmp)) {
++ glp_delete_prob(lp);
+ Py_DECREF(iter);
+ PY_ERR_TYPE("non-binary element in I");
+ }
+-#if PY_MAJOR_VERSION >= 3
+- int k = PyLong_AS_LONG(tmp);
+-#else
+- int k = PyInt_AS_LONG(tmp);
+-#endif
++ int k = PYINT_AS_LONG(tmp);
+ if ((k < 0) || (k >= n)) {
+- lpx_delete_prob(lp);
++ glp_delete_prob(lp);
+ Py_DECREF(iter);
+ PY_ERR(PyExc_IndexError, "index element out of range in B");
+ }
+@@ -686,117 +763,92 @@ static PyObject *integer(PyObject *self,
+ }
+
+
++ switch (glp_intopt(lp, &iocp)){
+
+- switch (lpx_intopt(lp)){
+-
+- case LPX_E_OK:
++ case 0:
+
+ x = (matrix *) Matrix_New(n,1,DOUBLE);
+ if (!x) {
+ Py_XDECREF(t);
+- lpx_delete_prob(lp);
++ glp_delete_prob(lp);
+ return PyErr_NoMemory();
+ }
+- PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+- PyUnicode_FromString("optimal"));
+-#else
+- PyString_FromString("optimal"));
+-#endif
++ PyTuple_SET_ITEM(t, 0, (PyObject *)PYSTRING_FROMSTRING("optimal"));
+
+ for (i=0; i<n; i++)
+- MAT_BUFD(x)[i] = lpx_mip_col_val(lp, i+1);
++ MAT_BUFD(x)[i] = glp_mip_col_val(lp, i+1);
+ PyTuple_SET_ITEM(t, 1, (PyObject *) x);
+
+- lpx_delete_prob(lp);
++ glp_delete_prob(lp);
+ return (PyObject *) t;
+
+- case LPX_E_TMLIM:
++ case GLP_ETMLIM:
+
+ x = (matrix *) Matrix_New(n,1,DOUBLE);
+ if (!x) {
+ Py_XDECREF(t);
+- lpx_delete_prob(lp);
++ glp_delete_prob(lp);
+ return PyErr_NoMemory();
+ }
+ PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+- PyUnicode_FromString("time limit exceeded"));
+-#else
+- PyString_FromString("time limit exceeded"));
+-#endif
++ PYSTRING_FROMSTRING("time limit exceeded"));
+
+ for (i=0; i<n; i++)
+- MAT_BUFD(x)[i] = lpx_mip_col_val(lp, i+1);
++ MAT_BUFD(x)[i] = glp_mip_col_val(lp, i+1);
+ PyTuple_SET_ITEM(t, 1, (PyObject *) x);
+
+- lpx_delete_prob(lp);
++ glp_delete_prob(lp);
+ return (PyObject *) t;
+
+
+- case LPX_E_FAULT:
++ case GLP_EBADB:
++ case GLP_ECOND:
++ case GLP_EBOUND:
+ PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+- PyUnicode_FromString("invalid MIP formulation"));
+-#else
+- PyString_FromString("invalid MIP formulation"));
+-#endif
++ PYSTRING_FROMSTRING("invalid MIP formulation"));
+ break;
+
+- case LPX_E_NOPFS:
++ case GLP_ENOPFS:
+ PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+- PyUnicode_FromString("primal infeasible"));
+-#else
+- PyString_FromString("primal infeasible"));
+-#endif
++ PYSTRING_FROMSTRING("primal infeasible"));
+ break;
+
+- case LPX_E_NODFS:
++ case GLP_ENODFS:
+
+ PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+- PyUnicode_FromString("dual infeasible"));
+-#else
+- PyString_FromString("dual infeasible"));
+-#endif
++ PYSTRING_FROMSTRING("dual infeasible"));
+ break;
+
+- case LPX_E_ITLIM:
++ case GLP_EITLIM:
+
+ PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+- PyUnicode_FromString("maxiters exceeded"));
+-#else
+- PyString_FromString("maxiters exceeded"));
+-#endif
++ PYSTRING_FROMSTRING("maxiters exceeded"));
+ break;
+
+- case LPX_E_SING:
++ case GLP_ESING:
+
+ PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+- PyUnicode_FromString("singular or ill-conditioned basis"));
+-#else
+- PyString_FromString("singular or ill-conditioned basis"));
+-#endif
++ PYSTRING_FROMSTRING("singular or ill-conditioned basis"));
+ break;
+
+
+ default:
+
+ PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+- PyUnicode_FromString("unknown"));
+-#else
+- PyString_FromString("unknown"));
+-#endif
++ PYSTRING_FROMSTRING("unknown"));
+ }
+
+- lpx_delete_prob(lp);
++ glp_delete_prob(lp);
+
+ PyTuple_SET_ITEM(t, 1, Py_BuildValue(""));
+ return (PyObject *) t;
++
++error:
++ sprintf(err_str, "invalid value for GLPK parameter: %-.20s", keystr);
++ PyErr_SetString(PyExc_ValueError, err_str);
++ glp_delete_prob(lp);
++ Py_DECREF(param);
++ return NULL;
+ }
+
+