PSO源程序.docx
《PSO源程序.docx》由会员分享，可在线阅读，更多相关《PSO源程序.docx（116页珍藏版）》请在冰豆网上搜索。
PSO源程序
//PSO头文件PSO.cpp如下:
//Header__PSO_H
//n
//PlatfoPurposeProvideaclassforparticleswarmoptimizatiormVisualC++7.0
//群微粒算法：
本算法用群微粒算法求目标函数的最大值
//本算法使用步骤
//
（1）派生自己的群微粒类，类中必须定义doubleGetFit（PARTICLE&）方法，用来计算每个微粒的适合度
//
（2）生成派生类实例，并在构造函数中指明微粒坐标维数和群体个数
//
（2）设置微粒坐标上界数组和下界数组，并用SetXup与SetXdown设置微粒坐标上下界
//（3）用SetVmax方法设置微粒最大速度
//（4）设置可选参数：
C1，C2，W和通讯函数
//（5）采用Run方法进行优化运算，优化后用GetBest方法获得最优个体适合度和坐标
#ifndef__PSO_H
#define__PSO_H
//微粒类
classPARTICLE
{
public:
double*X;//微粒的坐标数组
double*V;//微粒的速度数组
double*XBest;//微粒的最好位置数组
intDim;//微粒的维数
doubleFit;//微粒适合度
doubleFitBest;//微粒最好位置适合度
//构造函数
PARTICLE（）;//空构造函数
PARTICLE（intn）;//维数为参数的构造函数
//析构函数
~PARTICLE（）;
voidSetDim（intd）;//设置微粒的维数
};
//定义群粒子类
classPSO
{
protected:
PARTICLE*Particle;//微粒群数组
intPNum;//微粒个数
intGBestIndex;//最好微粒索引
doubleW;//惯性权重
doubleC1;//加速度系数1
doubleC2;//加速度系数2
double*Xup;//微粒坐标上界数组
double*Xdown;//微粒坐标下界数组
double*Vmax;//微粒最大速度数组
voidInitialize（）;//初始化群体
voidCalFit（）;//计算全体适合度
virtualvoidParticleFly（）;//微粒飞翔，产生新一代微粒
//通讯函数，返回值为false时，系统停止优化
bool（*Com）（double,//最优微粒适合度
double*,//最优微粒坐标数组
double**,//所有微粒坐标指针数组
int）;//当前最优微粒索引
public:
//构造函数
PSO（）;//空构造函数
PSO（intdim,//微粒维数
intnum）;//微粒个数
//析构函数
~PSO（）;
voidSetXup（double*）;//设置微粒坐标上界
voidSetXdown（double*）;//设置微粒坐标下界
voidSetVmax（double*）;//设置微粒最大速度，以数组为参数
voidSetVmax（double）;//设置微粒最大速度，以上下界百分比为参数
voidSetW（doublew）{W=w;};//设置权重
voidSetC1（doublec）{C1=c;};//设置C1
voidSetC2（doublec）{C2=c;};//设置C2
voidSetCom（void*p）{Com=（bool（*）（double,double*,double**,int））p;};//设置通讯函数
//计算特定微粒坐标所对应适合度，必须由派生的实际PSO类定义，以便计算适合度
virtualdoubleGetFit（PARTICLE&）=0;
//运行类进行优化
PARTICLE&Run（intmax）;//按最多次数限制运行PSO
PARTICLE&Run（doublefit）;//按最佳适合度目标运行PSO
doubleGetBest（double*）;//获得最优微粒适合度和坐标
};
#endif
//PSO源文件PSO.CPP如下:
//Header__PSO_H
//PurposeProvideaclassforparticleswarmoptimization
//PlatformVisualC++7.0
//Date2002.4.29
//AuthorLiuKang
//群微粒算法：
本算法涌群微粒算法求目标函数的最大值
//本算法使用步骤
//
（1）派生自己的群微粒类，类中必须定义doubleGetFit（PARTICLE&）方法，用来计算每个微粒的适合度
//
（2）生成派生类实例，并在构造函数中指明微粒坐标维数和群体个数
//
（2）设置微粒坐标上界数组和下界数组，并用SetXup与SetXdown设置微粒坐标上下界
//（3）用SetVmax方法设置微粒最大速度
//（4）设置可选参数：
C1，C2，W和通讯函数
//（5）采用Run方法进行优化运算，优化后用GetBest方法获得最优个体适合度和坐标
#include
#include
#include
//#include"PSO.H"
//微粒构造函数
PARTICLE:
:
PARTICLE（）//空构造函数
{
X=0;V=0;XBest=0;Dim=0;
}
PARTICLE:
:
PARTICLE（intn）//维数为参数的构造函数
{
Dim=n;
X=newdouble[Dim];
V=newdouble[Dim];
XBest=newdouble[Dim];
}
//微粒析构函数
PARTICLE:
:
~PARTICLE（）
{
if（Dim）
{
delete[]X;
delete[]V;
delete[]XBest;
}
}
//设置微粒的维数
voidPARTICLE:
:
SetDim（intd）
{
if（X）delete[]X;
if（V）delete[]V;
if（XBest）delete[]XBest;
Dim=d;
X=newdouble[Dim];
V=newdouble[Dim];
XBest=newdouble[Dim];
}
//PSO构造函数
PSO:
:
PSO（）
{
Particle=0;
PNum=0;
GBestIndex=0;
Xup=0;
Xdown=0;
W=1;
C1=2;
C2=2;
Com=0;
}
PSO:
:
PSO（intdim,intnum）
{
Particle=newPARTICLE[num];
for（inti=0;iPNum=num;
GBestIndex=0;
Xup=newdouble[dim];
Xdown=newdouble[dim];
Vmax=newdouble[dim];
W=1;
C1=2;
C2=2;
Com=0;
}
//析构函数
PSO:
:
~PSO（）
{
if（Particle）delete[]Particle;
if（Xup）delete[]Xup;
if（Xdown）delete[]Xdown;
if（Vmax）delete[]Vmax;
}
//设置坐标上界
voidPSO:
:
SetXup（double*up）
{
if（!
Particle）return;
for（inti=0;iXup[i]=up[i];
}
//设置坐标下界
voidPSO:
:
SetXdown（double*d）
{
if（!
Particle）return;
for（inti=0;iXdown[i]=d[i];
}
//设置最大速度
voidPSO:
:
SetVmax（double*max）
{
if（!
Particle）return;
for（inti=0;iVmax[i]=max[i];
}
voidPSO:
:
SetVmax（doublep）
{
if（!
Particle）return;
for（inti=0;iVmax[i]=（Xup[i]-Xdown[i]）*p;
}
//初始化群体
voidPSO:
:
Initialize（）
{
if（!
Particle）return;
staticintkk=（unsigned）time（NULL）;
srand（（unsigned）time（NULL）+kk++）;
GBestIndex=0;
for（inti=0;i{
for（intj=0;j{
Particle[i].X[j]=rand（）/（double）RAND_MAX*（Xup[j]-Xdown[j]）+Xdown[j];//随机初始化每个粒子的坐标
Particle[i].XBest[j]=Particle[i].X[j];
Particle[i].V[j]=rand（）/（double）RAND_MAX*Vmax[j]-Vmax[j]/2;//随机初始化速度
}
Particle[i].Fit=GetFit（Particle[i]）;//计算每个微粒适合度
Particle[i].FitBest=Particle[i].Fit;//设最优适合度初值
if（Particle[i].Fit>Particle[GBestIndex].Fit）GBestIndex=i;//如果这个鸟的适合度大于群体的最大适合度的话，记录下来查找群体最优微粒
}
}
//计算群体各个微粒适合度
voidPSO:
:
CalFit（）
{
if（!
Particle）return;
for（inti=0;iParticle[i].Fit=GetFit（Particle[i]）;
}
//微粒飞翔,产生新一代微粒
voidPSO:
:
ParticleFly（）
{
staticdoubleFitBak[100];//用来存放备份的合适度值
if（!
Particle）return;
staticinttt=（unsigned）time（NULL）;//wo:
以时间为产生随机数的种子
srand（（unsigned）time（NULL）*tt++）;//wo:
srand（）的作用是为rand（）设置种子,两者配合使用的
//整个群体飞向新的位置
for（inti=0;i{
for（intj=0;jParticle[i].V[j]=W*Particle[i].V[j]+//（FitBak[i]-Particle[i].Fit）+//修改速度
rand（）/（double）RAND_MAX*C1*（Particle[i].XBest[j]-Particle[i].X[j]）+
//wo:
此处的产生的两个rand（）是一样的，有待改进?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
//wo:
RAND_MAX为最大随机数
rand（）/（double）RAND_MAX*C2*（Particle[GBestIndex].XBest[j]-Particle[i].X[j]）;
for（j=0;j{
if（Particle[i].V[j]>Vmax[j]）Particle[i].V[j]=Vmax[j];
if（Particle[i].V[j]<-Vmax[j]）Particle[i].V[j]=-Vmax[j];
}
for（j=0;j{
Particle[i].X[j]+=Particle[i].V[j];//修改坐标
if（Particle[i].X[j]>Xup[j]）Particle[i].X[j]=Xup[j];//保护
if（Particle[i].X[j]}
}
//计算各微粒适合度
CalFit（）;
for（i=0;i//设置新的个体最好位置
for（i=0;i{
if（Particle[i].Fit>=Particle[i].FitBest）
{
Particle[i].FitBest=Particle[i].Fit;
for（intj=0;jParticle[i].XBest[j]=Particle[i].X[j];
}
}
//设置群体中新的最优个体
GBestIndex=0;
for（i=0;iif（Particle[i].FitBest>=Particle[GBestIndex].FitBest&&i!
=GBestIndex）GBestIndex=i;
}
//运行群粒算法
PARTICLE&PSO:
:
Run（intn）
{
Initialize（）;
double*opt_p=newdouble[Particle[0].Dim];//通讯用数组，最优点坐标
double**opt_a=newdouble*[PNum];//通讯用数组，所有点坐标
for（inti=0;i{
ParticleFly（）;
if（Com）//通讯函数存在，完成通讯
{
for（intk=0;kfor（k=0;kif（!
Com（Particle[GBestIndex].FitBest,opt_p,opt_a,GBestIndex））break;
}
}
delete[]opt_p;
delete[]opt_a;
returnParticle[GBestIndex];
}
PARTICLE&PSO:
:
Run（doublefit）
{
double*opt_p=newdouble[Particle[0].Dim];//通讯用数组，最优点坐标
double**opt_a=newdouble*[PNum];//通讯用数组，所有点坐标
Initialize（）;
do
{
ParticleFly（）;
if（Com）//通讯函数存在，完成通讯
{
for（intk=0;kfor（k=0;kif（!
Com（Particle[GBestIndex].FitBest,opt_p,opt_a,GBestIndex））break;
}
}while（Particle[GBestIndex].FitBestdelete[]opt_p;
delete[]opt_a;
returnParticle[GBestIndex];
}
//返回最佳个体
doublePSO:
:
GetBest（double*r）
{
for（inti=0;ir[i]=Particle[GBestIndex].XBest[i];
returnParticle[GBestIndex].FitBest;
}
**********************************************************************
//stdafx.h:
includefileforstandardsystemincludefiles,
//orprojectspecificincludefilesthatareusedfrequently,but
//arechangedinfrequently
//
#if!
defined（AFX_STDAFX_H__CA78CC4A_4FB0_49B9_B823_A4DBAEFB44D2__INCLUDED_）
#defineAFX_STDAFX_H__CA78CC4A_4FB0_49B9_B823_A4DBAEFB44D2__INCLUDED_
#if_MSC_VER>1000
#pragmaonce
#endif//_MSC_VER>1000
#defineWIN32_LEAN_AND_MEAN//Excluderarely-usedstufffromWindowsheaders
#include
//TODO:
referenceadditionalheadersyourprogramrequireshere
//{{AFX_INSERT_LOCATION}}
//MicrosoftVisualC++willinsertadditionaldeclarationsimmediatelybeforethepreviousline.
#endif//!
defined（AFX_STDAFX_H__CA78CC4A_4FB0_49B9_B823_A4DBAEFB44D2__INCLUDED_）
*************************************************************************
#ifndef_LIBSVM_H
#define_LIBSVM_H
#ifdef__cplusplus
extern"C"{
#endif
structsvm_node
{
intindex;
doublevalue;
};
structsvm_problem
{
intl;
double*y;
structsvm_node**x;
};
enum{C_SVC,NU_SVC,ONE_CLASS,EPSILON_SVR,NU_SVR};/*svm_type*/
enum{LINEAR,POLY,RBF,SIGMOID,PRECOMPUTED,MIX,COMBINATION};/*kernel_type*/
structsvm_parameter
{
intsvm_type;
intkernel_type;
intdegree;/*forpoly*/
doublegamma;/*forpoly/rbf/sigmoid*/
doublecoef0;/*forpoly/sigmoid*/
doublet;/*formix/combination*/
/*thesearefortrainingonly*/
doublecache_size;/*inMB*/
doubleeps;/*stoppingcriteria*/
doubleC;/*forC_SVC,EPSILON_SVRandNU_SVR*/
intnr_weight;/*forC_SVC*/
int*weight_label;/*forC_SVC*/
double*weight;/*forC_SVC*/
doublenu;/*forNU_SVC,ONE_CLASS,andNU_SVR*/
doublep;/*forEPSILON_SVR*/
intshrinking;/*usetheshrinkingheuristics*/
intprobability;/*doprobabilityestimates*/
};
structsvm_model*svm_train（conststructsvm_problem*prob,conststructsvm_parameter*param）;
voidsvm_cross_validation（conststructsvm_problem*prob,conststructsvm_parameter*param,intnr_fold,double*target）;
intsvm_save_model（constchar*model_file_name,conststructsvm_model*model）;
structsvm_model*svm_load_model（constchar*model_file_name）;
intsvm_get_svm_type（conststructsvm_model*model）;
intsvm_get_nr_class（co
升级会员 