t1 ends after t2 end, i.e. End(t1) >= End(t2) + delay.

t1 ends after t2 start, i.e. End(t1) >= Start(t2) + delay.

t1 ends at t2 end, i.e. End(t1) == End(t2) + delay.

t1 ends at t2 start, i.e. End(t1) == Start(t2) + delay.

t1 starts after t2 end, i.e. Start(t1) >= End(t2) + delay.

t1 starts after t2 start, i.e. Start(t1) >= Start(t2) + delay.

t1 starts at t2 end, i.e. Start(t1) == End(t2) + delay.

t1 starts at t2 start, i.e. Start(t1) == Start(t2) + delay.

STARTS_AT_START and ENDS_AT_END at the same time. t1 starts at t2 start, i.e. Start(t1) == Start(t2) + delay. t1 ends at t2 end, i.e. End(t1) == End(t2).

Keeps the default behavior, i.e. apply left branch first, and then right branch in case of backtracking.

Right branches are ignored. This is used to make the code faster when backtrack makes no sense or is not useful. This is faster as there is no need to create one new node per decision.

Left branches are ignored. This is used to make the code faster when backtrack makes no sense or is not useful. This is faster as there is no need to create one new node per decision.

Backtracks to the previous decisions, i.e. left and right branches are not applied.

Applies right branch first. Left branch will be applied in case of backtracking.

DELAYED_PRIORITY is the lowest priority: Demons will be processed after VAR_PRIORITY and NORMAL_PRIORITY demons.

VAR_PRIORITY is between DELAYED_PRIORITY and NORMAL_PRIORITY.

NORMAL_PRIORITY is the highest priority: Demons will be processed first.

Lin-Kernighan local search. While the accumulated local gain is positive, perform a 2opt or a 3opt move followed by a series of 2opt moves. Return a neighbor for which the global gain is positive.

Sliding TSP operator. Uses an exact dynamic programming algorithm to solve the TSP corresponding to path sub-chains. For a subchain 1 -> 2 -> 3 -> 4 -> 5 -> 6, solves the TSP on nodes A, 2, 3, 4, 5, where A is a merger of nodes 1 and 6 such that cost(A,i) = cost(1,i) and cost(i,A) = cost(i,6).

TSP-base LNS. Randomly merge consecutive nodes until n "meta"-nodes remain and solve the corresponding TSP. This is an "unlimited" neighborhood which must be stopped by search limits. To force diversification, the operator iteratively forces each node to serve as base of a meta-node.

Pairs are compared at the first call of the selector, and results are cached. Next calls to the selector use the previous computation, and so are not up-to-date, e.g. some <variable, value> pairs may not be possible anymore due to propagation since the first to call.

Pairs are compared each time a variable is selected. That way all pairs are relevant and evaluation is accurate. This strategy runs in O(number-of-pairs) at each variable selection, versus O(1) in the static version.

The default is INTERVAL_SET_TIMES_FORWARD.

The simple is INTERVAL_SET_TIMES_FORWARD.

Selects the variable with the lowest starting time of all variables, and fixes its starting time to this lowest value.

Selects the variable with the highest ending time of all variables, and fixes the ending time to this highest values.

The default behavior is ASSIGN_MIN_VALUE.

The simple selection is ASSIGN_MIN_VALUE.

Selects the min value of the selected variable.

Selects the max value of the selected variable.

Selects randomly one of the possible values of the selected variable.

Selects the first possible value which is the closest to the center of the domain of the selected variable. The center is defined as (min + max) / 2.

Split the domain in two around the center, and choose the lower part first.

Split the domain in two around the center, and choose the lower part first.

The default behavior is CHOOSE_FIRST_UNBOUND.

The simple selection is CHOOSE_FIRST_UNBOUND.

Select the first unbound variable. Variables are considered in the order of the vector of IntVars used to create the selector.

Randomly select one of the remaining unbound variables.

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.

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.

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.

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.

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.

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.

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.

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.

Among unbound variables, select the variable with the largest gap between the first and the second values of the domain.

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.

Move is accepted when the current objective value >= objective.Min.

Move is accepted when the current objective value <= objective.Max.

Move is accepted when the current objective value is in the interval objective.Min .. objective.Max.

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):

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):

Using Relocate with chain lengths of 1, 2 and 3 together is equivalent to the OrOpt operator on a path. The OrOpt operator is a limited version of 3Opt (breaks 3 arcs on a path).

Relocate neighborhood with length of 1 (see OROPT comment).

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):

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):

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:

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:

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:

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:

Operator which replaces a chain of active nodes 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:

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:

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

the two sub-chains can be part of the same path; they even may overlap.

Operator which relaxes one entire path and all inactive nodes, thus defining num_paths neighbors.

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.

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.

Operator which defines a neighborhood to decrement values. The behavior is the same as INCREMENT, except values are decremented instead of incremented.

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.

Before search, after search.

Executing the root node.

Executing the search code.

After successful NextSolution and before EndSearch.

After failed NextSolution and before EndSearch.

After search, the model is infeasible.

t ends after d, i.e. End(t) >= d.

t ends at d, i.e. End(t) == d.

t ends before d, i.e. End(t) <= d.

t starts after d, i.e. Start(t) >= d.

t starts at d, i.e. Start(t) == d.

t starts before d, i.e. Start(t) <= d.

STARTS_BEFORE and ENDS_AFTER at the same time, i.e. d is in t. t starts before d, i.e. Start(t) <= d. t ends after d, i.e. End(t) >= d.

STARTS_AFTER or ENDS_BEFORE, i.e. d is not in t. t starts after d, i.e. Start(t) >= d. t ends before d, i.e. End(t) <= d.