pso.cpp

在理解粒子群算法（PSO）前提下

/*各位老师好，这是我今天遇到的一个问题： 
一个全局变量individual[i].speed[j]在初始化initiate（）函数中输出，和初始化之后直接输出，
结果不同，不知道是为什么？ 
两个输出语句位置已经在文中标出，我觉得应该是没有变化呀，可是结果就是不一致。单步调试不成功 
各位老是帮帮忙吧，实在是水平有限，不知道问题出在哪里？ 
谢谢 
*/


//库文件 
#include   <iostream> 
//using   namesapce   std; 
#include <math.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 


using   namespace   std; 

//#include       <ostream.h>   

//#include   "cmath " 

//随机数定义 
#define   rdint(i)(rand()%(int)(i)) 
#define   rdft()(double)((double)(rdint(2000)-1000)) 
#define   rdftspeed()(double)((double)rdft()/(1299)) 
#define   rdftspeed1()(double)((double)(rdft()/119999.0)) 
#define   rdftIW()(double)((double)(rand()%(1638))/(14869.0)) 

//宏定义 
#define   POPSIZE   20 
#define   DIMENSION   3 
#define   MAXFITNESS   10000 

//全局变量定义 
double   W=1.0; 
double   C1=1.8; 
double   C2=1.8; 
double   VMAX=3; 
double   VMIN=-3; 


double   XMIN=-2.0; 
double   XMAX=2.0; 
double   P[DIMENSION]; 
double   PBEST; 

void   resolve(int   a,int   I); 
//double   IW_Buy[]={0.45,0.2,0.35}; 
double   IW_Buy[]={0.1,0.3,0.6}; 
//double   IW_Sale[]={0.36,0.34,0.3}; 
double   IW_Sale[]={0.1,0.3,0.6}; 

double   IVR_Sale[]={50,3,20}; 
double   IVR_Buy[]={60,5,12}; 

double   IV_store[POPSIZE][DIMENSION]={40.1,3.4,14.8}; 


struct   indi 
{ 
double   IV[DIMENSION]; 
double   best[DIMENSION]; 
double   bestfitness; 
double   fitness; 
        double   speed[DIMENSION]; 
}individual[POPSIZE]; 


void   initiate(double   IV_store[DIMENSION],int   a); 
void   calculation(int   num,double   IV_nego[DIMENSION],int   I,int   a); 
void   globalbest(int   number); 
void   localbest(int   number); 


//程序初始化定义 
void   initiate(double   IV_store[POPSIZE][DIMENSION],int   a) 
{ 
int   i,j; 
for(i=0;i <POPSIZE;i++) 
{ 
    
      individual[i].IV[0]=IV_store[0][0]+rdft()/456; 
//       cout < < "individual[ " < <i < < "].IV[0]== " < <individual[i].IV[0] < < "       "; 
      individual[i].IV[1]=IV_store[0][1]+rdft()/1000; 
//       cout < < "individual[ " < <i < < "].IV[1]== " < <individual[i].IV[1] < < "       "; 
      individual[i].IV[2]=IV_store[0][2]+rdft()/800; 
//             cout < < "individual[ " < <i < < "].IV[2]== " < <individual[i].IV[2] < < "       "; 
//       cout < <endl; 
} 


for(i=0;i <POPSIZE;i++) 
{ 
    for(j=0;j <DIMENSION;j++) 
    { 
      individual[i].speed[j]=VMAX*rdftspeed(); 

      //********************************************************************* 
      cout << "individual[ " <<i << "].speed[ " <<j << "]== " <<individual[i].speed[j] << "         "; 
      //********************************************************************** 
    } 
    cout <<endl; 
} 
    
    
for(i=0;i <POPSIZE;i++) 
    for(j=0;j <POPSIZE;j++) 
      individual[i].best[j]=individual[i].IV[j]; 

for(i=0;i <POPSIZE;i++) 
    calculation(i,IV_store[0],1,a); 
for(i=0;i <POPSIZE;i++) 
    individual[i].bestfitness=individual[i].fitness; 
globalbest(0); 

} 

//微粒历史最优位置修改程序 
void   localbest(int   number) 
{ 
int   i; 
if(individual[number].bestfitness> individual[number].fitness) 
for(i=0;i <DIMENSION;i++) 
    individual[number].best[i]=individual[number].IV[i]; 
individual[number].bestfitness=individual[number].fitness; 

} 

//种群历史最优位置修改程序 

