scs.cpp

（其中已经包含5个源码）所附源程序C或C++代码文件及其可执行文件 Scs.cpp 基本分类算法源程序

 rep<<" 多路复用器输出 = "<<environrec->output<<endl;
 rep<<" 分类器输出     = "<<environrec->classifieroutput<<endl;
}

int randomchar(double pgeneral)
{
  if(flip((float)pgeneral))
   return(wildcard);
  else if(flip(0.5))
    return(1);
  else
    return(0);
}

void readcondition(int *c,float pgeneral,int nposition)
{
 char ch;
 int j;
    for(j=0;j<=nposition-1;j++)
  {
   cfile>>ch;
   switch(ch)
   {
   case '0':
         c[nposition-1-j]=0;
		 break;
   case '1':
         c[nposition-1-j]=1;
		 break;
   case '#':
         c[nposition-1-j]=wildcard;
		 break;
   case 'R':
         c[nposition-1-j]=randomchar(pgeneral);
		 break;
      }
   	}
 }

void readclassifier(struct classtype *Class,float pgeneral,int nposition)
{
   char ch;
   readcondition(Class->c,pgeneral,nposition);
   cfile>>ch;
   cfile>>Class->a;
   cfile>>Class->strength;
   Class->bid=0.0; Class->ebid=0.0; Class->matchflag=0;
}

int counterspecificity(int *c, int nposition)
{
  int j;
  int temp;
  temp=0;
  j=0;
  while(j<=nposition-1)
  {
   if(c[j]!=wildcard)  temp=temp+1;
   j++;
  }
  return(temp);
}

void initclassifiers(struct poptype *population)
{
    int j;
    cfile>>population->pgeneral;
    cfile>>population->cbid;
    cfile>>population->bidsigma;
    cfile>>population->bidtax;
    cfile>>population->lifetax;
    cfile>>population->bid1;
    cfile>>population->bid2;
    cfile>>population->ebid1;
    cfile>>population->ebid2;
  for(j=0;j<=population->nclassifier-1; j++)
   {
    readclassifier(&population->classifier[j],population->pgeneral,population->nposition);
    population->classifier[j].specificity=counterspecificity(population->classifier[j].c,population->nposition);
   }
 }

void initrepclassifiers(struct poptype *population)
{
 skip(1);
 rep<<"         分类器表参数:                    "<<endl;
 rep<<"------------------------------------------"<<endl;
 rep<<" 分类器数目                 = "<< population->nclassifier<<endl;
 rep<<" 分类器前件码长             = "<< population->nposition<<endl;
 rep<<" 投标系数                   = "<< population->cbid<<endl;
 rep<<" 有效投标中随机噪声的均方差 = "<< population->bidsigma<<endl;
 rep<<" 投标税                     = "<< population->bidtax<<endl;
 rep<<" 存活税                     = "<< population->lifetax<<endl;
 rep<<" 随机概率                   = "<< population->pgeneral<<endl;
 rep<<" 投标确定性基数             = "<< population->bid1<<endl;
 rep<<" 投标确定性倍率             = "<< population->bid2<<endl;
 rep<<" 有效投标确定性基数         = "<< population->ebid1<<endl;
 rep<<" 有效投标确定性倍率         = "<< population->ebid2<<endl;
}

void  writecondition(int *c,int nposition)
{
int j;
for(j=0;j<=nposition-1; j++)
  {
	 switch(c[nposition-1-j])
	{
	case 1:
	   rep<<"1";
	   break;
	case 0:
	   rep<<"0";
	   break;
	case wildcard:
	   rep<<"#";
	   break;
    }     
   }
 }

void writeclassifier(struct classtype *Class,int number,int nposition)
{
 rep<<setw(4)<<number<<"  ";
 rep<<setiosflags(ios::fixed);
 rep<<setprecision(4)<<Class->strength<<"   ";
 rep<<setprecision(3)<<Class->bid;
 rep<<setw(12)<<Class->ebid;
 if(Class->matchflag)
 rep<<"    X   ";
 else
 rep<<"        ";
 writecondition(Class->c,nposition);
 rep<<"["<<setw(3)<<Class->a<<"]"<<endl;
}

void reportclassifiers(struct poptype *population)
{
 int j;
 skip(1);
 rep<<"  编号    权值   投标  有效投标    匹配    分类器  "<<endl;
 rep<<"-----------------------------------------------------"<<endl;
  for(j=0;j<=population->nclassifier-1; j++)
   writeclassifier(&population->classifier[j],j,population->nposition);
}

