gacode.cpp

遗传算法的C++源代码

#include "GlobalApi.h"    
#include "stdafx.h"    
#include "cdib.h"    
#include "math.h"    
#include <DIRECT.H>    
#include <COMPLEX>    
#include <STDIO.H>    
#include "malloc.h"    
#include "stdlib.h"    
   
   
using namespace std;   
   
#define WIDTHBYTES(bits)    (((bits) + 31) / 32 * 4)    
   
   
   
   
   
//GA////////////////////////////////////////////////////////////////    
   
struct individual                       /* 个体*/   
{   
    unsigned *chrom;                    /* 染色体 */   
    double   fitness;                   /* 个体适应度*/   
    unsigned char   varible;                   /* 个体对应的变量值*/   
    int      xsite;                     /* 交叉位置 */   
    int      parent[2];                 /* 父个体  */   
    int      *utility;                  /* 特定数据指针变量 */   
};   
struct bestever                         /* 最佳个体*/   
{   
    unsigned *chrom;                    /* 最佳个体染色体*/   
    double   fitness;                   /* 最佳个体适应度 */   
    double   varible;                   /* 最佳个体对应的变量值 */   
    int      generation;                /* 最佳个体生成代 */   
};   
 struct individual *oldpop;             /* 当前代种群 */   
 struct individual *newpop;             /* 新一代种群 */   
 struct bestever bestfit;               /* 最佳个体 */   
 double sumfitness;                     /* 种群中个体适应度累计 */   
 double max;                            /* 种群中个体最大适应度 */   
 double avg;                            /* 种群中个体平均适应度 */   
 double min;                            /* 种群中个体最小适应度 */   
 float  pcross;                         /* 交叉概率 */   
 float  pmutation;                      /* 变异概率 */   
 float  pmutationSA;                    /*  SA抖动参数*/   
 int    popsize;                        /* 种群大小  */   
 int    lchrom;                         /* 染色体长度*/   
 int    chromsize;                      /* 存储一染色体所需字节数 */   
 int    gen;                            /* 当前世代数 */   
 int    maxgen;                         /* 最大世代数   */   
 int    run;                            /* 当前运行次数 */   
 int    maxruns;                        /* 总运行次数   */   
 int    printstrings;                   /* 输出染色体编码的判断，0 -- 不输出, 1 -- 输出 */   
 int    nmutation;                      /* 当前代变异发生次数 */   
 int    ncross;                         /* 当前代交叉发生次数 */   
long Histgram[256];   
long sum=0;   
double u=0;   
   
   
/* 随机数发生器使用的静态变量 */   
static double oldrand[55];   
static int jrand;   
static double rndx2;   
static int rndcalcflag;   
/* 输出文件指针 */   
FILE *outfp ;   
   
void advance_random();   
int flip(float);rnd(int, int);   
void randomize();   
double randomnormaldeviate();   
float randomperc(),rndreal(float,float);   
void warmup_random(float);   
void initialize(CDib *pDib),initdata(CDib *pDib),initpop();   
void initreport(),generation(),initmalloc();   
void freeall(),nomemory(char *),report();   
void writepop(),writechrom(unsigned *);   
void preselect();   
void statistics(struct individual *);   
void title(),repchar (FILE *,char *,int);   
void skip(FILE *,int);   
int select();   
void object(struct individual *);   
int crossover (unsigned *, unsigned *, unsigned *, unsigned *);   
void mutation(unsigned *);   
double tempt(struct individual *pop);  //设均方值为初温    
void zhifantu(CDib *pDib);     //直方图    
           
   
   
void zhifantu(CDib *pDib)   
   
