public override ISolverResult Solve(IAlgorithm tspSolvingAlgorithm)
{
var context = SolvingTimeContext.Instance;
Statistics = new BasicSolverStatistics();
var resultAccumulator = new SolverResult();
var bestPath = new Path(new List <int>(), new ConstCostCalculationStrategy(int.MaxValue));
for (var i = 0; i < MslsRepeatAmount; i++)
{
using (context)
{
for (var j = 0; j < InsideAlgorithmRepeatAmount; j++)
{
var startNode = _randomGenerator.Next(0, CompleteGraph.NodesCount - 1);
var pathAccumulator = _internalSolver.Solve(_internalAlgorithm, startNode);
var localPath = pathAccumulator.Paths[0];
localPath = tspSolvingAlgorithm.Solve(localPath.Nodes.First(), CompleteGraph, localPath);
if (localPath.Cost < bestPath.Cost)
{
bestPath = localPath;
}
}
Statistics.UpdateSolvingResults(bestPath, context.Elapsed);
resultAccumulator.AddPath(bestPath);
}
}
return(resultAccumulator);
}
public override ISolverResult Solve(IAlgorithm tspSolvingAlgorithm, ISolverResult solverResult)
{
Statistics = new BasicSolverStatistics();
ISet <Path> initialPopulation = new HashSet <Path>(solverResult.Paths);
var optimalChilderens = new SolverResult();
_solverStopwatch.Start();
var localStopwatch = new Stopwatch();
while (_solverStopwatch.ElapsedMilliseconds < _solvingTime)
{
var parents = _selector.Select(initialPopulation);
var child = _recombinator.Recombine(parents.Item1, parents.Item2);
localStopwatch.Start();
var optimalChild = tspSolvingAlgorithm.Solve(StartNode(child), CompleteGraph, child);
localStopwatch.Stop();
optimalChilderens.AddPath(optimalChild);
initialPopulation = EnhancePopulation(optimalChild, initialPopulation);
Statistics.UpdateSolvingResults(optimalChild, localStopwatch.Elapsed);
localStopwatch.Reset();
}
_solverStopwatch.Reset();
return(optimalChilderens);
}
public override ISolverResult Solve(IAlgorithm tspSolvingAlgorithm)
{
var context = SolvingTimeContext.Instance;
Statistics = new BasicSolverStatistics();
var resultPathAccumulator = new SolverResult();
for (var i = 0; i < IlsRepeatAmount; i++)
{
Path bestPath;
using (context)
{
var pathAccumulator = _initializationSolver.Solve(_initializationAlgorithm, StartNode);
bestPath = pathAccumulator.Paths[0];
var timer = new Stopwatch();
timer.Start();
var newPath = bestPath;
while (timer.ElapsedMilliseconds < AlgorithmSolveTimeMs)
{
for (var j = 0; j < PerturbanceLength; j++)
{
var move = GetRandomMove(newPath, CompleteGraph);
newPath = move.Move(bestPath);
}
var solvedPath = tspSolvingAlgorithm.Solve(bestPath.Nodes.First(), CompleteGraph, bestPath);
if (solvedPath.Cost >= bestPath.Cost)
{
continue;
}
bestPath = newPath;
}
}
resultPathAccumulator.AddPath(bestPath);
Statistics.UpdateSolvingResults(bestPath, context.Elapsed);
Console.WriteLine(i + " / 10");
}
return(resultPathAccumulator);
}
public override ISolverResult Solve(IAlgorithm tspSolvingAlgorithm, ISolverResult solverResult)
{
Statistics = new BasicSolverStatistics();
var newAccumulator = new SolverResult();
foreach (var path in solverResult.Paths)
{
var context = SolvingTimeContext.Instance;
Path localyBestPath;
using (context)
{
localyBestPath = tspSolvingAlgorithm.Solve(SelectStartNode(path), CompleteGraph, path);
}
newAccumulator.AddPath(localyBestPath);
Statistics.UpdateSolvingResults(localyBestPath, context.Elapsed);
}
return(newAccumulator);
}
public static void Main(string[] args)
{
var buildConfig = BuildConfiguration();
var config = buildConfig.GetSection(nameof(AppConfiguration));
var dataPath = config["data"];
var resultPath = config["results"];
var graphEdges = System.IO.Path.Combine(dataPath, config["graphEdges"]);
var graphCoordinates = System.IO.Path.Combine(dataPath, config["graphCoordinates"]);
var dataLoader = new GraphLoader(graphEdges, 100);
var graph = dataLoader.Load();
var calculationStrategies = new ISimilarityCalculationStrategy[]
{ new EdgeSimillarityStrategy(), new NodeSimilarityStrategy() };
var simpleSolver = new TspSolver(graph);
var localSearchSolver = new TspLocalSearchSolver(graph);
var edgeFinder = new GraspEdgeFinder(3);
var evolutinarySolver = new EvolutionarySolver(graph,
new Recombinator(new SimilarityFinder(calculationStrategies), Steps, graph),
new Selector(), 41000);
var localSearch = new LocalSearchAlgorithm(Steps, edgeFinder);
var stats = new BasicSolverStatistics();
var bestCost = int.MaxValue;
ISolverStatistics bestStatistics = new BasicSolverStatistics();
for (var i = 0; i < 10; i++)
{
var generatedPaths = simpleSolver.Solve(new RandomPathAlgorithm(Steps, edgeFinder));
generatedPaths = localSearchSolver.Solve(localSearch, generatedPaths);
evolutinarySolver.Solve(localSearch, generatedPaths);
if (evolutinarySolver.SolvingStatistics.BestPath.Cost < bestCost)
{
bestCost = evolutinarySolver.SolvingStatistics.BestPath.Cost;
bestStatistics = evolutinarySolver.SolvingStatistics;
}
stats.UpdateSolvingResults(evolutinarySolver.SolvingStatistics.BestPath, evolutinarySolver.SolvingStatistics.MeanSolvingTime);
}
var statsPrinter = new FilePrinter(resultPath, "evo_stats.res");
statsPrinter.Print(stats.ToString());
var output = new StringBuilder();
output.AppendLine($"{"Id".PadRight(4)}\tCost\tTime");
for (var i = 0; i < bestStatistics.Costs.Count; i++)
{
output.AppendLine($"{i.ToString().PadRight(4)}\t{bestStatistics.Costs[i].ToString().PadRight(4)}\t{bestStatistics.SolvingTimes[i].Milliseconds:D}");
}
var evoResultsPrinter = new FilePrinter(resultPath, "evolutionary_results.res");
evoResultsPrinter.Print(output.ToString());
Console.WriteLine("Evolutionary solver ended his work!");
//SimilaritySolver(resultPath, graph, calculationStrategies, edgeFinder);
}