### Navigation

- index
- modules |
- next |
- previous |
- Numerical Optimization »

# Generic Backend for LP solvers

Generic Backend for LP solvers

This class only lists the methods that should be defined by any interface with a LP Solver. All these methods immediately raise `NotImplementedError` exceptions when called, and are obviously meant to be replaced by the solver-specific method. This file can also be used as a template to create a new interface : one would only need to replace the occurrences of `"Nonexistent_LP_solver"` by the solver’s name, and replace `GenericBackend` by `SolverName(GenericBackend)` so that the new solver extends this class.

AUTHORS:

- Nathann Cohen (2010-10) : initial implementation
- Risan (2012-02) : extension for PPL backend
- Ingolfur Edvardsson (2014-06): extension for CVXOPT backend

class `sage.numerical.backends.generic_backend.``GenericBackend`

  Bases: `object`

  x.__init__(...) initializes x; see help(type(x)) for signature

  `add_col`(indices, coeffs)

    Add a column.

    INPUT:

    - `indices` (list of integers) – this list contains the indices of the constraints in which the variable’s coefficient is nonzero
    - `coeffs` (list of real values) – associates a coefficient to the variable in each of the constraints in which it appears. Namely, the i-th entry of `coeffs` corresponds to the coefficient of the variable in the constraint represented by the i-th entry in `indices`.

    Note

    `indices` and `coeffs` are expected to be of the same length.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.ncols()                                       # optional - Nonexistent_LP_solver
        0
        sage: p.nrows()                                       # optional - Nonexistent_LP_solver
        0
        sage: p.add_linear_constraints(5, 0, None)            # optional - Nonexistent_LP_solver
        sage: p.add_col(range(5), range(5))                   # optional - Nonexistent_LP_solver
        sage: p.nrows()                                       # optional - Nonexistent_LP_solver
        5

  `add_linear_constraint`(coefficients, lower_bound, upper_bound, name=None)

    Add a linear constraint.

    INPUT:

    - `coefficients` – an iterable of pairs `(i, v)`. In each pair, `i` is a variable index (integer) and `v` is a value (element of `base_ring()`).
    - `lower_bound` – element of `base_ring()` or `None`. The lower bound.
    - `upper_bound` – element of `base_ring()` or `None`. The upper bound.
    - `name` – string or `None`. Optional name for this row.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import GenericBackend
        sage: solver = GenericBackend()
        sage: solver.add_linear_constraint(zip(range(5), range(5)), 2.0, 2.0)
        Traceback (most recent call last):
        ...
        NotImplementedError: add_linear_constraint

  `add_linear_constraint_vector`(degree, coefficients, lower_bound, upper_bound, name=None)

    Add a vector-valued linear constraint.

    Note

    This is the generic implementation, which will split the vector-valued constraint into components and add these individually. Backends are encouraged to replace it with their own optimized implementation.

    INPUT:

    - `degree` – integer. The vector degree, that is, the number of new scalar constraints.
    - `coefficients` – an iterable of pairs `(i, v)`. In each pair, `i` is a variable index (integer) and `v` is a vector (real and of length `degree`).
    - `lower_bound` – either a vector or `None`. The component-wise lower bound.
    - `upper_bound` – either a vector or `None`. The component-wise upper bound.
    - `name` – string or `None`. An optional name for all new rows.

    EXAMPLE:

        sage: coeffs = ([0, vector([1, 2])], [1, vector([2, 3])])
        sage: upper = vector([5, 5])
        sage: lower = vector([0, 0])
        sage: from sage.numerical.backends.generic_backend import GenericBackend
        sage: solver = GenericBackend()
        sage: solver.add_linear_constraint_vector(2, coeffs, lower, upper, 'foo')
        Traceback (most recent call last):
        ...
        NotImplementedError: add_linear_constraint

  `add_linear_constraints`(number, lower_bound, upper_bound, names=None)

    Add constraints.

    INPUT:

    - `number` (integer) – the number of constraints to add.
    - `lower_bound` - a lower bound, either a real value or `None`
    - `upper_bound` - an upper bound, either a real value or `None`
    - `names` - an optional list of names (default: `None`)

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
        sage: p.add_variables(5)                                # optional - Nonexistent_LP_solver
        5
        sage: p.add_linear_constraints(5, None, 2)          # optional - Nonexistent_LP_solver
        sage: p.row(4)                                      # optional - Nonexistent_LP_solver
        ([], [])
        sage: p.row_bounds(4)                               # optional - Nonexistent_LP_solver
        (None, 2.0)

  `add_variable`(lower_bound=None, upper_bound=None, binary=False, continuous=True, integer=False, obj=None, name=None)

    Add a variable.

    This amounts to adding a new column to the matrix. By default, the variable is both positive and real.

    INPUT:

    - `lower_bound` - the lower bound of the variable (default: 0)
    - `upper_bound` - the upper bound of the variable (default: `None`)
    - `binary` - `True` if the variable is binary (default: `False`).
    - `continuous` - `True` if the variable is binary (default: `True`).
    - `integer` - `True` if the variable is binary (default: `False`).
    - `obj` - (optional) coefficient of this variable in the objective function (default: 0.0)
    - `name` - an optional name for the newly added variable (default: `None`).

    OUTPUT: The index of the newly created variable

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")    # optional - Nonexistent_LP_solver
        sage: p.ncols()                                           # optional - Nonexistent_LP_solver
        0
        sage: p.add_variable()                                    # optional - Nonexistent_LP_solver
        0
        sage: p.ncols()                                           # optional - Nonexistent_LP_solver
        1
        sage: p.add_variable(binary=True)                         # optional - Nonexistent_LP_solver
        1
        sage: p.add_variable(lower_bound=-2.0, integer=True)      # optional - Nonexistent_LP_solver
        2
        sage: p.add_variable(continuous=True, integer=True)       # optional - Nonexistent_LP_solver
        Traceback (most recent call last):
        ...
        ValueError: ...
        sage: p.add_variable(name='x',obj=1.0)                    # optional - Nonexistent_LP_solver
        3
        sage: p.col_name(3)                                       # optional - Nonexistent_LP_solver
        'x'
        sage: p.objective_coefficient(3)                          # optional - Nonexistent_LP_solver
        1.0

  `add_variables`(n, lower_bound=None, upper_bound=None, binary=False, continuous=True, integer=False, obj=None, names=None)

    Add `n` variables.

    This amounts to adding new columns to the matrix. By default, the variables are both positive and real.

    INPUT:

    - `n` - the number of new variables (must be > 0)
    - `lower_bound` - the lower bound of the variable (default: 0)
    - `upper_bound` - the upper bound of the variable (default: `None`)
    - `binary` - `True` if the variable is binary (default: `False`).
    - `continuous` - `True` if the variable is binary (default: `True`).
    - `integer` - `True` if the variable is binary (default: `False`).
    - `obj` - (optional) coefficient of all variables in the objective function (default: 0.0)
    - `names` - optional list of names (default: `None`)

    OUTPUT: The index of the variable created last.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")    # optional - Nonexistent_LP_solver
        sage: p.ncols()                                           # optional - Nonexistent_LP_solver
        0
        sage: p.add_variables(5)                                  # optional - Nonexistent_LP_solver
        4
        sage: p.ncols()                                           # optional - Nonexistent_LP_solver
        5
        sage: p.add_variables(2, lower_bound=-2.0, integer=True, names=['a','b']) # optional - Nonexistent_LP_solver
        6

  `base_ring`()
  `col_bounds`(index)

    Return the bounds of a specific variable.

    INPUT:

    - `index` (integer) – the variable’s id.

    OUTPUT:

    A pair `(lower_bound, upper_bound)`. Each of them can be set to `None` if the variable is not bounded in the corresponding direction, and is a real value otherwise.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
        1
        sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
        (0.0, None)
        sage: p.variable_upper_bound(0, 5)                 # optional - Nonexistent_LP_solver
        sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
        (0.0, 5.0)

  `col_name`(index)

    Return the `index`-th column name

    INPUT:

    - `index` (integer) – the column id
    - `name` (`char *`) – its name. When set to `NULL` (default), the method returns the current name.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.add_variable(name="I am a variable")            # optional - Nonexistent_LP_solver
        1
        sage: p.col_name(0)                                     # optional - Nonexistent_LP_solver
        'I am a variable'

  `get_objective_value`()

    Return the value of the objective function.

    Note

    Behavior is undefined unless `solve` has been called before.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
        sage: p.add_variables(2)                               # optional - Nonexistent_LP_solver
        2
        sage: p.add_linear_constraint([(0,1), (1,2)], None, 3) # optional - Nonexistent_LP_solver
        sage: p.set_objective([2, 5])                          # optional - Nonexistent_LP_solver
        sage: p.solve()                                        # optional - Nonexistent_LP_solver
        0
        sage: p.get_objective_value()                          # optional - Nonexistent_LP_solver
        7.5
        sage: p.get_variable_value(0)                          # optional - Nonexistent_LP_solver
        0.0
        sage: p.get_variable_value(1)                          # optional - Nonexistent_LP_solver
        1.5

  `get_variable_value`(variable)

    Return the value of a variable given by the solver.

    Note

    Behavior is undefined unless `solve` has been called before.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
        sage: p.add_variables(2)                              # optional - Nonexistent_LP_solver
        2
        sage: p.add_linear_constraint([(0,1), (1, 2)], None, 3) # optional - Nonexistent_LP_solver
        sage: p.set_objective([2, 5])                         # optional - Nonexistent_LP_solver
        sage: p.solve()                                       # optional - Nonexistent_LP_solver
        0
        sage: p.get_objective_value()                         # optional - Nonexistent_LP_solver
        7.5
        sage: p.get_variable_value(0)                         # optional - Nonexistent_LP_solver
        0.0
        sage: p.get_variable_value(1)                         # optional - Nonexistent_LP_solver
        1.5

  `is_maximization`()

    Test whether the problem is a maximization

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
        sage: p.is_maximization()                             # optional - Nonexistent_LP_solver
        True
        sage: p.set_sense(-1)                             # optional - Nonexistent_LP_solver
        sage: p.is_maximization()                             # optional - Nonexistent_LP_solver
        False

  `is_variable_binary`(index)

    Test whether the given variable is of binary type.

    INPUT:

    - `index` (integer) – the variable’s id

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.ncols()                                       # optional - Nonexistent_LP_solver
        0
        sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
        1
        sage: p.set_variable_type(0,0)                         # optional - Nonexistent_LP_solver
        sage: p.is_variable_binary(0)                          # optional - Nonexistent_LP_solver
        True

  `is_variable_continuous`(index)

    Test whether the given variable is of continuous/real type.

    INPUT:

    - `index` (integer) – the variable’s id

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.ncols()                                       # optional - Nonexistent_LP_solver
        0
        sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
        1
        sage: p.is_variable_continuous(0)                      # optional - Nonexistent_LP_solver
        True
        sage: p.set_variable_type(0,1)                         # optional - Nonexistent_LP_solver
        sage: p.is_variable_continuous(0)                      # optional - Nonexistent_LP_solver
        False

  `is_variable_integer`(index)

    Test whether the given variable is of integer type.

    INPUT:

    - `index` (integer) – the variable’s id

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.ncols()                                       # optional - Nonexistent_LP_solver
        0
        sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
        1
        sage: p.set_variable_type(0,1)                         # optional - Nonexistent_LP_solver
        sage: p.is_variable_integer(0)                         # optional - Nonexistent_LP_solver
        True

  `ncols`()

    Return the number of columns/variables.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.ncols()                                       # optional - Nonexistent_LP_solver
        0
        sage: p.add_variables(2)                               # optional - Nonexistent_LP_solver
        2
        sage: p.ncols()                                       # optional - Nonexistent_LP_solver
        2

  `nrows`()

    Return the number of rows/constraints.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
        sage: p.nrows()                                        # optional - Nonexistent_LP_solver
        0
        sage: p.add_linear_constraints(2, 2.0, None)         # optional - Nonexistent_LP_solver
        sage: p.nrows()                                      # optional - Nonexistent_LP_solver
        2

  `objective_coefficient`(variable, coeff=None)

    Set or get the coefficient of a variable in the objective function

    INPUT:

    - `variable` (integer) – the variable’s id
    - `coeff` (double) – its coefficient

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
        1
        sage: p.objective_coefficient(0)                         # optional - Nonexistent_LP_solver
        0.0
        sage: p.objective_coefficient(0,2)                       # optional - Nonexistent_LP_solver
        sage: p.objective_coefficient(0)                         # optional - Nonexistent_LP_solver
        2.0

  `problem_name`(name='NULL')

    Return or define the problem’s name

    INPUT:

    - `name` (`char *`) – the problem’s name. When set to `NULL` (default), the method returns the problem’s name.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
        sage: p.problem_name("There once was a french fry") # optional - Nonexistent_LP_solver
        sage: print p.get_problem_name()                        # optional - Nonexistent_LP_solver
        There once was a french fry

  `remove_constraint`(i)

    Remove a constraint.

    INPUT:

        - ``i`` -- index of the constraint to remove.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.add_constraint(p[0] + p[1], max = 10)           # optional - Nonexistent_LP_solver
        sage: p.remove_constraint(0)                            # optional - Nonexistent_LP_solver

  `remove_constraints`(constraints)

    Remove several constraints.

    INPUT:

    - `constraints` – an iterable containing the indices of the rows to remove.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.add_constraint(p[0] + p[1], max = 10)           # optional - Nonexistent_LP_solver
        sage: p.remove_constraints([0])                         # optional - Nonexistent_LP_solver

  `row`(i)

    Return a row

    INPUT:

    - `index` (integer) – the constraint’s id.

    OUTPUT:

    A pair `(indices, coeffs)` where `indices` lists the entries whose coefficient is nonzero, and to which `coeffs` associates their coefficient on the model of the `add_linear_constraint` method.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.add_variables(5)                               # optional - Nonexistent_LP_solver
        5
        sage: p.add_linear_constraint(zip(range(5), range(5)), 2, 2) # optional - Nonexistent_LP_solver
        sage: p.row(0)                                     # optional - Nonexistent_LP_solver
        ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
        sage: p.row_bounds(0)                              # optional - Nonexistent_LP_solver
        (2.0, 2.0)

  `row_bounds`(index)

    Return the bounds of a specific constraint.

    INPUT:

    - `index` (integer) – the constraint’s id.

    OUTPUT:

    A pair `(lower_bound, upper_bound)`. Each of them can be set to `None` if the constraint is not bounded in the corresponding direction, and is a real value otherwise.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.add_variables(5)                               # optional - Nonexistent_LP_solver
        5
        sage: p.add_linear_constraint(range(5), range(5), 2, 2) # optional - Nonexistent_LP_solver
        sage: p.row(0)                                     # optional - Nonexistent_LP_solver
        ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
        sage: p.row_bounds(0)                              # optional - Nonexistent_LP_solver
        (2.0, 2.0)

  `row_name`(index)

    Return the `index` th row name

    INPUT:

    - `index` (integer) – the row’s id

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.add_linear_constraints(1, 2, None, name="Empty constraint 1")  # optional - Nonexistent_LP_solver
        sage: p.row_name(0)                                     # optional - Nonexistent_LP_solver
        'Empty constraint 1'

  `set_objective`(coeff, d=0.0)

    Set the objective function.

    INPUT:

    - `coeff` – a list of real values, whose i-th element is the coefficient of the i-th variable in the objective function.
    - `d` (double) – the constant term in the linear function (set to \(0\) by default)

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")    # optional - Nonexistent_LP_solver
        sage: p.add_variables(5)                                 # optional - Nonexistent_LP_solver
        5
        sage: p.set_objective([1, 1, 2, 1, 3])                   # optional - Nonexistent_LP_solver
        sage: map(lambda x :p.objective_coefficient(x), range(5))  # optional - Nonexistent_LP_solver
        [1.0, 1.0, 2.0, 1.0, 3.0]

    Constants in the objective function are respected:

        sage: p = MixedIntegerLinearProgram(solver='Nonexistent_LP_solver') # optional - Nonexistent_LP_solver
        sage: x,y = p[0], p[1]                              # optional - Nonexistent_LP_solver
        sage: p.add_constraint(2*x + 3*y, max = 6)          # optional - Nonexistent_LP_solver
        sage: p.add_constraint(3*x + 2*y, max = 6)          # optional - Nonexistent_LP_solver
        sage: p.set_objective(x + y + 7)                    # optional - Nonexistent_LP_solver
        sage: p.set_integer(x); p.set_integer(y)            # optional - Nonexistent_LP_solver
        sage: p.solve()                                     # optional - Nonexistent_LP_solver
        9.0

  `set_sense`(sense)

    Set the direction (maximization/minimization).

    INPUT:

    - `sense` (integer) :

      > - +1 => Maximization
      > - -1 => Minimization

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.is_maximization()                              # optional - Nonexistent_LP_solver
        True
        sage: p.set_sense(-1)                              # optional - Nonexistent_LP_solver
        sage: p.is_maximization()                              # optional - Nonexistent_LP_solver
        False

  `set_variable_type`(variable, vtype)

    Set the type of a variable

    INPUT:

    - `variable` (integer) – the variable’s id

    - `vtype` (integer) :

      > - 1 Integer

      > - 0 Binary

      > - `-1` | Continuous

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
        sage: p.ncols()                                        # optional - Nonexistent_LP_solver
        0
        sage: p.add_variable()                                  # optional - Nonexistent_LP_solver
        1
        sage: p.set_variable_type(0,1)                          # optional - Nonexistent_LP_solver
        sage: p.is_variable_integer(0)                          # optional - Nonexistent_LP_solver
        True

  `set_verbosity`(level)

    Set the log (verbosity) level

    INPUT:

    - `level` (integer) – From 0 (no verbosity) to 3.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.set_verbosity(2)                                # optional - Nonexistent_LP_solver

  `solve`()

    Solve the problem.

    Note

    This method raises `MIPSolverException` exceptions when the solution can not be computed for any reason (none exists, or the LP solver was not able to find it, etc...)

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
        sage: p.add_linear_constraints(5, 0, None)             # optional - Nonexistent_LP_solver
        sage: p.add_col(range(5), range(5))                    # optional - Nonexistent_LP_solver
        sage: p.solve()                                        # optional - Nonexistent_LP_solver
        0
        sage: p.objective_coefficient(0,1)                 # optional - Nonexistent_LP_solver
        sage: p.solve()                                        # optional - Nonexistent_LP_solver
        Traceback (most recent call last):
        ...
        MIPSolverException: ...

  `solver_parameter`(name, value=None)

    Return or define a solver parameter

    INPUT:

    - `name` (string) – the parameter
    - `value` – the parameter’s value if it is to be defined, or `None` (default) to obtain its current value.

    Note

    The list of available parameters is available at `solver_parameter()`.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.solver_parameter("timelimit")                   # optional - Nonexistent_LP_solver
        sage: p.solver_parameter("timelimit", 60)               # optional - Nonexistent_LP_solver
        sage: p.solver_parameter("timelimit")                   # optional - Nonexistent_LP_solver

  `variable_lower_bound`(index, value=None)

    Return or define the lower bound on a variable

    INPUT:

    - `index` (integer) – the variable’s id
    - `value` – real value, or `None` to mean that the variable has not lower bound. When set to `None` (default), the method returns the current value.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
        1
        sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
        (0.0, None)
        sage: p.variable_lower_bound(0, 5)                 # optional - Nonexistent_LP_solver
        sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
        (5.0, None)

  `variable_upper_bound`(index, value=None)

    Return or define the upper bound on a variable

    INPUT:

    - `index` (integer) – the variable’s id
    - `value` – real value, or `None` to mean that the variable has not upper bound. When set to `None` (default), the method returns the current value.

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
        1
        sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
        (0.0, None)
        sage: p.variable_upper_bound(0, 5)                 # optional - Nonexistent_LP_solver
        sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
        (0.0, 5.0)

  `write_lp`(name)

    Write the problem to a `.lp` file

    INPUT:

    - `filename` (string)

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.add_variables(2)                               # optional - Nonexistent_LP_solver
        2
        sage: p.add_linear_constraint([(0, 1], (1, 2)], None, 3) # optional - Nonexistent_LP_solver
        sage: p.set_objective([2, 5])                          # optional - Nonexistent_LP_solver
        sage: p.write_lp(os.path.join(SAGE_TMP, "lp_problem.lp"))            # optional - Nonexistent_LP_solver

  `write_mps`(name, modern)

    Write the problem to a `.mps` file

    INPUT:

    - `filename` (string)

    EXAMPLE:

        sage: from sage.numerical.backends.generic_backend import get_solver
        sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
        sage: p.add_variables(2)                               # optional - Nonexistent_LP_solver
        2
        sage: p.add_linear_constraint([(0, 1), (1, 2)], None, 3) # optional - Nonexistent_LP_solver
        sage: p.set_objective([2, 5])                          # optional - Nonexistent_LP_solver
        sage: p.write_lp(os.path.join(SAGE_TMP, "lp_problem.lp"))            # optional - Nonexistent_LP_solver

  `zero`()