{   
    LPBYTE lpDIBBits;   
    LONG lWidth;    
    LONG lHeight;   
   
    LPSTR   lpSrc;   
    BYTE pixel;   
   
    CSize sizeImage     = pDib->GetDimensions();   
    lWidth=sizeImage.cx;   
    lHeight=sizeImage.cy;   
    lpDIBBits=pDib->m_lpImage;   
   
    LONG lLineBytes;   
    lLineBytes = WIDTHBYTES(lWidth * 8);   
   
    for(int k=0;k<256;k++)   
    {   
      Histgram[k]=0;   
    }   
   
    for (int i = 0;i <LHEIGHT if(pop[j].fitness pop[j].fitness; + sumfitness="0;" { j++) popsize; < j="0;j" for(j="0;" * 计算最大、最小和累计适应度 max="pop[0].fitness;" min="pop[0].fitness;" j; i, int 计算种群统计数据 *pop) individual statistics(struct void } return(i-1); i else sum="Histgram[j]+sum;" i++) popsize); (i && pick) (sum for(i="0;" !="0)" if(sumfitness pick="randomperc();" i; pick; sum, float randomperc(); extern 轮盘赌选择* select() preselect() 输出染色体编码 *chrom) writechrom(unsigned writepop() 输出种群统计结果 report() exit(-1); 内存不足，退出* *string) nomemory(char free(bestfit.chrom); free(newpop); free(oldpop); free(newpop[i].chrom); free(oldpop[i].chrom); 释放内存空间 freeall() chromosome?); nomemory(?bestfit NULL) malloc(nbytes))="=" *) if((bestfit.chrom="(unsigned" chromosomes?); nomemory(?newpop if((newpop[j].chrom="(unsigned" nomemory(?oldpop if((oldpop[j].chrom="(unsigned" nbytes="popsize*sizeof(struct" 分配给染色体内存空间 nomemory(?newpop?); if((newpop="(struct" nomemory(?oldpop?); if((oldpop="(struct" individual); 分配给当前代和新一代种群内存空间 *malloc(); char nbytes; unsigned *为全局数据变量分配空间 initmalloc() (popsize-1)); }while(j 2; newpop[j+1].parent[1]="mate2+1;" newpop[j+1].xsite="jcross;" newpop[j+1].parent[0]="mate1+1;" object(&(newpop[j+1])); newpop[j].parent[1]="mate2+1;" newpop[j].xsite="jcross;" newpop[j].parent[0]="mate1+1;" *记录亲子关系和交叉位置 object(&(newpop[j])); 计算适应度 解码, mutation(newpop[j+1].chrom); mutation(newpop[j].chrom); newpop[j+1].chrom); newpop[j].chrom, oldpop[mate2].chrom, jcross="crossover(oldpop[mate1].chrom," 交叉和变异 mate2="select();" mate1="select();" 挑选交叉配对 do 变异 交叉, 选择, preselect(); 每代运算前进行预选 jcross, mate2, mate1, generation() 初始参数输出 initreport() 计算初始适应度* object(&(oldpop[j])); oldpop[j].xsite="0;" oldpop[j].parent[1]="0;" 初始父个体信息 oldpop[j].parent[0]="0;" oldpop[j].chrom[k]="0;" if(flip(0.5)) j1++) j1 for(j1="1;" stop="lchrom" (k*(8*sizeof(unsigned))); - (chromsize-1)) if(k="=" k++) chromsiz
e; k for(k="0;" mask="1;" stop; k, j1, j, 随机初始化种群 initpop() pmutation="0.2;" 变异率(0.01-0.9); pcross="0.6;" 交叉率(0.2-0.99); maxgen="50;" 最大世代数 printstrings="0;" lchrom="8;" popsize="20;" 种群大小(50-200); 遗传算法参数输入 *pDib) initdata(CDib initreport(); temptold="1000;" statistics(oldpop); initpop(); 初始化种群，并统计计算结果 bestfit.generation="0;" bestfit.fitness="0.0;" ncross="0;" nmutation="0;" 初始化全局计数变量和一些数值* randomize(); 初始化随机数发生器 initmalloc(); *分配给全局数据结构空间 chromsize++; if(lchrom%(8*sizeof(unsigned))) chromsize="(lchrom/(8*sizeof(unsigned)));" 确定染色体的字节长度 initdata(pDib); 键盘输入遗传算法参数 遗传算法初始化 initialize(CDib u (j="0;j<256;j++)" for (int Histgram[pixel]++; char)*lpSrc; pixel="(unsigned" lLineBytes *)lpDIBBits lpSrc="(char" 指向源图像倒数第j行，第i个象素的指针 <lWidth;j++) for(int ;i++)> 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;   
      }   
      }   
    /* 计算平均适应度 */   
    avg = sumfitness/popsize;   
}   
   
void title()   
{   
     
   
}   
   
void repchar (FILE *outfp,char *ch,int repcount)   
{   
    int j;   
    for (j = 1; j <= repcount; j++) printf("%s", ch);   
}   
   
void skip(FILE *outfp,int skipcount)   
{   
    int j;   
    for (j = 1; j <= skipcount; j++) printf("\n");   
}   
   
   
   
void object(struct individual *critter)  /* 计算适应度函数值 */   
{   
    unsigned mask=1;   
    unsigned bitpos;   
    unsigned tp;   
    double  bitpow ;   
    int j,k,stop;   
   
   
    double w0=0.0,w1=0.0,u0=0.0,u1=0.0;   
    long sum0=0,sum1=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;   
      }   
    }   
   
   
   
//u0    
for (j=0;j<CRITTER->varible;j++)   
    {   
      sum0=Histgram[j]+sum0;       
    }   
   
  for (j=0;j<CRITTER->varible;j++)   
    {   
      u0=Histgram[j]*j+u0;     
    }   
   
  u0=(double)u0/(double)sum0;   
   
   
   
//u1    
   
for (j=critter->varible;j<256;j++)   
    {   
      sum1=Histgram[j]+sum1;       
    }   
   
for (j=critter->varible;j<256;j++)   
    {   
      u1=Histgram[j]*j+u1;     
    }   
   
  u1=(double)u1/(double)sum1;