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