Get Gentoo!
gentoo.org sites
gentoo.org Wiki Bugs Forums Packages
Planet Archives Sources
Infra Status
summaryrefslogtreecommitdiff
path: root/dev-python/cvxopt
diff options
context:
space:
mode:
authorRobin H. Johnson <robbat2@gentoo.org>2015-08-08 13:49:04 -0700
committerRobin H. Johnson <robbat2@gentoo.org>2015-08-08 17:38:18 -0700
commit56bd759df1d0c750a065b8c845e93d5dfa6b549d (patch)
tree3f91093cdb475e565ae857f1c5a7fd339e2d781e /dev-python/cvxopt
downloadgentoo-56bd759df1d0c750a065b8c845e93d5dfa6b549d.tar.gz
gentoo-56bd759df1d0c750a065b8c845e93d5dfa6b549d.tar.bz2
gentoo-56bd759df1d0c750a065b8c845e93d5dfa6b549d.zip
proj/gentoo: Initial commit
This commit represents a new era for Gentoo: Storing the gentoo-x86 tree in Git, as converted from CVS. This commit is the start of the NEW history. Any historical data is intended to be grafted onto this point. Creation process: 1. Take final CVS checkout snapshot 2. Remove ALL ChangeLog* files 3. Transform all Manifests to thin 4. Remove empty Manifests 5. Convert all stale $Header$/$Id$ CVS keywords to non-expanded Git $Id$ 5.1. Do not touch files with -kb/-ko keyword flags. Signed-off-by: Robin H. Johnson <robbat2@gentoo.org> X-Thanks: Alec Warner <antarus@gentoo.org> - did the GSoC 2006 migration tests X-Thanks: Robin H. Johnson <robbat2@gentoo.org> - infra guy, herding this project X-Thanks: Nguyen Thai Ngoc Duy <pclouds@gentoo.org> - Former Gentoo developer, wrote Git features for the migration X-Thanks: Brian Harring <ferringb@gentoo.org> - wrote much python to improve cvs2svn X-Thanks: Rich Freeman <rich0@gentoo.org> - validation scripts X-Thanks: Patrick Lauer <patrick@gentoo.org> - Gentoo dev, running new 2014 work in migration X-Thanks: Michał Górny <mgorny@gentoo.org> - scripts, QA, nagging X-Thanks: All of other Gentoo developers - many ideas and lots of paint on the bikeshed
Diffstat (limited to 'dev-python/cvxopt')
-rw-r--r--dev-python/cvxopt/Manifest1
-rw-r--r--dev-python/cvxopt/cvxopt-1.1.6-r2.ebuild96
-rw-r--r--dev-python/cvxopt/files/cvxopt-1.1.6-glpk.patch889
-rw-r--r--dev-python/cvxopt/files/cvxopt-1.1.6-glpk449.patch1082
-rw-r--r--dev-python/cvxopt/files/cvxopt-1.1.6-setup.patch176
-rw-r--r--dev-python/cvxopt/metadata.xml20
6 files changed, 2264 insertions, 0 deletions
diff --git a/dev-python/cvxopt/Manifest b/dev-python/cvxopt/Manifest
new file mode 100644
index 000000000000..4f7f06c52ac5
--- /dev/null
+++ b/dev-python/cvxopt/Manifest
@@ -0,0 +1 @@
+DIST cvxopt-1.1.6.tar.gz 3352996 SHA256 7b4ccf3ed896dde6624623431c0b1f5e32d874384329ed716f51babcbf416227 SHA512 b9f5fd7870412423b60068d205efb99d3630012509cb659fb67a10d6175906768846d7c906cf2fcac4be29afd558619b71e2dca730041329195a2365dd1d722c WHIRLPOOL d43cf090ee0396a77851fb71e6e34c980152bccdd5fdb3ecc53d0a464a505ac87a1e7198d313ec669443970bcf8a2d616f03c2f861b7df2f620bd583a97ea140
diff --git a/dev-python/cvxopt/cvxopt-1.1.6-r2.ebuild b/dev-python/cvxopt/cvxopt-1.1.6-r2.ebuild
new file mode 100644
index 000000000000..256fcd3eb840
--- /dev/null
+++ b/dev-python/cvxopt/cvxopt-1.1.6-r2.ebuild
@@ -0,0 +1,96 @@
+# Copyright 1999-2015 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Id$
+
+EAPI=5
+
+PYTHON_COMPAT=( python{2_7,3_3,3_4} )
+
+inherit distutils-r1 toolchain-funcs eutils
+
+DESCRIPTION="Python package for convex optimization"
+HOMEPAGE="http://cvxopt.org/"
+SRC_URI="https://github.com/${PN}/${PN}/archive/${PV}.tar.gz -> ${P}.tar.gz"
+
+LICENSE="GPL-3"
+SLOT="0"
+KEYWORDS="~amd64 ~x86 ~amd64-linux ~x86-linux"
+IUSE="doc +dsdp examples fftw +glpk gsl"
+
+RDEPEND="
+ virtual/blas
+ virtual/cblas
+ virtual/lapack
+ sci-libs/cholmod:0=
+ sci-libs/umfpack:0=
+ dsdp? ( sci-libs/dsdp:0= )
+ fftw? ( sci-libs/fftw:3.0= )
+ glpk? ( sci-mathematics/glpk:0= )
+ gsl? ( sci-libs/gsl:0= )"
+DEPEND="${RDEPEND}
+ virtual/pkgconfig
+ doc? ( dev-python/sphinx )"
+
+python_prepare_all(){
+ epatch "${FILESDIR}"/${PN}-1.1.6-setup.patch
+
+ has_version ">=sci-mathematics/glpk-4.49" && \
+ epatch "${FILESDIR}"/${PN}-1.1.6-glpk449.patch
+
+ rm -r src/C/SuiteSparse*/ || die
+
+ pkg_lib() {
+ local pkg=$(echo $1 | tr '[:lower:]' '[:upper:]')
+ local libs="$($(tc-getPKG_CONFIG) --libs-only-l $1 | \
+ sed -e 's:[ ]-l*\(pthread\|m\)\([ ]\|$\)::g' -e 's:[ ]*$::' | \
+ tr ' ' '\n' | sort -u | sed -e "s:^-l\(.*\):'\1':g" | \
+ tr '\n' ',' | sed -e 's:,$::')"
+ local libdir="$($(tc-getPKG_CONFIG) --libs-only-L $1 | \
+ sed -e 's:[ ]*$::' | \
+ tr ' ' '\n' | sort -u | sed -e "s:^-L\(.*\):'\1':g" | \
+ tr '\n' ',' | sed -e 's:,$::')"
+ local incdir="$($(tc-getPKG_CONFIG) --cflags-only-I $1 | \
+ sed -e 's:[ ]*$::' | \
+ tr ' ' '\n' | sort -u | sed -e "s:^-L\(.*\):'\1':g" | \
+ tr '\n' ',' | sed -e 's:,$::')"
+ sed -i \
+ -e "/${pkg}_LIB[ ]*=/s:\(.*[ ]*=[ ]*\[\).*${1}.*:\1${libs}\]:" \
+ -e "s:\(${pkg}_INC_DIR[ ]*=\).*$:\1 ${incdir}:" \
+ -e "s:\[ BLAS_LIB_DIR \]:\[ ${libdir} \]:g" \
+ setup.py || die
+ }
+
+ use_cvx() {
+ if use $1 ; then
+ sed -i \
+ -e "s/\(BUILD_${1^^} =\) 0/\1 1/" \
+ setup.py || die
+ fi
+ }
+
+ pkg_lib blas
+ pkg_lib lapack
+
+ use_cvx gsl
+ use_cvx fftw
+ use_cvx glpk
+ use_cvx dsdp
+
+ distutils-r1_python_prepare_all
+}
+
+python_compile_all() {
+ use doc && export VARTEXFONTS="${T}/fonts" && emake -C doc -B html
+}
+
+python_test() {
+ cd examples/doc/chap8
+ "${EPYTHON}" lp.py || die
+}
+
+python_install_all() {
+ use doc && HTML_DOCS=( doc/build/html/. )
+ insinto /usr/share/doc/${PF}
+ use examples && doins -r examples
+ distutils-r1_python_install_all
+}
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 000000000000..2887ccd02206
--- /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;
+ }
+
+
diff --git a/dev-python/cvxopt/files/cvxopt-1.1.6-glpk449.patch b/dev-python/cvxopt/files/cvxopt-1.1.6-glpk449.patch
new file mode 100644
index 000000000000..2a1cc6737be4
--- /dev/null
+++ b/dev-python/cvxopt/files/cvxopt-1.1.6-glpk449.patch
@@ -0,0 +1,1082 @@
+--- 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), &param_id,
+- &param_type)){
+- 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){
+-#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, &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) &&
+-#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;
+ }
+
diff --git a/dev-python/cvxopt/files/cvxopt-1.1.6-setup.patch b/dev-python/cvxopt/files/cvxopt-1.1.6-setup.patch
new file mode 100644
index 000000000000..c95f31bf6048
--- /dev/null
+++ b/dev-python/cvxopt/files/cvxopt-1.1.6-setup.patch
@@ -0,0 +1,176 @@
+--- setup.py.orig 2013-05-16 21:36:29.616510963 +1200
++++ setup.py 2013-05-16 21:51:08.456347311 +1200
+@@ -2,7 +2,7 @@
+ from glob import glob
+
+ # Modifiy this if BLAS and LAPACK libraries are not in /usr/lib.
+-BLAS_LIB_DIR = '/usr/lib'
++BLAS_LIB_DIR = ''
+
+ # Default names of BLAS and LAPACK libraries
+ BLAS_LIB = ['blas']
+@@ -18,37 +18,37 @@
+ BUILD_GSL = 0
+
+ # Directory containing libgsl (used only when BUILD_GSL = 1).
+-GSL_LIB_DIR = '/usr/lib'
++GSL_LIB_DIR = ''
+
+ # Directory containing the GSL header files (used only when BUILD_GSL = 1).
+-GSL_INC_DIR = '/usr/include/gsl'
++GSL_INC_DIR = ''
+
+ # Set to 1 if you are installing the fftw module.
+ BUILD_FFTW = 0
+
+ # Directory containing libfftw3 (used only when BUILD_FFTW = 1).
+-FFTW_LIB_DIR = '/usr/lib'
++FFTW_LIB_DIR = ''
+
+ # Directory containing fftw.h (used only when BUILD_FFTW = 1).
+-FFTW_INC_DIR = '/usr/include'
++FFTW_INC_DIR = ''
+
+ # Set to 1 if you are installing the glpk module.
+ BUILD_GLPK = 0
+
+ # Directory containing libglpk (used only when BUILD_GLPK = 1).
+-GLPK_LIB_DIR = '/usr/lib'
++GLPK_LIB_DIR = ''
+
+ # Directory containing glpk.h (used only when BUILD_GLPK = 1).
+-GLPK_INC_DIR = '/usr/include'
++GLPK_INC_DIR = ''
+
+ # Set to 1 if you are installing the DSDP module.
+ BUILD_DSDP = 0
+
+ # Directory containing libdsdp (used only when BUILD_DSDP = 1).
+-DSDP_LIB_DIR = '/usr/lib'
++DSDP_LIB_DIR = ''
+
+ # Directory containing dsdp5.h (used only when BUILD_DSDP = 1).
+-DSDP_INC_DIR = '/usr/include/dsdp'
++DSDP_INC_DIR = ''
+
+ # No modifications should be needed below this line.
+
+@@ -61,39 +61,32 @@
+ # optional modules
+
+ if BUILD_GSL:
+- gsl = Extension('gsl', libraries = ['m', 'gsl'] + BLAS_LIB,
+- include_dirs = [ GSL_INC_DIR ],
+- library_dirs = [ GSL_LIB_DIR, BLAS_LIB_DIR ],
+- extra_link_args = BLAS_EXTRA_LINK_ARGS,
++ gsl = Extension('gsl', libraries = ['gsl'],
++ library_dirs = [ GSL_LIB_DIR ],
+ sources = ['src/C/gsl.c'] )
+ extmods += [gsl];
+
+ if BUILD_FFTW:
+- fftw = Extension('fftw', libraries = ['fftw3'] + BLAS_LIB,
+- include_dirs = [ FFTW_INC_DIR ],
+- library_dirs = [ FFTW_LIB_DIR, BLAS_LIB_DIR ],
+- extra_link_args = BLAS_EXTRA_LINK_ARGS,
++ fftw = Extension('fftw', libraries = ['fftw3'],
++ library_dirs = [ FFTW_LIB_DIR ],
+ sources = ['src/C/fftw.c'] )
+ extmods += [fftw];
+
+ if BUILD_GLPK:
+ glpk = Extension('glpk', libraries = ['glpk'],
+- include_dirs = [ GLPK_INC_DIR ],
+ library_dirs = [ GLPK_LIB_DIR ],
+ sources = ['src/C/glpk.c'] )
+ extmods += [glpk];
+
+ if BUILD_DSDP:
+- dsdp = Extension('dsdp', libraries = ['dsdp'] + LAPACK_LIB + BLAS_LIB,
+- include_dirs = [ DSDP_INC_DIR ],
+- library_dirs = [ DSDP_LIB_DIR, BLAS_LIB_DIR ],
+- extra_link_args = BLAS_EXTRA_LINK_ARGS,
++ dsdp = Extension('dsdp', libraries = ['dsdp'],
++ library_dirs = [ DSDP_LIB_DIR ],
+ sources = ['src/C/dsdp.c'] )
+ extmods += [dsdp];
+
+ # Required modules
+
+-base = Extension('base', libraries = ['m'] + LAPACK_LIB + BLAS_LIB,
++base = Extension('base', libraries = ['m'] + LAPACK_LIB,
+ library_dirs = [ BLAS_LIB_DIR ],
+ define_macros = MACROS,
+ extra_link_args = BLAS_EXTRA_LINK_ARGS,
+@@ -105,61 +98,36 @@
+ extra_link_args = BLAS_EXTRA_LINK_ARGS,
+ sources = ['src/C/blas.c'] )
+
+-lapack = Extension('lapack', libraries = LAPACK_LIB + BLAS_LIB,
++lapack = Extension('lapack', libraries = LAPACK_LIB,
+ library_dirs = [ BLAS_LIB_DIR ],
+ define_macros = MACROS,
+ extra_link_args = BLAS_EXTRA_LINK_ARGS,
+ sources = ['src/C/lapack.c'] )
+
+ umfpack = Extension('umfpack',
+- include_dirs = [ 'src/C/SuiteSparse/UMFPACK/Include',
+- 'src/C/SuiteSparse/AMD/Include',
+- 'src/C/SuiteSparse/AMD/Source',
+- 'src/C/SuiteSparse/SuiteSparse_config' ],
+ library_dirs = [ BLAS_LIB_DIR ],
+ define_macros = MACROS + [('NTIMER', '1'), ('NCHOLMOD', '1')],
+- libraries = LAPACK_LIB + BLAS_LIB,
++ libraries = [ 'umfpack' ],
+ extra_compile_args = ['-Wno-unknown-pragmas'],
+- extra_link_args = BLAS_EXTRA_LINK_ARGS,
+- sources = [ 'src/C/umfpack.c',
+- 'src/C/SuiteSparse/UMFPACK/Source/umfpack_global.c',
+- 'src/C/SuiteSparse/UMFPACK/Source/umfpack_tictoc.c' ] +
+- ['src/C/SuiteSparse/SuiteSparse_config/SuiteSparse_config.c'] +
+- glob('src/C/SuiteSparse_cvxopt_extra/umfpack/*'))
++ sources = [ 'src/C/umfpack.c' ])
+
+ # Build for int or long?
+ import sys
+ if sys.maxsize > 2**31: MACROS += [('DLONG',None)]
+
+ cholmod = Extension('cholmod',
+- library_dirs = [ BLAS_LIB_DIR ],
+- libraries = LAPACK_LIB + BLAS_LIB,
+- include_dirs = [ 'src/C/SuiteSparse/CHOLMOD/Include',
+- 'src/C/SuiteSparse/COLAMD',
+- 'src/C/SuiteSparse/AMD/Include',
+- 'src/C/SuiteSparse/COLAMD/Include',
+- 'src/C/SuiteSparse/SuiteSparse_config' ],
+- define_macros = MACROS + [('NPARTITION', '1'), ('NTIMER', '1')],
+- extra_link_args = BLAS_EXTRA_LINK_ARGS,
+- sources = [ 'src/C/cholmod.c' ] +
+- ['src/C/SuiteSparse/AMD/Source/' + s for s in ['amd_global.c',
+- 'amd_postorder.c', 'amd_post_tree.c', 'amd_2.c']] +
+- ['src/C/SuiteSparse/COLAMD/Source/' + s for s in ['colamd.c',
+- 'colamd_global.c']] +
+- ['src/C/SuiteSparse/SuiteSparse_config/SuiteSparse_config.c'] +
+- glob('src/C/SuiteSparse/CHOLMOD/Core/c*.c') +
+- glob('src/C/SuiteSparse/CHOLMOD/Cholesky/c*.c') +
+- ['src/C/SuiteSparse/CHOLMOD/Check/cholmod_check.c'] +
+- glob('src/C/SuiteSparse/CHOLMOD/Supernodal/c*.c') )
++ library_dirs = [ BLAS_LIB_DIR ],
++ libraries = ['cholmod'] + BLAS_LIB,
++ define_macros = MACROS + [('NPARTITION', '1'), ('NTIMER', '1')],
++ sources = [ 'src/C/cholmod.c' ])
+
+ amd = Extension('amd',
+- include_dirs = [ 'src/C/SuiteSparse/AMD/Include',
+- 'src/C/SuiteSparse/SuiteSparse_config' ],
+ define_macros = MACROS,
+- sources = [ 'src/C/amd.c' ] + glob('src/C/SuiteSparse/AMD/Source/*.c') )
++ libraries = ['amd'],
++ sources = [ 'src/C/amd.c' ])
+
+ misc_solvers = Extension('misc_solvers',
+- libraries = LAPACK_LIB + BLAS_LIB,
++ libraries = LAPACK_LIB,
+ library_dirs = [ BLAS_LIB_DIR ],
+ define_macros = MACROS,
+ extra_link_args = BLAS_EXTRA_LINK_ARGS,
diff --git a/dev-python/cvxopt/metadata.xml b/dev-python/cvxopt/metadata.xml
new file mode 100644
index 000000000000..9202e558f39b
--- /dev/null
+++ b/dev-python/cvxopt/metadata.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+ <herd>sci-mathematics</herd>
+ <longdescription lang="en">
+ CVXOPT is a software for convex optimization based on
+ the Python programming language. Its main purpose is to make the
+ development of software for convex optimization applications
+ straightforward.
+</longdescription>
+ <use>
+ <flag name="dsdp">Use interior point library
+ <pkg>sci-libs/dsdp</pkg></flag>
+ <flag name="glpk">Use GNU Linear Programming Kit
+ <pkg>sci-mathematics/glpk</pkg></flag>
+ </use>
+ <upstream>
+ <remote-id type="github">cvxopt/cvxopt</remote-id>
+ </upstream>
+</pkgmetadata>