sga.c

最近研究遗传算法

    fprintf(outfp," 子群中最小适应度：%f 最大适应度：%f  平均适应度 %f\n", min,max,A[subpop]);
    fprintf(outfp," 子群中发现最佳个体 =>  所在代数: %d  ", bestfit.generation);
    fprintf(outfp," 适应度：%f  染色体: ", bestfit.fitness);
    writechrom((&bestfit)->chrom);
    fprintf(outfp," 对应的变量值: %f", bestfit.varible);
	skip(outfp,1);
	fprintf(outfp," 迄今发现最佳个体   =>  所在分层: %d 所在子群: %d  所在代数: %d ", runA,bestfit.subpopulation,genA);
	fprintf(outfp," 适应度：%f  染色体: ", maxA);
    writechrom((&bestfit)->chromA);
	fprintf(outfp," 对应的变量值: %f", varibleA);
	skip(outfp,1);
	fprintf(outfp," 迄今发现最小适应度 => %f ",minA);
    skip(outfp,1);
    repchar(outfp,"-",80);
    skip(outfp,1);  
}

void writepop()
{
    struct individual *pind;
    int j;
    for(j=0; j<popsize; j++)
    {
        fprintf(outfp,"%3d)  ",j+1);
        /* 当前代个体 */
        pind = &(oldpop[subpop][j]);
        writechrom(pind->chrom);
        fprintf(outfp,"  %8f | ", pind->fitness);
        /* 新一代个体 */
        pind = &(newpop[subpop][j]);
        fprintf(outfp,"(%2d,%2d)   %2d   ",
        pind->parent[0], pind->parent[1], pind->xsite);
        writechrom(pind->chrom);
        fprintf(outfp,"  %8f\n", pind->fitness);
    }
}

void writechrom(chrom)           /* 输出染色体编码 */
unsigned *chrom;
{
    int j, k, stop;
    unsigned mask = 1, tmp;
    for(k = 0; k < chromsize; k++)
    {
        tmp = chrom[k];
        if(k == (chromsize-1))
            stop = lchrom - (k*(8*sizeof(unsigned)));
        else
            stop =8*sizeof(unsigned);
        for(j = 0; j < stop; j++)
        {
            if(tmp&mask)
                fprintf(outfp,"1");
            else
                fprintf(outfp,"0");
            tmp = tmp>>1;
        }
    }
}

void preselect()
{
    int j;
    sumfitness = 0;
    for(j = 0; j < popsize; j++) sumfitness += oldpop[subpop][j].fitness;
}

void preselectA()
{
	int j;
	sumA = 0.0;
	for(j = 0; j< subpopnum; j++) sumA += A[j];
}

int select()                    /* 轮盘赌选择*/
{
    extern float randomperc();
    float sum, pick;
    int i;
    pick = randomperc();
    sum = 0;
    if(sumfitness != 0)
    {
        for(i = 0; (sum < pick) && (i < popsize); i++)
            sum += oldpop[subpop][i].fitness/sumfitness;
    }
    else
        i = rnd(1,popsize);
    return(i-1);
}

int selectA()
{
	extern float randomperc();
    double sum;
	float pick;
    int i;
    pick = randomperc();
    sum = 0.0;
    if(sumA != 0)
    {
        for(i = 0; (sum < pick) && (i < subpopnum); i++)
            sum += A[i]/sumA;
    }
    else
        i = rnd(1,subpopnum);
    return(i-1);
}

void statistics(pop)  /* 计算种群统计数据 */
struct individual *pop;
{
    int i, j;
    sumfitness = 0.0;
    min = pop[0].fitness;
    max = pop[0].fitness;
    /* 计算最大、最小和累计适应度 */
    for(j = 0; j < popsize; j++)
    {
        sumfitness = sumfitness + pop[j].fitness;            
        if(pop[j].fitness > max) max = pop[j].fitness;        
        if(pop[j].fitness < min) min = pop[j].fitness;
        /* new global best-fit individual */
        if(pop[j].fitness > bestfit.fitness)
	  {
	   for(i = 0; i < chromsize; i++)
	    bestfit.chrom[i]      = pop[j].chrom[i];
            bestfit.fitness    = pop[j].fitness;
            bestfit.varible   = pop[j].varible;  
            bestfit.generation = gen;
	  }
      }
    /* 计算平均适应度 */
	if(bestfit.fitness>=maxA)
	{
		maxA=bestfit.fitness;
		for(i = 0; i < chromsize; i++)
			bestfit.chromA[i] = bestfit.chrom[i];
		varibleA = bestfit.varible;
		bestfit.subpopulation = subpop+1;
		runA=run;
		genA=bestfit.generation;
	}
	if(min<=minA) minA = min;
    avg = sumfitness/popsize;
	if(subpop!=(subpopnum-1))
	A[subpop]=avg;
}

