16#include "absl/strings/str_format.h"
18#include "ortools/sat/cp_model.pb.h"
21#include "ortools/sat/sat_parameters.pb.h"
29 : cp_model_(cp_model), index_(
index) {}
32 cp_model_->mutable_variables(index_)->set_name(
name);
41 const IntegerVariableProto& var_proto = cp_model_->variables(index_);
43 if (var_proto.name().empty() && var_proto.domain_size() == 2 &&
44 var_proto.domain(0) == var_proto.domain(1)) {
45 output.append(var_proto.domain(0) == 0 ?
"false" :
"true");
47 if (var_proto.name().empty()) {
48 absl::StrAppendFormat(&output,
"BoolVar%i(", index_);
50 absl::StrAppendFormat(&output,
"%s(", var_proto.name());
52 if (var_proto.domain(0) == var_proto.domain(1)) {
53 output.append(var_proto.domain(0) == 0 ?
"false)" :
"true)");
55 absl::StrAppend(&output, var_proto.domain(0),
", ", var_proto.domain(1),
73 : cp_model_(cp_model), index_(
index) {
78 cp_model_->mutable_variables(index_)->set_name(
name);
83 cp_model_ =
var.cp_model_;
92 var.cp_model_ = cp_model_;
103 return absl::StrFormat(
"Not(%s)",
106 const IntegerVariableProto& var_proto = cp_model_->variables(index_);
108 if (var_proto.name().empty() && var_proto.domain_size() == 2 &&
109 var_proto.domain(0) == var_proto.domain(1)) {
110 return absl::StrCat(var_proto.domain(0));
113 if (var_proto.name().empty()) {
114 absl::StrAppend(&output,
"IntVar", index_,
"(");
116 absl::StrAppend(&output, var_proto.name(),
"(");
118 if (var_proto.domain_size() == 2 &&
119 var_proto.domain(0) == var_proto.domain(1)) {
120 absl::StrAppend(&output, var_proto.domain(0),
")");
123 absl::StrAppend(&output, var_proto.domain(0),
", ", var_proto.domain(1),
152 absl::Span<const int64> coeffs) {
153 CHECK_EQ(vars.size(), coeffs.size());
155 for (
int i = 0; i < vars.size(); ++i) {
156 result.
AddTerm(vars[i], coeffs[i]);
176 absl::Span<const int64> coeffs) {
177 CHECK_EQ(vars.size(), coeffs.size());
179 for (
int i = 0; i < vars.size(); ++i) {
180 result.
AddTerm(vars[i], coeffs[i]);
195 variables_.push_back(
var);
196 coefficients_.push_back(coeff);
199 coefficients_.push_back(-coeff);
215 proto_->add_enforcement_literal(
var.index_);
239 for (
const int64 t : tuple) {
240 proto_->mutable_table()->add_values(t);
244ReservoirConstraint::ReservoirConstraint(ConstraintProto*
proto,
249 proto_->mutable_reservoir()->add_times(
250 builder_->GetOrCreateIntegerIndex(
time.index_));
252 proto_->mutable_reservoir()->add_actives(builder_->IndexFromConstant(1));
257 proto_->mutable_reservoir()->add_times(
258 builder_->GetOrCreateIntegerIndex(
time.index_));
260 proto_->mutable_reservoir()->add_actives(is_active.index_);
264 int64 transition_label) {
265 proto_->mutable_automaton()->add_transition_tail(
tail);
266 proto_->mutable_automaton()->add_transition_head(
head);
267 proto_->mutable_automaton()->add_transition_label(transition_label);
272 proto_->mutable_no_overlap_2d()->add_x_intervals(x_coordinate.index_);
273 proto_->mutable_no_overlap_2d()->add_y_intervals(y_coordinate.index_);
276CumulativeConstraint::CumulativeConstraint(ConstraintProto*
proto,
282 proto_->mutable_cumulative()->add_demands(
283 builder_->GetOrCreateIntegerIndex(
demand.index_));
289 : cp_model_(cp_model), index_(
index) {}
292 cp_model_->mutable_constraints(index_)->set_name(
name);
307 return BoolVar(cp_model_->constraints(index_).enforcement_literal(0),
312 return cp_model_->constraints(index_).name();
317 const ConstraintProto& ct_proto = cp_model_->constraints(index_);
319 if (ct_proto.name().empty()) {
320 absl::StrAppend(&output,
"IntervalVar", index_,
"(");
322 absl::StrAppend(&output, ct_proto.name(),
"(");
335int CpModelBuilder::IndexFromConstant(
int64 value) {
337 const int index = cp_model_.variables_size();
338 IntegerVariableProto*
const var_proto = cp_model_.add_variables();
339 var_proto->add_domain(
value);
340 var_proto->add_domain(
value);
343 return constant_to_index_map_[
value];
346int CpModelBuilder::GetOrCreateIntegerIndex(
int index) {
352 const IntegerVariableProto& old_var = cp_model_.variables(
var);
353 const int new_index = cp_model_.variables_size();
354 IntegerVariableProto*
const new_var = cp_model_.add_variables();
355 new_var->add_domain(0);
356 new_var->add_domain(1);
357 if (!old_var.name().empty()) {
358 new_var->set_name(absl::StrCat(
"Not(", old_var.name(),
")"));
361 bool_to_integer_index_map_[
index] = new_index;
364 return bool_to_integer_index_map_[
index];
368 const int index = cp_model_.variables_size();
369 IntegerVariableProto*
const var_proto = cp_model_.add_variables();
370 for (
const auto&
interval : domain) {
371 var_proto->add_domain(
interval.start);
372 var_proto->add_domain(
interval.end);
378 const int index = cp_model_.variables_size();
379 IntegerVariableProto*
const var_proto = cp_model_.add_variables();
380 var_proto->add_domain(0);
381 var_proto->add_domain(1);
386 return IntVar(IndexFromConstant(
value), &cp_model_);
390 return BoolVar(IndexFromConstant(1), &cp_model_);
394 return BoolVar(IndexFromConstant(0), &cp_model_);
405 const int index = cp_model_.constraints_size();
406 ConstraintProto*
const ct = cp_model_.add_constraints();
407 ct->add_enforcement_literal(presence.index_);
408 IntervalConstraintProto*
const interval =
ct->mutable_interval();
409 interval->set_start(GetOrCreateIntegerIndex(start.index_));
410 interval->set_size(GetOrCreateIntegerIndex(size.index_));
411 interval->set_end(GetOrCreateIntegerIndex(end.index_));
416 ConstraintProto*
const proto = cp_model_.add_constraints();
417 for (
const BoolVar& lit : literals) {
418 proto->mutable_bool_or()->add_literals(lit.index_);
424 ConstraintProto*
const proto = cp_model_.add_constraints();
425 for (
const BoolVar& lit : literals) {
426 proto->mutable_bool_and()->add_literals(lit.index_);
432 ConstraintProto*
const proto = cp_model_.add_constraints();
433 for (
const BoolVar& lit : literals) {
434 proto->mutable_bool_xor()->add_literals(lit.index_);
439void CpModelBuilder::FillLinearTerms(
const LinearExpr& left,
441 LinearConstraintProto*
proto) {
443 proto->add_vars(x.index_);
446 proto->add_coeffs(coeff);
448 for (
const IntVar& x : right.
variables()) {
449 proto->add_vars(x.index_);
452 proto->add_coeffs(-coeff);
458 ConstraintProto*
const proto = cp_model_.add_constraints();
459 FillLinearTerms(left, right,
proto->mutable_linear());
461 proto->mutable_linear()->add_domain(rhs);
462 proto->mutable_linear()->add_domain(rhs);
468 ConstraintProto*
const proto = cp_model_.add_constraints();
469 FillLinearTerms(left, right,
proto->mutable_linear());
471 proto->mutable_linear()->add_domain(rhs);
478 ConstraintProto*
const proto = cp_model_.add_constraints();
479 FillLinearTerms(left, right,
proto->mutable_linear());
482 proto->mutable_linear()->add_domain(rhs);
488 ConstraintProto*
const proto = cp_model_.add_constraints();
489 FillLinearTerms(left, right,
proto->mutable_linear());
491 proto->mutable_linear()->add_domain(rhs + 1);
498 ConstraintProto*
const proto = cp_model_.add_constraints();
499 FillLinearTerms(left, right,
proto->mutable_linear());
502 proto->mutable_linear()->add_domain(rhs - 1);
508 ConstraintProto*
const proto = cp_model_.add_constraints();
510 proto->mutable_linear()->add_vars(x.index_);
513 proto->mutable_linear()->add_coeffs(coeff);
516 for (
const auto& i : domain) {
517 proto->mutable_linear()->add_domain(i.start - cst);
518 proto->mutable_linear()->add_domain(i.end - cst);
525 ConstraintProto*
const proto = cp_model_.add_constraints();
526 FillLinearTerms(left, right,
proto->mutable_linear());
529 proto->mutable_linear()->add_domain(rhs - 1);
530 proto->mutable_linear()->add_domain(rhs + 1);
536 ConstraintProto*
const proto = cp_model_.add_constraints();
538 proto->mutable_all_diff()->add_vars(GetOrCreateIntegerIndex(
var.index_));
545 ConstraintProto*
const proto = cp_model_.add_constraints();
546 proto->mutable_element()->set_index(GetOrCreateIntegerIndex(
index.index_));
547 proto->mutable_element()->set_target(GetOrCreateIntegerIndex(target.index_));
549 proto->mutable_element()->add_vars(GetOrCreateIntegerIndex(
var.index_));
555 absl::Span<const int64> values,
557 ConstraintProto*
const proto = cp_model_.add_constraints();
558 proto->mutable_element()->set_index(GetOrCreateIntegerIndex(
index.index_));
559 proto->mutable_element()->set_target(GetOrCreateIntegerIndex(target.index_));
561 proto->mutable_element()->add_vars(IndexFromConstant(
value));
575 absl::Span<const IntVar> vars) {
576 ConstraintProto*
const proto = cp_model_.add_constraints();
578 proto->mutable_table()->add_vars(GetOrCreateIntegerIndex(
var.index_));
584 absl::Span<const IntVar> vars) {
585 ConstraintProto*
const proto = cp_model_.add_constraints();
587 proto->mutable_table()->add_vars(GetOrCreateIntegerIndex(
var.index_));
589 proto->mutable_table()->set_negated(
true);
594 absl::Span<const IntVar> variables,
595 absl::Span<const IntVar> inverse_variables) {
596 ConstraintProto*
const proto = cp_model_.add_constraints();
598 proto->mutable_inverse()->add_f_direct(GetOrCreateIntegerIndex(
var.index_));
600 for (
const IntVar&
var : inverse_variables) {
601 proto->mutable_inverse()->add_f_inverse(
602 GetOrCreateIntegerIndex(
var.index_));
609 ConstraintProto*
const proto = cp_model_.add_constraints();
610 proto->mutable_reservoir()->set_min_level(min_level);
611 proto->mutable_reservoir()->set_max_level(max_level);
616 absl::Span<const IntVar> transition_variables,
int starting_state,
617 absl::Span<const int> final_states) {
618 ConstraintProto*
const proto = cp_model_.add_constraints();
619 for (
const IntVar&
var : transition_variables) {
620 proto->mutable_automaton()->add_vars(GetOrCreateIntegerIndex(
var.index_));
622 proto->mutable_automaton()->set_starting_state(starting_state);
623 for (
const int final_state : final_states) {
624 proto->mutable_automaton()->add_final_states(final_state);
630 absl::Span<const IntVar> vars) {
631 ConstraintProto*
const proto = cp_model_.add_constraints();
632 proto->mutable_int_min()->set_target(GetOrCreateIntegerIndex(target.index_));
634 proto->mutable_int_min()->add_vars(GetOrCreateIntegerIndex(
var.index_));
639void CpModelBuilder::LinearExprToProto(
const LinearExpr& expr,
640 LinearExpressionProto* expr_proto) {
642 expr_proto->add_vars(GetOrCreateIntegerIndex(
var.index_));
645 expr_proto->add_coeffs(coeff);
647 expr_proto->set_offset(expr.
constant());
651 const LinearExpr& target, absl::Span<const LinearExpr> exprs) {
652 ConstraintProto*
const proto = cp_model_.add_constraints();
653 LinearExprToProto(target,
proto->mutable_lin_min()->mutable_target());
655 LinearExpressionProto* expr_proto =
proto->mutable_lin_min()->add_exprs();
656 LinearExprToProto(expr, expr_proto);
662 absl::Span<const IntVar> vars) {
663 ConstraintProto*
const proto = cp_model_.add_constraints();
664 proto->mutable_int_max()->set_target(GetOrCreateIntegerIndex(target.index_));
666 proto->mutable_int_max()->add_vars(GetOrCreateIntegerIndex(
var.index_));
672 const LinearExpr& target, absl::Span<const LinearExpr> exprs) {
673 ConstraintProto*
const proto = cp_model_.add_constraints();
674 LinearExprToProto(target,
proto->mutable_lin_max()->mutable_target());
676 LinearExpressionProto* expr_proto =
proto->mutable_lin_max()->add_exprs();
677 LinearExprToProto(expr, expr_proto);
684 ConstraintProto*
const proto = cp_model_.add_constraints();
685 proto->mutable_int_div()->set_target(GetOrCreateIntegerIndex(target.index_));
686 proto->mutable_int_div()->add_vars(GetOrCreateIntegerIndex(numerator.index_));
687 proto->mutable_int_div()->add_vars(
688 GetOrCreateIntegerIndex(denominator.index_));
693 ConstraintProto*
const proto = cp_model_.add_constraints();
694 proto->mutable_int_max()->set_target(GetOrCreateIntegerIndex(target.index_));
695 proto->mutable_int_max()->add_vars(GetOrCreateIntegerIndex(
var.index_));
696 proto->mutable_int_max()->add_vars(
703 ConstraintProto*
const proto = cp_model_.add_constraints();
704 proto->mutable_int_mod()->set_target(GetOrCreateIntegerIndex(target.index_));
705 proto->mutable_int_mod()->add_vars(GetOrCreateIntegerIndex(
var.index_));
706 proto->mutable_int_mod()->add_vars(GetOrCreateIntegerIndex(mod.index_));
711 absl::Span<const IntVar> vars) {
712 ConstraintProto*
const proto = cp_model_.add_constraints();
713 proto->mutable_int_prod()->set_target(GetOrCreateIntegerIndex(target.index_));
715 proto->mutable_int_prod()->add_vars(GetOrCreateIntegerIndex(
var.index_));
721 ConstraintProto*
const proto = cp_model_.add_constraints();
723 proto->mutable_no_overlap()->add_intervals(
724 GetOrCreateIntegerIndex(
var.index_));
734 ConstraintProto*
const proto = cp_model_.add_constraints();
735 proto->mutable_cumulative()->set_capacity(
736 GetOrCreateIntegerIndex(
capacity.index_));
741 cp_model_.mutable_objective()->Clear();
743 cp_model_.mutable_objective()->add_vars(x.index_);
746 cp_model_.mutable_objective()->add_coeffs(coeff);
748 cp_model_.mutable_objective()->set_offset(expr.
constant());
752 cp_model_.mutable_objective()->Clear();
754 cp_model_.mutable_objective()->add_vars(x.index_);
757 cp_model_.mutable_objective()->add_coeffs(-coeff);
759 cp_model_.mutable_objective()->set_offset(-expr.
constant());
760 cp_model_.mutable_objective()->set_scaling_factor(-1.0);
764 CHECK(cp_model_.has_objective());
765 cp_model_.mutable_objective()->set_scaling_factor(
766 scaling * cp_model_.objective().scaling_factor());
770 absl::Span<const IntVar> variables,
771 DecisionStrategyProto::VariableSelectionStrategy var_strategy,
772 DecisionStrategyProto::DomainReductionStrategy domain_strategy) {
773 DecisionStrategyProto*
const proto = cp_model_.add_search_strategy();
777 proto->set_variable_selection_strategy(var_strategy);
778 proto->set_domain_reduction_strategy(domain_strategy);
782 absl::Span<const BoolVar> variables,
783 DecisionStrategyProto::VariableSelectionStrategy var_strategy,
784 DecisionStrategyProto::DomainReductionStrategy domain_strategy) {
785 DecisionStrategyProto*
const proto = cp_model_.add_search_strategy();
789 proto->set_variable_selection_strategy(var_strategy);
790 proto->set_domain_reduction_strategy(domain_strategy);
794 cp_model_.mutable_solution_hint()->add_vars(
795 GetOrCreateIntegerIndex(
var.index_));
796 cp_model_.mutable_solution_hint()->add_values(
value);
800 cp_model_.mutable_solution_hint()->Clear();
804 cp_model_.mutable_assumptions()->Add(lit.index_);
808 for (
const BoolVar& lit : literals) {
809 cp_model_.mutable_assumptions()->Add(lit.index_);
814 cp_model_.mutable_assumptions()->Clear();
820 constant_to_index_map_.clear();
821 for (
int i = 0; i < cp_model_.variables_size(); ++i) {
822 const IntegerVariableProto&
var = cp_model_.variables(i);
823 if (
var.domain_size() == 2 &&
var.domain(0) ==
var.domain(1)) {
824 constant_to_index_map_[
var.domain(0)] = i;
828 bool_to_integer_index_map_.clear();
834 const IntegerVariableProto&
proto = cp_model_.variables(
index);
836 <<
"CpModelBuilder::GetBoolVarFromProtoIndex: The domain of the variable "
839 <<
"CpModelBuilder::GetBoolVarFromProtoIndex: The domain of the variable "
842 <<
"CpModelBuilder::GetBoolVarFromProtoIndex: The domain of the variable "
856 const ConstraintProto&
ct = cp_model_.constraints(
index);
857 CHECK_EQ(
ct.constraint_case(), ConstraintProto::kInterval)
858 <<
"CpModelBuilder::GetIntervalVarFromProtoIndex: the referenced "
859 "object is not an interval variable";
865 for (
int i = 0; i < expr.
variables().size(); ++i) {
872 if (r.solution_size() > 0) {
873 return r.solution(x.index_);
875 return r.solution_lower_bounds(x.index_);
880 if (r.solution_size() > 0) {
881 return r.solution(x.index_);
883 return r.solution_upper_bounds(x.index_);
888 const int ref = x.index_;
890 return r.solution(ref) == 1;
#define CHECK_LT(val1, val2)
#define CHECK_EQ(val1, val2)
#define CHECK_GE(val1, val2)
#define CHECK_LE(val1, val2)
We call domain any subset of Int64 = [kint64min, kint64max].
Specialized automaton constraint.
void AddTransition(int tail, int head, int64 transition_label)
Adds a transitions to the automaton.
BoolVar WithName(const std::string &name)
Sets the name of the variable.
std::string DebugString() const
Debug string.
BoolVar Not() const
Returns the logical negation of the current Boolean variable.
Specialized circuit constraint.
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.
const std::string & Name() const
Returns the name of the constraint (or the empty string if not set).
Constraint(ConstraintProto *proto)
Wrapper class around the cp_model proto.
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 ClearHints()
Remove all hints.
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.
friend class CumulativeConstraint
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).
friend class ReservoirConstraint
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.
Specialized cumulative constraint.
void AddDemand(IntervalVar interval, IntVar demand)
Adds a pair (interval, demand) to the constraint.
BoolVar ToBoolVar() const
Cast IntVar -> BoolVar.
LinearExpr AddConstant(int64 value) const
Adds a constant value to an integer variable and returns a linear expression.
std::string DebugString() const
Returns a debug string.
IntVar WithName(const std::string &name)
Sets the name of the variable.
int index() const
Returns the index of the variable in the model.
const IntegerVariableProto & Proto() const
Returns the underlying protobuf object (useful for testing).
Represents a Interval variable.
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).
std::string DebugString() const
Returns a debug string.
IntervalVar WithName(const std::string &name)
Sets the name of the variable.
IntVar EndVar() const
Returns the end variable.
IntervalVar()
Default ctor.
IntVar StartVar() const
Returns the start variable.
A dedicated container for linear expressions.
static LinearExpr Term(IntVar var, int64 coefficient)
Construncts var * coefficient.
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 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.
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.
int64 constant() const
Returns the constant term.
const std::vector< int64 > & coefficients() const
Returns the vector of coefficients.
Specialized circuit constraint.
void AddArc(int tail, int head, BoolVar literal)
Add an arc to the circuit.
Specialized no_overlap2D constraint.
void AddRectangle(IntervalVar x_coordinate, IntervalVar y_coordinate)
Adds a rectangle (parallel to the axis) to the constraint.
Specialized reservoir constraint.
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.
void AddTuple(absl::Span< const int64 > tuple)
Adds a tuple of possible values to the constraint.
This file implements a wrapper around the CP-SAT model proto.
CpModelProto const * model_proto
static const int64 kint64max
static const int64 kint64min
bool ContainsKey(const Collection &collection, const Key &key)
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.
bool RefIsPositive(int ref)
The vehicle routing library lets one model and solve generic vehicle routing problems ranging from th...