Google OR-Tools: ortools/constraint_solver/constraint

Google OR-Tools: ortools/constraint_solver/constraint_solver.h Source File

69#ifndef ORTOOLS_CONSTRAINT_SOLVER_CONSTRAINT_SOLVER_H_

70#define ORTOOLS_CONSTRAINT_SOLVER_CONSTRAINT_SOLVER_H_

72#include <stddef.h>

73#include <stdint.h>

75#include <deque>

76#include <functional>

77#include <memory>

78#include <ostream>

79#include <random>

80#include <string>

81#include <utility>

82#include <vector>

84#include "absl/base/attributes.h"

85#include "absl/base/log_severity.h"

86#include "absl/container/flat_hash_map.h"

87#include "absl/container/flat_hash_set.h"

88#include "absl/flags/declare.h"

89#include "absl/flags/flag.h"

90#include "absl/log/check.h"

91#include "absl/random/random.h"

92#include "absl/strings/str_format.h"

93#include "absl/strings/string_view.h"

94#include "absl/time/time.h"

95#include "absl/types/span.h"

107

108#ifndef SWIG

111#endif

112

114

116

117class Assignment;

118class AssignmentProto;

119class BaseObject;

120class CastConstraint;

122class Decision;

123class DecisionBuilder;

124class DecisionVisitor;

125class Demon;

126class DemonProfiler;

127class Dimension;

128class DisjunctiveConstraint;

129class ImprovementSearchLimit;

130class IntExpr;

131class IntVar;

132class IntVarAssignment;

133class IntVarLocalSearchFilter;

134class IntervalVar;

135class IntervalVarAssignment;

136class LocalSearch;

137class LocalSearchFilter;

138class LocalSearchFilterManager;

139class LocalSearchMonitor;

140class LocalSearchOperator;

141class LocalSearchPhaseParameters;

142class LocalSearchProfiler;

143class ModelCache;

144class ModelVisitor;

145class ObjectiveMonitor;

146class BaseObjectiveMonitor;

147class OptimizeVar;

148class Pack;

149class ProfiledDecisionBuilder;

150class PropagationBaseObject;

151class PropagationMonitor;

152class Queue;

153class RegularLimit;

154class RegularLimitParameters;

155class RevBitMatrix;

156class Search;

157class SearchLimit;

158class SearchMonitor;

159class SequenceVar;

160class SequenceVarAssignment;

161class SolutionCollector;

162class SolutionPool;

163class SymmetryBreaker;

164struct StateInfo;

165struct Trail;

166template <class T>

167class SimpleRevFIFO;

168template <typename F>

169class LightIntFunctionElementCt;

170template <typename F>

171class LightIntIntFunctionElementCt;

172template <typename F>

173class LightIntIntIntFunctionElementCt;

174

176 return absl::GetFlag(FLAGS_cp_random_seed) == -1

177 ? absl::Uniform<int64_t>(absl::BitGen(), 0, kint64max)

178 : absl::GetFlag(FLAGS_cp_random_seed);

179}

180

185 public:

191

196

198

202

205

209

214

219

222

226

229

233

236

239

241};

242

260 public:

274

277

283

286

291

294

302

310

318

326

332

338

343

348

352

356 };

357

358

364

367

370

373

376

381

385

389 };

390

414

422

437

453

470

473

484

497

507

516

526

535

545

559

568

572

577

587

592

601 };

602

628

642

657

663

666

669

672

675

678

681

684

689 };

690

696

699

702

705

708

711

716

721 };

722

751

755

771

774

775#ifndef SWIG

804#endif

805

809 typedef std::function<int64_t(int64_t, int64_t, int64_t)> IndexEvaluator3;

810

812

814

815 typedef std::function<int64_t(Solver* solver,

816 const std::vector<IntVar*>& vars,

817 int64_t first_unbound, int64_t last_unbound)>

819

820 typedef std::function<int64_t(const IntVar* v, int64_t id)>

822 typedef std::function<bool(int64_t, int64_t, int64_t)>

825

827 typedef std::function<void()> Closure;

828

830 explicit Solver(const std::string& name);

832

833#ifndef SWIG

834

837#endif

838

840

843

845 return parameters_;

846 }

847

848

850

852

856 template <class T>

858 InternalSaveValue(o);

859 }

860

873 template <typename T>

875 return reinterpret_cast<T*>(SafeRevAlloc(object));

879

884 template <typename T>

886 return reinterpret_cast<T*>(SafeRevAllocArray(object));

887 }

891

928

970 bool Solve(DecisionBuilder* db, const std::vector<SearchMonitor*>& monitors);

979

988

990 const std::vector<SearchMonitor*>& monitors);

998

1003

1013 const std::vector<SearchMonitor*>& monitors);

1020

1023

1028

1031

1033 void Fail();

1034

1035#if !defined(SWIG)

1041#endif

1042

1045

1048

1053 absl::Time Now() const;

1054

1058

1060 int64_t branches() const { return branches_; }

1061

1064

1067

1070

1072 int64_t failures() const { return fails_; }

1073

1075 int64_t neighbors() const { return neighbors_; }

1076

1081

1084

1087

1090 uint64_t stamp() const;

1091

1099 const std::string& context() const { return context_; }

1103 return optimization_direction_;

1104 }

1106 optimization_direction_ = direction;

1107 }

1108

1109

1110

1112 std::function<int64_t(int64_t, int64_t, int64_t)> penalty_callback) {

1113 penalty_callback_ = std::move(penalty_callback);

1114 }

1115

1117 return (penalty_callback_ == nullptr) ? 0 : penalty_callback_(i, j, k);

1118 }

1122

1123

1124

1129 IntVar* MakeIntVar(int64_t min, int64_t max, const std::string& name);

1133 const std::string& name);

1134

1136 IntVar* MakeIntVar(const std::vector<int>& values, const std::string& name);

1137

1140

1143

1146

1149

1152

1155

1158

1162 void MakeIntVarArray(int var_count, int64_t vmin, int64_t vmax,

1163 const std::string& name, std::vector<IntVar*>* vars);

1166 void MakeIntVarArray(int var_count, int64_t vmin, int64_t vmax,

1167 std::vector<IntVar*>* vars);

1170 const std::string& name);

1171

1175 void MakeBoolVarArray(int var_count, const std::string& name,

1176 std::vector<IntVar*>* vars);

1179 void MakeBoolVarArray(int var_count, std::vector<IntVar*>* vars);

1182

1183

1184

1191

1194 const std::vector<int64_t>& coefs);

1197 const std::vector<int>& coefs);

1198

1205

1210

1215

1222

1227

1242

1245

1246#if !defined(SWIG)

1249 int64_t range_end, IntVar* argument);

1250#endif

1251

1256

1263 template <typename F>

1265 std::function<bool()> deep_serialize = nullptr) {

1267 this, var, index, std::move(values), std::move(deep_serialize)));

1268 }

1269

1276 template <typename F>

1279 std::function<bool()> deep_serialize = nullptr) {

1281 this, var, index1, index2, std::move(values),

1282 std::move(deep_serialize)));

1283 }

1284

1289 template <typename F>

1292 IntVar* const index3) {

1294 this, var, index1, index2, index3, std::move(values)));

1295 }

1296

1298

1300

1313

1322

1325 int64_t early_date, int64_t late_date,

1326 int64_t late_cost);

1327

1331 int64_t step);

1332

1335

1337#ifndef SWIG

1340#endif

1341

1344

1347

1350 int64_t unperformed_value);

1351

1357

1372

1388

1404

1420

1435

1450

1454 int64_t cst);

1458 const std::vector<int64_t>& coefficients,

1459 int64_t cst);

1461 const std::vector<int>& coefficients,

1462 int64_t cst);

1464 const std::vector<int64_t>& coefficients,

1467 const std::vector<int>& coefficients,

1470 const std::vector<int64_t>& coeffs,

1471 int64_t cst);

1473 const std::vector<int>& coeffs,

1474 int64_t cst);

1476 const std::vector<int64_t>& coefficients,

1477 int64_t cst);

1479 const std::vector<int>& coefficients,

1480 int64_t cst);

1481

1486

1494 IntVar* index, int64_t target);

1502 IntVar* index, int64_t target);

1503

1511#if !defined(SWIG)

1514#endif

1517

1518

1519

1522

1528

1532

1533

1534

1539

1542 const std::vector<int64_t>& values);

1544

1547 std::vector<int64_t> ends);

1550 std::vector<int> ends);

1551#if !defined(SWIG)

1555#endif

1556

1564

1567 int64_t max_count);

1570 int64_t max_count);

1574

1577 const std::vector<int64_t>& values,

1578 const std::vector<IntVar*>& cards);

1581 const std::vector<int>& values,

1582 const std::vector<IntVar*>& cards);

1585 const std::vector<IntVar*>& cards);

1589 int64_t card_max, int64_t card_size);

1594 const std::vector<int64_t>& card_min,

1595 const std::vector<int64_t>& card_max);

1600 const std::vector<int>& card_min,

1601 const std::vector<int>& card_max);

1606 const std::vector<int64_t>& values,

1607 const std::vector<int64_t>& card_min,

1608 const std::vector<int64_t>& card_max);

1613 const std::vector<int>& values,

1614 const std::vector<int>& card_min,

1615 const std::vector<int>& card_max);

1616

1622 IntVar* deviation_var, int64_t total_sum);

1623

1627

1632 bool stronger_propagation);

1633

1637 int64_t escape_value);

1638

1639

1656 const std::vector<IntVar*>& sorted);

1657

1658

1659

1660

1664 const std::vector<IntVar*>& right);

1665

1669 const std::vector<IntVar*>& right);

1670

1676 std::vector<IntVar*> right,

1677 std::vector<int64_t> offsets);

1678

1679

1681 std::vector<IntVar*> left, std::vector<IntVar*> right,

1682 std::vector<int64_t> offsets, IntVar* boolvar);

1683

1689 const std::vector<IntVar*>& left, const std::vector<IntVar*>& right);

1690

1694 IntVar* index, const std::vector<IntVar*>& vars);

1695

1699 IntVar* index, const std::vector<IntVar*>& vars);

1700

1706 const std::vector<IntVar*>& second_vars);

1707

1714 const std::vector<IntVar*>& second_vars,

1715 int64_t escape_value);

1716

1717

1718

1719

1730 const std::vector<IntVar*>& active,

1733 const std::vector<IntVar*>& active,

1734 IndexFilter1 sink_handler, bool assume_paths);

1735

1738

1742

1748 const std::vector<IntVar*>& active,

1749 const std::vector<IntVar*>& cumuls,

1750 const std::vector<IntVar*>& transits);

1753

1755 const std::vector<IntVar*>& active,

1756 const std::vector<IntVar*>& cumuls,

1757 const std::vector<IntVar*>& transits);

1765 const std::vector<IntVar*>& active,

1766 const std::vector<IntVar*>& cumuls,

1768

1776 const std::vector<IntVar*>& active,

1777 const std::vector<IntVar*>& cumuls,

1778 const std::vector<IntVar*>& slacks,

1782

1785 std::vector<int64_t> sources,

1786 std::vector<int64_t> sinks,

1787 std::vector<IntVar*> status);

1788#ifndef SWIG

1791

1795 std::vector<IntVar*> nexts,

1796 const std::vector<std::pair<int, int>>& precedences);

1806 std::vector<IntVar*> nexts,

1807 const std::vector<std::pair<int, int>>& precedences,

1808 absl::Span<const int> lifo_path_starts,

1809 absl::Span<const int> fifo_path_starts);

1813 std::vector<IntVar*> nexts, std::vector<IntVar*> transits,

1814 const std::vector<std::pair<int, int>>& precedences);

1833 struct EnergyCost {

1837 bool IsNull() const {

1840 }

1841 };

1842 std::vector<IntVar*> nexts;

1843 std::vector<IntVar*> paths;

1844 std::vector<IntVar*> forces;

1858 Constraint* MakeMapDomain(IntVar* var, const std::vector<IntVar*>& actives);

1869

1875 const std::vector<IntVar*>& vars, const IntTupleSet& transition_table,

1876 int64_t initial_state, const std::vector<int64_t>& final_states);

1877

1887 int64_t initial_state,

1888 const std::vector<int>& final_states);

1889

1890#if defined(SWIGPYTHON)

1893 const std::vector<IntVar*>& vars,

1894 const std::vector<std::vector<int64_t> >& raw_tuples) {

1896 tuples.InsertAll(raw_tuples);

1898 }

1899

1901 const std::vector<IntVar*>& vars,

1902 const std::vector<std::vector<int64_t> >&

1903 raw_transitions,

1904 int64_t initial_state, const std::vector<int>& final_states) {

1906 transitions.InsertAll(raw_transitions);

1908 final_states);

1909 }

1910#endif

1911

1921 const std::vector<IntVar*>& x_vars, const std::vector<IntVar*>& y_vars,

1922 const std::vector<IntVar*>& x_size, const std::vector<IntVar*>& y_size);

1924 const std::vector<IntVar*>& x_vars, const std::vector<IntVar*>& y_vars,

1925 absl::Span<const int64_t> x_size, absl::Span<const int64_t> y_size);

1927 const std::vector<IntVar*>& x_vars, const std::vector<IntVar*>& y_vars,

1928 absl::Span<const int> x_size, absl::Span<const int> y_size);

1929

1939 const std::vector<IntVar*>& x_vars, const std::vector<IntVar*>& y_vars,

1940 const std::vector<IntVar*>& x_size, const std::vector<IntVar*>& y_size);

1942 const std::vector<IntVar*>& x_vars, const std::vector<IntVar*>& y_vars,

1943 absl::Span<const int64_t> x_size, absl::Span<const int64_t> y_size);

1945 const std::vector<IntVar*>& x_vars, const std::vector<IntVar*>& y_vars,

1946 absl::Span<const int> x_size, absl::Span<const int> y_size);

1947

1953 Pack* MakePack(const std::vector<IntVar*>& vars, int number_of_bins);

1954

1960 int64_t start_max, int64_t duration,

1961 bool optional,

1962 const std::string& name);

1963

1967 int64_t start_max, int64_t duration,

1968 bool optional, absl::string_view name,

1969 std::vector<IntervalVar*>* array);

1970

1974 int64_t duration,

1975 const std::string& name);

1976

1980 int64_t duration,

1981 IntVar* performed_variable,

1982 const std::string& name);

1983

1987 const std::vector<IntVar*>& start_variables, int64_t duration,

1988 absl::string_view name, std::vector<IntervalVar*>* array);

1989

1993 const std::vector<IntVar*>& start_variables,

1994 absl::Span<const int64_t> durations, absl::string_view name,

1995 std::vector<IntervalVar*>* array);

1999 const std::vector<IntVar*>& start_variables,

2000 absl::Span<const int> durations, absl::string_view name,

2001 std::vector<IntervalVar*>* array);

2002

2006 const std::vector<IntVar*>& start_variables,

2007 absl::Span<const int64_t> durations,

2008 const std::vector<IntVar*>& performed_variables, absl::string_view name,

2009 std::vector<IntervalVar*>* array);

2010

2014 const std::vector<IntVar*>& start_variables,

2015 absl::Span<const int> durations,

2016 const std::vector<IntVar*>& performed_variables, absl::string_view name,

2017 std::vector<IntervalVar*>* array);

2018

2021 const std::string& name);

2022

2026 int64_t duration_min, int64_t duration_max,

2027 int64_t end_min, int64_t end_max, bool optional,

2028 const std::string& name);

2029

2033 int64_t duration_min, int64_t duration_max,

2034 int64_t end_min, int64_t end_max, bool optional,

2035 absl::string_view name,

2036 std::vector<IntervalVar*>* array);

2037

2041

2047 IntervalVar* interval_var, int64_t duration, int64_t offset);

2048

2054 IntervalVar* interval_var, int64_t duration, int64_t offset);

2055

2061 IntervalVar* interval_var, int64_t duration, int64_t offset);

2062

2068 IntervalVar* interval_var, int64_t duration, int64_t offset);

2069

2088

2107

2111 int64_t d);

2112

2116

2124

2130

2134

2138 const std::vector<IntervalVar*>& intervals, const std::string& name);

2139

2144 const std::vector<IntervalVar*>& intervals, const std::string& name);

2145

2156 const std::vector<int64_t>& demands,

2157 int64_t capacity, const std::string& name);

2158

2169 const std::vector<int>& demands, int64_t capacity,

2170 const std::string& name);

2171

2182 const std::vector<int64_t>& demands,

2183 IntVar* capacity, absl::string_view name);

2184

2195 const std::vector<int>& demands, IntVar* capacity,

2196 const std::string& name);

2197

2206 const std::vector<IntVar*>& demands,

2207 int64_t capacity, const std::string& name);

2208

2217 const std::vector<IntVar*>& demands,

2218 IntVar* capacity, const std::string& name);

2219

2227

2230

2233

2236

2242

2248

2254 const Assignment* assignment, bool maximize);

2258 const Assignment* assignment, std::vector<bool> maximize);

2268 std::vector<bool> maximize);

2269

2274 const Assignment* assignment, int solution_count, bool maximize);

2276 bool maximize);

2280 const Assignment* assignment, int solution_count,

2281 std::vector<bool> maximize);

2283 int solution_count, std::vector<bool> maximize);

2284

2290

2293

2296

2299

2303 const std::vector<int64_t>& weights,

2304 int64_t step);

2305

2309 const std::vector<int>& weights,

2310 int64_t step);

2311

2314 const std::vector<int64_t>& weights,

2315 int64_t step);

2316

2319 const std::vector<int>& weights,

2320 int64_t step);

2321

2324 const std::vector<IntVar*>& sub_objectives,

2325 const std::vector<int64_t>& weights,

2326 int64_t step);

2327

2330 const std::vector<IntVar*>& sub_objectives,

2331 const std::vector<int>& weights,

2332 int64_t step);

2333

2337 std::vector<IntVar*> variables,

2338 std::vector<int64_t> steps);

2339

2341

2357

2359 int64_t step,

2360 const std::vector<IntVar*>& vars,

2361 int64_t keep_tenure, int64_t forbid_tenure,

2362 double tabu_factor);

2363

2365 const std::vector<bool>& maximize, std::vector<IntVar*> objectives,

2366 std::vector<int64_t> steps, const std::vector<IntVar*>& vars,

2367 int64_t keep_tenure, int64_t forbid_tenure, double tabu_factor);

2368

2372 int64_t step,

2373 const std::vector<IntVar*>& tabu_vars,

2374 int64_t forbid_tenure);

2375

2377

2379 int64_t step,

2380 int64_t initial_temperature);

2382 const std::vector<bool>& maximize, std::vector<IntVar*> vars,

2383 std::vector<int64_t> steps, std::vector<int64_t> initial_temperatures);

2384

2387#ifndef SWIG

2390 int64_t step, const std::vector<IntVar*>& vars, double penalty_factor,

2391 std::function<std::vector<std::pair<int64_t, int64_t>>(int64_t, int64_t)>

2392 get_equivalent_pairs = nullptr,

2393 bool reset_penalties_on_new_best_solution = false);

2396 int64_t step, const std::vector<IntVar*>& vars,

2397 const std::vector<IntVar*>& secondary_vars, double penalty_factor,

2398 std::function<std::vector<std::pair<int64_t, int64_t>>(int64_t, int64_t)>

2399 get_equivalent_pairs = nullptr,

2400 bool reset_penalties_on_new_best_solution = false);

2401#endif

2402

2403

2404

2405

2406

2408 std::vector<BaseObjectiveMonitor*> monitors,

2409 int num_max_local_optima_before_metaheuristic_switch);

2410

2415

2419

2422#if !defined(SWIG)

2423 ABSL_DEPRECATED("Use the version taking absl::Duration() as argument")

2424#endif

2427 ? absl::InfiniteDuration()

2428 : absl::Milliseconds(time_in_ms));

2429 }

2430

2434

2438

2442

2445

2446

2447 ABSL_MUST_USE_RESULT RegularLimit* MakeLimit(absl::Duration time,

2451 bool smart_time_check = false,

2452 bool cumulative = false);

2454 ABSL_MUST_USE_RESULT RegularLimit* MakeLimit(

2455 const RegularLimitParameters& proto);

2456

2457#if !defined(SWIG)

2458 ABSL_DEPRECATED("Use other MakeLimit() versions")

2459#endif

2463 bool smart_time_check = false,

2464 bool cumulative = false);

2465

2468

2474

2480 IntVar* objective_var, bool maximize, double objective_scaling_factor,

2481 double objective_offset, double improvement_rate_coefficient,

2482 int improvement_rate_solutions_distance);

