Python Reference: Linear Solver

Module pywraplp

Expand source code
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.1
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _pywraplp
else:
    import _pywraplp

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)



import numbers
from ortools.linear_solver.linear_solver_natural_api import OFFSET_KEY
from ortools.linear_solver.linear_solver_natural_api import inf
from ortools.linear_solver.linear_solver_natural_api import LinearExpr
from ortools.linear_solver.linear_solver_natural_api import ProductCst
from ortools.linear_solver.linear_solver_natural_api import Sum
from ortools.linear_solver.linear_solver_natural_api import SumArray
from ortools.linear_solver.linear_solver_natural_api import SumCst
from ortools.linear_solver.linear_solver_natural_api import LinearConstraint
from ortools.linear_solver.linear_solver_natural_api import VariableExpr

# Remove the documentation of some functions.
# See https://pdoc3.github.io/pdoc/doc/pdoc/#overriding-docstrings-with-
__pdoc__ = {}
__pdoc__['Solver_infinity'] = False
__pdoc__['Solver_Infinity'] = False
__pdoc__['Solver_SolveWithProto'] = False
__pdoc__['Solver_SupportsProblemType'] = False
__pdoc__['setup_variable_operator'] = False
__pdoc__['Constraint.thisown'] = False
__pdoc__['Constraint.thisown'] = False
__pdoc__['MPSolverParameters.thisown'] = False
__pdoc__['ModelExportOptions.thisown'] = False
__pdoc__['Objective.thisown'] = False
__pdoc__['Solver.thisown'] = False
__pdoc__['Variable.thisown'] = False

class Solver(object):
    r"""
    This mathematical programming (MP) solver class is the main class
    though which users build and solve problems.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CLP_LINEAR_PROGRAMMING = _pywraplp.Solver_CLP_LINEAR_PROGRAMMING
    r""" Linear Programming solver using Coin CBC."""
    GLOP_LINEAR_PROGRAMMING = _pywraplp.Solver_GLOP_LINEAR_PROGRAMMING
    r""" Linear Programming solver using GLOP (Recommended solver)."""
    CBC_MIXED_INTEGER_PROGRAMMING = _pywraplp.Solver_CBC_MIXED_INTEGER_PROGRAMMING
    r""" Mixed integer Programming Solver using Coin CBC."""
    BOP_INTEGER_PROGRAMMING = _pywraplp.Solver_BOP_INTEGER_PROGRAMMING
    r""" Linear Boolean Programming Solver."""

    def __init__(self, name: "std::string const &", problem_type: "operations_research::MPSolver::OptimizationProblemType"):
        r""" Create a solver with the given name and underlying solver backend."""
        _pywraplp.Solver_swiginit(self, _pywraplp.new_Solver(name, problem_type))
    __swig_destroy__ = _pywraplp.delete_Solver

    @staticmethod
    def SupportsProblemType(problem_type: "operations_research::MPSolver::OptimizationProblemType") -> "bool":
        r"""
        Whether the given problem type is supported (this will depend on the
        targets that you linked).
        """
        return _pywraplp.Solver_SupportsProblemType(problem_type)

    def Clear(self) -> "void":
        r"""
        Clears the objective (including the optimization direction), all variables
        and constraints. All the other properties of the MPSolver (like the time
        limit) are kept untouched.
        """
        return _pywraplp.Solver_Clear(self)

    def NumVariables(self) -> "int":
        r""" Returns the number of variables."""
        return _pywraplp.Solver_NumVariables(self)

    def variables(self) -> "std::vector< operations_research::MPVariable * > const &":
        r"""
        Returns the array of variables handled by the MPSolver. (They are listed in
        the order in which they were created.)
        """
        return _pywraplp.Solver_variables(self)

    def LookupVariable(self, var_name: "std::string const &") -> "operations_research::MPVariable *":
        r"""
        Looks up a variable by name, and returns nullptr if it does not exist. The
        first call has a O(n) complexity, as the variable name index is lazily
        created upon first use. Will crash if variable names are not unique.
        """
        return _pywraplp.Solver_LookupVariable(self, var_name)

    def Var(self, lb: "double", ub: "double", integer: "bool", name: "std::string const &") -> "operations_research::MPVariable *":
        r"""
        Creates a variable with the given bounds, integrality requirement and
        name. Bounds can be finite or +/- MPSolver::infinity(). The MPSolver owns
        the variable (i.e. the returned pointer is borrowed). Variable names are
        optional. If you give an empty name, name() will auto-generate one for you
        upon request.
        """
        return _pywraplp.Solver_Var(self, lb, ub, integer, name)

    def NumVar(self, lb: "double", ub: "double", name: "std::string const &") -> "operations_research::MPVariable *":
        r""" Creates a continuous variable."""
        return _pywraplp.Solver_NumVar(self, lb, ub, name)

    def IntVar(self, lb: "double", ub: "double", name: "std::string const &") -> "operations_research::MPVariable *":
        r""" Creates an integer variable."""
        return _pywraplp.Solver_IntVar(self, lb, ub, name)

    def BoolVar(self, name: "std::string const &") -> "operations_research::MPVariable *":
        r""" Creates a boolean variable."""
        return _pywraplp.Solver_BoolVar(self, name)

    def NumConstraints(self) -> "int":
        r""" Returns the number of constraints."""
        return _pywraplp.Solver_NumConstraints(self)

    def constraints(self) -> "std::vector< operations_research::MPConstraint * > const &":
        r"""
        Returns the array of constraints handled by the MPSolver.

        They are listed in the order in which they were created.
        """
        return _pywraplp.Solver_constraints(self)

    def LookupConstraint(self, constraint_name: "std::string const &") -> "operations_research::MPConstraint *":
        r"""
         Looks up a constraint by name, and returns nullptr if it does not exist.

        The first call has a O(n) complexity, as the constraint name index is
        lazily created upon first use. Will crash if constraint names are not
        unique.
        """
        return _pywraplp.Solver_LookupConstraint(self, constraint_name)

    def Constraint(self, *args) -> "operations_research::MPConstraint *":
        r"""
        *Overload 1:*

        Creates a linear constraint with given bounds.

        Bounds can be finite or +/- MPSolver::infinity(). The MPSolver class
        assumes ownership of the constraint.

        :rtype: :py:class:`MPConstraint`
        :return: a pointer to the newly created constraint.

        |

        *Overload 2:*
         Creates a constraint with -infinity and +infinity bounds.

        |

        *Overload 3:*
         Creates a named constraint with given bounds.

        |

        *Overload 4:*
         Creates a named constraint with -infinity and +infinity bounds.
        """
        return _pywraplp.Solver_Constraint(self, *args)

    def Objective(self) -> "operations_research::MPObjective *":
        r""" Returns the mutable objective object."""
        return _pywraplp.Solver_Objective(self)
    OPTIMAL = _pywraplp.Solver_OPTIMAL
    r""" optimal."""
    FEASIBLE = _pywraplp.Solver_FEASIBLE
    r""" feasible, or stopped by limit."""
    INFEASIBLE = _pywraplp.Solver_INFEASIBLE
    r""" proven infeasible."""
    UNBOUNDED = _pywraplp.Solver_UNBOUNDED
    r""" proven unbounded."""
    ABNORMAL = _pywraplp.Solver_ABNORMAL
    r""" abnormal, i.e., error of some kind."""
    NOT_SOLVED = _pywraplp.Solver_NOT_SOLVED
    r""" not been solved yet."""

    def Solve(self, *args) -> "operations_research::MPSolver::ResultStatus":
        r"""
        *Overload 1:*
        Solves the problem using default parameter values.

        |

        *Overload 2:*
        Solves the problem using the specified parameter values.
        """
        return _pywraplp.Solver_Solve(self, *args)

    def ComputeConstraintActivities(self) -> "std::vector< double >":
        r"""
        Advanced usage: compute the "activities" of all constraints, which are the
        sums of their linear terms. The activities are returned in the same order
        as constraints(), which is the order in which constraints were added; but
        you can also use MPConstraint::index() to get a constraint's index.
        """
        return _pywraplp.Solver_ComputeConstraintActivities(self)

    def VerifySolution(self, tolerance: "double", log_errors: "bool") -> "bool":
        r"""
        Advanced usage: Verifies the *correctness* of the solution.

        It verifies that all variables must be within their domains, all
        constraints must be satisfied, and the reported objective value must be
        accurate.

        Usage:
        - This can only be called after Solve() was called.
        - "tolerance" is interpreted as an absolute error threshold.
        - For the objective value only, if the absolute error is too large,
          the tolerance is interpreted as a relative error threshold instead.
        - If "log_errors" is true, every single violation will be logged.
        - If "tolerance" is negative, it will be set to infinity().

        Most users should just set the --verify_solution flag and not bother using
        this method directly.
        """
        return _pywraplp.Solver_VerifySolution(self, tolerance, log_errors)

    def InterruptSolve(self) -> "bool":
        r"""
         Interrupts the Solve() execution to terminate processing if possible.

        If the underlying interface supports interruption; it does that and returns
        true regardless of whether there's an ongoing Solve() or not. The Solve()
        call may still linger for a while depending on the conditions.  If
        interruption is not supported; returns false and does nothing.
        """
        return _pywraplp.Solver_InterruptSolve(self)

    def FillSolutionResponseProto(self, response: "operations_research::MPSolutionResponse *") -> "void":
        r""" Encodes the current solution in a solution response protocol buffer."""
        return _pywraplp.Solver_FillSolutionResponseProto(self, response)

    @staticmethod
    def SolveWithProto(model_request: "operations_research::MPModelRequest const &", response: "operations_research::MPSolutionResponse *") -> "operations_research::MPSolutionResponse *":
        r"""
        Solves the model encoded by a MPModelRequest protocol buffer and fills the
        solution encoded as a MPSolutionResponse.

        Note(user): This creates a temporary MPSolver and destroys it at the end.
        If you want to keep the MPSolver alive (for debugging, or for incremental
        solving), you should write another version of this function that creates
        the MPSolver object on the heap and returns it.
        """
        return _pywraplp.Solver_SolveWithProto(model_request, response)

    def ExportModelToProto(self, output_model: "operations_research::MPModelProto *") -> "void":
        r""" Exports model to protocol buffer."""
        return _pywraplp.Solver_ExportModelToProto(self, output_model)

    def LoadSolutionFromProto(self, *args) -> "util::Status":
        r"""
        Load a solution encoded in a protocol buffer onto this solver for easy
          access via the MPSolver interface.

        IMPORTANT: This may only be used in conjunction with ExportModel(),
          following this example:

           .. code-block:: c++

                 MPSolver my_solver;
                 ... add variables and constraints ...
                 MPModelProto model_proto;
                 my_solver.ExportModelToProto(model_proto);
                 MPSolutionResponse solver_response;
                 MPSolver::SolveWithProto(model_proto, solver_response);
                 if (solver_response.result_status() == MPSolutionResponse::OPTIMAL) {
                   CHECK_OK(my_solver.LoadSolutionFromProto(solver_response));
                   ... inspect the solution using the usual API: solution_value(), etc...
                 }

        The response must be in OPTIMAL or FEASIBLE status.

        Returns a non-OK status if a problem arised (typically, if it wasn't used
            like it should be):
        - loading a solution whose variables don't correspond to the solver's
          current variables
        - loading a solution with a status other than OPTIMAL / FEASIBLE.

        Note: the objective value isn't checked. You can use VerifySolution() for
              that.
        """
        return _pywraplp.Solver_LoadSolutionFromProto(self, *args)

    def SetSolverSpecificParametersAsString(self, parameters: "std::string const &") -> "bool":
        r"""
        Advanced usage: pass solver specific parameters in text format.

        The format is solver-specific and is the same as the corresponding solver
        configuration file format. Returns true if the operation was successful.
        """
        return _pywraplp.Solver_SetSolverSpecificParametersAsString(self, parameters)
    FREE = _pywraplp.Solver_FREE
    AT_LOWER_BOUND = _pywraplp.Solver_AT_LOWER_BOUND
    AT_UPPER_BOUND = _pywraplp.Solver_AT_UPPER_BOUND
    FIXED_VALUE = _pywraplp.Solver_FIXED_VALUE
    BASIC = _pywraplp.Solver_BASIC

    @staticmethod
    def infinity() -> "double":
        r"""
        Infinity.

        You can use -MPSolver::infinity() for negative infinity.
        """
        return _pywraplp.Solver_infinity()

    def EnableOutput(self) -> "void":
        r""" Enables solver logging."""
        return _pywraplp.Solver_EnableOutput(self)

    def SuppressOutput(self) -> "void":
        r""" Suppresses solver logging."""
        return _pywraplp.Solver_SuppressOutput(self)

    def iterations(self) -> "int64":
        r""" Returns the number of simplex iterations."""
        return _pywraplp.Solver_iterations(self)

    def nodes(self) -> "int64":
        r"""
        Returns the number of branch-and-bound nodes evaluated during the solve.

        Only available for discrete problems.
        """
        return _pywraplp.Solver_nodes(self)

    def ComputeExactConditionNumber(self) -> "double":
        r"""
         Advanced usage: computes the exact condition number of the current scaled
        basis: L1norm(B) * L1norm(inverse(B)), where B is the scaled basis.

        This method requires that a basis exists: it should be called after Solve.
        It is only available for continuous problems. It is implemented for GLPK
        but not CLP because CLP does not provide the API for doing it.

        The condition number measures how well the constraint matrix is conditioned
        and can be used to predict whether numerical issues will arise during the
        solve: the model is declared infeasible whereas it is feasible (or
        vice-versa), the solution obtained is not optimal or violates some
        constraints, the resolution is slow because of repeated singularities.

        The rule of thumb to interpret the condition number kappa is:
          - o kappa <= 1e7: virtually no chance of numerical issues
          - o 1e7 < kappa <= 1e10: small chance of numerical issues
          - o 1e10 < kappa <= 1e13: medium chance of numerical issues
          - o kappa > 1e13: high chance of numerical issues

        The computation of the condition number depends on the quality of the LU
        decomposition, so it is not very accurate when the matrix is ill
        conditioned.
        """
        return _pywraplp.Solver_ComputeExactConditionNumber(self)

    def NextSolution(self) -> "bool":
        r"""
        Some solvers (MIP only, not LP) can produce multiple solutions to the
        problem. Returns true when another solution is available, and updates the
        MPVariable* objects to make the new solution queryable. Call only after
        calling solve.

        The optimality properties of the additional solutions found, and whether or
        not the solver computes them ahead of time or when NextSolution() is called
        is solver specific.

        As of 2018-08-09, only Gurobi supports NextSolution(), see
        linear_solver_underlying_gurobi_test for an example of how to configure
        Gurobi for this purpose. The other solvers return false unconditionally.
        """
        return _pywraplp.Solver_NextSolution(self)

    def set_time_limit(self, time_limit_milliseconds: "int64") -> "void":
        return _pywraplp.Solver_set_time_limit(self, time_limit_milliseconds)

    def wall_time(self) -> "int64":
        return _pywraplp.Solver_wall_time(self)

    def LoadModelFromProto(self, input_model: "operations_research::MPModelProto const &") -> "std::string":
        return _pywraplp.Solver_LoadModelFromProto(self, input_model)

    def ExportModelAsLpFormat(self, obfuscated: "bool") -> "std::string":
        return _pywraplp.Solver_ExportModelAsLpFormat(self, obfuscated)

    def ExportModelAsMpsFormat(self, fixed_format: "bool", obfuscated: "bool") -> "std::string":
        return _pywraplp.Solver_ExportModelAsMpsFormat(self, fixed_format, obfuscated)

    def SetHint(self, variables: "std::vector< operations_research::MPVariable * > const &", values: "std::vector< double > const &") -> "void":
        r""" Set a hint for solution. If a feasible or almost-feasible solution to the problem is already known, it may be helpful to pass it to the solver so that it can be used. A solver that supports this feature will try to use this information to create its initial feasible solution. Note that it may not always be faster to give a hint like this to the solver. There is also no guarantee that the solver will use this hint or try to return a solution "close" to this assignment in case of multiple optimal solutions."""
        return _pywraplp.Solver_SetHint(self, variables, values)

    def SetNumThreads(self, num_theads: "int") -> "bool":
        r""" Sets the number of threads to be used by the solver."""
        return _pywraplp.Solver_SetNumThreads(self, num_theads)

    def Add(self, constraint, name=''):
      if isinstance(constraint, bool):
        if constraint:
          return self.RowConstraint(0, 0, name)
        else:
          return self.RowConstraint(1, 1, name)
      else:
        return constraint.Extract(self, name)

    def Sum(self, expr_array):
      result = SumArray(expr_array)
      return result

    def RowConstraint(self, *args):
      return self.Constraint(*args)

    def Minimize(self, expr):
      objective = self.Objective()
      objective.Clear()
      objective.SetMinimization()
      if isinstance(expr, numbers.Number):
          objective.SetOffset(expr)
      else:
          coeffs = expr.GetCoeffs()
          objective.SetOffset(coeffs.pop(OFFSET_KEY, 0.0))
          for v, c, in list(coeffs.items()):
            objective.SetCoefficient(v, float(c))

    def Maximize(self, expr):
      objective = self.Objective()
      objective.Clear()
      objective.SetMaximization()
      if isinstance(expr, numbers.Number):
          objective.SetOffset(expr)
      else:
          coeffs = expr.GetCoeffs()
          objective.SetOffset(coeffs.pop(OFFSET_KEY, 0.0))
          for v, c, in list(coeffs.items()):
            objective.SetCoefficient(v, float(c))


    @staticmethod
    def Infinity() -> "double":
        return _pywraplp.Solver_Infinity()

    def SetTimeLimit(self, x: "int64") -> "void":
        return _pywraplp.Solver_SetTimeLimit(self, x)

    def WallTime(self) -> "int64":
        return _pywraplp.Solver_WallTime(self)

    def Iterations(self) -> "int64":
        return _pywraplp.Solver_Iterations(self)

# Register Solver in _pywraplp:
_pywraplp.Solver_swigregister(Solver)

def Solver_SupportsProblemType(problem_type: "operations_research::MPSolver::OptimizationProblemType") -> "bool":
    r"""
    Whether the given problem type is supported (this will depend on the
    targets that you linked).
    """
    return _pywraplp.Solver_SupportsProblemType(problem_type)

def Solver_SolveWithProto(model_request: "operations_research::MPModelRequest const &", response: "operations_research::MPSolutionResponse *") -> "operations_research::MPSolutionResponse *":
    r"""
    Solves the model encoded by a MPModelRequest protocol buffer and fills the
    solution encoded as a MPSolutionResponse.

    Note(user): This creates a temporary MPSolver and destroys it at the end.
    If you want to keep the MPSolver alive (for debugging, or for incremental
    solving), you should write another version of this function that creates
    the MPSolver object on the heap and returns it.
    """
    return _pywraplp.Solver_SolveWithProto(model_request, response)

def Solver_infinity() -> "double":
    r"""
    Infinity.

    You can use -MPSolver::infinity() for negative infinity.
    """
    return _pywraplp.Solver_infinity()

def Solver_Infinity() -> "double":
    return _pywraplp.Solver_Infinity()


def __lshift__(*args) -> "std::ostream &":
    return _pywraplp.__lshift__(*args)
class Objective(object):
    r""" A class to express a linear objective."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def Clear(self) -> "void":
        r"""
         Clears the offset, all variables and coefficients, and the optimization
        direction.
        """
        return _pywraplp.Objective_Clear(self)

    def SetCoefficient(self, var: "Variable", coeff: "double") -> "void":
        r"""
        Sets the coefficient of the variable in the objective.

        If the variable does not belong to the solver, the function just returns,
        or crashes in non-opt mode.
        """
        return _pywraplp.Objective_SetCoefficient(self, var, coeff)

    def GetCoefficient(self, var: "Variable") -> "double":
        r"""
         Gets the coefficient of a given variable in the objective

        It returns 0 if the variable does not appear in the objective).
        """
        return _pywraplp.Objective_GetCoefficient(self, var)

    def SetOffset(self, value: "double") -> "void":
        r""" Sets the constant term in the objective."""
        return _pywraplp.Objective_SetOffset(self, value)

    def offset(self) -> "double":
        r""" Gets the constant term in the objective."""
        return _pywraplp.Objective_offset(self)

    def SetOptimizationDirection(self, maximize: "bool") -> "void":
        r""" Sets the optimization direction (maximize: true or minimize: false)."""
        return _pywraplp.Objective_SetOptimizationDirection(self, maximize)

    def SetMinimization(self) -> "void":
        r""" Sets the optimization direction to minimize."""
        return _pywraplp.Objective_SetMinimization(self)

    def SetMaximization(self) -> "void":
        r""" Sets the optimization direction to maximize."""
        return _pywraplp.Objective_SetMaximization(self)

    def maximization(self) -> "bool":
        r""" Is the optimization direction set to maximize?"""
        return _pywraplp.Objective_maximization(self)

    def minimization(self) -> "bool":
        r""" Is the optimization direction set to minimize?"""
        return _pywraplp.Objective_minimization(self)

    def Value(self) -> "double":
        r"""
        Returns the objective value of the best solution found so far.

        It is the optimal objective value if the problem has been solved to
        optimality.

        Note: the objective value may be slightly different than what you could
        compute yourself using ``MPVariable::solution_value();`` please use the
        --verify_solution flag to gain confidence about the numerical stability of
        your solution.
        """
        return _pywraplp.Objective_Value(self)

    def BestBound(self) -> "double":
        r"""
        Returns the best objective bound.

        In case of minimization, it is a lower bound on the objective value of the
        optimal integer solution. Only available for discrete problems.
        """
        return _pywraplp.Objective_BestBound(self)

    def Offset(self) -> "double":
        return _pywraplp.Objective_Offset(self)
    __swig_destroy__ = _pywraplp.delete_Objective

