ortools.constraint_solver.pywrapcp
1# This file was automatically generated by SWIG (https://www.swig.org). 2# Version 4.2.0 3# 4# Do not make changes to this file unless you know what you are doing - modify 5# the SWIG interface file instead. 6 7from sys import version_info as _swig_python_version_info 8# Import the low-level C/C++ module 9if __package__ or "." in __name__: 10 from . import _pywrapcp 11else: 12 import _pywrapcp 13 14try: 15 import builtins as __builtin__ 16except ImportError: 17 import __builtin__ 18 19def _swig_repr(self): 20 try: 21 strthis = "proxy of " + self.this.__repr__() 22 except __builtin__.Exception: 23 strthis = "" 24 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) 25 26 27def _swig_setattr_nondynamic_instance_variable(set): 28 def set_instance_attr(self, name, value): 29 if name == "this": 30 set(self, name, value) 31 elif name == "thisown": 32 self.this.own(value) 33 elif hasattr(self, name) and isinstance(getattr(type(self), name), property): 34 set(self, name, value) 35 else: 36 raise AttributeError("You cannot add instance attributes to %s" % self) 37 return set_instance_attr 38 39 40def _swig_setattr_nondynamic_class_variable(set): 41 def set_class_attr(cls, name, value): 42 if hasattr(cls, name) and not isinstance(getattr(cls, name), property): 43 set(cls, name, value) 44 else: 45 raise AttributeError("You cannot add class attributes to %s" % cls) 46 return set_class_attr 47 48 49def _swig_add_metaclass(metaclass): 50 """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass""" 51 def wrapper(cls): 52 return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy()) 53 return wrapper 54 55 56class _SwigNonDynamicMeta(type): 57 """Meta class to enforce nondynamic attributes (no new attributes) for a class""" 58 __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__) 59 60 61import weakref 62 63class DefaultPhaseParameters(object): 64 r""" 65 This struct holds all parameters for the default search. 66 DefaultPhaseParameters is only used by Solver::MakeDefaultPhase methods. 67 Note this is for advanced users only. 68 """ 69 70 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 71 __repr__ = _swig_repr 72 CHOOSE_MAX_SUM_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_SUM_IMPACT 73 CHOOSE_MAX_AVERAGE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_AVERAGE_IMPACT 74 CHOOSE_MAX_VALUE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_VALUE_IMPACT 75 SELECT_MIN_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MIN_IMPACT 76 SELECT_MAX_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MAX_IMPACT 77 NONE = _pywrapcp.DefaultPhaseParameters_NONE 78 NORMAL = _pywrapcp.DefaultPhaseParameters_NORMAL 79 VERBOSE = _pywrapcp.DefaultPhaseParameters_VERBOSE 80 var_selection_schema = property(_pywrapcp.DefaultPhaseParameters_var_selection_schema_get, _pywrapcp.DefaultPhaseParameters_var_selection_schema_set, doc=r""" 81 This parameter describes how the next variable to instantiate 82 will be chosen. 83 """) 84 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.""") 85 initialization_splits = property(_pywrapcp.DefaultPhaseParameters_initialization_splits_get, _pywrapcp.DefaultPhaseParameters_initialization_splits_set, doc=r""" 86 Maximum number of intervals that the initialization of impacts will scan 87 per variable. 88 """) 89 run_all_heuristics = property(_pywrapcp.DefaultPhaseParameters_run_all_heuristics_get, _pywrapcp.DefaultPhaseParameters_run_all_heuristics_set, doc=r""" 90 The default phase will run heuristics periodically. This parameter 91 indicates if we should run all heuristics, or a randomly selected 92 one. 93 """) 94 heuristic_period = property(_pywrapcp.DefaultPhaseParameters_heuristic_period_get, _pywrapcp.DefaultPhaseParameters_heuristic_period_set, doc=r""" 95 The distance in nodes between each run of the heuristics. A 96 negative or null value will mean that we will not run heuristics 97 at all. 98 """) 99 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.""") 100 persistent_impact = property(_pywrapcp.DefaultPhaseParameters_persistent_impact_get, _pywrapcp.DefaultPhaseParameters_persistent_impact_set, doc=r""" 101 Whether to keep the impact from the first search for other searches, 102 or to recompute the impact for each new search. 103 """) 104 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.""") 105 display_level = property(_pywrapcp.DefaultPhaseParameters_display_level_get, _pywrapcp.DefaultPhaseParameters_display_level_set, doc=r""" 106 This represents the amount of information displayed by the default search. 107 NONE means no display, VERBOSE means extra information. 108 """) 109 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.""") 110 111 def __init__(self): 112 _pywrapcp.DefaultPhaseParameters_swiginit(self, _pywrapcp.new_DefaultPhaseParameters()) 113 __swig_destroy__ = _pywrapcp.delete_DefaultPhaseParameters 114 115# Register DefaultPhaseParameters in _pywrapcp: 116_pywrapcp.DefaultPhaseParameters_swigregister(DefaultPhaseParameters) 117class Solver(object): 118 r""" 119 Solver Class 120 121 A solver represents the main computation engine. It implements the entire 122 range of Constraint Programming protocols: 123 - Reversibility 124 - Propagation 125 - Search 126 127 Usually, Constraint Programming code consists of 128 - the creation of the Solver, 129 - the creation of the decision variables of the model, 130 - the creation of the constraints of the model and their addition to the 131 solver() through the AddConstraint() method, 132 - the creation of the main DecisionBuilder class, 133 - the launch of the solve() method with the decision builder. 134 135 For the time being, Solver is neither MT_SAFE nor MT_HOT. 136 """ 137 138 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 139 __repr__ = _swig_repr 140 INT_VAR_DEFAULT = _pywrapcp.Solver_INT_VAR_DEFAULT 141 r""" The default behavior is CHOOSE_FIRST_UNBOUND.""" 142 INT_VAR_SIMPLE = _pywrapcp.Solver_INT_VAR_SIMPLE 143 r""" The simple selection is CHOOSE_FIRST_UNBOUND.""" 144 CHOOSE_FIRST_UNBOUND = _pywrapcp.Solver_CHOOSE_FIRST_UNBOUND 145 r""" 146 Select the first unbound variable. 147 Variables are considered in the order of the vector of IntVars used 148 to create the selector. 149 """ 150 CHOOSE_RANDOM = _pywrapcp.Solver_CHOOSE_RANDOM 151 r""" Randomly select one of the remaining unbound variables.""" 152 CHOOSE_MIN_SIZE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MIN 153 r""" 154 Among unbound variables, select the variable with the smallest size, 155 i.e., the smallest number of possible values. 156 In case of a tie, the selected variables is the one with the lowest min 157 value. 158 In case of a tie, the first one is selected, first being defined by the 159 order in the vector of IntVars used to create the selector. 160 """ 161 CHOOSE_MIN_SIZE_HIGHEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MIN 162 r""" 163 Among unbound variables, select the variable with the smallest size, 164 i.e., the smallest number of possible values. 165 In case of a tie, the selected variable is the one with the highest min 166 value. 167 In case of a tie, the first one is selected, first being defined by the 168 order in the vector of IntVars used to create the selector. 169 """ 170 CHOOSE_MIN_SIZE_LOWEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MAX 171 r""" 172 Among unbound variables, select the variable with the smallest size, 173 i.e., the smallest number of possible values. 174 In case of a tie, the selected variables is the one with the lowest max 175 value. 176 In case of a tie, the first one is selected, first being defined by the 177 order in the vector of IntVars used to create the selector. 178 """ 179 CHOOSE_MIN_SIZE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MAX 180 r""" 181 Among unbound variables, select the variable with the smallest size, 182 i.e., the smallest number of possible values. 183 In case of a tie, the selected variable is the one with the highest max 184 value. 185 In case of a tie, the first one is selected, first being defined by the 186 order in the vector of IntVars used to create the selector. 187 """ 188 CHOOSE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_LOWEST_MIN 189 r""" 190 Among unbound variables, select the variable with the smallest minimal 191 value. 192 In case of a tie, the first one is selected, "first" defined by the 193 order in the vector of IntVars used to create the selector. 194 """ 195 CHOOSE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_HIGHEST_MAX 196 r""" 197 Among unbound variables, select the variable with the highest maximal 198 value. 199 In case of a tie, the first one is selected, first being defined by the 200 order in the vector of IntVars used to create the selector. 201 """ 202 CHOOSE_MIN_SIZE = _pywrapcp.Solver_CHOOSE_MIN_SIZE 203 r""" 204 Among unbound variables, select the variable with the smallest size. 205 In case of a tie, the first one is selected, first being defined by the 206 order in the vector of IntVars used to create the selector. 207 """ 208 CHOOSE_MAX_SIZE = _pywrapcp.Solver_CHOOSE_MAX_SIZE 209 r""" 210 Among unbound variables, select the variable with the highest size. 211 In case of a tie, the first one is selected, first being defined by the 212 order in the vector of IntVars used to create the selector. 213 """ 214 CHOOSE_MAX_REGRET_ON_MIN = _pywrapcp.Solver_CHOOSE_MAX_REGRET_ON_MIN 215 r""" 216 Among unbound variables, select the variable with the largest 217 gap between the first and the second values of the domain. 218 """ 219 CHOOSE_PATH = _pywrapcp.Solver_CHOOSE_PATH 220 r""" 221 Selects the next unbound variable on a path, the path being defined by 222 the variables: var[i] corresponds to the index of the next of i. 223 """ 224 INT_VALUE_DEFAULT = _pywrapcp.Solver_INT_VALUE_DEFAULT 225 r""" The default behavior is ASSIGN_MIN_VALUE.""" 226 INT_VALUE_SIMPLE = _pywrapcp.Solver_INT_VALUE_SIMPLE 227 r""" The simple selection is ASSIGN_MIN_VALUE.""" 228 ASSIGN_MIN_VALUE = _pywrapcp.Solver_ASSIGN_MIN_VALUE 229 r""" Selects the min value of the selected variable.""" 230 ASSIGN_MAX_VALUE = _pywrapcp.Solver_ASSIGN_MAX_VALUE 231 r""" Selects the max value of the selected variable.""" 232 ASSIGN_RANDOM_VALUE = _pywrapcp.Solver_ASSIGN_RANDOM_VALUE 233 r""" Selects randomly one of the possible values of the selected variable.""" 234 ASSIGN_CENTER_VALUE = _pywrapcp.Solver_ASSIGN_CENTER_VALUE 235 r""" 236 Selects the first possible value which is the closest to the center 237 of the domain of the selected variable. 238 The center is defined as (min + max) / 2. 239 """ 240 SPLIT_LOWER_HALF = _pywrapcp.Solver_SPLIT_LOWER_HALF 241 r""" 242 Split the domain in two around the center, and choose the lower 243 part first. 244 """ 245 SPLIT_UPPER_HALF = _pywrapcp.Solver_SPLIT_UPPER_HALF 246 r""" 247 Split the domain in two around the center, and choose the lower 248 part first. 249 """ 250 SEQUENCE_DEFAULT = _pywrapcp.Solver_SEQUENCE_DEFAULT 251 SEQUENCE_SIMPLE = _pywrapcp.Solver_SEQUENCE_SIMPLE 252 CHOOSE_MIN_SLACK_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_MIN_SLACK_RANK_FORWARD 253 CHOOSE_RANDOM_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_RANDOM_RANK_FORWARD 254 INTERVAL_DEFAULT = _pywrapcp.Solver_INTERVAL_DEFAULT 255 r""" The default is INTERVAL_SET_TIMES_FORWARD.""" 256 INTERVAL_SIMPLE = _pywrapcp.Solver_INTERVAL_SIMPLE 257 r""" The simple is INTERVAL_SET_TIMES_FORWARD.""" 258 INTERVAL_SET_TIMES_FORWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_FORWARD 259 r""" 260 Selects the variable with the lowest starting time of all variables, 261 and fixes its starting time to this lowest value. 262 """ 263 INTERVAL_SET_TIMES_BACKWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_BACKWARD 264 r""" 265 Selects the variable with the highest ending time of all variables, 266 and fixes the ending time to this highest values. 267 """ 268 TWOOPT = _pywrapcp.Solver_TWOOPT 269 r""" 270 Operator which reverses a sub-chain of a path. It is called TwoOpt 271 because it breaks two arcs on the path; resulting paths are called 272 two-optimal. 273 Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 274 (where (1, 5) are first and last nodes of the path and can therefore not 275 be moved): 276 1 -> [3 -> 2] -> 4 -> 5 277 1 -> [4 -> 3 -> 2] -> 5 278 1 -> 2 -> [4 -> 3] -> 5 279 """ 280 OROPT = _pywrapcp.Solver_OROPT 281 r""" 282 Relocate: OROPT and RELOCATE. 283 Operator which moves a sub-chain of a path to another position; the 284 specified chain length is the fixed length of the chains being moved. 285 When this length is 1, the operator simply moves a node to another 286 position. 287 Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5, for a chain 288 length of 2 (where (1, 5) are first and last nodes of the path and can 289 therefore not be moved): 290 1 -> 4 -> [2 -> 3] -> 5 291 1 -> [3 -> 4] -> 2 -> 5 292 293 Using Relocate with chain lengths of 1, 2 and 3 together is equivalent 294 to the OrOpt operator on a path. The OrOpt operator is a limited 295 version of 3Opt (breaks 3 arcs on a path). 296 """ 297 RELOCATE = _pywrapcp.Solver_RELOCATE 298 r""" Relocate neighborhood with length of 1 (see OROPT comment).""" 299 EXCHANGE = _pywrapcp.Solver_EXCHANGE 300 r""" 301 Operator which exchanges the positions of two nodes. 302 Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 303 (where (1, 5) are first and last nodes of the path and can therefore not 304 be moved): 305 1 -> [3] -> [2] -> 4 -> 5 306 1 -> [4] -> 3 -> [2] -> 5 307 1 -> 2 -> [4] -> [3] -> 5 308 """ 309 CROSS = _pywrapcp.Solver_CROSS 310 r""" 311 Operator which cross exchanges the starting chains of 2 paths, including 312 exchanging the whole paths. 313 First and last nodes are not moved. 314 Possible neighbors for the paths 1 -> 2 -> 3 -> 4 -> 5 and 6 -> 7 -> 8 315 (where (1, 5) and (6, 8) are first and last nodes of the paths and can 316 therefore not be moved): 317 1 -> [7] -> 3 -> 4 -> 5 6 -> [2] -> 8 318 1 -> [7] -> 4 -> 5 6 -> [2 -> 3] -> 8 319 1 -> [7] -> 5 6 -> [2 -> 3 -> 4] -> 8 320 """ 321 MAKEACTIVE = _pywrapcp.Solver_MAKEACTIVE 322 r""" 323 Operator which inserts an inactive node into a path. 324 Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive 325 (where 1 and 4 are first and last nodes of the path) are: 326 1 -> [5] -> 2 -> 3 -> 4 327 1 -> 2 -> [5] -> 3 -> 4 328 1 -> 2 -> 3 -> [5] -> 4 329 """ 330 MAKEINACTIVE = _pywrapcp.Solver_MAKEINACTIVE 331 r""" 332 Operator which makes path nodes inactive. 333 Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are 334 first and last nodes of the path) are: 335 1 -> 3 -> 4 with 2 inactive 336 1 -> 2 -> 4 with 3 inactive 337 """ 338 MAKECHAININACTIVE = _pywrapcp.Solver_MAKECHAININACTIVE 339 r""" 340 Operator which makes a "chain" of path nodes inactive. 341 Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are 342 first and last nodes of the path) are: 343 1 -> 3 -> 4 with 2 inactive 344 1 -> 2 -> 4 with 3 inactive 345 1 -> 4 with 2 and 3 inactive 346 """ 347 SWAPACTIVE = _pywrapcp.Solver_SWAPACTIVE 348 r""" 349 Operator which replaces an active node by an inactive one. 350 Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive 351 (where 1 and 4 are first and last nodes of the path) are: 352 1 -> [5] -> 3 -> 4 with 2 inactive 353 1 -> 2 -> [5] -> 4 with 3 inactive 354 """ 355 EXTENDEDSWAPACTIVE = _pywrapcp.Solver_EXTENDEDSWAPACTIVE 356 r""" 357 Operator which makes an inactive node active and an active one inactive. 358 It is similar to SwapActiveOperator except that it tries to insert the 359 inactive node in all possible positions instead of just the position of 360 the node made inactive. 361 Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive 362 (where 1 and 4 are first and last nodes of the path) are: 363 1 -> [5] -> 3 -> 4 with 2 inactive 364 1 -> 3 -> [5] -> 4 with 2 inactive 365 1 -> [5] -> 2 -> 4 with 3 inactive 366 1 -> 2 -> [5] -> 4 with 3 inactive 367 """ 368 PATHLNS = _pywrapcp.Solver_PATHLNS 369 r""" 370 Operator which relaxes two sub-chains of three consecutive arcs each. 371 Each sub-chain is defined by a start node and the next three arcs. Those 372 six arcs are relaxed to build a new neighbor. 373 PATHLNS explores all possible pairs of starting nodes and so defines 374 n^2 neighbors, n being the number of nodes. 375 Note that the two sub-chains can be part of the same path; they even may 376 overlap. 377 """ 378 FULLPATHLNS = _pywrapcp.Solver_FULLPATHLNS 379 r""" 380 Operator which relaxes one entire path and all inactive nodes, thus 381 defining num_paths neighbors. 382 """ 383 UNACTIVELNS = _pywrapcp.Solver_UNACTIVELNS 384 r""" 385 Operator which relaxes all inactive nodes and one sub-chain of six 386 consecutive arcs. That way the path can be improved by inserting 387 inactive nodes or swapping arcs. 388 """ 389 INCREMENT = _pywrapcp.Solver_INCREMENT 390 r""" 391 Operator which defines one neighbor per variable. Each neighbor tries to 392 increment by one the value of the corresponding variable. When a new 393 solution is found the neighborhood is rebuilt from scratch, i.e., tries 394 to increment values in the variable order. 395 Consider for instance variables x and y. x is incremented one by one to 396 its max, and when it is not possible to increment x anymore, y is 397 incremented once. If this is a solution, then next neighbor tries to 398 increment x. 399 """ 400 DECREMENT = _pywrapcp.Solver_DECREMENT 401 r""" 402 Operator which defines a neighborhood to decrement values. 403 The behavior is the same as INCREMENT, except values are decremented 404 instead of incremented. 405 """ 406 SIMPLELNS = _pywrapcp.Solver_SIMPLELNS 407 r""" 408 Operator which defines one neighbor per variable. Each neighbor relaxes 409 one variable. 410 When a new solution is found the neighborhood is rebuilt from scratch. 411 Consider for instance variables x and y. First x is relaxed and the 412 solver is looking for the best possible solution (with only x relaxed). 413 Then y is relaxed, and the solver is looking for a new solution. 414 If a new solution is found, then the next variable to be relaxed is x. 415 """ 416 GE = _pywrapcp.Solver_GE 417 r""" Move is accepted when the current objective value >= objective.Min.""" 418 LE = _pywrapcp.Solver_LE 419 r""" Move is accepted when the current objective value <= objective.Max.""" 420 EQ = _pywrapcp.Solver_EQ 421 r""" 422 Move is accepted when the current objective value is in the interval 423 objective.Min .. objective.Max. 424 """ 425 DELAYED_PRIORITY = _pywrapcp.Solver_DELAYED_PRIORITY 426 r""" 427 DELAYED_PRIORITY is the lowest priority: Demons will be processed after 428 VAR_PRIORITY and NORMAL_PRIORITY demons. 429 """ 430 VAR_PRIORITY = _pywrapcp.Solver_VAR_PRIORITY 431 r""" VAR_PRIORITY is between DELAYED_PRIORITY and NORMAL_PRIORITY.""" 432 NORMAL_PRIORITY = _pywrapcp.Solver_NORMAL_PRIORITY 433 r""" NORMAL_PRIORITY is the highest priority: Demons will be processed first.""" 434 435 def __init__(self, *args): 436 _pywrapcp.Solver_swiginit(self, _pywrapcp.new_Solver(*args)) 437 438 self.__python_constraints = [] 439 440 441 442 __swig_destroy__ = _pywrapcp.delete_Solver 443 444 def Parameters(self): 445 r""" Stored Parameters.""" 446 return _pywrapcp.Solver_Parameters(self) 447 448 @staticmethod 449 def DefaultSolverParameters(): 450 r""" Create a ConstraintSolverParameters proto with all the default values.""" 451 return _pywrapcp.Solver_DefaultSolverParameters() 452 453 def AddConstraint(self, c): 454 r""" 455 Adds the constraint 'c' to the model. 456 457 After calling this method, and until there is a backtrack that undoes the 458 addition, any assignment of variables to values must satisfy the given 459 constraint in order to be considered feasible. There are two fairly 460 different use cases: 461 462 - the most common use case is modeling: the given constraint is really 463 part of the problem that the user is trying to solve. In this use case, 464 AddConstraint is called outside of search (i.e., with state() == 465 OUTSIDE_SEARCH). Most users should only use AddConstraint in this 466 way. In this case, the constraint will belong to the model forever: it 467 cannot be removed by backtracking. 468 469 - a rarer use case is that 'c' is not a real constraint of the model. It 470 may be a constraint generated by a branching decision (a constraint whose 471 goal is to restrict the search space), a symmetry breaking constraint (a 472 constraint that does restrict the search space, but in a way that cannot 473 have an impact on the quality of the solutions in the subtree), or an 474 inferred constraint that, while having no semantic value to the model (it 475 does not restrict the set of solutions), is worth having because we 476 believe it may strengthen the propagation. In these cases, it happens 477 that the constraint is added during the search (i.e., with state() == 478 IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is 479 added during a search, it applies only to the subtree of the search tree 480 rooted at the current node, and will be automatically removed by 481 backtracking. 482 483 This method does not take ownership of the constraint. If the constraint 484 has been created by any factory method (Solver::MakeXXX), it will 485 automatically be deleted. However, power users who implement their own 486 constraints should do: solver.AddConstraint(solver.RevAlloc(new 487 MyConstraint(...)); 488 """ 489 return _pywrapcp.Solver_AddConstraint(self, c) 490 491 def Solve(self, *args): 492 return _pywrapcp.Solver_Solve(self, *args) 493 494 def NewSearch(self, *args): 495 return _pywrapcp.Solver_NewSearch(self, *args) 496 497 def NextSolution(self): 498 return _pywrapcp.Solver_NextSolution(self) 499 500 def RestartSearch(self): 501 return _pywrapcp.Solver_RestartSearch(self) 502 503 def EndSearch(self): 504 return _pywrapcp.Solver_EndSearch(self) 505 506 def SolveAndCommit(self, *args): 507 return _pywrapcp.Solver_SolveAndCommit(self, *args) 508 509 def CheckAssignment(self, solution): 510 r""" Checks whether the given assignment satisfies all relevant constraints.""" 511 return _pywrapcp.Solver_CheckAssignment(self, solution) 512 513 def CheckConstraint(self, ct): 514 r""" 515 Checks whether adding this constraint will lead to an immediate 516 failure. It will return false if the model is already inconsistent, or if 517 adding the constraint makes it inconsistent. 518 """ 519 return _pywrapcp.Solver_CheckConstraint(self, ct) 520 521 def Fail(self): 522 r""" Abandon the current branch in the search tree. A backtrack will follow.""" 523 return _pywrapcp.Solver_Fail(self) 524 525 @staticmethod 526 def MemoryUsage(): 527 r""" Current memory usage in bytes""" 528 return _pywrapcp.Solver_MemoryUsage() 529 530 def WallTime(self): 531 r""" 532 DEPRECATED: Use Now() instead. 533 Time elapsed, in ms since the creation of the solver. 534 """ 535 return _pywrapcp.Solver_WallTime(self) 536 537 def Branches(self): 538 r""" The number of branches explored since the creation of the solver.""" 539 return _pywrapcp.Solver_Branches(self) 540 541 def Solutions(self): 542 r""" The number of solutions found since the start of the search.""" 543 return _pywrapcp.Solver_Solutions(self) 544 545 def Failures(self): 546 r""" The number of failures encountered since the creation of the solver.""" 547 return _pywrapcp.Solver_Failures(self) 548 549 def AcceptedNeighbors(self): 550 r""" The number of accepted neighbors.""" 551 return _pywrapcp.Solver_AcceptedNeighbors(self) 552 553 def Stamp(self): 554 r""" 555 The stamp indicates how many moves in the search tree we have performed. 556 It is useful to detect if we need to update same lazy structures. 557 """ 558 return _pywrapcp.Solver_Stamp(self) 559 560 def FailStamp(self): 561 r""" The fail_stamp() is incremented after each backtrack.""" 562 return _pywrapcp.Solver_FailStamp(self) 563 564 def IntVar(self, *args): 565 r""" 566 *Overload 1:* 567 MakeIntVar will create the best range based int var for the bounds given. 568 569 | 570 571 *Overload 2:* 572 MakeIntVar will create a variable with the given sparse domain. 573 574 | 575 576 *Overload 3:* 577 MakeIntVar will create a variable with the given sparse domain. 578 579 | 580 581 *Overload 4:* 582 MakeIntVar will create the best range based int var for the bounds given. 583 584 | 585 586 *Overload 5:* 587 MakeIntVar will create a variable with the given sparse domain. 588 589 | 590 591 *Overload 6:* 592 MakeIntVar will create a variable with the given sparse domain. 593 """ 594 return _pywrapcp.Solver_IntVar(self, *args) 595 596 def BoolVar(self, *args): 597 r""" 598 *Overload 1:* 599 MakeBoolVar will create a variable with a {0, 1} domain. 600 601 | 602 603 *Overload 2:* 604 MakeBoolVar will create a variable with a {0, 1} domain. 605 """ 606 return _pywrapcp.Solver_BoolVar(self, *args) 607 608 def IntConst(self, *args): 609 r""" 610 *Overload 1:* 611 IntConst will create a constant expression. 612 613 | 614 615 *Overload 2:* 616 IntConst will create a constant expression. 617 """ 618 return _pywrapcp.Solver_IntConst(self, *args) 619 620 def Sum(self, vars): 621 r""" sum of all vars.""" 622 return _pywrapcp.Solver_Sum(self, vars) 623 624 def ScalProd(self, *args): 625 r""" 626 *Overload 1:* 627 scalar product 628 629 | 630 631 *Overload 2:* 632 scalar product 633 """ 634 return _pywrapcp.Solver_ScalProd(self, *args) 635 636 def MonotonicElement(self, values, increasing, index): 637 r""" 638 Function based element. The constraint takes ownership of the 639 callback. The callback must be monotonic. It must be able to 640 cope with any possible value in the domain of 'index' 641 (potentially negative ones too). Furtermore, monotonicity is not 642 checked. Thus giving a non-monotonic function, or specifying an 643 incorrect increasing parameter will result in undefined behavior. 644 """ 645 return _pywrapcp.Solver_MonotonicElement(self, values, increasing, index) 646 647 def Element(self, *args): 648 r""" 649 *Overload 1:* 650 values[index] 651 652 | 653 654 *Overload 2:* 655 values[index] 656 657 | 658 659 *Overload 3:* 660 Function-based element. The constraint takes ownership of the 661 callback. The callback must be able to cope with any possible 662 value in the domain of 'index' (potentially negative ones too). 663 664 | 665 666 *Overload 4:* 667 2D version of function-based element expression, values(expr1, expr2). 668 669 | 670 671 *Overload 5:* 672 vars[expr] 673 """ 674 return _pywrapcp.Solver_Element(self, *args) 675 676 def IndexExpression(self, vars, value): 677 r""" 678 Returns the expression expr such that vars[expr] == value. 679 It assumes that vars are all different. 680 """ 681 return _pywrapcp.Solver_IndexExpression(self, vars, value) 682 683 def Min(self, *args): 684 r""" 685 *Overload 1:* 686 std::min(vars) 687 688 | 689 690 *Overload 2:* 691 std::min (left, right) 692 693 | 694 695 *Overload 3:* 696 std::min(expr, value) 697 698 | 699 700 *Overload 4:* 701 std::min(expr, value) 702 """ 703 return _pywrapcp.Solver_Min(self, *args) 704 705 def Max(self, *args): 706 r""" 707 *Overload 1:* 708 std::max(vars) 709 710 | 711 712 *Overload 2:* 713 std::max(left, right) 714 715 | 716 717 *Overload 3:* 718 std::max(expr, value) 719 720 | 721 722 *Overload 4:* 723 std::max(expr, value) 724 """ 725 return _pywrapcp.Solver_Max(self, *args) 726 727 def ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost): 728 r""" Convex piecewise function.""" 729 return _pywrapcp.Solver_ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost) 730 731 def SemiContinuousExpr(self, expr, fixed_charge, step): 732 r""" 733 Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) 734 a >= 0 and b >= 0 735 """ 736 return _pywrapcp.Solver_SemiContinuousExpr(self, expr, fixed_charge, step) 737 738 def ConditionalExpression(self, condition, expr, unperformed_value): 739 r""" Conditional Expr condition ? expr : unperformed_value""" 740 return _pywrapcp.Solver_ConditionalExpression(self, condition, expr, unperformed_value) 741 742 def TrueConstraint(self): 743 r""" This constraint always succeeds.""" 744 return _pywrapcp.Solver_TrueConstraint(self) 745 746 def FalseConstraint(self, *args): 747 return _pywrapcp.Solver_FalseConstraint(self, *args) 748 749 def IsEqualCstCt(self, var, value, boolvar): 750 r""" boolvar == (var == value)""" 751 return _pywrapcp.Solver_IsEqualCstCt(self, var, value, boolvar) 752 753 def IsEqualCstVar(self, var, value): 754 r""" status var of (var == value)""" 755 return _pywrapcp.Solver_IsEqualCstVar(self, var, value) 756 757 def IsEqualCt(self, v1, v2, b): 758 r""" b == (v1 == v2)""" 759 return _pywrapcp.Solver_IsEqualCt(self, v1, v2, b) 760 761 def IsEqualVar(self, v1, v2): 762 r""" status var of (v1 == v2)""" 763 return _pywrapcp.Solver_IsEqualVar(self, v1, v2) 764 765 def IsDifferentCstCt(self, var, value, boolvar): 766 r""" boolvar == (var != value)""" 767 return _pywrapcp.Solver_IsDifferentCstCt(self, var, value, boolvar) 768 769 def IsDifferentCstVar(self, var, value): 770 r""" status var of (var != value)""" 771 return _pywrapcp.Solver_IsDifferentCstVar(self, var, value) 772 773 def IsDifferentVar(self, v1, v2): 774 r""" status var of (v1 != v2)""" 775 return _pywrapcp.Solver_IsDifferentVar(self, v1, v2) 776 777 def IsDifferentCt(self, v1, v2, b): 778 r""" b == (v1 != v2)""" 779 return _pywrapcp.Solver_IsDifferentCt(self, v1, v2, b) 780 781 def IsLessOrEqualCstCt(self, var, value, boolvar): 782 r""" boolvar == (var <= value)""" 783 return _pywrapcp.Solver_IsLessOrEqualCstCt(self, var, value, boolvar) 784 785 def IsLessOrEqualCstVar(self, var, value): 786 r""" status var of (var <= value)""" 787 return _pywrapcp.Solver_IsLessOrEqualCstVar(self, var, value) 788 789 def IsLessOrEqualVar(self, left, right): 790 r""" status var of (left <= right)""" 791 return _pywrapcp.Solver_IsLessOrEqualVar(self, left, right) 792 793 def IsLessOrEqualCt(self, left, right, b): 794 r""" b == (left <= right)""" 795 return _pywrapcp.Solver_IsLessOrEqualCt(self, left, right, b) 796 797 def IsGreaterOrEqualCstCt(self, var, value, boolvar): 798 r""" boolvar == (var >= value)""" 799 return _pywrapcp.Solver_IsGreaterOrEqualCstCt(self, var, value, boolvar) 800 801 def IsGreaterOrEqualCstVar(self, var, value): 802 r""" status var of (var >= value)""" 803 return _pywrapcp.Solver_IsGreaterOrEqualCstVar(self, var, value) 804 805 def IsGreaterOrEqualVar(self, left, right): 806 r""" status var of (left >= right)""" 807 return _pywrapcp.Solver_IsGreaterOrEqualVar(self, left, right) 808 809 def IsGreaterOrEqualCt(self, left, right, b): 810 r""" b == (left >= right)""" 811 return _pywrapcp.Solver_IsGreaterOrEqualCt(self, left, right, b) 812 813 def IsGreaterCstCt(self, v, c, b): 814 r""" b == (v > c)""" 815 return _pywrapcp.Solver_IsGreaterCstCt(self, v, c, b) 816 817 def IsGreaterCstVar(self, var, value): 818 r""" status var of (var > value)""" 819 return _pywrapcp.Solver_IsGreaterCstVar(self, var, value) 820 821 def IsGreaterVar(self, left, right): 822 r""" status var of (left > right)""" 823 return _pywrapcp.Solver_IsGreaterVar(self, left, right) 824 825 def IsGreaterCt(self, left, right, b): 826 r""" b == (left > right)""" 827 return _pywrapcp.Solver_IsGreaterCt(self, left, right, b) 828 829 def IsLessCstCt(self, v, c, b): 830 r""" b == (v < c)""" 831 return _pywrapcp.Solver_IsLessCstCt(self, v, c, b) 832 833 def IsLessCstVar(self, var, value): 834 r""" status var of (var < value)""" 835 return _pywrapcp.Solver_IsLessCstVar(self, var, value) 836 837 def IsLessVar(self, left, right): 838 r""" status var of (left < right)""" 839 return _pywrapcp.Solver_IsLessVar(self, left, right) 840 841 def IsLessCt(self, left, right, b): 842 r""" b == (left < right)""" 843 return _pywrapcp.Solver_IsLessCt(self, left, right, b) 844 845 def SumLessOrEqual(self, vars, cst): 846 r""" Variation on arrays.""" 847 return _pywrapcp.Solver_SumLessOrEqual(self, vars, cst) 848 849 def SumGreaterOrEqual(self, vars, cst): 850 return _pywrapcp.Solver_SumGreaterOrEqual(self, vars, cst) 851 852 def SumEquality(self, *args): 853 return _pywrapcp.Solver_SumEquality(self, *args) 854 855 def ScalProdEquality(self, *args): 856 return _pywrapcp.Solver_ScalProdEquality(self, *args) 857 858 def ScalProdGreaterOrEqual(self, *args): 859 return _pywrapcp.Solver_ScalProdGreaterOrEqual(self, *args) 860 861 def ScalProdLessOrEqual(self, *args): 862 return _pywrapcp.Solver_ScalProdLessOrEqual(self, *args) 863 864 def MinEquality(self, vars, min_var): 865 return _pywrapcp.Solver_MinEquality(self, vars, min_var) 866 867 def MaxEquality(self, vars, max_var): 868 return _pywrapcp.Solver_MaxEquality(self, vars, max_var) 869 870 def ElementEquality(self, *args): 871 return _pywrapcp.Solver_ElementEquality(self, *args) 872 873 def AbsEquality(self, var, abs_var): 874 r""" Creates the constraint abs(var) == abs_var.""" 875 return _pywrapcp.Solver_AbsEquality(self, var, abs_var) 876 877 def IndexOfConstraint(self, vars, index, target): 878 r""" 879 This constraint is a special case of the element constraint with 880 an array of integer variables, where the variables are all 881 different and the index variable is constrained such that 882 vars[index] == target. 883 """ 884 return _pywrapcp.Solver_IndexOfConstraint(self, vars, index, target) 885 886 def ConstraintInitialPropagateCallback(self, ct): 887 r""" 888 This method is a specialized case of the MakeConstraintDemon 889 method to call the InitiatePropagate of the constraint 'ct'. 890 """ 891 return _pywrapcp.Solver_ConstraintInitialPropagateCallback(self, ct) 892 893 def DelayedConstraintInitialPropagateCallback(self, ct): 894 r""" 895 This method is a specialized case of the MakeConstraintDemon 896 method to call the InitiatePropagate of the constraint 'ct' with 897 low priority. 898 """ 899 return _pywrapcp.Solver_DelayedConstraintInitialPropagateCallback(self, ct) 900 901 def ClosureDemon(self, closure): 902 r""" Creates a demon from a closure.""" 903 return _pywrapcp.Solver_ClosureDemon(self, closure) 904 905 def BetweenCt(self, expr, l, u): 906 r""" (l <= expr <= u)""" 907 return _pywrapcp.Solver_BetweenCt(self, expr, l, u) 908 909 def IsBetweenCt(self, expr, l, u, b): 910 r""" b == (l <= expr <= u)""" 911 return _pywrapcp.Solver_IsBetweenCt(self, expr, l, u, b) 912 913 def IsBetweenVar(self, v, l, u): 914 return _pywrapcp.Solver_IsBetweenVar(self, v, l, u) 915 916 def MemberCt(self, *args): 917 return _pywrapcp.Solver_MemberCt(self, *args) 918 919 def NotMemberCt(self, *args): 920 r""" 921 *Overload 1:* 922 expr not in set. 923 924 | 925 926 *Overload 2:* 927 expr should not be in the list of forbidden intervals [start[i]..end[i]]. 928 929 | 930 931 *Overload 3:* 932 expr should not be in the list of forbidden intervals [start[i]..end[i]]. 933 """ 934 return _pywrapcp.Solver_NotMemberCt(self, *args) 935 936 def IsMemberCt(self, *args): 937 return _pywrapcp.Solver_IsMemberCt(self, *args) 938 939 def IsMemberVar(self, *args): 940 return _pywrapcp.Solver_IsMemberVar(self, *args) 941 942 def Count(self, *args): 943 r""" 944 *Overload 1:* 945 |{i | vars[i] == value}| == max_count 946 947 | 948 949 *Overload 2:* 950 |{i | vars[i] == value}| == max_count 951 """ 952 return _pywrapcp.Solver_Count(self, *args) 953 954 def Distribute(self, *args): 955 r""" 956 *Overload 1:* 957 Aggregated version of count: |{i | v[i] == values[j]}| == cards[j] 958 959 | 960 961 *Overload 2:* 962 Aggregated version of count: |{i | v[i] == values[j]}| == cards[j] 963 964 | 965 966 *Overload 3:* 967 Aggregated version of count: |{i | v[i] == j}| == cards[j] 968 969 | 970 971 *Overload 4:* 972 Aggregated version of count with bounded cardinalities: 973 forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max 974 975 | 976 977 *Overload 5:* 978 Aggregated version of count with bounded cardinalities: 979 forall j in 0 .. card_size - 1: 980 card_min[j] <= |{i | v[i] == j}| <= card_max[j] 981 982 | 983 984 *Overload 6:* 985 Aggregated version of count with bounded cardinalities: 986 forall j in 0 .. card_size - 1: 987 card_min[j] <= |{i | v[i] == j}| <= card_max[j] 988 989 | 990 991 *Overload 7:* 992 Aggregated version of count with bounded cardinalities: 993 forall j in 0 .. card_size - 1: 994 card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j] 995 996 | 997 998 *Overload 8:* 999 Aggregated version of count with bounded cardinalities: 1000 forall j in 0 .. card_size - 1: 1001 card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j] 1002 """ 1003 return _pywrapcp.Solver_Distribute(self, *args) 1004 1005 def Deviation(self, vars, deviation_var, total_sum): 1006 r""" 1007 Deviation constraint: 1008 sum_i |n * vars[i] - total_sum| <= deviation_var and 1009 sum_i vars[i] == total_sum 1010 n = #vars 1011 """ 1012 return _pywrapcp.Solver_Deviation(self, vars, deviation_var, total_sum) 1013 1014 def AllDifferent(self, *args): 1015 r""" 1016 *Overload 1:* 1017 All variables are pairwise different. This corresponds to the 1018 stronger version of the propagation algorithm. 1019 1020 | 1021 1022 *Overload 2:* 1023 All variables are pairwise different. If 'stronger_propagation' 1024 is true, stronger, and potentially slower propagation will 1025 occur. This API will be deprecated in the future. 1026 """ 1027 return _pywrapcp.Solver_AllDifferent(self, *args) 1028 1029 def AllDifferentExcept(self, vars, escape_value): 1030 r""" 1031 All variables are pairwise different, unless they are assigned to 1032 the escape value. 1033 """ 1034 return _pywrapcp.Solver_AllDifferentExcept(self, vars, escape_value) 1035 1036 def SortingConstraint(self, vars, sorted): 1037 r""" 1038 Creates a constraint binding the arrays of variables "vars" and 1039 "sorted_vars": sorted_vars[0] must be equal to the minimum of all 1040 variables in vars, and so on: the value of sorted_vars[i] must be 1041 equal to the i-th value of variables invars. 1042 1043 This constraint propagates in both directions: from "vars" to 1044 "sorted_vars" and vice-versa. 1045 1046 Behind the scenes, this constraint maintains that: 1047 - sorted is always increasing. 1048 - whatever the values of vars, there exists a permutation that 1049 injects its values into the sorted variables. 1050 1051 For more info, please have a look at: 1052 https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf 1053 """ 1054 return _pywrapcp.Solver_SortingConstraint(self, vars, sorted) 1055 1056 def LexicalLess(self, left, right): 1057 r""" 1058 Creates a constraint that enforces that left is lexicographically less 1059 than right. 1060 """ 1061 return _pywrapcp.Solver_LexicalLess(self, left, right) 1062 1063 def LexicalLessOrEqual(self, left, right): 1064 r""" 1065 Creates a constraint that enforces that left is lexicographically less 1066 than or equal to right. 1067 """ 1068 return _pywrapcp.Solver_LexicalLessOrEqual(self, left, right) 1069 1070 def InversePermutationConstraint(self, left, right): 1071 r""" 1072 Creates a constraint that enforces that 'left' and 'right' both 1073 represent permutations of [0..left.size()-1], and that 'right' is 1074 the inverse permutation of 'left', i.e. for all i in 1075 [0..left.size()-1], right[left[i]] = i. 1076 """ 1077 return _pywrapcp.Solver_InversePermutationConstraint(self, left, right) 1078 1079 def NullIntersect(self, first_vars, second_vars): 1080 r""" 1081 Creates a constraint that states that all variables in the first 1082 vector are different from all variables in the second 1083 group. Thus the set of values in the first vector does not 1084 intersect with the set of values in the second vector. 1085 """ 1086 return _pywrapcp.Solver_NullIntersect(self, first_vars, second_vars) 1087 1088 def NullIntersectExcept(self, first_vars, second_vars, escape_value): 1089 r""" 1090 Creates a constraint that states that all variables in the first 1091 vector are different from all variables from the second group, 1092 unless they are assigned to the escape value. Thus the set of 1093 values in the first vector minus the escape value does not 1094 intersect with the set of values in the second vector. 1095 """ 1096 return _pywrapcp.Solver_NullIntersectExcept(self, first_vars, second_vars, escape_value) 1097 1098 def Circuit(self, nexts): 1099 r""" Force the "nexts" variable to create a complete Hamiltonian path.""" 1100 return _pywrapcp.Solver_Circuit(self, nexts) 1101 1102 def SubCircuit(self, nexts): 1103 r""" 1104 Force the "nexts" variable to create a complete Hamiltonian path 1105 for those that do not loop upon themselves. 1106 """ 1107 return _pywrapcp.Solver_SubCircuit(self, nexts) 1108 1109 def DelayedPathCumul(self, nexts, active, cumuls, transits): 1110 r""" 1111 Delayed version of the same constraint: propagation on the nexts variables 1112 is delayed until all constraints have propagated. 1113 """ 1114 return _pywrapcp.Solver_DelayedPathCumul(self, nexts, active, cumuls, transits) 1115 1116 def PathCumul(self, *args): 1117 r""" 1118 *Overload 1:* 1119 Creates a constraint which accumulates values along a path such that: 1120 cumuls[next[i]] = cumuls[i] + transits[i]. 1121 Active variables indicate if the corresponding next variable is active; 1122 this could be useful to model unperformed nodes in a routing problem. 1123 1124 | 1125 1126 *Overload 2:* 1127 Creates a constraint which accumulates values along a path such that: 1128 cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). 1129 Active variables indicate if the corresponding next variable is active; 1130 this could be useful to model unperformed nodes in a routing problem. 1131 Ownership of transit_evaluator is taken and it must be a repeatable 1132 callback. 1133 1134 | 1135 1136 *Overload 3:* 1137 Creates a constraint which accumulates values along a path such that: 1138 cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. 1139 Active variables indicate if the corresponding next variable is active; 1140 this could be useful to model unperformed nodes in a routing problem. 1141 Ownership of transit_evaluator is taken and it must be a repeatable 1142 callback. 1143 """ 1144 return _pywrapcp.Solver_PathCumul(self, *args) 1145 1146 def AllowedAssignments(self, *args): 1147 r""" 1148 *Overload 1:* 1149 This method creates a constraint where the graph of the relation 1150 between the variables is given in extension. There are 'arity' 1151 variables involved in the relation and the graph is given by a 1152 integer tuple set. 1153 1154 | 1155 1156 *Overload 2:* 1157 Compatibility layer for Python API. 1158 """ 1159 return _pywrapcp.Solver_AllowedAssignments(self, *args) 1160 1161 def TransitionConstraint(self, *args): 1162 return _pywrapcp.Solver_TransitionConstraint(self, *args) 1163 1164 def NonOverlappingBoxesConstraint(self, *args): 1165 return _pywrapcp.Solver_NonOverlappingBoxesConstraint(self, *args) 1166 1167 def Pack(self, vars, number_of_bins): 1168 r""" 1169 This constraint packs all variables onto 'number_of_bins' 1170 variables. For any given variable, a value of 'number_of_bins' 1171 indicates that the variable is not assigned to any bin. 1172 Dimensions, i.e., cumulative constraints on this packing, can be 1173 added directly from the pack class. 1174 """ 1175 return _pywrapcp.Solver_Pack(self, vars, number_of_bins) 1176 1177 def FixedDurationIntervalVar(self, *args): 1178 r""" 1179 *Overload 1:* 1180 Creates an interval var with a fixed duration. The duration must 1181 be greater than 0. If optional is true, then the interval can be 1182 performed or unperformed. If optional is false, then the interval 1183 is always performed. 1184 1185 | 1186 1187 *Overload 2:* 1188 Creates a performed interval var with a fixed duration. The duration must 1189 be greater than 0. 1190 1191 | 1192 1193 *Overload 3:* 1194 Creates an interval var with a fixed duration, and performed_variable. 1195 The duration must be greater than 0. 1196 """ 1197 return _pywrapcp.Solver_FixedDurationIntervalVar(self, *args) 1198 1199 def FixedInterval(self, start, duration, name): 1200 r""" Creates a fixed and performed interval.""" 1201 return _pywrapcp.Solver_FixedInterval(self, start, duration, name) 1202 1203 def IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name): 1204 r""" 1205 Creates an interval var by specifying the bounds on start, 1206 duration, and end. 1207 """ 1208 return _pywrapcp.Solver_IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name) 1209 1210 def MirrorInterval(self, interval_var): 1211 r""" 1212 Creates an interval var that is the mirror image of the given one, that 1213 is, the interval var obtained by reversing the axis. 1214 """ 1215 return _pywrapcp.Solver_MirrorInterval(self, interval_var) 1216 1217 def FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset): 1218 r""" 1219 Creates an interval var with a fixed duration whose start is 1220 synchronized with the start of another interval, with a given 1221 offset. The performed status is also in sync with the performed 1222 status of the given interval variable. 1223 """ 1224 return _pywrapcp.Solver_FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset) 1225 1226 def FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset): 1227 r""" 1228 Creates an interval var with a fixed duration whose start is 1229 synchronized with the end of another interval, with a given 1230 offset. The performed status is also in sync with the performed 1231 status of the given interval variable. 1232 """ 1233 return _pywrapcp.Solver_FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset) 1234 1235 def FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset): 1236 r""" 1237 Creates an interval var with a fixed duration whose end is 1238 synchronized with the start of another interval, with a given 1239 offset. The performed status is also in sync with the performed 1240 status of the given interval variable. 1241 """ 1242 return _pywrapcp.Solver_FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset) 1243 1244 def FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset): 1245 r""" 1246 Creates an interval var with a fixed duration whose end is 1247 synchronized with the end of another interval, with a given 1248 offset. The performed status is also in sync with the performed 1249 status of the given interval variable. 1250 """ 1251 return _pywrapcp.Solver_FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset) 1252 1253 def IntervalRelaxedMin(self, interval_var): 1254 r""" 1255 Creates and returns an interval variable that wraps around the given one, 1256 relaxing the min start and end. Relaxing means making unbounded when 1257 optional. If the variable is non-optional, this method returns 1258 interval_var. 1259 1260 More precisely, such an interval variable behaves as follows: 1261 When the underlying must be performed, the returned interval variable 1262 behaves exactly as the underlying; 1263 When the underlying may or may not be performed, the returned interval 1264 variable behaves like the underlying, except that it is unbounded on 1265 the min side; 1266 When the underlying cannot be performed, the returned interval variable 1267 is of duration 0 and must be performed in an interval unbounded on 1268 both sides. 1269 1270 This is very useful to implement propagators that may only modify 1271 the start max or end max. 1272 """ 1273 return _pywrapcp.Solver_IntervalRelaxedMin(self, interval_var) 1274 1275 def IntervalRelaxedMax(self, interval_var): 1276 r""" 1277 Creates and returns an interval variable that wraps around the given one, 1278 relaxing the max start and end. Relaxing means making unbounded when 1279 optional. If the variable is non optional, this method returns 1280 interval_var. 1281 1282 More precisely, such an interval variable behaves as follows: 1283 When the underlying must be performed, the returned interval variable 1284 behaves exactly as the underlying; 1285 When the underlying may or may not be performed, the returned interval 1286 variable behaves like the underlying, except that it is unbounded on 1287 the max side; 1288 When the underlying cannot be performed, the returned interval variable 1289 is of duration 0 and must be performed in an interval unbounded on 1290 both sides. 1291 1292 This is very useful for implementing propagators that may only modify 1293 the start min or end min. 1294 """ 1295 return _pywrapcp.Solver_IntervalRelaxedMax(self, interval_var) 1296 1297 def TemporalDisjunction(self, *args): 1298 r""" 1299 *Overload 1:* 1300 This constraint implements a temporal disjunction between two 1301 interval vars t1 and t2. 'alt' indicates which alternative was 1302 chosen (alt == 0 is equivalent to t1 before t2). 1303 1304 | 1305 1306 *Overload 2:* 1307 This constraint implements a temporal disjunction between two 1308 interval vars. 1309 """ 1310 return _pywrapcp.Solver_TemporalDisjunction(self, *args) 1311 1312 def DisjunctiveConstraint(self, intervals, name): 1313 r""" 1314 This constraint forces all interval vars into an non-overlapping 1315 sequence. Intervals with zero duration can be scheduled anywhere. 1316 """ 1317 return _pywrapcp.Solver_DisjunctiveConstraint(self, intervals, name) 1318 1319 def Cumulative(self, *args): 1320 r""" 1321 *Overload 1:* 1322 This constraint forces that, for any integer t, the sum of the demands 1323 corresponding to an interval containing t does not exceed the given 1324 capacity. 1325 1326 Intervals and demands should be vectors of equal size. 1327 1328 Demands should only contain non-negative values. Zero values are 1329 supported, and the corresponding intervals are filtered out, as they 1330 neither impact nor are impacted by this constraint. 1331 1332 | 1333 1334 *Overload 2:* 1335 This constraint forces that, for any integer t, the sum of the demands 1336 corresponding to an interval containing t does not exceed the given 1337 capacity. 1338 1339 Intervals and demands should be vectors of equal size. 1340 1341 Demands should only contain non-negative values. Zero values are 1342 supported, and the corresponding intervals are filtered out, as they 1343 neither impact nor are impacted by this constraint. 1344 1345 | 1346 1347 *Overload 3:* 1348 This constraint forces that, for any integer t, the sum of the demands 1349 corresponding to an interval containing t does not exceed the given 1350 capacity. 1351 1352 Intervals and demands should be vectors of equal size. 1353 1354 Demands should only contain non-negative values. Zero values are 1355 supported, and the corresponding intervals are filtered out, as they 1356 neither impact nor are impacted by this constraint. 1357 1358 | 1359 1360 *Overload 4:* 1361 This constraint enforces that, for any integer t, the sum of the demands 1362 corresponding to an interval containing t does not exceed the given 1363 capacity. 1364 1365 Intervals and demands should be vectors of equal size. 1366 1367 Demands should only contain non-negative values. Zero values are 1368 supported, and the corresponding intervals are filtered out, as they 1369 neither impact nor are impacted by this constraint. 1370 1371 | 1372 1373 *Overload 5:* 1374 This constraint enforces that, for any integer t, the sum of demands 1375 corresponding to an interval containing t does not exceed the given 1376 capacity. 1377 1378 Intervals and demands should be vectors of equal size. 1379 1380 Demands should be positive. 1381 1382 | 1383 1384 *Overload 6:* 1385 This constraint enforces that, for any integer t, the sum of demands 1386 corresponding to an interval containing t does not exceed the given 1387 capacity. 1388 1389 Intervals and demands should be vectors of equal size. 1390 1391 Demands should be positive. 1392 """ 1393 return _pywrapcp.Solver_Cumulative(self, *args) 1394 1395 def Cover(self, vars, target_var): 1396 r""" 1397 This constraint states that the target_var is the convex hull of 1398 the intervals. If none of the interval variables is performed, 1399 then the target var is unperformed too. Also, if the target 1400 variable is unperformed, then all the intervals variables are 1401 unperformed too. 1402 """ 1403 return _pywrapcp.Solver_Cover(self, vars, target_var) 1404 1405 def Assignment(self, *args): 1406 r""" 1407 *Overload 1:* 1408 This method creates an empty assignment. 1409 1410 | 1411 1412 *Overload 2:* 1413 This method creates an assignment which is a copy of 'a'. 1414 """ 1415 return _pywrapcp.Solver_Assignment(self, *args) 1416 1417 def FirstSolutionCollector(self, *args): 1418 r""" 1419 *Overload 1:* 1420 Collect the first solution of the search. 1421 1422 | 1423 1424 *Overload 2:* 1425 Collect the first solution of the search. The variables will need to 1426 be added later. 1427 """ 1428 return _pywrapcp.Solver_FirstSolutionCollector(self, *args) 1429 1430 def LastSolutionCollector(self, *args): 1431 r""" 1432 *Overload 1:* 1433 Collect the last solution of the search. 1434 1435 | 1436 1437 *Overload 2:* 1438 Collect the last solution of the search. The variables will need to 1439 be added later. 1440 """ 1441 return _pywrapcp.Solver_LastSolutionCollector(self, *args) 1442 1443 def BestValueSolutionCollector(self, *args): 1444 r""" 1445 *Overload 1:* 1446 Collect the solution corresponding to the optimal value of the objective 1447 of 'assignment'; if 'assignment' does not have an objective no solution is 1448 collected. This collector only collects one solution corresponding to the 1449 best objective value (the first one found). 1450 1451 | 1452 1453 *Overload 2:* 1454 Collect the solution corresponding to the optimal value of the 1455 objective of the internal assignment; if this assignment does not have an 1456 objective no solution is collected. This collector only collects one 1457 solution corresponding to the best objective value (the first one found). 1458 The variables and objective(s) will need to be added later. 1459 """ 1460 return _pywrapcp.Solver_BestValueSolutionCollector(self, *args) 1461 1462 def AllSolutionCollector(self, *args): 1463 r""" 1464 *Overload 1:* 1465 Collect all solutions of the search. 1466 1467 | 1468 1469 *Overload 2:* 1470 Collect all solutions of the search. The variables will need to 1471 be added later. 1472 """ 1473 return _pywrapcp.Solver_AllSolutionCollector(self, *args) 1474 1475 def Minimize(self, v, step): 1476 r""" Creates a minimization objective.""" 1477 return _pywrapcp.Solver_Minimize(self, v, step) 1478 1479 def Maximize(self, v, step): 1480 r""" Creates a maximization objective.""" 1481 return _pywrapcp.Solver_Maximize(self, v, step) 1482 1483 def Optimize(self, maximize, v, step): 1484 r""" Creates a objective with a given sense (true = maximization).""" 1485 return _pywrapcp.Solver_Optimize(self, maximize, v, step) 1486 1487 def WeightedMinimize(self, *args): 1488 r""" 1489 *Overload 1:* 1490 Creates a minimization weighted objective. The actual objective is 1491 scalar_prod(sub_objectives, weights). 1492 1493 | 1494 1495 *Overload 2:* 1496 Creates a minimization weighted objective. The actual objective is 1497 scalar_prod(sub_objectives, weights). 1498 """ 1499 return _pywrapcp.Solver_WeightedMinimize(self, *args) 1500 1501 def WeightedMaximize(self, *args): 1502 r""" 1503 *Overload 1:* 1504 Creates a maximization weigthed objective. 1505 1506 | 1507 1508 *Overload 2:* 1509 Creates a maximization weigthed objective. 1510 """ 1511 return _pywrapcp.Solver_WeightedMaximize(self, *args) 1512 1513 def WeightedOptimize(self, *args): 1514 r""" 1515 *Overload 1:* 1516 Creates a weighted objective with a given sense (true = maximization). 1517 1518 | 1519 1520 *Overload 2:* 1521 Creates a weighted objective with a given sense (true = maximization). 1522 """ 1523 return _pywrapcp.Solver_WeightedOptimize(self, *args) 1524 1525 def TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor): 1526 r""" 1527 MetaHeuristics which try to get the search out of local optima. 1528 Creates a Tabu Search monitor. 1529 In the context of local search the behavior is similar to MakeOptimize(), 1530 creating an objective in a given sense. The behavior differs once a local 1531 optimum is reached: thereafter solutions which degrade the value of the 1532 objective are allowed if they are not "tabu". A solution is "tabu" if it 1533 doesn't respect the following rules: 1534 - improving the best solution found so far 1535 - variables in the "keep" list must keep their value, variables in the 1536 "forbid" list must not take the value they have in the list. 1537 Variables with new values enter the tabu lists after each new solution 1538 found and leave the lists after a given number of iterations (called 1539 tenure). Only the variables passed to the method can enter the lists. 1540 The tabu criterion is softened by the tabu factor which gives the number 1541 of "tabu" violations which is tolerated; a factor of 1 means no violations 1542 allowed; a factor of 0 means all violations are allowed. 1543 """ 1544 return _pywrapcp.Solver_TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor) 1545 1546 def SimulatedAnnealing(self, maximize, v, step, initial_temperature): 1547 r""" Creates a Simulated Annealing monitor.""" 1548 return _pywrapcp.Solver_SimulatedAnnealing(self, maximize, v, step, initial_temperature) 1549 1550 def LubyRestart(self, scale_factor): 1551 r""" 1552 This search monitor will restart the search periodically. 1553 At the iteration n, it will restart after scale_factor * Luby(n) failures 1554 where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...). 1555 """ 1556 return _pywrapcp.Solver_LubyRestart(self, scale_factor) 1557 1558 def ConstantRestart(self, frequency): 1559 r""" 1560 This search monitor will restart the search periodically after 'frequency' 1561 failures. 1562 """ 1563 return _pywrapcp.Solver_ConstantRestart(self, frequency) 1564 1565 def TimeLimit(self, *args): 1566 return _pywrapcp.Solver_TimeLimit(self, *args) 1567 1568 def BranchesLimit(self, branches): 1569 r""" 1570 Creates a search limit that constrains the number of branches 1571 explored in the search tree. 1572 """ 1573 return _pywrapcp.Solver_BranchesLimit(self, branches) 1574 1575 def FailuresLimit(self, failures): 1576 r""" 1577 Creates a search limit that constrains the number of failures 1578 that can happen when exploring the search tree. 1579 """ 1580 return _pywrapcp.Solver_FailuresLimit(self, failures) 1581 1582 def SolutionsLimit(self, solutions): 1583 r""" 1584 Creates a search limit that constrains the number of solutions found 1585 during the search. 1586 """ 1587 return _pywrapcp.Solver_SolutionsLimit(self, solutions) 1588 1589 def Limit(self, *args): 1590 r""" 1591 *Overload 1:* 1592 Limits the search with the 'time', 'branches', 'failures' and 1593 'solutions' limits. 'smart_time_check' reduces the calls to the wall 1594 1595 | 1596 1597 *Overload 2:* 1598 Creates a search limit from its protobuf description 1599 1600 | 1601 1602 *Overload 3:* 1603 Creates a search limit that is reached when either of the underlying limit 1604 is reached. That is, the returned limit is more stringent than both 1605 argument limits. 1606 """ 1607 return _pywrapcp.Solver_Limit(self, *args) 1608 1609 def CustomLimit(self, limiter): 1610 r""" 1611 Callback-based search limit. Search stops when limiter returns true; if 1612 this happens at a leaf the corresponding solution will be rejected. 1613 """ 1614 return _pywrapcp.Solver_CustomLimit(self, limiter) 1615 1616 def SearchLog(self, *args): 1617 return _pywrapcp.Solver_SearchLog(self, *args) 1618 1619 def SearchTrace(self, prefix): 1620 r""" 1621 Creates a search monitor that will trace precisely the behavior of the 1622 search. Use this only for low level debugging. 1623 """ 1624 return _pywrapcp.Solver_SearchTrace(self, prefix) 1625 1626 def PrintModelVisitor(self): 1627 r""" Prints the model.""" 1628 return _pywrapcp.Solver_PrintModelVisitor(self) 1629 1630 def StatisticsModelVisitor(self): 1631 r""" Displays some nice statistics on the model.""" 1632 return _pywrapcp.Solver_StatisticsModelVisitor(self) 1633 1634 def AssignVariableValue(self, var, val): 1635 r""" Decisions.""" 1636 return _pywrapcp.Solver_AssignVariableValue(self, var, val) 1637 1638 def VariableLessOrEqualValue(self, var, value): 1639 return _pywrapcp.Solver_VariableLessOrEqualValue(self, var, value) 1640 1641 def VariableGreaterOrEqualValue(self, var, value): 1642 return _pywrapcp.Solver_VariableGreaterOrEqualValue(self, var, value) 1643 1644 def SplitVariableDomain(self, var, val, start_with_lower_half): 1645 return _pywrapcp.Solver_SplitVariableDomain(self, var, val, start_with_lower_half) 1646 1647 def AssignVariableValueOrFail(self, var, value): 1648 return _pywrapcp.Solver_AssignVariableValueOrFail(self, var, value) 1649 1650 def AssignVariablesValues(self, vars, values): 1651 return _pywrapcp.Solver_AssignVariablesValues(self, vars, values) 1652 1653 def FailDecision(self): 1654 return _pywrapcp.Solver_FailDecision(self) 1655 1656 def Decision(self, apply, refute): 1657 return _pywrapcp.Solver_Decision(self, apply, refute) 1658 1659 def Compose(self, dbs): 1660 return _pywrapcp.Solver_Compose(self, dbs) 1661 1662 def Try(self, dbs): 1663 return _pywrapcp.Solver_Try(self, dbs) 1664 1665 def DefaultPhase(self, *args): 1666 return _pywrapcp.Solver_DefaultPhase(self, *args) 1667 1668 def ScheduleOrPostpone(self, var, est, marker): 1669 r""" 1670 Returns a decision that tries to schedule a task at a given time. 1671 On the Apply branch, it will set that interval var as performed and set 1672 its start to 'est'. On the Refute branch, it will just update the 1673 'marker' to 'est' + 1. This decision is used in the 1674 INTERVAL_SET_TIMES_FORWARD strategy. 1675 """ 1676 return _pywrapcp.Solver_ScheduleOrPostpone(self, var, est, marker) 1677 1678 def ScheduleOrExpedite(self, var, est, marker): 1679 r""" 1680 Returns a decision that tries to schedule a task at a given time. 1681 On the Apply branch, it will set that interval var as performed and set 1682 its end to 'est'. On the Refute branch, it will just update the 1683 'marker' to 'est' - 1. This decision is used in the 1684 INTERVAL_SET_TIMES_BACKWARD strategy. 1685 """ 1686 return _pywrapcp.Solver_ScheduleOrExpedite(self, var, est, marker) 1687 1688 def RankFirstInterval(self, sequence, index): 1689 r""" 1690 Returns a decision that tries to rank first the ith interval var 1691 in the sequence variable. 1692 """ 1693 return _pywrapcp.Solver_RankFirstInterval(self, sequence, index) 1694 1695 def RankLastInterval(self, sequence, index): 1696 r""" 1697 Returns a decision that tries to rank last the ith interval var 1698 in the sequence variable. 1699 """ 1700 return _pywrapcp.Solver_RankLastInterval(self, sequence, index) 1701 1702 def Phase(self, *args): 1703 return _pywrapcp.Solver_Phase(self, *args) 1704 1705 def DecisionBuilderFromAssignment(self, assignment, db, vars): 1706 r""" 1707 Returns a decision builder for which the left-most leaf corresponds 1708 to assignment, the rest of the tree being explored using 'db'. 1709 """ 1710 return _pywrapcp.Solver_DecisionBuilderFromAssignment(self, assignment, db, vars) 1711 1712 def ConstraintAdder(self, ct): 1713 r""" 1714 Returns a decision builder that will add the given constraint to 1715 the model. 1716 """ 1717 return _pywrapcp.Solver_ConstraintAdder(self, ct) 1718 1719 def SolveOnce(self, db, monitors): 1720 return _pywrapcp.Solver_SolveOnce(self, db, monitors) 1721 1722 def NestedOptimize(self, *args): 1723 return _pywrapcp.Solver_NestedOptimize(self, *args) 1724 1725 def RestoreAssignment(self, assignment): 1726 r""" 1727 Returns a DecisionBuilder which restores an Assignment 1728 (calls void Assignment::Restore()) 1729 """ 1730 return _pywrapcp.Solver_RestoreAssignment(self, assignment) 1731 1732 def StoreAssignment(self, assignment): 1733 r""" 1734 Returns a DecisionBuilder which stores an Assignment 1735 (calls void Assignment::Store()) 1736 """ 1737 return _pywrapcp.Solver_StoreAssignment(self, assignment) 1738 1739 def Operator(self, *args): 1740 return _pywrapcp.Solver_Operator(self, *args) 1741 1742 def RandomLnsOperator(self, *args): 1743 return _pywrapcp.Solver_RandomLnsOperator(self, *args) 1744 1745 def MoveTowardTargetOperator(self, *args): 1746 r""" 1747 *Overload 1:* 1748 Creates a local search operator that tries to move the assignment of some 1749 variables toward a target. The target is given as an Assignment. This 1750 operator generates neighbors in which the only difference compared to the 1751 current state is that one variable that belongs to the target assignment 1752 is set to its target value. 1753 1754 | 1755 1756 *Overload 2:* 1757 Creates a local search operator that tries to move the assignment of some 1758 variables toward a target. The target is given either as two vectors: a 1759 vector of variables and a vector of associated target values. The two 1760 vectors should be of the same length. This operator generates neighbors in 1761 which the only difference compared to the current state is that one 1762 variable that belongs to the given vector is set to its target value. 1763 """ 1764 return _pywrapcp.Solver_MoveTowardTargetOperator(self, *args) 1765 1766 def ConcatenateOperators(self, *args): 1767 return _pywrapcp.Solver_ConcatenateOperators(self, *args) 1768 1769 def RandomConcatenateOperators(self, *args): 1770 r""" 1771 *Overload 1:* 1772 Randomized version of local search concatenator; calls a random operator 1773 at each call to MakeNextNeighbor(). 1774 1775 | 1776 1777 *Overload 2:* 1778 Randomized version of local search concatenator; calls a random operator 1779 at each call to MakeNextNeighbor(). The provided seed is used to 1780 initialize the random number generator. 1781 """ 1782 return _pywrapcp.Solver_RandomConcatenateOperators(self, *args) 1783 1784 def NeighborhoodLimit(self, op, limit): 1785 r""" 1786 Creates a local search operator that wraps another local search 1787 operator and limits the number of neighbors explored (i.e., calls 1788 to MakeNextNeighbor from the current solution (between two calls 1789 to Start()). When this limit is reached, MakeNextNeighbor() 1790 returns false. The counter is cleared when Start() is called. 1791 """ 1792 return _pywrapcp.Solver_NeighborhoodLimit(self, op, limit) 1793 1794 def LocalSearchPhase(self, *args): 1795 return _pywrapcp.Solver_LocalSearchPhase(self, *args) 1796 1797 def LocalSearchPhaseParameters(self, *args): 1798 return _pywrapcp.Solver_LocalSearchPhaseParameters(self, *args) 1799 1800 def TopProgressPercent(self): 1801 r""" 1802 Returns a percentage representing the propress of the search before 1803 reaching the limits of the top-level search (can be called from a nested 1804 solve). 1805 """ 1806 return _pywrapcp.Solver_TopProgressPercent(self) 1807 1808 def SearchDepth(self): 1809 r""" 1810 Gets the search depth of the current active search. Returns -1 if 1811 there is no active search opened. 1812 """ 1813 return _pywrapcp.Solver_SearchDepth(self) 1814 1815 def SearchLeftDepth(self): 1816 r""" 1817 Gets the search left depth of the current active search. Returns -1 if 1818 there is no active search opened. 1819 """ 1820 return _pywrapcp.Solver_SearchLeftDepth(self) 1821 1822 def SolveDepth(self): 1823 r""" 1824 Gets the number of nested searches. It returns 0 outside search, 1825 1 during the top level search, 2 or more in case of nested searches. 1826 """ 1827 return _pywrapcp.Solver_SolveDepth(self) 1828 1829 def Rand64(self, size): 1830 r""" Returns a random value between 0 and 'size' - 1;""" 1831 return _pywrapcp.Solver_Rand64(self, size) 1832 1833 def Rand32(self, size): 1834 r""" Returns a random value between 0 and 'size' - 1;""" 1835 return _pywrapcp.Solver_Rand32(self, size) 1836 1837 def ReSeed(self, seed): 1838 r""" Reseed the solver random generator.""" 1839 return _pywrapcp.Solver_ReSeed(self, seed) 1840 1841 def LocalSearchProfile(self): 1842 r""" Returns local search profiling information in a human readable format.""" 1843 return _pywrapcp.Solver_LocalSearchProfile(self) 1844 1845 def Constraints(self): 1846 r""" 1847 Counts the number of constraints that have been added 1848 to the solver before the search. 1849 """ 1850 return _pywrapcp.Solver_Constraints(self) 1851 1852 def Accept(self, visitor): 1853 r""" Accepts the given model visitor.""" 1854 return _pywrapcp.Solver_Accept(self, visitor) 1855 1856 def FinishCurrentSearch(self): 1857 r""" Tells the solver to kill or restart the current search.""" 1858 return _pywrapcp.Solver_FinishCurrentSearch(self) 1859 1860 def RestartCurrentSearch(self): 1861 return _pywrapcp.Solver_RestartCurrentSearch(self) 1862 1863 def ShouldFail(self): 1864 r""" 1865 These methods are only useful for the SWIG wrappers, which need a way 1866 to externally cause the Solver to fail. 1867 """ 1868 return _pywrapcp.Solver_ShouldFail(self) 1869 1870 def __str__(self): 1871 return _pywrapcp.Solver___str__(self) 1872 1873 def Add(self, ct): 1874 if isinstance(ct, PyConstraint): 1875 self.__python_constraints.append(ct) 1876 self.AddConstraint(ct) 1877 1878 1879 def TreeNoCycle(self, nexts, active, callback=0): 1880 return _pywrapcp.Solver_TreeNoCycle(self, nexts, active, callback) 1881 1882 def SearchLogWithCallback(self, period, callback): 1883 return _pywrapcp.Solver_SearchLogWithCallback(self, period, callback) 1884 1885 def ElementFunction(self, values, index): 1886 return _pywrapcp.Solver_ElementFunction(self, values, index) 1887 1888 def VarEvalValStrPhase(self, vars, var_evaluator, val_str): 1889 return _pywrapcp.Solver_VarEvalValStrPhase(self, vars, var_evaluator, val_str) 1890 1891 def VarStrValEvalPhase(self, vars, var_str, val_eval): 1892 return _pywrapcp.Solver_VarStrValEvalPhase(self, vars, var_str, val_eval) 1893 1894 def VarEvalValEvalPhase(self, vars, var_eval, val_eval): 1895 return _pywrapcp.Solver_VarEvalValEvalPhase(self, vars, var_eval, val_eval) 1896 1897 def VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker): 1898 return _pywrapcp.Solver_VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker) 1899 1900 def VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker): 1901 return _pywrapcp.Solver_VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker) 1902 1903 def EvalEvalStrPhase(self, vars, evaluator, str): 1904 return _pywrapcp.Solver_EvalEvalStrPhase(self, vars, evaluator, str) 1905 1906 def EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str): 1907 return _pywrapcp.Solver_EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str) 1908 1909 def GuidedLocalSearch(self, *args): 1910 return _pywrapcp.Solver_GuidedLocalSearch(self, *args) 1911 1912 def SumObjectiveFilter(self, vars, values, filter_enum): 1913 return _pywrapcp.Solver_SumObjectiveFilter(self, vars, values, filter_enum) 1914 1915# Register Solver in _pywrapcp: 1916_pywrapcp.Solver_swigregister(Solver) 1917class BaseObject(object): 1918 r""" 1919 A BaseObject is the root of all reversibly allocated objects. 1920 A DebugString method and the associated << operator are implemented 1921 as a convenience. 1922 """ 1923 1924 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 1925 1926 def __init__(self): 1927 if self.__class__ == BaseObject: 1928 _self = None 1929 else: 1930 _self = self 1931 _pywrapcp.BaseObject_swiginit(self, _pywrapcp.new_BaseObject(_self, )) 1932 __swig_destroy__ = _pywrapcp.delete_BaseObject 1933 1934 def DebugString(self): 1935 return _pywrapcp.BaseObject_DebugString(self) 1936 1937 def __str__(self): 1938 return _pywrapcp.BaseObject___str__(self) 1939 1940 def __repr__(self): 1941 return _pywrapcp.BaseObject___repr__(self) 1942 def __disown__(self): 1943 self.this.disown() 1944 _pywrapcp.disown_BaseObject(self) 1945 return weakref.proxy(self) 1946 1947# Register BaseObject in _pywrapcp: 1948_pywrapcp.BaseObject_swigregister(BaseObject) 1949class PropagationBaseObject(BaseObject): 1950 r""" 1951 NOLINT 1952 The PropagationBaseObject is a subclass of BaseObject that is also 1953 friend to the Solver class. It allows accessing methods useful when 1954 writing new constraints or new expressions. 1955 """ 1956 1957 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 1958 __repr__ = _swig_repr 1959 1960 def __init__(self, s): 1961 if self.__class__ == PropagationBaseObject: 1962 _self = None 1963 else: 1964 _self = self 1965 _pywrapcp.PropagationBaseObject_swiginit(self, _pywrapcp.new_PropagationBaseObject(_self, s)) 1966 __swig_destroy__ = _pywrapcp.delete_PropagationBaseObject 1967 1968 def DebugString(self): 1969 return _pywrapcp.PropagationBaseObject_DebugString(self) 1970 1971 def solver(self): 1972 return _pywrapcp.PropagationBaseObject_solver(self) 1973 1974 def Name(self): 1975 r""" Object naming.""" 1976 return _pywrapcp.PropagationBaseObject_Name(self) 1977 def __disown__(self): 1978 self.this.disown() 1979 _pywrapcp.disown_PropagationBaseObject(self) 1980 return weakref.proxy(self) 1981 1982# Register PropagationBaseObject in _pywrapcp: 1983_pywrapcp.PropagationBaseObject_swigregister(PropagationBaseObject) 1984class Decision(BaseObject): 1985 r""" 1986 A Decision represents a choice point in the search tree. The two main 1987 methods are Apply() to go left, or Refute() to go right. 1988 """ 1989 1990 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 1991 1992 def __init__(self): 1993 if self.__class__ == Decision: 1994 _self = None 1995 else: 1996 _self = self 1997 _pywrapcp.Decision_swiginit(self, _pywrapcp.new_Decision(_self, )) 1998 __swig_destroy__ = _pywrapcp.delete_Decision 1999 2000 def ApplyWrapper(self, s): 2001 r""" Apply will be called first when the decision is executed.""" 2002 return _pywrapcp.Decision_ApplyWrapper(self, s) 2003 2004 def RefuteWrapper(self, s): 2005 r""" Refute will be called after a backtrack.""" 2006 return _pywrapcp.Decision_RefuteWrapper(self, s) 2007 2008 def DebugString(self): 2009 return _pywrapcp.Decision_DebugString(self) 2010 2011 def __repr__(self): 2012 return _pywrapcp.Decision___repr__(self) 2013 2014 def __str__(self): 2015 return _pywrapcp.Decision___str__(self) 2016 def __disown__(self): 2017 self.this.disown() 2018 _pywrapcp.disown_Decision(self) 2019 return weakref.proxy(self) 2020 2021# Register Decision in _pywrapcp: 2022_pywrapcp.Decision_swigregister(Decision) 2023class DecisionBuilder(BaseObject): 2024 r""" 2025 A DecisionBuilder is responsible for creating the search tree. The 2026 important method is Next(), which returns the next decision to execute. 2027 """ 2028 2029 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2030 2031 def __init__(self): 2032 if self.__class__ == DecisionBuilder: 2033 _self = None 2034 else: 2035 _self = self 2036 _pywrapcp.DecisionBuilder_swiginit(self, _pywrapcp.new_DecisionBuilder(_self, )) 2037 __swig_destroy__ = _pywrapcp.delete_DecisionBuilder 2038 2039 def NextWrapper(self, s): 2040 r""" 2041 This is the main method of the decision builder class. It must 2042 return a decision (an instance of the class Decision). If it 2043 returns nullptr, this means that the decision builder has finished 2044 its work. 2045 """ 2046 return _pywrapcp.DecisionBuilder_NextWrapper(self, s) 2047 2048 def DebugString(self): 2049 return _pywrapcp.DecisionBuilder_DebugString(self) 2050 2051 def __repr__(self): 2052 return _pywrapcp.DecisionBuilder___repr__(self) 2053 2054 def __str__(self): 2055 return _pywrapcp.DecisionBuilder___str__(self) 2056 def __disown__(self): 2057 self.this.disown() 2058 _pywrapcp.disown_DecisionBuilder(self) 2059 return weakref.proxy(self) 2060 2061# Register DecisionBuilder in _pywrapcp: 2062_pywrapcp.DecisionBuilder_swigregister(DecisionBuilder) 2063class Demon(BaseObject): 2064 r""" 2065 A Demon is the base element of a propagation queue. It is the main 2066 object responsible for implementing the actual propagation 2067 of the constraint and pruning the inconsistent values in the domains 2068 of the variables. The main concept is that demons are listeners that are 2069 attached to the variables and listen to their modifications. 2070 There are two methods: 2071 - Run() is the actual method called when the demon is processed. 2072 - priority() returns its priority. Standard priorities are slow, normal 2073 or fast. "immediate" is reserved for variables and is treated separately. 2074 """ 2075 2076 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2077 __repr__ = _swig_repr 2078 2079 def __init__(self): 2080 r""" 2081 This indicates the priority of a demon. Immediate demons are treated 2082 separately and corresponds to variables. 2083 """ 2084 if self.__class__ == Demon: 2085 _self = None 2086 else: 2087 _self = self 2088 _pywrapcp.Demon_swiginit(self, _pywrapcp.new_Demon(_self, )) 2089 __swig_destroy__ = _pywrapcp.delete_Demon 2090 2091 def RunWrapper(self, s): 2092 r""" This is the main callback of the demon.""" 2093 return _pywrapcp.Demon_RunWrapper(self, s) 2094 2095 def Priority(self): 2096 r""" 2097 This method returns the priority of the demon. Usually a demon is 2098 fast, slow or normal. Immediate demons are reserved for internal 2099 use to maintain variables. 2100 """ 2101 return _pywrapcp.Demon_Priority(self) 2102 2103 def DebugString(self): 2104 return _pywrapcp.Demon_DebugString(self) 2105 2106 def Inhibit(self, s): 2107 r""" 2108 This method inhibits the demon in the search tree below the 2109 current position. 2110 """ 2111 return _pywrapcp.Demon_Inhibit(self, s) 2112 2113 def Desinhibit(self, s): 2114 r""" This method un-inhibits the demon that was previously inhibited.""" 2115 return _pywrapcp.Demon_Desinhibit(self, s) 2116 def __disown__(self): 2117 self.this.disown() 2118 _pywrapcp.disown_Demon(self) 2119 return weakref.proxy(self) 2120 2121# Register Demon in _pywrapcp: 2122_pywrapcp.Demon_swigregister(Demon) 2123class Constraint(PropagationBaseObject): 2124 r""" 2125 A constraint is the main modeling object. It provides two methods: 2126 - Post() is responsible for creating the demons and attaching them to 2127 immediate demons(). 2128 - InitialPropagate() is called once just after Post and performs 2129 the initial propagation. The subsequent propagations will be performed 2130 by the demons Posted during the post() method. 2131 """ 2132 2133 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2134 2135 def __init__(self, solver): 2136 if self.__class__ == Constraint: 2137 _self = None 2138 else: 2139 _self = self 2140 _pywrapcp.Constraint_swiginit(self, _pywrapcp.new_Constraint(_self, solver)) 2141 __swig_destroy__ = _pywrapcp.delete_Constraint 2142 2143 def Post(self): 2144 r""" 2145 This method is called when the constraint is processed by the 2146 solver. Its main usage is to attach demons to variables. 2147 """ 2148 return _pywrapcp.Constraint_Post(self) 2149 2150 def InitialPropagateWrapper(self): 2151 r""" 2152 This method performs the initial propagation of the 2153 constraint. It is called just after the post. 2154 """ 2155 return _pywrapcp.Constraint_InitialPropagateWrapper(self) 2156 2157 def DebugString(self): 2158 return _pywrapcp.Constraint_DebugString(self) 2159 2160 def Var(self): 2161 r""" 2162 Creates a Boolean variable representing the status of the constraint 2163 (false = constraint is violated, true = constraint is satisfied). It 2164 returns nullptr if the constraint does not support this API. 2165 """ 2166 return _pywrapcp.Constraint_Var(self) 2167 2168 def __repr__(self): 2169 return _pywrapcp.Constraint___repr__(self) 2170 2171 def __str__(self): 2172 return _pywrapcp.Constraint___str__(self) 2173 2174 def __add__(self, *args): 2175 return _pywrapcp.Constraint___add__(self, *args) 2176 2177 def __radd__(self, v): 2178 return _pywrapcp.Constraint___radd__(self, v) 2179 2180 def __sub__(self, *args): 2181 return _pywrapcp.Constraint___sub__(self, *args) 2182 2183 def __rsub__(self, v): 2184 return _pywrapcp.Constraint___rsub__(self, v) 2185 2186 def __mul__(self, *args): 2187 return _pywrapcp.Constraint___mul__(self, *args) 2188 2189 def __rmul__(self, v): 2190 return _pywrapcp.Constraint___rmul__(self, v) 2191 2192 def __floordiv__(self, v): 2193 return _pywrapcp.Constraint___floordiv__(self, v) 2194 2195 def __neg__(self): 2196 return _pywrapcp.Constraint___neg__(self) 2197 2198 def __abs__(self): 2199 return _pywrapcp.Constraint___abs__(self) 2200 2201 def Square(self): 2202 return _pywrapcp.Constraint_Square(self) 2203 2204 def __eq__(self, *args): 2205 return _pywrapcp.Constraint___eq__(self, *args) 2206 2207 def __ne__(self, *args): 2208 return _pywrapcp.Constraint___ne__(self, *args) 2209 2210 def __ge__(self, *args): 2211 return _pywrapcp.Constraint___ge__(self, *args) 2212 2213 def __gt__(self, *args): 2214 return _pywrapcp.Constraint___gt__(self, *args) 2215 2216 def __le__(self, *args): 2217 return _pywrapcp.Constraint___le__(self, *args) 2218 2219 def __lt__(self, *args): 2220 return _pywrapcp.Constraint___lt__(self, *args) 2221 2222 def MapTo(self, vars): 2223 return _pywrapcp.Constraint_MapTo(self, vars) 2224 2225 def IndexOf(self, *args): 2226 return _pywrapcp.Constraint_IndexOf(self, *args) 2227 def __disown__(self): 2228 self.this.disown() 2229 _pywrapcp.disown_Constraint(self) 2230 return weakref.proxy(self) 2231 2232# Register Constraint in _pywrapcp: 2233_pywrapcp.Constraint_swigregister(Constraint) 2234class SearchMonitor(BaseObject): 2235 r""" A search monitor is a simple set of callbacks to monitor all search events""" 2236 2237 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2238 kNoProgress = _pywrapcp.SearchMonitor_kNoProgress 2239 2240 def __init__(self, s): 2241 if self.__class__ == SearchMonitor: 2242 _self = None 2243 else: 2244 _self = self 2245 _pywrapcp.SearchMonitor_swiginit(self, _pywrapcp.new_SearchMonitor(_self, s)) 2246 __swig_destroy__ = _pywrapcp.delete_SearchMonitor 2247 2248 def EnterSearch(self): 2249 r""" Beginning of the search.""" 2250 return _pywrapcp.SearchMonitor_EnterSearch(self) 2251 2252 def RestartSearch(self): 2253 r""" Restart the search.""" 2254 return _pywrapcp.SearchMonitor_RestartSearch(self) 2255 2256 def ExitSearch(self): 2257 r""" End of the search.""" 2258 return _pywrapcp.SearchMonitor_ExitSearch(self) 2259 2260 def BeginNextDecision(self, b): 2261 r""" Before calling DecisionBuilder::Next.""" 2262 return _pywrapcp.SearchMonitor_BeginNextDecision(self, b) 2263 2264 def EndNextDecision(self, b, d): 2265 r""" After calling DecisionBuilder::Next, along with the returned decision.""" 2266 return _pywrapcp.SearchMonitor_EndNextDecision(self, b, d) 2267 2268 def ApplyDecision(self, d): 2269 r""" Before applying the decision.""" 2270 return _pywrapcp.SearchMonitor_ApplyDecision(self, d) 2271 2272 def RefuteDecision(self, d): 2273 r""" Before refuting the decision.""" 2274 return _pywrapcp.SearchMonitor_RefuteDecision(self, d) 2275 2276 def AfterDecision(self, d, apply): 2277 r""" 2278 Just after refuting or applying the decision, apply is true after Apply. 2279 This is called only if the Apply() or Refute() methods have not failed. 2280 """ 2281 return _pywrapcp.SearchMonitor_AfterDecision(self, d, apply) 2282 2283 def BeginFail(self): 2284 r""" Just when the failure occurs.""" 2285 return _pywrapcp.SearchMonitor_BeginFail(self) 2286 2287 def EndFail(self): 2288 r""" After completing the backtrack.""" 2289 return _pywrapcp.SearchMonitor_EndFail(self) 2290 2291 def BeginInitialPropagation(self): 2292 r""" Before the initial propagation.""" 2293 return _pywrapcp.SearchMonitor_BeginInitialPropagation(self) 2294 2295 def EndInitialPropagation(self): 2296 r""" After the initial propagation.""" 2297 return _pywrapcp.SearchMonitor_EndInitialPropagation(self) 2298 2299 def AcceptSolution(self): 2300 r""" 2301 This method is called when a solution is found. It asserts whether the 2302 solution is valid. A value of false indicates that the solution 2303 should be discarded. 2304 """ 2305 return _pywrapcp.SearchMonitor_AcceptSolution(self) 2306 2307 def AtSolution(self): 2308 r""" 2309 This method is called when a valid solution is found. If the 2310 return value is true, then search will resume after. If the result 2311 is false, then search will stop there. 2312 """ 2313 return _pywrapcp.SearchMonitor_AtSolution(self) 2314 2315 def NoMoreSolutions(self): 2316 r""" When the search tree is finished.""" 2317 return _pywrapcp.SearchMonitor_NoMoreSolutions(self) 2318 2319 def LocalOptimum(self): 2320 r""" 2321 When a local optimum is reached. If 'true' is returned, the last solution 2322 is discarded and the search proceeds with the next one. 2323 """ 2324 return _pywrapcp.SearchMonitor_LocalOptimum(self) 2325 2326 def AcceptDelta(self, delta, deltadelta): 2327 2328 return _pywrapcp.SearchMonitor_AcceptDelta(self, delta, deltadelta) 2329 2330 def AcceptNeighbor(self): 2331 r""" After accepting a neighbor during local search.""" 2332 return _pywrapcp.SearchMonitor_AcceptNeighbor(self) 2333 2334 def ProgressPercent(self): 2335 r""" 2336 Returns a percentage representing the propress of the search before 2337 reaching limits. 2338 """ 2339 return _pywrapcp.SearchMonitor_ProgressPercent(self) 2340 2341 def solver(self): 2342 return _pywrapcp.SearchMonitor_solver(self) 2343 2344 def __repr__(self): 2345 return _pywrapcp.SearchMonitor___repr__(self) 2346 2347 def __str__(self): 2348 return _pywrapcp.SearchMonitor___str__(self) 2349 def __disown__(self): 2350 self.this.disown() 2351 _pywrapcp.disown_SearchMonitor(self) 2352 return weakref.proxy(self) 2353 2354# Register SearchMonitor in _pywrapcp: 2355_pywrapcp.SearchMonitor_swigregister(SearchMonitor) 2356class IntExpr(PropagationBaseObject): 2357 r""" 2358 The class IntExpr is the base of all integer expressions in 2359 constraint programming. 2360 It contains the basic protocol for an expression: 2361 - setting and modifying its bound 2362 - querying if it is bound 2363 - listening to events modifying its bounds 2364 - casting it into a variable (instance of IntVar) 2365 """ 2366 2367 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2368 2369 def __init__(self, *args, **kwargs): 2370 raise AttributeError("No constructor defined - class is abstract") 2371 2372 def Min(self): 2373 return _pywrapcp.IntExpr_Min(self) 2374 2375 def SetMin(self, m): 2376 return _pywrapcp.IntExpr_SetMin(self, m) 2377 2378 def Max(self): 2379 return _pywrapcp.IntExpr_Max(self) 2380 2381 def SetMax(self, m): 2382 return _pywrapcp.IntExpr_SetMax(self, m) 2383 2384 def SetRange(self, l, u): 2385 r""" This method sets both the min and the max of the expression.""" 2386 return _pywrapcp.IntExpr_SetRange(self, l, u) 2387 2388 def SetValue(self, v): 2389 r""" This method sets the value of the expression.""" 2390 return _pywrapcp.IntExpr_SetValue(self, v) 2391 2392 def Bound(self): 2393 r""" Returns true if the min and the max of the expression are equal.""" 2394 return _pywrapcp.IntExpr_Bound(self) 2395 2396 def IsVar(self): 2397 r""" Returns true if the expression is indeed a variable.""" 2398 return _pywrapcp.IntExpr_IsVar(self) 2399 2400 def Var(self): 2401 r""" Creates a variable from the expression.""" 2402 return _pywrapcp.IntExpr_Var(self) 2403 2404 def VarWithName(self, name): 2405 r""" 2406 Creates a variable from the expression and set the name of the 2407 resulting var. If the expression is already a variable, then it 2408 will set the name of the expression, possibly overwriting it. 2409 This is just a shortcut to Var() followed by set_name(). 2410 """ 2411 return _pywrapcp.IntExpr_VarWithName(self, name) 2412 2413 def WhenRange(self, *args): 2414 r""" 2415 *Overload 1:* 2416 Attach a demon that will watch the min or the max of the expression. 2417 2418 | 2419 2420 *Overload 2:* 2421 Attach a demon that will watch the min or the max of the expression. 2422 """ 2423 return _pywrapcp.IntExpr_WhenRange(self, *args) 2424 2425 def __repr__(self): 2426 return _pywrapcp.IntExpr___repr__(self) 2427 2428 def __str__(self): 2429 return _pywrapcp.IntExpr___str__(self) 2430 2431 def __add__(self, *args): 2432 return _pywrapcp.IntExpr___add__(self, *args) 2433 2434 def __radd__(self, v): 2435 return _pywrapcp.IntExpr___radd__(self, v) 2436 2437 def __sub__(self, *args): 2438 return _pywrapcp.IntExpr___sub__(self, *args) 2439 2440 def __rsub__(self, v): 2441 return _pywrapcp.IntExpr___rsub__(self, v) 2442 2443 def __mul__(self, *args): 2444 return _pywrapcp.IntExpr___mul__(self, *args) 2445 2446 def __rmul__(self, v): 2447 return _pywrapcp.IntExpr___rmul__(self, v) 2448 2449 def __floordiv__(self, *args): 2450 return _pywrapcp.IntExpr___floordiv__(self, *args) 2451 2452 def __mod__(self, *args): 2453 return _pywrapcp.IntExpr___mod__(self, *args) 2454 2455 def __neg__(self): 2456 return _pywrapcp.IntExpr___neg__(self) 2457 2458 def __abs__(self): 2459 return _pywrapcp.IntExpr___abs__(self) 2460 2461 def Square(self): 2462 return _pywrapcp.IntExpr_Square(self) 2463 2464 def __eq__(self, *args): 2465 return _pywrapcp.IntExpr___eq__(self, *args) 2466 2467 def __ne__(self, *args): 2468 return _pywrapcp.IntExpr___ne__(self, *args) 2469 2470 def __ge__(self, *args): 2471 return _pywrapcp.IntExpr___ge__(self, *args) 2472 2473 def __gt__(self, *args): 2474 return _pywrapcp.IntExpr___gt__(self, *args) 2475 2476 def __le__(self, *args): 2477 return _pywrapcp.IntExpr___le__(self, *args) 2478 2479 def __lt__(self, *args): 2480 return _pywrapcp.IntExpr___lt__(self, *args) 2481 2482 def MapTo(self, vars): 2483 return _pywrapcp.IntExpr_MapTo(self, vars) 2484 2485 def IndexOf(self, *args): 2486 return _pywrapcp.IntExpr_IndexOf(self, *args) 2487 2488 def IsMember(self, values): 2489 return _pywrapcp.IntExpr_IsMember(self, values) 2490 2491 def Member(self, values): 2492 return _pywrapcp.IntExpr_Member(self, values) 2493 2494 def NotMember(self, starts, ends): 2495 return _pywrapcp.IntExpr_NotMember(self, starts, ends) 2496 2497# Register IntExpr in _pywrapcp: 2498_pywrapcp.IntExpr_swigregister(IntExpr) 2499class IntVarIterator(BaseObject): 2500 r""" 2501 The class Iterator has two direct subclasses. HoleIterators 2502 iterates over all holes, that is value removed between the 2503 current min and max of the variable since the last time the 2504 variable was processed in the queue. DomainIterators iterates 2505 over all elements of the variable domain. Both iterators are not 2506 robust to domain changes. Hole iterators can also report values outside 2507 the current min and max of the variable. 2508 HoleIterators should only be called from a demon attached to the 2509 variable that has created this iterator. 2510 IntVar* current_var; 2511 std::unique_ptr<IntVarIterator> it(current_var->MakeHoleIterator(false)); 2512 for (const int64_t hole : InitAndGetValues(it)) { 2513 use the hole 2514 } 2515 """ 2516 2517 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2518 2519 def __init__(self, *args, **kwargs): 2520 raise AttributeError("No constructor defined - class is abstract") 2521 __repr__ = _swig_repr 2522 2523 def Init(self): 2524 r""" This method must be called before each loop.""" 2525 return _pywrapcp.IntVarIterator_Init(self) 2526 2527 def Ok(self): 2528 r""" This method indicates if we can call Value() or not.""" 2529 return _pywrapcp.IntVarIterator_Ok(self) 2530 2531 def Value(self): 2532 r""" This method returns the current value of the iterator.""" 2533 return _pywrapcp.IntVarIterator_Value(self) 2534 2535 def Next(self): 2536 r""" This method moves the iterator to the next value.""" 2537 return _pywrapcp.IntVarIterator_Next(self) 2538 2539 def DebugString(self): 2540 r""" Pretty Print.""" 2541 return _pywrapcp.IntVarIterator_DebugString(self) 2542 2543 def __iter__(self): 2544 self.Init() 2545 return self 2546 2547 def next(self): 2548 if self.Ok(): 2549 result = self.Value() 2550 self.Next() 2551 return result 2552 else: 2553 raise StopIteration() 2554 2555 def __next__(self): 2556 return self.next() 2557 2558 2559# Register IntVarIterator in _pywrapcp: 2560_pywrapcp.IntVarIterator_swigregister(IntVarIterator) 2561class IntVar(IntExpr): 2562 r""" 2563 The class IntVar is a subset of IntExpr. In addition to the 2564 IntExpr protocol, it offers persistence, removing values from the domains, 2565 and a finer model for events. 2566 """ 2567 2568 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2569 2570 def __init__(self, *args, **kwargs): 2571 raise AttributeError("No constructor defined - class is abstract") 2572 2573 def IsVar(self): 2574 return _pywrapcp.IntVar_IsVar(self) 2575 2576 def Var(self): 2577 return _pywrapcp.IntVar_Var(self) 2578 2579 def Value(self): 2580 r""" 2581 This method returns the value of the variable. This method checks 2582 before that the variable is bound. 2583 """ 2584 return _pywrapcp.IntVar_Value(self) 2585 2586 def RemoveValue(self, v): 2587 r""" This method removes the value 'v' from the domain of the variable.""" 2588 return _pywrapcp.IntVar_RemoveValue(self, v) 2589 2590 def RemoveInterval(self, l, u): 2591 r""" 2592 This method removes the interval 'l' .. 'u' from the domain of 2593 the variable. It assumes that 'l' <= 'u'. 2594 """ 2595 return _pywrapcp.IntVar_RemoveInterval(self, l, u) 2596 2597 def RemoveValues(self, values): 2598 r""" This method remove the values from the domain of the variable.""" 2599 return _pywrapcp.IntVar_RemoveValues(self, values) 2600 2601 def SetValues(self, values): 2602 r""" This method intersects the current domain with the values in the array.""" 2603 return _pywrapcp.IntVar_SetValues(self, values) 2604 2605 def WhenBound(self, *args): 2606 r""" 2607 *Overload 1:* 2608 This method attaches a demon that will be awakened when the 2609 variable is bound. 2610 2611 | 2612 2613 *Overload 2:* 2614 This method attaches a closure that will be awakened when the 2615 variable is bound. 2616 """ 2617 return _pywrapcp.IntVar_WhenBound(self, *args) 2618 2619 def WhenDomain(self, *args): 2620 r""" 2621 *Overload 1:* 2622 This method attaches a demon that will watch any domain 2623 modification of the domain of the variable. 2624 2625 | 2626 2627 *Overload 2:* 2628 This method attaches a closure that will watch any domain 2629 modification of the domain of the variable. 2630 """ 2631 return _pywrapcp.IntVar_WhenDomain(self, *args) 2632 2633 def Size(self): 2634 r""" This method returns the number of values in the domain of the variable.""" 2635 return _pywrapcp.IntVar_Size(self) 2636 2637 def Contains(self, v): 2638 r""" 2639 This method returns whether the value 'v' is in the domain of the 2640 variable. 2641 """ 2642 return _pywrapcp.IntVar_Contains(self, v) 2643 2644 def HoleIteratorAux(self, reversible): 2645 r""" 2646 Creates a hole iterator. When 'reversible' is false, the returned 2647 object is created on the normal C++ heap and the solver does NOT 2648 take ownership of the object. 2649 """ 2650 return _pywrapcp.IntVar_HoleIteratorAux(self, reversible) 2651 2652 def DomainIteratorAux(self, reversible): 2653 r""" 2654 Creates a domain iterator. When 'reversible' is false, the 2655 returned object is created on the normal C++ heap and the solver 2656 does NOT take ownership of the object. 2657 """ 2658 return _pywrapcp.IntVar_DomainIteratorAux(self, reversible) 2659 2660 def OldMin(self): 2661 r""" Returns the previous min.""" 2662 return _pywrapcp.IntVar_OldMin(self) 2663 2664 def OldMax(self): 2665 r""" Returns the previous max.""" 2666 return _pywrapcp.IntVar_OldMax(self) 2667 2668 def __repr__(self): 2669 return _pywrapcp.IntVar___repr__(self) 2670 2671 def __str__(self): 2672 return _pywrapcp.IntVar___str__(self) 2673 2674 def DomainIterator(self): 2675 return iter(self.DomainIteratorAux(False)) 2676 2677 def HoleIterator(self): 2678 return iter(self.HoleIteratorAux(False)) 2679 2680 2681# Register IntVar in _pywrapcp: 2682_pywrapcp.IntVar_swigregister(IntVar) 2683class SolutionCollector(SearchMonitor): 2684 r""" 2685 This class is the root class of all solution collectors. 2686 It implements a basic query API to be used independently 2687 of the collector used. 2688 """ 2689 2690 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2691 2692 def __init__(self, *args, **kwargs): 2693 raise AttributeError("No constructor defined") 2694 __repr__ = _swig_repr 2695 2696 def DebugString(self): 2697 return _pywrapcp.SolutionCollector_DebugString(self) 2698 2699 def Add(self, *args): 2700 return _pywrapcp.SolutionCollector_Add(self, *args) 2701 2702 def AddObjective(self, objective): 2703 return _pywrapcp.SolutionCollector_AddObjective(self, objective) 2704 2705 def EnterSearch(self): 2706 r""" Beginning of the search.""" 2707 return _pywrapcp.SolutionCollector_EnterSearch(self) 2708 2709 def SolutionCount(self): 2710 r""" Returns how many solutions were stored during the search.""" 2711 return _pywrapcp.SolutionCollector_SolutionCount(self) 2712 2713 def Solution(self, n): 2714 r""" Returns the nth solution.""" 2715 return _pywrapcp.SolutionCollector_Solution(self, n) 2716 2717 def WallTime(self, n): 2718 r""" Returns the wall time in ms for the nth solution.""" 2719 return _pywrapcp.SolutionCollector_WallTime(self, n) 2720 2721 def Branches(self, n): 2722 r""" Returns the number of branches when the nth solution was found.""" 2723 return _pywrapcp.SolutionCollector_Branches(self, n) 2724 2725 def Failures(self, n): 2726 r""" 2727 Returns the number of failures encountered at the time of the nth 2728 solution. 2729 """ 2730 return _pywrapcp.SolutionCollector_Failures(self, n) 2731 2732 def ObjectiveValue(self, n): 2733 r""" Returns the objective value of the nth solution.""" 2734 return _pywrapcp.SolutionCollector_ObjectiveValue(self, n) 2735 2736 def Value(self, n, var): 2737 r""" This is a shortcut to get the Value of 'var' in the nth solution.""" 2738 return _pywrapcp.SolutionCollector_Value(self, n, var) 2739 2740 def StartValue(self, n, var): 2741 r""" This is a shortcut to get the StartValue of 'var' in the nth solution.""" 2742 return _pywrapcp.SolutionCollector_StartValue(self, n, var) 2743 2744 def EndValue(self, n, var): 2745 r""" This is a shortcut to get the EndValue of 'var' in the nth solution.""" 2746 return _pywrapcp.SolutionCollector_EndValue(self, n, var) 2747 2748 def DurationValue(self, n, var): 2749 r""" This is a shortcut to get the DurationValue of 'var' in the nth solution.""" 2750 return _pywrapcp.SolutionCollector_DurationValue(self, n, var) 2751 2752 def PerformedValue(self, n, var): 2753 r""" This is a shortcut to get the PerformedValue of 'var' in the nth solution.""" 2754 return _pywrapcp.SolutionCollector_PerformedValue(self, n, var) 2755 2756 def ForwardSequence(self, n, var): 2757 r""" 2758 This is a shortcut to get the ForwardSequence of 'var' in the 2759 nth solution. The forward sequence is the list of ranked interval 2760 variables starting from the start of the sequence. 2761 """ 2762 return _pywrapcp.SolutionCollector_ForwardSequence(self, n, var) 2763 2764 def BackwardSequence(self, n, var): 2765 r""" 2766 This is a shortcut to get the BackwardSequence of 'var' in the 2767 nth solution. The backward sequence is the list of ranked interval 2768 variables starting from the end of the sequence. 2769 """ 2770 return _pywrapcp.SolutionCollector_BackwardSequence(self, n, var) 2771 2772 def Unperformed(self, n, var): 2773 r""" 2774 This is a shortcut to get the list of unperformed of 'var' in the 2775 nth solution. 2776 """ 2777 return _pywrapcp.SolutionCollector_Unperformed(self, n, var) 2778 2779# Register SolutionCollector in _pywrapcp: 2780_pywrapcp.SolutionCollector_swigregister(SolutionCollector) 2781class OptimizeVar(object): 2782 r""" 2783 This class encapsulates an objective. It requires the direction 2784 (minimize or maximize), the variable to optimize, and the 2785 improvement step. 2786 """ 2787 2788 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2789 2790 def __init__(self, *args, **kwargs): 2791 raise AttributeError("No constructor defined") 2792 __repr__ = _swig_repr 2793 2794 def Best(self): 2795 r""" Returns the best value found during search.""" 2796 return _pywrapcp.OptimizeVar_Best(self) 2797 2798 def BeginNextDecision(self, db): 2799 r""" Internal methods.""" 2800 return _pywrapcp.OptimizeVar_BeginNextDecision(self, db) 2801 2802 def RefuteDecision(self, d): 2803 return _pywrapcp.OptimizeVar_RefuteDecision(self, d) 2804 2805 def AtSolution(self): 2806 return _pywrapcp.OptimizeVar_AtSolution(self) 2807 2808 def AcceptSolution(self): 2809 return _pywrapcp.OptimizeVar_AcceptSolution(self) 2810 2811 def DebugString(self): 2812 return _pywrapcp.OptimizeVar_DebugString(self) 2813 __swig_destroy__ = _pywrapcp.delete_OptimizeVar 2814 2815# Register OptimizeVar in _pywrapcp: 2816_pywrapcp.OptimizeVar_swigregister(OptimizeVar) 2817class SearchLimit(SearchMonitor): 2818 r""" Base class of all search limits.""" 2819 2820 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2821 2822 def __init__(self, *args, **kwargs): 2823 raise AttributeError("No constructor defined - class is abstract") 2824 __repr__ = _swig_repr 2825 __swig_destroy__ = _pywrapcp.delete_SearchLimit 2826 2827 def Crossed(self): 2828 r""" Returns true if the limit has been crossed.""" 2829 return _pywrapcp.SearchLimit_Crossed(self) 2830 2831 def Check(self): 2832 r""" 2833 This method is called to check the status of the limit. A return 2834 value of true indicates that we have indeed crossed the limit. In 2835 that case, this method will not be called again and the remaining 2836 search will be discarded. 2837 """ 2838 return _pywrapcp.SearchLimit_Check(self) 2839 2840 def Init(self): 2841 r""" This method is called when the search limit is initialized.""" 2842 return _pywrapcp.SearchLimit_Init(self) 2843 2844 def EnterSearch(self): 2845 r""" Internal methods.""" 2846 return _pywrapcp.SearchLimit_EnterSearch(self) 2847 2848 def BeginNextDecision(self, b): 2849 return _pywrapcp.SearchLimit_BeginNextDecision(self, b) 2850 2851 def RefuteDecision(self, d): 2852 return _pywrapcp.SearchLimit_RefuteDecision(self, d) 2853 2854 def DebugString(self): 2855 return _pywrapcp.SearchLimit_DebugString(self) 2856 2857# Register SearchLimit in _pywrapcp: 2858_pywrapcp.SearchLimit_swigregister(SearchLimit) 2859class IntervalVar(PropagationBaseObject): 2860 r""" 2861 Interval variables are often used in scheduling. The main characteristics 2862 of an IntervalVar are the start position, duration, and end 2863 date. All these characteristics can be queried and set, and demons can 2864 be posted on their modifications. 2865 2866 An important aspect is optionality: an IntervalVar can be performed or not. 2867 If unperformed, then it simply does not exist, and its characteristics 2868 cannot be accessed any more. An interval var is automatically marked 2869 as unperformed when it is not consistent anymore (start greater 2870 than end, duration < 0...) 2871 """ 2872 2873 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2874 2875 def __init__(self, *args, **kwargs): 2876 raise AttributeError("No constructor defined - class is abstract") 2877 2878 def StartMin(self): 2879 r""" 2880 These methods query, set, and watch the start position of the 2881 interval var. 2882 """ 2883 return _pywrapcp.IntervalVar_StartMin(self) 2884 2885 def StartMax(self): 2886 return _pywrapcp.IntervalVar_StartMax(self) 2887 2888 def SetStartMin(self, m): 2889 return _pywrapcp.IntervalVar_SetStartMin(self, m) 2890 2891 def SetStartMax(self, m): 2892 return _pywrapcp.IntervalVar_SetStartMax(self, m) 2893 2894 def SetStartRange(self, mi, ma): 2895 return _pywrapcp.IntervalVar_SetStartRange(self, mi, ma) 2896 2897 def OldStartMin(self): 2898 return _pywrapcp.IntervalVar_OldStartMin(self) 2899 2900 def OldStartMax(self): 2901 return _pywrapcp.IntervalVar_OldStartMax(self) 2902 2903 def WhenStartRange(self, *args): 2904 return _pywrapcp.IntervalVar_WhenStartRange(self, *args) 2905 2906 def WhenStartBound(self, *args): 2907 return _pywrapcp.IntervalVar_WhenStartBound(self, *args) 2908 2909 def DurationMin(self): 2910 r""" These methods query, set, and watch the duration of the interval var.""" 2911 return _pywrapcp.IntervalVar_DurationMin(self) 2912 2913 def DurationMax(self): 2914 return _pywrapcp.IntervalVar_DurationMax(self) 2915 2916 def SetDurationMin(self, m): 2917 return _pywrapcp.IntervalVar_SetDurationMin(self, m) 2918 2919 def SetDurationMax(self, m): 2920 return _pywrapcp.IntervalVar_SetDurationMax(self, m) 2921 2922 def SetDurationRange(self, mi, ma): 2923 return _pywrapcp.IntervalVar_SetDurationRange(self, mi, ma) 2924 2925 def OldDurationMin(self): 2926 return _pywrapcp.IntervalVar_OldDurationMin(self) 2927 2928 def OldDurationMax(self): 2929 return _pywrapcp.IntervalVar_OldDurationMax(self) 2930 2931 def WhenDurationRange(self, *args): 2932 return _pywrapcp.IntervalVar_WhenDurationRange(self, *args) 2933 2934 def WhenDurationBound(self, *args): 2935 return _pywrapcp.IntervalVar_WhenDurationBound(self, *args) 2936 2937 def EndMin(self): 2938 r""" These methods query, set, and watch the end position of the interval var.""" 2939 return _pywrapcp.IntervalVar_EndMin(self) 2940 2941 def EndMax(self): 2942 return _pywrapcp.IntervalVar_EndMax(self) 2943 2944 def SetEndMin(self, m): 2945 return _pywrapcp.IntervalVar_SetEndMin(self, m) 2946 2947 def SetEndMax(self, m): 2948 return _pywrapcp.IntervalVar_SetEndMax(self, m) 2949 2950 def SetEndRange(self, mi, ma): 2951 return _pywrapcp.IntervalVar_SetEndRange(self, mi, ma) 2952 2953 def OldEndMin(self): 2954 return _pywrapcp.IntervalVar_OldEndMin(self) 2955 2956 def OldEndMax(self): 2957 return _pywrapcp.IntervalVar_OldEndMax(self) 2958 2959 def WhenEndRange(self, *args): 2960 return _pywrapcp.IntervalVar_WhenEndRange(self, *args) 2961 2962 def WhenEndBound(self, *args): 2963 return _pywrapcp.IntervalVar_WhenEndBound(self, *args) 2964 2965 def MustBePerformed(self): 2966 r""" 2967 These methods query, set, and watch the performed status of the 2968 interval var. 2969 """ 2970 return _pywrapcp.IntervalVar_MustBePerformed(self) 2971 2972 def MayBePerformed(self): 2973 return _pywrapcp.IntervalVar_MayBePerformed(self) 2974 2975 def CannotBePerformed(self): 2976 return _pywrapcp.IntervalVar_CannotBePerformed(self) 2977 2978 def IsPerformedBound(self): 2979 return _pywrapcp.IntervalVar_IsPerformedBound(self) 2980 2981 def SetPerformed(self, val): 2982 return _pywrapcp.IntervalVar_SetPerformed(self, val) 2983 2984 def WasPerformedBound(self): 2985 return _pywrapcp.IntervalVar_WasPerformedBound(self) 2986 2987 def WhenPerformedBound(self, *args): 2988 return _pywrapcp.IntervalVar_WhenPerformedBound(self, *args) 2989 2990 def WhenAnything(self, *args): 2991 r""" 2992 *Overload 1:* 2993 Attaches a demon awakened when anything about this interval changes. 2994 2995 | 2996 2997 *Overload 2:* 2998 Attaches a closure awakened when anything about this interval changes. 2999 """ 3000 return _pywrapcp.IntervalVar_WhenAnything(self, *args) 3001 3002 def StartExpr(self): 3003 r""" 3004 These methods create expressions encapsulating the start, end 3005 and duration of the interval var. Please note that these must not 3006 be used if the interval var is unperformed. 3007 """ 3008 return _pywrapcp.IntervalVar_StartExpr(self) 3009 3010 def DurationExpr(self): 3011 return _pywrapcp.IntervalVar_DurationExpr(self) 3012 3013 def EndExpr(self): 3014 return _pywrapcp.IntervalVar_EndExpr(self) 3015 3016 def PerformedExpr(self): 3017 return _pywrapcp.IntervalVar_PerformedExpr(self) 3018 3019 def SafeStartExpr(self, unperformed_value): 3020 r""" 3021 These methods create expressions encapsulating the start, end 3022 and duration of the interval var. If the interval var is 3023 unperformed, they will return the unperformed_value. 3024 """ 3025 return _pywrapcp.IntervalVar_SafeStartExpr(self, unperformed_value) 3026 3027 def SafeDurationExpr(self, unperformed_value): 3028 return _pywrapcp.IntervalVar_SafeDurationExpr(self, unperformed_value) 3029 3030 def SafeEndExpr(self, unperformed_value): 3031 return _pywrapcp.IntervalVar_SafeEndExpr(self, unperformed_value) 3032 3033 def EndsAfterEnd(self, other): 3034 return _pywrapcp.IntervalVar_EndsAfterEnd(self, other) 3035 3036 def EndsAfterEndWithDelay(self, other, delay): 3037 return _pywrapcp.IntervalVar_EndsAfterEndWithDelay(self, other, delay) 3038 3039 def EndsAfterStart(self, other): 3040 return _pywrapcp.IntervalVar_EndsAfterStart(self, other) 3041 3042 def EndsAfterStartWithDelay(self, other, delay): 3043 return _pywrapcp.IntervalVar_EndsAfterStartWithDelay(self, other, delay) 3044 3045 def EndsAtEnd(self, other): 3046 return _pywrapcp.IntervalVar_EndsAtEnd(self, other) 3047 3048 def EndsAtEndWithDelay(self, other, delay): 3049 return _pywrapcp.IntervalVar_EndsAtEndWithDelay(self, other, delay) 3050 3051 def EndsAtStart(self, other): 3052 return _pywrapcp.IntervalVar_EndsAtStart(self, other) 3053 3054 def EndsAtStartWithDelay(self, other, delay): 3055 return _pywrapcp.IntervalVar_EndsAtStartWithDelay(self, other, delay) 3056 3057 def StartsAfterEnd(self, other): 3058 return _pywrapcp.IntervalVar_StartsAfterEnd(self, other) 3059 3060 def StartsAfterEndWithDelay(self, other, delay): 3061 return _pywrapcp.IntervalVar_StartsAfterEndWithDelay(self, other, delay) 3062 3063 def StartsAfterStart(self, other): 3064 return _pywrapcp.IntervalVar_StartsAfterStart(self, other) 3065 3066 def StartsAfterStartWithDelay(self, other, delay): 3067 return _pywrapcp.IntervalVar_StartsAfterStartWithDelay(self, other, delay) 3068 3069 def StartsAtEnd(self, other): 3070 return _pywrapcp.IntervalVar_StartsAtEnd(self, other) 3071 3072 def StartsAtEndWithDelay(self, other, delay): 3073 return _pywrapcp.IntervalVar_StartsAtEndWithDelay(self, other, delay) 3074 3075 def StartsAtStart(self, other): 3076 return _pywrapcp.IntervalVar_StartsAtStart(self, other) 3077 3078 def StartsAtStartWithDelay(self, other, delay): 3079 return _pywrapcp.IntervalVar_StartsAtStartWithDelay(self, other, delay) 3080 3081 def StaysInSync(self, other): 3082 return _pywrapcp.IntervalVar_StaysInSync(self, other) 3083 3084 def StaysInSyncWithDelay(self, other, delay): 3085 return _pywrapcp.IntervalVar_StaysInSyncWithDelay(self, other, delay) 3086 3087 def EndsAfter(self, date): 3088 return _pywrapcp.IntervalVar_EndsAfter(self, date) 3089 3090 def EndsAt(self, date): 3091 return _pywrapcp.IntervalVar_EndsAt(self, date) 3092 3093 def EndsBefore(self, date): 3094 return _pywrapcp.IntervalVar_EndsBefore(self, date) 3095 3096 def StartsAfter(self, date): 3097 return _pywrapcp.IntervalVar_StartsAfter(self, date) 3098 3099 def StartsAt(self, date): 3100 return _pywrapcp.IntervalVar_StartsAt(self, date) 3101 3102 def StartsBefore(self, date): 3103 return _pywrapcp.IntervalVar_StartsBefore(self, date) 3104 3105 def CrossesDate(self, date): 3106 return _pywrapcp.IntervalVar_CrossesDate(self, date) 3107 3108 def AvoidsDate(self, date): 3109 return _pywrapcp.IntervalVar_AvoidsDate(self, date) 3110 3111 def __repr__(self): 3112 return _pywrapcp.IntervalVar___repr__(self) 3113 3114 def __str__(self): 3115 return _pywrapcp.IntervalVar___str__(self) 3116 3117# Register IntervalVar in _pywrapcp: 3118_pywrapcp.IntervalVar_swigregister(IntervalVar) 3119class SequenceVar(PropagationBaseObject): 3120 r""" 3121 A sequence variable is a variable whose domain is a set of possible 3122 orderings of the interval variables. It allows ordering of tasks. It 3123 has two sets of methods: ComputePossibleFirstsAndLasts(), which 3124 returns the list of interval variables that can be ranked first or 3125 last; and RankFirst/RankNotFirst/RankLast/RankNotLast, which can be 3126 used to create the search decision. 3127 """ 3128 3129 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3130 3131 def __init__(self, *args, **kwargs): 3132 raise AttributeError("No constructor defined") 3133 3134 def DebugString(self): 3135 return _pywrapcp.SequenceVar_DebugString(self) 3136 3137 def RankFirst(self, index): 3138 r""" 3139 Ranks the index_th interval var first of all unranked interval 3140 vars. After that, it will no longer be considered ranked. 3141 """ 3142 return _pywrapcp.SequenceVar_RankFirst(self, index) 3143 3144 def RankNotFirst(self, index): 3145 r""" 3146 Indicates that the index_th interval var will not be ranked first 3147 of all currently unranked interval vars. 3148 """ 3149 return _pywrapcp.SequenceVar_RankNotFirst(self, index) 3150 3151 def RankLast(self, index): 3152 r""" 3153 Ranks the index_th interval var first of all unranked interval 3154 vars. After that, it will no longer be considered ranked. 3155 """ 3156 return _pywrapcp.SequenceVar_RankLast(self, index) 3157 3158 def RankNotLast(self, index): 3159 r""" 3160 Indicates that the index_th interval var will not be ranked first 3161 of all currently unranked interval vars. 3162 """ 3163 return _pywrapcp.SequenceVar_RankNotLast(self, index) 3164 3165 def Interval(self, index): 3166 r""" Returns the index_th interval of the sequence.""" 3167 return _pywrapcp.SequenceVar_Interval(self, index) 3168 3169 def Next(self, index): 3170 r""" Returns the next of the index_th interval of the sequence.""" 3171 return _pywrapcp.SequenceVar_Next(self, index) 3172 3173 def Size(self): 3174 r""" Returns the number of interval vars in the sequence.""" 3175 return _pywrapcp.SequenceVar_Size(self) 3176 3177 def __repr__(self): 3178 return _pywrapcp.SequenceVar___repr__(self) 3179 3180 def __str__(self): 3181 return _pywrapcp.SequenceVar___str__(self) 3182 3183# Register SequenceVar in _pywrapcp: 3184_pywrapcp.SequenceVar_swigregister(SequenceVar) 3185class AssignmentElement(object): 3186 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3187 3188 def __init__(self, *args, **kwargs): 3189 raise AttributeError("No constructor defined") 3190 __repr__ = _swig_repr 3191 3192 def Activate(self): 3193 return _pywrapcp.AssignmentElement_Activate(self) 3194 3195 def Deactivate(self): 3196 return _pywrapcp.AssignmentElement_Deactivate(self) 3197 3198 def Activated(self): 3199 return _pywrapcp.AssignmentElement_Activated(self) 3200 __swig_destroy__ = _pywrapcp.delete_AssignmentElement 3201 3202# Register AssignmentElement in _pywrapcp: 3203_pywrapcp.AssignmentElement_swigregister(AssignmentElement) 3204class IntVarElement(AssignmentElement): 3205 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3206 3207 def __init__(self, *args, **kwargs): 3208 raise AttributeError("No constructor defined") 3209 __repr__ = _swig_repr 3210 3211 def Var(self): 3212 return _pywrapcp.IntVarElement_Var(self) 3213 3214 def Min(self): 3215 return _pywrapcp.IntVarElement_Min(self) 3216 3217 def SetMin(self, m): 3218 return _pywrapcp.IntVarElement_SetMin(self, m) 3219 3220 def Max(self): 3221 return _pywrapcp.IntVarElement_Max(self) 3222 3223 def SetMax(self, m): 3224 return _pywrapcp.IntVarElement_SetMax(self, m) 3225 3226 def Value(self): 3227 return _pywrapcp.IntVarElement_Value(self) 3228 3229 def Bound(self): 3230 return _pywrapcp.IntVarElement_Bound(self) 3231 3232 def SetRange(self, l, u): 3233 return _pywrapcp.IntVarElement_SetRange(self, l, u) 3234 3235 def SetValue(self, v): 3236 return _pywrapcp.IntVarElement_SetValue(self, v) 3237 3238 def __eq__(self, element): 3239 return _pywrapcp.IntVarElement___eq__(self, element) 3240 3241 def __ne__(self, element): 3242 return _pywrapcp.IntVarElement___ne__(self, element) 3243 __swig_destroy__ = _pywrapcp.delete_IntVarElement 3244 3245# Register IntVarElement in _pywrapcp: 3246_pywrapcp.IntVarElement_swigregister(IntVarElement) 3247class IntervalVarElement(AssignmentElement): 3248 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3249 3250 def __init__(self, *args, **kwargs): 3251 raise AttributeError("No constructor defined") 3252 __repr__ = _swig_repr 3253 3254 def Var(self): 3255 return _pywrapcp.IntervalVarElement_Var(self) 3256 3257 def StartMin(self): 3258 return _pywrapcp.IntervalVarElement_StartMin(self) 3259 3260 def StartMax(self): 3261 return _pywrapcp.IntervalVarElement_StartMax(self) 3262 3263 def StartValue(self): 3264 return _pywrapcp.IntervalVarElement_StartValue(self) 3265 3266 def DurationMin(self): 3267 return _pywrapcp.IntervalVarElement_DurationMin(self) 3268 3269 def DurationMax(self): 3270 return _pywrapcp.IntervalVarElement_DurationMax(self) 3271 3272 def DurationValue(self): 3273 return _pywrapcp.IntervalVarElement_DurationValue(self) 3274 3275 def EndMin(self): 3276 return _pywrapcp.IntervalVarElement_EndMin(self) 3277 3278 def EndMax(self): 3279 return _pywrapcp.IntervalVarElement_EndMax(self) 3280 3281 def EndValue(self): 3282 return _pywrapcp.IntervalVarElement_EndValue(self) 3283 3284 def PerformedMin(self): 3285 return _pywrapcp.IntervalVarElement_PerformedMin(self) 3286 3287 def PerformedMax(self): 3288 return _pywrapcp.IntervalVarElement_PerformedMax(self) 3289 3290 def PerformedValue(self): 3291 return _pywrapcp.IntervalVarElement_PerformedValue(self) 3292 3293 def SetStartMin(self, m): 3294 return _pywrapcp.IntervalVarElement_SetStartMin(self, m) 3295 3296 def SetStartMax(self, m): 3297 return _pywrapcp.IntervalVarElement_SetStartMax(self, m) 3298 3299 def SetStartRange(self, mi, ma): 3300 return _pywrapcp.IntervalVarElement_SetStartRange(self, mi, ma) 3301 3302 def SetStartValue(self, v): 3303 return _pywrapcp.IntervalVarElement_SetStartValue(self, v) 3304 3305 def SetDurationMin(self, m): 3306 return _pywrapcp.IntervalVarElement_SetDurationMin(self, m) 3307 3308 def SetDurationMax(self, m): 3309 return _pywrapcp.IntervalVarElement_SetDurationMax(self, m) 3310 3311 def SetDurationRange(self, mi, ma): 3312 return _pywrapcp.IntervalVarElement_SetDurationRange(self, mi, ma) 3313 3314 def SetDurationValue(self, v): 3315 return _pywrapcp.IntervalVarElement_SetDurationValue(self, v) 3316 3317 def SetEndMin(self, m): 3318 return _pywrapcp.IntervalVarElement_SetEndMin(self, m) 3319 3320 def SetEndMax(self, m): 3321 return _pywrapcp.IntervalVarElement_SetEndMax(self, m) 3322 3323 def SetEndRange(self, mi, ma): 3324 return _pywrapcp.IntervalVarElement_SetEndRange(self, mi, ma) 3325 3326 def SetEndValue(self, v): 3327 return _pywrapcp.IntervalVarElement_SetEndValue(self, v) 3328 3329 def SetPerformedMin(self, m): 3330 return _pywrapcp.IntervalVarElement_SetPerformedMin(self, m) 3331 3332 def SetPerformedMax(self, m): 3333 return _pywrapcp.IntervalVarElement_SetPerformedMax(self, m) 3334 3335 def SetPerformedRange(self, mi, ma): 3336 return _pywrapcp.IntervalVarElement_SetPerformedRange(self, mi, ma) 3337 3338 def SetPerformedValue(self, v): 3339 return _pywrapcp.IntervalVarElement_SetPerformedValue(self, v) 3340 3341 def __eq__(self, element): 3342 return _pywrapcp.IntervalVarElement___eq__(self, element) 3343 3344 def __ne__(self, element): 3345 return _pywrapcp.IntervalVarElement___ne__(self, element) 3346 __swig_destroy__ = _pywrapcp.delete_IntervalVarElement 3347 3348# Register IntervalVarElement in _pywrapcp: 3349_pywrapcp.IntervalVarElement_swigregister(IntervalVarElement) 3350class SequenceVarElement(AssignmentElement): 3351 r""" 3352 The SequenceVarElement stores a partial representation of ranked 3353 interval variables in the underlying sequence variable. 3354 This representation consists of three vectors: 3355 - the forward sequence. That is the list of interval variables 3356 ranked first in the sequence. The first element of the backward 3357 sequence is the first interval in the sequence variable. 3358 - the backward sequence. That is the list of interval variables 3359 ranked last in the sequence. The first element of the backward 3360 sequence is the last interval in the sequence variable. 3361 - The list of unperformed interval variables. 3362 Furthermore, if all performed variables are ranked, then by 3363 convention, the forward_sequence will contain all such variables 3364 and the backward_sequence will be empty. 3365 """ 3366 3367 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3368 3369 def __init__(self, *args, **kwargs): 3370 raise AttributeError("No constructor defined") 3371 __repr__ = _swig_repr 3372 3373 def Var(self): 3374 return _pywrapcp.SequenceVarElement_Var(self) 3375 3376 def ForwardSequence(self): 3377 return _pywrapcp.SequenceVarElement_ForwardSequence(self) 3378 3379 def BackwardSequence(self): 3380 return _pywrapcp.SequenceVarElement_BackwardSequence(self) 3381 3382 def Unperformed(self): 3383 return _pywrapcp.SequenceVarElement_Unperformed(self) 3384 3385 def SetSequence(self, forward_sequence, backward_sequence, unperformed): 3386 return _pywrapcp.SequenceVarElement_SetSequence(self, forward_sequence, backward_sequence, unperformed) 3387 3388 def SetForwardSequence(self, forward_sequence): 3389 return _pywrapcp.SequenceVarElement_SetForwardSequence(self, forward_sequence) 3390 3391 def SetBackwardSequence(self, backward_sequence): 3392 return _pywrapcp.SequenceVarElement_SetBackwardSequence(self, backward_sequence) 3393 3394 def SetUnperformed(self, unperformed): 3395 return _pywrapcp.SequenceVarElement_SetUnperformed(self, unperformed) 3396 3397 def __eq__(self, element): 3398 return _pywrapcp.SequenceVarElement___eq__(self, element) 3399 3400 def __ne__(self, element): 3401 return _pywrapcp.SequenceVarElement___ne__(self, element) 3402 __swig_destroy__ = _pywrapcp.delete_SequenceVarElement 3403 3404# Register SequenceVarElement in _pywrapcp: 3405_pywrapcp.SequenceVarElement_swigregister(SequenceVarElement) 3406class Assignment(PropagationBaseObject): 3407 r""" 3408 An Assignment is a variable -> domains mapping, used 3409 to report solutions to the user. 3410 """ 3411 3412 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3413 3414 def __init__(self, *args, **kwargs): 3415 raise AttributeError("No constructor defined") 3416 __repr__ = _swig_repr 3417 3418 def Clear(self): 3419 return _pywrapcp.Assignment_Clear(self) 3420 3421 def Empty(self): 3422 return _pywrapcp.Assignment_Empty(self) 3423 3424 def Size(self): 3425 return _pywrapcp.Assignment_Size(self) 3426 3427 def NumIntVars(self): 3428 return _pywrapcp.Assignment_NumIntVars(self) 3429 3430 def NumIntervalVars(self): 3431 return _pywrapcp.Assignment_NumIntervalVars(self) 3432 3433 def NumSequenceVars(self): 3434 return _pywrapcp.Assignment_NumSequenceVars(self) 3435 3436 def Store(self): 3437 return _pywrapcp.Assignment_Store(self) 3438 3439 def Restore(self): 3440 return _pywrapcp.Assignment_Restore(self) 3441 3442 def Load(self, *args): 3443 return _pywrapcp.Assignment_Load(self, *args) 3444 3445 def Save(self, *args): 3446 return _pywrapcp.Assignment_Save(self, *args) 3447 3448 def AddObjective(self, v): 3449 return _pywrapcp.Assignment_AddObjective(self, v) 3450 3451 def Objective(self): 3452 return _pywrapcp.Assignment_Objective(self) 3453 3454 def HasObjective(self): 3455 return _pywrapcp.Assignment_HasObjective(self) 3456 3457 def ObjectiveMin(self): 3458 return _pywrapcp.Assignment_ObjectiveMin(self) 3459 3460 def ObjectiveMax(self): 3461 return _pywrapcp.Assignment_ObjectiveMax(self) 3462 3463 def ObjectiveValue(self): 3464 return _pywrapcp.Assignment_ObjectiveValue(self) 3465 3466 def ObjectiveBound(self): 3467 return _pywrapcp.Assignment_ObjectiveBound(self) 3468 3469 def SetObjectiveMin(self, m): 3470 return _pywrapcp.Assignment_SetObjectiveMin(self, m) 3471 3472 def SetObjectiveMax(self, m): 3473 return _pywrapcp.Assignment_SetObjectiveMax(self, m) 3474 3475 def SetObjectiveValue(self, value): 3476 return _pywrapcp.Assignment_SetObjectiveValue(self, value) 3477 3478 def SetObjectiveRange(self, l, u): 3479 return _pywrapcp.Assignment_SetObjectiveRange(self, l, u) 3480 3481 def Min(self, var): 3482 return _pywrapcp.Assignment_Min(self, var) 3483 3484 def Max(self, var): 3485 return _pywrapcp.Assignment_Max(self, var) 3486 3487 def Value(self, var): 3488 return _pywrapcp.Assignment_Value(self, var) 3489 3490 def Bound(self, var): 3491 return _pywrapcp.Assignment_Bound(self, var) 3492 3493 def SetMin(self, var, m): 3494 return _pywrapcp.Assignment_SetMin(self, var, m) 3495 3496 def SetMax(self, var, m): 3497 return _pywrapcp.Assignment_SetMax(self, var, m) 3498 3499 def SetRange(self, var, l, u): 3500 return _pywrapcp.Assignment_SetRange(self, var, l, u) 3501 3502 def SetValue(self, var, value): 3503 return _pywrapcp.Assignment_SetValue(self, var, value) 3504 3505 def StartMin(self, var): 3506 return _pywrapcp.Assignment_StartMin(self, var) 3507 3508 def StartMax(self, var): 3509 return _pywrapcp.Assignment_StartMax(self, var) 3510 3511 def StartValue(self, var): 3512 return _pywrapcp.Assignment_StartValue(self, var) 3513 3514 def DurationMin(self, var): 3515 return _pywrapcp.Assignment_DurationMin(self, var) 3516 3517 def DurationMax(self, var): 3518 return _pywrapcp.Assignment_DurationMax(self, var) 3519 3520 def DurationValue(self, var): 3521 return _pywrapcp.Assignment_DurationValue(self, var) 3522 3523 def EndMin(self, var): 3524 return _pywrapcp.Assignment_EndMin(self, var) 3525 3526 def EndMax(self, var): 3527 return _pywrapcp.Assignment_EndMax(self, var) 3528 3529 def EndValue(self, var): 3530 return _pywrapcp.Assignment_EndValue(self, var) 3531 3532 def PerformedMin(self, var): 3533 return _pywrapcp.Assignment_PerformedMin(self, var) 3534 3535 def PerformedMax(self, var): 3536 return _pywrapcp.Assignment_PerformedMax(self, var) 3537 3538 def PerformedValue(self, var): 3539 return _pywrapcp.Assignment_PerformedValue(self, var) 3540 3541 def SetStartMin(self, var, m): 3542 return _pywrapcp.Assignment_SetStartMin(self, var, m) 3543 3544 def SetStartMax(self, var, m): 3545 return _pywrapcp.Assignment_SetStartMax(self, var, m) 3546 3547 def SetStartRange(self, var, mi, ma): 3548 return _pywrapcp.Assignment_SetStartRange(self, var, mi, ma) 3549 3550 def SetStartValue(self, var, value): 3551 return _pywrapcp.Assignment_SetStartValue(self, var, value) 3552 3553 def SetDurationMin(self, var, m): 3554 return _pywrapcp.Assignment_SetDurationMin(self, var, m) 3555 3556 def SetDurationMax(self, var, m): 3557 return _pywrapcp.Assignment_SetDurationMax(self, var, m) 3558 3559 def SetDurationRange(self, var, mi, ma): 3560 return _pywrapcp.Assignment_SetDurationRange(self, var, mi, ma) 3561 3562 def SetDurationValue(self, var, value): 3563 return _pywrapcp.Assignment_SetDurationValue(self, var, value) 3564 3565 def SetEndMin(self, var, m): 3566 return _pywrapcp.Assignment_SetEndMin(self, var, m) 3567 3568 def SetEndMax(self, var, m): 3569 return _pywrapcp.Assignment_SetEndMax(self, var, m) 3570 3571 def SetEndRange(self, var, mi, ma): 3572 return _pywrapcp.Assignment_SetEndRange(self, var, mi, ma) 3573 3574 def SetEndValue(self, var, value): 3575 return _pywrapcp.Assignment_SetEndValue(self, var, value) 3576 3577 def SetPerformedMin(self, var, m): 3578 return _pywrapcp.Assignment_SetPerformedMin(self, var, m) 3579 3580 def SetPerformedMax(self, var, m): 3581 return _pywrapcp.Assignment_SetPerformedMax(self, var, m) 3582 3583 def SetPerformedRange(self, var, mi, ma): 3584 return _pywrapcp.Assignment_SetPerformedRange(self, var, mi, ma) 3585 3586 def SetPerformedValue(self, var, value): 3587 return _pywrapcp.Assignment_SetPerformedValue(self, var, value) 3588 3589 def Add(self, *args): 3590 return _pywrapcp.Assignment_Add(self, *args) 3591 3592 def ForwardSequence(self, var): 3593 return _pywrapcp.Assignment_ForwardSequence(self, var) 3594 3595 def BackwardSequence(self, var): 3596 return _pywrapcp.Assignment_BackwardSequence(self, var) 3597 3598 def Unperformed(self, var): 3599 return _pywrapcp.Assignment_Unperformed(self, var) 3600 3601 def SetSequence(self, var, forward_sequence, backward_sequence, unperformed): 3602 return _pywrapcp.Assignment_SetSequence(self, var, forward_sequence, backward_sequence, unperformed) 3603 3604 def SetForwardSequence(self, var, forward_sequence): 3605 return _pywrapcp.Assignment_SetForwardSequence(self, var, forward_sequence) 3606 3607 def SetBackwardSequence(self, var, backward_sequence): 3608 return _pywrapcp.Assignment_SetBackwardSequence(self, var, backward_sequence) 3609 3610 def SetUnperformed(self, var, unperformed): 3611 return _pywrapcp.Assignment_SetUnperformed(self, var, unperformed) 3612 3613 def Activate(self, *args): 3614 return _pywrapcp.Assignment_Activate(self, *args) 3615 3616 def Deactivate(self, *args): 3617 return _pywrapcp.Assignment_Deactivate(self, *args) 3618 3619 def Activated(self, *args): 3620 return _pywrapcp.Assignment_Activated(self, *args) 3621 3622 def DebugString(self): 3623 return _pywrapcp.Assignment_DebugString(self) 3624 3625 def IntVarContainer(self): 3626 return _pywrapcp.Assignment_IntVarContainer(self) 3627 3628 def MutableIntVarContainer(self): 3629 return _pywrapcp.Assignment_MutableIntVarContainer(self) 3630 3631 def IntervalVarContainer(self): 3632 return _pywrapcp.Assignment_IntervalVarContainer(self) 3633 3634 def MutableIntervalVarContainer(self): 3635 return _pywrapcp.Assignment_MutableIntervalVarContainer(self) 3636 3637 def SequenceVarContainer(self): 3638 return _pywrapcp.Assignment_SequenceVarContainer(self) 3639 3640 def MutableSequenceVarContainer(self): 3641 return _pywrapcp.Assignment_MutableSequenceVarContainer(self) 3642 3643 def __eq__(self, assignment): 3644 return _pywrapcp.Assignment___eq__(self, assignment) 3645 3646 def __ne__(self, assignment): 3647 return _pywrapcp.Assignment___ne__(self, assignment) 3648 3649# Register Assignment in _pywrapcp: 3650_pywrapcp.Assignment_swigregister(Assignment) 3651 3652def __lshift__(*args): 3653 return _pywrapcp.__lshift__(*args) 3654class Pack(Constraint): 3655 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3656 3657 def __init__(self, *args, **kwargs): 3658 raise AttributeError("No constructor defined") 3659 __repr__ = _swig_repr 3660 3661 def AddWeightedSumLessOrEqualConstantDimension(self, *args): 3662 r""" 3663 *Overload 1:* 3664 Dimensions are additional constraints than can restrict what is 3665 possible with the pack constraint. It can be used to set capacity 3666 limits, to count objects per bin, to compute unassigned 3667 penalties... 3668 This dimension imposes that for all bins b, the weighted sum 3669 (weights[i]) of all objects i assigned to 'b' is less or equal 3670 'bounds[b]'. 3671 3672 | 3673 3674 *Overload 2:* 3675 This dimension imposes that for all bins b, the weighted sum 3676 (weights->Run(i)) of all objects i assigned to 'b' is less or 3677 equal to 'bounds[b]'. Ownership of the callback is transferred to 3678 the pack constraint. 3679 3680 | 3681 3682 *Overload 3:* 3683 This dimension imposes that for all bins b, the weighted sum 3684 (weights->Run(i, b) of all objects i assigned to 'b' is less or 3685 equal to 'bounds[b]'. Ownership of the callback is transferred to 3686 the pack constraint. 3687 """ 3688 return _pywrapcp.Pack_AddWeightedSumLessOrEqualConstantDimension(self, *args) 3689 3690 def AddWeightedSumEqualVarDimension(self, *args): 3691 r""" 3692 *Overload 1:* 3693 This dimension imposes that for all bins b, the weighted sum 3694 (weights[i]) of all objects i assigned to 'b' is equal to loads[b]. 3695 3696 | 3697 3698 *Overload 2:* 3699 This dimension imposes that for all bins b, the weighted sum 3700 (weights->Run(i, b)) of all objects i assigned to 'b' is equal to 3701 loads[b]. 3702 """ 3703 return _pywrapcp.Pack_AddWeightedSumEqualVarDimension(self, *args) 3704 3705 def AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity): 3706 r""" 3707 This dimension imposes: 3708 forall b in bins, 3709 sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b] 3710 where is_assigned(i, b) is true if and only if item i is assigned 3711 to the bin b. 3712 3713 This can be used to model shapes of items by linking variables of 3714 the same item on parallel dimensions with an allowed assignment 3715 constraint. 3716 """ 3717 return _pywrapcp.Pack_AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity) 3718 3719 def AddWeightedSumOfAssignedDimension(self, weights, cost_var): 3720 r""" 3721 This dimension enforces that cost_var == sum of weights[i] for 3722 all objects 'i' assigned to a bin. 3723 """ 3724 return _pywrapcp.Pack_AddWeightedSumOfAssignedDimension(self, weights, cost_var) 3725 3726 def AddCountUsedBinDimension(self, count_var): 3727 r""" 3728 This dimension links 'count_var' to the actual number of bins used in the 3729 pack. 3730 """ 3731 return _pywrapcp.Pack_AddCountUsedBinDimension(self, count_var) 3732 3733 def AddCountAssignedItemsDimension(self, count_var): 3734 r""" 3735 This dimension links 'count_var' to the actual number of items 3736 assigned to a bin in the pack. 3737 """ 3738 return _pywrapcp.Pack_AddCountAssignedItemsDimension(self, count_var) 3739 3740 def Post(self): 3741 return _pywrapcp.Pack_Post(self) 3742 3743 def InitialPropagateWrapper(self): 3744 return _pywrapcp.Pack_InitialPropagateWrapper(self) 3745 3746 def DebugString(self): 3747 return _pywrapcp.Pack_DebugString(self) 3748 3749# Register Pack in _pywrapcp: 3750_pywrapcp.Pack_swigregister(Pack) 3751class DisjunctiveConstraint(Constraint): 3752 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3753 3754 def __init__(self, *args, **kwargs): 3755 raise AttributeError("No constructor defined - class is abstract") 3756 __repr__ = _swig_repr 3757 3758 def SequenceVar(self): 3759 r""" Creates a sequence variable from the constraint.""" 3760 return _pywrapcp.DisjunctiveConstraint_SequenceVar(self) 3761 3762 def SetTransitionTime(self, transition_time): 3763 r""" 3764 Add a transition time between intervals. It forces the distance between 3765 the end of interval a and start of interval b that follows it to be at 3766 least transition_time(a, b). This function must always return 3767 a positive or null value. 3768 """ 3769 return _pywrapcp.DisjunctiveConstraint_SetTransitionTime(self, transition_time) 3770 3771 def TransitionTime(self, before_index, after_index): 3772 return _pywrapcp.DisjunctiveConstraint_TransitionTime(self, before_index, after_index) 3773 3774# Register DisjunctiveConstraint in _pywrapcp: 3775_pywrapcp.DisjunctiveConstraint_swigregister(DisjunctiveConstraint) 3776class RevInteger(object): 3777 r""" 3778 This class adds reversibility to a POD type. 3779 It contains the stamp optimization. i.e. the SaveValue call is done 3780 only once per node of the search tree. Please note that actual 3781 stamps always starts at 1, thus an initial value of 0 will always 3782 trigger the first SaveValue. 3783 """ 3784 3785 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3786 __repr__ = _swig_repr 3787 3788 def __init__(self, val): 3789 _pywrapcp.RevInteger_swiginit(self, _pywrapcp.new_RevInteger(val)) 3790 3791 def Value(self): 3792 return _pywrapcp.RevInteger_Value(self) 3793 3794 def SetValue(self, s, val): 3795 return _pywrapcp.RevInteger_SetValue(self, s, val) 3796 __swig_destroy__ = _pywrapcp.delete_RevInteger 3797 3798# Register RevInteger in _pywrapcp: 3799_pywrapcp.RevInteger_swigregister(RevInteger) 3800class NumericalRevInteger(RevInteger): 3801 r""" Subclass of Rev<T> which adds numerical operations.""" 3802 3803 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3804 __repr__ = _swig_repr 3805 3806 def __init__(self, val): 3807 _pywrapcp.NumericalRevInteger_swiginit(self, _pywrapcp.new_NumericalRevInteger(val)) 3808 3809 def Add(self, s, to_add): 3810 return _pywrapcp.NumericalRevInteger_Add(self, s, to_add) 3811 3812 def Incr(self, s): 3813 return _pywrapcp.NumericalRevInteger_Incr(self, s) 3814 3815 def Decr(self, s): 3816 return _pywrapcp.NumericalRevInteger_Decr(self, s) 3817 __swig_destroy__ = _pywrapcp.delete_NumericalRevInteger 3818 3819# Register NumericalRevInteger in _pywrapcp: 3820_pywrapcp.NumericalRevInteger_swigregister(NumericalRevInteger) 3821class RevBool(object): 3822 r""" 3823 This class adds reversibility to a POD type. 3824 It contains the stamp optimization. i.e. the SaveValue call is done 3825 only once per node of the search tree. Please note that actual 3826 stamps always starts at 1, thus an initial value of 0 will always 3827 trigger the first SaveValue. 3828 """ 3829 3830 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3831 __repr__ = _swig_repr 3832 3833 def __init__(self, val): 3834 _pywrapcp.RevBool_swiginit(self, _pywrapcp.new_RevBool(val)) 3835 3836 def Value(self): 3837 return _pywrapcp.RevBool_Value(self) 3838 3839 def SetValue(self, s, val): 3840 return _pywrapcp.RevBool_SetValue(self, s, val) 3841 __swig_destroy__ = _pywrapcp.delete_RevBool 3842 3843# Register RevBool in _pywrapcp: 3844_pywrapcp.RevBool_swigregister(RevBool) 3845class IntVarContainer(object): 3846 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3847 3848 def __init__(self, *args, **kwargs): 3849 raise AttributeError("No constructor defined") 3850 __repr__ = _swig_repr 3851 3852 def Contains(self, var): 3853 return _pywrapcp.IntVarContainer_Contains(self, var) 3854 3855 def Element(self, index): 3856 return _pywrapcp.IntVarContainer_Element(self, index) 3857 3858 def Size(self): 3859 return _pywrapcp.IntVarContainer_Size(self) 3860 3861 def Store(self): 3862 return _pywrapcp.IntVarContainer_Store(self) 3863 3864 def Restore(self): 3865 return _pywrapcp.IntVarContainer_Restore(self) 3866 3867 def __eq__(self, container): 3868 r""" 3869 Returns true if this and 'container' both represent the same V* -> E map. 3870 Runs in linear time; requires that the == operator on the type E is well 3871 defined. 3872 """ 3873 return _pywrapcp.IntVarContainer___eq__(self, container) 3874 3875 def __ne__(self, container): 3876 return _pywrapcp.IntVarContainer___ne__(self, container) 3877 __swig_destroy__ = _pywrapcp.delete_IntVarContainer 3878 3879# Register IntVarContainer in _pywrapcp: 3880_pywrapcp.IntVarContainer_swigregister(IntVarContainer) 3881class IntervalVarContainer(object): 3882 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3883 3884 def __init__(self, *args, **kwargs): 3885 raise AttributeError("No constructor defined") 3886 __repr__ = _swig_repr 3887 3888 def Contains(self, var): 3889 return _pywrapcp.IntervalVarContainer_Contains(self, var) 3890 3891 def Element(self, index): 3892 return _pywrapcp.IntervalVarContainer_Element(self, index) 3893 3894 def Size(self): 3895 return _pywrapcp.IntervalVarContainer_Size(self) 3896 3897 def Store(self): 3898 return _pywrapcp.IntervalVarContainer_Store(self) 3899 3900 def Restore(self): 3901 return _pywrapcp.IntervalVarContainer_Restore(self) 3902 3903 def __eq__(self, container): 3904 r""" 3905 Returns true if this and 'container' both represent the same V* -> E map. 3906 Runs in linear time; requires that the == operator on the type E is well 3907 defined. 3908 """ 3909 return _pywrapcp.IntervalVarContainer___eq__(self, container) 3910 3911 def __ne__(self, container): 3912 return _pywrapcp.IntervalVarContainer___ne__(self, container) 3913 __swig_destroy__ = _pywrapcp.delete_IntervalVarContainer 3914 3915# Register IntervalVarContainer in _pywrapcp: 3916_pywrapcp.IntervalVarContainer_swigregister(IntervalVarContainer) 3917class SequenceVarContainer(object): 3918 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3919 3920 def __init__(self, *args, **kwargs): 3921 raise AttributeError("No constructor defined") 3922 __repr__ = _swig_repr 3923 3924 def Contains(self, var): 3925 return _pywrapcp.SequenceVarContainer_Contains(self, var) 3926 3927 def Element(self, index): 3928 return _pywrapcp.SequenceVarContainer_Element(self, index) 3929 3930 def Size(self): 3931 return _pywrapcp.SequenceVarContainer_Size(self) 3932 3933 def Store(self): 3934 return _pywrapcp.SequenceVarContainer_Store(self) 3935 3936 def Restore(self): 3937 return _pywrapcp.SequenceVarContainer_Restore(self) 3938 3939 def __eq__(self, container): 3940 r""" 3941 Returns true if this and 'container' both represent the same V* -> E map. 3942 Runs in linear time; requires that the == operator on the type E is well 3943 defined. 3944 """ 3945 return _pywrapcp.SequenceVarContainer___eq__(self, container) 3946 3947 def __ne__(self, container): 3948 return _pywrapcp.SequenceVarContainer___ne__(self, container) 3949 __swig_destroy__ = _pywrapcp.delete_SequenceVarContainer 3950 3951# Register SequenceVarContainer in _pywrapcp: 3952_pywrapcp.SequenceVarContainer_swigregister(SequenceVarContainer) 3953class LocalSearchOperator(BaseObject): 3954 r""" 3955 The base class for all local search operators. 3956 3957 A local search operator is an object that defines the neighborhood of a 3958 solution. In other words, a neighborhood is the set of solutions which can 3959 be reached from a given solution using an operator. 3960 3961 The behavior of the LocalSearchOperator class is similar to iterators. 3962 The operator is synchronized with an assignment (gives the 3963 current values of the variables); this is done in the Start() method. 3964 3965 Then one can iterate over the neighbors using the MakeNextNeighbor method. 3966 This method returns an assignment which represents the incremental changes 3967 to the current solution. It also returns a second assignment representing 3968 the changes to the last solution defined by the neighborhood operator; this 3969 assignment is empty if the neighborhood operator cannot track this 3970 information. 3971 """ 3972 3973 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3974 3975 def __init__(self, *args, **kwargs): 3976 raise AttributeError("No constructor defined - class is abstract") 3977 __repr__ = _swig_repr 3978 3979 def NextNeighbor(self, delta, deltadelta): 3980 return _pywrapcp.LocalSearchOperator_NextNeighbor(self, delta, deltadelta) 3981 3982 def Start(self, assignment): 3983 return _pywrapcp.LocalSearchOperator_Start(self, assignment) 3984 def __disown__(self): 3985 self.this.disown() 3986 _pywrapcp.disown_LocalSearchOperator(self) 3987 return weakref.proxy(self) 3988 3989# Register LocalSearchOperator in _pywrapcp: 3990_pywrapcp.LocalSearchOperator_swigregister(LocalSearchOperator) 3991class IntVarLocalSearchOperator(LocalSearchOperator): 3992 r""" 3993 Specialization of LocalSearchOperator built from an array of IntVars 3994 which specifies the scope of the operator. 3995 This class also takes care of storing current variable values in Start(), 3996 keeps track of changes done by the operator and builds the delta. 3997 The Deactivate() method can be used to perform Large Neighborhood Search. 3998 """ 3999 4000 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4001 __repr__ = _swig_repr 4002 4003 def __init__(self, vars, keep_inverse_values=False): 4004 if self.__class__ == IntVarLocalSearchOperator: 4005 _self = None 4006 else: 4007 _self = self 4008 _pywrapcp.IntVarLocalSearchOperator_swiginit(self, _pywrapcp.new_IntVarLocalSearchOperator(_self, vars, keep_inverse_values)) 4009 __swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchOperator 4010 4011 def Start(self, assignment): 4012 r""" 4013 This method should not be overridden. Override OnStart() instead which is 4014 called before exiting this method. 4015 """ 4016 return _pywrapcp.IntVarLocalSearchOperator_Start(self, assignment) 4017 4018 def IsIncremental(self): 4019 return _pywrapcp.IntVarLocalSearchOperator_IsIncremental(self) 4020 4021 def Size(self): 4022 return _pywrapcp.IntVarLocalSearchOperator_Size(self) 4023 4024 def Value(self, index): 4025 r""" 4026 Returns the value in the current assignment of the variable of given 4027 index. 4028 """ 4029 return _pywrapcp.IntVarLocalSearchOperator_Value(self, index) 4030 4031 def Var(self, index): 4032 r""" Returns the variable of given index.""" 4033 return _pywrapcp.IntVarLocalSearchOperator_Var(self, index) 4034 4035 def OldValue(self, index): 4036 return _pywrapcp.IntVarLocalSearchOperator_OldValue(self, index) 4037 4038 def PrevValue(self, index): 4039 return _pywrapcp.IntVarLocalSearchOperator_PrevValue(self, index) 4040 4041 def SetValue(self, index, value): 4042 return _pywrapcp.IntVarLocalSearchOperator_SetValue(self, index, value) 4043 4044 def Activated(self, index): 4045 return _pywrapcp.IntVarLocalSearchOperator_Activated(self, index) 4046 4047 def Activate(self, index): 4048 return _pywrapcp.IntVarLocalSearchOperator_Activate(self, index) 4049 4050 def Deactivate(self, index): 4051 return _pywrapcp.IntVarLocalSearchOperator_Deactivate(self, index) 4052 4053 def AddVars(self, vars): 4054 return _pywrapcp.IntVarLocalSearchOperator_AddVars(self, vars) 4055 4056 def OnStart(self): 4057 r""" 4058 Called by Start() after synchronizing the operator with the current 4059 assignment. Should be overridden instead of Start() to avoid calling 4060 IntVarLocalSearchOperator::Start explicitly. 4061 """ 4062 return _pywrapcp.IntVarLocalSearchOperator_OnStart(self) 4063 4064 def NextNeighbor(self, delta, deltadelta): 4065 r""" 4066 OnStart() should really be protected, but then SWIG doesn't see it. So we 4067 make it public, but only subclasses should access to it (to override it). 4068 Redefines MakeNextNeighbor to export a simpler interface. The calls to 4069 ApplyChanges() and RevertChanges() are factored in this method, hiding 4070 both delta and deltadelta from subclasses which only need to override 4071 MakeOneNeighbor(). 4072 Therefore this method should not be overridden. Override MakeOneNeighbor() 4073 instead. 4074 """ 4075 return _pywrapcp.IntVarLocalSearchOperator_NextNeighbor(self, delta, deltadelta) 4076 4077 def OneNeighbor(self): 4078 r""" 4079 Creates a new neighbor. It returns false when the neighborhood is 4080 completely explored. 4081 MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator. 4082 """ 4083 return _pywrapcp.IntVarLocalSearchOperator_OneNeighbor(self) 4084 def __disown__(self): 4085 self.this.disown() 4086 _pywrapcp.disown_IntVarLocalSearchOperator(self) 4087 return weakref.proxy(self) 4088 4089# Register IntVarLocalSearchOperator in _pywrapcp: 4090_pywrapcp.IntVarLocalSearchOperator_swigregister(IntVarLocalSearchOperator) 4091class BaseLns(IntVarLocalSearchOperator): 4092 r""" 4093 This is the base class for building an Lns operator. An Lns fragment is a 4094 collection of variables which will be relaxed. Fragments are built with 4095 NextFragment(), which returns false if there are no more fragments to build. 4096 Optionally one can override InitFragments, which is called from 4097 LocalSearchOperator::Start to initialize fragment data. 4098 4099 Here's a sample relaxing one variable at a time: 4100 4101 class OneVarLns : public BaseLns { 4102 public: 4103 OneVarLns(const std::vector<IntVar*>& vars) : BaseLns(vars), index_(0) {} 4104 virtual ~OneVarLns() {} 4105 virtual void InitFragments() { index_ = 0; } 4106 virtual bool NextFragment() { 4107 const int size = Size(); 4108 if (index_ < size) { 4109 AppendToFragment(index_); 4110 ++index_; 4111 return true; 4112 } else { 4113 return false; 4114 } 4115 } 4116 4117 private: 4118 int index_; 4119 }; 4120 """ 4121 4122 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4123 __repr__ = _swig_repr 4124 4125 def __init__(self, vars): 4126 if self.__class__ == BaseLns: 4127 _self = None 4128 else: 4129 _self = self 4130 _pywrapcp.BaseLns_swiginit(self, _pywrapcp.new_BaseLns(_self, vars)) 4131 __swig_destroy__ = _pywrapcp.delete_BaseLns 4132 4133 def InitFragments(self): 4134 return _pywrapcp.BaseLns_InitFragments(self) 4135 4136 def NextFragment(self): 4137 return _pywrapcp.BaseLns_NextFragment(self) 4138 4139 def AppendToFragment(self, index): 4140 return _pywrapcp.BaseLns_AppendToFragment(self, index) 4141 4142 def FragmentSize(self): 4143 return _pywrapcp.BaseLns_FragmentSize(self) 4144 4145 def __getitem__(self, index): 4146 return _pywrapcp.BaseLns___getitem__(self, index) 4147 4148 def __len__(self): 4149 return _pywrapcp.BaseLns___len__(self) 4150 def __disown__(self): 4151 self.this.disown() 4152 _pywrapcp.disown_BaseLns(self) 4153 return weakref.proxy(self) 4154 4155# Register BaseLns in _pywrapcp: 4156_pywrapcp.BaseLns_swigregister(BaseLns) 4157class ChangeValue(IntVarLocalSearchOperator): 4158 r""" 4159 Defines operators which change the value of variables; 4160 each neighbor corresponds to *one* modified variable. 4161 Sub-classes have to define ModifyValue which determines what the new 4162 variable value is going to be (given the current value and the variable). 4163 """ 4164 4165 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4166 __repr__ = _swig_repr 4167 4168 def __init__(self, vars): 4169 if self.__class__ == ChangeValue: 4170 _self = None 4171 else: 4172 _self = self 4173 _pywrapcp.ChangeValue_swiginit(self, _pywrapcp.new_ChangeValue(_self, vars)) 4174 __swig_destroy__ = _pywrapcp.delete_ChangeValue 4175 4176 def ModifyValue(self, index, value): 4177 return _pywrapcp.ChangeValue_ModifyValue(self, index, value) 4178 4179 def OneNeighbor(self): 4180 r""" This method should not be overridden. Override ModifyValue() instead.""" 4181 return _pywrapcp.ChangeValue_OneNeighbor(self) 4182 def __disown__(self): 4183 self.this.disown() 4184 _pywrapcp.disown_ChangeValue(self) 4185 return weakref.proxy(self) 4186 4187# Register ChangeValue in _pywrapcp: 4188_pywrapcp.ChangeValue_swigregister(ChangeValue) 4189class PathOperator(IntVarLocalSearchOperator): 4190 r""" 4191 Base class of the local search operators dedicated to path modifications 4192 (a path is a set of nodes linked together by arcs). 4193 This family of neighborhoods supposes they are handling next variables 4194 representing the arcs (var[i] represents the node immediately after i on 4195 a path). 4196 Several services are provided: 4197 - arc manipulators (SetNext(), ReverseChain(), MoveChain()) 4198 - path inspectors (Next(), Prev(), IsPathEnd()) 4199 - path iterators: operators need a given number of nodes to define a 4200 neighbor; this class provides the iteration on a given number of (base) 4201 nodes which can be used to define a neighbor (through the BaseNode method) 4202 Subclasses only need to override MakeNeighbor to create neighbors using 4203 the services above (no direct manipulation of assignments). 4204 """ 4205 4206 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4207 4208 def __init__(self, *args, **kwargs): 4209 raise AttributeError("No constructor defined - class is abstract") 4210 __repr__ = _swig_repr 4211 4212 def Neighbor(self): 4213 return _pywrapcp.PathOperator_Neighbor(self) 4214 4215# Register PathOperator in _pywrapcp: 4216_pywrapcp.PathOperator_swigregister(PathOperator) 4217class LocalSearchFilter(BaseObject): 4218 r""" 4219 Classes to which this template function can be applied to as of 04/2014. 4220 Usage: LocalSearchOperator* op = MakeLocalSearchOperator<Relocate>(...); 4221 class TwoOpt; 4222 class Relocate; 4223 class Exchange; 4224 class Cross; 4225 class MakeActiveOperator; 4226 class MakeInactiveOperator; 4227 class MakeChainInactiveOperator; 4228 class SwapActiveOperator; 4229 class ExtendedSwapActiveOperator; 4230 class MakeActiveAndRelocate; 4231 class RelocateAndMakeActiveOperator; 4232 class RelocateAndMakeInactiveOperator; 4233 Local Search Filters are used for fast neighbor pruning. 4234 Filtering a move is done in several phases: 4235 - in the Relax phase, filters determine which parts of their internals 4236 will be changed by the candidate, and modify intermediary State 4237 - in the Accept phase, filters check that the candidate is feasible, 4238 - if the Accept phase succeeds, the solver may decide to trigger a 4239 Synchronize phase that makes filters change their internal representation 4240 to the last candidate, 4241 - otherwise (Accept fails or the solver does not want to synchronize), 4242 a Revert phase makes filters erase any intermediary State generated by the 4243 Relax and Accept phases. 4244 A given filter has phases called with the following pattern: 4245 (Relax.Accept.Synchronize | Relax.Accept.Revert | Relax.Revert)*. 4246 Filters's Revert() is always called in the reverse order their Accept() was 4247 called, to allow late filters to use state done/undone by early filters' 4248 Accept()/Revert(). 4249 """ 4250 4251 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4252 4253 def __init__(self, *args, **kwargs): 4254 raise AttributeError("No constructor defined - class is abstract") 4255 __repr__ = _swig_repr 4256 4257 def Accept(self, delta, deltadelta, objective_min, objective_max): 4258 r""" 4259 Accepts a "delta" given the assignment with which the filter has been 4260 synchronized; the delta holds the variables which have been modified and 4261 their new value. 4262 If the filter represents a part of the global objective, its contribution 4263 must be between objective_min and objective_max. 4264 Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1, 4265 for the assignment (a,1), (b,0), the delta (b,1) will be rejected 4266 but the delta (a,0) will be accepted. 4267 TODO(user): Remove arguments when there are no more need for those. 4268 """ 4269 return _pywrapcp.LocalSearchFilter_Accept(self, delta, deltadelta, objective_min, objective_max) 4270 4271 def IsIncremental(self): 4272 return _pywrapcp.LocalSearchFilter_IsIncremental(self) 4273 4274 def Synchronize(self, assignment, delta): 4275 r""" 4276 Synchronizes the filter with the current solution, delta being the 4277 difference with the solution passed to the previous call to Synchronize() 4278 or IncrementalSynchronize(). 'delta' can be used to incrementally 4279 synchronizing the filter with the new solution by only considering the 4280 changes in delta. 4281 """ 4282 return _pywrapcp.LocalSearchFilter_Synchronize(self, assignment, delta) 4283 __swig_destroy__ = _pywrapcp.delete_LocalSearchFilter 4284 4285# Register LocalSearchFilter in _pywrapcp: 4286_pywrapcp.LocalSearchFilter_swigregister(LocalSearchFilter) 4287class LocalSearchFilterManager(BaseObject): 4288 r""" 4289 Filter manager: when a move is made, filters are executed to decide whether 4290 the solution is feasible and compute parts of the new cost. This class 4291 schedules filter execution and composes costs as a sum. 4292 """ 4293 4294 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4295 __repr__ = _swig_repr 4296 4297 def DebugString(self): 4298 return _pywrapcp.LocalSearchFilterManager_DebugString(self) 4299 4300 def __init__(self, *args): 4301 _pywrapcp.LocalSearchFilterManager_swiginit(self, _pywrapcp.new_LocalSearchFilterManager(*args)) 4302 4303 def Accept(self, monitor, delta, deltadelta, objective_min, objective_max): 4304 r""" 4305 Returns true iff all filters return true, and the sum of their accepted 4306 objectives is between objective_min and objective_max. 4307 The monitor has its Begin/EndFiltering events triggered. 4308 """ 4309 return _pywrapcp.LocalSearchFilterManager_Accept(self, monitor, delta, deltadelta, objective_min, objective_max) 4310 4311 def Synchronize(self, assignment, delta): 4312 r""" Synchronizes all filters to assignment.""" 4313 return _pywrapcp.LocalSearchFilterManager_Synchronize(self, assignment, delta) 4314 __swig_destroy__ = _pywrapcp.delete_LocalSearchFilterManager 4315 4316# Register LocalSearchFilterManager in _pywrapcp: 4317_pywrapcp.LocalSearchFilterManager_swigregister(LocalSearchFilterManager) 4318class IntVarLocalSearchFilter(LocalSearchFilter): 4319 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4320 __repr__ = _swig_repr 4321 4322 def __init__(self, vars): 4323 if self.__class__ == IntVarLocalSearchFilter: 4324 _self = None 4325 else: 4326 _self = self 4327 _pywrapcp.IntVarLocalSearchFilter_swiginit(self, _pywrapcp.new_IntVarLocalSearchFilter(_self, vars)) 4328 __swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchFilter 4329 4330 def Synchronize(self, assignment, delta): 4331 r""" 4332 This method should not be overridden. Override OnSynchronize() instead 4333 which is called before exiting this method. 4334 """ 4335 return _pywrapcp.IntVarLocalSearchFilter_Synchronize(self, assignment, delta) 4336 4337 def Size(self): 4338 return _pywrapcp.IntVarLocalSearchFilter_Size(self) 4339 4340 def Value(self, index): 4341 return _pywrapcp.IntVarLocalSearchFilter_Value(self, index) 4342 4343 def IndexFromVar(self, var): 4344 return _pywrapcp.IntVarLocalSearchFilter_IndexFromVar(self, var) 4345 def __disown__(self): 4346 self.this.disown() 4347 _pywrapcp.disown_IntVarLocalSearchFilter(self) 4348 return weakref.proxy(self) 4349 4350# Register IntVarLocalSearchFilter in _pywrapcp: 4351_pywrapcp.IntVarLocalSearchFilter_swigregister(IntVarLocalSearchFilter) 4352class BooleanVar(IntVar): 4353 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4354 4355 def __init__(self, *args, **kwargs): 4356 raise AttributeError("No constructor defined - class is abstract") 4357 __repr__ = _swig_repr 4358 4359 def Min(self): 4360 return _pywrapcp.BooleanVar_Min(self) 4361 4362 def SetMin(self, m): 4363 return _pywrapcp.BooleanVar_SetMin(self, m) 4364 4365 def Max(self): 4366 return _pywrapcp.BooleanVar_Max(self) 4367 4368 def SetMax(self, m): 4369 return _pywrapcp.BooleanVar_SetMax(self, m) 4370 4371 def SetRange(self, mi, ma): 4372 return _pywrapcp.BooleanVar_SetRange(self, mi, ma) 4373 4374 def Bound(self): 4375 return _pywrapcp.BooleanVar_Bound(self) 4376 4377 def Value(self): 4378 return _pywrapcp.BooleanVar_Value(self) 4379 4380 def RemoveValue(self, v): 4381 return _pywrapcp.BooleanVar_RemoveValue(self, v) 4382 4383 def RemoveInterval(self, l, u): 4384 return _pywrapcp.BooleanVar_RemoveInterval(self, l, u) 4385 4386 def WhenBound(self, d): 4387 return _pywrapcp.BooleanVar_WhenBound(self, d) 4388 4389 def WhenRange(self, d): 4390 return _pywrapcp.BooleanVar_WhenRange(self, d) 4391 4392 def WhenDomain(self, d): 4393 return _pywrapcp.BooleanVar_WhenDomain(self, d) 4394 4395 def Size(self): 4396 return _pywrapcp.BooleanVar_Size(self) 4397 4398 def Contains(self, v): 4399 return _pywrapcp.BooleanVar_Contains(self, v) 4400 4401 def HoleIteratorAux(self, reversible): 4402 return _pywrapcp.BooleanVar_HoleIteratorAux(self, reversible) 4403 4404 def DomainIteratorAux(self, reversible): 4405 return _pywrapcp.BooleanVar_DomainIteratorAux(self, reversible) 4406 4407 def DebugString(self): 4408 return _pywrapcp.BooleanVar_DebugString(self) 4409 4410# Register BooleanVar in _pywrapcp: 4411_pywrapcp.BooleanVar_swigregister(BooleanVar) 4412 4413class PyDecision(Decision): 4414 def ApplyWrapper(self, solver): 4415 try: 4416 self.Apply(solver) 4417 except Exception as e: 4418 if 'CP Solver fail' in str(e): 4419 solver.ShouldFail() 4420 else: 4421 raise 4422 4423 def RefuteWrapper(self, solver): 4424 try: 4425 self.Refute(solver) 4426 except Exception as e: 4427 if 'CP Solver fail' in str(e): 4428 solver.ShouldFail() 4429 else: 4430 raise 4431 4432 def DebugString(self): 4433 return "PyDecision" 4434 4435 4436class PyDecisionBuilder(DecisionBuilder): 4437 def NextWrapper(self, solver): 4438 try: 4439 return self.Next(solver) 4440 except Exception as e: 4441 if 'CP Solver fail' in str(e): 4442 return solver.FailDecision() 4443 else: 4444 raise 4445 4446 def DebugString(self): 4447 return "PyDecisionBuilder" 4448 4449 4450class PyDemon(Demon): 4451 def RunWrapper(self, solver): 4452 try: 4453 self.Run(solver) 4454 except Exception as e: 4455 if 'CP Solver fail' in str(e): 4456 solver.ShouldFail() 4457 else: 4458 raise 4459 4460 def DebugString(self): 4461 return "PyDemon" 4462 4463 4464class PyConstraintDemon(PyDemon): 4465 def __init__(self, ct, method, delayed, *args): 4466 super().__init__() 4467 self.__constraint = ct 4468 self.__method = method 4469 self.__delayed = delayed 4470 self.__args = args 4471 4472 def Run(self, solver): 4473 self.__method(self.__constraint, *self.__args) 4474 4475 def Priority(self): 4476 return Solver.DELAYED_PRIORITY if self.__delayed else Solver.NORMAL_PRIORITY 4477 4478 def DebugString(self): 4479 return 'PyConstraintDemon' 4480 4481 4482class PyConstraint(Constraint): 4483 def __init__(self, solver): 4484 super().__init__(solver) 4485 self.__demons = [] 4486 4487 def Demon(self, method, *args): 4488 demon = PyConstraintDemon(self, method, False, *args) 4489 self.__demons.append(demon) 4490 return demon 4491 4492 def DelayedDemon(self, method, *args): 4493 demon = PyConstraintDemon(self, method, True, *args) 4494 self.__demons.append(demon) 4495 return demon 4496 4497 def InitialPropagateDemon(self): 4498 return self.solver().ConstraintInitialPropagateCallback(self) 4499 4500 def DelayedInitialPropagateDemon(self): 4501 return self.solver().DelayedConstraintInitialPropagateCallback(self) 4502 4503 def InitialPropagateWrapper(self): 4504 try: 4505 self.InitialPropagate() 4506 except Exception as e: 4507 if 'CP Solver fail' in str(e): 4508 self.solver().ShouldFail() 4509 else: 4510 raise 4511 4512 def DebugString(self): 4513 return "PyConstraint" 4514 4515class RoutingIndexManager(object): 4516 r""" 4517 Manager for any NodeIndex <-> variable index conversion. The routing solver 4518 uses variable indices internally and through its API. These variable indices 4519 are tricky to manage directly because one Node can correspond to a multitude 4520 of variables, depending on the number of times they appear in the model, and 4521 if they're used as start and/or end points. This class aims to simplify 4522 variable index usage, allowing users to use NodeIndex instead. 4523 4524 Usage: 4525 4526 .. code-block:: c++ 4527 4528 auto starts_ends = ...; /// These are NodeIndex. 4529 RoutingIndexManager manager(10, 4, starts_ends); // 10 nodes, 4 vehicles. 4530 RoutingModel model(manager); 4531 4532 Then, use 'manager.NodeToIndex(node)' whenever model requires a variable 4533 index. 4534 4535 Note: the mapping between node indices and variables indices is subject to 4536 change so no assumption should be made on it. The only guarantee is that 4537 indices range between 0 and n-1, where n = number of vehicles * 2 (for start 4538 and end nodes) + number of non-start or end nodes. 4539 """ 4540 4541 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4542 __repr__ = _swig_repr 4543 4544 def __init__(self, *args): 4545 _pywrapcp.RoutingIndexManager_swiginit(self, _pywrapcp.new_RoutingIndexManager(*args)) 4546 4547 def GetNumberOfNodes(self): 4548 return _pywrapcp.RoutingIndexManager_GetNumberOfNodes(self) 4549 4550 def GetNumberOfVehicles(self): 4551 return _pywrapcp.RoutingIndexManager_GetNumberOfVehicles(self) 4552 4553 def GetNumberOfIndices(self): 4554 return _pywrapcp.RoutingIndexManager_GetNumberOfIndices(self) 4555 4556 def GetStartIndex(self, vehicle): 4557 return _pywrapcp.RoutingIndexManager_GetStartIndex(self, vehicle) 4558 4559 def GetEndIndex(self, vehicle): 4560 return _pywrapcp.RoutingIndexManager_GetEndIndex(self, vehicle) 4561 4562 def NodeToIndex(self, node): 4563 return _pywrapcp.RoutingIndexManager_NodeToIndex(self, node) 4564 4565 def IndexToNode(self, index): 4566 return _pywrapcp.RoutingIndexManager_IndexToNode(self, index) 4567 __swig_destroy__ = _pywrapcp.delete_RoutingIndexManager 4568 4569# Register RoutingIndexManager in _pywrapcp: 4570_pywrapcp.RoutingIndexManager_swigregister(RoutingIndexManager) 4571 4572def DefaultRoutingModelParameters(): 4573 return _pywrapcp.DefaultRoutingModelParameters() 4574 4575def DefaultRoutingSearchParameters(): 4576 return _pywrapcp.DefaultRoutingSearchParameters() 4577 4578def FindErrorInRoutingSearchParameters(search_parameters): 4579 r""" 4580 Returns an empty std::string if the routing search parameters are valid, and 4581 a non-empty, human readable error description if they're not. 4582 """ 4583 return _pywrapcp.FindErrorInRoutingSearchParameters(search_parameters) 4584BOOL_UNSPECIFIED = _pywrapcp.BOOL_UNSPECIFIED 4585BOOL_FALSE = _pywrapcp.BOOL_FALSE 4586BOOL_TRUE = _pywrapcp.BOOL_TRUE 4587class FirstSolutionStrategy(object): 4588 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4589 __repr__ = _swig_repr 4590 4591 def __init__(self): 4592 _pywrapcp.FirstSolutionStrategy_swiginit(self, _pywrapcp.new_FirstSolutionStrategy()) 4593 __swig_destroy__ = _pywrapcp.delete_FirstSolutionStrategy 4594 4595# Register FirstSolutionStrategy in _pywrapcp: 4596_pywrapcp.FirstSolutionStrategy_swigregister(FirstSolutionStrategy) 4597class LocalSearchMetaheuristic(object): 4598 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4599 __repr__ = _swig_repr 4600 4601 def __init__(self): 4602 _pywrapcp.LocalSearchMetaheuristic_swiginit(self, _pywrapcp.new_LocalSearchMetaheuristic()) 4603 __swig_destroy__ = _pywrapcp.delete_LocalSearchMetaheuristic 4604 4605# Register LocalSearchMetaheuristic in _pywrapcp: 4606_pywrapcp.LocalSearchMetaheuristic_swigregister(LocalSearchMetaheuristic) 4607class PathsMetadata(object): 4608 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4609 __repr__ = _swig_repr 4610 4611 def __init__(self, manager): 4612 _pywrapcp.PathsMetadata_swiginit(self, _pywrapcp.new_PathsMetadata(manager)) 4613 4614 def IsStart(self, node): 4615 return _pywrapcp.PathsMetadata_IsStart(self, node) 4616 4617 def IsEnd(self, node): 4618 return _pywrapcp.PathsMetadata_IsEnd(self, node) 4619 4620 def GetPath(self, start_or_end_node): 4621 return _pywrapcp.PathsMetadata_GetPath(self, start_or_end_node) 4622 4623 def NumPaths(self): 4624 return _pywrapcp.PathsMetadata_NumPaths(self) 4625 4626 def Paths(self): 4627 return _pywrapcp.PathsMetadata_Paths(self) 4628 4629 def Starts(self): 4630 return _pywrapcp.PathsMetadata_Starts(self) 4631 4632 def Ends(self): 4633 return _pywrapcp.PathsMetadata_Ends(self) 4634 __swig_destroy__ = _pywrapcp.delete_PathsMetadata 4635 4636# Register PathsMetadata in _pywrapcp: 4637_pywrapcp.PathsMetadata_swigregister(PathsMetadata) 4638class RoutingModel(object): 4639 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4640 __repr__ = _swig_repr 4641 ROUTING_NOT_SOLVED = _pywrapcp.RoutingModel_ROUTING_NOT_SOLVED 4642 r""" Problem not solved yet (before calling RoutingModel::Solve()).""" 4643 ROUTING_SUCCESS = _pywrapcp.RoutingModel_ROUTING_SUCCESS 4644 r""" Problem solved successfully after calling RoutingModel::Solve().""" 4645 ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED = _pywrapcp.RoutingModel_ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED 4646 r""" 4647 Problem solved successfully after calling RoutingModel::Solve(), except 4648 that a local optimum has not been reached. Leaving more time would allow 4649 improving the solution. 4650 """ 4651 ROUTING_FAIL = _pywrapcp.RoutingModel_ROUTING_FAIL 4652 r""" No solution found to the problem after calling RoutingModel::Solve().""" 4653 ROUTING_FAIL_TIMEOUT = _pywrapcp.RoutingModel_ROUTING_FAIL_TIMEOUT 4654 r""" Time limit reached before finding a solution with RoutingModel::Solve().""" 4655 ROUTING_INVALID = _pywrapcp.RoutingModel_ROUTING_INVALID 4656 r""" Model, model parameters or flags are not valid.""" 4657 ROUTING_INFEASIBLE = _pywrapcp.RoutingModel_ROUTING_INFEASIBLE 4658 r""" Problem proven to be infeasible.""" 4659 ROUTING_OPTIMAL = _pywrapcp.RoutingModel_ROUTING_OPTIMAL 4660 r""" Problem has been solved to optimality.""" 4661 PICKUP_AND_DELIVERY_NO_ORDER = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_NO_ORDER 4662 r""" Any precedence is accepted.""" 4663 PICKUP_AND_DELIVERY_LIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_LIFO 4664 r""" Deliveries must be performed in reverse order of pickups.""" 4665 PICKUP_AND_DELIVERY_FIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_FIFO 4666 r""" Deliveries must be performed in the same order as pickups.""" 4667 4668 def __init__(self, *args): 4669 _pywrapcp.RoutingModel_swiginit(self, _pywrapcp.new_RoutingModel(*args)) 4670 __swig_destroy__ = _pywrapcp.delete_RoutingModel 4671 kTransitEvaluatorSignUnknown = _pywrapcp.RoutingModel_kTransitEvaluatorSignUnknown 4672 kTransitEvaluatorSignPositiveOrZero = _pywrapcp.RoutingModel_kTransitEvaluatorSignPositiveOrZero 4673 kTransitEvaluatorSignNegativeOrZero = _pywrapcp.RoutingModel_kTransitEvaluatorSignNegativeOrZero 4674 4675 def RegisterUnaryTransitVector(self, values): 4676 r""" 4677 Registers 'callback' and returns its index. 4678 The sign parameter allows to notify the solver that the callback only 4679 return values of the given sign. This can help the solver, but passing 4680 an incorrect sign may crash in non-opt compilation mode, and yield 4681 incorrect results in opt. 4682 """ 4683 return _pywrapcp.RoutingModel_RegisterUnaryTransitVector(self, values) 4684 4685 def RegisterUnaryTransitCallback(self, *args): 4686 return _pywrapcp.RoutingModel_RegisterUnaryTransitCallback(self, *args) 4687 4688 def RegisterTransitMatrix(self, values): 4689 return _pywrapcp.RoutingModel_RegisterTransitMatrix(self, values) 4690 4691 def RegisterTransitCallback(self, *args): 4692 return _pywrapcp.RoutingModel_RegisterTransitCallback(self, *args) 4693 4694 def TransitCallback(self, callback_index): 4695 return _pywrapcp.RoutingModel_TransitCallback(self, callback_index) 4696 4697 def UnaryTransitCallbackOrNull(self, callback_index): 4698 return _pywrapcp.RoutingModel_UnaryTransitCallbackOrNull(self, callback_index) 4699 4700 def AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name): 4701 r""" 4702 Model creation 4703 Methods to add dimensions to routes; dimensions represent quantities 4704 accumulated at nodes along the routes. They represent quantities such as 4705 weights or volumes carried along the route, or distance or times. 4706 Quantities at a node are represented by "cumul" variables and the increase 4707 or decrease of quantities between nodes are represented by "transit" 4708 variables. These variables are linked as follows: 4709 if j == next(i), cumul(j) = cumul(i) + transit(i, j) + slack(i) 4710 where slack is a positive slack variable (can represent waiting times for 4711 a time dimension). 4712 Setting the value of fix_start_cumul_to_zero to true will force the 4713 "cumul" variable of the start node of all vehicles to be equal to 0. 4714 Creates a dimension where the transit variable is constrained to be 4715 equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the 4716 slack variable and 'capacity' is the upper bound of the cumul variables. 4717 'name' is the name used to reference the dimension; this name is used to 4718 get cumul and transit variables from the routing model. 4719 Returns false if a dimension with the same name has already been created 4720 (and doesn't create the new dimension). 4721 Takes ownership of the callback 'evaluator'. 4722 """ 4723 return _pywrapcp.RoutingModel_AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name) 4724 4725 def AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name): 4726 return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name) 4727 4728 def AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name): 4729 return _pywrapcp.RoutingModel_AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name) 4730 4731 def AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name): 4732 return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name) 4733 4734 def AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name): 4735 r""" 4736 Creates a dimension where the transit variable is constrained to be 4737 equal to 'value'; 'capacity' is the upper bound of the cumul variables. 4738 'name' is the name used to reference the dimension; this name is used to 4739 get cumul and transit variables from the routing model. 4740 Returns a pair consisting of an index to the registered unary transit 4741 callback and a bool denoting whether the dimension has been created. 4742 It is false if a dimension with the same name has already been created 4743 (and doesn't create the new dimension but still register a new callback). 4744 """ 4745 return _pywrapcp.RoutingModel_AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name) 4746 4747 def AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name): 4748 return _pywrapcp.RoutingModel_AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name) 4749 4750 def AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name): 4751 r""" 4752 Creates a dimension where the transit variable is constrained to be 4753 equal to 'values[i]' for node i; 'capacity' is the upper bound of 4754 the cumul variables. 'name' is the name used to reference the dimension; 4755 this name is used to get cumul and transit variables from the routing 4756 model. 4757 Returns a pair consisting of an index to the registered unary transit 4758 callback and a bool denoting whether the dimension has been created. 4759 It is false if a dimension with the same name has already been created 4760 (and doesn't create the new dimension but still register a new callback). 4761 """ 4762 return _pywrapcp.RoutingModel_AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name) 4763 4764 def AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name): 4765 r""" 4766 Creates a dimension where the transit variable is constrained to be 4767 equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of 4768 the cumul variables. 'name' is the name used to reference the dimension; 4769 this name is used to get cumul and transit variables from the routing 4770 model. 4771 Returns a pair consisting of an index to the registered transit callback 4772 and a bool denoting whether the dimension has been created. 4773 It is false if a dimension with the same name has already been created 4774 (and doesn't create the new dimension but still register a new callback). 4775 """ 4776 return _pywrapcp.RoutingModel_AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name) 4777 4778 def GetAllDimensionNames(self): 4779 r""" Outputs the names of all dimensions added to the routing engine.""" 4780 return _pywrapcp.RoutingModel_GetAllDimensionNames(self) 4781 4782 def GetDimensions(self): 4783 r""" Returns all dimensions of the model.""" 4784 return _pywrapcp.RoutingModel_GetDimensions(self) 4785 4786 def GetDimensionsWithSoftOrSpanCosts(self): 4787 r""" Returns dimensions with soft or vehicle span costs.""" 4788 return _pywrapcp.RoutingModel_GetDimensionsWithSoftOrSpanCosts(self) 4789 4790 def GetUnaryDimensions(self): 4791 r""" Returns dimensions for which all transit evaluators are unary.""" 4792 return _pywrapcp.RoutingModel_GetUnaryDimensions(self) 4793 4794 def GetDimensionsWithGlobalCumulOptimizers(self): 4795 r""" Returns the dimensions which have [global|local]_dimension_optimizers_.""" 4796 return _pywrapcp.RoutingModel_GetDimensionsWithGlobalCumulOptimizers(self) 4797 4798 def GetDimensionsWithLocalCumulOptimizers(self): 4799 return _pywrapcp.RoutingModel_GetDimensionsWithLocalCumulOptimizers(self) 4800 4801 def HasGlobalCumulOptimizer(self, dimension): 4802 r""" Returns whether the given dimension has global/local cumul optimizers.""" 4803 return _pywrapcp.RoutingModel_HasGlobalCumulOptimizer(self, dimension) 4804 4805 def HasLocalCumulOptimizer(self, dimension): 4806 return _pywrapcp.RoutingModel_HasLocalCumulOptimizer(self, dimension) 4807 4808 def GetMutableGlobalCumulLPOptimizer(self, dimension): 4809 r""" 4810 Returns the global/local dimension cumul optimizer for a given dimension, 4811 or nullptr if there is none. 4812 """ 4813 return _pywrapcp.RoutingModel_GetMutableGlobalCumulLPOptimizer(self, dimension) 4814 4815 def GetMutableGlobalCumulMPOptimizer(self, dimension): 4816 return _pywrapcp.RoutingModel_GetMutableGlobalCumulMPOptimizer(self, dimension) 4817 4818 def GetMutableLocalCumulLPOptimizer(self, dimension): 4819 return _pywrapcp.RoutingModel_GetMutableLocalCumulLPOptimizer(self, dimension) 4820 4821 def GetMutableLocalCumulMPOptimizer(self, dimension): 4822 return _pywrapcp.RoutingModel_GetMutableLocalCumulMPOptimizer(self, dimension) 4823 4824 def HasDimension(self, dimension_name): 4825 r""" Returns true if a dimension exists for a given dimension name.""" 4826 return _pywrapcp.RoutingModel_HasDimension(self, dimension_name) 4827 4828 def GetDimensionOrDie(self, dimension_name): 4829 r""" Returns a dimension from its name. Dies if the dimension does not exist.""" 4830 return _pywrapcp.RoutingModel_GetDimensionOrDie(self, dimension_name) 4831 4832 def GetMutableDimension(self, dimension_name): 4833 r""" 4834 Returns a dimension from its name. Returns nullptr if the dimension does 4835 not exist. 4836 """ 4837 return _pywrapcp.RoutingModel_GetMutableDimension(self, dimension_name) 4838 4839 def SetPrimaryConstrainedDimension(self, dimension_name): 4840 r""" 4841 Set the given dimension as "primary constrained". As of August 2013, this 4842 is only used by ArcIsMoreConstrainedThanArc(). 4843 "dimension" must be the name of an existing dimension, or be empty, in 4844 which case there will not be a primary dimension after this call. 4845 """ 4846 return _pywrapcp.RoutingModel_SetPrimaryConstrainedDimension(self, dimension_name) 4847 4848 def GetPrimaryConstrainedDimension(self): 4849 r""" Get the primary constrained dimension, or an empty string if it is unset.""" 4850 return _pywrapcp.RoutingModel_GetPrimaryConstrainedDimension(self) 4851 4852 def GetResourceGroup(self, rg_index): 4853 return _pywrapcp.RoutingModel_GetResourceGroup(self, rg_index) 4854 4855 def GetDimensionResourceGroupIndices(self, dimension): 4856 r""" 4857 Returns the indices of resource groups for this dimension. This method can 4858 only be called after the model has been closed. 4859 """ 4860 return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndices(self, dimension) 4861 4862 def GetDimensionResourceGroupIndex(self, dimension): 4863 r""" 4864 Returns the index of the resource group attached to the dimension. 4865 DCHECKS that there's exactly one resource group for this dimension. 4866 """ 4867 return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndex(self, dimension) 4868 4869 def AddDisjunction(self, *args): 4870 r""" 4871 Adds a disjunction constraint on the indices: exactly 'max_cardinality' of 4872 the indices are active. Start and end indices of any vehicle cannot be 4873 part of a disjunction. 4874 4875 If a penalty is given, at most 'max_cardinality' of the indices can be 4876 active, and if less are active, 'penalty' is payed per inactive index. 4877 This is equivalent to adding the constraint: 4878 p + Sum(i)active[i] == max_cardinality 4879 where p is an integer variable, and the following cost to the cost 4880 function: 4881 p * penalty. 4882 'penalty' must be positive to make the disjunction optional; a negative 4883 penalty will force 'max_cardinality' indices of the disjunction to be 4884 performed, and therefore p == 0. 4885 Note: passing a vector with a single index will model an optional index 4886 with a penalty cost if it is not visited. 4887 """ 4888 return _pywrapcp.RoutingModel_AddDisjunction(self, *args) 4889 4890 def GetDisjunctionIndices(self, index): 4891 r""" Returns the indices of the disjunctions to which an index belongs.""" 4892 return _pywrapcp.RoutingModel_GetDisjunctionIndices(self, index) 4893 4894 def GetDisjunctionPenalty(self, index): 4895 r""" Returns the penalty of the node disjunction of index 'index'.""" 4896 return _pywrapcp.RoutingModel_GetDisjunctionPenalty(self, index) 4897 4898 def GetDisjunctionMaxCardinality(self, index): 4899 r""" 4900 Returns the maximum number of possible active nodes of the node 4901 disjunction of index 'index'. 4902 """ 4903 return _pywrapcp.RoutingModel_GetDisjunctionMaxCardinality(self, index) 4904 4905 def GetNumberOfDisjunctions(self): 4906 r""" Returns the number of node disjunctions in the model.""" 4907 return _pywrapcp.RoutingModel_GetNumberOfDisjunctions(self) 4908 4909 def HasMandatoryDisjunctions(self): 4910 r""" 4911 Returns true if the model contains mandatory disjunctions (ones with 4912 kNoPenalty as penalty). 4913 """ 4914 return _pywrapcp.RoutingModel_HasMandatoryDisjunctions(self) 4915 4916 def HasMaxCardinalityConstrainedDisjunctions(self): 4917 r""" 4918 Returns true if the model contains at least one disjunction which is 4919 constrained by its max_cardinality. 4920 """ 4921 return _pywrapcp.RoutingModel_HasMaxCardinalityConstrainedDisjunctions(self) 4922 4923 def GetPerfectBinaryDisjunctions(self): 4924 r""" 4925 Returns the list of all perfect binary disjunctions, as pairs of variable 4926 indices: a disjunction is "perfect" when its variables do not appear in 4927 any other disjunction. Each pair is sorted (lowest variable index first), 4928 and the output vector is also sorted (lowest pairs first). 4929 """ 4930 return _pywrapcp.RoutingModel_GetPerfectBinaryDisjunctions(self) 4931 4932 def IgnoreDisjunctionsAlreadyForcedToZero(self): 4933 r""" 4934 SPECIAL: Makes the solver ignore all the disjunctions whose active 4935 variables are all trivially zero (i.e. Max() == 0), by setting their 4936 max_cardinality to 0. 4937 This can be useful when using the BaseBinaryDisjunctionNeighborhood 4938 operators, in the context of arc-based routing. 4939 """ 4940 return _pywrapcp.RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero(self) 4941 4942 def AddSoftSameVehicleConstraint(self, indices, cost): 4943 r""" 4944 Adds a soft constraint to force a set of variable indices to be on the 4945 same vehicle. If all nodes are not on the same vehicle, each extra vehicle 4946 used adds 'cost' to the cost function. 4947 """ 4948 return _pywrapcp.RoutingModel_AddSoftSameVehicleConstraint(self, indices, cost) 4949 4950 def SetAllowedVehiclesForIndex(self, vehicles, index): 4951 r""" 4952 Sets the vehicles which can visit a given node. If the node is in a 4953 disjunction, this will not prevent it from being unperformed. 4954 Specifying an empty vector of vehicles has no effect (all vehicles 4955 will be allowed to visit the node). 4956 """ 4957 return _pywrapcp.RoutingModel_SetAllowedVehiclesForIndex(self, vehicles, index) 4958 4959 def IsVehicleAllowedForIndex(self, vehicle, index): 4960 r""" Returns true if a vehicle is allowed to visit a given node.""" 4961 return _pywrapcp.RoutingModel_IsVehicleAllowedForIndex(self, vehicle, index) 4962 4963 def AddPickupAndDelivery(self, pickup, delivery): 4964 r""" 4965 Notifies that index1 and index2 form a pair of nodes which should belong 4966 to the same route. This methods helps the search find better solutions, 4967 especially in the local search phase. 4968 It should be called each time you have an equality constraint linking 4969 the vehicle variables of two node (including for instance pickup and 4970 delivery problems): 4971 Solver* const solver = routing.solver(); 4972 int64_t index1 = manager.NodeToIndex(node1); 4973 int64_t index2 = manager.NodeToIndex(node2); 4974 solver->AddConstraint(solver->MakeEquality( 4975 routing.VehicleVar(index1), 4976 routing.VehicleVar(index2))); 4977 routing.AddPickupAndDelivery(index1, index2); 4978 """ 4979 return _pywrapcp.RoutingModel_AddPickupAndDelivery(self, pickup, delivery) 4980 4981 def AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction): 4982 r""" 4983 Same as AddPickupAndDelivery but notifying that the performed node from 4984 the disjunction of index 'pickup_disjunction' is on the same route as the 4985 performed node from the disjunction of index 'delivery_disjunction'. 4986 """ 4987 return _pywrapcp.RoutingModel_AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction) 4988 4989 def GetPickupPositions(self, node_index): 4990 r""" Returns the pickup and delivery positions where the node is a pickup.""" 4991 return _pywrapcp.RoutingModel_GetPickupPositions(self, node_index) 4992 4993 def GetDeliveryPositions(self, node_index): 4994 r""" Returns the pickup and delivery positions where the node is a delivery.""" 4995 return _pywrapcp.RoutingModel_GetDeliveryPositions(self, node_index) 4996 4997 def IsPickup(self, node_index): 4998 r""" Returns whether the node is a pickup (resp. delivery).""" 4999 return _pywrapcp.RoutingModel_IsPickup(self, node_index) 5000 5001 def IsDelivery(self, node_index): 5002 return _pywrapcp.RoutingModel_IsDelivery(self, node_index) 5003 5004 def SetPickupAndDeliveryPolicyOfAllVehicles(self, policy): 5005 r""" 5006 Sets the Pickup and delivery policy of all vehicles. It is equivalent to 5007 calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles. 5008 """ 5009 return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles(self, policy) 5010 5011 def SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle): 5012 return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle) 5013 5014 def GetPickupAndDeliveryPolicyOfVehicle(self, vehicle): 5015 return _pywrapcp.RoutingModel_GetPickupAndDeliveryPolicyOfVehicle(self, vehicle) 5016 5017 def GetNumOfSingletonNodes(self): 5018 r""" 5019 Returns the number of non-start/end nodes which do not appear in a 5020 pickup/delivery pair. 5021 """ 5022 return _pywrapcp.RoutingModel_GetNumOfSingletonNodes(self) 5023 TYPE_ADDED_TO_VEHICLE = _pywrapcp.RoutingModel_TYPE_ADDED_TO_VEHICLE 5024 r""" When visited, the number of types 'T' on the vehicle increases by one.""" 5025 ADDED_TYPE_REMOVED_FROM_VEHICLE = _pywrapcp.RoutingModel_ADDED_TYPE_REMOVED_FROM_VEHICLE 5026 r""" 5027 When visited, one instance of type 'T' previously added to the route 5028 (TYPE_ADDED_TO_VEHICLE), if any, is removed from the vehicle. 5029 If the type was not previously added to the route or all added instances 5030 have already been removed, this visit has no effect on the types. 5031 """ 5032 TYPE_ON_VEHICLE_UP_TO_VISIT = _pywrapcp.RoutingModel_TYPE_ON_VEHICLE_UP_TO_VISIT 5033 r""" 5034 With the following policy, the visit enforces that type 'T' is 5035 considered on the route from its start until this node is visited. 5036 """ 5037 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED = _pywrapcp.RoutingModel_TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED 5038 r""" 5039 The visit doesn't have an impact on the number of types 'T' on the 5040 route, as it's (virtually) added and removed directly. 5041 This policy can be used for visits which are part of an incompatibility 5042 or requirement set without affecting the type count on the route. 5043 """ 5044 5045 def SetVisitType(self, index, type, type_policy): 5046 return _pywrapcp.RoutingModel_SetVisitType(self, index, type, type_policy) 5047 5048 def GetVisitType(self, index): 5049 return _pywrapcp.RoutingModel_GetVisitType(self, index) 5050 5051 def GetSingleNodesOfType(self, type): 5052 return _pywrapcp.RoutingModel_GetSingleNodesOfType(self, type) 5053 5054 def GetPairIndicesOfType(self, type): 5055 return _pywrapcp.RoutingModel_GetPairIndicesOfType(self, type) 5056 5057 def GetVisitTypePolicy(self, index): 5058 return _pywrapcp.RoutingModel_GetVisitTypePolicy(self, index) 5059 5060 def CloseVisitTypes(self): 5061 r""" 5062 This function should be called once all node visit types have been set and 5063 prior to adding any incompatibilities/requirements. 5064 "close" types. 5065 """ 5066 return _pywrapcp.RoutingModel_CloseVisitTypes(self) 5067 5068 def GetNumberOfVisitTypes(self): 5069 return _pywrapcp.RoutingModel_GetNumberOfVisitTypes(self) 5070 5071 def AddHardTypeIncompatibility(self, type1, type2): 5072 r""" 5073 Incompatibilities: 5074 Two nodes with "hard" incompatible types cannot share the same route at 5075 all, while with a "temporal" incompatibility they can't be on the same 5076 route at the same time. 5077 """ 5078 return _pywrapcp.RoutingModel_AddHardTypeIncompatibility(self, type1, type2) 5079 5080 def AddTemporalTypeIncompatibility(self, type1, type2): 5081 return _pywrapcp.RoutingModel_AddTemporalTypeIncompatibility(self, type1, type2) 5082 5083 def GetHardTypeIncompatibilitiesOfType(self, type): 5084 r""" Returns visit types incompatible with a given type.""" 5085 return _pywrapcp.RoutingModel_GetHardTypeIncompatibilitiesOfType(self, type) 5086 5087 def GetTemporalTypeIncompatibilitiesOfType(self, type): 5088 return _pywrapcp.RoutingModel_GetTemporalTypeIncompatibilitiesOfType(self, type) 5089 5090 def HasHardTypeIncompatibilities(self): 5091 r""" 5092 Returns true iff any hard (resp. temporal) type incompatibilities have 5093 been added to the model. 5094 """ 5095 return _pywrapcp.RoutingModel_HasHardTypeIncompatibilities(self) 5096 5097 def HasTemporalTypeIncompatibilities(self): 5098 return _pywrapcp.RoutingModel_HasTemporalTypeIncompatibilities(self) 5099 5100 def AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives): 5101 r""" 5102 Requirements: 5103 NOTE: As of 2019-04, cycles in the requirement graph are not supported, 5104 and lead to the dependent nodes being skipped if possible (otherwise 5105 the model is considered infeasible). 5106 The following functions specify that "dependent_type" requires at least 5107 one of the types in "required_type_alternatives". 5108 5109 For same-vehicle requirements, a node of dependent type type_D requires at 5110 least one node of type type_R among the required alternatives on the same 5111 route. 5112 """ 5113 return _pywrapcp.RoutingModel_AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives) 5114 5115 def AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives): 5116 r""" 5117 If type_D depends on type_R when adding type_D, any node_D of type_D and 5118 VisitTypePolicy TYPE_ADDED_TO_VEHICLE or 5119 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its 5120 vehicle at the time node_D is visited. 5121 """ 5122 return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives) 5123 5124 def AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives): 5125 r""" 5126 The following requirements apply when visiting dependent nodes that remove 5127 their type from the route, i.e. type_R must be on the vehicle when type_D 5128 of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE, 5129 TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is 5130 visited. 5131 """ 5132 return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives) 5133 5134 def GetSameVehicleRequiredTypeAlternativesOfType(self, type): 5135 r""" 5136 Returns the set of same-vehicle requirement alternatives for the given 5137 type. 5138 """ 5139 return _pywrapcp.RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType(self, type) 5140 5141 def GetRequiredTypeAlternativesWhenAddingType(self, type): 5142 r""" Returns the set of requirement alternatives when adding the given type.""" 5143 return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenAddingType(self, type) 5144 5145 def GetRequiredTypeAlternativesWhenRemovingType(self, type): 5146 r""" Returns the set of requirement alternatives when removing the given type.""" 5147 return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenRemovingType(self, type) 5148 5149 def HasSameVehicleTypeRequirements(self): 5150 r""" 5151 Returns true iff any same-route (resp. temporal) type requirements have 5152 been added to the model. 5153 """ 5154 return _pywrapcp.RoutingModel_HasSameVehicleTypeRequirements(self) 5155 5156 def HasTemporalTypeRequirements(self): 5157 return _pywrapcp.RoutingModel_HasTemporalTypeRequirements(self) 5158 5159 def HasTypeRegulations(self): 5160 r""" 5161 Returns true iff the model has any incompatibilities or requirements set 5162 on node types. 5163 """ 5164 return _pywrapcp.RoutingModel_HasTypeRegulations(self) 5165 5166 def UnperformedPenalty(self, var_index): 5167 r""" 5168 Get the "unperformed" penalty of a node. This is only well defined if the 5169 node is only part of a single Disjunction, and that disjunction has a 5170 penalty. For forced active nodes returns max int64_t. In all other cases, 5171 this returns 0. 5172 """ 5173 return _pywrapcp.RoutingModel_UnperformedPenalty(self, var_index) 5174 5175 def UnperformedPenaltyOrValue(self, default_value, var_index): 5176 r""" 5177 Same as above except that it returns default_value instead of 0 when 5178 penalty is not well defined (default value is passed as first argument to 5179 simplify the usage of the method in a callback). 5180 """ 5181 return _pywrapcp.RoutingModel_UnperformedPenaltyOrValue(self, default_value, var_index) 5182 5183 def GetDepot(self): 5184 r""" 5185 Returns the variable index of the first starting or ending node of all 5186 routes. If all routes start and end at the same node (single depot), this 5187 is the node returned. 5188 """ 5189 return _pywrapcp.RoutingModel_GetDepot(self) 5190 5191 def SetMaximumNumberOfActiveVehicles(self, max_active_vehicles): 5192 r""" 5193 Constrains the maximum number of active vehicles, aka the number of 5194 vehicles which do not have an empty route. For instance, this can be used 5195 to limit the number of routes in the case where there are fewer drivers 5196 than vehicles and that the fleet of vehicle is heterogeneous. 5197 """ 5198 return _pywrapcp.RoutingModel_SetMaximumNumberOfActiveVehicles(self, max_active_vehicles) 5199 5200 def GetMaximumNumberOfActiveVehicles(self): 5201 r""" Returns the maximum number of active vehicles.""" 5202 return _pywrapcp.RoutingModel_GetMaximumNumberOfActiveVehicles(self) 5203 5204 def SetArcCostEvaluatorOfAllVehicles(self, evaluator_index): 5205 r""" 5206 Sets the cost function of the model such that the cost of a segment of a 5207 route between node 'from' and 'to' is evaluator(from, to), whatever the 5208 route or vehicle performing the route. 5209 """ 5210 return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfAllVehicles(self, evaluator_index) 5211 5212 def SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle): 5213 r""" Sets the cost function for a given vehicle route.""" 5214 return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle) 5215 5216 def SetFixedCostOfAllVehicles(self, cost): 5217 r""" 5218 Sets the fixed cost of all vehicle routes. It is equivalent to calling 5219 SetFixedCostOfVehicle on all vehicle routes. 5220 """ 5221 return _pywrapcp.RoutingModel_SetFixedCostOfAllVehicles(self, cost) 5222 5223 def SetFixedCostOfVehicle(self, cost, vehicle): 5224 r""" Sets the fixed cost of one vehicle route.""" 5225 return _pywrapcp.RoutingModel_SetFixedCostOfVehicle(self, cost, vehicle) 5226 5227 def GetFixedCostOfVehicle(self, vehicle): 5228 r""" 5229 Returns the route fixed cost taken into account if the route of the 5230 vehicle is not empty, aka there's at least one node on the route other 5231 than the first and last nodes. 5232 """ 5233 return _pywrapcp.RoutingModel_GetFixedCostOfVehicle(self, vehicle) 5234 5235 def SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle): 5236 return _pywrapcp.RoutingModel_SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle) 5237 5238 def SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor): 5239 r""" 5240 The following methods set the linear and quadratic cost factors of 5241 vehicles (must be positive values). The default value of these parameters 5242 is zero for all vehicles. 5243 5244 When set, the cost_ of the model will contain terms aiming at reducing the 5245 number of vehicles used in the model, by adding the following to the 5246 objective for every vehicle v: 5247 INDICATOR(v used in the model) * 5248 [linear_cost_factor_of_vehicle_[v] 5249 - quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)] 5250 i.e. for every used vehicle, we add the linear factor as fixed cost, and 5251 subtract the square of the route length multiplied by the quadratic 5252 factor. This second term aims at making the routes as dense as possible. 5253 5254 Sets the linear and quadratic cost factor of all vehicles. 5255 """ 5256 return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor) 5257 5258 def SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle): 5259 r""" Sets the linear and quadratic cost factor of the given vehicle.""" 5260 return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle) 5261 5262 def GetAmortizedLinearCostFactorOfVehicles(self): 5263 return _pywrapcp.RoutingModel_GetAmortizedLinearCostFactorOfVehicles(self) 5264 5265 def GetAmortizedQuadraticCostFactorOfVehicles(self): 5266 return _pywrapcp.RoutingModel_GetAmortizedQuadraticCostFactorOfVehicles(self) 5267 5268 def SetVehicleUsedWhenEmpty(self, is_used, vehicle): 5269 return _pywrapcp.RoutingModel_SetVehicleUsedWhenEmpty(self, is_used, vehicle) 5270 5271 def IsVehicleUsedWhenEmpty(self, vehicle): 5272 return _pywrapcp.RoutingModel_IsVehicleUsedWhenEmpty(self, vehicle) 5273 5274 def SetFirstSolutionEvaluator(self, evaluator): 5275 r""" 5276 Gets/sets the evaluator used during the search. Only relevant when 5277 RoutingSearchParameters.first_solution_strategy = EVALUATOR_STRATEGY. 5278 Takes ownership of evaluator. 5279 """ 5280 return _pywrapcp.RoutingModel_SetFirstSolutionEvaluator(self, evaluator) 5281 5282 def AddLocalSearchOperator(self, ls_operator): 5283 r""" 5284 Adds a local search operator to the set of operators used to solve the 5285 vehicle routing problem. 5286 """ 5287 return _pywrapcp.RoutingModel_AddLocalSearchOperator(self, ls_operator) 5288 5289 def AddSearchMonitor(self, monitor): 5290 r""" Adds a search monitor to the search used to solve the routing model.""" 5291 return _pywrapcp.RoutingModel_AddSearchMonitor(self, monitor) 5292 5293 def AddAtSolutionCallback(self, callback, track_unchecked_neighbors=False): 5294 r""" 5295 Adds a callback called each time a solution is found during the search. 5296 This is a shortcut to creating a monitor to call the callback on 5297 AtSolution() and adding it with AddSearchMonitor. 5298 If track_unchecked_neighbors is true, the callback will also be called on 5299 AcceptUncheckedNeighbor() events, which is useful to grab solutions 5300 obtained when solver_parameters.check_solution_period > 1 (aka fastLS). 5301 """ 5302 return _pywrapcp.RoutingModel_AddAtSolutionCallback(self, callback, track_unchecked_neighbors) 5303 5304 def AddVariableMinimizedByFinalizer(self, var): 5305 r""" 5306 Adds a variable to minimize in the solution finalizer. The solution 5307 finalizer is called each time a solution is found during the search and 5308 allows to instantiate secondary variables (such as dimension cumul 5309 variables). 5310 """ 5311 return _pywrapcp.RoutingModel_AddVariableMinimizedByFinalizer(self, var) 5312 5313 def AddVariableMaximizedByFinalizer(self, var): 5314 r""" 5315 Adds a variable to maximize in the solution finalizer (see above for 5316 information on the solution finalizer). 5317 """ 5318 return _pywrapcp.RoutingModel_AddVariableMaximizedByFinalizer(self, var) 5319 5320 def AddWeightedVariableMinimizedByFinalizer(self, var, cost): 5321 r""" 5322 Adds a variable to minimize in the solution finalizer, with a weighted 5323 priority: the higher the more priority it has. 5324 """ 5325 return _pywrapcp.RoutingModel_AddWeightedVariableMinimizedByFinalizer(self, var, cost) 5326 5327 def AddWeightedVariableMaximizedByFinalizer(self, var, cost): 5328 r""" 5329 Adds a variable to maximize in the solution finalizer, with a weighted 5330 priority: the higher the more priority it has. 5331 """ 5332 return _pywrapcp.RoutingModel_AddWeightedVariableMaximizedByFinalizer(self, var, cost) 5333 5334 def AddVariableTargetToFinalizer(self, var, target): 5335 r""" 5336 Add a variable to set the closest possible to the target value in the 5337 solution finalizer. 5338 """ 5339 return _pywrapcp.RoutingModel_AddVariableTargetToFinalizer(self, var, target) 5340 5341 def AddWeightedVariableTargetToFinalizer(self, var, target, cost): 5342 r""" 5343 Same as above with a weighted priority: the higher the cost, the more 5344 priority it has to be set close to the target value. 5345 """ 5346 return _pywrapcp.RoutingModel_AddWeightedVariableTargetToFinalizer(self, var, target, cost) 5347 5348 def CloseModel(self): 5349 r""" 5350 Closes the current routing model; after this method is called, no 5351 modification to the model can be done, but RoutesToAssignment becomes 5352 available. Note that CloseModel() is automatically called by Solve() and 5353 other methods that produce solution. 5354 This is equivalent to calling 5355 CloseModelWithParameters(DefaultRoutingSearchParameters()). 5356 """ 5357 return _pywrapcp.RoutingModel_CloseModel(self) 5358 5359 def CloseModelWithParameters(self, search_parameters): 5360 r""" 5361 Same as above taking search parameters (as of 10/2015 some the parameters 5362 have to be set when closing the model). 5363 """ 5364 return _pywrapcp.RoutingModel_CloseModelWithParameters(self, search_parameters) 5365 5366 def Solve(self, assignment=None): 5367 r""" 5368 Solves the current routing model; closes the current model. 5369 This is equivalent to calling 5370 SolveWithParameters(DefaultRoutingSearchParameters()) 5371 or 5372 SolveFromAssignmentWithParameters(assignment, 5373 DefaultRoutingSearchParameters()). 5374 """ 5375 return _pywrapcp.RoutingModel_Solve(self, assignment) 5376 5377 def SolveWithParameters(self, search_parameters, solutions=None): 5378 r""" 5379 Solves the current routing model with the given parameters. If 'solutions' 5380 is specified, it will contain the k best solutions found during the search 5381 (from worst to best, including the one returned by this method), where k 5382 corresponds to the 'number_of_solutions_to_collect' in 5383 'search_parameters'. Note that the Assignment returned by the method and 5384 the ones in solutions are owned by the underlying solver and should not be 5385 deleted. 5386 """ 5387 return _pywrapcp.RoutingModel_SolveWithParameters(self, search_parameters, solutions) 5388 5389 def SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions=None): 5390 r""" 5391 Same as above, except that if assignment is not null, it will be used as 5392 the initial solution. 5393 """ 5394 return _pywrapcp.RoutingModel_SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions) 5395 5396 def FastSolveFromAssignmentWithParameters(self, assignment, search_parameters, check_solution_in_cp, touched=None): 5397 r""" 5398 Improves a given assignment using unchecked local search. 5399 If check_solution_in_cp is true the final solution will be checked with 5400 the CP solver. 5401 As of 11/2023, only works with greedy descent. 5402 """ 5403 return _pywrapcp.RoutingModel_FastSolveFromAssignmentWithParameters(self, assignment, search_parameters, check_solution_in_cp, touched) 5404 5405 def SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions=None): 5406 r""" 5407 Same as above but will try all assignments in order as first solutions 5408 until one succeeds. 5409 """ 5410 return _pywrapcp.RoutingModel_SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions) 5411 5412 def SolveWithIteratedLocalSearch(self, search_parameters): 5413 r""" 5414 Solves the current routing model by using an Iterated Local Search 5415 approach. 5416 """ 5417 return _pywrapcp.RoutingModel_SolveWithIteratedLocalSearch(self, search_parameters) 5418 5419 def SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment): 5420 r""" 5421 Given a "source_model" and its "source_assignment", resets 5422 "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_ 5423 if costs aren't homogeneous across vehicles) of "this" model, with the 5424 values set according to those in "other_assignment". 5425 The objective_element of target_assignment is set to this->cost_. 5426 """ 5427 return _pywrapcp.RoutingModel_SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment) 5428 5429 def ComputeLowerBound(self): 5430 r""" 5431 Computes a lower bound to the routing problem solving a linear assignment 5432 problem. The routing model must be closed before calling this method. 5433 Note that problems with node disjunction constraints (including optional 5434 nodes) and non-homogenous costs are not supported (the method returns 0 in 5435 these cases). 5436 """ 5437 return _pywrapcp.RoutingModel_ComputeLowerBound(self) 5438 5439 def objective_lower_bound(self): 5440 r""" 5441 Returns the current lower bound found by internal solvers during the 5442 search. 5443 """ 5444 return _pywrapcp.RoutingModel_objective_lower_bound(self) 5445 5446 def status(self): 5447 r""" Returns the current status of the routing model.""" 5448 return _pywrapcp.RoutingModel_status(self) 5449 5450 def enable_deep_serialization(self): 5451 r""" Returns the value of the internal enable_deep_serialization_ parameter.""" 5452 return _pywrapcp.RoutingModel_enable_deep_serialization(self) 5453 5454 def ApplyLocks(self, locks): 5455 r""" 5456 Applies a lock chain to the next search. 'locks' represents an ordered 5457 vector of nodes representing a partial route which will be fixed during 5458 the next search; it will constrain next variables such that: 5459 next[locks[i]] == locks[i+1]. 5460 5461 Returns the next variable at the end of the locked chain; this variable is 5462 not locked. An assignment containing the locks can be obtained by calling 5463 PreAssignment(). 5464 """ 5465 return _pywrapcp.RoutingModel_ApplyLocks(self, locks) 5466 5467 def ApplyLocksToAllVehicles(self, locks, close_routes): 5468 r""" 5469 Applies lock chains to all vehicles to the next search, such that locks[p] 5470 is the lock chain for route p. Returns false if the locks do not contain 5471 valid routes; expects that the routes do not contain the depots, 5472 i.e. there are empty vectors in place of empty routes. 5473 If close_routes is set to true, adds the end nodes to the route of each 5474 vehicle and deactivates other nodes. 5475 An assignment containing the locks can be obtained by calling 5476 PreAssignment(). 5477 """ 5478 return _pywrapcp.RoutingModel_ApplyLocksToAllVehicles(self, locks, close_routes) 5479 5480 def PreAssignment(self): 5481 r""" 5482 Returns an assignment used to fix some of the variables of the problem. 5483 In practice, this assignment locks partial routes of the problem. This 5484 can be used in the context of locking the parts of the routes which have 5485 already been driven in online routing problems. 5486 """ 5487 return _pywrapcp.RoutingModel_PreAssignment(self) 5488 5489 def MutablePreAssignment(self): 5490 return _pywrapcp.RoutingModel_MutablePreAssignment(self) 5491 5492 def WriteAssignment(self, file_name): 5493 r""" 5494 Writes the current solution to a file containing an AssignmentProto. 5495 Returns false if the file cannot be opened or if there is no current 5496 solution. 5497 """ 5498 return _pywrapcp.RoutingModel_WriteAssignment(self, file_name) 5499 5500 def ReadAssignment(self, file_name): 5501 r""" 5502 Reads an assignment from a file and returns the current solution. 5503 Returns nullptr if the file cannot be opened or if the assignment is not 5504 valid. 5505 """ 5506 return _pywrapcp.RoutingModel_ReadAssignment(self, file_name) 5507 5508 def RestoreAssignment(self, solution): 5509 r""" 5510 Restores an assignment as a solution in the routing model and returns the 5511 new solution. Returns nullptr if the assignment is not valid. 5512 """ 5513 return _pywrapcp.RoutingModel_RestoreAssignment(self, solution) 5514 5515 def ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices): 5516 r""" 5517 Restores the routes as the current solution. Returns nullptr if the 5518 solution cannot be restored (routes do not contain a valid solution). Note 5519 that calling this method will run the solver to assign values to the 5520 dimension variables; this may take considerable amount of time, especially 5521 when using dimensions with slack. 5522 """ 5523 return _pywrapcp.RoutingModel_ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices) 5524 5525 def RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment): 5526 r""" 5527 Fills an assignment from a specification of the routes of the 5528 vehicles. The routes are specified as lists of variable indices that 5529 appear on the routes of the vehicles. The indices of the outer vector in 5530 'routes' correspond to vehicles IDs, the inner vector contains the 5531 variable indices on the routes for the given vehicle. The inner vectors 5532 must not contain the start and end indices, as these are determined by the 5533 routing model. Sets the value of NextVars in the assignment, adding the 5534 variables to the assignment if necessary. The method does not touch other 5535 variables in the assignment. The method can only be called after the model 5536 is closed. With ignore_inactive_indices set to false, this method will 5537 fail (return nullptr) in case some of the route contain indices that are 5538 deactivated in the model; when set to true, these indices will be 5539 skipped. Returns true if routes were successfully 5540 loaded. However, such assignment still might not be a valid 5541 solution to the routing problem due to more complex constraints; 5542 it is advisible to call solver()->CheckSolution() afterwards. 5543 """ 5544 return _pywrapcp.RoutingModel_RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment) 5545 5546 def AssignmentToRoutes(self, assignment, routes): 5547 r""" 5548 Converts the solution in the given assignment to routes for all vehicles. 5549 Expects that assignment contains a valid solution (i.e. routes for all 5550 vehicles end with an end index for that vehicle). 5551 """ 5552 return _pywrapcp.RoutingModel_AssignmentToRoutes(self, assignment, routes) 5553 5554 def CompactAssignment(self, assignment): 5555 r""" 5556 Converts the solution in the given assignment to routes for all vehicles. 5557 If the returned vector is route_indices, route_indices[i][j] is the index 5558 for jth location visited on route i. Note that contrary to 5559 AssignmentToRoutes, the vectors do include start and end locations. 5560 Returns a compacted version of the given assignment, in which all vehicles 5561 with id lower or equal to some N have non-empty routes, and all vehicles 5562 with id greater than N have empty routes. Does not take ownership of the 5563 returned object. 5564 If found, the cost of the compact assignment is the same as in the 5565 original assignment and it preserves the values of 'active' variables. 5566 Returns nullptr if a compact assignment was not found. 5567 This method only works in homogenous mode, and it only swaps equivalent 5568 vehicles (vehicles with the same start and end nodes). When creating the 5569 compact assignment, the empty plan is replaced by the route assigned to 5570 the compatible vehicle with the highest id. Note that with more complex 5571 constraints on vehicle variables, this method might fail even if a compact 5572 solution exists. 5573 This method changes the vehicle and dimension variables as necessary. 5574 While compacting the solution, only basic checks on vehicle variables are 5575 performed; if one of these checks fails no attempts to repair it are made 5576 (instead, the method returns nullptr). 5577 """ 5578 return _pywrapcp.RoutingModel_CompactAssignment(self, assignment) 5579 5580 def CompactAndCheckAssignment(self, assignment): 5581 r""" 5582 Same as CompactAssignment() but also checks the validity of the final 5583 compact solution; if it is not valid, no attempts to repair it are made 5584 (instead, the method returns nullptr). 5585 """ 5586 return _pywrapcp.RoutingModel_CompactAndCheckAssignment(self, assignment) 5587 5588 def AddToAssignment(self, var): 5589 r""" Adds an extra variable to the vehicle routing assignment.""" 5590 return _pywrapcp.RoutingModel_AddToAssignment(self, var) 5591 5592 def AddIntervalToAssignment(self, interval): 5593 return _pywrapcp.RoutingModel_AddIntervalToAssignment(self, interval) 5594 5595 def PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached=None): 5596 r""" 5597 For every dimension in the model with an optimizer in 5598 local/global_dimension_optimizers_, this method tries to pack the cumul 5599 values of the dimension, such that: 5600 - The cumul costs (span costs, soft lower and upper bound costs, etc) are 5601 minimized. 5602 - The cumuls of the ends of the routes are minimized for this given 5603 minimal cumul cost. 5604 - Given these minimal end cumuls, the route start cumuls are maximized. 5605 Returns the assignment resulting from allocating these packed cumuls with 5606 the solver, and nullptr if these cumuls could not be set by the solver. 5607 """ 5608 return _pywrapcp.RoutingModel_PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached) 5609 5610 def GetOrCreateNodeNeighborsByCostClass(self, *args): 5611 r""" 5612 *Overload 1:* 5613 Returns neighbors of all nodes for every cost class. The result is cached 5614 and is computed once. The number of neighbors considered is based on a 5615 ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum 5616 of min-neighbors node considered. 5617 5618 | 5619 5620 *Overload 2:* 5621 Returns parameters.num_neighbors neighbors of all nodes for every cost 5622 class. The result is cached and is computed once. 5623 5624 | 5625 5626 *Overload 3:* 5627 Returns parameters.num_neighbors neighbors of all nodes for every cost 5628 class. The result is cached and is computed once. 5629 """ 5630 return _pywrapcp.RoutingModel_GetOrCreateNodeNeighborsByCostClass(self, *args) 5631 5632 def AddLocalSearchFilter(self, filter): 5633 r""" 5634 Adds a custom local search filter to the list of filters used to speed up 5635 local search by pruning unfeasible variable assignments. 5636 Calling this method after the routing model has been closed (CloseModel() 5637 or Solve() has been called) has no effect. 5638 The routing model does not take ownership of the filter. 5639 """ 5640 return _pywrapcp.RoutingModel_AddLocalSearchFilter(self, filter) 5641 5642 def Start(self, vehicle): 5643 r""" 5644 Model inspection. 5645 Returns the variable index of the starting node of a vehicle route. 5646 """ 5647 return _pywrapcp.RoutingModel_Start(self, vehicle) 5648 5649 def End(self, vehicle): 5650 r""" Returns the variable index of the ending node of a vehicle route.""" 5651 return _pywrapcp.RoutingModel_End(self, vehicle) 5652 5653 def IsStart(self, index): 5654 r""" Returns true if 'index' represents the first node of a route.""" 5655 return _pywrapcp.RoutingModel_IsStart(self, index) 5656 5657 def IsEnd(self, index): 5658 r""" Returns true if 'index' represents the last node of a route.""" 5659 return _pywrapcp.RoutingModel_IsEnd(self, index) 5660 5661 def VehicleIndex(self, index): 5662 r""" 5663 Returns the vehicle of the given start/end index, and -1 if the given 5664 index is not a vehicle start/end. 5665 """ 5666 return _pywrapcp.RoutingModel_VehicleIndex(self, index) 5667 5668 def Next(self, assignment, index): 5669 r""" 5670 Assignment inspection 5671 Returns the variable index of the node directly after the node 5672 corresponding to 'index' in 'assignment'. 5673 """ 5674 return _pywrapcp.RoutingModel_Next(self, assignment, index) 5675 5676 def IsVehicleUsed(self, assignment, vehicle): 5677 r""" Returns true if the route of 'vehicle' is non empty in 'assignment'.""" 5678 return _pywrapcp.RoutingModel_IsVehicleUsed(self, assignment, vehicle) 5679 5680 def NextVar(self, index): 5681 r""" 5682 Returns the next variable of the node corresponding to index. Note that 5683 NextVar(index) == index is equivalent to ActiveVar(index) == 0. 5684 """ 5685 return _pywrapcp.RoutingModel_NextVar(self, index) 5686 5687 def ActiveVar(self, index): 5688 r""" Returns the active variable of the node corresponding to index.""" 5689 return _pywrapcp.RoutingModel_ActiveVar(self, index) 5690 5691 def ActiveVehicleVar(self, vehicle): 5692 r""" 5693 Returns the active variable of the vehicle. It will be equal to 1 iff the 5694 route of the vehicle is not empty, 0 otherwise. 5695 """ 5696 return _pywrapcp.RoutingModel_ActiveVehicleVar(self, vehicle) 5697 5698 def VehicleRouteConsideredVar(self, vehicle): 5699 r""" 5700 Returns the variable specifying whether or not the given vehicle route is 5701 considered for costs and constraints. It will be equal to 1 iff the route 5702 of the vehicle is not empty OR vehicle_used_when_empty_[vehicle] is true. 5703 """ 5704 return _pywrapcp.RoutingModel_VehicleRouteConsideredVar(self, vehicle) 5705 5706 def VehicleVar(self, index): 5707 r""" 5708 Returns the vehicle variable of the node corresponding to index. Note that 5709 VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0. 5710 """ 5711 return _pywrapcp.RoutingModel_VehicleVar(self, index) 5712 5713 def ResourceVar(self, vehicle, resource_group): 5714 r""" 5715 Returns the resource variable for the given vehicle index in the given 5716 resource group. If a vehicle doesn't require a resource from the 5717 corresponding resource group, then ResourceVar(v, r_g) == -1. 5718 """ 5719 return _pywrapcp.RoutingModel_ResourceVar(self, vehicle, resource_group) 5720 5721 def CostVar(self): 5722 r""" Returns the global cost variable which is being minimized.""" 5723 return _pywrapcp.RoutingModel_CostVar(self) 5724 5725 def GetArcCostForVehicle(self, from_index, to_index, vehicle): 5726 r""" 5727 Returns the cost of the transit arc between two nodes for a given vehicle. 5728 Input are variable indices of node. This returns 0 if vehicle < 0. 5729 """ 5730 return _pywrapcp.RoutingModel_GetArcCostForVehicle(self, from_index, to_index, vehicle) 5731 5732 def CostsAreHomogeneousAcrossVehicles(self): 5733 r""" Whether costs are homogeneous across all vehicles.""" 5734 return _pywrapcp.RoutingModel_CostsAreHomogeneousAcrossVehicles(self) 5735 5736 def GetHomogeneousCost(self, from_index, to_index): 5737 r""" 5738 Returns the cost of the segment between two nodes supposing all vehicle 5739 costs are the same (returns the cost for the first vehicle otherwise). 5740 """ 5741 return _pywrapcp.RoutingModel_GetHomogeneousCost(self, from_index, to_index) 5742 5743 def GetArcCostForFirstSolution(self, from_index, to_index): 5744 r""" 5745 Returns the cost of the arc in the context of the first solution strategy. 5746 This is typically a simplification of the actual cost; see the .cc. 5747 """ 5748 return _pywrapcp.RoutingModel_GetArcCostForFirstSolution(self, from_index, to_index) 5749 5750 def GetArcCostForClass(self, from_index, to_index, cost_class_index): 5751 r""" 5752 Returns the cost of the segment between two nodes for a given cost 5753 class. Input are variable indices of nodes and the cost class. 5754 Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the 5755 returned cost won't necessarily be zero: only some of the components 5756 of the cost that depend on the cost class will be omited. See the code 5757 for details. 5758 """ 5759 return _pywrapcp.RoutingModel_GetArcCostForClass(self, from_index, to_index, cost_class_index) 5760 5761 def GetCostClassIndexOfVehicle(self, vehicle): 5762 r""" Get the cost class index of the given vehicle.""" 5763 return _pywrapcp.RoutingModel_GetCostClassIndexOfVehicle(self, vehicle) 5764 5765 def HasVehicleWithCostClassIndex(self, cost_class_index): 5766 r""" 5767 Returns true iff the model contains a vehicle with the given 5768 cost_class_index. 5769 """ 5770 return _pywrapcp.RoutingModel_HasVehicleWithCostClassIndex(self, cost_class_index) 5771 5772 def GetCostClassesCount(self): 5773 r""" Returns the number of different cost classes in the model.""" 5774 return _pywrapcp.RoutingModel_GetCostClassesCount(self) 5775 5776 def GetNonZeroCostClassesCount(self): 5777 r""" Ditto, minus the 'always zero', built-in cost class.""" 5778 return _pywrapcp.RoutingModel_GetNonZeroCostClassesCount(self) 5779 5780 def GetVehicleClassIndexOfVehicle(self, vehicle): 5781 return _pywrapcp.RoutingModel_GetVehicleClassIndexOfVehicle(self, vehicle) 5782 5783 def GetVehicleOfClass(self, vehicle_class): 5784 r""" 5785 Returns a vehicle of the given vehicle class, and -1 if there are no 5786 vehicles for this class. 5787 """ 5788 return _pywrapcp.RoutingModel_GetVehicleOfClass(self, vehicle_class) 5789 5790 def GetVehicleClassesCount(self): 5791 r""" Returns the number of different vehicle classes in the model.""" 5792 return _pywrapcp.RoutingModel_GetVehicleClassesCount(self) 5793 5794 def GetSameVehicleIndicesOfIndex(self, node): 5795 r""" Returns variable indices of nodes constrained to be on the same route.""" 5796 return _pywrapcp.RoutingModel_GetSameVehicleIndicesOfIndex(self, node) 5797 5798 def GetVehicleTypeContainer(self): 5799 return _pywrapcp.RoutingModel_GetVehicleTypeContainer(self) 5800 5801 def ArcIsMoreConstrainedThanArc(self, _from, to1, to2): 5802 r""" 5803 Returns whether the arc from->to1 is more constrained than from->to2, 5804 taking into account, in order: 5805 - whether the destination node isn't an end node 5806 - whether the destination node is mandatory 5807 - whether the destination node is bound to the same vehicle as the source 5808 - the "primary constrained" dimension (see SetPrimaryConstrainedDimension) 5809 It then breaks ties using, in order: 5810 - the arc cost (taking unperformed penalties into account) 5811 - the size of the vehicle vars of "to1" and "to2" (lowest size wins) 5812 - the value: the lowest value of the indices to1 and to2 wins. 5813 See the .cc for details. 5814 The more constrained arc is typically preferable when building a 5815 first solution. This method is intended to be used as a callback for the 5816 BestValueByComparisonSelector value selector. 5817 Args: 5818 from: the variable index of the source node 5819 to1: the variable index of the first candidate destination node. 5820 to2: the variable index of the second candidate destination node. 5821 """ 5822 return _pywrapcp.RoutingModel_ArcIsMoreConstrainedThanArc(self, _from, to1, to2) 5823 5824 def DebugOutputAssignment(self, solution_assignment, dimension_to_print): 5825 r""" 5826 Print some debugging information about an assignment, including the 5827 feasible intervals of the CumulVar for dimension "dimension_to_print" 5828 at each step of the routes. 5829 If "dimension_to_print" is omitted, all dimensions will be printed. 5830 """ 5831 return _pywrapcp.RoutingModel_DebugOutputAssignment(self, solution_assignment, dimension_to_print) 5832 5833 def CheckIfAssignmentIsFeasible(self, assignment, call_at_solution_monitors): 5834 r""" 5835 Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair 5836 containing the minimum and maximum of the CumulVar of the jth node on 5837 route i. 5838 - cumul_bounds[i][j].first is the minimum. 5839 - cumul_bounds[i][j].second is the maximum. 5840 Checks if an assignment is feasible. 5841 """ 5842 return _pywrapcp.RoutingModel_CheckIfAssignmentIsFeasible(self, assignment, call_at_solution_monitors) 5843 5844 def solver(self): 5845 r""" 5846 Returns the underlying constraint solver. Can be used to add extra 5847 constraints and/or modify search algorithms. 5848 """ 5849 return _pywrapcp.RoutingModel_solver(self) 5850 5851 def CheckLimit(self, *args): 5852 r""" 5853 Returns true if the search limit has been crossed with the given time 5854 offset. 5855 """ 5856 return _pywrapcp.RoutingModel_CheckLimit(self, *args) 5857 5858 def RemainingTime(self): 5859 r""" Returns the time left in the search limit.""" 5860 return _pywrapcp.RoutingModel_RemainingTime(self) 5861 5862 def UpdateTimeLimit(self, time_limit): 5863 r""" Updates the time limit of the search limit.""" 5864 return _pywrapcp.RoutingModel_UpdateTimeLimit(self, time_limit) 5865 5866 def TimeBuffer(self): 5867 r""" Returns the time buffer to safely return a solution.""" 5868 return _pywrapcp.RoutingModel_TimeBuffer(self) 5869 5870 def GetMutableCPSatInterrupt(self): 5871 r""" Returns the atomic<bool> to stop the CP-SAT solver.""" 5872 return _pywrapcp.RoutingModel_GetMutableCPSatInterrupt(self) 5873 5874 def GetMutableCPInterrupt(self): 5875 r""" Returns the atomic<bool> to stop the CP solver.""" 5876 return _pywrapcp.RoutingModel_GetMutableCPInterrupt(self) 5877 5878 def CancelSearch(self): 5879 r""" Cancels the current search.""" 5880 return _pywrapcp.RoutingModel_CancelSearch(self) 5881 5882 def nodes(self): 5883 r""" 5884 Sizes and indices 5885 Returns the number of nodes in the model. 5886 """ 5887 return _pywrapcp.RoutingModel_nodes(self) 5888 5889 def vehicles(self): 5890 r""" Returns the number of vehicle routes in the model.""" 5891 return _pywrapcp.RoutingModel_vehicles(self) 5892 5893 def Size(self): 5894 r""" Returns the number of next variables in the model.""" 5895 return _pywrapcp.RoutingModel_Size(self) 5896 5897 def GetNumberOfDecisionsInFirstSolution(self, search_parameters): 5898 r""" 5899 Returns statistics on first solution search, number of decisions sent to 5900 filters, number of decisions rejected by filters. 5901 """ 5902 return _pywrapcp.RoutingModel_GetNumberOfDecisionsInFirstSolution(self, search_parameters) 5903 5904 def GetNumberOfRejectsInFirstSolution(self, search_parameters): 5905 return _pywrapcp.RoutingModel_GetNumberOfRejectsInFirstSolution(self, search_parameters) 5906 5907 def GetAutomaticFirstSolutionStrategy(self): 5908 r""" Returns the automatic first solution strategy selected.""" 5909 return _pywrapcp.RoutingModel_GetAutomaticFirstSolutionStrategy(self) 5910 5911 def IsMatchingModel(self): 5912 r""" Returns true if a vehicle/node matching problem is detected.""" 5913 return _pywrapcp.RoutingModel_IsMatchingModel(self) 5914 5915 def AreRoutesInterdependent(self, parameters): 5916 r""" 5917 Returns true if routes are interdependent. This means that any 5918 modification to a route might impact another. 5919 """ 5920 return _pywrapcp.RoutingModel_AreRoutesInterdependent(self, parameters) 5921 5922 def MakeGuidedSlackFinalizer(self, dimension, initializer): 5923 r""" 5924 The next few members are in the public section only for testing purposes. 5925 5926 MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a 5927 dimension using a callback to choose which values to start with. 5928 The finalizer works only when all next variables in the model have 5929 been fixed. It has the following two characteristics: 5930 1. It follows the routes defined by the nexts variables when choosing a 5931 variable to make a decision on. 5932 2. When it comes to choose a value for the slack of node i, the decision 5933 builder first calls the callback with argument i, and supposingly the 5934 returned value is x it creates decisions slack[i] = x, slack[i] = x + 5935 1, slack[i] = x - 1, slack[i] = x + 2, etc. 5936 """ 5937 return _pywrapcp.RoutingModel_MakeGuidedSlackFinalizer(self, dimension, initializer) 5938 5939 def MakeSelfDependentDimensionFinalizer(self, dimension): 5940 r""" 5941 MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a 5942 self-dependent dimension. It makes an extensive use of the caches of the 5943 state dependent transits. 5944 In detail, MakeSelfDependentDimensionFinalizer returns a composition of a 5945 local search decision builder with a greedy descent operator for the cumul 5946 of the start of each route and a guided slack finalizer. Provided there 5947 are no time windows and the maximum slacks are large enough, once the 5948 cumul of the start of route is fixed, the guided finalizer can find 5949 optimal values of the slacks for the rest of the route in time 5950 proportional to the length of the route. Therefore the composed finalizer 5951 generally works in time O(log(t)*n*m), where t is the latest possible 5952 departute time, n is the number of nodes in the network and m is the 5953 number of vehicles. 5954 """ 5955 return _pywrapcp.RoutingModel_MakeSelfDependentDimensionFinalizer(self, dimension) 5956 5957 def GetPathsMetadata(self): 5958 return _pywrapcp.RoutingModel_GetPathsMetadata(self) 5959 5960# Register RoutingModel in _pywrapcp: 5961_pywrapcp.RoutingModel_swigregister(RoutingModel) 5962cvar = _pywrapcp.cvar 5963RoutingModel.kNoPenalty = _pywrapcp.cvar.RoutingModel_kNoPenalty 5964RoutingModel.kNoDisjunction = _pywrapcp.cvar.RoutingModel_kNoDisjunction 5965RoutingModel.kNoDimension = _pywrapcp.cvar.RoutingModel_kNoDimension 5966 5967class RoutingModelVisitor(BaseObject): 5968 r""" Routing model visitor.""" 5969 5970 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 5971 __repr__ = _swig_repr 5972 5973 def __init__(self): 5974 _pywrapcp.RoutingModelVisitor_swiginit(self, _pywrapcp.new_RoutingModelVisitor()) 5975 __swig_destroy__ = _pywrapcp.delete_RoutingModelVisitor 5976 5977# Register RoutingModelVisitor in _pywrapcp: 5978_pywrapcp.RoutingModelVisitor_swigregister(RoutingModelVisitor) 5979RoutingModelVisitor.kLightElement = _pywrapcp.cvar.RoutingModelVisitor_kLightElement 5980RoutingModelVisitor.kLightElement2 = _pywrapcp.cvar.RoutingModelVisitor_kLightElement2 5981RoutingModelVisitor.kRemoveValues = _pywrapcp.cvar.RoutingModelVisitor_kRemoveValues 5982 5983class GlobalVehicleBreaksConstraint(Constraint): 5984 r""" 5985 GlobalVehicleBreaksConstraint ensures breaks constraints are enforced on 5986 all vehicles in the dimension passed to its constructor. 5987 It is intended to be used for dimensions representing time. 5988 A break constraint ensures break intervals fit on the route of a vehicle. 5989 For a given vehicle, it forces break intervals to be disjoint from visit 5990 intervals, where visit intervals start at CumulVar(node) and last for 5991 node_visit_transit[node]. Moreover, it ensures that there is enough time 5992 between two consecutive nodes of a route to do transit and vehicle breaks, 5993 i.e. if Next(nodeA) = nodeB, CumulVar(nodeA) = tA and CumulVar(nodeB) = tB, 5994 then SlackVar(nodeA) >= sum_{breaks [tA, tB)} duration(break). 5995 """ 5996 5997 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 5998 __repr__ = _swig_repr 5999 6000 def __init__(self, dimension): 6001 _pywrapcp.GlobalVehicleBreaksConstraint_swiginit(self, _pywrapcp.new_GlobalVehicleBreaksConstraint(dimension)) 6002 6003 def DebugString(self): 6004 return _pywrapcp.GlobalVehicleBreaksConstraint_DebugString(self) 6005 6006 def Post(self): 6007 return _pywrapcp.GlobalVehicleBreaksConstraint_Post(self) 6008 6009 def InitialPropagateWrapper(self): 6010 return _pywrapcp.GlobalVehicleBreaksConstraint_InitialPropagateWrapper(self) 6011 __swig_destroy__ = _pywrapcp.delete_GlobalVehicleBreaksConstraint 6012 6013# Register GlobalVehicleBreaksConstraint in _pywrapcp: 6014_pywrapcp.GlobalVehicleBreaksConstraint_swigregister(GlobalVehicleBreaksConstraint) 6015class TypeRegulationsChecker(object): 6016 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6017 6018 def __init__(self, *args, **kwargs): 6019 raise AttributeError("No constructor defined - class is abstract") 6020 __repr__ = _swig_repr 6021 __swig_destroy__ = _pywrapcp.delete_TypeRegulationsChecker 6022 6023 def CheckVehicle(self, vehicle, next_accessor): 6024 return _pywrapcp.TypeRegulationsChecker_CheckVehicle(self, vehicle, next_accessor) 6025 6026# Register TypeRegulationsChecker in _pywrapcp: 6027_pywrapcp.TypeRegulationsChecker_swigregister(TypeRegulationsChecker) 6028class TypeIncompatibilityChecker(TypeRegulationsChecker): 6029 r""" Checker for type incompatibilities.""" 6030 6031 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6032 __repr__ = _swig_repr 6033 6034 def __init__(self, model, check_hard_incompatibilities): 6035 _pywrapcp.TypeIncompatibilityChecker_swiginit(self, _pywrapcp.new_TypeIncompatibilityChecker(model, check_hard_incompatibilities)) 6036 __swig_destroy__ = _pywrapcp.delete_TypeIncompatibilityChecker 6037 6038# Register TypeIncompatibilityChecker in _pywrapcp: 6039_pywrapcp.TypeIncompatibilityChecker_swigregister(TypeIncompatibilityChecker) 6040class TypeRequirementChecker(TypeRegulationsChecker): 6041 r""" Checker for type requirements.""" 6042 6043 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6044 __repr__ = _swig_repr 6045 6046 def __init__(self, model): 6047 _pywrapcp.TypeRequirementChecker_swiginit(self, _pywrapcp.new_TypeRequirementChecker(model)) 6048 __swig_destroy__ = _pywrapcp.delete_TypeRequirementChecker 6049 6050# Register TypeRequirementChecker in _pywrapcp: 6051_pywrapcp.TypeRequirementChecker_swigregister(TypeRequirementChecker) 6052class TypeRegulationsConstraint(Constraint): 6053 r""" 6054 The following constraint ensures that incompatibilities and requirements 6055 between types are respected. 6056 6057 It verifies both "hard" and "temporal" incompatibilities. 6058 Two nodes with hard incompatible types cannot be served by the same vehicle 6059 at all, while with a temporal incompatibility they can't be on the same 6060 route at the same time. 6061 The VisitTypePolicy of a node determines how visiting it impacts the type 6062 count on the route. 6063 6064 For example, for 6065 - three temporally incompatible types T1 T2 and T3 6066 - 2 pairs of nodes a1/r1 and a2/r2 of type T1 and T2 respectively, with 6067 - a1 and a2 of VisitTypePolicy TYPE_ADDED_TO_VEHICLE 6068 - r1 and r2 of policy ADDED_TYPE_REMOVED_FROM_VEHICLE 6069 - 3 nodes A, UV and AR of type T3, respectively with type policies 6070 TYPE_ADDED_TO_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT and 6071 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED 6072 the configurations 6073 UV --> a1 --> r1 --> a2 --> r2, a1 --> r1 --> a2 --> r2 --> A and 6074 a1 --> r1 --> AR --> a2 --> r2 are acceptable, whereas the configurations 6075 a1 --> a2 --> r1 --> ..., or A --> a1 --> r1 --> ..., or 6076 a1 --> r1 --> UV --> ... are not feasible. 6077 6078 It also verifies same-vehicle and temporal type requirements. 6079 A node of type T_d with a same-vehicle requirement for type T_r needs to be 6080 served by the same vehicle as a node of type T_r. 6081 Temporal requirements, on the other hand, can take effect either when the 6082 dependent type is being added to the route or when it's removed from it, 6083 which is determined by the dependent node's VisitTypePolicy. 6084 In the above example: 6085 - If T3 is required on the same vehicle as T1, A, AR or UV must be on the 6086 same vehicle as a1. 6087 - If T2 is required when adding T1, a2 must be visited *before* a1, and if 6088 r2 is also visited on the route, it must be *after* a1, i.e. T2 must be on 6089 the vehicle when a1 is visited: 6090 ... --> a2 --> ... --> a1 --> ... --> r2 --> ... 6091 - If T3 is required when removing T1, T3 needs to be on the vehicle when 6092 r1 is visited: 6093 ... --> A --> ... --> r1 --> ... OR ... --> r1 --> ... --> UV --> ... 6094 """ 6095 6096 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6097 __repr__ = _swig_repr 6098 6099 def __init__(self, model): 6100 _pywrapcp.TypeRegulationsConstraint_swiginit(self, _pywrapcp.new_TypeRegulationsConstraint(model)) 6101 6102 def Post(self): 6103 return _pywrapcp.TypeRegulationsConstraint_Post(self) 6104 6105 def InitialPropagateWrapper(self): 6106 return _pywrapcp.TypeRegulationsConstraint_InitialPropagateWrapper(self) 6107 __swig_destroy__ = _pywrapcp.delete_TypeRegulationsConstraint 6108 6109# Register TypeRegulationsConstraint in _pywrapcp: 6110_pywrapcp.TypeRegulationsConstraint_swigregister(TypeRegulationsConstraint) 6111class BoundCost(object): 6112 r""" 6113 A structure meant to store soft bounds and associated violation constants. 6114 It is 'Simple' because it has one BoundCost per element, 6115 in contrast to 'Multiple'. Design notes: 6116 - it is meant to store model information to be shared through pointers, 6117 so it disallows copy and assign to avoid accidental duplication. 6118 - it keeps soft bounds as an array of structs to help cache, 6119 because code that uses such bounds typically use both bound and cost. 6120 - soft bounds are named pairs, prevents some mistakes. 6121 - using operator[] to access elements is not interesting, 6122 because the structure will be accessed through pointers, moreover having 6123 to type bound_cost reminds the user of the order if they do a copy 6124 assignment of the element. 6125 """ 6126 6127 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6128 __repr__ = _swig_repr 6129 bound = property(_pywrapcp.BoundCost_bound_get, _pywrapcp.BoundCost_bound_set) 6130 cost = property(_pywrapcp.BoundCost_cost_get, _pywrapcp.BoundCost_cost_set) 6131 6132 def __init__(self, *args): 6133 _pywrapcp.BoundCost_swiginit(self, _pywrapcp.new_BoundCost(*args)) 6134 __swig_destroy__ = _pywrapcp.delete_BoundCost 6135 6136# Register BoundCost in _pywrapcp: 6137_pywrapcp.BoundCost_swigregister(BoundCost) 6138class SimpleBoundCosts(object): 6139 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6140 __repr__ = _swig_repr 6141 6142 def __init__(self, num_bounds, default_bound_cost): 6143 _pywrapcp.SimpleBoundCosts_swiginit(self, _pywrapcp.new_SimpleBoundCosts(num_bounds, default_bound_cost)) 6144 6145 def bound_cost(self, element): 6146 return _pywrapcp.SimpleBoundCosts_bound_cost(self, element) 6147 6148 def size(self): 6149 return _pywrapcp.SimpleBoundCosts_size(self) 6150 __swig_destroy__ = _pywrapcp.delete_SimpleBoundCosts 6151 6152# Register SimpleBoundCosts in _pywrapcp: 6153_pywrapcp.SimpleBoundCosts_swigregister(SimpleBoundCosts) 6154class RoutingDimension(object): 6155 r""" 6156 Dimensions represent quantities accumulated at nodes along the routes. They 6157 represent quantities such as weights or volumes carried along the route, or 6158 distance or times. 6159 6160 Quantities at a node are represented by "cumul" variables and the increase 6161 or decrease of quantities between nodes are represented by "transit" 6162 variables. These variables are linked as follows: 6163 6164 if j == next(i), 6165 cumuls(j) = cumuls(i) + transits(i) + slacks(i) + 6166 state_dependent_transits(i) 6167 6168 where slack is a positive slack variable (can represent waiting times for 6169 a time dimension), and state_dependent_transits is a non-purely functional 6170 version of transits_. Favour transits over state_dependent_transits when 6171 possible, because purely functional callbacks allow more optimisations and 6172 make the model faster and easier to solve. 6173 for a given vehicle, it is passed as an external vector, it would be better 6174 to have this information here. 6175 """ 6176 6177 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6178 6179 def __init__(self, *args, **kwargs): 6180 raise AttributeError("No constructor defined") 6181 __repr__ = _swig_repr 6182 __swig_destroy__ = _pywrapcp.delete_RoutingDimension 6183 6184 def model(self): 6185 r""" Returns the model on which the dimension was created.""" 6186 return _pywrapcp.RoutingDimension_model(self) 6187 6188 def GetTransitValue(self, from_index, to_index, vehicle): 6189 r""" 6190 Returns the transition value for a given pair of nodes (as var index); 6191 this value is the one taken by the corresponding transit variable when 6192 the 'next' variable for 'from_index' is bound to 'to_index'. 6193 """ 6194 return _pywrapcp.RoutingDimension_GetTransitValue(self, from_index, to_index, vehicle) 6195 6196 def GetTransitValueFromClass(self, from_index, to_index, vehicle_class): 6197 r""" 6198 Same as above but taking a vehicle class of the dimension instead of a 6199 vehicle (the class of a vehicle can be obtained with vehicle_to_class()). 6200 """ 6201 return _pywrapcp.RoutingDimension_GetTransitValueFromClass(self, from_index, to_index, vehicle_class) 6202 6203 def CumulVar(self, index): 6204 r""" 6205 Get the cumul, transit and slack variables for the given node (given as 6206 int64_t var index). 6207 """ 6208 return _pywrapcp.RoutingDimension_CumulVar(self, index) 6209 6210 def TransitVar(self, index): 6211 return _pywrapcp.RoutingDimension_TransitVar(self, index) 6212 6213 def FixedTransitVar(self, index): 6214 return _pywrapcp.RoutingDimension_FixedTransitVar(self, index) 6215 6216 def SlackVar(self, index): 6217 return _pywrapcp.RoutingDimension_SlackVar(self, index) 6218 6219 def SetSpanUpperBoundForVehicle(self, upper_bound, vehicle): 6220 r""" 6221 Sets an upper bound on the dimension span on a given vehicle. This is the 6222 preferred way to limit the "length" of the route of a vehicle according to 6223 a dimension. 6224 """ 6225 return _pywrapcp.RoutingDimension_SetSpanUpperBoundForVehicle(self, upper_bound, vehicle) 6226 6227 def SetSpanCostCoefficientForVehicle(self, coefficient, vehicle): 6228 r""" 6229 Sets a cost proportional to the dimension span on a given vehicle, 6230 or on all vehicles at once. "coefficient" must be nonnegative. 6231 This is handy to model costs proportional to idle time when the dimension 6232 represents time. 6233 The cost for a vehicle is 6234 span_cost = coefficient * (dimension end value - dimension start value). 6235 """ 6236 return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForVehicle(self, coefficient, vehicle) 6237 6238 def SetSpanCostCoefficientForAllVehicles(self, coefficient): 6239 return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForAllVehicles(self, coefficient) 6240 6241 def SetSlackCostCoefficientForVehicle(self, coefficient, vehicle): 6242 r""" 6243 Sets a cost proportional to the dimension total slack on a given vehicle, 6244 or on all vehicles at once. "coefficient" must be nonnegative. 6245 This is handy to model costs only proportional to idle time when the 6246 dimension represents time. 6247 The cost for a vehicle is 6248 slack_cost = coefficient * 6249 (dimension end value - dimension start value - total_transit). 6250 """ 6251 return _pywrapcp.RoutingDimension_SetSlackCostCoefficientForVehicle(self, coefficient, vehicle) 6252 6253 def SetSlackCostCoefficientForAllVehicles(self, coefficient): 6254 return _pywrapcp.RoutingDimension_SetSlackCostCoefficientForAllVehicles(self, coefficient) 6255 6256 def SetGlobalSpanCostCoefficient(self, coefficient): 6257 r""" 6258 Sets a cost proportional to the *global* dimension span, that is the 6259 difference between the largest value of route end cumul variables and 6260 the smallest value of route start cumul variables. 6261 In other words: 6262 global_span_cost = 6263 coefficient * (Max(dimension end value) - Min(dimension start value)). 6264 """ 6265 return _pywrapcp.RoutingDimension_SetGlobalSpanCostCoefficient(self, coefficient) 6266 6267 def SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient): 6268 r""" 6269 Sets a soft upper bound to the cumul variable of a given variable index. 6270 If the value of the cumul variable is greater than the bound, a cost 6271 proportional to the difference between this value and the bound is added 6272 to the cost function of the model: 6273 cumulVar <= upper_bound -> cost = 0 6274 cumulVar > upper_bound -> cost = coefficient * (cumulVar - upper_bound) 6275 This is also handy to model tardiness costs when the dimension represents 6276 time. 6277 """ 6278 return _pywrapcp.RoutingDimension_SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient) 6279 6280 def HasCumulVarSoftUpperBound(self, index): 6281 r""" 6282 Returns true if a soft upper bound has been set for a given variable 6283 index. 6284 """ 6285 return _pywrapcp.RoutingDimension_HasCumulVarSoftUpperBound(self, index) 6286 6287 def GetCumulVarSoftUpperBound(self, index): 6288 r""" 6289 Returns the soft upper bound of a cumul variable for a given variable 6290 index. The "hard" upper bound of the variable is returned if no soft upper 6291 bound has been set. 6292 """ 6293 return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBound(self, index) 6294 6295 def GetCumulVarSoftUpperBoundCoefficient(self, index): 6296 r""" 6297 Returns the cost coefficient of the soft upper bound of a cumul variable 6298 for a given variable index. If no soft upper bound has been set, 0 is 6299 returned. 6300 """ 6301 return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBoundCoefficient(self, index) 6302 6303 def SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient): 6304 r""" 6305 Sets a soft lower bound to the cumul variable of a given variable index. 6306 If the value of the cumul variable is less than the bound, a cost 6307 proportional to the difference between this value and the bound is added 6308 to the cost function of the model: 6309 cumulVar > lower_bound -> cost = 0 6310 cumulVar <= lower_bound -> cost = coefficient * (lower_bound - 6311 cumulVar). 6312 This is also handy to model earliness costs when the dimension represents 6313 time. 6314 """ 6315 return _pywrapcp.RoutingDimension_SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient) 6316 6317 def HasCumulVarSoftLowerBound(self, index): 6318 r""" 6319 Returns true if a soft lower bound has been set for a given variable 6320 index. 6321 """ 6322 return _pywrapcp.RoutingDimension_HasCumulVarSoftLowerBound(self, index) 6323 6324 def GetCumulVarSoftLowerBound(self, index): 6325 r""" 6326 Returns the soft lower bound of a cumul variable for a given variable 6327 index. The "hard" lower bound of the variable is returned if no soft lower 6328 bound has been set. 6329 """ 6330 return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBound(self, index) 6331 6332 def GetCumulVarSoftLowerBoundCoefficient(self, index): 6333 r""" 6334 Returns the cost coefficient of the soft lower bound of a cumul variable 6335 for a given variable index. If no soft lower bound has been set, 0 is 6336 returned. 6337 """ 6338 return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBoundCoefficient(self, index) 6339 6340 def SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits): 6341 r""" 6342 Sets the breaks for a given vehicle. Breaks are represented by 6343 IntervalVars. They may interrupt transits between nodes and increase 6344 the value of corresponding slack variables. 6345 A break may take place before the start of a vehicle, after the end of 6346 a vehicle, or during a travel i -> j. 6347 6348 In that case, the interval [break.Start(), break.End()) must be a subset 6349 of [CumulVar(i) + pre_travel(i, j), CumulVar(j) - post_travel(i, j)). In 6350 other words, a break may not overlap any node n's visit, given by 6351 [CumulVar(n) - post_travel(_, n), CumulVar(n) + pre_travel(n, _)). 6352 This formula considers post_travel(_, start) and pre_travel(end, _) to be 6353 0; pre_travel will never be called on any (_, start) and post_travel will 6354 never we called on any (end, _). If pre_travel_evaluator or 6355 post_travel_evaluator is -1, it will be taken as a function that always 6356 returns 0. 6357 Deprecated, sets pre_travel(i, j) = node_visit_transit[i]. 6358 """ 6359 return _pywrapcp.RoutingDimension_SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits) 6360 6361 def SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle): 6362 r""" 6363 With breaks supposed to be consecutive, this forces the distance between 6364 breaks of size at least minimum_break_duration to be at most distance. 6365 This supposes that the time until route start and after route end are 6366 infinite breaks. 6367 """ 6368 return _pywrapcp.RoutingDimension_SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle) 6369 6370 def InitializeBreaks(self): 6371 r""" 6372 Sets up vehicle_break_intervals_, vehicle_break_distance_duration_, 6373 pre_travel_evaluators and post_travel_evaluators. 6374 """ 6375 return _pywrapcp.RoutingDimension_InitializeBreaks(self) 6376 6377 def HasBreakConstraints(self): 6378 r""" Returns true if any break interval or break distance was defined.""" 6379 return _pywrapcp.RoutingDimension_HasBreakConstraints(self) 6380 6381 def GetPreTravelEvaluatorOfVehicle(self, vehicle): 6382 return _pywrapcp.RoutingDimension_GetPreTravelEvaluatorOfVehicle(self, vehicle) 6383 6384 def GetPostTravelEvaluatorOfVehicle(self, vehicle): 6385 return _pywrapcp.RoutingDimension_GetPostTravelEvaluatorOfVehicle(self, vehicle) 6386 6387 def base_dimension(self): 6388 r""" Returns the parent in the dependency tree if any or nullptr otherwise.""" 6389 return _pywrapcp.RoutingDimension_base_dimension(self) 6390 6391 def ShortestTransitionSlack(self, node): 6392 r""" 6393 It makes sense to use the function only for self-dependent dimension. 6394 For such dimensions the value of the slack of a node determines the 6395 transition cost of the next transit. Provided that 6396 1. cumul[node] is fixed, 6397 2. next[node] and next[next[node]] (if exists) are fixed, 6398 the value of slack[node] for which cumul[next[node]] + transit[next[node]] 6399 is minimized can be found in O(1) using this function. 6400 """ 6401 return _pywrapcp.RoutingDimension_ShortestTransitionSlack(self, node) 6402 6403 def name(self): 6404 r""" Returns the name of the dimension.""" 6405 return _pywrapcp.RoutingDimension_name(self) 6406 6407 def SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index): 6408 return _pywrapcp.RoutingDimension_SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index) 6409 6410 def HasPickupToDeliveryLimits(self): 6411 return _pywrapcp.RoutingDimension_HasPickupToDeliveryLimits(self) 6412 6413 def AddNodePrecedence(self, first_node, second_node, offset): 6414 return _pywrapcp.RoutingDimension_AddNodePrecedence(self, first_node, second_node, offset) 6415 6416 def GetSpanUpperBoundForVehicle(self, vehicle): 6417 return _pywrapcp.RoutingDimension_GetSpanUpperBoundForVehicle(self, vehicle) 6418 6419 def GetSpanCostCoefficientForVehicle(self, vehicle): 6420 return _pywrapcp.RoutingDimension_GetSpanCostCoefficientForVehicle(self, vehicle) 6421 6422 def GetSlackCostCoefficientForVehicle(self, vehicle): 6423 return _pywrapcp.RoutingDimension_GetSlackCostCoefficientForVehicle(self, vehicle) 6424 6425 def global_span_cost_coefficient(self): 6426 return _pywrapcp.RoutingDimension_global_span_cost_coefficient(self) 6427 6428 def GetGlobalOptimizerOffset(self): 6429 return _pywrapcp.RoutingDimension_GetGlobalOptimizerOffset(self) 6430 6431 def GetLocalOptimizerOffsetForVehicle(self, vehicle): 6432 return _pywrapcp.RoutingDimension_GetLocalOptimizerOffsetForVehicle(self, vehicle) 6433 6434 def SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle): 6435 r""" 6436 If the span of vehicle on this dimension is larger than bound, 6437 the cost will be increased by cost * (span - bound). 6438 """ 6439 return _pywrapcp.RoutingDimension_SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle) 6440 6441 def HasSoftSpanUpperBounds(self): 6442 return _pywrapcp.RoutingDimension_HasSoftSpanUpperBounds(self) 6443 6444 def GetSoftSpanUpperBoundForVehicle(self, vehicle): 6445 return _pywrapcp.RoutingDimension_GetSoftSpanUpperBoundForVehicle(self, vehicle) 6446 6447 def SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle): 6448 r""" 6449 If the span of vehicle on this dimension is larger than bound, 6450 the cost will be increased by cost * (span - bound)^2. 6451 """ 6452 return _pywrapcp.RoutingDimension_SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle) 6453 6454 def HasQuadraticCostSoftSpanUpperBounds(self): 6455 return _pywrapcp.RoutingDimension_HasQuadraticCostSoftSpanUpperBounds(self) 6456 6457 def GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle): 6458 return _pywrapcp.RoutingDimension_GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle) 6459 6460# Register RoutingDimension in _pywrapcp: 6461_pywrapcp.RoutingDimension_swigregister(RoutingDimension) 6462 6463def SolveModelWithSat(model, search_parameters, initial_solution, solution): 6464 r""" 6465 Attempts to solve the model using the cp-sat solver. As of 5/2019, will 6466 solve the TSP corresponding to the model if it has a single vehicle. 6467 Therefore the resulting solution might not actually be feasible. Will return 6468 false if a solution could not be found. 6469 """ 6470 return _pywrapcp.SolveModelWithSat(model, search_parameters, initial_solution, solution)
class
DefaultPhaseParameters:
64class DefaultPhaseParameters(object): 65 r""" 66 This struct holds all parameters for the default search. 67 DefaultPhaseParameters is only used by Solver::MakeDefaultPhase methods. 68 Note this is for advanced users only. 69 """ 70 71 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 72 __repr__ = _swig_repr 73 CHOOSE_MAX_SUM_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_SUM_IMPACT 74 CHOOSE_MAX_AVERAGE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_AVERAGE_IMPACT 75 CHOOSE_MAX_VALUE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_VALUE_IMPACT 76 SELECT_MIN_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MIN_IMPACT 77 SELECT_MAX_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MAX_IMPACT 78 NONE = _pywrapcp.DefaultPhaseParameters_NONE 79 NORMAL = _pywrapcp.DefaultPhaseParameters_NORMAL 80 VERBOSE = _pywrapcp.DefaultPhaseParameters_VERBOSE 81 var_selection_schema = property(_pywrapcp.DefaultPhaseParameters_var_selection_schema_get, _pywrapcp.DefaultPhaseParameters_var_selection_schema_set, doc=r""" 82 This parameter describes how the next variable to instantiate 83 will be chosen. 84 """) 85 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.""") 86 initialization_splits = property(_pywrapcp.DefaultPhaseParameters_initialization_splits_get, _pywrapcp.DefaultPhaseParameters_initialization_splits_set, doc=r""" 87 Maximum number of intervals that the initialization of impacts will scan 88 per variable. 89 """) 90 run_all_heuristics = property(_pywrapcp.DefaultPhaseParameters_run_all_heuristics_get, _pywrapcp.DefaultPhaseParameters_run_all_heuristics_set, doc=r""" 91 The default phase will run heuristics periodically. This parameter 92 indicates if we should run all heuristics, or a randomly selected 93 one. 94 """) 95 heuristic_period = property(_pywrapcp.DefaultPhaseParameters_heuristic_period_get, _pywrapcp.DefaultPhaseParameters_heuristic_period_set, doc=r""" 96 The distance in nodes between each run of the heuristics. A 97 negative or null value will mean that we will not run heuristics 98 at all. 99 """) 100 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.""") 101 persistent_impact = property(_pywrapcp.DefaultPhaseParameters_persistent_impact_get, _pywrapcp.DefaultPhaseParameters_persistent_impact_set, doc=r""" 102 Whether to keep the impact from the first search for other searches, 103 or to recompute the impact for each new search. 104 """) 105 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.""") 106 display_level = property(_pywrapcp.DefaultPhaseParameters_display_level_get, _pywrapcp.DefaultPhaseParameters_display_level_set, doc=r""" 107 This represents the amount of information displayed by the default search. 108 NONE means no display, VERBOSE means extra information. 109 """) 110 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.""") 111 112 def __init__(self): 113 _pywrapcp.DefaultPhaseParameters_swiginit(self, _pywrapcp.new_DefaultPhaseParameters()) 114 __swig_destroy__ = _pywrapcp.delete_DefaultPhaseParameters
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
71 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
initialization_splits
Maximum number of intervals that the initialization of impacts will scan per variable.
run_all_heuristics
The default phase will run heuristics periodically. This parameter indicates if we should run all heuristics, or a randomly selected one.
heuristic_period
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.
persistent_impact
Whether to keep the impact from the first search for other searches, or to recompute the impact for each new search.
class
Solver:
118class Solver(object): 119 r""" 120 Solver Class 121 122 A solver represents the main computation engine. It implements the entire 123 range of Constraint Programming protocols: 124 - Reversibility 125 - Propagation 126 - Search 127 128 Usually, Constraint Programming code consists of 129 - the creation of the Solver, 130 - the creation of the decision variables of the model, 131 - the creation of the constraints of the model and their addition to the 132 solver() through the AddConstraint() method, 133 - the creation of the main DecisionBuilder class, 134 - the launch of the solve() method with the decision builder. 135 136 For the time being, Solver is neither MT_SAFE nor MT_HOT. 137 """ 138 139 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 140 __repr__ = _swig_repr 141 INT_VAR_DEFAULT = _pywrapcp.Solver_INT_VAR_DEFAULT 142 r""" The default behavior is CHOOSE_FIRST_UNBOUND.""" 143 INT_VAR_SIMPLE = _pywrapcp.Solver_INT_VAR_SIMPLE 144 r""" The simple selection is CHOOSE_FIRST_UNBOUND.""" 145 CHOOSE_FIRST_UNBOUND = _pywrapcp.Solver_CHOOSE_FIRST_UNBOUND 146 r""" 147 Select the first unbound variable. 148 Variables are considered in the order of the vector of IntVars used 149 to create the selector. 150 """ 151 CHOOSE_RANDOM = _pywrapcp.Solver_CHOOSE_RANDOM 152 r""" Randomly select one of the remaining unbound variables.""" 153 CHOOSE_MIN_SIZE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MIN 154 r""" 155 Among unbound variables, select the variable with the smallest size, 156 i.e., the smallest number of possible values. 157 In case of a tie, the selected variables is the one with the lowest min 158 value. 159 In case of a tie, the first one is selected, first being defined by the 160 order in the vector of IntVars used to create the selector. 161 """ 162 CHOOSE_MIN_SIZE_HIGHEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MIN 163 r""" 164 Among unbound variables, select the variable with the smallest size, 165 i.e., the smallest number of possible values. 166 In case of a tie, the selected variable is the one with the highest min 167 value. 168 In case of a tie, the first one is selected, first being defined by the 169 order in the vector of IntVars used to create the selector. 170 """ 171 CHOOSE_MIN_SIZE_LOWEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MAX 172 r""" 173 Among unbound variables, select the variable with the smallest size, 174 i.e., the smallest number of possible values. 175 In case of a tie, the selected variables is the one with the lowest max 176 value. 177 In case of a tie, the first one is selected, first being defined by the 178 order in the vector of IntVars used to create the selector. 179 """ 180 CHOOSE_MIN_SIZE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MAX 181 r""" 182 Among unbound variables, select the variable with the smallest size, 183 i.e., the smallest number of possible values. 184 In case of a tie, the selected variable is the one with the highest max 185 value. 186 In case of a tie, the first one is selected, first being defined by the 187 order in the vector of IntVars used to create the selector. 188 """ 189 CHOOSE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_LOWEST_MIN 190 r""" 191 Among unbound variables, select the variable with the smallest minimal 192 value. 193 In case of a tie, the first one is selected, "first" defined by the 194 order in the vector of IntVars used to create the selector. 195 """ 196 CHOOSE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_HIGHEST_MAX 197 r""" 198 Among unbound variables, select the variable with the highest maximal 199 value. 200 In case of a tie, the first one is selected, first being defined by the 201 order in the vector of IntVars used to create the selector. 202 """ 203 CHOOSE_MIN_SIZE = _pywrapcp.Solver_CHOOSE_MIN_SIZE 204 r""" 205 Among unbound variables, select the variable with the smallest size. 206 In case of a tie, the first one is selected, first being defined by the 207 order in the vector of IntVars used to create the selector. 208 """ 209 CHOOSE_MAX_SIZE = _pywrapcp.Solver_CHOOSE_MAX_SIZE 210 r""" 211 Among unbound variables, select the variable with the highest size. 212 In case of a tie, the first one is selected, first being defined by the 213 order in the vector of IntVars used to create the selector. 214 """ 215 CHOOSE_MAX_REGRET_ON_MIN = _pywrapcp.Solver_CHOOSE_MAX_REGRET_ON_MIN 216 r""" 217 Among unbound variables, select the variable with the largest 218 gap between the first and the second values of the domain. 219 """ 220 CHOOSE_PATH = _pywrapcp.Solver_CHOOSE_PATH 221 r""" 222 Selects the next unbound variable on a path, the path being defined by 223 the variables: var[i] corresponds to the index of the next of i. 224 """ 225 INT_VALUE_DEFAULT = _pywrapcp.Solver_INT_VALUE_DEFAULT 226 r""" The default behavior is ASSIGN_MIN_VALUE.""" 227 INT_VALUE_SIMPLE = _pywrapcp.Solver_INT_VALUE_SIMPLE 228 r""" The simple selection is ASSIGN_MIN_VALUE.""" 229 ASSIGN_MIN_VALUE = _pywrapcp.Solver_ASSIGN_MIN_VALUE 230 r""" Selects the min value of the selected variable.""" 231 ASSIGN_MAX_VALUE = _pywrapcp.Solver_ASSIGN_MAX_VALUE 232 r""" Selects the max value of the selected variable.""" 233 ASSIGN_RANDOM_VALUE = _pywrapcp.Solver_ASSIGN_RANDOM_VALUE 234 r""" Selects randomly one of the possible values of the selected variable.""" 235 ASSIGN_CENTER_VALUE = _pywrapcp.Solver_ASSIGN_CENTER_VALUE 236 r""" 237 Selects the first possible value which is the closest to the center 238 of the domain of the selected variable. 239 The center is defined as (min + max) / 2. 240 """ 241 SPLIT_LOWER_HALF = _pywrapcp.Solver_SPLIT_LOWER_HALF 242 r""" 243 Split the domain in two around the center, and choose the lower 244 part first. 245 """ 246 SPLIT_UPPER_HALF = _pywrapcp.Solver_SPLIT_UPPER_HALF 247 r""" 248 Split the domain in two around the center, and choose the lower 249 part first. 250 """ 251 SEQUENCE_DEFAULT = _pywrapcp.Solver_SEQUENCE_DEFAULT 252 SEQUENCE_SIMPLE = _pywrapcp.Solver_SEQUENCE_SIMPLE 253 CHOOSE_MIN_SLACK_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_MIN_SLACK_RANK_FORWARD 254 CHOOSE_RANDOM_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_RANDOM_RANK_FORWARD 255 INTERVAL_DEFAULT = _pywrapcp.Solver_INTERVAL_DEFAULT 256 r""" The default is INTERVAL_SET_TIMES_FORWARD.""" 257 INTERVAL_SIMPLE = _pywrapcp.Solver_INTERVAL_SIMPLE 258 r""" The simple is INTERVAL_SET_TIMES_FORWARD.""" 259 INTERVAL_SET_TIMES_FORWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_FORWARD 260 r""" 261 Selects the variable with the lowest starting time of all variables, 262 and fixes its starting time to this lowest value. 263 """ 264 INTERVAL_SET_TIMES_BACKWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_BACKWARD 265 r""" 266 Selects the variable with the highest ending time of all variables, 267 and fixes the ending time to this highest values. 268 """ 269 TWOOPT = _pywrapcp.Solver_TWOOPT 270 r""" 271 Operator which reverses a sub-chain of a path. It is called TwoOpt 272 because it breaks two arcs on the path; resulting paths are called 273 two-optimal. 274 Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 275 (where (1, 5) are first and last nodes of the path and can therefore not 276 be moved): 277 1 -> [3 -> 2] -> 4 -> 5 278 1 -> [4 -> 3 -> 2] -> 5 279 1 -> 2 -> [4 -> 3] -> 5 280 """ 281 OROPT = _pywrapcp.Solver_OROPT 282 r""" 283 Relocate: OROPT and RELOCATE. 284 Operator which moves a sub-chain of a path to another position; the 285 specified chain length is the fixed length of the chains being moved. 286 When this length is 1, the operator simply moves a node to another 287 position. 288 Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5, for a chain 289 length of 2 (where (1, 5) are first and last nodes of the path and can 290 therefore not be moved): 291 1 -> 4 -> [2 -> 3] -> 5 292 1 -> [3 -> 4] -> 2 -> 5 293 294 Using Relocate with chain lengths of 1, 2 and 3 together is equivalent 295 to the OrOpt operator on a path. The OrOpt operator is a limited 296 version of 3Opt (breaks 3 arcs on a path). 297 """ 298 RELOCATE = _pywrapcp.Solver_RELOCATE 299 r""" Relocate neighborhood with length of 1 (see OROPT comment).""" 300 EXCHANGE = _pywrapcp.Solver_EXCHANGE 301 r""" 302 Operator which exchanges the positions of two nodes. 303 Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 304 (where (1, 5) are first and last nodes of the path and can therefore not 305 be moved): 306 1 -> [3] -> [2] -> 4 -> 5 307 1 -> [4] -> 3 -> [2] -> 5 308 1 -> 2 -> [4] -> [3] -> 5 309 """ 310 CROSS = _pywrapcp.Solver_CROSS 311 r""" 312 Operator which cross exchanges the starting chains of 2 paths, including 313 exchanging the whole paths. 314 First and last nodes are not moved. 315 Possible neighbors for the paths 1 -> 2 -> 3 -> 4 -> 5 and 6 -> 7 -> 8 316 (where (1, 5) and (6, 8) are first and last nodes of the paths and can 317 therefore not be moved): 318 1 -> [7] -> 3 -> 4 -> 5 6 -> [2] -> 8 319 1 -> [7] -> 4 -> 5 6 -> [2 -> 3] -> 8 320 1 -> [7] -> 5 6 -> [2 -> 3 -> 4] -> 8 321 """ 322 MAKEACTIVE = _pywrapcp.Solver_MAKEACTIVE 323 r""" 324 Operator which inserts an inactive node into a path. 325 Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive 326 (where 1 and 4 are first and last nodes of the path) are: 327 1 -> [5] -> 2 -> 3 -> 4 328 1 -> 2 -> [5] -> 3 -> 4 329 1 -> 2 -> 3 -> [5] -> 4 330 """ 331 MAKEINACTIVE = _pywrapcp.Solver_MAKEINACTIVE 332 r""" 333 Operator which makes path nodes inactive. 334 Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are 335 first and last nodes of the path) are: 336 1 -> 3 -> 4 with 2 inactive 337 1 -> 2 -> 4 with 3 inactive 338 """ 339 MAKECHAININACTIVE = _pywrapcp.Solver_MAKECHAININACTIVE 340 r""" 341 Operator which makes a "chain" of path nodes inactive. 342 Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are 343 first and last nodes of the path) are: 344 1 -> 3 -> 4 with 2 inactive 345 1 -> 2 -> 4 with 3 inactive 346 1 -> 4 with 2 and 3 inactive 347 """ 348 SWAPACTIVE = _pywrapcp.Solver_SWAPACTIVE 349 r""" 350 Operator which replaces an active node by an inactive one. 351 Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive 352 (where 1 and 4 are first and last nodes of the path) are: 353 1 -> [5] -> 3 -> 4 with 2 inactive 354 1 -> 2 -> [5] -> 4 with 3 inactive 355 """ 356 EXTENDEDSWAPACTIVE = _pywrapcp.Solver_EXTENDEDSWAPACTIVE 357 r""" 358 Operator which makes an inactive node active and an active one inactive. 359 It is similar to SwapActiveOperator except that it tries to insert the 360 inactive node in all possible positions instead of just the position of 361 the node made inactive. 362 Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive 363 (where 1 and 4 are first and last nodes of the path) are: 364 1 -> [5] -> 3 -> 4 with 2 inactive 365 1 -> 3 -> [5] -> 4 with 2 inactive 366 1 -> [5] -> 2 -> 4 with 3 inactive 367 1 -> 2 -> [5] -> 4 with 3 inactive 368 """ 369 PATHLNS = _pywrapcp.Solver_PATHLNS 370 r""" 371 Operator which relaxes two sub-chains of three consecutive arcs each. 372 Each sub-chain is defined by a start node and the next three arcs. Those 373 six arcs are relaxed to build a new neighbor. 374 PATHLNS explores all possible pairs of starting nodes and so defines 375 n^2 neighbors, n being the number of nodes. 376 Note that the two sub-chains can be part of the same path; they even may 377 overlap. 378 """ 379 FULLPATHLNS = _pywrapcp.Solver_FULLPATHLNS 380 r""" 381 Operator which relaxes one entire path and all inactive nodes, thus 382 defining num_paths neighbors. 383 """ 384 UNACTIVELNS = _pywrapcp.Solver_UNACTIVELNS 385 r""" 386 Operator which relaxes all inactive nodes and one sub-chain of six 387 consecutive arcs. That way the path can be improved by inserting 388 inactive nodes or swapping arcs. 389 """ 390 INCREMENT = _pywrapcp.Solver_INCREMENT 391 r""" 392 Operator which defines one neighbor per variable. Each neighbor tries to 393 increment by one the value of the corresponding variable. When a new 394 solution is found the neighborhood is rebuilt from scratch, i.e., tries 395 to increment values in the variable order. 396 Consider for instance variables x and y. x is incremented one by one to 397 its max, and when it is not possible to increment x anymore, y is 398 incremented once. If this is a solution, then next neighbor tries to 399 increment x. 400 """ 401 DECREMENT = _pywrapcp.Solver_DECREMENT 402 r""" 403 Operator which defines a neighborhood to decrement values. 404 The behavior is the same as INCREMENT, except values are decremented 405 instead of incremented. 406 """ 407 SIMPLELNS = _pywrapcp.Solver_SIMPLELNS 408 r""" 409 Operator which defines one neighbor per variable. Each neighbor relaxes 410 one variable. 411 When a new solution is found the neighborhood is rebuilt from scratch. 412 Consider for instance variables x and y. First x is relaxed and the 413 solver is looking for the best possible solution (with only x relaxed). 414 Then y is relaxed, and the solver is looking for a new solution. 415 If a new solution is found, then the next variable to be relaxed is x. 416 """ 417 GE = _pywrapcp.Solver_GE 418 r""" Move is accepted when the current objective value >= objective.Min.""" 419 LE = _pywrapcp.Solver_LE 420 r""" Move is accepted when the current objective value <= objective.Max.""" 421 EQ = _pywrapcp.Solver_EQ 422 r""" 423 Move is accepted when the current objective value is in the interval 424 objective.Min .. objective.Max. 425 """ 426 DELAYED_PRIORITY = _pywrapcp.Solver_DELAYED_PRIORITY 427 r""" 428 DELAYED_PRIORITY is the lowest priority: Demons will be processed after 429 VAR_PRIORITY and NORMAL_PRIORITY demons. 430 """ 431 VAR_PRIORITY = _pywrapcp.Solver_VAR_PRIORITY 432 r""" VAR_PRIORITY is between DELAYED_PRIORITY and NORMAL_PRIORITY.""" 433 NORMAL_PRIORITY = _pywrapcp.Solver_NORMAL_PRIORITY 434 r""" NORMAL_PRIORITY is the highest priority: Demons will be processed first.""" 435 436 def __init__(self, *args): 437 _pywrapcp.Solver_swiginit(self, _pywrapcp.new_Solver(*args)) 438 439 self.__python_constraints = [] 440 441 442 443 __swig_destroy__ = _pywrapcp.delete_Solver 444 445 def Parameters(self): 446 r""" Stored Parameters.""" 447 return _pywrapcp.Solver_Parameters(self) 448 449 @staticmethod 450 def DefaultSolverParameters(): 451 r""" Create a ConstraintSolverParameters proto with all the default values.""" 452 return _pywrapcp.Solver_DefaultSolverParameters() 453 454 def AddConstraint(self, c): 455 r""" 456 Adds the constraint 'c' to the model. 457 458 After calling this method, and until there is a backtrack that undoes the 459 addition, any assignment of variables to values must satisfy the given 460 constraint in order to be considered feasible. There are two fairly 461 different use cases: 462 463 - the most common use case is modeling: the given constraint is really 464 part of the problem that the user is trying to solve. In this use case, 465 AddConstraint is called outside of search (i.e., with state() == 466 OUTSIDE_SEARCH). Most users should only use AddConstraint in this 467 way. In this case, the constraint will belong to the model forever: it 468 cannot be removed by backtracking. 469 470 - a rarer use case is that 'c' is not a real constraint of the model. It 471 may be a constraint generated by a branching decision (a constraint whose 472 goal is to restrict the search space), a symmetry breaking constraint (a 473 constraint that does restrict the search space, but in a way that cannot 474 have an impact on the quality of the solutions in the subtree), or an 475 inferred constraint that, while having no semantic value to the model (it 476 does not restrict the set of solutions), is worth having because we 477 believe it may strengthen the propagation. In these cases, it happens 478 that the constraint is added during the search (i.e., with state() == 479 IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is 480 added during a search, it applies only to the subtree of the search tree 481 rooted at the current node, and will be automatically removed by 482 backtracking. 483 484 This method does not take ownership of the constraint. If the constraint 485 has been created by any factory method (Solver::MakeXXX), it will 486 automatically be deleted. However, power users who implement their own 487 constraints should do: solver.AddConstraint(solver.RevAlloc(new 488 MyConstraint(...)); 489 """ 490 return _pywrapcp.Solver_AddConstraint(self, c) 491 492 def Solve(self, *args): 493 return _pywrapcp.Solver_Solve(self, *args) 494 495 def NewSearch(self, *args): 496 return _pywrapcp.Solver_NewSearch(self, *args) 497 498 def NextSolution(self): 499 return _pywrapcp.Solver_NextSolution(self) 500 501 def RestartSearch(self): 502 return _pywrapcp.Solver_RestartSearch(self) 503 504 def EndSearch(self): 505 return _pywrapcp.Solver_EndSearch(self) 506 507 def SolveAndCommit(self, *args): 508 return _pywrapcp.Solver_SolveAndCommit(self, *args) 509 510 def CheckAssignment(self, solution): 511 r""" Checks whether the given assignment satisfies all relevant constraints.""" 512 return _pywrapcp.Solver_CheckAssignment(self, solution) 513 514 def CheckConstraint(self, ct): 515 r""" 516 Checks whether adding this constraint will lead to an immediate 517 failure. It will return false if the model is already inconsistent, or if 518 adding the constraint makes it inconsistent. 519 """ 520 return _pywrapcp.Solver_CheckConstraint(self, ct) 521 522 def Fail(self): 523 r""" Abandon the current branch in the search tree. A backtrack will follow.""" 524 return _pywrapcp.Solver_Fail(self) 525 526 @staticmethod 527 def MemoryUsage(): 528 r""" Current memory usage in bytes""" 529 return _pywrapcp.Solver_MemoryUsage() 530 531 def WallTime(self): 532 r""" 533 DEPRECATED: Use Now() instead. 534 Time elapsed, in ms since the creation of the solver. 535 """ 536 return _pywrapcp.Solver_WallTime(self) 537 538 def Branches(self): 539 r""" The number of branches explored since the creation of the solver.""" 540 return _pywrapcp.Solver_Branches(self) 541 542 def Solutions(self): 543 r""" The number of solutions found since the start of the search.""" 544 return _pywrapcp.Solver_Solutions(self) 545 546 def Failures(self): 547 r""" The number of failures encountered since the creation of the solver.""" 548 return _pywrapcp.Solver_Failures(self) 549 550 def AcceptedNeighbors(self): 551 r""" The number of accepted neighbors.""" 552 return _pywrapcp.Solver_AcceptedNeighbors(self) 553 554 def Stamp(self): 555 r""" 556 The stamp indicates how many moves in the search tree we have performed. 557 It is useful to detect if we need to update same lazy structures. 558 """ 559 return _pywrapcp.Solver_Stamp(self) 560 561 def FailStamp(self): 562 r""" The fail_stamp() is incremented after each backtrack.""" 563 return _pywrapcp.Solver_FailStamp(self) 564 565 def IntVar(self, *args): 566 r""" 567 *Overload 1:* 568 MakeIntVar will create the best range based int var for the bounds given. 569 570 | 571 572 *Overload 2:* 573 MakeIntVar will create a variable with the given sparse domain. 574 575 | 576 577 *Overload 3:* 578 MakeIntVar will create a variable with the given sparse domain. 579 580 | 581 582 *Overload 4:* 583 MakeIntVar will create the best range based int var for the bounds given. 584 585 | 586 587 *Overload 5:* 588 MakeIntVar will create a variable with the given sparse domain. 589 590 | 591 592 *Overload 6:* 593 MakeIntVar will create a variable with the given sparse domain. 594 """ 595 return _pywrapcp.Solver_IntVar(self, *args) 596 597 def BoolVar(self, *args): 598 r""" 599 *Overload 1:* 600 MakeBoolVar will create a variable with a {0, 1} domain. 601 602 | 603 604 *Overload 2:* 605 MakeBoolVar will create a variable with a {0, 1} domain. 606 """ 607 return _pywrapcp.Solver_BoolVar(self, *args) 608 609 def IntConst(self, *args): 610 r""" 611 *Overload 1:* 612 IntConst will create a constant expression. 613 614 | 615 616 *Overload 2:* 617 IntConst will create a constant expression. 618 """ 619 return _pywrapcp.Solver_IntConst(self, *args) 620 621 def Sum(self, vars): 622 r""" sum of all vars.""" 623 return _pywrapcp.Solver_Sum(self, vars) 624 625 def ScalProd(self, *args): 626 r""" 627 *Overload 1:* 628 scalar product 629 630 | 631 632 *Overload 2:* 633 scalar product 634 """ 635 return _pywrapcp.Solver_ScalProd(self, *args) 636 637 def MonotonicElement(self, values, increasing, index): 638 r""" 639 Function based element. The constraint takes ownership of the 640 callback. The callback must be monotonic. It must be able to 641 cope with any possible value in the domain of 'index' 642 (potentially negative ones too). Furtermore, monotonicity is not 643 checked. Thus giving a non-monotonic function, or specifying an 644 incorrect increasing parameter will result in undefined behavior. 645 """ 646 return _pywrapcp.Solver_MonotonicElement(self, values, increasing, index) 647 648 def Element(self, *args): 649 r""" 650 *Overload 1:* 651 values[index] 652 653 | 654 655 *Overload 2:* 656 values[index] 657 658 | 659 660 *Overload 3:* 661 Function-based element. The constraint takes ownership of the 662 callback. The callback must be able to cope with any possible 663 value in the domain of 'index' (potentially negative ones too). 664 665 | 666 667 *Overload 4:* 668 2D version of function-based element expression, values(expr1, expr2). 669 670 | 671 672 *Overload 5:* 673 vars[expr] 674 """ 675 return _pywrapcp.Solver_Element(self, *args) 676 677 def IndexExpression(self, vars, value): 678 r""" 679 Returns the expression expr such that vars[expr] == value. 680 It assumes that vars are all different. 681 """ 682 return _pywrapcp.Solver_IndexExpression(self, vars, value) 683 684 def Min(self, *args): 685 r""" 686 *Overload 1:* 687 std::min(vars) 688 689 | 690 691 *Overload 2:* 692 std::min (left, right) 693 694 | 695 696 *Overload 3:* 697 std::min(expr, value) 698 699 | 700 701 *Overload 4:* 702 std::min(expr, value) 703 """ 704 return _pywrapcp.Solver_Min(self, *args) 705 706 def Max(self, *args): 707 r""" 708 *Overload 1:* 709 std::max(vars) 710 711 | 712 713 *Overload 2:* 714 std::max(left, right) 715 716 | 717 718 *Overload 3:* 719 std::max(expr, value) 720 721 | 722 723 *Overload 4:* 724 std::max(expr, value) 725 """ 726 return _pywrapcp.Solver_Max(self, *args) 727 728 def ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost): 729 r""" Convex piecewise function.""" 730 return _pywrapcp.Solver_ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost) 731 732 def SemiContinuousExpr(self, expr, fixed_charge, step): 733 r""" 734 Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) 735 a >= 0 and b >= 0 736 """ 737 return _pywrapcp.Solver_SemiContinuousExpr(self, expr, fixed_charge, step) 738 739 def ConditionalExpression(self, condition, expr, unperformed_value): 740 r""" Conditional Expr condition ? expr : unperformed_value""" 741 return _pywrapcp.Solver_ConditionalExpression(self, condition, expr, unperformed_value) 742 743 def TrueConstraint(self): 744 r""" This constraint always succeeds.""" 745 return _pywrapcp.Solver_TrueConstraint(self) 746 747 def FalseConstraint(self, *args): 748 return _pywrapcp.Solver_FalseConstraint(self, *args) 749 750 def IsEqualCstCt(self, var, value, boolvar): 751 r""" boolvar == (var == value)""" 752 return _pywrapcp.Solver_IsEqualCstCt(self, var, value, boolvar) 753 754 def IsEqualCstVar(self, var, value): 755 r""" status var of (var == value)""" 756 return _pywrapcp.Solver_IsEqualCstVar(self, var, value) 757 758 def IsEqualCt(self, v1, v2, b): 759 r""" b == (v1 == v2)""" 760 return _pywrapcp.Solver_IsEqualCt(self, v1, v2, b) 761 762 def IsEqualVar(self, v1, v2): 763 r""" status var of (v1 == v2)""" 764 return _pywrapcp.Solver_IsEqualVar(self, v1, v2) 765 766 def IsDifferentCstCt(self, var, value, boolvar): 767 r""" boolvar == (var != value)""" 768 return _pywrapcp.Solver_IsDifferentCstCt(self, var, value, boolvar) 769 770 def IsDifferentCstVar(self, var, value): 771 r""" status var of (var != value)""" 772 return _pywrapcp.Solver_IsDifferentCstVar(self, var, value) 773 774 def IsDifferentVar(self, v1, v2): 775 r""" status var of (v1 != v2)""" 776 return _pywrapcp.Solver_IsDifferentVar(self, v1, v2) 777 778 def IsDifferentCt(self, v1, v2, b): 779 r""" b == (v1 != v2)""" 780 return _pywrapcp.Solver_IsDifferentCt(self, v1, v2, b) 781 782 def IsLessOrEqualCstCt(self, var, value, boolvar): 783 r""" boolvar == (var <= value)""" 784 return _pywrapcp.Solver_IsLessOrEqualCstCt(self, var, value, boolvar) 785 786 def IsLessOrEqualCstVar(self, var, value): 787 r""" status var of (var <= value)""" 788 return _pywrapcp.Solver_IsLessOrEqualCstVar(self, var, value) 789 790 def IsLessOrEqualVar(self, left, right): 791 r""" status var of (left <= right)""" 792 return _pywrapcp.Solver_IsLessOrEqualVar(self, left, right) 793 794 def IsLessOrEqualCt(self, left, right, b): 795 r""" b == (left <= right)""" 796 return _pywrapcp.Solver_IsLessOrEqualCt(self, left, right, b) 797 798 def IsGreaterOrEqualCstCt(self, var, value, boolvar): 799 r""" boolvar == (var >= value)""" 800 return _pywrapcp.Solver_IsGreaterOrEqualCstCt(self, var, value, boolvar) 801 802 def IsGreaterOrEqualCstVar(self, var, value): 803 r""" status var of (var >= value)""" 804 return _pywrapcp.Solver_IsGreaterOrEqualCstVar(self, var, value) 805 806 def IsGreaterOrEqualVar(self, left, right): 807 r""" status var of (left >= right)""" 808 return _pywrapcp.Solver_IsGreaterOrEqualVar(self, left, right) 809 810 def IsGreaterOrEqualCt(self, left, right, b): 811 r""" b == (left >= right)""" 812 return _pywrapcp.Solver_IsGreaterOrEqualCt(self, left, right, b) 813 814 def IsGreaterCstCt(self, v, c, b): 815 r""" b == (v > c)""" 816 return _pywrapcp.Solver_IsGreaterCstCt(self, v, c, b) 817 818 def IsGreaterCstVar(self, var, value): 819 r""" status var of (var > value)""" 820 return _pywrapcp.Solver_IsGreaterCstVar(self, var, value) 821 822 def IsGreaterVar(self, left, right): 823 r""" status var of (left > right)""" 824 return _pywrapcp.Solver_IsGreaterVar(self, left, right) 825 826 def IsGreaterCt(self, left, right, b): 827 r""" b == (left > right)""" 828 return _pywrapcp.Solver_IsGreaterCt(self, left, right, b) 829 830 def IsLessCstCt(self, v, c, b): 831 r""" b == (v < c)""" 832 return _pywrapcp.Solver_IsLessCstCt(self, v, c, b) 833 834 def IsLessCstVar(self, var, value): 835 r""" status var of (var < value)""" 836 return _pywrapcp.Solver_IsLessCstVar(self, var, value) 837 838 def IsLessVar(self, left, right): 839 r""" status var of (left < right)""" 840 return _pywrapcp.Solver_IsLessVar(self, left, right) 841 842 def IsLessCt(self, left, right, b): 843 r""" b == (left < right)""" 844 return _pywrapcp.Solver_IsLessCt(self, left, right, b) 845 846 def SumLessOrEqual(self, vars, cst): 847 r""" Variation on arrays.""" 848 return _pywrapcp.Solver_SumLessOrEqual(self, vars, cst) 849 850 def SumGreaterOrEqual(self, vars, cst): 851 return _pywrapcp.Solver_SumGreaterOrEqual(self, vars, cst) 852 853 def SumEquality(self, *args): 854 return _pywrapcp.Solver_SumEquality(self, *args) 855 856 def ScalProdEquality(self, *args): 857 return _pywrapcp.Solver_ScalProdEquality(self, *args) 858 859 def ScalProdGreaterOrEqual(self, *args): 860 return _pywrapcp.Solver_ScalProdGreaterOrEqual(self, *args) 861 862 def ScalProdLessOrEqual(self, *args): 863 return _pywrapcp.Solver_ScalProdLessOrEqual(self, *args) 864 865 def MinEquality(self, vars, min_var): 866 return _pywrapcp.Solver_MinEquality(self, vars, min_var) 867 868 def MaxEquality(self, vars, max_var): 869 return _pywrapcp.Solver_MaxEquality(self, vars, max_var) 870 871 def ElementEquality(self, *args): 872 return _pywrapcp.Solver_ElementEquality(self, *args) 873 874 def AbsEquality(self, var, abs_var): 875 r""" Creates the constraint abs(var) == abs_var.""" 876 return _pywrapcp.Solver_AbsEquality(self, var, abs_var) 877 878 def IndexOfConstraint(self, vars, index, target): 879 r""" 880 This constraint is a special case of the element constraint with 881 an array of integer variables, where the variables are all 882 different and the index variable is constrained such that 883 vars[index] == target. 884 """ 885 return _pywrapcp.Solver_IndexOfConstraint(self, vars, index, target) 886 887 def ConstraintInitialPropagateCallback(self, ct): 888 r""" 889 This method is a specialized case of the MakeConstraintDemon 890 method to call the InitiatePropagate of the constraint 'ct'. 891 """ 892 return _pywrapcp.Solver_ConstraintInitialPropagateCallback(self, ct) 893 894 def DelayedConstraintInitialPropagateCallback(self, ct): 895 r""" 896 This method is a specialized case of the MakeConstraintDemon 897 method to call the InitiatePropagate of the constraint 'ct' with 898 low priority. 899 """ 900 return _pywrapcp.Solver_DelayedConstraintInitialPropagateCallback(self, ct) 901 902 def ClosureDemon(self, closure): 903 r""" Creates a demon from a closure.""" 904 return _pywrapcp.Solver_ClosureDemon(self, closure) 905 906 def BetweenCt(self, expr, l, u): 907 r""" (l <= expr <= u)""" 908 return _pywrapcp.Solver_BetweenCt(self, expr, l, u) 909 910 def IsBetweenCt(self, expr, l, u, b): 911 r""" b == (l <= expr <= u)""" 912 return _pywrapcp.Solver_IsBetweenCt(self, expr, l, u, b) 913 914 def IsBetweenVar(self, v, l, u): 915 return _pywrapcp.Solver_IsBetweenVar(self, v, l, u) 916 917 def MemberCt(self, *args): 918 return _pywrapcp.Solver_MemberCt(self, *args) 919 920 def NotMemberCt(self, *args): 921 r""" 922 *Overload 1:* 923 expr not in set. 924 925 | 926 927 *Overload 2:* 928 expr should not be in the list of forbidden intervals [start[i]..end[i]]. 929 930 | 931 932 *Overload 3:* 933 expr should not be in the list of forbidden intervals [start[i]..end[i]]. 934 """ 935 return _pywrapcp.Solver_NotMemberCt(self, *args) 936 937 def IsMemberCt(self, *args): 938 return _pywrapcp.Solver_IsMemberCt(self, *args) 939 940 def IsMemberVar(self, *args): 941 return _pywrapcp.Solver_IsMemberVar(self, *args) 942 943 def Count(self, *args): 944 r""" 945 *Overload 1:* 946 |{i | vars[i] == value}| == max_count 947 948 | 949 950 *Overload 2:* 951 |{i | vars[i] == value}| == max_count 952 """ 953 return _pywrapcp.Solver_Count(self, *args) 954 955 def Distribute(self, *args): 956 r""" 957 *Overload 1:* 958 Aggregated version of count: |{i | v[i] == values[j]}| == cards[j] 959 960 | 961 962 *Overload 2:* 963 Aggregated version of count: |{i | v[i] == values[j]}| == cards[j] 964 965 | 966 967 *Overload 3:* 968 Aggregated version of count: |{i | v[i] == j}| == cards[j] 969 970 | 971 972 *Overload 4:* 973 Aggregated version of count with bounded cardinalities: 974 forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max 975 976 | 977 978 *Overload 5:* 979 Aggregated version of count with bounded cardinalities: 980 forall j in 0 .. card_size - 1: 981 card_min[j] <= |{i | v[i] == j}| <= card_max[j] 982 983 | 984 985 *Overload 6:* 986 Aggregated version of count with bounded cardinalities: 987 forall j in 0 .. card_size - 1: 988 card_min[j] <= |{i | v[i] == j}| <= card_max[j] 989 990 | 991 992 *Overload 7:* 993 Aggregated version of count with bounded cardinalities: 994 forall j in 0 .. card_size - 1: 995 card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j] 996 997 | 998 999 *Overload 8:* 1000 Aggregated version of count with bounded cardinalities: 1001 forall j in 0 .. card_size - 1: 1002 card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j] 1003 """ 1004 return _pywrapcp.Solver_Distribute(self, *args) 1005 1006 def Deviation(self, vars, deviation_var, total_sum): 1007 r""" 1008 Deviation constraint: 1009 sum_i |n * vars[i] - total_sum| <= deviation_var and 1010 sum_i vars[i] == total_sum 1011 n = #vars 1012 """ 1013 return _pywrapcp.Solver_Deviation(self, vars, deviation_var, total_sum) 1014 1015 def AllDifferent(self, *args): 1016 r""" 1017 *Overload 1:* 1018 All variables are pairwise different. This corresponds to the 1019 stronger version of the propagation algorithm. 1020 1021 | 1022 1023 *Overload 2:* 1024 All variables are pairwise different. If 'stronger_propagation' 1025 is true, stronger, and potentially slower propagation will 1026 occur. This API will be deprecated in the future. 1027 """ 1028 return _pywrapcp.Solver_AllDifferent(self, *args) 1029 1030 def AllDifferentExcept(self, vars, escape_value): 1031 r""" 1032 All variables are pairwise different, unless they are assigned to 1033 the escape value. 1034 """ 1035 return _pywrapcp.Solver_AllDifferentExcept(self, vars, escape_value) 1036 1037 def SortingConstraint(self, vars, sorted): 1038 r""" 1039 Creates a constraint binding the arrays of variables "vars" and 1040 "sorted_vars": sorted_vars[0] must be equal to the minimum of all 1041 variables in vars, and so on: the value of sorted_vars[i] must be 1042 equal to the i-th value of variables invars. 1043 1044 This constraint propagates in both directions: from "vars" to 1045 "sorted_vars" and vice-versa. 1046 1047 Behind the scenes, this constraint maintains that: 1048 - sorted is always increasing. 1049 - whatever the values of vars, there exists a permutation that 1050 injects its values into the sorted variables. 1051 1052 For more info, please have a look at: 1053 https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf 1054 """ 1055 return _pywrapcp.Solver_SortingConstraint(self, vars, sorted) 1056 1057 def LexicalLess(self, left, right): 1058 r""" 1059 Creates a constraint that enforces that left is lexicographically less 1060 than right. 1061 """ 1062 return _pywrapcp.Solver_LexicalLess(self, left, right) 1063 1064 def LexicalLessOrEqual(self, left, right): 1065 r""" 1066 Creates a constraint that enforces that left is lexicographically less 1067 than or equal to right. 1068 """ 1069 return _pywrapcp.Solver_LexicalLessOrEqual(self, left, right) 1070 1071 def InversePermutationConstraint(self, left, right): 1072 r""" 1073 Creates a constraint that enforces that 'left' and 'right' both 1074 represent permutations of [0..left.size()-1], and that 'right' is 1075 the inverse permutation of 'left', i.e. for all i in 1076 [0..left.size()-1], right[left[i]] = i. 1077 """ 1078 return _pywrapcp.Solver_InversePermutationConstraint(self, left, right) 1079 1080 def NullIntersect(self, first_vars, second_vars): 1081 r""" 1082 Creates a constraint that states that all variables in the first 1083 vector are different from all variables in the second 1084 group. Thus the set of values in the first vector does not 1085 intersect with the set of values in the second vector. 1086 """ 1087 return _pywrapcp.Solver_NullIntersect(self, first_vars, second_vars) 1088 1089 def NullIntersectExcept(self, first_vars, second_vars, escape_value): 1090 r""" 1091 Creates a constraint that states that all variables in the first 1092 vector are different from all variables from the second group, 1093 unless they are assigned to the escape value. Thus the set of 1094 values in the first vector minus the escape value does not 1095 intersect with the set of values in the second vector. 1096 """ 1097 return _pywrapcp.Solver_NullIntersectExcept(self, first_vars, second_vars, escape_value) 1098 1099 def Circuit(self, nexts): 1100 r""" Force the "nexts" variable to create a complete Hamiltonian path.""" 1101 return _pywrapcp.Solver_Circuit(self, nexts) 1102 1103 def SubCircuit(self, nexts): 1104 r""" 1105 Force the "nexts" variable to create a complete Hamiltonian path 1106 for those that do not loop upon themselves. 1107 """ 1108 return _pywrapcp.Solver_SubCircuit(self, nexts) 1109 1110 def DelayedPathCumul(self, nexts, active, cumuls, transits): 1111 r""" 1112 Delayed version of the same constraint: propagation on the nexts variables 1113 is delayed until all constraints have propagated. 1114 """ 1115 return _pywrapcp.Solver_DelayedPathCumul(self, nexts, active, cumuls, transits) 1116 1117 def PathCumul(self, *args): 1118 r""" 1119 *Overload 1:* 1120 Creates a constraint which accumulates values along a path such that: 1121 cumuls[next[i]] = cumuls[i] + transits[i]. 1122 Active variables indicate if the corresponding next variable is active; 1123 this could be useful to model unperformed nodes in a routing problem. 1124 1125 | 1126 1127 *Overload 2:* 1128 Creates a constraint which accumulates values along a path such that: 1129 cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). 1130 Active variables indicate if the corresponding next variable is active; 1131 this could be useful to model unperformed nodes in a routing problem. 1132 Ownership of transit_evaluator is taken and it must be a repeatable 1133 callback. 1134 1135 | 1136 1137 *Overload 3:* 1138 Creates a constraint which accumulates values along a path such that: 1139 cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. 1140 Active variables indicate if the corresponding next variable is active; 1141 this could be useful to model unperformed nodes in a routing problem. 1142 Ownership of transit_evaluator is taken and it must be a repeatable 1143 callback. 1144 """ 1145 return _pywrapcp.Solver_PathCumul(self, *args) 1146 1147 def AllowedAssignments(self, *args): 1148 r""" 1149 *Overload 1:* 1150 This method creates a constraint where the graph of the relation 1151 between the variables is given in extension. There are 'arity' 1152 variables involved in the relation and the graph is given by a 1153 integer tuple set. 1154 1155 | 1156 1157 *Overload 2:* 1158 Compatibility layer for Python API. 1159 """ 1160 return _pywrapcp.Solver_AllowedAssignments(self, *args) 1161 1162 def TransitionConstraint(self, *args): 1163 return _pywrapcp.Solver_TransitionConstraint(self, *args) 1164 1165 def NonOverlappingBoxesConstraint(self, *args): 1166 return _pywrapcp.Solver_NonOverlappingBoxesConstraint(self, *args) 1167 1168 def Pack(self, vars, number_of_bins): 1169 r""" 1170 This constraint packs all variables onto 'number_of_bins' 1171 variables. For any given variable, a value of 'number_of_bins' 1172 indicates that the variable is not assigned to any bin. 1173 Dimensions, i.e., cumulative constraints on this packing, can be 1174 added directly from the pack class. 1175 """ 1176 return _pywrapcp.Solver_Pack(self, vars, number_of_bins) 1177 1178 def FixedDurationIntervalVar(self, *args): 1179 r""" 1180 *Overload 1:* 1181 Creates an interval var with a fixed duration. The duration must 1182 be greater than 0. If optional is true, then the interval can be 1183 performed or unperformed. If optional is false, then the interval 1184 is always performed. 1185 1186 | 1187 1188 *Overload 2:* 1189 Creates a performed interval var with a fixed duration. The duration must 1190 be greater than 0. 1191 1192 | 1193 1194 *Overload 3:* 1195 Creates an interval var with a fixed duration, and performed_variable. 1196 The duration must be greater than 0. 1197 """ 1198 return _pywrapcp.Solver_FixedDurationIntervalVar(self, *args) 1199 1200 def FixedInterval(self, start, duration, name): 1201 r""" Creates a fixed and performed interval.""" 1202 return _pywrapcp.Solver_FixedInterval(self, start, duration, name) 1203 1204 def IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name): 1205 r""" 1206 Creates an interval var by specifying the bounds on start, 1207 duration, and end. 1208 """ 1209 return _pywrapcp.Solver_IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name) 1210 1211 def MirrorInterval(self, interval_var): 1212 r""" 1213 Creates an interval var that is the mirror image of the given one, that 1214 is, the interval var obtained by reversing the axis. 1215 """ 1216 return _pywrapcp.Solver_MirrorInterval(self, interval_var) 1217 1218 def FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset): 1219 r""" 1220 Creates an interval var with a fixed duration whose start is 1221 synchronized with the start of another interval, with a given 1222 offset. The performed status is also in sync with the performed 1223 status of the given interval variable. 1224 """ 1225 return _pywrapcp.Solver_FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset) 1226 1227 def FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset): 1228 r""" 1229 Creates an interval var with a fixed duration whose start is 1230 synchronized with the end of another interval, with a given 1231 offset. The performed status is also in sync with the performed 1232 status of the given interval variable. 1233 """ 1234 return _pywrapcp.Solver_FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset) 1235 1236 def FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset): 1237 r""" 1238 Creates an interval var with a fixed duration whose end is 1239 synchronized with the start of another interval, with a given 1240 offset. The performed status is also in sync with the performed 1241 status of the given interval variable. 1242 """ 1243 return _pywrapcp.Solver_FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset) 1244 1245 def FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset): 1246 r""" 1247 Creates an interval var with a fixed duration whose end is 1248 synchronized with the end of another interval, with a given 1249 offset. The performed status is also in sync with the performed 1250 status of the given interval variable. 1251 """ 1252 return _pywrapcp.Solver_FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset) 1253 1254 def IntervalRelaxedMin(self, interval_var): 1255 r""" 1256 Creates and returns an interval variable that wraps around the given one, 1257 relaxing the min start and end. Relaxing means making unbounded when 1258 optional. If the variable is non-optional, this method returns 1259 interval_var. 1260 1261 More precisely, such an interval variable behaves as follows: 1262 When the underlying must be performed, the returned interval variable 1263 behaves exactly as the underlying; 1264 When the underlying may or may not be performed, the returned interval 1265 variable behaves like the underlying, except that it is unbounded on 1266 the min side; 1267 When the underlying cannot be performed, the returned interval variable 1268 is of duration 0 and must be performed in an interval unbounded on 1269 both sides. 1270 1271 This is very useful to implement propagators that may only modify 1272 the start max or end max. 1273 """ 1274 return _pywrapcp.Solver_IntervalRelaxedMin(self, interval_var) 1275 1276 def IntervalRelaxedMax(self, interval_var): 1277 r""" 1278 Creates and returns an interval variable that wraps around the given one, 1279 relaxing the max start and end. Relaxing means making unbounded when 1280 optional. If the variable is non optional, this method returns 1281 interval_var. 1282 1283 More precisely, such an interval variable behaves as follows: 1284 When the underlying must be performed, the returned interval variable 1285 behaves exactly as the underlying; 1286 When the underlying may or may not be performed, the returned interval 1287 variable behaves like the underlying, except that it is unbounded on 1288 the max side; 1289 When the underlying cannot be performed, the returned interval variable 1290 is of duration 0 and must be performed in an interval unbounded on 1291 both sides. 1292 1293 This is very useful for implementing propagators that may only modify 1294 the start min or end min. 1295 """ 1296 return _pywrapcp.Solver_IntervalRelaxedMax(self, interval_var) 1297 1298 def TemporalDisjunction(self, *args): 1299 r""" 1300 *Overload 1:* 1301 This constraint implements a temporal disjunction between two 1302 interval vars t1 and t2. 'alt' indicates which alternative was 1303 chosen (alt == 0 is equivalent to t1 before t2). 1304 1305 | 1306 1307 *Overload 2:* 1308 This constraint implements a temporal disjunction between two 1309 interval vars. 1310 """ 1311 return _pywrapcp.Solver_TemporalDisjunction(self, *args) 1312 1313 def DisjunctiveConstraint(self, intervals, name): 1314 r""" 1315 This constraint forces all interval vars into an non-overlapping 1316 sequence. Intervals with zero duration can be scheduled anywhere. 1317 """ 1318 return _pywrapcp.Solver_DisjunctiveConstraint(self, intervals, name) 1319 1320 def Cumulative(self, *args): 1321 r""" 1322 *Overload 1:* 1323 This constraint forces that, for any integer t, the sum of the demands 1324 corresponding to an interval containing t does not exceed the given 1325 capacity. 1326 1327 Intervals and demands should be vectors of equal size. 1328 1329 Demands should only contain non-negative values. Zero values are 1330 supported, and the corresponding intervals are filtered out, as they 1331 neither impact nor are impacted by this constraint. 1332 1333 | 1334 1335 *Overload 2:* 1336 This constraint forces that, for any integer t, the sum of the demands 1337 corresponding to an interval containing t does not exceed the given 1338 capacity. 1339 1340 Intervals and demands should be vectors of equal size. 1341 1342 Demands should only contain non-negative values. Zero values are 1343 supported, and the corresponding intervals are filtered out, as they 1344 neither impact nor are impacted by this constraint. 1345 1346 | 1347 1348 *Overload 3:* 1349 This constraint forces that, for any integer t, the sum of the demands 1350 corresponding to an interval containing t does not exceed the given 1351 capacity. 1352 1353 Intervals and demands should be vectors of equal size. 1354 1355 Demands should only contain non-negative values. Zero values are 1356 supported, and the corresponding intervals are filtered out, as they 1357 neither impact nor are impacted by this constraint. 1358 1359 | 1360 1361 *Overload 4:* 1362 This constraint enforces that, for any integer t, the sum of the demands 1363 corresponding to an interval containing t does not exceed the given 1364 capacity. 1365 1366 Intervals and demands should be vectors of equal size. 1367 1368 Demands should only contain non-negative values. Zero values are 1369 supported, and the corresponding intervals are filtered out, as they 1370 neither impact nor are impacted by this constraint. 1371 1372 | 1373 1374 *Overload 5:* 1375 This constraint enforces that, for any integer t, the sum of demands 1376 corresponding to an interval containing t does not exceed the given 1377 capacity. 1378 1379 Intervals and demands should be vectors of equal size. 1380 1381 Demands should be positive. 1382 1383 | 1384 1385 *Overload 6:* 1386 This constraint enforces that, for any integer t, the sum of demands 1387 corresponding to an interval containing t does not exceed the given 1388 capacity. 1389 1390 Intervals and demands should be vectors of equal size. 1391 1392 Demands should be positive. 1393 """ 1394 return _pywrapcp.Solver_Cumulative(self, *args) 1395 1396 def Cover(self, vars, target_var): 1397 r""" 1398 This constraint states that the target_var is the convex hull of 1399 the intervals. If none of the interval variables is performed, 1400 then the target var is unperformed too. Also, if the target 1401 variable is unperformed, then all the intervals variables are 1402 unperformed too. 1403 """ 1404 return _pywrapcp.Solver_Cover(self, vars, target_var) 1405 1406 def Assignment(self, *args): 1407 r""" 1408 *Overload 1:* 1409 This method creates an empty assignment. 1410 1411 | 1412 1413 *Overload 2:* 1414 This method creates an assignment which is a copy of 'a'. 1415 """ 1416 return _pywrapcp.Solver_Assignment(self, *args) 1417 1418 def FirstSolutionCollector(self, *args): 1419 r""" 1420 *Overload 1:* 1421 Collect the first solution of the search. 1422 1423 | 1424 1425 *Overload 2:* 1426 Collect the first solution of the search. The variables will need to 1427 be added later. 1428 """ 1429 return _pywrapcp.Solver_FirstSolutionCollector(self, *args) 1430 1431 def LastSolutionCollector(self, *args): 1432 r""" 1433 *Overload 1:* 1434 Collect the last solution of the search. 1435 1436 | 1437 1438 *Overload 2:* 1439 Collect the last solution of the search. The variables will need to 1440 be added later. 1441 """ 1442 return _pywrapcp.Solver_LastSolutionCollector(self, *args) 1443 1444 def BestValueSolutionCollector(self, *args): 1445 r""" 1446 *Overload 1:* 1447 Collect the solution corresponding to the optimal value of the objective 1448 of 'assignment'; if 'assignment' does not have an objective no solution is 1449 collected. This collector only collects one solution corresponding to the 1450 best objective value (the first one found). 1451 1452 | 1453 1454 *Overload 2:* 1455 Collect the solution corresponding to the optimal value of the 1456 objective of the internal assignment; if this assignment does not have an 1457 objective no solution is collected. This collector only collects one 1458 solution corresponding to the best objective value (the first one found). 1459 The variables and objective(s) will need to be added later. 1460 """ 1461 return _pywrapcp.Solver_BestValueSolutionCollector(self, *args) 1462 1463 def AllSolutionCollector(self, *args): 1464 r""" 1465 *Overload 1:* 1466 Collect all solutions of the search. 1467 1468 | 1469 1470 *Overload 2:* 1471 Collect all solutions of the search. The variables will need to 1472 be added later. 1473 """ 1474 return _pywrapcp.Solver_AllSolutionCollector(self, *args) 1475 1476 def Minimize(self, v, step): 1477 r""" Creates a minimization objective.""" 1478 return _pywrapcp.Solver_Minimize(self, v, step) 1479 1480 def Maximize(self, v, step): 1481 r""" Creates a maximization objective.""" 1482 return _pywrapcp.Solver_Maximize(self, v, step) 1483 1484 def Optimize(self, maximize, v, step): 1485 r""" Creates a objective with a given sense (true = maximization).""" 1486 return _pywrapcp.Solver_Optimize(self, maximize, v, step) 1487 1488 def WeightedMinimize(self, *args): 1489 r""" 1490 *Overload 1:* 1491 Creates a minimization weighted objective. The actual objective is 1492 scalar_prod(sub_objectives, weights). 1493 1494 | 1495 1496 *Overload 2:* 1497 Creates a minimization weighted objective. The actual objective is 1498 scalar_prod(sub_objectives, weights). 1499 """ 1500 return _pywrapcp.Solver_WeightedMinimize(self, *args) 1501 1502 def WeightedMaximize(self, *args): 1503 r""" 1504 *Overload 1:* 1505 Creates a maximization weigthed objective. 1506 1507 | 1508 1509 *Overload 2:* 1510 Creates a maximization weigthed objective. 1511 """ 1512 return _pywrapcp.Solver_WeightedMaximize(self, *args) 1513 1514 def WeightedOptimize(self, *args): 1515 r""" 1516 *Overload 1:* 1517 Creates a weighted objective with a given sense (true = maximization). 1518 1519 | 1520 1521 *Overload 2:* 1522 Creates a weighted objective with a given sense (true = maximization). 1523 """ 1524 return _pywrapcp.Solver_WeightedOptimize(self, *args) 1525 1526 def TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor): 1527 r""" 1528 MetaHeuristics which try to get the search out of local optima. 1529 Creates a Tabu Search monitor. 1530 In the context of local search the behavior is similar to MakeOptimize(), 1531 creating an objective in a given sense. The behavior differs once a local 1532 optimum is reached: thereafter solutions which degrade the value of the 1533 objective are allowed if they are not "tabu". A solution is "tabu" if it 1534 doesn't respect the following rules: 1535 - improving the best solution found so far 1536 - variables in the "keep" list must keep their value, variables in the 1537 "forbid" list must not take the value they have in the list. 1538 Variables with new values enter the tabu lists after each new solution 1539 found and leave the lists after a given number of iterations (called 1540 tenure). Only the variables passed to the method can enter the lists. 1541 The tabu criterion is softened by the tabu factor which gives the number 1542 of "tabu" violations which is tolerated; a factor of 1 means no violations 1543 allowed; a factor of 0 means all violations are allowed. 1544 """ 1545 return _pywrapcp.Solver_TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor) 1546 1547 def SimulatedAnnealing(self, maximize, v, step, initial_temperature): 1548 r""" Creates a Simulated Annealing monitor.""" 1549 return _pywrapcp.Solver_SimulatedAnnealing(self, maximize, v, step, initial_temperature) 1550 1551 def LubyRestart(self, scale_factor): 1552 r""" 1553 This search monitor will restart the search periodically. 1554 At the iteration n, it will restart after scale_factor * Luby(n) failures 1555 where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...). 1556 """ 1557 return _pywrapcp.Solver_LubyRestart(self, scale_factor) 1558 1559 def ConstantRestart(self, frequency): 1560 r""" 1561 This search monitor will restart the search periodically after 'frequency' 1562 failures. 1563 """ 1564 return _pywrapcp.Solver_ConstantRestart(self, frequency) 1565 1566 def TimeLimit(self, *args): 1567 return _pywrapcp.Solver_TimeLimit(self, *args) 1568 1569 def BranchesLimit(self, branches): 1570 r""" 1571 Creates a search limit that constrains the number of branches 1572 explored in the search tree. 1573 """ 1574 return _pywrapcp.Solver_BranchesLimit(self, branches) 1575 1576 def FailuresLimit(self, failures): 1577 r""" 1578 Creates a search limit that constrains the number of failures 1579 that can happen when exploring the search tree. 1580 """ 1581 return _pywrapcp.Solver_FailuresLimit(self, failures) 1582 1583 def SolutionsLimit(self, solutions): 1584 r""" 1585 Creates a search limit that constrains the number of solutions found 1586 during the search. 1587 """ 1588 return _pywrapcp.Solver_SolutionsLimit(self, solutions) 1589 1590 def Limit(self, *args): 1591 r""" 1592 *Overload 1:* 1593 Limits the search with the 'time', 'branches', 'failures' and 1594 'solutions' limits. 'smart_time_check' reduces the calls to the wall 1595 1596 | 1597 1598 *Overload 2:* 1599 Creates a search limit from its protobuf description 1600 1601 | 1602 1603 *Overload 3:* 1604 Creates a search limit that is reached when either of the underlying limit 1605 is reached. That is, the returned limit is more stringent than both 1606 argument limits. 1607 """ 1608 return _pywrapcp.Solver_Limit(self, *args) 1609 1610 def CustomLimit(self, limiter): 1611 r""" 1612 Callback-based search limit. Search stops when limiter returns true; if 1613 this happens at a leaf the corresponding solution will be rejected. 1614 """ 1615 return _pywrapcp.Solver_CustomLimit(self, limiter) 1616 1617 def SearchLog(self, *args): 1618 return _pywrapcp.Solver_SearchLog(self, *args) 1619 1620 def SearchTrace(self, prefix): 1621 r""" 1622 Creates a search monitor that will trace precisely the behavior of the 1623 search. Use this only for low level debugging. 1624 """ 1625 return _pywrapcp.Solver_SearchTrace(self, prefix) 1626 1627 def PrintModelVisitor(self): 1628 r""" Prints the model.""" 1629 return _pywrapcp.Solver_PrintModelVisitor(self) 1630 1631 def StatisticsModelVisitor(self): 1632 r""" Displays some nice statistics on the model.""" 1633 return _pywrapcp.Solver_StatisticsModelVisitor(self) 1634 1635 def AssignVariableValue(self, var, val): 1636 r""" Decisions.""" 1637 return _pywrapcp.Solver_AssignVariableValue(self, var, val) 1638 1639 def VariableLessOrEqualValue(self, var, value): 1640 return _pywrapcp.Solver_VariableLessOrEqualValue(self, var, value) 1641 1642 def VariableGreaterOrEqualValue(self, var, value): 1643 return _pywrapcp.Solver_VariableGreaterOrEqualValue(self, var, value) 1644 1645 def SplitVariableDomain(self, var, val, start_with_lower_half): 1646 return _pywrapcp.Solver_SplitVariableDomain(self, var, val, start_with_lower_half) 1647 1648 def AssignVariableValueOrFail(self, var, value): 1649 return _pywrapcp.Solver_AssignVariableValueOrFail(self, var, value) 1650 1651 def AssignVariablesValues(self, vars, values): 1652 return _pywrapcp.Solver_AssignVariablesValues(self, vars, values) 1653 1654 def FailDecision(self): 1655 return _pywrapcp.Solver_FailDecision(self) 1656 1657 def Decision(self, apply, refute): 1658 return _pywrapcp.Solver_Decision(self, apply, refute) 1659 1660 def Compose(self, dbs): 1661 return _pywrapcp.Solver_Compose(self, dbs) 1662 1663 def Try(self, dbs): 1664 return _pywrapcp.Solver_Try(self, dbs) 1665 1666 def DefaultPhase(self, *args): 1667 return _pywrapcp.Solver_DefaultPhase(self, *args) 1668 1669 def ScheduleOrPostpone(self, var, est, marker): 1670 r""" 1671 Returns a decision that tries to schedule a task at a given time. 1672 On the Apply branch, it will set that interval var as performed and set 1673 its start to 'est'. On the Refute branch, it will just update the 1674 'marker' to 'est' + 1. This decision is used in the 1675 INTERVAL_SET_TIMES_FORWARD strategy. 1676 """ 1677 return _pywrapcp.Solver_ScheduleOrPostpone(self, var, est, marker) 1678 1679 def ScheduleOrExpedite(self, var, est, marker): 1680 r""" 1681 Returns a decision that tries to schedule a task at a given time. 1682 On the Apply branch, it will set that interval var as performed and set 1683 its end to 'est'. On the Refute branch, it will just update the 1684 'marker' to 'est' - 1. This decision is used in the 1685 INTERVAL_SET_TIMES_BACKWARD strategy. 1686 """ 1687 return _pywrapcp.Solver_ScheduleOrExpedite(self, var, est, marker) 1688 1689 def RankFirstInterval(self, sequence, index): 1690 r""" 1691 Returns a decision that tries to rank first the ith interval var 1692 in the sequence variable. 1693 """ 1694 return _pywrapcp.Solver_RankFirstInterval(self, sequence, index) 1695 1696 def RankLastInterval(self, sequence, index): 1697 r""" 1698 Returns a decision that tries to rank last the ith interval var 1699 in the sequence variable. 1700 """ 1701 return _pywrapcp.Solver_RankLastInterval(self, sequence, index) 1702 1703 def Phase(self, *args): 1704 return _pywrapcp.Solver_Phase(self, *args) 1705 1706 def DecisionBuilderFromAssignment(self, assignment, db, vars): 1707 r""" 1708 Returns a decision builder for which the left-most leaf corresponds 1709 to assignment, the rest of the tree being explored using 'db'. 1710 """ 1711 return _pywrapcp.Solver_DecisionBuilderFromAssignment(self, assignment, db, vars) 1712 1713 def ConstraintAdder(self, ct): 1714 r""" 1715 Returns a decision builder that will add the given constraint to 1716 the model. 1717 """ 1718 return _pywrapcp.Solver_ConstraintAdder(self, ct) 1719 1720 def SolveOnce(self, db, monitors): 1721 return _pywrapcp.Solver_SolveOnce(self, db, monitors) 1722 1723 def NestedOptimize(self, *args): 1724 return _pywrapcp.Solver_NestedOptimize(self, *args) 1725 1726 def RestoreAssignment(self, assignment): 1727 r""" 1728 Returns a DecisionBuilder which restores an Assignment 1729 (calls void Assignment::Restore()) 1730 """ 1731 return _pywrapcp.Solver_RestoreAssignment(self, assignment) 1732 1733 def StoreAssignment(self, assignment): 1734 r""" 1735 Returns a DecisionBuilder which stores an Assignment 1736 (calls void Assignment::Store()) 1737 """ 1738 return _pywrapcp.Solver_StoreAssignment(self, assignment) 1739 1740 def Operator(self, *args): 1741 return _pywrapcp.Solver_Operator(self, *args) 1742 1743 def RandomLnsOperator(self, *args): 1744 return _pywrapcp.Solver_RandomLnsOperator(self, *args) 1745 1746 def MoveTowardTargetOperator(self, *args): 1747 r""" 1748 *Overload 1:* 1749 Creates a local search operator that tries to move the assignment of some 1750 variables toward a target. The target is given as an Assignment. This 1751 operator generates neighbors in which the only difference compared to the 1752 current state is that one variable that belongs to the target assignment 1753 is set to its target value. 1754 1755 | 1756 1757 *Overload 2:* 1758 Creates a local search operator that tries to move the assignment of some 1759 variables toward a target. The target is given either as two vectors: a 1760 vector of variables and a vector of associated target values. The two 1761 vectors should be of the same length. This operator generates neighbors in 1762 which the only difference compared to the current state is that one 1763 variable that belongs to the given vector is set to its target value. 1764 """ 1765 return _pywrapcp.Solver_MoveTowardTargetOperator(self, *args) 1766 1767 def ConcatenateOperators(self, *args): 1768 return _pywrapcp.Solver_ConcatenateOperators(self, *args) 1769 1770 def RandomConcatenateOperators(self, *args): 1771 r""" 1772 *Overload 1:* 1773 Randomized version of local search concatenator; calls a random operator 1774 at each call to MakeNextNeighbor(). 1775 1776 | 1777 1778 *Overload 2:* 1779 Randomized version of local search concatenator; calls a random operator 1780 at each call to MakeNextNeighbor(). The provided seed is used to 1781 initialize the random number generator. 1782 """ 1783 return _pywrapcp.Solver_RandomConcatenateOperators(self, *args) 1784 1785 def NeighborhoodLimit(self, op, limit): 1786 r""" 1787 Creates a local search operator that wraps another local search 1788 operator and limits the number of neighbors explored (i.e., calls 1789 to MakeNextNeighbor from the current solution (between two calls 1790 to Start()). When this limit is reached, MakeNextNeighbor() 1791 returns false. The counter is cleared when Start() is called. 1792 """ 1793 return _pywrapcp.Solver_NeighborhoodLimit(self, op, limit) 1794 1795 def LocalSearchPhase(self, *args): 1796 return _pywrapcp.Solver_LocalSearchPhase(self, *args) 1797 1798 def LocalSearchPhaseParameters(self, *args): 1799 return _pywrapcp.Solver_LocalSearchPhaseParameters(self, *args) 1800 1801 def TopProgressPercent(self): 1802 r""" 1803 Returns a percentage representing the propress of the search before 1804 reaching the limits of the top-level search (can be called from a nested 1805 solve). 1806 """ 1807 return _pywrapcp.Solver_TopProgressPercent(self) 1808 1809 def SearchDepth(self): 1810 r""" 1811 Gets the search depth of the current active search. Returns -1 if 1812 there is no active search opened. 1813 """ 1814 return _pywrapcp.Solver_SearchDepth(self) 1815 1816 def SearchLeftDepth(self): 1817 r""" 1818 Gets the search left depth of the current active search. Returns -1 if 1819 there is no active search opened. 1820 """ 1821 return _pywrapcp.Solver_SearchLeftDepth(self) 1822 1823 def SolveDepth(self): 1824 r""" 1825 Gets the number of nested searches. It returns 0 outside search, 1826 1 during the top level search, 2 or more in case of nested searches. 1827 """ 1828 return _pywrapcp.Solver_SolveDepth(self) 1829 1830 def Rand64(self, size): 1831 r""" Returns a random value between 0 and 'size' - 1;""" 1832 return _pywrapcp.Solver_Rand64(self, size) 1833 1834 def Rand32(self, size): 1835 r""" Returns a random value between 0 and 'size' - 1;""" 1836 return _pywrapcp.Solver_Rand32(self, size) 1837 1838 def ReSeed(self, seed): 1839 r""" Reseed the solver random generator.""" 1840 return _pywrapcp.Solver_ReSeed(self, seed) 1841 1842 def LocalSearchProfile(self): 1843 r""" Returns local search profiling information in a human readable format.""" 1844 return _pywrapcp.Solver_LocalSearchProfile(self) 1845 1846 def Constraints(self): 1847 r""" 1848 Counts the number of constraints that have been added 1849 to the solver before the search. 1850 """ 1851 return _pywrapcp.Solver_Constraints(self) 1852 1853 def Accept(self, visitor): 1854 r""" Accepts the given model visitor.""" 1855 return _pywrapcp.Solver_Accept(self, visitor) 1856 1857 def FinishCurrentSearch(self): 1858 r""" Tells the solver to kill or restart the current search.""" 1859 return _pywrapcp.Solver_FinishCurrentSearch(self) 1860 1861 def RestartCurrentSearch(self): 1862 return _pywrapcp.Solver_RestartCurrentSearch(self) 1863 1864 def ShouldFail(self): 1865 r""" 1866 These methods are only useful for the SWIG wrappers, which need a way 1867 to externally cause the Solver to fail. 1868 """ 1869 return _pywrapcp.Solver_ShouldFail(self) 1870 1871 def __str__(self): 1872 return _pywrapcp.Solver___str__(self) 1873 1874 def Add(self, ct): 1875 if isinstance(ct, PyConstraint): 1876 self.__python_constraints.append(ct) 1877 self.AddConstraint(ct) 1878 1879 1880 def TreeNoCycle(self, nexts, active, callback=0): 1881 return _pywrapcp.Solver_TreeNoCycle(self, nexts, active, callback) 1882 1883 def SearchLogWithCallback(self, period, callback): 1884 return _pywrapcp.Solver_SearchLogWithCallback(self, period, callback) 1885 1886 def ElementFunction(self, values, index): 1887 return _pywrapcp.Solver_ElementFunction(self, values, index) 1888 1889 def VarEvalValStrPhase(self, vars, var_evaluator, val_str): 1890 return _pywrapcp.Solver_VarEvalValStrPhase(self, vars, var_evaluator, val_str) 1891 1892 def VarStrValEvalPhase(self, vars, var_str, val_eval): 1893 return _pywrapcp.Solver_VarStrValEvalPhase(self, vars, var_str, val_eval) 1894 1895 def VarEvalValEvalPhase(self, vars, var_eval, val_eval): 1896 return _pywrapcp.Solver_VarEvalValEvalPhase(self, vars, var_eval, val_eval) 1897 1898 def VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker): 1899 return _pywrapcp.Solver_VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker) 1900 1901 def VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker): 1902 return _pywrapcp.Solver_VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker) 1903 1904 def EvalEvalStrPhase(self, vars, evaluator, str): 1905 return _pywrapcp.Solver_EvalEvalStrPhase(self, vars, evaluator, str) 1906 1907 def EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str): 1908 return _pywrapcp.Solver_EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str) 1909 1910 def GuidedLocalSearch(self, *args): 1911 return _pywrapcp.Solver_GuidedLocalSearch(self, *args) 1912 1913 def SumObjectiveFilter(self, vars, values, filter_enum): 1914 return _pywrapcp.Solver_SumObjectiveFilter(self, vars, values, filter_enum)
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
139 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
CHOOSE_FIRST_UNBOUND =
2
Select the first unbound variable. Variables are considered in the order of the vector of IntVars used to create the selector.
CHOOSE_MIN_SIZE_LOWEST_MIN =
4
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 =
5
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 =
6
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 =
7
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 =
8
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 =
9
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 =
10
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 =
11
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 =
12
Among unbound variables, select the variable with the largest gap between the first and the second values of the domain.
CHOOSE_PATH =
13
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.
ASSIGN_CENTER_VALUE =
5
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.
INTERVAL_SET_TIMES_FORWARD =
2
Selects the variable with the lowest starting time of all variables, and fixes its starting time to this lowest value.
INTERVAL_SET_TIMES_BACKWARD =
3
Selects the variable with the highest ending time of all variables, and fixes the ending time to this highest values.
TWOOPT =
0
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 =
1
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).
EXCHANGE =
3
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 =
4
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 =
5
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 =
6
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 =
7
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 =
8
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 =
9
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 =
10
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 =
11
Operator which relaxes one entire path and all inactive nodes, thus defining num_paths neighbors.
UNACTIVELNS =
12
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 =
13
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 =
14
Operator which defines a neighborhood to decrement values. The behavior is the same as INCREMENT, except values are decremented instead of incremented.
SIMPLELNS =
15
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.
EQ =
2
Move is accepted when the current objective value is in the interval objective.Min .. objective.Max.
DELAYED_PRIORITY =
0
DELAYED_PRIORITY is the lowest priority: Demons will be processed after VAR_PRIORITY and NORMAL_PRIORITY demons.
def
Parameters(self):
445 def Parameters(self): 446 r""" Stored Parameters.""" 447 return _pywrapcp.Solver_Parameters(self)
Stored Parameters.
@staticmethod
def
DefaultSolverParameters():
449 @staticmethod 450 def DefaultSolverParameters(): 451 r""" Create a ConstraintSolverParameters proto with all the default values.""" 452 return _pywrapcp.Solver_DefaultSolverParameters()
Create a ConstraintSolverParameters proto with all the default values.
def
AddConstraint(self, c):
454 def AddConstraint(self, c): 455 r""" 456 Adds the constraint 'c' to the model. 457 458 After calling this method, and until there is a backtrack that undoes the 459 addition, any assignment of variables to values must satisfy the given 460 constraint in order to be considered feasible. There are two fairly 461 different use cases: 462 463 - the most common use case is modeling: the given constraint is really 464 part of the problem that the user is trying to solve. In this use case, 465 AddConstraint is called outside of search (i.e., with state() == 466 OUTSIDE_SEARCH). Most users should only use AddConstraint in this 467 way. In this case, the constraint will belong to the model forever: it 468 cannot be removed by backtracking. 469 470 - a rarer use case is that 'c' is not a real constraint of the model. It 471 may be a constraint generated by a branching decision (a constraint whose 472 goal is to restrict the search space), a symmetry breaking constraint (a 473 constraint that does restrict the search space, but in a way that cannot 474 have an impact on the quality of the solutions in the subtree), or an 475 inferred constraint that, while having no semantic value to the model (it 476 does not restrict the set of solutions), is worth having because we 477 believe it may strengthen the propagation. In these cases, it happens 478 that the constraint is added during the search (i.e., with state() == 479 IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is 480 added during a search, it applies only to the subtree of the search tree 481 rooted at the current node, and will be automatically removed by 482 backtracking. 483 484 This method does not take ownership of the constraint. If the constraint 485 has been created by any factory method (Solver::MakeXXX), it will 486 automatically be deleted. However, power users who implement their own 487 constraints should do: solver.AddConstraint(solver.RevAlloc(new 488 MyConstraint(...)); 489 """ 490 return _pywrapcp.Solver_AddConstraint(self, c)
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 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(...));
def
CheckAssignment(self, solution):
510 def CheckAssignment(self, solution): 511 r""" Checks whether the given assignment satisfies all relevant constraints.""" 512 return _pywrapcp.Solver_CheckAssignment(self, solution)
Checks whether the given assignment satisfies all relevant constraints.
def
CheckConstraint(self, ct):
514 def CheckConstraint(self, ct): 515 r""" 516 Checks whether adding this constraint will lead to an immediate 517 failure. It will return false if the model is already inconsistent, or if 518 adding the constraint makes it inconsistent. 519 """ 520 return _pywrapcp.Solver_CheckConstraint(self, ct)
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.
def
Fail(self):
522 def Fail(self): 523 r""" Abandon the current branch in the search tree. A backtrack will follow.""" 524 return _pywrapcp.Solver_Fail(self)
Abandon the current branch in the search tree. A backtrack will follow.
@staticmethod
def
MemoryUsage():
526 @staticmethod 527 def MemoryUsage(): 528 r""" Current memory usage in bytes""" 529 return _pywrapcp.Solver_MemoryUsage()
Current memory usage in bytes
def
WallTime(self):
531 def WallTime(self): 532 r""" 533 DEPRECATED: Use Now() instead. 534 Time elapsed, in ms since the creation of the solver. 535 """ 536 return _pywrapcp.Solver_WallTime(self)
DEPRECATED: Use Now() instead. Time elapsed, in ms since the creation of the solver.
def
Branches(self):
538 def Branches(self): 539 r""" The number of branches explored since the creation of the solver.""" 540 return _pywrapcp.Solver_Branches(self)
The number of branches explored since the creation of the solver.
def
Solutions(self):
542 def Solutions(self): 543 r""" The number of solutions found since the start of the search.""" 544 return _pywrapcp.Solver_Solutions(self)
The number of solutions found since the start of the search.
def
Failures(self):
546 def Failures(self): 547 r""" The number of failures encountered since the creation of the solver.""" 548 return _pywrapcp.Solver_Failures(self)
The number of failures encountered since the creation of the solver.
def
AcceptedNeighbors(self):
550 def AcceptedNeighbors(self): 551 r""" The number of accepted neighbors.""" 552 return _pywrapcp.Solver_AcceptedNeighbors(self)
The number of accepted neighbors.
def
Stamp(self):
554 def Stamp(self): 555 r""" 556 The stamp indicates how many moves in the search tree we have performed. 557 It is useful to detect if we need to update same lazy structures. 558 """ 559 return _pywrapcp.Solver_Stamp(self)
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.
def
FailStamp(self):
561 def FailStamp(self): 562 r""" The fail_stamp() is incremented after each backtrack.""" 563 return _pywrapcp.Solver_FailStamp(self)
The fail_stamp() is incremented after each backtrack.
def
IntVar(self, *args):
565 def IntVar(self, *args): 566 r""" 567 *Overload 1:* 568 MakeIntVar will create the best range based int var for the bounds given. 569 570 | 571 572 *Overload 2:* 573 MakeIntVar will create a variable with the given sparse domain. 574 575 | 576 577 *Overload 3:* 578 MakeIntVar will create a variable with the given sparse domain. 579 580 | 581 582 *Overload 4:* 583 MakeIntVar will create the best range based int var for the bounds given. 584 585 | 586 587 *Overload 5:* 588 MakeIntVar will create a variable with the given sparse domain. 589 590 | 591 592 *Overload 6:* 593 MakeIntVar will create a variable with the given sparse domain. 594 """ 595 return _pywrapcp.Solver_IntVar(self, *args)
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.
def
BoolVar(self, *args):
597 def BoolVar(self, *args): 598 r""" 599 *Overload 1:* 600 MakeBoolVar will create a variable with a {0, 1} domain. 601 602 | 603 604 *Overload 2:* 605 MakeBoolVar will create a variable with a {0, 1} domain. 606 """ 607 return _pywrapcp.Solver_BoolVar(self, *args)
Overload 1: MakeBoolVar will create a variable with a {0, 1} domain.
|
Overload 2: MakeBoolVar will create a variable with a {0, 1} domain.
def
IntConst(self, *args):
609 def IntConst(self, *args): 610 r""" 611 *Overload 1:* 612 IntConst will create a constant expression. 613 614 | 615 616 *Overload 2:* 617 IntConst will create a constant expression. 618 """ 619 return _pywrapcp.Solver_IntConst(self, *args)
Overload 1: IntConst will create a constant expression.
|
Overload 2: IntConst will create a constant expression.
def
ScalProd(self, *args):
625 def ScalProd(self, *args): 626 r""" 627 *Overload 1:* 628 scalar product 629 630 | 631 632 *Overload 2:* 633 scalar product 634 """ 635 return _pywrapcp.Solver_ScalProd(self, *args)
Overload 1: scalar product
|
Overload 2: scalar product
def
MonotonicElement(self, values, increasing, index):
637 def MonotonicElement(self, values, increasing, index): 638 r""" 639 Function based element. The constraint takes ownership of the 640 callback. The callback must be monotonic. It must be able to 641 cope with any possible value in the domain of 'index' 642 (potentially negative ones too). Furtermore, monotonicity is not 643 checked. Thus giving a non-monotonic function, or specifying an 644 incorrect increasing parameter will result in undefined behavior. 645 """ 646 return _pywrapcp.Solver_MonotonicElement(self, values, increasing, index)
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.
def
Element(self, *args):
648 def Element(self, *args): 649 r""" 650 *Overload 1:* 651 values[index] 652 653 | 654 655 *Overload 2:* 656 values[index] 657 658 | 659 660 *Overload 3:* 661 Function-based element. The constraint takes ownership of the 662 callback. The callback must be able to cope with any possible 663 value in the domain of 'index' (potentially negative ones too). 664 665 | 666 667 *Overload 4:* 668 2D version of function-based element expression, values(expr1, expr2). 669 670 | 671 672 *Overload 5:* 673 vars[expr] 674 """ 675 return _pywrapcp.Solver_Element(self, *args)
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]
def
IndexExpression(self, vars, value):
677 def IndexExpression(self, vars, value): 678 r""" 679 Returns the expression expr such that vars[expr] == value. 680 It assumes that vars are all different. 681 """ 682 return _pywrapcp.Solver_IndexExpression(self, vars, value)
Returns the expression expr such that vars[expr] == value. It assumes that vars are all different.
def
Min(self, *args):
684 def Min(self, *args): 685 r""" 686 *Overload 1:* 687 std::min(vars) 688 689 | 690 691 *Overload 2:* 692 std::min (left, right) 693 694 | 695 696 *Overload 3:* 697 std::min(expr, value) 698 699 | 700 701 *Overload 4:* 702 std::min(expr, value) 703 """ 704 return _pywrapcp.Solver_Min(self, *args)
Overload 1: std::min(vars)
|
Overload 2: std::min (left, right)
|
Overload 3: std::min(expr, value)
|
Overload 4: std::min(expr, value)
def
Max(self, *args):
706 def Max(self, *args): 707 r""" 708 *Overload 1:* 709 std::max(vars) 710 711 | 712 713 *Overload 2:* 714 std::max(left, right) 715 716 | 717 718 *Overload 3:* 719 std::max(expr, value) 720 721 | 722 723 *Overload 4:* 724 std::max(expr, value) 725 """ 726 return _pywrapcp.Solver_Max(self, *args)
Overload 1: std::max(vars)
|
Overload 2: std::max(left, right)
|
Overload 3: std::max(expr, value)
|
Overload 4: std::max(expr, value)
def
ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost):
728 def ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost): 729 r""" Convex piecewise function.""" 730 return _pywrapcp.Solver_ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost)
Convex piecewise function.
def
SemiContinuousExpr(self, expr, fixed_charge, step):
732 def SemiContinuousExpr(self, expr, fixed_charge, step): 733 r""" 734 Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) 735 a >= 0 and b >= 0 736 """ 737 return _pywrapcp.Solver_SemiContinuousExpr(self, expr, fixed_charge, step)
Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) a >= 0 and b >= 0
def
ConditionalExpression(self, condition, expr, unperformed_value):
739 def ConditionalExpression(self, condition, expr, unperformed_value): 740 r""" Conditional Expr condition ? expr : unperformed_value""" 741 return _pywrapcp.Solver_ConditionalExpression(self, condition, expr, unperformed_value)
Conditional Expr condition ? expr : unperformed_value
def
TrueConstraint(self):
743 def TrueConstraint(self): 744 r""" This constraint always succeeds.""" 745 return _pywrapcp.Solver_TrueConstraint(self)
This constraint always succeeds.
def
IsEqualCstCt(self, var, value, boolvar):
750 def IsEqualCstCt(self, var, value, boolvar): 751 r""" boolvar == (var == value)""" 752 return _pywrapcp.Solver_IsEqualCstCt(self, var, value, boolvar)
boolvar == (var == value)
def
IsEqualCstVar(self, var, value):
754 def IsEqualCstVar(self, var, value): 755 r""" status var of (var == value)""" 756 return _pywrapcp.Solver_IsEqualCstVar(self, var, value)
status var of (var == value)
def
IsEqualCt(self, v1, v2, b):
758 def IsEqualCt(self, v1, v2, b): 759 r""" b == (v1 == v2)""" 760 return _pywrapcp.Solver_IsEqualCt(self, v1, v2, b)
b == (v1 == v2)
def
IsEqualVar(self, v1, v2):
762 def IsEqualVar(self, v1, v2): 763 r""" status var of (v1 == v2)""" 764 return _pywrapcp.Solver_IsEqualVar(self, v1, v2)
status var of (v1 == v2)
def
IsDifferentCstCt(self, var, value, boolvar):
766 def IsDifferentCstCt(self, var, value, boolvar): 767 r""" boolvar == (var != value)""" 768 return _pywrapcp.Solver_IsDifferentCstCt(self, var, value, boolvar)
boolvar == (var != value)
def
IsDifferentCstVar(self, var, value):
770 def IsDifferentCstVar(self, var, value): 771 r""" status var of (var != value)""" 772 return _pywrapcp.Solver_IsDifferentCstVar(self, var, value)
status var of (var != value)
def
IsDifferentVar(self, v1, v2):
774 def IsDifferentVar(self, v1, v2): 775 r""" status var of (v1 != v2)""" 776 return _pywrapcp.Solver_IsDifferentVar(self, v1, v2)
status var of (v1 != v2)
def
IsDifferentCt(self, v1, v2, b):
778 def IsDifferentCt(self, v1, v2, b): 779 r""" b == (v1 != v2)""" 780 return _pywrapcp.Solver_IsDifferentCt(self, v1, v2, b)
b == (v1 != v2)
def
IsLessOrEqualCstCt(self, var, value, boolvar):
782 def IsLessOrEqualCstCt(self, var, value, boolvar): 783 r""" boolvar == (var <= value)""" 784 return _pywrapcp.Solver_IsLessOrEqualCstCt(self, var, value, boolvar)
boolvar == (var <= value)
def
IsLessOrEqualCstVar(self, var, value):
786 def IsLessOrEqualCstVar(self, var, value): 787 r""" status var of (var <= value)""" 788 return _pywrapcp.Solver_IsLessOrEqualCstVar(self, var, value)
status var of (var <= value)
def
IsLessOrEqualVar(self, left, right):
790 def IsLessOrEqualVar(self, left, right): 791 r""" status var of (left <= right)""" 792 return _pywrapcp.Solver_IsLessOrEqualVar(self, left, right)
status var of (left <= right)
def
IsLessOrEqualCt(self, left, right, b):
794 def IsLessOrEqualCt(self, left, right, b): 795 r""" b == (left <= right)""" 796 return _pywrapcp.Solver_IsLessOrEqualCt(self, left, right, b)
b == (left <= right)
def
IsGreaterOrEqualCstCt(self, var, value, boolvar):
798 def IsGreaterOrEqualCstCt(self, var, value, boolvar): 799 r""" boolvar == (var >= value)""" 800 return _pywrapcp.Solver_IsGreaterOrEqualCstCt(self, var, value, boolvar)
boolvar == (var >= value)
def
IsGreaterOrEqualCstVar(self, var, value):
802 def IsGreaterOrEqualCstVar(self, var, value): 803 r""" status var of (var >= value)""" 804 return _pywrapcp.Solver_IsGreaterOrEqualCstVar(self, var, value)
status var of (var >= value)
def
IsGreaterOrEqualVar(self, left, right):
806 def IsGreaterOrEqualVar(self, left, right): 807 r""" status var of (left >= right)""" 808 return _pywrapcp.Solver_IsGreaterOrEqualVar(self, left, right)
status var of (left >= right)
def
IsGreaterOrEqualCt(self, left, right, b):
810 def IsGreaterOrEqualCt(self, left, right, b): 811 r""" b == (left >= right)""" 812 return _pywrapcp.Solver_IsGreaterOrEqualCt(self, left, right, b)
b == (left >= right)
def
IsGreaterCstCt(self, v, c, b):
814 def IsGreaterCstCt(self, v, c, b): 815 r""" b == (v > c)""" 816 return _pywrapcp.Solver_IsGreaterCstCt(self, v, c, b)
b == (v > c)
def
IsGreaterCstVar(self, var, value):
818 def IsGreaterCstVar(self, var, value): 819 r""" status var of (var > value)""" 820 return _pywrapcp.Solver_IsGreaterCstVar(self, var, value)
status var of (var > value)
def
IsGreaterVar(self, left, right):
822 def IsGreaterVar(self, left, right): 823 r""" status var of (left > right)""" 824 return _pywrapcp.Solver_IsGreaterVar(self, left, right)
status var of (left > right)
def
IsGreaterCt(self, left, right, b):
826 def IsGreaterCt(self, left, right, b): 827 r""" b == (left > right)""" 828 return _pywrapcp.Solver_IsGreaterCt(self, left, right, b)
b == (left > right)
def
IsLessCstCt(self, v, c, b):
830 def IsLessCstCt(self, v, c, b): 831 r""" b == (v < c)""" 832 return _pywrapcp.Solver_IsLessCstCt(self, v, c, b)
b == (v < c)
def
IsLessCstVar(self, var, value):
834 def IsLessCstVar(self, var, value): 835 r""" status var of (var < value)""" 836 return _pywrapcp.Solver_IsLessCstVar(self, var, value)
status var of (var < value)
def
IsLessVar(self, left, right):
838 def IsLessVar(self, left, right): 839 r""" status var of (left < right)""" 840 return _pywrapcp.Solver_IsLessVar(self, left, right)
status var of (left < right)
def
IsLessCt(self, left, right, b):
842 def IsLessCt(self, left, right, b): 843 r""" b == (left < right)""" 844 return _pywrapcp.Solver_IsLessCt(self, left, right, b)
b == (left < right)
def
SumLessOrEqual(self, vars, cst):
846 def SumLessOrEqual(self, vars, cst): 847 r""" Variation on arrays.""" 848 return _pywrapcp.Solver_SumLessOrEqual(self, vars, cst)
Variation on arrays.
def
AbsEquality(self, var, abs_var):
874 def AbsEquality(self, var, abs_var): 875 r""" Creates the constraint abs(var) == abs_var.""" 876 return _pywrapcp.Solver_AbsEquality(self, var, abs_var)
Creates the constraint abs(var) == abs_var.
def
IndexOfConstraint(self, vars, index, target):
878 def IndexOfConstraint(self, vars, index, target): 879 r""" 880 This constraint is a special case of the element constraint with 881 an array of integer variables, where the variables are all 882 different and the index variable is constrained such that 883 vars[index] == target. 884 """ 885 return _pywrapcp.Solver_IndexOfConstraint(self, vars, index, target)
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.
def
ConstraintInitialPropagateCallback(self, ct):
887 def ConstraintInitialPropagateCallback(self, ct): 888 r""" 889 This method is a specialized case of the MakeConstraintDemon 890 method to call the InitiatePropagate of the constraint 'ct'. 891 """ 892 return _pywrapcp.Solver_ConstraintInitialPropagateCallback(self, ct)
This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct'.
def
DelayedConstraintInitialPropagateCallback(self, ct):
894 def DelayedConstraintInitialPropagateCallback(self, ct): 895 r""" 896 This method is a specialized case of the MakeConstraintDemon 897 method to call the InitiatePropagate of the constraint 'ct' with 898 low priority. 899 """ 900 return _pywrapcp.Solver_DelayedConstraintInitialPropagateCallback(self, ct)
This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct' with low priority.
def
ClosureDemon(self, closure):
902 def ClosureDemon(self, closure): 903 r""" Creates a demon from a closure.""" 904 return _pywrapcp.Solver_ClosureDemon(self, closure)
Creates a demon from a closure.
def
BetweenCt(self, expr, l, u):
906 def BetweenCt(self, expr, l, u): 907 r""" (l <= expr <= u)""" 908 return _pywrapcp.Solver_BetweenCt(self, expr, l, u)
(l <= expr <= u)
def
IsBetweenCt(self, expr, l, u, b):
910 def IsBetweenCt(self, expr, l, u, b): 911 r""" b == (l <= expr <= u)""" 912 return _pywrapcp.Solver_IsBetweenCt(self, expr, l, u, b)
b == (l <= expr <= u)
def
NotMemberCt(self, *args):
920 def NotMemberCt(self, *args): 921 r""" 922 *Overload 1:* 923 expr not in set. 924 925 | 926 927 *Overload 2:* 928 expr should not be in the list of forbidden intervals [start[i]..end[i]]. 929 930 | 931 932 *Overload 3:* 933 expr should not be in the list of forbidden intervals [start[i]..end[i]]. 934 """ 935 return _pywrapcp.Solver_NotMemberCt(self, *args)
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]].
def
Count(self, *args):
943 def Count(self, *args): 944 r""" 945 *Overload 1:* 946 |{i | vars[i] == value}| == max_count 947 948 | 949 950 *Overload 2:* 951 |{i | vars[i] == value}| == max_count 952 """ 953 return _pywrapcp.Solver_Count(self, *args)
Overload 1: |{i | vars[i] == value}| == max_count
|
Overload 2: |{i | vars[i] == value}| == max_count
def
Distribute(self, *args):
955 def Distribute(self, *args): 956 r""" 957 *Overload 1:* 958 Aggregated version of count: |{i | v[i] == values[j]}| == cards[j] 959 960 | 961 962 *Overload 2:* 963 Aggregated version of count: |{i | v[i] == values[j]}| == cards[j] 964 965 | 966 967 *Overload 3:* 968 Aggregated version of count: |{i | v[i] == j}| == cards[j] 969 970 | 971 972 *Overload 4:* 973 Aggregated version of count with bounded cardinalities: 974 forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max 975 976 | 977 978 *Overload 5:* 979 Aggregated version of count with bounded cardinalities: 980 forall j in 0 .. card_size - 1: 981 card_min[j] <= |{i | v[i] == j}| <= card_max[j] 982 983 | 984 985 *Overload 6:* 986 Aggregated version of count with bounded cardinalities: 987 forall j in 0 .. card_size - 1: 988 card_min[j] <= |{i | v[i] == j}| <= card_max[j] 989 990 | 991 992 *Overload 7:* 993 Aggregated version of count with bounded cardinalities: 994 forall j in 0 .. card_size - 1: 995 card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j] 996 997 | 998 999 *Overload 8:* 1000 Aggregated version of count with bounded cardinalities: 1001 forall j in 0 .. card_size - 1: 1002 card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j] 1003 """ 1004 return _pywrapcp.Solver_Distribute(self, *args)
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]
def
Deviation(self, vars, deviation_var, total_sum):
1006 def Deviation(self, vars, deviation_var, total_sum): 1007 r""" 1008 Deviation constraint: 1009 sum_i |n * vars[i] - total_sum| <= deviation_var and 1010 sum_i vars[i] == total_sum 1011 n = #vars 1012 """ 1013 return _pywrapcp.Solver_Deviation(self, vars, deviation_var, total_sum)
Deviation constraint: sum_i |n * vars[i] - total_sum| <= deviation_var and sum_i vars[i] == total_sum n = #vars
def
AllDifferent(self, *args):
1015 def AllDifferent(self, *args): 1016 r""" 1017 *Overload 1:* 1018 All variables are pairwise different. This corresponds to the 1019 stronger version of the propagation algorithm. 1020 1021 | 1022 1023 *Overload 2:* 1024 All variables are pairwise different. If 'stronger_propagation' 1025 is true, stronger, and potentially slower propagation will 1026 occur. This API will be deprecated in the future. 1027 """ 1028 return _pywrapcp.Solver_AllDifferent(self, *args)
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.
def
AllDifferentExcept(self, vars, escape_value):
1030 def AllDifferentExcept(self, vars, escape_value): 1031 r""" 1032 All variables are pairwise different, unless they are assigned to 1033 the escape value. 1034 """ 1035 return _pywrapcp.Solver_AllDifferentExcept(self, vars, escape_value)
All variables are pairwise different, unless they are assigned to the escape value.
def
SortingConstraint(self, vars, sorted):
1037 def SortingConstraint(self, vars, sorted): 1038 r""" 1039 Creates a constraint binding the arrays of variables "vars" and 1040 "sorted_vars": sorted_vars[0] must be equal to the minimum of all 1041 variables in vars, and so on: the value of sorted_vars[i] must be 1042 equal to the i-th value of variables invars. 1043 1044 This constraint propagates in both directions: from "vars" to 1045 "sorted_vars" and vice-versa. 1046 1047 Behind the scenes, this constraint maintains that: 1048 - sorted is always increasing. 1049 - whatever the values of vars, there exists a permutation that 1050 injects its values into the sorted variables. 1051 1052 For more info, please have a look at: 1053 https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf 1054 """ 1055 return _pywrapcp.Solver_SortingConstraint(self, vars, sorted)
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
def
LexicalLess(self, left, right):
1057 def LexicalLess(self, left, right): 1058 r""" 1059 Creates a constraint that enforces that left is lexicographically less 1060 than right. 1061 """ 1062 return _pywrapcp.Solver_LexicalLess(self, left, right)
Creates a constraint that enforces that left is lexicographically less than right.
def
LexicalLessOrEqual(self, left, right):
1064 def LexicalLessOrEqual(self, left, right): 1065 r""" 1066 Creates a constraint that enforces that left is lexicographically less 1067 than or equal to right. 1068 """ 1069 return _pywrapcp.Solver_LexicalLessOrEqual(self, left, right)
Creates a constraint that enforces that left is lexicographically less than or equal to right.
def
InversePermutationConstraint(self, left, right):
1071 def InversePermutationConstraint(self, left, right): 1072 r""" 1073 Creates a constraint that enforces that 'left' and 'right' both 1074 represent permutations of [0..left.size()-1], and that 'right' is 1075 the inverse permutation of 'left', i.e. for all i in 1076 [0..left.size()-1], right[left[i]] = i. 1077 """ 1078 return _pywrapcp.Solver_InversePermutationConstraint(self, left, right)
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.
def
NullIntersect(self, first_vars, second_vars):
1080 def NullIntersect(self, first_vars, second_vars): 1081 r""" 1082 Creates a constraint that states that all variables in the first 1083 vector are different from all variables in the second 1084 group. Thus the set of values in the first vector does not 1085 intersect with the set of values in the second vector. 1086 """ 1087 return _pywrapcp.Solver_NullIntersect(self, first_vars, second_vars)
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.
def
NullIntersectExcept(self, first_vars, second_vars, escape_value):
1089 def NullIntersectExcept(self, first_vars, second_vars, escape_value): 1090 r""" 1091 Creates a constraint that states that all variables in the first 1092 vector are different from all variables from the second group, 1093 unless they are assigned to the escape value. Thus the set of 1094 values in the first vector minus the escape value does not 1095 intersect with the set of values in the second vector. 1096 """ 1097 return _pywrapcp.Solver_NullIntersectExcept(self, first_vars, second_vars, escape_value)
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.
def
Circuit(self, nexts):
1099 def Circuit(self, nexts): 1100 r""" Force the "nexts" variable to create a complete Hamiltonian path.""" 1101 return _pywrapcp.Solver_Circuit(self, nexts)
Force the "nexts" variable to create a complete Hamiltonian path.
def
SubCircuit(self, nexts):
1103 def SubCircuit(self, nexts): 1104 r""" 1105 Force the "nexts" variable to create a complete Hamiltonian path 1106 for those that do not loop upon themselves. 1107 """ 1108 return _pywrapcp.Solver_SubCircuit(self, nexts)
Force the "nexts" variable to create a complete Hamiltonian path for those that do not loop upon themselves.
def
DelayedPathCumul(self, nexts, active, cumuls, transits):
1110 def DelayedPathCumul(self, nexts, active, cumuls, transits): 1111 r""" 1112 Delayed version of the same constraint: propagation on the nexts variables 1113 is delayed until all constraints have propagated. 1114 """ 1115 return _pywrapcp.Solver_DelayedPathCumul(self, nexts, active, cumuls, transits)
Delayed version of the same constraint: propagation on the nexts variables is delayed until all constraints have propagated.
def
PathCumul(self, *args):
1117 def PathCumul(self, *args): 1118 r""" 1119 *Overload 1:* 1120 Creates a constraint which accumulates values along a path such that: 1121 cumuls[next[i]] = cumuls[i] + transits[i]. 1122 Active variables indicate if the corresponding next variable is active; 1123 this could be useful to model unperformed nodes in a routing problem. 1124 1125 | 1126 1127 *Overload 2:* 1128 Creates a constraint which accumulates values along a path such that: 1129 cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). 1130 Active variables indicate if the corresponding next variable is active; 1131 this could be useful to model unperformed nodes in a routing problem. 1132 Ownership of transit_evaluator is taken and it must be a repeatable 1133 callback. 1134 1135 | 1136 1137 *Overload 3:* 1138 Creates a constraint which accumulates values along a path such that: 1139 cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. 1140 Active variables indicate if the corresponding next variable is active; 1141 this could be useful to model unperformed nodes in a routing problem. 1142 Ownership of transit_evaluator is taken and it must be a repeatable 1143 callback. 1144 """ 1145 return _pywrapcp.Solver_PathCumul(self, *args)
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.
def
AllowedAssignments(self, *args):
1147 def AllowedAssignments(self, *args): 1148 r""" 1149 *Overload 1:* 1150 This method creates a constraint where the graph of the relation 1151 between the variables is given in extension. There are 'arity' 1152 variables involved in the relation and the graph is given by a 1153 integer tuple set. 1154 1155 | 1156 1157 *Overload 2:* 1158 Compatibility layer for Python API. 1159 """ 1160 return _pywrapcp.Solver_AllowedAssignments(self, *args)
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.
def
Pack(self, vars, number_of_bins):
1168 def Pack(self, vars, number_of_bins): 1169 r""" 1170 This constraint packs all variables onto 'number_of_bins' 1171 variables. For any given variable, a value of 'number_of_bins' 1172 indicates that the variable is not assigned to any bin. 1173 Dimensions, i.e., cumulative constraints on this packing, can be 1174 added directly from the pack class. 1175 """ 1176 return _pywrapcp.Solver_Pack(self, vars, number_of_bins)
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.
def
FixedDurationIntervalVar(self, *args):
1178 def FixedDurationIntervalVar(self, *args): 1179 r""" 1180 *Overload 1:* 1181 Creates an interval var with a fixed duration. The duration must 1182 be greater than 0. If optional is true, then the interval can be 1183 performed or unperformed. If optional is false, then the interval 1184 is always performed. 1185 1186 | 1187 1188 *Overload 2:* 1189 Creates a performed interval var with a fixed duration. The duration must 1190 be greater than 0. 1191 1192 | 1193 1194 *Overload 3:* 1195 Creates an interval var with a fixed duration, and performed_variable. 1196 The duration must be greater than 0. 1197 """ 1198 return _pywrapcp.Solver_FixedDurationIntervalVar(self, *args)
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.
def
FixedInterval(self, start, duration, name):
1200 def FixedInterval(self, start, duration, name): 1201 r""" Creates a fixed and performed interval.""" 1202 return _pywrapcp.Solver_FixedInterval(self, start, duration, name)
Creates a fixed and performed interval.
def
IntervalVar( self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name):
1204 def IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name): 1205 r""" 1206 Creates an interval var by specifying the bounds on start, 1207 duration, and end. 1208 """ 1209 return _pywrapcp.Solver_IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name)
Creates an interval var by specifying the bounds on start, duration, and end.
def
MirrorInterval(self, interval_var):
1211 def MirrorInterval(self, interval_var): 1212 r""" 1213 Creates an interval var that is the mirror image of the given one, that 1214 is, the interval var obtained by reversing the axis. 1215 """ 1216 return _pywrapcp.Solver_MirrorInterval(self, interval_var)
Creates an interval var that is the mirror image of the given one, that is, the interval var obtained by reversing the axis.
def
FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset):
1218 def FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset): 1219 r""" 1220 Creates an interval var with a fixed duration whose start is 1221 synchronized with the start of another interval, with a given 1222 offset. The performed status is also in sync with the performed 1223 status of the given interval variable. 1224 """ 1225 return _pywrapcp.Solver_FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset)
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.
def
FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset):
1227 def FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset): 1228 r""" 1229 Creates an interval var with a fixed duration whose start is 1230 synchronized with the end of another interval, with a given 1231 offset. The performed status is also in sync with the performed 1232 status of the given interval variable. 1233 """ 1234 return _pywrapcp.Solver_FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset)
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.
def
FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset):
1236 def FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset): 1237 r""" 1238 Creates an interval var with a fixed duration whose end is 1239 synchronized with the start of another interval, with a given 1240 offset. The performed status is also in sync with the performed 1241 status of the given interval variable. 1242 """ 1243 return _pywrapcp.Solver_FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset)
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.
def
FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset):
1245 def FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset): 1246 r""" 1247 Creates an interval var with a fixed duration whose end is 1248 synchronized with the end of another interval, with a given 1249 offset. The performed status is also in sync with the performed 1250 status of the given interval variable. 1251 """ 1252 return _pywrapcp.Solver_FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset)
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.
def
IntervalRelaxedMin(self, interval_var):
1254 def IntervalRelaxedMin(self, interval_var): 1255 r""" 1256 Creates and returns an interval variable that wraps around the given one, 1257 relaxing the min start and end. Relaxing means making unbounded when 1258 optional. If the variable is non-optional, this method returns 1259 interval_var. 1260 1261 More precisely, such an interval variable behaves as follows: 1262 When the underlying must be performed, the returned interval variable 1263 behaves exactly as the underlying; 1264 When the underlying may or may not be performed, the returned interval 1265 variable behaves like the underlying, except that it is unbounded on 1266 the min side; 1267 When the underlying cannot be performed, the returned interval variable 1268 is of duration 0 and must be performed in an interval unbounded on 1269 both sides. 1270 1271 This is very useful to implement propagators that may only modify 1272 the start max or end max. 1273 """ 1274 return _pywrapcp.Solver_IntervalRelaxedMin(self, interval_var)
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.
def
IntervalRelaxedMax(self, interval_var):
1276 def IntervalRelaxedMax(self, interval_var): 1277 r""" 1278 Creates and returns an interval variable that wraps around the given one, 1279 relaxing the max start and end. Relaxing means making unbounded when 1280 optional. If the variable is non optional, this method returns 1281 interval_var. 1282 1283 More precisely, such an interval variable behaves as follows: 1284 When the underlying must be performed, the returned interval variable 1285 behaves exactly as the underlying; 1286 When the underlying may or may not be performed, the returned interval 1287 variable behaves like the underlying, except that it is unbounded on 1288 the max side; 1289 When the underlying cannot be performed, the returned interval variable 1290 is of duration 0 and must be performed in an interval unbounded on 1291 both sides. 1292 1293 This is very useful for implementing propagators that may only modify 1294 the start min or end min. 1295 """ 1296 return _pywrapcp.Solver_IntervalRelaxedMax(self, interval_var)
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.
def
TemporalDisjunction(self, *args):
1298 def TemporalDisjunction(self, *args): 1299 r""" 1300 *Overload 1:* 1301 This constraint implements a temporal disjunction between two 1302 interval vars t1 and t2. 'alt' indicates which alternative was 1303 chosen (alt == 0 is equivalent to t1 before t2). 1304 1305 | 1306 1307 *Overload 2:* 1308 This constraint implements a temporal disjunction between two 1309 interval vars. 1310 """ 1311 return _pywrapcp.Solver_TemporalDisjunction(self, *args)
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.
def
DisjunctiveConstraint(self, intervals, name):
1313 def DisjunctiveConstraint(self, intervals, name): 1314 r""" 1315 This constraint forces all interval vars into an non-overlapping 1316 sequence. Intervals with zero duration can be scheduled anywhere. 1317 """ 1318 return _pywrapcp.Solver_DisjunctiveConstraint(self, intervals, name)
This constraint forces all interval vars into an non-overlapping sequence. Intervals with zero duration can be scheduled anywhere.
def
Cumulative(self, *args):
1320 def Cumulative(self, *args): 1321 r""" 1322 *Overload 1:* 1323 This constraint forces that, for any integer t, the sum of the demands 1324 corresponding to an interval containing t does not exceed the given 1325 capacity. 1326 1327 Intervals and demands should be vectors of equal size. 1328 1329 Demands should only contain non-negative values. Zero values are 1330 supported, and the corresponding intervals are filtered out, as they 1331 neither impact nor are impacted by this constraint. 1332 1333 | 1334 1335 *Overload 2:* 1336 This constraint forces that, for any integer t, the sum of the demands 1337 corresponding to an interval containing t does not exceed the given 1338 capacity. 1339 1340 Intervals and demands should be vectors of equal size. 1341 1342 Demands should only contain non-negative values. Zero values are 1343 supported, and the corresponding intervals are filtered out, as they 1344 neither impact nor are impacted by this constraint. 1345 1346 | 1347 1348 *Overload 3:* 1349 This constraint forces that, for any integer t, the sum of the demands 1350 corresponding to an interval containing t does not exceed the given 1351 capacity. 1352 1353 Intervals and demands should be vectors of equal size. 1354 1355 Demands should only contain non-negative values. Zero values are 1356 supported, and the corresponding intervals are filtered out, as they 1357 neither impact nor are impacted by this constraint. 1358 1359 | 1360 1361 *Overload 4:* 1362 This constraint enforces that, for any integer t, the sum of the demands 1363 corresponding to an interval containing t does not exceed the given 1364 capacity. 1365 1366 Intervals and demands should be vectors of equal size. 1367 1368 Demands should only contain non-negative values. Zero values are 1369 supported, and the corresponding intervals are filtered out, as they 1370 neither impact nor are impacted by this constraint. 1371 1372 | 1373 1374 *Overload 5:* 1375 This constraint enforces that, for any integer t, the sum of demands 1376 corresponding to an interval containing t does not exceed the given 1377 capacity. 1378 1379 Intervals and demands should be vectors of equal size. 1380 1381 Demands should be positive. 1382 1383 | 1384 1385 *Overload 6:* 1386 This constraint enforces that, for any integer t, the sum of demands 1387 corresponding to an interval containing t does not exceed the given 1388 capacity. 1389 1390 Intervals and demands should be vectors of equal size. 1391 1392 Demands should be positive. 1393 """ 1394 return _pywrapcp.Solver_Cumulative(self, *args)
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.
def
Cover(self, vars, target_var):
1396 def Cover(self, vars, target_var): 1397 r""" 1398 This constraint states that the target_var is the convex hull of 1399 the intervals. If none of the interval variables is performed, 1400 then the target var is unperformed too. Also, if the target 1401 variable is unperformed, then all the intervals variables are 1402 unperformed too. 1403 """ 1404 return _pywrapcp.Solver_Cover(self, vars, target_var)
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.
def
Assignment(self, *args):
1406 def Assignment(self, *args): 1407 r""" 1408 *Overload 1:* 1409 This method creates an empty assignment. 1410 1411 | 1412 1413 *Overload 2:* 1414 This method creates an assignment which is a copy of 'a'. 1415 """ 1416 return _pywrapcp.Solver_Assignment(self, *args)
Overload 1: This method creates an empty assignment.
|
Overload 2: This method creates an assignment which is a copy of 'a'.
def
FirstSolutionCollector(self, *args):
1418 def FirstSolutionCollector(self, *args): 1419 r""" 1420 *Overload 1:* 1421 Collect the first solution of the search. 1422 1423 | 1424 1425 *Overload 2:* 1426 Collect the first solution of the search. The variables will need to 1427 be added later. 1428 """ 1429 return _pywrapcp.Solver_FirstSolutionCollector(self, *args)
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.
def
LastSolutionCollector(self, *args):
1431 def LastSolutionCollector(self, *args): 1432 r""" 1433 *Overload 1:* 1434 Collect the last solution of the search. 1435 1436 | 1437 1438 *Overload 2:* 1439 Collect the last solution of the search. The variables will need to 1440 be added later. 1441 """ 1442 return _pywrapcp.Solver_LastSolutionCollector(self, *args)
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.
def
BestValueSolutionCollector(self, *args):
1444 def BestValueSolutionCollector(self, *args): 1445 r""" 1446 *Overload 1:* 1447 Collect the solution corresponding to the optimal value of the objective 1448 of 'assignment'; if 'assignment' does not have an objective no solution is 1449 collected. This collector only collects one solution corresponding to the 1450 best objective value (the first one found). 1451 1452 | 1453 1454 *Overload 2:* 1455 Collect the solution corresponding to the optimal value of the 1456 objective of the internal assignment; if this assignment does not have an 1457 objective no solution is collected. This collector only collects one 1458 solution corresponding to the best objective value (the first one found). 1459 The variables and objective(s) will need to be added later. 1460 """ 1461 return _pywrapcp.Solver_BestValueSolutionCollector(self, *args)
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 the internal assignment; if this 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 and objective(s) will need to be added later.
def
AllSolutionCollector(self, *args):
1463 def AllSolutionCollector(self, *args): 1464 r""" 1465 *Overload 1:* 1466 Collect all solutions of the search. 1467 1468 | 1469 1470 *Overload 2:* 1471 Collect all solutions of the search. The variables will need to 1472 be added later. 1473 """ 1474 return _pywrapcp.Solver_AllSolutionCollector(self, *args)
Overload 1: Collect all solutions of the search.
|
Overload 2: Collect all solutions of the search. The variables will need to be added later.
def
Minimize(self, v, step):
1476 def Minimize(self, v, step): 1477 r""" Creates a minimization objective.""" 1478 return _pywrapcp.Solver_Minimize(self, v, step)
Creates a minimization objective.
def
Maximize(self, v, step):
1480 def Maximize(self, v, step): 1481 r""" Creates a maximization objective.""" 1482 return _pywrapcp.Solver_Maximize(self, v, step)
Creates a maximization objective.
def
Optimize(self, maximize, v, step):
1484 def Optimize(self, maximize, v, step): 1485 r""" Creates a objective with a given sense (true = maximization).""" 1486 return _pywrapcp.Solver_Optimize(self, maximize, v, step)
Creates a objective with a given sense (true = maximization).
def
WeightedMinimize(self, *args):
1488 def WeightedMinimize(self, *args): 1489 r""" 1490 *Overload 1:* 1491 Creates a minimization weighted objective. The actual objective is 1492 scalar_prod(sub_objectives, weights). 1493 1494 | 1495 1496 *Overload 2:* 1497 Creates a minimization weighted objective. The actual objective is 1498 scalar_prod(sub_objectives, weights). 1499 """ 1500 return _pywrapcp.Solver_WeightedMinimize(self, *args)
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).
def
WeightedMaximize(self, *args):
1502 def WeightedMaximize(self, *args): 1503 r""" 1504 *Overload 1:* 1505 Creates a maximization weigthed objective. 1506 1507 | 1508 1509 *Overload 2:* 1510 Creates a maximization weigthed objective. 1511 """ 1512 return _pywrapcp.Solver_WeightedMaximize(self, *args)
Overload 1: Creates a maximization weigthed objective.
|
Overload 2: Creates a maximization weigthed objective.
def
WeightedOptimize(self, *args):
1514 def WeightedOptimize(self, *args): 1515 r""" 1516 *Overload 1:* 1517 Creates a weighted objective with a given sense (true = maximization). 1518 1519 | 1520 1521 *Overload 2:* 1522 Creates a weighted objective with a given sense (true = maximization). 1523 """ 1524 return _pywrapcp.Solver_WeightedOptimize(self, *args)
Overload 1: Creates a weighted objective with a given sense (true = maximization).
|
Overload 2: Creates a weighted objective with a given sense (true = maximization).
def
TabuSearch( self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor):
1526 def TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor): 1527 r""" 1528 MetaHeuristics which try to get the search out of local optima. 1529 Creates a Tabu Search monitor. 1530 In the context of local search the behavior is similar to MakeOptimize(), 1531 creating an objective in a given sense. The behavior differs once a local 1532 optimum is reached: thereafter solutions which degrade the value of the 1533 objective are allowed if they are not "tabu". A solution is "tabu" if it 1534 doesn't respect the following rules: 1535 - improving the best solution found so far 1536 - variables in the "keep" list must keep their value, variables in the 1537 "forbid" list must not take the value they have in the list. 1538 Variables with new values enter the tabu lists after each new solution 1539 found and leave the lists after a given number of iterations (called 1540 tenure). Only the variables passed to the method can enter the lists. 1541 The tabu criterion is softened by the tabu factor which gives the number 1542 of "tabu" violations which is tolerated; a factor of 1 means no violations 1543 allowed; a factor of 0 means all violations are allowed. 1544 """ 1545 return _pywrapcp.Solver_TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor)
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.
def
SimulatedAnnealing(self, maximize, v, step, initial_temperature):
1547 def SimulatedAnnealing(self, maximize, v, step, initial_temperature): 1548 r""" Creates a Simulated Annealing monitor.""" 1549 return _pywrapcp.Solver_SimulatedAnnealing(self, maximize, v, step, initial_temperature)
Creates a Simulated Annealing monitor.
def
LubyRestart(self, scale_factor):
1551 def LubyRestart(self, scale_factor): 1552 r""" 1553 This search monitor will restart the search periodically. 1554 At the iteration n, it will restart after scale_factor * Luby(n) failures 1555 where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...). 1556 """ 1557 return _pywrapcp.Solver_LubyRestart(self, scale_factor)
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...).
def
ConstantRestart(self, frequency):
1559 def ConstantRestart(self, frequency): 1560 r""" 1561 This search monitor will restart the search periodically after 'frequency' 1562 failures. 1563 """ 1564 return _pywrapcp.Solver_ConstantRestart(self, frequency)
This search monitor will restart the search periodically after 'frequency' failures.
def
BranchesLimit(self, branches):
1569 def BranchesLimit(self, branches): 1570 r""" 1571 Creates a search limit that constrains the number of branches 1572 explored in the search tree. 1573 """ 1574 return _pywrapcp.Solver_BranchesLimit(self, branches)
Creates a search limit that constrains the number of branches explored in the search tree.
def
FailuresLimit(self, failures):
1576 def FailuresLimit(self, failures): 1577 r""" 1578 Creates a search limit that constrains the number of failures 1579 that can happen when exploring the search tree. 1580 """ 1581 return _pywrapcp.Solver_FailuresLimit(self, failures)
Creates a search limit that constrains the number of failures that can happen when exploring the search tree.
def
SolutionsLimit(self, solutions):
1583 def SolutionsLimit(self, solutions): 1584 r""" 1585 Creates a search limit that constrains the number of solutions found 1586 during the search. 1587 """ 1588 return _pywrapcp.Solver_SolutionsLimit(self, solutions)
Creates a search limit that constrains the number of solutions found during the search.
def
Limit(self, *args):
1590 def Limit(self, *args): 1591 r""" 1592 *Overload 1:* 1593 Limits the search with the 'time', 'branches', 'failures' and 1594 'solutions' limits. 'smart_time_check' reduces the calls to the wall 1595 1596 | 1597 1598 *Overload 2:* 1599 Creates a search limit from its protobuf description 1600 1601 | 1602 1603 *Overload 3:* 1604 Creates a search limit that is reached when either of the underlying limit 1605 is reached. That is, the returned limit is more stringent than both 1606 argument limits. 1607 """ 1608 return _pywrapcp.Solver_Limit(self, *args)
Overload 1: Limits the search with the 'time', 'branches', 'failures' and 'solutions' limits. 'smart_time_check' reduces the calls to the wall
|
Overload 2: Creates a search limit from its protobuf description
|
Overload 3: 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.
def
CustomLimit(self, limiter):
1610 def CustomLimit(self, limiter): 1611 r""" 1612 Callback-based search limit. Search stops when limiter returns true; if 1613 this happens at a leaf the corresponding solution will be rejected. 1614 """ 1615 return _pywrapcp.Solver_CustomLimit(self, limiter)
Callback-based search limit. Search stops when limiter returns true; if this happens at a leaf the corresponding solution will be rejected.
def
SearchTrace(self, prefix):
1620 def SearchTrace(self, prefix): 1621 r""" 1622 Creates a search monitor that will trace precisely the behavior of the 1623 search. Use this only for low level debugging. 1624 """ 1625 return _pywrapcp.Solver_SearchTrace(self, prefix)
Creates a search monitor that will trace precisely the behavior of the search. Use this only for low level debugging.
def
PrintModelVisitor(self):
1627 def PrintModelVisitor(self): 1628 r""" Prints the model.""" 1629 return _pywrapcp.Solver_PrintModelVisitor(self)
Prints the model.
def
StatisticsModelVisitor(self):
1631 def StatisticsModelVisitor(self): 1632 r""" Displays some nice statistics on the model.""" 1633 return _pywrapcp.Solver_StatisticsModelVisitor(self)
Displays some nice statistics on the model.
def
AssignVariableValue(self, var, val):
1635 def AssignVariableValue(self, var, val): 1636 r""" Decisions.""" 1637 return _pywrapcp.Solver_AssignVariableValue(self, var, val)
Decisions.
def
ScheduleOrPostpone(self, var, est, marker):
1669 def ScheduleOrPostpone(self, var, est, marker): 1670 r""" 1671 Returns a decision that tries to schedule a task at a given time. 1672 On the Apply branch, it will set that interval var as performed and set 1673 its start to 'est'. On the Refute branch, it will just update the 1674 'marker' to 'est' + 1. This decision is used in the 1675 INTERVAL_SET_TIMES_FORWARD strategy. 1676 """ 1677 return _pywrapcp.Solver_ScheduleOrPostpone(self, var, est, marker)
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.
def
ScheduleOrExpedite(self, var, est, marker):
1679 def ScheduleOrExpedite(self, var, est, marker): 1680 r""" 1681 Returns a decision that tries to schedule a task at a given time. 1682 On the Apply branch, it will set that interval var as performed and set 1683 its end to 'est'. On the Refute branch, it will just update the 1684 'marker' to 'est' - 1. This decision is used in the 1685 INTERVAL_SET_TIMES_BACKWARD strategy. 1686 """ 1687 return _pywrapcp.Solver_ScheduleOrExpedite(self, var, est, marker)
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.
def
RankFirstInterval(self, sequence, index):
1689 def RankFirstInterval(self, sequence, index): 1690 r""" 1691 Returns a decision that tries to rank first the ith interval var 1692 in the sequence variable. 1693 """ 1694 return _pywrapcp.Solver_RankFirstInterval(self, sequence, index)
Returns a decision that tries to rank first the ith interval var in the sequence variable.
def
RankLastInterval(self, sequence, index):
1696 def RankLastInterval(self, sequence, index): 1697 r""" 1698 Returns a decision that tries to rank last the ith interval var 1699 in the sequence variable. 1700 """ 1701 return _pywrapcp.Solver_RankLastInterval(self, sequence, index)
Returns a decision that tries to rank last the ith interval var in the sequence variable.
def
DecisionBuilderFromAssignment(self, assignment, db, vars):
1706 def DecisionBuilderFromAssignment(self, assignment, db, vars): 1707 r""" 1708 Returns a decision builder for which the left-most leaf corresponds 1709 to assignment, the rest of the tree being explored using 'db'. 1710 """ 1711 return _pywrapcp.Solver_DecisionBuilderFromAssignment(self, assignment, db, vars)
Returns a decision builder for which the left-most leaf corresponds to assignment, the rest of the tree being explored using 'db'.
def
ConstraintAdder(self, ct):
1713 def ConstraintAdder(self, ct): 1714 r""" 1715 Returns a decision builder that will add the given constraint to 1716 the model. 1717 """ 1718 return _pywrapcp.Solver_ConstraintAdder(self, ct)
Returns a decision builder that will add the given constraint to the model.
def
RestoreAssignment(self, assignment):
1726 def RestoreAssignment(self, assignment): 1727 r""" 1728 Returns a DecisionBuilder which restores an Assignment 1729 (calls void Assignment::Restore()) 1730 """ 1731 return _pywrapcp.Solver_RestoreAssignment(self, assignment)
Returns a DecisionBuilder which restores an Assignment (calls void Assignment::Restore())
def
StoreAssignment(self, assignment):
1733 def StoreAssignment(self, assignment): 1734 r""" 1735 Returns a DecisionBuilder which stores an Assignment 1736 (calls void Assignment::Store()) 1737 """ 1738 return _pywrapcp.Solver_StoreAssignment(self, assignment)
Returns a DecisionBuilder which stores an Assignment (calls void Assignment::Store())
def
MoveTowardTargetOperator(self, *args):
1746 def MoveTowardTargetOperator(self, *args): 1747 r""" 1748 *Overload 1:* 1749 Creates a local search operator that tries to move the assignment of some 1750 variables toward a target. The target is given as an Assignment. This 1751 operator generates neighbors in which the only difference compared to the 1752 current state is that one variable that belongs to the target assignment 1753 is set to its target value. 1754 1755 | 1756 1757 *Overload 2:* 1758 Creates a local search operator that tries to move the assignment of some 1759 variables toward a target. The target is given either as two vectors: a 1760 vector of variables and a vector of associated target values. The two 1761 vectors should be of the same length. This operator generates neighbors in 1762 which the only difference compared to the current state is that one 1763 variable that belongs to the given vector is set to its target value. 1764 """ 1765 return _pywrapcp.Solver_MoveTowardTargetOperator(self, *args)
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.
def
RandomConcatenateOperators(self, *args):
1770 def RandomConcatenateOperators(self, *args): 1771 r""" 1772 *Overload 1:* 1773 Randomized version of local search concatenator; calls a random operator 1774 at each call to MakeNextNeighbor(). 1775 1776 | 1777 1778 *Overload 2:* 1779 Randomized version of local search concatenator; calls a random operator 1780 at each call to MakeNextNeighbor(). The provided seed is used to 1781 initialize the random number generator. 1782 """ 1783 return _pywrapcp.Solver_RandomConcatenateOperators(self, *args)
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.
def
NeighborhoodLimit(self, op, limit):
1785 def NeighborhoodLimit(self, op, limit): 1786 r""" 1787 Creates a local search operator that wraps another local search 1788 operator and limits the number of neighbors explored (i.e., calls 1789 to MakeNextNeighbor from the current solution (between two calls 1790 to Start()). When this limit is reached, MakeNextNeighbor() 1791 returns false. The counter is cleared when Start() is called. 1792 """ 1793 return _pywrapcp.Solver_NeighborhoodLimit(self, op, limit)
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.
def
TopProgressPercent(self):
1801 def TopProgressPercent(self): 1802 r""" 1803 Returns a percentage representing the propress of the search before 1804 reaching the limits of the top-level search (can be called from a nested 1805 solve). 1806 """ 1807 return _pywrapcp.Solver_TopProgressPercent(self)
Returns a percentage representing the propress of the search before reaching the limits of the top-level search (can be called from a nested solve).
def
SearchDepth(self):
1809 def SearchDepth(self): 1810 r""" 1811 Gets the search depth of the current active search. Returns -1 if 1812 there is no active search opened. 1813 """ 1814 return _pywrapcp.Solver_SearchDepth(self)
Gets the search depth of the current active search. Returns -1 if there is no active search opened.
def
SearchLeftDepth(self):
1816 def SearchLeftDepth(self): 1817 r""" 1818 Gets the search left depth of the current active search. Returns -1 if 1819 there is no active search opened. 1820 """ 1821 return _pywrapcp.Solver_SearchLeftDepth(self)
Gets the search left depth of the current active search. Returns -1 if there is no active search opened.
def
SolveDepth(self):
1823 def SolveDepth(self): 1824 r""" 1825 Gets the number of nested searches. It returns 0 outside search, 1826 1 during the top level search, 2 or more in case of nested searches. 1827 """ 1828 return _pywrapcp.Solver_SolveDepth(self)
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.
def
Rand64(self, size):
1830 def Rand64(self, size): 1831 r""" Returns a random value between 0 and 'size' - 1;""" 1832 return _pywrapcp.Solver_Rand64(self, size)
Returns a random value between 0 and 'size' - 1;
def
Rand32(self, size):
1834 def Rand32(self, size): 1835 r""" Returns a random value between 0 and 'size' - 1;""" 1836 return _pywrapcp.Solver_Rand32(self, size)
Returns a random value between 0 and 'size' - 1;
def
ReSeed(self, seed):
1838 def ReSeed(self, seed): 1839 r""" Reseed the solver random generator.""" 1840 return _pywrapcp.Solver_ReSeed(self, seed)
Reseed the solver random generator.
def
LocalSearchProfile(self):
1842 def LocalSearchProfile(self): 1843 r""" Returns local search profiling information in a human readable format.""" 1844 return _pywrapcp.Solver_LocalSearchProfile(self)
Returns local search profiling information in a human readable format.
def
Constraints(self):
1846 def Constraints(self): 1847 r""" 1848 Counts the number of constraints that have been added 1849 to the solver before the search. 1850 """ 1851 return _pywrapcp.Solver_Constraints(self)
Counts the number of constraints that have been added to the solver before the search.
def
Accept(self, visitor):
1853 def Accept(self, visitor): 1854 r""" Accepts the given model visitor.""" 1855 return _pywrapcp.Solver_Accept(self, visitor)
Accepts the given model visitor.
def
FinishCurrentSearch(self):
1857 def FinishCurrentSearch(self): 1858 r""" Tells the solver to kill or restart the current search.""" 1859 return _pywrapcp.Solver_FinishCurrentSearch(self)
Tells the solver to kill or restart the current search.
def
ShouldFail(self):
1864 def ShouldFail(self): 1865 r""" 1866 These methods are only useful for the SWIG wrappers, which need a way 1867 to externally cause the Solver to fail. 1868 """ 1869 return _pywrapcp.Solver_ShouldFail(self)
These methods are only useful for the SWIG wrappers, which need a way to externally cause the Solver to fail.
class
BaseObject:
1918class BaseObject(object): 1919 r""" 1920 A BaseObject is the root of all reversibly allocated objects. 1921 A DebugString method and the associated << operator are implemented 1922 as a convenience. 1923 """ 1924 1925 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 1926 1927 def __init__(self): 1928 if self.__class__ == BaseObject: 1929 _self = None 1930 else: 1931 _self = self 1932 _pywrapcp.BaseObject_swiginit(self, _pywrapcp.new_BaseObject(_self, )) 1933 __swig_destroy__ = _pywrapcp.delete_BaseObject 1934 1935 def DebugString(self): 1936 return _pywrapcp.BaseObject_DebugString(self) 1937 1938 def __str__(self): 1939 return _pywrapcp.BaseObject___str__(self) 1940 1941 def __repr__(self): 1942 return _pywrapcp.BaseObject___repr__(self) 1943 def __disown__(self): 1944 self.this.disown() 1945 _pywrapcp.disown_BaseObject(self) 1946 return weakref.proxy(self)
A BaseObject is the root of all reversibly allocated objects. A DebugString method and the associated << operator are implemented as a convenience.
thisown
1925 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
1950class PropagationBaseObject(BaseObject): 1951 r""" 1952 NOLINT 1953 The PropagationBaseObject is a subclass of BaseObject that is also 1954 friend to the Solver class. It allows accessing methods useful when 1955 writing new constraints or new expressions. 1956 """ 1957 1958 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 1959 __repr__ = _swig_repr 1960 1961 def __init__(self, s): 1962 if self.__class__ == PropagationBaseObject: 1963 _self = None 1964 else: 1965 _self = self 1966 _pywrapcp.PropagationBaseObject_swiginit(self, _pywrapcp.new_PropagationBaseObject(_self, s)) 1967 __swig_destroy__ = _pywrapcp.delete_PropagationBaseObject 1968 1969 def DebugString(self): 1970 return _pywrapcp.PropagationBaseObject_DebugString(self) 1971 1972 def solver(self): 1973 return _pywrapcp.PropagationBaseObject_solver(self) 1974 1975 def Name(self): 1976 r""" Object naming.""" 1977 return _pywrapcp.PropagationBaseObject_Name(self) 1978 def __disown__(self): 1979 self.this.disown() 1980 _pywrapcp.disown_PropagationBaseObject(self) 1981 return weakref.proxy(self)
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
1958 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
1985class Decision(BaseObject): 1986 r""" 1987 A Decision represents a choice point in the search tree. The two main 1988 methods are Apply() to go left, or Refute() to go right. 1989 """ 1990 1991 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 1992 1993 def __init__(self): 1994 if self.__class__ == Decision: 1995 _self = None 1996 else: 1997 _self = self 1998 _pywrapcp.Decision_swiginit(self, _pywrapcp.new_Decision(_self, )) 1999 __swig_destroy__ = _pywrapcp.delete_Decision 2000 2001 def ApplyWrapper(self, s): 2002 r""" Apply will be called first when the decision is executed.""" 2003 return _pywrapcp.Decision_ApplyWrapper(self, s) 2004 2005 def RefuteWrapper(self, s): 2006 r""" Refute will be called after a backtrack.""" 2007 return _pywrapcp.Decision_RefuteWrapper(self, s) 2008 2009 def DebugString(self): 2010 return _pywrapcp.Decision_DebugString(self) 2011 2012 def __repr__(self): 2013 return _pywrapcp.Decision___repr__(self) 2014 2015 def __str__(self): 2016 return _pywrapcp.Decision___str__(self) 2017 def __disown__(self): 2018 self.this.disown() 2019 _pywrapcp.disown_Decision(self) 2020 return weakref.proxy(self)
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
1991 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
ApplyWrapper(self, s):
2001 def ApplyWrapper(self, s): 2002 r""" Apply will be called first when the decision is executed.""" 2003 return _pywrapcp.Decision_ApplyWrapper(self, s)
Apply will be called first when the decision is executed.
2024class DecisionBuilder(BaseObject): 2025 r""" 2026 A DecisionBuilder is responsible for creating the search tree. The 2027 important method is Next(), which returns the next decision to execute. 2028 """ 2029 2030 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2031 2032 def __init__(self): 2033 if self.__class__ == DecisionBuilder: 2034 _self = None 2035 else: 2036 _self = self 2037 _pywrapcp.DecisionBuilder_swiginit(self, _pywrapcp.new_DecisionBuilder(_self, )) 2038 __swig_destroy__ = _pywrapcp.delete_DecisionBuilder 2039 2040 def NextWrapper(self, s): 2041 r""" 2042 This is the main method of the decision builder class. It must 2043 return a decision (an instance of the class Decision). If it 2044 returns nullptr, this means that the decision builder has finished 2045 its work. 2046 """ 2047 return _pywrapcp.DecisionBuilder_NextWrapper(self, s) 2048 2049 def DebugString(self): 2050 return _pywrapcp.DecisionBuilder_DebugString(self) 2051 2052 def __repr__(self): 2053 return _pywrapcp.DecisionBuilder___repr__(self) 2054 2055 def __str__(self): 2056 return _pywrapcp.DecisionBuilder___str__(self) 2057 def __disown__(self): 2058 self.this.disown() 2059 _pywrapcp.disown_DecisionBuilder(self) 2060 return weakref.proxy(self)
A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.
thisown
2030 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
NextWrapper(self, s):
2040 def NextWrapper(self, s): 2041 r""" 2042 This is the main method of the decision builder class. It must 2043 return a decision (an instance of the class Decision). If it 2044 returns nullptr, this means that the decision builder has finished 2045 its work. 2046 """ 2047 return _pywrapcp.DecisionBuilder_NextWrapper(self, s)
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.
2064class Demon(BaseObject): 2065 r""" 2066 A Demon is the base element of a propagation queue. It is the main 2067 object responsible for implementing the actual propagation 2068 of the constraint and pruning the inconsistent values in the domains 2069 of the variables. The main concept is that demons are listeners that are 2070 attached to the variables and listen to their modifications. 2071 There are two methods: 2072 - Run() is the actual method called when the demon is processed. 2073 - priority() returns its priority. Standard priorities are slow, normal 2074 or fast. "immediate" is reserved for variables and is treated separately. 2075 """ 2076 2077 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2078 __repr__ = _swig_repr 2079 2080 def __init__(self): 2081 r""" 2082 This indicates the priority of a demon. Immediate demons are treated 2083 separately and corresponds to variables. 2084 """ 2085 if self.__class__ == Demon: 2086 _self = None 2087 else: 2088 _self = self 2089 _pywrapcp.Demon_swiginit(self, _pywrapcp.new_Demon(_self, )) 2090 __swig_destroy__ = _pywrapcp.delete_Demon 2091 2092 def RunWrapper(self, s): 2093 r""" This is the main callback of the demon.""" 2094 return _pywrapcp.Demon_RunWrapper(self, s) 2095 2096 def Priority(self): 2097 r""" 2098 This method returns the priority of the demon. Usually a demon is 2099 fast, slow or normal. Immediate demons are reserved for internal 2100 use to maintain variables. 2101 """ 2102 return _pywrapcp.Demon_Priority(self) 2103 2104 def DebugString(self): 2105 return _pywrapcp.Demon_DebugString(self) 2106 2107 def Inhibit(self, s): 2108 r""" 2109 This method inhibits the demon in the search tree below the 2110 current position. 2111 """ 2112 return _pywrapcp.Demon_Inhibit(self, s) 2113 2114 def Desinhibit(self, s): 2115 r""" This method un-inhibits the demon that was previously inhibited.""" 2116 return _pywrapcp.Demon_Desinhibit(self, s) 2117 def __disown__(self): 2118 self.this.disown() 2119 _pywrapcp.disown_Demon(self) 2120 return weakref.proxy(self)
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.
Demon()
2080 def __init__(self): 2081 r""" 2082 This indicates the priority of a demon. Immediate demons are treated 2083 separately and corresponds to variables. 2084 """ 2085 if self.__class__ == Demon: 2086 _self = None 2087 else: 2088 _self = self 2089 _pywrapcp.Demon_swiginit(self, _pywrapcp.new_Demon(_self, ))
This indicates the priority of a demon. Immediate demons are treated separately and corresponds to variables.
thisown
2077 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
RunWrapper(self, s):
2092 def RunWrapper(self, s): 2093 r""" This is the main callback of the demon.""" 2094 return _pywrapcp.Demon_RunWrapper(self, s)
This is the main callback of the demon.
def
Priority(self):
2096 def Priority(self): 2097 r""" 2098 This method returns the priority of the demon. Usually a demon is 2099 fast, slow or normal. Immediate demons are reserved for internal 2100 use to maintain variables. 2101 """ 2102 return _pywrapcp.Demon_Priority(self)
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.
2124class Constraint(PropagationBaseObject): 2125 r""" 2126 A constraint is the main modeling object. It provides two methods: 2127 - Post() is responsible for creating the demons and attaching them to 2128 immediate demons(). 2129 - InitialPropagate() is called once just after Post and performs 2130 the initial propagation. The subsequent propagations will be performed 2131 by the demons Posted during the post() method. 2132 """ 2133 2134 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2135 2136 def __init__(self, solver): 2137 if self.__class__ == Constraint: 2138 _self = None 2139 else: 2140 _self = self 2141 _pywrapcp.Constraint_swiginit(self, _pywrapcp.new_Constraint(_self, solver)) 2142 __swig_destroy__ = _pywrapcp.delete_Constraint 2143 2144 def Post(self): 2145 r""" 2146 This method is called when the constraint is processed by the 2147 solver. Its main usage is to attach demons to variables. 2148 """ 2149 return _pywrapcp.Constraint_Post(self) 2150 2151 def InitialPropagateWrapper(self): 2152 r""" 2153 This method performs the initial propagation of the 2154 constraint. It is called just after the post. 2155 """ 2156 return _pywrapcp.Constraint_InitialPropagateWrapper(self) 2157 2158 def DebugString(self): 2159 return _pywrapcp.Constraint_DebugString(self) 2160 2161 def Var(self): 2162 r""" 2163 Creates a Boolean variable representing the status of the constraint 2164 (false = constraint is violated, true = constraint is satisfied). It 2165 returns nullptr if the constraint does not support this API. 2166 """ 2167 return _pywrapcp.Constraint_Var(self) 2168 2169 def __repr__(self): 2170 return _pywrapcp.Constraint___repr__(self) 2171 2172 def __str__(self): 2173 return _pywrapcp.Constraint___str__(self) 2174 2175 def __add__(self, *args): 2176 return _pywrapcp.Constraint___add__(self, *args) 2177 2178 def __radd__(self, v): 2179 return _pywrapcp.Constraint___radd__(self, v) 2180 2181 def __sub__(self, *args): 2182 return _pywrapcp.Constraint___sub__(self, *args) 2183 2184 def __rsub__(self, v): 2185 return _pywrapcp.Constraint___rsub__(self, v) 2186 2187 def __mul__(self, *args): 2188 return _pywrapcp.Constraint___mul__(self, *args) 2189 2190 def __rmul__(self, v): 2191 return _pywrapcp.Constraint___rmul__(self, v) 2192 2193 def __floordiv__(self, v): 2194 return _pywrapcp.Constraint___floordiv__(self, v) 2195 2196 def __neg__(self): 2197 return _pywrapcp.Constraint___neg__(self) 2198 2199 def __abs__(self): 2200 return _pywrapcp.Constraint___abs__(self) 2201 2202 def Square(self): 2203 return _pywrapcp.Constraint_Square(self) 2204 2205 def __eq__(self, *args): 2206 return _pywrapcp.Constraint___eq__(self, *args) 2207 2208 def __ne__(self, *args): 2209 return _pywrapcp.Constraint___ne__(self, *args) 2210 2211 def __ge__(self, *args): 2212 return _pywrapcp.Constraint___ge__(self, *args) 2213 2214 def __gt__(self, *args): 2215 return _pywrapcp.Constraint___gt__(self, *args) 2216 2217 def __le__(self, *args): 2218 return _pywrapcp.Constraint___le__(self, *args) 2219 2220 def __lt__(self, *args): 2221 return _pywrapcp.Constraint___lt__(self, *args) 2222 2223 def MapTo(self, vars): 2224 return _pywrapcp.Constraint_MapTo(self, vars) 2225 2226 def IndexOf(self, *args): 2227 return _pywrapcp.Constraint_IndexOf(self, *args) 2228 def __disown__(self): 2229 self.this.disown() 2230 _pywrapcp.disown_Constraint(self) 2231 return weakref.proxy(self)
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
2134 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
Post(self):
2144 def Post(self): 2145 r""" 2146 This method is called when the constraint is processed by the 2147 solver. Its main usage is to attach demons to variables. 2148 """ 2149 return _pywrapcp.Constraint_Post(self)
This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables.
def
InitialPropagateWrapper(self):
2151 def InitialPropagateWrapper(self): 2152 r""" 2153 This method performs the initial propagation of the 2154 constraint. It is called just after the post. 2155 """ 2156 return _pywrapcp.Constraint_InitialPropagateWrapper(self)
This method performs the initial propagation of the constraint. It is called just after the post.
def
Var(self):
2161 def Var(self): 2162 r""" 2163 Creates a Boolean variable representing the status of the constraint 2164 (false = constraint is violated, true = constraint is satisfied). It 2165 returns nullptr if the constraint does not support this API. 2166 """ 2167 return _pywrapcp.Constraint_Var(self)
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.
Inherited Members
2235class SearchMonitor(BaseObject): 2236 r""" A search monitor is a simple set of callbacks to monitor all search events""" 2237 2238 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2239 kNoProgress = _pywrapcp.SearchMonitor_kNoProgress 2240 2241 def __init__(self, s): 2242 if self.__class__ == SearchMonitor: 2243 _self = None 2244 else: 2245 _self = self 2246 _pywrapcp.SearchMonitor_swiginit(self, _pywrapcp.new_SearchMonitor(_self, s)) 2247 __swig_destroy__ = _pywrapcp.delete_SearchMonitor 2248 2249 def EnterSearch(self): 2250 r""" Beginning of the search.""" 2251 return _pywrapcp.SearchMonitor_EnterSearch(self) 2252 2253 def RestartSearch(self): 2254 r""" Restart the search.""" 2255 return _pywrapcp.SearchMonitor_RestartSearch(self) 2256 2257 def ExitSearch(self): 2258 r""" End of the search.""" 2259 return _pywrapcp.SearchMonitor_ExitSearch(self) 2260 2261 def BeginNextDecision(self, b): 2262 r""" Before calling DecisionBuilder::Next.""" 2263 return _pywrapcp.SearchMonitor_BeginNextDecision(self, b) 2264 2265 def EndNextDecision(self, b, d): 2266 r""" After calling DecisionBuilder::Next, along with the returned decision.""" 2267 return _pywrapcp.SearchMonitor_EndNextDecision(self, b, d) 2268 2269 def ApplyDecision(self, d): 2270 r""" Before applying the decision.""" 2271 return _pywrapcp.SearchMonitor_ApplyDecision(self, d) 2272 2273 def RefuteDecision(self, d): 2274 r""" Before refuting the decision.""" 2275 return _pywrapcp.SearchMonitor_RefuteDecision(self, d) 2276 2277 def AfterDecision(self, d, apply): 2278 r""" 2279 Just after refuting or applying the decision, apply is true after Apply. 2280 This is called only if the Apply() or Refute() methods have not failed. 2281 """ 2282 return _pywrapcp.SearchMonitor_AfterDecision(self, d, apply) 2283 2284 def BeginFail(self): 2285 r""" Just when the failure occurs.""" 2286 return _pywrapcp.SearchMonitor_BeginFail(self) 2287 2288 def EndFail(self): 2289 r""" After completing the backtrack.""" 2290 return _pywrapcp.SearchMonitor_EndFail(self) 2291 2292 def BeginInitialPropagation(self): 2293 r""" Before the initial propagation.""" 2294 return _pywrapcp.SearchMonitor_BeginInitialPropagation(self) 2295 2296 def EndInitialPropagation(self): 2297 r""" After the initial propagation.""" 2298 return _pywrapcp.SearchMonitor_EndInitialPropagation(self) 2299 2300 def AcceptSolution(self): 2301 r""" 2302 This method is called when a solution is found. It asserts whether the 2303 solution is valid. A value of false indicates that the solution 2304 should be discarded. 2305 """ 2306 return _pywrapcp.SearchMonitor_AcceptSolution(self) 2307 2308 def AtSolution(self): 2309 r""" 2310 This method is called when a valid solution is found. If the 2311 return value is true, then search will resume after. If the result 2312 is false, then search will stop there. 2313 """ 2314 return _pywrapcp.SearchMonitor_AtSolution(self) 2315 2316 def NoMoreSolutions(self): 2317 r""" When the search tree is finished.""" 2318 return _pywrapcp.SearchMonitor_NoMoreSolutions(self) 2319 2320 def LocalOptimum(self): 2321 r""" 2322 When a local optimum is reached. If 'true' is returned, the last solution 2323 is discarded and the search proceeds with the next one. 2324 """ 2325 return _pywrapcp.SearchMonitor_LocalOptimum(self) 2326 2327 def AcceptDelta(self, delta, deltadelta): 2328 2329 return _pywrapcp.SearchMonitor_AcceptDelta(self, delta, deltadelta) 2330 2331 def AcceptNeighbor(self): 2332 r""" After accepting a neighbor during local search.""" 2333 return _pywrapcp.SearchMonitor_AcceptNeighbor(self) 2334 2335 def ProgressPercent(self): 2336 r""" 2337 Returns a percentage representing the propress of the search before 2338 reaching limits. 2339 """ 2340 return _pywrapcp.SearchMonitor_ProgressPercent(self) 2341 2342 def solver(self): 2343 return _pywrapcp.SearchMonitor_solver(self) 2344 2345 def __repr__(self): 2346 return _pywrapcp.SearchMonitor___repr__(self) 2347 2348 def __str__(self): 2349 return _pywrapcp.SearchMonitor___str__(self) 2350 def __disown__(self): 2351 self.this.disown() 2352 _pywrapcp.disown_SearchMonitor(self) 2353 return weakref.proxy(self)
A search monitor is a simple set of callbacks to monitor all search events
thisown
2238 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
EnterSearch(self):
2249 def EnterSearch(self): 2250 r""" Beginning of the search.""" 2251 return _pywrapcp.SearchMonitor_EnterSearch(self)
Beginning of the search.
def
RestartSearch(self):
2253 def RestartSearch(self): 2254 r""" Restart the search.""" 2255 return _pywrapcp.SearchMonitor_RestartSearch(self)
Restart the search.
def
ExitSearch(self):
2257 def ExitSearch(self): 2258 r""" End of the search.""" 2259 return _pywrapcp.SearchMonitor_ExitSearch(self)
End of the search.
def
BeginNextDecision(self, b):
2261 def BeginNextDecision(self, b): 2262 r""" Before calling DecisionBuilder::Next.""" 2263 return _pywrapcp.SearchMonitor_BeginNextDecision(self, b)
Before calling DecisionBuilder::Next.
def
EndNextDecision(self, b, d):
2265 def EndNextDecision(self, b, d): 2266 r""" After calling DecisionBuilder::Next, along with the returned decision.""" 2267 return _pywrapcp.SearchMonitor_EndNextDecision(self, b, d)
After calling DecisionBuilder::Next, along with the returned decision.
def
ApplyDecision(self, d):
2269 def ApplyDecision(self, d): 2270 r""" Before applying the decision.""" 2271 return _pywrapcp.SearchMonitor_ApplyDecision(self, d)
Before applying the decision.
def
RefuteDecision(self, d):
2273 def RefuteDecision(self, d): 2274 r""" Before refuting the decision.""" 2275 return _pywrapcp.SearchMonitor_RefuteDecision(self, d)
Before refuting the decision.
def
AfterDecision(self, d, apply):
2277 def AfterDecision(self, d, apply): 2278 r""" 2279 Just after refuting or applying the decision, apply is true after Apply. 2280 This is called only if the Apply() or Refute() methods have not failed. 2281 """ 2282 return _pywrapcp.SearchMonitor_AfterDecision(self, d, apply)
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.
def
BeginFail(self):
2284 def BeginFail(self): 2285 r""" Just when the failure occurs.""" 2286 return _pywrapcp.SearchMonitor_BeginFail(self)
Just when the failure occurs.
def
EndFail(self):
2288 def EndFail(self): 2289 r""" After completing the backtrack.""" 2290 return _pywrapcp.SearchMonitor_EndFail(self)
After completing the backtrack.
def
BeginInitialPropagation(self):
2292 def BeginInitialPropagation(self): 2293 r""" Before the initial propagation.""" 2294 return _pywrapcp.SearchMonitor_BeginInitialPropagation(self)
Before the initial propagation.
def
EndInitialPropagation(self):
2296 def EndInitialPropagation(self): 2297 r""" After the initial propagation.""" 2298 return _pywrapcp.SearchMonitor_EndInitialPropagation(self)
After the initial propagation.
def
AcceptSolution(self):
2300 def AcceptSolution(self): 2301 r""" 2302 This method is called when a solution is found. It asserts whether the 2303 solution is valid. A value of false indicates that the solution 2304 should be discarded. 2305 """ 2306 return _pywrapcp.SearchMonitor_AcceptSolution(self)
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.
def
AtSolution(self):
2308 def AtSolution(self): 2309 r""" 2310 This method is called when a valid solution is found. If the 2311 return value is true, then search will resume after. If the result 2312 is false, then search will stop there. 2313 """ 2314 return _pywrapcp.SearchMonitor_AtSolution(self)
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.
def
NoMoreSolutions(self):
2316 def NoMoreSolutions(self): 2317 r""" When the search tree is finished.""" 2318 return _pywrapcp.SearchMonitor_NoMoreSolutions(self)
When the search tree is finished.
def
LocalOptimum(self):
2320 def LocalOptimum(self): 2321 r""" 2322 When a local optimum is reached. If 'true' is returned, the last solution 2323 is discarded and the search proceeds with the next one. 2324 """ 2325 return _pywrapcp.SearchMonitor_LocalOptimum(self)
When a local optimum is reached. If 'true' is returned, the last solution is discarded and the search proceeds with the next one.
def
AcceptNeighbor(self):
2331 def AcceptNeighbor(self): 2332 r""" After accepting a neighbor during local search.""" 2333 return _pywrapcp.SearchMonitor_AcceptNeighbor(self)
After accepting a neighbor during local search.
def
ProgressPercent(self):
2335 def ProgressPercent(self): 2336 r""" 2337 Returns a percentage representing the propress of the search before 2338 reaching limits. 2339 """ 2340 return _pywrapcp.SearchMonitor_ProgressPercent(self)
Returns a percentage representing the propress of the search before reaching limits.
Inherited Members
2357class IntExpr(PropagationBaseObject): 2358 r""" 2359 The class IntExpr is the base of all integer expressions in 2360 constraint programming. 2361 It contains the basic protocol for an expression: 2362 - setting and modifying its bound 2363 - querying if it is bound 2364 - listening to events modifying its bounds 2365 - casting it into a variable (instance of IntVar) 2366 """ 2367 2368 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2369 2370 def __init__(self, *args, **kwargs): 2371 raise AttributeError("No constructor defined - class is abstract") 2372 2373 def Min(self): 2374 return _pywrapcp.IntExpr_Min(self) 2375 2376 def SetMin(self, m): 2377 return _pywrapcp.IntExpr_SetMin(self, m) 2378 2379 def Max(self): 2380 return _pywrapcp.IntExpr_Max(self) 2381 2382 def SetMax(self, m): 2383 return _pywrapcp.IntExpr_SetMax(self, m) 2384 2385 def SetRange(self, l, u): 2386 r""" This method sets both the min and the max of the expression.""" 2387 return _pywrapcp.IntExpr_SetRange(self, l, u) 2388 2389 def SetValue(self, v): 2390 r""" This method sets the value of the expression.""" 2391 return _pywrapcp.IntExpr_SetValue(self, v) 2392 2393 def Bound(self): 2394 r""" Returns true if the min and the max of the expression are equal.""" 2395 return _pywrapcp.IntExpr_Bound(self) 2396 2397 def IsVar(self): 2398 r""" Returns true if the expression is indeed a variable.""" 2399 return _pywrapcp.IntExpr_IsVar(self) 2400 2401 def Var(self): 2402 r""" Creates a variable from the expression.""" 2403 return _pywrapcp.IntExpr_Var(self) 2404 2405 def VarWithName(self, name): 2406 r""" 2407 Creates a variable from the expression and set the name of the 2408 resulting var. If the expression is already a variable, then it 2409 will set the name of the expression, possibly overwriting it. 2410 This is just a shortcut to Var() followed by set_name(). 2411 """ 2412 return _pywrapcp.IntExpr_VarWithName(self, name) 2413 2414 def WhenRange(self, *args): 2415 r""" 2416 *Overload 1:* 2417 Attach a demon that will watch the min or the max of the expression. 2418 2419 | 2420 2421 *Overload 2:* 2422 Attach a demon that will watch the min or the max of the expression. 2423 """ 2424 return _pywrapcp.IntExpr_WhenRange(self, *args) 2425 2426 def __repr__(self): 2427 return _pywrapcp.IntExpr___repr__(self) 2428 2429 def __str__(self): 2430 return _pywrapcp.IntExpr___str__(self) 2431 2432 def __add__(self, *args): 2433 return _pywrapcp.IntExpr___add__(self, *args) 2434 2435 def __radd__(self, v): 2436 return _pywrapcp.IntExpr___radd__(self, v) 2437 2438 def __sub__(self, *args): 2439 return _pywrapcp.IntExpr___sub__(self, *args) 2440 2441 def __rsub__(self, v): 2442 return _pywrapcp.IntExpr___rsub__(self, v) 2443 2444 def __mul__(self, *args): 2445 return _pywrapcp.IntExpr___mul__(self, *args) 2446 2447 def __rmul__(self, v): 2448 return _pywrapcp.IntExpr___rmul__(self, v) 2449 2450 def __floordiv__(self, *args): 2451 return _pywrapcp.IntExpr___floordiv__(self, *args) 2452 2453 def __mod__(self, *args): 2454 return _pywrapcp.IntExpr___mod__(self, *args) 2455 2456 def __neg__(self): 2457 return _pywrapcp.IntExpr___neg__(self) 2458 2459 def __abs__(self): 2460 return _pywrapcp.IntExpr___abs__(self) 2461 2462 def Square(self): 2463 return _pywrapcp.IntExpr_Square(self) 2464 2465 def __eq__(self, *args): 2466 return _pywrapcp.IntExpr___eq__(self, *args) 2467 2468 def __ne__(self, *args): 2469 return _pywrapcp.IntExpr___ne__(self, *args) 2470 2471 def __ge__(self, *args): 2472 return _pywrapcp.IntExpr___ge__(self, *args) 2473 2474 def __gt__(self, *args): 2475 return _pywrapcp.IntExpr___gt__(self, *args) 2476 2477 def __le__(self, *args): 2478 return _pywrapcp.IntExpr___le__(self, *args) 2479 2480 def __lt__(self, *args): 2481 return _pywrapcp.IntExpr___lt__(self, *args) 2482 2483 def MapTo(self, vars): 2484 return _pywrapcp.IntExpr_MapTo(self, vars) 2485 2486 def IndexOf(self, *args): 2487 return _pywrapcp.IntExpr_IndexOf(self, *args) 2488 2489 def IsMember(self, values): 2490 return _pywrapcp.IntExpr_IsMember(self, values) 2491 2492 def Member(self, values): 2493 return _pywrapcp.IntExpr_Member(self, values) 2494 2495 def NotMember(self, starts, ends): 2496 return _pywrapcp.IntExpr_NotMember(self, starts, ends)
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
2368 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
SetRange(self, l, u):
2385 def SetRange(self, l, u): 2386 r""" This method sets both the min and the max of the expression.""" 2387 return _pywrapcp.IntExpr_SetRange(self, l, u)
This method sets both the min and the max of the expression.
def
SetValue(self, v):
2389 def SetValue(self, v): 2390 r""" This method sets the value of the expression.""" 2391 return _pywrapcp.IntExpr_SetValue(self, v)
This method sets the value of the expression.
def
Bound(self):
2393 def Bound(self): 2394 r""" Returns true if the min and the max of the expression are equal.""" 2395 return _pywrapcp.IntExpr_Bound(self)
Returns true if the min and the max of the expression are equal.
def
IsVar(self):
2397 def IsVar(self): 2398 r""" Returns true if the expression is indeed a variable.""" 2399 return _pywrapcp.IntExpr_IsVar(self)
Returns true if the expression is indeed a variable.
def
Var(self):
2401 def Var(self): 2402 r""" Creates a variable from the expression.""" 2403 return _pywrapcp.IntExpr_Var(self)
Creates a variable from the expression.
def
VarWithName(self, name):
2405 def VarWithName(self, name): 2406 r""" 2407 Creates a variable from the expression and set the name of the 2408 resulting var. If the expression is already a variable, then it 2409 will set the name of the expression, possibly overwriting it. 2410 This is just a shortcut to Var() followed by set_name(). 2411 """ 2412 return _pywrapcp.IntExpr_VarWithName(self, name)
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().
def
WhenRange(self, *args):
2414 def WhenRange(self, *args): 2415 r""" 2416 *Overload 1:* 2417 Attach a demon that will watch the min or the max of the expression. 2418 2419 | 2420 2421 *Overload 2:* 2422 Attach a demon that will watch the min or the max of the expression. 2423 """ 2424 return _pywrapcp.IntExpr_WhenRange(self, *args)
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.
Inherited Members
2500class IntVarIterator(BaseObject): 2501 r""" 2502 The class Iterator has two direct subclasses. HoleIterators 2503 iterates over all holes, that is value removed between the 2504 current min and max of the variable since the last time the 2505 variable was processed in the queue. DomainIterators iterates 2506 over all elements of the variable domain. Both iterators are not 2507 robust to domain changes. Hole iterators can also report values outside 2508 the current min and max of the variable. 2509 HoleIterators should only be called from a demon attached to the 2510 variable that has created this iterator. 2511 IntVar* current_var; 2512 std::unique_ptr<IntVarIterator> it(current_var->MakeHoleIterator(false)); 2513 for (const int64_t hole : InitAndGetValues(it)) { 2514 use the hole 2515 } 2516 """ 2517 2518 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2519 2520 def __init__(self, *args, **kwargs): 2521 raise AttributeError("No constructor defined - class is abstract") 2522 __repr__ = _swig_repr 2523 2524 def Init(self): 2525 r""" This method must be called before each loop.""" 2526 return _pywrapcp.IntVarIterator_Init(self) 2527 2528 def Ok(self): 2529 r""" This method indicates if we can call Value() or not.""" 2530 return _pywrapcp.IntVarIterator_Ok(self) 2531 2532 def Value(self): 2533 r""" This method returns the current value of the iterator.""" 2534 return _pywrapcp.IntVarIterator_Value(self) 2535 2536 def Next(self): 2537 r""" This method moves the iterator to the next value.""" 2538 return _pywrapcp.IntVarIterator_Next(self) 2539 2540 def DebugString(self): 2541 r""" Pretty Print.""" 2542 return _pywrapcp.IntVarIterator_DebugString(self) 2543 2544 def __iter__(self): 2545 self.Init() 2546 return self 2547 2548 def next(self): 2549 if self.Ok(): 2550 result = self.Value() 2551 self.Next() 2552 return result 2553 else: 2554 raise StopIteration() 2555 2556 def __next__(self): 2557 return self.next()
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
thisown
2518 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
Init(self):
2524 def Init(self): 2525 r""" This method must be called before each loop.""" 2526 return _pywrapcp.IntVarIterator_Init(self)
This method must be called before each loop.
def
Ok(self):
2528 def Ok(self): 2529 r""" This method indicates if we can call Value() or not.""" 2530 return _pywrapcp.IntVarIterator_Ok(self)
This method indicates if we can call Value() or not.
def
Value(self):
2532 def Value(self): 2533 r""" This method returns the current value of the iterator.""" 2534 return _pywrapcp.IntVarIterator_Value(self)
This method returns the current value of the iterator.
def
Next(self):
2536 def Next(self): 2537 r""" This method moves the iterator to the next value.""" 2538 return _pywrapcp.IntVarIterator_Next(self)
This method moves the iterator to the next value.
2562class IntVar(IntExpr): 2563 r""" 2564 The class IntVar is a subset of IntExpr. In addition to the 2565 IntExpr protocol, it offers persistence, removing values from the domains, 2566 and a finer model for events. 2567 """ 2568 2569 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2570 2571 def __init__(self, *args, **kwargs): 2572 raise AttributeError("No constructor defined - class is abstract") 2573 2574 def IsVar(self): 2575 return _pywrapcp.IntVar_IsVar(self) 2576 2577 def Var(self): 2578 return _pywrapcp.IntVar_Var(self) 2579 2580 def Value(self): 2581 r""" 2582 This method returns the value of the variable. This method checks 2583 before that the variable is bound. 2584 """ 2585 return _pywrapcp.IntVar_Value(self) 2586 2587 def RemoveValue(self, v): 2588 r""" This method removes the value 'v' from the domain of the variable.""" 2589 return _pywrapcp.IntVar_RemoveValue(self, v) 2590 2591 def RemoveInterval(self, l, u): 2592 r""" 2593 This method removes the interval 'l' .. 'u' from the domain of 2594 the variable. It assumes that 'l' <= 'u'. 2595 """ 2596 return _pywrapcp.IntVar_RemoveInterval(self, l, u) 2597 2598 def RemoveValues(self, values): 2599 r""" This method remove the values from the domain of the variable.""" 2600 return _pywrapcp.IntVar_RemoveValues(self, values) 2601 2602 def SetValues(self, values): 2603 r""" This method intersects the current domain with the values in the array.""" 2604 return _pywrapcp.IntVar_SetValues(self, values) 2605 2606 def WhenBound(self, *args): 2607 r""" 2608 *Overload 1:* 2609 This method attaches a demon that will be awakened when the 2610 variable is bound. 2611 2612 | 2613 2614 *Overload 2:* 2615 This method attaches a closure that will be awakened when the 2616 variable is bound. 2617 """ 2618 return _pywrapcp.IntVar_WhenBound(self, *args) 2619 2620 def WhenDomain(self, *args): 2621 r""" 2622 *Overload 1:* 2623 This method attaches a demon that will watch any domain 2624 modification of the domain of the variable. 2625 2626 | 2627 2628 *Overload 2:* 2629 This method attaches a closure that will watch any domain 2630 modification of the domain of the variable. 2631 """ 2632 return _pywrapcp.IntVar_WhenDomain(self, *args) 2633 2634 def Size(self): 2635 r""" This method returns the number of values in the domain of the variable.""" 2636 return _pywrapcp.IntVar_Size(self) 2637 2638 def Contains(self, v): 2639 r""" 2640 This method returns whether the value 'v' is in the domain of the 2641 variable. 2642 """ 2643 return _pywrapcp.IntVar_Contains(self, v) 2644 2645 def HoleIteratorAux(self, reversible): 2646 r""" 2647 Creates a hole iterator. When 'reversible' is false, the returned 2648 object is created on the normal C++ heap and the solver does NOT 2649 take ownership of the object. 2650 """ 2651 return _pywrapcp.IntVar_HoleIteratorAux(self, reversible) 2652 2653 def DomainIteratorAux(self, reversible): 2654 r""" 2655 Creates a domain iterator. When 'reversible' is false, the 2656 returned object is created on the normal C++ heap and the solver 2657 does NOT take ownership of the object. 2658 """ 2659 return _pywrapcp.IntVar_DomainIteratorAux(self, reversible) 2660 2661 def OldMin(self): 2662 r""" Returns the previous min.""" 2663 return _pywrapcp.IntVar_OldMin(self) 2664 2665 def OldMax(self): 2666 r""" Returns the previous max.""" 2667 return _pywrapcp.IntVar_OldMax(self) 2668 2669 def __repr__(self): 2670 return _pywrapcp.IntVar___repr__(self) 2671 2672 def __str__(self): 2673 return _pywrapcp.IntVar___str__(self) 2674 2675 def DomainIterator(self): 2676 return iter(self.DomainIteratorAux(False)) 2677 2678 def HoleIterator(self): 2679 return iter(self.HoleIteratorAux(False))
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
2569 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
Value(self):
2580 def Value(self): 2581 r""" 2582 This method returns the value of the variable. This method checks 2583 before that the variable is bound. 2584 """ 2585 return _pywrapcp.IntVar_Value(self)
This method returns the value of the variable. This method checks before that the variable is bound.
def
RemoveValue(self, v):
2587 def RemoveValue(self, v): 2588 r""" This method removes the value 'v' from the domain of the variable.""" 2589 return _pywrapcp.IntVar_RemoveValue(self, v)
This method removes the value 'v' from the domain of the variable.
def
RemoveInterval(self, l, u):
2591 def RemoveInterval(self, l, u): 2592 r""" 2593 This method removes the interval 'l' .. 'u' from the domain of 2594 the variable. It assumes that 'l' <= 'u'. 2595 """ 2596 return _pywrapcp.IntVar_RemoveInterval(self, l, u)
This method removes the interval 'l' .. 'u' from the domain of the variable. It assumes that 'l' <= 'u'.
def
RemoveValues(self, values):
2598 def RemoveValues(self, values): 2599 r""" This method remove the values from the domain of the variable.""" 2600 return _pywrapcp.IntVar_RemoveValues(self, values)
This method remove the values from the domain of the variable.
def
SetValues(self, values):
2602 def SetValues(self, values): 2603 r""" This method intersects the current domain with the values in the array.""" 2604 return _pywrapcp.IntVar_SetValues(self, values)
This method intersects the current domain with the values in the array.
def
WhenBound(self, *args):
2606 def WhenBound(self, *args): 2607 r""" 2608 *Overload 1:* 2609 This method attaches a demon that will be awakened when the 2610 variable is bound. 2611 2612 | 2613 2614 *Overload 2:* 2615 This method attaches a closure that will be awakened when the 2616 variable is bound. 2617 """ 2618 return _pywrapcp.IntVar_WhenBound(self, *args)
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.
def
WhenDomain(self, *args):
2620 def WhenDomain(self, *args): 2621 r""" 2622 *Overload 1:* 2623 This method attaches a demon that will watch any domain 2624 modification of the domain of the variable. 2625 2626 | 2627 2628 *Overload 2:* 2629 This method attaches a closure that will watch any domain 2630 modification of the domain of the variable. 2631 """ 2632 return _pywrapcp.IntVar_WhenDomain(self, *args)
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.
def
Size(self):
2634 def Size(self): 2635 r""" This method returns the number of values in the domain of the variable.""" 2636 return _pywrapcp.IntVar_Size(self)
This method returns the number of values in the domain of the variable.
def
Contains(self, v):
2638 def Contains(self, v): 2639 r""" 2640 This method returns whether the value 'v' is in the domain of the 2641 variable. 2642 """ 2643 return _pywrapcp.IntVar_Contains(self, v)
This method returns whether the value 'v' is in the domain of the variable.
def
HoleIteratorAux(self, reversible):
2645 def HoleIteratorAux(self, reversible): 2646 r""" 2647 Creates a hole iterator. When 'reversible' is false, the returned 2648 object is created on the normal C++ heap and the solver does NOT 2649 take ownership of the object. 2650 """ 2651 return _pywrapcp.IntVar_HoleIteratorAux(self, reversible)
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.
def
DomainIteratorAux(self, reversible):
2653 def DomainIteratorAux(self, reversible): 2654 r""" 2655 Creates a domain iterator. When 'reversible' is false, the 2656 returned object is created on the normal C++ heap and the solver 2657 does NOT take ownership of the object. 2658 """ 2659 return _pywrapcp.IntVar_DomainIteratorAux(self, reversible)
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.
def
OldMin(self):
2661 def OldMin(self): 2662 r""" Returns the previous min.""" 2663 return _pywrapcp.IntVar_OldMin(self)
Returns the previous min.
def
OldMax(self):
2665 def OldMax(self): 2666 r""" Returns the previous max.""" 2667 return _pywrapcp.IntVar_OldMax(self)
Returns the previous max.
2684class SolutionCollector(SearchMonitor): 2685 r""" 2686 This class is the root class of all solution collectors. 2687 It implements a basic query API to be used independently 2688 of the collector used. 2689 """ 2690 2691 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2692 2693 def __init__(self, *args, **kwargs): 2694 raise AttributeError("No constructor defined") 2695 __repr__ = _swig_repr 2696 2697 def DebugString(self): 2698 return _pywrapcp.SolutionCollector_DebugString(self) 2699 2700 def Add(self, *args): 2701 return _pywrapcp.SolutionCollector_Add(self, *args) 2702 2703 def AddObjective(self, objective): 2704 return _pywrapcp.SolutionCollector_AddObjective(self, objective) 2705 2706 def EnterSearch(self): 2707 r""" Beginning of the search.""" 2708 return _pywrapcp.SolutionCollector_EnterSearch(self) 2709 2710 def SolutionCount(self): 2711 r""" Returns how many solutions were stored during the search.""" 2712 return _pywrapcp.SolutionCollector_SolutionCount(self) 2713 2714 def Solution(self, n): 2715 r""" Returns the nth solution.""" 2716 return _pywrapcp.SolutionCollector_Solution(self, n) 2717 2718 def WallTime(self, n): 2719 r""" Returns the wall time in ms for the nth solution.""" 2720 return _pywrapcp.SolutionCollector_WallTime(self, n) 2721 2722 def Branches(self, n): 2723 r""" Returns the number of branches when the nth solution was found.""" 2724 return _pywrapcp.SolutionCollector_Branches(self, n) 2725 2726 def Failures(self, n): 2727 r""" 2728 Returns the number of failures encountered at the time of the nth 2729 solution. 2730 """ 2731 return _pywrapcp.SolutionCollector_Failures(self, n) 2732 2733 def ObjectiveValue(self, n): 2734 r""" Returns the objective value of the nth solution.""" 2735 return _pywrapcp.SolutionCollector_ObjectiveValue(self, n) 2736 2737 def Value(self, n, var): 2738 r""" This is a shortcut to get the Value of 'var' in the nth solution.""" 2739 return _pywrapcp.SolutionCollector_Value(self, n, var) 2740 2741 def StartValue(self, n, var): 2742 r""" This is a shortcut to get the StartValue of 'var' in the nth solution.""" 2743 return _pywrapcp.SolutionCollector_StartValue(self, n, var) 2744 2745 def EndValue(self, n, var): 2746 r""" This is a shortcut to get the EndValue of 'var' in the nth solution.""" 2747 return _pywrapcp.SolutionCollector_EndValue(self, n, var) 2748 2749 def DurationValue(self, n, var): 2750 r""" This is a shortcut to get the DurationValue of 'var' in the nth solution.""" 2751 return _pywrapcp.SolutionCollector_DurationValue(self, n, var) 2752 2753 def PerformedValue(self, n, var): 2754 r""" This is a shortcut to get the PerformedValue of 'var' in the nth solution.""" 2755 return _pywrapcp.SolutionCollector_PerformedValue(self, n, var) 2756 2757 def ForwardSequence(self, n, var): 2758 r""" 2759 This is a shortcut to get the ForwardSequence of 'var' in the 2760 nth solution. The forward sequence is the list of ranked interval 2761 variables starting from the start of the sequence. 2762 """ 2763 return _pywrapcp.SolutionCollector_ForwardSequence(self, n, var) 2764 2765 def BackwardSequence(self, n, var): 2766 r""" 2767 This is a shortcut to get the BackwardSequence of 'var' in the 2768 nth solution. The backward sequence is the list of ranked interval 2769 variables starting from the end of the sequence. 2770 """ 2771 return _pywrapcp.SolutionCollector_BackwardSequence(self, n, var) 2772 2773 def Unperformed(self, n, var): 2774 r""" 2775 This is a shortcut to get the list of unperformed of 'var' in the 2776 nth solution. 2777 """ 2778 return _pywrapcp.SolutionCollector_Unperformed(self, n, var)
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
2691 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
EnterSearch(self):
2706 def EnterSearch(self): 2707 r""" Beginning of the search.""" 2708 return _pywrapcp.SolutionCollector_EnterSearch(self)
Beginning of the search.
def
SolutionCount(self):
2710 def SolutionCount(self): 2711 r""" Returns how many solutions were stored during the search.""" 2712 return _pywrapcp.SolutionCollector_SolutionCount(self)
Returns how many solutions were stored during the search.
def
Solution(self, n):
2714 def Solution(self, n): 2715 r""" Returns the nth solution.""" 2716 return _pywrapcp.SolutionCollector_Solution(self, n)
Returns the nth solution.
def
WallTime(self, n):
2718 def WallTime(self, n): 2719 r""" Returns the wall time in ms for the nth solution.""" 2720 return _pywrapcp.SolutionCollector_WallTime(self, n)
Returns the wall time in ms for the nth solution.
def
Branches(self, n):
2722 def Branches(self, n): 2723 r""" Returns the number of branches when the nth solution was found.""" 2724 return _pywrapcp.SolutionCollector_Branches(self, n)
Returns the number of branches when the nth solution was found.
def
Failures(self, n):
2726 def Failures(self, n): 2727 r""" 2728 Returns the number of failures encountered at the time of the nth 2729 solution. 2730 """ 2731 return _pywrapcp.SolutionCollector_Failures(self, n)
Returns the number of failures encountered at the time of the nth solution.
def
ObjectiveValue(self, n):
2733 def ObjectiveValue(self, n): 2734 r""" Returns the objective value of the nth solution.""" 2735 return _pywrapcp.SolutionCollector_ObjectiveValue(self, n)
Returns the objective value of the nth solution.
def
Value(self, n, var):
2737 def Value(self, n, var): 2738 r""" This is a shortcut to get the Value of 'var' in the nth solution.""" 2739 return _pywrapcp.SolutionCollector_Value(self, n, var)
This is a shortcut to get the Value of 'var' in the nth solution.
def
StartValue(self, n, var):
2741 def StartValue(self, n, var): 2742 r""" This is a shortcut to get the StartValue of 'var' in the nth solution.""" 2743 return _pywrapcp.SolutionCollector_StartValue(self, n, var)
This is a shortcut to get the StartValue of 'var' in the nth solution.
def
EndValue(self, n, var):
2745 def EndValue(self, n, var): 2746 r""" This is a shortcut to get the EndValue of 'var' in the nth solution.""" 2747 return _pywrapcp.SolutionCollector_EndValue(self, n, var)
This is a shortcut to get the EndValue of 'var' in the nth solution.
def
DurationValue(self, n, var):
2749 def DurationValue(self, n, var): 2750 r""" This is a shortcut to get the DurationValue of 'var' in the nth solution.""" 2751 return _pywrapcp.SolutionCollector_DurationValue(self, n, var)
This is a shortcut to get the DurationValue of 'var' in the nth solution.
def
PerformedValue(self, n, var):
2753 def PerformedValue(self, n, var): 2754 r""" This is a shortcut to get the PerformedValue of 'var' in the nth solution.""" 2755 return _pywrapcp.SolutionCollector_PerformedValue(self, n, var)
This is a shortcut to get the PerformedValue of 'var' in the nth solution.
def
ForwardSequence(self, n, var):
2757 def ForwardSequence(self, n, var): 2758 r""" 2759 This is a shortcut to get the ForwardSequence of 'var' in the 2760 nth solution. The forward sequence is the list of ranked interval 2761 variables starting from the start of the sequence. 2762 """ 2763 return _pywrapcp.SolutionCollector_ForwardSequence(self, n, var)
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.
def
BackwardSequence(self, n, var):
2765 def BackwardSequence(self, n, var): 2766 r""" 2767 This is a shortcut to get the BackwardSequence of 'var' in the 2768 nth solution. The backward sequence is the list of ranked interval 2769 variables starting from the end of the sequence. 2770 """ 2771 return _pywrapcp.SolutionCollector_BackwardSequence(self, n, var)
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.
def
Unperformed(self, n, var):
2773 def Unperformed(self, n, var): 2774 r""" 2775 This is a shortcut to get the list of unperformed of 'var' in the 2776 nth solution. 2777 """ 2778 return _pywrapcp.SolutionCollector_Unperformed(self, n, var)
This is a shortcut to get the list of unperformed of 'var' in the nth solution.
Inherited Members
class
OptimizeVar:
2782class OptimizeVar(object): 2783 r""" 2784 This class encapsulates an objective. It requires the direction 2785 (minimize or maximize), the variable to optimize, and the 2786 improvement step. 2787 """ 2788 2789 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2790 2791 def __init__(self, *args, **kwargs): 2792 raise AttributeError("No constructor defined") 2793 __repr__ = _swig_repr 2794 2795 def Best(self): 2796 r""" Returns the best value found during search.""" 2797 return _pywrapcp.OptimizeVar_Best(self) 2798 2799 def BeginNextDecision(self, db): 2800 r""" Internal methods.""" 2801 return _pywrapcp.OptimizeVar_BeginNextDecision(self, db) 2802 2803 def RefuteDecision(self, d): 2804 return _pywrapcp.OptimizeVar_RefuteDecision(self, d) 2805 2806 def AtSolution(self): 2807 return _pywrapcp.OptimizeVar_AtSolution(self) 2808 2809 def AcceptSolution(self): 2810 return _pywrapcp.OptimizeVar_AcceptSolution(self) 2811 2812 def DebugString(self): 2813 return _pywrapcp.OptimizeVar_DebugString(self) 2814 __swig_destroy__ = _pywrapcp.delete_OptimizeVar
This class encapsulates an objective. It requires the direction (minimize or maximize), the variable to optimize, and the improvement step.
thisown
2789 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
Best(self):
2795 def Best(self): 2796 r""" Returns the best value found during search.""" 2797 return _pywrapcp.OptimizeVar_Best(self)
Returns the best value found during search.
def
BeginNextDecision(self, db):
2799 def BeginNextDecision(self, db): 2800 r""" Internal methods.""" 2801 return _pywrapcp.OptimizeVar_BeginNextDecision(self, db)
Internal methods.
2818class SearchLimit(SearchMonitor): 2819 r""" Base class of all search limits.""" 2820 2821 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2822 2823 def __init__(self, *args, **kwargs): 2824 raise AttributeError("No constructor defined - class is abstract") 2825 __repr__ = _swig_repr 2826 __swig_destroy__ = _pywrapcp.delete_SearchLimit 2827 2828 def Crossed(self): 2829 r""" Returns true if the limit has been crossed.""" 2830 return _pywrapcp.SearchLimit_Crossed(self) 2831 2832 def Check(self): 2833 r""" 2834 This method is called to check the status of the limit. A return 2835 value of true indicates that we have indeed crossed the limit. In 2836 that case, this method will not be called again and the remaining 2837 search will be discarded. 2838 """ 2839 return _pywrapcp.SearchLimit_Check(self) 2840 2841 def Init(self): 2842 r""" This method is called when the search limit is initialized.""" 2843 return _pywrapcp.SearchLimit_Init(self) 2844 2845 def EnterSearch(self): 2846 r""" Internal methods.""" 2847 return _pywrapcp.SearchLimit_EnterSearch(self) 2848 2849 def BeginNextDecision(self, b): 2850 return _pywrapcp.SearchLimit_BeginNextDecision(self, b) 2851 2852 def RefuteDecision(self, d): 2853 return _pywrapcp.SearchLimit_RefuteDecision(self, d) 2854 2855 def DebugString(self): 2856 return _pywrapcp.SearchLimit_DebugString(self)
Base class of all search limits.
thisown
2821 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
Crossed(self):
2828 def Crossed(self): 2829 r""" Returns true if the limit has been crossed.""" 2830 return _pywrapcp.SearchLimit_Crossed(self)
Returns true if the limit has been crossed.
def
Check(self):
2832 def Check(self): 2833 r""" 2834 This method is called to check the status of the limit. A return 2835 value of true indicates that we have indeed crossed the limit. In 2836 that case, this method will not be called again and the remaining 2837 search will be discarded. 2838 """ 2839 return _pywrapcp.SearchLimit_Check(self)
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.
def
Init(self):
2841 def Init(self): 2842 r""" This method is called when the search limit is initialized.""" 2843 return _pywrapcp.SearchLimit_Init(self)
This method is called when the search limit is initialized.
def
EnterSearch(self):
2845 def EnterSearch(self): 2846 r""" Internal methods.""" 2847 return _pywrapcp.SearchLimit_EnterSearch(self)
Internal methods.
2860class IntervalVar(PropagationBaseObject): 2861 r""" 2862 Interval variables are often used in scheduling. The main characteristics 2863 of an IntervalVar are the start position, duration, and end 2864 date. All these characteristics can be queried and set, and demons can 2865 be posted on their modifications. 2866 2867 An important aspect is optionality: an IntervalVar can be performed or not. 2868 If unperformed, then it simply does not exist, and its characteristics 2869 cannot be accessed any more. An interval var is automatically marked 2870 as unperformed when it is not consistent anymore (start greater 2871 than end, duration < 0...) 2872 """ 2873 2874 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2875 2876 def __init__(self, *args, **kwargs): 2877 raise AttributeError("No constructor defined - class is abstract") 2878 2879 def StartMin(self): 2880 r""" 2881 These methods query, set, and watch the start position of the 2882 interval var. 2883 """ 2884 return _pywrapcp.IntervalVar_StartMin(self) 2885 2886 def StartMax(self): 2887 return _pywrapcp.IntervalVar_StartMax(self) 2888 2889 def SetStartMin(self, m): 2890 return _pywrapcp.IntervalVar_SetStartMin(self, m) 2891 2892 def SetStartMax(self, m): 2893 return _pywrapcp.IntervalVar_SetStartMax(self, m) 2894 2895 def SetStartRange(self, mi, ma): 2896 return _pywrapcp.IntervalVar_SetStartRange(self, mi, ma) 2897 2898 def OldStartMin(self): 2899 return _pywrapcp.IntervalVar_OldStartMin(self) 2900 2901 def OldStartMax(self): 2902 return _pywrapcp.IntervalVar_OldStartMax(self) 2903 2904 def WhenStartRange(self, *args): 2905 return _pywrapcp.IntervalVar_WhenStartRange(self, *args) 2906 2907 def WhenStartBound(self, *args): 2908 return _pywrapcp.IntervalVar_WhenStartBound(self, *args) 2909 2910 def DurationMin(self): 2911 r""" These methods query, set, and watch the duration of the interval var.""" 2912 return _pywrapcp.IntervalVar_DurationMin(self) 2913 2914 def DurationMax(self): 2915 return _pywrapcp.IntervalVar_DurationMax(self) 2916 2917 def SetDurationMin(self, m): 2918 return _pywrapcp.IntervalVar_SetDurationMin(self, m) 2919 2920 def SetDurationMax(self, m): 2921 return _pywrapcp.IntervalVar_SetDurationMax(self, m) 2922 2923 def SetDurationRange(self, mi, ma): 2924 return _pywrapcp.IntervalVar_SetDurationRange(self, mi, ma) 2925 2926 def OldDurationMin(self): 2927 return _pywrapcp.IntervalVar_OldDurationMin(self) 2928 2929 def OldDurationMax(self): 2930 return _pywrapcp.IntervalVar_OldDurationMax(self) 2931 2932 def WhenDurationRange(self, *args): 2933 return _pywrapcp.IntervalVar_WhenDurationRange(self, *args) 2934 2935 def WhenDurationBound(self, *args): 2936 return _pywrapcp.IntervalVar_WhenDurationBound(self, *args) 2937 2938 def EndMin(self): 2939 r""" These methods query, set, and watch the end position of the interval var.""" 2940 return _pywrapcp.IntervalVar_EndMin(self) 2941 2942 def EndMax(self): 2943 return _pywrapcp.IntervalVar_EndMax(self) 2944 2945 def SetEndMin(self, m): 2946 return _pywrapcp.IntervalVar_SetEndMin(self, m) 2947 2948 def SetEndMax(self, m): 2949 return _pywrapcp.IntervalVar_SetEndMax(self, m) 2950 2951 def SetEndRange(self, mi, ma): 2952 return _pywrapcp.IntervalVar_SetEndRange(self, mi, ma) 2953 2954 def OldEndMin(self): 2955 return _pywrapcp.IntervalVar_OldEndMin(self) 2956 2957 def OldEndMax(self): 2958 return _pywrapcp.IntervalVar_OldEndMax(self) 2959 2960 def WhenEndRange(self, *args): 2961 return _pywrapcp.IntervalVar_WhenEndRange(self, *args) 2962 2963 def WhenEndBound(self, *args): 2964 return _pywrapcp.IntervalVar_WhenEndBound(self, *args) 2965 2966 def MustBePerformed(self): 2967 r""" 2968 These methods query, set, and watch the performed status of the 2969 interval var. 2970 """ 2971 return _pywrapcp.IntervalVar_MustBePerformed(self) 2972 2973 def MayBePerformed(self): 2974 return _pywrapcp.IntervalVar_MayBePerformed(self) 2975 2976 def CannotBePerformed(self): 2977 return _pywrapcp.IntervalVar_CannotBePerformed(self) 2978 2979 def IsPerformedBound(self): 2980 return _pywrapcp.IntervalVar_IsPerformedBound(self) 2981 2982 def SetPerformed(self, val): 2983 return _pywrapcp.IntervalVar_SetPerformed(self, val) 2984 2985 def WasPerformedBound(self): 2986 return _pywrapcp.IntervalVar_WasPerformedBound(self) 2987 2988 def WhenPerformedBound(self, *args): 2989 return _pywrapcp.IntervalVar_WhenPerformedBound(self, *args) 2990 2991 def WhenAnything(self, *args): 2992 r""" 2993 *Overload 1:* 2994 Attaches a demon awakened when anything about this interval changes. 2995 2996 | 2997 2998 *Overload 2:* 2999 Attaches a closure awakened when anything about this interval changes. 3000 """ 3001 return _pywrapcp.IntervalVar_WhenAnything(self, *args) 3002 3003 def StartExpr(self): 3004 r""" 3005 These methods create expressions encapsulating the start, end 3006 and duration of the interval var. Please note that these must not 3007 be used if the interval var is unperformed. 3008 """ 3009 return _pywrapcp.IntervalVar_StartExpr(self) 3010 3011 def DurationExpr(self): 3012 return _pywrapcp.IntervalVar_DurationExpr(self) 3013 3014 def EndExpr(self): 3015 return _pywrapcp.IntervalVar_EndExpr(self) 3016 3017 def PerformedExpr(self): 3018 return _pywrapcp.IntervalVar_PerformedExpr(self) 3019 3020 def SafeStartExpr(self, unperformed_value): 3021 r""" 3022 These methods create expressions encapsulating the start, end 3023 and duration of the interval var. If the interval var is 3024 unperformed, they will return the unperformed_value. 3025 """ 3026 return _pywrapcp.IntervalVar_SafeStartExpr(self, unperformed_value) 3027 3028 def SafeDurationExpr(self, unperformed_value): 3029 return _pywrapcp.IntervalVar_SafeDurationExpr(self, unperformed_value) 3030 3031 def SafeEndExpr(self, unperformed_value): 3032 return _pywrapcp.IntervalVar_SafeEndExpr(self, unperformed_value) 3033 3034 def EndsAfterEnd(self, other): 3035 return _pywrapcp.IntervalVar_EndsAfterEnd(self, other) 3036 3037 def EndsAfterEndWithDelay(self, other, delay): 3038 return _pywrapcp.IntervalVar_EndsAfterEndWithDelay(self, other, delay) 3039 3040 def EndsAfterStart(self, other): 3041 return _pywrapcp.IntervalVar_EndsAfterStart(self, other) 3042 3043 def EndsAfterStartWithDelay(self, other, delay): 3044 return _pywrapcp.IntervalVar_EndsAfterStartWithDelay(self, other, delay) 3045 3046 def EndsAtEnd(self, other): 3047 return _pywrapcp.IntervalVar_EndsAtEnd(self, other) 3048 3049 def EndsAtEndWithDelay(self, other, delay): 3050 return _pywrapcp.IntervalVar_EndsAtEndWithDelay(self, other, delay) 3051 3052 def EndsAtStart(self, other): 3053 return _pywrapcp.IntervalVar_EndsAtStart(self, other) 3054 3055 def EndsAtStartWithDelay(self, other, delay): 3056 return _pywrapcp.IntervalVar_EndsAtStartWithDelay(self, other, delay) 3057 3058 def StartsAfterEnd(self, other): 3059 return _pywrapcp.IntervalVar_StartsAfterEnd(self, other) 3060 3061 def StartsAfterEndWithDelay(self, other, delay): 3062 return _pywrapcp.IntervalVar_StartsAfterEndWithDelay(self, other, delay) 3063 3064 def StartsAfterStart(self, other): 3065 return _pywrapcp.IntervalVar_StartsAfterStart(self, other) 3066 3067 def StartsAfterStartWithDelay(self, other, delay): 3068 return _pywrapcp.IntervalVar_StartsAfterStartWithDelay(self, other, delay) 3069 3070 def StartsAtEnd(self, other): 3071 return _pywrapcp.IntervalVar_StartsAtEnd(self, other) 3072 3073 def StartsAtEndWithDelay(self, other, delay): 3074 return _pywrapcp.IntervalVar_StartsAtEndWithDelay(self, other, delay) 3075 3076 def StartsAtStart(self, other): 3077 return _pywrapcp.IntervalVar_StartsAtStart(self, other) 3078 3079 def StartsAtStartWithDelay(self, other, delay): 3080 return _pywrapcp.IntervalVar_StartsAtStartWithDelay(self, other, delay) 3081 3082 def StaysInSync(self, other): 3083 return _pywrapcp.IntervalVar_StaysInSync(self, other) 3084 3085 def StaysInSyncWithDelay(self, other, delay): 3086 return _pywrapcp.IntervalVar_StaysInSyncWithDelay(self, other, delay) 3087 3088 def EndsAfter(self, date): 3089 return _pywrapcp.IntervalVar_EndsAfter(self, date) 3090 3091 def EndsAt(self, date): 3092 return _pywrapcp.IntervalVar_EndsAt(self, date) 3093 3094 def EndsBefore(self, date): 3095 return _pywrapcp.IntervalVar_EndsBefore(self, date) 3096 3097 def StartsAfter(self, date): 3098 return _pywrapcp.IntervalVar_StartsAfter(self, date) 3099 3100 def StartsAt(self, date): 3101 return _pywrapcp.IntervalVar_StartsAt(self, date) 3102 3103 def StartsBefore(self, date): 3104 return _pywrapcp.IntervalVar_StartsBefore(self, date) 3105 3106 def CrossesDate(self, date): 3107 return _pywrapcp.IntervalVar_CrossesDate(self, date) 3108 3109 def AvoidsDate(self, date): 3110 return _pywrapcp.IntervalVar_AvoidsDate(self, date) 3111 3112 def __repr__(self): 3113 return _pywrapcp.IntervalVar___repr__(self) 3114 3115 def __str__(self): 3116 return _pywrapcp.IntervalVar___str__(self)
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
2874 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
StartMin(self):
2879 def StartMin(self): 2880 r""" 2881 These methods query, set, and watch the start position of the 2882 interval var. 2883 """ 2884 return _pywrapcp.IntervalVar_StartMin(self)
These methods query, set, and watch the start position of the interval var.
def
DurationMin(self):
2910 def DurationMin(self): 2911 r""" These methods query, set, and watch the duration of the interval var.""" 2912 return _pywrapcp.IntervalVar_DurationMin(self)
These methods query, set, and watch the duration of the interval var.
def
EndMin(self):
2938 def EndMin(self): 2939 r""" These methods query, set, and watch the end position of the interval var.""" 2940 return _pywrapcp.IntervalVar_EndMin(self)
These methods query, set, and watch the end position of the interval var.
def
MustBePerformed(self):
2966 def MustBePerformed(self): 2967 r""" 2968 These methods query, set, and watch the performed status of the 2969 interval var. 2970 """ 2971 return _pywrapcp.IntervalVar_MustBePerformed(self)
These methods query, set, and watch the performed status of the interval var.
def
WhenAnything(self, *args):
2991 def WhenAnything(self, *args): 2992 r""" 2993 *Overload 1:* 2994 Attaches a demon awakened when anything about this interval changes. 2995 2996 | 2997 2998 *Overload 2:* 2999 Attaches a closure awakened when anything about this interval changes. 3000 """ 3001 return _pywrapcp.IntervalVar_WhenAnything(self, *args)
Overload 1: Attaches a demon awakened when anything about this interval changes.
|
Overload 2: Attaches a closure awakened when anything about this interval changes.
def
StartExpr(self):
3003 def StartExpr(self): 3004 r""" 3005 These methods create expressions encapsulating the start, end 3006 and duration of the interval var. Please note that these must not 3007 be used if the interval var is unperformed. 3008 """ 3009 return _pywrapcp.IntervalVar_StartExpr(self)
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.
def
SafeStartExpr(self, unperformed_value):
3020 def SafeStartExpr(self, unperformed_value): 3021 r""" 3022 These methods create expressions encapsulating the start, end 3023 and duration of the interval var. If the interval var is 3024 unperformed, they will return the unperformed_value. 3025 """ 3026 return _pywrapcp.IntervalVar_SafeStartExpr(self, unperformed_value)
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.
Inherited Members
3120class SequenceVar(PropagationBaseObject): 3121 r""" 3122 A sequence variable is a variable whose domain is a set of possible 3123 orderings of the interval variables. It allows ordering of tasks. It 3124 has two sets of methods: ComputePossibleFirstsAndLasts(), which 3125 returns the list of interval variables that can be ranked first or 3126 last; and RankFirst/RankNotFirst/RankLast/RankNotLast, which can be 3127 used to create the search decision. 3128 """ 3129 3130 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3131 3132 def __init__(self, *args, **kwargs): 3133 raise AttributeError("No constructor defined") 3134 3135 def DebugString(self): 3136 return _pywrapcp.SequenceVar_DebugString(self) 3137 3138 def RankFirst(self, index): 3139 r""" 3140 Ranks the index_th interval var first of all unranked interval 3141 vars. After that, it will no longer be considered ranked. 3142 """ 3143 return _pywrapcp.SequenceVar_RankFirst(self, index) 3144 3145 def RankNotFirst(self, index): 3146 r""" 3147 Indicates that the index_th interval var will not be ranked first 3148 of all currently unranked interval vars. 3149 """ 3150 return _pywrapcp.SequenceVar_RankNotFirst(self, index) 3151 3152 def RankLast(self, index): 3153 r""" 3154 Ranks the index_th interval var first of all unranked interval 3155 vars. After that, it will no longer be considered ranked. 3156 """ 3157 return _pywrapcp.SequenceVar_RankLast(self, index) 3158 3159 def RankNotLast(self, index): 3160 r""" 3161 Indicates that the index_th interval var will not be ranked first 3162 of all currently unranked interval vars. 3163 """ 3164 return _pywrapcp.SequenceVar_RankNotLast(self, index) 3165 3166 def Interval(self, index): 3167 r""" Returns the index_th interval of the sequence.""" 3168 return _pywrapcp.SequenceVar_Interval(self, index) 3169 3170 def Next(self, index): 3171 r""" Returns the next of the index_th interval of the sequence.""" 3172 return _pywrapcp.SequenceVar_Next(self, index) 3173 3174 def Size(self): 3175 r""" Returns the number of interval vars in the sequence.""" 3176 return _pywrapcp.SequenceVar_Size(self) 3177 3178 def __repr__(self): 3179 return _pywrapcp.SequenceVar___repr__(self) 3180 3181 def __str__(self): 3182 return _pywrapcp.SequenceVar___str__(self)
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
3130 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
RankFirst(self, index):
3138 def RankFirst(self, index): 3139 r""" 3140 Ranks the index_th interval var first of all unranked interval 3141 vars. After that, it will no longer be considered ranked. 3142 """ 3143 return _pywrapcp.SequenceVar_RankFirst(self, index)
Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked.
def
RankNotFirst(self, index):
3145 def RankNotFirst(self, index): 3146 r""" 3147 Indicates that the index_th interval var will not be ranked first 3148 of all currently unranked interval vars. 3149 """ 3150 return _pywrapcp.SequenceVar_RankNotFirst(self, index)
Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars.
def
RankLast(self, index):
3152 def RankLast(self, index): 3153 r""" 3154 Ranks the index_th interval var first of all unranked interval 3155 vars. After that, it will no longer be considered ranked. 3156 """ 3157 return _pywrapcp.SequenceVar_RankLast(self, index)
Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked.
def
RankNotLast(self, index):
3159 def RankNotLast(self, index): 3160 r""" 3161 Indicates that the index_th interval var will not be ranked first 3162 of all currently unranked interval vars. 3163 """ 3164 return _pywrapcp.SequenceVar_RankNotLast(self, index)
Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars.
def
Interval(self, index):
3166 def Interval(self, index): 3167 r""" Returns the index_th interval of the sequence.""" 3168 return _pywrapcp.SequenceVar_Interval(self, index)
Returns the index_th interval of the sequence.
def
Next(self, index):
3170 def Next(self, index): 3171 r""" Returns the next of the index_th interval of the sequence.""" 3172 return _pywrapcp.SequenceVar_Next(self, index)
Returns the next of the index_th interval of the sequence.
def
Size(self):
3174 def Size(self): 3175 r""" Returns the number of interval vars in the sequence.""" 3176 return _pywrapcp.SequenceVar_Size(self)
Returns the number of interval vars in the sequence.
Inherited Members
class
AssignmentElement:
3186class AssignmentElement(object): 3187 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3188 3189 def __init__(self, *args, **kwargs): 3190 raise AttributeError("No constructor defined") 3191 __repr__ = _swig_repr 3192 3193 def Activate(self): 3194 return _pywrapcp.AssignmentElement_Activate(self) 3195 3196 def Deactivate(self): 3197 return _pywrapcp.AssignmentElement_Deactivate(self) 3198 3199 def Activated(self): 3200 return _pywrapcp.AssignmentElement_Activated(self) 3201 __swig_destroy__ = _pywrapcp.delete_AssignmentElement
thisown
3187 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
3205class IntVarElement(AssignmentElement): 3206 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3207 3208 def __init__(self, *args, **kwargs): 3209 raise AttributeError("No constructor defined") 3210 __repr__ = _swig_repr 3211 3212 def Var(self): 3213 return _pywrapcp.IntVarElement_Var(self) 3214 3215 def Min(self): 3216 return _pywrapcp.IntVarElement_Min(self) 3217 3218 def SetMin(self, m): 3219 return _pywrapcp.IntVarElement_SetMin(self, m) 3220 3221 def Max(self): 3222 return _pywrapcp.IntVarElement_Max(self) 3223 3224 def SetMax(self, m): 3225 return _pywrapcp.IntVarElement_SetMax(self, m) 3226 3227 def Value(self): 3228 return _pywrapcp.IntVarElement_Value(self) 3229 3230 def Bound(self): 3231 return _pywrapcp.IntVarElement_Bound(self) 3232 3233 def SetRange(self, l, u): 3234 return _pywrapcp.IntVarElement_SetRange(self, l, u) 3235 3236 def SetValue(self, v): 3237 return _pywrapcp.IntVarElement_SetValue(self, v) 3238 3239 def __eq__(self, element): 3240 return _pywrapcp.IntVarElement___eq__(self, element) 3241 3242 def __ne__(self, element): 3243 return _pywrapcp.IntVarElement___ne__(self, element) 3244 __swig_destroy__ = _pywrapcp.delete_IntVarElement
thisown
3206 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
Inherited Members
3248class IntervalVarElement(AssignmentElement): 3249 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3250 3251 def __init__(self, *args, **kwargs): 3252 raise AttributeError("No constructor defined") 3253 __repr__ = _swig_repr 3254 3255 def Var(self): 3256 return _pywrapcp.IntervalVarElement_Var(self) 3257 3258 def StartMin(self): 3259 return _pywrapcp.IntervalVarElement_StartMin(self) 3260 3261 def StartMax(self): 3262 return _pywrapcp.IntervalVarElement_StartMax(self) 3263 3264 def StartValue(self): 3265 return _pywrapcp.IntervalVarElement_StartValue(self) 3266 3267 def DurationMin(self): 3268 return _pywrapcp.IntervalVarElement_DurationMin(self) 3269 3270 def DurationMax(self): 3271 return _pywrapcp.IntervalVarElement_DurationMax(self) 3272 3273 def DurationValue(self): 3274 return _pywrapcp.IntervalVarElement_DurationValue(self) 3275 3276 def EndMin(self): 3277 return _pywrapcp.IntervalVarElement_EndMin(self) 3278 3279 def EndMax(self): 3280 return _pywrapcp.IntervalVarElement_EndMax(self) 3281 3282 def EndValue(self): 3283 return _pywrapcp.IntervalVarElement_EndValue(self) 3284 3285 def PerformedMin(self): 3286 return _pywrapcp.IntervalVarElement_PerformedMin(self) 3287 3288 def PerformedMax(self): 3289 return _pywrapcp.IntervalVarElement_PerformedMax(self) 3290 3291 def PerformedValue(self): 3292 return _pywrapcp.IntervalVarElement_PerformedValue(self) 3293 3294 def SetStartMin(self, m): 3295 return _pywrapcp.IntervalVarElement_SetStartMin(self, m) 3296 3297 def SetStartMax(self, m): 3298 return _pywrapcp.IntervalVarElement_SetStartMax(self, m) 3299 3300 def SetStartRange(self, mi, ma): 3301 return _pywrapcp.IntervalVarElement_SetStartRange(self, mi, ma) 3302 3303 def SetStartValue(self, v): 3304 return _pywrapcp.IntervalVarElement_SetStartValue(self, v) 3305 3306 def SetDurationMin(self, m): 3307 return _pywrapcp.IntervalVarElement_SetDurationMin(self, m) 3308 3309 def SetDurationMax(self, m): 3310 return _pywrapcp.IntervalVarElement_SetDurationMax(self, m) 3311 3312 def SetDurationRange(self, mi, ma): 3313 return _pywrapcp.IntervalVarElement_SetDurationRange(self, mi, ma) 3314 3315 def SetDurationValue(self, v): 3316 return _pywrapcp.IntervalVarElement_SetDurationValue(self, v) 3317 3318 def SetEndMin(self, m): 3319 return _pywrapcp.IntervalVarElement_SetEndMin(self, m) 3320 3321 def SetEndMax(self, m): 3322 return _pywrapcp.IntervalVarElement_SetEndMax(self, m) 3323 3324 def SetEndRange(self, mi, ma): 3325 return _pywrapcp.IntervalVarElement_SetEndRange(self, mi, ma) 3326 3327 def SetEndValue(self, v): 3328 return _pywrapcp.IntervalVarElement_SetEndValue(self, v) 3329 3330 def SetPerformedMin(self, m): 3331 return _pywrapcp.IntervalVarElement_SetPerformedMin(self, m) 3332 3333 def SetPerformedMax(self, m): 3334 return _pywrapcp.IntervalVarElement_SetPerformedMax(self, m) 3335 3336 def SetPerformedRange(self, mi, ma): 3337 return _pywrapcp.IntervalVarElement_SetPerformedRange(self, mi, ma) 3338 3339 def SetPerformedValue(self, v): 3340 return _pywrapcp.IntervalVarElement_SetPerformedValue(self, v) 3341 3342 def __eq__(self, element): 3343 return _pywrapcp.IntervalVarElement___eq__(self, element) 3344 3345 def __ne__(self, element): 3346 return _pywrapcp.IntervalVarElement___ne__(self, element) 3347 __swig_destroy__ = _pywrapcp.delete_IntervalVarElement
thisown
3249 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
Inherited Members
3351class SequenceVarElement(AssignmentElement): 3352 r""" 3353 The SequenceVarElement stores a partial representation of ranked 3354 interval variables in the underlying sequence variable. 3355 This representation consists of three vectors: 3356 - the forward sequence. That is the list of interval variables 3357 ranked first in the sequence. The first element of the backward 3358 sequence is the first interval in the sequence variable. 3359 - the backward sequence. That is the list of interval variables 3360 ranked last in the sequence. The first element of the backward 3361 sequence is the last interval in the sequence variable. 3362 - The list of unperformed interval variables. 3363 Furthermore, if all performed variables are ranked, then by 3364 convention, the forward_sequence will contain all such variables 3365 and the backward_sequence will be empty. 3366 """ 3367 3368 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3369 3370 def __init__(self, *args, **kwargs): 3371 raise AttributeError("No constructor defined") 3372 __repr__ = _swig_repr 3373 3374 def Var(self): 3375 return _pywrapcp.SequenceVarElement_Var(self) 3376 3377 def ForwardSequence(self): 3378 return _pywrapcp.SequenceVarElement_ForwardSequence(self) 3379 3380 def BackwardSequence(self): 3381 return _pywrapcp.SequenceVarElement_BackwardSequence(self) 3382 3383 def Unperformed(self): 3384 return _pywrapcp.SequenceVarElement_Unperformed(self) 3385 3386 def SetSequence(self, forward_sequence, backward_sequence, unperformed): 3387 return _pywrapcp.SequenceVarElement_SetSequence(self, forward_sequence, backward_sequence, unperformed) 3388 3389 def SetForwardSequence(self, forward_sequence): 3390 return _pywrapcp.SequenceVarElement_SetForwardSequence(self, forward_sequence) 3391 3392 def SetBackwardSequence(self, backward_sequence): 3393 return _pywrapcp.SequenceVarElement_SetBackwardSequence(self, backward_sequence) 3394 3395 def SetUnperformed(self, unperformed): 3396 return _pywrapcp.SequenceVarElement_SetUnperformed(self, unperformed) 3397 3398 def __eq__(self, element): 3399 return _pywrapcp.SequenceVarElement___eq__(self, element) 3400 3401 def __ne__(self, element): 3402 return _pywrapcp.SequenceVarElement___ne__(self, element) 3403 __swig_destroy__ = _pywrapcp.delete_SequenceVarElement
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
3368 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
Inherited Members
3407class Assignment(PropagationBaseObject): 3408 r""" 3409 An Assignment is a variable -> domains mapping, used 3410 to report solutions to the user. 3411 """ 3412 3413 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3414 3415 def __init__(self, *args, **kwargs): 3416 raise AttributeError("No constructor defined") 3417 __repr__ = _swig_repr 3418 3419 def Clear(self): 3420 return _pywrapcp.Assignment_Clear(self) 3421 3422 def Empty(self): 3423 return _pywrapcp.Assignment_Empty(self) 3424 3425 def Size(self): 3426 return _pywrapcp.Assignment_Size(self) 3427 3428 def NumIntVars(self): 3429 return _pywrapcp.Assignment_NumIntVars(self) 3430 3431 def NumIntervalVars(self): 3432 return _pywrapcp.Assignment_NumIntervalVars(self) 3433 3434 def NumSequenceVars(self): 3435 return _pywrapcp.Assignment_NumSequenceVars(self) 3436 3437 def Store(self): 3438 return _pywrapcp.Assignment_Store(self) 3439 3440 def Restore(self): 3441 return _pywrapcp.Assignment_Restore(self) 3442 3443 def Load(self, *args): 3444 return _pywrapcp.Assignment_Load(self, *args) 3445 3446 def Save(self, *args): 3447 return _pywrapcp.Assignment_Save(self, *args) 3448 3449 def AddObjective(self, v): 3450 return _pywrapcp.Assignment_AddObjective(self, v) 3451 3452 def Objective(self): 3453 return _pywrapcp.Assignment_Objective(self) 3454 3455 def HasObjective(self): 3456 return _pywrapcp.Assignment_HasObjective(self) 3457 3458 def ObjectiveMin(self): 3459 return _pywrapcp.Assignment_ObjectiveMin(self) 3460 3461 def ObjectiveMax(self): 3462 return _pywrapcp.Assignment_ObjectiveMax(self) 3463 3464 def ObjectiveValue(self): 3465 return _pywrapcp.Assignment_ObjectiveValue(self) 3466 3467 def ObjectiveBound(self): 3468 return _pywrapcp.Assignment_ObjectiveBound(self) 3469 3470 def SetObjectiveMin(self, m): 3471 return _pywrapcp.Assignment_SetObjectiveMin(self, m) 3472 3473 def SetObjectiveMax(self, m): 3474 return _pywrapcp.Assignment_SetObjectiveMax(self, m) 3475 3476 def SetObjectiveValue(self, value): 3477 return _pywrapcp.Assignment_SetObjectiveValue(self, value) 3478 3479 def SetObjectiveRange(self, l, u): 3480 return _pywrapcp.Assignment_SetObjectiveRange(self, l, u) 3481 3482 def Min(self, var): 3483 return _pywrapcp.Assignment_Min(self, var) 3484 3485 def Max(self, var): 3486 return _pywrapcp.Assignment_Max(self, var) 3487 3488 def Value(self, var): 3489 return _pywrapcp.Assignment_Value(self, var) 3490 3491 def Bound(self, var): 3492 return _pywrapcp.Assignment_Bound(self, var) 3493 3494 def SetMin(self, var, m): 3495 return _pywrapcp.Assignment_SetMin(self, var, m) 3496 3497 def SetMax(self, var, m): 3498 return _pywrapcp.Assignment_SetMax(self, var, m) 3499 3500 def SetRange(self, var, l, u): 3501 return _pywrapcp.Assignment_SetRange(self, var, l, u) 3502 3503 def SetValue(self, var, value): 3504 return _pywrapcp.Assignment_SetValue(self, var, value) 3505 3506 def StartMin(self, var): 3507 return _pywrapcp.Assignment_StartMin(self, var) 3508 3509 def StartMax(self, var): 3510 return _pywrapcp.Assignment_StartMax(self, var) 3511 3512 def StartValue(self, var): 3513 return _pywrapcp.Assignment_StartValue(self, var) 3514 3515 def DurationMin(self, var): 3516 return _pywrapcp.Assignment_DurationMin(self, var) 3517 3518 def DurationMax(self, var): 3519 return _pywrapcp.Assignment_DurationMax(self, var) 3520 3521 def DurationValue(self, var): 3522 return _pywrapcp.Assignment_DurationValue(self, var) 3523 3524 def EndMin(self, var): 3525 return _pywrapcp.Assignment_EndMin(self, var) 3526 3527 def EndMax(self, var): 3528 return _pywrapcp.Assignment_EndMax(self, var) 3529 3530 def EndValue(self, var): 3531 return _pywrapcp.Assignment_EndValue(self, var) 3532 3533 def PerformedMin(self, var): 3534 return _pywrapcp.Assignment_PerformedMin(self, var) 3535 3536 def PerformedMax(self, var): 3537 return _pywrapcp.Assignment_PerformedMax(self, var) 3538 3539 def PerformedValue(self, var): 3540 return _pywrapcp.Assignment_PerformedValue(self, var) 3541 3542 def SetStartMin(self, var, m): 3543 return _pywrapcp.Assignment_SetStartMin(self, var, m) 3544 3545 def SetStartMax(self, var, m): 3546 return _pywrapcp.Assignment_SetStartMax(self, var, m) 3547 3548 def SetStartRange(self, var, mi, ma): 3549 return _pywrapcp.Assignment_SetStartRange(self, var, mi, ma) 3550 3551 def SetStartValue(self, var, value): 3552 return _pywrapcp.Assignment_SetStartValue(self, var, value) 3553 3554 def SetDurationMin(self, var, m): 3555 return _pywrapcp.Assignment_SetDurationMin(self, var, m) 3556 3557 def SetDurationMax(self, var, m): 3558 return _pywrapcp.Assignment_SetDurationMax(self, var, m) 3559 3560 def SetDurationRange(self, var, mi, ma): 3561 return _pywrapcp.Assignment_SetDurationRange(self, var, mi, ma) 3562 3563 def SetDurationValue(self, var, value): 3564 return _pywrapcp.Assignment_SetDurationValue(self, var, value) 3565 3566 def SetEndMin(self, var, m): 3567 return _pywrapcp.Assignment_SetEndMin(self, var, m) 3568 3569 def SetEndMax(self, var, m): 3570 return _pywrapcp.Assignment_SetEndMax(self, var, m) 3571 3572 def SetEndRange(self, var, mi, ma): 3573 return _pywrapcp.Assignment_SetEndRange(self, var, mi, ma) 3574 3575 def SetEndValue(self, var, value): 3576 return _pywrapcp.Assignment_SetEndValue(self, var, value) 3577 3578 def SetPerformedMin(self, var, m): 3579 return _pywrapcp.Assignment_SetPerformedMin(self, var, m) 3580 3581 def SetPerformedMax(self, var, m): 3582 return _pywrapcp.Assignment_SetPerformedMax(self, var, m) 3583 3584 def SetPerformedRange(self, var, mi, ma): 3585 return _pywrapcp.Assignment_SetPerformedRange(self, var, mi, ma) 3586 3587 def SetPerformedValue(self, var, value): 3588 return _pywrapcp.Assignment_SetPerformedValue(self, var, value) 3589 3590 def Add(self, *args): 3591 return _pywrapcp.Assignment_Add(self, *args) 3592 3593 def ForwardSequence(self, var): 3594 return _pywrapcp.Assignment_ForwardSequence(self, var) 3595 3596 def BackwardSequence(self, var): 3597 return _pywrapcp.Assignment_BackwardSequence(self, var) 3598 3599 def Unperformed(self, var): 3600 return _pywrapcp.Assignment_Unperformed(self, var) 3601 3602 def SetSequence(self, var, forward_sequence, backward_sequence, unperformed): 3603 return _pywrapcp.Assignment_SetSequence(self, var, forward_sequence, backward_sequence, unperformed) 3604 3605 def SetForwardSequence(self, var, forward_sequence): 3606 return _pywrapcp.Assignment_SetForwardSequence(self, var, forward_sequence) 3607 3608 def SetBackwardSequence(self, var, backward_sequence): 3609 return _pywrapcp.Assignment_SetBackwardSequence(self, var, backward_sequence) 3610 3611 def SetUnperformed(self, var, unperformed): 3612 return _pywrapcp.Assignment_SetUnperformed(self, var, unperformed) 3613 3614 def Activate(self, *args): 3615 return _pywrapcp.Assignment_Activate(self, *args) 3616 3617 def Deactivate(self, *args): 3618 return _pywrapcp.Assignment_Deactivate(self, *args) 3619 3620 def Activated(self, *args): 3621 return _pywrapcp.Assignment_Activated(self, *args) 3622 3623 def DebugString(self): 3624 return _pywrapcp.Assignment_DebugString(self) 3625 3626 def IntVarContainer(self): 3627 return _pywrapcp.Assignment_IntVarContainer(self) 3628 3629 def MutableIntVarContainer(self): 3630 return _pywrapcp.Assignment_MutableIntVarContainer(self) 3631 3632 def IntervalVarContainer(self): 3633 return _pywrapcp.Assignment_IntervalVarContainer(self) 3634 3635 def MutableIntervalVarContainer(self): 3636 return _pywrapcp.Assignment_MutableIntervalVarContainer(self) 3637 3638 def SequenceVarContainer(self): 3639 return _pywrapcp.Assignment_SequenceVarContainer(self) 3640 3641 def MutableSequenceVarContainer(self): 3642 return _pywrapcp.Assignment_MutableSequenceVarContainer(self) 3643 3644 def __eq__(self, assignment): 3645 return _pywrapcp.Assignment___eq__(self, assignment) 3646 3647 def __ne__(self, assignment): 3648 return _pywrapcp.Assignment___ne__(self, assignment)
An Assignment is a variable -> domains mapping, used to report solutions to the user.
thisown
3413 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
Inherited Members
3655class Pack(Constraint): 3656 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3657 3658 def __init__(self, *args, **kwargs): 3659 raise AttributeError("No constructor defined") 3660 __repr__ = _swig_repr 3661 3662 def AddWeightedSumLessOrEqualConstantDimension(self, *args): 3663 r""" 3664 *Overload 1:* 3665 Dimensions are additional constraints than can restrict what is 3666 possible with the pack constraint. It can be used to set capacity 3667 limits, to count objects per bin, to compute unassigned 3668 penalties... 3669 This dimension imposes that for all bins b, the weighted sum 3670 (weights[i]) of all objects i assigned to 'b' is less or equal 3671 'bounds[b]'. 3672 3673 | 3674 3675 *Overload 2:* 3676 This dimension imposes that for all bins b, the weighted sum 3677 (weights->Run(i)) of all objects i assigned to 'b' is less or 3678 equal to 'bounds[b]'. Ownership of the callback is transferred to 3679 the pack constraint. 3680 3681 | 3682 3683 *Overload 3:* 3684 This dimension imposes that for all bins b, the weighted sum 3685 (weights->Run(i, b) of all objects i assigned to 'b' is less or 3686 equal to 'bounds[b]'. Ownership of the callback is transferred to 3687 the pack constraint. 3688 """ 3689 return _pywrapcp.Pack_AddWeightedSumLessOrEqualConstantDimension(self, *args) 3690 3691 def AddWeightedSumEqualVarDimension(self, *args): 3692 r""" 3693 *Overload 1:* 3694 This dimension imposes that for all bins b, the weighted sum 3695 (weights[i]) of all objects i assigned to 'b' is equal to loads[b]. 3696 3697 | 3698 3699 *Overload 2:* 3700 This dimension imposes that for all bins b, the weighted sum 3701 (weights->Run(i, b)) of all objects i assigned to 'b' is equal to 3702 loads[b]. 3703 """ 3704 return _pywrapcp.Pack_AddWeightedSumEqualVarDimension(self, *args) 3705 3706 def AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity): 3707 r""" 3708 This dimension imposes: 3709 forall b in bins, 3710 sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b] 3711 where is_assigned(i, b) is true if and only if item i is assigned 3712 to the bin b. 3713 3714 This can be used to model shapes of items by linking variables of 3715 the same item on parallel dimensions with an allowed assignment 3716 constraint. 3717 """ 3718 return _pywrapcp.Pack_AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity) 3719 3720 def AddWeightedSumOfAssignedDimension(self, weights, cost_var): 3721 r""" 3722 This dimension enforces that cost_var == sum of weights[i] for 3723 all objects 'i' assigned to a bin. 3724 """ 3725 return _pywrapcp.Pack_AddWeightedSumOfAssignedDimension(self, weights, cost_var) 3726 3727 def AddCountUsedBinDimension(self, count_var): 3728 r""" 3729 This dimension links 'count_var' to the actual number of bins used in the 3730 pack. 3731 """ 3732 return _pywrapcp.Pack_AddCountUsedBinDimension(self, count_var) 3733 3734 def AddCountAssignedItemsDimension(self, count_var): 3735 r""" 3736 This dimension links 'count_var' to the actual number of items 3737 assigned to a bin in the pack. 3738 """ 3739 return _pywrapcp.Pack_AddCountAssignedItemsDimension(self, count_var) 3740 3741 def Post(self): 3742 return _pywrapcp.Pack_Post(self) 3743 3744 def InitialPropagateWrapper(self): 3745 return _pywrapcp.Pack_InitialPropagateWrapper(self) 3746 3747 def DebugString(self): 3748 return _pywrapcp.Pack_DebugString(self)
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
3656 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
AddWeightedSumLessOrEqualConstantDimension(self, *args):
3662 def AddWeightedSumLessOrEqualConstantDimension(self, *args): 3663 r""" 3664 *Overload 1:* 3665 Dimensions are additional constraints than can restrict what is 3666 possible with the pack constraint. It can be used to set capacity 3667 limits, to count objects per bin, to compute unassigned 3668 penalties... 3669 This dimension imposes that for all bins b, the weighted sum 3670 (weights[i]) of all objects i assigned to 'b' is less or equal 3671 'bounds[b]'. 3672 3673 | 3674 3675 *Overload 2:* 3676 This dimension imposes that for all bins b, the weighted sum 3677 (weights->Run(i)) of all objects i assigned to 'b' is less or 3678 equal to 'bounds[b]'. Ownership of the callback is transferred to 3679 the pack constraint. 3680 3681 | 3682 3683 *Overload 3:* 3684 This dimension imposes that for all bins b, the weighted sum 3685 (weights->Run(i, b) of all objects i assigned to 'b' is less or 3686 equal to 'bounds[b]'. Ownership of the callback is transferred to 3687 the pack constraint. 3688 """ 3689 return _pywrapcp.Pack_AddWeightedSumLessOrEqualConstantDimension(self, *args)
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.
def
AddWeightedSumEqualVarDimension(self, *args):
3691 def AddWeightedSumEqualVarDimension(self, *args): 3692 r""" 3693 *Overload 1:* 3694 This dimension imposes that for all bins b, the weighted sum 3695 (weights[i]) of all objects i assigned to 'b' is equal to loads[b]. 3696 3697 | 3698 3699 *Overload 2:* 3700 This dimension imposes that for all bins b, the weighted sum 3701 (weights->Run(i, b)) of all objects i assigned to 'b' is equal to 3702 loads[b]. 3703 """ 3704 return _pywrapcp.Pack_AddWeightedSumEqualVarDimension(self, *args)
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].
def
AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity):
3706 def AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity): 3707 r""" 3708 This dimension imposes: 3709 forall b in bins, 3710 sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b] 3711 where is_assigned(i, b) is true if and only if item i is assigned 3712 to the bin b. 3713 3714 This can be used to model shapes of items by linking variables of 3715 the same item on parallel dimensions with an allowed assignment 3716 constraint. 3717 """ 3718 return _pywrapcp.Pack_AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity)
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.
def
AddWeightedSumOfAssignedDimension(self, weights, cost_var):
3720 def AddWeightedSumOfAssignedDimension(self, weights, cost_var): 3721 r""" 3722 This dimension enforces that cost_var == sum of weights[i] for 3723 all objects 'i' assigned to a bin. 3724 """ 3725 return _pywrapcp.Pack_AddWeightedSumOfAssignedDimension(self, weights, cost_var)
This dimension enforces that cost_var == sum of weights[i] for all objects 'i' assigned to a bin.
def
AddCountUsedBinDimension(self, count_var):
3727 def AddCountUsedBinDimension(self, count_var): 3728 r""" 3729 This dimension links 'count_var' to the actual number of bins used in the 3730 pack. 3731 """ 3732 return _pywrapcp.Pack_AddCountUsedBinDimension(self, count_var)
This dimension links 'count_var' to the actual number of bins used in the pack.
def
AddCountAssignedItemsDimension(self, count_var):
3734 def AddCountAssignedItemsDimension(self, count_var): 3735 r""" 3736 This dimension links 'count_var' to the actual number of items 3737 assigned to a bin in the pack. 3738 """ 3739 return _pywrapcp.Pack_AddCountAssignedItemsDimension(self, count_var)
This dimension links 'count_var' to the actual number of items assigned to a bin in the pack.
def
Post(self):
This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables.
def
InitialPropagateWrapper(self):
This method performs the initial propagation of the constraint. It is called just after the post.
Inherited Members
3752class DisjunctiveConstraint(Constraint): 3753 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3754 3755 def __init__(self, *args, **kwargs): 3756 raise AttributeError("No constructor defined - class is abstract") 3757 __repr__ = _swig_repr 3758 3759 def SequenceVar(self): 3760 r""" Creates a sequence variable from the constraint.""" 3761 return _pywrapcp.DisjunctiveConstraint_SequenceVar(self) 3762 3763 def SetTransitionTime(self, transition_time): 3764 r""" 3765 Add a transition time between intervals. It forces the distance between 3766 the end of interval a and start of interval b that follows it to be at 3767 least transition_time(a, b). This function must always return 3768 a positive or null value. 3769 """ 3770 return _pywrapcp.DisjunctiveConstraint_SetTransitionTime(self, transition_time) 3771 3772 def TransitionTime(self, before_index, after_index): 3773 return _pywrapcp.DisjunctiveConstraint_TransitionTime(self, before_index, after_index)
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
3753 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
SequenceVar(self):
3759 def SequenceVar(self): 3760 r""" Creates a sequence variable from the constraint.""" 3761 return _pywrapcp.DisjunctiveConstraint_SequenceVar(self)
Creates a sequence variable from the constraint.
def
SetTransitionTime(self, transition_time):
3763 def SetTransitionTime(self, transition_time): 3764 r""" 3765 Add a transition time between intervals. It forces the distance between 3766 the end of interval a and start of interval b that follows it to be at 3767 least transition_time(a, b). This function must always return 3768 a positive or null value. 3769 """ 3770 return _pywrapcp.DisjunctiveConstraint_SetTransitionTime(self, transition_time)
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.
Inherited Members
class
RevInteger:
3777class RevInteger(object): 3778 r""" 3779 This class adds reversibility to a POD type. 3780 It contains the stamp optimization. i.e. the SaveValue call is done 3781 only once per node of the search tree. Please note that actual 3782 stamps always starts at 1, thus an initial value of 0 will always 3783 trigger the first SaveValue. 3784 """ 3785 3786 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3787 __repr__ = _swig_repr 3788 3789 def __init__(self, val): 3790 _pywrapcp.RevInteger_swiginit(self, _pywrapcp.new_RevInteger(val)) 3791 3792 def Value(self): 3793 return _pywrapcp.RevInteger_Value(self) 3794 3795 def SetValue(self, s, val): 3796 return _pywrapcp.RevInteger_SetValue(self, s, val) 3797 __swig_destroy__ = _pywrapcp.delete_RevInteger
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
3786 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
3801class NumericalRevInteger(RevInteger): 3802 r""" Subclass of Rev<T> which adds numerical operations.""" 3803 3804 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3805 __repr__ = _swig_repr 3806 3807 def __init__(self, val): 3808 _pywrapcp.NumericalRevInteger_swiginit(self, _pywrapcp.new_NumericalRevInteger(val)) 3809 3810 def Add(self, s, to_add): 3811 return _pywrapcp.NumericalRevInteger_Add(self, s, to_add) 3812 3813 def Incr(self, s): 3814 return _pywrapcp.NumericalRevInteger_Incr(self, s) 3815 3816 def Decr(self, s): 3817 return _pywrapcp.NumericalRevInteger_Decr(self, s) 3818 __swig_destroy__ = _pywrapcp.delete_NumericalRevInteger
Subclass of Rev
thisown
3804 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
Inherited Members
class
RevBool:
3822class RevBool(object): 3823 r""" 3824 This class adds reversibility to a POD type. 3825 It contains the stamp optimization. i.e. the SaveValue call is done 3826 only once per node of the search tree. Please note that actual 3827 stamps always starts at 1, thus an initial value of 0 will always 3828 trigger the first SaveValue. 3829 """ 3830 3831 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3832 __repr__ = _swig_repr 3833 3834 def __init__(self, val): 3835 _pywrapcp.RevBool_swiginit(self, _pywrapcp.new_RevBool(val)) 3836 3837 def Value(self): 3838 return _pywrapcp.RevBool_Value(self) 3839 3840 def SetValue(self, s, val): 3841 return _pywrapcp.RevBool_SetValue(self, s, val) 3842 __swig_destroy__ = _pywrapcp.delete_RevBool
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
3831 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
class
IntVarContainer:
3846class IntVarContainer(object): 3847 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3848 3849 def __init__(self, *args, **kwargs): 3850 raise AttributeError("No constructor defined") 3851 __repr__ = _swig_repr 3852 3853 def Contains(self, var): 3854 return _pywrapcp.IntVarContainer_Contains(self, var) 3855 3856 def Element(self, index): 3857 return _pywrapcp.IntVarContainer_Element(self, index) 3858 3859 def Size(self): 3860 return _pywrapcp.IntVarContainer_Size(self) 3861 3862 def Store(self): 3863 return _pywrapcp.IntVarContainer_Store(self) 3864 3865 def Restore(self): 3866 return _pywrapcp.IntVarContainer_Restore(self) 3867 3868 def __eq__(self, container): 3869 r""" 3870 Returns true if this and 'container' both represent the same V* -> E map. 3871 Runs in linear time; requires that the == operator on the type E is well 3872 defined. 3873 """ 3874 return _pywrapcp.IntVarContainer___eq__(self, container) 3875 3876 def __ne__(self, container): 3877 return _pywrapcp.IntVarContainer___ne__(self, container) 3878 __swig_destroy__ = _pywrapcp.delete_IntVarContainer
thisown
3847 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
class
IntervalVarContainer:
3882class IntervalVarContainer(object): 3883 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3884 3885 def __init__(self, *args, **kwargs): 3886 raise AttributeError("No constructor defined") 3887 __repr__ = _swig_repr 3888 3889 def Contains(self, var): 3890 return _pywrapcp.IntervalVarContainer_Contains(self, var) 3891 3892 def Element(self, index): 3893 return _pywrapcp.IntervalVarContainer_Element(self, index) 3894 3895 def Size(self): 3896 return _pywrapcp.IntervalVarContainer_Size(self) 3897 3898 def Store(self): 3899 return _pywrapcp.IntervalVarContainer_Store(self) 3900 3901 def Restore(self): 3902 return _pywrapcp.IntervalVarContainer_Restore(self) 3903 3904 def __eq__(self, container): 3905 r""" 3906 Returns true if this and 'container' both represent the same V* -> E map. 3907 Runs in linear time; requires that the == operator on the type E is well 3908 defined. 3909 """ 3910 return _pywrapcp.IntervalVarContainer___eq__(self, container) 3911 3912 def __ne__(self, container): 3913 return _pywrapcp.IntervalVarContainer___ne__(self, container) 3914 __swig_destroy__ = _pywrapcp.delete_IntervalVarContainer
thisown
3883 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
class
SequenceVarContainer:
3918class SequenceVarContainer(object): 3919 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3920 3921 def __init__(self, *args, **kwargs): 3922 raise AttributeError("No constructor defined") 3923 __repr__ = _swig_repr 3924 3925 def Contains(self, var): 3926 return _pywrapcp.SequenceVarContainer_Contains(self, var) 3927 3928 def Element(self, index): 3929 return _pywrapcp.SequenceVarContainer_Element(self, index) 3930 3931 def Size(self): 3932 return _pywrapcp.SequenceVarContainer_Size(self) 3933 3934 def Store(self): 3935 return _pywrapcp.SequenceVarContainer_Store(self) 3936 3937 def Restore(self): 3938 return _pywrapcp.SequenceVarContainer_Restore(self) 3939 3940 def __eq__(self, container): 3941 r""" 3942 Returns true if this and 'container' both represent the same V* -> E map. 3943 Runs in linear time; requires that the == operator on the type E is well 3944 defined. 3945 """ 3946 return _pywrapcp.SequenceVarContainer___eq__(self, container) 3947 3948 def __ne__(self, container): 3949 return _pywrapcp.SequenceVarContainer___ne__(self, container) 3950 __swig_destroy__ = _pywrapcp.delete_SequenceVarContainer
thisown
3919 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
3954class LocalSearchOperator(BaseObject): 3955 r""" 3956 The base class for all local search operators. 3957 3958 A local search operator is an object that defines the neighborhood of a 3959 solution. In other words, a neighborhood is the set of solutions which can 3960 be reached from a given solution using an operator. 3961 3962 The behavior of the LocalSearchOperator class is similar to iterators. 3963 The operator is synchronized with an assignment (gives the 3964 current values of the variables); this is done in the Start() method. 3965 3966 Then one can iterate over the neighbors using the MakeNextNeighbor method. 3967 This method returns an assignment which represents the incremental changes 3968 to the current solution. It also returns a second assignment representing 3969 the changes to the last solution defined by the neighborhood operator; this 3970 assignment is empty if the neighborhood operator cannot track this 3971 information. 3972 """ 3973 3974 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3975 3976 def __init__(self, *args, **kwargs): 3977 raise AttributeError("No constructor defined - class is abstract") 3978 __repr__ = _swig_repr 3979 3980 def NextNeighbor(self, delta, deltadelta): 3981 return _pywrapcp.LocalSearchOperator_NextNeighbor(self, delta, deltadelta) 3982 3983 def Start(self, assignment): 3984 return _pywrapcp.LocalSearchOperator_Start(self, assignment) 3985 def __disown__(self): 3986 self.this.disown() 3987 _pywrapcp.disown_LocalSearchOperator(self) 3988 return weakref.proxy(self)
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
3974 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
Inherited Members
3992class IntVarLocalSearchOperator(LocalSearchOperator): 3993 r""" 3994 Specialization of LocalSearchOperator built from an array of IntVars 3995 which specifies the scope of the operator. 3996 This class also takes care of storing current variable values in Start(), 3997 keeps track of changes done by the operator and builds the delta. 3998 The Deactivate() method can be used to perform Large Neighborhood Search. 3999 """ 4000 4001 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4002 __repr__ = _swig_repr 4003 4004 def __init__(self, vars, keep_inverse_values=False): 4005 if self.__class__ == IntVarLocalSearchOperator: 4006 _self = None 4007 else: 4008 _self = self 4009 _pywrapcp.IntVarLocalSearchOperator_swiginit(self, _pywrapcp.new_IntVarLocalSearchOperator(_self, vars, keep_inverse_values)) 4010 __swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchOperator 4011 4012 def Start(self, assignment): 4013 r""" 4014 This method should not be overridden. Override OnStart() instead which is 4015 called before exiting this method. 4016 """ 4017 return _pywrapcp.IntVarLocalSearchOperator_Start(self, assignment) 4018 4019 def IsIncremental(self): 4020 return _pywrapcp.IntVarLocalSearchOperator_IsIncremental(self) 4021 4022 def Size(self): 4023 return _pywrapcp.IntVarLocalSearchOperator_Size(self) 4024 4025 def Value(self, index): 4026 r""" 4027 Returns the value in the current assignment of the variable of given 4028 index. 4029 """ 4030 return _pywrapcp.IntVarLocalSearchOperator_Value(self, index) 4031 4032 def Var(self, index): 4033 r""" Returns the variable of given index.""" 4034 return _pywrapcp.IntVarLocalSearchOperator_Var(self, index) 4035 4036 def OldValue(self, index): 4037 return _pywrapcp.IntVarLocalSearchOperator_OldValue(self, index) 4038 4039 def PrevValue(self, index): 4040 return _pywrapcp.IntVarLocalSearchOperator_PrevValue(self, index) 4041 4042 def SetValue(self, index, value): 4043 return _pywrapcp.IntVarLocalSearchOperator_SetValue(self, index, value) 4044 4045 def Activated(self, index): 4046 return _pywrapcp.IntVarLocalSearchOperator_Activated(self, index) 4047 4048 def Activate(self, index): 4049 return _pywrapcp.IntVarLocalSearchOperator_Activate(self, index) 4050 4051 def Deactivate(self, index): 4052 return _pywrapcp.IntVarLocalSearchOperator_Deactivate(self, index) 4053 4054 def AddVars(self, vars): 4055 return _pywrapcp.IntVarLocalSearchOperator_AddVars(self, vars) 4056 4057 def OnStart(self): 4058 r""" 4059 Called by Start() after synchronizing the operator with the current 4060 assignment. Should be overridden instead of Start() to avoid calling 4061 IntVarLocalSearchOperator::Start explicitly. 4062 """ 4063 return _pywrapcp.IntVarLocalSearchOperator_OnStart(self) 4064 4065 def NextNeighbor(self, delta, deltadelta): 4066 r""" 4067 OnStart() should really be protected, but then SWIG doesn't see it. So we 4068 make it public, but only subclasses should access to it (to override it). 4069 Redefines MakeNextNeighbor to export a simpler interface. The calls to 4070 ApplyChanges() and RevertChanges() are factored in this method, hiding 4071 both delta and deltadelta from subclasses which only need to override 4072 MakeOneNeighbor(). 4073 Therefore this method should not be overridden. Override MakeOneNeighbor() 4074 instead. 4075 """ 4076 return _pywrapcp.IntVarLocalSearchOperator_NextNeighbor(self, delta, deltadelta) 4077 4078 def OneNeighbor(self): 4079 r""" 4080 Creates a new neighbor. It returns false when the neighborhood is 4081 completely explored. 4082 MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator. 4083 """ 4084 return _pywrapcp.IntVarLocalSearchOperator_OneNeighbor(self) 4085 def __disown__(self): 4086 self.this.disown() 4087 _pywrapcp.disown_IntVarLocalSearchOperator(self) 4088 return weakref.proxy(self)
Specialization of LocalSearchOperator built from an array of IntVars which specifies the scope of the operator. This class also takes care of storing current variable values in Start(), keeps track of changes done by the operator and builds the delta. The Deactivate() method can be used to perform Large Neighborhood Search.
thisown
4001 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
Start(self, assignment):
4012 def Start(self, assignment): 4013 r""" 4014 This method should not be overridden. Override OnStart() instead which is 4015 called before exiting this method. 4016 """ 4017 return _pywrapcp.IntVarLocalSearchOperator_Start(self, assignment)
This method should not be overridden. Override OnStart() instead which is called before exiting this method.
def
Value(self, index):
4025 def Value(self, index): 4026 r""" 4027 Returns the value in the current assignment of the variable of given 4028 index. 4029 """ 4030 return _pywrapcp.IntVarLocalSearchOperator_Value(self, index)
Returns the value in the current assignment of the variable of given index.
def
Var(self, index):
4032 def Var(self, index): 4033 r""" Returns the variable of given index.""" 4034 return _pywrapcp.IntVarLocalSearchOperator_Var(self, index)
Returns the variable of given index.
def
OnStart(self):
4057 def OnStart(self): 4058 r""" 4059 Called by Start() after synchronizing the operator with the current 4060 assignment. Should be overridden instead of Start() to avoid calling 4061 IntVarLocalSearchOperator::Start explicitly. 4062 """ 4063 return _pywrapcp.IntVarLocalSearchOperator_OnStart(self)
Called by Start() after synchronizing the operator with the current assignment. Should be overridden instead of Start() to avoid calling IntVarLocalSearchOperator::Start explicitly.
def
NextNeighbor(self, delta, deltadelta):
4065 def NextNeighbor(self, delta, deltadelta): 4066 r""" 4067 OnStart() should really be protected, but then SWIG doesn't see it. So we 4068 make it public, but only subclasses should access to it (to override it). 4069 Redefines MakeNextNeighbor to export a simpler interface. The calls to 4070 ApplyChanges() and RevertChanges() are factored in this method, hiding 4071 both delta and deltadelta from subclasses which only need to override 4072 MakeOneNeighbor(). 4073 Therefore this method should not be overridden. Override MakeOneNeighbor() 4074 instead. 4075 """ 4076 return _pywrapcp.IntVarLocalSearchOperator_NextNeighbor(self, delta, deltadelta)
OnStart() should really be protected, but then SWIG doesn't see it. So we make it public, but only subclasses should access to it (to override it). 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.
def
OneNeighbor(self):
4078 def OneNeighbor(self): 4079 r""" 4080 Creates a new neighbor. It returns false when the neighborhood is 4081 completely explored. 4082 MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator. 4083 """ 4084 return _pywrapcp.IntVarLocalSearchOperator_OneNeighbor(self)
Creates a new neighbor. It returns false when the neighborhood is completely explored. MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator.
Inherited Members
4092class BaseLns(IntVarLocalSearchOperator): 4093 r""" 4094 This is the base class for building an Lns operator. An Lns fragment is a 4095 collection of variables which will be relaxed. Fragments are built with 4096 NextFragment(), which returns false if there are no more fragments to build. 4097 Optionally one can override InitFragments, which is called from 4098 LocalSearchOperator::Start to initialize fragment data. 4099 4100 Here's a sample relaxing one variable at a time: 4101 4102 class OneVarLns : public BaseLns { 4103 public: 4104 OneVarLns(const std::vector<IntVar*>& vars) : BaseLns(vars), index_(0) {} 4105 virtual ~OneVarLns() {} 4106 virtual void InitFragments() { index_ = 0; } 4107 virtual bool NextFragment() { 4108 const int size = Size(); 4109 if (index_ < size) { 4110 AppendToFragment(index_); 4111 ++index_; 4112 return true; 4113 } else { 4114 return false; 4115 } 4116 } 4117 4118 private: 4119 int index_; 4120 }; 4121 """ 4122 4123 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4124 __repr__ = _swig_repr 4125 4126 def __init__(self, vars): 4127 if self.__class__ == BaseLns: 4128 _self = None 4129 else: 4130 _self = self 4131 _pywrapcp.BaseLns_swiginit(self, _pywrapcp.new_BaseLns(_self, vars)) 4132 __swig_destroy__ = _pywrapcp.delete_BaseLns 4133 4134 def InitFragments(self): 4135 return _pywrapcp.BaseLns_InitFragments(self) 4136 4137 def NextFragment(self): 4138 return _pywrapcp.BaseLns_NextFragment(self) 4139 4140 def AppendToFragment(self, index): 4141 return _pywrapcp.BaseLns_AppendToFragment(self, index) 4142 4143 def FragmentSize(self): 4144 return _pywrapcp.BaseLns_FragmentSize(self) 4145 4146 def __getitem__(self, index): 4147 return _pywrapcp.BaseLns___getitem__(self, index) 4148 4149 def __len__(self): 4150 return _pywrapcp.BaseLns___len__(self) 4151 def __disown__(self): 4152 self.this.disown() 4153 _pywrapcp.disown_BaseLns(self) 4154 return weakref.proxy(self)
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
private: int index_; };
thisown
4123 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
4158class ChangeValue(IntVarLocalSearchOperator): 4159 r""" 4160 Defines operators which change the value of variables; 4161 each neighbor corresponds to *one* modified variable. 4162 Sub-classes have to define ModifyValue which determines what the new 4163 variable value is going to be (given the current value and the variable). 4164 """ 4165 4166 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4167 __repr__ = _swig_repr 4168 4169 def __init__(self, vars): 4170 if self.__class__ == ChangeValue: 4171 _self = None 4172 else: 4173 _self = self 4174 _pywrapcp.ChangeValue_swiginit(self, _pywrapcp.new_ChangeValue(_self, vars)) 4175 __swig_destroy__ = _pywrapcp.delete_ChangeValue 4176 4177 def ModifyValue(self, index, value): 4178 return _pywrapcp.ChangeValue_ModifyValue(self, index, value) 4179 4180 def OneNeighbor(self): 4181 r""" This method should not be overridden. Override ModifyValue() instead.""" 4182 return _pywrapcp.ChangeValue_OneNeighbor(self) 4183 def __disown__(self): 4184 self.this.disown() 4185 _pywrapcp.disown_ChangeValue(self) 4186 return weakref.proxy(self)
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
4166 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
4190class PathOperator(IntVarLocalSearchOperator): 4191 r""" 4192 Base class of the local search operators dedicated to path modifications 4193 (a path is a set of nodes linked together by arcs). 4194 This family of neighborhoods supposes they are handling next variables 4195 representing the arcs (var[i] represents the node immediately after i on 4196 a path). 4197 Several services are provided: 4198 - arc manipulators (SetNext(), ReverseChain(), MoveChain()) 4199 - path inspectors (Next(), Prev(), IsPathEnd()) 4200 - path iterators: operators need a given number of nodes to define a 4201 neighbor; this class provides the iteration on a given number of (base) 4202 nodes which can be used to define a neighbor (through the BaseNode method) 4203 Subclasses only need to override MakeNeighbor to create neighbors using 4204 the services above (no direct manipulation of assignments). 4205 """ 4206 4207 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4208 4209 def __init__(self, *args, **kwargs): 4210 raise AttributeError("No constructor defined - class is abstract") 4211 __repr__ = _swig_repr 4212 4213 def Neighbor(self): 4214 return _pywrapcp.PathOperator_Neighbor(self)
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(), Prev(), 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
4207 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
4218class LocalSearchFilter(BaseObject): 4219 r""" 4220 Classes to which this template function can be applied to as of 04/2014. 4221 Usage: LocalSearchOperator* op = MakeLocalSearchOperator<Relocate>(...); 4222 class TwoOpt; 4223 class Relocate; 4224 class Exchange; 4225 class Cross; 4226 class MakeActiveOperator; 4227 class MakeInactiveOperator; 4228 class MakeChainInactiveOperator; 4229 class SwapActiveOperator; 4230 class ExtendedSwapActiveOperator; 4231 class MakeActiveAndRelocate; 4232 class RelocateAndMakeActiveOperator; 4233 class RelocateAndMakeInactiveOperator; 4234 Local Search Filters are used for fast neighbor pruning. 4235 Filtering a move is done in several phases: 4236 - in the Relax phase, filters determine which parts of their internals 4237 will be changed by the candidate, and modify intermediary State 4238 - in the Accept phase, filters check that the candidate is feasible, 4239 - if the Accept phase succeeds, the solver may decide to trigger a 4240 Synchronize phase that makes filters change their internal representation 4241 to the last candidate, 4242 - otherwise (Accept fails or the solver does not want to synchronize), 4243 a Revert phase makes filters erase any intermediary State generated by the 4244 Relax and Accept phases. 4245 A given filter has phases called with the following pattern: 4246 (Relax.Accept.Synchronize | Relax.Accept.Revert | Relax.Revert)*. 4247 Filters's Revert() is always called in the reverse order their Accept() was 4248 called, to allow late filters to use state done/undone by early filters' 4249 Accept()/Revert(). 4250 """ 4251 4252 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4253 4254 def __init__(self, *args, **kwargs): 4255 raise AttributeError("No constructor defined - class is abstract") 4256 __repr__ = _swig_repr 4257 4258 def Accept(self, delta, deltadelta, objective_min, objective_max): 4259 r""" 4260 Accepts a "delta" given the assignment with which the filter has been 4261 synchronized; the delta holds the variables which have been modified and 4262 their new value. 4263 If the filter represents a part of the global objective, its contribution 4264 must be between objective_min and objective_max. 4265 Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1, 4266 for the assignment (a,1), (b,0), the delta (b,1) will be rejected 4267 but the delta (a,0) will be accepted. 4268 TODO(user): Remove arguments when there are no more need for those. 4269 """ 4270 return _pywrapcp.LocalSearchFilter_Accept(self, delta, deltadelta, objective_min, objective_max) 4271 4272 def IsIncremental(self): 4273 return _pywrapcp.LocalSearchFilter_IsIncremental(self) 4274 4275 def Synchronize(self, assignment, delta): 4276 r""" 4277 Synchronizes the filter with the current solution, delta being the 4278 difference with the solution passed to the previous call to Synchronize() 4279 or IncrementalSynchronize(). 'delta' can be used to incrementally 4280 synchronizing the filter with the new solution by only considering the 4281 changes in delta. 4282 """ 4283 return _pywrapcp.LocalSearchFilter_Synchronize(self, assignment, delta) 4284 __swig_destroy__ = _pywrapcp.delete_LocalSearchFilter
Classes to which this template function can be applied to as of 04/2014.
Usage: LocalSearchOperator* op = MakeLocalSearchOperator
- in the Relax phase, filters determine which parts of their internals will be changed by the candidate, and modify intermediary State
- in the Accept phase, filters check that the candidate is feasible,
- if the Accept phase succeeds, the solver may decide to trigger a Synchronize phase that makes filters change their internal representation to the last candidate,
- otherwise (Accept fails or the solver does not want to synchronize), a Revert phase makes filters erase any intermediary State generated by the Relax and Accept phases. A given filter has phases called with the following pattern: (Relax.Accept.Synchronize | Relax.Accept.Revert | Relax.Revert)*. Filters's Revert() is always called in the reverse order their Accept() was called, to allow late filters to use state done/undone by early filters' Accept()/Revert().
thisown
4252 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
Accept(self, delta, deltadelta, objective_min, objective_max):
4258 def Accept(self, delta, deltadelta, objective_min, objective_max): 4259 r""" 4260 Accepts a "delta" given the assignment with which the filter has been 4261 synchronized; the delta holds the variables which have been modified and 4262 their new value. 4263 If the filter represents a part of the global objective, its contribution 4264 must be between objective_min and objective_max. 4265 Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1, 4266 for the assignment (a,1), (b,0), the delta (b,1) will be rejected 4267 but the delta (a,0) will be accepted. 4268 TODO(user): Remove arguments when there are no more need for those. 4269 """ 4270 return _pywrapcp.LocalSearchFilter_Accept(self, delta, deltadelta, objective_min, objective_max)
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. If the filter represents a part of the global objective, its contribution must be between objective_min and objective_max. 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. TODO(user): Remove arguments when there are no more need for those.
def
Synchronize(self, assignment, delta):
4275 def Synchronize(self, assignment, delta): 4276 r""" 4277 Synchronizes the filter with the current solution, delta being the 4278 difference with the solution passed to the previous call to Synchronize() 4279 or IncrementalSynchronize(). 'delta' can be used to incrementally 4280 synchronizing the filter with the new solution by only considering the 4281 changes in delta. 4282 """ 4283 return _pywrapcp.LocalSearchFilter_Synchronize(self, assignment, delta)
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.
Inherited Members
4288class LocalSearchFilterManager(BaseObject): 4289 r""" 4290 Filter manager: when a move is made, filters are executed to decide whether 4291 the solution is feasible and compute parts of the new cost. This class 4292 schedules filter execution and composes costs as a sum. 4293 """ 4294 4295 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4296 __repr__ = _swig_repr 4297 4298 def DebugString(self): 4299 return _pywrapcp.LocalSearchFilterManager_DebugString(self) 4300 4301 def __init__(self, *args): 4302 _pywrapcp.LocalSearchFilterManager_swiginit(self, _pywrapcp.new_LocalSearchFilterManager(*args)) 4303 4304 def Accept(self, monitor, delta, deltadelta, objective_min, objective_max): 4305 r""" 4306 Returns true iff all filters return true, and the sum of their accepted 4307 objectives is between objective_min and objective_max. 4308 The monitor has its Begin/EndFiltering events triggered. 4309 """ 4310 return _pywrapcp.LocalSearchFilterManager_Accept(self, monitor, delta, deltadelta, objective_min, objective_max) 4311 4312 def Synchronize(self, assignment, delta): 4313 r""" Synchronizes all filters to assignment.""" 4314 return _pywrapcp.LocalSearchFilterManager_Synchronize(self, assignment, delta) 4315 __swig_destroy__ = _pywrapcp.delete_LocalSearchFilterManager
Filter manager: when a move is made, filters are executed to decide whether the solution is feasible and compute parts of the new cost. This class schedules filter execution and composes costs as a sum.
thisown
4295 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
Accept(self, monitor, delta, deltadelta, objective_min, objective_max):
4304 def Accept(self, monitor, delta, deltadelta, objective_min, objective_max): 4305 r""" 4306 Returns true iff all filters return true, and the sum of their accepted 4307 objectives is between objective_min and objective_max. 4308 The monitor has its Begin/EndFiltering events triggered. 4309 """ 4310 return _pywrapcp.LocalSearchFilterManager_Accept(self, monitor, delta, deltadelta, objective_min, objective_max)
Returns true iff all filters return true, and the sum of their accepted objectives is between objective_min and objective_max. The monitor has its Begin/EndFiltering events triggered.
4319class IntVarLocalSearchFilter(LocalSearchFilter): 4320 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4321 __repr__ = _swig_repr 4322 4323 def __init__(self, vars): 4324 if self.__class__ == IntVarLocalSearchFilter: 4325 _self = None 4326 else: 4327 _self = self 4328 _pywrapcp.IntVarLocalSearchFilter_swiginit(self, _pywrapcp.new_IntVarLocalSearchFilter(_self, vars)) 4329 __swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchFilter 4330 4331 def Synchronize(self, assignment, delta): 4332 r""" 4333 This method should not be overridden. Override OnSynchronize() instead 4334 which is called before exiting this method. 4335 """ 4336 return _pywrapcp.IntVarLocalSearchFilter_Synchronize(self, assignment, delta) 4337 4338 def Size(self): 4339 return _pywrapcp.IntVarLocalSearchFilter_Size(self) 4340 4341 def Value(self, index): 4342 return _pywrapcp.IntVarLocalSearchFilter_Value(self, index) 4343 4344 def IndexFromVar(self, var): 4345 return _pywrapcp.IntVarLocalSearchFilter_IndexFromVar(self, var) 4346 def __disown__(self): 4347 self.this.disown() 4348 _pywrapcp.disown_IntVarLocalSearchFilter(self) 4349 return weakref.proxy(self)
Classes to which this template function can be applied to as of 04/2014.
Usage: LocalSearchOperator* op = MakeLocalSearchOperator
- in the Relax phase, filters determine which parts of their internals will be changed by the candidate, and modify intermediary State
- in the Accept phase, filters check that the candidate is feasible,
- if the Accept phase succeeds, the solver may decide to trigger a Synchronize phase that makes filters change their internal representation to the last candidate,
- otherwise (Accept fails or the solver does not want to synchronize), a Revert phase makes filters erase any intermediary State generated by the Relax and Accept phases. A given filter has phases called with the following pattern: (Relax.Accept.Synchronize | Relax.Accept.Revert | Relax.Revert)*. Filters's Revert() is always called in the reverse order their Accept() was called, to allow late filters to use state done/undone by early filters' Accept()/Revert().
thisown
4320 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
Synchronize(self, assignment, delta):
4331 def Synchronize(self, assignment, delta): 4332 r""" 4333 This method should not be overridden. Override OnSynchronize() instead 4334 which is called before exiting this method. 4335 """ 4336 return _pywrapcp.IntVarLocalSearchFilter_Synchronize(self, assignment, delta)
This method should not be overridden. Override OnSynchronize() instead which is called before exiting this method.
Inherited Members
4353class BooleanVar(IntVar): 4354 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4355 4356 def __init__(self, *args, **kwargs): 4357 raise AttributeError("No constructor defined - class is abstract") 4358 __repr__ = _swig_repr 4359 4360 def Min(self): 4361 return _pywrapcp.BooleanVar_Min(self) 4362 4363 def SetMin(self, m): 4364 return _pywrapcp.BooleanVar_SetMin(self, m) 4365 4366 def Max(self): 4367 return _pywrapcp.BooleanVar_Max(self) 4368 4369 def SetMax(self, m): 4370 return _pywrapcp.BooleanVar_SetMax(self, m) 4371 4372 def SetRange(self, mi, ma): 4373 return _pywrapcp.BooleanVar_SetRange(self, mi, ma) 4374 4375 def Bound(self): 4376 return _pywrapcp.BooleanVar_Bound(self) 4377 4378 def Value(self): 4379 return _pywrapcp.BooleanVar_Value(self) 4380 4381 def RemoveValue(self, v): 4382 return _pywrapcp.BooleanVar_RemoveValue(self, v) 4383 4384 def RemoveInterval(self, l, u): 4385 return _pywrapcp.BooleanVar_RemoveInterval(self, l, u) 4386 4387 def WhenBound(self, d): 4388 return _pywrapcp.BooleanVar_WhenBound(self, d) 4389 4390 def WhenRange(self, d): 4391 return _pywrapcp.BooleanVar_WhenRange(self, d) 4392 4393 def WhenDomain(self, d): 4394 return _pywrapcp.BooleanVar_WhenDomain(self, d) 4395 4396 def Size(self): 4397 return _pywrapcp.BooleanVar_Size(self) 4398 4399 def Contains(self, v): 4400 return _pywrapcp.BooleanVar_Contains(self, v) 4401 4402 def HoleIteratorAux(self, reversible): 4403 return _pywrapcp.BooleanVar_HoleIteratorAux(self, reversible) 4404 4405 def DomainIteratorAux(self, reversible): 4406 return _pywrapcp.BooleanVar_DomainIteratorAux(self, reversible) 4407 4408 def DebugString(self): 4409 return _pywrapcp.BooleanVar_DebugString(self)
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
4354 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
Value(self):
This method returns the value of the variable. This method checks before that the variable is bound.
def
RemoveInterval(self, l, u):
This method removes the interval 'l' .. 'u' from the domain of the variable. It assumes that 'l' <= 'u'.
def
WhenBound(self, d):
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.
def
WhenRange(self, d):
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.
def
WhenDomain(self, d):
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.
def
HoleIteratorAux(self, reversible):
4402 def HoleIteratorAux(self, reversible): 4403 return _pywrapcp.BooleanVar_HoleIteratorAux(self, reversible)
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.
def
DomainIteratorAux(self, reversible):
4405 def DomainIteratorAux(self, reversible): 4406 return _pywrapcp.BooleanVar_DomainIteratorAux(self, reversible)
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.
4414class PyDecision(Decision): 4415 def ApplyWrapper(self, solver): 4416 try: 4417 self.Apply(solver) 4418 except Exception as e: 4419 if 'CP Solver fail' in str(e): 4420 solver.ShouldFail() 4421 else: 4422 raise 4423 4424 def RefuteWrapper(self, solver): 4425 try: 4426 self.Refute(solver) 4427 except Exception as e: 4428 if 'CP Solver fail' in str(e): 4429 solver.ShouldFail() 4430 else: 4431 raise 4432 4433 def DebugString(self): 4434 return "PyDecision"
A Decision represents a choice point in the search tree. The two main methods are Apply() to go left, or Refute() to go right.
def
ApplyWrapper(self, solver):
4415 def ApplyWrapper(self, solver): 4416 try: 4417 self.Apply(solver) 4418 except Exception as e: 4419 if 'CP Solver fail' in str(e): 4420 solver.ShouldFail() 4421 else: 4422 raise
Apply will be called first when the decision is executed.
4437class PyDecisionBuilder(DecisionBuilder): 4438 def NextWrapper(self, solver): 4439 try: 4440 return self.Next(solver) 4441 except Exception as e: 4442 if 'CP Solver fail' in str(e): 4443 return solver.FailDecision() 4444 else: 4445 raise 4446 4447 def DebugString(self): 4448 return "PyDecisionBuilder"
A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.
def
NextWrapper(self, solver):
4438 def NextWrapper(self, solver): 4439 try: 4440 return self.Next(solver) 4441 except Exception as e: 4442 if 'CP Solver fail' in str(e): 4443 return solver.FailDecision() 4444 else: 4445 raise
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.
Inherited Members
4451class PyDemon(Demon): 4452 def RunWrapper(self, solver): 4453 try: 4454 self.Run(solver) 4455 except Exception as e: 4456 if 'CP Solver fail' in str(e): 4457 solver.ShouldFail() 4458 else: 4459 raise 4460 4461 def DebugString(self): 4462 return "PyDemon"
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.
4465class PyConstraintDemon(PyDemon): 4466 def __init__(self, ct, method, delayed, *args): 4467 super().__init__() 4468 self.__constraint = ct 4469 self.__method = method 4470 self.__delayed = delayed 4471 self.__args = args 4472 4473 def Run(self, solver): 4474 self.__method(self.__constraint, *self.__args) 4475 4476 def Priority(self): 4477 return Solver.DELAYED_PRIORITY if self.__delayed else Solver.NORMAL_PRIORITY 4478 4479 def DebugString(self): 4480 return 'PyConstraintDemon'
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.
PyConstraintDemon(ct, method, delayed, *args)
4466 def __init__(self, ct, method, delayed, *args): 4467 super().__init__() 4468 self.__constraint = ct 4469 self.__method = method 4470 self.__delayed = delayed 4471 self.__args = args
This indicates the priority of a demon. Immediate demons are treated separately and corresponds to variables.
def
Priority(self):
4476 def Priority(self): 4477 return Solver.DELAYED_PRIORITY if self.__delayed else Solver.NORMAL_PRIORITY
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.
Inherited Members
4483class PyConstraint(Constraint): 4484 def __init__(self, solver): 4485 super().__init__(solver) 4486 self.__demons = [] 4487 4488 def Demon(self, method, *args): 4489 demon = PyConstraintDemon(self, method, False, *args) 4490 self.__demons.append(demon) 4491 return demon 4492 4493 def DelayedDemon(self, method, *args): 4494 demon = PyConstraintDemon(self, method, True, *args) 4495 self.__demons.append(demon) 4496 return demon 4497 4498 def InitialPropagateDemon(self): 4499 return self.solver().ConstraintInitialPropagateCallback(self) 4500 4501 def DelayedInitialPropagateDemon(self): 4502 return self.solver().DelayedConstraintInitialPropagateCallback(self) 4503 4504 def InitialPropagateWrapper(self): 4505 try: 4506 self.InitialPropagate() 4507 except Exception as e: 4508 if 'CP Solver fail' in str(e): 4509 self.solver().ShouldFail() 4510 else: 4511 raise 4512 4513 def DebugString(self): 4514 return "PyConstraint"
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.
def
InitialPropagateWrapper(self):
4504 def InitialPropagateWrapper(self): 4505 try: 4506 self.InitialPropagate() 4507 except Exception as e: 4508 if 'CP Solver fail' in str(e): 4509 self.solver().ShouldFail() 4510 else: 4511 raise
This method performs the initial propagation of the constraint. It is called just after the post.
Inherited Members
class
RoutingIndexManager:
4516class RoutingIndexManager(object): 4517 r""" 4518 Manager for any NodeIndex <-> variable index conversion. The routing solver 4519 uses variable indices internally and through its API. These variable indices 4520 are tricky to manage directly because one Node can correspond to a multitude 4521 of variables, depending on the number of times they appear in the model, and 4522 if they're used as start and/or end points. This class aims to simplify 4523 variable index usage, allowing users to use NodeIndex instead. 4524 4525 Usage: 4526 4527 .. code-block:: c++ 4528 4529 auto starts_ends = ...; /// These are NodeIndex. 4530 RoutingIndexManager manager(10, 4, starts_ends); // 10 nodes, 4 vehicles. 4531 RoutingModel model(manager); 4532 4533 Then, use 'manager.NodeToIndex(node)' whenever model requires a variable 4534 index. 4535 4536 Note: the mapping between node indices and variables indices is subject to 4537 change so no assumption should be made on it. The only guarantee is that 4538 indices range between 0 and n-1, where n = number of vehicles * 2 (for start 4539 and end nodes) + number of non-start or end nodes. 4540 """ 4541 4542 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4543 __repr__ = _swig_repr 4544 4545 def __init__(self, *args): 4546 _pywrapcp.RoutingIndexManager_swiginit(self, _pywrapcp.new_RoutingIndexManager(*args)) 4547 4548 def GetNumberOfNodes(self): 4549 return _pywrapcp.RoutingIndexManager_GetNumberOfNodes(self) 4550 4551 def GetNumberOfVehicles(self): 4552 return _pywrapcp.RoutingIndexManager_GetNumberOfVehicles(self) 4553 4554 def GetNumberOfIndices(self): 4555 return _pywrapcp.RoutingIndexManager_GetNumberOfIndices(self) 4556 4557 def GetStartIndex(self, vehicle): 4558 return _pywrapcp.RoutingIndexManager_GetStartIndex(self, vehicle) 4559 4560 def GetEndIndex(self, vehicle): 4561 return _pywrapcp.RoutingIndexManager_GetEndIndex(self, vehicle) 4562 4563 def NodeToIndex(self, node): 4564 return _pywrapcp.RoutingIndexManager_NodeToIndex(self, node) 4565 4566 def IndexToNode(self, index): 4567 return _pywrapcp.RoutingIndexManager_IndexToNode(self, index) 4568 __swig_destroy__ = _pywrapcp.delete_RoutingIndexManager
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:
```c++
auto starts_ends = ...; /// These are NodeIndex. RoutingIndexManager manager(10, 4, starts_ends); // 10 nodes, 4 vehicles. RoutingModel model(manager); ```
Then, use 'manager.NodeToIndex(node)' whenever model requires a variable index.
Note: the mapping between node indices and variables indices is subject to change so no assumption should be made on it. The only guarantee is that indices range between 0 and n-1, where n = number of vehicles * 2 (for start and end nodes) + number of non-start or end nodes.
thisown
4542 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
DefaultRoutingModelParameters():
def
DefaultRoutingSearchParameters():
def
FindErrorInRoutingSearchParameters(search_parameters):
4579def FindErrorInRoutingSearchParameters(search_parameters): 4580 r""" 4581 Returns an empty std::string if the routing search parameters are valid, and 4582 a non-empty, human readable error description if they're not. 4583 """ 4584 return _pywrapcp.FindErrorInRoutingSearchParameters(search_parameters)
Returns an empty std::string if the routing search parameters are valid, and a non-empty, human readable error description if they're not.
BOOL_UNSPECIFIED =
0
BOOL_FALSE =
2
BOOL_TRUE =
3
class
FirstSolutionStrategy:
4588class FirstSolutionStrategy(object): 4589 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4590 __repr__ = _swig_repr 4591 4592 def __init__(self): 4593 _pywrapcp.FirstSolutionStrategy_swiginit(self, _pywrapcp.new_FirstSolutionStrategy()) 4594 __swig_destroy__ = _pywrapcp.delete_FirstSolutionStrategy
thisown
4589 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
class
LocalSearchMetaheuristic:
4598class LocalSearchMetaheuristic(object): 4599 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4600 __repr__ = _swig_repr 4601 4602 def __init__(self): 4603 _pywrapcp.LocalSearchMetaheuristic_swiginit(self, _pywrapcp.new_LocalSearchMetaheuristic()) 4604 __swig_destroy__ = _pywrapcp.delete_LocalSearchMetaheuristic
thisown
4599 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
class
PathsMetadata:
4608class PathsMetadata(object): 4609 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4610 __repr__ = _swig_repr 4611 4612 def __init__(self, manager): 4613 _pywrapcp.PathsMetadata_swiginit(self, _pywrapcp.new_PathsMetadata(manager)) 4614 4615 def IsStart(self, node): 4616 return _pywrapcp.PathsMetadata_IsStart(self, node) 4617 4618 def IsEnd(self, node): 4619 return _pywrapcp.PathsMetadata_IsEnd(self, node) 4620 4621 def GetPath(self, start_or_end_node): 4622 return _pywrapcp.PathsMetadata_GetPath(self, start_or_end_node) 4623 4624 def NumPaths(self): 4625 return _pywrapcp.PathsMetadata_NumPaths(self) 4626 4627 def Paths(self): 4628 return _pywrapcp.PathsMetadata_Paths(self) 4629 4630 def Starts(self): 4631 return _pywrapcp.PathsMetadata_Starts(self) 4632 4633 def Ends(self): 4634 return _pywrapcp.PathsMetadata_Ends(self) 4635 __swig_destroy__ = _pywrapcp.delete_PathsMetadata
thisown
4609 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
class
RoutingModel:
4639class RoutingModel(object): 4640 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4641 __repr__ = _swig_repr 4642 ROUTING_NOT_SOLVED = _pywrapcp.RoutingModel_ROUTING_NOT_SOLVED 4643 r""" Problem not solved yet (before calling RoutingModel::Solve()).""" 4644 ROUTING_SUCCESS = _pywrapcp.RoutingModel_ROUTING_SUCCESS 4645 r""" Problem solved successfully after calling RoutingModel::Solve().""" 4646 ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED = _pywrapcp.RoutingModel_ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED 4647 r""" 4648 Problem solved successfully after calling RoutingModel::Solve(), except 4649 that a local optimum has not been reached. Leaving more time would allow 4650 improving the solution. 4651 """ 4652 ROUTING_FAIL = _pywrapcp.RoutingModel_ROUTING_FAIL 4653 r""" No solution found to the problem after calling RoutingModel::Solve().""" 4654 ROUTING_FAIL_TIMEOUT = _pywrapcp.RoutingModel_ROUTING_FAIL_TIMEOUT 4655 r""" Time limit reached before finding a solution with RoutingModel::Solve().""" 4656 ROUTING_INVALID = _pywrapcp.RoutingModel_ROUTING_INVALID 4657 r""" Model, model parameters or flags are not valid.""" 4658 ROUTING_INFEASIBLE = _pywrapcp.RoutingModel_ROUTING_INFEASIBLE 4659 r""" Problem proven to be infeasible.""" 4660 ROUTING_OPTIMAL = _pywrapcp.RoutingModel_ROUTING_OPTIMAL 4661 r""" Problem has been solved to optimality.""" 4662 PICKUP_AND_DELIVERY_NO_ORDER = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_NO_ORDER 4663 r""" Any precedence is accepted.""" 4664 PICKUP_AND_DELIVERY_LIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_LIFO 4665 r""" Deliveries must be performed in reverse order of pickups.""" 4666 PICKUP_AND_DELIVERY_FIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_FIFO 4667 r""" Deliveries must be performed in the same order as pickups.""" 4668 4669 def __init__(self, *args): 4670 _pywrapcp.RoutingModel_swiginit(self, _pywrapcp.new_RoutingModel(*args)) 4671 __swig_destroy__ = _pywrapcp.delete_RoutingModel 4672 kTransitEvaluatorSignUnknown = _pywrapcp.RoutingModel_kTransitEvaluatorSignUnknown 4673 kTransitEvaluatorSignPositiveOrZero = _pywrapcp.RoutingModel_kTransitEvaluatorSignPositiveOrZero 4674 kTransitEvaluatorSignNegativeOrZero = _pywrapcp.RoutingModel_kTransitEvaluatorSignNegativeOrZero 4675 4676 def RegisterUnaryTransitVector(self, values): 4677 r""" 4678 Registers 'callback' and returns its index. 4679 The sign parameter allows to notify the solver that the callback only 4680 return values of the given sign. This can help the solver, but passing 4681 an incorrect sign may crash in non-opt compilation mode, and yield 4682 incorrect results in opt. 4683 """ 4684 return _pywrapcp.RoutingModel_RegisterUnaryTransitVector(self, values) 4685 4686 def RegisterUnaryTransitCallback(self, *args): 4687 return _pywrapcp.RoutingModel_RegisterUnaryTransitCallback(self, *args) 4688 4689 def RegisterTransitMatrix(self, values): 4690 return _pywrapcp.RoutingModel_RegisterTransitMatrix(self, values) 4691 4692 def RegisterTransitCallback(self, *args): 4693 return _pywrapcp.RoutingModel_RegisterTransitCallback(self, *args) 4694 4695 def TransitCallback(self, callback_index): 4696 return _pywrapcp.RoutingModel_TransitCallback(self, callback_index) 4697 4698 def UnaryTransitCallbackOrNull(self, callback_index): 4699 return _pywrapcp.RoutingModel_UnaryTransitCallbackOrNull(self, callback_index) 4700 4701 def AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name): 4702 r""" 4703 Model creation 4704 Methods to add dimensions to routes; dimensions represent quantities 4705 accumulated at nodes along the routes. They represent quantities such as 4706 weights or volumes carried along the route, or distance or times. 4707 Quantities at a node are represented by "cumul" variables and the increase 4708 or decrease of quantities between nodes are represented by "transit" 4709 variables. These variables are linked as follows: 4710 if j == next(i), cumul(j) = cumul(i) + transit(i, j) + slack(i) 4711 where slack is a positive slack variable (can represent waiting times for 4712 a time dimension). 4713 Setting the value of fix_start_cumul_to_zero to true will force the 4714 "cumul" variable of the start node of all vehicles to be equal to 0. 4715 Creates a dimension where the transit variable is constrained to be 4716 equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the 4717 slack variable and 'capacity' is the upper bound of the cumul variables. 4718 'name' is the name used to reference the dimension; this name is used to 4719 get cumul and transit variables from the routing model. 4720 Returns false if a dimension with the same name has already been created 4721 (and doesn't create the new dimension). 4722 Takes ownership of the callback 'evaluator'. 4723 """ 4724 return _pywrapcp.RoutingModel_AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name) 4725 4726 def AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name): 4727 return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name) 4728 4729 def AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name): 4730 return _pywrapcp.RoutingModel_AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name) 4731 4732 def AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name): 4733 return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name) 4734 4735 def AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name): 4736 r""" 4737 Creates a dimension where the transit variable is constrained to be 4738 equal to 'value'; 'capacity' is the upper bound of the cumul variables. 4739 'name' is the name used to reference the dimension; this name is used to 4740 get cumul and transit variables from the routing model. 4741 Returns a pair consisting of an index to the registered unary transit 4742 callback and a bool denoting whether the dimension has been created. 4743 It is false if a dimension with the same name has already been created 4744 (and doesn't create the new dimension but still register a new callback). 4745 """ 4746 return _pywrapcp.RoutingModel_AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name) 4747 4748 def AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name): 4749 return _pywrapcp.RoutingModel_AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name) 4750 4751 def AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name): 4752 r""" 4753 Creates a dimension where the transit variable is constrained to be 4754 equal to 'values[i]' for node i; 'capacity' is the upper bound of 4755 the cumul variables. 'name' is the name used to reference the dimension; 4756 this name is used to get cumul and transit variables from the routing 4757 model. 4758 Returns a pair consisting of an index to the registered unary transit 4759 callback and a bool denoting whether the dimension has been created. 4760 It is false if a dimension with the same name has already been created 4761 (and doesn't create the new dimension but still register a new callback). 4762 """ 4763 return _pywrapcp.RoutingModel_AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name) 4764 4765 def AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name): 4766 r""" 4767 Creates a dimension where the transit variable is constrained to be 4768 equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of 4769 the cumul variables. 'name' is the name used to reference the dimension; 4770 this name is used to get cumul and transit variables from the routing 4771 model. 4772 Returns a pair consisting of an index to the registered transit callback 4773 and a bool denoting whether the dimension has been created. 4774 It is false if a dimension with the same name has already been created 4775 (and doesn't create the new dimension but still register a new callback). 4776 """ 4777 return _pywrapcp.RoutingModel_AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name) 4778 4779 def GetAllDimensionNames(self): 4780 r""" Outputs the names of all dimensions added to the routing engine.""" 4781 return _pywrapcp.RoutingModel_GetAllDimensionNames(self) 4782 4783 def GetDimensions(self): 4784 r""" Returns all dimensions of the model.""" 4785 return _pywrapcp.RoutingModel_GetDimensions(self) 4786 4787 def GetDimensionsWithSoftOrSpanCosts(self): 4788 r""" Returns dimensions with soft or vehicle span costs.""" 4789 return _pywrapcp.RoutingModel_GetDimensionsWithSoftOrSpanCosts(self) 4790 4791 def GetUnaryDimensions(self): 4792 r""" Returns dimensions for which all transit evaluators are unary.""" 4793 return _pywrapcp.RoutingModel_GetUnaryDimensions(self) 4794 4795 def GetDimensionsWithGlobalCumulOptimizers(self): 4796 r""" Returns the dimensions which have [global|local]_dimension_optimizers_.""" 4797 return _pywrapcp.RoutingModel_GetDimensionsWithGlobalCumulOptimizers(self) 4798 4799 def GetDimensionsWithLocalCumulOptimizers(self): 4800 return _pywrapcp.RoutingModel_GetDimensionsWithLocalCumulOptimizers(self) 4801 4802 def HasGlobalCumulOptimizer(self, dimension): 4803 r""" Returns whether the given dimension has global/local cumul optimizers.""" 4804 return _pywrapcp.RoutingModel_HasGlobalCumulOptimizer(self, dimension) 4805 4806 def HasLocalCumulOptimizer(self, dimension): 4807 return _pywrapcp.RoutingModel_HasLocalCumulOptimizer(self, dimension) 4808 4809 def GetMutableGlobalCumulLPOptimizer(self, dimension): 4810 r""" 4811 Returns the global/local dimension cumul optimizer for a given dimension, 4812 or nullptr if there is none. 4813 """ 4814 return _pywrapcp.RoutingModel_GetMutableGlobalCumulLPOptimizer(self, dimension) 4815 4816 def GetMutableGlobalCumulMPOptimizer(self, dimension): 4817 return _pywrapcp.RoutingModel_GetMutableGlobalCumulMPOptimizer(self, dimension) 4818 4819 def GetMutableLocalCumulLPOptimizer(self, dimension): 4820 return _pywrapcp.RoutingModel_GetMutableLocalCumulLPOptimizer(self, dimension) 4821 4822 def GetMutableLocalCumulMPOptimizer(self, dimension): 4823 return _pywrapcp.RoutingModel_GetMutableLocalCumulMPOptimizer(self, dimension) 4824 4825 def HasDimension(self, dimension_name): 4826 r""" Returns true if a dimension exists for a given dimension name.""" 4827 return _pywrapcp.RoutingModel_HasDimension(self, dimension_name) 4828 4829 def GetDimensionOrDie(self, dimension_name): 4830 r""" Returns a dimension from its name. Dies if the dimension does not exist.""" 4831 return _pywrapcp.RoutingModel_GetDimensionOrDie(self, dimension_name) 4832 4833 def GetMutableDimension(self, dimension_name): 4834 r""" 4835 Returns a dimension from its name. Returns nullptr if the dimension does 4836 not exist. 4837 """ 4838 return _pywrapcp.RoutingModel_GetMutableDimension(self, dimension_name) 4839 4840 def SetPrimaryConstrainedDimension(self, dimension_name): 4841 r""" 4842 Set the given dimension as "primary constrained". As of August 2013, this 4843 is only used by ArcIsMoreConstrainedThanArc(). 4844 "dimension" must be the name of an existing dimension, or be empty, in 4845 which case there will not be a primary dimension after this call. 4846 """ 4847 return _pywrapcp.RoutingModel_SetPrimaryConstrainedDimension(self, dimension_name) 4848 4849 def GetPrimaryConstrainedDimension(self): 4850 r""" Get the primary constrained dimension, or an empty string if it is unset.""" 4851 return _pywrapcp.RoutingModel_GetPrimaryConstrainedDimension(self) 4852 4853 def GetResourceGroup(self, rg_index): 4854 return _pywrapcp.RoutingModel_GetResourceGroup(self, rg_index) 4855 4856 def GetDimensionResourceGroupIndices(self, dimension): 4857 r""" 4858 Returns the indices of resource groups for this dimension. This method can 4859 only be called after the model has been closed. 4860 """ 4861 return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndices(self, dimension) 4862 4863 def GetDimensionResourceGroupIndex(self, dimension): 4864 r""" 4865 Returns the index of the resource group attached to the dimension. 4866 DCHECKS that there's exactly one resource group for this dimension. 4867 """ 4868 return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndex(self, dimension) 4869 4870 def AddDisjunction(self, *args): 4871 r""" 4872 Adds a disjunction constraint on the indices: exactly 'max_cardinality' of 4873 the indices are active. Start and end indices of any vehicle cannot be 4874 part of a disjunction. 4875 4876 If a penalty is given, at most 'max_cardinality' of the indices can be 4877 active, and if less are active, 'penalty' is payed per inactive index. 4878 This is equivalent to adding the constraint: 4879 p + Sum(i)active[i] == max_cardinality 4880 where p is an integer variable, and the following cost to the cost 4881 function: 4882 p * penalty. 4883 'penalty' must be positive to make the disjunction optional; a negative 4884 penalty will force 'max_cardinality' indices of the disjunction to be 4885 performed, and therefore p == 0. 4886 Note: passing a vector with a single index will model an optional index 4887 with a penalty cost if it is not visited. 4888 """ 4889 return _pywrapcp.RoutingModel_AddDisjunction(self, *args) 4890 4891 def GetDisjunctionIndices(self, index): 4892 r""" Returns the indices of the disjunctions to which an index belongs.""" 4893 return _pywrapcp.RoutingModel_GetDisjunctionIndices(self, index) 4894 4895 def GetDisjunctionPenalty(self, index): 4896 r""" Returns the penalty of the node disjunction of index 'index'.""" 4897 return _pywrapcp.RoutingModel_GetDisjunctionPenalty(self, index) 4898 4899 def GetDisjunctionMaxCardinality(self, index): 4900 r""" 4901 Returns the maximum number of possible active nodes of the node 4902 disjunction of index 'index'. 4903 """ 4904 return _pywrapcp.RoutingModel_GetDisjunctionMaxCardinality(self, index) 4905 4906 def GetNumberOfDisjunctions(self): 4907 r""" Returns the number of node disjunctions in the model.""" 4908 return _pywrapcp.RoutingModel_GetNumberOfDisjunctions(self) 4909 4910 def HasMandatoryDisjunctions(self): 4911 r""" 4912 Returns true if the model contains mandatory disjunctions (ones with 4913 kNoPenalty as penalty). 4914 """ 4915 return _pywrapcp.RoutingModel_HasMandatoryDisjunctions(self) 4916 4917 def HasMaxCardinalityConstrainedDisjunctions(self): 4918 r""" 4919 Returns true if the model contains at least one disjunction which is 4920 constrained by its max_cardinality. 4921 """ 4922 return _pywrapcp.RoutingModel_HasMaxCardinalityConstrainedDisjunctions(self) 4923 4924 def GetPerfectBinaryDisjunctions(self): 4925 r""" 4926 Returns the list of all perfect binary disjunctions, as pairs of variable 4927 indices: a disjunction is "perfect" when its variables do not appear in 4928 any other disjunction. Each pair is sorted (lowest variable index first), 4929 and the output vector is also sorted (lowest pairs first). 4930 """ 4931 return _pywrapcp.RoutingModel_GetPerfectBinaryDisjunctions(self) 4932 4933 def IgnoreDisjunctionsAlreadyForcedToZero(self): 4934 r""" 4935 SPECIAL: Makes the solver ignore all the disjunctions whose active 4936 variables are all trivially zero (i.e. Max() == 0), by setting their 4937 max_cardinality to 0. 4938 This can be useful when using the BaseBinaryDisjunctionNeighborhood 4939 operators, in the context of arc-based routing. 4940 """ 4941 return _pywrapcp.RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero(self) 4942 4943 def AddSoftSameVehicleConstraint(self, indices, cost): 4944 r""" 4945 Adds a soft constraint to force a set of variable indices to be on the 4946 same vehicle. If all nodes are not on the same vehicle, each extra vehicle 4947 used adds 'cost' to the cost function. 4948 """ 4949 return _pywrapcp.RoutingModel_AddSoftSameVehicleConstraint(self, indices, cost) 4950 4951 def SetAllowedVehiclesForIndex(self, vehicles, index): 4952 r""" 4953 Sets the vehicles which can visit a given node. If the node is in a 4954 disjunction, this will not prevent it from being unperformed. 4955 Specifying an empty vector of vehicles has no effect (all vehicles 4956 will be allowed to visit the node). 4957 """ 4958 return _pywrapcp.RoutingModel_SetAllowedVehiclesForIndex(self, vehicles, index) 4959 4960 def IsVehicleAllowedForIndex(self, vehicle, index): 4961 r""" Returns true if a vehicle is allowed to visit a given node.""" 4962 return _pywrapcp.RoutingModel_IsVehicleAllowedForIndex(self, vehicle, index) 4963 4964 def AddPickupAndDelivery(self, pickup, delivery): 4965 r""" 4966 Notifies that index1 and index2 form a pair of nodes which should belong 4967 to the same route. This methods helps the search find better solutions, 4968 especially in the local search phase. 4969 It should be called each time you have an equality constraint linking 4970 the vehicle variables of two node (including for instance pickup and 4971 delivery problems): 4972 Solver* const solver = routing.solver(); 4973 int64_t index1 = manager.NodeToIndex(node1); 4974 int64_t index2 = manager.NodeToIndex(node2); 4975 solver->AddConstraint(solver->MakeEquality( 4976 routing.VehicleVar(index1), 4977 routing.VehicleVar(index2))); 4978 routing.AddPickupAndDelivery(index1, index2); 4979 """ 4980 return _pywrapcp.RoutingModel_AddPickupAndDelivery(self, pickup, delivery) 4981 4982 def AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction): 4983 r""" 4984 Same as AddPickupAndDelivery but notifying that the performed node from 4985 the disjunction of index 'pickup_disjunction' is on the same route as the 4986 performed node from the disjunction of index 'delivery_disjunction'. 4987 """ 4988 return _pywrapcp.RoutingModel_AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction) 4989 4990 def GetPickupPositions(self, node_index): 4991 r""" Returns the pickup and delivery positions where the node is a pickup.""" 4992 return _pywrapcp.RoutingModel_GetPickupPositions(self, node_index) 4993 4994 def GetDeliveryPositions(self, node_index): 4995 r""" Returns the pickup and delivery positions where the node is a delivery.""" 4996 return _pywrapcp.RoutingModel_GetDeliveryPositions(self, node_index) 4997 4998 def IsPickup(self, node_index): 4999 r""" Returns whether the node is a pickup (resp. delivery).""" 5000 return _pywrapcp.RoutingModel_IsPickup(self, node_index) 5001 5002 def IsDelivery(self, node_index): 5003 return _pywrapcp.RoutingModel_IsDelivery(self, node_index) 5004 5005 def SetPickupAndDeliveryPolicyOfAllVehicles(self, policy): 5006 r""" 5007 Sets the Pickup and delivery policy of all vehicles. It is equivalent to 5008 calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles. 5009 """ 5010 return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles(self, policy) 5011 5012 def SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle): 5013 return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle) 5014 5015 def GetPickupAndDeliveryPolicyOfVehicle(self, vehicle): 5016 return _pywrapcp.RoutingModel_GetPickupAndDeliveryPolicyOfVehicle(self, vehicle) 5017 5018 def GetNumOfSingletonNodes(self): 5019 r""" 5020 Returns the number of non-start/end nodes which do not appear in a 5021 pickup/delivery pair. 5022 """ 5023 return _pywrapcp.RoutingModel_GetNumOfSingletonNodes(self) 5024 TYPE_ADDED_TO_VEHICLE = _pywrapcp.RoutingModel_TYPE_ADDED_TO_VEHICLE 5025 r""" When visited, the number of types 'T' on the vehicle increases by one.""" 5026 ADDED_TYPE_REMOVED_FROM_VEHICLE = _pywrapcp.RoutingModel_ADDED_TYPE_REMOVED_FROM_VEHICLE 5027 r""" 5028 When visited, one instance of type 'T' previously added to the route 5029 (TYPE_ADDED_TO_VEHICLE), if any, is removed from the vehicle. 5030 If the type was not previously added to the route or all added instances 5031 have already been removed, this visit has no effect on the types. 5032 """ 5033 TYPE_ON_VEHICLE_UP_TO_VISIT = _pywrapcp.RoutingModel_TYPE_ON_VEHICLE_UP_TO_VISIT 5034 r""" 5035 With the following policy, the visit enforces that type 'T' is 5036 considered on the route from its start until this node is visited. 5037 """ 5038 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED = _pywrapcp.RoutingModel_TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED 5039 r""" 5040 The visit doesn't have an impact on the number of types 'T' on the 5041 route, as it's (virtually) added and removed directly. 5042 This policy can be used for visits which are part of an incompatibility 5043 or requirement set without affecting the type count on the route. 5044 """ 5045 5046 def SetVisitType(self, index, type, type_policy): 5047 return _pywrapcp.RoutingModel_SetVisitType(self, index, type, type_policy) 5048 5049 def GetVisitType(self, index): 5050 return _pywrapcp.RoutingModel_GetVisitType(self, index) 5051 5052 def GetSingleNodesOfType(self, type): 5053 return _pywrapcp.RoutingModel_GetSingleNodesOfType(self, type) 5054 5055 def GetPairIndicesOfType(self, type): 5056 return _pywrapcp.RoutingModel_GetPairIndicesOfType(self, type) 5057 5058 def GetVisitTypePolicy(self, index): 5059 return _pywrapcp.RoutingModel_GetVisitTypePolicy(self, index) 5060 5061 def CloseVisitTypes(self): 5062 r""" 5063 This function should be called once all node visit types have been set and 5064 prior to adding any incompatibilities/requirements. 5065 "close" types. 5066 """ 5067 return _pywrapcp.RoutingModel_CloseVisitTypes(self) 5068 5069 def GetNumberOfVisitTypes(self): 5070 return _pywrapcp.RoutingModel_GetNumberOfVisitTypes(self) 5071 5072 def AddHardTypeIncompatibility(self, type1, type2): 5073 r""" 5074 Incompatibilities: 5075 Two nodes with "hard" incompatible types cannot share the same route at 5076 all, while with a "temporal" incompatibility they can't be on the same 5077 route at the same time. 5078 """ 5079 return _pywrapcp.RoutingModel_AddHardTypeIncompatibility(self, type1, type2) 5080 5081 def AddTemporalTypeIncompatibility(self, type1, type2): 5082 return _pywrapcp.RoutingModel_AddTemporalTypeIncompatibility(self, type1, type2) 5083 5084 def GetHardTypeIncompatibilitiesOfType(self, type): 5085 r""" Returns visit types incompatible with a given type.""" 5086 return _pywrapcp.RoutingModel_GetHardTypeIncompatibilitiesOfType(self, type) 5087 5088 def GetTemporalTypeIncompatibilitiesOfType(self, type): 5089 return _pywrapcp.RoutingModel_GetTemporalTypeIncompatibilitiesOfType(self, type) 5090 5091 def HasHardTypeIncompatibilities(self): 5092 r""" 5093 Returns true iff any hard (resp. temporal) type incompatibilities have 5094 been added to the model. 5095 """ 5096 return _pywrapcp.RoutingModel_HasHardTypeIncompatibilities(self) 5097 5098 def HasTemporalTypeIncompatibilities(self): 5099 return _pywrapcp.RoutingModel_HasTemporalTypeIncompatibilities(self) 5100 5101 def AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives): 5102 r""" 5103 Requirements: 5104 NOTE: As of 2019-04, cycles in the requirement graph are not supported, 5105 and lead to the dependent nodes being skipped if possible (otherwise 5106 the model is considered infeasible). 5107 The following functions specify that "dependent_type" requires at least 5108 one of the types in "required_type_alternatives". 5109 5110 For same-vehicle requirements, a node of dependent type type_D requires at 5111 least one node of type type_R among the required alternatives on the same 5112 route. 5113 """ 5114 return _pywrapcp.RoutingModel_AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives) 5115 5116 def AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives): 5117 r""" 5118 If type_D depends on type_R when adding type_D, any node_D of type_D and 5119 VisitTypePolicy TYPE_ADDED_TO_VEHICLE or 5120 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its 5121 vehicle at the time node_D is visited. 5122 """ 5123 return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives) 5124 5125 def AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives): 5126 r""" 5127 The following requirements apply when visiting dependent nodes that remove 5128 their type from the route, i.e. type_R must be on the vehicle when type_D 5129 of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE, 5130 TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is 5131 visited. 5132 """ 5133 return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives) 5134 5135 def GetSameVehicleRequiredTypeAlternativesOfType(self, type): 5136 r""" 5137 Returns the set of same-vehicle requirement alternatives for the given 5138 type. 5139 """ 5140 return _pywrapcp.RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType(self, type) 5141 5142 def GetRequiredTypeAlternativesWhenAddingType(self, type): 5143 r""" Returns the set of requirement alternatives when adding the given type.""" 5144 return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenAddingType(self, type) 5145 5146 def GetRequiredTypeAlternativesWhenRemovingType(self, type): 5147 r""" Returns the set of requirement alternatives when removing the given type.""" 5148 return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenRemovingType(self, type) 5149 5150 def HasSameVehicleTypeRequirements(self): 5151 r""" 5152 Returns true iff any same-route (resp. temporal) type requirements have 5153 been added to the model. 5154 """ 5155 return _pywrapcp.RoutingModel_HasSameVehicleTypeRequirements(self) 5156 5157 def HasTemporalTypeRequirements(self): 5158 return _pywrapcp.RoutingModel_HasTemporalTypeRequirements(self) 5159 5160 def HasTypeRegulations(self): 5161 r""" 5162 Returns true iff the model has any incompatibilities or requirements set 5163 on node types. 5164 """ 5165 return _pywrapcp.RoutingModel_HasTypeRegulations(self) 5166 5167 def UnperformedPenalty(self, var_index): 5168 r""" 5169 Get the "unperformed" penalty of a node. This is only well defined if the 5170 node is only part of a single Disjunction, and that disjunction has a 5171 penalty. For forced active nodes returns max int64_t. In all other cases, 5172 this returns 0. 5173 """ 5174 return _pywrapcp.RoutingModel_UnperformedPenalty(self, var_index) 5175 5176 def UnperformedPenaltyOrValue(self, default_value, var_index): 5177 r""" 5178 Same as above except that it returns default_value instead of 0 when 5179 penalty is not well defined (default value is passed as first argument to 5180 simplify the usage of the method in a callback). 5181 """ 5182 return _pywrapcp.RoutingModel_UnperformedPenaltyOrValue(self, default_value, var_index) 5183 5184 def GetDepot(self): 5185 r""" 5186 Returns the variable index of the first starting or ending node of all 5187 routes. If all routes start and end at the same node (single depot), this 5188 is the node returned. 5189 """ 5190 return _pywrapcp.RoutingModel_GetDepot(self) 5191 5192 def SetMaximumNumberOfActiveVehicles(self, max_active_vehicles): 5193 r""" 5194 Constrains the maximum number of active vehicles, aka the number of 5195 vehicles which do not have an empty route. For instance, this can be used 5196 to limit the number of routes in the case where there are fewer drivers 5197 than vehicles and that the fleet of vehicle is heterogeneous. 5198 """ 5199 return _pywrapcp.RoutingModel_SetMaximumNumberOfActiveVehicles(self, max_active_vehicles) 5200 5201 def GetMaximumNumberOfActiveVehicles(self): 5202 r""" Returns the maximum number of active vehicles.""" 5203 return _pywrapcp.RoutingModel_GetMaximumNumberOfActiveVehicles(self) 5204 5205 def SetArcCostEvaluatorOfAllVehicles(self, evaluator_index): 5206 r""" 5207 Sets the cost function of the model such that the cost of a segment of a 5208 route between node 'from' and 'to' is evaluator(from, to), whatever the 5209 route or vehicle performing the route. 5210 """ 5211 return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfAllVehicles(self, evaluator_index) 5212 5213 def SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle): 5214 r""" Sets the cost function for a given vehicle route.""" 5215 return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle) 5216 5217 def SetFixedCostOfAllVehicles(self, cost): 5218 r""" 5219 Sets the fixed cost of all vehicle routes. It is equivalent to calling 5220 SetFixedCostOfVehicle on all vehicle routes. 5221 """ 5222 return _pywrapcp.RoutingModel_SetFixedCostOfAllVehicles(self, cost) 5223 5224 def SetFixedCostOfVehicle(self, cost, vehicle): 5225 r""" Sets the fixed cost of one vehicle route.""" 5226 return _pywrapcp.RoutingModel_SetFixedCostOfVehicle(self, cost, vehicle) 5227 5228 def GetFixedCostOfVehicle(self, vehicle): 5229 r""" 5230 Returns the route fixed cost taken into account if the route of the 5231 vehicle is not empty, aka there's at least one node on the route other 5232 than the first and last nodes. 5233 """ 5234 return _pywrapcp.RoutingModel_GetFixedCostOfVehicle(self, vehicle) 5235 5236 def SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle): 5237 return _pywrapcp.RoutingModel_SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle) 5238 5239 def SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor): 5240 r""" 5241 The following methods set the linear and quadratic cost factors of 5242 vehicles (must be positive values). The default value of these parameters 5243 is zero for all vehicles. 5244 5245 When set, the cost_ of the model will contain terms aiming at reducing the 5246 number of vehicles used in the model, by adding the following to the 5247 objective for every vehicle v: 5248 INDICATOR(v used in the model) * 5249 [linear_cost_factor_of_vehicle_[v] 5250 - quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)] 5251 i.e. for every used vehicle, we add the linear factor as fixed cost, and 5252 subtract the square of the route length multiplied by the quadratic 5253 factor. This second term aims at making the routes as dense as possible. 5254 5255 Sets the linear and quadratic cost factor of all vehicles. 5256 """ 5257 return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor) 5258 5259 def SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle): 5260 r""" Sets the linear and quadratic cost factor of the given vehicle.""" 5261 return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle) 5262 5263 def GetAmortizedLinearCostFactorOfVehicles(self): 5264 return _pywrapcp.RoutingModel_GetAmortizedLinearCostFactorOfVehicles(self) 5265 5266 def GetAmortizedQuadraticCostFactorOfVehicles(self): 5267 return _pywrapcp.RoutingModel_GetAmortizedQuadraticCostFactorOfVehicles(self) 5268 5269 def SetVehicleUsedWhenEmpty(self, is_used, vehicle): 5270 return _pywrapcp.RoutingModel_SetVehicleUsedWhenEmpty(self, is_used, vehicle) 5271 5272 def IsVehicleUsedWhenEmpty(self, vehicle): 5273 return _pywrapcp.RoutingModel_IsVehicleUsedWhenEmpty(self, vehicle) 5274 5275 def SetFirstSolutionEvaluator(self, evaluator): 5276 r""" 5277 Gets/sets the evaluator used during the search. Only relevant when 5278 RoutingSearchParameters.first_solution_strategy = EVALUATOR_STRATEGY. 5279 Takes ownership of evaluator. 5280 """ 5281 return _pywrapcp.RoutingModel_SetFirstSolutionEvaluator(self, evaluator) 5282 5283 def AddLocalSearchOperator(self, ls_operator): 5284 r""" 5285 Adds a local search operator to the set of operators used to solve the 5286 vehicle routing problem. 5287 """ 5288 return _pywrapcp.RoutingModel_AddLocalSearchOperator(self, ls_operator) 5289 5290 def AddSearchMonitor(self, monitor): 5291 r""" Adds a search monitor to the search used to solve the routing model.""" 5292 return _pywrapcp.RoutingModel_AddSearchMonitor(self, monitor) 5293 5294 def AddAtSolutionCallback(self, callback, track_unchecked_neighbors=False): 5295 r""" 5296 Adds a callback called each time a solution is found during the search. 5297 This is a shortcut to creating a monitor to call the callback on 5298 AtSolution() and adding it with AddSearchMonitor. 5299 If track_unchecked_neighbors is true, the callback will also be called on 5300 AcceptUncheckedNeighbor() events, which is useful to grab solutions 5301 obtained when solver_parameters.check_solution_period > 1 (aka fastLS). 5302 """ 5303 return _pywrapcp.RoutingModel_AddAtSolutionCallback(self, callback, track_unchecked_neighbors) 5304 5305 def AddVariableMinimizedByFinalizer(self, var): 5306 r""" 5307 Adds a variable to minimize in the solution finalizer. The solution 5308 finalizer is called each time a solution is found during the search and 5309 allows to instantiate secondary variables (such as dimension cumul 5310 variables). 5311 """ 5312 return _pywrapcp.RoutingModel_AddVariableMinimizedByFinalizer(self, var) 5313 5314 def AddVariableMaximizedByFinalizer(self, var): 5315 r""" 5316 Adds a variable to maximize in the solution finalizer (see above for 5317 information on the solution finalizer). 5318 """ 5319 return _pywrapcp.RoutingModel_AddVariableMaximizedByFinalizer(self, var) 5320 5321 def AddWeightedVariableMinimizedByFinalizer(self, var, cost): 5322 r""" 5323 Adds a variable to minimize in the solution finalizer, with a weighted 5324 priority: the higher the more priority it has. 5325 """ 5326 return _pywrapcp.RoutingModel_AddWeightedVariableMinimizedByFinalizer(self, var, cost) 5327 5328 def AddWeightedVariableMaximizedByFinalizer(self, var, cost): 5329 r""" 5330 Adds a variable to maximize in the solution finalizer, with a weighted 5331 priority: the higher the more priority it has. 5332 """ 5333 return _pywrapcp.RoutingModel_AddWeightedVariableMaximizedByFinalizer(self, var, cost) 5334 5335 def AddVariableTargetToFinalizer(self, var, target): 5336 r""" 5337 Add a variable to set the closest possible to the target value in the 5338 solution finalizer. 5339 """ 5340 return _pywrapcp.RoutingModel_AddVariableTargetToFinalizer(self, var, target) 5341 5342 def AddWeightedVariableTargetToFinalizer(self, var, target, cost): 5343 r""" 5344 Same as above with a weighted priority: the higher the cost, the more 5345 priority it has to be set close to the target value. 5346 """ 5347 return _pywrapcp.RoutingModel_AddWeightedVariableTargetToFinalizer(self, var, target, cost) 5348 5349 def CloseModel(self): 5350 r""" 5351 Closes the current routing model; after this method is called, no 5352 modification to the model can be done, but RoutesToAssignment becomes 5353 available. Note that CloseModel() is automatically called by Solve() and 5354 other methods that produce solution. 5355 This is equivalent to calling 5356 CloseModelWithParameters(DefaultRoutingSearchParameters()). 5357 """ 5358 return _pywrapcp.RoutingModel_CloseModel(self) 5359 5360 def CloseModelWithParameters(self, search_parameters): 5361 r""" 5362 Same as above taking search parameters (as of 10/2015 some the parameters 5363 have to be set when closing the model). 5364 """ 5365 return _pywrapcp.RoutingModel_CloseModelWithParameters(self, search_parameters) 5366 5367 def Solve(self, assignment=None): 5368 r""" 5369 Solves the current routing model; closes the current model. 5370 This is equivalent to calling 5371 SolveWithParameters(DefaultRoutingSearchParameters()) 5372 or 5373 SolveFromAssignmentWithParameters(assignment, 5374 DefaultRoutingSearchParameters()). 5375 """ 5376 return _pywrapcp.RoutingModel_Solve(self, assignment) 5377 5378 def SolveWithParameters(self, search_parameters, solutions=None): 5379 r""" 5380 Solves the current routing model with the given parameters. If 'solutions' 5381 is specified, it will contain the k best solutions found during the search 5382 (from worst to best, including the one returned by this method), where k 5383 corresponds to the 'number_of_solutions_to_collect' in 5384 'search_parameters'. Note that the Assignment returned by the method and 5385 the ones in solutions are owned by the underlying solver and should not be 5386 deleted. 5387 """ 5388 return _pywrapcp.RoutingModel_SolveWithParameters(self, search_parameters, solutions) 5389 5390 def SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions=None): 5391 r""" 5392 Same as above, except that if assignment is not null, it will be used as 5393 the initial solution. 5394 """ 5395 return _pywrapcp.RoutingModel_SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions) 5396 5397 def FastSolveFromAssignmentWithParameters(self, assignment, search_parameters, check_solution_in_cp, touched=None): 5398 r""" 5399 Improves a given assignment using unchecked local search. 5400 If check_solution_in_cp is true the final solution will be checked with 5401 the CP solver. 5402 As of 11/2023, only works with greedy descent. 5403 """ 5404 return _pywrapcp.RoutingModel_FastSolveFromAssignmentWithParameters(self, assignment, search_parameters, check_solution_in_cp, touched) 5405 5406 def SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions=None): 5407 r""" 5408 Same as above but will try all assignments in order as first solutions 5409 until one succeeds. 5410 """ 5411 return _pywrapcp.RoutingModel_SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions) 5412 5413 def SolveWithIteratedLocalSearch(self, search_parameters): 5414 r""" 5415 Solves the current routing model by using an Iterated Local Search 5416 approach. 5417 """ 5418 return _pywrapcp.RoutingModel_SolveWithIteratedLocalSearch(self, search_parameters) 5419 5420 def SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment): 5421 r""" 5422 Given a "source_model" and its "source_assignment", resets 5423 "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_ 5424 if costs aren't homogeneous across vehicles) of "this" model, with the 5425 values set according to those in "other_assignment". 5426 The objective_element of target_assignment is set to this->cost_. 5427 """ 5428 return _pywrapcp.RoutingModel_SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment) 5429 5430 def ComputeLowerBound(self): 5431 r""" 5432 Computes a lower bound to the routing problem solving a linear assignment 5433 problem. The routing model must be closed before calling this method. 5434 Note that problems with node disjunction constraints (including optional 5435 nodes) and non-homogenous costs are not supported (the method returns 0 in 5436 these cases). 5437 """ 5438 return _pywrapcp.RoutingModel_ComputeLowerBound(self) 5439 5440 def objective_lower_bound(self): 5441 r""" 5442 Returns the current lower bound found by internal solvers during the 5443 search. 5444 """ 5445 return _pywrapcp.RoutingModel_objective_lower_bound(self) 5446 5447 def status(self): 5448 r""" Returns the current status of the routing model.""" 5449 return _pywrapcp.RoutingModel_status(self) 5450 5451 def enable_deep_serialization(self): 5452 r""" Returns the value of the internal enable_deep_serialization_ parameter.""" 5453 return _pywrapcp.RoutingModel_enable_deep_serialization(self) 5454 5455 def ApplyLocks(self, locks): 5456 r""" 5457 Applies a lock chain to the next search. 'locks' represents an ordered 5458 vector of nodes representing a partial route which will be fixed during 5459 the next search; it will constrain next variables such that: 5460 next[locks[i]] == locks[i+1]. 5461 5462 Returns the next variable at the end of the locked chain; this variable is 5463 not locked. An assignment containing the locks can be obtained by calling 5464 PreAssignment(). 5465 """ 5466 return _pywrapcp.RoutingModel_ApplyLocks(self, locks) 5467 5468 def ApplyLocksToAllVehicles(self, locks, close_routes): 5469 r""" 5470 Applies lock chains to all vehicles to the next search, such that locks[p] 5471 is the lock chain for route p. Returns false if the locks do not contain 5472 valid routes; expects that the routes do not contain the depots, 5473 i.e. there are empty vectors in place of empty routes. 5474 If close_routes is set to true, adds the end nodes to the route of each 5475 vehicle and deactivates other nodes. 5476 An assignment containing the locks can be obtained by calling 5477 PreAssignment(). 5478 """ 5479 return _pywrapcp.RoutingModel_ApplyLocksToAllVehicles(self, locks, close_routes) 5480 5481 def PreAssignment(self): 5482 r""" 5483 Returns an assignment used to fix some of the variables of the problem. 5484 In practice, this assignment locks partial routes of the problem. This 5485 can be used in the context of locking the parts of the routes which have 5486 already been driven in online routing problems. 5487 """ 5488 return _pywrapcp.RoutingModel_PreAssignment(self) 5489 5490 def MutablePreAssignment(self): 5491 return _pywrapcp.RoutingModel_MutablePreAssignment(self) 5492 5493 def WriteAssignment(self, file_name): 5494 r""" 5495 Writes the current solution to a file containing an AssignmentProto. 5496 Returns false if the file cannot be opened or if there is no current 5497 solution. 5498 """ 5499 return _pywrapcp.RoutingModel_WriteAssignment(self, file_name) 5500 5501 def ReadAssignment(self, file_name): 5502 r""" 5503 Reads an assignment from a file and returns the current solution. 5504 Returns nullptr if the file cannot be opened or if the assignment is not 5505 valid. 5506 """ 5507 return _pywrapcp.RoutingModel_ReadAssignment(self, file_name) 5508 5509 def RestoreAssignment(self, solution): 5510 r""" 5511 Restores an assignment as a solution in the routing model and returns the 5512 new solution. Returns nullptr if the assignment is not valid. 5513 """ 5514 return _pywrapcp.RoutingModel_RestoreAssignment(self, solution) 5515 5516 def ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices): 5517 r""" 5518 Restores the routes as the current solution. Returns nullptr if the 5519 solution cannot be restored (routes do not contain a valid solution). Note 5520 that calling this method will run the solver to assign values to the 5521 dimension variables; this may take considerable amount of time, especially 5522 when using dimensions with slack. 5523 """ 5524 return _pywrapcp.RoutingModel_ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices) 5525 5526 def RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment): 5527 r""" 5528 Fills an assignment from a specification of the routes of the 5529 vehicles. The routes are specified as lists of variable indices that 5530 appear on the routes of the vehicles. The indices of the outer vector in 5531 'routes' correspond to vehicles IDs, the inner vector contains the 5532 variable indices on the routes for the given vehicle. The inner vectors 5533 must not contain the start and end indices, as these are determined by the 5534 routing model. Sets the value of NextVars in the assignment, adding the 5535 variables to the assignment if necessary. The method does not touch other 5536 variables in the assignment. The method can only be called after the model 5537 is closed. With ignore_inactive_indices set to false, this method will 5538 fail (return nullptr) in case some of the route contain indices that are 5539 deactivated in the model; when set to true, these indices will be 5540 skipped. Returns true if routes were successfully 5541 loaded. However, such assignment still might not be a valid 5542 solution to the routing problem due to more complex constraints; 5543 it is advisible to call solver()->CheckSolution() afterwards. 5544 """ 5545 return _pywrapcp.RoutingModel_RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment) 5546 5547 def AssignmentToRoutes(self, assignment, routes): 5548 r""" 5549 Converts the solution in the given assignment to routes for all vehicles. 5550 Expects that assignment contains a valid solution (i.e. routes for all 5551 vehicles end with an end index for that vehicle). 5552 """ 5553 return _pywrapcp.RoutingModel_AssignmentToRoutes(self, assignment, routes) 5554 5555 def CompactAssignment(self, assignment): 5556 r""" 5557 Converts the solution in the given assignment to routes for all vehicles. 5558 If the returned vector is route_indices, route_indices[i][j] is the index 5559 for jth location visited on route i. Note that contrary to 5560 AssignmentToRoutes, the vectors do include start and end locations. 5561 Returns a compacted version of the given assignment, in which all vehicles 5562 with id lower or equal to some N have non-empty routes, and all vehicles 5563 with id greater than N have empty routes. Does not take ownership of the 5564 returned object. 5565 If found, the cost of the compact assignment is the same as in the 5566 original assignment and it preserves the values of 'active' variables. 5567 Returns nullptr if a compact assignment was not found. 5568 This method only works in homogenous mode, and it only swaps equivalent 5569 vehicles (vehicles with the same start and end nodes). When creating the 5570 compact assignment, the empty plan is replaced by the route assigned to 5571 the compatible vehicle with the highest id. Note that with more complex 5572 constraints on vehicle variables, this method might fail even if a compact 5573 solution exists. 5574 This method changes the vehicle and dimension variables as necessary. 5575 While compacting the solution, only basic checks on vehicle variables are 5576 performed; if one of these checks fails no attempts to repair it are made 5577 (instead, the method returns nullptr). 5578 """ 5579 return _pywrapcp.RoutingModel_CompactAssignment(self, assignment) 5580 5581 def CompactAndCheckAssignment(self, assignment): 5582 r""" 5583 Same as CompactAssignment() but also checks the validity of the final 5584 compact solution; if it is not valid, no attempts to repair it are made 5585 (instead, the method returns nullptr). 5586 """ 5587 return _pywrapcp.RoutingModel_CompactAndCheckAssignment(self, assignment) 5588 5589 def AddToAssignment(self, var): 5590 r""" Adds an extra variable to the vehicle routing assignment.""" 5591 return _pywrapcp.RoutingModel_AddToAssignment(self, var) 5592 5593 def AddIntervalToAssignment(self, interval): 5594 return _pywrapcp.RoutingModel_AddIntervalToAssignment(self, interval) 5595 5596 def PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached=None): 5597 r""" 5598 For every dimension in the model with an optimizer in 5599 local/global_dimension_optimizers_, this method tries to pack the cumul 5600 values of the dimension, such that: 5601 - The cumul costs (span costs, soft lower and upper bound costs, etc) are 5602 minimized. 5603 - The cumuls of the ends of the routes are minimized for this given 5604 minimal cumul cost. 5605 - Given these minimal end cumuls, the route start cumuls are maximized. 5606 Returns the assignment resulting from allocating these packed cumuls with 5607 the solver, and nullptr if these cumuls could not be set by the solver. 5608 """ 5609 return _pywrapcp.RoutingModel_PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached) 5610 5611 def GetOrCreateNodeNeighborsByCostClass(self, *args): 5612 r""" 5613 *Overload 1:* 5614 Returns neighbors of all nodes for every cost class. The result is cached 5615 and is computed once. The number of neighbors considered is based on a 5616 ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum 5617 of min-neighbors node considered. 5618 5619 | 5620 5621 *Overload 2:* 5622 Returns parameters.num_neighbors neighbors of all nodes for every cost 5623 class. The result is cached and is computed once. 5624 5625 | 5626 5627 *Overload 3:* 5628 Returns parameters.num_neighbors neighbors of all nodes for every cost 5629 class. The result is cached and is computed once. 5630 """ 5631 return _pywrapcp.RoutingModel_GetOrCreateNodeNeighborsByCostClass(self, *args) 5632 5633 def AddLocalSearchFilter(self, filter): 5634 r""" 5635 Adds a custom local search filter to the list of filters used to speed up 5636 local search by pruning unfeasible variable assignments. 5637 Calling this method after the routing model has been closed (CloseModel() 5638 or Solve() has been called) has no effect. 5639 The routing model does not take ownership of the filter. 5640 """ 5641 return _pywrapcp.RoutingModel_AddLocalSearchFilter(self, filter) 5642 5643 def Start(self, vehicle): 5644 r""" 5645 Model inspection. 5646 Returns the variable index of the starting node of a vehicle route. 5647 """ 5648 return _pywrapcp.RoutingModel_Start(self, vehicle) 5649 5650 def End(self, vehicle): 5651 r""" Returns the variable index of the ending node of a vehicle route.""" 5652 return _pywrapcp.RoutingModel_End(self, vehicle) 5653 5654 def IsStart(self, index): 5655 r""" Returns true if 'index' represents the first node of a route.""" 5656 return _pywrapcp.RoutingModel_IsStart(self, index) 5657 5658 def IsEnd(self, index): 5659 r""" Returns true if 'index' represents the last node of a route.""" 5660 return _pywrapcp.RoutingModel_IsEnd(self, index) 5661 5662 def VehicleIndex(self, index): 5663 r""" 5664 Returns the vehicle of the given start/end index, and -1 if the given 5665 index is not a vehicle start/end. 5666 """ 5667 return _pywrapcp.RoutingModel_VehicleIndex(self, index) 5668 5669 def Next(self, assignment, index): 5670 r""" 5671 Assignment inspection 5672 Returns the variable index of the node directly after the node 5673 corresponding to 'index' in 'assignment'. 5674 """ 5675 return _pywrapcp.RoutingModel_Next(self, assignment, index) 5676 5677 def IsVehicleUsed(self, assignment, vehicle): 5678 r""" Returns true if the route of 'vehicle' is non empty in 'assignment'.""" 5679 return _pywrapcp.RoutingModel_IsVehicleUsed(self, assignment, vehicle) 5680 5681 def NextVar(self, index): 5682 r""" 5683 Returns the next variable of the node corresponding to index. Note that 5684 NextVar(index) == index is equivalent to ActiveVar(index) == 0. 5685 """ 5686 return _pywrapcp.RoutingModel_NextVar(self, index) 5687 5688 def ActiveVar(self, index): 5689 r""" Returns the active variable of the node corresponding to index.""" 5690 return _pywrapcp.RoutingModel_ActiveVar(self, index) 5691 5692 def ActiveVehicleVar(self, vehicle): 5693 r""" 5694 Returns the active variable of the vehicle. It will be equal to 1 iff the 5695 route of the vehicle is not empty, 0 otherwise. 5696 """ 5697 return _pywrapcp.RoutingModel_ActiveVehicleVar(self, vehicle) 5698 5699 def VehicleRouteConsideredVar(self, vehicle): 5700 r""" 5701 Returns the variable specifying whether or not the given vehicle route is 5702 considered for costs and constraints. It will be equal to 1 iff the route 5703 of the vehicle is not empty OR vehicle_used_when_empty_[vehicle] is true. 5704 """ 5705 return _pywrapcp.RoutingModel_VehicleRouteConsideredVar(self, vehicle) 5706 5707 def VehicleVar(self, index): 5708 r""" 5709 Returns the vehicle variable of the node corresponding to index. Note that 5710 VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0. 5711 """ 5712 return _pywrapcp.RoutingModel_VehicleVar(self, index) 5713 5714 def ResourceVar(self, vehicle, resource_group): 5715 r""" 5716 Returns the resource variable for the given vehicle index in the given 5717 resource group. If a vehicle doesn't require a resource from the 5718 corresponding resource group, then ResourceVar(v, r_g) == -1. 5719 """ 5720 return _pywrapcp.RoutingModel_ResourceVar(self, vehicle, resource_group) 5721 5722 def CostVar(self): 5723 r""" Returns the global cost variable which is being minimized.""" 5724 return _pywrapcp.RoutingModel_CostVar(self) 5725 5726 def GetArcCostForVehicle(self, from_index, to_index, vehicle): 5727 r""" 5728 Returns the cost of the transit arc between two nodes for a given vehicle. 5729 Input are variable indices of node. This returns 0 if vehicle < 0. 5730 """ 5731 return _pywrapcp.RoutingModel_GetArcCostForVehicle(self, from_index, to_index, vehicle) 5732 5733 def CostsAreHomogeneousAcrossVehicles(self): 5734 r""" Whether costs are homogeneous across all vehicles.""" 5735 return _pywrapcp.RoutingModel_CostsAreHomogeneousAcrossVehicles(self) 5736 5737 def GetHomogeneousCost(self, from_index, to_index): 5738 r""" 5739 Returns the cost of the segment between two nodes supposing all vehicle 5740 costs are the same (returns the cost for the first vehicle otherwise). 5741 """ 5742 return _pywrapcp.RoutingModel_GetHomogeneousCost(self, from_index, to_index) 5743 5744 def GetArcCostForFirstSolution(self, from_index, to_index): 5745 r""" 5746 Returns the cost of the arc in the context of the first solution strategy. 5747 This is typically a simplification of the actual cost; see the .cc. 5748 """ 5749 return _pywrapcp.RoutingModel_GetArcCostForFirstSolution(self, from_index, to_index) 5750 5751 def GetArcCostForClass(self, from_index, to_index, cost_class_index): 5752 r""" 5753 Returns the cost of the segment between two nodes for a given cost 5754 class. Input are variable indices of nodes and the cost class. 5755 Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the 5756 returned cost won't necessarily be zero: only some of the components 5757 of the cost that depend on the cost class will be omited. See the code 5758 for details. 5759 """ 5760 return _pywrapcp.RoutingModel_GetArcCostForClass(self, from_index, to_index, cost_class_index) 5761 5762 def GetCostClassIndexOfVehicle(self, vehicle): 5763 r""" Get the cost class index of the given vehicle.""" 5764 return _pywrapcp.RoutingModel_GetCostClassIndexOfVehicle(self, vehicle) 5765 5766 def HasVehicleWithCostClassIndex(self, cost_class_index): 5767 r""" 5768 Returns true iff the model contains a vehicle with the given 5769 cost_class_index. 5770 """ 5771 return _pywrapcp.RoutingModel_HasVehicleWithCostClassIndex(self, cost_class_index) 5772 5773 def GetCostClassesCount(self): 5774 r""" Returns the number of different cost classes in the model.""" 5775 return _pywrapcp.RoutingModel_GetCostClassesCount(self) 5776 5777 def GetNonZeroCostClassesCount(self): 5778 r""" Ditto, minus the 'always zero', built-in cost class.""" 5779 return _pywrapcp.RoutingModel_GetNonZeroCostClassesCount(self) 5780 5781 def GetVehicleClassIndexOfVehicle(self, vehicle): 5782 return _pywrapcp.RoutingModel_GetVehicleClassIndexOfVehicle(self, vehicle) 5783 5784 def GetVehicleOfClass(self, vehicle_class): 5785 r""" 5786 Returns a vehicle of the given vehicle class, and -1 if there are no 5787 vehicles for this class. 5788 """ 5789 return _pywrapcp.RoutingModel_GetVehicleOfClass(self, vehicle_class) 5790 5791 def GetVehicleClassesCount(self): 5792 r""" Returns the number of different vehicle classes in the model.""" 5793 return _pywrapcp.RoutingModel_GetVehicleClassesCount(self) 5794 5795 def GetSameVehicleIndicesOfIndex(self, node): 5796 r""" Returns variable indices of nodes constrained to be on the same route.""" 5797 return _pywrapcp.RoutingModel_GetSameVehicleIndicesOfIndex(self, node) 5798 5799 def GetVehicleTypeContainer(self): 5800 return _pywrapcp.RoutingModel_GetVehicleTypeContainer(self) 5801 5802 def ArcIsMoreConstrainedThanArc(self, _from, to1, to2): 5803 r""" 5804 Returns whether the arc from->to1 is more constrained than from->to2, 5805 taking into account, in order: 5806 - whether the destination node isn't an end node 5807 - whether the destination node is mandatory 5808 - whether the destination node is bound to the same vehicle as the source 5809 - the "primary constrained" dimension (see SetPrimaryConstrainedDimension) 5810 It then breaks ties using, in order: 5811 - the arc cost (taking unperformed penalties into account) 5812 - the size of the vehicle vars of "to1" and "to2" (lowest size wins) 5813 - the value: the lowest value of the indices to1 and to2 wins. 5814 See the .cc for details. 5815 The more constrained arc is typically preferable when building a 5816 first solution. This method is intended to be used as a callback for the 5817 BestValueByComparisonSelector value selector. 5818 Args: 5819 from: the variable index of the source node 5820 to1: the variable index of the first candidate destination node. 5821 to2: the variable index of the second candidate destination node. 5822 """ 5823 return _pywrapcp.RoutingModel_ArcIsMoreConstrainedThanArc(self, _from, to1, to2) 5824 5825 def DebugOutputAssignment(self, solution_assignment, dimension_to_print): 5826 r""" 5827 Print some debugging information about an assignment, including the 5828 feasible intervals of the CumulVar for dimension "dimension_to_print" 5829 at each step of the routes. 5830 If "dimension_to_print" is omitted, all dimensions will be printed. 5831 """ 5832 return _pywrapcp.RoutingModel_DebugOutputAssignment(self, solution_assignment, dimension_to_print) 5833 5834 def CheckIfAssignmentIsFeasible(self, assignment, call_at_solution_monitors): 5835 r""" 5836 Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair 5837 containing the minimum and maximum of the CumulVar of the jth node on 5838 route i. 5839 - cumul_bounds[i][j].first is the minimum. 5840 - cumul_bounds[i][j].second is the maximum. 5841 Checks if an assignment is feasible. 5842 """ 5843 return _pywrapcp.RoutingModel_CheckIfAssignmentIsFeasible(self, assignment, call_at_solution_monitors) 5844 5845 def solver(self): 5846 r""" 5847 Returns the underlying constraint solver. Can be used to add extra 5848 constraints and/or modify search algorithms. 5849 """ 5850 return _pywrapcp.RoutingModel_solver(self) 5851 5852 def CheckLimit(self, *args): 5853 r""" 5854 Returns true if the search limit has been crossed with the given time 5855 offset. 5856 """ 5857 return _pywrapcp.RoutingModel_CheckLimit(self, *args) 5858 5859 def RemainingTime(self): 5860 r""" Returns the time left in the search limit.""" 5861 return _pywrapcp.RoutingModel_RemainingTime(self) 5862 5863 def UpdateTimeLimit(self, time_limit): 5864 r""" Updates the time limit of the search limit.""" 5865 return _pywrapcp.RoutingModel_UpdateTimeLimit(self, time_limit) 5866 5867 def TimeBuffer(self): 5868 r""" Returns the time buffer to safely return a solution.""" 5869 return _pywrapcp.RoutingModel_TimeBuffer(self) 5870 5871 def GetMutableCPSatInterrupt(self): 5872 r""" Returns the atomic<bool> to stop the CP-SAT solver.""" 5873 return _pywrapcp.RoutingModel_GetMutableCPSatInterrupt(self) 5874 5875 def GetMutableCPInterrupt(self): 5876 r""" Returns the atomic<bool> to stop the CP solver.""" 5877 return _pywrapcp.RoutingModel_GetMutableCPInterrupt(self) 5878 5879 def CancelSearch(self): 5880 r""" Cancels the current search.""" 5881 return _pywrapcp.RoutingModel_CancelSearch(self) 5882 5883 def nodes(self): 5884 r""" 5885 Sizes and indices 5886 Returns the number of nodes in the model. 5887 """ 5888 return _pywrapcp.RoutingModel_nodes(self) 5889 5890 def vehicles(self): 5891 r""" Returns the number of vehicle routes in the model.""" 5892 return _pywrapcp.RoutingModel_vehicles(self) 5893 5894 def Size(self): 5895 r""" Returns the number of next variables in the model.""" 5896 return _pywrapcp.RoutingModel_Size(self) 5897 5898 def GetNumberOfDecisionsInFirstSolution(self, search_parameters): 5899 r""" 5900 Returns statistics on first solution search, number of decisions sent to 5901 filters, number of decisions rejected by filters. 5902 """ 5903 return _pywrapcp.RoutingModel_GetNumberOfDecisionsInFirstSolution(self, search_parameters) 5904 5905 def GetNumberOfRejectsInFirstSolution(self, search_parameters): 5906 return _pywrapcp.RoutingModel_GetNumberOfRejectsInFirstSolution(self, search_parameters) 5907 5908 def GetAutomaticFirstSolutionStrategy(self): 5909 r""" Returns the automatic first solution strategy selected.""" 5910 return _pywrapcp.RoutingModel_GetAutomaticFirstSolutionStrategy(self) 5911 5912 def IsMatchingModel(self): 5913 r""" Returns true if a vehicle/node matching problem is detected.""" 5914 return _pywrapcp.RoutingModel_IsMatchingModel(self) 5915 5916 def AreRoutesInterdependent(self, parameters): 5917 r""" 5918 Returns true if routes are interdependent. This means that any 5919 modification to a route might impact another. 5920 """ 5921 return _pywrapcp.RoutingModel_AreRoutesInterdependent(self, parameters) 5922 5923 def MakeGuidedSlackFinalizer(self, dimension, initializer): 5924 r""" 5925 The next few members are in the public section only for testing purposes. 5926 5927 MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a 5928 dimension using a callback to choose which values to start with. 5929 The finalizer works only when all next variables in the model have 5930 been fixed. It has the following two characteristics: 5931 1. It follows the routes defined by the nexts variables when choosing a 5932 variable to make a decision on. 5933 2. When it comes to choose a value for the slack of node i, the decision 5934 builder first calls the callback with argument i, and supposingly the 5935 returned value is x it creates decisions slack[i] = x, slack[i] = x + 5936 1, slack[i] = x - 1, slack[i] = x + 2, etc. 5937 """ 5938 return _pywrapcp.RoutingModel_MakeGuidedSlackFinalizer(self, dimension, initializer) 5939 5940 def MakeSelfDependentDimensionFinalizer(self, dimension): 5941 r""" 5942 MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a 5943 self-dependent dimension. It makes an extensive use of the caches of the 5944 state dependent transits. 5945 In detail, MakeSelfDependentDimensionFinalizer returns a composition of a 5946 local search decision builder with a greedy descent operator for the cumul 5947 of the start of each route and a guided slack finalizer. Provided there 5948 are no time windows and the maximum slacks are large enough, once the 5949 cumul of the start of route is fixed, the guided finalizer can find 5950 optimal values of the slacks for the rest of the route in time 5951 proportional to the length of the route. Therefore the composed finalizer 5952 generally works in time O(log(t)*n*m), where t is the latest possible 5953 departute time, n is the number of nodes in the network and m is the 5954 number of vehicles. 5955 """ 5956 return _pywrapcp.RoutingModel_MakeSelfDependentDimensionFinalizer(self, dimension) 5957 5958 def GetPathsMetadata(self): 5959 return _pywrapcp.RoutingModel_GetPathsMetadata(self)
thisown
4640 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED =
2
Problem solved successfully after calling RoutingModel::Solve(), except that a local optimum has not been reached. Leaving more time would allow improving the solution.
def
RegisterUnaryTransitVector(self, values):
4676 def RegisterUnaryTransitVector(self, values): 4677 r""" 4678 Registers 'callback' and returns its index. 4679 The sign parameter allows to notify the solver that the callback only 4680 return values of the given sign. This can help the solver, but passing 4681 an incorrect sign may crash in non-opt compilation mode, and yield 4682 incorrect results in opt. 4683 """ 4684 return _pywrapcp.RoutingModel_RegisterUnaryTransitVector(self, values)
Registers 'callback' and returns its index. The sign parameter allows to notify the solver that the callback only return values of the given sign. This can help the solver, but passing an incorrect sign may crash in non-opt compilation mode, and yield incorrect results in opt.
def
AddDimension( self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name):
4701 def AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name): 4702 r""" 4703 Model creation 4704 Methods to add dimensions to routes; dimensions represent quantities 4705 accumulated at nodes along the routes. They represent quantities such as 4706 weights or volumes carried along the route, or distance or times. 4707 Quantities at a node are represented by "cumul" variables and the increase 4708 or decrease of quantities between nodes are represented by "transit" 4709 variables. These variables are linked as follows: 4710 if j == next(i), cumul(j) = cumul(i) + transit(i, j) + slack(i) 4711 where slack is a positive slack variable (can represent waiting times for 4712 a time dimension). 4713 Setting the value of fix_start_cumul_to_zero to true will force the 4714 "cumul" variable of the start node of all vehicles to be equal to 0. 4715 Creates a dimension where the transit variable is constrained to be 4716 equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the 4717 slack variable and 'capacity' is the upper bound of the cumul variables. 4718 'name' is the name used to reference the dimension; this name is used to 4719 get cumul and transit variables from the routing model. 4720 Returns false if a dimension with the same name has already been created 4721 (and doesn't create the new dimension). 4722 Takes ownership of the callback 'evaluator'. 4723 """ 4724 return _pywrapcp.RoutingModel_AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name)
Model creation Methods to add dimensions to routes; dimensions represent quantities accumulated at nodes along the routes. They represent quantities such as weights or volumes carried along the route, or distance or times. Quantities at a node are represented by "cumul" variables and the increase or decrease of quantities between nodes are represented by "transit" variables. These variables are linked as follows: if j == next(i), cumul(j) = cumul(i) + transit(i, j) + slack(i) where slack is a positive slack variable (can represent waiting times for a time dimension). Setting the value of fix_start_cumul_to_zero to true will force the "cumul" variable of the start node of all vehicles to be equal to 0. Creates a dimension where the transit variable is constrained to be equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the slack variable and 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns false if a dimension with the same name has already been created (and doesn't create the new dimension). Takes ownership of the callback 'evaluator'.
def
AddDimensionWithVehicleTransits( self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name):
def
AddDimensionWithVehicleCapacity( self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name):
def
AddDimensionWithVehicleTransitAndCapacity( self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name):
4732 def AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name): 4733 return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)
def
AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name):
4735 def AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name): 4736 r""" 4737 Creates a dimension where the transit variable is constrained to be 4738 equal to 'value'; 'capacity' is the upper bound of the cumul variables. 4739 'name' is the name used to reference the dimension; this name is used to 4740 get cumul and transit variables from the routing model. 4741 Returns a pair consisting of an index to the registered unary transit 4742 callback and a bool denoting whether the dimension has been created. 4743 It is false if a dimension with the same name has already been created 4744 (and doesn't create the new dimension but still register a new callback). 4745 """ 4746 return _pywrapcp.RoutingModel_AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name)
Creates a dimension where the transit variable is constrained to be equal to 'value'; 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns a pair consisting of an index to the registered unary transit callback and a bool denoting whether the dimension has been created. It is false if a dimension with the same name has already been created (and doesn't create the new dimension but still register a new callback).
def
AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name):
4751 def AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name): 4752 r""" 4753 Creates a dimension where the transit variable is constrained to be 4754 equal to 'values[i]' for node i; 'capacity' is the upper bound of 4755 the cumul variables. 'name' is the name used to reference the dimension; 4756 this name is used to get cumul and transit variables from the routing 4757 model. 4758 Returns a pair consisting of an index to the registered unary transit 4759 callback and a bool denoting whether the dimension has been created. 4760 It is false if a dimension with the same name has already been created 4761 (and doesn't create the new dimension but still register a new callback). 4762 """ 4763 return _pywrapcp.RoutingModel_AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name)
Creates a dimension where the transit variable is constrained to be equal to 'values[i]' for node i; 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns a pair consisting of an index to the registered unary transit callback and a bool denoting whether the dimension has been created. It is false if a dimension with the same name has already been created (and doesn't create the new dimension but still register a new callback).
def
AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name):
4765 def AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name): 4766 r""" 4767 Creates a dimension where the transit variable is constrained to be 4768 equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of 4769 the cumul variables. 'name' is the name used to reference the dimension; 4770 this name is used to get cumul and transit variables from the routing 4771 model. 4772 Returns a pair consisting of an index to the registered transit callback 4773 and a bool denoting whether the dimension has been created. 4774 It is false if a dimension with the same name has already been created 4775 (and doesn't create the new dimension but still register a new callback). 4776 """ 4777 return _pywrapcp.RoutingModel_AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name)
Creates a dimension where the transit variable is constrained to be equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns a pair consisting of an index to the registered transit callback and a bool denoting whether the dimension has been created. It is false if a dimension with the same name has already been created (and doesn't create the new dimension but still register a new callback).
def
GetAllDimensionNames(self):
4779 def GetAllDimensionNames(self): 4780 r""" Outputs the names of all dimensions added to the routing engine.""" 4781 return _pywrapcp.RoutingModel_GetAllDimensionNames(self)
Outputs the names of all dimensions added to the routing engine.
def
GetDimensions(self):
4783 def GetDimensions(self): 4784 r""" Returns all dimensions of the model.""" 4785 return _pywrapcp.RoutingModel_GetDimensions(self)
Returns all dimensions of the model.
def
GetDimensionsWithSoftOrSpanCosts(self):
4787 def GetDimensionsWithSoftOrSpanCosts(self): 4788 r""" Returns dimensions with soft or vehicle span costs.""" 4789 return _pywrapcp.RoutingModel_GetDimensionsWithSoftOrSpanCosts(self)
Returns dimensions with soft or vehicle span costs.
def
GetUnaryDimensions(self):
4791 def GetUnaryDimensions(self): 4792 r""" Returns dimensions for which all transit evaluators are unary.""" 4793 return _pywrapcp.RoutingModel_GetUnaryDimensions(self)
Returns dimensions for which all transit evaluators are unary.
def
GetDimensionsWithGlobalCumulOptimizers(self):
4795 def GetDimensionsWithGlobalCumulOptimizers(self): 4796 r""" Returns the dimensions which have [global|local]_dimension_optimizers_.""" 4797 return _pywrapcp.RoutingModel_GetDimensionsWithGlobalCumulOptimizers(self)
Returns the dimensions which have [global|local]_dimension_optimizers_.
def
HasGlobalCumulOptimizer(self, dimension):
4802 def HasGlobalCumulOptimizer(self, dimension): 4803 r""" Returns whether the given dimension has global/local cumul optimizers.""" 4804 return _pywrapcp.RoutingModel_HasGlobalCumulOptimizer(self, dimension)
Returns whether the given dimension has global/local cumul optimizers.
def
GetMutableGlobalCumulLPOptimizer(self, dimension):
4809 def GetMutableGlobalCumulLPOptimizer(self, dimension): 4810 r""" 4811 Returns the global/local dimension cumul optimizer for a given dimension, 4812 or nullptr if there is none. 4813 """ 4814 return _pywrapcp.RoutingModel_GetMutableGlobalCumulLPOptimizer(self, dimension)
Returns the global/local dimension cumul optimizer for a given dimension, or nullptr if there is none.
def
HasDimension(self, dimension_name):
4825 def HasDimension(self, dimension_name): 4826 r""" Returns true if a dimension exists for a given dimension name.""" 4827 return _pywrapcp.RoutingModel_HasDimension(self, dimension_name)
Returns true if a dimension exists for a given dimension name.
def
GetDimensionOrDie(self, dimension_name):
4829 def GetDimensionOrDie(self, dimension_name): 4830 r""" Returns a dimension from its name. Dies if the dimension does not exist.""" 4831 return _pywrapcp.RoutingModel_GetDimensionOrDie(self, dimension_name)
Returns a dimension from its name. Dies if the dimension does not exist.
def
GetMutableDimension(self, dimension_name):
4833 def GetMutableDimension(self, dimension_name): 4834 r""" 4835 Returns a dimension from its name. Returns nullptr if the dimension does 4836 not exist. 4837 """ 4838 return _pywrapcp.RoutingModel_GetMutableDimension(self, dimension_name)
Returns a dimension from its name. Returns nullptr if the dimension does not exist.
def
SetPrimaryConstrainedDimension(self, dimension_name):
4840 def SetPrimaryConstrainedDimension(self, dimension_name): 4841 r""" 4842 Set the given dimension as "primary constrained". As of August 2013, this 4843 is only used by ArcIsMoreConstrainedThanArc(). 4844 "dimension" must be the name of an existing dimension, or be empty, in 4845 which case there will not be a primary dimension after this call. 4846 """ 4847 return _pywrapcp.RoutingModel_SetPrimaryConstrainedDimension(self, dimension_name)
Set the given dimension as "primary constrained". As of August 2013, this is only used by ArcIsMoreConstrainedThanArc(). "dimension" must be the name of an existing dimension, or be empty, in which case there will not be a primary dimension after this call.
def
GetPrimaryConstrainedDimension(self):
4849 def GetPrimaryConstrainedDimension(self): 4850 r""" Get the primary constrained dimension, or an empty string if it is unset.""" 4851 return _pywrapcp.RoutingModel_GetPrimaryConstrainedDimension(self)
Get the primary constrained dimension, or an empty string if it is unset.
def
GetDimensionResourceGroupIndices(self, dimension):
4856 def GetDimensionResourceGroupIndices(self, dimension): 4857 r""" 4858 Returns the indices of resource groups for this dimension. This method can 4859 only be called after the model has been closed. 4860 """ 4861 return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndices(self, dimension)
Returns the indices of resource groups for this dimension. This method can only be called after the model has been closed.
def
GetDimensionResourceGroupIndex(self, dimension):
4863 def GetDimensionResourceGroupIndex(self, dimension): 4864 r""" 4865 Returns the index of the resource group attached to the dimension. 4866 DCHECKS that there's exactly one resource group for this dimension. 4867 """ 4868 return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndex(self, dimension)
Returns the index of the resource group attached to the dimension. DCHECKS that there's exactly one resource group for this dimension.
def
AddDisjunction(self, *args):
4870 def AddDisjunction(self, *args): 4871 r""" 4872 Adds a disjunction constraint on the indices: exactly 'max_cardinality' of 4873 the indices are active. Start and end indices of any vehicle cannot be 4874 part of a disjunction. 4875 4876 If a penalty is given, at most 'max_cardinality' of the indices can be 4877 active, and if less are active, 'penalty' is payed per inactive index. 4878 This is equivalent to adding the constraint: 4879 p + Sum(i)active[i] == max_cardinality 4880 where p is an integer variable, and the following cost to the cost 4881 function: 4882 p * penalty. 4883 'penalty' must be positive to make the disjunction optional; a negative 4884 penalty will force 'max_cardinality' indices of the disjunction to be 4885 performed, and therefore p == 0. 4886 Note: passing a vector with a single index will model an optional index 4887 with a penalty cost if it is not visited. 4888 """ 4889 return _pywrapcp.RoutingModel_AddDisjunction(self, *args)
Adds a disjunction constraint on the indices: exactly 'max_cardinality' of the indices are active. Start and end indices of any vehicle cannot be part of a disjunction.
If a penalty is given, at most 'max_cardinality' of the indices can be active, and if less are active, 'penalty' is payed per inactive index.
This is equivalent to adding the constraint:
p + Sum(i)active[i] == max_cardinality
where p is an integer variable, and the following cost to the cost function: p * penalty. 'penalty' must be positive to make the disjunction optional; a negative penalty will force 'max_cardinality' indices of the disjunction to be performed, and therefore p == 0. Note: passing a vector with a single index will model an optional index with a penalty cost if it is not visited.
def
GetDisjunctionIndices(self, index):
4891 def GetDisjunctionIndices(self, index): 4892 r""" Returns the indices of the disjunctions to which an index belongs.""" 4893 return _pywrapcp.RoutingModel_GetDisjunctionIndices(self, index)
Returns the indices of the disjunctions to which an index belongs.
def
GetDisjunctionPenalty(self, index):
4895 def GetDisjunctionPenalty(self, index): 4896 r""" Returns the penalty of the node disjunction of index 'index'.""" 4897 return _pywrapcp.RoutingModel_GetDisjunctionPenalty(self, index)
Returns the penalty of the node disjunction of index 'index'.
def
GetDisjunctionMaxCardinality(self, index):
4899 def GetDisjunctionMaxCardinality(self, index): 4900 r""" 4901 Returns the maximum number of possible active nodes of the node 4902 disjunction of index 'index'. 4903 """ 4904 return _pywrapcp.RoutingModel_GetDisjunctionMaxCardinality(self, index)
Returns the maximum number of possible active nodes of the node disjunction of index 'index'.
def
GetNumberOfDisjunctions(self):
4906 def GetNumberOfDisjunctions(self): 4907 r""" Returns the number of node disjunctions in the model.""" 4908 return _pywrapcp.RoutingModel_GetNumberOfDisjunctions(self)
Returns the number of node disjunctions in the model.
def
HasMandatoryDisjunctions(self):
4910 def HasMandatoryDisjunctions(self): 4911 r""" 4912 Returns true if the model contains mandatory disjunctions (ones with 4913 kNoPenalty as penalty). 4914 """ 4915 return _pywrapcp.RoutingModel_HasMandatoryDisjunctions(self)
Returns true if the model contains mandatory disjunctions (ones with kNoPenalty as penalty).
def
HasMaxCardinalityConstrainedDisjunctions(self):
4917 def HasMaxCardinalityConstrainedDisjunctions(self): 4918 r""" 4919 Returns true if the model contains at least one disjunction which is 4920 constrained by its max_cardinality. 4921 """ 4922 return _pywrapcp.RoutingModel_HasMaxCardinalityConstrainedDisjunctions(self)
Returns true if the model contains at least one disjunction which is constrained by its max_cardinality.
def
GetPerfectBinaryDisjunctions(self):
4924 def GetPerfectBinaryDisjunctions(self): 4925 r""" 4926 Returns the list of all perfect binary disjunctions, as pairs of variable 4927 indices: a disjunction is "perfect" when its variables do not appear in 4928 any other disjunction. Each pair is sorted (lowest variable index first), 4929 and the output vector is also sorted (lowest pairs first). 4930 """ 4931 return _pywrapcp.RoutingModel_GetPerfectBinaryDisjunctions(self)
Returns the list of all perfect binary disjunctions, as pairs of variable indices: a disjunction is "perfect" when its variables do not appear in any other disjunction. Each pair is sorted (lowest variable index first), and the output vector is also sorted (lowest pairs first).
def
IgnoreDisjunctionsAlreadyForcedToZero(self):
4933 def IgnoreDisjunctionsAlreadyForcedToZero(self): 4934 r""" 4935 SPECIAL: Makes the solver ignore all the disjunctions whose active 4936 variables are all trivially zero (i.e. Max() == 0), by setting their 4937 max_cardinality to 0. 4938 This can be useful when using the BaseBinaryDisjunctionNeighborhood 4939 operators, in the context of arc-based routing. 4940 """ 4941 return _pywrapcp.RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero(self)
SPECIAL: Makes the solver ignore all the disjunctions whose active variables are all trivially zero (i.e. Max() == 0), by setting their max_cardinality to 0. This can be useful when using the BaseBinaryDisjunctionNeighborhood operators, in the context of arc-based routing.
def
AddSoftSameVehicleConstraint(self, indices, cost):
4943 def AddSoftSameVehicleConstraint(self, indices, cost): 4944 r""" 4945 Adds a soft constraint to force a set of variable indices to be on the 4946 same vehicle. If all nodes are not on the same vehicle, each extra vehicle 4947 used adds 'cost' to the cost function. 4948 """ 4949 return _pywrapcp.RoutingModel_AddSoftSameVehicleConstraint(self, indices, cost)
Adds a soft constraint to force a set of variable indices to be on the same vehicle. If all nodes are not on the same vehicle, each extra vehicle used adds 'cost' to the cost function.
def
SetAllowedVehiclesForIndex(self, vehicles, index):
4951 def SetAllowedVehiclesForIndex(self, vehicles, index): 4952 r""" 4953 Sets the vehicles which can visit a given node. If the node is in a 4954 disjunction, this will not prevent it from being unperformed. 4955 Specifying an empty vector of vehicles has no effect (all vehicles 4956 will be allowed to visit the node). 4957 """ 4958 return _pywrapcp.RoutingModel_SetAllowedVehiclesForIndex(self, vehicles, index)
Sets the vehicles which can visit a given node. If the node is in a disjunction, this will not prevent it from being unperformed. Specifying an empty vector of vehicles has no effect (all vehicles will be allowed to visit the node).
def
IsVehicleAllowedForIndex(self, vehicle, index):
4960 def IsVehicleAllowedForIndex(self, vehicle, index): 4961 r""" Returns true if a vehicle is allowed to visit a given node.""" 4962 return _pywrapcp.RoutingModel_IsVehicleAllowedForIndex(self, vehicle, index)
Returns true if a vehicle is allowed to visit a given node.
def
AddPickupAndDelivery(self, pickup, delivery):
4964 def AddPickupAndDelivery(self, pickup, delivery): 4965 r""" 4966 Notifies that index1 and index2 form a pair of nodes which should belong 4967 to the same route. This methods helps the search find better solutions, 4968 especially in the local search phase. 4969 It should be called each time you have an equality constraint linking 4970 the vehicle variables of two node (including for instance pickup and 4971 delivery problems): 4972 Solver* const solver = routing.solver(); 4973 int64_t index1 = manager.NodeToIndex(node1); 4974 int64_t index2 = manager.NodeToIndex(node2); 4975 solver->AddConstraint(solver->MakeEquality( 4976 routing.VehicleVar(index1), 4977 routing.VehicleVar(index2))); 4978 routing.AddPickupAndDelivery(index1, index2); 4979 """ 4980 return _pywrapcp.RoutingModel_AddPickupAndDelivery(self, pickup, delivery)
Notifies that index1 and index2 form a pair of nodes which should belong to the same route. This methods helps the search find better solutions, especially in the local search phase. It should be called each time you have an equality constraint linking the vehicle variables of two node (including for instance pickup and delivery problems): Solver* const solver = routing.solver(); int64_t index1 = manager.NodeToIndex(node1); int64_t index2 = manager.NodeToIndex(node2); solver->AddConstraint(solver->MakeEquality( routing.VehicleVar(index1), routing.VehicleVar(index2))); routing.AddPickupAndDelivery(index1, index2);
def
AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction):
4982 def AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction): 4983 r""" 4984 Same as AddPickupAndDelivery but notifying that the performed node from 4985 the disjunction of index 'pickup_disjunction' is on the same route as the 4986 performed node from the disjunction of index 'delivery_disjunction'. 4987 """ 4988 return _pywrapcp.RoutingModel_AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction)
Same as AddPickupAndDelivery but notifying that the performed node from the disjunction of index 'pickup_disjunction' is on the same route as the performed node from the disjunction of index 'delivery_disjunction'.
def
GetPickupPositions(self, node_index):
4990 def GetPickupPositions(self, node_index): 4991 r""" Returns the pickup and delivery positions where the node is a pickup.""" 4992 return _pywrapcp.RoutingModel_GetPickupPositions(self, node_index)
Returns the pickup and delivery positions where the node is a pickup.
def
GetDeliveryPositions(self, node_index):
4994 def GetDeliveryPositions(self, node_index): 4995 r""" Returns the pickup and delivery positions where the node is a delivery.""" 4996 return _pywrapcp.RoutingModel_GetDeliveryPositions(self, node_index)
Returns the pickup and delivery positions where the node is a delivery.
def
IsPickup(self, node_index):
4998 def IsPickup(self, node_index): 4999 r""" Returns whether the node is a pickup (resp. delivery).""" 5000 return _pywrapcp.RoutingModel_IsPickup(self, node_index)
Returns whether the node is a pickup (resp. delivery).
def
SetPickupAndDeliveryPolicyOfAllVehicles(self, policy):
5005 def SetPickupAndDeliveryPolicyOfAllVehicles(self, policy): 5006 r""" 5007 Sets the Pickup and delivery policy of all vehicles. It is equivalent to 5008 calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles. 5009 """ 5010 return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles(self, policy)
Sets the Pickup and delivery policy of all vehicles. It is equivalent to calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles.
def
GetNumOfSingletonNodes(self):
5018 def GetNumOfSingletonNodes(self): 5019 r""" 5020 Returns the number of non-start/end nodes which do not appear in a 5021 pickup/delivery pair. 5022 """ 5023 return _pywrapcp.RoutingModel_GetNumOfSingletonNodes(self)
Returns the number of non-start/end nodes which do not appear in a pickup/delivery pair.
ADDED_TYPE_REMOVED_FROM_VEHICLE =
1
When visited, one instance of type 'T' previously added to the route (TYPE_ADDED_TO_VEHICLE), if any, is removed from the vehicle. If the type was not previously added to the route or all added instances have already been removed, this visit has no effect on the types.
TYPE_ON_VEHICLE_UP_TO_VISIT =
2
With the following policy, the visit enforces that type 'T' is considered on the route from its start until this node is visited.
TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED =
3
The visit doesn't have an impact on the number of types 'T' on the route, as it's (virtually) added and removed directly. This policy can be used for visits which are part of an incompatibility or requirement set without affecting the type count on the route.
def
CloseVisitTypes(self):
5061 def CloseVisitTypes(self): 5062 r""" 5063 This function should be called once all node visit types have been set and 5064 prior to adding any incompatibilities/requirements. 5065 "close" types. 5066 """ 5067 return _pywrapcp.RoutingModel_CloseVisitTypes(self)
This function should be called once all node visit types have been set and prior to adding any incompatibilities/requirements. "close" types.
def
AddHardTypeIncompatibility(self, type1, type2):
5072 def AddHardTypeIncompatibility(self, type1, type2): 5073 r""" 5074 Incompatibilities: 5075 Two nodes with "hard" incompatible types cannot share the same route at 5076 all, while with a "temporal" incompatibility they can't be on the same 5077 route at the same time. 5078 """ 5079 return _pywrapcp.RoutingModel_AddHardTypeIncompatibility(self, type1, type2)
Incompatibilities: Two nodes with "hard" incompatible types cannot share the same route at all, while with a "temporal" incompatibility they can't be on the same route at the same time.
def
GetHardTypeIncompatibilitiesOfType(self, type):
5084 def GetHardTypeIncompatibilitiesOfType(self, type): 5085 r""" Returns visit types incompatible with a given type.""" 5086 return _pywrapcp.RoutingModel_GetHardTypeIncompatibilitiesOfType(self, type)
Returns visit types incompatible with a given type.
def
HasHardTypeIncompatibilities(self):
5091 def HasHardTypeIncompatibilities(self): 5092 r""" 5093 Returns true iff any hard (resp. temporal) type incompatibilities have 5094 been added to the model. 5095 """ 5096 return _pywrapcp.RoutingModel_HasHardTypeIncompatibilities(self)
Returns true iff any hard (resp. temporal) type incompatibilities have been added to the model.
def
AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives):
5101 def AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives): 5102 r""" 5103 Requirements: 5104 NOTE: As of 2019-04, cycles in the requirement graph are not supported, 5105 and lead to the dependent nodes being skipped if possible (otherwise 5106 the model is considered infeasible). 5107 The following functions specify that "dependent_type" requires at least 5108 one of the types in "required_type_alternatives". 5109 5110 For same-vehicle requirements, a node of dependent type type_D requires at 5111 least one node of type type_R among the required alternatives on the same 5112 route. 5113 """ 5114 return _pywrapcp.RoutingModel_AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives)
Requirements: NOTE: As of 2019-04, cycles in the requirement graph are not supported, and lead to the dependent nodes being skipped if possible (otherwise the model is considered infeasible). The following functions specify that "dependent_type" requires at least one of the types in "required_type_alternatives".
For same-vehicle requirements, a node of dependent type type_D requires at least one node of type type_R among the required alternatives on the same route.
def
AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives):
5116 def AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives): 5117 r""" 5118 If type_D depends on type_R when adding type_D, any node_D of type_D and 5119 VisitTypePolicy TYPE_ADDED_TO_VEHICLE or 5120 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its 5121 vehicle at the time node_D is visited. 5122 """ 5123 return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives)
If type_D depends on type_R when adding type_D, any node_D of type_D and VisitTypePolicy TYPE_ADDED_TO_VEHICLE or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its vehicle at the time node_D is visited.
def
AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives):
5125 def AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives): 5126 r""" 5127 The following requirements apply when visiting dependent nodes that remove 5128 their type from the route, i.e. type_R must be on the vehicle when type_D 5129 of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE, 5130 TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is 5131 visited. 5132 """ 5133 return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives)
The following requirements apply when visiting dependent nodes that remove their type from the route, i.e. type_R must be on the vehicle when type_D of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is visited.
def
GetSameVehicleRequiredTypeAlternativesOfType(self, type):
5135 def GetSameVehicleRequiredTypeAlternativesOfType(self, type): 5136 r""" 5137 Returns the set of same-vehicle requirement alternatives for the given 5138 type. 5139 """ 5140 return _pywrapcp.RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType(self, type)
Returns the set of same-vehicle requirement alternatives for the given type.
def
GetRequiredTypeAlternativesWhenAddingType(self, type):
5142 def GetRequiredTypeAlternativesWhenAddingType(self, type): 5143 r""" Returns the set of requirement alternatives when adding the given type.""" 5144 return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenAddingType(self, type)
Returns the set of requirement alternatives when adding the given type.
def
GetRequiredTypeAlternativesWhenRemovingType(self, type):
5146 def GetRequiredTypeAlternativesWhenRemovingType(self, type): 5147 r""" Returns the set of requirement alternatives when removing the given type.""" 5148 return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenRemovingType(self, type)
Returns the set of requirement alternatives when removing the given type.
def
HasSameVehicleTypeRequirements(self):
5150 def HasSameVehicleTypeRequirements(self): 5151 r""" 5152 Returns true iff any same-route (resp. temporal) type requirements have 5153 been added to the model. 5154 """ 5155 return _pywrapcp.RoutingModel_HasSameVehicleTypeRequirements(self)
Returns true iff any same-route (resp. temporal) type requirements have been added to the model.
def
HasTypeRegulations(self):
5160 def HasTypeRegulations(self): 5161 r""" 5162 Returns true iff the model has any incompatibilities or requirements set 5163 on node types. 5164 """ 5165 return _pywrapcp.RoutingModel_HasTypeRegulations(self)
Returns true iff the model has any incompatibilities or requirements set on node types.
def
UnperformedPenalty(self, var_index):
5167 def UnperformedPenalty(self, var_index): 5168 r""" 5169 Get the "unperformed" penalty of a node. This is only well defined if the 5170 node is only part of a single Disjunction, and that disjunction has a 5171 penalty. For forced active nodes returns max int64_t. In all other cases, 5172 this returns 0. 5173 """ 5174 return _pywrapcp.RoutingModel_UnperformedPenalty(self, var_index)
Get the "unperformed" penalty of a node. This is only well defined if the node is only part of a single Disjunction, and that disjunction has a penalty. For forced active nodes returns max int64_t. In all other cases, this returns 0.
def
UnperformedPenaltyOrValue(self, default_value, var_index):
5176 def UnperformedPenaltyOrValue(self, default_value, var_index): 5177 r""" 5178 Same as above except that it returns default_value instead of 0 when 5179 penalty is not well defined (default value is passed as first argument to 5180 simplify the usage of the method in a callback). 5181 """ 5182 return _pywrapcp.RoutingModel_UnperformedPenaltyOrValue(self, default_value, var_index)
Same as above except that it returns default_value instead of 0 when penalty is not well defined (default value is passed as first argument to simplify the usage of the method in a callback).
def
GetDepot(self):
5184 def GetDepot(self): 5185 r""" 5186 Returns the variable index of the first starting or ending node of all 5187 routes. If all routes start and end at the same node (single depot), this 5188 is the node returned. 5189 """ 5190 return _pywrapcp.RoutingModel_GetDepot(self)
Returns the variable index of the first starting or ending node of all routes. If all routes start and end at the same node (single depot), this is the node returned.
def
SetMaximumNumberOfActiveVehicles(self, max_active_vehicles):
5192 def SetMaximumNumberOfActiveVehicles(self, max_active_vehicles): 5193 r""" 5194 Constrains the maximum number of active vehicles, aka the number of 5195 vehicles which do not have an empty route. For instance, this can be used 5196 to limit the number of routes in the case where there are fewer drivers 5197 than vehicles and that the fleet of vehicle is heterogeneous. 5198 """ 5199 return _pywrapcp.RoutingModel_SetMaximumNumberOfActiveVehicles(self, max_active_vehicles)
Constrains the maximum number of active vehicles, aka the number of vehicles which do not have an empty route. For instance, this can be used to limit the number of routes in the case where there are fewer drivers than vehicles and that the fleet of vehicle is heterogeneous.
def
GetMaximumNumberOfActiveVehicles(self):
5201 def GetMaximumNumberOfActiveVehicles(self): 5202 r""" Returns the maximum number of active vehicles.""" 5203 return _pywrapcp.RoutingModel_GetMaximumNumberOfActiveVehicles(self)
Returns the maximum number of active vehicles.
def
SetArcCostEvaluatorOfAllVehicles(self, evaluator_index):
5205 def SetArcCostEvaluatorOfAllVehicles(self, evaluator_index): 5206 r""" 5207 Sets the cost function of the model such that the cost of a segment of a 5208 route between node 'from' and 'to' is evaluator(from, to), whatever the 5209 route or vehicle performing the route. 5210 """ 5211 return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfAllVehicles(self, evaluator_index)
Sets the cost function of the model such that the cost of a segment of a route between node 'from' and 'to' is evaluator(from, to), whatever the route or vehicle performing the route.
def
SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle):
5213 def SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle): 5214 r""" Sets the cost function for a given vehicle route.""" 5215 return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle)
Sets the cost function for a given vehicle route.
def
SetFixedCostOfAllVehicles(self, cost):
5217 def SetFixedCostOfAllVehicles(self, cost): 5218 r""" 5219 Sets the fixed cost of all vehicle routes. It is equivalent to calling 5220 SetFixedCostOfVehicle on all vehicle routes. 5221 """ 5222 return _pywrapcp.RoutingModel_SetFixedCostOfAllVehicles(self, cost)
Sets the fixed cost of all vehicle routes. It is equivalent to calling SetFixedCostOfVehicle on all vehicle routes.
def
SetFixedCostOfVehicle(self, cost, vehicle):
5224 def SetFixedCostOfVehicle(self, cost, vehicle): 5225 r""" Sets the fixed cost of one vehicle route.""" 5226 return _pywrapcp.RoutingModel_SetFixedCostOfVehicle(self, cost, vehicle)
Sets the fixed cost of one vehicle route.
def
GetFixedCostOfVehicle(self, vehicle):
5228 def GetFixedCostOfVehicle(self, vehicle): 5229 r""" 5230 Returns the route fixed cost taken into account if the route of the 5231 vehicle is not empty, aka there's at least one node on the route other 5232 than the first and last nodes. 5233 """ 5234 return _pywrapcp.RoutingModel_GetFixedCostOfVehicle(self, vehicle)
Returns the route fixed cost taken into account if the route of the vehicle is not empty, aka there's at least one node on the route other than the first and last nodes.
def
SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor):
5239 def SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor): 5240 r""" 5241 The following methods set the linear and quadratic cost factors of 5242 vehicles (must be positive values). The default value of these parameters 5243 is zero for all vehicles. 5244 5245 When set, the cost_ of the model will contain terms aiming at reducing the 5246 number of vehicles used in the model, by adding the following to the 5247 objective for every vehicle v: 5248 INDICATOR(v used in the model) * 5249 [linear_cost_factor_of_vehicle_[v] 5250 - quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)] 5251 i.e. for every used vehicle, we add the linear factor as fixed cost, and 5252 subtract the square of the route length multiplied by the quadratic 5253 factor. This second term aims at making the routes as dense as possible. 5254 5255 Sets the linear and quadratic cost factor of all vehicles. 5256 """ 5257 return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor)
The following methods set the linear and quadratic cost factors of vehicles (must be positive values). The default value of these parameters is zero for all vehicles.
When set, the cost_ of the model will contain terms aiming at reducing the number of vehicles used in the model, by adding the following to the objective for every vehicle v: INDICATOR(v used in the model) * [linear_cost_factor_of_vehicle_[v]
- quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)] i.e. for every used vehicle, we add the linear factor as fixed cost, and subtract the square of the route length multiplied by the quadratic factor. This second term aims at making the routes as dense as possible.
Sets the linear and quadratic cost factor of all vehicles.
def
SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle):
5259 def SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle): 5260 r""" Sets the linear and quadratic cost factor of the given vehicle.""" 5261 return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle)
Sets the linear and quadratic cost factor of the given vehicle.
def
SetFirstSolutionEvaluator(self, evaluator):
5275 def SetFirstSolutionEvaluator(self, evaluator): 5276 r""" 5277 Gets/sets the evaluator used during the search. Only relevant when 5278 RoutingSearchParameters.first_solution_strategy = EVALUATOR_STRATEGY. 5279 Takes ownership of evaluator. 5280 """ 5281 return _pywrapcp.RoutingModel_SetFirstSolutionEvaluator(self, evaluator)
Gets/sets the evaluator used during the search. Only relevant when RoutingSearchParameters.first_solution_strategy = EVALUATOR_STRATEGY. Takes ownership of evaluator.
def
AddLocalSearchOperator(self, ls_operator):
5283 def AddLocalSearchOperator(self, ls_operator): 5284 r""" 5285 Adds a local search operator to the set of operators used to solve the 5286 vehicle routing problem. 5287 """ 5288 return _pywrapcp.RoutingModel_AddLocalSearchOperator(self, ls_operator)
Adds a local search operator to the set of operators used to solve the vehicle routing problem.
def
AddSearchMonitor(self, monitor):
5290 def AddSearchMonitor(self, monitor): 5291 r""" Adds a search monitor to the search used to solve the routing model.""" 5292 return _pywrapcp.RoutingModel_AddSearchMonitor(self, monitor)
Adds a search monitor to the search used to solve the routing model.
def
AddAtSolutionCallback(self, callback, track_unchecked_neighbors=False):
5294 def AddAtSolutionCallback(self, callback, track_unchecked_neighbors=False): 5295 r""" 5296 Adds a callback called each time a solution is found during the search. 5297 This is a shortcut to creating a monitor to call the callback on 5298 AtSolution() and adding it with AddSearchMonitor. 5299 If track_unchecked_neighbors is true, the callback will also be called on 5300 AcceptUncheckedNeighbor() events, which is useful to grab solutions 5301 obtained when solver_parameters.check_solution_period > 1 (aka fastLS). 5302 """ 5303 return _pywrapcp.RoutingModel_AddAtSolutionCallback(self, callback, track_unchecked_neighbors)
Adds a callback called each time a solution is found during the search. This is a shortcut to creating a monitor to call the callback on AtSolution() and adding it with AddSearchMonitor. If track_unchecked_neighbors is true, the callback will also be called on AcceptUncheckedNeighbor() events, which is useful to grab solutions obtained when solver_parameters.check_solution_period > 1 (aka fastLS).
def
AddVariableMinimizedByFinalizer(self, var):
5305 def AddVariableMinimizedByFinalizer(self, var): 5306 r""" 5307 Adds a variable to minimize in the solution finalizer. The solution 5308 finalizer is called each time a solution is found during the search and 5309 allows to instantiate secondary variables (such as dimension cumul 5310 variables). 5311 """ 5312 return _pywrapcp.RoutingModel_AddVariableMinimizedByFinalizer(self, var)
Adds a variable to minimize in the solution finalizer. The solution finalizer is called each time a solution is found during the search and allows to instantiate secondary variables (such as dimension cumul variables).
def
AddVariableMaximizedByFinalizer(self, var):
5314 def AddVariableMaximizedByFinalizer(self, var): 5315 r""" 5316 Adds a variable to maximize in the solution finalizer (see above for 5317 information on the solution finalizer). 5318 """ 5319 return _pywrapcp.RoutingModel_AddVariableMaximizedByFinalizer(self, var)
Adds a variable to maximize in the solution finalizer (see above for information on the solution finalizer).
def
AddWeightedVariableMinimizedByFinalizer(self, var, cost):
5321 def AddWeightedVariableMinimizedByFinalizer(self, var, cost): 5322 r""" 5323 Adds a variable to minimize in the solution finalizer, with a weighted 5324 priority: the higher the more priority it has. 5325 """ 5326 return _pywrapcp.RoutingModel_AddWeightedVariableMinimizedByFinalizer(self, var, cost)
Adds a variable to minimize in the solution finalizer, with a weighted priority: the higher the more priority it has.
def
AddWeightedVariableMaximizedByFinalizer(self, var, cost):
5328 def AddWeightedVariableMaximizedByFinalizer(self, var, cost): 5329 r""" 5330 Adds a variable to maximize in the solution finalizer, with a weighted 5331 priority: the higher the more priority it has. 5332 """ 5333 return _pywrapcp.RoutingModel_AddWeightedVariableMaximizedByFinalizer(self, var, cost)
Adds a variable to maximize in the solution finalizer, with a weighted priority: the higher the more priority it has.
def
AddVariableTargetToFinalizer(self, var, target):
5335 def AddVariableTargetToFinalizer(self, var, target): 5336 r""" 5337 Add a variable to set the closest possible to the target value in the 5338 solution finalizer. 5339 """ 5340 return _pywrapcp.RoutingModel_AddVariableTargetToFinalizer(self, var, target)
Add a variable to set the closest possible to the target value in the solution finalizer.
def
AddWeightedVariableTargetToFinalizer(self, var, target, cost):
5342 def AddWeightedVariableTargetToFinalizer(self, var, target, cost): 5343 r""" 5344 Same as above with a weighted priority: the higher the cost, the more 5345 priority it has to be set close to the target value. 5346 """ 5347 return _pywrapcp.RoutingModel_AddWeightedVariableTargetToFinalizer(self, var, target, cost)
Same as above with a weighted priority: the higher the cost, the more priority it has to be set close to the target value.
def
CloseModel(self):
5349 def CloseModel(self): 5350 r""" 5351 Closes the current routing model; after this method is called, no 5352 modification to the model can be done, but RoutesToAssignment becomes 5353 available. Note that CloseModel() is automatically called by Solve() and 5354 other methods that produce solution. 5355 This is equivalent to calling 5356 CloseModelWithParameters(DefaultRoutingSearchParameters()). 5357 """ 5358 return _pywrapcp.RoutingModel_CloseModel(self)
Closes the current routing model; after this method is called, no modification to the model can be done, but RoutesToAssignment becomes available. Note that CloseModel() is automatically called by Solve() and other methods that produce solution. This is equivalent to calling CloseModelWithParameters(DefaultRoutingSearchParameters()).
def
CloseModelWithParameters(self, search_parameters):
5360 def CloseModelWithParameters(self, search_parameters): 5361 r""" 5362 Same as above taking search parameters (as of 10/2015 some the parameters 5363 have to be set when closing the model). 5364 """ 5365 return _pywrapcp.RoutingModel_CloseModelWithParameters(self, search_parameters)
Same as above taking search parameters (as of 10/2015 some the parameters have to be set when closing the model).
def
Solve(self, assignment=None):
5367 def Solve(self, assignment=None): 5368 r""" 5369 Solves the current routing model; closes the current model. 5370 This is equivalent to calling 5371 SolveWithParameters(DefaultRoutingSearchParameters()) 5372 or 5373 SolveFromAssignmentWithParameters(assignment, 5374 DefaultRoutingSearchParameters()). 5375 """ 5376 return _pywrapcp.RoutingModel_Solve(self, assignment)
Solves the current routing model; closes the current model. This is equivalent to calling SolveWithParameters(DefaultRoutingSearchParameters()) or SolveFromAssignmentWithParameters(assignment, DefaultRoutingSearchParameters()).
def
SolveWithParameters(self, search_parameters, solutions=None):
5378 def SolveWithParameters(self, search_parameters, solutions=None): 5379 r""" 5380 Solves the current routing model with the given parameters. If 'solutions' 5381 is specified, it will contain the k best solutions found during the search 5382 (from worst to best, including the one returned by this method), where k 5383 corresponds to the 'number_of_solutions_to_collect' in 5384 'search_parameters'. Note that the Assignment returned by the method and 5385 the ones in solutions are owned by the underlying solver and should not be 5386 deleted. 5387 """ 5388 return _pywrapcp.RoutingModel_SolveWithParameters(self, search_parameters, solutions)
Solves the current routing model with the given parameters. If 'solutions' is specified, it will contain the k best solutions found during the search (from worst to best, including the one returned by this method), where k corresponds to the 'number_of_solutions_to_collect' in 'search_parameters'. Note that the Assignment returned by the method and the ones in solutions are owned by the underlying solver and should not be deleted.
def
SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions=None):
5390 def SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions=None): 5391 r""" 5392 Same as above, except that if assignment is not null, it will be used as 5393 the initial solution. 5394 """ 5395 return _pywrapcp.RoutingModel_SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions)
Same as above, except that if assignment is not null, it will be used as the initial solution.
def
FastSolveFromAssignmentWithParameters( self, assignment, search_parameters, check_solution_in_cp, touched=None):
5397 def FastSolveFromAssignmentWithParameters(self, assignment, search_parameters, check_solution_in_cp, touched=None): 5398 r""" 5399 Improves a given assignment using unchecked local search. 5400 If check_solution_in_cp is true the final solution will be checked with 5401 the CP solver. 5402 As of 11/2023, only works with greedy descent. 5403 """ 5404 return _pywrapcp.RoutingModel_FastSolveFromAssignmentWithParameters(self, assignment, search_parameters, check_solution_in_cp, touched)
Improves a given assignment using unchecked local search. If check_solution_in_cp is true the final solution will be checked with the CP solver. As of 11/2023, only works with greedy descent.
def
SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions=None):
5406 def SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions=None): 5407 r""" 5408 Same as above but will try all assignments in order as first solutions 5409 until one succeeds. 5410 """ 5411 return _pywrapcp.RoutingModel_SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions)
Same as above but will try all assignments in order as first solutions until one succeeds.
def
SolveWithIteratedLocalSearch(self, search_parameters):
5413 def SolveWithIteratedLocalSearch(self, search_parameters): 5414 r""" 5415 Solves the current routing model by using an Iterated Local Search 5416 approach. 5417 """ 5418 return _pywrapcp.RoutingModel_SolveWithIteratedLocalSearch(self, search_parameters)
Solves the current routing model by using an Iterated Local Search approach.
def
SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment):
5420 def SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment): 5421 r""" 5422 Given a "source_model" and its "source_assignment", resets 5423 "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_ 5424 if costs aren't homogeneous across vehicles) of "this" model, with the 5425 values set according to those in "other_assignment". 5426 The objective_element of target_assignment is set to this->cost_. 5427 """ 5428 return _pywrapcp.RoutingModel_SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment)
Given a "source_model" and its "source_assignment", resets "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_ if costs aren't homogeneous across vehicles) of "this" model, with the values set according to those in "other_assignment". The objective_element of target_assignment is set to this->cost_.
def
ComputeLowerBound(self):
5430 def ComputeLowerBound(self): 5431 r""" 5432 Computes a lower bound to the routing problem solving a linear assignment 5433 problem. The routing model must be closed before calling this method. 5434 Note that problems with node disjunction constraints (including optional 5435 nodes) and non-homogenous costs are not supported (the method returns 0 in 5436 these cases). 5437 """ 5438 return _pywrapcp.RoutingModel_ComputeLowerBound(self)
Computes a lower bound to the routing problem solving a linear assignment problem. The routing model must be closed before calling this method. Note that problems with node disjunction constraints (including optional nodes) and non-homogenous costs are not supported (the method returns 0 in these cases).
def
objective_lower_bound(self):
5440 def objective_lower_bound(self): 5441 r""" 5442 Returns the current lower bound found by internal solvers during the 5443 search. 5444 """ 5445 return _pywrapcp.RoutingModel_objective_lower_bound(self)
Returns the current lower bound found by internal solvers during the search.
def
status(self):
5447 def status(self): 5448 r""" Returns the current status of the routing model.""" 5449 return _pywrapcp.RoutingModel_status(self)
Returns the current status of the routing model.
def
enable_deep_serialization(self):
5451 def enable_deep_serialization(self): 5452 r""" Returns the value of the internal enable_deep_serialization_ parameter.""" 5453 return _pywrapcp.RoutingModel_enable_deep_serialization(self)
Returns the value of the internal enable_deep_serialization_ parameter.
def
ApplyLocks(self, locks):
5455 def ApplyLocks(self, locks): 5456 r""" 5457 Applies a lock chain to the next search. 'locks' represents an ordered 5458 vector of nodes representing a partial route which will be fixed during 5459 the next search; it will constrain next variables such that: 5460 next[locks[i]] == locks[i+1]. 5461 5462 Returns the next variable at the end of the locked chain; this variable is 5463 not locked. An assignment containing the locks can be obtained by calling 5464 PreAssignment(). 5465 """ 5466 return _pywrapcp.RoutingModel_ApplyLocks(self, locks)
Applies a lock chain to the next search. 'locks' represents an ordered vector of nodes representing a partial route which will be fixed during the next search; it will constrain next variables such that: next[locks[i]] == locks[i+1].
Returns the next variable at the end of the locked chain; this variable is not locked. An assignment containing the locks can be obtained by calling PreAssignment().
def
ApplyLocksToAllVehicles(self, locks, close_routes):
5468 def ApplyLocksToAllVehicles(self, locks, close_routes): 5469 r""" 5470 Applies lock chains to all vehicles to the next search, such that locks[p] 5471 is the lock chain for route p. Returns false if the locks do not contain 5472 valid routes; expects that the routes do not contain the depots, 5473 i.e. there are empty vectors in place of empty routes. 5474 If close_routes is set to true, adds the end nodes to the route of each 5475 vehicle and deactivates other nodes. 5476 An assignment containing the locks can be obtained by calling 5477 PreAssignment(). 5478 """ 5479 return _pywrapcp.RoutingModel_ApplyLocksToAllVehicles(self, locks, close_routes)
Applies lock chains to all vehicles to the next search, such that locks[p] is the lock chain for route p. Returns false if the locks do not contain valid routes; expects that the routes do not contain the depots, i.e. there are empty vectors in place of empty routes. If close_routes is set to true, adds the end nodes to the route of each vehicle and deactivates other nodes. An assignment containing the locks can be obtained by calling PreAssignment().
def
PreAssignment(self):
5481 def PreAssignment(self): 5482 r""" 5483 Returns an assignment used to fix some of the variables of the problem. 5484 In practice, this assignment locks partial routes of the problem. This 5485 can be used in the context of locking the parts of the routes which have 5486 already been driven in online routing problems. 5487 """ 5488 return _pywrapcp.RoutingModel_PreAssignment(self)
Returns an assignment used to fix some of the variables of the problem. In practice, this assignment locks partial routes of the problem. This can be used in the context of locking the parts of the routes which have already been driven in online routing problems.
def
WriteAssignment(self, file_name):
5493 def WriteAssignment(self, file_name): 5494 r""" 5495 Writes the current solution to a file containing an AssignmentProto. 5496 Returns false if the file cannot be opened or if there is no current 5497 solution. 5498 """ 5499 return _pywrapcp.RoutingModel_WriteAssignment(self, file_name)
Writes the current solution to a file containing an AssignmentProto. Returns false if the file cannot be opened or if there is no current solution.
def
ReadAssignment(self, file_name):
5501 def ReadAssignment(self, file_name): 5502 r""" 5503 Reads an assignment from a file and returns the current solution. 5504 Returns nullptr if the file cannot be opened or if the assignment is not 5505 valid. 5506 """ 5507 return _pywrapcp.RoutingModel_ReadAssignment(self, file_name)
Reads an assignment from a file and returns the current solution. Returns nullptr if the file cannot be opened or if the assignment is not valid.
def
RestoreAssignment(self, solution):
5509 def RestoreAssignment(self, solution): 5510 r""" 5511 Restores an assignment as a solution in the routing model and returns the 5512 new solution. Returns nullptr if the assignment is not valid. 5513 """ 5514 return _pywrapcp.RoutingModel_RestoreAssignment(self, solution)
Restores an assignment as a solution in the routing model and returns the new solution. Returns nullptr if the assignment is not valid.
def
ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices):
5516 def ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices): 5517 r""" 5518 Restores the routes as the current solution. Returns nullptr if the 5519 solution cannot be restored (routes do not contain a valid solution). Note 5520 that calling this method will run the solver to assign values to the 5521 dimension variables; this may take considerable amount of time, especially 5522 when using dimensions with slack. 5523 """ 5524 return _pywrapcp.RoutingModel_ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices)
Restores the routes as the current solution. Returns nullptr if the solution cannot be restored (routes do not contain a valid solution). Note that calling this method will run the solver to assign values to the dimension variables; this may take considerable amount of time, especially when using dimensions with slack.
def
RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment):
5526 def RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment): 5527 r""" 5528 Fills an assignment from a specification of the routes of the 5529 vehicles. The routes are specified as lists of variable indices that 5530 appear on the routes of the vehicles. The indices of the outer vector in 5531 'routes' correspond to vehicles IDs, the inner vector contains the 5532 variable indices on the routes for the given vehicle. The inner vectors 5533 must not contain the start and end indices, as these are determined by the 5534 routing model. Sets the value of NextVars in the assignment, adding the 5535 variables to the assignment if necessary. The method does not touch other 5536 variables in the assignment. The method can only be called after the model 5537 is closed. With ignore_inactive_indices set to false, this method will 5538 fail (return nullptr) in case some of the route contain indices that are 5539 deactivated in the model; when set to true, these indices will be 5540 skipped. Returns true if routes were successfully 5541 loaded. However, such assignment still might not be a valid 5542 solution to the routing problem due to more complex constraints; 5543 it is advisible to call solver()->CheckSolution() afterwards. 5544 """ 5545 return _pywrapcp.RoutingModel_RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment)
Fills an assignment from a specification of the routes of the vehicles. The routes are specified as lists of variable indices that appear on the routes of the vehicles. The indices of the outer vector in 'routes' correspond to vehicles IDs, the inner vector contains the variable indices on the routes for the given vehicle. The inner vectors must not contain the start and end indices, as these are determined by the routing model. Sets the value of NextVars in the assignment, adding the variables to the assignment if necessary. The method does not touch other variables in the assignment. The method can only be called after the model is closed. With ignore_inactive_indices set to false, this method will fail (return nullptr) in case some of the route contain indices that are deactivated in the model; when set to true, these indices will be skipped. Returns true if routes were successfully loaded. However, such assignment still might not be a valid solution to the routing problem due to more complex constraints; it is advisible to call solver()->CheckSolution() afterwards.
def
AssignmentToRoutes(self, assignment, routes):
5547 def AssignmentToRoutes(self, assignment, routes): 5548 r""" 5549 Converts the solution in the given assignment to routes for all vehicles. 5550 Expects that assignment contains a valid solution (i.e. routes for all 5551 vehicles end with an end index for that vehicle). 5552 """ 5553 return _pywrapcp.RoutingModel_AssignmentToRoutes(self, assignment, routes)
Converts the solution in the given assignment to routes for all vehicles. Expects that assignment contains a valid solution (i.e. routes for all vehicles end with an end index for that vehicle).
def
CompactAssignment(self, assignment):
5555 def CompactAssignment(self, assignment): 5556 r""" 5557 Converts the solution in the given assignment to routes for all vehicles. 5558 If the returned vector is route_indices, route_indices[i][j] is the index 5559 for jth location visited on route i. Note that contrary to 5560 AssignmentToRoutes, the vectors do include start and end locations. 5561 Returns a compacted version of the given assignment, in which all vehicles 5562 with id lower or equal to some N have non-empty routes, and all vehicles 5563 with id greater than N have empty routes. Does not take ownership of the 5564 returned object. 5565 If found, the cost of the compact assignment is the same as in the 5566 original assignment and it preserves the values of 'active' variables. 5567 Returns nullptr if a compact assignment was not found. 5568 This method only works in homogenous mode, and it only swaps equivalent 5569 vehicles (vehicles with the same start and end nodes). When creating the 5570 compact assignment, the empty plan is replaced by the route assigned to 5571 the compatible vehicle with the highest id. Note that with more complex 5572 constraints on vehicle variables, this method might fail even if a compact 5573 solution exists. 5574 This method changes the vehicle and dimension variables as necessary. 5575 While compacting the solution, only basic checks on vehicle variables are 5576 performed; if one of these checks fails no attempts to repair it are made 5577 (instead, the method returns nullptr). 5578 """ 5579 return _pywrapcp.RoutingModel_CompactAssignment(self, assignment)
Converts the solution in the given assignment to routes for all vehicles. If the returned vector is route_indices, route_indices[i][j] is the index for jth location visited on route i. Note that contrary to AssignmentToRoutes, the vectors do include start and end locations. Returns a compacted version of the given assignment, in which all vehicles with id lower or equal to some N have non-empty routes, and all vehicles with id greater than N have empty routes. Does not take ownership of the returned object. If found, the cost of the compact assignment is the same as in the original assignment and it preserves the values of 'active' variables. Returns nullptr if a compact assignment was not found. This method only works in homogenous mode, and it only swaps equivalent vehicles (vehicles with the same start and end nodes). When creating the compact assignment, the empty plan is replaced by the route assigned to the compatible vehicle with the highest id. Note that with more complex constraints on vehicle variables, this method might fail even if a compact solution exists. This method changes the vehicle and dimension variables as necessary. While compacting the solution, only basic checks on vehicle variables are performed; if one of these checks fails no attempts to repair it are made (instead, the method returns nullptr).
def
CompactAndCheckAssignment(self, assignment):
5581 def CompactAndCheckAssignment(self, assignment): 5582 r""" 5583 Same as CompactAssignment() but also checks the validity of the final 5584 compact solution; if it is not valid, no attempts to repair it are made 5585 (instead, the method returns nullptr). 5586 """ 5587 return _pywrapcp.RoutingModel_CompactAndCheckAssignment(self, assignment)
Same as CompactAssignment() but also checks the validity of the final compact solution; if it is not valid, no attempts to repair it are made (instead, the method returns nullptr).
def
AddToAssignment(self, var):
5589 def AddToAssignment(self, var): 5590 r""" Adds an extra variable to the vehicle routing assignment.""" 5591 return _pywrapcp.RoutingModel_AddToAssignment(self, var)
Adds an extra variable to the vehicle routing assignment.
def
PackCumulsOfOptimizerDimensionsFromAssignment( self, original_assignment, duration_limit, time_limit_was_reached=None):
5596 def PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached=None): 5597 r""" 5598 For every dimension in the model with an optimizer in 5599 local/global_dimension_optimizers_, this method tries to pack the cumul 5600 values of the dimension, such that: 5601 - The cumul costs (span costs, soft lower and upper bound costs, etc) are 5602 minimized. 5603 - The cumuls of the ends of the routes are minimized for this given 5604 minimal cumul cost. 5605 - Given these minimal end cumuls, the route start cumuls are maximized. 5606 Returns the assignment resulting from allocating these packed cumuls with 5607 the solver, and nullptr if these cumuls could not be set by the solver. 5608 """ 5609 return _pywrapcp.RoutingModel_PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached)
For every dimension in the model with an optimizer in local/global_dimension_optimizers_, this method tries to pack the cumul values of the dimension, such that:
- The cumul costs (span costs, soft lower and upper bound costs, etc) are minimized.
- The cumuls of the ends of the routes are minimized for this given minimal cumul cost.
- Given these minimal end cumuls, the route start cumuls are maximized. Returns the assignment resulting from allocating these packed cumuls with the solver, and nullptr if these cumuls could not be set by the solver.
def
GetOrCreateNodeNeighborsByCostClass(self, *args):
5611 def GetOrCreateNodeNeighborsByCostClass(self, *args): 5612 r""" 5613 *Overload 1:* 5614 Returns neighbors of all nodes for every cost class. The result is cached 5615 and is computed once. The number of neighbors considered is based on a 5616 ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum 5617 of min-neighbors node considered. 5618 5619 | 5620 5621 *Overload 2:* 5622 Returns parameters.num_neighbors neighbors of all nodes for every cost 5623 class. The result is cached and is computed once. 5624 5625 | 5626 5627 *Overload 3:* 5628 Returns parameters.num_neighbors neighbors of all nodes for every cost 5629 class. The result is cached and is computed once. 5630 """ 5631 return _pywrapcp.RoutingModel_GetOrCreateNodeNeighborsByCostClass(self, *args)
Overload 1: Returns neighbors of all nodes for every cost class. The result is cached and is computed once. The number of neighbors considered is based on a ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum of min-neighbors node considered.
|
Overload 2: Returns parameters.num_neighbors neighbors of all nodes for every cost class. The result is cached and is computed once.
|
Overload 3: Returns parameters.num_neighbors neighbors of all nodes for every cost class. The result is cached and is computed once.
def
AddLocalSearchFilter(self, filter):
5633 def AddLocalSearchFilter(self, filter): 5634 r""" 5635 Adds a custom local search filter to the list of filters used to speed up 5636 local search by pruning unfeasible variable assignments. 5637 Calling this method after the routing model has been closed (CloseModel() 5638 or Solve() has been called) has no effect. 5639 The routing model does not take ownership of the filter. 5640 """ 5641 return _pywrapcp.RoutingModel_AddLocalSearchFilter(self, filter)
Adds a custom local search filter to the list of filters used to speed up local search by pruning unfeasible variable assignments. Calling this method after the routing model has been closed (CloseModel() or Solve() has been called) has no effect. The routing model does not take ownership of the filter.
def
Start(self, vehicle):
5643 def Start(self, vehicle): 5644 r""" 5645 Model inspection. 5646 Returns the variable index of the starting node of a vehicle route. 5647 """ 5648 return _pywrapcp.RoutingModel_Start(self, vehicle)
Model inspection. Returns the variable index of the starting node of a vehicle route.
def
End(self, vehicle):
5650 def End(self, vehicle): 5651 r""" Returns the variable index of the ending node of a vehicle route.""" 5652 return _pywrapcp.RoutingModel_End(self, vehicle)
Returns the variable index of the ending node of a vehicle route.
def
IsStart(self, index):
5654 def IsStart(self, index): 5655 r""" Returns true if 'index' represents the first node of a route.""" 5656 return _pywrapcp.RoutingModel_IsStart(self, index)
Returns true if 'index' represents the first node of a route.
def
IsEnd(self, index):
5658 def IsEnd(self, index): 5659 r""" Returns true if 'index' represents the last node of a route.""" 5660 return _pywrapcp.RoutingModel_IsEnd(self, index)
Returns true if 'index' represents the last node of a route.
def
VehicleIndex(self, index):
5662 def VehicleIndex(self, index): 5663 r""" 5664 Returns the vehicle of the given start/end index, and -1 if the given 5665 index is not a vehicle start/end. 5666 """ 5667 return _pywrapcp.RoutingModel_VehicleIndex(self, index)
Returns the vehicle of the given start/end index, and -1 if the given index is not a vehicle start/end.
def
Next(self, assignment, index):
5669 def Next(self, assignment, index): 5670 r""" 5671 Assignment inspection 5672 Returns the variable index of the node directly after the node 5673 corresponding to 'index' in 'assignment'. 5674 """ 5675 return _pywrapcp.RoutingModel_Next(self, assignment, index)
Assignment inspection Returns the variable index of the node directly after the node corresponding to 'index' in 'assignment'.
def
IsVehicleUsed(self, assignment, vehicle):
5677 def IsVehicleUsed(self, assignment, vehicle): 5678 r""" Returns true if the route of 'vehicle' is non empty in 'assignment'.""" 5679 return _pywrapcp.RoutingModel_IsVehicleUsed(self, assignment, vehicle)
Returns true if the route of 'vehicle' is non empty in 'assignment'.
def
NextVar(self, index):
5681 def NextVar(self, index): 5682 r""" 5683 Returns the next variable of the node corresponding to index. Note that 5684 NextVar(index) == index is equivalent to ActiveVar(index) == 0. 5685 """ 5686 return _pywrapcp.RoutingModel_NextVar(self, index)
Returns the next variable of the node corresponding to index. Note that NextVar(index) == index is equivalent to ActiveVar(index) == 0.
def
ActiveVar(self, index):
5688 def ActiveVar(self, index): 5689 r""" Returns the active variable of the node corresponding to index.""" 5690 return _pywrapcp.RoutingModel_ActiveVar(self, index)
Returns the active variable of the node corresponding to index.
def
ActiveVehicleVar(self, vehicle):
5692 def ActiveVehicleVar(self, vehicle): 5693 r""" 5694 Returns the active variable of the vehicle. It will be equal to 1 iff the 5695 route of the vehicle is not empty, 0 otherwise. 5696 """ 5697 return _pywrapcp.RoutingModel_ActiveVehicleVar(self, vehicle)
Returns the active variable of the vehicle. It will be equal to 1 iff the route of the vehicle is not empty, 0 otherwise.
def
VehicleRouteConsideredVar(self, vehicle):
5699 def VehicleRouteConsideredVar(self, vehicle): 5700 r""" 5701 Returns the variable specifying whether or not the given vehicle route is 5702 considered for costs and constraints. It will be equal to 1 iff the route 5703 of the vehicle is not empty OR vehicle_used_when_empty_[vehicle] is true. 5704 """ 5705 return _pywrapcp.RoutingModel_VehicleRouteConsideredVar(self, vehicle)
Returns the variable specifying whether or not the given vehicle route is considered for costs and constraints. It will be equal to 1 iff the route of the vehicle is not empty OR vehicle_used_when_empty_[vehicle] is true.
def
VehicleVar(self, index):
5707 def VehicleVar(self, index): 5708 r""" 5709 Returns the vehicle variable of the node corresponding to index. Note that 5710 VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0. 5711 """ 5712 return _pywrapcp.RoutingModel_VehicleVar(self, index)
Returns the vehicle variable of the node corresponding to index. Note that VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0.
def
ResourceVar(self, vehicle, resource_group):
5714 def ResourceVar(self, vehicle, resource_group): 5715 r""" 5716 Returns the resource variable for the given vehicle index in the given 5717 resource group. If a vehicle doesn't require a resource from the 5718 corresponding resource group, then ResourceVar(v, r_g) == -1. 5719 """ 5720 return _pywrapcp.RoutingModel_ResourceVar(self, vehicle, resource_group)
Returns the resource variable for the given vehicle index in the given resource group. If a vehicle doesn't require a resource from the corresponding resource group, then ResourceVar(v, r_g) == -1.
def
CostVar(self):
5722 def CostVar(self): 5723 r""" Returns the global cost variable which is being minimized.""" 5724 return _pywrapcp.RoutingModel_CostVar(self)
Returns the global cost variable which is being minimized.
def
GetArcCostForVehicle(self, from_index, to_index, vehicle):
5726 def GetArcCostForVehicle(self, from_index, to_index, vehicle): 5727 r""" 5728 Returns the cost of the transit arc between two nodes for a given vehicle. 5729 Input are variable indices of node. This returns 0 if vehicle < 0. 5730 """ 5731 return _pywrapcp.RoutingModel_GetArcCostForVehicle(self, from_index, to_index, vehicle)
Returns the cost of the transit arc between two nodes for a given vehicle. Input are variable indices of node. This returns 0 if vehicle < 0.
def
CostsAreHomogeneousAcrossVehicles(self):
5733 def CostsAreHomogeneousAcrossVehicles(self): 5734 r""" Whether costs are homogeneous across all vehicles.""" 5735 return _pywrapcp.RoutingModel_CostsAreHomogeneousAcrossVehicles(self)
Whether costs are homogeneous across all vehicles.
def
GetHomogeneousCost(self, from_index, to_index):
5737 def GetHomogeneousCost(self, from_index, to_index): 5738 r""" 5739 Returns the cost of the segment between two nodes supposing all vehicle 5740 costs are the same (returns the cost for the first vehicle otherwise). 5741 """ 5742 return _pywrapcp.RoutingModel_GetHomogeneousCost(self, from_index, to_index)
Returns the cost of the segment between two nodes supposing all vehicle costs are the same (returns the cost for the first vehicle otherwise).
def
GetArcCostForFirstSolution(self, from_index, to_index):
5744 def GetArcCostForFirstSolution(self, from_index, to_index): 5745 r""" 5746 Returns the cost of the arc in the context of the first solution strategy. 5747 This is typically a simplification of the actual cost; see the .cc. 5748 """ 5749 return _pywrapcp.RoutingModel_GetArcCostForFirstSolution(self, from_index, to_index)
Returns the cost of the arc in the context of the first solution strategy. This is typically a simplification of the actual cost; see the .cc.
def
GetArcCostForClass(self, from_index, to_index, cost_class_index):
5751 def GetArcCostForClass(self, from_index, to_index, cost_class_index): 5752 r""" 5753 Returns the cost of the segment between two nodes for a given cost 5754 class. Input are variable indices of nodes and the cost class. 5755 Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the 5756 returned cost won't necessarily be zero: only some of the components 5757 of the cost that depend on the cost class will be omited. See the code 5758 for details. 5759 """ 5760 return _pywrapcp.RoutingModel_GetArcCostForClass(self, from_index, to_index, cost_class_index)
Returns the cost of the segment between two nodes for a given cost class. Input are variable indices of nodes and the cost class. Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the returned cost won't necessarily be zero: only some of the components of the cost that depend on the cost class will be omited. See the code for details.
def
GetCostClassIndexOfVehicle(self, vehicle):
5762 def GetCostClassIndexOfVehicle(self, vehicle): 5763 r""" Get the cost class index of the given vehicle.""" 5764 return _pywrapcp.RoutingModel_GetCostClassIndexOfVehicle(self, vehicle)
Get the cost class index of the given vehicle.
def
HasVehicleWithCostClassIndex(self, cost_class_index):
5766 def HasVehicleWithCostClassIndex(self, cost_class_index): 5767 r""" 5768 Returns true iff the model contains a vehicle with the given 5769 cost_class_index. 5770 """ 5771 return _pywrapcp.RoutingModel_HasVehicleWithCostClassIndex(self, cost_class_index)
Returns true iff the model contains a vehicle with the given cost_class_index.
def
GetCostClassesCount(self):
5773 def GetCostClassesCount(self): 5774 r""" Returns the number of different cost classes in the model.""" 5775 return _pywrapcp.RoutingModel_GetCostClassesCount(self)
Returns the number of different cost classes in the model.
def
GetNonZeroCostClassesCount(self):
5777 def GetNonZeroCostClassesCount(self): 5778 r""" Ditto, minus the 'always zero', built-in cost class.""" 5779 return _pywrapcp.RoutingModel_GetNonZeroCostClassesCount(self)
Ditto, minus the 'always zero', built-in cost class.
def
GetVehicleOfClass(self, vehicle_class):
5784 def GetVehicleOfClass(self, vehicle_class): 5785 r""" 5786 Returns a vehicle of the given vehicle class, and -1 if there are no 5787 vehicles for this class. 5788 """ 5789 return _pywrapcp.RoutingModel_GetVehicleOfClass(self, vehicle_class)
Returns a vehicle of the given vehicle class, and -1 if there are no vehicles for this class.
def
GetVehicleClassesCount(self):
5791 def GetVehicleClassesCount(self): 5792 r""" Returns the number of different vehicle classes in the model.""" 5793 return _pywrapcp.RoutingModel_GetVehicleClassesCount(self)
Returns the number of different vehicle classes in the model.
def
GetSameVehicleIndicesOfIndex(self, node):
5795 def GetSameVehicleIndicesOfIndex(self, node): 5796 r""" Returns variable indices of nodes constrained to be on the same route.""" 5797 return _pywrapcp.RoutingModel_GetSameVehicleIndicesOfIndex(self, node)
Returns variable indices of nodes constrained to be on the same route.
def
ArcIsMoreConstrainedThanArc(self, _from, to1, to2):
5802 def ArcIsMoreConstrainedThanArc(self, _from, to1, to2): 5803 r""" 5804 Returns whether the arc from->to1 is more constrained than from->to2, 5805 taking into account, in order: 5806 - whether the destination node isn't an end node 5807 - whether the destination node is mandatory 5808 - whether the destination node is bound to the same vehicle as the source 5809 - the "primary constrained" dimension (see SetPrimaryConstrainedDimension) 5810 It then breaks ties using, in order: 5811 - the arc cost (taking unperformed penalties into account) 5812 - the size of the vehicle vars of "to1" and "to2" (lowest size wins) 5813 - the value: the lowest value of the indices to1 and to2 wins. 5814 See the .cc for details. 5815 The more constrained arc is typically preferable when building a 5816 first solution. This method is intended to be used as a callback for the 5817 BestValueByComparisonSelector value selector. 5818 Args: 5819 from: the variable index of the source node 5820 to1: the variable index of the first candidate destination node. 5821 to2: the variable index of the second candidate destination node. 5822 """ 5823 return _pywrapcp.RoutingModel_ArcIsMoreConstrainedThanArc(self, _from, to1, to2)
Returns whether the arc from->to1 is more constrained than from->to2, taking into account, in order:
- whether the destination node isn't an end node
- whether the destination node is mandatory
- whether the destination node is bound to the same vehicle as the source
- the "primary constrained" dimension (see SetPrimaryConstrainedDimension) It then breaks ties using, in order:
- the arc cost (taking unperformed penalties into account)
- the size of the vehicle vars of "to1" and "to2" (lowest size wins)
- the value: the lowest value of the indices to1 and to2 wins. See the .cc for details. The more constrained arc is typically preferable when building a first solution. This method is intended to be used as a callback for the BestValueByComparisonSelector value selector.
Arguments:
- from: the variable index of the source node
- to1: the variable index of the first candidate destination node.
- to2: the variable index of the second candidate destination node.
def
DebugOutputAssignment(self, solution_assignment, dimension_to_print):
5825 def DebugOutputAssignment(self, solution_assignment, dimension_to_print): 5826 r""" 5827 Print some debugging information about an assignment, including the 5828 feasible intervals of the CumulVar for dimension "dimension_to_print" 5829 at each step of the routes. 5830 If "dimension_to_print" is omitted, all dimensions will be printed. 5831 """ 5832 return _pywrapcp.RoutingModel_DebugOutputAssignment(self, solution_assignment, dimension_to_print)
Print some debugging information about an assignment, including the feasible intervals of the CumulVar for dimension "dimension_to_print" at each step of the routes. If "dimension_to_print" is omitted, all dimensions will be printed.
def
CheckIfAssignmentIsFeasible(self, assignment, call_at_solution_monitors):
5834 def CheckIfAssignmentIsFeasible(self, assignment, call_at_solution_monitors): 5835 r""" 5836 Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair 5837 containing the minimum and maximum of the CumulVar of the jth node on 5838 route i. 5839 - cumul_bounds[i][j].first is the minimum. 5840 - cumul_bounds[i][j].second is the maximum. 5841 Checks if an assignment is feasible. 5842 """ 5843 return _pywrapcp.RoutingModel_CheckIfAssignmentIsFeasible(self, assignment, call_at_solution_monitors)
Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair containing the minimum and maximum of the CumulVar of the jth node on route i.
- cumul_bounds[i][j].first is the minimum.
- cumul_bounds[i][j].second is the maximum. Checks if an assignment is feasible.
def
solver(self):
5845 def solver(self): 5846 r""" 5847 Returns the underlying constraint solver. Can be used to add extra 5848 constraints and/or modify search algorithms. 5849 """ 5850 return _pywrapcp.RoutingModel_solver(self)
Returns the underlying constraint solver. Can be used to add extra constraints and/or modify search algorithms.
def
CheckLimit(self, *args):
5852 def CheckLimit(self, *args): 5853 r""" 5854 Returns true if the search limit has been crossed with the given time 5855 offset. 5856 """ 5857 return _pywrapcp.RoutingModel_CheckLimit(self, *args)
Returns true if the search limit has been crossed with the given time offset.
def
RemainingTime(self):
5859 def RemainingTime(self): 5860 r""" Returns the time left in the search limit.""" 5861 return _pywrapcp.RoutingModel_RemainingTime(self)
Returns the time left in the search limit.
def
UpdateTimeLimit(self, time_limit):
5863 def UpdateTimeLimit(self, time_limit): 5864 r""" Updates the time limit of the search limit.""" 5865 return _pywrapcp.RoutingModel_UpdateTimeLimit(self, time_limit)
Updates the time limit of the search limit.
def
TimeBuffer(self):
5867 def TimeBuffer(self): 5868 r""" Returns the time buffer to safely return a solution.""" 5869 return _pywrapcp.RoutingModel_TimeBuffer(self)
Returns the time buffer to safely return a solution.
def
GetMutableCPSatInterrupt(self):
5871 def GetMutableCPSatInterrupt(self): 5872 r""" Returns the atomic<bool> to stop the CP-SAT solver.""" 5873 return _pywrapcp.RoutingModel_GetMutableCPSatInterrupt(self)
Returns the atomic
def
GetMutableCPInterrupt(self):
5875 def GetMutableCPInterrupt(self): 5876 r""" Returns the atomic<bool> to stop the CP solver.""" 5877 return _pywrapcp.RoutingModel_GetMutableCPInterrupt(self)
Returns the atomic
def
CancelSearch(self):
5879 def CancelSearch(self): 5880 r""" Cancels the current search.""" 5881 return _pywrapcp.RoutingModel_CancelSearch(self)
Cancels the current search.
def
nodes(self):
5883 def nodes(self): 5884 r""" 5885 Sizes and indices 5886 Returns the number of nodes in the model. 5887 """ 5888 return _pywrapcp.RoutingModel_nodes(self)
Sizes and indices Returns the number of nodes in the model.
def
vehicles(self):
5890 def vehicles(self): 5891 r""" Returns the number of vehicle routes in the model.""" 5892 return _pywrapcp.RoutingModel_vehicles(self)
Returns the number of vehicle routes in the model.
def
Size(self):
5894 def Size(self): 5895 r""" Returns the number of next variables in the model.""" 5896 return _pywrapcp.RoutingModel_Size(self)
Returns the number of next variables in the model.
def
GetNumberOfDecisionsInFirstSolution(self, search_parameters):
5898 def GetNumberOfDecisionsInFirstSolution(self, search_parameters): 5899 r""" 5900 Returns statistics on first solution search, number of decisions sent to 5901 filters, number of decisions rejected by filters. 5902 """ 5903 return _pywrapcp.RoutingModel_GetNumberOfDecisionsInFirstSolution(self, search_parameters)
Returns statistics on first solution search, number of decisions sent to filters, number of decisions rejected by filters.
def
GetAutomaticFirstSolutionStrategy(self):
5908 def GetAutomaticFirstSolutionStrategy(self): 5909 r""" Returns the automatic first solution strategy selected.""" 5910 return _pywrapcp.RoutingModel_GetAutomaticFirstSolutionStrategy(self)
Returns the automatic first solution strategy selected.
def
IsMatchingModel(self):
5912 def IsMatchingModel(self): 5913 r""" Returns true if a vehicle/node matching problem is detected.""" 5914 return _pywrapcp.RoutingModel_IsMatchingModel(self)
Returns true if a vehicle/node matching problem is detected.
def
AreRoutesInterdependent(self, parameters):
5916 def AreRoutesInterdependent(self, parameters): 5917 r""" 5918 Returns true if routes are interdependent. This means that any 5919 modification to a route might impact another. 5920 """ 5921 return _pywrapcp.RoutingModel_AreRoutesInterdependent(self, parameters)
Returns true if routes are interdependent. This means that any modification to a route might impact another.
def
MakeGuidedSlackFinalizer(self, dimension, initializer):
5923 def MakeGuidedSlackFinalizer(self, dimension, initializer): 5924 r""" 5925 The next few members are in the public section only for testing purposes. 5926 5927 MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a 5928 dimension using a callback to choose which values to start with. 5929 The finalizer works only when all next variables in the model have 5930 been fixed. It has the following two characteristics: 5931 1. It follows the routes defined by the nexts variables when choosing a 5932 variable to make a decision on. 5933 2. When it comes to choose a value for the slack of node i, the decision 5934 builder first calls the callback with argument i, and supposingly the 5935 returned value is x it creates decisions slack[i] = x, slack[i] = x + 5936 1, slack[i] = x - 1, slack[i] = x + 2, etc. 5937 """ 5938 return _pywrapcp.RoutingModel_MakeGuidedSlackFinalizer(self, dimension, initializer)
The next few members are in the public section only for testing purposes.
MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a dimension using a callback to choose which values to start with. The finalizer works only when all next variables in the model have been fixed. It has the following two characteristics:
- It follows the routes defined by the nexts variables when choosing a variable to make a decision on.
- When it comes to choose a value for the slack of node i, the decision builder first calls the callback with argument i, and supposingly the returned value is x it creates decisions slack[i] = x, slack[i] = x + 1, slack[i] = x - 1, slack[i] = x + 2, etc.
def
MakeSelfDependentDimensionFinalizer(self, dimension):
5940 def MakeSelfDependentDimensionFinalizer(self, dimension): 5941 r""" 5942 MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a 5943 self-dependent dimension. It makes an extensive use of the caches of the 5944 state dependent transits. 5945 In detail, MakeSelfDependentDimensionFinalizer returns a composition of a 5946 local search decision builder with a greedy descent operator for the cumul 5947 of the start of each route and a guided slack finalizer. Provided there 5948 are no time windows and the maximum slacks are large enough, once the 5949 cumul of the start of route is fixed, the guided finalizer can find 5950 optimal values of the slacks for the rest of the route in time 5951 proportional to the length of the route. Therefore the composed finalizer 5952 generally works in time O(log(t)*n*m), where t is the latest possible 5953 departute time, n is the number of nodes in the network and m is the 5954 number of vehicles. 5955 """ 5956 return _pywrapcp.RoutingModel_MakeSelfDependentDimensionFinalizer(self, dimension)
MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a self-dependent dimension. It makes an extensive use of the caches of the state dependent transits. In detail, MakeSelfDependentDimensionFinalizer returns a composition of a local search decision builder with a greedy descent operator for the cumul of the start of each route and a guided slack finalizer. Provided there are no time windows and the maximum slacks are large enough, once the cumul of the start of route is fixed, the guided finalizer can find optimal values of the slacks for the rest of the route in time proportional to the length of the route. Therefore the composed finalizer generally works in time O(log(t)nm), where t is the latest possible departute time, n is the number of nodes in the network and m is the number of vehicles.
cvar =
<Swig global variables>
5968class RoutingModelVisitor(BaseObject): 5969 r""" Routing model visitor.""" 5970 5971 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 5972 __repr__ = _swig_repr 5973 5974 def __init__(self): 5975 _pywrapcp.RoutingModelVisitor_swiginit(self, _pywrapcp.new_RoutingModelVisitor()) 5976 __swig_destroy__ = _pywrapcp.delete_RoutingModelVisitor
Routing model visitor.
thisown
5971 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
Inherited Members
5984class GlobalVehicleBreaksConstraint(Constraint): 5985 r""" 5986 GlobalVehicleBreaksConstraint ensures breaks constraints are enforced on 5987 all vehicles in the dimension passed to its constructor. 5988 It is intended to be used for dimensions representing time. 5989 A break constraint ensures break intervals fit on the route of a vehicle. 5990 For a given vehicle, it forces break intervals to be disjoint from visit 5991 intervals, where visit intervals start at CumulVar(node) and last for 5992 node_visit_transit[node]. Moreover, it ensures that there is enough time 5993 between two consecutive nodes of a route to do transit and vehicle breaks, 5994 i.e. if Next(nodeA) = nodeB, CumulVar(nodeA) = tA and CumulVar(nodeB) = tB, 5995 then SlackVar(nodeA) >= sum_{breaks [tA, tB)} duration(break). 5996 """ 5997 5998 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 5999 __repr__ = _swig_repr 6000 6001 def __init__(self, dimension): 6002 _pywrapcp.GlobalVehicleBreaksConstraint_swiginit(self, _pywrapcp.new_GlobalVehicleBreaksConstraint(dimension)) 6003 6004 def DebugString(self): 6005 return _pywrapcp.GlobalVehicleBreaksConstraint_DebugString(self) 6006 6007 def Post(self): 6008 return _pywrapcp.GlobalVehicleBreaksConstraint_Post(self) 6009 6010 def InitialPropagateWrapper(self): 6011 return _pywrapcp.GlobalVehicleBreaksConstraint_InitialPropagateWrapper(self) 6012 __swig_destroy__ = _pywrapcp.delete_GlobalVehicleBreaksConstraint
GlobalVehicleBreaksConstraint ensures breaks constraints are enforced on all vehicles in the dimension passed to its constructor. It is intended to be used for dimensions representing time. A break constraint ensures break intervals fit on the route of a vehicle. For a given vehicle, it forces break intervals to be disjoint from visit intervals, where visit intervals start at CumulVar(node) and last for node_visit_transit[node]. Moreover, it ensures that there is enough time between two consecutive nodes of a route to do transit and vehicle breaks, i.e. if Next(nodeA) = nodeB, CumulVar(nodeA) = tA and CumulVar(nodeB) = tB, then SlackVar(nodeA) >= sum_{breaks [tA, tB)} duration(break).
thisown
5998 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
Post(self):
This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables.
def
InitialPropagateWrapper(self):
6010 def InitialPropagateWrapper(self): 6011 return _pywrapcp.GlobalVehicleBreaksConstraint_InitialPropagateWrapper(self)
This method performs the initial propagation of the constraint. It is called just after the post.
Inherited Members
class
TypeRegulationsChecker:
6016class TypeRegulationsChecker(object): 6017 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6018 6019 def __init__(self, *args, **kwargs): 6020 raise AttributeError("No constructor defined - class is abstract") 6021 __repr__ = _swig_repr 6022 __swig_destroy__ = _pywrapcp.delete_TypeRegulationsChecker 6023 6024 def CheckVehicle(self, vehicle, next_accessor): 6025 return _pywrapcp.TypeRegulationsChecker_CheckVehicle(self, vehicle, next_accessor)
thisown
6017 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
6029class TypeIncompatibilityChecker(TypeRegulationsChecker): 6030 r""" Checker for type incompatibilities.""" 6031 6032 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6033 __repr__ = _swig_repr 6034 6035 def __init__(self, model, check_hard_incompatibilities): 6036 _pywrapcp.TypeIncompatibilityChecker_swiginit(self, _pywrapcp.new_TypeIncompatibilityChecker(model, check_hard_incompatibilities)) 6037 __swig_destroy__ = _pywrapcp.delete_TypeIncompatibilityChecker
Checker for type incompatibilities.
thisown
6032 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
Inherited Members
6041class TypeRequirementChecker(TypeRegulationsChecker): 6042 r""" Checker for type requirements.""" 6043 6044 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6045 __repr__ = _swig_repr 6046 6047 def __init__(self, model): 6048 _pywrapcp.TypeRequirementChecker_swiginit(self, _pywrapcp.new_TypeRequirementChecker(model)) 6049 __swig_destroy__ = _pywrapcp.delete_TypeRequirementChecker
Checker for type requirements.
thisown
6044 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
Inherited Members
6053class TypeRegulationsConstraint(Constraint): 6054 r""" 6055 The following constraint ensures that incompatibilities and requirements 6056 between types are respected. 6057 6058 It verifies both "hard" and "temporal" incompatibilities. 6059 Two nodes with hard incompatible types cannot be served by the same vehicle 6060 at all, while with a temporal incompatibility they can't be on the same 6061 route at the same time. 6062 The VisitTypePolicy of a node determines how visiting it impacts the type 6063 count on the route. 6064 6065 For example, for 6066 - three temporally incompatible types T1 T2 and T3 6067 - 2 pairs of nodes a1/r1 and a2/r2 of type T1 and T2 respectively, with 6068 - a1 and a2 of VisitTypePolicy TYPE_ADDED_TO_VEHICLE 6069 - r1 and r2 of policy ADDED_TYPE_REMOVED_FROM_VEHICLE 6070 - 3 nodes A, UV and AR of type T3, respectively with type policies 6071 TYPE_ADDED_TO_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT and 6072 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED 6073 the configurations 6074 UV --> a1 --> r1 --> a2 --> r2, a1 --> r1 --> a2 --> r2 --> A and 6075 a1 --> r1 --> AR --> a2 --> r2 are acceptable, whereas the configurations 6076 a1 --> a2 --> r1 --> ..., or A --> a1 --> r1 --> ..., or 6077 a1 --> r1 --> UV --> ... are not feasible. 6078 6079 It also verifies same-vehicle and temporal type requirements. 6080 A node of type T_d with a same-vehicle requirement for type T_r needs to be 6081 served by the same vehicle as a node of type T_r. 6082 Temporal requirements, on the other hand, can take effect either when the 6083 dependent type is being added to the route or when it's removed from it, 6084 which is determined by the dependent node's VisitTypePolicy. 6085 In the above example: 6086 - If T3 is required on the same vehicle as T1, A, AR or UV must be on the 6087 same vehicle as a1. 6088 - If T2 is required when adding T1, a2 must be visited *before* a1, and if 6089 r2 is also visited on the route, it must be *after* a1, i.e. T2 must be on 6090 the vehicle when a1 is visited: 6091 ... --> a2 --> ... --> a1 --> ... --> r2 --> ... 6092 - If T3 is required when removing T1, T3 needs to be on the vehicle when 6093 r1 is visited: 6094 ... --> A --> ... --> r1 --> ... OR ... --> r1 --> ... --> UV --> ... 6095 """ 6096 6097 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6098 __repr__ = _swig_repr 6099 6100 def __init__(self, model): 6101 _pywrapcp.TypeRegulationsConstraint_swiginit(self, _pywrapcp.new_TypeRegulationsConstraint(model)) 6102 6103 def Post(self): 6104 return _pywrapcp.TypeRegulationsConstraint_Post(self) 6105 6106 def InitialPropagateWrapper(self): 6107 return _pywrapcp.TypeRegulationsConstraint_InitialPropagateWrapper(self) 6108 __swig_destroy__ = _pywrapcp.delete_TypeRegulationsConstraint
The following constraint ensures that incompatibilities and requirements between types are respected.
It verifies both "hard" and "temporal" incompatibilities. Two nodes with hard incompatible types cannot be served by the same vehicle at all, while with a temporal incompatibility they can't be on the same route at the same time. The VisitTypePolicy of a node determines how visiting it impacts the type count on the route.
For example, for
- three temporally incompatible types T1 T2 and T3
- 2 pairs of nodes a1/r1 and a2/r2 of type T1 and T2 respectively, with
- a1 and a2 of VisitTypePolicy TYPE_ADDED_TO_VEHICLE
- r1 and r2 of policy ADDED_TYPE_REMOVED_FROM_VEHICLE
- 3 nodes A, UV and AR of type T3, respectively with type policies TYPE_ADDED_TO_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT and TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED the configurations UV --> a1 --> r1 --> a2 --> r2, a1 --> r1 --> a2 --> r2 --> A and a1 --> r1 --> AR --> a2 --> r2 are acceptable, whereas the configurations a1 --> a2 --> r1 --> ..., or A --> a1 --> r1 --> ..., or a1 --> r1 --> UV --> ... are not feasible.
It also verifies same-vehicle and temporal type requirements. A node of type T_d with a same-vehicle requirement for type T_r needs to be served by the same vehicle as a node of type T_r. Temporal requirements, on the other hand, can take effect either when the dependent type is being added to the route or when it's removed from it, which is determined by the dependent node's VisitTypePolicy. In the above example:
- If T3 is required on the same vehicle as T1, A, AR or UV must be on the same vehicle as a1.
- If T2 is required when adding T1, a2 must be visited before a1, and if r2 is also visited on the route, it must be after a1, i.e. T2 must be on the vehicle when a1 is visited: ... --> a2 --> ... --> a1 --> ... --> r2 --> ...
- If T3 is required when removing T1, T3 needs to be on the vehicle when r1 is visited: ... --> A --> ... --> r1 --> ... OR ... --> r1 --> ... --> UV --> ...
thisown
6097 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
Post(self):
This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables.
def
InitialPropagateWrapper(self):
6106 def InitialPropagateWrapper(self): 6107 return _pywrapcp.TypeRegulationsConstraint_InitialPropagateWrapper(self)
This method performs the initial propagation of the constraint. It is called just after the post.
Inherited Members
class
BoundCost:
6112class BoundCost(object): 6113 r""" 6114 A structure meant to store soft bounds and associated violation constants. 6115 It is 'Simple' because it has one BoundCost per element, 6116 in contrast to 'Multiple'. Design notes: 6117 - it is meant to store model information to be shared through pointers, 6118 so it disallows copy and assign to avoid accidental duplication. 6119 - it keeps soft bounds as an array of structs to help cache, 6120 because code that uses such bounds typically use both bound and cost. 6121 - soft bounds are named pairs, prevents some mistakes. 6122 - using operator[] to access elements is not interesting, 6123 because the structure will be accessed through pointers, moreover having 6124 to type bound_cost reminds the user of the order if they do a copy 6125 assignment of the element. 6126 """ 6127 6128 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6129 __repr__ = _swig_repr 6130 bound = property(_pywrapcp.BoundCost_bound_get, _pywrapcp.BoundCost_bound_set) 6131 cost = property(_pywrapcp.BoundCost_cost_get, _pywrapcp.BoundCost_cost_set) 6132 6133 def __init__(self, *args): 6134 _pywrapcp.BoundCost_swiginit(self, _pywrapcp.new_BoundCost(*args)) 6135 __swig_destroy__ = _pywrapcp.delete_BoundCost
A structure meant to store soft bounds and associated violation constants. It is 'Simple' because it has one BoundCost per element, in contrast to 'Multiple'. Design notes:
- it is meant to store model information to be shared through pointers, so it disallows copy and assign to avoid accidental duplication.
- it keeps soft bounds as an array of structs to help cache, because code that uses such bounds typically use both bound and cost.
- soft bounds are named pairs, prevents some mistakes.
- using operator[] to access elements is not interesting, because the structure will be accessed through pointers, moreover having to type bound_cost reminds the user of the order if they do a copy assignment of the element.
thisown
6128 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
class
SimpleBoundCosts:
6139class SimpleBoundCosts(object): 6140 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6141 __repr__ = _swig_repr 6142 6143 def __init__(self, num_bounds, default_bound_cost): 6144 _pywrapcp.SimpleBoundCosts_swiginit(self, _pywrapcp.new_SimpleBoundCosts(num_bounds, default_bound_cost)) 6145 6146 def bound_cost(self, element): 6147 return _pywrapcp.SimpleBoundCosts_bound_cost(self, element) 6148 6149 def size(self): 6150 return _pywrapcp.SimpleBoundCosts_size(self) 6151 __swig_destroy__ = _pywrapcp.delete_SimpleBoundCosts
thisown
6140 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
class
RoutingDimension:
6155class RoutingDimension(object): 6156 r""" 6157 Dimensions represent quantities accumulated at nodes along the routes. They 6158 represent quantities such as weights or volumes carried along the route, or 6159 distance or times. 6160 6161 Quantities at a node are represented by "cumul" variables and the increase 6162 or decrease of quantities between nodes are represented by "transit" 6163 variables. These variables are linked as follows: 6164 6165 if j == next(i), 6166 cumuls(j) = cumuls(i) + transits(i) + slacks(i) + 6167 state_dependent_transits(i) 6168 6169 where slack is a positive slack variable (can represent waiting times for 6170 a time dimension), and state_dependent_transits is a non-purely functional 6171 version of transits_. Favour transits over state_dependent_transits when 6172 possible, because purely functional callbacks allow more optimisations and 6173 make the model faster and easier to solve. 6174 for a given vehicle, it is passed as an external vector, it would be better 6175 to have this information here. 6176 """ 6177 6178 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6179 6180 def __init__(self, *args, **kwargs): 6181 raise AttributeError("No constructor defined") 6182 __repr__ = _swig_repr 6183 __swig_destroy__ = _pywrapcp.delete_RoutingDimension 6184 6185 def model(self): 6186 r""" Returns the model on which the dimension was created.""" 6187 return _pywrapcp.RoutingDimension_model(self) 6188 6189 def GetTransitValue(self, from_index, to_index, vehicle): 6190 r""" 6191 Returns the transition value for a given pair of nodes (as var index); 6192 this value is the one taken by the corresponding transit variable when 6193 the 'next' variable for 'from_index' is bound to 'to_index'. 6194 """ 6195 return _pywrapcp.RoutingDimension_GetTransitValue(self, from_index, to_index, vehicle) 6196 6197 def GetTransitValueFromClass(self, from_index, to_index, vehicle_class): 6198 r""" 6199 Same as above but taking a vehicle class of the dimension instead of a 6200 vehicle (the class of a vehicle can be obtained with vehicle_to_class()). 6201 """ 6202 return _pywrapcp.RoutingDimension_GetTransitValueFromClass(self, from_index, to_index, vehicle_class) 6203 6204 def CumulVar(self, index): 6205 r""" 6206 Get the cumul, transit and slack variables for the given node (given as 6207 int64_t var index). 6208 """ 6209 return _pywrapcp.RoutingDimension_CumulVar(self, index) 6210 6211 def TransitVar(self, index): 6212 return _pywrapcp.RoutingDimension_TransitVar(self, index) 6213 6214 def FixedTransitVar(self, index): 6215 return _pywrapcp.RoutingDimension_FixedTransitVar(self, index) 6216 6217 def SlackVar(self, index): 6218 return _pywrapcp.RoutingDimension_SlackVar(self, index) 6219 6220 def SetSpanUpperBoundForVehicle(self, upper_bound, vehicle): 6221 r""" 6222 Sets an upper bound on the dimension span on a given vehicle. This is the 6223 preferred way to limit the "length" of the route of a vehicle according to 6224 a dimension. 6225 """ 6226 return _pywrapcp.RoutingDimension_SetSpanUpperBoundForVehicle(self, upper_bound, vehicle) 6227 6228 def SetSpanCostCoefficientForVehicle(self, coefficient, vehicle): 6229 r""" 6230 Sets a cost proportional to the dimension span on a given vehicle, 6231 or on all vehicles at once. "coefficient" must be nonnegative. 6232 This is handy to model costs proportional to idle time when the dimension 6233 represents time. 6234 The cost for a vehicle is 6235 span_cost = coefficient * (dimension end value - dimension start value). 6236 """ 6237 return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForVehicle(self, coefficient, vehicle) 6238 6239 def SetSpanCostCoefficientForAllVehicles(self, coefficient): 6240 return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForAllVehicles(self, coefficient) 6241 6242 def SetSlackCostCoefficientForVehicle(self, coefficient, vehicle): 6243 r""" 6244 Sets a cost proportional to the dimension total slack on a given vehicle, 6245 or on all vehicles at once. "coefficient" must be nonnegative. 6246 This is handy to model costs only proportional to idle time when the 6247 dimension represents time. 6248 The cost for a vehicle is 6249 slack_cost = coefficient * 6250 (dimension end value - dimension start value - total_transit). 6251 """ 6252 return _pywrapcp.RoutingDimension_SetSlackCostCoefficientForVehicle(self, coefficient, vehicle) 6253 6254 def SetSlackCostCoefficientForAllVehicles(self, coefficient): 6255 return _pywrapcp.RoutingDimension_SetSlackCostCoefficientForAllVehicles(self, coefficient) 6256 6257 def SetGlobalSpanCostCoefficient(self, coefficient): 6258 r""" 6259 Sets a cost proportional to the *global* dimension span, that is the 6260 difference between the largest value of route end cumul variables and 6261 the smallest value of route start cumul variables. 6262 In other words: 6263 global_span_cost = 6264 coefficient * (Max(dimension end value) - Min(dimension start value)). 6265 """ 6266 return _pywrapcp.RoutingDimension_SetGlobalSpanCostCoefficient(self, coefficient) 6267 6268 def SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient): 6269 r""" 6270 Sets a soft upper bound to the cumul variable of a given variable index. 6271 If the value of the cumul variable is greater than the bound, a cost 6272 proportional to the difference between this value and the bound is added 6273 to the cost function of the model: 6274 cumulVar <= upper_bound -> cost = 0 6275 cumulVar > upper_bound -> cost = coefficient * (cumulVar - upper_bound) 6276 This is also handy to model tardiness costs when the dimension represents 6277 time. 6278 """ 6279 return _pywrapcp.RoutingDimension_SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient) 6280 6281 def HasCumulVarSoftUpperBound(self, index): 6282 r""" 6283 Returns true if a soft upper bound has been set for a given variable 6284 index. 6285 """ 6286 return _pywrapcp.RoutingDimension_HasCumulVarSoftUpperBound(self, index) 6287 6288 def GetCumulVarSoftUpperBound(self, index): 6289 r""" 6290 Returns the soft upper bound of a cumul variable for a given variable 6291 index. The "hard" upper bound of the variable is returned if no soft upper 6292 bound has been set. 6293 """ 6294 return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBound(self, index) 6295 6296 def GetCumulVarSoftUpperBoundCoefficient(self, index): 6297 r""" 6298 Returns the cost coefficient of the soft upper bound of a cumul variable 6299 for a given variable index. If no soft upper bound has been set, 0 is 6300 returned. 6301 """ 6302 return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBoundCoefficient(self, index) 6303 6304 def SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient): 6305 r""" 6306 Sets a soft lower bound to the cumul variable of a given variable index. 6307 If the value of the cumul variable is less than the bound, a cost 6308 proportional to the difference between this value and the bound is added 6309 to the cost function of the model: 6310 cumulVar > lower_bound -> cost = 0 6311 cumulVar <= lower_bound -> cost = coefficient * (lower_bound - 6312 cumulVar). 6313 This is also handy to model earliness costs when the dimension represents 6314 time. 6315 """ 6316 return _pywrapcp.RoutingDimension_SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient) 6317 6318 def HasCumulVarSoftLowerBound(self, index): 6319 r""" 6320 Returns true if a soft lower bound has been set for a given variable 6321 index. 6322 """ 6323 return _pywrapcp.RoutingDimension_HasCumulVarSoftLowerBound(self, index) 6324 6325 def GetCumulVarSoftLowerBound(self, index): 6326 r""" 6327 Returns the soft lower bound of a cumul variable for a given variable 6328 index. The "hard" lower bound of the variable is returned if no soft lower 6329 bound has been set. 6330 """ 6331 return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBound(self, index) 6332 6333 def GetCumulVarSoftLowerBoundCoefficient(self, index): 6334 r""" 6335 Returns the cost coefficient of the soft lower bound of a cumul variable 6336 for a given variable index. If no soft lower bound has been set, 0 is 6337 returned. 6338 """ 6339 return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBoundCoefficient(self, index) 6340 6341 def SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits): 6342 r""" 6343 Sets the breaks for a given vehicle. Breaks are represented by 6344 IntervalVars. They may interrupt transits between nodes and increase 6345 the value of corresponding slack variables. 6346 A break may take place before the start of a vehicle, after the end of 6347 a vehicle, or during a travel i -> j. 6348 6349 In that case, the interval [break.Start(), break.End()) must be a subset 6350 of [CumulVar(i) + pre_travel(i, j), CumulVar(j) - post_travel(i, j)). In 6351 other words, a break may not overlap any node n's visit, given by 6352 [CumulVar(n) - post_travel(_, n), CumulVar(n) + pre_travel(n, _)). 6353 This formula considers post_travel(_, start) and pre_travel(end, _) to be 6354 0; pre_travel will never be called on any (_, start) and post_travel will 6355 never we called on any (end, _). If pre_travel_evaluator or 6356 post_travel_evaluator is -1, it will be taken as a function that always 6357 returns 0. 6358 Deprecated, sets pre_travel(i, j) = node_visit_transit[i]. 6359 """ 6360 return _pywrapcp.RoutingDimension_SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits) 6361 6362 def SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle): 6363 r""" 6364 With breaks supposed to be consecutive, this forces the distance between 6365 breaks of size at least minimum_break_duration to be at most distance. 6366 This supposes that the time until route start and after route end are 6367 infinite breaks. 6368 """ 6369 return _pywrapcp.RoutingDimension_SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle) 6370 6371 def InitializeBreaks(self): 6372 r""" 6373 Sets up vehicle_break_intervals_, vehicle_break_distance_duration_, 6374 pre_travel_evaluators and post_travel_evaluators. 6375 """ 6376 return _pywrapcp.RoutingDimension_InitializeBreaks(self) 6377 6378 def HasBreakConstraints(self): 6379 r""" Returns true if any break interval or break distance was defined.""" 6380 return _pywrapcp.RoutingDimension_HasBreakConstraints(self) 6381 6382 def GetPreTravelEvaluatorOfVehicle(self, vehicle): 6383 return _pywrapcp.RoutingDimension_GetPreTravelEvaluatorOfVehicle(self, vehicle) 6384 6385 def GetPostTravelEvaluatorOfVehicle(self, vehicle): 6386 return _pywrapcp.RoutingDimension_GetPostTravelEvaluatorOfVehicle(self, vehicle) 6387 6388 def base_dimension(self): 6389 r""" Returns the parent in the dependency tree if any or nullptr otherwise.""" 6390 return _pywrapcp.RoutingDimension_base_dimension(self) 6391 6392 def ShortestTransitionSlack(self, node): 6393 r""" 6394 It makes sense to use the function only for self-dependent dimension. 6395 For such dimensions the value of the slack of a node determines the 6396 transition cost of the next transit. Provided that 6397 1. cumul[node] is fixed, 6398 2. next[node] and next[next[node]] (if exists) are fixed, 6399 the value of slack[node] for which cumul[next[node]] + transit[next[node]] 6400 is minimized can be found in O(1) using this function. 6401 """ 6402 return _pywrapcp.RoutingDimension_ShortestTransitionSlack(self, node) 6403 6404 def name(self): 6405 r""" Returns the name of the dimension.""" 6406 return _pywrapcp.RoutingDimension_name(self) 6407 6408 def SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index): 6409 return _pywrapcp.RoutingDimension_SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index) 6410 6411 def HasPickupToDeliveryLimits(self): 6412 return _pywrapcp.RoutingDimension_HasPickupToDeliveryLimits(self) 6413 6414 def AddNodePrecedence(self, first_node, second_node, offset): 6415 return _pywrapcp.RoutingDimension_AddNodePrecedence(self, first_node, second_node, offset) 6416 6417 def GetSpanUpperBoundForVehicle(self, vehicle): 6418 return _pywrapcp.RoutingDimension_GetSpanUpperBoundForVehicle(self, vehicle) 6419 6420 def GetSpanCostCoefficientForVehicle(self, vehicle): 6421 return _pywrapcp.RoutingDimension_GetSpanCostCoefficientForVehicle(self, vehicle) 6422 6423 def GetSlackCostCoefficientForVehicle(self, vehicle): 6424 return _pywrapcp.RoutingDimension_GetSlackCostCoefficientForVehicle(self, vehicle) 6425 6426 def global_span_cost_coefficient(self): 6427 return _pywrapcp.RoutingDimension_global_span_cost_coefficient(self) 6428 6429 def GetGlobalOptimizerOffset(self): 6430 return _pywrapcp.RoutingDimension_GetGlobalOptimizerOffset(self) 6431 6432 def GetLocalOptimizerOffsetForVehicle(self, vehicle): 6433 return _pywrapcp.RoutingDimension_GetLocalOptimizerOffsetForVehicle(self, vehicle) 6434 6435 def SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle): 6436 r""" 6437 If the span of vehicle on this dimension is larger than bound, 6438 the cost will be increased by cost * (span - bound). 6439 """ 6440 return _pywrapcp.RoutingDimension_SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle) 6441 6442 def HasSoftSpanUpperBounds(self): 6443 return _pywrapcp.RoutingDimension_HasSoftSpanUpperBounds(self) 6444 6445 def GetSoftSpanUpperBoundForVehicle(self, vehicle): 6446 return _pywrapcp.RoutingDimension_GetSoftSpanUpperBoundForVehicle(self, vehicle) 6447 6448 def SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle): 6449 r""" 6450 If the span of vehicle on this dimension is larger than bound, 6451 the cost will be increased by cost * (span - bound)^2. 6452 """ 6453 return _pywrapcp.RoutingDimension_SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle) 6454 6455 def HasQuadraticCostSoftSpanUpperBounds(self): 6456 return _pywrapcp.RoutingDimension_HasQuadraticCostSoftSpanUpperBounds(self) 6457 6458 def GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle): 6459 return _pywrapcp.RoutingDimension_GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle)
Dimensions represent quantities accumulated at nodes along the routes. They represent quantities such as weights or volumes carried along the route, or distance or times.
Quantities at a node are represented by "cumul" variables and the increase or decrease of quantities between nodes are represented by "transit" variables. These variables are linked as follows:
if j == next(i), cumuls(j) = cumuls(i) + transits(i) + slacks(i) + state_dependent_transits(i)
where slack is a positive slack variable (can represent waiting times for a time dimension), and state_dependent_transits is a non-purely functional version of transits_. Favour transits over state_dependent_transits when possible, because purely functional callbacks allow more optimisations and make the model faster and easier to solve. for a given vehicle, it is passed as an external vector, it would be better to have this information here.
thisown
6178 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
The membership flag
def
model(self):
6185 def model(self): 6186 r""" Returns the model on which the dimension was created.""" 6187 return _pywrapcp.RoutingDimension_model(self)
Returns the model on which the dimension was created.
def
GetTransitValue(self, from_index, to_index, vehicle):
6189 def GetTransitValue(self, from_index, to_index, vehicle): 6190 r""" 6191 Returns the transition value for a given pair of nodes (as var index); 6192 this value is the one taken by the corresponding transit variable when 6193 the 'next' variable for 'from_index' is bound to 'to_index'. 6194 """ 6195 return _pywrapcp.RoutingDimension_GetTransitValue(self, from_index, to_index, vehicle)
Returns the transition value for a given pair of nodes (as var index); this value is the one taken by the corresponding transit variable when the 'next' variable for 'from_index' is bound to 'to_index'.
def
GetTransitValueFromClass(self, from_index, to_index, vehicle_class):
6197 def GetTransitValueFromClass(self, from_index, to_index, vehicle_class): 6198 r""" 6199 Same as above but taking a vehicle class of the dimension instead of a 6200 vehicle (the class of a vehicle can be obtained with vehicle_to_class()). 6201 """ 6202 return _pywrapcp.RoutingDimension_GetTransitValueFromClass(self, from_index, to_index, vehicle_class)
Same as above but taking a vehicle class of the dimension instead of a vehicle (the class of a vehicle can be obtained with vehicle_to_class()).
def
CumulVar(self, index):
6204 def CumulVar(self, index): 6205 r""" 6206 Get the cumul, transit and slack variables for the given node (given as 6207 int64_t var index). 6208 """ 6209 return _pywrapcp.RoutingDimension_CumulVar(self, index)
Get the cumul, transit and slack variables for the given node (given as int64_t var index).
def
SetSpanUpperBoundForVehicle(self, upper_bound, vehicle):
6220 def SetSpanUpperBoundForVehicle(self, upper_bound, vehicle): 6221 r""" 6222 Sets an upper bound on the dimension span on a given vehicle. This is the 6223 preferred way to limit the "length" of the route of a vehicle according to 6224 a dimension. 6225 """ 6226 return _pywrapcp.RoutingDimension_SetSpanUpperBoundForVehicle(self, upper_bound, vehicle)
Sets an upper bound on the dimension span on a given vehicle. This is the preferred way to limit the "length" of the route of a vehicle according to a dimension.
def
SetSpanCostCoefficientForVehicle(self, coefficient, vehicle):
6228 def SetSpanCostCoefficientForVehicle(self, coefficient, vehicle): 6229 r""" 6230 Sets a cost proportional to the dimension span on a given vehicle, 6231 or on all vehicles at once. "coefficient" must be nonnegative. 6232 This is handy to model costs proportional to idle time when the dimension 6233 represents time. 6234 The cost for a vehicle is 6235 span_cost = coefficient * (dimension end value - dimension start value). 6236 """ 6237 return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForVehicle(self, coefficient, vehicle)
Sets a cost proportional to the dimension span on a given vehicle, or on all vehicles at once. "coefficient" must be nonnegative. This is handy to model costs proportional to idle time when the dimension represents time. The cost for a vehicle is span_cost = coefficient * (dimension end value - dimension start value).
def
SetSlackCostCoefficientForVehicle(self, coefficient, vehicle):
6242 def SetSlackCostCoefficientForVehicle(self, coefficient, vehicle): 6243 r""" 6244 Sets a cost proportional to the dimension total slack on a given vehicle, 6245 or on all vehicles at once. "coefficient" must be nonnegative. 6246 This is handy to model costs only proportional to idle time when the 6247 dimension represents time. 6248 The cost for a vehicle is 6249 slack_cost = coefficient * 6250 (dimension end value - dimension start value - total_transit). 6251 """ 6252 return _pywrapcp.RoutingDimension_SetSlackCostCoefficientForVehicle(self, coefficient, vehicle)
Sets a cost proportional to the dimension total slack on a given vehicle, or on all vehicles at once. "coefficient" must be nonnegative. This is handy to model costs only proportional to idle time when the dimension represents time. The cost for a vehicle is slack_cost = coefficient * (dimension end value - dimension start value - total_transit).
def
SetGlobalSpanCostCoefficient(self, coefficient):
6257 def SetGlobalSpanCostCoefficient(self, coefficient): 6258 r""" 6259 Sets a cost proportional to the *global* dimension span, that is the 6260 difference between the largest value of route end cumul variables and 6261 the smallest value of route start cumul variables. 6262 In other words: 6263 global_span_cost = 6264 coefficient * (Max(dimension end value) - Min(dimension start value)). 6265 """ 6266 return _pywrapcp.RoutingDimension_SetGlobalSpanCostCoefficient(self, coefficient)
Sets a cost proportional to the global dimension span, that is the difference between the largest value of route end cumul variables and the smallest value of route start cumul variables. In other words: global_span_cost = coefficient * (Max(dimension end value) - Min(dimension start value)).
def
SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient):
6268 def SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient): 6269 r""" 6270 Sets a soft upper bound to the cumul variable of a given variable index. 6271 If the value of the cumul variable is greater than the bound, a cost 6272 proportional to the difference between this value and the bound is added 6273 to the cost function of the model: 6274 cumulVar <= upper_bound -> cost = 0 6275 cumulVar > upper_bound -> cost = coefficient * (cumulVar - upper_bound) 6276 This is also handy to model tardiness costs when the dimension represents 6277 time. 6278 """ 6279 return _pywrapcp.RoutingDimension_SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient)
Sets a soft upper bound to the cumul variable of a given variable index. If the value of the cumul variable is greater than the bound, a cost proportional to the difference between this value and the bound is added to the cost function of the model: cumulVar <= upper_bound -> cost = 0 cumulVar > upper_bound -> cost = coefficient * (cumulVar - upper_bound) This is also handy to model tardiness costs when the dimension represents time.
def
HasCumulVarSoftUpperBound(self, index):
6281 def HasCumulVarSoftUpperBound(self, index): 6282 r""" 6283 Returns true if a soft upper bound has been set for a given variable 6284 index. 6285 """ 6286 return _pywrapcp.RoutingDimension_HasCumulVarSoftUpperBound(self, index)
Returns true if a soft upper bound has been set for a given variable index.
def
GetCumulVarSoftUpperBound(self, index):
6288 def GetCumulVarSoftUpperBound(self, index): 6289 r""" 6290 Returns the soft upper bound of a cumul variable for a given variable 6291 index. The "hard" upper bound of the variable is returned if no soft upper 6292 bound has been set. 6293 """ 6294 return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBound(self, index)
Returns the soft upper bound of a cumul variable for a given variable index. The "hard" upper bound of the variable is returned if no soft upper bound has been set.
def
GetCumulVarSoftUpperBoundCoefficient(self, index):
6296 def GetCumulVarSoftUpperBoundCoefficient(self, index): 6297 r""" 6298 Returns the cost coefficient of the soft upper bound of a cumul variable 6299 for a given variable index. If no soft upper bound has been set, 0 is 6300 returned. 6301 """ 6302 return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBoundCoefficient(self, index)
Returns the cost coefficient of the soft upper bound of a cumul variable for a given variable index. If no soft upper bound has been set, 0 is returned.
def
SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient):
6304 def SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient): 6305 r""" 6306 Sets a soft lower bound to the cumul variable of a given variable index. 6307 If the value of the cumul variable is less than the bound, a cost 6308 proportional to the difference between this value and the bound is added 6309 to the cost function of the model: 6310 cumulVar > lower_bound -> cost = 0 6311 cumulVar <= lower_bound -> cost = coefficient * (lower_bound - 6312 cumulVar). 6313 This is also handy to model earliness costs when the dimension represents 6314 time. 6315 """ 6316 return _pywrapcp.RoutingDimension_SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient)
Sets a soft lower bound to the cumul variable of a given variable index. If the value of the cumul variable is less than the bound, a cost proportional to the difference between this value and the bound is added to the cost function of the model: cumulVar > lower_bound -> cost = 0 cumulVar <= lower_bound -> cost = coefficient * (lower_bound - cumulVar). This is also handy to model earliness costs when the dimension represents time.
def
HasCumulVarSoftLowerBound(self, index):
6318 def HasCumulVarSoftLowerBound(self, index): 6319 r""" 6320 Returns true if a soft lower bound has been set for a given variable 6321 index. 6322 """ 6323 return _pywrapcp.RoutingDimension_HasCumulVarSoftLowerBound(self, index)
Returns true if a soft lower bound has been set for a given variable index.
def
GetCumulVarSoftLowerBound(self, index):
6325 def GetCumulVarSoftLowerBound(self, index): 6326 r""" 6327 Returns the soft lower bound of a cumul variable for a given variable 6328 index. The "hard" lower bound of the variable is returned if no soft lower 6329 bound has been set. 6330 """ 6331 return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBound(self, index)
Returns the soft lower bound of a cumul variable for a given variable index. The "hard" lower bound of the variable is returned if no soft lower bound has been set.
def
GetCumulVarSoftLowerBoundCoefficient(self, index):
6333 def GetCumulVarSoftLowerBoundCoefficient(self, index): 6334 r""" 6335 Returns the cost coefficient of the soft lower bound of a cumul variable 6336 for a given variable index. If no soft lower bound has been set, 0 is 6337 returned. 6338 """ 6339 return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBoundCoefficient(self, index)
Returns the cost coefficient of the soft lower bound of a cumul variable for a given variable index. If no soft lower bound has been set, 0 is returned.
def
SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits):
6341 def SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits): 6342 r""" 6343 Sets the breaks for a given vehicle. Breaks are represented by 6344 IntervalVars. They may interrupt transits between nodes and increase 6345 the value of corresponding slack variables. 6346 A break may take place before the start of a vehicle, after the end of 6347 a vehicle, or during a travel i -> j. 6348 6349 In that case, the interval [break.Start(), break.End()) must be a subset 6350 of [CumulVar(i) + pre_travel(i, j), CumulVar(j) - post_travel(i, j)). In 6351 other words, a break may not overlap any node n's visit, given by 6352 [CumulVar(n) - post_travel(_, n), CumulVar(n) + pre_travel(n, _)). 6353 This formula considers post_travel(_, start) and pre_travel(end, _) to be 6354 0; pre_travel will never be called on any (_, start) and post_travel will 6355 never we called on any (end, _). If pre_travel_evaluator or 6356 post_travel_evaluator is -1, it will be taken as a function that always 6357 returns 0. 6358 Deprecated, sets pre_travel(i, j) = node_visit_transit[i]. 6359 """ 6360 return _pywrapcp.RoutingDimension_SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits)
Sets the breaks for a given vehicle. Breaks are represented by IntervalVars. They may interrupt transits between nodes and increase the value of corresponding slack variables. A break may take place before the start of a vehicle, after the end of a vehicle, or during a travel i -> j.
In that case, the interval [break.Start(), break.End()) must be a subset of [CumulVar(i) + pre_travel(i, j), CumulVar(j) - post_travel(i, j)). In other words, a break may not overlap any node n's visit, given by [CumulVar(n) - post_travel(_, n), CumulVar(n) + pre_travel(n, _)). This formula considers post_travel(_, start) and pre_travel(end, _) to be 0; pre_travel will never be called on any (_, start) and post_travel will never we called on any (end, _). If pre_travel_evaluator or post_travel_evaluator is -1, it will be taken as a function that always returns 0. Deprecated, sets pre_travel(i, j) = node_visit_transit[i].
def
SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle):
6362 def SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle): 6363 r""" 6364 With breaks supposed to be consecutive, this forces the distance between 6365 breaks of size at least minimum_break_duration to be at most distance. 6366 This supposes that the time until route start and after route end are 6367 infinite breaks. 6368 """ 6369 return _pywrapcp.RoutingDimension_SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle)
With breaks supposed to be consecutive, this forces the distance between breaks of size at least minimum_break_duration to be at most distance. This supposes that the time until route start and after route end are infinite breaks.
def
InitializeBreaks(self):
6371 def InitializeBreaks(self): 6372 r""" 6373 Sets up vehicle_break_intervals_, vehicle_break_distance_duration_, 6374 pre_travel_evaluators and post_travel_evaluators. 6375 """ 6376 return _pywrapcp.RoutingDimension_InitializeBreaks(self)
Sets up vehicle_break_intervals_, vehicle_break_distance_duration_, pre_travel_evaluators and post_travel_evaluators.
def
HasBreakConstraints(self):
6378 def HasBreakConstraints(self): 6379 r""" Returns true if any break interval or break distance was defined.""" 6380 return _pywrapcp.RoutingDimension_HasBreakConstraints(self)
Returns true if any break interval or break distance was defined.
def
base_dimension(self):
6388 def base_dimension(self): 6389 r""" Returns the parent in the dependency tree if any or nullptr otherwise.""" 6390 return _pywrapcp.RoutingDimension_base_dimension(self)
Returns the parent in the dependency tree if any or nullptr otherwise.
def
ShortestTransitionSlack(self, node):
6392 def ShortestTransitionSlack(self, node): 6393 r""" 6394 It makes sense to use the function only for self-dependent dimension. 6395 For such dimensions the value of the slack of a node determines the 6396 transition cost of the next transit. Provided that 6397 1. cumul[node] is fixed, 6398 2. next[node] and next[next[node]] (if exists) are fixed, 6399 the value of slack[node] for which cumul[next[node]] + transit[next[node]] 6400 is minimized can be found in O(1) using this function. 6401 """ 6402 return _pywrapcp.RoutingDimension_ShortestTransitionSlack(self, node)
It makes sense to use the function only for self-dependent dimension. For such dimensions the value of the slack of a node determines the transition cost of the next transit. Provided that
- cumul[node] is fixed,
- next[node] and next[next[node]] (if exists) are fixed, the value of slack[node] for which cumul[next[node]] + transit[next[node]] is minimized can be found in O(1) using this function.
def
name(self):
6404 def name(self): 6405 r""" Returns the name of the dimension.""" 6406 return _pywrapcp.RoutingDimension_name(self)
Returns the name of the dimension.
def
SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle):
6435 def SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle): 6436 r""" 6437 If the span of vehicle on this dimension is larger than bound, 6438 the cost will be increased by cost * (span - bound). 6439 """ 6440 return _pywrapcp.RoutingDimension_SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle)
If the span of vehicle on this dimension is larger than bound, the cost will be increased by cost * (span - bound).
def
SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle):
6448 def SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle): 6449 r""" 6450 If the span of vehicle on this dimension is larger than bound, 6451 the cost will be increased by cost * (span - bound)^2. 6452 """ 6453 return _pywrapcp.RoutingDimension_SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle)
If the span of vehicle on this dimension is larger than bound, the cost will be increased by cost * (span - bound)^2.
def
SolveModelWithSat(model, search_parameters, initial_solution, solution):
6464def SolveModelWithSat(model, search_parameters, initial_solution, solution): 6465 r""" 6466 Attempts to solve the model using the cp-sat solver. As of 5/2019, will 6467 solve the TSP corresponding to the model if it has a single vehicle. 6468 Therefore the resulting solution might not actually be feasible. Will return 6469 false if a solution could not be found. 6470 """ 6471 return _pywrapcp.SolveModelWithSat(model, search_parameters, initial_solution, solution)
Attempts to solve the model using the cp-sat solver. As of 5/2019, will solve the TSP corresponding to the model if it has a single vehicle. Therefore the resulting solution might not actually be feasible. Will return false if a solution could not be found.