public static void Main()
{
var a = new VariableInteger("a", 0, 9);
var b = new VariableInteger("b", 0, 9);
var c = new VariableInteger("c", 0, 9);
var d = new VariableInteger("d", 0, 9);
var e = new VariableInteger("e", 0, 9);
var f = new VariableInteger("f", 0, 9);
var g = new VariableInteger("g", 0, 9);
var h = new VariableInteger("h", 0, 9);
var optimise = new VariableInteger("optimise", 0, 72);
var array = new ConstrainedArray(new int[] { 0, 23, 52, 62, 75, 73, 47, 20, 87, 27 });
var constraints = new List <IConstraint>
{
new AllDifferentInteger(new [] { a, b, c, d }),
new AllDifferentInteger(new [] { e, f, g, h }),
new ConstraintInteger(a + b < 10),
new ConstraintInteger(c + d > 15),
new ConstraintInteger(h > e),
new ConstraintInteger(array[a] < 40),
new ConstraintInteger(optimise == a + b + c + d + e + f + g + h)
};
var variables = new[] { a, b, c, d, e, f, g, h, optimise };
IState <int> state = new StateInteger(variables, constraints);
StateOperationResult searchResult;
var solution = default(IDictionary <string, IVariable <int> >);
state.StartSearch(out searchResult, optimise, out solution, 2);
Console.WriteLine("a: {0}", solution["a"]);
Console.WriteLine("b: {0}", solution["b"]);
Console.WriteLine("c: {0}", solution["c"]);
Console.WriteLine("d: {0}", solution["d"]);
Console.WriteLine("e: {0}", solution["e"]);
Console.WriteLine("f: {0}", solution["f"]);
Console.WriteLine("g: {0}", solution["g"]);
Console.WriteLine("h: {0}\n", solution["h"]);
Console.WriteLine("Optimised Variable: {0}\n", solution["optimise"]);
Console.WriteLine("Runtime:\t{0}\nBacktracks:\t{1}\n", state.Runtime, state.Backtracks);
Console.ReadKey();
}
public static Signal CreateSignal(string name, ISubtypeIndication si)
{
if (si is ResolvedSubtypeIndication)
{
Signal res = CreateSignal(name, (si as ResolvedSubtypeIndication).BaseType);
return(res);
}
if (si is RangeSubtypeIndication)
{
Signal res = CreateSignal(name, (si as RangeSubtypeIndication).BaseType);
return(res);
}
if (si is IndexSubtypeIndication)
{
Signal res = CreateUnconstrainedArraySignal(name, si as IndexSubtypeIndication);
return(res);
}
if (si is Subtype)
{
return(CreateSignal(name, (si as Subtype).SubtypeIndication));
}
if (si is IntegerType)
{
ModellingType resType = ModellingType.CreateModellingType(si as IntegerType);
IntegerAbstractValueConvertor conv = new IntegerAbstractValueConvertor(resType);
AbstractSimpleSignalDump <int> resDump = new AbstractSimpleSignalDump <int>(name, resType, conv);
Signal resSignal = new Signal(resDump);
return(resSignal);
}
if (si is RealType)
{
ModellingType resType = ModellingType.CreateModellingType(si as RealType);
RealAbstractValueConvertor conv = new RealAbstractValueConvertor(resType);
AbstractSimpleSignalDump <double> resDump = new AbstractSimpleSignalDump <double>(name, resType, conv);
Signal resSignal = new Signal(resDump);
return(resSignal);
}
if (si is PhysicalType)
{
ModellingType resType = ModellingType.CreateModellingType(si as PhysicalType);
PhysicalAbstractValueConvertor conv = new PhysicalAbstractValueConvertor(resType);
AbstractSimpleSignalDump <PhysicalLiteral> resDump = new AbstractSimpleSignalDump <PhysicalLiteral>(name, resType, conv);
Signal resSignal = new Signal(resDump);
return(resSignal);
}
if (si is RecordType)
{
RecordType recType = si as RecordType;
ModellingType resType = ModellingType.CreateModellingType(recType);
List <AbstractSignalDump> dumps = new List <AbstractSignalDump>();
List <Signal> childrens = new List <Signal>();
foreach (var el in recType.Elements)
{
foreach (string s in el.Identifiers)
{
Signal newSignal = CreateSignal(s, el.Type);
childrens.Add(newSignal);
dumps.Add(newSignal.Dump);
}
}
SignalScopeDump resDump = new SignalScopeDump(name, resType, dumps);
Signal resSignal = new Signal(resDump);
return(resSignal);
}
if (si is EnumerationType)
{
ModellingType resType = ModellingType.CreateModellingType(si as EnumerationType);
EnumerationAbstractValueConvertor conv;
if (si == StdLogic1164.STD_ULOGIC)
{
conv = new STD_ULOGIC_AbstractValueConvertor(resType);
}
else
{
if (si == StdLogic1164.STD_LOGIC)
{
conv = new STD_LOGIC_AbstractValueConvertor(resType);
}
else
{
conv = new EnumerationAbstractValueConvertor(resType);
}
}
AbstractSimpleSignalDump <EnumerationLiteral> resDump = new AbstractSimpleSignalDump <EnumerationLiteral>(name, resType, conv);
Signal resSignal = new Signal(resDump);
return(resSignal);
}
if (si is ConstrainedArray)
{
ConstrainedArray arrayType = si as ConstrainedArray;
ModellingType resType = ModellingType.CreateModellingType(arrayType);
List <AbstractSignalDump> dumps = new List <AbstractSignalDump>();
List <Signal> childrens = new List <Signal>();
ResolvedDiscreteRange[] ranges = resType.Dimension;
int[,] resIndexes = ResolvedDiscreteRange.CombineRanges(ranges);
for (int i = 0; i < resIndexes.GetLength(0); i++)
{
for (int j = 0; j < resIndexes.GetLength(1); j++)
{
Signal newSignal = CreateSignal(ranges[j][resIndexes[i, j]].ToString(), arrayType.ElementType);
childrens.Add(newSignal);
dumps.Add(newSignal.Dump);
}
}
SignalScopeDump resDump = new SignalScopeDump(name, resType, dumps);
Signal resSignal = new Signal(resDump);
return(resSignal);
}
return(null);
}
static void Main(string[] args)
{
var badnessFactor = 3;
var teams = new[]
{
new Team(0, 3, 1, 0, 0, 0),
new Team(1, 2, 0, 1, 0, 0),
new Team(2, 1, 0, 0, 1, 0),
new Team(3, 0, 0, 0, 0, 1),
new Team(4, 3, 0, 0, 0, 1),
new Team(5, 2, 0, 0, 1, 0),
new Team(6, 1, 0, 1, 0, 0),
new Team(7, 0, 1, 0, 0, 0)
};
Array.Sort(teams, (x, y) => y.Score.CompareTo(x.Score)); //High to low
var rooms = teams.Length / 4;
//Positions[room * position] = TeamId
var positions = new List <VariableInteger>(teams.Length);
for (var i = 0; i < teams.Length; i++)
{
positions.Add(new VariableInteger($"Team_{i}", 0, teams.Length - 1));
}
//Scores[teamId] = current score
var scores = new ConstrainedArray(teams.Select(x => x.Score));
//Optimise positions
var firstProp = new ConstrainedArray(teams.Select(x => x.FirstProp * badnessFactor));
var secondProp = new ConstrainedArray(teams.Select(x => x.SecondProp * badnessFactor));
var firstOpp = new ConstrainedArray(teams.Select(x => x.FirstOpp * badnessFactor));
var secondOpp = new ConstrainedArray(teams.Select(x => x.SecondOpp * badnessFactor));
var maxBadness = firstProp.Union(secondProp).Union(firstOpp).Union(secondOpp).Max() * teams.Length;
var optimise = new VariableInteger("optimise", 0, maxBadness);
//TODO Change optimise to look at the bound and stop if best reached
var variables = new List <VariableInteger>(positions);
variables.Add(optimise);
var constraints = new List <IConstraint> {
new AllDifferentInteger(positions)
};
for (var i = 0; i < rooms - 1; i++)
{
for (var j = 0; j < 4; j++)
{
var x = positions[i * 4 + j];
for (var k = 0; k < 4; k++)
{
var y = positions[(i + 1) * 4 + k];
constraints.Add(new ConstraintInteger(scores[x] >= scores[y]));
}
}
}
constraints.Add(new ConstraintInteger(optimise == maxBadness -
firstProp[positions[0]] - firstOpp[positions[1]] - secondProp[positions[2]] - secondOpp[positions[3]]
));
IState <int> state = new StateInteger(variables, constraints);
StateOperationResult searchResult;
IDictionary <string, IVariable <int> > solution;
state.StartSearch(out searchResult, optimise, out solution, 2);
if (searchResult == StateOperationResult.Unsatisfiable)
{
Console.WriteLine("Could not find a solution");
Console.ReadKey();
return;
}
if (searchResult == StateOperationResult.TimedOut)
{
Console.WriteLine("Search timed out before a solution could be found");
Console.ReadKey();
return;
}
Console.WriteLine("Runtime:\t{0}\nBacktracks:\t{1}\nSolutions:\t{2}", state.Runtime, state.Backtracks, state.NumberOfSolutions);
Console.WriteLine("Badness:\t{0}", solution[optimise.Name].InstantiatedValue);
Console.WriteLine("Room | 1P | 1O | 2P | 2O | Scores ");
for (var i = 0; i < rooms; i++)
{
var fp = solution[positions[i * 4].Name].InstantiatedValue;
var sp = solution[positions[i * 4 + 1].Name].InstantiatedValue;
var fo = solution[positions[i * 4 + 2].Name].InstantiatedValue;
var so = solution[positions[i * 4 + 3].Name].InstantiatedValue;
Console.WriteLine("{0,-5}|{1,3} |{2,3} |{3,3} |{4,3} | {5} {6} {7} {8}", i, fp, sp, fo, so, scores[fp], scores[sp], scores[fo], scores[so]);
}
Console.ReadKey();
}