# Register Objective in _pywraplp:
_pywraplp.Objective_swigregister(Objective)

class Variable(object):
    r""" The class for variables of a Mathematical Programming (MP) model."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")

    def name(self) -> "std::string const &":
        r""" Returns the name of the variable."""
        return _pywraplp.Variable_name(self)

    def integer(self) -> "bool":
        r""" Returns the integrality requirement of the variable."""
        return _pywraplp.Variable_integer(self)

    def solution_value(self) -> "double":
        r"""
        Returns the value of the variable in the current solution.

        If the variable is integer, then the value will always be an integer (the
        underlying solver handles floating-point values only, but this function
        automatically rounds it to the nearest integer; see: man 3 round).
        """
        return _pywraplp.Variable_solution_value(self)

    def index(self) -> "int":
        r""" Returns the index of the variable in the MPSolver::variables_."""
        return _pywraplp.Variable_index(self)

    def lb(self) -> "double":
        r""" Returns the lower bound."""
        return _pywraplp.Variable_lb(self)

    def ub(self) -> "double":
        r""" Returns the upper bound."""
        return _pywraplp.Variable_ub(self)

    def SetBounds(self, lb: "double", ub: "double") -> "void":
        r""" Sets both the lower and upper bounds."""
        return _pywraplp.Variable_SetBounds(self, lb, ub)

    def reduced_cost(self) -> "double":
        r"""
        Advanced usage: returns the reduced cost of the variable in the current
        solution (only available for continuous problems).
        """
        return _pywraplp.Variable_reduced_cost(self)

    def basis_status(self) -> "operations_research::MPSolver::BasisStatus":
        r"""
        Advanced usage: returns the basis status of the variable in the current
        solution (only available for continuous problems).

        See also: MPSolver::BasisStatus.
        """
        return _pywraplp.Variable_basis_status(self)

    def __str__(self) -> "std::string":
        return _pywraplp.Variable___str__(self)

    def __repr__(self) -> "std::string":
        return _pywraplp.Variable___repr__(self)

    def __getattr__(self, name):
      return getattr(VariableExpr(self), name)


    def SolutionValue(self) -> "double":
        return _pywraplp.Variable_SolutionValue(self)

    def Integer(self) -> "bool":
        return _pywraplp.Variable_Integer(self)

    def Lb(self) -> "double":
        return _pywraplp.Variable_Lb(self)

    def Ub(self) -> "double":
        return _pywraplp.Variable_Ub(self)

    def SetLb(self, x: "double") -> "void":
        return _pywraplp.Variable_SetLb(self, x)

    def SetUb(self, x: "double") -> "void":
        return _pywraplp.Variable_SetUb(self, x)

    def ReducedCost(self) -> "double":
        return _pywraplp.Variable_ReducedCost(self)
    __swig_destroy__ = _pywraplp.delete_Variable

# Register Variable in _pywraplp:
_pywraplp.Variable_swigregister(Variable)

class Constraint(object):
    r"""
    The class for constraints of a Mathematical Programming (MP) model.

    A constraint is represented as a linear equation or inequality.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def name(self) -> "std::string const &":
        r""" Returns the name of the constraint."""
        return _pywraplp.Constraint_name(self)

    def SetCoefficient(self, var: "Variable", coeff: "double") -> "void":
        r"""
        Sets the coefficient of the variable on the constraint.

        If the variable does not belong to the solver, the function just returns,
        or crashes in non-opt mode.
        """
        return _pywraplp.Constraint_SetCoefficient(self, var, coeff)

    def GetCoefficient(self, var: "Variable") -> "double":
        r"""
        Gets the coefficient of a given variable on the constraint (which is 0 if
        the variable does not appear in the constraint).
        """
        return _pywraplp.Constraint_GetCoefficient(self, var)

    def lb(self) -> "double":
        r""" Returns the lower bound."""
        return _pywraplp.Constraint_lb(self)

    def ub(self) -> "double":
        r""" Returns the upper bound."""
        return _pywraplp.Constraint_ub(self)

    def SetBounds(self, lb: "double", ub: "double") -> "void":
        r""" Sets both the lower and upper bounds."""
        return _pywraplp.Constraint_SetBounds(self, lb, ub)

    def set_is_lazy(self, laziness: "bool") -> "void":
        r"""
        Advanced usage: sets the constraint "laziness".

        **This is only supported for SCIP and has no effect on other
        solvers.**

        When **laziness** is true, the constraint is only considered by the Linear
        Programming solver if its current solution violates the constraint. In this
        case, the constraint is definitively added to the problem. This may be
        useful in some MIP problems, and may have a dramatic impact on performance.

        For more info see: http://tinyurl.com/lazy-constraints.
        """
        return _pywraplp.Constraint_set_is_lazy(self, laziness)

    def index(self) -> "int":
        r""" Returns the index of the constraint in the MPSolver::constraints_."""
        return _pywraplp.Constraint_index(self)

    def dual_value(self) -> "double":
        r"""
        Advanced usage: returns the dual value of the constraint in the current
        solution (only available for continuous problems).
        """
        return _pywraplp.Constraint_dual_value(self)

    def basis_status(self) -> "operations_research::MPSolver::BasisStatus":
        r"""
        Advanced usage: returns the basis status of the constraint.

        It is only available for continuous problems).

        Note that if a constraint "linear_expression in [lb, ub]" is transformed
        into "linear_expression + slack = 0" with slack in [-ub, -lb], then this
        status is the same as the status of the slack variable with AT_UPPER_BOUND
        and AT_LOWER_BOUND swapped.

        See also: MPSolver::BasisStatus.
        """
        return _pywraplp.Constraint_basis_status(self)

    def Lb(self) -> "double":
        return _pywraplp.Constraint_Lb(self)

    def Ub(self) -> "double":
        return _pywraplp.Constraint_Ub(self)

    def SetLb(self, x: "double") -> "void":
        return _pywraplp.Constraint_SetLb(self, x)

    def SetUb(self, x: "double") -> "void":
        return _pywraplp.Constraint_SetUb(self, x)

    def DualValue(self) -> "double":
        return _pywraplp.Constraint_DualValue(self)
    __swig_destroy__ = _pywraplp.delete_Constraint

