⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 mypso.cpp

📁 本代码是PSO算法的C语言版本
💻 CPP
字号:
🔍 
//PSO源文件myPSO.CPP如下:
//Header  PSO.H
//Purpose Provide a class for particle swarm optimization
//Platform Visual C++ 6.0
//Date 2005.4.2
//Author ZhouXiandong

//群微粒算法：本算法涌群微粒算法求目标函数的最小值
//本算法使用步骤
// （1）派生自己的群微粒类，类中必须定义double GetFit(PARTICLE&)方法，用来计算每个微粒的适合度
// （2）生成派生类实例，并在构造函数中指明微粒坐标维数和群体个数
// （2）设置微粒坐标上界数组和下界数组，并用SetXup与SetXdown设置微粒坐标上下界
// （3）用SetVmax方法设置微粒最大速度
// （4）设置可选参数：C1，C2，W和通讯函数
// （5）采用Run方法进行优化运算，优化后用GetBest方法获得最优个体适合度和坐标

#include <stdlib.h>
#include <time.h>
#include <math.h>
#include "PSO.H"

//微粒构造函数
PARTICLE::PARTICLE() //空构造函数
{
X = 0; V = 0; XBest = 0; Dim = 0;
}
PARTICLE::PARTICLE(int n) //维数为参数的构造函数
{
Dim = n;
X = new double[Dim];
V = new double[Dim];
XBest = new double[Dim];
}

//微粒析构函数
PARTICLE::~PARTICLE()
{
if(Dim)
{
delete []X;
delete []V;
delete XBest;
}
}

//设置微粒的维数
void PARTICLE::SetDim(int d)
{
if(X) delete []X;
if(V) delete []V;
if(XBest) delete []XBest;
Dim = d;
X = new double[Dim];
V = new double[Dim];
XBest = new double[Dim];
}

//PSO构造函数
PSO::PSO()
{
Particle = 0;
PNum = 0;
GBestIndex = 0;
Xup = 0;
Xdown = 0;
W = 1;
C1 = 2;
C2 = 2;
Com = 0;
}
PSO::PSO(int dim, int num)
{
Particle = new PARTICLE[num];
for(int i=0; i<num; i++) Particle[i].SetDim(dim);
PNum = num;
GBestIndex = 0;
Xup = new double[dim];
Xdown = new double[dim];
Vmax = new double[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;
}
//设置坐标上界
void PSO::SetXup(double *up)
{
if(!Particle) return;
for(int i=0; i<Particle[0].Dim; i++)
Xup[i] = up[i];
}
//设置坐标下界
void PSO::SetXdown(double *d)
{
if(!Particle) return;
for(int i=0; i<Particle[0].Dim;i++)
Xdown[i] = d[i];
}
//设置最大速度
void PSO::SetVmax(double *max)
{
if(!Particle) return;
for(int i=0; i<Particle[0].Dim;i++)
Vmax[i] = max[i];
}
void PSO::SetVmax(double p)
{
if(!Particle) return;
for(int i=0; i<Particle[0].Dim; i++)
Vmax[i] = (Xup[i]-Xdown[i])*p;
}

//初始化群体
void PSO::Initialize()
{
if(!Particle) return;
static int kk=(unsigned)time(NULL);
srand((unsigned)time(NULL)+kk++);
GBestIndex = 0;
for(int i=0; i<PNum; i++)
{
for(int j=0; j<Particle[i].Dim; 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*2*Vmax[j]-Vmax[j];//初始化速度
}
Particle[i].Fit = GetFit(Particle[i]); //计算该微粒适合度
Particle[i].FitBest = Particle[i].Fit; //设最优适合度初值
if(Particle[i].Fit>Particle[GBestIndex].Fit) GBestIndex = i;//查找群体最优微粒
}
}

//计算群体各个微粒适合度
void PSO::CalFit()
{
if(!Particle) return;
for(int i=0; i<PNum; i++)
Particle[i].Fit = GetFit(Particle[i]);
}

//微粒飞翔,产生新一代微粒
void PSO::ParticleFly()
{
	static double FitBak[100];
	if(!Particle) return;
	static int tt=(unsigned)time(NULL);
	srand((unsigned)time(NULL)+tt++);
	//整个群体飞向新的位置
	for(int i=0; i<PNum; i++)
	{
		for(int j=0; j<Particle[i].Dim; j++)
			Particle[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])+
				rand()/(double)RAND_MAX*C2*(Particle[GBestIndex].XBest[j]-Particle[i].X[j]);
		for(j=0; j<Particle[i].Dim; 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].Dim; 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]<Xdown[j]) Particle[i].X[j]=Xdown[j];
		}
	}
	//计算各微粒适合度
	CalFit();
	for(i=0; i<PNum; i++) FitBak[i] = Particle[i].Fit;
	//设置新的个体最好位置
	for(i=0; i<PNum; i++)
	if(Particle[i].Fit<=Particle[i].FitBest)
	{
		Particle[i].FitBest = Particle[i].Fit;
		for(int j=0; j<Particle[i].Dim; j++)
		Particle[i].XBest[j] = Particle[i].X[j];
	}
	//设置新的最优个体
	GBestIndex = 0;
	for(i=0; i<PNum; i++)
		if(Particle[i].FitBest<=Particle[GBestIndex].FitBest && i!=GBestIndex) GBestIndex = i;
}

