22050 lines
1.2 MiB
22050 lines
1.2 MiB
<!doctype html>
|
|
<html lang="en">
|
|
<head>
|
|
<meta charset="utf-8">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
|
|
<meta name="generator" content="pdoc 0.6.2" />
|
|
<title>pywrapcp API documentation</title>
|
|
<meta name="description" content="" />
|
|
<link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
|
|
<link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
|
|
<link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
|
|
<style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase;cursor:pointer}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
|
|
<style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
|
|
<style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
|
|
<style type="text/css">
|
|
a:link { color: #46641e; text-decoration: none}
|
|
.ident { color: #46641e }
|
|
</style>
|
|
<link rel="icon" href="https://developers.google.com/optimization/images/orLogo.png">
|
|
</head>
|
|
<body>
|
|
<main>
|
|
<article id="content">
|
|
<header>
|
|
<h1 class="title">Module <code>pywrapcp</code></h1>
|
|
</header>
|
|
<section id="section-intro">
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python"># This file was automatically generated by SWIG (http://www.swig.org).
|
|
# Version 4.0.0
|
|
#
|
|
# 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 _pywrapcp
|
|
else:
|
|
import _pywrapcp
|
|
|
|
try:
|
|
import builtins as __builtin__
|
|
except ImportError:
|
|
import __builtin__
|
|
|
|
def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
|
|
if name == "thisown":
|
|
return self.this.own(value)
|
|
if name == "this":
|
|
if type(value).__name__ == 'SwigPyObject':
|
|
self.__dict__[name] = value
|
|
return
|
|
method = class_type.__swig_setmethods__.get(name, None)
|
|
if method:
|
|
return method(self, value)
|
|
if not static:
|
|
object.__setattr__(self, name, value)
|
|
else:
|
|
raise AttributeError("You cannot add attributes to %s" % self)
|
|
|
|
|
|
def _swig_setattr(self, class_type, name, value):
|
|
return _swig_setattr_nondynamic(self, class_type, name, value, 0)
|
|
|
|
|
|
def _swig_getattr(self, class_type, name):
|
|
if name == "thisown":
|
|
return self.this.own()
|
|
method = class_type.__swig_getmethods__.get(name, None)
|
|
if method:
|
|
return method(self)
|
|
raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))
|
|
|
|
|
|
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 weakref
|
|
|
|
class DefaultPhaseParameters(object):
|
|
r""" This struct holds all parameters for the default search. DefaultPhaseParameters is only used by Solver::MakeDefaultPhase methods. Note this is for advanced users only."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
CHOOSE_MAX_SUM_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_SUM_IMPACT
|
|
CHOOSE_MAX_AVERAGE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_AVERAGE_IMPACT
|
|
CHOOSE_MAX_VALUE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_VALUE_IMPACT
|
|
SELECT_MIN_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MIN_IMPACT
|
|
SELECT_MAX_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MAX_IMPACT
|
|
NONE = _pywrapcp.DefaultPhaseParameters_NONE
|
|
NORMAL = _pywrapcp.DefaultPhaseParameters_NORMAL
|
|
VERBOSE = _pywrapcp.DefaultPhaseParameters_VERBOSE
|
|
var_selection_schema = property(_pywrapcp.DefaultPhaseParameters_var_selection_schema_get, _pywrapcp.DefaultPhaseParameters_var_selection_schema_set, doc=r""" This parameter describes how the next variable to instantiate will be chosen.""")
|
|
value_selection_schema = property(_pywrapcp.DefaultPhaseParameters_value_selection_schema_get, _pywrapcp.DefaultPhaseParameters_value_selection_schema_set, doc=r""" This parameter describes which value to select for a given var.""")
|
|
initialization_splits = property(_pywrapcp.DefaultPhaseParameters_initialization_splits_get, _pywrapcp.DefaultPhaseParameters_initialization_splits_set, doc=r""" Maximum number of intervals that the initialization of impacts will scan per variable.""")
|
|
run_all_heuristics = property(_pywrapcp.DefaultPhaseParameters_run_all_heuristics_get, _pywrapcp.DefaultPhaseParameters_run_all_heuristics_set, doc=r""" The default phase will run heuristics periodically. This parameter indicates if we should run all heuristics, or a randomly selected one.""")
|
|
heuristic_period = property(_pywrapcp.DefaultPhaseParameters_heuristic_period_get, _pywrapcp.DefaultPhaseParameters_heuristic_period_set, doc=r""" The distance in nodes between each run of the heuristics. A negative or null value will mean that we will not run heuristics at all.""")
|
|
heuristic_num_failures_limit = property(_pywrapcp.DefaultPhaseParameters_heuristic_num_failures_limit_get, _pywrapcp.DefaultPhaseParameters_heuristic_num_failures_limit_set, doc=r""" The failure limit for each heuristic that we run.""")
|
|
persistent_impact = property(_pywrapcp.DefaultPhaseParameters_persistent_impact_get, _pywrapcp.DefaultPhaseParameters_persistent_impact_set, doc=r""" Whether to keep the impact from the first search for other searches, or to recompute the impact for each new search.""")
|
|
random_seed = property(_pywrapcp.DefaultPhaseParameters_random_seed_get, _pywrapcp.DefaultPhaseParameters_random_seed_set, doc=r""" Seed used to initialize the random part in some heuristics.""")
|
|
display_level = property(_pywrapcp.DefaultPhaseParameters_display_level_get, _pywrapcp.DefaultPhaseParameters_display_level_set, doc=r""" This represents the amount of information displayed by the default search. NONE means no display, VERBOSE means extra information.""")
|
|
decision_builder = property(_pywrapcp.DefaultPhaseParameters_decision_builder_get, _pywrapcp.DefaultPhaseParameters_decision_builder_set, doc=r""" When defined, this overrides the default impact based decision builder.""")
|
|
|
|
def __init__(self):
|
|
_pywrapcp.DefaultPhaseParameters_swiginit(self, _pywrapcp.new_DefaultPhaseParameters())
|
|
__swig_destroy__ = _pywrapcp.delete_DefaultPhaseParameters
|
|
|
|
# Register DefaultPhaseParameters in _pywrapcp:
|
|
_pywrapcp.DefaultPhaseParameters_swigregister(DefaultPhaseParameters)
|
|
|
|
class Solver(object):
|
|
r""" Solver Class A solver represents the main computation engine. It implements the entire range of Constraint Programming protocols: - Reversibility - Propagation - Search Usually, Constraint Programming code consists of - the creation of the Solver, - the creation of the decision variables of the model, - the creation of the constraints of the model and their addition to the solver() through the AddConstraint() method, - the creation of the main DecisionBuilder class, - the launch of the solve() method with the decision builder. For the time being, Solver is neither MT_SAFE nor MT_HOT."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
INT_VAR_DEFAULT = _pywrapcp.Solver_INT_VAR_DEFAULT
|
|
r""" The default behavior is CHOOSE_FIRST_UNBOUND."""
|
|
INT_VAR_SIMPLE = _pywrapcp.Solver_INT_VAR_SIMPLE
|
|
r""" The simple selection is CHOOSE_FIRST_UNBOUND."""
|
|
CHOOSE_FIRST_UNBOUND = _pywrapcp.Solver_CHOOSE_FIRST_UNBOUND
|
|
r""" Select the first unbound variable. Variables are considered in the order of the vector of IntVars used to create the selector."""
|
|
CHOOSE_RANDOM = _pywrapcp.Solver_CHOOSE_RANDOM
|
|
r""" Randomly select one of the remaining unbound variables."""
|
|
CHOOSE_MIN_SIZE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MIN
|
|
r""" Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variables is the one with the lowest min value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_MIN_SIZE_HIGHEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MIN
|
|
r""" Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variable is the one with the highest min value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_MIN_SIZE_LOWEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MAX
|
|
r""" Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variables is the one with the lowest max value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_MIN_SIZE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MAX
|
|
r""" Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variable is the one with the highest max value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_LOWEST_MIN
|
|
r""" Among unbound variables, select the variable with the smallest minimal value. In case of a tie, the first one is selected, "first" defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_HIGHEST_MAX
|
|
r""" Among unbound variables, select the variable with the highest maximal value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_MIN_SIZE = _pywrapcp.Solver_CHOOSE_MIN_SIZE
|
|
r""" Among unbound variables, select the variable with the smallest size. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_MAX_SIZE = _pywrapcp.Solver_CHOOSE_MAX_SIZE
|
|
r""" Among unbound variables, select the variable with the highest size. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_MAX_REGRET_ON_MIN = _pywrapcp.Solver_CHOOSE_MAX_REGRET_ON_MIN
|
|
r""" Among unbound variables, select the variable with the largest gap between the first and the second values of the domain."""
|
|
CHOOSE_PATH = _pywrapcp.Solver_CHOOSE_PATH
|
|
r""" Selects the next unbound variable on a path, the path being defined by the variables: var[i] corresponds to the index of the next of i."""
|
|
INT_VALUE_DEFAULT = _pywrapcp.Solver_INT_VALUE_DEFAULT
|
|
r""" The default behavior is ASSIGN_MIN_VALUE."""
|
|
INT_VALUE_SIMPLE = _pywrapcp.Solver_INT_VALUE_SIMPLE
|
|
r""" The simple selection is ASSIGN_MIN_VALUE."""
|
|
ASSIGN_MIN_VALUE = _pywrapcp.Solver_ASSIGN_MIN_VALUE
|
|
r""" Selects the min value of the selected variable."""
|
|
ASSIGN_MAX_VALUE = _pywrapcp.Solver_ASSIGN_MAX_VALUE
|
|
r""" Selects the max value of the selected variable."""
|
|
ASSIGN_RANDOM_VALUE = _pywrapcp.Solver_ASSIGN_RANDOM_VALUE
|
|
r""" Selects randomly one of the possible values of the selected variable."""
|
|
ASSIGN_CENTER_VALUE = _pywrapcp.Solver_ASSIGN_CENTER_VALUE
|
|
r""" Selects the first possible value which is the closest to the center of the domain of the selected variable. The center is defined as (min + max) / 2."""
|
|
SPLIT_LOWER_HALF = _pywrapcp.Solver_SPLIT_LOWER_HALF
|
|
r""" Split the domain in two around the center, and choose the lower part first."""
|
|
SPLIT_UPPER_HALF = _pywrapcp.Solver_SPLIT_UPPER_HALF
|
|
r""" Split the domain in two around the center, and choose the lower part first."""
|
|
SEQUENCE_DEFAULT = _pywrapcp.Solver_SEQUENCE_DEFAULT
|
|
SEQUENCE_SIMPLE = _pywrapcp.Solver_SEQUENCE_SIMPLE
|
|
CHOOSE_MIN_SLACK_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_MIN_SLACK_RANK_FORWARD
|
|
CHOOSE_RANDOM_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_RANDOM_RANK_FORWARD
|
|
INTERVAL_DEFAULT = _pywrapcp.Solver_INTERVAL_DEFAULT
|
|
r""" The default is INTERVAL_SET_TIMES_FORWARD."""
|
|
INTERVAL_SIMPLE = _pywrapcp.Solver_INTERVAL_SIMPLE
|
|
r""" The simple is INTERVAL_SET_TIMES_FORWARD."""
|
|
INTERVAL_SET_TIMES_FORWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_FORWARD
|
|
r""" Selects the variable with the lowest starting time of all variables, and fixes its starting time to this lowest value."""
|
|
INTERVAL_SET_TIMES_BACKWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_BACKWARD
|
|
r""" Selects the variable with the highest ending time of all variables, and fixes the ending time to this highest values."""
|
|
TWOOPT = _pywrapcp.Solver_TWOOPT
|
|
r""" Operator which reverses a sub-chain of a path. It is called TwoOpt because it breaks two arcs on the path; resulting paths are called two-optimal. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 (where (1, 5) are first and last nodes of the path and can therefore not be moved): 1 -> [3 -> 2] -> 4 -> 5 1 -> [4 -> 3 -> 2] -> 5 1 -> 2 -> [4 -> 3] -> 5"""
|
|
OROPT = _pywrapcp.Solver_OROPT
|
|
r""" Relocate: OROPT and RELOCATE. Operator which moves a sub-chain of a path to another position; the specified chain length is the fixed length of the chains being moved. When this length is 1, the operator simply moves a node to another position. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5, for a chain length of 2 (where (1, 5) are first and last nodes of the path and can therefore not be moved): 1 -> 4 -> [2 -> 3] -> 5 1 -> [3 -> 4] -> 2 -> 5 Using Relocate with chain lengths of 1, 2 and 3 together is equivalent to the OrOpt operator on a path. The OrOpt operator is a limited version of 3Opt (breaks 3 arcs on a path)."""
|
|
RELOCATE = _pywrapcp.Solver_RELOCATE
|
|
r""" Relocate neighborhood with length of 1 (see OROPT comment)."""
|
|
EXCHANGE = _pywrapcp.Solver_EXCHANGE
|
|
r""" Operator which exchanges the positions of two nodes. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 (where (1, 5) are first and last nodes of the path and can therefore not be moved): 1 -> [3] -> [2] -> 4 -> 5 1 -> [4] -> 3 -> [2] -> 5 1 -> 2 -> [4] -> [3] -> 5"""
|
|
CROSS = _pywrapcp.Solver_CROSS
|
|
r""" Operator which cross exchanges the starting chains of 2 paths, including exchanging the whole paths. First and last nodes are not moved. Possible neighbors for the paths 1 -> 2 -> 3 -> 4 -> 5 and 6 -> 7 -> 8 (where (1, 5) and (6, 8) are first and last nodes of the paths and can therefore not be moved): 1 -> [7] -> 3 -> 4 -> 5 6 -> [2] -> 8 1 -> [7] -> 4 -> 5 6 -> [2 -> 3] -> 8 1 -> [7] -> 5 6 -> [2 -> 3 -> 4] -> 8"""
|
|
MAKEACTIVE = _pywrapcp.Solver_MAKEACTIVE
|
|
r""" Operator which inserts an inactive node into a path. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are: 1 -> [5] -> 2 -> 3 -> 4 1 -> 2 -> [5] -> 3 -> 4 1 -> 2 -> 3 -> [5] -> 4"""
|
|
MAKEINACTIVE = _pywrapcp.Solver_MAKEINACTIVE
|
|
r""" Operator which makes path nodes inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are first and last nodes of the path) are: 1 -> 3 -> 4 with 2 inactive 1 -> 2 -> 4 with 3 inactive"""
|
|
MAKECHAININACTIVE = _pywrapcp.Solver_MAKECHAININACTIVE
|
|
r""" Operator which makes a "chain" of path nodes inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are first and last nodes of the path) are: 1 -> 3 -> 4 with 2 inactive 1 -> 2 -> 4 with 3 inactive 1 -> 4 with 2 and 3 inactive"""
|
|
SWAPACTIVE = _pywrapcp.Solver_SWAPACTIVE
|
|
r""" Operator which replaces an active node by an inactive one. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are: 1 -> [5] -> 3 -> 4 with 2 inactive 1 -> 2 -> [5] -> 4 with 3 inactive"""
|
|
EXTENDEDSWAPACTIVE = _pywrapcp.Solver_EXTENDEDSWAPACTIVE
|
|
r""" Operator which makes an inactive node active and an active one inactive. It is similar to SwapActiveOperator except that it tries to insert the inactive node in all possible positions instead of just the position of the node made inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are: 1 -> [5] -> 3 -> 4 with 2 inactive 1 -> 3 -> [5] -> 4 with 2 inactive 1 -> [5] -> 2 -> 4 with 3 inactive 1 -> 2 -> [5] -> 4 with 3 inactive"""
|
|
PATHLNS = _pywrapcp.Solver_PATHLNS
|
|
r""" Operator which relaxes two sub-chains of three consecutive arcs each. Each sub-chain is defined by a start node and the next three arcs. Those six arcs are relaxed to build a new neighbor. PATHLNS explores all possible pairs of starting nodes and so defines n^2 neighbors, n being the number of nodes. Note that the two sub-chains can be part of the same path; they even may overlap."""
|
|
FULLPATHLNS = _pywrapcp.Solver_FULLPATHLNS
|
|
r""" Operator which relaxes one entire path and all inactive nodes, thus defining num_paths neighbors."""
|
|
UNACTIVELNS = _pywrapcp.Solver_UNACTIVELNS
|
|
r""" Operator which relaxes all inactive nodes and one sub-chain of six consecutive arcs. That way the path can be improved by inserting inactive nodes or swapping arcs."""
|
|
INCREMENT = _pywrapcp.Solver_INCREMENT
|
|
r""" Operator which defines one neighbor per variable. Each neighbor tries to increment by one the value of the corresponding variable. When a new solution is found the neighborhood is rebuilt from scratch, i.e., tries to increment values in the variable order. Consider for instance variables x and y. x is incremented one by one to its max, and when it is not possible to increment x anymore, y is incremented once. If this is a solution, then next neighbor tries to increment x."""
|
|
DECREMENT = _pywrapcp.Solver_DECREMENT
|
|
r""" Operator which defines a neighborhood to decrement values. The behavior is the same as INCREMENT, except values are decremented instead of incremented."""
|
|
SIMPLELNS = _pywrapcp.Solver_SIMPLELNS
|
|
r""" Operator which defines one neighbor per variable. Each neighbor relaxes one variable. When a new solution is found the neighborhood is rebuilt from scratch. Consider for instance variables x and y. First x is relaxed and the solver is looking for the best possible solution (with only x relaxed). Then y is relaxed, and the solver is looking for a new solution. If a new solution is found, then the next variable to be relaxed is x."""
|
|
GE = _pywrapcp.Solver_GE
|
|
r""" Move is accepted when the current objective value >= objective.Min."""
|
|
LE = _pywrapcp.Solver_LE
|
|
r""" Move is accepted when the current objective value <= objective.Max."""
|
|
EQ = _pywrapcp.Solver_EQ
|
|
r""" Move is accepted when the current objective value is in the interval objective.Min .. objective.Max."""
|
|
DELAYED_PRIORITY = _pywrapcp.Solver_DELAYED_PRIORITY
|
|
r""" DELAYED_PRIORITY is the lowest priority: Demons will be processed after VAR_PRIORITY and NORMAL_PRIORITY demons."""
|
|
VAR_PRIORITY = _pywrapcp.Solver_VAR_PRIORITY
|
|
r""" VAR_PRIORITY is between DELAYED_PRIORITY and NORMAL_PRIORITY."""
|
|
NORMAL_PRIORITY = _pywrapcp.Solver_NORMAL_PRIORITY
|
|
r""" NORMAL_PRIORITY is the highest priority: Demons will be processed first."""
|
|
|
|
def __init__(self, *args):
|
|
_pywrapcp.Solver_swiginit(self, _pywrapcp.new_Solver(*args))
|
|
|
|
self.__python_constraints = []
|
|
|
|
|
|
|
|
__swig_destroy__ = _pywrapcp.delete_Solver
|
|
|
|
def Parameters(self) -> "operations_research::ConstraintSolverParameters":
|
|
r""" Stored Parameters."""
|
|
return _pywrapcp.Solver_Parameters(self)
|
|
|
|
@staticmethod
|
|
def DefaultSolverParameters() -> "operations_research::ConstraintSolverParameters":
|
|
r""" Create a ConstraintSolverParameters proto with all the default values."""
|
|
return _pywrapcp.Solver_DefaultSolverParameters()
|
|
|
|
def AddConstraint(self, c: 'Constraint') -> "void":
|
|
r""" Adds the constraint 'c' to the model. After calling this method, and until there is a backtrack that undoes the addition, any assignment of variables to values must satisfy the given constraint in order to be considered feasible. There are two fairly different use cases: - the most common use case is modeling: the given constraint is really part of the problem that the user is trying to solve. In this use case, AddConstraint is called outside of search (i.e., with state() == OUTSIDE_SEARCH). Most users should only use AddConstraint in this way. In this case, the constraint will belong to the model forever: it cannot not be removed by backtracking. - a rarer use case is that 'c' is not a real constraint of the model. It may be a constraint generated by a branching decision (a constraint whose goal is to restrict the search space), a symmetry breaking constraint (a constraint that does restrict the search space, but in a way that cannot have an impact on the quality of the solutions in the subtree), or an inferred constraint that, while having no semantic value to the model (it does not restrict the set of solutions), is worth having because we believe it may strengthen the propagation. In these cases, it happens that the constraint is added during the search (i.e., with state() == IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is added during a search, it applies only to the subtree of the search tree rooted at the current node, and will be automatically removed by backtracking. This method does not take ownership of the constraint. If the constraint has been created by any factory method (Solver::MakeXXX), it will automatically be deleted. However, power users who implement their own constraints should do: solver.AddConstraint(solver.RevAlloc(new MyConstraint(...));"""
|
|
return _pywrapcp.Solver_AddConstraint(self, c)
|
|
|
|
def Solve(self, *args) -> "bool":
|
|
return _pywrapcp.Solver_Solve(self, *args)
|
|
|
|
def NewSearch(self, *args) -> "void":
|
|
return _pywrapcp.Solver_NewSearch(self, *args)
|
|
|
|
def NextSolution(self) -> "bool":
|
|
return _pywrapcp.Solver_NextSolution(self)
|
|
|
|
def RestartSearch(self) -> "void":
|
|
return _pywrapcp.Solver_RestartSearch(self)
|
|
|
|
def EndSearch(self) -> "void":
|
|
return _pywrapcp.Solver_EndSearch(self)
|
|
|
|
def SolveAndCommit(self, *args) -> "bool":
|
|
return _pywrapcp.Solver_SolveAndCommit(self, *args)
|
|
|
|
def CheckAssignment(self, solution: 'Assignment') -> "bool":
|
|
r""" Checks whether the given assignment satisfies all relevant constraints."""
|
|
return _pywrapcp.Solver_CheckAssignment(self, solution)
|
|
|
|
def CheckConstraint(self, ct: 'Constraint') -> "bool":
|
|
r""" Checks whether adding this constraint will lead to an immediate failure. It will return false if the model is already inconsistent, or if adding the constraint makes it inconsistent."""
|
|
return _pywrapcp.Solver_CheckConstraint(self, ct)
|
|
|
|
def Fail(self) -> "void":
|
|
r""" Abandon the current branch in the search tree. A backtrack will follow."""
|
|
return _pywrapcp.Solver_Fail(self)
|
|
|
|
@staticmethod
|
|
def MemoryUsage() -> "int64":
|
|
r""" Current memory usage in bytes"""
|
|
return _pywrapcp.Solver_MemoryUsage()
|
|
|
|
def WallTime(self) -> "int64":
|
|
r""" DEPRECATED: Use Now() instead. Time elapsed, in ms since the creation of the solver."""
|
|
return _pywrapcp.Solver_WallTime(self)
|
|
|
|
def Branches(self) -> "int64":
|
|
r""" The number of branches explored since the creation of the solver."""
|
|
return _pywrapcp.Solver_Branches(self)
|
|
|
|
def Solutions(self) -> "int64":
|
|
r""" The number of solutions found since the start of the search."""
|
|
return _pywrapcp.Solver_Solutions(self)
|
|
|
|
def Failures(self) -> "int64":
|
|
r""" The number of failures encountered since the creation of the solver."""
|
|
return _pywrapcp.Solver_Failures(self)
|
|
|
|
def AcceptedNeighbors(self) -> "int64":
|
|
r""" The number of accepted neighbors."""
|
|
return _pywrapcp.Solver_AcceptedNeighbors(self)
|
|
|
|
def Stamp(self) -> "uint64":
|
|
r""" The stamp indicates how many moves in the search tree we have performed. It is useful to detect if we need to update same lazy structures."""
|
|
return _pywrapcp.Solver_Stamp(self)
|
|
|
|
def FailStamp(self) -> "uint64":
|
|
r""" The fail_stamp() is incremented after each backtrack."""
|
|
return _pywrapcp.Solver_FailStamp(self)
|
|
|
|
def IntVar(self, *args) -> "operations_research::IntVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
MakeIntVar will create the best range based int var for the bounds given.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
MakeIntVar will create a variable with the given sparse domain.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
MakeIntVar will create a variable with the given sparse domain.
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
MakeIntVar will create the best range based int var for the bounds given.
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
MakeIntVar will create a variable with the given sparse domain.
|
|
|
|
|
|
|
|
|
*Overload 6:*
|
|
MakeIntVar will create a variable with the given sparse domain.
|
|
"""
|
|
return _pywrapcp.Solver_IntVar(self, *args)
|
|
|
|
def BoolVar(self, *args) -> "operations_research::IntVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
MakeBoolVar will create a variable with a {0, 1} domain.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
MakeBoolVar will create a variable with a {0, 1} domain.
|
|
"""
|
|
return _pywrapcp.Solver_BoolVar(self, *args)
|
|
|
|
def IntConst(self, *args) -> "operations_research::IntVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
IntConst will create a constant expression.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
IntConst will create a constant expression.
|
|
"""
|
|
return _pywrapcp.Solver_IntConst(self, *args)
|
|
|
|
def Sum(self, vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::IntExpr *":
|
|
r""" sum of all vars."""
|
|
return _pywrapcp.Solver_Sum(self, vars)
|
|
|
|
def ScalProd(self, *args) -> "operations_research::IntExpr *":
|
|
r"""
|
|
*Overload 1:*
|
|
scalar product
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
scalar product
|
|
"""
|
|
return _pywrapcp.Solver_ScalProd(self, *args)
|
|
|
|
def MonotonicElement(self, values: 'operations_research::Solver::IndexEvaluator1', increasing: 'bool', index: 'IntVar') -> "operations_research::IntExpr *":
|
|
r""" Function based element. The constraint takes ownership of the callback. The callback must be monotonic. It must be able to cope with any possible value in the domain of 'index' (potentially negative ones too). Furtermore, monotonicity is not checked. Thus giving a non-monotonic function, or specifying an incorrect increasing parameter will result in undefined behavior."""
|
|
return _pywrapcp.Solver_MonotonicElement(self, values, increasing, index)
|
|
|
|
def Element(self, *args) -> "operations_research::IntExpr *":
|
|
r"""
|
|
*Overload 1:*
|
|
values[index]
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
values[index]
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Function-based element. The constraint takes ownership of the callback. The callback must be able to cope with any possible value in the domain of 'index' (potentially negative ones too).
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
2D version of function-based element expression, values(expr1, expr2).
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
vars[expr]
|
|
"""
|
|
return _pywrapcp.Solver_Element(self, *args)
|
|
|
|
def IndexExpression(self, vars: 'std::vector< operations_research::IntVar * > const &', value: 'int64') -> "operations_research::IntExpr *":
|
|
r""" Returns the expression expr such that vars[expr] == value. It assumes that vars are all different."""
|
|
return _pywrapcp.Solver_IndexExpression(self, vars, value)
|
|
|
|
def Min(self, *args) -> "operations_research::IntExpr *":
|
|
r"""
|
|
*Overload 1:*
|
|
std::min(vars)
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
std::min (left, right)
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
std::min(expr, value)
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
std::min(expr, value)
|
|
"""
|
|
return _pywrapcp.Solver_Min(self, *args)
|
|
|
|
def Max(self, *args) -> "operations_research::IntExpr *":
|
|
r"""
|
|
*Overload 1:*
|
|
std::max(vars)
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
std::max(left, right)
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
std::max(expr, value)
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
std::max(expr, value)
|
|
"""
|
|
return _pywrapcp.Solver_Max(self, *args)
|
|
|
|
def ConvexPiecewiseExpr(self, expr: 'IntExpr', early_cost: 'int64', early_date: 'int64', late_date: 'int64', late_cost: 'int64') -> "operations_research::IntExpr *":
|
|
r""" Convex piecewise function."""
|
|
return _pywrapcp.Solver_ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost)
|
|
|
|
def SemiContinuousExpr(self, expr: 'IntExpr', fixed_charge: 'int64', step: 'int64') -> "operations_research::IntExpr *":
|
|
r""" Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) a >= 0 and b >= 0"""
|
|
return _pywrapcp.Solver_SemiContinuousExpr(self, expr, fixed_charge, step)
|
|
|
|
def ConditionalExpression(self, condition: 'IntVar', expr: 'IntExpr', unperformed_value: 'int64') -> "operations_research::IntExpr *":
|
|
r""" Conditional Expr condition ? expr : unperformed_value"""
|
|
return _pywrapcp.Solver_ConditionalExpression(self, condition, expr, unperformed_value)
|
|
|
|
def TrueConstraint(self) -> "operations_research::Constraint *":
|
|
r""" This constraint always succeeds."""
|
|
return _pywrapcp.Solver_TrueConstraint(self)
|
|
|
|
def FalseConstraint(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_FalseConstraint(self, *args)
|
|
|
|
def IsEqualCstCt(self, var: 'IntExpr', value: 'int64', boolvar: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" boolvar == (var == value)"""
|
|
return _pywrapcp.Solver_IsEqualCstCt(self, var, value, boolvar)
|
|
|
|
def IsEqualCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var == value)"""
|
|
return _pywrapcp.Solver_IsEqualCstVar(self, var, value)
|
|
|
|
def IsEqualCt(self, v1: 'IntExpr', v2: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (v1 == v2)"""
|
|
return _pywrapcp.Solver_IsEqualCt(self, v1, v2, b)
|
|
|
|
def IsEqualVar(self, v1: 'IntExpr', v2: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (v1 == v2)"""
|
|
return _pywrapcp.Solver_IsEqualVar(self, v1, v2)
|
|
|
|
def IsDifferentCstCt(self, var: 'IntExpr', value: 'int64', boolvar: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" boolvar == (var != value)"""
|
|
return _pywrapcp.Solver_IsDifferentCstCt(self, var, value, boolvar)
|
|
|
|
def IsDifferentCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var != value)"""
|
|
return _pywrapcp.Solver_IsDifferentCstVar(self, var, value)
|
|
|
|
def IsDifferentVar(self, v1: 'IntExpr', v2: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (v1 != v2)"""
|
|
return _pywrapcp.Solver_IsDifferentVar(self, v1, v2)
|
|
|
|
def IsDifferentCt(self, v1: 'IntExpr', v2: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (v1 != v2)"""
|
|
return _pywrapcp.Solver_IsDifferentCt(self, v1, v2, b)
|
|
|
|
def IsLessOrEqualCstCt(self, var: 'IntExpr', value: 'int64', boolvar: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" boolvar == (var <= value)"""
|
|
return _pywrapcp.Solver_IsLessOrEqualCstCt(self, var, value, boolvar)
|
|
|
|
def IsLessOrEqualCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var <= value)"""
|
|
return _pywrapcp.Solver_IsLessOrEqualCstVar(self, var, value)
|
|
|
|
def IsLessOrEqualVar(self, left: 'IntExpr', right: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (left <= right)"""
|
|
return _pywrapcp.Solver_IsLessOrEqualVar(self, left, right)
|
|
|
|
def IsLessOrEqualCt(self, left: 'IntExpr', right: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (left <= right)"""
|
|
return _pywrapcp.Solver_IsLessOrEqualCt(self, left, right, b)
|
|
|
|
def IsGreaterOrEqualCstCt(self, var: 'IntExpr', value: 'int64', boolvar: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" boolvar == (var >= value)"""
|
|
return _pywrapcp.Solver_IsGreaterOrEqualCstCt(self, var, value, boolvar)
|
|
|
|
def IsGreaterOrEqualCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var >= value)"""
|
|
return _pywrapcp.Solver_IsGreaterOrEqualCstVar(self, var, value)
|
|
|
|
def IsGreaterOrEqualVar(self, left: 'IntExpr', right: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (left >= right)"""
|
|
return _pywrapcp.Solver_IsGreaterOrEqualVar(self, left, right)
|
|
|
|
def IsGreaterOrEqualCt(self, left: 'IntExpr', right: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (left >= right)"""
|
|
return _pywrapcp.Solver_IsGreaterOrEqualCt(self, left, right, b)
|
|
|
|
def IsGreaterCstCt(self, v: 'IntExpr', c: 'int64', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (v > c)"""
|
|
return _pywrapcp.Solver_IsGreaterCstCt(self, v, c, b)
|
|
|
|
def IsGreaterCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var > value)"""
|
|
return _pywrapcp.Solver_IsGreaterCstVar(self, var, value)
|
|
|
|
def IsGreaterVar(self, left: 'IntExpr', right: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (left > right)"""
|
|
return _pywrapcp.Solver_IsGreaterVar(self, left, right)
|
|
|
|
def IsGreaterCt(self, left: 'IntExpr', right: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (left > right)"""
|
|
return _pywrapcp.Solver_IsGreaterCt(self, left, right, b)
|
|
|
|
def IsLessCstCt(self, v: 'IntExpr', c: 'int64', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (v < c)"""
|
|
return _pywrapcp.Solver_IsLessCstCt(self, v, c, b)
|
|
|
|
def IsLessCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var < value)"""
|
|
return _pywrapcp.Solver_IsLessCstVar(self, var, value)
|
|
|
|
def IsLessVar(self, left: 'IntExpr', right: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (left < right)"""
|
|
return _pywrapcp.Solver_IsLessVar(self, left, right)
|
|
|
|
def IsLessCt(self, left: 'IntExpr', right: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (left < right)"""
|
|
return _pywrapcp.Solver_IsLessCt(self, left, right, b)
|
|
|
|
def SumLessOrEqual(self, vars: 'std::vector< operations_research::IntVar * > const &', cst: 'int64') -> "operations_research::Constraint *":
|
|
r""" Variation on arrays."""
|
|
return _pywrapcp.Solver_SumLessOrEqual(self, vars, cst)
|
|
|
|
def SumGreaterOrEqual(self, vars: 'std::vector< operations_research::IntVar * > const &', cst: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_SumGreaterOrEqual(self, vars, cst)
|
|
|
|
def SumEquality(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_SumEquality(self, *args)
|
|
|
|
def ScalProdEquality(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_ScalProdEquality(self, *args)
|
|
|
|
def ScalProdGreaterOrEqual(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_ScalProdGreaterOrEqual(self, *args)
|
|
|
|
def ScalProdLessOrEqual(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_ScalProdLessOrEqual(self, *args)
|
|
|
|
def MinEquality(self, vars: 'std::vector< operations_research::IntVar * > const &', min_var: 'IntVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_MinEquality(self, vars, min_var)
|
|
|
|
def MaxEquality(self, vars: 'std::vector< operations_research::IntVar * > const &', max_var: 'IntVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_MaxEquality(self, vars, max_var)
|
|
|
|
def ElementEquality(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_ElementEquality(self, *args)
|
|
|
|
def AbsEquality(self, var: 'IntVar', abs_var: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" Creates the constraint abs(var) == abs_var."""
|
|
return _pywrapcp.Solver_AbsEquality(self, var, abs_var)
|
|
|
|
def IndexOfConstraint(self, vars: 'std::vector< operations_research::IntVar * > const &', index: 'IntVar', target: 'int64') -> "operations_research::Constraint *":
|
|
r""" This constraint is a special case of the element constraint with an array of integer variables, where the variables are all different and the index variable is constrained such that vars[index] == target."""
|
|
return _pywrapcp.Solver_IndexOfConstraint(self, vars, index, target)
|
|
|
|
def ConstraintInitialPropagateCallback(self, ct: 'Constraint') -> "operations_research::Demon *":
|
|
r""" This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct'."""
|
|
return _pywrapcp.Solver_ConstraintInitialPropagateCallback(self, ct)
|
|
|
|
def DelayedConstraintInitialPropagateCallback(self, ct: 'Constraint') -> "operations_research::Demon *":
|
|
r""" This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct' with low priority."""
|
|
return _pywrapcp.Solver_DelayedConstraintInitialPropagateCallback(self, ct)
|
|
|
|
def ClosureDemon(self, closure: 'operations_research::Solver::Closure') -> "operations_research::Demon *":
|
|
r""" Creates a demon from a closure."""
|
|
return _pywrapcp.Solver_ClosureDemon(self, closure)
|
|
|
|
def BetweenCt(self, expr: 'IntExpr', l: 'int64', u: 'int64') -> "operations_research::Constraint *":
|
|
r""" (l <= expr <= u)"""
|
|
return _pywrapcp.Solver_BetweenCt(self, expr, l, u)
|
|
|
|
def IsBetweenCt(self, expr: 'IntExpr', l: 'int64', u: 'int64', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (l <= expr <= u)"""
|
|
return _pywrapcp.Solver_IsBetweenCt(self, expr, l, u, b)
|
|
|
|
def IsBetweenVar(self, v: 'IntExpr', l: 'int64', u: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.Solver_IsBetweenVar(self, v, l, u)
|
|
|
|
def MemberCt(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_MemberCt(self, *args)
|
|
|
|
def NotMemberCt(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
expr not in set.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
expr should not be in the list of forbidden intervals [start[i]..end[i]].
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
expr should not be in the list of forbidden intervals [start[i]..end[i]].
|
|
"""
|
|
return _pywrapcp.Solver_NotMemberCt(self, *args)
|
|
|
|
def IsMemberCt(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_IsMemberCt(self, *args)
|
|
|
|
def IsMemberVar(self, *args) -> "operations_research::IntVar *":
|
|
return _pywrapcp.Solver_IsMemberVar(self, *args)
|
|
|
|
def Count(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
|{i | vars[i] == value}| == max_count
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
|{i | vars[i] == value}| == max_count
|
|
"""
|
|
return _pywrapcp.Solver_Count(self, *args)
|
|
|
|
def Distribute(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
Aggregated version of count: |{i | v[i] == values[j]}| == cards[j]
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Aggregated version of count: |{i | v[i] == values[j]}| == cards[j]
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Aggregated version of count: |{i | v[i] == j}| == cards[j]
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == j}| <= card_max[j]
|
|
|
|
|
|
|
|
|
*Overload 6:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == j}| <= card_max[j]
|
|
|
|
|
|
|
|
|
*Overload 7:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
|
|
|
|
|
|
|
|
|
*Overload 8:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
|
|
"""
|
|
return _pywrapcp.Solver_Distribute(self, *args)
|
|
|
|
def Deviation(self, vars: 'std::vector< operations_research::IntVar * > const &', deviation_var: 'IntVar', total_sum: 'int64') -> "operations_research::Constraint *":
|
|
r""" Deviation constraint: sum_i |n * vars[i] - total_sum| <= deviation_var and sum_i vars[i] == total_sum n = #vars"""
|
|
return _pywrapcp.Solver_Deviation(self, vars, deviation_var, total_sum)
|
|
|
|
def AllDifferent(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
All variables are pairwise different. This corresponds to the stronger version of the propagation algorithm.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
All variables are pairwise different. If 'stronger_propagation' is true, stronger, and potentially slower propagation will occur. This API will be deprecated in the future.
|
|
"""
|
|
return _pywrapcp.Solver_AllDifferent(self, *args)
|
|
|
|
def AllDifferentExcept(self, vars: 'std::vector< operations_research::IntVar * > const &', escape_value: 'int64') -> "operations_research::Constraint *":
|
|
r""" All variables are pairwise different, unless they are assigned to the escape value."""
|
|
return _pywrapcp.Solver_AllDifferentExcept(self, vars, escape_value)
|
|
|
|
def SortingConstraint(self, vars: 'std::vector< operations_research::IntVar * > const &', sorted: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint binding the arrays of variables "vars" and "sorted_vars": sorted_vars[0] must be equal to the minimum of all variables in vars, and so on: the value of sorted_vars[i] must be equal to the i-th value of variables invars. This constraint propagates in both directions: from "vars" to "sorted_vars" and vice-versa. Behind the scenes, this constraint maintains that: - sorted is always increasing. - whatever the values of vars, there exists a permutation that injects its values into the sorted variables. For more info, please have a look at: https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf"""
|
|
return _pywrapcp.Solver_SortingConstraint(self, vars, sorted)
|
|
|
|
def LexicalLess(self, left: 'std::vector< operations_research::IntVar * > const &', right: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" std::vector<IntVar*>* const sorted); Creates a constraint that enforces that left is lexicographically less than right."""
|
|
return _pywrapcp.Solver_LexicalLess(self, left, right)
|
|
|
|
def LexicalLessOrEqual(self, left: 'std::vector< operations_research::IntVar * > const &', right: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint that enforces that left is lexicographically less than or equal to right."""
|
|
return _pywrapcp.Solver_LexicalLessOrEqual(self, left, right)
|
|
|
|
def InversePermutationConstraint(self, left: 'std::vector< operations_research::IntVar * > const &', right: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint that enforces that 'left' and 'right' both represent permutations of [0..left.size()-1], and that 'right' is the inverse permutation of 'left', i.e. for all i in [0..left.size()-1], right[left[i]] = i."""
|
|
return _pywrapcp.Solver_InversePermutationConstraint(self, left, right)
|
|
|
|
def NullIntersect(self, first_vars: 'std::vector< operations_research::IntVar * > const &', second_vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint that states that all variables in the first vector are different from all variables in the second group. Thus the set of values in the first vector does not intersect with the set of values in the second vector."""
|
|
return _pywrapcp.Solver_NullIntersect(self, first_vars, second_vars)
|
|
|
|
def NullIntersectExcept(self, first_vars: 'std::vector< operations_research::IntVar * > const &', second_vars: 'std::vector< operations_research::IntVar * > const &', escape_value: 'int64') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint that states that all variables in the first vector are different from all variables from the second group, unless they are assigned to the escape value. Thus the set of values in the first vector minus the escape value does not intersect with the set of values in the second vector."""
|
|
return _pywrapcp.Solver_NullIntersectExcept(self, first_vars, second_vars, escape_value)
|
|
|
|
def Circuit(self, nexts: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Force the "nexts" variable to create a complete Hamiltonian path."""
|
|
return _pywrapcp.Solver_Circuit(self, nexts)
|
|
|
|
def SubCircuit(self, nexts: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Force the "nexts" variable to create a complete Hamiltonian path for those that do not loop upon themselves."""
|
|
return _pywrapcp.Solver_SubCircuit(self, nexts)
|
|
|
|
def DelayedPathCumul(self, nexts: 'std::vector< operations_research::IntVar * > const &', active: 'std::vector< operations_research::IntVar * > const &', cumuls: 'std::vector< operations_research::IntVar * > const &', transits: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Delayed version of the same constraint: propagation on the nexts variables is delayed until all constraints have propagated."""
|
|
return _pywrapcp.Solver_DelayedPathCumul(self, nexts, active, cumuls, transits)
|
|
|
|
def PathCumul(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transits[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.
|
|
"""
|
|
return _pywrapcp.Solver_PathCumul(self, *args)
|
|
|
|
def AllowedAssignments(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
This method creates a constraint where the graph of the relation between the variables is given in extension. There are 'arity' variables involved in the relation and the graph is given by a integer tuple set.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Compatibility layer for Python API.
|
|
"""
|
|
return _pywrapcp.Solver_AllowedAssignments(self, *args)
|
|
|
|
def TransitionConstraint(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_TransitionConstraint(self, *args)
|
|
|
|
def NonOverlappingBoxesConstraint(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_NonOverlappingBoxesConstraint(self, *args)
|
|
|
|
def Pack(self, vars: 'std::vector< operations_research::IntVar * > const &', number_of_bins: 'int') -> "operations_research::Pack *":
|
|
r""" This constraint packs all variables onto 'number_of_bins' variables. For any given variable, a value of 'number_of_bins' indicates that the variable is not assigned to any bin. Dimensions, i.e., cumulative constraints on this packing, can be added directly from the pack class."""
|
|
return _pywrapcp.Solver_Pack(self, vars, number_of_bins)
|
|
|
|
def FixedDurationIntervalVar(self, *args) -> "operations_research::IntervalVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates an interval var with a fixed duration. The duration must be greater than 0. If optional is true, then the interval can be performed or unperformed. If optional is false, then the interval is always performed.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a performed interval var with a fixed duration. The duration must be greater than 0.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Creates an interval var with a fixed duration, and performed_variable. The duration must be greater than 0.
|
|
"""
|
|
return _pywrapcp.Solver_FixedDurationIntervalVar(self, *args)
|
|
|
|
def FixedInterval(self, start: 'int64', duration: 'int64', name: 'std::string const &') -> "operations_research::IntervalVar *":
|
|
r""" Creates a fixed and performed interval."""
|
|
return _pywrapcp.Solver_FixedInterval(self, start, duration, name)
|
|
|
|
def IntervalVar(self, start_min: 'int64', start_max: 'int64', duration_min: 'int64', duration_max: 'int64', end_min: 'int64', end_max: 'int64', optional: 'bool', name: 'std::string const &') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var by specifying the bounds on start, duration, and end."""
|
|
return _pywrapcp.Solver_IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name)
|
|
|
|
def MirrorInterval(self, interval_var: 'IntervalVar') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var that is the mirror image of the given one, that is, the interval var obtained by reversing the axis."""
|
|
return _pywrapcp.Solver_MirrorInterval(self, interval_var)
|
|
|
|
def FixedDurationStartSyncedOnStartIntervalVar(self, interval_var: 'IntervalVar', duration: 'int64', offset: 'int64') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var with a fixed duration whose start is synchronized with the start of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable."""
|
|
return _pywrapcp.Solver_FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset)
|
|
|
|
def FixedDurationStartSyncedOnEndIntervalVar(self, interval_var: 'IntervalVar', duration: 'int64', offset: 'int64') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var with a fixed duration whose start is synchronized with the end of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable."""
|
|
return _pywrapcp.Solver_FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset)
|
|
|
|
def FixedDurationEndSyncedOnStartIntervalVar(self, interval_var: 'IntervalVar', duration: 'int64', offset: 'int64') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var with a fixed duration whose end is synchronized with the start of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable."""
|
|
return _pywrapcp.Solver_FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset)
|
|
|
|
def FixedDurationEndSyncedOnEndIntervalVar(self, interval_var: 'IntervalVar', duration: 'int64', offset: 'int64') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var with a fixed duration whose end is synchronized with the end of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable."""
|
|
return _pywrapcp.Solver_FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset)
|
|
|
|
def IntervalRelaxedMin(self, interval_var: 'IntervalVar') -> "operations_research::IntervalVar *":
|
|
r""" Creates and returns an interval variable that wraps around the given one, relaxing the min start and end. Relaxing means making unbounded when optional. If the variable is non-optional, this method returns interval_var. More precisely, such an interval variable behaves as follows: * When the underlying must be performed, the returned interval variable behaves exactly as the underlying; * When the underlying may or may not be performed, the returned interval variable behaves like the underlying, except that it is unbounded on the min side; * When the underlying cannot be performed, the returned interval variable is of duration 0 and must be performed in an interval unbounded on both sides. This is very useful to implement propagators that may only modify the start max or end max."""
|
|
return _pywrapcp.Solver_IntervalRelaxedMin(self, interval_var)
|
|
|
|
def IntervalRelaxedMax(self, interval_var: 'IntervalVar') -> "operations_research::IntervalVar *":
|
|
r""" Creates and returns an interval variable that wraps around the given one, relaxing the max start and end. Relaxing means making unbounded when optional. If the variable is non optional, this method returns interval_var. More precisely, such an interval variable behaves as follows: * When the underlying must be performed, the returned interval variable behaves exactly as the underlying; * When the underlying may or may not be performed, the returned interval variable behaves like the underlying, except that it is unbounded on the max side; * When the underlying cannot be performed, the returned interval variable is of duration 0 and must be performed in an interval unbounded on both sides. This is very useful for implementing propagators that may only modify the start min or end min."""
|
|
return _pywrapcp.Solver_IntervalRelaxedMax(self, interval_var)
|
|
|
|
def TemporalDisjunction(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
This constraint implements a temporal disjunction between two interval vars t1 and t2. 'alt' indicates which alternative was chosen (alt == 0 is equivalent to t1 before t2).
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This constraint implements a temporal disjunction between two interval vars.
|
|
"""
|
|
return _pywrapcp.Solver_TemporalDisjunction(self, *args)
|
|
|
|
def DisjunctiveConstraint(self, intervals: 'std::vector< operations_research::IntervalVar * > const &', name: 'std::string const &') -> "operations_research::DisjunctiveConstraint *":
|
|
r""" This constraint forces all interval vars into an non-overlapping sequence. Intervals with zero duration can be scheduled anywhere."""
|
|
return _pywrapcp.Solver_DisjunctiveConstraint(self, intervals, name)
|
|
|
|
def Cumulative(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
This constraint enforces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should be positive.
|
|
|
|
|
|
|
|
|
*Overload 6:*
|
|
This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should be positive.
|
|
"""
|
|
return _pywrapcp.Solver_Cumulative(self, *args)
|
|
|
|
def Cover(self, vars: 'std::vector< operations_research::IntervalVar * > const &', target_var: 'IntervalVar') -> "operations_research::Constraint *":
|
|
r""" This constraint states that the target_var is the convex hull of the intervals. If none of the interval variables is performed, then the target var is unperformed too. Also, if the target variable is unperformed, then all the intervals variables are unperformed too."""
|
|
return _pywrapcp.Solver_Cover(self, vars, target_var)
|
|
|
|
def Assignment(self, *args) -> "operations_research::Assignment *":
|
|
r"""
|
|
*Overload 1:*
|
|
This method creates an empty assignment.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This method creates an assignment which is a copy of 'a'.
|
|
"""
|
|
return _pywrapcp.Solver_Assignment(self, *args)
|
|
|
|
def FirstSolutionCollector(self, *args) -> "operations_research::SolutionCollector *":
|
|
r"""
|
|
*Overload 1:*
|
|
Collect the first solution of the search.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Collect the first solution of the search. The variables will need to be added later.
|
|
"""
|
|
return _pywrapcp.Solver_FirstSolutionCollector(self, *args)
|
|
|
|
def LastSolutionCollector(self, *args) -> "operations_research::SolutionCollector *":
|
|
r"""
|
|
*Overload 1:*
|
|
Collect the last solution of the search.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Collect the last solution of the search. The variables will need to be added later.
|
|
"""
|
|
return _pywrapcp.Solver_LastSolutionCollector(self, *args)
|
|
|
|
def BestValueSolutionCollector(self, *args) -> "operations_research::SolutionCollector *":
|
|
r"""
|
|
*Overload 1:*
|
|
Collect the solution corresponding to the optimal value of the objective of 'assignment'; if 'assignment' does not have an objective no solution is collected. This collector only collects one solution corresponding to the best objective value (the first one found).
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Collect the solution corresponding to the optimal value of the objective of 'assignment'; if 'assignment' does not have an objective no solution is collected. This collector only collects one solution corresponding to the best objective value (the first one found). The variables will need to be added later.
|
|
"""
|
|
return _pywrapcp.Solver_BestValueSolutionCollector(self, *args)
|
|
|
|
def AllSolutionCollector(self, *args) -> "operations_research::SolutionCollector *":
|
|
r"""
|
|
*Overload 1:*
|
|
Collect all solutions of the search.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Collect all solutions of the search. The variables will need to be added later.
|
|
"""
|
|
return _pywrapcp.Solver_AllSolutionCollector(self, *args)
|
|
|
|
def Minimize(self, v: 'IntVar', step: 'int64') -> "operations_research::OptimizeVar *":
|
|
r""" Creates a minimization objective."""
|
|
return _pywrapcp.Solver_Minimize(self, v, step)
|
|
|
|
def Maximize(self, v: 'IntVar', step: 'int64') -> "operations_research::OptimizeVar *":
|
|
r""" Creates a maximization objective."""
|
|
return _pywrapcp.Solver_Maximize(self, v, step)
|
|
|
|
def Optimize(self, maximize: 'bool', v: 'IntVar', step: 'int64') -> "operations_research::OptimizeVar *":
|
|
r""" Creates a objective with a given sense (true = maximization)."""
|
|
return _pywrapcp.Solver_Optimize(self, maximize, v, step)
|
|
|
|
def WeightedMinimize(self, *args) -> "operations_research::OptimizeVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a minimization weighted objective. The actual objective is scalar_prod(sub_objectives, weights).
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a minimization weighted objective. The actual objective is scalar_prod(sub_objectives, weights).
|
|
"""
|
|
return _pywrapcp.Solver_WeightedMinimize(self, *args)
|
|
|
|
def WeightedMaximize(self, *args) -> "operations_research::OptimizeVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a maximization weigthed objective.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a maximization weigthed objective.
|
|
"""
|
|
return _pywrapcp.Solver_WeightedMaximize(self, *args)
|
|
|
|
def WeightedOptimize(self, *args) -> "operations_research::OptimizeVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a weighted objective with a given sense (true = maximization).
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a weighted objective with a given sense (true = maximization).
|
|
"""
|
|
return _pywrapcp.Solver_WeightedOptimize(self, *args)
|
|
|
|
def TabuSearch(self, maximize: 'bool', v: 'IntVar', step: 'int64', vars: 'std::vector< operations_research::IntVar * > const &', keep_tenure: 'int64', forbid_tenure: 'int64', tabu_factor: 'double') -> "operations_research::SearchMonitor *":
|
|
r""" MetaHeuristics which try to get the search out of local optima. Creates a Tabu Search monitor. In the context of local search the behavior is similar to MakeOptimize(), creating an objective in a given sense. The behavior differs once a local optimum is reached: thereafter solutions which degrade the value of the objective are allowed if they are not "tabu". A solution is "tabu" if it doesn't respect the following rules: - improving the best solution found so far - variables in the "keep" list must keep their value, variables in the "forbid" list must not take the value they have in the list. Variables with new values enter the tabu lists after each new solution found and leave the lists after a given number of iterations (called tenure). Only the variables passed to the method can enter the lists. The tabu criterion is softened by the tabu factor which gives the number of "tabu" violations which is tolerated; a factor of 1 means no violations allowed; a factor of 0 means all violations are allowed."""
|
|
return _pywrapcp.Solver_TabuSearch(self, maximize, v, step, vars, keep_tenure, forbid_tenure, tabu_factor)
|
|
|
|
def SimulatedAnnealing(self, maximize: 'bool', v: 'IntVar', step: 'int64', initial_temperature: 'int64') -> "operations_research::SearchMonitor *":
|
|
r""" Creates a Simulated Annealing monitor."""
|
|
return _pywrapcp.Solver_SimulatedAnnealing(self, maximize, v, step, initial_temperature)
|
|
|
|
def LubyRestart(self, scale_factor: 'int') -> "operations_research::SearchMonitor *":
|
|
r""" This search monitor will restart the search periodically. At the iteration n, it will restart after scale_factor * Luby(n) failures where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...)."""
|
|
return _pywrapcp.Solver_LubyRestart(self, scale_factor)
|
|
|
|
def ConstantRestart(self, frequency: 'int') -> "operations_research::SearchMonitor *":
|
|
r""" This search monitor will restart the search periodically after 'frequency' failures."""
|
|
return _pywrapcp.Solver_ConstantRestart(self, frequency)
|
|
|
|
def TimeLimit(self, time_in_ms: 'int64') -> "operations_research::RegularLimit *":
|
|
r""" Creates a search limit that constrains the running time given in milliseconds."""
|
|
return _pywrapcp.Solver_TimeLimit(self, time_in_ms)
|
|
|
|
def BranchesLimit(self, branches: 'int64') -> "operations_research::RegularLimit *":
|
|
r""" Creates a search limit that constrains the number of branches explored in the search tree."""
|
|
return _pywrapcp.Solver_BranchesLimit(self, branches)
|
|
|
|
def FailuresLimit(self, failures: 'int64') -> "operations_research::RegularLimit *":
|
|
r""" Creates a search limit that constrains the number of failures that can happen when exploring the search tree."""
|
|
return _pywrapcp.Solver_FailuresLimit(self, failures)
|
|
|
|
def SolutionsLimit(self, solutions: 'int64') -> "operations_research::RegularLimit *":
|
|
r""" Creates a search limit that constrains the number of solutions found during the search."""
|
|
return _pywrapcp.Solver_SolutionsLimit(self, solutions)
|
|
|
|
def Limit(self, *args) -> "operations_research::SearchLimit *":
|
|
r"""
|
|
*Overload 1:*
|
|
Limits the search with the 'time', 'branches', 'failures' and 'solutions' limits.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Version reducing calls to wall timer by estimating number of remaining calls.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Creates a search limit which can either apply cumulatively or search-by-search.
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
Creates a search limit from its protobuf description
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
Creates a search limit that is reached when either of the underlying limit is reached. That is, the returned limit is more stringent than both argument limits.
|
|
"""
|
|
return _pywrapcp.Solver_Limit(self, *args)
|
|
|
|
def CustomLimit(self, limiter: 'std::function< bool () >') -> "operations_research::SearchLimit *":
|
|
r""" Callback-based search limit. Search stops when limiter returns true; if this happens at a leaf the corresponding solution will be rejected."""
|
|
return _pywrapcp.Solver_CustomLimit(self, limiter)
|
|
|
|
def SearchLog(self, *args) -> "operations_research::SearchMonitor *":
|
|
return _pywrapcp.Solver_SearchLog(self, *args)
|
|
|
|
def SearchTrace(self, prefix: 'std::string const &') -> "operations_research::SearchMonitor *":
|
|
r""" Creates a search monitor that will trace precisely the behavior of the search. Use this only for low level debugging."""
|
|
return _pywrapcp.Solver_SearchTrace(self, prefix)
|
|
|
|
def PrintModelVisitor(self) -> "operations_research::ModelVisitor *":
|
|
r""" Prints the model."""
|
|
return _pywrapcp.Solver_PrintModelVisitor(self)
|
|
|
|
def StatisticsModelVisitor(self) -> "operations_research::ModelVisitor *":
|
|
r""" Displays some nice statistics on the model."""
|
|
return _pywrapcp.Solver_StatisticsModelVisitor(self)
|
|
|
|
def AssignVariableValue(self, var: 'IntVar', val: 'int64') -> "operations_research::Decision *":
|
|
r""" Decisions."""
|
|
return _pywrapcp.Solver_AssignVariableValue(self, var, val)
|
|
|
|
def VariableLessOrEqualValue(self, var: 'IntVar', value: 'int64') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_VariableLessOrEqualValue(self, var, value)
|
|
|
|
def VariableGreaterOrEqualValue(self, var: 'IntVar', value: 'int64') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_VariableGreaterOrEqualValue(self, var, value)
|
|
|
|
def SplitVariableDomain(self, var: 'IntVar', val: 'int64', start_with_lower_half: 'bool') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_SplitVariableDomain(self, var, val, start_with_lower_half)
|
|
|
|
def AssignVariableValueOrFail(self, var: 'IntVar', value: 'int64') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_AssignVariableValueOrFail(self, var, value)
|
|
|
|
def AssignVariablesValues(self, vars: 'std::vector< operations_research::IntVar * > const &', values: 'std::vector< int64 > const &') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_AssignVariablesValues(self, vars, values)
|
|
|
|
def FailDecision(self) -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_FailDecision(self)
|
|
|
|
def Decision(self, apply: 'operations_research::Solver::Action', refute: 'operations_research::Solver::Action') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_Decision(self, apply, refute)
|
|
|
|
def Compose(self, dbs: 'std::vector< operations_research::DecisionBuilder * > const &') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_Compose(self, dbs)
|
|
|
|
def Try(self, dbs: 'std::vector< operations_research::DecisionBuilder * > const &') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_Try(self, dbs)
|
|
|
|
def DefaultPhase(self, *args) -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_DefaultPhase(self, *args)
|
|
|
|
def ScheduleOrPostpone(self, var: 'IntervalVar', est: 'int64', marker: 'int64 *const') -> "operations_research::Decision *":
|
|
r""" Returns a decision that tries to schedule a task at a given time. On the Apply branch, it will set that interval var as performed and set its start to 'est'. On the Refute branch, it will just update the 'marker' to 'est' + 1. This decision is used in the INTERVAL_SET_TIMES_FORWARD strategy."""
|
|
return _pywrapcp.Solver_ScheduleOrPostpone(self, var, est, marker)
|
|
|
|
def ScheduleOrExpedite(self, var: 'IntervalVar', est: 'int64', marker: 'int64 *const') -> "operations_research::Decision *":
|
|
r""" Returns a decision that tries to schedule a task at a given time. On the Apply branch, it will set that interval var as performed and set its end to 'est'. On the Refute branch, it will just update the 'marker' to 'est' - 1. This decision is used in the INTERVAL_SET_TIMES_BACKWARD strategy."""
|
|
return _pywrapcp.Solver_ScheduleOrExpedite(self, var, est, marker)
|
|
|
|
def RankFirstInterval(self, sequence: 'SequenceVar', index: 'int') -> "operations_research::Decision *":
|
|
r""" Returns a decision that tries to rank first the ith interval var in the sequence variable."""
|
|
return _pywrapcp.Solver_RankFirstInterval(self, sequence, index)
|
|
|
|
def RankLastInterval(self, sequence: 'SequenceVar', index: 'int') -> "operations_research::Decision *":
|
|
r""" Returns a decision that tries to rank last the ith interval var in the sequence variable."""
|
|
return _pywrapcp.Solver_RankLastInterval(self, sequence, index)
|
|
|
|
def Phase(self, *args) -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_Phase(self, *args)
|
|
|
|
def DecisionBuilderFromAssignment(self, assignment: 'Assignment', db: 'DecisionBuilder', vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::DecisionBuilder *":
|
|
r""" Returns a decision builder for which the left-most leaf corresponds to assignment, the rest of the tree being explored using 'db'."""
|
|
return _pywrapcp.Solver_DecisionBuilderFromAssignment(self, assignment, db, vars)
|
|
|
|
def ConstraintAdder(self, ct: 'Constraint') -> "operations_research::DecisionBuilder *":
|
|
r""" Returns a decision builder that will add the given constraint to the model."""
|
|
return _pywrapcp.Solver_ConstraintAdder(self, ct)
|
|
|
|
def SolveOnce(self, db: 'DecisionBuilder', monitors: 'std::vector< operations_research::SearchMonitor * > const &') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_SolveOnce(self, db, monitors)
|
|
|
|
def NestedOptimize(self, *args) -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_NestedOptimize(self, *args)
|
|
|
|
def RestoreAssignment(self, assignment: 'Assignment') -> "operations_research::DecisionBuilder *":
|
|
r""" Returns a DecisionBuilder which restores an Assignment (calls void Assignment::Restore())"""
|
|
return _pywrapcp.Solver_RestoreAssignment(self, assignment)
|
|
|
|
def StoreAssignment(self, assignment: 'Assignment') -> "operations_research::DecisionBuilder *":
|
|
r""" Returns a DecisionBuilder which stores an Assignment (calls void Assignment::Store())"""
|
|
return _pywrapcp.Solver_StoreAssignment(self, assignment)
|
|
|
|
def Operator(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
return _pywrapcp.Solver_Operator(self, *args)
|
|
|
|
def RandomLnsOperator(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
return _pywrapcp.Solver_RandomLnsOperator(self, *args)
|
|
|
|
def MoveTowardTargetOperator(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a local search operator that tries to move the assignment of some variables toward a target. The target is given as an Assignment. This operator generates neighbors in which the only difference compared to the current state is that one variable that belongs to the target assignment is set to its target value.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a local search operator that tries to move the assignment of some variables toward a target. The target is given either as two vectors: a vector of variables and a vector of associated target values. The two vectors should be of the same length. This operator generates neighbors in which the only difference compared to the current state is that one variable that belongs to the given vector is set to its target value.
|
|
"""
|
|
return _pywrapcp.Solver_MoveTowardTargetOperator(self, *args)
|
|
|
|
def ConcatenateOperators(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
return _pywrapcp.Solver_ConcatenateOperators(self, *args)
|
|
|
|
def RandomConcatenateOperators(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
r"""
|
|
*Overload 1:*
|
|
Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeighbor().
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeighbor(). The provided seed is used to initialize the random number generator.
|
|
"""
|
|
return _pywrapcp.Solver_RandomConcatenateOperators(self, *args)
|
|
|
|
def NeighborhoodLimit(self, op: 'LocalSearchOperator', limit: 'int64') -> "operations_research::LocalSearchOperator *":
|
|
r""" Creates a local search operator that wraps another local search operator and limits the number of neighbors explored (i.e., calls to MakeNextNeighbor from the current solution (between two calls to Start()). When this limit is reached, MakeNextNeighbor() returns false. The counter is cleared when Start() is called."""
|
|
return _pywrapcp.Solver_NeighborhoodLimit(self, op, limit)
|
|
|
|
def LocalSearchPhase(self, *args) -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_LocalSearchPhase(self, *args)
|
|
|
|
def LocalSearchPhaseParameters(self, *args) -> "operations_research::LocalSearchPhaseParameters *":
|
|
return _pywrapcp.Solver_LocalSearchPhaseParameters(self, *args)
|
|
|
|
def SearchDepth(self) -> "int":
|
|
r""" Gets the search depth of the current active search. Returns -1 if there is no active search opened."""
|
|
return _pywrapcp.Solver_SearchDepth(self)
|
|
|
|
def SearchLeftDepth(self) -> "int":
|
|
r""" Gets the search left depth of the current active search. Returns -1 if there is no active search opened."""
|
|
return _pywrapcp.Solver_SearchLeftDepth(self)
|
|
|
|
def SolveDepth(self) -> "int":
|
|
r""" Gets the number of nested searches. It returns 0 outside search, 1 during the top level search, 2 or more in case of nested searches."""
|
|
return _pywrapcp.Solver_SolveDepth(self)
|
|
|
|
def Rand64(self, size: 'int64') -> "int64":
|
|
r""" Returns a random value between 0 and 'size' - 1;"""
|
|
return _pywrapcp.Solver_Rand64(self, size)
|
|
|
|
def Rand32(self, size: 'int32') -> "int32":
|
|
r""" Returns a random value between 0 and 'size' - 1;"""
|
|
return _pywrapcp.Solver_Rand32(self, size)
|
|
|
|
def ReSeed(self, seed: 'int32') -> "void":
|
|
r""" Reseed the solver random generator."""
|
|
return _pywrapcp.Solver_ReSeed(self, seed)
|
|
|
|
def LocalSearchProfile(self) -> "std::string":
|
|
r""" Returns local search profiling information in a human readable format. search profiles."""
|
|
return _pywrapcp.Solver_LocalSearchProfile(self)
|
|
|
|
def Constraints(self) -> "int":
|
|
r""" Counts the number of constraints that have been added to the solver before the search."""
|
|
return _pywrapcp.Solver_Constraints(self)
|
|
|
|
def Accept(self, visitor: 'operations_research::ModelVisitor *const') -> "void":
|
|
r""" Accepts the given model visitor."""
|
|
return _pywrapcp.Solver_Accept(self, visitor)
|
|
|
|
def FinishCurrentSearch(self) -> "void":
|
|
r""" Tells the solver to kill or restart the current search."""
|
|
return _pywrapcp.Solver_FinishCurrentSearch(self)
|
|
|
|
def RestartCurrentSearch(self) -> "void":
|
|
return _pywrapcp.Solver_RestartCurrentSearch(self)
|
|
|
|
def ShouldFail(self) -> "void":
|
|
r""" These methods are only useful for the SWIG wrappers, which need a way to externally cause the Solver to fail."""
|
|
return _pywrapcp.Solver_ShouldFail(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.Solver___str__(self)
|
|
|
|
def Add(self, ct):
|
|
if isinstance(ct, PyConstraint):
|
|
self.__python_constraints.append(ct)
|
|
self.AddConstraint(ct)
|
|
|
|
|
|
def TreeNoCycle(self, nexts: 'std::vector< operations_research::IntVar * > const &', active: 'std::vector< operations_research::IntVar * > const &', callback: 'operations_research::Solver::IndexFilter1'=0) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_TreeNoCycle(self, nexts, active, callback)
|
|
|
|
def SearchLogWithCallback(self, period: 'int', callback: 'std::function< std::string () >') -> "operations_research::SearchMonitor *":
|
|
return _pywrapcp.Solver_SearchLogWithCallback(self, period, callback)
|
|
|
|
def ElementFunction(self, values: 'std::function< int64 (int64) >', index: 'IntVar') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Solver_ElementFunction(self, values, index)
|
|
|
|
def VarEvalValStrPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_evaluator: 'std::function< int64 (int64) >', val_str: 'operations_research::Solver::IntValueStrategy') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarEvalValStrPhase(self, vars, var_evaluator, val_str)
|
|
|
|
def VarStrValEvalPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_str: 'operations_research::Solver::IntVarStrategy', val_eval: 'operations_research::Solver::IndexEvaluator2') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarStrValEvalPhase(self, vars, var_str, val_eval)
|
|
|
|
def VarEvalValEvalPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_eval: 'std::function< int64 (int64) >', val_eval: 'operations_research::Solver::IndexEvaluator2') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarEvalValEvalPhase(self, vars, var_eval, val_eval)
|
|
|
|
def VarStrValEvalTieBreakPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_str: 'operations_research::Solver::IntVarStrategy', val_eval: 'operations_research::Solver::IndexEvaluator2', tie_breaker: 'std::function< int64 (int64) >') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker)
|
|
|
|
def VarEvalValEvalTieBreakPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_eval: 'std::function< int64 (int64) >', val_eval: 'operations_research::Solver::IndexEvaluator2', tie_breaker: 'std::function< int64 (int64) >') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker)
|
|
|
|
def EvalEvalStrPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', evaluator: 'operations_research::Solver::IndexEvaluator2', str: 'operations_research::Solver::EvaluatorStrategy') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_EvalEvalStrPhase(self, vars, evaluator, str)
|
|
|
|
def EvalEvalStrTieBreakPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', evaluator: 'operations_research::Solver::IndexEvaluator2', tie_breaker: 'operations_research::Solver::IndexEvaluator1', str: 'operations_research::Solver::EvaluatorStrategy') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str)
|
|
|
|
def GuidedLocalSearch(self, *args) -> "operations_research::SearchMonitor *":
|
|
return _pywrapcp.Solver_GuidedLocalSearch(self, *args)
|
|
|
|
def SumObjectiveFilter(self, vars: 'std::vector< operations_research::IntVar * > const &', values: 'operations_research::Solver::IndexEvaluator2', objective: 'IntVar', filter_enum: 'operations_research::Solver::LocalSearchFilterBound') -> "operations_research::LocalSearchFilter *":
|
|
return _pywrapcp.Solver_SumObjectiveFilter(self, vars, values, objective, filter_enum)
|
|
|
|
# Register Solver in _pywrapcp:
|
|
_pywrapcp.Solver_swigregister(Solver)
|
|
|
|
def Solver_DefaultSolverParameters() -> "operations_research::ConstraintSolverParameters":
|
|
r""" Create a ConstraintSolverParameters proto with all the default values."""
|
|
return _pywrapcp.Solver_DefaultSolverParameters()
|
|
|
|
def Solver_MemoryUsage() -> "int64":
|
|
r""" Current memory usage in bytes"""
|
|
return _pywrapcp.Solver_MemoryUsage()
|
|
|
|
class BaseObject(object):
|
|
r""" A BaseObject is the root of all reversibly allocated objects. A DebugString method and the associated << operator are implemented as a convenience."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
|
|
def __init__(self):
|
|
if self.__class__ == BaseObject:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.BaseObject_swiginit(self, _pywrapcp.new_BaseObject(_self, ))
|
|
__swig_destroy__ = _pywrapcp.delete_BaseObject
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.BaseObject_DebugString(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.BaseObject___str__(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.BaseObject___repr__(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_BaseObject(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register BaseObject in _pywrapcp:
|
|
_pywrapcp.BaseObject_swigregister(BaseObject)
|
|
|
|
class PropagationBaseObject(BaseObject):
|
|
r""" NOLINT The PropagationBaseObject is a subclass of BaseObject that is also friend to the Solver class. It allows accessing methods useful when writing new constraints or new expressions."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, s: 'Solver'):
|
|
if self.__class__ == PropagationBaseObject:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.PropagationBaseObject_swiginit(self, _pywrapcp.new_PropagationBaseObject(_self, s))
|
|
__swig_destroy__ = _pywrapcp.delete_PropagationBaseObject
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.PropagationBaseObject_DebugString(self)
|
|
|
|
def solver(self) -> "operations_research::Solver *":
|
|
return _pywrapcp.PropagationBaseObject_solver(self)
|
|
|
|
def Name(self) -> "std::string":
|
|
r""" Object naming."""
|
|
return _pywrapcp.PropagationBaseObject_Name(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_PropagationBaseObject(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register PropagationBaseObject in _pywrapcp:
|
|
_pywrapcp.PropagationBaseObject_swigregister(PropagationBaseObject)
|
|
|
|
class Decision(BaseObject):
|
|
r""" A Decision represents a choice point in the search tree. The two main methods are Apply() to go left, or Refute() to go right."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
|
|
def __init__(self):
|
|
if self.__class__ == Decision:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.Decision_swiginit(self, _pywrapcp.new_Decision(_self, ))
|
|
__swig_destroy__ = _pywrapcp.delete_Decision
|
|
|
|
def ApplyWrapper(self, s: 'Solver') -> "void":
|
|
r""" Apply will be called first when the decision is executed."""
|
|
return _pywrapcp.Decision_ApplyWrapper(self, s)
|
|
|
|
def RefuteWrapper(self, s: 'Solver') -> "void":
|
|
r""" Refute will be called after a backtrack."""
|
|
return _pywrapcp.Decision_RefuteWrapper(self, s)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Decision_DebugString(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.Decision___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.Decision___str__(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_Decision(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register Decision in _pywrapcp:
|
|
_pywrapcp.Decision_swigregister(Decision)
|
|
|
|
class DecisionBuilder(BaseObject):
|
|
r""" A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
|
|
def __init__(self):
|
|
if self.__class__ == DecisionBuilder:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.DecisionBuilder_swiginit(self, _pywrapcp.new_DecisionBuilder(_self, ))
|
|
__swig_destroy__ = _pywrapcp.delete_DecisionBuilder
|
|
|
|
def NextWrapper(self, s: 'Solver') -> "operations_research::Decision *":
|
|
r""" This is the main method of the decision builder class. It must return a decision (an instance of the class Decision). If it returns nullptr, this means that the decision builder has finished its work."""
|
|
return _pywrapcp.DecisionBuilder_NextWrapper(self, s)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.DecisionBuilder_DebugString(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.DecisionBuilder___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.DecisionBuilder___str__(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_DecisionBuilder(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register DecisionBuilder in _pywrapcp:
|
|
_pywrapcp.DecisionBuilder_swigregister(DecisionBuilder)
|
|
|
|
class Demon(BaseObject):
|
|
r""" A Demon is the base element of a propagation queue. It is the main object responsible for implementing the actual propagation of the constraint and pruning the inconsistent values in the domains of the variables. The main concept is that demons are listeners that are attached to the variables and listen to their modifications. There are two methods: - Run() is the actual method called when the demon is processed. - priority() returns its priority. Standard priorities are slow, normal or fast. "immediate" is reserved for variables and is treated separately."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self):
|
|
r""" This indicates the priority of a demon. Immediate demons are treated separately and corresponds to variables."""
|
|
if self.__class__ == Demon:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.Demon_swiginit(self, _pywrapcp.new_Demon(_self, ))
|
|
__swig_destroy__ = _pywrapcp.delete_Demon
|
|
|
|
def RunWrapper(self, s: 'Solver') -> "void":
|
|
r""" This is the main callback of the demon."""
|
|
return _pywrapcp.Demon_RunWrapper(self, s)
|
|
|
|
def Priority(self) -> "operations_research::Solver::DemonPriority":
|
|
r""" This method returns the priority of the demon. Usually a demon is fast, slow or normal. Immediate demons are reserved for internal use to maintain variables."""
|
|
return _pywrapcp.Demon_Priority(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Demon_DebugString(self)
|
|
|
|
def Inhibit(self, s: 'Solver') -> "void":
|
|
r""" This method inhibits the demon in the search tree below the current position."""
|
|
return _pywrapcp.Demon_Inhibit(self, s)
|
|
|
|
def Desinhibit(self, s: 'Solver') -> "void":
|
|
r""" This method un-inhibits the demon that was previously inhibited."""
|
|
return _pywrapcp.Demon_Desinhibit(self, s)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_Demon(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register Demon in _pywrapcp:
|
|
_pywrapcp.Demon_swigregister(Demon)
|
|
|
|
class Constraint(PropagationBaseObject):
|
|
r""" A constraint is the main modeling object. It provides two methods: - Post() is responsible for creating the demons and attaching them to immediate demons(). - InitialPropagate() is called once just after Post and performs the initial propagation. The subsequent propagations will be performed by the demons Posted during the post() method."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
|
|
def __init__(self, solver: 'Solver'):
|
|
if self.__class__ == Constraint:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.Constraint_swiginit(self, _pywrapcp.new_Constraint(_self, solver))
|
|
__swig_destroy__ = _pywrapcp.delete_Constraint
|
|
|
|
def Post(self) -> "void":
|
|
r""" This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables."""
|
|
return _pywrapcp.Constraint_Post(self)
|
|
|
|
def InitialPropagateWrapper(self) -> "void":
|
|
r""" This method performs the initial propagation of the constraint. It is called just after the post."""
|
|
return _pywrapcp.Constraint_InitialPropagateWrapper(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Constraint_DebugString(self)
|
|
|
|
def Var(self) -> "operations_research::IntVar *":
|
|
r""" Creates a Boolean variable representing the status of the constraint (false = constraint is violated, true = constraint is satisfied). It returns nullptr if the constraint does not support this API."""
|
|
return _pywrapcp.Constraint_Var(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.Constraint___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.Constraint___str__(self)
|
|
|
|
def __add__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___add__(self, *args)
|
|
|
|
def __radd__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___radd__(self, v)
|
|
|
|
def __sub__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___sub__(self, *args)
|
|
|
|
def __rsub__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___rsub__(self, v)
|
|
|
|
def __mul__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___mul__(self, *args)
|
|
|
|
def __rmul__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___rmul__(self, v)
|
|
|
|
def __floordiv__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___floordiv__(self, v)
|
|
|
|
def __neg__(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___neg__(self)
|
|
|
|
def __abs__(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___abs__(self)
|
|
|
|
def Square(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint_Square(self)
|
|
|
|
def __eq__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint___eq__(self, *args)
|
|
|
|
def __ne__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint___ne__(self, *args)
|
|
|
|
def __ge__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint___ge__(self, *args)
|
|
|
|
def __gt__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint___gt__(self, *args)
|
|
|
|
def __le__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint___le__(self, *args)
|
|
|
|
def __lt__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint___lt__(self, *args)
|
|
|
|
def MapTo(self, vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint_MapTo(self, vars)
|
|
|
|
def IndexOf(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint_IndexOf(self, *args)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_Constraint(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register Constraint in _pywrapcp:
|
|
_pywrapcp.Constraint_swigregister(Constraint)
|
|
|
|
class SearchMonitor(BaseObject):
|
|
r""" A search monitor is a simple set of callbacks to monitor all search events"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
|
|
def __init__(self, s: 'Solver'):
|
|
if self.__class__ == SearchMonitor:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.SearchMonitor_swiginit(self, _pywrapcp.new_SearchMonitor(_self, s))
|
|
__swig_destroy__ = _pywrapcp.delete_SearchMonitor
|
|
|
|
def EnterSearch(self) -> "void":
|
|
r""" Beginning of the search."""
|
|
return _pywrapcp.SearchMonitor_EnterSearch(self)
|
|
|
|
def RestartSearch(self) -> "void":
|
|
r""" Restart the search."""
|
|
return _pywrapcp.SearchMonitor_RestartSearch(self)
|
|
|
|
def ExitSearch(self) -> "void":
|
|
r""" End of the search."""
|
|
return _pywrapcp.SearchMonitor_ExitSearch(self)
|
|
|
|
def BeginNextDecision(self, b: 'DecisionBuilder') -> "void":
|
|
r""" Before calling DecisionBuilder::Next."""
|
|
return _pywrapcp.SearchMonitor_BeginNextDecision(self, b)
|
|
|
|
def EndNextDecision(self, b: 'DecisionBuilder', d: 'Decision') -> "void":
|
|
r""" After calling DecisionBuilder::Next, along with the returned decision."""
|
|
return _pywrapcp.SearchMonitor_EndNextDecision(self, b, d)
|
|
|
|
def ApplyDecision(self, d: 'Decision') -> "void":
|
|
r""" Before applying the decision."""
|
|
return _pywrapcp.SearchMonitor_ApplyDecision(self, d)
|
|
|
|
def RefuteDecision(self, d: 'Decision') -> "void":
|
|
r""" Before refuting the decision."""
|
|
return _pywrapcp.SearchMonitor_RefuteDecision(self, d)
|
|
|
|
def AfterDecision(self, d: 'Decision', apply: 'bool') -> "void":
|
|
r""" Just after refuting or applying the decision, apply is true after Apply. This is called only if the Apply() or Refute() methods have not failed."""
|
|
return _pywrapcp.SearchMonitor_AfterDecision(self, d, apply)
|
|
|
|
def BeginFail(self) -> "void":
|
|
r""" Just when the failure occurs."""
|
|
return _pywrapcp.SearchMonitor_BeginFail(self)
|
|
|
|
def EndFail(self) -> "void":
|
|
r""" After completing the backtrack."""
|
|
return _pywrapcp.SearchMonitor_EndFail(self)
|
|
|
|
def BeginInitialPropagation(self) -> "void":
|
|
r""" Before the initial propagation."""
|
|
return _pywrapcp.SearchMonitor_BeginInitialPropagation(self)
|
|
|
|
def EndInitialPropagation(self) -> "void":
|
|
r""" After the initial propagation."""
|
|
return _pywrapcp.SearchMonitor_EndInitialPropagation(self)
|
|
|
|
def AcceptSolution(self) -> "bool":
|
|
r""" This method is called when a solution is found. It asserts whether the solution is valid. A value of false indicates that the solution should be discarded."""
|
|
return _pywrapcp.SearchMonitor_AcceptSolution(self)
|
|
|
|
def AtSolution(self) -> "bool":
|
|
r""" This method is called when a valid solution is found. If the return value is true, then search will resume after. If the result is false, then search will stop there."""
|
|
return _pywrapcp.SearchMonitor_AtSolution(self)
|
|
|
|
def NoMoreSolutions(self) -> "void":
|
|
r""" When the search tree is finished."""
|
|
return _pywrapcp.SearchMonitor_NoMoreSolutions(self)
|
|
|
|
def LocalOptimum(self) -> "bool":
|
|
r""" When a local optimum is reached. If 'true' is returned, the last solution is discarded and the search proceeds with the next one."""
|
|
return _pywrapcp.SearchMonitor_LocalOptimum(self)
|
|
|
|
def AcceptDelta(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
return _pywrapcp.SearchMonitor_AcceptDelta(self, delta, deltadelta)
|
|
|
|
def AcceptNeighbor(self) -> "void":
|
|
r""" After accepting a neighbor during local search."""
|
|
return _pywrapcp.SearchMonitor_AcceptNeighbor(self)
|
|
|
|
def solver(self) -> "operations_research::Solver *":
|
|
return _pywrapcp.SearchMonitor_solver(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.SearchMonitor___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.SearchMonitor___str__(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_SearchMonitor(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register SearchMonitor in _pywrapcp:
|
|
_pywrapcp.SearchMonitor_swigregister(SearchMonitor)
|
|
|
|
class IntExpr(PropagationBaseObject):
|
|
r""" The class IntExpr is the base of all integer expressions in constraint programming. It contains the basic protocol for an expression: - setting and modifying its bound - querying if it is bound - listening to events modifying its bounds - casting it into a variable (instance of IntVar)"""
|
|
|
|
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 - class is abstract")
|
|
|
|
def Min(self) -> "int64":
|
|
return _pywrapcp.IntExpr_Min(self)
|
|
|
|
def SetMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntExpr_SetMin(self, m)
|
|
|
|
def Max(self) -> "int64":
|
|
return _pywrapcp.IntExpr_Max(self)
|
|
|
|
def SetMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntExpr_SetMax(self, m)
|
|
|
|
def SetRange(self, l: 'int64', u: 'int64') -> "void":
|
|
r""" This method sets both the min and the max of the expression."""
|
|
return _pywrapcp.IntExpr_SetRange(self, l, u)
|
|
|
|
def SetValue(self, v: 'int64') -> "void":
|
|
r""" This method sets the value of the expression."""
|
|
return _pywrapcp.IntExpr_SetValue(self, v)
|
|
|
|
def Bound(self) -> "bool":
|
|
r""" Returns true if the min and the max of the expression are equal."""
|
|
return _pywrapcp.IntExpr_Bound(self)
|
|
|
|
def IsVar(self) -> "bool":
|
|
r""" Returns true if the expression is indeed a variable."""
|
|
return _pywrapcp.IntExpr_IsVar(self)
|
|
|
|
def Var(self) -> "operations_research::IntVar *":
|
|
r""" Creates a variable from the expression."""
|
|
return _pywrapcp.IntExpr_Var(self)
|
|
|
|
def VarWithName(self, name: 'std::string const &') -> "operations_research::IntVar *":
|
|
r""" Creates a variable from the expression and set the name of the resulting var. If the expression is already a variable, then it will set the name of the expression, possibly overwriting it. This is just a shortcut to Var() followed by set_name()."""
|
|
return _pywrapcp.IntExpr_VarWithName(self, name)
|
|
|
|
def WhenRange(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
Attach a demon that will watch the min or the max of the expression.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Attach a demon that will watch the min or the max of the expression.
|
|
"""
|
|
return _pywrapcp.IntExpr_WhenRange(self, *args)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.IntExpr___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.IntExpr___str__(self)
|
|
|
|
def __add__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___add__(self, *args)
|
|
|
|
def __radd__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___radd__(self, v)
|
|
|
|
def __sub__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___sub__(self, *args)
|
|
|
|
def __rsub__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___rsub__(self, v)
|
|
|
|
def __mul__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___mul__(self, *args)
|
|
|
|
def __rmul__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___rmul__(self, v)
|
|
|
|
def __floordiv__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___floordiv__(self, *args)
|
|
|
|
def __mod__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___mod__(self, *args)
|
|
|
|
def __neg__(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___neg__(self)
|
|
|
|
def __abs__(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___abs__(self)
|
|
|
|
def Square(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr_Square(self)
|
|
|
|
def __eq__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr___eq__(self, *args)
|
|
|
|
def __ne__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr___ne__(self, *args)
|
|
|
|
def __ge__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr___ge__(self, *args)
|
|
|
|
def __gt__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr___gt__(self, *args)
|
|
|
|
def __le__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr___le__(self, *args)
|
|
|
|
def __lt__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr___lt__(self, *args)
|
|
|
|
def MapTo(self, vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr_MapTo(self, vars)
|
|
|
|
def IndexOf(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr_IndexOf(self, *args)
|
|
|
|
def IsMember(self, values: 'std::vector< int64 > const &') -> "operations_research::IntVar *":
|
|
return _pywrapcp.IntExpr_IsMember(self, values)
|
|
|
|
def Member(self, values: 'std::vector< int64 > const &') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr_Member(self, values)
|
|
|
|
def NotMember(self, starts: 'std::vector< int64 > const &', ends: 'std::vector< int64 > const &') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr_NotMember(self, starts, ends)
|
|
|
|
# Register IntExpr in _pywrapcp:
|
|
_pywrapcp.IntExpr_swigregister(IntExpr)
|
|
|
|
class IntVarIterator(BaseObject):
|
|
r""" The class Iterator has two direct subclasses. HoleIterators iterates over all holes, that is value removed between the current min and max of the variable since the last time the variable was processed in the queue. DomainIterators iterates over all elements of the variable domain. Both iterators are not robust to domain changes. Hole iterators can also report values outside the current min and max of the variable. HoleIterators should only be called from a demon attached to the variable that has created this iterator. IntVar* current_var; std::unique_ptr<IntVarIterator> it(current_var->MakeHoleIterator(false)); for (const int64 hole : InitAndGetValues(it)) { /// use the hole }"""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def Init(self) -> "void":
|
|
r""" This method must be called before each loop."""
|
|
return _pywrapcp.IntVarIterator_Init(self)
|
|
|
|
def Ok(self) -> "bool":
|
|
r""" This method indicates if we can call Value() or not."""
|
|
return _pywrapcp.IntVarIterator_Ok(self)
|
|
|
|
def Value(self) -> "int64":
|
|
r""" This method returns the current value of the iterator."""
|
|
return _pywrapcp.IntVarIterator_Value(self)
|
|
|
|
def Next(self) -> "void":
|
|
r""" This method moves the iterator to the next value."""
|
|
return _pywrapcp.IntVarIterator_Next(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
r""" Pretty Print."""
|
|
return _pywrapcp.IntVarIterator_DebugString(self)
|
|
|
|
def __iter__(self):
|
|
self.Init()
|
|
return self
|
|
|
|
def next(self):
|
|
if self.Ok():
|
|
result = self.Value()
|
|
self.Next()
|
|
return result
|
|
else:
|
|
raise StopIteration()
|
|
|
|
def __next__(self):
|
|
return self.next()
|
|
|
|
|
|
# Register IntVarIterator in _pywrapcp:
|
|
_pywrapcp.IntVarIterator_swigregister(IntVarIterator)
|
|
|
|
class IntVar(IntExpr):
|
|
r""" The class IntVar is a subset of IntExpr. In addition to the IntExpr protocol, it offers persistence, removing values from the domains, and a finer model for events."""
|
|
|
|
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 - class is abstract")
|
|
|
|
def IsVar(self) -> "bool":
|
|
return _pywrapcp.IntVar_IsVar(self)
|
|
|
|
def Var(self) -> "operations_research::IntVar *":
|
|
return _pywrapcp.IntVar_Var(self)
|
|
|
|
def Value(self) -> "int64":
|
|
r""" This method returns the value of the variable. This method checks before that the variable is bound."""
|
|
return _pywrapcp.IntVar_Value(self)
|
|
|
|
def RemoveValue(self, v: 'int64') -> "void":
|
|
r""" This method removes the value 'v' from the domain of the variable."""
|
|
return _pywrapcp.IntVar_RemoveValue(self, v)
|
|
|
|
def RemoveInterval(self, l: 'int64', u: 'int64') -> "void":
|
|
r""" This method removes the interval 'l' .. 'u' from the domain of the variable. It assumes that 'l' <= 'u'."""
|
|
return _pywrapcp.IntVar_RemoveInterval(self, l, u)
|
|
|
|
def RemoveValues(self, values: 'std::vector< int64 > const &') -> "void":
|
|
r""" This method remove the values from the domain of the variable."""
|
|
return _pywrapcp.IntVar_RemoveValues(self, values)
|
|
|
|
def SetValues(self, values: 'std::vector< int64 > const &') -> "void":
|
|
r""" This method intersects the current domain with the values in the array."""
|
|
return _pywrapcp.IntVar_SetValues(self, values)
|
|
|
|
def WhenBound(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
This method attaches a demon that will be awakened when the variable is bound.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This method attaches a closure that will be awakened when the variable is bound.
|
|
"""
|
|
return _pywrapcp.IntVar_WhenBound(self, *args)
|
|
|
|
def WhenDomain(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
This method attaches a demon that will watch any domain modification of the domain of the variable.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This method attaches a closure that will watch any domain modification of the domain of the variable.
|
|
"""
|
|
return _pywrapcp.IntVar_WhenDomain(self, *args)
|
|
|
|
def Size(self) -> "uint64":
|
|
r""" This method returns the number of values in the domain of the variable."""
|
|
return _pywrapcp.IntVar_Size(self)
|
|
|
|
def Contains(self, v: 'int64') -> "bool":
|
|
r""" This method returns whether the value 'v' is in the domain of the variable."""
|
|
return _pywrapcp.IntVar_Contains(self, v)
|
|
|
|
def HoleIteratorAux(self, reversible: 'bool') -> "operations_research::IntVarIterator *":
|
|
r""" Creates a hole iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object."""
|
|
return _pywrapcp.IntVar_HoleIteratorAux(self, reversible)
|
|
|
|
def DomainIteratorAux(self, reversible: 'bool') -> "operations_research::IntVarIterator *":
|
|
r""" Creates a domain iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object."""
|
|
return _pywrapcp.IntVar_DomainIteratorAux(self, reversible)
|
|
|
|
def OldMin(self) -> "int64":
|
|
r""" Returns the previous min."""
|
|
return _pywrapcp.IntVar_OldMin(self)
|
|
|
|
def OldMax(self) -> "int64":
|
|
r""" Returns the previous max."""
|
|
return _pywrapcp.IntVar_OldMax(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.IntVar___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.IntVar___str__(self)
|
|
|
|
def DomainIterator(self):
|
|
return iter(self.DomainIteratorAux(False))
|
|
|
|
def HoleIterator(self):
|
|
return iter(self.HoleIteratorAux(False))
|
|
|
|
|
|
# Register IntVar in _pywrapcp:
|
|
_pywrapcp.IntVar_swigregister(IntVar)
|
|
|
|
class SolutionCollector(SearchMonitor):
|
|
r""" This class is the root class of all solution collectors. It implements a basic query API to be used independently of the collector used."""
|
|
|
|
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 DebugString(self) -> "std::string":
|
|
return _pywrapcp.SolutionCollector_DebugString(self)
|
|
|
|
def Add(self, *args) -> "void":
|
|
return _pywrapcp.SolutionCollector_Add(self, *args)
|
|
|
|
def AddObjective(self, objective: 'IntVar') -> "void":
|
|
return _pywrapcp.SolutionCollector_AddObjective(self, objective)
|
|
|
|
def EnterSearch(self) -> "void":
|
|
r""" Beginning of the search."""
|
|
return _pywrapcp.SolutionCollector_EnterSearch(self)
|
|
|
|
def SolutionCount(self) -> "int":
|
|
r""" Returns how many solutions were stored during the search."""
|
|
return _pywrapcp.SolutionCollector_SolutionCount(self)
|
|
|
|
def Solution(self, n: 'int') -> "operations_research::Assignment *":
|
|
r""" Returns the nth solution."""
|
|
return _pywrapcp.SolutionCollector_Solution(self, n)
|
|
|
|
def WallTime(self, n: 'int') -> "int64":
|
|
r""" Returns the wall time in ms for the nth solution."""
|
|
return _pywrapcp.SolutionCollector_WallTime(self, n)
|
|
|
|
def Branches(self, n: 'int') -> "int64":
|
|
r""" Returns the number of branches when the nth solution was found."""
|
|
return _pywrapcp.SolutionCollector_Branches(self, n)
|
|
|
|
def Failures(self, n: 'int') -> "int64":
|
|
r""" Returns the number of failures encountered at the time of the nth solution."""
|
|
return _pywrapcp.SolutionCollector_Failures(self, n)
|
|
|
|
def ObjectiveValue(self, n: 'int') -> "int64":
|
|
r""" Returns the objective value of the nth solution."""
|
|
return _pywrapcp.SolutionCollector_ObjectiveValue(self, n)
|
|
|
|
def Value(self, n: 'int', var: 'IntVar') -> "int64":
|
|
r""" This is a shortcut to get the Value of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_Value(self, n, var)
|
|
|
|
def StartValue(self, n: 'int', var: 'IntervalVar') -> "int64":
|
|
r""" This is a shortcut to get the StartValue of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_StartValue(self, n, var)
|
|
|
|
def EndValue(self, n: 'int', var: 'IntervalVar') -> "int64":
|
|
r""" This is a shortcut to get the EndValue of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_EndValue(self, n, var)
|
|
|
|
def DurationValue(self, n: 'int', var: 'IntervalVar') -> "int64":
|
|
r""" This is a shortcut to get the DurationValue of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_DurationValue(self, n, var)
|
|
|
|
def PerformedValue(self, n: 'int', var: 'IntervalVar') -> "int64":
|
|
r""" This is a shortcut to get the PerformedValue of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_PerformedValue(self, n, var)
|
|
|
|
def ForwardSequence(self, n: 'int', var: 'SequenceVar') -> "std::vector< int > const &":
|
|
r""" This is a shortcut to get the ForwardSequence of 'var' in the nth solution. The forward sequence is the list of ranked interval variables starting from the start of the sequence."""
|
|
return _pywrapcp.SolutionCollector_ForwardSequence(self, n, var)
|
|
|
|
def BackwardSequence(self, n: 'int', var: 'SequenceVar') -> "std::vector< int > const &":
|
|
r""" This is a shortcut to get the BackwardSequence of 'var' in the nth solution. The backward sequence is the list of ranked interval variables starting from the end of the sequence."""
|
|
return _pywrapcp.SolutionCollector_BackwardSequence(self, n, var)
|
|
|
|
def Unperformed(self, n: 'int', var: 'SequenceVar') -> "std::vector< int > const &":
|
|
r""" This is a shortcut to get the list of unperformed of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_Unperformed(self, n, var)
|
|
|
|
# Register SolutionCollector in _pywrapcp:
|
|
_pywrapcp.SolutionCollector_swigregister(SolutionCollector)
|
|
|
|
class OptimizeVar(SearchMonitor):
|
|
r""" This class encapsulates an objective. It requires the direction (minimize or maximize), the variable to optimize, and the improvement step."""
|
|
|
|
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 Best(self) -> "int64":
|
|
r""" Returns the best value found during search."""
|
|
return _pywrapcp.OptimizeVar_Best(self)
|
|
|
|
def Var(self) -> "operations_research::IntVar *":
|
|
r""" Returns the variable that is optimized."""
|
|
return _pywrapcp.OptimizeVar_Var(self)
|
|
|
|
def AcceptDelta(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
r""" Internal methods."""
|
|
return _pywrapcp.OptimizeVar_AcceptDelta(self, delta, deltadelta)
|
|
|
|
def EnterSearch(self) -> "void":
|
|
return _pywrapcp.OptimizeVar_EnterSearch(self)
|
|
|
|
def BeginNextDecision(self, db: 'DecisionBuilder') -> "void":
|
|
return _pywrapcp.OptimizeVar_BeginNextDecision(self, db)
|
|
|
|
def RefuteDecision(self, d: 'Decision') -> "void":
|
|
return _pywrapcp.OptimizeVar_RefuteDecision(self, d)
|
|
|
|
def AtSolution(self) -> "bool":
|
|
return _pywrapcp.OptimizeVar_AtSolution(self)
|
|
|
|
def AcceptSolution(self) -> "bool":
|
|
return _pywrapcp.OptimizeVar_AcceptSolution(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.OptimizeVar_DebugString(self)
|
|
|
|
# Register OptimizeVar in _pywrapcp:
|
|
_pywrapcp.OptimizeVar_swigregister(OptimizeVar)
|
|
|
|
class SearchLimit(SearchMonitor):
|
|
r""" Base class of all search limits."""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_SearchLimit
|
|
|
|
def Crossed(self) -> "bool":
|
|
r""" Returns true if the limit has been crossed."""
|
|
return _pywrapcp.SearchLimit_Crossed(self)
|
|
|
|
def Check(self) -> "bool":
|
|
r""" This method is called to check the status of the limit. A return value of true indicates that we have indeed crossed the limit. In that case, this method will not be called again and the remaining search will be discarded."""
|
|
return _pywrapcp.SearchLimit_Check(self)
|
|
|
|
def Init(self) -> "void":
|
|
r""" This method is called when the search limit is initialized."""
|
|
return _pywrapcp.SearchLimit_Init(self)
|
|
|
|
def EnterSearch(self) -> "void":
|
|
r""" Internal methods."""
|
|
return _pywrapcp.SearchLimit_EnterSearch(self)
|
|
|
|
def BeginNextDecision(self, b: 'DecisionBuilder') -> "void":
|
|
return _pywrapcp.SearchLimit_BeginNextDecision(self, b)
|
|
|
|
def RefuteDecision(self, d: 'Decision') -> "void":
|
|
return _pywrapcp.SearchLimit_RefuteDecision(self, d)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.SearchLimit_DebugString(self)
|
|
|
|
# Register SearchLimit in _pywrapcp:
|
|
_pywrapcp.SearchLimit_swigregister(SearchLimit)
|
|
|
|
class IntervalVar(PropagationBaseObject):
|
|
r""" Interval variables are often used in scheduling. The main characteristics of an IntervalVar are the start position, duration, and end date. All these characteristics can be queried and set, and demons can be posted on their modifications. An important aspect is optionality: an IntervalVar can be performed or not. If unperformed, then it simply does not exist, and its characteristics cannot be accessed any more. An interval var is automatically marked as unperformed when it is not consistent anymore (start greater than end, duration < 0...)"""
|
|
|
|
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 - class is abstract")
|
|
|
|
def StartMin(self) -> "int64":
|
|
r""" These methods query, set, and watch the start position of the interval var."""
|
|
return _pywrapcp.IntervalVar_StartMin(self)
|
|
|
|
def StartMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_StartMax(self)
|
|
|
|
def SetStartMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetStartMin(self, m)
|
|
|
|
def SetStartMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetStartMax(self, m)
|
|
|
|
def SetStartRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetStartRange(self, mi, ma)
|
|
|
|
def OldStartMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldStartMin(self)
|
|
|
|
def OldStartMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldStartMax(self)
|
|
|
|
def WhenStartRange(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenStartRange(self, *args)
|
|
|
|
def WhenStartBound(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenStartBound(self, *args)
|
|
|
|
def DurationMin(self) -> "int64":
|
|
r""" These methods query, set, and watch the duration of the interval var."""
|
|
return _pywrapcp.IntervalVar_DurationMin(self)
|
|
|
|
def DurationMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_DurationMax(self)
|
|
|
|
def SetDurationMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetDurationMin(self, m)
|
|
|
|
def SetDurationMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetDurationMax(self, m)
|
|
|
|
def SetDurationRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetDurationRange(self, mi, ma)
|
|
|
|
def OldDurationMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldDurationMin(self)
|
|
|
|
def OldDurationMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldDurationMax(self)
|
|
|
|
def WhenDurationRange(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenDurationRange(self, *args)
|
|
|
|
def WhenDurationBound(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenDurationBound(self, *args)
|
|
|
|
def EndMin(self) -> "int64":
|
|
r""" These methods query, set, and watch the end position of the interval var."""
|
|
return _pywrapcp.IntervalVar_EndMin(self)
|
|
|
|
def EndMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_EndMax(self)
|
|
|
|
def SetEndMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetEndMin(self, m)
|
|
|
|
def SetEndMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetEndMax(self, m)
|
|
|
|
def SetEndRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetEndRange(self, mi, ma)
|
|
|
|
def OldEndMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldEndMin(self)
|
|
|
|
def OldEndMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldEndMax(self)
|
|
|
|
def WhenEndRange(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenEndRange(self, *args)
|
|
|
|
def WhenEndBound(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenEndBound(self, *args)
|
|
|
|
def MustBePerformed(self) -> "bool":
|
|
r""" These methods query, set, and watch the performed status of the interval var."""
|
|
return _pywrapcp.IntervalVar_MustBePerformed(self)
|
|
|
|
def MayBePerformed(self) -> "bool":
|
|
return _pywrapcp.IntervalVar_MayBePerformed(self)
|
|
|
|
def CannotBePerformed(self) -> "bool":
|
|
return _pywrapcp.IntervalVar_CannotBePerformed(self)
|
|
|
|
def IsPerformedBound(self) -> "bool":
|
|
return _pywrapcp.IntervalVar_IsPerformedBound(self)
|
|
|
|
def SetPerformed(self, val: 'bool') -> "void":
|
|
return _pywrapcp.IntervalVar_SetPerformed(self, val)
|
|
|
|
def WasPerformedBound(self) -> "bool":
|
|
return _pywrapcp.IntervalVar_WasPerformedBound(self)
|
|
|
|
def WhenPerformedBound(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenPerformedBound(self, *args)
|
|
|
|
def WhenAnything(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
Attaches a demon awakened when anything about this interval changes.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Attaches a closure awakened when anything about this interval changes.
|
|
"""
|
|
return _pywrapcp.IntervalVar_WhenAnything(self, *args)
|
|
|
|
def StartExpr(self) -> "operations_research::IntExpr *":
|
|
r""" These methods create expressions encapsulating the start, end and duration of the interval var. Please note that these must not be used if the interval var is unperformed."""
|
|
return _pywrapcp.IntervalVar_StartExpr(self)
|
|
|
|
def DurationExpr(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_DurationExpr(self)
|
|
|
|
def EndExpr(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_EndExpr(self)
|
|
|
|
def PerformedExpr(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_PerformedExpr(self)
|
|
|
|
def SafeStartExpr(self, unperformed_value: 'int64') -> "operations_research::IntExpr *":
|
|
r""" These methods create expressions encapsulating the start, end and duration of the interval var. If the interval var is unperformed, they will return the unperformed_value."""
|
|
return _pywrapcp.IntervalVar_SafeStartExpr(self, unperformed_value)
|
|
|
|
def SafeDurationExpr(self, unperformed_value: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_SafeDurationExpr(self, unperformed_value)
|
|
|
|
def SafeEndExpr(self, unperformed_value: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_SafeEndExpr(self, unperformed_value)
|
|
|
|
def EndsAfterEnd(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfterEnd(self, other)
|
|
|
|
def EndsAfterEndWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfterEndWithDelay(self, other, delay)
|
|
|
|
def EndsAfterStart(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfterStart(self, other)
|
|
|
|
def EndsAfterStartWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfterStartWithDelay(self, other, delay)
|
|
|
|
def EndsAtEnd(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAtEnd(self, other)
|
|
|
|
def EndsAtEndWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAtEndWithDelay(self, other, delay)
|
|
|
|
def EndsAtStart(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAtStart(self, other)
|
|
|
|
def EndsAtStartWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAtStartWithDelay(self, other, delay)
|
|
|
|
def StartsAfterEnd(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfterEnd(self, other)
|
|
|
|
def StartsAfterEndWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfterEndWithDelay(self, other, delay)
|
|
|
|
def StartsAfterStart(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfterStart(self, other)
|
|
|
|
def StartsAfterStartWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfterStartWithDelay(self, other, delay)
|
|
|
|
def StartsAtEnd(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAtEnd(self, other)
|
|
|
|
def StartsAtEndWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAtEndWithDelay(self, other, delay)
|
|
|
|
def StartsAtStart(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAtStart(self, other)
|
|
|
|
def StartsAtStartWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAtStartWithDelay(self, other, delay)
|
|
|
|
def StaysInSync(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StaysInSync(self, other)
|
|
|
|
def StaysInSyncWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StaysInSyncWithDelay(self, other, delay)
|
|
|
|
def EndsAfter(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfter(self, date)
|
|
|
|
def EndsAt(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAt(self, date)
|
|
|
|
def EndsBefore(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsBefore(self, date)
|
|
|
|
def StartsAfter(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfter(self, date)
|
|
|
|
def StartsAt(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAt(self, date)
|
|
|
|
def StartsBefore(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsBefore(self, date)
|
|
|
|
def CrossesDate(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_CrossesDate(self, date)
|
|
|
|
def AvoidsDate(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_AvoidsDate(self, date)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.IntervalVar___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.IntervalVar___str__(self)
|
|
|
|
# Register IntervalVar in _pywrapcp:
|
|
_pywrapcp.IntervalVar_swigregister(IntervalVar)
|
|
|
|
class SequenceVar(PropagationBaseObject):
|
|
r""" A sequence variable is a variable whose domain is a set of possible orderings of the interval variables. It allows ordering of tasks. It has two sets of methods: ComputePossibleFirstsAndLasts(), which returns the list of interval variables that can be ranked first or last; and RankFirst/RankNotFirst/RankLast/RankNotLast, which can be used to create the search decision."""
|
|
|
|
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 DebugString(self) -> "std::string":
|
|
return _pywrapcp.SequenceVar_DebugString(self)
|
|
|
|
def RankFirst(self, index: 'int') -> "void":
|
|
r""" Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked."""
|
|
return _pywrapcp.SequenceVar_RankFirst(self, index)
|
|
|
|
def RankNotFirst(self, index: 'int') -> "void":
|
|
r""" Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars."""
|
|
return _pywrapcp.SequenceVar_RankNotFirst(self, index)
|
|
|
|
def RankLast(self, index: 'int') -> "void":
|
|
r""" Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked."""
|
|
return _pywrapcp.SequenceVar_RankLast(self, index)
|
|
|
|
def RankNotLast(self, index: 'int') -> "void":
|
|
r""" Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars."""
|
|
return _pywrapcp.SequenceVar_RankNotLast(self, index)
|
|
|
|
def Interval(self, index: 'int') -> "operations_research::IntervalVar *":
|
|
r""" Returns the index_th interval of the sequence."""
|
|
return _pywrapcp.SequenceVar_Interval(self, index)
|
|
|
|
def Next(self, index: 'int') -> "operations_research::IntVar *":
|
|
r""" Returns the next of the index_th interval of the sequence."""
|
|
return _pywrapcp.SequenceVar_Next(self, index)
|
|
|
|
def Size(self) -> "int64":
|
|
r""" Returns the number of interval vars in the sequence."""
|
|
return _pywrapcp.SequenceVar_Size(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.SequenceVar___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.SequenceVar___str__(self)
|
|
|
|
# Register SequenceVar in _pywrapcp:
|
|
_pywrapcp.SequenceVar_swigregister(SequenceVar)
|
|
|
|
class AssignmentElement(object):
|
|
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 Activate(self) -> "void":
|
|
return _pywrapcp.AssignmentElement_Activate(self)
|
|
|
|
def Deactivate(self) -> "void":
|
|
return _pywrapcp.AssignmentElement_Deactivate(self)
|
|
|
|
def Activated(self) -> "bool":
|
|
return _pywrapcp.AssignmentElement_Activated(self)
|
|
__swig_destroy__ = _pywrapcp.delete_AssignmentElement
|
|
|
|
# Register AssignmentElement in _pywrapcp:
|
|
_pywrapcp.AssignmentElement_swigregister(AssignmentElement)
|
|
|
|
class IntVarElement(AssignmentElement):
|
|
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 Var(self) -> "operations_research::IntVar *":
|
|
return _pywrapcp.IntVarElement_Var(self)
|
|
|
|
def Min(self) -> "int64":
|
|
return _pywrapcp.IntVarElement_Min(self)
|
|
|
|
def SetMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntVarElement_SetMin(self, m)
|
|
|
|
def Max(self) -> "int64":
|
|
return _pywrapcp.IntVarElement_Max(self)
|
|
|
|
def SetMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntVarElement_SetMax(self, m)
|
|
|
|
def Value(self) -> "int64":
|
|
return _pywrapcp.IntVarElement_Value(self)
|
|
|
|
def Bound(self) -> "bool":
|
|
return _pywrapcp.IntVarElement_Bound(self)
|
|
|
|
def SetRange(self, l: 'int64', u: 'int64') -> "void":
|
|
return _pywrapcp.IntVarElement_SetRange(self, l, u)
|
|
|
|
def SetValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntVarElement_SetValue(self, v)
|
|
|
|
def __eq__(self, element: 'IntVarElement') -> "bool":
|
|
return _pywrapcp.IntVarElement___eq__(self, element)
|
|
|
|
def __ne__(self, element: 'IntVarElement') -> "bool":
|
|
return _pywrapcp.IntVarElement___ne__(self, element)
|
|
__swig_destroy__ = _pywrapcp.delete_IntVarElement
|
|
|
|
# Register IntVarElement in _pywrapcp:
|
|
_pywrapcp.IntVarElement_swigregister(IntVarElement)
|
|
|
|
class IntervalVarElement(AssignmentElement):
|
|
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 Var(self) -> "operations_research::IntervalVar *":
|
|
return _pywrapcp.IntervalVarElement_Var(self)
|
|
|
|
def StartMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_StartMin(self)
|
|
|
|
def StartMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_StartMax(self)
|
|
|
|
def StartValue(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_StartValue(self)
|
|
|
|
def DurationMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_DurationMin(self)
|
|
|
|
def DurationMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_DurationMax(self)
|
|
|
|
def DurationValue(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_DurationValue(self)
|
|
|
|
def EndMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_EndMin(self)
|
|
|
|
def EndMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_EndMax(self)
|
|
|
|
def EndValue(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_EndValue(self)
|
|
|
|
def PerformedMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_PerformedMin(self)
|
|
|
|
def PerformedMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_PerformedMax(self)
|
|
|
|
def PerformedValue(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_PerformedValue(self)
|
|
|
|
def SetStartMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetStartMin(self, m)
|
|
|
|
def SetStartMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetStartMax(self, m)
|
|
|
|
def SetStartRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetStartRange(self, mi, ma)
|
|
|
|
def SetStartValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetStartValue(self, v)
|
|
|
|
def SetDurationMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetDurationMin(self, m)
|
|
|
|
def SetDurationMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetDurationMax(self, m)
|
|
|
|
def SetDurationRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetDurationRange(self, mi, ma)
|
|
|
|
def SetDurationValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetDurationValue(self, v)
|
|
|
|
def SetEndMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetEndMin(self, m)
|
|
|
|
def SetEndMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetEndMax(self, m)
|
|
|
|
def SetEndRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetEndRange(self, mi, ma)
|
|
|
|
def SetEndValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetEndValue(self, v)
|
|
|
|
def SetPerformedMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetPerformedMin(self, m)
|
|
|
|
def SetPerformedMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetPerformedMax(self, m)
|
|
|
|
def SetPerformedRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetPerformedRange(self, mi, ma)
|
|
|
|
def SetPerformedValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetPerformedValue(self, v)
|
|
|
|
def __eq__(self, element: 'IntervalVarElement') -> "bool":
|
|
return _pywrapcp.IntervalVarElement___eq__(self, element)
|
|
|
|
def __ne__(self, element: 'IntervalVarElement') -> "bool":
|
|
return _pywrapcp.IntervalVarElement___ne__(self, element)
|
|
__swig_destroy__ = _pywrapcp.delete_IntervalVarElement
|
|
|
|
# Register IntervalVarElement in _pywrapcp:
|
|
_pywrapcp.IntervalVarElement_swigregister(IntervalVarElement)
|
|
|
|
class SequenceVarElement(AssignmentElement):
|
|
r""" The SequenceVarElement stores a partial representation of ranked interval variables in the underlying sequence variable. This representation consists of three vectors: - the forward sequence. That is the list of interval variables ranked first in the sequence. The first element of the backward sequence is the first interval in the sequence variable. - the backward sequence. That is the list of interval variables ranked last in the sequence. The first element of the backward sequence is the last interval in the sequence variable. - The list of unperformed interval variables. Furthermore, if all performed variables are ranked, then by convention, the forward_sequence will contain all such variables and the backward_sequence will be empty."""
|
|
|
|
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 Var(self) -> "operations_research::SequenceVar *":
|
|
return _pywrapcp.SequenceVarElement_Var(self)
|
|
|
|
def ForwardSequence(self) -> "std::vector< int > const &":
|
|
return _pywrapcp.SequenceVarElement_ForwardSequence(self)
|
|
|
|
def BackwardSequence(self) -> "std::vector< int > const &":
|
|
return _pywrapcp.SequenceVarElement_BackwardSequence(self)
|
|
|
|
def Unperformed(self) -> "std::vector< int > const &":
|
|
return _pywrapcp.SequenceVarElement_Unperformed(self)
|
|
|
|
def SetSequence(self, forward_sequence: 'std::vector< int > const &', backward_sequence: 'std::vector< int > const &', unperformed: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarElement_SetSequence(self, forward_sequence, backward_sequence, unperformed)
|
|
|
|
def SetForwardSequence(self, forward_sequence: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarElement_SetForwardSequence(self, forward_sequence)
|
|
|
|
def SetBackwardSequence(self, backward_sequence: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarElement_SetBackwardSequence(self, backward_sequence)
|
|
|
|
def SetUnperformed(self, unperformed: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarElement_SetUnperformed(self, unperformed)
|
|
|
|
def __eq__(self, element: 'SequenceVarElement') -> "bool":
|
|
return _pywrapcp.SequenceVarElement___eq__(self, element)
|
|
|
|
def __ne__(self, element: 'SequenceVarElement') -> "bool":
|
|
return _pywrapcp.SequenceVarElement___ne__(self, element)
|
|
__swig_destroy__ = _pywrapcp.delete_SequenceVarElement
|
|
|
|
# Register SequenceVarElement in _pywrapcp:
|
|
_pywrapcp.SequenceVarElement_swigregister(SequenceVarElement)
|
|
|
|
class Assignment(PropagationBaseObject):
|
|
r""" An Assignment is a variable -> domains mapping, used to report solutions to the user."""
|
|
|
|
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":
|
|
return _pywrapcp.Assignment_Clear(self)
|
|
|
|
def Empty(self) -> "bool":
|
|
return _pywrapcp.Assignment_Empty(self)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.Assignment_Size(self)
|
|
|
|
def NumIntVars(self) -> "int":
|
|
return _pywrapcp.Assignment_NumIntVars(self)
|
|
|
|
def NumIntervalVars(self) -> "int":
|
|
return _pywrapcp.Assignment_NumIntervalVars(self)
|
|
|
|
def NumSequenceVars(self) -> "int":
|
|
return _pywrapcp.Assignment_NumSequenceVars(self)
|
|
|
|
def Store(self) -> "void":
|
|
return _pywrapcp.Assignment_Store(self)
|
|
|
|
def Restore(self) -> "void":
|
|
return _pywrapcp.Assignment_Restore(self)
|
|
|
|
def Load(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Load(self, *args)
|
|
|
|
def Save(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Save(self, *args)
|
|
|
|
def AddObjective(self, v: 'IntVar') -> "void":
|
|
return _pywrapcp.Assignment_AddObjective(self, v)
|
|
|
|
def Objective(self) -> "operations_research::IntVar *":
|
|
return _pywrapcp.Assignment_Objective(self)
|
|
|
|
def HasObjective(self) -> "bool":
|
|
return _pywrapcp.Assignment_HasObjective(self)
|
|
|
|
def ObjectiveMin(self) -> "int64":
|
|
return _pywrapcp.Assignment_ObjectiveMin(self)
|
|
|
|
def ObjectiveMax(self) -> "int64":
|
|
return _pywrapcp.Assignment_ObjectiveMax(self)
|
|
|
|
def ObjectiveValue(self) -> "int64":
|
|
return _pywrapcp.Assignment_ObjectiveValue(self)
|
|
|
|
def ObjectiveBound(self) -> "bool":
|
|
return _pywrapcp.Assignment_ObjectiveBound(self)
|
|
|
|
def SetObjectiveMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetObjectiveMin(self, m)
|
|
|
|
def SetObjectiveMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetObjectiveMax(self, m)
|
|
|
|
def SetObjectiveValue(self, value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetObjectiveValue(self, value)
|
|
|
|
def SetObjectiveRange(self, l: 'int64', u: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetObjectiveRange(self, l, u)
|
|
|
|
def Min(self, var: 'IntVar') -> "int64":
|
|
return _pywrapcp.Assignment_Min(self, var)
|
|
|
|
def Max(self, var: 'IntVar') -> "int64":
|
|
return _pywrapcp.Assignment_Max(self, var)
|
|
|
|
def Value(self, var: 'IntVar') -> "int64":
|
|
return _pywrapcp.Assignment_Value(self, var)
|
|
|
|
def Bound(self, var: 'IntVar') -> "bool":
|
|
return _pywrapcp.Assignment_Bound(self, var)
|
|
|
|
def SetMin(self, var: 'IntVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetMin(self, var, m)
|
|
|
|
def SetMax(self, var: 'IntVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetMax(self, var, m)
|
|
|
|
def SetRange(self, var: 'IntVar', l: 'int64', u: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetRange(self, var, l, u)
|
|
|
|
def SetValue(self, var: 'IntVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetValue(self, var, value)
|
|
|
|
def StartMin(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_StartMin(self, var)
|
|
|
|
def StartMax(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_StartMax(self, var)
|
|
|
|
def StartValue(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_StartValue(self, var)
|
|
|
|
def DurationMin(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_DurationMin(self, var)
|
|
|
|
def DurationMax(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_DurationMax(self, var)
|
|
|
|
def DurationValue(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_DurationValue(self, var)
|
|
|
|
def EndMin(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_EndMin(self, var)
|
|
|
|
def EndMax(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_EndMax(self, var)
|
|
|
|
def EndValue(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_EndValue(self, var)
|
|
|
|
def PerformedMin(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_PerformedMin(self, var)
|
|
|
|
def PerformedMax(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_PerformedMax(self, var)
|
|
|
|
def PerformedValue(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_PerformedValue(self, var)
|
|
|
|
def SetStartMin(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetStartMin(self, var, m)
|
|
|
|
def SetStartMax(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetStartMax(self, var, m)
|
|
|
|
def SetStartRange(self, var: 'IntervalVar', mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetStartRange(self, var, mi, ma)
|
|
|
|
def SetStartValue(self, var: 'IntervalVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetStartValue(self, var, value)
|
|
|
|
def SetDurationMin(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetDurationMin(self, var, m)
|
|
|
|
def SetDurationMax(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetDurationMax(self, var, m)
|
|
|
|
def SetDurationRange(self, var: 'IntervalVar', mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetDurationRange(self, var, mi, ma)
|
|
|
|
def SetDurationValue(self, var: 'IntervalVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetDurationValue(self, var, value)
|
|
|
|
def SetEndMin(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetEndMin(self, var, m)
|
|
|
|
def SetEndMax(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetEndMax(self, var, m)
|
|
|
|
def SetEndRange(self, var: 'IntervalVar', mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetEndRange(self, var, mi, ma)
|
|
|
|
def SetEndValue(self, var: 'IntervalVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetEndValue(self, var, value)
|
|
|
|
def SetPerformedMin(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetPerformedMin(self, var, m)
|
|
|
|
def SetPerformedMax(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetPerformedMax(self, var, m)
|
|
|
|
def SetPerformedRange(self, var: 'IntervalVar', mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetPerformedRange(self, var, mi, ma)
|
|
|
|
def SetPerformedValue(self, var: 'IntervalVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetPerformedValue(self, var, value)
|
|
|
|
def Add(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Add(self, *args)
|
|
|
|
def ForwardSequence(self, var: 'SequenceVar') -> "std::vector< int > const &":
|
|
return _pywrapcp.Assignment_ForwardSequence(self, var)
|
|
|
|
def BackwardSequence(self, var: 'SequenceVar') -> "std::vector< int > const &":
|
|
return _pywrapcp.Assignment_BackwardSequence(self, var)
|
|
|
|
def Unperformed(self, var: 'SequenceVar') -> "std::vector< int > const &":
|
|
return _pywrapcp.Assignment_Unperformed(self, var)
|
|
|
|
def SetSequence(self, var: 'SequenceVar', forward_sequence: 'std::vector< int > const &', backward_sequence: 'std::vector< int > const &', unperformed: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.Assignment_SetSequence(self, var, forward_sequence, backward_sequence, unperformed)
|
|
|
|
def SetForwardSequence(self, var: 'SequenceVar', forward_sequence: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.Assignment_SetForwardSequence(self, var, forward_sequence)
|
|
|
|
def SetBackwardSequence(self, var: 'SequenceVar', backward_sequence: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.Assignment_SetBackwardSequence(self, var, backward_sequence)
|
|
|
|
def SetUnperformed(self, var: 'SequenceVar', unperformed: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.Assignment_SetUnperformed(self, var, unperformed)
|
|
|
|
def Activate(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Activate(self, *args)
|
|
|
|
def Deactivate(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Deactivate(self, *args)
|
|
|
|
def Activated(self, *args) -> "bool":
|
|
return _pywrapcp.Assignment_Activated(self, *args)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Assignment_DebugString(self)
|
|
|
|
def IntVarContainer(self) -> "operations_research::Assignment::IntContainer const &":
|
|
return _pywrapcp.Assignment_IntVarContainer(self)
|
|
|
|
def MutableIntVarContainer(self) -> "operations_research::Assignment::IntContainer *":
|
|
return _pywrapcp.Assignment_MutableIntVarContainer(self)
|
|
|
|
def IntervalVarContainer(self) -> "operations_research::Assignment::IntervalContainer const &":
|
|
return _pywrapcp.Assignment_IntervalVarContainer(self)
|
|
|
|
def MutableIntervalVarContainer(self) -> "operations_research::Assignment::IntervalContainer *":
|
|
return _pywrapcp.Assignment_MutableIntervalVarContainer(self)
|
|
|
|
def SequenceVarContainer(self) -> "operations_research::Assignment::SequenceContainer const &":
|
|
return _pywrapcp.Assignment_SequenceVarContainer(self)
|
|
|
|
def MutableSequenceVarContainer(self) -> "operations_research::Assignment::SequenceContainer *":
|
|
return _pywrapcp.Assignment_MutableSequenceVarContainer(self)
|
|
|
|
def __eq__(self, assignment: 'Assignment') -> "bool":
|
|
return _pywrapcp.Assignment___eq__(self, assignment)
|
|
|
|
def __ne__(self, assignment: 'Assignment') -> "bool":
|
|
return _pywrapcp.Assignment___ne__(self, assignment)
|
|
|
|
# Register Assignment in _pywrapcp:
|
|
_pywrapcp.Assignment_swigregister(Assignment)
|
|
|
|
|
|
def __lshift__(*args) -> "std::ostream &":
|
|
return _pywrapcp.__lshift__(*args)
|
|
class Pack(Constraint):
|
|
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 AddWeightedSumLessOrEqualConstantDimension(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
Dimensions are additional constraints than can restrict what is possible with the pack constraint. It can be used to set capacity limits, to count objects per bin, to compute unassigned penalties... This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned to 'b' is less or equal 'bounds[b]'.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This dimension imposes that for all bins b, the weighted sum (weights->Run(i)) of all objects i assigned to 'b' is less or equal to 'bounds[b]'. Ownership of the callback is transferred to the pack constraint.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b) of all objects i assigned to 'b' is less or equal to 'bounds[b]'. Ownership of the callback is transferred to the pack constraint.
|
|
"""
|
|
return _pywrapcp.Pack_AddWeightedSumLessOrEqualConstantDimension(self, *args)
|
|
|
|
def AddWeightedSumEqualVarDimension(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned to 'b' is equal to loads[b].
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b)) of all objects i assigned to 'b' is equal to loads[b].
|
|
"""
|
|
return _pywrapcp.Pack_AddWeightedSumEqualVarDimension(self, *args)
|
|
|
|
def AddSumVariableWeightsLessOrEqualConstantDimension(self, usage: 'std::vector< operations_research::IntVar * > const &', capacity: 'std::vector< int64 > const &') -> "void":
|
|
r""" This dimension imposes: forall b in bins, sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b] where is_assigned(i, b) is true if and only if item i is assigned to the bin b. This can be used to model shapes of items by linking variables of the same item on parallel dimensions with an allowed assignment constraint."""
|
|
return _pywrapcp.Pack_AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity)
|
|
|
|
def AddWeightedSumOfAssignedDimension(self, weights: 'std::vector< int64 > const &', cost_var: 'IntVar') -> "void":
|
|
r""" This dimension enforces that cost_var == sum of weights[i] for all objects 'i' assigned to a bin."""
|
|
return _pywrapcp.Pack_AddWeightedSumOfAssignedDimension(self, weights, cost_var)
|
|
|
|
def AddCountUsedBinDimension(self, count_var: 'IntVar') -> "void":
|
|
r""" This dimension links 'count_var' to the actual number of bins used in the pack."""
|
|
return _pywrapcp.Pack_AddCountUsedBinDimension(self, count_var)
|
|
|
|
def AddCountAssignedItemsDimension(self, count_var: 'IntVar') -> "void":
|
|
r""" This dimension links 'count_var' to the actual number of items assigned to a bin in the pack."""
|
|
return _pywrapcp.Pack_AddCountAssignedItemsDimension(self, count_var)
|
|
|
|
def Post(self) -> "void":
|
|
return _pywrapcp.Pack_Post(self)
|
|
|
|
def InitialPropagateWrapper(self) -> "void":
|
|
return _pywrapcp.Pack_InitialPropagateWrapper(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Pack_DebugString(self)
|
|
|
|
# Register Pack in _pywrapcp:
|
|
_pywrapcp.Pack_swigregister(Pack)
|
|
|
|
class DisjunctiveConstraint(Constraint):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def SequenceVar(self) -> "operations_research::SequenceVar *":
|
|
r""" Creates a sequence variable from the constraint."""
|
|
return _pywrapcp.DisjunctiveConstraint_SequenceVar(self)
|
|
|
|
def SetTransitionTime(self, transition_time: 'operations_research::Solver::IndexEvaluator2') -> "void":
|
|
r""" Add a transition time between intervals. It forces the distance between the end of interval a and start of interval b that follows it to be at least transition_time(a, b). This function must always return a positive or null value."""
|
|
return _pywrapcp.DisjunctiveConstraint_SetTransitionTime(self, transition_time)
|
|
|
|
def TransitionTime(self, before_index: 'int', after_index: 'int') -> "int64":
|
|
return _pywrapcp.DisjunctiveConstraint_TransitionTime(self, before_index, after_index)
|
|
|
|
# Register DisjunctiveConstraint in _pywrapcp:
|
|
_pywrapcp.DisjunctiveConstraint_swigregister(DisjunctiveConstraint)
|
|
|
|
class RevInteger(object):
|
|
r""" This class adds reversibility to a POD type. It contains the stamp optimization. i.e. the SaveValue call is done only once per node of the search tree. Please note that actual stamps always starts at 1, thus an initial value of 0 will always trigger the first SaveValue."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, val: 'long long const &'):
|
|
_pywrapcp.RevInteger_swiginit(self, _pywrapcp.new_RevInteger(val))
|
|
|
|
def Value(self) -> "long long const &":
|
|
return _pywrapcp.RevInteger_Value(self)
|
|
|
|
def SetValue(self, s: 'Solver', val: 'long long const &') -> "void":
|
|
return _pywrapcp.RevInteger_SetValue(self, s, val)
|
|
__swig_destroy__ = _pywrapcp.delete_RevInteger
|
|
|
|
# Register RevInteger in _pywrapcp:
|
|
_pywrapcp.RevInteger_swigregister(RevInteger)
|
|
|
|
class NumericalRevInteger(RevInteger):
|
|
r""" Subclass of Rev<T> which adds numerical operations."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, val: 'long long const &'):
|
|
_pywrapcp.NumericalRevInteger_swiginit(self, _pywrapcp.new_NumericalRevInteger(val))
|
|
|
|
def Add(self, s: 'Solver', to_add: 'long long const &') -> "void":
|
|
return _pywrapcp.NumericalRevInteger_Add(self, s, to_add)
|
|
|
|
def Incr(self, s: 'Solver') -> "void":
|
|
return _pywrapcp.NumericalRevInteger_Incr(self, s)
|
|
|
|
def Decr(self, s: 'Solver') -> "void":
|
|
return _pywrapcp.NumericalRevInteger_Decr(self, s)
|
|
__swig_destroy__ = _pywrapcp.delete_NumericalRevInteger
|
|
|
|
# Register NumericalRevInteger in _pywrapcp:
|
|
_pywrapcp.NumericalRevInteger_swigregister(NumericalRevInteger)
|
|
|
|
class RevBool(object):
|
|
r""" This class adds reversibility to a POD type. It contains the stamp optimization. i.e. the SaveValue call is done only once per node of the search tree. Please note that actual stamps always starts at 1, thus an initial value of 0 will always trigger the first SaveValue."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, val: 'bool const &'):
|
|
_pywrapcp.RevBool_swiginit(self, _pywrapcp.new_RevBool(val))
|
|
|
|
def Value(self) -> "bool const &":
|
|
return _pywrapcp.RevBool_Value(self)
|
|
|
|
def SetValue(self, s: 'Solver', val: 'bool const &') -> "void":
|
|
return _pywrapcp.RevBool_SetValue(self, s, val)
|
|
__swig_destroy__ = _pywrapcp.delete_RevBool
|
|
|
|
# Register RevBool in _pywrapcp:
|
|
_pywrapcp.RevBool_swigregister(RevBool)
|
|
|
|
class IntVarContainer(object):
|
|
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 Contains(self, var: 'IntVar') -> "bool":
|
|
return _pywrapcp.IntVarContainer_Contains(self, var)
|
|
|
|
def Element(self, index: 'int') -> "operations_research::IntVarElement *":
|
|
return _pywrapcp.IntVarContainer_Element(self, index)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.IntVarContainer_Size(self)
|
|
|
|
def Store(self) -> "void":
|
|
return _pywrapcp.IntVarContainer_Store(self)
|
|
|
|
def Restore(self) -> "void":
|
|
return _pywrapcp.IntVarContainer_Restore(self)
|
|
|
|
def __eq__(self, container: 'IntVarContainer') -> "bool":
|
|
r""" Returns true if this and 'container' both represent the same V* -> E map. Runs in linear time; requires that the == operator on the type E is well defined."""
|
|
return _pywrapcp.IntVarContainer___eq__(self, container)
|
|
|
|
def __ne__(self, container: 'IntVarContainer') -> "bool":
|
|
return _pywrapcp.IntVarContainer___ne__(self, container)
|
|
__swig_destroy__ = _pywrapcp.delete_IntVarContainer
|
|
|
|
# Register IntVarContainer in _pywrapcp:
|
|
_pywrapcp.IntVarContainer_swigregister(IntVarContainer)
|
|
|
|
class IntervalVarContainer(object):
|
|
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 Contains(self, var: 'IntervalVar') -> "bool":
|
|
return _pywrapcp.IntervalVarContainer_Contains(self, var)
|
|
|
|
def Element(self, index: 'int') -> "operations_research::IntervalVarElement *":
|
|
return _pywrapcp.IntervalVarContainer_Element(self, index)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.IntervalVarContainer_Size(self)
|
|
|
|
def Store(self) -> "void":
|
|
return _pywrapcp.IntervalVarContainer_Store(self)
|
|
|
|
def Restore(self) -> "void":
|
|
return _pywrapcp.IntervalVarContainer_Restore(self)
|
|
|
|
def __eq__(self, container: 'IntervalVarContainer') -> "bool":
|
|
r""" Returns true if this and 'container' both represent the same V* -> E map. Runs in linear time; requires that the == operator on the type E is well defined."""
|
|
return _pywrapcp.IntervalVarContainer___eq__(self, container)
|
|
|
|
def __ne__(self, container: 'IntervalVarContainer') -> "bool":
|
|
return _pywrapcp.IntervalVarContainer___ne__(self, container)
|
|
__swig_destroy__ = _pywrapcp.delete_IntervalVarContainer
|
|
|
|
# Register IntervalVarContainer in _pywrapcp:
|
|
_pywrapcp.IntervalVarContainer_swigregister(IntervalVarContainer)
|
|
|
|
class SequenceVarContainer(object):
|
|
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 Contains(self, var: 'SequenceVar') -> "bool":
|
|
return _pywrapcp.SequenceVarContainer_Contains(self, var)
|
|
|
|
def Element(self, index: 'int') -> "operations_research::SequenceVarElement *":
|
|
return _pywrapcp.SequenceVarContainer_Element(self, index)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.SequenceVarContainer_Size(self)
|
|
|
|
def Store(self) -> "void":
|
|
return _pywrapcp.SequenceVarContainer_Store(self)
|
|
|
|
def Restore(self) -> "void":
|
|
return _pywrapcp.SequenceVarContainer_Restore(self)
|
|
|
|
def __eq__(self, container: 'SequenceVarContainer') -> "bool":
|
|
r""" Returns true if this and 'container' both represent the same V* -> E map. Runs in linear time; requires that the == operator on the type E is well defined."""
|
|
return _pywrapcp.SequenceVarContainer___eq__(self, container)
|
|
|
|
def __ne__(self, container: 'SequenceVarContainer') -> "bool":
|
|
return _pywrapcp.SequenceVarContainer___ne__(self, container)
|
|
__swig_destroy__ = _pywrapcp.delete_SequenceVarContainer
|
|
|
|
# Register SequenceVarContainer in _pywrapcp:
|
|
_pywrapcp.SequenceVarContainer_swigregister(SequenceVarContainer)
|
|
|
|
class LocalSearchOperator(BaseObject):
|
|
r""" This class represent a reversible FIFO structure. The main difference w.r.t a standard FIFO structure is that a Solver is given as parameter to the modifiers such that the solver can store the backtrack information Iterator's traversing order should not be changed, as some algorithm depend on it to be consistent. It's main use is to store a list of demons in the various classes of variables. The base class for all local search operators. A local search operator is an object that defines the neighborhood of a solution. In other words, a neighborhood is the set of solutions which can be reached from a given solution using an operator. The behavior of the LocalSearchOperator class is similar to iterators. The operator is synchronized with an assignment (gives the current values of the variables); this is done in the Start() method. Then one can iterate over the neighbors using the MakeNextNeighbor method. This method returns an assignment which represents the incremental changes to the current solution. It also returns a second assignment representing the changes to the last solution defined by the neighborhood operator; this assignment is empty if the neighborhood operator cannot track this information."""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def NextNeighbor(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
return _pywrapcp.LocalSearchOperator_NextNeighbor(self, delta, deltadelta)
|
|
|
|
def Start(self, assignment: 'Assignment') -> "void":
|
|
return _pywrapcp.LocalSearchOperator_Start(self, assignment)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_LocalSearchOperator(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register LocalSearchOperator in _pywrapcp:
|
|
_pywrapcp.LocalSearchOperator_swigregister(LocalSearchOperator)
|
|
|
|
class IntVarLocalSearchOperatorTemplate(LocalSearchOperator):
|
|
r""" Base operator class for operators manipulating variables."""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def Start(self, assignment: 'Assignment') -> "void":
|
|
r""" This method should not be overridden. Override OnStart() instead which is called before exiting this method."""
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_Start(self, assignment)
|
|
|
|
def IsIncremental(self) -> "bool":
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_IsIncremental(self)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_Size(self)
|
|
|
|
def Value(self, index: 'int64') -> "long long const &":
|
|
r""" Returns the value in the current assignment of the variable of given index."""
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_Value(self, index)
|
|
|
|
def OldValue(self, index: 'int64') -> "long long const &":
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_OldValue(self, index)
|
|
|
|
def SetValue(self, index: 'int64', value: 'long long const &') -> "void":
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_SetValue(self, index, value)
|
|
|
|
def OnStart(self) -> "void":
|
|
r""" Called by Start() after synchronizing the operator with the current assignment. Should be overridden instead of Start() to avoid calling VarLocalSearchOperator::Start explicitly."""
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_OnStart(self)
|
|
|
|
# Register IntVarLocalSearchOperatorTemplate in _pywrapcp:
|
|
_pywrapcp.IntVarLocalSearchOperatorTemplate_swigregister(IntVarLocalSearchOperatorTemplate)
|
|
|
|
class IntVarLocalSearchOperator(IntVarLocalSearchOperatorTemplate):
|
|
r""" clang-format on"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
if self.__class__ == IntVarLocalSearchOperator:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.IntVarLocalSearchOperator_swiginit(self, _pywrapcp.new_IntVarLocalSearchOperator(_self, *args))
|
|
__swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchOperator
|
|
|
|
def NextNeighbor(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
r""" Redefines MakeNextNeighbor to export a simpler interface. The calls to ApplyChanges() and RevertChanges() are factored in this method, hiding both delta and deltadelta from subclasses which only need to override MakeOneNeighbor(). Therefore this method should not be overridden. Override MakeOneNeighbor() instead."""
|
|
return _pywrapcp.IntVarLocalSearchOperator_NextNeighbor(self, delta, deltadelta)
|
|
|
|
def OneNeighbor(self) -> "bool":
|
|
r""" Creates a new neighbor. It returns false when the neighborhood is completely explored. MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator."""
|
|
return _pywrapcp.IntVarLocalSearchOperator_OneNeighbor(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_IntVarLocalSearchOperator(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register IntVarLocalSearchOperator in _pywrapcp:
|
|
_pywrapcp.IntVarLocalSearchOperator_swigregister(IntVarLocalSearchOperator)
|
|
|
|
class SequenceVarLocalSearchOperatorTemplate(LocalSearchOperator):
|
|
r""" Base operator class for operators manipulating variables."""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def Start(self, assignment: 'Assignment') -> "void":
|
|
r""" This method should not be overridden. Override OnStart() instead which is called before exiting this method."""
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_Start(self, assignment)
|
|
|
|
def IsIncremental(self) -> "bool":
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_IsIncremental(self)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_Size(self)
|
|
|
|
def Value(self, index: 'int64') -> "std::vector< int > const &":
|
|
r""" Returns the value in the current assignment of the variable of given index."""
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_Value(self, index)
|
|
|
|
def OldValue(self, index: 'int64') -> "std::vector< int > const &":
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_OldValue(self, index)
|
|
|
|
def SetValue(self, index: 'int64', value: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_SetValue(self, index, value)
|
|
|
|
def OnStart(self) -> "void":
|
|
r""" Called by Start() after synchronizing the operator with the current assignment. Should be overridden instead of Start() to avoid calling VarLocalSearchOperator::Start explicitly."""
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_OnStart(self)
|
|
|
|
# Register SequenceVarLocalSearchOperatorTemplate in _pywrapcp:
|
|
_pywrapcp.SequenceVarLocalSearchOperatorTemplate_swigregister(SequenceVarLocalSearchOperatorTemplate)
|
|
|
|
class SequenceVarLocalSearchOperator(SequenceVarLocalSearchOperatorTemplate):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
# Register SequenceVarLocalSearchOperator in _pywrapcp:
|
|
_pywrapcp.SequenceVarLocalSearchOperator_swigregister(SequenceVarLocalSearchOperator)
|
|
|
|
class BaseLns(IntVarLocalSearchOperator):
|
|
r""" This is the base class for building an Lns operator. An Lns fragment is a collection of variables which will be relaxed. Fragments are built with NextFragment(), which returns false if there are no more fragments to build. Optionally one can override InitFragments, which is called from LocalSearchOperator::Start to initialize fragment data. Here's a sample relaxing one variable at a time: class OneVarLns : public BaseLns { public: OneVarLns(const std::vector<IntVar*>& vars) : BaseLns(vars), index_(0) {} virtual ~OneVarLns() {} virtual void InitFragments() { index_ = 0; } virtual bool NextFragment() { const int size = Size(); if (index_ < size) { AppendToFragment(index_); ++index_; return true; } else { return false; } } private: int index_; };"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, vars: 'std::vector< operations_research::IntVar * > const &'):
|
|
if self.__class__ == BaseLns:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.BaseLns_swiginit(self, _pywrapcp.new_BaseLns(_self, vars))
|
|
__swig_destroy__ = _pywrapcp.delete_BaseLns
|
|
|
|
def InitFragments(self) -> "void":
|
|
return _pywrapcp.BaseLns_InitFragments(self)
|
|
|
|
def NextFragment(self) -> "bool":
|
|
return _pywrapcp.BaseLns_NextFragment(self)
|
|
|
|
def AppendToFragment(self, index: 'int') -> "void":
|
|
return _pywrapcp.BaseLns_AppendToFragment(self, index)
|
|
|
|
def FragmentSize(self) -> "int":
|
|
return _pywrapcp.BaseLns_FragmentSize(self)
|
|
|
|
def __getitem__(self, index: 'int') -> "int64":
|
|
return _pywrapcp.BaseLns___getitem__(self, index)
|
|
|
|
def __len__(self) -> "int":
|
|
return _pywrapcp.BaseLns___len__(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_BaseLns(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register BaseLns in _pywrapcp:
|
|
_pywrapcp.BaseLns_swigregister(BaseLns)
|
|
|
|
class ChangeValue(IntVarLocalSearchOperator):
|
|
r""" Defines operators which change the value of variables; each neighbor corresponds to *one* modified variable. Sub-classes have to define ModifyValue which determines what the new variable value is going to be (given the current value and the variable)."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, vars: 'std::vector< operations_research::IntVar * > const &'):
|
|
if self.__class__ == ChangeValue:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.ChangeValue_swiginit(self, _pywrapcp.new_ChangeValue(_self, vars))
|
|
__swig_destroy__ = _pywrapcp.delete_ChangeValue
|
|
|
|
def ModifyValue(self, index: 'int64', value: 'int64') -> "int64":
|
|
return _pywrapcp.ChangeValue_ModifyValue(self, index, value)
|
|
|
|
def OneNeighbor(self) -> "bool":
|
|
r""" This method should not be overridden. Override ModifyValue() instead."""
|
|
return _pywrapcp.ChangeValue_OneNeighbor(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_ChangeValue(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register ChangeValue in _pywrapcp:
|
|
_pywrapcp.ChangeValue_swigregister(ChangeValue)
|
|
|
|
class PathOperator(IntVarLocalSearchOperator):
|
|
r""" Base class of the local search operators dedicated to path modifications (a path is a set of nodes linked together by arcs). This family of neighborhoods supposes they are handling next variables representing the arcs (var[i] represents the node immediately after i on a path). Several services are provided: - arc manipulators (SetNext(), ReverseChain(), MoveChain()) - path inspectors (Next(), IsPathEnd()) - path iterators: operators need a given number of nodes to define a neighbor; this class provides the iteration on a given number of (base) nodes which can be used to define a neighbor (through the BaseNode method) Subclasses only need to override MakeNeighbor to create neighbors using the services above (no direct manipulation of assignments)."""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def Neighbor(self) -> "bool":
|
|
return _pywrapcp.PathOperator_Neighbor(self)
|
|
|
|
# Register PathOperator in _pywrapcp:
|
|
_pywrapcp.PathOperator_swigregister(PathOperator)
|
|
|
|
class LocalSearchFilter(BaseObject):
|
|
r""" Local Search Filters are used for fast neighbor pruning."""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def Accept(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
r""" Accepts a "delta" given the assignment with which the filter has been synchronized; the delta holds the variables which have been modified and their new value. Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1, for the assignment (a,1), (b,0), the delta (b,1) will be rejected but the delta (a,0) will be accepted."""
|
|
return _pywrapcp.LocalSearchFilter_Accept(self, delta, deltadelta)
|
|
|
|
def Synchronize(self, assignment: 'Assignment', delta: 'Assignment') -> "void":
|
|
r""" Synchronizes the filter with the current solution, delta being the difference with the solution passed to the previous call to Synchronize() or IncrementalSynchronize(). 'delta' can be used to incrementally synchronizing the filter with the new solution by only considering the changes in delta."""
|
|
return _pywrapcp.LocalSearchFilter_Synchronize(self, assignment, delta)
|
|
|
|
def IsIncremental(self) -> "bool":
|
|
return _pywrapcp.LocalSearchFilter_IsIncremental(self)
|
|
__swig_destroy__ = _pywrapcp.delete_LocalSearchFilter
|
|
|
|
# Register LocalSearchFilter in _pywrapcp:
|
|
_pywrapcp.LocalSearchFilter_swigregister(LocalSearchFilter)
|
|
|
|
class IntVarLocalSearchFilter(LocalSearchFilter):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
if self.__class__ == IntVarLocalSearchFilter:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.IntVarLocalSearchFilter_swiginit(self, _pywrapcp.new_IntVarLocalSearchFilter(_self, *args))
|
|
__swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchFilter
|
|
|
|
def Synchronize(self, assignment: 'Assignment', delta: 'Assignment') -> "void":
|
|
r""" This method should not be overridden. Override OnSynchronize() instead which is called before exiting this method."""
|
|
return _pywrapcp.IntVarLocalSearchFilter_Synchronize(self, assignment, delta)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.IntVarLocalSearchFilter_Size(self)
|
|
|
|
def Value(self, index: 'int') -> "int64":
|
|
return _pywrapcp.IntVarLocalSearchFilter_Value(self, index)
|
|
|
|
def IndexFromVar(self, var: 'IntVar') -> "int64":
|
|
return _pywrapcp.IntVarLocalSearchFilter_IndexFromVar(self, var)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_IntVarLocalSearchFilter(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register IntVarLocalSearchFilter in _pywrapcp:
|
|
_pywrapcp.IntVarLocalSearchFilter_swigregister(IntVarLocalSearchFilter)
|
|
|
|
class BooleanVar(IntVar):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def Min(self) -> "int64":
|
|
return _pywrapcp.BooleanVar_Min(self)
|
|
|
|
def SetMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.BooleanVar_SetMin(self, m)
|
|
|
|
def Max(self) -> "int64":
|
|
return _pywrapcp.BooleanVar_Max(self)
|
|
|
|
def SetMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.BooleanVar_SetMax(self, m)
|
|
|
|
def SetRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.BooleanVar_SetRange(self, mi, ma)
|
|
|
|
def Bound(self) -> "bool":
|
|
return _pywrapcp.BooleanVar_Bound(self)
|
|
|
|
def Value(self) -> "int64":
|
|
return _pywrapcp.BooleanVar_Value(self)
|
|
|
|
def RemoveValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.BooleanVar_RemoveValue(self, v)
|
|
|
|
def RemoveInterval(self, l: 'int64', u: 'int64') -> "void":
|
|
return _pywrapcp.BooleanVar_RemoveInterval(self, l, u)
|
|
|
|
def WhenBound(self, d: 'Demon') -> "void":
|
|
return _pywrapcp.BooleanVar_WhenBound(self, d)
|
|
|
|
def WhenRange(self, d: 'Demon') -> "void":
|
|
return _pywrapcp.BooleanVar_WhenRange(self, d)
|
|
|
|
def WhenDomain(self, d: 'Demon') -> "void":
|
|
return _pywrapcp.BooleanVar_WhenDomain(self, d)
|
|
|
|
def Size(self) -> "uint64":
|
|
return _pywrapcp.BooleanVar_Size(self)
|
|
|
|
def Contains(self, v: 'int64') -> "bool":
|
|
return _pywrapcp.BooleanVar_Contains(self, v)
|
|
|
|
def HoleIteratorAux(self, reversible: 'bool') -> "operations_research::IntVarIterator *":
|
|
return _pywrapcp.BooleanVar_HoleIteratorAux(self, reversible)
|
|
|
|
def DomainIteratorAux(self, reversible: 'bool') -> "operations_research::IntVarIterator *":
|
|
return _pywrapcp.BooleanVar_DomainIteratorAux(self, reversible)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.BooleanVar_DebugString(self)
|
|
|
|
# Register BooleanVar in _pywrapcp:
|
|
_pywrapcp.BooleanVar_swigregister(BooleanVar)
|
|
|
|
|
|
class PyDecision(Decision):
|
|
|
|
def __init__(self):
|
|
Decision.__init__(self)
|
|
|
|
def ApplyWrapper(self, solver):
|
|
try:
|
|
self.Apply(solver)
|
|
except Exception as e:
|
|
if 'CP Solver fail' in str(e):
|
|
solver.ShouldFail()
|
|
else:
|
|
raise
|
|
|
|
def RefuteWrapper(self, solver):
|
|
try:
|
|
self.Refute(solver)
|
|
except Exception as e:
|
|
if 'CP Solver fail' in str(e):
|
|
solver.ShouldFail()
|
|
else:
|
|
raise
|
|
|
|
def DebugString(self):
|
|
return "PyDecision"
|
|
|
|
|
|
class PyDecisionBuilder(DecisionBuilder):
|
|
|
|
def __init__(self):
|
|
DecisionBuilder.__init__(self)
|
|
|
|
def NextWrapper(self, solver):
|
|
try:
|
|
return self.Next(solver)
|
|
except Exception as e:
|
|
if 'CP Solver fail' in str(e):
|
|
return solver.FailDecision()
|
|
else:
|
|
raise
|
|
|
|
def DebugString(self):
|
|
return "PyDecisionBuilder"
|
|
|
|
|
|
class PyDemon(Demon):
|
|
|
|
def RunWrapper(self, solver):
|
|
try:
|
|
self.Run(solver)
|
|
except Exception as e:
|
|
if 'CP Solver fail' in str(e):
|
|
solver.ShouldFail()
|
|
else:
|
|
raise
|
|
|
|
def DebugString(self):
|
|
return "PyDemon"
|
|
|
|
|
|
class PyConstraintDemon(PyDemon):
|
|
|
|
def __init__(self, ct, method, delayed, *args):
|
|
PyDemon.__init__(self)
|
|
self.__constraint = ct
|
|
self.__method = method
|
|
self.__delayed = delayed
|
|
self.__args = args
|
|
|
|
def Run(self, solver):
|
|
self.__method(self.__constraint, *self.__args)
|
|
|
|
def Priority(self):
|
|
return Solver.DELAYED_PRIORITY if self.__delayed else Solver.NORMAL_PRIORITY
|
|
|
|
def DebugString(self):
|
|
return 'PyConstraintDemon'
|
|
|
|
|
|
class PyConstraint(Constraint):
|
|
|
|
def __init__(self, solver):
|
|
Constraint.__init__(self, solver)
|
|
self.__demons = []
|
|
|
|
def Demon(self, method, *args):
|
|
demon = PyConstraintDemon(self, method, False, *args)
|
|
self.__demons.append(demon)
|
|
return demon
|
|
|
|
def DelayedDemon(self, method, *args):
|
|
demon = PyConstraintDemon(self, method, True, *args)
|
|
self.__demons.append(demon)
|
|
return demon
|
|
|
|
def InitialPropagateDemon(self):
|
|
return self.solver().ConstraintInitialPropagateCallback(self)
|
|
|
|
def DelayedInitialPropagateDemon(self):
|
|
return self.solver().DelayedConstraintInitialPropagateCallback(self)
|
|
|
|
def InitialPropagateWrapper(self):
|
|
try:
|
|
self.InitialPropagate()
|
|
except Exception as e:
|
|
if 'CP Solver fail' in str(e):
|
|
self.solver().ShouldFail()
|
|
else:
|
|
raise
|
|
|
|
def DebugString(self):
|
|
return "PyConstraint"
|
|
|
|
|
|
|
|
class RoutingIndexManager(object):
|
|
r""" Manager for any NodeIndex <-> variable index conversion. The routing solver uses variable indices internally and through its API. These variable indices are tricky to manage directly because one Node can correspond to a multitude of variables, depending on the number of times they appear in the model, and if they're used as start and/or end points. This class aims to simplify variable index usage, allowing users to use NodeIndex instead. Usage: auto starts_ends = ...; /// These are NodeIndex. RoutingIndexManager manager(/*nodes*/10, /*vehicles*/4, starts_ends); RoutingModel model(manager); Then, use 'manager.NodeToIndex(node)' whenever 'model' requires a variable index."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
_pywrapcp.RoutingIndexManager_swiginit(self, _pywrapcp.new_RoutingIndexManager(*args))
|
|
__swig_destroy__ = _pywrapcp.delete_RoutingIndexManager
|
|
|
|
def GetNumberOfNodes(self) -> "int":
|
|
return _pywrapcp.RoutingIndexManager_GetNumberOfNodes(self)
|
|
|
|
def GetNumberOfVehicles(self) -> "int":
|
|
return _pywrapcp.RoutingIndexManager_GetNumberOfVehicles(self)
|
|
|
|
def GetNumberOfIndices(self) -> "int":
|
|
return _pywrapcp.RoutingIndexManager_GetNumberOfIndices(self)
|
|
|
|
def NodeToIndex(self, node: 'operations_research::RoutingIndexManager::NodeIndex') -> "int64":
|
|
return _pywrapcp.RoutingIndexManager_NodeToIndex(self, node)
|
|
|
|
def IndexToNode(self, index: 'int64') -> "operations_research::RoutingIndexManager::NodeIndex":
|
|
return _pywrapcp.RoutingIndexManager_IndexToNode(self, index)
|
|
|
|
# Register RoutingIndexManager in _pywrapcp:
|
|
_pywrapcp.RoutingIndexManager_swigregister(RoutingIndexManager)
|
|
|
|
|
|
def DefaultRoutingModelParameters() -> "operations_research::RoutingModelParameters":
|
|
return _pywrapcp.DefaultRoutingModelParameters()
|
|
|
|
def DefaultRoutingSearchParameters() -> "operations_research::RoutingSearchParameters":
|
|
return _pywrapcp.DefaultRoutingSearchParameters()
|
|
|
|
def FindErrorInRoutingSearchParameters(search_parameters: 'operations_research::RoutingSearchParameters const &') -> "std::string":
|
|
r""" Returns an empty std::string if the routing search parameters are valid, and a non-empty, human readable error description if they're not."""
|
|
return _pywrapcp.FindErrorInRoutingSearchParameters(search_parameters)
|
|
BOOL_UNSPECIFIED = _pywrapcp.BOOL_UNSPECIFIED
|
|
BOOL_FALSE = _pywrapcp.BOOL_FALSE
|
|
BOOL_TRUE = _pywrapcp.BOOL_TRUE
|
|
class RoutingModel(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
ROUTING_NOT_SOLVED = _pywrapcp.RoutingModel_ROUTING_NOT_SOLVED
|
|
ROUTING_SUCCESS = _pywrapcp.RoutingModel_ROUTING_SUCCESS
|
|
ROUTING_FAIL = _pywrapcp.RoutingModel_ROUTING_FAIL
|
|
ROUTING_FAIL_TIMEOUT = _pywrapcp.RoutingModel_ROUTING_FAIL_TIMEOUT
|
|
ROUTING_INVALID = _pywrapcp.RoutingModel_ROUTING_INVALID
|
|
PICKUP_AND_DELIVERY_NO_ORDER = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_NO_ORDER
|
|
PICKUP_AND_DELIVERY_LIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_LIFO
|
|
PICKUP_AND_DELIVERY_FIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_FIFO
|
|
|
|
def __init__(self, *args):
|
|
_pywrapcp.RoutingModel_swiginit(self, _pywrapcp.new_RoutingModel(*args))
|
|
__swig_destroy__ = _pywrapcp.delete_RoutingModel
|
|
|
|
def RegisterUnaryTransitCallback(self, callback: 'operations_research::RoutingModel::TransitCallback1') -> "int":
|
|
return _pywrapcp.RoutingModel_RegisterUnaryTransitCallback(self, callback)
|
|
|
|
def RegisterTransitCallback(self, callback: 'operations_research::RoutingModel::TransitCallback2') -> "int":
|
|
return _pywrapcp.RoutingModel_RegisterTransitCallback(self, callback)
|
|
|
|
def RegisterPositiveTransitCallback(self, callback: 'operations_research::RoutingModel::TransitCallback2') -> "int":
|
|
return _pywrapcp.RoutingModel_RegisterPositiveTransitCallback(self, callback)
|
|
|
|
def TransitCallback(self, callback_index: 'int') -> "operations_research::RoutingModel::TransitCallback2 const &":
|
|
return _pywrapcp.RoutingModel_TransitCallback(self, callback_index)
|
|
|
|
def UnaryTransitCallbackOrNull(self, callback_index: 'int') -> "operations_research::RoutingModel::TransitCallback1 const &":
|
|
return _pywrapcp.RoutingModel_UnaryTransitCallbackOrNull(self, callback_index)
|
|
|
|
def AddDimension(self, evaluator_index: 'int', slack_max: 'int64', capacity: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name)
|
|
|
|
def AddDimensionWithVehicleTransits(self, evaluator_indices: 'std::vector< int > const &', slack_max: 'int64', capacity: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name)
|
|
|
|
def AddDimensionWithVehicleCapacity(self, evaluator_index: 'int', slack_max: 'int64', vehicle_capacities: 'std::vector< int64 >', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)
|
|
|
|
def AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices: 'std::vector< int > const &', slack_max: 'int64', vehicle_capacities: 'std::vector< int64 >', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)
|
|
|
|
def AddConstantDimensionWithSlack(self, value: 'int64', capacity: 'int64', slack_max: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name)
|
|
|
|
def AddConstantDimension(self, value: 'int64', capacity: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name)
|
|
|
|
def AddVectorDimension(self, values: 'std::vector< int64 >', capacity: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name)
|
|
|
|
def MakePathSpansAndTotalSlacks(self, dimension: 'RoutingDimension', spans: 'std::vector< operations_research::IntVar * >', total_slacks: 'std::vector< operations_research::IntVar * >') -> "operations_research::Constraint *":
|
|
return _pywrapcp.RoutingModel_MakePathSpansAndTotalSlacks(self, dimension, spans, total_slacks)
|
|
|
|
def GetAllDimensionNames(self) -> "std::vector< ::std::string >":
|
|
return _pywrapcp.RoutingModel_GetAllDimensionNames(self)
|
|
|
|
def GetDimensions(self) -> "std::vector< operations_research::RoutingDimension * > const &":
|
|
return _pywrapcp.RoutingModel_GetDimensions(self)
|
|
|
|
def GetDimensionsWithSoftOrSpanCosts(self) -> "std::vector< operations_research::RoutingDimension * >":
|
|
return _pywrapcp.RoutingModel_GetDimensionsWithSoftOrSpanCosts(self)
|
|
|
|
def GetDimensionsForGlobalCumulOptimizers(self) -> "std::vector< operations_research::RoutingDimension * > const &":
|
|
return _pywrapcp.RoutingModel_GetDimensionsForGlobalCumulOptimizers(self)
|
|
|
|
def GetDimensionsForLocalCumulOptimizers(self) -> "std::vector< operations_research::RoutingDimension * > const &":
|
|
return _pywrapcp.RoutingModel_GetDimensionsForLocalCumulOptimizers(self)
|
|
|
|
def HasDimension(self, dimension_name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_HasDimension(self, dimension_name)
|
|
|
|
def GetDimensionOrDie(self, dimension_name: 'std::string const &') -> "operations_research::RoutingDimension const &":
|
|
return _pywrapcp.RoutingModel_GetDimensionOrDie(self, dimension_name)
|
|
|
|
def GetMutableDimension(self, dimension_name: 'std::string const &') -> "operations_research::RoutingDimension *":
|
|
return _pywrapcp.RoutingModel_GetMutableDimension(self, dimension_name)
|
|
|
|
def SetPrimaryConstrainedDimension(self, dimension_name: 'std::string const &') -> "void":
|
|
return _pywrapcp.RoutingModel_SetPrimaryConstrainedDimension(self, dimension_name)
|
|
|
|
def GetPrimaryConstrainedDimension(self) -> "std::string const &":
|
|
return _pywrapcp.RoutingModel_GetPrimaryConstrainedDimension(self)
|
|
|
|
def AddDisjunction(self, *args) -> "operations_research::RoutingModel::DisjunctionIndex":
|
|
return _pywrapcp.RoutingModel_AddDisjunction(self, *args)
|
|
|
|
def GetDisjunctionIndices(self, index: 'int64') -> "std::vector< operations_research::RoutingModel::DisjunctionIndex > const &":
|
|
return _pywrapcp.RoutingModel_GetDisjunctionIndices(self, index)
|
|
|
|
def GetDisjunctionPenalty(self, index: 'operations_research::RoutingModel::DisjunctionIndex') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetDisjunctionPenalty(self, index)
|
|
|
|
def GetDisjunctionMaxCardinality(self, index: 'operations_research::RoutingModel::DisjunctionIndex') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetDisjunctionMaxCardinality(self, index)
|
|
|
|
def GetNumberOfDisjunctions(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetNumberOfDisjunctions(self)
|
|
|
|
def GetPerfectBinaryDisjunctions(self) -> "std::vector< std::pair< int64,int64 > >":
|
|
return _pywrapcp.RoutingModel_GetPerfectBinaryDisjunctions(self)
|
|
|
|
def IgnoreDisjunctionsAlreadyForcedToZero(self) -> "void":
|
|
return _pywrapcp.RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero(self)
|
|
|
|
def AddSoftSameVehicleConstraint(self, indices: 'std::vector< int64 > const &', cost: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_AddSoftSameVehicleConstraint(self, indices, cost)
|
|
|
|
def SetAllowedVehiclesForIndex(self, vehicles: 'std::vector< int > const &', index: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_SetAllowedVehiclesForIndex(self, vehicles, index)
|
|
|
|
def IsVehicleAllowedForIndex(self, vehicle: 'int', index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingModel_IsVehicleAllowedForIndex(self, vehicle, index)
|
|
|
|
def AddPickupAndDelivery(self, pickup: 'int64', delivery: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_AddPickupAndDelivery(self, pickup, delivery)
|
|
|
|
def AddPickupAndDeliverySets(self, pickup_disjunction: 'operations_research::RoutingModel::DisjunctionIndex', delivery_disjunction: 'operations_research::RoutingModel::DisjunctionIndex') -> "void":
|
|
return _pywrapcp.RoutingModel_AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction)
|
|
|
|
def GetPickupIndexPairs(self, node_index: 'int64') -> "std::vector< std::pair< int,int > > const &":
|
|
return _pywrapcp.RoutingModel_GetPickupIndexPairs(self, node_index)
|
|
|
|
def GetDeliveryIndexPairs(self, node_index: 'int64') -> "std::vector< std::pair< int,int > > const &":
|
|
return _pywrapcp.RoutingModel_GetDeliveryIndexPairs(self, node_index)
|
|
|
|
def SetPickupAndDeliveryPolicyOfAllVehicles(self, policy: 'operations_research::RoutingModel::PickupAndDeliveryPolicy') -> "void":
|
|
return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles(self, policy)
|
|
|
|
def SetPickupAndDeliveryPolicyOfVehicle(self, policy: 'operations_research::RoutingModel::PickupAndDeliveryPolicy', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle)
|
|
|
|
def GetPickupAndDeliveryPolicyOfVehicle(self, vehicle: 'int') -> "operations_research::RoutingModel::PickupAndDeliveryPolicy":
|
|
return _pywrapcp.RoutingModel_GetPickupAndDeliveryPolicyOfVehicle(self, vehicle)
|
|
|
|
def GetNumOfSingletonNodes(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetNumOfSingletonNodes(self)
|
|
|
|
def SetVisitType(self, index: 'int64', type: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetVisitType(self, index, type)
|
|
|
|
def GetVisitType(self, index: 'int64') -> "int":
|
|
return _pywrapcp.RoutingModel_GetVisitType(self, index)
|
|
|
|
def CloseVisitTypes(self) -> "void":
|
|
return _pywrapcp.RoutingModel_CloseVisitTypes(self)
|
|
|
|
def GetNumberOfVisitTypes(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetNumberOfVisitTypes(self)
|
|
|
|
def AddHardTypeIncompatibility(self, type1: 'int', type2: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_AddHardTypeIncompatibility(self, type1, type2)
|
|
|
|
def AddTemporalTypeIncompatibility(self, type1: 'int', type2: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_AddTemporalTypeIncompatibility(self, type1, type2)
|
|
|
|
def GetHardTypeIncompatibilitiesOfType(self, type: 'int') -> "absl::flat_hash_set< int > const &":
|
|
return _pywrapcp.RoutingModel_GetHardTypeIncompatibilitiesOfType(self, type)
|
|
|
|
def GetTemporalTypeIncompatibilitiesOfType(self, type: 'int') -> "absl::flat_hash_set< int > const &":
|
|
return _pywrapcp.RoutingModel_GetTemporalTypeIncompatibilitiesOfType(self, type)
|
|
|
|
def HasHardTypeIncompatibilities(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasHardTypeIncompatibilities(self)
|
|
|
|
def HasTemporalTypeIncompatibilities(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasTemporalTypeIncompatibilities(self)
|
|
|
|
def AddSameVehicleRequiredTypeAlternatives(self, dependent_type: 'int', required_type_alternatives: 'absl::flat_hash_set< int >') -> "void":
|
|
return _pywrapcp.RoutingModel_AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives)
|
|
|
|
def AddTemporalRequiredTypeAlternatives(self, dependent_type: 'int', required_type_alternatives: 'absl::flat_hash_set< int >') -> "void":
|
|
return _pywrapcp.RoutingModel_AddTemporalRequiredTypeAlternatives(self, dependent_type, required_type_alternatives)
|
|
|
|
def GetSameVehicleRequiredTypeAlternativesOfType(self, type: 'int') -> "std::vector< absl::flat_hash_set< int > > const &":
|
|
return _pywrapcp.RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType(self, type)
|
|
|
|
def GetTemporalRequiredTypeAlternativesOfType(self, type: 'int') -> "std::vector< absl::flat_hash_set< int > > const &":
|
|
return _pywrapcp.RoutingModel_GetTemporalRequiredTypeAlternativesOfType(self, type)
|
|
|
|
def HasSameVehicleTypeRequirements(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasSameVehicleTypeRequirements(self)
|
|
|
|
def HasTemporalTypeRequirements(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasTemporalTypeRequirements(self)
|
|
|
|
def HasTypeRegulations(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasTypeRegulations(self)
|
|
|
|
def UnperformedPenalty(self, var_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_UnperformedPenalty(self, var_index)
|
|
|
|
def UnperformedPenaltyOrValue(self, default_value: 'int64', var_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_UnperformedPenaltyOrValue(self, default_value, var_index)
|
|
|
|
def GetDepot(self) -> "int64":
|
|
return _pywrapcp.RoutingModel_GetDepot(self)
|
|
|
|
def SetArcCostEvaluatorOfAllVehicles(self, evaluator_index: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfAllVehicles(self, evaluator_index)
|
|
|
|
def SetArcCostEvaluatorOfVehicle(self, evaluator_index: 'int', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle)
|
|
|
|
def SetFixedCostOfAllVehicles(self, cost: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_SetFixedCostOfAllVehicles(self, cost)
|
|
|
|
def SetFixedCostOfVehicle(self, cost: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetFixedCostOfVehicle(self, cost, vehicle)
|
|
|
|
def GetFixedCostOfVehicle(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetFixedCostOfVehicle(self, vehicle)
|
|
|
|
def SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor: 'int64', quadratic_cost_factor: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor)
|
|
|
|
def SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor: 'int64', quadratic_cost_factor: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle)
|
|
|
|
def GetAmortizedLinearCostFactorOfVehicles(self) -> "std::vector< int64 > const &":
|
|
return _pywrapcp.RoutingModel_GetAmortizedLinearCostFactorOfVehicles(self)
|
|
|
|
def GetAmortizedQuadraticCostFactorOfVehicles(self) -> "std::vector< int64 > const &":
|
|
return _pywrapcp.RoutingModel_GetAmortizedQuadraticCostFactorOfVehicles(self)
|
|
|
|
def ConsiderEmptyRouteCostsForVehicle(self, consider_costs: 'bool', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_ConsiderEmptyRouteCostsForVehicle(self, consider_costs, vehicle)
|
|
|
|
def AreEmptyRouteCostsConsideredForVehicle(self, vehicle: 'int') -> "bool":
|
|
return _pywrapcp.RoutingModel_AreEmptyRouteCostsConsideredForVehicle(self, vehicle)
|
|
|
|
def SetFirstSolutionEvaluator(self, evaluator: 'operations_research::Solver::IndexEvaluator2') -> "void":
|
|
return _pywrapcp.RoutingModel_SetFirstSolutionEvaluator(self, evaluator)
|
|
|
|
def AddLocalSearchOperator(self, ls_operator: 'LocalSearchOperator') -> "void":
|
|
return _pywrapcp.RoutingModel_AddLocalSearchOperator(self, ls_operator)
|
|
|
|
def AddSearchMonitor(self, monitor: 'SearchMonitor') -> "void":
|
|
return _pywrapcp.RoutingModel_AddSearchMonitor(self, monitor)
|
|
|
|
def AddAtSolutionCallback(self, callback: 'std::function< void () >') -> "void":
|
|
return _pywrapcp.RoutingModel_AddAtSolutionCallback(self, callback)
|
|
|
|
def AddVariableMinimizedByFinalizer(self, var: 'IntVar') -> "void":
|
|
return _pywrapcp.RoutingModel_AddVariableMinimizedByFinalizer(self, var)
|
|
|
|
def AddVariableMaximizedByFinalizer(self, var: 'IntVar') -> "void":
|
|
return _pywrapcp.RoutingModel_AddVariableMaximizedByFinalizer(self, var)
|
|
|
|
def AddWeightedVariableMinimizedByFinalizer(self, var: 'IntVar', cost: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_AddWeightedVariableMinimizedByFinalizer(self, var, cost)
|
|
|
|
def AddVariableTargetToFinalizer(self, var: 'IntVar', target: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_AddVariableTargetToFinalizer(self, var, target)
|
|
|
|
def CloseModel(self) -> "void":
|
|
return _pywrapcp.RoutingModel_CloseModel(self)
|
|
|
|
def CloseModelWithParameters(self, search_parameters: 'operations_research::RoutingSearchParameters const &') -> "void":
|
|
return _pywrapcp.RoutingModel_CloseModelWithParameters(self, search_parameters)
|
|
|
|
def Solve(self, assignment: 'Assignment'=None) -> "operations_research::Assignment const *":
|
|
return _pywrapcp.RoutingModel_Solve(self, assignment)
|
|
|
|
def SolveWithParameters(self, search_parameters: 'operations_research::RoutingSearchParameters const &', solutions: 'std::vector< operations_research::Assignment const * > *'=None) -> "operations_research::Assignment const *":
|
|
return _pywrapcp.RoutingModel_SolveWithParameters(self, search_parameters, solutions)
|
|
|
|
def SolveFromAssignmentWithParameters(self, assignment: 'Assignment', search_parameters: 'operations_research::RoutingSearchParameters const &', solutions: 'std::vector< operations_research::Assignment const * > *'=None) -> "operations_research::Assignment const *":
|
|
return _pywrapcp.RoutingModel_SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions)
|
|
|
|
def SetAssignmentFromOtherModelAssignment(self, target_assignment: 'Assignment', source_model: 'RoutingModel', source_assignment: 'Assignment') -> "void":
|
|
return _pywrapcp.RoutingModel_SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment)
|
|
|
|
def ComputeLowerBound(self) -> "int64":
|
|
return _pywrapcp.RoutingModel_ComputeLowerBound(self)
|
|
|
|
def status(self) -> "operations_research::RoutingModel::Status":
|
|
return _pywrapcp.RoutingModel_status(self)
|
|
|
|
def ApplyLocks(self, locks: 'std::vector< int64 > const &') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_ApplyLocks(self, locks)
|
|
|
|
def ApplyLocksToAllVehicles(self, locks: 'std::vector< std::vector< int64 > > const &', close_routes: 'bool') -> "bool":
|
|
return _pywrapcp.RoutingModel_ApplyLocksToAllVehicles(self, locks, close_routes)
|
|
|
|
def PreAssignment(self) -> "operations_research::Assignment const *const":
|
|
return _pywrapcp.RoutingModel_PreAssignment(self)
|
|
|
|
def MutablePreAssignment(self) -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_MutablePreAssignment(self)
|
|
|
|
def WriteAssignment(self, file_name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_WriteAssignment(self, file_name)
|
|
|
|
def ReadAssignment(self, file_name: 'std::string const &') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_ReadAssignment(self, file_name)
|
|
|
|
def RestoreAssignment(self, solution: 'Assignment') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_RestoreAssignment(self, solution)
|
|
|
|
def ReadAssignmentFromRoutes(self, routes: 'std::vector< std::vector< int64 > > const &', ignore_inactive_indices: 'bool') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices)
|
|
|
|
def RoutesToAssignment(self, routes: 'std::vector< std::vector< int64 > > const &', ignore_inactive_indices: 'bool', close_routes: 'bool', assignment: 'Assignment') -> "bool":
|
|
return _pywrapcp.RoutingModel_RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment)
|
|
|
|
def AssignmentToRoutes(self, assignment: 'Assignment', routes: 'std::vector< std::vector< int64 > > *const') -> "void":
|
|
return _pywrapcp.RoutingModel_AssignmentToRoutes(self, assignment, routes)
|
|
|
|
def CompactAssignment(self, assignment: 'Assignment') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_CompactAssignment(self, assignment)
|
|
|
|
def CompactAndCheckAssignment(self, assignment: 'Assignment') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_CompactAndCheckAssignment(self, assignment)
|
|
|
|
def AddToAssignment(self, var: 'IntVar') -> "void":
|
|
return _pywrapcp.RoutingModel_AddToAssignment(self, var)
|
|
|
|
def AddIntervalToAssignment(self, interval: 'IntervalVar') -> "void":
|
|
return _pywrapcp.RoutingModel_AddIntervalToAssignment(self, interval)
|
|
|
|
def PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment: 'Assignment', duration_limit: 'absl::Duration') -> "operations_research::Assignment const *":
|
|
return _pywrapcp.RoutingModel_PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit)
|
|
|
|
def AddLocalSearchFilter(self, filter: 'LocalSearchFilter') -> "void":
|
|
return _pywrapcp.RoutingModel_AddLocalSearchFilter(self, filter)
|
|
|
|
def Start(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingModel_Start(self, vehicle)
|
|
|
|
def End(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingModel_End(self, vehicle)
|
|
|
|
def IsStart(self, index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingModel_IsStart(self, index)
|
|
|
|
def IsEnd(self, index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingModel_IsEnd(self, index)
|
|
|
|
def VehicleIndex(self, index: 'int') -> "int":
|
|
return _pywrapcp.RoutingModel_VehicleIndex(self, index)
|
|
|
|
def Next(self, assignment: 'Assignment', index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_Next(self, assignment, index)
|
|
|
|
def IsVehicleUsed(self, assignment: 'Assignment', vehicle: 'int') -> "bool":
|
|
return _pywrapcp.RoutingModel_IsVehicleUsed(self, assignment, vehicle)
|
|
|
|
def NextVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_NextVar(self, index)
|
|
|
|
def ActiveVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_ActiveVar(self, index)
|
|
|
|
def VehicleCostsConsideredVar(self, vehicle: 'int') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_VehicleCostsConsideredVar(self, vehicle)
|
|
|
|
def VehicleVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_VehicleVar(self, index)
|
|
|
|
def CostVar(self) -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_CostVar(self)
|
|
|
|
def GetArcCostForVehicle(self, from_index: 'int64', to_index: 'int64', vehicle: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetArcCostForVehicle(self, from_index, to_index, vehicle)
|
|
|
|
def CostsAreHomogeneousAcrossVehicles(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_CostsAreHomogeneousAcrossVehicles(self)
|
|
|
|
def GetHomogeneousCost(self, from_index: 'int64', to_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetHomogeneousCost(self, from_index, to_index)
|
|
|
|
def GetArcCostForFirstSolution(self, from_index: 'int64', to_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetArcCostForFirstSolution(self, from_index, to_index)
|
|
|
|
def GetArcCostForClass(self, from_index: 'int64', to_index: 'int64', cost_class_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetArcCostForClass(self, from_index, to_index, cost_class_index)
|
|
|
|
def GetCostClassIndexOfVehicle(self, vehicle: 'int64') -> "operations_research::RoutingModel::CostClassIndex":
|
|
return _pywrapcp.RoutingModel_GetCostClassIndexOfVehicle(self, vehicle)
|
|
|
|
def HasVehicleWithCostClassIndex(self, cost_class_index: 'operations_research::RoutingModel::CostClassIndex') -> "bool":
|
|
return _pywrapcp.RoutingModel_HasVehicleWithCostClassIndex(self, cost_class_index)
|
|
|
|
def GetCostClassesCount(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetCostClassesCount(self)
|
|
|
|
def GetNonZeroCostClassesCount(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetNonZeroCostClassesCount(self)
|
|
|
|
def GetVehicleClassIndexOfVehicle(self, vehicle: 'int64') -> "operations_research::RoutingModel::VehicleClassIndex":
|
|
return _pywrapcp.RoutingModel_GetVehicleClassIndexOfVehicle(self, vehicle)
|
|
|
|
def GetVehicleClassesCount(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetVehicleClassesCount(self)
|
|
|
|
def GetSameVehicleIndicesOfIndex(self, node: 'int') -> "std::vector< int > const &":
|
|
return _pywrapcp.RoutingModel_GetSameVehicleIndicesOfIndex(self, node)
|
|
|
|
def ArcIsMoreConstrainedThanArc(self, _from: 'int64', to1: 'int64', to2: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingModel_ArcIsMoreConstrainedThanArc(self, _from, to1, to2)
|
|
|
|
def DebugOutputAssignment(self, solution_assignment: 'Assignment', dimension_to_print: 'std::string const &') -> "std::string":
|
|
return _pywrapcp.RoutingModel_DebugOutputAssignment(self, solution_assignment, dimension_to_print)
|
|
|
|
def solver(self) -> "operations_research::Solver *":
|
|
return _pywrapcp.RoutingModel_solver(self)
|
|
|
|
def CheckLimit(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_CheckLimit(self)
|
|
|
|
def RemainingTime(self) -> "absl::Duration":
|
|
return _pywrapcp.RoutingModel_RemainingTime(self)
|
|
|
|
def nodes(self) -> "int":
|
|
return _pywrapcp.RoutingModel_nodes(self)
|
|
|
|
def vehicles(self) -> "int":
|
|
return _pywrapcp.RoutingModel_vehicles(self)
|
|
|
|
def Size(self) -> "int64":
|
|
return _pywrapcp.RoutingModel_Size(self)
|
|
|
|
def GetNumberOfDecisionsInFirstSolution(self, search_parameters: 'operations_research::RoutingSearchParameters const &') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetNumberOfDecisionsInFirstSolution(self, search_parameters)
|
|
|
|
def GetNumberOfRejectsInFirstSolution(self, search_parameters: 'operations_research::RoutingSearchParameters const &') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetNumberOfRejectsInFirstSolution(self, search_parameters)
|
|
|
|
def IsMatchingModel(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_IsMatchingModel(self)
|
|
|
|
def MakeGuidedSlackFinalizer(self, dimension: 'RoutingDimension', initializer: 'std::function< int64 (int64) >') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.RoutingModel_MakeGuidedSlackFinalizer(self, dimension, initializer)
|
|
|
|
def MakeSelfDependentDimensionFinalizer(self, dimension: 'RoutingDimension') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.RoutingModel_MakeSelfDependentDimensionFinalizer(self, dimension)
|
|
|
|
def AddMatrixDimension(self, *args) -> "void":
|
|
return _pywrapcp.RoutingModel_AddMatrixDimension(self, *args)
|
|
|
|
# Register RoutingModel in _pywrapcp:
|
|
_pywrapcp.RoutingModel_swigregister(RoutingModel)
|
|
cvar = _pywrapcp.cvar
|
|
RoutingModel.kNoPenalty = _pywrapcp.cvar.RoutingModel_kNoPenalty
|
|
RoutingModel.kNoDisjunction = _pywrapcp.cvar.RoutingModel_kNoDisjunction
|
|
RoutingModel.kNoDimension = _pywrapcp.cvar.RoutingModel_kNoDimension
|
|
|
|
class RoutingModelVisitor(BaseObject):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self):
|
|
_pywrapcp.RoutingModelVisitor_swiginit(self, _pywrapcp.new_RoutingModelVisitor())
|
|
__swig_destroy__ = _pywrapcp.delete_RoutingModelVisitor
|
|
|
|
# Register RoutingModelVisitor in _pywrapcp:
|
|
_pywrapcp.RoutingModelVisitor_swigregister(RoutingModelVisitor)
|
|
RoutingModelVisitor.kLightElement = _pywrapcp.cvar.RoutingModelVisitor_kLightElement
|
|
RoutingModelVisitor.kLightElement2 = _pywrapcp.cvar.RoutingModelVisitor_kLightElement2
|
|
RoutingModelVisitor.kRemoveValues = _pywrapcp.cvar.RoutingModelVisitor_kRemoveValues
|
|
|
|
class GlobalVehicleBreaksConstraint(Constraint):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, dimension: 'RoutingDimension'):
|
|
_pywrapcp.GlobalVehicleBreaksConstraint_swiginit(self, _pywrapcp.new_GlobalVehicleBreaksConstraint(dimension))
|
|
|
|
def Post(self) -> "void":
|
|
return _pywrapcp.GlobalVehicleBreaksConstraint_Post(self)
|
|
|
|
def InitialPropagateWrapper(self) -> "void":
|
|
return _pywrapcp.GlobalVehicleBreaksConstraint_InitialPropagateWrapper(self)
|
|
__swig_destroy__ = _pywrapcp.delete_GlobalVehicleBreaksConstraint
|
|
|
|
# Register GlobalVehicleBreaksConstraint in _pywrapcp:
|
|
_pywrapcp.GlobalVehicleBreaksConstraint_swigregister(GlobalVehicleBreaksConstraint)
|
|
|
|
class TypeRegulationsChecker(object):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_TypeRegulationsChecker
|
|
|
|
def CheckVehicle(self, vehicle: 'int', next_accessor: 'std::function< int64 (int64) > const &') -> "bool":
|
|
return _pywrapcp.TypeRegulationsChecker_CheckVehicle(self, vehicle, next_accessor)
|
|
|
|
# Register TypeRegulationsChecker in _pywrapcp:
|
|
_pywrapcp.TypeRegulationsChecker_swigregister(TypeRegulationsChecker)
|
|
|
|
class TypeIncompatibilityChecker(TypeRegulationsChecker):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, model: 'RoutingModel', check_hard_incompatibilities: 'bool'):
|
|
_pywrapcp.TypeIncompatibilityChecker_swiginit(self, _pywrapcp.new_TypeIncompatibilityChecker(model, check_hard_incompatibilities))
|
|
__swig_destroy__ = _pywrapcp.delete_TypeIncompatibilityChecker
|
|
|
|
# Register TypeIncompatibilityChecker in _pywrapcp:
|
|
_pywrapcp.TypeIncompatibilityChecker_swigregister(TypeIncompatibilityChecker)
|
|
|
|
class TypeRequirementChecker(TypeRegulationsChecker):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, model: 'RoutingModel'):
|
|
_pywrapcp.TypeRequirementChecker_swiginit(self, _pywrapcp.new_TypeRequirementChecker(model))
|
|
__swig_destroy__ = _pywrapcp.delete_TypeRequirementChecker
|
|
|
|
# Register TypeRequirementChecker in _pywrapcp:
|
|
_pywrapcp.TypeRequirementChecker_swigregister(TypeRequirementChecker)
|
|
|
|
class TypeRegulationsConstraint(Constraint):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, model: 'RoutingModel'):
|
|
_pywrapcp.TypeRegulationsConstraint_swiginit(self, _pywrapcp.new_TypeRegulationsConstraint(model))
|
|
|
|
def Post(self) -> "void":
|
|
return _pywrapcp.TypeRegulationsConstraint_Post(self)
|
|
|
|
def InitialPropagateWrapper(self) -> "void":
|
|
return _pywrapcp.TypeRegulationsConstraint_InitialPropagateWrapper(self)
|
|
__swig_destroy__ = _pywrapcp.delete_TypeRegulationsConstraint
|
|
|
|
# Register TypeRegulationsConstraint in _pywrapcp:
|
|
_pywrapcp.TypeRegulationsConstraint_swigregister(TypeRegulationsConstraint)
|
|
|
|
class RoutingDimension(object):
|
|
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
|
|
__swig_destroy__ = _pywrapcp.delete_RoutingDimension
|
|
|
|
def model(self) -> "operations_research::RoutingModel *":
|
|
return _pywrapcp.RoutingDimension_model(self)
|
|
|
|
def GetTransitValue(self, from_index: 'int64', to_index: 'int64', vehicle: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetTransitValue(self, from_index, to_index, vehicle)
|
|
|
|
def GetTransitValueFromClass(self, from_index: 'int64', to_index: 'int64', vehicle_class: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetTransitValueFromClass(self, from_index, to_index, vehicle_class)
|
|
|
|
def CumulVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingDimension_CumulVar(self, index)
|
|
|
|
def TransitVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingDimension_TransitVar(self, index)
|
|
|
|
def FixedTransitVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingDimension_FixedTransitVar(self, index)
|
|
|
|
def SlackVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingDimension_SlackVar(self, index)
|
|
|
|
def SetSpanUpperBoundForVehicle(self, upper_bound: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetSpanUpperBoundForVehicle(self, upper_bound, vehicle)
|
|
|
|
def SetSpanCostCoefficientForVehicle(self, coefficient: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForVehicle(self, coefficient, vehicle)
|
|
|
|
def SetSpanCostCoefficientForAllVehicles(self, coefficient: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForAllVehicles(self, coefficient)
|
|
|
|
def SetGlobalSpanCostCoefficient(self, coefficient: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetGlobalSpanCostCoefficient(self, coefficient)
|
|
|
|
def SetCumulVarSoftUpperBound(self, index: 'int64', upper_bound: 'int64', coefficient: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient)
|
|
|
|
def HasCumulVarSoftUpperBound(self, index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingDimension_HasCumulVarSoftUpperBound(self, index)
|
|
|
|
def GetCumulVarSoftUpperBound(self, index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBound(self, index)
|
|
|
|
def GetCumulVarSoftUpperBoundCoefficient(self, index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBoundCoefficient(self, index)
|
|
|
|
def SetCumulVarSoftLowerBound(self, index: 'int64', lower_bound: 'int64', coefficient: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient)
|
|
|
|
def HasCumulVarSoftLowerBound(self, index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingDimension_HasCumulVarSoftLowerBound(self, index)
|
|
|
|
def GetCumulVarSoftLowerBound(self, index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBound(self, index)
|
|
|
|
def GetCumulVarSoftLowerBoundCoefficient(self, index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBoundCoefficient(self, index)
|
|
|
|
def SetBreakIntervalsOfVehicle(self, breaks: 'std::vector< operations_research::IntervalVar * >', vehicle: 'int', node_visit_transits: 'std::vector< int64 >') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits)
|
|
|
|
def SetBreakDistanceDurationOfVehicle(self, distance: 'int64', duration: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle)
|
|
|
|
def InitializeBreaks(self) -> "void":
|
|
return _pywrapcp.RoutingDimension_InitializeBreaks(self)
|
|
|
|
def HasBreakConstraints(self) -> "bool":
|
|
return _pywrapcp.RoutingDimension_HasBreakConstraints(self)
|
|
|
|
def GetPreTravelEvaluatorOfVehicle(self, vehicle: 'int') -> "int":
|
|
return _pywrapcp.RoutingDimension_GetPreTravelEvaluatorOfVehicle(self, vehicle)
|
|
|
|
def GetPostTravelEvaluatorOfVehicle(self, vehicle: 'int') -> "int":
|
|
return _pywrapcp.RoutingDimension_GetPostTravelEvaluatorOfVehicle(self, vehicle)
|
|
|
|
def base_dimension(self) -> "operations_research::RoutingDimension const *":
|
|
return _pywrapcp.RoutingDimension_base_dimension(self)
|
|
|
|
def ShortestTransitionSlack(self, node: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_ShortestTransitionSlack(self, node)
|
|
|
|
def name(self) -> "std::string const &":
|
|
return _pywrapcp.RoutingDimension_name(self)
|
|
|
|
def SetPickupToDeliveryLimitFunctionForPair(self, limit_function: 'operations_research::RoutingDimension::PickupToDeliveryLimitFunction', pair_index: 'int') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index)
|
|
|
|
def HasPickupToDeliveryLimits(self) -> "bool":
|
|
return _pywrapcp.RoutingDimension_HasPickupToDeliveryLimits(self)
|
|
|
|
def AddNodePrecedence(self, first_node: 'int64', second_node: 'int64', offset: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_AddNodePrecedence(self, first_node, second_node, offset)
|
|
|
|
def GetSpanUpperBoundForVehicle(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetSpanUpperBoundForVehicle(self, vehicle)
|
|
|
|
def GetSpanCostCoefficientForVehicle(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetSpanCostCoefficientForVehicle(self, vehicle)
|
|
|
|
def global_span_cost_coefficient(self) -> "int64":
|
|
return _pywrapcp.RoutingDimension_global_span_cost_coefficient(self)
|
|
|
|
def GetGlobalOptimizerOffset(self) -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetGlobalOptimizerOffset(self)
|
|
|
|
def GetLocalOptimizerOffsetForVehicle(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetLocalOptimizerOffsetForVehicle(self, vehicle)
|
|
|
|
# Register RoutingDimension in _pywrapcp:
|
|
_pywrapcp.RoutingDimension_swigregister(RoutingDimension)
|
|
|
|
|
|
def MakeSetValuesFromTargets(solver: 'Solver', variables: 'std::vector< operations_research::IntVar * >', targets: 'std::vector< int64 >') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.MakeSetValuesFromTargets(solver, variables, targets)
|
|
class IntVarFilteredDecisionBuilder(DecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_IntVarFilteredDecisionBuilder
|
|
|
|
def NextWrapper(self, solver: 'Solver') -> "operations_research::Decision *":
|
|
return _pywrapcp.IntVarFilteredDecisionBuilder_NextWrapper(self, solver)
|
|
|
|
def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.IntVarFilteredDecisionBuilder_BuildSolution(self)
|
|
|
|
def number_of_decisions(self) -> "int64":
|
|
return _pywrapcp.IntVarFilteredDecisionBuilder_number_of_decisions(self)
|
|
|
|
def number_of_rejects(self) -> "int64":
|
|
return _pywrapcp.IntVarFilteredDecisionBuilder_number_of_rejects(self)
|
|
|
|
# Register IntVarFilteredDecisionBuilder in _pywrapcp:
|
|
_pywrapcp.IntVarFilteredDecisionBuilder_swigregister(IntVarFilteredDecisionBuilder)
|
|
|
|
class RoutingFilteredDecisionBuilder(IntVarFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_RoutingFilteredDecisionBuilder
|
|
|
|
def model(self) -> "operations_research::RoutingModel *":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_model(self)
|
|
|
|
def GetStartChainEnd(self, vehicle: 'int') -> "int":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_GetStartChainEnd(self, vehicle)
|
|
|
|
def GetEndChainStart(self, vehicle: 'int') -> "int":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_GetEndChainStart(self, vehicle)
|
|
|
|
def MakeDisjunctionNodesUnperformed(self, node: 'int64') -> "void":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_MakeDisjunctionNodesUnperformed(self, node)
|
|
|
|
def MakeUnassignedNodesUnperformed(self) -> "void":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_MakeUnassignedNodesUnperformed(self)
|
|
|
|
# Register RoutingFilteredDecisionBuilder in _pywrapcp:
|
|
_pywrapcp.RoutingFilteredDecisionBuilder_swigregister(RoutingFilteredDecisionBuilder)
|
|
|
|
class CheapestInsertionFilteredDecisionBuilder(RoutingFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_CheapestInsertionFilteredDecisionBuilder
|
|
|
|
# Register CheapestInsertionFilteredDecisionBuilder in _pywrapcp:
|
|
_pywrapcp.CheapestInsertionFilteredDecisionBuilder_swigregister(CheapestInsertionFilteredDecisionBuilder)
|
|
|
|
class GlobalCheapestInsertionFilteredDecisionBuilder(CheapestInsertionFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_GlobalCheapestInsertionFilteredDecisionBuilder
|
|
|
|
def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder_BuildSolution(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder_DebugString(self)
|
|
|
|
# Register GlobalCheapestInsertionFilteredDecisionBuilder in _pywrapcp:
|
|
_pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder_swigregister(GlobalCheapestInsertionFilteredDecisionBuilder)
|
|
|
|
class LocalCheapestInsertionFilteredDecisionBuilder(CheapestInsertionFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_LocalCheapestInsertionFilteredDecisionBuilder
|
|
|
|
def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder_BuildSolution(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder_DebugString(self)
|
|
|
|
# Register LocalCheapestInsertionFilteredDecisionBuilder in _pywrapcp:
|
|
_pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder_swigregister(LocalCheapestInsertionFilteredDecisionBuilder)
|
|
|
|
class CheapestAdditionFilteredDecisionBuilder(RoutingFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_CheapestAdditionFilteredDecisionBuilder
|
|
|
|
def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.CheapestAdditionFilteredDecisionBuilder_BuildSolution(self)
|
|
|
|
# Register CheapestAdditionFilteredDecisionBuilder in _pywrapcp:
|
|
_pywrapcp.CheapestAdditionFilteredDecisionBuilder_swigregister(CheapestAdditionFilteredDecisionBuilder)
|
|
|
|
class EvaluatorCheapestAdditionFilteredDecisionBuilder(CheapestAdditionFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_EvaluatorCheapestAdditionFilteredDecisionBuilder
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.EvaluatorCheapestAdditionFilteredDecisionBuilder_DebugString(self)
|
|
|
|
# Register EvaluatorCheapestAdditionFilteredDecisionBuilder in _pywrapcp:
|
|
_pywrapcp.EvaluatorCheapestAdditionFilteredDecisionBuilder_swigregister(EvaluatorCheapestAdditionFilteredDecisionBuilder)
|
|
|
|
class ComparatorCheapestAdditionFilteredDecisionBuilder(CheapestAdditionFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_ComparatorCheapestAdditionFilteredDecisionBuilder
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.ComparatorCheapestAdditionFilteredDecisionBuilder_DebugString(self)
|
|
|
|
# Register ComparatorCheapestAdditionFilteredDecisionBuilder in _pywrapcp:
|
|
_pywrapcp.ComparatorCheapestAdditionFilteredDecisionBuilder_swigregister(ComparatorCheapestAdditionFilteredDecisionBuilder)
|
|
|
|
class SavingsFilteredDecisionBuilder(RoutingFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_SavingsFilteredDecisionBuilder
|
|
|
|
def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.SavingsFilteredDecisionBuilder_BuildSolution(self)
|
|
|
|
# Register SavingsFilteredDecisionBuilder in _pywrapcp:
|
|
_pywrapcp.SavingsFilteredDecisionBuilder_swigregister(SavingsFilteredDecisionBuilder)
|
|
|
|
class SequentialSavingsFilteredDecisionBuilder(SavingsFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_SequentialSavingsFilteredDecisionBuilder
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.SequentialSavingsFilteredDecisionBuilder_DebugString(self)
|
|
|
|
# Register SequentialSavingsFilteredDecisionBuilder in _pywrapcp:
|
|
_pywrapcp.SequentialSavingsFilteredDecisionBuilder_swigregister(SequentialSavingsFilteredDecisionBuilder)
|
|
|
|
class ParallelSavingsFilteredDecisionBuilder(SavingsFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_ParallelSavingsFilteredDecisionBuilder
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.ParallelSavingsFilteredDecisionBuilder_DebugString(self)
|
|
|
|
# Register ParallelSavingsFilteredDecisionBuilder in _pywrapcp:
|
|
_pywrapcp.ParallelSavingsFilteredDecisionBuilder_swigregister(ParallelSavingsFilteredDecisionBuilder)
|
|
|
|
class ChristofidesFilteredDecisionBuilder(RoutingFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_ChristofidesFilteredDecisionBuilder
|
|
|
|
def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.ChristofidesFilteredDecisionBuilder_BuildSolution(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.ChristofidesFilteredDecisionBuilder_DebugString(self)
|
|
|
|
# Register ChristofidesFilteredDecisionBuilder in _pywrapcp:
|
|
_pywrapcp.ChristofidesFilteredDecisionBuilder_swigregister(ChristofidesFilteredDecisionBuilder)
|
|
|
|
|
|
def SolveModelWithSat(model: 'RoutingModel', initial_solution: 'Assignment', solution: 'Assignment') -> "bool":
|
|
return _pywrapcp.SolveModelWithSat(model, initial_solution, solution)
|
|
class BasePathFilter(IntVarLocalSearchFilter):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_BasePathFilter
|
|
|
|
def Accept(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
return _pywrapcp.BasePathFilter_Accept(self, delta, deltadelta)
|
|
|
|
def OnSynchronize(self, delta: 'Assignment') -> "void":
|
|
return _pywrapcp.BasePathFilter_OnSynchronize(self, delta)
|
|
|
|
# Register BasePathFilter in _pywrapcp:
|
|
_pywrapcp.BasePathFilter_swigregister(BasePathFilter)
|
|
|
|
class CPFeasibilityFilter(IntVarLocalSearchFilter):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, routing_model: 'RoutingModel'):
|
|
_pywrapcp.CPFeasibilityFilter_swiginit(self, _pywrapcp.new_CPFeasibilityFilter(routing_model))
|
|
__swig_destroy__ = _pywrapcp.delete_CPFeasibilityFilter
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.CPFeasibilityFilter_DebugString(self)
|
|
|
|
def Accept(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
return _pywrapcp.CPFeasibilityFilter_Accept(self, delta, deltadelta)
|
|
|
|
def OnSynchronize(self, delta: 'Assignment') -> "void":
|
|
return _pywrapcp.CPFeasibilityFilter_OnSynchronize(self, delta)
|
|
|
|
# Register CPFeasibilityFilter in _pywrapcp:
|
|
_pywrapcp.CPFeasibilityFilter_swigregister(CPFeasibilityFilter)</code></pre>
|
|
</details>
|
|
</section>
|
|
<section>
|
|
</section>
|
|
<section>
|
|
</section>
|
|
<section>
|
|
<h2 class="section-title" id="header-functions">Functions</h2>
|
|
<dl>
|
|
<dt id="pywrapcp.DefaultRoutingModelParameters"><code class="name flex">
|
|
<span>def <span class="ident">DefaultRoutingModelParameters</span></span>(<span>)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DefaultRoutingModelParameters() -> "operations_research::RoutingModelParameters":
|
|
return _pywrapcp.DefaultRoutingModelParameters()</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultRoutingSearchParameters"><code class="name flex">
|
|
<span>def <span class="ident">DefaultRoutingSearchParameters</span></span>(<span>)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DefaultRoutingSearchParameters() -> "operations_research::RoutingSearchParameters":
|
|
return _pywrapcp.DefaultRoutingSearchParameters()</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.FindErrorInRoutingSearchParameters"><code class="name flex">
|
|
<span>def <span class="ident">FindErrorInRoutingSearchParameters</span></span>(<span>search_parameters)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns an empty std::string if the routing search parameters are valid, and a non-empty, human readable error description if they're not.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FindErrorInRoutingSearchParameters(search_parameters: 'operations_research::RoutingSearchParameters const &') -> "std::string":
|
|
r""" Returns an empty std::string if the routing search parameters are valid, and a non-empty, human readable error description if they're not."""
|
|
return _pywrapcp.FindErrorInRoutingSearchParameters(search_parameters)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.MakeSetValuesFromTargets"><code class="name flex">
|
|
<span>def <span class="ident">MakeSetValuesFromTargets</span></span>(<span>solver, variables, targets)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MakeSetValuesFromTargets(solver: 'Solver', variables: 'std::vector< operations_research::IntVar * >', targets: 'std::vector< int64 >') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.MakeSetValuesFromTargets(solver, variables, targets)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolveModelWithSat"><code class="name flex">
|
|
<span>def <span class="ident">SolveModelWithSat</span></span>(<span>model, initial_solution, solution)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SolveModelWithSat(model: 'RoutingModel', initial_solution: 'Assignment', solution: 'Assignment') -> "bool":
|
|
return _pywrapcp.SolveModelWithSat(model, initial_solution, solution)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver_DefaultSolverParameters"><code class="name flex">
|
|
<span>def <span class="ident">Solver_DefaultSolverParameters</span></span>(<span>)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Create a ConstraintSolverParameters proto with all the default values.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Solver_DefaultSolverParameters() -> "operations_research::ConstraintSolverParameters":
|
|
r""" Create a ConstraintSolverParameters proto with all the default values."""
|
|
return _pywrapcp.Solver_DefaultSolverParameters()</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver_MemoryUsage"><code class="name flex">
|
|
<span>def <span class="ident">Solver_MemoryUsage</span></span>(<span>)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Current memory usage in bytes</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Solver_MemoryUsage() -> "int64":
|
|
r""" Current memory usage in bytes"""
|
|
return _pywrapcp.Solver_MemoryUsage()</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
</section>
|
|
<section>
|
|
<h2 class="section-title" id="header-classes">Classes</h2>
|
|
<dl>
|
|
<dt id="pywrapcp.Assignment"><code class="flex name class">
|
|
<span>class <span class="ident">Assignment</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>An Assignment is a variable -> domains mapping, used to report solutions to the user.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class Assignment(PropagationBaseObject):
|
|
r""" An Assignment is a variable -> domains mapping, used to report solutions to the user."""
|
|
|
|
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":
|
|
return _pywrapcp.Assignment_Clear(self)
|
|
|
|
def Empty(self) -> "bool":
|
|
return _pywrapcp.Assignment_Empty(self)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.Assignment_Size(self)
|
|
|
|
def NumIntVars(self) -> "int":
|
|
return _pywrapcp.Assignment_NumIntVars(self)
|
|
|
|
def NumIntervalVars(self) -> "int":
|
|
return _pywrapcp.Assignment_NumIntervalVars(self)
|
|
|
|
def NumSequenceVars(self) -> "int":
|
|
return _pywrapcp.Assignment_NumSequenceVars(self)
|
|
|
|
def Store(self) -> "void":
|
|
return _pywrapcp.Assignment_Store(self)
|
|
|
|
def Restore(self) -> "void":
|
|
return _pywrapcp.Assignment_Restore(self)
|
|
|
|
def Load(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Load(self, *args)
|
|
|
|
def Save(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Save(self, *args)
|
|
|
|
def AddObjective(self, v: 'IntVar') -> "void":
|
|
return _pywrapcp.Assignment_AddObjective(self, v)
|
|
|
|
def Objective(self) -> "operations_research::IntVar *":
|
|
return _pywrapcp.Assignment_Objective(self)
|
|
|
|
def HasObjective(self) -> "bool":
|
|
return _pywrapcp.Assignment_HasObjective(self)
|
|
|
|
def ObjectiveMin(self) -> "int64":
|
|
return _pywrapcp.Assignment_ObjectiveMin(self)
|
|
|
|
def ObjectiveMax(self) -> "int64":
|
|
return _pywrapcp.Assignment_ObjectiveMax(self)
|
|
|
|
def ObjectiveValue(self) -> "int64":
|
|
return _pywrapcp.Assignment_ObjectiveValue(self)
|
|
|
|
def ObjectiveBound(self) -> "bool":
|
|
return _pywrapcp.Assignment_ObjectiveBound(self)
|
|
|
|
def SetObjectiveMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetObjectiveMin(self, m)
|
|
|
|
def SetObjectiveMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetObjectiveMax(self, m)
|
|
|
|
def SetObjectiveValue(self, value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetObjectiveValue(self, value)
|
|
|
|
def SetObjectiveRange(self, l: 'int64', u: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetObjectiveRange(self, l, u)
|
|
|
|
def Min(self, var: 'IntVar') -> "int64":
|
|
return _pywrapcp.Assignment_Min(self, var)
|
|
|
|
def Max(self, var: 'IntVar') -> "int64":
|
|
return _pywrapcp.Assignment_Max(self, var)
|
|
|
|
def Value(self, var: 'IntVar') -> "int64":
|
|
return _pywrapcp.Assignment_Value(self, var)
|
|
|
|
def Bound(self, var: 'IntVar') -> "bool":
|
|
return _pywrapcp.Assignment_Bound(self, var)
|
|
|
|
def SetMin(self, var: 'IntVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetMin(self, var, m)
|
|
|
|
def SetMax(self, var: 'IntVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetMax(self, var, m)
|
|
|
|
def SetRange(self, var: 'IntVar', l: 'int64', u: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetRange(self, var, l, u)
|
|
|
|
def SetValue(self, var: 'IntVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetValue(self, var, value)
|
|
|
|
def StartMin(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_StartMin(self, var)
|
|
|
|
def StartMax(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_StartMax(self, var)
|
|
|
|
def StartValue(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_StartValue(self, var)
|
|
|
|
def DurationMin(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_DurationMin(self, var)
|
|
|
|
def DurationMax(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_DurationMax(self, var)
|
|
|
|
def DurationValue(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_DurationValue(self, var)
|
|
|
|
def EndMin(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_EndMin(self, var)
|
|
|
|
def EndMax(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_EndMax(self, var)
|
|
|
|
def EndValue(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_EndValue(self, var)
|
|
|
|
def PerformedMin(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_PerformedMin(self, var)
|
|
|
|
def PerformedMax(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_PerformedMax(self, var)
|
|
|
|
def PerformedValue(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_PerformedValue(self, var)
|
|
|
|
def SetStartMin(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetStartMin(self, var, m)
|
|
|
|
def SetStartMax(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetStartMax(self, var, m)
|
|
|
|
def SetStartRange(self, var: 'IntervalVar', mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetStartRange(self, var, mi, ma)
|
|
|
|
def SetStartValue(self, var: 'IntervalVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetStartValue(self, var, value)
|
|
|
|
def SetDurationMin(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetDurationMin(self, var, m)
|
|
|
|
def SetDurationMax(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetDurationMax(self, var, m)
|
|
|
|
def SetDurationRange(self, var: 'IntervalVar', mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetDurationRange(self, var, mi, ma)
|
|
|
|
def SetDurationValue(self, var: 'IntervalVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetDurationValue(self, var, value)
|
|
|
|
def SetEndMin(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetEndMin(self, var, m)
|
|
|
|
def SetEndMax(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetEndMax(self, var, m)
|
|
|
|
def SetEndRange(self, var: 'IntervalVar', mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetEndRange(self, var, mi, ma)
|
|
|
|
def SetEndValue(self, var: 'IntervalVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetEndValue(self, var, value)
|
|
|
|
def SetPerformedMin(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetPerformedMin(self, var, m)
|
|
|
|
def SetPerformedMax(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetPerformedMax(self, var, m)
|
|
|
|
def SetPerformedRange(self, var: 'IntervalVar', mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetPerformedRange(self, var, mi, ma)
|
|
|
|
def SetPerformedValue(self, var: 'IntervalVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetPerformedValue(self, var, value)
|
|
|
|
def Add(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Add(self, *args)
|
|
|
|
def ForwardSequence(self, var: 'SequenceVar') -> "std::vector< int > const &":
|
|
return _pywrapcp.Assignment_ForwardSequence(self, var)
|
|
|
|
def BackwardSequence(self, var: 'SequenceVar') -> "std::vector< int > const &":
|
|
return _pywrapcp.Assignment_BackwardSequence(self, var)
|
|
|
|
def Unperformed(self, var: 'SequenceVar') -> "std::vector< int > const &":
|
|
return _pywrapcp.Assignment_Unperformed(self, var)
|
|
|
|
def SetSequence(self, var: 'SequenceVar', forward_sequence: 'std::vector< int > const &', backward_sequence: 'std::vector< int > const &', unperformed: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.Assignment_SetSequence(self, var, forward_sequence, backward_sequence, unperformed)
|
|
|
|
def SetForwardSequence(self, var: 'SequenceVar', forward_sequence: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.Assignment_SetForwardSequence(self, var, forward_sequence)
|
|
|
|
def SetBackwardSequence(self, var: 'SequenceVar', backward_sequence: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.Assignment_SetBackwardSequence(self, var, backward_sequence)
|
|
|
|
def SetUnperformed(self, var: 'SequenceVar', unperformed: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.Assignment_SetUnperformed(self, var, unperformed)
|
|
|
|
def Activate(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Activate(self, *args)
|
|
|
|
def Deactivate(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Deactivate(self, *args)
|
|
|
|
def Activated(self, *args) -> "bool":
|
|
return _pywrapcp.Assignment_Activated(self, *args)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Assignment_DebugString(self)
|
|
|
|
def IntVarContainer(self) -> "operations_research::Assignment::IntContainer const &":
|
|
return _pywrapcp.Assignment_IntVarContainer(self)
|
|
|
|
def MutableIntVarContainer(self) -> "operations_research::Assignment::IntContainer *":
|
|
return _pywrapcp.Assignment_MutableIntVarContainer(self)
|
|
|
|
def IntervalVarContainer(self) -> "operations_research::Assignment::IntervalContainer const &":
|
|
return _pywrapcp.Assignment_IntervalVarContainer(self)
|
|
|
|
def MutableIntervalVarContainer(self) -> "operations_research::Assignment::IntervalContainer *":
|
|
return _pywrapcp.Assignment_MutableIntervalVarContainer(self)
|
|
|
|
def SequenceVarContainer(self) -> "operations_research::Assignment::SequenceContainer const &":
|
|
return _pywrapcp.Assignment_SequenceVarContainer(self)
|
|
|
|
def MutableSequenceVarContainer(self) -> "operations_research::Assignment::SequenceContainer *":
|
|
return _pywrapcp.Assignment_MutableSequenceVarContainer(self)
|
|
|
|
def __eq__(self, assignment: 'Assignment') -> "bool":
|
|
return _pywrapcp.Assignment___eq__(self, assignment)
|
|
|
|
def __ne__(self, assignment: 'Assignment') -> "bool":
|
|
return _pywrapcp.Assignment___ne__(self, assignment)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.Assignment.Activate"><code class="name flex">
|
|
<span>def <span class="ident">Activate</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Activate(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Activate(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Activated"><code class="name flex">
|
|
<span>def <span class="ident">Activated</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Activated(self, *args) -> "bool":
|
|
return _pywrapcp.Assignment_Activated(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Add"><code class="name flex">
|
|
<span>def <span class="ident">Add</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Add(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Add(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.AddObjective"><code class="name flex">
|
|
<span>def <span class="ident">AddObjective</span></span>(<span>self, v)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddObjective(self, v: 'IntVar') -> "void":
|
|
return _pywrapcp.Assignment_AddObjective(self, v)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.BackwardSequence"><code class="name flex">
|
|
<span>def <span class="ident">BackwardSequence</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BackwardSequence(self, var: 'SequenceVar') -> "std::vector< int > const &":
|
|
return _pywrapcp.Assignment_BackwardSequence(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Bound"><code class="name flex">
|
|
<span>def <span class="ident">Bound</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Bound(self, var: 'IntVar') -> "bool":
|
|
return _pywrapcp.Assignment_Bound(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Clear"><code class="name flex">
|
|
<span>def <span class="ident">Clear</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Clear(self) -> "void":
|
|
return _pywrapcp.Assignment_Clear(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Deactivate"><code class="name flex">
|
|
<span>def <span class="ident">Deactivate</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Deactivate(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Deactivate(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Assignment_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.DurationMax"><code class="name flex">
|
|
<span>def <span class="ident">DurationMax</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DurationMax(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_DurationMax(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.DurationMin"><code class="name flex">
|
|
<span>def <span class="ident">DurationMin</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DurationMin(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_DurationMin(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.DurationValue"><code class="name flex">
|
|
<span>def <span class="ident">DurationValue</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DurationValue(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_DurationValue(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Empty"><code class="name flex">
|
|
<span>def <span class="ident">Empty</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Empty(self) -> "bool":
|
|
return _pywrapcp.Assignment_Empty(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.EndMax"><code class="name flex">
|
|
<span>def <span class="ident">EndMax</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndMax(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_EndMax(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.EndMin"><code class="name flex">
|
|
<span>def <span class="ident">EndMin</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndMin(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_EndMin(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.EndValue"><code class="name flex">
|
|
<span>def <span class="ident">EndValue</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndValue(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_EndValue(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.ForwardSequence"><code class="name flex">
|
|
<span>def <span class="ident">ForwardSequence</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ForwardSequence(self, var: 'SequenceVar') -> "std::vector< int > const &":
|
|
return _pywrapcp.Assignment_ForwardSequence(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.HasObjective"><code class="name flex">
|
|
<span>def <span class="ident">HasObjective</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HasObjective(self) -> "bool":
|
|
return _pywrapcp.Assignment_HasObjective(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.IntVarContainer"><code class="name flex">
|
|
<span>def <span class="ident">IntVarContainer</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IntVarContainer(self) -> "operations_research::Assignment::IntContainer const &":
|
|
return _pywrapcp.Assignment_IntVarContainer(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.IntervalVarContainer"><code class="name flex">
|
|
<span>def <span class="ident">IntervalVarContainer</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IntervalVarContainer(self) -> "operations_research::Assignment::IntervalContainer const &":
|
|
return _pywrapcp.Assignment_IntervalVarContainer(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Load"><code class="name flex">
|
|
<span>def <span class="ident">Load</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Load(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Load(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Max"><code class="name flex">
|
|
<span>def <span class="ident">Max</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Max(self, var: 'IntVar') -> "int64":
|
|
return _pywrapcp.Assignment_Max(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Min"><code class="name flex">
|
|
<span>def <span class="ident">Min</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Min(self, var: 'IntVar') -> "int64":
|
|
return _pywrapcp.Assignment_Min(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.MutableIntVarContainer"><code class="name flex">
|
|
<span>def <span class="ident">MutableIntVarContainer</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MutableIntVarContainer(self) -> "operations_research::Assignment::IntContainer *":
|
|
return _pywrapcp.Assignment_MutableIntVarContainer(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.MutableIntervalVarContainer"><code class="name flex">
|
|
<span>def <span class="ident">MutableIntervalVarContainer</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MutableIntervalVarContainer(self) -> "operations_research::Assignment::IntervalContainer *":
|
|
return _pywrapcp.Assignment_MutableIntervalVarContainer(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.MutableSequenceVarContainer"><code class="name flex">
|
|
<span>def <span class="ident">MutableSequenceVarContainer</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MutableSequenceVarContainer(self) -> "operations_research::Assignment::SequenceContainer *":
|
|
return _pywrapcp.Assignment_MutableSequenceVarContainer(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.NumIntVars"><code class="name flex">
|
|
<span>def <span class="ident">NumIntVars</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NumIntVars(self) -> "int":
|
|
return _pywrapcp.Assignment_NumIntVars(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.NumIntervalVars"><code class="name flex">
|
|
<span>def <span class="ident">NumIntervalVars</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NumIntervalVars(self) -> "int":
|
|
return _pywrapcp.Assignment_NumIntervalVars(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.NumSequenceVars"><code class="name flex">
|
|
<span>def <span class="ident">NumSequenceVars</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NumSequenceVars(self) -> "int":
|
|
return _pywrapcp.Assignment_NumSequenceVars(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Objective"><code class="name flex">
|
|
<span>def <span class="ident">Objective</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Objective(self) -> "operations_research::IntVar *":
|
|
return _pywrapcp.Assignment_Objective(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.ObjectiveBound"><code class="name flex">
|
|
<span>def <span class="ident">ObjectiveBound</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ObjectiveBound(self) -> "bool":
|
|
return _pywrapcp.Assignment_ObjectiveBound(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.ObjectiveMax"><code class="name flex">
|
|
<span>def <span class="ident">ObjectiveMax</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ObjectiveMax(self) -> "int64":
|
|
return _pywrapcp.Assignment_ObjectiveMax(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.ObjectiveMin"><code class="name flex">
|
|
<span>def <span class="ident">ObjectiveMin</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ObjectiveMin(self) -> "int64":
|
|
return _pywrapcp.Assignment_ObjectiveMin(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.ObjectiveValue"><code class="name flex">
|
|
<span>def <span class="ident">ObjectiveValue</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ObjectiveValue(self) -> "int64":
|
|
return _pywrapcp.Assignment_ObjectiveValue(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.PerformedMax"><code class="name flex">
|
|
<span>def <span class="ident">PerformedMax</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def PerformedMax(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_PerformedMax(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.PerformedMin"><code class="name flex">
|
|
<span>def <span class="ident">PerformedMin</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def PerformedMin(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_PerformedMin(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.PerformedValue"><code class="name flex">
|
|
<span>def <span class="ident">PerformedValue</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def PerformedValue(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_PerformedValue(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Restore"><code class="name flex">
|
|
<span>def <span class="ident">Restore</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Restore(self) -> "void":
|
|
return _pywrapcp.Assignment_Restore(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Save"><code class="name flex">
|
|
<span>def <span class="ident">Save</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Save(self, *args) -> "void":
|
|
return _pywrapcp.Assignment_Save(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SequenceVarContainer"><code class="name flex">
|
|
<span>def <span class="ident">SequenceVarContainer</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SequenceVarContainer(self) -> "operations_research::Assignment::SequenceContainer const &":
|
|
return _pywrapcp.Assignment_SequenceVarContainer(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetBackwardSequence"><code class="name flex">
|
|
<span>def <span class="ident">SetBackwardSequence</span></span>(<span>self, var, backward_sequence)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetBackwardSequence(self, var: 'SequenceVar', backward_sequence: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.Assignment_SetBackwardSequence(self, var, backward_sequence)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetDurationMax"><code class="name flex">
|
|
<span>def <span class="ident">SetDurationMax</span></span>(<span>self, var, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetDurationMax(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetDurationMax(self, var, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetDurationMin"><code class="name flex">
|
|
<span>def <span class="ident">SetDurationMin</span></span>(<span>self, var, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetDurationMin(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetDurationMin(self, var, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetDurationRange"><code class="name flex">
|
|
<span>def <span class="ident">SetDurationRange</span></span>(<span>self, var, mi, ma)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetDurationRange(self, var: 'IntervalVar', mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetDurationRange(self, var, mi, ma)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetDurationValue"><code class="name flex">
|
|
<span>def <span class="ident">SetDurationValue</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetDurationValue(self, var: 'IntervalVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetDurationValue(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetEndMax"><code class="name flex">
|
|
<span>def <span class="ident">SetEndMax</span></span>(<span>self, var, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetEndMax(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetEndMax(self, var, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetEndMin"><code class="name flex">
|
|
<span>def <span class="ident">SetEndMin</span></span>(<span>self, var, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetEndMin(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetEndMin(self, var, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetEndRange"><code class="name flex">
|
|
<span>def <span class="ident">SetEndRange</span></span>(<span>self, var, mi, ma)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetEndRange(self, var: 'IntervalVar', mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetEndRange(self, var, mi, ma)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetEndValue"><code class="name flex">
|
|
<span>def <span class="ident">SetEndValue</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetEndValue(self, var: 'IntervalVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetEndValue(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetForwardSequence"><code class="name flex">
|
|
<span>def <span class="ident">SetForwardSequence</span></span>(<span>self, var, forward_sequence)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetForwardSequence(self, var: 'SequenceVar', forward_sequence: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.Assignment_SetForwardSequence(self, var, forward_sequence)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetMax"><code class="name flex">
|
|
<span>def <span class="ident">SetMax</span></span>(<span>self, var, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetMax(self, var: 'IntVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetMax(self, var, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetMin"><code class="name flex">
|
|
<span>def <span class="ident">SetMin</span></span>(<span>self, var, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetMin(self, var: 'IntVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetMin(self, var, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetObjectiveMax"><code class="name flex">
|
|
<span>def <span class="ident">SetObjectiveMax</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetObjectiveMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetObjectiveMax(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetObjectiveMin"><code class="name flex">
|
|
<span>def <span class="ident">SetObjectiveMin</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetObjectiveMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetObjectiveMin(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetObjectiveRange"><code class="name flex">
|
|
<span>def <span class="ident">SetObjectiveRange</span></span>(<span>self, l, u)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetObjectiveRange(self, l: 'int64', u: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetObjectiveRange(self, l, u)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetObjectiveValue"><code class="name flex">
|
|
<span>def <span class="ident">SetObjectiveValue</span></span>(<span>self, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetObjectiveValue(self, value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetObjectiveValue(self, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetPerformedMax"><code class="name flex">
|
|
<span>def <span class="ident">SetPerformedMax</span></span>(<span>self, var, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetPerformedMax(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetPerformedMax(self, var, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetPerformedMin"><code class="name flex">
|
|
<span>def <span class="ident">SetPerformedMin</span></span>(<span>self, var, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetPerformedMin(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetPerformedMin(self, var, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetPerformedRange"><code class="name flex">
|
|
<span>def <span class="ident">SetPerformedRange</span></span>(<span>self, var, mi, ma)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetPerformedRange(self, var: 'IntervalVar', mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetPerformedRange(self, var, mi, ma)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetPerformedValue"><code class="name flex">
|
|
<span>def <span class="ident">SetPerformedValue</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetPerformedValue(self, var: 'IntervalVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetPerformedValue(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetRange"><code class="name flex">
|
|
<span>def <span class="ident">SetRange</span></span>(<span>self, var, l, u)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetRange(self, var: 'IntVar', l: 'int64', u: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetRange(self, var, l, u)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetSequence"><code class="name flex">
|
|
<span>def <span class="ident">SetSequence</span></span>(<span>self, var, forward_sequence, backward_sequence, unperformed)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetSequence(self, var: 'SequenceVar', forward_sequence: 'std::vector< int > const &', backward_sequence: 'std::vector< int > const &', unperformed: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.Assignment_SetSequence(self, var, forward_sequence, backward_sequence, unperformed)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetStartMax"><code class="name flex">
|
|
<span>def <span class="ident">SetStartMax</span></span>(<span>self, var, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetStartMax(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetStartMax(self, var, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetStartMin"><code class="name flex">
|
|
<span>def <span class="ident">SetStartMin</span></span>(<span>self, var, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetStartMin(self, var: 'IntervalVar', m: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetStartMin(self, var, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetStartRange"><code class="name flex">
|
|
<span>def <span class="ident">SetStartRange</span></span>(<span>self, var, mi, ma)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetStartRange(self, var: 'IntervalVar', mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetStartRange(self, var, mi, ma)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetStartValue"><code class="name flex">
|
|
<span>def <span class="ident">SetStartValue</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetStartValue(self, var: 'IntervalVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetStartValue(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetUnperformed"><code class="name flex">
|
|
<span>def <span class="ident">SetUnperformed</span></span>(<span>self, var, unperformed)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetUnperformed(self, var: 'SequenceVar', unperformed: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.Assignment_SetUnperformed(self, var, unperformed)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.SetValue"><code class="name flex">
|
|
<span>def <span class="ident">SetValue</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetValue(self, var: 'IntVar', value: 'int64') -> "void":
|
|
return _pywrapcp.Assignment_SetValue(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Size"><code class="name flex">
|
|
<span>def <span class="ident">Size</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Size(self) -> "int":
|
|
return _pywrapcp.Assignment_Size(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.StartMax"><code class="name flex">
|
|
<span>def <span class="ident">StartMax</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartMax(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_StartMax(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.StartMin"><code class="name flex">
|
|
<span>def <span class="ident">StartMin</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartMin(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_StartMin(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.StartValue"><code class="name flex">
|
|
<span>def <span class="ident">StartValue</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartValue(self, var: 'IntervalVar') -> "int64":
|
|
return _pywrapcp.Assignment_StartValue(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Store"><code class="name flex">
|
|
<span>def <span class="ident">Store</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Store(self) -> "void":
|
|
return _pywrapcp.Assignment_Store(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Unperformed"><code class="name flex">
|
|
<span>def <span class="ident">Unperformed</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Unperformed(self, var: 'SequenceVar') -> "std::vector< int > const &":
|
|
return _pywrapcp.Assignment_Unperformed(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Assignment.Value"><code class="name flex">
|
|
<span>def <span class="ident">Value</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Value(self, var: 'IntVar') -> "int64":
|
|
return _pywrapcp.Assignment_Value(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.PropagationBaseObject.Name" href="#pywrapcp.PropagationBaseObject.Name">Name</a></code></li>
|
|
<li><code><a title="pywrapcp.PropagationBaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.AssignmentElement"><code class="flex name class">
|
|
<span>class <span class="ident">AssignmentElement</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class AssignmentElement(object):
|
|
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 Activate(self) -> "void":
|
|
return _pywrapcp.AssignmentElement_Activate(self)
|
|
|
|
def Deactivate(self) -> "void":
|
|
return _pywrapcp.AssignmentElement_Deactivate(self)
|
|
|
|
def Activated(self) -> "bool":
|
|
return _pywrapcp.AssignmentElement_Activated(self)
|
|
__swig_destroy__ = _pywrapcp.delete_AssignmentElement</code></pre>
|
|
</details>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntVarElement" href="#pywrapcp.IntVarElement">IntVarElement</a></li>
|
|
<li><a title="pywrapcp.IntervalVarElement" href="#pywrapcp.IntervalVarElement">IntervalVarElement</a></li>
|
|
<li><a title="pywrapcp.SequenceVarElement" href="#pywrapcp.SequenceVarElement">SequenceVarElement</a></li>
|
|
</ul>
|
|
<h3>Instance variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.AssignmentElement.thisown"><code class="name">var <span class="ident">thisown</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The membership flag</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.AssignmentElement.Activate"><code class="name flex">
|
|
<span>def <span class="ident">Activate</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Activate(self) -> "void":
|
|
return _pywrapcp.AssignmentElement_Activate(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.AssignmentElement.Activated"><code class="name flex">
|
|
<span>def <span class="ident">Activated</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Activated(self) -> "bool":
|
|
return _pywrapcp.AssignmentElement_Activated(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.AssignmentElement.Deactivate"><code class="name flex">
|
|
<span>def <span class="ident">Deactivate</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Deactivate(self) -> "void":
|
|
return _pywrapcp.AssignmentElement_Deactivate(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
</dd>
|
|
<dt id="pywrapcp.BaseLns"><code class="flex name class">
|
|
<span>class <span class="ident">BaseLns</span></span>
|
|
<span>(</span><span>vars)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This is the base class for building an Lns operator. An Lns fragment is a collection of variables which will be relaxed. Fragments are built with NextFragment(), which returns false if there are no more fragments to build. Optionally one can override InitFragments, which is called from LocalSearchOperator::Start to initialize fragment data. Here's a sample relaxing one variable at a time: class OneVarLns : public BaseLns {
|
|
public:
|
|
OneVarLns(const std::vector<IntVar*>& vars) : BaseLns(vars), index_(0) {}
|
|
virtual ~OneVarLns() {}
|
|
virtual void InitFragments() { index_ = 0; }
|
|
virtual bool NextFragment() {
|
|
const int size = Size();
|
|
if (index_ < size) {
|
|
AppendToFragment(index_);
|
|
++index_;
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
private:
|
|
int index_; };</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class BaseLns(IntVarLocalSearchOperator):
|
|
r""" This is the base class for building an Lns operator. An Lns fragment is a collection of variables which will be relaxed. Fragments are built with NextFragment(), which returns false if there are no more fragments to build. Optionally one can override InitFragments, which is called from LocalSearchOperator::Start to initialize fragment data. Here's a sample relaxing one variable at a time: class OneVarLns : public BaseLns { public: OneVarLns(const std::vector<IntVar*>& vars) : BaseLns(vars), index_(0) {} virtual ~OneVarLns() {} virtual void InitFragments() { index_ = 0; } virtual bool NextFragment() { const int size = Size(); if (index_ < size) { AppendToFragment(index_); ++index_; return true; } else { return false; } } private: int index_; };"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, vars: 'std::vector< operations_research::IntVar * > const &'):
|
|
if self.__class__ == BaseLns:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.BaseLns_swiginit(self, _pywrapcp.new_BaseLns(_self, vars))
|
|
__swig_destroy__ = _pywrapcp.delete_BaseLns
|
|
|
|
def InitFragments(self) -> "void":
|
|
return _pywrapcp.BaseLns_InitFragments(self)
|
|
|
|
def NextFragment(self) -> "bool":
|
|
return _pywrapcp.BaseLns_NextFragment(self)
|
|
|
|
def AppendToFragment(self, index: 'int') -> "void":
|
|
return _pywrapcp.BaseLns_AppendToFragment(self, index)
|
|
|
|
def FragmentSize(self) -> "int":
|
|
return _pywrapcp.BaseLns_FragmentSize(self)
|
|
|
|
def __getitem__(self, index: 'int') -> "int64":
|
|
return _pywrapcp.BaseLns___getitem__(self, index)
|
|
|
|
def __len__(self) -> "int":
|
|
return _pywrapcp.BaseLns___len__(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_BaseLns(self)
|
|
return weakref.proxy(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntVarLocalSearchOperator" href="#pywrapcp.IntVarLocalSearchOperator">IntVarLocalSearchOperator</a></li>
|
|
<li><a title="pywrapcp.IntVarLocalSearchOperatorTemplate" href="#pywrapcp.IntVarLocalSearchOperatorTemplate">IntVarLocalSearchOperatorTemplate</a></li>
|
|
<li><a title="pywrapcp.LocalSearchOperator" href="#pywrapcp.LocalSearchOperator">LocalSearchOperator</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.BaseLns.AppendToFragment"><code class="name flex">
|
|
<span>def <span class="ident">AppendToFragment</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AppendToFragment(self, index: 'int') -> "void":
|
|
return _pywrapcp.BaseLns_AppendToFragment(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.BaseLns.FragmentSize"><code class="name flex">
|
|
<span>def <span class="ident">FragmentSize</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FragmentSize(self) -> "int":
|
|
return _pywrapcp.BaseLns_FragmentSize(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.BaseLns.InitFragments"><code class="name flex">
|
|
<span>def <span class="ident">InitFragments</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def InitFragments(self) -> "void":
|
|
return _pywrapcp.BaseLns_InitFragments(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.BaseLns.NextFragment"><code class="name flex">
|
|
<span>def <span class="ident">NextFragment</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NextFragment(self) -> "bool":
|
|
return _pywrapcp.BaseLns_NextFragment(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.IntVarLocalSearchOperator" href="#pywrapcp.IntVarLocalSearchOperator">IntVarLocalSearchOperator</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.NextNeighbor" href="#pywrapcp.IntVarLocalSearchOperator.NextNeighbor">NextNeighbor</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.OnStart" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.OnStart">OnStart</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.OneNeighbor" href="#pywrapcp.IntVarLocalSearchOperator.OneNeighbor">OneNeighbor</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.Start" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.Start">Start</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.Value" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.Value">Value</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.BaseObject"><code class="flex name class">
|
|
<span>class <span class="ident">BaseObject</span></span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A BaseObject is the root of all reversibly allocated objects. A DebugString method and the associated << operator are implemented as a convenience.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class BaseObject(object):
|
|
r""" A BaseObject is the root of all reversibly allocated objects. A DebugString method and the associated << operator are implemented as a convenience."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
|
|
def __init__(self):
|
|
if self.__class__ == BaseObject:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.BaseObject_swiginit(self, _pywrapcp.new_BaseObject(_self, ))
|
|
__swig_destroy__ = _pywrapcp.delete_BaseObject
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.BaseObject_DebugString(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.BaseObject___str__(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.BaseObject___repr__(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_BaseObject(self)
|
|
return weakref.proxy(self)</code></pre>
|
|
</details>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></li>
|
|
<li><a title="pywrapcp.Decision" href="#pywrapcp.Decision">Decision</a></li>
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.Demon" href="#pywrapcp.Demon">Demon</a></li>
|
|
<li><a title="pywrapcp.SearchMonitor" href="#pywrapcp.SearchMonitor">SearchMonitor</a></li>
|
|
<li><a title="pywrapcp.IntVarIterator" href="#pywrapcp.IntVarIterator">IntVarIterator</a></li>
|
|
<li><a title="pywrapcp.LocalSearchOperator" href="#pywrapcp.LocalSearchOperator">LocalSearchOperator</a></li>
|
|
<li><a title="pywrapcp.LocalSearchFilter" href="#pywrapcp.LocalSearchFilter">LocalSearchFilter</a></li>
|
|
<li><a title="pywrapcp.RoutingModelVisitor" href="#pywrapcp.RoutingModelVisitor">RoutingModelVisitor</a></li>
|
|
</ul>
|
|
<h3>Instance variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.BaseObject.thisown"><code class="name">var <span class="ident">thisown</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The membership flag</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.BaseObject.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.BaseObject_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
</dd>
|
|
<dt id="pywrapcp.BasePathFilter"><code class="flex name class">
|
|
<span>class <span class="ident">BasePathFilter</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Local Search Filters are used for fast neighbor pruning.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class BasePathFilter(IntVarLocalSearchFilter):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_BasePathFilter
|
|
|
|
def Accept(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
return _pywrapcp.BasePathFilter_Accept(self, delta, deltadelta)
|
|
|
|
def OnSynchronize(self, delta: 'Assignment') -> "void":
|
|
return _pywrapcp.BasePathFilter_OnSynchronize(self, delta)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntVarLocalSearchFilter" href="#pywrapcp.IntVarLocalSearchFilter">IntVarLocalSearchFilter</a></li>
|
|
<li><a title="pywrapcp.LocalSearchFilter" href="#pywrapcp.LocalSearchFilter">LocalSearchFilter</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.BasePathFilter.OnSynchronize"><code class="name flex">
|
|
<span>def <span class="ident">OnSynchronize</span></span>(<span>self, delta)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OnSynchronize(self, delta: 'Assignment') -> "void":
|
|
return _pywrapcp.BasePathFilter_OnSynchronize(self, delta)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.IntVarLocalSearchFilter" href="#pywrapcp.IntVarLocalSearchFilter">IntVarLocalSearchFilter</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchFilter.Accept" href="#pywrapcp.LocalSearchFilter.Accept">Accept</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchFilter.Synchronize" href="#pywrapcp.IntVarLocalSearchFilter.Synchronize">Synchronize</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchFilter.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.BooleanVar"><code class="flex name class">
|
|
<span>class <span class="ident">BooleanVar</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The class IntVar is a subset of IntExpr. In addition to the IntExpr protocol, it offers persistence, removing values from the domains, and a finer model for events.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class BooleanVar(IntVar):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def Min(self) -> "int64":
|
|
return _pywrapcp.BooleanVar_Min(self)
|
|
|
|
def SetMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.BooleanVar_SetMin(self, m)
|
|
|
|
def Max(self) -> "int64":
|
|
return _pywrapcp.BooleanVar_Max(self)
|
|
|
|
def SetMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.BooleanVar_SetMax(self, m)
|
|
|
|
def SetRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.BooleanVar_SetRange(self, mi, ma)
|
|
|
|
def Bound(self) -> "bool":
|
|
return _pywrapcp.BooleanVar_Bound(self)
|
|
|
|
def Value(self) -> "int64":
|
|
return _pywrapcp.BooleanVar_Value(self)
|
|
|
|
def RemoveValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.BooleanVar_RemoveValue(self, v)
|
|
|
|
def RemoveInterval(self, l: 'int64', u: 'int64') -> "void":
|
|
return _pywrapcp.BooleanVar_RemoveInterval(self, l, u)
|
|
|
|
def WhenBound(self, d: 'Demon') -> "void":
|
|
return _pywrapcp.BooleanVar_WhenBound(self, d)
|
|
|
|
def WhenRange(self, d: 'Demon') -> "void":
|
|
return _pywrapcp.BooleanVar_WhenRange(self, d)
|
|
|
|
def WhenDomain(self, d: 'Demon') -> "void":
|
|
return _pywrapcp.BooleanVar_WhenDomain(self, d)
|
|
|
|
def Size(self) -> "uint64":
|
|
return _pywrapcp.BooleanVar_Size(self)
|
|
|
|
def Contains(self, v: 'int64') -> "bool":
|
|
return _pywrapcp.BooleanVar_Contains(self, v)
|
|
|
|
def HoleIteratorAux(self, reversible: 'bool') -> "operations_research::IntVarIterator *":
|
|
return _pywrapcp.BooleanVar_HoleIteratorAux(self, reversible)
|
|
|
|
def DomainIteratorAux(self, reversible: 'bool') -> "operations_research::IntVarIterator *":
|
|
return _pywrapcp.BooleanVar_DomainIteratorAux(self, reversible)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.BooleanVar_DebugString(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntVar" href="#pywrapcp.IntVar">IntVar</a></li>
|
|
<li><a title="pywrapcp.IntExpr" href="#pywrapcp.IntExpr">IntExpr</a></li>
|
|
<li><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.BooleanVar.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.BooleanVar_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.BooleanVar.Max"><code class="name flex">
|
|
<span>def <span class="ident">Max</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Max(self) -> "int64":
|
|
return _pywrapcp.BooleanVar_Max(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.BooleanVar.Min"><code class="name flex">
|
|
<span>def <span class="ident">Min</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Min(self) -> "int64":
|
|
return _pywrapcp.BooleanVar_Min(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.BooleanVar.SetMax"><code class="name flex">
|
|
<span>def <span class="ident">SetMax</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.BooleanVar_SetMax(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.BooleanVar.SetMin"><code class="name flex">
|
|
<span>def <span class="ident">SetMin</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.BooleanVar_SetMin(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.IntVar" href="#pywrapcp.IntVar">IntVar</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.IntVar.Bound" href="#pywrapcp.IntExpr.Bound">Bound</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.Contains" href="#pywrapcp.IntVar.Contains">Contains</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.DomainIteratorAux" href="#pywrapcp.IntVar.DomainIteratorAux">DomainIteratorAux</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.HoleIteratorAux" href="#pywrapcp.IntVar.HoleIteratorAux">HoleIteratorAux</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.IsVar" href="#pywrapcp.IntExpr.IsVar">IsVar</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.Name" href="#pywrapcp.PropagationBaseObject.Name">Name</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.OldMax" href="#pywrapcp.IntVar.OldMax">OldMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.OldMin" href="#pywrapcp.IntVar.OldMin">OldMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.RemoveInterval" href="#pywrapcp.IntVar.RemoveInterval">RemoveInterval</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.RemoveValue" href="#pywrapcp.IntVar.RemoveValue">RemoveValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.RemoveValues" href="#pywrapcp.IntVar.RemoveValues">RemoveValues</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.SetRange" href="#pywrapcp.IntExpr.SetRange">SetRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.SetValue" href="#pywrapcp.IntExpr.SetValue">SetValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.SetValues" href="#pywrapcp.IntVar.SetValues">SetValues</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.Size" href="#pywrapcp.IntVar.Size">Size</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.Value" href="#pywrapcp.IntVar.Value">Value</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.Var" href="#pywrapcp.IntExpr.Var">Var</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.VarWithName" href="#pywrapcp.IntExpr.VarWithName">VarWithName</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.WhenBound" href="#pywrapcp.IntVar.WhenBound">WhenBound</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.WhenDomain" href="#pywrapcp.IntVar.WhenDomain">WhenDomain</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.WhenRange" href="#pywrapcp.IntExpr.WhenRange">WhenRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.CPFeasibilityFilter"><code class="flex name class">
|
|
<span>class <span class="ident">CPFeasibilityFilter</span></span>
|
|
<span>(</span><span>routing_model)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Local Search Filters are used for fast neighbor pruning.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class CPFeasibilityFilter(IntVarLocalSearchFilter):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, routing_model: 'RoutingModel'):
|
|
_pywrapcp.CPFeasibilityFilter_swiginit(self, _pywrapcp.new_CPFeasibilityFilter(routing_model))
|
|
__swig_destroy__ = _pywrapcp.delete_CPFeasibilityFilter
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.CPFeasibilityFilter_DebugString(self)
|
|
|
|
def Accept(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
return _pywrapcp.CPFeasibilityFilter_Accept(self, delta, deltadelta)
|
|
|
|
def OnSynchronize(self, delta: 'Assignment') -> "void":
|
|
return _pywrapcp.CPFeasibilityFilter_OnSynchronize(self, delta)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntVarLocalSearchFilter" href="#pywrapcp.IntVarLocalSearchFilter">IntVarLocalSearchFilter</a></li>
|
|
<li><a title="pywrapcp.LocalSearchFilter" href="#pywrapcp.LocalSearchFilter">LocalSearchFilter</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.CPFeasibilityFilter.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.CPFeasibilityFilter_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.CPFeasibilityFilter.OnSynchronize"><code class="name flex">
|
|
<span>def <span class="ident">OnSynchronize</span></span>(<span>self, delta)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OnSynchronize(self, delta: 'Assignment') -> "void":
|
|
return _pywrapcp.CPFeasibilityFilter_OnSynchronize(self, delta)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.IntVarLocalSearchFilter" href="#pywrapcp.IntVarLocalSearchFilter">IntVarLocalSearchFilter</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchFilter.Accept" href="#pywrapcp.LocalSearchFilter.Accept">Accept</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchFilter.Synchronize" href="#pywrapcp.IntVarLocalSearchFilter.Synchronize">Synchronize</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchFilter.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.ChangeValue"><code class="flex name class">
|
|
<span>class <span class="ident">ChangeValue</span></span>
|
|
<span>(</span><span>vars)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Defines operators which change the value of variables; each neighbor corresponds to <em>one</em> modified variable. Sub-classes have to define ModifyValue which determines what the new variable value is going to be (given the current value and the variable).</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class ChangeValue(IntVarLocalSearchOperator):
|
|
r""" Defines operators which change the value of variables; each neighbor corresponds to *one* modified variable. Sub-classes have to define ModifyValue which determines what the new variable value is going to be (given the current value and the variable)."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, vars: 'std::vector< operations_research::IntVar * > const &'):
|
|
if self.__class__ == ChangeValue:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.ChangeValue_swiginit(self, _pywrapcp.new_ChangeValue(_self, vars))
|
|
__swig_destroy__ = _pywrapcp.delete_ChangeValue
|
|
|
|
def ModifyValue(self, index: 'int64', value: 'int64') -> "int64":
|
|
return _pywrapcp.ChangeValue_ModifyValue(self, index, value)
|
|
|
|
def OneNeighbor(self) -> "bool":
|
|
r""" This method should not be overridden. Override ModifyValue() instead."""
|
|
return _pywrapcp.ChangeValue_OneNeighbor(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_ChangeValue(self)
|
|
return weakref.proxy(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntVarLocalSearchOperator" href="#pywrapcp.IntVarLocalSearchOperator">IntVarLocalSearchOperator</a></li>
|
|
<li><a title="pywrapcp.IntVarLocalSearchOperatorTemplate" href="#pywrapcp.IntVarLocalSearchOperatorTemplate">IntVarLocalSearchOperatorTemplate</a></li>
|
|
<li><a title="pywrapcp.LocalSearchOperator" href="#pywrapcp.LocalSearchOperator">LocalSearchOperator</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.ChangeValue.ModifyValue"><code class="name flex">
|
|
<span>def <span class="ident">ModifyValue</span></span>(<span>self, index, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ModifyValue(self, index: 'int64', value: 'int64') -> "int64":
|
|
return _pywrapcp.ChangeValue_ModifyValue(self, index, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.ChangeValue.OneNeighbor"><code class="name flex">
|
|
<span>def <span class="ident">OneNeighbor</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method should not be overridden. Override ModifyValue() instead.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OneNeighbor(self) -> "bool":
|
|
r""" This method should not be overridden. Override ModifyValue() instead."""
|
|
return _pywrapcp.ChangeValue_OneNeighbor(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.IntVarLocalSearchOperator" href="#pywrapcp.IntVarLocalSearchOperator">IntVarLocalSearchOperator</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.NextNeighbor" href="#pywrapcp.IntVarLocalSearchOperator.NextNeighbor">NextNeighbor</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.OnStart" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.OnStart">OnStart</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.Start" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.Start">Start</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.Value" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.Value">Value</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.CheapestAdditionFilteredDecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">CheapestAdditionFilteredDecisionBuilder</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class CheapestAdditionFilteredDecisionBuilder(RoutingFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_CheapestAdditionFilteredDecisionBuilder
|
|
|
|
def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.CheapestAdditionFilteredDecisionBuilder_BuildSolution(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.EvaluatorCheapestAdditionFilteredDecisionBuilder" href="#pywrapcp.EvaluatorCheapestAdditionFilteredDecisionBuilder">EvaluatorCheapestAdditionFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.ComparatorCheapestAdditionFilteredDecisionBuilder" href="#pywrapcp.ComparatorCheapestAdditionFilteredDecisionBuilder">ComparatorCheapestAdditionFilteredDecisionBuilder</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.CheapestAdditionFilteredDecisionBuilder.BuildSolution"><code class="name flex">
|
|
<span>def <span class="ident">BuildSolution</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.CheapestAdditionFilteredDecisionBuilder_BuildSolution(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.RoutingFilteredDecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingFilteredDecisionBuilder.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.CheapestInsertionFilteredDecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">CheapestInsertionFilteredDecisionBuilder</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class CheapestInsertionFilteredDecisionBuilder(RoutingFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_CheapestInsertionFilteredDecisionBuilder</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder" href="#pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder">GlobalCheapestInsertionFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder" href="#pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder">LocalCheapestInsertionFilteredDecisionBuilder</a></li>
|
|
</ul>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.RoutingFilteredDecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingFilteredDecisionBuilder.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.ChristofidesFilteredDecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">ChristofidesFilteredDecisionBuilder</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class ChristofidesFilteredDecisionBuilder(RoutingFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_ChristofidesFilteredDecisionBuilder
|
|
|
|
def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.ChristofidesFilteredDecisionBuilder_BuildSolution(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.ChristofidesFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.ChristofidesFilteredDecisionBuilder.BuildSolution"><code class="name flex">
|
|
<span>def <span class="ident">BuildSolution</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.ChristofidesFilteredDecisionBuilder_BuildSolution(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.ChristofidesFilteredDecisionBuilder.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.ChristofidesFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.RoutingFilteredDecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingFilteredDecisionBuilder.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.ComparatorCheapestAdditionFilteredDecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">ComparatorCheapestAdditionFilteredDecisionBuilder</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class ComparatorCheapestAdditionFilteredDecisionBuilder(CheapestAdditionFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_ComparatorCheapestAdditionFilteredDecisionBuilder
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.ComparatorCheapestAdditionFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.CheapestAdditionFilteredDecisionBuilder" href="#pywrapcp.CheapestAdditionFilteredDecisionBuilder">CheapestAdditionFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.ComparatorCheapestAdditionFilteredDecisionBuilder.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.ComparatorCheapestAdditionFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.CheapestAdditionFilteredDecisionBuilder" href="#pywrapcp.CheapestAdditionFilteredDecisionBuilder">CheapestAdditionFilteredDecisionBuilder</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.CheapestAdditionFilteredDecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.CheapestAdditionFilteredDecisionBuilder.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.Constraint"><code class="flex name class">
|
|
<span>class <span class="ident">Constraint</span></span>
|
|
<span>(</span><span>solver)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A constraint is the main modeling object. It provides two methods:
|
|
- Post() is responsible for creating the demons and attaching them to
|
|
immediate demons().
|
|
- InitialPropagate() is called once just after Post and performs
|
|
the initial propagation. The subsequent propagations will be performed
|
|
by the demons Posted during the post() method.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class Constraint(PropagationBaseObject):
|
|
r""" A constraint is the main modeling object. It provides two methods: - Post() is responsible for creating the demons and attaching them to immediate demons(). - InitialPropagate() is called once just after Post and performs the initial propagation. The subsequent propagations will be performed by the demons Posted during the post() method."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
|
|
def __init__(self, solver: 'Solver'):
|
|
if self.__class__ == Constraint:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.Constraint_swiginit(self, _pywrapcp.new_Constraint(_self, solver))
|
|
__swig_destroy__ = _pywrapcp.delete_Constraint
|
|
|
|
def Post(self) -> "void":
|
|
r""" This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables."""
|
|
return _pywrapcp.Constraint_Post(self)
|
|
|
|
def InitialPropagateWrapper(self) -> "void":
|
|
r""" This method performs the initial propagation of the constraint. It is called just after the post."""
|
|
return _pywrapcp.Constraint_InitialPropagateWrapper(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Constraint_DebugString(self)
|
|
|
|
def Var(self) -> "operations_research::IntVar *":
|
|
r""" Creates a Boolean variable representing the status of the constraint (false = constraint is violated, true = constraint is satisfied). It returns nullptr if the constraint does not support this API."""
|
|
return _pywrapcp.Constraint_Var(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.Constraint___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.Constraint___str__(self)
|
|
|
|
def __add__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___add__(self, *args)
|
|
|
|
def __radd__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___radd__(self, v)
|
|
|
|
def __sub__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___sub__(self, *args)
|
|
|
|
def __rsub__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___rsub__(self, v)
|
|
|
|
def __mul__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___mul__(self, *args)
|
|
|
|
def __rmul__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___rmul__(self, v)
|
|
|
|
def __floordiv__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___floordiv__(self, v)
|
|
|
|
def __neg__(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___neg__(self)
|
|
|
|
def __abs__(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint___abs__(self)
|
|
|
|
def Square(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint_Square(self)
|
|
|
|
def __eq__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint___eq__(self, *args)
|
|
|
|
def __ne__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint___ne__(self, *args)
|
|
|
|
def __ge__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint___ge__(self, *args)
|
|
|
|
def __gt__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint___gt__(self, *args)
|
|
|
|
def __le__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint___le__(self, *args)
|
|
|
|
def __lt__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint___lt__(self, *args)
|
|
|
|
def MapTo(self, vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint_MapTo(self, vars)
|
|
|
|
def IndexOf(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint_IndexOf(self, *args)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_Constraint(self)
|
|
return weakref.proxy(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.Pack" href="#pywrapcp.Pack">Pack</a></li>
|
|
<li><a title="pywrapcp.DisjunctiveConstraint" href="#pywrapcp.DisjunctiveConstraint">DisjunctiveConstraint</a></li>
|
|
<li><a title="pywrapcp.PyConstraint" href="#pywrapcp.PyConstraint">PyConstraint</a></li>
|
|
<li><a title="pywrapcp.GlobalVehicleBreaksConstraint" href="#pywrapcp.GlobalVehicleBreaksConstraint">GlobalVehicleBreaksConstraint</a></li>
|
|
<li><a title="pywrapcp.TypeRegulationsConstraint" href="#pywrapcp.TypeRegulationsConstraint">TypeRegulationsConstraint</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.Constraint.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Constraint_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Constraint.IndexOf"><code class="name flex">
|
|
<span>def <span class="ident">IndexOf</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IndexOf(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint_IndexOf(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Constraint.InitialPropagateWrapper"><code class="name flex">
|
|
<span>def <span class="ident">InitialPropagateWrapper</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method performs the initial propagation of the constraint. It is called just after the post.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def InitialPropagateWrapper(self) -> "void":
|
|
r""" This method performs the initial propagation of the constraint. It is called just after the post."""
|
|
return _pywrapcp.Constraint_InitialPropagateWrapper(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Constraint.MapTo"><code class="name flex">
|
|
<span>def <span class="ident">MapTo</span></span>(<span>self, vars)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MapTo(self, vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
return _pywrapcp.Constraint_MapTo(self, vars)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Constraint.Post"><code class="name flex">
|
|
<span>def <span class="ident">Post</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Post(self) -> "void":
|
|
r""" This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables."""
|
|
return _pywrapcp.Constraint_Post(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Constraint.Square"><code class="name flex">
|
|
<span>def <span class="ident">Square</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Square(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Constraint_Square(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Constraint.Var"><code class="name flex">
|
|
<span>def <span class="ident">Var</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a Boolean variable representing the status of the constraint (false = constraint is violated, true = constraint is satisfied). It returns nullptr if the constraint does not support this API.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Var(self) -> "operations_research::IntVar *":
|
|
r""" Creates a Boolean variable representing the status of the constraint (false = constraint is violated, true = constraint is satisfied). It returns nullptr if the constraint does not support this API."""
|
|
return _pywrapcp.Constraint_Var(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.PropagationBaseObject.Name" href="#pywrapcp.PropagationBaseObject.Name">Name</a></code></li>
|
|
<li><code><a title="pywrapcp.PropagationBaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.Decision"><code class="flex name class">
|
|
<span>class <span class="ident">Decision</span></span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A Decision represents a choice point in the search tree. The two main methods are Apply() to go left, or Refute() to go right.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class Decision(BaseObject):
|
|
r""" A Decision represents a choice point in the search tree. The two main methods are Apply() to go left, or Refute() to go right."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
|
|
def __init__(self):
|
|
if self.__class__ == Decision:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.Decision_swiginit(self, _pywrapcp.new_Decision(_self, ))
|
|
__swig_destroy__ = _pywrapcp.delete_Decision
|
|
|
|
def ApplyWrapper(self, s: 'Solver') -> "void":
|
|
r""" Apply will be called first when the decision is executed."""
|
|
return _pywrapcp.Decision_ApplyWrapper(self, s)
|
|
|
|
def RefuteWrapper(self, s: 'Solver') -> "void":
|
|
r""" Refute will be called after a backtrack."""
|
|
return _pywrapcp.Decision_RefuteWrapper(self, s)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Decision_DebugString(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.Decision___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.Decision___str__(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_Decision(self)
|
|
return weakref.proxy(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.PyDecision" href="#pywrapcp.PyDecision">PyDecision</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.Decision.ApplyWrapper"><code class="name flex">
|
|
<span>def <span class="ident">ApplyWrapper</span></span>(<span>self, s)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Apply will be called first when the decision is executed.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ApplyWrapper(self, s: 'Solver') -> "void":
|
|
r""" Apply will be called first when the decision is executed."""
|
|
return _pywrapcp.Decision_ApplyWrapper(self, s)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Decision.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Decision_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Decision.RefuteWrapper"><code class="name flex">
|
|
<span>def <span class="ident">RefuteWrapper</span></span>(<span>self, s)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Refute will be called after a backtrack.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RefuteWrapper(self, s: 'Solver') -> "void":
|
|
r""" Refute will be called after a backtrack."""
|
|
return _pywrapcp.Decision_RefuteWrapper(self, s)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.BaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.DecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">DecisionBuilder</span></span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class DecisionBuilder(BaseObject):
|
|
r""" A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
|
|
def __init__(self):
|
|
if self.__class__ == DecisionBuilder:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.DecisionBuilder_swiginit(self, _pywrapcp.new_DecisionBuilder(_self, ))
|
|
__swig_destroy__ = _pywrapcp.delete_DecisionBuilder
|
|
|
|
def NextWrapper(self, s: 'Solver') -> "operations_research::Decision *":
|
|
r""" This is the main method of the decision builder class. It must return a decision (an instance of the class Decision). If it returns nullptr, this means that the decision builder has finished its work."""
|
|
return _pywrapcp.DecisionBuilder_NextWrapper(self, s)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.DecisionBuilder_DebugString(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.DecisionBuilder___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.DecisionBuilder___str__(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_DecisionBuilder(self)
|
|
return weakref.proxy(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.PyDecisionBuilder" href="#pywrapcp.PyDecisionBuilder">PyDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.DecisionBuilder.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.DecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.DecisionBuilder.NextWrapper"><code class="name flex">
|
|
<span>def <span class="ident">NextWrapper</span></span>(<span>self, s)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This is the main method of the decision builder class. It must return a decision (an instance of the class Decision). If it returns nullptr, this means that the decision builder has finished its work.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NextWrapper(self, s: 'Solver') -> "operations_research::Decision *":
|
|
r""" This is the main method of the decision builder class. It must return a decision (an instance of the class Decision). If it returns nullptr, this means that the decision builder has finished its work."""
|
|
return _pywrapcp.DecisionBuilder_NextWrapper(self, s)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.BaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters"><code class="flex name class">
|
|
<span>class <span class="ident">DefaultPhaseParameters</span></span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This struct holds all parameters for the default search. DefaultPhaseParameters is only used by Solver::MakeDefaultPhase methods. Note this is for advanced users only.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class DefaultPhaseParameters(object):
|
|
r""" This struct holds all parameters for the default search. DefaultPhaseParameters is only used by Solver::MakeDefaultPhase methods. Note this is for advanced users only."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
CHOOSE_MAX_SUM_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_SUM_IMPACT
|
|
CHOOSE_MAX_AVERAGE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_AVERAGE_IMPACT
|
|
CHOOSE_MAX_VALUE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_VALUE_IMPACT
|
|
SELECT_MIN_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MIN_IMPACT
|
|
SELECT_MAX_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MAX_IMPACT
|
|
NONE = _pywrapcp.DefaultPhaseParameters_NONE
|
|
NORMAL = _pywrapcp.DefaultPhaseParameters_NORMAL
|
|
VERBOSE = _pywrapcp.DefaultPhaseParameters_VERBOSE
|
|
var_selection_schema = property(_pywrapcp.DefaultPhaseParameters_var_selection_schema_get, _pywrapcp.DefaultPhaseParameters_var_selection_schema_set, doc=r""" This parameter describes how the next variable to instantiate will be chosen.""")
|
|
value_selection_schema = property(_pywrapcp.DefaultPhaseParameters_value_selection_schema_get, _pywrapcp.DefaultPhaseParameters_value_selection_schema_set, doc=r""" This parameter describes which value to select for a given var.""")
|
|
initialization_splits = property(_pywrapcp.DefaultPhaseParameters_initialization_splits_get, _pywrapcp.DefaultPhaseParameters_initialization_splits_set, doc=r""" Maximum number of intervals that the initialization of impacts will scan per variable.""")
|
|
run_all_heuristics = property(_pywrapcp.DefaultPhaseParameters_run_all_heuristics_get, _pywrapcp.DefaultPhaseParameters_run_all_heuristics_set, doc=r""" The default phase will run heuristics periodically. This parameter indicates if we should run all heuristics, or a randomly selected one.""")
|
|
heuristic_period = property(_pywrapcp.DefaultPhaseParameters_heuristic_period_get, _pywrapcp.DefaultPhaseParameters_heuristic_period_set, doc=r""" The distance in nodes between each run of the heuristics. A negative or null value will mean that we will not run heuristics at all.""")
|
|
heuristic_num_failures_limit = property(_pywrapcp.DefaultPhaseParameters_heuristic_num_failures_limit_get, _pywrapcp.DefaultPhaseParameters_heuristic_num_failures_limit_set, doc=r""" The failure limit for each heuristic that we run.""")
|
|
persistent_impact = property(_pywrapcp.DefaultPhaseParameters_persistent_impact_get, _pywrapcp.DefaultPhaseParameters_persistent_impact_set, doc=r""" Whether to keep the impact from the first search for other searches, or to recompute the impact for each new search.""")
|
|
random_seed = property(_pywrapcp.DefaultPhaseParameters_random_seed_get, _pywrapcp.DefaultPhaseParameters_random_seed_set, doc=r""" Seed used to initialize the random part in some heuristics.""")
|
|
display_level = property(_pywrapcp.DefaultPhaseParameters_display_level_get, _pywrapcp.DefaultPhaseParameters_display_level_set, doc=r""" This represents the amount of information displayed by the default search. NONE means no display, VERBOSE means extra information.""")
|
|
decision_builder = property(_pywrapcp.DefaultPhaseParameters_decision_builder_get, _pywrapcp.DefaultPhaseParameters_decision_builder_set, doc=r""" When defined, this overrides the default impact based decision builder.""")
|
|
|
|
def __init__(self):
|
|
_pywrapcp.DefaultPhaseParameters_swiginit(self, _pywrapcp.new_DefaultPhaseParameters())
|
|
__swig_destroy__ = _pywrapcp.delete_DefaultPhaseParameters</code></pre>
|
|
</details>
|
|
<h3>Class variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.CHOOSE_MAX_AVERAGE_IMPACT"><code class="name">var <span class="ident">CHOOSE_MAX_AVERAGE_IMPACT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.CHOOSE_MAX_SUM_IMPACT"><code class="name">var <span class="ident">CHOOSE_MAX_SUM_IMPACT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.CHOOSE_MAX_VALUE_IMPACT"><code class="name">var <span class="ident">CHOOSE_MAX_VALUE_IMPACT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.NONE"><code class="name">var <span class="ident">NONE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.NORMAL"><code class="name">var <span class="ident">NORMAL</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.SELECT_MAX_IMPACT"><code class="name">var <span class="ident">SELECT_MAX_IMPACT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.SELECT_MIN_IMPACT"><code class="name">var <span class="ident">SELECT_MIN_IMPACT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.VERBOSE"><code class="name">var <span class="ident">VERBOSE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
</dl>
|
|
<h3>Instance variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.decision_builder"><code class="name">var <span class="ident">decision_builder</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>When defined, this overrides the default impact based decision builder.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.display_level"><code class="name">var <span class="ident">display_level</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This represents the amount of information displayed by the default search. NONE means no display, VERBOSE means extra information.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.heuristic_num_failures_limit"><code class="name">var <span class="ident">heuristic_num_failures_limit</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The failure limit for each heuristic that we run.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.heuristic_period"><code class="name">var <span class="ident">heuristic_period</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The distance in nodes between each run of the heuristics. A negative or null value will mean that we will not run heuristics at all.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.initialization_splits"><code class="name">var <span class="ident">initialization_splits</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Maximum number of intervals that the initialization of impacts will scan per variable.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.persistent_impact"><code class="name">var <span class="ident">persistent_impact</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Whether to keep the impact from the first search for other searches, or to recompute the impact for each new search.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.random_seed"><code class="name">var <span class="ident">random_seed</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Seed used to initialize the random part in some heuristics.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.run_all_heuristics"><code class="name">var <span class="ident">run_all_heuristics</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The default phase will run heuristics periodically. This parameter indicates if we should run all heuristics, or a randomly selected one.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.thisown"><code class="name">var <span class="ident">thisown</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The membership flag</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.value_selection_schema"><code class="name">var <span class="ident">value_selection_schema</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This parameter describes which value to select for a given var.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.DefaultPhaseParameters.var_selection_schema"><code class="name">var <span class="ident">var_selection_schema</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This parameter describes how the next variable to instantiate will be chosen.</p></section>
|
|
</dd>
|
|
</dl>
|
|
</dd>
|
|
<dt id="pywrapcp.Demon"><code class="flex name class">
|
|
<span>class <span class="ident">Demon</span></span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A Demon is the base element of a propagation queue. It is the main
|
|
object responsible for implementing the actual propagation
|
|
of the constraint and pruning the inconsistent values in the domains
|
|
of the variables. The main concept is that demons are listeners that are
|
|
attached to the variables and listen to their modifications. There are two methods:
|
|
- Run() is the actual method called when the demon is processed.
|
|
- priority() returns its priority. Standard priorities are slow, normal
|
|
or fast. "immediate" is reserved for variables and is treated separately.</p>
|
|
<p>This indicates the priority of a demon. Immediate demons are treated separately and corresponds to variables.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class Demon(BaseObject):
|
|
r""" A Demon is the base element of a propagation queue. It is the main object responsible for implementing the actual propagation of the constraint and pruning the inconsistent values in the domains of the variables. The main concept is that demons are listeners that are attached to the variables and listen to their modifications. There are two methods: - Run() is the actual method called when the demon is processed. - priority() returns its priority. Standard priorities are slow, normal or fast. "immediate" is reserved for variables and is treated separately."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self):
|
|
r""" This indicates the priority of a demon. Immediate demons are treated separately and corresponds to variables."""
|
|
if self.__class__ == Demon:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.Demon_swiginit(self, _pywrapcp.new_Demon(_self, ))
|
|
__swig_destroy__ = _pywrapcp.delete_Demon
|
|
|
|
def RunWrapper(self, s: 'Solver') -> "void":
|
|
r""" This is the main callback of the demon."""
|
|
return _pywrapcp.Demon_RunWrapper(self, s)
|
|
|
|
def Priority(self) -> "operations_research::Solver::DemonPriority":
|
|
r""" This method returns the priority of the demon. Usually a demon is fast, slow or normal. Immediate demons are reserved for internal use to maintain variables."""
|
|
return _pywrapcp.Demon_Priority(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Demon_DebugString(self)
|
|
|
|
def Inhibit(self, s: 'Solver') -> "void":
|
|
r""" This method inhibits the demon in the search tree below the current position."""
|
|
return _pywrapcp.Demon_Inhibit(self, s)
|
|
|
|
def Desinhibit(self, s: 'Solver') -> "void":
|
|
r""" This method un-inhibits the demon that was previously inhibited."""
|
|
return _pywrapcp.Demon_Desinhibit(self, s)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_Demon(self)
|
|
return weakref.proxy(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.PyDemon" href="#pywrapcp.PyDemon">PyDemon</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.Demon.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Demon_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Demon.Desinhibit"><code class="name flex">
|
|
<span>def <span class="ident">Desinhibit</span></span>(<span>self, s)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method un-inhibits the demon that was previously inhibited.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Desinhibit(self, s: 'Solver') -> "void":
|
|
r""" This method un-inhibits the demon that was previously inhibited."""
|
|
return _pywrapcp.Demon_Desinhibit(self, s)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Demon.Inhibit"><code class="name flex">
|
|
<span>def <span class="ident">Inhibit</span></span>(<span>self, s)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method inhibits the demon in the search tree below the current position.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Inhibit(self, s: 'Solver') -> "void":
|
|
r""" This method inhibits the demon in the search tree below the current position."""
|
|
return _pywrapcp.Demon_Inhibit(self, s)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Demon.Priority"><code class="name flex">
|
|
<span>def <span class="ident">Priority</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method returns the priority of the demon. Usually a demon is fast, slow or normal. Immediate demons are reserved for internal use to maintain variables.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Priority(self) -> "operations_research::Solver::DemonPriority":
|
|
r""" This method returns the priority of the demon. Usually a demon is fast, slow or normal. Immediate demons are reserved for internal use to maintain variables."""
|
|
return _pywrapcp.Demon_Priority(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Demon.RunWrapper"><code class="name flex">
|
|
<span>def <span class="ident">RunWrapper</span></span>(<span>self, s)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This is the main callback of the demon.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RunWrapper(self, s: 'Solver') -> "void":
|
|
r""" This is the main callback of the demon."""
|
|
return _pywrapcp.Demon_RunWrapper(self, s)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.BaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.DisjunctiveConstraint"><code class="flex name class">
|
|
<span>class <span class="ident">DisjunctiveConstraint</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A constraint is the main modeling object. It provides two methods:
|
|
- Post() is responsible for creating the demons and attaching them to
|
|
immediate demons().
|
|
- InitialPropagate() is called once just after Post and performs
|
|
the initial propagation. The subsequent propagations will be performed
|
|
by the demons Posted during the post() method.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class DisjunctiveConstraint(Constraint):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def SequenceVar(self) -> "operations_research::SequenceVar *":
|
|
r""" Creates a sequence variable from the constraint."""
|
|
return _pywrapcp.DisjunctiveConstraint_SequenceVar(self)
|
|
|
|
def SetTransitionTime(self, transition_time: 'operations_research::Solver::IndexEvaluator2') -> "void":
|
|
r""" Add a transition time between intervals. It forces the distance between the end of interval a and start of interval b that follows it to be at least transition_time(a, b). This function must always return a positive or null value."""
|
|
return _pywrapcp.DisjunctiveConstraint_SetTransitionTime(self, transition_time)
|
|
|
|
def TransitionTime(self, before_index: 'int', after_index: 'int') -> "int64":
|
|
return _pywrapcp.DisjunctiveConstraint_TransitionTime(self, before_index, after_index)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.Constraint" href="#pywrapcp.Constraint">Constraint</a></li>
|
|
<li><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.DisjunctiveConstraint.SequenceVar"><code class="name flex">
|
|
<span>def <span class="ident">SequenceVar</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a sequence variable from the constraint.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SequenceVar(self) -> "operations_research::SequenceVar *":
|
|
r""" Creates a sequence variable from the constraint."""
|
|
return _pywrapcp.DisjunctiveConstraint_SequenceVar(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.DisjunctiveConstraint.SetTransitionTime"><code class="name flex">
|
|
<span>def <span class="ident">SetTransitionTime</span></span>(<span>self, transition_time)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Add a transition time between intervals.
|
|
It forces the distance between the end of interval a and start of interval b that follows it to be at least transition_time(a, b). This function must always return a positive or null value.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetTransitionTime(self, transition_time: 'operations_research::Solver::IndexEvaluator2') -> "void":
|
|
r""" Add a transition time between intervals. It forces the distance between the end of interval a and start of interval b that follows it to be at least transition_time(a, b). This function must always return a positive or null value."""
|
|
return _pywrapcp.DisjunctiveConstraint_SetTransitionTime(self, transition_time)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.DisjunctiveConstraint.TransitionTime"><code class="name flex">
|
|
<span>def <span class="ident">TransitionTime</span></span>(<span>self, before_index, after_index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def TransitionTime(self, before_index: 'int', after_index: 'int') -> "int64":
|
|
return _pywrapcp.DisjunctiveConstraint_TransitionTime(self, before_index, after_index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.Constraint" href="#pywrapcp.Constraint">Constraint</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.Constraint.InitialPropagateWrapper" href="#pywrapcp.Constraint.InitialPropagateWrapper">InitialPropagateWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Name" href="#pywrapcp.PropagationBaseObject.Name">Name</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Post" href="#pywrapcp.Constraint.Post">Post</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Var" href="#pywrapcp.Constraint.Var">Var</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.EvaluatorCheapestAdditionFilteredDecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">EvaluatorCheapestAdditionFilteredDecisionBuilder</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class EvaluatorCheapestAdditionFilteredDecisionBuilder(CheapestAdditionFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_EvaluatorCheapestAdditionFilteredDecisionBuilder
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.EvaluatorCheapestAdditionFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.CheapestAdditionFilteredDecisionBuilder" href="#pywrapcp.CheapestAdditionFilteredDecisionBuilder">CheapestAdditionFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.EvaluatorCheapestAdditionFilteredDecisionBuilder.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.EvaluatorCheapestAdditionFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.CheapestAdditionFilteredDecisionBuilder" href="#pywrapcp.CheapestAdditionFilteredDecisionBuilder">CheapestAdditionFilteredDecisionBuilder</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.CheapestAdditionFilteredDecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.CheapestAdditionFilteredDecisionBuilder.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">GlobalCheapestInsertionFilteredDecisionBuilder</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class GlobalCheapestInsertionFilteredDecisionBuilder(CheapestInsertionFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_GlobalCheapestInsertionFilteredDecisionBuilder
|
|
|
|
def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder_BuildSolution(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.CheapestInsertionFilteredDecisionBuilder" href="#pywrapcp.CheapestInsertionFilteredDecisionBuilder">CheapestInsertionFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder.BuildSolution"><code class="name flex">
|
|
<span>def <span class="ident">BuildSolution</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder_BuildSolution(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.CheapestInsertionFilteredDecisionBuilder" href="#pywrapcp.CheapestInsertionFilteredDecisionBuilder">CheapestInsertionFilteredDecisionBuilder</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.CheapestInsertionFilteredDecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.CheapestInsertionFilteredDecisionBuilder.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.GlobalVehicleBreaksConstraint"><code class="flex name class">
|
|
<span>class <span class="ident">GlobalVehicleBreaksConstraint</span></span>
|
|
<span>(</span><span>dimension)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A constraint is the main modeling object. It provides two methods:
|
|
- Post() is responsible for creating the demons and attaching them to
|
|
immediate demons().
|
|
- InitialPropagate() is called once just after Post and performs
|
|
the initial propagation. The subsequent propagations will be performed
|
|
by the demons Posted during the post() method.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class GlobalVehicleBreaksConstraint(Constraint):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, dimension: 'RoutingDimension'):
|
|
_pywrapcp.GlobalVehicleBreaksConstraint_swiginit(self, _pywrapcp.new_GlobalVehicleBreaksConstraint(dimension))
|
|
|
|
def Post(self) -> "void":
|
|
return _pywrapcp.GlobalVehicleBreaksConstraint_Post(self)
|
|
|
|
def InitialPropagateWrapper(self) -> "void":
|
|
return _pywrapcp.GlobalVehicleBreaksConstraint_InitialPropagateWrapper(self)
|
|
__swig_destroy__ = _pywrapcp.delete_GlobalVehicleBreaksConstraint</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.Constraint" href="#pywrapcp.Constraint">Constraint</a></li>
|
|
<li><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.Constraint" href="#pywrapcp.Constraint">Constraint</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.Constraint.InitialPropagateWrapper" href="#pywrapcp.Constraint.InitialPropagateWrapper">InitialPropagateWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Name" href="#pywrapcp.PropagationBaseObject.Name">Name</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Post" href="#pywrapcp.Constraint.Post">Post</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Var" href="#pywrapcp.Constraint.Var">Var</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr"><code class="flex name class">
|
|
<span>class <span class="ident">IntExpr</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The class IntExpr is the base of all integer expressions in constraint programming. It contains the basic protocol for an expression:
|
|
- setting and modifying its bound
|
|
- querying if it is bound
|
|
- listening to events modifying its bounds
|
|
- casting it into a variable (instance of IntVar)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class IntExpr(PropagationBaseObject):
|
|
r""" The class IntExpr is the base of all integer expressions in constraint programming. It contains the basic protocol for an expression: - setting and modifying its bound - querying if it is bound - listening to events modifying its bounds - casting it into a variable (instance of IntVar)"""
|
|
|
|
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 - class is abstract")
|
|
|
|
def Min(self) -> "int64":
|
|
return _pywrapcp.IntExpr_Min(self)
|
|
|
|
def SetMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntExpr_SetMin(self, m)
|
|
|
|
def Max(self) -> "int64":
|
|
return _pywrapcp.IntExpr_Max(self)
|
|
|
|
def SetMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntExpr_SetMax(self, m)
|
|
|
|
def SetRange(self, l: 'int64', u: 'int64') -> "void":
|
|
r""" This method sets both the min and the max of the expression."""
|
|
return _pywrapcp.IntExpr_SetRange(self, l, u)
|
|
|
|
def SetValue(self, v: 'int64') -> "void":
|
|
r""" This method sets the value of the expression."""
|
|
return _pywrapcp.IntExpr_SetValue(self, v)
|
|
|
|
def Bound(self) -> "bool":
|
|
r""" Returns true if the min and the max of the expression are equal."""
|
|
return _pywrapcp.IntExpr_Bound(self)
|
|
|
|
def IsVar(self) -> "bool":
|
|
r""" Returns true if the expression is indeed a variable."""
|
|
return _pywrapcp.IntExpr_IsVar(self)
|
|
|
|
def Var(self) -> "operations_research::IntVar *":
|
|
r""" Creates a variable from the expression."""
|
|
return _pywrapcp.IntExpr_Var(self)
|
|
|
|
def VarWithName(self, name: 'std::string const &') -> "operations_research::IntVar *":
|
|
r""" Creates a variable from the expression and set the name of the resulting var. If the expression is already a variable, then it will set the name of the expression, possibly overwriting it. This is just a shortcut to Var() followed by set_name()."""
|
|
return _pywrapcp.IntExpr_VarWithName(self, name)
|
|
|
|
def WhenRange(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
Attach a demon that will watch the min or the max of the expression.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Attach a demon that will watch the min or the max of the expression.
|
|
"""
|
|
return _pywrapcp.IntExpr_WhenRange(self, *args)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.IntExpr___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.IntExpr___str__(self)
|
|
|
|
def __add__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___add__(self, *args)
|
|
|
|
def __radd__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___radd__(self, v)
|
|
|
|
def __sub__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___sub__(self, *args)
|
|
|
|
def __rsub__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___rsub__(self, v)
|
|
|
|
def __mul__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___mul__(self, *args)
|
|
|
|
def __rmul__(self, v: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___rmul__(self, v)
|
|
|
|
def __floordiv__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___floordiv__(self, *args)
|
|
|
|
def __mod__(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___mod__(self, *args)
|
|
|
|
def __neg__(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___neg__(self)
|
|
|
|
def __abs__(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr___abs__(self)
|
|
|
|
def Square(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr_Square(self)
|
|
|
|
def __eq__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr___eq__(self, *args)
|
|
|
|
def __ne__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr___ne__(self, *args)
|
|
|
|
def __ge__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr___ge__(self, *args)
|
|
|
|
def __gt__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr___gt__(self, *args)
|
|
|
|
def __le__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr___le__(self, *args)
|
|
|
|
def __lt__(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr___lt__(self, *args)
|
|
|
|
def MapTo(self, vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr_MapTo(self, vars)
|
|
|
|
def IndexOf(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr_IndexOf(self, *args)
|
|
|
|
def IsMember(self, values: 'std::vector< int64 > const &') -> "operations_research::IntVar *":
|
|
return _pywrapcp.IntExpr_IsMember(self, values)
|
|
|
|
def Member(self, values: 'std::vector< int64 > const &') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr_Member(self, values)
|
|
|
|
def NotMember(self, starts: 'std::vector< int64 > const &', ends: 'std::vector< int64 > const &') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr_NotMember(self, starts, ends)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntVar" href="#pywrapcp.IntVar">IntVar</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntExpr.Bound"><code class="name flex">
|
|
<span>def <span class="ident">Bound</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns true if the min and the max of the expression are equal.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Bound(self) -> "bool":
|
|
r""" Returns true if the min and the max of the expression are equal."""
|
|
return _pywrapcp.IntExpr_Bound(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.IndexOf"><code class="name flex">
|
|
<span>def <span class="ident">IndexOf</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IndexOf(self, *args) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr_IndexOf(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.IsMember"><code class="name flex">
|
|
<span>def <span class="ident">IsMember</span></span>(<span>self, values)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsMember(self, values: 'std::vector< int64 > const &') -> "operations_research::IntVar *":
|
|
return _pywrapcp.IntExpr_IsMember(self, values)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.IsVar"><code class="name flex">
|
|
<span>def <span class="ident">IsVar</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns true if the expression is indeed a variable.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsVar(self) -> "bool":
|
|
r""" Returns true if the expression is indeed a variable."""
|
|
return _pywrapcp.IntExpr_IsVar(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.MapTo"><code class="name flex">
|
|
<span>def <span class="ident">MapTo</span></span>(<span>self, vars)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MapTo(self, vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr_MapTo(self, vars)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.Max"><code class="name flex">
|
|
<span>def <span class="ident">Max</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Max(self) -> "int64":
|
|
return _pywrapcp.IntExpr_Max(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.Member"><code class="name flex">
|
|
<span>def <span class="ident">Member</span></span>(<span>self, values)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Member(self, values: 'std::vector< int64 > const &') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr_Member(self, values)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.Min"><code class="name flex">
|
|
<span>def <span class="ident">Min</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Min(self) -> "int64":
|
|
return _pywrapcp.IntExpr_Min(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.NotMember"><code class="name flex">
|
|
<span>def <span class="ident">NotMember</span></span>(<span>self, starts, ends)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NotMember(self, starts: 'std::vector< int64 > const &', ends: 'std::vector< int64 > const &') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntExpr_NotMember(self, starts, ends)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.SetMax"><code class="name flex">
|
|
<span>def <span class="ident">SetMax</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntExpr_SetMax(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.SetMin"><code class="name flex">
|
|
<span>def <span class="ident">SetMin</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntExpr_SetMin(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.SetRange"><code class="name flex">
|
|
<span>def <span class="ident">SetRange</span></span>(<span>self, l, u)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method sets both the min and the max of the expression.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetRange(self, l: 'int64', u: 'int64') -> "void":
|
|
r""" This method sets both the min and the max of the expression."""
|
|
return _pywrapcp.IntExpr_SetRange(self, l, u)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.SetValue"><code class="name flex">
|
|
<span>def <span class="ident">SetValue</span></span>(<span>self, v)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method sets the value of the expression.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetValue(self, v: 'int64') -> "void":
|
|
r""" This method sets the value of the expression."""
|
|
return _pywrapcp.IntExpr_SetValue(self, v)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.Square"><code class="name flex">
|
|
<span>def <span class="ident">Square</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Square(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntExpr_Square(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.Var"><code class="name flex">
|
|
<span>def <span class="ident">Var</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a variable from the expression.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Var(self) -> "operations_research::IntVar *":
|
|
r""" Creates a variable from the expression."""
|
|
return _pywrapcp.IntExpr_Var(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.VarWithName"><code class="name flex">
|
|
<span>def <span class="ident">VarWithName</span></span>(<span>self, name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a variable from the expression and set the name of the resulting var. If the expression is already a variable, then it will set the name of the expression, possibly overwriting it. This is just a shortcut to Var() followed by set_name().</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def VarWithName(self, name: 'std::string const &') -> "operations_research::IntVar *":
|
|
r""" Creates a variable from the expression and set the name of the resulting var. If the expression is already a variable, then it will set the name of the expression, possibly overwriting it. This is just a shortcut to Var() followed by set_name()."""
|
|
return _pywrapcp.IntExpr_VarWithName(self, name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntExpr.WhenRange"><code class="name flex">
|
|
<span>def <span class="ident">WhenRange</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Attach a demon that will watch the min or the max of the expression.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Attach a demon that will watch the min or the max of the expression.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WhenRange(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
Attach a demon that will watch the min or the max of the expression.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Attach a demon that will watch the min or the max of the expression.
|
|
"""
|
|
return _pywrapcp.IntExpr_WhenRange(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.PropagationBaseObject.Name" href="#pywrapcp.PropagationBaseObject.Name">Name</a></code></li>
|
|
<li><code><a title="pywrapcp.PropagationBaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar"><code class="flex name class">
|
|
<span>class <span class="ident">IntVar</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The class IntVar is a subset of IntExpr. In addition to the IntExpr protocol, it offers persistence, removing values from the domains, and a finer model for events.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class IntVar(IntExpr):
|
|
r""" The class IntVar is a subset of IntExpr. In addition to the IntExpr protocol, it offers persistence, removing values from the domains, and a finer model for events."""
|
|
|
|
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 - class is abstract")
|
|
|
|
def IsVar(self) -> "bool":
|
|
return _pywrapcp.IntVar_IsVar(self)
|
|
|
|
def Var(self) -> "operations_research::IntVar *":
|
|
return _pywrapcp.IntVar_Var(self)
|
|
|
|
def Value(self) -> "int64":
|
|
r""" This method returns the value of the variable. This method checks before that the variable is bound."""
|
|
return _pywrapcp.IntVar_Value(self)
|
|
|
|
def RemoveValue(self, v: 'int64') -> "void":
|
|
r""" This method removes the value 'v' from the domain of the variable."""
|
|
return _pywrapcp.IntVar_RemoveValue(self, v)
|
|
|
|
def RemoveInterval(self, l: 'int64', u: 'int64') -> "void":
|
|
r""" This method removes the interval 'l' .. 'u' from the domain of the variable. It assumes that 'l' <= 'u'."""
|
|
return _pywrapcp.IntVar_RemoveInterval(self, l, u)
|
|
|
|
def RemoveValues(self, values: 'std::vector< int64 > const &') -> "void":
|
|
r""" This method remove the values from the domain of the variable."""
|
|
return _pywrapcp.IntVar_RemoveValues(self, values)
|
|
|
|
def SetValues(self, values: 'std::vector< int64 > const &') -> "void":
|
|
r""" This method intersects the current domain with the values in the array."""
|
|
return _pywrapcp.IntVar_SetValues(self, values)
|
|
|
|
def WhenBound(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
This method attaches a demon that will be awakened when the variable is bound.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This method attaches a closure that will be awakened when the variable is bound.
|
|
"""
|
|
return _pywrapcp.IntVar_WhenBound(self, *args)
|
|
|
|
def WhenDomain(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
This method attaches a demon that will watch any domain modification of the domain of the variable.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This method attaches a closure that will watch any domain modification of the domain of the variable.
|
|
"""
|
|
return _pywrapcp.IntVar_WhenDomain(self, *args)
|
|
|
|
def Size(self) -> "uint64":
|
|
r""" This method returns the number of values in the domain of the variable."""
|
|
return _pywrapcp.IntVar_Size(self)
|
|
|
|
def Contains(self, v: 'int64') -> "bool":
|
|
r""" This method returns whether the value 'v' is in the domain of the variable."""
|
|
return _pywrapcp.IntVar_Contains(self, v)
|
|
|
|
def HoleIteratorAux(self, reversible: 'bool') -> "operations_research::IntVarIterator *":
|
|
r""" Creates a hole iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object."""
|
|
return _pywrapcp.IntVar_HoleIteratorAux(self, reversible)
|
|
|
|
def DomainIteratorAux(self, reversible: 'bool') -> "operations_research::IntVarIterator *":
|
|
r""" Creates a domain iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object."""
|
|
return _pywrapcp.IntVar_DomainIteratorAux(self, reversible)
|
|
|
|
def OldMin(self) -> "int64":
|
|
r""" Returns the previous min."""
|
|
return _pywrapcp.IntVar_OldMin(self)
|
|
|
|
def OldMax(self) -> "int64":
|
|
r""" Returns the previous max."""
|
|
return _pywrapcp.IntVar_OldMax(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.IntVar___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.IntVar___str__(self)
|
|
|
|
def DomainIterator(self):
|
|
return iter(self.DomainIteratorAux(False))
|
|
|
|
def HoleIterator(self):
|
|
return iter(self.HoleIteratorAux(False))</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntExpr" href="#pywrapcp.IntExpr">IntExpr</a></li>
|
|
<li><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.BooleanVar" href="#pywrapcp.BooleanVar">BooleanVar</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntVar.Contains"><code class="name flex">
|
|
<span>def <span class="ident">Contains</span></span>(<span>self, v)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method returns whether the value 'v' is in the domain of the variable.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Contains(self, v: 'int64') -> "bool":
|
|
r""" This method returns whether the value 'v' is in the domain of the variable."""
|
|
return _pywrapcp.IntVar_Contains(self, v)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.DomainIterator"><code class="name flex">
|
|
<span>def <span class="ident">DomainIterator</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DomainIterator(self):
|
|
return iter(self.DomainIteratorAux(False))</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.DomainIteratorAux"><code class="name flex">
|
|
<span>def <span class="ident">DomainIteratorAux</span></span>(<span>self, reversible)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a domain iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DomainIteratorAux(self, reversible: 'bool') -> "operations_research::IntVarIterator *":
|
|
r""" Creates a domain iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object."""
|
|
return _pywrapcp.IntVar_DomainIteratorAux(self, reversible)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.HoleIterator"><code class="name flex">
|
|
<span>def <span class="ident">HoleIterator</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HoleIterator(self):
|
|
return iter(self.HoleIteratorAux(False))</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.HoleIteratorAux"><code class="name flex">
|
|
<span>def <span class="ident">HoleIteratorAux</span></span>(<span>self, reversible)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a hole iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HoleIteratorAux(self, reversible: 'bool') -> "operations_research::IntVarIterator *":
|
|
r""" Creates a hole iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object."""
|
|
return _pywrapcp.IntVar_HoleIteratorAux(self, reversible)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.OldMax"><code class="name flex">
|
|
<span>def <span class="ident">OldMax</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the previous max.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OldMax(self) -> "int64":
|
|
r""" Returns the previous max."""
|
|
return _pywrapcp.IntVar_OldMax(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.OldMin"><code class="name flex">
|
|
<span>def <span class="ident">OldMin</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the previous min.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OldMin(self) -> "int64":
|
|
r""" Returns the previous min."""
|
|
return _pywrapcp.IntVar_OldMin(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.RemoveInterval"><code class="name flex">
|
|
<span>def <span class="ident">RemoveInterval</span></span>(<span>self, l, u)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method removes the interval 'l' .. 'u' from the domain of the variable. It assumes that 'l' <= 'u'.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RemoveInterval(self, l: 'int64', u: 'int64') -> "void":
|
|
r""" This method removes the interval 'l' .. 'u' from the domain of the variable. It assumes that 'l' <= 'u'."""
|
|
return _pywrapcp.IntVar_RemoveInterval(self, l, u)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.RemoveValue"><code class="name flex">
|
|
<span>def <span class="ident">RemoveValue</span></span>(<span>self, v)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method removes the value 'v' from the domain of the variable.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RemoveValue(self, v: 'int64') -> "void":
|
|
r""" This method removes the value 'v' from the domain of the variable."""
|
|
return _pywrapcp.IntVar_RemoveValue(self, v)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.RemoveValues"><code class="name flex">
|
|
<span>def <span class="ident">RemoveValues</span></span>(<span>self, values)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method remove the values from the domain of the variable.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RemoveValues(self, values: 'std::vector< int64 > const &') -> "void":
|
|
r""" This method remove the values from the domain of the variable."""
|
|
return _pywrapcp.IntVar_RemoveValues(self, values)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.SetValues"><code class="name flex">
|
|
<span>def <span class="ident">SetValues</span></span>(<span>self, values)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method intersects the current domain with the values in the array.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetValues(self, values: 'std::vector< int64 > const &') -> "void":
|
|
r""" This method intersects the current domain with the values in the array."""
|
|
return _pywrapcp.IntVar_SetValues(self, values)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.Size"><code class="name flex">
|
|
<span>def <span class="ident">Size</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method returns the number of values in the domain of the variable.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Size(self) -> "uint64":
|
|
r""" This method returns the number of values in the domain of the variable."""
|
|
return _pywrapcp.IntVar_Size(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.Value"><code class="name flex">
|
|
<span>def <span class="ident">Value</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method returns the value of the variable. This method checks before that the variable is bound.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Value(self) -> "int64":
|
|
r""" This method returns the value of the variable. This method checks before that the variable is bound."""
|
|
return _pywrapcp.IntVar_Value(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.WhenBound"><code class="name flex">
|
|
<span>def <span class="ident">WhenBound</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
This method attaches a demon that will be awakened when the variable is bound.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
This method attaches a closure that will be awakened when the variable is bound.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WhenBound(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
This method attaches a demon that will be awakened when the variable is bound.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This method attaches a closure that will be awakened when the variable is bound.
|
|
"""
|
|
return _pywrapcp.IntVar_WhenBound(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVar.WhenDomain"><code class="name flex">
|
|
<span>def <span class="ident">WhenDomain</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
This method attaches a demon that will watch any domain modification of the domain of the variable.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
This method attaches a closure that will watch any domain modification of the domain of the variable.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WhenDomain(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
This method attaches a demon that will watch any domain modification of the domain of the variable.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This method attaches a closure that will watch any domain modification of the domain of the variable.
|
|
"""
|
|
return _pywrapcp.IntVar_WhenDomain(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.IntExpr" href="#pywrapcp.IntExpr">IntExpr</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.IntExpr.Bound" href="#pywrapcp.IntExpr.Bound">Bound</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.IsVar" href="#pywrapcp.IntExpr.IsVar">IsVar</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.Name" href="#pywrapcp.PropagationBaseObject.Name">Name</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.SetRange" href="#pywrapcp.IntExpr.SetRange">SetRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.SetValue" href="#pywrapcp.IntExpr.SetValue">SetValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.Var" href="#pywrapcp.IntExpr.Var">Var</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.VarWithName" href="#pywrapcp.IntExpr.VarWithName">VarWithName</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.WhenRange" href="#pywrapcp.IntExpr.WhenRange">WhenRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarContainer"><code class="flex name class">
|
|
<span>class <span class="ident">IntVarContainer</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class IntVarContainer(object):
|
|
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 Contains(self, var: 'IntVar') -> "bool":
|
|
return _pywrapcp.IntVarContainer_Contains(self, var)
|
|
|
|
def Element(self, index: 'int') -> "operations_research::IntVarElement *":
|
|
return _pywrapcp.IntVarContainer_Element(self, index)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.IntVarContainer_Size(self)
|
|
|
|
def Store(self) -> "void":
|
|
return _pywrapcp.IntVarContainer_Store(self)
|
|
|
|
def Restore(self) -> "void":
|
|
return _pywrapcp.IntVarContainer_Restore(self)
|
|
|
|
def __eq__(self, container: 'IntVarContainer') -> "bool":
|
|
r""" Returns true if this and 'container' both represent the same V* -> E map. Runs in linear time; requires that the == operator on the type E is well defined."""
|
|
return _pywrapcp.IntVarContainer___eq__(self, container)
|
|
|
|
def __ne__(self, container: 'IntVarContainer') -> "bool":
|
|
return _pywrapcp.IntVarContainer___ne__(self, container)
|
|
__swig_destroy__ = _pywrapcp.delete_IntVarContainer</code></pre>
|
|
</details>
|
|
<h3>Instance variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntVarContainer.thisown"><code class="name">var <span class="ident">thisown</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The membership flag</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntVarContainer.Contains"><code class="name flex">
|
|
<span>def <span class="ident">Contains</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Contains(self, var: 'IntVar') -> "bool":
|
|
return _pywrapcp.IntVarContainer_Contains(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarContainer.Element"><code class="name flex">
|
|
<span>def <span class="ident">Element</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Element(self, index: 'int') -> "operations_research::IntVarElement *":
|
|
return _pywrapcp.IntVarContainer_Element(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarContainer.Restore"><code class="name flex">
|
|
<span>def <span class="ident">Restore</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Restore(self) -> "void":
|
|
return _pywrapcp.IntVarContainer_Restore(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarContainer.Size"><code class="name flex">
|
|
<span>def <span class="ident">Size</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Size(self) -> "int":
|
|
return _pywrapcp.IntVarContainer_Size(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarContainer.Store"><code class="name flex">
|
|
<span>def <span class="ident">Store</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Store(self) -> "void":
|
|
return _pywrapcp.IntVarContainer_Store(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarElement"><code class="flex name class">
|
|
<span>class <span class="ident">IntVarElement</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class IntVarElement(AssignmentElement):
|
|
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 Var(self) -> "operations_research::IntVar *":
|
|
return _pywrapcp.IntVarElement_Var(self)
|
|
|
|
def Min(self) -> "int64":
|
|
return _pywrapcp.IntVarElement_Min(self)
|
|
|
|
def SetMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntVarElement_SetMin(self, m)
|
|
|
|
def Max(self) -> "int64":
|
|
return _pywrapcp.IntVarElement_Max(self)
|
|
|
|
def SetMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntVarElement_SetMax(self, m)
|
|
|
|
def Value(self) -> "int64":
|
|
return _pywrapcp.IntVarElement_Value(self)
|
|
|
|
def Bound(self) -> "bool":
|
|
return _pywrapcp.IntVarElement_Bound(self)
|
|
|
|
def SetRange(self, l: 'int64', u: 'int64') -> "void":
|
|
return _pywrapcp.IntVarElement_SetRange(self, l, u)
|
|
|
|
def SetValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntVarElement_SetValue(self, v)
|
|
|
|
def __eq__(self, element: 'IntVarElement') -> "bool":
|
|
return _pywrapcp.IntVarElement___eq__(self, element)
|
|
|
|
def __ne__(self, element: 'IntVarElement') -> "bool":
|
|
return _pywrapcp.IntVarElement___ne__(self, element)
|
|
__swig_destroy__ = _pywrapcp.delete_IntVarElement</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.AssignmentElement" href="#pywrapcp.AssignmentElement">AssignmentElement</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntVarElement.Bound"><code class="name flex">
|
|
<span>def <span class="ident">Bound</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Bound(self) -> "bool":
|
|
return _pywrapcp.IntVarElement_Bound(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarElement.Max"><code class="name flex">
|
|
<span>def <span class="ident">Max</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Max(self) -> "int64":
|
|
return _pywrapcp.IntVarElement_Max(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarElement.Min"><code class="name flex">
|
|
<span>def <span class="ident">Min</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Min(self) -> "int64":
|
|
return _pywrapcp.IntVarElement_Min(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarElement.SetMax"><code class="name flex">
|
|
<span>def <span class="ident">SetMax</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntVarElement_SetMax(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarElement.SetMin"><code class="name flex">
|
|
<span>def <span class="ident">SetMin</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntVarElement_SetMin(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarElement.SetRange"><code class="name flex">
|
|
<span>def <span class="ident">SetRange</span></span>(<span>self, l, u)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetRange(self, l: 'int64', u: 'int64') -> "void":
|
|
return _pywrapcp.IntVarElement_SetRange(self, l, u)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarElement.SetValue"><code class="name flex">
|
|
<span>def <span class="ident">SetValue</span></span>(<span>self, v)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntVarElement_SetValue(self, v)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarElement.Value"><code class="name flex">
|
|
<span>def <span class="ident">Value</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Value(self) -> "int64":
|
|
return _pywrapcp.IntVarElement_Value(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarElement.Var"><code class="name flex">
|
|
<span>def <span class="ident">Var</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Var(self) -> "operations_research::IntVar *":
|
|
return _pywrapcp.IntVarElement_Var(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.AssignmentElement" href="#pywrapcp.AssignmentElement">AssignmentElement</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.AssignmentElement.thisown" href="#pywrapcp.AssignmentElement.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarFilteredDecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">IntVarFilteredDecisionBuilder</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class IntVarFilteredDecisionBuilder(DecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_IntVarFilteredDecisionBuilder
|
|
|
|
def NextWrapper(self, solver: 'Solver') -> "operations_research::Decision *":
|
|
return _pywrapcp.IntVarFilteredDecisionBuilder_NextWrapper(self, solver)
|
|
|
|
def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.IntVarFilteredDecisionBuilder_BuildSolution(self)
|
|
|
|
def number_of_decisions(self) -> "int64":
|
|
return _pywrapcp.IntVarFilteredDecisionBuilder_number_of_decisions(self)
|
|
|
|
def number_of_rejects(self) -> "int64":
|
|
return _pywrapcp.IntVarFilteredDecisionBuilder_number_of_rejects(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntVarFilteredDecisionBuilder.BuildSolution"><code class="name flex">
|
|
<span>def <span class="ident">BuildSolution</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.IntVarFilteredDecisionBuilder_BuildSolution(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarFilteredDecisionBuilder.number_of_decisions"><code class="name flex">
|
|
<span>def <span class="ident">number_of_decisions</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def number_of_decisions(self) -> "int64":
|
|
return _pywrapcp.IntVarFilteredDecisionBuilder_number_of_decisions(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarFilteredDecisionBuilder.number_of_rejects"><code class="name flex">
|
|
<span>def <span class="ident">number_of_rejects</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def number_of_rejects(self) -> "int64":
|
|
return _pywrapcp.IntVarFilteredDecisionBuilder_number_of_rejects(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.DecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.DecisionBuilder.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarIterator"><code class="flex name class">
|
|
<span>class <span class="ident">IntVarIterator</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The class Iterator has two direct subclasses. HoleIterators iterates over all holes, that is value removed between the current min and max of the variable since the last time the variable was processed in the queue. DomainIterators iterates over all elements of the variable domain. Both iterators are not robust to domain changes. Hole iterators can also report values outside the current min and max of the variable. HoleIterators should only be called from a demon attached to the variable that has created this iterator. IntVar* current_var; std::unique_ptr<IntVarIterator> it(current_var->MakeHoleIterator(false)); for (const int64 hole : InitAndGetValues(it)) {
|
|
/// use the hole }</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class IntVarIterator(BaseObject):
|
|
r""" The class Iterator has two direct subclasses. HoleIterators iterates over all holes, that is value removed between the current min and max of the variable since the last time the variable was processed in the queue. DomainIterators iterates over all elements of the variable domain. Both iterators are not robust to domain changes. Hole iterators can also report values outside the current min and max of the variable. HoleIterators should only be called from a demon attached to the variable that has created this iterator. IntVar* current_var; std::unique_ptr<IntVarIterator> it(current_var->MakeHoleIterator(false)); for (const int64 hole : InitAndGetValues(it)) { /// use the hole }"""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def Init(self) -> "void":
|
|
r""" This method must be called before each loop."""
|
|
return _pywrapcp.IntVarIterator_Init(self)
|
|
|
|
def Ok(self) -> "bool":
|
|
r""" This method indicates if we can call Value() or not."""
|
|
return _pywrapcp.IntVarIterator_Ok(self)
|
|
|
|
def Value(self) -> "int64":
|
|
r""" This method returns the current value of the iterator."""
|
|
return _pywrapcp.IntVarIterator_Value(self)
|
|
|
|
def Next(self) -> "void":
|
|
r""" This method moves the iterator to the next value."""
|
|
return _pywrapcp.IntVarIterator_Next(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
r""" Pretty Print."""
|
|
return _pywrapcp.IntVarIterator_DebugString(self)
|
|
|
|
def __iter__(self):
|
|
self.Init()
|
|
return self
|
|
|
|
def next(self):
|
|
if self.Ok():
|
|
result = self.Value()
|
|
self.Next()
|
|
return result
|
|
else:
|
|
raise StopIteration()
|
|
|
|
def __next__(self):
|
|
return self.next()</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntVarIterator.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Pretty Print.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
r""" Pretty Print."""
|
|
return _pywrapcp.IntVarIterator_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarIterator.Init"><code class="name flex">
|
|
<span>def <span class="ident">Init</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method must be called before each loop.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Init(self) -> "void":
|
|
r""" This method must be called before each loop."""
|
|
return _pywrapcp.IntVarIterator_Init(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarIterator.Next"><code class="name flex">
|
|
<span>def <span class="ident">Next</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method moves the iterator to the next value.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Next(self) -> "void":
|
|
r""" This method moves the iterator to the next value."""
|
|
return _pywrapcp.IntVarIterator_Next(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarIterator.Ok"><code class="name flex">
|
|
<span>def <span class="ident">Ok</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method indicates if we can call Value() or not.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Ok(self) -> "bool":
|
|
r""" This method indicates if we can call Value() or not."""
|
|
return _pywrapcp.IntVarIterator_Ok(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarIterator.Value"><code class="name flex">
|
|
<span>def <span class="ident">Value</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method returns the current value of the iterator.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Value(self) -> "int64":
|
|
r""" This method returns the current value of the iterator."""
|
|
return _pywrapcp.IntVarIterator_Value(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarIterator.next"><code class="name flex">
|
|
<span>def <span class="ident">next</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def next(self):
|
|
if self.Ok():
|
|
result = self.Value()
|
|
self.Next()
|
|
return result
|
|
else:
|
|
raise StopIteration()</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.BaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarLocalSearchFilter"><code class="flex name class">
|
|
<span>class <span class="ident">IntVarLocalSearchFilter</span></span>
|
|
<span>(</span><span>*args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Local Search Filters are used for fast neighbor pruning.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class IntVarLocalSearchFilter(LocalSearchFilter):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
if self.__class__ == IntVarLocalSearchFilter:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.IntVarLocalSearchFilter_swiginit(self, _pywrapcp.new_IntVarLocalSearchFilter(_self, *args))
|
|
__swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchFilter
|
|
|
|
def Synchronize(self, assignment: 'Assignment', delta: 'Assignment') -> "void":
|
|
r""" This method should not be overridden. Override OnSynchronize() instead which is called before exiting this method."""
|
|
return _pywrapcp.IntVarLocalSearchFilter_Synchronize(self, assignment, delta)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.IntVarLocalSearchFilter_Size(self)
|
|
|
|
def Value(self, index: 'int') -> "int64":
|
|
return _pywrapcp.IntVarLocalSearchFilter_Value(self, index)
|
|
|
|
def IndexFromVar(self, var: 'IntVar') -> "int64":
|
|
return _pywrapcp.IntVarLocalSearchFilter_IndexFromVar(self, var)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_IntVarLocalSearchFilter(self)
|
|
return weakref.proxy(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.LocalSearchFilter" href="#pywrapcp.LocalSearchFilter">LocalSearchFilter</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.BasePathFilter" href="#pywrapcp.BasePathFilter">BasePathFilter</a></li>
|
|
<li><a title="pywrapcp.CPFeasibilityFilter" href="#pywrapcp.CPFeasibilityFilter">CPFeasibilityFilter</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntVarLocalSearchFilter.IndexFromVar"><code class="name flex">
|
|
<span>def <span class="ident">IndexFromVar</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IndexFromVar(self, var: 'IntVar') -> "int64":
|
|
return _pywrapcp.IntVarLocalSearchFilter_IndexFromVar(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarLocalSearchFilter.Size"><code class="name flex">
|
|
<span>def <span class="ident">Size</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Size(self) -> "int":
|
|
return _pywrapcp.IntVarLocalSearchFilter_Size(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarLocalSearchFilter.Synchronize"><code class="name flex">
|
|
<span>def <span class="ident">Synchronize</span></span>(<span>self, assignment, delta)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method should not be overridden. Override OnSynchronize() instead which is called before exiting this method.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Synchronize(self, assignment: 'Assignment', delta: 'Assignment') -> "void":
|
|
r""" This method should not be overridden. Override OnSynchronize() instead which is called before exiting this method."""
|
|
return _pywrapcp.IntVarLocalSearchFilter_Synchronize(self, assignment, delta)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarLocalSearchFilter.Value"><code class="name flex">
|
|
<span>def <span class="ident">Value</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Value(self, index: 'int') -> "int64":
|
|
return _pywrapcp.IntVarLocalSearchFilter_Value(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.LocalSearchFilter" href="#pywrapcp.LocalSearchFilter">LocalSearchFilter</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.LocalSearchFilter.Accept" href="#pywrapcp.LocalSearchFilter.Accept">Accept</a></code></li>
|
|
<li><code><a title="pywrapcp.LocalSearchFilter.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarLocalSearchOperator"><code class="flex name class">
|
|
<span>class <span class="ident">IntVarLocalSearchOperator</span></span>
|
|
<span>(</span><span>*args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>clang-format on</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class IntVarLocalSearchOperator(IntVarLocalSearchOperatorTemplate):
|
|
r""" clang-format on"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
if self.__class__ == IntVarLocalSearchOperator:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.IntVarLocalSearchOperator_swiginit(self, _pywrapcp.new_IntVarLocalSearchOperator(_self, *args))
|
|
__swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchOperator
|
|
|
|
def NextNeighbor(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
r""" Redefines MakeNextNeighbor to export a simpler interface. The calls to ApplyChanges() and RevertChanges() are factored in this method, hiding both delta and deltadelta from subclasses which only need to override MakeOneNeighbor(). Therefore this method should not be overridden. Override MakeOneNeighbor() instead."""
|
|
return _pywrapcp.IntVarLocalSearchOperator_NextNeighbor(self, delta, deltadelta)
|
|
|
|
def OneNeighbor(self) -> "bool":
|
|
r""" Creates a new neighbor. It returns false when the neighborhood is completely explored. MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator."""
|
|
return _pywrapcp.IntVarLocalSearchOperator_OneNeighbor(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_IntVarLocalSearchOperator(self)
|
|
return weakref.proxy(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntVarLocalSearchOperatorTemplate" href="#pywrapcp.IntVarLocalSearchOperatorTemplate">IntVarLocalSearchOperatorTemplate</a></li>
|
|
<li><a title="pywrapcp.LocalSearchOperator" href="#pywrapcp.LocalSearchOperator">LocalSearchOperator</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.BaseLns" href="#pywrapcp.BaseLns">BaseLns</a></li>
|
|
<li><a title="pywrapcp.ChangeValue" href="#pywrapcp.ChangeValue">ChangeValue</a></li>
|
|
<li><a title="pywrapcp.PathOperator" href="#pywrapcp.PathOperator">PathOperator</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntVarLocalSearchOperator.NextNeighbor"><code class="name flex">
|
|
<span>def <span class="ident">NextNeighbor</span></span>(<span>self, delta, deltadelta)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Redefines MakeNextNeighbor to export a simpler interface. The calls to ApplyChanges() and RevertChanges() are factored in this method, hiding both delta and deltadelta from subclasses which only need to override MakeOneNeighbor(). Therefore this method should not be overridden. Override MakeOneNeighbor() instead.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NextNeighbor(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
r""" Redefines MakeNextNeighbor to export a simpler interface. The calls to ApplyChanges() and RevertChanges() are factored in this method, hiding both delta and deltadelta from subclasses which only need to override MakeOneNeighbor(). Therefore this method should not be overridden. Override MakeOneNeighbor() instead."""
|
|
return _pywrapcp.IntVarLocalSearchOperator_NextNeighbor(self, delta, deltadelta)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarLocalSearchOperator.OneNeighbor"><code class="name flex">
|
|
<span>def <span class="ident">OneNeighbor</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a new neighbor. It returns false when the neighborhood is completely explored. MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OneNeighbor(self) -> "bool":
|
|
r""" Creates a new neighbor. It returns false when the neighborhood is completely explored. MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator."""
|
|
return _pywrapcp.IntVarLocalSearchOperator_OneNeighbor(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.IntVarLocalSearchOperatorTemplate" href="#pywrapcp.IntVarLocalSearchOperatorTemplate">IntVarLocalSearchOperatorTemplate</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperatorTemplate.OnStart" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.OnStart">OnStart</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperatorTemplate.Start" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.Start">Start</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperatorTemplate.Value" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.Value">Value</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperatorTemplate.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarLocalSearchOperatorTemplate"><code class="flex name class">
|
|
<span>class <span class="ident">IntVarLocalSearchOperatorTemplate</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Base operator class for operators manipulating variables.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class IntVarLocalSearchOperatorTemplate(LocalSearchOperator):
|
|
r""" Base operator class for operators manipulating variables."""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def Start(self, assignment: 'Assignment') -> "void":
|
|
r""" This method should not be overridden. Override OnStart() instead which is called before exiting this method."""
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_Start(self, assignment)
|
|
|
|
def IsIncremental(self) -> "bool":
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_IsIncremental(self)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_Size(self)
|
|
|
|
def Value(self, index: 'int64') -> "long long const &":
|
|
r""" Returns the value in the current assignment of the variable of given index."""
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_Value(self, index)
|
|
|
|
def OldValue(self, index: 'int64') -> "long long const &":
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_OldValue(self, index)
|
|
|
|
def SetValue(self, index: 'int64', value: 'long long const &') -> "void":
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_SetValue(self, index, value)
|
|
|
|
def OnStart(self) -> "void":
|
|
r""" Called by Start() after synchronizing the operator with the current assignment. Should be overridden instead of Start() to avoid calling VarLocalSearchOperator::Start explicitly."""
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_OnStart(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.LocalSearchOperator" href="#pywrapcp.LocalSearchOperator">LocalSearchOperator</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntVarLocalSearchOperator" href="#pywrapcp.IntVarLocalSearchOperator">IntVarLocalSearchOperator</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntVarLocalSearchOperatorTemplate.IsIncremental"><code class="name flex">
|
|
<span>def <span class="ident">IsIncremental</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsIncremental(self) -> "bool":
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_IsIncremental(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarLocalSearchOperatorTemplate.OldValue"><code class="name flex">
|
|
<span>def <span class="ident">OldValue</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OldValue(self, index: 'int64') -> "long long const &":
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_OldValue(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarLocalSearchOperatorTemplate.OnStart"><code class="name flex">
|
|
<span>def <span class="ident">OnStart</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Called by Start() after synchronizing the operator with the current assignment. Should be overridden instead of Start() to avoid calling VarLocalSearchOperator::Start explicitly.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OnStart(self) -> "void":
|
|
r""" Called by Start() after synchronizing the operator with the current assignment. Should be overridden instead of Start() to avoid calling VarLocalSearchOperator::Start explicitly."""
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_OnStart(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarLocalSearchOperatorTemplate.SetValue"><code class="name flex">
|
|
<span>def <span class="ident">SetValue</span></span>(<span>self, index, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetValue(self, index: 'int64', value: 'long long const &') -> "void":
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_SetValue(self, index, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarLocalSearchOperatorTemplate.Size"><code class="name flex">
|
|
<span>def <span class="ident">Size</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Size(self) -> "int":
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_Size(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarLocalSearchOperatorTemplate.Start"><code class="name flex">
|
|
<span>def <span class="ident">Start</span></span>(<span>self, assignment)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method should not be overridden. Override OnStart() instead which is called before exiting this method.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Start(self, assignment: 'Assignment') -> "void":
|
|
r""" This method should not be overridden. Override OnStart() instead which is called before exiting this method."""
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_Start(self, assignment)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntVarLocalSearchOperatorTemplate.Value"><code class="name flex">
|
|
<span>def <span class="ident">Value</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the value in the current assignment of the variable of given index.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Value(self, index: 'int64') -> "long long const &":
|
|
r""" Returns the value in the current assignment of the variable of given index."""
|
|
return _pywrapcp.IntVarLocalSearchOperatorTemplate_Value(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.LocalSearchOperator" href="#pywrapcp.LocalSearchOperator">LocalSearchOperator</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.LocalSearchOperator.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar"><code class="flex name class">
|
|
<span>class <span class="ident">IntervalVar</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Interval variables are often used in scheduling. The main characteristics of an IntervalVar are the start position, duration, and end date. All these characteristics can be queried and set, and demons can be posted on their modifications. An important aspect is optionality: an IntervalVar can be performed or not. If unperformed, then it simply does not exist, and its characteristics cannot be accessed any more. An interval var is automatically marked as unperformed when it is not consistent anymore (start greater than end, duration < 0…)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class IntervalVar(PropagationBaseObject):
|
|
r""" Interval variables are often used in scheduling. The main characteristics of an IntervalVar are the start position, duration, and end date. All these characteristics can be queried and set, and demons can be posted on their modifications. An important aspect is optionality: an IntervalVar can be performed or not. If unperformed, then it simply does not exist, and its characteristics cannot be accessed any more. An interval var is automatically marked as unperformed when it is not consistent anymore (start greater than end, duration < 0...)"""
|
|
|
|
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 - class is abstract")
|
|
|
|
def StartMin(self) -> "int64":
|
|
r""" These methods query, set, and watch the start position of the interval var."""
|
|
return _pywrapcp.IntervalVar_StartMin(self)
|
|
|
|
def StartMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_StartMax(self)
|
|
|
|
def SetStartMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetStartMin(self, m)
|
|
|
|
def SetStartMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetStartMax(self, m)
|
|
|
|
def SetStartRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetStartRange(self, mi, ma)
|
|
|
|
def OldStartMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldStartMin(self)
|
|
|
|
def OldStartMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldStartMax(self)
|
|
|
|
def WhenStartRange(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenStartRange(self, *args)
|
|
|
|
def WhenStartBound(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenStartBound(self, *args)
|
|
|
|
def DurationMin(self) -> "int64":
|
|
r""" These methods query, set, and watch the duration of the interval var."""
|
|
return _pywrapcp.IntervalVar_DurationMin(self)
|
|
|
|
def DurationMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_DurationMax(self)
|
|
|
|
def SetDurationMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetDurationMin(self, m)
|
|
|
|
def SetDurationMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetDurationMax(self, m)
|
|
|
|
def SetDurationRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetDurationRange(self, mi, ma)
|
|
|
|
def OldDurationMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldDurationMin(self)
|
|
|
|
def OldDurationMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldDurationMax(self)
|
|
|
|
def WhenDurationRange(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenDurationRange(self, *args)
|
|
|
|
def WhenDurationBound(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenDurationBound(self, *args)
|
|
|
|
def EndMin(self) -> "int64":
|
|
r""" These methods query, set, and watch the end position of the interval var."""
|
|
return _pywrapcp.IntervalVar_EndMin(self)
|
|
|
|
def EndMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_EndMax(self)
|
|
|
|
def SetEndMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetEndMin(self, m)
|
|
|
|
def SetEndMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetEndMax(self, m)
|
|
|
|
def SetEndRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetEndRange(self, mi, ma)
|
|
|
|
def OldEndMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldEndMin(self)
|
|
|
|
def OldEndMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldEndMax(self)
|
|
|
|
def WhenEndRange(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenEndRange(self, *args)
|
|
|
|
def WhenEndBound(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenEndBound(self, *args)
|
|
|
|
def MustBePerformed(self) -> "bool":
|
|
r""" These methods query, set, and watch the performed status of the interval var."""
|
|
return _pywrapcp.IntervalVar_MustBePerformed(self)
|
|
|
|
def MayBePerformed(self) -> "bool":
|
|
return _pywrapcp.IntervalVar_MayBePerformed(self)
|
|
|
|
def CannotBePerformed(self) -> "bool":
|
|
return _pywrapcp.IntervalVar_CannotBePerformed(self)
|
|
|
|
def IsPerformedBound(self) -> "bool":
|
|
return _pywrapcp.IntervalVar_IsPerformedBound(self)
|
|
|
|
def SetPerformed(self, val: 'bool') -> "void":
|
|
return _pywrapcp.IntervalVar_SetPerformed(self, val)
|
|
|
|
def WasPerformedBound(self) -> "bool":
|
|
return _pywrapcp.IntervalVar_WasPerformedBound(self)
|
|
|
|
def WhenPerformedBound(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenPerformedBound(self, *args)
|
|
|
|
def WhenAnything(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
Attaches a demon awakened when anything about this interval changes.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Attaches a closure awakened when anything about this interval changes.
|
|
"""
|
|
return _pywrapcp.IntervalVar_WhenAnything(self, *args)
|
|
|
|
def StartExpr(self) -> "operations_research::IntExpr *":
|
|
r""" These methods create expressions encapsulating the start, end and duration of the interval var. Please note that these must not be used if the interval var is unperformed."""
|
|
return _pywrapcp.IntervalVar_StartExpr(self)
|
|
|
|
def DurationExpr(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_DurationExpr(self)
|
|
|
|
def EndExpr(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_EndExpr(self)
|
|
|
|
def PerformedExpr(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_PerformedExpr(self)
|
|
|
|
def SafeStartExpr(self, unperformed_value: 'int64') -> "operations_research::IntExpr *":
|
|
r""" These methods create expressions encapsulating the start, end and duration of the interval var. If the interval var is unperformed, they will return the unperformed_value."""
|
|
return _pywrapcp.IntervalVar_SafeStartExpr(self, unperformed_value)
|
|
|
|
def SafeDurationExpr(self, unperformed_value: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_SafeDurationExpr(self, unperformed_value)
|
|
|
|
def SafeEndExpr(self, unperformed_value: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_SafeEndExpr(self, unperformed_value)
|
|
|
|
def EndsAfterEnd(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfterEnd(self, other)
|
|
|
|
def EndsAfterEndWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfterEndWithDelay(self, other, delay)
|
|
|
|
def EndsAfterStart(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfterStart(self, other)
|
|
|
|
def EndsAfterStartWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfterStartWithDelay(self, other, delay)
|
|
|
|
def EndsAtEnd(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAtEnd(self, other)
|
|
|
|
def EndsAtEndWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAtEndWithDelay(self, other, delay)
|
|
|
|
def EndsAtStart(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAtStart(self, other)
|
|
|
|
def EndsAtStartWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAtStartWithDelay(self, other, delay)
|
|
|
|
def StartsAfterEnd(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfterEnd(self, other)
|
|
|
|
def StartsAfterEndWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfterEndWithDelay(self, other, delay)
|
|
|
|
def StartsAfterStart(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfterStart(self, other)
|
|
|
|
def StartsAfterStartWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfterStartWithDelay(self, other, delay)
|
|
|
|
def StartsAtEnd(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAtEnd(self, other)
|
|
|
|
def StartsAtEndWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAtEndWithDelay(self, other, delay)
|
|
|
|
def StartsAtStart(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAtStart(self, other)
|
|
|
|
def StartsAtStartWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAtStartWithDelay(self, other, delay)
|
|
|
|
def StaysInSync(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StaysInSync(self, other)
|
|
|
|
def StaysInSyncWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StaysInSyncWithDelay(self, other, delay)
|
|
|
|
def EndsAfter(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfter(self, date)
|
|
|
|
def EndsAt(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAt(self, date)
|
|
|
|
def EndsBefore(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsBefore(self, date)
|
|
|
|
def StartsAfter(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfter(self, date)
|
|
|
|
def StartsAt(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAt(self, date)
|
|
|
|
def StartsBefore(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsBefore(self, date)
|
|
|
|
def CrossesDate(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_CrossesDate(self, date)
|
|
|
|
def AvoidsDate(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_AvoidsDate(self, date)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.IntervalVar___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.IntervalVar___str__(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntervalVar.AvoidsDate"><code class="name flex">
|
|
<span>def <span class="ident">AvoidsDate</span></span>(<span>self, date)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AvoidsDate(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_AvoidsDate(self, date)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.CannotBePerformed"><code class="name flex">
|
|
<span>def <span class="ident">CannotBePerformed</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CannotBePerformed(self) -> "bool":
|
|
return _pywrapcp.IntervalVar_CannotBePerformed(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.CrossesDate"><code class="name flex">
|
|
<span>def <span class="ident">CrossesDate</span></span>(<span>self, date)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CrossesDate(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_CrossesDate(self, date)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.DurationExpr"><code class="name flex">
|
|
<span>def <span class="ident">DurationExpr</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DurationExpr(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_DurationExpr(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.DurationMax"><code class="name flex">
|
|
<span>def <span class="ident">DurationMax</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DurationMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_DurationMax(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.DurationMin"><code class="name flex">
|
|
<span>def <span class="ident">DurationMin</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>These methods query, set, and watch the duration of the interval var.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DurationMin(self) -> "int64":
|
|
r""" These methods query, set, and watch the duration of the interval var."""
|
|
return _pywrapcp.IntervalVar_DurationMin(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndExpr"><code class="name flex">
|
|
<span>def <span class="ident">EndExpr</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndExpr(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_EndExpr(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndMax"><code class="name flex">
|
|
<span>def <span class="ident">EndMax</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_EndMax(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndMin"><code class="name flex">
|
|
<span>def <span class="ident">EndMin</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>These methods query, set, and watch the end position of the interval var.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndMin(self) -> "int64":
|
|
r""" These methods query, set, and watch the end position of the interval var."""
|
|
return _pywrapcp.IntervalVar_EndMin(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndsAfter"><code class="name flex">
|
|
<span>def <span class="ident">EndsAfter</span></span>(<span>self, date)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndsAfter(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfter(self, date)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndsAfterEnd"><code class="name flex">
|
|
<span>def <span class="ident">EndsAfterEnd</span></span>(<span>self, other)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndsAfterEnd(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfterEnd(self, other)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndsAfterEndWithDelay"><code class="name flex">
|
|
<span>def <span class="ident">EndsAfterEndWithDelay</span></span>(<span>self, other, delay)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndsAfterEndWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfterEndWithDelay(self, other, delay)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndsAfterStart"><code class="name flex">
|
|
<span>def <span class="ident">EndsAfterStart</span></span>(<span>self, other)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndsAfterStart(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfterStart(self, other)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndsAfterStartWithDelay"><code class="name flex">
|
|
<span>def <span class="ident">EndsAfterStartWithDelay</span></span>(<span>self, other, delay)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndsAfterStartWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAfterStartWithDelay(self, other, delay)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndsAt"><code class="name flex">
|
|
<span>def <span class="ident">EndsAt</span></span>(<span>self, date)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndsAt(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAt(self, date)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndsAtEnd"><code class="name flex">
|
|
<span>def <span class="ident">EndsAtEnd</span></span>(<span>self, other)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndsAtEnd(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAtEnd(self, other)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndsAtEndWithDelay"><code class="name flex">
|
|
<span>def <span class="ident">EndsAtEndWithDelay</span></span>(<span>self, other, delay)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndsAtEndWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAtEndWithDelay(self, other, delay)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndsAtStart"><code class="name flex">
|
|
<span>def <span class="ident">EndsAtStart</span></span>(<span>self, other)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndsAtStart(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAtStart(self, other)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndsAtStartWithDelay"><code class="name flex">
|
|
<span>def <span class="ident">EndsAtStartWithDelay</span></span>(<span>self, other, delay)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndsAtStartWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsAtStartWithDelay(self, other, delay)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.EndsBefore"><code class="name flex">
|
|
<span>def <span class="ident">EndsBefore</span></span>(<span>self, date)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndsBefore(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_EndsBefore(self, date)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.IsPerformedBound"><code class="name flex">
|
|
<span>def <span class="ident">IsPerformedBound</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsPerformedBound(self) -> "bool":
|
|
return _pywrapcp.IntervalVar_IsPerformedBound(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.MayBePerformed"><code class="name flex">
|
|
<span>def <span class="ident">MayBePerformed</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MayBePerformed(self) -> "bool":
|
|
return _pywrapcp.IntervalVar_MayBePerformed(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.MustBePerformed"><code class="name flex">
|
|
<span>def <span class="ident">MustBePerformed</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>These methods query, set, and watch the performed status of the interval var.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MustBePerformed(self) -> "bool":
|
|
r""" These methods query, set, and watch the performed status of the interval var."""
|
|
return _pywrapcp.IntervalVar_MustBePerformed(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.OldDurationMax"><code class="name flex">
|
|
<span>def <span class="ident">OldDurationMax</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OldDurationMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldDurationMax(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.OldDurationMin"><code class="name flex">
|
|
<span>def <span class="ident">OldDurationMin</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OldDurationMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldDurationMin(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.OldEndMax"><code class="name flex">
|
|
<span>def <span class="ident">OldEndMax</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OldEndMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldEndMax(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.OldEndMin"><code class="name flex">
|
|
<span>def <span class="ident">OldEndMin</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OldEndMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldEndMin(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.OldStartMax"><code class="name flex">
|
|
<span>def <span class="ident">OldStartMax</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OldStartMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldStartMax(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.OldStartMin"><code class="name flex">
|
|
<span>def <span class="ident">OldStartMin</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OldStartMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_OldStartMin(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.PerformedExpr"><code class="name flex">
|
|
<span>def <span class="ident">PerformedExpr</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def PerformedExpr(self) -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_PerformedExpr(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.SafeDurationExpr"><code class="name flex">
|
|
<span>def <span class="ident">SafeDurationExpr</span></span>(<span>self, unperformed_value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SafeDurationExpr(self, unperformed_value: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_SafeDurationExpr(self, unperformed_value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.SafeEndExpr"><code class="name flex">
|
|
<span>def <span class="ident">SafeEndExpr</span></span>(<span>self, unperformed_value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SafeEndExpr(self, unperformed_value: 'int64') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.IntervalVar_SafeEndExpr(self, unperformed_value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.SafeStartExpr"><code class="name flex">
|
|
<span>def <span class="ident">SafeStartExpr</span></span>(<span>self, unperformed_value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>These methods create expressions encapsulating the start, end and duration of the interval var. If the interval var is unperformed, they will return the unperformed_value.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SafeStartExpr(self, unperformed_value: 'int64') -> "operations_research::IntExpr *":
|
|
r""" These methods create expressions encapsulating the start, end and duration of the interval var. If the interval var is unperformed, they will return the unperformed_value."""
|
|
return _pywrapcp.IntervalVar_SafeStartExpr(self, unperformed_value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.SetDurationMax"><code class="name flex">
|
|
<span>def <span class="ident">SetDurationMax</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetDurationMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetDurationMax(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.SetDurationMin"><code class="name flex">
|
|
<span>def <span class="ident">SetDurationMin</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetDurationMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetDurationMin(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.SetDurationRange"><code class="name flex">
|
|
<span>def <span class="ident">SetDurationRange</span></span>(<span>self, mi, ma)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetDurationRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetDurationRange(self, mi, ma)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.SetEndMax"><code class="name flex">
|
|
<span>def <span class="ident">SetEndMax</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetEndMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetEndMax(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.SetEndMin"><code class="name flex">
|
|
<span>def <span class="ident">SetEndMin</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetEndMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetEndMin(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.SetEndRange"><code class="name flex">
|
|
<span>def <span class="ident">SetEndRange</span></span>(<span>self, mi, ma)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetEndRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetEndRange(self, mi, ma)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.SetPerformed"><code class="name flex">
|
|
<span>def <span class="ident">SetPerformed</span></span>(<span>self, val)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetPerformed(self, val: 'bool') -> "void":
|
|
return _pywrapcp.IntervalVar_SetPerformed(self, val)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.SetStartMax"><code class="name flex">
|
|
<span>def <span class="ident">SetStartMax</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetStartMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetStartMax(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.SetStartMin"><code class="name flex">
|
|
<span>def <span class="ident">SetStartMin</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetStartMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetStartMin(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.SetStartRange"><code class="name flex">
|
|
<span>def <span class="ident">SetStartRange</span></span>(<span>self, mi, ma)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetStartRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVar_SetStartRange(self, mi, ma)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartExpr"><code class="name flex">
|
|
<span>def <span class="ident">StartExpr</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>These methods create expressions encapsulating the start, end and duration of the interval var. Please note that these must not be used if the interval var is unperformed.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartExpr(self) -> "operations_research::IntExpr *":
|
|
r""" These methods create expressions encapsulating the start, end and duration of the interval var. Please note that these must not be used if the interval var is unperformed."""
|
|
return _pywrapcp.IntervalVar_StartExpr(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartMax"><code class="name flex">
|
|
<span>def <span class="ident">StartMax</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVar_StartMax(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartMin"><code class="name flex">
|
|
<span>def <span class="ident">StartMin</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>These methods query, set, and watch the start position of the interval var.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartMin(self) -> "int64":
|
|
r""" These methods query, set, and watch the start position of the interval var."""
|
|
return _pywrapcp.IntervalVar_StartMin(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartsAfter"><code class="name flex">
|
|
<span>def <span class="ident">StartsAfter</span></span>(<span>self, date)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartsAfter(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfter(self, date)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartsAfterEnd"><code class="name flex">
|
|
<span>def <span class="ident">StartsAfterEnd</span></span>(<span>self, other)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartsAfterEnd(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfterEnd(self, other)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartsAfterEndWithDelay"><code class="name flex">
|
|
<span>def <span class="ident">StartsAfterEndWithDelay</span></span>(<span>self, other, delay)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartsAfterEndWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfterEndWithDelay(self, other, delay)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartsAfterStart"><code class="name flex">
|
|
<span>def <span class="ident">StartsAfterStart</span></span>(<span>self, other)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartsAfterStart(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfterStart(self, other)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartsAfterStartWithDelay"><code class="name flex">
|
|
<span>def <span class="ident">StartsAfterStartWithDelay</span></span>(<span>self, other, delay)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartsAfterStartWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAfterStartWithDelay(self, other, delay)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartsAt"><code class="name flex">
|
|
<span>def <span class="ident">StartsAt</span></span>(<span>self, date)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartsAt(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAt(self, date)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartsAtEnd"><code class="name flex">
|
|
<span>def <span class="ident">StartsAtEnd</span></span>(<span>self, other)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartsAtEnd(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAtEnd(self, other)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartsAtEndWithDelay"><code class="name flex">
|
|
<span>def <span class="ident">StartsAtEndWithDelay</span></span>(<span>self, other, delay)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartsAtEndWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAtEndWithDelay(self, other, delay)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartsAtStart"><code class="name flex">
|
|
<span>def <span class="ident">StartsAtStart</span></span>(<span>self, other)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartsAtStart(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAtStart(self, other)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartsAtStartWithDelay"><code class="name flex">
|
|
<span>def <span class="ident">StartsAtStartWithDelay</span></span>(<span>self, other, delay)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartsAtStartWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsAtStartWithDelay(self, other, delay)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StartsBefore"><code class="name flex">
|
|
<span>def <span class="ident">StartsBefore</span></span>(<span>self, date)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartsBefore(self, date: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StartsBefore(self, date)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StaysInSync"><code class="name flex">
|
|
<span>def <span class="ident">StaysInSync</span></span>(<span>self, other)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StaysInSync(self, other: 'IntervalVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StaysInSync(self, other)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.StaysInSyncWithDelay"><code class="name flex">
|
|
<span>def <span class="ident">StaysInSyncWithDelay</span></span>(<span>self, other, delay)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StaysInSyncWithDelay(self, other: 'IntervalVar', delay: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.IntervalVar_StaysInSyncWithDelay(self, other, delay)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.WasPerformedBound"><code class="name flex">
|
|
<span>def <span class="ident">WasPerformedBound</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WasPerformedBound(self) -> "bool":
|
|
return _pywrapcp.IntervalVar_WasPerformedBound(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.WhenAnything"><code class="name flex">
|
|
<span>def <span class="ident">WhenAnything</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Attaches a demon awakened when anything about this interval changes.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Attaches a closure awakened when anything about this interval changes.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WhenAnything(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
Attaches a demon awakened when anything about this interval changes.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Attaches a closure awakened when anything about this interval changes.
|
|
"""
|
|
return _pywrapcp.IntervalVar_WhenAnything(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.WhenDurationBound"><code class="name flex">
|
|
<span>def <span class="ident">WhenDurationBound</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WhenDurationBound(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenDurationBound(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.WhenDurationRange"><code class="name flex">
|
|
<span>def <span class="ident">WhenDurationRange</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WhenDurationRange(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenDurationRange(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.WhenEndBound"><code class="name flex">
|
|
<span>def <span class="ident">WhenEndBound</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WhenEndBound(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenEndBound(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.WhenEndRange"><code class="name flex">
|
|
<span>def <span class="ident">WhenEndRange</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WhenEndRange(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenEndRange(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.WhenPerformedBound"><code class="name flex">
|
|
<span>def <span class="ident">WhenPerformedBound</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WhenPerformedBound(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenPerformedBound(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.WhenStartBound"><code class="name flex">
|
|
<span>def <span class="ident">WhenStartBound</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WhenStartBound(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenStartBound(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVar.WhenStartRange"><code class="name flex">
|
|
<span>def <span class="ident">WhenStartRange</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WhenStartRange(self, *args) -> "void":
|
|
return _pywrapcp.IntervalVar_WhenStartRange(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.PropagationBaseObject.Name" href="#pywrapcp.PropagationBaseObject.Name">Name</a></code></li>
|
|
<li><code><a title="pywrapcp.PropagationBaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarContainer"><code class="flex name class">
|
|
<span>class <span class="ident">IntervalVarContainer</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class IntervalVarContainer(object):
|
|
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 Contains(self, var: 'IntervalVar') -> "bool":
|
|
return _pywrapcp.IntervalVarContainer_Contains(self, var)
|
|
|
|
def Element(self, index: 'int') -> "operations_research::IntervalVarElement *":
|
|
return _pywrapcp.IntervalVarContainer_Element(self, index)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.IntervalVarContainer_Size(self)
|
|
|
|
def Store(self) -> "void":
|
|
return _pywrapcp.IntervalVarContainer_Store(self)
|
|
|
|
def Restore(self) -> "void":
|
|
return _pywrapcp.IntervalVarContainer_Restore(self)
|
|
|
|
def __eq__(self, container: 'IntervalVarContainer') -> "bool":
|
|
r""" Returns true if this and 'container' both represent the same V* -> E map. Runs in linear time; requires that the == operator on the type E is well defined."""
|
|
return _pywrapcp.IntervalVarContainer___eq__(self, container)
|
|
|
|
def __ne__(self, container: 'IntervalVarContainer') -> "bool":
|
|
return _pywrapcp.IntervalVarContainer___ne__(self, container)
|
|
__swig_destroy__ = _pywrapcp.delete_IntervalVarContainer</code></pre>
|
|
</details>
|
|
<h3>Instance variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntervalVarContainer.thisown"><code class="name">var <span class="ident">thisown</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The membership flag</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntervalVarContainer.Contains"><code class="name flex">
|
|
<span>def <span class="ident">Contains</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Contains(self, var: 'IntervalVar') -> "bool":
|
|
return _pywrapcp.IntervalVarContainer_Contains(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarContainer.Element"><code class="name flex">
|
|
<span>def <span class="ident">Element</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Element(self, index: 'int') -> "operations_research::IntervalVarElement *":
|
|
return _pywrapcp.IntervalVarContainer_Element(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarContainer.Restore"><code class="name flex">
|
|
<span>def <span class="ident">Restore</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Restore(self) -> "void":
|
|
return _pywrapcp.IntervalVarContainer_Restore(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarContainer.Size"><code class="name flex">
|
|
<span>def <span class="ident">Size</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Size(self) -> "int":
|
|
return _pywrapcp.IntervalVarContainer_Size(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarContainer.Store"><code class="name flex">
|
|
<span>def <span class="ident">Store</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Store(self) -> "void":
|
|
return _pywrapcp.IntervalVarContainer_Store(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement"><code class="flex name class">
|
|
<span>class <span class="ident">IntervalVarElement</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class IntervalVarElement(AssignmentElement):
|
|
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 Var(self) -> "operations_research::IntervalVar *":
|
|
return _pywrapcp.IntervalVarElement_Var(self)
|
|
|
|
def StartMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_StartMin(self)
|
|
|
|
def StartMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_StartMax(self)
|
|
|
|
def StartValue(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_StartValue(self)
|
|
|
|
def DurationMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_DurationMin(self)
|
|
|
|
def DurationMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_DurationMax(self)
|
|
|
|
def DurationValue(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_DurationValue(self)
|
|
|
|
def EndMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_EndMin(self)
|
|
|
|
def EndMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_EndMax(self)
|
|
|
|
def EndValue(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_EndValue(self)
|
|
|
|
def PerformedMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_PerformedMin(self)
|
|
|
|
def PerformedMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_PerformedMax(self)
|
|
|
|
def PerformedValue(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_PerformedValue(self)
|
|
|
|
def SetStartMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetStartMin(self, m)
|
|
|
|
def SetStartMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetStartMax(self, m)
|
|
|
|
def SetStartRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetStartRange(self, mi, ma)
|
|
|
|
def SetStartValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetStartValue(self, v)
|
|
|
|
def SetDurationMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetDurationMin(self, m)
|
|
|
|
def SetDurationMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetDurationMax(self, m)
|
|
|
|
def SetDurationRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetDurationRange(self, mi, ma)
|
|
|
|
def SetDurationValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetDurationValue(self, v)
|
|
|
|
def SetEndMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetEndMin(self, m)
|
|
|
|
def SetEndMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetEndMax(self, m)
|
|
|
|
def SetEndRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetEndRange(self, mi, ma)
|
|
|
|
def SetEndValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetEndValue(self, v)
|
|
|
|
def SetPerformedMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetPerformedMin(self, m)
|
|
|
|
def SetPerformedMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetPerformedMax(self, m)
|
|
|
|
def SetPerformedRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetPerformedRange(self, mi, ma)
|
|
|
|
def SetPerformedValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetPerformedValue(self, v)
|
|
|
|
def __eq__(self, element: 'IntervalVarElement') -> "bool":
|
|
return _pywrapcp.IntervalVarElement___eq__(self, element)
|
|
|
|
def __ne__(self, element: 'IntervalVarElement') -> "bool":
|
|
return _pywrapcp.IntervalVarElement___ne__(self, element)
|
|
__swig_destroy__ = _pywrapcp.delete_IntervalVarElement</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.AssignmentElement" href="#pywrapcp.AssignmentElement">AssignmentElement</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.IntervalVarElement.DurationMax"><code class="name flex">
|
|
<span>def <span class="ident">DurationMax</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DurationMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_DurationMax(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.DurationMin"><code class="name flex">
|
|
<span>def <span class="ident">DurationMin</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DurationMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_DurationMin(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.DurationValue"><code class="name flex">
|
|
<span>def <span class="ident">DurationValue</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DurationValue(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_DurationValue(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.EndMax"><code class="name flex">
|
|
<span>def <span class="ident">EndMax</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_EndMax(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.EndMin"><code class="name flex">
|
|
<span>def <span class="ident">EndMin</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_EndMin(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.EndValue"><code class="name flex">
|
|
<span>def <span class="ident">EndValue</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndValue(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_EndValue(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.PerformedMax"><code class="name flex">
|
|
<span>def <span class="ident">PerformedMax</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def PerformedMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_PerformedMax(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.PerformedMin"><code class="name flex">
|
|
<span>def <span class="ident">PerformedMin</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def PerformedMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_PerformedMin(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.PerformedValue"><code class="name flex">
|
|
<span>def <span class="ident">PerformedValue</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def PerformedValue(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_PerformedValue(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetDurationMax"><code class="name flex">
|
|
<span>def <span class="ident">SetDurationMax</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetDurationMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetDurationMax(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetDurationMin"><code class="name flex">
|
|
<span>def <span class="ident">SetDurationMin</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetDurationMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetDurationMin(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetDurationRange"><code class="name flex">
|
|
<span>def <span class="ident">SetDurationRange</span></span>(<span>self, mi, ma)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetDurationRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetDurationRange(self, mi, ma)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetDurationValue"><code class="name flex">
|
|
<span>def <span class="ident">SetDurationValue</span></span>(<span>self, v)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetDurationValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetDurationValue(self, v)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetEndMax"><code class="name flex">
|
|
<span>def <span class="ident">SetEndMax</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetEndMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetEndMax(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetEndMin"><code class="name flex">
|
|
<span>def <span class="ident">SetEndMin</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetEndMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetEndMin(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetEndRange"><code class="name flex">
|
|
<span>def <span class="ident">SetEndRange</span></span>(<span>self, mi, ma)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetEndRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetEndRange(self, mi, ma)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetEndValue"><code class="name flex">
|
|
<span>def <span class="ident">SetEndValue</span></span>(<span>self, v)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetEndValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetEndValue(self, v)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetPerformedMax"><code class="name flex">
|
|
<span>def <span class="ident">SetPerformedMax</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetPerformedMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetPerformedMax(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetPerformedMin"><code class="name flex">
|
|
<span>def <span class="ident">SetPerformedMin</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetPerformedMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetPerformedMin(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetPerformedRange"><code class="name flex">
|
|
<span>def <span class="ident">SetPerformedRange</span></span>(<span>self, mi, ma)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetPerformedRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetPerformedRange(self, mi, ma)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetPerformedValue"><code class="name flex">
|
|
<span>def <span class="ident">SetPerformedValue</span></span>(<span>self, v)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetPerformedValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetPerformedValue(self, v)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetStartMax"><code class="name flex">
|
|
<span>def <span class="ident">SetStartMax</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetStartMax(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetStartMax(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetStartMin"><code class="name flex">
|
|
<span>def <span class="ident">SetStartMin</span></span>(<span>self, m)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetStartMin(self, m: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetStartMin(self, m)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetStartRange"><code class="name flex">
|
|
<span>def <span class="ident">SetStartRange</span></span>(<span>self, mi, ma)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetStartRange(self, mi: 'int64', ma: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetStartRange(self, mi, ma)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.SetStartValue"><code class="name flex">
|
|
<span>def <span class="ident">SetStartValue</span></span>(<span>self, v)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetStartValue(self, v: 'int64') -> "void":
|
|
return _pywrapcp.IntervalVarElement_SetStartValue(self, v)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.StartMax"><code class="name flex">
|
|
<span>def <span class="ident">StartMax</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartMax(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_StartMax(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.StartMin"><code class="name flex">
|
|
<span>def <span class="ident">StartMin</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartMin(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_StartMin(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.StartValue"><code class="name flex">
|
|
<span>def <span class="ident">StartValue</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartValue(self) -> "int64":
|
|
return _pywrapcp.IntervalVarElement_StartValue(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.IntervalVarElement.Var"><code class="name flex">
|
|
<span>def <span class="ident">Var</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Var(self) -> "operations_research::IntervalVar *":
|
|
return _pywrapcp.IntervalVarElement_Var(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.AssignmentElement" href="#pywrapcp.AssignmentElement">AssignmentElement</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.AssignmentElement.thisown" href="#pywrapcp.AssignmentElement.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">LocalCheapestInsertionFilteredDecisionBuilder</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class LocalCheapestInsertionFilteredDecisionBuilder(CheapestInsertionFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_LocalCheapestInsertionFilteredDecisionBuilder
|
|
|
|
def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder_BuildSolution(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.CheapestInsertionFilteredDecisionBuilder" href="#pywrapcp.CheapestInsertionFilteredDecisionBuilder">CheapestInsertionFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder.BuildSolution"><code class="name flex">
|
|
<span>def <span class="ident">BuildSolution</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder_BuildSolution(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.CheapestInsertionFilteredDecisionBuilder" href="#pywrapcp.CheapestInsertionFilteredDecisionBuilder">CheapestInsertionFilteredDecisionBuilder</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.CheapestInsertionFilteredDecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.CheapestInsertionFilteredDecisionBuilder.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.LocalSearchFilter"><code class="flex name class">
|
|
<span>class <span class="ident">LocalSearchFilter</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Local Search Filters are used for fast neighbor pruning.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class LocalSearchFilter(BaseObject):
|
|
r""" Local Search Filters are used for fast neighbor pruning."""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def Accept(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
r""" Accepts a "delta" given the assignment with which the filter has been synchronized; the delta holds the variables which have been modified and their new value. Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1, for the assignment (a,1), (b,0), the delta (b,1) will be rejected but the delta (a,0) will be accepted."""
|
|
return _pywrapcp.LocalSearchFilter_Accept(self, delta, deltadelta)
|
|
|
|
def Synchronize(self, assignment: 'Assignment', delta: 'Assignment') -> "void":
|
|
r""" Synchronizes the filter with the current solution, delta being the difference with the solution passed to the previous call to Synchronize() or IncrementalSynchronize(). 'delta' can be used to incrementally synchronizing the filter with the new solution by only considering the changes in delta."""
|
|
return _pywrapcp.LocalSearchFilter_Synchronize(self, assignment, delta)
|
|
|
|
def IsIncremental(self) -> "bool":
|
|
return _pywrapcp.LocalSearchFilter_IsIncremental(self)
|
|
__swig_destroy__ = _pywrapcp.delete_LocalSearchFilter</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntVarLocalSearchFilter" href="#pywrapcp.IntVarLocalSearchFilter">IntVarLocalSearchFilter</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.LocalSearchFilter.Accept"><code class="name flex">
|
|
<span>def <span class="ident">Accept</span></span>(<span>self, delta, deltadelta)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Accepts a "delta" given the assignment with which the filter has been synchronized; the delta holds the variables which have been modified and their new value. Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1, for the assignment (a,1), (b,0), the delta (b,1) will be rejected but the delta (a,0) will be accepted.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Accept(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
r""" Accepts a "delta" given the assignment with which the filter has been synchronized; the delta holds the variables which have been modified and their new value. Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1, for the assignment (a,1), (b,0), the delta (b,1) will be rejected but the delta (a,0) will be accepted."""
|
|
return _pywrapcp.LocalSearchFilter_Accept(self, delta, deltadelta)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.LocalSearchFilter.IsIncremental"><code class="name flex">
|
|
<span>def <span class="ident">IsIncremental</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsIncremental(self) -> "bool":
|
|
return _pywrapcp.LocalSearchFilter_IsIncremental(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.LocalSearchFilter.Synchronize"><code class="name flex">
|
|
<span>def <span class="ident">Synchronize</span></span>(<span>self, assignment, delta)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Synchronizes the filter with the current solution, delta being the difference with the solution passed to the previous call to Synchronize() or IncrementalSynchronize(). 'delta' can be used to incrementally synchronizing the filter with the new solution by only considering the changes in delta.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Synchronize(self, assignment: 'Assignment', delta: 'Assignment') -> "void":
|
|
r""" Synchronizes the filter with the current solution, delta being the difference with the solution passed to the previous call to Synchronize() or IncrementalSynchronize(). 'delta' can be used to incrementally synchronizing the filter with the new solution by only considering the changes in delta."""
|
|
return _pywrapcp.LocalSearchFilter_Synchronize(self, assignment, delta)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.BaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.LocalSearchOperator"><code class="flex name class">
|
|
<span>class <span class="ident">LocalSearchOperator</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This class represent a reversible FIFO structure. The main difference w.r.t a standard FIFO structure is that a Solver is given as parameter to the modifiers such that the solver can store the backtrack information Iterator's traversing order should not be changed, as some algorithm depend on it to be consistent. It's main use is to store a list of demons in the various classes of variables. The base class for all local search operators. A local search operator is an object that defines the neighborhood of a solution. In other words, a neighborhood is the set of solutions which can be reached from a given solution using an operator. The behavior of the LocalSearchOperator class is similar to iterators. The operator is synchronized with an assignment (gives the current values of the variables); this is done in the Start() method. Then one can iterate over the neighbors using the MakeNextNeighbor method. This method returns an assignment which represents the incremental changes to the current solution. It also returns a second assignment representing the changes to the last solution defined by the neighborhood operator; this assignment is empty if the neighborhood operator cannot track this information.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class LocalSearchOperator(BaseObject):
|
|
r""" This class represent a reversible FIFO structure. The main difference w.r.t a standard FIFO structure is that a Solver is given as parameter to the modifiers such that the solver can store the backtrack information Iterator's traversing order should not be changed, as some algorithm depend on it to be consistent. It's main use is to store a list of demons in the various classes of variables. The base class for all local search operators. A local search operator is an object that defines the neighborhood of a solution. In other words, a neighborhood is the set of solutions which can be reached from a given solution using an operator. The behavior of the LocalSearchOperator class is similar to iterators. The operator is synchronized with an assignment (gives the current values of the variables); this is done in the Start() method. Then one can iterate over the neighbors using the MakeNextNeighbor method. This method returns an assignment which represents the incremental changes to the current solution. It also returns a second assignment representing the changes to the last solution defined by the neighborhood operator; this assignment is empty if the neighborhood operator cannot track this information."""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def NextNeighbor(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
return _pywrapcp.LocalSearchOperator_NextNeighbor(self, delta, deltadelta)
|
|
|
|
def Start(self, assignment: 'Assignment') -> "void":
|
|
return _pywrapcp.LocalSearchOperator_Start(self, assignment)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_LocalSearchOperator(self)
|
|
return weakref.proxy(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntVarLocalSearchOperatorTemplate" href="#pywrapcp.IntVarLocalSearchOperatorTemplate">IntVarLocalSearchOperatorTemplate</a></li>
|
|
<li><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate">SequenceVarLocalSearchOperatorTemplate</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.LocalSearchOperator.NextNeighbor"><code class="name flex">
|
|
<span>def <span class="ident">NextNeighbor</span></span>(<span>self, delta, deltadelta)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NextNeighbor(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
return _pywrapcp.LocalSearchOperator_NextNeighbor(self, delta, deltadelta)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.LocalSearchOperator.Start"><code class="name flex">
|
|
<span>def <span class="ident">Start</span></span>(<span>self, assignment)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Start(self, assignment: 'Assignment') -> "void":
|
|
return _pywrapcp.LocalSearchOperator_Start(self, assignment)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.BaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.NumericalRevInteger"><code class="flex name class">
|
|
<span>class <span class="ident">NumericalRevInteger</span></span>
|
|
<span>(</span><span>val)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Subclass of Rev<T> which adds numerical operations.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class NumericalRevInteger(RevInteger):
|
|
r""" Subclass of Rev<T> which adds numerical operations."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, val: 'long long const &'):
|
|
_pywrapcp.NumericalRevInteger_swiginit(self, _pywrapcp.new_NumericalRevInteger(val))
|
|
|
|
def Add(self, s: 'Solver', to_add: 'long long const &') -> "void":
|
|
return _pywrapcp.NumericalRevInteger_Add(self, s, to_add)
|
|
|
|
def Incr(self, s: 'Solver') -> "void":
|
|
return _pywrapcp.NumericalRevInteger_Incr(self, s)
|
|
|
|
def Decr(self, s: 'Solver') -> "void":
|
|
return _pywrapcp.NumericalRevInteger_Decr(self, s)
|
|
__swig_destroy__ = _pywrapcp.delete_NumericalRevInteger</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.RevInteger" href="#pywrapcp.RevInteger">RevInteger</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.NumericalRevInteger.Add"><code class="name flex">
|
|
<span>def <span class="ident">Add</span></span>(<span>self, s, to_add)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Add(self, s: 'Solver', to_add: 'long long const &') -> "void":
|
|
return _pywrapcp.NumericalRevInteger_Add(self, s, to_add)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.NumericalRevInteger.Decr"><code class="name flex">
|
|
<span>def <span class="ident">Decr</span></span>(<span>self, s)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Decr(self, s: 'Solver') -> "void":
|
|
return _pywrapcp.NumericalRevInteger_Decr(self, s)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.NumericalRevInteger.Incr"><code class="name flex">
|
|
<span>def <span class="ident">Incr</span></span>(<span>self, s)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Incr(self, s: 'Solver') -> "void":
|
|
return _pywrapcp.NumericalRevInteger_Incr(self, s)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.RevInteger" href="#pywrapcp.RevInteger">RevInteger</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.RevInteger.thisown" href="#pywrapcp.RevInteger.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.OptimizeVar"><code class="flex name class">
|
|
<span>class <span class="ident">OptimizeVar</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This class encapsulates an objective. It requires the direction (minimize or maximize), the variable to optimize, and the improvement step.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class OptimizeVar(SearchMonitor):
|
|
r""" This class encapsulates an objective. It requires the direction (minimize or maximize), the variable to optimize, and the improvement step."""
|
|
|
|
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 Best(self) -> "int64":
|
|
r""" Returns the best value found during search."""
|
|
return _pywrapcp.OptimizeVar_Best(self)
|
|
|
|
def Var(self) -> "operations_research::IntVar *":
|
|
r""" Returns the variable that is optimized."""
|
|
return _pywrapcp.OptimizeVar_Var(self)
|
|
|
|
def AcceptDelta(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
r""" Internal methods."""
|
|
return _pywrapcp.OptimizeVar_AcceptDelta(self, delta, deltadelta)
|
|
|
|
def EnterSearch(self) -> "void":
|
|
return _pywrapcp.OptimizeVar_EnterSearch(self)
|
|
|
|
def BeginNextDecision(self, db: 'DecisionBuilder') -> "void":
|
|
return _pywrapcp.OptimizeVar_BeginNextDecision(self, db)
|
|
|
|
def RefuteDecision(self, d: 'Decision') -> "void":
|
|
return _pywrapcp.OptimizeVar_RefuteDecision(self, d)
|
|
|
|
def AtSolution(self) -> "bool":
|
|
return _pywrapcp.OptimizeVar_AtSolution(self)
|
|
|
|
def AcceptSolution(self) -> "bool":
|
|
return _pywrapcp.OptimizeVar_AcceptSolution(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.OptimizeVar_DebugString(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.SearchMonitor" href="#pywrapcp.SearchMonitor">SearchMonitor</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.OptimizeVar.AcceptDelta"><code class="name flex">
|
|
<span>def <span class="ident">AcceptDelta</span></span>(<span>self, delta, deltadelta)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Internal methods.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AcceptDelta(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
r""" Internal methods."""
|
|
return _pywrapcp.OptimizeVar_AcceptDelta(self, delta, deltadelta)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.OptimizeVar.Best"><code class="name flex">
|
|
<span>def <span class="ident">Best</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the best value found during search.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Best(self) -> "int64":
|
|
r""" Returns the best value found during search."""
|
|
return _pywrapcp.OptimizeVar_Best(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.OptimizeVar.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.OptimizeVar_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.OptimizeVar.Var"><code class="name flex">
|
|
<span>def <span class="ident">Var</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the variable that is optimized.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Var(self) -> "operations_research::IntVar *":
|
|
r""" Returns the variable that is optimized."""
|
|
return _pywrapcp.OptimizeVar_Var(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.SearchMonitor" href="#pywrapcp.SearchMonitor">SearchMonitor</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.SearchMonitor.AcceptNeighbor" href="#pywrapcp.SearchMonitor.AcceptNeighbor">AcceptNeighbor</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.AcceptSolution" href="#pywrapcp.SearchMonitor.AcceptSolution">AcceptSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.AfterDecision" href="#pywrapcp.SearchMonitor.AfterDecision">AfterDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.ApplyDecision" href="#pywrapcp.SearchMonitor.ApplyDecision">ApplyDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.AtSolution" href="#pywrapcp.SearchMonitor.AtSolution">AtSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.BeginFail" href="#pywrapcp.SearchMonitor.BeginFail">BeginFail</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.BeginInitialPropagation" href="#pywrapcp.SearchMonitor.BeginInitialPropagation">BeginInitialPropagation</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.BeginNextDecision" href="#pywrapcp.SearchMonitor.BeginNextDecision">BeginNextDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EndFail" href="#pywrapcp.SearchMonitor.EndFail">EndFail</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EndInitialPropagation" href="#pywrapcp.SearchMonitor.EndInitialPropagation">EndInitialPropagation</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EndNextDecision" href="#pywrapcp.SearchMonitor.EndNextDecision">EndNextDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EnterSearch" href="#pywrapcp.SearchMonitor.EnterSearch">EnterSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.ExitSearch" href="#pywrapcp.SearchMonitor.ExitSearch">ExitSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.LocalOptimum" href="#pywrapcp.SearchMonitor.LocalOptimum">LocalOptimum</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.NoMoreSolutions" href="#pywrapcp.SearchMonitor.NoMoreSolutions">NoMoreSolutions</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.RefuteDecision" href="#pywrapcp.SearchMonitor.RefuteDecision">RefuteDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.RestartSearch" href="#pywrapcp.SearchMonitor.RestartSearch">RestartSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.Pack"><code class="flex name class">
|
|
<span>class <span class="ident">Pack</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A constraint is the main modeling object. It provides two methods:
|
|
- Post() is responsible for creating the demons and attaching them to
|
|
immediate demons().
|
|
- InitialPropagate() is called once just after Post and performs
|
|
the initial propagation. The subsequent propagations will be performed
|
|
by the demons Posted during the post() method.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class Pack(Constraint):
|
|
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 AddWeightedSumLessOrEqualConstantDimension(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
Dimensions are additional constraints than can restrict what is possible with the pack constraint. It can be used to set capacity limits, to count objects per bin, to compute unassigned penalties... This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned to 'b' is less or equal 'bounds[b]'.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This dimension imposes that for all bins b, the weighted sum (weights->Run(i)) of all objects i assigned to 'b' is less or equal to 'bounds[b]'. Ownership of the callback is transferred to the pack constraint.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b) of all objects i assigned to 'b' is less or equal to 'bounds[b]'. Ownership of the callback is transferred to the pack constraint.
|
|
"""
|
|
return _pywrapcp.Pack_AddWeightedSumLessOrEqualConstantDimension(self, *args)
|
|
|
|
def AddWeightedSumEqualVarDimension(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned to 'b' is equal to loads[b].
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b)) of all objects i assigned to 'b' is equal to loads[b].
|
|
"""
|
|
return _pywrapcp.Pack_AddWeightedSumEqualVarDimension(self, *args)
|
|
|
|
def AddSumVariableWeightsLessOrEqualConstantDimension(self, usage: 'std::vector< operations_research::IntVar * > const &', capacity: 'std::vector< int64 > const &') -> "void":
|
|
r""" This dimension imposes: forall b in bins, sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b] where is_assigned(i, b) is true if and only if item i is assigned to the bin b. This can be used to model shapes of items by linking variables of the same item on parallel dimensions with an allowed assignment constraint."""
|
|
return _pywrapcp.Pack_AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity)
|
|
|
|
def AddWeightedSumOfAssignedDimension(self, weights: 'std::vector< int64 > const &', cost_var: 'IntVar') -> "void":
|
|
r""" This dimension enforces that cost_var == sum of weights[i] for all objects 'i' assigned to a bin."""
|
|
return _pywrapcp.Pack_AddWeightedSumOfAssignedDimension(self, weights, cost_var)
|
|
|
|
def AddCountUsedBinDimension(self, count_var: 'IntVar') -> "void":
|
|
r""" This dimension links 'count_var' to the actual number of bins used in the pack."""
|
|
return _pywrapcp.Pack_AddCountUsedBinDimension(self, count_var)
|
|
|
|
def AddCountAssignedItemsDimension(self, count_var: 'IntVar') -> "void":
|
|
r""" This dimension links 'count_var' to the actual number of items assigned to a bin in the pack."""
|
|
return _pywrapcp.Pack_AddCountAssignedItemsDimension(self, count_var)
|
|
|
|
def Post(self) -> "void":
|
|
return _pywrapcp.Pack_Post(self)
|
|
|
|
def InitialPropagateWrapper(self) -> "void":
|
|
return _pywrapcp.Pack_InitialPropagateWrapper(self)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Pack_DebugString(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.Constraint" href="#pywrapcp.Constraint">Constraint</a></li>
|
|
<li><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.Pack.AddCountAssignedItemsDimension"><code class="name flex">
|
|
<span>def <span class="ident">AddCountAssignedItemsDimension</span></span>(<span>self, count_var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This dimension links 'count_var' to the actual number of items assigned to a bin in the pack.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddCountAssignedItemsDimension(self, count_var: 'IntVar') -> "void":
|
|
r""" This dimension links 'count_var' to the actual number of items assigned to a bin in the pack."""
|
|
return _pywrapcp.Pack_AddCountAssignedItemsDimension(self, count_var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Pack.AddCountUsedBinDimension"><code class="name flex">
|
|
<span>def <span class="ident">AddCountUsedBinDimension</span></span>(<span>self, count_var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This dimension links 'count_var' to the actual number of bins used in the pack.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddCountUsedBinDimension(self, count_var: 'IntVar') -> "void":
|
|
r""" This dimension links 'count_var' to the actual number of bins used in the pack."""
|
|
return _pywrapcp.Pack_AddCountUsedBinDimension(self, count_var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Pack.AddSumVariableWeightsLessOrEqualConstantDimension"><code class="name flex">
|
|
<span>def <span class="ident">AddSumVariableWeightsLessOrEqualConstantDimension</span></span>(<span>self, usage, capacity)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This dimension imposes: forall b in bins,
|
|
sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b] where is_assigned(i, b) is true if and only if item i is assigned to the bin b. This can be used to model shapes of items by linking variables of the same item on parallel dimensions with an allowed assignment constraint.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddSumVariableWeightsLessOrEqualConstantDimension(self, usage: 'std::vector< operations_research::IntVar * > const &', capacity: 'std::vector< int64 > const &') -> "void":
|
|
r""" This dimension imposes: forall b in bins, sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b] where is_assigned(i, b) is true if and only if item i is assigned to the bin b. This can be used to model shapes of items by linking variables of the same item on parallel dimensions with an allowed assignment constraint."""
|
|
return _pywrapcp.Pack_AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Pack.AddWeightedSumEqualVarDimension"><code class="name flex">
|
|
<span>def <span class="ident">AddWeightedSumEqualVarDimension</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned to 'b' is equal to loads[b].</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b)) of all objects i assigned to 'b' is equal to loads[b].</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddWeightedSumEqualVarDimension(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned to 'b' is equal to loads[b].
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b)) of all objects i assigned to 'b' is equal to loads[b].
|
|
"""
|
|
return _pywrapcp.Pack_AddWeightedSumEqualVarDimension(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Pack.AddWeightedSumLessOrEqualConstantDimension"><code class="name flex">
|
|
<span>def <span class="ident">AddWeightedSumLessOrEqualConstantDimension</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Dimensions are additional constraints than can restrict what is possible with the pack constraint. It can be used to set capacity limits, to count objects per bin, to compute unassigned penalties… This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned to 'b' is less or equal 'bounds[b]'.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
This dimension imposes that for all bins b, the weighted sum (weights->Run(i)) of all objects i assigned to 'b' is less or equal to 'bounds[b]'. Ownership of the callback is transferred to the pack constraint.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 3:</em>
|
|
This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b) of all objects i assigned to 'b' is less or equal to 'bounds[b]'. Ownership of the callback is transferred to the pack constraint.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddWeightedSumLessOrEqualConstantDimension(self, *args) -> "void":
|
|
r"""
|
|
*Overload 1:*
|
|
Dimensions are additional constraints than can restrict what is possible with the pack constraint. It can be used to set capacity limits, to count objects per bin, to compute unassigned penalties... This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned to 'b' is less or equal 'bounds[b]'.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This dimension imposes that for all bins b, the weighted sum (weights->Run(i)) of all objects i assigned to 'b' is less or equal to 'bounds[b]'. Ownership of the callback is transferred to the pack constraint.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b) of all objects i assigned to 'b' is less or equal to 'bounds[b]'. Ownership of the callback is transferred to the pack constraint.
|
|
"""
|
|
return _pywrapcp.Pack_AddWeightedSumLessOrEqualConstantDimension(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Pack.AddWeightedSumOfAssignedDimension"><code class="name flex">
|
|
<span>def <span class="ident">AddWeightedSumOfAssignedDimension</span></span>(<span>self, weights, cost_var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This dimension enforces that cost_var == sum of weights[i] for all objects 'i' assigned to a bin.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddWeightedSumOfAssignedDimension(self, weights: 'std::vector< int64 > const &', cost_var: 'IntVar') -> "void":
|
|
r""" This dimension enforces that cost_var == sum of weights[i] for all objects 'i' assigned to a bin."""
|
|
return _pywrapcp.Pack_AddWeightedSumOfAssignedDimension(self, weights, cost_var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Pack.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.Pack_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.Constraint" href="#pywrapcp.Constraint">Constraint</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.Constraint.InitialPropagateWrapper" href="#pywrapcp.Constraint.InitialPropagateWrapper">InitialPropagateWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Name" href="#pywrapcp.PropagationBaseObject.Name">Name</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Post" href="#pywrapcp.Constraint.Post">Post</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Var" href="#pywrapcp.Constraint.Var">Var</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.ParallelSavingsFilteredDecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">ParallelSavingsFilteredDecisionBuilder</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class ParallelSavingsFilteredDecisionBuilder(SavingsFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_ParallelSavingsFilteredDecisionBuilder
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.ParallelSavingsFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.SavingsFilteredDecisionBuilder" href="#pywrapcp.SavingsFilteredDecisionBuilder">SavingsFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.ParallelSavingsFilteredDecisionBuilder.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.ParallelSavingsFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.SavingsFilteredDecisionBuilder" href="#pywrapcp.SavingsFilteredDecisionBuilder">SavingsFilteredDecisionBuilder</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.SavingsFilteredDecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.SavingsFilteredDecisionBuilder.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.PathOperator"><code class="flex name class">
|
|
<span>class <span class="ident">PathOperator</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Base class of the local search operators dedicated to path modifications (a path is a set of nodes linked together by arcs). This family of neighborhoods supposes they are handling next variables representing the arcs (var[i] represents the node immediately after i on a path). Several services are provided: - arc manipulators (SetNext(), ReverseChain(), MoveChain()) - path inspectors (Next(), IsPathEnd()) - path iterators: operators need a given number of nodes to define a
|
|
neighbor; this class provides the iteration on a given number of (base)
|
|
nodes which can be used to define a neighbor (through the BaseNode method) Subclasses only need to override MakeNeighbor to create neighbors using the services above (no direct manipulation of assignments).</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class PathOperator(IntVarLocalSearchOperator):
|
|
r""" Base class of the local search operators dedicated to path modifications (a path is a set of nodes linked together by arcs). This family of neighborhoods supposes they are handling next variables representing the arcs (var[i] represents the node immediately after i on a path). Several services are provided: - arc manipulators (SetNext(), ReverseChain(), MoveChain()) - path inspectors (Next(), IsPathEnd()) - path iterators: operators need a given number of nodes to define a neighbor; this class provides the iteration on a given number of (base) nodes which can be used to define a neighbor (through the BaseNode method) Subclasses only need to override MakeNeighbor to create neighbors using the services above (no direct manipulation of assignments)."""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def Neighbor(self) -> "bool":
|
|
return _pywrapcp.PathOperator_Neighbor(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntVarLocalSearchOperator" href="#pywrapcp.IntVarLocalSearchOperator">IntVarLocalSearchOperator</a></li>
|
|
<li><a title="pywrapcp.IntVarLocalSearchOperatorTemplate" href="#pywrapcp.IntVarLocalSearchOperatorTemplate">IntVarLocalSearchOperatorTemplate</a></li>
|
|
<li><a title="pywrapcp.LocalSearchOperator" href="#pywrapcp.LocalSearchOperator">LocalSearchOperator</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.PathOperator.Neighbor"><code class="name flex">
|
|
<span>def <span class="ident">Neighbor</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Neighbor(self) -> "bool":
|
|
return _pywrapcp.PathOperator_Neighbor(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.IntVarLocalSearchOperator" href="#pywrapcp.IntVarLocalSearchOperator">IntVarLocalSearchOperator</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.NextNeighbor" href="#pywrapcp.IntVarLocalSearchOperator.NextNeighbor">NextNeighbor</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.OnStart" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.OnStart">OnStart</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.OneNeighbor" href="#pywrapcp.IntVarLocalSearchOperator.OneNeighbor">OneNeighbor</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.Start" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.Start">Start</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.Value" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.Value">Value</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.PropagationBaseObject"><code class="flex name class">
|
|
<span>class <span class="ident">PropagationBaseObject</span></span>
|
|
<span>(</span><span>s)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>NOLINT The PropagationBaseObject is a subclass of BaseObject that is also friend to the Solver class. It allows accessing methods useful when writing new constraints or new expressions.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class PropagationBaseObject(BaseObject):
|
|
r""" NOLINT The PropagationBaseObject is a subclass of BaseObject that is also friend to the Solver class. It allows accessing methods useful when writing new constraints or new expressions."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, s: 'Solver'):
|
|
if self.__class__ == PropagationBaseObject:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.PropagationBaseObject_swiginit(self, _pywrapcp.new_PropagationBaseObject(_self, s))
|
|
__swig_destroy__ = _pywrapcp.delete_PropagationBaseObject
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.PropagationBaseObject_DebugString(self)
|
|
|
|
def solver(self) -> "operations_research::Solver *":
|
|
return _pywrapcp.PropagationBaseObject_solver(self)
|
|
|
|
def Name(self) -> "std::string":
|
|
r""" Object naming."""
|
|
return _pywrapcp.PropagationBaseObject_Name(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_PropagationBaseObject(self)
|
|
return weakref.proxy(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.Constraint" href="#pywrapcp.Constraint">Constraint</a></li>
|
|
<li><a title="pywrapcp.IntExpr" href="#pywrapcp.IntExpr">IntExpr</a></li>
|
|
<li><a title="pywrapcp.IntervalVar" href="#pywrapcp.IntervalVar">IntervalVar</a></li>
|
|
<li><a title="pywrapcp.SequenceVar" href="#pywrapcp.SequenceVar">SequenceVar</a></li>
|
|
<li><a title="pywrapcp.Assignment" href="#pywrapcp.Assignment">Assignment</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.PropagationBaseObject.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.PropagationBaseObject_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.PropagationBaseObject.Name"><code class="name flex">
|
|
<span>def <span class="ident">Name</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Object naming.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Name(self) -> "std::string":
|
|
r""" Object naming."""
|
|
return _pywrapcp.PropagationBaseObject_Name(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.PropagationBaseObject.solver"><code class="name flex">
|
|
<span>def <span class="ident">solver</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def solver(self) -> "operations_research::Solver *":
|
|
return _pywrapcp.PropagationBaseObject_solver(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.BaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.PyConstraint"><code class="flex name class">
|
|
<span>class <span class="ident">PyConstraint</span></span>
|
|
<span>(</span><span>solver)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A constraint is the main modeling object. It provides two methods:
|
|
- Post() is responsible for creating the demons and attaching them to
|
|
immediate demons().
|
|
- InitialPropagate() is called once just after Post and performs
|
|
the initial propagation. The subsequent propagations will be performed
|
|
by the demons Posted during the post() method.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class PyConstraint(Constraint):
|
|
|
|
def __init__(self, solver):
|
|
Constraint.__init__(self, solver)
|
|
self.__demons = []
|
|
|
|
def Demon(self, method, *args):
|
|
demon = PyConstraintDemon(self, method, False, *args)
|
|
self.__demons.append(demon)
|
|
return demon
|
|
|
|
def DelayedDemon(self, method, *args):
|
|
demon = PyConstraintDemon(self, method, True, *args)
|
|
self.__demons.append(demon)
|
|
return demon
|
|
|
|
def InitialPropagateDemon(self):
|
|
return self.solver().ConstraintInitialPropagateCallback(self)
|
|
|
|
def DelayedInitialPropagateDemon(self):
|
|
return self.solver().DelayedConstraintInitialPropagateCallback(self)
|
|
|
|
def InitialPropagateWrapper(self):
|
|
try:
|
|
self.InitialPropagate()
|
|
except Exception as e:
|
|
if 'CP Solver fail' in str(e):
|
|
self.solver().ShouldFail()
|
|
else:
|
|
raise
|
|
|
|
def DebugString(self):
|
|
return "PyConstraint"</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.Constraint" href="#pywrapcp.Constraint">Constraint</a></li>
|
|
<li><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.PyConstraint.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self):
|
|
return "PyConstraint"</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.PyConstraint.DelayedDemon"><code class="name flex">
|
|
<span>def <span class="ident">DelayedDemon</span></span>(<span>self, method, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DelayedDemon(self, method, *args):
|
|
demon = PyConstraintDemon(self, method, True, *args)
|
|
self.__demons.append(demon)
|
|
return demon</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.PyConstraint.DelayedInitialPropagateDemon"><code class="name flex">
|
|
<span>def <span class="ident">DelayedInitialPropagateDemon</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DelayedInitialPropagateDemon(self):
|
|
return self.solver().DelayedConstraintInitialPropagateCallback(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.PyConstraint.Demon"><code class="name flex">
|
|
<span>def <span class="ident">Demon</span></span>(<span>self, method, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Demon(self, method, *args):
|
|
demon = PyConstraintDemon(self, method, False, *args)
|
|
self.__demons.append(demon)
|
|
return demon</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.PyConstraint.InitialPropagateDemon"><code class="name flex">
|
|
<span>def <span class="ident">InitialPropagateDemon</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def InitialPropagateDemon(self):
|
|
return self.solver().ConstraintInitialPropagateCallback(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.Constraint" href="#pywrapcp.Constraint">Constraint</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.Constraint.InitialPropagateWrapper" href="#pywrapcp.Constraint.InitialPropagateWrapper">InitialPropagateWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Name" href="#pywrapcp.PropagationBaseObject.Name">Name</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Post" href="#pywrapcp.Constraint.Post">Post</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Var" href="#pywrapcp.Constraint.Var">Var</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.PyConstraintDemon"><code class="flex name class">
|
|
<span>class <span class="ident">PyConstraintDemon</span></span>
|
|
<span>(</span><span>ct, method, delayed, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A Demon is the base element of a propagation queue. It is the main
|
|
object responsible for implementing the actual propagation
|
|
of the constraint and pruning the inconsistent values in the domains
|
|
of the variables. The main concept is that demons are listeners that are
|
|
attached to the variables and listen to their modifications. There are two methods:
|
|
- Run() is the actual method called when the demon is processed.
|
|
- priority() returns its priority. Standard priorities are slow, normal
|
|
or fast. "immediate" is reserved for variables and is treated separately.</p>
|
|
<p>This indicates the priority of a demon. Immediate demons are treated separately and corresponds to variables.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class PyConstraintDemon(PyDemon):
|
|
|
|
def __init__(self, ct, method, delayed, *args):
|
|
PyDemon.__init__(self)
|
|
self.__constraint = ct
|
|
self.__method = method
|
|
self.__delayed = delayed
|
|
self.__args = args
|
|
|
|
def Run(self, solver):
|
|
self.__method(self.__constraint, *self.__args)
|
|
|
|
def Priority(self):
|
|
return Solver.DELAYED_PRIORITY if self.__delayed else Solver.NORMAL_PRIORITY
|
|
|
|
def DebugString(self):
|
|
return 'PyConstraintDemon'</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.PyDemon" href="#pywrapcp.PyDemon">PyDemon</a></li>
|
|
<li><a title="pywrapcp.Demon" href="#pywrapcp.Demon">Demon</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.PyConstraintDemon.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self):
|
|
return 'PyConstraintDemon'</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.PyConstraintDemon.Run"><code class="name flex">
|
|
<span>def <span class="ident">Run</span></span>(<span>self, solver)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Run(self, solver):
|
|
self.__method(self.__constraint, *self.__args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.PyDemon" href="#pywrapcp.PyDemon">PyDemon</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.PyDemon.Desinhibit" href="#pywrapcp.Demon.Desinhibit">Desinhibit</a></code></li>
|
|
<li><code><a title="pywrapcp.PyDemon.Inhibit" href="#pywrapcp.Demon.Inhibit">Inhibit</a></code></li>
|
|
<li><code><a title="pywrapcp.PyDemon.Priority" href="#pywrapcp.Demon.Priority">Priority</a></code></li>
|
|
<li><code><a title="pywrapcp.PyDemon.RunWrapper" href="#pywrapcp.Demon.RunWrapper">RunWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.PyDemon.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.PyDecision"><code class="flex name class">
|
|
<span>class <span class="ident">PyDecision</span></span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A Decision represents a choice point in the search tree. The two main methods are Apply() to go left, or Refute() to go right.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class PyDecision(Decision):
|
|
|
|
def __init__(self):
|
|
Decision.__init__(self)
|
|
|
|
def ApplyWrapper(self, solver):
|
|
try:
|
|
self.Apply(solver)
|
|
except Exception as e:
|
|
if 'CP Solver fail' in str(e):
|
|
solver.ShouldFail()
|
|
else:
|
|
raise
|
|
|
|
def RefuteWrapper(self, solver):
|
|
try:
|
|
self.Refute(solver)
|
|
except Exception as e:
|
|
if 'CP Solver fail' in str(e):
|
|
solver.ShouldFail()
|
|
else:
|
|
raise
|
|
|
|
def DebugString(self):
|
|
return "PyDecision"</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.Decision" href="#pywrapcp.Decision">Decision</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.PyDecision.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self):
|
|
return "PyDecision"</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.Decision" href="#pywrapcp.Decision">Decision</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.Decision.ApplyWrapper" href="#pywrapcp.Decision.ApplyWrapper">ApplyWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.Decision.RefuteWrapper" href="#pywrapcp.Decision.RefuteWrapper">RefuteWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.Decision.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.PyDecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">PyDecisionBuilder</span></span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class PyDecisionBuilder(DecisionBuilder):
|
|
|
|
def __init__(self):
|
|
DecisionBuilder.__init__(self)
|
|
|
|
def NextWrapper(self, solver):
|
|
try:
|
|
return self.Next(solver)
|
|
except Exception as e:
|
|
if 'CP Solver fail' in str(e):
|
|
return solver.FailDecision()
|
|
else:
|
|
raise
|
|
|
|
def DebugString(self):
|
|
return "PyDecisionBuilder"</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.PyDecisionBuilder.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self):
|
|
return "PyDecisionBuilder"</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.DecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.DecisionBuilder.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.PyDemon"><code class="flex name class">
|
|
<span>class <span class="ident">PyDemon</span></span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A Demon is the base element of a propagation queue. It is the main
|
|
object responsible for implementing the actual propagation
|
|
of the constraint and pruning the inconsistent values in the domains
|
|
of the variables. The main concept is that demons are listeners that are
|
|
attached to the variables and listen to their modifications. There are two methods:
|
|
- Run() is the actual method called when the demon is processed.
|
|
- priority() returns its priority. Standard priorities are slow, normal
|
|
or fast. "immediate" is reserved for variables and is treated separately.</p>
|
|
<p>This indicates the priority of a demon. Immediate demons are treated separately and corresponds to variables.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class PyDemon(Demon):
|
|
|
|
def RunWrapper(self, solver):
|
|
try:
|
|
self.Run(solver)
|
|
except Exception as e:
|
|
if 'CP Solver fail' in str(e):
|
|
solver.ShouldFail()
|
|
else:
|
|
raise
|
|
|
|
def DebugString(self):
|
|
return "PyDemon"</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.Demon" href="#pywrapcp.Demon">Demon</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.PyConstraintDemon" href="#pywrapcp.PyConstraintDemon">PyConstraintDemon</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.PyDemon.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self):
|
|
return "PyDemon"</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.Demon" href="#pywrapcp.Demon">Demon</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.Demon.Desinhibit" href="#pywrapcp.Demon.Desinhibit">Desinhibit</a></code></li>
|
|
<li><code><a title="pywrapcp.Demon.Inhibit" href="#pywrapcp.Demon.Inhibit">Inhibit</a></code></li>
|
|
<li><code><a title="pywrapcp.Demon.Priority" href="#pywrapcp.Demon.Priority">Priority</a></code></li>
|
|
<li><code><a title="pywrapcp.Demon.RunWrapper" href="#pywrapcp.Demon.RunWrapper">RunWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.Demon.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.RevBool"><code class="flex name class">
|
|
<span>class <span class="ident">RevBool</span></span>
|
|
<span>(</span><span>val)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This class adds reversibility to a POD type. It contains the stamp optimization. i.e. the SaveValue call is done only once per node of the search tree.
|
|
Please note that actual stamps always starts at 1, thus an initial value of 0 will always trigger the first SaveValue.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class RevBool(object):
|
|
r""" This class adds reversibility to a POD type. It contains the stamp optimization. i.e. the SaveValue call is done only once per node of the search tree. Please note that actual stamps always starts at 1, thus an initial value of 0 will always trigger the first SaveValue."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, val: 'bool const &'):
|
|
_pywrapcp.RevBool_swiginit(self, _pywrapcp.new_RevBool(val))
|
|
|
|
def Value(self) -> "bool const &":
|
|
return _pywrapcp.RevBool_Value(self)
|
|
|
|
def SetValue(self, s: 'Solver', val: 'bool const &') -> "void":
|
|
return _pywrapcp.RevBool_SetValue(self, s, val)
|
|
__swig_destroy__ = _pywrapcp.delete_RevBool</code></pre>
|
|
</details>
|
|
<h3>Instance variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.RevBool.thisown"><code class="name">var <span class="ident">thisown</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The membership flag</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.RevBool.SetValue"><code class="name flex">
|
|
<span>def <span class="ident">SetValue</span></span>(<span>self, s, val)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetValue(self, s: 'Solver', val: 'bool const &') -> "void":
|
|
return _pywrapcp.RevBool_SetValue(self, s, val)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RevBool.Value"><code class="name flex">
|
|
<span>def <span class="ident">Value</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Value(self) -> "bool const &":
|
|
return _pywrapcp.RevBool_Value(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
</dd>
|
|
<dt id="pywrapcp.RevInteger"><code class="flex name class">
|
|
<span>class <span class="ident">RevInteger</span></span>
|
|
<span>(</span><span>val)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This class adds reversibility to a POD type. It contains the stamp optimization. i.e. the SaveValue call is done only once per node of the search tree.
|
|
Please note that actual stamps always starts at 1, thus an initial value of 0 will always trigger the first SaveValue.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class RevInteger(object):
|
|
r""" This class adds reversibility to a POD type. It contains the stamp optimization. i.e. the SaveValue call is done only once per node of the search tree. Please note that actual stamps always starts at 1, thus an initial value of 0 will always trigger the first SaveValue."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, val: 'long long const &'):
|
|
_pywrapcp.RevInteger_swiginit(self, _pywrapcp.new_RevInteger(val))
|
|
|
|
def Value(self) -> "long long const &":
|
|
return _pywrapcp.RevInteger_Value(self)
|
|
|
|
def SetValue(self, s: 'Solver', val: 'long long const &') -> "void":
|
|
return _pywrapcp.RevInteger_SetValue(self, s, val)
|
|
__swig_destroy__ = _pywrapcp.delete_RevInteger</code></pre>
|
|
</details>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.NumericalRevInteger" href="#pywrapcp.NumericalRevInteger">NumericalRevInteger</a></li>
|
|
</ul>
|
|
<h3>Instance variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.RevInteger.thisown"><code class="name">var <span class="ident">thisown</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The membership flag</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.RevInteger.SetValue"><code class="name flex">
|
|
<span>def <span class="ident">SetValue</span></span>(<span>self, s, val)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetValue(self, s: 'Solver', val: 'long long const &') -> "void":
|
|
return _pywrapcp.RevInteger_SetValue(self, s, val)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RevInteger.Value"><code class="name flex">
|
|
<span>def <span class="ident">Value</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Value(self) -> "long long const &":
|
|
return _pywrapcp.RevInteger_Value(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension"><code class="flex name class">
|
|
<span>class <span class="ident">RoutingDimension</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class RoutingDimension(object):
|
|
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
|
|
__swig_destroy__ = _pywrapcp.delete_RoutingDimension
|
|
|
|
def model(self) -> "operations_research::RoutingModel *":
|
|
return _pywrapcp.RoutingDimension_model(self)
|
|
|
|
def GetTransitValue(self, from_index: 'int64', to_index: 'int64', vehicle: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetTransitValue(self, from_index, to_index, vehicle)
|
|
|
|
def GetTransitValueFromClass(self, from_index: 'int64', to_index: 'int64', vehicle_class: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetTransitValueFromClass(self, from_index, to_index, vehicle_class)
|
|
|
|
def CumulVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingDimension_CumulVar(self, index)
|
|
|
|
def TransitVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingDimension_TransitVar(self, index)
|
|
|
|
def FixedTransitVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingDimension_FixedTransitVar(self, index)
|
|
|
|
def SlackVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingDimension_SlackVar(self, index)
|
|
|
|
def SetSpanUpperBoundForVehicle(self, upper_bound: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetSpanUpperBoundForVehicle(self, upper_bound, vehicle)
|
|
|
|
def SetSpanCostCoefficientForVehicle(self, coefficient: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForVehicle(self, coefficient, vehicle)
|
|
|
|
def SetSpanCostCoefficientForAllVehicles(self, coefficient: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForAllVehicles(self, coefficient)
|
|
|
|
def SetGlobalSpanCostCoefficient(self, coefficient: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetGlobalSpanCostCoefficient(self, coefficient)
|
|
|
|
def SetCumulVarSoftUpperBound(self, index: 'int64', upper_bound: 'int64', coefficient: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient)
|
|
|
|
def HasCumulVarSoftUpperBound(self, index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingDimension_HasCumulVarSoftUpperBound(self, index)
|
|
|
|
def GetCumulVarSoftUpperBound(self, index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBound(self, index)
|
|
|
|
def GetCumulVarSoftUpperBoundCoefficient(self, index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBoundCoefficient(self, index)
|
|
|
|
def SetCumulVarSoftLowerBound(self, index: 'int64', lower_bound: 'int64', coefficient: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient)
|
|
|
|
def HasCumulVarSoftLowerBound(self, index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingDimension_HasCumulVarSoftLowerBound(self, index)
|
|
|
|
def GetCumulVarSoftLowerBound(self, index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBound(self, index)
|
|
|
|
def GetCumulVarSoftLowerBoundCoefficient(self, index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBoundCoefficient(self, index)
|
|
|
|
def SetBreakIntervalsOfVehicle(self, breaks: 'std::vector< operations_research::IntervalVar * >', vehicle: 'int', node_visit_transits: 'std::vector< int64 >') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits)
|
|
|
|
def SetBreakDistanceDurationOfVehicle(self, distance: 'int64', duration: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle)
|
|
|
|
def InitializeBreaks(self) -> "void":
|
|
return _pywrapcp.RoutingDimension_InitializeBreaks(self)
|
|
|
|
def HasBreakConstraints(self) -> "bool":
|
|
return _pywrapcp.RoutingDimension_HasBreakConstraints(self)
|
|
|
|
def GetPreTravelEvaluatorOfVehicle(self, vehicle: 'int') -> "int":
|
|
return _pywrapcp.RoutingDimension_GetPreTravelEvaluatorOfVehicle(self, vehicle)
|
|
|
|
def GetPostTravelEvaluatorOfVehicle(self, vehicle: 'int') -> "int":
|
|
return _pywrapcp.RoutingDimension_GetPostTravelEvaluatorOfVehicle(self, vehicle)
|
|
|
|
def base_dimension(self) -> "operations_research::RoutingDimension const *":
|
|
return _pywrapcp.RoutingDimension_base_dimension(self)
|
|
|
|
def ShortestTransitionSlack(self, node: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_ShortestTransitionSlack(self, node)
|
|
|
|
def name(self) -> "std::string const &":
|
|
return _pywrapcp.RoutingDimension_name(self)
|
|
|
|
def SetPickupToDeliveryLimitFunctionForPair(self, limit_function: 'operations_research::RoutingDimension::PickupToDeliveryLimitFunction', pair_index: 'int') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index)
|
|
|
|
def HasPickupToDeliveryLimits(self) -> "bool":
|
|
return _pywrapcp.RoutingDimension_HasPickupToDeliveryLimits(self)
|
|
|
|
def AddNodePrecedence(self, first_node: 'int64', second_node: 'int64', offset: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_AddNodePrecedence(self, first_node, second_node, offset)
|
|
|
|
def GetSpanUpperBoundForVehicle(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetSpanUpperBoundForVehicle(self, vehicle)
|
|
|
|
def GetSpanCostCoefficientForVehicle(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetSpanCostCoefficientForVehicle(self, vehicle)
|
|
|
|
def global_span_cost_coefficient(self) -> "int64":
|
|
return _pywrapcp.RoutingDimension_global_span_cost_coefficient(self)
|
|
|
|
def GetGlobalOptimizerOffset(self) -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetGlobalOptimizerOffset(self)
|
|
|
|
def GetLocalOptimizerOffsetForVehicle(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetLocalOptimizerOffsetForVehicle(self, vehicle)</code></pre>
|
|
</details>
|
|
<h3>Instance variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.RoutingDimension.thisown"><code class="name">var <span class="ident">thisown</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The membership flag</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.RoutingDimension.AddNodePrecedence"><code class="name flex">
|
|
<span>def <span class="ident">AddNodePrecedence</span></span>(<span>self, first_node, second_node, offset)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddNodePrecedence(self, first_node: 'int64', second_node: 'int64', offset: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_AddNodePrecedence(self, first_node, second_node, offset)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.CumulVar"><code class="name flex">
|
|
<span>def <span class="ident">CumulVar</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CumulVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingDimension_CumulVar(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.FixedTransitVar"><code class="name flex">
|
|
<span>def <span class="ident">FixedTransitVar</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FixedTransitVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingDimension_FixedTransitVar(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.GetCumulVarSoftLowerBound"><code class="name flex">
|
|
<span>def <span class="ident">GetCumulVarSoftLowerBound</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetCumulVarSoftLowerBound(self, index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBound(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.GetCumulVarSoftLowerBoundCoefficient"><code class="name flex">
|
|
<span>def <span class="ident">GetCumulVarSoftLowerBoundCoefficient</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetCumulVarSoftLowerBoundCoefficient(self, index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBoundCoefficient(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.GetCumulVarSoftUpperBound"><code class="name flex">
|
|
<span>def <span class="ident">GetCumulVarSoftUpperBound</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetCumulVarSoftUpperBound(self, index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBound(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.GetCumulVarSoftUpperBoundCoefficient"><code class="name flex">
|
|
<span>def <span class="ident">GetCumulVarSoftUpperBoundCoefficient</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetCumulVarSoftUpperBoundCoefficient(self, index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBoundCoefficient(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.GetGlobalOptimizerOffset"><code class="name flex">
|
|
<span>def <span class="ident">GetGlobalOptimizerOffset</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetGlobalOptimizerOffset(self) -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetGlobalOptimizerOffset(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.GetLocalOptimizerOffsetForVehicle"><code class="name flex">
|
|
<span>def <span class="ident">GetLocalOptimizerOffsetForVehicle</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetLocalOptimizerOffsetForVehicle(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetLocalOptimizerOffsetForVehicle(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.GetPostTravelEvaluatorOfVehicle"><code class="name flex">
|
|
<span>def <span class="ident">GetPostTravelEvaluatorOfVehicle</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetPostTravelEvaluatorOfVehicle(self, vehicle: 'int') -> "int":
|
|
return _pywrapcp.RoutingDimension_GetPostTravelEvaluatorOfVehicle(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.GetPreTravelEvaluatorOfVehicle"><code class="name flex">
|
|
<span>def <span class="ident">GetPreTravelEvaluatorOfVehicle</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetPreTravelEvaluatorOfVehicle(self, vehicle: 'int') -> "int":
|
|
return _pywrapcp.RoutingDimension_GetPreTravelEvaluatorOfVehicle(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.GetSpanCostCoefficientForVehicle"><code class="name flex">
|
|
<span>def <span class="ident">GetSpanCostCoefficientForVehicle</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetSpanCostCoefficientForVehicle(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetSpanCostCoefficientForVehicle(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.GetSpanUpperBoundForVehicle"><code class="name flex">
|
|
<span>def <span class="ident">GetSpanUpperBoundForVehicle</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetSpanUpperBoundForVehicle(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetSpanUpperBoundForVehicle(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.GetTransitValue"><code class="name flex">
|
|
<span>def <span class="ident">GetTransitValue</span></span>(<span>self, from_index, to_index, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetTransitValue(self, from_index: 'int64', to_index: 'int64', vehicle: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetTransitValue(self, from_index, to_index, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.GetTransitValueFromClass"><code class="name flex">
|
|
<span>def <span class="ident">GetTransitValueFromClass</span></span>(<span>self, from_index, to_index, vehicle_class)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetTransitValueFromClass(self, from_index: 'int64', to_index: 'int64', vehicle_class: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_GetTransitValueFromClass(self, from_index, to_index, vehicle_class)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.HasBreakConstraints"><code class="name flex">
|
|
<span>def <span class="ident">HasBreakConstraints</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HasBreakConstraints(self) -> "bool":
|
|
return _pywrapcp.RoutingDimension_HasBreakConstraints(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.HasCumulVarSoftLowerBound"><code class="name flex">
|
|
<span>def <span class="ident">HasCumulVarSoftLowerBound</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HasCumulVarSoftLowerBound(self, index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingDimension_HasCumulVarSoftLowerBound(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.HasCumulVarSoftUpperBound"><code class="name flex">
|
|
<span>def <span class="ident">HasCumulVarSoftUpperBound</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HasCumulVarSoftUpperBound(self, index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingDimension_HasCumulVarSoftUpperBound(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.HasPickupToDeliveryLimits"><code class="name flex">
|
|
<span>def <span class="ident">HasPickupToDeliveryLimits</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HasPickupToDeliveryLimits(self) -> "bool":
|
|
return _pywrapcp.RoutingDimension_HasPickupToDeliveryLimits(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.InitializeBreaks"><code class="name flex">
|
|
<span>def <span class="ident">InitializeBreaks</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def InitializeBreaks(self) -> "void":
|
|
return _pywrapcp.RoutingDimension_InitializeBreaks(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.SetBreakDistanceDurationOfVehicle"><code class="name flex">
|
|
<span>def <span class="ident">SetBreakDistanceDurationOfVehicle</span></span>(<span>self, distance, duration, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetBreakDistanceDurationOfVehicle(self, distance: 'int64', duration: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.SetBreakIntervalsOfVehicle"><code class="name flex">
|
|
<span>def <span class="ident">SetBreakIntervalsOfVehicle</span></span>(<span>self, breaks, vehicle, node_visit_transits)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetBreakIntervalsOfVehicle(self, breaks: 'std::vector< operations_research::IntervalVar * >', vehicle: 'int', node_visit_transits: 'std::vector< int64 >') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.SetCumulVarSoftLowerBound"><code class="name flex">
|
|
<span>def <span class="ident">SetCumulVarSoftLowerBound</span></span>(<span>self, index, lower_bound, coefficient)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetCumulVarSoftLowerBound(self, index: 'int64', lower_bound: 'int64', coefficient: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.SetCumulVarSoftUpperBound"><code class="name flex">
|
|
<span>def <span class="ident">SetCumulVarSoftUpperBound</span></span>(<span>self, index, upper_bound, coefficient)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetCumulVarSoftUpperBound(self, index: 'int64', upper_bound: 'int64', coefficient: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.SetGlobalSpanCostCoefficient"><code class="name flex">
|
|
<span>def <span class="ident">SetGlobalSpanCostCoefficient</span></span>(<span>self, coefficient)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetGlobalSpanCostCoefficient(self, coefficient: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetGlobalSpanCostCoefficient(self, coefficient)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.SetPickupToDeliveryLimitFunctionForPair"><code class="name flex">
|
|
<span>def <span class="ident">SetPickupToDeliveryLimitFunctionForPair</span></span>(<span>self, limit_function, pair_index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetPickupToDeliveryLimitFunctionForPair(self, limit_function: 'operations_research::RoutingDimension::PickupToDeliveryLimitFunction', pair_index: 'int') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.SetSpanCostCoefficientForAllVehicles"><code class="name flex">
|
|
<span>def <span class="ident">SetSpanCostCoefficientForAllVehicles</span></span>(<span>self, coefficient)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetSpanCostCoefficientForAllVehicles(self, coefficient: 'int64') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForAllVehicles(self, coefficient)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.SetSpanCostCoefficientForVehicle"><code class="name flex">
|
|
<span>def <span class="ident">SetSpanCostCoefficientForVehicle</span></span>(<span>self, coefficient, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetSpanCostCoefficientForVehicle(self, coefficient: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForVehicle(self, coefficient, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.SetSpanUpperBoundForVehicle"><code class="name flex">
|
|
<span>def <span class="ident">SetSpanUpperBoundForVehicle</span></span>(<span>self, upper_bound, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetSpanUpperBoundForVehicle(self, upper_bound: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingDimension_SetSpanUpperBoundForVehicle(self, upper_bound, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.ShortestTransitionSlack"><code class="name flex">
|
|
<span>def <span class="ident">ShortestTransitionSlack</span></span>(<span>self, node)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ShortestTransitionSlack(self, node: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingDimension_ShortestTransitionSlack(self, node)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.SlackVar"><code class="name flex">
|
|
<span>def <span class="ident">SlackVar</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SlackVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingDimension_SlackVar(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.TransitVar"><code class="name flex">
|
|
<span>def <span class="ident">TransitVar</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def TransitVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingDimension_TransitVar(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.base_dimension"><code class="name flex">
|
|
<span>def <span class="ident">base_dimension</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def base_dimension(self) -> "operations_research::RoutingDimension const *":
|
|
return _pywrapcp.RoutingDimension_base_dimension(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.global_span_cost_coefficient"><code class="name flex">
|
|
<span>def <span class="ident">global_span_cost_coefficient</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def global_span_cost_coefficient(self) -> "int64":
|
|
return _pywrapcp.RoutingDimension_global_span_cost_coefficient(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.model"><code class="name flex">
|
|
<span>def <span class="ident">model</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def model(self) -> "operations_research::RoutingModel *":
|
|
return _pywrapcp.RoutingDimension_model(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingDimension.name"><code class="name flex">
|
|
<span>def <span class="ident">name</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def name(self) -> "std::string const &":
|
|
return _pywrapcp.RoutingDimension_name(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingFilteredDecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">RoutingFilteredDecisionBuilder</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class RoutingFilteredDecisionBuilder(IntVarFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_RoutingFilteredDecisionBuilder
|
|
|
|
def model(self) -> "operations_research::RoutingModel *":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_model(self)
|
|
|
|
def GetStartChainEnd(self, vehicle: 'int') -> "int":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_GetStartChainEnd(self, vehicle)
|
|
|
|
def GetEndChainStart(self, vehicle: 'int') -> "int":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_GetEndChainStart(self, vehicle)
|
|
|
|
def MakeDisjunctionNodesUnperformed(self, node: 'int64') -> "void":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_MakeDisjunctionNodesUnperformed(self, node)
|
|
|
|
def MakeUnassignedNodesUnperformed(self) -> "void":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_MakeUnassignedNodesUnperformed(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.CheapestInsertionFilteredDecisionBuilder" href="#pywrapcp.CheapestInsertionFilteredDecisionBuilder">CheapestInsertionFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.CheapestAdditionFilteredDecisionBuilder" href="#pywrapcp.CheapestAdditionFilteredDecisionBuilder">CheapestAdditionFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.SavingsFilteredDecisionBuilder" href="#pywrapcp.SavingsFilteredDecisionBuilder">SavingsFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.ChristofidesFilteredDecisionBuilder" href="#pywrapcp.ChristofidesFilteredDecisionBuilder">ChristofidesFilteredDecisionBuilder</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.RoutingFilteredDecisionBuilder.GetEndChainStart"><code class="name flex">
|
|
<span>def <span class="ident">GetEndChainStart</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetEndChainStart(self, vehicle: 'int') -> "int":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_GetEndChainStart(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingFilteredDecisionBuilder.GetStartChainEnd"><code class="name flex">
|
|
<span>def <span class="ident">GetStartChainEnd</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetStartChainEnd(self, vehicle: 'int') -> "int":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_GetStartChainEnd(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingFilteredDecisionBuilder.MakeDisjunctionNodesUnperformed"><code class="name flex">
|
|
<span>def <span class="ident">MakeDisjunctionNodesUnperformed</span></span>(<span>self, node)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MakeDisjunctionNodesUnperformed(self, node: 'int64') -> "void":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_MakeDisjunctionNodesUnperformed(self, node)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingFilteredDecisionBuilder.MakeUnassignedNodesUnperformed"><code class="name flex">
|
|
<span>def <span class="ident">MakeUnassignedNodesUnperformed</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MakeUnassignedNodesUnperformed(self) -> "void":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_MakeUnassignedNodesUnperformed(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingFilteredDecisionBuilder.model"><code class="name flex">
|
|
<span>def <span class="ident">model</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def model(self) -> "operations_research::RoutingModel *":
|
|
return _pywrapcp.RoutingFilteredDecisionBuilder_model(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.IntVarFilteredDecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarFilteredDecisionBuilder.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingIndexManager"><code class="flex name class">
|
|
<span>class <span class="ident">RoutingIndexManager</span></span>
|
|
<span>(</span><span>*args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Manager for any NodeIndex <-> variable index conversion. The routing solver uses variable indices internally and through its API. These variable indices are tricky to manage directly because one Node can correspond to a multitude of variables, depending on the number of times they appear in the model, and if they're used as start and/or end points. This class aims to simplify variable index usage, allowing users to use NodeIndex instead. Usage:
|
|
auto starts_ends = …;
|
|
/// These are NodeIndex.
|
|
RoutingIndexManager manager(/<em>nodes</em>/10, /<em>vehicles</em>/4, starts_ends);
|
|
RoutingModel model(manager); Then, use 'manager.NodeToIndex(node)' whenever 'model' requires a variable index.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class RoutingIndexManager(object):
|
|
r""" Manager for any NodeIndex <-> variable index conversion. The routing solver uses variable indices internally and through its API. These variable indices are tricky to manage directly because one Node can correspond to a multitude of variables, depending on the number of times they appear in the model, and if they're used as start and/or end points. This class aims to simplify variable index usage, allowing users to use NodeIndex instead. Usage: auto starts_ends = ...; /// These are NodeIndex. RoutingIndexManager manager(/*nodes*/10, /*vehicles*/4, starts_ends); RoutingModel model(manager); Then, use 'manager.NodeToIndex(node)' whenever 'model' requires a variable index."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
_pywrapcp.RoutingIndexManager_swiginit(self, _pywrapcp.new_RoutingIndexManager(*args))
|
|
__swig_destroy__ = _pywrapcp.delete_RoutingIndexManager
|
|
|
|
def GetNumberOfNodes(self) -> "int":
|
|
return _pywrapcp.RoutingIndexManager_GetNumberOfNodes(self)
|
|
|
|
def GetNumberOfVehicles(self) -> "int":
|
|
return _pywrapcp.RoutingIndexManager_GetNumberOfVehicles(self)
|
|
|
|
def GetNumberOfIndices(self) -> "int":
|
|
return _pywrapcp.RoutingIndexManager_GetNumberOfIndices(self)
|
|
|
|
def NodeToIndex(self, node: 'operations_research::RoutingIndexManager::NodeIndex') -> "int64":
|
|
return _pywrapcp.RoutingIndexManager_NodeToIndex(self, node)
|
|
|
|
def IndexToNode(self, index: 'int64') -> "operations_research::RoutingIndexManager::NodeIndex":
|
|
return _pywrapcp.RoutingIndexManager_IndexToNode(self, index)</code></pre>
|
|
</details>
|
|
<h3>Instance variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.RoutingIndexManager.thisown"><code class="name">var <span class="ident">thisown</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The membership flag</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.RoutingIndexManager.GetNumberOfIndices"><code class="name flex">
|
|
<span>def <span class="ident">GetNumberOfIndices</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetNumberOfIndices(self) -> "int":
|
|
return _pywrapcp.RoutingIndexManager_GetNumberOfIndices(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingIndexManager.GetNumberOfNodes"><code class="name flex">
|
|
<span>def <span class="ident">GetNumberOfNodes</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetNumberOfNodes(self) -> "int":
|
|
return _pywrapcp.RoutingIndexManager_GetNumberOfNodes(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingIndexManager.GetNumberOfVehicles"><code class="name flex">
|
|
<span>def <span class="ident">GetNumberOfVehicles</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetNumberOfVehicles(self) -> "int":
|
|
return _pywrapcp.RoutingIndexManager_GetNumberOfVehicles(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingIndexManager.IndexToNode"><code class="name flex">
|
|
<span>def <span class="ident">IndexToNode</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IndexToNode(self, index: 'int64') -> "operations_research::RoutingIndexManager::NodeIndex":
|
|
return _pywrapcp.RoutingIndexManager_IndexToNode(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingIndexManager.NodeToIndex"><code class="name flex">
|
|
<span>def <span class="ident">NodeToIndex</span></span>(<span>self, node)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NodeToIndex(self, node: 'operations_research::RoutingIndexManager::NodeIndex') -> "int64":
|
|
return _pywrapcp.RoutingIndexManager_NodeToIndex(self, node)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel"><code class="flex name class">
|
|
<span>class <span class="ident">RoutingModel</span></span>
|
|
<span>(</span><span>*args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class RoutingModel(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
ROUTING_NOT_SOLVED = _pywrapcp.RoutingModel_ROUTING_NOT_SOLVED
|
|
ROUTING_SUCCESS = _pywrapcp.RoutingModel_ROUTING_SUCCESS
|
|
ROUTING_FAIL = _pywrapcp.RoutingModel_ROUTING_FAIL
|
|
ROUTING_FAIL_TIMEOUT = _pywrapcp.RoutingModel_ROUTING_FAIL_TIMEOUT
|
|
ROUTING_INVALID = _pywrapcp.RoutingModel_ROUTING_INVALID
|
|
PICKUP_AND_DELIVERY_NO_ORDER = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_NO_ORDER
|
|
PICKUP_AND_DELIVERY_LIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_LIFO
|
|
PICKUP_AND_DELIVERY_FIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_FIFO
|
|
|
|
def __init__(self, *args):
|
|
_pywrapcp.RoutingModel_swiginit(self, _pywrapcp.new_RoutingModel(*args))
|
|
__swig_destroy__ = _pywrapcp.delete_RoutingModel
|
|
|
|
def RegisterUnaryTransitCallback(self, callback: 'operations_research::RoutingModel::TransitCallback1') -> "int":
|
|
return _pywrapcp.RoutingModel_RegisterUnaryTransitCallback(self, callback)
|
|
|
|
def RegisterTransitCallback(self, callback: 'operations_research::RoutingModel::TransitCallback2') -> "int":
|
|
return _pywrapcp.RoutingModel_RegisterTransitCallback(self, callback)
|
|
|
|
def RegisterPositiveTransitCallback(self, callback: 'operations_research::RoutingModel::TransitCallback2') -> "int":
|
|
return _pywrapcp.RoutingModel_RegisterPositiveTransitCallback(self, callback)
|
|
|
|
def TransitCallback(self, callback_index: 'int') -> "operations_research::RoutingModel::TransitCallback2 const &":
|
|
return _pywrapcp.RoutingModel_TransitCallback(self, callback_index)
|
|
|
|
def UnaryTransitCallbackOrNull(self, callback_index: 'int') -> "operations_research::RoutingModel::TransitCallback1 const &":
|
|
return _pywrapcp.RoutingModel_UnaryTransitCallbackOrNull(self, callback_index)
|
|
|
|
def AddDimension(self, evaluator_index: 'int', slack_max: 'int64', capacity: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name)
|
|
|
|
def AddDimensionWithVehicleTransits(self, evaluator_indices: 'std::vector< int > const &', slack_max: 'int64', capacity: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name)
|
|
|
|
def AddDimensionWithVehicleCapacity(self, evaluator_index: 'int', slack_max: 'int64', vehicle_capacities: 'std::vector< int64 >', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)
|
|
|
|
def AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices: 'std::vector< int > const &', slack_max: 'int64', vehicle_capacities: 'std::vector< int64 >', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)
|
|
|
|
def AddConstantDimensionWithSlack(self, value: 'int64', capacity: 'int64', slack_max: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name)
|
|
|
|
def AddConstantDimension(self, value: 'int64', capacity: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name)
|
|
|
|
def AddVectorDimension(self, values: 'std::vector< int64 >', capacity: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name)
|
|
|
|
def MakePathSpansAndTotalSlacks(self, dimension: 'RoutingDimension', spans: 'std::vector< operations_research::IntVar * >', total_slacks: 'std::vector< operations_research::IntVar * >') -> "operations_research::Constraint *":
|
|
return _pywrapcp.RoutingModel_MakePathSpansAndTotalSlacks(self, dimension, spans, total_slacks)
|
|
|
|
def GetAllDimensionNames(self) -> "std::vector< ::std::string >":
|
|
return _pywrapcp.RoutingModel_GetAllDimensionNames(self)
|
|
|
|
def GetDimensions(self) -> "std::vector< operations_research::RoutingDimension * > const &":
|
|
return _pywrapcp.RoutingModel_GetDimensions(self)
|
|
|
|
def GetDimensionsWithSoftOrSpanCosts(self) -> "std::vector< operations_research::RoutingDimension * >":
|
|
return _pywrapcp.RoutingModel_GetDimensionsWithSoftOrSpanCosts(self)
|
|
|
|
def GetDimensionsForGlobalCumulOptimizers(self) -> "std::vector< operations_research::RoutingDimension * > const &":
|
|
return _pywrapcp.RoutingModel_GetDimensionsForGlobalCumulOptimizers(self)
|
|
|
|
def GetDimensionsForLocalCumulOptimizers(self) -> "std::vector< operations_research::RoutingDimension * > const &":
|
|
return _pywrapcp.RoutingModel_GetDimensionsForLocalCumulOptimizers(self)
|
|
|
|
def HasDimension(self, dimension_name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_HasDimension(self, dimension_name)
|
|
|
|
def GetDimensionOrDie(self, dimension_name: 'std::string const &') -> "operations_research::RoutingDimension const &":
|
|
return _pywrapcp.RoutingModel_GetDimensionOrDie(self, dimension_name)
|
|
|
|
def GetMutableDimension(self, dimension_name: 'std::string const &') -> "operations_research::RoutingDimension *":
|
|
return _pywrapcp.RoutingModel_GetMutableDimension(self, dimension_name)
|
|
|
|
def SetPrimaryConstrainedDimension(self, dimension_name: 'std::string const &') -> "void":
|
|
return _pywrapcp.RoutingModel_SetPrimaryConstrainedDimension(self, dimension_name)
|
|
|
|
def GetPrimaryConstrainedDimension(self) -> "std::string const &":
|
|
return _pywrapcp.RoutingModel_GetPrimaryConstrainedDimension(self)
|
|
|
|
def AddDisjunction(self, *args) -> "operations_research::RoutingModel::DisjunctionIndex":
|
|
return _pywrapcp.RoutingModel_AddDisjunction(self, *args)
|
|
|
|
def GetDisjunctionIndices(self, index: 'int64') -> "std::vector< operations_research::RoutingModel::DisjunctionIndex > const &":
|
|
return _pywrapcp.RoutingModel_GetDisjunctionIndices(self, index)
|
|
|
|
def GetDisjunctionPenalty(self, index: 'operations_research::RoutingModel::DisjunctionIndex') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetDisjunctionPenalty(self, index)
|
|
|
|
def GetDisjunctionMaxCardinality(self, index: 'operations_research::RoutingModel::DisjunctionIndex') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetDisjunctionMaxCardinality(self, index)
|
|
|
|
def GetNumberOfDisjunctions(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetNumberOfDisjunctions(self)
|
|
|
|
def GetPerfectBinaryDisjunctions(self) -> "std::vector< std::pair< int64,int64 > >":
|
|
return _pywrapcp.RoutingModel_GetPerfectBinaryDisjunctions(self)
|
|
|
|
def IgnoreDisjunctionsAlreadyForcedToZero(self) -> "void":
|
|
return _pywrapcp.RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero(self)
|
|
|
|
def AddSoftSameVehicleConstraint(self, indices: 'std::vector< int64 > const &', cost: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_AddSoftSameVehicleConstraint(self, indices, cost)
|
|
|
|
def SetAllowedVehiclesForIndex(self, vehicles: 'std::vector< int > const &', index: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_SetAllowedVehiclesForIndex(self, vehicles, index)
|
|
|
|
def IsVehicleAllowedForIndex(self, vehicle: 'int', index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingModel_IsVehicleAllowedForIndex(self, vehicle, index)
|
|
|
|
def AddPickupAndDelivery(self, pickup: 'int64', delivery: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_AddPickupAndDelivery(self, pickup, delivery)
|
|
|
|
def AddPickupAndDeliverySets(self, pickup_disjunction: 'operations_research::RoutingModel::DisjunctionIndex', delivery_disjunction: 'operations_research::RoutingModel::DisjunctionIndex') -> "void":
|
|
return _pywrapcp.RoutingModel_AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction)
|
|
|
|
def GetPickupIndexPairs(self, node_index: 'int64') -> "std::vector< std::pair< int,int > > const &":
|
|
return _pywrapcp.RoutingModel_GetPickupIndexPairs(self, node_index)
|
|
|
|
def GetDeliveryIndexPairs(self, node_index: 'int64') -> "std::vector< std::pair< int,int > > const &":
|
|
return _pywrapcp.RoutingModel_GetDeliveryIndexPairs(self, node_index)
|
|
|
|
def SetPickupAndDeliveryPolicyOfAllVehicles(self, policy: 'operations_research::RoutingModel::PickupAndDeliveryPolicy') -> "void":
|
|
return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles(self, policy)
|
|
|
|
def SetPickupAndDeliveryPolicyOfVehicle(self, policy: 'operations_research::RoutingModel::PickupAndDeliveryPolicy', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle)
|
|
|
|
def GetPickupAndDeliveryPolicyOfVehicle(self, vehicle: 'int') -> "operations_research::RoutingModel::PickupAndDeliveryPolicy":
|
|
return _pywrapcp.RoutingModel_GetPickupAndDeliveryPolicyOfVehicle(self, vehicle)
|
|
|
|
def GetNumOfSingletonNodes(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetNumOfSingletonNodes(self)
|
|
|
|
def SetVisitType(self, index: 'int64', type: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetVisitType(self, index, type)
|
|
|
|
def GetVisitType(self, index: 'int64') -> "int":
|
|
return _pywrapcp.RoutingModel_GetVisitType(self, index)
|
|
|
|
def CloseVisitTypes(self) -> "void":
|
|
return _pywrapcp.RoutingModel_CloseVisitTypes(self)
|
|
|
|
def GetNumberOfVisitTypes(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetNumberOfVisitTypes(self)
|
|
|
|
def AddHardTypeIncompatibility(self, type1: 'int', type2: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_AddHardTypeIncompatibility(self, type1, type2)
|
|
|
|
def AddTemporalTypeIncompatibility(self, type1: 'int', type2: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_AddTemporalTypeIncompatibility(self, type1, type2)
|
|
|
|
def GetHardTypeIncompatibilitiesOfType(self, type: 'int') -> "absl::flat_hash_set< int > const &":
|
|
return _pywrapcp.RoutingModel_GetHardTypeIncompatibilitiesOfType(self, type)
|
|
|
|
def GetTemporalTypeIncompatibilitiesOfType(self, type: 'int') -> "absl::flat_hash_set< int > const &":
|
|
return _pywrapcp.RoutingModel_GetTemporalTypeIncompatibilitiesOfType(self, type)
|
|
|
|
def HasHardTypeIncompatibilities(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasHardTypeIncompatibilities(self)
|
|
|
|
def HasTemporalTypeIncompatibilities(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasTemporalTypeIncompatibilities(self)
|
|
|
|
def AddSameVehicleRequiredTypeAlternatives(self, dependent_type: 'int', required_type_alternatives: 'absl::flat_hash_set< int >') -> "void":
|
|
return _pywrapcp.RoutingModel_AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives)
|
|
|
|
def AddTemporalRequiredTypeAlternatives(self, dependent_type: 'int', required_type_alternatives: 'absl::flat_hash_set< int >') -> "void":
|
|
return _pywrapcp.RoutingModel_AddTemporalRequiredTypeAlternatives(self, dependent_type, required_type_alternatives)
|
|
|
|
def GetSameVehicleRequiredTypeAlternativesOfType(self, type: 'int') -> "std::vector< absl::flat_hash_set< int > > const &":
|
|
return _pywrapcp.RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType(self, type)
|
|
|
|
def GetTemporalRequiredTypeAlternativesOfType(self, type: 'int') -> "std::vector< absl::flat_hash_set< int > > const &":
|
|
return _pywrapcp.RoutingModel_GetTemporalRequiredTypeAlternativesOfType(self, type)
|
|
|
|
def HasSameVehicleTypeRequirements(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasSameVehicleTypeRequirements(self)
|
|
|
|
def HasTemporalTypeRequirements(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasTemporalTypeRequirements(self)
|
|
|
|
def HasTypeRegulations(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasTypeRegulations(self)
|
|
|
|
def UnperformedPenalty(self, var_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_UnperformedPenalty(self, var_index)
|
|
|
|
def UnperformedPenaltyOrValue(self, default_value: 'int64', var_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_UnperformedPenaltyOrValue(self, default_value, var_index)
|
|
|
|
def GetDepot(self) -> "int64":
|
|
return _pywrapcp.RoutingModel_GetDepot(self)
|
|
|
|
def SetArcCostEvaluatorOfAllVehicles(self, evaluator_index: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfAllVehicles(self, evaluator_index)
|
|
|
|
def SetArcCostEvaluatorOfVehicle(self, evaluator_index: 'int', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle)
|
|
|
|
def SetFixedCostOfAllVehicles(self, cost: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_SetFixedCostOfAllVehicles(self, cost)
|
|
|
|
def SetFixedCostOfVehicle(self, cost: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetFixedCostOfVehicle(self, cost, vehicle)
|
|
|
|
def GetFixedCostOfVehicle(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetFixedCostOfVehicle(self, vehicle)
|
|
|
|
def SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor: 'int64', quadratic_cost_factor: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor)
|
|
|
|
def SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor: 'int64', quadratic_cost_factor: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle)
|
|
|
|
def GetAmortizedLinearCostFactorOfVehicles(self) -> "std::vector< int64 > const &":
|
|
return _pywrapcp.RoutingModel_GetAmortizedLinearCostFactorOfVehicles(self)
|
|
|
|
def GetAmortizedQuadraticCostFactorOfVehicles(self) -> "std::vector< int64 > const &":
|
|
return _pywrapcp.RoutingModel_GetAmortizedQuadraticCostFactorOfVehicles(self)
|
|
|
|
def ConsiderEmptyRouteCostsForVehicle(self, consider_costs: 'bool', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_ConsiderEmptyRouteCostsForVehicle(self, consider_costs, vehicle)
|
|
|
|
def AreEmptyRouteCostsConsideredForVehicle(self, vehicle: 'int') -> "bool":
|
|
return _pywrapcp.RoutingModel_AreEmptyRouteCostsConsideredForVehicle(self, vehicle)
|
|
|
|
def SetFirstSolutionEvaluator(self, evaluator: 'operations_research::Solver::IndexEvaluator2') -> "void":
|
|
return _pywrapcp.RoutingModel_SetFirstSolutionEvaluator(self, evaluator)
|
|
|
|
def AddLocalSearchOperator(self, ls_operator: 'LocalSearchOperator') -> "void":
|
|
return _pywrapcp.RoutingModel_AddLocalSearchOperator(self, ls_operator)
|
|
|
|
def AddSearchMonitor(self, monitor: 'SearchMonitor') -> "void":
|
|
return _pywrapcp.RoutingModel_AddSearchMonitor(self, monitor)
|
|
|
|
def AddAtSolutionCallback(self, callback: 'std::function< void () >') -> "void":
|
|
return _pywrapcp.RoutingModel_AddAtSolutionCallback(self, callback)
|
|
|
|
def AddVariableMinimizedByFinalizer(self, var: 'IntVar') -> "void":
|
|
return _pywrapcp.RoutingModel_AddVariableMinimizedByFinalizer(self, var)
|
|
|
|
def AddVariableMaximizedByFinalizer(self, var: 'IntVar') -> "void":
|
|
return _pywrapcp.RoutingModel_AddVariableMaximizedByFinalizer(self, var)
|
|
|
|
def AddWeightedVariableMinimizedByFinalizer(self, var: 'IntVar', cost: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_AddWeightedVariableMinimizedByFinalizer(self, var, cost)
|
|
|
|
def AddVariableTargetToFinalizer(self, var: 'IntVar', target: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_AddVariableTargetToFinalizer(self, var, target)
|
|
|
|
def CloseModel(self) -> "void":
|
|
return _pywrapcp.RoutingModel_CloseModel(self)
|
|
|
|
def CloseModelWithParameters(self, search_parameters: 'operations_research::RoutingSearchParameters const &') -> "void":
|
|
return _pywrapcp.RoutingModel_CloseModelWithParameters(self, search_parameters)
|
|
|
|
def Solve(self, assignment: 'Assignment'=None) -> "operations_research::Assignment const *":
|
|
return _pywrapcp.RoutingModel_Solve(self, assignment)
|
|
|
|
def SolveWithParameters(self, search_parameters: 'operations_research::RoutingSearchParameters const &', solutions: 'std::vector< operations_research::Assignment const * > *'=None) -> "operations_research::Assignment const *":
|
|
return _pywrapcp.RoutingModel_SolveWithParameters(self, search_parameters, solutions)
|
|
|
|
def SolveFromAssignmentWithParameters(self, assignment: 'Assignment', search_parameters: 'operations_research::RoutingSearchParameters const &', solutions: 'std::vector< operations_research::Assignment const * > *'=None) -> "operations_research::Assignment const *":
|
|
return _pywrapcp.RoutingModel_SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions)
|
|
|
|
def SetAssignmentFromOtherModelAssignment(self, target_assignment: 'Assignment', source_model: 'RoutingModel', source_assignment: 'Assignment') -> "void":
|
|
return _pywrapcp.RoutingModel_SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment)
|
|
|
|
def ComputeLowerBound(self) -> "int64":
|
|
return _pywrapcp.RoutingModel_ComputeLowerBound(self)
|
|
|
|
def status(self) -> "operations_research::RoutingModel::Status":
|
|
return _pywrapcp.RoutingModel_status(self)
|
|
|
|
def ApplyLocks(self, locks: 'std::vector< int64 > const &') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_ApplyLocks(self, locks)
|
|
|
|
def ApplyLocksToAllVehicles(self, locks: 'std::vector< std::vector< int64 > > const &', close_routes: 'bool') -> "bool":
|
|
return _pywrapcp.RoutingModel_ApplyLocksToAllVehicles(self, locks, close_routes)
|
|
|
|
def PreAssignment(self) -> "operations_research::Assignment const *const":
|
|
return _pywrapcp.RoutingModel_PreAssignment(self)
|
|
|
|
def MutablePreAssignment(self) -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_MutablePreAssignment(self)
|
|
|
|
def WriteAssignment(self, file_name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_WriteAssignment(self, file_name)
|
|
|
|
def ReadAssignment(self, file_name: 'std::string const &') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_ReadAssignment(self, file_name)
|
|
|
|
def RestoreAssignment(self, solution: 'Assignment') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_RestoreAssignment(self, solution)
|
|
|
|
def ReadAssignmentFromRoutes(self, routes: 'std::vector< std::vector< int64 > > const &', ignore_inactive_indices: 'bool') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices)
|
|
|
|
def RoutesToAssignment(self, routes: 'std::vector< std::vector< int64 > > const &', ignore_inactive_indices: 'bool', close_routes: 'bool', assignment: 'Assignment') -> "bool":
|
|
return _pywrapcp.RoutingModel_RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment)
|
|
|
|
def AssignmentToRoutes(self, assignment: 'Assignment', routes: 'std::vector< std::vector< int64 > > *const') -> "void":
|
|
return _pywrapcp.RoutingModel_AssignmentToRoutes(self, assignment, routes)
|
|
|
|
def CompactAssignment(self, assignment: 'Assignment') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_CompactAssignment(self, assignment)
|
|
|
|
def CompactAndCheckAssignment(self, assignment: 'Assignment') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_CompactAndCheckAssignment(self, assignment)
|
|
|
|
def AddToAssignment(self, var: 'IntVar') -> "void":
|
|
return _pywrapcp.RoutingModel_AddToAssignment(self, var)
|
|
|
|
def AddIntervalToAssignment(self, interval: 'IntervalVar') -> "void":
|
|
return _pywrapcp.RoutingModel_AddIntervalToAssignment(self, interval)
|
|
|
|
def PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment: 'Assignment', duration_limit: 'absl::Duration') -> "operations_research::Assignment const *":
|
|
return _pywrapcp.RoutingModel_PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit)
|
|
|
|
def AddLocalSearchFilter(self, filter: 'LocalSearchFilter') -> "void":
|
|
return _pywrapcp.RoutingModel_AddLocalSearchFilter(self, filter)
|
|
|
|
def Start(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingModel_Start(self, vehicle)
|
|
|
|
def End(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingModel_End(self, vehicle)
|
|
|
|
def IsStart(self, index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingModel_IsStart(self, index)
|
|
|
|
def IsEnd(self, index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingModel_IsEnd(self, index)
|
|
|
|
def VehicleIndex(self, index: 'int') -> "int":
|
|
return _pywrapcp.RoutingModel_VehicleIndex(self, index)
|
|
|
|
def Next(self, assignment: 'Assignment', index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_Next(self, assignment, index)
|
|
|
|
def IsVehicleUsed(self, assignment: 'Assignment', vehicle: 'int') -> "bool":
|
|
return _pywrapcp.RoutingModel_IsVehicleUsed(self, assignment, vehicle)
|
|
|
|
def NextVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_NextVar(self, index)
|
|
|
|
def ActiveVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_ActiveVar(self, index)
|
|
|
|
def VehicleCostsConsideredVar(self, vehicle: 'int') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_VehicleCostsConsideredVar(self, vehicle)
|
|
|
|
def VehicleVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_VehicleVar(self, index)
|
|
|
|
def CostVar(self) -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_CostVar(self)
|
|
|
|
def GetArcCostForVehicle(self, from_index: 'int64', to_index: 'int64', vehicle: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetArcCostForVehicle(self, from_index, to_index, vehicle)
|
|
|
|
def CostsAreHomogeneousAcrossVehicles(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_CostsAreHomogeneousAcrossVehicles(self)
|
|
|
|
def GetHomogeneousCost(self, from_index: 'int64', to_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetHomogeneousCost(self, from_index, to_index)
|
|
|
|
def GetArcCostForFirstSolution(self, from_index: 'int64', to_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetArcCostForFirstSolution(self, from_index, to_index)
|
|
|
|
def GetArcCostForClass(self, from_index: 'int64', to_index: 'int64', cost_class_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetArcCostForClass(self, from_index, to_index, cost_class_index)
|
|
|
|
def GetCostClassIndexOfVehicle(self, vehicle: 'int64') -> "operations_research::RoutingModel::CostClassIndex":
|
|
return _pywrapcp.RoutingModel_GetCostClassIndexOfVehicle(self, vehicle)
|
|
|
|
def HasVehicleWithCostClassIndex(self, cost_class_index: 'operations_research::RoutingModel::CostClassIndex') -> "bool":
|
|
return _pywrapcp.RoutingModel_HasVehicleWithCostClassIndex(self, cost_class_index)
|
|
|
|
def GetCostClassesCount(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetCostClassesCount(self)
|
|
|
|
def GetNonZeroCostClassesCount(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetNonZeroCostClassesCount(self)
|
|
|
|
def GetVehicleClassIndexOfVehicle(self, vehicle: 'int64') -> "operations_research::RoutingModel::VehicleClassIndex":
|
|
return _pywrapcp.RoutingModel_GetVehicleClassIndexOfVehicle(self, vehicle)
|
|
|
|
def GetVehicleClassesCount(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetVehicleClassesCount(self)
|
|
|
|
def GetSameVehicleIndicesOfIndex(self, node: 'int') -> "std::vector< int > const &":
|
|
return _pywrapcp.RoutingModel_GetSameVehicleIndicesOfIndex(self, node)
|
|
|
|
def ArcIsMoreConstrainedThanArc(self, _from: 'int64', to1: 'int64', to2: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingModel_ArcIsMoreConstrainedThanArc(self, _from, to1, to2)
|
|
|
|
def DebugOutputAssignment(self, solution_assignment: 'Assignment', dimension_to_print: 'std::string const &') -> "std::string":
|
|
return _pywrapcp.RoutingModel_DebugOutputAssignment(self, solution_assignment, dimension_to_print)
|
|
|
|
def solver(self) -> "operations_research::Solver *":
|
|
return _pywrapcp.RoutingModel_solver(self)
|
|
|
|
def CheckLimit(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_CheckLimit(self)
|
|
|
|
def RemainingTime(self) -> "absl::Duration":
|
|
return _pywrapcp.RoutingModel_RemainingTime(self)
|
|
|
|
def nodes(self) -> "int":
|
|
return _pywrapcp.RoutingModel_nodes(self)
|
|
|
|
def vehicles(self) -> "int":
|
|
return _pywrapcp.RoutingModel_vehicles(self)
|
|
|
|
def Size(self) -> "int64":
|
|
return _pywrapcp.RoutingModel_Size(self)
|
|
|
|
def GetNumberOfDecisionsInFirstSolution(self, search_parameters: 'operations_research::RoutingSearchParameters const &') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetNumberOfDecisionsInFirstSolution(self, search_parameters)
|
|
|
|
def GetNumberOfRejectsInFirstSolution(self, search_parameters: 'operations_research::RoutingSearchParameters const &') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetNumberOfRejectsInFirstSolution(self, search_parameters)
|
|
|
|
def IsMatchingModel(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_IsMatchingModel(self)
|
|
|
|
def MakeGuidedSlackFinalizer(self, dimension: 'RoutingDimension', initializer: 'std::function< int64 (int64) >') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.RoutingModel_MakeGuidedSlackFinalizer(self, dimension, initializer)
|
|
|
|
def MakeSelfDependentDimensionFinalizer(self, dimension: 'RoutingDimension') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.RoutingModel_MakeSelfDependentDimensionFinalizer(self, dimension)
|
|
|
|
def AddMatrixDimension(self, *args) -> "void":
|
|
return _pywrapcp.RoutingModel_AddMatrixDimension(self, *args)</code></pre>
|
|
</details>
|
|
<h3>Class variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.RoutingModel.PICKUP_AND_DELIVERY_FIFO"><code class="name">var <span class="ident">PICKUP_AND_DELIVERY_FIFO</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.PICKUP_AND_DELIVERY_LIFO"><code class="name">var <span class="ident">PICKUP_AND_DELIVERY_LIFO</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.PICKUP_AND_DELIVERY_NO_ORDER"><code class="name">var <span class="ident">PICKUP_AND_DELIVERY_NO_ORDER</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.ROUTING_FAIL"><code class="name">var <span class="ident">ROUTING_FAIL</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.ROUTING_FAIL_TIMEOUT"><code class="name">var <span class="ident">ROUTING_FAIL_TIMEOUT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.ROUTING_INVALID"><code class="name">var <span class="ident">ROUTING_INVALID</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.ROUTING_NOT_SOLVED"><code class="name">var <span class="ident">ROUTING_NOT_SOLVED</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.ROUTING_SUCCESS"><code class="name">var <span class="ident">ROUTING_SUCCESS</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.kNoDimension"><code class="name">var <span class="ident">kNoDimension</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.kNoDisjunction"><code class="name">var <span class="ident">kNoDisjunction</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.kNoPenalty"><code class="name">var <span class="ident">kNoPenalty</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
</dl>
|
|
<h3>Instance variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.RoutingModel.thisown"><code class="name">var <span class="ident">thisown</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The membership flag</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.RoutingModel.ActiveVar"><code class="name flex">
|
|
<span>def <span class="ident">ActiveVar</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ActiveVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_ActiveVar(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddAtSolutionCallback"><code class="name flex">
|
|
<span>def <span class="ident">AddAtSolutionCallback</span></span>(<span>self, callback)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddAtSolutionCallback(self, callback: 'std::function< void () >') -> "void":
|
|
return _pywrapcp.RoutingModel_AddAtSolutionCallback(self, callback)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddConstantDimension"><code class="name flex">
|
|
<span>def <span class="ident">AddConstantDimension</span></span>(<span>self, value, capacity, fix_start_cumul_to_zero, name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddConstantDimension(self, value: 'int64', capacity: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddConstantDimensionWithSlack"><code class="name flex">
|
|
<span>def <span class="ident">AddConstantDimensionWithSlack</span></span>(<span>self, value, capacity, slack_max, fix_start_cumul_to_zero, name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddConstantDimensionWithSlack(self, value: 'int64', capacity: 'int64', slack_max: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddDimension"><code class="name flex">
|
|
<span>def <span class="ident">AddDimension</span></span>(<span>self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddDimension(self, evaluator_index: 'int', slack_max: 'int64', capacity: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddDimensionWithVehicleCapacity"><code class="name flex">
|
|
<span>def <span class="ident">AddDimensionWithVehicleCapacity</span></span>(<span>self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddDimensionWithVehicleCapacity(self, evaluator_index: 'int', slack_max: 'int64', vehicle_capacities: 'std::vector< int64 >', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddDimensionWithVehicleTransitAndCapacity"><code class="name flex">
|
|
<span>def <span class="ident">AddDimensionWithVehicleTransitAndCapacity</span></span>(<span>self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices: 'std::vector< int > const &', slack_max: 'int64', vehicle_capacities: 'std::vector< int64 >', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddDimensionWithVehicleTransits"><code class="name flex">
|
|
<span>def <span class="ident">AddDimensionWithVehicleTransits</span></span>(<span>self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddDimensionWithVehicleTransits(self, evaluator_indices: 'std::vector< int > const &', slack_max: 'int64', capacity: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddDisjunction"><code class="name flex">
|
|
<span>def <span class="ident">AddDisjunction</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddDisjunction(self, *args) -> "operations_research::RoutingModel::DisjunctionIndex":
|
|
return _pywrapcp.RoutingModel_AddDisjunction(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddHardTypeIncompatibility"><code class="name flex">
|
|
<span>def <span class="ident">AddHardTypeIncompatibility</span></span>(<span>self, type1, type2)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddHardTypeIncompatibility(self, type1: 'int', type2: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_AddHardTypeIncompatibility(self, type1, type2)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddIntervalToAssignment"><code class="name flex">
|
|
<span>def <span class="ident">AddIntervalToAssignment</span></span>(<span>self, interval)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddIntervalToAssignment(self, interval: 'IntervalVar') -> "void":
|
|
return _pywrapcp.RoutingModel_AddIntervalToAssignment(self, interval)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddLocalSearchFilter"><code class="name flex">
|
|
<span>def <span class="ident">AddLocalSearchFilter</span></span>(<span>self, filter)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddLocalSearchFilter(self, filter: 'LocalSearchFilter') -> "void":
|
|
return _pywrapcp.RoutingModel_AddLocalSearchFilter(self, filter)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddLocalSearchOperator"><code class="name flex">
|
|
<span>def <span class="ident">AddLocalSearchOperator</span></span>(<span>self, ls_operator)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddLocalSearchOperator(self, ls_operator: 'LocalSearchOperator') -> "void":
|
|
return _pywrapcp.RoutingModel_AddLocalSearchOperator(self, ls_operator)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddMatrixDimension"><code class="name flex">
|
|
<span>def <span class="ident">AddMatrixDimension</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddMatrixDimension(self, *args) -> "void":
|
|
return _pywrapcp.RoutingModel_AddMatrixDimension(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddPickupAndDelivery"><code class="name flex">
|
|
<span>def <span class="ident">AddPickupAndDelivery</span></span>(<span>self, pickup, delivery)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddPickupAndDelivery(self, pickup: 'int64', delivery: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_AddPickupAndDelivery(self, pickup, delivery)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddPickupAndDeliverySets"><code class="name flex">
|
|
<span>def <span class="ident">AddPickupAndDeliverySets</span></span>(<span>self, pickup_disjunction, delivery_disjunction)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddPickupAndDeliverySets(self, pickup_disjunction: 'operations_research::RoutingModel::DisjunctionIndex', delivery_disjunction: 'operations_research::RoutingModel::DisjunctionIndex') -> "void":
|
|
return _pywrapcp.RoutingModel_AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddSameVehicleRequiredTypeAlternatives"><code class="name flex">
|
|
<span>def <span class="ident">AddSameVehicleRequiredTypeAlternatives</span></span>(<span>self, dependent_type, required_type_alternatives)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddSameVehicleRequiredTypeAlternatives(self, dependent_type: 'int', required_type_alternatives: 'absl::flat_hash_set< int >') -> "void":
|
|
return _pywrapcp.RoutingModel_AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddSearchMonitor"><code class="name flex">
|
|
<span>def <span class="ident">AddSearchMonitor</span></span>(<span>self, monitor)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddSearchMonitor(self, monitor: 'SearchMonitor') -> "void":
|
|
return _pywrapcp.RoutingModel_AddSearchMonitor(self, monitor)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddSoftSameVehicleConstraint"><code class="name flex">
|
|
<span>def <span class="ident">AddSoftSameVehicleConstraint</span></span>(<span>self, indices, cost)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddSoftSameVehicleConstraint(self, indices: 'std::vector< int64 > const &', cost: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_AddSoftSameVehicleConstraint(self, indices, cost)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddTemporalRequiredTypeAlternatives"><code class="name flex">
|
|
<span>def <span class="ident">AddTemporalRequiredTypeAlternatives</span></span>(<span>self, dependent_type, required_type_alternatives)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddTemporalRequiredTypeAlternatives(self, dependent_type: 'int', required_type_alternatives: 'absl::flat_hash_set< int >') -> "void":
|
|
return _pywrapcp.RoutingModel_AddTemporalRequiredTypeAlternatives(self, dependent_type, required_type_alternatives)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddTemporalTypeIncompatibility"><code class="name flex">
|
|
<span>def <span class="ident">AddTemporalTypeIncompatibility</span></span>(<span>self, type1, type2)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddTemporalTypeIncompatibility(self, type1: 'int', type2: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_AddTemporalTypeIncompatibility(self, type1, type2)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddToAssignment"><code class="name flex">
|
|
<span>def <span class="ident">AddToAssignment</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddToAssignment(self, var: 'IntVar') -> "void":
|
|
return _pywrapcp.RoutingModel_AddToAssignment(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddVariableMaximizedByFinalizer"><code class="name flex">
|
|
<span>def <span class="ident">AddVariableMaximizedByFinalizer</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddVariableMaximizedByFinalizer(self, var: 'IntVar') -> "void":
|
|
return _pywrapcp.RoutingModel_AddVariableMaximizedByFinalizer(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddVariableMinimizedByFinalizer"><code class="name flex">
|
|
<span>def <span class="ident">AddVariableMinimizedByFinalizer</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddVariableMinimizedByFinalizer(self, var: 'IntVar') -> "void":
|
|
return _pywrapcp.RoutingModel_AddVariableMinimizedByFinalizer(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddVariableTargetToFinalizer"><code class="name flex">
|
|
<span>def <span class="ident">AddVariableTargetToFinalizer</span></span>(<span>self, var, target)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddVariableTargetToFinalizer(self, var: 'IntVar', target: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_AddVariableTargetToFinalizer(self, var, target)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddVectorDimension"><code class="name flex">
|
|
<span>def <span class="ident">AddVectorDimension</span></span>(<span>self, values, capacity, fix_start_cumul_to_zero, name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddVectorDimension(self, values: 'std::vector< int64 >', capacity: 'int64', fix_start_cumul_to_zero: 'bool', name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AddWeightedVariableMinimizedByFinalizer"><code class="name flex">
|
|
<span>def <span class="ident">AddWeightedVariableMinimizedByFinalizer</span></span>(<span>self, var, cost)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddWeightedVariableMinimizedByFinalizer(self, var: 'IntVar', cost: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_AddWeightedVariableMinimizedByFinalizer(self, var, cost)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.ApplyLocks"><code class="name flex">
|
|
<span>def <span class="ident">ApplyLocks</span></span>(<span>self, locks)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ApplyLocks(self, locks: 'std::vector< int64 > const &') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_ApplyLocks(self, locks)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.ApplyLocksToAllVehicles"><code class="name flex">
|
|
<span>def <span class="ident">ApplyLocksToAllVehicles</span></span>(<span>self, locks, close_routes)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ApplyLocksToAllVehicles(self, locks: 'std::vector< std::vector< int64 > > const &', close_routes: 'bool') -> "bool":
|
|
return _pywrapcp.RoutingModel_ApplyLocksToAllVehicles(self, locks, close_routes)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.ArcIsMoreConstrainedThanArc"><code class="name flex">
|
|
<span>def <span class="ident">ArcIsMoreConstrainedThanArc</span></span>(<span>self, _from, to1, to2)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ArcIsMoreConstrainedThanArc(self, _from: 'int64', to1: 'int64', to2: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingModel_ArcIsMoreConstrainedThanArc(self, _from, to1, to2)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AreEmptyRouteCostsConsideredForVehicle"><code class="name flex">
|
|
<span>def <span class="ident">AreEmptyRouteCostsConsideredForVehicle</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AreEmptyRouteCostsConsideredForVehicle(self, vehicle: 'int') -> "bool":
|
|
return _pywrapcp.RoutingModel_AreEmptyRouteCostsConsideredForVehicle(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.AssignmentToRoutes"><code class="name flex">
|
|
<span>def <span class="ident">AssignmentToRoutes</span></span>(<span>self, assignment, routes)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AssignmentToRoutes(self, assignment: 'Assignment', routes: 'std::vector< std::vector< int64 > > *const') -> "void":
|
|
return _pywrapcp.RoutingModel_AssignmentToRoutes(self, assignment, routes)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.CheckLimit"><code class="name flex">
|
|
<span>def <span class="ident">CheckLimit</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CheckLimit(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_CheckLimit(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.CloseModel"><code class="name flex">
|
|
<span>def <span class="ident">CloseModel</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CloseModel(self) -> "void":
|
|
return _pywrapcp.RoutingModel_CloseModel(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.CloseModelWithParameters"><code class="name flex">
|
|
<span>def <span class="ident">CloseModelWithParameters</span></span>(<span>self, search_parameters)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CloseModelWithParameters(self, search_parameters: 'operations_research::RoutingSearchParameters const &') -> "void":
|
|
return _pywrapcp.RoutingModel_CloseModelWithParameters(self, search_parameters)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.CloseVisitTypes"><code class="name flex">
|
|
<span>def <span class="ident">CloseVisitTypes</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CloseVisitTypes(self) -> "void":
|
|
return _pywrapcp.RoutingModel_CloseVisitTypes(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.CompactAndCheckAssignment"><code class="name flex">
|
|
<span>def <span class="ident">CompactAndCheckAssignment</span></span>(<span>self, assignment)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CompactAndCheckAssignment(self, assignment: 'Assignment') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_CompactAndCheckAssignment(self, assignment)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.CompactAssignment"><code class="name flex">
|
|
<span>def <span class="ident">CompactAssignment</span></span>(<span>self, assignment)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CompactAssignment(self, assignment: 'Assignment') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_CompactAssignment(self, assignment)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.ComputeLowerBound"><code class="name flex">
|
|
<span>def <span class="ident">ComputeLowerBound</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ComputeLowerBound(self) -> "int64":
|
|
return _pywrapcp.RoutingModel_ComputeLowerBound(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.ConsiderEmptyRouteCostsForVehicle"><code class="name flex">
|
|
<span>def <span class="ident">ConsiderEmptyRouteCostsForVehicle</span></span>(<span>self, consider_costs, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ConsiderEmptyRouteCostsForVehicle(self, consider_costs: 'bool', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_ConsiderEmptyRouteCostsForVehicle(self, consider_costs, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.CostVar"><code class="name flex">
|
|
<span>def <span class="ident">CostVar</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CostVar(self) -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_CostVar(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.CostsAreHomogeneousAcrossVehicles"><code class="name flex">
|
|
<span>def <span class="ident">CostsAreHomogeneousAcrossVehicles</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CostsAreHomogeneousAcrossVehicles(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_CostsAreHomogeneousAcrossVehicles(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.DebugOutputAssignment"><code class="name flex">
|
|
<span>def <span class="ident">DebugOutputAssignment</span></span>(<span>self, solution_assignment, dimension_to_print)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugOutputAssignment(self, solution_assignment: 'Assignment', dimension_to_print: 'std::string const &') -> "std::string":
|
|
return _pywrapcp.RoutingModel_DebugOutputAssignment(self, solution_assignment, dimension_to_print)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.End"><code class="name flex">
|
|
<span>def <span class="ident">End</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def End(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingModel_End(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetAllDimensionNames"><code class="name flex">
|
|
<span>def <span class="ident">GetAllDimensionNames</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetAllDimensionNames(self) -> "std::vector< ::std::string >":
|
|
return _pywrapcp.RoutingModel_GetAllDimensionNames(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetAmortizedLinearCostFactorOfVehicles"><code class="name flex">
|
|
<span>def <span class="ident">GetAmortizedLinearCostFactorOfVehicles</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetAmortizedLinearCostFactorOfVehicles(self) -> "std::vector< int64 > const &":
|
|
return _pywrapcp.RoutingModel_GetAmortizedLinearCostFactorOfVehicles(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetAmortizedQuadraticCostFactorOfVehicles"><code class="name flex">
|
|
<span>def <span class="ident">GetAmortizedQuadraticCostFactorOfVehicles</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetAmortizedQuadraticCostFactorOfVehicles(self) -> "std::vector< int64 > const &":
|
|
return _pywrapcp.RoutingModel_GetAmortizedQuadraticCostFactorOfVehicles(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetArcCostForClass"><code class="name flex">
|
|
<span>def <span class="ident">GetArcCostForClass</span></span>(<span>self, from_index, to_index, cost_class_index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetArcCostForClass(self, from_index: 'int64', to_index: 'int64', cost_class_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetArcCostForClass(self, from_index, to_index, cost_class_index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetArcCostForFirstSolution"><code class="name flex">
|
|
<span>def <span class="ident">GetArcCostForFirstSolution</span></span>(<span>self, from_index, to_index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetArcCostForFirstSolution(self, from_index: 'int64', to_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetArcCostForFirstSolution(self, from_index, to_index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetArcCostForVehicle"><code class="name flex">
|
|
<span>def <span class="ident">GetArcCostForVehicle</span></span>(<span>self, from_index, to_index, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetArcCostForVehicle(self, from_index: 'int64', to_index: 'int64', vehicle: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetArcCostForVehicle(self, from_index, to_index, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetCostClassIndexOfVehicle"><code class="name flex">
|
|
<span>def <span class="ident">GetCostClassIndexOfVehicle</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetCostClassIndexOfVehicle(self, vehicle: 'int64') -> "operations_research::RoutingModel::CostClassIndex":
|
|
return _pywrapcp.RoutingModel_GetCostClassIndexOfVehicle(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetCostClassesCount"><code class="name flex">
|
|
<span>def <span class="ident">GetCostClassesCount</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetCostClassesCount(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetCostClassesCount(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetDeliveryIndexPairs"><code class="name flex">
|
|
<span>def <span class="ident">GetDeliveryIndexPairs</span></span>(<span>self, node_index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetDeliveryIndexPairs(self, node_index: 'int64') -> "std::vector< std::pair< int,int > > const &":
|
|
return _pywrapcp.RoutingModel_GetDeliveryIndexPairs(self, node_index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetDepot"><code class="name flex">
|
|
<span>def <span class="ident">GetDepot</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetDepot(self) -> "int64":
|
|
return _pywrapcp.RoutingModel_GetDepot(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetDimensionOrDie"><code class="name flex">
|
|
<span>def <span class="ident">GetDimensionOrDie</span></span>(<span>self, dimension_name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetDimensionOrDie(self, dimension_name: 'std::string const &') -> "operations_research::RoutingDimension const &":
|
|
return _pywrapcp.RoutingModel_GetDimensionOrDie(self, dimension_name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetDimensions"><code class="name flex">
|
|
<span>def <span class="ident">GetDimensions</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetDimensions(self) -> "std::vector< operations_research::RoutingDimension * > const &":
|
|
return _pywrapcp.RoutingModel_GetDimensions(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetDimensionsForGlobalCumulOptimizers"><code class="name flex">
|
|
<span>def <span class="ident">GetDimensionsForGlobalCumulOptimizers</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetDimensionsForGlobalCumulOptimizers(self) -> "std::vector< operations_research::RoutingDimension * > const &":
|
|
return _pywrapcp.RoutingModel_GetDimensionsForGlobalCumulOptimizers(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetDimensionsForLocalCumulOptimizers"><code class="name flex">
|
|
<span>def <span class="ident">GetDimensionsForLocalCumulOptimizers</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetDimensionsForLocalCumulOptimizers(self) -> "std::vector< operations_research::RoutingDimension * > const &":
|
|
return _pywrapcp.RoutingModel_GetDimensionsForLocalCumulOptimizers(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetDimensionsWithSoftOrSpanCosts"><code class="name flex">
|
|
<span>def <span class="ident">GetDimensionsWithSoftOrSpanCosts</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetDimensionsWithSoftOrSpanCosts(self) -> "std::vector< operations_research::RoutingDimension * >":
|
|
return _pywrapcp.RoutingModel_GetDimensionsWithSoftOrSpanCosts(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetDisjunctionIndices"><code class="name flex">
|
|
<span>def <span class="ident">GetDisjunctionIndices</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetDisjunctionIndices(self, index: 'int64') -> "std::vector< operations_research::RoutingModel::DisjunctionIndex > const &":
|
|
return _pywrapcp.RoutingModel_GetDisjunctionIndices(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetDisjunctionMaxCardinality"><code class="name flex">
|
|
<span>def <span class="ident">GetDisjunctionMaxCardinality</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetDisjunctionMaxCardinality(self, index: 'operations_research::RoutingModel::DisjunctionIndex') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetDisjunctionMaxCardinality(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetDisjunctionPenalty"><code class="name flex">
|
|
<span>def <span class="ident">GetDisjunctionPenalty</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetDisjunctionPenalty(self, index: 'operations_research::RoutingModel::DisjunctionIndex') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetDisjunctionPenalty(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetFixedCostOfVehicle"><code class="name flex">
|
|
<span>def <span class="ident">GetFixedCostOfVehicle</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetFixedCostOfVehicle(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetFixedCostOfVehicle(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetHardTypeIncompatibilitiesOfType"><code class="name flex">
|
|
<span>def <span class="ident">GetHardTypeIncompatibilitiesOfType</span></span>(<span>self, type)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetHardTypeIncompatibilitiesOfType(self, type: 'int') -> "absl::flat_hash_set< int > const &":
|
|
return _pywrapcp.RoutingModel_GetHardTypeIncompatibilitiesOfType(self, type)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetHomogeneousCost"><code class="name flex">
|
|
<span>def <span class="ident">GetHomogeneousCost</span></span>(<span>self, from_index, to_index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetHomogeneousCost(self, from_index: 'int64', to_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetHomogeneousCost(self, from_index, to_index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetMutableDimension"><code class="name flex">
|
|
<span>def <span class="ident">GetMutableDimension</span></span>(<span>self, dimension_name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetMutableDimension(self, dimension_name: 'std::string const &') -> "operations_research::RoutingDimension *":
|
|
return _pywrapcp.RoutingModel_GetMutableDimension(self, dimension_name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetNonZeroCostClassesCount"><code class="name flex">
|
|
<span>def <span class="ident">GetNonZeroCostClassesCount</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetNonZeroCostClassesCount(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetNonZeroCostClassesCount(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetNumOfSingletonNodes"><code class="name flex">
|
|
<span>def <span class="ident">GetNumOfSingletonNodes</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetNumOfSingletonNodes(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetNumOfSingletonNodes(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetNumberOfDecisionsInFirstSolution"><code class="name flex">
|
|
<span>def <span class="ident">GetNumberOfDecisionsInFirstSolution</span></span>(<span>self, search_parameters)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetNumberOfDecisionsInFirstSolution(self, search_parameters: 'operations_research::RoutingSearchParameters const &') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetNumberOfDecisionsInFirstSolution(self, search_parameters)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetNumberOfDisjunctions"><code class="name flex">
|
|
<span>def <span class="ident">GetNumberOfDisjunctions</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetNumberOfDisjunctions(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetNumberOfDisjunctions(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetNumberOfRejectsInFirstSolution"><code class="name flex">
|
|
<span>def <span class="ident">GetNumberOfRejectsInFirstSolution</span></span>(<span>self, search_parameters)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetNumberOfRejectsInFirstSolution(self, search_parameters: 'operations_research::RoutingSearchParameters const &') -> "int64":
|
|
return _pywrapcp.RoutingModel_GetNumberOfRejectsInFirstSolution(self, search_parameters)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetNumberOfVisitTypes"><code class="name flex">
|
|
<span>def <span class="ident">GetNumberOfVisitTypes</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetNumberOfVisitTypes(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetNumberOfVisitTypes(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetPerfectBinaryDisjunctions"><code class="name flex">
|
|
<span>def <span class="ident">GetPerfectBinaryDisjunctions</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetPerfectBinaryDisjunctions(self) -> "std::vector< std::pair< int64,int64 > >":
|
|
return _pywrapcp.RoutingModel_GetPerfectBinaryDisjunctions(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetPickupAndDeliveryPolicyOfVehicle"><code class="name flex">
|
|
<span>def <span class="ident">GetPickupAndDeliveryPolicyOfVehicle</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetPickupAndDeliveryPolicyOfVehicle(self, vehicle: 'int') -> "operations_research::RoutingModel::PickupAndDeliveryPolicy":
|
|
return _pywrapcp.RoutingModel_GetPickupAndDeliveryPolicyOfVehicle(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetPickupIndexPairs"><code class="name flex">
|
|
<span>def <span class="ident">GetPickupIndexPairs</span></span>(<span>self, node_index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetPickupIndexPairs(self, node_index: 'int64') -> "std::vector< std::pair< int,int > > const &":
|
|
return _pywrapcp.RoutingModel_GetPickupIndexPairs(self, node_index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetPrimaryConstrainedDimension"><code class="name flex">
|
|
<span>def <span class="ident">GetPrimaryConstrainedDimension</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetPrimaryConstrainedDimension(self) -> "std::string const &":
|
|
return _pywrapcp.RoutingModel_GetPrimaryConstrainedDimension(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetSameVehicleIndicesOfIndex"><code class="name flex">
|
|
<span>def <span class="ident">GetSameVehicleIndicesOfIndex</span></span>(<span>self, node)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetSameVehicleIndicesOfIndex(self, node: 'int') -> "std::vector< int > const &":
|
|
return _pywrapcp.RoutingModel_GetSameVehicleIndicesOfIndex(self, node)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetSameVehicleRequiredTypeAlternativesOfType"><code class="name flex">
|
|
<span>def <span class="ident">GetSameVehicleRequiredTypeAlternativesOfType</span></span>(<span>self, type)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetSameVehicleRequiredTypeAlternativesOfType(self, type: 'int') -> "std::vector< absl::flat_hash_set< int > > const &":
|
|
return _pywrapcp.RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType(self, type)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetTemporalRequiredTypeAlternativesOfType"><code class="name flex">
|
|
<span>def <span class="ident">GetTemporalRequiredTypeAlternativesOfType</span></span>(<span>self, type)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetTemporalRequiredTypeAlternativesOfType(self, type: 'int') -> "std::vector< absl::flat_hash_set< int > > const &":
|
|
return _pywrapcp.RoutingModel_GetTemporalRequiredTypeAlternativesOfType(self, type)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetTemporalTypeIncompatibilitiesOfType"><code class="name flex">
|
|
<span>def <span class="ident">GetTemporalTypeIncompatibilitiesOfType</span></span>(<span>self, type)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetTemporalTypeIncompatibilitiesOfType(self, type: 'int') -> "absl::flat_hash_set< int > const &":
|
|
return _pywrapcp.RoutingModel_GetTemporalTypeIncompatibilitiesOfType(self, type)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetVehicleClassIndexOfVehicle"><code class="name flex">
|
|
<span>def <span class="ident">GetVehicleClassIndexOfVehicle</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetVehicleClassIndexOfVehicle(self, vehicle: 'int64') -> "operations_research::RoutingModel::VehicleClassIndex":
|
|
return _pywrapcp.RoutingModel_GetVehicleClassIndexOfVehicle(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetVehicleClassesCount"><code class="name flex">
|
|
<span>def <span class="ident">GetVehicleClassesCount</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetVehicleClassesCount(self) -> "int":
|
|
return _pywrapcp.RoutingModel_GetVehicleClassesCount(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.GetVisitType"><code class="name flex">
|
|
<span>def <span class="ident">GetVisitType</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GetVisitType(self, index: 'int64') -> "int":
|
|
return _pywrapcp.RoutingModel_GetVisitType(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.HasDimension"><code class="name flex">
|
|
<span>def <span class="ident">HasDimension</span></span>(<span>self, dimension_name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HasDimension(self, dimension_name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_HasDimension(self, dimension_name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.HasHardTypeIncompatibilities"><code class="name flex">
|
|
<span>def <span class="ident">HasHardTypeIncompatibilities</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HasHardTypeIncompatibilities(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasHardTypeIncompatibilities(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.HasSameVehicleTypeRequirements"><code class="name flex">
|
|
<span>def <span class="ident">HasSameVehicleTypeRequirements</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HasSameVehicleTypeRequirements(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasSameVehicleTypeRequirements(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.HasTemporalTypeIncompatibilities"><code class="name flex">
|
|
<span>def <span class="ident">HasTemporalTypeIncompatibilities</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HasTemporalTypeIncompatibilities(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasTemporalTypeIncompatibilities(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.HasTemporalTypeRequirements"><code class="name flex">
|
|
<span>def <span class="ident">HasTemporalTypeRequirements</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HasTemporalTypeRequirements(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasTemporalTypeRequirements(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.HasTypeRegulations"><code class="name flex">
|
|
<span>def <span class="ident">HasTypeRegulations</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HasTypeRegulations(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_HasTypeRegulations(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.HasVehicleWithCostClassIndex"><code class="name flex">
|
|
<span>def <span class="ident">HasVehicleWithCostClassIndex</span></span>(<span>self, cost_class_index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def HasVehicleWithCostClassIndex(self, cost_class_index: 'operations_research::RoutingModel::CostClassIndex') -> "bool":
|
|
return _pywrapcp.RoutingModel_HasVehicleWithCostClassIndex(self, cost_class_index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.IgnoreDisjunctionsAlreadyForcedToZero"><code class="name flex">
|
|
<span>def <span class="ident">IgnoreDisjunctionsAlreadyForcedToZero</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IgnoreDisjunctionsAlreadyForcedToZero(self) -> "void":
|
|
return _pywrapcp.RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.IsEnd"><code class="name flex">
|
|
<span>def <span class="ident">IsEnd</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsEnd(self, index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingModel_IsEnd(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.IsMatchingModel"><code class="name flex">
|
|
<span>def <span class="ident">IsMatchingModel</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsMatchingModel(self) -> "bool":
|
|
return _pywrapcp.RoutingModel_IsMatchingModel(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.IsStart"><code class="name flex">
|
|
<span>def <span class="ident">IsStart</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsStart(self, index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingModel_IsStart(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.IsVehicleAllowedForIndex"><code class="name flex">
|
|
<span>def <span class="ident">IsVehicleAllowedForIndex</span></span>(<span>self, vehicle, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsVehicleAllowedForIndex(self, vehicle: 'int', index: 'int64') -> "bool":
|
|
return _pywrapcp.RoutingModel_IsVehicleAllowedForIndex(self, vehicle, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.IsVehicleUsed"><code class="name flex">
|
|
<span>def <span class="ident">IsVehicleUsed</span></span>(<span>self, assignment, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsVehicleUsed(self, assignment: 'Assignment', vehicle: 'int') -> "bool":
|
|
return _pywrapcp.RoutingModel_IsVehicleUsed(self, assignment, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.MakeGuidedSlackFinalizer"><code class="name flex">
|
|
<span>def <span class="ident">MakeGuidedSlackFinalizer</span></span>(<span>self, dimension, initializer)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MakeGuidedSlackFinalizer(self, dimension: 'RoutingDimension', initializer: 'std::function< int64 (int64) >') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.RoutingModel_MakeGuidedSlackFinalizer(self, dimension, initializer)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.MakePathSpansAndTotalSlacks"><code class="name flex">
|
|
<span>def <span class="ident">MakePathSpansAndTotalSlacks</span></span>(<span>self, dimension, spans, total_slacks)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MakePathSpansAndTotalSlacks(self, dimension: 'RoutingDimension', spans: 'std::vector< operations_research::IntVar * >', total_slacks: 'std::vector< operations_research::IntVar * >') -> "operations_research::Constraint *":
|
|
return _pywrapcp.RoutingModel_MakePathSpansAndTotalSlacks(self, dimension, spans, total_slacks)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.MakeSelfDependentDimensionFinalizer"><code class="name flex">
|
|
<span>def <span class="ident">MakeSelfDependentDimensionFinalizer</span></span>(<span>self, dimension)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MakeSelfDependentDimensionFinalizer(self, dimension: 'RoutingDimension') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.RoutingModel_MakeSelfDependentDimensionFinalizer(self, dimension)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.MutablePreAssignment"><code class="name flex">
|
|
<span>def <span class="ident">MutablePreAssignment</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MutablePreAssignment(self) -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_MutablePreAssignment(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.Next"><code class="name flex">
|
|
<span>def <span class="ident">Next</span></span>(<span>self, assignment, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Next(self, assignment: 'Assignment', index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_Next(self, assignment, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.NextVar"><code class="name flex">
|
|
<span>def <span class="ident">NextVar</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NextVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_NextVar(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.PackCumulsOfOptimizerDimensionsFromAssignment"><code class="name flex">
|
|
<span>def <span class="ident">PackCumulsOfOptimizerDimensionsFromAssignment</span></span>(<span>self, original_assignment, duration_limit)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment: 'Assignment', duration_limit: 'absl::Duration') -> "operations_research::Assignment const *":
|
|
return _pywrapcp.RoutingModel_PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.PreAssignment"><code class="name flex">
|
|
<span>def <span class="ident">PreAssignment</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def PreAssignment(self) -> "operations_research::Assignment const *const":
|
|
return _pywrapcp.RoutingModel_PreAssignment(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.ReadAssignment"><code class="name flex">
|
|
<span>def <span class="ident">ReadAssignment</span></span>(<span>self, file_name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ReadAssignment(self, file_name: 'std::string const &') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_ReadAssignment(self, file_name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.ReadAssignmentFromRoutes"><code class="name flex">
|
|
<span>def <span class="ident">ReadAssignmentFromRoutes</span></span>(<span>self, routes, ignore_inactive_indices)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ReadAssignmentFromRoutes(self, routes: 'std::vector< std::vector< int64 > > const &', ignore_inactive_indices: 'bool') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.RegisterPositiveTransitCallback"><code class="name flex">
|
|
<span>def <span class="ident">RegisterPositiveTransitCallback</span></span>(<span>self, callback)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RegisterPositiveTransitCallback(self, callback: 'operations_research::RoutingModel::TransitCallback2') -> "int":
|
|
return _pywrapcp.RoutingModel_RegisterPositiveTransitCallback(self, callback)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.RegisterTransitCallback"><code class="name flex">
|
|
<span>def <span class="ident">RegisterTransitCallback</span></span>(<span>self, callback)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RegisterTransitCallback(self, callback: 'operations_research::RoutingModel::TransitCallback2') -> "int":
|
|
return _pywrapcp.RoutingModel_RegisterTransitCallback(self, callback)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.RegisterUnaryTransitCallback"><code class="name flex">
|
|
<span>def <span class="ident">RegisterUnaryTransitCallback</span></span>(<span>self, callback)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RegisterUnaryTransitCallback(self, callback: 'operations_research::RoutingModel::TransitCallback1') -> "int":
|
|
return _pywrapcp.RoutingModel_RegisterUnaryTransitCallback(self, callback)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.RemainingTime"><code class="name flex">
|
|
<span>def <span class="ident">RemainingTime</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RemainingTime(self) -> "absl::Duration":
|
|
return _pywrapcp.RoutingModel_RemainingTime(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.RestoreAssignment"><code class="name flex">
|
|
<span>def <span class="ident">RestoreAssignment</span></span>(<span>self, solution)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RestoreAssignment(self, solution: 'Assignment') -> "operations_research::Assignment *":
|
|
return _pywrapcp.RoutingModel_RestoreAssignment(self, solution)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.RoutesToAssignment"><code class="name flex">
|
|
<span>def <span class="ident">RoutesToAssignment</span></span>(<span>self, routes, ignore_inactive_indices, close_routes, assignment)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RoutesToAssignment(self, routes: 'std::vector< std::vector< int64 > > const &', ignore_inactive_indices: 'bool', close_routes: 'bool', assignment: 'Assignment') -> "bool":
|
|
return _pywrapcp.RoutingModel_RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SetAllowedVehiclesForIndex"><code class="name flex">
|
|
<span>def <span class="ident">SetAllowedVehiclesForIndex</span></span>(<span>self, vehicles, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetAllowedVehiclesForIndex(self, vehicles: 'std::vector< int > const &', index: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_SetAllowedVehiclesForIndex(self, vehicles, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SetAmortizedCostFactorsOfAllVehicles"><code class="name flex">
|
|
<span>def <span class="ident">SetAmortizedCostFactorsOfAllVehicles</span></span>(<span>self, linear_cost_factor, quadratic_cost_factor)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor: 'int64', quadratic_cost_factor: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SetAmortizedCostFactorsOfVehicle"><code class="name flex">
|
|
<span>def <span class="ident">SetAmortizedCostFactorsOfVehicle</span></span>(<span>self, linear_cost_factor, quadratic_cost_factor, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor: 'int64', quadratic_cost_factor: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SetArcCostEvaluatorOfAllVehicles"><code class="name flex">
|
|
<span>def <span class="ident">SetArcCostEvaluatorOfAllVehicles</span></span>(<span>self, evaluator_index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetArcCostEvaluatorOfAllVehicles(self, evaluator_index: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfAllVehicles(self, evaluator_index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SetArcCostEvaluatorOfVehicle"><code class="name flex">
|
|
<span>def <span class="ident">SetArcCostEvaluatorOfVehicle</span></span>(<span>self, evaluator_index, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetArcCostEvaluatorOfVehicle(self, evaluator_index: 'int', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SetAssignmentFromOtherModelAssignment"><code class="name flex">
|
|
<span>def <span class="ident">SetAssignmentFromOtherModelAssignment</span></span>(<span>self, target_assignment, source_model, source_assignment)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetAssignmentFromOtherModelAssignment(self, target_assignment: 'Assignment', source_model: 'RoutingModel', source_assignment: 'Assignment') -> "void":
|
|
return _pywrapcp.RoutingModel_SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SetFirstSolutionEvaluator"><code class="name flex">
|
|
<span>def <span class="ident">SetFirstSolutionEvaluator</span></span>(<span>self, evaluator)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetFirstSolutionEvaluator(self, evaluator: 'operations_research::Solver::IndexEvaluator2') -> "void":
|
|
return _pywrapcp.RoutingModel_SetFirstSolutionEvaluator(self, evaluator)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SetFixedCostOfAllVehicles"><code class="name flex">
|
|
<span>def <span class="ident">SetFixedCostOfAllVehicles</span></span>(<span>self, cost)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetFixedCostOfAllVehicles(self, cost: 'int64') -> "void":
|
|
return _pywrapcp.RoutingModel_SetFixedCostOfAllVehicles(self, cost)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SetFixedCostOfVehicle"><code class="name flex">
|
|
<span>def <span class="ident">SetFixedCostOfVehicle</span></span>(<span>self, cost, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetFixedCostOfVehicle(self, cost: 'int64', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetFixedCostOfVehicle(self, cost, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SetPickupAndDeliveryPolicyOfAllVehicles"><code class="name flex">
|
|
<span>def <span class="ident">SetPickupAndDeliveryPolicyOfAllVehicles</span></span>(<span>self, policy)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetPickupAndDeliveryPolicyOfAllVehicles(self, policy: 'operations_research::RoutingModel::PickupAndDeliveryPolicy') -> "void":
|
|
return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles(self, policy)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SetPickupAndDeliveryPolicyOfVehicle"><code class="name flex">
|
|
<span>def <span class="ident">SetPickupAndDeliveryPolicyOfVehicle</span></span>(<span>self, policy, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetPickupAndDeliveryPolicyOfVehicle(self, policy: 'operations_research::RoutingModel::PickupAndDeliveryPolicy', vehicle: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SetPrimaryConstrainedDimension"><code class="name flex">
|
|
<span>def <span class="ident">SetPrimaryConstrainedDimension</span></span>(<span>self, dimension_name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetPrimaryConstrainedDimension(self, dimension_name: 'std::string const &') -> "void":
|
|
return _pywrapcp.RoutingModel_SetPrimaryConstrainedDimension(self, dimension_name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SetVisitType"><code class="name flex">
|
|
<span>def <span class="ident">SetVisitType</span></span>(<span>self, index, type)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetVisitType(self, index: 'int64', type: 'int') -> "void":
|
|
return _pywrapcp.RoutingModel_SetVisitType(self, index, type)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.Size"><code class="name flex">
|
|
<span>def <span class="ident">Size</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Size(self) -> "int64":
|
|
return _pywrapcp.RoutingModel_Size(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.Solve"><code class="name flex">
|
|
<span>def <span class="ident">Solve</span></span>(<span>self, assignment=None)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Solve(self, assignment: 'Assignment'=None) -> "operations_research::Assignment const *":
|
|
return _pywrapcp.RoutingModel_Solve(self, assignment)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SolveFromAssignmentWithParameters"><code class="name flex">
|
|
<span>def <span class="ident">SolveFromAssignmentWithParameters</span></span>(<span>self, assignment, search_parameters, solutions=None)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SolveFromAssignmentWithParameters(self, assignment: 'Assignment', search_parameters: 'operations_research::RoutingSearchParameters const &', solutions: 'std::vector< operations_research::Assignment const * > *'=None) -> "operations_research::Assignment const *":
|
|
return _pywrapcp.RoutingModel_SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.SolveWithParameters"><code class="name flex">
|
|
<span>def <span class="ident">SolveWithParameters</span></span>(<span>self, search_parameters, solutions=None)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SolveWithParameters(self, search_parameters: 'operations_research::RoutingSearchParameters const &', solutions: 'std::vector< operations_research::Assignment const * > *'=None) -> "operations_research::Assignment const *":
|
|
return _pywrapcp.RoutingModel_SolveWithParameters(self, search_parameters, solutions)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.Start"><code class="name flex">
|
|
<span>def <span class="ident">Start</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Start(self, vehicle: 'int') -> "int64":
|
|
return _pywrapcp.RoutingModel_Start(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.TransitCallback"><code class="name flex">
|
|
<span>def <span class="ident">TransitCallback</span></span>(<span>self, callback_index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def TransitCallback(self, callback_index: 'int') -> "operations_research::RoutingModel::TransitCallback2 const &":
|
|
return _pywrapcp.RoutingModel_TransitCallback(self, callback_index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.UnaryTransitCallbackOrNull"><code class="name flex">
|
|
<span>def <span class="ident">UnaryTransitCallbackOrNull</span></span>(<span>self, callback_index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def UnaryTransitCallbackOrNull(self, callback_index: 'int') -> "operations_research::RoutingModel::TransitCallback1 const &":
|
|
return _pywrapcp.RoutingModel_UnaryTransitCallbackOrNull(self, callback_index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.UnperformedPenalty"><code class="name flex">
|
|
<span>def <span class="ident">UnperformedPenalty</span></span>(<span>self, var_index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def UnperformedPenalty(self, var_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_UnperformedPenalty(self, var_index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.UnperformedPenaltyOrValue"><code class="name flex">
|
|
<span>def <span class="ident">UnperformedPenaltyOrValue</span></span>(<span>self, default_value, var_index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def UnperformedPenaltyOrValue(self, default_value: 'int64', var_index: 'int64') -> "int64":
|
|
return _pywrapcp.RoutingModel_UnperformedPenaltyOrValue(self, default_value, var_index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.VehicleCostsConsideredVar"><code class="name flex">
|
|
<span>def <span class="ident">VehicleCostsConsideredVar</span></span>(<span>self, vehicle)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def VehicleCostsConsideredVar(self, vehicle: 'int') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_VehicleCostsConsideredVar(self, vehicle)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.VehicleIndex"><code class="name flex">
|
|
<span>def <span class="ident">VehicleIndex</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def VehicleIndex(self, index: 'int') -> "int":
|
|
return _pywrapcp.RoutingModel_VehicleIndex(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.VehicleVar"><code class="name flex">
|
|
<span>def <span class="ident">VehicleVar</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def VehicleVar(self, index: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.RoutingModel_VehicleVar(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.WriteAssignment"><code class="name flex">
|
|
<span>def <span class="ident">WriteAssignment</span></span>(<span>self, file_name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WriteAssignment(self, file_name: 'std::string const &') -> "bool":
|
|
return _pywrapcp.RoutingModel_WriteAssignment(self, file_name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.nodes"><code class="name flex">
|
|
<span>def <span class="ident">nodes</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def nodes(self) -> "int":
|
|
return _pywrapcp.RoutingModel_nodes(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.solver"><code class="name flex">
|
|
<span>def <span class="ident">solver</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def solver(self) -> "operations_research::Solver *":
|
|
return _pywrapcp.RoutingModel_solver(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.status"><code class="name flex">
|
|
<span>def <span class="ident">status</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def status(self) -> "operations_research::RoutingModel::Status":
|
|
return _pywrapcp.RoutingModel_status(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModel.vehicles"><code class="name flex">
|
|
<span>def <span class="ident">vehicles</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def vehicles(self) -> "int":
|
|
return _pywrapcp.RoutingModel_vehicles(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModelVisitor"><code class="flex name class">
|
|
<span>class <span class="ident">RoutingModelVisitor</span></span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A BaseObject is the root of all reversibly allocated objects. A DebugString method and the associated << operator are implemented as a convenience.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class RoutingModelVisitor(BaseObject):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self):
|
|
_pywrapcp.RoutingModelVisitor_swiginit(self, _pywrapcp.new_RoutingModelVisitor())
|
|
__swig_destroy__ = _pywrapcp.delete_RoutingModelVisitor</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Class variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.RoutingModelVisitor.kLightElement"><code class="name">var <span class="ident">kLightElement</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModelVisitor.kLightElement2"><code class="name">var <span class="ident">kLightElement2</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.RoutingModelVisitor.kRemoveValues"><code class="name">var <span class="ident">kRemoveValues</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.BaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.SavingsFilteredDecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">SavingsFilteredDecisionBuilder</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class SavingsFilteredDecisionBuilder(RoutingFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_SavingsFilteredDecisionBuilder
|
|
|
|
def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.SavingsFilteredDecisionBuilder_BuildSolution(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.SequentialSavingsFilteredDecisionBuilder" href="#pywrapcp.SequentialSavingsFilteredDecisionBuilder">SequentialSavingsFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.ParallelSavingsFilteredDecisionBuilder" href="#pywrapcp.ParallelSavingsFilteredDecisionBuilder">ParallelSavingsFilteredDecisionBuilder</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.SavingsFilteredDecisionBuilder.BuildSolution"><code class="name flex">
|
|
<span>def <span class="ident">BuildSolution</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BuildSolution(self) -> "bool":
|
|
return _pywrapcp.SavingsFilteredDecisionBuilder_BuildSolution(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.RoutingFilteredDecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingFilteredDecisionBuilder.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchLimit"><code class="flex name class">
|
|
<span>class <span class="ident">SearchLimit</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Base class of all search limits.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class SearchLimit(SearchMonitor):
|
|
r""" Base class of all search limits."""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_SearchLimit
|
|
|
|
def Crossed(self) -> "bool":
|
|
r""" Returns true if the limit has been crossed."""
|
|
return _pywrapcp.SearchLimit_Crossed(self)
|
|
|
|
def Check(self) -> "bool":
|
|
r""" This method is called to check the status of the limit. A return value of true indicates that we have indeed crossed the limit. In that case, this method will not be called again and the remaining search will be discarded."""
|
|
return _pywrapcp.SearchLimit_Check(self)
|
|
|
|
def Init(self) -> "void":
|
|
r""" This method is called when the search limit is initialized."""
|
|
return _pywrapcp.SearchLimit_Init(self)
|
|
|
|
def EnterSearch(self) -> "void":
|
|
r""" Internal methods."""
|
|
return _pywrapcp.SearchLimit_EnterSearch(self)
|
|
|
|
def BeginNextDecision(self, b: 'DecisionBuilder') -> "void":
|
|
return _pywrapcp.SearchLimit_BeginNextDecision(self, b)
|
|
|
|
def RefuteDecision(self, d: 'Decision') -> "void":
|
|
return _pywrapcp.SearchLimit_RefuteDecision(self, d)
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.SearchLimit_DebugString(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.SearchMonitor" href="#pywrapcp.SearchMonitor">SearchMonitor</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.SearchLimit.Check"><code class="name flex">
|
|
<span>def <span class="ident">Check</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method is called to check the status of the limit. A return value of true indicates that we have indeed crossed the limit. In that case, this method will not be called again and the remaining search will be discarded.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Check(self) -> "bool":
|
|
r""" This method is called to check the status of the limit. A return value of true indicates that we have indeed crossed the limit. In that case, this method will not be called again and the remaining search will be discarded."""
|
|
return _pywrapcp.SearchLimit_Check(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchLimit.Crossed"><code class="name flex">
|
|
<span>def <span class="ident">Crossed</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns true if the limit has been crossed.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Crossed(self) -> "bool":
|
|
r""" Returns true if the limit has been crossed."""
|
|
return _pywrapcp.SearchLimit_Crossed(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchLimit.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.SearchLimit_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchLimit.EnterSearch"><code class="name flex">
|
|
<span>def <span class="ident">EnterSearch</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Internal methods.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EnterSearch(self) -> "void":
|
|
r""" Internal methods."""
|
|
return _pywrapcp.SearchLimit_EnterSearch(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchLimit.Init"><code class="name flex">
|
|
<span>def <span class="ident">Init</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method is called when the search limit is initialized.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Init(self) -> "void":
|
|
r""" This method is called when the search limit is initialized."""
|
|
return _pywrapcp.SearchLimit_Init(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.SearchMonitor" href="#pywrapcp.SearchMonitor">SearchMonitor</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.SearchMonitor.AcceptNeighbor" href="#pywrapcp.SearchMonitor.AcceptNeighbor">AcceptNeighbor</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.AcceptSolution" href="#pywrapcp.SearchMonitor.AcceptSolution">AcceptSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.AfterDecision" href="#pywrapcp.SearchMonitor.AfterDecision">AfterDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.ApplyDecision" href="#pywrapcp.SearchMonitor.ApplyDecision">ApplyDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.AtSolution" href="#pywrapcp.SearchMonitor.AtSolution">AtSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.BeginFail" href="#pywrapcp.SearchMonitor.BeginFail">BeginFail</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.BeginInitialPropagation" href="#pywrapcp.SearchMonitor.BeginInitialPropagation">BeginInitialPropagation</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.BeginNextDecision" href="#pywrapcp.SearchMonitor.BeginNextDecision">BeginNextDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EndFail" href="#pywrapcp.SearchMonitor.EndFail">EndFail</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EndInitialPropagation" href="#pywrapcp.SearchMonitor.EndInitialPropagation">EndInitialPropagation</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EndNextDecision" href="#pywrapcp.SearchMonitor.EndNextDecision">EndNextDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.ExitSearch" href="#pywrapcp.SearchMonitor.ExitSearch">ExitSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.LocalOptimum" href="#pywrapcp.SearchMonitor.LocalOptimum">LocalOptimum</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.NoMoreSolutions" href="#pywrapcp.SearchMonitor.NoMoreSolutions">NoMoreSolutions</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.RefuteDecision" href="#pywrapcp.SearchMonitor.RefuteDecision">RefuteDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.RestartSearch" href="#pywrapcp.SearchMonitor.RestartSearch">RestartSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor"><code class="flex name class">
|
|
<span>class <span class="ident">SearchMonitor</span></span>
|
|
<span>(</span><span>s)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A search monitor is a simple set of callbacks to monitor all search events</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class SearchMonitor(BaseObject):
|
|
r""" A search monitor is a simple set of callbacks to monitor all search events"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
|
|
def __init__(self, s: 'Solver'):
|
|
if self.__class__ == SearchMonitor:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_pywrapcp.SearchMonitor_swiginit(self, _pywrapcp.new_SearchMonitor(_self, s))
|
|
__swig_destroy__ = _pywrapcp.delete_SearchMonitor
|
|
|
|
def EnterSearch(self) -> "void":
|
|
r""" Beginning of the search."""
|
|
return _pywrapcp.SearchMonitor_EnterSearch(self)
|
|
|
|
def RestartSearch(self) -> "void":
|
|
r""" Restart the search."""
|
|
return _pywrapcp.SearchMonitor_RestartSearch(self)
|
|
|
|
def ExitSearch(self) -> "void":
|
|
r""" End of the search."""
|
|
return _pywrapcp.SearchMonitor_ExitSearch(self)
|
|
|
|
def BeginNextDecision(self, b: 'DecisionBuilder') -> "void":
|
|
r""" Before calling DecisionBuilder::Next."""
|
|
return _pywrapcp.SearchMonitor_BeginNextDecision(self, b)
|
|
|
|
def EndNextDecision(self, b: 'DecisionBuilder', d: 'Decision') -> "void":
|
|
r""" After calling DecisionBuilder::Next, along with the returned decision."""
|
|
return _pywrapcp.SearchMonitor_EndNextDecision(self, b, d)
|
|
|
|
def ApplyDecision(self, d: 'Decision') -> "void":
|
|
r""" Before applying the decision."""
|
|
return _pywrapcp.SearchMonitor_ApplyDecision(self, d)
|
|
|
|
def RefuteDecision(self, d: 'Decision') -> "void":
|
|
r""" Before refuting the decision."""
|
|
return _pywrapcp.SearchMonitor_RefuteDecision(self, d)
|
|
|
|
def AfterDecision(self, d: 'Decision', apply: 'bool') -> "void":
|
|
r""" Just after refuting or applying the decision, apply is true after Apply. This is called only if the Apply() or Refute() methods have not failed."""
|
|
return _pywrapcp.SearchMonitor_AfterDecision(self, d, apply)
|
|
|
|
def BeginFail(self) -> "void":
|
|
r""" Just when the failure occurs."""
|
|
return _pywrapcp.SearchMonitor_BeginFail(self)
|
|
|
|
def EndFail(self) -> "void":
|
|
r""" After completing the backtrack."""
|
|
return _pywrapcp.SearchMonitor_EndFail(self)
|
|
|
|
def BeginInitialPropagation(self) -> "void":
|
|
r""" Before the initial propagation."""
|
|
return _pywrapcp.SearchMonitor_BeginInitialPropagation(self)
|
|
|
|
def EndInitialPropagation(self) -> "void":
|
|
r""" After the initial propagation."""
|
|
return _pywrapcp.SearchMonitor_EndInitialPropagation(self)
|
|
|
|
def AcceptSolution(self) -> "bool":
|
|
r""" This method is called when a solution is found. It asserts whether the solution is valid. A value of false indicates that the solution should be discarded."""
|
|
return _pywrapcp.SearchMonitor_AcceptSolution(self)
|
|
|
|
def AtSolution(self) -> "bool":
|
|
r""" This method is called when a valid solution is found. If the return value is true, then search will resume after. If the result is false, then search will stop there."""
|
|
return _pywrapcp.SearchMonitor_AtSolution(self)
|
|
|
|
def NoMoreSolutions(self) -> "void":
|
|
r""" When the search tree is finished."""
|
|
return _pywrapcp.SearchMonitor_NoMoreSolutions(self)
|
|
|
|
def LocalOptimum(self) -> "bool":
|
|
r""" When a local optimum is reached. If 'true' is returned, the last solution is discarded and the search proceeds with the next one."""
|
|
return _pywrapcp.SearchMonitor_LocalOptimum(self)
|
|
|
|
def AcceptDelta(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
return _pywrapcp.SearchMonitor_AcceptDelta(self, delta, deltadelta)
|
|
|
|
def AcceptNeighbor(self) -> "void":
|
|
r""" After accepting a neighbor during local search."""
|
|
return _pywrapcp.SearchMonitor_AcceptNeighbor(self)
|
|
|
|
def solver(self) -> "operations_research::Solver *":
|
|
return _pywrapcp.SearchMonitor_solver(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.SearchMonitor___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.SearchMonitor___str__(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_pywrapcp.disown_SearchMonitor(self)
|
|
return weakref.proxy(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.SolutionCollector" href="#pywrapcp.SolutionCollector">SolutionCollector</a></li>
|
|
<li><a title="pywrapcp.OptimizeVar" href="#pywrapcp.OptimizeVar">OptimizeVar</a></li>
|
|
<li><a title="pywrapcp.SearchLimit" href="#pywrapcp.SearchLimit">SearchLimit</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.SearchMonitor.AcceptDelta"><code class="name flex">
|
|
<span>def <span class="ident">AcceptDelta</span></span>(<span>self, delta, deltadelta)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AcceptDelta(self, delta: 'Assignment', deltadelta: 'Assignment') -> "bool":
|
|
return _pywrapcp.SearchMonitor_AcceptDelta(self, delta, deltadelta)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.AcceptNeighbor"><code class="name flex">
|
|
<span>def <span class="ident">AcceptNeighbor</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>After accepting a neighbor during local search.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AcceptNeighbor(self) -> "void":
|
|
r""" After accepting a neighbor during local search."""
|
|
return _pywrapcp.SearchMonitor_AcceptNeighbor(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.AcceptSolution"><code class="name flex">
|
|
<span>def <span class="ident">AcceptSolution</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method is called when a solution is found. It asserts whether the solution is valid. A value of false indicates that the solution should be discarded.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AcceptSolution(self) -> "bool":
|
|
r""" This method is called when a solution is found. It asserts whether the solution is valid. A value of false indicates that the solution should be discarded."""
|
|
return _pywrapcp.SearchMonitor_AcceptSolution(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.AfterDecision"><code class="name flex">
|
|
<span>def <span class="ident">AfterDecision</span></span>(<span>self, d, apply)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Just after refuting or applying the decision, apply is true after Apply. This is called only if the Apply() or Refute() methods have not failed.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AfterDecision(self, d: 'Decision', apply: 'bool') -> "void":
|
|
r""" Just after refuting or applying the decision, apply is true after Apply. This is called only if the Apply() or Refute() methods have not failed."""
|
|
return _pywrapcp.SearchMonitor_AfterDecision(self, d, apply)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.ApplyDecision"><code class="name flex">
|
|
<span>def <span class="ident">ApplyDecision</span></span>(<span>self, d)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Before applying the decision.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ApplyDecision(self, d: 'Decision') -> "void":
|
|
r""" Before applying the decision."""
|
|
return _pywrapcp.SearchMonitor_ApplyDecision(self, d)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.AtSolution"><code class="name flex">
|
|
<span>def <span class="ident">AtSolution</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method is called when a valid solution is found. If the return value is true, then search will resume after. If the result is false, then search will stop there.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AtSolution(self) -> "bool":
|
|
r""" This method is called when a valid solution is found. If the return value is true, then search will resume after. If the result is false, then search will stop there."""
|
|
return _pywrapcp.SearchMonitor_AtSolution(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.BeginFail"><code class="name flex">
|
|
<span>def <span class="ident">BeginFail</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Just when the failure occurs.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BeginFail(self) -> "void":
|
|
r""" Just when the failure occurs."""
|
|
return _pywrapcp.SearchMonitor_BeginFail(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.BeginInitialPropagation"><code class="name flex">
|
|
<span>def <span class="ident">BeginInitialPropagation</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Before the initial propagation.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BeginInitialPropagation(self) -> "void":
|
|
r""" Before the initial propagation."""
|
|
return _pywrapcp.SearchMonitor_BeginInitialPropagation(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.BeginNextDecision"><code class="name flex">
|
|
<span>def <span class="ident">BeginNextDecision</span></span>(<span>self, b)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Before calling DecisionBuilder::Next.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BeginNextDecision(self, b: 'DecisionBuilder') -> "void":
|
|
r""" Before calling DecisionBuilder::Next."""
|
|
return _pywrapcp.SearchMonitor_BeginNextDecision(self, b)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.EndFail"><code class="name flex">
|
|
<span>def <span class="ident">EndFail</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>After completing the backtrack.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndFail(self) -> "void":
|
|
r""" After completing the backtrack."""
|
|
return _pywrapcp.SearchMonitor_EndFail(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.EndInitialPropagation"><code class="name flex">
|
|
<span>def <span class="ident">EndInitialPropagation</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>After the initial propagation.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndInitialPropagation(self) -> "void":
|
|
r""" After the initial propagation."""
|
|
return _pywrapcp.SearchMonitor_EndInitialPropagation(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.EndNextDecision"><code class="name flex">
|
|
<span>def <span class="ident">EndNextDecision</span></span>(<span>self, b, d)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>After calling DecisionBuilder::Next, along with the returned decision.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndNextDecision(self, b: 'DecisionBuilder', d: 'Decision') -> "void":
|
|
r""" After calling DecisionBuilder::Next, along with the returned decision."""
|
|
return _pywrapcp.SearchMonitor_EndNextDecision(self, b, d)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.EnterSearch"><code class="name flex">
|
|
<span>def <span class="ident">EnterSearch</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Beginning of the search.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EnterSearch(self) -> "void":
|
|
r""" Beginning of the search."""
|
|
return _pywrapcp.SearchMonitor_EnterSearch(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.ExitSearch"><code class="name flex">
|
|
<span>def <span class="ident">ExitSearch</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>End of the search.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ExitSearch(self) -> "void":
|
|
r""" End of the search."""
|
|
return _pywrapcp.SearchMonitor_ExitSearch(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.LocalOptimum"><code class="name flex">
|
|
<span>def <span class="ident">LocalOptimum</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>When a local optimum is reached. If 'true' is returned, the last solution is discarded and the search proceeds with the next one.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def LocalOptimum(self) -> "bool":
|
|
r""" When a local optimum is reached. If 'true' is returned, the last solution is discarded and the search proceeds with the next one."""
|
|
return _pywrapcp.SearchMonitor_LocalOptimum(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.NoMoreSolutions"><code class="name flex">
|
|
<span>def <span class="ident">NoMoreSolutions</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>When the search tree is finished.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NoMoreSolutions(self) -> "void":
|
|
r""" When the search tree is finished."""
|
|
return _pywrapcp.SearchMonitor_NoMoreSolutions(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.RefuteDecision"><code class="name flex">
|
|
<span>def <span class="ident">RefuteDecision</span></span>(<span>self, d)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Before refuting the decision.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RefuteDecision(self, d: 'Decision') -> "void":
|
|
r""" Before refuting the decision."""
|
|
return _pywrapcp.SearchMonitor_RefuteDecision(self, d)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.RestartSearch"><code class="name flex">
|
|
<span>def <span class="ident">RestartSearch</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Restart the search.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RestartSearch(self) -> "void":
|
|
r""" Restart the search."""
|
|
return _pywrapcp.SearchMonitor_RestartSearch(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SearchMonitor.solver"><code class="name flex">
|
|
<span>def <span class="ident">solver</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def solver(self) -> "operations_research::Solver *":
|
|
return _pywrapcp.SearchMonitor_solver(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.BaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVar"><code class="flex name class">
|
|
<span>class <span class="ident">SequenceVar</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A sequence variable is a variable whose domain is a set of possible orderings of the interval variables. It allows ordering of tasks. It has two sets of methods: ComputePossibleFirstsAndLasts(), which returns the list of interval variables that can be ranked first or last; and RankFirst/RankNotFirst/RankLast/RankNotLast, which can be used to create the search decision.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class SequenceVar(PropagationBaseObject):
|
|
r""" A sequence variable is a variable whose domain is a set of possible orderings of the interval variables. It allows ordering of tasks. It has two sets of methods: ComputePossibleFirstsAndLasts(), which returns the list of interval variables that can be ranked first or last; and RankFirst/RankNotFirst/RankLast/RankNotLast, which can be used to create the search decision."""
|
|
|
|
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 DebugString(self) -> "std::string":
|
|
return _pywrapcp.SequenceVar_DebugString(self)
|
|
|
|
def RankFirst(self, index: 'int') -> "void":
|
|
r""" Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked."""
|
|
return _pywrapcp.SequenceVar_RankFirst(self, index)
|
|
|
|
def RankNotFirst(self, index: 'int') -> "void":
|
|
r""" Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars."""
|
|
return _pywrapcp.SequenceVar_RankNotFirst(self, index)
|
|
|
|
def RankLast(self, index: 'int') -> "void":
|
|
r""" Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked."""
|
|
return _pywrapcp.SequenceVar_RankLast(self, index)
|
|
|
|
def RankNotLast(self, index: 'int') -> "void":
|
|
r""" Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars."""
|
|
return _pywrapcp.SequenceVar_RankNotLast(self, index)
|
|
|
|
def Interval(self, index: 'int') -> "operations_research::IntervalVar *":
|
|
r""" Returns the index_th interval of the sequence."""
|
|
return _pywrapcp.SequenceVar_Interval(self, index)
|
|
|
|
def Next(self, index: 'int') -> "operations_research::IntVar *":
|
|
r""" Returns the next of the index_th interval of the sequence."""
|
|
return _pywrapcp.SequenceVar_Next(self, index)
|
|
|
|
def Size(self) -> "int64":
|
|
r""" Returns the number of interval vars in the sequence."""
|
|
return _pywrapcp.SequenceVar_Size(self)
|
|
|
|
def __repr__(self) -> "std::string":
|
|
return _pywrapcp.SequenceVar___repr__(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.SequenceVar___str__(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.SequenceVar.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.SequenceVar_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVar.Interval"><code class="name flex">
|
|
<span>def <span class="ident">Interval</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the index_th interval of the sequence.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Interval(self, index: 'int') -> "operations_research::IntervalVar *":
|
|
r""" Returns the index_th interval of the sequence."""
|
|
return _pywrapcp.SequenceVar_Interval(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVar.Next"><code class="name flex">
|
|
<span>def <span class="ident">Next</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the next of the index_th interval of the sequence.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Next(self, index: 'int') -> "operations_research::IntVar *":
|
|
r""" Returns the next of the index_th interval of the sequence."""
|
|
return _pywrapcp.SequenceVar_Next(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVar.RankFirst"><code class="name flex">
|
|
<span>def <span class="ident">RankFirst</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RankFirst(self, index: 'int') -> "void":
|
|
r""" Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked."""
|
|
return _pywrapcp.SequenceVar_RankFirst(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVar.RankLast"><code class="name flex">
|
|
<span>def <span class="ident">RankLast</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RankLast(self, index: 'int') -> "void":
|
|
r""" Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked."""
|
|
return _pywrapcp.SequenceVar_RankLast(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVar.RankNotFirst"><code class="name flex">
|
|
<span>def <span class="ident">RankNotFirst</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RankNotFirst(self, index: 'int') -> "void":
|
|
r""" Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars."""
|
|
return _pywrapcp.SequenceVar_RankNotFirst(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVar.RankNotLast"><code class="name flex">
|
|
<span>def <span class="ident">RankNotLast</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RankNotLast(self, index: 'int') -> "void":
|
|
r""" Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars."""
|
|
return _pywrapcp.SequenceVar_RankNotLast(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVar.Size"><code class="name flex">
|
|
<span>def <span class="ident">Size</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the number of interval vars in the sequence.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Size(self) -> "int64":
|
|
r""" Returns the number of interval vars in the sequence."""
|
|
return _pywrapcp.SequenceVar_Size(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.PropagationBaseObject.Name" href="#pywrapcp.PropagationBaseObject.Name">Name</a></code></li>
|
|
<li><code><a title="pywrapcp.PropagationBaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarContainer"><code class="flex name class">
|
|
<span>class <span class="ident">SequenceVarContainer</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class SequenceVarContainer(object):
|
|
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 Contains(self, var: 'SequenceVar') -> "bool":
|
|
return _pywrapcp.SequenceVarContainer_Contains(self, var)
|
|
|
|
def Element(self, index: 'int') -> "operations_research::SequenceVarElement *":
|
|
return _pywrapcp.SequenceVarContainer_Element(self, index)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.SequenceVarContainer_Size(self)
|
|
|
|
def Store(self) -> "void":
|
|
return _pywrapcp.SequenceVarContainer_Store(self)
|
|
|
|
def Restore(self) -> "void":
|
|
return _pywrapcp.SequenceVarContainer_Restore(self)
|
|
|
|
def __eq__(self, container: 'SequenceVarContainer') -> "bool":
|
|
r""" Returns true if this and 'container' both represent the same V* -> E map. Runs in linear time; requires that the == operator on the type E is well defined."""
|
|
return _pywrapcp.SequenceVarContainer___eq__(self, container)
|
|
|
|
def __ne__(self, container: 'SequenceVarContainer') -> "bool":
|
|
return _pywrapcp.SequenceVarContainer___ne__(self, container)
|
|
__swig_destroy__ = _pywrapcp.delete_SequenceVarContainer</code></pre>
|
|
</details>
|
|
<h3>Instance variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.SequenceVarContainer.thisown"><code class="name">var <span class="ident">thisown</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The membership flag</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.SequenceVarContainer.Contains"><code class="name flex">
|
|
<span>def <span class="ident">Contains</span></span>(<span>self, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Contains(self, var: 'SequenceVar') -> "bool":
|
|
return _pywrapcp.SequenceVarContainer_Contains(self, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarContainer.Element"><code class="name flex">
|
|
<span>def <span class="ident">Element</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Element(self, index: 'int') -> "operations_research::SequenceVarElement *":
|
|
return _pywrapcp.SequenceVarContainer_Element(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarContainer.Restore"><code class="name flex">
|
|
<span>def <span class="ident">Restore</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Restore(self) -> "void":
|
|
return _pywrapcp.SequenceVarContainer_Restore(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarContainer.Size"><code class="name flex">
|
|
<span>def <span class="ident">Size</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Size(self) -> "int":
|
|
return _pywrapcp.SequenceVarContainer_Size(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarContainer.Store"><code class="name flex">
|
|
<span>def <span class="ident">Store</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Store(self) -> "void":
|
|
return _pywrapcp.SequenceVarContainer_Store(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarElement"><code class="flex name class">
|
|
<span>class <span class="ident">SequenceVarElement</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The SequenceVarElement stores a partial representation of ranked interval variables in the underlying sequence variable. This representation consists of three vectors:
|
|
- the forward sequence. That is the list of interval variables
|
|
ranked first in the sequence.
|
|
The first element of the backward
|
|
sequence is the first interval in the sequence variable.
|
|
- the backward sequence. That is the list of interval variables
|
|
ranked last in the sequence. The first element of the backward
|
|
sequence is the last interval in the sequence variable.
|
|
- The list of unperformed interval variables.
|
|
Furthermore, if all performed variables are ranked, then by
|
|
convention, the forward_sequence will contain all such variables
|
|
and the backward_sequence will be empty.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class SequenceVarElement(AssignmentElement):
|
|
r""" The SequenceVarElement stores a partial representation of ranked interval variables in the underlying sequence variable. This representation consists of three vectors: - the forward sequence. That is the list of interval variables ranked first in the sequence. The first element of the backward sequence is the first interval in the sequence variable. - the backward sequence. That is the list of interval variables ranked last in the sequence. The first element of the backward sequence is the last interval in the sequence variable. - The list of unperformed interval variables. Furthermore, if all performed variables are ranked, then by convention, the forward_sequence will contain all such variables and the backward_sequence will be empty."""
|
|
|
|
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 Var(self) -> "operations_research::SequenceVar *":
|
|
return _pywrapcp.SequenceVarElement_Var(self)
|
|
|
|
def ForwardSequence(self) -> "std::vector< int > const &":
|
|
return _pywrapcp.SequenceVarElement_ForwardSequence(self)
|
|
|
|
def BackwardSequence(self) -> "std::vector< int > const &":
|
|
return _pywrapcp.SequenceVarElement_BackwardSequence(self)
|
|
|
|
def Unperformed(self) -> "std::vector< int > const &":
|
|
return _pywrapcp.SequenceVarElement_Unperformed(self)
|
|
|
|
def SetSequence(self, forward_sequence: 'std::vector< int > const &', backward_sequence: 'std::vector< int > const &', unperformed: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarElement_SetSequence(self, forward_sequence, backward_sequence, unperformed)
|
|
|
|
def SetForwardSequence(self, forward_sequence: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarElement_SetForwardSequence(self, forward_sequence)
|
|
|
|
def SetBackwardSequence(self, backward_sequence: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarElement_SetBackwardSequence(self, backward_sequence)
|
|
|
|
def SetUnperformed(self, unperformed: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarElement_SetUnperformed(self, unperformed)
|
|
|
|
def __eq__(self, element: 'SequenceVarElement') -> "bool":
|
|
return _pywrapcp.SequenceVarElement___eq__(self, element)
|
|
|
|
def __ne__(self, element: 'SequenceVarElement') -> "bool":
|
|
return _pywrapcp.SequenceVarElement___ne__(self, element)
|
|
__swig_destroy__ = _pywrapcp.delete_SequenceVarElement</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.AssignmentElement" href="#pywrapcp.AssignmentElement">AssignmentElement</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.SequenceVarElement.BackwardSequence"><code class="name flex">
|
|
<span>def <span class="ident">BackwardSequence</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BackwardSequence(self) -> "std::vector< int > const &":
|
|
return _pywrapcp.SequenceVarElement_BackwardSequence(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarElement.ForwardSequence"><code class="name flex">
|
|
<span>def <span class="ident">ForwardSequence</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ForwardSequence(self) -> "std::vector< int > const &":
|
|
return _pywrapcp.SequenceVarElement_ForwardSequence(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarElement.SetBackwardSequence"><code class="name flex">
|
|
<span>def <span class="ident">SetBackwardSequence</span></span>(<span>self, backward_sequence)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetBackwardSequence(self, backward_sequence: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarElement_SetBackwardSequence(self, backward_sequence)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarElement.SetForwardSequence"><code class="name flex">
|
|
<span>def <span class="ident">SetForwardSequence</span></span>(<span>self, forward_sequence)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetForwardSequence(self, forward_sequence: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarElement_SetForwardSequence(self, forward_sequence)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarElement.SetSequence"><code class="name flex">
|
|
<span>def <span class="ident">SetSequence</span></span>(<span>self, forward_sequence, backward_sequence, unperformed)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetSequence(self, forward_sequence: 'std::vector< int > const &', backward_sequence: 'std::vector< int > const &', unperformed: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarElement_SetSequence(self, forward_sequence, backward_sequence, unperformed)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarElement.SetUnperformed"><code class="name flex">
|
|
<span>def <span class="ident">SetUnperformed</span></span>(<span>self, unperformed)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetUnperformed(self, unperformed: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarElement_SetUnperformed(self, unperformed)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarElement.Unperformed"><code class="name flex">
|
|
<span>def <span class="ident">Unperformed</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Unperformed(self) -> "std::vector< int > const &":
|
|
return _pywrapcp.SequenceVarElement_Unperformed(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarElement.Var"><code class="name flex">
|
|
<span>def <span class="ident">Var</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Var(self) -> "operations_research::SequenceVar *":
|
|
return _pywrapcp.SequenceVarElement_Var(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.AssignmentElement" href="#pywrapcp.AssignmentElement">AssignmentElement</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.AssignmentElement.thisown" href="#pywrapcp.AssignmentElement.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarLocalSearchOperator"><code class="flex name class">
|
|
<span>class <span class="ident">SequenceVarLocalSearchOperator</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Base operator class for operators manipulating variables.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class SequenceVarLocalSearchOperator(SequenceVarLocalSearchOperatorTemplate):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate">SequenceVarLocalSearchOperatorTemplate</a></li>
|
|
<li><a title="pywrapcp.LocalSearchOperator" href="#pywrapcp.LocalSearchOperator">LocalSearchOperator</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate">SequenceVarLocalSearchOperatorTemplate</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate.OnStart" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate.OnStart">OnStart</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate.Start" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate.Start">Start</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate.Value" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate.Value">Value</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarLocalSearchOperatorTemplate"><code class="flex name class">
|
|
<span>class <span class="ident">SequenceVarLocalSearchOperatorTemplate</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Base operator class for operators manipulating variables.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class SequenceVarLocalSearchOperatorTemplate(LocalSearchOperator):
|
|
r""" Base operator class for operators manipulating variables."""
|
|
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def Start(self, assignment: 'Assignment') -> "void":
|
|
r""" This method should not be overridden. Override OnStart() instead which is called before exiting this method."""
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_Start(self, assignment)
|
|
|
|
def IsIncremental(self) -> "bool":
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_IsIncremental(self)
|
|
|
|
def Size(self) -> "int":
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_Size(self)
|
|
|
|
def Value(self, index: 'int64') -> "std::vector< int > const &":
|
|
r""" Returns the value in the current assignment of the variable of given index."""
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_Value(self, index)
|
|
|
|
def OldValue(self, index: 'int64') -> "std::vector< int > const &":
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_OldValue(self, index)
|
|
|
|
def SetValue(self, index: 'int64', value: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_SetValue(self, index, value)
|
|
|
|
def OnStart(self) -> "void":
|
|
r""" Called by Start() after synchronizing the operator with the current assignment. Should be overridden instead of Start() to avoid calling VarLocalSearchOperator::Start explicitly."""
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_OnStart(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.LocalSearchOperator" href="#pywrapcp.LocalSearchOperator">LocalSearchOperator</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.SequenceVarLocalSearchOperator" href="#pywrapcp.SequenceVarLocalSearchOperator">SequenceVarLocalSearchOperator</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.SequenceVarLocalSearchOperatorTemplate.IsIncremental"><code class="name flex">
|
|
<span>def <span class="ident">IsIncremental</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsIncremental(self) -> "bool":
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_IsIncremental(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarLocalSearchOperatorTemplate.OldValue"><code class="name flex">
|
|
<span>def <span class="ident">OldValue</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OldValue(self, index: 'int64') -> "std::vector< int > const &":
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_OldValue(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarLocalSearchOperatorTemplate.OnStart"><code class="name flex">
|
|
<span>def <span class="ident">OnStart</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Called by Start() after synchronizing the operator with the current assignment. Should be overridden instead of Start() to avoid calling VarLocalSearchOperator::Start explicitly.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def OnStart(self) -> "void":
|
|
r""" Called by Start() after synchronizing the operator with the current assignment. Should be overridden instead of Start() to avoid calling VarLocalSearchOperator::Start explicitly."""
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_OnStart(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarLocalSearchOperatorTemplate.SetValue"><code class="name flex">
|
|
<span>def <span class="ident">SetValue</span></span>(<span>self, index, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SetValue(self, index: 'int64', value: 'std::vector< int > const &') -> "void":
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_SetValue(self, index, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarLocalSearchOperatorTemplate.Size"><code class="name flex">
|
|
<span>def <span class="ident">Size</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Size(self) -> "int":
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_Size(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarLocalSearchOperatorTemplate.Start"><code class="name flex">
|
|
<span>def <span class="ident">Start</span></span>(<span>self, assignment)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method should not be overridden. Override OnStart() instead which is called before exiting this method.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Start(self, assignment: 'Assignment') -> "void":
|
|
r""" This method should not be overridden. Override OnStart() instead which is called before exiting this method."""
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_Start(self, assignment)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SequenceVarLocalSearchOperatorTemplate.Value"><code class="name flex">
|
|
<span>def <span class="ident">Value</span></span>(<span>self, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the value in the current assignment of the variable of given index.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Value(self, index: 'int64') -> "std::vector< int > const &":
|
|
r""" Returns the value in the current assignment of the variable of given index."""
|
|
return _pywrapcp.SequenceVarLocalSearchOperatorTemplate_Value(self, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.LocalSearchOperator" href="#pywrapcp.LocalSearchOperator">LocalSearchOperator</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.LocalSearchOperator.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.SequentialSavingsFilteredDecisionBuilder"><code class="flex name class">
|
|
<span>class <span class="ident">SequentialSavingsFilteredDecisionBuilder</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class SequentialSavingsFilteredDecisionBuilder(SavingsFilteredDecisionBuilder):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_SequentialSavingsFilteredDecisionBuilder
|
|
|
|
def DebugString(self) -> "std::string":
|
|
return _pywrapcp.SequentialSavingsFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.SavingsFilteredDecisionBuilder" href="#pywrapcp.SavingsFilteredDecisionBuilder">SavingsFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.SequentialSavingsFilteredDecisionBuilder.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.SequentialSavingsFilteredDecisionBuilder_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.SavingsFilteredDecisionBuilder" href="#pywrapcp.SavingsFilteredDecisionBuilder">SavingsFilteredDecisionBuilder</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.SavingsFilteredDecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.SavingsFilteredDecisionBuilder.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector"><code class="flex name class">
|
|
<span>class <span class="ident">SolutionCollector</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This class is the root class of all solution collectors. It implements a basic query API to be used independently of the collector used.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class SolutionCollector(SearchMonitor):
|
|
r""" This class is the root class of all solution collectors. It implements a basic query API to be used independently of the collector used."""
|
|
|
|
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 DebugString(self) -> "std::string":
|
|
return _pywrapcp.SolutionCollector_DebugString(self)
|
|
|
|
def Add(self, *args) -> "void":
|
|
return _pywrapcp.SolutionCollector_Add(self, *args)
|
|
|
|
def AddObjective(self, objective: 'IntVar') -> "void":
|
|
return _pywrapcp.SolutionCollector_AddObjective(self, objective)
|
|
|
|
def EnterSearch(self) -> "void":
|
|
r""" Beginning of the search."""
|
|
return _pywrapcp.SolutionCollector_EnterSearch(self)
|
|
|
|
def SolutionCount(self) -> "int":
|
|
r""" Returns how many solutions were stored during the search."""
|
|
return _pywrapcp.SolutionCollector_SolutionCount(self)
|
|
|
|
def Solution(self, n: 'int') -> "operations_research::Assignment *":
|
|
r""" Returns the nth solution."""
|
|
return _pywrapcp.SolutionCollector_Solution(self, n)
|
|
|
|
def WallTime(self, n: 'int') -> "int64":
|
|
r""" Returns the wall time in ms for the nth solution."""
|
|
return _pywrapcp.SolutionCollector_WallTime(self, n)
|
|
|
|
def Branches(self, n: 'int') -> "int64":
|
|
r""" Returns the number of branches when the nth solution was found."""
|
|
return _pywrapcp.SolutionCollector_Branches(self, n)
|
|
|
|
def Failures(self, n: 'int') -> "int64":
|
|
r""" Returns the number of failures encountered at the time of the nth solution."""
|
|
return _pywrapcp.SolutionCollector_Failures(self, n)
|
|
|
|
def ObjectiveValue(self, n: 'int') -> "int64":
|
|
r""" Returns the objective value of the nth solution."""
|
|
return _pywrapcp.SolutionCollector_ObjectiveValue(self, n)
|
|
|
|
def Value(self, n: 'int', var: 'IntVar') -> "int64":
|
|
r""" This is a shortcut to get the Value of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_Value(self, n, var)
|
|
|
|
def StartValue(self, n: 'int', var: 'IntervalVar') -> "int64":
|
|
r""" This is a shortcut to get the StartValue of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_StartValue(self, n, var)
|
|
|
|
def EndValue(self, n: 'int', var: 'IntervalVar') -> "int64":
|
|
r""" This is a shortcut to get the EndValue of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_EndValue(self, n, var)
|
|
|
|
def DurationValue(self, n: 'int', var: 'IntervalVar') -> "int64":
|
|
r""" This is a shortcut to get the DurationValue of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_DurationValue(self, n, var)
|
|
|
|
def PerformedValue(self, n: 'int', var: 'IntervalVar') -> "int64":
|
|
r""" This is a shortcut to get the PerformedValue of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_PerformedValue(self, n, var)
|
|
|
|
def ForwardSequence(self, n: 'int', var: 'SequenceVar') -> "std::vector< int > const &":
|
|
r""" This is a shortcut to get the ForwardSequence of 'var' in the nth solution. The forward sequence is the list of ranked interval variables starting from the start of the sequence."""
|
|
return _pywrapcp.SolutionCollector_ForwardSequence(self, n, var)
|
|
|
|
def BackwardSequence(self, n: 'int', var: 'SequenceVar') -> "std::vector< int > const &":
|
|
r""" This is a shortcut to get the BackwardSequence of 'var' in the nth solution. The backward sequence is the list of ranked interval variables starting from the end of the sequence."""
|
|
return _pywrapcp.SolutionCollector_BackwardSequence(self, n, var)
|
|
|
|
def Unperformed(self, n: 'int', var: 'SequenceVar') -> "std::vector< int > const &":
|
|
r""" This is a shortcut to get the list of unperformed of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_Unperformed(self, n, var)</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.SearchMonitor" href="#pywrapcp.SearchMonitor">SearchMonitor</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.SolutionCollector.Add"><code class="name flex">
|
|
<span>def <span class="ident">Add</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Add(self, *args) -> "void":
|
|
return _pywrapcp.SolutionCollector_Add(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.AddObjective"><code class="name flex">
|
|
<span>def <span class="ident">AddObjective</span></span>(<span>self, objective)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddObjective(self, objective: 'IntVar') -> "void":
|
|
return _pywrapcp.SolutionCollector_AddObjective(self, objective)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.BackwardSequence"><code class="name flex">
|
|
<span>def <span class="ident">BackwardSequence</span></span>(<span>self, n, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This is a shortcut to get the BackwardSequence of 'var' in the nth solution. The backward sequence is the list of ranked interval variables starting from the end of the sequence.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BackwardSequence(self, n: 'int', var: 'SequenceVar') -> "std::vector< int > const &":
|
|
r""" This is a shortcut to get the BackwardSequence of 'var' in the nth solution. The backward sequence is the list of ranked interval variables starting from the end of the sequence."""
|
|
return _pywrapcp.SolutionCollector_BackwardSequence(self, n, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.Branches"><code class="name flex">
|
|
<span>def <span class="ident">Branches</span></span>(<span>self, n)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the number of branches when the nth solution was found.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Branches(self, n: 'int') -> "int64":
|
|
r""" Returns the number of branches when the nth solution was found."""
|
|
return _pywrapcp.SolutionCollector_Branches(self, n)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.DebugString"><code class="name flex">
|
|
<span>def <span class="ident">DebugString</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DebugString(self) -> "std::string":
|
|
return _pywrapcp.SolutionCollector_DebugString(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.DurationValue"><code class="name flex">
|
|
<span>def <span class="ident">DurationValue</span></span>(<span>self, n, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This is a shortcut to get the DurationValue of 'var' in the nth solution.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DurationValue(self, n: 'int', var: 'IntervalVar') -> "int64":
|
|
r""" This is a shortcut to get the DurationValue of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_DurationValue(self, n, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.EndValue"><code class="name flex">
|
|
<span>def <span class="ident">EndValue</span></span>(<span>self, n, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This is a shortcut to get the EndValue of 'var' in the nth solution.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndValue(self, n: 'int', var: 'IntervalVar') -> "int64":
|
|
r""" This is a shortcut to get the EndValue of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_EndValue(self, n, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.Failures"><code class="name flex">
|
|
<span>def <span class="ident">Failures</span></span>(<span>self, n)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the number of failures encountered at the time of the nth solution.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Failures(self, n: 'int') -> "int64":
|
|
r""" Returns the number of failures encountered at the time of the nth solution."""
|
|
return _pywrapcp.SolutionCollector_Failures(self, n)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.ForwardSequence"><code class="name flex">
|
|
<span>def <span class="ident">ForwardSequence</span></span>(<span>self, n, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This is a shortcut to get the ForwardSequence of 'var' in the nth solution. The forward sequence is the list of ranked interval variables starting from the start of the sequence.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ForwardSequence(self, n: 'int', var: 'SequenceVar') -> "std::vector< int > const &":
|
|
r""" This is a shortcut to get the ForwardSequence of 'var' in the nth solution. The forward sequence is the list of ranked interval variables starting from the start of the sequence."""
|
|
return _pywrapcp.SolutionCollector_ForwardSequence(self, n, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.ObjectiveValue"><code class="name flex">
|
|
<span>def <span class="ident">ObjectiveValue</span></span>(<span>self, n)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the objective value of the nth solution.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ObjectiveValue(self, n: 'int') -> "int64":
|
|
r""" Returns the objective value of the nth solution."""
|
|
return _pywrapcp.SolutionCollector_ObjectiveValue(self, n)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.PerformedValue"><code class="name flex">
|
|
<span>def <span class="ident">PerformedValue</span></span>(<span>self, n, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This is a shortcut to get the PerformedValue of 'var' in the nth solution.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def PerformedValue(self, n: 'int', var: 'IntervalVar') -> "int64":
|
|
r""" This is a shortcut to get the PerformedValue of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_PerformedValue(self, n, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.Solution"><code class="name flex">
|
|
<span>def <span class="ident">Solution</span></span>(<span>self, n)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the nth solution.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Solution(self, n: 'int') -> "operations_research::Assignment *":
|
|
r""" Returns the nth solution."""
|
|
return _pywrapcp.SolutionCollector_Solution(self, n)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.SolutionCount"><code class="name flex">
|
|
<span>def <span class="ident">SolutionCount</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns how many solutions were stored during the search.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SolutionCount(self) -> "int":
|
|
r""" Returns how many solutions were stored during the search."""
|
|
return _pywrapcp.SolutionCollector_SolutionCount(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.StartValue"><code class="name flex">
|
|
<span>def <span class="ident">StartValue</span></span>(<span>self, n, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This is a shortcut to get the StartValue of 'var' in the nth solution.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StartValue(self, n: 'int', var: 'IntervalVar') -> "int64":
|
|
r""" This is a shortcut to get the StartValue of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_StartValue(self, n, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.Unperformed"><code class="name flex">
|
|
<span>def <span class="ident">Unperformed</span></span>(<span>self, n, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This is a shortcut to get the list of unperformed of 'var' in the nth solution.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Unperformed(self, n: 'int', var: 'SequenceVar') -> "std::vector< int > const &":
|
|
r""" This is a shortcut to get the list of unperformed of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_Unperformed(self, n, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.Value"><code class="name flex">
|
|
<span>def <span class="ident">Value</span></span>(<span>self, n, var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This is a shortcut to get the Value of 'var' in the nth solution.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Value(self, n: 'int', var: 'IntVar') -> "int64":
|
|
r""" This is a shortcut to get the Value of 'var' in the nth solution."""
|
|
return _pywrapcp.SolutionCollector_Value(self, n, var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.SolutionCollector.WallTime"><code class="name flex">
|
|
<span>def <span class="ident">WallTime</span></span>(<span>self, n)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the wall time in ms for the nth solution.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WallTime(self, n: 'int') -> "int64":
|
|
r""" Returns the wall time in ms for the nth solution."""
|
|
return _pywrapcp.SolutionCollector_WallTime(self, n)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.SearchMonitor" href="#pywrapcp.SearchMonitor">SearchMonitor</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.SearchMonitor.AcceptNeighbor" href="#pywrapcp.SearchMonitor.AcceptNeighbor">AcceptNeighbor</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.AcceptSolution" href="#pywrapcp.SearchMonitor.AcceptSolution">AcceptSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.AfterDecision" href="#pywrapcp.SearchMonitor.AfterDecision">AfterDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.ApplyDecision" href="#pywrapcp.SearchMonitor.ApplyDecision">ApplyDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.AtSolution" href="#pywrapcp.SearchMonitor.AtSolution">AtSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.BeginFail" href="#pywrapcp.SearchMonitor.BeginFail">BeginFail</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.BeginInitialPropagation" href="#pywrapcp.SearchMonitor.BeginInitialPropagation">BeginInitialPropagation</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.BeginNextDecision" href="#pywrapcp.SearchMonitor.BeginNextDecision">BeginNextDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EndFail" href="#pywrapcp.SearchMonitor.EndFail">EndFail</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EndInitialPropagation" href="#pywrapcp.SearchMonitor.EndInitialPropagation">EndInitialPropagation</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EndNextDecision" href="#pywrapcp.SearchMonitor.EndNextDecision">EndNextDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EnterSearch" href="#pywrapcp.SearchMonitor.EnterSearch">EnterSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.ExitSearch" href="#pywrapcp.SearchMonitor.ExitSearch">ExitSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.LocalOptimum" href="#pywrapcp.SearchMonitor.LocalOptimum">LocalOptimum</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.NoMoreSolutions" href="#pywrapcp.SearchMonitor.NoMoreSolutions">NoMoreSolutions</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.RefuteDecision" href="#pywrapcp.SearchMonitor.RefuteDecision">RefuteDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.RestartSearch" href="#pywrapcp.SearchMonitor.RestartSearch">RestartSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver"><code class="flex name class">
|
|
<span>class <span class="ident">Solver</span></span>
|
|
<span>(</span><span>*args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Solver Class A solver represents the main computation engine. It implements the entire range of Constraint Programming protocols:
|
|
- Reversibility
|
|
- Propagation
|
|
- Search Usually, Constraint Programming code consists of
|
|
- the creation of the Solver,
|
|
- the creation of the decision variables of the model,
|
|
- the creation of the constraints of the model and their addition to the
|
|
solver() through the AddConstraint() method,
|
|
- the creation of the main DecisionBuilder class,
|
|
- the launch of the solve() method with the decision builder. For the time being, Solver is neither MT_SAFE nor MT_HOT.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class Solver(object):
|
|
r""" Solver Class A solver represents the main computation engine. It implements the entire range of Constraint Programming protocols: - Reversibility - Propagation - Search Usually, Constraint Programming code consists of - the creation of the Solver, - the creation of the decision variables of the model, - the creation of the constraints of the model and their addition to the solver() through the AddConstraint() method, - the creation of the main DecisionBuilder class, - the launch of the solve() method with the decision builder. For the time being, Solver is neither MT_SAFE nor MT_HOT."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
INT_VAR_DEFAULT = _pywrapcp.Solver_INT_VAR_DEFAULT
|
|
r""" The default behavior is CHOOSE_FIRST_UNBOUND."""
|
|
INT_VAR_SIMPLE = _pywrapcp.Solver_INT_VAR_SIMPLE
|
|
r""" The simple selection is CHOOSE_FIRST_UNBOUND."""
|
|
CHOOSE_FIRST_UNBOUND = _pywrapcp.Solver_CHOOSE_FIRST_UNBOUND
|
|
r""" Select the first unbound variable. Variables are considered in the order of the vector of IntVars used to create the selector."""
|
|
CHOOSE_RANDOM = _pywrapcp.Solver_CHOOSE_RANDOM
|
|
r""" Randomly select one of the remaining unbound variables."""
|
|
CHOOSE_MIN_SIZE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MIN
|
|
r""" Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variables is the one with the lowest min value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_MIN_SIZE_HIGHEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MIN
|
|
r""" Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variable is the one with the highest min value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_MIN_SIZE_LOWEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MAX
|
|
r""" Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variables is the one with the lowest max value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_MIN_SIZE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MAX
|
|
r""" Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variable is the one with the highest max value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_LOWEST_MIN
|
|
r""" Among unbound variables, select the variable with the smallest minimal value. In case of a tie, the first one is selected, "first" defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_HIGHEST_MAX
|
|
r""" Among unbound variables, select the variable with the highest maximal value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_MIN_SIZE = _pywrapcp.Solver_CHOOSE_MIN_SIZE
|
|
r""" Among unbound variables, select the variable with the smallest size. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_MAX_SIZE = _pywrapcp.Solver_CHOOSE_MAX_SIZE
|
|
r""" Among unbound variables, select the variable with the highest size. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector."""
|
|
CHOOSE_MAX_REGRET_ON_MIN = _pywrapcp.Solver_CHOOSE_MAX_REGRET_ON_MIN
|
|
r""" Among unbound variables, select the variable with the largest gap between the first and the second values of the domain."""
|
|
CHOOSE_PATH = _pywrapcp.Solver_CHOOSE_PATH
|
|
r""" Selects the next unbound variable on a path, the path being defined by the variables: var[i] corresponds to the index of the next of i."""
|
|
INT_VALUE_DEFAULT = _pywrapcp.Solver_INT_VALUE_DEFAULT
|
|
r""" The default behavior is ASSIGN_MIN_VALUE."""
|
|
INT_VALUE_SIMPLE = _pywrapcp.Solver_INT_VALUE_SIMPLE
|
|
r""" The simple selection is ASSIGN_MIN_VALUE."""
|
|
ASSIGN_MIN_VALUE = _pywrapcp.Solver_ASSIGN_MIN_VALUE
|
|
r""" Selects the min value of the selected variable."""
|
|
ASSIGN_MAX_VALUE = _pywrapcp.Solver_ASSIGN_MAX_VALUE
|
|
r""" Selects the max value of the selected variable."""
|
|
ASSIGN_RANDOM_VALUE = _pywrapcp.Solver_ASSIGN_RANDOM_VALUE
|
|
r""" Selects randomly one of the possible values of the selected variable."""
|
|
ASSIGN_CENTER_VALUE = _pywrapcp.Solver_ASSIGN_CENTER_VALUE
|
|
r""" Selects the first possible value which is the closest to the center of the domain of the selected variable. The center is defined as (min + max) / 2."""
|
|
SPLIT_LOWER_HALF = _pywrapcp.Solver_SPLIT_LOWER_HALF
|
|
r""" Split the domain in two around the center, and choose the lower part first."""
|
|
SPLIT_UPPER_HALF = _pywrapcp.Solver_SPLIT_UPPER_HALF
|
|
r""" Split the domain in two around the center, and choose the lower part first."""
|
|
SEQUENCE_DEFAULT = _pywrapcp.Solver_SEQUENCE_DEFAULT
|
|
SEQUENCE_SIMPLE = _pywrapcp.Solver_SEQUENCE_SIMPLE
|
|
CHOOSE_MIN_SLACK_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_MIN_SLACK_RANK_FORWARD
|
|
CHOOSE_RANDOM_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_RANDOM_RANK_FORWARD
|
|
INTERVAL_DEFAULT = _pywrapcp.Solver_INTERVAL_DEFAULT
|
|
r""" The default is INTERVAL_SET_TIMES_FORWARD."""
|
|
INTERVAL_SIMPLE = _pywrapcp.Solver_INTERVAL_SIMPLE
|
|
r""" The simple is INTERVAL_SET_TIMES_FORWARD."""
|
|
INTERVAL_SET_TIMES_FORWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_FORWARD
|
|
r""" Selects the variable with the lowest starting time of all variables, and fixes its starting time to this lowest value."""
|
|
INTERVAL_SET_TIMES_BACKWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_BACKWARD
|
|
r""" Selects the variable with the highest ending time of all variables, and fixes the ending time to this highest values."""
|
|
TWOOPT = _pywrapcp.Solver_TWOOPT
|
|
r""" Operator which reverses a sub-chain of a path. It is called TwoOpt because it breaks two arcs on the path; resulting paths are called two-optimal. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 (where (1, 5) are first and last nodes of the path and can therefore not be moved): 1 -> [3 -> 2] -> 4 -> 5 1 -> [4 -> 3 -> 2] -> 5 1 -> 2 -> [4 -> 3] -> 5"""
|
|
OROPT = _pywrapcp.Solver_OROPT
|
|
r""" Relocate: OROPT and RELOCATE. Operator which moves a sub-chain of a path to another position; the specified chain length is the fixed length of the chains being moved. When this length is 1, the operator simply moves a node to another position. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5, for a chain length of 2 (where (1, 5) are first and last nodes of the path and can therefore not be moved): 1 -> 4 -> [2 -> 3] -> 5 1 -> [3 -> 4] -> 2 -> 5 Using Relocate with chain lengths of 1, 2 and 3 together is equivalent to the OrOpt operator on a path. The OrOpt operator is a limited version of 3Opt (breaks 3 arcs on a path)."""
|
|
RELOCATE = _pywrapcp.Solver_RELOCATE
|
|
r""" Relocate neighborhood with length of 1 (see OROPT comment)."""
|
|
EXCHANGE = _pywrapcp.Solver_EXCHANGE
|
|
r""" Operator which exchanges the positions of two nodes. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 (where (1, 5) are first and last nodes of the path and can therefore not be moved): 1 -> [3] -> [2] -> 4 -> 5 1 -> [4] -> 3 -> [2] -> 5 1 -> 2 -> [4] -> [3] -> 5"""
|
|
CROSS = _pywrapcp.Solver_CROSS
|
|
r""" Operator which cross exchanges the starting chains of 2 paths, including exchanging the whole paths. First and last nodes are not moved. Possible neighbors for the paths 1 -> 2 -> 3 -> 4 -> 5 and 6 -> 7 -> 8 (where (1, 5) and (6, 8) are first and last nodes of the paths and can therefore not be moved): 1 -> [7] -> 3 -> 4 -> 5 6 -> [2] -> 8 1 -> [7] -> 4 -> 5 6 -> [2 -> 3] -> 8 1 -> [7] -> 5 6 -> [2 -> 3 -> 4] -> 8"""
|
|
MAKEACTIVE = _pywrapcp.Solver_MAKEACTIVE
|
|
r""" Operator which inserts an inactive node into a path. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are: 1 -> [5] -> 2 -> 3 -> 4 1 -> 2 -> [5] -> 3 -> 4 1 -> 2 -> 3 -> [5] -> 4"""
|
|
MAKEINACTIVE = _pywrapcp.Solver_MAKEINACTIVE
|
|
r""" Operator which makes path nodes inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are first and last nodes of the path) are: 1 -> 3 -> 4 with 2 inactive 1 -> 2 -> 4 with 3 inactive"""
|
|
MAKECHAININACTIVE = _pywrapcp.Solver_MAKECHAININACTIVE
|
|
r""" Operator which makes a "chain" of path nodes inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are first and last nodes of the path) are: 1 -> 3 -> 4 with 2 inactive 1 -> 2 -> 4 with 3 inactive 1 -> 4 with 2 and 3 inactive"""
|
|
SWAPACTIVE = _pywrapcp.Solver_SWAPACTIVE
|
|
r""" Operator which replaces an active node by an inactive one. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are: 1 -> [5] -> 3 -> 4 with 2 inactive 1 -> 2 -> [5] -> 4 with 3 inactive"""
|
|
EXTENDEDSWAPACTIVE = _pywrapcp.Solver_EXTENDEDSWAPACTIVE
|
|
r""" Operator which makes an inactive node active and an active one inactive. It is similar to SwapActiveOperator except that it tries to insert the inactive node in all possible positions instead of just the position of the node made inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are: 1 -> [5] -> 3 -> 4 with 2 inactive 1 -> 3 -> [5] -> 4 with 2 inactive 1 -> [5] -> 2 -> 4 with 3 inactive 1 -> 2 -> [5] -> 4 with 3 inactive"""
|
|
PATHLNS = _pywrapcp.Solver_PATHLNS
|
|
r""" Operator which relaxes two sub-chains of three consecutive arcs each. Each sub-chain is defined by a start node and the next three arcs. Those six arcs are relaxed to build a new neighbor. PATHLNS explores all possible pairs of starting nodes and so defines n^2 neighbors, n being the number of nodes. Note that the two sub-chains can be part of the same path; they even may overlap."""
|
|
FULLPATHLNS = _pywrapcp.Solver_FULLPATHLNS
|
|
r""" Operator which relaxes one entire path and all inactive nodes, thus defining num_paths neighbors."""
|
|
UNACTIVELNS = _pywrapcp.Solver_UNACTIVELNS
|
|
r""" Operator which relaxes all inactive nodes and one sub-chain of six consecutive arcs. That way the path can be improved by inserting inactive nodes or swapping arcs."""
|
|
INCREMENT = _pywrapcp.Solver_INCREMENT
|
|
r""" Operator which defines one neighbor per variable. Each neighbor tries to increment by one the value of the corresponding variable. When a new solution is found the neighborhood is rebuilt from scratch, i.e., tries to increment values in the variable order. Consider for instance variables x and y. x is incremented one by one to its max, and when it is not possible to increment x anymore, y is incremented once. If this is a solution, then next neighbor tries to increment x."""
|
|
DECREMENT = _pywrapcp.Solver_DECREMENT
|
|
r""" Operator which defines a neighborhood to decrement values. The behavior is the same as INCREMENT, except values are decremented instead of incremented."""
|
|
SIMPLELNS = _pywrapcp.Solver_SIMPLELNS
|
|
r""" Operator which defines one neighbor per variable. Each neighbor relaxes one variable. When a new solution is found the neighborhood is rebuilt from scratch. Consider for instance variables x and y. First x is relaxed and the solver is looking for the best possible solution (with only x relaxed). Then y is relaxed, and the solver is looking for a new solution. If a new solution is found, then the next variable to be relaxed is x."""
|
|
GE = _pywrapcp.Solver_GE
|
|
r""" Move is accepted when the current objective value >= objective.Min."""
|
|
LE = _pywrapcp.Solver_LE
|
|
r""" Move is accepted when the current objective value <= objective.Max."""
|
|
EQ = _pywrapcp.Solver_EQ
|
|
r""" Move is accepted when the current objective value is in the interval objective.Min .. objective.Max."""
|
|
DELAYED_PRIORITY = _pywrapcp.Solver_DELAYED_PRIORITY
|
|
r""" DELAYED_PRIORITY is the lowest priority: Demons will be processed after VAR_PRIORITY and NORMAL_PRIORITY demons."""
|
|
VAR_PRIORITY = _pywrapcp.Solver_VAR_PRIORITY
|
|
r""" VAR_PRIORITY is between DELAYED_PRIORITY and NORMAL_PRIORITY."""
|
|
NORMAL_PRIORITY = _pywrapcp.Solver_NORMAL_PRIORITY
|
|
r""" NORMAL_PRIORITY is the highest priority: Demons will be processed first."""
|
|
|
|
def __init__(self, *args):
|
|
_pywrapcp.Solver_swiginit(self, _pywrapcp.new_Solver(*args))
|
|
|
|
self.__python_constraints = []
|
|
|
|
|
|
|
|
__swig_destroy__ = _pywrapcp.delete_Solver
|
|
|
|
def Parameters(self) -> "operations_research::ConstraintSolverParameters":
|
|
r""" Stored Parameters."""
|
|
return _pywrapcp.Solver_Parameters(self)
|
|
|
|
@staticmethod
|
|
def DefaultSolverParameters() -> "operations_research::ConstraintSolverParameters":
|
|
r""" Create a ConstraintSolverParameters proto with all the default values."""
|
|
return _pywrapcp.Solver_DefaultSolverParameters()
|
|
|
|
def AddConstraint(self, c: 'Constraint') -> "void":
|
|
r""" Adds the constraint 'c' to the model. After calling this method, and until there is a backtrack that undoes the addition, any assignment of variables to values must satisfy the given constraint in order to be considered feasible. There are two fairly different use cases: - the most common use case is modeling: the given constraint is really part of the problem that the user is trying to solve. In this use case, AddConstraint is called outside of search (i.e., with state() == OUTSIDE_SEARCH). Most users should only use AddConstraint in this way. In this case, the constraint will belong to the model forever: it cannot not be removed by backtracking. - a rarer use case is that 'c' is not a real constraint of the model. It may be a constraint generated by a branching decision (a constraint whose goal is to restrict the search space), a symmetry breaking constraint (a constraint that does restrict the search space, but in a way that cannot have an impact on the quality of the solutions in the subtree), or an inferred constraint that, while having no semantic value to the model (it does not restrict the set of solutions), is worth having because we believe it may strengthen the propagation. In these cases, it happens that the constraint is added during the search (i.e., with state() == IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is added during a search, it applies only to the subtree of the search tree rooted at the current node, and will be automatically removed by backtracking. This method does not take ownership of the constraint. If the constraint has been created by any factory method (Solver::MakeXXX), it will automatically be deleted. However, power users who implement their own constraints should do: solver.AddConstraint(solver.RevAlloc(new MyConstraint(...));"""
|
|
return _pywrapcp.Solver_AddConstraint(self, c)
|
|
|
|
def Solve(self, *args) -> "bool":
|
|
return _pywrapcp.Solver_Solve(self, *args)
|
|
|
|
def NewSearch(self, *args) -> "void":
|
|
return _pywrapcp.Solver_NewSearch(self, *args)
|
|
|
|
def NextSolution(self) -> "bool":
|
|
return _pywrapcp.Solver_NextSolution(self)
|
|
|
|
def RestartSearch(self) -> "void":
|
|
return _pywrapcp.Solver_RestartSearch(self)
|
|
|
|
def EndSearch(self) -> "void":
|
|
return _pywrapcp.Solver_EndSearch(self)
|
|
|
|
def SolveAndCommit(self, *args) -> "bool":
|
|
return _pywrapcp.Solver_SolveAndCommit(self, *args)
|
|
|
|
def CheckAssignment(self, solution: 'Assignment') -> "bool":
|
|
r""" Checks whether the given assignment satisfies all relevant constraints."""
|
|
return _pywrapcp.Solver_CheckAssignment(self, solution)
|
|
|
|
def CheckConstraint(self, ct: 'Constraint') -> "bool":
|
|
r""" Checks whether adding this constraint will lead to an immediate failure. It will return false if the model is already inconsistent, or if adding the constraint makes it inconsistent."""
|
|
return _pywrapcp.Solver_CheckConstraint(self, ct)
|
|
|
|
def Fail(self) -> "void":
|
|
r""" Abandon the current branch in the search tree. A backtrack will follow."""
|
|
return _pywrapcp.Solver_Fail(self)
|
|
|
|
@staticmethod
|
|
def MemoryUsage() -> "int64":
|
|
r""" Current memory usage in bytes"""
|
|
return _pywrapcp.Solver_MemoryUsage()
|
|
|
|
def WallTime(self) -> "int64":
|
|
r""" DEPRECATED: Use Now() instead. Time elapsed, in ms since the creation of the solver."""
|
|
return _pywrapcp.Solver_WallTime(self)
|
|
|
|
def Branches(self) -> "int64":
|
|
r""" The number of branches explored since the creation of the solver."""
|
|
return _pywrapcp.Solver_Branches(self)
|
|
|
|
def Solutions(self) -> "int64":
|
|
r""" The number of solutions found since the start of the search."""
|
|
return _pywrapcp.Solver_Solutions(self)
|
|
|
|
def Failures(self) -> "int64":
|
|
r""" The number of failures encountered since the creation of the solver."""
|
|
return _pywrapcp.Solver_Failures(self)
|
|
|
|
def AcceptedNeighbors(self) -> "int64":
|
|
r""" The number of accepted neighbors."""
|
|
return _pywrapcp.Solver_AcceptedNeighbors(self)
|
|
|
|
def Stamp(self) -> "uint64":
|
|
r""" The stamp indicates how many moves in the search tree we have performed. It is useful to detect if we need to update same lazy structures."""
|
|
return _pywrapcp.Solver_Stamp(self)
|
|
|
|
def FailStamp(self) -> "uint64":
|
|
r""" The fail_stamp() is incremented after each backtrack."""
|
|
return _pywrapcp.Solver_FailStamp(self)
|
|
|
|
def IntVar(self, *args) -> "operations_research::IntVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
MakeIntVar will create the best range based int var for the bounds given.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
MakeIntVar will create a variable with the given sparse domain.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
MakeIntVar will create a variable with the given sparse domain.
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
MakeIntVar will create the best range based int var for the bounds given.
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
MakeIntVar will create a variable with the given sparse domain.
|
|
|
|
|
|
|
|
|
*Overload 6:*
|
|
MakeIntVar will create a variable with the given sparse domain.
|
|
"""
|
|
return _pywrapcp.Solver_IntVar(self, *args)
|
|
|
|
def BoolVar(self, *args) -> "operations_research::IntVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
MakeBoolVar will create a variable with a {0, 1} domain.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
MakeBoolVar will create a variable with a {0, 1} domain.
|
|
"""
|
|
return _pywrapcp.Solver_BoolVar(self, *args)
|
|
|
|
def IntConst(self, *args) -> "operations_research::IntVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
IntConst will create a constant expression.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
IntConst will create a constant expression.
|
|
"""
|
|
return _pywrapcp.Solver_IntConst(self, *args)
|
|
|
|
def Sum(self, vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::IntExpr *":
|
|
r""" sum of all vars."""
|
|
return _pywrapcp.Solver_Sum(self, vars)
|
|
|
|
def ScalProd(self, *args) -> "operations_research::IntExpr *":
|
|
r"""
|
|
*Overload 1:*
|
|
scalar product
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
scalar product
|
|
"""
|
|
return _pywrapcp.Solver_ScalProd(self, *args)
|
|
|
|
def MonotonicElement(self, values: 'operations_research::Solver::IndexEvaluator1', increasing: 'bool', index: 'IntVar') -> "operations_research::IntExpr *":
|
|
r""" Function based element. The constraint takes ownership of the callback. The callback must be monotonic. It must be able to cope with any possible value in the domain of 'index' (potentially negative ones too). Furtermore, monotonicity is not checked. Thus giving a non-monotonic function, or specifying an incorrect increasing parameter will result in undefined behavior."""
|
|
return _pywrapcp.Solver_MonotonicElement(self, values, increasing, index)
|
|
|
|
def Element(self, *args) -> "operations_research::IntExpr *":
|
|
r"""
|
|
*Overload 1:*
|
|
values[index]
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
values[index]
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Function-based element. The constraint takes ownership of the callback. The callback must be able to cope with any possible value in the domain of 'index' (potentially negative ones too).
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
2D version of function-based element expression, values(expr1, expr2).
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
vars[expr]
|
|
"""
|
|
return _pywrapcp.Solver_Element(self, *args)
|
|
|
|
def IndexExpression(self, vars: 'std::vector< operations_research::IntVar * > const &', value: 'int64') -> "operations_research::IntExpr *":
|
|
r""" Returns the expression expr such that vars[expr] == value. It assumes that vars are all different."""
|
|
return _pywrapcp.Solver_IndexExpression(self, vars, value)
|
|
|
|
def Min(self, *args) -> "operations_research::IntExpr *":
|
|
r"""
|
|
*Overload 1:*
|
|
std::min(vars)
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
std::min (left, right)
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
std::min(expr, value)
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
std::min(expr, value)
|
|
"""
|
|
return _pywrapcp.Solver_Min(self, *args)
|
|
|
|
def Max(self, *args) -> "operations_research::IntExpr *":
|
|
r"""
|
|
*Overload 1:*
|
|
std::max(vars)
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
std::max(left, right)
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
std::max(expr, value)
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
std::max(expr, value)
|
|
"""
|
|
return _pywrapcp.Solver_Max(self, *args)
|
|
|
|
def ConvexPiecewiseExpr(self, expr: 'IntExpr', early_cost: 'int64', early_date: 'int64', late_date: 'int64', late_cost: 'int64') -> "operations_research::IntExpr *":
|
|
r""" Convex piecewise function."""
|
|
return _pywrapcp.Solver_ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost)
|
|
|
|
def SemiContinuousExpr(self, expr: 'IntExpr', fixed_charge: 'int64', step: 'int64') -> "operations_research::IntExpr *":
|
|
r""" Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) a >= 0 and b >= 0"""
|
|
return _pywrapcp.Solver_SemiContinuousExpr(self, expr, fixed_charge, step)
|
|
|
|
def ConditionalExpression(self, condition: 'IntVar', expr: 'IntExpr', unperformed_value: 'int64') -> "operations_research::IntExpr *":
|
|
r""" Conditional Expr condition ? expr : unperformed_value"""
|
|
return _pywrapcp.Solver_ConditionalExpression(self, condition, expr, unperformed_value)
|
|
|
|
def TrueConstraint(self) -> "operations_research::Constraint *":
|
|
r""" This constraint always succeeds."""
|
|
return _pywrapcp.Solver_TrueConstraint(self)
|
|
|
|
def FalseConstraint(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_FalseConstraint(self, *args)
|
|
|
|
def IsEqualCstCt(self, var: 'IntExpr', value: 'int64', boolvar: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" boolvar == (var == value)"""
|
|
return _pywrapcp.Solver_IsEqualCstCt(self, var, value, boolvar)
|
|
|
|
def IsEqualCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var == value)"""
|
|
return _pywrapcp.Solver_IsEqualCstVar(self, var, value)
|
|
|
|
def IsEqualCt(self, v1: 'IntExpr', v2: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (v1 == v2)"""
|
|
return _pywrapcp.Solver_IsEqualCt(self, v1, v2, b)
|
|
|
|
def IsEqualVar(self, v1: 'IntExpr', v2: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (v1 == v2)"""
|
|
return _pywrapcp.Solver_IsEqualVar(self, v1, v2)
|
|
|
|
def IsDifferentCstCt(self, var: 'IntExpr', value: 'int64', boolvar: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" boolvar == (var != value)"""
|
|
return _pywrapcp.Solver_IsDifferentCstCt(self, var, value, boolvar)
|
|
|
|
def IsDifferentCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var != value)"""
|
|
return _pywrapcp.Solver_IsDifferentCstVar(self, var, value)
|
|
|
|
def IsDifferentVar(self, v1: 'IntExpr', v2: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (v1 != v2)"""
|
|
return _pywrapcp.Solver_IsDifferentVar(self, v1, v2)
|
|
|
|
def IsDifferentCt(self, v1: 'IntExpr', v2: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (v1 != v2)"""
|
|
return _pywrapcp.Solver_IsDifferentCt(self, v1, v2, b)
|
|
|
|
def IsLessOrEqualCstCt(self, var: 'IntExpr', value: 'int64', boolvar: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" boolvar == (var <= value)"""
|
|
return _pywrapcp.Solver_IsLessOrEqualCstCt(self, var, value, boolvar)
|
|
|
|
def IsLessOrEqualCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var <= value)"""
|
|
return _pywrapcp.Solver_IsLessOrEqualCstVar(self, var, value)
|
|
|
|
def IsLessOrEqualVar(self, left: 'IntExpr', right: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (left <= right)"""
|
|
return _pywrapcp.Solver_IsLessOrEqualVar(self, left, right)
|
|
|
|
def IsLessOrEqualCt(self, left: 'IntExpr', right: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (left <= right)"""
|
|
return _pywrapcp.Solver_IsLessOrEqualCt(self, left, right, b)
|
|
|
|
def IsGreaterOrEqualCstCt(self, var: 'IntExpr', value: 'int64', boolvar: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" boolvar == (var >= value)"""
|
|
return _pywrapcp.Solver_IsGreaterOrEqualCstCt(self, var, value, boolvar)
|
|
|
|
def IsGreaterOrEqualCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var >= value)"""
|
|
return _pywrapcp.Solver_IsGreaterOrEqualCstVar(self, var, value)
|
|
|
|
def IsGreaterOrEqualVar(self, left: 'IntExpr', right: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (left >= right)"""
|
|
return _pywrapcp.Solver_IsGreaterOrEqualVar(self, left, right)
|
|
|
|
def IsGreaterOrEqualCt(self, left: 'IntExpr', right: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (left >= right)"""
|
|
return _pywrapcp.Solver_IsGreaterOrEqualCt(self, left, right, b)
|
|
|
|
def IsGreaterCstCt(self, v: 'IntExpr', c: 'int64', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (v > c)"""
|
|
return _pywrapcp.Solver_IsGreaterCstCt(self, v, c, b)
|
|
|
|
def IsGreaterCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var > value)"""
|
|
return _pywrapcp.Solver_IsGreaterCstVar(self, var, value)
|
|
|
|
def IsGreaterVar(self, left: 'IntExpr', right: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (left > right)"""
|
|
return _pywrapcp.Solver_IsGreaterVar(self, left, right)
|
|
|
|
def IsGreaterCt(self, left: 'IntExpr', right: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (left > right)"""
|
|
return _pywrapcp.Solver_IsGreaterCt(self, left, right, b)
|
|
|
|
def IsLessCstCt(self, v: 'IntExpr', c: 'int64', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (v < c)"""
|
|
return _pywrapcp.Solver_IsLessCstCt(self, v, c, b)
|
|
|
|
def IsLessCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var < value)"""
|
|
return _pywrapcp.Solver_IsLessCstVar(self, var, value)
|
|
|
|
def IsLessVar(self, left: 'IntExpr', right: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (left < right)"""
|
|
return _pywrapcp.Solver_IsLessVar(self, left, right)
|
|
|
|
def IsLessCt(self, left: 'IntExpr', right: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (left < right)"""
|
|
return _pywrapcp.Solver_IsLessCt(self, left, right, b)
|
|
|
|
def SumLessOrEqual(self, vars: 'std::vector< operations_research::IntVar * > const &', cst: 'int64') -> "operations_research::Constraint *":
|
|
r""" Variation on arrays."""
|
|
return _pywrapcp.Solver_SumLessOrEqual(self, vars, cst)
|
|
|
|
def SumGreaterOrEqual(self, vars: 'std::vector< operations_research::IntVar * > const &', cst: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_SumGreaterOrEqual(self, vars, cst)
|
|
|
|
def SumEquality(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_SumEquality(self, *args)
|
|
|
|
def ScalProdEquality(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_ScalProdEquality(self, *args)
|
|
|
|
def ScalProdGreaterOrEqual(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_ScalProdGreaterOrEqual(self, *args)
|
|
|
|
def ScalProdLessOrEqual(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_ScalProdLessOrEqual(self, *args)
|
|
|
|
def MinEquality(self, vars: 'std::vector< operations_research::IntVar * > const &', min_var: 'IntVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_MinEquality(self, vars, min_var)
|
|
|
|
def MaxEquality(self, vars: 'std::vector< operations_research::IntVar * > const &', max_var: 'IntVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_MaxEquality(self, vars, max_var)
|
|
|
|
def ElementEquality(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_ElementEquality(self, *args)
|
|
|
|
def AbsEquality(self, var: 'IntVar', abs_var: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" Creates the constraint abs(var) == abs_var."""
|
|
return _pywrapcp.Solver_AbsEquality(self, var, abs_var)
|
|
|
|
def IndexOfConstraint(self, vars: 'std::vector< operations_research::IntVar * > const &', index: 'IntVar', target: 'int64') -> "operations_research::Constraint *":
|
|
r""" This constraint is a special case of the element constraint with an array of integer variables, where the variables are all different and the index variable is constrained such that vars[index] == target."""
|
|
return _pywrapcp.Solver_IndexOfConstraint(self, vars, index, target)
|
|
|
|
def ConstraintInitialPropagateCallback(self, ct: 'Constraint') -> "operations_research::Demon *":
|
|
r""" This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct'."""
|
|
return _pywrapcp.Solver_ConstraintInitialPropagateCallback(self, ct)
|
|
|
|
def DelayedConstraintInitialPropagateCallback(self, ct: 'Constraint') -> "operations_research::Demon *":
|
|
r""" This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct' with low priority."""
|
|
return _pywrapcp.Solver_DelayedConstraintInitialPropagateCallback(self, ct)
|
|
|
|
def ClosureDemon(self, closure: 'operations_research::Solver::Closure') -> "operations_research::Demon *":
|
|
r""" Creates a demon from a closure."""
|
|
return _pywrapcp.Solver_ClosureDemon(self, closure)
|
|
|
|
def BetweenCt(self, expr: 'IntExpr', l: 'int64', u: 'int64') -> "operations_research::Constraint *":
|
|
r""" (l <= expr <= u)"""
|
|
return _pywrapcp.Solver_BetweenCt(self, expr, l, u)
|
|
|
|
def IsBetweenCt(self, expr: 'IntExpr', l: 'int64', u: 'int64', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (l <= expr <= u)"""
|
|
return _pywrapcp.Solver_IsBetweenCt(self, expr, l, u, b)
|
|
|
|
def IsBetweenVar(self, v: 'IntExpr', l: 'int64', u: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.Solver_IsBetweenVar(self, v, l, u)
|
|
|
|
def MemberCt(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_MemberCt(self, *args)
|
|
|
|
def NotMemberCt(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
expr not in set.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
expr should not be in the list of forbidden intervals [start[i]..end[i]].
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
expr should not be in the list of forbidden intervals [start[i]..end[i]].
|
|
"""
|
|
return _pywrapcp.Solver_NotMemberCt(self, *args)
|
|
|
|
def IsMemberCt(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_IsMemberCt(self, *args)
|
|
|
|
def IsMemberVar(self, *args) -> "operations_research::IntVar *":
|
|
return _pywrapcp.Solver_IsMemberVar(self, *args)
|
|
|
|
def Count(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
|{i | vars[i] == value}| == max_count
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
|{i | vars[i] == value}| == max_count
|
|
"""
|
|
return _pywrapcp.Solver_Count(self, *args)
|
|
|
|
def Distribute(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
Aggregated version of count: |{i | v[i] == values[j]}| == cards[j]
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Aggregated version of count: |{i | v[i] == values[j]}| == cards[j]
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Aggregated version of count: |{i | v[i] == j}| == cards[j]
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == j}| <= card_max[j]
|
|
|
|
|
|
|
|
|
*Overload 6:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == j}| <= card_max[j]
|
|
|
|
|
|
|
|
|
*Overload 7:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
|
|
|
|
|
|
|
|
|
*Overload 8:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
|
|
"""
|
|
return _pywrapcp.Solver_Distribute(self, *args)
|
|
|
|
def Deviation(self, vars: 'std::vector< operations_research::IntVar * > const &', deviation_var: 'IntVar', total_sum: 'int64') -> "operations_research::Constraint *":
|
|
r""" Deviation constraint: sum_i |n * vars[i] - total_sum| <= deviation_var and sum_i vars[i] == total_sum n = #vars"""
|
|
return _pywrapcp.Solver_Deviation(self, vars, deviation_var, total_sum)
|
|
|
|
def AllDifferent(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
All variables are pairwise different. This corresponds to the stronger version of the propagation algorithm.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
All variables are pairwise different. If 'stronger_propagation' is true, stronger, and potentially slower propagation will occur. This API will be deprecated in the future.
|
|
"""
|
|
return _pywrapcp.Solver_AllDifferent(self, *args)
|
|
|
|
def AllDifferentExcept(self, vars: 'std::vector< operations_research::IntVar * > const &', escape_value: 'int64') -> "operations_research::Constraint *":
|
|
r""" All variables are pairwise different, unless they are assigned to the escape value."""
|
|
return _pywrapcp.Solver_AllDifferentExcept(self, vars, escape_value)
|
|
|
|
def SortingConstraint(self, vars: 'std::vector< operations_research::IntVar * > const &', sorted: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint binding the arrays of variables "vars" and "sorted_vars": sorted_vars[0] must be equal to the minimum of all variables in vars, and so on: the value of sorted_vars[i] must be equal to the i-th value of variables invars. This constraint propagates in both directions: from "vars" to "sorted_vars" and vice-versa. Behind the scenes, this constraint maintains that: - sorted is always increasing. - whatever the values of vars, there exists a permutation that injects its values into the sorted variables. For more info, please have a look at: https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf"""
|
|
return _pywrapcp.Solver_SortingConstraint(self, vars, sorted)
|
|
|
|
def LexicalLess(self, left: 'std::vector< operations_research::IntVar * > const &', right: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" std::vector<IntVar*>* const sorted); Creates a constraint that enforces that left is lexicographically less than right."""
|
|
return _pywrapcp.Solver_LexicalLess(self, left, right)
|
|
|
|
def LexicalLessOrEqual(self, left: 'std::vector< operations_research::IntVar * > const &', right: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint that enforces that left is lexicographically less than or equal to right."""
|
|
return _pywrapcp.Solver_LexicalLessOrEqual(self, left, right)
|
|
|
|
def InversePermutationConstraint(self, left: 'std::vector< operations_research::IntVar * > const &', right: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint that enforces that 'left' and 'right' both represent permutations of [0..left.size()-1], and that 'right' is the inverse permutation of 'left', i.e. for all i in [0..left.size()-1], right[left[i]] = i."""
|
|
return _pywrapcp.Solver_InversePermutationConstraint(self, left, right)
|
|
|
|
def NullIntersect(self, first_vars: 'std::vector< operations_research::IntVar * > const &', second_vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint that states that all variables in the first vector are different from all variables in the second group. Thus the set of values in the first vector does not intersect with the set of values in the second vector."""
|
|
return _pywrapcp.Solver_NullIntersect(self, first_vars, second_vars)
|
|
|
|
def NullIntersectExcept(self, first_vars: 'std::vector< operations_research::IntVar * > const &', second_vars: 'std::vector< operations_research::IntVar * > const &', escape_value: 'int64') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint that states that all variables in the first vector are different from all variables from the second group, unless they are assigned to the escape value. Thus the set of values in the first vector minus the escape value does not intersect with the set of values in the second vector."""
|
|
return _pywrapcp.Solver_NullIntersectExcept(self, first_vars, second_vars, escape_value)
|
|
|
|
def Circuit(self, nexts: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Force the "nexts" variable to create a complete Hamiltonian path."""
|
|
return _pywrapcp.Solver_Circuit(self, nexts)
|
|
|
|
def SubCircuit(self, nexts: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Force the "nexts" variable to create a complete Hamiltonian path for those that do not loop upon themselves."""
|
|
return _pywrapcp.Solver_SubCircuit(self, nexts)
|
|
|
|
def DelayedPathCumul(self, nexts: 'std::vector< operations_research::IntVar * > const &', active: 'std::vector< operations_research::IntVar * > const &', cumuls: 'std::vector< operations_research::IntVar * > const &', transits: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Delayed version of the same constraint: propagation on the nexts variables is delayed until all constraints have propagated."""
|
|
return _pywrapcp.Solver_DelayedPathCumul(self, nexts, active, cumuls, transits)
|
|
|
|
def PathCumul(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transits[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.
|
|
"""
|
|
return _pywrapcp.Solver_PathCumul(self, *args)
|
|
|
|
def AllowedAssignments(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
This method creates a constraint where the graph of the relation between the variables is given in extension. There are 'arity' variables involved in the relation and the graph is given by a integer tuple set.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Compatibility layer for Python API.
|
|
"""
|
|
return _pywrapcp.Solver_AllowedAssignments(self, *args)
|
|
|
|
def TransitionConstraint(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_TransitionConstraint(self, *args)
|
|
|
|
def NonOverlappingBoxesConstraint(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_NonOverlappingBoxesConstraint(self, *args)
|
|
|
|
def Pack(self, vars: 'std::vector< operations_research::IntVar * > const &', number_of_bins: 'int') -> "operations_research::Pack *":
|
|
r""" This constraint packs all variables onto 'number_of_bins' variables. For any given variable, a value of 'number_of_bins' indicates that the variable is not assigned to any bin. Dimensions, i.e., cumulative constraints on this packing, can be added directly from the pack class."""
|
|
return _pywrapcp.Solver_Pack(self, vars, number_of_bins)
|
|
|
|
def FixedDurationIntervalVar(self, *args) -> "operations_research::IntervalVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates an interval var with a fixed duration. The duration must be greater than 0. If optional is true, then the interval can be performed or unperformed. If optional is false, then the interval is always performed.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a performed interval var with a fixed duration. The duration must be greater than 0.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Creates an interval var with a fixed duration, and performed_variable. The duration must be greater than 0.
|
|
"""
|
|
return _pywrapcp.Solver_FixedDurationIntervalVar(self, *args)
|
|
|
|
def FixedInterval(self, start: 'int64', duration: 'int64', name: 'std::string const &') -> "operations_research::IntervalVar *":
|
|
r""" Creates a fixed and performed interval."""
|
|
return _pywrapcp.Solver_FixedInterval(self, start, duration, name)
|
|
|
|
def IntervalVar(self, start_min: 'int64', start_max: 'int64', duration_min: 'int64', duration_max: 'int64', end_min: 'int64', end_max: 'int64', optional: 'bool', name: 'std::string const &') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var by specifying the bounds on start, duration, and end."""
|
|
return _pywrapcp.Solver_IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name)
|
|
|
|
def MirrorInterval(self, interval_var: 'IntervalVar') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var that is the mirror image of the given one, that is, the interval var obtained by reversing the axis."""
|
|
return _pywrapcp.Solver_MirrorInterval(self, interval_var)
|
|
|
|
def FixedDurationStartSyncedOnStartIntervalVar(self, interval_var: 'IntervalVar', duration: 'int64', offset: 'int64') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var with a fixed duration whose start is synchronized with the start of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable."""
|
|
return _pywrapcp.Solver_FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset)
|
|
|
|
def FixedDurationStartSyncedOnEndIntervalVar(self, interval_var: 'IntervalVar', duration: 'int64', offset: 'int64') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var with a fixed duration whose start is synchronized with the end of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable."""
|
|
return _pywrapcp.Solver_FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset)
|
|
|
|
def FixedDurationEndSyncedOnStartIntervalVar(self, interval_var: 'IntervalVar', duration: 'int64', offset: 'int64') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var with a fixed duration whose end is synchronized with the start of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable."""
|
|
return _pywrapcp.Solver_FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset)
|
|
|
|
def FixedDurationEndSyncedOnEndIntervalVar(self, interval_var: 'IntervalVar', duration: 'int64', offset: 'int64') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var with a fixed duration whose end is synchronized with the end of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable."""
|
|
return _pywrapcp.Solver_FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset)
|
|
|
|
def IntervalRelaxedMin(self, interval_var: 'IntervalVar') -> "operations_research::IntervalVar *":
|
|
r""" Creates and returns an interval variable that wraps around the given one, relaxing the min start and end. Relaxing means making unbounded when optional. If the variable is non-optional, this method returns interval_var. More precisely, such an interval variable behaves as follows: * When the underlying must be performed, the returned interval variable behaves exactly as the underlying; * When the underlying may or may not be performed, the returned interval variable behaves like the underlying, except that it is unbounded on the min side; * When the underlying cannot be performed, the returned interval variable is of duration 0 and must be performed in an interval unbounded on both sides. This is very useful to implement propagators that may only modify the start max or end max."""
|
|
return _pywrapcp.Solver_IntervalRelaxedMin(self, interval_var)
|
|
|
|
def IntervalRelaxedMax(self, interval_var: 'IntervalVar') -> "operations_research::IntervalVar *":
|
|
r""" Creates and returns an interval variable that wraps around the given one, relaxing the max start and end. Relaxing means making unbounded when optional. If the variable is non optional, this method returns interval_var. More precisely, such an interval variable behaves as follows: * When the underlying must be performed, the returned interval variable behaves exactly as the underlying; * When the underlying may or may not be performed, the returned interval variable behaves like the underlying, except that it is unbounded on the max side; * When the underlying cannot be performed, the returned interval variable is of duration 0 and must be performed in an interval unbounded on both sides. This is very useful for implementing propagators that may only modify the start min or end min."""
|
|
return _pywrapcp.Solver_IntervalRelaxedMax(self, interval_var)
|
|
|
|
def TemporalDisjunction(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
This constraint implements a temporal disjunction between two interval vars t1 and t2. 'alt' indicates which alternative was chosen (alt == 0 is equivalent to t1 before t2).
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This constraint implements a temporal disjunction between two interval vars.
|
|
"""
|
|
return _pywrapcp.Solver_TemporalDisjunction(self, *args)
|
|
|
|
def DisjunctiveConstraint(self, intervals: 'std::vector< operations_research::IntervalVar * > const &', name: 'std::string const &') -> "operations_research::DisjunctiveConstraint *":
|
|
r""" This constraint forces all interval vars into an non-overlapping sequence. Intervals with zero duration can be scheduled anywhere."""
|
|
return _pywrapcp.Solver_DisjunctiveConstraint(self, intervals, name)
|
|
|
|
def Cumulative(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
This constraint enforces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should be positive.
|
|
|
|
|
|
|
|
|
*Overload 6:*
|
|
This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should be positive.
|
|
"""
|
|
return _pywrapcp.Solver_Cumulative(self, *args)
|
|
|
|
def Cover(self, vars: 'std::vector< operations_research::IntervalVar * > const &', target_var: 'IntervalVar') -> "operations_research::Constraint *":
|
|
r""" This constraint states that the target_var is the convex hull of the intervals. If none of the interval variables is performed, then the target var is unperformed too. Also, if the target variable is unperformed, then all the intervals variables are unperformed too."""
|
|
return _pywrapcp.Solver_Cover(self, vars, target_var)
|
|
|
|
def Assignment(self, *args) -> "operations_research::Assignment *":
|
|
r"""
|
|
*Overload 1:*
|
|
This method creates an empty assignment.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This method creates an assignment which is a copy of 'a'.
|
|
"""
|
|
return _pywrapcp.Solver_Assignment(self, *args)
|
|
|
|
def FirstSolutionCollector(self, *args) -> "operations_research::SolutionCollector *":
|
|
r"""
|
|
*Overload 1:*
|
|
Collect the first solution of the search.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Collect the first solution of the search. The variables will need to be added later.
|
|
"""
|
|
return _pywrapcp.Solver_FirstSolutionCollector(self, *args)
|
|
|
|
def LastSolutionCollector(self, *args) -> "operations_research::SolutionCollector *":
|
|
r"""
|
|
*Overload 1:*
|
|
Collect the last solution of the search.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Collect the last solution of the search. The variables will need to be added later.
|
|
"""
|
|
return _pywrapcp.Solver_LastSolutionCollector(self, *args)
|
|
|
|
def BestValueSolutionCollector(self, *args) -> "operations_research::SolutionCollector *":
|
|
r"""
|
|
*Overload 1:*
|
|
Collect the solution corresponding to the optimal value of the objective of 'assignment'; if 'assignment' does not have an objective no solution is collected. This collector only collects one solution corresponding to the best objective value (the first one found).
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Collect the solution corresponding to the optimal value of the objective of 'assignment'; if 'assignment' does not have an objective no solution is collected. This collector only collects one solution corresponding to the best objective value (the first one found). The variables will need to be added later.
|
|
"""
|
|
return _pywrapcp.Solver_BestValueSolutionCollector(self, *args)
|
|
|
|
def AllSolutionCollector(self, *args) -> "operations_research::SolutionCollector *":
|
|
r"""
|
|
*Overload 1:*
|
|
Collect all solutions of the search.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Collect all solutions of the search. The variables will need to be added later.
|
|
"""
|
|
return _pywrapcp.Solver_AllSolutionCollector(self, *args)
|
|
|
|
def Minimize(self, v: 'IntVar', step: 'int64') -> "operations_research::OptimizeVar *":
|
|
r""" Creates a minimization objective."""
|
|
return _pywrapcp.Solver_Minimize(self, v, step)
|
|
|
|
def Maximize(self, v: 'IntVar', step: 'int64') -> "operations_research::OptimizeVar *":
|
|
r""" Creates a maximization objective."""
|
|
return _pywrapcp.Solver_Maximize(self, v, step)
|
|
|
|
def Optimize(self, maximize: 'bool', v: 'IntVar', step: 'int64') -> "operations_research::OptimizeVar *":
|
|
r""" Creates a objective with a given sense (true = maximization)."""
|
|
return _pywrapcp.Solver_Optimize(self, maximize, v, step)
|
|
|
|
def WeightedMinimize(self, *args) -> "operations_research::OptimizeVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a minimization weighted objective. The actual objective is scalar_prod(sub_objectives, weights).
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a minimization weighted objective. The actual objective is scalar_prod(sub_objectives, weights).
|
|
"""
|
|
return _pywrapcp.Solver_WeightedMinimize(self, *args)
|
|
|
|
def WeightedMaximize(self, *args) -> "operations_research::OptimizeVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a maximization weigthed objective.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a maximization weigthed objective.
|
|
"""
|
|
return _pywrapcp.Solver_WeightedMaximize(self, *args)
|
|
|
|
def WeightedOptimize(self, *args) -> "operations_research::OptimizeVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a weighted objective with a given sense (true = maximization).
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a weighted objective with a given sense (true = maximization).
|
|
"""
|
|
return _pywrapcp.Solver_WeightedOptimize(self, *args)
|
|
|
|
def TabuSearch(self, maximize: 'bool', v: 'IntVar', step: 'int64', vars: 'std::vector< operations_research::IntVar * > const &', keep_tenure: 'int64', forbid_tenure: 'int64', tabu_factor: 'double') -> "operations_research::SearchMonitor *":
|
|
r""" MetaHeuristics which try to get the search out of local optima. Creates a Tabu Search monitor. In the context of local search the behavior is similar to MakeOptimize(), creating an objective in a given sense. The behavior differs once a local optimum is reached: thereafter solutions which degrade the value of the objective are allowed if they are not "tabu". A solution is "tabu" if it doesn't respect the following rules: - improving the best solution found so far - variables in the "keep" list must keep their value, variables in the "forbid" list must not take the value they have in the list. Variables with new values enter the tabu lists after each new solution found and leave the lists after a given number of iterations (called tenure). Only the variables passed to the method can enter the lists. The tabu criterion is softened by the tabu factor which gives the number of "tabu" violations which is tolerated; a factor of 1 means no violations allowed; a factor of 0 means all violations are allowed."""
|
|
return _pywrapcp.Solver_TabuSearch(self, maximize, v, step, vars, keep_tenure, forbid_tenure, tabu_factor)
|
|
|
|
def SimulatedAnnealing(self, maximize: 'bool', v: 'IntVar', step: 'int64', initial_temperature: 'int64') -> "operations_research::SearchMonitor *":
|
|
r""" Creates a Simulated Annealing monitor."""
|
|
return _pywrapcp.Solver_SimulatedAnnealing(self, maximize, v, step, initial_temperature)
|
|
|
|
def LubyRestart(self, scale_factor: 'int') -> "operations_research::SearchMonitor *":
|
|
r""" This search monitor will restart the search periodically. At the iteration n, it will restart after scale_factor * Luby(n) failures where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...)."""
|
|
return _pywrapcp.Solver_LubyRestart(self, scale_factor)
|
|
|
|
def ConstantRestart(self, frequency: 'int') -> "operations_research::SearchMonitor *":
|
|
r""" This search monitor will restart the search periodically after 'frequency' failures."""
|
|
return _pywrapcp.Solver_ConstantRestart(self, frequency)
|
|
|
|
def TimeLimit(self, time_in_ms: 'int64') -> "operations_research::RegularLimit *":
|
|
r""" Creates a search limit that constrains the running time given in milliseconds."""
|
|
return _pywrapcp.Solver_TimeLimit(self, time_in_ms)
|
|
|
|
def BranchesLimit(self, branches: 'int64') -> "operations_research::RegularLimit *":
|
|
r""" Creates a search limit that constrains the number of branches explored in the search tree."""
|
|
return _pywrapcp.Solver_BranchesLimit(self, branches)
|
|
|
|
def FailuresLimit(self, failures: 'int64') -> "operations_research::RegularLimit *":
|
|
r""" Creates a search limit that constrains the number of failures that can happen when exploring the search tree."""
|
|
return _pywrapcp.Solver_FailuresLimit(self, failures)
|
|
|
|
def SolutionsLimit(self, solutions: 'int64') -> "operations_research::RegularLimit *":
|
|
r""" Creates a search limit that constrains the number of solutions found during the search."""
|
|
return _pywrapcp.Solver_SolutionsLimit(self, solutions)
|
|
|
|
def Limit(self, *args) -> "operations_research::SearchLimit *":
|
|
r"""
|
|
*Overload 1:*
|
|
Limits the search with the 'time', 'branches', 'failures' and 'solutions' limits.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Version reducing calls to wall timer by estimating number of remaining calls.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Creates a search limit which can either apply cumulatively or search-by-search.
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
Creates a search limit from its protobuf description
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
Creates a search limit that is reached when either of the underlying limit is reached. That is, the returned limit is more stringent than both argument limits.
|
|
"""
|
|
return _pywrapcp.Solver_Limit(self, *args)
|
|
|
|
def CustomLimit(self, limiter: 'std::function< bool () >') -> "operations_research::SearchLimit *":
|
|
r""" Callback-based search limit. Search stops when limiter returns true; if this happens at a leaf the corresponding solution will be rejected."""
|
|
return _pywrapcp.Solver_CustomLimit(self, limiter)
|
|
|
|
def SearchLog(self, *args) -> "operations_research::SearchMonitor *":
|
|
return _pywrapcp.Solver_SearchLog(self, *args)
|
|
|
|
def SearchTrace(self, prefix: 'std::string const &') -> "operations_research::SearchMonitor *":
|
|
r""" Creates a search monitor that will trace precisely the behavior of the search. Use this only for low level debugging."""
|
|
return _pywrapcp.Solver_SearchTrace(self, prefix)
|
|
|
|
def PrintModelVisitor(self) -> "operations_research::ModelVisitor *":
|
|
r""" Prints the model."""
|
|
return _pywrapcp.Solver_PrintModelVisitor(self)
|
|
|
|
def StatisticsModelVisitor(self) -> "operations_research::ModelVisitor *":
|
|
r""" Displays some nice statistics on the model."""
|
|
return _pywrapcp.Solver_StatisticsModelVisitor(self)
|
|
|
|
def AssignVariableValue(self, var: 'IntVar', val: 'int64') -> "operations_research::Decision *":
|
|
r""" Decisions."""
|
|
return _pywrapcp.Solver_AssignVariableValue(self, var, val)
|
|
|
|
def VariableLessOrEqualValue(self, var: 'IntVar', value: 'int64') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_VariableLessOrEqualValue(self, var, value)
|
|
|
|
def VariableGreaterOrEqualValue(self, var: 'IntVar', value: 'int64') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_VariableGreaterOrEqualValue(self, var, value)
|
|
|
|
def SplitVariableDomain(self, var: 'IntVar', val: 'int64', start_with_lower_half: 'bool') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_SplitVariableDomain(self, var, val, start_with_lower_half)
|
|
|
|
def AssignVariableValueOrFail(self, var: 'IntVar', value: 'int64') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_AssignVariableValueOrFail(self, var, value)
|
|
|
|
def AssignVariablesValues(self, vars: 'std::vector< operations_research::IntVar * > const &', values: 'std::vector< int64 > const &') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_AssignVariablesValues(self, vars, values)
|
|
|
|
def FailDecision(self) -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_FailDecision(self)
|
|
|
|
def Decision(self, apply: 'operations_research::Solver::Action', refute: 'operations_research::Solver::Action') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_Decision(self, apply, refute)
|
|
|
|
def Compose(self, dbs: 'std::vector< operations_research::DecisionBuilder * > const &') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_Compose(self, dbs)
|
|
|
|
def Try(self, dbs: 'std::vector< operations_research::DecisionBuilder * > const &') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_Try(self, dbs)
|
|
|
|
def DefaultPhase(self, *args) -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_DefaultPhase(self, *args)
|
|
|
|
def ScheduleOrPostpone(self, var: 'IntervalVar', est: 'int64', marker: 'int64 *const') -> "operations_research::Decision *":
|
|
r""" Returns a decision that tries to schedule a task at a given time. On the Apply branch, it will set that interval var as performed and set its start to 'est'. On the Refute branch, it will just update the 'marker' to 'est' + 1. This decision is used in the INTERVAL_SET_TIMES_FORWARD strategy."""
|
|
return _pywrapcp.Solver_ScheduleOrPostpone(self, var, est, marker)
|
|
|
|
def ScheduleOrExpedite(self, var: 'IntervalVar', est: 'int64', marker: 'int64 *const') -> "operations_research::Decision *":
|
|
r""" Returns a decision that tries to schedule a task at a given time. On the Apply branch, it will set that interval var as performed and set its end to 'est'. On the Refute branch, it will just update the 'marker' to 'est' - 1. This decision is used in the INTERVAL_SET_TIMES_BACKWARD strategy."""
|
|
return _pywrapcp.Solver_ScheduleOrExpedite(self, var, est, marker)
|
|
|
|
def RankFirstInterval(self, sequence: 'SequenceVar', index: 'int') -> "operations_research::Decision *":
|
|
r""" Returns a decision that tries to rank first the ith interval var in the sequence variable."""
|
|
return _pywrapcp.Solver_RankFirstInterval(self, sequence, index)
|
|
|
|
def RankLastInterval(self, sequence: 'SequenceVar', index: 'int') -> "operations_research::Decision *":
|
|
r""" Returns a decision that tries to rank last the ith interval var in the sequence variable."""
|
|
return _pywrapcp.Solver_RankLastInterval(self, sequence, index)
|
|
|
|
def Phase(self, *args) -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_Phase(self, *args)
|
|
|
|
def DecisionBuilderFromAssignment(self, assignment: 'Assignment', db: 'DecisionBuilder', vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::DecisionBuilder *":
|
|
r""" Returns a decision builder for which the left-most leaf corresponds to assignment, the rest of the tree being explored using 'db'."""
|
|
return _pywrapcp.Solver_DecisionBuilderFromAssignment(self, assignment, db, vars)
|
|
|
|
def ConstraintAdder(self, ct: 'Constraint') -> "operations_research::DecisionBuilder *":
|
|
r""" Returns a decision builder that will add the given constraint to the model."""
|
|
return _pywrapcp.Solver_ConstraintAdder(self, ct)
|
|
|
|
def SolveOnce(self, db: 'DecisionBuilder', monitors: 'std::vector< operations_research::SearchMonitor * > const &') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_SolveOnce(self, db, monitors)
|
|
|
|
def NestedOptimize(self, *args) -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_NestedOptimize(self, *args)
|
|
|
|
def RestoreAssignment(self, assignment: 'Assignment') -> "operations_research::DecisionBuilder *":
|
|
r""" Returns a DecisionBuilder which restores an Assignment (calls void Assignment::Restore())"""
|
|
return _pywrapcp.Solver_RestoreAssignment(self, assignment)
|
|
|
|
def StoreAssignment(self, assignment: 'Assignment') -> "operations_research::DecisionBuilder *":
|
|
r""" Returns a DecisionBuilder which stores an Assignment (calls void Assignment::Store())"""
|
|
return _pywrapcp.Solver_StoreAssignment(self, assignment)
|
|
|
|
def Operator(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
return _pywrapcp.Solver_Operator(self, *args)
|
|
|
|
def RandomLnsOperator(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
return _pywrapcp.Solver_RandomLnsOperator(self, *args)
|
|
|
|
def MoveTowardTargetOperator(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a local search operator that tries to move the assignment of some variables toward a target. The target is given as an Assignment. This operator generates neighbors in which the only difference compared to the current state is that one variable that belongs to the target assignment is set to its target value.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a local search operator that tries to move the assignment of some variables toward a target. The target is given either as two vectors: a vector of variables and a vector of associated target values. The two vectors should be of the same length. This operator generates neighbors in which the only difference compared to the current state is that one variable that belongs to the given vector is set to its target value.
|
|
"""
|
|
return _pywrapcp.Solver_MoveTowardTargetOperator(self, *args)
|
|
|
|
def ConcatenateOperators(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
return _pywrapcp.Solver_ConcatenateOperators(self, *args)
|
|
|
|
def RandomConcatenateOperators(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
r"""
|
|
*Overload 1:*
|
|
Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeighbor().
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeighbor(). The provided seed is used to initialize the random number generator.
|
|
"""
|
|
return _pywrapcp.Solver_RandomConcatenateOperators(self, *args)
|
|
|
|
def NeighborhoodLimit(self, op: 'LocalSearchOperator', limit: 'int64') -> "operations_research::LocalSearchOperator *":
|
|
r""" Creates a local search operator that wraps another local search operator and limits the number of neighbors explored (i.e., calls to MakeNextNeighbor from the current solution (between two calls to Start()). When this limit is reached, MakeNextNeighbor() returns false. The counter is cleared when Start() is called."""
|
|
return _pywrapcp.Solver_NeighborhoodLimit(self, op, limit)
|
|
|
|
def LocalSearchPhase(self, *args) -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_LocalSearchPhase(self, *args)
|
|
|
|
def LocalSearchPhaseParameters(self, *args) -> "operations_research::LocalSearchPhaseParameters *":
|
|
return _pywrapcp.Solver_LocalSearchPhaseParameters(self, *args)
|
|
|
|
def SearchDepth(self) -> "int":
|
|
r""" Gets the search depth of the current active search. Returns -1 if there is no active search opened."""
|
|
return _pywrapcp.Solver_SearchDepth(self)
|
|
|
|
def SearchLeftDepth(self) -> "int":
|
|
r""" Gets the search left depth of the current active search. Returns -1 if there is no active search opened."""
|
|
return _pywrapcp.Solver_SearchLeftDepth(self)
|
|
|
|
def SolveDepth(self) -> "int":
|
|
r""" Gets the number of nested searches. It returns 0 outside search, 1 during the top level search, 2 or more in case of nested searches."""
|
|
return _pywrapcp.Solver_SolveDepth(self)
|
|
|
|
def Rand64(self, size: 'int64') -> "int64":
|
|
r""" Returns a random value between 0 and 'size' - 1;"""
|
|
return _pywrapcp.Solver_Rand64(self, size)
|
|
|
|
def Rand32(self, size: 'int32') -> "int32":
|
|
r""" Returns a random value between 0 and 'size' - 1;"""
|
|
return _pywrapcp.Solver_Rand32(self, size)
|
|
|
|
def ReSeed(self, seed: 'int32') -> "void":
|
|
r""" Reseed the solver random generator."""
|
|
return _pywrapcp.Solver_ReSeed(self, seed)
|
|
|
|
def LocalSearchProfile(self) -> "std::string":
|
|
r""" Returns local search profiling information in a human readable format. search profiles."""
|
|
return _pywrapcp.Solver_LocalSearchProfile(self)
|
|
|
|
def Constraints(self) -> "int":
|
|
r""" Counts the number of constraints that have been added to the solver before the search."""
|
|
return _pywrapcp.Solver_Constraints(self)
|
|
|
|
def Accept(self, visitor: 'operations_research::ModelVisitor *const') -> "void":
|
|
r""" Accepts the given model visitor."""
|
|
return _pywrapcp.Solver_Accept(self, visitor)
|
|
|
|
def FinishCurrentSearch(self) -> "void":
|
|
r""" Tells the solver to kill or restart the current search."""
|
|
return _pywrapcp.Solver_FinishCurrentSearch(self)
|
|
|
|
def RestartCurrentSearch(self) -> "void":
|
|
return _pywrapcp.Solver_RestartCurrentSearch(self)
|
|
|
|
def ShouldFail(self) -> "void":
|
|
r""" These methods are only useful for the SWIG wrappers, which need a way to externally cause the Solver to fail."""
|
|
return _pywrapcp.Solver_ShouldFail(self)
|
|
|
|
def __str__(self) -> "std::string":
|
|
return _pywrapcp.Solver___str__(self)
|
|
|
|
def Add(self, ct):
|
|
if isinstance(ct, PyConstraint):
|
|
self.__python_constraints.append(ct)
|
|
self.AddConstraint(ct)
|
|
|
|
|
|
def TreeNoCycle(self, nexts: 'std::vector< operations_research::IntVar * > const &', active: 'std::vector< operations_research::IntVar * > const &', callback: 'operations_research::Solver::IndexFilter1'=0) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_TreeNoCycle(self, nexts, active, callback)
|
|
|
|
def SearchLogWithCallback(self, period: 'int', callback: 'std::function< std::string () >') -> "operations_research::SearchMonitor *":
|
|
return _pywrapcp.Solver_SearchLogWithCallback(self, period, callback)
|
|
|
|
def ElementFunction(self, values: 'std::function< int64 (int64) >', index: 'IntVar') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Solver_ElementFunction(self, values, index)
|
|
|
|
def VarEvalValStrPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_evaluator: 'std::function< int64 (int64) >', val_str: 'operations_research::Solver::IntValueStrategy') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarEvalValStrPhase(self, vars, var_evaluator, val_str)
|
|
|
|
def VarStrValEvalPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_str: 'operations_research::Solver::IntVarStrategy', val_eval: 'operations_research::Solver::IndexEvaluator2') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarStrValEvalPhase(self, vars, var_str, val_eval)
|
|
|
|
def VarEvalValEvalPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_eval: 'std::function< int64 (int64) >', val_eval: 'operations_research::Solver::IndexEvaluator2') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarEvalValEvalPhase(self, vars, var_eval, val_eval)
|
|
|
|
def VarStrValEvalTieBreakPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_str: 'operations_research::Solver::IntVarStrategy', val_eval: 'operations_research::Solver::IndexEvaluator2', tie_breaker: 'std::function< int64 (int64) >') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker)
|
|
|
|
def VarEvalValEvalTieBreakPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_eval: 'std::function< int64 (int64) >', val_eval: 'operations_research::Solver::IndexEvaluator2', tie_breaker: 'std::function< int64 (int64) >') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker)
|
|
|
|
def EvalEvalStrPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', evaluator: 'operations_research::Solver::IndexEvaluator2', str: 'operations_research::Solver::EvaluatorStrategy') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_EvalEvalStrPhase(self, vars, evaluator, str)
|
|
|
|
def EvalEvalStrTieBreakPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', evaluator: 'operations_research::Solver::IndexEvaluator2', tie_breaker: 'operations_research::Solver::IndexEvaluator1', str: 'operations_research::Solver::EvaluatorStrategy') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str)
|
|
|
|
def GuidedLocalSearch(self, *args) -> "operations_research::SearchMonitor *":
|
|
return _pywrapcp.Solver_GuidedLocalSearch(self, *args)
|
|
|
|
def SumObjectiveFilter(self, vars: 'std::vector< operations_research::IntVar * > const &', values: 'operations_research::Solver::IndexEvaluator2', objective: 'IntVar', filter_enum: 'operations_research::Solver::LocalSearchFilterBound') -> "operations_research::LocalSearchFilter *":
|
|
return _pywrapcp.Solver_SumObjectiveFilter(self, vars, values, objective, filter_enum)</code></pre>
|
|
</details>
|
|
<h3>Class variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.Solver.ASSIGN_CENTER_VALUE"><code class="name">var <span class="ident">ASSIGN_CENTER_VALUE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Selects the first possible value which is the closest to the center of the domain of the selected variable. The center is defined as (min + max) / 2.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ASSIGN_MAX_VALUE"><code class="name">var <span class="ident">ASSIGN_MAX_VALUE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Selects the max value of the selected variable.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ASSIGN_MIN_VALUE"><code class="name">var <span class="ident">ASSIGN_MIN_VALUE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Selects the min value of the selected variable.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ASSIGN_RANDOM_VALUE"><code class="name">var <span class="ident">ASSIGN_RANDOM_VALUE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Selects randomly one of the possible values of the selected variable.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_FIRST_UNBOUND"><code class="name">var <span class="ident">CHOOSE_FIRST_UNBOUND</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Select the first unbound variable. Variables are considered in the order of the vector of IntVars used to create the selector.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_HIGHEST_MAX"><code class="name">var <span class="ident">CHOOSE_HIGHEST_MAX</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Among unbound variables, select the variable with the highest maximal value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_LOWEST_MIN"><code class="name">var <span class="ident">CHOOSE_LOWEST_MIN</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Among unbound variables, select the variable with the smallest minimal value. In case of a tie, the first one is selected, "first" defined by the order in the vector of IntVars used to create the selector.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_MAX_REGRET_ON_MIN"><code class="name">var <span class="ident">CHOOSE_MAX_REGRET_ON_MIN</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Among unbound variables, select the variable with the largest gap between the first and the second values of the domain.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_MAX_SIZE"><code class="name">var <span class="ident">CHOOSE_MAX_SIZE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Among unbound variables, select the variable with the highest size. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_MIN_SIZE"><code class="name">var <span class="ident">CHOOSE_MIN_SIZE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Among unbound variables, select the variable with the smallest size. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_MIN_SIZE_HIGHEST_MAX"><code class="name">var <span class="ident">CHOOSE_MIN_SIZE_HIGHEST_MAX</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variable is the one with the highest max value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_MIN_SIZE_HIGHEST_MIN"><code class="name">var <span class="ident">CHOOSE_MIN_SIZE_HIGHEST_MIN</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variable is the one with the highest min value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_MIN_SIZE_LOWEST_MAX"><code class="name">var <span class="ident">CHOOSE_MIN_SIZE_LOWEST_MAX</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variables is the one with the lowest max value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_MIN_SIZE_LOWEST_MIN"><code class="name">var <span class="ident">CHOOSE_MIN_SIZE_LOWEST_MIN</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variables is the one with the lowest min value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_MIN_SLACK_RANK_FORWARD"><code class="name">var <span class="ident">CHOOSE_MIN_SLACK_RANK_FORWARD</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_PATH"><code class="name">var <span class="ident">CHOOSE_PATH</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Selects the next unbound variable on a path, the path being defined by the variables: var[i] corresponds to the index of the next of i.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_RANDOM"><code class="name">var <span class="ident">CHOOSE_RANDOM</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Randomly select one of the remaining unbound variables.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CHOOSE_RANDOM_RANK_FORWARD"><code class="name">var <span class="ident">CHOOSE_RANDOM_RANK_FORWARD</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CROSS"><code class="name">var <span class="ident">CROSS</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which cross exchanges the starting chains of 2 paths, including exchanging the whole paths. First and last nodes are not moved. Possible neighbors for the paths 1 -> 2 -> 3 -> 4 -> 5 and 6 -> 7 -> 8 (where (1, 5) and (6, 8) are first and last nodes of the paths and can therefore not be moved):
|
|
1 -> [7] -> 3 -> 4 -> 5
|
|
6 -> [2] -> 8
|
|
1 -> [7] -> 4 -> 5
|
|
6 -> [2 -> 3] -> 8
|
|
1 -> [7] -> 5
|
|
6 -> [2 -> 3 -> 4] -> 8</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.DECREMENT"><code class="name">var <span class="ident">DECREMENT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which defines a neighborhood to decrement values. The behavior is the same as INCREMENT, except values are decremented instead of incremented.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.DELAYED_PRIORITY"><code class="name">var <span class="ident">DELAYED_PRIORITY</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>DELAYED_PRIORITY is the lowest priority: Demons will be processed after VAR_PRIORITY and NORMAL_PRIORITY demons.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.EQ"><code class="name">var <span class="ident">EQ</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Move is accepted when the current objective value is in the interval objective.Min .. objective.Max.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.EXCHANGE"><code class="name">var <span class="ident">EXCHANGE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which exchanges the positions of two nodes. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 (where (1, 5) are first and last nodes of the path and can therefore not be moved):
|
|
1 -> [3] -> [2] ->
|
|
4
|
|
-> 5
|
|
1 -> [4] ->
|
|
3
|
|
-> [2] -> 5
|
|
1 ->
|
|
2
|
|
-> [4] -> [3] -> 5</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.EXTENDEDSWAPACTIVE"><code class="name">var <span class="ident">EXTENDEDSWAPACTIVE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which makes an inactive node active and an active one inactive. It is similar to SwapActiveOperator except that it tries to insert the inactive node in all possible positions instead of just the position of the node made inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are:
|
|
1 -> [5] ->
|
|
3
|
|
-> 4 with 2 inactive
|
|
1 ->
|
|
3
|
|
-> [5] -> 4 with 2 inactive
|
|
1 -> [5] ->
|
|
2
|
|
-> 4 with 3 inactive
|
|
1 ->
|
|
2
|
|
-> [5] -> 4 with 3 inactive</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.FULLPATHLNS"><code class="name">var <span class="ident">FULLPATHLNS</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which relaxes one entire path and all inactive nodes, thus defining num_paths neighbors.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.GE"><code class="name">var <span class="ident">GE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Move is accepted when the current objective value >= objective.Min.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.INCREMENT"><code class="name">var <span class="ident">INCREMENT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which defines one neighbor per variable. Each neighbor tries to increment by one the value of the corresponding variable. When a new solution is found the neighborhood is rebuilt from scratch, i.e., tries to increment values in the variable order. Consider for instance variables x and y. x is incremented one by one to its max, and when it is not possible to increment x anymore, y is incremented once. If this is a solution, then next neighbor tries to increment x.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.INTERVAL_DEFAULT"><code class="name">var <span class="ident">INTERVAL_DEFAULT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The default is INTERVAL_SET_TIMES_FORWARD.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.INTERVAL_SET_TIMES_BACKWARD"><code class="name">var <span class="ident">INTERVAL_SET_TIMES_BACKWARD</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Selects the variable with the highest ending time of all variables, and fixes the ending time to this highest values.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.INTERVAL_SET_TIMES_FORWARD"><code class="name">var <span class="ident">INTERVAL_SET_TIMES_FORWARD</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Selects the variable with the lowest starting time of all variables, and fixes its starting time to this lowest value.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.INTERVAL_SIMPLE"><code class="name">var <span class="ident">INTERVAL_SIMPLE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The simple is INTERVAL_SET_TIMES_FORWARD.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.INT_VALUE_DEFAULT"><code class="name">var <span class="ident">INT_VALUE_DEFAULT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The default behavior is ASSIGN_MIN_VALUE.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.INT_VALUE_SIMPLE"><code class="name">var <span class="ident">INT_VALUE_SIMPLE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The simple selection is ASSIGN_MIN_VALUE.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.INT_VAR_DEFAULT"><code class="name">var <span class="ident">INT_VAR_DEFAULT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The default behavior is CHOOSE_FIRST_UNBOUND.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.INT_VAR_SIMPLE"><code class="name">var <span class="ident">INT_VAR_SIMPLE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The simple selection is CHOOSE_FIRST_UNBOUND.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.LE"><code class="name">var <span class="ident">LE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Move is accepted when the current objective value <= objective.Max.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.MAKEACTIVE"><code class="name">var <span class="ident">MAKEACTIVE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which inserts an inactive node into a path. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are:
|
|
1 -> [5] ->
|
|
2
|
|
->
|
|
3
|
|
-> 4
|
|
1 ->
|
|
2
|
|
-> [5] ->
|
|
3
|
|
-> 4
|
|
1 ->
|
|
2
|
|
->
|
|
3
|
|
-> [5] -> 4</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.MAKECHAININACTIVE"><code class="name">var <span class="ident">MAKECHAININACTIVE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which makes a "chain" of path nodes inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are first and last nodes of the path) are:
|
|
1 -> 3 -> 4 with 2 inactive
|
|
1 -> 2 -> 4 with 3 inactive
|
|
1 -> 4 with 2 and 3 inactive</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.MAKEINACTIVE"><code class="name">var <span class="ident">MAKEINACTIVE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which makes path nodes inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are first and last nodes of the path) are:
|
|
1 -> 3 -> 4 with 2 inactive
|
|
1 -> 2 -> 4 with 3 inactive</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.NORMAL_PRIORITY"><code class="name">var <span class="ident">NORMAL_PRIORITY</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>NORMAL_PRIORITY is the highest priority: Demons will be processed first.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.OROPT"><code class="name">var <span class="ident">OROPT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Relocate: OROPT and RELOCATE. Operator which moves a sub-chain of a path to another position; the specified chain length is the fixed length of the chains being moved. When this length is 1, the operator simply moves a node to another position. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5, for a chain length of 2 (where (1, 5) are first and last nodes of the path and can therefore not be moved):
|
|
1 ->
|
|
4 -> [2 -> 3] -> 5
|
|
1 -> [3 -> 4] -> 2
|
|
-> 5 Using Relocate with chain lengths of 1, 2 and 3 together is equivalent to the OrOpt operator on a path. The OrOpt operator is a limited
|
|
version of 3Opt (breaks 3 arcs on a path).</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.PATHLNS"><code class="name">var <span class="ident">PATHLNS</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which relaxes two sub-chains of three consecutive arcs each. Each sub-chain is defined by a start node and the next three arcs. Those six arcs are relaxed to build a new neighbor. PATHLNS explores all possible pairs of starting nodes and so defines n^2 neighbors, n being the number of nodes. Note that the two sub-chains can be part of the same path; they even may overlap.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.RELOCATE"><code class="name">var <span class="ident">RELOCATE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Relocate neighborhood with length of 1 (see OROPT comment).</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SEQUENCE_DEFAULT"><code class="name">var <span class="ident">SEQUENCE_DEFAULT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SEQUENCE_SIMPLE"><code class="name">var <span class="ident">SEQUENCE_SIMPLE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SIMPLELNS"><code class="name">var <span class="ident">SIMPLELNS</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which defines one neighbor per variable. Each neighbor relaxes one variable. When a new solution is found the neighborhood is rebuilt from scratch. Consider for instance variables x and y. First x is relaxed and the solver is looking for the best possible solution (with only x relaxed). Then y is relaxed, and the solver is looking for a new solution. If a new solution is found, then the next variable to be relaxed is x.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SPLIT_LOWER_HALF"><code class="name">var <span class="ident">SPLIT_LOWER_HALF</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Split the domain in two around the center, and choose the lower part first.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SPLIT_UPPER_HALF"><code class="name">var <span class="ident">SPLIT_UPPER_HALF</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Split the domain in two around the center, and choose the lower part first.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SWAPACTIVE"><code class="name">var <span class="ident">SWAPACTIVE</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which replaces an active node by an inactive one. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are:
|
|
1 -> [5] ->
|
|
3
|
|
-> 4 with 2 inactive
|
|
1 ->
|
|
2
|
|
-> [5] -> 4 with 3 inactive</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.TWOOPT"><code class="name">var <span class="ident">TWOOPT</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which reverses a sub-chain of a path. It is called TwoOpt because it breaks two arcs on the path; resulting paths are called two-optimal. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 (where (1, 5) are first and last nodes of the path and can therefore not be moved):
|
|
1 -> [3 -> 2] -> 4
|
|
-> 5
|
|
1 -> [4 -> 3
|
|
-> 2] -> 5
|
|
1 ->
|
|
2 -> [4 -> 3] -> 5</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.UNACTIVELNS"><code class="name">var <span class="ident">UNACTIVELNS</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Operator which relaxes all inactive nodes and one sub-chain of six consecutive arcs. That way the path can be improved by inserting inactive nodes or swapping arcs.</p></section>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.VAR_PRIORITY"><code class="name">var <span class="ident">VAR_PRIORITY</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>VAR_PRIORITY is between DELAYED_PRIORITY and NORMAL_PRIORITY.</p></section>
|
|
</dd>
|
|
</dl>
|
|
<h3>Static methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.Solver.DefaultSolverParameters"><code class="name flex">
|
|
<span>def <span class="ident">DefaultSolverParameters</span></span>(<span>)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Create a ConstraintSolverParameters proto with all the default values.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">@staticmethod
|
|
def DefaultSolverParameters() -> "operations_research::ConstraintSolverParameters":
|
|
r""" Create a ConstraintSolverParameters proto with all the default values."""
|
|
return _pywrapcp.Solver_DefaultSolverParameters()</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.MemoryUsage"><code class="name flex">
|
|
<span>def <span class="ident">MemoryUsage</span></span>(<span>)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Current memory usage in bytes</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">@staticmethod
|
|
def MemoryUsage() -> "int64":
|
|
r""" Current memory usage in bytes"""
|
|
return _pywrapcp.Solver_MemoryUsage()</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Instance variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.Solver.thisown"><code class="name">var <span class="ident">thisown</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The membership flag</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.Solver.AbsEquality"><code class="name flex">
|
|
<span>def <span class="ident">AbsEquality</span></span>(<span>self, var, abs_var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates the constraint abs(var) == abs_var.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AbsEquality(self, var: 'IntVar', abs_var: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" Creates the constraint abs(var) == abs_var."""
|
|
return _pywrapcp.Solver_AbsEquality(self, var, abs_var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Accept"><code class="name flex">
|
|
<span>def <span class="ident">Accept</span></span>(<span>self, visitor)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Accepts the given model visitor.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Accept(self, visitor: 'operations_research::ModelVisitor *const') -> "void":
|
|
r""" Accepts the given model visitor."""
|
|
return _pywrapcp.Solver_Accept(self, visitor)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.AcceptedNeighbors"><code class="name flex">
|
|
<span>def <span class="ident">AcceptedNeighbors</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The number of accepted neighbors.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AcceptedNeighbors(self) -> "int64":
|
|
r""" The number of accepted neighbors."""
|
|
return _pywrapcp.Solver_AcceptedNeighbors(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Add"><code class="name flex">
|
|
<span>def <span class="ident">Add</span></span>(<span>self, ct)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Add(self, ct):
|
|
if isinstance(ct, PyConstraint):
|
|
self.__python_constraints.append(ct)
|
|
self.AddConstraint(ct)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.AddConstraint"><code class="name flex">
|
|
<span>def <span class="ident">AddConstraint</span></span>(<span>self, c)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Adds the constraint 'c' to the model. After calling this method, and until there is a backtrack that undoes the addition, any assignment of variables to values must satisfy the given constraint in order to be considered feasible. There are two fairly different use cases: - the most common use case is modeling: the given constraint is really part of the problem that the user is trying to solve. In this use case, AddConstraint is called outside of search (i.e., with state() == OUTSIDE_SEARCH). Most users should only use AddConstraint in this way. In this case, the constraint will belong to the model forever: it cannot not be removed by backtracking. - a rarer use case is that 'c' is not a real constraint of the model. It may be a constraint generated by a branching decision (a constraint whose goal is to restrict the search space), a symmetry breaking constraint (a constraint that does restrict the search space, but in a way that cannot have an impact on the quality of the solutions in the subtree), or an inferred constraint that, while having no semantic value to the model (it does not restrict the set of solutions), is worth having because we believe it may strengthen the propagation. In these cases, it happens that the constraint is added during the search (i.e., with state() == IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is added during a search, it applies only to the subtree of the search tree rooted at the current node, and will be automatically removed by backtracking. This method does not take ownership of the constraint. If the constraint has been created by any factory method (Solver::MakeXXX), it will automatically be deleted. However, power users who implement their own constraints should do: solver.AddConstraint(solver.RevAlloc(new MyConstraint(…));</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AddConstraint(self, c: 'Constraint') -> "void":
|
|
r""" Adds the constraint 'c' to the model. After calling this method, and until there is a backtrack that undoes the addition, any assignment of variables to values must satisfy the given constraint in order to be considered feasible. There are two fairly different use cases: - the most common use case is modeling: the given constraint is really part of the problem that the user is trying to solve. In this use case, AddConstraint is called outside of search (i.e., with state() == OUTSIDE_SEARCH). Most users should only use AddConstraint in this way. In this case, the constraint will belong to the model forever: it cannot not be removed by backtracking. - a rarer use case is that 'c' is not a real constraint of the model. It may be a constraint generated by a branching decision (a constraint whose goal is to restrict the search space), a symmetry breaking constraint (a constraint that does restrict the search space, but in a way that cannot have an impact on the quality of the solutions in the subtree), or an inferred constraint that, while having no semantic value to the model (it does not restrict the set of solutions), is worth having because we believe it may strengthen the propagation. In these cases, it happens that the constraint is added during the search (i.e., with state() == IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is added during a search, it applies only to the subtree of the search tree rooted at the current node, and will be automatically removed by backtracking. This method does not take ownership of the constraint. If the constraint has been created by any factory method (Solver::MakeXXX), it will automatically be deleted. However, power users who implement their own constraints should do: solver.AddConstraint(solver.RevAlloc(new MyConstraint(...));"""
|
|
return _pywrapcp.Solver_AddConstraint(self, c)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.AllDifferent"><code class="name flex">
|
|
<span>def <span class="ident">AllDifferent</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
All variables are pairwise different. This corresponds to the stronger version of the propagation algorithm.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
All variables are pairwise different.
|
|
If 'stronger_propagation' is true, stronger, and potentially slower propagation will occur. This API will be deprecated in the future.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AllDifferent(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
All variables are pairwise different. This corresponds to the stronger version of the propagation algorithm.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
All variables are pairwise different. If 'stronger_propagation' is true, stronger, and potentially slower propagation will occur. This API will be deprecated in the future.
|
|
"""
|
|
return _pywrapcp.Solver_AllDifferent(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.AllDifferentExcept"><code class="name flex">
|
|
<span>def <span class="ident">AllDifferentExcept</span></span>(<span>self, vars, escape_value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>All variables are pairwise different, unless they are assigned to the escape value.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AllDifferentExcept(self, vars: 'std::vector< operations_research::IntVar * > const &', escape_value: 'int64') -> "operations_research::Constraint *":
|
|
r""" All variables are pairwise different, unless they are assigned to the escape value."""
|
|
return _pywrapcp.Solver_AllDifferentExcept(self, vars, escape_value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.AllSolutionCollector"><code class="name flex">
|
|
<span>def <span class="ident">AllSolutionCollector</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Collect all solutions of the search.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Collect all solutions of the search. The variables will need to be added later.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AllSolutionCollector(self, *args) -> "operations_research::SolutionCollector *":
|
|
r"""
|
|
*Overload 1:*
|
|
Collect all solutions of the search.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Collect all solutions of the search. The variables will need to be added later.
|
|
"""
|
|
return _pywrapcp.Solver_AllSolutionCollector(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.AllowedAssignments"><code class="name flex">
|
|
<span>def <span class="ident">AllowedAssignments</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
This method creates a constraint where the graph of the relation between the variables is given in extension. There are 'arity' variables involved in the relation and the graph is given by a integer tuple set.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Compatibility layer for Python API.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AllowedAssignments(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
This method creates a constraint where the graph of the relation between the variables is given in extension. There are 'arity' variables involved in the relation and the graph is given by a integer tuple set.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Compatibility layer for Python API.
|
|
"""
|
|
return _pywrapcp.Solver_AllowedAssignments(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.AssignVariableValue"><code class="name flex">
|
|
<span>def <span class="ident">AssignVariableValue</span></span>(<span>self, var, val)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Decisions.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AssignVariableValue(self, var: 'IntVar', val: 'int64') -> "operations_research::Decision *":
|
|
r""" Decisions."""
|
|
return _pywrapcp.Solver_AssignVariableValue(self, var, val)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.AssignVariableValueOrFail"><code class="name flex">
|
|
<span>def <span class="ident">AssignVariableValueOrFail</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AssignVariableValueOrFail(self, var: 'IntVar', value: 'int64') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_AssignVariableValueOrFail(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.AssignVariablesValues"><code class="name flex">
|
|
<span>def <span class="ident">AssignVariablesValues</span></span>(<span>self, vars, values)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def AssignVariablesValues(self, vars: 'std::vector< operations_research::IntVar * > const &', values: 'std::vector< int64 > const &') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_AssignVariablesValues(self, vars, values)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Assignment"><code class="name flex">
|
|
<span>def <span class="ident">Assignment</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
This method creates an empty assignment.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
This method creates an assignment which is a copy of 'a'.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Assignment(self, *args) -> "operations_research::Assignment *":
|
|
r"""
|
|
*Overload 1:*
|
|
This method creates an empty assignment.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This method creates an assignment which is a copy of 'a'.
|
|
"""
|
|
return _pywrapcp.Solver_Assignment(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.BestValueSolutionCollector"><code class="name flex">
|
|
<span>def <span class="ident">BestValueSolutionCollector</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Collect the solution corresponding to the optimal value of the objective of 'assignment'; if 'assignment' does not have an objective no solution is collected. This collector only collects one solution corresponding to the best objective value (the first one found).</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Collect the solution corresponding to the optimal value of the objective of 'assignment'; if 'assignment' does not have an objective no solution is collected. This collector only collects one solution corresponding to the best objective value (the first one found). The variables will need to be added later.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BestValueSolutionCollector(self, *args) -> "operations_research::SolutionCollector *":
|
|
r"""
|
|
*Overload 1:*
|
|
Collect the solution corresponding to the optimal value of the objective of 'assignment'; if 'assignment' does not have an objective no solution is collected. This collector only collects one solution corresponding to the best objective value (the first one found).
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Collect the solution corresponding to the optimal value of the objective of 'assignment'; if 'assignment' does not have an objective no solution is collected. This collector only collects one solution corresponding to the best objective value (the first one found). The variables will need to be added later.
|
|
"""
|
|
return _pywrapcp.Solver_BestValueSolutionCollector(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.BetweenCt"><code class="name flex">
|
|
<span>def <span class="ident">BetweenCt</span></span>(<span>self, expr, l, u)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>(l <= expr <= u)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BetweenCt(self, expr: 'IntExpr', l: 'int64', u: 'int64') -> "operations_research::Constraint *":
|
|
r""" (l <= expr <= u)"""
|
|
return _pywrapcp.Solver_BetweenCt(self, expr, l, u)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.BoolVar"><code class="name flex">
|
|
<span>def <span class="ident">BoolVar</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
MakeBoolVar will create a variable with a {0, 1} domain.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
MakeBoolVar will create a variable with a {0, 1} domain.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BoolVar(self, *args) -> "operations_research::IntVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
MakeBoolVar will create a variable with a {0, 1} domain.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
MakeBoolVar will create a variable with a {0, 1} domain.
|
|
"""
|
|
return _pywrapcp.Solver_BoolVar(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Branches"><code class="name flex">
|
|
<span>def <span class="ident">Branches</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The number of branches explored since the creation of the solver.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Branches(self) -> "int64":
|
|
r""" The number of branches explored since the creation of the solver."""
|
|
return _pywrapcp.Solver_Branches(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.BranchesLimit"><code class="name flex">
|
|
<span>def <span class="ident">BranchesLimit</span></span>(<span>self, branches)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a search limit that constrains the number of branches explored in the search tree.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def BranchesLimit(self, branches: 'int64') -> "operations_research::RegularLimit *":
|
|
r""" Creates a search limit that constrains the number of branches explored in the search tree."""
|
|
return _pywrapcp.Solver_BranchesLimit(self, branches)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CheckAssignment"><code class="name flex">
|
|
<span>def <span class="ident">CheckAssignment</span></span>(<span>self, solution)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Checks whether the given assignment satisfies all relevant constraints.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CheckAssignment(self, solution: 'Assignment') -> "bool":
|
|
r""" Checks whether the given assignment satisfies all relevant constraints."""
|
|
return _pywrapcp.Solver_CheckAssignment(self, solution)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CheckConstraint"><code class="name flex">
|
|
<span>def <span class="ident">CheckConstraint</span></span>(<span>self, ct)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Checks whether adding this constraint will lead to an immediate failure. It will return false if the model is already inconsistent, or if adding the constraint makes it inconsistent.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CheckConstraint(self, ct: 'Constraint') -> "bool":
|
|
r""" Checks whether adding this constraint will lead to an immediate failure. It will return false if the model is already inconsistent, or if adding the constraint makes it inconsistent."""
|
|
return _pywrapcp.Solver_CheckConstraint(self, ct)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Circuit"><code class="name flex">
|
|
<span>def <span class="ident">Circuit</span></span>(<span>self, nexts)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Force the "nexts" variable to create a complete Hamiltonian path.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Circuit(self, nexts: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Force the "nexts" variable to create a complete Hamiltonian path."""
|
|
return _pywrapcp.Solver_Circuit(self, nexts)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ClosureDemon"><code class="name flex">
|
|
<span>def <span class="ident">ClosureDemon</span></span>(<span>self, closure)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a demon from a closure.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ClosureDemon(self, closure: 'operations_research::Solver::Closure') -> "operations_research::Demon *":
|
|
r""" Creates a demon from a closure."""
|
|
return _pywrapcp.Solver_ClosureDemon(self, closure)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Compose"><code class="name flex">
|
|
<span>def <span class="ident">Compose</span></span>(<span>self, dbs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Compose(self, dbs: 'std::vector< operations_research::DecisionBuilder * > const &') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_Compose(self, dbs)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ConcatenateOperators"><code class="name flex">
|
|
<span>def <span class="ident">ConcatenateOperators</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ConcatenateOperators(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
return _pywrapcp.Solver_ConcatenateOperators(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ConditionalExpression"><code class="name flex">
|
|
<span>def <span class="ident">ConditionalExpression</span></span>(<span>self, condition, expr, unperformed_value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Conditional Expr condition ? expr : unperformed_value</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ConditionalExpression(self, condition: 'IntVar', expr: 'IntExpr', unperformed_value: 'int64') -> "operations_research::IntExpr *":
|
|
r""" Conditional Expr condition ? expr : unperformed_value"""
|
|
return _pywrapcp.Solver_ConditionalExpression(self, condition, expr, unperformed_value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ConstantRestart"><code class="name flex">
|
|
<span>def <span class="ident">ConstantRestart</span></span>(<span>self, frequency)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This search monitor will restart the search periodically after 'frequency' failures.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ConstantRestart(self, frequency: 'int') -> "operations_research::SearchMonitor *":
|
|
r""" This search monitor will restart the search periodically after 'frequency' failures."""
|
|
return _pywrapcp.Solver_ConstantRestart(self, frequency)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ConstraintAdder"><code class="name flex">
|
|
<span>def <span class="ident">ConstraintAdder</span></span>(<span>self, ct)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns a decision builder that will add the given constraint to the model.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ConstraintAdder(self, ct: 'Constraint') -> "operations_research::DecisionBuilder *":
|
|
r""" Returns a decision builder that will add the given constraint to the model."""
|
|
return _pywrapcp.Solver_ConstraintAdder(self, ct)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ConstraintInitialPropagateCallback"><code class="name flex">
|
|
<span>def <span class="ident">ConstraintInitialPropagateCallback</span></span>(<span>self, ct)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct'.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ConstraintInitialPropagateCallback(self, ct: 'Constraint') -> "operations_research::Demon *":
|
|
r""" This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct'."""
|
|
return _pywrapcp.Solver_ConstraintInitialPropagateCallback(self, ct)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Constraints"><code class="name flex">
|
|
<span>def <span class="ident">Constraints</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Counts the number of constraints that have been added to the solver before the search.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Constraints(self) -> "int":
|
|
r""" Counts the number of constraints that have been added to the solver before the search."""
|
|
return _pywrapcp.Solver_Constraints(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ConvexPiecewiseExpr"><code class="name flex">
|
|
<span>def <span class="ident">ConvexPiecewiseExpr</span></span>(<span>self, expr, early_cost, early_date, late_date, late_cost)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Convex piecewise function.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ConvexPiecewiseExpr(self, expr: 'IntExpr', early_cost: 'int64', early_date: 'int64', late_date: 'int64', late_cost: 'int64') -> "operations_research::IntExpr *":
|
|
r""" Convex piecewise function."""
|
|
return _pywrapcp.Solver_ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Count"><code class="name flex">
|
|
<span>def <span class="ident">Count</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
|{i | vars[i] == value}| == max_count</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
|{i | vars[i] == value}| == max_count</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Count(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
|{i | vars[i] == value}| == max_count
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
|{i | vars[i] == value}| == max_count
|
|
"""
|
|
return _pywrapcp.Solver_Count(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Cover"><code class="name flex">
|
|
<span>def <span class="ident">Cover</span></span>(<span>self, vars, target_var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This constraint states that the target_var is the convex hull of the intervals. If none of the interval variables is performed, then the target var is unperformed too. Also, if the target variable is unperformed, then all the intervals variables are unperformed too.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Cover(self, vars: 'std::vector< operations_research::IntervalVar * > const &', target_var: 'IntervalVar') -> "operations_research::Constraint *":
|
|
r""" This constraint states that the target_var is the convex hull of the intervals. If none of the interval variables is performed, then the target var is unperformed too. Also, if the target variable is unperformed, then all the intervals variables are unperformed too."""
|
|
return _pywrapcp.Solver_Cover(self, vars, target_var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Cumulative"><code class="name flex">
|
|
<span>def <span class="ident">Cumulative</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 3:</em>
|
|
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 4:</em>
|
|
This constraint enforces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 5:</em>
|
|
This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should be positive.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 6:</em>
|
|
This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should be positive.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Cumulative(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
This constraint enforces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should be positive.
|
|
|
|
|
|
|
|
|
*Overload 6:*
|
|
This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should be positive.
|
|
"""
|
|
return _pywrapcp.Solver_Cumulative(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.CustomLimit"><code class="name flex">
|
|
<span>def <span class="ident">CustomLimit</span></span>(<span>self, limiter)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Callback-based search limit. Search stops when limiter returns true; if this happens at a leaf the corresponding solution will be rejected.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CustomLimit(self, limiter: 'std::function< bool () >') -> "operations_research::SearchLimit *":
|
|
r""" Callback-based search limit. Search stops when limiter returns true; if this happens at a leaf the corresponding solution will be rejected."""
|
|
return _pywrapcp.Solver_CustomLimit(self, limiter)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Decision"><code class="name flex">
|
|
<span>def <span class="ident">Decision</span></span>(<span>self, apply, refute)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Decision(self, apply: 'operations_research::Solver::Action', refute: 'operations_research::Solver::Action') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_Decision(self, apply, refute)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.DecisionBuilderFromAssignment"><code class="name flex">
|
|
<span>def <span class="ident">DecisionBuilderFromAssignment</span></span>(<span>self, assignment, db, vars)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns a decision builder for which the left-most leaf corresponds to assignment, the rest of the tree being explored using 'db'.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DecisionBuilderFromAssignment(self, assignment: 'Assignment', db: 'DecisionBuilder', vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::DecisionBuilder *":
|
|
r""" Returns a decision builder for which the left-most leaf corresponds to assignment, the rest of the tree being explored using 'db'."""
|
|
return _pywrapcp.Solver_DecisionBuilderFromAssignment(self, assignment, db, vars)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.DefaultPhase"><code class="name flex">
|
|
<span>def <span class="ident">DefaultPhase</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DefaultPhase(self, *args) -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_DefaultPhase(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.DelayedConstraintInitialPropagateCallback"><code class="name flex">
|
|
<span>def <span class="ident">DelayedConstraintInitialPropagateCallback</span></span>(<span>self, ct)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct' with low priority.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DelayedConstraintInitialPropagateCallback(self, ct: 'Constraint') -> "operations_research::Demon *":
|
|
r""" This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct' with low priority."""
|
|
return _pywrapcp.Solver_DelayedConstraintInitialPropagateCallback(self, ct)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.DelayedPathCumul"><code class="name flex">
|
|
<span>def <span class="ident">DelayedPathCumul</span></span>(<span>self, nexts, active, cumuls, transits)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Delayed version of the same constraint: propagation on the nexts variables is delayed until all constraints have propagated.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DelayedPathCumul(self, nexts: 'std::vector< operations_research::IntVar * > const &', active: 'std::vector< operations_research::IntVar * > const &', cumuls: 'std::vector< operations_research::IntVar * > const &', transits: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Delayed version of the same constraint: propagation on the nexts variables is delayed until all constraints have propagated."""
|
|
return _pywrapcp.Solver_DelayedPathCumul(self, nexts, active, cumuls, transits)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Deviation"><code class="name flex">
|
|
<span>def <span class="ident">Deviation</span></span>(<span>self, vars, deviation_var, total_sum)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Deviation constraint: sum_i |n * vars[i] - total_sum| <= deviation_var and sum_i vars[i] == total_sum n = #vars</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Deviation(self, vars: 'std::vector< operations_research::IntVar * > const &', deviation_var: 'IntVar', total_sum: 'int64') -> "operations_research::Constraint *":
|
|
r""" Deviation constraint: sum_i |n * vars[i] - total_sum| <= deviation_var and sum_i vars[i] == total_sum n = #vars"""
|
|
return _pywrapcp.Solver_Deviation(self, vars, deviation_var, total_sum)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.DisjunctiveConstraint"><code class="name flex">
|
|
<span>def <span class="ident">DisjunctiveConstraint</span></span>(<span>self, intervals, name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This constraint forces all interval vars into an non-overlapping sequence. Intervals with zero duration can be scheduled anywhere.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def DisjunctiveConstraint(self, intervals: 'std::vector< operations_research::IntervalVar * > const &', name: 'std::string const &') -> "operations_research::DisjunctiveConstraint *":
|
|
r""" This constraint forces all interval vars into an non-overlapping sequence. Intervals with zero duration can be scheduled anywhere."""
|
|
return _pywrapcp.Solver_DisjunctiveConstraint(self, intervals, name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Distribute"><code class="name flex">
|
|
<span>def <span class="ident">Distribute</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Aggregated version of count:
|
|
|{i | v[i] == values[j]}| == cards[j]</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Aggregated version of count:
|
|
|{i | v[i] == values[j]}| == cards[j]</p>
|
|
<p>|</p>
|
|
<p><em>Overload 3:</em>
|
|
Aggregated version of count:
|
|
|{i | v[i] == j}| == cards[j]</p>
|
|
<p>|</p>
|
|
<p><em>Overload 4:</em>
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max</p>
|
|
<p>|</p>
|
|
<p><em>Overload 5:</em>
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1:
|
|
card_min[j] <= |{i | v[i] == j}| <= card_max[j]</p>
|
|
<p>|</p>
|
|
<p><em>Overload 6:</em>
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1:
|
|
card_min[j] <= |{i | v[i] == j}| <= card_max[j]</p>
|
|
<p>|</p>
|
|
<p><em>Overload 7:</em>
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1:
|
|
card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]</p>
|
|
<p>|</p>
|
|
<p><em>Overload 8:</em>
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1:
|
|
card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Distribute(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
Aggregated version of count: |{i | v[i] == values[j]}| == cards[j]
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Aggregated version of count: |{i | v[i] == values[j]}| == cards[j]
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Aggregated version of count: |{i | v[i] == j}| == cards[j]
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == j}| <= card_max[j]
|
|
|
|
|
|
|
|
|
*Overload 6:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == j}| <= card_max[j]
|
|
|
|
|
|
|
|
|
*Overload 7:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
|
|
|
|
|
|
|
|
|
*Overload 8:*
|
|
Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
|
|
"""
|
|
return _pywrapcp.Solver_Distribute(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Element"><code class="name flex">
|
|
<span>def <span class="ident">Element</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
values[index]</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
values[index]</p>
|
|
<p>|</p>
|
|
<p><em>Overload 3:</em>
|
|
Function-based element. The constraint takes ownership of the callback. The callback must be able to cope with any possible value in the domain of 'index' (potentially negative ones too).</p>
|
|
<p>|</p>
|
|
<p><em>Overload 4:</em>
|
|
2D version of function-based element expression, values(expr1, expr2).</p>
|
|
<p>|</p>
|
|
<p><em>Overload 5:</em>
|
|
vars[expr]</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Element(self, *args) -> "operations_research::IntExpr *":
|
|
r"""
|
|
*Overload 1:*
|
|
values[index]
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
values[index]
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Function-based element. The constraint takes ownership of the callback. The callback must be able to cope with any possible value in the domain of 'index' (potentially negative ones too).
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
2D version of function-based element expression, values(expr1, expr2).
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
vars[expr]
|
|
"""
|
|
return _pywrapcp.Solver_Element(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ElementEquality"><code class="name flex">
|
|
<span>def <span class="ident">ElementEquality</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ElementEquality(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_ElementEquality(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ElementFunction"><code class="name flex">
|
|
<span>def <span class="ident">ElementFunction</span></span>(<span>self, values, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ElementFunction(self, values: 'std::function< int64 (int64) >', index: 'IntVar') -> "operations_research::IntExpr *":
|
|
return _pywrapcp.Solver_ElementFunction(self, values, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.EndSearch"><code class="name flex">
|
|
<span>def <span class="ident">EndSearch</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EndSearch(self) -> "void":
|
|
return _pywrapcp.Solver_EndSearch(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.EvalEvalStrPhase"><code class="name flex">
|
|
<span>def <span class="ident">EvalEvalStrPhase</span></span>(<span>self, vars, evaluator, str)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EvalEvalStrPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', evaluator: 'operations_research::Solver::IndexEvaluator2', str: 'operations_research::Solver::EvaluatorStrategy') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_EvalEvalStrPhase(self, vars, evaluator, str)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.EvalEvalStrTieBreakPhase"><code class="name flex">
|
|
<span>def <span class="ident">EvalEvalStrTieBreakPhase</span></span>(<span>self, vars, evaluator, tie_breaker, str)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def EvalEvalStrTieBreakPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', evaluator: 'operations_research::Solver::IndexEvaluator2', tie_breaker: 'operations_research::Solver::IndexEvaluator1', str: 'operations_research::Solver::EvaluatorStrategy') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Fail"><code class="name flex">
|
|
<span>def <span class="ident">Fail</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Abandon the current branch in the search tree. A backtrack will follow.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Fail(self) -> "void":
|
|
r""" Abandon the current branch in the search tree. A backtrack will follow."""
|
|
return _pywrapcp.Solver_Fail(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.FailDecision"><code class="name flex">
|
|
<span>def <span class="ident">FailDecision</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FailDecision(self) -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_FailDecision(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.FailStamp"><code class="name flex">
|
|
<span>def <span class="ident">FailStamp</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The fail_stamp() is incremented after each backtrack.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FailStamp(self) -> "uint64":
|
|
r""" The fail_stamp() is incremented after each backtrack."""
|
|
return _pywrapcp.Solver_FailStamp(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Failures"><code class="name flex">
|
|
<span>def <span class="ident">Failures</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The number of failures encountered since the creation of the solver.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Failures(self) -> "int64":
|
|
r""" The number of failures encountered since the creation of the solver."""
|
|
return _pywrapcp.Solver_Failures(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.FailuresLimit"><code class="name flex">
|
|
<span>def <span class="ident">FailuresLimit</span></span>(<span>self, failures)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a search limit that constrains the number of failures that can happen when exploring the search tree.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FailuresLimit(self, failures: 'int64') -> "operations_research::RegularLimit *":
|
|
r""" Creates a search limit that constrains the number of failures that can happen when exploring the search tree."""
|
|
return _pywrapcp.Solver_FailuresLimit(self, failures)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.FalseConstraint"><code class="name flex">
|
|
<span>def <span class="ident">FalseConstraint</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FalseConstraint(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_FalseConstraint(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.FinishCurrentSearch"><code class="name flex">
|
|
<span>def <span class="ident">FinishCurrentSearch</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Tells the solver to kill or restart the current search.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FinishCurrentSearch(self) -> "void":
|
|
r""" Tells the solver to kill or restart the current search."""
|
|
return _pywrapcp.Solver_FinishCurrentSearch(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.FirstSolutionCollector"><code class="name flex">
|
|
<span>def <span class="ident">FirstSolutionCollector</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Collect the first solution of the search.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Collect the first solution of the search. The variables will need to be added later.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FirstSolutionCollector(self, *args) -> "operations_research::SolutionCollector *":
|
|
r"""
|
|
*Overload 1:*
|
|
Collect the first solution of the search.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Collect the first solution of the search. The variables will need to be added later.
|
|
"""
|
|
return _pywrapcp.Solver_FirstSolutionCollector(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.FixedDurationEndSyncedOnEndIntervalVar"><code class="name flex">
|
|
<span>def <span class="ident">FixedDurationEndSyncedOnEndIntervalVar</span></span>(<span>self, interval_var, duration, offset)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates an interval var with a fixed duration whose end is synchronized with the end of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FixedDurationEndSyncedOnEndIntervalVar(self, interval_var: 'IntervalVar', duration: 'int64', offset: 'int64') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var with a fixed duration whose end is synchronized with the end of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable."""
|
|
return _pywrapcp.Solver_FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.FixedDurationEndSyncedOnStartIntervalVar"><code class="name flex">
|
|
<span>def <span class="ident">FixedDurationEndSyncedOnStartIntervalVar</span></span>(<span>self, interval_var, duration, offset)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates an interval var with a fixed duration whose end is synchronized with the start of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FixedDurationEndSyncedOnStartIntervalVar(self, interval_var: 'IntervalVar', duration: 'int64', offset: 'int64') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var with a fixed duration whose end is synchronized with the start of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable."""
|
|
return _pywrapcp.Solver_FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.FixedDurationIntervalVar"><code class="name flex">
|
|
<span>def <span class="ident">FixedDurationIntervalVar</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Creates an interval var with a fixed duration. The duration must be greater than 0. If optional is true, then the interval can be performed or unperformed. If optional is false, then the interval is always performed.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Creates a performed interval var with a fixed duration. The duration must be greater than 0.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 3:</em>
|
|
Creates an interval var with a fixed duration, and performed_variable. The duration must be greater than 0.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FixedDurationIntervalVar(self, *args) -> "operations_research::IntervalVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates an interval var with a fixed duration. The duration must be greater than 0. If optional is true, then the interval can be performed or unperformed. If optional is false, then the interval is always performed.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a performed interval var with a fixed duration. The duration must be greater than 0.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Creates an interval var with a fixed duration, and performed_variable. The duration must be greater than 0.
|
|
"""
|
|
return _pywrapcp.Solver_FixedDurationIntervalVar(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.FixedDurationStartSyncedOnEndIntervalVar"><code class="name flex">
|
|
<span>def <span class="ident">FixedDurationStartSyncedOnEndIntervalVar</span></span>(<span>self, interval_var, duration, offset)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates an interval var with a fixed duration whose start is synchronized with the end of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FixedDurationStartSyncedOnEndIntervalVar(self, interval_var: 'IntervalVar', duration: 'int64', offset: 'int64') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var with a fixed duration whose start is synchronized with the end of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable."""
|
|
return _pywrapcp.Solver_FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.FixedDurationStartSyncedOnStartIntervalVar"><code class="name flex">
|
|
<span>def <span class="ident">FixedDurationStartSyncedOnStartIntervalVar</span></span>(<span>self, interval_var, duration, offset)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates an interval var with a fixed duration whose start is synchronized with the start of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FixedDurationStartSyncedOnStartIntervalVar(self, interval_var: 'IntervalVar', duration: 'int64', offset: 'int64') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var with a fixed duration whose start is synchronized with the start of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable."""
|
|
return _pywrapcp.Solver_FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.FixedInterval"><code class="name flex">
|
|
<span>def <span class="ident">FixedInterval</span></span>(<span>self, start, duration, name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a fixed and performed interval.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def FixedInterval(self, start: 'int64', duration: 'int64', name: 'std::string const &') -> "operations_research::IntervalVar *":
|
|
r""" Creates a fixed and performed interval."""
|
|
return _pywrapcp.Solver_FixedInterval(self, start, duration, name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.GuidedLocalSearch"><code class="name flex">
|
|
<span>def <span class="ident">GuidedLocalSearch</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def GuidedLocalSearch(self, *args) -> "operations_research::SearchMonitor *":
|
|
return _pywrapcp.Solver_GuidedLocalSearch(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IndexExpression"><code class="name flex">
|
|
<span>def <span class="ident">IndexExpression</span></span>(<span>self, vars, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns the expression expr such that vars[expr] == value. It assumes that vars are all different.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IndexExpression(self, vars: 'std::vector< operations_research::IntVar * > const &', value: 'int64') -> "operations_research::IntExpr *":
|
|
r""" Returns the expression expr such that vars[expr] == value. It assumes that vars are all different."""
|
|
return _pywrapcp.Solver_IndexExpression(self, vars, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IndexOfConstraint"><code class="name flex">
|
|
<span>def <span class="ident">IndexOfConstraint</span></span>(<span>self, vars, index, target)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This constraint is a special case of the element constraint with an array of integer variables, where the variables are all different and the index variable is constrained such that vars[index] == target.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IndexOfConstraint(self, vars: 'std::vector< operations_research::IntVar * > const &', index: 'IntVar', target: 'int64') -> "operations_research::Constraint *":
|
|
r""" This constraint is a special case of the element constraint with an array of integer variables, where the variables are all different and the index variable is constrained such that vars[index] == target."""
|
|
return _pywrapcp.Solver_IndexOfConstraint(self, vars, index, target)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IntConst"><code class="name flex">
|
|
<span>def <span class="ident">IntConst</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
IntConst will create a constant expression.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
IntConst will create a constant expression.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IntConst(self, *args) -> "operations_research::IntVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
IntConst will create a constant expression.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
IntConst will create a constant expression.
|
|
"""
|
|
return _pywrapcp.Solver_IntConst(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IntVar"><code class="name flex">
|
|
<span>def <span class="ident">IntVar</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
MakeIntVar will create the best range based int var for the bounds given.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
MakeIntVar will create a variable with the given sparse domain.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 3:</em>
|
|
MakeIntVar will create a variable with the given sparse domain.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 4:</em>
|
|
MakeIntVar will create the best range based int var for the bounds given.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 5:</em>
|
|
MakeIntVar will create a variable with the given sparse domain.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 6:</em>
|
|
MakeIntVar will create a variable with the given sparse domain.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IntVar(self, *args) -> "operations_research::IntVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
MakeIntVar will create the best range based int var for the bounds given.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
MakeIntVar will create a variable with the given sparse domain.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
MakeIntVar will create a variable with the given sparse domain.
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
MakeIntVar will create the best range based int var for the bounds given.
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
MakeIntVar will create a variable with the given sparse domain.
|
|
|
|
|
|
|
|
|
*Overload 6:*
|
|
MakeIntVar will create a variable with the given sparse domain.
|
|
"""
|
|
return _pywrapcp.Solver_IntVar(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IntervalRelaxedMax"><code class="name flex">
|
|
<span>def <span class="ident">IntervalRelaxedMax</span></span>(<span>self, interval_var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates and returns an interval variable that wraps around the given one, relaxing the max start and end. Relaxing means making unbounded when optional. If the variable is non optional, this method returns interval_var. More precisely, such an interval variable behaves as follows: * When the underlying must be performed, the returned interval variable
|
|
behaves exactly as the underlying; * When the underlying may or may not be performed, the returned interval
|
|
variable behaves like the underlying, except that it is unbounded on
|
|
the max side; * When the underlying cannot be performed, the returned interval variable
|
|
is of duration 0 and must be performed in an interval unbounded on
|
|
both sides. This is very useful for implementing propagators that may only modify the start min or end min.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IntervalRelaxedMax(self, interval_var: 'IntervalVar') -> "operations_research::IntervalVar *":
|
|
r""" Creates and returns an interval variable that wraps around the given one, relaxing the max start and end. Relaxing means making unbounded when optional. If the variable is non optional, this method returns interval_var. More precisely, such an interval variable behaves as follows: * When the underlying must be performed, the returned interval variable behaves exactly as the underlying; * When the underlying may or may not be performed, the returned interval variable behaves like the underlying, except that it is unbounded on the max side; * When the underlying cannot be performed, the returned interval variable is of duration 0 and must be performed in an interval unbounded on both sides. This is very useful for implementing propagators that may only modify the start min or end min."""
|
|
return _pywrapcp.Solver_IntervalRelaxedMax(self, interval_var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IntervalRelaxedMin"><code class="name flex">
|
|
<span>def <span class="ident">IntervalRelaxedMin</span></span>(<span>self, interval_var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates and returns an interval variable that wraps around the given one, relaxing the min start and end. Relaxing means making unbounded when optional. If the variable is non-optional, this method returns interval_var. More precisely, such an interval variable behaves as follows: * When the underlying must be performed, the returned interval variable
|
|
behaves exactly as the underlying; * When the underlying may or may not be performed, the returned interval
|
|
variable behaves like the underlying, except that it is unbounded on
|
|
the min side; * When the underlying cannot be performed, the returned interval variable
|
|
is of duration 0 and must be performed in an interval unbounded on
|
|
both sides. This is very useful to implement propagators that may only modify the start max or end max.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IntervalRelaxedMin(self, interval_var: 'IntervalVar') -> "operations_research::IntervalVar *":
|
|
r""" Creates and returns an interval variable that wraps around the given one, relaxing the min start and end. Relaxing means making unbounded when optional. If the variable is non-optional, this method returns interval_var. More precisely, such an interval variable behaves as follows: * When the underlying must be performed, the returned interval variable behaves exactly as the underlying; * When the underlying may or may not be performed, the returned interval variable behaves like the underlying, except that it is unbounded on the min side; * When the underlying cannot be performed, the returned interval variable is of duration 0 and must be performed in an interval unbounded on both sides. This is very useful to implement propagators that may only modify the start max or end max."""
|
|
return _pywrapcp.Solver_IntervalRelaxedMin(self, interval_var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IntervalVar"><code class="name flex">
|
|
<span>def <span class="ident">IntervalVar</span></span>(<span>self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates an interval var by specifying the bounds on start, duration, and end.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IntervalVar(self, start_min: 'int64', start_max: 'int64', duration_min: 'int64', duration_max: 'int64', end_min: 'int64', end_max: 'int64', optional: 'bool', name: 'std::string const &') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var by specifying the bounds on start, duration, and end."""
|
|
return _pywrapcp.Solver_IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.InversePermutationConstraint"><code class="name flex">
|
|
<span>def <span class="ident">InversePermutationConstraint</span></span>(<span>self, left, right)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a constraint that enforces that 'left' and 'right' both represent permutations of [0..left.size()-1], and that 'right' is the inverse permutation of 'left', i.e. for all i in [0..left.size()-1], right[left[i]] = i.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def InversePermutationConstraint(self, left: 'std::vector< operations_research::IntVar * > const &', right: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint that enforces that 'left' and 'right' both represent permutations of [0..left.size()-1], and that 'right' is the inverse permutation of 'left', i.e. for all i in [0..left.size()-1], right[left[i]] = i."""
|
|
return _pywrapcp.Solver_InversePermutationConstraint(self, left, right)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsBetweenCt"><code class="name flex">
|
|
<span>def <span class="ident">IsBetweenCt</span></span>(<span>self, expr, l, u, b)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>b == (l <= expr <= u)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsBetweenCt(self, expr: 'IntExpr', l: 'int64', u: 'int64', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (l <= expr <= u)"""
|
|
return _pywrapcp.Solver_IsBetweenCt(self, expr, l, u, b)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsBetweenVar"><code class="name flex">
|
|
<span>def <span class="ident">IsBetweenVar</span></span>(<span>self, v, l, u)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsBetweenVar(self, v: 'IntExpr', l: 'int64', u: 'int64') -> "operations_research::IntVar *":
|
|
return _pywrapcp.Solver_IsBetweenVar(self, v, l, u)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsDifferentCstCt"><code class="name flex">
|
|
<span>def <span class="ident">IsDifferentCstCt</span></span>(<span>self, var, value, boolvar)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>boolvar == (var != value)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsDifferentCstCt(self, var: 'IntExpr', value: 'int64', boolvar: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" boolvar == (var != value)"""
|
|
return _pywrapcp.Solver_IsDifferentCstCt(self, var, value, boolvar)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsDifferentCstVar"><code class="name flex">
|
|
<span>def <span class="ident">IsDifferentCstVar</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>status var of (var != value)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsDifferentCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var != value)"""
|
|
return _pywrapcp.Solver_IsDifferentCstVar(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsDifferentCt"><code class="name flex">
|
|
<span>def <span class="ident">IsDifferentCt</span></span>(<span>self, v1, v2, b)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>b == (v1 != v2)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsDifferentCt(self, v1: 'IntExpr', v2: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (v1 != v2)"""
|
|
return _pywrapcp.Solver_IsDifferentCt(self, v1, v2, b)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsDifferentVar"><code class="name flex">
|
|
<span>def <span class="ident">IsDifferentVar</span></span>(<span>self, v1, v2)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>status var of (v1 != v2)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsDifferentVar(self, v1: 'IntExpr', v2: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (v1 != v2)"""
|
|
return _pywrapcp.Solver_IsDifferentVar(self, v1, v2)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsEqualCstCt"><code class="name flex">
|
|
<span>def <span class="ident">IsEqualCstCt</span></span>(<span>self, var, value, boolvar)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>boolvar == (var == value)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsEqualCstCt(self, var: 'IntExpr', value: 'int64', boolvar: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" boolvar == (var == value)"""
|
|
return _pywrapcp.Solver_IsEqualCstCt(self, var, value, boolvar)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsEqualCstVar"><code class="name flex">
|
|
<span>def <span class="ident">IsEqualCstVar</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>status var of (var == value)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsEqualCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var == value)"""
|
|
return _pywrapcp.Solver_IsEqualCstVar(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsEqualCt"><code class="name flex">
|
|
<span>def <span class="ident">IsEqualCt</span></span>(<span>self, v1, v2, b)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>b == (v1 == v2)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsEqualCt(self, v1: 'IntExpr', v2: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (v1 == v2)"""
|
|
return _pywrapcp.Solver_IsEqualCt(self, v1, v2, b)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsEqualVar"><code class="name flex">
|
|
<span>def <span class="ident">IsEqualVar</span></span>(<span>self, v1, v2)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>status var of (v1 == v2)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsEqualVar(self, v1: 'IntExpr', v2: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (v1 == v2)"""
|
|
return _pywrapcp.Solver_IsEqualVar(self, v1, v2)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsGreaterCstCt"><code class="name flex">
|
|
<span>def <span class="ident">IsGreaterCstCt</span></span>(<span>self, v, c, b)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>b == (v > c)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsGreaterCstCt(self, v: 'IntExpr', c: 'int64', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (v > c)"""
|
|
return _pywrapcp.Solver_IsGreaterCstCt(self, v, c, b)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsGreaterCstVar"><code class="name flex">
|
|
<span>def <span class="ident">IsGreaterCstVar</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>status var of (var > value)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsGreaterCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var > value)"""
|
|
return _pywrapcp.Solver_IsGreaterCstVar(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsGreaterCt"><code class="name flex">
|
|
<span>def <span class="ident">IsGreaterCt</span></span>(<span>self, left, right, b)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>b == (left > right)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsGreaterCt(self, left: 'IntExpr', right: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (left > right)"""
|
|
return _pywrapcp.Solver_IsGreaterCt(self, left, right, b)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsGreaterOrEqualCstCt"><code class="name flex">
|
|
<span>def <span class="ident">IsGreaterOrEqualCstCt</span></span>(<span>self, var, value, boolvar)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>boolvar == (var >= value)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsGreaterOrEqualCstCt(self, var: 'IntExpr', value: 'int64', boolvar: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" boolvar == (var >= value)"""
|
|
return _pywrapcp.Solver_IsGreaterOrEqualCstCt(self, var, value, boolvar)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsGreaterOrEqualCstVar"><code class="name flex">
|
|
<span>def <span class="ident">IsGreaterOrEqualCstVar</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>status var of (var >= value)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsGreaterOrEqualCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var >= value)"""
|
|
return _pywrapcp.Solver_IsGreaterOrEqualCstVar(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsGreaterOrEqualCt"><code class="name flex">
|
|
<span>def <span class="ident">IsGreaterOrEqualCt</span></span>(<span>self, left, right, b)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>b == (left >= right)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsGreaterOrEqualCt(self, left: 'IntExpr', right: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (left >= right)"""
|
|
return _pywrapcp.Solver_IsGreaterOrEqualCt(self, left, right, b)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsGreaterOrEqualVar"><code class="name flex">
|
|
<span>def <span class="ident">IsGreaterOrEqualVar</span></span>(<span>self, left, right)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>status var of (left >= right)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsGreaterOrEqualVar(self, left: 'IntExpr', right: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (left >= right)"""
|
|
return _pywrapcp.Solver_IsGreaterOrEqualVar(self, left, right)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsGreaterVar"><code class="name flex">
|
|
<span>def <span class="ident">IsGreaterVar</span></span>(<span>self, left, right)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>status var of (left > right)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsGreaterVar(self, left: 'IntExpr', right: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (left > right)"""
|
|
return _pywrapcp.Solver_IsGreaterVar(self, left, right)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsLessCstCt"><code class="name flex">
|
|
<span>def <span class="ident">IsLessCstCt</span></span>(<span>self, v, c, b)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>b == (v < c)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsLessCstCt(self, v: 'IntExpr', c: 'int64', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (v < c)"""
|
|
return _pywrapcp.Solver_IsLessCstCt(self, v, c, b)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsLessCstVar"><code class="name flex">
|
|
<span>def <span class="ident">IsLessCstVar</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>status var of (var < value)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsLessCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var < value)"""
|
|
return _pywrapcp.Solver_IsLessCstVar(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsLessCt"><code class="name flex">
|
|
<span>def <span class="ident">IsLessCt</span></span>(<span>self, left, right, b)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>b == (left < right)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsLessCt(self, left: 'IntExpr', right: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (left < right)"""
|
|
return _pywrapcp.Solver_IsLessCt(self, left, right, b)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsLessOrEqualCstCt"><code class="name flex">
|
|
<span>def <span class="ident">IsLessOrEqualCstCt</span></span>(<span>self, var, value, boolvar)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>boolvar == (var <= value)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsLessOrEqualCstCt(self, var: 'IntExpr', value: 'int64', boolvar: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" boolvar == (var <= value)"""
|
|
return _pywrapcp.Solver_IsLessOrEqualCstCt(self, var, value, boolvar)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsLessOrEqualCstVar"><code class="name flex">
|
|
<span>def <span class="ident">IsLessOrEqualCstVar</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>status var of (var <= value)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsLessOrEqualCstVar(self, var: 'IntExpr', value: 'int64') -> "operations_research::IntVar *":
|
|
r""" status var of (var <= value)"""
|
|
return _pywrapcp.Solver_IsLessOrEqualCstVar(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsLessOrEqualCt"><code class="name flex">
|
|
<span>def <span class="ident">IsLessOrEqualCt</span></span>(<span>self, left, right, b)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>b == (left <= right)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsLessOrEqualCt(self, left: 'IntExpr', right: 'IntExpr', b: 'IntVar') -> "operations_research::Constraint *":
|
|
r""" b == (left <= right)"""
|
|
return _pywrapcp.Solver_IsLessOrEqualCt(self, left, right, b)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsLessOrEqualVar"><code class="name flex">
|
|
<span>def <span class="ident">IsLessOrEqualVar</span></span>(<span>self, left, right)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>status var of (left <= right)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsLessOrEqualVar(self, left: 'IntExpr', right: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (left <= right)"""
|
|
return _pywrapcp.Solver_IsLessOrEqualVar(self, left, right)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsLessVar"><code class="name flex">
|
|
<span>def <span class="ident">IsLessVar</span></span>(<span>self, left, right)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>status var of (left < right)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsLessVar(self, left: 'IntExpr', right: 'IntExpr') -> "operations_research::IntVar *":
|
|
r""" status var of (left < right)"""
|
|
return _pywrapcp.Solver_IsLessVar(self, left, right)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsMemberCt"><code class="name flex">
|
|
<span>def <span class="ident">IsMemberCt</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsMemberCt(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_IsMemberCt(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.IsMemberVar"><code class="name flex">
|
|
<span>def <span class="ident">IsMemberVar</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def IsMemberVar(self, *args) -> "operations_research::IntVar *":
|
|
return _pywrapcp.Solver_IsMemberVar(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.LastSolutionCollector"><code class="name flex">
|
|
<span>def <span class="ident">LastSolutionCollector</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Collect the last solution of the search.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Collect the last solution of the search. The variables will need to be added later.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def LastSolutionCollector(self, *args) -> "operations_research::SolutionCollector *":
|
|
r"""
|
|
*Overload 1:*
|
|
Collect the last solution of the search.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Collect the last solution of the search. The variables will need to be added later.
|
|
"""
|
|
return _pywrapcp.Solver_LastSolutionCollector(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.LexicalLess"><code class="name flex">
|
|
<span>def <span class="ident">LexicalLess</span></span>(<span>self, left, right)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>std::vector<IntVar*>* const
|
|
sorted); Creates a constraint that enforces that left is lexicographically less than right.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def LexicalLess(self, left: 'std::vector< operations_research::IntVar * > const &', right: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" std::vector<IntVar*>* const sorted); Creates a constraint that enforces that left is lexicographically less than right."""
|
|
return _pywrapcp.Solver_LexicalLess(self, left, right)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.LexicalLessOrEqual"><code class="name flex">
|
|
<span>def <span class="ident">LexicalLessOrEqual</span></span>(<span>self, left, right)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a constraint that enforces that left is lexicographically less than or equal to right.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def LexicalLessOrEqual(self, left: 'std::vector< operations_research::IntVar * > const &', right: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint that enforces that left is lexicographically less than or equal to right."""
|
|
return _pywrapcp.Solver_LexicalLessOrEqual(self, left, right)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Limit"><code class="name flex">
|
|
<span>def <span class="ident">Limit</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Limits the search with the 'time', 'branches', 'failures' and 'solutions' limits.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Version reducing calls to wall timer by estimating number of remaining calls.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 3:</em>
|
|
Creates a search limit which can either apply cumulatively or search-by-search.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 4:</em>
|
|
Creates a search limit from its protobuf description</p>
|
|
<p>|</p>
|
|
<p><em>Overload 5:</em>
|
|
Creates a search limit that is reached when either of the underlying limit is reached. That is, the returned limit is more stringent than both argument limits.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Limit(self, *args) -> "operations_research::SearchLimit *":
|
|
r"""
|
|
*Overload 1:*
|
|
Limits the search with the 'time', 'branches', 'failures' and 'solutions' limits.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Version reducing calls to wall timer by estimating number of remaining calls.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Creates a search limit which can either apply cumulatively or search-by-search.
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
Creates a search limit from its protobuf description
|
|
|
|
|
|
|
|
|
*Overload 5:*
|
|
Creates a search limit that is reached when either of the underlying limit is reached. That is, the returned limit is more stringent than both argument limits.
|
|
"""
|
|
return _pywrapcp.Solver_Limit(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.LocalSearchPhase"><code class="name flex">
|
|
<span>def <span class="ident">LocalSearchPhase</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def LocalSearchPhase(self, *args) -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_LocalSearchPhase(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.LocalSearchPhaseParameters"><code class="name flex">
|
|
<span>def <span class="ident">LocalSearchPhaseParameters</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def LocalSearchPhaseParameters(self, *args) -> "operations_research::LocalSearchPhaseParameters *":
|
|
return _pywrapcp.Solver_LocalSearchPhaseParameters(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.LocalSearchProfile"><code class="name flex">
|
|
<span>def <span class="ident">LocalSearchProfile</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns local search profiling information in a human readable format. search profiles.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def LocalSearchProfile(self) -> "std::string":
|
|
r""" Returns local search profiling information in a human readable format. search profiles."""
|
|
return _pywrapcp.Solver_LocalSearchProfile(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.LubyRestart"><code class="name flex">
|
|
<span>def <span class="ident">LubyRestart</span></span>(<span>self, scale_factor)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This search monitor will restart the search periodically. At the iteration n, it will restart after scale_factor * Luby(n) failures where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8…).</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def LubyRestart(self, scale_factor: 'int') -> "operations_research::SearchMonitor *":
|
|
r""" This search monitor will restart the search periodically. At the iteration n, it will restart after scale_factor * Luby(n) failures where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...)."""
|
|
return _pywrapcp.Solver_LubyRestart(self, scale_factor)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Max"><code class="name flex">
|
|
<span>def <span class="ident">Max</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
std::max(vars)</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
std::max(left, right)</p>
|
|
<p>|</p>
|
|
<p><em>Overload 3:</em>
|
|
std::max(expr, value)</p>
|
|
<p>|</p>
|
|
<p><em>Overload 4:</em>
|
|
std::max(expr, value)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Max(self, *args) -> "operations_research::IntExpr *":
|
|
r"""
|
|
*Overload 1:*
|
|
std::max(vars)
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
std::max(left, right)
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
std::max(expr, value)
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
std::max(expr, value)
|
|
"""
|
|
return _pywrapcp.Solver_Max(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.MaxEquality"><code class="name flex">
|
|
<span>def <span class="ident">MaxEquality</span></span>(<span>self, vars, max_var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MaxEquality(self, vars: 'std::vector< operations_research::IntVar * > const &', max_var: 'IntVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_MaxEquality(self, vars, max_var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Maximize"><code class="name flex">
|
|
<span>def <span class="ident">Maximize</span></span>(<span>self, v, step)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a maximization objective.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Maximize(self, v: 'IntVar', step: 'int64') -> "operations_research::OptimizeVar *":
|
|
r""" Creates a maximization objective."""
|
|
return _pywrapcp.Solver_Maximize(self, v, step)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.MemberCt"><code class="name flex">
|
|
<span>def <span class="ident">MemberCt</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MemberCt(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_MemberCt(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Min"><code class="name flex">
|
|
<span>def <span class="ident">Min</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
std::min(vars)</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
std::min (left, right)</p>
|
|
<p>|</p>
|
|
<p><em>Overload 3:</em>
|
|
std::min(expr, value)</p>
|
|
<p>|</p>
|
|
<p><em>Overload 4:</em>
|
|
std::min(expr, value)</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Min(self, *args) -> "operations_research::IntExpr *":
|
|
r"""
|
|
*Overload 1:*
|
|
std::min(vars)
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
std::min (left, right)
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
std::min(expr, value)
|
|
|
|
|
|
|
|
|
*Overload 4:*
|
|
std::min(expr, value)
|
|
"""
|
|
return _pywrapcp.Solver_Min(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.MinEquality"><code class="name flex">
|
|
<span>def <span class="ident">MinEquality</span></span>(<span>self, vars, min_var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MinEquality(self, vars: 'std::vector< operations_research::IntVar * > const &', min_var: 'IntVar') -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_MinEquality(self, vars, min_var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Minimize"><code class="name flex">
|
|
<span>def <span class="ident">Minimize</span></span>(<span>self, v, step)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a minimization objective.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Minimize(self, v: 'IntVar', step: 'int64') -> "operations_research::OptimizeVar *":
|
|
r""" Creates a minimization objective."""
|
|
return _pywrapcp.Solver_Minimize(self, v, step)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.MirrorInterval"><code class="name flex">
|
|
<span>def <span class="ident">MirrorInterval</span></span>(<span>self, interval_var)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates an interval var that is the mirror image of the given one, that is, the interval var obtained by reversing the axis.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MirrorInterval(self, interval_var: 'IntervalVar') -> "operations_research::IntervalVar *":
|
|
r""" Creates an interval var that is the mirror image of the given one, that is, the interval var obtained by reversing the axis."""
|
|
return _pywrapcp.Solver_MirrorInterval(self, interval_var)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.MonotonicElement"><code class="name flex">
|
|
<span>def <span class="ident">MonotonicElement</span></span>(<span>self, values, increasing, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Function based element. The constraint takes ownership of the callback.
|
|
The callback must be monotonic. It must be able to cope with any possible value in the domain of 'index' (potentially negative ones too). Furtermore, monotonicity is not checked. Thus giving a non-monotonic function, or specifying an incorrect increasing parameter will result in undefined behavior.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MonotonicElement(self, values: 'operations_research::Solver::IndexEvaluator1', increasing: 'bool', index: 'IntVar') -> "operations_research::IntExpr *":
|
|
r""" Function based element. The constraint takes ownership of the callback. The callback must be monotonic. It must be able to cope with any possible value in the domain of 'index' (potentially negative ones too). Furtermore, monotonicity is not checked. Thus giving a non-monotonic function, or specifying an incorrect increasing parameter will result in undefined behavior."""
|
|
return _pywrapcp.Solver_MonotonicElement(self, values, increasing, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.MoveTowardTargetOperator"><code class="name flex">
|
|
<span>def <span class="ident">MoveTowardTargetOperator</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Creates a local search operator that tries to move the assignment of some variables toward a target. The target is given as an Assignment. This operator generates neighbors in which the only difference compared to the current state is that one variable that belongs to the target assignment is set to its target value.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Creates a local search operator that tries to move the assignment of some variables toward a target. The target is given either as two vectors: a vector of variables and a vector of associated target values. The two vectors should be of the same length. This operator generates neighbors in which the only difference compared to the current state is that one variable that belongs to the given vector is set to its target value.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def MoveTowardTargetOperator(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a local search operator that tries to move the assignment of some variables toward a target. The target is given as an Assignment. This operator generates neighbors in which the only difference compared to the current state is that one variable that belongs to the target assignment is set to its target value.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a local search operator that tries to move the assignment of some variables toward a target. The target is given either as two vectors: a vector of variables and a vector of associated target values. The two vectors should be of the same length. This operator generates neighbors in which the only difference compared to the current state is that one variable that belongs to the given vector is set to its target value.
|
|
"""
|
|
return _pywrapcp.Solver_MoveTowardTargetOperator(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.NeighborhoodLimit"><code class="name flex">
|
|
<span>def <span class="ident">NeighborhoodLimit</span></span>(<span>self, op, limit)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a local search operator that wraps another local search operator and limits the number of neighbors explored (i.e., calls to MakeNextNeighbor from the current solution (between two calls to Start()). When this limit is reached, MakeNextNeighbor() returns false. The counter is cleared when Start() is called.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NeighborhoodLimit(self, op: 'LocalSearchOperator', limit: 'int64') -> "operations_research::LocalSearchOperator *":
|
|
r""" Creates a local search operator that wraps another local search operator and limits the number of neighbors explored (i.e., calls to MakeNextNeighbor from the current solution (between two calls to Start()). When this limit is reached, MakeNextNeighbor() returns false. The counter is cleared when Start() is called."""
|
|
return _pywrapcp.Solver_NeighborhoodLimit(self, op, limit)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.NestedOptimize"><code class="name flex">
|
|
<span>def <span class="ident">NestedOptimize</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NestedOptimize(self, *args) -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_NestedOptimize(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.NewSearch"><code class="name flex">
|
|
<span>def <span class="ident">NewSearch</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NewSearch(self, *args) -> "void":
|
|
return _pywrapcp.Solver_NewSearch(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.NextSolution"><code class="name flex">
|
|
<span>def <span class="ident">NextSolution</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NextSolution(self) -> "bool":
|
|
return _pywrapcp.Solver_NextSolution(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.NonOverlappingBoxesConstraint"><code class="name flex">
|
|
<span>def <span class="ident">NonOverlappingBoxesConstraint</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NonOverlappingBoxesConstraint(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_NonOverlappingBoxesConstraint(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.NotMemberCt"><code class="name flex">
|
|
<span>def <span class="ident">NotMemberCt</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
expr not in set.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
expr should not be in the list of forbidden intervals [start[i]..end[i]].</p>
|
|
<p>|</p>
|
|
<p><em>Overload 3:</em>
|
|
expr should not be in the list of forbidden intervals [start[i]..end[i]].</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NotMemberCt(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
expr not in set.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
expr should not be in the list of forbidden intervals [start[i]..end[i]].
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
expr should not be in the list of forbidden intervals [start[i]..end[i]].
|
|
"""
|
|
return _pywrapcp.Solver_NotMemberCt(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.NullIntersect"><code class="name flex">
|
|
<span>def <span class="ident">NullIntersect</span></span>(<span>self, first_vars, second_vars)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a constraint that states that all variables in the first vector are different from all variables in the second group. Thus the set of values in the first vector does not intersect with the set of values in the second vector.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NullIntersect(self, first_vars: 'std::vector< operations_research::IntVar * > const &', second_vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint that states that all variables in the first vector are different from all variables in the second group. Thus the set of values in the first vector does not intersect with the set of values in the second vector."""
|
|
return _pywrapcp.Solver_NullIntersect(self, first_vars, second_vars)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.NullIntersectExcept"><code class="name flex">
|
|
<span>def <span class="ident">NullIntersectExcept</span></span>(<span>self, first_vars, second_vars, escape_value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a constraint that states that all variables in the first vector are different from all variables from the second group, unless they are assigned to the escape value. Thus the set of values in the first vector minus the escape value does not intersect with the set of values in the second vector.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def NullIntersectExcept(self, first_vars: 'std::vector< operations_research::IntVar * > const &', second_vars: 'std::vector< operations_research::IntVar * > const &', escape_value: 'int64') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint that states that all variables in the first vector are different from all variables from the second group, unless they are assigned to the escape value. Thus the set of values in the first vector minus the escape value does not intersect with the set of values in the second vector."""
|
|
return _pywrapcp.Solver_NullIntersectExcept(self, first_vars, second_vars, escape_value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Operator"><code class="name flex">
|
|
<span>def <span class="ident">Operator</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Operator(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
return _pywrapcp.Solver_Operator(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Optimize"><code class="name flex">
|
|
<span>def <span class="ident">Optimize</span></span>(<span>self, maximize, v, step)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a objective with a given sense (true = maximization).</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Optimize(self, maximize: 'bool', v: 'IntVar', step: 'int64') -> "operations_research::OptimizeVar *":
|
|
r""" Creates a objective with a given sense (true = maximization)."""
|
|
return _pywrapcp.Solver_Optimize(self, maximize, v, step)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Pack"><code class="name flex">
|
|
<span>def <span class="ident">Pack</span></span>(<span>self, vars, number_of_bins)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This constraint packs all variables onto 'number_of_bins' variables.
|
|
For any given variable, a value of 'number_of_bins' indicates that the variable is not assigned to any bin. Dimensions, i.e., cumulative constraints on this packing, can be added directly from the pack class.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Pack(self, vars: 'std::vector< operations_research::IntVar * > const &', number_of_bins: 'int') -> "operations_research::Pack *":
|
|
r""" This constraint packs all variables onto 'number_of_bins' variables. For any given variable, a value of 'number_of_bins' indicates that the variable is not assigned to any bin. Dimensions, i.e., cumulative constraints on this packing, can be added directly from the pack class."""
|
|
return _pywrapcp.Solver_Pack(self, vars, number_of_bins)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Parameters"><code class="name flex">
|
|
<span>def <span class="ident">Parameters</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Stored Parameters.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Parameters(self) -> "operations_research::ConstraintSolverParameters":
|
|
r""" Stored Parameters."""
|
|
return _pywrapcp.Solver_Parameters(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.PathCumul"><code class="name flex">
|
|
<span>def <span class="ident">PathCumul</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transits[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 3:</em>
|
|
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def PathCumul(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transits[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.
|
|
|
|
|
|
|
|
|
*Overload 3:*
|
|
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.
|
|
"""
|
|
return _pywrapcp.Solver_PathCumul(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Phase"><code class="name flex">
|
|
<span>def <span class="ident">Phase</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Phase(self, *args) -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_Phase(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.PrintModelVisitor"><code class="name flex">
|
|
<span>def <span class="ident">PrintModelVisitor</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Prints the model.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def PrintModelVisitor(self) -> "operations_research::ModelVisitor *":
|
|
r""" Prints the model."""
|
|
return _pywrapcp.Solver_PrintModelVisitor(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Rand32"><code class="name flex">
|
|
<span>def <span class="ident">Rand32</span></span>(<span>self, size)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns a random value between 0 and 'size' - 1;</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Rand32(self, size: 'int32') -> "int32":
|
|
r""" Returns a random value between 0 and 'size' - 1;"""
|
|
return _pywrapcp.Solver_Rand32(self, size)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Rand64"><code class="name flex">
|
|
<span>def <span class="ident">Rand64</span></span>(<span>self, size)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns a random value between 0 and 'size' - 1;</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Rand64(self, size: 'int64') -> "int64":
|
|
r""" Returns a random value between 0 and 'size' - 1;"""
|
|
return _pywrapcp.Solver_Rand64(self, size)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.RandomConcatenateOperators"><code class="name flex">
|
|
<span>def <span class="ident">RandomConcatenateOperators</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeighbor().</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeighbor(). The provided seed is used to initialize the random number generator.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RandomConcatenateOperators(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
r"""
|
|
*Overload 1:*
|
|
Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeighbor().
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeighbor(). The provided seed is used to initialize the random number generator.
|
|
"""
|
|
return _pywrapcp.Solver_RandomConcatenateOperators(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.RandomLnsOperator"><code class="name flex">
|
|
<span>def <span class="ident">RandomLnsOperator</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RandomLnsOperator(self, *args) -> "operations_research::LocalSearchOperator *":
|
|
return _pywrapcp.Solver_RandomLnsOperator(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.RankFirstInterval"><code class="name flex">
|
|
<span>def <span class="ident">RankFirstInterval</span></span>(<span>self, sequence, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns a decision that tries to rank first the ith interval var in the sequence variable.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RankFirstInterval(self, sequence: 'SequenceVar', index: 'int') -> "operations_research::Decision *":
|
|
r""" Returns a decision that tries to rank first the ith interval var in the sequence variable."""
|
|
return _pywrapcp.Solver_RankFirstInterval(self, sequence, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.RankLastInterval"><code class="name flex">
|
|
<span>def <span class="ident">RankLastInterval</span></span>(<span>self, sequence, index)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns a decision that tries to rank last the ith interval var in the sequence variable.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RankLastInterval(self, sequence: 'SequenceVar', index: 'int') -> "operations_research::Decision *":
|
|
r""" Returns a decision that tries to rank last the ith interval var in the sequence variable."""
|
|
return _pywrapcp.Solver_RankLastInterval(self, sequence, index)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ReSeed"><code class="name flex">
|
|
<span>def <span class="ident">ReSeed</span></span>(<span>self, seed)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Reseed the solver random generator.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ReSeed(self, seed: 'int32') -> "void":
|
|
r""" Reseed the solver random generator."""
|
|
return _pywrapcp.Solver_ReSeed(self, seed)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.RestartCurrentSearch"><code class="name flex">
|
|
<span>def <span class="ident">RestartCurrentSearch</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RestartCurrentSearch(self) -> "void":
|
|
return _pywrapcp.Solver_RestartCurrentSearch(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.RestartSearch"><code class="name flex">
|
|
<span>def <span class="ident">RestartSearch</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RestartSearch(self) -> "void":
|
|
return _pywrapcp.Solver_RestartSearch(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.RestoreAssignment"><code class="name flex">
|
|
<span>def <span class="ident">RestoreAssignment</span></span>(<span>self, assignment)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns a DecisionBuilder which restores an Assignment (calls void Assignment::Restore())</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def RestoreAssignment(self, assignment: 'Assignment') -> "operations_research::DecisionBuilder *":
|
|
r""" Returns a DecisionBuilder which restores an Assignment (calls void Assignment::Restore())"""
|
|
return _pywrapcp.Solver_RestoreAssignment(self, assignment)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ScalProd"><code class="name flex">
|
|
<span>def <span class="ident">ScalProd</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
scalar product</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
scalar product</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ScalProd(self, *args) -> "operations_research::IntExpr *":
|
|
r"""
|
|
*Overload 1:*
|
|
scalar product
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
scalar product
|
|
"""
|
|
return _pywrapcp.Solver_ScalProd(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ScalProdEquality"><code class="name flex">
|
|
<span>def <span class="ident">ScalProdEquality</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ScalProdEquality(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_ScalProdEquality(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ScalProdGreaterOrEqual"><code class="name flex">
|
|
<span>def <span class="ident">ScalProdGreaterOrEqual</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ScalProdGreaterOrEqual(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_ScalProdGreaterOrEqual(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ScalProdLessOrEqual"><code class="name flex">
|
|
<span>def <span class="ident">ScalProdLessOrEqual</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ScalProdLessOrEqual(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_ScalProdLessOrEqual(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ScheduleOrExpedite"><code class="name flex">
|
|
<span>def <span class="ident">ScheduleOrExpedite</span></span>(<span>self, var, est, marker)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns a decision that tries to schedule a task at a given time. On the Apply branch, it will set that interval var as performed and set its end to 'est'. On the Refute branch, it will just update the 'marker' to 'est' - 1. This decision is used in the INTERVAL_SET_TIMES_BACKWARD strategy.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ScheduleOrExpedite(self, var: 'IntervalVar', est: 'int64', marker: 'int64 *const') -> "operations_research::Decision *":
|
|
r""" Returns a decision that tries to schedule a task at a given time. On the Apply branch, it will set that interval var as performed and set its end to 'est'. On the Refute branch, it will just update the 'marker' to 'est' - 1. This decision is used in the INTERVAL_SET_TIMES_BACKWARD strategy."""
|
|
return _pywrapcp.Solver_ScheduleOrExpedite(self, var, est, marker)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ScheduleOrPostpone"><code class="name flex">
|
|
<span>def <span class="ident">ScheduleOrPostpone</span></span>(<span>self, var, est, marker)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns a decision that tries to schedule a task at a given time. On the Apply branch, it will set that interval var as performed and set its start to 'est'. On the Refute branch, it will just update the 'marker' to 'est' + 1. This decision is used in the INTERVAL_SET_TIMES_FORWARD strategy.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ScheduleOrPostpone(self, var: 'IntervalVar', est: 'int64', marker: 'int64 *const') -> "operations_research::Decision *":
|
|
r""" Returns a decision that tries to schedule a task at a given time. On the Apply branch, it will set that interval var as performed and set its start to 'est'. On the Refute branch, it will just update the 'marker' to 'est' + 1. This decision is used in the INTERVAL_SET_TIMES_FORWARD strategy."""
|
|
return _pywrapcp.Solver_ScheduleOrPostpone(self, var, est, marker)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SearchDepth"><code class="name flex">
|
|
<span>def <span class="ident">SearchDepth</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Gets the search depth of the current active search. Returns -1 if there is no active search opened.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SearchDepth(self) -> "int":
|
|
r""" Gets the search depth of the current active search. Returns -1 if there is no active search opened."""
|
|
return _pywrapcp.Solver_SearchDepth(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SearchLeftDepth"><code class="name flex">
|
|
<span>def <span class="ident">SearchLeftDepth</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Gets the search left depth of the current active search. Returns -1 if there is no active search opened.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SearchLeftDepth(self) -> "int":
|
|
r""" Gets the search left depth of the current active search. Returns -1 if there is no active search opened."""
|
|
return _pywrapcp.Solver_SearchLeftDepth(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SearchLog"><code class="name flex">
|
|
<span>def <span class="ident">SearchLog</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SearchLog(self, *args) -> "operations_research::SearchMonitor *":
|
|
return _pywrapcp.Solver_SearchLog(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SearchLogWithCallback"><code class="name flex">
|
|
<span>def <span class="ident">SearchLogWithCallback</span></span>(<span>self, period, callback)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SearchLogWithCallback(self, period: 'int', callback: 'std::function< std::string () >') -> "operations_research::SearchMonitor *":
|
|
return _pywrapcp.Solver_SearchLogWithCallback(self, period, callback)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SearchTrace"><code class="name flex">
|
|
<span>def <span class="ident">SearchTrace</span></span>(<span>self, prefix)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a search monitor that will trace precisely the behavior of the search. Use this only for low level debugging.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SearchTrace(self, prefix: 'std::string const &') -> "operations_research::SearchMonitor *":
|
|
r""" Creates a search monitor that will trace precisely the behavior of the search. Use this only for low level debugging."""
|
|
return _pywrapcp.Solver_SearchTrace(self, prefix)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SemiContinuousExpr"><code class="name flex">
|
|
<span>def <span class="ident">SemiContinuousExpr</span></span>(<span>self, expr, fixed_charge, step)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) a >= 0 and b >= 0</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SemiContinuousExpr(self, expr: 'IntExpr', fixed_charge: 'int64', step: 'int64') -> "operations_research::IntExpr *":
|
|
r""" Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) a >= 0 and b >= 0"""
|
|
return _pywrapcp.Solver_SemiContinuousExpr(self, expr, fixed_charge, step)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.ShouldFail"><code class="name flex">
|
|
<span>def <span class="ident">ShouldFail</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>These methods are only useful for the SWIG wrappers, which need a way to externally cause the Solver to fail.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def ShouldFail(self) -> "void":
|
|
r""" These methods are only useful for the SWIG wrappers, which need a way to externally cause the Solver to fail."""
|
|
return _pywrapcp.Solver_ShouldFail(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SimulatedAnnealing"><code class="name flex">
|
|
<span>def <span class="ident">SimulatedAnnealing</span></span>(<span>self, maximize, v, step, initial_temperature)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a Simulated Annealing monitor.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SimulatedAnnealing(self, maximize: 'bool', v: 'IntVar', step: 'int64', initial_temperature: 'int64') -> "operations_research::SearchMonitor *":
|
|
r""" Creates a Simulated Annealing monitor."""
|
|
return _pywrapcp.Solver_SimulatedAnnealing(self, maximize, v, step, initial_temperature)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Solutions"><code class="name flex">
|
|
<span>def <span class="ident">Solutions</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The number of solutions found since the start of the search.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Solutions(self) -> "int64":
|
|
r""" The number of solutions found since the start of the search."""
|
|
return _pywrapcp.Solver_Solutions(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SolutionsLimit"><code class="name flex">
|
|
<span>def <span class="ident">SolutionsLimit</span></span>(<span>self, solutions)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a search limit that constrains the number of solutions found during the search.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SolutionsLimit(self, solutions: 'int64') -> "operations_research::RegularLimit *":
|
|
r""" Creates a search limit that constrains the number of solutions found during the search."""
|
|
return _pywrapcp.Solver_SolutionsLimit(self, solutions)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Solve"><code class="name flex">
|
|
<span>def <span class="ident">Solve</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Solve(self, *args) -> "bool":
|
|
return _pywrapcp.Solver_Solve(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SolveAndCommit"><code class="name flex">
|
|
<span>def <span class="ident">SolveAndCommit</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SolveAndCommit(self, *args) -> "bool":
|
|
return _pywrapcp.Solver_SolveAndCommit(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SolveDepth"><code class="name flex">
|
|
<span>def <span class="ident">SolveDepth</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Gets the number of nested searches. It returns 0 outside search, 1 during the top level search, 2 or more in case of nested searches.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SolveDepth(self) -> "int":
|
|
r""" Gets the number of nested searches. It returns 0 outside search, 1 during the top level search, 2 or more in case of nested searches."""
|
|
return _pywrapcp.Solver_SolveDepth(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SolveOnce"><code class="name flex">
|
|
<span>def <span class="ident">SolveOnce</span></span>(<span>self, db, monitors)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SolveOnce(self, db: 'DecisionBuilder', monitors: 'std::vector< operations_research::SearchMonitor * > const &') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_SolveOnce(self, db, monitors)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SortingConstraint"><code class="name flex">
|
|
<span>def <span class="ident">SortingConstraint</span></span>(<span>self, vars, sorted)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a constraint binding the arrays of variables "vars" and "sorted_vars": sorted_vars[0] must be equal to the minimum of all variables in vars, and so on: the value of sorted_vars[i] must be equal to the i-th value of variables invars. This constraint propagates in both directions: from "vars" to "sorted_vars" and vice-versa. Behind the scenes, this constraint maintains that:
|
|
- sorted is always increasing.
|
|
- whatever the values of vars, there exists a permutation that
|
|
injects its values into the sorted variables. For more info, please have a look at:
|
|
<a href="https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf">https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf</a></p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SortingConstraint(self, vars: 'std::vector< operations_research::IntVar * > const &', sorted: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Creates a constraint binding the arrays of variables "vars" and "sorted_vars": sorted_vars[0] must be equal to the minimum of all variables in vars, and so on: the value of sorted_vars[i] must be equal to the i-th value of variables invars. This constraint propagates in both directions: from "vars" to "sorted_vars" and vice-versa. Behind the scenes, this constraint maintains that: - sorted is always increasing. - whatever the values of vars, there exists a permutation that injects its values into the sorted variables. For more info, please have a look at: https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf"""
|
|
return _pywrapcp.Solver_SortingConstraint(self, vars, sorted)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SplitVariableDomain"><code class="name flex">
|
|
<span>def <span class="ident">SplitVariableDomain</span></span>(<span>self, var, val, start_with_lower_half)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SplitVariableDomain(self, var: 'IntVar', val: 'int64', start_with_lower_half: 'bool') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_SplitVariableDomain(self, var, val, start_with_lower_half)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Stamp"><code class="name flex">
|
|
<span>def <span class="ident">Stamp</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The stamp indicates how many moves in the search tree we have performed. It is useful to detect if we need to update same lazy structures.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Stamp(self) -> "uint64":
|
|
r""" The stamp indicates how many moves in the search tree we have performed. It is useful to detect if we need to update same lazy structures."""
|
|
return _pywrapcp.Solver_Stamp(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.StatisticsModelVisitor"><code class="name flex">
|
|
<span>def <span class="ident">StatisticsModelVisitor</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Displays some nice statistics on the model.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StatisticsModelVisitor(self) -> "operations_research::ModelVisitor *":
|
|
r""" Displays some nice statistics on the model."""
|
|
return _pywrapcp.Solver_StatisticsModelVisitor(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.StoreAssignment"><code class="name flex">
|
|
<span>def <span class="ident">StoreAssignment</span></span>(<span>self, assignment)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Returns a DecisionBuilder which stores an Assignment (calls void Assignment::Store())</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def StoreAssignment(self, assignment: 'Assignment') -> "operations_research::DecisionBuilder *":
|
|
r""" Returns a DecisionBuilder which stores an Assignment (calls void Assignment::Store())"""
|
|
return _pywrapcp.Solver_StoreAssignment(self, assignment)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SubCircuit"><code class="name flex">
|
|
<span>def <span class="ident">SubCircuit</span></span>(<span>self, nexts)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Force the "nexts" variable to create a complete Hamiltonian path for those that do not loop upon themselves.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SubCircuit(self, nexts: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::Constraint *":
|
|
r""" Force the "nexts" variable to create a complete Hamiltonian path for those that do not loop upon themselves."""
|
|
return _pywrapcp.Solver_SubCircuit(self, nexts)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Sum"><code class="name flex">
|
|
<span>def <span class="ident">Sum</span></span>(<span>self, vars)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>sum of all vars.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Sum(self, vars: 'std::vector< operations_research::IntVar * > const &') -> "operations_research::IntExpr *":
|
|
r""" sum of all vars."""
|
|
return _pywrapcp.Solver_Sum(self, vars)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SumEquality"><code class="name flex">
|
|
<span>def <span class="ident">SumEquality</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SumEquality(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_SumEquality(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SumGreaterOrEqual"><code class="name flex">
|
|
<span>def <span class="ident">SumGreaterOrEqual</span></span>(<span>self, vars, cst)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SumGreaterOrEqual(self, vars: 'std::vector< operations_research::IntVar * > const &', cst: 'int64') -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_SumGreaterOrEqual(self, vars, cst)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SumLessOrEqual"><code class="name flex">
|
|
<span>def <span class="ident">SumLessOrEqual</span></span>(<span>self, vars, cst)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Variation on arrays.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SumLessOrEqual(self, vars: 'std::vector< operations_research::IntVar * > const &', cst: 'int64') -> "operations_research::Constraint *":
|
|
r""" Variation on arrays."""
|
|
return _pywrapcp.Solver_SumLessOrEqual(self, vars, cst)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.SumObjectiveFilter"><code class="name flex">
|
|
<span>def <span class="ident">SumObjectiveFilter</span></span>(<span>self, vars, values, objective, filter_enum)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def SumObjectiveFilter(self, vars: 'std::vector< operations_research::IntVar * > const &', values: 'operations_research::Solver::IndexEvaluator2', objective: 'IntVar', filter_enum: 'operations_research::Solver::LocalSearchFilterBound') -> "operations_research::LocalSearchFilter *":
|
|
return _pywrapcp.Solver_SumObjectiveFilter(self, vars, values, objective, filter_enum)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.TabuSearch"><code class="name flex">
|
|
<span>def <span class="ident">TabuSearch</span></span>(<span>self, maximize, v, step, vars, keep_tenure, forbid_tenure, tabu_factor)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>MetaHeuristics which try to get the search out of local optima. Creates a Tabu Search monitor. In the context of local search the behavior is similar to MakeOptimize(), creating an objective in a given sense. The behavior differs once a local optimum is reached: thereafter solutions which degrade the value of the objective are allowed if they are not "tabu". A solution is "tabu" if it doesn't respect the following rules: - improving the best solution found so far - variables in the "keep" list must keep their value, variables in the "forbid" list must not take the value they have in the list. Variables with new values enter the tabu lists after each new solution found and leave the lists after a given number of iterations (called tenure). Only the variables passed to the method can enter the lists. The tabu criterion is softened by the tabu factor which gives the number of "tabu" violations which is tolerated; a factor of 1 means no violations allowed; a factor of 0 means all violations are allowed.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def TabuSearch(self, maximize: 'bool', v: 'IntVar', step: 'int64', vars: 'std::vector< operations_research::IntVar * > const &', keep_tenure: 'int64', forbid_tenure: 'int64', tabu_factor: 'double') -> "operations_research::SearchMonitor *":
|
|
r""" MetaHeuristics which try to get the search out of local optima. Creates a Tabu Search monitor. In the context of local search the behavior is similar to MakeOptimize(), creating an objective in a given sense. The behavior differs once a local optimum is reached: thereafter solutions which degrade the value of the objective are allowed if they are not "tabu". A solution is "tabu" if it doesn't respect the following rules: - improving the best solution found so far - variables in the "keep" list must keep their value, variables in the "forbid" list must not take the value they have in the list. Variables with new values enter the tabu lists after each new solution found and leave the lists after a given number of iterations (called tenure). Only the variables passed to the method can enter the lists. The tabu criterion is softened by the tabu factor which gives the number of "tabu" violations which is tolerated; a factor of 1 means no violations allowed; a factor of 0 means all violations are allowed."""
|
|
return _pywrapcp.Solver_TabuSearch(self, maximize, v, step, vars, keep_tenure, forbid_tenure, tabu_factor)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.TemporalDisjunction"><code class="name flex">
|
|
<span>def <span class="ident">TemporalDisjunction</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
This constraint implements a temporal disjunction between two interval vars t1 and t2. 'alt' indicates which alternative was chosen (alt == 0 is equivalent to t1 before t2).</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
This constraint implements a temporal disjunction between two interval vars.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def TemporalDisjunction(self, *args) -> "operations_research::Constraint *":
|
|
r"""
|
|
*Overload 1:*
|
|
This constraint implements a temporal disjunction between two interval vars t1 and t2. 'alt' indicates which alternative was chosen (alt == 0 is equivalent to t1 before t2).
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
This constraint implements a temporal disjunction between two interval vars.
|
|
"""
|
|
return _pywrapcp.Solver_TemporalDisjunction(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.TimeLimit"><code class="name flex">
|
|
<span>def <span class="ident">TimeLimit</span></span>(<span>self, time_in_ms)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>Creates a search limit that constrains the running time given in milliseconds.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def TimeLimit(self, time_in_ms: 'int64') -> "operations_research::RegularLimit *":
|
|
r""" Creates a search limit that constrains the running time given in milliseconds."""
|
|
return _pywrapcp.Solver_TimeLimit(self, time_in_ms)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.TransitionConstraint"><code class="name flex">
|
|
<span>def <span class="ident">TransitionConstraint</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def TransitionConstraint(self, *args) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_TransitionConstraint(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.TreeNoCycle"><code class="name flex">
|
|
<span>def <span class="ident">TreeNoCycle</span></span>(<span>self, nexts, active, callback=0)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def TreeNoCycle(self, nexts: 'std::vector< operations_research::IntVar * > const &', active: 'std::vector< operations_research::IntVar * > const &', callback: 'operations_research::Solver::IndexFilter1'=0) -> "operations_research::Constraint *":
|
|
return _pywrapcp.Solver_TreeNoCycle(self, nexts, active, callback)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.TrueConstraint"><code class="name flex">
|
|
<span>def <span class="ident">TrueConstraint</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>This constraint always succeeds.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def TrueConstraint(self) -> "operations_research::Constraint *":
|
|
r""" This constraint always succeeds."""
|
|
return _pywrapcp.Solver_TrueConstraint(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.Try"><code class="name flex">
|
|
<span>def <span class="ident">Try</span></span>(<span>self, dbs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def Try(self, dbs: 'std::vector< operations_research::DecisionBuilder * > const &') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_Try(self, dbs)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.VarEvalValEvalPhase"><code class="name flex">
|
|
<span>def <span class="ident">VarEvalValEvalPhase</span></span>(<span>self, vars, var_eval, val_eval)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def VarEvalValEvalPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_eval: 'std::function< int64 (int64) >', val_eval: 'operations_research::Solver::IndexEvaluator2') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarEvalValEvalPhase(self, vars, var_eval, val_eval)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.VarEvalValEvalTieBreakPhase"><code class="name flex">
|
|
<span>def <span class="ident">VarEvalValEvalTieBreakPhase</span></span>(<span>self, vars, var_eval, val_eval, tie_breaker)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def VarEvalValEvalTieBreakPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_eval: 'std::function< int64 (int64) >', val_eval: 'operations_research::Solver::IndexEvaluator2', tie_breaker: 'std::function< int64 (int64) >') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.VarEvalValStrPhase"><code class="name flex">
|
|
<span>def <span class="ident">VarEvalValStrPhase</span></span>(<span>self, vars, var_evaluator, val_str)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def VarEvalValStrPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_evaluator: 'std::function< int64 (int64) >', val_str: 'operations_research::Solver::IntValueStrategy') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarEvalValStrPhase(self, vars, var_evaluator, val_str)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.VarStrValEvalPhase"><code class="name flex">
|
|
<span>def <span class="ident">VarStrValEvalPhase</span></span>(<span>self, vars, var_str, val_eval)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def VarStrValEvalPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_str: 'operations_research::Solver::IntVarStrategy', val_eval: 'operations_research::Solver::IndexEvaluator2') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarStrValEvalPhase(self, vars, var_str, val_eval)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.VarStrValEvalTieBreakPhase"><code class="name flex">
|
|
<span>def <span class="ident">VarStrValEvalTieBreakPhase</span></span>(<span>self, vars, var_str, val_eval, tie_breaker)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def VarStrValEvalTieBreakPhase(self, vars: 'std::vector< operations_research::IntVar * > const &', var_str: 'operations_research::Solver::IntVarStrategy', val_eval: 'operations_research::Solver::IndexEvaluator2', tie_breaker: 'std::function< int64 (int64) >') -> "operations_research::DecisionBuilder *":
|
|
return _pywrapcp.Solver_VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.VariableGreaterOrEqualValue"><code class="name flex">
|
|
<span>def <span class="ident">VariableGreaterOrEqualValue</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def VariableGreaterOrEqualValue(self, var: 'IntVar', value: 'int64') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_VariableGreaterOrEqualValue(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.VariableLessOrEqualValue"><code class="name flex">
|
|
<span>def <span class="ident">VariableLessOrEqualValue</span></span>(<span>self, var, value)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def VariableLessOrEqualValue(self, var: 'IntVar', value: 'int64') -> "operations_research::Decision *":
|
|
return _pywrapcp.Solver_VariableLessOrEqualValue(self, var, value)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.WallTime"><code class="name flex">
|
|
<span>def <span class="ident">WallTime</span></span>(<span>self)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>DEPRECATED: Use Now() instead. Time elapsed, in ms since the creation of the solver.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WallTime(self) -> "int64":
|
|
r""" DEPRECATED: Use Now() instead. Time elapsed, in ms since the creation of the solver."""
|
|
return _pywrapcp.Solver_WallTime(self)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.WeightedMaximize"><code class="name flex">
|
|
<span>def <span class="ident">WeightedMaximize</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Creates a maximization weigthed objective.</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Creates a maximization weigthed objective.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WeightedMaximize(self, *args) -> "operations_research::OptimizeVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a maximization weigthed objective.
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a maximization weigthed objective.
|
|
"""
|
|
return _pywrapcp.Solver_WeightedMaximize(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.WeightedMinimize"><code class="name flex">
|
|
<span>def <span class="ident">WeightedMinimize</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Creates a minimization weighted objective. The actual objective is scalar_prod(sub_objectives, weights).</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Creates a minimization weighted objective. The actual objective is scalar_prod(sub_objectives, weights).</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WeightedMinimize(self, *args) -> "operations_research::OptimizeVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a minimization weighted objective. The actual objective is scalar_prod(sub_objectives, weights).
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a minimization weighted objective. The actual objective is scalar_prod(sub_objectives, weights).
|
|
"""
|
|
return _pywrapcp.Solver_WeightedMinimize(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
<dt id="pywrapcp.Solver.WeightedOptimize"><code class="name flex">
|
|
<span>def <span class="ident">WeightedOptimize</span></span>(<span>self, *args)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p><em>Overload 1:</em>
|
|
Creates a weighted objective with a given sense (true = maximization).</p>
|
|
<p>|</p>
|
|
<p><em>Overload 2:</em>
|
|
Creates a weighted objective with a given sense (true = maximization).</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def WeightedOptimize(self, *args) -> "operations_research::OptimizeVar *":
|
|
r"""
|
|
*Overload 1:*
|
|
Creates a weighted objective with a given sense (true = maximization).
|
|
|
|
|
|
|
|
|
*Overload 2:*
|
|
Creates a weighted objective with a given sense (true = maximization).
|
|
"""
|
|
return _pywrapcp.Solver_WeightedOptimize(self, *args)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
</dd>
|
|
<dt id="pywrapcp.TypeIncompatibilityChecker"><code class="flex name class">
|
|
<span>class <span class="ident">TypeIncompatibilityChecker</span></span>
|
|
<span>(</span><span>model, check_hard_incompatibilities)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class TypeIncompatibilityChecker(TypeRegulationsChecker):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, model: 'RoutingModel', check_hard_incompatibilities: 'bool'):
|
|
_pywrapcp.TypeIncompatibilityChecker_swiginit(self, _pywrapcp.new_TypeIncompatibilityChecker(model, check_hard_incompatibilities))
|
|
__swig_destroy__ = _pywrapcp.delete_TypeIncompatibilityChecker</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.TypeRegulationsChecker" href="#pywrapcp.TypeRegulationsChecker">TypeRegulationsChecker</a></li>
|
|
</ul>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.TypeRegulationsChecker" href="#pywrapcp.TypeRegulationsChecker">TypeRegulationsChecker</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.TypeRegulationsChecker.thisown" href="#pywrapcp.TypeRegulationsChecker.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.TypeRegulationsChecker"><code class="flex name class">
|
|
<span>class <span class="ident">TypeRegulationsChecker</span></span>
|
|
<span>(</span><span>*args, **kwargs)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class TypeRegulationsChecker(object):
|
|
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 - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _pywrapcp.delete_TypeRegulationsChecker
|
|
|
|
def CheckVehicle(self, vehicle: 'int', next_accessor: 'std::function< int64 (int64) > const &') -> "bool":
|
|
return _pywrapcp.TypeRegulationsChecker_CheckVehicle(self, vehicle, next_accessor)</code></pre>
|
|
</details>
|
|
<h3>Subclasses</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.TypeIncompatibilityChecker" href="#pywrapcp.TypeIncompatibilityChecker">TypeIncompatibilityChecker</a></li>
|
|
<li><a title="pywrapcp.TypeRequirementChecker" href="#pywrapcp.TypeRequirementChecker">TypeRequirementChecker</a></li>
|
|
</ul>
|
|
<h3>Instance variables</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.TypeRegulationsChecker.thisown"><code class="name">var <span class="ident">thisown</span></code></dt>
|
|
<dd>
|
|
<section class="desc"><p>The membership flag</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
<h3>Methods</h3>
|
|
<dl>
|
|
<dt id="pywrapcp.TypeRegulationsChecker.CheckVehicle"><code class="name flex">
|
|
<span>def <span class="ident">CheckVehicle</span></span>(<span>self, vehicle, next_accessor)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">def CheckVehicle(self, vehicle: 'int', next_accessor: 'std::function< int64 (int64) > const &') -> "bool":
|
|
return _pywrapcp.TypeRegulationsChecker_CheckVehicle(self, vehicle, next_accessor)</code></pre>
|
|
</details>
|
|
</dd>
|
|
</dl>
|
|
</dd>
|
|
<dt id="pywrapcp.TypeRegulationsConstraint"><code class="flex name class">
|
|
<span>class <span class="ident">TypeRegulationsConstraint</span></span>
|
|
<span>(</span><span>model)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"><p>A constraint is the main modeling object. It provides two methods:
|
|
- Post() is responsible for creating the demons and attaching them to
|
|
immediate demons().
|
|
- InitialPropagate() is called once just after Post and performs
|
|
the initial propagation. The subsequent propagations will be performed
|
|
by the demons Posted during the post() method.</p></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class TypeRegulationsConstraint(Constraint):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, model: 'RoutingModel'):
|
|
_pywrapcp.TypeRegulationsConstraint_swiginit(self, _pywrapcp.new_TypeRegulationsConstraint(model))
|
|
|
|
def Post(self) -> "void":
|
|
return _pywrapcp.TypeRegulationsConstraint_Post(self)
|
|
|
|
def InitialPropagateWrapper(self) -> "void":
|
|
return _pywrapcp.TypeRegulationsConstraint_InitialPropagateWrapper(self)
|
|
__swig_destroy__ = _pywrapcp.delete_TypeRegulationsConstraint</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.Constraint" href="#pywrapcp.Constraint">Constraint</a></li>
|
|
<li><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></li>
|
|
<li><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></li>
|
|
</ul>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.Constraint" href="#pywrapcp.Constraint">Constraint</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.Constraint.InitialPropagateWrapper" href="#pywrapcp.Constraint.InitialPropagateWrapper">InitialPropagateWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Name" href="#pywrapcp.PropagationBaseObject.Name">Name</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Post" href="#pywrapcp.Constraint.Post">Post</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Var" href="#pywrapcp.Constraint.Var">Var</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
<dt id="pywrapcp.TypeRequirementChecker"><code class="flex name class">
|
|
<span>class <span class="ident">TypeRequirementChecker</span></span>
|
|
<span>(</span><span>model)</span>
|
|
</code></dt>
|
|
<dd>
|
|
<section class="desc"></section>
|
|
<details class="source">
|
|
<summary>Source code</summary>
|
|
<pre><code class="python">class TypeRequirementChecker(TypeRegulationsChecker):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, model: 'RoutingModel'):
|
|
_pywrapcp.TypeRequirementChecker_swiginit(self, _pywrapcp.new_TypeRequirementChecker(model))
|
|
__swig_destroy__ = _pywrapcp.delete_TypeRequirementChecker</code></pre>
|
|
</details>
|
|
<h3>Ancestors</h3>
|
|
<ul class="hlist">
|
|
<li><a title="pywrapcp.TypeRegulationsChecker" href="#pywrapcp.TypeRegulationsChecker">TypeRegulationsChecker</a></li>
|
|
</ul>
|
|
<h3>Inherited members</h3>
|
|
<ul class="hlist">
|
|
<li><code><b><a title="pywrapcp.TypeRegulationsChecker" href="#pywrapcp.TypeRegulationsChecker">TypeRegulationsChecker</a></b></code>:
|
|
<ul class="hlist">
|
|
<li><code><a title="pywrapcp.TypeRegulationsChecker.thisown" href="#pywrapcp.TypeRegulationsChecker.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</dd>
|
|
</dl>
|
|
</section>
|
|
</article>
|
|
<nav id="sidebar">
|
|
<header>
|
|
<a class="homelink" rel="home" title="OR-Tools Home" href="https://google.github.io/or-tools/">
|
|
<img src="https://developers.google.com/optimization/images/orLogo.png" alt=""> OR-Tools
|
|
</a>
|
|
</header>
|
|
<h1>Index</h1>
|
|
<div class="toc">
|
|
<ul></ul>
|
|
</div>
|
|
<ul id="index">
|
|
<li><h3><a href="#header-functions">Functions</a></h3>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.DefaultRoutingModelParameters" href="#pywrapcp.DefaultRoutingModelParameters">DefaultRoutingModelParameters</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultRoutingSearchParameters" href="#pywrapcp.DefaultRoutingSearchParameters">DefaultRoutingSearchParameters</a></code></li>
|
|
<li><code><a title="pywrapcp.FindErrorInRoutingSearchParameters" href="#pywrapcp.FindErrorInRoutingSearchParameters">FindErrorInRoutingSearchParameters</a></code></li>
|
|
<li><code><a title="pywrapcp.MakeSetValuesFromTargets" href="#pywrapcp.MakeSetValuesFromTargets">MakeSetValuesFromTargets</a></code></li>
|
|
<li><code><a title="pywrapcp.SolveModelWithSat" href="#pywrapcp.SolveModelWithSat">SolveModelWithSat</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver_DefaultSolverParameters" href="#pywrapcp.Solver_DefaultSolverParameters">Solver_DefaultSolverParameters</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver_MemoryUsage" href="#pywrapcp.Solver_MemoryUsage">Solver_MemoryUsage</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li><h3><a href="#header-classes">Classes</a></h3>
|
|
<ul>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.Assignment" href="#pywrapcp.Assignment">Assignment</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.Assignment.Activate" href="#pywrapcp.Assignment.Activate">Activate</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Activated" href="#pywrapcp.Assignment.Activated">Activated</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Add" href="#pywrapcp.Assignment.Add">Add</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.AddObjective" href="#pywrapcp.Assignment.AddObjective">AddObjective</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.BackwardSequence" href="#pywrapcp.Assignment.BackwardSequence">BackwardSequence</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Bound" href="#pywrapcp.Assignment.Bound">Bound</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Clear" href="#pywrapcp.Assignment.Clear">Clear</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Deactivate" href="#pywrapcp.Assignment.Deactivate">Deactivate</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.DebugString" href="#pywrapcp.Assignment.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.DurationMax" href="#pywrapcp.Assignment.DurationMax">DurationMax</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.DurationMin" href="#pywrapcp.Assignment.DurationMin">DurationMin</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.DurationValue" href="#pywrapcp.Assignment.DurationValue">DurationValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Empty" href="#pywrapcp.Assignment.Empty">Empty</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.EndMax" href="#pywrapcp.Assignment.EndMax">EndMax</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.EndMin" href="#pywrapcp.Assignment.EndMin">EndMin</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.EndValue" href="#pywrapcp.Assignment.EndValue">EndValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.ForwardSequence" href="#pywrapcp.Assignment.ForwardSequence">ForwardSequence</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.HasObjective" href="#pywrapcp.Assignment.HasObjective">HasObjective</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.IntVarContainer" href="#pywrapcp.Assignment.IntVarContainer">IntVarContainer</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.IntervalVarContainer" href="#pywrapcp.Assignment.IntervalVarContainer">IntervalVarContainer</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Load" href="#pywrapcp.Assignment.Load">Load</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Max" href="#pywrapcp.Assignment.Max">Max</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Min" href="#pywrapcp.Assignment.Min">Min</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.MutableIntVarContainer" href="#pywrapcp.Assignment.MutableIntVarContainer">MutableIntVarContainer</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.MutableIntervalVarContainer" href="#pywrapcp.Assignment.MutableIntervalVarContainer">MutableIntervalVarContainer</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.MutableSequenceVarContainer" href="#pywrapcp.Assignment.MutableSequenceVarContainer">MutableSequenceVarContainer</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.NumIntVars" href="#pywrapcp.Assignment.NumIntVars">NumIntVars</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.NumIntervalVars" href="#pywrapcp.Assignment.NumIntervalVars">NumIntervalVars</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.NumSequenceVars" href="#pywrapcp.Assignment.NumSequenceVars">NumSequenceVars</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Objective" href="#pywrapcp.Assignment.Objective">Objective</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.ObjectiveBound" href="#pywrapcp.Assignment.ObjectiveBound">ObjectiveBound</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.ObjectiveMax" href="#pywrapcp.Assignment.ObjectiveMax">ObjectiveMax</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.ObjectiveMin" href="#pywrapcp.Assignment.ObjectiveMin">ObjectiveMin</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.ObjectiveValue" href="#pywrapcp.Assignment.ObjectiveValue">ObjectiveValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.PerformedMax" href="#pywrapcp.Assignment.PerformedMax">PerformedMax</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.PerformedMin" href="#pywrapcp.Assignment.PerformedMin">PerformedMin</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.PerformedValue" href="#pywrapcp.Assignment.PerformedValue">PerformedValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Restore" href="#pywrapcp.Assignment.Restore">Restore</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Save" href="#pywrapcp.Assignment.Save">Save</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SequenceVarContainer" href="#pywrapcp.Assignment.SequenceVarContainer">SequenceVarContainer</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetBackwardSequence" href="#pywrapcp.Assignment.SetBackwardSequence">SetBackwardSequence</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetDurationMax" href="#pywrapcp.Assignment.SetDurationMax">SetDurationMax</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetDurationMin" href="#pywrapcp.Assignment.SetDurationMin">SetDurationMin</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetDurationRange" href="#pywrapcp.Assignment.SetDurationRange">SetDurationRange</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetDurationValue" href="#pywrapcp.Assignment.SetDurationValue">SetDurationValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetEndMax" href="#pywrapcp.Assignment.SetEndMax">SetEndMax</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetEndMin" href="#pywrapcp.Assignment.SetEndMin">SetEndMin</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetEndRange" href="#pywrapcp.Assignment.SetEndRange">SetEndRange</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetEndValue" href="#pywrapcp.Assignment.SetEndValue">SetEndValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetForwardSequence" href="#pywrapcp.Assignment.SetForwardSequence">SetForwardSequence</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetMax" href="#pywrapcp.Assignment.SetMax">SetMax</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetMin" href="#pywrapcp.Assignment.SetMin">SetMin</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetObjectiveMax" href="#pywrapcp.Assignment.SetObjectiveMax">SetObjectiveMax</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetObjectiveMin" href="#pywrapcp.Assignment.SetObjectiveMin">SetObjectiveMin</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetObjectiveRange" href="#pywrapcp.Assignment.SetObjectiveRange">SetObjectiveRange</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetObjectiveValue" href="#pywrapcp.Assignment.SetObjectiveValue">SetObjectiveValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetPerformedMax" href="#pywrapcp.Assignment.SetPerformedMax">SetPerformedMax</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetPerformedMin" href="#pywrapcp.Assignment.SetPerformedMin">SetPerformedMin</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetPerformedRange" href="#pywrapcp.Assignment.SetPerformedRange">SetPerformedRange</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetPerformedValue" href="#pywrapcp.Assignment.SetPerformedValue">SetPerformedValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetRange" href="#pywrapcp.Assignment.SetRange">SetRange</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetSequence" href="#pywrapcp.Assignment.SetSequence">SetSequence</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetStartMax" href="#pywrapcp.Assignment.SetStartMax">SetStartMax</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetStartMin" href="#pywrapcp.Assignment.SetStartMin">SetStartMin</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetStartRange" href="#pywrapcp.Assignment.SetStartRange">SetStartRange</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetStartValue" href="#pywrapcp.Assignment.SetStartValue">SetStartValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetUnperformed" href="#pywrapcp.Assignment.SetUnperformed">SetUnperformed</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.SetValue" href="#pywrapcp.Assignment.SetValue">SetValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Size" href="#pywrapcp.Assignment.Size">Size</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.StartMax" href="#pywrapcp.Assignment.StartMax">StartMax</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.StartMin" href="#pywrapcp.Assignment.StartMin">StartMin</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.StartValue" href="#pywrapcp.Assignment.StartValue">StartValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Store" href="#pywrapcp.Assignment.Store">Store</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Unperformed" href="#pywrapcp.Assignment.Unperformed">Unperformed</a></code></li>
|
|
<li><code><a title="pywrapcp.Assignment.Value" href="#pywrapcp.Assignment.Value">Value</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.AssignmentElement" href="#pywrapcp.AssignmentElement">AssignmentElement</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.AssignmentElement.Activate" href="#pywrapcp.AssignmentElement.Activate">Activate</a></code></li>
|
|
<li><code><a title="pywrapcp.AssignmentElement.Activated" href="#pywrapcp.AssignmentElement.Activated">Activated</a></code></li>
|
|
<li><code><a title="pywrapcp.AssignmentElement.Deactivate" href="#pywrapcp.AssignmentElement.Deactivate">Deactivate</a></code></li>
|
|
<li><code><a title="pywrapcp.AssignmentElement.thisown" href="#pywrapcp.AssignmentElement.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.BaseLns" href="#pywrapcp.BaseLns">BaseLns</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.BaseLns.AppendToFragment" href="#pywrapcp.BaseLns.AppendToFragment">AppendToFragment</a></code></li>
|
|
<li><code><a title="pywrapcp.BaseLns.FragmentSize" href="#pywrapcp.BaseLns.FragmentSize">FragmentSize</a></code></li>
|
|
<li><code><a title="pywrapcp.BaseLns.InitFragments" href="#pywrapcp.BaseLns.InitFragments">InitFragments</a></code></li>
|
|
<li><code><a title="pywrapcp.BaseLns.NextFragment" href="#pywrapcp.BaseLns.NextFragment">NextFragment</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.BaseObject" href="#pywrapcp.BaseObject">BaseObject</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.BaseObject.DebugString" href="#pywrapcp.BaseObject.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.BaseObject.thisown" href="#pywrapcp.BaseObject.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.BasePathFilter" href="#pywrapcp.BasePathFilter">BasePathFilter</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.BasePathFilter.OnSynchronize" href="#pywrapcp.BasePathFilter.OnSynchronize">OnSynchronize</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.BooleanVar" href="#pywrapcp.BooleanVar">BooleanVar</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.BooleanVar.DebugString" href="#pywrapcp.BooleanVar.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.BooleanVar.Max" href="#pywrapcp.BooleanVar.Max">Max</a></code></li>
|
|
<li><code><a title="pywrapcp.BooleanVar.Min" href="#pywrapcp.BooleanVar.Min">Min</a></code></li>
|
|
<li><code><a title="pywrapcp.BooleanVar.SetMax" href="#pywrapcp.BooleanVar.SetMax">SetMax</a></code></li>
|
|
<li><code><a title="pywrapcp.BooleanVar.SetMin" href="#pywrapcp.BooleanVar.SetMin">SetMin</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.CPFeasibilityFilter" href="#pywrapcp.CPFeasibilityFilter">CPFeasibilityFilter</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.CPFeasibilityFilter.DebugString" href="#pywrapcp.CPFeasibilityFilter.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.CPFeasibilityFilter.OnSynchronize" href="#pywrapcp.CPFeasibilityFilter.OnSynchronize">OnSynchronize</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.ChangeValue" href="#pywrapcp.ChangeValue">ChangeValue</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.ChangeValue.ModifyValue" href="#pywrapcp.ChangeValue.ModifyValue">ModifyValue</a></code></li>
|
|
<li><code><a title="pywrapcp.ChangeValue.OneNeighbor" href="#pywrapcp.ChangeValue.OneNeighbor">OneNeighbor</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.CheapestAdditionFilteredDecisionBuilder" href="#pywrapcp.CheapestAdditionFilteredDecisionBuilder">CheapestAdditionFilteredDecisionBuilder</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.CheapestAdditionFilteredDecisionBuilder.BuildSolution" href="#pywrapcp.CheapestAdditionFilteredDecisionBuilder.BuildSolution">BuildSolution</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.CheapestInsertionFilteredDecisionBuilder" href="#pywrapcp.CheapestInsertionFilteredDecisionBuilder">CheapestInsertionFilteredDecisionBuilder</a></code></h4>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.ChristofidesFilteredDecisionBuilder" href="#pywrapcp.ChristofidesFilteredDecisionBuilder">ChristofidesFilteredDecisionBuilder</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.ChristofidesFilteredDecisionBuilder.BuildSolution" href="#pywrapcp.ChristofidesFilteredDecisionBuilder.BuildSolution">BuildSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.ChristofidesFilteredDecisionBuilder.DebugString" href="#pywrapcp.ChristofidesFilteredDecisionBuilder.DebugString">DebugString</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.ComparatorCheapestAdditionFilteredDecisionBuilder" href="#pywrapcp.ComparatorCheapestAdditionFilteredDecisionBuilder">ComparatorCheapestAdditionFilteredDecisionBuilder</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.ComparatorCheapestAdditionFilteredDecisionBuilder.DebugString" href="#pywrapcp.ComparatorCheapestAdditionFilteredDecisionBuilder.DebugString">DebugString</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.Constraint" href="#pywrapcp.Constraint">Constraint</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.Constraint.DebugString" href="#pywrapcp.Constraint.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.IndexOf" href="#pywrapcp.Constraint.IndexOf">IndexOf</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.InitialPropagateWrapper" href="#pywrapcp.Constraint.InitialPropagateWrapper">InitialPropagateWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.MapTo" href="#pywrapcp.Constraint.MapTo">MapTo</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Post" href="#pywrapcp.Constraint.Post">Post</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Square" href="#pywrapcp.Constraint.Square">Square</a></code></li>
|
|
<li><code><a title="pywrapcp.Constraint.Var" href="#pywrapcp.Constraint.Var">Var</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.Decision" href="#pywrapcp.Decision">Decision</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.Decision.ApplyWrapper" href="#pywrapcp.Decision.ApplyWrapper">ApplyWrapper</a></code></li>
|
|
<li><code><a title="pywrapcp.Decision.DebugString" href="#pywrapcp.Decision.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.Decision.RefuteWrapper" href="#pywrapcp.Decision.RefuteWrapper">RefuteWrapper</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.DecisionBuilder" href="#pywrapcp.DecisionBuilder">DecisionBuilder</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.DecisionBuilder.DebugString" href="#pywrapcp.DecisionBuilder.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.DecisionBuilder.NextWrapper" href="#pywrapcp.DecisionBuilder.NextWrapper">NextWrapper</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.DefaultPhaseParameters" href="#pywrapcp.DefaultPhaseParameters">DefaultPhaseParameters</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.CHOOSE_MAX_AVERAGE_IMPACT" href="#pywrapcp.DefaultPhaseParameters.CHOOSE_MAX_AVERAGE_IMPACT">CHOOSE_MAX_AVERAGE_IMPACT</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.CHOOSE_MAX_SUM_IMPACT" href="#pywrapcp.DefaultPhaseParameters.CHOOSE_MAX_SUM_IMPACT">CHOOSE_MAX_SUM_IMPACT</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.CHOOSE_MAX_VALUE_IMPACT" href="#pywrapcp.DefaultPhaseParameters.CHOOSE_MAX_VALUE_IMPACT">CHOOSE_MAX_VALUE_IMPACT</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.NONE" href="#pywrapcp.DefaultPhaseParameters.NONE">NONE</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.NORMAL" href="#pywrapcp.DefaultPhaseParameters.NORMAL">NORMAL</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.SELECT_MAX_IMPACT" href="#pywrapcp.DefaultPhaseParameters.SELECT_MAX_IMPACT">SELECT_MAX_IMPACT</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.SELECT_MIN_IMPACT" href="#pywrapcp.DefaultPhaseParameters.SELECT_MIN_IMPACT">SELECT_MIN_IMPACT</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.VERBOSE" href="#pywrapcp.DefaultPhaseParameters.VERBOSE">VERBOSE</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.decision_builder" href="#pywrapcp.DefaultPhaseParameters.decision_builder">decision_builder</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.display_level" href="#pywrapcp.DefaultPhaseParameters.display_level">display_level</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.heuristic_num_failures_limit" href="#pywrapcp.DefaultPhaseParameters.heuristic_num_failures_limit">heuristic_num_failures_limit</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.heuristic_period" href="#pywrapcp.DefaultPhaseParameters.heuristic_period">heuristic_period</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.initialization_splits" href="#pywrapcp.DefaultPhaseParameters.initialization_splits">initialization_splits</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.persistent_impact" href="#pywrapcp.DefaultPhaseParameters.persistent_impact">persistent_impact</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.random_seed" href="#pywrapcp.DefaultPhaseParameters.random_seed">random_seed</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.run_all_heuristics" href="#pywrapcp.DefaultPhaseParameters.run_all_heuristics">run_all_heuristics</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.thisown" href="#pywrapcp.DefaultPhaseParameters.thisown">thisown</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.value_selection_schema" href="#pywrapcp.DefaultPhaseParameters.value_selection_schema">value_selection_schema</a></code></li>
|
|
<li><code><a title="pywrapcp.DefaultPhaseParameters.var_selection_schema" href="#pywrapcp.DefaultPhaseParameters.var_selection_schema">var_selection_schema</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.Demon" href="#pywrapcp.Demon">Demon</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.Demon.DebugString" href="#pywrapcp.Demon.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.Demon.Desinhibit" href="#pywrapcp.Demon.Desinhibit">Desinhibit</a></code></li>
|
|
<li><code><a title="pywrapcp.Demon.Inhibit" href="#pywrapcp.Demon.Inhibit">Inhibit</a></code></li>
|
|
<li><code><a title="pywrapcp.Demon.Priority" href="#pywrapcp.Demon.Priority">Priority</a></code></li>
|
|
<li><code><a title="pywrapcp.Demon.RunWrapper" href="#pywrapcp.Demon.RunWrapper">RunWrapper</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.DisjunctiveConstraint" href="#pywrapcp.DisjunctiveConstraint">DisjunctiveConstraint</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.DisjunctiveConstraint.SequenceVar" href="#pywrapcp.DisjunctiveConstraint.SequenceVar">SequenceVar</a></code></li>
|
|
<li><code><a title="pywrapcp.DisjunctiveConstraint.SetTransitionTime" href="#pywrapcp.DisjunctiveConstraint.SetTransitionTime">SetTransitionTime</a></code></li>
|
|
<li><code><a title="pywrapcp.DisjunctiveConstraint.TransitionTime" href="#pywrapcp.DisjunctiveConstraint.TransitionTime">TransitionTime</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.EvaluatorCheapestAdditionFilteredDecisionBuilder" href="#pywrapcp.EvaluatorCheapestAdditionFilteredDecisionBuilder">EvaluatorCheapestAdditionFilteredDecisionBuilder</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.EvaluatorCheapestAdditionFilteredDecisionBuilder.DebugString" href="#pywrapcp.EvaluatorCheapestAdditionFilteredDecisionBuilder.DebugString">DebugString</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder" href="#pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder">GlobalCheapestInsertionFilteredDecisionBuilder</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder.BuildSolution" href="#pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder.BuildSolution">BuildSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder.DebugString" href="#pywrapcp.GlobalCheapestInsertionFilteredDecisionBuilder.DebugString">DebugString</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.GlobalVehicleBreaksConstraint" href="#pywrapcp.GlobalVehicleBreaksConstraint">GlobalVehicleBreaksConstraint</a></code></h4>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.IntExpr" href="#pywrapcp.IntExpr">IntExpr</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.IntExpr.Bound" href="#pywrapcp.IntExpr.Bound">Bound</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.IndexOf" href="#pywrapcp.IntExpr.IndexOf">IndexOf</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.IsMember" href="#pywrapcp.IntExpr.IsMember">IsMember</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.IsVar" href="#pywrapcp.IntExpr.IsVar">IsVar</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.MapTo" href="#pywrapcp.IntExpr.MapTo">MapTo</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.Max" href="#pywrapcp.IntExpr.Max">Max</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.Member" href="#pywrapcp.IntExpr.Member">Member</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.Min" href="#pywrapcp.IntExpr.Min">Min</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.NotMember" href="#pywrapcp.IntExpr.NotMember">NotMember</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.SetMax" href="#pywrapcp.IntExpr.SetMax">SetMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.SetMin" href="#pywrapcp.IntExpr.SetMin">SetMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.SetRange" href="#pywrapcp.IntExpr.SetRange">SetRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.SetValue" href="#pywrapcp.IntExpr.SetValue">SetValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.Square" href="#pywrapcp.IntExpr.Square">Square</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.Var" href="#pywrapcp.IntExpr.Var">Var</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.VarWithName" href="#pywrapcp.IntExpr.VarWithName">VarWithName</a></code></li>
|
|
<li><code><a title="pywrapcp.IntExpr.WhenRange" href="#pywrapcp.IntExpr.WhenRange">WhenRange</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.IntVar" href="#pywrapcp.IntVar">IntVar</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.IntVar.Contains" href="#pywrapcp.IntVar.Contains">Contains</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.DomainIterator" href="#pywrapcp.IntVar.DomainIterator">DomainIterator</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.DomainIteratorAux" href="#pywrapcp.IntVar.DomainIteratorAux">DomainIteratorAux</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.HoleIterator" href="#pywrapcp.IntVar.HoleIterator">HoleIterator</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.HoleIteratorAux" href="#pywrapcp.IntVar.HoleIteratorAux">HoleIteratorAux</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.OldMax" href="#pywrapcp.IntVar.OldMax">OldMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.OldMin" href="#pywrapcp.IntVar.OldMin">OldMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.RemoveInterval" href="#pywrapcp.IntVar.RemoveInterval">RemoveInterval</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.RemoveValue" href="#pywrapcp.IntVar.RemoveValue">RemoveValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.RemoveValues" href="#pywrapcp.IntVar.RemoveValues">RemoveValues</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.SetValues" href="#pywrapcp.IntVar.SetValues">SetValues</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.Size" href="#pywrapcp.IntVar.Size">Size</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.Value" href="#pywrapcp.IntVar.Value">Value</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.WhenBound" href="#pywrapcp.IntVar.WhenBound">WhenBound</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVar.WhenDomain" href="#pywrapcp.IntVar.WhenDomain">WhenDomain</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.IntVarContainer" href="#pywrapcp.IntVarContainer">IntVarContainer</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.IntVarContainer.Contains" href="#pywrapcp.IntVarContainer.Contains">Contains</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarContainer.Element" href="#pywrapcp.IntVarContainer.Element">Element</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarContainer.Restore" href="#pywrapcp.IntVarContainer.Restore">Restore</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarContainer.Size" href="#pywrapcp.IntVarContainer.Size">Size</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarContainer.Store" href="#pywrapcp.IntVarContainer.Store">Store</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarContainer.thisown" href="#pywrapcp.IntVarContainer.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.IntVarElement" href="#pywrapcp.IntVarElement">IntVarElement</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.IntVarElement.Bound" href="#pywrapcp.IntVarElement.Bound">Bound</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarElement.Max" href="#pywrapcp.IntVarElement.Max">Max</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarElement.Min" href="#pywrapcp.IntVarElement.Min">Min</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarElement.SetMax" href="#pywrapcp.IntVarElement.SetMax">SetMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarElement.SetMin" href="#pywrapcp.IntVarElement.SetMin">SetMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarElement.SetRange" href="#pywrapcp.IntVarElement.SetRange">SetRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarElement.SetValue" href="#pywrapcp.IntVarElement.SetValue">SetValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarElement.Value" href="#pywrapcp.IntVarElement.Value">Value</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarElement.Var" href="#pywrapcp.IntVarElement.Var">Var</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.IntVarFilteredDecisionBuilder" href="#pywrapcp.IntVarFilteredDecisionBuilder">IntVarFilteredDecisionBuilder</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.IntVarFilteredDecisionBuilder.BuildSolution" href="#pywrapcp.IntVarFilteredDecisionBuilder.BuildSolution">BuildSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarFilteredDecisionBuilder.number_of_decisions" href="#pywrapcp.IntVarFilteredDecisionBuilder.number_of_decisions">number_of_decisions</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarFilteredDecisionBuilder.number_of_rejects" href="#pywrapcp.IntVarFilteredDecisionBuilder.number_of_rejects">number_of_rejects</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.IntVarIterator" href="#pywrapcp.IntVarIterator">IntVarIterator</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.IntVarIterator.DebugString" href="#pywrapcp.IntVarIterator.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarIterator.Init" href="#pywrapcp.IntVarIterator.Init">Init</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarIterator.Next" href="#pywrapcp.IntVarIterator.Next">Next</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarIterator.Ok" href="#pywrapcp.IntVarIterator.Ok">Ok</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarIterator.Value" href="#pywrapcp.IntVarIterator.Value">Value</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarIterator.next" href="#pywrapcp.IntVarIterator.next">next</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.IntVarLocalSearchFilter" href="#pywrapcp.IntVarLocalSearchFilter">IntVarLocalSearchFilter</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchFilter.IndexFromVar" href="#pywrapcp.IntVarLocalSearchFilter.IndexFromVar">IndexFromVar</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchFilter.Size" href="#pywrapcp.IntVarLocalSearchFilter.Size">Size</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchFilter.Synchronize" href="#pywrapcp.IntVarLocalSearchFilter.Synchronize">Synchronize</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchFilter.Value" href="#pywrapcp.IntVarLocalSearchFilter.Value">Value</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.IntVarLocalSearchOperator" href="#pywrapcp.IntVarLocalSearchOperator">IntVarLocalSearchOperator</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.NextNeighbor" href="#pywrapcp.IntVarLocalSearchOperator.NextNeighbor">NextNeighbor</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperator.OneNeighbor" href="#pywrapcp.IntVarLocalSearchOperator.OneNeighbor">OneNeighbor</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.IntVarLocalSearchOperatorTemplate" href="#pywrapcp.IntVarLocalSearchOperatorTemplate">IntVarLocalSearchOperatorTemplate</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperatorTemplate.IsIncremental" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.IsIncremental">IsIncremental</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperatorTemplate.OldValue" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.OldValue">OldValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperatorTemplate.OnStart" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.OnStart">OnStart</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperatorTemplate.SetValue" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.SetValue">SetValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperatorTemplate.Size" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.Size">Size</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperatorTemplate.Start" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.Start">Start</a></code></li>
|
|
<li><code><a title="pywrapcp.IntVarLocalSearchOperatorTemplate.Value" href="#pywrapcp.IntVarLocalSearchOperatorTemplate.Value">Value</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.IntervalVar" href="#pywrapcp.IntervalVar">IntervalVar</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.IntervalVar.AvoidsDate" href="#pywrapcp.IntervalVar.AvoidsDate">AvoidsDate</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.CannotBePerformed" href="#pywrapcp.IntervalVar.CannotBePerformed">CannotBePerformed</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.CrossesDate" href="#pywrapcp.IntervalVar.CrossesDate">CrossesDate</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.DurationExpr" href="#pywrapcp.IntervalVar.DurationExpr">DurationExpr</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.DurationMax" href="#pywrapcp.IntervalVar.DurationMax">DurationMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.DurationMin" href="#pywrapcp.IntervalVar.DurationMin">DurationMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndExpr" href="#pywrapcp.IntervalVar.EndExpr">EndExpr</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndMax" href="#pywrapcp.IntervalVar.EndMax">EndMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndMin" href="#pywrapcp.IntervalVar.EndMin">EndMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndsAfter" href="#pywrapcp.IntervalVar.EndsAfter">EndsAfter</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndsAfterEnd" href="#pywrapcp.IntervalVar.EndsAfterEnd">EndsAfterEnd</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndsAfterEndWithDelay" href="#pywrapcp.IntervalVar.EndsAfterEndWithDelay">EndsAfterEndWithDelay</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndsAfterStart" href="#pywrapcp.IntervalVar.EndsAfterStart">EndsAfterStart</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndsAfterStartWithDelay" href="#pywrapcp.IntervalVar.EndsAfterStartWithDelay">EndsAfterStartWithDelay</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndsAt" href="#pywrapcp.IntervalVar.EndsAt">EndsAt</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndsAtEnd" href="#pywrapcp.IntervalVar.EndsAtEnd">EndsAtEnd</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndsAtEndWithDelay" href="#pywrapcp.IntervalVar.EndsAtEndWithDelay">EndsAtEndWithDelay</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndsAtStart" href="#pywrapcp.IntervalVar.EndsAtStart">EndsAtStart</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndsAtStartWithDelay" href="#pywrapcp.IntervalVar.EndsAtStartWithDelay">EndsAtStartWithDelay</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.EndsBefore" href="#pywrapcp.IntervalVar.EndsBefore">EndsBefore</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.IsPerformedBound" href="#pywrapcp.IntervalVar.IsPerformedBound">IsPerformedBound</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.MayBePerformed" href="#pywrapcp.IntervalVar.MayBePerformed">MayBePerformed</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.MustBePerformed" href="#pywrapcp.IntervalVar.MustBePerformed">MustBePerformed</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.OldDurationMax" href="#pywrapcp.IntervalVar.OldDurationMax">OldDurationMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.OldDurationMin" href="#pywrapcp.IntervalVar.OldDurationMin">OldDurationMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.OldEndMax" href="#pywrapcp.IntervalVar.OldEndMax">OldEndMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.OldEndMin" href="#pywrapcp.IntervalVar.OldEndMin">OldEndMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.OldStartMax" href="#pywrapcp.IntervalVar.OldStartMax">OldStartMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.OldStartMin" href="#pywrapcp.IntervalVar.OldStartMin">OldStartMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.PerformedExpr" href="#pywrapcp.IntervalVar.PerformedExpr">PerformedExpr</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.SafeDurationExpr" href="#pywrapcp.IntervalVar.SafeDurationExpr">SafeDurationExpr</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.SafeEndExpr" href="#pywrapcp.IntervalVar.SafeEndExpr">SafeEndExpr</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.SafeStartExpr" href="#pywrapcp.IntervalVar.SafeStartExpr">SafeStartExpr</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.SetDurationMax" href="#pywrapcp.IntervalVar.SetDurationMax">SetDurationMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.SetDurationMin" href="#pywrapcp.IntervalVar.SetDurationMin">SetDurationMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.SetDurationRange" href="#pywrapcp.IntervalVar.SetDurationRange">SetDurationRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.SetEndMax" href="#pywrapcp.IntervalVar.SetEndMax">SetEndMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.SetEndMin" href="#pywrapcp.IntervalVar.SetEndMin">SetEndMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.SetEndRange" href="#pywrapcp.IntervalVar.SetEndRange">SetEndRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.SetPerformed" href="#pywrapcp.IntervalVar.SetPerformed">SetPerformed</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.SetStartMax" href="#pywrapcp.IntervalVar.SetStartMax">SetStartMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.SetStartMin" href="#pywrapcp.IntervalVar.SetStartMin">SetStartMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.SetStartRange" href="#pywrapcp.IntervalVar.SetStartRange">SetStartRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartExpr" href="#pywrapcp.IntervalVar.StartExpr">StartExpr</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartMax" href="#pywrapcp.IntervalVar.StartMax">StartMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartMin" href="#pywrapcp.IntervalVar.StartMin">StartMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartsAfter" href="#pywrapcp.IntervalVar.StartsAfter">StartsAfter</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartsAfterEnd" href="#pywrapcp.IntervalVar.StartsAfterEnd">StartsAfterEnd</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartsAfterEndWithDelay" href="#pywrapcp.IntervalVar.StartsAfterEndWithDelay">StartsAfterEndWithDelay</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartsAfterStart" href="#pywrapcp.IntervalVar.StartsAfterStart">StartsAfterStart</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartsAfterStartWithDelay" href="#pywrapcp.IntervalVar.StartsAfterStartWithDelay">StartsAfterStartWithDelay</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartsAt" href="#pywrapcp.IntervalVar.StartsAt">StartsAt</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartsAtEnd" href="#pywrapcp.IntervalVar.StartsAtEnd">StartsAtEnd</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartsAtEndWithDelay" href="#pywrapcp.IntervalVar.StartsAtEndWithDelay">StartsAtEndWithDelay</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartsAtStart" href="#pywrapcp.IntervalVar.StartsAtStart">StartsAtStart</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartsAtStartWithDelay" href="#pywrapcp.IntervalVar.StartsAtStartWithDelay">StartsAtStartWithDelay</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StartsBefore" href="#pywrapcp.IntervalVar.StartsBefore">StartsBefore</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StaysInSync" href="#pywrapcp.IntervalVar.StaysInSync">StaysInSync</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.StaysInSyncWithDelay" href="#pywrapcp.IntervalVar.StaysInSyncWithDelay">StaysInSyncWithDelay</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.WasPerformedBound" href="#pywrapcp.IntervalVar.WasPerformedBound">WasPerformedBound</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.WhenAnything" href="#pywrapcp.IntervalVar.WhenAnything">WhenAnything</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.WhenDurationBound" href="#pywrapcp.IntervalVar.WhenDurationBound">WhenDurationBound</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.WhenDurationRange" href="#pywrapcp.IntervalVar.WhenDurationRange">WhenDurationRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.WhenEndBound" href="#pywrapcp.IntervalVar.WhenEndBound">WhenEndBound</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.WhenEndRange" href="#pywrapcp.IntervalVar.WhenEndRange">WhenEndRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.WhenPerformedBound" href="#pywrapcp.IntervalVar.WhenPerformedBound">WhenPerformedBound</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.WhenStartBound" href="#pywrapcp.IntervalVar.WhenStartBound">WhenStartBound</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVar.WhenStartRange" href="#pywrapcp.IntervalVar.WhenStartRange">WhenStartRange</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.IntervalVarContainer" href="#pywrapcp.IntervalVarContainer">IntervalVarContainer</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.IntervalVarContainer.Contains" href="#pywrapcp.IntervalVarContainer.Contains">Contains</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarContainer.Element" href="#pywrapcp.IntervalVarContainer.Element">Element</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarContainer.Restore" href="#pywrapcp.IntervalVarContainer.Restore">Restore</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarContainer.Size" href="#pywrapcp.IntervalVarContainer.Size">Size</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarContainer.Store" href="#pywrapcp.IntervalVarContainer.Store">Store</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarContainer.thisown" href="#pywrapcp.IntervalVarContainer.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.IntervalVarElement" href="#pywrapcp.IntervalVarElement">IntervalVarElement</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.IntervalVarElement.DurationMax" href="#pywrapcp.IntervalVarElement.DurationMax">DurationMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.DurationMin" href="#pywrapcp.IntervalVarElement.DurationMin">DurationMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.DurationValue" href="#pywrapcp.IntervalVarElement.DurationValue">DurationValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.EndMax" href="#pywrapcp.IntervalVarElement.EndMax">EndMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.EndMin" href="#pywrapcp.IntervalVarElement.EndMin">EndMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.EndValue" href="#pywrapcp.IntervalVarElement.EndValue">EndValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.PerformedMax" href="#pywrapcp.IntervalVarElement.PerformedMax">PerformedMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.PerformedMin" href="#pywrapcp.IntervalVarElement.PerformedMin">PerformedMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.PerformedValue" href="#pywrapcp.IntervalVarElement.PerformedValue">PerformedValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetDurationMax" href="#pywrapcp.IntervalVarElement.SetDurationMax">SetDurationMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetDurationMin" href="#pywrapcp.IntervalVarElement.SetDurationMin">SetDurationMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetDurationRange" href="#pywrapcp.IntervalVarElement.SetDurationRange">SetDurationRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetDurationValue" href="#pywrapcp.IntervalVarElement.SetDurationValue">SetDurationValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetEndMax" href="#pywrapcp.IntervalVarElement.SetEndMax">SetEndMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetEndMin" href="#pywrapcp.IntervalVarElement.SetEndMin">SetEndMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetEndRange" href="#pywrapcp.IntervalVarElement.SetEndRange">SetEndRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetEndValue" href="#pywrapcp.IntervalVarElement.SetEndValue">SetEndValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetPerformedMax" href="#pywrapcp.IntervalVarElement.SetPerformedMax">SetPerformedMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetPerformedMin" href="#pywrapcp.IntervalVarElement.SetPerformedMin">SetPerformedMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetPerformedRange" href="#pywrapcp.IntervalVarElement.SetPerformedRange">SetPerformedRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetPerformedValue" href="#pywrapcp.IntervalVarElement.SetPerformedValue">SetPerformedValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetStartMax" href="#pywrapcp.IntervalVarElement.SetStartMax">SetStartMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetStartMin" href="#pywrapcp.IntervalVarElement.SetStartMin">SetStartMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetStartRange" href="#pywrapcp.IntervalVarElement.SetStartRange">SetStartRange</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.SetStartValue" href="#pywrapcp.IntervalVarElement.SetStartValue">SetStartValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.StartMax" href="#pywrapcp.IntervalVarElement.StartMax">StartMax</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.StartMin" href="#pywrapcp.IntervalVarElement.StartMin">StartMin</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.StartValue" href="#pywrapcp.IntervalVarElement.StartValue">StartValue</a></code></li>
|
|
<li><code><a title="pywrapcp.IntervalVarElement.Var" href="#pywrapcp.IntervalVarElement.Var">Var</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder" href="#pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder">LocalCheapestInsertionFilteredDecisionBuilder</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder.BuildSolution" href="#pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder.BuildSolution">BuildSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder.DebugString" href="#pywrapcp.LocalCheapestInsertionFilteredDecisionBuilder.DebugString">DebugString</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.LocalSearchFilter" href="#pywrapcp.LocalSearchFilter">LocalSearchFilter</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.LocalSearchFilter.Accept" href="#pywrapcp.LocalSearchFilter.Accept">Accept</a></code></li>
|
|
<li><code><a title="pywrapcp.LocalSearchFilter.IsIncremental" href="#pywrapcp.LocalSearchFilter.IsIncremental">IsIncremental</a></code></li>
|
|
<li><code><a title="pywrapcp.LocalSearchFilter.Synchronize" href="#pywrapcp.LocalSearchFilter.Synchronize">Synchronize</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.LocalSearchOperator" href="#pywrapcp.LocalSearchOperator">LocalSearchOperator</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.LocalSearchOperator.NextNeighbor" href="#pywrapcp.LocalSearchOperator.NextNeighbor">NextNeighbor</a></code></li>
|
|
<li><code><a title="pywrapcp.LocalSearchOperator.Start" href="#pywrapcp.LocalSearchOperator.Start">Start</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.NumericalRevInteger" href="#pywrapcp.NumericalRevInteger">NumericalRevInteger</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.NumericalRevInteger.Add" href="#pywrapcp.NumericalRevInteger.Add">Add</a></code></li>
|
|
<li><code><a title="pywrapcp.NumericalRevInteger.Decr" href="#pywrapcp.NumericalRevInteger.Decr">Decr</a></code></li>
|
|
<li><code><a title="pywrapcp.NumericalRevInteger.Incr" href="#pywrapcp.NumericalRevInteger.Incr">Incr</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.OptimizeVar" href="#pywrapcp.OptimizeVar">OptimizeVar</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.OptimizeVar.AcceptDelta" href="#pywrapcp.OptimizeVar.AcceptDelta">AcceptDelta</a></code></li>
|
|
<li><code><a title="pywrapcp.OptimizeVar.Best" href="#pywrapcp.OptimizeVar.Best">Best</a></code></li>
|
|
<li><code><a title="pywrapcp.OptimizeVar.DebugString" href="#pywrapcp.OptimizeVar.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.OptimizeVar.Var" href="#pywrapcp.OptimizeVar.Var">Var</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.Pack" href="#pywrapcp.Pack">Pack</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.Pack.AddCountAssignedItemsDimension" href="#pywrapcp.Pack.AddCountAssignedItemsDimension">AddCountAssignedItemsDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.Pack.AddCountUsedBinDimension" href="#pywrapcp.Pack.AddCountUsedBinDimension">AddCountUsedBinDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.Pack.AddSumVariableWeightsLessOrEqualConstantDimension" href="#pywrapcp.Pack.AddSumVariableWeightsLessOrEqualConstantDimension">AddSumVariableWeightsLessOrEqualConstantDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.Pack.AddWeightedSumEqualVarDimension" href="#pywrapcp.Pack.AddWeightedSumEqualVarDimension">AddWeightedSumEqualVarDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.Pack.AddWeightedSumLessOrEqualConstantDimension" href="#pywrapcp.Pack.AddWeightedSumLessOrEqualConstantDimension">AddWeightedSumLessOrEqualConstantDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.Pack.AddWeightedSumOfAssignedDimension" href="#pywrapcp.Pack.AddWeightedSumOfAssignedDimension">AddWeightedSumOfAssignedDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.Pack.DebugString" href="#pywrapcp.Pack.DebugString">DebugString</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.ParallelSavingsFilteredDecisionBuilder" href="#pywrapcp.ParallelSavingsFilteredDecisionBuilder">ParallelSavingsFilteredDecisionBuilder</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.ParallelSavingsFilteredDecisionBuilder.DebugString" href="#pywrapcp.ParallelSavingsFilteredDecisionBuilder.DebugString">DebugString</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.PathOperator" href="#pywrapcp.PathOperator">PathOperator</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.PathOperator.Neighbor" href="#pywrapcp.PathOperator.Neighbor">Neighbor</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.PropagationBaseObject" href="#pywrapcp.PropagationBaseObject">PropagationBaseObject</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.PropagationBaseObject.DebugString" href="#pywrapcp.PropagationBaseObject.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.PropagationBaseObject.Name" href="#pywrapcp.PropagationBaseObject.Name">Name</a></code></li>
|
|
<li><code><a title="pywrapcp.PropagationBaseObject.solver" href="#pywrapcp.PropagationBaseObject.solver">solver</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.PyConstraint" href="#pywrapcp.PyConstraint">PyConstraint</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.PyConstraint.DebugString" href="#pywrapcp.PyConstraint.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.PyConstraint.DelayedDemon" href="#pywrapcp.PyConstraint.DelayedDemon">DelayedDemon</a></code></li>
|
|
<li><code><a title="pywrapcp.PyConstraint.DelayedInitialPropagateDemon" href="#pywrapcp.PyConstraint.DelayedInitialPropagateDemon">DelayedInitialPropagateDemon</a></code></li>
|
|
<li><code><a title="pywrapcp.PyConstraint.Demon" href="#pywrapcp.PyConstraint.Demon">Demon</a></code></li>
|
|
<li><code><a title="pywrapcp.PyConstraint.InitialPropagateDemon" href="#pywrapcp.PyConstraint.InitialPropagateDemon">InitialPropagateDemon</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.PyConstraintDemon" href="#pywrapcp.PyConstraintDemon">PyConstraintDemon</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.PyConstraintDemon.DebugString" href="#pywrapcp.PyConstraintDemon.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.PyConstraintDemon.Run" href="#pywrapcp.PyConstraintDemon.Run">Run</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.PyDecision" href="#pywrapcp.PyDecision">PyDecision</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.PyDecision.DebugString" href="#pywrapcp.PyDecision.DebugString">DebugString</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.PyDecisionBuilder" href="#pywrapcp.PyDecisionBuilder">PyDecisionBuilder</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.PyDecisionBuilder.DebugString" href="#pywrapcp.PyDecisionBuilder.DebugString">DebugString</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.PyDemon" href="#pywrapcp.PyDemon">PyDemon</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.PyDemon.DebugString" href="#pywrapcp.PyDemon.DebugString">DebugString</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.RevBool" href="#pywrapcp.RevBool">RevBool</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.RevBool.SetValue" href="#pywrapcp.RevBool.SetValue">SetValue</a></code></li>
|
|
<li><code><a title="pywrapcp.RevBool.Value" href="#pywrapcp.RevBool.Value">Value</a></code></li>
|
|
<li><code><a title="pywrapcp.RevBool.thisown" href="#pywrapcp.RevBool.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.RevInteger" href="#pywrapcp.RevInteger">RevInteger</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.RevInteger.SetValue" href="#pywrapcp.RevInteger.SetValue">SetValue</a></code></li>
|
|
<li><code><a title="pywrapcp.RevInteger.Value" href="#pywrapcp.RevInteger.Value">Value</a></code></li>
|
|
<li><code><a title="pywrapcp.RevInteger.thisown" href="#pywrapcp.RevInteger.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.RoutingDimension" href="#pywrapcp.RoutingDimension">RoutingDimension</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.RoutingDimension.AddNodePrecedence" href="#pywrapcp.RoutingDimension.AddNodePrecedence">AddNodePrecedence</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.CumulVar" href="#pywrapcp.RoutingDimension.CumulVar">CumulVar</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.FixedTransitVar" href="#pywrapcp.RoutingDimension.FixedTransitVar">FixedTransitVar</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.GetCumulVarSoftLowerBound" href="#pywrapcp.RoutingDimension.GetCumulVarSoftLowerBound">GetCumulVarSoftLowerBound</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.GetCumulVarSoftLowerBoundCoefficient" href="#pywrapcp.RoutingDimension.GetCumulVarSoftLowerBoundCoefficient">GetCumulVarSoftLowerBoundCoefficient</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.GetCumulVarSoftUpperBound" href="#pywrapcp.RoutingDimension.GetCumulVarSoftUpperBound">GetCumulVarSoftUpperBound</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.GetCumulVarSoftUpperBoundCoefficient" href="#pywrapcp.RoutingDimension.GetCumulVarSoftUpperBoundCoefficient">GetCumulVarSoftUpperBoundCoefficient</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.GetGlobalOptimizerOffset" href="#pywrapcp.RoutingDimension.GetGlobalOptimizerOffset">GetGlobalOptimizerOffset</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.GetLocalOptimizerOffsetForVehicle" href="#pywrapcp.RoutingDimension.GetLocalOptimizerOffsetForVehicle">GetLocalOptimizerOffsetForVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.GetPostTravelEvaluatorOfVehicle" href="#pywrapcp.RoutingDimension.GetPostTravelEvaluatorOfVehicle">GetPostTravelEvaluatorOfVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.GetPreTravelEvaluatorOfVehicle" href="#pywrapcp.RoutingDimension.GetPreTravelEvaluatorOfVehicle">GetPreTravelEvaluatorOfVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.GetSpanCostCoefficientForVehicle" href="#pywrapcp.RoutingDimension.GetSpanCostCoefficientForVehicle">GetSpanCostCoefficientForVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.GetSpanUpperBoundForVehicle" href="#pywrapcp.RoutingDimension.GetSpanUpperBoundForVehicle">GetSpanUpperBoundForVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.GetTransitValue" href="#pywrapcp.RoutingDimension.GetTransitValue">GetTransitValue</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.GetTransitValueFromClass" href="#pywrapcp.RoutingDimension.GetTransitValueFromClass">GetTransitValueFromClass</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.HasBreakConstraints" href="#pywrapcp.RoutingDimension.HasBreakConstraints">HasBreakConstraints</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.HasCumulVarSoftLowerBound" href="#pywrapcp.RoutingDimension.HasCumulVarSoftLowerBound">HasCumulVarSoftLowerBound</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.HasCumulVarSoftUpperBound" href="#pywrapcp.RoutingDimension.HasCumulVarSoftUpperBound">HasCumulVarSoftUpperBound</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.HasPickupToDeliveryLimits" href="#pywrapcp.RoutingDimension.HasPickupToDeliveryLimits">HasPickupToDeliveryLimits</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.InitializeBreaks" href="#pywrapcp.RoutingDimension.InitializeBreaks">InitializeBreaks</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.SetBreakDistanceDurationOfVehicle" href="#pywrapcp.RoutingDimension.SetBreakDistanceDurationOfVehicle">SetBreakDistanceDurationOfVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.SetBreakIntervalsOfVehicle" href="#pywrapcp.RoutingDimension.SetBreakIntervalsOfVehicle">SetBreakIntervalsOfVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.SetCumulVarSoftLowerBound" href="#pywrapcp.RoutingDimension.SetCumulVarSoftLowerBound">SetCumulVarSoftLowerBound</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.SetCumulVarSoftUpperBound" href="#pywrapcp.RoutingDimension.SetCumulVarSoftUpperBound">SetCumulVarSoftUpperBound</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.SetGlobalSpanCostCoefficient" href="#pywrapcp.RoutingDimension.SetGlobalSpanCostCoefficient">SetGlobalSpanCostCoefficient</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.SetPickupToDeliveryLimitFunctionForPair" href="#pywrapcp.RoutingDimension.SetPickupToDeliveryLimitFunctionForPair">SetPickupToDeliveryLimitFunctionForPair</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.SetSpanCostCoefficientForAllVehicles" href="#pywrapcp.RoutingDimension.SetSpanCostCoefficientForAllVehicles">SetSpanCostCoefficientForAllVehicles</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.SetSpanCostCoefficientForVehicle" href="#pywrapcp.RoutingDimension.SetSpanCostCoefficientForVehicle">SetSpanCostCoefficientForVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.SetSpanUpperBoundForVehicle" href="#pywrapcp.RoutingDimension.SetSpanUpperBoundForVehicle">SetSpanUpperBoundForVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.ShortestTransitionSlack" href="#pywrapcp.RoutingDimension.ShortestTransitionSlack">ShortestTransitionSlack</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.SlackVar" href="#pywrapcp.RoutingDimension.SlackVar">SlackVar</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.TransitVar" href="#pywrapcp.RoutingDimension.TransitVar">TransitVar</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.base_dimension" href="#pywrapcp.RoutingDimension.base_dimension">base_dimension</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.global_span_cost_coefficient" href="#pywrapcp.RoutingDimension.global_span_cost_coefficient">global_span_cost_coefficient</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.model" href="#pywrapcp.RoutingDimension.model">model</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.name" href="#pywrapcp.RoutingDimension.name">name</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingDimension.thisown" href="#pywrapcp.RoutingDimension.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.RoutingFilteredDecisionBuilder" href="#pywrapcp.RoutingFilteredDecisionBuilder">RoutingFilteredDecisionBuilder</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.RoutingFilteredDecisionBuilder.GetEndChainStart" href="#pywrapcp.RoutingFilteredDecisionBuilder.GetEndChainStart">GetEndChainStart</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingFilteredDecisionBuilder.GetStartChainEnd" href="#pywrapcp.RoutingFilteredDecisionBuilder.GetStartChainEnd">GetStartChainEnd</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingFilteredDecisionBuilder.MakeDisjunctionNodesUnperformed" href="#pywrapcp.RoutingFilteredDecisionBuilder.MakeDisjunctionNodesUnperformed">MakeDisjunctionNodesUnperformed</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingFilteredDecisionBuilder.MakeUnassignedNodesUnperformed" href="#pywrapcp.RoutingFilteredDecisionBuilder.MakeUnassignedNodesUnperformed">MakeUnassignedNodesUnperformed</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingFilteredDecisionBuilder.model" href="#pywrapcp.RoutingFilteredDecisionBuilder.model">model</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.RoutingIndexManager" href="#pywrapcp.RoutingIndexManager">RoutingIndexManager</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.RoutingIndexManager.GetNumberOfIndices" href="#pywrapcp.RoutingIndexManager.GetNumberOfIndices">GetNumberOfIndices</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingIndexManager.GetNumberOfNodes" href="#pywrapcp.RoutingIndexManager.GetNumberOfNodes">GetNumberOfNodes</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingIndexManager.GetNumberOfVehicles" href="#pywrapcp.RoutingIndexManager.GetNumberOfVehicles">GetNumberOfVehicles</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingIndexManager.IndexToNode" href="#pywrapcp.RoutingIndexManager.IndexToNode">IndexToNode</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingIndexManager.NodeToIndex" href="#pywrapcp.RoutingIndexManager.NodeToIndex">NodeToIndex</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingIndexManager.thisown" href="#pywrapcp.RoutingIndexManager.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.RoutingModel" href="#pywrapcp.RoutingModel">RoutingModel</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.RoutingModel.ActiveVar" href="#pywrapcp.RoutingModel.ActiveVar">ActiveVar</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddAtSolutionCallback" href="#pywrapcp.RoutingModel.AddAtSolutionCallback">AddAtSolutionCallback</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddConstantDimension" href="#pywrapcp.RoutingModel.AddConstantDimension">AddConstantDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddConstantDimensionWithSlack" href="#pywrapcp.RoutingModel.AddConstantDimensionWithSlack">AddConstantDimensionWithSlack</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddDimension" href="#pywrapcp.RoutingModel.AddDimension">AddDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddDimensionWithVehicleCapacity" href="#pywrapcp.RoutingModel.AddDimensionWithVehicleCapacity">AddDimensionWithVehicleCapacity</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddDimensionWithVehicleTransitAndCapacity" href="#pywrapcp.RoutingModel.AddDimensionWithVehicleTransitAndCapacity">AddDimensionWithVehicleTransitAndCapacity</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddDimensionWithVehicleTransits" href="#pywrapcp.RoutingModel.AddDimensionWithVehicleTransits">AddDimensionWithVehicleTransits</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddDisjunction" href="#pywrapcp.RoutingModel.AddDisjunction">AddDisjunction</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddHardTypeIncompatibility" href="#pywrapcp.RoutingModel.AddHardTypeIncompatibility">AddHardTypeIncompatibility</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddIntervalToAssignment" href="#pywrapcp.RoutingModel.AddIntervalToAssignment">AddIntervalToAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddLocalSearchFilter" href="#pywrapcp.RoutingModel.AddLocalSearchFilter">AddLocalSearchFilter</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddLocalSearchOperator" href="#pywrapcp.RoutingModel.AddLocalSearchOperator">AddLocalSearchOperator</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddMatrixDimension" href="#pywrapcp.RoutingModel.AddMatrixDimension">AddMatrixDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddPickupAndDelivery" href="#pywrapcp.RoutingModel.AddPickupAndDelivery">AddPickupAndDelivery</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddPickupAndDeliverySets" href="#pywrapcp.RoutingModel.AddPickupAndDeliverySets">AddPickupAndDeliverySets</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddSameVehicleRequiredTypeAlternatives" href="#pywrapcp.RoutingModel.AddSameVehicleRequiredTypeAlternatives">AddSameVehicleRequiredTypeAlternatives</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddSearchMonitor" href="#pywrapcp.RoutingModel.AddSearchMonitor">AddSearchMonitor</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddSoftSameVehicleConstraint" href="#pywrapcp.RoutingModel.AddSoftSameVehicleConstraint">AddSoftSameVehicleConstraint</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddTemporalRequiredTypeAlternatives" href="#pywrapcp.RoutingModel.AddTemporalRequiredTypeAlternatives">AddTemporalRequiredTypeAlternatives</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddTemporalTypeIncompatibility" href="#pywrapcp.RoutingModel.AddTemporalTypeIncompatibility">AddTemporalTypeIncompatibility</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddToAssignment" href="#pywrapcp.RoutingModel.AddToAssignment">AddToAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddVariableMaximizedByFinalizer" href="#pywrapcp.RoutingModel.AddVariableMaximizedByFinalizer">AddVariableMaximizedByFinalizer</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddVariableMinimizedByFinalizer" href="#pywrapcp.RoutingModel.AddVariableMinimizedByFinalizer">AddVariableMinimizedByFinalizer</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddVariableTargetToFinalizer" href="#pywrapcp.RoutingModel.AddVariableTargetToFinalizer">AddVariableTargetToFinalizer</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddVectorDimension" href="#pywrapcp.RoutingModel.AddVectorDimension">AddVectorDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AddWeightedVariableMinimizedByFinalizer" href="#pywrapcp.RoutingModel.AddWeightedVariableMinimizedByFinalizer">AddWeightedVariableMinimizedByFinalizer</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.ApplyLocks" href="#pywrapcp.RoutingModel.ApplyLocks">ApplyLocks</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.ApplyLocksToAllVehicles" href="#pywrapcp.RoutingModel.ApplyLocksToAllVehicles">ApplyLocksToAllVehicles</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.ArcIsMoreConstrainedThanArc" href="#pywrapcp.RoutingModel.ArcIsMoreConstrainedThanArc">ArcIsMoreConstrainedThanArc</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AreEmptyRouteCostsConsideredForVehicle" href="#pywrapcp.RoutingModel.AreEmptyRouteCostsConsideredForVehicle">AreEmptyRouteCostsConsideredForVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.AssignmentToRoutes" href="#pywrapcp.RoutingModel.AssignmentToRoutes">AssignmentToRoutes</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.CheckLimit" href="#pywrapcp.RoutingModel.CheckLimit">CheckLimit</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.CloseModel" href="#pywrapcp.RoutingModel.CloseModel">CloseModel</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.CloseModelWithParameters" href="#pywrapcp.RoutingModel.CloseModelWithParameters">CloseModelWithParameters</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.CloseVisitTypes" href="#pywrapcp.RoutingModel.CloseVisitTypes">CloseVisitTypes</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.CompactAndCheckAssignment" href="#pywrapcp.RoutingModel.CompactAndCheckAssignment">CompactAndCheckAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.CompactAssignment" href="#pywrapcp.RoutingModel.CompactAssignment">CompactAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.ComputeLowerBound" href="#pywrapcp.RoutingModel.ComputeLowerBound">ComputeLowerBound</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.ConsiderEmptyRouteCostsForVehicle" href="#pywrapcp.RoutingModel.ConsiderEmptyRouteCostsForVehicle">ConsiderEmptyRouteCostsForVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.CostVar" href="#pywrapcp.RoutingModel.CostVar">CostVar</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.CostsAreHomogeneousAcrossVehicles" href="#pywrapcp.RoutingModel.CostsAreHomogeneousAcrossVehicles">CostsAreHomogeneousAcrossVehicles</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.DebugOutputAssignment" href="#pywrapcp.RoutingModel.DebugOutputAssignment">DebugOutputAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.End" href="#pywrapcp.RoutingModel.End">End</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetAllDimensionNames" href="#pywrapcp.RoutingModel.GetAllDimensionNames">GetAllDimensionNames</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetAmortizedLinearCostFactorOfVehicles" href="#pywrapcp.RoutingModel.GetAmortizedLinearCostFactorOfVehicles">GetAmortizedLinearCostFactorOfVehicles</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetAmortizedQuadraticCostFactorOfVehicles" href="#pywrapcp.RoutingModel.GetAmortizedQuadraticCostFactorOfVehicles">GetAmortizedQuadraticCostFactorOfVehicles</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetArcCostForClass" href="#pywrapcp.RoutingModel.GetArcCostForClass">GetArcCostForClass</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetArcCostForFirstSolution" href="#pywrapcp.RoutingModel.GetArcCostForFirstSolution">GetArcCostForFirstSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetArcCostForVehicle" href="#pywrapcp.RoutingModel.GetArcCostForVehicle">GetArcCostForVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetCostClassIndexOfVehicle" href="#pywrapcp.RoutingModel.GetCostClassIndexOfVehicle">GetCostClassIndexOfVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetCostClassesCount" href="#pywrapcp.RoutingModel.GetCostClassesCount">GetCostClassesCount</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetDeliveryIndexPairs" href="#pywrapcp.RoutingModel.GetDeliveryIndexPairs">GetDeliveryIndexPairs</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetDepot" href="#pywrapcp.RoutingModel.GetDepot">GetDepot</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetDimensionOrDie" href="#pywrapcp.RoutingModel.GetDimensionOrDie">GetDimensionOrDie</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetDimensions" href="#pywrapcp.RoutingModel.GetDimensions">GetDimensions</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetDimensionsForGlobalCumulOptimizers" href="#pywrapcp.RoutingModel.GetDimensionsForGlobalCumulOptimizers">GetDimensionsForGlobalCumulOptimizers</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetDimensionsForLocalCumulOptimizers" href="#pywrapcp.RoutingModel.GetDimensionsForLocalCumulOptimizers">GetDimensionsForLocalCumulOptimizers</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetDimensionsWithSoftOrSpanCosts" href="#pywrapcp.RoutingModel.GetDimensionsWithSoftOrSpanCosts">GetDimensionsWithSoftOrSpanCosts</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetDisjunctionIndices" href="#pywrapcp.RoutingModel.GetDisjunctionIndices">GetDisjunctionIndices</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetDisjunctionMaxCardinality" href="#pywrapcp.RoutingModel.GetDisjunctionMaxCardinality">GetDisjunctionMaxCardinality</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetDisjunctionPenalty" href="#pywrapcp.RoutingModel.GetDisjunctionPenalty">GetDisjunctionPenalty</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetFixedCostOfVehicle" href="#pywrapcp.RoutingModel.GetFixedCostOfVehicle">GetFixedCostOfVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetHardTypeIncompatibilitiesOfType" href="#pywrapcp.RoutingModel.GetHardTypeIncompatibilitiesOfType">GetHardTypeIncompatibilitiesOfType</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetHomogeneousCost" href="#pywrapcp.RoutingModel.GetHomogeneousCost">GetHomogeneousCost</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetMutableDimension" href="#pywrapcp.RoutingModel.GetMutableDimension">GetMutableDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetNonZeroCostClassesCount" href="#pywrapcp.RoutingModel.GetNonZeroCostClassesCount">GetNonZeroCostClassesCount</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetNumOfSingletonNodes" href="#pywrapcp.RoutingModel.GetNumOfSingletonNodes">GetNumOfSingletonNodes</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetNumberOfDecisionsInFirstSolution" href="#pywrapcp.RoutingModel.GetNumberOfDecisionsInFirstSolution">GetNumberOfDecisionsInFirstSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetNumberOfDisjunctions" href="#pywrapcp.RoutingModel.GetNumberOfDisjunctions">GetNumberOfDisjunctions</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetNumberOfRejectsInFirstSolution" href="#pywrapcp.RoutingModel.GetNumberOfRejectsInFirstSolution">GetNumberOfRejectsInFirstSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetNumberOfVisitTypes" href="#pywrapcp.RoutingModel.GetNumberOfVisitTypes">GetNumberOfVisitTypes</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetPerfectBinaryDisjunctions" href="#pywrapcp.RoutingModel.GetPerfectBinaryDisjunctions">GetPerfectBinaryDisjunctions</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetPickupAndDeliveryPolicyOfVehicle" href="#pywrapcp.RoutingModel.GetPickupAndDeliveryPolicyOfVehicle">GetPickupAndDeliveryPolicyOfVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetPickupIndexPairs" href="#pywrapcp.RoutingModel.GetPickupIndexPairs">GetPickupIndexPairs</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetPrimaryConstrainedDimension" href="#pywrapcp.RoutingModel.GetPrimaryConstrainedDimension">GetPrimaryConstrainedDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetSameVehicleIndicesOfIndex" href="#pywrapcp.RoutingModel.GetSameVehicleIndicesOfIndex">GetSameVehicleIndicesOfIndex</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetSameVehicleRequiredTypeAlternativesOfType" href="#pywrapcp.RoutingModel.GetSameVehicleRequiredTypeAlternativesOfType">GetSameVehicleRequiredTypeAlternativesOfType</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetTemporalRequiredTypeAlternativesOfType" href="#pywrapcp.RoutingModel.GetTemporalRequiredTypeAlternativesOfType">GetTemporalRequiredTypeAlternativesOfType</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetTemporalTypeIncompatibilitiesOfType" href="#pywrapcp.RoutingModel.GetTemporalTypeIncompatibilitiesOfType">GetTemporalTypeIncompatibilitiesOfType</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetVehicleClassIndexOfVehicle" href="#pywrapcp.RoutingModel.GetVehicleClassIndexOfVehicle">GetVehicleClassIndexOfVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetVehicleClassesCount" href="#pywrapcp.RoutingModel.GetVehicleClassesCount">GetVehicleClassesCount</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.GetVisitType" href="#pywrapcp.RoutingModel.GetVisitType">GetVisitType</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.HasDimension" href="#pywrapcp.RoutingModel.HasDimension">HasDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.HasHardTypeIncompatibilities" href="#pywrapcp.RoutingModel.HasHardTypeIncompatibilities">HasHardTypeIncompatibilities</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.HasSameVehicleTypeRequirements" href="#pywrapcp.RoutingModel.HasSameVehicleTypeRequirements">HasSameVehicleTypeRequirements</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.HasTemporalTypeIncompatibilities" href="#pywrapcp.RoutingModel.HasTemporalTypeIncompatibilities">HasTemporalTypeIncompatibilities</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.HasTemporalTypeRequirements" href="#pywrapcp.RoutingModel.HasTemporalTypeRequirements">HasTemporalTypeRequirements</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.HasTypeRegulations" href="#pywrapcp.RoutingModel.HasTypeRegulations">HasTypeRegulations</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.HasVehicleWithCostClassIndex" href="#pywrapcp.RoutingModel.HasVehicleWithCostClassIndex">HasVehicleWithCostClassIndex</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.IgnoreDisjunctionsAlreadyForcedToZero" href="#pywrapcp.RoutingModel.IgnoreDisjunctionsAlreadyForcedToZero">IgnoreDisjunctionsAlreadyForcedToZero</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.IsEnd" href="#pywrapcp.RoutingModel.IsEnd">IsEnd</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.IsMatchingModel" href="#pywrapcp.RoutingModel.IsMatchingModel">IsMatchingModel</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.IsStart" href="#pywrapcp.RoutingModel.IsStart">IsStart</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.IsVehicleAllowedForIndex" href="#pywrapcp.RoutingModel.IsVehicleAllowedForIndex">IsVehicleAllowedForIndex</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.IsVehicleUsed" href="#pywrapcp.RoutingModel.IsVehicleUsed">IsVehicleUsed</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.MakeGuidedSlackFinalizer" href="#pywrapcp.RoutingModel.MakeGuidedSlackFinalizer">MakeGuidedSlackFinalizer</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.MakePathSpansAndTotalSlacks" href="#pywrapcp.RoutingModel.MakePathSpansAndTotalSlacks">MakePathSpansAndTotalSlacks</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.MakeSelfDependentDimensionFinalizer" href="#pywrapcp.RoutingModel.MakeSelfDependentDimensionFinalizer">MakeSelfDependentDimensionFinalizer</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.MutablePreAssignment" href="#pywrapcp.RoutingModel.MutablePreAssignment">MutablePreAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.Next" href="#pywrapcp.RoutingModel.Next">Next</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.NextVar" href="#pywrapcp.RoutingModel.NextVar">NextVar</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.PICKUP_AND_DELIVERY_FIFO" href="#pywrapcp.RoutingModel.PICKUP_AND_DELIVERY_FIFO">PICKUP_AND_DELIVERY_FIFO</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.PICKUP_AND_DELIVERY_LIFO" href="#pywrapcp.RoutingModel.PICKUP_AND_DELIVERY_LIFO">PICKUP_AND_DELIVERY_LIFO</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.PICKUP_AND_DELIVERY_NO_ORDER" href="#pywrapcp.RoutingModel.PICKUP_AND_DELIVERY_NO_ORDER">PICKUP_AND_DELIVERY_NO_ORDER</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.PackCumulsOfOptimizerDimensionsFromAssignment" href="#pywrapcp.RoutingModel.PackCumulsOfOptimizerDimensionsFromAssignment">PackCumulsOfOptimizerDimensionsFromAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.PreAssignment" href="#pywrapcp.RoutingModel.PreAssignment">PreAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.ROUTING_FAIL" href="#pywrapcp.RoutingModel.ROUTING_FAIL">ROUTING_FAIL</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.ROUTING_FAIL_TIMEOUT" href="#pywrapcp.RoutingModel.ROUTING_FAIL_TIMEOUT">ROUTING_FAIL_TIMEOUT</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.ROUTING_INVALID" href="#pywrapcp.RoutingModel.ROUTING_INVALID">ROUTING_INVALID</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.ROUTING_NOT_SOLVED" href="#pywrapcp.RoutingModel.ROUTING_NOT_SOLVED">ROUTING_NOT_SOLVED</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.ROUTING_SUCCESS" href="#pywrapcp.RoutingModel.ROUTING_SUCCESS">ROUTING_SUCCESS</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.ReadAssignment" href="#pywrapcp.RoutingModel.ReadAssignment">ReadAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.ReadAssignmentFromRoutes" href="#pywrapcp.RoutingModel.ReadAssignmentFromRoutes">ReadAssignmentFromRoutes</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.RegisterPositiveTransitCallback" href="#pywrapcp.RoutingModel.RegisterPositiveTransitCallback">RegisterPositiveTransitCallback</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.RegisterTransitCallback" href="#pywrapcp.RoutingModel.RegisterTransitCallback">RegisterTransitCallback</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.RegisterUnaryTransitCallback" href="#pywrapcp.RoutingModel.RegisterUnaryTransitCallback">RegisterUnaryTransitCallback</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.RemainingTime" href="#pywrapcp.RoutingModel.RemainingTime">RemainingTime</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.RestoreAssignment" href="#pywrapcp.RoutingModel.RestoreAssignment">RestoreAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.RoutesToAssignment" href="#pywrapcp.RoutingModel.RoutesToAssignment">RoutesToAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SetAllowedVehiclesForIndex" href="#pywrapcp.RoutingModel.SetAllowedVehiclesForIndex">SetAllowedVehiclesForIndex</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SetAmortizedCostFactorsOfAllVehicles" href="#pywrapcp.RoutingModel.SetAmortizedCostFactorsOfAllVehicles">SetAmortizedCostFactorsOfAllVehicles</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SetAmortizedCostFactorsOfVehicle" href="#pywrapcp.RoutingModel.SetAmortizedCostFactorsOfVehicle">SetAmortizedCostFactorsOfVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SetArcCostEvaluatorOfAllVehicles" href="#pywrapcp.RoutingModel.SetArcCostEvaluatorOfAllVehicles">SetArcCostEvaluatorOfAllVehicles</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SetArcCostEvaluatorOfVehicle" href="#pywrapcp.RoutingModel.SetArcCostEvaluatorOfVehicle">SetArcCostEvaluatorOfVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SetAssignmentFromOtherModelAssignment" href="#pywrapcp.RoutingModel.SetAssignmentFromOtherModelAssignment">SetAssignmentFromOtherModelAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SetFirstSolutionEvaluator" href="#pywrapcp.RoutingModel.SetFirstSolutionEvaluator">SetFirstSolutionEvaluator</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SetFixedCostOfAllVehicles" href="#pywrapcp.RoutingModel.SetFixedCostOfAllVehicles">SetFixedCostOfAllVehicles</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SetFixedCostOfVehicle" href="#pywrapcp.RoutingModel.SetFixedCostOfVehicle">SetFixedCostOfVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SetPickupAndDeliveryPolicyOfAllVehicles" href="#pywrapcp.RoutingModel.SetPickupAndDeliveryPolicyOfAllVehicles">SetPickupAndDeliveryPolicyOfAllVehicles</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SetPickupAndDeliveryPolicyOfVehicle" href="#pywrapcp.RoutingModel.SetPickupAndDeliveryPolicyOfVehicle">SetPickupAndDeliveryPolicyOfVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SetPrimaryConstrainedDimension" href="#pywrapcp.RoutingModel.SetPrimaryConstrainedDimension">SetPrimaryConstrainedDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SetVisitType" href="#pywrapcp.RoutingModel.SetVisitType">SetVisitType</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.Size" href="#pywrapcp.RoutingModel.Size">Size</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.Solve" href="#pywrapcp.RoutingModel.Solve">Solve</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SolveFromAssignmentWithParameters" href="#pywrapcp.RoutingModel.SolveFromAssignmentWithParameters">SolveFromAssignmentWithParameters</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.SolveWithParameters" href="#pywrapcp.RoutingModel.SolveWithParameters">SolveWithParameters</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.Start" href="#pywrapcp.RoutingModel.Start">Start</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.TransitCallback" href="#pywrapcp.RoutingModel.TransitCallback">TransitCallback</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.UnaryTransitCallbackOrNull" href="#pywrapcp.RoutingModel.UnaryTransitCallbackOrNull">UnaryTransitCallbackOrNull</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.UnperformedPenalty" href="#pywrapcp.RoutingModel.UnperformedPenalty">UnperformedPenalty</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.UnperformedPenaltyOrValue" href="#pywrapcp.RoutingModel.UnperformedPenaltyOrValue">UnperformedPenaltyOrValue</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.VehicleCostsConsideredVar" href="#pywrapcp.RoutingModel.VehicleCostsConsideredVar">VehicleCostsConsideredVar</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.VehicleIndex" href="#pywrapcp.RoutingModel.VehicleIndex">VehicleIndex</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.VehicleVar" href="#pywrapcp.RoutingModel.VehicleVar">VehicleVar</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.WriteAssignment" href="#pywrapcp.RoutingModel.WriteAssignment">WriteAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.kNoDimension" href="#pywrapcp.RoutingModel.kNoDimension">kNoDimension</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.kNoDisjunction" href="#pywrapcp.RoutingModel.kNoDisjunction">kNoDisjunction</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.kNoPenalty" href="#pywrapcp.RoutingModel.kNoPenalty">kNoPenalty</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.nodes" href="#pywrapcp.RoutingModel.nodes">nodes</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.solver" href="#pywrapcp.RoutingModel.solver">solver</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.status" href="#pywrapcp.RoutingModel.status">status</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.thisown" href="#pywrapcp.RoutingModel.thisown">thisown</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModel.vehicles" href="#pywrapcp.RoutingModel.vehicles">vehicles</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.RoutingModelVisitor" href="#pywrapcp.RoutingModelVisitor">RoutingModelVisitor</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.RoutingModelVisitor.kLightElement" href="#pywrapcp.RoutingModelVisitor.kLightElement">kLightElement</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModelVisitor.kLightElement2" href="#pywrapcp.RoutingModelVisitor.kLightElement2">kLightElement2</a></code></li>
|
|
<li><code><a title="pywrapcp.RoutingModelVisitor.kRemoveValues" href="#pywrapcp.RoutingModelVisitor.kRemoveValues">kRemoveValues</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.SavingsFilteredDecisionBuilder" href="#pywrapcp.SavingsFilteredDecisionBuilder">SavingsFilteredDecisionBuilder</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.SavingsFilteredDecisionBuilder.BuildSolution" href="#pywrapcp.SavingsFilteredDecisionBuilder.BuildSolution">BuildSolution</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.SearchLimit" href="#pywrapcp.SearchLimit">SearchLimit</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.SearchLimit.Check" href="#pywrapcp.SearchLimit.Check">Check</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchLimit.Crossed" href="#pywrapcp.SearchLimit.Crossed">Crossed</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchLimit.DebugString" href="#pywrapcp.SearchLimit.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchLimit.EnterSearch" href="#pywrapcp.SearchLimit.EnterSearch">EnterSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchLimit.Init" href="#pywrapcp.SearchLimit.Init">Init</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.SearchMonitor" href="#pywrapcp.SearchMonitor">SearchMonitor</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.SearchMonitor.AcceptDelta" href="#pywrapcp.SearchMonitor.AcceptDelta">AcceptDelta</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.AcceptNeighbor" href="#pywrapcp.SearchMonitor.AcceptNeighbor">AcceptNeighbor</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.AcceptSolution" href="#pywrapcp.SearchMonitor.AcceptSolution">AcceptSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.AfterDecision" href="#pywrapcp.SearchMonitor.AfterDecision">AfterDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.ApplyDecision" href="#pywrapcp.SearchMonitor.ApplyDecision">ApplyDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.AtSolution" href="#pywrapcp.SearchMonitor.AtSolution">AtSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.BeginFail" href="#pywrapcp.SearchMonitor.BeginFail">BeginFail</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.BeginInitialPropagation" href="#pywrapcp.SearchMonitor.BeginInitialPropagation">BeginInitialPropagation</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.BeginNextDecision" href="#pywrapcp.SearchMonitor.BeginNextDecision">BeginNextDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EndFail" href="#pywrapcp.SearchMonitor.EndFail">EndFail</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EndInitialPropagation" href="#pywrapcp.SearchMonitor.EndInitialPropagation">EndInitialPropagation</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EndNextDecision" href="#pywrapcp.SearchMonitor.EndNextDecision">EndNextDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.EnterSearch" href="#pywrapcp.SearchMonitor.EnterSearch">EnterSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.ExitSearch" href="#pywrapcp.SearchMonitor.ExitSearch">ExitSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.LocalOptimum" href="#pywrapcp.SearchMonitor.LocalOptimum">LocalOptimum</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.NoMoreSolutions" href="#pywrapcp.SearchMonitor.NoMoreSolutions">NoMoreSolutions</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.RefuteDecision" href="#pywrapcp.SearchMonitor.RefuteDecision">RefuteDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.RestartSearch" href="#pywrapcp.SearchMonitor.RestartSearch">RestartSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.SearchMonitor.solver" href="#pywrapcp.SearchMonitor.solver">solver</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.SequenceVar" href="#pywrapcp.SequenceVar">SequenceVar</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.SequenceVar.DebugString" href="#pywrapcp.SequenceVar.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVar.Interval" href="#pywrapcp.SequenceVar.Interval">Interval</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVar.Next" href="#pywrapcp.SequenceVar.Next">Next</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVar.RankFirst" href="#pywrapcp.SequenceVar.RankFirst">RankFirst</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVar.RankLast" href="#pywrapcp.SequenceVar.RankLast">RankLast</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVar.RankNotFirst" href="#pywrapcp.SequenceVar.RankNotFirst">RankNotFirst</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVar.RankNotLast" href="#pywrapcp.SequenceVar.RankNotLast">RankNotLast</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVar.Size" href="#pywrapcp.SequenceVar.Size">Size</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.SequenceVarContainer" href="#pywrapcp.SequenceVarContainer">SequenceVarContainer</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.SequenceVarContainer.Contains" href="#pywrapcp.SequenceVarContainer.Contains">Contains</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarContainer.Element" href="#pywrapcp.SequenceVarContainer.Element">Element</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarContainer.Restore" href="#pywrapcp.SequenceVarContainer.Restore">Restore</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarContainer.Size" href="#pywrapcp.SequenceVarContainer.Size">Size</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarContainer.Store" href="#pywrapcp.SequenceVarContainer.Store">Store</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarContainer.thisown" href="#pywrapcp.SequenceVarContainer.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.SequenceVarElement" href="#pywrapcp.SequenceVarElement">SequenceVarElement</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.SequenceVarElement.BackwardSequence" href="#pywrapcp.SequenceVarElement.BackwardSequence">BackwardSequence</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarElement.ForwardSequence" href="#pywrapcp.SequenceVarElement.ForwardSequence">ForwardSequence</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarElement.SetBackwardSequence" href="#pywrapcp.SequenceVarElement.SetBackwardSequence">SetBackwardSequence</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarElement.SetForwardSequence" href="#pywrapcp.SequenceVarElement.SetForwardSequence">SetForwardSequence</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarElement.SetSequence" href="#pywrapcp.SequenceVarElement.SetSequence">SetSequence</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarElement.SetUnperformed" href="#pywrapcp.SequenceVarElement.SetUnperformed">SetUnperformed</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarElement.Unperformed" href="#pywrapcp.SequenceVarElement.Unperformed">Unperformed</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarElement.Var" href="#pywrapcp.SequenceVarElement.Var">Var</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.SequenceVarLocalSearchOperator" href="#pywrapcp.SequenceVarLocalSearchOperator">SequenceVarLocalSearchOperator</a></code></h4>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate">SequenceVarLocalSearchOperatorTemplate</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate.IsIncremental" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate.IsIncremental">IsIncremental</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate.OldValue" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate.OldValue">OldValue</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate.OnStart" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate.OnStart">OnStart</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate.SetValue" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate.SetValue">SetValue</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate.Size" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate.Size">Size</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate.Start" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate.Start">Start</a></code></li>
|
|
<li><code><a title="pywrapcp.SequenceVarLocalSearchOperatorTemplate.Value" href="#pywrapcp.SequenceVarLocalSearchOperatorTemplate.Value">Value</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.SequentialSavingsFilteredDecisionBuilder" href="#pywrapcp.SequentialSavingsFilteredDecisionBuilder">SequentialSavingsFilteredDecisionBuilder</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.SequentialSavingsFilteredDecisionBuilder.DebugString" href="#pywrapcp.SequentialSavingsFilteredDecisionBuilder.DebugString">DebugString</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.SolutionCollector" href="#pywrapcp.SolutionCollector">SolutionCollector</a></code></h4>
|
|
<ul class="two-column">
|
|
<li><code><a title="pywrapcp.SolutionCollector.Add" href="#pywrapcp.SolutionCollector.Add">Add</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.AddObjective" href="#pywrapcp.SolutionCollector.AddObjective">AddObjective</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.BackwardSequence" href="#pywrapcp.SolutionCollector.BackwardSequence">BackwardSequence</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.Branches" href="#pywrapcp.SolutionCollector.Branches">Branches</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.DebugString" href="#pywrapcp.SolutionCollector.DebugString">DebugString</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.DurationValue" href="#pywrapcp.SolutionCollector.DurationValue">DurationValue</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.EndValue" href="#pywrapcp.SolutionCollector.EndValue">EndValue</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.Failures" href="#pywrapcp.SolutionCollector.Failures">Failures</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.ForwardSequence" href="#pywrapcp.SolutionCollector.ForwardSequence">ForwardSequence</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.ObjectiveValue" href="#pywrapcp.SolutionCollector.ObjectiveValue">ObjectiveValue</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.PerformedValue" href="#pywrapcp.SolutionCollector.PerformedValue">PerformedValue</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.Solution" href="#pywrapcp.SolutionCollector.Solution">Solution</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.SolutionCount" href="#pywrapcp.SolutionCollector.SolutionCount">SolutionCount</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.StartValue" href="#pywrapcp.SolutionCollector.StartValue">StartValue</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.Unperformed" href="#pywrapcp.SolutionCollector.Unperformed">Unperformed</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.Value" href="#pywrapcp.SolutionCollector.Value">Value</a></code></li>
|
|
<li><code><a title="pywrapcp.SolutionCollector.WallTime" href="#pywrapcp.SolutionCollector.WallTime">WallTime</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.Solver" href="#pywrapcp.Solver">Solver</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.Solver.ASSIGN_CENTER_VALUE" href="#pywrapcp.Solver.ASSIGN_CENTER_VALUE">ASSIGN_CENTER_VALUE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ASSIGN_MAX_VALUE" href="#pywrapcp.Solver.ASSIGN_MAX_VALUE">ASSIGN_MAX_VALUE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ASSIGN_MIN_VALUE" href="#pywrapcp.Solver.ASSIGN_MIN_VALUE">ASSIGN_MIN_VALUE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ASSIGN_RANDOM_VALUE" href="#pywrapcp.Solver.ASSIGN_RANDOM_VALUE">ASSIGN_RANDOM_VALUE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.AbsEquality" href="#pywrapcp.Solver.AbsEquality">AbsEquality</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Accept" href="#pywrapcp.Solver.Accept">Accept</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.AcceptedNeighbors" href="#pywrapcp.Solver.AcceptedNeighbors">AcceptedNeighbors</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Add" href="#pywrapcp.Solver.Add">Add</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.AddConstraint" href="#pywrapcp.Solver.AddConstraint">AddConstraint</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.AllDifferent" href="#pywrapcp.Solver.AllDifferent">AllDifferent</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.AllDifferentExcept" href="#pywrapcp.Solver.AllDifferentExcept">AllDifferentExcept</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.AllSolutionCollector" href="#pywrapcp.Solver.AllSolutionCollector">AllSolutionCollector</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.AllowedAssignments" href="#pywrapcp.Solver.AllowedAssignments">AllowedAssignments</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.AssignVariableValue" href="#pywrapcp.Solver.AssignVariableValue">AssignVariableValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.AssignVariableValueOrFail" href="#pywrapcp.Solver.AssignVariableValueOrFail">AssignVariableValueOrFail</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.AssignVariablesValues" href="#pywrapcp.Solver.AssignVariablesValues">AssignVariablesValues</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Assignment" href="#pywrapcp.Solver.Assignment">Assignment</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.BestValueSolutionCollector" href="#pywrapcp.Solver.BestValueSolutionCollector">BestValueSolutionCollector</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.BetweenCt" href="#pywrapcp.Solver.BetweenCt">BetweenCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.BoolVar" href="#pywrapcp.Solver.BoolVar">BoolVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Branches" href="#pywrapcp.Solver.Branches">Branches</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.BranchesLimit" href="#pywrapcp.Solver.BranchesLimit">BranchesLimit</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_FIRST_UNBOUND" href="#pywrapcp.Solver.CHOOSE_FIRST_UNBOUND">CHOOSE_FIRST_UNBOUND</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_HIGHEST_MAX" href="#pywrapcp.Solver.CHOOSE_HIGHEST_MAX">CHOOSE_HIGHEST_MAX</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_LOWEST_MIN" href="#pywrapcp.Solver.CHOOSE_LOWEST_MIN">CHOOSE_LOWEST_MIN</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_MAX_REGRET_ON_MIN" href="#pywrapcp.Solver.CHOOSE_MAX_REGRET_ON_MIN">CHOOSE_MAX_REGRET_ON_MIN</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_MAX_SIZE" href="#pywrapcp.Solver.CHOOSE_MAX_SIZE">CHOOSE_MAX_SIZE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_MIN_SIZE" href="#pywrapcp.Solver.CHOOSE_MIN_SIZE">CHOOSE_MIN_SIZE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_MIN_SIZE_HIGHEST_MAX" href="#pywrapcp.Solver.CHOOSE_MIN_SIZE_HIGHEST_MAX">CHOOSE_MIN_SIZE_HIGHEST_MAX</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_MIN_SIZE_HIGHEST_MIN" href="#pywrapcp.Solver.CHOOSE_MIN_SIZE_HIGHEST_MIN">CHOOSE_MIN_SIZE_HIGHEST_MIN</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_MIN_SIZE_LOWEST_MAX" href="#pywrapcp.Solver.CHOOSE_MIN_SIZE_LOWEST_MAX">CHOOSE_MIN_SIZE_LOWEST_MAX</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_MIN_SIZE_LOWEST_MIN" href="#pywrapcp.Solver.CHOOSE_MIN_SIZE_LOWEST_MIN">CHOOSE_MIN_SIZE_LOWEST_MIN</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_MIN_SLACK_RANK_FORWARD" href="#pywrapcp.Solver.CHOOSE_MIN_SLACK_RANK_FORWARD">CHOOSE_MIN_SLACK_RANK_FORWARD</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_PATH" href="#pywrapcp.Solver.CHOOSE_PATH">CHOOSE_PATH</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_RANDOM" href="#pywrapcp.Solver.CHOOSE_RANDOM">CHOOSE_RANDOM</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CHOOSE_RANDOM_RANK_FORWARD" href="#pywrapcp.Solver.CHOOSE_RANDOM_RANK_FORWARD">CHOOSE_RANDOM_RANK_FORWARD</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CROSS" href="#pywrapcp.Solver.CROSS">CROSS</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CheckAssignment" href="#pywrapcp.Solver.CheckAssignment">CheckAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CheckConstraint" href="#pywrapcp.Solver.CheckConstraint">CheckConstraint</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Circuit" href="#pywrapcp.Solver.Circuit">Circuit</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ClosureDemon" href="#pywrapcp.Solver.ClosureDemon">ClosureDemon</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Compose" href="#pywrapcp.Solver.Compose">Compose</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ConcatenateOperators" href="#pywrapcp.Solver.ConcatenateOperators">ConcatenateOperators</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ConditionalExpression" href="#pywrapcp.Solver.ConditionalExpression">ConditionalExpression</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ConstantRestart" href="#pywrapcp.Solver.ConstantRestart">ConstantRestart</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ConstraintAdder" href="#pywrapcp.Solver.ConstraintAdder">ConstraintAdder</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ConstraintInitialPropagateCallback" href="#pywrapcp.Solver.ConstraintInitialPropagateCallback">ConstraintInitialPropagateCallback</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Constraints" href="#pywrapcp.Solver.Constraints">Constraints</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ConvexPiecewiseExpr" href="#pywrapcp.Solver.ConvexPiecewiseExpr">ConvexPiecewiseExpr</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Count" href="#pywrapcp.Solver.Count">Count</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Cover" href="#pywrapcp.Solver.Cover">Cover</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Cumulative" href="#pywrapcp.Solver.Cumulative">Cumulative</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.CustomLimit" href="#pywrapcp.Solver.CustomLimit">CustomLimit</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.DECREMENT" href="#pywrapcp.Solver.DECREMENT">DECREMENT</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.DELAYED_PRIORITY" href="#pywrapcp.Solver.DELAYED_PRIORITY">DELAYED_PRIORITY</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Decision" href="#pywrapcp.Solver.Decision">Decision</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.DecisionBuilderFromAssignment" href="#pywrapcp.Solver.DecisionBuilderFromAssignment">DecisionBuilderFromAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.DefaultPhase" href="#pywrapcp.Solver.DefaultPhase">DefaultPhase</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.DefaultSolverParameters" href="#pywrapcp.Solver.DefaultSolverParameters">DefaultSolverParameters</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.DelayedConstraintInitialPropagateCallback" href="#pywrapcp.Solver.DelayedConstraintInitialPropagateCallback">DelayedConstraintInitialPropagateCallback</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.DelayedPathCumul" href="#pywrapcp.Solver.DelayedPathCumul">DelayedPathCumul</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Deviation" href="#pywrapcp.Solver.Deviation">Deviation</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.DisjunctiveConstraint" href="#pywrapcp.Solver.DisjunctiveConstraint">DisjunctiveConstraint</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Distribute" href="#pywrapcp.Solver.Distribute">Distribute</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.EQ" href="#pywrapcp.Solver.EQ">EQ</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.EXCHANGE" href="#pywrapcp.Solver.EXCHANGE">EXCHANGE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.EXTENDEDSWAPACTIVE" href="#pywrapcp.Solver.EXTENDEDSWAPACTIVE">EXTENDEDSWAPACTIVE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Element" href="#pywrapcp.Solver.Element">Element</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ElementEquality" href="#pywrapcp.Solver.ElementEquality">ElementEquality</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ElementFunction" href="#pywrapcp.Solver.ElementFunction">ElementFunction</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.EndSearch" href="#pywrapcp.Solver.EndSearch">EndSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.EvalEvalStrPhase" href="#pywrapcp.Solver.EvalEvalStrPhase">EvalEvalStrPhase</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.EvalEvalStrTieBreakPhase" href="#pywrapcp.Solver.EvalEvalStrTieBreakPhase">EvalEvalStrTieBreakPhase</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.FULLPATHLNS" href="#pywrapcp.Solver.FULLPATHLNS">FULLPATHLNS</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Fail" href="#pywrapcp.Solver.Fail">Fail</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.FailDecision" href="#pywrapcp.Solver.FailDecision">FailDecision</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.FailStamp" href="#pywrapcp.Solver.FailStamp">FailStamp</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Failures" href="#pywrapcp.Solver.Failures">Failures</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.FailuresLimit" href="#pywrapcp.Solver.FailuresLimit">FailuresLimit</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.FalseConstraint" href="#pywrapcp.Solver.FalseConstraint">FalseConstraint</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.FinishCurrentSearch" href="#pywrapcp.Solver.FinishCurrentSearch">FinishCurrentSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.FirstSolutionCollector" href="#pywrapcp.Solver.FirstSolutionCollector">FirstSolutionCollector</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.FixedDurationEndSyncedOnEndIntervalVar" href="#pywrapcp.Solver.FixedDurationEndSyncedOnEndIntervalVar">FixedDurationEndSyncedOnEndIntervalVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.FixedDurationEndSyncedOnStartIntervalVar" href="#pywrapcp.Solver.FixedDurationEndSyncedOnStartIntervalVar">FixedDurationEndSyncedOnStartIntervalVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.FixedDurationIntervalVar" href="#pywrapcp.Solver.FixedDurationIntervalVar">FixedDurationIntervalVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.FixedDurationStartSyncedOnEndIntervalVar" href="#pywrapcp.Solver.FixedDurationStartSyncedOnEndIntervalVar">FixedDurationStartSyncedOnEndIntervalVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.FixedDurationStartSyncedOnStartIntervalVar" href="#pywrapcp.Solver.FixedDurationStartSyncedOnStartIntervalVar">FixedDurationStartSyncedOnStartIntervalVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.FixedInterval" href="#pywrapcp.Solver.FixedInterval">FixedInterval</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.GE" href="#pywrapcp.Solver.GE">GE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.GuidedLocalSearch" href="#pywrapcp.Solver.GuidedLocalSearch">GuidedLocalSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.INCREMENT" href="#pywrapcp.Solver.INCREMENT">INCREMENT</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.INTERVAL_DEFAULT" href="#pywrapcp.Solver.INTERVAL_DEFAULT">INTERVAL_DEFAULT</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.INTERVAL_SET_TIMES_BACKWARD" href="#pywrapcp.Solver.INTERVAL_SET_TIMES_BACKWARD">INTERVAL_SET_TIMES_BACKWARD</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.INTERVAL_SET_TIMES_FORWARD" href="#pywrapcp.Solver.INTERVAL_SET_TIMES_FORWARD">INTERVAL_SET_TIMES_FORWARD</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.INTERVAL_SIMPLE" href="#pywrapcp.Solver.INTERVAL_SIMPLE">INTERVAL_SIMPLE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.INT_VALUE_DEFAULT" href="#pywrapcp.Solver.INT_VALUE_DEFAULT">INT_VALUE_DEFAULT</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.INT_VALUE_SIMPLE" href="#pywrapcp.Solver.INT_VALUE_SIMPLE">INT_VALUE_SIMPLE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.INT_VAR_DEFAULT" href="#pywrapcp.Solver.INT_VAR_DEFAULT">INT_VAR_DEFAULT</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.INT_VAR_SIMPLE" href="#pywrapcp.Solver.INT_VAR_SIMPLE">INT_VAR_SIMPLE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IndexExpression" href="#pywrapcp.Solver.IndexExpression">IndexExpression</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IndexOfConstraint" href="#pywrapcp.Solver.IndexOfConstraint">IndexOfConstraint</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IntConst" href="#pywrapcp.Solver.IntConst">IntConst</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IntVar" href="#pywrapcp.Solver.IntVar">IntVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IntervalRelaxedMax" href="#pywrapcp.Solver.IntervalRelaxedMax">IntervalRelaxedMax</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IntervalRelaxedMin" href="#pywrapcp.Solver.IntervalRelaxedMin">IntervalRelaxedMin</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IntervalVar" href="#pywrapcp.Solver.IntervalVar">IntervalVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.InversePermutationConstraint" href="#pywrapcp.Solver.InversePermutationConstraint">InversePermutationConstraint</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsBetweenCt" href="#pywrapcp.Solver.IsBetweenCt">IsBetweenCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsBetweenVar" href="#pywrapcp.Solver.IsBetweenVar">IsBetweenVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsDifferentCstCt" href="#pywrapcp.Solver.IsDifferentCstCt">IsDifferentCstCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsDifferentCstVar" href="#pywrapcp.Solver.IsDifferentCstVar">IsDifferentCstVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsDifferentCt" href="#pywrapcp.Solver.IsDifferentCt">IsDifferentCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsDifferentVar" href="#pywrapcp.Solver.IsDifferentVar">IsDifferentVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsEqualCstCt" href="#pywrapcp.Solver.IsEqualCstCt">IsEqualCstCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsEqualCstVar" href="#pywrapcp.Solver.IsEqualCstVar">IsEqualCstVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsEqualCt" href="#pywrapcp.Solver.IsEqualCt">IsEqualCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsEqualVar" href="#pywrapcp.Solver.IsEqualVar">IsEqualVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsGreaterCstCt" href="#pywrapcp.Solver.IsGreaterCstCt">IsGreaterCstCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsGreaterCstVar" href="#pywrapcp.Solver.IsGreaterCstVar">IsGreaterCstVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsGreaterCt" href="#pywrapcp.Solver.IsGreaterCt">IsGreaterCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsGreaterOrEqualCstCt" href="#pywrapcp.Solver.IsGreaterOrEqualCstCt">IsGreaterOrEqualCstCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsGreaterOrEqualCstVar" href="#pywrapcp.Solver.IsGreaterOrEqualCstVar">IsGreaterOrEqualCstVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsGreaterOrEqualCt" href="#pywrapcp.Solver.IsGreaterOrEqualCt">IsGreaterOrEqualCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsGreaterOrEqualVar" href="#pywrapcp.Solver.IsGreaterOrEqualVar">IsGreaterOrEqualVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsGreaterVar" href="#pywrapcp.Solver.IsGreaterVar">IsGreaterVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsLessCstCt" href="#pywrapcp.Solver.IsLessCstCt">IsLessCstCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsLessCstVar" href="#pywrapcp.Solver.IsLessCstVar">IsLessCstVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsLessCt" href="#pywrapcp.Solver.IsLessCt">IsLessCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsLessOrEqualCstCt" href="#pywrapcp.Solver.IsLessOrEqualCstCt">IsLessOrEqualCstCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsLessOrEqualCstVar" href="#pywrapcp.Solver.IsLessOrEqualCstVar">IsLessOrEqualCstVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsLessOrEqualCt" href="#pywrapcp.Solver.IsLessOrEqualCt">IsLessOrEqualCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsLessOrEqualVar" href="#pywrapcp.Solver.IsLessOrEqualVar">IsLessOrEqualVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsLessVar" href="#pywrapcp.Solver.IsLessVar">IsLessVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsMemberCt" href="#pywrapcp.Solver.IsMemberCt">IsMemberCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.IsMemberVar" href="#pywrapcp.Solver.IsMemberVar">IsMemberVar</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.LE" href="#pywrapcp.Solver.LE">LE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.LastSolutionCollector" href="#pywrapcp.Solver.LastSolutionCollector">LastSolutionCollector</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.LexicalLess" href="#pywrapcp.Solver.LexicalLess">LexicalLess</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.LexicalLessOrEqual" href="#pywrapcp.Solver.LexicalLessOrEqual">LexicalLessOrEqual</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Limit" href="#pywrapcp.Solver.Limit">Limit</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.LocalSearchPhase" href="#pywrapcp.Solver.LocalSearchPhase">LocalSearchPhase</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.LocalSearchPhaseParameters" href="#pywrapcp.Solver.LocalSearchPhaseParameters">LocalSearchPhaseParameters</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.LocalSearchProfile" href="#pywrapcp.Solver.LocalSearchProfile">LocalSearchProfile</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.LubyRestart" href="#pywrapcp.Solver.LubyRestart">LubyRestart</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.MAKEACTIVE" href="#pywrapcp.Solver.MAKEACTIVE">MAKEACTIVE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.MAKECHAININACTIVE" href="#pywrapcp.Solver.MAKECHAININACTIVE">MAKECHAININACTIVE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.MAKEINACTIVE" href="#pywrapcp.Solver.MAKEINACTIVE">MAKEINACTIVE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Max" href="#pywrapcp.Solver.Max">Max</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.MaxEquality" href="#pywrapcp.Solver.MaxEquality">MaxEquality</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Maximize" href="#pywrapcp.Solver.Maximize">Maximize</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.MemberCt" href="#pywrapcp.Solver.MemberCt">MemberCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.MemoryUsage" href="#pywrapcp.Solver.MemoryUsage">MemoryUsage</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Min" href="#pywrapcp.Solver.Min">Min</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.MinEquality" href="#pywrapcp.Solver.MinEquality">MinEquality</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Minimize" href="#pywrapcp.Solver.Minimize">Minimize</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.MirrorInterval" href="#pywrapcp.Solver.MirrorInterval">MirrorInterval</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.MonotonicElement" href="#pywrapcp.Solver.MonotonicElement">MonotonicElement</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.MoveTowardTargetOperator" href="#pywrapcp.Solver.MoveTowardTargetOperator">MoveTowardTargetOperator</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.NORMAL_PRIORITY" href="#pywrapcp.Solver.NORMAL_PRIORITY">NORMAL_PRIORITY</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.NeighborhoodLimit" href="#pywrapcp.Solver.NeighborhoodLimit">NeighborhoodLimit</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.NestedOptimize" href="#pywrapcp.Solver.NestedOptimize">NestedOptimize</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.NewSearch" href="#pywrapcp.Solver.NewSearch">NewSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.NextSolution" href="#pywrapcp.Solver.NextSolution">NextSolution</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.NonOverlappingBoxesConstraint" href="#pywrapcp.Solver.NonOverlappingBoxesConstraint">NonOverlappingBoxesConstraint</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.NotMemberCt" href="#pywrapcp.Solver.NotMemberCt">NotMemberCt</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.NullIntersect" href="#pywrapcp.Solver.NullIntersect">NullIntersect</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.NullIntersectExcept" href="#pywrapcp.Solver.NullIntersectExcept">NullIntersectExcept</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.OROPT" href="#pywrapcp.Solver.OROPT">OROPT</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Operator" href="#pywrapcp.Solver.Operator">Operator</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Optimize" href="#pywrapcp.Solver.Optimize">Optimize</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.PATHLNS" href="#pywrapcp.Solver.PATHLNS">PATHLNS</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Pack" href="#pywrapcp.Solver.Pack">Pack</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Parameters" href="#pywrapcp.Solver.Parameters">Parameters</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.PathCumul" href="#pywrapcp.Solver.PathCumul">PathCumul</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Phase" href="#pywrapcp.Solver.Phase">Phase</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.PrintModelVisitor" href="#pywrapcp.Solver.PrintModelVisitor">PrintModelVisitor</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.RELOCATE" href="#pywrapcp.Solver.RELOCATE">RELOCATE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Rand32" href="#pywrapcp.Solver.Rand32">Rand32</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Rand64" href="#pywrapcp.Solver.Rand64">Rand64</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.RandomConcatenateOperators" href="#pywrapcp.Solver.RandomConcatenateOperators">RandomConcatenateOperators</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.RandomLnsOperator" href="#pywrapcp.Solver.RandomLnsOperator">RandomLnsOperator</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.RankFirstInterval" href="#pywrapcp.Solver.RankFirstInterval">RankFirstInterval</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.RankLastInterval" href="#pywrapcp.Solver.RankLastInterval">RankLastInterval</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ReSeed" href="#pywrapcp.Solver.ReSeed">ReSeed</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.RestartCurrentSearch" href="#pywrapcp.Solver.RestartCurrentSearch">RestartCurrentSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.RestartSearch" href="#pywrapcp.Solver.RestartSearch">RestartSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.RestoreAssignment" href="#pywrapcp.Solver.RestoreAssignment">RestoreAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SEQUENCE_DEFAULT" href="#pywrapcp.Solver.SEQUENCE_DEFAULT">SEQUENCE_DEFAULT</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SEQUENCE_SIMPLE" href="#pywrapcp.Solver.SEQUENCE_SIMPLE">SEQUENCE_SIMPLE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SIMPLELNS" href="#pywrapcp.Solver.SIMPLELNS">SIMPLELNS</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SPLIT_LOWER_HALF" href="#pywrapcp.Solver.SPLIT_LOWER_HALF">SPLIT_LOWER_HALF</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SPLIT_UPPER_HALF" href="#pywrapcp.Solver.SPLIT_UPPER_HALF">SPLIT_UPPER_HALF</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SWAPACTIVE" href="#pywrapcp.Solver.SWAPACTIVE">SWAPACTIVE</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ScalProd" href="#pywrapcp.Solver.ScalProd">ScalProd</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ScalProdEquality" href="#pywrapcp.Solver.ScalProdEquality">ScalProdEquality</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ScalProdGreaterOrEqual" href="#pywrapcp.Solver.ScalProdGreaterOrEqual">ScalProdGreaterOrEqual</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ScalProdLessOrEqual" href="#pywrapcp.Solver.ScalProdLessOrEqual">ScalProdLessOrEqual</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ScheduleOrExpedite" href="#pywrapcp.Solver.ScheduleOrExpedite">ScheduleOrExpedite</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ScheduleOrPostpone" href="#pywrapcp.Solver.ScheduleOrPostpone">ScheduleOrPostpone</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SearchDepth" href="#pywrapcp.Solver.SearchDepth">SearchDepth</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SearchLeftDepth" href="#pywrapcp.Solver.SearchLeftDepth">SearchLeftDepth</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SearchLog" href="#pywrapcp.Solver.SearchLog">SearchLog</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SearchLogWithCallback" href="#pywrapcp.Solver.SearchLogWithCallback">SearchLogWithCallback</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SearchTrace" href="#pywrapcp.Solver.SearchTrace">SearchTrace</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SemiContinuousExpr" href="#pywrapcp.Solver.SemiContinuousExpr">SemiContinuousExpr</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.ShouldFail" href="#pywrapcp.Solver.ShouldFail">ShouldFail</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SimulatedAnnealing" href="#pywrapcp.Solver.SimulatedAnnealing">SimulatedAnnealing</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Solutions" href="#pywrapcp.Solver.Solutions">Solutions</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SolutionsLimit" href="#pywrapcp.Solver.SolutionsLimit">SolutionsLimit</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Solve" href="#pywrapcp.Solver.Solve">Solve</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SolveAndCommit" href="#pywrapcp.Solver.SolveAndCommit">SolveAndCommit</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SolveDepth" href="#pywrapcp.Solver.SolveDepth">SolveDepth</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SolveOnce" href="#pywrapcp.Solver.SolveOnce">SolveOnce</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SortingConstraint" href="#pywrapcp.Solver.SortingConstraint">SortingConstraint</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SplitVariableDomain" href="#pywrapcp.Solver.SplitVariableDomain">SplitVariableDomain</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Stamp" href="#pywrapcp.Solver.Stamp">Stamp</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.StatisticsModelVisitor" href="#pywrapcp.Solver.StatisticsModelVisitor">StatisticsModelVisitor</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.StoreAssignment" href="#pywrapcp.Solver.StoreAssignment">StoreAssignment</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SubCircuit" href="#pywrapcp.Solver.SubCircuit">SubCircuit</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Sum" href="#pywrapcp.Solver.Sum">Sum</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SumEquality" href="#pywrapcp.Solver.SumEquality">SumEquality</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SumGreaterOrEqual" href="#pywrapcp.Solver.SumGreaterOrEqual">SumGreaterOrEqual</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SumLessOrEqual" href="#pywrapcp.Solver.SumLessOrEqual">SumLessOrEqual</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.SumObjectiveFilter" href="#pywrapcp.Solver.SumObjectiveFilter">SumObjectiveFilter</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.TWOOPT" href="#pywrapcp.Solver.TWOOPT">TWOOPT</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.TabuSearch" href="#pywrapcp.Solver.TabuSearch">TabuSearch</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.TemporalDisjunction" href="#pywrapcp.Solver.TemporalDisjunction">TemporalDisjunction</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.TimeLimit" href="#pywrapcp.Solver.TimeLimit">TimeLimit</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.TransitionConstraint" href="#pywrapcp.Solver.TransitionConstraint">TransitionConstraint</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.TreeNoCycle" href="#pywrapcp.Solver.TreeNoCycle">TreeNoCycle</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.TrueConstraint" href="#pywrapcp.Solver.TrueConstraint">TrueConstraint</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.Try" href="#pywrapcp.Solver.Try">Try</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.UNACTIVELNS" href="#pywrapcp.Solver.UNACTIVELNS">UNACTIVELNS</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.VAR_PRIORITY" href="#pywrapcp.Solver.VAR_PRIORITY">VAR_PRIORITY</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.VarEvalValEvalPhase" href="#pywrapcp.Solver.VarEvalValEvalPhase">VarEvalValEvalPhase</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.VarEvalValEvalTieBreakPhase" href="#pywrapcp.Solver.VarEvalValEvalTieBreakPhase">VarEvalValEvalTieBreakPhase</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.VarEvalValStrPhase" href="#pywrapcp.Solver.VarEvalValStrPhase">VarEvalValStrPhase</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.VarStrValEvalPhase" href="#pywrapcp.Solver.VarStrValEvalPhase">VarStrValEvalPhase</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.VarStrValEvalTieBreakPhase" href="#pywrapcp.Solver.VarStrValEvalTieBreakPhase">VarStrValEvalTieBreakPhase</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.VariableGreaterOrEqualValue" href="#pywrapcp.Solver.VariableGreaterOrEqualValue">VariableGreaterOrEqualValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.VariableLessOrEqualValue" href="#pywrapcp.Solver.VariableLessOrEqualValue">VariableLessOrEqualValue</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.WallTime" href="#pywrapcp.Solver.WallTime">WallTime</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.WeightedMaximize" href="#pywrapcp.Solver.WeightedMaximize">WeightedMaximize</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.WeightedMinimize" href="#pywrapcp.Solver.WeightedMinimize">WeightedMinimize</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.WeightedOptimize" href="#pywrapcp.Solver.WeightedOptimize">WeightedOptimize</a></code></li>
|
|
<li><code><a title="pywrapcp.Solver.thisown" href="#pywrapcp.Solver.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.TypeIncompatibilityChecker" href="#pywrapcp.TypeIncompatibilityChecker">TypeIncompatibilityChecker</a></code></h4>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.TypeRegulationsChecker" href="#pywrapcp.TypeRegulationsChecker">TypeRegulationsChecker</a></code></h4>
|
|
<ul class="">
|
|
<li><code><a title="pywrapcp.TypeRegulationsChecker.CheckVehicle" href="#pywrapcp.TypeRegulationsChecker.CheckVehicle">CheckVehicle</a></code></li>
|
|
<li><code><a title="pywrapcp.TypeRegulationsChecker.thisown" href="#pywrapcp.TypeRegulationsChecker.thisown">thisown</a></code></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.TypeRegulationsConstraint" href="#pywrapcp.TypeRegulationsConstraint">TypeRegulationsConstraint</a></code></h4>
|
|
</li>
|
|
<li>
|
|
<h4><code><a title="pywrapcp.TypeRequirementChecker" href="#pywrapcp.TypeRequirementChecker">TypeRequirementChecker</a></code></h4>
|
|
</li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</nav>
|
|
</main>
|
|
<footer id="footer">
|
|
<p><span style="color:#ddd">卐</span></p>
|
|
<p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.6.2</a>.</p>
|
|
</footer>
|
|
<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
|
|
<script>hljs.initHighlightingOnLoad()</script>
|
|
</body>
|
|
</html> |