C++ Reference

C++ Reference: CP-SAT

cp_model.h
Go to the documentation of this file.
1// Copyright 2010-2018 Google LLC
2// Licensed under the Apache License, Version 2.0 (the "License");
3// you may not use this file except in compliance with the License.
4// You may obtain a copy of the License at
5//
6// http://www.apache.org/licenses/LICENSE-2.0
7//
8// Unless required by applicable law or agreed to in writing, software
9// distributed under the License is distributed on an "AS IS" BASIS,
10// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11// See the License for the specific language governing permissions and
12// limitations under the License.
13
38#ifndef OR_TOOLS_SAT_CP_MODEL_H_
39#define OR_TOOLS_SAT_CP_MODEL_H_
40
41#include <string>
42
43#include "absl/container/flat_hash_map.h"
44#include "absl/types/span.h"
45#include "ortools/sat/cp_model.pb.h"
47#include "ortools/sat/cp_model_utils.h"
48#include "ortools/sat/model.h"
49#include "ortools/sat/sat_parameters.pb.h"
51
53namespace sat {
54
55class CpModelBuilder;
56class LinearExpr;
57class IntVar;
58
67class BoolVar {
68 public:
70
72 BoolVar WithName(const std::string& name);
73
75 const std::string& Name() const { return Proto().name(); }
76
78 BoolVar Not() const { return BoolVar(NegatedRef(index_), cp_model_); }
79
81 bool operator==(const BoolVar& other) const {
82 return other.cp_model_ == cp_model_ && other.index_ == index_;
83 }
84
86 bool operator!=(const BoolVar& other) const {
87 return other.cp_model_ != cp_model_ || other.index_ != index_;
88 }
89
91 std::string DebugString() const;
92
94 const IntegerVariableProto& Proto() const {
95 return cp_model_->variables(index_);
96 }
97
99 IntegerVariableProto* MutableProto() const {
100 return cp_model_->mutable_variables(index_);
101 }
102
109 int index() const { return index_; }
110
111 private:
112 friend class CircuitConstraint;
113 friend class Constraint;
114 friend class CpModelBuilder;
115 friend class IntVar;
116 friend class IntervalVar;
118 friend class LinearExpr;
120 friend bool SolutionBooleanValue(const CpSolverResponse& r, BoolVar x);
121
122 BoolVar(int index, CpModelProto* cp_model);
123
124 CpModelProto* cp_model_ = nullptr;
125 int index_ = kint32min;
126};
127
128std::ostream& operator<<(std::ostream& os, const BoolVar& var);
129
135
146class IntVar {
147 public:
149
151 IntVar(const BoolVar& var); // NOLINT(runtime/explicit)
152
156
158 IntVar WithName(const std::string& name);
159
161 const std::string& Name() const { return Proto().name(); }
162
165 LinearExpr AddConstant(int64 value) const;
166
168 bool operator==(const IntVar& other) const {
169 return other.cp_model_ == cp_model_ && other.index_ == index_;
170 }
171
173 bool operator!=(const IntVar& other) const {
174 return other.cp_model_ != cp_model_ || other.index_ != index_;
175 }
176
178 std::string DebugString() const;
179
181 const IntegerVariableProto& Proto() const {
182 return cp_model_->variables(index_);
183 }
184
186 IntegerVariableProto* MutableProto() const {
187 return cp_model_->mutable_variables(index_);
188 }
189
191 int index() const { return index_; }
192
193 private:
194 friend class BoolVar;
195 friend class CpModelBuilder;
197 friend class LinearExpr;
198 friend class IntervalVar;
200 friend int64 SolutionIntegerValue(const CpSolverResponse& r,
201 const LinearExpr& expr);
202 friend int64 SolutionIntegerMin(const CpSolverResponse& r, IntVar x);
203 friend int64 SolutionIntegerMax(const CpSolverResponse& r, IntVar x);
204
205 IntVar(int index, CpModelProto* cp_model);
206
207 CpModelProto* cp_model_ = nullptr;
208 int index_ = kint32min;
209};
210
211std::ostream& operator<<(std::ostream& os, const IntVar& var);
212
249 public:
251
257 LinearExpr(BoolVar var); // NOLINT(runtime/explicit)
258
260 LinearExpr(IntVar var); // NOLINT(runtime/explicit)
261
263 LinearExpr(int64 constant); // NOLINT(runtime/explicit)
264
266 LinearExpr& AddConstant(int64 value);
267
269 void AddVar(IntVar var);
270
272 void AddTerm(IntVar var, int64 coeff);
273
275 static LinearExpr Sum(absl::Span<const IntVar> vars);
276
278 static LinearExpr ScalProd(absl::Span<const IntVar> vars,
279 absl::Span<const int64> coeffs);
280
282 static LinearExpr BooleanSum(absl::Span<const BoolVar> vars);
283
285 static LinearExpr BooleanScalProd(absl::Span<const BoolVar> vars,
286 absl::Span<const int64> coeffs);
288 static LinearExpr Term(IntVar var, int64 coefficient);
289
291 const std::vector<IntVar>& variables() const { return variables_; }
292
294 const std::vector<int64>& coefficients() const { return coefficients_; }
295
297 int64 constant() const { return constant_; }
298
299 // TODO(user): LinearExpr.DebugString() and operator<<.
300
301 private:
302 std::vector<IntVar> variables_;
303 std::vector<int64> coefficients_;
304 int64 constant_ = 0;
305};
306
327 public:
330
332 IntervalVar WithName(const std::string& name);
333
335 std::string Name() const;
336
339
342
344 IntVar EndVar() const;
345
352
354 bool operator==(const IntervalVar& other) const {
355 return other.cp_model_ == cp_model_ && other.index_ == index_;
356 }
357
359 bool operator!=(const IntervalVar& other) const {
360 return other.cp_model_ != cp_model_ || other.index_ != index_;
361 }
362
364 std::string DebugString() const;
365
367 const IntervalConstraintProto& Proto() const {
368 return cp_model_->constraints(index_).interval();
369 }
370
372 IntervalConstraintProto* MutableProto() const {
373 return cp_model_->mutable_constraints(index_)->mutable_interval();
374 }
375
377 int index() const { return index_; }
378
379 private:
380 friend class CpModelBuilder;
383 friend std::ostream& operator<<(std::ostream& os, const IntervalVar& var);
384
385 IntervalVar(int index, CpModelProto* cp_model);
386
387 CpModelProto* cp_model_ = nullptr;
388 int index_ = kint32min;
389};
390
391std::ostream& operator<<(std::ostream& os, const IntervalVar& var);
392
403 public:
421 Constraint OnlyEnforceIf(absl::Span<const BoolVar> literals);
422
425
427 Constraint WithName(const std::string& name);
428
430 const std::string& Name() const;
431
433 const ConstraintProto& Proto() const { return *proto_; }
434
436 ConstraintProto* MutableProto() const { return proto_; }
437
438 protected:
439 friend class CpModelBuilder;
440
441 explicit Constraint(ConstraintProto* proto);
442
443 ConstraintProto* proto_ = nullptr;
444};
445
452 public:
460 void AddArc(int tail, int head, BoolVar literal);
461
462 private:
463 friend class CpModelBuilder;
464
466};
467
475 public:
483 void AddArc(int tail, int head, BoolVar literal);
484
485 private:
486 friend class CpModelBuilder;
487
489};
490
498 public:
500 void AddTuple(absl::Span<const int64> tuple);
501
502 private:
503 friend class CpModelBuilder;
504
506};
507
515 public:
521 void AddEvent(IntVar time, int64 demand);
522
529 void AddOptionalEvent(IntVar time, int64 demand, BoolVar is_active);
530
531 private:
532 friend class CpModelBuilder;
533
534 ReservoirConstraint(ConstraintProto* proto, CpModelBuilder* builder);
535
536 CpModelBuilder* builder_;
537};
538
546 public:
548 void AddTransition(int tail, int head, int64 transition_label);
549
550 private:
551 friend class CpModelBuilder;
552
554};
555
563 public:
565 void AddRectangle(IntervalVar x_coordinate, IntervalVar y_coordinate);
566
567 private:
568 friend class CpModelBuilder;
569
571};
572
580 public:
582 void AddDemand(IntervalVar interval, IntVar demand);
583
584 private:
585 friend class CpModelBuilder;
586
587 CumulativeConstraint(ConstraintProto* proto, CpModelBuilder* builder);
588
589 CpModelBuilder* builder_;
590};
591
600 public:
602 IntVar NewIntVar(const Domain& domain);
603
606
608 IntVar NewConstant(int64 value);
609
612
615
618
621 BoolVar presence);
622
624 Constraint AddBoolOr(absl::Span<const BoolVar> literals);
625
627 Constraint AddBoolAnd(absl::Span<const BoolVar> literals);
628
630 Constraint AddBoolXor(absl::Span<const BoolVar> literals);
631
634 return AddBoolOr({a.Not(), b});
635 }
636
638 Constraint AddEquality(const LinearExpr& left, const LinearExpr& right);
639
642
644 Constraint AddGreaterThan(const LinearExpr& left, const LinearExpr& right);
645
647 Constraint AddLessOrEqual(const LinearExpr& left, const LinearExpr& right);
648
650 Constraint AddLessThan(const LinearExpr& left, const LinearExpr& right);
651
653 Constraint AddLinearConstraint(const LinearExpr& expr, const Domain& domain);
654
656 Constraint AddNotEqual(const LinearExpr& left, const LinearExpr& right);
657
659 Constraint AddAllDifferent(absl::Span<const IntVar> vars);
660
663 absl::Span<const IntVar> variables,
664 IntVar target);
665
667 Constraint AddElement(IntVar index, absl::Span<const int64> values,
668 IntVar target);
669
687
702
714 TableConstraint AddAllowedAssignments(absl::Span<const IntVar> vars);
715
726 TableConstraint AddForbiddenAssignments(absl::Span<const IntVar> vars);
727
733 Constraint AddInverseConstraint(absl::Span<const IntVar> variables,
734 absl::Span<const IntVar> inverse_variables);
735
754 ReservoirConstraint AddReservoirConstraint(int64 min_level, int64 max_level);
755
784 absl::Span<const IntVar> transition_variables, int starting_state,
785 absl::Span<const int> final_states);
786
788 Constraint AddMinEquality(IntVar target, absl::Span<const IntVar> vars);
789
792 absl::Span<const LinearExpr> exprs);
793
795 Constraint AddMaxEquality(IntVar target, absl::Span<const IntVar> vars);
796
799 absl::Span<const LinearExpr> exprs);
800
803 IntVar denominator);
804
807
810
812 Constraint AddProductEquality(IntVar target, absl::Span<const IntVar> vars);
813
818 Constraint AddNoOverlap(absl::Span<const IntervalVar> vars);
819
824
831
833 void Minimize(const LinearExpr& expr);
834
836 void Maximize(const LinearExpr& expr);
837
845 void ScaleObjectiveBy(double scaling);
846
849 absl::Span<const IntVar> variables,
850 DecisionStrategyProto::VariableSelectionStrategy var_strategy,
851 DecisionStrategyProto::DomainReductionStrategy domain_strategy);
852
855 absl::Span<const BoolVar> variables,
856 DecisionStrategyProto::VariableSelectionStrategy var_strategy,
857 DecisionStrategyProto::DomainReductionStrategy domain_strategy);
858
860 void AddHint(IntVar var, int64 value);
861
864
867
869 void AddAssumptions(absl::Span<const BoolVar> literals);
870
873
874 // TODO(user) : add MapDomain?
875
876 const CpModelProto& Build() const { return Proto(); }
877
878 const CpModelProto& Proto() const { return cp_model_; }
879 CpModelProto* MutableProto() { return &cp_model_; }
880
882 void CopyFrom(const CpModelProto& model_proto);
883
886
889
892
893 private:
896
897 // Fills the 'expr_proto' with the linear expression represented by 'expr'.
898 void LinearExprToProto(const LinearExpr& expr,
899 LinearExpressionProto* expr_proto);
900
901 // Returns a (cached) integer variable index with a constant value.
902 int IndexFromConstant(int64 value);
903
904 // Returns a valid integer index from a BoolVar index.
905 // If the input index is a positive, it returns this index.
906 // If the input index is negative, it creates a cached IntVar equal to
907 // 1 - BoolVar(PositiveRef(index)), and returns the index of this new
908 // variable.
909 int GetOrCreateIntegerIndex(int index);
910
911 void FillLinearTerms(const LinearExpr& left, const LinearExpr& right,
912 LinearConstraintProto* proto);
913
914 CpModelProto cp_model_;
915 absl::flat_hash_map<int64, int> constant_to_index_map_;
916 absl::flat_hash_map<int, int> bool_to_integer_index_map_;
917};
918
920int64 SolutionIntegerValue(const CpSolverResponse& r, const LinearExpr& expr);
921
923int64 SolutionIntegerMin(const CpSolverResponse& r, IntVar x);
924
926int64 SolutionIntegerMax(const CpSolverResponse& r, IntVar x);
927
929bool SolutionBooleanValue(const CpSolverResponse& r, BoolVar x);
930
931} // namespace sat
932} // namespace operations_research
933
934#endif // OR_TOOLS_SAT_CP_MODEL_H_
We call domain any subset of Int64 = [kint64min, kint64max].
Specialized automaton constraint.
Definition: cp_model.h:545
void AddTransition(int tail, int head, int64 transition_label)
Adds a transitions to the automaton.
A Boolean variable.
Definition: cp_model.h:67
IntegerVariableProto * MutableProto() const
Returns the mutable underlying protobuf object (useful for model edition).
Definition: cp_model.h:99
BoolVar WithName(const std::string &name)
Sets the name of the variable.
std::string DebugString() const
Debug string.
friend bool SolutionBooleanValue(const CpSolverResponse &r, BoolVar x)
Evaluates the value of a Boolean literal in a solver response.
const std::string & Name() const
Returns the name of the variable.
Definition: cp_model.h:75
bool operator!=(const BoolVar &other) const
Dis-Equality test.
Definition: cp_model.h:86
bool operator==(const BoolVar &other) const
Equality test with another boolvar.
Definition: cp_model.h:81
int index() const
Returns the index of the variable in the model.
Definition: cp_model.h:109
BoolVar Not() const
Returns the logical negation of the current Boolean variable.
Definition: cp_model.h:78
const IntegerVariableProto & Proto() const
Returns the underlying protobuf object (useful for testing).
Definition: cp_model.h:94
Specialized circuit constraint.
Definition: cp_model.h:451
void AddArc(int tail, int head, BoolVar literal)
Add an arc to the circuit.
Constraint OnlyEnforceIf(absl::Span< const BoolVar > literals)
The constraint will be enforced iff all literals listed here are true.
Constraint WithName(const std::string &name)
Sets the name of the constraint.
ConstraintProto * MutableProto() const
Returns the mutable underlying protobuf object (useful for model edition).
Definition: cp_model.h:436
const std::string & Name() const
Returns the name of the constraint (or the empty string if not set).
Constraint(ConstraintProto *proto)
Constraint OnlyEnforceIf(BoolVar literal)
See OnlyEnforceIf(absl::Span<const BoolVar> literals).
const ConstraintProto & Proto() const
Returns the underlying protobuf object (useful for testing).
Definition: cp_model.h:433
Wrapper class around the cp_model proto.
Definition: cp_model.h:599
IntVar NewConstant(int64 value)
Creates a constant variable.
TableConstraint AddForbiddenAssignments(absl::Span< const IntVar > vars)
Adds an forbidden assignments constraint.
Constraint AddLinearConstraint(const LinearExpr &expr, const Domain &domain)
Adds expr in domain.
void ClearAssumptions()
Remove all assumptions from the model.
Constraint AddAbsEquality(IntVar target, IntVar var)
Adds target == abs(var).
void AddAssumptions(absl::Span< const BoolVar > literals)
Adds multiple literals to the model as assumptions.
ReservoirConstraint AddReservoirConstraint(int64 min_level, int64 max_level)
Adds a reservoir constraint with optional refill/emptying events.
MultipleCircuitConstraint AddMultipleCircuitConstraint()
Adds a multiple circuit constraint, aka the "VRP" (Vehicle Routing Problem) constraint.
Constraint AddMinEquality(IntVar target, absl::Span< const IntVar > vars)
Adds target == min(vars).
BoolVar TrueVar()
Creates an always true Boolean variable.
IntVar NewIntVar(const Domain &domain)
Creates an integer variable with the given domain.
Constraint AddMaxEquality(IntVar target, absl::Span< const IntVar > vars)
Adds target == max(vars).
Constraint AddDivisionEquality(IntVar target, IntVar numerator, IntVar denominator)
Adds target = num / denom (integer division rounded towards 0).
void AddDecisionStrategy(absl::Span< const BoolVar > variables, DecisionStrategyProto::VariableSelectionStrategy var_strategy, DecisionStrategyProto::DomainReductionStrategy domain_strategy)
Adds a decision strategy on a list of boolean variables.
void Maximize(const LinearExpr &expr)
Adds a linear maximization objective.
IntervalVar NewOptionalIntervalVar(IntVar start, IntVar size, IntVar end, BoolVar presence)
Creates an optional interval variable.
BoolVar NewBoolVar()
Creates a Boolean variable.
void AddDecisionStrategy(absl::Span< const IntVar > variables, DecisionStrategyProto::VariableSelectionStrategy var_strategy, DecisionStrategyProto::DomainReductionStrategy domain_strategy)
Adds a decision strategy on a list of integer variables.
void ScaleObjectiveBy(double scaling)
Sets scaling of the objective.
CircuitConstraint AddCircuitConstraint()
Adds a circuit constraint.
Constraint AddVariableElement(IntVar index, absl::Span< const IntVar > variables, IntVar target)
Adds the element constraint: variables[index] == target.
CumulativeConstraint AddCumulative(IntVar capacity)
The cumulative constraint.
Constraint AddGreaterThan(const LinearExpr &left, const LinearExpr &right)
Adds left > right.
void CopyFrom(const CpModelProto &model_proto)
Replace the current model with the one from the given proto.
Constraint AddLessThan(const LinearExpr &left, const LinearExpr &right)
Adds left < right.
Constraint AddBoolXor(absl::Span< const BoolVar > literals)
Adds the constraint that a odd number of literal is true.
void AddAssumption(BoolVar lit)
Adds a literal to the model as assumptions.
void Minimize(const LinearExpr &expr)
Adds a linear minimization objective.
BoolVar FalseVar()
Creates an always false Boolean variable.
Constraint AddImplication(BoolVar a, BoolVar b)
Adds a => b.
Definition: cp_model.h:633
Constraint AddBoolAnd(absl::Span< const BoolVar > literals)
Adds the constraint that all literals must be true.
IntervalVar GetIntervalVarFromProtoIndex(int index)
Returns the interval variable from its index in the proto.
Constraint AddLessOrEqual(const LinearExpr &left, const LinearExpr &right)
Adds left <= right.
Constraint AddModuloEquality(IntVar target, IntVar var, IntVar mod)
Adds target = var % mod.
Constraint AddEquality(const LinearExpr &left, const LinearExpr &right)
Adds left == right.
NoOverlap2DConstraint AddNoOverlap2D()
The no_overlap_2d constraint prevents a set of boxes from overlapping.
Constraint AddElement(IntVar index, absl::Span< const int64 > values, IntVar target)
Adds the element constraint: values[index] == target.
Constraint AddGreaterOrEqual(const LinearExpr &left, const LinearExpr &right)
Adds left >= right.
Constraint AddBoolOr(absl::Span< const BoolVar > literals)
Adds the constraint that at least one of the literals must be true.
IntVar GetIntVarFromProtoIndex(int index)
Returns the integer variable from its index in the proto.
AutomatonConstraint AddAutomaton(absl::Span< const IntVar > transition_variables, int starting_state, absl::Span< const int > final_states)
An automaton constraint/.
void AddHint(IntVar var, int64 value)
Adds hinting to a variable.
Constraint AddLinMinEquality(const LinearExpr &target, absl::Span< const LinearExpr > exprs)
Adds target == min(exprs).
Constraint AddProductEquality(IntVar target, absl::Span< const IntVar > vars)
Adds target == prod(vars).
Constraint AddLinMaxEquality(const LinearExpr &target, absl::Span< const LinearExpr > exprs)
Adds target == max(exprs).
const CpModelProto & Build() const
Definition: cp_model.h:876
BoolVar GetBoolVarFromProtoIndex(int index)
Returns the Boolean variable from its index in the proto.
Constraint AddNotEqual(const LinearExpr &left, const LinearExpr &right)
Adds left != right.
Constraint AddAllDifferent(absl::Span< const IntVar > vars)
this constraint forces all variables to have different values.
TableConstraint AddAllowedAssignments(absl::Span< const IntVar > vars)
Adds an allowed assignments constraint.
Constraint AddInverseConstraint(absl::Span< const IntVar > variables, absl::Span< const IntVar > inverse_variables)
An inverse constraint.
IntervalVar NewIntervalVar(IntVar start, IntVar size, IntVar end)
Creates an interval variable.
Constraint AddNoOverlap(absl::Span< const IntervalVar > vars)
Adds a no-overlap constraint that ensures that all present intervals do not overlap in time.
const CpModelProto & Proto() const
Definition: cp_model.h:878
Specialized cumulative constraint.
Definition: cp_model.h:579
void AddDemand(IntervalVar interval, IntVar demand)
Adds a pair (interval, demand) to the constraint.
An integer variable.
Definition: cp_model.h:146
BoolVar ToBoolVar() const
Cast IntVar -> BoolVar.
IntegerVariableProto * MutableProto() const
Returns the mutable underlying protobuf object (useful for model edition).
Definition: cp_model.h:186
LinearExpr AddConstant(int64 value) const
Adds a constant value to an integer variable and returns a linear expression.
bool operator==(const IntVar &other) const
Equality test with another IntVar.
Definition: cp_model.h:168
friend int64 SolutionIntegerValue(const CpSolverResponse &r, const LinearExpr &expr)
Evaluates the value of an linear expression in a solver response.
std::string DebugString() const
Returns a debug string.
friend int64 SolutionIntegerMax(const CpSolverResponse &r, IntVar x)
Returns the max of an integer variable in a solution.
bool operator!=(const IntVar &other) const
Difference test with anpther IntVar.
Definition: cp_model.h:173
IntVar WithName(const std::string &name)
Sets the name of the variable.
const std::string & Name() const
Returns the name of the variable (or the empty string if not set).
Definition: cp_model.h:161
friend int64 SolutionIntegerMin(const CpSolverResponse &r, IntVar x)
Returns the min of an integer variable in a solution.
int index() const
Returns the index of the variable in the model.
Definition: cp_model.h:191
IntVar(const BoolVar &var)
Implicit cast BoolVar -> IntVar.
const IntegerVariableProto & Proto() const
Returns the underlying protobuf object (useful for testing).
Definition: cp_model.h:181
Represents a Interval variable.
Definition: cp_model.h:326
BoolVar PresenceBoolVar() const
Returns a BoolVar indicating the presence of this interval.
std::string Name() const
Returns the name of the interval (or the empty string if not set).
IntVar SizeVar() const
Returns the size variable.
const IntervalConstraintProto & Proto() const
Returns the underlying protobuf object (useful for testing).
Definition: cp_model.h:367
std::string DebugString() const
Returns a debug string.
bool operator!=(const IntervalVar &other) const
Difference test with another interval variable.
Definition: cp_model.h:359
bool operator==(const IntervalVar &other) const
Equality test with another interval variable.
Definition: cp_model.h:354
IntervalVar WithName(const std::string &name)
Sets the name of the variable.
IntVar EndVar() const
Returns the end variable.
IntervalConstraintProto * MutableProto() const
Returns the mutable underlying protobuf object (useful for model edition).
Definition: cp_model.h:372
int index() const
Returns the index of the interval constraint in the model.
Definition: cp_model.h:377
friend std::ostream & operator<<(std::ostream &os, const IntervalVar &var)
IntVar StartVar() const
Returns the start variable.
A dedicated container for linear expressions.
Definition: cp_model.h:248
static LinearExpr ScalProd(absl::Span< const IntVar > vars, absl::Span< const int64 > coeffs)
Constructs the scalar product of variables and coefficients.
LinearExpr & AddConstant(int64 value)
Adds a constant value to the linear expression.
static LinearExpr Term(IntVar var, int64 coefficient)
Construncts var * coefficient.
LinearExpr(IntVar var)
Constructs a linear expression from an integer variable.
static LinearExpr BooleanScalProd(absl::Span< const BoolVar > vars, absl::Span< const int64 > coeffs)
Constructs the scalar product of Booleans and coefficients.
static LinearExpr Sum(absl::Span< const IntVar > vars)
Constructs the sum of a list of variables.
LinearExpr(BoolVar var)
Constructs a linear expression from a Boolean variable.
LinearExpr(int64 constant)
Constructs a constant linear expression.
static LinearExpr BooleanSum(absl::Span< const BoolVar > vars)
Constructs the sum of a list of Booleans.
void AddTerm(IntVar var, int64 coeff)
Adds a term (var * coeff) to the linear expression.
void AddVar(IntVar var)
Adds a single integer variable to the linear expression.
const std::vector< IntVar > & variables() const
Returns the vector of variables.
Definition: cp_model.h:291
int64 constant() const
Returns the constant term.
Definition: cp_model.h:297
const std::vector< int64 > & coefficients() const
Returns the vector of coefficients.
Definition: cp_model.h:294
void AddArc(int tail, int head, BoolVar literal)
Add an arc to the circuit.
Specialized no_overlap2D constraint.
Definition: cp_model.h:562
void AddRectangle(IntervalVar x_coordinate, IntervalVar y_coordinate)
Adds a rectangle (parallel to the axis) to the constraint.
Specialized reservoir constraint.
Definition: cp_model.h:514
void AddEvent(IntVar time, int64 demand)
Adds a mandatory event.
void AddOptionalEvent(IntVar time, int64 demand, BoolVar is_active)
Adds a optional event.
Specialized assignment constraint.
Definition: cp_model.h:497
void AddTuple(absl::Span< const int64 > tuple)
Adds a tuple of possible values to the constraint.
std::ostream & operator<<(std::ostream &os, const BoolVar &var)
int64 SolutionIntegerValue(const CpSolverResponse &r, const LinearExpr &expr)
Evaluates the value of an linear expression in a solver response.
int64 SolutionIntegerMax(const CpSolverResponse &r, IntVar x)
Returns the max of an integer variable in a solution.
BoolVar Not(BoolVar x)
A convenient wrapper so we can write Not(x) instead of x.Not() which is sometimes clearer.
bool SolutionBooleanValue(const CpSolverResponse &r, BoolVar x)
Evaluates the value of a Boolean literal in a solver response.
int64 SolutionIntegerMin(const CpSolverResponse &r, IntVar x)
Returns the min of an integer variable in a solution.