# Register Constraint in _pywraplp:
_pywraplp.Constraint_swigregister(Constraint)

class MPSolverParameters(object):
    r"""
    This class stores parameter settings for LP and MIP solvers. Some parameters
    are marked as advanced: do not change their values unless you know what you
    are doing!

    For developers: how to add a new parameter:
    - Add the new Foo parameter in the DoubleParam or IntegerParam enum.
    - If it is a categorical param, add a FooValues enum.
    - Decide if the wrapper should define a default value for it: yes
      if it controls the properties of the solution (example:
      tolerances) or if it consistently improves performance, no
      otherwise. If yes, define kDefaultFoo.
    - Add a foo_value_ member and, if no default value is defined, a
      foo_is_default_ member.
    - Add code to handle Foo in Set...Param, Reset...Param,
      Get...Param, Reset and the constructor.
    - In class MPSolverInterface, add a virtual method SetFoo, add it
      to SetCommonParameters or SetMIPParameters, and implement it for
      each solver. Sometimes, parameters need to be implemented
      differently, see for example the INCREMENTALITY implementation.
    - Add a test in linear_solver_test.cc.

    TODO(user): store the parameter values in a protocol buffer
    instead. We need to figure out how to deal with the subtleties of
    the default values.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    RELATIVE_MIP_GAP = _pywraplp.MPSolverParameters_RELATIVE_MIP_GAP
    r""" Limit for relative MIP gap."""
    PRIMAL_TOLERANCE = _pywraplp.MPSolverParameters_PRIMAL_TOLERANCE
    r"""
    Advanced usage: tolerance for primal feasibility of basic solutions.

    This does not control the integer feasibility tolerance of integer
    solutions for MIP or the tolerance used during presolve.
    """
    DUAL_TOLERANCE = _pywraplp.MPSolverParameters_DUAL_TOLERANCE
    r""" Advanced usage: tolerance for dual feasibility of basic solutions."""
    PRESOLVE = _pywraplp.MPSolverParameters_PRESOLVE
    r""" Advanced usage: presolve mode."""
    LP_ALGORITHM = _pywraplp.MPSolverParameters_LP_ALGORITHM
    r""" Algorithm to solve linear programs."""
    INCREMENTALITY = _pywraplp.MPSolverParameters_INCREMENTALITY
    r""" Advanced usage: incrementality from one solve to the next."""
    SCALING = _pywraplp.MPSolverParameters_SCALING
    r""" Advanced usage: enable or disable matrix scaling."""
    PRESOLVE_OFF = _pywraplp.MPSolverParameters_PRESOLVE_OFF
    r""" Presolve is off."""
    PRESOLVE_ON = _pywraplp.MPSolverParameters_PRESOLVE_ON
    r""" Presolve is on."""
    DUAL = _pywraplp.MPSolverParameters_DUAL
    r""" Dual simplex."""
    PRIMAL = _pywraplp.MPSolverParameters_PRIMAL
    r""" Primal simplex."""
    BARRIER = _pywraplp.MPSolverParameters_BARRIER
    r""" Barrier algorithm."""
    INCREMENTALITY_OFF = _pywraplp.MPSolverParameters_INCREMENTALITY_OFF
    r""" Start solve from scratch."""
    INCREMENTALITY_ON = _pywraplp.MPSolverParameters_INCREMENTALITY_ON
    r"""
    Reuse results from previous solve as much as the underlying solver
    allows.
    """
    SCALING_OFF = _pywraplp.MPSolverParameters_SCALING_OFF
    r""" Scaling is off."""
    SCALING_ON = _pywraplp.MPSolverParameters_SCALING_ON
    r""" Scaling is on."""

    def __init__(self):
        r""" The constructor sets all parameters to their default value."""
        _pywraplp.MPSolverParameters_swiginit(self, _pywraplp.new_MPSolverParameters())

    def SetDoubleParam(self, param: "operations_research::MPSolverParameters::DoubleParam", value: "double") -> "void":
        r""" Sets a double parameter to a specific value."""
        return _pywraplp.MPSolverParameters_SetDoubleParam(self, param, value)

    def SetIntegerParam(self, param: "operations_research::MPSolverParameters::IntegerParam", value: "int") -> "void":
        r""" Sets a integer parameter to a specific value."""
        return _pywraplp.MPSolverParameters_SetIntegerParam(self, param, value)

    def GetDoubleParam(self, param: "operations_research::MPSolverParameters::DoubleParam") -> "double":
        r""" Returns the value of a double parameter."""
        return _pywraplp.MPSolverParameters_GetDoubleParam(self, param)

    def GetIntegerParam(self, param: "operations_research::MPSolverParameters::IntegerParam") -> "int":
        r""" Returns the value of an integer parameter."""
        return _pywraplp.MPSolverParameters_GetIntegerParam(self, param)
    __swig_destroy__ = _pywraplp.delete_MPSolverParameters

# Register MPSolverParameters in _pywraplp:
_pywraplp.MPSolverParameters_swigregister(MPSolverParameters)
cvar = _pywraplp.cvar
MPSolverParameters.kDefaultRelativeMipGap = _pywraplp.cvar.MPSolverParameters_kDefaultRelativeMipGap
MPSolverParameters.kDefaultPrimalTolerance = _pywraplp.cvar.MPSolverParameters_kDefaultPrimalTolerance
MPSolverParameters.kDefaultDualTolerance = _pywraplp.cvar.MPSolverParameters_kDefaultDualTolerance
MPSolverParameters.kDefaultPresolve = _pywraplp.cvar.MPSolverParameters_kDefaultPresolve
MPSolverParameters.kDefaultIncrementality = _pywraplp.cvar.MPSolverParameters_kDefaultIncrementality

class ModelExportOptions(object):
    r""" Export options."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _pywraplp.ModelExportOptions_swiginit(self, _pywraplp.new_ModelExportOptions())
    __swig_destroy__ = _pywraplp.delete_ModelExportOptions

# Register ModelExportOptions in _pywraplp:
_pywraplp.ModelExportOptions_swigregister(ModelExportOptions)


def ExportModelAsLpFormat(*args) -> "std::string":
    return _pywraplp.ExportModelAsLpFormat(*args)

def ExportModelAsMpsFormat(*args) -> "std::string":
    return _pywraplp.ExportModelAsMpsFormat(*args)

def setup_variable_operator(opname):
  setattr(Variable, opname,
          lambda self, *args: getattr(VariableExpr(self), opname)(*args))
for opname in LinearExpr.OVERRIDDEN_OPERATOR_METHODS:
  setup_variable_operator(opname)
Functions

ExportModelAsLpFormat

def ExportModelAsLpFormat(*args)
Expand source code
def ExportModelAsLpFormat(*args) -> "std::string":
    return _pywraplp.ExportModelAsLpFormat(*args)

ExportModelAsMpsFormat

def ExportModelAsMpsFormat(*args)
Expand source code
def ExportModelAsMpsFormat(*args) -> "std::string":
    return _pywraplp.ExportModelAsMpsFormat(*args)
Classes

Constraint

class Constraint (*args, **kwargs)

The class for constraints of a Mathematical Programming (MP) model.

A constraint is represented as a linear equation or inequality.

