ga.txt

C语言编写的遗传算法程序（可以运行

/***************************************************************/  
/* This is a simple genetic algorithm implementation where the */  
/* evaluation function takes positive values only and the      */  
/* fitness of an individual is the same as the value of the    */  
/* objective function                                          */  
/***************************************************************/  
 
#include <stdio.h>  
#include <stdlib.h>  
#include <math.h>  
 
/* Change any of these parameters to match your needs */  
 
#define POPSIZE 80               /* population size */  
#define MAXGENS 1000             /* max. number of generations */  
#define NVARS 2                  /* no. of problem variables */  
#define PXOVER 0.8               /* probability of crossover */  
#define PMUTATION 0.01           /* probability of mutation */  
#define TRUE 1  
#define FALSE 0  
 
int generation;                  /* current generation no. */  
int cur_best;                    /* best individual */  
FILE *galog;                     /* an output file */  
 
struct genotype /* genotype (GT), a member of the population */  
{  
 double gene[NVARS];        /* a string of variables */  
 double fitness;            /* GT's fitness */  
 double upper[NVARS];       /* GT's variables upper bound */  
 double lower[NVARS];       /* GT's variables lower bound */  
 double rfitness;           /* relative fitness */  
 double cfitness;           /* cumulative fitness */  
};  
 
struct genotype population[POPSIZE+1];    /* population */  
struct genotype newpopulation[POPSIZE+1]; /* new population; */  
                                         /* replaces the */  
                                         /* old generation */  
 
/* Declaration of procedures used by this genetic algorithm */  
 
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(void);  
void report(void);  
 
/***************************************************************/  
/* Initialization function: Initializes the values of genes    */  
/* within the variables bounds. It also initializes (to zero)  */  
/* all fitness values for each member of the population. It    */  
/* reads upper and lower bounds of each variable from the      */  
/* input file `gadata.txt'. It randomly generates values       */  
/* between these bounds for each gene of each genotype in the  */  
/* population. The format of the input file `gadata.txt' is    */  
/* var1_lower_bound var1_upper bound                           */  
/* var2_lower_bound var2_upper bound ...                       */  
/***************************************************************/  
 
void initialize(void)  
{  
/*FILE *infile; */ 
int i, j;  
double lbound, ubound;  
/* 
if ((infile = fopen("gadata.txt","r"))==NULL)   //&Ocirc;&Uacute;&Icirc;&Auml;&frac14;&thorn;&sup1;&aelig;&para;¨&ordm;&Atilde;&Euml;ù&Ccedil;ó±&auml;&Aacute;&iquest;&micro;&Auml;&Eacute;&Iuml;&Iuml;&Acirc;&Iuml;&THORN; 
     {  
     fprintf(galog,"\nCannot open input file!\n");  
     exit(1);  
     }  
*/ 
 
/* initialize variables within the bounds */  
 
printf("please input the bound of each variable:\n"); 
for (i = 0; i < NVARS; i++)  
     {  
     /* 
     fscanf(infile, "%lf",&lbound);  
     fscanf(infile, "%lf",&ubound);  
     */ 
     printf("please input lower and upper bound of VAR(%d)\n",i+1); 
     scanf("%lf",&lbound); 
     scanf("%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);  
*/ 
}  
 
/***********************************************************/  
/* Random value generator: Generates a value within bounds */  
/***********************************************************/  
 
double randval(double low, double high)  
{  
double val;  
val = ((double)(rand()%1000)/1000.0)*(high - low) + low;  
return(val);  
}      
 
/*************************************************************/  
/* Evaluation function: This takes a user defined function.  */  
/* Each time this is changed, the code has to be recompiled. */  
/* The current function is:  x[1]^2-x[1]*x[2]+x[3]           */  
/*************************************************************/  
 
void evaluate(void)  
{  
int mem;  
int i;  
double x[NVARS+1];  
//&acute;&laquo;&micro;&Yacute;±&auml;&Aacute;&iquest;&micro;&Auml;&Ouml;&micro;&cedil;&oslash;&Ecirc;&Ecirc;&Oacute;&brvbar;&Ouml;&micro;&ordm;&macr;&Ecirc;&yacute; 
for (mem = 0; mem < POPSIZE; mem++)  
     {  
     for (i = 0; i < NVARS; i++)  
           x[i+1] = population[mem].gene[i];  
//&sup1;&Oslash;&frac14;ü&micro;&atilde;&pound;&not;&para;&Ocirc;&Oacute;&Uacute;&sup2;&raquo;&Iacute;&not;&micro;&Auml;&Icirc;&Ecirc;&Igrave;&acirc;&pound;&not;&ETH;&THORN;&cedil;&Auml;&sup2;&raquo;&Iacute;&not;&micro;&Auml;&Ecirc;&Ecirc;&Oacute;&brvbar;&Ouml;&micro;&ordm;&macr;&Ecirc;&yacute;      
//   population[mem].fitness = (x[1]*x[1]) - (x[1]*x[2]) + x[3];  
     population[mem].fitness = 5*sin(x[1]*sin(x[2])+cos(x[2])); 
     }  
}  
 
/***************************************************************/  
/* Keep_the_best function: This function keeps track of the    */  
/* best member of the population. Note that the last entry in  */  
/* the array Population holds a copy of the best individual    */  
/***************************************************************/  
 
void keep_the_best()  
{  
int mem;  
int i;  
cur_best = 0; /* stores the index of the best individual */  
 
for (mem = 0; mem < POPSIZE; mem++)  
     {  
     if (population[mem].fitness > population[POPSIZE].fitness)  
           {  
           cur_best = mem;  
           population[POPSIZE].fitness = population[mem].fitness;  
           }  
     }  
/* once the best member in the population is found, copy the genes */  
for (i = 0; i < NVARS; i++)  
     population[POPSIZE].gene[i] = population[cur_best].gene[i];  
}  
 
/****************************************************************/  
/* Elitist function: The best member of the previous generation */  
/* is stored as the last in the array. If the best member of    */  
/* the current generation is worse then the best member of the  */  
/* previous generation, the latter one would replace the worst  */  
/* member of the current population                             */  
/****************************************************************/  
 
void elitist()  
{  
int i;  
double best, worst;             /* best and worst fitness values */  
int best_mem, worst_mem; /* indexes of the best and worst member */  
 
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 individual from the new population is better than */  
/* the best individual from the previous population, then    */  
/* copy the best from the new population; else replace the   */  
/* worst individual from the current population with the     */  
/* best one from the previous generation                     */  
 
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