`sage.numerical.backends.generic_backend.``default_mip_solver`(solver=None)

  Returns/Sets the default MILP Solver used by Sage

  INPUT:

  - `solver` – defines the solver to use:

    > - GLPK (`solver="GLPK"`). See the GLPK web site.
    > - COIN Branch and Cut (`solver="Coin"`). See the COIN-OR web site.
    > - CPLEX (`solver="CPLEX"`). See the CPLEX web site.
    > - CVXOPT (`solver="CVXOPT"`). See the CVXOPT web site.
    > - PPL (`solver="PPL"`). See the PPL web site.
    > - Gurobi (`solver="Gurobi"`). See the Gurobi web site.

    > `solver` should then be equal to one of `"GLPK"`, `"Coin"`, `"CPLEX"`, `"CVXOPT"`, `"Gurobi"` or `"PPL"` .

    > - If `solver=None` (default), the current default solver’s name is returned.

  OUTPUT:

  This function returns the current default solver’s name if `solver = None` (default). Otherwise, it sets the default solver to the one given. If this solver does not exist, or is not available, a `ValueError` exception is raised.

  EXAMPLE:

      sage: former_solver = default_mip_solver()
      sage: default_mip_solver("GLPK")
      sage: default_mip_solver()
      'Glpk'
      sage: default_mip_solver("PPL")
      sage: default_mip_solver()
      'Ppl'
      sage: default_mip_solver("GUROBI")
      Traceback (most recent call last):
      ...
      ValueError: Gurobi is not available. Please refer to the documentation to install it.
      sage: default_mip_solver("Yeahhhhhhhhhhh")
      Traceback (most recent call last):
      ...
      ValueError: 'solver' should be set to 'GLPK', 'Coin', 'CPLEX', 'Gurobi', 'CVXOPT', 'PPL' or None.
      sage: default_mip_solver(former_solver)

