public void AddMapDomain(IntVar var, IEnumerable <IntVar> bool_vars, long offset = 0)
{
int i = 0;
foreach (IntVar bool_var in bool_vars)
{
int b_index = bool_var.Index;
int var_index = var.Index;
ConstraintProto ct1 = new ConstraintProto();
LinearConstraintProto lin1 = new LinearConstraintProto();
lin1.Vars.Add(var_index);
lin1.Coeffs.Add(1L);
lin1.Domain.Add(offset + i);
lin1.Domain.Add(offset + i);
ct1.Linear = lin1;
ct1.EnforcementLiteral.Add(b_index);
model_.Constraints.Add(ct1);
ConstraintProto ct2 = new ConstraintProto();
LinearConstraintProto lin2 = new LinearConstraintProto();
lin2.Vars.Add(var_index);
lin2.Coeffs.Add(1L);
lin2.Domain.Add(Int64.MinValue);
lin2.Domain.Add(offset + i - 1);
lin2.Domain.Add(offset + i + 1);
lin2.Domain.Add(Int64.MaxValue);
ct2.Linear = lin2;
ct2.EnforcementLiteral.Add(-b_index - 1);
model_.Constraints.Add(ct2);
i++;
}
}
public Constraint AddLinearExpressionInDomain(LinearExpr linear_expr, Domain domain)
{
Dictionary <IntVar, long> dict = new Dictionary <IntVar, long>();
long constant = LinearExpr.GetVarValueMap(linear_expr, 1L, dict);
Constraint ct = new Constraint(model_);
LinearConstraintProto linear = new LinearConstraintProto();
foreach (KeyValuePair <IntVar, long> term in dict)
{
linear.Vars.Add(term.Key.Index);
linear.Coeffs.Add(term.Value);
}
foreach (long value in domain.FlattenedIntervals())
{
if (value == Int64.MinValue || value == Int64.MaxValue)
{
linear.Domain.Add(value);
}
else
{
linear.Domain.Add(value - constant);
}
}
ct.Proto.Linear = linear;
return(ct);
}
static ConstraintProto NewLinear2(int v1, int v2, long c1, long c2, long lb, long ub)
{
LinearConstraintProto linear = new LinearConstraintProto();
linear.Vars.Add(v1);
linear.Vars.Add(v2);
linear.Coeffs.Add(c1);
linear.Coeffs.Add(c2);
linear.Domain.Add(lb);
linear.Domain.Add(ub);
ConstraintProto ct = new ConstraintProto();
ct.Linear = linear;
return(ct);
}
private long FillLinearConstraint(LinearExpr expr, out LinearConstraintProto linear)
{
var dict = var_value_map_;
dict.Clear();
long constant = LinearExpr.GetVarValueMap(expr, dict, terms_);
var count = dict.Count;
linear = new LinearConstraintProto();
linear.Vars.Capacity = count;
linear.Vars.AddRange(dict.Keys);
linear.Coeffs.Capacity = count;
linear.Coeffs.AddRange(dict.Values);
return(constant);
}
public Constraint AddLinearConstraint(IEnumerable<Tuple<IntVar, long>> terms,
long lb, long ub)
{
Constraint ct = new Constraint(model_);
LinearConstraintProto lin = new LinearConstraintProto();
foreach (Tuple<IntVar, long> term in terms)
{
lin.Vars.Add(term.Item1.Index);
lin.Coeffs.Add(term.Item2);
}
lin.Domain.Add(lb);
lin.Domain.Add(ub);
ct.Proto.Linear = lin;
return ct;
}
public Constraint AddSumConstraint(IEnumerable<IntVar> vars, long lb,
long ub)
{
Constraint ct = new Constraint(model_);
LinearConstraintProto lin = new LinearConstraintProto();
foreach (IntVar var in vars)
{
lin.Vars.Add(var.Index);
lin.Coeffs.Add(1L);
}
lin.Domain.Add(lb);
lin.Domain.Add(ub);
ct.Proto.Linear = lin;
return ct;
}
private long FillLinearConstraint(LinearExpr expr, out LinearConstraintProto linear)
{
linear = new LinearConstraintProto();
Dictionary <IntVar, long> dict = new Dictionary <IntVar, long>();
long constant = LinearExpr.GetVarValueMap(expr, 1L, dict, terms_);
var count = dict.Count;
linear.Vars.Capacity = count;
linear.Coeffs.Capacity = count;
foreach (KeyValuePair <IntVar, long> term in dict)
{
linear.Vars.Add(term.Key.Index);
linear.Coeffs.Add(term.Value);
}
return(constant);
}
public Constraint AddLinearConstraintWithBounds(
IEnumerable<Tuple<IntVar, long>> terms, IEnumerable<long> bounds)
{
Constraint ct = new Constraint(model_);
LinearConstraintProto lin = new LinearConstraintProto();
foreach (Tuple<IntVar, long> term in terms)
{
lin.Vars.Add(term.Item1.Index);
lin.Coeffs.Add(term.Item2);
}
foreach (long b in bounds)
{
lin.Domain.Add(b);
}
ct.Proto.Linear = lin;
return ct;
}
public Constraint AddLinearConstraint(IEnumerable <IntVar> vars,
IEnumerable <long> coeffs,
long lb, long ub)
{
Constraint ct = new Constraint(model_);
LinearConstraintProto lin = new LinearConstraintProto();
foreach (IntVar var in vars)
{
lin.Vars.Add(var.Index);
}
foreach (long coeff in coeffs)
{
lin.Coeffs.Add(coeff);
}
lin.Domain.Add(lb);
lin.Domain.Add(ub);
ct.Proto.Linear = lin;
return(ct);
}
public Constraint AddLinearConstraintWithBounds(IEnumerable<IntVar> vars,
IEnumerable<int> coeffs,
IEnumerable<long> bounds)
{
Constraint ct = new Constraint(model_);
LinearConstraintProto lin = new LinearConstraintProto();
foreach (IntVar var in vars)
{
lin.Vars.Add(var.Index);
}
foreach (int coeff in coeffs)
{
lin.Coeffs.Add(coeff);
}
foreach (long b in bounds)
{
lin.Domain.Add(b);
}
ct.Proto.Linear = lin;
return ct;
}
public Constraint Add(BoundIntegerExpression lin)
{
switch (lin.CtType)
{
case BoundIntegerExpression.Type.BoundExpression:
{
Dictionary <IntVar, long> dict = new Dictionary <IntVar, long>();
long constant = IntegerExpression.GetVarValueMap(lin.Left, 1L, dict);
Constraint ct = new Constraint(model_);
LinearConstraintProto linear = new LinearConstraintProto();
foreach (KeyValuePair <IntVar, long> term in dict)
{
linear.Vars.Add(term.Key.Index);
linear.Coeffs.Add(term.Value);
}
linear.Domain.Add(lin.Lb == Int64.MinValue ? Int64.MinValue
: lin.Lb - constant);
linear.Domain.Add(lin.Ub == Int64.MaxValue ? Int64.MaxValue
: lin.Ub - constant);
ct.Proto.Linear = linear;
return(ct);
}
case BoundIntegerExpression.Type.VarEqVar:
{
Dictionary <IntVar, long> dict = new Dictionary <IntVar, long>();
long constant = IntegerExpression.GetVarValueMap(lin.Left, 1L, dict);
constant += IntegerExpression.GetVarValueMap(lin.Right, -1L, dict);
Constraint ct = new Constraint(model_);
LinearConstraintProto linear = new LinearConstraintProto();
foreach (KeyValuePair <IntVar, long> term in dict)
{
linear.Vars.Add(term.Key.Index);
linear.Coeffs.Add(term.Value);
}
linear.Domain.Add(-constant);
linear.Domain.Add(-constant);
ct.Proto.Linear = linear;
return(ct);
}
case BoundIntegerExpression.Type.VarDiffVar:
{
Dictionary <IntVar, long> dict = new Dictionary <IntVar, long>();
long constant = IntegerExpression.GetVarValueMap(lin.Left, 1L, dict);
constant += IntegerExpression.GetVarValueMap(lin.Right, -1L, dict);
Constraint ct = new Constraint(model_);
LinearConstraintProto linear = new LinearConstraintProto();
foreach (KeyValuePair <IntVar, long> term in dict)
{
linear.Vars.Add(term.Key.Index);
linear.Coeffs.Add(term.Value);
}
linear.Domain.Add(Int64.MinValue);
linear.Domain.Add(-constant - 1);
linear.Domain.Add(-constant + 1);
linear.Domain.Add(Int64.MaxValue);
ct.Proto.Linear = linear;
return(ct);
}
case BoundIntegerExpression.Type.VarEqCst:
{
Dictionary <IntVar, long> dict = new Dictionary <IntVar, long>();
long constant = IntegerExpression.GetVarValueMap(lin.Left, 1L, dict);
Constraint ct = new Constraint(model_);
LinearConstraintProto linear = new LinearConstraintProto();
foreach (KeyValuePair <IntVar, long> term in dict)
{
linear.Vars.Add(term.Key.Index);
linear.Coeffs.Add(term.Value);
}
linear.Domain.Add(lin.Lb - constant);
linear.Domain.Add(lin.Lb - constant);
ct.Proto.Linear = linear;
return(ct);
}
case BoundIntegerExpression.Type.VarDiffCst:
{
Dictionary <IntVar, long> dict = new Dictionary <IntVar, long>();
long constant = IntegerExpression.GetVarValueMap(lin.Left, 1L, dict);
Constraint ct = new Constraint(model_);
LinearConstraintProto linear = new LinearConstraintProto();
foreach (KeyValuePair <IntVar, long> term in dict)
{
linear.Vars.Add(term.Key.Index);
linear.Coeffs.Add(term.Value);
}
linear.Domain.Add(Int64.MinValue);
linear.Domain.Add(lin.Lb - constant - 1);
linear.Domain.Add(lin.Lb - constant + 1);
linear.Domain.Add(Int64.MaxValue);
ct.Proto.Linear = linear;
return(ct);
}
}
return(null);
}