Expand source code
class Constraint(object):
    r"""
    The class for constraints of a Mathematical Programming (MP) model.

    A constraint is represented as a linear equation or inequality.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def name(self) -> "std::string const &":
        r""" Returns the name of the constraint."""
        return _pywraplp.Constraint_name(self)

    def SetCoefficient(self, var: "Variable", coeff: "double") -> "void":
        r"""
        Sets the coefficient of the variable on the constraint.

        If the variable does not belong to the solver, the function just returns,
        or crashes in non-opt mode.
        """
        return _pywraplp.Constraint_SetCoefficient(self, var, coeff)

    def GetCoefficient(self, var: "Variable") -> "double":
        r"""
        Gets the coefficient of a given variable on the constraint (which is 0 if
        the variable does not appear in the constraint).
        """
        return _pywraplp.Constraint_GetCoefficient(self, var)

    def lb(self) -> "double":
        r""" Returns the lower bound."""
        return _pywraplp.Constraint_lb(self)

    def ub(self) -> "double":
        r""" Returns the upper bound."""
        return _pywraplp.Constraint_ub(self)

    def SetBounds(self, lb: "double", ub: "double") -> "void":
        r""" Sets both the lower and upper bounds."""
        return _pywraplp.Constraint_SetBounds(self, lb, ub)

    def set_is_lazy(self, laziness: "bool") -> "void":
        r"""
        Advanced usage: sets the constraint "laziness".

        **This is only supported for SCIP and has no effect on other
        solvers.**

        When **laziness** is true, the constraint is only considered by the Linear
        Programming solver if its current solution violates the constraint. In this
        case, the constraint is definitively added to the problem. This may be
        useful in some MIP problems, and may have a dramatic impact on performance.

        For more info see: http://tinyurl.com/lazy-constraints.
        """
        return _pywraplp.Constraint_set_is_lazy(self, laziness)

    def index(self) -> "int":
        r""" Returns the index of the constraint in the MPSolver::constraints_."""
        return _pywraplp.Constraint_index(self)

    def dual_value(self) -> "double":
        r"""
        Advanced usage: returns the dual value of the constraint in the current
        solution (only available for continuous problems).
        """
        return _pywraplp.Constraint_dual_value(self)

    def basis_status(self) -> "operations_research::MPSolver::BasisStatus":
        r"""
        Advanced usage: returns the basis status of the constraint.

        It is only available for continuous problems).

        Note that if a constraint "linear_expression in [lb, ub]" is transformed
        into "linear_expression + slack = 0" with slack in [-ub, -lb], then this
        status is the same as the status of the slack variable with AT_UPPER_BOUND
        and AT_LOWER_BOUND swapped.

        See also: MPSolver::BasisStatus.
        """
        return _pywraplp.Constraint_basis_status(self)

    def Lb(self) -> "double":
        return _pywraplp.Constraint_Lb(self)

    def Ub(self) -> "double":
        return _pywraplp.Constraint_Ub(self)

    def SetLb(self, x: "double") -> "void":
        return _pywraplp.Constraint_SetLb(self, x)

    def SetUb(self, x: "double") -> "void":
        return _pywraplp.Constraint_SetUb(self, x)

    def DualValue(self) -> "double":
        return _pywraplp.Constraint_DualValue(self)
    __swig_destroy__ = _pywraplp.delete_Constraint
Methods

DualValue

def DualValue(self)
Expand source code
def DualValue(self) -> "double":
    return _pywraplp.Constraint_DualValue(self)

GetCoefficient

def GetCoefficient(self, var)

Gets the coefficient of a given variable on the constraint (which is 0 if the variable does not appear in the constraint).

Expand source code
def GetCoefficient(self, var: "Variable") -> "double":
    r"""
    Gets the coefficient of a given variable on the constraint (which is 0 if
    the variable does not appear in the constraint).
    """
    return _pywraplp.Constraint_GetCoefficient(self, var)

Lb

def Lb(self)
Expand source code
def Lb(self) -> "double":
    return _pywraplp.Constraint_Lb(self)

SetBounds

def SetBounds(self, lb, ub)

Sets both the lower and upper bounds.

Expand source code
def SetBounds(self, lb: "double", ub: "double") -> "void":
    r""" Sets both the lower and upper bounds."""
    return _pywraplp.Constraint_SetBounds(self, lb, ub)

SetCoefficient

def SetCoefficient(self, var, coeff)

Sets the coefficient of the variable on the constraint.

If the variable does not belong to the solver, the function just returns, or crashes in non-opt mode.

Expand source code
def SetCoefficient(self, var: "Variable", coeff: "double") -> "void":
    r"""
    Sets the coefficient of the variable on the constraint.

    If the variable does not belong to the solver, the function just returns,
    or crashes in non-opt mode.
    """
    return _pywraplp.Constraint_SetCoefficient(self, var, coeff)

SetLb

def SetLb(self, x)
Expand source code
def SetLb(self, x: "double") -> "void":
    return _pywraplp.Constraint_SetLb(self, x)

SetUb

def SetUb(self, x)
Expand source code
def SetUb(self, x: "double") -> "void":
    return _pywraplp.Constraint_SetUb(self, x)

Ub

def Ub(self)
Expand source code
def Ub(self) -> "double":
    return _pywraplp.Constraint_Ub(self)

basis_status

def basis_status(self)

Advanced usage: returns the basis status of the constraint.

It is only available for continuous problems).

Note that if a constraint "linear_expression in [lb, ub]" is transformed into "linear_expression + slack = 0" with slack in [-ub, -lb], then this status is the same as the status of the slack variable with AT_UPPER_BOUND and AT_LOWER_BOUND swapped.

See also: MPSolver::BasisStatus.

Expand source code
def basis_status(self) -> "operations_research::MPSolver::BasisStatus":
    r"""
    Advanced usage: returns the basis status of the constraint.

    It is only available for continuous problems).

    Note that if a constraint "linear_expression in [lb, ub]" is transformed
    into "linear_expression + slack = 0" with slack in [-ub, -lb], then this
    status is the same as the status of the slack variable with AT_UPPER_BOUND
    and AT_LOWER_BOUND swapped.

    See also: MPSolver::BasisStatus.
    """
    return _pywraplp.Constraint_basis_status(self)

dual_value

def dual_value(self)

Advanced usage: returns the dual value of the constraint in the current solution (only available for continuous problems).

Expand source code
def dual_value(self) -> "double":
    r"""
    Advanced usage: returns the dual value of the constraint in the current
    solution (only available for continuous problems).
    """
    return _pywraplp.Constraint_dual_value(self)

index

def index(self)

Returns the index of the constraint in the MPSolver::constraints_.

Expand source code
def index(self) -> "int":
    r""" Returns the index of the constraint in the MPSolver::constraints_."""
    return _pywraplp.Constraint_index(self)

lb

def lb(self)

Returns the lower bound.

Expand source code
def lb(self) -> "double":
    r""" Returns the lower bound."""
    return _pywraplp.Constraint_lb(self)

name

def name(self)

Returns the name of the constraint.

Expand source code
def name(self) -> "std::string const &":
    r""" Returns the name of the constraint."""
    return _pywraplp.Constraint_name(self)

set_is_lazy

def set_is_lazy(self, laziness)

Advanced usage: sets the constraint "laziness".

This is only supported for SCIP and has no effect on other solvers.

When laziness is true, the constraint is only considered by the Linear Programming solver if its current solution violates the constraint. In this case, the constraint is definitively added to the problem. This may be useful in some MIP problems, and may have a dramatic impact on performance.

For more info see: http://tinyurl.com/lazy-constraints.

Expand source code
def set_is_lazy(self, laziness: "bool") -> "void":
    r"""
    Advanced usage: sets the constraint "laziness".

    **This is only supported for SCIP and has no effect on other
    solvers.**

    When **laziness** is true, the constraint is only considered by the Linear
    Programming solver if its current solution violates the constraint. In this
    case, the constraint is definitively added to the problem. This may be
    useful in some MIP problems, and may have a dramatic impact on performance.

    For more info see: http://tinyurl.com/lazy-constraints.
    """
    return _pywraplp.Constraint_set_is_lazy(self, laziness)

ub

def ub(self)

Returns the upper bound.

Expand source code
def ub(self) -> "double":
    r""" Returns the upper bound."""
    return _pywraplp.Constraint_ub(self)

MPSolverParameters

class MPSolverParameters

This class stores parameter settings for LP and MIP solvers. Some parameters are marked as advanced: do not change their values unless you know what you are doing!

For developers: how to add a new parameter: - Add the new Foo parameter in the DoubleParam or IntegerParam enum. - If it is a categorical param, add a FooValues enum. - Decide if the wrapper should define a default value for it: yes if it controls the properties of the solution (example: tolerances) or if it consistently improves performance, no otherwise. If yes, define kDefaultFoo. - Add a foo_value_ member and, if no default value is defined, a foo_is_default_ member. - Add code to handle Foo in Set…Param, Reset…Param, Get…Param, Reset and the constructor. - In class MPSolverInterface, add a virtual method SetFoo, add it to SetCommonParameters or SetMIPParameters, and implement it for each solver. Sometimes, parameters need to be implemented differently, see for example the INCREMENTALITY implementation. - Add a test in linear_solver_test.cc.

TODO(user): store the parameter values in a protocol buffer instead. We need to figure out how to deal with the subtleties of the default values.

The constructor sets all parameters to their default value.

Expand source code
class MPSolverParameters(object):
    r"""
    This class stores parameter settings for LP and MIP solvers. Some parameters
    are marked as advanced: do not change their values unless you know what you
    are doing!

    For developers: how to add a new parameter:
    - Add the new Foo parameter in the DoubleParam or IntegerParam enum.
    - If it is a categorical param, add a FooValues enum.
    - Decide if the wrapper should define a default value for it: yes
      if it controls the properties of the solution (example:
      tolerances) or if it consistently improves performance, no
      otherwise. If yes, define kDefaultFoo.
    - Add a foo_value_ member and, if no default value is defined, a
      foo_is_default_ member.
    - Add code to handle Foo in Set...Param, Reset...Param,
      Get...Param, Reset and the constructor.
    - In class MPSolverInterface, add a virtual method SetFoo, add it
      to SetCommonParameters or SetMIPParameters, and implement it for
      each solver. Sometimes, parameters need to be implemented
      differently, see for example the INCREMENTALITY implementation.
    - Add a test in linear_solver_test.cc.

    TODO(user): store the parameter values in a protocol buffer
    instead. We need to figure out how to deal with the subtleties of
    the default values.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    RELATIVE_MIP_GAP = _pywraplp.MPSolverParameters_RELATIVE_MIP_GAP
    r""" Limit for relative MIP gap."""
    PRIMAL_TOLERANCE = _pywraplp.MPSolverParameters_PRIMAL_TOLERANCE
    r"""
    Advanced usage: tolerance for primal feasibility of basic solutions.

    This does not control the integer feasibility tolerance of integer
    solutions for MIP or the tolerance used during presolve.
    """
    DUAL_TOLERANCE = _pywraplp.MPSolverParameters_DUAL_TOLERANCE
    r""" Advanced usage: tolerance for dual feasibility of basic solutions."""
    PRESOLVE = _pywraplp.MPSolverParameters_PRESOLVE
    r""" Advanced usage: presolve mode."""
    LP_ALGORITHM = _pywraplp.MPSolverParameters_LP_ALGORITHM
    r""" Algorithm to solve linear programs."""
    INCREMENTALITY = _pywraplp.MPSolverParameters_INCREMENTALITY
    r""" Advanced usage: incrementality from one solve to the next."""
    SCALING = _pywraplp.MPSolverParameters_SCALING
    r""" Advanced usage: enable or disable matrix scaling."""
    PRESOLVE_OFF = _pywraplp.MPSolverParameters_PRESOLVE_OFF
    r""" Presolve is off."""
    PRESOLVE_ON = _pywraplp.MPSolverParameters_PRESOLVE_ON
    r""" Presolve is on."""
    DUAL = _pywraplp.MPSolverParameters_DUAL
    r""" Dual simplex."""
    PRIMAL = _pywraplp.MPSolverParameters_PRIMAL
    r""" Primal simplex."""
    BARRIER = _pywraplp.MPSolverParameters_BARRIER
    r""" Barrier algorithm."""
    INCREMENTALITY_OFF = _pywraplp.MPSolverParameters_INCREMENTALITY_OFF
    r""" Start solve from scratch."""
    INCREMENTALITY_ON = _pywraplp.MPSolverParameters_INCREMENTALITY_ON
    r"""
    Reuse results from previous solve as much as the underlying solver
    allows.
    """
    SCALING_OFF = _pywraplp.MPSolverParameters_SCALING_OFF
    r""" Scaling is off."""
    SCALING_ON = _pywraplp.MPSolverParameters_SCALING_ON
    r""" Scaling is on."""

    def __init__(self):
        r""" The constructor sets all parameters to their default value."""
        _pywraplp.MPSolverParameters_swiginit(self, _pywraplp.new_MPSolverParameters())

    def SetDoubleParam(self, param: "operations_research::MPSolverParameters::DoubleParam", value: "double") -> "void":
        r""" Sets a double parameter to a specific value."""
        return _pywraplp.MPSolverParameters_SetDoubleParam(self, param, value)

    def SetIntegerParam(self, param: "operations_research::MPSolverParameters::IntegerParam", value: "int") -> "void":
        r""" Sets a integer parameter to a specific value."""
        return _pywraplp.MPSolverParameters_SetIntegerParam(self, param, value)

    def GetDoubleParam(self, param: "operations_research::MPSolverParameters::DoubleParam") -> "double":
        r""" Returns the value of a double parameter."""
        return _pywraplp.MPSolverParameters_GetDoubleParam(self, param)

    def GetIntegerParam(self, param: "operations_research::MPSolverParameters::IntegerParam") -> "int":
        r""" Returns the value of an integer parameter."""
        return _pywraplp.MPSolverParameters_GetIntegerParam(self, param)
    __swig_destroy__ = _pywraplp.delete_MPSolverParameters
Class variables

BARRIER

var BARRIER

Barrier algorithm.

DUAL

var DUAL

Dual simplex.

DUAL_TOLERANCE

var DUAL_TOLERANCE

Advanced usage: tolerance for dual feasibility of basic solutions.

INCREMENTALITY

var INCREMENTALITY

Advanced usage: incrementality from one solve to the next.

INCREMENTALITY_OFF

var INCREMENTALITY_OFF

Start solve from scratch.

INCREMENTALITY_ON

var INCREMENTALITY_ON

Reuse results from previous solve as much as the underlying solver allows.

LP_ALGORITHM

var LP_ALGORITHM

Algorithm to solve linear programs.

PRESOLVE

var PRESOLVE

Advanced usage: presolve mode.

PRESOLVE_OFF

var PRESOLVE_OFF

Presolve is off.

PRESOLVE_ON

var PRESOLVE_ON

Presolve is on.

PRIMAL

var PRIMAL

Primal simplex.

PRIMAL_TOLERANCE

var PRIMAL_TOLERANCE

Advanced usage: tolerance for primal feasibility of basic solutions.

This does not control the integer feasibility tolerance of integer solutions for MIP or the tolerance used during presolve.

RELATIVE_MIP_GAP

var RELATIVE_MIP_GAP

Limit for relative MIP gap.

SCALING

var SCALING

Advanced usage: enable or disable matrix scaling.

SCALING_OFF

var SCALING_OFF

Scaling is off.

SCALING_ON

var SCALING_ON

Scaling is on.

kDefaultDualTolerance

var kDefaultDualTolerance

Convert a string or number to a floating point number, if possible.

kDefaultIncrementality

var kDefaultIncrementality

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.int(). For floating point numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.

>>> int('0b100', base=0)
4

kDefaultPresolve

var kDefaultPresolve

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.int(). For floating point numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.

>>> int('0b100', base=0)
4

kDefaultPrimalTolerance

var kDefaultPrimalTolerance

Convert a string or number to a floating point number, if possible.

kDefaultRelativeMipGap

var kDefaultRelativeMipGap

Convert a string or number to a floating point number, if possible.

Methods

GetDoubleParam

def GetDoubleParam(self, param)

Returns the value of a double parameter.

Expand source code
def GetDoubleParam(self, param: "operations_research::MPSolverParameters::DoubleParam") -> "double":
    r""" Returns the value of a double parameter."""
    return _pywraplp.MPSolverParameters_GetDoubleParam(self, param)

GetIntegerParam

def GetIntegerParam(self, param)

Returns the value of an integer parameter.

Expand source code
def GetIntegerParam(self, param: "operations_research::MPSolverParameters::IntegerParam") -> "int":
    r""" Returns the value of an integer parameter."""
    return _pywraplp.MPSolverParameters_GetIntegerParam(self, param)

SetDoubleParam

def SetDoubleParam(self, param, value)

Sets a double parameter to a specific value.

Expand source code
def SetDoubleParam(self, param: "operations_research::MPSolverParameters::DoubleParam", value: "double") -> "void":
    r""" Sets a double parameter to a specific value."""
    return _pywraplp.MPSolverParameters_SetDoubleParam(self, param, value)

SetIntegerParam

def SetIntegerParam(self, param, value)

Sets a integer parameter to a specific value.

Expand source code
def SetIntegerParam(self, param: "operations_research::MPSolverParameters::IntegerParam", value: "int") -> "void":
    r""" Sets a integer parameter to a specific value."""
    return _pywraplp.MPSolverParameters_SetIntegerParam(self, param, value)

ModelExportOptions

class ModelExportOptions

Export options.

