C++ Reference
C++ Reference: Routing
constraint_solver.h
Go to the documentation of this file.
430 };
568 };
594 };
608 };
656 };
688 };
717 };
737 };
1682 Constraint* MakeMapDomain(IntVar* const var,
bool AreAllElementsBound() const
Definition: constraint_solver.h:4970
bool operator==(const AssignmentContainer< V, E > &container) const
Returns true if this and 'container' both represent the same V* -> E map.
Definition: constraint_solver.h:4980
const E * ElementPtrOrNull(const V *const var) const
Definition: constraint_solver.h:4947
E * MutableElementOrNull(const V *const var)
Definition: constraint_solver.h:4934
bool Contains(const V *const var) const
Definition: constraint_solver.h:4924
const E & Element(const V *const var) const
Definition: constraint_solver.h:4941
E * AddAtPosition(V *var, int position)
Advanced usage: Adds element at a given position; position has to have been allocated with Assignment...
Definition: constraint_solver.h:4879
void Copy(const AssignmentContainer< V, E > &container)
Copies all the elements of 'container' to this container, clearing its previous content.
Definition: constraint_solver.h:4917
bool operator!=(const AssignmentContainer< V, E > &container) const
Definition: constraint_solver.h:4999
E * MutableElement(const V *const var)
Definition: constraint_solver.h:4928
AssignmentContainer()
Definition: constraint_solver.h:4861
void CopyIntersection(const AssignmentContainer< V, E > &container)
Copies the elements of 'container' which are already in the calling container.
Definition: constraint_solver.h:4895
const E & Element(int index) const
Definition: constraint_solver.h:4956
E * FastAdd(V *var)
Adds element without checking its presence in the container.
Definition: constraint_solver.h:4872
const std::vector< E > & elements() const
Definition: constraint_solver.h:4954
bool Empty() const
Definition: constraint_solver.h:4892
void Resize(size_t size)
Advanced usage: Resizes the container, potentially adding elements with null variables.
Definition: constraint_solver.h:4891
E * MutableElement(int index)
Definition: constraint_solver.h:4955
void Deactivate()
Definition: constraint_solver.h:4644
bool Activated() const
Definition: constraint_solver.h:4645
AssignmentElement()
Definition: constraint_solver.h:4641
An Assignment is a variable -> domains mapping, used to report solutions to the user.
Definition: constraint_solver.h:5038
bool ActivatedObjective() const
const std::vector< int > & Unperformed(const SequenceVar *const var) const
int64 DurationMin(const IntervalVar *const var) const
bool Activated(const IntervalVar *const var) const
void SetForwardSequence(const SequenceVar *const var, const std::vector< int > &forward_sequence)
SequenceVarElement * Add(SequenceVar *const var)
int64 Value(const IntVar *const var) const
void Deactivate(const IntVar *const var)
void SetStartMin(const IntervalVar *const var, int64 m)
bool Save(File *file) const
SequenceContainer * MutableSequenceVarContainer()
Definition: constraint_solver.h:5200
void Restore()
void SetBackwardSequence(const SequenceVar *const var, const std::vector< int > &backward_sequence)
IntervalVarElement * FastAdd(IntervalVar *const var)
Adds without checking if variable has been previously added.
void SetObjectiveRange(int64 l, int64 u)
const std::vector< int > & BackwardSequence(const SequenceVar *const var) const
bool AreAllElementsBound() const
Definition: constraint_solver.h:5173
int64 ObjectiveMin() const
void SetDurationValue(const IntervalVar *const var, int64 value)
void SetEndMax(const IntervalVar *const var, int64 m)
Assignment(Solver *const s)
SequenceVarElement * FastAdd(SequenceVar *const var)
Adds without checking if the variable had been previously added.
int64 EndMax(const IntervalVar *const var) const
void Deactivate(const SequenceVar *const var)
const IntervalContainer & IntervalVarContainer() const
Definition: constraint_solver.h:5191
int64 StartValue(const IntervalVar *const var) const
AssignmentContainer< SequenceVar, SequenceVarElement > SequenceContainer
Definition: constraint_solver.h:5044
void SetStartMax(const IntervalVar *const var, int64 m)
int NumSequenceVars() const
Definition: constraint_solver.h:5060
void ActivateObjective()
void Store()
bool Activated(const SequenceVar *const var) const
void ClearObjective()
Definition: constraint_solver.h:5079
bool Contains(const SequenceVar *const var) const
void SetPerformedValue(const IntervalVar *const var, int64 value)
IntVar * Objective() const
int64 PerformedMin(const IntervalVar *const var) const
void Add(const std::vector< SequenceVar * > &vars)
bool Load(const std::string &filename)
Loads an assignment from a file; does not add variables to the assignment (only the variables contain...
IntervalVarElement * Add(IntervalVar *const var)
int64 Min(const IntVar *const var) const
bool Contains(const IntVar *const var) const
void Add(const std::vector< IntVar * > &vars)
void Activate(const SequenceVar *const var)
bool Contains(const IntervalVar *const var) const
bool Activated(const IntVar *const var) const
bool Save(const std::string &filename) const
Saves the assignment to a file.
int64 EndMin(const IntervalVar *const var) const
void SetMax(const IntVar *const var, int64 m)
void Add(const std::vector< IntervalVar * > &vars)
void SetPerformedRange(const IntervalVar *const var, int64 mi, int64 ma)
void SetEndMin(const IntervalVar *const var, int64 m)
IntervalContainer * MutableIntervalVarContainer()
Definition: constraint_solver.h:5194
const std::vector< int > & ForwardSequence(const SequenceVar *const var) const
bool HasObjective() const
Definition: constraint_solver.h:5081
~Assignment() override
const SequenceContainer & SequenceVarContainer() const
Definition: constraint_solver.h:5197
void AddObjective(IntVar *const v)
int64 ObjectiveValue() const
int64 StartMin(const IntervalVar *const var) const
void Activate(const IntVar *const var)
void SetPerformedMin(const IntervalVar *const var, int64 m)
void DeactivateObjective()
void SetMin(const IntVar *const var, int64 m)
void SetPerformedMax(const IntervalVar *const var, int64 m)
int64 Max(const IntVar *const var) const
bool Load(File *file)
void SetEndValue(const IntervalVar *const var, int64 value)
void SetUnperformed(const SequenceVar *const var, const std::vector< int > &unperformed)
void Clear()
int64 DurationMax(const IntervalVar *const var) const
void SetObjectiveMax(int64 m)
void Deactivate(const IntervalVar *const var)
bool operator==(const Assignment &assignment) const
Definition: constraint_solver.h:5203
void SetStartValue(const IntervalVar *const var, int64 value)
void CopyIntersection(const Assignment *assignment)
Copies the intersection of the two assignments to the current assignment.
int NumIntervalVars() const
Definition: constraint_solver.h:5059
bool ObjectiveBound() const
void SetDurationMax(const IntervalVar *const var, int64 m)
AssignmentContainer< IntervalVar, IntervalVarElement > IntervalContainer
Definition: constraint_solver.h:5042
void SetStartRange(const IntervalVar *const var, int64 mi, int64 ma)
void Activate(const IntervalVar *const var)
void SetObjectiveMin(int64 m)
void SetValue(const IntVar *const var, int64 value)
IntContainer * MutableIntVarContainer()
Definition: constraint_solver.h:5190
void Load(const AssignmentProto &assignment_proto)
#if !defined(SWIG)
void Copy(const Assignment *assignment)
Copies 'assignment' to the current assignment, clearing its previous content.
int64 PerformedMax(const IntervalVar *const var) const
AssignmentContainer< IntVar, IntVarElement > IntContainer
Definition: constraint_solver.h:5040
void SetSequence(const SequenceVar *const var, const std::vector< int > &forward_sequence, const std::vector< int > &backward_sequence, const std::vector< int > &unperformed)
int64 DurationValue(const IntervalVar *const var) const
void SetDurationMin(const IntervalVar *const var, int64 m)
int64 ObjectiveMax() const
int NumIntVars() const
Definition: constraint_solver.h:5058
int64 StartMax(const IntervalVar *const var) const
int64 EndValue(const IntervalVar *const var) const
int64 PerformedValue(const IntervalVar *const var) const
IntVarElement * Add(IntVar *const var)
void SetEndRange(const IntervalVar *const var, int64 mi, int64 ma)
void SetDurationRange(const IntervalVar *const var, int64 mi, int64 ma)
bool Bound(const IntVar *const var) const
std::string DebugString() const override
const IntContainer & IntVarContainer() const
Definition: constraint_solver.h:5189
void Save(AssignmentProto *const assignment_proto) const
void SetObjectiveValue(int64 value)
IntVarElement * FastAdd(IntVar *const var)
Adds without checking if variable has been previously added.
Assignment(const Assignment *const copy)
void SetRange(const IntVar *const var, int64 l, int64 u)
bool operator!=(const Assignment &assignment) const
Definition: constraint_solver.h:5209
This is the base class for all expressions that are not variables.
Definition: constraint_solveri.h:109
A BaseObject is the root of all reversibly allocated objects.
Definition: constraint_solver.h:3152
virtual std::string DebugString() const
Definition: constraint_solver.h:3156
virtual ~BaseObject()
Definition: constraint_solver.h:3155
Cast constraints are special channeling constraints designed to keep a variable in sync with an expre...
Definition: constraint_solver.h:3620
~CastConstraint() override
Definition: constraint_solver.h:3626
IntVar *const target_var_
Definition: constraint_solver.h:3631
IntVar * target_var() const
Definition: constraint_solver.h:3628
CastConstraint(Solver *const solver, IntVar *const target_var)
Definition: constraint_solver.h:3622
A constraint is the main modeling object.
Definition: constraint_solver.h:3584
~Constraint() override
Definition: constraint_solver.h:3587
void PostAndPropagate()
Calls Post and then Propagate to initialize the constraints.
virtual IntVar * Var()
Creates a Boolean variable representing the status of the constraint (false = constraint is violated,...
bool IsCastConstraint() const
Is the constraint created by a cast from expression to integer variable?
virtual void InitialPropagate()=0
This method performs the initial propagation of the constraint.
Constraint(Solver *const solver)
Definition: constraint_solver.h:3586
std::string DebugString() const override
virtual void Post()=0
This method is called when the constraint is processed by the solver.
virtual void Accept(ModelVisitor *const visitor) const
Accepts the given visitor.
A DecisionBuilder is responsible for creating the search tree.
Definition: constraint_solver.h:3268
virtual Decision * Next(Solver *const s)=0
This is the main method of the decision builder class.
virtual void AppendMonitors(Solver *const solver, std::vector< SearchMonitor * > *const extras)
This method will be called at the start of the search.
DecisionBuilder()
Definition: constraint_solver.h:3270
~DecisionBuilder() override
Definition: constraint_solver.h:3271
std::string DebugString() const override
virtual void Accept(ModelVisitor *const visitor) const
A Decision represents a choice point in the search tree.
Definition: constraint_solver.h:3228
virtual void Apply(Solver *const s)=0
Apply will be called first when the decision is executed.
virtual void Accept(DecisionVisitor *const visitor) const
Accepts the given visitor.
virtual void Refute(Solver *const s)=0
Refute will be called after a backtrack.
std::string DebugString() const override
Definition: constraint_solver.h:3239
A DecisionVisitor is used to inspect a decision.
Definition: constraint_solver.h:3249
virtual void VisitScheduleOrPostpone(IntervalVar *const var, int64 est)
~DecisionVisitor() override
Definition: constraint_solver.h:3252
virtual void VisitSetVariableValue(IntVar *const var, int64 value)
virtual void VisitSplitVariableDomain(IntVar *const var, int64 value, bool start_with_lower_half)
virtual void VisitRankLastInterval(SequenceVar *const sequence, int index)
virtual void VisitRankFirstInterval(SequenceVar *const sequence, int index)
virtual void VisitUnknownDecision()
DecisionVisitor()
Definition: constraint_solver.h:3251
virtual void VisitScheduleOrExpedite(IntervalVar *const var, int64 est)
A Demon is the base element of a propagation queue.
Definition: constraint_solver.h:3301
void inhibit(Solver *const s)
This method inhibits the demon in the search tree below the current position.
void desinhibit(Solver *const s)
This method un-inhibits the demon that was previously inhibited.
virtual Solver::DemonPriority priority() const
This method returns the priority of the demon.
std::string DebugString() const override
virtual void Run(Solver *const s)=0
This is the main callback of the demon.
const std::vector< IntervalVar * > intervals_
Definition: constraint_solver.h:5368
virtual const std::vector< IntVar * > & time_slacks() const =0
virtual SequenceVar * MakeSequenceVar()=0
Creates a sequence variable from the constraint.
virtual const std::vector< IntVar * > & actives() const =0
virtual const std::vector< IntVar * > & nexts() const =0
virtual const std::vector< IntVar * > & time_cumuls() const =0
int64 TransitionTime(int before_index, int after_index)
Definition: constraint_solver.h:5355
~DisjunctiveConstraint() override
DisjunctiveConstraint(Solver *const s, const std::vector< IntervalVar * > &intervals, const std::string &name)
void SetTransitionTime(Solver::IndexEvaluator2 transition_time)
Add a transition time between intervals.
Solver::IndexEvaluator2 transition_time_
Definition: constraint_solver.h:5369
bool Check() override
This method is called to check the status of the limit.
void Init() override
This method is called when the search limit is initialized.
~ImprovementSearchLimit() override
void Copy(const SearchLimit *const limit) override
Copy a limit.
bool AtSolution() override
This method is called when a valid solution is found.
ImprovementSearchLimit(Solver *const s, IntVar *objective_var, bool maximize, double objective_scaling_factor, double objective_offset, double improvement_rate_coefficient, int improvement_rate_solutions_distance)
SearchLimit * MakeClone() const override
Allocates a clone of the limit.
Utility class to encapsulate an IntVarIterator and use it in a range-based loop.
Definition: constraint_solver.h:3941
InitAndGetValues(IntVarIterator *it)
Definition: constraint_solver.h:3943
The class IntExpr is the base of all integer expressions in constraint programming.
Definition: constraint_solver.h:3836
virtual void SetMax(int64 m)=0
void WhenRange(Solver::Closure closure)
Attach a demon that will watch the min or the max of the expression.
Definition: constraint_solver.h:3879
virtual void SetRange(int64 l, int64 u)
This method sets both the min and the max of the expression.
Definition: constraint_solver.h:3853
virtual void SetValue(int64 v)
This method sets the value of the expression.
Definition: constraint_solver.h:3859
virtual bool Bound() const
Returns true if the min and the max of the expression are equal.
Definition: constraint_solver.h:3862
virtual void SetMin(int64 m)=0
virtual bool IsVar() const
Returns true if the expression is indeed a variable.
Definition: constraint_solver.h:3865
virtual void Range(int64 *l, int64 *u)
By default calls Min() and Max(), but can be redefined when Min and Max code can be factorized.
Definition: constraint_solver.h:3848
virtual int64 Max() const =0
IntVar * VarWithName(const std::string &name)
Creates a variable from the expression and set the name of the resulting var.
virtual int64 Min() const =0
virtual void WhenRange(Demon *d)=0
Attach a demon that will watch the min or the max of the expression.
void WhenRange(Solver::Action action)
Attach a demon that will watch the min or the max of the expression.
Definition: constraint_solver.h:3885
virtual void Accept(ModelVisitor *const visitor) const
Accepts the given visitor.
void Copy(const IntVarElement &element)
bool operator!=(const IntVarElement &element) const
Definition: constraint_solver.h:4692
void Reset(IntVar *const var)
bool operator==(const IntVarElement &element) const
IntVarElement(IntVar *const var)
IntVarElement * Clone()
IntVarElement()
std::string DebugString() const
void WriteToProto(IntVarAssignment *int_var_assignment_proto) const
void SetRange(int64 l, int64 u)
Definition: constraint_solver.h:4681
void LoadFromProto(const IntVarAssignment &int_var_assignment_proto)
void SetValue(int64 v)
Definition: constraint_solver.h:4685
The class IntVar is a subset of IntExpr.
Definition: constraint_solver.h:3997
virtual void SetValues(const std::vector< int64 > &values)
This method intersects the current domain with the values in the array.
void WhenBound(Solver::Closure closure)
This method attaches a closure that will be awakened when the variable is bound.
Definition: constraint_solver.h:4028
virtual IntVarIterator * MakeHoleIterator(bool reversible) const =0
Creates a hole iterator.
virtual void RemoveValue(int64 v)=0
This method removes the value 'v' from the domain of the variable.
IntVar(Solver *const s)
virtual IntVar * IsLessOrEqual(int64 constant)=0
virtual void WhenBound(Demon *d)=0
This method attaches a demon that will be awakened when the variable is bound.
virtual bool Contains(int64 v) const =0
This method returns whether the value 'v' is in the domain of the variable.
virtual void RemoveValues(const std::vector< int64 > &values)
This method remove the values from the domain of the variable.
void WhenDomain(Solver::Closure closure)
This method attaches a closure that will watch any domain modification of the domain of the variable.
Definition: constraint_solver.h:4045
void WhenDomain(Solver::Action action)
This method attaches an action that will watch any domain modification of the domain of the variable.
Definition: constraint_solver.h:4051
void Accept(ModelVisitor *const visitor) const override
Accepts the given visitor.
virtual void WhenDomain(Demon *d)=0
This method attaches a demon that will watch any domain modification of the domain of the variable.
IntVar(Solver *const s, const std::string &name)
virtual int64 Value() const =0
This method returns the value of the variable.
virtual void RemoveInterval(int64 l, int64 u)=0
This method removes the interval 'l' .
virtual uint64 Size() const =0
This method returns the number of values in the domain of the variable.
void WhenBound(Solver::Action action)
This method attaches an action that will be awakened when the variable is bound.
Definition: constraint_solver.h:4035
virtual int VarType() const
virtual IntVar * IsGreaterOrEqual(int64 constant)=0
bool IsVar() const override
Returns true if the expression is indeed a variable.
Definition: constraint_solver.h:4003
virtual IntVar * IsDifferent(int64 constant)=0
virtual IntVarIterator * MakeDomainIterator(bool reversible) const =0
Creates a domain iterator.
The class Iterator has two direct subclasses.
Definition: constraint_solver.h:3914
virtual void Init()=0
This method must be called before each loop.
virtual void Next()=0
This method moves the iterator to the next value.
virtual int64 Value() const =0
This method returns the current value of the iterator.
~IntVarIterator() override
Definition: constraint_solver.h:3916
virtual bool Ok() const =0
This method indicates if we can call Value() or not.
int64 StartMin() const
Definition: constraint_solver.h:4716
IntervalVarElement * Clone()
void SetPerformedValue(int64 v)
Definition: constraint_solver.h:4776
void LoadFromProto(const IntervalVarAssignment &interval_var_assignment_proto)
void Restore()
void SetPerformedRange(int64 mi, int64 ma)
Definition: constraint_solver.h:4772
void SetStartValue(int64 v)
Definition: constraint_solver.h:4746
bool operator!=(const IntervalVarElement &element) const
Definition: constraint_solver.h:4786
void Reset(IntervalVar *const var)
int64 EndMin() const
Definition: constraint_solver.h:4728
void Store()
void SetPerformedMin(int64 m)
Definition: constraint_solver.h:4770
int64 DurationMin() const
Definition: constraint_solver.h:4722
void SetEndMin(int64 m)
Definition: constraint_solver.h:4760
bool Bound() const
Definition: constraint_solver.h:4780
void SetDurationValue(int64 v)
Definition: constraint_solver.h:4756
void SetEndMax(int64 m)
Definition: constraint_solver.h:4761
void SetStartMax(int64 m)
Definition: constraint_solver.h:4741
void SetEndValue(int64 v)
Definition: constraint_solver.h:4766
void SetEndRange(int64 mi, int64 ma)
Definition: constraint_solver.h:4762
int64 DurationValue() const
Definition: constraint_solver.h:4724
std::string DebugString() const
int64 StartMax() const
Definition: constraint_solver.h:4717
int64 DurationMax() const
Definition: constraint_solver.h:4723
void SetStartRange(int64 mi, int64 ma)
Definition: constraint_solver.h:4742
int64 PerformedValue() const
Definition: constraint_solver.h:4736
IntervalVarElement(IntervalVar *const var)
int64 StartValue() const
Definition: constraint_solver.h:4718
void SetStartMin(int64 m)
Definition: constraint_solver.h:4740
void SetDurationRange(int64 mi, int64 ma)
Definition: constraint_solver.h:4752
int64 EndValue() const
Definition: constraint_solver.h:4730
IntervalVarElement()
bool operator==(const IntervalVarElement &element) const
void Copy(const IntervalVarElement &element)
void SetDurationMin(int64 m)
Definition: constraint_solver.h:4750
void WriteToProto(IntervalVarAssignment *interval_var_assignment_proto) const
void SetPerformedMax(int64 m)
Definition: constraint_solver.h:4771
void SetDurationMax(int64 m)
Definition: constraint_solver.h:4751
int64 PerformedMin() const
Definition: constraint_solver.h:4734
int64 PerformedMax() const
Definition: constraint_solver.h:4735
IntervalVar * Var() const
Definition: constraint_solver.h:4709
int64 EndMax() const
Definition: constraint_solver.h:4729
Interval variables are often used in scheduling.
Definition: constraint_solver.h:4394
virtual int64 OldStartMin() const =0
virtual int64 StartMax() const =0
virtual IntExpr * SafeStartExpr(int64 unperformed_value)=0
These methods create expressions encapsulating the start, end and duration of the interval var.
void WhenDurationRange(Solver::Closure closure)
Definition: constraint_solver.h:4443
virtual IntExpr * DurationExpr()=0
virtual IntExpr * PerformedExpr()=0
void WhenAnything(Solver::Closure closure)
Attaches a closure awakened when anything about this interval changes.
Definition: constraint_solver.h:4511
virtual int64 OldEndMin() const =0
static const int64 kMaxValidValue
The largest acceptable value to be returned by EndMax()
Definition: constraint_solver.h:4399
void WhenStartBound(Solver::Closure closure)
Definition: constraint_solver.h:4425
virtual void WhenStartBound(Demon *const d)=0
void WhenEndRange(Solver::Closure closure)
Definition: constraint_solver.h:4470
void WhenAnything(Demon *const d)
Attaches a demon awakened when anything about this interval changes.
virtual int64 DurationMax() const =0
virtual void SetPerformed(bool val)=0
virtual int64 EndMax() const =0
void WhenEndBound(Solver::Action action)
Definition: constraint_solver.h:4483
virtual void SetEndMax(int64 m)=0
virtual void WhenEndRange(Demon *const d)=0
virtual void SetStartMin(int64 m)=0
virtual void SetDurationMin(int64 m)=0
virtual void WhenDurationBound(Demon *const d)=0
virtual int64 OldDurationMin() const =0
virtual void SetEndMin(int64 m)=0
virtual bool WasPerformedBound() const =0
void WhenStartRange(Solver::Action action)
Definition: constraint_solver.h:4420
virtual void SetEndRange(int64 mi, int64 ma)=0
virtual void WhenDurationRange(Demon *const d)=0
static const int64 kMinValidValue
The smallest acceptable value to be returned by StartMin()
Definition: constraint_solver.h:4397
virtual IntExpr * SafeDurationExpr(int64 unperformed_value)=0
virtual void WhenEndBound(Demon *const d)=0
virtual void Accept(ModelVisitor *const visitor) const =0
Accepts the given visitor.
void WhenDurationBound(Solver::Action action)
Definition: constraint_solver.h:4456
virtual bool MustBePerformed() const =0
These methods query, set, and watch the performed status of the interval var.
IntervalVar(Solver *const solver, const std::string &name)
Definition: constraint_solver.h:4400
virtual void WhenPerformedBound(Demon *const d)=0
~IntervalVar() override
Definition: constraint_solver.h:4404
virtual void SetStartMax(int64 m)=0
virtual IntExpr * SafeEndExpr(int64 unperformed_value)=0
virtual int64 OldEndMax() const =0
virtual int64 StartMin() const =0
These methods query, set, and watch the start position of the interval var.
void WhenStartBound(Solver::Action action)
Definition: constraint_solver.h:4429
virtual void SetStartRange(int64 mi, int64 ma)=0
void WhenAnything(Solver::Action action)
Attaches an action awakened when anything about this interval changes.
Definition: constraint_solver.h:4516
virtual int64 OldDurationMax() const =0
void WhenEndRange(Solver::Action action)
Definition: constraint_solver.h:4474
void WhenStartRange(Solver::Closure closure)
Definition: constraint_solver.h:4416
virtual IntExpr * EndExpr()=0
virtual int64 EndMin() const =0
These methods query, set, and watch the end position of the interval var.
virtual void WhenStartRange(Demon *const d)=0
virtual IntExpr * StartExpr()=0
These methods create expressions encapsulating the start, end and duration of the interval var.
bool IsPerformedBound() const
Definition: constraint_solver.h:4493
virtual int64 DurationMin() const =0
These methods query, set, and watch the duration of the interval var.
virtual void SetDurationRange(int64 mi, int64 ma)=0
virtual void SetDurationMax(int64 m)=0
void WhenPerformedBound(Solver::Action action)
Definition: constraint_solver.h:4503
void WhenPerformedBound(Solver::Closure closure)
Definition: constraint_solver.h:4499
virtual int64 OldStartMax() const =0
void WhenEndBound(Solver::Closure closure)
Definition: constraint_solver.h:4479
virtual bool MayBePerformed() const =0
void WhenDurationRange(Solver::Action action)
Definition: constraint_solver.h:4447
bool CannotBePerformed() const
Definition: constraint_solver.h:4492
void WhenDurationBound(Solver::Closure closure)
Definition: constraint_solver.h:4452
Local Search Filters are used for fast neighbor pruning.
Definition: constraint_solveri.h:1719
Filter manager: when a move is made, filters are executed to decide whether the solution is feasible ...
Definition: constraint_solveri.h:1763
The base class for all local search operators.
Definition: constraint_solveri.h:798
Implements a complete cache for model elements: expressions and constraints.
Definition: constraint_solveri.h:2073
static const char kIsMember[]
Definition: constraint_solver.h:3377
static const char kDistribute[]
Definition: constraint_solver.h:3353
virtual void EndVisitIntegerExpression(const std::string &type_name, const IntExpr *const expr)
static const char kIndexOf[]
Definition: constraint_solver.h:3342
static const char kObjectiveExtension[]
Definition: constraint_solver.h:3425
virtual void VisitIntegerVariable(const IntVar *const variable, IntExpr *const delegate)
static const char kOpposite[]
Definition: constraint_solver.h:3394
static const char kElement[]
Definition: constraint_solver.h:3356
static const char kIntervalVariable[]
Definition: constraint_solver.h:3368
static const char kStepArgument[]
Definition: constraint_solver.h:3486
static const char kPathCumul[]
Definition: constraint_solver.h:3396
virtual void VisitIntegerVariableEvaluatorArgument(const std::string &arg_name, const Solver::Int64ToIntVar &arguments)
Helpers.
~ModelVisitor() override
static const char kRelaxedMinOperation[]
Definition: constraint_solver.h:3500
static const char kTrace[]
Definition: constraint_solver.h:3414
static const char kUsageEqualVariableExtension[]
Definition: constraint_solver.h:3427
static const char kTransition[]
Definition: constraint_solver.h:3415
static const char kAllowedAssignments[]
Definition: constraint_solver.h:3340
static const char kDemandsArgument[]
Definition: constraint_solver.h:3444
static const char kSizeYArgument[]
Definition: constraint_solver.h:3480
static const char kDeviation[]
Definition: constraint_solver.h:3350
static const char kDivide[]
Definition: constraint_solver.h:3354
static const char kCircuit[]
Definition: constraint_solver.h:3345
static const char kMaxEqual[]
Definition: constraint_solver.h:3384
static const char kCapacityArgument[]
Definition: constraint_solver.h:3438
static const char kRangeArgument[]
Definition: constraint_solver.h:3473
static const char kInt64ToBoolExtension[]
Definition: constraint_solver.h:3423
static const char kCumulativeArgument[]
Definition: constraint_solver.h:3442
static const char kLinkExprVar[]
Definition: constraint_solver.h:3381
static const char kCountUsedBinsExtension[]
Definition: constraint_solver.h:3422
static const char kIsDifferent[]
Definition: constraint_solver.h:3371
virtual void BeginVisitExtension(const std::string &type)
static const char kVarsArgument[]
Definition: constraint_solver.h:3494
static const char kDifferenceOperation[]
Definition: constraint_solver.h:3502
virtual void VisitIntegerVariableArrayArgument(const std::string &arg_name, const std::vector< IntVar * > &arguments)
static const char kCardsArgument[]
Definition: constraint_solver.h:3439
virtual void VisitIntegerArgument(const std::string &arg_name, int64 value)
Visit integer arguments.
static const char kCountEqual[]
Definition: constraint_solver.h:3347
static const char kMinEqual[]
Definition: constraint_solver.h:3387
static const char kEndsArgument[]
Definition: constraint_solver.h:3451
static const char kTimeLimitArgument[]
Definition: constraint_solver.h:3488
static const char kSizeArgument[]
Definition: constraint_solver.h:3478
static const char kVariableGroupExtension[]
Definition: constraint_solver.h:3430
static const char kIntervalUnaryRelation[]
Definition: constraint_solver.h:3367
static const char kPartialArgument[]
Definition: constraint_solver.h:3470
static const char kMapDomain[]
Definition: constraint_solver.h:3382
static const char kTargetArgument[]
Definition: constraint_solver.h:3487
static const char kIntervalBinaryRelation[]
Definition: constraint_solver.h:3365
static const char kSumOperation[]
Definition: constraint_solver.h:3501
static const char kInt64ToInt64Extension[]
Definition: constraint_solver.h:3424
static const char kGreater[]
Definition: constraint_solver.h:3362
static const char kNextsArgument[]
Definition: constraint_solver.h:3468
static const char kVarValueWatcher[]
Definition: constraint_solver.h:3418
static const char kEquality[]
Definition: constraint_solver.h:3359
static const char kEvaluatorArgument[]
Definition: constraint_solver.h:3495
static const char kEarlyDateArgument[]
Definition: constraint_solver.h:3448
static const char kUsageLessConstantExtension[]
Definition: constraint_solver.h:3429
virtual void VisitSequenceVariable(const SequenceVar *const variable)
static const char kRightArgument[]
Definition: constraint_solver.h:3475
static const char kBetween[]
Definition: constraint_solver.h:3343
static const char kIsGreater[]
Definition: constraint_solver.h:3373
static const char kSortingConstraint[]
Definition: constraint_solver.h:3407
static const char kLessOrEqual[]
Definition: constraint_solver.h:3379
static const char kDurationExpr[]
Definition: constraint_solver.h:3355
static const char kAssumePathsArgument[]
Definition: constraint_solver.h:3436
static const char kIsEqual[]
Definition: constraint_solver.h:3372
static const char kModulo[]
Definition: constraint_solver.h:3388
static const char kScalProdLessOrEqual[]
Definition: constraint_solver.h:3404
static const char kAllDifferent[]
Definition: constraint_solver.h:3339
static const char kSearchLimitExtension[]
Definition: constraint_solver.h:3426
static const char kVariableArgument[]
Definition: constraint_solver.h:3493
static const char kLateCostArgument[]
Definition: constraint_solver.h:3461
static const char kFixedChargeArgument[]
Definition: constraint_solver.h:3455
static const char kRelationArgument[]
Definition: constraint_solver.h:3474
static const char kIndexArgument[]
Definition: constraint_solver.h:3457
static const char kDelayedPathCumul[]
Definition: constraint_solver.h:3397
static const char kMember[]
Definition: constraint_solver.h:3385
virtual void BeginVisitModel(const std::string &type_name)
--— Virtual methods for visitors --—
static const char kScalProdEqual[]
Definition: constraint_solver.h:3402
static const char kValuesArgument[]
Definition: constraint_solver.h:3492
static const char kConvexPiecewise[]
Definition: constraint_solver.h:3346
static const char kModuloArgument[]
Definition: constraint_solver.h:3467
static const char kLeftArgument[]
Definition: constraint_solver.h:3463
static const char kLess[]
Definition: constraint_solver.h:3378
static const char kNoCycle[]
Definition: constraint_solver.h:3389
static const char kGlobalCardinality[]
Definition: constraint_solver.h:3361
static const char kDurationMaxArgument[]
Definition: constraint_solver.h:3445
static const char kStartMaxArgument[]
Definition: constraint_solver.h:3483
static const char kNonEqual[]
Definition: constraint_solver.h:3390
virtual void BeginVisitIntegerExpression(const std::string &type_name, const IntExpr *const expr)
void VisitInt64ToInt64Extension(const Solver::IndexEvaluator1 &eval, int64 index_min, int64 index_max)
static const char kDurationMinArgument[]
Definition: constraint_solver.h:3446
virtual void BeginVisitConstraint(const std::string &type_name, const Constraint *const constraint)
static const char kSumLessOrEqual[]
Definition: constraint_solver.h:3413
static const char kIsLess[]
Definition: constraint_solver.h:3375
static const char kPerformedExpr[]
Definition: constraint_solver.h:3398
virtual void EndVisitConstraint(const std::string &type_name, const Constraint *const constraint)
static const char kDifference[]
Definition: constraint_solver.h:3351
static const char kAbsEqual[]
Definition: constraint_solver.h:3338
virtual void EndVisitExtension(const std::string &type)
static const char kEndMinArgument[]
Definition: constraint_solver.h:3450
static const char kLateDateArgument[]
Definition: constraint_solver.h:3462
static const char kCumulative[]
Definition: constraint_solver.h:3349
static const char kSmartTimeCheckArgument[]
Definition: constraint_solver.h:3481
static const char kNotBetween[]
Definition: constraint_solver.h:3391
static const char kNullIntersect[]
Definition: constraint_solver.h:3393
static const char kEndMaxArgument[]
Definition: constraint_solver.h:3449
virtual void VisitIntegerMatrixArgument(const std::string &arg_name, const IntTupleSet &tuples)
static const char kFalseConstraint[]
Definition: constraint_solver.h:3360
static const char kSequenceVariable[]
Definition: constraint_solver.h:3406
static const char kDisjunctive[]
Definition: constraint_solver.h:3352
static const char kTrueConstraint[]
Definition: constraint_solver.h:3416
static const char kEndExpr[]
Definition: constraint_solver.h:3358
static const char kMaxArgument[]
Definition: constraint_solver.h:3464
static const char kSquare[]
Definition: constraint_solver.h:3408
static const char kFinalStatesArgument[]
Definition: constraint_solver.h:3454
static const char kCountAssignedItemsExtension[]
Extension names:
Definition: constraint_solver.h:3421
static const char kTuplesArgument[]
Definition: constraint_solver.h:3490
virtual void VisitIntegerVariable(const IntVar *const variable, const std::string &operation, int64 value, IntVar *const delegate)
static const char kSolutionLimitArgument[]
Definition: constraint_solver.h:3482
static const char kValueArgument[]
Definition: constraint_solver.h:3491
static const char kIntervalsArgument[]
Definition: constraint_solver.h:3460
static const char kOptionalArgument[]
Definition: constraint_solver.h:3469
static const char kElementEqual[]
Definition: constraint_solver.h:3357
static const char kGreaterOrEqual[]
Definition: constraint_solver.h:3363
static const char kIsGreaterOrEqual[]
Definition: constraint_solver.h:3374
static const char kCoefficientsArgument[]
Definition: constraint_solver.h:3440
static const char kCumulsArgument[]
Definition: constraint_solver.h:3443
static const char kSumGreaterOrEqual[]
Definition: constraint_solver.h:3412
static const char kIsBetween[]
Definition: constraint_solver.h:3370
static const char kMaximizeArgument[]
Definition: constraint_solver.h:3465
static const char kIntervalArgument[]
Definition: constraint_solver.h:3459
static const char kPack[]
Definition: constraint_solver.h:3395
static const char kIntegerVariable[]
Definition: constraint_solver.h:3364
static const char kCover[]
Definition: constraint_solver.h:3348
virtual void VisitIntervalArrayArgument(const std::string &arg_name, const std::vector< IntervalVar * > &arguments)
static const char kSequenceArgument[]
Definition: constraint_solver.h:3476
virtual void VisitIntervalVariable(const IntervalVar *const variable, const std::string &operation, int64 value, IntervalVar *const delegate)
static const char kIndex2Argument[]
Definition: constraint_solver.h:3456
static const char kMinArgument[]
Definition: constraint_solver.h:3466
static const char kFailuresLimitArgument[]
Definition: constraint_solver.h:3453
static const char kScalProd[]
Definition: constraint_solver.h:3401
static const char kVarBoundWatcher[]
Definition: constraint_solver.h:3417
static const char kProductOperation[]
Definition: constraint_solver.h:3503
static const char kPower[]
Definition: constraint_solver.h:3399
static const char kBranchesLimitArgument[]
Definition: constraint_solver.h:3437
static const char kAtMost[]
Definition: constraint_solver.h:3341
static const char kNotMember[]
Definition: constraint_solver.h:3392
static const char kStartSyncOnStartOperation[]
Definition: constraint_solver.h:3504
virtual void VisitIntegerExpressionArgument(const std::string &arg_name, IntExpr *const argument)
Visit integer expression argument.
static const char kStartExpr[]
Definition: constraint_solver.h:3409
static const char kEarlyCostArgument[]
Definition: constraint_solver.h:3447
static const char kTransitsArgument[]
Definition: constraint_solver.h:3489
virtual void VisitSequenceArrayArgument(const std::string &arg_name, const std::vector< SequenceVar * > &arguments)
static const char kSizeXArgument[]
Definition: constraint_solver.h:3479
void VisitInt64ToBoolExtension(Solver::IndexFilter1 filter, int64 index_min, int64 index_max)
Using SWIG on callbacks is troublesome, so we hide these methods during the wrapping.
virtual void VisitIntervalArgument(const std::string &arg_name, IntervalVar *const argument)
Visit interval argument.
static const char kInitialState[]
Definition: constraint_solver.h:3458
static const char kCountArgument[]
Definition: constraint_solver.h:3441
static const char kRelaxedMaxOperation[]
Definition: constraint_solver.h:3499
static const char kPositionYArgument[]
Definition: constraint_solver.h:3472
virtual void VisitIntegerArrayArgument(const std::string &arg_name, const std::vector< int64 > &values)
static const char kStartMinArgument[]
Definition: constraint_solver.h:3484
static const char kExpressionArgument[]
Definition: constraint_solver.h:3452
static const char kScalProdGreaterOrEqual[]
Definition: constraint_solver.h:3403
static const char kWeightedSumOfAssignedEqualVariableExtension[]
Definition: constraint_solver.h:3432
static const char kStartsArgument[]
Definition: constraint_solver.h:3485
virtual void VisitSequenceArgument(const std::string &arg_name, SequenceVar *const argument)
Visit sequence argument.
void VisitInt64ToInt64AsArray(const Solver::IndexEvaluator1 &eval, const std::string &arg_name, int64 index_max)
Expands function as array when index min is 0.
static const char kInversePermutation[]
Definition: constraint_solver.h:3369
static const char kIsLessOrEqual[]
Definition: constraint_solver.h:3376
static const char kPositionXArgument[]
Definition: constraint_solver.h:3471
static const char kVariableUsageLessConstantExtension[]
Definition: constraint_solver.h:3431
static const char kStartSyncOnEndOperation[]
Definition: constraint_solver.h:3505
static const char kSumEqual[]
Definition: constraint_solver.h:3411
virtual void EndVisitModel(const std::string &type_name)
static const char kLexLess[]
Definition: constraint_solver.h:3380
static const char kSemiContinuous[]
Definition: constraint_solver.h:3405
static const char kConditionalExpr[]
Definition: constraint_solver.h:3344
static const char kSequencesArgument[]
Definition: constraint_solver.h:3477
static const char kTraceOperation[]
Definition: constraint_solver.h:3506
static const char kProduct[]
Definition: constraint_solver.h:3400
static const char kIntervalDisjunction[]
Definition: constraint_solver.h:3366
Subclass of RevArray<T> which adds numerical operations.
Definition: constraint_solver.h:3816
void Decr(Solver *const s, int index)
Definition: constraint_solver.h:3826
NumericalRevArray(int size, const T &val)
Definition: constraint_solver.h:3818
void Add(Solver *const s, int index, const T &to_add)
Definition: constraint_solver.h:3820
void Incr(Solver *const s, int index)
Definition: constraint_solver.h:3824
Subclass of Rev<T> which adds numerical operations.
Definition: constraint_solver.h:3758
NumericalRev(const T &val)
Definition: constraint_solver.h:3760
void Decr(Solver *const s)
Definition: constraint_solver.h:3768
void Incr(Solver *const s)
Definition: constraint_solver.h:3766
void Add(Solver *const s, const T &to_add)
Definition: constraint_solver.h:3762
This class encapsulates an objective.
Definition: constraint_solver.h:4204
void ApplyBound()
void BeginNextDecision(DecisionBuilder *const db) override
Before calling DecisionBuilder::Next.
~OptimizeVar() override
bool found_initial_solution_
Definition: constraint_solver.h:4232
void Accept(ModelVisitor *const visitor) const override
Accepts the given model visitor.
bool AcceptSolution() override
This method is called when a solution is found.
bool AtSolution() override
This method is called when a valid solution is found.
virtual std::string Print() const
void RefuteDecision(Decision *const d) override
Before refuting the decision.
OptimizeVar(Solver *const s, bool maximize, IntVar *const a, int64 step)
bool AcceptDelta(Assignment *delta, Assignment *deltadelta) override
Internal methods.
std::string DebugString() const override
void Propagate()
void AddWeightedSumOfAssignedDimension(const std::vector< int64 > &weights, IntVar *const cost_var)
This dimension enforces that cost_var == sum of weights[i] for all objects 'i' assigned to a bin.
bool IsAssignedStatusKnown(int var_index) const
void Post() override
This method is called when the constraint is processed by the solver.
void AddCountAssignedItemsDimension(IntVar *const count_var)
This dimension links 'count_var' to the actual number of items assigned to a bin in the pack.
void InitialPropagate() override
This method performs the initial propagation of the constraint.
void AddWeightedSumEqualVarDimension(Solver::IndexEvaluator2 weights, const std::vector< IntVar * > &loads)
This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b)) of all objects i as...
Pack(Solver *const s, const std::vector< IntVar * > &vars, int number_of_bins)
void SetImpossible(int var_index, int bin_index)
void SetAssigned(int var_index)
void AddWeightedSumLessOrEqualConstantDimension(Solver::IndexEvaluator1 weights, const std::vector< int64 > &bounds)
This dimension imposes that for all bins b, the weighted sum (weights->Run(i)) of all objects i assig...
void AddWeightedSumEqualVarDimension(const std::vector< int64 > &weights, const std::vector< IntVar * > &loads)
This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned t...
bool IsUndecided(int var_index, int bin_index) const
~Pack() override
bool IsPossible(int var_index, int bin_index) const
void AssignFirstPossibleToBin(int bin_index)
void AddCountUsedBinDimension(IntVar *const count_var)
This dimension links 'count_var' to the actual number of bins used in the pack.
void OneDomain(int var_index)
void SetUnassigned(int var_index)
void AddSumVariableWeightsLessOrEqualConstantDimension(const std::vector< IntVar * > &usage, const std::vector< int64 > &capacity)
This dimension imposes: forall b in bins, sum (i in items: usage[i] * is_assigned(i,...
void Accept(ModelVisitor *const visitor) const override
Accepts the given visitor.
void AssignAllPossibleToBin(int bin_index)
void ClearAll()
void PropagateDelayed()
void Assign(int var_index, int bin_index)
void UnassignAllRemainingItems()
std::string DebugString() const override
void AssignAllRemainingItems()
void AddWeightedSumLessOrEqualConstantDimension(const std::vector< int64 > &weights, const std::vector< int64 > &bounds)
Dimensions are additional constraints than can restrict what is possible with the pack constraint.
IntVar * AssignVar(int var_index, int bin_index) const
void RemoveAllPossibleFromBin(int bin_index)
void AddWeightedSumLessOrEqualConstantDimension(Solver::IndexEvaluator2 weights, const std::vector< int64 > &bounds)
This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b) of all objects i ass...
virtual std::string BaseName() const
Returns a base name for automatic naming.
Solver * solver() const
Definition: constraint_solver.h:3179
void EnqueueDelayedDemon(Demon *const d)
This method pushes the demon onto the propagation queue.
Definition: constraint_solver.h:3192
void reset_action_on_fail()
This method clears the failure callback.
Definition: constraint_solver.h:3206
bool HasName() const
Returns whether the object has been named or not.
void set_action_on_fail(Solver::Action a)
Definition: constraint_solver.h:3200
void ExecuteAll(const SimpleRevFIFO< Demon * > &demons)
void EnqueueVar(Demon *const d)
Definition: constraint_solver.h:3193
void EnqueueAll(const SimpleRevFIFO< Demon * > &demons)
~PropagationBaseObject() override
Definition: constraint_solver.h:3170
void set_variable_to_clean_on_fail(IntVar *v)
Shortcut for variable cleaner.
Definition: constraint_solver.h:3209
PropagationBaseObject(Solver *const s)
Definition: constraint_solver.h:3169
void set_name(const std::string &name)
void UnfreezeQueue()
This method unfreezes the propagation queue.
Definition: constraint_solver.h:3187
std::string DebugString() const override
Definition: constraint_solver.h:3172
Usual limit based on wall_time, number of explored branches and number of failures in the search tree...
Definition: constraint_solver.h:4281
bool Check() override
This method is called to check the status of the limit.
absl::Duration duration_limit() const
Definition: constraint_solver.h:4295
bool IsUncheckedSolutionLimitReached() override
Returns true if the limit of solutions has been reached including unchecked solutions.
int64 solutions() const
Definition: constraint_solver.h:4303
int64 failures() const
Definition: constraint_solver.h:4302
void Init() override
This method is called when the search limit is initialized.
~RegularLimit() override
RegularLimit(Solver *const s, absl::Duration time, int64 branches, int64 failures, int64 solutions, bool smart_time_check, bool cumulative)
int ProgressPercent() override
Returns a percentage representing the propress of the search before reaching limits.
int64 wall_time() const
Definition: constraint_solver.h:4296
absl::Time AbsoluteSolverDeadline() const
Definition: constraint_solver.h:4308
void Accept(ModelVisitor *const visitor) const override
Accepts the given model visitor.
void Copy(const SearchLimit *const limit) override
Copy a limit.
void UpdateLimits(absl::Duration time, int64 branches, int64 failures, int64 solutions)
int64 branches() const
Definition: constraint_solver.h:4301
RegularLimit * MakeIdenticalClone() const
std::string DebugString() const override
SearchLimit * MakeClone() const override
Allocates a clone of the limit.
const T & operator[](int index) const
Definition: constraint_solver.h:3794
const T & Value(int index) const
Definition: constraint_solver.h:3791
RevArray(int size, const T &val)
Definition: constraint_solver.h:3779
void SetValue(Solver *const s, int index, const T &val)
Definition: constraint_solver.h:3797
Matrix version of the RevBitSet class.
Definition: constraint_solveri.h:463
This class represents a reversible bitset.
Definition: constraint_solveri.h:428
This class adds reversibility to a POD type.
Definition: constraint_solver.h:3735
void SetValue(Solver *const s, const T &val)
Definition: constraint_solver.h:3741
Reversible Immutable MultiMap class.
Definition: constraint_solveri.h:281
Definition: routing.h:213
Base class of all search limits.
Definition: constraint_solver.h:4239
virtual SearchLimit * MakeClone() const =0
Allocates a clone of the limit.
SearchLimit(Solver *const s)
Definition: constraint_solver.h:4241
void PeriodicCheck() override
Periodic call to check limits in long running methods.
virtual void Init()=0
This method is called when the search limit is initialized.
~SearchLimit() override
void BeginNextDecision(DecisionBuilder *const b) override
Before calling DecisionBuilder::Next.
virtual void Copy(const SearchLimit *const limit)=0
Copy a limit.
void RefuteDecision(Decision *const d) override
Before refuting the decision.
std::string DebugString() const override
Definition: constraint_solver.h:4268
virtual bool Check()=0
This method is called to check the status of the limit.
A search monitor is a simple set of callbacks to monitor all search events.
Definition: constraint_solver.h:3635
SearchMonitor(Solver *const s)
Definition: constraint_solver.h:3639
Solver * solver() const
Definition: constraint_solver.h:3708
virtual void RefuteDecision(Decision *const d)
Before refuting the decision.
virtual void Install()
Registers itself on the solver such that it gets notified of the search and propagation events.
virtual bool IsUncheckedSolutionLimitReached()
Returns true if the limit of solutions has been reached including unchecked solutions.
Definition: constraint_solver.h:3706
virtual void EndInitialPropagation()
After the initial propagation.
virtual void PeriodicCheck()
Periodic call to check limits in long running methods.
virtual bool AcceptSolution()
This method is called when a solution is found.
virtual int ProgressPercent()
Returns a percentage representing the propress of the search before reaching limits.
Definition: constraint_solver.h:3715
virtual void AcceptNeighbor()
After accepting a neighbor during local search.
virtual void NoMoreSolutions()
When the search tree is finished.
~SearchMonitor() override
Definition: constraint_solver.h:3640
static constexpr int kNoProgress
Definition: constraint_solver.h:3637
virtual bool AcceptDelta(Assignment *delta, Assignment *deltadelta)
virtual void AfterDecision(Decision *const d, bool apply)
Just after refuting or applying the decision, apply is true after Apply.
virtual bool AtSolution()
This method is called when a valid solution is found.
virtual void EndNextDecision(DecisionBuilder *const b, Decision *const d)
After calling DecisionBuilder::Next, along with the returned decision.
virtual bool LocalOptimum()
When a local optimum is reached.
virtual void BeginNextDecision(DecisionBuilder *const b)
Before calling DecisionBuilder::Next.
virtual void BeginInitialPropagation()
Before the initial propagation.
virtual void AcceptUncheckedNeighbor()
After accepting an unchecked neighbor during local search.
virtual void ApplyDecision(Decision *const d)
Before applying the decision.
virtual void Accept(ModelVisitor *const visitor) const
Accepts the given model visitor.
The SequenceVarElement stores a partial representation of ranked interval variables in the underlying...
Definition: constraint_solver.h:4815
void SetSequence(const std::vector< int > &forward_sequence, const std::vector< int > &backward_sequence, const std::vector< int > &unperformed)
void Restore()
void Reset(SequenceVar *const var)
bool operator==(const SequenceVarElement &element) const
const std::vector< int > & BackwardSequence() const
bool operator!=(const SequenceVarElement &element) const
Definition: constraint_solver.h:4845
void Store()
void SetBackwardSequence(const std::vector< int > &backward_sequence)
const std::vector< int > & Unperformed() const
bool Bound() const
Definition: constraint_solver.h:4838
SequenceVarElement()
void SetUnperformed(const std::vector< int > &unperformed)
std::string DebugString() const
SequenceVarElement * Clone()
const std::vector< int > & ForwardSequence() const
void Copy(const SequenceVarElement &element)
SequenceVarElement(SequenceVar *const var)
void LoadFromProto(const SequenceVarAssignment &sequence_var_assignment_proto)
void WriteToProto(SequenceVarAssignment *sequence_var_assignment_proto) const
void SetForwardSequence(const std::vector< int > &forward_sequence)
SequenceVar * Var() const
Definition: constraint_solver.h:4822
A sequence variable is a variable whose domain is a set of possible orderings of the interval variabl...
Definition: constraint_solver.h:4548
void ComputePossibleFirstsAndLasts(std::vector< int > *const possible_firsts, std::vector< int > *const possible_lasts)
Computes the set of indices of interval variables that can be ranked first in the set of unranked act...
void FillSequence(std::vector< int > *const rank_first, std::vector< int > *const rank_last, std::vector< int > *const unperformed) const
Clears 'rank_first' and 'rank_last', and fills them with the intervals in the order of the ranks.
void RankSequence(const std::vector< int > &rank_first, const std::vector< int > &rank_last, const std::vector< int > &unperformed)
Applies the following sequence of ranks, ranks first, then rank last.
void ComputeStatistics(int *const ranked, int *const not_ranked, int *const unperformed) const
Compute statistics on the sequence.
void ActiveHorizonRange(int64 *const hmin, int64 *const hmax) const
Returns the minimum start min and the maximum end max of all unranked interval vars in the sequence.
~SequenceVar() override
void HorizonRange(int64 *const hmin, int64 *const hmax) const
Returns the minimum start min and the maximum end max of all interval vars in the sequence.
int64 size() const
Returns the number of interval vars in the sequence.
Definition: constraint_solver.h:4624
IntVar * Next(int index) const
Returns the next of the index_th interval of the sequence.
IntervalVar * Interval(int index) const
Returns the index_th interval of the sequence.
void RankLast(int index)
Ranks the index_th interval var first of all unranked interval vars.
void DurationRange(int64 *const dmin, int64 *const dmax) const
Returns the minimum and maximum duration of combined interval vars in the sequence.
void RankFirst(int index)
Ranks the index_th interval var first of all unranked interval vars.
void RankNotLast(int index)
Indicates that the index_th interval var will not be ranked first of all currently unranked interval ...
void RankNotFirst(int index)
Indicates that the index_th interval var will not be ranked first of all currently unranked interval ...
SequenceVar(Solver *const s, const std::vector< IntervalVar * > &intervals, const std::vector< IntVar * > &nexts, const std::string &name)
std::string DebugString() const override
virtual void Accept(ModelVisitor *const visitor) const
Accepts the given visitor.
This class represent a reversible FIFO structure.
Definition: constraint_solveri.h:145
This class is the root class of all solution collectors.
Definition: constraint_solver.h:4101
void check_index(int n) const
void EnterSearch() override
Beginning of the search.
int64 Value(int n, IntVar *const var) const
This is a shortcut to get the Value of 'var' in the nth solution.
int64 failures(int n) const
Returns the number of failures encountered at the time of the nth solution.
~SolutionCollector() override
void Push(const SolutionData &data)
Definition: constraint_solver.h:4182
void PushSolution()
Push the current state as a new solution.
void AddObjective(IntVar *const objective)
std::vector< Assignment * > recycle_solutions_
Definition: constraint_solver.h:4191
void Add(const std::vector< SequenceVar * > &vars)
std::vector< SolutionData > solution_data_
Definition: constraint_solver.h:4190
SolutionCollector(Solver *const solver)
int solution_count() const
Returns how many solutions were stored during the search.
int64 DurationValue(int n, IntervalVar *const var) const
This is a shortcut to get the DurationValue of 'var' in the nth solution.
void Add(const std::vector< IntVar * > &vars)
void Add(IntervalVar *const var)
void Add(const std::vector< IntervalVar * > &vars)
int64 PerformedValue(int n, IntervalVar *const var) const
This is a shortcut to get the PerformedValue of 'var' in the nth solution.
SolutionData BuildSolutionDataForCurrentState()
const std::vector< int > & Unperformed(int n, SequenceVar *const var) const
This is a shortcut to get the list of unperformed of 'var' in the nth solution.
Assignment * solution(int n) const
Returns the nth solution.
int64 wall_time(int n) const
Returns the wall time in ms for the nth solution.
int64 EndValue(int n, IntervalVar *const var) const
This is a shortcut to get the EndValue of 'var' in the nth solution.
const std::vector< int > & ForwardSequence(int n, SequenceVar *const var) const
This is a shortcut to get the ForwardSequence of 'var' in the nth solution.
int64 objective_value(int n) const
Returns the objective value of the nth solution.
void FreeSolution(Assignment *solution)
std::unique_ptr< Assignment > prototype_
Definition: constraint_solver.h:4189
SolutionCollector(Solver *const solver, const Assignment *assignment)
int64 branches(int n) const
Returns the number of branches when the nth solution was found.
void PopSolution()
Remove and delete the last popped solution.
std::string DebugString() const override
Definition: constraint_solver.h:4106
const std::vector< int > & BackwardSequence(int n, SequenceVar *const var) const
This is a shortcut to get the BackwardSequence of 'var' in the nth solution.
void Add(SequenceVar *const var)
int64 StartValue(int n, IntervalVar *const var) const
This is a shortcut to get the StartValue of 'var' in the nth solution.
This class is used to manage a pool of solutions.
Definition: constraint_solver.h:5377
virtual bool SyncNeeded(Assignment *const local_assignment)=0
This method checks if the local solution needs to be updated with an external one.
virtual void RegisterNewSolution(Assignment *const assignment)=0
This method is called when a new solution has been accepted by the local search.
virtual void GetNextSolution(Assignment *const assignment)=0
This method is called when the local search starts a new neighborhood to initialize the default assig...
~SolutionPool() override
Definition: constraint_solver.h:5380
virtual void Initialize(Assignment *const assignment)=0
This method is called to initialize the solution pool with the assignment from the local search.
Constraint * MakeIntervalVarRelation(IntervalVar *const t1, BinaryIntervalRelation r, IntervalVar *const t2)
This method creates a relation between two interval vars.
Decision * MakeDecision(Action apply, Action refute)
std::function< bool(int64)> IndexFilter1
Definition: constraint_solver.h:747
IntExpr * MakeElement(const std::vector< int64 > &values, IntVar *const index)
values[index]
SearchMonitor * MakeLubyRestart(int scale_factor)
This search monitor will restart the search periodically.
Constraint * MakeMemberCt(IntExpr *const expr, const std::vector< int64 > &values)
expr in set.
SolutionCollector * MakeAllSolutionCollector()
Collect all solutions of the search.
IntVarLocalSearchFilter * MakeSumObjectiveFilter(const std::vector< IntVar * > &vars, const std::vector< IntVar * > &secondary_vars, IndexEvaluator3 values, Solver::LocalSearchFilterBound filter_enum)
DecisionModification
The Solver is responsible for creating the search tree.
Definition: constraint_solver.h:695
bool IsBooleanVar(IntExpr *const expr, IntVar **inner_var, bool *is_negated) const
Returns true if expr represents either boolean_var or 1 - boolean_var.
DecisionBuilder * MakeNestedOptimize(DecisionBuilder *const db, Assignment *const solution, bool maximize, int64 step, SearchMonitor *const monitor1, SearchMonitor *const monitor2, SearchMonitor *const monitor3)
IntExpr * MakeSum(const std::vector< IntVar * > &vars)
sum of all vars.
RegularLimit * MakeLimit(absl::Duration time, int64 branches, int64 failures, int64 solutions, bool smart_time_check=false, bool cumulative=false)
Limits the search with the 'time', 'branches', 'failures' and 'solutions' limits.
bool SolveAndCommit(DecisionBuilder *const db)
void 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>" wher...
LocalSearchFilter * MakeVariableDomainFilter()
Decision * MakeSplitVariableDomain(IntVar *const var, int64 val, bool start_with_lower_half)
bool HasName(const PropagationBaseObject *object) const
Returns whether the object has been named or not.
Constraint * MakeDeviation(const std::vector< IntVar * > &vars, IntVar *const deviation_var, int64 total_sum)
Deviation constraint: sum_i |n * vars[i] - total_sum| <= deviation_var and sum_i vars[i] == total_sum...
void RestartSearch()
OptimizeVar * MakeWeightedMaximize(const std::vector< IntVar * > &sub_objectives, const std::vector< int64 > &weights, int64 step)
Creates a maximization weigthed objective.
LocalSearchPhaseParameters * MakeLocalSearchPhaseParameters(IntVar *objective, LocalSearchOperator *const ls_operator, DecisionBuilder *const sub_decision_builder, RegularLimit *const limit)
SolutionCollector * MakeLastSolutionCollector()
Collect the last solution of the search.
LocalSearchPhaseParameters * MakeLocalSearchPhaseParameters(IntVar *objective, LocalSearchOperator *const ls_operator, DecisionBuilder *const sub_decision_builder, RegularLimit *const limit, LocalSearchFilterManager *filter_manager)
RegularLimit * MakeSolutionsLimit(int64 solutions)
Creates a search limit that constrains the number of solutions found during the search.
Decision * MakeAssignVariableValue(IntVar *const var, int64 val)
Decisions.
SearchMonitor * MakeAtSolutionCallback(std::function< void()> callback)
IntExpr * MakeProd(IntExpr *const expr, int64 value)
expr * value
IntExpr * RegisterIntExpr(IntExpr *const expr)
Registers a new IntExpr and wraps it inside a TraceIntExpr if necessary.
SolutionCollector * MakeAllSolutionCollector(const Assignment *const assignment)
Collect all solutions of the search.
IntVar * MakeIsGreaterOrEqualCstVar(IntExpr *const var, int64 value)
status var of (var >= value)
void RestartCurrentSearch()
SearchLimit * MakeCustomLimit(std::function< bool()> limiter)
Callback-based search limit.
friend class DemonProfiler
Definition: constraint_solver.h:2944
Constraint * MakeNullIntersectExcept(const std::vector< IntVar * > &first_vars, const std::vector< IntVar * > &second_vars, int64 escape_value)
Creates a constraint that states that all variables in the first vector are different from all variab...
bool SolveAndCommit(DecisionBuilder *const db, const std::vector< SearchMonitor * > &monitors)
SolveAndCommit using a decision builder and up to three search monitors, usually one for the objectiv...
Constraint * MakeLess(IntExpr *const left, IntExpr *const right)
left < right
bool SolveAndCommit(DecisionBuilder *const db, SearchMonitor *const m1, SearchMonitor *const m2, SearchMonitor *const m3)
Constraint * MakeIntervalVarRelation(IntervalVar *const t, UnaryIntervalRelation r, int64 d)
This method creates a relation between an interval var and a date.
friend void InternalSaveBooleanVarValue(Solver *const, IntVar *const)
LocalSearchOperator * MakeMoveTowardTargetOperator(const Assignment &target)
Creates a local search operator that tries to move the assignment of some variables toward a target.
Constraint * MakeSubCircuit(const std::vector< IntVar * > &nexts)
Force the "nexts" variable to create a complete Hamiltonian path for those that do not loop upon them...
DecisionBuilder * MakePhase(const std::vector< IntVar * > &vars, IntVarStrategy var_str, VariableValueComparator var_val1_val2_comparator)
var_val1_val2_comparator(var, val1, val2) is true iff assigning value "val1" to variable "var" is bet...
Constraint * MakeFalseConstraint()
This constraint always fails.
void NewSearch(DecisionBuilder *const db)
Constraint * MakeEquality(IntExpr *const left, IntExpr *const right)
left == right
Constraint * MakeIsDifferentCt(IntExpr *const v1, IntExpr *const v2, IntVar *const b)
b == (v1 != v2)
Constraint * MakeCount(const std::vector< IntVar * > &vars, int64 value, IntVar *const max_count)
|{i | vars[i] == value}| == max_count
IntExpr * MakeScalProd(const std::vector< IntVar * > &vars, const std::vector< int > &coefs)
scalar product
Constraint * MakeLessOrEqual(IntExpr *const left, IntExpr *const right)
left <= right
IntExpr * MakePiecewiseLinearExpr(IntExpr *expr, const PiecewiseLinearFunction &f)
General piecewise-linear function expression, built from f(x) where f is piecewise-linear.
int64 solutions() const
The number of solutions found since the start of the search.
ConstraintSolverStatistics GetConstraintSolverStatistics() const
Returns detailed cp search statistics.
Constraint * MakeNullIntersect(const std::vector< IntVar * > &first_vars, const std::vector< IntVar * > &second_vars)
Creates a constraint that states that all variables in the first vector are different from all variab...
DisjunctiveConstraint * MakeStrictDisjunctiveConstraint(const std::vector< IntervalVar * > &intervals, const std::string &name)
This constraint forces all interval vars into an non-overlapping sequence.
Constraint * MakeCumulative(const std::vector< IntervalVar * > &intervals, const std::vector< IntVar * > &demands, IntVar *const capacity, const std::string &name)
This constraint enforces that, for any integer t, the sum of demands corresponding to an interval con...
IntVar * MakeIsGreaterVar(IntExpr *const left, IntExpr *const right)
status var of (left > right)
LocalSearchStatistics GetLocalSearchStatistics() const
Returns detailed local search statistics.
IntExpr * MakeMin(const std::vector< IntVar * > &vars)
std::min(vars)
Constraint * MakeLess(IntExpr *const expr, int value)
expr < value
Constraint * MakeIsLessCstCt(IntExpr *const v, int64 c, IntVar *const b)
b == (v < c)
static constexpr int kNumPriorities
Number of priorities for demons.
Definition: constraint_solver.h:270
Decision * MakeAssignVariableValueOrFail(IntVar *const var, int64 value)
DemonPriority
This enum represents the three possible priorities for a demon in the Solver queue.
Definition: constraint_solver.h:613
@ VAR_PRIORITY
VAR_PRIORITY is between DELAYED_PRIORITY and NORMAL_PRIORITY.
Definition: constraint_solver.h:619
@ DELAYED_PRIORITY
DELAYED_PRIORITY is the lowest priority: Demons will be processed after VAR_PRIORITY and NORMAL_PRIOR...
Definition: constraint_solver.h:616
@ NORMAL_PRIORITY
NORMAL_PRIORITY is the highest priority: Demons will be processed first.
Definition: constraint_solver.h:622
OptimizeVar * MakeMaximize(IntVar *const v, int64 step)
Creates a maximization objective.
Constraint * MakeElementEquality(const std::vector< IntVar * > &vars, IntVar *const index, IntVar *const target)
int64 failures() const
The number of failures encountered since the creation of the solver.
Definition: constraint_solver.h:999
Constraint * MakeIndexOfFirstMinValueConstraint(IntVar *index, const std::vector< IntVar * > &vars)
Creates a constraint that binds the index variable to the index of the first variable with the minimu...
SearchMonitor * MakeSymmetryManager(const std::vector< SymmetryBreaker * > &visitors)
Symmetry Breaking.
LocalSearchPhaseParameters * MakeLocalSearchPhaseParameters(IntVar *objective, SolutionPool *const pool, LocalSearchOperator *const ls_operator, DecisionBuilder *const sub_decision_builder, RegularLimit *const limit, LocalSearchFilterManager *filter_manager)
IntExpr * MakeModulo(IntExpr *const x, IntExpr *const mod)
Modulo expression x % mod (with the python convention for modulo).
SolverState
This enum represents the state of the solver w.r.t. the search.
Definition: constraint_solver.h:724
@ NO_MORE_SOLUTIONS
After failed NextSolution and before EndSearch.
Definition: constraint_solver.h:734
int64 demon_runs(DemonPriority p) const
The number of demons executed during search for a given priority.
Definition: constraint_solver.h:996
Constraint * MakeAbsEquality(IntVar *const var, IntVar *const abs_var)
Creates the constraint abs(var) == abs_var.
std::function< bool(int64, int64, int64)> VariableValueComparator
Definition: constraint_solver.h:756
Constraint * MakeNonEquality(IntExpr *const expr, int value)
expr != value
std::string SearchContext() const
SearchLimit * MakeLimit(SearchLimit *const limit_1, SearchLimit *const limit_2)
Creates a search limit that is reached when either of the underlying limit is reached.
bool CheckAssignment(Assignment *const solution)
Checks whether the given assignment satisfies all relevant constraints.
IntVar * RegisterIntVar(IntVar *const var)
Registers a new IntVar and wraps it inside a TraceIntVar if necessary.
void EndSearch()
DecisionBuilder * MakePhase(IntVar *const v0, IntVar *const v1, IntVarStrategy var_str, IntValueStrategy val_str)
SolutionCollector * MakeLastSolutionCollector(const Assignment *const assignment)
Collect the last solution of the search.
SearchMonitor * MakeGenericTabuSearch(bool maximize, IntVar *const v, int64 step, const std::vector< IntVar * > &tabu_vars, int64 forbid_tenure)
Creates a Tabu Search based on the vars |vars|.
DecisionBuilder * Try(const std::vector< DecisionBuilder * > &dbs)
SearchMonitor * MakeSimulatedAnnealing(bool maximize, IntVar *const v, int64 step, int64 initial_temperature)
Creates a Simulated Annealing monitor.
IntVar * MakeIsDifferentVar(IntExpr *const v1, IntExpr *const v2)
status var of (v1 != v2)
Constraint * MakeMemberCt(IntExpr *const expr, const std::vector< int > &values)
IntVar * MakeIsEqualVar(IntExpr *const v1, IntExpr *v2)
status var of (v1 == v2)
Constraint * MakeNotBetweenCt(IntExpr *const expr, int64 l, int64 u)
(expr < l || expr > u) This constraint is lazy as it will not make holes in the domain of variables.
DecisionBuilder * MakeConstraintAdder(Constraint *const ct)
Returns a decision builder that will add the given constraint to the model.
Constraint * MakeCircuit(const std::vector< IntVar * > &nexts)
Force the "nexts" variable to create a complete Hamiltonian path.
IntVar * MakeIntConst(int64 val)
IntConst will create a constant expression.
IntervalStrategy
This enum describes the straregy used to select the next interval variable and its value to be fixed.
Definition: constraint_solver.h:419
@ INTERVAL_SET_TIMES_FORWARD
Selects the variable with the lowest starting time of all variables, and fixes its starting time to t...
Definition: constraint_solver.h:426
@ INTERVAL_SET_TIMES_BACKWARD
Selects the variable with the highest ending time of all variables, and fixes the ending time to this...
Definition: constraint_solver.h:429
Constraint * MakeGreater(IntExpr *const left, IntExpr *const right)
left > right
Pack * MakePack(const std::vector< IntVar * > &vars, int number_of_bins)
This constraint packs all variables onto 'number_of_bins' variables.
Assignment * GetOrCreateLocalSearchState()
Returns (or creates) an assignment representing the state of local search.
Constraint * MakeTransitionConstraint(const std::vector< IntVar * > &vars, const IntTupleSet &transition_table, int64 initial_state, const std::vector< int64 > &final_states)
This constraint create a finite automaton that will check the sequence of variables vars.
LocalSearchOperator * MakeOperator(const std::vector< IntVar * > &vars, IndexEvaluator3 evaluator, EvaluatorLocalSearchOperators op)
bool IsProfilingEnabled() const
Returns whether we are profiling the solver.
Constraint * MakeElementEquality(const std::vector< IntVar * > &vars, IntVar *const index, int64 target)
Demon * MakeActionDemon(Action action)
Creates a demon from a callback.
DecisionBuilder * Try(DecisionBuilder *const db1, DecisionBuilder *const db2)
Creates a decision builder which will create a search tree where each decision builder is called from...
uint64 fail_stamp() const
The fail_stamp() is incremented after each backtrack.
Constraint * MakeLexicalLess(const std::vector< IntVar * > &left, const std::vector< IntVar * > &right)
Creates a constraint that enforces that left is lexicographically less than right.
LocalSearchOperator * MakeMoveTowardTargetOperator(const std::vector< IntVar * > &variables, const std::vector< int64 > &target_values)
Creates a local search operator that tries to move the assignment of some variables toward a target.
void AddPropagationMonitor(PropagationMonitor *const monitor)
Adds the propagation monitor to the solver.
Constraint * MakeBetweenCt(IntExpr *const expr, int64 l, int64 u)
(l <= expr <= u)
Constraint * MakeIsEqualCstCt(IntExpr *const var, int64 value, IntVar *const boolvar)
boolvar == (var == value)
DecisionBuilder * MakeNestedOptimize(DecisionBuilder *const db, Assignment *const solution, bool maximize, int64 step, SearchMonitor *const monitor1, SearchMonitor *const monitor2, SearchMonitor *const monitor3, SearchMonitor *const monitor4)
RegularLimit * MakeFailuresLimit(int64 failures)
Creates a search limit that constrains the number of failures that can happen when exploring the sear...
RegularLimit * MakeTimeLimit(int64 time_in_ms)
Definition: constraint_solver.h:2211
SearchMonitor * MakeSearchLog(int branch_period)
The SearchMonitors below will display a periodic search log on LOG(INFO) every branch_period branches...
DecisionBuilder * MakeNestedOptimize(DecisionBuilder *const db, Assignment *const solution, bool maximize, int64 step, SearchMonitor *const monitor1)
IntValueStrategy
This enum describes the strategy used to select the next variable value to set.
Definition: constraint_solver.h:355
@ ASSIGN_CENTER_VALUE
Selects the first possible value which is the closest to the center of the domain of the selected var...
Definition: constraint_solver.h:374
@ SPLIT_UPPER_HALF
Split the domain in two around the center, and choose the lower part first.
Definition: constraint_solver.h:382
@ ASSIGN_MIN_VALUE
Selects the min value of the selected variable.
Definition: constraint_solver.h:363
@ ASSIGN_RANDOM_VALUE
Selects randomly one of the possible values of the selected variable.
Definition: constraint_solver.h:369
@ ASSIGN_MAX_VALUE
Selects the max value of the selected variable.
Definition: constraint_solver.h:366
@ SPLIT_LOWER_HALF
Split the domain in two around the center, and choose the lower part first.
Definition: constraint_solver.h:378
IntExpr * MakePower(IntExpr *const expr, int64 n)
expr ^ n (n > 0)
Constraint * MakeEquality(IntExpr *const expr, int value)
expr == value
UnaryIntervalRelation
This enum is used in Solver::MakeIntervalVarRelation to specify the temporal relation between an inte...
Definition: constraint_solver.h:660
Constraint * MakeDelayedPathCumul(const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, const std::vector< IntVar * > &cumuls, const std::vector< IntVar * > &transits)
Delayed version of the same constraint: propagation on the nexts variables is delayed until all const...
Constraint * MakeDistribute(const std::vector< IntVar * > &vars, const std::vector< int64 > &values, const std::vector< int64 > &card_min, const std::vector< int64 > &card_max)
Aggregated version of count with bounded cardinalities: forall j in 0 .
bool CheckConstraint(Constraint *const ct)
Checks whether adding this constraint will lead to an immediate failure.
IntVar * MakeIsDifferentCstVar(IntExpr *const var, int64 value)
status var of (var != value)
Constraint * MakeCover(const std::vector< IntervalVar * > &vars, IntervalVar *const target_var)
This constraint states that the target_var is the convex hull of the intervals.
void SetSearchContext(Search *search, const std::string &search_context)
bool SolveAndCommit(DecisionBuilder *const db, SearchMonitor *const m1, SearchMonitor *const m2)
Constraint * MakeIsGreaterCstCt(IntExpr *const v, int64 c, IntVar *const b)
b == (v > c)
SearchMonitor * MakeSearchLog(int branch_period, std::function< std::string()> display_callback)
At each solution, this monitor will also display result of display_callback.
IntVar ** MakeBoolVarArray(int var_count, const std::string &name)
Same but allocates an array and returns it.
bool Solve(DecisionBuilder *const db, SearchMonitor *const m1, SearchMonitor *const m2)
Decision * MakeAssignVariablesValues(const std::vector< IntVar * > &vars, const std::vector< int64 > &values)
Constraint * MakeCumulative(const std::vector< IntervalVar * > &intervals, const std::vector< int64 > &demands, int64 capacity, const std::string &name)
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval c...
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)
This constraint states that all the boxes must not overlap.
void TopPeriodicCheck()
Performs PeriodicCheck on the top-level search; for instance, can be called from a nested solve to ch...
DecisionBuilder * MakeLocalSearchPhase(const std::vector< IntVar * > &vars, DecisionBuilder *const first_solution, DecisionBuilder *const first_solution_sub_decision_builder, LocalSearchPhaseParameters *const parameters)
Variant with a sub_decison_builder specific to the first solution.
void MakeFixedDurationIntervalVarArray(const std::vector< IntVar * > &start_variables, const std::vector< int > &durations, const std::vector< IntVar * > &performed_variables, const std::string &name, std::vector< IntervalVar * > *const array)
This method fills the vector with interval variables built with the corresponding start and performed...
DecisionBuilder * MakeApplyBranchSelector(BranchSelector bs)
Creates a decision builder that will set the branch selector.
LocalSearchPhaseParameters * MakeLocalSearchPhaseParameters(IntVar *objective, SolutionPool *const pool, LocalSearchOperator *const ls_operator, DecisionBuilder *const sub_decision_builder)
IntExpr * MakeDiv(IntExpr *const numerator, IntExpr *const denominator)
numerator / denominator (integer division). Terms need to be positive.
Constraint * MakeAllDifferentExcept(const std::vector< IntVar * > &vars, int64 escape_value)
All variables are pairwise different, unless they are assigned to the escape value.
IntervalVar * MakeFixedDurationIntervalVar(IntVar *const start_variable, int64 duration, IntVar *const performed_variable, const std::string &name)
Creates an interval var with a fixed duration, and performed_variable.
SearchMonitor * MakeSymmetryManager(SymmetryBreaker *const v1, SymmetryBreaker *const v2, SymmetryBreaker *const v3)
int64 Rand64(int64 size)
Returns a random value between 0 and 'size' - 1;.
Definition: constraint_solver.h:2828
LocalSearchOperator * RandomConcatenateOperators(const std::vector< LocalSearchOperator * > &ops, int32 seed)
Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeig...
SearchMonitor * MakeSearchLog(int branch_period, IntVar *var, std::function< std::string()> display_callback)
At each solution, this monitor will display the 'var' value and the result of display_callback.
Constraint * MakePathTransitPrecedenceConstraint(std::vector< IntVar * > nexts, std::vector< IntVar * > transits, const std::vector< std::pair< int, int > > &precedences)
Same as MakePathPrecedenceConstraint but will force i to be before j if the sum of transits on the pa...
void SetUseFastLocalSearch(bool use_fast_local_search)
enabled for metaheuristics.
Definition: constraint_solver.h:2884
Decision * MakeAssignVariableValueOrDoNothing(IntVar *const var, int64 value)
IntervalVar * MakeIntervalRelaxedMin(IntervalVar *const interval_var)
Creates and returns an interval variable that wraps around the given one, relaxing the min start and ...
Constraint * MakeNotMemberCt(IntExpr *const expr, const std::vector< int > &values)
IntervalVar * MakeFixedDurationEndSyncedOnEndIntervalVar(IntervalVar *const interval_var, int64 duration, int64 offset)
Creates an interval var with a fixed duration whose end is synchronized with the end of another inter...
DecisionBuilder * MakePhase(const std::vector< IntervalVar * > &intervals, IntervalStrategy str)
Scheduling phases.
Constraint * MakePathConnected(std::vector< IntVar * > nexts, std::vector< int64 > sources, std::vector< int64 > sinks, std::vector< IntVar * > status)
Constraint enforcing that status[i] is true iff there's a path defined on next variables from sources...
Demon * MakeClosureDemon(Closure closure)
!defined(SWIG)
void AddConstraint(Constraint *const c)
Adds the constraint 'c' to the model.
Constraint * MakeNonOverlappingBoxesConstraint(const std::vector< IntVar * > &x_vars, const std::vector< IntVar * > &y_vars, const std::vector< int64 > &x_size, const std::vector< int64 > &y_size)
void NewSearch(DecisionBuilder *const db, SearchMonitor *const m1)
Constraint * MakeAllDifferent(const std::vector< IntVar * > &vars, bool stronger_propagation)
All variables are pairwise different.
DecisionBuilder * MakeSolveOnce(DecisionBuilder *const db)
SolveOnce will collapse a search tree described by a decision builder 'db' and a set of monitors and ...
LocalSearchOperator * ConcatenateOperators(const std::vector< LocalSearchOperator * > &ops)
Creates a local search operator which concatenates a vector of operators.
IntervalVar * MakeFixedInterval(int64 start, int64 duration, const std::string &name)
Creates a fixed and performed interval.
LocalSearchFilter * MakeRejectFilter()
Constraint * MakePathPrecedenceConstraint(std::vector< IntVar * > nexts, const std::vector< std::pair< int, int > > &precedences, const std::vector< int > &lifo_path_starts, const std::vector< int > &fifo_path_starts)
Same as MakePathPrecedenceConstraint but ensures precedence pairs on some paths follow a LIFO or FIFO...
Constraint * MakeScalProdEquality(const std::vector< IntVar * > &vars, const std::vector< int > &coefficients, IntVar *const target)
IntExpr * MakeElement(const std::vector< int > &values, IntVar *const index)
values[index]
Constraint * MakeNotMemberCt(IntExpr *expr, SortedDisjointIntervalList intervals)
expr should not be in the list of forbidden intervals.
void MakeFixedDurationIntervalVarArray(const std::vector< IntVar * > &start_variables, const std::vector< int64 > &durations, const std::vector< IntVar * > &performed_variables, const std::string &name, std::vector< IntervalVar * > *const array)
This method fills the vector with interval variables built with the corresponding start and performed...
LocalSearchFilter * MakeAcceptFilter()
Local Search Filters.
Constraint * MakeNonOverlappingNonStrictBoxesConstraint(const std::vector< IntVar * > &x_vars, const std::vector< IntVar * > &y_vars, const std::vector< int64 > &x_size, const std::vector< int64 > &y_size)
bool Solve(DecisionBuilder *const db)
Constraint * MakeDistribute(const std::vector< IntVar * > &vars, int64 card_min, int64 card_max, int64 card_size)
Aggregated version of count with bounded cardinalities: forall j in 0 .
SearchMonitor * MakeSearchLog(int branch_period, IntVar *const var)
At each solution, this monitor also display the var value.
LocalSearchOperator * MakeOperator(const std::vector< IntVar * > &vars, const std::vector< IntVar * > &secondary_vars, LocalSearchOperators op)
IntExpr * MakeElement(const std::vector< IntVar * > &vars, IntVar *const index)
vars[expr]
LocalSearchOperator * MakeRandomLnsOperator(const std::vector< IntVar * > &vars, int number_of_variables)
Creates a large neighborhood search operator which creates fragments (set of relaxed variables) with ...
bool Solve(DecisionBuilder *const db, SearchMonitor *const m1)
DecisionBuilder * Compose(DecisionBuilder *const db1, DecisionBuilder *const db2, DecisionBuilder *const db3)
friend class LocalSearchProfiler
Definition: constraint_solver.h:2952
Constraint * MakeIsLessCt(IntExpr *const left, IntExpr *const right, IntVar *const b)
b == (left < right)
Decision * MakeVariableLessOrEqualValue(IntVar *const var, int64 value)
DisjunctiveConstraint * MakeDisjunctiveConstraint(const std::vector< IntervalVar * > &intervals, const std::string &name)
This constraint forces all interval vars into an non-overlapping sequence.
Constraint * MakeGreater(IntExpr *const expr, int value)
expr > value
DecisionBuilder * MakePhase(const std::vector< IntVar * > &vars, IndexEvaluator1 var_evaluator, IndexEvaluator2 value_evaluator, IndexEvaluator1 tie_breaker)
void ShouldFail()
These methods are only useful for the SWIG wrappers, which need a way to externally cause the Solver ...
Definition: constraint_solver.h:2985
IntExpr * MakeSum(IntExpr *const expr, int64 value)
expr + value.
int SearchDepth() const
Gets the search depth of the current active search.
DecisionBuilder * MakeSolveOnce(DecisionBuilder *const db, SearchMonitor *const monitor1, SearchMonitor *const monitor2)
SolutionCollector * MakeBestValueSolutionCollector(bool maximize)
Collect the solution corresponding to the optimal value of the objective of 'assignment'; if 'assignm...
friend class FindOneNeighbor
Definition: constraint_solver.h:2945
Constraint * MakePathCumul(const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, const std::vector< IntVar * > &cumuls, IndexEvaluator2 transit_evaluator)
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + t...
IntVar * MakeIsMemberVar(IntExpr *const expr, const std::vector< int64 > &values)
Constraint * MakeTemporalDisjunction(IntervalVar *const t1, IntervalVar *const t2)
This constraint implements a temporal disjunction between two interval vars.
Constraint * MakeLessOrEqual(IntExpr *const expr, int value)
expr <= value
SearchMonitor * MakeSymmetryManager(SymmetryBreaker *const v1, SymmetryBreaker *const v2, SymmetryBreaker *const v3, SymmetryBreaker *const v4)
RegularLimit * MakeLimit(const RegularLimitParameters &proto)
Creates a search limit from its protobuf description.
void AddLocalSearchMonitor(LocalSearchMonitor *monitor)
Adds the local search monitor to the solver.
LocalSearchOperator * RandomConcatenateOperators(const std::vector< LocalSearchOperator * > &ops)
Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeig...
Constraint * MakeCumulative(const std::vector< IntervalVar * > &intervals, const std::vector< IntVar * > &demands, int64 capacity, const std::string &name)
This constraint enforces that, for any integer t, the sum of demands corresponding to an interval con...
IntVar * MakeIsEqualCstVar(IntExpr *const var, int64 value)
status var of (var == value)
SearchMonitor * MakeGuidedLocalSearch(bool maximize, IntVar *const objective, IndexEvaluator3 objective_function, int64 step, const std::vector< IntVar * > &vars, const std::vector< IntVar * > &secondary_vars, double penalty_factor)
Constraint * MakeScalProdLessOrEqual(const std::vector< IntVar * > &vars, const std::vector< int > &coefficients, int64 cst)
Constraint * MakeScalProdLessOrEqual(const std::vector< IntVar * > &vars, const std::vector< int64 > &coefficients, int64 cst)
Constraint * MakeNotMemberCt(IntExpr *const expr, const std::vector< int64 > &values)
expr not in set.
BinaryIntervalRelation
This enum is used in Solver::MakeIntervalVarRelation to specify the temporal relation between the two...
Definition: constraint_solver.h:627
@ ENDS_AFTER_END
t1 ends after t2 end, i.e. End(t1) >= End(t2) + delay.
Definition: constraint_solver.h:629
@ ENDS_AFTER_START
t1 ends after t2 start, i.e. End(t1) >= Start(t2) + delay.
Definition: constraint_solver.h:632
@ STARTS_AT_END
t1 starts at t2 end, i.e. Start(t1) == End(t2) + delay.
Definition: constraint_solver.h:647
@ ENDS_AT_START
t1 ends at t2 start, i.e. End(t1) == Start(t2) + delay.
Definition: constraint_solver.h:638
@ STARTS_AFTER_END
t1 starts after t2 end, i.e. Start(t1) >= End(t2) + delay.
Definition: constraint_solver.h:641
@ STARTS_AFTER_START
t1 starts after t2 start, i.e. Start(t1) >= Start(t2) + delay.
Definition: constraint_solver.h:644
@ STARTS_AT_START
t1 starts at t2 start, i.e. Start(t1) == Start(t2) + delay.
Definition: constraint_solver.h:650
Constraint * MakeMaxEquality(const std::vector< IntVar * > &vars, IntVar *const max_var)
LocalSearchOperators
This enum is used in Solver::MakeOperator to specify the neighborhood to create.
Definition: constraint_solver.h:434
@ RELOCATE
Relocate neighborhood with length of 1 (see OROPT comment).
Definition: constraint_solver.h:463
@ SWAPACTIVE
Operator which replaces an active node by an inactive one.
Definition: constraint_solver.h:513
@ MAKECHAININACTIVE
Operator which makes a "chain" of path nodes inactive.
Definition: constraint_solver.h:506
@ FULLPATHLNS
Operator which relaxes one entire path and all inactive nodes, thus defining num_paths neighbors.
Definition: constraint_solver.h:538
@ EXTENDEDSWAPACTIVE
Operator which makes an inactive node active and an active one inactive.
Definition: constraint_solver.h:525
@ PATHLNS
Operator which relaxes two sub-chains of three consecutive arcs each.
Definition: constraint_solver.h:534
@ UNACTIVELNS
Operator which relaxes all inactive nodes and one sub-chain of six consecutive arcs.
Definition: constraint_solver.h:543
@ DECREMENT
Operator which defines a neighborhood to decrement values.
Definition: constraint_solver.h:558
@ CROSS
Operator which cross exchanges the starting chains of 2 paths, including exchanging the whole paths.
Definition: constraint_solver.h:483
Constraint * MakeIsEqualCt(IntExpr *const v1, IntExpr *v2, IntVar *const b)
b == (v1 == v2)
LocalSearchPhaseParameters * MakeLocalSearchPhaseParameters(IntVar *objective, LocalSearchOperator *const ls_operator, DecisionBuilder *const sub_decision_builder)
Local Search Phase Parameters.
void PushState()
The PushState and PopState methods manipulates the states of the reversible objects.
bool IsLocalSearchProfilingEnabled() const
Returns whether we are profiling local search.
OptimizeVar * MakeWeightedOptimize(bool maximize, const std::vector< IntVar * > &sub_objectives, const std::vector< int64 > &weights, int64 step)
Creates a weighted objective with a given sense (true = maximization).
IntVarLocalSearchFilter * MakeSumObjectiveFilter(const std::vector< IntVar * > &vars, IndexEvaluator2 values, Solver::LocalSearchFilterBound filter_enum)
LocalSearchOperator * MakeNeighborhoodLimit(LocalSearchOperator *const op, int64 limit)
Creates a local search operator that wraps another local search operator and limits the number of nei...
IntExpr * MakeMax(IntExpr *const expr, int64 value)
std::max(expr, value)
Constraint * MakeIfThenElseCt(IntVar *const condition, IntExpr *const then_expr, IntExpr *const else_expr, IntVar *const target_var)
Special cases with arrays of size two.
Decision * MakeScheduleOrExpedite(IntervalVar *const var, int64 est, int64 *const marker)
Returns a decision that tries to schedule a task at a given time.
Demon * MakeConstraintInitialPropagateCallback(Constraint *const ct)
This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of ...
Constraint * MakeDistribute(const std::vector< IntVar * > &vars, const std::vector< int64 > &card_min, const std::vector< int64 > &card_max)
Aggregated version of count with bounded cardinalities: forall j in 0 .
Constraint * MakeScalProdEquality(const std::vector< IntVar * > &vars, const std::vector< int64 > &coefficients, IntVar *const target)
Constraint * MakeCumulative(const std::vector< IntervalVar * > &intervals, const std::vector< int > &demands, int64 capacity, const std::string &name)
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval c...
DecisionBuilder * MakeSolveOnce(DecisionBuilder *const db, SearchMonitor *const monitor1)
Constraint * MakeTrueConstraint()
This constraint always succeeds.
LocalSearchOperator * MakeOperator(const std::vector< IntVar * > &vars, const std::vector< IntVar * > &secondary_vars, IndexEvaluator3 evaluator, EvaluatorLocalSearchOperators op)
IntervalVar * MakeFixedDurationEndSyncedOnStartIntervalVar(IntervalVar *const interval_var, int64 duration, int64 offset)
Creates an interval var with a fixed duration whose end is synchronized with the start of another int...
DecisionBuilder * MakePhase(IntVar *const v0, IntVar *const v1, IntVar *const v2, IntVarStrategy var_str, IntValueStrategy val_str)
Demon * RegisterDemon(Demon *const demon)
Adds a new demon and wraps it inside a DemonProfiler if necessary.
bool Solve(DecisionBuilder *const db, SearchMonitor *const m1, SearchMonitor *const m2, SearchMonitor *const m3, SearchMonitor *const m4)
IntExpr * MakeModulo(IntExpr *const x, int64 mod)
Modulo expression x % mod (with the python convention for modulo).
SearchMonitor * MakeSearchLog(int branch_period, OptimizeVar *const opt_var)
OptimizeVar Search Logs At each solution, this monitor will also display the 'opt_var' value.
Search * ActiveSearch() const
Returns the active search, nullptr outside search.
IntVar * MakeIntVar(const std::vector< int64 > &values)
MakeIntVar will create a variable with the given sparse domain.
IntExpr * MakeConditionalExpression(IntVar *const condition, IntExpr *const expr, int64 unperformed_value)
Conditional Expr condition ? expr : unperformed_value.
IntVar * MakeIntVar(const std::vector< int > &values, const std::string &name)
MakeIntVar will create a variable with the given sparse domain.
Constraint * MakeElementEquality(const std::vector< int > &vals, IntVar *const index, IntVar *const target)
Constraint * MakeIsBetweenCt(IntExpr *const expr, int64 l, int64 u, IntVar *const b)
b == (l <= expr <= u)
IntervalVar * MakeIntervalRelaxedMax(IntervalVar *const interval_var)
Creates and returns an interval variable that wraps around the given one, relaxing the max start and ...
DecisionBuilder * MakePhase(const std::vector< IntVar * > &vars, IntVarStrategy var_str, IndexEvaluator2 value_evaluator, IndexEvaluator1 tie_breaker)
IntVar * MakeBoolVar(const std::string &name)
MakeBoolVar will create a variable with a {0, 1} domain.
Constraint * MakeDistribute(const std::vector< IntVar * > &vars, const std::vector< int64 > &values, const std::vector< IntVar * > &cards)
Aggregated version of count: |{i | v[i] == values[j]}| == cards[j].
RegularLimit * MakeBranchesLimit(int64 branches)
Creates a search limit that constrains the number of branches explored in the search tree.
ImprovementSearchLimit * MakeImprovementLimit(IntVar *objective_var, bool maximize, double objective_scaling_factor, double objective_offset, double improvement_rate_coefficient, int improvement_rate_solutions_distance)
Limits the search based on the improvements of 'objective_var'.
DecisionBuilder * Compose(const std::vector< DecisionBuilder * > &dbs)
Constraint * MakeNoCycle(const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, IndexFilter1 sink_handler, bool assume_paths)
Constraint * MakeGreater(IntExpr *const expr, int64 value)
expr > value
Constraint * MakeAtMost(std::vector< IntVar * > vars, int64 value, int64 max_count)
|{i | vars[i] == value}| <= max_count
IntExpr * MakeElement(IndexEvaluator1 values, IntVar *const index)
Function-based element.
void PopState()
static ConstraintSolverParameters DefaultSolverParameters()
Create a ConstraintSolverParameters proto with all the default values.
ModelVisitor * MakeVariableDegreeVisitor(absl::flat_hash_map< const IntVar *, int > *const map)
Compute the number of constraints a variable is attached to.
Constraint * MakeFalseConstraint(const std::string &explanation)
int64 accepted_neighbors() const
The number of accepted neighbors.
Definition: constraint_solver.h:1008
SearchMonitor * MakeConstantRestart(int frequency)
This search monitor will restart the search periodically after 'frequency' failures.
std::function< int64(int64, int64, int64)> IndexEvaluator3
Definition: constraint_solver.h:745
LocalSearchMonitor * GetLocalSearchMonitor() const
Returns the local search monitor.
int constraints() const
Counts the number of constraints that have been added to the solver before the search.
Definition: constraint_solver.h:2865
std::string SearchContext(const Search *search) const
DecisionBuilder * MakePhase(const std::vector< IntVar * > &vars, IndexEvaluator2 eval, EvaluatorStrategy str)
Returns a decision builder which assigns values to variables which minimize the values returned by th...
void MakeBoolVarArray(int var_count, std::vector< IntVar * > *vars)
This method will append the vector vars with 'var_count' boolean variables having no names.
Constraint * MakeSumEquality(const std::vector< IntVar * > &vars, int64 cst)
Constraint * MakeLexicalLessOrEqual(const std::vector< IntVar * > &left, const std::vector< IntVar * > &right)
Creates a constraint that enforces that left is lexicographically less than or equal to right.
void MakeFixedDurationIntervalVarArray(int count, int64 start_min, int64 start_max, int64 duration, bool optional, const std::string &name, std::vector< IntervalVar * > *const array)
This method fills the vector with 'count' interval variables built with the corresponding parameters.
EvaluatorStrategy
This enum is used by Solver::MakePhase to specify how to select variables and values during the searc...
Definition: constraint_solver.h:395
@ CHOOSE_STATIC_GLOBAL_BEST
Pairs are compared at the first call of the selector, and results are cached.
Definition: constraint_solver.h:400
@ CHOOSE_DYNAMIC_GLOBAL_BEST
Pairs are compared each time a variable is selected.
Definition: constraint_solver.h:406
void set_optimization_direction(OptimizationDirection direction)
Definition: constraint_solver.h:1021
IntExpr * MakeElement(IndexEvaluator2 values, IntVar *const index1, IntVar *const index2)
2D version of function-based element expression, values(expr1, expr2).
DecisionBuilder * MakeLocalSearchPhase(const std::vector< IntVar * > &vars, DecisionBuilder *const first_solution, LocalSearchPhaseParameters *const parameters)
PropagationMonitor * GetPropagationMonitor() const
Returns the propagation monitor.
IntExpr * MakeDifference(int64 value, IntExpr *const expr)
value - expr
Decision * MakeRankFirstInterval(SequenceVar *const sequence, int index)
Returns a decision that tries to rank first the ith interval var in the sequence variable.
Constraint * MakeNonOverlappingNonStrictBoxesConstraint(const std::vector< IntVar * > &x_vars, const std::vector< IntVar * > &y_vars, const std::vector< int > &x_size, const std::vector< int > &y_size)
IntExpr * MakeMax(const std::vector< IntVar * > &vars)
std::max(vars)
Constraint * MakeIsLessOrEqualCt(IntExpr *const left, IntExpr *const right, IntVar *const b)
b == (left <= right)
Constraint * MakeCumulative(const std::vector< IntervalVar * > &intervals, const std::vector< int > &demands, IntVar *const capacity, const std::string &name)
This constraint enforces that, for any integer t, the sum of the demands corresponding to an interval...
bool Solve(DecisionBuilder *const db, const std::vector< SearchMonitor * > &monitors)
Constraint * MakeDistribute(const std::vector< IntVar * > &vars, const std::vector< IntVar * > &cards)
Aggregated version of count: |{i | v[i] == j}| == cards[j].
SolutionPool * MakeDefaultSolutionPool()
Solution Pool.
void clear_fail_intercept()
Definition: constraint_solver.h:2878
IntVar * MakeIsMemberVar(IntExpr *const expr, const std::vector< int > &values)
Constraint * MakeIntervalVarRelationWithDelay(IntervalVar *const t1, BinaryIntervalRelation r, IntervalVar *const t2, int64 delay)
This method creates a relation between two interval vars.
Constraint * MakeScalProdGreaterOrEqual(const std::vector< IntVar * > &vars, const std::vector< int64 > &coeffs, int64 cst)
IntExpr * MakeDifference(IntExpr *const left, IntExpr *const right)
left - right
void NewSearch(DecisionBuilder *const db, SearchMonitor *const m1, SearchMonitor *const m2, SearchMonitor *const m3, SearchMonitor *const m4)
DecisionBuilder * Try(DecisionBuilder *const db1, DecisionBuilder *const db2, DecisionBuilder *const db3)
Constraint * MakeNotMemberCt(IntExpr *const expr, std::vector< int > starts, std::vector< int > ends)
expr should not be in the list of forbidden intervals [start[i]..end[i]].
IntVar * MakeIntVar(const std::vector< int64 > &values, const std::string &name)
MakeIntVar will create a variable with the given sparse domain.
void MakeIntVarArray(int var_count, int64 vmin, int64 vmax, const std::string &name, std::vector< IntVar * > *vars)
This method will append the vector vars with 'var_count' variables having bounds vmin and vmax and ha...
Constraint * MakeDistribute(const std::vector< IntVar * > &vars, const std::vector< int > &card_min, const std::vector< int > &card_max)
Aggregated version of count with bounded cardinalities: forall j in 0 .
Assignment * MakeAssignment(const Assignment *const a)
This method creates an assignment which is a copy of 'a'.
RegularLimitParameters MakeDefaultRegularLimitParameters() const
Creates a regular limit proto containing default values.
RegularLimit * MakeTimeLimit(absl::Duration time)
Creates a search limit that constrains the running time.
Decision * MakeVariableGreaterOrEqualValue(IntVar *const var, int64 value)
IntVar * MakeBoolVar()
MakeBoolVar will create a variable with a {0, 1} domain.
DecisionBuilder * MakePhase(IntVar *const v0, IntVarStrategy var_str, IntValueStrategy val_str)
Shortcuts for small arrays.
DecisionBuilder * MakeNestedOptimize(DecisionBuilder *const db, Assignment *const solution, bool maximize, int64 step, const std::vector< SearchMonitor * > &monitors)
bool UseFastLocalSearch() const
Returns true if fast local search is enabled.
Definition: constraint_solver.h:2888
bool InstrumentsVariables() const
Returns whether we are tracing variables.
IntExpr * MakeMax(IntExpr *const expr, int value)
std::max(expr, value)
Constraint * MakeEquality(IntExpr *const expr, int64 value)
expr == value
Decision * MakeScheduleOrPostpone(IntervalVar *const var, int64 est, int64 *const marker)
Returns a decision that tries to schedule a task at a given time.
SearchMonitor * MakeSearchTrace(const std::string &prefix)
Creates a search monitor that will trace precisely the behavior of the search.
LocalSearchOperator * MakeRandomLnsOperator(const std::vector< IntVar * > &vars, int number_of_variables, int32 seed)
IntExpr * MakeMin(IntExpr *const expr, int value)
std::min(expr, value)
IntExpr * MakeDiv(IntExpr *const expr, int64 value)
expr / value (integer division)
SearchMonitor * MakeGuidedLocalSearch(bool maximize, IntVar *const objective, IndexEvaluator2 objective_function, int64 step, const std::vector< IntVar * > &vars, double penalty_factor)
Creates a Guided Local Search monitor.
int64 filtered_neighbors() const
The number of filtered neighbors (neighbors accepted by filters).
Definition: constraint_solver.h:1005
Constraint * MakeNonEquality(IntExpr *const left, IntExpr *const right)
left != right
IntVar * MakeIsLessVar(IntExpr *const left, IntExpr *const right)
status var of (left < right)
Constraint * MakeGreaterOrEqual(IntExpr *const expr, int64 value)
expr >= value
LocalSearchOperator * MakeOperator(const std::vector< IntVar * > &vars, LocalSearchOperators op)
Local Search Operators.
std::string LocalSearchProfile() const
Returns local search profiling information in a human readable format.
void Accept(ModelVisitor *const visitor) const
Accepts the given model visitor.
int SearchLeftDepth() const
Gets the search left depth of the current active search.
Constraint * MakeNonEquality(IntExpr *const expr, int64 value)
expr != value
void AddBacktrackAction(Action a, bool fast)
When SaveValue() is not the best way to go, one can create a reversible action that will be called up...
IntervalVar * MakeFixedDurationIntervalVar(IntVar *const start_variable, int64 duration, const std::string &name)
Creates a performed interval var with a fixed duration.
Constraint * MakeTemporalDisjunction(IntervalVar *const t1, IntervalVar *const t2, IntVar *const alt)
This constraint implements a temporal disjunction between two interval vars t1 and t2.
void MakeIntervalVarArray(int count, int64 start_min, int64 start_max, int64 duration_min, int64 duration_max, int64 end_min, int64 end_max, bool optional, const std::string &name, std::vector< IntervalVar * > *const array)
This method fills the vector with 'count' interval var built with the corresponding parameters.
int TopProgressPercent()
Returns a percentage representing the propress of the search before reaching the limits of the top-le...
OptimizeVar * MakeWeightedMinimize(const std::vector< IntVar * > &sub_objectives, const std::vector< int > &weights, int64 step)
Creates a minimization weighted objective.
Constraint * MakeTransitionConstraint(const std::vector< IntVar * > &vars, const IntTupleSet &transition_table, int64 initial_state, const std::vector< int > &final_states)
This constraint create a finite automaton that will check the sequence of variables vars.
IntVar * MakeIsBetweenVar(IntExpr *const v, int64 l, int64 u)
bool CurrentlyInSolve() const
Returns true whether the current search has been created using a Solve() call instead of a NewSearch ...
Decision * balancing_decision() const
Definition: constraint_solver.h:2870
LocalSearchOperator * ConcatenateOperators(const std::vector< LocalSearchOperator * > &ops, std::function< int64(int, int)> evaluator)
DecisionBuilder * Try(DecisionBuilder *const db1, DecisionBuilder *const db2, DecisionBuilder *const db3, DecisionBuilder *const db4)
IntervalVar * MakeFixedDurationIntervalVar(int64 start_min, int64 start_max, int64 duration, bool optional, const std::string &name)
Creates an interval var with a fixed duration.
Constraint * MakeIsMemberCt(IntExpr *const expr, const std::vector< int64 > &values, IntVar *const boolvar)
boolvar == (expr in set)
IntVarStrategy
This enum describes the strategy used to select the next branching variable at each node during the s...
Definition: constraint_solver.h:274
@ CHOOSE_RANDOM
Randomly select one of the remaining unbound variables.
Definition: constraint_solver.h:287
@ CHOOSE_MIN_SIZE
Among unbound variables, select the variable with the smallest size.
Definition: constraint_solver.h:336
@ CHOOSE_PATH
Selects the next unbound variable on a path, the path being defined by the variables: var[i] correspo...
Definition: constraint_solver.h:349
@ CHOOSE_HIGHEST_MAX
Among unbound variables, select the variable with the highest maximal value.
Definition: constraint_solver.h:331
@ CHOOSE_MIN_SIZE_LOWEST_MIN
Among unbound variables, select the variable with the smallest size, i.e., the smallest number of pos...
Definition: constraint_solver.h:295
@ CHOOSE_MIN_SIZE_HIGHEST_MAX
Among unbound variables, select the variable with the smallest size, i.e., the smallest number of pos...
Definition: constraint_solver.h:319
@ CHOOSE_MAX_REGRET_ON_MIN
Among unbound variables, select the variable with the largest gap between the first and the second va...
Definition: constraint_solver.h:345
@ CHOOSE_MIN_SIZE_HIGHEST_MIN
Among unbound variables, select the variable with the smallest size, i.e., the smallest number of pos...
Definition: constraint_solver.h:303
@ CHOOSE_MAX_SIZE
Among unbound variables, select the variable with the highest size.
Definition: constraint_solver.h:341
@ CHOOSE_MIN_SIZE_LOWEST_MAX
Among unbound variables, select the variable with the smallest size, i.e., the smallest number of pos...
Definition: constraint_solver.h:311
@ CHOOSE_LOWEST_MIN
Among unbound variables, select the variable with the smallest minimal value.
Definition: constraint_solver.h:325
OptimizeVar * MakeWeightedOptimize(bool maximize, const std::vector< IntVar * > &sub_objectives, const std::vector< int > &weights, int64 step)
Creates a weighted objective with a given sense (true = maximization).
DecisionBuilder * MakePhase(const std::vector< IntVar * > &vars, IntVarStrategy var_str, IntValueStrategy val_str)
Phases on IntVar arrays.
bool NextSolution()
@ CHOOSE_MIN_SLACK_RANK_FORWARD
Definition: constraint_solver.h:413
@ CHOOSE_RANDOM_RANK_FORWARD
Definition: constraint_solver.h:414
void MakeIntVarArray(int var_count, int64 vmin, int64 vmax, std::vector< IntVar * > *vars)
This method will append the vector vars with 'var_count' variables having bounds vmin and vmax and ha...
std::function< int64(int64, int64)> IndexEvaluator2
Definition: constraint_solver.h:744
IntVar * MakeIntVar(int64 min, int64 max)
MakeIntVar will create the best range based int var for the bounds given.
IntExpr * MakeMin(IntExpr *const left, IntExpr *const right)
std::min (left, right)
void NewSearch(DecisionBuilder *const db, SearchMonitor *const m1, SearchMonitor *const m2, SearchMonitor *const m3)
Constraint * MakeInversePermutationConstraint(const std::vector< IntVar * > &left, const std::vector< IntVar * > &right)
Creates a constraint that enforces that 'left' and 'right' both represent permutations of [0....
bool Solve(DecisionBuilder *const db, SearchMonitor *const m1, SearchMonitor *const m2, SearchMonitor *const m3)
IntervalVar * MakeFixedDurationStartSyncedOnEndIntervalVar(IntervalVar *const interval_var, int64 duration, int64 offset)
Creates an interval var with a fixed duration whose start is synchronized with the end of another int...
DecisionBuilder * MakeNestedOptimize(DecisionBuilder *const db, Assignment *const solution, bool maximize, int64 step)
NestedOptimize will collapse a search tree described by a decision builder 'db' and a set of monitors...
LocalSearchPhaseParameters * MakeLocalSearchPhaseParameters(IntVar *objective, SolutionPool *const pool, LocalSearchOperator *const ls_operator, DecisionBuilder *const sub_decision_builder, RegularLimit *const limit)
Constraint * MakeNonOverlappingBoxesConstraint(const std::vector< IntVar * > &x_vars, const std::vector< IntVar * > &y_vars, const std::vector< int > &x_size, const std::vector< int > &y_size)
DecisionBuilder * MakePhase(const std::vector< IntVar * > &vars, IndexEvaluator1 var_evaluator, IntValueStrategy val_str)
DecisionBuilder * MakePhase(const std::vector< IntVar * > &vars, IndexEvaluator2 eval, IndexEvaluator1 tie_breaker, EvaluatorStrategy str)
Returns a decision builder which assigns values to variables which minimize the values returned by th...
Constraint * MakeCount(const std::vector< IntVar * > &vars, int64 value, int64 max_count)
|{i | vars[i] == value}| == max_count
Decision * MakeRankLastInterval(SequenceVar *const sequence, int index)
Returns a decision that tries to rank last the ith interval var in the sequence variable.
Constraint * MakeAllDifferent(const std::vector< IntVar * > &vars)
All variables are pairwise different.
Constraint * MakeSortingConstraint(const std::vector< IntVar * > &vars, const std::vector< IntVar * > &sorted)
Creates a constraint binding the arrays of variables "vars" and "sorted_vars": sorted_vars[0] must be...
DecisionBuilder * MakeSolveOnce(DecisionBuilder *const db, const std::vector< SearchMonitor * > &monitors)
Constraint * MakeNotMemberCt(IntExpr *const expr, std::vector< int64 > starts, std::vector< int64 > ends)
expr should not be in the list of forbidden intervals [start[i]..end[i]].
DecisionBuilder * MakeSolveOnce(DecisionBuilder *const db, SearchMonitor *const monitor1, SearchMonitor *const monitor2, SearchMonitor *const monitor3)
DecisionBuilder * MakeLocalSearchPhase(Assignment *const assignment, LocalSearchPhaseParameters *const parameters)
Local Search decision builders factories.
DecisionBuilder * MakePhase(const std::vector< SequenceVar * > &sequences, SequenceStrategy str)
IntExpr * MakeSemiContinuousExpr(IntExpr *const expr, int64 fixed_charge, int64 step)
Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) a >= 0 and b >= 0.
IntExpr * MakeMax(IntExpr *const left, IntExpr *const right)
std::max(left, right)
Demon * MakeDelayedConstraintInitialPropagateCallback(Constraint *const ct)
This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of ...
IntExpr * MakeScalProd(const std::vector< IntVar * > &vars, const std::vector< int64 > &coefs)
scalar product
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)
This constraint states that all the boxes must not overlap.
RegularLimit * MakeLimit(int64 time, int64 branches, int64 failures, int64 solutions, bool smart_time_check=false, bool cumulative=false)
bool NameAllVariables() const
Returns whether all variables should be named.
DecisionBuilder * MakeSolveOnce(DecisionBuilder *const db, SearchMonitor *const monitor1, SearchMonitor *const monitor2, SearchMonitor *const monitor3, SearchMonitor *const monitor4)
Constraint * MakeGreaterOrEqual(IntExpr *const expr, int value)
expr >= value
DecisionBuilder * MakeNestedOptimize(DecisionBuilder *const db, Assignment *const solution, bool maximize, int64 step, SearchMonitor *const monitor1, SearchMonitor *const monitor2)
int64 unchecked_solutions() const
The number of unchecked solutions found by local search.
Constraint * MakeEquality(IntervalVar *const var1, IntervalVar *const var2)
This constraints states that the two interval variables are equal.
IntExpr * MakeSum(IntExpr *const left, IntExpr *const right)
left + right.
IntExpr * CastExpression(const IntVar *const var) const
!defined(SWIG)
Constraint * MakeScalProdGreaterOrEqual(const std::vector< IntVar * > &vars, const std::vector< int > &coeffs, int64 cst)
SearchMonitor * MakeEnterSearchCallback(std::function< void()> callback)
--— Callback-based search monitors --—
DecisionBuilder * MakePhase(IntVar *const v0, IntVar *const v1, IntVar *const v2, IntVar *const v3, IntVarStrategy var_str, IntValueStrategy val_str)
IntExpr * MakeIndexExpression(const std::vector< IntVar * > &vars, int64 value)
Returns the expression expr such that vars[expr] == value.
Constraint * MakeIsDifferentCstCt(IntExpr *const var, int64 value, IntVar *const boolvar)
boolvar == (var != value)
void SetBranchSelector(BranchSelector bs)
Sets the given branch selector on the current active search.
SearchMonitor * MakeTabuSearch(bool maximize, IntVar *const v, int64 step, const std::vector< IntVar * > &vars, int64 keep_tenure, int64 forbid_tenure, double tabu_factor)
MetaHeuristics which try to get the search out of local optima.
friend class PropagationBaseObject
Definition: constraint_solver.h:2947
SearchMonitor * MakeSymmetryManager(SymmetryBreaker *const v1)
IntervalVar * MakeFixedDurationStartSyncedOnStartIntervalVar(IntervalVar *const interval_var, int64 duration, int64 offset)
Creates an interval var with a fixed duration whose start is synchronized with the start of another i...
OptimizeVar * MakeWeightedMinimize(const std::vector< IntVar * > &sub_objectives, const std::vector< int64 > &weights, int64 step)
Creates a minimization weighted objective.
SolutionCollector * MakeFirstSolutionCollector(const Assignment *const assignment)
Collect the first solution of the search.
int64 branches() const
The number of branches explored since the creation of the solver.
Definition: constraint_solver.h:987
std::function< int64(Solver *solver, const std::vector< IntVar * > &vars, int64 first_unbound, int64 last_unbound)> VariableIndexSelector
Definition: constraint_solver.h:753
IntVar ** MakeIntVarArray(int var_count, int64 vmin, int64 vmax, const std::string &name)
Same but allocates an array and returns it.
IntervalVar * MakeMirrorInterval(IntervalVar *const interval_var)
Creates an interval var that is the mirror image of the given one, that is, the interval var obtained...
uint64 stamp() const
The stamp indicates how many moves in the search tree we have performed.
LocalSearchOperator * MultiArmedBanditConcatenateOperators(const std::vector< LocalSearchOperator * > &ops, double memory_coefficient, double exploration_coefficient, bool maximize)
Creates a local search operator which concatenates a vector of operators.
Constraint * MakeSumLessOrEqual(const std::vector< IntVar * > &vars, int64 cst)
Variation on arrays.
Constraint * MakeIsGreaterCt(IntExpr *const left, IntExpr *const right, IntVar *const b)
b == (left > right)
Assignment * MakeAssignment()
This method creates an empty assignment.
ModelVisitor * MakePrintModelVisitor()
Prints the model.
std::function< void()> Closure
Definition: constraint_solver.h:760
Constraint * MakePathCumul(const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, const std::vector< IntVar * > &cumuls, const std::vector< IntVar * > &transits)
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + t...
IntVar * MakeIntVar(int64 min, int64 max, const std::string &name)
MakeIntVar will create the best range based int var for the bounds given.
std::function< void(Solver *)> Action
Definition: constraint_solver.h:759
IntExpr * MakeElement(Int64ToIntVar vars, int64 range_start, int64 range_end, IntVar *argument)
vars(argument)
SolutionCollector * MakeFirstSolutionCollector()
Collect the first solution of the search.
T * RevAllocArray(T *object)
Like RevAlloc() above, but for an array of objects: the array must have been allocated with the new[]...
Definition: constraint_solver.h:807
IntExpr * MakeMin(IntExpr *const expr, int64 value)
std::min(expr, value)
int32 Rand32(int32 size)
Returns a random value between 0 and 'size' - 1;.
Definition: constraint_solver.h:2834
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)
Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + t...
DecisionBuilder * MakePhase(const std::vector< IntVar * > &vars, IntVarStrategy var_str, IndexEvaluator2 value_evaluator)
Constraint * MakeIndexOfConstraint(const std::vector< IntVar * > &vars, IntVar *const index, int64 target)
This constraint is a special case of the element constraint with an array of integer variables,...
OptimizeVar * MakeWeightedMaximize(const std::vector< IntVar * > &sub_objectives, const std::vector< int > &weights, int64 step)
Creates a maximization weigthed objective.
DecisionBuilder * MakePhase(const std::vector< IntVar * > &vars, IndexEvaluator1 var_evaluator, IndexEvaluator2 value_evaluator)
void ExportProfilingOverview(const std::string &filename)
Exports the profiling information in a human readable overview.
SolutionCollector * MakeNBestValueSolutionCollector(int solution_count, bool maximize)
DecisionBuilder * Compose(DecisionBuilder *const db1, DecisionBuilder *const db2)
Creates a decision builder which sequentially composes decision builders.
std::function< IntVar *(int64)> Int64ToIntVar
Definition: constraint_solver.h:749
Constraint * MakeElementEquality(const std::vector< int64 > &vals, IntVar *const index, IntVar *const target)
Constraint * MakeIndexOfFirstMaxValueConstraint(IntVar *index, const std::vector< IntVar * > &vars)
Creates a constraint that binds the index variable to the index of the first variable with the maximu...
IntExpr * MakeConvexPiecewiseExpr(IntExpr *expr, int64 early_cost, int64 early_date, int64 late_date, int64 late_cost)
Convex piecewise function.
Solver(const std::string &name, const ConstraintSolverParameters ¶meters)
IntVar * MakeIsLessCstVar(IntExpr *const var, int64 value)
status var of (var < value)
SearchMonitor * MakeSearchLog(int branch_period, OptimizeVar *const opt_var, std::function< std::string()> display_callback)
Creates a search monitor that will also print the result of the display callback.
MarkerType
This enum is used internally in private methods Solver::PushState and Solver::PopState to tag states ...
Definition: constraint_solver.h:721
@ REVERSIBLE_ACTION
Definition: constraint_solver.h:721
SolutionCollector * MakeBestValueSolutionCollector(const Assignment *const assignment, bool maximize)
Collect the solution corresponding to the optimal value of the objective of 'assignment'; if 'assignm...
Constraint * MakeIsMemberCt(IntExpr *const expr, const std::vector< int > &values, IntVar *const boolvar)
IntVar * MakeIsGreaterCstVar(IntExpr *const var, int64 value)
status var of (var > value)
Constraint * MakeMinEquality(const std::vector< IntVar * > &vars, IntVar *const min_var)
void MakeFixedDurationIntervalVarArray(const std::vector< IntVar * > &start_variables, const std::vector< int > &durations, const std::string &name, std::vector< IntervalVar * > *const array)
This method fills the vector with interval variables built with the corresponding start variables.
Constraint * MakePathPrecedenceConstraint(std::vector< IntVar * > nexts, const std::vector< std::pair< int, int > > &precedences)
Contraint enforcing, for each pair (i,j) in precedences, i to be before j in paths defined by next va...
void AddCastConstraint(CastConstraint *const constraint, IntVar *const target_var, IntExpr *const expr)
Adds 'constraint' to the solver and marks it as a cast constraint, that is, a constraint created call...
IntervalVar * MakeIntervalVar(int64 start_min, int64 start_max, int64 duration_min, int64 duration_max, int64 end_min, int64 end_max, bool optional, const std::string &name)
Creates an interval var by specifying the bounds on start, duration, and end.
IntVar * MakeIsLessOrEqualCstVar(IntExpr *const var, int64 value)
status var of (var <= value)
OptimizeVar * MakeMinimize(IntVar *const v, int64 step)
Creates a minimization objective.
DecisionBuilder * MakeStoreAssignment(Assignment *assignment)
Returns a DecisionBuilder which stores an Assignment (calls void Assignment::Store())
Constraint * MakeIsLessOrEqualCstCt(IntExpr *const var, int64 value, IntVar *const boolvar)
boolvar == (var <= value)
std::function< DecisionModification()> BranchSelector
Definition: constraint_solver.h:757
DecisionBuilder * Compose(DecisionBuilder *const db1, DecisionBuilder *const db2, DecisionBuilder *const db3, DecisionBuilder *const db4)
bool InstrumentsDemons() const
Returns whether we are instrumenting demons.
Constraint * MakeCumulative(const std::vector< IntervalVar * > &intervals, const std::vector< int64 > &demands, IntVar *const capacity, const std::string &name)
This constraint forces that, for any integer t, the sum of the demands corresponding to an interval c...
std::function< int64(const IntVar *v, int64 id)> VariableValueSelector
Definition: constraint_solver.h:755
SearchMonitor * MakeExitSearchCallback(std::function< void()> callback)
bool SolveAndCommit(DecisionBuilder *const db, SearchMonitor *const m1)
DecisionBuilder * MakeDefaultPhase(const std::vector< IntVar * > &vars)
IntExpr * MakeProd(IntExpr *const left, IntExpr *const right)
left * right
DecisionBuilder * MakeDecisionBuilderFromAssignment(Assignment *const assignment, DecisionBuilder *const db, const std::vector< IntVar * > &vars)
Returns a decision builder for which the left-most leaf corresponds to assignment,...
void set_fail_intercept(std::function< void()> fail_intercept)
Internal.
Definition: constraint_solver.h:2874
DecisionBuilder * MakeRestoreAssignment(Assignment *assignment)
Returns a DecisionBuilder which restores an Assignment (calls void Assignment::Restore())
SearchMonitor * MakeSearchLog(SearchLogParameters parameters)
Constraint * MakeLessOrEqual(IntExpr *const expr, int64 value)
expr <= value
Decision * MakeFailDecision()
void Fail()
Abandon the current branch in the search tree. A backtrack will follow.
Constraint * MakeSumEquality(const std::vector< IntVar * > &vars, IntVar *const var)
Constraint * MakeGreaterOrEqual(IntExpr *const left, IntExpr *const right)
left >= right
IntVar * MakeIntVar(const std::vector< int > &values)
MakeIntVar will create a variable with the given sparse domain.
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].
OptimizeVar * MakeOptimize(bool maximize, IntVar *const v, int64 step)
Creates a objective with a given sense (true = maximization).
void MakeFixedDurationIntervalVarArray(const std::vector< IntVar * > &start_variables, int64 duration, const std::string &name, std::vector< IntervalVar * > *const array)
This method fills the vector with 'count' interval var built with the corresponding start variables.
void NewSearch(DecisionBuilder *const db, SearchMonitor *const m1, SearchMonitor *const m2)
LocalSearchOperator * ConcatenateOperators(const std::vector< LocalSearchOperator * > &ops, bool restart)
~Solver()
Constraint * MakeIsGreaterOrEqualCstCt(IntExpr *const var, int64 value, IntVar *const boolvar)
boolvar == (var >= value)
IntVar * MakeIsGreaterOrEqualVar(IntExpr *const left, IntExpr *const right)
status var of (left >= right)
Constraint * MakeIsGreaterOrEqualCt(IntExpr *const left, IntExpr *const right, IntVar *const b)
b == (left >= right)
DecisionBuilder * MakeLocalSearchPhase(const std::vector< SequenceVar * > &vars, DecisionBuilder *const first_solution, LocalSearchPhaseParameters *const parameters)
Constraint * MakeSumGreaterOrEqual(const std::vector< IntVar * > &vars, int64 cst)
Constraint * 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 ex...
T * RevAlloc(T *object)
Registers the given object as being reversible.
Definition: constraint_solver.h:796
void FinishCurrentSearch()
Tells the solver to kill or restart the current search.
bool IsProduct(IntExpr *const expr, IntExpr **inner_expr, int64 *coefficient)
Returns true if expr represents a product of a expr and a constant.
Constraint * MakeLess(IntExpr *const expr, int64 value)
expr < value
void NewSearch(DecisionBuilder *const db, const std::vector< SearchMonitor * > &monitors)
IntExpr * MakeMonotonicElement(IndexEvaluator1 values, bool increasing, IntVar *const index)
Function based element.
Constraint * MakeNoCycle(const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, IndexFilter1 sink_handler=nullptr)
Prevent cycles.
SearchMonitor * MakeSymmetryManager(SymmetryBreaker *const v1, SymmetryBreaker *const v2)
IntVar * MakeIntConst(int64 val, const std::string &name)
IntConst will create a constant expression.
SolutionCollector * MakeNBestValueSolutionCollector(const Assignment *const assignment, int solution_count, bool maximize)
Same as MakeBestValueSolutionCollector but collects the best solution_count solutions.
ModelVisitor * MakeStatisticsModelVisitor()
Displays some nice statistics on the model.
Constraint * MakeScalProdEquality(const std::vector< IntVar * > &vars, const std::vector< int > &coefficients, int64 cst)
IntVar * MakeIsLessOrEqualVar(IntExpr *const left, IntExpr *const right)
status var of (left <= right)
IntervalVar * RegisterIntervalVar(IntervalVar *const var)
Registers a new IntervalVar and wraps it inside a TraceIntervalVar if necessary.
EvaluatorLocalSearchOperators
This enum is used in Solver::MakeOperator associated with an evaluator to specify the neighborhood to...
Definition: constraint_solver.h:572
LocalSearchFilterBound
This enum is used in Solver::MakeLocalSearchObjectiveFilter.
Definition: constraint_solver.h:600
@ GE
Move is accepted when the current objective value >= objective.Min.
Definition: constraint_solver.h:602
@ LE
Move is accepted when the current objective value <= objective.Max.
Definition: constraint_solver.h:604
@ EQ
Move is accepted when the current objective value is in the interval objective.Min .
Definition: constraint_solver.h:607
Constraint * MakeDistribute(const std::vector< IntVar * > &vars, const std::vector< int > &values, const std::vector< int > &card_min, const std::vector< int > &card_max)
Aggregated version of count with bounded cardinalities: forall j in 0 .
Constraint * MakeScalProdEquality(const std::vector< IntVar * > &vars, const std::vector< int64 > &coefficients, int64 cst)
void MakeFixedDurationIntervalVarArray(const std::vector< IntVar * > &start_variables, const std::vector< int64 > &durations, const std::string &name, std::vector< IntervalVar * > *const array)
This method fills the vector with interval variables built with the corresponding start variables.
DecisionBuilder * MakeDefaultPhase(const std::vector< IntVar * > &vars, const DefaultPhaseParameters ¶meters)
OptimizationDirection optimization_direction() const
The direction of optimization, getter and setter.
Definition: constraint_solver.h:1018
A symmetry breaker is an object that will visit a decision and create the 'symmetrical' decision in r...
Definition: constraint_solveri.h:1994
ABSL_DECLARE_FLAG(int64, cp_random_seed)
Declaration of the core objects for the constraint solver.
The vehicle routing library lets one model and solve generic vehicle routing problems ranging from th...
Definition: constraint_solver.h:106
std::ostream & operator<<(std::ostream &out, const Solver *const s)
void SetAssignmentFromAssignment(Assignment *target_assignment, const std::vector< IntVar * > &target_vars, const Assignment *source_assignment, const std::vector< IntVar * > &source_vars)
NOLINT.
This struct holds all parameters for the default search.
Definition: constraint_solver.h:177
DefaultPhaseParameters()
int heuristic_num_failures_limit
The failure limit for each heuristic that we run.
Definition: constraint_solver.h:214
int initialization_splits
Maximum number of intervals that the initialization of impacts will scan per variable.
Definition: constraint_solver.h:201
DisplayLevel
Definition: constraint_solver.h:190
DecisionBuilder * decision_builder
When defined, this overrides the default impact based decision builder.
Definition: constraint_solver.h:231
DisplayLevel display_level
This represents the amount of information displayed by the default search.
Definition: constraint_solver.h:225
ValueSelection value_selection_schema
This parameter describes which value to select for a given var.
Definition: constraint_solver.h:197
VariableSelection
Definition: constraint_solver.h:179
@ CHOOSE_MAX_VALUE_IMPACT
Definition: constraint_solver.h:182
@ CHOOSE_MAX_SUM_IMPACT
Definition: constraint_solver.h:180
@ CHOOSE_MAX_AVERAGE_IMPACT
Definition: constraint_solver.h:181
VariableSelection var_selection_schema
This parameter describes how the next variable to instantiate will be chosen.
Definition: constraint_solver.h:194
ValueSelection
Definition: constraint_solver.h:185
@ SELECT_MAX_IMPACT
Definition: constraint_solver.h:187
@ SELECT_MIN_IMPACT
Definition: constraint_solver.h:186
bool persistent_impact
Whether to keep the impact from the first search for other searches, or to recompute the impact for e...
Definition: constraint_solver.h:218
bool use_last_conflict
Should we use last conflict method. The default is false.
Definition: constraint_solver.h:228
int heuristic_period
The distance in nodes between each run of the heuristics.
Definition: constraint_solver.h:211
int random_seed
Seed used to initialize the random part in some heuristics.
Definition: constraint_solver.h:221
bool run_all_heuristics
The default phase will run heuristics periodically.
Definition: constraint_solver.h:206
static Iterator Begin(IntVarIterator *it)
These are the only way to construct an Iterator.
Definition: constraint_solver.h:3959
bool operator!=(const Iterator &other) const
Definition: constraint_solver.h:3975
static Iterator End(IntVarIterator *it)
Definition: constraint_solver.h:3962
int64 operator*() const
Definition: constraint_solver.h:3966
Iterator & operator++()
Definition: constraint_solver.h:3970
int64 time
Definition: constraint_solver.h:4169
int64 objective_value
Definition: constraint_solver.h:4172
bool operator<(const SolutionData &other) const
Definition: constraint_solver.h:4173
Assignment * solution
Definition: constraint_solver.h:4168
int64 branches
Definition: constraint_solver.h:4170
int64 failures
Definition: constraint_solver.h:4171
Holds semantic information stating that the 'expression' has been cast into 'variable' using the Var(...
Definition: constraint_solver.h:259
IntegerCastInfo(IntVar *const v, IntExpr *const e, Constraint *const c)
Definition: constraint_solver.h:262
IntExpr * expression
Definition: constraint_solver.h:265
IntegerCastInfo()
Definition: constraint_solver.h:260
IntVar * variable
Definition: constraint_solver.h:264
Constraint * maintainer
Definition: constraint_solver.h:266
Creates a search monitor from logging parameters.
Definition: constraint_solver.h:2297
int branch_period
SearchMonitors will display a periodic search log every branch_period branches explored.
Definition: constraint_solver.h:2300
double offset
Definition: constraint_solver.h:2309
OptimizeVar * objective
SearchMonitors will display values of objective or variable (both cannot be used together).
Definition: constraint_solver.h:2303
std::function< std::string()> display_callback
SearchMonitors will display the result of display_callback at each new solution found and when the se...
Definition: constraint_solver.h:2313
double scaling_factor
When displayed, objective or var values will be scaled and offset by the given values in the followin...
Definition: constraint_solver.h:2308
bool display_on_new_solutions_only
To be used to protect from cases where display_callback assumes variables are instantiated,...
Definition: constraint_solver.h:2316
IntVar * variable
Definition: constraint_solver.h:2304