简单的遗传算法源代码

导读：
　　 文章由算法源码吧(www.sfcode.cn) 收集
　　这是一个非常简单的遗传算法源代码，是由Denis Cormier (North Carolina State University)开发的，Sita S.Raghavan (University of North Carolina at Charlotte)修正。代码保证尽可能少，实际上也不必查错。对一特定的应用修正此代码，用户只需改变常数的定义并且定义“评价函数”即可。注意代码 的设计是求最大值，其中的目标函数只能取正值；且函数值和个体的适应值之间没有区别。该系统使用比率选择、精华模型、单点杂交和均匀变异。如果用 Gaussian变异替换均匀变异，可能得到更好的效果。代码没有任何图形，甚至也没有屏幕输出，主要是保证在平台之间的高可移植性。读者可以从ftp.uncc.edu, 目录 coe/evol中的文件prog.c中获得。要求输入的文件应该命名为‘gadata.txt’；系统产生的输出文件为‘galog.txt’。输入的 文件由几行组成：数目对应于变量数。且每一行提供次序——对应于变量的上下界。如第一行为第一个变量提供上下界，第二行为第二个变量提供上下界，等等。
　　/**************************************************************************/
　　/* 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
　　#include
　　#include
　　/* Change any of these parameters to match your needs */
　　#define POPSIZE 50 /* population size */
　　#define MAXGENS 1000 /* max. number of generations */
　　#define NVARS 3 /* no. of problem variables */
　　#define PXOVER 0.8 /* probability of crossover */
　　#define PMUTATION 0.15 /* 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)
　　{
　　fprintf(galog,"/nCannot open input file!/n");
　　exit(1);
　　}
　　/* initialize variables within the bounds */
　　for (i = 0; i
　　{
　　fscanf(infile, "%lf",&lbound);
　　fscanf(infile, "%lf",&ubound);
　　for (j = 0; 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];
　　for (mem = 0; mem
　　{
　　for (i = 0; i 　　x[i+1] = population[mem].gene[i];
　　population[mem].fitness = (x[1]*x[1]) - (x[1]*x[2]) + x[3];
　　}
　　}
　　/***************************************************************/
　　/* 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
　　{
　　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
　　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
　　{
　　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
　　population[POPSIZE].gene[i] = population[best_mem].gene[i];
　　population[POPSIZE].fitness = population[best_mem].fitness;
　　}
　　else
　　{
　　for (i = 0; i 　　population[worst_mem].gene[i] = population[POPSIZE].gene[i];
　　population[worst_mem].fitness = population[POPSIZE].fitness;
　　}
　　}
　　/**************************************************************/
　　/* Selection function: Standard proportional selection for */
　　/* maximization problems incorporating elitist model - makes */
　　/* sure that the best member survives */
　　/**************************************************************/
　　void select(void)
　　{
　　int mem, i, j, k;
　　double sum = 0;
　　double p;
　　/* find total fitness of the population */
　　for (mem = 0; mem
　　{
　　sum += population[mem].fitness;
　　}
　　/* calculate relative fitness */
　　for (mem = 0; mem
　　{
　　population[mem].rfitness = population[mem].fitness/sum;
　　}
　　population[0].cfitness = population[0].rfitness;
　　/* calculate cumulative fitness */
　　for (mem = 1; mem
　　{
　　population[mem].cfitness = population[mem-1].cfitness +
　　population[mem].rfitness;
　　}
　　/* finally select survivors using cumulative fitness. */
　　for (i = 0; i 　　{
　　p = rand()%1000/1000.0;
　　if (p
　　newpopulation[i] = population[0];
　　else
　　{
　　for (j = 0; j
　　if (p >= population[j].cfitness &&
　　p
　　newpopulation[i] = population[j+1];
　　}
　　}
　　/* once a new population is created, copy it back */
　　for (i = 0; i 　　population[i] = newpopulation[i];
　　}
　　/***************************************************************/
　　/* Crossover selection: selects two parents that take part in */
　　/* the crossover. Implements a single point crossover */
　　/***************************************************************/
　　void crossover(void)
　　{
　　int i, mem, one;
　　int first = 0; /* count of the number of members chosen */
　　double x;
　　for (mem = 0; mem
　　{
　　x = rand()%1000/1000.0;
　　if (x
　　{
　　++first;
　　if (first % 2 == 0)
　　Xover(one, mem);
　　else
　　one = mem;
　　}
　　}
　　}
　　/**************************************************************/
　　/* Crossover: performs crossover of the two selected parents. */
　　/**************************************************************/
　　void Xover(int one, int two)
　　{
　　int i;
　　int point; /* crossover point */
　　/* select crossover point */
　　if(NVARS >1)
　　{
　　if(NVARS == 2)
　　point = 1;
　　else
　　point = (rand() % (NVARS - 1)) + 1;
　　for (i = 0; i 　　swap(&population[one].gene[i], &population[two].gene[i]);
　　}
　　}
　　/*************************************************************/
　　/* Swap: A swap procedure that helps in swapping 2 variables */
　　/*************************************************************/
　　void swap(double *x, double *y)
　　{
　　double temp;
　　temp = *x;
　　*x = *y;
　　*y = temp;
　　}
　　/**************************************************************/
　　/* Mutation: Random uniform mutation. A variable selected for */
　　/* mutation is replaced by a random value between lower and */
　　/* upper bounds of this variable */
　　/**************************************************************/
　　void mutate(void)
　　{
　　int i, j;
　　double lbound, hbound;
　　double x;
　　for (i = 0; i 　　for (j = 0; j
　　{
　　x = rand()%1000/1000.0;
　　if (x
　　{
　　/* find the bounds on the variable to be mutated */
　　lbound = population[i].lower[j];
　　hbound = population[i].upper[j];
　　population[i].gene[j] = randval(lbound, hbound);
　　}
　　}
　　}
　　/***************************************************************/
　　/* Report function: Reports progress of the simulation. Data */
　　/* dumped into the output file are separated by commas */
　　/***************************************************************/
　　void report(void)
　　{
　　int i;
　　double best_val; /* best population fitness */
　　double avg; /* avg population fitness */
　　double stddev; /* std. deviation of population fitness */
　　double sum_square; /* sum of square for std. calc */
　　double square_sum; /* square of sum for std. calc */
　　double sum; /* total population fitness */
　　sum = 0.0;
　　sum_square = 0.0;
　　for (i = 0; i 　　{
　　sum += population[i].fitness;
　　sum_square += population[i].fitness * population[i].fitness;
　　}
　　avg = sum/(double)POPSIZE;
　　square_sum = avg * avg * POPSIZE;
　　stddev = sqrt((sum_square - square_sum)/(POPSIZE - 1));
　　best_val = population[POPSIZE].fitness;
　　fprintf(galog, "/n%5d, %6.3f, %6.3f, %6.3f /n/n", generation,
　　best_val, avg, stddev);
　　}
　　/**************************************************************/
　　/* Main function: Each generation involves selecting the best */
　　/* members, performing crossover &mutation and then */
　　/* evaluating the resulting population, until the terminating */
　　/* condition is satisfied */
　　/**************************************************************/
　　void main(void)
　　{
　　int i;
　　if ((galog = fopen("galog.txt","w"))==NULL)
　　{
　　exit(1);
　　}
　　generation = 0;
　　fprintf(galog, "/n generation best average standard /n");
　　fprintf(galog, " number value fitness deviation /n");
　　initialize();
　　evaluate();
　　keep_the_best();
　　while(generation
　　{
　　generation++;
　　select();
　　crossover();
　　mutate();
　　report();
　　evaluate();
　　elitist();
　　}
　　fprintf(galog,"/n/n Simulation completed/n");
　　fprintf(galog,"/n Best member: /n");
　　for (i = 0; i 　　{
　　fprintf (galog,"/n var(%d) = %3.3f",i,population[POPSIZE].gene[i]);
　　}
　　fprintf(galog,"/n/n Best fitness = %3.3f",population[POPSIZE].fitness);
　　fclose(galog);
　　printf("Success/n");
　　 本文链接网址

本文转自
http://www.sfcode.cn/soft/00538835.htm