Expand source code
class ModelExportOptions(object):
    r""" Export options."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _pywraplp.ModelExportOptions_swiginit(self, _pywraplp.new_ModelExportOptions())
    __swig_destroy__ = _pywraplp.delete_ModelExportOptions

Objective

class Objective (*args, **kwargs)

A class to express a linear objective.

Expand source code
class Objective(object):
    r""" A class to express a linear objective."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def Clear(self) -> "void":
        r"""
         Clears the offset, all variables and coefficients, and the optimization
        direction.
        """
        return _pywraplp.Objective_Clear(self)

    def SetCoefficient(self, var: "Variable", coeff: "double") -> "void":
        r"""
        Sets the coefficient of the variable in the objective.

        If the variable does not belong to the solver, the function just returns,
        or crashes in non-opt mode.
        """
        return _pywraplp.Objective_SetCoefficient(self, var, coeff)

    def GetCoefficient(self, var: "Variable") -> "double":
        r"""
         Gets the coefficient of a given variable in the objective

        It returns 0 if the variable does not appear in the objective).
        """
        return _pywraplp.Objective_GetCoefficient(self, var)

    def SetOffset(self, value: "double") -> "void":
        r""" Sets the constant term in the objective."""
        return _pywraplp.Objective_SetOffset(self, value)

    def offset(self) -> "double":
        r""" Gets the constant term in the objective."""
        return _pywraplp.Objective_offset(self)

    def SetOptimizationDirection(self, maximize: "bool") -> "void":
        r""" Sets the optimization direction (maximize: true or minimize: false)."""
        return _pywraplp.Objective_SetOptimizationDirection(self, maximize)

    def SetMinimization(self) -> "void":
        r""" Sets the optimization direction to minimize."""
        return _pywraplp.Objective_SetMinimization(self)

    def SetMaximization(self) -> "void":
        r""" Sets the optimization direction to maximize."""
        return _pywraplp.Objective_SetMaximization(self)

    def maximization(self) -> "bool":
        r""" Is the optimization direction set to maximize?"""
        return _pywraplp.Objective_maximization(self)

    def minimization(self) -> "bool":
        r""" Is the optimization direction set to minimize?"""
        return _pywraplp.Objective_minimization(self)

    def Value(self) -> "double":
        r"""
        Returns the objective value of the best solution found so far.

        It is the optimal objective value if the problem has been solved to
        optimality.

        Note: the objective value may be slightly different than what you could
        compute yourself using ``MPVariable::solution_value();`` please use the
        --verify_solution flag to gain confidence about the numerical stability of
        your solution.
        """
        return _pywraplp.Objective_Value(self)

    def BestBound(self) -> "double":
        r"""
        Returns the best objective bound.

        In case of minimization, it is a lower bound on the objective value of the
        optimal integer solution. Only available for discrete problems.
        """
        return _pywraplp.Objective_BestBound(self)

    def Offset(self) -> "double":
        return _pywraplp.Objective_Offset(self)
    __swig_destroy__ = _pywraplp.delete_Objective
Methods

BestBound

def BestBound(self)

Returns the best objective bound.

In case of minimization, it is a lower bound on the objective value of the optimal integer solution. Only available for discrete problems.

Expand source code
def BestBound(self) -> "double":
    r"""
    Returns the best objective bound.

    In case of minimization, it is a lower bound on the objective value of the
    optimal integer solution. Only available for discrete problems.
    """
    return _pywraplp.Objective_BestBound(self)

Clear

def Clear(self)

Clears the offset, all variables and coefficients, and the optimization direction.

Expand source code
def Clear(self) -> "void":
    r"""
     Clears the offset, all variables and coefficients, and the optimization
    direction.
    """
    return _pywraplp.Objective_Clear(self)

GetCoefficient

def GetCoefficient(self, var)

Gets the coefficient of a given variable in the objective

It returns 0 if the variable does not appear in the objective).

Expand source code
def GetCoefficient(self, var: "Variable") -> "double":
    r"""
     Gets the coefficient of a given variable in the objective

    It returns 0 if the variable does not appear in the objective).
    """
    return _pywraplp.Objective_GetCoefficient(self, var)

Offset

def Offset(self)
Expand source code
def Offset(self) -> "double":
    return _pywraplp.Objective_Offset(self)

SetCoefficient

def SetCoefficient(self, var, coeff)

Sets the coefficient of the variable in the objective.

If the variable does not belong to the solver, the function just returns, or crashes in non-opt mode.

Expand source code
def SetCoefficient(self, var: "Variable", coeff: "double") -> "void":
    r"""
    Sets the coefficient of the variable in the objective.

    If the variable does not belong to the solver, the function just returns,
    or crashes in non-opt mode.
    """
    return _pywraplp.Objective_SetCoefficient(self, var, coeff)

SetMaximization

def SetMaximization(self)

Sets the optimization direction to maximize.

Expand source code
def SetMaximization(self) -> "void":
    r""" Sets the optimization direction to maximize."""
    return _pywraplp.Objective_SetMaximization(self)

SetMinimization

def SetMinimization(self)

Sets the optimization direction to minimize.

Expand source code
def SetMinimization(self) -> "void":
    r""" Sets the optimization direction to minimize."""
    return _pywraplp.Objective_SetMinimization(self)

SetOffset

def SetOffset(self, value)

Sets the constant term in the objective.

Expand source code
def SetOffset(self, value: "double") -> "void":
    r""" Sets the constant term in the objective."""
    return _pywraplp.Objective_SetOffset(self, value)

SetOptimizationDirection

def SetOptimizationDirection(self, maximize)

Sets the optimization direction (maximize: true or minimize: false).

Expand source code
def SetOptimizationDirection(self, maximize: "bool") -> "void":
    r""" Sets the optimization direction (maximize: true or minimize: false)."""
    return _pywraplp.Objective_SetOptimizationDirection(self, maximize)

Value

def Value(self)

Returns the objective value of the best solution found so far.

It is the optimal objective value if the problem has been solved to optimality.

Note: the objective value may be slightly different than what you could compute yourself using MPVariable::solution_value(); please use the –verify_solution flag to gain confidence about the numerical stability of your solution.

Expand source code
def Value(self) -> "double":
    r"""
    Returns the objective value of the best solution found so far.

    It is the optimal objective value if the problem has been solved to
    optimality.

    Note: the objective value may be slightly different than what you could
    compute yourself using ``MPVariable::solution_value();`` please use the
    --verify_solution flag to gain confidence about the numerical stability of
    your solution.
    """
    return _pywraplp.Objective_Value(self)

maximization

def maximization(self)

Is the optimization direction set to maximize?

Expand source code
def maximization(self) -> "bool":
    r""" Is the optimization direction set to maximize?"""
    return _pywraplp.Objective_maximization(self)

minimization

def minimization(self)

Is the optimization direction set to minimize?

Expand source code
def minimization(self) -> "bool":
    r""" Is the optimization direction set to minimize?"""
    return _pywraplp.Objective_minimization(self)

offset

def offset(self)

Gets the constant term in the objective.

Expand source code
def offset(self) -> "double":
    r""" Gets the constant term in the objective."""
    return _pywraplp.Objective_offset(self)

Solver

class Solver (name, problem_type)

This mathematical programming (MP) solver class is the main class though which users build and solve problems.

Create a solver with the given name and underlying solver backend.

