ortools.linear_solver.pywraplp

  1# This file was automatically generated by SWIG (https://www.swig.org).
  2# Version 4.2.1
  3#
  4# Do not make changes to this file unless you know what you are doing - modify
  5# the SWIG interface file instead.
  6
  7from sys import version_info as _swig_python_version_info
  8# Import the low-level C/C++ module
  9if __package__ or "." in __name__:
 10    from . import _pywraplp
 11else:
 12    import _pywraplp
 13
 14try:
 15    import builtins as __builtin__
 16except ImportError:
 17    import __builtin__
 18
 19def _swig_repr(self):
 20    try:
 21        strthis = "proxy of " + self.this.__repr__()
 22    except __builtin__.Exception:
 23        strthis = ""
 24    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
 25
 26
 27def _swig_setattr_nondynamic_instance_variable(set):
 28    def set_instance_attr(self, name, value):
 29        if name == "this":
 30            set(self, name, value)
 31        elif name == "thisown":
 32            self.this.own(value)
 33        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
 34            set(self, name, value)
 35        else:
 36            raise AttributeError("You cannot add instance attributes to %s" % self)
 37    return set_instance_attr
 38
 39
 40def _swig_setattr_nondynamic_class_variable(set):
 41    def set_class_attr(cls, name, value):
 42        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
 43            set(cls, name, value)
 44        else:
 45            raise AttributeError("You cannot add class attributes to %s" % cls)
 46    return set_class_attr
 47
 48
 49def _swig_add_metaclass(metaclass):
 50    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
 51    def wrapper(cls):
 52        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
 53    return wrapper
 54
 55
 56class _SwigNonDynamicMeta(type):
 57    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
 58    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
 59
 60
 61
 62import numbers
 63from ortools.linear_solver.python.linear_solver_natural_api import OFFSET_KEY
 64from ortools.linear_solver.python.linear_solver_natural_api import inf
 65from ortools.linear_solver.python.linear_solver_natural_api import LinearExpr
 66from ortools.linear_solver.python.linear_solver_natural_api import ProductCst
 67from ortools.linear_solver.python.linear_solver_natural_api import Sum
 68from ortools.linear_solver.python.linear_solver_natural_api import SumArray
 69from ortools.linear_solver.python.linear_solver_natural_api import SumCst
 70from ortools.linear_solver.python.linear_solver_natural_api import LinearConstraint
 71from ortools.linear_solver.python.linear_solver_natural_api import VariableExpr
 72
 73class Solver(object):
 74    r"""
 75    This mathematical programming (MP) solver class is the main class
 76    though which users build and solve problems.
 77    """
 78
 79    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 80    __repr__ = _swig_repr
 81    CLP_LINEAR_PROGRAMMING = _pywraplp.Solver_CLP_LINEAR_PROGRAMMING
 82    GLPK_LINEAR_PROGRAMMING = _pywraplp.Solver_GLPK_LINEAR_PROGRAMMING
 83    GLOP_LINEAR_PROGRAMMING = _pywraplp.Solver_GLOP_LINEAR_PROGRAMMING
 84    PDLP_LINEAR_PROGRAMMING = _pywraplp.Solver_PDLP_LINEAR_PROGRAMMING
 85    SCIP_MIXED_INTEGER_PROGRAMMING = _pywraplp.Solver_SCIP_MIXED_INTEGER_PROGRAMMING
 86    GLPK_MIXED_INTEGER_PROGRAMMING = _pywraplp.Solver_GLPK_MIXED_INTEGER_PROGRAMMING
 87    CBC_MIXED_INTEGER_PROGRAMMING = _pywraplp.Solver_CBC_MIXED_INTEGER_PROGRAMMING
 88    BOP_INTEGER_PROGRAMMING = _pywraplp.Solver_BOP_INTEGER_PROGRAMMING
 89    SAT_INTEGER_PROGRAMMING = _pywraplp.Solver_SAT_INTEGER_PROGRAMMING
 90    GUROBI_LINEAR_PROGRAMMING = _pywraplp.Solver_GUROBI_LINEAR_PROGRAMMING
 91    GUROBI_MIXED_INTEGER_PROGRAMMING = _pywraplp.Solver_GUROBI_MIXED_INTEGER_PROGRAMMING
 92    CPLEX_LINEAR_PROGRAMMING = _pywraplp.Solver_CPLEX_LINEAR_PROGRAMMING
 93    CPLEX_MIXED_INTEGER_PROGRAMMING = _pywraplp.Solver_CPLEX_MIXED_INTEGER_PROGRAMMING
 94    XPRESS_LINEAR_PROGRAMMING = _pywraplp.Solver_XPRESS_LINEAR_PROGRAMMING
 95    XPRESS_MIXED_INTEGER_PROGRAMMING = _pywraplp.Solver_XPRESS_MIXED_INTEGER_PROGRAMMING
 96
 97    def __init__(self, name, problem_type):
 98        r""" Create a solver with the given name and underlying solver backend."""
 99        _pywraplp.Solver_swiginit(self, _pywraplp.new_Solver(name, problem_type))
