protected void RunScenario(string title, string input, Action <FacilityNode> modifyInitialState = null)
{
RunScenario(title, () =>
{
var lines = input.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
// https://regex101.com/
var pattern = new Regex(@"a ([^ -]*)(|-compatible) (generator|microchip)");
var initialState = new FacilityNode()
{
ElevatorFloor = 1, GeneratorFloors = new sbyte[0], MicrochipFloors = new sbyte[0]
};
var types = new List <string>();
for (var i = 0; i < lines.Length; i++)
{
var line = lines[i];
foreach (Match match in pattern.Matches(line))
{
var type = match.Groups[1].Value;
var item = match.Groups[3].Value;
if (!types.Contains(type))
{
types.Add(type);
}
var typeIx = types.IndexOf(type);
while (initialState.GeneratorFloors.Length <= typeIx)
{
initialState.GeneratorFloors = initialState.GeneratorFloors.Concat(new sbyte[] { -1 }).ToArray();
initialState.MicrochipFloors = initialState.MicrochipFloors.Concat(new sbyte[] { -1 }).ToArray();
}
if (item == "generator")
{
initialState.GeneratorFloors[typeIx] = (sbyte)(i + 1);
}
else if (item == "microchip")
{
initialState.MicrochipFloors[typeIx] = (sbyte)(i + 1);
}
else
{
throw new ArgumentException($"item: {item}");
}
}
}
initialState.StaticInfo = new StaticInfo()
{
Floors = lines.Length, TargetFloor = lines.Length, Types = types.ToArray()
};
initialState.StaticInfo.SwapSets =
initialState.GeneratorFloors
.Select((i, ix) => new { ix, g = i, m = initialState.MicrochipFloors[ix] })
.Where(i => i.g == i.m)
.GroupBy(i => i.g, i => i.ix)
.Select(g => g.ToArray()).ToArray();
modifyInitialState?.Invoke(initialState);
var finalState = new ParallelSolver(8).Evaluate(initialState, initialState.Key);
Console.WriteLine($"{title} - moves: {finalState.CurrentCost}");
});
}
public static void Main(string[] args)
{
const int equationsNum = 100000;
const int threadsNum = 1;
var equations = Generator.GenerateEquations(equationsNum);
Console.WriteLine($"Equations num: {equationsNum}\n");
// By default threads num are equal to available processor threads
ParallelSolver.SolveEquations(equations);
Console.WriteLine($"{ParallelSolver.AvailableThreads} " +
$"threads : {ParallelSolver.Watch.ElapsedMilliseconds}ms");
ParallelSolver.SolveEquations(equations, threadsNum);
Console.WriteLine($"{threadsNum}" +
$" threads : {ParallelSolver.Watch.ElapsedMilliseconds}ms");
}
protected void RunScenario(string title, string input)
{
RunScenario(title, () =>
{
var initialState = input.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
.Select(i => i.Split(new [] { '/' }).Select(int.Parse).ToArray())
.ToArray();
var state = new BridgeNode()
{
StaticInfo = new StaticInfo()
{
Pieces = initialState,
MaxStrength = initialState.Sum(i => i.Sum())
},
UsedPieces = new int[0],
};
var best = new ParallelSolver(8).Evaluate(state, state.Key);
Console.WriteLine(-(best.CurrentCost - state.StaticInfo.MaxStrength));
});
}
public static void Main(String[] args)
{
String problem = "ft10";
long timeout = 1000 * 60 * 10;
String[] solverNames = new String[] { "sa", "ibb", "taboo" };
int i = 0;
if (i < args.Length)
{
problem = args[i++];
}
if (i < args.Length)
{
timeout = Int32.Parse(args[i++]) * 1000;
}
if (i < args.Length)
{
solverNames = new String[args.Length - i];
int j = 0;
for (; i < args.Length; i++)
{
solverNames[j++] = args[i];
}
}
Network network = (new JSSPProblem(problem)).network();
if (network == null)
{
return;
}
//int opt = Solver.MINIMIZE | Solver.BETTER;
int opt = Solver.Default;
Solver[] solvers = new Solver[solverNames.Length];
for (i = 0; i < solvers.Length; i++)
{
String name = solverNames[i];
if (name.Equals("sa"))
{
solvers[i] = new SimulatedAnneallingSearch((Network)network.Clone(), opt, name);
}
else if (name.Equals("ibb"))
{
solvers[i] = new IterativeBranchAndBoundSearch((Network)network.Clone(), opt, name);
}
else if (name.Equals("taboo") || name.Equals("tabu"))
{
solvers[i] = new TabooSearch((Network)network.Clone(), opt, name);
}
else if (name.Equals("rw"))
{
solvers[i] = new LocalSearch((Network)network.Clone(), opt, name);
}
else
{
Console.Out.WriteLine("Unknown solver name " + name);
solvers[i] = null;
}
}
Solver all = new ParallelSolver(solvers);
//Monitor monitor = new Monitor();
//monitor.setX(0, (int)(timeout/1000));
//all.setMonitor(monitor);
//SolutionHandler sh=null;
Solution solution = all.FindBest(timeout);
Console.Out.WriteLine(solution);
Console.In.ReadLine();
}
private void button3_Click(object sender, EventArgs e)
{
ParallelSolver.RunAsync();
}
private void button1_Click(object sender, EventArgs e)
{
ParallelSolver.SolveCurrentDocument();
}
public static void Main(String[] args)
{
Network net = new Network();
ft06(net);
String solverName = "ibb";
int opt = Solver.Minimize;
long timeout = 180000;
if (args.Length >= 1)
{
solverName = args[0];
}
Solver solver;
if (solverName.Equals("bb"))
{
solver = new DefaultSolver(net, opt, "bb");
}
else if (solverName.Equals("random"))
{
solver = new LocalSearch(net, opt, "rs");
}
else if (solverName.Equals("sa"))
{
solver = new SimulatedAnneallingSearch(net, opt, "sa");
}
else if (solverName.Equals("ibb"))
{
solver = new IterativeBranchAndBoundSearch(net, opt, "ibb");
}
else if (solverName.Equals("taboo"))
{
solver = new TabooSearch(net, opt, "taboo");
}
else
{
Solver sa = new SimulatedAnneallingSearch((Network)net.Clone(), opt, "sa");
Solver ibb = new IterativeBranchAndBoundSearch((Network)net.Clone(), opt, "ibb");
solver = new ParallelSolver(new Solver[] { sa, ibb });
}
solver.SolverStrategy = Solver.StrategyMethod.Bisect;
//Cream.Monitor monitor = new Monitor();
//monitor.setX(0, (int)(timeout / 1000));
//solver.setMonitor(monitor);
Console.Out.WriteLine("Start " + solver + ", timeout = " + timeout + " msecs");
Solution bestSolution;
int c = 0;
if (true)
{
for (solver.Start(timeout); solver.WaitNext(); solver.Resume())
{
Solution solution = solver.Solution;
Console.Out.WriteLine(++c);
Console.Out.WriteLine(solution);
int value_Renamed = solution.ObjectiveIntValue;
Console.Out.WriteLine(value_Renamed);
Console.Out.WriteLine("=======================");
}
solver.Stop();
bestSolution = solver.BestSolution;
}
else
{
bestSolution = solver.FindBest(timeout);
}
Console.Out.WriteLine("Best = " + bestSolution.ObjectiveIntValue);
Console.Out.WriteLine("Best = " + bestSolution);
Console.In.ReadLine();
}