2487 std::vector<IntVar*> objective_vars, std::vector<bool> maximize,

2488 std::vector<double> objective_scaling_factors,

2489 std::vector<double> objective_offsets,

2490 double improvement_rate_coefficient,

2491 int improvement_rate_solutions_distance);

2492

2496 std::function<bool()> limiter);

2497

2498

2499

2503

2506

2510 std::function<std::string()> display_callback);

2511

2515 std::function<std::string()> display_callback);

2516

2520 std::function<std::string()> display_callback);

2521

2525

2529 std::function<std::string()> display_callback);

2530

2544 std::vector<double> offsets;

2552 };

2554

2558

2563

2568#if !defined(SWIG)

2571 absl::flat_hash_map<const IntVar*, int>* map);

2572#endif

2573

2576 const std::vector<SymmetryBreaker*>& visitors);

2583

2589 bool start_with_lower_half);

2593 const std::vector<int64_t>& values);

2595 const std::vector<IntVar*>& vars, const std::vector<int64_t>& values);

2597 const std::vector<int64_t>& values);

2600

2615

2627

2638

2640

2647

2651

2657

2661

2666

2671

2675

2685

2692 int64_t* marker);

2693

2700 int64_t* marker);

2701

2705

2709

2717

2728

2732

2735

2740 const std::vector<IntVar*>& vars);

2741

2745

2762 const std::vector<SearchMonitor*>& monitors);

2763

2772 bool maximize, int64_t step);

2774 bool maximize, int64_t step,

2777 bool maximize, int64_t step,

2781 bool maximize, int64_t step,

2786 bool maximize, int64_t step,

2793 const std::vector<SearchMonitor*>& monitors);

2794

2798

2802

2806 std::function<const std::vector<int>&(int, int)> get_incoming_neighbors =

2807 nullptr,

2808 std::function<const std::vector<int>&(int, int)> get_outgoing_neighbors =

2809 nullptr);

2811 const std::vector<IntVar*>& vars,

2813 std::function<const std::vector<int>&(int, int)> get_incoming_neighbors =

2814 nullptr,

2815 std::function<const std::vector<int>&(int, int)> get_outgoing_neighbors =

2816 nullptr);

2817

2818

2823 const std::vector<IntVar*>& secondary_vars,

2826

2835 int number_of_variables);

2837 int number_of_variables,

2838 int32_t seed);

2839

2846

2854 const std::vector<IntVar*>& variables,

2855 const std::vector<int64_t>& target_values);

2856

2888 const std::vector<LocalSearchOperator*>& ops);

2890 const std::vector<LocalSearchOperator*>& ops, bool restart);

2892 const std::vector<LocalSearchOperator*>& ops,

2893 std::function<int64_t(int, int)> evaluator);

2897 const std::vector<LocalSearchOperator*>& ops);

2898

2903 const std::vector<LocalSearchOperator*>& ops, int32_t seed);

2904

2913 const std::vector<LocalSearchOperator*>& ops, double memory_coefficient,

2914 double exploration_coefficient, bool maximize);

2915

2922 int64_t limit);

2923

2948

2949

2950

2958 const std::vector<IntVar*>& vars, DecisionBuilder* first_solution,

2964

2973 const std::vector<SearchMonitor*>& monitors, RegularLimit* limit,

2974 absl::flat_hash_set<IntVar*>* touched = nullptr);

2975

2978

2990

3001

3007 const std::vector<IntVar*>& vars, IndexEvaluator2 values,

3010 const std::vector<IntVar*>& vars,

3011 const std::vector<IntVar*>& secondary_vars, IndexEvaluator3 values,

3013

3021

3027

3031

3035

3039

3042

3045

3047 template <class T>

3049 if (*adr != val) {

3050 InternalSaveValue(adr);

3051 *adr = val;

3052 }

3053 }

3054

3056 template <class T>

3058 if (val != 0) {

3059 InternalSaveValue(adr);

3060 (*adr) += val;

3061 }

3062 }

3063

3065 int64_t Rand64(int64_t size) {

3066 DCHECK_GT(size, 0);

3067 return absl::Uniform<int64_t>(random_, 0, size);

3068 }

3069

3071 int32_t Rand32(int32_t size) {

3072 DCHECK_GT(size, 0);

3073 return absl::Uniform<int32_t>(random_, 0, size);

3074 }

3075

3077 void ReSeed(int32_t seed) { random_.seed(seed); }

3078

3083

3085

3087

3088#if !defined(SWIG)

3097

3099

3100

3101

3102 int constraints() const { return constraints_list_.size(); }

3103

3106

3112 fail_intercept_ = std::move(fail_intercept);

3113 }

3118

3122 use_fast_local_search_ = use_fast_local_search;

3123 }

3137

3141 ModelCache* Cache() const;

3157

3169

3173

3179

3184 friend class IntVar;

3186 friend class Queue;

3192

3193#if !defined(SWIG)

3195 template <class>

3197 template <class K, class V>

3199

3205

3211#endif

3212

3216

3220

3225 if (!should_fail_) return;

3226 should_fail_ = false;

3234 void Init();

3237 void PushSentinel(int magic_code);

3238 void BacktrackToSentinel(int magic_code);

3239 void ProcessConstraints();

3240 bool BacktrackOneLevel(Decision** fail_decision);

3241 void JumpToSentinelWhenNested();

3242 void JumpToSentinel();

3243 void check_alloc_state();

3244 void FreezeQueue();

3245 void EnqueueVar(Demon* d);

3246 void EnqueueDelayedDemon(Demon* d);

3249 void UnfreezeQueue();

3250 void reset_action_on_fail();

3251 void set_action_on_fail(Action a);

3252 void set_variable_to_clean_on_fail(IntVar* v);

3253 void IncrementUncheckedSolutionCounter();

3254 bool IsUncheckedSolutionLimitReached();

3255

3256 void InternalSaveValue(int* valptr);

3257 void InternalSaveValue(int64_t* valptr);

3258 void InternalSaveValue(uint64_t* valptr);

3259 void InternalSaveValue(double* valptr);

3260 void InternalSaveValue(bool* valptr);

3261 void InternalSaveValue(void** valptr);

3262 void InternalSaveValue(int64_t** valptr) {

3263 InternalSaveValue(reinterpret_cast<void**>(valptr));

3264 }

3265

3268 int* SafeRevAllocArray(int* ptr);

3269 int64_t* SafeRevAllocArray(int64_t* ptr);

3270 uint64_t* SafeRevAllocArray(uint64_t* ptr);

3271 double* SafeRevAllocArray(double* ptr);

3278 void* UnsafeRevAllocAux(void* ptr);

3279 template <class T>

3280 T* UnsafeRevAlloc(T* ptr) {

3281 return reinterpret_cast<T*>(

3282 UnsafeRevAllocAux(reinterpret_cast<void*>(ptr)));

3283 }

3284 void** UnsafeRevAllocArrayAux(void** ptr);

3285 template <class T>

3286 T** UnsafeRevAllocArray(T** ptr) {

3287 return reinterpret_cast<T**>(

3288 UnsafeRevAllocArrayAux(reinterpret_cast<void**>(ptr)));

3289 }

3290

3291 void InitCachedIntConstants();

3292 void InitCachedConstraint();

3293

3297 Search* TopLevelSearch() const { return searches_.at(1); }

3301 Search* ParentSearch() const {

3302 const size_t search_size = searches_.size();

3303 DCHECK_GT(search_size, 1);

3304 return searches_[search_size - 2];

3305 }

3306

3307 template <bool is_profile_active>

3308 Assignment* RunUncheckedLocalSearchInternal(

3309 const Assignment* initial_solution,

3310 LocalSearchFilterManager* filter_manager,

3311 LocalSearchOperator* ls_operator,

3312 const std::vector<SearchMonitor*>& monitors, RegularLimit* limit,

3313 absl::flat_hash_set<IntVar*>* touched);

3314

3318

3321 int GetNewIntVarIndex() { return num_int_vars_++; }

3322

3324 bool IsADifference(IntExpr* expr, IntExpr** left, IntExpr** right);

3325

3326 const std::string name_;

3327 const ConstraintSolverParameters parameters_;

3328 absl::flat_hash_map<const PropagationBaseObject*, std::string>

3329 propagation_object_names_;

3330 absl::flat_hash_map<const PropagationBaseObject*, IntegerCastInfo>

3331 cast_information_;

3332 absl::flat_hash_set<const Constraint*> cast_constraints_;

3333 const std::string empty_name_;

3334 std::unique_ptr<Queue> queue_;

3335 std::unique_ptr<Trail> trail_;

3336 std::vector<Constraint*> constraints_list_;

3337 std::vector<Constraint*> additional_constraints_list_;

3338 std::vector<int> additional_constraints_parent_list_;

3340 int64_t branches_;

3341 int64_t fails_;

3342 int64_t decisions_;

3344 int64_t neighbors_;

3345 int64_t filtered_neighbors_;

3346 int64_t accepted_neighbors_;

3347 std::string context_;

3349 std::unique_ptr<ClockTimer> timer_;

3350 std::vector<Search*> searches_;

3351 std::mt19937 random_;

3352 uint64_t fail_stamp_;

3353 std::unique_ptr<Decision> balancing_decision_;

3355 std::function<void()> fail_intercept_;

3359 bool use_fast_local_search_;

3363 std::unique_ptr<Assignment> local_search_state_;

3364

3366 enum { MIN_CACHED_INT_CONST = -8, MAX_CACHED_INT_CONST = 8 };

3367 IntVar* cached_constants_[MAX_CACHED_INT_CONST + 1 - MIN_CACHED_INT_CONST];

3368

3372

3373 std::unique_ptr<Decision> fail_decision_;

3374 int constraint_index_;

3375 int additional_constraint_index_;

3376 int num_int_vars_;

3377

3378 std::unique_ptr<ModelCache> model_cache_;

3379 std::unique_ptr<PropagationMonitor> propagation_monitor_;

3380 PropagationMonitor* print_trace_;

3381 std::unique_ptr<LocalSearchMonitor> local_search_monitor_;

3382 int anonymous_variable_index_;

3383 bool should_fail_;

3384

3385 std::function<int64_t(int64_t, int64_t, int64_t)> penalty_callback_;

3386};

3387

3388std::ostream& operator<<(std::ostream& out, const Solver* const s);

3389

3393inline int64_t Zero() { return 0; }

3394

3396inline int64_t One() { return 1; }

3397

3402 public:

3404

3405#ifndef SWIG

3406

3409#endif

3411 virtual std::string DebugString() const { return "BaseObject"; }

3412};

3413

3415

3420 public:

3422

3423#ifndef SWIG

3424

3427#endif

3429

3430 std::string DebugString() const override {

3431 if (name().empty()) {

3432 return "PropagationBaseObject";

3433 } else {

3434 return absl::StrFormat("PropagationBaseObject: %s", name());

3435 }

3437 Solver* solver() const { return solver_; }

3438

3441 void FreezeQueue() { solver_->FreezeQueue(); }

3442

3456

3457

3459 solver_->set_action_on_fail(std::move(a));

3460 }

3461#endif

3465

3468 solver_->set_variable_to_clean_on_fail(v);

3470

3472 virtual std::string name() const;

3477 virtual std::string BaseName() const;

3478

3479 private:

3481};

3482

3486 public:

3489#ifndef SWIG

3490

3495

3498

3502 std::string DebugString() const override { return "Decision"; }

3505};

3506

3513#ifndef SWIG

3514

3517#endif

3521 bool start_with_lower_half);

3527};

3532 public:

3536

3539#endif

3546 std::string DebugString() const override;

3547#if !defined(SWIG)

3549

3553 std::vector<SearchMonitor*>* extras);

3555#endif

3556 void set_name(absl::string_view name) { name_ = name; }

3557 std::string GetName() const;

3560 std::string name_;

3562

3563#if !defined(SWIG)

3565 public:

3568 const std::string& name() const { return name_; }

3569 double seconds() const { return seconds_; }

3570 Decision* Next(Solver* solver) override;

3571 std::string DebugString() const override;

3573 std::vector<SearchMonitor*>* extras) override;

3575

3578 const std::string name_;

3580 double seconds_;

3582#endif

3594 public:

3597 Demon() : stamp_(uint64_t{0}) {}

3598

3600

3603#endif

3604 ~Demon() override {}

3605

3608

3613

3614 std::string DebugString() const override;

3615

3619

3622

3623 private:

3624 friend class Queue;

3625 void set_stamp(int64_t stamp) { stamp_ = stamp; }

3626 uint64_t stamp() const { return stamp_; }

3627 uint64_t stamp_;

3628};

3629

3631class

3632#ifndef SWIG

3634#endif

3638 static const char kAbs[];

3639 static const char kAbsEqual[];

3640 static const char kAllDifferent[];

3641 static const char kAllowedAssignments[];

3642 static const char kAtMost[];

3643 static const char kIndexOf[];

3644 static const char kBetween[];

3645 static const char kConditionalExpr[];

3646 static const char kCircuit[];

3647 static const char kConvexPiecewise[];

3648 static const char kCountEqual[];

3649 static const char kCover[];

3650 static const char kCumulative[];

3651 static const char kDeviation[];

3652 static const char kDifference[];

3653 static const char kDisjunctive[];

3654 static const char kDistribute[];

3655 static const char kDivide[];

3656 static const char kDurationExpr[];

3657 static const char kElement[];

3658 static const char kLightElementEqual[];

3659 static const char kElementEqual[];

3660 static const char kEndExpr[];

3661 static const char kEquality[];

3662 static const char kFalseConstraint[];

3663 static const char kGlobalCardinality[];

3664 static const char kGreater[];

3665 static const char kGreaterOrEqual[];

3666 static const char kIntegerVariable[];

3667 static const char kIntervalBinaryRelation[];

3668 static const char kIntervalDisjunction[];

3669 static const char kIntervalUnaryRelation[];

3670 static const char kIntervalVariable[];

3671 static const char kInversePermutation[];

3672 static const char kIsBetween[];

3673 static const char kIsDifferent[];

3677 static const char kIsLess[];

3680 static const char kLess[];

3830 const std::string& operation, int64_t value,

3833 const std::string& operation,

3840 const std::vector<int64_t>& values);

3843

3849 const std::string& arg_name, const std::vector<IntVar*>& arguments);

3854

3856 const std::string& arg_name, const std::vector<IntervalVar*>& arguments);

3860

3862 const std::string& arg_name, const std::vector<SequenceVar*>& arguments);

3863#if !defined(SWIG)

3867

3871 int64_t index_max);

3873 int64_t index_min, int64_t index_max);

3876 const std::string& arg_name, int64_t index_max);

3877#endif

3878};

3879

3887 public:

3889

3890#ifndef SWIG

3891

3894#endif

3896

3899 virtual void Post() = 0;

3900

3904 std::string DebugString() const override;

3905

3909

3911 virtual void Accept(ModelVisitor* visitor) const;

3912

3915

3919 virtual IntVar* Var();

3920};

3921

3922

3926 public:

3930 }

3932

3934

3937};

3941 public:

3943

3945

3947

3950#endif

3954

3957

3960

3963

3964

3966

3982

3983

3988

3993

3998

4001

4005

4008

4011

4014

4018

4021

4025

4027 virtual void Accept(ModelVisitor* visitor) const;

4028

4033

4034 Solver* solver() const { return solver_; }

4035

4036 protected:

4038

4039 private:

4040 Solver* const solver_;

4041};

4042

4048template <class T>

4049class Rev {

4050 public:

4051 explicit Rev(const T& val) : stamp_(0), value_(val) {}

4052

4053 const T& Value() const { return value_; }

4054

4055 void SetValue(Solver* const s, const T& val) {

4056 if (val != value_) {

4057 if (stamp_ < s->stamp()) {

4058 s->SaveValue(&value_);

4059 stamp_ = s->stamp();

4060 }

4061 value_ = val;

4062 }

4063 }

4064

4065 private:

4066 uint64_t stamp_;

4067 T value_;

4069

4071template <class T>

4073 public:

4075

4076 void Add(Solver* const s, const T& to_add) {

4079

4081

4082 void Decr(Solver* const s) { Add(s, -1); }

4083};

4084

4086

4090template <class T>

4092 public:

4094 : stamps_(new uint64_t[size]), values_(new T[size]), size_(size) {

4095 for (int i = 0; i < size; ++i) {

4096 stamps_[i] = 0;

4097 values_[i] = val;

4098 }

4100

4102

4103 int64_t size() const { return size_; }

4104

4105 const T& Value(int index) const { return values_[index]; }

4106

4107#if !defined(SWIG)

4108 const T& operator[](int index) const { return values_[index]; }

4109#endif

4110

4111 void SetValue(Solver* const s, int index, const T& val) {

4112 DCHECK_LT(index, size_);

4113 if (val != values_[index]) {

4114 if (stamps_[index] < s->stamp()) {

4115 s->SaveValue(&values_[index]);

4116 stamps_[index] = s->stamp();

4117 }

4118 values_[index] = val;

4119 }

4123 std::unique_ptr<uint64_t[]> stamps_;

4124 std::unique_ptr<T[]> values_;

4125 const int size_;

4127

4128

4129template <class T>

4131 public:

4133

4134 void Add(Solver* const s, int index, const T& to_add) {

4136 }

4138 void Incr(Solver* const s, int index) { Add(s, index, 1); }

4139

4140 void Decr(Solver* const s, int index) { Add(s, index, -1); }

4141};

4142

4144

4151 public:

4153

4154#ifndef SWIG

4155

4158#endif

4160

4161 virtual int64_t Min() const = 0;

4162 virtual void SetMin(int64_t m) = 0;

4163 virtual int64_t Max() const = 0;

4164 virtual void SetMax(int64_t m) = 0;

4165

4168 virtual void Range(int64_t* l, int64_t* u) {

4169 *l = Min();

4170 *u = Max();

4171 }

4173 virtual void SetRange(int64_t l, int64_t u) {

4177

4181

4183

4185 virtual bool IsVar() const { return false; }

4186

4189

4195

4202

4203#if !defined(SWIG)

4208#endif

4209

4216

4221

4224

4230

4234

4236 virtual void Init() = 0;

4237

4239 virtual bool Ok() const = 0;

4240

4242 virtual int64_t Value() const = 0;

4245 virtual void Next() = 0;

4246

4248 std::string DebugString() const override { return "IntVar::Iterator"; }

4252

4257

4259 public:

4261 : it_(it), begin_was_called_(false) {

4262 it_->Init();

4263 }

4264 struct Iterator;

4265

4266 Iterator begin() {

4268 DCHECK(!begin_was_called_);

4269 begin_was_called_ = true;

4270 }

4272 }

4274

4275 struct Iterator {

4278 return Iterator(it, false);

4279 }

4281 return Iterator(it, true);

4282 }

4285 DCHECK(it->Ok());

4287 }

4291 return *this;

4293 bool operator!=(const Iterator& other) const {

4294 DCHECK(other.it == it);

4295 DCHECK(other.is_end);

4296 return it->Ok();

4297 }

4298

4299 private:

4300 Iterator(IntVarIterator* it, bool is_end) : it(it), is_end(is_end) {}

4301

4302 IntVarIterator* const it;

4303 const bool is_end;

4304 };

4306 private:

4308 bool begin_was_called_;

4309};

4310#endif

4319

4321

4328 bool IsVar() const override { return true; }

4338

4343 virtual void RemoveValues(const std::vector<int64_t>& values);

4344

4346 virtual void SetValues(const std::vector<int64_t>& values);

4347

4354 WhenBound(solver()->MakeClosureDemon(std::move(closure)));

4355 }

4356

4357#if !defined(SWIG)

4361 WhenBound(solver()->MakeActionDemon(std::move(action)));

4362 }

4363#endif

4364

4372 }

4373#if !defined(SWIG)

4379#endif

4380

4382 virtual uint64_t Size() const = 0;

4383

4386 virtual bool Contains(int64_t v) const = 0;

4387

4392

4397

4398

4399 virtual int64_t OldMin() const = 0;

4400

4401

4402 virtual int64_t OldMax() const = 0;

4403

4404 virtual int VarType() const;

4408

4414

4415

4416 int index() const { return index_; }

4417

4418 private:

4419 const int index_;

4420};

4424

4426 public:

4429

4430#ifndef SWIG

4431

4434#endif

4435

4437 void Install() override;

4438 std::string DebugString() const override { return "SolutionCollector"; }

4439

4442 void Add(const std::vector<IntVar*>& vars);

4444 void Add(const std::vector<IntervalVar*>& vars);

4446 void Add(const std::vector<SequenceVar*>& vars);

