yichuansuanfa.txt

遗传算法的源程序

          if(printstrings   ==   1)   
          {   
                  repchar(outfp,"   ",((80-17)/2));   
                  fprintf(outfp,"模拟计算统计报告     \n");   
                  fprintf(outfp,   "世代数   %3d",   gen);   
                  repchar(outfp,"   ",(80-28));   
                  fprintf(outfp,   "世代数   %3d\n",   (gen+1));   
                  fprintf(outfp,"个体     染色体编码");   
                  repchar(outfp,"   ",lchrom-5);   
                  fprintf(outfp,"适应度         父个体   交叉位置     ");   
                  fprintf(outfp,"染色体编码   ");   
                  repchar(outfp,"   ",lchrom-5);   
                  fprintf(outfp,"适应度\n");   
                  repchar(outfp,"-",80);   
                  skip(outfp,1);   
                  writepop(outfp);   
                  repchar(outfp,"-",80);   
                  skip(outfp,1);   
            }   
          fprintf(outfp,"第   %d   代统计:   \n",gen);   
          fprintf(outfp,"总交叉操作次数   =   %d,   总变异操作数   =   %d\n",ncross,nmutation);   
          fprintf(outfp,"   最小适应度：%f   最大适应度：%f     平均适应度   %f\n",   min,max,avg);   
          fprintf(outfp,"   迄今发现最佳个体   =>     所在代数：   %d     ",   bestfit.generation);   
          fprintf(outfp,"   适应度：%f     染色体：",   bestfit.fitness);   
          writechrom((&bestfit)->chrom);   
          fprintf(outfp,"   对应的变量值:   %f",   bestfit.varible);   
          skip(outfp,1);   
          repchar(outfp,"-",80);   
          skip(outfp,1);       
  }   
    
  void   writepop()   
  {   
          struct   individual   *pind;   
          int   j;   
          for(j=0;   j<popsize;   j++)   
          {   
                  fprintf(outfp,"%3d)     ",j+1);   
                  /*   当前代个体   */   
                  pind   =   &(oldpop[j]);   
                  writechrom(pind->chrom);   
                  fprintf(outfp,"     %8f   |   ",   pind->fitness);   
                  /*   新一代个体   */   
                  pind   =   &(newpop[j]);   
                  fprintf(outfp,"(%2d,%2d)       %2d       ",   
                  pind->parent[0],   pind->parent[1],   pind->xsite);   
                  writechrom(pind->chrom);   
                  fprintf(outfp,"     %8f\n",   pind->fitness);   
          }   
  }   
    
  void   writechrom(chrom)                       /*   输出染色体编码   */   
  unsigned   *chrom;   
  {   
          int   j,   k,   stop;   
          unsigned   mask   =   1,   tmp;   
          for(k   =   0;   k   <   chromsize;   k++)   
          {   
                  tmp   =   chrom[k];   
                  if(k   ==   (chromsize-1))   
                          stop   =   lchrom   -   (k*(8*sizeof(unsigned)));   
                  else   
                          stop   =8*sizeof(unsigned);   
                  for(j   =   0;   j   <   stop;   j++)   
                  {   
                          if(tmp&mask)   
                                  fprintf(outfp,"1");   
                          else   
                                  fprintf(outfp,"0");   
                          tmp   =   tmp>>1;   
                  }   
          }   
  }   
    
  void   preselect()   
  {   
          int   j;   
          sumfitness   =   0;   
          for(j   =   0;   j   <   popsize;   j++)   sumfitness   +=   oldpop[j].fitness;   
  }   
    
  int   select()                                         /*   轮盘赌选择*/   
  {   
          extern   float   randomperc();   
          float   sum,   pick;   
          int   i;   
          pick   =   randomperc();   
          sum   =   0;   
          if(sumfitness   !=   0)   
          {   
                  for(i   =   0;   (sum   <   pick)   &&   (i   <   popsize);   i++)   
                          sum   +=   oldpop[i].fitness/sumfitness;   
          }   
          else   
                  i   =   rnd(1,popsize);   
          return(i-1);   
  }   
    
  void   statistics(pop)     /*   计算种群统计数据   */   
  struct   individual   *pop;   
  {   
          int   i,   j;   
          sumfitness   =   0.0;   
          min   =   pop[0].fitness;   
          max   =   pop[0].fitness;   
          /*   计算最大、最小和累计适应度   */   
          for(j   =   0;   j   <   popsize;   j++)   
          {   
                  sumfitness   =   sumfitness   +   pop[j].fitness;                           
                  if(pop[j].fitness   >   max)   max   =   pop[j].fitness;                   
                  if(pop[j].fitness   <   min)   min   =   pop[j].fitness;                     
                  /*   new   global   best-fit   individual   */   
                  if(pop[j].fitness   >   bestfit.fitness)   
      {   
        for(i   =   0;   i   <   chromsize;   i++)   
          bestfit.chrom[i]             =   pop[j].chrom[i];   
                          bestfit.fitness         =   pop[j].fitness;   
                          bestfit.varible       =   pop[j].varible;       
                          bestfit.generation   =   gen;   
      }   
              }   
          /*   计算平均适应度   */   
          avg   =   sumfitness/popsize;   
  }   
    
  void   title()   
  {   
      printf("SGA   Optimizer   Jean.Timex\n");   
  }   
    
  void   repchar   (outfp,ch,repcount)   
  FILE   *outfp;   
  char   *ch;   
  int   repcount;   
  {   
          int   j;   
          for   (j   =   1;   j   <=   repcount;   j++)   fprintf(outfp,"%s",   ch);   
  }   
    
  void   skip(outfp,skipcount)   
  FILE   *outfp;   
  int   skipcount;   
  {   
          int   j;   
          for   (j   =   1;   j   <=   skipcount;   j++)   fprintf(outfp,"\n");   
  }   
    
  void   objfunc(critter)                         /*   计算适应度函数值   */   
  struct   individual   *critter;   
  {   
          unsigned   mask=1;   
          unsigned   bitpos;   
          unsigned   tp;   
          double   pow(),   bitpow   ;   
          int   j,   k,   stop;   
          critter->varible   =   0.0;   
          for(k   =   0;   k   <   chromsize;   k++)   
          {   
                  if(k   ==   (chromsize-1))   
                          stop   =   lchrom-(k*(8*sizeof(unsigned)));   
                  else   
                          stop   =8*sizeof(unsigned);   
                  tp   =   critter->chrom[k];   
                  for(j   =   0;   j   <   stop;   j++)   
                  {   
                          bitpos   =   j   +   (8*sizeof(unsigned))*k;   
                          if((tp&mask)   ==   1)   
                          {   
                                  bitpow   =   pow(2.0,(double)   bitpos);   
                                  critter->varible   =   critter->varible   +   bitpow;   
                          }   
                          tp   =   tp>>1;   
                  }   
          }   
          critter->varible   =-1+critter->varible*3/(pow(2.0,(double)lchrom)-1);   
          critter->fitness   =critter->varible*sin(critter->varible*10*atan(1)*4)+2.0;   
  }

