多目标优化NSGA-II(非支配排序常见于遗传算法)(C语言实现）

目录

１重要知识回顾

２案例

３Ｃ语言代码实现 

４结果展示

---

１重要知识回顾

多目标优化NSGA-II(非支配排序常见于遗传算法)[1]

多目标遗传优化算法NSGAII求解微电网调度(Python&Matlab)

２案例

 

本次我们以ZDT１函数为例． 

３Ｃ语言代码实现 

//======头文件=======
#include
#include
#include
#include
#include
#include
#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];//各个变异交叉后的群体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]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]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_distancecrowding_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;i1)
                    Q[i].value[j]=1.0-(1e-6);
                if(i+11)
                        Q[i+1].value[j]=(1-1e-6);
                }
            }
            i++;
        }
        else
        {
            for(j=0;j1)
                    Q[i].value[j]=1-(1e-6);
            }
        }
    }
    Qnum=popsize;
    for(i=0;iF[i][j].fvalue[0])
            m_min=F[i][j].fvalue[0];
    }
    for(j=1;jF[i][j].fvalue[1])
            m_min=F[i][j].fvalue[1];
    }
    for(j=1;jP[b].crowding_distance)
            return a;
        else
            return b;
    }
    else
        return b;
}

//========主要操作函数==========
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_f)break;
        }
        if(i

４结果展示