#### Genetic Algorithm for TSP in C++ errors

I’m trying to launch the program code for Travelling Salesman Problem (TSP) with Genetic algorithm.
Couldn’t figure out in a code as it’s not mine. Can anyone understand how to fix it?

I need to define the global object in the code and place it in a right place
How can I define it in the code? I am confused(

``````Graph Map_City;//Define the global object graph and place it after the Graph class
GA zq; //Population category, placed after GA category

#include <iostream>
#include <fstream>
#include <string>
#include <time.h>
#include <stdlib.h>
#include <random>
using namespace std;

default_random_engine random((unsigned int)time(NULL));
uniform_real_distribution<double> u0(0, 1); //Random number distribution object
const int citycount = 29; //The number of cities is used as a global constant and needs to be assigned in the code in advance
Graph Map_City; //Define the global object graph and place it after the Graph class
GA zq; //Population category, placed after GA category

class City
{
public:
string name;//city name
double x, y;//The two-dimensional coordinates of the city point
void shuchu()
{
std::cout << name + ":" << "(" << x << "," << y << ")" << endl;
}
};
class Graph
{
public:

City city[citycount];//City array
double distance[citycount][citycount];//Distance matrix between cities
void Readcoordinatetxt(string txtfilename = "tsp.txt")//Read the function of the city coordinate file
{
ifstream myfile(txtfilename, ios::in);
double x = 0, y = 0;
int z = 0;
if (!myfile.fail())
{
int i = 0;
while (!myfile.eof() && (myfile >> z >> x >> y))
{
city[i].name = to_string(long(z));//City name is converted to string
city[i].x = x; city[i].y = y;
i++;
}
}
else
cout << "file does not exist";
myfile.close();//Calculate the city distance matrix
for (int i = 0; i < citycount; i++)
for (int j = 0; j < citycount; j++)
{
distance[i][j] = sqrt((pow((city[i].x - city[j].x), 2) + pow((city[i].y - city[j].y), 2)) / 10.0);//Calculate the pseudo Euclidean distance between cities ij
if (round(distance[i][j] < distance[i][j]))distance[i][j] = round(distance[i][j]) + 1;
else distance[i][j] = round(distance[i][j]);
}
}
void shuchu()
{
cout << "city name " << "Coordinate x" << " " << "Coordinate y" << endl;
for (int i = 0; i < citycount; i++)
city[i].shuchu();
cout << "Distance matrix:" << endl;
for (int i = 0; i < citycount; i++)
{
for (int j = 0; j < citycount; j++)
{
if (j == citycount - 1)
std::cout << distance[i][j] << endl;
else
std::cout << distance[i][j] << "  ";
}
}
}
};
double round(double r) { return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5); }

