geneticalgorithm.cpp

一个使用遗传算法实现桥梁的最优化维护的代码

{
    int j;
    for (j = 1; j <= repcount; j++) printf("%s", ch);
}

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

void CGeneticAlgorithm::objfunc(struct individual *critter)  /* 计算适应度函数值 */
{
    unsigned mask=1;
    unsigned bitpos;
    unsigned tp;
    double  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.0)*4)+2.0;
	critter->fitness =-1*(critter->varible-1.6)*(critter->varible-1.4)+20;
}

void  CGeneticAlgorithm::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 CGeneticAlgorithm::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 */
		//因为我们程序中一个基因是两个位点表示的，所以要将jcross变为偶数
        if(jcross%2)
		{
			jcross++;
		}
        ncross++;
        for(k = 1; k <= chromsize; k++)
        {
            if(jcross >= (k*32))
            {
                child1[k-1] = parent1[k-1];
                child2[k-1] = parent2[k-1];
            }
            else if((jcross < (k*32)) && (jcross > ((k-1)*32)))
            {
                mask = 1;
                for(j = 1; j <= (jcross-1-((k-1)*32)); 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 CGeneticAlgorithm::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 CGeneticAlgorithm::flip(float prob) /* 以一定概率产生0或1 */
{
   
    if(randomperc() <= prob)
        return(1);
    else
        return(0);
}

void CGeneticAlgorithm::randomize()  /* 设定随机数种子并初始化随机数发生器 */
{
    float randomseed;

    int j1;
    for(j1=0; j1<=54; j1++)
      oldrand[j1] = 0.0;
    jrand=0;
      do
        {
            
          //   printf("随机数种子[0-1]:");
            //  scanf("%f", &randomseed);
			 randomseed = 0.5;
         }
        while((randomseed < 0.0) || (randomseed > 1.0));
    warmup_random(randomseed);
}

double CGeneticAlgorithm::randomnormaldeviate() /* 产生随机标准差 */
{
    //double sqrt(), log(), sin(), cos();
    
    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 CGeneticAlgorithm::randomperc() /*与库函数random()作用相同, 产生[0,1]之间一个随机数 */
{
    jrand++;
    if(jrand >= 55)
    {
        jrand = 1;
        advance_random();
    }
    return((float) oldrand[jrand]);
}

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


void CGeneticAlgorithm::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;
}


// 设置种群的大小
void CGeneticAlgorithm::SetPopsize(int iVar)
{
	this->popsize = iVar;
	if((popsize%2) != 0)
    {
	  // 种群大小已设置为偶数
	  popsize++;
    };
}

// 设置染色体长度
void CGeneticAlgorithm::SetLchrom(int iVar)
{
	this->lchrom = iVar;
}

// 设置最大世代数
void CGeneticAlgorithm::SetMaxgen(int iVar)
{
	this->maxgen = iVar;
}

// 设置交叉率
void CGeneticAlgorithm::SetCross(float fVar)
{
	this->pcross = fVar;
}

// 设置变异率
void CGeneticAlgorithm::SetMutation(float fVar)
{
	this->pmutation = fVar;
}

// 运行遗传算法
int  CGeneticAlgorithm::Run(void)
{

    int i;
	float fTemp;
	bool bStop;
	float fFitness[10];//用于存放最近十次的适应度值，如果最后十次的适应度值相差很小，则可以提前终止运行，并将当前的迭代次数返回
	memset(fFitness,0,sizeof(int)*10);

	struct individual *temp;
	 
	 int  gen;
     for(gen=0; gen<maxgen; gen++)
     {
       //  printf("\n 当前代为 %d, 共 %d 代\n",gen,maxgen);
            /* 产生新一代 */
        this->generation();
            /* 计算新一代种群的适应度统计数据 */
        this->statistics(this->newpop);
            /* 输出新一代统计数据 */
      //  this->report();
        temp = this->oldpop;
        this->oldpop = this->newpop;
        this->newpop = temp;
        
		//一下是建立一个模型，当目标方程满足一定条件时，终止优化过程
		fFitness[gen%10] = avg;
		if(gen<10) 
		{
			continue;
		}
		fTemp = 0;
		for(i = 0; i<10 ;i++)
		{
			fTemp += fFitness[i];

		}
		fTemp /= 10;
		bStop = true;
		for(i = 0; i<10;i++)
		{
			if(abs(fTemp - fFitness[i])/fTemp>0.01)
			{
				bStop = false;
			}
		}
		if(bStop)
			return gen;
        
	 }
	 return maxgen;
}

// 设置出示种群个体中染色体中1出现的概率
void CGeneticAlgorithm::SetInitPop(float fVar)
{
	this->fInitPop = fVar;
}