Ticket #10341: mip_interface_changes.patch

File mip_interface_changes.patch, 58.9 KB (added by malb, 11 years ago)
  • sage/numerical/backends/generic_backend.pxd

    # HG changeset patch
    # User Martin Albrecht <martinralbrecht@googlemail.com>
    # Date 1290790091 0
    # Node ID 073e4cbe35f34c2fc57f553a1d38c8bacb61ccda
    # Parent  cbaf095a0f0ddc36eb4bfdad562859879187c5de
    making the MIP backend interface more pythonic
    
    diff -r cbaf095a0f0d -r 073e4cbe35f3 sage/numerical/backends/generic_backend.pxd
    a b  
    66##############################################################################
    77
    88cdef class GenericBackend:
    9     cpdef int add_variable(self)
    10     cpdef int add_variables(self, int)
     9    cpdef int add_variable(self, lower_bound=*, upper_bound=*, binary=*, continuous=*, integer=*) except -1
     10    cpdef int add_variables(self, int, lower_bound=*, upper_bound=*, binary=*, continuous=*, integer=*) except -1
    1111    cpdef set_variable_type(self, int variable, int vtype)
    1212    cpdef set_sense(self, int sense)
    1313    cpdef set_objective_coefficient(self, int variable, double coeff)
    1414    cpdef set_objective(self, list coeff)
    1515    cpdef set_verbosity(self, int level)
    16     cpdef add_linear_constraint(self, list indices, list coeffs, int direction, double bound)
     16    cpdef add_linear_constraint(self, constraints, lower_bound, upper_bound)
    1717    cpdef add_col(self, list indices, list coeffs)
    18     cpdef add_linear_constraints(self, int number, int direction, double bound)
     18    cpdef add_linear_constraints(self, int number, lower_bound, upper_bound)
    1919    cpdef int solve(self) except -1
    2020    cpdef double get_objective_value(self)
    2121    cpdef double get_variable_value(self, int variable)
     
    3636    cpdef col_bounds(self, int index)
    3737    cpdef row_name(self, int index, char * name = *)
    3838    cpdef col_name(self, int index, char * name = *)
    39     cpdef variable_max(self, int index, value = *)
    40     cpdef variable_min(self, int index, value = *)
     39    cpdef variable_upper_bound(self, int index, value = *)
     40    cpdef variable_lower_bound(self, int index, value = *)
    4141
  • sage/numerical/backends/generic_backend.pyx

    diff -r cbaf095a0f0d -r 073e4cbe35f3 sage/numerical/backends/generic_backend.pyx
    a b  
    2626
    2727
    2828cdef class GenericBackend:
    29 
    30     cpdef int add_variable(self):
    31         r"""
    32         Adds a variable.
     29    cpdef int add_variable(self, lower_bound=0.0, upper_bound=None, binary=False, continuous=True, integer=False) except -1:
     30        """
     31        Add a variable.
    3332
    3433        This amounts to adding a new column to the matrix. By default,
    3534        the variable is both positive and real.
    3635
     36        INPUT:
     37
     38        - ``lower_bound`` - the lower bound of the variable (default: 0)
     39
     40        - ``upper_bound`` - the upper bound of the variable (default: ``None``)
     41
     42        - ``binary`` - ``True`` if the variable is binary (default: ``False``).
     43
     44        - ``continuous`` - ``True`` if the variable is binary (default: ``True``).
     45
     46        - ``integer`` - ``True`` if the variable is binary (default: ``False``).
     47
     48        OUTPUT: The index of the newly created variable           
     49
    3750        EXAMPLE::
    3851
    3952            sage: from sage.numerical.backends.generic_backend import get_solver
    4053            sage: p = get_solver(solver = "Nonexistent_LP_solver")    # optional - Nonexistent_LP_solver
    41             sage: p.ncols()                                         # optional - Nonexistent_LP_solver
     54            sage: p.ncols()                                           # optional - Nonexistent_LP_solver
    4255            0
    43             sage: p.add_variable()                                   # optional - Nonexistent_LP_solver
     56            sage: p.add_variable()                                    # optional - Nonexistent_LP_solver
     57            0
     58            sage: p.ncols()                                           # optional - Nonexistent_LP_solver
    4459            1
    45             sage: p.ncols()                                         # optional - Nonexistent_LP_solver
     60            sage: p.add_variable(binary=True)                         # optional - Nonexistent_LP_solver
    4661            1
     62            sage: p.add_variable(lower_bound=-2.0, integer=True)      # optional - Nonexistent_LP_solver
     63            2
     64            sage: p.add_variable(continuous=True, integer=True)       # optional - Nonexistent_LP_solver
     65            Traceback (most recent call last):
     66            ...
     67            ValueError: ...           
    4768        """
    4869        raise NotImplementedError()
    4970
    50     cpdef int add_variables(self, int n):
    51         r"""
    52         Adds ``number`` variables.
     71    cpdef int add_variables(self, int n, lower_bound=0.0, upper_bound=None, binary=False, continuous=True, integer=False) except -1:
     72        """
     73        Add ``n`` variables.
    5374
    5475        This amounts to adding new columns to the matrix. By default,
    5576        the variables are both positive and real.
    5677
     78        INPUT:
     79
     80        - ``n`` - the number of new variables (must be > 0)
     81
     82        - ``lower_bound`` - the lower bound of the variable (default: 0)
     83
     84        - ``upper_bound`` - the upper bound of the variable (default: ``None``)
     85
     86        - ``binary`` - ``True`` if the variable is binary (default: ``False``).
     87
     88        - ``continuous`` - ``True`` if the variable is binary (default: ``True``).
     89
     90        - ``integer`` - ``True`` if the variable is binary (default: ``False``).
     91
     92        OUTPUT: The index of the variable created last.
     93
    5794        EXAMPLE::
    5895
    5996            sage: from sage.numerical.backends.generic_backend import get_solver
    6097            sage: p = get_solver(solver = "Nonexistent_LP_solver")    # optional - Nonexistent_LP_solver
    61             sage: p.ncols()                                         # optional - Nonexistent_LP_solver
     98            sage: p.ncols()                                           # optional - Nonexistent_LP_solver
    6299            0
    63             sage: p.add_variables(5)                                 # optional - Nonexistent_LP_solver
     100            sage: p.add_variables(5)                                  # optional - Nonexistent_LP_solver
     101            4
     102            sage: p.ncols()                                           # optional - Nonexistent_LP_solver
    64103            5
    65             sage: p.ncols()                                         # optional - Nonexistent_LP_solver
    66             5
     104            sage: p.add_variables(2, lower_bound=-2.0, integer=True)  # optional - Nonexistent_LP_solver
     105            6
    67106        """
    68 
    69107        raise NotImplementedError()
    70108
    71109    cpdef  set_variable_type(self, int variable, int vtype):
    72         r"""
    73         Sets the type of a variable
     110        """
     111        Set the type of a variable
    74112
    75113        INPUT:
    76114
     
    80118
    81119            *  1  Integer
    82120            *  0  Binary
    83             * -1 Real
     121            * -1  Continuous
    84122
    85123        EXAMPLE::
    86124
     
    94132            sage: p.is_variable_integer(0)                          # optional - Nonexistent_LP_solver
    95133            True
    96134        """
    97 
    98135        raise NotImplementedError()
    99136
    100137    cpdef set_sense(self, int sense):
    101         r"""
    102         Sets the direction (maximization/minimization).
     138        """
     139        Set the direction (maximization/minimization).
    103140
    104141        INPUT:
    105142
     
    118155            sage: p.is_maximization()                              # optional - Nonexistent_LP_solver
    119156            False
    120157        """
    121 
    122158        raise NotImplementedError()
    123159
    124160    cpdef  set_objective_coefficient(self, int variable, double coeff):
    125         r"""
    126         Sets the coefficient of a variable in the objective function
     161        """
     162        Set the coefficient of a variable in the objective function
    127163
    128164        INPUT:
    129165
     
    143179            sage: p.get_objective_coefficient(0)                         # optional - Nonexistent_LP_solver
    144180            2.0
    145181        """
    146 
    147182        raise NotImplementedError()
    148183
    149184    cpdef  set_objective(self, list coeff):
    150         r"""
    151         Sets the objective function.
     185        """
     186        Set the objective function.
    152187
    153188        INPUT:
    154189
     
    165200            sage: map(lambda x :p.get_objective_coeffient(x), range(5))  # optional - Nonexistent_LP_solver
    166201            [1.0, 1.0, 2.0, 1.0, 3.0]
    167202        """
    168 
    169203        raise NotImplementedError()
    170204
    171205    cpdef set_verbosity(self, int level):
    172         r"""
    173         Sets the log (verbosity) level
     206        """
     207        Set the log (verbosity) level
    174208
    175209        INPUT:
    176210
     
    179213        EXAMPLE::
    180214
    181215            sage: from sage.numerical.backends.generic_backend import get_solver
    182             sage: p = get_solver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
     216            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    183217            sage: p.set_verbosity(2)                                # optional - Nonexistent_LP_solver
    184 
    185218        """
    186 
    187219        raise NotImplementedError()
    188220
    189     cpdef add_linear_constraint(self, list indices, list coeffs, int direction, double bound):
    190         r"""
    191         Adds a linear constraint.
     221    cpdef add_linear_constraint(self, constraints, lower_bound, upper_bound):
     222        """
     223        Add a linear constraint.
    192224
    193225        INPUT:
    194226
    195         - ``indices`` (list of integers) -- this list constains the
    196           indices of the variables whose coefficient is nonzero in the
    197           constraint.
     227        - ``contraints`` an iterable with ``(c,v)`` pairs where ``c``
     228          is a variable index (integer) and ``v`` is a value (real
     229          value).
    198230
    199         - ``coeffs`` (list of real values) -- associates a coefficient
    200           to the variables listed by ``indices``. Namely, the ith
    201           entry of ``coeffs`` corresponds to the coefficient of the
    202           variable represented by the ith entry in ``indices``.
     231        - ``lower_bound`` - a lower bound, either a real value or ``None``
    203232
    204         - ``direction`` (integer) -- the direction of the constraint,
    205           where :
    206 
    207               * +1 indicates : function `\leq` ``bound``
    208               *  0 indicates : function `=` ``bound``
    209               * -1 indicates : function `\geq` ``bound``
    210 
    211         - ``bound`` (double) -- value of the right-hand side (as
    212           illustrated immediately above).
    213 
    214         .. NOTE::
    215 
    216             ``indices`` and ``coeffs`` are expected to be of the same
    217             length.
    218 
     233        - ``upper_bound`` - an upper bound, either a real value or ``None``
     234 
    219235        EXAMPLE::
    220236
    221237            sage: from sage.numerical.backends.generic_backend import get_solver
    222238            sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
    223             sage: p.add_variables(5)                              # optional - Nonexistent_LP_solver
    224             5
    225             sage: p.add_linear_constraint(range(5), range(5), 0, 2)      # optional - Nonexistent_LP_solver
    226             sage: p.row(0)                                    # optional - Nonexistent_LP_solver
    227             ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
    228             sage: p.row_bounds(0)                             # optional - Nonexistent_LP_solver
     239            sage: p.add_variables(5)                               # optional - Nonexistent_LP_solver
     240            4
     241            sage: p.add_linear_constraint(zip(range(5), range(5)), 2.0, 2.0) # optional - Nonexistent_LP_solver
     242            sage: p.row(0)                                         # optional - Nonexistent_LP_solver
     243            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])                   # optional - Nonexistent_LP_solver
     244            sage: p.row_bounds(0)                                  # optional - Nonexistent_LP_solver
    229245            (2.0, 2.0)
    230246        """
    231247        raise NotImplementedError()
    232248
    233249    cpdef add_col(self, list indices, list coeffs):
    234         r"""
    235         Adds a column.
     250        """
     251        Add a column.
    236252
    237253        INPUT:
    238254
     
    259275            0
    260276            sage: p.nrows()                                       # optional - Nonexistent_LP_solver
    261277            0
    262             sage: p.add_linear_constraints(5, -1, 0)                      # optional - Nonexistent_LP_solver
    263             sage: p.add_col(range(5), range(5))                    # optional - Nonexistent_LP_solver
     278            sage: p.add_linear_constraints(5, 0, None)            # optional - Nonexistent_LP_solver
     279            sage: p.add_col(range(5), range(5))                   # optional - Nonexistent_LP_solver
    264280            sage: p.nrows()                                       # optional - Nonexistent_LP_solver
    265281            5
    266282        """
    267 
    268283        raise NotImplementedError()
    269284
    270     cpdef add_linear_constraints(self, int number, int direction, double bound):
    271         r"""
    272         Adds constraints.
     285    cpdef add_linear_constraints(self, int number, lower_bound, upper_bound):
     286        """
     287        Add constraints.
    273288
    274289        INPUT:
    275290
    276291        - ``number`` (integer) -- the number of constraints to add.
    277292
    278         - ``direction`` (integer) -- the direction of the constraint,
    279           where :
     293        - ``lower_bound`` - a lower bound, either a real value or ``None``
    280294
    281               * +1 indicates : function `\leq` ``bound``
    282               *  0 indicates : function `=` ``bound``
    283               * -1 indicates : function `\geq` ``bound``
    284 
    285         - ``bound`` (double) -- value of the right-hand side (as
    286           illustrated immediately above).
     295        - ``upper_bound`` - an upper bound, either a real value or ``None``
    287296
    288297        EXAMPLE::
    289298
     
    291300            sage: p = get_solver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
    292301            sage: p.add_variables(5)                                # optional - Nonexistent_LP_solver
    293302            5
    294             sage: p.add_linear_constraints(5, +1, 2)                       # optional - Nonexistent_LP_solver
     303            sage: p.add_linear_constraints(5, None, 2)          # optional - Nonexistent_LP_solver
    295304            sage: p.row(4)                                      # optional - Nonexistent_LP_solver
    296305            ([], [])
    297306            sage: p.row_bounds(4)                               # optional - Nonexistent_LP_solver
    298307            (None, 2.0)
    299308        """
    300 
    301309        raise NotImplementedError()
    302310
    303311    cpdef int solve(self) except -1:
    304         r"""
    305         Solves the problem.
     312        """
     313        Solve the problem.
    306314
    307315        .. NOTE::
    308316
     
    314322
    315323            sage: from sage.numerical.backends.generic_backend import get_solver
    316324            sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
    317             sage: p.add_linear_constraints(5, -1, 0)                     # optional - Nonexistent_LP_solver
    318             sage: p.add_col(range(5), range(5))                   # optional - Nonexistent_LP_solver
    319             sage: p.solve()                                       # optional - Nonexistent_LP_solver
     325            sage: p.add_linear_constraints(5, 0, None)             # optional - Nonexistent_LP_solver
     326            sage: p.add_col(range(5), range(5))                    # optional - Nonexistent_LP_solver
     327            sage: p.solve()                                        # optional - Nonexistent_LP_solver
    320328            0
    321             sage: p.set_objective_coefficient(0,1)                      # optional - Nonexistent_LP_solver
    322             sage: p.solve()                                       # optional - Nonexistent_LP_solver
     329            sage: p.set_objective_coefficient(0,1)                 # optional - Nonexistent_LP_solver
     330            sage: p.solve()                                        # optional - Nonexistent_LP_solver
    323331            Traceback (most recent call last):
    324332            ...
    325333            MIPSolverException: ...
     
    327335        raise NotImplementedError()
    328336
    329337    cpdef double get_objective_value(self):
    330         r"""
    331         Returns the value of the objective function.
     338        """
     339        Return the value of the objective function.
    332340
    333341        .. NOTE::
    334342
    335            Has no meaning unless ``solve`` has been called before.
     343           Behaviour is undefined unless ``solve`` has been called before.
    336344
    337345        EXAMPLE::
    338346
    339347            sage: from sage.numerical.backends.generic_backend import get_solver
    340             sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     348            sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
    341349            sage: p.add_variables(2)                               # optional - Nonexistent_LP_solver
    342350            2
    343             sage: p.add_linear_constraint([0, 1], [1, 2], +1, 3)          # optional - Nonexistent_LP_solver
     351            sage: p.add_linear_constraint([(0,1), (1,2)], None, 3) # optional - Nonexistent_LP_solver
    344352            sage: p.set_objective([2, 5])                          # optional - Nonexistent_LP_solver
    345353            sage: p.solve()                                        # optional - Nonexistent_LP_solver
    346354            0
     
    355363        raise NotImplementedError()
    356364
    357365    cpdef double get_variable_value(self, int variable):
    358         r"""
    359         Returns the value of a variable given by the solver.
     366        """
     367        Return the value of a variable given by the solver.
    360368
    361369        .. NOTE::
    362370
    363            Has no meaning unless ``solve`` has been called before.
     371           Behaviour is undefined unless ``solve`` has been called before.
    364372
    365373        EXAMPLE::
    366374
     
    368376            sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
    369377            sage: p.add_variables(2)                              # optional - Nonexistent_LP_solver
    370378            2
    371             sage: p.add_linear_constraint([0, 1], [1, 2], +1, 3)        # optional - Nonexistent_LP_solver
     379            sage: p.add_linear_constraint([(0,1), (1, 2)], None, 3) # optional - Nonexistent_LP_solver
    372380            sage: p.set_objective([2, 5])                         # optional - Nonexistent_LP_solver
    373381            sage: p.solve()                                       # optional - Nonexistent_LP_solver
    374382            0
     
    383391        raise NotImplementedError()
    384392
    385393    cpdef int ncols(self):
    386         r"""
    387         Returns the number of columns/variables.
     394        """
     395        Return the number of columns/variables.
    388396
    389397        EXAMPLE::
    390398
     
    401409        raise NotImplementedError()
    402410
    403411    cpdef int nrows(self):
    404         r"""
    405         Returns the number of rows/constraints.
     412        """
     413        Return the number of rows/constraints.
    406414
    407415        EXAMPLE::
    408416
    409417            sage: from sage.numerical.backends.generic_backend import get_solver
    410418            sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
    411             sage: p.nrows()                                      # optional - Nonexistent_LP_solver
     419            sage: p.nrows()                                        # optional - Nonexistent_LP_solver
    412420            0
    413             sage: p.add_linear_constraints(2, -1, 2)                     # optional - Nonexistent_LP_solver
     421            sage: p.add_linear_constraints(2, 2.0, None)         # optional - Nonexistent_LP_solver
    414422            sage: p.nrows()                                      # optional - Nonexistent_LP_solver
    415423            2
    416424        """
    417425
    418426        raise NotImplementedError()
    419427
    420     cpdef name(self):
    421         raise NotImplementedError()
    422 
    423428    cpdef bint is_maximization(self):
    424         r"""
    425         Tests whether the problem is a maximization
     429        """
     430        Test whether the problem is a maximization
    426431
    427432        EXAMPLE::
    428433
     
    437442        raise NotImplementedError()
    438443
    439444    cpdef problem_name(self, char * name = NULL):
    440         r"""
    441         Returns or defines the problem's name
     445        """
     446        Return or define the problem's name
    442447
    443448        INPUT:
    444449
     
    457462        raise NotImplementedError()
    458463
    459464    cpdef write_lp(self, char * name):
    460         r"""
    461         Writes the problem to a .lp file
     465        """
     466        Write the problem to a .lp file
    462467
    463468        INPUT:
    464469       
     
    470475            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    471476            sage: p.add_variables(2)                               # optional - Nonexistent_LP_solver
    472477            2
    473             sage: p.add_linear_constraint([0, 1], [1, 2], +1, 3)          # optional - Nonexistent_LP_solver
     478            sage: p.add_linear_constraint([(0, 1], (1, 2)], None, 3) # optional - Nonexistent_LP_solver
    474479            sage: p.set_objective([2, 5])                          # optional - Nonexistent_LP_solver
    475480            sage: p.write_lp(SAGE_TMP+"/lp_problem.lp")            # optional - Nonexistent_LP_solver
    476481        """
    477482        raise NotImplementedError()
    478483
    479484    cpdef write_mps(self, char * name, int modern):
    480         r"""
    481         Writes the problem to a .mps file
     485        """
     486        Write the problem to a .mps file
    482487
    483488        INPUT:
    484489       
     
    490495            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    491496            sage: p.add_variables(2)                               # optional - Nonexistent_LP_solver
    492497            2
    493             sage: p.add_linear_constraint([0, 1], [1, 2], +1, 3)          # optional - Nonexistent_LP_solver
     498            sage: p.add_linear_constraint([(0, 1), (1, 2)], None, 3) # optional - Nonexistent_LP_solver
    494499            sage: p.set_objective([2, 5])                          # optional - Nonexistent_LP_solver
    495500            sage: p.write_lp(SAGE_TMP+"/lp_problem.lp")            # optional - Nonexistent_LP_solver
    496501        """
    497502        raise NotImplementedError()
    498503
    499504    cpdef row(self, int i):
    500         r"""
    501         Returns a row
     505        """
     506        Return a row
    502507
    503508        INPUT:
    504509
     
    517522            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    518523            sage: p.add_variables(5)                               # optional - Nonexistent_LP_solver
    519524            5
    520             sage: p.add_linear_constraint(range(5), range(5), 0, 2)      # optional - Nonexistent_LP_solver
     525            sage: p.add_linear_constraint(zip(range(5), range(5)), 2, 2) # optional - Nonexistent_LP_solver
    521526            sage: p.row(0)                                     # optional - Nonexistent_LP_solver
    522527            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
    523528            sage: p.row_bounds(0)                              # optional - Nonexistent_LP_solver
    524529            (2.0, 2.0)
    525530        """
    526 
    527531        raise NotImplementedError()
    528532
    529533    cpdef double get_objective_coefficient(self, int i):
    530         r"""
    531         Sets the coefficient of a variable in the objective function
     534        """
     535        Set the coefficient of a variable in the objective function
    532536
    533537        INPUT:
    534538
     
    548552            sage: p.get_objective_coeffient(0)                         # optional - Nonexistent_LP_solver
    549553            2.0
    550554        """
    551 
    552555        raise NotImplementedError()
    553556
    554557    cpdef row_bounds(self, int index):
    555         r"""
    556         Returns the bounds of a specific constraint.
     558        """
     559        Return the bounds of a specific constraint.
    557560
    558561        INPUT:
    559562
     
    571574            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    572575            sage: p.add_variables(5)                               # optional - Nonexistent_LP_solver
    573576            5
    574             sage: p.add_linear_constraint(range(5), range(5), 0, 2)      # optional - Nonexistent_LP_solver
     577            sage: p.add_linear_constraint(range(5), range(5), 2, 2) # optional - Nonexistent_LP_solver
    575578            sage: p.row(0)                                     # optional - Nonexistent_LP_solver
    576579            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
    577580            sage: p.row_bounds(0)                              # optional - Nonexistent_LP_solver
     
    580583        raise NotImplementedError()
    581584
    582585    cpdef col_bounds(self, int index):
    583         r"""
    584         Returns the bounds of a specific variable.
     586        """
     587        Return the bounds of a specific variable.
    585588
    586589        INPUT:
    587590
     
    601604            1
    602605            sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
    603606            (0.0, None)
    604             sage: p.variable_max(0, 5)                         # optional - Nonexistent_LP_solver
     607            sage: p.variable_upper_bound(0, 5)                 # optional - Nonexistent_LP_solver
    605608            sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
    606609            (0.0, 5.0)
    607610        """
    608 
    609611        raise NotImplementedError()
    610612
    611613    cpdef bint is_variable_binary(self, int index):
    612         r"""
    613         Tests whether the given variable is of binary type.
     614        """
     615        Test whether the given variable is of binary type.
    614616
    615617        INPUT:
    616618
     
    629631            True
    630632
    631633        """
    632 
    633634        raise NotImplementedError()
    634635
    635636    cpdef bint is_variable_integer(self, int index):
    636         r"""
    637         Tests whether the given variable is of integer type.
     637        """
     638        Test whether the given variable is of integer type.
    638639
    639640        INPUT:
    640641
     
    652653            sage: p.is_variable_integer(0)                         # optional - Nonexistent_LP_solver
    653654            True
    654655        """
    655 
    656656        raise NotImplementedError()
    657657
    658658    cpdef bint is_variable_continuous(self, int index):
    659         r"""
    660         Tests whether the given variable is of continuous/real type.
     659        """
     660        Test whether the given variable is of continuous/real type.
    661661
    662662        INPUT:
    663663
     
    678678            False
    679679
    680680        """
    681 
    682681        raise NotImplementedError()
    683682
    684683    cpdef row_name(self, int index, char * name = NULL):
    685         r"""
    686         Returns or defines the ``index`` th row name
     684        """
     685        Return or define the ``index`` th row name
    687686
    688687        INPUT:
    689688
     
    696695
    697696            sage: from sage.numerical.backends.generic_backend import get_solver
    698697            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    699             sage: p.add_linear_constraints(1, -1, 2)                      # optional - Nonexistent_LP_solver
     698            sage: p.add_linear_constraints(1, 2, None)         # optional - Nonexistent_LP_solver
    700699            sage: p.row_name(0, "Empty constraint 1")          # optional - Nonexistent_LP_solver
    701700            sage: p.row_name(0)                                # optional - Nonexistent_LP_solver
    702701            'Empty constraint 1'
    703702
    704703        """
    705 
    706704        raise NotImplementedError()
    707705
    708706    cpdef col_name(self, int index, char * name = NULL):
    709         r"""
    710         Returns or defines the ``index`` th col name
     707        """
     708        Return or define the ``index`` th col name
    711709
    712710        INPUT:
    713711
     
    726724            sage: p.col_name(0)                                # optional - Nonexistent_LP_solver
    727725            'I am a variable'
    728726        """
    729 
    730727        raise NotImplementedError()
    731728
    732     cpdef  variable_max(self, int index, value = None):
    733         r"""
    734         Returns or defines the upper bound on a variable
     729    cpdef variable_upper_bound(self, int index, value = None):
     730        """
     731        Return or define the upper bound on a variable
    735732
    736733        INPUT:
    737734
     
    749746            1
    750747            sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
    751748            (0.0, None)
    752             sage: p.variable_max(0, 5)                         # optional - Nonexistent_LP_solver
     749            sage: p.variable_upper_bound(0, 5)                 # optional - Nonexistent_LP_solver
    753750            sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
    754751            (0.0, 5.0)
    755752        """
    756 
    757753        raise NotImplementedError()
    758754
    759     cpdef  variable_min(self, int index, value = None):
    760         r"""
    761         Returns or defines the lower bound on a variable
     755    cpdef variable_lower_bound(self, int index, value = None):
     756        """
     757        Return or define the lower bound on a variable
    762758
    763759        INPUT:
    764760
     
    776772            1
    777773            sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
    778774            (0.0, None)
    779             sage: p.variable_min(0, 5)                         # optional - Nonexistent_LP_solver
     775            sage: p.variable_lower_bound(0, 5)                 # optional - Nonexistent_LP_solver
    780776            sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
    781777            (5.0, None)
    782778        """
    783 
    784779        raise NotImplementedError()
    785780   
    786781default_solver = None
    787782
    788783def default_mip_solver(solver = None):
    789     r"""
     784    """
    790785    Returns/Sets the default MILP Solver used by Sage
    791786
    792787    INPUT:
     
    864859        raise ValueError("'solver' should be set to 'GLPK', 'Coin', 'CPLEX' or None.")
    865860
    866861cpdef GenericBackend get_solver(constraint_generation = False, solver = None):
    867     r"""
    868     Returns a solver according to the given preferences
     862    """
     863    Return a solver according to the given preferences
    869864
    870865    INPUT:
    871866
  • sage/numerical/backends/glpk_backend.pyx

    diff -r cbaf095a0f0d -r 073e4cbe35f3 sage/numerical/backends/glpk_backend.pyx
    a b  
    1616from sage.numerical.mip import MIPSolverException
    1717
    1818cdef class GLPKBackend(GenericBackend):
    19 
    2019    def __cinit__(self, maximization = True):
    21         r"""
     20        """
    2221        Constructor
    2322
    2423        EXAMPLE::
    2524
    2625            sage: p = MixedIntegerLinearProgram(solver="GLPK")
    2726        """
    28 
    2927        self.lp = glp_create_prob()
    3028        self.iocp = new_c_glp_iocp()
    3129        glp_init_iocp(self.iocp)
     
    3735        else:
    3836            self.set_sense(-1)
    3937
    40         #self.iocp.gmi_cuts = GLP_ON
    41         #self.iocp.fp_heur = GLP_ON
    42         #self.iocp.mir_cuts = GLP_ON
    43 
    44     cpdef int add_variable(self):
    45         r"""
    46         Adds a variable.
     38    cpdef int add_variable(self, lower_bound=0.0, upper_bound=None, binary=False, continuous=False, integer=False) except -1:
     39        """
     40        Add a variable.
    4741
    4842        This amounts to adding a new column to the matrix. By default,
    4943        the variable is both positive and real.
    5044
     45        INPUT:
     46
     47        - ``lower_bound`` - the lower bound of the variable (default: 0)
     48
     49        - ``upper_bound`` - the upper bound of the variable (default: ``None``)
     50
     51        - ``binary`` - ``True`` if the variable is binary (default: ``False``).
     52
     53        - ``continuous`` - ``True`` if the variable is binary (default: ``True``).
     54
     55        - ``integer`` - ``True`` if the variable is binary (default: ``False``).
     56
     57        OUTPUT: The index of the newly created variable           
     58
    5159        EXAMPLE::
    5260
    5361            sage: from sage.numerical.backends.generic_backend import get_solver
     
    5563            sage: p.ncols()
    5664            0
    5765            sage: p.add_variable()
    58             1
     66            0
    5967            sage: p.ncols()
    6068            1
     69            sage: p.add_variable(binary=True)
     70            1
     71            sage: p.add_variable(lower_bound=-2.0, integer=True)
     72            2
     73            sage: p.add_variable(continuous=True, integer=True)
     74            Traceback (most recent call last):
     75            ...
     76            ValueError: ...           
    6177        """
     78        cdef int vtype = int(bool(binary)) + int(bool(continuous)) + int(bool(integer))
     79        if  vtype == 0:
     80            continuous = True           
     81        elif vtype != 1:
     82            raise ValueError("Exactly one parameter of 'binary', 'integer' and 'continuous' must be 'True'.")
    6283
    6384        glp_add_cols(self.lp, 1)
    6485        cdef int n_var = glp_get_num_cols(self.lp)
    65         glp_set_col_bnds(self.lp, n_var, GLP_LO, 0, 0)
    66         glp_set_col_kind(self.lp, n_var, GLP_CV)
     86
     87        self.variable_lower_bound(n_var - 1, lower_bound)
     88        self.variable_upper_bound(n_var - 1, upper_bound)
     89
     90        if continuous:
     91            glp_set_col_kind(self.lp, n_var, GLP_CV)
     92        elif binary:
     93            glp_set_col_kind(self.lp, n_var, GLP_BV)
     94        elif integer:
     95            glp_set_col_kind(self.lp, n_var, GLP_IV)
    6796       
    68         return n_var
     97        return n_var - 1
    6998
    70     cpdef int add_variables(self, int number):
    71         r"""
    72         Adds ``number`` variables.
     99    cpdef int add_variables(self, int number, lower_bound=0.0, upper_bound=None, binary=False, continuous=False, integer=False) except -1:
     100        """
     101        Add ``number`` new variables.
    73102
    74103        This amounts to adding new columns to the matrix. By default,
    75104        the variables are both positive and real.
    76105
     106        INPUT:
     107
     108        - ``n`` - the number of new variables (must be > 0)
     109
     110        - ``lower_bound`` - the lower bound of the variable (default: 0)
     111
     112        - ``upper_bound`` - the upper bound of the variable (default: ``None``)
     113
     114        - ``binary`` - ``True`` if the variable is binary (default: ``False``).
     115
     116        - ``continuous`` - ``True`` if the variable is binary (default: ``True``).
     117
     118        - ``integer`` - ``True`` if the variable is binary (default: ``False``).
     119
     120        OUTPUT: The index of the variable created last.
     121
    77122        EXAMPLE::
    78123
    79124            sage: from sage.numerical.backends.generic_backend import get_solver
     
    81126            sage: p.ncols()
    82127            0
    83128            sage: p.add_variables(5)
    84             5
     129            4
    85130            sage: p.ncols()
    86131            5
     132            sage: p.add_variables(2, lower_bound=-2.0, integer=True)
     133            6
    87134        """
     135        cdef int vtype = int(bool(binary)) + int(bool(continuous)) + int(bool(integer))
     136        if  vtype == 0:
     137            continuous = True           
     138        elif vtype != 1:
     139            raise ValueError("Exactly one parameter of 'binary', 'integer' and 'continuous' must be 'True'.")
    88140
    89141        glp_add_cols(self.lp, number)
    90142
    91143        cdef int n_var
    92144        n_var = glp_get_num_cols(self.lp)
    93145
    94 
    95146        cdef int i
    96147       
    97148        for 0<= i < number:
    98             glp_set_col_bnds(self.lp, n_var-i, GLP_LO, 0, 0)
    99             glp_set_col_kind(self.lp, n_var-i, GLP_CV)
    100        
    101         return n_var
     149            self.variable_lower_bound(n_var - i - 1, lower_bound)
     150            self.variable_upper_bound(n_var - i - 1, upper_bound)
     151            if continuous:
     152                glp_set_col_kind(self.lp, n_var - i, GLP_CV)
     153            elif binary:
     154                glp_set_col_kind(self.lp, n_var - i, GLP_BV)
     155            elif integer:
     156                glp_set_col_kind(self.lp, n_var - i, GLP_IV)
     157        return n_var - 1
    102158
    103159    cpdef set_variable_type(self, int variable, int vtype):
    104         r"""
    105         Sets the type of a variable
     160        """
     161        Set the type of a variable
    106162
    107163        INPUT:
    108164
     
    121177            sage: p.ncols()
    122178            0
    123179            sage: p.add_variable()
    124             1
     180            0
    125181            sage: p.set_variable_type(0,1)
    126182            sage: p.is_variable_integer(0)
    127183            True
     
    137193            glp_set_col_kind(self.lp, variable+1, GLP_CV)
    138194
    139195    cpdef set_sense(self, int sense):
    140         r"""
    141         Sets the direction (maximization/minimization).
     196        """
     197        Set the direction (maximization/minimization).
    142198
    143199        INPUT:
    144200
     
    163219            glp_set_obj_dir(self.lp, GLP_MIN)
    164220
    165221    cpdef set_objective_coefficient(self, int variable, double coeff):
    166         r"""
    167         Sets the coefficient of a variable in the objective function
     222        """
     223        Set the coefficient of a variable in the objective function
    168224
    169225        INPUT:
    170226
     
    177233            sage: from sage.numerical.backends.generic_backend import get_solver
    178234            sage: p = get_solver(solver = "GLPK")
    179235            sage: p.add_variable()
    180             1
     236            0
    181237            sage: p.get_objective_coefficient(0)
    182238            0.0
    183239            sage: p.set_objective_coefficient(0,2)
    184240            sage: p.get_objective_coefficient(0)
    185241            2.0
    186242        """
    187 
    188243        glp_set_obj_coef(self.lp, variable + 1, coeff)
    189244
    190 
    191245    cpdef problem_name(self, char * name = NULL):
    192         r"""
    193         Returns or defines the problem's name
     246        """
     247        Return or define the problem's name
    194248
    195249        INPUT:
    196250
     
    218272            glp_set_prob_name(self.lp, name)
    219273
    220274    cpdef set_objective(self, list coeff):
    221         r"""
    222         Sets the objective function.
     275        """
     276        Set the objective function.
    223277
    224278        INPUT:
    225279
    226         - ``coeff`` -- a list of real values, whose ith element is the
     280        - ``coeff`` - a list of real values, whose ith element is the
    227281          coefficient of the ith variable in the objective function.
    228282
    229283        EXAMPLE::
     
    231285            sage: from sage.numerical.backends.generic_backend import get_solver
    232286            sage: p = get_solver(solver = "GLPK")
    233287            sage: p.add_variables(5)
    234             5
     288            4
    235289            sage: p.set_objective([1, 1, 2, 1, 3])
    236290            sage: map(lambda x :p.get_objective_coefficient(x), range(5))
    237291            [1.0, 1.0, 2.0, 1.0, 3.0]
    238292        """
    239 
    240293        cdef int i
    241294
    242295        for i,v in enumerate(coeff):
    243296            glp_set_obj_coef(self.lp, i+1, v)
    244297
    245298    cpdef set_verbosity(self, int level):
    246         r"""
    247         Sets the verbosity level
     299        """
     300        Set the verbosity level
    248301
    249302        INPUT:
    250303
     
    266319        else:
    267320            self.iocp.msg_lev = GLP_MSG_ALL
    268321
    269     cpdef add_linear_constraints(self, int number, int direction, double bound):
    270         r"""
    271         Adds constraints.
     322    cpdef add_linear_constraint(self, constraints, lower_bound, upper_bound):
     323        """
     324        Add a linear constraint.
     325
     326        INPUT:
     327
     328        - ``contraints`` an iterable with ``(c,v)`` pairs where ``c``
     329          is a variable index (integer) and ``v`` is a value (real
     330          value).
     331
     332        - ``lower_bound`` - a lower bound, either a real value or ``None``
     333
     334        - ``upper_bound`` - an upper bound, either a real value or ``None``
     335 
     336        EXAMPLE::
     337
     338            sage: from sage.numerical.backends.generic_backend import get_solver
     339            sage: p = get_solver(solver = "GLPK")
     340            sage: p.add_variables(5)
     341            4
     342            sage: p.add_linear_constraint( zip(range(5), range(5)), 2.0, 2.0)
     343            sage: p.row(0)
     344            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
     345            sage: p.row_bounds(0)
     346            (2.0, 2.0)
     347        """
     348        if lower_bound is None and upper_bound is None:
     349            raise ValueError("At least one of 'upper_bound' or 'lower_bound' must be set.")
     350
     351        glp_add_rows(self.lp, 1)
     352        cdef int n = glp_get_num_rows(self.lp)
     353
     354        cdef int * row_i
     355        cdef double * row_values
     356
     357        row_i = <int *> sage_malloc((len(constraints)+1) * sizeof(int))
     358        row_values = <double *> sage_malloc((len(constraints)+1) * sizeof(double))
     359
     360        for i,(c,v) in enumerate(constraints):
     361            row_i[i+1] = c+1
     362            row_values[i+1] = v
     363       
     364        glp_set_mat_row(self.lp, n, len(constraints), row_i, row_values)
     365
     366        if upper_bound is not None and lower_bound is None:
     367            glp_set_row_bnds(self.lp, n, GLP_UP, upper_bound, upper_bound)
     368        elif lower_bound is not None and upper_bound is None:
     369            glp_set_row_bnds(self.lp, n, GLP_LO, lower_bound, lower_bound)           
     370        elif upper_bound is not None and lower_bound is not None:
     371            if lower_bound == upper_bound:
     372                glp_set_row_bnds(self.lp, n, GLP_FX, lower_bound, upper_bound)
     373            else:
     374                glp_set_row_bnds(self.lp, n, GLP_DB, lower_bound, upper_bound)
     375
     376        sage_free(row_i)
     377        sage_free(row_values)
     378
     379    cpdef add_linear_constraints(self, int number, lower_bound, upper_bound):
     380        """
     381        Add ``'number`` linear constraints.
    272382
    273383        INPUT:
    274384
    275385        - ``number`` (integer) -- the number of constraints to add.
    276386
    277         - ``direction`` (integer) -- the direction of the constraint,
    278           where :
     387        - ``lower_bound`` - a lower bound, either a real value or ``None``
    279388
    280               * +1 indicates : function `\leq` ``bound``
    281               *  0 indicates : function `=` ``bound``
    282               * -1 indicates : function `\geq` ``bound``
    283 
    284         - ``bound`` (double) -- value of the right-hand side (as
    285           illustrated immediately above).
     389        - ``upper_bound`` - an upper bound, either a real value or ``None``
    286390
    287391        EXAMPLE::
    288392
    289393            sage: from sage.numerical.backends.generic_backend import get_solver
    290394            sage: p = get_solver(solver = "GLPK")
    291395            sage: p.add_variables(5)
    292             5
    293             sage: p.add_linear_constraints(5, +1, 2)
     396            4
     397            sage: p.add_linear_constraints(5, None, 2)
    294398            sage: p.row(4)
    295399            ([], [])
    296400            sage: p.row_bounds(4)
    297401            (None, 2.0)
    298402        """
     403        if lower_bound is None and upper_bound is None:
     404            raise ValueError("At least one of 'upper_bound' or 'lower_bound' must be set.")
    299405
    300406        glp_add_rows(self.lp, number)
    301407        cdef int n = glp_get_num_rows(self.lp)
    302408
    303         if direction == +1:
    304             direction = GLP_UP
    305         elif direction == -1:
    306             direction = GLP_LO
    307         else:
    308             direction = GLP_FX
    309        
    310409        cdef int i
    311410        for 0<= i < number:
    312             glp_set_row_bnds(self.lp, n-i, direction, bound, bound)
    313 
    314     cpdef add_linear_constraint(self, list indices, list coeffs, int direction, double bound):
    315         r"""
    316         Adds a linear constraint.
    317 
    318         INPUT:
    319 
    320         - ``indices`` (list of integers) -- this list constains the
    321           indices of the variables whose coefficient is nonzero in the
    322           constraint.
    323 
    324         - ``coeffs`` (list of real values) -- associates a coefficient
    325           to the variables listed by ``indices``. Namely, the ith
    326           entry of ``coeffs`` corresponds to the coefficient of the
    327           variable represented by the ith entry in ``indices``.
    328 
    329         - ``direction`` (integer) -- the direction of the constraint,
    330           where :
    331 
    332               * +1 indicates : function `\leq` ``bound``
    333               *  0 indicates : function `=` ``bound``
    334               * -1 indicates : function `\geq` ``bound``
    335 
    336         - ``bound`` (double) -- value of the right-hand side (as
    337           illustrated immediately above).
    338 
    339         .. NOTE::
    340 
    341             ``indices`` and ``coeffs`` are expected to be of the same
    342             length.
    343 
    344         EXAMPLE::
    345 
    346             sage: from sage.numerical.backends.generic_backend import get_solver
    347             sage: p = get_solver(solver = "GLPK")
    348             sage: p.add_variables(5)
    349             5
    350             sage: p.add_linear_constraint(range(5), range(5), 0, 2)
    351             sage: p.row(0)
    352             ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
    353             sage: p.row_bounds(0)
    354             (2.0, 2.0)
    355         """
    356 
    357         glp_add_rows(self.lp, 1)
    358         cdef int n = glp_get_num_rows(self.lp)
    359 
    360         if direction == +1:
    361             direction = GLP_UP
    362         elif direction == -1:
    363             direction = GLP_LO
    364         else:
    365             direction = GLP_FX
    366 
    367         cdef int * row_i
    368         cdef double * row_values
    369 
    370         row_i = <int *> sage_malloc((len(indices)+1) * sizeof(int))
    371         row_values = <double *> sage_malloc((len(indices)+1) * sizeof(double))
    372 
    373         for i,v in enumerate(indices):
    374             row_i[i+1] = v+1
    375         for i,v in enumerate(coeffs):
    376             row_values[i+1] = v
    377        
    378         glp_set_mat_row(self.lp, n, len(indices), row_i, row_values)
    379         glp_set_row_bnds(self.lp, n, direction, bound, bound)
     411            if upper_bound is not None and lower_bound is None:
     412                glp_set_row_bnds(self.lp, n-i, GLP_UP, upper_bound, upper_bound)
     413            elif lower_bound is not None and upper_bound is None:
     414                glp_set_row_bnds(self.lp, n-i, GLP_LO, lower_bound, lower_bound)           
     415            elif upper_bound is not None and lower_bound is not None:
     416                if lower_bound == upper_bound:
     417                    glp_set_row_bnds(self.lp, n-i, GLP_FX, lower_bound, upper_bound)
     418                else:
     419                    glp_set_row_bnds(self.lp, n-i, GLP_DB, lower_bound, upper_bound)
    380420
    381421    cpdef row(self, int index):
    382422        r"""
    383         Returns a row
     423        Return a row
    384424
    385425        INPUT:
    386426
     
    398438            sage: from sage.numerical.backends.generic_backend import get_solver
    399439            sage: p = get_solver(solver = "GLPK")
    400440            sage: p.add_variables(5)
    401             5
    402             sage: p.add_linear_constraint(range(5), range(5), 0, 2)
     441            4
     442            sage: p.add_linear_constraint(zip(range(5), range(5)), 2, 2)
    403443            sage: p.row(0)
    404444            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
    405445            sage: p.row_bounds(0)
     
    423463        return (indices, values)
    424464
    425465    cpdef row_bounds(self, int index):
    426         r"""
    427         Returns the bounds of a specific constraint.
     466        """
     467        Return the bounds of a specific constraint.
    428468
    429469        INPUT:
    430470
     
    441481            sage: from sage.numerical.backends.generic_backend import get_solver
    442482            sage: p = get_solver(solver = "GLPK")
    443483            sage: p.add_variables(5)
    444             5
    445             sage: p.add_linear_constraint(range(5), range(5), 0, 2)
     484            4
     485            sage: p.add_linear_constraint(zip(range(5), range(5)), 2, 2)
    446486            sage: p.row(0)
    447487            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
    448488            sage: p.row_bounds(0)
     
    460500            )
    461501
    462502    cpdef col_bounds(self, int index):
    463         r"""
    464         Returns the bounds of a specific variable.
     503        """
     504        Return the bounds of a specific variable.
    465505
    466506        INPUT:
    467507
     
    478518            sage: from sage.numerical.backends.generic_backend import get_solver
    479519            sage: p = get_solver(solver = "GLPK")
    480520            sage: p.add_variable()
    481             1
     521            0
    482522            sage: p.col_bounds(0)
    483523            (0.0, None)
    484             sage: p.variable_max(0, 5)
     524            sage: p.variable_upper_bound(0, 5)
    485525            sage: p.col_bounds(0)
    486526            (0.0, 5.0)
    487527        """
     
    498538            )
    499539
    500540    cpdef double get_objective_coefficient(self, int index):
    501         r"""
    502         Returns the coefficient of a variable in the objective
     541        """
     542        Return the coefficient of a variable in the objective
    503543        function.
    504544
    505545        INPUT:
     
    511551            sage: from sage.numerical.backends.generic_backend import get_solver
    512552            sage: p = get_solver(solver = "GLPK")
    513553            sage: p.add_variable()
    514             1
     554            0
    515555            sage: p.get_objective_coefficient(0)
    516556            0.0
    517557            sage: p.set_objective_coefficient(0,2)
     
    522562           
    523563
    524564    cpdef add_col(self, list indices, list coeffs):
    525         r"""
    526         Adds a column.
     565        """
     566        Add a column.
    527567
    528568        INPUT:
    529569
     
    550590            0
    551591            sage: p.nrows()
    552592            0
    553             sage: p.add_linear_constraints(5, -1, 0)
     593            sage: p.add_linear_constraints(5, 0, None)
    554594            sage: p.add_col(range(5), range(5))
    555595            sage: p.nrows()
    556596            5
     
    575615
    576616
    577617    cpdef int solve(self) except -1:
    578         r"""
    579         Solves the problem.
     618        """
     619        Solve the problem.
    580620
    581621        .. NOTE::
    582622
     
    588628
    589629            sage: from sage.numerical.backends.generic_backend import get_solver
    590630            sage: p = get_solver(solver = "GLPK")
    591             sage: p.add_linear_constraints(5, -1, 0)
     631            sage: p.add_linear_constraints(5, 0, None)
    592632            sage: p.add_col(range(5), range(5))
    593633            sage: p.solve()
    594634            0
     
    614654        return 0
    615655
    616656    cpdef double get_objective_value(self):
    617         r"""
     657        """
    618658        Returns the value of the objective function.
    619659
    620660        .. NOTE::
    621661
    622            Has no meaning unless ``solve`` has been called before.
     662           Behaviour is undefined unless ``solve`` has been called before.
    623663
    624664        EXAMPLE::
    625665
    626666            sage: from sage.numerical.backends.generic_backend import get_solver
    627667            sage: p = get_solver(solver = "GLPK")
    628668            sage: p.add_variables(2)
    629             2
    630             sage: p.add_linear_constraint([0, 1], [1, 2], +1, 3)
     669            1
     670            sage: p.add_linear_constraint([[0, 1], [1, 2]], None, 3)
    631671            sage: p.set_objective([2, 5])
    632672            sage: p.solve()
    633673            0
     
    641681        return glp_mip_obj_val(self.lp)
    642682
    643683    cpdef double get_variable_value(self, int variable):
    644         r"""
     684        """
    645685        Returns the value of a variable given by the solver.
    646686
    647687        .. NOTE::
    648688
    649            Has no meaning unless ``solve`` has been called before.
     689           Behaviour is undefined unless ``solve`` has been called before.
    650690
    651691        EXAMPLE::
    652692
    653693            sage: from sage.numerical.backends.generic_backend import get_solver
    654694            sage: p = get_solver(solver = "GLPK")
    655695            sage: p.add_variables(2)
    656             2
    657             sage: p.add_linear_constraint([0, 1], [1, 2], +1, 3)
     696            1
     697            sage: p.add_linear_constraint([[0, 1], [1, 2]], None, 3)
    658698            sage: p.set_objective([2, 5])
    659699            sage: p.solve()
    660700            0
     
    668708        return glp_mip_col_val(self.lp, variable+1)
    669709
    670710    cpdef int ncols(self):
    671         r"""
    672         Returns the number of columns/variables.
     711        """
     712        Return the number of columns/variables.
    673713
    674714        EXAMPLE::
    675715
     
    678718            sage: p.ncols()
    679719            0
    680720            sage: p.add_variables(2)
    681             2
     721            1
    682722            sage: p.ncols()
    683723            2
    684724        """
    685725        return glp_get_num_cols(self.lp)
    686726
    687727    cpdef int nrows(self):
    688         r"""
    689         Returns the number of rows/constraints.
     728        """
     729        Return the number of rows/constraints.
    690730
    691731        EXAMPLE::
    692732
     
    694734            sage: p = get_solver(solver = "GLPK")
    695735            sage: p.nrows()
    696736            0
    697             sage: p.add_linear_constraints(2, -1, 2)
     737            sage: p.add_linear_constraints(2, 2, None)
    698738            sage: p.nrows()
    699739            2
    700740        """
     
    702742        return glp_get_num_rows(self.lp)
    703743
    704744    cpdef col_name(self, int index, char * name = NULL):
    705         r"""
    706         Returns or defines the ``index`` th col name
     745        """
     746        Return or define the ``index`` th col name
    707747
    708748        INPUT:
    709749
     
    717757            sage: from sage.numerical.backends.generic_backend import get_solver
    718758            sage: p = get_solver(solver = "GLPK")
    719759            sage: p.add_variable()
    720             1
     760            0
    721761            sage: p.col_name(0, "I am a variable")
    722762            sage: p.col_name(0)
    723763            'I am a variable'
     
    736776            glp_set_col_name(self.lp, index + 1, name)
    737777
    738778    cpdef row_name(self, int index, char * name = NULL):
    739         r"""
    740         Returns or defines the ``index`` th row name
     779        """
     780        Return or define the ``index`` th row name
    741781
    742782        INPUT:
    743783
     
    750790
    751791            sage: from sage.numerical.backends.generic_backend import get_solver
    752792            sage: p = get_solver(solver = "GLPK")
    753             sage: p.add_linear_constraints(1, -1, 2)
     793            sage: p.add_linear_constraints(1, 2, None)
    754794            sage: p.row_name(0, "Empty constraint 1")
    755795            sage: p.row_name(0)
    756796            'Empty constraint 1'
    757 
    758797        """
    759798        cdef char *  s
    760799
     
    770809            glp_set_row_name(self.lp, index + 1, name)
    771810
    772811    cpdef bint is_variable_binary(self, int index):
    773         r"""
    774         Tests whether the given variable is of binary type.
     812        """
     813        Test whether the given variable is of binary type.
    775814
    776815        INPUT:
    777816
     
    784823            sage: p.ncols()
    785824            0
    786825            sage: p.add_variable()
    787             1
     826            0
    788827            sage: p.set_variable_type(0,0)
    789828            sage: p.is_variable_binary(0)
    790829            True
     
    793832        return glp_get_col_kind(self.lp, index + 1) == GLP_BV
    794833
    795834    cpdef bint is_variable_integer(self, int index):
    796         r"""
    797         Tests whether the given variable is of integer type.
     835        """
     836        Test whether the given variable is of integer type.
    798837
    799838        INPUT:
    800839
     
    807846            sage: p.ncols()
    808847            0
    809848            sage: p.add_variable()
    810             1
     849            0
    811850            sage: p.set_variable_type(0,1)
    812851            sage: p.is_variable_integer(0)
    813852            True
     
    815854        return glp_get_col_kind(self.lp, index + 1) == GLP_IV
    816855
    817856    cpdef bint is_variable_continuous(self, int index):
    818         r"""
    819         Tests whether the given variable is of continuous/real type.
     857        """
     858        Test whether the given variable is of continuous/real type.
    820859
    821860        INPUT:
    822861
     
    829868            sage: p.ncols()
    830869            0
    831870            sage: p.add_variable()
    832             1
     871            0
    833872            sage: p.is_variable_continuous(0)
    834873            True
    835874            sage: p.set_variable_type(0,1)
     
    840879        return glp_get_col_kind(self.lp, index + 1) == GLP_CV
    841880
    842881    cpdef bint is_maximization(self):
    843         r"""
    844         Tests whether the problem is a maximization
     882        """
     883        Test whether the problem is a maximization
    845884
    846885        EXAMPLE::
    847886
     
    856895
    857896        return glp_get_obj_dir(self.lp) == GLP_MAX
    858897
    859     cpdef variable_max(self, int index, value = False):
    860         r"""
    861         Returns or defines the upper bound on a variable
     898    cpdef variable_upper_bound(self, int index, value = False):
     899        """
     900        Return or define the upper bound on a variable
    862901
    863902        INPUT:
    864903
     
    873912            sage: from sage.numerical.backends.generic_backend import get_solver
    874913            sage: p = get_solver(solver = "GLPK")
    875914            sage: p.add_variable()
    876             1
     915            0
    877916            sage: p.col_bounds(0)
    878917            (0.0, None)
    879             sage: p.variable_max(0, 5)
     918            sage: p.variable_upper_bound(0, 5)
    880919            sage: p.col_bounds(0)
    881920            (0.0, 5.0)
    882921        """
     
    909948                glp_set_col_bnds(self.lp, index + 1, GLP_DB, min, value)
    910949
    911950
    912     cpdef variable_min(self, int index, value = False):
    913         r"""
    914         Returns or defines the lower bound on a variable
     951    cpdef variable_lower_bound(self, int index, value = False):
     952        """
     953        Return or define the lower bound on a variable
    915954
    916955        INPUT:
    917956
     
    926965            sage: from sage.numerical.backends.generic_backend import get_solver
    927966            sage: p = get_solver(solver = "GLPK")
    928967            sage: p.add_variable()
    929             1
     968            0
    930969            sage: p.col_bounds(0)
    931970            (0.0, None)
    932             sage: p.variable_min(0, 5)
     971            sage: p.variable_lower_bound(0, 5)
    933972            sage: p.col_bounds(0)
    934973            (5.0, None)
    935974        """
     
    958997                glp_set_col_bnds(self.lp, index + 1, GLP_FX,  value, value)
    959998
    960999            else:
    961                 glp_set_col_bnds(self.lp, index + 1, GLP_DB, value, min)
     1000                glp_set_col_bnds(self.lp, index + 1, GLP_DB, value, max)
    9621001
    9631002    cpdef write_lp(self, char * filename):
    964         r"""
    965         Writes the problem to a .lp file
     1003        """
     1004        Write the problem to a .lp file
    9661005
    9671006        INPUT:
    9681007       
     
    9731012            sage: from sage.numerical.backends.generic_backend import get_solver
    9741013            sage: p = get_solver(solver = "GLPK")
    9751014            sage: p.add_variables(2)
    976             2
    977             sage: p.add_linear_constraint([0, 1], [1, 2], +1, 3)
     1015            1
     1016            sage: p.add_linear_constraint([[0, 1], [1, 2]], None, 3)
    9781017            sage: p.set_objective([2, 5])
    9791018            sage: p.write_lp(SAGE_TMP+"/lp_problem.lp")
    9801019        """
    9811020        glp_write_lp(self.lp, NULL, filename)
    9821021
    9831022    cpdef write_mps(self, char * filename, int modern):
    984         r"""
    985         Writes the problem to a .mps file
     1023        """
     1024        Write the problem to a .mps file
    9861025
    9871026        INPUT:
    9881027       
     
    9931032            sage: from sage.numerical.backends.generic_backend import get_solver
    9941033            sage: p = get_solver(solver = "GLPK")
    9951034            sage: p.add_variables(2)
    996             2
    997             sage: p.add_linear_constraint([0, 1], [1, 2], +1, 3)
     1035            1
     1036            sage: p.add_linear_constraint([[0, 1], [1, 2]], None, 3)
    9981037            sage: p.set_objective([2, 5])
    9991038            sage: p.write_lp(SAGE_TMP+"/lp_problem.lp")
    10001039        """
    10011040        glp_write_mps(self.lp, modern, NULL,  filename)
    10021041
    10031042    def __dealloc__(self):
    1004         r"""
     1043        """
    10051044        Destructor
    10061045        """
    10071046        glp_delete_prob(self.lp)
  • sage/numerical/mip.pyx

    diff -r cbaf095a0f0d -r 073e4cbe35f3 sage/numerical/mip.pyx
    a b  
    762762            indices = []
    763763            values = []
    764764
    765             for (v,coeff) in f.iteritems():
    766                 if v != -1:
    767                     indices.append(v)
    768                     values.append(coeff)
     765            C = [(v,coeff) for (v,coeff) in f.iteritems() if v != -1]
    769766
    770767            if min == None and max == None:
    771                 raise ValueError("Both max and min are set to None ? Weird !")
    772             elif min == max:
    773                 self._backend.add_linear_constraint(indices, values, 0, min)
    774             elif min != None:
    775                 self._backend.add_linear_constraint(indices, values, -1, min)
    776             elif max != None:
    777                 self._backend.add_linear_constraint(indices, values, +1, max)
     768                raise ValueError("Both max and min are set to None ? Weird!")
     769
     770            self._backend.add_linear_constraint(C, min, max)
    778771
    779772            if name != None:
    780773                self._backend.row_name(self._backend.nrows()-1,name)
    781774
    782775        elif isinstance(linear_function,LinearConstraint):
     776            #######
     777            ####### IS THIS DEAD CODE???
     778            #######
    783779            functions = linear_function.constraints
    784780           
    785781            if linear_function.equality:
     
    11291125            sage: p.get_min(v[1])
    11301126            6.0
    11311127        """
    1132         self._backend.variable_min(self._variables[v], min)
     1128        self._backend.variable_lower_bound(self._variables[v], min)
    11331129
    11341130    def set_max(self, v, max):
    11351131        r"""
     
    11531149            6.0
    11541150        """
    11551151
    1156         self._backend.variable_max(self._variables[v], max)
     1152        self._backend.variable_upper_bound(self._variables[v], max)
    11571153
    11581154    def get_min(self, v):
    11591155        r"""
     
    11801176            6.0
    11811177        """
    11821178
    1183         return self._backend.variable_min(self._variables[v])
     1179        return self._backend.variable_lower_bound(self._variables[v])
    11841180
    11851181    def get_max(self, v):
    11861182        r"""
     
    12061202            6.0
    12071203        """
    12081204
    1209         return self._backend.variable_max(self._variables[v])
     1205        return self._backend.variable_upper_bound(self._variables[v])
    12101206
    12111207class MIPSolverException(Exception):
    12121208    r"""