Ticket #7804: trac_7804.patch

module_list.py

@@ -632 +632 @@
               libraries = ["csage", "ntl", "gmp", "gmpxx", "m", "stdc++"],
               language='c++'),
 
-
-
     ################################
     ## 
     ## sage.matrix
@@ -1403 +1401 @@
               depends = [SAGE_ROOT + "/local/include/pynac/ginac.h"],
               libraries = ["pynac"]),
 
-    
-
-    
     ]
 
+# Optional extensions :
+# These extensions are to be compiled only if the
+# corresponding packages have been installed
+
+from sage.misc.package import is_package_installed
+
+if is_package_installed('glpk'):
+    ext_modules.append(
+        Extension("sage.numerical.mip_glpk",
+                  ["sage/numerical/mip_glpk.pyx"],
+                  include_dirs = [SAGE_ROOT+"/local/include/", "sage/c_lib/include/"],
+                  language = 'c++',
+                  libraries=["csage", "stdc++", "glpk"])
+        )
+
+if is_package_installed('cbc'):
+    ext_modules.append(
+        Extension("sage.numerical.mip_coin",
+                  ["sage/numerical/mip_coin.pyx"],
+                  include_dirs = [SAGE_ROOT+"/local/include/","sage/c_lib/include/"],
+                  language = 'c++',
+                  libraries = ["csage", "stdc++", "Cbc", "CbcSolver", "Cgl", "Clp", "CoinUtils", "OsiCbc", "OsiClp", "Osi", "OsiVol", "Vol"])
+        )
+    
 
 # Only include darwin_utilities on OS_X >= 10.5
 UNAME = os.uname()

sage/numerical/mip.pyx

@@ -61 +61 @@
             sage: p = MixedIntegerLinearProgram(maximization=True)
         """
         try:
-            from sage.numerical.mipCoin import solveCoin
+            from sage.numerical.mip_coin import solve_coin
             self._default_solver = "Coin"
         except:
             try:
-                from sage.numerical.mipGlpk import solve_glpk
+                from sage.numerical.mip_glpk import solve_glpk
                 self._default_solver = "GLPK"
             except:
                 self._default_solver = None
@@ -438 +438 @@
         """
         
         try:
-            from sage.numerical.mipGlpk import write_mps
+            from sage.numerical.mip_glpk import write_mps
         except:
             raise NotImplementedError("You need GLPK installed to use this function. To install it, you can type in Sage: install_package('glpk')")
 
@@ -469 +469 @@
         http://lpsolve.sourceforge.net/5.5/lp-format.htm
         """
         try:
-            from sage.numerical.mipGlpk import write_lp
+            from sage.numerical.mip_glpk import write_lp
         except:
             raise NotImplementedError("You need GLPK installed to use this function. To install it, you can type in Sage: install_package('glpk')")
 
@@ -959 +959 @@
             sage: p.solve(solver='GLPK', objective_only=True) # optional - requires GLPK
             Traceback (most recent call last): 
             ... 
-            NotImplementedError: ... 
+            RuntimeError
         """
         if self._objective_i == None:
             raise ValueError("No objective function has been defined.")
@@ -971 +971 @@
             raise ValueError("There does not seem to be any solver installed. Please visit http://www.sagemath.org/doc/tutorial/tour_LP.html for more informations.")
         elif solver == "Coin":
             try:
-                from sage.numerical.mipCoin import solveCoin
+                from sage.numerical.mip_coin import solve_coin
             except:
                 raise NotImplementedError("Coin/CBC is not installed and cannot be used to solve this MixedIntegerLinearProgram. To install it, you can type in Sage: install_package('cbc')")
             _sig_on
-            r = solveCoin(self, log=log, objective_only=objective_only)
+            r = solve_coin(self, log=log, objective_only=objective_only)
             _sig_off
             return r
         elif solver == "GLPK":
             try:
-                from sage.numerical.mipGlpk import solve_glpk
+                from sage.numerical.mip_glpk import solve_glpk
             except:
                 raise NotImplementedError("GLPK is not installed and cannot be used to solve this MixedIntegerLinearProgram. To install it, you can type in Sage: install_package('glpk')")
             _sig_on

new file sage/numerical/mip_coin.pxd