100    __swig_destroy__ = _pywraplp.delete_Solver
101
102    @staticmethod
103    def CreateSolver(solver_id):
104        r"""
105        Recommended factory method to create a MPSolver instance, especially in
106        non C++ languages.
107
108        It returns a newly created solver instance if successful, or a nullptr
109        otherwise. This can occur if the relevant interface is not linked in, or if
110        a needed license is not accessible for commercial solvers.
111
112        Ownership of the solver is passed on to the caller of this method.
113        It will accept both string names of the OptimizationProblemType enum, as
114        well as a short version (i.e. "SCIP_MIXED_INTEGER_PROGRAMMING" or "SCIP").
115
116        solver_id is case insensitive, and the following names are supported:
117          - CLP_LINEAR_PROGRAMMING or CLP
118          - CBC_MIXED_INTEGER_PROGRAMMING or CBC
119          - GLOP_LINEAR_PROGRAMMING or GLOP
120          - BOP_INTEGER_PROGRAMMING or BOP
121          - SAT_INTEGER_PROGRAMMING or SAT or CP_SAT
122          - SCIP_MIXED_INTEGER_PROGRAMMING or SCIP
123          - GUROBI_LINEAR_PROGRAMMING or GUROBI_LP
124          - GUROBI_MIXED_INTEGER_PROGRAMMING or GUROBI or GUROBI_MIP
125          - CPLEX_LINEAR_PROGRAMMING or CPLEX_LP
126          - CPLEX_MIXED_INTEGER_PROGRAMMING or CPLEX or CPLEX_MIP
127          - XPRESS_LINEAR_PROGRAMMING or XPRESS_LP
128          - XPRESS_MIXED_INTEGER_PROGRAMMING or XPRESS or XPRESS_MIP
129          - GLPK_LINEAR_PROGRAMMING or GLPK_LP
130          - GLPK_MIXED_INTEGER_PROGRAMMING or GLPK or GLPK_MIP
131        """
132        return _pywraplp.Solver_CreateSolver(solver_id)
133
134    @staticmethod
135    def SupportsProblemType(problem_type):
136        r"""
137        Whether the given problem type is supported (this will depend on the
138        targets that you linked).
139        """
140        return _pywraplp.Solver_SupportsProblemType(problem_type)
141
142    def IsMip(self):
143        return _pywraplp.Solver_IsMip(self)
144
145    def Clear(self):
146        r"""
147        Clears the objective (including the optimization direction), all variables
148        and constraints. All the other properties of the MPSolver (like the time
149        limit) are kept untouched.
150        """
151        return _pywraplp.Solver_Clear(self)
152
153    def NumVariables(self):
154        r""" Returns the number of variables."""
155        return _pywraplp.Solver_NumVariables(self)
156
157    def variables(self):
158        r"""
159        Returns the array of variables handled by the MPSolver. (They are listed in
160        the order in which they were created.)
161        """
162        return _pywraplp.Solver_variables(self)
163
164    def variable(self, index):
165        r"""Returns the variable at position index."""
166        return _pywraplp.Solver_variable(self, index)
167
168    def LookupVariable(self, var_name):
169        r"""
170        Looks up a variable by name, and returns nullptr if it does not exist. The
171        first call has a O(n) complexity, as the variable name index is lazily
172        created upon first use. Will crash if variable names are not unique.
173        """
174        return _pywraplp.Solver_LookupVariable(self, var_name)
175
176    def Var(self, lb, ub, integer, name):
177        r"""
178        Creates a variable with the given bounds, integrality requirement and
179        name. Bounds can be finite or +/- MPSolver::infinity(). The MPSolver owns
180        the variable (i.e. the returned pointer is borrowed). Variable names are
181        optional. If you give an empty name, name() will auto-generate one for you
182        upon request.
183        """
184        return _pywraplp.Solver_Var(self, lb, ub, integer, name)
185
186    def NumVar(self, lb, ub, name):
187        r""" Creates a continuous variable."""
188        return _pywraplp.Solver_NumVar(self, lb, ub, name)
189
190    def IntVar(self, lb, ub, name):
191        r""" Creates an integer variable."""
192        return _pywraplp.Solver_IntVar(self, lb, ub, name)
193
194    def BoolVar(self, name):
195        r""" Creates a boolean variable."""
196        return _pywraplp.Solver_BoolVar(self, name)
197
198    def NumConstraints(self):
199        r""" Returns the number of constraints."""
200        return _pywraplp.Solver_NumConstraints(self)
201
202    def constraints(self):
203        r"""
204        Returns the array of constraints handled by the MPSolver.
205
206        They are listed in the order in which they were created.
207        """
208        return _pywraplp.Solver_constraints(self)
209
210    def constraint(self, index):
211        r""" Returns the constraint at the given index."""
212        return _pywraplp.Solver_constraint(self, index)
213
214    def LookupConstraint(self, constraint_name):
215        r"""
216         Looks up a constraint by name, and returns nullptr if it does not exist.
217
218        The first call has a O(n) complexity, as the constraint name index is
219        lazily created upon first use. Will crash if constraint names are not
220        unique.
221        """
222        return _pywraplp.Solver_LookupConstraint(self, constraint_name)
223
224    def Constraint(self, *args):
225        r"""
226        *Overload 1:*
227
228        Creates a linear constraint with given bounds.
229
230        Bounds can be finite or +/- MPSolver::infinity(). The MPSolver class
231        assumes ownership of the constraint.
232
233        :rtype: :py:class:`MPConstraint`
234        :return: a pointer to the newly created constraint.
235
236        |
237
238        *Overload 2:*
239         Creates a constraint with -infinity and +infinity bounds.
240
241        |
242
243        *Overload 3:*
244         Creates a named constraint with given bounds.
245
246        |
247
248        *Overload 4:*
249         Creates a named constraint with -infinity and +infinity bounds.
250        """
251        return _pywraplp.Solver_Constraint(self, *args)
252
253    def Objective(self):
254        r""" Returns the mutable objective object."""
255        return _pywraplp.Solver_Objective(self)
256    OPTIMAL = _pywraplp.Solver_OPTIMAL
257    r""" optimal."""
258    FEASIBLE = _pywraplp.Solver_FEASIBLE
259    r""" feasible, or stopped by limit."""
260    INFEASIBLE = _pywraplp.Solver_INFEASIBLE
261    r""" proven infeasible."""
262    UNBOUNDED = _pywraplp.Solver_UNBOUNDED
263    r""" proven unbounded."""
264    ABNORMAL = _pywraplp.Solver_ABNORMAL
265    r""" abnormal, i.e., error of some kind."""
266    MODEL_INVALID = _pywraplp.Solver_MODEL_INVALID
267    r""" the model is trivially invalid (NaN coefficients, etc)."""
268    NOT_SOLVED = _pywraplp.Solver_NOT_SOLVED
269    r""" not been solved yet."""
270
271    def Solve(self, *args):
272        r"""
273        *Overload 1:*
274        Solves the problem using the default parameter values.
275
276        |
277
278        *Overload 2:*
279        Solves the problem using the specified parameter values.
280        """
281        return _pywraplp.Solver_Solve(self, *args)
282
283    def Write(self, file_name):
284        r"""
285        Writes the model using the solver internal write function.  Currently only
286        available for Gurobi.
287        """
288        return _pywraplp.Solver_Write(self, file_name)
289
290    def ComputeConstraintActivities(self):
291        r"""
292        Advanced usage: compute the "activities" of all constraints, which are the
293        sums of their linear terms. The activities are returned in the same order
294        as constraints(), which is the order in which constraints were added; but
295        you can also use MPConstraint::index() to get a constraint's index.
296        """
297        return _pywraplp.Solver_ComputeConstraintActivities(self)
298
299    def VerifySolution(self, tolerance, log_errors):
300        r"""
301        Advanced usage: Verifies the *correctness* of the solution.
302
303        It verifies that all variables must be within their domains, all
304        constraints must be satisfied, and the reported objective value must be
305        accurate.
306
307        Usage:
308        - This can only be called after Solve() was called.
309        - "tolerance" is interpreted as an absolute error threshold.
310        - For the objective value only, if the absolute error is too large,
311          the tolerance is interpreted as a relative error threshold instead.
312        - If "log_errors" is true, every single violation will be logged.
313        - If "tolerance" is negative, it will be set to infinity().
314
315        Most users should just set the --verify_solution flag and not bother using
316        this method directly.
317        """
318        return _pywraplp.Solver_VerifySolution(self, tolerance, log_errors)
319
320    def InterruptSolve(self):
321        r"""
322         Interrupts the Solve() execution to terminate processing if possible.
323
324        If the underlying interface supports interruption; it does that and returns
325        true regardless of whether there's an ongoing Solve() or not. The Solve()
326        call may still linger for a while depending on the conditions.  If
327        interruption is not supported; returns false and does nothing.
328        MPSolver::SolverTypeSupportsInterruption can be used to check if
329        interruption is supported for a given solver type.
330        """
331        return _pywraplp.Solver_InterruptSolve(self)
332
333    def FillSolutionResponseProto(self, response):
334        r""" Encodes the current solution in a solution response protocol buffer."""
335        return _pywraplp.Solver_FillSolutionResponseProto(self, response)
336
337    @staticmethod
338    def SolveWithProto(model_request, response, interrupt=None):
339        r"""
340        Solves the model encoded by a MPModelRequest protocol buffer and fills the
341        solution encoded as a MPSolutionResponse. The solve is stopped prematurely
342        if interrupt is non-null at set to true during (or before) solving.
343        Interruption is only supported if SolverTypeSupportsInterruption() returns
344        true for the requested solver. Passing a non-null interruption with any
345        other solver type immediately returns an MPSOLVER_INCOMPATIBLE_OPTIONS
346        error.
347
348        `interrupt` is non-const because the internal solver may set it to true
349        itself, in some cases.
350
351        Note(user): This attempts to first use `DirectlySolveProto()` (if
352        implemented). Consequently, this most likely does *not* override any of
353        the default parameters of the underlying solver. This behavior *differs*
354        from `MPSolver::Solve()` which by default sets the feasibility tolerance
355        and the gap limit (as of 2020/02/11, to 1e-7 and 0.0001, respectively).
356        """
357        return _pywraplp.Solver_SolveWithProto(model_request, response, interrupt)
358
359    def ExportModelToProto(self, output_model):
360        r""" Exports model to protocol buffer."""
361        return _pywraplp.Solver_ExportModelToProto(self, output_model)
362
363    def SetSolverSpecificParametersAsString(self, parameters):
364        r"""
365        Advanced usage: pass solver specific parameters in text format.
366
367        The format is solver-specific and is the same as the corresponding solver
368        configuration file format. Returns true if the operation was successful.
369        """
370        return _pywraplp.Solver_SetSolverSpecificParametersAsString(self, parameters)
371    FREE = _pywraplp.Solver_FREE
372    AT_LOWER_BOUND = _pywraplp.Solver_AT_LOWER_BOUND
373    AT_UPPER_BOUND = _pywraplp.Solver_AT_UPPER_BOUND
374    FIXED_VALUE = _pywraplp.Solver_FIXED_VALUE
375    BASIC = _pywraplp.Solver_BASIC
376
377    @staticmethod
378    def infinity():
379        r"""
380        Infinity.
381
382        You can use -MPSolver::infinity() for negative infinity.
383        """
384        return _pywraplp.Solver_infinity()
385
386    def EnableOutput(self):
387        r""" Enables solver logging."""
388        return _pywraplp.Solver_EnableOutput(self)
389
390    def SuppressOutput(self):
391        r""" Suppresses solver logging."""
392        return _pywraplp.Solver_SuppressOutput(self)
393
394    def iterations(self):
395        r""" Returns the number of simplex iterations."""
396        return _pywraplp.Solver_iterations(self)
397
398    def nodes(self):
399        r"""
400        Returns the number of branch-and-bound nodes evaluated during the solve.
401
402        Only available for discrete problems.
403        """
404        return _pywraplp.Solver_nodes(self)
405
406    def SolverVersion(self):
407        r""" Returns a string describing the underlying solver and its version."""
408        return _pywraplp.Solver_SolverVersion(self)
409
410    def ComputeExactConditionNumber(self):
411        r"""
412         Advanced usage: computes the exact condition number of the current scaled
413        basis: L1norm(B) * L1norm(inverse(B)), where B is the scaled basis.
414
415        This method requires that a basis exists: it should be called after Solve.
416        It is only available for continuous problems. It is implemented for GLPK
417        but not CLP because CLP does not provide the API for doing it.
418
419        The condition number measures how well the constraint matrix is conditioned
420        and can be used to predict whether numerical issues will arise during the
421        solve: the model is declared infeasible whereas it is feasible (or
422        vice-versa), the solution obtained is not optimal or violates some
423        constraints, the resolution is slow because of repeated singularities.
424
425        The rule of thumb to interpret the condition number kappa is:
426          - o kappa <= 1e7: virtually no chance of numerical issues
427          - o 1e7 < kappa <= 1e10: small chance of numerical issues
428          - o 1e10 < kappa <= 1e13: medium chance of numerical issues
429          - o kappa > 1e13: high chance of numerical issues
430
431        The computation of the condition number depends on the quality of the LU
432        decomposition, so it is not very accurate when the matrix is ill
433        conditioned.
434        """
435        return _pywraplp.Solver_ComputeExactConditionNumber(self)
436
437    def NextSolution(self):
438        r"""
439        Some solvers (MIP only, not LP) can produce multiple solutions to the
440        problem. Returns true when another solution is available, and updates the
441        MPVariable* objects to make the new solution queryable. Call only after
442        calling solve.
443
444        The optimality properties of the additional solutions found, and whether or
445        not the solver computes them ahead of time or when NextSolution() is called
446        is solver specific.
447
448        As of 2020-02-10, only Gurobi and SCIP support NextSolution(), see
449        linear_solver_interfaces_test for an example of how to configure these
450        solvers for multiple solutions. Other solvers return false unconditionally.
451        """
452        return _pywraplp.Solver_NextSolution(self)
453
454    def set_time_limit(self, time_limit_milliseconds):
455        return _pywraplp.Solver_set_time_limit(self, time_limit_milliseconds)
456
457    def wall_time(self):
458        return _pywraplp.Solver_wall_time(self)
459
460    def LoadModelFromProto(self, input_model):
461        return _pywraplp.Solver_LoadModelFromProto(self, input_model)
462
463    def LoadModelFromProtoKeepNames(self, input_model):
464        return _pywraplp.Solver_LoadModelFromProtoKeepNames(self, input_model)
465
466    def LoadModelFromProtoWithUniqueNamesOrDie(self, input_model):
467        return _pywraplp.Solver_LoadModelFromProtoWithUniqueNamesOrDie(self, input_model)
468
469    def LoadSolutionFromProto(self, *args):
470        return _pywraplp.Solver_LoadSolutionFromProto(self, *args)
471
472    def ExportModelAsLpFormat(self, obfuscated):
473        return _pywraplp.Solver_ExportModelAsLpFormat(self, obfuscated)
474
475    def ExportModelAsMpsFormat(self, fixed_format, obfuscated):
476        return _pywraplp.Solver_ExportModelAsMpsFormat(self, fixed_format, obfuscated)
477
478    def SetHint(self, variables, values):
479        r"""
480        Set a hint for solution.
481
482        If a feasible or almost-feasible solution to the problem is already known,
483        it may be helpful to pass it to the solver so that it can be used. A
484        solver that supports this feature will try to use this information to
485        create its initial feasible solution.
486
487        Note that it may not always be faster to give a hint like this to the
488        solver. There is also no guarantee that the solver will use this hint or
489        try to return a solution "close" to this assignment in case of multiple
490        optimal solutions.
491        """
492        return _pywraplp.Solver_SetHint(self, variables, values)
493
494    def SetNumThreads(self, num_theads):
495        r""" Sets the number of threads to be used by the solver."""
496        return _pywraplp.Solver_SetNumThreads(self, num_theads)
497
498    def Add(self, constraint, name=''):
499      if isinstance(constraint, bool):
500        if constraint:
501          return self.RowConstraint(0, 0, name)
502        else:
503          return self.RowConstraint(1, 1, name)
504      else:
505        return constraint.Extract(self, name)
506
507    def Sum(self, expr_array):
508      result = SumArray(expr_array)
509      return result
510
511    def RowConstraint(self, *args):
512      return self.Constraint(*args)
513
514    def Minimize(self, expr):
515      objective = self.Objective()
516      objective.Clear()
517      objective.SetMinimization()
518      if isinstance(expr, numbers.Number):
519          objective.SetOffset(expr)
520      else:
521          coeffs = expr.GetCoeffs()
522          objective.SetOffset(coeffs.pop(OFFSET_KEY, 0.0))
523          for v, c, in list(coeffs.items()):
524            objective.SetCoefficient(v, float(c))
525
526    def Maximize(self, expr):
527      objective = self.Objective()
528      objective.Clear()
529      objective.SetMaximization()
530      if isinstance(expr, numbers.Number):
531          objective.SetOffset(expr)
532      else:
533          coeffs = expr.GetCoeffs()
534          objective.SetOffset(coeffs.pop(OFFSET_KEY, 0.0))
535          for v, c, in list(coeffs.items()):
536            objective.SetCoefficient(v, float(c))
537
538
539    @staticmethod
540    def Infinity():
541        return _pywraplp.Solver_Infinity()
542
543    def SetTimeLimit(self, x):
544        return _pywraplp.Solver_SetTimeLimit(self, x)
545
546    def WallTime(self):
547        return _pywraplp.Solver_WallTime(self)
548
549    def Iterations(self):
550        return _pywraplp.Solver_Iterations(self)
551
552# Register Solver in _pywraplp:
553_pywraplp.Solver_swigregister(Solver)
554
555def __lshift__(*args):
556    return _pywraplp.__lshift__(*args)
557class Objective(object):
558    r""" A class to express a linear objective."""
559
560    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
561
562    def __init__(self, *args, **kwargs):
563        raise AttributeError("No constructor defined")
564    __repr__ = _swig_repr
565
566    def Clear(self):
567        r"""
568         Clears the offset, all variables and coefficients, and the optimization
569        direction.
570        """
571        return _pywraplp.Objective_Clear(self)
572
573    def SetCoefficient(self, var, coeff):
574        r"""
575        Sets the coefficient of the variable in the objective.
576
577        If the variable does not belong to the solver, the function just returns,
578        or crashes in non-opt mode.
579        """
580        return _pywraplp.Objective_SetCoefficient(self, var, coeff)
581
582    def GetCoefficient(self, var):
583        r"""
584         Gets the coefficient of a given variable in the objective
585
586        It returns 0 if the variable does not appear in the objective).
587        """
588        return _pywraplp.Objective_GetCoefficient(self, var)
589
590    def SetOffset(self, value):
591        r""" Sets the constant term in the objective."""
592        return _pywraplp.Objective_SetOffset(self, value)
593
594    def offset(self):
595        r""" Gets the constant term in the objective."""
596        return _pywraplp.Objective_offset(self)
597
598    def SetOptimizationDirection(self, maximize):
599        r""" Sets the optimization direction (maximize: true or minimize: false)."""
600        return _pywraplp.Objective_SetOptimizationDirection(self, maximize)
601
602    def SetMinimization(self):
603        r""" Sets the optimization direction to minimize."""
604        return _pywraplp.Objective_SetMinimization(self)
605
606    def SetMaximization(self):
607        r""" Sets the optimization direction to maximize."""
608        return _pywraplp.Objective_SetMaximization(self)
609
610    def maximization(self):
611        r""" Is the optimization direction set to maximize?"""
612        return _pywraplp.Objective_maximization(self)
613
614    def minimization(self):
615        r""" Is the optimization direction set to minimize?"""
616        return _pywraplp.Objective_minimization(self)
617
618    def Value(self):
619        r"""
620        Returns the objective value of the best solution found so far.
621
622        It is the optimal objective value if the problem has been solved to
623        optimality.
624
625        Note: the objective value may be slightly different than what you could
626        compute yourself using ``MPVariable::solution_value();`` please use the
627        --verify_solution flag to gain confidence about the numerical stability of
628        your solution.
629        """
630        return _pywraplp.Objective_Value(self)
631
632    def BestBound(self):
633        r"""
634        Returns the best objective bound.
635
636        In case of minimization, it is a lower bound on the objective value of the
637        optimal integer solution. Only available for discrete problems.
638        """
639        return _pywraplp.Objective_BestBound(self)
640
641    def Offset(self):
642        return _pywraplp.Objective_Offset(self)
643    __swig_destroy__ = _pywraplp.delete_Objective
644
645# Register Objective in _pywraplp:
646_pywraplp.Objective_swigregister(Objective)
647class Variable(object):
648    r""" The class for variables of a Mathematical Programming (MP) model."""
649
650    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
651
652    def __init__(self, *args, **kwargs):
653        raise AttributeError("No constructor defined")
654
655    def name(self):
656        r""" Returns the name of the variable."""
657        return _pywraplp.Variable_name(self)
658
659    def SetInteger(self, integer):
660        r""" Sets the integrality requirement of the variable."""
661        return _pywraplp.Variable_SetInteger(self, integer)
662
663    def integer(self):
664        r""" Returns the integrality requirement of the variable."""
665        return _pywraplp.Variable_integer(self)
666
667    def solution_value(self):
668        r"""
669        Returns the value of the variable in the current solution.
670
671        If the variable is integer, then the value will always be an integer (the
672        underlying solver handles floating-point values only, but this function
673        automatically rounds it to the nearest integer; see: man 3 round).
674        """
675        return _pywraplp.Variable_solution_value(self)
676
677    def index(self):
678        r""" Returns the index of the variable in the MPSolver::variables_."""
679        return _pywraplp.Variable_index(self)
680
681    def lb(self):
682        r""" Returns the lower bound."""
683        return _pywraplp.Variable_lb(self)
684
685    def ub(self):
686        r""" Returns the upper bound."""
687        return _pywraplp.Variable_ub(self)
688
689    def SetBounds(self, lb, ub):
690        r""" Sets both the lower and upper bounds."""
691        return _pywraplp.Variable_SetBounds(self, lb, ub)
692
693    def reduced_cost(self):
694        r"""
695        Advanced usage: returns the reduced cost of the variable in the current
696        solution (only available for continuous problems).
697        """
698        return _pywraplp.Variable_reduced_cost(self)
699
700    def basis_status(self):
701        r"""
702        Advanced usage: returns the basis status of the variable in the current
703        solution (only available for continuous problems).
704
705        See also: MPSolver::BasisStatus.
706        """
707        return _pywraplp.Variable_basis_status(self)
708
709    def branching_priority(self):
710        r"""
711        Advanced usage: Certain MIP solvers (e.g. Gurobi or SCIP) allow you to set
712        a per-variable priority for determining which variable to branch on.
713
714        A value of 0 is treated as default, and is equivalent to not setting the
715        branching priority. The solver looks first to branch on fractional
716        variables in higher priority levels. As of 2019-05, only Gurobi and SCIP
717        support setting branching priority; all other solvers will simply ignore
718        this annotation.
719        """
720        return _pywraplp.Variable_branching_priority(self)
721
722    def SetBranchingPriority(self, priority):
723        return _pywraplp.Variable_SetBranchingPriority(self, priority)
724
725    def __str__(self):
726        return _pywraplp.Variable___str__(self)
727
728    def __repr__(self):
729        return _pywraplp.Variable___repr__(self)
730
731    def __getattr__(self, name):
732      return getattr(VariableExpr(self), name)
733
734
735    def SolutionValue(self):
736        return _pywraplp.Variable_SolutionValue(self)
737
738    def Integer(self):
739        return _pywraplp.Variable_Integer(self)
740
741    def Lb(self):
742        return _pywraplp.Variable_Lb(self)
743
744    def Ub(self):
745        return _pywraplp.Variable_Ub(self)
746
747    def SetLb(self, x):
748        return _pywraplp.Variable_SetLb(self, x)
749
750    def SetUb(self, x):
751        return _pywraplp.Variable_SetUb(self, x)
752
753    def ReducedCost(self):
754        return _pywraplp.Variable_ReducedCost(self)
755    __swig_destroy__ = _pywraplp.delete_Variable
756
757# Register Variable in _pywraplp:
758_pywraplp.Variable_swigregister(Variable)
759class Constraint(object):
760    r"""
761    The class for constraints of a Mathematical Programming (MP) model.
762
763    A constraint is represented as a linear equation or inequality.
764    """
765
766    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
767
768    def __init__(self, *args, **kwargs):
769        raise AttributeError("No constructor defined")
770    __repr__ = _swig_repr
771
772    def name(self):
773        r""" Returns the name of the constraint."""
774        return _pywraplp.Constraint_name(self)
775
776    def Clear(self):
777        r""" Clears all variables and coefficients. Does not clear the bounds."""
778        return _pywraplp.Constraint_Clear(self)
779
780    def SetCoefficient(self, var, coeff):
781        r"""
782        Sets the coefficient of the variable on the constraint.
783
784        If the variable does not belong to the solver, the function just returns,
785        or crashes in non-opt mode.
786        """
787        return _pywraplp.Constraint_SetCoefficient(self, var, coeff)
788
789    def GetCoefficient(self, var):
790        r"""
791        Gets the coefficient of a given variable on the constraint (which is 0 if
792        the variable does not appear in the constraint).
793        """
794        return _pywraplp.Constraint_GetCoefficient(self, var)
795
796    def lb(self):
797        r""" Returns the lower bound."""
798        return _pywraplp.Constraint_lb(self)
799
800    def ub(self):
801        r""" Returns the upper bound."""
802        return _pywraplp.Constraint_ub(self)
803
804    def SetBounds(self, lb, ub):
805        r""" Sets both the lower and upper bounds."""
806        return _pywraplp.Constraint_SetBounds(self, lb, ub)
807
808    def set_is_lazy(self, laziness):
809        r"""
810        Advanced usage: sets the constraint "laziness".
811
812        **This is only supported for SCIP and has no effect on other
813        solvers.**
814
815        When **laziness** is true, the constraint is only considered by the Linear
816        Programming solver if its current solution violates the constraint. In this
817        case, the constraint is definitively added to the problem. This may be
818        useful in some MIP problems, and may have a dramatic impact on performance.
819
820        For more info see: http://tinyurl.com/lazy-constraints.
821        """
822        return _pywraplp.Constraint_set_is_lazy(self, laziness)
823
824    def index(self):
825        r""" Returns the index of the constraint in the MPSolver::constraints_."""
826        return _pywraplp.Constraint_index(self)
827
828    def dual_value(self):
829        r"""
830        Advanced usage: returns the dual value of the constraint in the current
831        solution (only available for continuous problems).
832        """
833        return _pywraplp.Constraint_dual_value(self)
834
835    def basis_status(self):
836        r"""
837        Advanced usage: returns the basis status of the constraint.
838
839        It is only available for continuous problems).
840
841        Note that if a constraint "linear_expression in [lb, ub]" is transformed
842        into "linear_expression + slack = 0" with slack in [-ub, -lb], then this
843        status is the same as the status of the slack variable with AT_UPPER_BOUND
844        and AT_LOWER_BOUND swapped.
845
846        See also: MPSolver::BasisStatus.
847        """
848        return _pywraplp.Constraint_basis_status(self)
849
850    def Lb(self):
851        return _pywraplp.Constraint_Lb(self)
852
853    def Ub(self):
854        return _pywraplp.Constraint_Ub(self)
855
856    def SetLb(self, x):
857        return _pywraplp.Constraint_SetLb(self, x)
858
859    def SetUb(self, x):
860        return _pywraplp.Constraint_SetUb(self, x)
861
862    def DualValue(self):
863        return _pywraplp.Constraint_DualValue(self)
864    __swig_destroy__ = _pywraplp.delete_Constraint
865
866# Register Constraint in _pywraplp:
867_pywraplp.Constraint_swigregister(Constraint)
868class MPSolverParameters(object):
869    r"""
870    This class stores parameter settings for LP and MIP solvers. Some parameters
871    are marked as advanced: do not change their values unless you know what you
872    are doing!
873
874    For developers: how to add a new parameter:
875    - Add the new Foo parameter in the DoubleParam or IntegerParam enum.
876    - If it is a categorical param, add a FooValues enum.
877    - Decide if the wrapper should define a default value for it: yes
878      if it controls the properties of the solution (example:
879      tolerances) or if it consistently improves performance, no
880      otherwise. If yes, define kDefaultFoo.
881    - Add a foo_value_ member and, if no default value is defined, a
882      foo_is_default_ member.
883    - Add code to handle Foo in Set...Param, Reset...Param,
884      Get...Param, Reset and the constructor.
885    - In class MPSolverInterface, add a virtual method SetFoo, add it
886      to SetCommonParameters or SetMIPParameters, and implement it for
887      each solver. Sometimes, parameters need to be implemented
888      differently, see for example the INCREMENTALITY implementation.
889    - Add a test in linear_solver_test.cc.
890
891    TODO(user): store the parameter values in a protocol buffer
892    instead. We need to figure out how to deal with the subtleties of
893    the default values.
894    """
895
896    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
897    __repr__ = _swig_repr
898    RELATIVE_MIP_GAP = _pywraplp.MPSolverParameters_RELATIVE_MIP_GAP
899    r""" Limit for relative MIP gap."""
900    PRIMAL_TOLERANCE = _pywraplp.MPSolverParameters_PRIMAL_TOLERANCE
901    r"""
902    Advanced usage: tolerance for primal feasibility of basic solutions.
903
904    This does not control the integer feasibility tolerance of integer
905    solutions for MIP or the tolerance used during presolve.
906    """
907    DUAL_TOLERANCE = _pywraplp.MPSolverParameters_DUAL_TOLERANCE
908    r""" Advanced usage: tolerance for dual feasibility of basic solutions."""
909    PRESOLVE = _pywraplp.MPSolverParameters_PRESOLVE
910    r""" Advanced usage: presolve mode."""
911    LP_ALGORITHM = _pywraplp.MPSolverParameters_LP_ALGORITHM
912    r""" Algorithm to solve linear programs."""
913    INCREMENTALITY = _pywraplp.MPSolverParameters_INCREMENTALITY
914    r""" Advanced usage: incrementality from one solve to the next."""
915    SCALING = _pywraplp.MPSolverParameters_SCALING
916    r""" Advanced usage: enable or disable matrix scaling."""
917    PRESOLVE_OFF = _pywraplp.MPSolverParameters_PRESOLVE_OFF
918    r""" Presolve is off."""
919    PRESOLVE_ON = _pywraplp.MPSolverParameters_PRESOLVE_ON
920    r""" Presolve is on."""
921    DUAL = _pywraplp.MPSolverParameters_DUAL
922    r""" Dual simplex."""
923    PRIMAL = _pywraplp.MPSolverParameters_PRIMAL
924    r""" Primal simplex."""
925    BARRIER = _pywraplp.MPSolverParameters_BARRIER
926    r""" Barrier algorithm."""
927    INCREMENTALITY_OFF = _pywraplp.MPSolverParameters_INCREMENTALITY_OFF
928    r""" Start solve from scratch."""
929    INCREMENTALITY_ON = _pywraplp.MPSolverParameters_INCREMENTALITY_ON
930    r"""
931    Reuse results from previous solve as much as the underlying solver
932    allows.
933    """
934    SCALING_OFF = _pywraplp.MPSolverParameters_SCALING_OFF
935    r""" Scaling is off."""
936    SCALING_ON = _pywraplp.MPSolverParameters_SCALING_ON
937    r""" Scaling is on."""
938
939    def __init__(self):
940        r""" The constructor sets all parameters to their default value."""
941        _pywraplp.MPSolverParameters_swiginit(self, _pywraplp.new_MPSolverParameters())
942
943    def SetDoubleParam(self, param, value):
944        r""" Sets a double parameter to a specific value."""
945        return _pywraplp.MPSolverParameters_SetDoubleParam(self, param, value)
946
947    def SetIntegerParam(self, param, value):
948        r""" Sets a integer parameter to a specific value."""
949        return _pywraplp.MPSolverParameters_SetIntegerParam(self, param, value)
950
951    def GetDoubleParam(self, param):
952        r""" Returns the value of a double parameter."""
953        return _pywraplp.MPSolverParameters_GetDoubleParam(self, param)
954
955    def GetIntegerParam(self, param):
956        r""" Returns the value of an integer parameter."""
957        return _pywraplp.MPSolverParameters_GetIntegerParam(self, param)
958    __swig_destroy__ = _pywraplp.delete_MPSolverParameters
959
960# Register MPSolverParameters in _pywraplp:
961_pywraplp.MPSolverParameters_swigregister(MPSolverParameters)
962cvar = _pywraplp.cvar
963MPSolverParameters.kDefaultRelativeMipGap = _pywraplp.cvar.MPSolverParameters_kDefaultRelativeMipGap
964MPSolverParameters.kDefaultPrimalTolerance = _pywraplp.cvar.MPSolverParameters_kDefaultPrimalTolerance
965MPSolverParameters.kDefaultDualTolerance = _pywraplp.cvar.MPSolverParameters_kDefaultDualTolerance
966MPSolverParameters.kDefaultPresolve = _pywraplp.cvar.MPSolverParameters_kDefaultPresolve
967MPSolverParameters.kDefaultIncrementality = _pywraplp.cvar.MPSolverParameters_kDefaultIncrementality
968
969class ModelExportOptions(object):
970    r""" Export options."""
971
972    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
973    __repr__ = _swig_repr
974
975    def __init__(self):
976        _pywraplp.ModelExportOptions_swiginit(self, _pywraplp.new_ModelExportOptions())
977    __swig_destroy__ = _pywraplp.delete_ModelExportOptions
978
979# Register ModelExportOptions in _pywraplp:
980_pywraplp.ModelExportOptions_swigregister(ModelExportOptions)
981
982def ExportModelAsLpFormat(*args):
983    return _pywraplp.ExportModelAsLpFormat(*args)
984
985def ExportModelAsMpsFormat(*args):
986    return _pywraplp.ExportModelAsMpsFormat(*args)
987
988def FindErrorInModelProto(input_model):
989    return _pywraplp.FindErrorInModelProto(input_model)
990
991def setup_variable_operator(opname):
992  setattr(Variable, opname,
993          lambda self, *args: getattr(VariableExpr(self), opname)(*args))
994for opname in LinearExpr.OVERRIDDEN_OPERATOR_METHODS:
995  setup_variable_operator(opname)