void     mutation(unsigned   *child)       /*变异操作*/   
  {   
          int   j,   k,   stop;   
          unsigned   mask,   temp   =   1;   
          for(k   =   0;   k   <   chromsize;   k++)   
          {   
                  mask   =   0;   
                  if(k   ==   (chromsize-1))   
                          stop   =   lchrom   -   (k*(8*sizeof(unsigned)));   
                  else   
                          stop   =   8*sizeof(unsigned);   
                  for(j   =   0;   j   <   stop;   j++)   
                  {   
                          if(flip(pmutation))   
                          {   
                                  mask   =   mask|(temp<<j);   
                                  nmutation++;   
                          }   
                  }   
                  child[k]   =   child[k]^mask;   
          }   
  }   
    
  int   crossover   (unsigned   *parent1,   unsigned   *parent2,   unsigned   *child1,   unsigned   *child2)   
  /*   由两个父个体交叉产生两个子个体   */   
  {   
          int   j,   jcross1,   jcross2,   jcross3,   jtemp,   k;   
          unsigned   mask,   temp;   
          if(flip(pcross))   
          {   
                  jcross1   =   rnd(1   ,(lchrom   -   1));/*   Cross   between   1   and   l-1   */   
  jcross2   =   rnd(1   ,(lchrom   -   1));   
  jcross3   =   rnd(1   ,(lchrom   -   1));   
  if(jcross2<jcross1)       /*   交换位置   */   
  {   
  jtemp   =   jcross1;   
  jcross1   =   jcross2;   
  jcross2   =   jtemp;   
  }   
  if(jcross3<jcross1)   
  { jtemp   =   jcross1;   
  jcross1   =   jcross3;   
  jcross3   =   jtemp;   
  }   
  if(jcross3<jcross2)   
  {   
  jtemp   =   jcross2;   
  jcross2   =   jcross3;   
  jcross3   =   jtemp;   
  }   
                  ncross++;   
  /*   第一次交换   */