int match(int *c,int *m, int nposition)
{
  int matchtemp,np;
  np=nposition-1;
  matchtemp=1;
  while(matchtemp && (np>=0))
  {
   matchtemp=(c[np]==wildcard)||(c[np]==m[np]);
   np=np-1;
  }
return(matchtemp);
}

void matchclassifiers(struct poptype *population,int *emess,struct classlist *matchlist)
{
  int j;
  matchlist->nactive=0;
  for(j=0;j<=population->nclassifier-1; j++)
  {
     population->classifier[j].matchflag=match(population->classifier[j].c,emess,population->nposition);
     if(population->classifier[j].matchflag)
     {
     matchlist->clist[matchlist->nactive]=j;
	 matchlist->nactive=matchlist->nactive+1;
	  }
   }
 }

void initaoc(struct crecord *clearingrec)
{
    char ch;
    cfile>>ch;
    clearingrec->bucketbrigadeflag=(ch=='y')||(ch=='Y') ;
    clearingrec->winner=0; clearingrec->oldwinner=0;
}

void initrepaoc(struct crecord *clearingrec)
{
 skip(1);
 rep<<"      信任分配参数： "<<endl;
 rep<<"-----------------------------"<<endl;
 rep<<" 桶队列标志变量  =";
 if(clearingrec->bucketbrigadeflag)
 rep<<"1"<<endl;
 else
 rep<<"0"<<endl;
}

int auction(struct poptype *population,struct classlist *matchlist,int oldwinner)
{
int j,k,winner;
float bidfmaximum;
bidfmaximum=0.0;
winner=oldwinner;
if(matchlist->nactive>=0)
 {
   for(j=0;j<=matchlist->nactive-1;j++)
   {
     k=matchlist->clist[j];
     population->classifier[k].bid=population->cbid*(population->bid1+
         population->bid2*population->classifier[k].specificity)*population->classifier[k].strength;
     population->classifier[k].ebid=population->cbid*(population->ebid1+
              population->ebid2*population->classifier[k].specificity)*population->classifier[k].strength+noise(0,population->bidsigma);
     if(population->classifier[k].ebid>bidfmaximum)
         {
          winner=k;
	      bidfmaximum=population->classifier[k].ebid;
         }
    }
 }
 return(winner);
}

void clearinghouse(struct poptype *population,struct crecord *clearingrec)
{
 float payment;
 payment=population->classifier[clearingrec->winner].bid;
 population->classifier[clearingrec->winner].strength=population->classifier[clearingrec->winner].strength-payment;
 if(clearingrec->bucketbrigadeflag)
  population->classifier[clearingrec->oldwinner].strength=population->classifier[clearingrec->oldwinner].strength+payment;
}

void taxcollector(struct poptype *population)
{
  int j;
  float bidtaxswitch;
  if((population->lifetax!=0.0)||(population->bidtax!=0.0))
   {
       for(j=0;j<=population->nclassifier-1; j++)
       {
        if(population->classifier[j].matchflag)
          bidtaxswitch=1.0;
        else
          bidtaxswitch=0.0;
        population->classifier[j].strength=population->classifier[j].strength-
                         population->lifetax*population->classifier[j].strength-
                         population->bidtax*bidtaxswitch*population->classifier[j].strength;
       }
   }
}

void reportaoc(struct crecord *clearingrec)
{
 skip(1);
 rep<<" 新胜者 ["<<clearingrec->winner<<"]  旧胜者 ["<<clearingrec->oldwinner<<"] "<<endl;
}

void aoc(struct poptype *population,struct classlist *matchlist,struct crecord *clearingrec)
{
   clearingrec->winner=auction(population,matchlist,clearingrec->oldwinner);
   taxcollector(population);
   clearinghouse(population,clearingrec);
}

void initreinforcement(struct rrecord *reinforcementrec)
{
 rfile>>reinforcementrec->reward;
 reinforcementrec->rewardcount=0.0;
 reinforcementrec->rewardcount50=0.0;
 reinforcementrec->totalcount=0.0;
 reinforcementrec->count50=0.0;
 reinforcementrec->proportionreward=0.0;
 reinforcementrec->proportionreward50=0.0;
 reinforcementrec->lastwinner=0;
}

void initrepreinforcement(struct rrecord *reinforcementrec)
{
 skip(1);
 rep<<"       增强参数： "<<endl;
 rep<<"--------------------------"<<endl;
 rep<<" 增强得分 ="<<reinforcementrec->reward<<endl;
}

