多目标遗传算法 ------ NSGA-II （部分源码解析） 交叉操作 crossover.c

遗传算法中的交叉操作是 对NSGA-II  源码分析的  最后一部分， 这一部分也是我 从读该算法源代码和看该算法论文理解偏差最大的  函数模块。

这里，首先提一下，遗传算法的  交叉操作、变异操作都是需要设定概率的， 即交叉概率和变异概率。

假设种群个体 大小为  popsize ,  那么交叉操作需要进行 popsize/2 次 ，   变异操作需要进行 popsize 次， 其中每次操作的时候都需要随机生成一个随机数来与给定的概率进行判断，若小于给定的概率则继续执行否则退出该操作。

如果继续操作的话  需要注意一个问题  对两个个体交叉 ，或  对单个个体进行变异  都是对 个体的所有变量  进行操作，其中变异对二进制编码的个体来说是对每个个体的每个变量 的二进制编码的 每个比特位进行变异。

包装函数，通过对标识位判断编码形式来决定 具体的核心功能 所调用的函数。

 /* Crossover routines */

 # include <stdio.h>
 # include <stdlib.h>
 # include <math.h>

 # include "global.h"
 # include "rand.h"

 /* Function to cross two individuals */
 void crossover (individual *parent1, individual *parent2, individual *child1, individual *child2)
 {
     if (nreal!=)
     {
         realcross (parent1, parent2, child1, child2);
     }
     if (nbin!=)
     {
         bincross (parent1, parent2, child1, child2);
     }
     return;
 }

实数编码的  两个个体交叉操作， 采用 SBX 方式交叉。需要交叉的两个个体  每个变量  都进行交叉操作。

 /* Routine for real variable SBX crossover */
 void realcross (individual *parent1, individual *parent2, individual *child1, individual *child2)
 {
     int i;
     double rand;
     double y1, y2, yl, yu;
     double alpha, beta, betaq;
     if (randomperc() <= pcross_real)
     {
         nrealcross++;
         for (i=; i<nreal; i++)
         {
             if (randomperc() <= 0.5 )
             {
                 if (parent1->xreal[i] < parent2->xreal[i])
                 {
                     y1 = parent1->xreal[i];
                     y2 = parent2->xreal[i];
                 }
                 else
                 {
                     y1 = parent2->xreal[i];
                     y2 = parent1->xreal[i];
                 }
                 if (fabs(parent1->xreal[i]-parent2->xreal[i]) > EPS)
                 {
                     yl = min_realvar[i];
                     yu = max_realvar[i];
                     rand = randomperc();
                     beta = 1.0 + (2.0*(y1-yl)/(y2-y1));
                     alpha = 2.0 - pow(beta,-(eta_c+1.0));
                     if (rand <= (1.0/alpha))
                     {
                         betaq = pow ((rand*alpha),(1.0/(eta_c+1.0)));
                     }
                     else
                     {
                         betaq = pow ((1.0/(2.0 - rand*alpha)),(1.0/(eta_c+1.0)));
                     }
                     child1->xreal[i] = 0.5*((y1+y2)-betaq*(y2-y1));
                     beta = 1.0 + (2.0*(yu-y2)/(y2-y1));
                     alpha = 2.0 - pow(beta,-(eta_c+1.0));
                     if (rand <= (1.0/alpha))
                     {
                         betaq = pow ((rand*alpha),(1.0/(eta_c+1.0)));
                     }
                     else
                     {
                         betaq = pow ((1.0/(2.0 - rand*alpha)),(1.0/(eta_c+1.0)));
                     }
                     child2->xreal[i] = 0.5*((y1+y2)+betaq*(y2-y1));
                     if (child1->xreal[i]<yl)
                     {
                         child1->xreal[i]=yl;
                     }
                     if (child1->xreal[i]>yu)
                     {
                         child1->xreal[i]=yu;
                     }
                     if (child2->xreal[i]<yl)
                     {
                         child2->xreal[i]=yl;
                     }
                     if (child2->xreal[i]>yu)
                     {
                         child2->xreal[i]=yu;
                     }
                 }
                 else
                 {
                     child1->xreal[i] = parent1->xreal[i];
                     child2->xreal[i] = parent2->xreal[i];
                 }
             }
             else
             {
                 child1->xreal[i] = parent1->xreal[i];
                 child2->xreal[i] = parent2->xreal[i];
             }
         }
     }
     else
     {
         for (i=; i<nreal; i++)
         {
             child1->xreal[i] = parent1->xreal[i];
             child2->xreal[i] = parent2->xreal[i];
         }
     }
     return;
 }

二进制编码  的   交叉操作：

（双点 交叉）  两个个体的  每个对应的变量  彼此交叉操作。这里每个变量的 二进制编码 段 随机选取两点， 将中间部门的二进制段  互换，两个交叉点。

 /* Routine for two point binary crossover */
 void bincross (individual *parent1, individual *parent2, individual *child1, individual *child2)
 {
     int i, j;
     double rand;
     int temp, site1, site2;
     for (i=; i<nbin; i++)
     {
         rand = randomperc();
         if (rand <= pcross_bin)
         {
             nbincross++;
             site1 = rnd(,nbits[i]-);
             site2 = rnd(,nbits[i]-);
             if (site1 > site2)
             {
                 temp = site1;
                 site1 = site2;
                 site2 = temp;
             }
             for (j=; j<site1; j++)
             {
                 child1->gene[i][j] = parent1->gene[i][j];
                 child2->gene[i][j] = parent2->gene[i][j];
             }
             for (j=site1; j<site2; j++)
             {
                 child1->gene[i][j] = parent2->gene[i][j];
                 child2->gene[i][j] = parent1->gene[i][j];
             }
             for (j=site2; j<nbits[i]; j++)
             {
                 child1->gene[i][j] = parent1->gene[i][j];
                 child2->gene[i][j] = parent2->gene[i][j];
             }
         }
         else
         {
             for (j=; j<nbits[i]; j++)
             {
                 child1->gene[i][j] = parent1->gene[i][j];
                 child2->gene[i][j] = parent2->gene[i][j];
             }
         }
     }
     return;
 }

对于   遗传算法的交叉操作， 有一点是需要注意的 那就是  交叉操作  执行  popsize/2 次， 而且是按照种群个体的排序顺序（按照个体的序号）依次取出两个个体进行交叉操作，而每次执行交叉操作时是否真的进行交叉还要比对随机生成的随机数 与  给定的交叉概率大小 。