4448 void AddObjectives(const std::vector<IntVar*>& objectives);

4449

4452

4464

4467

4469 int64_t branches(int n) const;

4473 int64_t failures(int n) const;

4474

4480

4482 int64_t Value(int n, IntVar* var) const;

4486

4489

4492

4495

4507

4508 protected:

4511 int64_t time;

4517 };

4518

4521 void Push(const SolutionData& data) { solution_data_.push_back(data); }

4527

4528 std::unique_ptr<Assignment> prototype_;

4531#if !defined(SWIG)

4532 std::vector<std::unique_ptr<Assignment>> solution_pool_;

4533#endif

4534};

4535

4536

4537

4539 public:

4542#ifndef SWIG

4545#endif

4546 virtual IntVar* ObjectiveVar(int index) const = 0;

4548 virtual int64_t Step(int index) const = 0;

4549 virtual bool Maximize(int index) const = 0;

4550 virtual int64_t BestValue(int index) const = 0;

4551 virtual int Size() const = 0;

4552 bool is_active() const { return is_active_; }

4556 bool is_active_ = true;

4559

4560

4562 public:

4564 std::vector<IntVar*> vars, std::vector<int64_t> steps);

4569#endif

4571 return objective_vars_[index];

4572 }

4574 return minimization_vars_[index];

4576 int64_t Step(int index) const override { return steps_[index]; }

4579 }

4580 int64_t BestValue(int index) const override {

4584 int Size() const override { return objective_vars_.size(); }

4590 protected:

4591 const std::vector<IntVar*>& objective_vars() const { return objective_vars_; }

4593 return minimization_vars_;

4597 return current_values_[index];

4600 current_values_[index] = value;

4601 }

4602 template <typename T>

4604 if (Size() == 1) {

4608 for (int i = 0; i < Size(); ++i) {

4612 minimization_vars_, upper_bounds_, steps_));

4614 }

4615 template <typename T>

4617 const T& upper_bounds) {

4623 } else {

4624 for (int i = 0; i < Size(); ++i) {

4625 upper_bounds_[i] = solver->MakeIntConst(upper_bounds(i));

4626 }

4628 minimization_vars_, upper_bounds_, steps_, status));

4630 return status;

4631 }

4633

4635

4638 const std::vector<IntVar*> objective_vars_;

4639 std::vector<IntVar*> minimization_vars_;

4640 std::vector<IntVar*> upper_bounds_;

4641 std::vector<int64_t> steps_;

4642 std::vector<int64_t> best_values_;

4643 std::vector<int64_t> current_values_;

4647

4648

4650 public:

4652

4653

4655 std::vector<IntVar*> vars, std::vector<int64_t> steps);

4656#ifndef SWIG

4658#endif

4659

4660

4662

4665

4666#ifndef SWIG

4670 std::function<void(int64_t)> on_optimal_found) {

4671 on_optimal_found_ = std::move(on_optimal_found);

4672 }

4673#endif

4674

4680 virtual std::string Name() const;

4681 std::string DebugString() const override;

4684

4685 private:

4686 std::function<void(int64_t)> on_optimal_found_;

4687};

4688

4691 public:

4693

4695

4698#endif

4700

4702 bool crossed() const { return crossed_; }

4703

4711 virtual bool CheckWithOffset(absl::Duration offset) = 0;

4712

4719

4722

4728 std::string DebugString() const override {

4729 return absl::StrFormat("SearchLimit(crossed = %i)", crossed_);

4730 }

4731 void Install() override;

4732

4733 private:

4734 void TopPeriodicCheck();

4736 bool crossed_;

4738

4745 bool cumulative);

4751 void Init() override;

4755 absl::Duration duration_limit() const { return duration_limit_; }

4757 return duration_limit_ == absl::InfiniteDuration()

4760 }

4761 int64_t branches() const { return branches_; }

4762 int64_t failures() const { return failures_; }

4763 int64_t solutions() const { return solutions_; }

4767 void Install() override;

4768

4770 return solver_time_at_limit_start_ + duration_limit_;

4771 }

4772

4776 bool CheckTime(absl::Duration offset);

4777 absl::Duration TimeElapsed();

4778 static int64_t GetPercent(int64_t value, int64_t offset, int64_t total) {

4779 return (total > 0 && total < kint64max) ? 100 * (value - offset) / total

4780 : -1;

4781 }

4782

4783 absl::Duration duration_limit_;

4784 absl::Time solver_time_at_limit_start_;

4785 absl::Duration last_time_elapsed_;

4786 int64_t check_count_;

4787 int64_t next_check_;

4788 bool smart_time_check_;

4789 int64_t branches_;

4790 int64_t branches_offset_;

4791 int64_t failures_;

4792 int64_t failures_offset_;

4793 int64_t solutions_;

4794 int64_t solutions_offset_;

4801

4802 bool cumulative_;

4803};

4804

4805

4806

4807

4808

4809

4810

4811

4812

4813

4818 double objective_scaling_factor,

4819 double objective_offset,

4820 double improvement_rate_coefficient,

4821 int improvement_rate_solutions_distance);

4823 std::vector<bool> maximize,

4824 std::vector<double> objective_scaling_factors,

4825 std::vector<double> objective_offsets,

4826 double improvement_rate_coefficient,

4827 int improvement_rate_solutions_distance);

4833 void Init() override;

4834 void Install() override;

4835

4836 private:

4837 std::vector<IntVar*> objective_vars_;

4838 std::vector<bool> maximize_;

4839 std::vector<double> objective_scaling_factors_;

4840 std::vector<double> objective_offsets_;

4841 double improvement_rate_coefficient_;

4842 int improvement_rate_solutions_distance_;

4843

4844 std::vector<double> best_objectives_;

4845

4846 std::vector<std::deque<std::pair<double, int64_t> > > improvements_;

4847

4848 std::vector<double> thresholds_;

4849 bool objective_updated_;

4850 bool gradient_stage_;

4851};

4852

4860

4861

4862

4863class

4864#ifndef SWIG

4866#endif

4868 public:

4870 static const int64_t kMinValidValue;

4872 static const int64_t kMaxValidValue;

4875 set_name(name);

4876 }

4877

4878#ifndef SWIG

4879

4882#endif

4884

4887 virtual int64_t StartMin() const = 0;

4888 virtual int64_t StartMax() const = 0;

4889 virtual void SetStartMin(int64_t m) = 0;

4890 virtual void SetStartMax(int64_t m) = 0;

4891 virtual void SetStartRange(int64_t mi, int64_t ma) = 0;

4892 virtual int64_t OldStartMin() const = 0;

4893 virtual int64_t OldStartMax() const = 0;

4894 virtual void WhenStartRange(Demon* d) = 0;

4896 WhenStartRange(solver()->MakeClosureDemon(std::move(closure)));

4897 }

4898#if !defined(SWIG)

4900 WhenStartRange(solver()->MakeActionDemon(std::move(action)));

4901 }

4902#endif

4903 virtual void WhenStartBound(Demon* d) = 0;

4905 WhenStartBound(solver()->MakeClosureDemon(std::move(closure)));

4906 }

4907#if !defined(SWIG)

4910 }

4911#endif

4912

4914 virtual int64_t DurationMin() const = 0;

4915 virtual int64_t DurationMax() const = 0;

4924 }

4925#if !defined(SWIG)

4928 }

4929#endif

4934#if !defined(SWIG)

4938#endif

4942 virtual int64_t EndMax() const = 0;

4943 virtual void SetEndMin(int64_t m) = 0;

4944 virtual void SetEndMax(int64_t m) = 0;

4951 }

4952#if !defined(SWIG)

4957 virtual void WhenEndBound(Demon* d) = 0;

4959 WhenEndBound(solver()->MakeClosureDemon(std::move(closure)));

4961#if !defined(SWIG)

4965#endif

4975 virtual void SetPerformed(bool val) = 0;

4980 }

4984 }

4985#endif

4986

4993#if !defined(SWIG)

4998#endif

5002

5007

5013

5021

5022

5023

5027 const std::vector<IntVar*>& nexts, const std::string& name);

5031 std::string DebugString() const override;

5032

5033#if !defined(SWIG)

5039

5040 void HorizonRange(int64_t* hmin, int64_t* hmax) const;

5045

5047 void ComputeStatistics(int* ranked, int* not_ranked, int* unperformed) const;

5048#endif

5053

5063

5065

5069 std::vector<int>* possible_lasts);

5076 void RankSequence(const std::vector<int>& rank_first,

5077 const std::vector<int>& rank_last,

5078 const std::vector<int>& unperformed);

5079

5088 void FillSequence(std::vector<int>* rank_first, std::vector<int>* rank_last,

5089 std::vector<int>* unperformed) const;

5090

5093

5096

5098 int64_t size() const { return intervals_.size(); }

5099

5102

5103 private:

5104 int ComputeForwardFrontier();

5105 int ComputeBackwardFrontier();

5106 void UpdatePrevious() const;

5107

5108 const std::vector<IntervalVar*> intervals_;

5109 const std::vector<IntVar*> nexts_;

5110 mutable std::vector<int> previous_;

5111};

5112

5113class AssignmentElement {

5114 public:

5117

5118 void Activate() { activated_ = true; }

5119 void Deactivate() { activated_ = false; }

5120 bool Activated() const { return activated_; }

5121

5122 private:

5123 bool activated_;

5124};

5125

5127 public:

5131 void Reset(IntVar* var);

5134 IntVar* Var() const { return var_; }

5136 min_ = var_->Min();

5137 max_ = var_->Max();

5138 }

5140 if (var_ != nullptr) {

5141 var_->SetRange(min_, max_);

5142 }

5143 }

5146

5147 int64_t Min() const { return min_; }

5148 void SetMin(int64_t m) { min_ = m; }

5149 int64_t Max() const { return max_; }

5150 void SetMax(int64_t m) { max_ = m; }

5151 int64_t Value() const {

5152 DCHECK_EQ(min_, max_);

5153

5154 return min_;

5155 }

5156 bool Bound() const { return (max_ == min_); }

5157 void SetRange(int64_t l, int64_t u) {

5158 min_ = l;

5160 }

5163 max_ = v;

5169 return !(*this == element);

5170 }

5171

5174 int64_t min_;

5175 int64_t max_;

5177

5179 public:

5191

5192 int64_t StartMin() const { return start_min_; }

5193 int64_t StartMax() const { return start_max_; }

5195 CHECK_EQ(start_max_, start_min_);

5196 return start_max_;

5198 int64_t DurationMin() const { return duration_min_; }

5199 int64_t DurationMax() const { return duration_max_; }

5201 CHECK_EQ(duration_max_, duration_min_);

5202 return duration_max_;

5204 int64_t EndMin() const { return end_min_; }

5205 int64_t EndMax() const { return end_max_; }

5207 CHECK_EQ(end_max_, end_min_);

5208 return end_max_;

5209 }

5210 int64_t PerformedMin() const { return performed_min_; }

5211 int64_t PerformedMax() const { return performed_max_; }

5213 CHECK_EQ(performed_max_, performed_min_);

5214 return performed_max_;

5215 }

5216 void SetStartMin(int64_t m) { start_min_ = m; }

5217 void SetStartMax(int64_t m) { start_max_ = m; }

5219 start_min_ = mi;

5220 start_max_ = ma;

5221 }

5223 start_min_ = v;

5224 start_max_ = v;

5225 }

5226 void SetDurationMin(int64_t m) { duration_min_ = m; }

5227 void SetDurationMax(int64_t m) { duration_max_ = m; }

5229 duration_min_ = mi;

5230 duration_max_ = ma;

5233 duration_min_ = v;

5234 duration_max_ = v;

5235 }

5236 void SetEndMin(int64_t m) { end_min_ = m; }

5237 void SetEndMax(int64_t m) { end_max_ = m; }

5239 end_min_ = mi;

5240 end_max_ = ma;

5241 }

5243 end_min_ = v;

5244 end_max_ = v;

5249 performed_min_ = mi;

5250 performed_max_ = ma;

5253 performed_min_ = v;

5254 performed_max_ = v;

5255 }

5257 return (start_min_ == start_max_ && duration_min_ == duration_max_ &&

5258 end_min_ == end_max_ && performed_min_ == performed_max_);

5259 }

5263 return !(*this == element);

5265

5266 private:

5267 int64_t start_min_;

5268 int64_t start_max_;

5269 int64_t duration_min_;

5270 int64_t duration_max_;

5271 int64_t end_min_;

5272 int64_t end_max_;

5273 int64_t performed_min_;

5274 int64_t performed_max_;

5276};

5277

5278

5282

5283

5307 const std::vector<int>& Unperformed() const;

5308 void SetSequence(const std::vector<int>& forward_sequence,

5309 const std::vector<int>& backward_sequence,

5310 const std::vector<int>& unperformed);

5313 void SetUnperformed(const std::vector<int>& unperformed);

5314 bool Bound() const {

5315 return forward_sequence_.size() + unperformed_.size() == var_->size();

5316 }

5317

5319

5322 return !(*this == element);

5323 }

5324

5325 private:

5326 bool CheckClassInvariants();

5327

5328 SequenceVar* var_;

5329 std::vector<int> forward_sequence_;

5330 std::vector<int> backward_sequence_;

5331 std::vector<int> unperformed_;

5332};

5333

5334template <class V, class E>

5336 public:

5338 E* Add(V* var) {

5339 CHECK(var != nullptr);

5340 int index = -1;

5341 if (!Find(var, &index)) {

5343 } else {

5344 return &elements_[index];

5345 }

5346 }

5349 DCHECK(var != nullptr);

5350 elements_.emplace_back(var);

5351 return &elements_.back();

5352 }

5356 elements_[position].Reset(var);

5357 return &elements_[position];

5358 }

5360 elements_.clear();

5361 if (!elements_map_.empty()) {

5362 elements_map_.clear();

5363 }

5364 }

5367 void Resize(size_t size) { elements_.resize(size); }

5368 bool Empty() const { return elements_.empty(); }

5370

5372 for (int i = 0; i < container.elements_.size(); ++i) {

5373 const E& element = container.elements_[i];

5374 const V* const var = element.Var();

5375 int index = -1;

5376 if (i < elements_.size() && elements_[i].Var() == var) {

5377 index = i;

5378 } else if (!Find(var, &index)) {

5379 continue;

5380 }

5381 DCHECK_GE(index, 0);

5382 E* const local_element = &elements_[index];

5383 local_element->Copy(element);

5384 if (element.Activated()) {

5385 local_element->Activate();

5386 } else {

5387 local_element->Deactivate();

5388 }

5389 }

5390 }

5395 for (const E& element : container.elements_) {

5396 elements_.emplace_back(element);

5397 }

5398 }

5399 bool Contains(const V* const var) const {

5400 int index;

5401 return Find(var, &index);

5402 }

5405 DCHECK(element != nullptr)

5406 << "Unknown variable " << var->DebugString() << " in solution";

5407 return element;

5408 }

5410 int index = -1;

5411 if (Find(var, &index)) {

5414 return nullptr;

5415 }

5416 const E& Element(const V* const var) const {

5418 DCHECK(element != nullptr)

5419 << "Unknown variable " << var->DebugString() << " in solution";

5420 return *element;

5421 }

5423 int index = -1;

5424 if (Find(var, &index)) {

5426 }

5427 return nullptr;

5428 }

5429 const std::vector<E>& elements() const { return elements_; }

5430 E* MutableElement(int index) { return &elements_[index]; }

5431 const E& Element(int index) const { return elements_[index]; }

5432 int Size() const { return elements_.size(); }

5434 for (E& element : elements_) {

5435 element.Store();

5436 }

5437 }

5439 for (E& element : elements_) {

5440 if (element.Activated()) {

5441 element.Restore();

5442 }

5443 }

5444 }

5446 for (const E& element : elements_) {

5447 if (!element.Bound()) return false;

5448 }

5449 return true;

5450 }

5451

5457 if (Size() != container.Size()) {

5458 return false;

5459 }

5461 EnsureMapIsUpToDate();

5462

5463

5464

5465 for (const E& element : container.elements_) {

5466 const int position =

5468 if (position < 0 || elements_[position] != element) {

5469 return false;

5470 }

5471 }

5472 return true;

5473 }

5475 return !(*this == container);

5479 void EnsureMapIsUpToDate() const {

5480 absl::flat_hash_map<const V*, int>* map =

5481 const_cast<absl::flat_hash_map<const V*, int>*>(&elements_map_);

5482 for (int i = map->size(); i < elements_.size(); ++i) {

5483 (*map)[elements_[i].Var()] = i;

5485 }

5486 bool Find(const V* const var, int* index) const {

5488 const size_t kMaxSizeForLinearAccess = 11;

5489 if (Size() <= kMaxSizeForLinearAccess) {

5491

5492

5493 for (int i = 0; i < elements_.size(); ++i) {

5494 if (var == elements_[i].Var()) {

5495 *index = i;

5496 return true;

5497 }

5498 }

5499 return false;

5500 } else {

5501 EnsureMapIsUpToDate();

5502 DCHECK_EQ(elements_map_.size(), elements_.size());

5503 return gtl::FindCopy(elements_map_, var, index);

5504 }

5505 }

5506

5507 std::vector<E> elements_;

5508 absl::flat_hash_map<const V*, int> elements_map_;

5509};

5510

5514 public:

5515 typedef AssignmentContainer<IntVar, IntVarElement> IntContainer;

5516 typedef AssignmentContainer<IntervalVar, IntervalVarElement>

5518 typedef AssignmentContainer<SequenceVar, SequenceVarElement>

5523

5524#ifndef SWIG

5525

5528#endif

5529

5531

5533 bool Empty() const {

5534 return int_var_container_.Empty() && interval_var_container_.Empty() &&

5535 sequence_var_container_.Empty();

5536 }

5537 int Size() const {

5539 }

5540 int NumIntVars() const { return int_var_container_.Size(); }

5541 int NumIntervalVars() const { return interval_var_container_.Size(); }

5542 int NumSequenceVars() const { return sequence_var_container_.Size(); }

5545

5548 bool Load(const std::string& filename);

5549#if !defined(SWIG)

5550 bool Load(File* file);

5551#endif

5552 void Load(const AssignmentProto& assignment_proto);

5554 bool Save(const std::string& filename) const;

5555#if !defined(SWIG)

5556 bool Save(File* file) const;

5557#endif

5558 void Save(AssignmentProto* assignment_proto) const;

5562

5564 objective_elements_.reserve(vars.size());

5566 if (var != nullptr) {

5567 objective_elements_.emplace_back(var);

5568 }

5569 }

5570 }

5571 void ClearObjective() { objective_elements_.clear(); }

5572 int NumObjectives() const { return objective_elements_.size(); }

5576 : nullptr;

5577 }

5578 bool HasObjective() const { return !objective_elements_.empty(); }

5580 return index < objective_elements_.size();

5581 }

5590 }

5593 }

5596 }

5599 }

5602 : 0;

5603 }

5610 objective_elements_[index].SetMin(m);

5611 }

5612 }

5615 objective_elements_[index].SetMax(m);

5616 }

5620 objective_elements_[index].SetValue(value);

5621 }

5622 }

5625 objective_elements_[index].SetRange(l, u);

5626 }

5627 }

5630 void Add(const std::vector<IntVar*>& vars);

5643 void Add(const std::vector<IntervalVar*>& vars);

5674

5676 void Add(const std::vector<SequenceVar*>& vars);

5683 const std::vector<int>& forward_sequence,

5684 const std::vector<int>& backward_sequence,

5685 const std::vector<int>& unperformed);

5687 const std::vector<int>& forward_sequence);

5689 const std::vector<int>& backward_sequence);

5691 const std::vector<int>& unperformed);

5692

5696

5700

5704

5710 objective_elements_[index].Activate();

5711 }

5712 }

5715 objective_elements_[index].Deactivate();

5716 }

5717 }

5720 : true;

5721 }

5722

5723 std::string DebugString() const override;

5724

5726 return int_var_container_.AreAllElementsBound() &&

5727 interval_var_container_.AreAllElementsBound() &&

5728 sequence_var_container_.AreAllElementsBound();

5729 }

5730

5731 bool Contains(const IntVar* var) const;

5732 bool Contains(const IntervalVar* var) const;

5733 bool Contains(const SequenceVar* var) const;

5740

5741

5745 return interval_var_container_;

5746 }

5748 return &interval_var_container_;

5749 }

5751 return sequence_var_container_;

5754 return &sequence_var_container_;

5755 }

5757 return int_var_container_ == assignment.int_var_container_ &&

5758 interval_var_container_ == assignment.interval_var_container_ &&

5759 sequence_var_container_ == assignment.sequence_var_container_ &&