//运行群粒算法
PARTICLE& PSO::Run(int n)
{
Initialize();
double *opt_p = new double[Particle[0].Dim]; //通讯用数组，最优点坐标
double **opt_a = new double*[PNum]; //通讯用数组，所有点坐标
for(int i=0; i<n; i++)
{ SetW(0.9 -  i* (0.9 - 0.4) / n);  //线性减小w的值;
ParticleFly();
if(Com) //通讯函数存在，完成通讯
{
for(int k=0; k<Particle[0].Dim; k++) opt_p[k]=Particle[GBestIndex].XBest[k];//拷贝最优点坐标
for(k=0; k<PNum; k++) opt_a[k] = Particle[k].X; //指向所有点坐标
if(!Com(Particle[GBestIndex].FitBest,opt_p,opt_a,GBestIndex)) break;
}
}
delete []opt_p;
delete []opt_a;
return Particle[GBestIndex];
}
PARTICLE& PSO::Run(double fit)
{
double *opt_p = new double[Particle[0].Dim]; //通讯用数组，最优点坐标
double **opt_a = new double*[PNum]; //通讯用数组，所有点坐标
Initialize();
do
{
ParticleFly();
if(Com) //通讯函数存在，完成通讯
{
for(int k=0; k<Particle[0].Dim; k++) opt_p[k]=Particle[GBestIndex].XBest[k];//拷贝最优点坐标
for(k=0; k<PNum; k++) opt_a[k] = Particle[k].X; //指向所有点坐标
if(!Com(Particle[GBestIndex].FitBest,opt_p,opt_a,GBestIndex)) break;
}
}while(Particle[GBestIndex].FitBest<fit);
delete []opt_p;
delete []opt_a;
return Particle[GBestIndex];
}

//返回最佳个体
double PSO::GetBest(double *r)
{
for(int i=0; i<Particle[GBestIndex].Dim; i++)
r[i] = Particle[GBestIndex].XBest[i];
return Particle[GBestIndex].FitBest;
}





// pso.cpp : Defines the entry point for the console application.
//

//#include "stdafx.h"
#include "PSO.h"
#include <iostream.h>
#include <math.h>


//派生自己的PSO类
class MyPSO : public PSO
{
public:
MyPSO(int d, int n):PSO(d, n){}; //构造函数，给出微粒维数和微粒个数
double GetFit(PARTICLE &p) //适合度计算方法，必须定义
{
double t=10;            
        double X[]={5,15,25,35,45,55,65,75,85,95};             
            double *Y=new double[10];
            double xc[]={25,64,34,77,94,65,15,93}; 
            double yc[]={87,28,53,92,55,24,11,14}; 
            double p1[]={1.5 ,2,3,2,3,1.5,3,3}; 
            double q[]={1.5, 3.5, 2, 2, 3, 1.5 ,2, 3}; 
            double u[]={30,65,21,6,11,13,11,13}; 
            double v[]={20,12,13,25,14,9,13,11}; 
            double h[]={57,19,-32,38,24,-22,-14,-17}; 
            double *k=new double [10];

			int i,j,ii;
            Y[0]=92;Y[9]=9; 
            for(i=1;i<9;i++) 
            {
                Y[i]=p.X[i-1];
            }
              
                  
            double s=0; 
            double* xt=new double[11];
            double* yt=new double[11];
            double* z=new double[11];
            
            for(i=0;i<9;i++)
                k[i]=(Y[i+1]-Y[i])/(X[i+1]-X[i]);//由已经知道的XY求各段斜率
                      //下面求每小段的10等份后的各点的X，Y的值及对应的Z值
            s=0;
            for(i=0;i<9;i++)
            {
                for(j=0;j<11;j++)
                {
                    xt[j]=X[i]+j*0.1*t;
                    yt[j]=k[i]*(xt[j]-X[i])+Y[i];
                    z[j]=0;
                    for(ii=0;ii<8;ii++)
                        z[j]=z[j]+h[ii]*exp(-pow(fabs(xt[j]-xc[ii])/u[ii],p1[ii])-pow(fabs(yt[j]-yc[ii])/v[ii],q[ii]));

                }
                
                for(j=0;j<10;j++)
                    s=s+sqrt((0.1*t)*(0.1*t)+(k[i]*(0.1*t))*(k[i]*(0.1*t))+(z[j+1]-z[j])*(z[j+1]-z[j]));
            }
            delete []Y;
			delete []k;
			delete []xt;
			delete []yt;
			delete []z;
            return s; 
}
};

//定义通讯函数
bool MyCom(double fit, double *op, double**,int)
{
static long sn=1;

//if(sn%100==0)
//{
 cout<<"\nNo="<<sn<<"\tFun="<<fit;
  for(int i=0; i<8; i++)
  cout<<"\tX("<<i<<")="<<op[i];
//}
sn++;
return true;
}

//申明相关数据
const int PNum = 30; //微粒个数
const int PDim = 8; //微粒维数
double Xup[] = {92,92,92,92,92,92,92,92}; //自变量上界
double Xdown[] = {9,9,9,9,9,9,9,9}; //自变量下界

//主程序
void main()
{
MyPSO pso(PDim, PNum); //生成微粒群实例
pso.SetXup(Xup); //设置自变量上界
pso.SetXdown(Xdown); //设置自变量下界
pso.SetVmax(0.2); //设置最大速度
pso.SetCom(MyCom); //设置通讯函数
cout<<"\nRun Now:\n";
pso.Run(1000); //运行微粒群
cout<<"\nThe Result is:\t"<<pso.GetBest(Xup)<<"\n"; //输出结果
}

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -