Solver Class. More...

Detailed Description

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.

Definition at line 259 of file constraint_solver.h.

#include <constraint_solver.h>

Classes
struct	IntegerCastInfo
struct	PathEnergyCostConstraintSpecification
struct	SearchLogParameters
	Creates a search monitor from logging parameters. More...

Public Types
enum	IntVarStrategy { INT_VAR_DEFAULT , INT_VAR_SIMPLE , CHOOSE_FIRST_UNBOUND , CHOOSE_RANDOM , CHOOSE_MIN_SIZE_LOWEST_MIN , CHOOSE_MIN_SIZE_HIGHEST_MIN , CHOOSE_MIN_SIZE_LOWEST_MAX , CHOOSE_MIN_SIZE_HIGHEST_MAX , CHOOSE_LOWEST_MIN , CHOOSE_HIGHEST_MAX , CHOOSE_MIN_SIZE , CHOOSE_MAX_SIZE , CHOOSE_MAX_REGRET_ON_MIN , CHOOSE_PATH }
enum	IntValueStrategy { INT_VALUE_DEFAULT , INT_VALUE_SIMPLE , ASSIGN_MIN_VALUE , ASSIGN_MAX_VALUE , ASSIGN_RANDOM_VALUE , ASSIGN_CENTER_VALUE , SPLIT_LOWER_HALF , SPLIT_UPPER_HALF }
enum	EvaluatorStrategy { CHOOSE_STATIC_GLOBAL_BEST , CHOOSE_DYNAMIC_GLOBAL_BEST }
enum	SequenceStrategy { SEQUENCE_DEFAULT , SEQUENCE_SIMPLE , CHOOSE_MIN_SLACK_RANK_FORWARD , CHOOSE_RANDOM_RANK_FORWARD }
	Used for scheduling. Not yet implemented. More...
enum	IntervalStrategy { INTERVAL_DEFAULT , INTERVAL_SIMPLE , INTERVAL_SET_TIMES_FORWARD , INTERVAL_SET_TIMES_BACKWARD }
enum	LocalSearchOperators { TWOOPT , OROPT , RELOCATE , EXCHANGE , CROSS , MAKEACTIVE , MAKEINACTIVE , MAKECHAININACTIVE , SWAPACTIVE , SWAPACTIVECHAIN , EXTENDEDSWAPACTIVE , PATHLNS , FULLPATHLNS , UNACTIVELNS , INCREMENT , DECREMENT , SIMPLELNS }
enum	EvaluatorLocalSearchOperators { LK , TSPOPT , TSPLNS }
enum	LocalSearchFilterBound { GE , LE , EQ }
enum	DemonPriority { DELAYED_PRIORITY = 0 , VAR_PRIORITY = 1 , NORMAL_PRIORITY = 2 }
enum	BinaryIntervalRelation { ENDS_AFTER_END , ENDS_AFTER_START , ENDS_AT_END , ENDS_AT_START , STARTS_AFTER_END , STARTS_AFTER_START , STARTS_AT_END , STARTS_AT_START , STAYS_IN_SYNC }
enum	UnaryIntervalRelation { ENDS_AFTER , ENDS_AT , ENDS_BEFORE , STARTS_AFTER , STARTS_AT , STARTS_BEFORE , CROSS_DATE , AVOID_DATE }
enum	DecisionModification { NO_CHANGE , KEEP_LEFT , KEEP_RIGHT , KILL_BOTH , SWITCH_BRANCHES }
enum	MarkerType { SENTINEL , SIMPLE_MARKER , CHOICE_POINT , REVERSIBLE_ACTION }
enum	SolverState { OUTSIDE_SEARCH , IN_ROOT_NODE , IN_SEARCH , AT_SOLUTION , NO_MORE_SOLUTIONS , PROBLEM_INFEASIBLE }
	This enum represents the state of the solver w.r.t. the search. More...
enum	OptimizationDirection { NOT_SET , MAXIMIZATION , MINIMIZATION }
	Optimization directions. More...
enum class	MonitorEvent : int { kEnterSearch = 0 , kRestartSearch , kExitSearch , kBeginNextDecision , kEndNextDecision , kApplyDecision , kRefuteDecision , kAfterDecision , kBeginFail , kEndFail , kBeginInitialPropagation , kEndInitialPropagation , kAcceptSolution , kAtSolution , kNoMoreSolutions , kLocalOptimum , kAcceptDelta , kAcceptNeighbor , kAcceptUncheckedNeighbor , kIsUncheckedSolutionLimitReached , kPeriodicCheck , kProgressPercent , kAccept , kLast }
	Search monitor events. More...
typedef std::function< int64_t(int64_t)>	IndexEvaluator1
	Callback typedefs.
typedef std::function< int64_t(int64_t, int64_t)>	IndexEvaluator2
typedef std::function< int64_t(int64_t, int64_t, int64_t)>	IndexEvaluator3
typedef std::function< bool(int64_t)>	IndexFilter1
typedef std::function< IntVar *(int64_t)>	Int64ToIntVar
typedef std::function< int64_t(Solver solver, const std::vector< IntVar > &vars, int64_t first_unbound, int64_t last_unbound)>	VariableIndexSelector
typedef std::function< int64_t(const IntVar *v, int64_t id)>	VariableValueSelector
typedef std::function< bool(int64_t, int64_t, int64_t)>	VariableValueComparator
typedef std::function< DecisionModification()>	BranchSelector
typedef std::function< void(Solver *)>	Action
typedef std::function< void()>	Closure

Public Member Functions
	Solver (const std::string &name)
	Solver API.
	Solver (const std::string &name, const ConstraintSolverParameters &parameters)
	Solver (const Solver &)=delete
Solver &	operator= (const Solver &)=delete
	~Solver ()
ConstraintSolverParameters	parameters () const
	Stored Parameters.
const ConstraintSolverParameters &	const_parameters () const
template<class T>
void	SaveValue (T *o)
	reversibility
template<typename T>
T *	RevAlloc (T *object)
template<typename T>
T *	RevAllocArray (T *object)
void	AddConstraint (Constraint *c)
	Adds the constraint 'c' to the model.
void	AddCastConstraint (CastConstraint constraint, IntVar target_var, IntExpr *expr)
bool	SolveAndCommit (DecisionBuilder db, const std::vector< SearchMonitor > &monitors)
bool	SolveAndCommit (DecisionBuilder *db)
bool	SolveAndCommit (DecisionBuilder db, SearchMonitor m1)
bool	SolveAndCommit (DecisionBuilder db, SearchMonitor m1, SearchMonitor *m2)
bool	SolveAndCommit (DecisionBuilder db, SearchMonitor m1, SearchMonitor m2, SearchMonitor m3)
bool	CheckAssignment (Assignment *solution)
	Checks whether the given assignment satisfies all relevant constraints.
bool	CheckConstraint (Constraint *ct)
SolverState	state () const
	State of the solver.
void	Fail ()
	Abandon the current branch in the search tree. A backtrack will follow.
void	AddBacktrackAction (Action a, bool fast)
std::string	DebugString () const
	!defined(SWIG)
absl::Time	Now () const
int64_t	wall_time () const
int64_t	branches () const
	The number of branches explored since the creation of the solver.
int64_t	solutions () const
	The number of solutions found since the start of the search.
int64_t	unchecked_solutions () const
	The number of unchecked solutions found by local search.
int64_t	demon_runs (DemonPriority p) const
	The number of demons executed during search for a given priority.
int64_t	failures () const
	The number of failures encountered since the creation of the solver.
int64_t	neighbors () const
	The number of neighbors created.
void	ClearNeighbors ()
void	IncrementNeighbors ()
int64_t	filtered_neighbors () const
	The number of filtered neighbors (neighbors accepted by filters).
int64_t	accepted_neighbors () const
	The number of accepted neighbors.
uint64_t	stamp () const
uint64_t	fail_stamp () const
	The fail_stamp() is incremented after each backtrack.
void	set_context (absl::string_view context)
	Sets the current context of the search.
const std::string &	context () const
	Gets the current context of the search.
OptimizationDirection	optimization_direction () const
	The direction of optimization, getter and setter.
void	set_optimization_direction (OptimizationDirection direction)
void	SetGuidedLocalSearchPenaltyCallback (std::function< int64_t(int64_t, int64_t, int64_t)> penalty_callback)
int64_t	GetGuidedLocalSearchPenalty (int64_t i, int64_t j, int64_t k) const
IntVar *	MakeIntVar (int64_t min, int64_t max, const std::string &name)
	MakeIntVar will create the best range based int var for the bounds given.
IntVar *	MakeIntVar (const std::vector< int64_t > &values, const std::string &name)
	MakeIntVar will create a variable with the given sparse domain.
IntVar *	MakeIntVar (const std::vector< int > &values, const std::string &name)
	MakeIntVar will create a variable with the given sparse domain.
IntVar *	MakeIntVar (int64_t min, int64_t max)
	MakeIntVar will create the best range based int var for the bounds given.
IntVar *	MakeIntVar (const std::vector< int64_t > &values)
	MakeIntVar will create a variable with the given sparse domain.
IntVar *	MakeIntVar (const std::vector< int > &values)
	MakeIntVar will create a variable with the given sparse domain.
IntVar *	MakeBoolVar (const std::string &name)
	MakeBoolVar will create a variable with a {0, 1} domain.
IntVar *	MakeBoolVar ()
	MakeBoolVar will create a variable with a {0, 1} domain.
IntVar *	MakeIntConst (int64_t val, const std::string &name)
	IntConst will create a constant expression.
IntVar *	MakeIntConst (int64_t val)
	IntConst will create a constant expression.
void	MakeIntVarArray (int var_count, int64_t vmin, int64_t vmax, const std::string &name, std::vector< IntVar * > *vars)
void	MakeIntVarArray (int var_count, int64_t vmin, int64_t vmax, std::vector< IntVar * > *vars)
IntVar **	MakeIntVarArray (int var_count, int64_t vmin, int64_t vmax, const std::string &name)
	Same but allocates an array and returns it.
void	MakeBoolVarArray (int var_count, const std::string &name, std::vector< IntVar * > *vars)
void	MakeBoolVarArray (int var_count, std::vector< IntVar * > *vars)
IntVar **	MakeBoolVarArray (int var_count, const std::string &name)
	Same but allocates an array and returns it.
IntExpr *	MakeSum (IntExpr left, IntExpr right)
	left + right.
IntExpr *	MakeSum (IntExpr *expr, int64_t value)
	expr + value.
IntExpr *	MakeSum (const std::vector< IntVar * > &vars)
	sum of all vars.
IntExpr *	MakeScalProd (const std::vector< IntVar * > &vars, const std::vector< int64_t > &coefs)
	scalar product
IntExpr *	MakeScalProd (const std::vector< IntVar * > &vars, const std::vector< int > &coefs)
	scalar product
IntExpr *	MakeDifference (IntExpr left, IntExpr right)
	left - right
IntExpr *	MakeDifference (int64_t value, IntExpr *expr)
	value - expr
IntExpr *	MakeOpposite (IntExpr *expr)
	-expr
IntExpr *	MakeProd (IntExpr left, IntExpr right)
	left * right
IntExpr *	MakeProd (IntExpr *expr, int64_t value)
	expr * value
IntExpr *	MakeDiv (IntExpr *expr, int64_t value)
	expr / value (integer division)
IntExpr *	MakeDiv (IntExpr numerator, IntExpr denominator)
	numerator / denominator (integer division). Terms need to be positive.
IntExpr *	MakeAbs (IntExpr *expr)
	expr
IntExpr *	MakeSquare (IntExpr *expr)
	expr * expr
IntExpr *	MakePower (IntExpr *expr, int64_t n)
	expr ^ n (n > 0)
IntExpr *	MakeElement (const std::vector< int64_t > &values, IntVar *index)
	values[index]
IntExpr *	MakeElement (const std::vector< int > &values, IntVar *index)
	values[index]
IntExpr *	MakeElement (IndexEvaluator1 values, IntVar *index)
IntExpr *	MakeMonotonicElement (IndexEvaluator1 values, bool increasing, IntVar *index)
IntExpr *	MakeElement (IndexEvaluator2 values, IntVar index1, IntVar index2)
	2D version of function-based element expression, values(expr1, expr2).
IntExpr *	MakeElement (const std::vector< IntVar * > &vars, IntVar *index)
	vars[expr]
IntExpr *	MakeElement (Int64ToIntVar vars, int64_t range_start, int64_t range_end, IntVar *argument)
	vars(argument)
template<typename F>
Constraint *	MakeLightElement (F values, IntVar const var, IntVar const index, std::function< bool()> deep_serialize=nullptr)
template<typename F>
Constraint *	MakeLightElement (F values, IntVar const var, IntVar const index1, IntVar *const index2, std::function< bool()> deep_serialize=nullptr)
template<typename F>
Constraint *	MakeLightElement (F values, IntVar const var, IntVar const index1, IntVar const index2, IntVar const index3)
IntExpr *	MakeIndexExpression (const std::vector< IntVar * > &vars, int64_t value)
Constraint *	MakeIfThenElseCt (IntVar condition, IntExpr then_expr, IntExpr else_expr, IntVar target_var)
	Special cases with arrays of size two.
IntExpr *	MakeMin (const std::vector< IntVar * > &vars)
	std::min(vars)
IntExpr *	MakeMin (IntExpr left, IntExpr right)
	std::min (left, right)
IntExpr *	MakeMin (IntExpr *expr, int64_t value)
	std::min(expr, value)
IntExpr *	MakeMin (IntExpr *expr, int value)
	std::min(expr, value)
IntExpr *	MakeMax (const std::vector< IntVar * > &vars)
	std::max(vars)
IntExpr *	MakeMax (IntExpr left, IntExpr right)
	std::max(left, right)
IntExpr *	MakeMax (IntExpr *expr, int64_t value)
	std::max(expr, value)
IntExpr *	MakeMax (IntExpr *expr, int value)
	std::max(expr, value)
IntExpr *	MakeConvexPiecewiseExpr (IntExpr *expr, int64_t early_cost, int64_t early_date, int64_t late_date, int64_t late_cost)
	Convex piecewise function.
IntExpr *	MakeSemiContinuousExpr (IntExpr *expr, int64_t fixed_charge, int64_t step)
IntExpr *	MakePiecewiseLinearExpr (IntExpr *expr, const PiecewiseLinearFunction &f)
	expressions.
IntExpr *	MakeModulo (IntExpr *x, int64_t mod)
	Modulo expression x % mod (with the python convention for modulo).
IntExpr *	MakeModulo (IntExpr x, IntExpr mod)
	Modulo expression x % mod (with the python convention for modulo).
IntExpr *	MakeConditionalExpression (IntVar condition, IntExpr expr, int64_t unperformed_value)
	Conditional Expr condition ? expr : unperformed_value.
Constraint *	MakeTrueConstraint ()
	This constraint always succeeds.
Constraint *	MakeFalseConstraint ()
	This constraint always fails.
Constraint *	MakeFalseConstraint (const std::string &explanation)
Constraint *	MakeIsEqualCstCt (IntExpr var, int64_t value, IntVar boolvar)
	boolvar == (var == value)
IntVar *	MakeIsEqualCstVar (IntExpr *var, int64_t value)
	status var of (var == value)
Constraint *	MakeIsEqualCt (IntExpr v1, IntExpr v2, IntVar *b)
	b == (v1 == v2)
IntVar *	MakeIsEqualVar (IntExpr v1, IntExpr v2)
	status var of (v1 == v2)
Constraint *	MakeEquality (IntExpr left, IntExpr right)
	left == right
Constraint *	MakeEquality (IntExpr *expr, int64_t value)
	expr == value
Constraint *	MakeEquality (IntExpr *expr, int value)
	expr == value
Constraint *	MakeIsDifferentCstCt (IntExpr var, int64_t value, IntVar boolvar)
	boolvar == (var != value)
IntVar *	MakeIsDifferentCstVar (IntExpr *var, int64_t value)
	status var of (var != value)
IntVar *	MakeIsDifferentVar (IntExpr v1, IntExpr v2)
	status var of (v1 != v2)
Constraint *	MakeIsDifferentCt (IntExpr v1, IntExpr v2, IntVar *b)
	b == (v1 != v2)
Constraint *	MakeNonEquality (IntExpr left, IntExpr right)
	left != right
Constraint *	MakeNonEquality (IntExpr *expr, int64_t value)
	expr != value
Constraint *	MakeNonEquality (IntExpr *expr, int value)
	expr != value
Constraint *	MakeIsLessOrEqualCstCt (IntExpr var, int64_t value, IntVar boolvar)
	boolvar == (var <= value)
IntVar *	MakeIsLessOrEqualCstVar (IntExpr *var, int64_t value)
	status var of (var <= value)
IntVar *	MakeIsLessOrEqualVar (IntExpr left, IntExpr right)
	status var of (left <= right)
Constraint *	MakeIsLessOrEqualCt (IntExpr left, IntExpr right, IntVar *b)
	b == (left <= right)
Constraint *	MakeLessOrEqual (IntExpr left, IntExpr right)
	left <= right
Constraint *	MakeLessOrEqual (IntExpr *expr, int64_t value)
	expr <= value
Constraint *	MakeLessOrEqual (IntExpr *expr, int value)
	expr <= value
Constraint *	MakeIsGreaterOrEqualCstCt (IntExpr var, int64_t value, IntVar boolvar)
	boolvar == (var >= value)
IntVar *	MakeIsGreaterOrEqualCstVar (IntExpr *var, int64_t value)
	status var of (var >= value)
IntVar *	MakeIsGreaterOrEqualVar (IntExpr left, IntExpr right)
	status var of (left >= right)
Constraint *	MakeIsGreaterOrEqualCt (IntExpr left, IntExpr right, IntVar *b)
	b == (left >= right)
Constraint *	MakeGreaterOrEqual (IntExpr left, IntExpr right)
	left >= right
Constraint *	MakeGreaterOrEqual (IntExpr *expr, int64_t value)
	expr >= value
Constraint *	MakeGreaterOrEqual (IntExpr *expr, int value)
	expr >= value
Constraint *	MakeIsGreaterCstCt (IntExpr v, int64_t c, IntVar b)
	b == (v > c)
IntVar *	MakeIsGreaterCstVar (IntExpr *var, int64_t value)
	status var of (var > value)
IntVar *	MakeIsGreaterVar (IntExpr left, IntExpr right)
	status var of (left > right)
Constraint *	MakeIsGreaterCt (IntExpr left, IntExpr right, IntVar *b)
	b == (left > right)
Constraint *	MakeGreater (IntExpr left, IntExpr right)
	left > right
Constraint *	MakeGreater (IntExpr *expr, int64_t value)
	expr > value
Constraint *	MakeGreater (IntExpr *expr, int value)
	expr > value
Constraint *	MakeIsLessCstCt (IntExpr v, int64_t c, IntVar b)
	b == (v < c)
IntVar *	MakeIsLessCstVar (IntExpr *var, int64_t value)
	status var of (var < value)
IntVar *	MakeIsLessVar (IntExpr left, IntExpr right)
	status var of (left < right)
Constraint *	MakeIsLessCt (IntExpr left, IntExpr right, IntVar *b)
	b == (left < right)
Constraint *	MakeLess (IntExpr left, IntExpr right)
	left < right
Constraint *	MakeLess (IntExpr *expr, int64_t value)
	expr < value
Constraint *	MakeLess (IntExpr *expr, int value)
	expr < value
Constraint *	MakeSumLessOrEqual (const std::vector< IntVar * > &vars, int64_t cst)
	Variation on arrays.
Constraint *	MakeSumGreaterOrEqual (const std::vector< IntVar * > &vars, int64_t cst)
Constraint *	MakeSumEquality (const std::vector< IntVar * > &vars, int64_t cst)
Constraint *	MakeSumEquality (const std::vector< IntVar * > &vars, IntVar *var)
Constraint *	MakeScalProdEquality (const std::vector< IntVar * > &vars, const std::vector< int64_t > &coefficients, int64_t cst)
Constraint *	MakeScalProdEquality (const std::vector< IntVar * > &vars, const std::vector< int > &coefficients, int64_t cst)
Constraint *	MakeScalProdEquality (const std::vector< IntVar * > &vars, const std::vector< int64_t > &coefficients, IntVar *target)
Constraint *	MakeScalProdEquality (const std::vector< IntVar * > &vars, const std::vector< int > &coefficients, IntVar *target)
Constraint *	MakeScalProdGreaterOrEqual (const std::vector< IntVar * > &vars, const std::vector< int64_t > &coeffs, int64_t cst)
Constraint *	MakeScalProdGreaterOrEqual (const std::vector< IntVar * > &vars, const std::vector< int > &coeffs, int64_t cst)
Constraint *	MakeScalProdLessOrEqual (const std::vector< IntVar * > &vars, const std::vector< int64_t > &coefficients, int64_t cst)
Constraint *	MakeScalProdLessOrEqual (const std::vector< IntVar * > &vars, const std::vector< int > &coefficients, int64_t cst)
Constraint *	MakeMinEquality (const std::vector< IntVar * > &vars, IntVar *min_var)
Constraint *	MakeMaxEquality (const std::vector< IntVar * > &vars, IntVar *max_var)
Constraint *	MakeElementEquality (const std::vector< int64_t > &vals, IntVar index, IntVar target)
Constraint *	MakeElementEquality (const std::vector< int > &vals, IntVar index, IntVar target)
Constraint *	MakeElementEquality (const std::vector< IntVar * > &vars, IntVar index, IntVar target)
Constraint *	MakeElementEquality (const std::vector< IntVar * > &vars, IntVar *index, int64_t target)
Constraint *	MakeAbsEquality (IntVar var, IntVar abs_var)
	Creates the constraint abs(var) == abs_var.
Constraint *	MakeIndexOfConstraint (const std::vector< IntVar * > &vars, IntVar *index, int64_t target)
Demon *	MakeConstraintInitialPropagateCallback (Constraint *ct)
Demon *	MakeDelayedConstraintInitialPropagateCallback (Constraint *ct)
Demon *	MakeActionDemon (Action action)
	Creates a demon from a callback.
Demon *	MakeClosureDemon (Closure closure)
	Creates a demon from a closure.
Constraint *	MakeBetweenCt (IntExpr *expr, int64_t l, int64_t u)
	(l <= expr <= u)
Constraint *	MakeNotBetweenCt (IntExpr *expr, int64_t l, int64_t u)
Constraint *	MakeIsBetweenCt (IntExpr expr, int64_t l, int64_t u, IntVar b)
	b == (l <= expr <= u)
IntVar *	MakeIsBetweenVar (IntExpr *v, int64_t l, int64_t u)
Constraint *	MakeMemberCt (IntExpr *expr, const std::vector< int64_t > &values)
Constraint *	MakeMemberCt (IntExpr *expr, const std::vector< int > &values)
Constraint *	MakeNotMemberCt (IntExpr *expr, const std::vector< int64_t > &values)
	expr not in set.
Constraint *	MakeNotMemberCt (IntExpr *expr, const std::vector< int > &values)
Constraint *	MakeNotMemberCt (IntExpr *expr, std::vector< int64_t > starts, std::vector< int64_t > ends)
	expr should not be in the list of forbidden intervals [start[i]..end[i]].
Constraint *	MakeNotMemberCt (IntExpr *expr, std::vector< int > starts, std::vector< int > ends)
	expr should not be in the list of forbidden intervals [start[i]..end[i]].
Constraint *	MakeNotMemberCt (IntExpr *expr, SortedDisjointIntervalList intervals)
	expr should not be in the list of forbidden intervals.
Constraint *	MakeIsMemberCt (IntExpr expr, const std::vector< int64_t > &values, IntVar boolvar)
	boolvar == (expr in set)
Constraint *	MakeIsMemberCt (IntExpr expr, const std::vector< int > &values, IntVar boolvar)
IntVar *	MakeIsMemberVar (IntExpr *expr, const std::vector< int64_t > &values)
IntVar *	MakeIsMemberVar (IntExpr *expr, const std::vector< int > &values)
Constraint *	MakeAtMost (std::vector< IntVar * > vars, int64_t value, int64_t max_count)
	\|{i \| vars[i] == value}\| <= max_count
Constraint *	MakeCount (const std::vector< IntVar * > &vars, int64_t value, int64_t max_count)
	\|{i \| vars[i] == value}\| == max_count
Constraint *	MakeCount (const std::vector< IntVar * > &vars, int64_t value, IntVar *max_count)
	\|{i \| vars[i] == value}\| == max_count
Constraint *	MakeDistribute (const std::vector< IntVar * > &vars, const std::vector< int64_t > &values, const std::vector< IntVar * > &cards)
	Aggregated version of count: \|{i \| v[i] == values[j]}\| == cards[j].
Constraint *	MakeDistribute (const std::vector< IntVar * > &vars, const std::vector< int > &values, const std::vector< IntVar * > &cards)
	Aggregated version of count: \|{i \| v[i] == values[j]}\| == cards[j].
Constraint *	MakeDistribute (const std::vector< IntVar * > &vars, const std::vector< IntVar * > &cards)
	Aggregated version of count: \|{i \| v[i] == j}\| == cards[j].
