public void InitializeTreils_AllRegionsInitializedInRange_Success()
{
var random = new Random(1);
var options = new BaseOptions(numberOfIterations: 100, numberOfRegions: 3, alfa: 1, beta: 5, ro: 0.6, delta: 0.1D);
var verticesWeights = new List <Vertex>
{
new Vertex(0, 4),
new Vertex(1, 3),
new Vertex(2, 8),
new Vertex(3, 7),
new Vertex(4, 5),
new Vertex(5, 3),
new Vertex(6, 6),
new Vertex(7, 7),
new Vertex(8, 2)
};
var mockGraph = new Mock <IGraph>();
mockGraph.SetupGet(prop => prop.NumberOfVertices).Returns(verticesWeights.Count);
mockGraph.SetupGet(prop => prop.VerticesWeights).Returns(verticesWeights);
mockGraph.Setup(prop => prop.EdgesWeights).Returns(new int[verticesWeights.Count, verticesWeights.Count]);
var antSystem = new WeightedAntSystemFragment(random, options, mockGraph.Object);
for (var i = 0; i < options.NumberOfRegions; i++)
{
int velueOfFirstVerticeInRegion = antSystem.Treil[i].Single().Weight;
Assert.IsTrue(velueOfFirstVerticeInRegion <= 8);
Assert.IsTrue(velueOfFirstVerticeInRegion >= 0);
}
}
public void SumOfWeight_AllZerosSet_Success()
{
var random = new Random(1);
var options = new BaseOptions(numberOfIterations: 100, numberOfRegions: 3, alfa: 1, beta: 5, ro: 0.6, delta: 0.1D);
var verticesWeights = new List <Vertex>
{
new Vertex(0, 4),
new Vertex(1, 3),
new Vertex(2, 8),
new Vertex(3, 7),
new Vertex(4, 5),
new Vertex(5, 3),
new Vertex(6, 6),
new Vertex(7, 7),
new Vertex(8, 2)
};
var mockGraph = new Mock <IGraph>();
mockGraph.SetupGet(prop => prop.NumberOfVertices).Returns(verticesWeights.Count);
mockGraph.SetupGet(prop => prop.VerticesWeights).Returns(verticesWeights);
mockGraph.Setup(prop => prop.EdgesWeights).Returns(new int[verticesWeights.Count, verticesWeights.Count]);
var antSystem = new WeightedAntSystemFragment(random, options, mockGraph.Object);
var sumOfWeights = antSystem.WeightOfColonies.Sum();
Assert.AreEqual(15, sumOfWeights);
}
public void GetNextColony_AddVertex_Success()
{
var random = new Random(1);
var options = new BaseOptions(numberOfIterations: 100, numberOfRegions: 3, alfa: 1, beta: 5, ro: 0.6, delta: 0.1D);
var verticesWeights = new List <Vertex>
{
new Vertex(0, 4),
new Vertex(1, 3),
new Vertex(2, 8),
new Vertex(3, 7),
new Vertex(4, 5),
new Vertex(5, 3),
new Vertex(6, 6),
new Vertex(7, 7),
new Vertex(8, 2)
};
var mockGraph = new Mock <IGraph>();
mockGraph.SetupGet(prop => prop.NumberOfVertices).Returns(verticesWeights.Count);
mockGraph.SetupGet(prop => prop.VerticesWeights).Returns(verticesWeights);
mockGraph.Setup(prop => prop.EdgesWeights).Returns(new int[verticesWeights.Count, verticesWeights.Count]);
var antSystem = new WeightedAntSystemFragment(random, options, mockGraph.Object);
antSystem.AddFreeVertexToTreil(0, antSystem.FreeVertices.First());
var nextColonyIndex = antSystem.GetNextColony();
var nextColonyWeightSum = antSystem.WeightOfColonies[nextColonyIndex];
for (int i = 0; i < options.NumberOfRegions; i++)
{
Assert.IsTrue(antSystem.WeightOfColonies[i] >= nextColonyWeightSum);
}
}
public void CalculateProbability_Success()
{
var random = new Random(1);
var options = new BaseOptions(numberOfIterations: 100, numberOfRegions: 3, alfa: 1, beta: 5, ro: 0.6, delta: 0.1D);
var verticesWeights = new List <Vertex>
{
new Vertex(0, 4),
new Vertex(1, 3),
new Vertex(2, 8),
new Vertex(3, 7),
new Vertex(4, 5),
new Vertex(5, 3),
new Vertex(6, 6),
new Vertex(7, 7),
new Vertex(8, 2)
};
var mockGraph = new Mock <IGraph>();
mockGraph.SetupGet(prop => prop.NumberOfVertices).Returns(verticesWeights.Count);
mockGraph.SetupGet(prop => prop.VerticesWeights).Returns(verticesWeights);
mockGraph.Setup(prop => prop.EdgesWeights).Returns(new int[verticesWeights.Count, verticesWeights.Count]);
mockGraph.Setup(prop => prop.PheromoneMatrix).Returns(new double[verticesWeights.Count, verticesWeights.Count]);
var antSystem = new WeightedAntSystemFragment(random, options, mockGraph.Object);
var probability = antSystem.CalculateProbability(1);
Assert.AreEqual(probability[0], 0);
}
public void SumaKriterijumaOptimalnosti_Initialized_Success()
{
var random = new Random(1);
var options = new BaseOptions(numberOfIterations: 100, numberOfRegions: 3, alfa: 1, beta: 5, ro: 0.6, delta: 0.1D);
var verticesWeights = new List <Vertex>
{
new Vertex(0, 4),
new Vertex(1, 3),
new Vertex(2, 8),
new Vertex(3, 7),
new Vertex(4, 5),
new Vertex(5, 3),
new Vertex(6, 6),
new Vertex(7, 7),
new Vertex(8, 2)
};
var mockGraph = new Mock <IGraph>();
mockGraph.SetupGet(prop => prop.NumberOfVertices).Returns(verticesWeights.Count);
mockGraph.SetupGet(prop => prop.VerticesWeights).Returns(verticesWeights);
mockGraph.Setup(prop => prop.EdgesWeights).Returns(new int[verticesWeights.Count, verticesWeights.Count]);
var antSystem = new WeightedAntSystemFragment(random, options, mockGraph.Object);
Assert.IsNotNull(antSystem.EdgesWeightOfColonies);
for (var i = 0; i < options.NumberOfRegions; i++)
{
Assert.AreEqual(0, antSystem.EdgesWeightOfColonies[i]);
}
}
public void AddFreeVertexToTreil_AddVertex_Success()
{
var random = new Random(1);
var options = new BaseOptions(numberOfIterations: 100, numberOfRegions: 3, alfa: 1, beta: 5, ro: 0.6, delta: 0.1D);
var verticesWeights = new List <Vertex>
{
new Vertex(0, 4),
new Vertex(1, 3),
new Vertex(2, 8),
new Vertex(3, 7),
new Vertex(4, 5),
new Vertex(5, 3),
new Vertex(6, 6),
new Vertex(7, 7),
new Vertex(8, 2)
};
var mockGraph = new Mock <IGraph>();
mockGraph.SetupGet(prop => prop.NumberOfVertices).Returns(verticesWeights.Count);
mockGraph.SetupGet(prop => prop.VerticesWeights).Returns(verticesWeights);
mockGraph.Setup(prop => prop.EdgesWeights).Returns(new int[verticesWeights.Count, verticesWeights.Count]);
var antSystem = new WeightedAntSystemFragment(random, options, mockGraph.Object);
antSystem.AddFreeVertexToTreil(0, antSystem.FreeVertices.First());
Assert.AreEqual(2, antSystem.Treil[0].Count);
Assert.AreEqual(1, antSystem.Treil[1].Count);
Assert.AreEqual(1, antSystem.Treil[2].Count);
Assert.AreEqual(4, antSystem.PassedVertices.Count);
}
public AntSystemParallelOptimisation(Random rnd, OptionsParallelOptimisation options, IGraph graph)
{
_rnd = rnd;
_graph = graph;
_options = options;
AntSystemFragments = new WeightedAntSystemFragment[options.NumberOfInterSections];
for (var i = 0; i < options.NumberOfInterSections; i++)
{
AntSystemFragments[i] = new WeightedAntSystemFragment(rnd, options, graph);
}
}
public override ResultData GetQuality()
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var result = new Result(double.MinValue);
var bestCostIteration = 0;
while (Options.NumberOfIterations > 0)
{
Log.Debug("Iteration: " + Options.NumberOfIterations);
var antSystemFragment = new WeightedAntSystemFragment(Rnd, Options, Graph);
var antSystem = new AntSystemBasic(antSystemFragment, Options, Graph);
for (var vertexIndex = Options.NumberOfRegions; vertexIndex < Graph.NumberOfVertices; vertexIndex++)
{
var nextColony = antSystem.GetNextColony();
decimal[] probability = antSystem.CalculateProbability(nextColony);
var chosenVertexIndex = Roulette(probability);
var chosenVertex = Graph.VerticesWeights[chosenVertexIndex];
antSystem.AddFreeVertexToTreil(nextColony, chosenVertex);
}
var bestFragment = antSystem.UpdatePhermone();
var newQuality = bestFragment.SumOfOptimalityCriterion;
Console.WriteLine($"New quality: {newQuality}");
//Log.Debug($"New quality: {newQuality}");
// Save the best results.
if (result.Quality < newQuality)
{
result = new Result(newQuality, bestFragment.Treil);
bestCostIteration = Options.NumberOfIterations;
}
Options.NumberOfIterations--;
}
stopwatch.Stop();
//Log.Debug($"Best result: {result.Quality}");
var qualityResult = new ResultData((int)result.Quality, bestCostIteration, stopwatch.ElapsedMilliseconds);
return(qualityResult);
}
public override ResultData GetQuality()
{
var bestResult = new Result(double.MinValue);
WeightedAntSystemFragment previousBestFragment = null;
var options = (OptionsParallelOptimisation)Options;
while (Options.NumberOfIterations > 0)
{
var antSystem = new AntSystemParallelOptimisationWithInheritance(Rnd, options, Graph, previousBestFragment);
for (short interSectionIndex = 0;
interSectionIndex < options.NumberOfInterSections;
interSectionIndex++)
{
for (var vertexIndex = Options.NumberOfRegions;
vertexIndex < Graph.NumberOfVertices;
vertexIndex++)
{
var nextColony = antSystem.GetNextColony(interSectionIndex);
decimal[] probability = antSystem.CalculateProbability(interSectionIndex, nextColony);
var chosenVertexIndex = Roulette(probability);
var chosenVertex = Graph.VerticesWeights[chosenVertexIndex];
antSystem.AddFreeVertexToTreil(interSectionIndex, nextColony, chosenVertex);
}
}
previousBestFragment = antSystem.UpdatePhermone();
var newQuality = previousBestFragment.SumOfOptimalityCriterion;
// Save the best results.
if (bestResult.Quality < newQuality)
{
bestResult = new Result(newQuality, previousBestFragment.Treil);
}
Options.NumberOfIterations--;
}
//return bestResult;
return(null);
}
public AntSystemParallelOptimisationWithInheritance(Random rnd, OptionsParallelOptimisation options, IGraph graph, WeightedAntSystemFragment previousBestFragment)
{
_rnd = rnd;
_graph = graph;
_options = options;
AntSystemFragments = new WeightedAntSystemFragment[options.NumberOfInterSections];
short index = 0;
if (previousBestFragment != null)
{
AntSystemFragments[0] = previousBestFragment;
index = 1;
}
for (; index < options.NumberOfInterSections; index++)
{
AntSystemFragments[index] = new WeightedAntSystemFragment(rnd, options, _graph);
}
}
public void WeightsOfColonies_Initialized_Success()
{
var random = new Random(1);
var options = new BaseOptions(numberOfIterations: 100, numberOfRegions: 3, alfa: 1, beta: 5, ro: 0.6, delta: 0.1D);
var verticesWeights = new List <Vertex>
{
new Vertex(0, 4),
new Vertex(1, 3),
new Vertex(2, 8),
new Vertex(3, 7),
new Vertex(4, 5),
new Vertex(5, 3),
new Vertex(6, 6),
new Vertex(7, 7),
new Vertex(8, 2)
};
var mockGraph = new Mock <IGraph>();
mockGraph.SetupGet(prop => prop.NumberOfVertices).Returns(verticesWeights.Count);
mockGraph.SetupGet(prop => prop.VerticesWeights).Returns(verticesWeights);
mockGraph.Setup(prop => prop.EdgesWeights).Returns(new int[verticesWeights.Count, verticesWeights.Count]);
var antSystem = new WeightedAntSystemFragment(random, options, mockGraph.Object);
Assert.IsNotNull(antSystem.WeightOfColonies);
Assert.AreEqual(8, antSystem.WeightOfColonies[0]);
Assert.AreEqual(4, antSystem.WeightOfColonies[1]);
Assert.AreEqual(3, antSystem.WeightOfColonies[2]);
/*
* for (int i = 0; i < options.NumberOfRegions; i++)
* {
* Assert.AreEqual(antSystem.Treil[i].First().Weight, antSystem.WeightOfColonies[i]);
* }
*/
}