void title()
{
  printf("SGA Optimizer Jean.Timex\n");
}

void repchar (outfp,ch,repcount)
FILE *outfp;
char *ch;
int repcount;
{
    int j;
    for (j = 1; j <= repcount; j++) fprintf(outfp,"%s", ch);
}

void skip(outfp,skipcount)
FILE *outfp;
int skipcount;
{
    int j;
    for (j = 1; j <= skipcount; j++) fprintf(outfp,"\n");
}

void objfunc(critter)            /* 计算适应度函数值 */
struct individual *critter;
{
    unsigned mask=1;
    unsigned bitpos;
    unsigned tp;
    double pow(), bitpow ;
    int j, k, stop;
    critter->varible = 0.0;
    for(k = 0; k < chromsize; k++)
    {
        if(k == (chromsize-1))
            stop = lchrom-(k*(8*sizeof(unsigned)));
        else
            stop =8*sizeof(unsigned);
        tp = critter->chrom[k];
        for(j = 0; j < stop; j++)
        {
            bitpos = j + (8*sizeof(unsigned))*k;
            if((tp&mask) == 1)
            {
                bitpow = pow(2.0,(double) bitpos);
                critter->varible = critter->varible + bitpow;
            }
            tp = tp>>1;
        }
    }
    critter->varible =-1+critter->varible*3/(pow(2.0,(double)lchrom)-1);
    critter->fitness =critter->varible*sin(critter->varible*10*atan(1)*4)+2.0;
}

void  mutation(unsigned *child)   /*变异操作*/
{
    int j, k, stop;
    unsigned mask, temp = 1;
    for(k = 0; k < chromsize; k++)
    {
        mask = 0;
        if(k == (chromsize-1))
            stop = lchrom - (k*(8*sizeof(unsigned)));
        else
            stop = 8*sizeof(unsigned);
        for(j = 0; j < stop; j++)
        {
            if(flip(pmutation))
            {
                mask = mask|(temp<<j);
                nmutation++;
            }
        }
        child[k] = child[k]^mask;
    }
}


int crossover (unsigned *parent1, unsigned *parent2, unsigned *child1, unsigned *child2)
/* 由两个父个体交叉产生两个子个体 */
{
    int j, jcross, k;
    unsigned mask, temp;
    if(flip(pcross))
    {
        jcross = rnd(1 ,(lchrom - 1));/* Cross between 1 and l-1 */
        ncross++;
        for(k = 1; k <= chromsize; k++)
        {
            if(jcross >= (k*(8*sizeof(unsigned))))
            {
                child1[k-1] = parent1[k-1];
                child2[k-1] = parent2[k-1];
            }
            else if((jcross < (k*(8*sizeof(unsigned)))) && (jcross > ((k-1)*(8*sizeof(unsigned)))))
            {
                mask = 1;
                for(j = 1; j <= (jcross-1-((k-1)*(8*sizeof(unsigned)))); j++)
                {
                    temp = 1;
                    mask = mask<<1;
                    mask = mask|temp;
                }
                child1[k-1] = (parent1[k-1]&mask)|(parent2[k-1]&(~mask));
                child2[k-1] = (parent1[k-1]&(~mask))|(parent2[k-1]&mask);
            }
            else
            {
                child1[k-1] = parent2[k-1];
                child2[k-1] = parent1[k-1];
            }
        }
    }
    else
    {
        for(k = 0; k < chromsize; k++)
        {
            child1[k] = parent1[k];
            child2[k] = parent2[k];
        }
        jcross = 0;
    }
    return(jcross);
}

