modfiyga.c

改进的遗传算法源程序

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

#define POPSIZE 50
#define MAXGENS 500
#define NVARS 2
#define PXOVER 0.65
#define PMUTATION 0.15
#define TRUE 1
#define FALSE 0
#define pi 3.1415926

int generation;
int cur_best;
FILE *galog;

struct genotype
{
  double gene[NVARS];
  double fitness;
  double upper[NVARS];
  double lower[NVARS];
  double rfitness;
  double cfitness;
};

struct genotype population[POPSIZE+1];
struct genotype newpopulation[POPSIZE+1];



void initialize(void);
double randval(double,double);
void evaluate(void);
void keep_the_best(void);
void elitist(void);
void select(void);
void crossover(void);
void Xover(int,int);
void swap(double *,double *);
void mutate(int);
void report(void);
void transfer(void);
void center(void);
void adapt(int,int,double,double);



void initialize(void)
{
FILE *infile;
int i,j;
double lbound,ubound;

if((infile=fopen("gadata.txt","r"))==NULL)
     {
      fprintf(galog,"\nCannot open input file!\n");
      exit(1);
     }

for (i=0;i<NVARS;i++)
   {
    fscanf(infile,"%lf",&lbound);
    fscanf(infile,"%lf",&ubound);

    for(j=0;j<POPSIZE;j++)
       {
       population[j].fitness=0;
       population[j].rfitness=0;
       population[j].cfitness=0;
       population[j].lower[i]=lbound;
       population[j].upper[i]=ubound;
       population[j].gene[i]=randval(population[j].lower[i],
                                population[j].upper[i]);
       }
   }
fclose(infile);
}

double randval(double low,double high)
{
 double val;
 val=((double)(rand()%10000)/10000.0)*(high-low)+low;
 return(val);
}

void evaluate(void)
{
int mem;
int i;
double x[NVARS+1];

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

    population[mem].fitness=40-(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*x[2]));
    /*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<100)
          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;
 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);
   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");

}