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 
14 namespace 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 AddAutomaton(IEnumerable< IntVar > vars, long starting_state, IEnumerable< Tuple< long, long, long >> transitions, IEnumerable< long > final_states)
Definition: CpModel.cs:251
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
Constraint AddCircuit(IEnumerable< Tuple< int, int, ILiteral >> arcs)
Definition: CpModel.cs:186
void AddTermToObjective(IntVar var, long coeff)
Definition: CpModel.cs:584
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
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)