hhm.c

这是一个改进混合遗产算法的C语言源程序

double x[NVARS];

for(mem=0;mem<POPSIZE;mem++)
   {
    for(i=0;i<NVARS;i++)
       x[i]=population[mem].gene[i];

    population[mem].fitness=40-objf(x);
    /*x[1]*sin(10*pi*x[1])+2.0;*/
    /*0.1*sqrt((x[1]-25)*(x[1]-25)+(x[2]-40)*(x[2]-40))+10-10*sin(0.5*pi*x[1])
      *cos(0.75*pi*y); */
    /*(x[1]*x[1])-(x[1]*x[2])+x[3]; */
    /*   20-(x[1]*x[1]+x[2]*x[2]-x[1]*x[2]-10*x[1]-4*x[2])*/
    }
}


void keep_the_best()
{
int mem;
int i;
cur_best=0;
for(mem=0;mem<POPSIZE;mem++)
   {
    if(population[mem].fitness>population[POPSIZE].fitness)
        {
         cur_best=mem;
         population[POPSIZE].fitness=population[mem].fitness;
        }
   }

for(i=0;i<NVARS;i++)
   population[POPSIZE].gene[i]=population[cur_best].gene[i];
}


void elitist()
{
  int i;
  double best,worst;
  int best_mem,worst_mem;

  best=population[0].fitness;
  worst=population[0].fitness;
  for(i=0;i<POPSIZE-1;++i)
    {
     if(population[i].fitness>population[i+1].fitness)
      {
       if(population[i].fitness>=best)
       {
       best=population[i].fitness;
       best_mem=i;
      }
     if(population[i+1].fitness<=worst)
      {
       worst=population[i+1].fitness;
       worst_mem=i+1;
      }
    }
     else
         {
         if(population[i].fitness<=worst)
           {
            worst=population[i].fitness;
            worst_mem=i;
           }
          if(population[i+1].fitness>=best)
           {
            best=population[i+1].fitness;
            best_mem=i+1;
           }
        }
}



if(best>=population[POPSIZE].fitness)
  {
    for(i=0;i<NVARS;i++)
        population[POPSIZE].gene[i]=population[best_mem].gene[i];
        population[POPSIZE].fitness=population[best_mem].fitness;
   }
else
   {
    for(i=0;i<NVARS;i++)
     population[worst_mem].gene[i]=population[POPSIZE].gene[i];
     population[worst_mem].fitness=population[POPSIZE].fitness;
    }
}


void select(void)
{
 int mem,i,j;
 double sum=0;
 double p;
for(mem=0;mem<POPSIZE;mem++)
     {
      sum+=population[mem].fitness;
     }

for(mem=0;mem<POPSIZE;mem++)
    {
     population[mem].rfitness=population[mem].fitness/sum;
    }
population[0].cfitness=population[0].rfitness;

for(mem=1;mem<POPSIZE;mem++)
   {
    population[mem].cfitness=population[mem-1].cfitness+population[mem].rfitness;
   }

for(i=0;i<POPSIZE;i++)
   {
    p=rand()%10000/10000.0;
    if(p<population[0].cfitness)
           newpopulation[i]=population[0];
    else
       {
        for(j=0;j<POPSIZE;j++)
           if(p>=population[j].cfitness&&p<population[j+1].cfitness)
              newpopulation[i]=population[j+1];
        }
  }

for(i=0;i<POPSIZE;i++)
    population[i]=newpopulation[i];
}



void crossover(void)
{
 int mem,one;
 int first=0;
 double x;

 for(mem=0;mem<POPSIZE;++mem)
{
 x=rand()%1000/1000.0;
  if(x<PXOVER)
    {
     ++first;
     if(first%2==0)
       Xover(one,mem);
     else
        one=mem;
     }
}
}