Expand source code
class Solver(object):
    r"""
    This mathematical programming (MP) solver class is the main class
    though which users build and solve problems.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CLP_LINEAR_PROGRAMMING = _pywraplp.Solver_CLP_LINEAR_PROGRAMMING
    r""" Linear Programming solver using Coin CBC."""
    GLOP_LINEAR_PROGRAMMING = _pywraplp.Solver_GLOP_LINEAR_PROGRAMMING
    r""" Linear Programming solver using GLOP (Recommended solver)."""
    CBC_MIXED_INTEGER_PROGRAMMING = _pywraplp.Solver_CBC_MIXED_INTEGER_PROGRAMMING
    r""" Mixed integer Programming Solver using Coin CBC."""
    BOP_INTEGER_PROGRAMMING = _pywraplp.Solver_BOP_INTEGER_PROGRAMMING
    r""" Linear Boolean Programming Solver."""

    def __init__(self, name: "std::string const &", problem_type: "operations_research::MPSolver::OptimizationProblemType"):
        r""" Create a solver with the given name and underlying solver backend."""
        _pywraplp.Solver_swiginit(self, _pywraplp.new_Solver(name, problem_type))
    __swig_destroy__ = _pywraplp.delete_Solver

    @staticmethod
    def SupportsProblemType(problem_type: "operations_research::MPSolver::OptimizationProblemType") -> "bool":
        r"""
        Whether the given problem type is supported (this will depend on the
        targets that you linked).
        """
        return _pywraplp.Solver_SupportsProblemType(problem_type)

    def Clear(self) -> "void":
        r"""
        Clears the objective (including the optimization direction), all variables
        and constraints. All the other properties of the MPSolver (like the time
        limit) are kept untouched.
        """
        return _pywraplp.Solver_Clear(self)

    def NumVariables(self) -> "int":
        r""" Returns the number of variables."""
        return _pywraplp.Solver_NumVariables(self)

    def variables(self) -> "std::vector< operations_research::MPVariable * > const &":
        r"""
        Returns the array of variables handled by the MPSolver. (They are listed in
        the order in which they were created.)
        """
        return _pywraplp.Solver_variables(self)

    def LookupVariable(self, var_name: "std::string const &") -> "operations_research::MPVariable *":
        r"""
        Looks up a variable by name, and returns nullptr if it does not exist. The
        first call has a O(n) complexity, as the variable name index is lazily
        created upon first use. Will crash if variable names are not unique.
        """
        return _pywraplp.Solver_LookupVariable(self, var_name)

    def Var(self, lb: "double", ub: "double", integer: "bool", name: "std::string const &") -> "operations_research::MPVariable *":
        r"""
        Creates a variable with the given bounds, integrality requirement and
        name. Bounds can be finite or +/- MPSolver::infinity(). The MPSolver owns
        the variable (i.e. the returned pointer is borrowed). Variable names are
        optional. If you give an empty name, name() will auto-generate one for you
        upon request.
        """
        return _pywraplp.Solver_Var(self, lb, ub, integer, name)

    def NumVar(self, lb: "double", ub: "double", name: "std::string const &") -> "operations_research::MPVariable *":
        r""" Creates a continuous variable."""
        return _pywraplp.Solver_NumVar(self, lb, ub, name)

    def IntVar(self, lb: "double", ub: "double", name: "std::string const &") -> "operations_research::MPVariable *":
        r""" Creates an integer variable."""
        return _pywraplp.Solver_IntVar(self, lb, ub, name)

    def BoolVar(self, name: "std::string const &") -> "operations_research::MPVariable *":
        r""" Creates a boolean variable."""
        return _pywraplp.Solver_BoolVar(self, name)

    def NumConstraints(self) -> "int":
        r""" Returns the number of constraints."""
        return _pywraplp.Solver_NumConstraints(self)

    def constraints(self) -> "std::vector< operations_research::MPConstraint * > const &":
        r"""
        Returns the array of constraints handled by the MPSolver.

        They are listed in the order in which they were created.
        """
        return _pywraplp.Solver_constraints(self)

    def LookupConstraint(self, constraint_name: "std::string const &") -> "operations_research::MPConstraint *":
        r"""
         Looks up a constraint by name, and returns nullptr if it does not exist.

        The first call has a O(n) complexity, as the constraint name index is
        lazily created upon first use. Will crash if constraint names are not
        unique.
        """
        return _pywraplp.Solver_LookupConstraint(self, constraint_name)

    def Constraint(self, *args) -> "operations_research::MPConstraint *":
        r"""
        *Overload 1:*

        Creates a linear constraint with given bounds.

        Bounds can be finite or +/- MPSolver::infinity(). The MPSolver class
        assumes ownership of the constraint.

        :rtype: :py:class:`MPConstraint`
        :return: a pointer to the newly created constraint.

        |

        *Overload 2:*
         Creates a constraint with -infinity and +infinity bounds.

        |

        *Overload 3:*
         Creates a named constraint with given bounds.

        |

        *Overload 4:*
         Creates a named constraint with -infinity and +infinity bounds.
        """
        return _pywraplp.Solver_Constraint(self, *args)

    def Objective(self) -> "operations_research::MPObjective *":
        r""" Returns the mutable objective object."""
        return _pywraplp.Solver_Objective(self)
    OPTIMAL = _pywraplp.Solver_OPTIMAL
    r""" optimal."""
    FEASIBLE = _pywraplp.Solver_FEASIBLE
    r""" feasible, or stopped by limit."""
    INFEASIBLE = _pywraplp.Solver_INFEASIBLE
    r""" proven infeasible."""
    UNBOUNDED = _pywraplp.Solver_UNBOUNDED
    r""" proven unbounded."""
    ABNORMAL = _pywraplp.Solver_ABNORMAL
    r""" abnormal, i.e., error of some kind."""
    NOT_SOLVED = _pywraplp.Solver_NOT_SOLVED
    r""" not been solved yet."""

    def Solve(self, *args) -> "operations_research::MPSolver::ResultStatus":
        r"""
        *Overload 1:*
        Solves the problem using default parameter values.

        |

        *Overload 2:*
        Solves the problem using the specified parameter values.
        """
        return _pywraplp.Solver_Solve(self, *args)

    def ComputeConstraintActivities(self) -> "std::vector< double >":
        r"""
        Advanced usage: compute the "activities" of all constraints, which are the
        sums of their linear terms. The activities are returned in the same order
        as constraints(), which is the order in which constraints were added; but
        you can also use MPConstraint::index() to get a constraint's index.
        """
        return _pywraplp.Solver_ComputeConstraintActivities(self)

    def VerifySolution(self, tolerance: "double", log_errors: "bool") -> "bool":
        r"""
        Advanced usage: Verifies the *correctness* of the solution.

        It verifies that all variables must be within their domains, all
        constraints must be satisfied, and the reported objective value must be
        accurate.

        Usage:
        - This can only be called after Solve() was called.
        - "tolerance" is interpreted as an absolute error threshold.
        - For the objective value only, if the absolute error is too large,
          the tolerance is interpreted as a relative error threshold instead.
        - If "log_errors" is true, every single violation will be logged.
        - If "tolerance" is negative, it will be set to infinity().

        Most users should just set the --verify_solution flag and not bother using
        this method directly.
        """
        return _pywraplp.Solver_VerifySolution(self, tolerance, log_errors)

    def InterruptSolve(self) -> "bool":
        r"""
         Interrupts the Solve() execution to terminate processing if possible.

        If the underlying interface supports interruption; it does that and returns
        true regardless of whether there's an ongoing Solve() or not. The Solve()
        call may still linger for a while depending on the conditions.  If
        interruption is not supported; returns false and does nothing.
        """
        return _pywraplp.Solver_InterruptSolve(self)

    def FillSolutionResponseProto(self, response: "operations_research::MPSolutionResponse *") -> "void":
        r""" Encodes the current solution in a solution response protocol buffer."""
        return _pywraplp.Solver_FillSolutionResponseProto(self, response)

    @staticmethod
    def SolveWithProto(model_request: "operations_research::MPModelRequest const &", response: "operations_research::MPSolutionResponse *") -> "operations_research::MPSolutionResponse *":
        r"""
        Solves the model encoded by a MPModelRequest protocol buffer and fills the
        solution encoded as a MPSolutionResponse.

        Note(user): This creates a temporary MPSolver and destroys it at the end.
        If you want to keep the MPSolver alive (for debugging, or for incremental
        solving), you should write another version of this function that creates
        the MPSolver object on the heap and returns it.
        """
        return _pywraplp.Solver_SolveWithProto(model_request, response)

    def ExportModelToProto(self, output_model: "operations_research::MPModelProto *") -> "void":
        r""" Exports model to protocol buffer."""
        return _pywraplp.Solver_ExportModelToProto(self, output_model)

    def LoadSolutionFromProto(self, *args) -> "util::Status":
        r"""
        Load a solution encoded in a protocol buffer onto this solver for easy
          access via the MPSolver interface.

        IMPORTANT: This may only be used in conjunction with ExportModel(),
          following this example:

           .. code-block:: c++

                 MPSolver my_solver;
                 ... add variables and constraints ...
                 MPModelProto model_proto;
                 my_solver.ExportModelToProto(model_proto);
                 MPSolutionResponse solver_response;
                 MPSolver::SolveWithProto(model_proto, solver_response);
                 if (solver_response.result_status() == MPSolutionResponse::OPTIMAL) {
                   CHECK_OK(my_solver.LoadSolutionFromProto(solver_response));
                   ... inspect the solution using the usual API: solution_value(), etc...
                 }

        The response must be in OPTIMAL or FEASIBLE status.

        Returns a non-OK status if a problem arised (typically, if it wasn't used
            like it should be):
        - loading a solution whose variables don't correspond to the solver's
          current variables
        - loading a solution with a status other than OPTIMAL / FEASIBLE.

        Note: the objective value isn't checked. You can use VerifySolution() for
              that.
        """
        return _pywraplp.Solver_LoadSolutionFromProto(self, *args)

    def SetSolverSpecificParametersAsString(self, parameters: "std::string const &") -> "bool":
        r"""
        Advanced usage: pass solver specific parameters in text format.

        The format is solver-specific and is the same as the corresponding solver
        configuration file format. Returns true if the operation was successful.
        """
        return _pywraplp.Solver_SetSolverSpecificParametersAsString(self, parameters)
    FREE = _pywraplp.Solver_FREE
    AT_LOWER_BOUND = _pywraplp.Solver_AT_LOWER_BOUND
    AT_UPPER_BOUND = _pywraplp.Solver_AT_UPPER_BOUND
    FIXED_VALUE = _pywraplp.Solver_FIXED_VALUE
    BASIC = _pywraplp.Solver_BASIC

    @staticmethod
    def infinity() -> "double":
        r"""
        Infinity.

        You can use -MPSolver::infinity() for negative infinity.
        """
        return _pywraplp.Solver_infinity()

    def EnableOutput(self) -> "void":
        r""" Enables solver logging."""
        return _pywraplp.Solver_EnableOutput(self)

    def SuppressOutput(self) -> "void":
        r""" Suppresses solver logging."""
        return _pywraplp.Solver_SuppressOutput(self)

    def iterations(self) -> "int64":
        r""" Returns the number of simplex iterations."""
        return _pywraplp.Solver_iterations(self)

    def nodes(self) -> "int64":
        r"""
        Returns the number of branch-and-bound nodes evaluated during the solve.

        Only available for discrete problems.
        """
        return _pywraplp.Solver_nodes(self)

    def ComputeExactConditionNumber(self) -> "double":
        r"""
         Advanced usage: computes the exact condition number of the current scaled
        basis: L1norm(B) * L1norm(inverse(B)), where B is the scaled basis.

        This method requires that a basis exists: it should be called after Solve.
        It is only available for continuous problems. It is implemented for GLPK
        but not CLP because CLP does not provide the API for doing it.

        The condition number measures how well the constraint matrix is conditioned
        and can be used to predict whether numerical issues will arise during the
        solve: the model is declared infeasible whereas it is feasible (or
        vice-versa), the solution obtained is not optimal or violates some
        constraints, the resolution is slow because of repeated singularities.

        The rule of thumb to interpret the condition number kappa is:
          - o kappa <= 1e7: virtually no chance of numerical issues
          - o 1e7 < kappa <= 1e10: small chance of numerical issues
          - o 1e10 < kappa <= 1e13: medium chance of numerical issues
          - o kappa > 1e13: high chance of numerical issues

        The computation of the condition number depends on the quality of the LU
        decomposition, so it is not very accurate when the matrix is ill
        conditioned.
        """
        return _pywraplp.Solver_ComputeExactConditionNumber(self)

    def NextSolution(self) -> "bool":
        r"""
        Some solvers (MIP only, not LP) can produce multiple solutions to the
        problem. Returns true when another solution is available, and updates the
        MPVariable* objects to make the new solution queryable. Call only after
        calling solve.

        The optimality properties of the additional solutions found, and whether or
        not the solver computes them ahead of time or when NextSolution() is called
        is solver specific.

        As of 2018-08-09, only Gurobi supports NextSolution(), see
        linear_solver_underlying_gurobi_test for an example of how to configure
        Gurobi for this purpose. The other solvers return false unconditionally.
        """
        return _pywraplp.Solver_NextSolution(self)

    def set_time_limit(self, time_limit_milliseconds: "int64") -> "void":
        return _pywraplp.Solver_set_time_limit(self, time_limit_milliseconds)

    def wall_time(self) -> "int64":
        return _pywraplp.Solver_wall_time(self)

    def LoadModelFromProto(self, input_model: "operations_research::MPModelProto const &") -> "std::string":
        return _pywraplp.Solver_LoadModelFromProto(self, input_model)

    def ExportModelAsLpFormat(self, obfuscated: "bool") -> "std::string":
        return _pywraplp.Solver_ExportModelAsLpFormat(self, obfuscated)

    def ExportModelAsMpsFormat(self, fixed_format: "bool", obfuscated: "bool") -> "std::string":
        return _pywraplp.Solver_ExportModelAsMpsFormat(self, fixed_format, obfuscated)

    def SetHint(self, variables: "std::vector< operations_research::MPVariable * > const &", values: "std::vector< double > const &") -> "void":
        r""" Set a hint for solution. If a feasible or almost-feasible solution to the problem is already known, it may be helpful to pass it to the solver so that it can be used. A solver that supports this feature will try to use this information to create its initial feasible solution. Note that it may not always be faster to give a hint like this to the solver. There is also no guarantee that the solver will use this hint or try to return a solution "close" to this assignment in case of multiple optimal solutions."""
        return _pywraplp.Solver_SetHint(self, variables, values)

    def SetNumThreads(self, num_theads: "int") -> "bool":
        r""" Sets the number of threads to be used by the solver."""
        return _pywraplp.Solver_SetNumThreads(self, num_theads)

    def Add(self, constraint, name=''):
      if isinstance(constraint, bool):
        if constraint:
          return self.RowConstraint(0, 0, name)
        else:
          return self.RowConstraint(1, 1, name)
      else:
        return constraint.Extract(self, name)

    def Sum(self, expr_array):
      result = SumArray(expr_array)
      return result

    def RowConstraint(self, *args):
      return self.Constraint(*args)

    def Minimize(self, expr):
      objective = self.Objective()
      objective.Clear()
      objective.SetMinimization()
      if isinstance(expr, numbers.Number):
          objective.SetOffset(expr)
      else:
          coeffs = expr.GetCoeffs()
          objective.SetOffset(coeffs.pop(OFFSET_KEY, 0.0))
          for v, c, in list(coeffs.items()):
            objective.SetCoefficient(v, float(c))

    def Maximize(self, expr):
      objective = self.Objective()
      objective.Clear()
      objective.SetMaximization()
      if isinstance(expr, numbers.Number):
          objective.SetOffset(expr)
      else:
          coeffs = expr.GetCoeffs()
          objective.SetOffset(coeffs.pop(OFFSET_KEY, 0.0))
          for v, c, in list(coeffs.items()):
            objective.SetCoefficient(v, float(c))


    @staticmethod
    def Infinity() -> "double":
        return _pywraplp.Solver_Infinity()

    def SetTimeLimit(self, x: "int64") -> "void":
        return _pywraplp.Solver_SetTimeLimit(self, x)

    def WallTime(self) -> "int64":
        return _pywraplp.Solver_WallTime(self)

    def Iterations(self) -> "int64":
        return _pywraplp.Solver_Iterations(self)
Class variables

ABNORMAL

var ABNORMAL

abnormal, i.e., error of some kind.

AT_LOWER_BOUND

var AT_LOWER_BOUND

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.int(). For floating point numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.

>>> int('0b100', base=0)
4

AT_UPPER_BOUND

var AT_UPPER_BOUND

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.int(). For floating point numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.

>>> int('0b100', base=0)
4

BASIC

var BASIC

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.int(). For floating point numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.

>>> int('0b100', base=0)
4

BOP_INTEGER_PROGRAMMING

var BOP_INTEGER_PROGRAMMING

Linear Boolean Programming Solver.

CBC_MIXED_INTEGER_PROGRAMMING

var CBC_MIXED_INTEGER_PROGRAMMING

Mixed integer Programming Solver using Coin CBC.

CLP_LINEAR_PROGRAMMING

var CLP_LINEAR_PROGRAMMING

Linear Programming solver using Coin CBC.

FEASIBLE

var FEASIBLE

feasible, or stopped by limit.

FIXED_VALUE

var FIXED_VALUE

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.int(). For floating point numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.

>>> int('0b100', base=0)
4

FREE

var FREE

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.int(). For floating point numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.

>>> int('0b100', base=0)
4

GLOP_LINEAR_PROGRAMMING

var GLOP_LINEAR_PROGRAMMING

Linear Programming solver using GLOP (Recommended solver).

INFEASIBLE

var INFEASIBLE

proven infeasible.

NOT_SOLVED

var NOT_SOLVED

not been solved yet.

OPTIMAL

var OPTIMAL

optimal.

UNBOUNDED

var UNBOUNDED

proven unbounded.

Static methods

Infinity

def Infinity()
Expand source code
@staticmethod
def Infinity() -> "double":
    return _pywraplp.Solver_Infinity()

SolveWithProto

def SolveWithProto(model_request, response)

Solves the model encoded by a MPModelRequest protocol buffer and fills the solution encoded as a MPSolutionResponse.

Note(user): This creates a temporary MPSolver and destroys it at the end. If you want to keep the MPSolver alive (for debugging, or for incremental solving), you should write another version of this function that creates the MPSolver object on the heap and returns it.

Expand source code
@staticmethod
def SolveWithProto(model_request: "operations_research::MPModelRequest const &", response: "operations_research::MPSolutionResponse *") -> "operations_research::MPSolutionResponse *":
    r"""
    Solves the model encoded by a MPModelRequest protocol buffer and fills the
    solution encoded as a MPSolutionResponse.

    Note(user): This creates a temporary MPSolver and destroys it at the end.
    If you want to keep the MPSolver alive (for debugging, or for incremental
    solving), you should write another version of this function that creates
    the MPSolver object on the heap and returns it.
    """
    return _pywraplp.Solver_SolveWithProto(model_request, response)

SupportsProblemType

def SupportsProblemType(problem_type)

Whether the given problem type is supported (this will depend on the targets that you linked).

Expand source code
@staticmethod
def SupportsProblemType(problem_type: "operations_research::MPSolver::OptimizationProblemType") -> "bool":
    r"""
    Whether the given problem type is supported (this will depend on the
    targets that you linked).
    """
    return _pywraplp.Solver_SupportsProblemType(problem_type)

infinity

def infinity()

Infinity.

You can use -MPSolver::infinity() for negative infinity.

Expand source code
@staticmethod
def infinity() -> "double":
    r"""
    Infinity.

    You can use -MPSolver::infinity() for negative infinity.
    """
    return _pywraplp.Solver_infinity()
Methods

Add

def Add(self, constraint, name='')
Expand source code
def Add(self, constraint, name=''):
  if isinstance(constraint, bool):
    if constraint:
      return self.RowConstraint(0, 0, name)
    else:
      return self.RowConstraint(1, 1, name)
  else:
    return constraint.Extract(self, name)

BoolVar

def BoolVar(self, name)

Creates a boolean variable.

Expand source code
def BoolVar(self, name: "std::string const &") -> "operations_research::MPVariable *":
    r""" Creates a boolean variable."""
    return _pywraplp.Solver_BoolVar(self, name)

Clear

def Clear(self)

Clears the objective (including the optimization direction), all variables and constraints. All the other properties of the MPSolver (like the time limit) are kept untouched.

Expand source code
def Clear(self) -> "void":
    r"""
    Clears the objective (including the optimization direction), all variables
    and constraints. All the other properties of the MPSolver (like the time
    limit) are kept untouched.
    """
    return _pywraplp.Solver_Clear(self)

ComputeConstraintActivities

def ComputeConstraintActivities(self)

Advanced usage: compute the "activities" of all constraints, which are the sums of their linear terms. The activities are returned in the same order as constraints(), which is the order in which constraints were added; but you can also use MPConstraint::index() to get a constraint's index.

Expand source code
def ComputeConstraintActivities(self) -> "std::vector< double >":
    r"""
    Advanced usage: compute the "activities" of all constraints, which are the
    sums of their linear terms. The activities are returned in the same order
    as constraints(), which is the order in which constraints were added; but
    you can also use MPConstraint::index() to get a constraint's index.
    """
    return _pywraplp.Solver_ComputeConstraintActivities(self)

ComputeExactConditionNumber

def ComputeExactConditionNumber(self)

Advanced usage: computes the exact condition number of the current scaled basis: L1norm(B) * L1norm(inverse(B)), where B is the scaled basis.

This method requires that a basis exists: it should be called after Solve. It is only available for continuous problems. It is implemented for GLPK but not CLP because CLP does not provide the API for doing it.

The condition number measures how well the constraint matrix is conditioned and can be used to predict whether numerical issues will arise during the solve: the model is declared infeasible whereas it is feasible (or vice-versa), the solution obtained is not optimal or violates some constraints, the resolution is slow because of repeated singularities.

The rule of thumb to interpret the condition number kappa is: - o kappa <= 1e7: virtually no chance of numerical issues - o 1e7 < kappa <= 1e10: small chance of numerical issues - o 1e10 < kappa <= 1e13: medium chance of numerical issues - o kappa > 1e13: high chance of numerical issues

The computation of the condition number depends on the quality of the LU decomposition, so it is not very accurate when the matrix is ill conditioned.

Expand source code
def ComputeExactConditionNumber(self) -> "double":
    r"""
     Advanced usage: computes the exact condition number of the current scaled
    basis: L1norm(B) * L1norm(inverse(B)), where B is the scaled basis.

    This method requires that a basis exists: it should be called after Solve.
    It is only available for continuous problems. It is implemented for GLPK
    but not CLP because CLP does not provide the API for doing it.

    The condition number measures how well the constraint matrix is conditioned
    and can be used to predict whether numerical issues will arise during the
    solve: the model is declared infeasible whereas it is feasible (or
    vice-versa), the solution obtained is not optimal or violates some
    constraints, the resolution is slow because of repeated singularities.

    The rule of thumb to interpret the condition number kappa is:
      - o kappa <= 1e7: virtually no chance of numerical issues
      - o 1e7 < kappa <= 1e10: small chance of numerical issues
      - o 1e10 < kappa <= 1e13: medium chance of numerical issues
      - o kappa > 1e13: high chance of numerical issues

    The computation of the condition number depends on the quality of the LU
    decomposition, so it is not very accurate when the matrix is ill
    conditioned.
    """
    return _pywraplp.Solver_ComputeExactConditionNumber(self)

Constraint

def Constraint(self, *args)

Overload 1:

Creates a linear constraint with given bounds.

Bounds can be finite or +/- MPSolver::infinity(). The MPSolver class assumes ownership of the constraint.

:rtype: :py:class:MPConstraint :return: a pointer to the newly created constraint.

|

Overload 2: Creates a constraint with -infinity and +infinity bounds.

|

Overload 3: Creates a named constraint with given bounds.

|

Overload 4: Creates a named constraint with -infinity and +infinity bounds.

Expand source code
def Constraint(self, *args) -> "operations_research::MPConstraint *":
    r"""
    *Overload 1:*

    Creates a linear constraint with given bounds.

    Bounds can be finite or +/- MPSolver::infinity(). The MPSolver class
    assumes ownership of the constraint.

    :rtype: :py:class:`MPConstraint`
    :return: a pointer to the newly created constraint.

    |

    *Overload 2:*
     Creates a constraint with -infinity and +infinity bounds.

    |

    *Overload 3:*
     Creates a named constraint with given bounds.

    |

    *Overload 4:*
     Creates a named constraint with -infinity and +infinity bounds.
    """
    return _pywraplp.Solver_Constraint(self, *args)

EnableOutput

def EnableOutput(self)

Enables solver logging.

Expand source code
def EnableOutput(self) -> "void":
    r""" Enables solver logging."""
    return _pywraplp.Solver_EnableOutput(self)

ExportModelAsLpFormat

def ExportModelAsLpFormat(self, obfuscated)
Expand source code
def ExportModelAsLpFormat(self, obfuscated: "bool") -> "std::string":
    return _pywraplp.Solver_ExportModelAsLpFormat(self, obfuscated)

ExportModelAsMpsFormat

def ExportModelAsMpsFormat(self, fixed_format, obfuscated)
Expand source code
def ExportModelAsMpsFormat(self, fixed_format: "bool", obfuscated: "bool") -> "std::string":
    return _pywraplp.Solver_ExportModelAsMpsFormat(self, fixed_format, obfuscated)

ExportModelToProto

def ExportModelToProto(self, output_model)

Exports model to protocol buffer.

Expand source code
def ExportModelToProto(self, output_model: "operations_research::MPModelProto *") -> "void":
    r""" Exports model to protocol buffer."""
    return _pywraplp.Solver_ExportModelToProto(self, output_model)

FillSolutionResponseProto

def FillSolutionResponseProto(self, response)

Encodes the current solution in a solution response protocol buffer.

Expand source code
def FillSolutionResponseProto(self, response: "operations_research::MPSolutionResponse *") -> "void":
    r""" Encodes the current solution in a solution response protocol buffer."""
    return _pywraplp.Solver_FillSolutionResponseProto(self, response)

IntVar

def IntVar(self, lb, ub, name)

Creates an integer variable.

Expand source code
def IntVar(self, lb: "double", ub: "double", name: "std::string const &") -> "operations_research::MPVariable *":
    r""" Creates an integer variable."""
    return _pywraplp.Solver_IntVar(self, lb, ub, name)

InterruptSolve

def InterruptSolve(self)

Interrupts the Solve() execution to terminate processing if possible.

If the underlying interface supports interruption; it does that and returns true regardless of whether there's an ongoing Solve() or not. The Solve() call may still linger for a while depending on the conditions. If interruption is not supported; returns false and does nothing.

Expand source code
def InterruptSolve(self) -> "bool":
    r"""
     Interrupts the Solve() execution to terminate processing if possible.

    If the underlying interface supports interruption; it does that and returns
    true regardless of whether there's an ongoing Solve() or not. The Solve()
    call may still linger for a while depending on the conditions.  If
    interruption is not supported; returns false and does nothing.
    """
    return _pywraplp.Solver_InterruptSolve(self)

Iterations

def Iterations(self)
Expand source code
def Iterations(self) -> "int64":
    return _pywraplp.Solver_Iterations(self)

LoadModelFromProto

def LoadModelFromProto(self, input_model)
Expand source code
def LoadModelFromProto(self, input_model: "operations_research::MPModelProto const &") -> "std::string":
    return _pywraplp.Solver_LoadModelFromProto(self, input_model)

LoadSolutionFromProto

def LoadSolutionFromProto(self, *args)

Load a solution encoded in a protocol buffer onto this solver for easy access via the MPSolver interface.

IMPORTANT: This may only be used in conjunction with ExportModel(), following this example:

.. code-block:: c++

     MPSolver my_solver;
     ... add variables and constraints ...
     MPModelProto model_proto;
     my_solver.ExportModelToProto(model_proto);
     MPSolutionResponse solver_response;
     MPSolver::SolveWithProto(model_proto, solver_response);
     if (solver_response.result_status() == MPSolutionResponse::OPTIMAL) {
       CHECK_OK(my_solver.LoadSolutionFromProto(solver_response));
       ... inspect the solution using the usual API: solution_value(), etc...
     }

The response must be in OPTIMAL or FEASIBLE status.

Returns a non-OK status if a problem arised (typically, if it wasn't used like it should be): - loading a solution whose variables don't correspond to the solver's current variables - loading a solution with a status other than OPTIMAL / FEASIBLE.

Note: the objective value isn't checked. You can use VerifySolution() for that.

Expand source code
def LoadSolutionFromProto(self, *args) -> "util::Status":
    r"""
    Load a solution encoded in a protocol buffer onto this solver for easy
      access via the MPSolver interface.

    IMPORTANT: This may only be used in conjunction with ExportModel(),
      following this example:

       .. code-block:: c++

             MPSolver my_solver;
             ... add variables and constraints ...
             MPModelProto model_proto;
             my_solver.ExportModelToProto(model_proto);
             MPSolutionResponse solver_response;
             MPSolver::SolveWithProto(model_proto, solver_response);
             if (solver_response.result_status() == MPSolutionResponse::OPTIMAL) {
               CHECK_OK(my_solver.LoadSolutionFromProto(solver_response));
               ... inspect the solution using the usual API: solution_value(), etc...
             }

    The response must be in OPTIMAL or FEASIBLE status.

    Returns a non-OK status if a problem arised (typically, if it wasn't used
        like it should be):
    - loading a solution whose variables don't correspond to the solver's
      current variables
    - loading a solution with a status other than OPTIMAL / FEASIBLE.

    Note: the objective value isn't checked. You can use VerifySolution() for
          that.
    """
    return _pywraplp.Solver_LoadSolutionFromProto(self, *args)

LookupConstraint

def LookupConstraint(self, constraint_name)

Looks up a constraint by name, and returns nullptr if it does not exist.

The first call has a O(n) complexity, as the constraint name index is lazily created upon first use. Will crash if constraint names are not unique.

Expand source code
def LookupConstraint(self, constraint_name: "std::string const &") -> "operations_research::MPConstraint *":
    r"""
     Looks up a constraint by name, and returns nullptr if it does not exist.

    The first call has a O(n) complexity, as the constraint name index is
    lazily created upon first use. Will crash if constraint names are not
    unique.
    """
    return _pywraplp.Solver_LookupConstraint(self, constraint_name)

LookupVariable

def LookupVariable(self, var_name)

Looks up a variable by name, and returns nullptr if it does not exist. The first call has a O(n) complexity, as the variable name index is lazily created upon first use. Will crash if variable names are not unique.

Expand source code
def LookupVariable(self, var_name: "std::string const &") -> "operations_research::MPVariable *":
    r"""
    Looks up a variable by name, and returns nullptr if it does not exist. The
    first call has a O(n) complexity, as the variable name index is lazily
    created upon first use. Will crash if variable names are not unique.
    """
    return _pywraplp.Solver_LookupVariable(self, var_name)

Maximize

def Maximize(self, expr)
Expand source code
def Maximize(self, expr):
  objective = self.Objective()
  objective.Clear()
  objective.SetMaximization()
  if isinstance(expr, numbers.Number):
      objective.SetOffset(expr)
  else:
      coeffs = expr.GetCoeffs()
      objective.SetOffset(coeffs.pop(OFFSET_KEY, 0.0))
      for v, c, in list(coeffs.items()):
        objective.SetCoefficient(v, float(c))

Minimize

def Minimize(self, expr)
Expand source code
def Minimize(self, expr):
  objective = self.Objective()
  objective.Clear()
  objective.SetMinimization()
  if isinstance(expr, numbers.Number):
      objective.SetOffset(expr)
  else:
      coeffs = expr.GetCoeffs()
      objective.SetOffset(coeffs.pop(OFFSET_KEY, 0.0))
      for v, c, in list(coeffs.items()):
        objective.SetCoefficient(v, float(c))

NextSolution

def NextSolution(self)

Some solvers (MIP only, not LP) can produce multiple solutions to the problem. Returns true when another solution is available, and updates the MPVariable* objects to make the new solution queryable. Call only after calling solve.

The optimality properties of the additional solutions found, and whether or not the solver computes them ahead of time or when NextSolution() is called is solver specific.

As of 2018-08-09, only Gurobi supports NextSolution(), see linear_solver_underlying_gurobi_test for an example of how to configure Gurobi for this purpose. The other solvers return false unconditionally.

Expand source code
def NextSolution(self) -> "bool":
    r"""
    Some solvers (MIP only, not LP) can produce multiple solutions to the
    problem. Returns true when another solution is available, and updates the
    MPVariable* objects to make the new solution queryable. Call only after
    calling solve.

    The optimality properties of the additional solutions found, and whether or
    not the solver computes them ahead of time or when NextSolution() is called
    is solver specific.

    As of 2018-08-09, only Gurobi supports NextSolution(), see
    linear_solver_underlying_gurobi_test for an example of how to configure
    Gurobi for this purpose. The other solvers return false unconditionally.
    """
    return _pywraplp.Solver_NextSolution(self)

NumConstraints

def NumConstraints(self)

Returns the number of constraints.

Expand source code
def NumConstraints(self) -> "int":
    r""" Returns the number of constraints."""
    return _pywraplp.Solver_NumConstraints(self)

NumVar

def NumVar(self, lb, ub, name)

Creates a continuous variable.

Expand source code
def NumVar(self, lb: "double", ub: "double", name: "std::string const &") -> "operations_research::MPVariable *":
    r""" Creates a continuous variable."""
    return _pywraplp.Solver_NumVar(self, lb, ub, name)

NumVariables

def NumVariables(self)

Returns the number of variables.

Expand source code
def NumVariables(self) -> "int":
    r""" Returns the number of variables."""
    return _pywraplp.Solver_NumVariables(self)

Objective

def Objective(self)

Returns the mutable objective object.

Expand source code
def Objective(self) -> "operations_research::MPObjective *":
    r""" Returns the mutable objective object."""
    return _pywraplp.Solver_Objective(self)

RowConstraint

def RowConstraint(self, *args)
Expand source code
def RowConstraint(self, *args):
  return self.Constraint(*args)

SetHint

def SetHint(self, variables, values)

Set a hint for solution. If a feasible or almost-feasible solution to the problem is already known, it may be helpful to pass it to the solver so that it can be used. A solver that supports this feature will try to use this information to create its initial feasible solution. Note that it may not always be faster to give a hint like this to the solver. There is also no guarantee that the solver will use this hint or try to return a solution "close" to this assignment in case of multiple optimal solutions.

Expand source code
def SetHint(self, variables: "std::vector< operations_research::MPVariable * > const &", values: "std::vector< double > const &") -> "void":
    r""" Set a hint for solution. If a feasible or almost-feasible solution to the problem is already known, it may be helpful to pass it to the solver so that it can be used. A solver that supports this feature will try to use this information to create its initial feasible solution. Note that it may not always be faster to give a hint like this to the solver. There is also no guarantee that the solver will use this hint or try to return a solution "close" to this assignment in case of multiple optimal solutions."""
    return _pywraplp.Solver_SetHint(self, variables, values)

SetNumThreads

def SetNumThreads(self, num_theads)

Sets the number of threads to be used by the solver.

Expand source code
def SetNumThreads(self, num_theads: "int") -> "bool":
    r""" Sets the number of threads to be used by the solver."""
    return _pywraplp.Solver_SetNumThreads(self, num_theads)

SetSolverSpecificParametersAsString

def SetSolverSpecificParametersAsString(self, parameters)

Advanced usage: pass solver specific parameters in text format.

The format is solver-specific and is the same as the corresponding solver configuration file format. Returns true if the operation was successful.

Expand source code
def SetSolverSpecificParametersAsString(self, parameters: "std::string const &") -> "bool":
    r"""
    Advanced usage: pass solver specific parameters in text format.

    The format is solver-specific and is the same as the corresponding solver
    configuration file format. Returns true if the operation was successful.
    """
    return _pywraplp.Solver_SetSolverSpecificParametersAsString(self, parameters)

SetTimeLimit

def SetTimeLimit(self, x)
Expand source code
def SetTimeLimit(self, x: "int64") -> "void":
    return _pywraplp.Solver_SetTimeLimit(self, x)

Solve

def Solve(self, *args)

Overload 1: Solves the problem using default parameter values.

|

Overload 2: Solves the problem using the specified parameter values.

Expand source code
def Solve(self, *args) -> "operations_research::MPSolver::ResultStatus":
    r"""
    *Overload 1:*
    Solves the problem using default parameter values.

    |

    *Overload 2:*
    Solves the problem using the specified parameter values.
    """
    return _pywraplp.Solver_Solve(self, *args)

Sum

def Sum(self, expr_array)
Expand source code
def Sum(self, expr_array):
  result = SumArray(expr_array)
  return result

SuppressOutput

def SuppressOutput(self)

Suppresses solver logging.

Expand source code
def SuppressOutput(self) -> "void":
    r""" Suppresses solver logging."""
    return _pywraplp.Solver_SuppressOutput(self)

Var

def Var(self, lb, ub, integer, name)

Creates a variable with the given bounds, integrality requirement and name. Bounds can be finite or +/- MPSolver::infinity(). The MPSolver owns the variable (i.e. the returned pointer is borrowed). Variable names are optional. If you give an empty name, name() will auto-generate one for you upon request.

Expand source code
def Var(self, lb: "double", ub: "double", integer: "bool", name: "std::string const &") -> "operations_research::MPVariable *":
    r"""
    Creates a variable with the given bounds, integrality requirement and
    name. Bounds can be finite or +/- MPSolver::infinity(). The MPSolver owns
    the variable (i.e. the returned pointer is borrowed). Variable names are
    optional. If you give an empty name, name() will auto-generate one for you
    upon request.
    """
    return _pywraplp.Solver_Var(self, lb, ub, integer, name)

VerifySolution

def VerifySolution(self, tolerance, log_errors)

Advanced usage: Verifies the correctness of the solution.

It verifies that all variables must be within their domains, all constraints must be satisfied, and the reported objective value must be accurate.

Usage: - This can only be called after Solve() was called. - "tolerance" is interpreted as an absolute error threshold. - For the objective value only, if the absolute error is too large, the tolerance is interpreted as a relative error threshold instead. - If "log_errors" is true, every single violation will be logged. - If "tolerance" is negative, it will be set to infinity().

Most users should just set the –verify_solution flag and not bother using this method directly.

Expand source code
def VerifySolution(self, tolerance: "double", log_errors: "bool") -> "bool":
    r"""
    Advanced usage: Verifies the *correctness* of the solution.

    It verifies that all variables must be within their domains, all
    constraints must be satisfied, and the reported objective value must be
    accurate.

    Usage:
    - This can only be called after Solve() was called.
    - "tolerance" is interpreted as an absolute error threshold.
    - For the objective value only, if the absolute error is too large,
      the tolerance is interpreted as a relative error threshold instead.
    - If "log_errors" is true, every single violation will be logged.
    - If "tolerance" is negative, it will be set to infinity().

    Most users should just set the --verify_solution flag and not bother using
    this method directly.
    """
    return _pywraplp.Solver_VerifySolution(self, tolerance, log_errors)

WallTime

def WallTime(self)
Expand source code
def WallTime(self) -> "int64":
    return _pywraplp.Solver_WallTime(self)

constraints

def constraints(self)

Returns the array of constraints handled by the MPSolver.

They are listed in the order in which they were created.

Expand source code
def constraints(self) -> "std::vector< operations_research::MPConstraint * > const &":
    r"""
    Returns the array of constraints handled by the MPSolver.

    They are listed in the order in which they were created.
    """
    return _pywraplp.Solver_constraints(self)

iterations

def iterations(self)

Returns the number of simplex iterations.

Expand source code
def iterations(self) -> "int64":
    r""" Returns the number of simplex iterations."""
    return _pywraplp.Solver_iterations(self)

nodes

def nodes(self)

Returns the number of branch-and-bound nodes evaluated during the solve.

Only available for discrete problems.

Expand source code
def nodes(self) -> "int64":
    r"""
    Returns the number of branch-and-bound nodes evaluated during the solve.

    Only available for discrete problems.
    """
    return _pywraplp.Solver_nodes(self)

set_time_limit

def set_time_limit(self, time_limit_milliseconds)
Expand source code
def set_time_limit(self, time_limit_milliseconds: "int64") -> "void":
    return _pywraplp.Solver_set_time_limit(self, time_limit_milliseconds)

variables

def variables(self)

Returns the array of variables handled by the MPSolver. (They are listed in the order in which they were created.)

Expand source code
def variables(self) -> "std::vector< operations_research::MPVariable * > const &":
    r"""
    Returns the array of variables handled by the MPSolver. (They are listed in
    the order in which they were created.)
    """
    return _pywraplp.Solver_variables(self)

wall_time

def wall_time(self)
Expand source code
def wall_time(self) -> "int64":
    return _pywraplp.Solver_wall_time(self)

Variable

class Variable (*args, **kwargs)

The class for variables of a Mathematical Programming (MP) model.

Expand source code
class Variable(object):
    r""" The class for variables of a Mathematical Programming (MP) model."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")

    def name(self) -> "std::string const &":
        r""" Returns the name of the variable."""
        return _pywraplp.Variable_name(self)

    def integer(self) -> "bool":
        r""" Returns the integrality requirement of the variable."""
        return _pywraplp.Variable_integer(self)

    def solution_value(self) -> "double":
        r"""
        Returns the value of the variable in the current solution.

        If the variable is integer, then the value will always be an integer (the
        underlying solver handles floating-point values only, but this function
        automatically rounds it to the nearest integer; see: man 3 round).
        """
        return _pywraplp.Variable_solution_value(self)

    def index(self) -> "int":
        r""" Returns the index of the variable in the MPSolver::variables_."""
        return _pywraplp.Variable_index(self)

    def lb(self) -> "double":
        r""" Returns the lower bound."""
        return _pywraplp.Variable_lb(self)

    def ub(self) -> "double":
        r""" Returns the upper bound."""
        return _pywraplp.Variable_ub(self)

    def SetBounds(self, lb: "double", ub: "double") -> "void":
        r""" Sets both the lower and upper bounds."""
        return _pywraplp.Variable_SetBounds(self, lb, ub)

    def reduced_cost(self) -> "double":
        r"""
        Advanced usage: returns the reduced cost of the variable in the current
        solution (only available for continuous problems).
        """
        return _pywraplp.Variable_reduced_cost(self)

    def basis_status(self) -> "operations_research::MPSolver::BasisStatus":
        r"""
        Advanced usage: returns the basis status of the variable in the current
        solution (only available for continuous problems).

        See also: MPSolver::BasisStatus.
        """
        return _pywraplp.Variable_basis_status(self)

    def __str__(self) -> "std::string":
        return _pywraplp.Variable___str__(self)

    def __repr__(self) -> "std::string":
        return _pywraplp.Variable___repr__(self)

    def __getattr__(self, name):
      return getattr(VariableExpr(self), name)


    def SolutionValue(self) -> "double":
        return _pywraplp.Variable_SolutionValue(self)

    def Integer(self) -> "bool":
        return _pywraplp.Variable_Integer(self)

    def Lb(self) -> "double":
        return _pywraplp.Variable_Lb(self)

    def Ub(self) -> "double":
        return _pywraplp.Variable_Ub(self)

    def SetLb(self, x: "double") -> "void":
        return _pywraplp.Variable_SetLb(self, x)

    def SetUb(self, x: "double") -> "void":
        return _pywraplp.Variable_SetUb(self, x)

    def ReducedCost(self) -> "double":
        return _pywraplp.Variable_ReducedCost(self)
    __swig_destroy__ = _pywraplp.delete_Variable
