DotNet Reference

.Net Reference

CpModel.cs
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
14namespace Google.OrTools.Sat
15{
16 using System;
17 using System.Collections.Generic;
18 using Google.OrTools.Util;
19
23 public class CpModel
24 {
25 public CpModel()
26 {
27 model_ = new CpModelProto();
28 constant_map_ = new Dictionary<long, int>();
29 }
30
31 // Getters.
32
33 public CpModelProto Model
34 {
35 get {
36 return model_;
37 }
38 }
39
40 int Negated(int index)
41 {
42 return -index - 1;
43 }
44
45 // Integer variables and constraints.
46
47 public IntVar NewIntVar(long lb, long ub, string name)
48 {
49 return new IntVar(model_, new Domain(lb, ub), name);
50 }
51
52 public IntVar NewIntVarFromDomain(Domain domain, string name)
53 {
54 return new IntVar(model_, domain, name);
55 }
56 // Constants (named or not).
57
58 // TODO: Cache constant.
59 public IntVar NewConstant(long value)
60 {
61 return new IntVar(model_, new Domain(value), String.Format("{0}", value));
62 }
63
64 public IntVar NewConstant(long value, string name)
65 {
66 return new IntVar(model_, new Domain(value), name);
67 }
68
69 public IntVar NewBoolVar(string name)
70 {
71 return new IntVar(model_, new Domain(0, 1), name);
72 }
73
74 public Constraint AddLinearConstraint(LinearExpr linear_expr, long lb, long ub)
75 {
76 return AddLinearExpressionInDomain(linear_expr, new Domain(lb, ub));
77 }
78
79 public Constraint AddLinearExpressionInDomain(LinearExpr linear_expr, Domain domain)
80 {
81 Dictionary<IntVar, long> dict = new Dictionary<IntVar, long>();
82 long constant = LinearExpr.GetVarValueMap(linear_expr, 1L, dict);
83 Constraint ct = new Constraint(model_);
84 LinearConstraintProto linear = new LinearConstraintProto();
85 foreach (KeyValuePair<IntVar, long> term in dict)
86 {
87 linear.Vars.Add(term.Key.Index);
88 linear.Coeffs.Add(term.Value);
89 }
90 foreach (long value in domain.FlattenedIntervals())
91 {
92 if (value == Int64.MinValue || value == Int64.MaxValue)
93 {
94 linear.Domain.Add(value);
95 }
96 else
97 {
98 linear.Domain.Add(value - constant);
99 }
100 }
101 ct.Proto.Linear = linear;
102 return ct;
103 }
104
106 {
107 switch (lin.CtType)
108 {
109 case BoundedLinearExpression.Type.BoundExpression: {
110 return AddLinearExpressionInDomain(lin.Left, new Domain(lin.Lb, lin.Ub));
111 }
112 case BoundedLinearExpression.Type.VarEqVar: {
113 return AddLinearExpressionInDomain(lin.Left - lin.Right, new Domain(0));
114 }
115 case BoundedLinearExpression.Type.VarDiffVar: {
117 lin.Left - lin.Right,
118 Domain.FromFlatIntervals(new long[] { Int64.MinValue, -1, 1, Int64.MaxValue }));
119 }
120 case BoundedLinearExpression.Type.VarEqCst: {
121 return AddLinearExpressionInDomain(lin.Left, new Domain(lin.Lb, lin.Lb));
122 }
123 case BoundedLinearExpression.Type.VarDiffCst: {
125 lin.Left,
126 Domain.FromFlatIntervals(new long[] { Int64.MinValue, lin.Lb - 1, lin.Lb + 1, Int64.MaxValue }));
127 }
128 }
129 return null;
130 }
131
132 public Constraint AddAllDifferent(IEnumerable<IntVar> vars)
133 {
134 Constraint ct = new Constraint(model_);
135 AllDifferentConstraintProto alldiff = new AllDifferentConstraintProto();
136 foreach (IntVar var in vars)
137 {
138 alldiff.Vars.Add(var.Index);
139 }
140 ct.Proto.AllDiff = alldiff;
141 return ct;
142 }
143
144 public Constraint AddElement(IntVar index, IEnumerable<IntVar> vars, IntVar target)
145 {
146 Constraint ct = new Constraint(model_);
147 ElementConstraintProto element = new ElementConstraintProto();
148 element.Index = index.Index;
149 foreach (IntVar var in vars)
150 {
151 element.Vars.Add(var.Index);
152 }
153 element.Target = target.Index;
154 ct.Proto.Element = element;
155 return ct;
156 }
157
158 public Constraint AddElement(IntVar index, IEnumerable<long> values, IntVar target)
159 {
160 Constraint ct = new Constraint(model_);
161 ElementConstraintProto element = new ElementConstraintProto();
162 element.Index = index.Index;
163 foreach (long value in values)
164 {
165 element.Vars.Add(ConvertConstant(value));
166 }
167 element.Target = target.Index;
168 ct.Proto.Element = element;
169 return ct;
170 }
171
172 public Constraint AddElement(IntVar index, IEnumerable<int> values, IntVar target)
173 {
174 Constraint ct = new Constraint(model_);
175 ElementConstraintProto element = new ElementConstraintProto();
176 element.Index = index.Index;
177 foreach (int value in values)
178 {
179 element.Vars.Add(ConvertConstant(value));
180 }
181 element.Target = target.Index;
182 ct.Proto.Element = element;
183 return ct;
184 }
185
186 public Constraint AddCircuit(IEnumerable<Tuple<int, int, ILiteral>> arcs)
187 {
188 Constraint ct = new Constraint(model_);
189 CircuitConstraintProto circuit = new CircuitConstraintProto();
190 foreach (var arc in arcs)
191 {
192 circuit.Tails.Add(arc.Item1);
193 circuit.Heads.Add(arc.Item2);
194 circuit.Literals.Add(arc.Item3.GetIndex());
195 }
196 ct.Proto.Circuit = circuit;
197 return ct;
198 }
199
200 public Constraint AddAllowedAssignments(IEnumerable<IntVar> vars, long[,] tuples)
201 {
202 Constraint ct = new Constraint(model_);
203 TableConstraintProto table = new TableConstraintProto();
204 foreach (IntVar var in vars)
205 {
206 table.Vars.Add(var.Index);
207 }
208 for (int i = 0; i < tuples.GetLength(0); ++i)
209 {
210 for (int j = 0; j < tuples.GetLength(1); ++j)
211 {
212 table.Values.Add(tuples[i, j]);
213 }
214 }
215 ct.Proto.Table = table;
216 return ct;
217 }
218
219 public Constraint AddForbiddenAssignments(IEnumerable<IntVar> vars, long[,] tuples)
220 {
221 Constraint ct = AddAllowedAssignments(vars, tuples);
222 ct.Proto.Table.Negated = true;
223 return ct;
224 }
225
226 public Constraint AddAutomaton(IEnumerable<IntVar> vars, long starting_state, long[,] transitions,
227 IEnumerable<long> final_states)
228 {
229 Constraint ct = new Constraint(model_);
230 AutomatonConstraintProto aut = new AutomatonConstraintProto();
231 foreach (IntVar var in vars)
232 {
233 aut.Vars.Add(var.Index);
234 }
235 aut.StartingState = starting_state;
236 foreach (long f in final_states)
237 {
238 aut.FinalStates.Add(f);
239 }
240 for (int i = 0; i < transitions.GetLength(0); ++i)
241 {
242 aut.TransitionTail.Add(transitions[i, 0]);
243 aut.TransitionLabel.Add(transitions[i, 1]);
244 aut.TransitionHead.Add(transitions[i, 2]);
245 }
246
247 ct.Proto.Automaton = aut;
248 return ct;
249 }
250
251 public Constraint AddAutomaton(IEnumerable<IntVar> vars, long starting_state,
252 IEnumerable<Tuple<long, long, long>> transitions, IEnumerable<long> final_states)
253 {
254 Constraint ct = new Constraint(model_);
255 AutomatonConstraintProto aut = new AutomatonConstraintProto();
256 foreach (IntVar var in vars)
257 {
258 aut.Vars.Add(var.Index);
259 }
260 aut.StartingState = starting_state;
261 foreach (long f in final_states)
262 {
263 aut.FinalStates.Add(f);
264 }
265 foreach (Tuple<long, long, long> transition in transitions)
266 {
267 aut.TransitionHead.Add(transition.Item1);
268 aut.TransitionLabel.Add(transition.Item2);
269 aut.TransitionTail.Add(transition.Item3);
270 }
271
272 ct.Proto.Automaton = aut;
273 return ct;
274 }
275
276 public Constraint AddInverse(IEnumerable<IntVar> direct, IEnumerable<IntVar> reverse)
277 {
278 Constraint ct = new Constraint(model_);
279 InverseConstraintProto inverse = new InverseConstraintProto();
280 foreach (IntVar var in direct)
281 {
282 inverse.FDirect.Add(var.Index);
283 }
284 foreach (IntVar var in reverse)
285 {
286 inverse.FInverse.Add(var.Index);
287 }
288 ct.Proto.Inverse = inverse;
289 return ct;
290 }
291
292 public Constraint AddReservoirConstraint<I>(IEnumerable<IntVar> times, IEnumerable<I> demands, long min_level,
293 long max_level)
294 {
295 Constraint ct = new Constraint(model_);
296 ReservoirConstraintProto res = new ReservoirConstraintProto();
297 foreach (IntVar var in times)
298 {
299 res.Times.Add(var.Index);
300 }
301 foreach (I d in demands)
302 {
303 res.Demands.Add(Convert.ToInt64(d));
304 }
305
306 res.MinLevel = min_level;
307 res.MaxLevel = max_level;
308 ct.Proto.Reservoir = res;
309
310 return ct;
311 }
312
313 public Constraint AddReservoirConstraintWithActive<I>(IEnumerable<IntVar> times, IEnumerable<I> demands,
314 IEnumerable<IntVar> actives, long min_level,
315 long max_level)
316 {
317 Constraint ct = new Constraint(model_);
318 ReservoirConstraintProto res = new ReservoirConstraintProto();
319 foreach (IntVar var in times)
320 {
321 res.Times.Add(var.Index);
322 }
323 foreach (I d in demands)
324 {
325 res.Demands.Add(Convert.ToInt64(d));
326 }
327 foreach (IntVar var in actives)
328 {
329 res.Actives.Add(var.Index);
330 }
331 res.MinLevel = min_level;
332 res.MaxLevel = max_level;
333 ct.Proto.Reservoir = res;
334
335 return ct;
336 }
337
338 public void AddMapDomain(IntVar var, IEnumerable<IntVar> bool_vars, long offset = 0)
339 {
340 int i = 0;
341 foreach (IntVar bool_var in bool_vars)
342 {
343 int b_index = bool_var.Index;
344 int var_index = var.Index;
345
346 ConstraintProto ct1 = new ConstraintProto();
347 LinearConstraintProto lin1 = new LinearConstraintProto();
348 lin1.Vars.Add(var_index);
349 lin1.Coeffs.Add(1L);
350 lin1.Domain.Add(offset + i);
351 lin1.Domain.Add(offset + i);
352 ct1.Linear = lin1;
353 ct1.EnforcementLiteral.Add(b_index);
354 model_.Constraints.Add(ct1);
355
356 ConstraintProto ct2 = new ConstraintProto();
357 LinearConstraintProto lin2 = new LinearConstraintProto();
358 lin2.Vars.Add(var_index);
359 lin2.Coeffs.Add(1L);
360 lin2.Domain.Add(Int64.MinValue);
361 lin2.Domain.Add(offset + i - 1);
362 lin2.Domain.Add(offset + i + 1);
363 lin2.Domain.Add(Int64.MaxValue);
364 ct2.Linear = lin2;
365 ct2.EnforcementLiteral.Add(-b_index - 1);
366 model_.Constraints.Add(ct2);
367
368 i++;
369 }
370 }
371
373 {
374 Constraint ct = new Constraint(model_);
375 BoolArgumentProto or = new BoolArgumentProto();
376 or.Literals.Add(a.Not().GetIndex());
377 or.Literals.Add(b.GetIndex());
378 ct.Proto.BoolOr = or;
379 return ct;
380 }
381
382 public Constraint AddBoolOr(IEnumerable<ILiteral> literals)
383 {
384 Constraint ct = new Constraint(model_);
385 BoolArgumentProto bool_argument = new BoolArgumentProto();
386 foreach (ILiteral lit in literals)
387 {
388 bool_argument.Literals.Add(lit.GetIndex());
389 }
390 ct.Proto.BoolOr = bool_argument;
391 return ct;
392 }
393
394 public Constraint AddBoolAnd(IEnumerable<ILiteral> literals)
395 {
396 Constraint ct = new Constraint(model_);
397 BoolArgumentProto bool_argument = new BoolArgumentProto();
398 foreach (ILiteral lit in literals)
399 {
400 bool_argument.Literals.Add(lit.GetIndex());
401 }
402 ct.Proto.BoolAnd = bool_argument;
403 return ct;
404 }
405
406 public Constraint AddBoolXor(IEnumerable<ILiteral> literals)
407 {
408 Constraint ct = new Constraint(model_);
409 BoolArgumentProto bool_argument = new BoolArgumentProto();
410 foreach (ILiteral lit in literals)
411 {
412 bool_argument.Literals.Add(lit.GetIndex());
413 }
414 ct.Proto.BoolXor = bool_argument;
415 return ct;
416 }
417
418 public Constraint AddMinEquality(IntVar target, IEnumerable<IntVar> vars)
419 {
420 Constraint ct = new Constraint(model_);
421 IntegerArgumentProto args = new IntegerArgumentProto();
422 foreach (IntVar var in vars)
423 {
424 args.Vars.Add(var.Index);
425 }
426 args.Target = target.Index;
427 ct.Proto.IntMin = args;
428 return ct;
429 }
430
431 public Constraint AddMaxEquality(IntVar target, IEnumerable<IntVar> vars)
432 {
433 Constraint ct = new Constraint(model_);
434 IntegerArgumentProto args = new IntegerArgumentProto();
435 foreach (IntVar var in vars)
436 {
437 args.Vars.Add(var.Index);
438 }
439 args.Target = target.Index;
440 ct.Proto.IntMax = args;
441 return ct;
442 }
443
444 public Constraint AddDivisionEquality<T, N, D>(T target, N num, D denom)
445 {
446 Constraint ct = new Constraint(model_);
447 IntegerArgumentProto args = new IntegerArgumentProto();
448 args.Vars.Add(GetOrCreateIndex(num));
449 args.Vars.Add(GetOrCreateIndex(denom));
450 args.Target = GetOrCreateIndex(target);
451 ct.Proto.IntDiv = args;
452 return ct;
453 }
454
456 {
457 Constraint ct = new Constraint(model_);
458 IntegerArgumentProto args = new IntegerArgumentProto();
459 args.Vars.Add(var.Index);
460 args.Vars.Add(-var.Index - 1);
461 args.Target = target.Index;
462 ct.Proto.IntMax = args;
463 return ct;
464 }
465
466 public Constraint AddModuloEquality<T, V, M>(T target, V v, M m)
467 {
468 Constraint ct = new Constraint(model_);
469 IntegerArgumentProto args = new IntegerArgumentProto();
470 args.Vars.Add(GetOrCreateIndex(v));
471 args.Vars.Add(GetOrCreateIndex(m));
472 args.Target = GetOrCreateIndex(target);
473 ct.Proto.IntMod = args;
474 return ct;
475 }
476
477 public Constraint AddMultiplicationEquality(IntVar target, IEnumerable<IntVar> vars)
478 {
479 Constraint ct = new Constraint(model_);
480 IntegerArgumentProto args = new IntegerArgumentProto();
481 args.Target = target.Index;
482 foreach (IntVar var in vars)
483 {
484 args.Vars.Add(var.Index);
485 }
486 ct.Proto.IntProd = args;
487 return ct;
488 }
489
490 public Constraint AddProdEquality(IntVar target, IEnumerable<IntVar> vars)
491 {
492 return AddMultiplicationEquality(target, vars);
493 }
494
495 // Scheduling support
496
497 public IntervalVar NewIntervalVar<S, D, E>(S start, D duration, E end, string name)
498 {
499 return new IntervalVar(model_, GetOrCreateIndex(start), GetOrCreateIndex(duration), GetOrCreateIndex(end),
500 name);
501 }
502
503 public IntervalVar NewOptionalIntervalVar<S, D, E>(S start, D duration, E end, ILiteral is_present, string name)
504 {
505 int i = is_present.GetIndex();
506 return new IntervalVar(model_, GetOrCreateIndex(start), GetOrCreateIndex(duration), GetOrCreateIndex(end),
507 i, name);
508 }
509
510 public Constraint AddNoOverlap(IEnumerable<IntervalVar> intervals)
511 {
512 Constraint ct = new Constraint(model_);
513 NoOverlapConstraintProto args = new NoOverlapConstraintProto();
514 foreach (IntervalVar var in intervals)
515 {
516 args.Intervals.Add(var.GetIndex());
517 }
518 ct.Proto.NoOverlap = args;
519 return ct;
520 }
521
522 public Constraint AddNoOverlap2D(IEnumerable<IntervalVar> x_intervals, IEnumerable<IntervalVar> y_intervals)
523 {
524 Constraint ct = new Constraint(model_);
525 NoOverlap2DConstraintProto args = new NoOverlap2DConstraintProto();
526 foreach (IntervalVar var in x_intervals)
527 {
528 args.XIntervals.Add(var.GetIndex());
529 }
530 foreach (IntervalVar var in y_intervals)
531 {
532 args.YIntervals.Add(var.GetIndex());
533 }
534 ct.Proto.NoOverlap2D = args;
535 return ct;
536 }
537
538 public Constraint AddCumulative<D, C>(IEnumerable<IntervalVar> intervals, IEnumerable<D> demands, C capacity)
539 {
540 Constraint ct = new Constraint(model_);
541 CumulativeConstraintProto cumul = new CumulativeConstraintProto();
542 foreach (IntervalVar var in intervals)
543 {
544 cumul.Intervals.Add(var.GetIndex());
545 }
546 foreach (D demand in demands)
547 {
548 cumul.Demands.Add(GetOrCreateIndex(demand));
549 }
550 cumul.Capacity = GetOrCreateIndex(capacity);
551 ct.Proto.Cumulative = cumul;
552 return ct;
553 }
554
555 // Objective.
556 public void Minimize(LinearExpr obj)
557 {
558 SetObjective(obj, true);
559 }
560
561 public void Maximize(LinearExpr obj)
562 {
563 SetObjective(obj, false);
564 }
565
566 public void Minimize()
567 {
568 SetObjective(null, true);
569 }
570
571 public void Maximize()
572 {
573 SetObjective(null, false);
574 }
575
576 public void AddVarToObjective(IntVar var)
577 {
578 if ((Object)var == null)
579 return;
580 model_.Objective.Vars.Add(var.Index);
581 model_.Objective.Coeffs.Add(model_.Objective.ScalingFactor > 0 ? 1 : -1);
582 }
583
584 public void AddTermToObjective(IntVar var, long coeff)
585 {
586 if (coeff == 0 || (Object)var == null)
587 return;
588 model_.Objective.Vars.Add(var.Index);
589 model_.Objective.Coeffs.Add(model_.Objective.ScalingFactor > 0 ? coeff : -coeff);
590 }
591
592 bool HasObjective()
593 {
594 return model_.Objective == null;
595 }
596
597 // Search Decision.
598
599 public void AddDecisionStrategy(IEnumerable<IntVar> vars,
600 DecisionStrategyProto.Types.VariableSelectionStrategy var_str,
601 DecisionStrategyProto.Types.DomainReductionStrategy dom_str)
602 {
603 DecisionStrategyProto ds = new DecisionStrategyProto();
604 foreach (IntVar var in vars)
605 {
606 ds.Variables.Add(var.Index);
607 }
608 ds.VariableSelectionStrategy = var_str;
609 ds.DomainReductionStrategy = dom_str;
610 model_.SearchStrategy.Add(ds);
611 }
612
613 public void AddHint(IntVar var, long value)
614 {
615 if (model_.SolutionHint == null)
616 {
617 model_.SolutionHint = new PartialVariableAssignment();
618 }
619 model_.SolutionHint.Vars.Add(var.GetIndex());
620 model_.SolutionHint.Values.Add(value);
621 }
622
623 public void ClearHints()
624 {
625 model_.SolutionHint = null;
626 }
627
628 public void AddAssumption(ILiteral lit)
629 {
630 model_.Assumptions.Add(lit.GetIndex());
631 }
632
633 public void AddAssumptions(IEnumerable<ILiteral> literals)
634 {
635 foreach (ILiteral lit in literals)
636 {
637 AddAssumption(lit);
638 }
639 }
640
641 public void ClearAssumptions()
642 {
643 model_.Assumptions.Clear();
644 }
645
646 // Internal methods.
647
648 void SetObjective(LinearExpr obj, bool minimize)
649 {
650 CpObjectiveProto objective = new CpObjectiveProto();
651 if (obj == null)
652 {
653 objective.Offset = 0L;
654 objective.ScalingFactor = minimize ? 1L : -1;
655 }
656 else if (obj is IntVar)
657 {
658 objective.Offset = 0L;
659 objective.Vars.Add(obj.Index);
660 if (minimize)
661 {
662 objective.Coeffs.Add(1L);
663 objective.ScalingFactor = 1L;
664 }
665 else
666 {
667 objective.Coeffs.Add(-1L);
668 objective.ScalingFactor = -1L;
669 }
670 }
671 else
672 {
673 Dictionary<IntVar, long> dict = new Dictionary<IntVar, long>();
674 long constant = LinearExpr.GetVarValueMap(obj, 1L, dict);
675 if (minimize)
676 {
677 objective.ScalingFactor = 1L;
678 objective.Offset = constant;
679 }
680 else
681 {
682 objective.ScalingFactor = -1L;
683 objective.Offset = -constant;
684 }
685 foreach (KeyValuePair<IntVar, long> it in dict)
686 {
687 objective.Vars.Add(it.Key.Index);
688 objective.Coeffs.Add(minimize ? it.Value : -it.Value);
689 }
690 }
691 model_.Objective = objective;
692 }
693
694 public String ModelStats()
695 {
696 return SatHelper.ModelStats(model_);
697 }
698
699 public Boolean ExportToFile(String filename)
700 {
701 return SatHelper.WriteModelToFile(model_, filename);
702 }
703
704 public String Validate()
705 {
706 return SatHelper.ValidateModel(model_);
707 }
708
709 private int ConvertConstant(long value)
710 {
711 if (constant_map_.ContainsKey(value))
712 {
713 return constant_map_[value];
714 }
715 else
716 {
717 int index = model_.Variables.Count;
718 IntegerVariableProto var = new IntegerVariableProto();
719 var.Domain.Add(value);
720 var.Domain.Add(value);
721 constant_map_.Add(value, index);
722 model_.Variables.Add(var);
723 return index;
724 }
725 }
726
727 private int GetOrCreateIndex<X>(X x)
728 {
729 if (typeof(X) == typeof(IntVar))
730 {
731 IntVar vx = (IntVar)(Object)x;
732 return vx.Index;
733 }
734 if (typeof(X) == typeof(long) || typeof(X) == typeof(int))
735 {
736 return ConvertConstant(Convert.ToInt64(x));
737 }
738 throw new ArgumentException("Cannot extract index from argument");
739 }
740
741 private CpModelProto model_;
742 private Dictionary<long, int> constant_map_;
743 }
744
745} // namespace Google.OrTools.Sat
using System
Definition: Program.cs:14
Wrapper class around the cp_model proto.
Definition: CpModel.cs:24
void AddAssumption(ILiteral lit)
Definition: CpModel.cs:628
Constraint AddInverse(IEnumerable< IntVar > direct, IEnumerable< IntVar > reverse)
Definition: CpModel.cs:276
Constraint AddReservoirConstraintWithActive< I >(IEnumerable< IntVar > times, IEnumerable< I > demands, IEnumerable< IntVar > actives, long min_level, long max_level)
Definition: CpModel.cs:313
void Minimize(LinearExpr obj)
Definition: CpModel.cs:556
Constraint AddBoolXor(IEnumerable< ILiteral > literals)
Definition: CpModel.cs:406
void AddMapDomain(IntVar var, IEnumerable< IntVar > bool_vars, long offset=0)
Definition: CpModel.cs:338
IntVar NewBoolVar(string name)
Definition: CpModel.cs:69
Constraint AddAbsEquality(IntVar target, IntVar var)
Definition: CpModel.cs:455
void AddDecisionStrategy(IEnumerable< IntVar > vars, DecisionStrategyProto.Types.VariableSelectionStrategy var_str, DecisionStrategyProto.Types.DomainReductionStrategy dom_str)
Definition: CpModel.cs:599
Constraint AddDivisionEquality< T, N, D >(T target, N num, D denom)
Definition: CpModel.cs:444
Constraint AddLinearExpressionInDomain(LinearExpr linear_expr, Domain domain)
Definition: CpModel.cs:79
Constraint AddNoOverlap(IEnumerable< IntervalVar > intervals)
Definition: CpModel.cs:510
Constraint AddReservoirConstraint< I >(IEnumerable< IntVar > times, IEnumerable< I > demands, long min_level, long max_level)
Definition: CpModel.cs:292
Constraint AddProdEquality(IntVar target, IEnumerable< IntVar > vars)
Definition: CpModel.cs:490
IntVar NewConstant(long value)
Definition: CpModel.cs:59
Constraint AddLinearConstraint(LinearExpr linear_expr, long lb, long ub)
Definition: CpModel.cs:74
void AddHint(IntVar var, long value)
Definition: CpModel.cs:613
Constraint AddElement(IntVar index, IEnumerable< IntVar > vars, IntVar target)
Definition: CpModel.cs:144
Boolean ExportToFile(String filename)
Definition: CpModel.cs:699
void AddVarToObjective(IntVar var)
Definition: CpModel.cs:576
void Maximize(LinearExpr obj)
Definition: CpModel.cs:561
Constraint AddImplication(ILiteral a, ILiteral b)
Definition: CpModel.cs:372
IntVar NewIntVar(long lb, long ub, string name)
Definition: CpModel.cs:47
Constraint AddBoolAnd(IEnumerable< ILiteral > literals)
Definition: CpModel.cs:394
Constraint AddBoolOr(IEnumerable< ILiteral > literals)
Definition: CpModel.cs:382
Constraint AddModuloEquality< T, V, M >(T target, V v, M m)
Definition: CpModel.cs:466
Constraint AddElement(IntVar index, IEnumerable< long > values, IntVar target)
Definition: CpModel.cs:158
Constraint AddForbiddenAssignments(IEnumerable< IntVar > vars, long[,] tuples)
Definition: CpModel.cs:219
IntVar NewConstant(long value, string name)
Definition: CpModel.cs:64
Constraint AddAllDifferent(IEnumerable< IntVar > vars)
Definition: CpModel.cs:132
Constraint AddMultiplicationEquality(IntVar target, IEnumerable< IntVar > vars)
Definition: CpModel.cs:477
IntVar NewIntVarFromDomain(Domain domain, string name)
Definition: CpModel.cs:52
Constraint AddNoOverlap2D(IEnumerable< IntervalVar > x_intervals, IEnumerable< IntervalVar > y_intervals)
Definition: CpModel.cs:522
Constraint AddAllowedAssignments(IEnumerable< IntVar > vars, long[,] tuples)
Definition: CpModel.cs:200
Constraint AddMaxEquality(IntVar target, IEnumerable< IntVar > vars)
Definition: CpModel.cs:431
IntervalVar NewOptionalIntervalVar< S, D, E >(S start, D duration, E end, ILiteral is_present, string name)
Definition: CpModel.cs:503
Constraint AddElement(IntVar index, IEnumerable< int > values, IntVar target)
Definition: CpModel.cs:172
Constraint AddCumulative< D, C >(IEnumerable< IntervalVar > intervals, IEnumerable< D > demands, C capacity)
Definition: CpModel.cs:538
CpModelProto Model
Definition: CpModel.cs:34
void AddTermToObjective(IntVar var, long coeff)
Definition: CpModel.cs:584
Constraint AddAutomaton(IEnumerable< IntVar > vars, long starting_state, IEnumerable< Tuple< long, long, long > > transitions, IEnumerable< long > final_states)
Definition: CpModel.cs:251
Constraint Add(BoundedLinearExpression lin)
Definition: CpModel.cs:105
Constraint AddMinEquality(IntVar target, IEnumerable< IntVar > vars)
Definition: CpModel.cs:418
Constraint AddAutomaton(IEnumerable< IntVar > vars, long starting_state, long[,] transitions, IEnumerable< long > final_states)
Definition: CpModel.cs:226
Constraint AddCircuit(IEnumerable< Tuple< int, int, ILiteral > > arcs)
Definition: CpModel.cs:186
void AddAssumptions(IEnumerable< ILiteral > literals)
Definition: CpModel.cs:633
IntervalVar NewIntervalVar< S, D, E >(S start, D duration, E end, string name)
Definition: CpModel.cs:497
static long GetVarValueMap(LinearExpr e, long initial_coeff, Dictionary< IntVar, long > dict)