void advance_random()          /* 产生55个随机数 */
{
    int j1;
    double new_random;
    for(j1 = 0; j1 < 24; j1++)
    {
        new_random = oldrand[j1] - oldrand[j1+31];
        if(new_random < 0.0) new_random = new_random + 1.0;
        oldrand[j1] = new_random;
    }
    for(j1 = 24; j1 < 55; j1++)
    {
        new_random = oldrand [j1] - oldrand [j1-24];
        if(new_random < 0.0) new_random = new_random + 1.0;
        oldrand[j1] = new_random;
    }
}

int flip(float prob)          /* 以一定概率产生0或1 */
{
    float randomperc();
    if(randomperc() <= prob)
        return(1);
    else
        return(0);
}

void randomize()            /* 设定随机数种子并初始化随机数发生器 */
{
    int j1;
    for(j1=0; j1<=54; j1++)
      oldrand[j1] = 0.0;
    jrand=0;
    warmup_random(randomseed);
}

double randomnormaldeviate()         /* 产生随机标准差 */
{
    double sqrt(), log(), sin(), cos();
    float randomperc();
    double t, rndx1;
    if(rndcalcflag)
    {   rndx1 = sqrt(- 2.0*log((double) randomperc()));
        t = 6.2831853072 * (double) randomperc();
        rndx2 = rndx1 * sin(t);
        rndcalcflag = 0;
        return(rndx1 * cos(t));
    }
    else
    {
        rndcalcflag = 1;
        return(rndx2);
    }
}

float randomperc()            /*与库函数random()作用相同, 产生[0,1]之间一个随机数 */
{
    jrand++;
    if(jrand >= 55)
    {
        jrand = 1;
        advance_random();
    }
    return((float) oldrand[jrand]);
}

int rnd(low, high)           /*在整数low和high之间产生一个随机整数*/
int low,high;
{
    int i;
    float randomperc();
    if(low >= high)
        i = low;
    else
    {
        i = (randomperc() * (high - low + 1)) + low;
        if(i > high) i = high;
    }
    return(i);
}


void warmup_random(float random_seed)       /* 初始化随机数发生器*/
{
    int j1, ii;
    double new_random, prev_random;

    oldrand[54] = random_seed;
    new_random = 0.000000001;
    prev_random = random_seed;
    for(j1 = 1 ; j1 <= 54; j1++)
    {
        ii = (21*j1)%54;
        oldrand[ii] = new_random;
        new_random = prev_random-new_random;
        if(new_random<0.0) new_random = new_random + 1.0;
        prev_random = oldrand[ii];
    }
    advance_random();
    advance_random();
    advance_random();
    jrand = 0;
}


main()           /*  主程序  */
{
    struct individual **temp;
    FILE   *fopen();
    void   title();
    char   *malloc();
        if((outfp = fopen("output4.txt","w")) == NULL)
        {
           fprintf(stderr,"Cannot open output file %s\n","output4.txt");
            exit(-1);
        }
     title();
     maxruns=2;
   for(run=1; run<=maxruns; run++)
   {
	 
	 subpopnum=20;
	 if(run==1)
	 {
		initialize();
		bestfit.subpopulation = 0;
		varibleA = 0;
	 }
	 randomseed = 0;
	 ncross=0;
	 nmutation=0;
	 for(subpop=0;subpop<subpopnum;subpop++)
	 {
        /* 初始化随机数发生器 */
		randomseed += (float)(1)/(float)(subpopnum+run);
		randomize();
    /* 初始化全局计数变量和一些数值*/
		nmutation = 0;
		ncross = 0;
		bestfit.fitness = 0.0;
		bestfit.generation = 0;
		
    /* 初始化种群，并统计计算结果 */
		if(run==1)
			initpop();
		statistics(oldpop[subpop]);
			for(gen=0; gen<maxgen; gen++)
			{
				generation();
            /* 计算新一代种群的适应度统计数据 */
				statistics(newpop[subpop]);
				temp = oldpop;
				oldpop = newpop;
				newpop = temp;
			}
			report();
			if(subpop==(subpopnum-1))
			{
				ncrossA=0;
				nmutationA=0;
				fprintf(outfp,"\n第 %d / %d 次分层优化\n", run,maxruns);
			/* 选择交叉变异 */
				CMTransA();
			/* 计算新一代种群的适应度统计数据 */
			
				for(shu = 0; shu<subpopnum; shu++)
					statistics(newpop[shu]);
				reportA();

				temp = oldpop;
				oldpop = newpop;
				newpop = temp;
			}
	 }
   }
	 freeall();
	 fclose(outfp);
}