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 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);
}
private IVariable MultiplyNonBinaryIntegers(IMilpManager baseMilpManager, IVariable[] nonBinaries, Domain domain)
{
var first = nonBinaries[0];
var second = nonBinaries[1];
var mightBeNegatives = first.Domain == Domain.AnyInteger || first.Domain == Domain.AnyConstantInteger ||
second.Domain == Domain.AnyInteger || second.Domain == Domain.AnyConstantInteger;
first = MakePositiveIfNeeded(first);
second = MakePositiveIfNeeded(second);
var zero = baseMilpManager.FromConstant(0);
var result = MakeLongMultiplication(baseMilpManager, domain, zero, second, first);
result = FixSign(baseMilpManager, nonBinaries, mightBeNegatives, zero, result);
result = result.ChangeDomain(domain);
return result.Operation(OperationType.Multiplication, nonBinaries.Skip(2).ToArray());
}
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 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 MsfMilpVariable(IMilpManager milpManager, string name, Domain domain)
{
MilpManager = milpManager;
Name = name;
Domain = domain;
}
protected override IVariable InternalSumVariables(IVariable first, IVariable second, Domain domain)
{
var firstVariable = (MsfMilpVariable) first;
var secondVariable = (MsfMilpVariable) second;
return new MsfMilpVariable(this, NewVariableName(), domain)
{
Term = firstVariable.Term + secondVariable.Term
};
}
protected override IVariable InternalNegateVariable(IVariable variable, Domain domain)
{
var casted = (MsfMilpVariable) variable;
return new MsfMilpVariable(this, NewVariableName(), domain)
{
Term = -casted.Term
};
}
protected override IVariable InternalMultiplyVariableByConstant(IVariable variable, IVariable constant, Domain domain)
{
return new MsfMilpVariable(this, NewVariableName(), domain)
{
Term = ((MsfMilpVariable) variable).Term*((MsfMilpVariable) constant).Term
};
}
protected override IVariable InternalFromConstant(string name, double value, Domain domain)
{
var variable = new MsfMilpVariable(this, name, domain) { Term = 1 * value };
return variable;
}
protected override IVariable InternalCreate(string name, Domain domain)
{
var variable = new MsfMilpVariable(this, name, domain);
var msfDomain = (domain == Domain.BinaryConstantInteger ||
domain == Domain.BinaryInteger)
? Microsoft.SolverFoundation.Services.Domain.Boolean
: (domain == Domain.PositiveOrZeroConstantInteger || domain == Domain.PositiveOrZeroInteger)
? Microsoft.SolverFoundation.Services.Domain.IntegerRange(0, Int64.MaxValue)
: (domain == Domain.PositiveOrZeroConstantReal || domain == Domain.PositiveOrZeroReal)
? Microsoft.SolverFoundation.Services.Domain.RealNonnegative
: (domain == Domain.AnyConstantInteger || domain == Domain.AnyInteger)
? Microsoft.SolverFoundation.Services.Domain.IntegerRange(Int64.MinValue, Int64.MaxValue)
: Microsoft.SolverFoundation.Services.Domain.Real;
variable.Decision = new Decision(msfDomain, name);
Solver.AddDecision(variable.Decision);
variable.Term = 1*variable.Decision;
return variable;
}
private IVariable MultiplyNonBinaryIntegers(IMilpManager baseMilpManager, IVariable[] nonBinaries, Domain domain)
{
var first = nonBinaries[0];
var second = nonBinaries[1];
var mightBeNegatives = first.Domain == Domain.AnyInteger || first.Domain == Domain.AnyConstantInteger ||
second.Domain == Domain.AnyInteger || second.Domain == Domain.AnyConstantInteger;
first = MakePositiveIfNeeded(first);
second = MakePositiveIfNeeded(second);
var zero = baseMilpManager.FromConstant(0);
var result = MakeLongMultiplication(baseMilpManager, domain, zero, second, first);
result = FixSign(baseMilpManager, nonBinaries, mightBeNegatives, zero, result);
result = result.ChangeDomain(domain);
return(result.Operation(OperationType.Multiplication, nonBinaries.Skip(2).ToArray()));
}