Constraint *	MakeDistribute (const std::vector< IntVar * > &vars, int64_t card_min, int64_t card_max, int64_t card_size)
Constraint *	MakeDistribute (const std::vector< IntVar * > &vars, const std::vector< int64_t > &card_min, const std::vector< int64_t > &card_max)
Constraint *	MakeDistribute (const std::vector< IntVar * > &vars, const std::vector< int > &card_min, const std::vector< int > &card_max)
Constraint *	MakeDistribute (const std::vector< IntVar * > &vars, const std::vector< int64_t > &values, const std::vector< int64_t > &card_min, const std::vector< int64_t > &card_max)
Constraint *	MakeDistribute (const std::vector< IntVar * > &vars, const std::vector< int > &values, const std::vector< int > &card_min, const std::vector< int > &card_max)
Constraint *	MakeDeviation (const std::vector< IntVar * > &vars, IntVar *deviation_var, int64_t total_sum)
Constraint *	MakeAllDifferent (const std::vector< IntVar * > &vars)
Constraint *	MakeAllDifferent (const std::vector< IntVar * > &vars, bool stronger_propagation)
Constraint *	MakeAllDifferentExcept (const std::vector< IntVar * > &vars, int64_t escape_value)
Constraint *	MakeSortingConstraint (const std::vector< IntVar * > &vars, const std::vector< IntVar * > &sorted)
Constraint *	MakeLexicalLess (const std::vector< IntVar * > &left, const std::vector< IntVar * > &right)
Constraint *	MakeLexicalLessOrEqual (const std::vector< IntVar * > &left, const std::vector< IntVar * > &right)
Constraint *	MakeLexicalLessOrEqualWithOffsets (std::vector< IntVar * > left, std::vector< IntVar * > right, std::vector< int64_t > offsets)
Constraint *	MakeIsLexicalLessOrEqualWithOffsetsCt (std::vector< IntVar * > left, std::vector< IntVar * > right, std::vector< int64_t > offsets, IntVar *boolvar)
Constraint *	MakeInversePermutationConstraint (const std::vector< IntVar * > &left, const std::vector< IntVar * > &right)
Constraint *	MakeIndexOfFirstMaxValueConstraint (IntVar index, const std::vector< IntVar > &vars)
Constraint *	MakeIndexOfFirstMinValueConstraint (IntVar index, const std::vector< IntVar > &vars)
Constraint *	MakeNullIntersect (const std::vector< IntVar * > &first_vars, const std::vector< IntVar * > &second_vars)
Constraint *	MakeNullIntersectExcept (const std::vector< IntVar * > &first_vars, const std::vector< IntVar * > &second_vars, int64_t escape_value)
Constraint *	MakeNoCycle (const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, IndexFilter1 sink_handler=nullptr)
Constraint *	MakeNoCycle (const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, IndexFilter1 sink_handler, bool assume_paths)
Constraint *	MakeCircuit (const std::vector< IntVar * > &nexts)
	Force the "nexts" variable to create a complete Hamiltonian path.
Constraint *	MakeSubCircuit (const std::vector< IntVar * > &nexts)
Constraint *	MakePathCumul (const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, const std::vector< IntVar * > &cumuls, const std::vector< IntVar * > &transits)
Constraint *	MakeDelayedPathCumul (const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, const std::vector< IntVar * > &cumuls, const std::vector< IntVar * > &transits)
Constraint *	MakePathCumul (const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, const std::vector< IntVar * > &cumuls, IndexEvaluator2 transit_evaluator)
Constraint *	MakePathCumul (const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, const std::vector< IntVar * > &cumuls, const std::vector< IntVar * > &slacks, IndexEvaluator2 transit_evaluator)
Constraint *	MakePathConnected (std::vector< IntVar * > nexts, std::vector< int64_t > sources, std::vector< int64_t > sinks, std::vector< IntVar * > status)
	Check whether more propagation is needed.
Constraint *	MakePathPrecedenceConstraint (std::vector< IntVar * > nexts, const std::vector< std::pair< int, int > > &precedences)
Constraint *	MakePathPrecedenceConstraint (std::vector< IntVar * > nexts, const std::vector< std::pair< int, int > > &precedences, absl::Span< const int > lifo_path_starts, absl::Span< const int > fifo_path_starts)
Constraint *	MakePathTransitPrecedenceConstraint (std::vector< IntVar * > nexts, std::vector< IntVar * > transits, const std::vector< std::pair< int, int > > &precedences)
Constraint *	MakePathEnergyCostConstraint (PathEnergyCostConstraintSpecification specification)
Constraint *	MakeMapDomain (IntVar var, const std::vector< IntVar > &actives)
Constraint *	MakeAllowedAssignments (const std::vector< IntVar * > &vars, const IntTupleSet &tuples)
Constraint *	MakeTransitionConstraint (const std::vector< IntVar * > &vars, const IntTupleSet &transition_table, int64_t initial_state, const std::vector< int64_t > &final_states)
Constraint *	MakeTransitionConstraint (const std::vector< IntVar * > &vars, const IntTupleSet &transition_table, int64_t initial_state, const std::vector< int > &final_states)
Constraint *	MakeNonOverlappingBoxesConstraint (const std::vector< IntVar * > &x_vars, const std::vector< IntVar * > &y_vars, const std::vector< IntVar * > &x_size, const std::vector< IntVar * > &y_size)
Constraint *	MakeNonOverlappingBoxesConstraint (const std::vector< IntVar * > &x_vars, const std::vector< IntVar * > &y_vars, absl::Span< const int64_t > x_size, absl::Span< const int64_t > y_size)
Constraint *	MakeNonOverlappingBoxesConstraint (const std::vector< IntVar * > &x_vars, const std::vector< IntVar * > &y_vars, absl::Span< const int > x_size, absl::Span< const int > y_size)
Constraint *	MakeNonOverlappingNonStrictBoxesConstraint (const std::vector< IntVar * > &x_vars, const std::vector< IntVar * > &y_vars, const std::vector< IntVar * > &x_size, const std::vector< IntVar * > &y_size)
Constraint *	MakeNonOverlappingNonStrictBoxesConstraint (const std::vector< IntVar * > &x_vars, const std::vector< IntVar * > &y_vars, absl::Span< const int64_t > x_size, absl::Span< const int64_t > y_size)
Constraint *	MakeNonOverlappingNonStrictBoxesConstraint (const std::vector< IntVar * > &x_vars, const std::vector< IntVar * > &y_vars, absl::Span< const int > x_size, absl::Span< const int > y_size)
Pack *	MakePack (const std::vector< IntVar * > &vars, int number_of_bins)
IntervalVar *	MakeFixedDurationIntervalVar (int64_t start_min, int64_t start_max, int64_t duration, bool optional, const std::string &name)
void	MakeFixedDurationIntervalVarArray (int count, int64_t start_min, int64_t start_max, int64_t duration, bool optional, absl::string_view name, std::vector< IntervalVar * > *array)
IntervalVar *	MakeFixedDurationIntervalVar (IntVar *start_variable, int64_t duration, const std::string &name)
IntervalVar *	MakeFixedDurationIntervalVar (IntVar start_variable, int64_t duration, IntVar performed_variable, const std::string &name)
void	MakeFixedDurationIntervalVarArray (const std::vector< IntVar * > &start_variables, int64_t duration, absl::string_view name, std::vector< IntervalVar * > *array)
void	MakeFixedDurationIntervalVarArray (const std::vector< IntVar * > &start_variables, absl::Span< const int64_t > durations, absl::string_view name, std::vector< IntervalVar * > *array)
void	MakeFixedDurationIntervalVarArray (const std::vector< IntVar * > &start_variables, absl::Span< const int > durations, absl::string_view name, std::vector< IntervalVar * > *array)
void	MakeFixedDurationIntervalVarArray (const std::vector< IntVar * > &start_variables, absl::Span< const int64_t > durations, const std::vector< IntVar * > &performed_variables, absl::string_view name, std::vector< IntervalVar * > *array)
void	MakeFixedDurationIntervalVarArray (const std::vector< IntVar * > &start_variables, absl::Span< const int > durations, const std::vector< IntVar * > &performed_variables, absl::string_view name, std::vector< IntervalVar * > *array)
IntervalVar *	MakeFixedInterval (int64_t start, int64_t duration, const std::string &name)
	Creates a fixed and performed interval.
IntervalVar *	MakeIntervalVar (int64_t start_min, int64_t start_max, int64_t duration_min, int64_t duration_max, int64_t end_min, int64_t end_max, bool optional, const std::string &name)
void	MakeIntervalVarArray (int count, int64_t start_min, int64_t start_max, int64_t duration_min, int64_t duration_max, int64_t end_min, int64_t end_max, bool optional, absl::string_view name, std::vector< IntervalVar * > *array)
IntervalVar *	MakeMirrorInterval (IntervalVar *interval_var)
IntervalVar *	MakeFixedDurationStartSyncedOnStartIntervalVar (IntervalVar *interval_var, int64_t duration, int64_t offset)
IntervalVar *	MakeFixedDurationStartSyncedOnEndIntervalVar (IntervalVar *interval_var, int64_t duration, int64_t offset)
IntervalVar *	MakeFixedDurationEndSyncedOnStartIntervalVar (IntervalVar *interval_var, int64_t duration, int64_t offset)
IntervalVar *	MakeFixedDurationEndSyncedOnEndIntervalVar (IntervalVar *interval_var, int64_t duration, int64_t offset)
IntervalVar *	MakeIntervalRelaxedMin (IntervalVar *interval_var)
IntervalVar *	MakeIntervalRelaxedMax (IntervalVar *interval_var)
Constraint *	MakeIntervalVarRelation (IntervalVar *t, UnaryIntervalRelation r, int64_t d)
Constraint *	MakeIntervalVarRelation (IntervalVar t1, BinaryIntervalRelation r, IntervalVar t2)
	This method creates a relation between two interval vars.
Constraint *	MakeIntervalVarRelationWithDelay (IntervalVar t1, BinaryIntervalRelation r, IntervalVar t2, int64_t delay)
Constraint *	MakeTemporalDisjunction (IntervalVar t1, IntervalVar t2, IntVar *alt)
Constraint *	MakeTemporalDisjunction (IntervalVar t1, IntervalVar t2)
DisjunctiveConstraint *	MakeDisjunctiveConstraint (const std::vector< IntervalVar * > &intervals, const std::string &name)
DisjunctiveConstraint *	MakeStrictDisjunctiveConstraint (const std::vector< IntervalVar * > &intervals, const std::string &name)
Constraint *	MakeCumulative (const std::vector< IntervalVar * > &intervals, const std::vector< int64_t > &demands, int64_t capacity, const std::string &name)
	Intervals and demands should be vectors of equal size.
Constraint *	MakeCumulative (const std::vector< IntervalVar * > &intervals, const std::vector< int > &demands, int64_t capacity, const std::string &name)
	Intervals and demands should be vectors of equal size.
Constraint *	MakeCumulative (const std::vector< IntervalVar * > &intervals, const std::vector< int64_t > &demands, IntVar *capacity, absl::string_view name)
	Intervals and demands should be vectors of equal size.
Constraint *	MakeCumulative (const std::vector< IntervalVar * > &intervals, const std::vector< int > &demands, IntVar *capacity, const std::string &name)
	Intervals and demands should be vectors of equal size.
Constraint *	MakeCumulative (const std::vector< IntervalVar * > &intervals, const std::vector< IntVar * > &demands, int64_t capacity, const std::string &name)
	Intervals and demands should be vectors of equal size.
Constraint *	MakeCumulative (const std::vector< IntervalVar * > &intervals, const std::vector< IntVar * > &demands, IntVar *capacity, const std::string &name)
	Intervals and demands should be vectors of equal size.
Constraint *	MakeCover (const std::vector< IntervalVar * > &vars, IntervalVar *target_var)
Constraint *	MakeEquality (IntervalVar var1, IntervalVar var2)
	This constraints states that the two interval variables are equal.
Assignment *	MakeAssignment ()
	This method creates an empty assignment.
Assignment *	MakeAssignment (const Assignment *a)
	This method creates an assignment which is a copy of 'a'.
SolutionCollector *	MakeFirstSolutionCollector (const Assignment *assignment)
	Collect the first solution of the search.
SolutionCollector *	MakeFirstSolutionCollector ()
SolutionCollector *	MakeLastSolutionCollector (const Assignment *assignment)
	Collect the last solution of the search.
SolutionCollector *	MakeLastSolutionCollector ()
SolutionCollector *	MakeBestValueSolutionCollector (const Assignment *assignment, bool maximize)
SolutionCollector *	MakeBestLexicographicValueSolutionCollector (const Assignment *assignment, std::vector< bool > maximize)
SolutionCollector *	MakeBestValueSolutionCollector (bool maximize)
SolutionCollector *	MakeBestLexicographicValueSolutionCollector (std::vector< bool > maximize)
SolutionCollector *	MakeNBestValueSolutionCollector (const Assignment *assignment, int solution_count, bool maximize)
SolutionCollector *	MakeNBestValueSolutionCollector (int solution_count, bool maximize)
SolutionCollector *	MakeNBestLexicographicValueSolutionCollector (const Assignment *assignment, int solution_count, std::vector< bool > maximize)
SolutionCollector *	MakeNBestLexicographicValueSolutionCollector (int solution_count, std::vector< bool > maximize)
SolutionCollector *	MakeAllSolutionCollector (const Assignment *assignment)
	Collect all solutions of the search.
