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 
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 
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_);
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_);
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_);
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_);
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_);
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_);
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_);
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_);
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_);
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_);
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_);
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_);
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();
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();
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_);
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_);
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_);
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_);
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_);
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_);
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 AddProdEquality(IntVar target, IEnumerable<IntVar> vars)
478  {
479  Constraint ct = new Constraint(model_);
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  // Scheduling support
491 
492  public IntervalVar NewIntervalVar<S, D, E>(S start, D duration, E end, string name)
493  {
494  return new IntervalVar(model_, GetOrCreateIndex(start), GetOrCreateIndex(duration), GetOrCreateIndex(end),
495  name);
496  }
497 
498  public IntervalVar NewOptionalIntervalVar<S, D, E>(S start, D duration, E end, ILiteral is_present, string name)
499  {
500  int i = is_present.GetIndex();
501  return new IntervalVar(model_, GetOrCreateIndex(start), GetOrCreateIndex(duration), GetOrCreateIndex(end),
502  i, name);
503  }
504 
505  public Constraint AddNoOverlap(IEnumerable<IntervalVar> intervals)
506  {
507  Constraint ct = new Constraint(model_);
509  foreach (IntervalVar var in intervals)
510  {
511  args.Intervals.Add(var.GetIndex());
512  }
513  ct.Proto.NoOverlap = args;
514  return ct;
515  }
516 
517  public Constraint AddNoOverlap2D(IEnumerable<IntervalVar> x_intervals, IEnumerable<IntervalVar> y_intervals)
518  {
519  Constraint ct = new Constraint(model_);
521  foreach (IntervalVar var in x_intervals)
522  {
523  args.XIntervals.Add(var.GetIndex());
524  }
525  foreach (IntervalVar var in y_intervals)
526  {
527  args.YIntervals.Add(var.GetIndex());
528  }
529  ct.Proto.NoOverlap2D = args;
530  return ct;
531  }
532 
533  public Constraint AddCumulative<D, C>(IEnumerable<IntervalVar> intervals, IEnumerable<D> demands, C capacity)
534  {
535  Constraint ct = new Constraint(model_);
537  foreach (IntervalVar var in intervals)
538  {
539  cumul.Intervals.Add(var.GetIndex());
540  }
541  foreach (D demand in demands)
542  {
543  cumul.Demands.Add(GetOrCreateIndex(demand));
544  }
545  cumul.Capacity = GetOrCreateIndex(capacity);
546  ct.Proto.Cumulative = cumul;
547  return ct;
548  }
549 
550  // Objective.
551  public void Minimize(LinearExpr obj)
552  {
553  SetObjective(obj, true);
554  }
555 
556  public void Maximize(LinearExpr obj)
557  {
558  SetObjective(obj, false);
559  }
560 
561  public void Minimize()
562  {
563  SetObjective(null, true);
564  }
565 
566  public void Maximize()
567  {
568  SetObjective(null, false);
569  }
570 
571  public void AddVarToObjective(IntVar var)
572  {
573  if ((Object)var == null)
574  return;
575  model_.Objective.Vars.Add(var.Index);
576  model_.Objective.Coeffs.Add(model_.Objective.ScalingFactor > 0 ? 1 : -1);
577  }
578 
579  public void AddTermToObjective(IntVar var, long coeff)
580  {
581  if (coeff == 0 || (Object)var == null)
582  return;
583  model_.Objective.Vars.Add(var.Index);
584  model_.Objective.Coeffs.Add(model_.Objective.ScalingFactor > 0 ? coeff : -coeff);
585  }
586 
587  bool HasObjective()
588  {
589  return model_.Objective == null;
590  }
591 
592  // Search Decision.
593 
594  public void AddDecisionStrategy(IEnumerable<IntVar> vars,
597  {
599  foreach (IntVar var in vars)
600  {
601  ds.Variables.Add(var.Index);
602  }
603  ds.VariableSelectionStrategy = var_str;
604  ds.DomainReductionStrategy = dom_str;
605  model_.SearchStrategy.Add(ds);
606  }
607 
608  public void AddHint(IntVar var, long value)
609  {
610  if (model_.SolutionHint == null)
611  {
613  }
614  model_.SolutionHint.Vars.Add(var.GetIndex());
615  model_.SolutionHint.Values.Add(value);
616  }
617 
618  // Internal methods.
619 
620  void SetObjective(LinearExpr obj, bool minimize)
621  {
622  CpObjectiveProto objective = new CpObjectiveProto();
623  if (obj == null)
624  {
625  objective.Offset = 0L;
626  objective.ScalingFactor = minimize ? 1L : -1;
627  }
628  else if (obj is IntVar)
629  {
630  objective.Offset = 0L;
631  objective.Vars.Add(obj.Index);
632  if (minimize)
633  {
634  objective.Coeffs.Add(1L);
635  objective.ScalingFactor = 1L;
636  }
637  else
638  {
639  objective.Coeffs.Add(-1L);
640  objective.ScalingFactor = -1L;
641  }
642  }
643  else
644  {
645  Dictionary<IntVar, long> dict = new Dictionary<IntVar, long>();
646  long constant = LinearExpr.GetVarValueMap(obj, 1L, dict);
647  if (minimize)
648  {
649  objective.ScalingFactor = 1L;
650  objective.Offset = constant;
651  }
652  else
653  {
654  objective.ScalingFactor = -1L;
655  objective.Offset = -constant;
656  }
657  foreach (KeyValuePair<IntVar, long> it in dict)
658  {
659  objective.Vars.Add(it.Key.Index);
660  objective.Coeffs.Add(minimize ? it.Value : -it.Value);
661  }
662  }
663  model_.Objective = objective;
664  }
665 
666  public String ModelStats()
667  {
668  return SatHelper.ModelStats(model_);
669  }
670 
671  public Boolean ExportToFile(String filename)
672  {
673  return SatHelper.WriteModelToFile(model_, filename);
674  }
675 
676  public String Validate()
677  {
678  return SatHelper.ValidateModel(model_);
679  }
680 
681  private int ConvertConstant(long value)
682  {
683  if (constant_map_.ContainsKey(value))
684  {
685  return constant_map_[value];
686  }
687  else
688  {
689  int index = model_.Variables.Count;
690  IntegerVariableProto var = new IntegerVariableProto();
691  var.Domain.Add(value);
692  var.Domain.Add(value);
693  constant_map_.Add(value, index);
694  model_.Variables.Add(var);
695  return index;
696  }
697  }
698 
699  private int GetOrCreateIndex<X>(X x)
700  {
701  if (typeof(X) == typeof(IntVar))
702  {
703  IntVar vx = (IntVar)(Object)x;
704  return vx.Index;
705  }
706  if (typeof(X) == typeof(long) || typeof(X) == typeof(int))
707  {
708  return ConvertConstant(Convert.ToInt64(x));
709  }
710  throw new ArgumentException("Cannot extract index from argument");
711  }
712 
713  private CpModelProto model_;
714  private Dictionary<long, int> constant_map_;
715  }
716 
717 } // namespace Google.OrTools.Sat
Container for nested types declared in the DecisionStrategyProto message type.
Definition: CpModel.pb.cs:6558
Argument of the constraints of the form target_var = OP(vars).
Definition: CpModel.pb.cs:634
Wrapper class around the cp_model proto.
Definition: CpModel.cs:24
The linear sum vars[i] * coeffs[i] must fall in the given domain.
Definition: CpModel.pb.cs:1439
Constraint AddBoolXor(IEnumerable< ILiteral > literals)
Definition: CpModel.cs:406
global::Google.OrTools.Sat.PartialVariableAssignment SolutionHint
Solution hint.
Definition: CpModel.pb.cs:7174
static long GetVarValueMap(LinearExpr e, long initial_coeff, Dictionary< IntVar, long > dict)
ConstraintProto Proto
Definition: Constraints.cs:49
pbc::RepeatedField< int > Vars
The linear terms of the objective to minimize.
Definition: CpModel.pb.cs:6033
Constraint AddMinEquality(IntVar target, IEnumerable< IntVar > vars)
Definition: CpModel.cs:418
pbc::RepeatedField< int > EnforcementLiteral
The constraint will be enforced iff all literals listed here are true.
Definition: CpModel.pb.cs:4530
Definition: Domain.cs:17
Constraint AddAllowedAssignments(IEnumerable< IntVar > vars, long[,] tuples)
Definition: CpModel.cs:200
Constraint AddDivisionEquality< T, N, D >(T target, N num, D denom)
Definition: CpModel.cs:444
CpModelProto Model
Definition: CpModel.cs:34
static Domain FromFlatIntervals(long[] flat_intervals)
Definition: Domain.cs:79
void Minimize(LinearExpr obj)
Definition: CpModel.cs:551
override int GetIndex()
All the intervals (index of IntervalConstraintProto) must be disjoint.
Definition: CpModel.pb.cs:2153
Constraint AddMaxEquality(IntVar target, IEnumerable< IntVar > vars)
Definition: CpModel.cs:431
void AddDecisionStrategy(IEnumerable< IntVar > vars, DecisionStrategyProto.Types.VariableSelectionStrategy var_str, DecisionStrategyProto.Types.DomainReductionStrategy dom_str)
Definition: CpModel.cs:594
global::Google.OrTools.Sat.LinearConstraintProto?? Linear
The linear constraint enforces a linear inequality among the variables, such as 0 <= x + 2y <= 10.
Definition: CpModel.pb.cs:4714
CpModel()
Definition: CpModel.cs:25
bool Negated
If true, the meaning is "negated", that is we forbid any of the given tuple from a feasible assignmen...
Definition: CpModel.pb.cs:3696
IntVar NewConstant(long value)
Definition: CpModel.cs:59
Optimization objective.
Definition: CpModel.pb.cs:5984
Constraint AddImplication(ILiteral a, ILiteral b)
Definition: CpModel.cs:372
int GetIndex()
Maintain a reservoir level within bounds.
Definition: CpModel.pb.cs:2799
VariableSelectionStrategy
The order in which the variables above should be considered.
Definition: CpModel.pb.cs:6565
String ModelStats()
Definition: CpModel.cs:666
Constraint AddNoOverlap(IEnumerable< IntervalVar > intervals)
Definition: CpModel.cs:505
Constraint AddBoolAnd(IEnumerable< ILiteral > literals)
Definition: CpModel.cs:394
Type
The sum of the demands of the intervals at each interval point cannot exceed a capacity.
Definition: CpModel.pb.cs:2554
Definition: SatHelper.cs:15
double ScalingFactor
Definition: CpModel.pb.cs:6071
ILiteral Not()
static string ValidateModel(Google.OrTools.Sat.CpModelProto model_proto)
Definition: SatHelper.cs:119
pbc::RepeatedField< int > Vars
Definition: CpModel.pb.cs:1481
Constraint AddInverse(IEnumerable< IntVar > direct, IEnumerable< IntVar > reverse)
Definition: CpModel.cs:276
int Target
Definition: CpModel.pb.cs:673
pbc::RepeatedField< int > Vars
Definition: CpModel.pb.cs:6892
Constraint AddBoolOr(IEnumerable< ILiteral > literals)
Definition: CpModel.cs:382
Constraint AddElement(IntVar index, IEnumerable< IntVar > vars, IntVar target)
Definition: CpModel.cs:144
Constraint AddLinearConstraint(LinearExpr linear_expr, long lb, long ub)
Definition: CpModel.cs:74
using System
Definition: Program.cs:14
The constraint target = vars[index].
Definition: CpModel.pb.cs:1663
The boxes defined by [start_x, end_x) * [start_y, end_y) cannot overlap.
Definition: CpModel.pb.cs:2319
IntVar NewConstant(long value, string name)
Definition: CpModel.cs:64
void AddTermToObjective(IntVar var, long coeff)
Definition: CpModel.cs:579
A constraint programming problem.
Definition: CpModel.pb.cs:7044
void Maximize()
Definition: CpModel.cs:566
IntVar NewIntVar(long lb, long ub, string name)
Definition: CpModel.cs:47
pbc::RepeatedField< int > Vars
Definition: CpModel.pb.cs:686
Constraint Add(BoundedLinearExpression lin)
Definition: CpModel.cs:105
global::Google.OrTools.Sat.TableConstraintProto?? Table
The table constraint enforces what values a tuple of variables may take.
Definition: CpModel.pb.cs:4787
Argument of the constraints of the form OP(literals).
Definition: CpModel.pb.cs:468
int Index
The values of the n-tuple formed by the given variables can only be one of the listed n-tuples in val...
Definition: CpModel.pb.cs:3632
long Lb
Constraint AddForbiddenAssignments(IEnumerable< IntVar > vars, long[,] tuples)
Definition: CpModel.cs:219
pbc::RepeatedField< global::Google.OrTools.Sat.IntegerVariableProto > Variables
The associated Protos should be referred by their index in these fields.
Definition: CpModel.pb.cs:7107
This constraint forces a sequence of variables to be accepted by an automaton.
Definition: CpModel.pb.cs:4060
global::Google.OrTools.Sat.IntegerArgumentProto?? IntMax
The int_max constraint forces the target to equal the maximum of all variables.
Definition: CpModel.pb.cs:4640
pbc::RepeatedField< global::Google.OrTools.Sat.DecisionStrategyProto > SearchStrategy
Defines the strategy that the solver should follow when the search_branching parameter is set to FIXE...
Definition: CpModel.pb.cs:7153
Constraint AddElement(IntVar index, IEnumerable< int > values, IntVar target)
Definition: CpModel.cs:172
Constraint AddElement(IntVar index, IEnumerable< long > values, IntVar target)
Definition: CpModel.cs:158
int Index
Definition: CpModel.pb.cs:1703
long Ub
Constraint AddCircuit(IEnumerable< Tuple< int, int, ILiteral >> arcs)
Definition: CpModel.cs:186
global::Google.OrTools.Sat.IntegerArgumentProto?? IntMod
The int_mod constraint forces the target to equal vars[0] % vars[1].
Definition: CpModel.pb.cs:4620
global::Google.OrTools.Sat.CpObjectiveProto Objective
The objective to minimize.
Definition: CpModel.pb.cs:7128
void Minimize()
Definition: CpModel.cs:561
Constraint AddLinearExpressionInDomain(LinearExpr linear_expr, Domain domain)
Definition: CpModel.cs:79
Constraint AddAbsEquality(IntVar target, IntVar var)
Definition: CpModel.cs:455
LinearExpr Left
Constraint AddCumulative< D, C >(IEnumerable< IntervalVar > intervals, IEnumerable< D > demands, C capacity)
Definition: CpModel.cs:533
IntervalVar NewIntervalVar< S, D, E >(S start, D duration, E end, string name)
Definition: CpModel.cs:492
pbc::RepeatedField< int > Literals
Definition: CpModel.pb.cs:508
IntervalVar NewOptionalIntervalVar< S, D, E >(S start, D duration, E end, ILiteral is_present, string name)
Definition: CpModel.cs:498
static string ModelStats(Google.OrTools.Sat.CpModelProto model_proto)
Definition: SatHelper.cs:109
void AddHint(IntVar var, long value)
Definition: CpModel.cs:608
void AddVarToObjective(IntVar var)
Definition: CpModel.cs:571
IntVar NewIntVarFromDomain(Domain domain, string name)
Definition: CpModel.cs:52
DomainReductionStrategy
Once a variable has been chosen, this enum describe what decision is taken on its domain.
Definition: CpModel.pb.cs:6579
Constraint AddAllDifferent(IEnumerable< IntVar > vars)
Definition: CpModel.cs:132
Constraint AddModuloEquality< T, V, M >(T target, V v, M m)
Definition: CpModel.cs:466
Next id: 29
Definition: CpModel.pb.cs:4384
Constraint AddAutomaton(IEnumerable< IntVar > vars, long starting_state, IEnumerable< Tuple< long, long, long >> transitions, IEnumerable< long > final_states)
Definition: CpModel.cs:251
The circuit constraint is defined on a graph where the arc presence are controlled by literals.
Definition: CpModel.pb.cs:3108
void AddMapDomain(IntVar var, IEnumerable< IntVar > bool_vars, long offset=0)
Definition: CpModel.cs:338
Type CtType
Constraint AddReservoirConstraintWithActive< I >(IEnumerable< IntVar > times, IEnumerable< I > demands, IEnumerable< IntVar > actives, long min_level, long max_level)
Definition: CpModel.cs:313
pbc::RepeatedField< global::Google.OrTools.Sat.ConstraintProto > Constraints
Definition: CpModel.pb.cs:7117
global::Google.OrTools.Sat.BoolArgumentProto?? BoolOr
The bool_or constraint forces at least one literal to be true.
Definition: CpModel.pb.cs:4540
The two arrays of variable each represent a function, the second is the inverse of the first: f_direc...
Definition: CpModel.pb.cs:3866
LinearExpr Right
Constraint AddProdEquality(IntVar target, IEnumerable< IntVar > vars)
Definition: CpModel.cs:477
Definition: Domain.cs:11
void Maximize(LinearExpr obj)
Definition: CpModel.cs:556
IntVar NewBoolVar(string name)
Definition: CpModel.cs:69
Constraint AddReservoirConstraint< I >(IEnumerable< IntVar > times, IEnumerable< I > demands, long min_level, long max_level)
Definition: CpModel.cs:292
pbc::RepeatedField< long > Domain
Definition: CpModel.pb.cs:1504
pbc::RepeatedField< long > Values
Definition: CpModel.pb.cs:6902
Boolean ExportToFile(String filename)
Definition: CpModel.cs:671
int Index
String Validate()
Definition: CpModel.cs:676
int GetIndex()
Define the strategy to follow when the solver needs to take a new decision.
Definition: CpModel.pb.cs:6296
Constraint AddAutomaton(IEnumerable< IntVar > vars, long starting_state, long[,] transitions, IEnumerable< long > final_states)
Definition: CpModel.cs:226
static bool WriteModelToFile(Google.OrTools.Sat.CpModelProto model_proto, string filename)
Definition: SatHelper.cs:129
This message encodes a partial (or full) assignment of the variables of a CpModelProto.
Definition: CpModel.pb.cs:6851
pbc::RepeatedField< long > Coeffs
Definition: CpModel.pb.cs:6043
Definition: Constraints.cs:20
All variables must take different values.
Definition: CpModel.pb.cs:1268
pbc::RepeatedField< long > Coeffs
Same size as vars.
Definition: CpModel.pb.cs:1494
Constraint AddNoOverlap2D(IEnumerable< IntervalVar > x_intervals, IEnumerable< IntervalVar > y_intervals)
Definition: CpModel.cs:517
global::Google.OrTools.Sat.IntegerArgumentProto?? IntDiv
The int_div constraint forces the target to equal vars[0] / vars[1].
Definition: CpModel.pb.cs:4605
double Offset
The displayed objective is always: scaling_factor * (sum(coefficients[i] * objective_vars[i]) + offse...
Definition: CpModel.pb.cs:6060
Definition: CpModel.pb.cs:12