ortools.linear_solver.pywraplp

  1# This file was automatically generated by SWIG (https://www.swig.org).
  2# Version 4.4.0
  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 getattr(globals().get("__spec__"), "parent", None) or __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        r"""Deprecated: Use DurationSinceConstruction() instead."""
459        return _pywraplp.Solver_wall_time(self)
460
461    def LoadModelFromProto(self, input_model):
462        return _pywraplp.Solver_LoadModelFromProto(self, input_model)
463
464    def LoadModelFromProtoKeepNames(self, input_model):
465        return _pywraplp.Solver_LoadModelFromProtoKeepNames(self, input_model)
466
467    def LoadModelFromProtoWithUniqueNamesOrDie(self, input_model):
468        return _pywraplp.Solver_LoadModelFromProtoWithUniqueNamesOrDie(self, input_model)
469
470    def LoadSolutionFromProto(self, *args):
471        return _pywraplp.Solver_LoadSolutionFromProto(self, *args)
472
473    def ExportModelAsLpFormat(self, obfuscate):
474        return _pywraplp.Solver_ExportModelAsLpFormat(self, obfuscate)
475
476    def ExportModelAsMpsFormat(self, fixed_format, obfuscate):
477        return _pywraplp.Solver_ExportModelAsMpsFormat(self, fixed_format, obfuscate)
478
479    def WriteModelToMpsFile(self, filename, fixed_format, obfuscate):
480        return _pywraplp.Solver_WriteModelToMpsFile(self, filename, fixed_format, obfuscate)
481
482    def SetHint(self, variables, values):
483        r"""
484        Set a hint for solution.
485
486        If a feasible or almost-feasible solution to the problem is already known,
487        it may be helpful to pass it to the solver so that it can be used. A
488        solver that supports this feature will try to use this information to
489        create its initial feasible solution.
490
491        Note that it may not always be faster to give a hint like this to the
492        solver. There is also no guarantee that the solver will use this hint or
493        try to return a solution "close" to this assignment in case of multiple
494        optimal solutions.
495        """
496        return _pywraplp.Solver_SetHint(self, variables, values)
497
498    def SetNumThreads(self, num_theads):
499        r"""Sets the number of threads to be used by the solver."""
500        return _pywraplp.Solver_SetNumThreads(self, num_theads)
501
502    def Add(self, constraint, name=''):
503      if isinstance(constraint, bool):
504        if constraint:
505          return self.RowConstraint(0, 0, name)
506        else:
507          return self.RowConstraint(1, 1, name)
508      else:
509        return constraint.Extract(self, name)
510
511    def Sum(self, expr_array):
512      result = SumArray(expr_array)
513      return result
514
515    def RowConstraint(self, *args):
516      return self.Constraint(*args)
517
518    def Minimize(self, expr):
519      objective = self.Objective()
520      objective.Clear()
521      objective.SetMinimization()
522      if isinstance(expr, numbers.Number):
523          objective.SetOffset(expr)
524      else:
525          coeffs = expr.GetCoeffs()
526          objective.SetOffset(coeffs.pop(OFFSET_KEY, 0.0))
527          for v, c, in list(coeffs.items()):
528            objective.SetCoefficient(v, float(c))
529
530    def Maximize(self, expr):
531      objective = self.Objective()
532      objective.Clear()
533      objective.SetMaximization()
534      if isinstance(expr, numbers.Number):
535          objective.SetOffset(expr)
536      else:
537          coeffs = expr.GetCoeffs()
538          objective.SetOffset(coeffs.pop(OFFSET_KEY, 0.0))
539          for v, c, in list(coeffs.items()):
540            objective.SetCoefficient(v, float(c))
541
542
543    @staticmethod
544    def Infinity():
545        return _pywraplp.Solver_Infinity()
546
547    def SetTimeLimit(self, x):
548        return _pywraplp.Solver_SetTimeLimit(self, x)
549
550    def WallTime(self):
551        return _pywraplp.Solver_WallTime(self)
552
553    def Iterations(self):
554        return _pywraplp.Solver_Iterations(self)
555
556# Register Solver in _pywraplp:
557_pywraplp.Solver_swigregister(Solver)
558
559def __lshift__(*args):
560    return _pywraplp.__lshift__(*args)
561class Objective(object):
562    r"""A class to express a linear objective."""
563
564    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
565
566    def __init__(self, *args, **kwargs):
567        raise AttributeError("No constructor defined")
568    __repr__ = _swig_repr
569
570    def Clear(self):
571        r"""
572         Clears the offset, all variables and coefficients, and the optimization
573        direction.
574        """
575        return _pywraplp.Objective_Clear(self)
576
577    def SetCoefficient(self, var, coeff):
578        r"""
579        Sets the coefficient of the variable in the objective.
580
581        If the variable does not belong to the solver, the function just returns,
582        or crashes in non-opt mode.
583        """
584        return _pywraplp.Objective_SetCoefficient(self, var, coeff)
585
586    def GetCoefficient(self, var):
587        r"""
588         Gets the coefficient of a given variable in the objective
589
590        It returns 0 if the variable does not appear in the objective).
591        """
592        return _pywraplp.Objective_GetCoefficient(self, var)
593
594    def SetOffset(self, value):
595        r"""Sets the constant term in the objective."""
596        return _pywraplp.Objective_SetOffset(self, value)
597
598    def offset(self):
599        r"""Gets the constant term in the objective."""
600        return _pywraplp.Objective_offset(self)
601
602    def SetOptimizationDirection(self, maximize):
603        r"""Sets the optimization direction (maximize: true or minimize: false)."""
604        return _pywraplp.Objective_SetOptimizationDirection(self, maximize)
605
606    def SetMinimization(self):
607        r"""Sets the optimization direction to minimize."""
608        return _pywraplp.Objective_SetMinimization(self)
609
610    def SetMaximization(self):
611        r"""Sets the optimization direction to maximize."""
612        return _pywraplp.Objective_SetMaximization(self)
613
614    def maximization(self):
615        r"""Is the optimization direction set to maximize?"""
616        return _pywraplp.Objective_maximization(self)
617
618    def minimization(self):
619        r"""Is the optimization direction set to minimize?"""
620        return _pywraplp.Objective_minimization(self)
621
622    def Value(self):
623        r"""
624        Returns the objective value of the best solution found so far.
625
626        It is the optimal objective value if the problem has been solved to
627        optimality.
628
629        Note: the objective value may be slightly different than what you could
630        compute yourself using ``MPVariable::solution_value();`` please use the
631        --verify_solution flag to gain confidence about the numerical stability of
632        your solution.
633        """
634        return _pywraplp.Objective_Value(self)
635
636    def BestBound(self):
637        r"""
638        Returns the best objective bound.
639
640        In case of minimization, it is a lower bound on the objective value of the
641        optimal integer solution. Only available for discrete problems.
642        """
643        return _pywraplp.Objective_BestBound(self)
644
645    def Offset(self):
646        return _pywraplp.Objective_Offset(self)
647    __swig_destroy__ = _pywraplp.delete_Objective
648
649# Register Objective in _pywraplp:
650_pywraplp.Objective_swigregister(Objective)
651class Variable(object):
652    r"""The class for variables of a Mathematical Programming (MP) model."""
653
654    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
655
656    def __init__(self, *args, **kwargs):
657        raise AttributeError("No constructor defined")
658
659    def name(self):
660        r"""Returns the name of the variable."""
661        return _pywraplp.Variable_name(self)
662
663    def SetInteger(self, integer):
664        r"""Sets the integrality requirement of the variable."""
665        return _pywraplp.Variable_SetInteger(self, integer)
666
667    def integer(self):
668        r"""Returns the integrality requirement of the variable."""
669        return _pywraplp.Variable_integer(self)
670
671    def solution_value(self):
672        r"""
673        Returns the value of the variable in the current solution.
674
675        If the variable is integer, then the value will always be an integer (the
676        underlying solver handles floating-point values only, but this function
677        automatically rounds it to the nearest integer; see: man 3 round).
678        """
679        return _pywraplp.Variable_solution_value(self)
680
681    def index(self):
682        r"""Returns the index of the variable in the MPSolver::variables_."""
683        return _pywraplp.Variable_index(self)
684
685    def lb(self):
686        r"""Returns the lower bound."""
687        return _pywraplp.Variable_lb(self)
688
689    def ub(self):
690        r"""Returns the upper bound."""
691        return _pywraplp.Variable_ub(self)
692
693    def SetBounds(self, lb, ub):
694        r"""Sets both the lower and upper bounds."""
695        return _pywraplp.Variable_SetBounds(self, lb, ub)
696
697    def reduced_cost(self):
698        r"""
699        Advanced usage: returns the reduced cost of the variable in the current
700        solution (only available for continuous problems).
701        """
702        return _pywraplp.Variable_reduced_cost(self)
703
704    def basis_status(self):
705        r"""
706        Advanced usage: returns the basis status of the variable in the current
707        solution (only available for continuous problems).
708
709        See also: MPSolver::BasisStatus.
710        """
711        return _pywraplp.Variable_basis_status(self)
712
713    def branching_priority(self):
714        r"""
715        Advanced usage: Certain MIP solvers (e.g. Gurobi or SCIP) allow you to set
716        a per-variable priority for determining which variable to branch on.
717
718        A value of 0 is treated as default, and is equivalent to not setting the
719        branching priority. The solver looks first to branch on fractional
720        variables in higher priority levels. As of 2019-05, only Gurobi and SCIP
721        support setting branching priority; all other solvers will simply ignore
722        this annotation.
723        """
724        return _pywraplp.Variable_branching_priority(self)
725
726    def SetBranchingPriority(self, priority):
727        return _pywraplp.Variable_SetBranchingPriority(self, priority)
728
729    def __str__(self):
730        return _pywraplp.Variable___str__(self)
731
732    def __repr__(self):
733        return _pywraplp.Variable___repr__(self)
734
735    def __getattr__(self, name):
736      return getattr(VariableExpr(self), name)
737
738
739    def SolutionValue(self):
740        return _pywraplp.Variable_SolutionValue(self)
741
742    def Integer(self):
743        return _pywraplp.Variable_Integer(self)
744
745    def Lb(self):
746        return _pywraplp.Variable_Lb(self)
747
748    def Ub(self):
749        return _pywraplp.Variable_Ub(self)
750
751    def SetLb(self, x):
752        return _pywraplp.Variable_SetLb(self, x)
753
754    def SetUb(self, x):
755        return _pywraplp.Variable_SetUb(self, x)
756
757    def ReducedCost(self):
758        return _pywraplp.Variable_ReducedCost(self)
759    __swig_destroy__ = _pywraplp.delete_Variable
760
761# Register Variable in _pywraplp:
762_pywraplp.Variable_swigregister(Variable)
763class Constraint(object):
764    r"""
765    The class for constraints of a Mathematical Programming (MP) model.
766
767    A constraint is represented as a linear equation or inequality.
768    """
769
770    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
771
772    def __init__(self, *args, **kwargs):
773        raise AttributeError("No constructor defined")
774    __repr__ = _swig_repr
775
776    def name(self):
777        r"""Returns the name of the constraint."""
778        return _pywraplp.Constraint_name(self)
779
780    def Clear(self):
781        r"""Clears all variables and coefficients. Does not clear the bounds."""
782        return _pywraplp.Constraint_Clear(self)
783
784    def SetCoefficient(self, var, coeff):
785        r"""
786        Sets the coefficient of the variable on the constraint.
787
788        If the variable does not belong to the solver, the function just returns,
789        or crashes in non-opt mode.
790        """
791        return _pywraplp.Constraint_SetCoefficient(self, var, coeff)
792
793    def GetCoefficient(self, var):
794        r"""
795        Gets the coefficient of a given variable on the constraint (which is 0 if
796        the variable does not appear in the constraint).
797        """
798        return _pywraplp.Constraint_GetCoefficient(self, var)
799
800    def lb(self):
801        r"""Returns the lower bound."""
802        return _pywraplp.Constraint_lb(self)
803
804    def ub(self):
805        r"""Returns the upper bound."""
806        return _pywraplp.Constraint_ub(self)
807
808    def SetBounds(self, lb, ub):
809        r"""Sets both the lower and upper bounds."""
810        return _pywraplp.Constraint_SetBounds(self, lb, ub)
811
812    def set_is_lazy(self, laziness):
813        r"""
814        Advanced usage: sets the constraint "laziness".
815
816        **This is only supported for SCIP and has no effect on other
817        solvers.**
818
819        When **laziness** is true, the constraint is only considered by the Linear
820        Programming solver if its current solution violates the constraint. In this
821        case, the constraint is definitively added to the problem. This may be
822        useful in some MIP problems, and may have a dramatic impact on performance.
823
824        For more info see: http://tinyurl.com/lazy-constraints.
825        """
826        return _pywraplp.Constraint_set_is_lazy(self, laziness)
827
828    def index(self):
829        r"""Returns the index of the constraint in the MPSolver::constraints_."""
830        return _pywraplp.Constraint_index(self)
831
832    def dual_value(self):
833        r"""
834        Advanced usage: returns the dual value of the constraint in the current
835        solution (only available for continuous problems).
836        """
837        return _pywraplp.Constraint_dual_value(self)
838
839    def basis_status(self):
840        r"""
841        Advanced usage: returns the basis status of the constraint.
842
843        It is only available for continuous problems).
844
845        Note that if a constraint "linear_expression in [lb, ub]" is transformed
846        into "linear_expression + slack = 0" with slack in [-ub, -lb], then this
847        status is the same as the status of the slack variable with AT_UPPER_BOUND
848        and AT_LOWER_BOUND swapped.
849
850        See also: MPSolver::BasisStatus.
851        """
852        return _pywraplp.Constraint_basis_status(self)
853
854    def Lb(self):
855        return _pywraplp.Constraint_Lb(self)
856
857    def Ub(self):
858        return _pywraplp.Constraint_Ub(self)
859
860    def SetLb(self, x):
861        return _pywraplp.Constraint_SetLb(self, x)
862
863    def SetUb(self, x):
864        return _pywraplp.Constraint_SetUb(self, x)
865
866    def DualValue(self):
867        return _pywraplp.Constraint_DualValue(self)
868    __swig_destroy__ = _pywraplp.delete_Constraint
869
870# Register Constraint in _pywraplp:
871_pywraplp.Constraint_swigregister(Constraint)
872class MPSolverParameters(object):
873    r"""
874    This class stores parameter settings for LP and MIP solvers. Some parameters
875    are marked as advanced: do not change their values unless you know what you
876    are doing!
877
878    For developers: how to add a new parameter:
879    - Add the new Foo parameter in the DoubleParam or IntegerParam enum.
880    - If it is a categorical param, add a FooValues enum.
881    - Decide if the wrapper should define a default value for it: yes
882      if it controls the properties of the solution (example:
883      tolerances) or if it consistently improves performance, no
884      otherwise. If yes, define kDefaultFoo.
885    - Add a foo_value_ member and, if no default value is defined, a
886      foo_is_default_ member.
887    - Add code to handle Foo in Set...Param, Reset...Param,
888      Get...Param, Reset and the constructor.
889    - In class MPSolverInterface, add a virtual method SetFoo, add it
890      to SetCommonParameters or SetMIPParameters, and implement it for
891      each solver. Sometimes, parameters need to be implemented
892      differently, see for example the INCREMENTALITY implementation.
893    - Add a test in linear_solver_test.cc.
894
895    TODO(user): store the parameter values in a protocol buffer
896    instead. We need to figure out how to deal with the subtleties of
897    the default values.
898    """
899
900    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
901    __repr__ = _swig_repr
902    RELATIVE_MIP_GAP = _pywraplp.MPSolverParameters_RELATIVE_MIP_GAP
903    r"""Limit for relative MIP gap."""
904    PRIMAL_TOLERANCE = _pywraplp.MPSolverParameters_PRIMAL_TOLERANCE
905    r"""
906    Advanced usage: tolerance for primal feasibility of basic solutions.
907
908    This does not control the integer feasibility tolerance of integer
909    solutions for MIP or the tolerance used during presolve.
910    """
911    DUAL_TOLERANCE = _pywraplp.MPSolverParameters_DUAL_TOLERANCE
912    r"""Advanced usage: tolerance for dual feasibility of basic solutions."""
913    PRESOLVE = _pywraplp.MPSolverParameters_PRESOLVE
914    r"""Advanced usage: presolve mode."""
915    LP_ALGORITHM = _pywraplp.MPSolverParameters_LP_ALGORITHM
916    r"""Algorithm to solve linear programs."""
917    INCREMENTALITY = _pywraplp.MPSolverParameters_INCREMENTALITY
918    r"""Advanced usage: incrementality from one solve to the next."""
919    SCALING = _pywraplp.MPSolverParameters_SCALING
920    r"""Advanced usage: enable or disable matrix scaling."""
921    PRESOLVE_OFF = _pywraplp.MPSolverParameters_PRESOLVE_OFF
922    r"""Presolve is off."""
923    PRESOLVE_ON = _pywraplp.MPSolverParameters_PRESOLVE_ON
924    r"""Presolve is on."""
925    DUAL = _pywraplp.MPSolverParameters_DUAL
926    r"""Dual simplex."""
927    PRIMAL = _pywraplp.MPSolverParameters_PRIMAL
928    r"""Primal simplex."""
929    BARRIER = _pywraplp.MPSolverParameters_BARRIER
930    r"""Barrier algorithm."""
931    INCREMENTALITY_OFF = _pywraplp.MPSolverParameters_INCREMENTALITY_OFF
932    r"""Start solve from scratch."""
933    INCREMENTALITY_ON = _pywraplp.MPSolverParameters_INCREMENTALITY_ON
934    r"""
935    Reuse results from previous solve as much as the underlying solver
936    allows.
937    """
938    SCALING_OFF = _pywraplp.MPSolverParameters_SCALING_OFF
939    r"""Scaling is off."""
940    SCALING_ON = _pywraplp.MPSolverParameters_SCALING_ON
941    r"""Scaling is on."""
942
943    def __init__(self):
944        r"""The constructor sets all parameters to their default value."""
945        _pywraplp.MPSolverParameters_swiginit(self, _pywraplp.new_MPSolverParameters())
946
947    def SetDoubleParam(self, param, value):
948        r"""Sets a double parameter to a specific value."""
949        return _pywraplp.MPSolverParameters_SetDoubleParam(self, param, value)
950
951    def SetIntegerParam(self, param, value):
952        r"""Sets a integer parameter to a specific value."""
953        return _pywraplp.MPSolverParameters_SetIntegerParam(self, param, value)
954
955    def GetDoubleParam(self, param):
956        r"""Returns the value of a double parameter."""
957        return _pywraplp.MPSolverParameters_GetDoubleParam(self, param)
958
959    def GetIntegerParam(self, param):
960        r"""Returns the value of an integer parameter."""
961        return _pywraplp.MPSolverParameters_GetIntegerParam(self, param)
962    __swig_destroy__ = _pywraplp.delete_MPSolverParameters
963
964# Register MPSolverParameters in _pywraplp:
965_pywraplp.MPSolverParameters_swigregister(MPSolverParameters)
966cvar = _pywraplp.cvar
967MPSolverParameters.kDefaultRelativeMipGap = _pywraplp.cvar.MPSolverParameters_kDefaultRelativeMipGap
968MPSolverParameters.kDefaultPrimalTolerance = _pywraplp.cvar.MPSolverParameters_kDefaultPrimalTolerance
969MPSolverParameters.kDefaultDualTolerance = _pywraplp.cvar.MPSolverParameters_kDefaultDualTolerance
970MPSolverParameters.kDefaultPresolve = _pywraplp.cvar.MPSolverParameters_kDefaultPresolve
971MPSolverParameters.kDefaultIncrementality = _pywraplp.cvar.MPSolverParameters_kDefaultIncrementality
972
973class ModelExportOptions(object):
974    r"""Export options."""
975
976    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
977    __repr__ = _swig_repr
978
979    def __init__(self):
980        _pywraplp.ModelExportOptions_swiginit(self, _pywraplp.new_ModelExportOptions())
981    __swig_destroy__ = _pywraplp.delete_ModelExportOptions
982
983# Register ModelExportOptions in _pywraplp:
984_pywraplp.ModelExportOptions_swigregister(ModelExportOptions)
985
986def ExportModelAsLpFormat(*args):
987    return _pywraplp.ExportModelAsLpFormat(*args)
988
989def ExportModelAsMpsFormat(*args):
990    return _pywraplp.ExportModelAsMpsFormat(*args)
991
992def FindErrorInModelProto(input_model):
993    return _pywraplp.FindErrorInModelProto(input_model)
994
995def setup_variable_operator(opname):
996  setattr(Variable, opname,
997          lambda self, *args: getattr(VariableExpr(self), opname)(*args))
998for opname in LinearExpr.OVERRIDDEN_OPERATOR_METHODS:
999  setup_variable_operator(opname)