SolutionCollector *	MakeAllSolutionCollector ()
OptimizeVar *	MakeMinimize (IntVar *v, int64_t step)
	Creates a minimization objective.
OptimizeVar *	MakeMaximize (IntVar *v, int64_t step)
	Creates a maximization objective.
OptimizeVar *	MakeOptimize (bool maximize, IntVar *v, int64_t step)
	Creates a objective with a given sense (true = maximization).
OptimizeVar *	MakeWeightedMinimize (const std::vector< IntVar * > &sub_objectives, const std::vector< int64_t > &weights, int64_t step)
OptimizeVar *	MakeWeightedMinimize (const std::vector< IntVar * > &sub_objectives, const std::vector< int > &weights, int64_t step)
OptimizeVar *	MakeWeightedMaximize (const std::vector< IntVar * > &sub_objectives, const std::vector< int64_t > &weights, int64_t step)
	Creates a maximization weigthed objective.
OptimizeVar *	MakeWeightedMaximize (const std::vector< IntVar * > &sub_objectives, const std::vector< int > &weights, int64_t step)
	Creates a maximization weigthed objective.
OptimizeVar *	MakeWeightedOptimize (bool maximize, const std::vector< IntVar * > &sub_objectives, const std::vector< int64_t > &weights, int64_t step)
	Creates a weighted objective with a given sense (true = maximization).
OptimizeVar *	MakeWeightedOptimize (bool maximize, const std::vector< IntVar * > &sub_objectives, const std::vector< int > &weights, int64_t step)
	Creates a weighted objective with a given sense (true = maximization).
OptimizeVar *	MakeLexicographicOptimize (std::vector< bool > maximize, std::vector< IntVar * > variables, std::vector< int64_t > steps)
ObjectiveMonitor *	MakeTabuSearch (bool maximize, IntVar objective, int64_t step, const std::vector< IntVar > &vars, int64_t keep_tenure, int64_t forbid_tenure, double tabu_factor)
	MetaHeuristics which try to get the search out of local optima.
ObjectiveMonitor *	MakeLexicographicTabuSearch (const std::vector< bool > &maximize, std::vector< IntVar * > objectives, std::vector< int64_t > steps, const std::vector< IntVar * > &vars, int64_t keep_tenure, int64_t forbid_tenure, double tabu_factor)
ObjectiveMonitor *	MakeGenericTabuSearch (bool maximize, IntVar v, int64_t step, const std::vector< IntVar > &tabu_vars, int64_t forbid_tenure)
ObjectiveMonitor *	MakeSimulatedAnnealing (bool maximize, IntVar *v, int64_t step, int64_t initial_temperature)
	Creates a Simulated Annealing monitor.
ObjectiveMonitor *	MakeLexicographicSimulatedAnnealing (const std::vector< bool > &maximize, std::vector< IntVar * > vars, std::vector< int64_t > steps, std::vector< int64_t > initial_temperatures)
ObjectiveMonitor *	MakeGuidedLocalSearch (bool maximize, IntVar objective, IndexEvaluator2 objective_function, int64_t step, const std::vector< IntVar > &vars, double penalty_factor, std::function< std::vector< std::pair< int64_t, int64_t > >(int64_t, int64_t)> get_equivalent_pairs=nullptr, bool reset_penalties_on_new_best_solution=false)
ObjectiveMonitor *	MakeGuidedLocalSearch (bool maximize, IntVar objective, IndexEvaluator3 objective_function, int64_t step, const std::vector< IntVar > &vars, const std::vector< IntVar * > &secondary_vars, double penalty_factor, std::function< std::vector< std::pair< int64_t, int64_t > >(int64_t, int64_t)> get_equivalent_pairs=nullptr, bool reset_penalties_on_new_best_solution=false)
BaseObjectiveMonitor *	MakeRoundRobinCompoundObjectiveMonitor (std::vector< BaseObjectiveMonitor * > monitors, int num_max_local_optima_before_metaheuristic_switch)
SearchMonitor *	MakeLubyRestart (int scale_factor)
SearchMonitor *	MakeConstantRestart (int frequency)
ABSL_MUST_USE_RESULT RegularLimit *	MakeTimeLimit (absl::Duration time)
	Creates a search limit that constrains the running time.
ABSL_MUST_USE_RESULT RegularLimit *	MakeTimeLimit (int64_t time_in_ms)
ABSL_MUST_USE_RESULT RegularLimit *	MakeBranchesLimit (int64_t branches)
ABSL_MUST_USE_RESULT RegularLimit *	MakeFailuresLimit (int64_t failures)
ABSL_MUST_USE_RESULT RegularLimit *	MakeSolutionsLimit (int64_t solutions)
ABSL_MUST_USE_RESULT RegularLimit *	MakeLimit (absl::Duration time, int64_t branches, int64_t failures, int64_t solutions, bool smart_time_check=false, bool cumulative=false)
ABSL_MUST_USE_RESULT RegularLimit *	MakeLimit (const RegularLimitParameters &proto)
	Creates a search limit from its protobuf description.
ABSL_MUST_USE_RESULT RegularLimit *	MakeLimit (int64_t time, int64_t branches, int64_t failures, int64_t solutions, bool smart_time_check=false, bool cumulative=false)
RegularLimitParameters	MakeDefaultRegularLimitParameters () const
	Creates a regular limit proto containing default values.
ABSL_MUST_USE_RESULT SearchLimit *	MakeLimit (SearchLimit limit_1, SearchLimit limit_2)
ABSL_MUST_USE_RESULT ImprovementSearchLimit *	MakeImprovementLimit (IntVar *objective_var, bool maximize, double objective_scaling_factor, double objective_offset, double improvement_rate_coefficient, int improvement_rate_solutions_distance)
ABSL_MUST_USE_RESULT ImprovementSearchLimit *	MakeLexicographicImprovementLimit (std::vector< IntVar * > objective_vars, std::vector< bool > maximize, std::vector< double > objective_scaling_factors, std::vector< double > objective_offsets, double improvement_rate_coefficient, int improvement_rate_solutions_distance)
ABSL_MUST_USE_RESULT SearchLimit *	MakeCustomLimit (std::function< bool()> limiter)
SearchMonitor *	MakeSearchLog (int branch_period)
SearchMonitor *	MakeSearchLog (int branch_period, IntVar *var)
	At each solution, this monitor also display the var value.
SearchMonitor *	MakeSearchLog (int branch_period, std::function< std::string()> display_callback)
SearchMonitor *	MakeSearchLog (int branch_period, IntVar *var, std::function< std::string()> display_callback)
SearchMonitor *	MakeSearchLog (int branch_period, std::vector< IntVar * > vars, std::function< std::string()> display_callback)
SearchMonitor *	MakeSearchLog (int branch_period, OptimizeVar *opt_var)
SearchMonitor *	MakeSearchLog (int branch_period, OptimizeVar *opt_var, std::function< std::string()> display_callback)
SearchMonitor *	MakeSearchLog (SearchLogParameters parameters)
SearchMonitor *	MakeSearchTrace (const std::string &prefix)
SearchMonitor *	MakeEnterSearchCallback (std::function< void()> callback)
	--— Callback-based search monitors --—
SearchMonitor *	MakeExitSearchCallback (std::function< void()> callback)
SearchMonitor *	MakeAtSolutionCallback (std::function< void()> callback)
ModelVisitor *	MakePrintModelVisitor ()
	Prints the model.
ModelVisitor *	MakeStatisticsModelVisitor ()
	Displays some nice statistics on the model.
ModelVisitor *	MakeVariableDegreeVisitor (absl::flat_hash_map< const IntVar , int > map)
	Compute the number of constraints a variable is attached to.
SearchMonitor *	MakeSymmetryManager (const std::vector< SymmetryBreaker * > &visitors)
	Symmetry Breaking.
SearchMonitor *	MakeSymmetryManager (SymmetryBreaker *v1)
SearchMonitor *	MakeSymmetryManager (SymmetryBreaker v1, SymmetryBreaker v2)
SearchMonitor *	MakeSymmetryManager (SymmetryBreaker v1, SymmetryBreaker v2, SymmetryBreaker *v3)
SearchMonitor *	MakeSymmetryManager (SymmetryBreaker v1, SymmetryBreaker v2, SymmetryBreaker v3, SymmetryBreaker v4)
Decision *	MakeAssignVariableValue (IntVar *var, int64_t val)
	Decisions.
Decision *	MakeVariableLessOrEqualValue (IntVar *var, int64_t value)
Decision *	MakeVariableGreaterOrEqualValue (IntVar *var, int64_t value)
Decision *	MakeSplitVariableDomain (IntVar *var, int64_t val, bool start_with_lower_half)
Decision *	MakeAssignVariableValueOrFail (IntVar *var, int64_t value)
Decision *	MakeAssignVariableValueOrDoNothing (IntVar *var, int64_t value)
Decision *	MakeAssignVariablesValues (const std::vector< IntVar * > &vars, const std::vector< int64_t > &values)
Decision *	MakeAssignVariablesValuesOrDoNothing (const std::vector< IntVar * > &vars, const std::vector< int64_t > &values)
Decision *	MakeAssignVariablesValuesOrFail (const std::vector< IntVar * > &vars, const std::vector< int64_t > &values)
Decision *	MakeFailDecision ()
Decision *	MakeDecision (Action apply, Action refute)
DecisionBuilder *	Compose (DecisionBuilder db1, DecisionBuilder db2)
DecisionBuilder *	Compose (DecisionBuilder db1, DecisionBuilder db2, DecisionBuilder *db3)
DecisionBuilder *	Compose (DecisionBuilder db1, DecisionBuilder db2, DecisionBuilder db3, DecisionBuilder db4)
DecisionBuilder *	Compose (const std::vector< DecisionBuilder * > &dbs)
DecisionBuilder *	Try (DecisionBuilder db1, DecisionBuilder db2)
DecisionBuilder *	Try (DecisionBuilder db1, DecisionBuilder db2, DecisionBuilder *db3)
DecisionBuilder *	Try (DecisionBuilder db1, DecisionBuilder db2, DecisionBuilder db3, DecisionBuilder db4)
DecisionBuilder *	Try (const std::vector< DecisionBuilder * > &dbs)
DecisionBuilder *	MakePhase (const std::vector< IntVar * > &vars, IntVarStrategy var_str, IntValueStrategy val_str)
	Phases on IntVar arrays.
DecisionBuilder *	MakePhase (const std::vector< IntVar * > &vars, IndexEvaluator1 var_evaluator, IntValueStrategy val_str)
DecisionBuilder *	MakePhase (const std::vector< IntVar * > &vars, IntVarStrategy var_str, IndexEvaluator2 value_evaluator)
DecisionBuilder *	MakePhase (const std::vector< IntVar * > &vars, IntVarStrategy var_str, VariableValueComparator var_val1_val2_comparator)
DecisionBuilder *	MakePhase (const std::vector< IntVar * > &vars, IndexEvaluator1 var_evaluator, IndexEvaluator2 value_evaluator)
DecisionBuilder *	MakePhase (const std::vector< IntVar * > &vars, IntVarStrategy var_str, IndexEvaluator2 value_evaluator, IndexEvaluator1 tie_breaker)
DecisionBuilder *	MakePhase (const std::vector< IntVar * > &vars, IndexEvaluator1 var_evaluator, IndexEvaluator2 value_evaluator, IndexEvaluator1 tie_breaker)
DecisionBuilder *	MakeDefaultPhase (const std::vector< IntVar * > &vars)
DecisionBuilder *	MakeDefaultPhase (const std::vector< IntVar * > &vars, const DefaultPhaseParameters &parameters)
DecisionBuilder *	MakePhase (IntVar *v0, IntVarStrategy var_str, IntValueStrategy val_str)
	Shortcuts for small arrays.
DecisionBuilder *	MakePhase (IntVar v0, IntVar v1, IntVarStrategy var_str, IntValueStrategy val_str)
DecisionBuilder *	MakePhase (IntVar v0, IntVar v1, IntVar *v2, IntVarStrategy var_str, IntValueStrategy val_str)
DecisionBuilder *	MakePhase (IntVar v0, IntVar v1, IntVar v2, IntVar v3, IntVarStrategy var_str, IntValueStrategy val_str)
Decision *	MakeScheduleOrPostpone (IntervalVar var, int64_t est, int64_t marker)
Decision *	MakeScheduleOrExpedite (IntervalVar var, int64_t est, int64_t marker)
Decision *	MakeRankFirstInterval (SequenceVar *sequence, int index)
Decision *	MakeRankLastInterval (SequenceVar *sequence, int index)
DecisionBuilder *	MakePhase (const std::vector< IntVar * > &vars, IndexEvaluator2 eval, EvaluatorStrategy str)
DecisionBuilder *	MakePhase (const std::vector< IntVar * > &vars, IndexEvaluator2 eval, IndexEvaluator1 tie_breaker, EvaluatorStrategy str)
DecisionBuilder *	MakePhase (const std::vector< IntervalVar * > &intervals, IntervalStrategy str)
	Scheduling phases.
DecisionBuilder *	MakePhase (const std::vector< SequenceVar * > &sequences, SequenceStrategy str)
DecisionBuilder *	MakeDecisionBuilderFromAssignment (Assignment assignment, DecisionBuilder db, const std::vector< IntVar * > &vars)
DecisionBuilder *	MakeConstraintAdder (Constraint *ct)
DecisionBuilder *	MakeSolveOnce (DecisionBuilder *db)
DecisionBuilder *	MakeSolveOnce (DecisionBuilder db, SearchMonitor monitor1)
DecisionBuilder *	MakeSolveOnce (DecisionBuilder db, SearchMonitor monitor1, SearchMonitor *monitor2)
DecisionBuilder *	MakeSolveOnce (DecisionBuilder db, SearchMonitor monitor1, SearchMonitor monitor2, SearchMonitor monitor3)
DecisionBuilder *	MakeSolveOnce (DecisionBuilder db, SearchMonitor monitor1, SearchMonitor monitor2, SearchMonitor monitor3, SearchMonitor *monitor4)
DecisionBuilder *	MakeSolveOnce (DecisionBuilder db, const std::vector< SearchMonitor > &monitors)
DecisionBuilder *	MakeNestedOptimize (DecisionBuilder db, Assignment solution, bool maximize, int64_t step)
DecisionBuilder *	MakeNestedOptimize (DecisionBuilder db, Assignment solution, bool maximize, int64_t step, SearchMonitor *monitor1)
DecisionBuilder *	MakeNestedOptimize (DecisionBuilder db, Assignment solution, bool maximize, int64_t step, SearchMonitor monitor1, SearchMonitor monitor2)
DecisionBuilder *	MakeNestedOptimize (DecisionBuilder db, Assignment solution, bool maximize, int64_t step, SearchMonitor monitor1, SearchMonitor monitor2, SearchMonitor *monitor3)
DecisionBuilder *	MakeNestedOptimize (DecisionBuilder db, Assignment solution, bool maximize, int64_t step, SearchMonitor monitor1, SearchMonitor monitor2, SearchMonitor monitor3, SearchMonitor monitor4)
DecisionBuilder *	MakeNestedOptimize (DecisionBuilder db, Assignment solution, bool maximize, int64_t step, const std::vector< SearchMonitor * > &monitors)
DecisionBuilder *	MakeRestoreAssignment (Assignment *assignment)
DecisionBuilder *	MakeStoreAssignment (Assignment *assignment)
LocalSearchOperator *	MakeOperator (const std::vector< IntVar * > &vars, LocalSearchOperators op, std::function< const std::vector< int > &(int, int)> get_incoming_neighbors=nullptr, std::function< const std::vector< int > &(int, int)> get_outgoing_neighbors=nullptr)
	Local Search Operators.
LocalSearchOperator *	MakeOperator (const std::vector< IntVar * > &vars, const std::vector< IntVar * > &secondary_vars, LocalSearchOperators op, std::function< const std::vector< int > &(int, int)> get_incoming_neighbors=nullptr, std::function< const std::vector< int > &(int, int)> get_outgoing_neighbors=nullptr)
LocalSearchOperator *	MakeOperator (const std::vector< IntVar * > &vars, IndexEvaluator3 evaluator, EvaluatorLocalSearchOperators op)
LocalSearchOperator *	MakeOperator (const std::vector< IntVar * > &vars, const std::vector< IntVar * > &secondary_vars, IndexEvaluator3 evaluator, EvaluatorLocalSearchOperators op)
LocalSearchOperator *	MakeRandomLnsOperator (const std::vector< IntVar * > &vars, int number_of_variables)
LocalSearchOperator *	MakeRandomLnsOperator (const std::vector< IntVar * > &vars, int number_of_variables, int32_t seed)
LocalSearchOperator *	MakeMoveTowardTargetOperator (const Assignment &target)
LocalSearchOperator *	MakeMoveTowardTargetOperator (const std::vector< IntVar * > &variables, const std::vector< int64_t > &target_values)
LocalSearchOperator *	ConcatenateOperators (const std::vector< LocalSearchOperator * > &ops)
	Example:
LocalSearchOperator *	ConcatenateOperators (const std::vector< LocalSearchOperator * > &ops, bool restart)
LocalSearchOperator *	ConcatenateOperators (const std::vector< LocalSearchOperator * > &ops, std::function< int64_t(int, int)> evaluator)
LocalSearchOperator *	RandomConcatenateOperators (const std::vector< LocalSearchOperator * > &ops)
LocalSearchOperator *	RandomConcatenateOperators (const std::vector< LocalSearchOperator * > &ops, int32_t seed)
LocalSearchOperator *	MultiArmedBanditConcatenateOperators (const std::vector< LocalSearchOperator * > &ops, double memory_coefficient, double exploration_coefficient, bool maximize)
LocalSearchOperator *	MakeNeighborhoodLimit (LocalSearchOperator *op, int64_t limit)
DecisionBuilder *	MakeLocalSearchPhase (Assignment assignment, LocalSearchPhaseParameters parameters)
DecisionBuilder *	MakeLocalSearchPhase (const std::vector< IntVar * > &vars, DecisionBuilder first_solution, LocalSearchPhaseParameters parameters)
DecisionBuilder *	MakeLocalSearchPhase (const std::vector< IntVar * > &vars, DecisionBuilder first_solution, DecisionBuilder first_solution_sub_decision_builder, LocalSearchPhaseParameters *parameters)
	Variant with a sub_decison_builder specific to the first solution.
DecisionBuilder *	MakeLocalSearchPhase (const std::vector< SequenceVar * > &vars, DecisionBuilder first_solution, LocalSearchPhaseParameters parameters)
Assignment *	RunUncheckedLocalSearch (const Assignment initial_solution, LocalSearchFilterManager filter_manager, LocalSearchOperator ls_operator, const std::vector< SearchMonitor > &monitors, RegularLimit limit, absl::flat_hash_set< IntVar > *touched=nullptr)
SolutionPool *	MakeDefaultSolutionPool ()
	Solution Pool.
LocalSearchPhaseParameters *	MakeLocalSearchPhaseParameters (IntVar objective, LocalSearchOperator ls_operator, DecisionBuilder *sub_decision_builder)
	Local Search Phase Parameters.
LocalSearchPhaseParameters *	MakeLocalSearchPhaseParameters (IntVar objective, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder, RegularLimit limit)
LocalSearchPhaseParameters *	MakeLocalSearchPhaseParameters (IntVar objective, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder, RegularLimit limit, LocalSearchFilterManager *filter_manager)
LocalSearchPhaseParameters *	MakeLocalSearchPhaseParameters (IntVar objective, SolutionPool pool, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder)
LocalSearchPhaseParameters *	MakeLocalSearchPhaseParameters (IntVar objective, SolutionPool pool, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder, RegularLimit *limit)
LocalSearchPhaseParameters *	MakeLocalSearchPhaseParameters (IntVar objective, SolutionPool pool, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder, RegularLimit limit, LocalSearchFilterManager filter_manager)
LocalSearchFilter *	MakeAcceptFilter ()
	Local Search Filters.
LocalSearchFilter *	MakeRejectFilter ()
LocalSearchFilter *	MakeVariableDomainFilter ()
IntVarLocalSearchFilter *	MakeSumObjectiveFilter (const std::vector< IntVar * > &vars, IndexEvaluator2 values, Solver::LocalSearchFilterBound filter_enum)
IntVarLocalSearchFilter *	MakeSumObjectiveFilter (const std::vector< IntVar * > &vars, const std::vector< IntVar * > &secondary_vars, IndexEvaluator3 values, Solver::LocalSearchFilterBound filter_enum)
void	TopPeriodicCheck ()
int	TopProgressPercent ()
void	PushState ()
void	PopState ()
int	SearchDepth () const
int	SearchLeftDepth () const
int	SolveDepth () const
void	SetBranchSelector (BranchSelector bs)
	Sets the given branch selector on the current active search.
DecisionBuilder *	MakeApplyBranchSelector (BranchSelector bs)
	Creates a decision builder that will set the branch selector.
template<class T>
void	SaveAndSetValue (T *adr, T val)
	All-in-one SaveAndSetValue.
template<class T>
void	SaveAndAdd (T *adr, T val)
	All-in-one SaveAndAdd_value.
int64_t	Rand64 (int64_t size)
	Returns a random value between 0 and 'size' - 1;.
int32_t	Rand32 (int32_t size)
	Returns a random value between 0 and 'size' - 1;.
void	ReSeed (int32_t seed)
	Reseed the solver random generator.
void	ExportProfilingOverview (const std::string &filename)
std::string	LocalSearchProfile () const
	Returns local search profiling information in a human readable format.
ConstraintSolverStatistics	GetConstraintSolverStatistics () const
	Returns detailed cp search statistics.
LocalSearchStatistics	GetLocalSearchStatistics () const
	Returns detailed local search statistics.
bool	CurrentlyInSolve () const
int	constraints () const
void	Accept (ModelVisitor *visitor) const
	Accepts the given model visitor.
Decision *	balancing_decision () const
void	set_fail_intercept (std::function< void()> fail_intercept)
	Internal.
void	clear_fail_intercept ()
DemonProfiler *	demon_profiler () const
	Access to demon profiler.
void	SetUseFastLocalSearch (bool use_fast_local_search)
bool	UseFastLocalSearch () const
	Returns true if fast local search is enabled.
bool	HasName (const PropagationBaseObject *object) const
	Returns whether the object has been named or not.
Demon *	RegisterDemon (Demon *demon)
	Adds a new demon and wraps it inside a DemonProfiler if necessary.
IntExpr *	RegisterIntExpr (IntExpr *expr)
	Registers a new IntExpr and wraps it inside a TraceIntExpr if necessary.
IntVar *	RegisterIntVar (IntVar *var)
	Registers a new IntVar and wraps it inside a TraceIntVar if necessary.
IntervalVar *	RegisterIntervalVar (IntervalVar *var)
Search *	ActiveSearch () const
	Returns the active search, nullptr outside search.
ModelCache *	Cache () const
	Returns the cache of the model.
bool	InstrumentsDemons () const
	Returns whether we are instrumenting demons.
bool	IsProfilingEnabled () const
	Returns whether we are profiling the solver.
bool	IsLocalSearchProfilingEnabled () const
	Returns whether we are profiling local search.
bool	InstrumentsVariables () const
	Returns whether we are tracing variables.
bool	NameAllVariables () const
	Returns whether all variables should be named.
std::string	model_name () const
	Returns the name of the model.
PropagationMonitor *	GetPropagationMonitor () const
	Returns the propagation monitor.
void	AddPropagationMonitor (PropagationMonitor *monitor)
LocalSearchMonitor *	GetLocalSearchMonitor () const
	Returns the local search monitor.
void	AddLocalSearchMonitor (LocalSearchMonitor *monitor)
void	SetSearchContext (Search *search, absl::string_view search_context)
std::string	SearchContext () const
std::string	SearchContext (const Search *search) const
bool	AcceptSolution (Search *search) const
Assignment *	GetOrCreateLocalSearchState ()
	Returns (or creates) an assignment representing the state of local search.
void	ClearLocalSearchState ()
	Clears the local search state.
bool	IsBooleanVar (IntExpr expr, IntVar inner_var, bool is_negated) const
bool	IsProduct (IntExpr expr, IntExpr inner_expr, int64_t coefficient)
IntExpr *	CastExpression (const IntVar *var) const
	!defined(SWIG)
void	FinishCurrentSearch ()
	Tells the solver to kill or restart the current search.
void	RestartCurrentSearch ()
void	ShouldFail ()
void	CheckFail ()
DecisionBuilder *	MakeProfiledDecisionBuilderWrapper (DecisionBuilder *db)
	Activates profiling on a decision builder.

bool	Solve (DecisionBuilder db, const std::vector< SearchMonitor > &monitors)
bool	Solve (DecisionBuilder *db)
bool	Solve (DecisionBuilder db, SearchMonitor m1)
bool	Solve (DecisionBuilder db, SearchMonitor m1, SearchMonitor *m2)
bool	Solve (DecisionBuilder db, SearchMonitor m1, SearchMonitor m2, SearchMonitor m3)
bool	Solve (DecisionBuilder db, SearchMonitor m1, SearchMonitor m2, SearchMonitor m3, SearchMonitor *m4)