5760 objective_elements_ == assignment.objective_elements_;

5761 }

5763 return !(*this == assignment);

5770 std::vector<IntVarElement> objective_elements_;

5772

5773std::ostream& operator<<(std::ostream& out,

5775

5776

5782 const std::vector<IntVar*>& target_vars,

5783 const Assignment* source_assignment,

5784 const std::vector<IntVar*>& source_vars);

5785

5787 public:

5788 Pack(Solver* s, const std::vector<IntVar*>& vars, int number_of_bins);

5793

5799

5801 const std::vector<int64_t>& weights, const std::vector<int64_t>& bounds);

5811

5816

5818

5820 const std::vector<IntVar*>& loads);

5821

5826 const std::vector<IntVar*>& loads);

5827

5832

5833

5834

5835

5836

5838 const std::vector<IntVar*>& usage, const std::vector<int64_t>& capacity);

5839

5844

5848

5852

5853 void Post() override;

5859 std::string DebugString() const override;

5860 bool IsUndecided(int var_index, int bin_index) const;

5861 void SetImpossible(int var_index, int bin_index);

5862 void Assign(int var_index, int bin_index);

5864 bool IsPossible(int var_index, int bin_index) const;

5874

5875 private:

5876 bool IsInProcess() const;

5877 const std::vector<IntVar*> vars_;

5878 const int bins_;

5879 std::vector<Dimension*> dims_;

5880 std::unique_ptr<RevBitMatrix> unprocessed_;

5881 std::vector<std::vector<int>> forced_;

5882 std::vector<std::vector<int>> removed_;

5883 std::vector<IntVarIterator*> holes_;

5884 uint64_t stamp_;

5886 std::vector<std::pair<int, int>> to_set_;

5887 std::vector<std::pair<int, int>> to_unset_;

5888 bool in_process_;

5889};

5890

5892 public:

5894 const std::string& name);

5895

5896#ifndef SWIG

5897

5900#endif

5901

5903

5906

5912

5913 int64_t TransitionTime(int before_index, int after_index) {

5916 }

5917

5918#if !defined(SWIG)

5919 virtual const std::vector<IntVar*>& nexts() const = 0;

5920 virtual const std::vector<IntVar*>& actives() const = 0;

5921 virtual const std::vector<IntVar*>& time_cumuls() const = 0;

5922 virtual const std::vector<IntVar*>& time_slacks() const = 0;

5923#endif

5924

5925 protected:

5926 const std::vector<IntervalVar*> intervals_;

5928};

5929

5933 public:

5936

5937

5938

5940

5944

5948

5953}

5954

5955#endif

const E & Element(const V *const var) const

Definition constraint_solver.h:5462

int Size() const

Definition constraint_solver.h:5478

void Resize(size_t size)

Definition constraint_solver.h:5413

E * FastAdd(V *var)

Adds element without checking its presence in the container.

Definition constraint_solver.h:5394

bool AreAllElementsBound() const

Definition constraint_solver.h:5491

void Copy(const AssignmentContainer< V, E > &container)

Definition constraint_solver.h:5439

bool operator!=(const AssignmentContainer< V, E > &container) const

Definition constraint_solver.h:5520

E * MutableElementOrNull(const V *const var)

Definition constraint_solver.h:5455

E * MutableElement(const V *const var)

Definition constraint_solver.h:5449

E * AddAtPosition(V *var, int position)

Definition constraint_solver.h:5401

bool operator==(const AssignmentContainer< V, E > &container) const

Definition constraint_solver.h:5501

void CopyIntersection(const AssignmentContainer< V, E > &container)

Definition constraint_solver.h:5417

E * Add(V *var)

Definition constraint_solver.h:5384

bool Empty() const

Definition constraint_solver.h:5414

const std::vector< E > & elements() const

Definition constraint_solver.h:5475

void Clear()

Definition constraint_solver.h:5405

bool Contains(const V *const var) const

Definition constraint_solver.h:5445

void Restore()

Definition constraint_solver.h:5484

void Store()

Definition constraint_solver.h:5479

const E * ElementPtrOrNull(const V *const var) const

Definition constraint_solver.h:5468

AssignmentContainer()

Definition constraint_solver.h:5383

void Activate()

Definition constraint_solver.h:5164

AssignmentElement()

Definition constraint_solver.h:5161

void Deactivate()

Definition constraint_solver.h:5165

bool Activated() const

Definition constraint_solver.h:5166

void Activate(const IntVar *var)

Assignment(Solver *solver)

void SetPerformedRange(const IntervalVar *var, int64_t mi, int64_t ma)

AssignmentContainer< SequenceVar, SequenceVarElement > SequenceContainer

Definition constraint_solver.h:5565

int64_t Value(const IntVar *var) const

void SetStartMax(const IntervalVar *var, int64_t m)

void SetMax(const IntVar *var, int64_t m)

void SetForwardSequence(const SequenceVar *var, const std::vector< int > &forward_sequence)

int64_t EndMin(const IntervalVar *var) const

bool Activated(const IntVar *var) const

IntContainer * MutableIntVarContainer()

Definition constraint_solver.h:5789

int64_t ObjectiveValueFromIndex(int index) const

Definition constraint_solver.h:5646

int64_t DurationMax(const IntervalVar *var) const

void SetObjectiveMax(int64_t m)

Definition constraint_solver.h:5633

int64_t PerformedMin(const IntervalVar *var) const

int64_t Max(const IntVar *var) const

void SetBackwardSequence(const SequenceVar *var, const std::vector< int > &backward_sequence)

int64_t Min(const IntVar *var) const

void SetEndValue(const IntervalVar *var, int64_t value)

bool Contains(const IntVar *var) const

bool HasObjective() const

Definition constraint_solver.h:5624

void SetValue(const IntVar *var, int64_t value)

bool ObjectiveBoundFromIndex(int index) const

Definition constraint_solver.h:5650

void SetEndMin(const IntervalVar *var, int64_t m)

void AddObjectives(const std::vector< IntVar * > &vars)

Definition constraint_solver.h:5607

bool Load(const std::string &filename)

int64_t EndValue(const IntervalVar *var) const

void SetMin(const IntVar *var, int64_t m)

bool operator==(const Assignment &assignment) const

Definition constraint_solver.h:5802

void DeactivateObjectiveFromIndex(int index)

Definition constraint_solver.h:5759

const std::vector< int > & Unperformed(const SequenceVar *var) const

void SetPerformedValue(const IntervalVar *var, int64_t value)

int64_t PerformedValue(const IntervalVar *var) const

IntervalContainer * MutableIntervalVarContainer()

Definition constraint_solver.h:5793

int64_t StartValue(const IntervalVar *var) const

bool ObjectiveBound() const

Definition constraint_solver.h:5631

void SetObjectiveRange(int64_t l, int64_t u)

Definition constraint_solver.h:5637

void SetObjectiveValue(int64_t value)

Definition constraint_solver.h:5634

IntVarElement * Add(IntVar *var)

const IntervalContainer & IntervalVarContainer() const

Definition constraint_solver.h:5790

int NumIntVars() const

Definition constraint_solver.h:5586

const SequenceContainer & SequenceVarContainer() const

Definition constraint_solver.h:5796

void SetPerformedMax(const IntervalVar *var, int64_t m)

void ActivateObjectiveFromIndex(int index)

Definition constraint_solver.h:5754

int64_t ObjectiveMinFromIndex(int index) const

Definition constraint_solver.h:5640

void SetObjectiveMinFromIndex(int index, int64_t m)

Definition constraint_solver.h:5654

std::string DebugString() const override

bool AreAllElementsBound() const

Definition constraint_solver.h:5771

int64_t EndMax(const IntervalVar *var) const

int64_t StartMin(const IntervalVar *var) const

IntVarElement * FastAdd(IntVar *var)

Adds without checking if variable has been previously added.

bool ActivatedObjective() const

Definition constraint_solver.h:5753

void Deactivate(const IntVar *var)

int NumIntervalVars() const

Definition constraint_solver.h:5587

void Copy(const Assignment *assignment)

int64_t ObjectiveMin() const

Definition constraint_solver.h:5628

int Size() const

Definition constraint_solver.h:5583

const std::vector< int > & ForwardSequence(const SequenceVar *var) const

AssignmentContainer< IntVar, IntVarElement > IntContainer

Definition constraint_solver.h:5561

IntVar * Objective() const

Definition constraint_solver.h:5619

void SetRange(const IntVar *var, int64_t l, int64_t u)

int64_t ObjectiveMaxFromIndex(int index) const

Definition constraint_solver.h:5643

int64_t ObjectiveMax() const

Definition constraint_solver.h:5629

bool ActivatedObjectiveFromIndex(int index) const

Definition constraint_solver.h:5764

int64_t DurationMin(const IntervalVar *var) const

int NumObjectives() const

Definition constraint_solver.h:5618

const IntContainer & IntVarContainer() const

Definition constraint_solver.h:5788

void SetObjectiveMaxFromIndex(int index, int64_t m)

Definition constraint_solver.h:5659

bool Bound(const IntVar *var) const

void DeactivateObjective()

Definition constraint_solver.h:5752

int64_t DurationValue(const IntervalVar *var) const

AssignmentContainer< IntervalVar, IntervalVarElement > IntervalContainer

Definition constraint_solver.h:5563

void SetSequence(const SequenceVar *var, const std::vector< int > &forward_sequence, const std::vector< int > &backward_sequence, const std::vector< int > &unperformed)

int NumSequenceVars() const

Definition constraint_solver.h:5588

void SetStartMin(const IntervalVar *var, int64_t m)

void SetDurationMin(const IntervalVar *var, int64_t m)

void SetStartValue(const IntervalVar *var, int64_t value)

void SetDurationMax(const IntervalVar *var, int64_t m)

Assignment & operator=(const Assignment &)=delete

void SetEndMax(const IntervalVar *var, int64_t m)

int64_t ObjectiveValue() const

Definition constraint_solver.h:5630

void SetStartRange(const IntervalVar *var, int64_t mi, int64_t ma)

void SetDurationValue(const IntervalVar *var, int64_t value)

void CopyIntersection(const Assignment *assignment)

bool Empty() const

Definition constraint_solver.h:5579

void SetEndRange(const IntervalVar *var, int64_t mi, int64_t ma)

void AddObjective(IntVar *const v)

Definition constraint_solver.h:5606

void SetDurationRange(const IntervalVar *var, int64_t mi, int64_t ma)

void ActivateObjective()

Definition constraint_solver.h:5751

bool operator!=(const Assignment &assignment) const

Definition constraint_solver.h:5808

void ClearObjective()

Definition constraint_solver.h:5617

SequenceContainer * MutableSequenceVarContainer()

Definition constraint_solver.h:5799

bool HasObjectiveFromIndex(int index) const

Definition constraint_solver.h:5625

int64_t StartMax(const IntervalVar *var) const

IntVar * ObjectiveFromIndex(int index) const

Definition constraint_solver.h:5620

void SetObjectiveValueFromIndex(int index, int64_t value)

Definition constraint_solver.h:5664

bool Save(const std::string &filename) const

Saves the assignment to a file.

const std::vector< int > & BackwardSequence(const SequenceVar *var) const

void SetPerformedMin(const IntervalVar *var, int64_t m)

void SetObjectiveRangeFromIndex(int index, int64_t l, int64_t u)

Definition constraint_solver.h:5669

void SetObjectiveMin(int64_t m)

Definition constraint_solver.h:5632

void SetUnperformed(const SequenceVar *var, const std::vector< int > &unperformed)

int64_t PerformedMax(const IntervalVar *var) const

BaseObject & operator=(const BaseObject &)=delete

virtual ~BaseObject()=default

BaseObject()

Definition constraint_solver.h:3446

virtual std::string DebugString() const

Definition constraint_solver.h:3454

virtual IntVar * ObjectiveVar(int index) const =0

virtual bool Maximize(int index) const =0

virtual IntVar * MinimizationVar(int index) const =0

virtual int64_t BestValue(int index) const =0

BaseObjectiveMonitor & operator=(const BaseObjectiveMonitor &)=delete

bool is_active() const

Definition constraint_solver.h:4597

void set_active(bool is_active)

Definition constraint_solver.h:4598

BaseObjectiveMonitor(Solver *solver)

Definition constraint_solver.h:4585

virtual int64_t Step(int index) const =0

virtual int Size() const =0

~BaseObjectiveMonitor() override

Definition constraint_solver.h:4586

IntVar * target_var() const

Definition constraint_solver.h:3976

CastConstraint(Solver *const solver, IntVar *const target_var)

Definition constraint_solver.h:3970

~CastConstraint() override

Definition constraint_solver.h:3974

IntVar *const target_var_

Definition constraint_solver.h:3979

Constraint & operator=(const Constraint &)=delete

std::string DebugString() const override

virtual void InitialPropagate()=0

bool IsCastConstraint() const

Is the constraint created by a cast from expression to integer variable?

~Constraint() override

Definition constraint_solver.h:3938

Constraint(Solver *const solver)

Definition constraint_solver.h:3931

virtual void Accept(ModelVisitor *visitor) const

Accepts the given visitor.

DecisionBuilder & operator=(const DecisionBuilder &)=delete

void set_name(absl::string_view name)

Definition constraint_solver.h:3599

virtual void Accept(ModelVisitor *visitor) const

virtual void AppendMonitors(Solver *solver, std::vector< SearchMonitor * > *extras)

std::string GetName() const

std::string DebugString() const override

DecisionBuilder()

Definition constraint_solver.h:3576

~DecisionBuilder() override

Definition constraint_solver.h:3583

virtual void VisitRankFirstInterval(SequenceVar *sequence, int index)

virtual void VisitSetVariableValue(IntVar *var, int64_t value)

virtual void VisitScheduleOrPostpone(IntervalVar *var, int64_t est)

DecisionVisitor()

Definition constraint_solver.h:3554

~DecisionVisitor() override

Definition constraint_solver.h:3561

virtual void VisitRankLastInterval(SequenceVar *sequence, int index)

virtual void VisitUnknownDecision()

virtual void VisitScheduleOrExpedite(IntervalVar *var, int64_t est)

DecisionVisitor & operator=(const DecisionVisitor &)=delete

virtual void VisitSplitVariableDomain(IntVar *var, int64_t value, bool start_with_lower_half)

Decision()

Definition constraint_solver.h:3530

virtual void Refute(Solver *s)=0

Refute will be called after a backtrack.

~Decision() override

Definition constraint_solver.h:3537

std::string DebugString() const override

Definition constraint_solver.h:3545

virtual void Apply(Solver *s)=0

Apply will be called first when the decision is executed.

Decision & operator=(const Decision &)=delete

virtual void Accept(DecisionVisitor *visitor) const

Accepts the given visitor.

Demon & operator=(const Demon &)=delete

virtual Solver::DemonPriority priority() const

~Demon() override

Definition constraint_solver.h:3647

std::string DebugString() const override

Demon()

Definition constraint_solver.h:3640

void desinhibit(Solver *s)

This method un-inhibits the demon that was previously inhibited.

virtual const std::vector< IntVar * > & time_slacks() const =0

virtual SequenceVar * MakeSequenceVar()=0

Creates a sequence variable from the constraint.

DisjunctiveConstraint(Solver *s, const std::vector< IntervalVar * > &intervals, const std::string &name)

virtual const std::vector< IntVar * > & time_cumuls() const =0

Solver::IndexEvaluator2 transition_time_

Definition constraint_solver.h:5974

virtual const std::vector< IntVar * > & actives() const =0

int64_t TransitionTime(int before_index, int after_index)

Definition constraint_solver.h:5960

DisjunctiveConstraint & operator=(const DisjunctiveConstraint &)=delete

const std::vector< IntervalVar * > intervals_

Definition constraint_solver.h:5973

virtual const std::vector< IntVar * > & nexts() const =0

~DisjunctiveConstraint() override

void SetTransitionTime(Solver::IndexEvaluator2 transition_time)

bool CheckWithOffset(absl::Duration offset) override

~ImprovementSearchLimit() override

ImprovementSearchLimit(Solver *solver, IntVar *objective_var, bool maximize, double objective_scaling_factor, double objective_offset, double improvement_rate_coefficient, int improvement_rate_solutions_distance)

void Init() override

This method is called when the search limit is initialized.

void Copy(const SearchLimit *limit) override

bool AtSolution() override

SearchLimit * MakeClone() const override

Allocates a clone of the limit.

Iterator end()

Definition constraint_solver.h:4318

InitAndGetValues(IntVarIterator *it)

Definition constraint_solver.h:4305

Iterator begin()

Definition constraint_solver.h:4311

virtual void SetValue(int64_t v)

This method sets the value of the expression.

Definition constraint_solver.h:4223

virtual bool Bound() const

Returns true if the min and the max of the expression are equal.

Definition constraint_solver.h:4226

virtual void SetMax(int64_t m)=0

virtual bool IsVar() const

Returns true if the expression is indeed a variable.

Definition constraint_solver.h:4229

virtual void SetRange(int64_t l, int64_t u)

This method sets both the min and the max of the expression.

Definition constraint_solver.h:4217

virtual int64_t Min() const =0

~IntExpr() override

Definition constraint_solver.h:4203

IntExpr & operator=(const IntExpr &)=delete

virtual void SetMin(int64_t m)=0

virtual void WhenRange(Demon *d)=0

Attach a demon that will watch the min or the max of the expression.

virtual void Range(int64_t *l, int64_t *u)

Definition constraint_solver.h:4212

IntVar * VarWithName(const std::string &name)

virtual IntVar * Var()=0

Creates a variable from the expression.

virtual int64_t Max() const =0

IntExpr(Solver *const s)

Definition constraint_solver.h:4196

virtual void Accept(ModelVisitor *visitor) const

Accepts the given visitor.

void Restore()

Definition constraint_solver.h:5185

int64_t Value() const

Definition constraint_solver.h:5197

bool operator==(const IntVarElement &element) const

bool Bound() const

Definition constraint_solver.h:5202

void SetRange(int64_t l, int64_t u)

Definition constraint_solver.h:5203

bool operator!=(const IntVarElement &element) const

Definition constraint_solver.h:5214

IntVar * Var() const

Definition constraint_solver.h:5180

void SetMin(int64_t m)

Definition constraint_solver.h:5194

int64_t Max() const

Definition constraint_solver.h:5195

void Store()

Definition constraint_solver.h:5181

std::string DebugString() const

int64_t Min() const

Definition constraint_solver.h:5193

void Copy(const IntVarElement &element)

void WriteToProto(IntVarAssignment *int_var_assignment_proto) const

void SetMax(int64_t m)

Definition constraint_solver.h:5196

void LoadFromProto(const IntVarAssignment &int_var_assignment_proto)

void SetValue(int64_t v)

Definition constraint_solver.h:5207

virtual bool Ok() const =0

This method indicates if we can call Value() or not.

virtual int64_t Value() const =0

This method returns the current value of the iterator.

virtual void Next()=0

This method moves the iterator to the next value.

~IntVarIterator() override

Definition constraint_solver.h:4277

virtual void Init()=0

This method must be called before each loop.

std::string DebugString() const override

Pretty Print.

Definition constraint_solver.h:4292

virtual void WhenBound(Demon *d)=0

virtual void WhenDomain(Demon *d)=0

bool IsVar() const override

Returns true if the expression is indeed a variable.

Definition constraint_solver.h:4373

virtual void SetValues(const std::vector< int64_t > &values)

This method intersects the current domain with the values in the array.

void Accept(ModelVisitor *visitor) const override

Accepts the given visitor.

virtual IntVar * IsDifferent(int64_t constant)=0

int index() const

Returns the index of the variable.

Definition constraint_solver.h:4461

virtual IntVarIterator * MakeDomainIterator(bool reversible) const =0

virtual int64_t OldMax() const =0

Returns the previous max.

IntVar * Var() override

Creates a variable from the expression.

Definition constraint_solver.h:4374

virtual IntVar * IsLessOrEqual(int64_t constant)=0

IntVar & operator=(const IntVar &)=delete

virtual bool Contains(int64_t v) const =0

virtual int64_t Value() const =0

virtual int VarType() const

virtual void RemoveValue(int64_t v)=0

This method removes the value 'v' from the domain of the variable.

virtual uint64_t Size() const =0

This method returns the number of values in the domain of the variable.

~IntVar() override

Definition constraint_solver.h:4371

virtual IntVarIterator * MakeHoleIterator(bool reversible) const =0

virtual IntVar * IsGreaterOrEqual(int64_t constant)=0

virtual IntVar * IsEqual(int64_t constant)=0

IsEqual.

