internal LinearExpressionProto GetLinearExpressionProto(LinearExpr expr, bool negate = false)
{
var dict = var_value_map_;
dict.Clear();
long constant = LinearExpr.GetVarValueMap(expr, dict, terms_);
LinearExpressionProto linear = new LinearExpressionProto();
var dictCount = dict.Count;
linear.Vars.Capacity = dictCount;
linear.Vars.AddRange(dict.Keys);
linear.Coeffs.Capacity = dictCount;
if (negate)
{
foreach (var coeff in dict.Values)
{
linear.Coeffs.Add(-coeff);
}
linear.Offset = -constant;
}
else
{
linear.Coeffs.AddRange(dict.Values);
linear.Offset = constant;
}
return(linear);
}
public static LinearExpr RebuildLinearExprFromLinearExpressionProto(LinearExpressionProto proto,
CpModelProto model)
{
int numElements = proto.Vars.Count;
long offset = proto.Offset;
if (numElements == 0)
{
return(LinearExpr.Constant(offset));
}
else
if (numElements == 1)
{
IntVar var = new IntVar(model, proto.Vars[0]);
long coeff = proto.Coeffs[0];
return(LinearExpr.Affine(var, coeff, offset));
}
else
{
LinearExpr[] exprs = new LinearExpr[numElements];
for (int i = 0; i < numElements; ++i)
{
IntVar var = new IntVar(model, proto.Vars[i]);
long coeff = proto.Coeffs[i];
exprs[i] = Prod(var, coeff);
}
SumArray sum = new SumArray(exprs);
sum.Offset = sum.Offset + offset;
return(sum);
}
}
internal static LinearExpr RebuildLinearExprFromLinearExpressionProto(LinearExpressionProto proto,
CpModelProto model)
{
int numElements = proto.Vars.Count;
long offset = proto.Offset;
if (numElements == 0)
{
return(LinearExpr.Constant(offset));
}
else if (numElements == 1)
{
IntVar var = new IntVar(model, proto.Vars[0]);
long coeff = proto.Coeffs[0];
return(LinearExpr.Affine(var, coeff, offset));
}
else
{
LinearExprBuilder builder = LinearExpr.NewBuilder(numElements);
for (int i = 0; i < numElements; ++i)
{
builder.AddTerm(new IntVar(model, proto.Vars[i]), proto.Coeffs[i]);
}
builder.Add(offset);
return(builder);
}
}
public IntervalVar NewOptionalFixedSizeIntervalVar <S>(S start, long duration, ILiteral is_present, string name)
{
LinearExpr startExpr = GetLinearExpr(start);
LinearExpr durationExpr = GetLinearExpr(duration);
LinearExpr endExpr = LinearExpr.Sum(new LinearExpr[] { startExpr, durationExpr });
LinearExpressionProto startProto = GetLinearExpressionProto(startExpr);
LinearExpressionProto durationProto = GetLinearExpressionProto(durationExpr);
LinearExpressionProto endProto = GetLinearExpressionProto(endExpr);
return(new IntervalVar(model_, startProto, durationProto, endProto, is_present.GetIndex(), name));
}
/**
* <summary>
* Creates an interval variable from an affine expression start, and a fixed size.
* </summary>
*
* <remarks>An interval variable is a constraint, that is itself used in other constraints like
* NoOverlap.
* </remarks>
*
* <param name="start"> the start of the interval. It needs to be an affine or constant expression. *
* </param>
* <param name="size"> the fixed size of the interval </param>
* <param name="name"> the name of the interval variable </param>
* <returns> An IntervalVar object</returns>
*/
public IntervalVar NewFixedSizeIntervalVar <S>(S start, long size, string name)
{
LinearExpr startExpr = GetLinearExpr(start);
LinearExpr sizeExpr = GetLinearExpr(size);
LinearExpr endExpr = LinearExpr.Sum(new LinearExpr[] { startExpr, sizeExpr });
LinearExpressionProto startProto = GetLinearExpressionProto(startExpr);
LinearExpressionProto sizeProto = GetLinearExpressionProto(sizeExpr);
LinearExpressionProto endProto = GetLinearExpressionProto(endExpr);
return(new IntervalVar(model_, startProto, sizeProto, endProto, name));
}
public IntervalVar NewOptionalIntervalVar <S, D, E>(S start, D duration, E end, ILiteral is_present, string name)
{
LinearExpr startExpr = GetLinearExpr(start);
LinearExpr durationExpr = GetLinearExpr(duration);
LinearExpr endExpr = GetLinearExpr(end);
Add(startExpr + durationExpr == endExpr).OnlyEnforceIf(is_present);
LinearExpressionProto startProto = GetLinearExpressionProto(startExpr);
LinearExpressionProto durationProto = GetLinearExpressionProto(durationExpr);
LinearExpressionProto endProto = GetLinearExpressionProto(endExpr);
return(new IntervalVar(model_, startProto, durationProto, endProto, is_present.GetIndex(), name));
}
// Scheduling support
public IntervalVar NewIntervalVar <S, D, E>(S start, D duration, E end, string name)
{
LinearExpr startExpr = GetLinearExpr(start);
LinearExpr durationExpr = GetLinearExpr(duration);
LinearExpr endExpr = GetLinearExpr(end);
Add(startExpr + durationExpr == endExpr);
LinearExpressionProto startProto = GetLinearExpressionProto(startExpr);
LinearExpressionProto durationProto = GetLinearExpressionProto(durationExpr);
LinearExpressionProto endProto = GetLinearExpressionProto(endExpr);
return(new IntervalVar(model_, startProto, durationProto, endProto, name));
}
// Scheduling support
/**
* <summary>
* Creates an interval variable from three affine expressions start, size, and end.
* </summary>
*
* <remarks>An interval variable is a constraint, that is itself used in other constraints like
* NoOverlap. Internally, it ensures that <c>start + size == end</c>.
* </remarks>
*
* <param name="start"> the start of the interval. It needs to be an affine or constant expression. </param>
* <param name="size"> the size of the interval. It needs to be an affine or constant expression. </param>
* <param name="end"> the end of the interval. It needs to be an affine or constant expression. </param>
* <param name="name"> the name of the interval variable </param>
* <returns> An IntervalVar object</returns>
*/
public IntervalVar NewIntervalVar <S, D, E>(S start, D size, E end, string name)
{
LinearExpr startExpr = GetLinearExpr(start);
LinearExpr sizeExpr = GetLinearExpr(size);
LinearExpr endExpr = GetLinearExpr(end);
Add(startExpr + sizeExpr == endExpr);
LinearExpressionProto startProto = GetLinearExpressionProto(startExpr);
LinearExpressionProto sizeProto = GetLinearExpressionProto(sizeExpr);
LinearExpressionProto endProto = GetLinearExpressionProto(endExpr);
return(new IntervalVar(model_, startProto, sizeProto, endProto, name));
}
private LinearExpressionProto GetLinearExpressionProto(LinearExpr expr, bool negate = false)
{
Dictionary <IntVar, long> dict = new Dictionary <IntVar, long>();
long constant = LinearExpr.GetVarValueMap(expr, 1L, dict);
long mult = negate ? -1 : 1;
LinearExpressionProto linear = new LinearExpressionProto();
foreach (KeyValuePair <IntVar, long> term in dict)
{
linear.Vars.Add(term.Key.Index);
linear.Coeffs.Add(term.Value * mult);
}
linear.Offset = constant * mult;
return(linear);
}
public IntervalVar(CpModelProto model, LinearExpressionProto start, LinearExpressionProto size,
LinearExpressionProto end, string name)
{
model_ = model;
index_ = model.Constraints.Count;
interval_ = new IntervalConstraintProto();
interval_.Start = start;
interval_.Size = size;
interval_.End = end;
ConstraintProto ct = new ConstraintProto();
ct.Interval = interval_;
ct.Name = name;
model_.Constraints.Add(ct);
}
public IntervalVar(CpModelProto model, LinearExpressionProto start, LinearExpressionProto size,
LinearExpressionProto end, int is_present_index, string name)
{
model_ = model;
index_ = model.Constraints.Count;
interval_ = new IntervalConstraintProto();
interval_.StartView = start;
interval_.SizeView = size;
interval_.EndView = end;
ConstraintProto ct = new ConstraintProto();
ct.Interval = interval_;
ct.Name = name;
ct.EnforcementLiteral.Add(is_present_index);
model.Constraints.Add(ct);
}