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
22namespace operations_research {
23namespace sat {
24
25namespace {
26
27template <typename IntList>
28void AddIndices(const IntList& indices, std::vector<int>* output) {
29 output->insert(output->end(), indices.begin(), indices.end());
30}
31
32} // namespace
33
34void 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
44IndexReferences 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
176void 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
245void 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
357void 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
424std::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
484std::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
499std::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
565int64_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::ConstraintProto
Definition: cp_model.pb.h:3942
operations_research::sat::ConstraintProto::ConstraintCase
ConstraintCase
Definition: cp_model.pb.h:3984
operations_research::sat::CpObjectiveProto
Definition: cp_model.pb.h:4702
operations_research::sat::CpObjectiveProto::coeffs
::PROTOBUF_NAMESPACE_ID::int64 coeffs(int index) const
Definition: cp_model.pb.h:11411
operations_research::sat::CpObjectiveProto::vars_size
int vars_size() const
Definition: cp_model.pb.h:11355
operations_research::sat::CpObjectiveProto::vars
::PROTOBUF_NAMESPACE_ID::int32 vars(int index) const
Definition: cp_model.pb.h:11364
operations_research::sat::CpSolverResponse
Definition: cp_model.pb.h:6377
operations_research::sat::LinearExpressionProto
Definition: cp_model.pb.h:767
operations_research::sat::LinearExpressionProto::coeffs
::PROTOBUF_NAMESPACE_ID::int64 coeffs(int index) const
Definition: cp_model.pb.h:7113
operations_research::sat::LinearExpressionProto::offset
::PROTOBUF_NAMESPACE_ID::int64 offset() const
Definition: cp_model.pb.h:7154
operations_research::sat::LinearExpressionProto::vars_size
int vars_size() const
Definition: cp_model.pb.h:7057
operations_research::sat::LinearExpressionProto::set_offset
void set_offset(::PROTOBUF_NAMESPACE_ID::int64 value)
Definition: cp_model.pb.h:7162
operations_research::sat::LinearExpressionProto::add_coeffs
void add_coeffs(::PROTOBUF_NAMESPACE_ID::int64 value)
Definition: cp_model.pb.h:7124
operations_research::sat::LinearExpressionProto::Clear
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final
Definition: cp_model.pb.cc:1827
operations_research::sat::LinearExpressionProto::vars
::PROTOBUF_NAMESPACE_ID::int32 vars(int index) const
Definition: cp_model.pb.h:7066
operations_research::sat::LinearExpressionProto::add_vars
void add_vars(::PROTOBUF_NAMESPACE_ID::int32 value)
Definition: cp_model.pb.h:7077
cp_model.pb.h
response
SharedResponseManager * response
Definition: cp_model_solver.cc:2015
APPLY_TO_SINGULAR_FIELD
#define APPLY_TO_SINGULAR_FIELD(ct_name, field_name)
Definition: cp_model_utils.cc:164
APPLY_TO_REPEATED_FIELD
#define APPLY_TO_REPEATED_FIELD(ct_name, field_name)
Definition: cp_model_utils.cc:171
cp_model_utils.h
ct
const Constraint * ct
Definition: demon_profiler.cc:43
var
IntVar * var
Definition: expr_array.cc:1874
gtl::STLSortAndRemoveDuplicates
void STLSortAndRemoveDuplicates(T *v, const LessFunc &less_func)
Definition: stl_util.h:58
operations_research::sat::ComputeInnerObjective
int64_t ComputeInnerObjective(const CpObjectiveProto &objective, const CpSolverResponse &response)
Definition: cp_model_utils.cc:565
operations_research::sat::UsedVariables
std::vector< int > UsedVariables(const ConstraintProto &ct)
Definition: cp_model_utils.cc:484
operations_research::sat::RefIsPositive
bool RefIsPositive(int ref)
Definition: cp_model_utils.h:36
operations_research::sat::UsedIntervals
std::vector< int > UsedIntervals(const ConstraintProto &ct)
Definition: cp_model_utils.cc:499
operations_research::sat::SetToNegatedLinearExpression
void SetToNegatedLinearExpression(const LinearExpressionProto &input_expr, LinearExpressionProto *output_negated_expr)
Definition: cp_model_utils.cc:34
operations_research::sat::ApplyToAllLiteralIndices
void ApplyToAllLiteralIndices(const std::function< void(int *)> &f, ConstraintProto *ct)
Definition: cp_model_utils.cc:176
operations_research::sat::ApplyToAllIntervalIndices
void ApplyToAllIntervalIndices(const std::function< void(int *)> &f, ConstraintProto *ct)
Definition: cp_model_utils.cc:357
operations_research::sat::ApplyToAllVariableIndices
void ApplyToAllVariableIndices(const std::function< void(int *)> &f, ConstraintProto *ct)
Definition: cp_model_utils.cc:245
operations_research::sat::GetReferencesUsedByConstraint
IndexReferences GetReferencesUsedByConstraint(const ConstraintProto &ct)
Definition: cp_model_utils.cc:44
operations_research::sat::PositiveRef
int PositiveRef(int ref)
Definition: cp_model_utils.h:35
operations_research::sat::ConstraintCaseName
std::string ConstraintCaseName(ConstraintProto::ConstraintCase constraint_case)
Definition: cp_model_utils.cc:424
operations_research::sat::NegatedRef
int NegatedRef(int ref)
Definition: cp_model_utils.h:34
operations_research
Collection of objects used to extend the Constraint Solver library.
Definition: dense_doubly_linked_list.h:21
index
int index
Definition: pack.cc:509
interval
IntervalVar * interval
Definition: resource.cc:100
capacity
int64_t capacity
Definition: routing_flow.cc:151
stl_util.h
operations_research::sat::IndexReferences
Definition: cp_model_utils.h:54
operations_research::sat::IndexReferences::variables
std::vector< int > variables
Definition: cp_model_utils.h:55
operations_research::sat::IndexReferences::literals
std::vector< int > literals
Definition: cp_model_utils.h:56