virtual void RemoveInterval(int64_t l, int64_t u)=0

virtual int64_t OldMin() const =0

Returns the previous min.

virtual void RemoveValues(const std::vector< int64_t > &values)

This method remove the values from the domain of the variable.

void SetStartValue(int64_t v)

Definition constraint_solver.h:5268

void SetDurationValue(int64_t v)

Definition constraint_solver.h:5278

int64_t PerformedValue() const

Definition constraint_solver.h:5258

IntervalVar * Var() const

Definition constraint_solver.h:5231

bool Bound() const

Definition constraint_solver.h:5302

void SetEndMin(int64_t m)

Definition constraint_solver.h:5282

void SetDurationRange(int64_t mi, int64_t ma)

Definition constraint_solver.h:5274

void SetStartMax(int64_t m)

Definition constraint_solver.h:5263

void SetPerformedMin(int64_t m)

Definition constraint_solver.h:5292

IntervalVarElement * Clone()

void SetStartMin(int64_t m)

Definition constraint_solver.h:5262

std::string DebugString() const

int64_t EndValue() const

Definition constraint_solver.h:5252

void WriteToProto(IntervalVarAssignment *interval_var_assignment_proto) const

void SetPerformedMax(int64_t m)

Definition constraint_solver.h:5293

void SetPerformedValue(int64_t v)

Definition constraint_solver.h:5298

void SetEndMax(int64_t m)

Definition constraint_solver.h:5283

bool operator!=(const IntervalVarElement &element) const

Definition constraint_solver.h:5308

void Reset(IntervalVar *var)

void Copy(const IntervalVarElement &element)

int64_t DurationMax() const

Definition constraint_solver.h:5245

void SetEndRange(int64_t mi, int64_t ma)

Definition constraint_solver.h:5284

int64_t StartMax() const

Definition constraint_solver.h:5239

void SetDurationMax(int64_t m)

Definition constraint_solver.h:5273

int64_t PerformedMin() const

Definition constraint_solver.h:5256

bool operator==(const IntervalVarElement &element) const

void SetStartRange(int64_t mi, int64_t ma)

Definition constraint_solver.h:5264

int64_t DurationMin() const

Definition constraint_solver.h:5244

void SetPerformedRange(int64_t mi, int64_t ma)

Definition constraint_solver.h:5294

void LoadFromProto(const IntervalVarAssignment &interval_var_assignment_proto)

int64_t PerformedMax() const

Definition constraint_solver.h:5257

int64_t DurationValue() const

Definition constraint_solver.h:5246

void SetEndValue(int64_t v)

Definition constraint_solver.h:5288

int64_t StartMin() const

Definition constraint_solver.h:5238

int64_t EndMin() const

Definition constraint_solver.h:5250

int64_t EndMax() const

Definition constraint_solver.h:5251

void SetDurationMin(int64_t m)

Definition constraint_solver.h:5272

int64_t StartValue() const

Definition constraint_solver.h:5240

virtual IntExpr * PerformedExpr()=0

bool IsPerformedBound() const

Definition constraint_solver.h:5018

virtual bool WasPerformedBound() const =0

virtual void WhenEndRange(Demon *d)=0

virtual void SetEndRange(int64_t mi, int64_t ma)=0

virtual int64_t OldEndMax() const =0

virtual int64_t OldDurationMin() const =0

virtual int64_t EndMax() const =0

virtual IntExpr * StartExpr()=0

virtual int64_t EndMin() const =0

These methods query, set, and watch the end position of the interval var.

virtual void SetEndMax(int64_t m)=0

virtual void SetDurationMax(int64_t m)=0

virtual int64_t OldDurationMax() const =0

bool CannotBePerformed() const

Definition constraint_solver.h:5017

void WhenAnything(Demon *d)

Attaches a demon awakened when anything about this interval changes.

virtual int64_t OldEndMin() const =0

virtual bool MayBePerformed() const =0

virtual void SetDurationMin(int64_t m)=0

virtual void WhenDurationBound(Demon *d)=0

virtual IntExpr * SafeStartExpr(int64_t unperformed_value)=0

virtual void WhenStartBound(Demon *d)=0

virtual IntExpr * SafeDurationExpr(int64_t unperformed_value)=0

virtual IntExpr * SafeEndExpr(int64_t unperformed_value)=0

virtual IntExpr * DurationExpr()=0

virtual void WhenDurationRange(Demon *d)=0

virtual void WhenEndBound(Demon *d)=0

virtual void SetEndMin(int64_t m)=0

virtual IntExpr * EndExpr()=0

virtual void Accept(ModelVisitor *visitor) const =0

Accepts the given visitor.

virtual void WhenPerformedBound(Demon *d)=0

virtual void SetDurationRange(int64_t mi, int64_t ma)=0

virtual bool MustBePerformed() const =0

The base class for all local search operators.

Model visitor.

Definition constraint_solver.h:3678

static const char kCumulsArgument[]

Definition constraint_solver.h:3788

static const char kStartMaxArgument[]

Definition constraint_solver.h:3829

static const char kVarValueWatcher[]

Definition constraint_solver.h:3763

static const char kScalProdGreaterOrEqual[]

Definition constraint_solver.h:3748

static const char kStepArgument[]

Definition constraint_solver.h:3832

static const char kLexLess[]

Definition constraint_solver.h:3725

virtual void VisitSequenceVariable(const SequenceVar *variable)

static const char kMin[]

Definition constraint_solver.h:3731

static const char kSolutionLimitArgument[]

Definition constraint_solver.h:3828

static const char kNullIntersect[]

Definition constraint_solver.h:3738

static const char kStartExpr[]

Definition constraint_solver.h:3754

virtual void VisitIntervalArrayArgument(const std::string &arg_name, const std::vector< IntervalVar * > &arguments)

virtual void VisitIntervalArgument(const std::string &arg_name, IntervalVar *argument)

Visit interval argument.

static const char kVariableUsageLessConstantExtension[]

Definition constraint_solver.h:3776

static const char kSequenceArgument[]

Definition constraint_solver.h:3822

static const char kAssumePathsArgument[]

Definition constraint_solver.h:3781

void VisitInt64ToBoolExtension(Solver::IndexFilter1 filter, int64_t index_min, int64_t index_max)

static const char kDifferenceOperation[]

Definition constraint_solver.h:3848

static const char kInitialState[]

Definition constraint_solver.h:3804

static const char kIsMember[]

Definition constraint_solver.h:3722

static const char kTraceOperation[]

Definition constraint_solver.h:3852

static const char kSearchLimitExtension[]

Definition constraint_solver.h:3771

static const char kEndsArgument[]

Definition constraint_solver.h:3796

static const char kRelaxedMinOperation[]

Definition constraint_solver.h:3846

static const char kFixedChargeArgument[]

Definition constraint_solver.h:3800

static const char kDurationMaxArgument[]

Definition constraint_solver.h:3790

void VisitInt64ToInt64AsArray(const Solver::IndexEvaluator1 &eval, const std::string &arg_name, int64_t index_max)

Expands function as array when index min is 0.

static const char kSumOperation[]

Definition constraint_solver.h:3847

static const char kFinalStatesArgument[]

Definition constraint_solver.h:3799

static const char kNoCycle[]

Definition constraint_solver.h:3734

static const char kSequenceVariable[]

Definition constraint_solver.h:3751

static const char kTuplesArgument[]

Definition constraint_solver.h:3836

static const char kFailuresLimitArgument[]

Definition constraint_solver.h:3798

static const char kMirrorOperation[]

Operations.

Definition constraint_solver.h:3844

static const char kMinEqual[]

Definition constraint_solver.h:3732

static const char kEarlyCostArgument[]

Definition constraint_solver.h:3792

static const char kInt64ToInt64Extension[]

Definition constraint_solver.h:3769

static const char kNotBetween[]

Definition constraint_solver.h:3736

static const char kMax[]

Definition constraint_solver.h:3728

static const char kOpposite[]

Definition constraint_solver.h:3739

static const char kTransition[]

Definition constraint_solver.h:3760

static const char kActiveArgument[]

argument names:

Definition constraint_solver.h:3780

static const char kObjectiveExtension[]

Definition constraint_solver.h:3770

static const char kIsGreater[]

Definition constraint_solver.h:3718

virtual void BeginVisitModel(const std::string &type_name)

--— Virtual methods for visitors --—

static const char kDurationMinArgument[]

Definition constraint_solver.h:3791

virtual void BeginVisitIntegerExpression(const std::string &type_name, const IntExpr *expr)

static const char kNextsArgument[]

Definition constraint_solver.h:3814

static const char kProduct[]

Definition constraint_solver.h:3745

virtual void VisitIntegerArgument(const std::string &arg_name, int64_t value)

Visit integer arguments.

static const char kRangeArgument[]

Definition constraint_solver.h:3819

static const char kLateCostArgument[]

Definition constraint_solver.h:3807

static const char kEndMinArgument[]

Definition constraint_solver.h:3795

static const char kMinArgument[]

Definition constraint_solver.h:3812

virtual void VisitIntegerVariable(const IntVar *variable, IntExpr *delegate)

virtual void VisitSequenceArrayArgument(const std::string &arg_name, const std::vector< SequenceVar * > &arguments)

static const char kCoefficientsArgument[]

Definition constraint_solver.h:3785

virtual void VisitIntegerMatrixArgument(const std::string &arg_name, const IntTupleSet &tuples)

static const char kExpressionArgument[]

Definition constraint_solver.h:3797

static const char kTrace[]

Definition constraint_solver.h:3759

virtual void VisitIntegerVariableEvaluatorArgument(const std::string &arg_name, const Solver::Int64ToIntVar &arguments)

Helpers.

static const char kTargetArgument[]

Definition constraint_solver.h:3833

static const char kMapDomain[]

Definition constraint_solver.h:3727

static const char kStartsArgument[]

Definition constraint_solver.h:3831

static const char kPositionXArgument[]

Definition constraint_solver.h:3817

static const char kStartSyncOnStartOperation[]

Definition constraint_solver.h:3850

static const char kRelationArgument[]

Definition constraint_solver.h:3820

static const char kSortingConstraint[]

Definition constraint_solver.h:3752

static const char kSizeArgument[]

Definition constraint_solver.h:3824

static const char kMember[]

Definition constraint_solver.h:3730

static const char kModulo[]

Definition constraint_solver.h:3733

static const char kSumGreaterOrEqual[]

Definition constraint_solver.h:3757

static const char kMaxArgument[]

Definition constraint_solver.h:3810

virtual void EndVisitModel(const std::string &type_name)

static const char kProductOperation[]

Definition constraint_solver.h:3849

static const char kTransitsArgument[]

Definition constraint_solver.h:3835

static const char kPerformedExpr[]

Definition constraint_solver.h:3743

virtual void VisitIntegerExpressionArgument(const std::string &arg_name, IntExpr *argument)

Visit integer expression argument.

static const char kNotMember[]

Definition constraint_solver.h:3737

static const char kValueArgument[]

Definition constraint_solver.h:3837

static const char kLessOrEqual[]

Definition constraint_solver.h:3724

static const char kMaxEqual[]

Definition constraint_solver.h:3729

static const char kSum[]

Definition constraint_solver.h:3755

static const char kLateDateArgument[]

Definition constraint_solver.h:3808

static const char kRightArgument[]

Definition constraint_solver.h:3821

static const char kEarlyDateArgument[]

Definition constraint_solver.h:3793

static const char kScalProdLessOrEqual[]

Definition constraint_solver.h:3749

static const char kIsGreaterOrEqual[]

Definition constraint_solver.h:3719

virtual void VisitIntegerVariableArrayArgument(const std::string &arg_name, const std::vector< IntVar * > &arguments)

static const char kCapacityArgument[]

Definition constraint_solver.h:3783

static const char kSumLessOrEqual[]

Definition constraint_solver.h:3758

static const char kModuloArgument[]

Definition constraint_solver.h:3813

static const char kVarBoundWatcher[]

Definition constraint_solver.h:3762

static const char kIsEqual[]

Definition constraint_solver.h:3717

static const char kScalProdEqual[]

Definition constraint_solver.h:3747

static const char kSizeYArgument[]

Definition constraint_solver.h:3826

static const char kSequencesArgument[]

Definition constraint_solver.h:3823

static const char kEndMaxArgument[]

Definition constraint_solver.h:3794

static const char kVariableGroupExtension[]

Definition constraint_solver.h:3775

virtual void VisitIntegerArrayArgument(const std::string &arg_name, const std::vector< int64_t > &values)

static const char kValuesArgument[]

Definition constraint_solver.h:3838

static const char kIsLess[]

Definition constraint_solver.h:3720

static const char kIndexArgument[]

Definition constraint_solver.h:3803

static const char kPack[]

Definition constraint_solver.h:3740

static const char kPathCumul[]

Definition constraint_solver.h:3741

static const char kRelaxedMaxOperation[]

Definition constraint_solver.h:3845

static const char kScalProd[]

Definition constraint_solver.h:3746

static const char kStartSyncOnEndOperation[]

Definition constraint_solver.h:3851

static const char kUsageLessConstantExtension[]

Definition constraint_solver.h:3774

static const char kMaximizeArgument[]

Definition constraint_solver.h:3811

static const char kCumulativeArgument[]

Definition constraint_solver.h:3787

static const char kSquare[]

Definition constraint_solver.h:3753

static const char kIntervalArgument[]

Definition constraint_solver.h:3805

static const char kPositionYArgument[]

Definition constraint_solver.h:3818

static const char kVarsArgument[]

Definition constraint_solver.h:3840

virtual void BeginVisitConstraint(const std::string &type_name, const Constraint *constraint)

static const char kVariableArgument[]

Definition constraint_solver.h:3839

static const char kLinkExprVar[]

Definition constraint_solver.h:3726

static const char kBranchesLimitArgument[]

Definition constraint_solver.h:3782

static const char kIndex2Argument[]

Definition constraint_solver.h:3801

static const char kSumEqual[]

Definition constraint_solver.h:3756

virtual void EndVisitExtension(const std::string &type)

static const char kUsageEqualVariableExtension[]

Definition constraint_solver.h:3772

static const char kSemiContinuous[]

Definition constraint_solver.h:3750

static const char kDemandsArgument[]

Definition constraint_solver.h:3789

static const char kNonEqual[]

Definition constraint_solver.h:3735

static const char kSizeXArgument[]

Definition constraint_solver.h:3825

static const char kLeftArgument[]

Definition constraint_solver.h:3809

static const char kCountAssignedItemsExtension[]

Extension names:

Definition constraint_solver.h:3766

virtual void VisitIntervalVariable(const IntervalVar *variable, const std::string &operation, int64_t value, IntervalVar *delegate)

static const char kCountUsedBinsExtension[]

Definition constraint_solver.h:3767

static const char kStartMinArgument[]

Definition constraint_solver.h:3830

static const char kOptionalArgument[]

Definition constraint_solver.h:3815

static const char kCountArgument[]

Definition constraint_solver.h:3786

void VisitInt64ToInt64Extension(const Solver::IndexEvaluator1 &eval, int64_t index_min, int64_t index_max)

static const char kTrueConstraint[]

Definition constraint_solver.h:3761

static const char kPartialArgument[]

Definition constraint_solver.h:3816

static const char kDelayedPathCumul[]

Definition constraint_solver.h:3742

virtual void BeginVisitExtension(const std::string &type)

static const char kIndex3Argument[]

Definition constraint_solver.h:3802

static const char kWeightedSumOfAssignedEqualVariableExtension[]

Definition constraint_solver.h:3777

static const char kInt64ToBoolExtension[]

Definition constraint_solver.h:3768

virtual void VisitSequenceArgument(const std::string &arg_name, SequenceVar *argument)

Visit sequence argument.

static const char kEvaluatorArgument[]

Definition constraint_solver.h:3841

virtual void EndVisitIntegerExpression(const std::string &type_name, const IntExpr *expr)

static const char kSmartTimeCheckArgument[]

Definition constraint_solver.h:3827

static const char kCardsArgument[]

Definition constraint_solver.h:3784

static const char kTimeLimitArgument[]

Definition constraint_solver.h:3834

static const char kPower[]

Definition constraint_solver.h:3744

static const char kIsLessOrEqual[]

Definition constraint_solver.h:3721

static const char kLess[]

Definition constraint_solver.h:3723

static const char kIntervalsArgument[]

Definition constraint_solver.h:3806

virtual void EndVisitConstraint(const std::string &type_name, const Constraint *constraint)

Subclass of RevArray<T> which adds numerical operations.

Definition constraint_solver.h:4174

void Decr(Solver *const s, int index)

Definition constraint_solver.h:4184

NumericalRevArray(int size, const T &val)

Definition constraint_solver.h:4176

void Add(Solver *const s, int index, const T &to_add)

Definition constraint_solver.h:4178

void Incr(Solver *const s, int index)

Definition constraint_solver.h:4182

Subclass of Rev<T> which adds numerical operations.

Definition constraint_solver.h:4116

NumericalRev(const T &val)

Definition constraint_solver.h:4118

void Incr(Solver *const s)

Definition constraint_solver.h:4124

void Decr(Solver *const s)

Definition constraint_solver.h:4126

void Add(Solver *const s, const T &to_add)

Definition constraint_solver.h:4120

bool CurrentInternalValuesAreConstraining() const

const std::vector< IntVar * > & minimization_vars() const

Definition constraint_solver.h:4637

friend class Solver

Definition constraint_solver.h:4682

const std::vector< IntVar * > & objective_vars() const

Definition constraint_solver.h:4636

~ObjectiveMonitor() override

Definition constraint_solver.h:4610

int64_t Step(int index) const override

Definition constraint_solver.h:4621

int Size() const override

Definition constraint_solver.h:4629

void SetCurrentInternalValue(int index, int64_t value)

Definition constraint_solver.h:4644

void MakeMinimizationVarsLessOrEqualWithSteps(const T &upper_bounds)

Definition constraint_solver.h:4648

int64_t BestInternalValue(int index) const

Definition constraint_solver.h:4640

bool found_initial_solution_

Definition constraint_solver.h:4679

int64_t CurrentInternalValue(int index) const

Definition constraint_solver.h:4641

bool Maximize(int index) const override

Definition constraint_solver.h:4622

bool AcceptDelta(Assignment *delta, Assignment *deltadelta) override

void Accept(ModelVisitor *visitor) const override

Accepts the given model visitor.

int64_t BestValue(int index) const override

Definition constraint_solver.h:4625

bool AtSolution() override

ObjectiveMonitor(Solver *solver, const std::vector< bool > &maximize, std::vector< IntVar * > vars, std::vector< int64_t > steps)

IntVar * MakeMinimizationVarsLessOrEqualWithStepsStatus(const T &upper_bounds)

Definition constraint_solver.h:4661

void EnterSearch() override

Beginning of the search.

ObjectiveMonitor & operator=(const ObjectiveMonitor &)=delete

IntVar * ObjectiveVar(int index) const override

Definition constraint_solver.h:4615

IntVar * MinimizationVar(int index) const override

Definition constraint_solver.h:4618

void SetOnOptimalFoundcallback(std::function< void(int64_t)> on_optimal_found)

Definition constraint_solver.h:4714

void BeginNextDecision(DecisionBuilder *db) override

Internal methods.

int64_t best() const

Returns the best value found during search.

Definition constraint_solver.h:4706

~OptimizeVar() override

Definition constraint_solver.h:4702

void RefuteDecision(Decision *d) override

Before refuting the decision.

bool AtSolution() override

IntVar * var() const

Returns the variable that is optimized.

Definition constraint_solver.h:4709

OptimizeVar(Solver *solver, bool maximize, IntVar *var, int64_t step)

std::string DebugString() const override

bool AcceptSolution() override

virtual std::string Name() const

void SetUnassigned(int var_index)

void SetAssigned(int var_index)

void Assign(int var_index, int bin_index)

bool IsPossible(int var_index, int bin_index) const

void AddCountUsedBinDimension(IntVar *count_var)

Pack(Solver *s, const std::vector< IntVar * > &vars, int number_of_bins)

void AddWeightedSumLessOrEqualConstantDimension(const std::vector< int64_t > &weights, const std::vector< int64_t > &bounds)

void AddSumVariableWeightsLessOrEqualConstantDimension(const std::vector< IntVar * > &usage, const std::vector< int64_t > &capacity)

void AddCountAssignedItemsDimension(IntVar *count_var)

void UnassignAllRemainingItems()

void AssignAllRemainingItems()

std::string DebugString() const override

void AssignAllPossibleToBin(int bin_index)

void Accept(ModelVisitor *visitor) const override

Accepts the given visitor.

