63 #ifndef OR_TOOLS_CONSTRAINT_SOLVER_CONSTRAINT_SOLVER_H_
64 #define OR_TOOLS_CONSTRAINT_SOLVER_CONSTRAINT_SOLVER_H_
74 #include "absl/base/macros.h"
75 #include "absl/container/flat_hash_map.h"
76 #include "absl/container/flat_hash_set.h"
77 #include "absl/random/distributions.h"
78 #include "absl/random/random.h"
79 #include "absl/strings/str_format.h"
96 #endif // !defined(SWIG)
103 class AssignmentProto;
107 class CpIntegerExpression;
108 class CpIntervalVariable;
109 class CpSequenceVariable;
110 class CastConstraint;
113 class DecisionBuilder;
114 class DecisionVisitor;
117 class LocalSearchProfiler;
119 class DisjunctiveConstraint;
120 class ExpressionCache;
124 class IntVarAssignment;
127 class IntervalVarAssignment;
128 class IntervalVarElement;
129 class IntVarLocalSearchFilter;
130 class LocalSearchFilter;
131 class LocalSearchFilterManager;
132 class LocalSearchOperator;
133 class LocalSearchPhaseParameters;
138 class PropagationBaseObject;
139 class PropagationMonitor;
140 class LocalSearchMonitor;
145 class RegularLimitParameters;
150 class SequenceVarAssignment;
151 class SolutionCollector;
154 class ConstraintSolverParameters;
155 class SymmetryBreaker;
161 inline int64 CpRandomSeed() {
162 return FLAGS_cp_random_seed == -1
163 ? absl::Uniform<int64>(absl::BitGen(), 0,
kint64max)
164 : FLAGS_cp_random_seed;
170 struct DefaultPhaseParameters {
172 enum VariableSelection {
173 CHOOSE_MAX_SUM_IMPACT = 0,
174 CHOOSE_MAX_AVERAGE_IMPACT = 1,
175 CHOOSE_MAX_VALUE_IMPACT = 2,
178 enum ValueSelection {
179 SELECT_MIN_IMPACT = 0,
180 SELECT_MAX_IMPACT = 1,
183 enum DisplayLevel { NONE = 0, NORMAL = 1, VERBOSE = 2 };
187 VariableSelection var_selection_schema;
190 ValueSelection value_selection_schema;
194 int initialization_splits;
199 bool run_all_heuristics;
204 int heuristic_period;
207 int heuristic_num_failures_limit;
211 bool persistent_impact;
218 DisplayLevel display_level;
221 bool use_last_conflict;
224 DecisionBuilder* decision_builder;
226 DefaultPhaseParameters();
252 struct IntegerCastInfo {
254 : variable(nullptr), expression(nullptr), maintainer(nullptr) {}
255 IntegerCastInfo(IntVar*
const v, IntExpr*
const e, Constraint*
const c)
256 : variable(v), expression(e), maintainer(c) {}
259 Constraint* maintainer;
263 static constexpr
int kNumPriorities = 3;
267 enum IntVarStrategy {
277 CHOOSE_FIRST_UNBOUND,
288 CHOOSE_MIN_SIZE_LOWEST_MIN,
296 CHOOSE_MIN_SIZE_HIGHEST_MIN,
304 CHOOSE_MIN_SIZE_LOWEST_MAX,
312 CHOOSE_MIN_SIZE_HIGHEST_MAX,
338 CHOOSE_MAX_REGRET_ON_MIN,
348 enum IntValueStrategy {
388 enum EvaluatorStrategy {
393 CHOOSE_STATIC_GLOBAL_BEST,
399 CHOOSE_DYNAMIC_GLOBAL_BEST,
403 enum SequenceStrategy {
406 CHOOSE_MIN_SLACK_RANK_FORWARD,
407 CHOOSE_RANDOM_RANK_FORWARD,
412 enum IntervalStrategy {
419 INTERVAL_SET_TIMES_FORWARD,
422 INTERVAL_SET_TIMES_BACKWARD
427 enum LocalSearchOperators {
565 enum EvaluatorLocalSearchOperators {
593 enum LocalSearchFilterBound {
609 DELAYED_PRIORITY = 0,
620 enum BinaryIntervalRelation {
653 enum UnaryIntervalRelation {
688 enum DecisionModification {
714 enum MarkerType { SENTINEL, SIMPLE_MARKER, CHOICE_POINT, REVERSIBLE_ACTION };
733 enum OptimizationDirection { NOT_SET, MAXIMIZATION, MINIMIZATION };
736 typedef std::function<
int64(
int64)> IndexEvaluator1;
740 typedef std::function<bool(
int64)> IndexFilter1;
742 typedef std::function<IntVar*(
int64)> Int64ToIntVar;
744 typedef std::function<
int64(Solver* solver,
const std::vector<IntVar*>& vars,
746 VariableIndexSelector;
748 typedef std::function<
int64(
const IntVar* v,
int64 id)> VariableValueSelector;
749 typedef std::function<bool(
int64,
int64,
int64)> VariableValueComparator;
750 typedef std::function<DecisionModification()> BranchSelector;
752 typedef std::function<void(Solver*)> Action;
753 typedef std::function<void()> Closure;
756 explicit Solver(
const std::string&
name);
757 Solver(
const std::string&
name,
const ConstraintSolverParameters&
parameters);
761 ConstraintSolverParameters
parameters()
const {
return parameters_; }
764 static ConstraintSolverParameters DefaultSolverParameters();
772 void SaveValue(T* o) {
773 InternalSaveValue(o);
788 template <
typename T>
789 T* RevAlloc(T*
object) {
790 return reinterpret_cast<T*
>(SafeRevAlloc(
object));
799 template <
typename T>
800 T* RevAllocArray(T*
object) {
801 return reinterpret_cast<T*
>(SafeRevAllocArray(
object));
837 void AddConstraint(Constraint*
const c);
841 void AddCastConstraint(CastConstraint*
const constraint,
842 IntVar*
const target_var, IntExpr*
const expr);
885 bool Solve(DecisionBuilder*
const db,
886 const std::vector<SearchMonitor*>& monitors);
887 bool Solve(DecisionBuilder*
const db);
888 bool Solve(DecisionBuilder*
const db, SearchMonitor*
const m1);
889 bool Solve(DecisionBuilder*
const db, SearchMonitor*
const m1,
890 SearchMonitor*
const m2);
891 bool Solve(DecisionBuilder*
const db, SearchMonitor*
const m1,
892 SearchMonitor*
const m2, SearchMonitor*
const m3);
893 bool Solve(DecisionBuilder*
const db, SearchMonitor*
const m1,
894 SearchMonitor*
const m2, SearchMonitor*
const m3,
895 SearchMonitor*
const m4);
907 void NewSearch(DecisionBuilder*
const db,
908 const std::vector<SearchMonitor*>& monitors);
909 void NewSearch(DecisionBuilder*
const db);
910 void NewSearch(DecisionBuilder*
const db, SearchMonitor*
const m1);
911 void NewSearch(DecisionBuilder*
const db, SearchMonitor*
const m1,
912 SearchMonitor*
const m2);
913 void NewSearch(DecisionBuilder*
const db, SearchMonitor*
const m1,
914 SearchMonitor*
const m2, SearchMonitor*
const m3);
915 void NewSearch(DecisionBuilder*
const db, SearchMonitor*
const m1,
916 SearchMonitor*
const m2, SearchMonitor*
const m3,
917 SearchMonitor*
const m4);
920 void RestartSearch();
932 bool SolveAndCommit(DecisionBuilder*
const db,
933 const std::vector<SearchMonitor*>& monitors);
934 bool SolveAndCommit(DecisionBuilder*
const db);
935 bool SolveAndCommit(DecisionBuilder*
const db, SearchMonitor*
const m1);
936 bool SolveAndCommit(DecisionBuilder*
const db, SearchMonitor*
const m1,
937 SearchMonitor*
const m2);
938 bool SolveAndCommit(DecisionBuilder*
const db, SearchMonitor*
const m1,
939 SearchMonitor*
const m2, SearchMonitor*
const m3);
942 bool CheckAssignment(Assignment*
const solution);
947 bool CheckConstraint(Constraint*
const ct);
950 SolverState state()
const {
return state_; }
956 void AddBacktrackAction(Action
a,
bool fast);
963 std::string DebugString()
const;
973 absl::Time Now()
const;
977 int64 wall_time()
const;
980 int64 branches()
const {
return branches_; }
983 int64 solutions()
const;
986 int64 unchecked_solutions()
const;
989 int64 demon_runs(DemonPriority p)
const {
return demon_runs_[p]; }
992 int64 failures()
const {
return fails_; }
995 int64 neighbors()
const {
return neighbors_; }
998 int64 filtered_neighbors()
const {
return filtered_neighbors_; }
1001 int64 accepted_neighbors()
const {
return accepted_neighbors_; }
1008 uint64 fail_stamp()
const;
1011 OptimizationDirection optimization_direction()
const {
1012 return optimization_direction_;
1014 void set_optimization_direction(OptimizationDirection direction) {
1015 optimization_direction_ = direction;
1030 IntVar* MakeIntVar(
const std::vector<int64>& values,
const std::string&
name);
1033 IntVar* MakeIntVar(
const std::vector<int>& values,
const std::string&
name);
1039 IntVar* MakeIntVar(
const std::vector<int64>& values);
1042 IntVar* MakeIntVar(
const std::vector<int>& values);
1045 IntVar* MakeBoolVar(
const std::string&
name);
1048 IntVar* MakeBoolVar();
1051 IntVar* MakeIntConst(
int64 val,
const std::string&
name);
1054 IntVar* MakeIntConst(
int64 val);
1059 void MakeIntVarArray(
int var_count,
int64 vmin,
int64 vmax,
1060 const std::string&
name, std::vector<IntVar*>* vars);
1063 void MakeIntVarArray(
int var_count,
int64 vmin,
int64 vmax,
1064 std::vector<IntVar*>* vars);
1066 IntVar** MakeIntVarArray(
int var_count,
int64 vmin,
int64 vmax,
1067 const std::string&
name);
1072 void MakeBoolVarArray(
int var_count,
const std::string&
name,
1073 std::vector<IntVar*>* vars);
1076 void MakeBoolVarArray(
int var_count, std::vector<IntVar*>* vars);
1078 IntVar** MakeBoolVarArray(
int var_count,
const std::string&
name);
1083 IntExpr* MakeSum(IntExpr*
const left, IntExpr*
const right);
1085 IntExpr* MakeSum(IntExpr*
const expr,
int64 value);
1087 IntExpr* MakeSum(
const std::vector<IntVar*>& vars);
1090 IntExpr* MakeScalProd(
const std::vector<IntVar*>& vars,
1091 const std::vector<int64>& coefs);
1093 IntExpr* MakeScalProd(
const std::vector<IntVar*>& vars,
1094 const std::vector<int>& coefs);
1097 IntExpr* MakeDifference(IntExpr*
const left, IntExpr*
const right);
1099 IntExpr* MakeDifference(
int64 value, IntExpr*
const expr);
1101 IntExpr* MakeOpposite(IntExpr*
const expr);
1104 IntExpr* MakeProd(IntExpr*
const left, IntExpr*
const right);
1106 IntExpr* MakeProd(IntExpr*
const expr,
int64 value);
1109 IntExpr* MakeDiv(IntExpr*
const expr,
int64 value);
1111 IntExpr* MakeDiv(IntExpr*
const numerator, IntExpr*
const denominator);
1114 IntExpr* MakeAbs(IntExpr*
const expr);
1116 IntExpr* MakeSquare(IntExpr*
const expr);
1118 IntExpr* MakePower(IntExpr*
const expr,
int64 n);
1121 IntExpr* MakeElement(
const std::vector<int64>& values, IntVar*
const index);
1123 IntExpr* MakeElement(
const std::vector<int>& values, IntVar*
const index);
1128 IntExpr* MakeElement(IndexEvaluator1 values, IntVar*
const index);
1135 IntExpr* MakeMonotonicElement(IndexEvaluator1 values,
bool increasing,
1136 IntVar*
const index);
1138 IntExpr* MakeElement(IndexEvaluator2 values, IntVar*
const index1,
1139 IntVar*
const index2);
1142 IntExpr* MakeElement(
const std::vector<IntVar*>& vars, IntVar*
const index);
1145 IntExpr* MakeElement(Int64ToIntVar vars,
int64 range_start,
int64 range_end,
1152 IntExpr* MakeIndexExpression(
const std::vector<IntVar*>& vars,
int64 value);
1155 Constraint* MakeIfThenElseCt(IntVar*
const condition,
1156 IntExpr*
const then_expr,
1157 IntExpr*
const else_expr,
1158 IntVar*
const target_var);
1161 IntExpr* MakeMin(
const std::vector<IntVar*>& vars);
1163 IntExpr* MakeMin(IntExpr*
const left, IntExpr*
const right);
1165 IntExpr* MakeMin(IntExpr*
const expr,
int64 value);
1167 IntExpr* MakeMin(IntExpr*
const expr,
int value);
1170 IntExpr* MakeMax(
const std::vector<IntVar*>& vars);
1172 IntExpr* MakeMax(IntExpr*
const left, IntExpr*
const right);
1174 IntExpr* MakeMax(IntExpr*
const expr,
int64 value);
1176 IntExpr* MakeMax(IntExpr*
const expr,
int value);
1179 IntExpr* MakeConvexPiecewiseExpr(IntExpr* expr,
int64 early_cost,
1185 IntExpr* MakeSemiContinuousExpr(IntExpr*
const expr,
int64 fixed_charge,
1193 IntExpr* MakePiecewiseLinearExpr(IntExpr* expr,
1194 const PiecewiseLinearFunction& f);
1198 IntExpr* MakeModulo(IntExpr*
const x,
int64 mod);
1201 IntExpr* MakeModulo(IntExpr*
const x, IntExpr*
const mod);
1204 IntExpr* MakeConditionalExpression(IntVar*
const condition,
1205 IntExpr*
const expr,
1206 int64 unperformed_value);
1209 Constraint* MakeTrueConstraint();
1211 Constraint* MakeFalseConstraint();
1212 Constraint* MakeFalseConstraint(
const std::string& explanation);
1215 Constraint* MakeIsEqualCstCt(IntExpr*
const var,
int64 value,
1216 IntVar*
const boolvar);
1220 Constraint* MakeIsEqualCt(IntExpr*
const v1, IntExpr* v2, IntVar*
const b);
1222 IntVar* MakeIsEqualVar(IntExpr*
const v1, IntExpr* v2);
1224 Constraint* MakeEquality(IntExpr*
const left, IntExpr*
const right);
1226 Constraint* MakeEquality(IntExpr*
const expr,
int64 value);
1228 Constraint* MakeEquality(IntExpr*
const expr,
int value);
1231 Constraint* MakeIsDifferentCstCt(IntExpr*
const var,
int64 value,
1232 IntVar*
const boolvar);
1234 IntVar* MakeIsDifferentCstVar(IntExpr*
const var,
int64 value);
1236 IntVar* MakeIsDifferentVar(IntExpr*
const v1, IntExpr*
const v2);
1238 Constraint* MakeIsDifferentCt(IntExpr*
const v1, IntExpr*
const v2,
1241 Constraint* MakeNonEquality(IntExpr*
const left, IntExpr*
const right);
1243 Constraint* MakeNonEquality(IntExpr*
const expr,
int64 value);
1245 Constraint* MakeNonEquality(IntExpr*
const expr,
int value);
1248 Constraint* MakeIsLessOrEqualCstCt(IntExpr*
const var,
int64 value,
1249 IntVar*
const boolvar);
1251 IntVar* MakeIsLessOrEqualCstVar(IntExpr*
const var,
int64 value);
1253 IntVar* MakeIsLessOrEqualVar(IntExpr*
const left, IntExpr*
const right);
1255 Constraint* MakeIsLessOrEqualCt(IntExpr*
const left, IntExpr*
const right,
1258 Constraint* MakeLessOrEqual(IntExpr*
const left, IntExpr*
const right);
1260 Constraint* MakeLessOrEqual(IntExpr*
const expr,
int64 value);
1262 Constraint* MakeLessOrEqual(IntExpr*
const expr,
int value);
1265 Constraint* MakeIsGreaterOrEqualCstCt(IntExpr*
const var,
int64 value,
1266 IntVar*
const boolvar);
1268 IntVar* MakeIsGreaterOrEqualCstVar(IntExpr*
const var,
int64 value);
1270 IntVar* MakeIsGreaterOrEqualVar(IntExpr*
const left, IntExpr*
const right);
1272 Constraint* MakeIsGreaterOrEqualCt(IntExpr*
const left, IntExpr*
const right,
1275 Constraint* MakeGreaterOrEqual(IntExpr*
const left, IntExpr*
const right);
1277 Constraint* MakeGreaterOrEqual(IntExpr*
const expr,
int64 value);
1279 Constraint* MakeGreaterOrEqual(IntExpr*
const expr,
int value);
1282 Constraint* MakeIsGreaterCstCt(IntExpr*
const v,
int64 c, IntVar*
const b);
1284 IntVar* MakeIsGreaterCstVar(IntExpr*
const var,
int64 value);
1286 IntVar* MakeIsGreaterVar(IntExpr*
const left, IntExpr*
const right);
1288 Constraint* MakeIsGreaterCt(IntExpr*
const left, IntExpr*
const right,
1291 Constraint* MakeGreater(IntExpr*
const left, IntExpr*
const right);
1293 Constraint* MakeGreater(IntExpr*
const expr,
int64 value);
1295 Constraint* MakeGreater(IntExpr*
const expr,
int value);
1298 Constraint* MakeIsLessCstCt(IntExpr*
const v,
int64 c, IntVar*
const b);
1302 IntVar* MakeIsLessVar(IntExpr*
const left, IntExpr*
const right);
1304 Constraint* MakeIsLessCt(IntExpr*
const left, IntExpr*
const right,
1307 Constraint* MakeLess(IntExpr*
const left, IntExpr*
const right);
1309 Constraint* MakeLess(IntExpr*
const expr,
int64 value);
1311 Constraint* MakeLess(IntExpr*
const expr,
int value);
1314 Constraint* MakeSumLessOrEqual(
const std::vector<IntVar*>& vars,
int64 cst);
1315 Constraint* MakeSumGreaterOrEqual(
const std::vector<IntVar*>& vars,
1317 Constraint* MakeSumEquality(
const std::vector<IntVar*>& vars,
int64 cst);
1318 Constraint* MakeSumEquality(
const std::vector<IntVar*>& vars,
1320 Constraint* MakeScalProdEquality(
const std::vector<IntVar*>& vars,
1323 Constraint* MakeScalProdEquality(
const std::vector<IntVar*>& vars,
1326 Constraint* MakeScalProdEquality(
const std::vector<IntVar*>& vars,
1328 IntVar*
const target);
1329 Constraint* MakeScalProdEquality(
const std::vector<IntVar*>& vars,
1331 IntVar*
const target);
1332 Constraint* MakeScalProdGreaterOrEqual(
const std::vector<IntVar*>& vars,
1333 const std::vector<int64>& coeffs,
1335 Constraint* MakeScalProdGreaterOrEqual(
const std::vector<IntVar*>& vars,
1336 const std::vector<int>& coeffs,
1338 Constraint* MakeScalProdLessOrEqual(
const std::vector<IntVar*>& vars,
1341 Constraint* MakeScalProdLessOrEqual(
const std::vector<IntVar*>& vars,
1345 Constraint* MakeMinEquality(
const std::vector<IntVar*>& vars,
1346 IntVar*
const min_var);
1347 Constraint* MakeMaxEquality(
const std::vector<IntVar*>& vars,
1348 IntVar*
const max_var);
1350 Constraint* MakeElementEquality(
const std::vector<int64>& vals,
1351 IntVar*
const index, IntVar*
const target);
1352 Constraint* MakeElementEquality(
const std::vector<int>& vals,
1353 IntVar*
const index, IntVar*
const target);
1354 Constraint* MakeElementEquality(
const std::vector<IntVar*>& vars,
1355 IntVar*
const index, IntVar*
const target);
1356 Constraint* MakeElementEquality(
const std::vector<IntVar*>& vars,
1359 Constraint* MakeAbsEquality(IntVar*
const var, IntVar*
const abs_var);
1364 Constraint* MakeIndexOfConstraint(
const std::vector<IntVar*>& vars,
1369 Demon* MakeConstraintInitialPropagateCallback(Constraint*
const ct);
1373 Demon* MakeDelayedConstraintInitialPropagateCallback(Constraint*
const ct);
1375 Demon* MakeActionDemon(Action action);
1378 Demon* MakeClosureDemon(Closure closure);
1384 Constraint* MakeBetweenCt(IntExpr*
const expr,
int64 l,
int64 u);
1390 Constraint* MakeNotBetweenCt(IntExpr*
const expr,
int64 l,
int64 u);
1393 Constraint* MakeIsBetweenCt(IntExpr*
const expr,
int64 l,
int64 u,
1395 IntVar* MakeIsBetweenVar(IntExpr*
const v,
int64 l,
int64 u);
1401 Constraint* MakeMemberCt(IntExpr*
const expr,
1402 const std::vector<int64>& values);
1403 Constraint* MakeMemberCt(IntExpr*
const expr,
const std::vector<int>& values);
1406 Constraint* MakeNotMemberCt(IntExpr*
const expr,
1407 const std::vector<int64>& values);
1408 Constraint* MakeNotMemberCt(IntExpr*
const expr,
1409 const std::vector<int>& values);
1412 Constraint* MakeNotMemberCt(IntExpr*
const expr, std::vector<int64> starts,
1413 std::vector<int64> ends);
1415 Constraint* MakeNotMemberCt(IntExpr*
const expr, std::vector<int> starts,
1416 std::vector<int> ends);
1418 Constraint* MakeNotMemberCt(IntExpr* expr,
1420 SortedDisjointIntervalList intervals);
1421 #endif // !defined(SWIG)
1424 Constraint* MakeIsMemberCt(IntExpr*
const expr,
1425 const std::vector<int64>& values,
1426 IntVar*
const boolvar);
1427 Constraint* MakeIsMemberCt(IntExpr*
const expr,
1428 const std::vector<int>& values,
1429 IntVar*
const boolvar);
1430 IntVar* MakeIsMemberVar(IntExpr*
const expr,
1431 const std::vector<int64>& values);
1432 IntVar* MakeIsMemberVar(IntExpr*
const expr,
const std::vector<int>& values);
1435 Constraint* MakeAtMost(std::vector<IntVar*> vars,
int64 value,
1438 Constraint* MakeCount(
const std::vector<IntVar*>& vars,
int64 value,
1441 Constraint* MakeCount(
const std::vector<IntVar*>& vars,
int64 value,
1442 IntVar*
const max_count);
1445 Constraint* MakeDistribute(
const std::vector<IntVar*>& vars,
1446 const std::vector<int64>& values,
1447 const std::vector<IntVar*>& cards);
1449 Constraint* MakeDistribute(
const std::vector<IntVar*>& vars,
1450 const std::vector<int>& values,
1451 const std::vector<IntVar*>& cards);
1453 Constraint* MakeDistribute(
const std::vector<IntVar*>& vars,
1454 const std::vector<IntVar*>& cards);
1457 Constraint* MakeDistribute(
const std::vector<IntVar*>& vars,
int64 card_min,
1462 Constraint* MakeDistribute(
const std::vector<IntVar*>& vars,
1463 const std::vector<int64>& card_min,
1464 const std::vector<int64>& card_max);
1468 Constraint* MakeDistribute(
const std::vector<IntVar*>& vars,
1469 const std::vector<int>& card_min,
1470 const std::vector<int>& card_max);
1474 Constraint* MakeDistribute(
const std::vector<IntVar*>& vars,
1475 const std::vector<int64>& values,
1476 const std::vector<int64>& card_min,
1477 const std::vector<int64>& card_max);
1481 Constraint* MakeDistribute(
const std::vector<IntVar*>& vars,
1482 const std::vector<int>& values,
1483 const std::vector<int>& card_min,
1484 const std::vector<int>& card_max);
1490 Constraint* MakeDeviation(
const std::vector<IntVar*>& vars,
1491 IntVar*
const deviation_var,
int64 total_sum);
1495 Constraint* MakeAllDifferent(
const std::vector<IntVar*>& vars);
1500 Constraint* MakeAllDifferent(
const std::vector<IntVar*>& vars,
1501 bool stronger_propagation);
1505 Constraint* MakeAllDifferentExcept(
const std::vector<IntVar*>& vars,
1506 int64 escape_value);
1524 Constraint* MakeSortingConstraint(
const std::vector<IntVar*>& vars,
1525 const std::vector<IntVar*>& sorted);
1532 Constraint* MakeLexicalLess(
const std::vector<IntVar*>& left,
1533 const std::vector<IntVar*>& right);
1537 Constraint* MakeLexicalLessOrEqual(
const std::vector<IntVar*>& left,
1538 const std::vector<IntVar*>& right);
1544 Constraint* MakeInversePermutationConstraint(
1545 const std::vector<IntVar*>& left,
const std::vector<IntVar*>& right);
1549 Constraint* MakeIndexOfFirstMaxValueConstraint(
1550 IntVar*
index,
const std::vector<IntVar*>& vars);
1554 Constraint* MakeIndexOfFirstMinValueConstraint(
1555 IntVar*
index,
const std::vector<IntVar*>& vars);
1561 Constraint* MakeNullIntersect(
const std::vector<IntVar*>& first_vars,
1562 const std::vector<IntVar*>& second_vars);
1569 Constraint* MakeNullIntersectExcept(
const std::vector<IntVar*>& first_vars,
1570 const std::vector<IntVar*>& second_vars,
1571 int64 escape_value);
1585 Constraint* MakeNoCycle(
const std::vector<IntVar*>& nexts,
1586 const std::vector<IntVar*>& active,
1587 IndexFilter1 sink_handler =
nullptr);
1588 Constraint* MakeNoCycle(
const std::vector<IntVar*>& nexts,
1589 const std::vector<IntVar*>& active,
1590 IndexFilter1 sink_handler,
bool assume_paths);
1593 Constraint* MakeCircuit(
const std::vector<IntVar*>& nexts);
1597 Constraint* MakeSubCircuit(
const std::vector<IntVar*>& nexts);
1603 Constraint* MakePathCumul(
const std::vector<IntVar*>& nexts,
1604 const std::vector<IntVar*>& active,
1605 const std::vector<IntVar*>& cumuls,
1606 const std::vector<IntVar*>& transits);
1610 Constraint* MakeDelayedPathCumul(
const std::vector<IntVar*>& nexts,
1611 const std::vector<IntVar*>& active,
1612 const std::vector<IntVar*>& cumuls,
1613 const std::vector<IntVar*>& transits);
1620 Constraint* MakePathCumul(
const std::vector<IntVar*>& nexts,
1621 const std::vector<IntVar*>& active,
1622 const std::vector<IntVar*>& cumuls,
1623 IndexEvaluator2 transit_evaluator);
1631 Constraint* MakePathCumul(
const std::vector<IntVar*>& nexts,
1632 const std::vector<IntVar*>& active,
1633 const std::vector<IntVar*>& cumuls,
1634 const std::vector<IntVar*>& slacks,
1635 IndexEvaluator2 transit_evaluator);
1640 Constraint* MakePathConnected(std::vector<IntVar*> nexts,
1641 std::vector<int64> sources,
1642 std::vector<int64> sinks,
1643 std::vector<IntVar*> status);
1650 Constraint* MakePathPrecedenceConstraint(
1651 std::vector<IntVar*> nexts,
1652 const std::vector<std::pair<int, int>>& precedences);
1661 Constraint* MakePathPrecedenceConstraint(
1662 std::vector<IntVar*> nexts,
1663 const std::vector<std::pair<int, int>>& precedences,
1664 const std::vector<int>& lifo_path_starts,
1665 const std::vector<int>& fifo_path_starts);
1668 Constraint* MakePathTransitPrecedenceConstraint(
1669 std::vector<IntVar*> nexts, std::vector<IntVar*> transits,
1670 const std::vector<std::pair<int, int>>& precedences);
1672 Constraint* MakeMapDomain(IntVar*
const var,
1676 const std::vector<IntVar*>& actives);
1682 Constraint* MakeAllowedAssignments(
const std::vector<IntVar*>& vars,
1683 const IntTupleSet& tuples);
1692 Constraint* MakeTransitionConstraint(
const std::vector<IntVar*>& vars,
1693 const IntTupleSet& transition_table,
1694 int64 initial_state,
1695 const std::vector<int64>& final_states);
1704 Constraint* MakeTransitionConstraint(
const std::vector<IntVar*>& vars,
1705 const IntTupleSet& transition_table,
1706 int64 initial_state,
1707 const std::vector<int>& final_states);
1709 #if defined(SWIGPYTHON)
1710 Constraint* MakeAllowedAssignments(
1712 const std::vector<IntVar*>& vars,
1713 const std::vector<std::vector<int64>>& raw_tuples) {
1714 IntTupleSet tuples(vars.size());
1715 tuples.InsertAll(raw_tuples);
1716 return MakeAllowedAssignments(vars, tuples);
1719 Constraint* MakeTransitionConstraint(
1720 const std::vector<IntVar*>& vars,
1721 const std::vector<std::vector<int64>>& raw_transitions,
1722 int64 initial_state,
const std::vector<int>& final_states) {
1723 IntTupleSet transitions(3);
1724 transitions.InsertAll(raw_transitions);
1725 return MakeTransitionConstraint(vars, transitions, initial_state,
1738 Constraint* MakeNonOverlappingBoxesConstraint(
1739 const std::vector<IntVar*>& x_vars,
const std::vector<IntVar*>& y_vars,
1740 const std::vector<IntVar*>& x_size,
const std::vector<IntVar*>& y_size);
1741 Constraint* MakeNonOverlappingBoxesConstraint(
1742 const std::vector<IntVar*>& x_vars,
const std::vector<IntVar*>& y_vars,
1743 const std::vector<int64>& x_size,
const std::vector<int64>& y_size);
1744 Constraint* MakeNonOverlappingBoxesConstraint(
1745 const std::vector<IntVar*>& x_vars,
const std::vector<IntVar*>& y_vars,
1746 const std::vector<int>& x_size,
const std::vector<int>& y_size);
1756 Constraint* MakeNonOverlappingNonStrictBoxesConstraint(
1757 const std::vector<IntVar*>& x_vars,
const std::vector<IntVar*>& y_vars,
1758 const std::vector<IntVar*>& x_size,
const std::vector<IntVar*>& y_size);
1759 Constraint* MakeNonOverlappingNonStrictBoxesConstraint(
1760 const std::vector<IntVar*>& x_vars,
const std::vector<IntVar*>& y_vars,
1761 const std::vector<int64>& x_size,
const std::vector<int64>& y_size);
1762 Constraint* MakeNonOverlappingNonStrictBoxesConstraint(
1763 const std::vector<IntVar*>& x_vars,
const std::vector<IntVar*>& y_vars,
1764 const std::vector<int>& x_size,
const std::vector<int>& y_size);
1771 Pack* MakePack(
const std::vector<IntVar*>& vars,
int number_of_bins);
1778 int64 duration,
bool optional,
1779 const std::string&
name);
1783 void MakeFixedDurationIntervalVarArray(
1785 bool optional,
const std::string&
name,
1786 std::vector<IntervalVar*>*
const array);
1790 IntervalVar* MakeFixedDurationIntervalVar(IntVar*
const start_variable,
1792 const std::string&
name);
1796 IntervalVar* MakeFixedDurationIntervalVar(IntVar*
const start_variable,
1798 IntVar*
const performed_variable,
1799 const std::string&
name);
1803 void MakeFixedDurationIntervalVarArray(
1804 const std::vector<IntVar*>& start_variables,
int64 duration,
1805 const std::string&
name, std::vector<IntervalVar*>*
const array);
1809 void MakeFixedDurationIntervalVarArray(
1810 const std::vector<IntVar*>& start_variables,
1811 const std::vector<int64>& durations,
const std::string&
name,
1812 std::vector<IntervalVar*>*
const array);
1815 void MakeFixedDurationIntervalVarArray(
1816 const std::vector<IntVar*>& start_variables,
1817 const std::vector<int>& durations,
const std::string&
name,
1818 std::vector<IntervalVar*>*
const array);
1822 void MakeFixedDurationIntervalVarArray(
1823 const std::vector<IntVar*>& start_variables,
1824 const std::vector<int64>& durations,
1825 const std::vector<IntVar*>& performed_variables,
const std::string&
name,
1826 std::vector<IntervalVar*>*
const array);
1830 void MakeFixedDurationIntervalVarArray(
1831 const std::vector<IntVar*>& start_variables,
1832 const std::vector<int>& durations,
1833 const std::vector<IntVar*>& performed_variables,
const std::string&
name,
1834 std::vector<IntervalVar*>*
const array);
1837 IntervalVar* MakeFixedInterval(
int64 start,
int64 duration,
1838 const std::string&
name);
1845 const std::string&
name);
1852 const std::string&
name,
1853 std::vector<IntervalVar*>*
const array);
1857 IntervalVar* MakeMirrorInterval(IntervalVar*
const interval_var);
1863 IntervalVar* MakeFixedDurationStartSyncedOnStartIntervalVar(
1864 IntervalVar*
const interval_var,
int64 duration,
int64 offset);
1870 IntervalVar* MakeFixedDurationStartSyncedOnEndIntervalVar(
1871 IntervalVar*
const interval_var,
int64 duration,
int64 offset);
1877 IntervalVar* MakeFixedDurationEndSyncedOnStartIntervalVar(
1878 IntervalVar*
const interval_var,
int64 duration,
int64 offset);
1884 IntervalVar* MakeFixedDurationEndSyncedOnEndIntervalVar(
1885 IntervalVar*
const interval_var,
int64 duration,
int64 offset);
1904 IntervalVar* MakeIntervalRelaxedMin(IntervalVar*
const interval_var);
1923 IntervalVar* MakeIntervalRelaxedMax(IntervalVar*
const interval_var);
1927 Constraint* MakeIntervalVarRelation(IntervalVar*
const t,
1928 UnaryIntervalRelation r,
int64 d);
1931 Constraint* MakeIntervalVarRelation(IntervalVar*
const t1,
1932 BinaryIntervalRelation r,
1933 IntervalVar*
const t2);
1939 Constraint* MakeIntervalVarRelationWithDelay(IntervalVar*
const t1,
1940 BinaryIntervalRelation r,
1941 IntervalVar*
const t2,
1947 Constraint* MakeTemporalDisjunction(IntervalVar*
const t1,
1948 IntervalVar*
const t2, IntVar*
const alt);
1952 Constraint* MakeTemporalDisjunction(IntervalVar*
const t1,
1953 IntervalVar*
const t2);
1957 DisjunctiveConstraint* MakeDisjunctiveConstraint(
1958 const std::vector<IntervalVar*>& intervals,
const std::string&
name);
1963 DisjunctiveConstraint* MakeStrictDisjunctiveConstraint(
1964 const std::vector<IntervalVar*>& intervals,
const std::string&
name);
1975 Constraint* MakeCumulative(
const std::vector<IntervalVar*>& intervals,
1977 const std::string&
name);
1988 Constraint* MakeCumulative(
const std::vector<IntervalVar*>& intervals,
1990 const std::string&
name);
2001 Constraint* MakeCumulative(
const std::vector<IntervalVar*>& intervals,
2002 const std::vector<int64>& demands,
2014 Constraint* MakeCumulative(
const std::vector<IntervalVar*>& intervals,
2015 const std::vector<int>& demands,
2025 Constraint* MakeCumulative(
const std::vector<IntervalVar*>& intervals,
2026 const std::vector<IntVar*>& demands,
2036 Constraint* MakeCumulative(
const std::vector<IntervalVar*>& intervals,
2037 const std::vector<IntVar*>& demands,
2045 Constraint* MakeCover(
const std::vector<IntervalVar*>& vars,
2046 IntervalVar*
const target_var);
2049 Constraint* MakeEquality(IntervalVar*
const var1, IntervalVar*
const var2);
2052 Assignment* MakeAssignment();
2055 Assignment* MakeAssignment(
const Assignment*
const a);
2058 SolutionCollector* MakeFirstSolutionCollector(
2059 const Assignment*
const assignment);
2062 SolutionCollector* MakeFirstSolutionCollector();
2065 SolutionCollector* MakeLastSolutionCollector(
2066 const Assignment*
const assignment);
2069 SolutionCollector* MakeLastSolutionCollector();
2075 SolutionCollector* MakeBestValueSolutionCollector(
2076 const Assignment*
const assignment,
bool maximize);
2082 SolutionCollector* MakeBestValueSolutionCollector(
bool maximize);
2087 SolutionCollector* MakeNBestValueSolutionCollector(
2088 const Assignment*
const assignment,
int solution_count,
bool maximize);
2089 SolutionCollector* MakeNBestValueSolutionCollector(
int solution_count,
2093 SolutionCollector* MakeAllSolutionCollector(
2094 const Assignment*
const assignment);
2097 SolutionCollector* MakeAllSolutionCollector();
2100 OptimizeVar* MakeMinimize(IntVar*
const v,
int64 step);
2103 OptimizeVar* MakeMaximize(IntVar*
const v,
int64 step);
2106 OptimizeVar* MakeOptimize(
bool maximize, IntVar*
const v,
int64 step);
2110 OptimizeVar* MakeWeightedMinimize(
const std::vector<IntVar*>& sub_objectives,
2111 const std::vector<int64>& weights,
2116 OptimizeVar* MakeWeightedMinimize(
const std::vector<IntVar*>& sub_objectives,
2117 const std::vector<int>& weights,
2121 OptimizeVar* MakeWeightedMaximize(
const std::vector<IntVar*>& sub_objectives,
2122 const std::vector<int64>& weights,
2126 OptimizeVar* MakeWeightedMaximize(
const std::vector<IntVar*>& sub_objectives,
2127 const std::vector<int>& weights,
2131 OptimizeVar* MakeWeightedOptimize(
bool maximize,
2132 const std::vector<IntVar*>& sub_objectives,
2133 const std::vector<int64>& weights,
2137 OptimizeVar* MakeWeightedOptimize(
bool maximize,
2138 const std::vector<IntVar*>& sub_objectives,
2139 const std::vector<int>& weights,
2160 SearchMonitor* MakeTabuSearch(
bool maximize, IntVar*
const v,
int64 step,
2161 const std::vector<IntVar*>& vars,
2163 double tabu_factor);
2167 SearchMonitor* MakeGenericTabuSearch(
bool maximize, IntVar*
const v,
2169 const std::vector<IntVar*>& tabu_vars,
2170 int64 forbid_tenure);
2174 SearchMonitor* MakeSimulatedAnnealing(
bool maximize, IntVar*
const v,
2179 SearchMonitor* MakeGuidedLocalSearch(
bool maximize, IntVar*
const objective,
2180 IndexEvaluator2 objective_function,
2182 const std::vector<IntVar*>& vars,
2183 double penalty_factor);
2184 SearchMonitor* MakeGuidedLocalSearch(
2185 bool maximize, IntVar*
const objective,
2186 IndexEvaluator3 objective_function,
int64 step,
2187 const std::vector<IntVar*>& vars,
2188 const std::vector<IntVar*>& secondary_vars,
double penalty_factor);
2193 SearchMonitor* MakeLubyRestart(
int scale_factor);
2197 SearchMonitor* MakeConstantRestart(
int frequency);
2200 RegularLimit* MakeTimeLimit(absl::Duration
time);
2203 ABSL_DEPRECATED(
"Use the version taking absl::Duration() as argument")
2205 RegularLimit* MakeTimeLimit(
int64 time_in_ms) {
2206 return MakeTimeLimit(time_in_ms ==
kint64max
2207 ? absl::InfiniteDuration()
2208 : absl::Milliseconds(time_in_ms));
2213 RegularLimit* MakeBranchesLimit(
int64 branches);
2217 RegularLimit* MakeFailuresLimit(
int64 failures);
2221 RegularLimit* MakeSolutionsLimit(
int64 solutions);
2227 RegularLimit* MakeLimit(absl::Duration
time,
int64 branches,
int64 failures,
2228 int64 solutions,
bool smart_time_check =
false,
2229 bool cumulative =
false);
2231 RegularLimit* MakeLimit(
const RegularLimitParameters&
proto);
2234 ABSL_DEPRECATED(
"Use other MakeLimit() versions")
2237 int64 solutions,
bool smart_time_check =
false,
2238 bool cumulative =
false);
2241 RegularLimitParameters MakeDefaultRegularLimitParameters()
const;
2246 SearchLimit* MakeLimit(SearchLimit*
const limit_1,
2247 SearchLimit*
const limit_2);
2251 SearchLimit* MakeCustomLimit(std::function<
bool()> limiter);
2257 SearchMonitor* MakeSearchLog(
int branch_period);
2260 SearchMonitor* MakeSearchLog(
int branch_period, IntVar*
const var);
2264 SearchMonitor* MakeSearchLog(
int branch_period,
2265 std::function<std::string()> display_callback);
2269 SearchMonitor* MakeSearchLog(
int branch_period, IntVar*
var,
2270 std::function<std::string()> display_callback);
2274 SearchMonitor* MakeSearchLog(
int branch_period, OptimizeVar*
const opt_var);
2278 SearchMonitor* MakeSearchLog(
int branch_period, OptimizeVar*
const opt_var,
2279 std::function<std::string()> display_callback);
2282 struct SearchLogParameters {
2285 int branch_period = 1;
2288 OptimizeVar* objective =
nullptr;
2289 IntVar* variable =
nullptr;
2293 double scaling_factor = 1.0;
2297 std::function<std::string()> display_callback;
2299 SearchMonitor* MakeSearchLog(SearchLogParameters
parameters);
2303 SearchMonitor* MakeSearchTrace(
const std::string& prefix);
2306 SearchMonitor* MakeEnterSearchCallback(std::function<
void()>
callback);
2307 SearchMonitor* MakeExitSearchCallback(std::function<
void()>
callback);
2308 SearchMonitor* MakeAtSolutionCallback(std::function<
void()>
callback);
2311 ModelVisitor* MakePrintModelVisitor();
2313 ModelVisitor* MakeStatisticsModelVisitor();
2315 ModelVisitor* MakeVariableDegreeVisitor(
2317 absl::flat_hash_map<const IntVar*, int>*
const map);
2318 #endif // !defined(SWIG)
2321 SearchMonitor* MakeSymmetryManager(
2322 const std::vector<SymmetryBreaker*>& visitors);
2323 SearchMonitor* MakeSymmetryManager(SymmetryBreaker*
const v1);
2324 SearchMonitor* MakeSymmetryManager(SymmetryBreaker*
const v1,
2325 SymmetryBreaker*
const v2);
2326 SearchMonitor* MakeSymmetryManager(SymmetryBreaker*
const v1,
2327 SymmetryBreaker*
const v2,
2328 SymmetryBreaker*
const v3);
2329 SearchMonitor* MakeSymmetryManager(SymmetryBreaker*
const v1,
2330 SymmetryBreaker*
const v2,
2331 SymmetryBreaker*
const v3,
2332 SymmetryBreaker*
const v4);
2335 Decision* MakeAssignVariableValue(IntVar*
const var,
int64 val);
2336 Decision* MakeVariableLessOrEqualValue(IntVar*
const var,
int64 value);
2337 Decision* MakeVariableGreaterOrEqualValue(IntVar*
const var,
int64 value);
2338 Decision* MakeSplitVariableDomain(IntVar*
const var,
int64 val,
2339 bool start_with_lower_half);
2340 Decision* MakeAssignVariableValueOrFail(IntVar*
const var,
int64 value);
2341 Decision* MakeAssignVariableValueOrDoNothing(IntVar*
const var,
int64 value);
2342 Decision* MakeAssignVariablesValues(
const std::vector<IntVar*>& vars,
2343 const std::vector<int64>& values);
2344 Decision* MakeFailDecision();
2345 Decision* MakeDecision(Action apply, Action refute);
2355 DecisionBuilder* Compose(DecisionBuilder*
const db1,
2356 DecisionBuilder*
const db2);
2357 DecisionBuilder* Compose(DecisionBuilder*
const db1,
2358 DecisionBuilder*
const db2,
2359 DecisionBuilder*
const db3);
2360 DecisionBuilder* Compose(DecisionBuilder*
const db1,
2361 DecisionBuilder*
const db2,
2362 DecisionBuilder*
const db3,
2363 DecisionBuilder*
const db4);
2364 DecisionBuilder* Compose(
const std::vector<DecisionBuilder*>& dbs);
2382 DecisionBuilder* Try(DecisionBuilder*
const db1, DecisionBuilder*
const db2);
2383 DecisionBuilder* Try(DecisionBuilder*
const db1, DecisionBuilder*
const db2,
2384 DecisionBuilder*
const db3);
2385 DecisionBuilder* Try(DecisionBuilder*
const db1, DecisionBuilder*
const db2,
2386 DecisionBuilder*
const db3, DecisionBuilder*
const db4);
2387 DecisionBuilder* Try(
const std::vector<DecisionBuilder*>& dbs);
2392 DecisionBuilder* MakePhase(
const std::vector<IntVar*>& vars,
2393 IntVarStrategy var_str, IntValueStrategy val_str);
2394 DecisionBuilder* MakePhase(
const std::vector<IntVar*>& vars,
2395 IndexEvaluator1 var_evaluator,
2396 IntValueStrategy val_str);
2398 DecisionBuilder* MakePhase(
const std::vector<IntVar*>& vars,
2399 IntVarStrategy var_str,
2400 IndexEvaluator2 value_evaluator);
2404 DecisionBuilder* MakePhase(
const std::vector<IntVar*>& vars,
2405 IntVarStrategy var_str,
2406 VariableValueComparator var_val1_val2_comparator);
2408 DecisionBuilder* MakePhase(
const std::vector<IntVar*>& vars,
2409 IndexEvaluator1 var_evaluator,
2410 IndexEvaluator2 value_evaluator);
2412 DecisionBuilder* MakePhase(
const std::vector<IntVar*>& vars,
2413 IntVarStrategy var_str,
2414 IndexEvaluator2 value_evaluator,
2415 IndexEvaluator1 tie_breaker);
2417 DecisionBuilder* MakePhase(
const std::vector<IntVar*>& vars,
2418 IndexEvaluator1 var_evaluator,
2419 IndexEvaluator2 value_evaluator,
2420 IndexEvaluator1 tie_breaker);
2422 DecisionBuilder* MakeDefaultPhase(
const std::vector<IntVar*>& vars);
2423 DecisionBuilder* MakeDefaultPhase(
const std::vector<IntVar*>& vars,
2427 DecisionBuilder* MakePhase(IntVar*
const v0, IntVarStrategy var_str,
2428 IntValueStrategy val_str);
2429 DecisionBuilder* MakePhase(IntVar*
const v0, IntVar*
const v1,
2430 IntVarStrategy var_str, IntValueStrategy val_str);
2431 DecisionBuilder* MakePhase(IntVar*
const v0, IntVar*
const v1,
2432 IntVar*
const v2, IntVarStrategy var_str,
2433 IntValueStrategy val_str);
2434 DecisionBuilder* MakePhase(IntVar*
const v0, IntVar*
const v1,
2435 IntVar*
const v2, IntVar*
const v3,
2436 IntVarStrategy var_str, IntValueStrategy val_str);
2443 Decision* MakeScheduleOrPostpone(IntervalVar*
const var,
int64 est,
2444 int64*
const marker);
2451 Decision* MakeScheduleOrExpedite(IntervalVar*
const var,
int64 est,
2452 int64*
const marker);
2456 Decision* MakeRankFirstInterval(SequenceVar*
const sequence,
int index);
2460 Decision* MakeRankLastInterval(SequenceVar*
const sequence,
int index);
2467 DecisionBuilder* MakePhase(
const std::vector<IntVar*>& vars,
2468 IndexEvaluator2 eval, EvaluatorStrategy str);
2477 DecisionBuilder* MakePhase(
const std::vector<IntVar*>& vars,
2478 IndexEvaluator2 eval, IndexEvaluator1 tie_breaker,
2479 EvaluatorStrategy str);
2482 DecisionBuilder* MakePhase(
const std::vector<IntervalVar*>& intervals,
2483 IntervalStrategy str);
2485 DecisionBuilder* MakePhase(
const std::vector<SequenceVar*>& sequences,
2486 SequenceStrategy str);
2490 DecisionBuilder* MakeDecisionBuilderFromAssignment(
2491 Assignment*
const assignment, DecisionBuilder*
const db,
2492 const std::vector<IntVar*>& vars);
2496 DecisionBuilder* MakeConstraintAdder(Constraint*
const ct);
2502 DecisionBuilder* MakeSolveOnce(DecisionBuilder*
const db);
2503 DecisionBuilder* MakeSolveOnce(DecisionBuilder*
const db,
2504 SearchMonitor*
const monitor1);
2505 DecisionBuilder* MakeSolveOnce(DecisionBuilder*
const db,
2506 SearchMonitor*
const monitor1,
2507 SearchMonitor*
const monitor2);
2508 DecisionBuilder* MakeSolveOnce(DecisionBuilder*
const db,
2509 SearchMonitor*
const monitor1,
2510 SearchMonitor*
const monitor2,
2511 SearchMonitor*
const monitor3);
2512 DecisionBuilder* MakeSolveOnce(DecisionBuilder*
const db,
2513 SearchMonitor*
const monitor1,
2514 SearchMonitor*
const monitor2,
2515 SearchMonitor*
const monitor3,
2516 SearchMonitor*
const monitor4);
2517 DecisionBuilder* MakeSolveOnce(DecisionBuilder*
const db,
2518 const std::vector<SearchMonitor*>& monitors);
2527 DecisionBuilder* MakeNestedOptimize(DecisionBuilder*
const db,
2528 Assignment*
const solution,
bool maximize,
2530 DecisionBuilder* MakeNestedOptimize(DecisionBuilder*
const db,
2531 Assignment*
const solution,
bool maximize,
2533 SearchMonitor*
const monitor1);
2534 DecisionBuilder* MakeNestedOptimize(DecisionBuilder*
const db,
2535 Assignment*
const solution,
bool maximize,
2536 int64 step, SearchMonitor*
const monitor1,
2537 SearchMonitor*
const monitor2);
2538 DecisionBuilder* MakeNestedOptimize(DecisionBuilder*
const db,
2539 Assignment*
const solution,
bool maximize,
2540 int64 step, SearchMonitor*
const monitor1,
2541 SearchMonitor*
const monitor2,
2542 SearchMonitor*
const monitor3);
2543 DecisionBuilder* MakeNestedOptimize(DecisionBuilder*
const db,
2544 Assignment*
const solution,
bool maximize,
2545 int64 step, SearchMonitor*
const monitor1,
2546 SearchMonitor*
const monitor2,
2547 SearchMonitor*
const monitor3,
2548 SearchMonitor*
const monitor4);
2549 DecisionBuilder* MakeNestedOptimize(
2550 DecisionBuilder*
const db, Assignment*
const solution,
bool maximize,
2551 int64 step,
const std::vector<SearchMonitor*>& monitors);
2555 DecisionBuilder* MakeRestoreAssignment(Assignment* assignment);
2559 DecisionBuilder* MakeStoreAssignment(Assignment* assignment);
2562 LocalSearchOperator* MakeOperator(
const std::vector<IntVar*>& vars,
2563 LocalSearchOperators op);
2564 LocalSearchOperator* MakeOperator(
const std::vector<IntVar*>& vars,
2565 const std::vector<IntVar*>& secondary_vars,
2566 LocalSearchOperators op);
2569 LocalSearchOperator* MakeOperator(
const std::vector<IntVar*>& vars,
2570 IndexEvaluator3 evaluator,
2571 EvaluatorLocalSearchOperators op);
2572 LocalSearchOperator* MakeOperator(
const std::vector<IntVar*>& vars,
2573 const std::vector<IntVar*>& secondary_vars,
2574 IndexEvaluator3 evaluator,
2575 EvaluatorLocalSearchOperators op);
2584 LocalSearchOperator* MakeRandomLnsOperator(
const std::vector<IntVar*>& vars,
2585 int number_of_variables);
2586 LocalSearchOperator* MakeRandomLnsOperator(
const std::vector<IntVar*>& vars,
2587 int number_of_variables,
2595 LocalSearchOperator* MakeMoveTowardTargetOperator(
const Assignment& target);
2603 LocalSearchOperator* MakeMoveTowardTargetOperator(
2604 const std::vector<IntVar*>& variables,
2605 const std::vector<int64>& target_values);
2637 LocalSearchOperator* ConcatenateOperators(
2638 const std::vector<LocalSearchOperator*>& ops);
2639 LocalSearchOperator* ConcatenateOperators(
2640 const std::vector<LocalSearchOperator*>& ops,
bool restart);
2641 LocalSearchOperator* ConcatenateOperators(
2642 const std::vector<LocalSearchOperator*>& ops,
2643 std::function<
int64(
int,
int)> evaluator);
2646 LocalSearchOperator* RandomConcatenateOperators(
2647 const std::vector<LocalSearchOperator*>& ops);
2652 LocalSearchOperator* RandomConcatenateOperators(
2653 const std::vector<LocalSearchOperator*>& ops,
int32 seed);
2660 LocalSearchOperator* MakeNeighborhoodLimit(LocalSearchOperator*
const op,
2690 DecisionBuilder* MakeLocalSearchPhase(
2691 Assignment*
const assignment,
2692 LocalSearchPhaseParameters*
const parameters);
2693 DecisionBuilder* MakeLocalSearchPhase(
2694 const std::vector<IntVar*>& vars, DecisionBuilder*
const first_solution,
2695 LocalSearchPhaseParameters*
const parameters);
2697 DecisionBuilder* MakeLocalSearchPhase(
2698 const std::vector<IntVar*>& vars, DecisionBuilder*
const first_solution,
2699 DecisionBuilder*
const first_solution_sub_decision_builder,
2700 LocalSearchPhaseParameters*
const parameters);
2701 DecisionBuilder* MakeLocalSearchPhase(
2702 const std::vector<SequenceVar*>& vars,
2703 DecisionBuilder*
const first_solution,
2704 LocalSearchPhaseParameters*
const parameters);
2707 SolutionPool* MakeDefaultSolutionPool();
2710 LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters(
2711 IntVar* objective, LocalSearchOperator*
const ls_operator,
2712 DecisionBuilder*
const sub_decision_builder);
2713 LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters(
2714 IntVar* objective, LocalSearchOperator*
const ls_operator,
2715 DecisionBuilder*
const sub_decision_builder, RegularLimit*
const limit);
2716 LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters(
2717 IntVar* objective, LocalSearchOperator*
const ls_operator,
2718 DecisionBuilder*
const sub_decision_builder, RegularLimit*
const limit,
2719 LocalSearchFilterManager* filter_manager);
2721 LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters(
2722 IntVar* objective, SolutionPool*
const pool,
2723 LocalSearchOperator*
const ls_operator,
2724 DecisionBuilder*
const sub_decision_builder);
2725 LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters(
2726 IntVar* objective, SolutionPool*
const pool,
2727 LocalSearchOperator*
const ls_operator,
2728 DecisionBuilder*
const sub_decision_builder, RegularLimit*
const limit);
2729 LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters(
2730 IntVar* objective, SolutionPool*
const pool,
2731 LocalSearchOperator*
const ls_operator,
2732 DecisionBuilder*
const sub_decision_builder, RegularLimit*
const limit,
2733 LocalSearchFilterManager* filter_manager);
2736 LocalSearchFilter* MakeAcceptFilter();
2737 LocalSearchFilter* MakeRejectFilter();
2738 LocalSearchFilter* MakeVariableDomainFilter();
2739 IntVarLocalSearchFilter* MakeSumObjectiveFilter(
2740 const std::vector<IntVar*>& vars, IndexEvaluator2 values,
2741 Solver::LocalSearchFilterBound filter_enum);
2742 IntVarLocalSearchFilter* MakeSumObjectiveFilter(
2743 const std::vector<IntVar*>& vars,
2744 const std::vector<IntVar*>& secondary_vars, IndexEvaluator3 values,
2745 Solver::LocalSearchFilterBound filter_enum);
2746 LocalSearchFilterManager* MakeLocalSearchFilterManager(
2747 std::vector<LocalSearchFilter*> filters);
2751 void TopPeriodicCheck();
2755 int TopProgressPercent();
2765 int SearchDepth()
const;
2769 int SearchLeftDepth()
const;
2773 int SolveDepth()
const;
2776 void SetBranchSelector(BranchSelector bs);
2779 DecisionBuilder* MakeApplyBranchSelector(BranchSelector bs);
2783 void SaveAndSetValue(T* adr, T val) {
2785 InternalSaveValue(adr);
2792 void SaveAndAdd(T* adr, T val) {
2794 InternalSaveValue(adr);
2802 return absl::Uniform<int64>(random_, 0, size);
2808 return absl::Uniform<int32>(random_, 0, size);
2812 void ReSeed(
int32 seed) { random_.seed(seed); }
2817 void ExportProfilingOverview(
const std::string& filename);
2821 std::string LocalSearchProfile()
const;
2824 LocalSearchStatistics GetLocalSearchStatistics()
const;
2826 #endif // !defined(SWIG)
2831 bool CurrentlyInSolve()
const;
2835 int constraints()
const {
return constraints_list_.size(); }
2838 void Accept(ModelVisitor*
const visitor)
const;
2840 Decision* balancing_decision()
const {
return balancing_decision_.get(); }
2844 void set_fail_intercept(std::function<
void()> fail_intercept) {
2845 fail_intercept_ = std::move(fail_intercept);
2847 #endif // !defined(SWIG)
2848 void clear_fail_intercept() { fail_intercept_ =
nullptr; }
2850 DemonProfiler* demon_profiler()
const {
return demon_profiler_; }
2854 void SetUseFastLocalSearch(
bool use_fast_local_search) {
2855 use_fast_local_search_ = use_fast_local_search;
2858 bool UseFastLocalSearch()
const {
return use_fast_local_search_; }
2860 bool HasName(
const PropagationBaseObject*
object)
const;
2864 IntExpr* RegisterIntExpr(IntExpr*
const expr);
2866 IntVar* RegisterIntVar(IntVar*
const var);
2869 IntervalVar* RegisterIntervalVar(IntervalVar*
const var);
2872 Search* ActiveSearch()
const;
2874 ModelCache* Cache()
const;
2876 bool InstrumentsDemons()
const;
2878 bool IsProfilingEnabled()
const;
2880 bool IsLocalSearchProfilingEnabled()
const;
2882 bool InstrumentsVariables()
const;
2884 bool NameAllVariables()
const;
2886 std::string model_name()
const;
2888 PropagationMonitor* GetPropagationMonitor()
const;
2891 void AddPropagationMonitor(PropagationMonitor*
const monitor);
2893 LocalSearchMonitor* GetLocalSearchMonitor()
const;
2896 void AddLocalSearchMonitor(LocalSearchMonitor* monitor);
2897 void SetSearchContext(Search* search,
const std::string& search_context);
2898 std::string SearchContext()
const;
2899 std::string SearchContext(
const Search* search)
const;
2902 Assignment* GetOrCreateLocalSearchState();
2904 void ClearLocalSearchState() { local_search_state_.reset(
nullptr); }
2910 std::vector<int64> tmp_vector_;
2912 friend class BaseIntExpr;
2913 friend class Constraint;
2914 friend class DemonProfiler;
2915 friend class FindOneNeighbor;
2916 friend class IntVar;
2917 friend class PropagationBaseObject;
2919 friend class SearchMonitor;
2920 friend class SearchLimit;
2921 friend class RoutingModel;
2922 friend class LocalSearchProfiler;
2927 friend class SimpleRevFIFO;
2928 template <
class K,
class V>
2929 friend class RevImmutableMultiMap;
2935 bool IsBooleanVar(IntExpr*
const expr, IntVar** inner_var,
2936 bool* is_negated)
const;
2942 bool IsProduct(IntExpr*
const expr, IntExpr** inner_expr,
int64*
coefficient);
2945 IntExpr* CastExpression(
const IntVar*
const var)
const;
2950 void FinishCurrentSearch();
2951 void RestartCurrentSearch();
2955 void ShouldFail() { should_fail_ =
true; }
2957 if (!should_fail_)
return;
2958 should_fail_ =
false;
2964 void PushState(MarkerType t,
const StateInfo& info);
2965 MarkerType PopState(StateInfo* info);
2966 void PushSentinel(
int magic_code);
2967 void BacktrackToSentinel(
int magic_code);
2968 void ProcessConstraints();
2969 bool BacktrackOneLevel(Decision** fail_decision);
2970 void JumpToSentinelWhenNested();
2971 void JumpToSentinel();
2972 void check_alloc_state();
2974 void EnqueueVar(Demon*
const d);
2975 void EnqueueDelayedDemon(Demon*
const d);
2976 void ExecuteAll(
const SimpleRevFIFO<Demon*>& demons);
2977 void EnqueueAll(
const SimpleRevFIFO<Demon*>& demons);
2978 void UnfreezeQueue();
2979 void reset_action_on_fail();
2980 void set_action_on_fail(Action
a);
2981 void set_variable_to_clean_on_fail(IntVar* v);
2982 void IncrementUncheckedSolutionCounter();
2983 bool IsUncheckedSolutionLimitReached();
2985 void InternalSaveValue(
int* valptr);
2986 void InternalSaveValue(
int64* valptr);
2987 void InternalSaveValue(
uint64* valptr);
2988 void InternalSaveValue(
double* valptr);
2989 void InternalSaveValue(
bool* valptr);
2990 void InternalSaveValue(
void** valptr);
2991 void InternalSaveValue(
int64** valptr) {
2992 InternalSaveValue(
reinterpret_cast<void**
>(valptr));
2995 BaseObject* SafeRevAlloc(BaseObject* ptr);
2997 int* SafeRevAllocArray(
int* ptr);
3000 double* SafeRevAllocArray(
double* ptr);
3001 BaseObject** SafeRevAllocArray(BaseObject** ptr);
3002 IntVar** SafeRevAllocArray(IntVar** ptr);
3003 IntExpr** SafeRevAllocArray(IntExpr** ptr);
3004 Constraint** SafeRevAllocArray(Constraint** ptr);
3007 void* UnsafeRevAllocAux(
void* ptr);
3009 T* UnsafeRevAlloc(T* ptr) {
3010 return reinterpret_cast<T*
>(
3011 UnsafeRevAllocAux(
reinterpret_cast<void*
>(ptr)));
3013 void** UnsafeRevAllocArrayAux(
void** ptr);
3015 T** UnsafeRevAllocArray(T** ptr) {
3016 return reinterpret_cast<T**
>(
3017 UnsafeRevAllocArrayAux(
reinterpret_cast<void**
>(ptr)));
3020 void InitCachedIntConstants();
3021 void InitCachedConstraint();
3026 Search* TopLevelSearch()
const {
return searches_.at(1); }
3030 Search* ParentSearch()
const {
3031 const size_t search_size = searches_.size();
3032 DCHECK_GT(search_size, 1);
3033 return searches_[search_size - 2];
3037 std::string GetName(
const PropagationBaseObject*
object);
3038 void SetName(
const PropagationBaseObject*
object,
const std::string&
name);
3042 int GetNewIntVarIndex() {
return num_int_vars_++; }
3045 bool IsADifference(IntExpr* expr, IntExpr**
const left,
3046 IntExpr**
const right);
3048 const std::string name_;
3049 const ConstraintSolverParameters parameters_;
3050 absl::flat_hash_map<const PropagationBaseObject*, std::string>
3051 propagation_object_names_;
3052 absl::flat_hash_map<const PropagationBaseObject*, IntegerCastInfo>
3054 absl::flat_hash_set<const Constraint*> cast_constraints_;
3055 const std::string empty_name_;
3056 std::unique_ptr<Queue> queue_;
3057 std::unique_ptr<Trail> trail_;
3058 std::vector<Constraint*> constraints_list_;
3059 std::vector<Constraint*> additional_constraints_list_;
3060 std::vector<int> additional_constraints_parent_list_;
3065 int64 demon_runs_[kNumPriorities];
3067 int64 filtered_neighbors_;
3068 int64 accepted_neighbors_;
3069 OptimizationDirection optimization_direction_;
3070 std::unique_ptr<ClockTimer> timer_;
3071 std::vector<Search*> searches_;
3072 std::mt19937 random_;
3074 std::unique_ptr<Decision> balancing_decision_;
3076 std::function<void()> fail_intercept_;
3078 DemonProfiler*
const demon_profiler_;
3080 bool use_fast_local_search_;
3082 LocalSearchProfiler*
const local_search_profiler_;
3084 std::unique_ptr<Assignment> local_search_state_;
3087 enum { MIN_CACHED_INT_CONST = -8, MAX_CACHED_INT_CONST = 8 };
3088 IntVar* cached_constants_[MAX_CACHED_INT_CONST + 1 - MIN_CACHED_INT_CONST];
3091 Constraint* true_constraint_;
3092 Constraint* false_constraint_;
3094 std::unique_ptr<Decision> fail_decision_;
3095 int constraint_index_;
3096 int additional_constraint_index_;
3099 std::unique_ptr<ModelCache> model_cache_;
3100 std::unique_ptr<PropagationMonitor> propagation_monitor_;
3101 PropagationMonitor* print_trace_;
3102 std::unique_ptr<LocalSearchMonitor> local_search_monitor_;
3103 int anonymous_variable_index_;
3109 std::ostream&
operator<<(std::ostream& out,
const Solver*
const s);
3114 inline int64 Zero() {
return 0; }
3117 inline int64 One() {
return 1; }
3125 virtual ~BaseObject() {}
3126 virtual std::string DebugString()
const {
return "BaseObject"; }
3132 std::ostream&
operator<<(std::ostream& out,
const BaseObject* o);
3137 class PropagationBaseObject :
public BaseObject {
3139 explicit PropagationBaseObject(Solver*
const s) : solver_(s) {}
3140 ~PropagationBaseObject()
override {}
3142 std::string DebugString()
const override {
3143 if (
name().empty()) {
3144 return "PropagationBaseObject";
3146 return absl::StrFormat(
"PropagationBaseObject: %s",
name());
3149 Solver* solver()
const {
return solver_; }
3153 void FreezeQueue() { solver_->FreezeQueue(); }
3157 void UnfreezeQueue() { solver_->UnfreezeQueue(); }
3162 void EnqueueDelayedDemon(Demon*
const d) { solver_->EnqueueDelayedDemon(d); }
3163 void EnqueueVar(Demon*
const d) { solver_->EnqueueVar(d); }
3164 void ExecuteAll(
const SimpleRevFIFO<Demon*>& demons);
3165 void EnqueueAll(
const SimpleRevFIFO<Demon*>& demons);
3170 void set_action_on_fail(Solver::Action
a) {
3171 solver_->set_action_on_fail(std::move(
a));
3173 #endif // !defined(SWIG)
3176 void reset_action_on_fail() { solver_->reset_action_on_fail(); }
3179 void set_variable_to_clean_on_fail(IntVar* v) {
3180 solver_->set_variable_to_clean_on_fail(v);
3184 virtual std::string
name()
const;
3185 void set_name(
const std::string&
name);
3187 bool HasName()
const;
3189 virtual std::string BaseName()
const;
3192 Solver*
const solver_;
3198 class Decision :
public BaseObject {
3201 ~Decision()
override {}
3204 virtual void Apply(Solver*
const s) = 0;
3207 virtual void Refute(Solver*
const s) = 0;
3209 std::string DebugString()
const override {
return "Decision"; }
3211 virtual void Accept(DecisionVisitor*
const visitor)
const;
3219 class DecisionVisitor :
public BaseObject {
3221 DecisionVisitor() {}
3222 ~DecisionVisitor()
override {}
3223 virtual void VisitSetVariableValue(IntVar*
const var,
int64 value);
3224 virtual void VisitSplitVariableDomain(IntVar*
const var,
int64 value,
3225 bool start_with_lower_half);
3226 virtual void VisitScheduleOrPostpone(IntervalVar*
const var,
int64 est);
3227 virtual void VisitScheduleOrExpedite(IntervalVar*
const var,
int64 est);
3228 virtual void VisitRankFirstInterval(SequenceVar*
const sequence,
int index);
3229 virtual void VisitRankLastInterval(SequenceVar*
const sequence,
int index);
3230 virtual void VisitUnknownDecision();
3238 class DecisionBuilder :
public BaseObject {
3240 DecisionBuilder() {}
3241 ~DecisionBuilder()
override {}
3246 virtual Decision* Next(Solver*
const s) = 0;
3247 std::string DebugString()
const override;
3249 virtual void AppendMonitors(Solver*
const solver,
3254 std::vector<SearchMonitor*>*
const extras);
3255 virtual void Accept(ModelVisitor*
const visitor)
const;
3271 class Demon :
public BaseObject {
3276 ~Demon()
override {}
3279 virtual void Run(Solver*
const s) = 0;
3284 virtual Solver::DemonPriority priority()
const;
3286 std::string DebugString()
const override;
3290 void inhibit(Solver*
const s);
3293 void desinhibit(Solver*
const s);
3304 class ModelVisitor :
public BaseObject {
3307 static const char kAbs[];
3308 static const char kAbsEqual[];
3309 static const char kAllDifferent[];
3310 static const char kAllowedAssignments[];
3311 static const char kAtMost[];
3312 static const char kIndexOf[];
3313 static const char kBetween[];
3314 static const char kConditionalExpr[];
3315 static const char kCircuit[];
3316 static const char kConvexPiecewise[];
3317 static const char kCountEqual[];
3318 static const char kCover[];
3319 static const char kCumulative[];
3320 static const char kDeviation[];
3321 static const char kDifference[];
3322 static const char kDisjunctive[];
3323 static const char kDistribute[];
3324 static const char kDivide[];
3325 static const char kDurationExpr[];
3326 static const char kElement[];
3327 static const char kElementEqual[];
3328 static const char kEndExpr[];
3329 static const char kEquality[];
3330 static const char kFalseConstraint[];
3331 static const char kGlobalCardinality[];
3332 static const char kGreater[];
3333 static const char kGreaterOrEqual[];
3334 static const char kIntegerVariable[];
3335 static const char kIntervalBinaryRelation[];
3336 static const char kIntervalDisjunction[];
3337 static const char kIntervalUnaryRelation[];
3338 static const char kIntervalVariable[];
3339 static const char kInversePermutation[];
3340 static const char kIsBetween[];
3341 static const char kIsDifferent[];
3342 static const char kIsEqual[];
3343 static const char kIsGreater[];
3344 static const char kIsGreaterOrEqual[];
3345 static const char kIsLess[];
3346 static const char kIsLessOrEqual[];
3347 static const char kIsMember[];
3348 static const char kLess[];
3349 static const char kLessOrEqual[];
3350 static const char kLexLess[];
3351 static const char kLinkExprVar[];
3352 static const char kMapDomain[];
3353 static const char kMax[];
3354 static const char kMaxEqual[];
3355 static const char kMember[];
3356 static const char kMin[];
3357 static const char kMinEqual[];
3358 static const char kModulo[];
3359 static const char kNoCycle[];
3360 static const char kNonEqual[];
3361 static const char kNotBetween[];
3362 static const char kNotMember[];
3363 static const char kNullIntersect[];
3364 static const char kOpposite[];
3365 static const char kPack[];
3366 static const char kPathCumul[];
3367 static const char kDelayedPathCumul[];
3368 static const char kPerformedExpr[];
3369 static const char kPower[];
3370 static const char kProduct[];
3371 static const char kScalProd[];
3372 static const char kScalProdEqual[];
3373 static const char kScalProdGreaterOrEqual[];
3374 static const char kScalProdLessOrEqual[];
3375 static const char kSemiContinuous[];
3376 static const char kSequenceVariable[];
3377 static const char kSortingConstraint[];
3378 static const char kSquare[];
3379 static const char kStartExpr[];
3380 static const char kSum[];
3381 static const char kSumEqual[];
3382 static const char kSumGreaterOrEqual[];
3383 static const char kSumLessOrEqual[];
3384 static const char kTrace[];
3385 static const char kTransition[];
3386 static const char kTrueConstraint[];
3387 static const char kVarBoundWatcher[];
3388 static const char kVarValueWatcher[];
3391 static const char kCountAssignedItemsExtension[];
3392 static const char kCountUsedBinsExtension[];
3393 static const char kInt64ToBoolExtension[];
3394 static const char kInt64ToInt64Extension[];
3395 static const char kObjectiveExtension[];
3396 static const char kSearchLimitExtension[];
3397 static const char kUsageEqualVariableExtension[];
3399 static const char kUsageLessConstantExtension[];
3400 static const char kVariableGroupExtension[];
3401 static const char kVariableUsageLessConstantExtension[];
3402 static const char kWeightedSumOfAssignedEqualVariableExtension[];
3405 static const char kActiveArgument[];
3406 static const char kAssumePathsArgument[];
3407 static const char kBranchesLimitArgument[];
3408 static const char kCapacityArgument[];
3409 static const char kCardsArgument[];
3410 static const char kCoefficientsArgument[];
3411 static const char kCountArgument[];
3412 static const char kCumulativeArgument[];
3413 static const char kCumulsArgument[];
3414 static const char kDemandsArgument[];
3415 static const char kDurationMaxArgument[];
3416 static const char kDurationMinArgument[];
3417 static const char kEarlyCostArgument[];
3418 static const char kEarlyDateArgument[];
3419 static const char kEndMaxArgument[];
3420 static const char kEndMinArgument[];
3421 static const char kEndsArgument[];
3422 static const char kExpressionArgument[];
3423 static const char kFailuresLimitArgument[];
3424 static const char kFinalStatesArgument[];
3425 static const char kFixedChargeArgument[];
3426 static const char kIndex2Argument[];
3427 static const char kIndexArgument[];
3428 static const char kInitialState[];
3429 static const char kIntervalArgument[];
3430 static const char kIntervalsArgument[];
3431 static const char kLateCostArgument[];
3432 static const char kLateDateArgument[];
3433 static const char kLeftArgument[];
3434 static const char kMaxArgument[];
3435 static const char kMaximizeArgument[];
3436 static const char kMinArgument[];
3437 static const char kModuloArgument[];
3438 static const char kNextsArgument[];
3439 static const char kOptionalArgument[];
3440 static const char kPartialArgument[];
3441 static const char kPositionXArgument[];
3442 static const char kPositionYArgument[];
3443 static const char kRangeArgument[];
3444 static const char kRelationArgument[];
3445 static const char kRightArgument[];
3446 static const char kSequenceArgument[];
3447 static const char kSequencesArgument[];
3448 static const char kSizeArgument[];
3449 static const char kSizeXArgument[];
3450 static const char kSizeYArgument[];
3451 static const char kSmartTimeCheckArgument[];
3452 static const char kSolutionLimitArgument[];
3453 static const char kStartMaxArgument[];
3454 static const char kStartMinArgument[];
3455 static const char kStartsArgument[];
3456 static const char kStepArgument[];
3457 static const char kTargetArgument[];
3458 static const char kTimeLimitArgument[];
3459 static const char kTransitsArgument[];
3460 static const char kTuplesArgument[];
3461 static const char kValueArgument[];
3462 static const char kValuesArgument[];
3463 static const char kVariableArgument[];
3464 static const char kVarsArgument[];
3465 static const char kEvaluatorArgument[];
3468 static const char kMirrorOperation[];
3469 static const char kRelaxedMaxOperation[];
3470 static const char kRelaxedMinOperation[];
3471 static const char kSumOperation[];
3472 static const char kDifferenceOperation[];
3473 static const char kProductOperation[];
3474 static const char kStartSyncOnStartOperation[];
3475 static const char kStartSyncOnEndOperation[];
3476 static const char kTraceOperation[];
3478 ~ModelVisitor()
override;
3483 virtual void BeginVisitModel(
const std::string& type_name);
3484 virtual void EndVisitModel(
const std::string& type_name);
3485 virtual void BeginVisitConstraint(
const std::string& type_name,
3486 const Constraint*
const constraint);
3487 virtual void EndVisitConstraint(
const std::string& type_name,
3488 const Constraint*
const constraint);
3489 virtual void BeginVisitExtension(
const std::string& type);
3490 virtual void EndVisitExtension(
const std::string& type);
3491 virtual void BeginVisitIntegerExpression(
const std::string& type_name,
3492 const IntExpr*
const expr);
3493 virtual void EndVisitIntegerExpression(
const std::string& type_name,
3494 const IntExpr*
const expr);
3495 virtual void VisitIntegerVariable(
const IntVar*
const variable,
3496 IntExpr*
const delegate);
3497 virtual void VisitIntegerVariable(
const IntVar*
const variable,
3499 IntVar*
const delegate);
3500 virtual void VisitIntervalVariable(
const IntervalVar*
const variable,
3502 IntervalVar*
const delegate);
3503 virtual void VisitSequenceVariable(
const SequenceVar*
const variable);
3506 virtual void VisitIntegerArgument(
const std::string& arg_name,
int64 value);
3507 virtual void VisitIntegerArrayArgument(
const std::string& arg_name,
3508 const std::vector<int64>& values);
3509 virtual void VisitIntegerMatrixArgument(
const std::string& arg_name,
3510 const IntTupleSet& tuples);
3513 virtual void VisitIntegerExpressionArgument(
const std::string& arg_name,
3514 IntExpr*
const argument);
3516 virtual void VisitIntegerVariableArrayArgument(
3517 const std::string& arg_name,
const std::vector<IntVar*>& arguments);
3520 virtual void VisitIntervalArgument(
const std::string& arg_name,
3521 IntervalVar*
const argument);
3523 virtual void VisitIntervalArrayArgument(
3524 const std::string& arg_name,
const std::vector<IntervalVar*>& arguments);
3526 virtual void VisitSequenceArgument(
const std::string& arg_name,
3527 SequenceVar*
const argument);
3529 virtual void VisitSequenceArrayArgument(
3530 const std::string& arg_name,
const std::vector<SequenceVar*>& arguments);
3532 virtual void VisitIntegerVariableEvaluatorArgument(
3534 const std::string& arg_name,
const Solver::Int64ToIntVar& arguments);
3538 void VisitInt64ToBoolExtension(Solver::IndexFilter1 filter,
int64 index_min,
3540 void VisitInt64ToInt64Extension(
const Solver::IndexEvaluator1& eval,
3543 void VisitInt64ToInt64AsArray(
const Solver::IndexEvaluator1& eval,
3544 const std::string& arg_name,
int64 index_max);
3545 #endif // #if !defined(SWIG)
3554 class Constraint :
public PropagationBaseObject {
3556 explicit Constraint(Solver*
const solver) : PropagationBaseObject(solver) {}
3557 ~Constraint()
override {}
3561 virtual void Post() = 0;
3565 virtual void InitialPropagate() = 0;
3566 std::string DebugString()
const override;
3570 void PostAndPropagate();
3573 virtual void Accept(ModelVisitor*
const visitor)
const;
3576 bool IsCastConstraint()
const;
3581 virtual IntVar* Var();
3590 class CastConstraint :
public Constraint {
3592 CastConstraint(Solver*
const solver, IntVar*
const target_var)
3594 CHECK(target_var !=
nullptr);
3596 ~CastConstraint()
override {}
3598 IntVar* target_var()
const {
return target_var_; }
3605 class SearchMonitor :
public BaseObject {
3607 static constexpr
int kNoProgress = -1;
3609 explicit SearchMonitor(Solver*
const s) : solver_(s) {}
3610 ~SearchMonitor()
override {}
3612 virtual void EnterSearch();
3615 virtual void RestartSearch();
3618 virtual void ExitSearch();
3621 virtual void BeginNextDecision(DecisionBuilder*
const b);
3624 virtual void EndNextDecision(DecisionBuilder*
const b, Decision*
const d);
3627 virtual void ApplyDecision(Decision*
const d);
3630 virtual void RefuteDecision(Decision*
const d);
3634 virtual void AfterDecision(Decision*
const d,
bool apply);
3637 virtual void BeginFail();
3640 virtual void EndFail();
3643 virtual void BeginInitialPropagation();
3646 virtual void EndInitialPropagation();
3651 virtual bool AcceptSolution();
3656 virtual bool AtSolution();
3659 virtual void NoMoreSolutions();
3663 virtual bool LocalOptimum();
3676 virtual bool IsUncheckedSolutionLimitReached() {
return false; }
3678 Solver* solver()
const {
return solver_; }
3681 virtual void PeriodicCheck();
3685 virtual int ProgressPercent() {
return kNoProgress; }
3688 virtual void Accept(ModelVisitor*
const visitor)
const;
3692 virtual void Install();
3695 Solver*
const solver_;
3707 explicit Rev(
const T& val) :
stamp_(0), value_(val) {}
3709 const T&
Value()
const {
return value_; }
3711 void SetValue(Solver*
const s,
const T& val) {
3712 if (val != value_) {
3713 if (stamp_ < s->stamp()) {
3714 s->SaveValue(&value_);
3728 class NumericalRev :
public Rev<T> {
3730 explicit NumericalRev(
const T& val) : Rev<T>(val) {}
3732 void Add(Solver*
const s,
const T& to_add) {
3733 this->SetValue(s, this->
Value() + to_add);
3736 void Incr(Solver*
const s) { Add(s, 1); }
3738 void Decr(Solver*
const s) { Add(s, -1); }
3749 RevArray(
int size,
const T& val)
3750 : stamps_(new
uint64[size]), values_(new T[size]), size_(size) {
3751 for (
int i = 0; i < size; ++i) {
3759 int64 size()
const {
return size_; }
3764 const T& operator[](
int index)
const {
return values_[
index]; }
3767 void SetValue(Solver*
const s,
int index,
const T& val) {
3768 DCHECK_LT(
index, size_);
3769 if (val != values_[
index]) {
3770 if (stamps_[
index] < s->stamp()) {
3771 s->SaveValue(&values_[
index]);
3772 stamps_[
index] = s->stamp();
3774 values_[
index] = val;
3779 std::unique_ptr<uint64[]> stamps_;
3780 std::unique_ptr<T[]> values_;
3786 class NumericalRevArray :
public RevArray<T> {
3788 NumericalRevArray(
int size,
const T& val) : RevArray<T>(size, val) {}
3790 void Add(Solver*
const s,
int index,
const T& to_add) {
3791 this->SetValue(s,
index, this->
Value(index) + to_add);
3794 void Incr(Solver*
const s,
int index) { Add(s,
index, 1); }
3796 void Decr(Solver*
const s,
int index) { Add(s,
index, -1); }
3806 class IntExpr :
public PropagationBaseObject {
3808 explicit IntExpr(Solver*
const s) : PropagationBaseObject(s) {}
3809 ~IntExpr()
override {}
3811 virtual int64 Min()
const = 0;
3812 virtual void SetMin(
int64 m) = 0;
3813 virtual int64 Max()
const = 0;
3814 virtual void SetMax(
int64 m) = 0;
3829 virtual void SetValue(
int64 v) { SetRange(v, v); }
3832 virtual bool Bound()
const {
return (Min() == Max()); }
3835 virtual bool IsVar()
const {
return false; }
3838 virtual IntVar* Var() = 0;
3844 IntVar* VarWithName(
const std::string&
name);
3847 virtual void WhenRange(Demon* d) = 0;
3849 void WhenRange(Solver::Closure closure) {
3850 WhenRange(solver()->MakeClosureDemon(std::move(closure)));
3854 void WhenRange(Solver::Action action) {
3856 WhenRange(solver()->MakeActionDemon(std::move(action)));
3861 virtual void Accept(ModelVisitor*
const visitor)
const;
3884 class IntVarIterator :
public BaseObject {
3886 ~IntVarIterator()
override {}
3889 virtual void Init() = 0;
3892 virtual bool Ok()
const = 0;
3898 virtual void Next() = 0;
3901 std::string DebugString()
const override {
return "IntVar::Iterator"; }
3905 class InitAndGetValues {
3913 explicit InitAndGetValues(IntVarIterator* it)
3914 : it_(it), begin_was_called_(false) {
3920 DCHECK(!begin_was_called_);
3921 begin_was_called_ =
true;
3923 return Iterator::Begin(it_);
3925 Iterator end() {
return Iterator::End(it_); }
3929 static Iterator Begin(IntVarIterator* it) {
3930 return Iterator(it,
false);
3932 static Iterator End(IntVarIterator* it) {
3933 return Iterator(it,
true);
3938 return it_->Value();
3940 Iterator& operator++() {
3945 bool operator!=(
const Iterator& other)
const {
3946 DCHECK(other.it_ == it_);
3947 DCHECK(other.is_end_);
3952 Iterator(IntVarIterator* it,
bool is_end) : it_(it), is_end_(is_end) {}
3954 IntVarIterator*
const it_;
3959 IntVarIterator*
const it_;
3960 bool begin_was_called_;
3967 class IntVar :
public IntExpr {
3969 explicit IntVar(Solver*
const s);
3970 IntVar(Solver*
const s,
const std::string&
name);
3971 ~IntVar()
override {}
3973 bool IsVar()
const override {
return true; }
3974 IntVar* Var()
override {
return this; }
3981 virtual void RemoveValue(
int64 v) = 0;
3985 virtual void RemoveInterval(
int64 l,
int64 u) = 0;
3988 virtual void RemoveValues(
const std::vector<int64>& values);
3991 virtual void SetValues(
const std::vector<int64>& values);
3995 virtual void WhenBound(Demon* d) = 0;
3998 void WhenBound(Solver::Closure closure) {
3999 WhenBound(solver()->MakeClosureDemon(std::move(closure)));
4003 void WhenBound(Solver::Action action) {
4006 WhenBound(solver()->MakeActionDemon(std::move(action)));
4012 virtual void WhenDomain(Demon* d) = 0;
4015 void WhenDomain(Solver::Closure closure) {
4016 WhenDomain(solver()->MakeClosureDemon(std::move(closure)));
4019 void WhenDomain(Solver::Action action) {
4022 WhenDomain(solver()->MakeActionDemon(std::move(action)));
4027 virtual uint64 Size()
const = 0;
4031 virtual bool Contains(
int64 v)
const = 0;
4036 virtual IntVarIterator* MakeHoleIterator(
bool reversible)
const = 0;
4041 virtual IntVarIterator* MakeDomainIterator(
bool reversible)
const = 0;
4044 virtual int64 OldMin()
const = 0;
4047 virtual int64 OldMax()
const = 0;
4049 virtual int VarType()
const;
4052 void Accept(ModelVisitor*
const visitor)
const override;
4055 virtual IntVar* IsEqual(
int64 constant) = 0;
4056 virtual IntVar* IsDifferent(
int64 constant) = 0;
4057 virtual IntVar* IsGreaterOrEqual(
int64 constant) = 0;
4058 virtual IntVar* IsLessOrEqual(
int64 constant) = 0;
4061 int index()
const {
return index_; }
4071 class SolutionCollector :
public SearchMonitor {
4073 SolutionCollector(Solver*
const solver,
const Assignment* assignment);
4074 explicit SolutionCollector(Solver*
const solver);
4075 ~SolutionCollector()
override;
4076 std::string DebugString()
const override {
return "SolutionCollector"; }
4079 void Add(IntVar*
const var);
4080 void Add(
const std::vector<IntVar*>& vars);
4081 void Add(IntervalVar*
const var);
4082 void Add(
const std::vector<IntervalVar*>& vars);
4083 void Add(SequenceVar*
const var);
4084 void Add(
const std::vector<SequenceVar*>& vars);
4085 void AddObjective(IntVar*
const objective);
4088 void EnterSearch()
override;
4091 int solution_count()
const;
4094 Assignment* solution(
int n)
const;
4097 int64 wall_time(
int n)
const;
4100 int64 branches(
int n)
const;
4104 int64 failures(
int n)
const;
4107 int64 objective_value(
int n)
const;
4113 int64 StartValue(
int n, IntervalVar*
const var)
const;
4116 int64 EndValue(
int n, IntervalVar*
const var)
const;
4119 int64 DurationValue(
int n, IntervalVar*
const var)
const;
4122 int64 PerformedValue(
int n, IntervalVar*
const var)
const;
4127 const std::vector<int>& ForwardSequence(
int n, SequenceVar*
const var)
const;
4131 const std::vector<int>& BackwardSequence(
int n, SequenceVar*
const var)
const;
4134 const std::vector<int>& Unperformed(
int n, SequenceVar*
const var)
const;
4137 struct SolutionData {
4138 Assignment* solution;
4142 int64 objective_value;
4143 bool operator<(
const SolutionData& other)
const {
4144 return std::tie(solution,
time, branches, failures, objective_value) <
4145 std::tie(other.solution, other.time, other.branches,
4146 other.failures, other.objective_value);
4151 void PushSolution();
4152 void Push(
const SolutionData& data) { solution_data_.push_back(data); }
4155 SolutionData BuildSolutionDataForCurrentState();
4156 void FreeSolution(Assignment* solution);
4157 void check_index(
int n)
const;
4159 std::unique_ptr<Assignment> prototype_;
4160 std::vector<SolutionData> solution_data_;
4161 std::vector<Assignment*> recycle_solutions_;
4174 class OptimizeVar :
public SearchMonitor {
4176 OptimizeVar(Solver*
const s,
bool maximize, IntVar*
const a,
int64 step);
4177 ~OptimizeVar()
override;
4183 IntVar* Var()
const {
return var_; }
4186 void EnterSearch()
override;
4187 void BeginNextDecision(DecisionBuilder*
const db)
override;
4188 void RefuteDecision(Decision*
const d)
override;
4189 bool AtSolution()
override;
4190 bool AcceptSolution()
override;
4191 virtual std::string Print()
const;
4192 std::string DebugString()
const override;
4193 void Accept(ModelVisitor*
const visitor)
const override;
4202 bool found_initial_solution_;
4209 class SearchLimit :
public SearchMonitor {
4211 explicit SearchLimit(Solver*
const s) : SearchMonitor(s), crossed_(false) {}
4212 ~SearchLimit()
override;
4215 bool crossed()
const {
return crossed_; }
4221 virtual bool Check() = 0;
4224 virtual void Init() = 0;
4228 virtual void Copy(
const SearchLimit*
const limit) = 0;
4231 virtual SearchLimit* MakeClone()
const = 0;
4234 void EnterSearch()
override;
4235 void BeginNextDecision(DecisionBuilder*
const b)
override;
4236 void PeriodicCheck()
override;
4237 void RefuteDecision(Decision*
const d)
override;
4238 std::string DebugString()
const override {
4239 return absl::StrFormat(
"SearchLimit(crossed = %i)", crossed_);
4243 void TopPeriodicCheck();
4251 class RegularLimit :
public SearchLimit {
4253 RegularLimit(Solver*
const s, absl::Duration
time,
int64 branches,
4254 int64 failures,
int64 solutions,
bool smart_time_check,
4256 ~RegularLimit()
override;
4257 void Copy(
const SearchLimit*
const limit)
override;
4258 SearchLimit* MakeClone()
const override;
4259 RegularLimit* MakeIdenticalClone()
const;
4260 bool Check()
override;
4261 void Init()
override;
4262 void ExitSearch()
override;
4263 void UpdateLimits(absl::Duration
time,
int64 branches,
int64 failures,
4265 absl::Duration duration_limit()
const {
return duration_limit_; }
4266 int64 wall_time()
const {
4267 return duration_limit_ == absl::InfiniteDuration()
4269 : absl::ToInt64Milliseconds(duration_limit());
4271 int64 branches()
const {
return branches_; }
4272 int64 failures()
const {
return failures_; }
4273 int64 solutions()
const {
return solutions_; }
4274 bool IsUncheckedSolutionLimitReached()
override;
4275 int ProgressPercent()
override;
4276 std::string DebugString()
const override;
4278 absl::Time AbsoluteSolverDeadline()
const {
4279 return solver_time_at_limit_start_ + duration_limit_;
4282 void Accept(ModelVisitor*
const visitor)
const override;
4286 absl::Duration TimeElapsed();
4288 return (total > 0 && total <
kint64max) ? 100 * (
value - offset) / total
4292 absl::Duration duration_limit_;
4293 absl::Time solver_time_at_limit_start_;
4294 absl::Duration last_time_elapsed_;
4297 bool smart_time_check_;
4299 int64 branches_offset_;
4301 int64 failures_offset_;
4303 int64 solutions_offset_;
4324 class IntervalVar :
public PropagationBaseObject {
4327 static const int64 kMinValidValue;
4329 static const int64 kMaxValidValue;
4330 IntervalVar(Solver*
const solver,
const std::string&
name)
4331 : PropagationBaseObject(solver) {
4334 ~IntervalVar()
override {}
4338 virtual int64 StartMin()
const = 0;
4339 virtual int64 StartMax()
const = 0;
4340 virtual void SetStartMin(
int64 m) = 0;
4341 virtual void SetStartMax(
int64 m) = 0;
4342 virtual void SetStartRange(
int64 mi,
int64 ma) = 0;
4343 virtual int64 OldStartMin()
const = 0;
4344 virtual int64 OldStartMax()
const = 0;
4345 virtual void WhenStartRange(Demon*
const d) = 0;
4346 void WhenStartRange(Solver::Closure closure) {
4347 WhenStartRange(solver()->MakeClosureDemon(std::move(closure)));
4350 void WhenStartRange(Solver::Action action) {
4351 WhenStartRange(solver()->MakeActionDemon(std::move(action)));
4354 virtual void WhenStartBound(Demon*
const d) = 0;
4355 void WhenStartBound(Solver::Closure closure) {
4356 WhenStartBound(solver()->MakeClosureDemon(std::move(closure)));
4359 void WhenStartBound(Solver::Action action) {
4360 WhenStartBound(solver()->MakeActionDemon(std::move(action)));
4365 virtual int64 DurationMin()
const = 0;
4366 virtual int64 DurationMax()
const = 0;
4367 virtual void SetDurationMin(
int64 m) = 0;
4368 virtual void SetDurationMax(
int64 m) = 0;
4369 virtual void SetDurationRange(
int64 mi,
int64 ma) = 0;
4370 virtual int64 OldDurationMin()
const = 0;
4371 virtual int64 OldDurationMax()
const = 0;
4372 virtual void WhenDurationRange(Demon*
const d) = 0;
4373 void WhenDurationRange(Solver::Closure closure) {
4374 WhenDurationRange(solver()->MakeClosureDemon(std::move(closure)));
4377 void WhenDurationRange(Solver::Action action) {
4378 WhenDurationRange(solver()->MakeActionDemon(std::move(action)));
4381 virtual void WhenDurationBound(Demon*
const d) = 0;
4382 void WhenDurationBound(Solver::Closure closure) {
4383 WhenDurationBound(solver()->MakeClosureDemon(std::move(closure)));
4386 void WhenDurationBound(Solver::Action action) {
4387 WhenDurationBound(solver()->MakeActionDemon(std::move(action)));
4392 virtual int64 EndMin()
const = 0;
4393 virtual int64 EndMax()
const = 0;
4394 virtual void SetEndMin(
int64 m) = 0;
4395 virtual void SetEndMax(
int64 m) = 0;
4396 virtual void SetEndRange(
int64 mi,
int64 ma) = 0;
4397 virtual int64 OldEndMin()
const = 0;
4398 virtual int64 OldEndMax()
const = 0;
4399 virtual void WhenEndRange(Demon*
const d) = 0;
4400 void WhenEndRange(Solver::Closure closure) {
4401 WhenEndRange(solver()->MakeClosureDemon(std::move(closure)));
4404 void WhenEndRange(Solver::Action action) {
4405 WhenEndRange(solver()->MakeActionDemon(std::move(action)));
4408 virtual void WhenEndBound(Demon*
const d) = 0;
4409 void WhenEndBound(Solver::Closure closure) {
4410 WhenEndBound(solver()->MakeClosureDemon(std::move(closure)));
4413 void WhenEndBound(Solver::Action action) {
4414 WhenEndBound(solver()->MakeActionDemon(std::move(action)));
4420 virtual bool MustBePerformed()
const = 0;
4421 virtual bool MayBePerformed()
const = 0;
4422 bool CannotBePerformed()
const {
return !MayBePerformed(); }
4423 bool IsPerformedBound()
const {
4424 return MustBePerformed() || !MayBePerformed();
4426 virtual void SetPerformed(
bool val) = 0;
4427 virtual bool WasPerformedBound()
const = 0;
4428 virtual void WhenPerformedBound(Demon*
const d) = 0;
4429 void WhenPerformedBound(Solver::Closure closure) {
4430 WhenPerformedBound(solver()->MakeClosureDemon(std::move(closure)));
4433 void WhenPerformedBound(Solver::Action action) {
4434 WhenPerformedBound(solver()->MakeActionDemon(std::move(action)));
4439 void WhenAnything(Demon*
const d);
4441 void WhenAnything(Solver::Closure closure) {
4442 WhenAnything(solver()->MakeClosureDemon(std::move(closure)));
4445 void WhenAnything(Solver::Action action) {
4447 WhenAnything(solver()->MakeActionDemon(std::move(action)));
4454 virtual IntExpr* StartExpr() = 0;
4455 virtual IntExpr* DurationExpr() = 0;
4456 virtual IntExpr* EndExpr() = 0;
4457 virtual IntExpr* PerformedExpr() = 0;
4461 virtual IntExpr* SafeStartExpr(
int64 unperformed_value) = 0;
4462 virtual IntExpr* SafeDurationExpr(
int64 unperformed_value) = 0;
4463 virtual IntExpr* SafeEndExpr(
int64 unperformed_value) = 0;
4466 virtual void Accept(ModelVisitor*
const visitor)
const = 0;
4478 class SequenceVar :
public PropagationBaseObject {
4480 SequenceVar(Solver*
const s,
const std::vector<IntervalVar*>& intervals,
4481 const std::vector<IntVar*>& nexts,
const std::string&
name);
4483 ~SequenceVar()
override;
4485 std::string DebugString()
const override;
4488 void DurationRange(
int64*
const dmin,
int64*
const dmax)
const;
4494 void HorizonRange(
int64*
const hmin,
int64*
const hmax)
const;
4498 void ActiveHorizonRange(
int64*
const hmin,
int64*
const hmax)
const;
4501 void ComputeStatistics(
int*
const ranked,
int*
const not_ranked,
4502 int*
const unperformed)
const;
4503 #endif // !defined(SWIG)
4507 void RankFirst(
int index);
4511 void RankNotFirst(
int index);
4515 void RankLast(
int index);
4519 void RankNotLast(
int index);
4523 void ComputePossibleFirstsAndLasts(std::vector<int>*
const possible_firsts,
4524 std::vector<int>*
const possible_lasts);
4531 void RankSequence(
const std::vector<int>& rank_first,
4532 const std::vector<int>& rank_last,
4533 const std::vector<int>& unperformed);
4543 void FillSequence(std::vector<int>*
const rank_first,
4544 std::vector<int>*
const rank_last,
4545 std::vector<int>*
const unperformed)
const;
4548 IntervalVar* Interval(
int index)
const;
4551 IntVar* Next(
int index)
const;
4554 int64 size()
const {
return intervals_.size(); }
4557 virtual void Accept(ModelVisitor*
const visitor)
const;
4560 int ComputeForwardFrontier();
4561 int ComputeBackwardFrontier();
4562 void UpdatePrevious()
const;
4564 const std::vector<IntervalVar*> intervals_;
4565 const std::vector<IntVar*> nexts_;
4566 mutable std::vector<int> previous_;
4569 class AssignmentElement {
4571 AssignmentElement() : activated_(true) {}
4573 void Activate() { activated_ =
true; }
4574 void Deactivate() { activated_ =
false; }
4575 bool Activated()
const {
return activated_; }
4581 class IntVarElement :
public AssignmentElement {
4584 explicit IntVarElement(IntVar*
const var);
4585 void Reset(IntVar*
const var);
4586 IntVarElement* Clone();
4587 void Copy(
const IntVarElement& element);
4588 IntVar* Var()
const {
return var_; }
4594 if (var_ !=
nullptr) {
4595 var_->SetRange(min_, max_);
4598 void LoadFromProto(
const IntVarAssignment& int_var_assignment_proto);
4599 void WriteToProto(IntVarAssignment* int_var_assignment_proto)
const;
4601 int64 Min()
const {
return min_; }
4602 void SetMin(
int64 m) { min_ = m; }
4603 int64 Max()
const {
return max_; }
4604 void SetMax(
int64 m) { max_ = m; }
4606 DCHECK_EQ(min_, max_);
4610 bool Bound()
const {
return (max_ == min_); }
4615 void SetValue(
int64 v) {
4619 std::string DebugString()
const;
4621 bool operator==(
const IntVarElement& element)
const;
4622 bool operator!=(
const IntVarElement& element)
const {
4623 return !(*
this == element);
4632 class IntervalVarElement :
public AssignmentElement {
4634 IntervalVarElement();
4635 explicit IntervalVarElement(IntervalVar*
const var);
4636 void Reset(IntervalVar*
const var);
4637 IntervalVarElement* Clone();
4638 void Copy(
const IntervalVarElement& element);
4639 IntervalVar* Var()
const {
return var_; }
4643 const IntervalVarAssignment& interval_var_assignment_proto);
4644 void WriteToProto(IntervalVarAssignment* interval_var_assignment_proto)
const;
4646 int64 StartMin()
const {
return start_min_; }
4647 int64 StartMax()
const {
return start_max_; }
4648 int64 StartValue()
const {
4649 CHECK_EQ(start_max_, start_min_);
4652 int64 DurationMin()
const {
return duration_min_; }
4653 int64 DurationMax()
const {
return duration_max_; }
4654 int64 DurationValue()
const {
4655 CHECK_EQ(duration_max_, duration_min_);
4656 return duration_max_;
4658 int64 EndMin()
const {
return end_min_; }
4659 int64 EndMax()
const {
return end_max_; }
4660 int64 EndValue()
const {
4661 CHECK_EQ(end_max_, end_min_);
4664 int64 PerformedMin()
const {
return performed_min_; }
4665 int64 PerformedMax()
const {
return performed_max_; }
4666 int64 PerformedValue()
const {
4667 CHECK_EQ(performed_max_, performed_min_);
4668 return performed_max_;
4670 void SetStartMin(
int64 m) { start_min_ = m; }
4671 void SetStartMax(
int64 m) { start_max_ = m; }
4676 void SetStartValue(
int64 v) {
4680 void SetDurationMin(
int64 m) { duration_min_ = m; }
4681 void SetDurationMax(
int64 m) { duration_max_ = m; }
4686 void SetDurationValue(
int64 v) {
4690 void SetEndMin(
int64 m) { end_min_ = m; }
4691 void SetEndMax(
int64 m) { end_max_ = m; }
4696 void SetEndValue(
int64 v) {
4700 void SetPerformedMin(
int64 m) { performed_min_ = m; }
4701 void SetPerformedMax(
int64 m) { performed_max_ = m; }
4703 performed_min_ = mi;
4704 performed_max_ = ma;
4706 void SetPerformedValue(
int64 v) {
4710 bool Bound()
const {
4711 return (start_min_ == start_max_ && duration_min_ == duration_max_ &&
4712 end_min_ == end_max_ && performed_min_ == performed_max_);
4714 std::string DebugString()
const;
4715 bool operator==(
const IntervalVarElement& element)
const;
4716 bool operator!=(
const IntervalVarElement& element)
const {
4717 return !(*
this == element);
4723 int64 duration_min_;
4724 int64 duration_max_;
4727 int64 performed_min_;
4728 int64 performed_max_;
4745 class SequenceVarElement :
public AssignmentElement {
4747 SequenceVarElement();
4748 explicit SequenceVarElement(SequenceVar*
const var);
4749 void Reset(SequenceVar*
const var);
4750 SequenceVarElement* Clone();
4751 void Copy(
const SequenceVarElement& element);
4752 SequenceVar* Var()
const {
return var_; }
4756 const SequenceVarAssignment& sequence_var_assignment_proto);
4757 void WriteToProto(SequenceVarAssignment* sequence_var_assignment_proto)
const;
4759 const std::vector<int>& ForwardSequence()
const;
4760 const std::vector<int>& BackwardSequence()
const;
4761 const std::vector<int>& Unperformed()
const;
4762 void SetSequence(
const std::vector<int>& forward_sequence,
4763 const std::vector<int>& backward_sequence,
4764 const std::vector<int>& unperformed);
4765 void SetForwardSequence(
const std::vector<int>& forward_sequence);
4766 void SetBackwardSequence(
const std::vector<int>& backward_sequence);
4767 void SetUnperformed(
const std::vector<int>& unperformed);
4768 bool Bound()
const {
4769 return forward_sequence_.size() + unperformed_.size() == var_->size();
4772 std::string DebugString()
const;
4774 bool operator==(
const SequenceVarElement& element)
const;
4775 bool operator!=(
const SequenceVarElement& element)
const {
4776 return !(*
this == element);
4780 bool CheckClassInvariants();
4783 std::vector<int> forward_sequence_;
4784 std::vector<int> backward_sequence_;
4785 std::vector<int> unperformed_;
4788 template <
class V,
class E>
4789 class AssignmentContainer {
4791 AssignmentContainer() {}
4793 CHECK(
var !=
nullptr);
4796 return FastAdd(
var);
4798 return &elements_[
index];
4802 E* FastAdd(V*
var) {
4803 DCHECK(
var !=
nullptr);
4804 elements_.emplace_back(
var);
4805 return &elements_.back();
4809 E* AddAtPosition(V*
var,
int position) {
4810 elements_[position].Reset(
var);
4811 return &elements_[position];
4815 if (!elements_map_.empty()) {
4816 elements_map_.clear();
4821 void Resize(
size_t size) { elements_.resize(size); }
4822 bool Empty()
const {
return elements_.empty(); }
4825 void CopyIntersection(
const AssignmentContainer<V, E>& container) {
4826 for (
int i = 0; i < container.elements_.size(); ++i) {
4827 const E& element = container.elements_[i];
4828 const V*
const var = element.Var();
4830 if (i < elements_.size() && elements_[i].Var() ==
var) {
4835 DCHECK_GE(
index, 0);
4836 E*
const local_element = &elements_[
index];
4837 local_element->Copy(element);
4838 if (element.Activated()) {
4839 local_element->Activate();
4841 local_element->Deactivate();
4847 void Copy(
const AssignmentContainer<V, E>& container) {
4849 for (
int i = 0; i < container.elements_.size(); ++i) {
4850 const E& element = container.elements_[i];
4851 FastAdd(element.Var())->Copy(element);
4854 bool Contains(
const V*
const var)
const {
4858 E* MutableElement(
const V*
const var) {
4859 E*
const element = MutableElementOrNull(
var);
4860 DCHECK(element !=
nullptr)
4861 <<
"Unknown variable " <<
var->DebugString() <<
" in solution";
4864 E* MutableElementOrNull(
const V*
const var) {
4867 return MutableElement(
index);
4871 const E& Element(
const V*
const var)
const {
4872 const E*
const element = ElementPtrOrNull(
var);
4873 DCHECK(element !=
nullptr)
4874 <<
"Unknown variable " <<
var->DebugString() <<
" in solution";
4877 const E* ElementPtrOrNull(
const V*
const var)
const {
4880 return &Element(
index);
4884 const std::vector<E>& elements()
const {
return elements_; }
4885 E* MutableElement(
int index) {
return &elements_[
index]; }
4886 const E& Element(
int index)
const {
return elements_[
index]; }
4887 int Size()
const {
return elements_.size(); }
4889 for (E& element : elements_) {
4894 for (E& element : elements_) {
4895 if (element.Activated()) {
4900 bool AreAllElementsBound()
const {
4901 for (
const E& element : elements_) {
4902 if (!element.Bound())
return false;
4910 bool operator==(
const AssignmentContainer<V, E>& container)
const {
4912 if (Size() != container.Size()) {
4916 EnsureMapIsUpToDate();
4920 for (
const E& element : container.elements_) {
4921 const int position =
4923 if (position < 0 || elements_[position] != element) {
4929 bool operator!=(
const AssignmentContainer<V, E>& container)
const {
4930 return !(*
this == container);
4934 void EnsureMapIsUpToDate()
const {
4935 absl::flat_hash_map<const V*, int>* map =
4936 const_cast<absl::flat_hash_map<const V*, int>*
>(&elements_map_);
4937 for (
int i = map->size(); i < elements_.size(); ++i) {
4938 (*map)[elements_[i].Var()] = i;
4941 bool Find(
const V*
const var,
int*
index)
const {
4943 const size_t kMaxSizeForLinearAccess = 11;
4944 if (Size() <= kMaxSizeForLinearAccess) {
4948 for (
int i = 0; i < elements_.size(); ++i) {
4949 if (
var == elements_[i].Var()) {
4956 EnsureMapIsUpToDate();
4957 DCHECK_EQ(elements_map_.size(), elements_.size());
4962 std::vector<E> elements_;
4963 absl::flat_hash_map<const V*, int> elements_map_;
4968 class Assignment :
public PropagationBaseObject {
4970 typedef AssignmentContainer<IntVar, IntVarElement> IntContainer;
4971 typedef AssignmentContainer<IntervalVar, IntervalVarElement>
4973 typedef AssignmentContainer<SequenceVar, SequenceVarElement>
4976 explicit Assignment(Solver*
const s);
4977 explicit Assignment(
const Assignment*
const copy);
4978 ~Assignment()
override;
4981 bool Empty()
const {
4982 return int_var_container_.Empty() && interval_var_container_.Empty() &&
4983 sequence_var_container_.Empty();
4986 return NumIntVars() + NumIntervalVars() + NumSequenceVars();
4988 int NumIntVars()
const {
return int_var_container_.Size(); }
4989 int NumIntervalVars()
const {
return interval_var_container_.Size(); }
4990 int NumSequenceVars()
const {
return sequence_var_container_.Size(); }
4996 bool Load(
const std::string& filename);
5000 void Load(const AssignmentProto& assignment_proto);
5001 bool Save(
const std::string& filename)
const;
5005 #endif // #if !defined(SWIG)
5006 void Save(AssignmentProto*
const assignment_proto)
const;
5008 void AddObjective(IntVar*
const v);
5009 void ClearObjective() { objective_element_.Reset(
nullptr); }
5010 IntVar* Objective()
const;
5011 bool HasObjective()
const {
return (objective_element_.Var() !=
nullptr); }
5012 int64 ObjectiveMin()
const;
5013 int64 ObjectiveMax()
const;
5014 int64 ObjectiveValue()
const;
5015 bool ObjectiveBound()
const;
5016 void SetObjectiveMin(
int64 m);
5017 void SetObjectiveMax(
int64 m);
5021 IntVarElement* Add(IntVar*
const var);
5022 void Add(
const std::vector<IntVar*>& vars);
5024 IntVarElement* FastAdd(IntVar*
const var);
5025 int64 Min(
const IntVar*
const var)
const;
5026 int64 Max(
const IntVar*
const var)
const;
5028 bool Bound(
const IntVar*
const var)
const;
5029 void SetMin(
const IntVar*
const var,
int64 m);
5030 void SetMax(
const IntVar*
const var,
int64 m);
5034 IntervalVarElement* Add(IntervalVar*
const var);
5035 void Add(
const std::vector<IntervalVar*>& vars);
5037 IntervalVarElement* FastAdd(IntervalVar*
const var);
5038 int64 StartMin(
const IntervalVar*
const var)
const;
5039 int64 StartMax(
const IntervalVar*
const var)
const;
5040 int64 StartValue(
const IntervalVar*
const var)
const;
5041 int64 DurationMin(
const IntervalVar*
const var)
const;
5042 int64 DurationMax(
const IntervalVar*
const var)
const;
5043 int64 DurationValue(
const IntervalVar*
const var)
const;
5044 int64 EndMin(
const IntervalVar*
const var)
const;
5045 int64 EndMax(
const IntervalVar*
const var)
const;
5046 int64 EndValue(
const IntervalVar*
const var)
const;
5047 int64 PerformedMin(
const IntervalVar*
const var)
const;
5048 int64 PerformedMax(
const IntervalVar*
const var)
const;
5049 int64 PerformedValue(
const IntervalVar*
const var)
const;
5050 void SetStartMin(
const IntervalVar*
const var,
int64 m);
5051 void SetStartMax(
const IntervalVar*
const var,
int64 m);
5052 void SetStartRange(
const IntervalVar*
const var,
int64 mi,
int64 ma);
5053 void SetStartValue(
const IntervalVar*
const var,
int64 value);
5054 void SetDurationMin(
const IntervalVar*
const var,
int64 m);
5055 void SetDurationMax(
const IntervalVar*
const var,
int64 m);
5056 void SetDurationRange(
const IntervalVar*
const var,
int64 mi,
int64 ma);
5057 void SetDurationValue(
const IntervalVar*
const var,
int64 value);
5058 void SetEndMin(
const IntervalVar*
const var,
int64 m);
5059 void SetEndMax(
const IntervalVar*
const var,
int64 m);
5060 void SetEndRange(
const IntervalVar*
const var,
int64 mi,
int64 ma);
5061 void SetEndValue(
const IntervalVar*
const var,
int64 value);
5062 void SetPerformedMin(
const IntervalVar*
const var,
int64 m);
5063 void SetPerformedMax(
const IntervalVar*
const var,
int64 m);
5064 void SetPerformedRange(
const IntervalVar*
const var,
int64 mi,
int64 ma);
5065 void SetPerformedValue(
const IntervalVar*
const var,
int64 value);
5067 SequenceVarElement* Add(SequenceVar*
const var);
5068 void Add(
const std::vector<SequenceVar*>& vars);
5070 SequenceVarElement* FastAdd(SequenceVar*
const var);
5071 const std::vector<int>& ForwardSequence(
const SequenceVar*
const var)
const;
5072 const std::vector<int>& BackwardSequence(
const SequenceVar*
const var)
const;
5073 const std::vector<int>& Unperformed(
const SequenceVar*
const var)
const;
5074 void SetSequence(
const SequenceVar*
const var,
5075 const std::vector<int>& forward_sequence,
5076 const std::vector<int>& backward_sequence,
5077 const std::vector<int>& unperformed);
5078 void SetForwardSequence(
const SequenceVar*
const var,
5079 const std::vector<int>& forward_sequence);
5080 void SetBackwardSequence(
const SequenceVar*
const var,
5081 const std::vector<int>& backward_sequence);
5082 void SetUnperformed(
const SequenceVar*
const var,
5083 const std::vector<int>& unperformed);
5085 void Activate(
const IntVar*
const var);
5086 void Deactivate(
const IntVar*
const var);
5087 bool Activated(
const IntVar*
const var)
const;
5089 void Activate(
const IntervalVar*
const var);
5090 void Deactivate(
const IntervalVar*
const var);
5091 bool Activated(
const IntervalVar*
const var)
const;
5093 void Activate(
const SequenceVar*
const var);
5094 void Deactivate(
const SequenceVar*
const var);
5095 bool Activated(
const SequenceVar*
const var)
const;
5097 void ActivateObjective();
5098 void DeactivateObjective();
5099 bool ActivatedObjective()
const;
5101 std::string DebugString()
const override;
5103 bool AreAllElementsBound()
const {
5104 return int_var_container_.AreAllElementsBound() &&
5105 interval_var_container_.AreAllElementsBound() &&
5106 sequence_var_container_.AreAllElementsBound();
5109 bool Contains(
const IntVar*
const var)
const;
5110 bool Contains(
const IntervalVar*
const var)
const;
5111 bool Contains(
const SequenceVar*
const var)
const;
5113 void CopyIntersection(
const Assignment* assignment);
5116 void Copy(
const Assignment* assignment);
5119 const IntContainer& IntVarContainer()
const {
return int_var_container_; }
5120 IntContainer* MutableIntVarContainer() {
return &int_var_container_; }
5121 const IntervalContainer& IntervalVarContainer()
const {
5122 return interval_var_container_;
5124 IntervalContainer* MutableIntervalVarContainer() {
5125 return &interval_var_container_;
5127 const SequenceContainer& SequenceVarContainer()
const {
5128 return sequence_var_container_;
5130 SequenceContainer* MutableSequenceVarContainer() {
5131 return &sequence_var_container_;
5133 bool operator==(
const Assignment& assignment)
const {
5134 return int_var_container_ == assignment.int_var_container_ &&
5135 interval_var_container_ == assignment.interval_var_container_ &&
5136 sequence_var_container_ == assignment.sequence_var_container_ &&
5137 objective_element_ == assignment.objective_element_;
5139 bool operator!=(
const Assignment& assignment)
const {
5140 return !(*
this == assignment);
5144 IntContainer int_var_container_;
5145 IntervalContainer interval_var_container_;
5146 SequenceContainer sequence_var_container_;
5147 IntVarElement objective_element_;
5152 const Assignment& assignment);
5160 const std::vector<IntVar*>& target_vars,
5161 const Assignment* source_assignment,
5162 const std::vector<IntVar*>& source_vars);
5164 class Pack :
public Constraint {
5166 Pack(Solver*
const s,
const std::vector<IntVar*>& vars,
int number_of_bins);
5178 void AddWeightedSumLessOrEqualConstantDimension(
5179 const std::vector<int64>& weights,
const std::vector<int64>&
bounds);
5185 void AddWeightedSumLessOrEqualConstantDimension(
5186 Solver::IndexEvaluator1 weights,
const std::vector<int64>&
bounds);
5192 void AddWeightedSumLessOrEqualConstantDimension(
5193 Solver::IndexEvaluator2 weights,
const std::vector<int64>&
bounds);
5197 void AddWeightedSumEqualVarDimension(
const std::vector<int64>& weights,
5198 const std::vector<IntVar*>& loads);
5203 void AddWeightedSumEqualVarDimension(Solver::IndexEvaluator2 weights,
5204 const std::vector<IntVar*>& loads);
5215 void AddSumVariableWeightsLessOrEqualConstantDimension(
5216 const std::vector<IntVar*>& usage,
const std::vector<int64>&
capacity);
5220 void AddWeightedSumOfAssignedDimension(
const std::vector<int64>& weights,
5221 IntVar*
const cost_var);
5225 void AddCountUsedBinDimension(IntVar*
const count_var);
5229 void AddCountAssignedItemsDimension(IntVar*
const count_var);
5231 void Post()
override;
5233 void PropagateDelayed();
5234 void InitialPropagate()
override;
5236 void OneDomain(
int var_index);
5237 std::string DebugString()
const override;
5238 bool IsUndecided(
int var_index,
int bin_index)
const;
5239 void SetImpossible(
int var_index,
int bin_index);
5240 void Assign(
int var_index,
int bin_index);
5241 bool IsAssignedStatusKnown(
int var_index)
const;
5242 bool IsPossible(
int var_index,
int bin_index)
const;
5243 IntVar* AssignVar(
int var_index,
int bin_index)
const;
5244 void SetAssigned(
int var_index);
5245 void SetUnassigned(
int var_index);
5246 void RemoveAllPossibleFromBin(
int bin_index);
5247 void AssignAllPossibleToBin(
int bin_index);
5248 void AssignFirstPossibleToBin(
int bin_index);
5249 void AssignAllRemainingItems();
5250 void UnassignAllRemainingItems();
5251 void Accept(ModelVisitor*
const visitor)
const override;
5254 bool IsInProcess()
const;
5255 const std::vector<IntVar*>
vars_;
5257 std::vector<Dimension*> dims_;
5258 std::unique_ptr<RevBitMatrix> unprocessed_;
5259 std::vector<std::vector<int>> forced_;
5260 std::vector<std::vector<int>> removed_;
5261 std::vector<IntVarIterator*>
holes_;
5264 std::vector<std::pair<int, int>> to_set_;
5265 std::vector<std::pair<int, int>> to_unset_;
5269 class DisjunctiveConstraint :
public Constraint {
5271 DisjunctiveConstraint(Solver*
const s,
5272 const std::vector<IntervalVar*>& intervals,
5273 const std::string&
name);
5274 ~DisjunctiveConstraint()
override;
5277 virtual SequenceVar* MakeSequenceVar() = 0;
5283 void SetTransitionTime(Solver::IndexEvaluator2 transition_time);
5285 int64 TransitionTime(
int before_index,
int after_index) {
5286 DCHECK(transition_time_);
5287 return transition_time_(before_index, after_index);
5291 virtual const std::vector<IntVar*>& nexts()
const = 0;
5292 virtual const std::vector<IntVar*>& actives()
const = 0;
5293 virtual const std::vector<IntVar*>& time_cumuls()
const = 0;
5294 virtual const std::vector<IntVar*>& time_slacks()
const = 0;
5295 #endif // !defined(SWIG)
5298 const std::vector<IntervalVar*> intervals_;
5299 Solver::IndexEvaluator2 transition_time_;
5307 class SolutionPool :
public BaseObject {
5310 ~SolutionPool()
override {}
5314 virtual void Initialize(Assignment*
const assignment) = 0;
5318 virtual void RegisterNewSolution(Assignment*
const assignment) = 0;
5322 virtual void GetNextSolution(Assignment*
const assignment) = 0;
5326 virtual bool SyncNeeded(Assignment*
const local_assignment) = 0;
5330 #endif // OR_TOOLS_CONSTRAINT_SOLVER_CONSTRAINT_SOLVER_H_
1.8.18