public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
if (arguments.All(a => a.IsConstant()))
{
var constantResult = (int) arguments[0].ConstantValue.Value%(int) arguments[1].ConstantValue.Value;
return milpManager.FromConstant((int)constantResult);
}
IVariable numerator = arguments[0];
IVariable denominator = arguments[1];
var one = milpManager.FromConstant(1);
var any = milpManager.CreateAnonymous(Domain.PositiveOrZeroInteger);
any.Operation(OperationType.Multiplication, denominator).Set(ConstraintType.LessOrEqual, numerator);
any.Operation(OperationType.Addition, one)
.Operation(OperationType.Multiplication, denominator)
.Set(ConstraintType.GreaterOrEqual, numerator.Operation(OperationType.Addition, one));
IVariable result = milpManager.CreateAnonymous(Domain.PositiveOrZeroInteger);
result.Set(ConstraintType.LessOrEqual, denominator);
result.Set(ConstraintType.Equal,
numerator.Operation(OperationType.Subtraction,
denominator.Operation(OperationType.Multiplication, any)));
result.ConstantValue = numerator.ConstantValue%denominator.ConstantValue;
result.Expression = $"{numerator.FullExpression()} % {denominator.FullExpression()}";
return result;
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
}
if (arguments.All(a => a.IsConstant()))
{
var constantResult = (int)arguments[0].ConstantValue.Value % (int)arguments[1].ConstantValue.Value;
return(milpManager.FromConstant((int)constantResult));
}
IVariable numerator = arguments[0];
IVariable denominator = arguments[1];
var one = milpManager.FromConstant(1);
var any = milpManager.CreateAnonymous(Domain.PositiveOrZeroInteger);
any.Operation(OperationType.Multiplication, denominator).Set(ConstraintType.LessOrEqual, numerator);
any.Operation(OperationType.Addition, one)
.Operation(OperationType.Multiplication, denominator)
.Set(ConstraintType.GreaterOrEqual, numerator.Operation(OperationType.Addition, one));
IVariable result = milpManager.CreateAnonymous(Domain.PositiveOrZeroInteger);
result.Set(ConstraintType.LessOrEqual, denominator);
result.Set(ConstraintType.Equal,
numerator.Operation(OperationType.Subtraction,
denominator.Operation(OperationType.Multiplication, any)));
result.ConstantValue = numerator.ConstantValue % denominator.ConstantValue;
result.Expression = $"{numerator.FullExpression()} % {denominator.FullExpression()}";
return(result);
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if(!SupportsOperation(type,arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
if (arguments.All(x => x.IsConstant()))
{
if (arguments[0].IsInteger())
{
return milpManager.FromConstant(Math.Abs((int)arguments[0].ConstantValue.Value));
}
return milpManager.FromConstant(Math.Abs(arguments[0].ConstantValue.Value));
}
var number = arguments[0];
var numberNegated = number.Operation(OperationType.Negation);
var result = milpManager.CreateAnonymous(number.IsInteger() ? Domain.PositiveOrZeroInteger : Domain.PositiveOrZeroReal);
result.Set(ConstraintType.GreaterOrEqual, number)
.Set(ConstraintType.GreaterOrEqual, numberNegated);
milpManager.Operation(OperationType.Addition,
result.Operation(OperationType.IsEqual, number),
result.Operation(OperationType.IsEqual, numberNegated))
.Set(ConstraintType.GreaterOrEqual, milpManager.FromConstant(1));
result.ConstantValue = number.ConstantValue.HasValue ? Math.Abs(number.ConstantValue.Value) : number.ConstantValue;
result.Expression = $"|{number.FullExpression()}|";
return result;
}
public IEnumerable<IVariable> Calculate(IMilpManager milpManager, CompositeOperationType type, ICompositeOperationParameters parameters,
params IVariable[] arguments)
{
if (!SupportsOperation(type, parameters, arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, parameters, arguments));
var typedParameters = (ArrayGetParameters) parameters;
if (typedParameters.Index.IsConstant())
{
return new[] { arguments[(int) typedParameters.Index.ConstantValue.Value] };
}
var index = typedParameters.Index;
var result = milpManager.CreateAnonymous(arguments.Skip(1)
.Aggregate(arguments[0].Domain, (domain, next) => domain.LowestEncompassingDomain(next.Domain)));
for (int i = 0; i < arguments.Length; ++i)
{
milpManager.FromConstant(i).Operation(OperationType.IsEqual, index)
.Operation(OperationType.MaterialImplication, result.Operation(OperationType.IsEqual, arguments[i]))
.MakeTrue();
}
result.ConstantValue = index.ConstantValue.HasValue ? arguments[(int)index.ConstantValue.Value].ConstantValue : null;
result.Expression = $"arrayGet(index: {index.FullExpression()}, {string.Join(", ", arguments.Select(a => a.FullExpression()).ToArray())})";
return new[] {result};
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
}
if (arguments.All(x => x.IsConstant()))
{
if (arguments[0].IsInteger())
{
return(milpManager.FromConstant(Math.Abs((int)arguments[0].ConstantValue.Value)));
}
return(milpManager.FromConstant(Math.Abs(arguments[0].ConstantValue.Value)));
}
var number = arguments[0];
var numberNegated = number.Operation(OperationType.Negation);
var result = milpManager.CreateAnonymous(number.IsInteger() ? Domain.PositiveOrZeroInteger : Domain.PositiveOrZeroReal);
result.Set(ConstraintType.GreaterOrEqual, number)
.Set(ConstraintType.GreaterOrEqual, numberNegated);
milpManager.Operation(OperationType.Addition,
result.Operation(OperationType.IsEqual, number),
result.Operation(OperationType.IsEqual, numberNegated))
.Set(ConstraintType.GreaterOrEqual, milpManager.FromConstant(1));
result.ConstantValue = number.ConstantValue.HasValue ? Math.Abs(number.ConstantValue.Value) : number.ConstantValue;
result.Expression = $"|{number.FullExpression()}|";
return(result);
}
public IEnumerable <IVariable> Calculate(IMilpManager milpManager, CompositeOperationType type, ICompositeOperationParameters parameters,
params IVariable[] arguments)
{
if (!SupportsOperation(type, parameters, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, parameters, arguments));
}
var typedParameters = parameters as ApproximateParameters;
var x = arguments.First();
if (arguments.All(i => i.IsConstant()))
{
return(new [] { milpManager.FromConstant(typedParameters.Function(x.ConstantValue.Value)) });
}
var one = milpManager.FromConstant(1);
var points = typedParameters.Arguments.Select(a => Tuple.Create(milpManager.FromConstant(a), milpManager.FromConstant(typedParameters.Function(a)))).ToArray();
var variables = points.Select(p => milpManager.CreateAnonymous(typedParameters.ArgumentMustBeOnAGrid ? Domain.BinaryInteger : Domain.PositiveOrZeroReal).Set(ConstraintType.LessOrEqual, one)).ToArray();
x.Set(ConstraintType.Equal, milpManager.Operation(OperationType.Addition, points.Select((point, index) => variables[index].Operation(OperationType.Multiplication, point.Item1)).ToArray()));
var y = milpManager.Operation(OperationType.Addition, points.Select((point, index) => variables[index].Operation(OperationType.Multiplication, point.Item2)).ToArray());
milpManager.Operation(OperationType.Addition, variables).Set(ConstraintType.Equal, one);
milpManager.Set(CompositeConstraintType.SpecialOrderedSetType2, variables.First(), variables.Skip(1).ToArray());
y.ConstantValue = x.IsConstant() ? typedParameters.Function(x.ConstantValue.Value) : (double?)null;
y.Expression = $"approximation({typedParameters.FunctionDescription})";
return(new[] { y });
}
private static IEnumerable <IVariable> CalculateForVariable(IMilpManager milpManager, IVariable[] arguments, uint decompositionBase)
{
List <Tuple <IVariable, int> > variables =
Enumerable.Range(0, GetDigitsCount(milpManager, decompositionBase))
.Select(i =>
{
var baseRaised = (int)Math.Pow(decompositionBase, i);
var variable = milpManager.CreateAnonymous(decompositionBase == 2 ? Domain.BinaryInteger : Domain.PositiveOrZeroInteger);
if (decompositionBase > 2)
{
variable = variable.Set(ConstraintType.LessOrEqual, milpManager.FromConstant((int)decompositionBase - 1));
}
return(Tuple.Create(variable, baseRaised));
})
.ToList();
milpManager.Operation(OperationType.Addition,
variables.Select(v => v.Item1.Operation(OperationType.Multiplication, milpManager.FromConstant(v.Item2)))
.ToArray()).Set(ConstraintType.Equal, arguments[0]);
return(variables.Select((v, index) => {
var result = v.Item1;
result.Expression = $"decomposition(digit: {index}, base: {decompositionBase}, {arguments[0].FullExpression()})";
return result;
}));
}
public IEnumerable <IVariable> Calculate(IMilpManager milpManager, CompositeOperationType type, ICompositeOperationParameters parameters,
params IVariable[] arguments)
{
if (!SupportsOperation(type, parameters, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, parameters, arguments));
}
var typedParameters = (ArrayGetParameters)parameters;
if (typedParameters.Index.IsConstant())
{
return(new[] { arguments[(int)typedParameters.Index.ConstantValue.Value] });
}
var index = typedParameters.Index;
var result = milpManager.CreateAnonymous(arguments.Skip(1)
.Aggregate(arguments[0].Domain, (domain, next) => domain.LowestEncompassingDomain(next.Domain)));
for (int i = 0; i < arguments.Length; ++i)
{
milpManager.FromConstant(i).Operation(OperationType.IsEqual, index)
.Operation(OperationType.MaterialImplication, result.Operation(OperationType.IsEqual, arguments[i]))
.MakeTrue();
}
result.ConstantValue = index.ConstantValue.HasValue ? arguments[(int)index.ConstantValue.Value].ConstantValue : null;
result.Expression = $"arrayGet(index: {index.FullExpression()}, {string.Join(", ", arguments.Select(a => a.FullExpression()).ToArray())})";
return(new[] { result });
}
public IVariable Set(IMilpManager milpManager, CompositeConstraintType type, ICompositeConstraintParameters parameters,
IVariable leftVariable, params IVariable[] rightVariable)
{
var maximumIntegerValue = milpManager.FromConstant(milpManager.MaximumIntegerValue);
var one = milpManager.FromConstant(1);
var allVariables = new[] { leftVariable }.Concat(rightVariable).ToArray();
var boundaryVariables = allVariables.Select(v => milpManager.CreateAnonymous(Domain.BinaryInteger)).ToArray();
milpManager.Operation(OperationType.Addition, boundaryVariables).Set(ConstraintType.LessOrEqual, one);
for (int i = 0; i < allVariables.Length; ++i)
{
IVariable sum = boundaryVariables[i];
if (i < allVariables.Length - 1)
{
sum = sum.Operation(OperationType.Addition, boundaryVariables[i + 1]);
}
allVariables[i]
.Set(ConstraintType.LessOrEqual, sum.Operation(OperationType.Multiplication, maximumIntegerValue))
.Set(ConstraintType.GreaterOrEqual, sum.Operation(OperationType.Multiplication, maximumIntegerValue).Operation(OperationType.Negation));
}
return(leftVariable);
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
}
if (arguments.All(a => a.IsConstant()))
{
return(milpManager.FromConstant(arguments[0].ConstantValue.Value > arguments[1].ConstantValue.Value ? 1 : 0));
}
var result = milpManager.CreateAnonymous(Domain.BinaryInteger);
var first = arguments[0];
var second = arguments[1];
second.Operation(OperationType.Subtraction, first)
.Operation(OperationType.Addition,
result.Operation(OperationType.Multiplication, milpManager.FromConstant(milpManager.IntegerInfinity)))
.Set(ConstraintType.GreaterOrEqual, milpManager.FromConstant(0))
.Set(ConstraintType.LessOrEqual, milpManager.FromConstant(milpManager.IntegerInfinity - (arguments.Any(a => a.IsReal()) ? milpManager.Epsilon : 1)));
result.ConstantValue = arguments.All(a => a.ConstantValue.HasValue)
? arguments[0].ConstantValue > arguments[1].ConstantValue ? 1 : 0
: (double?)null;
result.Expression = $"{arguments[0].FullExpression()} ?> {arguments[1].FullExpression()}";
return(result);
}
private static IEnumerable<IVariable> CalculateForVariable(IMilpManager milpManager, IVariable[] arguments, uint decompositionBase)
{
List<Tuple<IVariable, int>> variables =
Enumerable.Range(0, GetDigitsCount(milpManager, decompositionBase))
.Select(i =>
{
var baseRaised = (int)Math.Pow(decompositionBase, i);
var variable = milpManager.CreateAnonymous(decompositionBase == 2 ? Domain.BinaryInteger : Domain.PositiveOrZeroInteger);
if (decompositionBase > 2)
{
variable = variable.Set(ConstraintType.LessOrEqual,milpManager.FromConstant((int) decompositionBase - 1));
}
return Tuple.Create(variable, baseRaised);
})
.ToList();
milpManager.Operation(OperationType.Addition,
variables.Select(v => v.Item1.Operation(OperationType.Multiplication, milpManager.FromConstant(v.Item2)))
.ToArray()).Set(ConstraintType.Equal, arguments[0]);
return variables.Select((v, index) => {
var result = v.Item1;
result.Expression = $"decomposition(digit: {index}, base: {decompositionBase}, {arguments[0].FullExpression()})";
return result;
});
}
public IVariable Set(IMilpManager milpManager, ConstraintType type, IVariable leftVariable, IVariable rightVariable)
{
IVariable any = milpManager.CreateAnonymous(Domain.AnyInteger);
leftVariable.Set(ConstraintType.Equal,any.Operation(OperationType.Multiplication, rightVariable));
return leftVariable;
}
public IVariable Set(IMilpManager milpManager, ConstraintType type, IVariable leftVariable, IVariable rightVariable)
{
IVariable any = milpManager.CreateAnonymous(Domain.AnyInteger);
leftVariable.Set(ConstraintType.Equal, any.Operation(OperationType.Multiplication, rightVariable));
return(leftVariable);
}
private static IVariable CalculateInternal(IMilpManager milpManager, params IVariable[] arguments)
{
var a = arguments[0];
var b = arguments[1];
var gcd = milpManager.CreateAnonymous(Domain.PositiveOrZeroInteger);
var x = milpManager.CreateAnonymous(Domain.PositiveOrZeroInteger);
var y = milpManager.CreateAnonymous(Domain.PositiveOrZeroInteger);
var m = milpManager.CreateAnonymous(Domain.AnyInteger);
var n = milpManager.CreateAnonymous(Domain.AnyInteger);
gcd.Set(ConstraintType.GreaterOrEqual, milpManager.FromConstant(1));
a.Set(ConstraintType.Equal, x.Operation(OperationType.Multiplication, gcd));
b.Set(ConstraintType.Equal, y.Operation(OperationType.Multiplication, gcd));
gcd.Set(ConstraintType.Equal, m.Operation(OperationType.Multiplication, a).Operation(OperationType.Addition, n.Operation(OperationType.Multiplication, b)));
gcd.ConstantValue = a.ConstantValue.HasValue && b.ConstantValue.HasValue
? Gcd((int) a.ConstantValue.Value, (int) b.ConstantValue.Value)
: (double?) null;
gcd.Expression = $"gcd({a.FullExpression()}, {b.FullExpression()})";
return gcd;
}
private static IVariable CalculateInternal(IMilpManager milpManager, params IVariable[] arguments)
{
var a = arguments[0];
var b = arguments[1];
var gcd = milpManager.CreateAnonymous(Domain.PositiveOrZeroInteger);
var x = milpManager.CreateAnonymous(Domain.PositiveOrZeroInteger);
var y = milpManager.CreateAnonymous(Domain.PositiveOrZeroInteger);
var m = milpManager.CreateAnonymous(Domain.AnyInteger);
var n = milpManager.CreateAnonymous(Domain.AnyInteger);
gcd.Set(ConstraintType.GreaterOrEqual, milpManager.FromConstant(1));
a.Set(ConstraintType.Equal, x.Operation(OperationType.Multiplication, gcd));
b.Set(ConstraintType.Equal, y.Operation(OperationType.Multiplication, gcd));
gcd.Set(ConstraintType.Equal, m.Operation(OperationType.Multiplication, a).Operation(OperationType.Addition, n.Operation(OperationType.Multiplication, b)));
gcd.ConstantValue = a.ConstantValue.HasValue && b.ConstantValue.HasValue
? Gcd((int)a.ConstantValue.Value, (int)b.ConstantValue.Value)
: (double?)null;
gcd.Expression = $"gcd({a.FullExpression()}, {b.FullExpression()})";
return(gcd);
}
private static IVariable CalculateForTwoVariables(IMilpManager milpManager, OperationType type, IVariable[] arguments)
{
if (arguments.All(a => a.IsConstant()))
{
var values = arguments.Select(a => a.ConstantValue.Value);
var result = type == OperationType.Maximum ? values.Max() : values.Min();
if (arguments.All(a => a.IsInteger()))
{
return(milpManager.FromConstant((int)result));
}
else
{
return(milpManager.FromConstant(result));
}
}
var first = arguments[0];
var second = arguments[1];
IVariable max = milpManager.CreateAnonymous(CalculateDomain(arguments));
IVariable min = milpManager.CreateAnonymous(CalculateDomain(arguments));
max.Set(ConstraintType.GreaterOrEqual, first);
max.Set(ConstraintType.GreaterOrEqual, second);
min.Set(ConstraintType.LessOrEqual, first);
min.Set(ConstraintType.LessOrEqual, second);
max.Operation(OperationType.Subtraction, min)
.Set(ConstraintType.Equal,
first.Operation(OperationType.Subtraction, second).Operation(OperationType.AbsoluteValue));
max.ConstantValue = arguments.All(a => a.ConstantValue.HasValue)
? Math.Max(arguments[0].ConstantValue.Value, arguments[1].ConstantValue.Value)
: (double?)null;
min.ConstantValue = arguments.All(a => a.ConstantValue.HasValue)
? Math.Min(arguments[0].ConstantValue.Value, arguments[1].ConstantValue.Value)
: (double?)null;
max.Expression = $"max({arguments[0].FullExpression()}, {arguments[1].FullExpression()}";
min.Expression = $"min({arguments[0].FullExpression()}, {arguments[1].FullExpression()}";
return(type == OperationType.Maximum ? max : min);
}
private static IVariable CalculateForTwoVariables(IMilpManager milpManager, OperationType type, IVariable[] arguments)
{
if (arguments.All(a => a.IsConstant()))
{
var values = arguments.Select(a => a.ConstantValue.Value);
var result = type == OperationType.Maximum ? values.Max() : values.Min();
if (arguments.All(a => a.IsInteger()))
{
return milpManager.FromConstant((int) result);
}
else
{
return milpManager.FromConstant(result);
}
}
var first = arguments[0];
var second = arguments[1];
IVariable max = milpManager.CreateAnonymous(CalculateDomain(arguments));
IVariable min = milpManager.CreateAnonymous(CalculateDomain(arguments));
max.Set(ConstraintType.GreaterOrEqual, first);
max.Set(ConstraintType.GreaterOrEqual, second);
min.Set(ConstraintType.LessOrEqual, first);
min.Set(ConstraintType.LessOrEqual, second);
max.Operation(OperationType.Subtraction, min)
.Set(ConstraintType.Equal,
first.Operation(OperationType.Subtraction, second).Operation(OperationType.AbsoluteValue));
max.ConstantValue = arguments.All(a => a.ConstantValue.HasValue)
? Math.Max(arguments[0].ConstantValue.Value, arguments[1].ConstantValue.Value)
: (double?)null;
min.ConstantValue = arguments.All(a => a.ConstantValue.HasValue)
? Math.Min(arguments[0].ConstantValue.Value, arguments[1].ConstantValue.Value)
: (double?)null;
max.Expression = $"max({arguments[0].FullExpression()}, {arguments[1].FullExpression()}";
min.Expression = $"min({arguments[0].FullExpression()}, {arguments[1].FullExpression()}";
return type == OperationType.Maximum ? max : min;
}
public IVariable Calculate(IMilpManager milpManager, GoalType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
if (arguments.All(a => a.IsConstant()))
{
return milpManager.Operation(OperationType.Maximum, arguments);
}
var result = milpManager.CreateAnonymous(arguments.Any(a => a.IsReal()) ? Domain.AnyReal : Domain.AnyInteger);
arguments.Aggregate(milpManager.FromConstant(0),(existing, next) => existing.Operation(OperationType.Disjunction, result.Operation(OperationType.IsEqual, next)))
.Set(ConstraintType.Equal, milpManager.FromConstant(1));
return result;
}
public IVariable Calculate(IMilpManager milpManager, GoalType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
if (arguments.All(a => a.IsConstant()))
{
return milpManager.Operation(OperationType.Minimum, arguments);
}
var result = milpManager.CreateAnonymous(arguments.Any(a => a.IsReal()) ? Domain.AnyReal : Domain.AnyInteger);
foreach (var argument in arguments)
{
result.Set(ConstraintType.LessOrEqual, argument);
}
return result;
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
}
if (arguments.All(a => a.IsConstant()))
{
var constantResult = arguments[0].ConstantValue.Value / arguments[1].ConstantValue.Value;
if (arguments.All(a => a.IsInteger()))
{
return(milpManager.FromConstant((int)constantResult));
}
else
{
return(milpManager.FromConstant(constantResult));
}
}
var domain = CalculateDomain(arguments);
if (IsDividingByConstant(arguments))
{
var finalDomain = arguments.All(x => x.IsConstant()) ? domain.MakeConstant() : domain;
var physicalResult = milpManager.DivideVariableByConstant(arguments[0], arguments[1], finalDomain);
physicalResult.ConstantValue = arguments[0].ConstantValue / arguments[1].ConstantValue;
physicalResult.Expression = $"{arguments[0].FullExpression()} / {arguments[1].FullExpression()}";
return(physicalResult);
}
IVariable one = milpManager.FromConstant(1);
var result = milpManager.CreateAnonymous(domain);
result.Operation(OperationType.Multiplication, arguments[1])
.Set(ConstraintType.LessOrEqual, arguments[0]);
result.Operation(OperationType.Addition, one)
.Operation(OperationType.Multiplication, arguments[1])
.Set(ConstraintType.GreaterOrEqual, arguments[0].Operation(OperationType.Addition, one));
result.ConstantValue = arguments.All(a => a.ConstantValue.HasValue)
? arguments[1].ConstantValue.Value == 0
? (double?)null
: (long)arguments[0].ConstantValue.Value / (long)arguments[1].ConstantValue.Value
: null;
result.Expression = $"{arguments[0].FullExpression()} / {arguments[1].FullExpression()}";
return(result);
}
public IVariable Set(IMilpManager milpManager, CompositeConstraintType type, ICompositeConstraintParameters parameters,
IVariable leftVariable, params IVariable[] rightVariable)
{
var one = milpManager.FromConstant(1);
var maximumIntegerValue = milpManager.FromConstant(milpManager.MaximumIntegerValue);
var allVariables = new[] {leftVariable}.Concat(rightVariable).ToArray();
var boundaryVariables = allVariables.Select(v => milpManager.CreateAnonymous(Domain.BinaryInteger)).ToArray();
milpManager.Operation(OperationType.Addition, boundaryVariables).Set(ConstraintType.LessOrEqual, one);
foreach (var pair in allVariables.Zip(boundaryVariables, Tuple.Create))
{
pair.Item1
.Set(ConstraintType.LessOrEqual, pair.Item2.Operation(OperationType.Multiplication, maximumIntegerValue))
.Set(ConstraintType.GreaterOrEqual, pair.Item2.Operation(OperationType.Multiplication, maximumIntegerValue).Operation(OperationType.Negation));
}
return leftVariable;
}
public IVariable Calculate(IMilpManager milpManager, GoalType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
}
if (arguments.All(a => a.IsConstant()))
{
return(milpManager.Operation(OperationType.Maximum, arguments));
}
var result = milpManager.CreateAnonymous(arguments.Any(a => a.IsReal()) ? Domain.AnyReal : Domain.AnyInteger);
arguments.Aggregate(milpManager.FromConstant(0), (existing, next) => existing.Operation(OperationType.Disjunction, result.Operation(OperationType.IsEqual, next)))
.Set(ConstraintType.Equal, milpManager.FromConstant(1));
return(result);
}
public IEnumerable <IVariable> Calculate(IMilpManager milpManager, CompositeOperationType type, ICompositeOperationParameters parameters,
params IVariable[] arguments)
{
if (!SupportsOperation(type, parameters, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, parameters, arguments));
}
var options = parameters as LoopParameters;
var totalBound = milpManager.CreateAnonymous(Domain.PositiveOrZeroInteger);
totalBound.Set(ConstraintType.LessOrEqual, milpManager.FromConstant(options.MaxIterations));
options.BeforeLoopAction(totalBound, arguments);
for (int i = 1; i <= options.MaxIterations; ++i)
{
var counter = milpManager.FromConstant(i);
var isLooping = counter.Operation(OperationType.IsLessOrEqual, totalBound);
options.BeforeIterationAction(counter, isLooping, totalBound, arguments);
for (int v = 0; v < arguments.Length; ++v)
{
if (options.BeforeBody.Length > v)
{
options.BeforeBody[v](arguments[v], counter, isLooping, totalBound, arguments);
}
arguments[v] = milpManager.Operation(OperationType.Condition, isLooping, options.Body[v](arguments[v], counter, isLooping, totalBound, arguments), arguments[v]);
if (options.AfterBody.Length > v)
{
options.AfterBody[v](arguments[v], counter, isLooping, totalBound, arguments);
}
}
options.AfterIterationAction(counter, isLooping, totalBound, arguments);
}
options.AfterLoopAction(totalBound, arguments);
return(arguments.Concat(new[] { totalBound }).ToArray());
}
public IVariable Set(IMilpManager milpManager, CompositeConstraintType type, ICompositeConstraintParameters parameters,
IVariable leftVariable, params IVariable[] rightVariable)
{
var one = milpManager.FromConstant(1);
var maximumIntegerValue = milpManager.FromConstant(milpManager.MaximumIntegerValue);
var allVariables = new[] { leftVariable }.Concat(rightVariable).ToArray();
var boundaryVariables = allVariables.Select(v => milpManager.CreateAnonymous(Domain.BinaryInteger)).ToArray();
milpManager.Operation(OperationType.Addition, boundaryVariables).Set(ConstraintType.LessOrEqual, one);
foreach (var pair in allVariables.Zip(boundaryVariables, Tuple.Create))
{
pair.Item1
.Set(ConstraintType.LessOrEqual, pair.Item2.Operation(OperationType.Multiplication, maximumIntegerValue))
.Set(ConstraintType.GreaterOrEqual, pair.Item2.Operation(OperationType.Multiplication, maximumIntegerValue).Operation(OperationType.Negation));
}
return(leftVariable);
}
public IVariable Calculate(IMilpManager milpManager, GoalType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
}
if (arguments.All(a => a.IsConstant()))
{
return(milpManager.Operation(OperationType.Minimum, arguments));
}
var result = milpManager.CreateAnonymous(arguments.Any(a => a.IsReal()) ? Domain.AnyReal : Domain.AnyInteger);
foreach (var argument in arguments)
{
result.Set(ConstraintType.LessOrEqual, argument);
}
return(result);
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
if (arguments.All(a => a.IsConstant()))
{
var constantResult = arguments[0].ConstantValue.Value/arguments[1].ConstantValue.Value;
if (arguments.All(a => a.IsInteger()))
{
return milpManager.FromConstant((int) constantResult);
}
else
{
return milpManager.FromConstant(constantResult);
}
}
var domain = CalculateDomain(arguments);
if (IsDividingByConstant(arguments))
{
var finalDomain = arguments.All(x => x.IsConstant()) ? domain.MakeConstant() : domain;
var physicalResult = milpManager.DivideVariableByConstant(arguments[0], arguments[1], finalDomain);
physicalResult.ConstantValue = arguments[0].ConstantValue/arguments[1].ConstantValue;
physicalResult.Expression = $"{arguments[0].FullExpression()} / {arguments[1].FullExpression()}";
return physicalResult;
}
IVariable one = milpManager.FromConstant(1);
var result = milpManager.CreateAnonymous(domain);
result.Operation(OperationType.Multiplication, arguments[1])
.Set(ConstraintType.LessOrEqual, arguments[0]);
result.Operation(OperationType.Addition, one)
.Operation(OperationType.Multiplication, arguments[1])
.Set(ConstraintType.GreaterOrEqual, arguments[0].Operation(OperationType.Addition, one));
result.ConstantValue = arguments.All(a => a.ConstantValue.HasValue)
? arguments[1].ConstantValue.Value == 0
? (double?)null
: (long)arguments[0].ConstantValue.Value / (long)arguments[1].ConstantValue.Value
: null;
result.Expression = $"{arguments[0].FullExpression()} / {arguments[1].FullExpression()}";
return result;
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
}
if (arguments.All(a => a.IsConstant()))
{
return(milpManager.FromConstant(arguments.Select(a => (int)a.ConstantValue).Aggregate(Math.Min)));
}
var variable = milpManager.CreateAnonymous(Domain.BinaryInteger);
var sum = milpManager.Operation(OperationType.Addition, arguments);
var argumentsCount = arguments.Length;
sum.Operation(OperationType.Subtraction,
milpManager.FromConstant(argumentsCount).Operation(OperationType.Multiplication, variable))
.Set(ConstraintType.LessOrEqual, milpManager.FromConstant(argumentsCount - 1))
.Set(ConstraintType.GreaterOrEqual, milpManager.FromConstant(0));
variable.ConstantValue = arguments.Aggregate((double?)1.0, (a, b) => a.HasValue && b.ConstantValue.HasValue ? Math.Min(a.Value, b.ConstantValue.Value) : (double?)null);
variable.Expression = $"{string.Join(" && ", arguments.Select(a => a.FullExpression()).ToArray())}";
return(variable);
}
public IVariable Set(IMilpManager milpManager, CompositeConstraintType type, ICompositeConstraintParameters parameters,
IVariable leftVariable, params IVariable[] rightVariable)
{
var maximumIntegerValue = milpManager.FromConstant(milpManager.MaximumIntegerValue);
var one = milpManager.FromConstant(1);
var allVariables = new[] { leftVariable }.Concat(rightVariable).ToArray();
var boundaryVariables = allVariables.Select(v => milpManager.CreateAnonymous(Domain.BinaryInteger)).ToArray();
milpManager.Operation(OperationType.Addition, boundaryVariables).Set(ConstraintType.LessOrEqual, one);
for (int i = 0; i < allVariables.Length; ++i)
{
IVariable sum = boundaryVariables[i];
if (i < allVariables.Length - 1)
{
sum = sum.Operation(OperationType.Addition, boundaryVariables[i + 1]);
}
allVariables[i]
.Set(ConstraintType.LessOrEqual, sum.Operation(OperationType.Multiplication, maximumIntegerValue))
.Set(ConstraintType.GreaterOrEqual, sum.Operation(OperationType.Multiplication, maximumIntegerValue).Operation(OperationType.Negation));
}
return leftVariable;
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
if (arguments.All(a => a.IsConstant()))
{
return milpManager.FromConstant(arguments[0].ConstantValue.Value > arguments[1].ConstantValue.Value ? 1 : 0);
}
var result = milpManager.CreateAnonymous(Domain.BinaryInteger);
var first = arguments[0];
var second = arguments[1];
second.Operation(OperationType.Subtraction, first)
.Operation(OperationType.Addition,
result.Operation(OperationType.Multiplication, milpManager.FromConstant(milpManager.IntegerInfinity)))
.Set(ConstraintType.GreaterOrEqual, milpManager.FromConstant(0))
.Set(ConstraintType.LessOrEqual, milpManager.FromConstant(milpManager.IntegerInfinity - (arguments.Any(a => a.IsReal()) ? milpManager.Epsilon : 1)));
result.ConstantValue = arguments.All(a => a.ConstantValue.HasValue)
? arguments[0].ConstantValue > arguments[1].ConstantValue ? 1 : 0
: (double?)null;
result.Expression = $"{arguments[0].FullExpression()} ?> {arguments[1].FullExpression()}";
return result;
}
public IEnumerable<IVariable> Calculate(IMilpManager milpManager, CompositeOperationType type, ICompositeOperationParameters parameters,
params IVariable[] arguments)
{
if (!SupportsOperation(type, parameters, arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, parameters, arguments));
var typedParameters = parameters as Approximate2DParameters;
var x = arguments.First();
var y = arguments.Skip(1).First();
if (arguments.All(i => i.IsConstant()))
{
return new[] { milpManager.FromConstant(typedParameters.Function(x.ConstantValue.Value, y.ConstantValue.Value)) };
}
var one = milpManager.FromConstant(1);
var variables =
Enumerable.Range(0, typedParameters.ArgumentsX.Count()).Select(p =>
Enumerable.Range(0, typedParameters.ArgumentsY.Count()).Select(q =>
milpManager.CreateAnonymous(typedParameters.ArgumentMustBeOnAGrid
? Domain.BinaryInteger
: Domain.PositiveOrZeroReal).Set(ConstraintType.LessOrEqual, one)).ToArray())
.ToArray();
x.Set(ConstraintType.Equal, milpManager.Operation(OperationType.Addition,
Enumerable.Range(0, typedParameters.ArgumentsX.Count()).SelectMany(indexX =>
Enumerable.Range(0, typedParameters.ArgumentsY.Count()).Select(indexY =>
variables[indexX][indexY].Operation(OperationType.Multiplication, milpManager.FromConstant(typedParameters.ArgumentsX.ElementAt(indexX))))).ToArray()
));
y.Set(ConstraintType.Equal, milpManager.Operation(OperationType.Addition,
Enumerable.Range(0, typedParameters.ArgumentsX.Count()).SelectMany(indexX =>
Enumerable.Range(0, typedParameters.ArgumentsY.Count()).Select(indexY =>
variables[indexX][indexY].Operation(OperationType.Multiplication, milpManager.FromConstant(typedParameters.ArgumentsY.ElementAt(indexY))))).ToArray()
));
var z = milpManager.Operation(OperationType.Addition,
Enumerable.Range(0, typedParameters.ArgumentsX.Count()).SelectMany(indexX =>
Enumerable.Range(0, typedParameters.ArgumentsY.Count()).Select(indexY =>
variables[indexX][indexY].Operation(OperationType.Multiplication, milpManager.FromConstant(typedParameters.Function(typedParameters.ArgumentsX.ElementAt(indexX), typedParameters.ArgumentsY.ElementAt(indexY)))))).ToArray()
);
milpManager.Operation(OperationType.Addition, variables.SelectMany(v => v).ToArray()).Set(ConstraintType.Equal, one);
var xSet = Enumerable.Range(0, typedParameters.ArgumentsX.Count()).Select(indexX => milpManager.Operation(OperationType.Addition, Enumerable.Range(0, typedParameters.ArgumentsY.Count()).Select(indexY => variables[indexX][indexY]).ToArray())).ToArray();
milpManager.Set(CompositeConstraintType.SpecialOrderedSetType2, xSet.First(), xSet.Skip(1).ToArray());
var ySet = Enumerable.Range(0, typedParameters.ArgumentsY.Count()).Select(indexY => milpManager.Operation(OperationType.Addition, Enumerable.Range(0, typedParameters.ArgumentsX.Count()).Select(indexX => variables[indexX][indexY]).ToArray())).ToArray();
milpManager.Set(CompositeConstraintType.SpecialOrderedSetType2, ySet.First(), ySet.Skip(1).ToArray());
if (!typedParameters.ArgumentMustBeOnAGrid)
{
var triangleSet = Enumerable.Range(0, typedParameters.ArgumentsY.Count()).SelectMany(indexY =>
{
var variablesToSet = Enumerable.Range(0, typedParameters.ArgumentsX.Count()).Where(indexX => indexX + indexY < variables[indexX].Length).Select(indexX => variables[indexX][indexX + indexY]).ToArray();
if (variablesToSet.Any())
{
return new[] {milpManager.Operation(OperationType.Addition, variablesToSet)};
}
return new IVariable[0];
}).ToArray();
milpManager.Set(CompositeConstraintType.SpecialOrderedSetType2, triangleSet.First(), triangleSet.Skip(1).ToArray());
}
z.ConstantValue = x.IsConstant() && y.IsConstant() ? typedParameters.Function(x.ConstantValue.Value, y.ConstantValue.Value) : (double?)null;
z.Expression = $"approximation2D({typedParameters.FunctionDescription})";
return new[] { z };
}
public IEnumerable <IVariable> Calculate(IMilpManager milpManager, CompositeOperationType type, ICompositeOperationParameters parameters,
params IVariable[] arguments)
{
if (!SupportsOperation(type, parameters, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, parameters, arguments));
}
var typedParameters = parameters as Approximate2DParameters;
var x = arguments.First();
var y = arguments.Skip(1).First();
if (arguments.All(i => i.IsConstant()))
{
return(new[] { milpManager.FromConstant(typedParameters.Function(x.ConstantValue.Value, y.ConstantValue.Value)) });
}
var one = milpManager.FromConstant(1);
var variables =
Enumerable.Range(0, typedParameters.ArgumentsX.Count()).Select(p =>
Enumerable.Range(0, typedParameters.ArgumentsY.Count()).Select(q =>
milpManager.CreateAnonymous(typedParameters.ArgumentMustBeOnAGrid
? Domain.BinaryInteger
: Domain.PositiveOrZeroReal).Set(ConstraintType.LessOrEqual, one)).ToArray())
.ToArray();
x.Set(ConstraintType.Equal, milpManager.Operation(OperationType.Addition,
Enumerable.Range(0, typedParameters.ArgumentsX.Count()).SelectMany(indexX =>
Enumerable.Range(0, typedParameters.ArgumentsY.Count()).Select(indexY =>
variables[indexX][indexY].Operation(OperationType.Multiplication, milpManager.FromConstant(typedParameters.ArgumentsX.ElementAt(indexX))))).ToArray()
));
y.Set(ConstraintType.Equal, milpManager.Operation(OperationType.Addition,
Enumerable.Range(0, typedParameters.ArgumentsX.Count()).SelectMany(indexX =>
Enumerable.Range(0, typedParameters.ArgumentsY.Count()).Select(indexY =>
variables[indexX][indexY].Operation(OperationType.Multiplication, milpManager.FromConstant(typedParameters.ArgumentsY.ElementAt(indexY))))).ToArray()
));
var z = milpManager.Operation(OperationType.Addition,
Enumerable.Range(0, typedParameters.ArgumentsX.Count()).SelectMany(indexX =>
Enumerable.Range(0, typedParameters.ArgumentsY.Count()).Select(indexY =>
variables[indexX][indexY].Operation(OperationType.Multiplication, milpManager.FromConstant(typedParameters.Function(typedParameters.ArgumentsX.ElementAt(indexX), typedParameters.ArgumentsY.ElementAt(indexY)))))).ToArray()
);
milpManager.Operation(OperationType.Addition, variables.SelectMany(v => v).ToArray()).Set(ConstraintType.Equal, one);
var xSet = Enumerable.Range(0, typedParameters.ArgumentsX.Count()).Select(indexX => milpManager.Operation(OperationType.Addition, Enumerable.Range(0, typedParameters.ArgumentsY.Count()).Select(indexY => variables[indexX][indexY]).ToArray())).ToArray();
milpManager.Set(CompositeConstraintType.SpecialOrderedSetType2, xSet.First(), xSet.Skip(1).ToArray());
var ySet = Enumerable.Range(0, typedParameters.ArgumentsY.Count()).Select(indexY => milpManager.Operation(OperationType.Addition, Enumerable.Range(0, typedParameters.ArgumentsX.Count()).Select(indexX => variables[indexX][indexY]).ToArray())).ToArray();
milpManager.Set(CompositeConstraintType.SpecialOrderedSetType2, ySet.First(), ySet.Skip(1).ToArray());
if (!typedParameters.ArgumentMustBeOnAGrid)
{
var triangleSet = Enumerable.Range(0, typedParameters.ArgumentsY.Count()).SelectMany(indexY =>
{
var variablesToSet = Enumerable.Range(0, typedParameters.ArgumentsX.Count()).Where(indexX => indexX + indexY < variables[indexX].Length).Select(indexX => variables[indexX][indexX + indexY]).ToArray();
if (variablesToSet.Any())
{
return(new[] { milpManager.Operation(OperationType.Addition, variablesToSet) });
}
return(new IVariable[0]);
}).ToArray();
milpManager.Set(CompositeConstraintType.SpecialOrderedSetType2, triangleSet.First(), triangleSet.Skip(1).ToArray());
}
z.ConstantValue = x.IsConstant() && y.IsConstant() ? typedParameters.Function(x.ConstantValue.Value, y.ConstantValue.Value) : (double?)null;
z.Expression = $"approximation2D({typedParameters.FunctionDescription})";
return(new[] { z });
}