void   globalbest(int   number) 
{ 
int   i,j; 
double   s=0; 
int   flag=0; 
if(number==0) 
{ 
    s=individual[0].fitness; 
    flag=0; 
    for(i=1;i <POPSIZE;i++) 
      if(individual[i].fitness <s) 
      { 
        s=individual[i].fitness; 
        flag=i; 
      } 
      
    for(i=1;i <DIMENSION;i++) 
      P[i]=individual[flag].IV[i]; 
    PBEST=individual[flag].fitness; 
    cout << "PBEST= " <<PBEST; 
} 
else 
{ 
for(i=0;i <POPSIZE;i++) 
    if(individual[i].bestfitness <PBEST) 
    { 
      for(j=0;j <DIMENSION;j++) 
        P[j]=individual[i].best[j]; 
      PBEST=individual[i].bestfitness; 
    } 
} 
} 
//适应值函数计算程序 
void   calculation(int   num,double   IV_nego[DIMENSION],int   I,int   a) 
{ 

switch(a) 
{ 
case   1://卖方僵局 
    if(individual[num].IV[0] <60&&individual[num].IV[0]> 50) 
      individual[num].fitness=-((individual[num].IV[1]-IV_nego[1]) 
                                                      +(individual[num].IV[2]-IV_nego[2])); 
    else 
      individual[num].fitness=MAXFITNESS; 
    break; 
case   0://买方僵局 
    if(individual[num].IV[0] <60&&individual[num].IV[0]> 50) 
      individual[num].fitness=((individual[num].IV[1]-IV_nego[1]) 
                                                      +(individual[num].IV[2]-IV_nego[2])); 
    else 
      individual[num].fitness=MAXFITNESS; 
    break; 
} 


} 

//主程序 
void   main() 
{ 
srand((unsigned)time(NULL)); 

resolve(0,1); 


} 
void   resolve(int   a,int   I) 
{ 
double   IW[DIMENSION]; 
double   deltaSum=0; 
double   deltaSum2=0; 
double   IV_Nego[DIMENSION]; 
for(int   p=0;p <DIMENSION;p++) 
for(int   p=0;p <DIMENSION;p++) 
    IV_Nego[p]=IV_store[0][p]; 

if(a==0)///买方a：标志 
{ 
    for(int   m=0;m <DIMENSION;m++) 
      IW[m]=IW_Buy[m]; 
} 
else   if(a==1)//卖方 
{ 
    for(int   n=0;n <DIMENSION;n++) 
      IW[n]=IW_Sale[n]; 

} 
for(int   l=0;l <DIMENSION;l++) 
    deltaSum+=IW[l]*IV_store[0][l]; 
cout << "deltaSum==" <<deltaSum <<'\n'; 
int   i,j,k,t,total=0; 
double   sum=0; 
for(j=0;j <1;j++) 
{ 
    initiate(IV_store,a); 
    for(k=0;k <POPSIZE;k++) 
	{
      for(t=0;t <DIMENSION;t++) 
      { 
        cout << "individual["<<k<<"].speed["<<t<<"]== "<<individual[k].speed[t] << "\;"; 
		cout<<'\n';
      } 
	  
	}
    for(i=0;i <1;i++) 

    { 
      cout << "i== " <<i <<'\,'<<endl; 
        //W=1.0-i*rdftIW();//0.6/199; 
      W=1.0-i*0.6;//;*rdftIW(); 
      cout << "W== " <<W <<'\n'<<endl; 

      { 
        for(k=0;k <POPSIZE;k++) 
        { 
          //srand((unsigned)time(NULL)); 
          for(t=0;t <DIMENSION;t++) 
          { 
            //cout < < "individual[ " < <k < < "].speed[ " < <t < < "]== " < <individual[k].speed[t] < < "     "; 
            //******************************************** 
          } 
          for(t=0;t <DIMENSION;t++) 
          { 
            srand((unsigned)time(NULL)); 
            //******************************************** 
            //cout < < "individual[ " < <k < < "].speed[ " < <t < < "]== " < <individual[k].speed[t] < < "     "; 
            //******************************************** 
            individual[k].speed[t]=W*individual[k].speed[t]+C1*rdftspeed1()*( 
              individual[k].best[t]-individual[k].IV[t])+C2*rdftspeed1()*(P[t]- 
              individual[k].IV[t]); 
            if(individual[k].speed[t]> VMAX) 
              individual[k].speed[t]=VMAX; 
            if(individual[k].speed[t] <VMIN) 
              individual[k].speed[t]=VMIN; 
//           
          } 
          cout <<endl; 
//           
        
          for(t=1;t <DIMENSION;t++) 
          { 
            individual[k].IV[t]=individual[k].IV[t]+individual[k].speed[t]; 
//             
          } 


          if(individual[k].IV[1] <IVR_Sale[1]) 
            individual[k].IV[1]=individual[k].IV[1]+(IVR_Buy[1]-IVR_Sale[1]); 
          if(individual[k].IV[1]> IVR_Buy[1]) 
            individual[k].IV[1]=individual[k].IV[1]-(IVR_Buy[1]-IVR_Sale[1]); 

          if(individual[k].IV[2]> IVR_Sale[2]) 
            individual[k].IV[2]=individual[k].IV[2]-(IVR_Buy[2]-IVR_Sale[2]); 
          if(individual[k].IV[2] <IVR_Buy[2]) 
            individual[k].IV[2]=individual[k].IV[2]+(IVR_Buy[2]-IVR_Sale[2]); 
          deltaSum2=0; 
          for(t=1;t <DIMENSION;t++) 
            deltaSum2+=IW[t]*individual[k].IV[t]; 

          individual[k].IV[0]=(deltaSum-deltaSum2)/IW[0]; 
          for(int   ii=0;ii <DIMENSION;ii++) 
              
          calculation(k,IV_Nego,I,a); 
          localbest(k); 
        } 
        globalbest(1); 
      } 
    } 
    cout << "i= " <<i << "     " << "PBEST= " <<PBEST<<endl; 
    
} 

}