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(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()))
{
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 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()))
{
var sum = arguments.Select(x => x.ConstantValue.Value).Sum();
if (arguments.All(x => x.IsInteger()))
{
return(milpManager.FromConstant((int)sum));
}
return(milpManager.FromConstant(sum));
}
var domain = CalculateDomain(arguments);
return(arguments.Aggregate((x, y) =>
{
var result = milpManager.SumVariables(x, y, domain);
result.ConstantValue = x.ConstantValue + y.ConstantValue;
result.Expression = $"{x.FullExpression()} + {y.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 NthElementsParameters;
if (arguments.All(a => a.IsConstant()) && typedParameters.Indexes.All(a => a.IsConstant()))
{
var sorted = arguments.OrderBy(a => a.ConstantValue.Value).ToArray();
return typedParameters.Indexes.Select(i => sorted[(int)i.ConstantValue.Value]);
}
var variables = new List<IVariable>();
var sums = arguments.Select(a => Tuple.Create(a, milpManager.Operation(OperationType.Addition,
arguments.Where(b => a != b).Select(b => a.Operation(OperationType.IsGreaterOrEqual, b).Create()).ToArray()).Create())).ToArray();
var huge = milpManager.FromConstant(milpManager.MaximumIntegerValue);
foreach(var indexVariable in typedParameters.Indexes)
{
var result = huge;
foreach (var sum in sums)
{
result = result.Operation(OperationType.Minimum, milpManager.Operation(OperationType.Condition,
sum.Item2.Operation(OperationType.IsGreaterOrEqual, indexVariable),
sum.Item1,
huge
));
}
var singleVariable = result.Create();
singleVariable.Expression = $"nthElement(index: {indexVariable.FullExpression()}, {string.Join(",", arguments.Select(a => a.FullExpression()).ToArray())})";
variables.Add(singleVariable);
}
return variables;
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
}
if (arguments[0].IsConstant())
{
if (arguments[0].ConstantValue.Value <= milpManager.Epsilon)
{
return(arguments[2]);
}
return(arguments[1]);
}
var trueBranch = arguments[0].Operation(OperationType.Multiplication, arguments[1]);
var falseBranch = arguments[0].Operation(OperationType.BinaryNegation)
.Operation(OperationType.Multiplication, arguments[2]);
var result = milpManager.Create(milpManager.Operation(OperationType.Addition,
trueBranch,
falseBranch
).ChangeDomain(trueBranch.LowestEncompassingDomain(falseBranch)));
result.Expression = $"{arguments[0].FullExpression()} ? {arguments[1].FullExpression()} : {arguments[2].FullExpression()}";
result.ConstantValue = !arguments[0].ConstantValue.HasValue
? null
: (int)arguments[0].ConstantValue.Value == 1 ? trueBranch.ConstantValue : falseBranch.ConstantValue;
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 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 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, arguments));
var typedParameters = parameters as LexicographicalCompareParameters;
if (arguments.All(i => i.IsConstant()) &&
typedParameters.Pattern.All(i => i.IsConstant()))
{
return new [] {
CompareFinalResult(milpManager.FromConstant(arguments.Zip(typedParameters.Pattern, Tuple.Create)
.Select(pair => pair.Item1.ConstantValue.Value - pair.Item2.ConstantValue.Value)
.Select(v => v > 0 ? 1 : (v < 0 ? -1 : 0))
.FirstOrDefault(v => v != 0)), milpManager)
};
}
var compareResult = CalculateBatches(milpManager, parameters, arguments).ToArray();
while (compareResult.Length > 1)
{
var zero = milpManager.FromConstant(0);
var newParameters = new LexicographicalCompareParameters
{
Pattern = Enumerable.Range(0, compareResult.Length).Select(x => zero).ToArray()
};
compareResult = CalculateBatches(milpManager, newParameters, compareResult).ToArray();
}
var result = compareResult.First();
result.ConstantValue = arguments.All(a => a.ConstantValue.HasValue) && typedParameters.Pattern.All(a => a.IsConstant())
? ConstantFinalResult(arguments.Zip(typedParameters.Pattern, Tuple.Create).Select(p => p.Item1.ConstantValue.Value - p.Item2.ConstantValue.Value).Select(v => v > 0 ? 1 : v < 0 ? -1 : 0).TakeWhile(v => v != 0).FirstOrDefault())
: (double?)null;
result.Expression = $"({string.Join(",", arguments.Select(a => a.FullExpression()).ToArray())}) {ComparerFinalResult} ({string.Join(",", typedParameters.Pattern.Select(a => a.FullExpression()).ToArray())})";
return new[] {CompareFinalResult(compareResult[0], milpManager)};
}
public IVariable Set(IMilpManager milpManager, ConstraintType type, IVariable leftVariable,
IVariable rightVariable)
{
switch (type)
{
case ConstraintType.Equal:
milpManager.SetEqual(leftVariable, rightVariable);
leftVariable.ConstantValue = rightVariable.ConstantValue ?? leftVariable.ConstantValue;
rightVariable.ConstantValue = leftVariable.ConstantValue ?? rightVariable.ConstantValue;
break;
case ConstraintType.LessOrEqual:
milpManager.SetLessOrEqual(leftVariable, rightVariable);
break;
case ConstraintType.GreaterOrEqual:
milpManager.SetGreaterOrEqual(leftVariable, rightVariable);
break;
case ConstraintType.LessThan:
milpManager.Operation(OperationType.IsLessThan, leftVariable, rightVariable)
.Set(ConstraintType.Equal, milpManager.FromConstant(1));
break;
case ConstraintType.GreaterThan:
milpManager.Operation(OperationType.IsGreaterThan, leftVariable, rightVariable)
.Set(ConstraintType.Equal, milpManager.FromConstant(1));
break;
case ConstraintType.NotEqual:
milpManager.Operation(OperationType.IsNotEqual, leftVariable, rightVariable)
.Set(ConstraintType.Equal, milpManager.FromConstant(1));
break;
default:
throw new InvalidOperationException("Cannot set constraint");
}
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;
}
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 index = ((ArraySetParameters)parameters).Index;
var value = ((ArraySetParameters)parameters).Value;
if (index.IsConstant())
{
arguments[(int)index.ConstantValue.Value] = value;
return(arguments);
}
var catenatedArguments = string.Join(", ", arguments.Select(a => a.FullExpression()).ToArray());
for (int i = 0; i < arguments.Length; ++i)
{
arguments[i] = milpManager.Operation(OperationType.Condition, milpManager.FromConstant(i).Operation(OperationType.IsEqual, index), value, arguments[i]);
arguments[i].Expression = $"arraySet(wantedIndex: {index.FullExpression()}, value: {value.FullExpression()}, inArrayIndex: {i}, {catenatedArguments})";
}
return(arguments);
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
}
if (arguments[0].IsConstant())
{
var value = -arguments[0].ConstantValue.Value;
if (arguments[0].IsInteger())
{
return(milpManager.FromConstant((int)value));
}
else
{
return(milpManager.FromConstant(value));
}
}
Domain domain = arguments[0].IsReal() ? Domain.AnyReal : Domain.AnyInteger;
var result = milpManager.NegateVariable(arguments[0], domain);
result.ConstantValue = -arguments[0].ConstantValue;
result.Expression = $"-{arguments[0].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 => a.ConstantValue.Value).Distinct().Count()));
}
var total = milpManager.FromConstant(0);
foreach (var first in arguments)
{
var different = milpManager.FromConstant(1);
foreach (var second in arguments.TakeWhile(a => a != first))
{
different = different.Operation(OperationType.Conjunction,
first.Operation(OperationType.IsNotEqual, second));
}
total = total.Operation(OperationType.Addition, different);
}
total.Expression = $"differentValuesCount({string.Join(",", arguments.Select(a => a.FullExpression()).ToArray())})";
return(total);
}
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 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 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 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));
}
return(InternalCalculate(milpManager, arguments, ((DecompositionParameters)parameters).Base));
}
public IVariable Calculate(IMilpManager milpManager, GoalType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
}
return(arguments[0]);
}
public IVariable Set(IMilpManager milpManager, CompositeConstraintType type, ICompositeConstraintParameters parameters,
IVariable leftVariable, params IVariable[] rightVariable)
{
leftVariable.Operation(OperationType.DifferentValuesCount, rightVariable)
.Set(ConstraintType.Equal, milpManager.FromConstant(rightVariable.Length + 1));
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);
}
public IVariable Set(IMilpManager milpManager, CompositeConstraintType type, ICompositeConstraintParameters parameters,
IVariable leftVariable, params IVariable[] rightVariable)
{
leftVariable.Operation(OperationType.DifferentValuesCount, rightVariable)
.Set(ConstraintType.Equal, milpManager.FromConstant(rightVariable.Length + 1));
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.Length > 2)
{
return arguments[0].Operation(type, milpManager.Operation(type, arguments.Skip(1).ToArray()));
}
return CalculateForTwoVariables(milpManager, type, arguments);
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
}
return
(arguments.Aggregate((left, right) => left.Operation(OperationType.Addition, right.Operation(OperationType.Negation))));
}
public IVariable Set(IMilpManager milpManager, CompositeConstraintType type, ICompositeConstraintParameters parameters,
IVariable leftVariable, params IVariable[] rightVariable)
{
rightVariable.Aggregate(milpManager.FromConstant(0),
(current, variable) =>
current.Operation(OperationType.Addition, leftVariable.Operation(OperationType.IsEqual, variable))).Create()
.Set(ConstraintType.Equal, milpManager.FromConstant(0));
return leftVariable;
}
public IVariable Set(IMilpManager milpManager, CompositeConstraintType type, ICompositeConstraintParameters parameters,
IVariable leftVariable, params IVariable[] rightVariable)
{
rightVariable.Aggregate(milpManager.FromConstant(0),
(current, variable) =>
current.Operation(OperationType.Addition, leftVariable.Operation(OperationType.IsEqual, variable))).Create()
.Set(ConstraintType.Equal, milpManager.FromConstant(0));
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[0].IsConstant())
{
return milpManager.FromConstant((int) (1 - arguments[0].ConstantValue.Value));
}
var result = milpManager.FromConstant(1).Operation(OperationType.Subtraction, arguments[0]).ChangeDomain(Domain.BinaryInteger).Create();
result.Expression = $"!{arguments[0].FullExpression()}";
return result;
}
private static IEnumerable<IVariable> CalculateBatches(IMilpManager milpManager, ICompositeOperationParameters parameters,
IVariable[] arguments)
{
var batchSize = milpManager.IntegerWidth;
var batches = (arguments.Length - 1)/batchSize + 1;
return Enumerable.Range(0, batches)
.Select(
index =>
CalculateBatch(milpManager, arguments.Skip(index*batchSize).Take(batchSize).ToArray(),
(parameters as LexicographicalCompareParameters).Pattern.Skip(index*batchSize).Take(batchSize).ToArray()));
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
if (arguments[0].IsConstant())
{
return milpManager.FromConstant((int) (1 - arguments[0].ConstantValue.Value));
}
var result = milpManager.FromConstant(1).Operation(OperationType.Subtraction, arguments[0]).ChangeDomain(Domain.BinaryInteger).Create();
result.Expression = $"!{arguments[0].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 = Math.Pow(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 number = arguments[0];
var power = arguments[1];
var one = milpManager.FromConstant(1);
var zero = milpManager.FromConstant(0);
var isNumberLessOrEqualOne = number.Operation(OperationType.IsLessOrEqual, one);
var isPowerZero = power.Operation(OperationType.IsLessOrEqual, zero);
var isPowerOne = power.Operation(OperationType.IsEqual, one);
var isEdgeCase = milpManager.Operation(OperationType.Disjunction, isNumberLessOrEqualOne, isPowerZero, isPowerOne);
var result = milpManager.Operation(
OperationType.Condition,
isPowerZero,
one,
milpManager.Operation(
OperationType.Condition,
isNumberLessOrEqualOne,
number,
milpManager.Operation(
OperationType.Condition,
isPowerOne,
number,
CalculatePower(number, power, milpManager, isEdgeCase)
)
)
);
result.ConstantValue = number.ConstantValue.HasValue && power.ConstantValue.HasValue
? number.ConstantValue == 0
? 0.0
: power.ConstantValue == 0
? number.ConstantValue
: Math.Pow(number.ConstantValue.Value, power.ConstantValue.Value)
: (double?)null;
result.Expression = $"{number.FullExpression()} ** {power.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((int)(arguments[0].ConstantValue.Value == 0 ? 1 : arguments[1].ConstantValue.Value));
}
var variable = arguments[0].Operation(OperationType.BinaryNegation).Operation(OperationType.Disjunction, arguments[1]);
variable.Expression = $"{arguments[0].FullExpression()} => {arguments[1].FullExpression()}";
return variable;
}
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((int)(arguments[0].ConstantValue.Value == 0 ? 1 : arguments[1].ConstantValue.Value));
}
var variable = arguments[0].Operation(OperationType.BinaryNegation).Operation(OperationType.Disjunction, arguments[1]);
variable.Expression = $"{arguments[0].FullExpression()} => {arguments[1].FullExpression()}";
return variable;
}
private static int GetDigitsCount(IMilpManager milpManager, uint decompositionBase)
{
double value = 1;
int digits = 0;
while (value <= milpManager.MaximumIntegerValue)
{
digits++;
value *= decompositionBase;
}
return digits;
}
public CplexVariable(IMilpManager manager, Domain domain, INumExpr var, string name)
{
_milpManager = manager;
Domain = domain;
Var = var;
Name = name;
if (Var is CpxNumVar)
{
// We need to store variable index in order to be able to deserialize the problem later
Index = (CplexIndex) IndexField.GetValue(Var);
}
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments))
{
throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
}
if (arguments.Length > 2)
{
return(arguments[0].Operation(type, milpManager.Operation(type, arguments.Skip(1).ToArray())));
}
return(CalculateForTwoVariables(milpManager, type, arguments));
}
private static IEnumerable <IVariable> CalculateBatches(IMilpManager milpManager, ICompositeOperationParameters parameters,
IVariable[] arguments)
{
var batchSize = milpManager.IntegerWidth;
var batches = (arguments.Length - 1) / batchSize + 1;
return(Enumerable.Range(0, batches)
.Select(
index =>
CalculateBatch(milpManager, arguments.Skip(index * batchSize).Take(batchSize).ToArray(),
(parameters as LexicographicalCompareParameters).Pattern.Skip(index * batchSize).Take(batchSize).ToArray())));
}
private static int GetDigitsCount(IMilpManager milpManager, uint decompositionBase)
{
double value = 1;
int digits = 0;
while (value <= milpManager.MaximumIntegerValue)
{
digits++;
value *= decompositionBase;
}
return(digits);
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
if (arguments.All(v => v.IsConstant()))
{
return milpManager.FromConstant(Gcd((int) arguments[0].ConstantValue.Value, (int) arguments[1].ConstantValue.Value));
}
var a = arguments[0];
var b = arguments[1];
var gcd = CalculateInternal(milpManager, a, b);
return gcd;
}
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));
}
return(milpManager.MakeGoal(GoalType.MaximizeMaximum, arguments).MakeGoal(GoalType.Minimize));
}
private static IVariable CalculateBatch(IMilpManager milpManager, IVariable[] first, IVariable[] second)
{
var power = (int)Math.Pow(2, first.Length);
return first.Zip(second, Tuple.Create).Aggregate(milpManager.FromConstant(0),
(result, pair) =>
{
power /= 2;
return result.Operation(OperationType.Addition,
pair.Item1.Operation(OperationType.IsGreaterOrEqual, pair.Item2).Operation(OperationType.Multiplication, milpManager.FromConstant(power)),
pair.Item1.Operation(OperationType.IsLessOrEqual, pair.Item2).Operation(OperationType.Multiplication, milpManager.FromConstant(-power))
);
});
}
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 = Math.Pow(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 number = arguments[0];
var power = arguments[1];
var one = milpManager.FromConstant(1);
var zero = milpManager.FromConstant(0);
var isNumberLessOrEqualOne = number.Operation(OperationType.IsLessOrEqual, one);
var isPowerZero = power.Operation(OperationType.IsLessOrEqual, zero);
var isPowerOne = power.Operation(OperationType.IsEqual, one);
var isEdgeCase = milpManager.Operation(OperationType.Disjunction, isNumberLessOrEqualOne, isPowerZero, isPowerOne);
var result = milpManager.Operation(
OperationType.Condition,
isPowerZero,
one,
milpManager.Operation(
OperationType.Condition,
isNumberLessOrEqualOne,
number,
milpManager.Operation(
OperationType.Condition,
isPowerOne,
number,
CalculatePower(number, power, milpManager, isEdgeCase)
)
)
);
result.ConstantValue = number.ConstantValue.HasValue && power.ConstantValue.HasValue
? number.ConstantValue == 0
? 0.0
: power.ConstantValue == 0
? number.ConstantValue
: Math.Pow(number.ConstantValue.Value, power.ConstantValue.Value)
: (double?) null;
result.Expression = $"{number.FullExpression()} ** {power.FullExpression()}";
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.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;
}
private IVariable MultiplyIntegers(IMilpManager baseMilpManager, Domain domain, IVariable[] arguments)
{
var binaries = arguments.Where(a => a.IsBinary()).ToArray();
var nonBinaries = arguments.Where(a => !a.IsBinary()).ToArray();
if (binaries.Any())
{
IVariable conjucted = baseMilpManager.Operation(OperationType.Multiplication, binaries);
return(MultipleByBinaryDigit(baseMilpManager, nonBinaries[0], conjucted).ChangeDomain(domain)
.Operation(OperationType.Multiplication, nonBinaries.Skip(1).ToArray()));
}
return(MultiplyNonBinaryIntegers(baseMilpManager, nonBinaries, domain));
}
private static IVariable CalculateBatch(IMilpManager milpManager, IVariable[] first, IVariable[] second)
{
var power = (int)Math.Pow(2, first.Length);
return(first.Zip(second, Tuple.Create).Aggregate(milpManager.FromConstant(0),
(result, pair) =>
{
power /= 2;
return result.Operation(OperationType.Addition,
pair.Item1.Operation(OperationType.IsGreaterOrEqual, pair.Item2).Operation(OperationType.Multiplication, milpManager.FromConstant(power)),
pair.Item1.Operation(OperationType.IsLessOrEqual, pair.Item2).Operation(OperationType.Multiplication, milpManager.FromConstant(-power))
);
}));
}
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.Operation(OperationType.IsGreaterThan, arguments[1], arguments[0]);
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 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((a, b) => (a + b) % 2));
}
var variable = arguments.Aggregate((a,b) =>
milpManager.Operation(OperationType.Disjunction,
milpManager.Operation(OperationType.Conjunction, a.Operation(OperationType.BinaryNegation), b),
milpManager.Operation(OperationType.Conjunction, a, b.Operation(OperationType.BinaryNegation))));
variable.Expression = $"{string.Join(" ^ ", arguments.Select(a => a.FullExpression()).ToArray())}";
return variable;
}
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 decomposition = milpManager.CompositeOperation(CompositeOperationType.Decomposition, new DecompositionParameters { Base = 2 }, arguments);
if (arguments[0].IsConstant())
{
return decomposition;
}
return decomposition.Zip(Enumerable.Range(0, milpManager.IntegerWidth), (v, index) =>
{
v.Expression = $"unsignedMagnitudeDecomposition(bit: {index}, {arguments[0].FullExpression()})";
return v;
});
}
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));
if (arguments.All(a => a.IsConstant()))
{
return arguments.OrderBy(a => a.ConstantValue.Value);
}
var results = milpManager.CompositeOperation(CompositeOperationType.NthElements,
new NthElementsParameters {Indexes = Enumerable.Range(0, arguments.Length).Select(milpManager.FromConstant).ToArray()},
arguments).ToArray();
for (int i = 0; i < results.Length; ++i)
{
results[i].Expression = $"selectionSort(position: {i+1}, {string.Join(",", arguments.Select(a => a.FullExpression()).ToArray())})";
}
return results;
}
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(v => v.IsConstant()))
{
return(milpManager.FromConstant(Gcd((int)arguments[0].ConstantValue.Value, (int)arguments[1].ConstantValue.Value)));
}
var a = arguments[0];
var b = arguments[1];
var gcd = CalculateInternal(milpManager, a, b);
return(gcd);
}
private IVariable MakeLongMultiplication(IMilpManager baseMilpManager, Domain domain, IVariable zero, IVariable second,
IVariable first)
{
var result = zero;
var secondDigits = second.CompositeOperation(CompositeOperationType.UnsignedMagnitudeDecomposition).ToArray();
for (int index = 0, power = 1; index < secondDigits.Length; ++index, power = power * 2)
{
result = result.Operation(OperationType.Addition,
MultipleByBinaryDigit(baseMilpManager, first, secondDigits[index])
.ChangeDomain(domain)
.Operation(OperationType.Multiplication, baseMilpManager.FromConstant(power))
);
}
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.Length == 1)
{
return(arguments[0]);
}
if (MultiplyOnlyConstants(arguments))
{
var result = arguments.Select(a => a.ConstantValue.Value).Aggregate((a, b) => a * b);
if (arguments.All(a => a.IsInteger()))
{
return(milpManager.FromConstant((int)result));
}
else
{
return(milpManager.FromConstant(result));
}
}
var domain = CalculateDomain(arguments);
if (MultiplyAtMostOneNonconstant(arguments))
{
return(arguments.Aggregate((x, y) =>
{
var result = y.IsConstant()
? milpManager.MultiplyVariableByConstant(x, y, domain)
: milpManager.MultiplyVariableByConstant(y, x, domain);
result.ConstantValue = x.ConstantValue * y.ConstantValue;
result.Expression = $"{x.FullExpression()} * {y.FullExpression()}";
return result;
}));
}
if (MultiplyBinaryVariables(arguments))
{
return(milpManager.Operation(OperationType.Conjunction, arguments));
}
return(MultiplyIntegers(milpManager, domain, arguments));
}
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));
}
if (arguments.All(a => a.IsConstant()))
{
return(arguments.OrderBy(a => a.ConstantValue.Value));
}
var castedParameters = parameters as CountingSortParameters;
var values = castedParameters.Values;
var valuesWithCounts = new Dictionary <IVariable, IVariable>();
var zero = milpManager.FromConstant(0);
foreach (var value in values)
{
valuesWithCounts[value] = arguments.Aggregate(zero,
(current, val) =>
current.Operation(OperationType.Addition, val.Operation(OperationType.IsEqual, value)));
}
var sum = zero;
foreach (var value in values)
{
sum = sum.Operation(OperationType.Addition, valuesWithCounts[value]);
valuesWithCounts[value] = sum;
}
var infinity = milpManager.FromConstant(milpManager.MaximumIntegerValue);
var results = Enumerable.Range(1, arguments.Length).Select(p =>
{
var position = milpManager.FromConstant(p);
var result = milpManager.Operation(OperationType.Minimum,
values.Select(value =>
milpManager.Operation(OperationType.Condition,
position.Operation(OperationType.IsLessOrEqual, valuesWithCounts[value]), value, infinity)
).ToArray());
result.Expression = $"countingSort(position: {p}, {string.Join(", ", arguments.Select(a => a.FullExpression()).ToArray())})";
return(result);
}).ToArray();
return(results);
}
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;
}
private IEnumerable<IVariable> InternalCalculate(IMilpManager milpManager, IVariable[] arguments, uint decompositionBase)
{
if (arguments[0].IsConstant())
{
uint currentValue = (uint)arguments[0].ConstantValue.Value;
for (int i = 0; i < GetDigitsCount(milpManager, decompositionBase); ++i)
{
yield return milpManager.FromConstant((int)(currentValue % decompositionBase));
currentValue /= decompositionBase;
}
yield break;
}
foreach (var i in CalculateForVariable(milpManager, arguments, decompositionBase))
{
yield return i;
}
}
public IVariable Calculate(IMilpManager milpManager, OperationType type, params IVariable[] arguments)
{
if (!SupportsOperation(type, arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, arguments));
if (arguments.Length == 1)
{
return arguments[0];
}
if (MultiplyOnlyConstants(arguments))
{
var result = arguments.Select(a => a.ConstantValue.Value).Aggregate((a, b) => a*b);
if (arguments.All(a => a.IsInteger()))
{
return milpManager.FromConstant((int) result);
}
else
{
return milpManager.FromConstant(result);
}
}
var domain = CalculateDomain(arguments);
if (MultiplyAtMostOneNonconstant(arguments))
{
return arguments.Aggregate((x, y) =>
{
var result = y.IsConstant()
? milpManager.MultiplyVariableByConstant(x, y, domain)
: milpManager.MultiplyVariableByConstant(y, x, domain);
result.ConstantValue = x.ConstantValue*y.ConstantValue;
result.Expression = $"{x.FullExpression()} * {y.FullExpression()}";
return result;
});
}
if (MultiplyBinaryVariables(arguments))
{
return milpManager.Operation(OperationType.Conjunction, arguments);
}
return MultiplyIntegers(milpManager, domain, arguments);
}
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 first = arguments[0];
var second = arguments[1];
var isGreater = first.Operation(OperationType.IsGreaterThan, second);
var isLess = first.Operation(OperationType.IsLessThan, second);
var disjunction = isGreater.Operation(OperationType.Disjunction, isLess);
disjunction.ConstantValue = arguments.All(a => a.ConstantValue.HasValue)
? arguments[0].ConstantValue != arguments[1].ConstantValue ? 1 : 0
: (double?)null;
disjunction.Expression = $"{arguments[0].FullExpression()} ?!= {arguments[1].FullExpression()}";
return disjunction;
}
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;
}