Methods

Integer

def Integer(self)
Expand source code
def Integer(self) -> "bool":
    return _pywraplp.Variable_Integer(self)

Lb

def Lb(self)
Expand source code
def Lb(self) -> "double":
    return _pywraplp.Variable_Lb(self)

ReducedCost

def ReducedCost(self)
Expand source code
def ReducedCost(self) -> "double":
    return _pywraplp.Variable_ReducedCost(self)

SetBounds

def SetBounds(self, lb, ub)

Sets both the lower and upper bounds.

Expand source code
def SetBounds(self, lb: "double", ub: "double") -> "void":
    r""" Sets both the lower and upper bounds."""
    return _pywraplp.Variable_SetBounds(self, lb, ub)

SetLb

def SetLb(self, x)
Expand source code
def SetLb(self, x: "double") -> "void":
    return _pywraplp.Variable_SetLb(self, x)

SetUb

def SetUb(self, x)
Expand source code
def SetUb(self, x: "double") -> "void":
    return _pywraplp.Variable_SetUb(self, x)

SolutionValue

def SolutionValue(self)
Expand source code
def SolutionValue(self) -> "double":
    return _pywraplp.Variable_SolutionValue(self)

Ub

def Ub(self)
Expand source code
def Ub(self) -> "double":
    return _pywraplp.Variable_Ub(self)