void	NewSearch (DecisionBuilder db, const std::vector< SearchMonitor > &monitors)
void	NewSearch (DecisionBuilder *db)
void	NewSearch (DecisionBuilder db, SearchMonitor m1)
void	NewSearch (DecisionBuilder db, SearchMonitor m1, SearchMonitor *m2)
void	NewSearch (DecisionBuilder db, SearchMonitor m1, SearchMonitor m2, SearchMonitor m3)
void	NewSearch (DecisionBuilder db, SearchMonitor m1, SearchMonitor m2, SearchMonitor m3, SearchMonitor *m4)
bool	NextSolution ()
void	RestartSearch ()
void	EndSearch ()

Static Public Member Functions
static ConstraintSolverParameters	DefaultSolverParameters ()
	Create a ConstraintSolverParameters proto with all the default values.
static int64_t	MemoryUsage ()
	Current memory usage in bytes.

Public Attributes
std::vector< int64_t >	tmp_vector_

Static Public Attributes
static constexpr int	kNumPriorities = 3
	Number of priorities for demons.

Friends
class	BaseIntExpr
class	Constraint
class	DemonProfiler
class	FindOneNeighbor
class	IntVar
class	PropagationBaseObject
class	Queue
class	SearchMonitor
class	SearchLimit
class	RoutingModel
class	LocalSearch
class	LocalSearchProfiler
template<class>
class	SimpleRevFIFO
template<class K, class V>
class	RevImmutableMultiMap
void	InternalSaveBooleanVarValue (Solver solver, IntVar var)

Member Typedef Documentation

◆ Action

typedef std::function<void(Solver*)> operations_research::Solver::Action

Definition at line 826 of file constraint_solver.h.

◆ BranchSelector

typedef std::function<DecisionModification()> operations_research::Solver::BranchSelector

Definition at line 824 of file constraint_solver.h.

◆ Closure

typedef std::function<void()> operations_research::Solver::Closure

Definition at line 827 of file constraint_solver.h.

◆ IndexEvaluator1

typedef std::function<int64_t(int64_t)> operations_research::Solver::IndexEvaluator1

Callback typedefs.

Definition at line 807 of file constraint_solver.h.

◆ IndexEvaluator2

typedef std::function<int64_t(int64_t, int64_t)> operations_research::Solver::IndexEvaluator2

Definition at line 808 of file constraint_solver.h.

◆ IndexEvaluator3

typedef std::function<int64_t(int64_t, int64_t, int64_t)> operations_research::Solver::IndexEvaluator3

Definition at line 809 of file constraint_solver.h.

◆ IndexFilter1

typedef std::function<bool(int64_t)> operations_research::Solver::IndexFilter1

Definition at line 811 of file constraint_solver.h.

◆ Int64ToIntVar

typedef std::function<IntVar*(int64_t)> operations_research::Solver::Int64ToIntVar

Definition at line 813 of file constraint_solver.h.

◆ VariableIndexSelector

typedef std::function<int64_t(Solver* solver, const std::vector<IntVar*>& vars, int64_t first_unbound, int64_t last_unbound)> operations_research::Solver::VariableIndexSelector

Definition at line 818 of file constraint_solver.h.

◆ VariableValueComparator

typedef std::function<bool(int64_t, int64_t, int64_t)> operations_research::Solver::VariableValueComparator

Definition at line 823 of file constraint_solver.h.

◆ VariableValueSelector

typedef std::function<int64_t(const IntVar* v, int64_t id)> operations_research::Solver::VariableValueSelector

Definition at line 821 of file constraint_solver.h.

Member Enumeration Documentation

◆ BinaryIntervalRelation

enum operations_research::Solver::BinaryIntervalRelation

This enum is used in Solver::MakeIntervalVarRelation to specify the temporal relation between the two intervals t1 and t2.

Enumerator
ENDS_AFTER_END	t1 ends after t2 end, i.e. End(t1) >= End(t2) + delay.
ENDS_AFTER_START	t1 ends after t2 start, i.e. End(t1) >= Start(t2) + delay.
ENDS_AT_END	t1 ends at t2 end, i.e. End(t1) == End(t2) + delay.
ENDS_AT_START	t1 ends at t2 start, i.e. End(t1) == Start(t2) + delay.
STARTS_AFTER_END	t1 starts after t2 end, i.e. Start(t1) >= End(t2) + delay.
STARTS_AFTER_START	t1 starts after t2 start, i.e. Start(t1) >= Start(t2) + delay.
STARTS_AT_END	t1 starts at t2 end, i.e. Start(t1) == End(t2) + delay.
STARTS_AT_START	t1 starts at t2 start, i.e. Start(t1) == Start(t2) + delay.
STAYS_IN_SYNC	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).

Definition at line 660 of file constraint_solver.h.

◆ DecisionModification

enum operations_research::Solver::DecisionModification

The Solver is responsible for creating the search tree. Thanks to the DecisionBuilder, it creates a new decision with two branches at each node: left and right. The DecisionModification enum is used to specify how the branch selector should behave.

Enumerator
NO_CHANGE	Keeps the default behavior, i.e. apply left branch first, and then right branch in case of backtracking.
KEEP_LEFT	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.
KEEP_RIGHT	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.
KILL_BOTH	Backtracks to the previous decisions, i.e. left and right branches are not applied.
SWITCH_BRANCHES	Applies right branch first. Left branch will be applied in case of backtracking.

Definition at line 728 of file constraint_solver.h.

◆ DemonPriority

enum operations_research::Solver::DemonPriority

This enum represents the three possible priorities for a demon in the Solver queue.

Note: this is for advanced users only.

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

Definition at line 646 of file constraint_solver.h.

◆ EvaluatorLocalSearchOperators

enum operations_research::Solver::EvaluatorLocalSearchOperators

This enum is used in Solver::MakeOperator associated with an evaluator to specify the neighborhood to create.

Enumerator
LK	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.
TSPOPT	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).
TSPLNS	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.

Definition at line 605 of file constraint_solver.h.

◆ EvaluatorStrategy

enum operations_research::Solver::EvaluatorStrategy

This enum is used by Solver::MakePhase to specify how to select variables and values during the search. In Solver::MakePhase(const std::vector<IntVar*>&, IntVarStrategy, IntValueStrategy), variables are selected first, and then the associated value. In Solver::MakePhase(const std::vector<IntVar*>& vars, IndexEvaluator2, EvaluatorStrategy), the selection is done scanning every pair <variable, possible value>. The next selected pair is then the best among all possibilities, i.e. the pair with the smallest evaluation. As this is costly, two options are offered: static or dynamic evaluation.

Enumerator
CHOOSE_STATIC_GLOBAL_BEST	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.
CHOOSE_DYNAMIC_GLOBAL_BEST	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.

Definition at line 401 of file constraint_solver.h.

◆ IntervalStrategy

enum operations_research::Solver::IntervalStrategy

This enum describes the straregy used to select the next interval variable and its value to be fixed.

Enumerator
INTERVAL_DEFAULT	The default is INTERVAL_SET_TIMES_FORWARD.
INTERVAL_SIMPLE	The simple is INTERVAL_SET_TIMES_FORWARD.
INTERVAL_SET_TIMES_FORWARD	Selects the variable with the lowest starting time of all variables, and fixes its starting time to this lowest value.
INTERVAL_SET_TIMES_BACKWARD	Selects the variable with the highest ending time of all variables, and fixes the ending time to this highest values.

Definition at line 425 of file constraint_solver.h.

◆ IntValueStrategy

enum operations_research::Solver::IntValueStrategy

This enum describes the strategy used to select the next variable value to set.

Enumerator
INT_VALUE_DEFAULT	The default behavior is ASSIGN_MIN_VALUE.
INT_VALUE_SIMPLE	The simple selection is ASSIGN_MIN_VALUE.
ASSIGN_MIN_VALUE	Selects the min value of the selected variable.
ASSIGN_MAX_VALUE	Selects the max value of the selected variable.
ASSIGN_RANDOM_VALUE	Selects randomly one of the possible values of the selected variable.
ASSIGN_CENTER_VALUE	Selects the first possible value which is the closest to the center of the domain of the selected variable. The center is defined as (min + max) / 2.
SPLIT_LOWER_HALF	Split the domain in two around the center, and choose the lower part first.
SPLIT_UPPER_HALF	Split the domain in two around the center, and choose the lower part first.

Definition at line 361 of file constraint_solver.h.

◆ IntVarStrategy

enum operations_research::Solver::IntVarStrategy

This enum describes the strategy used to select the next branching variable at each node during the search.

Enumerator
INT_VAR_DEFAULT	The default behavior is CHOOSE_FIRST_UNBOUND.
INT_VAR_SIMPLE	The simple selection is CHOOSE_FIRST_UNBOUND.
CHOOSE_FIRST_UNBOUND	Select the first unbound variable. Variables are considered in the order of the vector of IntVars used to create the selector.
CHOOSE_RANDOM	Randomly select one of the remaining unbound variables.
CHOOSE_MIN_SIZE_LOWEST_MIN	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	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	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	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	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	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	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	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	Among unbound variables, select the variable with the largest gap between the first and the second values of the domain.
CHOOSE_PATH	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.

Definition at line 280 of file constraint_solver.h.

◆ LocalSearchFilterBound

enum operations_research::Solver::LocalSearchFilterBound

This enum is used in Solver::MakeLocalSearchObjectiveFilter. It specifies the behavior of the objective filter to create. The goal is to define under which condition a move is accepted based on the current objective value.

Enumerator
GE	Move is accepted when the current objective value >= objective.Min.
LE	Move is accepted when the current objective value <= objective.Max.
EQ	Move is accepted when the current objective value is in the interval objective.Min .. objective.Max.

Definition at line 633 of file constraint_solver.h.

◆ LocalSearchOperators

enum operations_research::Solver::LocalSearchOperators

This enum is used in Solver::MakeOperator to specify the neighborhood to create.

Enumerator
TWOOPT	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	Relocate: OROPT and RELOCATE. Operator which moves a sub-chain of a path to another position; the specified chain length is the fixed length of the chains being moved. When this length is 1, the operator simply moves a node to another position. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5, for a chain length of 2 (where (1, 5) are first and last nodes of the path and can therefore not be moved): 1 -> 4 -> [2 -> 3] -> 5 1 -> [3 -> 4] -> 2 -> 5 Using Relocate with chain lengths of 1, 2 and 3 together is equivalent to the OrOpt operator on a path. The OrOpt operator is a limited version of 3Opt (breaks 3 arcs on a path).
RELOCATE	Relocate neighborhood with length of 1 (see OROPT comment).
EXCHANGE	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	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	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	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	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	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
SWAPACTIVECHAIN	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: 1 -> [5] -> 3 -> 4 with 2 inactive 1 -> 2 -> [5] -> 4 with 3 inactive 1 -> [5] -> 4 with 2 and 3 inactive
EXTENDEDSWAPACTIVE	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	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.
FULLPATHLNS	Operator which relaxes one entire path and all inactive nodes, thus defining num_paths neighbors.
UNACTIVELNS	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	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	Operator which defines a neighborhood to decrement values. The behavior is the same as INCREMENT, except values are decremented instead of incremented.
SIMPLELNS	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.

Definition at line 440 of file constraint_solver.h.

◆ MarkerType

enum operations_research::Solver::MarkerType

This enum is used internally in private methods Solver::PushState and Solver::PopState to tag states in the search tree.

Enumerator
SENTINEL
SIMPLE_MARKER
CHOICE_POINT
REVERSIBLE_ACTION

Definition at line 754 of file constraint_solver.h.

◆ MonitorEvent

enum class operations_research::Solver::MonitorEvent : int

strong

Search monitor events.

Enumerator
kEnterSearch
kRestartSearch
kExitSearch
kBeginNextDecision
kEndNextDecision
kApplyDecision
kRefuteDecision
kAfterDecision
kBeginFail
kEndFail
kBeginInitialPropagation
kEndInitialPropagation
kAcceptSolution
kAtSolution
kNoMoreSolutions
kLocalOptimum
kAcceptDelta
kAcceptNeighbor
kAcceptUncheckedNeighbor
kIsUncheckedSolutionLimitReached
kPeriodicCheck
kProgressPercent
kAccept
kLast

Definition at line 777 of file constraint_solver.h.

◆ OptimizationDirection

enum operations_research::Solver::OptimizationDirection

Optimization directions.

Enumerator
NOT_SET
MAXIMIZATION
MINIMIZATION

Definition at line 773 of file constraint_solver.h.

◆ SequenceStrategy

enum operations_research::Solver::SequenceStrategy

Used for scheduling. Not yet implemented.

Enumerator
SEQUENCE_DEFAULT
SEQUENCE_SIMPLE
CHOOSE_MIN_SLACK_RANK_FORWARD
CHOOSE_RANDOM_RANK_FORWARD