@@ +1 @@
+cdef extern from *:
+    ctypedef double* const_double_ptr "const double*"
+
+cdef extern from "../../local/include/coin/CoinPackedVector.hpp":
+     ctypedef struct c_CoinPackedVector "CoinPackedVector":
+         void insert(float, float)
+     c_CoinPackedVector *new_c_CoinPackedVector "new CoinPackedVector" ()
+     void del_CoinPackedVector "delete" (c_CoinPackedVector *)
+cdef extern from "../../local/include/coin/CoinPackedMatrix.hpp":
+     ctypedef struct c_CoinPackedMatrix "CoinPackedMatrix":
+         void setDimensions(int, int)
+         void appendRow(c_CoinPackedVector)
+     c_CoinPackedMatrix *new_c_CoinPackedMatrix "new CoinPackedMatrix" (bool, double, double)
+     void del_CoinPackedMatrix "delete" (c_CoinPackedMatrix *)
+
+cdef extern from "../../local/include/coin/CoinMessageHandler.hpp":
+     ctypedef struct c_CoinMessageHandler "CoinMessageHandler":
+         void setLogLevel (int)
+     c_CoinMessageHandler *new_c_CoinMessageHandler "new CoinMessageHandler" ()
+     void del_CoinMessageHandler "delete" (c_CoinMessageHandler *)
+
+
+cdef extern from "../../local/include/coin/CbcModel.hpp":
+     ctypedef struct c_CbcModel "CbcModel":
+         c_CoinMessageHandler * messageHandler ()
+         void setNumberThreads (int)
+         int getSolutionCount()
+
+     c_CbcModel *new_c_CbcModel "new CbcModel" ()
+     void del_CbcModel "delete" (c_CbcModel *)
+
+cdef extern from "../../local/include/coin/OsiCbcSolverInterface.hpp":
+     ctypedef struct c_OsiCbcSolverInterface "OsiCbcSolverInterface":
+         double getInfinity()
+         void loadProblem(c_CoinPackedMatrix, const_double_ptr, const_double_ptr, const_double_ptr, const_double_ptr, const_double_ptr)
+         void assignProblem(c_CoinPackedMatrix *, const_double_ptr, const_double_ptr, const_double_ptr, const_double_ptr, const_double_ptr)
+         void writeMps(char *, char *, double)
+         void initialSolve()
+         void branchAndBound()
+         void readMps(string)
+         float getObjValue()
+         double * getColSolution()
+         void setObjSense (double )
+         void setLogLevel(int)
+         void setInteger(int)
+         void setContinuous(int)
+         c_CoinMessageHandler * messageHandler ()
+         c_CbcModel * getModelPtr  ()
+         int isAbandoned ()
+         int isProvenOptimal ()
+         int isProvenPrimalInfeasible ()
+         int isProvenDualInfeasible ()
+         int isPrimalObjectiveLimitReached ()
+         int isDualObjectiveLimitReached ()
+         int isIterationLimitReached ()
+         void setMaximumSolutions(int)
+         int getMaximumSolutions()
+     c_OsiCbcSolverInterface *new_c_OsiCbcSolverInterface "new OsiCbcSolverInterface" ()
+     void del_OsiCbcSolverInterface "delete" (c_OsiCbcSolverInterface *)

new file sage/numerical/mip_coin.pyx