`sage.numerical.backends.generic_backend.``get_solver`(constraint_generation=False, solver=None)

  Return a solver according to the given preferences

  INPUT:

  - `solver` – 6 solvers should be available through this class:

    > - GLPK (`solver="GLPK"`). See the GLPK web site.
    > - COIN Branch and Cut (`solver="Coin"`). See the COIN-OR web site.
    > - CPLEX (`solver="CPLEX"`). See the CPLEX web site.
    > - CVXOPT (`solver="CVXOPT"`). See the CVXOPT web site.
    > - Gurobi (`solver="Gurobi"`). See the Gurobi web site.
    > - PPL (`solver="PPL"`). See the PPL web site.

    > `solver` should then be equal to one of `"GLPK"`, `"Coin"`, `"CPLEX"`, `"CVXOPT"`,``”Gurobi”`, ``"PPL"`, or `None`. If `solver=None` (default), the default solver is used (see `default_mip_solver` method.

  - `constraint_generation` – Only used when `solver=None`.

    - When set to `True`, after solving the `MixedIntegerLinearProgram`, it is possible to add a constraint, and then solve it again. The effect is that solvers that do not support this feature will not be used.
    - Defaults to `False`.

  See also

  - `default_mip_solver()` – Returns/Sets the default MIP solver.

  EXAMPLE:

      sage: from sage.numerical.backends.generic_backend import get_solver
      sage: p = get_solver()

### Navigation

- index
- modules |
- next |
- previous |
- Numerical Optimization »