Definition at line 416 of file constraint_solver.h.

◆ SolverState

enum operations_research::Solver::SolverState

This enum represents the state of the solver w.r.t. the search.

Enumerator
OUTSIDE_SEARCH	Before search, after search.
IN_ROOT_NODE	Executing the root node.
IN_SEARCH	Executing the search code.
AT_SOLUTION	After successful NextSolution and before EndSearch.
NO_MORE_SOLUTIONS	After failed NextSolution and before EndSearch.
PROBLEM_INFEASIBLE	After search, the model is infeasible.

Definition at line 757 of file constraint_solver.h.

◆ UnaryIntervalRelation

enum operations_research::Solver::UnaryIntervalRelation

This enum is used in Solver::MakeIntervalVarRelation to specify the temporal relation between an interval t and an integer d.

Enumerator
ENDS_AFTER	t ends after d, i.e. End(t) >= d.
ENDS_AT	t ends at d, i.e. End(t) == d.
ENDS_BEFORE	t ends before d, i.e. End(t) <= d.
STARTS_AFTER	t starts after d, i.e. Start(t) >= d.
STARTS_AT	t starts at d, i.e. Start(t) == d.
STARTS_BEFORE	t starts before d, i.e. Start(t) <= d.
CROSS_DATE	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.
AVOID_DATE	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.

Definition at line 693 of file constraint_solver.h.

Constructor & Destructor Documentation

◆ Solver() [1/3]

operations_research::Solver::Solver ( const std::string & name )

explicit

Solver API.

Definition at line 1448 of file constraint_solver.cc.

◆ Solver() [2/3]

operations_research::Solver::Solver	(	const std::string &	name,
		const ConstraintSolverParameters &	parameters )

Definition at line 1437 of file constraint_solver.cc.

◆ Solver() [3/3]

operations_research::Solver::Solver ( const Solver & )

delete

◆ ~Solver()

operations_research::Solver::~Solver ( )

Definition at line 1502 of file constraint_solver.cc.

Member Function Documentation

◆ Accept()

void operations_research::Solver::Accept ( ModelVisitor * visitor ) const

Accepts the given model visitor.

Definition at line 1726 of file constraint_solver.cc.

◆ accepted_neighbors()

int64_t operations_research::Solver::accepted_neighbors ( ) const

inline

The number of accepted neighbors.

Definition at line 1100 of file constraint_solver.h.

◆ AcceptSolution()

bool operations_research::Solver::AcceptSolution ( Search * search ) const

Definition at line 3255 of file constraint_solver.cc.

◆ ActiveSearch()

Search * operations_research::Solver::ActiveSearch ( ) const

Returns the active search, nullptr outside search.

Definition at line 1153 of file constraint_solver.cc.

◆ AddBacktrackAction()

void operations_research::Solver::AddBacktrackAction	(	Action	a,
		bool	fast )

When SaveValue() is not the best way to go, one can create a reversible action that will be called upon backtrack. The "fast" parameter indicates whether we need restore all values saved through SaveValue() before calling this method.

Definition at line 1622 of file constraint_solver.cc.

◆ AddCastConstraint()

void operations_research::Solver::AddCastConstraint	(	CastConstraint *	constraint,
		IntVar *	target_var,
		IntExpr *	expr )

Adds 'constraint' to the solver and marks it as a cast constraint, that is, a constraint created calling Var() on an expression. This is used internally.

Definition at line 1714 of file constraint_solver.cc.

◆ AddConstraint()

void operations_research::Solver::AddConstraint ( Constraint * 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(...));

Definition at line 1690 of file constraint_solver.cc.

◆ AddLocalSearchMonitor()

void operations_research::Solver::AddLocalSearchMonitor ( LocalSearchMonitor * monitor )

Adds the local search monitor to the solver. This is called internally when a propagation monitor is passed to the Solve() or NewSearch() method.

Definition at line 3232 of file constraint_solver.cc.

◆ AddPropagationMonitor()

void operations_research::Solver::AddPropagationMonitor ( PropagationMonitor * monitor )

Adds the propagation monitor to the solver. This is called internally when a propagation monitor is passed to the Solve() or NewSearch() method.

Definition at line 3154 of file constraint_solver.cc.

◆ balancing_decision()

Decision * operations_research::Solver::balancing_decision ( ) const

inline

Definition at line 3150 of file constraint_solver.h.

◆ branches()

int64_t operations_research::Solver::branches ( ) const

inline

The number of branches explored since the creation of the solver.

Definition at line 1074 of file constraint_solver.h.

◆ Cache()

ModelCache * operations_research::Solver::Cache ( ) const

Returns the cache of the model.

Definition at line 850 of file model_cache.cc.

◆ CastExpression()

IntExpr * operations_research::Solver::CastExpression ( const IntVar * var ) const

!defined(SWIG)

Internal. If the variables is the result of expr->Var(), this method returns expr, nullptr otherwise.

Definition at line 2427 of file constraint_solver.cc.

◆ CheckAssignment()

bool operations_research::Solver::CheckAssignment ( Assignment * solution )

Checks whether the given assignment satisfies all relevant constraints.

Definition at line 2293 of file constraint_solver.cc.

◆ CheckConstraint()