int* Random_N(int n)
{
int* geti;
geti = new int[n];
int j = 0;
while (j < n)
{
while (true)
{
int flag = -1;
int temp = rand() % n + 1;
if (j > 0)
{
int k = 0;
for (; k < j; k++)
{
if (temp == *(geti + k))break;
}
if (k == j)
{
*(geti + j) = temp;
flag = 1;
}
}
else
{
*(geti + j) = temp;
flag = 1;
}
if (flag == 1)break;
}
j++;
}
return geti;
}
class Ranseti
{
public:
int* X;
double fitness;
void Init()
{
X = new int[citycount];
int* M = Random_N(citycount);
for (int j = 0; j < citycount; j++)
X[j] = *(M + j);
fitness = 0;
}
void shuchu()
{
for (int j = 0; j < citycount; j++)
{
if (j == citycount - 1) std::cout << X[j] << " " << fitness << endl;
else std::cout << X[j] << "->";
}
}
};
class GA
{
public:
Ranseti* oldranseti;//Last generation population
Ranseti* ranseti;//Next generation population
int Pop_Size;//Population size
int Itetime;//Number of iterations
double Cross_Prob;//Crossover probability
double Bianyi_Prob;//Probability of mutation
Ranseti Bestranseti;//Best chromosomal individual
double Bestlength;//The length of the shortest path
double* Leiji_Prob;//Cumulative selection probability
void Init(int popsize, int itetime, double crossprob, double bianyiprob, string filename)
{
Map_City.shuchu();
Pop_Size = popsize;
Itetime = itetime;
Cross_Prob = crossprob;
Bianyi_Prob = bianyiprob;
oldranseti = new Ranseti[Pop_Size];
ranseti = new Ranseti[Pop_Size];
Leiji_Prob = new double[Pop_Size];
for (int i = 0; i < Pop_Size; i++)
{
oldranseti[i].Init();
oldranseti[i].fitness = Evaluate(i);//Initial fitness
}
int bestid = -1;
for (int i = 0; i < Pop_Size; i++)
{
int j = 0;
for (; j < Pop_Size; j++)
{
if (oldranseti[i].fitness > oldranseti[j].fitness)break;
}
if (j == Pop_Size)
{
bestid = i;
break;
}
}
Bestranseti.Init();
Bestranseti.fitness = 0;
for (int j = 0; j < citycount; j++)
Bestranseti.X[j] = oldranseti[bestid].X[j];
for (int j = 0; j < citycount - 1; j++)
Bestranseti.fitness += Map_City.distance[Bestranseti.X[j]][Bestranseti.X[j + 1]];
Bestranseti.fitness += Map_City.distance[Bestranseti.X[citycount - 1]][Bestranseti.X[0]];
Bestlength = Bestranseti.fitness;
}
void shuchu()
{
for (int i = 0; i < Pop_Size; i++)
oldranseti[i].shuchu();
}
double Evaluate(int k)//Calculate the function of chromosome fitness, calculate the path distance
{
double distancer = 0;
for (int j = 0; j < citycount - 1; j++)
distancer += Map_City.distance[oldranseti[k].X[j]][oldranseti[k].X[j + 1]];
distancer += Map_City.distance[oldranseti[k].X[citycount - 1]][oldranseti[k].X[0]];
oldranseti[k].fitness = distancer;
return distancer;
}
void CalculateLeijiProb()
{
double Sumfitness = -0;
for (int i = 0; i < Pop_Size; i++)
oldranseti[i].fitness = Evaluate(i);
for (int i = 0; i < Pop_Size; i++)
Sumfitness += oldranseti[i].fitness;//Calculate the sum of fitness values ​​of all chromosomes in the population
double* SelectProb;
SelectProb = new double[Pop_Size];
for (int i = 0; i < Pop_Size; i++)
SelectProb[i] = oldranseti[i].fitness / Sumfitness;//Calculate the selection probability of each chromosome
for (int i = 0; i < Pop_Size; i++)
{
Leiji_Prob[i] = 0;
for (int j = 0; j <= i; j++)
Leiji_Prob[i] += SelectProb[j];//Calculate the cumulative probability of each chromosome
}
}
void Roulette()
{
for (int i = 0; i < Pop_Size; i++)//Roulette selection generates a new population
{
double suijishu = u0(random);//Generate a random number between 0-1
int j = 0;
for (; j < Pop_Size; j++)
{
if (suijishu <= Leiji_Prob[j])break;
}
ranseti[i].Init();
for (int k = 0; k < citycount; k++)
ranseti[i].X[k] = oldranseti[j].X[k];
}
for (int i = 0; i < Pop_Size; i++)
{
ranseti[i].fitness = 0;
for (int j = 0; j < citycount - 1; j++)
ranseti[i].fitness += Map_City.distance[ranseti[i].X[j]][ranseti[i].X[j + 1]];
ranseti[i].fitness += Map_City.distance[ranseti[i].X[citycount - 1]][ranseti[i].X[0]];
}
}
void Cross(double Pc)//Cross function adopts partial matching cross strategy
{
for (int k = 0; k + 1 < Pop_Size; k = k + 2)
{
int k1 = k;
int k2 = k1 + 1;
double suijishu = u0(random);
if (Pc > suijishu)
{
int pos1 = rand() % citycount, pos2 = rand() % citycount;
if (pos1 > pos2)//Ensure that pos1 is less than pos2
{
pos1 += pos2;
pos2 = pos1 - pos2;
pos1 = pos1 - pos2;
}
for (int j = 0; j < citycount; j++)
{
if (j >= pos1 && j <= pos2)
{
ranseti[k1].X[j] = ranseti[k1].X[j] + ranseti[k2].X[j];
ranseti[k2].X[j] = ranseti[k1].X[j] - ranseti[k2].X[j];
ranseti[k1].X[j] = ranseti[k1].X[j] - ranseti[k2].X[j];
}
}
int cishu = pos2 - pos1 + 1;
for (int j = 0; j < citycount; j++)
{
if ((j < pos1) || (j > pos2))
{
for (int jishu = 1; jishu <= cishu; jishu++)
{
for (int m = pos1; m <= pos2; m++)
{
if (ranseti[k1].X[j] == ranseti[k1].X[m])
{
ranseti[k1].X[j] = ranseti[k2].X[m];
}
}
}
}
}
for (int j = 0; j < citycount; j++)
{
if ((j < pos1) || (j > pos2))
{
for (int jishu = 1; jishu <= cishu; jishu++)
{
for (int m = pos1; m <= pos2; m++)
{
if (ranseti[k2].X[j] == ranseti[k2].X[m])
{
ranseti[k2].X[j] = ranseti[k1].X[m];
}
}
}
}
}
}
}
for (int i = 0; i < Pop_Size; i++)
{
ranseti[i].fitness = 0;
for (int j = 0; j < citycount - 1; j++)
ranseti[i].fitness += Map_City.distance[ranseti[i].X[j]][ranseti[i].X[j + 1]];
ranseti[i].fitness += Map_City.distance[ranseti[i].X[citycount - 1]][ranseti[i].X[0]];
}
}
void Bianyi(double Pm)//Variation function
{
for (int k = 0; k < Pop_Size; k++)
{
double suijishu = u0(random);
if (Pm > suijishu)
{
int pos1 = rand() % citycount, pos2 = rand() % citycount;//Randomly select two mutation locations, and then exchange the city numbers in the two locations
while (pos2 == pos1)
pos2 = rand() % citycount;
ranseti[k].X[pos1] += ranseti[k].X[pos2];
ranseti[k].X[pos2] = ranseti[k].X[pos1] - ranseti[k].X[pos2];
ranseti[k].X[pos1] = ranseti[k].X[pos1] - ranseti[k].X[pos2];
}
ranseti[k].fitness = 0;
for (int j = 0; j < citycount - 1; j++)
ranseti[k].fitness += Map_City.distance[ranseti[k].X[j]][ranseti[k].X[j + 1]];
ranseti[k].fitness += Map_City.distance[ranseti[k].X[citycount - 1]][ranseti[k].X[0]];
}
}
void SelectBestRanseti()
{
for (int i = 0; i < Pop_Size; i++)
{
if (ranseti[i].fitness < Bestranseti.fitness)
{
for (int j = 0; j < citycount; j++)
Bestranseti.X[j] = ranseti[i].X[j];
}
}
Bestranseti.fitness = 0;
for (int j = 0; j < citycount - 1; j++)
Bestranseti.fitness += Map_City.distance[Bestranseti.X[j]][Bestranseti.X[j + 1]];
Bestranseti.fitness += Map_City.distance[Bestranseti.X[citycount - 1]][Bestranseti.X[0]];
}
void GA_TSP()
{
ofstream outfile;
outfile.open("result.txt", ios::trunc);
for (int k = 0; k < Itetime; k++)
{
outfile << " " << k + 1 << "Generation population:" << endl;
CalculateLeijiProb();//Calculate the cumulative probability of the chromosomes of the previous generation population
Roulette();//The roulette method selects the next generation population
outfile << "The new population after roulette selection:" << endl;
for (int i = 0; i < Pop_Size; i++)
for (int j = 0; j < citycount; j++)
{
if (j == citycount - 1)outfile << ranseti[i].X[j] << " " << ranseti[i].fitness << " " << endl;
else outfile << ranseti[i].X[j] << "->";
}
Cross(Cross_Prob);
outfile << "New population after crossover:" << endl;
for (int i = 0; i < Pop_Size; i++)
for (int j = 0; j < citycount; j++)
{
if (j == citycount - 1)outfile << ranseti[i].X[j] << " " << ranseti[i].fitness << " " << endl;
else outfile << ranseti[i].X[j] << "->";
}
Bianyi(Bianyi_Prob);
outfile << "The new population after mutation:" << "n";
for (int i = 0; i < Pop_Size; i++)
for (int j = 0; j < citycount; j++)
{
if (j == citycount - 1)outfile << ranseti[i].X[j] << " " << ranseti[i].fitness << " " << endl;
else outfile << ranseti[i].X[j] << "->";
}
std::cout << " " << k + 1 << "The optimal path length for the second iteration is:" << Bestranseti.fitness << endl;
outfile << " " << k + 1 << "The optimal path length for the second iteration is:" << Bestranseti.fitness << endl;
for (int i = 0; i < Pop_Size; i++)
{
for (int j = 0; j < citycount; j++)
{
oldranseti[i].X[j] = ranseti[i].X[j];
}
oldranseti[i].fitness = ranseti[i].fitness;
}
}
std::cout << "****************Iteration is over!****************" << endl;
std::cout << Itetime << "The optimal path length after the second iteration is:" << Bestranseti.fitness << endl;
std::cout << Itetime << "The optimal individual after the second iteration is as follows:" << endl;
outfile << Itetime << "The optimal path length after the second iteration is:" << Bestranseti.fitness << endl;
outfile << Itetime << "The optimal individual after the second iteration is as follows:" << endl;
for (int j = 0; j < citycount; j++)
{
if (j == citycount - 1)
{
std::cout << Bestranseti.X[j] << endl;
outfile << Bestranseti.X[j] << endl;
}
else
{
std::cout << Bestranseti.X[j] << "->";
outfile << Bestranseti.X[j] << "->";
}
}
outfile.close();
}
};

int main()
{
std::cout << "**************** Genetic algorithm to solve traveling salesman problem!****************" << endl;
std::cout << "**************** Number of cities:" << citycount << "****************" << endl;
zq.Init(50, 100, 0.8, 0.9, "C:UsersBehzodSourceReposGen_TSPtsp.txt");
std::cout << "**************** The population after initialization is as follows: ******************" << endl;
zq.shuchu();
zq.GA_TSP();
system("pause");
return 0;
}
``````

enter image description here
The program output the next error

Error C2065 ‘Map_City’: undeclared identifier 148
Error C2065 ‘Map_City’: undeclared identifier
Error C2065 ‘zq’: undeclared identifier Gen_TSP

Source: Windows Questions C++