Ticket #12833: trac_12833.patch

File trac_12833.patch, 57.3 KB (added by ncohen, 9 years ago)
  • sage/graphs/digraph.py

    # HG changeset patch
    # User Nathann Cohen <nathann.cohen@gmail.com>
    # Date 1334234028 -7200
    # Node ID 89d18ab55f9e6be9a4bdafd529f5b26f925098fc
    # Parent  7d8ac0ee679de0e5eeba4966fe280f5f65295472
    Crashes and broken doctests with Gurobi
    
    diff --git a/sage/graphs/digraph.py b/sage/graphs/digraph.py
    a b  
    13141314        - ``verbose`` -- integer (default: ``0``). Sets the level of
    13151315          verbosity. Set to 0 by default, which means quiet.
    13161316
    1317         ALGORITHM: 
     1317        ALGORITHM:
    13181318
    13191319        This problem is solved using Linear Programming, in two different
    13201320        ways. The first one is to solve the following formulation:
    13211321
    13221322        .. MATH::
    13231323
    1324             \mbox{Minimize : }&\sum_{(u,v)\in G} b_{(u,v)}\\ 
    1325             \mbox{Such that : }&\\ 
    1326             &\forall (u,v)\in G, d_u-d_v+nb_{(u,v)}\geq 0\\
     1324            \mbox{Minimize : }&\sum_{(u,v)\in G} b_{(u,v)}\\
     1325            \mbox{Such that : }&\\
     1326            &\forall (u,v)\in G, d_u-d_v+ n \cdot b_{(u,v)}\geq 0\\
    13271327            &\forall u\in G, 0\leq d_u\leq |G|\\
    1328                        
     1328
    13291329        An explanation:
    13301330
    13311331        An acyclic digraph can be seen as a poset, and every poset has a linear
     
    13391339
    13401340        The number of edges removed is then minimized, which is the objective.
    13411341
    1342         (Constraint Generation) 
    1343  
     1342        (Constraint Generation)
     1343
    13441344        If the parameter ``constraint_generation`` is enabled, a more efficient
    13451345        formulation is used :
    1346  
    1347         .. MATH:: 
    1348  
    1349             \mbox{Minimize : }&\sum_{(u,v)\in G} b_{(u,v)}\\ 
    1350             \mbox{Such that : }&\\ 
    1351             &\forall C\text{ circuits }\subseteq G, \sum_{uv\in C}b_{(u,v)}\geq 1\\ 
    1352  
     1346
     1347        .. MATH::
     1348
     1349            \mbox{Minimize : }&\sum_{(u,v)\in G} b_{(u,v)}\\
     1350            \mbox{Such that : }&\\
     1351            &\forall C\text{ circuits }\subseteq G, \sum_{uv\in C}b_{(u,v)}\geq 1\\
     1352
    13531353        As the number of circuits contained in a graph is exponential, this LP
    13541354        is solved through constraint generation. This means that the solver is
    13551355        sequentially asked to solved the problem, knowing only a portion of the
     
    13641364
    13651365            sage: cycle=graphs.CycleGraph(5)
    13661366            sage: dcycle=DiGraph(cycle)
    1367             sage: cycle.size() 
     1367            sage: cycle.size()
    13681368            5
    13691369            sage: dcycle.feedback_edge_set(value_only=True)
    13701370            5
    1371        
     1371
    13721372        And in this situation, for any edge `uv` of the first graph, `uv` of
    13731373        `vu` is in the returned feedback arc set::
    13741374
     
    13791379           sage: (u,v) in feedback or (v,u) in feedback
    13801380           True
    13811381
    1382         TESTS:
    1383  
    1384         Comparing with/without constraint generation::
    1385  
    1386             sage: g = digraphs.RandomDirectedGNP(10,.3)
    1387             sage: x = g.feedback_edge_set(value_only = True)
    1388             sage: y = g.feedback_edge_set(value_only = True,
    1389             ...          constraint_generation = False)
    1390             sage: x == y
    1391             True
     1382        TESTS:
     1383
     1384        Comparing with/without constraint generation. Also double-checks ticket :trac:`12833`::
     1385
     1386            sage: for i in range(20):
     1387            ...      g = digraphs.RandomDirectedGNP(10,.3)
     1388            ...      x = g.feedback_edge_set(value_only = True)
     1389            ...      y = g.feedback_edge_set(value_only = True,
     1390            ...             constraint_generation = False)
     1391            ...      if x != y:
     1392            ...         print "Oh my, oh my !"
     1393            ...         break
    13921394        """
    13931395        # It would be a pity to start a LP if the digraph is already acyclic
    13941396        if self.is_directed_acyclic():
     
    14091411
    14101412            # Variables are binary, and their coefficient in the objective is 1
    14111413
    1412             p.set_objective( Sum( b[u][v] 
     1414            p.set_objective( Sum( b[u][v]
    14131415                                  for u,v in self.edges(labels = False)))
    14141416
    14151417            p.solve(log = verbose)
    14161418
    14171419            # For as long as we do not break because the digraph is
    14181420            # acyclic....
    1419             while (1):
     1421            while True:
    14201422
    14211423                # Building the graph without the edges removed by the LP
    14221424                h = DiGraph()
     
    14261428
    14271429                # Is the digraph acyclic ?
    14281430                isok, certificate = h.is_directed_acyclic(certificate = True)
    1429        
     1431
    14301432                # If so, we are done !
    14311433                if isok:
    14321434                    break
     
    14371439                # There is a circuit left. Let's add the corresponding
    14381440                # constraint !
    14391441
    1440                 p.add_constraint( 
    1441                     Sum( b[u][v] for u,v in 
     1442                p.add_constraint(
     1443                    Sum( b[u][v] for u,v in
    14421444                         zip(certificate, certificate[1:] + [certificate[0]])),
    14431445                    min = 1)
    1444                
     1446
    14451447                obj = p.solve(log = verbose)
    14461448
    14471449            if value_only:
    14481450                return Integer(round(obj))
    1449            
     1451
    14501452            else:
    1451            
     1453
    14521454                # listing the edges contained in the MFAS
    14531455                return [(u,v) for u,v in self.edges(labels = False)
    14541456                        if p.get_values(b[u][v]) > .5]
     
    14581460        ######################################
    14591461        else:
    14601462            p=MixedIntegerLinearProgram(maximization=False, solver=solver)
    1461        
     1463
    14621464            b=p.new_variable(binary = True)
    14631465            d=p.new_variable(integer = True)
    14641466
     
    14681470                p.add_constraint(d[u]-d[v]+n*(b[(u,v)]),min=1)
    14691471
    14701472            for v in self:
    1471                 p.add_constraint(d[v],min=n)
    1472 
     1473                p.add_constraint(d[v] <= n)
    14731474
    14741475            p.set_objective(Sum([b[(u,v)] for (u,v) in self.edges(labels=None)]))
    14751476
     
    14771478                return Integer(round(p.solve(objective_only=True, log=verbose)))
    14781479            else:
    14791480                p.solve(log=verbose)
    1480                
     1481
    14811482                b_sol=p.get_values(b)
    1482                
     1483
    14831484                return [(u,v) for (u,v) in self.edges(labels=None) if b_sol[(u,v)]==1]
    14841485
    14851486    def feedback_vertex_set(self, value_only=False, solver=None, verbose=0, constraint_generation = True):
  • sage/numerical/backends/generic_backend.pyx

    diff --git a/sage/numerical/backends/generic_backend.pyx b/sage/numerical/backends/generic_backend.pyx
    a b  
    818818        - CPLEX (``solver="CPLEX"``). See the
    819819          `CPLEX <http://www.ilog.com/products/cplex/>`_ web site.
    820820
    821         - GUROBI (``solver="GUROBI"``). See the `GUROBI
     821        - Gurobi (``solver="Gurobi"``). See the `Gurobi
    822822          <http://www.gurobi.com/>`_ web site.
    823823
    824824        ``solver`` should then be equal to one of ``"GLPK"``,
    825         ``"Coin"``, ``"CPLEX"``, or ``"GUROBI"``.
     825        ``"Coin"``, ``"CPLEX"``, or ``"Gurobi"``.
    826826
    827827        - If ``solver=None`` (default), the current default solver's name is
    828828          returned.
     
    843843        sage: default_mip_solver("Yeahhhhhhhhhhh")
    844844        Traceback (most recent call last):
    845845        ...
    846         ValueError: 'solver' should be set to 'GLPK', 'Coin', 'CPLEX', 'GUROBI' or None.
     846        ValueError: 'solver' should be set to 'GLPK', 'Coin', 'CPLEX', 'Gurobi' or None.
    847847        sage: default_mip_solver(former_solver)
    848848    """
    849849    global default_solver
     
    854854            return default_solver
    855855
    856856        else:
    857             for s in ["CPLEX", "GUROBI", "Coin", "GLPK"]:
     857            for s in ["CPLEX", "Gurobi", "Coin", "GLPK"]:
    858858                try:
    859859                    default_mip_solver(s)
    860860                    return s
     
    875875        except ImportError:
    876876            raise ValueError("COIN is not available. Please refer to the documentation to install it.")
    877877
    878     elif solver == "GUROBI":
     878    elif solver == "Gurobi":
    879879        try:
    880880            from sage.numerical.backends.gurobi_backend import GurobiBackend
    881881            default_solver = solver
     
    886886        default_solver = solver
    887887
    888888    else:
    889         raise ValueError("'solver' should be set to 'GLPK', 'Coin', 'CPLEX', 'GUROBI' or None.")
     889        raise ValueError("'solver' should be set to 'GLPK', 'Coin', 'CPLEX', 'Gurobi' or None.")
    890890
    891891cpdef GenericBackend get_solver(constraint_generation = False, solver = None):
    892892    """
     
    905905        - CPLEX (``solver="CPLEX"``). See the
    906906          `CPLEX <http://www.ilog.com/products/cplex/>`_ web site.
    907907
    908         - GUROBI (``solver="GUROBI"``). See the `GUROBI
     908        - Gurobi (``solver="Gurobi"``). See the `Gurobi
    909909          <http://www.gurobi.com/>`_ web site.
    910910
    911911        ``solver`` should then be equal to one of ``"GLPK"``, ``"Coin"``,
    912         ``"CPLEX"``, ``"GUROBI"``, or ``None``. If ``solver=None`` (default),
     912        ``"CPLEX"``, ``"Gurobi"``, or ``None``. If ``solver=None`` (default),
    913913        the default solver is used (see ``default_mip_solver`` method.
    914914
    915915    - ``constraint_generation`` (boolean) -- whether the solver
     
    949949        from sage.numerical.backends.cplex_backend import CPLEXBackend
    950950        return CPLEXBackend()
    951951
    952     elif solver == "GUROBI":
     952    elif solver == "Gurobi":
    953953        from sage.numerical.backends.gurobi_backend import GurobiBackend
    954954        return GurobiBackend()
    955955
    956956    else:
    957         raise ValueError("'solver' should be set to 'GLPK', 'Coin', 'CPLEX', 'GUROBI' or None (in which case the default one is used).")
     957        raise ValueError("'solver' should be set to 'GLPK', 'Coin', 'CPLEX', 'Gurobi' or None (in which case the default one is used).")
    958958
    959959
  • sage/numerical/backends/gurobi_backend.pxd

    diff --git a/sage/numerical/backends/gurobi_backend.pxd b/sage/numerical/backends/gurobi_backend.pxd
    a b  
    6161     int GRBsetintparam(GRBenv *env, char * attrname, int value)
    6262
    6363     GRBenv * GRBgetenv (GRBmodel * model )
    64      
     64
    6565
    6666     int GRBgetconstrs (GRBmodel * model, int * numnzP, int * cbeg, int * cind, double * cval, int start, int len )
    6767
     
    9595
    9696    cdef GRBenv * env
    9797    cdef GRBmodel ** model
    98    
     98
    9999    cdef int num_vars
    100100
    101101
  • sage/numerical/backends/gurobi_backend.pyx

    diff --git a/sage/numerical/backends/gurobi_backend.pyx b/sage/numerical/backends/gurobi_backend.pyx
    a b  
    11"""
    22Gurobi Backend
    33
    4 AUTHORS: 
     4AUTHORS:
    55
    66- Nathann Cohen (2011-10): initial implementation
     7
     8TESTS:
     9
     10Bug from :trac:`12833`::
     11
     12    sage: g = DiGraph('IESK@XgAbCgH??KG??')
     13    sage: g.feedback_edge_set(value_only = True, constraint_generation = False)
     14    7
     15    sage: g.feedback_edge_set(value_only = True, constraint_generation = False, solver = "Gurobi") # optional - Gurobi
     16    7
     17
     18Methods
     19-------
    720"""
    821
    922##############################################################################
     
    1629from sage.numerical.mip import MIPSolverException
    1730
    1831cdef class GurobiBackend(GenericBackend):
    19     def __cinit__(self, maximization = True):
     32    def __init__(self, maximization = True):
    2033        """
    2134        Constructor
    2235
    2336        EXAMPLE::
    2437
    25             sage: p = MixedIntegerLinearProgram(solver="Gurobi")            # optional - GUROBI
     38            sage: p = MixedIntegerLinearProgram(solver="Gurobi")            # optional - Gurobi
    2639        """
    27         cdef int error 
     40        cdef int error
    2841
    2942        cdef GRBenv ** env
    3043        env = <GRBenv **> sage_malloc(sizeof(GRBenv *))
    31        
    3244
    3345        error = GRBloadenv(env, NULL)
    3446
    35         if error or (env[0] == NULL):
     47        check(self.env, error)
     48
     49        if env[0] == NULL:
    3650            raise Exception("Could not initialize Gurobi environment")
    3751
    3852        self.model = <GRBmodel **> sage_malloc(sizeof(GRBmodel *))
     53
    3954        error = GRBnewmodel(env[0], self.model, NULL, 0, NULL, NULL, NULL, NULL, NULL)
    4055
    41 
    4256        self.env = GRBgetenv (self.model[0])
    4357
    44 
    4558        if error:
    4659            raise Exception("Could not initialize Gurobi model")
    4760
     
    8295
    8396        - ``name`` - an optional name for the newly added variable (default: ``None``).
    8497
    85         OUTPUT: The index of the newly created variable           
     98        OUTPUT: The index of the newly created variable
    8699
    87100        EXAMPLE::
    88101
    89             sage: from sage.numerical.backends.generic_backend import get_solver # optional - GUROBI
    90             sage: p = get_solver(solver = "Gurobi")                              # optional - GUROBI
    91             sage: p.ncols()                                                      # optional - GUROBI
     102            sage: from sage.numerical.backends.generic_backend import get_solver # optional - Gurobi
     103            sage: p = get_solver(solver = "Gurobi")                              # optional - Gurobi
     104            sage: p.ncols()                                                      # optional - Gurobi
    92105            0
    93             sage: p.add_variable()                                               # optional - GUROBI
     106            sage: p.add_variable()                                               # optional - Gurobi
    94107            0
    95             sage: p.ncols()                                                      # optional - GUROBI
     108            sage: p.ncols()                                                      # optional - Gurobi
    96109            1
    97             sage: p.add_variable(binary=True)                                    # optional - GUROBI
     110            sage: p.add_variable(binary=True)                                    # optional - Gurobi
    98111            1
    99             sage: p.add_variable(lower_bound=-2.0, integer=True)                 # optional - GUROBI
     112            sage: p.add_variable(lower_bound=-2.0, integer=True)                 # optional - Gurobi
    100113            2
    101             sage: p.add_variable(continuous=True, integer=True)                  # optional - GUROBI
     114            sage: p.add_variable(continuous=True, integer=True)                  # optional - Gurobi
    102115            Traceback (most recent call last):
    103116            ...
    104             ValueError: ...           
    105             sage: p.add_variable(name='x',obj=1.0)                               # optional - GUROBI
     117            ValueError: ...
     118            sage: p.add_variable(name='x',obj=1.0)                               # optional - Gurobi
    106119            3
    107             sage: p.col_name(3)                                                  # optional - GUROBI
     120            sage: p.col_name(3)                                                  # optional - Gurobi
    108121            'x'
    109             sage: p.objective_coefficient(3)                                     # optional - GUROBI
     122            sage: p.objective_coefficient(3)                                     # optional - Gurobi
    110123            1.0
    111124        """
    112125        # Checking the input
    113126        cdef char vtype = int(bool(binary)) + int(bool(continuous)) + int(bool(integer))
    114127        if  vtype == 0:
    115             continuous = True           
     128            continuous = True
    116129        elif vtype != 1:
    117130            raise ValueError("Exactly one parameter of 'binary', 'integer' and 'continuous' must be 'True'.")
    118131
     
    125138        elif integer:
    126139            vtype = GRB_INTEGER
    127140
    128         cdef char * c_name = "" 
     141        cdef char * c_name = ""
    129142
    130143        if name is None:
    131144            name = "x_"+str(self.ncols())
     
    136149            upper_bound = GRB_INFINITY
    137150        if lower_bound is None:
    138151            lower_bound = -GRB_INFINITY
    139        
    140        
     152
     153
    141154        error = GRBaddvar(self.model[0], 0, NULL, NULL, obj, <double> lower_bound, <double> upper_bound, vtype, c_name)
    142155
    143156        check(self.env,error)
     
    176189
    177190        EXAMPLE::
    178191
    179             sage: from sage.numerical.backends.generic_backend import get_solver           # optional - GUROBI
    180             sage: p = get_solver(solver = "Gurobi")                                        # optional - GUROBI
    181             sage: p.ncols()                                                                # optional - GUROBI
     192            sage: from sage.numerical.backends.generic_backend import get_solver           # optional - Gurobi
     193            sage: p = get_solver(solver = "Gurobi")                                        # optional - Gurobi
     194            sage: p.ncols()                                                                # optional - Gurobi
    182195            0
    183             sage: p.add_variables(5)                                                       # optional - GUROBI
     196            sage: p.add_variables(5)                                                       # optional - Gurobi
    184197            4
    185             sage: p.ncols()                                                                # optional - GUROBI
     198            sage: p.ncols()                                                                # optional - Gurobi
    186199            5
    187             sage: p.add_variables(2, lower_bound=-2.0, integer=True, names=['a','b'])      # optional - GUROBI
     200            sage: p.add_variables(2, lower_bound=-2.0, integer=True, names=['a','b'])      # optional - Gurobi
    188201            6
    189202        """
    190203        cdef int i
    191204        cdef int value
    192205        for i in range(number):
    193             value = self.add_variable(lower_bound = lower_bound, 
    194                               upper_bound = upper_bound, 
     206            value = self.add_variable(lower_bound = lower_bound,
     207                              upper_bound = upper_bound,
    195208                              binary = binary,
    196209                              continuous = continuous,
    197210                              integer = integer,
     
    233246#                p_types[0] = GRB_BINARY
    234247#            else:
    235248#                p_types[0] = GRB_INTEGER
    236 #               
     249#
    237250#            for i in range(2, number):
    238251#                p_types[i] = p_types[i-1]
    239252#
     
    244257#            for i, name in enumerate(names):
    245258#                p_names[i+1] = p_names[i] + NAME_MAX_LEN
    246259#                p_names[i][0] = str(name)
    247 #               
     260#
    248261#        error = GRBaddvars (self.model[0], number, 0, NULL, NULL, NULL, p_obj, p_lb, p_ub, p_types, p_names)
    249262#
    250263#        # Freeing the memory
     
    279292
    280293        EXAMPLE::
    281294
    282             sage: from sage.numerical.backends.generic_backend import get_solver  # optional - GUROBI
    283             sage: p = get_solver(solver = "Gurobi")                               # optional - GUROBI
    284             sage: p.ncols()                                                       # optional - GUROBI
     295            sage: from sage.numerical.backends.generic_backend import get_solver  # optional - Gurobi
     296            sage: p = get_solver(solver = "Gurobi")                               # optional - Gurobi
     297            sage: p.ncols()                                                       # optional - Gurobi
    285298            0
    286             sage: p.add_variable()                                                # optional - GUROBI
     299            sage: p.add_variable()                                                # optional - Gurobi
    287300            0
    288             sage: p.set_variable_type(0,1)                                        # optional - GUROBI
    289             sage: p.is_variable_integer(0)                                        # optional - GUROBI
     301            sage: p.set_variable_type(0,1)                                        # optional - Gurobi
     302            sage: p.is_variable_integer(0)                                        # optional - Gurobi
    290303            True
    291304        """
    292305        cdef int error
     
    314327
    315328        EXAMPLE::
    316329
    317             sage: from sage.numerical.backends.generic_backend import get_solver   # optional - GUROBI
    318             sage: p = get_solver(solver = "Gurobi")                                # optional - GUROBI
    319             sage: p.is_maximization()                                              # optional - GUROBI
     330            sage: from sage.numerical.backends.generic_backend import get_solver   # optional - Gurobi
     331            sage: p = get_solver(solver = "Gurobi")                                # optional - Gurobi
     332            sage: p.is_maximization()                                              # optional - Gurobi
    320333            True
    321             sage: p.set_sense(-1)                                                  # optional - GUROBI
    322             sage: p.is_maximization()                                              # optional - GUROBI
     334            sage: p.set_sense(-1)                                                  # optional - Gurobi
     335            sage: p.is_maximization()                                              # optional - Gurobi
    323336            False
    324337        """
    325338        cdef int error
     
    345358
    346359        EXAMPLE::
    347360
    348             sage: from sage.numerical.backends.generic_backend import get_solver   # optional - GUROBI
    349             sage: p = get_solver(solver = "Gurobi")                                # optional - GUROBI
    350             sage: p.add_variable()                                                 # optional - GUROBI
     361            sage: from sage.numerical.backends.generic_backend import get_solver   # optional - Gurobi
     362            sage: p = get_solver(solver = "Gurobi")                                # optional - Gurobi
     363            sage: p.add_variable()                                                 # optional - Gurobi
    351364            0
    352             sage: p.objective_coefficient(0) == 0                                  # optional - GUROBI
     365            sage: p.objective_coefficient(0) == 0                                  # optional - Gurobi
    353366            True
    354             sage: p.objective_coefficient(0,2)                                     # optional - GUROBI
    355             sage: p.objective_coefficient(0)                                       # optional - GUROBI
     367            sage: p.objective_coefficient(0,2)                                     # optional - Gurobi
     368            sage: p.objective_coefficient(0)                                       # optional - Gurobi
    356369            2.0
    357370        """
    358371        cdef int error
     
    378391
    379392        EXAMPLE::
    380393
    381             sage: from sage.numerical.backends.generic_backend import get_solver      # optional - GUROBI
    382             sage: p = get_solver(solver = "Gurobi")                                   # optional - GUROBI
    383             sage: p.problem_name("There once was a french fry")                       # optional - GUROBI
    384             sage: print p.problem_name()                                              # optional - GUROBI
     394            sage: from sage.numerical.backends.generic_backend import get_solver      # optional - Gurobi
     395            sage: p = get_solver(solver = "Gurobi")                                   # optional - Gurobi
     396            sage: p.problem_name("There once was a french fry")                       # optional - Gurobi
     397            sage: print p.problem_name()                                              # optional - Gurobi
    385398            There once was a french fry
    386399
    387400        TESTS::
    388401
    389             sage: from sage.numerical.backends.generic_backend import get_solver    # optional - GUROBI
    390             sage: p = get_solver(solver = "Gurobi")                                 # optional - GUROBI
    391             sage: print p.problem_name()                                            # optional - GUROBI
     402            sage: from sage.numerical.backends.generic_backend import get_solver    # optional - Gurobi
     403            sage: p = get_solver(solver = "Gurobi")                                 # optional - Gurobi
     404            sage: print p.problem_name()                                            # optional - Gurobi
    392405        """
    393406        cdef int error
    394407        cdef char * pp_name[1]
     
    397410            error = GRBsetstrattr(self.model[0], "ModelName", name)
    398411            check(self.env, error)
    399412            check(self.env,GRBupdatemodel(self.model[0]))
    400        
     413
    401414        else:
    402415            check(self.env,GRBgetstrattr(self.model[0], "ModelName", <char **> pp_name))
    403416            if pp_name[0] == NULL:
     
    405418            else:
    406419                value = str(pp_name[0])
    407420
    408             return value       
     421            return value
    409422
    410423    cpdef set_objective(self, list coeff):
    411424        """
     
    418431
    419432        EXAMPLE::
    420433
    421             sage: from sage.numerical.backends.generic_backend import get_solver     # optional - GUROBI
    422             sage: p = get_solver(solver = "Gurobi")                                  # optional - GUROBI
    423             sage: p.add_variables(5)                                                 # optional - GUROBI
     434            sage: from sage.numerical.backends.generic_backend import get_solver     # optional - Gurobi
     435            sage: p = get_solver(solver = "Gurobi")                                  # optional - Gurobi
     436            sage: p.add_variables(5)                                                 # optional - Gurobi
    424437            4
    425             sage: p.set_objective([1, 1, 2, 1, 3])                                   # optional - GUROBI
    426             sage: map(lambda x :p.objective_coefficient(x), range(5))                # optional - GUROBI
     438            sage: p.set_objective([1, 1, 2, 1, 3])                                   # optional - Gurobi
     439            sage: map(lambda x :p.objective_coefficient(x), range(5))                # optional - Gurobi
    427440            [1.0, 1.0, 2.0, 1.0, 3.0]
    428441        """
    429442        cdef int i = 0
    430443        cdef double value
    431444        cdef int error
    432        
     445
    433446        for value in coeff:
    434447            error = GRBsetdblattrelement (self.model[0], "Obj", i, value)
    435448            check(self.env,error)
     
    447460
    448461        EXAMPLE::
    449462
    450             sage: from sage.numerical.backends.generic_backend import get_solver   # optional - GUROBI
    451             sage: p = get_solver(solver = "Gurobi")                                # optional - GUROBI
    452             sage: p.set_verbosity(2)                                               # optional - GUROBI
     463            sage: from sage.numerical.backends.generic_backend import get_solver   # optional - Gurobi
     464            sage: p = get_solver(solver = "Gurobi")                                # optional - Gurobi
     465            sage: p.set_verbosity(2)                                               # optional - Gurobi
    453466
    454467        """
    455468        cdef int error
     
    475488        - ``upper_bound`` - an upper bound, either a real value or ``None``
    476489
    477490        - ``name`` - an optional name for this row (default: ``None``)
    478  
     491
    479492        EXAMPLE::
    480493
    481             sage: from sage.numerical.backends.generic_backend import get_solver          # optional - GUROBI
    482             sage: p = get_solver(solver = "Gurobi")                                       # optional - GUROBI
    483             sage: p.add_variables(5)                                                      # optional - GUROBI
     494            sage: from sage.numerical.backends.generic_backend import get_solver          # optional - Gurobi
     495            sage: p = get_solver(solver = "Gurobi")                                       # optional - Gurobi
     496            sage: p.add_variables(5)                                                      # optional - Gurobi
    484497            4
    485             sage: p.add_linear_constraint( zip(range(5), range(5)), 2.0, 2.0)             # optional - GUROBI
    486             sage: p.row(0)                                                                # optional - GUROBI
     498            sage: p.add_linear_constraint( zip(range(5), range(5)), 2.0, 2.0)             # optional - Gurobi
     499            sage: p.row(0)                                                                # optional - Gurobi
    487500            ([0, 1, 2, 3, 4], [0.0, 1.0, 2.0, 3.0, 4.0])
    488             sage: p.row_bounds(0)                                                         # optional - GUROBI
     501            sage: p.row_bounds(0)                                                         # optional - Gurobi
    489502            (2.0, 2.0)
    490             sage: p.add_linear_constraint( zip(range(5), range(5)), 1.0, 1.0, name='foo') # optional - GUROBI
    491             sage: p.row_name(1)                                                           # optional - GUROBI
     503            sage: p.add_linear_constraint( zip(range(5), range(5)), 1.0, 1.0, name='foo') # optional - Gurobi
     504            sage: p.row_name(1)                                                           # optional - Gurobi
    492505            'foo'
    493506        """
    494507
     
    500513
    501514        row_i = <int *> sage_malloc((len(coefficients)) * sizeof(int))
    502515        row_values = <double *> sage_malloc((len(coefficients)) * sizeof(double))
    503        
     516
    504517
    505518        for i,(c,v) in enumerate(coefficients):
    506519            row_i[i] = c
     
    523536                error = GRBaddrangeconstr(self.model[0], len(coefficients), row_i, row_values, <double> lower_bound, <double> upper_bound, name)
    524537
    525538        check(self.env,error)
    526        
     539
    527540        error = GRBupdatemodel(self.model[0])
    528541
    529542        check(self.env,error)
     
    548561
    549562        EXAMPLE::
    550563
    551             sage: from sage.numerical.backends.generic_backend import get_solver   # optional - GUROBI
    552             sage: p = get_solver(solver = "Gurobi")                                # optional - GUROBI
    553             sage: p.add_variables(5)                                               # optional - GUROBI
     564            sage: from sage.numerical.backends.generic_backend import get_solver   # optional - Gurobi
     565            sage: p = get_solver(solver = "Gurobi")                                # optional - Gurobi
     566            sage: p.add_variables(5)                                               # optional - Gurobi
    554567            4
    555             sage: p.add_linear_constraint(zip(range(5), range(5)), 2, 2)           # optional - GUROBI
    556             sage: p.row(0)                                                         # optional - GUROBI
     568            sage: p.add_linear_constraint(zip(range(5), range(5)), 2, 2)           # optional - Gurobi
     569            sage: p.row(0)                                                         # optional - Gurobi
    557570            ([0, 1, 2, 3, 4], [0.0, 1.0, 2.0, 3.0, 4.0])
    558             sage: p.row_bounds(0)                                                  # optional - GUROBI
     571            sage: p.row_bounds(0)                                                  # optional - Gurobi
    559572            (2.0, 2.0)
    560573        """
    561574        cdef int error
     
    564577        cdef int length[1]
    565578        error =  GRBgetconstrs(self.model[0], length, NULL, NULL, NULL, index, 1 )
    566579        check(self.env,error)
    567        
     580
    568581        cdef int * p_indices = <int *> sage_malloc(length[0] * sizeof(int))
    569582        cdef double * p_values = <double *> sage_malloc(length[0] * sizeof(double))
    570        
     583
    571584        error =  GRBgetconstrs(self.model[0], length, <int *> fake, p_indices, p_values, index, 1 )
    572585        check(self.env,error)
    573586
     
    581594
    582595        sage_free(p_indices)
    583596        sage_free(p_values)
    584        
     597
    585598        return indices, values
    586599
    587600
     
    601614
    602615        EXAMPLE::
    603616
    604             sage: from sage.numerical.backends.generic_backend import get_solver    # optional - GUROBI
    605             sage: p = get_solver(solver = "Gurobi")                                 # optional - GUROBI
    606             sage: p.add_variables(5)                                                # optional - GUROBI
     617            sage: from sage.numerical.backends.generic_backend import get_solver    # optional - Gurobi
     618            sage: p = get_solver(solver = "Gurobi")                                 # optional - Gurobi
     619            sage: p.add_variables(5)                                                # optional - Gurobi
    607620            4
    608             sage: p.add_linear_constraint(zip(range(5), range(5)), 2, 2)            # optional - GUROBI
    609             sage: p.row(0)                                                          # optional - GUROBI
     621            sage: p.add_linear_constraint(zip(range(5), range(5)), 2, 2)            # optional - Gurobi
     622            sage: p.row(0)                                                          # optional - Gurobi
    610623            ([0, 1, 2, 3, 4], [0.0, 1.0, 2.0, 3.0, 4.0])
    611             sage: p.row_bounds(0)                                                   # optional - GUROBI
     624            sage: p.row_bounds(0)                                                   # optional - Gurobi
    612625            (2.0, 2.0)
    613626        """
    614627        cdef double d[1]
     
    644657
    645658        EXAMPLE::
    646659
    647             sage: from sage.numerical.backends.generic_backend import get_solver    # optional - GUROBI
    648             sage: p = get_solver(solver = "Gurobi")                                 # optional - GUROBI
    649             sage: p.add_variable()                                                  # optional - GUROBI
     660            sage: from sage.numerical.backends.generic_backend import get_solver    # optional - Gurobi
     661            sage: p = get_solver(solver = "Gurobi")                                 # optional - Gurobi
     662            sage: p.add_variable()                                                  # optional - Gurobi
    650663            0
    651             sage: p.col_bounds(0)                                                   # optional - GUROBI
     664            sage: p.col_bounds(0)                                                   # optional - Gurobi
    652665            (0.0, None)
    653             sage: p.variable_upper_bound(0, 5)                                      # optional - GUROBI
    654             sage: p.col_bounds(0)                                                   # optional - GUROBI
     666            sage: p.variable_upper_bound(0, 5)                                      # optional - Gurobi
     667            sage: p.col_bounds(0)                                                   # optional - Gurobi
    655668            (0.0, 5.0)
    656669        """
    657670
     
    660673        error = GRBgetdblattrelement(self.model[0], "LB", index, <double *> lb)
    661674        check(self.env, error)
    662675
    663 
    664676        error = GRBgetdblattrelement(self.model[0], "UB", index, <double *> ub)
    665677        check(self.env, error)
    666678
    667679        return (None if lb[0] <= -2147483647 else lb[0],
    668                 None if  (<int> ub[0]) >= 2147483647 else ub[0])
     680                None if  ub[0] >= 2147483647 else ub[0])
    669681
    670682    cpdef int solve(self) except -1:
    671683        """
     
    679691
    680692        EXAMPLE::
    681693
    682             sage: from sage.numerical.backends.generic_backend import get_solver  # optional - GUROBI
    683             sage: p = get_solver(solver = "Gurobi")                               # optional - GUROBI
    684             sage: p.add_variables(5)                                              # optional - GUROBI
     694            sage: from sage.numerical.backends.generic_backend import get_solver  # optional - Gurobi
     695            sage: p = get_solver(solver = "Gurobi")                               # optional - Gurobi
     696            sage: p.add_variables(5)                                              # optional - Gurobi
    685697            4
    686             sage: p.add_linear_constraint([(0,1), (1, 1)], 1.2, 1.7)              # optional - GUROBI
    687             sage: p.set_variable_type(0, 1)                                       # optional - GUROBI
    688             sage: p.set_variable_type(1, 1)                                       # optional - GUROBI
    689             sage: p.solve()                                                       # optional - GUROBI
     698            sage: p.add_linear_constraint([(0,1), (1, 1)], 1.2, 1.7)              # optional - Gurobi
     699            sage: p.set_variable_type(0, 1)                                       # optional - Gurobi
     700            sage: p.set_variable_type(1, 1)                                       # optional - Gurobi
     701            sage: p.solve()                                                       # optional - Gurobi
    690702            Traceback (most recent call last):
    691703            ...
    692704            MIPSolverException: 'Gurobi: The problem is infeasible'
    693705        """
    694706        cdef int error
    695707        global mip_status
    696        
     708
    697709        check(self.env, GRBoptimize(self.model[0]))
    698710
    699711        cdef int status[1]
     
    714726
    715727        EXAMPLE::
    716728
    717             sage: from sage.numerical.backends.generic_backend import get_solver  # optional - GUROBI
    718             sage: p = get_solver(solver = "Gurobi")                               # optional - GUROBI
    719             sage: p.add_variables(2)                                              # optional - GUROBI
     729            sage: from sage.numerical.backends.generic_backend import get_solver  # optional - Gurobi
     730            sage: p = get_solver(solver = "Gurobi")                               # optional - Gurobi
     731            sage: p.add_variables(2)                                              # optional - Gurobi
    720732            1
    721             sage: p.add_linear_constraint([[0, 1], [1, 2]], None, 3)              # optional - GUROBI
    722             sage: p.set_objective([2, 5])                                         # optional - GUROBI
    723             sage: p.solve()                                                       # optional - GUROBI
     733            sage: p.add_linear_constraint([[0, 1], [1, 2]], None, 3)              # optional - Gurobi
     734            sage: p.set_objective([2, 5])                                         # optional - Gurobi
     735            sage: p.solve()                                                       # optional - Gurobi
    724736            0
    725             sage: p.get_objective_value()                                         # optional - GUROBI
     737            sage: p.get_objective_value()                                         # optional - Gurobi
    726738            7.5
    727             sage: p.get_variable_value(0)                                         # optional - GUROBI
     739            sage: p.get_variable_value(0)                                         # optional - Gurobi
    728740            0.0
    729             sage: p.get_variable_value(1)                                         # optional - GUROBI
     741            sage: p.get_variable_value(1)                                         # optional - Gurobi
    730742            1.5
    731743        """
    732744        cdef double p_value[1]
    733        
     745
    734746        check(self.env,GRBgetdblattr(self.model[0], "ObjVal", <double* >p_value))
    735747
    736748        return p_value[0]
     
    745757
    746758        EXAMPLE::
    747759
    748             sage: from sage.numerical.backends.generic_backend import get_solver   # optional - GUROBI
    749             sage: p = get_solver(solver = "Gurobi")                                # optional - GUROBI
    750             sage: p.add_variables(2)                                               # optional - GUROBI
     760            sage: from sage.numerical.backends.generic_backend import get_solver   # optional - Gurobi
     761            sage: p = get_solver(solver = "Gurobi")                                # optional - Gurobi
     762            sage: p.add_variables(2)                                               # optional - Gurobi
    751763            1
    752             sage: p.add_linear_constraint([[0, 1], [1, 2]], None, 3)               # optional - GUROBI
    753             sage: p.set_objective([2, 5])                                          # optional - GUROBI
    754             sage: p.solve()                                                        # optional - GUROBI
     764            sage: p.add_linear_constraint([[0, 1], [1, 2]], None, 3)               # optional - Gurobi
     765            sage: p.set_objective([2, 5])                                          # optional - Gurobi
     766            sage: p.solve()                                                        # optional - Gurobi
    755767            0
    756             sage: p.get_objective_value()                                          # optional - GUROBI
     768            sage: p.get_objective_value()                                          # optional - Gurobi
    757769            7.5
    758             sage: p.get_variable_value(0)                                          # optional - GUROBI
     770            sage: p.get_variable_value(0)                                          # optional - Gurobi
    759771            0.0
    760             sage: p.get_variable_value(1)                                          # optional - GUROBI
     772            sage: p.get_variable_value(1)                                          # optional - Gurobi
    761773            1.5
    762774        """
    763775
     
    771783
    772784        EXAMPLE::
    773785
    774             sage: from sage.numerical.backends.generic_backend import get_solver  # optional - GUROBI
    775             sage: p = get_solver(solver = "Gurobi")                               # optional - GUROBI
    776             sage: p.ncols()                                                       # optional - GUROBI
     786            sage: from sage.numerical.backends.generic_backend import get_solver  # optional - Gurobi
     787            sage: p = get_solver(solver = "Gurobi")                               # optional - Gurobi
     788            sage: p.ncols()                                                       # optional - Gurobi
    777789            0
    778             sage: p.add_variables(2)                                              # optional - GUROBI
     790            sage: p.add_variables(2)                                              # optional - Gurobi
    779791            1
    780             sage: p.ncols()                                                       # optional - GUROBI
     792            sage: p.ncols()                                                       # optional - Gurobi
    781793            2
    782794        """
    783795        cdef int i[1]
     
    790802
    791803        EXAMPLE::
    792804
    793             sage: from sage.numerical.backends.generic_backend import get_solver # optional - GUROBI
    794             sage: p = get_solver(solver = "Gurobi")                              # optional - GUROBI
    795             sage: p.nrows()                                                      # optional - GUROBI
     805            sage: from sage.numerical.backends.generic_backend import get_solver # optional - Gurobi
     806            sage: p = get_solver(solver = "Gurobi")                              # optional - Gurobi
     807            sage: p.nrows()                                                      # optional - Gurobi
    796808            0
    797             sage: p.add_linear_constraint([], 2, None)                           # optional - GUROBI
    798             sage: p.add_linear_constraint([], 2, None)                           # optional - GUROBI
    799             sage: p.nrows()                                                      # optional - GUROBI
     809            sage: p.add_linear_constraint([], 2, None)                           # optional - Gurobi
     810            sage: p.add_linear_constraint([], 2, None)                           # optional - Gurobi
     811            sage: p.nrows()                                                      # optional - Gurobi
    800812            2
    801813        """
    802814        cdef int i[1]
     
    813825
    814826        EXAMPLE::
    815827
    816             sage: from sage.numerical.backends.generic_backend import get_solver  # optional - GUROBI
    817             sage: p = get_solver(solver = "Gurobi")                               # optional - GUROBI
    818             sage: p.add_variable(name='I am a variable')                          # optional - GUROBI
     828            sage: from sage.numerical.backends.generic_backend import get_solver  # optional - Gurobi
     829            sage: p = get_solver(solver = "Gurobi")                               # optional - Gurobi
     830            sage: p.add_variable(name='I am a variable')                          # optional - Gurobi
    819831            0
    820             sage: p.col_name(0)                                                   # optional - GUROBI
     832            sage: p.col_name(0)                                                   # optional - Gurobi
    821833            'I am a variable'
    822834        """
    823835        cdef char * name[1]
     
    838850
    839851        EXAMPLE::
    840852
    841             sage: from sage.numerical.backends.generic_backend import get_solver  # optional - GUROBI
    842             sage: p = get_solver(solver = "Gurobi")                               # optional - GUROBI
    843             sage: p.add_linear_constraint([], 2, None, name='Empty constraint 1') # optional - GUROBI
    844             sage: p.row_name(0)                                                   # optional - GUROBI
     853            sage: from sage.numerical.backends.generic_backend import get_solver  # optional - Gurobi
     854            sage: p = get_solver(solver = "Gurobi")                               # optional - Gurobi
     855            sage: p.add_linear_constraint([], 2, None, name='Empty constraint 1') # optional - Gurobi
     856            sage: p.row_name(0)                                                   # optional - Gurobi
    845857            'Empty constraint 1'
    846858        """
    847859        cdef char * name[1]
     
    862874
    863875        EXAMPLE::
    864876
    865             sage: from sage.numerical.backends.generic_backend import get_solver   # optional - GUROBI
    866             sage: p = get_solver(solver = "Gurobi")                                # optional - GUROBI
    867             sage: p.ncols()                                                        # optional - GUROBI
     877            sage: from sage.numerical.backends.generic_backend import get_solver   # optional - Gurobi
     878            sage: p = get_solver(solver = "Gurobi")                                # optional - Gurobi
     879            sage: p.ncols()                                                        # optional - Gurobi
    868880            0
    869             sage: p.add_variable()                                                 # optional - GUROBI
     881            sage: p.add_variable()                                                 # optional - Gurobi
    870882            0
    871             sage: p.set_variable_type(0,0)                                         # optional - GUROBI
    872             sage: p.is_variable_binary(0)                                          # optional - GUROBI
     883            sage: p.set_variable_type(0,0)                                         # optional - Gurobi
     884            sage: p.is_variable_binary(0)                                          # optional - Gurobi
    873885            True
    874886        """
    875887        cdef char vtype[1]
     
    887899
    888900        EXAMPLE::
    889901
    890             sage: from sage.numerical.backends.generic_backend import get_solver  # optional - GUROBI
    891             sage: p = get_solver(solver = "Gurobi")                               # optional - GUROBI
    892             sage: p.ncols()                                                       # optional - GUROBI
     902            sage: from sage.numerical.backends.generic_backend import get_solver  # optional - Gurobi
     903            sage: p = get_solver(solver = "Gurobi")                               # optional - Gurobi
     904            sage: p.ncols()                                                       # optional - Gurobi
    893905            0
    894             sage: p.add_variable()                                                # optional - GUROBI
     906            sage: p.add_variable()                                                # optional - Gurobi
    895907            0
    896             sage: p.set_variable_type(0,1)                                        # optional - GUROBI
    897             sage: p.is_variable_integer(0)                                        # optional - GUROBI
     908            sage: p.set_variable_type(0,1)                                        # optional - Gurobi
     909            sage: p.is_variable_integer(0)                                        # optional - Gurobi
    898910            True
    899911        """
    900912        cdef char vtype[1]
     
    911923
    912924        EXAMPLE::
    913925
    914             sage: from sage.numerical.backends.generic_backend import get_solver   # optional - GUROBI
    915             sage: p = get_solver(solver = "Gurobi")                                # optional - GUROBI
    916             sage: p.ncols()                                                        # optional - GUROBI
     926            sage: from sage.numerical.backends.generic_backend import get_solver   # optional - Gurobi
     927            sage: p = get_solver(solver = "Gurobi")                                # optional - Gurobi
     928            sage: p.ncols()                                                        # optional - Gurobi
    917929            0
    918             sage: p.add_variable()                                                 # optional - GUROBI
     930            sage: p.add_variable()                                                 # optional - Gurobi
    919931            0
    920             sage: p.is_variable_continuous(0)                                      # optional - GUROBI
     932            sage: p.is_variable_continuous(0)                                      # optional - Gurobi
    921933            True
    922             sage: p.set_variable_type(0,1)                                         # optional - GUROBI
    923             sage: p.is_variable_continuous(0)                                      # optional - GUROBI
     934            sage: p.set_variable_type(0,1)                                         # optional - Gurobi
     935            sage: p.is_variable_continuous(0)                                      # optional - Gurobi
    924936            False
    925937
    926938        """
     
    934946
    935947        EXAMPLE::
    936948
    937             sage: from sage.numerical.backends.generic_backend import get_solver    # optional - GUROBI
    938             sage: p = get_solver(solver = "Gurobi")                                 # optional - GUROBI
    939             sage: p.is_maximization()                                               # optional - GUROBI
     949            sage: from sage.numerical.backends.generic_backend import get_solver    # optional - Gurobi
     950            sage: p = get_solver(solver = "Gurobi")                                 # optional - Gurobi
     951            sage: p.is_maximization()                                               # optional - Gurobi
    940952            True
    941             sage: p.set_sense(-1)                                                   # optional - GUROBI
    942             sage: p.is_maximization()                                               # optional - GUROBI
     953            sage: p.set_sense(-1)                                                   # optional - Gurobi
     954            sage: p.is_maximization()                                               # optional - Gurobi
    943955            False
    944956        """
    945957        cdef int sense[1]
     
    960972
    961973        EXAMPLE::
    962974
    963             sage: from sage.numerical.backends.generic_backend import get_solver    # optional - GUROBI
    964             sage: p = get_solver(solver = "Gurobi")                                 # optional - GUROBI
    965             sage: p.add_variable()                                                  # optional - GUROBI
     975            sage: from sage.numerical.backends.generic_backend import get_solver    # optional - Gurobi
     976            sage: p = get_solver(solver = "Gurobi")                                 # optional - Gurobi
     977            sage: p.add_variable()                                                  # optional - Gurobi
    966978            0
    967             sage: p.col_bounds(0)                                                   # optional - GUROBI
     979            sage: p.col_bounds(0)                                                   # optional - Gurobi
    968980            (0.0, None)
    969             sage: p.variable_upper_bound(0, 5)                                      # optional - GUROBI
    970             sage: p.col_bounds(0)                                                   # optional - GUROBI
     981            sage: p.variable_upper_bound(0, 5)                                      # optional - Gurobi
     982            sage: p.col_bounds(0)                                                   # optional - Gurobi
    971983            (0.0, 5.0)
    972984        """
    973985        cdef double b[1]
    974986
    975987        if not value is False:
    976988            check(self.env, GRBsetdblattrelement(
    977                     self.model[0], "UB", 
    978                     index, 
     989                    self.model[0], "UB",
     990                    index,
    979991                    value if value is not None else GRB_INFINITY))
    980992
    981993            check(self.env,GRBupdatemodel(self.model[0]))
     
    9981010
    9991011        EXAMPLE::
    10001012
    1001             sage: from sage.numerical.backends.generic_backend import get_solver    # optional - GUROBI
    1002             sage: p = get_solver(solver = "Gurobi")                                 # optional - GUROBI
    1003             sage: p.add_variable()                                                  # optional - GUROBI
     1013            sage: from sage.numerical.backends.generic_backend import get_solver    # optional - Gurobi
     1014            sage: p = get_solver(solver = "Gurobi")                                 # optional - Gurobi
     1015            sage: p.add_variable()                                                  # optional - Gurobi
    10041016            0
    1005             sage: p.col_bounds(0)                                                   # optional - GUROBI
     1017            sage: p.col_bounds(0)                                                   # optional - Gurobi
    10061018            (0.0, None)
    1007             sage: p.variable_lower_bound(0, 5)                                      # optional - GUROBI
    1008             sage: p.col_bounds(0)                                                   # optional - GUROBI
     1019            sage: p.variable_lower_bound(0, 5)                                      # optional - Gurobi
     1020            sage: p.col_bounds(0)                                                   # optional - Gurobi
    10091021            (5.0, None)
    10101022        """
    10111023        cdef double b[1]
    10121024
    1013        
     1025
    10141026        if not value is False:
    10151027            check(self.env, GRBsetdblattrelement(
    1016                     self.model[0], "LB", 
    1017                     index, 
     1028                    self.model[0], "LB",
     1029                    index,
    10181030                    value if value is not None else -GRB_INFINITY))
    10191031
    10201032            check(self.env,GRBupdatemodel(self.model[0]))
     
    10291041        Write the problem to a .lp file
    10301042
    10311043        INPUT:
    1032        
     1044
    10331045        - ``filename`` (string)
    10341046
    10351047        EXAMPLE::
    10361048
    1037             sage: from sage.numerical.backends.generic_backend import get_solver    # optional - GUROBI
    1038             sage: p = get_solver(solver = "Gurobi")                                 # optional - GUROBI
    1039             sage: p.add_variables(2)                                                # optional - GUROBI
     1049            sage: from sage.numerical.backends.generic_backend import get_solver    # optional - Gurobi
     1050            sage: p = get_solver(solver = "Gurobi")                                 # optional - Gurobi
     1051            sage: p.add_variables(2)                                                # optional - Gurobi
    10401052            1
    1041             sage: p.add_linear_constraint([[0, 1], [1, 2]], None, 3)                # optional - GUROBI
    1042             sage: p.set_objective([2, 5])                                           # optional - GUROBI
    1043             sage: p.write_lp(SAGE_TMP+"/lp_problem.lp")                             # optional - GUROBI
     1053            sage: p.add_linear_constraint([[0, 1], [1, 2]], None, 3)                # optional - Gurobi
     1054            sage: p.set_objective([2, 5])                                           # optional - Gurobi
     1055            sage: p.write_lp(SAGE_TMP+"/lp_problem.lp")                             # optional - Gurobi
    10441056        """
    10451057        check(self.env, GRBwrite(self.model[0], filename))
    10461058
     
    10491061        Write the problem to a .mps file
    10501062
    10511063        INPUT:
    1052        
     1064
    10531065        - ``filename`` (string)
    10541066
    10551067        EXAMPLE::
    10561068
    1057             sage: from sage.numerical.backends.generic_backend import get_solver    # optional - GUROBI
    1058             sage: p = get_solver(solver = "Gurobi")                                 # optional - GUROBI
    1059             sage: p.add_variables(2)                                                # optional - GUROBI
     1069            sage: from sage.numerical.backends.generic_backend import get_solver    # optional - Gurobi
     1070            sage: p = get_solver(solver = "Gurobi")                                 # optional - Gurobi
     1071            sage: p.add_variables(2)                                                # optional - Gurobi
    10601072            1
    1061             sage: p.add_linear_constraint([[0, 1], [1, 2]], None, 3)                # optional - GUROBI
    1062             sage: p.set_objective([2, 5])                                           # optional - GUROBI
    1063             sage: p.write_lp(SAGE_TMP+"/lp_problem.lp")                             # optional - GUROBI
     1073            sage: p.add_linear_constraint([[0, 1], [1, 2]], None, 3)                # optional - Gurobi
     1074            sage: p.set_objective([2, 5])                                           # optional - Gurobi
     1075            sage: p.write_lp(SAGE_TMP+"/lp_problem.lp")                             # optional - Gurobi
    10641076        """
    10651077        check(self.env, GRBwrite(self.model[0], filename))
    10661078
     
    10681080        """
    10691081        Destructor
    10701082        """
    1071         GRBfreemodel(self.model[0])
     1083        if self.model != NULL:
     1084            GRBfreemodel(self.model[0])
    10721085
    10731086
    10741087cdef dict errors = {
  • sage/numerical/mip.pyx

    diff --git a/sage/numerical/mip.pyx b/sage/numerical/mip.pyx
    a b  
    456456        others.
    457457
    458458        ``lower_bound`` and ``upper_bound`` are numerical values.
    459        
     459
    460460        EXAMPLE:
    461461
    462462        First, let us define a small LP::
     
    526526            for i in indices:
    527527                lb, ub = b.row_bounds(i)
    528528                result.append((lb, b.row(i), ub))
    529        
     529
    530530            return result
    531531
    532532        # Weird Input
     
    576576        cdef GenericBackend b = self._backend
    577577
    578578        # inv_variables associates a MIPVariable object to an id
    579         inv_variables = [0]*len(self._variables)
     579        inv_variables = {}
     580
    580581        for (v, id) in self._variables.iteritems():
    581582            inv_variables[id]=v
    582583
    583 
    584584        # varid_name associates variables id to names
    585585        varid_name = {}
    586586
     
    592592
    593593        print ("Maximization:" if b.is_maximization() else "Minimization:")
    594594        print " ",
    595        
     595
    596596        first = True
    597597        for 0<= i< b.ncols():
    598598            c = b.objective_coefficient(i)
     
    14931493
    14941494              The command ::
    14951495
    1496                   sage: p.solver_parameter("CPX_PARAM_TILIM", 60) # optional - CPLEX
     1496                  sage: p = MixedIntegerLinearProgram(solver = "CPLEX") # optional - CPLEX
     1497                  sage: p.solver_parameter("CPX_PARAM_TILIM", 60)       # optional - CPLEX
    14971498
    14981499              works as intended.
    14991500