//Looks through each tour in the wisdomList and finds
//the most common city at each index for all the tours
//to generate the final tour
public static void crowds(int tourLength, ref globalVars globalVars)
{
//Temp variables for finding the most used city at each index
int max = 0;
int tempCity = 0;
int tempIndex = 0;
int tempIndex2 = 0;
//Array to store the count of each city for each index
int[] crowdArray = new int[tourLength + 1];
//Look through each index of the tours
for (int i = 0; i < tourLength; i++)
{
//Reset the crowdArray after each index search
Array.Clear(crowdArray, 0, crowdArray.Length);
//Find the city of each tour at index i
for (int j = 0; j < globalVars.crowdSize; j++)
{
//If the city != 0, increment the count for
//that city in the crowdArray
if ((globalVars.wisdomList[j].path[i]) != 0)
{
tempCity = globalVars.wisdomList[j].path[i];
crowdArray[tempCity] = (crowdArray[tempCity] + 1);
}
}
//Find the city that was most used at
//index i and add it to the final tour's path
max = crowdArray.Max();
tempIndex = crowdArray.ToList().IndexOf(max);
globalVars.shortList.Add(tempIndex);
//Replace the city that was just added in the final tour
//with a 0 in the wisdomList tours
for (int k = 0; k < globalVars.crowdSize; k++)
{
tempIndex2 = globalVars.wisdomList[k].path.IndexOf(tempIndex);
globalVars.wisdomList[k].path.RemoveAt(tempIndex2);
globalVars.wisdomList[k].path.Insert(tempIndex2, 0);
}
}
//Add a 1 to the end of the list to complete the tour
globalVars.shortList.Add(1);
}
//Sets up for the pmx crossover thats implemented in the NewGenChild class
public static newChild newGen(newCity[] cityArray, ref globalVars globalVars, ref List <newChild>[] genList)
{
//Random variables/functions
int rand = 0;
Random rnd = new Random();
Random rnd2 = new Random(Guid.NewGuid().GetHashCode());
//Temp lists to feed the newGenChild function to execute the pmx crossover
List <int> temp1 = new List <int>();
List <int> temp2 = new List <int>();
List <int> pmx1 = new List <int>();
List <int> pmx2 = new List <int>();
List <int> tempFinal = new List <int>();
//Copy the best parent from the current generation to the next generation
if (globalVars.genVar == 0)
{
SortChild.sortChild(((genList[0])[0]), ref globalVars, ref genList[1]);
}
else
{
SortChild.sortChild(((genList[1])[0]), ref globalVars, ref genList[0]);
}
//Do for each parent in the current generation
for (int i = 0; i < genList[globalVars.genVar].Count; i++)
{
//Variable to stop an infinte loop when trying
//to find unique substrings from the parents
int help = 0;
//Clear temp lists
temp1.Clear();
temp2.Clear();
tempFinal.Clear();
pmx1.Clear();
pmx2.Clear();
//Parent 1, which will be all the parents
//in the current generation
temp1.AddRange(((genList[globalVars.genVar])[i]).path);
temp1.RemoveAt(temp1.Count - 1);
//Randomly pick parent 2 while checking that
//it's not parent 1
rand = rnd.Next(0, genList[globalVars.genVar].Count);
while (((rand = rnd.Next(0, genList[globalVars.genVar].Count)) == i))
{
}
temp2.AddRange(((genList[globalVars.genVar])[rand]).path);
temp2.RemoveAt(temp2.Count - 1);
//Generate the substrings starting at a random point
//in the lists with globalVars.pmx length
rand = rnd.Next(0, temp1.Count - globalVars.pmx);
for (int p = rand; p < (rand + globalVars.pmx); p++)
{
pmx1.Add(temp1[p]);
pmx2.Add(temp2[p]);
}
//Checks to make sure the substrings are not equal
//to prevent the crossover from doing nothing
//Will only attempt 100 times before exiting
//to prevent infine loops when both parents are equal
while ((pmx1.SequenceEqual(pmx2) == true) && (help < 100))
{
pmx1.Clear();
pmx2.Clear();
rand = rnd.Next(1, temp1.Count - globalVars.pmx);
for (int p = rand; p < (rand + globalVars.pmx); p++)
{
pmx1.Add(temp1[p]);
pmx2.Add(temp2[p]);
}
help++;
}
//Call the newGenChild function to perform the pmx crossover
//on both parents with the other parents subsections to create 2 new children
//rand2 is used to determine if mutation will occur within the function
double rand2 = rnd2.NextDouble();
NewGenChild.newGenChild(cityArray, ref globalVars, ref genList, rand, temp1, pmx2, rand2);
rand2 = rnd2.NextDouble();
NewGenChild.newGenChild(cityArray, ref globalVars, ref genList, rand, temp2, pmx1, rand2);
}
//Once all the children have been created
//Swap the globalVar.genVar so that the new
//children become the new parents and the current
//parents are cleared to make space for the next generation of children
//The best child from the generation is then returned to determine
//if the generation inproved fitness
if (globalVars.genVar == 0)
{
globalVars.genVar = 1;
genList[0].Clear();
return((genList[1])[0]);
}
else
{
globalVars.genVar = 0;
genList[1].Clear();
return((genList[0])[0]);
}
}
//Same the Split function about but splits the map at x coordinates instead of y coordinates
public static void splitX(newCity[] cityArray, float split, ref globalVars globalVars, ref List <newChild> childList)
{
//Distance variables
float distance = 0;
float totalDistance = 0;
float distanceTL = 0; //Top Left distance
float distanceTR = 0; //Top Right distance
float distanceBR = 0; //Bottom Right Distance
float distanceBL = 0; //Bottom Left distance
//newCorner objects to find the 4 corners
newCorner topLeft = new newCorner(float.MaxValue);
newCorner topRight = new newCorner(float.MaxValue);
newCorner bottomLeft = new newCorner(float.MaxValue);
newCorner bottomRight = new newCorner(float.MaxValue);
//Lists to store the cities above and below the split point
List <int> topList = new List <int>();
List <int> topFinal = new List <int>();
List <int> bottomList = new List <int>();
List <int> bottomFinal = new List <int>();
//Check each city in the cityArray to see if it's
//above or below the split point
for (int c = 1; c < cityArray.Length + 1; c++)
{
//Above the split point
if (cityArray[c - 1].xCoordinate > split)
{
topList.Add(c); //Add to the topList
//Find cities closest to (split, 0) and (split, 100)
float x1 = cityArray[c - 1].xCoordinate;
float y1 = cityArray[c - 1].yCoordinate;
float x2 = split;
float y2 = 0;
float y3 = 100;
distanceBR = (float)Math.Sqrt((((x2 - x1)) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
distanceTR = (float)Math.Sqrt((((x2 - x1)) * (x2 - x1)) + ((y3 - y1) * (y3 - y1)));
//Check if the city is closest to (split, 0) and (split, 100)
if (distanceTL < topLeft.coordinate)
{
topLeft.id = c;
topLeft.coordinate = distanceTL;
}
if (distanceTR < topRight.coordinate)
{
topRight.id = c;
topRight.coordinate = distanceTR;
}
}
//At or below the split point
else
{
bottomList.Add(c); //Add to the bottom list
//Find cities closest to (split, 0) and (split, 100)
float x1 = cityArray[c - 1].xCoordinate;
float y1 = cityArray[c - 1].yCoordinate;
float x2 = split;
float y2 = 0;
float y3 = 100;
distanceBL = (float)Math.Sqrt((((x2 - x1)) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
distanceTL = (float)Math.Sqrt((((x2 - x1)) * (x2 - x1)) + ((y3 - y1) * (y3 - y1)));
//Check if the city is closest to (split, 0) and (split, 100)
if (distanceBL < bottomLeft.coordinate)
{
bottomLeft.id = c;
bottomLeft.coordinate = distanceBL;
}
if (distanceBR < bottomRight.coordinate)
{
bottomRight.id = c;
bottomRight.coordinate = distanceBR;
}
}
}
//Discard current split if it resulted in a single city being
//both bottomRight/bottomLeft or topRight/topLeft
if ((topList.Count <= 1) || (bottomList.Count <= 1))
{
return;
}
//Adding the corner cities to the top/bottomFinal lists
//Removing the corner cities from the top/bottom lists
topFinal.Add(topLeft.id);
topFinal.Add(topRight.id);
bottomFinal.Add(bottomRight.id);
bottomFinal.Add(bottomLeft.id);
topList.Remove(topLeft.id);
topList.Remove(topRight.id);
bottomList.Remove(bottomLeft.id);
bottomList.Remove(bottomRight.id);
//Call insertNode function to generate the new greedy paths
InsertNode.insertNode(cityArray, topList, ref topFinal);
InsertNode.insertNode(cityArray, bottomList, ref bottomFinal);
//Combine the top and bottom paths to complete the tour
topFinal.AddRange(bottomFinal);
topFinal.Add(topFinal[0]);
//If the path's distance wasn't the most recent path to be computed
//find the distance of the path
if (topFinal.SequenceEqual(globalVars.lastPath) == false)
{
globalVars.unique++;
for (int d = 1; d < topFinal.Count; d++)
{
int xy1 = topFinal[d - 1] - 1; //Location of city A in city List
int xy2 = topFinal[d] - 1; //Location of city B in city List
//Find x and y coordinates of city A and B
float x1 = cityArray[xy1].xCoordinate;
float x2 = cityArray[xy2].xCoordinate;
float y1 = cityArray[xy1].yCoordinate;
float y2 = cityArray[xy2].yCoordinate;
//Use distance equation to find the distance between city A and B
//Add distance to totalDistance
distance = (float)Math.Sqrt((((x2 - x1)) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
totalDistance = totalDistance + distance;
}
//Store the most recent path to avoid
//computing the same path multiple times
globalVars.lastPath = topFinal;
//Create newChild with topFinal path and corresponding distance
newChild tempChild = new newChild(totalDistance, topFinal);
//Rearange the tempChilds path so that it starts and ends with "1"
tempChild.path.RemoveAt(topFinal.Count - 1);
for (int i = 0; i < tempChild.path.Count; i++)
{
i = 0;
if (tempChild.path[0] == 1)
{
break;
}
else
{
tempChild.path.Add(tempChild.path[0]);
tempChild.path.RemoveAt(0);
}
}
tempChild.path.Add(tempChild.path[0]);
//If the new path distance is smaller than the
//current smallest distance then replace
//the smallest distance with the new distance
if (tempChild.distance < globalVars.shortDistance)
{
globalVars.shortList.Clear();
globalVars.shortDistance = tempChild.distance; //Store the new shorter distance
globalVars.shortList.AddRange(tempChild.path); //Store the corresponding path
globalVars.shortSplit = split; //Store the current split value
}
//Sort the tempChild
SortChild.sortChild(tempChild, ref globalVars, ref childList);
SortChild.sortChild(tempChild, ref globalVars, ref globalVars.wisdomList);
}
}
//Sorts the newChild object according to its distance from smallest distance to largest distance
//The List only contains the up to the top "globalVars.maxChildren" children
public static void sortChild(newChild tempChild, ref globalVars globalVars, ref List <newChild> childList)
{
//If the list is empty, add the current child
if (childList.Count == 0)
{
childList.Add(tempChild);
}
//If the list is not empty
else
{
//If the list is currently full
if (childList.Count == globalVars.maxChildren)
{
//If the distance of the last child in the list is less than the current child's distance,
//don't sort the current child and return back to the NewGen class
if (childList[globalVars.maxChildren - 1].distance < tempChild.distance)
{
return;
}
//If the distance of the last child in the list is greater than the current child's distance,
//sort the current child as it is guarenteed to find a spot in the list
else
{
//Check all the distances in the list and find where
//the current child should be inserted by finding the
//first element in the list that has a distance greater than
//the current child and insert the child before that element
for (int c = 0; c < childList.Count; c++)
{
if (tempChild.distance == childList[c].distance)
{
return;
}
else if (tempChild.distance < childList[c].distance)
{
childList.Insert(c, tempChild);
childList.RemoveAt(globalVars.maxChildren);
return;
}
}
}
}
//If the list is not full,
//sort the current child as it is guarenteed to find a spot in the list
else
{
//Check all the distances in the list and find where
//the current child should be inserted by finding the
//first element in the list that has a distance greater than
//the current child and insert the child before that element
for (int c = 0; c < childList.Count; c++)
{
if (tempChild.distance == childList[c].distance)
{
return;
}
else if (tempChild.distance < childList[c].distance)
{
childList.Insert(c, tempChild);
return;
}
//If the current child needs to be the
//last item in the list for the first time
else if (c == childList.Count - 1)
{
childList.Add(tempChild);
return;
}
}
}
}
}
public static void newGenChild(newCity[] cityArray, ref globalVars globalVars, ref List <newChild>[] genList, int rand, List <int> _tempList, List <int> _altPmx, double rand2)
{
//Temp variables
int index;
int tempVar;
float distance = 0;
float totalDistance = 0;
//Random function and temp lists
Random rnd = new Random(Guid.NewGuid().GetHashCode());
List <int> tempList = new List <int>(_tempList);
List <int> altPmx = new List <int>(_altPmx);
List <int> tempMut = new List <int>();
//Performs the pmx crossover by swapping the cities in the
//parent's list according to the sublist from the other parent
for (int j = rand; j < rand + globalVars.pmx; j++)
{
tempVar = tempList[j];
index = tempList.IndexOf(altPmx[j - rand]);
tempList.RemoveAt(index);
tempList.Insert(index, tempVar);
tempList.RemoveAt(j);
tempList.Insert(j, altPmx[j - rand]);
}
//Performs inversion mutation if rand2 was less than
//the globalVars.mutation/100
if (rand2 < (globalVars.mutation / 100))
{
tempMut.Clear();
rand = rnd.Next(1, tempList.Count - globalVars.pmx);
for (int k = rand; k < rand + globalVars.pmx; k++)
{
tempMut.Add(tempList[k]);
tempList.RemoveAt(k);
tempList.Insert(rand, tempMut[k - rand]);
}
}
tempList.Add(tempList[0]);
//Calculate the tour distance
for (int d = 1; d < tempList.Count; d++)
{
int xy1 = tempList[d - 1] - 1; //Location of city A in city List
int xy2 = tempList[d] - 1; //Location of city B in city List
//Find x and y coordinates of city A and B
float x1 = cityArray[xy1].xCoordinate;
float x2 = cityArray[xy2].xCoordinate;
float y1 = cityArray[xy1].yCoordinate;
float y2 = cityArray[xy2].yCoordinate;
//Use distance equation to find the distance between city A and B
//Add distance to totalDistance
distance = (float)Math.Sqrt((((x2 - x1)) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
totalDistance = totalDistance + distance;
}
//Create newChild with tempList path and corresponding distance
newChild tempChild = new newChild(totalDistance, tempList);
//Sort the tempChild node in the not current parent genList
if (globalVars.genVar == 0)
{
SortChild.sortChild(tempChild, ref globalVars, ref genList[1]);
}
else
{
SortChild.sortChild(tempChild, ref globalVars, ref genList[0]);
}
//Sort child into the wisdomList to be used for WOC
SortChild.sortChild(tempChild, ref globalVars, ref globalVars.wisdomList);
}
static void Main(string[] args)
{
//Code needed to run the Windows Form Application
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
string fileName = "Random22.TSP"; //File name being tested
//Variables to keep track of execution time
Stopwatch stopWatch = new Stopwatch();
float time1 = 0;
string time2 = null;
string timer = null;
stopWatch.Start(); //Start Stopwatch
//Temp float to keep track of
//shortest distance of each generation
float tempDistance = float.MaxValue;
int z = 0; //Temp variable
int gen = 0; //Keeps track of current generation
int count = 0; //Count variable
double split = 2; //Split variables
float split2 = 0;
float distance = 0; //Distance variables
float totalDistance = 0;
globalVars globalVars = new globalVars(); //Object to hold "global" variables
List <newChild>[] genList = new List <newChild> [2]; //Array to hold the children of each generation
genList[0] = new List <newChild>(); //Swaps between holding the parents and children of a generation
genList[1] = new List <newChild>(); //Swaps between holding the parents and children of a generation
//Reads file to find # of lines
//Stores (# of lines - 7) to get the number of cities in the file
string[] lines = File.ReadAllLines(fileName);
int newLength = lines.Length - 7;
//Array of newCity objects with size = # of cities
newCity[] cityArray = new newCity[newLength];
//Stores city data
string line;
System.IO.StreamReader file = new System.IO.StreamReader(fileName);
while ((line = file.ReadLine()) != null)
{
//Ignore first 7 lines of the file
//8th line is where the city data begins
if (count >= 7)
{
string[] data = line.Split(' '); //Split and store the city data in data string array
//Create newCity object using data pulled from data array (ID, x Coordinate, y Coordinate)
//Store each newCity object in newCity array
cityArray[count - 7] = new newCity(Int32.Parse(data[0]), float.Parse(data[1]), float.Parse(data[2]));
}
count++;
}
//Close File
file.Close();
//If input for GA is choosen to be random
if (globalVars.random == true)
{
Console.WriteLine("Random Inputs");
Random rnd = new Random();
List <int> temp1 = new List <int>(); //Temp list
//Create a list with all the cities in it
for (int l = 0; l < newLength; l++)
{
temp1.Add(cityArray[l].id);
}
temp1.RemoveAt(0); //Remove "1" from the list
//Create "population size" of random tours
for (int r = 0; r < globalVars.maxChildren; r++)
{
List <int> temp2 = new List <int>(temp1);
int n = temp2.Count;
//Scramble the list containing the cities
while (n > 1)
{
n--;
int rand = rnd.Next(n + 1);
z = temp2[rand];
temp2[rand] = temp2[n];
temp2[n] = z;
}
//Add "1" to the start and end of the list to complete the tour
temp2.Insert(0, 1);
temp2.Add(1);
//Calculate the tour distance
for (int d = 1; d < temp2.Count; d++)
{
int xy1 = temp2[d - 1] - 1; //Location of city A in city List
int xy2 = temp2[d] - 1; //Location of city B in city List
//Find x and y coordinates of city A and B
float x1 = cityArray[xy1].xCoordinate;
float x2 = cityArray[xy2].xCoordinate;
float y1 = cityArray[xy1].yCoordinate;
float y2 = cityArray[xy2].yCoordinate;
//Use distance equation to find the distance between city A and B
//Add distance to totalDistance
distance = (float)Math.Sqrt((((x2 - x1)) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
totalDistance = totalDistance + distance;
}
//Create the newChild object using the randomized list
//and the corresponding distance and then sort the child in genList[0]
newChild tempChild = new newChild(totalDistance, temp2);
SortChild.sortChild(tempChild, ref globalVars, ref genList[0]);
}
}
//If input for GA is choosen to use the tours found by the greedy algorithm
else
{
Console.WriteLine("Greedy Inputs");
//Split the map of cities at y = split and x = split
//to generate solutions to use as the initial parents for the GA
for (split = 2; split < 100; split += 0.5)
{
split2 = Convert.ToSingle(split);
//Call the split function to split the map of cities at y = split
Split.splitY(cityArray, split2, ref globalVars, ref genList[0]);
//Call the split function to split the map of cities at x = split
Split.splitX(cityArray, split2, ref globalVars, ref genList[0]);
}
}
//Calls GA functions until the same distance
//of the top child is found "globalVars.sameGen" times
Console.WriteLine("Start GA");
for (z = 0; z < globalVars.sameGen; z++)
{
gen++; //Keeps track of the current generation
//Calls newGen function to create the next generation
//and return the child with the shortest distance
newChild topChild = NewGen.newGen(cityArray, ref globalVars, ref genList);
//Checks if the top child from the generation is more fit
//than the top child from the last generation
tempDistance = topChild.distance;
//Console.WriteLine("gen " + gen + " " + tempDistance);
if (tempDistance < globalVars.shortDistance)
{
//If the child is more fit than the previous generation
//set the new distance as the shorest distance
//and reset the GA stop condition
z = 0;
globalVars.shortDistance = tempDistance;
globalVars.shortList.Clear();
globalVars.shortList.AddRange(topChild.path);
}
}
//Prints the shortest tour/distance before the wisdom of crowds function is called
Console.WriteLine("The Old Distance is " + globalVars.shortDistance);
Console.WriteLine("The Old Path is " + string.Join(",", globalVars.shortList));
globalVars.shortDistance = 0;
globalVars.shortList.Clear();
//Calls the Wisdom of Crowds function
Console.WriteLine("Start WOC");
Console.WriteLine("WOC List Length = " + globalVars.wisdomList.Count);
Crowds.crowds(newLength, ref globalVars);
//Finds the distance for the Wisdom of Crowds tour
for (int d = 1; d < globalVars.shortList.Count; d++)
{
int xy1 = globalVars.shortList[d - 1] - 1; //Location of city A in city List
int xy2 = globalVars.shortList[d] - 1; //Location of city B in city List
//If the WOC algorithm produced an imcomplete tour (not likely),
//restart the application to find a clean solution
//Bad solutions occurs when the WOC algorithm finds
//an index that has no cities in it (all cities at index i are set to 0)
if (xy1 < 0 || xy2 < 0)
{
Console.WriteLine("Bad Solution");
Console.WriteLine("Press any key to restart");
Console.ReadKey();
Application.Restart();
Environment.Exit(0);
}
//Find x and y coordinates of city A and B
float x1 = cityArray[xy1].xCoordinate;
float x2 = cityArray[xy2].xCoordinate;
float y1 = cityArray[xy1].yCoordinate;
float y2 = cityArray[xy2].yCoordinate;
//Use distance equation to find the distance between city A and B
//Add distance to totalDistance
distance = (float)Math.Sqrt((((x2 - x1)) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
totalDistance = totalDistance + distance;
}
globalVars.shortDistance = totalDistance;
stopWatch.Stop(); //Stop Stopwatch
//Print distance/path/time data
Console.WriteLine("File = " + fileName);
Console.WriteLine("The New Distance is " + globalVars.shortDistance);
Console.WriteLine("The New Path is " + string.Join(",", globalVars.shortList));
time1 = stopWatch.ElapsedMilliseconds;
time1 = (float)TimeSpan.FromMilliseconds(time1).TotalSeconds;
time2 = stopWatch.ElapsedMilliseconds.ToString();
timer = time1.ToString();
Console.WriteLine("Execution time took " + time2 + " Milliseconds, or " + timer + " Seconds");
//Run Windows Form Application to graph the shortest path
Application.Run(new GUI(cityArray, globalVars.shortList));
//Application.Restart();
//Environment.Exit(0);
Console.ReadKey();
}