private void button2_Click(object sender, EventArgs e)
{
int cities = numCities;
int ants = Convert.ToInt32(this.ants.Text);
AntColony colony = new AntColony(cities, ants, graph.dists);
int[] trail = colony.FindBestTrail();
var bestTrails = colony.ConvertTrails();
var bestIterations = colony.ConvertIter();
res = new Results();
for (int i = 0; i < bestTrails.Count; i++)
{
res.AddBestTrail(bestTrails[i], bestIterations[i]);
}
res.AddBestTrail(" ", " ");
string str = "";
for (int i = 0; i < trail.Length; i++)
{
str += trail[i].ToString() + " -> ";
}
str += (colony.bestLength * 100).ToString();
res.AddBestTrail(str, colony.bestIteration.ToString());
res.ShowDialog();
}
static void begin(LowerTriangularMatrix <double> lt, int start, int antCount, double alpha,
double beta, double pheromoneEvaporationCoef, double pheromoneConstant, int maxIters,
Queue <IterationContext> cq)
{
AntColony ac = new AntColony(lt, start, antCount, alpha, beta, pheromoneEvaporationCoef,
pheromoneConstant, maxIters, cq);
ac.begin();
int currIter = 0;
while (currIter < maxIters - 1)
{
IterationContext it;
while (cq.TryDequeue(out it) == false)
{
;
}
currIter = it.currIter;
Console.WriteLine("" + it.currIter);
}
var path = string.Join("=>", ac.shortestPath);
var dist = ac.shrotestDistance;
Console.WriteLine($"Shortest path has length of {dist} and it is: {path}");
}
static void Main(string[] args)
{
var algorithm = new AntColony();
var inputPermutation = new List<int> { 1, 2, 3 };
algorithm.RunAlgorithm(inputPermutation);
}
static void Main(string[] args)
{
var algorithm = new AntColony();
var inputPermutation = new List <int> {
1, 2, 3
};
algorithm.RunAlgorithm(inputPermutation);
}
public static void RunColony(TrailSystem <TravelToCity> system, Func <Ant <TravelToCity> > createAnt)
{
var result = AntColony.OptimizeCSharp(createAnt,
50, 50, system);
foreach (var x in result)
{
Console.WriteLine(x.Destination.Name);
}
}
/// <summary>
/// Checking if Drone reached Queen
/// </summary>
/// <returns>Returns bool</returns>
public bool ReachedQueen()
{
var queenPosition = AntColony.GetTheQueen().GetPosition();
if (Coordinates.DistanceToCoordinate(queenPosition) == 0)
{
return(true);
}
return(false);
}
static void OnPostColonyIteration(object sender, EventArgs e)
{
AntColony <DRComponent> colony = sender as AntColony <DRComponent>;
Console.WriteLine("------------------------");
Console.WriteLine("Iteration [" + colony.CurrentIteration.ToString() + "]");
Console.WriteLine("------------------------");
Console.WriteLine("Iteration Best: " + Math.Round(colony.IterationBestAnt.Solution.Quality, 2).ToString());
Console.WriteLine("Global Best: " + Math.Round(colony.BestAnt.Solution.Quality, 2).ToString());
Console.WriteLine("------------------------");
}
/// <summary>
/// Drone tries mating with Queen
/// </summary>
public void TryMating()
{
if (AntColony.GetTheQueen().IsInGoodMood())
{
Console.WriteLine("Drone says: HALLELUJAH");
_isMating = true;
}
else if (!AntColony.GetTheQueen().IsInGoodMood() && !_isMating)
{
Console.WriteLine("Drone says: :(\n");
Coordinates = GetPositionAfterKickout();
}
}
/// <summary>
/// Moves Drone towards Queen
/// </summary>
/// <returns>Returns Position</returns>
public Position MoveTowardsQueen()
{
var nextPosition = Coordinates.NextCoordinatesInDirection(DirectionExtensions.GetRandomDirection());
var queenPosition = AntColony.GetTheQueen().GetPosition();
while (nextPosition.DistanceToCoordinate(queenPosition) > Coordinates.DistanceToCoordinate(queenPosition))
{
nextPosition = Coordinates.NextCoordinatesInDirection(DirectionExtensions.GetRandomDirection());
}
Coordinates = nextPosition;
return(Coordinates);
}
///<summary>
/// Sets new position after kickout
///</summary>
///<returns>Returns new Drone position</returns>
public Position GetPositionAfterKickout()
{
var kickOutPositions = new List <Position>();
for (int x = 0; x < AntColony.GetWidth(); x++)
{
kickOutPositions.Add(new Position(x, 0));
kickOutPositions.Add(new Position(x, AntColony.GetWidth() - 1));
kickOutPositions.Add(new Position(0, x));
kickOutPositions.Add(new Position(AntColony.GetWidth() - 1, x));
}
return(kickOutPositions[new Random().Next(kickOutPositions.Count)]);
}
/// <summary>
/// Checks validity of Worker move
/// </summary>
/// <param name="next"> next </param>
/// <returns>
/// Returns bool
/// </returns>
public bool IsMoveValid(Position next)
{
if (next.X >= AntColony.GetWidth() || next.X < 0)
{
return(false);
}
else if (next.Y >= AntColony.GetWidth() || next.Y < 0)
{
return(false);
}
else
{
return(true);
}
}
public void startAlgorithm()
{
stoped = false;
if (aco != null)
{
animationControler.reset();
}
iterations = new Queue <IterationContext>();
aco = new AntColony(getMatrix(), 0, antNumber_, alpha_, beta_,
coefficient_, feremonAmount_, iterationCount_, iterations);
aco.begin();
Debug.Log("i started");
StartCoroutine(waitForIterCtx());
}
public void SearchingPathWithGraphV1ShouldReturnBestTrail()
{
const int numberOfAnts = 4;
const int alpha = 3;
const int beta = 2;
const double rhoFactor = 0.01;
const double qFactor = 2.0;
var map = Map.Create().ReadCitiesFromJsonFile("Data/v1Graph.json");
var antColony = new AntColony(numberOfAnts, map, alpha, beta, rhoFactor, qFactor, _randomizer);
var bestTrail = antColony.LetAntsToFindBestTrail(50);
var bestDistance = 43;
bestTrail.Distance.ShouldBeEquivalentTo(bestDistance);
ShowTrail(bestTrail);
}
static void OnPostColonyIteration(object sender, EventArgs e)
{
if (sender is AntColony <ConnectionDC> )
{
AntColony <ConnectionDC> colony = sender as AntColony <ConnectionDC>;
Console.WriteLine("------------------------");
Console.WriteLine("Iteration [" + colony.CurrentIteration.ToString() + "]");
Console.WriteLine("------------------------");
Console.WriteLine("Iteration Best: " + Math.Round(colony.IterationBestAnt.Solution.Quality, 2).ToString());
Console.WriteLine("Global Best: " + Math.Round(colony.BestAnt.Solution.Quality, 2).ToString());
Console.WriteLine("------------------------");
}
if (sender is AntColony <double> )
{
ContinuousACO.Algorithms.ACO_R acor = sender as ContinuousACO.Algorithms.ACO_R;
Console.WriteLine("Iteration [" + acor.CurrentIteration.ToString() + "] " + Math.Round(acor.GlobalBest.Quality, 2).ToString());
}
}
public void SearchingPathWithRandomizedMapShouldReturnBestTrail()
{
const int numberOfAnts = 4;
const int numberOfCities = 10;
const int alpha = 3;
const int beta = 2;
const double rhoFactor = 0.01;
const double qFactor = 2.0;
var map = Map.Create().AddCitiesWithRandomDistance(numberOfCities, _randomizer, new Range(1, 8));
var antColony = new AntColony(numberOfAnts, map, alpha, beta, rhoFactor, qFactor, _randomizer);
var bestTrail = antColony.LetAntsToFindBestTrail(30);
var bestDistance = 20;
bestTrail.Distance.ShouldBeEquivalentTo(bestDistance);
ShowTrail(bestTrail);
}
/// <summary>
/// Main method
/// </summary>
public static void Main()
{
View.PrintFile("Title.txt");
View.PrintFile("Ant.txt");
Console.WriteLine("Provide colony width: \n");
var area = GetInput();
AntColony colony = new AntColony(area);
colony.CreateEmptyColony();
Console.WriteLine("Provide number of workers: \n");
var workers = GetInput();
Console.WriteLine("Provide number of soldiers: \n");
var soldiers = GetInput();
Console.WriteLine("Provide number of drones: \n");
var drones = GetInput();
Console.Clear();
colony.GenerateAnts(workers, soldiers, drones);
Console.WriteLine("Hello Ants!");
Console.WriteLine("Press Enter to update the colony\n");
colony.PrintColony();
Console.WriteLine("Colony statistics: \n");
Console.WriteLine("All ants: " + (workers + drones + soldiers + 1));
Console.WriteLine("Workers * : " + workers + "\n" + "Soldiers @ : " + soldiers + "\n" + "Drones # : " + drones + "\n" + "The Queen & " + "\n");
Console.WriteLine("Colony area: " + area + "x" + area);
while (IsUpdated())
{
Console.Clear();
Console.WriteLine("Mating status: \n");
colony.UpdateAndPrintColony();
Console.WriteLine("Colony statistics: \n");
Console.WriteLine("All ants: " + (workers + drones + soldiers + 1));
Console.WriteLine("Workers * : " + workers + "\n" + "Soldiers @ : " + soldiers + "\n" + "Drones # : " + drones + "\n" + "The Queen & " + "\n");
Console.WriteLine("Colony area: " + area + "x" + area + "\n");
Console.WriteLine("Press Enter to Update the colony \nPress 'q' to finish the simulation\n");
}
}
private static void abclassifier_OnPostColonyIteration(object sender, EventArgs e)
{
if (sender is AntColony <Edge> )
{
AntColony <Edge> colony = sender as AntColony <Edge>;
Console.WriteLine("------------------------");
Console.WriteLine("Iteration [" + colony.CurrentIteration.ToString() + "]");
Console.WriteLine("------------------------");
Console.WriteLine("Iteration Best: " + Math.Round(colony.IterationBestAnt.Solution.Quality, 5).ToString());
Console.WriteLine("Global Best: " + Math.Round(colony.BestAnt.Solution.Quality, 5).ToString());
Console.WriteLine("------------------------");
}
if (sender is AntColony <VariableTypeAssignment> )
{
AntColony <VariableTypeAssignment> colony = sender as AntColony <VariableTypeAssignment>;
Console.WriteLine("------------------------");
Console.WriteLine("Iteration [" + colony.CurrentIteration.ToString() + "]");
Console.WriteLine("------------------------");
Console.WriteLine("Iteration Best: " + Math.Round(colony.IterationBestAnt.Solution.Quality, 5).ToString());
Console.WriteLine("Global Best: " + Math.Round(colony.BestAnt.Solution.Quality, 5).ToString());
Console.WriteLine("------------------------");
}
}
static void antClustering_OnPostColonyIteration(object sender, EventArgs e)
{
if (sender is AntColony <DataMining.Model.ClusterExampleAssignment> )
{
AntColony <DataMining.Model.ClusterExampleAssignment> colony = sender as AntColony <DataMining.Model.ClusterExampleAssignment>;
Console.WriteLine("------------------------");
Console.WriteLine("Iteration [" + colony.CurrentIteration.ToString() + "]" + colony.ToString());
Console.WriteLine("------------------------");
Console.WriteLine("Iteration Best: " + Math.Round(colony.IterationBestAnt.Solution.Quality, 5).ToString());
Console.WriteLine("Global Best: " + Math.Round(colony.BestAnt.Solution.Quality, 5).ToString());
Console.WriteLine("------------------------");
}
else
{
AntColony <int> colony = sender as AntColony <int>;
Console.WriteLine("------------------------");
Console.WriteLine("Iteration [" + colony.CurrentIteration.ToString() + "]" + colony.ToString());
Console.WriteLine("------------------------");
Console.WriteLine("Iteration Best: " + Math.Round(colony.IterationBestAnt.Solution.Quality, 5).ToString());
Console.WriteLine("Global Best: " + Math.Round(colony.BestAnt.Solution.Quality, 5).ToString());
Console.WriteLine("------------------------");
}
}
private void threadRun(ConcurrentQueue <int> unservisedColonies, LowerTriangularMatrix <double> lt)
{
while (!unservisedColonies.IsEmpty)
{
int index;
Queue <IterationContext> cq = new Queue <IterationContext>();//unused here
unservisedColonies.TryDequeue(out index);
Colony tmp = currentGeneration[index];
Stopwatch sw = new Stopwatch();
//since ACO is nondeterministic, we will repeat algoritam few times and take average
double[] dists = new double[this.numberOfRepetitions];
int[] times = new int[this.numberOfRepetitions];
for (int i = 0; i < this.numberOfRepetitions; ++i)
{
sw.Start();
AntColony ac = new AntColony(lt, 0, (int)tmp.parameters[0], tmp.parameters[1], tmp.parameters[2],
tmp.parameters[3], tmp.parameters[4], (int)tmp.parameters[5], cq);
ac.mainLoop();
sw.Stop();
dists[i] = ac.shrotestDistance;
times[i] = (int)sw.ElapsedMilliseconds;
}
double averageDist = dists.Sum() / dists.Length;
int averageTime = times.Sum() / times.Length;
int time = (int)sw.ElapsedMilliseconds;
currentGeneration[index].fitness = fitnessFunction(averageDist, averageTime);
currentGeneration[index].shorestDistance = averageDist;
currentGeneration[index].time = averageTime;
// Console.WriteLine("index: " + index + " fitness: " + currentGeneration[index].fitness
// +" for " + time + "ms");
}
}
static List <Road> getPath(GameObject car)
{
// get the ant colony associated with car
AntColony selectedAntColony = null;
foreach (GameObject goAnt in antColonyList)
{
AntColony ac = goAnt.GetComponent <AntColony> ();
if (ac.car == car)
{
selectedAntColony = ac;
}
}
//start from the car to the user.
List <Road> path = new List <Road>();
Pheremone startPheremone = selectedAntColony.pheremoneList.Find(p => (
(p.EndA == car.transform.position && p.EndB == selectedAntColony.carTargetNode.location) ||
(p.EndB == car.transform.position && p.EndA == selectedAntColony.carTargetNode.location)));
path.Add(startPheremone.road);
Vector3 previousLocation = car.transform.position;
Vector3 currentLocation = ((previousLocation == path [0].End_A) ? path [0].End_B : path [0].End_A);
// keep on moving until we reach the user.
int safeexit = 0;
while (currentLocation != UserSelector.selectedNode.transform.position)
{
safeexit++;
if (safeexit >= 1000)
{
break;
}
// get current node
Node thisNode = selectedAntColony.AntColonyNodeList.Find(node => node.location == currentLocation);
Pheremone maxPheremone = null;
float maxPheremoneFound = 0;
foreach (Vector3 newLocation in thisNode.ways)
{
// for each path check the pheremone
if (newLocation != previousLocation)
{
Pheremone thisPheremone = selectedAntColony.pheremoneList.Find(p =>
(p.EndA == newLocation && p.EndB == currentLocation) ||
(p.EndB == newLocation && p.EndA == currentLocation));
// check for maximum pheremone
if (thisPheremone.pheremone >= maxPheremoneFound)
{
maxPheremoneFound = thisPheremone.pheremone;
maxPheremone = thisPheremone;
}
}
}
path.Add(maxPheremone.road);
previousLocation = currentLocation;
currentLocation = ((previousLocation == maxPheremone.road.End_A) ? maxPheremone.road.End_B : maxPheremone.road.End_A);
}
return(path);
}
public async Task CalculateAC()
{
ClearTextBox();
cts[1].Cancel();
cts[1] = new CancellationTokenSource();
progressAC.Visibility = Visibility.Visible;
int alpha;
if (!Int32.TryParse(textB_alpha.Text, out alpha))
{
textB_alpha.Background = Brushes.Coral;
errorTB.Push(textB_alpha);
return;
}
int beta;
if (!Int32.TryParse(textB_beta.Text, out beta))
{
textB_beta.Background = Brushes.Coral;
errorTB.Push(textB_beta);
return;
}
double rho;
if (!Double.TryParse(textB_rho.Text, out rho))
{
textB_rho.Background = Brushes.Coral;
errorTB.Push(textB_rho);
return;
}
double Q;
if (!Double.TryParse(textB_Q.Text, out Q))
{
textB_Q.Background = Brushes.Coral;
errorTB.Push(textB_Q);
return;
}
int numAnts;
if (!Int32.TryParse(textB_nAnts.Text, out numAnts))
{
textB_nAnts.Background = Brushes.Coral;
errorTB.Push(textB_nAnts);
return;
}
int maxTime;
if (!Int32.TryParse(textB_time.Text, out maxTime))
{
textB_time.Background = Brushes.Coral;
errorTB.Push(textB_time);
return;
}
AntColony algorithm = null;
Stopwatch time = null;
int[] solve = null;
Task thisTask = (Task.Run(() =>
{
algorithm = new AntColony(alpha, beta, rho, Q, numAnts, maxTime);
time = new Stopwatch();
time.Start();
solve = algorithm.Solution(cities);
time.Stop();
}));
tasks.Enqueue(thisTask);
await Task.Run(() =>
{
while (true)
{
if (cts[1].Token.IsCancellationRequested || thisTask.IsCompleted)
{
break;
}
}
});
if (solve != null)
{
DrawLines(solve, graphs[1]);
timeAC.Content = time.ElapsedMilliseconds.ToString();
lengthAC.Content = algorithm.TotalDistance.ToString("F2");
}
progressAC.Visibility = Visibility.Hidden;
}
public void Run()
{
if (A == null)
{
MessageBox.Show("Załaduj najpierw dane");
return;
}
IAlgorithm algorithm = null;
string name = "Algorytm";
int iterations = 0;
//wybieranie algorytmu
switch (SelectedTab)
{
case 0:
algorithm = new AntColony(_antColony.Ants, _antColony.MaxAssigns, _antColony.Alpha, _antColony.Beta, _antColony.Rho, _antColony.q, _antColony.Q0, _antColony.T0, _antColony.Q);
name = "AlgorytmMrówkowy";
iterations = _antColony.MaxAssigns;
break;
case 1:
algorithm = new BeesAlgorithm()
{
M = BeeAlgorithm.M,
Imax = BeeAlgorithm.Imax,
E = beeAlgorithm.E,
Ngh = beeAlgorithm.Ngh,
Nsp = beeAlgorithm.Nsp,
Nb = beeAlgorithm.Nb,
Nep = beeAlgorithm.Nep
};
name = "AlgorytmPszczeli";
iterations = BeeAlgorithm.Imax;
break;
case 2:
algorithm = new FireflyAlgorithm()
{
M = FireflyAlgorithm.M,
Imax = FireflyAlgorithm.Imax,
Gamma = FireflyAlgorithm.Gamma,
Alfa = FireflyAlgorithm.Alfa
};
name = "AlgorytmŚwietlikowy";
iterations = FireflyAlgorithm.Imax;
break;
case 3:
algorithm = new BeeAlgorithm(this.beeAlgorithmSBC.TotalNumberBees, this.beeAlgorithmSBC.NumberScout, this.beeAlgorithmSBC.MaxNumberVisits, this.beeAlgorithmSBC.MaxNumberCycles, this.beeAlgorithmSBC.ProbPersuasion, this.beeAlgorithmSBC.ProbMistake);
name = "AlgorytmPszczeliBSC";
iterations = FireflyAlgorithm.Imax;
break;
}
if (algorithm == null)
{
MessageBox.Show("Nie załadowano algorytmu.");
return;
}
//ładowanie algorytmu
algorithm.SetTestData((int[, ])A.Clone(), (int[, ])B.Clone(), size);
var sth = new Chart(algorithm, iterations, name, this.iterationGap, filename);
sth.Show();
}
public ActionResult Run(List <SimulatedAnnealingTask> saTasks, List <RepeatedNearestNeighborTask> nnTasks, List <AntColonyTask> antTasks)
{
var result = new Result();
using (var dbContext = new RsmDbContext())
{
if (saTasks != null)
{
foreach (var saTask in saTasks)
{
var parameters = Mapper.Map <SimulatedAnnealingParameters>(saTask);
var dataSet = dbContext.DataSets.Find(saTask.DataSet.Id);
var graph = new Graph(dataSet);
var saResult = new SimulatedAnnealingResult()
{
Parameters = parameters,
DataSet = saTask.DataSet,
Id = saTask.Id
};
for (var i = 0; i < saTask.HomManyTimes; i++)
{
var saAlg = new SimulatedAnnealing(graph, parameters);
var resultSa = saAlg.Performe();
var ids = resultSa.VerticesSequence.Select(v => v.Id);
var locations = dbContext.Locations.Where(loc => ids.Contains(loc.Id)).ToList();
saResult.Paths.Add(locations);
saResult.Scores.Add(resultSa.Score);
}
result.SimulatedAnnealingResults.Add(saResult);
}
}
if (nnTasks != null)
{
foreach (var nnTask in nnTasks)
{
var parameters = Mapper.Map <RepeatedNearestNeighborParameters>(nnTask);
var dataSet = dbContext.DataSets.Find(nnTask.DataSet.Id);
var graph = new Graph(dataSet);
var nnAlg = new RepeatedNearestNeighbor(graph, parameters);
var resultSa = nnAlg.Performe();
var ids = resultSa.VerticesSequence.Select(v => v.Id);
var locations = dbContext.Locations.Where(loc => ids.Contains(loc.Id)).ToList();
result.RepeatedNearestNeighborResults.Add(new RepeatedNearestNeighborResult()
{
Parameters = parameters,
DataSet = nnTask.DataSet,
Path = locations,
Score = resultSa.Score,
Id = nnTask.Id
});
}
}
if (antTasks != null)
{
foreach (var antTask in antTasks)
{
var parameters = Mapper.Map <AntColonyParameters>(antTask);
var dataSet = dbContext.DataSets.Find(antTask.DataSet.Id);
var graph = new Graph(dataSet);
var antResult = new AntColonyResult()
{
Parameters = parameters,
DataSet = antTask.DataSet,
Id = antTask.Id
};
for (var i = 0; i < antTask.HomManyTimes; i++)
{
var antAlg = new AntColony(graph, parameters);
var resultAnt = antAlg.Performe();
var ids = resultAnt.VerticesSequence.Select(v => v.Id);
var locations = dbContext.Locations.Where(loc => ids.Contains(loc.Id)).ToList();
antResult.Paths.Add(locations);
antResult.Scores.Add(resultAnt.Score);
}
result.AntColonyResults.Add(antResult);
}
}
}
return(Json(result));
}
