OR-Tools  8.0
cp_model_utils.cc
Go to the documentation of this file.
1 // Copyright 2010-2018 Google LLC
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13 
14 #include "ortools/sat/cp_model_utils.h"
15 
16 #include "absl/container/flat_hash_set.h"
17 #include "ortools/base/stl_util.h"
18 
19 namespace operations_research {
20 namespace sat {
21 
22 namespace {
23 
24 template <typename IntList>
25 void AddIndices(const IntList& indices, absl::flat_hash_set<int>* output) {
26  output->insert(indices.begin(), indices.end());
27 }
28 
29 template <typename IntList>
30 void AddIndices(const IntList& indices, std::vector<int>* output) {
31  output->insert(output->end(), indices.begin(), indices.end());
32 }
33 
34 } // namespace
35 
36 void SetToNegatedLinearExpression(const LinearExpressionProto& input_expr,
37  LinearExpressionProto* output_negated_expr) {
38  output_negated_expr->Clear();
39  for (int i = 0; i < input_expr.vars_size(); ++i) {
40  output_negated_expr->add_vars(NegatedRef(input_expr.vars(i)));
41  output_negated_expr->add_coeffs(input_expr.coeffs(i));
42  }
43  output_negated_expr->set_offset(-input_expr.offset());
44 }
45 
46 IndexReferences GetReferencesUsedByConstraint(const ConstraintProto& ct) {
47  IndexReferences output;
48  switch (ct.constraint_case()) {
49  case ConstraintProto::ConstraintCase::kBoolOr:
50  AddIndices(ct.bool_or().literals(), &output.literals);
51  break;
52  case ConstraintProto::ConstraintCase::kBoolAnd:
53  AddIndices(ct.bool_and().literals(), &output.literals);
54  break;
55  case ConstraintProto::ConstraintCase::kAtMostOne:
56  AddIndices(ct.at_most_one().literals(), &output.literals);
57  break;
58  case ConstraintProto::ConstraintCase::kBoolXor:
59  AddIndices(ct.bool_xor().literals(), &output.literals);
60  break;
61  case ConstraintProto::ConstraintCase::kIntDiv:
62  output.variables.push_back(ct.int_div().target());
63  AddIndices(ct.int_div().vars(), &output.variables);
64  break;
65  case ConstraintProto::ConstraintCase::kIntMod:
66  output.variables.push_back(ct.int_mod().target());
67  AddIndices(ct.int_mod().vars(), &output.variables);
68  break;
69  case ConstraintProto::ConstraintCase::kIntMax:
70  output.variables.push_back(ct.int_max().target());
71  AddIndices(ct.int_max().vars(), &output.variables);
72  break;
73  case ConstraintProto::ConstraintCase::kLinMax: {
74  AddIndices(ct.lin_max().target().vars(), &output.variables);
75  for (int i = 0; i < ct.lin_max().exprs_size(); ++i) {
76  AddIndices(ct.lin_max().exprs(i).vars(), &output.variables);
77  }
78  break;
79  }
80  case ConstraintProto::ConstraintCase::kIntMin:
81  output.variables.push_back(ct.int_min().target());
82  AddIndices(ct.int_min().vars(), &output.variables);
83  break;
84  case ConstraintProto::ConstraintCase::kLinMin: {
85  AddIndices(ct.lin_min().target().vars(), &output.variables);
86  for (int i = 0; i < ct.lin_min().exprs_size(); ++i) {
87  AddIndices(ct.lin_min().exprs(i).vars(), &output.variables);
88  }
89  break;
90  }
91  case ConstraintProto::ConstraintCase::kIntProd:
92  output.variables.push_back(ct.int_prod().target());
93  AddIndices(ct.int_prod().vars(), &output.variables);
94  break;
95  case ConstraintProto::ConstraintCase::kLinear:
96  AddIndices(ct.linear().vars(), &output.variables);
97  break;
98  case ConstraintProto::ConstraintCase::kAllDiff:
99  AddIndices(ct.all_diff().vars(), &output.variables);
100  break;
101  case ConstraintProto::ConstraintCase::kElement:
102  output.variables.push_back(ct.element().index());
103  output.variables.push_back(ct.element().target());
104  AddIndices(ct.element().vars(), &output.variables);
105  break;
106  case ConstraintProto::ConstraintCase::kCircuit:
107  AddIndices(ct.circuit().literals(), &output.literals);
108  break;
109  case ConstraintProto::ConstraintCase::kRoutes:
110  AddIndices(ct.routes().literals(), &output.literals);
111  break;
112  case ConstraintProto::ConstraintCase::kCircuitCovering:
113  AddIndices(ct.circuit_covering().nexts(), &output.variables);
114  break;
115  case ConstraintProto::ConstraintCase::kInverse:
116  AddIndices(ct.inverse().f_direct(), &output.variables);
117  AddIndices(ct.inverse().f_inverse(), &output.variables);
118  break;
119  case ConstraintProto::ConstraintCase::kReservoir:
120  AddIndices(ct.reservoir().times(), &output.variables);
121  AddIndices(ct.reservoir().actives(), &output.literals);
122  break;
123  case ConstraintProto::ConstraintCase::kTable:
124  AddIndices(ct.table().vars(), &output.variables);
125  break;
126  case ConstraintProto::ConstraintCase::kAutomaton:
127  AddIndices(ct.automaton().vars(), &output.variables);
128  break;
129  case ConstraintProto::ConstraintCase::kInterval:
130  output.variables.push_back(ct.interval().start());
131  output.variables.push_back(ct.interval().end());
132  output.variables.push_back(ct.interval().size());
133  break;
134  case ConstraintProto::ConstraintCase::kNoOverlap:
135  break;
136  case ConstraintProto::ConstraintCase::kNoOverlap2D:
137  break;
138  case ConstraintProto::ConstraintCase::kCumulative:
139  output.variables.push_back(ct.cumulative().capacity());
140  AddIndices(ct.cumulative().demands(), &output.variables);
141  break;
142  case ConstraintProto::ConstraintCase::CONSTRAINT_NOT_SET:
143  break;
144  }
145  return output;
146 }
147 
148 #define APPLY_TO_SINGULAR_FIELD(ct_name, field_name) \
149  { \
150  int temp = ct->mutable_##ct_name()->field_name(); \
151  f(&temp); \
152  ct->mutable_##ct_name()->set_##field_name(temp); \
153  }
154 
155 #define APPLY_TO_REPEATED_FIELD(ct_name, field_name) \
156  { \
157  for (int& r : *ct->mutable_##ct_name()->mutable_##field_name()) f(&r); \
158  }
159 
160 void ApplyToAllLiteralIndices(const std::function<void(int*)>& f,
161  ConstraintProto* ct) {
162  for (int& r : *ct->mutable_enforcement_literal()) f(&r);
163  switch (ct->constraint_case()) {
164  case ConstraintProto::ConstraintCase::kBoolOr:
165  APPLY_TO_REPEATED_FIELD(bool_or, literals);
166  break;
167  case ConstraintProto::ConstraintCase::kBoolAnd:
168  APPLY_TO_REPEATED_FIELD(bool_and, literals);
169  break;
170  case ConstraintProto::ConstraintCase::kAtMostOne:
171  APPLY_TO_REPEATED_FIELD(at_most_one, literals);
172  break;
173  case ConstraintProto::ConstraintCase::kBoolXor:
174  APPLY_TO_REPEATED_FIELD(bool_xor, literals);
175  break;
176  case ConstraintProto::ConstraintCase::kIntDiv:
177  break;
178  case ConstraintProto::ConstraintCase::kIntMod:
179  break;
180  case ConstraintProto::ConstraintCase::kIntMax:
181  break;
182  case ConstraintProto::ConstraintCase::kLinMax:
183  break;
184  case ConstraintProto::ConstraintCase::kIntMin:
185  break;
186  case ConstraintProto::ConstraintCase::kLinMin:
187  break;
188  case ConstraintProto::ConstraintCase::kIntProd:
189  break;
190  case ConstraintProto::ConstraintCase::kLinear:
191  break;
192  case ConstraintProto::ConstraintCase::kAllDiff:
193  break;
194  case ConstraintProto::ConstraintCase::kElement:
195  break;
196  case ConstraintProto::ConstraintCase::kCircuit:
197  APPLY_TO_REPEATED_FIELD(circuit, literals);
198  break;
199  case ConstraintProto::ConstraintCase::kRoutes:
200  APPLY_TO_REPEATED_FIELD(routes, literals);
201  break;
202  case ConstraintProto::ConstraintCase::kCircuitCovering:
203  break;
204  case ConstraintProto::ConstraintCase::kInverse:
205  break;
206  case ConstraintProto::ConstraintCase::kReservoir:
207  APPLY_TO_REPEATED_FIELD(reservoir, actives);
208  break;
209  case ConstraintProto::ConstraintCase::kTable:
210  break;
211  case ConstraintProto::ConstraintCase::kAutomaton:
212  break;
213  case ConstraintProto::ConstraintCase::kInterval:
214  break;
215  case ConstraintProto::ConstraintCase::kNoOverlap:
216  break;
217  case ConstraintProto::ConstraintCase::kNoOverlap2D:
218  break;
219  case ConstraintProto::ConstraintCase::kCumulative:
220  break;
221  case ConstraintProto::ConstraintCase::CONSTRAINT_NOT_SET:
222  break;
223  }
224 }
225 
226 void ApplyToAllVariableIndices(const std::function<void(int*)>& f,
227  ConstraintProto* ct) {
228  switch (ct->constraint_case()) {
229  case ConstraintProto::ConstraintCase::kBoolOr:
230  break;
231  case ConstraintProto::ConstraintCase::kBoolAnd:
232  break;
233  case ConstraintProto::ConstraintCase::kAtMostOne:
234  break;
235  case ConstraintProto::ConstraintCase::kBoolXor:
236  break;
237  case ConstraintProto::ConstraintCase::kIntDiv:
238  APPLY_TO_SINGULAR_FIELD(int_div, target);
239  APPLY_TO_REPEATED_FIELD(int_div, vars);
240  break;
241  case ConstraintProto::ConstraintCase::kIntMod:
242  APPLY_TO_SINGULAR_FIELD(int_mod, target);
243  APPLY_TO_REPEATED_FIELD(int_mod, vars);
244  break;
245  case ConstraintProto::ConstraintCase::kIntMax:
246  APPLY_TO_SINGULAR_FIELD(int_max, target);
247  APPLY_TO_REPEATED_FIELD(int_max, vars);
248  break;
249  case ConstraintProto::ConstraintCase::kLinMax:
250  APPLY_TO_REPEATED_FIELD(lin_max, target()->mutable_vars);
251  for (int i = 0; i < ct->lin_max().exprs_size(); ++i) {
252  APPLY_TO_REPEATED_FIELD(lin_max, exprs(i)->mutable_vars);
253  }
254  break;
255  case ConstraintProto::ConstraintCase::kIntMin:
256  APPLY_TO_SINGULAR_FIELD(int_min, target);
257  APPLY_TO_REPEATED_FIELD(int_min, vars);
258  break;
259  case ConstraintProto::ConstraintCase::kLinMin:
260  APPLY_TO_REPEATED_FIELD(lin_min, target()->mutable_vars);
261  for (int i = 0; i < ct->lin_min().exprs_size(); ++i) {
262  APPLY_TO_REPEATED_FIELD(lin_min, exprs(i)->mutable_vars);
263  }
264  break;
265  case ConstraintProto::ConstraintCase::kIntProd:
266  APPLY_TO_SINGULAR_FIELD(int_prod, target);
267  APPLY_TO_REPEATED_FIELD(int_prod, vars);
268  break;
269  case ConstraintProto::ConstraintCase::kLinear:
270  APPLY_TO_REPEATED_FIELD(linear, vars);
271  break;
272  case ConstraintProto::ConstraintCase::kAllDiff:
273  APPLY_TO_REPEATED_FIELD(all_diff, vars);
274  break;
275  case ConstraintProto::ConstraintCase::kElement:
276  APPLY_TO_SINGULAR_FIELD(element, index);
277  APPLY_TO_SINGULAR_FIELD(element, target);
278  APPLY_TO_REPEATED_FIELD(element, vars);
279  break;
280  case ConstraintProto::ConstraintCase::kCircuit:
281  break;
282  case ConstraintProto::ConstraintCase::kRoutes:
283  break;
284  case ConstraintProto::ConstraintCase::kCircuitCovering:
285  APPLY_TO_REPEATED_FIELD(circuit_covering, nexts);
286  break;
287  case ConstraintProto::ConstraintCase::kInverse:
288  APPLY_TO_REPEATED_FIELD(inverse, f_direct);
289  APPLY_TO_REPEATED_FIELD(inverse, f_inverse);
290  break;
291  case ConstraintProto::ConstraintCase::kReservoir:
292  APPLY_TO_REPEATED_FIELD(reservoir, times);
293  break;
294  case ConstraintProto::ConstraintCase::kTable:
295  APPLY_TO_REPEATED_FIELD(table, vars);
296  break;
297  case ConstraintProto::ConstraintCase::kAutomaton:
298  APPLY_TO_REPEATED_FIELD(automaton, vars);
299  break;
300  case ConstraintProto::ConstraintCase::kInterval:
301  APPLY_TO_SINGULAR_FIELD(interval, start);
302  APPLY_TO_SINGULAR_FIELD(interval, end);
303  APPLY_TO_SINGULAR_FIELD(interval, size);
304  break;
305  case ConstraintProto::ConstraintCase::kNoOverlap:
306  break;
307  case ConstraintProto::ConstraintCase::kNoOverlap2D:
308  break;
309  case ConstraintProto::ConstraintCase::kCumulative:
310  APPLY_TO_SINGULAR_FIELD(cumulative, capacity);
311  APPLY_TO_REPEATED_FIELD(cumulative, demands);
312  break;
313  case ConstraintProto::ConstraintCase::CONSTRAINT_NOT_SET:
314  break;
315  }
316 }
317 
318 void ApplyToAllIntervalIndices(const std::function<void(int*)>& f,
319  ConstraintProto* ct) {
320  switch (ct->constraint_case()) {
321  case ConstraintProto::ConstraintCase::kBoolOr:
322  break;
323  case ConstraintProto::ConstraintCase::kBoolAnd:
324  break;
325  case ConstraintProto::ConstraintCase::kAtMostOne:
326  break;
327  case ConstraintProto::ConstraintCase::kBoolXor:
328  break;
329  case ConstraintProto::ConstraintCase::kIntDiv:
330  break;
331  case ConstraintProto::ConstraintCase::kIntMod:
332  break;
333  case ConstraintProto::ConstraintCase::kIntMax:
334  break;
335  case ConstraintProto::ConstraintCase::kLinMax:
336  break;
337  case ConstraintProto::ConstraintCase::kIntMin:
338  break;
339  case ConstraintProto::ConstraintCase::kLinMin:
340  break;
341  case ConstraintProto::ConstraintCase::kIntProd:
342  break;
343  case ConstraintProto::ConstraintCase::kLinear:
344  break;
345  case ConstraintProto::ConstraintCase::kAllDiff:
346  break;
347  case ConstraintProto::ConstraintCase::kElement:
348  break;
349  case ConstraintProto::ConstraintCase::kCircuit:
350  break;
351  case ConstraintProto::ConstraintCase::kRoutes:
352  break;
353  case ConstraintProto::ConstraintCase::kCircuitCovering:
354  break;
355  case ConstraintProto::ConstraintCase::kInverse:
356  break;
357  case ConstraintProto::ConstraintCase::kReservoir:
358  break;
359  case ConstraintProto::ConstraintCase::kTable:
360  break;
361  case ConstraintProto::ConstraintCase::kAutomaton:
362  break;
363  case ConstraintProto::ConstraintCase::kInterval:
364  break;
365  case ConstraintProto::ConstraintCase::kNoOverlap:
366  APPLY_TO_REPEATED_FIELD(no_overlap, intervals);
367  break;
368  case ConstraintProto::ConstraintCase::kNoOverlap2D:
369  APPLY_TO_REPEATED_FIELD(no_overlap_2d, x_intervals);
370  APPLY_TO_REPEATED_FIELD(no_overlap_2d, y_intervals);
371  break;
372  case ConstraintProto::ConstraintCase::kCumulative:
373  APPLY_TO_REPEATED_FIELD(cumulative, intervals);
374  break;
375  case ConstraintProto::ConstraintCase::CONSTRAINT_NOT_SET:
376  break;
377  }
378 }
379 
380 #undef APPLY_TO_SINGULAR_FIELD
381 #undef APPLY_TO_REPEATED_FIELD
382 
383 std::string ConstraintCaseName(
384  ConstraintProto::ConstraintCase constraint_case) {
385  switch (constraint_case) {
386  case ConstraintProto::ConstraintCase::kBoolOr:
387  return "kBoolOr";
388  case ConstraintProto::ConstraintCase::kBoolAnd:
389  return "kBoolAnd";
390  case ConstraintProto::ConstraintCase::kAtMostOne:
391  return "kAtMostOne";
392  case ConstraintProto::ConstraintCase::kBoolXor:
393  return "kBoolXor";
394  case ConstraintProto::ConstraintCase::kIntDiv:
395  return "kIntDiv";
396  case ConstraintProto::ConstraintCase::kIntMod:
397  return "kIntMod";
398  case ConstraintProto::ConstraintCase::kIntMax:
399  return "kIntMax";
400  case ConstraintProto::ConstraintCase::kLinMax:
401  return "kLinMax";
402  case ConstraintProto::ConstraintCase::kIntMin:
403  return "kIntMin";
404  case ConstraintProto::ConstraintCase::kLinMin:
405  return "kLinMin";
406  case ConstraintProto::ConstraintCase::kIntProd:
407  return "kIntProd";
408  case ConstraintProto::ConstraintCase::kLinear:
409  return "kLinear";
410  case ConstraintProto::ConstraintCase::kAllDiff:
411  return "kAllDiff";
412  case ConstraintProto::ConstraintCase::kElement:
413  return "kElement";
414  case ConstraintProto::ConstraintCase::kCircuit:
415  return "kCircuit";
416  case ConstraintProto::ConstraintCase::kRoutes:
417  return "kRoutes";
418  case ConstraintProto::ConstraintCase::kCircuitCovering:
419  return "kCircuitCovering";
420  case ConstraintProto::ConstraintCase::kInverse:
421  return "kInverse";
422  case ConstraintProto::ConstraintCase::kReservoir:
423  return "kReservoir";
424  case ConstraintProto::ConstraintCase::kTable:
425  return "kTable";
426  case ConstraintProto::ConstraintCase::kAutomaton:
427  return "kAutomaton";
428  case ConstraintProto::ConstraintCase::kInterval:
429  return "kInterval";
430  case ConstraintProto::ConstraintCase::kNoOverlap:
431  return "kNoOverlap";
432  case ConstraintProto::ConstraintCase::kNoOverlap2D:
433  return "kNoOverlap2D";
434  case ConstraintProto::ConstraintCase::kCumulative:
435  return "kCumulative";
436  case ConstraintProto::ConstraintCase::CONSTRAINT_NOT_SET:
437  return "kEmpty";
438  }
439 }
440 
441 std::vector<int> UsedVariables(const ConstraintProto& ct) {
442  IndexReferences references = GetReferencesUsedByConstraint(ct);
443  for (int& ref : references.variables) {
444  ref = PositiveRef(ref);
445  }
446  for (const int lit : references.literals) {
447  references.variables.push_back(PositiveRef(lit));
448  }
449  for (const int lit : ct.enforcement_literal()) {
450  references.variables.push_back(PositiveRef(lit));
451  }
452  gtl::STLSortAndRemoveDuplicates(&references.variables);
453  return references.variables;
454 }
455 
456 std::vector<int> UsedIntervals(const ConstraintProto& ct) {
457  std::vector<int> used_intervals;
458  switch (ct.constraint_case()) {
459  case ConstraintProto::ConstraintCase::kBoolOr:
460  break;
461  case ConstraintProto::ConstraintCase::kBoolAnd:
462  break;
463  case ConstraintProto::ConstraintCase::kAtMostOne:
464  break;
465  case ConstraintProto::ConstraintCase::kBoolXor:
466  break;
467  case ConstraintProto::ConstraintCase::kIntDiv:
468  break;
469  case ConstraintProto::ConstraintCase::kIntMod:
470  break;
471  case ConstraintProto::ConstraintCase::kIntMax:
472  break;
473  case ConstraintProto::ConstraintCase::kLinMax:
474  break;
475  case ConstraintProto::ConstraintCase::kIntMin:
476  break;
477  case ConstraintProto::ConstraintCase::kLinMin:
478  break;
479  case ConstraintProto::ConstraintCase::kIntProd:
480  break;
481  case ConstraintProto::ConstraintCase::kLinear:
482  break;
483  case ConstraintProto::ConstraintCase::kAllDiff:
484  break;
485  case ConstraintProto::ConstraintCase::kElement:
486  break;
487  case ConstraintProto::ConstraintCase::kCircuit:
488  break;
489  case ConstraintProto::ConstraintCase::kRoutes:
490  break;
491  case ConstraintProto::ConstraintCase::kCircuitCovering:
492  break;
493  case ConstraintProto::ConstraintCase::kInverse:
494  break;
495  case ConstraintProto::ConstraintCase::kReservoir:
496  break;
497  case ConstraintProto::ConstraintCase::kTable:
498  break;
499  case ConstraintProto::ConstraintCase::kAutomaton:
500  break;
501  case ConstraintProto::ConstraintCase::kInterval:
502  break;
503  case ConstraintProto::ConstraintCase::kNoOverlap:
504  AddIndices(ct.no_overlap().intervals(), &used_intervals);
505  break;
506  case ConstraintProto::ConstraintCase::kNoOverlap2D:
507  AddIndices(ct.no_overlap_2d().x_intervals(), &used_intervals);
508  AddIndices(ct.no_overlap_2d().y_intervals(), &used_intervals);
509  break;
510  case ConstraintProto::ConstraintCase::kCumulative:
511  AddIndices(ct.cumulative().intervals(), &used_intervals);
512  break;
513  case ConstraintProto::ConstraintCase::CONSTRAINT_NOT_SET:
514  break;
515  }
516  gtl::STLSortAndRemoveDuplicates(&used_intervals);
517  return used_intervals;
518 }
519 
520 int64 ComputeInnerObjective(const CpObjectiveProto& objective,
521  const CpSolverResponse& response) {
522  int64 objective_value = 0;
523  auto& repeated_field_values = response.solution().empty()
524  ? response.solution_lower_bounds()
525  : response.solution();
526  for (int i = 0; i < objective.vars_size(); ++i) {
527  int64 coeff = objective.coeffs(i);
528  const int ref = objective.vars(i);
529  const int var = PositiveRef(ref);
530  if (!RefIsPositive(ref)) coeff = -coeff;
531  objective_value += coeff * repeated_field_values[var];
532  }
533  return objective_value;
534 }
535 
536 } // namespace sat
537 } // namespace operations_research
var
IntVar * var
Definition: expr_array.cc:1858
operations_research::sat::ApplyToAllVariableIndices
void ApplyToAllVariableIndices(const std::function< void(int *)> &f, ConstraintProto *ct)
Definition: cp_model_utils.cc:226
response
SharedResponseManager * response
Definition: cp_model_solver.cc:2027
operations_research::sat::ApplyToAllLiteralIndices
void ApplyToAllLiteralIndices(const std::function< void(int *)> &f, ConstraintProto *ct)
Definition: cp_model_utils.cc:160
operations_research::sat::UsedVariables
std::vector< int > UsedVariables(const ConstraintProto &ct)
Definition: cp_model_utils.cc:441
operations_research
The vehicle routing library lets one model and solve generic vehicle routing problems ranging from th...
Definition: dense_doubly_linked_list.h:21
operations_research::sat::GetReferencesUsedByConstraint
IndexReferences GetReferencesUsedByConstraint(const ConstraintProto &ct)
Definition: cp_model_utils.cc:46
int64
int64_t int64
Definition: integral_types.h:34
operations_research::sat::IndexReferences::literals
std::vector< int > literals
Definition: cp_model_utils.h:54
index
int index
Definition: pack.cc:508
operations_research::sat::UsedIntervals
std::vector< int > UsedIntervals(const ConstraintProto &ct)
Definition: cp_model_utils.cc:456
operations_research::sat::IndexReferences::variables
std::vector< int > variables
Definition: cp_model_utils.h:53
operations_research::sat::PositiveRef
int PositiveRef(int ref)
Definition: cp_model_utils.h:33
operations_research::sat::IndexReferences
Definition: cp_model_utils.h:52
gtl::STLSortAndRemoveDuplicates
void STLSortAndRemoveDuplicates(T *v, const LessFunc &less_func)
Definition: stl_util.h:58
ct
const Constraint * ct
Definition: demon_profiler.cc:42
operations_research::sat::ComputeInnerObjective
int64 ComputeInnerObjective(const CpObjectiveProto &objective, const CpSolverResponse &response)
Definition: cp_model_utils.cc:520
operations_research::sat::NegatedRef
int NegatedRef(int ref)
Definition: cp_model_utils.h:32
operations_research::sat::RefIsPositive
bool RefIsPositive(int ref)
Definition: cp_model_utils.h:34
operations_research::sat::ApplyToAllIntervalIndices
void ApplyToAllIntervalIndices(const std::function< void(int *)> &f, ConstraintProto *ct)
Definition: cp_model_utils.cc:318
stl_util.h
APPLY_TO_REPEATED_FIELD
#define APPLY_TO_REPEATED_FIELD(ct_name, field_name)
Definition: cp_model_utils.cc:155
operations_research::sat::SetToNegatedLinearExpression
void SetToNegatedLinearExpression(const LinearExpressionProto &input_expr, LinearExpressionProto *output_negated_expr)
Definition: cp_model_utils.cc:36
APPLY_TO_SINGULAR_FIELD
#define APPLY_TO_SINGULAR_FIELD(ct_name, field_name)
Definition: cp_model_utils.cc:148
operations_research::sat::ConstraintCaseName
std::string ConstraintCaseName(ConstraintProto::ConstraintCase constraint_case)
Definition: cp_model_utils.cc:383
capacity
int64 capacity
Definition: routing_flow.cc:129
interval
IntervalVar * interval
Definition: resource.cc:98
cp_model_utils.h