inherit.cpp

本程序利用遗传算法解决一简单的多项式极值问题

/**************************************************************************/
/* 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>
#include <iostream.h>
#include "time.h"
#include <fstream.h>
#include "iomanip.h"


/* Change any of these parameters to match your needs */

#define POPSIZE 500              /* 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 */
ofstream 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(ofstream);



/**************************************************************/
/* 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)
{
//  	cout<<"the programm is going1......\n";
    printf("the programm is going......\n");

	int i;
    srand(time(NULL));

	ofstream galog;                     /* an output file */
	galog.open("galog.txt");
	if (galog.fail())
	{
		cout<<"can't create the file 'galog.txt' "<<endl;
		exit(1);
	}
	//设置输出格式
	galog<<setiosflags(ios::fixed)//使这个流输出所有的数字
		<<setiosflags(ios::showpoint)//让这个流总是输出小数点
		<<setprecision(4);//使流在小数点后保留两位
//也可以用写列方法格式化
// 	galog.setf(ios::fixed);
// 	galog.setf(ios::showpoint);
// 	galog.precision(4);


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


	galog<<"generation best  average standard \n";
	galog<<"number     value fitness deviation"<<endl;
// 	fprintf(galog, "generation best  average standard \n");
// 	fprintf(galog, " number    value fitness deviation \n");
	
	initialize();
	evaluate();
	keep_the_best();
	while(generation<MAXGENS)
	{
		generation++;
		select();
		crossover();
		mutate();
		report(galog);
		evaluate();
		elitist();
	}
	galog<<"\n\n Simulation completed\n";
	galog<<"\n Best member: \n";
// 	fprintf(galog,"\n\n Simulation completed\n");
// 	fprintf(galog,"\n Best member: \n");

	for (i = 0; i < NVARS; i++)
	{
		galog<<"var("<<i<<") = "<<population[POPSIZE].gene[i]<<endl;
// 		fprintf (galog,"\n var(%d) = %3.3f",i,population[POPSIZE].gene[i]);
	}

	galog<<"Best fitness ="<<population[POPSIZE].fitness<<endl;
// 	fprintf(galog,"\n\n Best fitness = %3.3f",population[POPSIZE].fitness);	
// 	fclose(galog); 
	galog.close();
	cout<<"success\n";
}
/***************************************************************/

/***************************************************************/
/* 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;*/
	ifstream infile;
	int i, j;
	double lbound, ubound;
	
	infile.open("gadata.txt");
	if (infile.fail())
	{
		cout<<"Cannot open input file!\n";
		exit(1);
	}
// 	if ((infile = fopen("gadata.txt","r"))==NULL)
// 	{
// 		fprintf(galog,"\nCannot open input file!\n");
// 		cout<<"Cannot open input file!\n";
// 		exit(1);
// 	}

/* initialize variables within the bounds */
	for (j=0;j<POPSIZE;j++)
	{
		population[j].fitness = 0;  
		population[j].rfitness = 0;  
		population[j].cfitness = 0;   
	}

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

		for (j = 0; j < POPSIZE; j++)
		{		
			population[j].lower[i] = lbound;
			population[j].upper[i]= ubound;
			population[j].gene[i] = randval(population[j].lower[i], population[j].upper[i]);
		}
	}
	infile.close();
// 	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;*/
	val=rand()/((RAND_MAX+1)*1.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 < POPSIZE; mem++)
	{
		for (i = 0; i < NVARS; 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 < 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                             */
/****************************************************************/