IntVar * AssignVar(int var_index, int bin_index) const

bool IsAssignedStatusKnown(int var_index) const

void AssignFirstPossibleToBin(int bin_index)

void AddWeightedSumEqualVarDimension(const std::vector< int64_t > &weights, const std::vector< IntVar * > &loads)

void RemoveAllPossibleFromBin(int bin_index)

void AddWeightedSumOfAssignedDimension(const std::vector< int64_t > &weights, IntVar *cost_var)

void InitialPropagate() override

void SetImpossible(int var_index, int bin_index)

void OneDomain(int var_index)

bool IsUndecided(int var_index, int bin_index) const

double seconds() const

Definition constraint_solver.h:3612

ProfiledDecisionBuilder(DecisionBuilder *db)

std::string DebugString() const override

void Accept(ModelVisitor *visitor) const override

const std::string & name() const

Definition constraint_solver.h:3611

void AppendMonitors(Solver *solver, std::vector< SearchMonitor * > *extras) override

~ProfiledDecisionBuilder() override

Definition constraint_solver.h:3610

NOLINT.

Definition constraint_solver.h:3462

PropagationBaseObject & operator=(const PropagationBaseObject &)=delete

void EnqueueVar(Demon *const d)

Definition constraint_solver.h:3494

void ExecuteAll(const SimpleRevFIFO< Demon * > &demons)

virtual std::string name() const

Object naming.

void set_variable_to_clean_on_fail(IntVar *v)

Shortcut for variable cleaner.

Definition constraint_solver.h:3510

void EnqueueAll(const SimpleRevFIFO< Demon * > &demons)

void set_action_on_fail(Solver::Action a)

Definition constraint_solver.h:3501

void EnqueueDelayedDemon(Demon *const d)

Definition constraint_solver.h:3493

~PropagationBaseObject() override

Definition constraint_solver.h:3471

void FreezeQueue()

Definition constraint_solver.h:3484

virtual std::string BaseName() const

Returns a base name for automatic naming.

void UnfreezeQueue()

Definition constraint_solver.h:3488

void set_name(absl::string_view name)

void reset_action_on_fail()

This method clears the failure callback.

Definition constraint_solver.h:3507

Solver * solver() const

Definition constraint_solver.h:3480

std::string DebugString() const override

Definition constraint_solver.h:3473

bool HasName() const

Returns whether the object has been named or not.

PropagationBaseObject(Solver *const s)

Definition constraint_solver.h:3464

absl::Duration duration_limit() const

Definition constraint_solver.h:4800

int64_t branches() const

Definition constraint_solver.h:4806

SearchLimit * MakeClone() const override

Allocates a clone of the limit.

bool IsUncheckedSolutionLimitReached() override

bool CheckWithOffset(absl::Duration offset) override

int64_t wall_time() const

Definition constraint_solver.h:4801

void Init() override

This method is called when the search limit is initialized.

int64_t solutions() const

Definition constraint_solver.h:4808

int ProgressPercent() override

std::string DebugString() const override

void Accept(ModelVisitor *visitor) const override

Accepts the given model visitor.

void ExitSearch() override

End of the search.

absl::Time AbsoluteSolverDeadline() const

Definition constraint_solver.h:4814

int64_t failures() const

Definition constraint_solver.h:4807

RegularLimit(Solver *s, absl::Duration time, int64_t branches, int64_t failures, int64_t solutions, bool smart_time_check, bool cumulative)

void Copy(const SearchLimit *limit) override

void UpdateLimits(absl::Duration time, int64_t branches, int64_t failures, int64_t solutions)

RegularLimit * MakeIdenticalClone() const

const T & Value(int index) const

Definition constraint_solver.h:4149

int64_t size() const

Definition constraint_solver.h:4147

RevArray(int size, const T &val)

Definition constraint_solver.h:4137

void SetValue(Solver *const s, int index, const T &val)

Definition constraint_solver.h:4155

const T & operator[](int index) const

Definition constraint_solver.h:4152

~RevArray()

Definition constraint_solver.h:4145

Rev(const T &val)

Definition constraint_solver.h:4095

void SetValue(Solver *const s, const T &val)

Definition constraint_solver.h:4099

const T & Value() const

Definition constraint_solver.h:4097

Base class of all search limits.

Definition constraint_solver.h:4735

std::string DebugString() const override

Definition constraint_solver.h:4773

void BeginNextDecision(DecisionBuilder *b) override

Before calling DecisionBuilder::Next.

void PeriodicCheck() override

Periodic call to check limits in long running methods.

bool crossed() const

Returns true if the limit has been crossed.

Definition constraint_solver.h:4747

virtual void Copy(const SearchLimit *limit)=0

bool Check()

Definition constraint_solver.h:4753

void EnterSearch() override

Internal methods.

virtual void Init()=0

This method is called when the search limit is initialized.

SearchLimit & operator=(const SearchLimit &)=delete

virtual bool CheckWithOffset(absl::Duration offset)=0

SearchLimit(Solver *const s)

Definition constraint_solver.h:4737

void RefuteDecision(Decision *d) override

Before refuting the decision.

virtual SearchLimit * MakeClone() const =0

Allocates a clone of the limit.

A search monitor is a simple set of callbacks to monitor all search events.

Definition constraint_solver.h:3983

static constexpr int kNoProgress

Definition constraint_solver.h:3985

~SearchMonitor() override

Definition constraint_solver.h:3994

virtual bool AtSolution()

virtual void BeginInitialPropagation()

Before the initial propagation.

virtual void EndFail()

After completing the backtrack.

virtual void RestartSearch()

Restart the search.

virtual void EndInitialPropagation()

After the initial propagation.

virtual bool AcceptDelta(Assignment *delta, Assignment *deltadelta)

virtual void BeginNextDecision(DecisionBuilder *b)

Before calling DecisionBuilder::Next.

virtual void RefuteDecision(Decision *d)

Before refuting the decision.

virtual int ProgressPercent()

Definition constraint_solver.h:4068

virtual void EndNextDecision(DecisionBuilder *b, Decision *d)

After calling DecisionBuilder::Next, along with the returned decision.

virtual void ApplyDecision(Decision *d)

Before applying the decision.

virtual void Accept(ModelVisitor *visitor) const

Accepts the given model visitor.

virtual bool AtLocalOptimum()

virtual bool IsUncheckedSolutionLimitReached()

Definition constraint_solver.h:4061

virtual void ExitSearch()

End of the search.

SearchMonitor(Solver *const s)

Definition constraint_solver.h:3987

virtual void PeriodicCheck()

Periodic call to check limits in long running methods.

virtual void NoMoreSolutions()

When the search tree is finished.

SearchMonitor & operator=(const SearchMonitor &)=delete

void ListenToEvent(Solver::MonitorEvent event)

virtual void BeginFail()

Just when the failure occurs.

Solver * solver() const

Definition constraint_solver.h:4078

virtual bool AcceptSolution()

virtual void EnterSearch()

Beginning of the search.

virtual void AfterDecision(Decision *d, bool apply)

virtual void AcceptNeighbor()

After accepting a neighbor during local search.

virtual void AcceptUncheckedNeighbor()

After accepting an unchecked neighbor during local search.

void Reset(SequenceVar *var)

void WriteToProto(SequenceVarAssignment *sequence_var_assignment_proto) const

bool operator==(const SequenceVarElement &element) const

std::string DebugString() const

SequenceVarElement * Clone()

bool operator!=(const SequenceVarElement &element) const

Definition constraint_solver.h:5367

bool Bound() const

Definition constraint_solver.h:5360

void SetUnperformed(const std::vector< int > &unperformed)

const std::vector< int > & ForwardSequence() const

void Copy(const SequenceVarElement &element)

void SetBackwardSequence(const std::vector< int > &backward_sequence)

const std::vector< int > & BackwardSequence() const

void SetSequence(const std::vector< int > &forward_sequence, const std::vector< int > &backward_sequence, const std::vector< int > &unperformed)

void SetForwardSequence(const std::vector< int > &forward_sequence)

SequenceVar * Var() const

Definition constraint_solver.h:5344

void LoadFromProto(const SequenceVarAssignment &sequence_var_assignment_proto)

const std::vector< int > & Unperformed() const

void RankNotFirst(int index)

void HorizonRange(int64_t *hmin, int64_t *hmax) const

virtual void Accept(ModelVisitor *visitor) const

Accepts the given visitor.

void RankNotLast(int index)

void RankSequence(const std::vector< int > &rank_first, const std::vector< int > &rank_last, const std::vector< int > &unperformed)

IntervalVar * Interval(int index) const

Returns the index_th interval of the sequence.

void ComputePossibleFirstsAndLasts(std::vector< int > *possible_firsts, std::vector< int > *possible_lasts)

int64_t size() const

Returns the number of interval vars in the sequence.

Definition constraint_solver.h:5144

SequenceVar(Solver *s, const std::vector< IntervalVar * > &intervals, const std::vector< IntVar * > &nexts, const std::string &name)

void RankFirst(int index)

void ComputeStatistics(int *ranked, int *not_ranked, int *unperformed) const

Compute statistics on the sequence.

void FillSequence(std::vector< int > *rank_first, std::vector< int > *rank_last, std::vector< int > *unperformed) const

std::string DebugString() const override

void ActiveHorizonRange(int64_t *hmin, int64_t *hmax) const

void DurationRange(int64_t *dmin, int64_t *dmax) const

std::string DebugString() const override

Definition constraint_solver.h:4483

int64_t branches(int n) const

Returns the number of branches when the nth solution was found.

SolutionData BuildSolutionDataForCurrentState()

void AddObjectives(const std::vector< IntVar * > &objectives)

const std::vector< int > & ForwardSequence(int n, SequenceVar *var) const

int64_t objective_value(int n) const

Returns the objective value of the nth solution.

~SolutionCollector() override

void Add(IntVar *var)

Add API.

SolutionCollector & operator=(const SolutionCollector &)=delete

std::vector< std::unique_ptr< Assignment > > solution_pool_

Definition constraint_solver.h:4577

int64_t PerformedValue(int n, IntervalVar *var) const

This is a shortcut to get the PerformedValue of 'var' in the nth solution.

void EnterSearch() override

Beginning of the search.

void FreeSolution(Assignment *solution)

void Push(const SolutionData &data)

Definition constraint_solver.h:4566

void PopSolution()

Remove and delete the last popped solution.

const std::vector< int > & Unperformed(int n, SequenceVar *var) const

void AddObjective(IntVar *objective)

bool has_solution() const

Returns whether any solutions were stored during the search.

void check_index(int n) const

int solution_count() const

Returns how many solutions were stored during the search.

int64_t wall_time(int n) const

Returns the wall time in ms for the nth solution.

void PushSolution()

Push the current state as a new solution.

int64_t DurationValue(int n, IntervalVar *var) const

This is a shortcut to get the DurationValue of 'var' in the nth solution.

int64_t ObjectiveValueFromIndex(int n, int index) const

Returns the value of the index-th objective of the nth solution.

int64_t failures(int n) const

const std::vector< int > & BackwardSequence(int n, SequenceVar *var) const

int64_t StartValue(int n, IntervalVar *var) const

This is a shortcut to get the StartValue of 'var' in the nth solution.

SolutionCollector(Solver *solver, const Assignment *assignment)

Assignment * solution(int n) const

Returns the nth solution.

int64_t Value(int n, IntVar *var) const

This is a shortcut to get the Value of 'var' in the nth solution.

std::vector< Assignment * > recycle_solutions_

Definition constraint_solver.h:4575

std::vector< SolutionData > solution_data_

Definition constraint_solver.h:4574

std::unique_ptr< Assignment > prototype_

Definition constraint_solver.h:4573

Assignment * last_solution_or_null() const

Returns the last solution if there are any, nullptr otherwise.

int64_t EndValue(int n, IntervalVar *var) const

This is a shortcut to get the EndValue of 'var' in the nth solution.

SolutionPool()

Definition constraint_solver.h:5981

virtual bool SyncNeeded(Assignment *local_assignment)=0

virtual void Initialize(Assignment *assignment)=0

virtual void RegisterNewSolution(Assignment *assignment)=0

virtual void GetNextSolution(Assignment *assignment)=0

~SolutionPool() override

Definition constraint_solver.h:5982

Solver Class.

Definition constraint_solver.h:259

Constraint * MakeIsLexicalLessOrEqualWithOffsetsCt(std::vector< IntVar * > left, std::vector< IntVar * > right, std::vector< int64_t > offsets, IntVar *boolvar)

static ConstraintSolverParameters DefaultSolverParameters()

Create a ConstraintSolverParameters proto with all the default values.

Constraint * MakeDistribute(const std::vector< IntVar * > &vars, const std::vector< int64_t > &values, const std::vector< IntVar * > &cards)

Aggregated version of count: |{i | v[i] == values[j]}| == cards[j].

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

Definition constraint_solver.h:818

void SetBranchSelector(BranchSelector bs)

Sets the given branch selector on the current active search.

IntervalVar * MakeMirrorInterval(IntervalVar *interval_var)

IntExpr * MakeElement(const std::vector< int64_t > &values, IntVar *index)

values[index]

OptimizationDirection optimization_direction() const

The direction of optimization, getter and setter.

Definition constraint_solver.h:1116

Constraint * MakePathConnected(std::vector< IntVar * > nexts, std::vector< int64_t > sources, std::vector< int64_t > sinks, std::vector< IntVar * > status)

Check whether more propagation is needed.

int constraints() const

Definition constraint_solver.h:3145

bool CurrentlyInSolve() const

Constraint * MakeIsLessOrEqualCt(IntExpr *left, IntExpr *right, IntVar *b)

b == (left <= right)

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

Demon * RegisterDemon(Demon *demon)

Adds a new demon and wraps it inside a DemonProfiler if necessary.

Search * ActiveSearch() const

Returns the active search, nullptr outside search.

Constraint * MakeScalProdLessOrEqual(const std::vector< IntVar * > &vars, const std::vector< int64_t > &coefficients, int64_t cst)

Solver(const Solver &)=delete

Constraint * MakeIsEqualCstCt(IntExpr *var, int64_t value, IntVar *boolvar)

boolvar == (var == value)

Demon * MakeClosureDemon(Closure closure)

Creates a demon from a closure.

IntExpr * MakeScalProd(const std::vector< IntVar * > &vars, const std::vector< int64_t > &coefs)

scalar product

IntVar * MakeIsGreaterOrEqualVar(IntExpr *left, IntExpr *right)

status var of (left >= right)

IntExpr * MakeDiv(IntExpr *expr, int64_t value)

expr / value (integer division)

Constraint * MakeSortingConstraint(const std::vector< IntVar * > &vars, const std::vector< IntVar * > &sorted)

bool IsLocalSearchProfilingEnabled() const

Returns whether we are profiling local search.

void ExportProfilingOverview(const std::string &filename)

Constraint * MakeLexicalLess(const std::vector< IntVar * > &left, const std::vector< IntVar * > &right)

Constraint * MakeSumEquality(const std::vector< IntVar * > &vars, int64_t cst)

DecisionBuilder * MakeSolveOnce(DecisionBuilder *db)

uint64_t fail_stamp() const

The fail_stamp() is incremented after each backtrack.

int64_t accepted_neighbors() const

The number of accepted neighbors.

Definition constraint_solver.h:1100

DecisionBuilder * MakeApplyBranchSelector(BranchSelector bs)

Creates a decision builder that will set the branch selector.

Constraint * MakeNotMemberCt(IntExpr *expr, const std::vector< int64_t > &values)

expr not in set.

void set_fail_intercept(std::function< void()> fail_intercept)

Internal.

Definition constraint_solver.h:3154

friend class DemonProfiler

Definition constraint_solver.h:3225

Constraint * MakeIsGreaterCt(IntExpr *left, IntExpr *right, IntVar *b)

b == (left > right)

DecisionBuilder * MakeRestoreAssignment(Assignment *assignment)

Constraint * MakeIsGreaterOrEqualCt(IntExpr *left, IntExpr *right, IntVar *b)

b == (left >= right)

SearchMonitor * MakeEnterSearchCallback(std::function< void()> callback)

--— Callback-based search monitors --—

LocalSearchOperator * MakeMoveTowardTargetOperator(const Assignment &target)

void IncrementNeighbors()

Definition constraint_solver.h:1094

Constraint * MakeIsEqualCt(IntExpr *v1, IntExpr *v2, IntVar *b)

b == (v1 == v2)

IntVar * MakeIsMemberVar(IntExpr *expr, const std::vector< int64_t > &values)

Decision * MakeAssignVariableValueOrFail(IntVar *var, int64_t value)

Constraint * MakeNonEquality(IntExpr *left, IntExpr *right)

left != right

IntVar * MakeIsEqualCstVar(IntExpr *var, int64_t value)

status var of (var == value)

Constraint * MakeSubCircuit(const std::vector< IntVar * > &nexts)

Decision * MakeVariableLessOrEqualValue(IntVar *var, int64_t value)

IntExpr * MakeMax(const std::vector< IntVar * > &vars)

std::max(vars)

SearchMonitor * MakeLubyRestart(int scale_factor)

int64_t branches() const

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

Definition constraint_solver.h:1074

OptimizeVar * MakeWeightedOptimize(bool maximize, const std::vector< IntVar * > &sub_objectives, const std::vector< int64_t > &weights, int64_t step)

Creates a weighted objective with a given sense (true = maximization).

IntervalVar * MakeFixedDurationStartSyncedOnEndIntervalVar(IntervalVar *interval_var, int64_t duration, int64_t offset)

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

Example:

IntExpr * MakeDifference(IntExpr *left, IntExpr *right)

left - right

SearchMonitor * MakeConstantRestart(int frequency)

int64_t solutions() const

The number of solutions found since the start of the search.

LocalSearchFilter * MakeVariableDomainFilter()

bool NameAllVariables() const

Returns whether all variables should be named.

DecisionBuilder * MakeNestedOptimize(DecisionBuilder *db, Assignment *solution, bool maximize, int64_t step)

Constraint * MakeMemberCt(IntExpr *expr, const std::vector< int64_t > &values)

friend class IntVar

Definition constraint_solver.h:3227

ABSL_MUST_USE_RESULT RegularLimit * MakeSolutionsLimit(int64_t solutions)

Constraint * MakeGreaterOrEqual(IntExpr *left, IntExpr *right)

left >= right

void AddPropagationMonitor(PropagationMonitor *monitor)

Decision * MakeRankLastInterval(SequenceVar *sequence, int index)

IntVar * MakeBoolVar()

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

T * RevAlloc(T *object)

Definition constraint_solver.h:876

LocalSearchPhaseParameters * MakeLocalSearchPhaseParameters(IntVar *objective, LocalSearchOperator *ls_operator, DecisionBuilder *sub_decision_builder)

Local Search Phase Parameters.

void MakeIntervalVarArray(int count, int64_t start_min, int64_t start_max, int64_t duration_min, int64_t duration_max, int64_t end_min, int64_t end_max, bool optional, absl::string_view name, std::vector< IntervalVar * > *array)

SolutionCollector * MakeBestValueSolutionCollector(const Assignment *assignment, bool maximize)

IntVar * MakeIsLessOrEqualCstVar(IntExpr *var, int64_t value)

status var of (var <= value)

Constraint * MakeIfThenElseCt(IntVar *condition, IntExpr *then_expr, IntExpr *else_expr, IntVar *target_var)

Special cases with arrays of size two.

Solver & operator=(const Solver &)=delete

IntExpr * MakeSum(IntExpr *left, IntExpr *right)

left + right.

Constraint * MakeCumulative(const std::vector< IntervalVar * > &intervals, const std::vector< int64_t > &demands, int64_t capacity, const std::string &name)

Intervals and demands should be vectors of equal size.

ABSL_MUST_USE_RESULT SearchLimit * MakeCustomLimit(std::function< bool()> limiter)

Constraint * MakeScalProdEquality(const std::vector< IntVar * > &vars, const std::vector< int64_t > &coefficients, int64_t cst)

Constraint * MakeIsMemberCt(IntExpr *expr, const std::vector< int64_t > &values, IntVar *boolvar)

boolvar == (expr in set)

static constexpr int kNumPriorities

Number of priorities for demons.

Definition constraint_solver.h:276

IntExpr * MakeMin(const std::vector< IntVar * > &vars)

std::min(vars)

void Fail()

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

Constraint * MakePathCumul(const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, const std::vector< IntVar * > &cumuls, const std::vector< IntVar * > &transits)

const ConstraintSolverParameters & const_parameters() const

Definition constraint_solver.h:844

void CheckFail()

Definition constraint_solver.h:3267