@@ +1 @@
+include 'mip_coin.pxd'
+include '../../../../devel/sage/sage/ext/stdsage.pxi'
+
+cdef int BINARY = 1
+cdef int REAL = -1
+cdef int INTEGER = 0
+
+
+def solve_coin(self,log=False,objective_only=False):
+    r"""
+    Solves the MIP using COIN-OR CBC/CLP
+    """
+
+    from itertools import izip
+
+    # Creates the solver interfaces
+    cdef c_OsiCbcSolverInterface* si
+    si = new_c_OsiCbcSolverInterface();
+
+    n_cols = len(self._variables_type);
+
+    # Definition of the objective function
+    cdef double * objective = <double*> sage_malloc(n_cols*sizeof(double))
+
+    # a hand-made memset
+    for 0<= i < n_cols:
+        objective[i] = 0
+
+    for (i,v) in izip(self._objective_i,self._objective_values):
+        objective[i]=float(v)
+
+
+    # Upper and lower bounds on the variables
+    cdef double * col_lb = <double*> sage_malloc(n_cols*sizeof(double))
+    cdef double * col_ub = <double*> sage_malloc(n_cols*sizeof(double))
+
+
+    cdef int id
+    id=0
+
+    for (type,min,max) in izip(self._variables_type,self._variables_bounds_min,self._variables_bounds_max):
+        if type == BINARY:
+            col_lb[id] = 0.0
+            col_ub[id] = 1.0
+        else:
+            if min == None:
+                col_lb[id] = -1.0*si.getInfinity();
+            else:
+                col_lb[id] = float(min)
+
+            if max == None:
+                col_ub[id] = 1.0*si.getInfinity();
+            else:
+                col_ub[id] = float(max)
+        id+=1
+
+
+    # Definition of the problem matrix
+    n_rows = len(self._constraints_bounds_min);
+    cdef c_CoinPackedMatrix * matrix
+    matrix = new_c_CoinPackedMatrix(False, 0, 0);
+    matrix.setDimensions(0, n_cols);
+
+
+    # Upper and lower bounds on the constraints
+    cdef double * row_lb = <double*> sage_malloc(n_rows*sizeof(double))
+    cdef double * row_ub = <double*> sage_malloc(n_rows*sizeof(double))
+
+    # The constraint to be added
+    cdef c_CoinPackedVector* row
+
+    cdef int a
+    a = 0
+
+    for (min,max) in izip(self._constraints_bounds_min,self._constraints_bounds_max):
+        if min == None:
+            row_lb[a] = -1.0*si.getInfinity();
+        else:
+            row_lb[a] = float(min)
+
+        if max == None:
+            row_ub[a] = 1.0*si.getInfinity();
+        else:
+            row_ub[a] = float(max)
+        a += 1
+
+    cdef int last
+    last = 0;
+    row = new_c_CoinPackedVector()
+
+    for (i,j,v) in izip (self._constraints_matrix_i,self._constraints_matrix_j,self._constraints_matrix_values):
+        if i != last:
+            matrix.appendRow(row[0]);
+            row = new_c_CoinPackedVector();
+            last = i
+        row.insert(j, float(v))
+
+    matrix.appendRow(row[0]);
+
+    # Direction of the problem : maximization, minimization...
+    if self._maximization == False:
+        si.setObjSense(1.0)
+    else:
+        si.setObjSense(-1.0)
+
+    # stuff related to the loglevel
+    cdef c_CoinMessageHandler * msg
+    cdef c_CbcModel * model
+    model = si.getModelPtr()
+    msg = model.messageHandler()
+    msg.setLogLevel(log if False != log else log)
+
+    si.assignProblem(matrix, col_lb, col_ub, objective, row_lb, row_ub);
+
+    # Sets variables as integers when needed
+    id = 0;
+    for type in self._variables_type:
+        if type == REAL:
+            si.setContinuous(id)
+        else:
+            si.setInteger(id)
+        id += 1
+
+    # Has there been any problem during the computations ?
+    flag = True
+
+    # Solves the MIP
+    si.branchAndBound();
+
+    cdef const_double_ptr solution
+
+    if si.isAbandoned():
+        flag = True
+        exception_txt = "Coin Branch and Cut: The solver has abandoned!"
+    elif si.isProvenPrimalInfeasible() or si.isProvenDualInfeasible():
+        flag = True
+        exception_txt="Coin Branch and Cut: The problem or its dual has been proven infeasible!"
+    elif si.isPrimalObjectiveLimitReached() or si.isDualObjectiveLimitReached():
+        flag = True
+        exception_txt = "Coin Branch and Cut: The objective limit has been reached for the problem or its dual!"
+    elif si.isIterationLimitReached():
+        flag = True
+        exception_txt = "Coin Branch and Cut: The iteration limit has been reached!"
+    elif si.isProvenOptimal() == True:
+        flag = False
+        return_value = si.getObjValue();
+        if objective_only == False:
+            solution = si.getColSolution();
+
+            # Builds the returned dictionary of values
+            for ((v,id),type) in izip(self._variables.iteritems(),self._variables_type):
+                self._values[v] = solution[id] if type == REAL else round(solution[id])
+
+
+    del_OsiCbcSolverInterface(si)
+    sage_free(objective)
+    sage_free(col_lb)
+    sage_free(col_ub)
+    sage_free(row_lb)
+    sage_free(row_ub)
+    del_CoinPackedMatrix(matrix)
+
+    if flag:
+        from sage.numerical.mip import MIPSolverException
+        raise MIPSolverException(exception_txt)
+    return return_value

new file sage/numerical/mip_glpk.pxd