bool operations_research::Solver::CheckConstraint ( Constraint * 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.

Definition at line 2372 of file constraint_solver.cc.

◆ CheckFail()

void operations_research::Solver::CheckFail ( )

inline

Definition at line 3267 of file constraint_solver.h.

◆ clear_fail_intercept()

void operations_research::Solver::clear_fail_intercept ( )

inline

Definition at line 3158 of file constraint_solver.h.

◆ ClearLocalSearchState()

void operations_research::Solver::ClearLocalSearchState ( )

inline

Clears the local search state.

Definition at line 3215 of file constraint_solver.h.

◆ ClearNeighbors()

void operations_research::Solver::ClearNeighbors ( )

inline

Manipulate neighbors count; to be used for testing purposes only.

Todo: (user): Find a workaround to avoid exposing this.

Definition at line 1093 of file constraint_solver.h.

◆ Compose() [1/4]

DecisionBuilder * operations_research::Solver::Compose ( const std::vector< DecisionBuilder * > & dbs )

Definition at line 665 of file search.cc.

◆ Compose() [2/4]

DecisionBuilder * operations_research::Solver::Compose	(	DecisionBuilder *	db1,
		DecisionBuilder *	db2 )

Creates a decision builder which sequentially composes decision builders. At each leaf of a decision builder, the next decision builder is therefore called. For instance, Compose(db1, db2) will result in the following tree: d1 tree | / | \ | db1 leaves | / | \ | db2 tree db2 tree db2 tree |

Definition at line 635 of file search.cc.

◆ Compose() [3/4]

DecisionBuilder * operations_research::Solver::Compose	(	DecisionBuilder *	db1,
		DecisionBuilder *	db2,
		DecisionBuilder *	db3 )

Definition at line 643 of file search.cc.

◆ Compose() [4/4]

DecisionBuilder * operations_research::Solver::Compose	(	DecisionBuilder *	db1,
		DecisionBuilder *	db2,
		DecisionBuilder *	db3,
		DecisionBuilder *	db4 )

Definition at line 653 of file search.cc.

◆ ConcatenateOperators() [1/3]

LocalSearchOperator * operations_research::Solver::ConcatenateOperators ( const std::vector< LocalSearchOperator * > & ops )

Example:

Creates a local search operator which concatenates a vector of operators. Each operator from the vector is called sequentially. By default, when a neighbor is found the neighborhood exploration restarts from the last active operator (the one which produced the neighbor). This can be overridden by setting restart to true to force the exploration to start from the first operator in the vector. The default behavior can also be overridden using an evaluation callback to set the order in which the operators are explored (the callback is called in LocalSearchOperator::Start()). The first argument of the callback is the index of the operator which produced the last move, the second argument is the index of the operator to be evaluated. Ownership of the callback is taken by ConcatenateOperators. const int kPriorities = {10, 100, 10, 0}; int64_t Evaluate(int active_operator, int current_operator) { return kPriorities[current_operator]; } LocalSearchOperator* concat = solver.ConcatenateOperators(operators, NewPermanentCallback(&Evaluate)); The elements of the vector operators will be sorted by increasing priority and explored in that order (tie-breaks are handled by keeping the relative operator order in the vector). This would result in the following order: operators[3], operators[0], operators[2], operators[1].

Definition at line 2072 of file local_search.cc.

◆ ConcatenateOperators() [2/3]

LocalSearchOperator * operations_research::Solver::ConcatenateOperators	(	const std::vector< LocalSearchOperator * > &	ops,
		bool	restart )

Definition at line 2077 of file local_search.cc.

◆ ConcatenateOperators() [3/3]

LocalSearchOperator * operations_research::Solver::ConcatenateOperators	(	const std::vector< LocalSearchOperator * > &	ops,
		std::function< int64_t(int, int)>	evaluator )

Definition at line 2089 of file local_search.cc.

◆ const_parameters()

const ConstraintSolverParameters & operations_research::Solver::const_parameters ( ) const

inline

Definition at line 844 of file constraint_solver.h.

◆ constraints()

int operations_research::Solver::constraints ( ) const

inline

Counts the number of constraints that have been added to the solver before the search.

Definition at line 3145 of file constraint_solver.h.

◆ context()

const std::string & operations_research::Solver::context ( ) const

inline

Gets the current context of the search.

Definition at line 1113 of file constraint_solver.h.

◆ CurrentlyInSolve()

bool operations_research::Solver::CurrentlyInSolve ( ) const

Returns true whether the current search has been created using a Solve() call instead of a NewSearch one. It returns false if the solver is not in search at all.

Definition at line 1779 of file constraint_solver.cc.

◆ DebugString()

std::string operations_research::Solver::DebugString ( ) const

!defined(SWIG)

misc debug string.

Definition at line 1518 of file constraint_solver.cc.

◆ DefaultSolverParameters()

ConstraintSolverParameters operations_research::Solver::DefaultSolverParameters ( )

static

Create a ConstraintSolverParameters proto with all the default values.

Definition at line 127 of file constraint_solver.cc.

◆ demon_profiler()

DemonProfiler * operations_research::Solver::demon_profiler ( ) const

inline

Access to demon profiler.

Definition at line 3160 of file constraint_solver.h.

◆ demon_runs()

int64_t operations_research::Solver::demon_runs ( DemonPriority p ) const

inline

The number of demons executed during search for a given priority.

Definition at line 1083 of file constraint_solver.h.

◆ EndSearch()

void operations_research::Solver::EndSearch ( )

Definition at line 2262 of file constraint_solver.cc.

◆ ExportProfilingOverview()

void operations_research::Solver::ExportProfilingOverview ( const std::string & filename )

Exports the profiling information in a human readable overview. The parameter profile_level used to create the solver must be set to true.

Definition at line 435 of file demon_profiler.cc.

◆ Fail()

void operations_research::Solver::Fail ( )

Abandon the current branch in the search tree. A backtrack will follow.

Definition at line 2406 of file constraint_solver.cc.

◆ fail_stamp()

uint64_t operations_research::Solver::fail_stamp ( ) const

The fail_stamp() is incremented after each backtrack.

Definition at line 1678 of file constraint_solver.cc.

◆ failures()

int64_t operations_research::Solver::failures ( ) const

inline

The number of failures encountered since the creation of the solver.

Definition at line 1086 of file constraint_solver.h.

◆ filtered_neighbors()

int64_t operations_research::Solver::filtered_neighbors ( ) const

inline

The number of filtered neighbors (neighbors accepted by filters).

Definition at line 1097 of file constraint_solver.h.

◆ FinishCurrentSearch()

void operations_research::Solver::FinishCurrentSearch ( )

Tells the solver to kill or restart the current search.

Definition at line 2417 of file constraint_solver.cc.

◆ GetConstraintSolverStatistics()

ConstraintSolverStatistics operations_research::Solver::GetConstraintSolverStatistics ( ) const

Returns detailed cp search statistics.

Definition at line 1579 of file constraint_solver.cc.

◆ GetGuidedLocalSearchPenalty()

int64_t operations_research::Solver::GetGuidedLocalSearchPenalty	(	int64_t	i,
		int64_t	j,
		int64_t	k ) const

inline

Definition at line 1130 of file constraint_solver.h.

◆ GetLocalSearchMonitor()

LocalSearchMonitor * operations_research::Solver::GetLocalSearchMonitor ( ) const

Returns the local search monitor.

Definition at line 3238 of file constraint_solver.cc.

◆ GetLocalSearchStatistics()

LocalSearchStatistics operations_research::Solver::GetLocalSearchStatistics ( ) const

Returns detailed local search statistics.

Definition at line 3766 of file local_search.cc.

◆ GetOrCreateLocalSearchState()

Assignment * operations_research::Solver::GetOrCreateLocalSearchState ( )

Returns (or creates) an assignment representing the state of local search.

Definition at line 3259 of file constraint_solver.cc.

◆ GetPropagationMonitor()

PropagationMonitor * operations_research::Solver::GetPropagationMonitor ( ) const

Returns the propagation monitor.

Definition at line 3159 of file constraint_solver.cc.

◆ HasName()

bool operations_research::Solver::HasName ( const PropagationBaseObject * object ) const

Returns whether the object has been named or not.

Definition at line 2475 of file constraint_solver.cc.

◆ IncrementNeighbors()

void operations_research::Solver::IncrementNeighbors ( )

inline

Definition at line 1094 of file constraint_solver.h.

◆ InstrumentsDemons()

bool operations_research::Solver::InstrumentsDemons ( ) const

Returns whether we are instrumenting demons.

Definition at line 178 of file constraint_solver.cc.

◆ InstrumentsVariables()

bool operations_research::Solver::InstrumentsVariables ( ) const

Returns whether we are tracing variables.

Definition at line 192 of file constraint_solver.cc.

◆ IsBooleanVar()

bool operations_research::Solver::IsBooleanVar	(	IntExpr *	expr,
		IntVar **	inner_var,
		bool *	is_negated ) const

Returns true if expr represents either boolean_var or 1 - boolean_var. In that case, it fills inner_var and is_negated to be true if the expression is 1 - boolean_var – equivalent to not(boolean_var).

Definition at line 7499 of file expressions.cc.

◆ IsLocalSearchProfilingEnabled()

bool operations_research::Solver::IsLocalSearchProfilingEnabled ( ) const

Returns whether we are profiling local search.

Definition at line 187 of file constraint_solver.cc.

◆ IsProduct()

bool operations_research::Solver::IsProduct	(	IntExpr *	expr,
		IntExpr **	inner_expr,
		int64_t *	coefficient )

Returns true if expr represents a product of a expr and a constant. In that case, it fills inner_expr and coefficient with these, and returns true. In the other case, it fills inner_expr with expr, coefficient with 1, and returns false.

Definition at line 7517 of file expressions.cc.

◆ IsProfilingEnabled()

bool operations_research::Solver::IsProfilingEnabled ( ) const

Returns whether we are profiling the solver.

Definition at line 182 of file constraint_solver.cc.

◆ LocalSearchProfile()

std::string operations_research::Solver::LocalSearchProfile ( ) const

Returns local search profiling information in a human readable format.

Definition at line 3759 of file local_search.cc.

◆ MakeAbs()

IntExpr * operations_research::Solver::MakeAbs ( IntExpr * expr )

expr

Definition at line 7043 of file expressions.cc.

◆ MakeAbsEquality()

Constraint * operations_research::Solver::MakeAbsEquality	(	IntVar *	var,
		IntVar *	abs_var )

Creates the constraint abs(var) == abs_var.

Definition at line 7036 of file expressions.cc.

◆ MakeAcceptFilter()

LocalSearchFilter * operations_research::Solver::MakeAcceptFilter ( )

Local Search Filters.

Definition at line 2509 of file local_search.cc.

◆ MakeActionDemon()

Demon * operations_research::Solver::MakeActionDemon ( Solver::Action action )

Creates a demon from a callback.

Definition at line 522 of file constraints.cc.

◆ MakeAllDifferent() [1/2]

Constraint * operations_research::Solver::MakeAllDifferent ( const std::vector< IntVar * > & vars )

All variables are pairwise different. This corresponds to the stronger version of the propagation algorithm.

Definition at line 692 of file alldiff_cst.cc.

◆ MakeAllDifferent() [2/2]

Constraint * operations_research::Solver::MakeAllDifferent	(	const std::vector< IntVar * > &	vars,
		bool	stronger_propagation )

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.

Definition at line 696 of file alldiff_cst.cc.

◆ MakeAllDifferentExcept()

Constraint * operations_research::Solver::MakeAllDifferentExcept	(	const std::vector< IntVar * > &	vars,
		int64_t	escape_value )

All variables are pairwise different, unless they are assigned to the escape value.

Definition at line 722 of file alldiff_cst.cc.

◆ MakeAllowedAssignments()

Constraint * operations_research::Solver::MakeAllowedAssignments	(	const std::vector< IntVar * > &	vars,
		const IntTupleSet &	tuples )

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.

Definition at line 1258 of file table.cc.

◆ MakeAllSolutionCollector() [1/2]

SolutionCollector * operations_research::Solver::MakeAllSolutionCollector ( )

Collect all solutions of the search. The variables will need to be added later.

Definition at line 2966 of file search.cc.

◆ MakeAllSolutionCollector() [2/2]

SolutionCollector * operations_research::Solver::MakeAllSolutionCollector ( const Assignment * assignment )

Collect all solutions of the search.

Definition at line 2961 of file search.cc.

◆ MakeApplyBranchSelector()

DecisionBuilder * operations_research::Solver::MakeApplyBranchSelector ( BranchSelector bs )

Creates a decision builder that will set the branch selector.

Definition at line 1193 of file constraint_solver.cc.

◆ MakeAssignment() [1/2]

Assignment * operations_research::Solver::MakeAssignment ( )

This method creates an empty assignment.

Definition at line 969 of file assignment.cc.

◆ MakeAssignment() [2/2]

Assignment * operations_research::Solver::MakeAssignment ( const Assignment * a )

This method creates an assignment which is a copy of 'a'.

Definition at line 971 of file assignment.cc.

◆ MakeAssignVariablesValues()

Decision * operations_research::Solver::MakeAssignVariablesValues	(	const std::vector< IntVar * > &	vars,
		const std::vector< int64_t > &	values )

Definition at line 1872 of file search.cc.

◆ MakeAssignVariablesValuesOrDoNothing()

Decision * operations_research::Solver::MakeAssignVariablesValuesOrDoNothing	(	const std::vector< IntVar * > &	vars,
		const std::vector< int64_t > &	values )

Definition at line 1880 of file search.cc.

◆ MakeAssignVariablesValuesOrFail()

Decision * operations_research::Solver::MakeAssignVariablesValuesOrFail	(	const std::vector< IntVar * > &	vars,
		const std::vector< int64_t > &	values )

Definition at line 1887 of file search.cc.

◆ MakeAssignVariableValue()

Decision * operations_research::Solver::MakeAssignVariableValue	(	IntVar *	var,
		int64_t	val )

Decisions.

Definition at line 1642 of file search.cc.

◆ MakeAssignVariableValueOrDoNothing()

Decision * operations_research::Solver::MakeAssignVariableValueOrDoNothing	(	IntVar *	var,
		int64_t	value )

Definition at line 1709 of file search.cc.

◆ MakeAssignVariableValueOrFail()

Decision * operations_research::Solver::MakeAssignVariableValueOrFail	(	IntVar *	var,
		int64_t	value )

Definition at line 1680 of file search.cc.

◆ MakeAtMost()

Constraint * operations_research::Solver::MakeAtMost	(	std::vector< IntVar * >	vars,
		int64_t	value,
		int64_t	max_count )

|{i | vars[i] == value}| <= max_count

Definition at line 956 of file count_cst.cc.

◆ MakeAtSolutionCallback()

SearchMonitor * operations_research::Solver::MakeAtSolutionCallback ( std::function< void()> callback )

Definition at line 491 of file search.cc.

◆ MakeBestLexicographicValueSolutionCollector() [1/2]

SolutionCollector * operations_research::Solver::MakeBestLexicographicValueSolutionCollector	(	const Assignment *	assignment,
		std::vector< bool >	maximize )

Same as above, but supporting lexicographic objectives; 'maximize' specifies the optimization direction for each objective in 'assignment'.

Definition at line 2761 of file search.cc.

◆ MakeBestLexicographicValueSolutionCollector() [2/2]

SolutionCollector * operations_research::Solver::MakeBestLexicographicValueSolutionCollector ( std::vector< bool > maximize )

Same as above, but supporting lexicographic objectives; 'maximize' specifies the optimization direction for each objective.

Definition at line 2771 of file search.cc.

◆ MakeBestValueSolutionCollector() [1/2]

SolutionCollector * operations_research::Solver::MakeBestValueSolutionCollector ( bool maximize )

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.

Definition at line 2767 of file search.cc.

◆ MakeBestValueSolutionCollector() [2/2]

SolutionCollector * operations_research::Solver::MakeBestValueSolutionCollector	(	const Assignment *	assignment,
		bool	maximize )

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

Definition at line 2756 of file search.cc.

◆ MakeBetweenCt()

Constraint * operations_research::Solver::MakeBetweenCt	(	IntExpr *	expr,
		int64_t	l,
		int64_t	u )

(l <= expr <= u)

Definition at line 928 of file expr_cst.cc.

◆ MakeBoolVar() [1/2]

IntVar * operations_research::Solver::MakeBoolVar ( )

MakeBoolVar will create a variable with a {0, 1} domain.

Definition at line 6438 of file expressions.cc.

◆ MakeBoolVar() [2/2]

IntVar * operations_research::Solver::MakeBoolVar ( const std::string & name )

MakeBoolVar will create a variable with a {0, 1} domain.

Definition at line 6434 of file expressions.cc.

◆ MakeBoolVarArray() [1/3]

IntVar ** operations_research::Solver::MakeBoolVarArray	(	int	var_count,
		const std::string &	name )

Same but allocates an array and returns it.

Definition at line 6575 of file expressions.cc.

◆ MakeBoolVarArray() [2/3]

void operations_research::Solver::MakeBoolVarArray	(	int	var_count,
		const std::string &	name,
		std::vector< IntVar * > *	vars )

This method will append the vector vars with 'var_count' boolean variables having name "name<i>" where is the index of the variable.

Definition at line 6562 of file expressions.cc.

◆ MakeBoolVarArray() [3/3]

void operations_research::Solver::MakeBoolVarArray	(	int	var_count,
		std::vector< IntVar * > *	vars )

This method will append the vector vars with 'var_count' boolean variables having no names.

Definition at line 6569 of file expressions.cc.

◆ MakeBranchesLimit()

RegularLimit * operations_research::Solver::MakeBranchesLimit ( int64_t branches )

Creates a search limit that constrains the number of branches explored in the search tree.

Definition at line 4744 of file search.cc.

◆ MakeCircuit()

Constraint * operations_research::Solver::MakeCircuit ( const std::vector< IntVar * > & nexts )

Force the "nexts" variable to create a complete Hamiltonian path.

Definition at line 641 of file graph_constraints.cc.

◆ MakeClosureDemon()

Demon * operations_research::Solver::MakeClosureDemon ( Solver::Closure closure )

Creates a demon from a closure.

!defined(SWIG)

Definition at line 526 of file constraints.cc.

◆ MakeConditionalExpression()

IntExpr * operations_research::Solver::MakeConditionalExpression	(	IntVar *	condition,
		IntExpr *	expr,
		int64_t	unperformed_value )

Conditional Expr condition ? expr : unperformed_value.

Definition at line 7275 of file expressions.cc.

◆ MakeConstantRestart()

SearchMonitor * operations_research::Solver::MakeConstantRestart ( int frequency )

This search monitor will restart the search periodically after 'frequency' failures.

Definition at line 5390 of file search.cc.

◆ MakeConstraintAdder()

DecisionBuilder * operations_research::Solver::MakeConstraintAdder ( Constraint * ct )

Returns a decision builder that will add the given constraint to the model.

Definition at line 2368 of file constraint_solver.cc.

◆ MakeConstraintInitialPropagateCallback()

Demon * operations_research::Solver::MakeConstraintInitialPropagateCallback ( Constraint * ct )

This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct'.

Definition at line 37 of file constraints.cc.

◆ MakeConvexPiecewiseExpr()

IntExpr * operations_research::Solver::MakeConvexPiecewiseExpr	(	IntExpr *	expr,
		int64_t	early_cost,
		int64_t	early_date,
		int64_t	late_date,
		int64_t	late_cost )

Convex piecewise function.

Definition at line 7188 of file expressions.cc.

◆ MakeCount() [1/2]

Constraint * operations_research::Solver::MakeCount	(	const std::vector< IntVar * > &	vars,
		int64_t	value,
		int64_t	max_count )

|{i | vars[i] == value}| == max_count

Definition at line 32 of file count_cst.cc.

◆ MakeCount() [2/2]

Constraint * operations_research::Solver::MakeCount	(	const std::vector< IntVar * > &	vars,
		int64_t	value,
		IntVar *	max_count )

|{i | vars[i] == value}| == max_count

Definition at line 47 of file count_cst.cc.

◆ MakeCover()

Constraint * operations_research::Solver::MakeCover	(	const std::vector< IntervalVar * > &	vars,
		IntervalVar *	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.

Definition at line 588 of file sched_constraints.cc.