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