bicatali 14/03/25 01:17:25 Added: cvxopt-1.1.6-glpk449.patch Log: Fixes for glpk-4.53 (bug #501320) and library dupes (bug #505404). Added more EAPI5 changes (Portage version: 2.2.8-prefix/cvs/Linux x86_64, signed Manifest commit with key 0x13CB1360)
Revision Changes Path 1.1 dev-python/cvxopt/files/cvxopt-1.1.6-glpk449.patch file : http://sources.gentoo.org/viewvc.cgi/gentoo-x86/dev-python/cvxopt/files/cvxopt-1.1.6-glpk449.patch?rev=1.1&view=markup plain: http://sources.gentoo.org/viewvc.cgi/gentoo-x86/dev-python/cvxopt/files/cvxopt-1.1.6-glpk449.patch?rev=1.1&content-type=text/plain Index: cvxopt-1.1.6-glpk449.patch =================================================================== --- src/C/glpk.c.orig 2014-03-24 09:39:39.510214726 -0700 +++ src/C/glpk.c 2014-03-24 09:38:41.251897138 -0700 @@ -23,75 +23,271 @@ #include "misc.h" #include "glpk.h" + PyDoc_STRVAR(glpk__doc__, "Interface to the simplex and mixed integer LP algorithms in GLPK.\n\n" "The GLPK control parameters have the default values listed in \n" - "the GLPK documentation, except for 'LPX_K_PRESOL', which is set\n" + "the GLPK documentation, except for 'presolve', which is set\n" "to 1 and cannot be modified. The other parameters can be\n" - "modified by making an entry in the dictionary glpk.options.\n" - "For example, the command glpk.options['LPX_K_MSGLEV'] = 0 turns\n" - "off the printed output during execution of glpk.simplex().\n" + "modified by passing a smcp or iocp object to the appropriate function\n" + "For example, the commands param = glpk.smcp(msg_lev = 0), or \n" + "param=glpk.smcp(); param.msg_lev=1 turn off the printed output during" + " execution of glpk.simplex().\n" "See the documentation at www.gnu.org/software/glpk/glpk.html for\n" "the list of GLPK control parameters and their default values."); 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 */ +/* Wrappers around the option glpk structs */ +typedef struct{ + PyObject_HEAD + glp_smcp obj; +} pysmcp; +/* Deallocation of smcp object */ +static void smcp_dealloc(pysmcp* self) +{ + Py_TYPE(self)->tp_free((PyObject*)self); +} -#if PY_MAJOR_VERSION >= 3 -static int get_param_idx(const char *str, int *idx, char *type) -#else -static int get_param_idx(char *str, int *idx, char *type) -#endif +/* New smcp method */ +static PyObject * +smcp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { - int i; + pysmcp *self; + self = (pysmcp *)type->tp_alloc(type, 0); + return (PyObject *)self; +} + +/* Initialisation of smcp object */ +static int +smcp_init(pysmcp *self, PyObject *args, PyObject *kwds) +{ + /*static char *kwlist[] = {"number", NULL};*/ + static char *kwlist[] = { "msg_lev", "meth", "pricing", "r_test", "tol_bnd", "tol_dj", "tol_piv", "obj_ll", "obj_ul", "it_lim", "tm_lim", "out_frq", "out_dly", "presolve" }; + glp_init_smcp(&self->obj); + if (! PyArg_ParseTupleAndKeywords(args, kwds, "|iiiidddddiiiii", kwlist, + &self->obj.msg_lev, + &self->obj.meth, + &self->obj.pricing, + &self->obj.r_test, + &self->obj.tol_bnd, + &self->obj.tol_dj, + &self->obj.tol_piv, + &self->obj.obj_ll, + &self->obj.obj_ul, + &self->obj.it_lim, + &self->obj.tm_lim, + &self->obj.out_frq, + &self->obj.out_dly, + &self->obj.presolve)) + return -1; - 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; } +/* smcp members declaration */ +static PyMemberDef smcpMembers[] = { + {"msg_lev", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,msg_lev), 0, "message level: "}, + {"meth", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,meth), 0, "simplex method option: "}, + {"pricing", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,pricing), 0, "pricing technique: "}, + {"r_test", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,r_test), 0, "ratio test technique: "}, + {"tol_bnd", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_smcp,tol_bnd), 0, "spx.tol_bnd "}, + {"tol_dj", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_smcp,tol_dj), 0, "spx.tol_dj "}, + {"tol_piv", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_smcp,tol_piv), 0, "spx.tol_piv "}, + {"obj_ll", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_smcp,obj_ll), 0, "spx.obj_ll "}, + {"obj_ul", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_smcp,obj_ul), 0, "spx.obj_ul "}, + {"it_lim", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,it_lim), 0, "spx.it_lim "}, + {"tm_lim", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,tm_lim), 0, "spx.tm_lim (milliseconds) "}, + {"out_frq", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,out_frq), 0, "spx.out_frq "}, + {"out_dly", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,out_dly), 0, "spx.out_dly (milliseconds) "}, + {"presolve", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,presolve), 0, "enable/disable using LP presolver "}, +}; + +static PyTypeObject smcp_t = { + PyVarObject_HEAD_INIT(NULL, 0) + "glpk.smcp", /* tp_name */ + sizeof(pysmcp), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)smcp_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | + Py_TPFLAGS_BASETYPE, /* tp_flags */ + "simplex method control parameters", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + smcpMembers, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)smcp_init, /* tp_init */ + 0, /* tp_alloc */ + smcp_new, /* tp_new */ +}; + + +/* Wrappers around the option glpk structs */ +typedef struct{ + PyObject_HEAD + glp_iocp obj; +} pyiocp; + +/* Deallocation of iocp object */ +static void iocp_dealloc(pysmcp* self) +{ + Py_TYPE(self)->tp_free((PyObject*)self); +} + +/* New iocp method */ +static PyObject * +iocp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + pyiocp *self; + self = (pyiocp *)type->tp_alloc(type, 0); + return (PyObject *)self; +} + +/* Initialisation of iocp object */ +static int +iocp_init(pyiocp *self, PyObject *args, PyObject *kwds) +{ + /*static char *kwlist[] = {"number", NULL};*/ + static char *kwlist[] = { "msg_lev", "br_tech", "bt_tech", "tol_int", "tol_obj", "tm_lim", "out_frq", "out_dly", "cb_size", "pp_tech", "mip_gap", "mir_cuts", "gmi_cuts", "cov_cuts", "clq_cuts", "presolve", "binarize", "fp_heur", "ps_heur", "ps_tm_lim", "use_sol", "save_sol", "alien",NULL}; + glp_init_iocp(&self->obj); + + if (! PyArg_ParseTupleAndKeywords(args, kwds, "|iiiddiiiiidiiiiiiiiiisi", kwlist, + &self->obj.msg_lev, + &self->obj.br_tech, + &self->obj.bt_tech, + &self->obj.tol_int, + &self->obj.tol_obj, + &self->obj.tm_lim, + &self->obj.out_frq, + &self->obj.out_dly, + &self->obj.cb_size, + &self->obj.pp_tech, + &self->obj.mip_gap, + &self->obj.mir_cuts, + &self->obj.gmi_cuts, + &self->obj.cov_cuts, + &self->obj.clq_cuts, + &self->obj.presolve, + &self->obj.binarize, + &self->obj.fp_heur, + &self->obj.ps_heur, + &self->obj.ps_tm_lim, + &self->obj.use_sol, + &self->obj.save_sol, + &self->obj.alien)) + return -1; + + return 0; +} + +/* iocp members declaration */ +static PyMemberDef iocpMembers[] = { + {"msg_lev", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,msg_lev), 0, "message level (see glp_smcp) "}, + {"br_tech", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,br_tech), 0, "branching technique: "}, + {"bt_tech", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,bt_tech), 0, "backtracking technique: "}, + {"tol_int", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_iocp,tol_int), 0, "mip.tol_int "}, + {"tol_obj", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_iocp,tol_obj), 0, "mip.tol_obj "}, + {"tm_lim", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,tm_lim), 0, "mip.tm_lim (milliseconds) "}, + {"out_frq", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,out_frq), 0, "mip.out_frq (milliseconds) "}, + {"out_dly", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,out_dly), 0, "mip.out_dly (milliseconds) "}, + /*void (*cb_func)(glp_tree *T, void *info); [> mip.cb_func <]*/ + /*void *cb_info; [> mip.cb_info <]*/ + {"cb_size", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,cb_size), 0, "mip.cb_size "}, + {"pp_tech", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,pp_tech), 0, "preprocessing technique: "}, + {"mip_gap", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_iocp,mip_gap), 0, "relative MIP gap tolerance "}, + {"mir_cuts", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,mir_cuts), 0, "MIR cuts (GLP_ON/GLP_OFF) "}, + {"gmi_cuts", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,gmi_cuts), 0, "Gomory's cuts (GLP_ON/GLP_OFF) "}, + {"cov_cuts", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,cov_cuts), 0, "cover cuts (GLP_ON/GLP_OFF) "}, + {"clq_cuts", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,clq_cuts), 0, "clique cuts (GLP_ON/GLP_OFF) "}, + {"presolve", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,presolve), 0, "enable/disable using MIP presolver "}, + {"binarize", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,binarize), 0, "try to binarize integer variables "}, + {"fp_heur", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,fp_heur), 0, "feasibility pump heuristic "}, + {"ps_heur", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,ps_heur), 0, "proximity search heuristic "}, + {"ps_tm_lim", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,ps_tm_lim), 0, "proxy time limit, milliseconds "}, + {"use_sol", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,use_sol), 0, "use existing solution "}, + {"save_sol",T_STRING,offsetof(pysmcp,obj)+offsetof(glp_iocp,save_sol),0, "filename to save every new solution"}, + {"alien", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,alien), 0, "use alien solver "}, +}; + +static PyTypeObject iocp_t = { + PyVarObject_HEAD_INIT(NULL, 0) + "glpk.iocp", /* tp_name */ + sizeof(pyiocp), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)iocp_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | + Py_TPFLAGS_BASETYPE, /* tp_flags */ + "integer optimizer control parameters", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + iocpMembers, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)iocp_init, /* tp_init */ + 0, /* tp_alloc */ + iocp_new, /* tp_new */ +}; + + + +/* Small helper function to generate the output string of the simplex function */ +inline static void set_output_string(PyObject* t,const char s[]) { + PyTuple_SET_ITEM(t, 0, (PyObject *) +#if PY_MAJOR_VERSION >= 3 + PyUnicode_FromString(s)); +#else + PyString_FromString(s)); +#endif + } + static char doc_simplex[] = "Solves a linear program using GLPK.\n\n" @@ -126,21 +322,16 @@ PyObject *kwrds) { 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; - int_t pos=0; + 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 param_type, err_str[100]; -#if PY_MAJOR_VERSION >= 3 - const char *keystr; -#else - char *keystr; -#endif - char *kwlist[] = {"c", "G", "h", "A", "b", NULL}; + char *kwlist[] = {"c", "G", "h", "A", "b","options", NULL}; - if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OOO|OO", kwlist, &c, - &G, &h, &A, &b)) return 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) || @@ -182,19 +373,30 @@ 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 = 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 +405,7 @@ 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 +444,18 @@ 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); - 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)) && - get_param_idx(_PyUnicode_AsString(key), ¶m_id, - ¶m_type)){ - keystr = _PyUnicode_AsString(key); -#else - if ((keystr = PyString_AsString(key)) && get_param_idx(keystr, - ¶m_id, ¶m_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){ -#endif - PyErr_Warn(PyExc_UserWarning, "ignoring value of " - "GLPK parameter 'LPX_K_PRESOL'"); - } - 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)); - } - } - lpx_set_int_parm(lp, LPX_K_PRESOL, 1); - Py_DECREF(param); - switch (lpx_simplex(lp)){ + switch (glp_simplex(lp,options)){ - case LPX_E_OK: + case 0: x = (matrix *) Matrix_New(n,1,DOUBLE); z = (matrix *) Matrix_New(m,1,DOUBLE); @@ -329,65 +465,70 @@ Py_XDECREF(z); Py_XDECREF(y); Py_XDECREF(t); - lpx_delete_prob(lp); + Py_XDECREF(smcpParm); + 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 + set_output_string(t,"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); + Py_XDECREF(smcpParm); + glp_delete_prob(lp); return (PyObject *) t; - - case LPX_E_NOPFS: - - PyTuple_SET_ITEM(t, 0, (PyObject *) -#if PY_MAJOR_VERSION >= 3 - PyUnicode_FromString("primal infeasible")); -#else - PyString_FromString("primal infeasible")); -#endif + case GLP_EBADB: + set_output_string(t,"incorrect initial basis"); break; - - case LPX_E_NODFS: - - PyTuple_SET_ITEM(t, 0, (PyObject *) -#if PY_MAJOR_VERSION >= 3 - PyUnicode_FromString("dual infeasible")); -#else - PyString_FromString("dual infeasible")); -#endif + 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: - - PyTuple_SET_ITEM(t, 0, (PyObject *) -#if PY_MAJOR_VERSION >= 3 - PyUnicode_FromString("unknown")); -#else - PyString_FromString("unknown")); -#endif + set_output_string(t,"unknown"); + break; } - lpx_delete_prob(lp); + Py_XDECREF(smcpParm); + glp_delete_prob(lp); PyTuple_SET_ITEM(t, 1, Py_BuildValue("")); PyTuple_SET_ITEM(t, 2, Py_BuildValue("")); @@ -427,21 +568,28 @@ { 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; - int_t pos=0; + PyObject *t=NULL; + pyiocp *iocpParm = NULL;; + glp_iocp *options = NULL; + glp_prob *lp; + int m, n, p, i, j, k, nnz, nnzmax, *rn=NULL, *cn=NULL; double *a=NULL, val; - char param_type, err_str[100]; -#if PY_MAJOR_VERSION >= 3 - const char *keystr; -#else - char *keystr; -#endif - char *kwlist[] = {"c", "G", "h", "A", "b", "I", "B", NULL}; + char *kwlist[] = {"c", "G", "h", "A", "b", "I", "B","iocp", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OOO|OOOOO!", kwlist, &c, + &G, &h, &A, &b, &IntSet, &BinSet,iocp_t,&iocpParm)) return NULL; - if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OOO|OOOO", kwlist, &c, - &G, &h, &A, &b, &IntSet, &BinSet)) return NULL; + if(!iocpParm) + { + iocpParm = (pyiocp*)malloc(sizeof(*iocpParm)); + glp_init_iocp(&(iocpParm->obj)); + } + if(iocpParm) + { + Py_INCREF(iocpParm); + options = &iocpParm->obj; + options->presolve = 1; + } if ((Matrix_Check(G) && MAT_ID(G) != DOUBLE) || (SpMatrix_Check(G) && SP_ID(G) != DOUBLE) || @@ -490,18 +638,18 @@ 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 +658,7 @@ 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,79 +697,14 @@ 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); - 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, ¶m_id, ¶m_type)){ -#else - if ((keystr = PyString_AsString(key)) && get_param_idx(keystr, - ¶m_id, ¶m_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){ -#endif - PyErr_Warn(PyExc_UserWarning, "ignoring value of " - "GLPK parameter 'LPX_K_PRESOL'"); - } - 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)); - } - } - lpx_set_int_parm(lp, LPX_K_PRESOL, 1); - Py_DECREF(param); - if (IntSet) { PyObject *iter = PySequence_Fast(IntSet, "Critical error: not sequence"); @@ -633,7 +716,7 @@ #else if (!PyInt_Check(tmp)) { #endif - lpx_delete_prob(lp); + glp_delete_prob(lp); Py_DECREF(iter); PY_ERR_TYPE("non-integer element in I"); } @@ -643,7 +726,7 @@ int k = PyInt_AS_LONG(tmp); #endif 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"); } @@ -664,7 +747,7 @@ #else if (!PyInt_Check(tmp)) { #endif - lpx_delete_prob(lp); + glp_delete_prob(lp); Py_DECREF(iter); PY_ERR_TYPE("non-binary element in I"); } @@ -674,7 +757,7 @@ int k = PyInt_AS_LONG(tmp); #endif 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,114 +769,85 @@ } + switch (glp_intopt(lp,options)){ - switch (lpx_intopt(lp)){ + case 0: - case LPX_E_OK: + x = (matrix *) Matrix_New(n,1,DOUBLE); + if (!x) { + Py_XDECREF(iocpParm); + Py_XDECREF(t); + glp_delete_prob(lp); + return PyErr_NoMemory(); + } + set_output_string(t,"optimal"); + set_output_string(t,"optimal"); - x = (matrix *) Matrix_New(n,1,DOUBLE); - if (!x) { - Py_XDECREF(t); - lpx_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 + for (i=0; i<n; i++) + MAT_BUFD(x)[i] = glp_mip_col_val(lp, i+1); + PyTuple_SET_ITEM(t, 1, (PyObject *) x); - for (i=0; i<n; i++) - MAT_BUFD(x)[i] = lpx_mip_col_val(lp, i+1); - PyTuple_SET_ITEM(t, 1, (PyObject *) x); + Py_XDECREF(iocpParm); + glp_delete_prob(lp); + return (PyObject *) t; - lpx_delete_prob(lp); - return (PyObject *) t; + case GLP_ETMLIM: - case LPX_E_TMLIM: + x = (matrix *) Matrix_New(n,1,DOUBLE); + if (!x) { + Py_XDECREF(t); + Py_XDECREF(iocpParm); + glp_delete_prob(lp); + return PyErr_NoMemory(); + } + set_output_string(t,"time limit exceeded"); - x = (matrix *) Matrix_New(n,1,DOUBLE); - if (!x) { - Py_XDECREF(t); - lpx_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 + for (i=0; i<n; i++) + MAT_BUFD(x)[i] = glp_mip_col_val(lp, i+1); + PyTuple_SET_ITEM(t, 1, (PyObject *) x); - for (i=0; i<n; i++) - MAT_BUFD(x)[i] = lpx_mip_col_val(lp, i+1); - PyTuple_SET_ITEM(t, 1, (PyObject *) x); - - lpx_delete_prob(lp); - return (PyObject *) t; + Py_XDECREF(iocpParm); + glp_delete_prob(lp); + return (PyObject *) t; - case LPX_E_FAULT: - PyTuple_SET_ITEM(t, 0, (PyObject *) -#if PY_MAJOR_VERSION >= 3 - PyUnicode_FromString("invalid MIP formulation")); -#else - PyString_FromString("invalid MIP formulation")); -#endif - break; + case GLP_EBOUND: + set_output_string(t,"incorrect bounds"); + break; + case GLP_EFAIL: + set_output_string(t,"invalid MIP formulation"); + break; - case LPX_E_NOPFS: - PyTuple_SET_ITEM(t, 0, (PyObject *) -#if PY_MAJOR_VERSION >= 3 - PyUnicode_FromString("primal infeasible")); -#else - PyString_FromString("primal infeasible")); -#endif - break; + case GLP_ENOPFS: + set_output_string(t,"primal infeasible"); + break; - case LPX_E_NODFS: + case GLP_ENODFS: + set_output_string(t,"dual infeasible"); + break; - PyTuple_SET_ITEM(t, 0, (PyObject *) -#if PY_MAJOR_VERSION >= 3 - PyUnicode_FromString("dual infeasible")); -#else - PyString_FromString("dual infeasible")); -#endif - break; + case GLP_EMIPGAP: + set_output_string(t,"Relative mip gap tolerance reached"); + break; - case LPX_E_ITLIM: + /*case LPX_E_ITLIM: - PyTuple_SET_ITEM(t, 0, (PyObject *) -#if PY_MAJOR_VERSION >= 3 - PyUnicode_FromString("maxiters exceeded")); -#else - PyString_FromString("maxiters exceeded")); -#endif - break; + set_output_string(t,"maxiters exceeded"); + break;*/ - case LPX_E_SING: + /*case LPX_E_SING: - 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 - break; + set_output_string(t,"singular or ill-conditioned basis"); + break;*/ - default: + default: - PyTuple_SET_ITEM(t, 0, (PyObject *) -#if PY_MAJOR_VERSION >= 3 - PyUnicode_FromString("unknown")); -#else - PyString_FromString("unknown")); -#endif - } + set_output_string(t,"unknown"); + } - lpx_delete_prob(lp); + Py_XDECREF(iocpParm); + glp_delete_prob(lp); PyTuple_SET_ITEM(t, 1, Py_BuildValue("")); return (PyObject *) t; @@ -819,10 +873,94 @@ NULL, NULL, NULL, NULL }; +void addglpkConstants (void) +{ + PyModule_AddIntMacro(glpk_module, GLP_ON); + PyModule_AddIntMacro(glpk_module,GLP_OFF); + + /* reason codes: */ + PyModule_AddIntMacro(glpk_module,GLP_IROWGEN); + PyModule_AddIntMacro(glpk_module,GLP_IBINGO); + PyModule_AddIntMacro(glpk_module,GLP_IHEUR); + PyModule_AddIntMacro(glpk_module,GLP_ICUTGEN); + PyModule_AddIntMacro(glpk_module,GLP_IBRANCH); + PyModule_AddIntMacro(glpk_module,GLP_ISELECT); + PyModule_AddIntMacro(glpk_module,GLP_IPREPRO); + + /* branch selection indicator: */ + PyModule_AddIntMacro(glpk_module,GLP_NO_BRNCH); + PyModule_AddIntMacro(glpk_module,GLP_DN_BRNCH); + PyModule_AddIntMacro(glpk_module,GLP_UP_BRNCH); + + /* return codes: */ + PyModule_AddIntMacro(glpk_module,GLP_EBADB); + PyModule_AddIntMacro(glpk_module,GLP_ESING); + PyModule_AddIntMacro(glpk_module,GLP_ECOND); + PyModule_AddIntMacro(glpk_module,GLP_EBOUND); + PyModule_AddIntMacro(glpk_module,GLP_EFAIL); + PyModule_AddIntMacro(glpk_module,GLP_EOBJLL); + PyModule_AddIntMacro(glpk_module,GLP_EOBJUL); + PyModule_AddIntMacro(glpk_module,GLP_EITLIM); + PyModule_AddIntMacro(glpk_module,GLP_ETMLIM); + PyModule_AddIntMacro(glpk_module,GLP_ENOPFS); + PyModule_AddIntMacro(glpk_module,GLP_ENODFS); + PyModule_AddIntMacro(glpk_module,GLP_EROOT); + PyModule_AddIntMacro(glpk_module,GLP_ESTOP); + PyModule_AddIntMacro(glpk_module,GLP_EMIPGAP); + PyModule_AddIntMacro(glpk_module,GLP_ENOFEAS); + PyModule_AddIntMacro(glpk_module,GLP_ENOCVG); + PyModule_AddIntMacro(glpk_module,GLP_EINSTAB); + PyModule_AddIntMacro(glpk_module,GLP_EDATA); + PyModule_AddIntMacro(glpk_module,GLP_ERANGE); + + /* condition indicator: */ + PyModule_AddIntMacro(glpk_module,GLP_KKT_PE); + PyModule_AddIntMacro(glpk_module,GLP_KKT_PB); + PyModule_AddIntMacro(glpk_module,GLP_KKT_DE); + PyModule_AddIntMacro(glpk_module,GLP_KKT_DB); + PyModule_AddIntMacro(glpk_module,GLP_KKT_CS); + + /* MPS file format: */ + PyModule_AddIntMacro(glpk_module,GLP_MPS_DECK); + PyModule_AddIntMacro(glpk_module,GLP_MPS_FILE); + + /* simplex method control parameters */ + /* message level: */ + PyModule_AddIntMacro(glpk_module,GLP_MSG_OFF); + PyModule_AddIntMacro(glpk_module,GLP_MSG_ERR); + PyModule_AddIntMacro(glpk_module,GLP_MSG_ON); + PyModule_AddIntMacro(glpk_module,GLP_MSG_ALL); + PyModule_AddIntMacro(glpk_module,GLP_MSG_DBG); + /* simplex method option: */ + PyModule_AddIntMacro(glpk_module,GLP_PRIMAL); + PyModule_AddIntMacro(glpk_module,GLP_DUALP); + PyModule_AddIntMacro(glpk_module,GLP_DUAL); + /* pricing technique: */ + PyModule_AddIntMacro(glpk_module,GLP_PT_STD); + PyModule_AddIntMacro(glpk_module,GLP_PT_PSE); + /* ratio test technique: */ + PyModule_AddIntMacro(glpk_module,GLP_RT_STD); + PyModule_AddIntMacro(glpk_module,GLP_RT_HAR); + + /* interior-point solver control parameters */ + /* ordering algorithm: */ + PyModule_AddIntMacro(glpk_module,GLP_ORD_NONE); + PyModule_AddIntMacro(glpk_module,GLP_ORD_QMD); + PyModule_AddIntMacro(glpk_module,GLP_ORD_AMD); + PyModule_AddIntMacro(glpk_module,GLP_ORD_SYMAMD); +} + PyMODINIT_FUNC PyInit_glpk(void) { if (!(glpk_module = PyModule_Create(&glpk_module_def))) return NULL; - PyModule_AddObject(glpk_module, "options", PyDict_New()); + if (PyType_Ready(&iocp_t) < 0 || (PyType_Ready(&smcp_t) < 0)) return NULL; + /* Adding macros */ + addglpkConstants(); + /* Adding option lists as objects */ + Py_INCREF(&smcp_t); + PyModule_AddObject(glpk_module,"smcp",(PyObject*)&smcp_t); + Py_INCREF(&iocp_t); + PyModule_AddObject(glpk_module,"iocp",(PyObject*)&iocp_t); if (import_cvxopt() < 0) return NULL; return glpk_module; } @@ -832,8 +970,13 @@ PyMODINIT_FUNC initglpk(void) { glpk_module = Py_InitModule3("cvxopt.glpk", glpk_functions, - glpk__doc__); - PyModule_AddObject(glpk_module, "options", PyDict_New()); + glpk__doc__); + if (PyType_Ready(&iocp_t) < 0 || (PyType_Ready(&smcp_t) < 0)) return NULL; + addglpkConstants(); + Py_INCREF(&smcp_t); + PyModule_AddObject(glpk_module,"smcp",(PyObject*)&smcp_t); + Py_INCREF(&iocp_t); + PyModule_AddObject(glpk_module,"iocp",(PyObject*)&iocp_t); if (import_cvxopt() < 0) return; }
