prog.c

采用FORTRAN编制的小生境遗传算法反演程序

            {
			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
    {
		for (i=0; i<NVARS; 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;
    double sum = 0;
    double p;

/* find total fitness of the population */
    for (mem = 0; mem < POPSIZE; mem++)
	{
      sum+=population[mem].fitness;
    }

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

/* calculate cumulative fitness */
    for (mem = 1; mem < POPSIZE; mem++)
	{
		population[mem].cfitness=population[mem-1].cfitness+population[mem].rfitness;
    }

/* finally select survivors using cumulative fitness. */

    for (i = 0; i < POPSIZE; i++)
	{
		p = rand()%1000/1000.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];
		}
	}
/* once a new population is created, copy it back */

    for (i = 0; i < POPSIZE; 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 mem, one=0;
    int first=0; /* count of the number of members chosen */
    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;
         }
      }
}
/**************************************************************/
/* Crossover: performs crossover of the two selected parents. */
/**************************************************************/

void Xover(int one, int two)
{
	int i;
	int point; /* crossover point */
	/* select crossover point */
	double x1=0,x2=0;// 用于实现算术交叉的辅助变量
	double alph=0.0+0.3*(rand()%1000/1000.0);
	if(NVARS>1)
	{
		if(NVARS == 2)
			point = 1;
		else
			point = (rand() % (NVARS - 1)) + 1;
		for (i = 0; i < point; i++)
			swap(&population[one].gene[i], &population[two].gene[i]);
		//{//用于实现算术交叉
		//	x1=population[one].gene[i];
		//	x2=population[two].gene[i];
		//	population[one].gene[i]=alph*x2+(1.0-alph)*x1;
		//	population[two].gene[i]=alph*x1+(1.0-alph)*x2;
		//}

   }
}

/*************************************************************/
/* 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 < POPSIZE; i++)
		for (j = 0; j < NVARS; j++)
		{
			x = rand()%1000/1000.0;
            if (x<PMUTATION)
			{
				/* find the bounds on the variable to be mutated */
				lbound = population[i].lower[j];
				hbound = population[i].upper[j];
				population[i].gene[j] = randvalNu(i,j,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 < POPSIZE; 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+500;
	fprintf(galog, "\n%6.3f\n", best_val);
}

/**************************************************************/
/* 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;
	srand((unsigned int)time(NULL));
    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<MAXGEN)
	{
		generation++;
        select();
        crossover();
        mutate();
        report();
        evaluate();
        elitist();
    }
	fprintf(galog,"\n\n Simulation completed\n");
    fprintf(galog,"\n Best member: \n");
	for (i = 0; i < NVARS; i++)
	{
		fprintf (galog,"\n var(%d) = %10.7f",i,population[POPSIZE].gene[i]);
    }
	fprintf(galog,"\n\n Best fitness = %10.6f",-population[POPSIZE].fitness+500);
    fclose(galog);
    printf("Success\n");
}
/***************************************************************/