void Xover(int one,int two)
{
 int i;
 int point;
 double onet[NVARS],twot[NVARS],a[NVARS];
 if(NVARS>1)
   {
    if(NVARS==2)
       point=0;
     else
        point=(rand()%(NVARS-1));
for(i=point;i<NVARS;i++)
  {/* swap(&population[one].gene[i],&population[two].gene[i]);*/
    a[i]=rand()%10000/10000.0;
    onet[i]=population[one].gene[i];
    twot[i]=population[two].gene[i];
    population[one].gene[i]=twot[i]+(onet[i]-twot[i])*a[i];
    population[two].gene[i]=onet[i]+(twot[i]-onet[i])*a[i];

   }
   }
  }


/*void  swap(double *x,double *y)
  {
  double temp;

  temp=*x;
  *x=*y;
  *y=temp;
}*/

void mutate(int gen)
{
 int i,j;
 double lbound,hbound;
 double x;

for(i=0;i<POPSIZE;i++)
     for(j=0;j<NVARS;j++)
       {
        x=rand()%1000/1000.0;
        if(x<PMUTATION)
        { lbound=population[i].lower[j];
          hbound=population[i].upper[j];
          if(gen<50)
          population[i].gene[j]=randval(lbound,hbound);
          else
          adapt(i,j,lbound,hbound);
            }
        }
 }

void adapt(int i,int j,double low,double high)
{int T,del,b;
 double r;
 r=rand()%10000/10000.0;
 T=1-population[i].fitness/population[POPSIZE].fitness;
 b=(1-T)*(1-T);
 if (r>0.5)
 {del=(low-population[i].gene[j])*(1-pow(r,b));
  population[i].gene[j]=del+population[i].gene[j];
  }
  else
  { del=(population[i].gene[j]-high)*(1-pow(r,b));
    population[i].gene[j]=population[i].gene[j]-del;
    }
  }

void report(void)
{
int i;
double best_val;
double avg;
double stddev;
double sum_square;
double square_sum;
double sum;


sum=0.0;
sum_square=0.0;

for(i=0;i<POPSIZE;i++)
   {
    sum+=population[i].fitness;
    sum_square+=population[i].fitness*population[i].fitness;
   }

avg=sum/(double)POPSIZE;
square_sum=avg*avg*(double)POPSIZE;
stddev=sqrt(abs((sum_square-square_sum)/(POPSIZE-1)));
best_val=population[POPSIZE].fitness;

fprintf(galog,"\n%5d,  %6.4f,%6.4f,%6.4f \n\n",generation,best_val,avg,stddev);
}


void main(void)
{
 int i,j,gen;
 double x[NVARS],p[NVARS],ff,g;
 srand(time(NULL));

  if((galog=fopen("galog.txt","w"))==NULL)
   {
   exit(1);
   }
generation=0;

fprintf(galog,"\n generation best average stadard\n");
fprintf(galog,"number   value fitness deviation\n");

initialize();
evaluate();
keep_the_best();
while(generation<MAXGENS)
  {
   generation++;

   select();
   crossover();
   mutate(generation);
   for(i=0;i<POPSIZE;i++)
   {
    g=rand()%1000/1000;
    if(g<mpw)
  {  for(j=0;j<NVARS;j++)
    p[j]=population[i].gene[j];
    ff=powell(p,0.3,0.001,0.0001,2,x);
     gen=0;
     for(j=0;j<NVARS;j++)
     {if(x[j]>population[0].lower[j]&&x[j]<population[0].upper[j])
         gen=gen+1;

      }
      if(gen==NVARS)

      {
        for(j=0;j<NVARS;j++)
         population[i].gene[j]=x[j];
         population[i].fitness=40-ff;
         }
    }
    }
   report();
   evaluate();
   elitist();
   }

fprintf(galog,"\n Simulation completed\n");
fprintf(galog,"\n Best member:\n");

for(i=0;i<NVARS;i++)
  {
   fprintf(galog,"\n var(%d)=%3.4f",i,population[POPSIZE].gene[i]);
  }
fprintf(galog,"\n\n best fitness=%3.4f",population[POPSIZE].fitness);
fclose(galog);
printf("Success\n");

}