别人的代码,整理了一下,可以直接运行的。
NSGA-Ⅱ算法C++实现(测试函数为ZDT1):
原文代码链接:https://blog.csdn.net/xyisv/article/details/73311045
#pragma warning(disable:4996)
#include<stdio.h>
#include<stdlib.h>
#include<Windows.h>
#include<math.h>
#include<time.h>
#include<iostream>
#define Dimension 30//基因维数,在这里即ZDT1问题xi的i的最大值
#define popsize 100//种群大小
#define generation 500 //繁衍代数
#define URAND (rand()/(RAND_MAX+1.0))//产生随机数
int temp1[popsize];//临时数组
int mark[popsize];//标记数组
//以上两个数组用于产生新的子代
using namespace std;
//个体的类声明:
class individual
{
public:
double value[Dimension];//xi的值
int sp[2 * popsize];
//被支配个体集合SP。该量是可行解空间中所有被个体p支配的个体组成的集合。
int np;
//支配个数np。该量是在可行解空间中可以支配个体p的所以个体的数量。
int is_dominated;//集合sp的个数
void init();//初始化个体
int rank;//优先级,Pareto级别为当前最高级
double crowding_distance;//拥挤距离
double fvalue[2];//ZDT1问题目标函数的值
void f_count();//计算fvalue的值
};
//群体的类声明:
class population
{
public:
population();//类初始化
individual P[popsize];
individual Q[popsize];
individual R[2 * popsize];
void set_p_q();
//随机产生一个初始父代P,在此基础上采用二元锦标赛选择、
//交叉和变异操作产生子代Q。P和Q群体规模均为popsize
//将Pt和Qt并入到Rt中(初始时t=0),对Rt进行快速非支配解排序,
//构造其所有不同等级的非支配解集F1、F2........
int Rnum;
int Pnum;
int Qnum;
//P,Q,R中元素的个数
void make_new_pop();//产生新的子代
void fast_nondominated_sort();//快速非支配排序
void calu_crowding_distance(int i);//拥挤距离计算
void f_sort(int i);//对拥挤距离降序排列
void maincal();//主要操作
int choice(int a, int b);
//两个个体属于不同等级的非支配解集,优先考虑等级序号较小的
//若两个个体属于同一等级的非支配解集,优先考虑拥挤距离较大的
int len[2 * popsize]; //len 各个变异交叉后的群体Fi的长度的集合
int len_f;//整个群体rank值
};
//全局变量及部分函数声明:
individual F[2 * popsize][2 * popsize];
double rand_real(double low, double high)
//产生随机实数
{
double h;
h = (high - low)*URAND + low + 0.001;
if (h >= high)
h = high - 0.001;
return h;
}
int rand_int(int low, int high)
//产生随机整数
{
return int((high - low + 1)*URAND) + low;
}
//关于排序函数qsort
int cmp1(const void *a, const void *b)
//目标函数f1的升序排序
{
const individual *e = (const individual *)a;
const individual *f = (const individual *)b;
if (e->fvalue[0] == f->fvalue[0])
return 0;
else if (e->fvalue[0]<f->fvalue[0])
return -1;
else return 1;
}
int cmp2(const void *a, const void *b)
//目标函数f2的升序排序
{
const individual *e = (const individual *)a;
const individual *f = (const individual *)b;
if (e->fvalue[1] == f->fvalue[1])
return 0;
else if (e->fvalue[1]<f->fvalue[1])
return -1;
else return 1;
}
int cmp_c_d(const void *a, const void *b)
//对拥挤距离降序排序
{
const individual *e = (const individual *)a;
const individual *f = (const individual *)b;
if (e->crowding_distance == f->crowding_distance)
return 0;
else if (e->crowding_distance<f->crowding_distance)
return 1;
else
return -1;
}
void population::f_sort(int i)
{
int n;
n = len[i];
qsort(F[i], n, sizeof(individual), cmp_c_d);
}
//群的初始化:
population::population()
{
int i;
for (i = 0; i<popsize; i++)
{
P[i].init();
}
for (i = 0; i<popsize; i++)
{
P[i].f_count();
}
Pnum = popsize;
Qnum = 0;
Rnum = 0;
}
//个体初始化:
void individual::init()
{
for (int i = 0; i<Dimension; i++)
value[i] = rand_real(0.0, 1.0);
}
//利用二进制锦标赛产生子代:
void population::make_new_pop()
{
int i, j, x, y, t1, t2, t3;
double s, u, b;
memset(mark, 0, sizeof(mark));
t3 = 0;
while (t3<popsize / 2)
{
while (t1 = t2 = rand_int(0, popsize - 1), mark[t1]);
while (t1 == t2 || mark[t2])
{
t2 = rand_int(0, popsize - 1);
}
t1 = choice(t1, t2);
temp1[t3++] = t1;
mark[t1] = 1;
}
for (i = 0; i<popsize; i++)
{
s = rand_real(0.0, 1.0);
if (s <= 0.9)
{
for (j = 0; j<Dimension; j++)
{
u = rand_real((0.0 + 1e-6), (1.0 - 1e-6));
if (u <= 0.5)
b = pow(2 * u, 1.0 / 21);
else
b = 1.0 / pow(2 * (1 - u), 1.0 / 21);
x = y = rand_int(0, popsize / 2 - 1);
while (x == y)
y = rand_int(0, popsize / 2 - 1);
Q[i].value[j] = 1.0 / 2 * ((1 - b)*P[temp1[x]].value[j] + (1 + b)*P[temp1[y]].value[j]);
if (Q[i].value[j]<0)
Q[i].value[j] = 1e-6;
else if (Q[i].value[j]>1)
Q[i].value[j] = 1.0 - (1e-6);
if (i + 1<popsize)
{
Q[i + 1].value[j] = 1.0 / 2 * ((1 + b)*P[temp1[x]].value[j] + (1 - b)*P[temp1[y]].value[j]);
if (Q[i + 1].value[j] <= 0)
Q[i + 1].value[j] = 1e-6;
else if (Q[i + 1].value[j]>1)
Q[i + 1].value[j] = (1 - 1e-6);
}
}
i++;
}
else
{
for (j = 0; j<Dimension; j++)
{
x = rand_int(0, popsize / 2 - 1);
u = rand_real(0.0 + (1e-6), 1.0 - (1e-6));
if (u<0.5)
u = pow(2 * u, 1.0 / 21) - 1;
else
u = 1 - pow(2 * (1 - u), 1.0 / 21);
Q[i].value[j] = P[temp1[x]].value[j] + (1.0 - 0.0)*u;
if (Q[i].value[j]<0)
Q[i].value[j] = 1e-6;
else if (Q[i].value[j]>1)
Q[i].value[j] = 1 - (1e-6);
}
}
}
Qnum = popsize;
for (i = 0; i<popsize; i++)
Q[i].f_count();
}
void population::set_p_q()
{
Rnum = 0;
Qnum = popsize;
int i;
for (i = 0; i<Pnum; i++)
R[Rnum++] = P[i];
for (i = 0; i<Qnum; i++)
R[Rnum++] = Q[i];
for (i = 0; i<2 * popsize; i++)
R[i].f_count();
}
//ZDT1问题函数值的计算:
void individual::f_count()
{
fvalue[0] = value[0];
int i;
double g = 1, sum = 0;
for (i = 1; i<Dimension; i++)
{
sum += value[i];
}
sum += 9 * (sum / (Dimension - 1));
g += sum;
fvalue[1] = g*(1 - sqrt(value[0] / g));
}
//判断目标函数值是否被支配:
bool e_is_dominated(const individual &a, const individual &b)
{
if ((a.fvalue[0] <= b.fvalue[0]) && (a.fvalue[1] <= b.fvalue[1]))
{
if ((a.fvalue[0] == b.fvalue[0]) && a.fvalue[1] == b.fvalue[1])
return false;
else
return true;
}
else
return false;
}
//快速非支配排序法:重点!!!
void population::fast_nondominated_sort()
{
int i, j, k;
individual H[2 * popsize];
int h_len = 0;
for (i = 0; i<2 * popsize; i++)
{
R[i].np = 0;
R[i].is_dominated = 0;
len[i] = 0;
}
for (i = 0; i<2 * popsize; i++)
{
for (j = 0; j<2 * popsize; j++)
{
if (i != j)
{
if (e_is_dominated(R[i], R[j]))
R[i].sp[R[i].is_dominated++] = j;
else if (e_is_dominated(R[j], R[i]))
R[i].np += 1;
}
}
if (R[i].np == 0)
{
len_f = 1;
F[0][len[0]++] = R[i];
}
}
i = 0;
while (len[i] != 0)
{
h_len = 0;
for (j = 0; j<len[i]; j++)
{
for (k = 0; k<F[i][j].is_dominated; k++)
{
R[F[i][j].sp[k]].np--;
if (R[F[i][j].sp[k]].np == 0)
{
H[h_len++] = R[F[i][j].sp[k]];
R[F[i][j].sp[k]].rank = i + 2;
}
}
}
i++;
len[i] = h_len;
if (h_len != 0)
{
len_f++;
for (j = 0; j<len[i]; j++)
F[i][j] = H[j];
}
}
}
//计算拥挤距离:重点!!!具体解释见其他文章!!!
void population::calu_crowding_distance(int i)
{
int n = len[i];
double m_max, m_min;
int j;
for (j = 0; j<n; j++)
F[i][j].crowding_distance = 0;
F[i][0].crowding_distance = F[i][n - 1].crowding_distance = 0xffffff;
qsort(F[i], n, sizeof(individual), cmp1);
m_max = -0xfffff;
m_min = 0xfffff;
for (j = 0; j<n; j++)
{
if (m_max<F[i][j].fvalue[0])
m_max = F[i][j].fvalue[0];
if (m_min>F[i][j].fvalue[0])
m_min = F[i][j].fvalue[0];
}
for (j = 1; j<n - 1; j++)
F[i][j].crowding_distance += (F[i][j + 1].fvalue[0] - F[i][j - 1].fvalue[0]) / (m_max - m_min);
F[i][0].crowding_distance = F[i][n - 1].crowding_distance = 0xffffff;
qsort(F[i], n, sizeof(individual), cmp2);
m_max = -0xfffff;
m_min = 0xfffff;
for (j = 0; j<n; j++)
{
if (m_max<F[i][j].fvalue[1])
m_max = F[i][j].fvalue[1];
if (m_min>F[i][j].fvalue[1])
m_min = F[i][j].fvalue[1];
}
for (j = 1; j<n - 1; j++)
F[i][j].crowding_distance += (F[i][j + 1].fvalue[1] - F[i][j - 1].fvalue[1]) / (m_max - m_min);
}
//采集多样性的选择
int population::choice(int a, int b)
{
if (P[a].rank<P[b].rank)
return a;
else if (P[a].rank == P[b].rank)
{
if (P[a].crowding_distance>P[b].crowding_distance)
return a;
else
return b;
}
else
return b;
}
//NSGAII主要操作函数:
void population::maincal()
{
int s, i, j;
s = generation; //繁衍代数
make_new_pop(); //利用二进制锦标赛产生子代:
while (s--)
{
printf("The %d generation\n", s);
set_p_q();
fast_nondominated_sort(); //快速非支配排序
Pnum = 0;
i = 0;
while (Pnum + len[i] <= popsize)
{
calu_crowding_distance(i);
for (j = 0; j<len[i]; j++)
P[Pnum++] = F[i][j];
i++;
if (i >= len_f)break;
}
if (i<len_f) //len_f 整个群体rank值
{
calu_crowding_distance(i); //计算拥挤距离
f_sort(i); //对拥挤距离降序排序
}
for (j = 0; j<popsize - Pnum; j++)
P[Pnum++] = F[i][j];
make_new_pop(); //利用二进制锦标赛产生子代:
}
}
int main()
{
FILE *p;
p = fopen("ZDT1.txt", "w+"); //保存计算结果
srand((unsigned int)(time(0))); //随机数种子
population pop; //种群初始化
pop.maincal(); //NSGAII 主操作函数
int i, j;
fprintf(p, "Problem ZDT1\n");
fprintf(p, "\n");
for (i = 0; i<popsize; i++) //popsize 种群大小
{
fprintf(p, "The %d generation situation:\n", i);
for (j = 1; j <= Dimension; j++) //维度
{
fprintf(p, "x%d=%e ", j, pop.P[i].value[j]);
}
fprintf(p, "\n");
fprintf(p, "f1(x)=%f f2(x)=%f\n", pop.P[i].fvalue[0], pop.P[i].fvalue[1]); //评估值
fprintf(p, "\n");
}
fclose(p);
system("pause");
return 0;
}