basis_status

def basis_status(self)

Advanced usage: returns the basis status of the variable in the current solution (only available for continuous problems).

See also: MPSolver::BasisStatus.

Expand source code
def basis_status(self) -> "operations_research::MPSolver::BasisStatus":
    r"""
    Advanced usage: returns the basis status of the variable in the current
    solution (only available for continuous problems).

    See also: MPSolver::BasisStatus.
    """
    return _pywraplp.Variable_basis_status(self)

index

def index(self)

Returns the index of the variable in the MPSolver::variables_.

Expand source code
def index(self) -> "int":
    r""" Returns the index of the variable in the MPSolver::variables_."""
    return _pywraplp.Variable_index(self)

integer

def integer(self)

Returns the integrality requirement of the variable.

Expand source code
def integer(self) -> "bool":
    r""" Returns the integrality requirement of the variable."""
    return _pywraplp.Variable_integer(self)

lb

def lb(self)

Returns the lower bound.

Expand source code
def lb(self) -> "double":
    r""" Returns the lower bound."""
    return _pywraplp.Variable_lb(self)

name

def name(self)

Returns the name of the variable.

Expand source code
def name(self) -> "std::string const &":
    r""" Returns the name of the variable."""
    return _pywraplp.Variable_name(self)

reduced_cost

def reduced_cost(self)

Advanced usage: returns the reduced cost of the variable in the current solution (only available for continuous problems).

Expand source code
def reduced_cost(self) -> "double":
    r"""
    Advanced usage: returns the reduced cost of the variable in the current
    solution (only available for continuous problems).
    """
    return _pywraplp.Variable_reduced_cost(self)

solution_value

def solution_value(self)

Returns the value of the variable in the current solution.

If the variable is integer, then the value will always be an integer (the underlying solver handles floating-point values only, but this function automatically rounds it to the nearest integer; see: man 3 round).

Expand source code
def solution_value(self) -> "double":
    r"""
    Returns the value of the variable in the current solution.

    If the variable is integer, then the value will always be an integer (the
    underlying solver handles floating-point values only, but this function
    automatically rounds it to the nearest integer; see: man 3 round).
    """
    return _pywraplp.Variable_solution_value(self)

ub

def ub(self)

Returns the upper bound.

Expand source code
def ub(self) -> "double":
    r""" Returns the upper bound."""
    return _pywraplp.Variable_ub(self)