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

EXAMPLE:

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

Previous topic

Interactive Simplex Method

Next topic

GLPK Backend

This Page