IntVar * MakeIsDifferentVar(IntExpr *v1, IntExpr *v2)

status var of (v1 != v2)

IntervalVar * MakeIntervalVar(int64_t start_min, int64_t start_max, int64_t duration_min, int64_t duration_max, int64_t end_min, int64_t end_max, bool optional, const std::string &name)

ABSL_MUST_USE_RESULT RegularLimit * MakeFailuresLimit(int64_t failures)

Decision * balancing_decision() const

Definition constraint_solver.h:3150

int64_t demon_runs(DemonPriority p) const

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

Definition constraint_solver.h:1083

DemonPriority

Definition constraint_solver.h:646

@ NORMAL_PRIORITY

NORMAL_PRIORITY is the highest priority: Demons will be processed first.

Definition constraint_solver.h:655

@ VAR_PRIORITY

VAR_PRIORITY is between DELAYED_PRIORITY and NORMAL_PRIORITY.

Definition constraint_solver.h:652

@ DELAYED_PRIORITY

Definition constraint_solver.h:649

OptimizeVar * MakeWeightedMinimize(const std::vector< IntVar * > &sub_objectives, const std::vector< int64_t > &weights, int64_t step)

void NewSearch(DecisionBuilder *db, const std::vector< SearchMonitor * > &monitors)

IntVarLocalSearchFilter * MakeSumObjectiveFilter(const std::vector< IntVar * > &vars, IndexEvaluator2 values, Solver::LocalSearchFilterBound filter_enum)

Constraint * MakeNonOverlappingNonStrictBoxesConstraint(const std::vector< IntVar * > &x_vars, const std::vector< IntVar * > &y_vars, const std::vector< IntVar * > &x_size, const std::vector< IntVar * > &y_size)

DecisionBuilder * MakeProfiledDecisionBuilderWrapper(DecisionBuilder *db)

Activates profiling on a decision builder.

bool UseFastLocalSearch() const

Returns true if fast local search is enabled.

Definition constraint_solver.h:3168

IntVar * MakeIsGreaterVar(IntExpr *left, IntExpr *right)

status var of (left > right)

Decision * MakeVariableGreaterOrEqualValue(IntVar *var, int64_t value)

LocalSearchMonitor * GetLocalSearchMonitor() const

Returns the local search monitor.

Assignment * RunUncheckedLocalSearch(const Assignment *initial_solution, LocalSearchFilterManager *filter_manager, LocalSearchOperator *ls_operator, const std::vector< SearchMonitor * > &monitors, RegularLimit *limit, absl::flat_hash_set< IntVar * > *touched=nullptr)

IntVar * MakeIsLessVar(IntExpr *left, IntExpr *right)

status var of (left < right)

ABSL_MUST_USE_RESULT RegularLimit * MakeTimeLimit(absl::Duration time)

Creates a search limit that constrains the running time.

void clear_fail_intercept()

Definition constraint_solver.h:3158

const std::string & context() const

Gets the current context of the search.

Definition constraint_solver.h:1113

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

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

Constraint * MakeDeviation(const std::vector< IntVar * > &vars, IntVar *deviation_var, int64_t total_sum)

int SearchLeftDepth() const

std::function< int64_t(int64_t)> IndexEvaluator1

Callback typedefs.

Definition constraint_solver.h:807

SolverState

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

Definition constraint_solver.h:757

@ IN_SEARCH

Executing the search code.

Definition constraint_solver.h:763

@ IN_ROOT_NODE

Executing the root node.

Definition constraint_solver.h:761

@ PROBLEM_INFEASIBLE

After search, the model is infeasible.

Definition constraint_solver.h:769

@ NO_MORE_SOLUTIONS

After failed NextSolution and before EndSearch.

Definition constraint_solver.h:767

@ OUTSIDE_SEARCH

Before search, after search.

Definition constraint_solver.h:759

@ AT_SOLUTION

After successful NextSolution and before EndSearch.

Definition constraint_solver.h:765

std::function< int64_t(int64_t, int64_t, int64_t)> IndexEvaluator3

Definition constraint_solver.h:809

void set_context(absl::string_view context)

Sets the current context of the search.

Definition constraint_solver.h:1110

DisjunctiveConstraint * MakeDisjunctiveConstraint(const std::vector< IntervalVar * > &intervals, const std::string &name)

DecisionModification

Definition constraint_solver.h:728

@ KEEP_RIGHT

Definition constraint_solver.h:741

@ KEEP_LEFT

Definition constraint_solver.h:736

@ SWITCH_BRANCHES

Definition constraint_solver.h:749

@ NO_CHANGE

Definition constraint_solver.h:731

@ KILL_BOTH

Definition constraint_solver.h:745

friend class LocalSearchProfiler

Definition constraint_solver.h:3234

LocalSearchStatistics GetLocalSearchStatistics() const

Returns detailed local search statistics.

void SaveAndAdd(T *adr, T val)

All-in-one SaveAndAdd_value.

Definition constraint_solver.h:3100

IntVar * RegisterIntVar(IntVar *var)

Registers a new IntVar and wraps it inside a TraceIntVar if necessary.

Constraint * MakeIsGreaterCstCt(IntExpr *v, int64_t c, IntVar *b)

b == (v > c)

DecisionBuilder * Compose(DecisionBuilder *db1, DecisionBuilder *db2)

ObjectiveMonitor * MakeTabuSearch(bool maximize, IntVar *objective, int64_t step, const std::vector< IntVar * > &vars, int64_t keep_tenure, int64_t forbid_tenure, double tabu_factor)

MetaHeuristics which try to get the search out of local optima.

std::string LocalSearchProfile() const

Returns local search profiling information in a human readable format.

IntervalVar * MakeFixedDurationEndSyncedOnStartIntervalVar(IntervalVar *interval_var, int64_t duration, int64_t offset)

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

DecisionBuilder * MakePhase(const std::vector< IntVar * > &vars, IntVarStrategy var_str, IntValueStrategy val_str)

Phases on IntVar arrays.

IntVar * MakeIsGreaterCstVar(IntExpr *var, int64_t value)

status var of (var > value)

bool CheckAssignment(Assignment *solution)

Checks whether the given assignment satisfies all relevant constraints.

LocalSearchOperator * RandomConcatenateOperators(const std::vector< LocalSearchOperator * > &ops)

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

void AddBacktrackAction(Action a, bool fast)

void MakeFixedDurationIntervalVarArray(int count, int64_t start_min, int64_t start_max, int64_t duration, bool optional, absl::string_view name, std::vector< IntervalVar * > *array)

friend class Constraint

Definition constraint_solver.h:3224

Decision * MakeAssignVariableValue(IntVar *var, int64_t val)

Decisions.

void SaveAndSetValue(T *adr, T val)

All-in-one SaveAndSetValue.

Definition constraint_solver.h:3091

std::string model_name() const

Returns the name of the model.

LocalSearchFilter * MakeAcceptFilter()

Local Search Filters.

IntExpr * MakeMonotonicElement(IndexEvaluator1 values, bool increasing, IntVar *index)

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

Decision * MakeScheduleOrExpedite(IntervalVar *var, int64_t est, int64_t *marker)

Constraint * MakeSumLessOrEqual(const std::vector< IntVar * > &vars, int64_t cst)

Variation on arrays.

Constraint * MakeIsLessCstCt(IntExpr *v, int64_t c, IntVar *b)

b == (v < c)

std::function< DecisionModification()> BranchSelector

Definition constraint_solver.h:824

SolutionPool * MakeDefaultSolutionPool()

Solution Pool.

Constraint * MakeNonOverlappingBoxesConstraint(const std::vector< IntVar * > &x_vars, const std::vector< IntVar * > &y_vars, const std::vector< IntVar * > &x_size, const std::vector< IntVar * > &y_size)

LocalSearchOperator * MakeNeighborhoodLimit(LocalSearchOperator *op, int64_t limit)

ConstraintSolverStatistics GetConstraintSolverStatistics() const

Returns detailed cp search statistics.

void SetGuidedLocalSearchPenaltyCallback(std::function< int64_t(int64_t, int64_t, int64_t)> penalty_callback)

Definition constraint_solver.h:1125

Constraint * MakePathEnergyCostConstraint(PathEnergyCostConstraintSpecification specification)

Decision * MakeSplitVariableDomain(IntVar *var, int64_t val, bool start_with_lower_half)

Constraint * MakeSumGreaterOrEqual(const std::vector< IntVar * > &vars, int64_t cst)

Constraint * MakeTemporalDisjunction(IntervalVar *t1, IntervalVar *t2, IntVar *alt)

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

Constraint * MakePathPrecedenceConstraint(std::vector< IntVar * > nexts, const std::vector< std::pair< int, int > > &precedences)

IntervalVar * MakeFixedDurationIntervalVar(int64_t start_min, int64_t start_max, int64_t duration, bool optional, const std::string &name)

DecisionBuilder * MakeLocalSearchPhase(Assignment *assignment, LocalSearchPhaseParameters *parameters)

Constraint * MakeLightElement(F values, IntVar *const var, IntVar *const index, std::function< bool()> deep_serialize=nullptr)

Definition constraint_solver.h:1278

Constraint * MakeLess(IntExpr *left, IntExpr *right)

left < right

IntExpr * CastExpression(const IntVar *var) const

!defined(SWIG)

ModelCache * Cache() const

Returns the cache of the model.

IntExpr * MakeOpposite(IntExpr *expr)

-expr

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

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

ABSL_MUST_USE_RESULT ImprovementSearchLimit * MakeLexicographicImprovementLimit(std::vector< IntVar * > objective_vars, std::vector< bool > maximize, std::vector< double > objective_scaling_factors, std::vector< double > objective_offsets, double improvement_rate_coefficient, int improvement_rate_solutions_distance)

Constraint * MakeAbsEquality(IntVar *var, IntVar *abs_var)

Creates the constraint abs(var) == abs_var.

OptimizeVar * MakeOptimize(bool maximize, IntVar *v, int64_t step)

Creates a objective with a given sense (true = maximization).

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

friend class SimpleRevFIFO

Definition constraint_solver.h:3239

DecisionBuilder * MakeConstraintAdder(Constraint *ct)

UnaryIntervalRelation

Definition constraint_solver.h:693

@ STARTS_BEFORE

t starts before d, i.e. Start(t) <= d.

Definition constraint_solver.h:710

@ ENDS_AT

t ends at d, i.e. End(t) == d.

Definition constraint_solver.h:698

@ STARTS_AFTER

t starts after d, i.e. Start(t) >= d.

Definition constraint_solver.h:704

@ AVOID_DATE

Definition constraint_solver.h:720

@ CROSS_DATE

Definition constraint_solver.h:715

@ ENDS_BEFORE

t ends before d, i.e. End(t) <= d.

Definition constraint_solver.h:701

@ STARTS_AT

t starts at d, i.e. Start(t) == d.

Definition constraint_solver.h:707

@ ENDS_AFTER

t ends after d, i.e. End(t) >= d.

Definition constraint_solver.h:695

IntExpr * MakePiecewiseLinearExpr(IntExpr *expr, const PiecewiseLinearFunction &f)

expressions.

IntExpr * RegisterIntExpr(IntExpr *expr)

Registers a new IntExpr and wraps it inside a TraceIntExpr if necessary.

int64_t neighbors() const

The number of neighbors created.

Definition constraint_solver.h:1089

Constraint * MakeIsDifferentCt(IntExpr *v1, IntExpr *v2, IntVar *b)

b == (v1 != v2)

Constraint * MakeNullIntersectExcept(const std::vector< IntVar * > &first_vars, const std::vector< IntVar * > &second_vars, int64_t escape_value)

IntExpr * MakeModulo(IntExpr *x, int64_t mod)

Modulo expression x % mod (with the python convention for modulo).

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

Definition constraint_solver.h:826

Constraint * MakeGreater(IntExpr *left, IntExpr *right)

left > right

DisjunctiveConstraint * MakeStrictDisjunctiveConstraint(const std::vector< IntervalVar * > &intervals, const std::string &name)

Constraint * MakeLexicalLessOrEqual(const std::vector< IntVar * > &left, const std::vector< IntVar * > &right)

OptimizationDirection

Optimization directions.

Definition constraint_solver.h:773

@ MAXIMIZATION

Definition constraint_solver.h:773

@ NOT_SET

Definition constraint_solver.h:773

@ MINIMIZATION

Definition constraint_solver.h:773

IntVar * MakeIsEqualVar(IntExpr *v1, IntExpr *v2)

status var of (v1 == v2)

IntVar * MakeIsDifferentCstVar(IntExpr *var, int64_t value)

status var of (var != value)

LocalSearchOperator * MakeOperator(const std::vector< IntVar * > &vars, LocalSearchOperators op, std::function< const std::vector< int > &(int, int)> get_incoming_neighbors=nullptr, std::function< const std::vector< int > &(int, int)> get_outgoing_neighbors=nullptr)

Local Search Operators.

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

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

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

IntVarStrategy

Definition constraint_solver.h:280

@ CHOOSE_MIN_SIZE_LOWEST_MIN

Definition constraint_solver.h:301

@ CHOOSE_RANDOM

Randomly select one of the remaining unbound variables.

Definition constraint_solver.h:293

@ CHOOSE_LOWEST_MIN

Definition constraint_solver.h:331

@ CHOOSE_PATH

Definition constraint_solver.h:355

@ CHOOSE_HIGHEST_MAX

Definition constraint_solver.h:337

@ CHOOSE_MIN_SIZE_LOWEST_MAX

Definition constraint_solver.h:317

@ CHOOSE_FIRST_UNBOUND

Definition constraint_solver.h:290

@ INT_VAR_DEFAULT

The default behavior is CHOOSE_FIRST_UNBOUND.

Definition constraint_solver.h:282

@ CHOOSE_MIN_SIZE

Definition constraint_solver.h:342

@ CHOOSE_MAX_SIZE

Definition constraint_solver.h:347

@ INT_VAR_SIMPLE

The simple selection is CHOOSE_FIRST_UNBOUND.

Definition constraint_solver.h:285

@ CHOOSE_MIN_SIZE_HIGHEST_MAX

Definition constraint_solver.h:325

@ CHOOSE_MAX_REGRET_ON_MIN

Definition constraint_solver.h:351

@ CHOOSE_MIN_SIZE_HIGHEST_MIN

Definition constraint_solver.h:309

IntVar * MakeIsBetweenVar(IntExpr *v, int64_t l, int64_t u)

Constraint * MakeElementEquality(const std::vector< int64_t > &vals, IntVar *index, IntVar *target)

IntervalVar * MakeFixedInterval(int64_t start, int64_t duration, const std::string &name)

Creates a fixed and performed interval.

Pack * MakePack(const std::vector< IntVar * > &vars, int number_of_bins)

LocalSearchFilterBound

Definition constraint_solver.h:633

@ EQ

Definition constraint_solver.h:640

@ LE

Move is accepted when the current objective value <= objective.Max.

Definition constraint_solver.h:637

@ GE

Move is accepted when the current objective value >= objective.Min.

Definition constraint_solver.h:635

DecisionBuilder * Try(DecisionBuilder *db1, DecisionBuilder *db2)

std::function< int64_t(int64_t, int64_t)> IndexEvaluator2

Definition constraint_solver.h:808

T * RevAllocArray(T *object)

Definition constraint_solver.h:888

SolutionCollector * MakeAllSolutionCollector()

DecisionBuilder * MakeDefaultPhase(const std::vector< IntVar * > &vars)

SequenceStrategy

Used for scheduling. Not yet implemented.

Definition constraint_solver.h:416

@ CHOOSE_RANDOM_RANK_FORWARD

Definition constraint_solver.h:420

@ SEQUENCE_SIMPLE

Definition constraint_solver.h:418

@ SEQUENCE_DEFAULT

Definition constraint_solver.h:417

@ CHOOSE_MIN_SLACK_RANK_FORWARD

Definition constraint_solver.h:419

LocalSearchFilter * MakeRejectFilter()

IntervalVar * RegisterIntervalVar(IntervalVar *var)

int64_t unchecked_solutions() const

The number of unchecked solutions found by local search.

IntVar * MakeIsGreaterOrEqualCstVar(IntExpr *var, int64_t value)

status var of (var >= value)

Constraint * MakeMinEquality(const std::vector< IntVar * > &vars, IntVar *min_var)

Decision * MakeDecision(Action apply, Action refute)

Constraint * MakeIsLessCt(IntExpr *left, IntExpr *right, IntVar *b)

b == (left < right)

ObjectiveMonitor * MakeLexicographicSimulatedAnnealing(const std::vector< bool > &maximize, std::vector< IntVar * > vars, std::vector< int64_t > steps, std::vector< int64_t > initial_temperatures)

SolutionCollector * MakeFirstSolutionCollector()

Constraint * MakeIndexOfConstraint(const std::vector< IntVar * > &vars, IntVar *index, int64_t target)

int32_t Rand32(int32_t size)

Returns a random value between 0 and 'size' - 1;.

Definition constraint_solver.h:3114

void FinishCurrentSearch()

Tells the solver to kill or restart the current search.

Constraint * MakeDelayedPathCumul(const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, const std::vector< IntVar * > &cumuls, const std::vector< IntVar * > &transits)

std::function< bool(int64_t)> IndexFilter1

Definition constraint_solver.h:811

void Accept(ModelVisitor *visitor) const

Accepts the given model visitor.

Constraint * MakeIndexOfFirstMinValueConstraint(IntVar *index, const std::vector< IntVar * > &vars)

void ClearNeighbors()

Definition constraint_solver.h:1093

IntExpr * MakeAbs(IntExpr *expr)

expr

Decision * MakeRankFirstInterval(SequenceVar *sequence, int index)

IntExpr * MakeSquare(IntExpr *expr)

expr * expr

std::vector< int64_t > tmp_vector_

Definition constraint_solver.h:3221

SolutionCollector * MakeLastSolutionCollector()

ModelVisitor * MakeVariableDegreeVisitor(absl::flat_hash_map< const IntVar *, int > *map)

Compute the number of constraints a variable is attached to.

Constraint * MakeNoCycle(const std::vector< IntVar * > &nexts, const std::vector< IntVar * > &active, IndexFilter1 sink_handler=nullptr)

bool IsProfilingEnabled() const

Returns whether we are profiling the solver.

MonitorEvent

Search monitor events.

Definition constraint_solver.h:777

@ kAccept

Definition constraint_solver.h:800

@ kAtSolution

Definition constraint_solver.h:791

@ kEndNextDecision

Definition constraint_solver.h:782

@ kEndFail

Definition constraint_solver.h:787

@ kRefuteDecision

Definition constraint_solver.h:784

@ kLocalOptimum

Definition constraint_solver.h:793

@ kIsUncheckedSolutionLimitReached

Definition constraint_solver.h:797

@ kBeginFail

Definition constraint_solver.h:786

@ kAcceptSolution

Definition constraint_solver.h:790

@ kPeriodicCheck

Definition constraint_solver.h:798

@ kAcceptUncheckedNeighbor

Definition constraint_solver.h:796

@ kNoMoreSolutions

Definition constraint_solver.h:792

@ kAcceptDelta

Definition constraint_solver.h:794

@ kEnterSearch

Definition constraint_solver.h:778

@ kLast

Definition constraint_solver.h:802

@ kBeginNextDecision

Definition constraint_solver.h:781

@ kRestartSearch

Definition constraint_solver.h:779

@ kEndInitialPropagation

Definition constraint_solver.h:789

@ kAcceptNeighbor

Definition constraint_solver.h:795

@ kAfterDecision

Definition constraint_solver.h:785

@ kExitSearch

Definition constraint_solver.h:780

@ kProgressPercent

Definition constraint_solver.h:799

@ kBeginInitialPropagation

Definition constraint_solver.h:788

@ kApplyDecision

Definition constraint_solver.h:783

std::function< void()> Closure

Definition constraint_solver.h:827

friend class SearchMonitor

Definition constraint_solver.h:3230

Constraint * MakeIndexOfFirstMaxValueConstraint(IntVar *index, const std::vector< IntVar * > &vars)

DecisionBuilder * MakeStoreAssignment(Assignment *assignment)

Constraint * MakeScalProdGreaterOrEqual(const std::vector< IntVar * > &vars, const std::vector< int64_t > &coeffs, int64_t cst)

IntExpr * MakeIndexExpression(const std::vector< IntVar * > &vars, int64_t value)

std::string SearchContext() const

BinaryIntervalRelation

Definition constraint_solver.h:660

@ STAYS_IN_SYNC

Definition constraint_solver.h:688

@ STARTS_AT_START

t1 starts at t2 start, i.e. Start(t1) == Start(t2) + delay.