int criterion(struct rrecord *rrec,struct erecord *environrec)
{
   int tempflag;
   tempflag=(environrec->output==environrec->classifieroutput);
   rrec->totalcount=rrec->totalcount+1;
   rrec->count50=rrec->count50+1;
   if(tempflag)
   {
    rrec->rewardcount=rrec->rewardcount+1;
    rrec->rewardcount50=rrec->rewardcount50+1;
   }
   rrec->proportionreward=rrec->rewardcount/rrec->totalcount;
   if((int)ceil(rrec->count50-50.0)==0)
    {
    rrec->proportionreward50=(float)(rrec->rewardcount50/50.0);
    rrec->rewardcount50=0.0; rrec->count50=0.0;
    }
   return(tempflag);
}

void payreward(struct poptype *population,struct rrecord *rrec,struct crecord *clearingrec)
{
  population->classifier[clearingrec->winner].strength=
           population->classifier[clearingrec->winner].strength+rrec->reward;
  rrec->lastwinner=clearingrec->winner;
}

void reportreinforcement(struct rrecord *reinforcementrec)
{
 skip(1);
 rep<<"          增强报告："<<endl;
 rep<<"---------------------------------------"<<endl;
 rep<<" 正确比例(from start) ="<<reinforcementrec->proportionreward<<endl;
 rep<<" 正确比例(last fifty) ="<<reinforcementrec->proportionreward50<<endl;
 rep<<" 最终获胜分类器号     ="<<reinforcementrec->lastwinner<<endl;
}

void reinforcement(struct rrecord *reinforcementrec,struct poptype *population,
             struct crecord *clearingrec,struct erecord *environrec)
{
 if(criterion(reinforcementrec,environrec))
  payreward(population,reinforcementrec,clearingrec);
}

void advance(struct crecord *clearingrec)
{
 clearingrec->oldwinner=clearingrec->winner;
}

void initga(struct grecord *garec,struct poptype *population)
{
    gfile>>garec->populationselect;
    gfile>>garec->pmutation;
    gfile>>garec->pcrossover;
    gfile>>garec->crowdingfactor;
    gfile>>garec->crowdingsubpop;
    garec->nselect=(int)(garec->populationselect*population->nclassifier*0.5);
    garec->nmutation=0; garec->ncrossover=0;
}

void initrepga(struct grecord *garec)
{
 skip(1);
 rep<<"          遗传算法参数： "<<endl;
 rep<<"---------------------------------------"<<endl;
 rep<<" 选择分类器比例 ="<<garec->populationselect<<endl;
 rep<<" 选择分类器数目 ="<<garec->nselect<<endl;
 rep<<" 变异概率         ="<<garec->pmutation<<endl;
 rep<<" 交叉概率         ="<<garec->pcrossover<<endl;
 rep<<" 排挤因子       ="<<garec->crowdingfactor<<endl;
 rep<<" 排挤子种群     ="<<garec->crowdingsubpop<<endl;
}

int select(struct poptype *population)
{
double random;
float partsum;
int j;
partsum=0.0; j=-1;
random=rand()/32767.*population->sumstrength;
do
   {
   j++;
   partsum=partsum+population->classifier[j].strength;
    } while((partsum<random) &&(j<population->nclassifier));
 return(j);
}

int mutation(int positionvalue,float pmutation,long &nmutation )
{
int tempmutation;
if(flip(pmutation))
 {
   tempmutation=(int)fmod( (double)(positionvalue+rnd(1,2)+1), 3.0)-1;
   nmutation=nmutation+1;
 }
else
   tempmutation=positionvalue;
return( tempmutation);
}

int bmutation(int positionvalue,float pmutation,long &nmutation )
{
int tempmutation;
if(flip(pmutation))
 {
   tempmutation=(int)fmod( (double)(positionvalue+1), 2.0);
    nmutation=nmutation+1;
 }
else
   tempmutation=positionvalue;
return( tempmutation);
}

void crossover(struct classtype *parent1,struct classtype *parent2,struct classtype *child1,struct classtype *child2,
       float pcrossover,float pmutation,int &sitecross,int nposition,long &ncrossover,long &nmutation)
{
float inheritance;
int j;
if(flip(pcrossover))
{
  sitecross=rnd(0,nposition-2);
  ncrossover=ncrossover+1;
}
else
  sitecross=nposition;
 child1->a=bmutation(parent1->a,pmutation,nmutation);
 child2->a=bmutation(parent2->a,pmutation,nmutation);
j=sitecross;
while(j<=nposition-1) 
{