@@ +1 @@
+cdef extern from *:
+    ctypedef double* const_double_ptr "const double*"
+
+cdef extern from "../../local/include/glpk.h":
+     ctypedef struct c_glp_prob "glp_prob":
+         pass
+     ctypedef struct c_glp_iocp "glp_iocp":
+         int presolve
+         int msg_lev
+     c_glp_iocp *new_c_glp_iocp "new glp_iocp" ()
+     void glp_init_iocp(c_glp_iocp *)
+     c_glp_prob * glp_create_prob()
+     void glp_set_prob_name(c_glp_prob *, char *)
+     void glp_set_obj_dir(c_glp_prob *, int)
+     void glp_add_rows(c_glp_prob *, int)
+     void glp_add_cols(c_glp_prob *, int)
+     void glp_set_row_name(c_glp_prob *, int, char *)
+     void glp_set_col_name(c_glp_prob *, int, char *)
+     void glp_set_row_bnds(c_glp_prob *, int, int, double, double)
+     void glp_set_col_bnds(c_glp_prob *, int, int, double, double)
+     void glp_set_obj_coef(c_glp_prob *, int, double)
+     void glp_load_matrix(c_glp_prob *, int, int *, int *, double *)
+     void glp_simplex(c_glp_prob *, int)
+     void glp_intopt(c_glp_prob *, c_glp_iocp *)
+     int lpx_intopt(c_glp_prob *)
+     void glp_delete_prob(c_glp_prob *)
+     double glp_get_col_prim(c_glp_prob *, int)
+     double glp_get_obj_val(c_glp_prob *)
+     double glp_mip_col_val(c_glp_prob *, int)
+     double glp_mip_obj_val(c_glp_prob *)
+     void glp_set_col_kind(c_glp_prob *, int, int)
+     int glp_write_mps(c_glp_prob *lp, int fmt, void *parm, char *fname)
+     int glp_write_lp(c_glp_prob *lp, void *parm, char *fname)
+     void glp_set_prob_name(c_glp_prob *lp, char *name)
+     void glp_set_obj_name(c_glp_prob *lp, char *name)
+     void glp_set_row_name(c_glp_prob *lp, int i, char *name)
+     void glp_set_col_name(c_glp_prob *lp, int i, char *name)
+     int glp_mip_status(c_glp_prob *lp)
+
+     int GLP_ON
+     int GLP_MAX
+     int GLP_MIN
+     int GLP_UP
+     int GLP_FR
+     int GLP_DB
+     int GLP_FX
+     int GLP_LO
+     int GLP_CV
+     int GLP_IV
+     int GLP_BV
+     int GLP_MSG_OFF
+     int GLP_MSG_ERR
+     int GLP_MSG_ON
+     int GLP_MSG_ALL
+     int GLP_MPS_DECK
+     int GLP_MPS_FILE
+
+     int GLP_UNDEF
+     int GLP_OPT
+     int GLP_FEAS
+     int GLP_NOFEAS

new file sage/numerical/mip_glpk.pyx

@@ +1 @@
+"""
+AUTHOR:
+
+- Nathan Cohen (2009): initial version
+"""
+
+include 'mip_glpk.pxd'
+include '../../../../devel/sage/sage/ext/stdsage.pxi'
+
+cdef int BINARY = 1
+cdef int REAL = -1
+cdef int INTEGER = 0
+
+def solve_glpk(self, log=0, objective_only=False):
+    """
+    Solves the ``MixedIntegerLinearProgram`` using GLPK. 
+    Use ``solve()`` instead.
+
+    INPUT:
+    
+    - ``log`` (integer) -- level of verbosity during the
+      solving process. Set ``log=3`` for maximal verbosity and
+      ``log=0`` for no verbosity at all.
+
+    - ``objective_only`` (boolean) -- Indicates whether the
+      values corresponding to an optimal assignment of the 
+      variables should be computed. Setting ``objective_only``
+      to ``True`` saves some time on the computation when
+      this information is not needed.
+
+    OUTPUT:
+
+    This function returns the optimal value of the objective
+    function given by GLPK.
+    """
+
+    # Raises an exception if no objective has been defined
+    if self._objective_i is None:
+        raise ValueError("No objective function has been defined!")
+
+    # Creates the structures
+    cdef c_glp_prob * lp = glp_create_prob()
+    cdef c_glp_iocp * iocp = new_c_glp_iocp()
+    glp_init_iocp(iocp)
+    
+    # Builds the GLPK version of the problem
+    build_glp_prob(lp, iocp, self,log, False)
+
+    # Solves the problem
+    glp_intopt(lp, iocp)
+    
+    cdef int status = glp_mip_status(lp)
+    if status == GLP_UNDEF:
+        glp_delete_prob(lp)
+        from sage.numerical.mip import MIPSolverException
+        raise MIPSolverException("GLPK : Solution is undefined")
+
+    elif status == GLP_OPT:
+        # Everything is fine !
+        obj = glp_mip_obj_val(lp)
+
+        # If the users is interested in the variables' value
+        # fills self._values
+        if objective_only == False:
+            for (v, id) in self._variables.items():
+                self._values[v] = glp_mip_col_val(lp, id+1) if self._variables_type[id]==REAL else round(glp_mip_col_val(lp, id+1))
+
+        glp_delete_prob(lp)
+        return obj
+
+    elif status == GLP_FEAS:
+        glp_delete_prob(lp)
+        from sage.numerical.mip import MIPSolverException
+        raise MIPSolverException("GLPK : Feasible solution found, while optimality has not been proven")
+
+    elif status == GLP_NOFEAS:
+        glp_delete_prob(lp)
+        from sage.numerical.mip import MIPSolverException
+        raise MIPSolverException("GLPK : There is no feasible integer solution to this Linear Program")
+
+    else:
+        glp_delete_prob(lp)
+        raise ValueError("The value returned by the solver is unknown!")
+
+def write_mps(self, filename,modern=True):
+    """
+    Write the linear program as a MPS file.
+    
+    INPUT:
+    
+    - ``filename`` -- The file in which you want the problem 
+      to be written.
+    - ``modern`` -- Lets you choose between Fixed MPS and Free MPS
+        - ``True`` -- Writes the problem in Free MPS
+        - ``False`` -- Writes the problem in Fixed MPS
+    
+    OUTPUT:
+
+    This function has no output.
+
+    For information about the MPS file format :
+    http://en.wikipedia.org/wiki/MPS_%28format%29
+    """
+
+    # Raises an exception if no objective has been defined
+    if self._objective_i is None:
+        raise ValueError("No objective function has been defined!")
+
+    # Creates the structures
+    cdef c_glp_prob * lp = glp_create_prob()
+    cdef c_glp_iocp * iocp = new_c_glp_iocp()
+    glp_init_iocp(iocp)
+
+    # Builds the GLPK version of the problem
+    build_glp_prob(lp, iocp, self, False, True)
+
+    if modern:
+        glp_write_mps(lp, GLP_MPS_FILE, NULL, filename)
+    else:
+        glp_write_mps(lp, GLP_MPS_DECK, NULL, filename)
+
+def write_lp(self, filename):
+    """
+    Write the linear program as a MPS file.
+    
+    INPUT:
+    
+    - ``filename`` -- The file in which you want the problem 
+      to be written.
+
+    OUTPUT:
+
+    This function has no output.
+
+    For more information about the LP file format :
+    http://lpsolve.sourceforge.net/5.5/lp-format.htm
+    """
+
+    # Raises an exception if no objective has been defined
+    if self._objective_i is None:
+        raise ValueError("No objective function has been defined!")
+
+    # Creates the structures
+    cdef c_glp_prob * lp = glp_create_prob()
+    cdef c_glp_iocp * iocp = new_c_glp_iocp()
+    glp_init_iocp(iocp)
+
+    # Builds the GLPK version of the problem
+    build_glp_prob(lp, iocp, self,False,True)
+
+    glp_write_lp(lp,NULL,filename)
+
+cdef int build_glp_prob(c_glp_prob * lp, c_glp_iocp * iocp, LP, int log, bool names) except -1:
+    """
+    Builds the GLPK structure corresponding to the LP
+
+    INPUT:
+
+    - ``lp`` -- the ``c_glp_prob`` structure to be filled
+    - ``iocp`` -- the ``c_glp_iocp`` structure to be filled
+    - ``LP`` -- The data defining the LP
+    - ``log`` -- integer indicating the level of verbosity
+    - ``names`` -- should the names ( both variables and constraints ) be included
+      in the problem ? ( only useful when the problem is to be written in a file )
+    """
+    glp_add_rows(lp, len(LP._constraints_bounds_max))
+    glp_add_cols(lp, len(LP._variables_bounds_min))
+
+    cdef int * c_matrix_i = <int*> sage_malloc((len(LP._constraints_matrix_i)+1)*sizeof(int))
+    cdef int * c_matrix_j = <int*> sage_malloc((len(LP._constraints_matrix_j)+1)*sizeof(int))
+    cdef double * c_matrix_values = <double*> sage_malloc((len(LP._constraints_matrix_values)+1)*sizeof(double))
+
+    # iterator faster than "for 0<= i < len(LP.constraints.matrix.i)" ?
+
+    cdef int c
+    for c,v in enumerate(LP._constraints_matrix_i):
+        c_matrix_i[c+1]=v+1
+
+    for c,v in enumerate(LP._constraints_matrix_j):
+        c_matrix_j[c+1]=v+1
+
+    for c,v in enumerate(LP._constraints_matrix_values):
+        c_matrix_values[c+1]=v
+
+    glp_load_matrix(lp, len(LP._constraints_matrix_i),c_matrix_i,c_matrix_j,c_matrix_values)
+
+    cdef int i
+    for i in range(len(LP._objective_i)):
+        glp_set_obj_coef(lp, LP._objective_i[i]+1, LP._objective_values[i])
+        
+
+    for i in range(len(LP._variables_bounds_min)):
+        # Upper and lower bounds on the variables
+        if LP._variables_bounds_min[i] is not None and LP._variables_bounds_max[i] is not None:
+            glp_set_col_bnds(lp, i+1, GLP_DB, LP._variables_bounds_min[i], LP._variables_bounds_max[i])
+
+        elif LP._variables_bounds_min[i] is None and LP._variables_bounds_max[i] is not None:
+            glp_set_col_bnds(lp, i+1, GLP_UP, 0, LP._variables_bounds_max[i])
+
+        elif LP._variables_bounds_min[i] is not None and LP._variables_bounds_max[i] is None:
+            glp_set_col_bnds(lp, i+1, GLP_LO, LP._variables_bounds_min[i], 0)
+
+        else:
+            glp_set_col_bnds(lp, i+1, GLP_FR, 0, 0)
+
+        # Types
+        if LP._variables_type[i]==INTEGER:
+            glp_set_col_kind(lp, i+1, GLP_IV)
+
+        elif LP._variables_type[i]==BINARY:
+            glp_set_col_kind(lp, i+1, GLP_BV)
+
+        else:
+            glp_set_col_kind(lp, i+1, GLP_CV)
+
+    for i in range(len(LP._constraints_bounds_max)):
+        if LP._constraints_bounds_min[i] is not None and LP._constraints_bounds_max[i] is not None:
+            if LP._constraints_bounds_min[i] == LP._constraints_bounds_max[i]:
+                glp_set_row_bnds(lp, i+1, GLP_FX, LP._constraints_bounds_min[i], LP._constraints_bounds_max[i])
+            else:
+                glp_set_row_bnds(lp, i+1, GLP_DB, LP._constraints_bounds_min[i], LP._constraints_bounds_max[i])
+
+        elif LP._constraints_bounds_min[i] is None and LP._constraints_bounds_max[i] is not None:
+            glp_set_row_bnds(lp, i+1, GLP_UP, 0, LP._constraints_bounds_max[i])
+
+        elif LP._constraints_bounds_min[i] is not None and LP._constraints_bounds_max[i] is None:
+            glp_set_row_bnds(lp, i+1, GLP_LO, LP._constraints_bounds_min[i], 0)
+
+        else:
+            glp_set_row_bnds(lp, i+1, GLP_FR, 0, 0)        
+
+    # Direction of the problem : maximization, minimization...
+    if LP._maximization is False:
+        glp_set_obj_dir(lp, GLP_MIN)
+    else:
+        glp_set_obj_dir(lp, GLP_MAX)
+
+    # Writing the names if needed
+
+    if names:
+        if LP._name is not None:
+            glp_set_prob_name(lp, LP._name)
+        if LP._objective_name is not None:
+            glp_set_obj_name(lp, LP._objective_name)
+
+        for c,s in enumerate(LP._constraints_name):
+            if s is not None:
+                glp_set_row_name(lp,c+1,s)
+
+        for c,s in enumerate(LP._variables_name):
+            if s is not None:
+                glp_set_col_name(lp,c+1,s)
+    
+    iocp.presolve = GLP_ON
+    # stuff related to the loglevel
+    if log == 0:
+        iocp.msg_lev = GLP_MSG_OFF
+    elif log == 1:
+        iocp.msg_lev = GLP_MSG_ERR
+    elif log == 2:
+        iocp.msg_lev = GLP_MSG_ON
+    else:
+        iocp.msg_lev = GLP_MSG_ALL
+
+    sage_free(c_matrix_i)
+    sage_free(c_matrix_j)
+    sage_free(c_matrix_values)
+    return 0