Definition constraint_solver.h:683

@ ENDS_AFTER_END

t1 ends after t2 end, i.e. End(t1) >= End(t2) + delay.

Definition constraint_solver.h:662

@ ENDS_AFTER_START

t1 ends after t2 start, i.e. End(t1) >= Start(t2) + delay.

Definition constraint_solver.h:665

@ ENDS_AT_END

t1 ends at t2 end, i.e. End(t1) == End(t2) + delay.

Definition constraint_solver.h:668

@ ENDS_AT_START

t1 ends at t2 start, i.e. End(t1) == Start(t2) + delay.

Definition constraint_solver.h:671

@ STARTS_AFTER_END

t1 starts after t2 end, i.e. Start(t1) >= End(t2) + delay.

Definition constraint_solver.h:674

@ STARTS_AFTER_START

t1 starts after t2 start, i.e. Start(t1) >= Start(t2) + delay.

Definition constraint_solver.h:677

@ STARTS_AT_END

t1 starts at t2 end, i.e. Start(t1) == End(t2) + delay.

Definition constraint_solver.h:680

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

SearchMonitor * MakeExitSearchCallback(std::function< void()> callback)

LocalSearchOperator * MultiArmedBanditConcatenateOperators(const std::vector< LocalSearchOperator * > &ops, double memory_coefficient, double exploration_coefficient, bool maximize)

SearchMonitor * MakeSearchTrace(const std::string &prefix)

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

SolutionCollector * MakeNBestValueSolutionCollector(const Assignment *assignment, int solution_count, bool maximize)

Constraint * MakeMaxEquality(const std::vector< IntVar * > &vars, IntVar *max_var)

friend class SearchLimit

Definition constraint_solver.h:3231

void ClearLocalSearchState()

Clears the local search state.

Definition constraint_solver.h:3215

std::function< IntVar *(int64_t)> Int64ToIntVar

Definition constraint_solver.h:813

Constraint * MakeEquality(IntExpr *left, IntExpr *right)

left == right

IntervalVar * MakeIntervalRelaxedMax(IntervalVar *interval_var)

IntVar * MakeIsLessOrEqualVar(IntExpr *left, IntExpr *right)

status var of (left <= right)

ObjectiveMonitor * MakeLexicographicTabuSearch(const std::vector< bool > &maximize, std::vector< IntVar * > objectives, std::vector< int64_t > steps, const std::vector< IntVar * > &vars, int64_t keep_tenure, int64_t forbid_tenure, double tabu_factor)

Assignment * MakeAssignment()

This method creates an empty assignment.

DecisionBuilder * MakeDecisionBuilderFromAssignment(Assignment *assignment, DecisionBuilder *db, const std::vector< IntVar * > &vars)

EvaluatorLocalSearchOperators

Definition constraint_solver.h:605

@ TSPLNS

Definition constraint_solver.h:626

@ LK

Definition constraint_solver.h:610

@ TSPOPT

Definition constraint_solver.h:618

int64_t wall_time() const

ABSL_MUST_USE_RESULT RegularLimit * MakeBranchesLimit(int64_t branches)

LocalSearchOperators

Definition constraint_solver.h:440

@ MAKEINACTIVE

Definition constraint_solver.h:515

@ EXCHANGE

Definition constraint_solver.h:483

@ SIMPLELNS

Definition constraint_solver.h:600

@ FULLPATHLNS

Definition constraint_solver.h:571

@ MAKEACTIVE

Definition constraint_solver.h:506

@ UNACTIVELNS

Definition constraint_solver.h:576

@ CROSS

Definition constraint_solver.h:496

@ TWOOPT

Definition constraint_solver.h:452

@ OROPT

Definition constraint_solver.h:469

@ SWAPACTIVECHAIN

Definition constraint_solver.h:544

@ EXTENDEDSWAPACTIVE

Definition constraint_solver.h:558

@ MAKECHAININACTIVE

Definition constraint_solver.h:525

@ PATHLNS

Definition constraint_solver.h:567

@ DECREMENT

Definition constraint_solver.h:591

@ RELOCATE

Relocate neighborhood with length of 1 (see OROPT comment).

Definition constraint_solver.h:472

@ SWAPACTIVE

Definition constraint_solver.h:534

@ INCREMENT

Definition constraint_solver.h:586

Constraint * MakeTrueConstraint()

This constraint always succeeds.

Decision * MakeScheduleOrPostpone(IntervalVar *var, int64_t est, int64_t *marker)

Demon * MakeDelayedConstraintInitialPropagateCallback(Constraint *ct)

SearchMonitor * MakeSearchLog(int branch_period)

friend class PropagationBaseObject

Definition constraint_solver.h:3228

ObjectiveMonitor * MakeSimulatedAnnealing(bool maximize, IntVar *v, int64_t step, int64_t initial_temperature)

Creates a Simulated Annealing monitor.

Constraint * MakeLessOrEqual(IntExpr *left, IntExpr *right)

left <= right

bool HasName(const PropagationBaseObject *object) const

Returns whether the object has been named or not.

Constraint * MakeIsGreaterOrEqualCstCt(IntExpr *var, int64_t value, IntVar *boolvar)

boolvar == (var >= value)

int64_t GetGuidedLocalSearchPenalty(int64_t i, int64_t j, int64_t k) const

Definition constraint_solver.h:1130

OptimizeVar * MakeMinimize(IntVar *v, int64_t step)

Creates a minimization objective.

void SetSearchContext(Search *search, absl::string_view search_context)

void RestartCurrentSearch()

ObjectiveMonitor * MakeGuidedLocalSearch(bool maximize, IntVar *objective, IndexEvaluator2 objective_function, int64_t step, const std::vector< IntVar * > &vars, double penalty_factor, std::function< std::vector< std::pair< int64_t, int64_t > >(int64_t, int64_t)> get_equivalent_pairs=nullptr, bool reset_penalties_on_new_best_solution=false)

IntervalVar * MakeFixedDurationEndSyncedOnEndIntervalVar(IntervalVar *interval_var, int64_t duration, int64_t offset)

Constraint * MakeLexicalLessOrEqualWithOffsets(std::vector< IntVar * > left, std::vector< IntVar * > right, std::vector< int64_t > offsets)

std::string DebugString() const

!defined(SWIG)

Constraint * MakeBetweenCt(IntExpr *expr, int64_t l, int64_t u)

(l <= expr <= u)

DemonProfiler * demon_profiler() const

Access to demon profiler.

Definition constraint_solver.h:3160

Demon * MakeConstraintInitialPropagateCallback(Constraint *ct)

void MakeIntVarArray(int var_count, int64_t vmin, int64_t vmax, const std::string &name, std::vector< IntVar * > *vars)

ABSL_MUST_USE_RESULT RegularLimit * MakeLimit(absl::Duration time, int64_t branches, int64_t failures, int64_t solutions, bool smart_time_check=false, bool cumulative=false)

OptimizeVar * MakeWeightedMaximize(const std::vector< IntVar * > &sub_objectives, const std::vector< int64_t > &weights, int64_t step)

Creates a maximization weigthed objective.

int64_t filtered_neighbors() const

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

Definition constraint_solver.h:1097

Decision * MakeAssignVariableValueOrDoNothing(IntVar *var, int64_t value)

SolverState state() const

State of the solver.

Definition constraint_solver.h:1044

SolutionCollector * MakeNBestLexicographicValueSolutionCollector(const Assignment *assignment, int solution_count, std::vector< bool > maximize)

int64_t Rand64(int64_t size)

Returns a random value between 0 and 'size' - 1;.

Definition constraint_solver.h:3108

IntVar * MakeIntVar(int64_t min, int64_t max, const std::string &name)

MakeIntVar will create the best range based int var for the bounds given.

void ShouldFail()

Definition constraint_solver.h:3266

ConstraintSolverParameters parameters() const

Stored Parameters.

Definition constraint_solver.h:842

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

Constraint * MakeIntervalVarRelationWithDelay(IntervalVar *t1, BinaryIntervalRelation r, IntervalVar *t2, int64_t delay)

std::function< bool(int64_t, int64_t, int64_t)> VariableValueComparator

Definition constraint_solver.h:823

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

ModelVisitor * MakePrintModelVisitor()

Prints the model.

void SaveValue(T *o)

reversibility

Definition constraint_solver.h:857

Constraint * MakeFalseConstraint()

This constraint always fails.

friend void InternalSaveBooleanVarValue(Solver *, IntVar *)

ObjectiveMonitor * MakeGenericTabuSearch(bool maximize, IntVar *v, int64_t step, const std::vector< IntVar * > &tabu_vars, int64_t forbid_tenure)

void ReSeed(int32_t seed)

Reseed the solver random generator.

Definition constraint_solver.h:3120

IntervalStrategy

Definition constraint_solver.h:425

@ INTERVAL_SET_TIMES_FORWARD

Definition constraint_solver.h:432

@ INTERVAL_DEFAULT

The default is INTERVAL_SET_TIMES_FORWARD.

Definition constraint_solver.h:427

@ INTERVAL_SET_TIMES_BACKWARD

Definition constraint_solver.h:435

@ INTERVAL_SIMPLE

The simple is INTERVAL_SET_TIMES_FORWARD.

Definition constraint_solver.h:429

bool IsProduct(IntExpr *expr, IntExpr **inner_expr, int64_t *coefficient)

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

Convex piecewise function.

Assignment * GetOrCreateLocalSearchState()

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

IntervalVar * MakeFixedDurationStartSyncedOnStartIntervalVar(IntervalVar *interval_var, int64_t duration, int64_t offset)

void set_optimization_direction(OptimizationDirection direction)

Definition constraint_solver.h:1119

IntExpr * MakePower(IntExpr *expr, int64_t n)

expr ^ n (n > 0)

IntExpr * MakeConditionalExpression(IntVar *condition, IntExpr *expr, int64_t unperformed_value)

Conditional Expr condition ? expr : unperformed_value.

IntValueStrategy

Definition constraint_solver.h:361

@ ASSIGN_CENTER_VALUE

Definition constraint_solver.h:380

@ SPLIT_UPPER_HALF

Definition constraint_solver.h:388

@ ASSIGN_MAX_VALUE

Selects the max value of the selected variable.

Definition constraint_solver.h:372

@ INT_VALUE_DEFAULT

The default behavior is ASSIGN_MIN_VALUE.

Definition constraint_solver.h:363

@ SPLIT_LOWER_HALF

Definition constraint_solver.h:384

@ INT_VALUE_SIMPLE

The simple selection is ASSIGN_MIN_VALUE.

Definition constraint_solver.h:366

@ ASSIGN_MIN_VALUE

Selects the min value of the selected variable.

Definition constraint_solver.h:369

@ ASSIGN_RANDOM_VALUE

Selects randomly one of the possible values of the selected variable.

Definition constraint_solver.h:375

OptimizeVar * MakeLexicographicOptimize(std::vector< bool > maximize, std::vector< IntVar * > variables, std::vector< int64_t > steps)

MarkerType

Definition constraint_solver.h:754

@ CHOICE_POINT

Definition constraint_solver.h:754

@ SENTINEL

Definition constraint_solver.h:754

@ SIMPLE_MARKER

Definition constraint_solver.h:754

@ REVERSIBLE_ACTION

Definition constraint_solver.h:754

SearchMonitor * MakeSymmetryManager(const std::vector< SymmetryBreaker * > &visitors)

Symmetry Breaking.

IntVar * MakeIsLessCstVar(IntExpr *var, int64_t value)

status var of (var < value)

IntervalVar * MakeIntervalRelaxedMin(IntervalVar *interval_var)

int64_t failures() const

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

Definition constraint_solver.h:1086

bool CheckConstraint(Constraint *ct)

RegularLimitParameters MakeDefaultRegularLimitParameters() const

Creates a regular limit proto containing default values.

bool InstrumentsDemons() const

Returns whether we are instrumenting demons.

Constraint * MakeIsBetweenCt(IntExpr *expr, int64_t l, int64_t u, IntVar *b)

b == (l <= expr <= u)

Constraint * MakeIsLessOrEqualCstCt(IntExpr *var, int64_t value, IntVar *boolvar)

boolvar == (var <= value)

bool AcceptSolution(Search *search) const

PropagationMonitor * GetPropagationMonitor() const

Returns the propagation monitor.

Constraint * MakeTransitionConstraint(const std::vector< IntVar * > &vars, const IntTupleSet &transition_table, int64_t initial_state, const std::vector< int64_t > &final_states)

Decision * MakeFailDecision()

IntExpr * MakeProd(IntExpr *left, IntExpr *right)

left * right

IntVar * MakeIntConst(int64_t val, const std::string &name)

IntConst will create a constant expression.

Constraint * MakeIntervalVarRelation(IntervalVar *t, UnaryIntervalRelation r, int64_t d)

Demon * MakeActionDemon(Action action)

Creates a demon from a callback.

Constraint * MakeNullIntersect(const std::vector< IntVar * > &first_vars, const std::vector< IntVar * > &second_vars)

Solver(const std::string &name)

Solver API.

bool InstrumentsVariables() const

Returns whether we are tracing variables.

Constraint * MakeNotBetweenCt(IntExpr *expr, int64_t l, int64_t u)

void AddLocalSearchMonitor(LocalSearchMonitor *monitor)

BaseObjectiveMonitor * MakeRoundRobinCompoundObjectiveMonitor(std::vector< BaseObjectiveMonitor * > monitors, int num_max_local_optima_before_metaheuristic_switch)

Constraint * MakePathTransitPrecedenceConstraint(std::vector< IntVar * > nexts, std::vector< IntVar * > transits, const std::vector< std::pair< int, int > > &precedences)

static int64_t MemoryUsage()

Current memory usage in bytes.

Constraint * MakeCover(const std::vector< IntervalVar * > &vars, IntervalVar *target_var)

void AddConstraint(Constraint *c)

Adds the constraint 'c' to the model.

LocalSearchOperator * MakeRandomLnsOperator(const std::vector< IntVar * > &vars, int number_of_variables)

Constraint * MakeInversePermutationConstraint(const std::vector< IntVar * > &left, const std::vector< IntVar * > &right)

void SetUseFastLocalSearch(bool use_fast_local_search)

Definition constraint_solver.h:3164

OptimizeVar * MakeMaximize(IntVar *v, int64_t step)

Creates a maximization objective.

EvaluatorStrategy

Definition constraint_solver.h:401

@ CHOOSE_DYNAMIC_GLOBAL_BEST

Definition constraint_solver.h:412

@ CHOOSE_STATIC_GLOBAL_BEST

Definition constraint_solver.h:406

Constraint * MakeIsDifferentCstCt(IntExpr *var, int64_t value, IntVar *boolvar)

boolvar == (var != value)

IntExpr * MakeSemiContinuousExpr(IntExpr *expr, int64_t fixed_charge, int64_t step)

ABSL_MUST_USE_RESULT ImprovementSearchLimit * MakeImprovementLimit(IntVar *objective_var, bool maximize, double objective_scaling_factor, double objective_offset, double improvement_rate_coefficient, int improvement_rate_solutions_distance)

ModelVisitor * MakeStatisticsModelVisitor()

Displays some nice statistics on the model.

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

Definition constraint_solver.h:821

bool SolveAndCommit(DecisionBuilder *db, const std::vector< SearchMonitor * > &monitors)

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

OR_DLL ABSL_DECLARE_FLAG(int64_t, cp_random_seed)

bool FindCopy(const Collection &collection, const Key &key, Value *const value)

const MapUtilMappedT< Collection > & FindWithDefault(const Collection &collection, const KeyType &key, const MapUtilMappedT< Collection > &value)

dual_gradient T(y - `dual_solution`) class DiagonalTrustRegionProblemFromQp

Select next search node to expand Select next item_i to add this new search node to the search Generate a new search node where item_i is not in the knapsack Check validity of this new partial solution(using propagators) - If valid

int64_t CapSub(int64_t x, int64_t y)

int64_t Zero()

NOLINT.

Definition constraint_solver.h:3436

int64_t CpRandomSeed()

Definition constraint_solver.h:175

std::ostream & operator<<(std::ostream &out, const Assignment &assignment)

int64_t One()

This method returns 1.

Definition constraint_solver.h:3439

void SetAssignmentFromAssignment(Assignment *target_assignment, const std::vector< IntVar * > &target_vars, const Assignment *source_assignment, const std::vector< IntVar * > &source_vars)

NOLINT.

int64_t CapOpp(int64_t v)

This struct holds all parameters for the default search.

Definition constraint_solver.h:184

bool run_all_heuristics

Definition constraint_solver.h:213

bool use_last_conflict

Should we use last conflict method. The default is false.

Definition constraint_solver.h:235

bool persistent_impact

Definition constraint_solver.h:225

DecisionBuilder * decision_builder

When defined, this overrides the default impact based decision builder.

Definition constraint_solver.h:238

int heuristic_period

Definition constraint_solver.h:218

DisplayLevel

Definition constraint_solver.h:197

@ NORMAL

Definition constraint_solver.h:197

@ VERBOSE

Definition constraint_solver.h:197

@ NONE

Definition constraint_solver.h:197

ValueSelection

Definition constraint_solver.h:192

@ SELECT_MAX_IMPACT

Definition constraint_solver.h:194

@ SELECT_MIN_IMPACT

Definition constraint_solver.h:193

int initialization_splits

Definition constraint_solver.h:208

int heuristic_num_failures_limit

The failure limit for each heuristic that we run.

Definition constraint_solver.h:221

DisplayLevel display_level

Definition constraint_solver.h:232

VariableSelection

Definition constraint_solver.h:186

@ CHOOSE_MAX_SUM_IMPACT

Definition constraint_solver.h:187

@ CHOOSE_MAX_VALUE_IMPACT

Definition constraint_solver.h:189

@ CHOOSE_MAX_AVERAGE_IMPACT

Definition constraint_solver.h:188

ValueSelection value_selection_schema

This parameter describes which value to select for a given var.

Definition constraint_solver.h:204

int random_seed

Seed used to initialize the random part in some heuristics.

Definition constraint_solver.h:228

VariableSelection var_selection_schema

Definition constraint_solver.h:201

static Iterator End(IntVarIterator *it)

Definition constraint_solver.h:4325

Iterator & operator++()

Definition constraint_solver.h:4333

bool operator!=(const Iterator &other) const

Definition constraint_solver.h:4338

static Iterator Begin(IntVarIterator *it)

These are the only way to construct an Iterator.

Definition constraint_solver.h:4322

int64_t operator*() const

Definition constraint_solver.h:4329

int64_t ObjectiveValue() const

int64_t time

Definition constraint_solver.h:4556

bool operator<(const SolutionData &other) const

int64_t ObjectiveValueFromIndex(int index) const

IntegerCastInfo()

Definition constraint_solver.h:266

IntVar * variable

Definition constraint_solver.h:270

IntExpr * expression

Definition constraint_solver.h:271

IntegerCastInfo(IntVar *const v, IntExpr *const e, Constraint *const c)

Definition constraint_solver.h:268

Constraint * maintainer

Definition constraint_solver.h:272

bool IsNull() const

Definition constraint_solver.h:1854

int64_t cost_per_unit_above_threshold

Definition constraint_solver.h:1853

int64_t threshold

Definition constraint_solver.h:1851

int64_t cost_per_unit_below_threshold

Definition constraint_solver.h:1852

std::vector< IntVar * > paths

Definition constraint_solver.h:1860

std::vector< IntVar * > nexts

Definition constraint_solver.h:1859

std::vector< EnergyCost > path_energy_costs

Definition constraint_solver.h:1863

std::vector< bool > path_used_when_empty

Definition constraint_solver.h:1864

std::vector< IntVar * > forces

Definition constraint_solver.h:1861

std::vector< int64_t > path_starts

Definition constraint_solver.h:1865

std::vector< IntVar * > costs

Definition constraint_solver.h:1867

std::vector< int64_t > path_ends

Definition constraint_solver.h:1866

std::vector< IntVar * > distances

Definition constraint_solver.h:1862

Creates a search monitor from logging parameters.

Definition constraint_solver.h:2565

std::vector< double > scaling_factors

Definition constraint_solver.h:2576

std::vector< double > offsets

Definition constraint_solver.h:2577

int branch_period

Definition constraint_solver.h:2568

std::function< std::string()> display_callback

Definition constraint_solver.h:2581

bool display_on_new_solutions_only

Definition constraint_solver.h:2584

OptimizeVar * objective

Definition constraint_solver.h:2571

std::vector< IntVar * > variables

Definition constraint_solver.h:2572

CycleTimer SimpleCycleTimer

static const int64_t kint64max