切换到宽版
阿果石油APP正式发布 石油推广咨询 石油地质QQ群：181983917 物探地震反演群：165218480
阿果石油官方微信公众号：agoil2005      
发帖 回复
返回列表
  • 1537阅读
  • 8回复

具有扩展性能的粒子群算法c++类 [复制链接]

 上一主题 下一主题
离线jiajialei816
果园新丁
 
发帖
50
财富
893
威望
0
交易币
0
只看楼主 倒序阅读 使用道具 0楼 发表于: 2011-12-03 | 石油求职招聘就上: 阿果石油英才网
复制代码
  1. /***********************************************************************************
  2. Particle.h - 粒子抽象基类头文件
  3. ************************************************************************************
  4. 类说明：
  5. 该类是单个粒子的一个抽象，是一个抽象基类；
  6. 派生类必须对该类中的成员变量进行内存分配；
  7. 该类包含计算粒子适应度的纯虚函数；
  8. 该类不能直接对象化，必须在其子类对适应度函数进行实现后方能对粒子进行实例化
  9. ************************************************************************************
  10. 作者：贾家磊，jiajialei816@163.com，中国地质大学（北京）地震勘探实验室，2011/11/30
  11. ************************************************************************************/
  12. #ifndef _PARTICLE_H_JIAJIALEI
  13. #define _PARTICLE_H_JIAJIALEI
  15. #include <stdlib.h>
  17. class CParticle
  18. {
  19. public:
  20. ////////////////////
  21. //构造与析构部分
  22. ////////////////////
  24. //粒子类缺省构造函数
  25. CParticle();
  26. //粒子类带参数构造函数
  27. CParticle(int dimension);
  28. //粒子类析构函数
  29. virtual ~CParticle();
  31. //////////////////
  32. //参数设置部分
  33. //////////////////
  35. //设置粒子的位置
  36. virtual void SetPosition(float *position);
  37. //设置粒子的速度
  38. virtual void SetVelocity(float *velocity);
  39. //设置粒子个体的最优解位置
  40. virtual void SetBestPosition(float *bestPosition);
  41. //设置粒子的适应度
  42. virtual void SetFitness(float fitness) { fFitness = fitness; };
  43. //设置粒子个体的最好适应度
  44. virtual void SetBestFitness(float bestFitness) { fBestFitness = bestFitness; };
  45. //设置粒子个体的维度
  46. virtual void SetDimension(int dimension) { nDimension = dimension; };
  48. //////////////////
  49. //参数输出部分
  50. //////////////////
  52. //返回粒子的位置
  53. virtual float* GetPosition() { return pfPosition; };
  54. //返回粒子的速度
  55. virtual float* GetVelocity() { return pfVelocity; };
  56. //返回粒子个体的最优解位置
  57. virtual float* GetBestPosition() { return pfBestPosition; }
  58. //返回粒子的适应度
  59. virtual float GetFitness() { return fFitness; }
  60. //返回粒子个体的最好适应度
  61. virtual float GetBestFitness() { return fBestFitness; };
  62. //返回粒子个体的维度
  63. virtual int GetDimension() { return nDimension; };
  65. //////////////
  66. //计算部分
  67. //////////////
  69. //更新粒子的最好适应度及其位置信息
  70. virtual void UpdateBestPosition();
  71. //计算粒子的适应度值，纯虚函数，必须在其子类定义
  72. virtual void CalculateFitness() = 0;
  74. protected:
  75. //粒子的位置(坐标)
  76. float *pfPosition;
  77. //粒子的速度
  78. float *pfVelocity;
  79. //粒子个体的最优解位置(坐标)
  80. float *pfBestPosition;
  81. //粒子的适应度(误差，其值越小适应度越好)
  82. float fFitness;
  83. //粒子个体的最好适应度(误差，其值越小适应度越好)
  84. float fBestFitness;
  85. //粒子的维度
  86. int nDimension;
  87. };
  89. #endif//_PARTICLE_H_JIAJIALEI
复制代码
  1. /***********************************************************************************
  2. Particle.cpp - 粒子抽象基类的实现文件
  3. ************************************************************************************
  4. 类说明：
  5. 该类是单个粒子的一个抽象，是一个抽象基类；
  6. 该类包含计算粒子适应度的纯虚函数；
  7. 该类不能直接对象化，必须在其子类对适应度函数进行实现后方能对粒子进行实例化
  8. ************************************************************************************
  9. 作者：贾家磊，jiajialei816@163.com，中国地质大学（北京）地震勘探实验室，2011/11/30
  10. ************************************************************************************/
  11. #include "Particle.h"
  13. /*粒子类缺省构造函数*/
  14. CParticle::CParticle()
  15. {
  16. pfPosition = NULL;
  17. pfVelocity = NULL;
  18. pfBestPosition = NULL;
  19. fFitness = 0;
  20. fBestFitness = 0;
  21. nDimension = 0;
  22. }
  24. /*粒子类带参数构造函数*/
  25. CParticle::CParticle(int dimension)
  26. {
  27. pfPosition = NULL;
  28. pfVelocity = NULL;
  29. pfBestPosition = NULL;
  30. fFitness = 0;
  31. fBestFitness = 0;
  32. nDimension = dimension;
  33. }
  35. /*粒子类析构函数*/
  36. CParticle::~CParticle()
  37. {
  38. }
  40. /*更新粒子的最好适应度及其位置信息*/
  41. void CParticle::UpdateBestPosition()
  42. {
  43. //如果粒子当前计算的适应度小于粒子个体的最好适应度时
  44. if(fFitness<fBestFitness)
  45. {
  46. fBestFitness = fFitness;
  47. for(int i=0; i<nDimension; i++)
  48. pfBestPosition[i] = pfPosition[i];
  49. }
  50. }
  52. /*设置粒子的位置*/
  53. void CParticle::SetPosition(float *position)
  54. {
  55. for(int i=0; i<nDimension; i++)
  56. pfPosition[i] = position[i];
  57. }
  59. /*设置粒子个体的最优解位置*/
  60. void CParticle::SetBestPosition(float *bestPosition)
  61. {
  62. for(int i=0; i<nDimension; i++)
  63. pfBestPosition[i] = bestPosition[i];
  64. }
  66. /*设置粒子的速度*/
  67. void CParticle::SetVelocity(float *velocity)
  68. {
  69. for(int i=0; i<nDimension; i++)
  70. pfVelocity[i] = velocity[i];
  71. }
复制代码
  1. /***********************************************************************************
  2. ParticleSwarm.h - 粒子群基类头文件
  3. ************************************************************************************
  4. 类说明：
  5. 该类是由多个抽象粒子组成的粒子群基类；
  6. 粒子群派生类必须对粒子群基类中的成员变量进行内存分配
  7. 该类主要包括粒子群随机初始化函数Randomize和粒子群进化一代函数ParticleFly
  8. ************************************************************************************
  9. 作者：贾家磊，jiajialei816@163.com，中国地质大学（北京）地震勘探实验室，2011/11/30
  10. ************************************************************************************/
  11. #ifndef _PARTICLE_SWARM_H_JIAJIALEI
  12. #define _PARTICLE_SWARM_H_JIAJIALEI
  14. #include "Particle.h"
  16. class CParticleSwarm
  17. {
  18. public:
  19. ////////////////////
  20. //构造与析构部分
  21. ////////////////////
  23. //粒子群类缺省构造函数
  24. CParticleSwarm();
  25. //粒子群类带参数构造函数
  26. CParticleSwarm(int dimension, int particleNum);
  27. //粒子类析构函数
  28. virtual ~CParticleSwarm();
  30. //////////////////
  31. //参数设置部分
  32. //////////////////
  34. //设置粒子位置信息的下界
  35. virtual void SetMinPosition(float *minPosition);
  36. //设置粒子位置信息的上界
  37. virtual void SetMaxPosition(float *maxPosition);
  38. //设置粒子的最大速度
  39. virtual void SetMaxVelocity(float percent);
  40. virtual void SetMaxVelocity(float *minVelocity);
  41. //设置粒子的非负惯性权系数
  42. virtual void SetMomentum(float momentum) { fMomentum = momentum; };
  43. //设置线性惯性权系数的范围(线性惯性权系数时使用)
  44. virtual void SetMomentumRange(float minMomentum, float maxMomentum);
  45. //设置量化粒子认知能力的学习因子fC1
  46. virtual void SetC1(float c1) { fC1 = c1; };
  47. //设置量化粒子社会能力的学习因子fC2
  48. virtual void SetC2(float c2) { fC2 = c2; };
  50. //////////////////
  51. //参数输出部分
  52. //////////////////
  54. //返回粒子位置信息的下界
  55. virtual float* GetMinPosition() { return pfMinPosition; };
  56. //返回粒子位置信息的上界
  57. virtual float* GetMaxPosition() { return pfMaxPosition; };
  58. //返回粒子的最大速度
  59. virtual float* GetMaxVelocity() { return pfMaxVelocity; };
  60. //返回粒子的惯性权系数
  61. virtual float GetMomentum() { return fMomentum; };
  62. //返回量化粒子认知能力的学习因子fC1
  63. virtual float GetC1() { return fC1; };
  64. //返回量化粒子社会能力的学习因子fC2
  65. virtual float GetC2() { return fC2; };
  66. //返回粒子群中全局最优粒子的索引号
  67. virtual int GetGroupBestIndex() { return nGroupBestIndex; };
  68. //返回全局最优粒子的位置
  69. virtual void GetGroupBestPosition(float* bestPosition);
  70. //返回全局最优粒子的适应度
  71. virtual float GetGroupBestFitness();
  72. //返回粒子群中各个粒子最优适应度的中位索引号
  73. virtual int GetGroupMedianIndex();
  74. //计算粒子群中各个粒子最优适应度的中位数，然后返回对应粒子的最优位置
  75. virtual void GetGroupMedianPosition(float* midPosition);
  76. //返回粒子群中各个粒子最优位置的平均
  77. virtual void GetGroupAveragePosition(float* avgPosition);
  78. //返回粒子群中各个粒子适应度的平均值
  79. virtual float GetGroupAverageFitness();
  80. //返回粒子群中的粒子数
  81. virtual int GetParticleNum() { return nParticleNum; };
  82. //返回全局最优的粒子
  83. virtual CParticle& GetGroupBestParticle() { return cParticle[nGroupBestIndex]; };
  84. //返回指定的粒子
  85. virtual CParticle& GetParticleFromIndex(int index) { return cParticle[index]; };
  86. //返回粒子群指针
  87. virtual CParticle* GetParticleSwarm() { return cParticle; };
  89. //////////////
  90. //计算部分
  91. //////////////
  93. //粒子群迭代进化(对于不同的实现算法可重载该函数实现)
  94. virtual void RunEpoch(int iteration);//迭代次数控制
  95. virtual void RunEpoch(float fitError);//适应度控制
  96. //随机初始化粒子群(位置和速度信息)
  97. virtual void Randomize();
  98. //生成新一代的粒子群
  99. virtual void ParticleFly();
  100. protected:
  101. //随机初始化粒子的位置信息(对于不同的更新算法可重载该函数实现)
  102. virtual void InitialPosition(int particleIndex, int dimension);
  103. //更新粒子的位置信息(对于不同的更新算法可重载该函数实现)
  104. virtual void UpdatePosition(int particleIndex, int dimension);
  105. //更新粒子群中全局最优粒子的索引号
  106. virtual void UpdateGroupBestIndex();
  107. //检查粒子的速度信息是否越界
  108. virtual void CheckVelocity(float *velocity);
  109. //检查粒子的位置信息是否越界
  110. virtual void CheckPosition(float *position);
  112. protected:
  113. //指向单个粒子的指针
  114. CParticle *cParticle;
  115. //粒子群中的粒子数
  116. int nParticleNum;
  117. //全局最优粒子的索引号(0,1,2,3...)
  118. int nGroupBestIndex;
  119. //粒子的位置信息下界
  120. float *pfMinPosition;
  121. //粒子的位置信息上界
  122. float *pfMaxPosition;
  123. //粒子的最大速度
  124. float *pfMaxVelocity;
  125. //粒子的非负惯性权系数：系数越大，全局寻优能力强；反之，局部寻优能力强
  126. float fMomentum;
  127. //最小非负惯性权系数(线性惯性权系数时使用)
  128. float fMinMomentum;
  129. //最大非负惯性全系数(线性惯性权系数时使用)
  130. float fMaxMomentum;
  131. //量化粒子认知能力的学习因子fC1
  132. float fC1;
  133. //量化粒子社会能力的学习因子fC2
  134. float fC2;
  135. };
  137. #endif//_PARTICLE_SWARM_H_JIAJIALEI
复制代码
  1. /***********************************************************************************
  2. ParticleSwarm.cpp - 粒子群基类的实现文件
  3. ************************************************************************************
  4. 类说明：
  5. 该类是由多个抽象粒子组成的粒子群基类；
  6. 粒子群派生类必须对粒子群基类中的成员变量进行内存分配
  7. 该类主要包括粒子群随机初始化函数Randomize和粒子群进化一代函数ParticleFly
  8. ************************************************************************************
  9. 作者：贾家磊，jiajialei816@163.com，中国地质大学（北京）地震勘探实验室，2011/11/30
  10. ************************************************************************************/
  11. #include "ParticleSwarm.h"
  12. #include <time.h>
  14. /*粒子群类缺省构造函数*/
  15. CParticleSwarm::CParticleSwarm()
  16. {
  17. cParticle = NULL;
  18. pfMinPosition = NULL;
  19. pfMaxPosition = NULL;
  20. pfMaxVelocity = NULL;
  21. nParticleNum = 0;
  22. nGroupBestIndex = 0;
  23. fMomentum = 0.8f;
  24. fMinMomentum = 0.4f;
  25. fMaxMomentum = 0.9f;
  26. fC1 = 2.0f;
  27. fC2 = 2.0f;
  29. }
  31. /*粒子群类带参数构造函数*/
  32. CParticleSwarm::CParticleSwarm(int dimension, int particleNum)
  33. {
  34. pfMinPosition = NULL;
  35. pfMaxPosition = NULL;
  36. pfMaxVelocity = NULL;
  37. nParticleNum = particleNum;
  38. nGroupBestIndex = 0;
  39. fMomentum = 0.8f;
  40. fMinMomentum = 0.4f;
  41. fMaxMomentum = 0.9f;
  42. fC1 = 2.0f;
  43. fC2 = 2.0f;
  44. }
  46. /*粒子群类析构函数*/
  47. CParticleSwarm::~CParticleSwarm()
  48. {
  49. }
  51. /*设置粒子位置信息的下界*/
  52. void CParticleSwarm::SetMinPosition(float *minPosition)
  53. {
  54. int dimension = cParticle[0].GetDimension();
  55. for(int i=0; i<dimension; i++)
  56. pfMinPosition[i] = minPosition[i];
  57. }
  59. /*设置粒子位置信息的上界*/
  60. void CParticleSwarm::SetMaxPosition(float *maxPosition)
  61. {
  62. int dimension = cParticle[0].GetDimension();
  63. for(int i=0; i<dimension; i++)
  64. pfMaxPosition[i] = maxPosition[i];
  65. }
  67. /*设置粒子的最大速度*/
  68. void CParticleSwarm::SetMaxVelocity(float percent)
  69. {
  70. if(!nParticleNum) return;
  71. int dimension = cParticle[0].GetDimension();
  72. for(int i=0; i<dimension; i++)
  73. pfMaxVelocity[i] = percent*(pfMaxPosition[i]-pfMinPosition[i]);
  74. }
  75. void CParticleSwarm::SetMaxVelocity(float *maxVelocity)
  76. {
  77. int dimension = cParticle[0].GetDimension();
  78. for(int i=0; i<dimension; i++)
  79. pfMaxVelocity[i] = maxVelocity[i];
  80. }
  82. /*设置线性惯性权系数的范围*/
  83. void CParticleSwarm::SetMomentumRange(float minMomentum, float maxMomentum)
  84. {
  85. fMinMomentum = minMomentum;
  86. fMaxMomentum = maxMomentum;
  87. }
  89. /*跟新粒子群中全局最优粒子的索引号*/
  90. void CParticleSwarm::UpdateGroupBestIndex()
  91. {
  92. for(int i=0; i<nParticleNum; i++)
  93. {
  94. if(i!=nGroupBestIndex &&
  95. cParticle[i].GetBestFitness()<cParticle[nGroupBestIndex].GetBestFitness())
  96. nGroupBestIndex = i;
  97. }
  98. }
  100. /*返回粒子群中各个粒子最优位置的平均*/
  101. void CParticleSwarm::GetGroupAveragePosition(float* avgPosition)
  102. {
  103. int i,j;
  104. int dimension = cParticle[0].GetDimension();
  105. float *bestPos;
  107. for(i=0; i<dimension; i++)
  108. avgPosition[i] = 0.0;
  110. for(j=0; j<nParticleNum; j++)
  111. {
  112. bestPos = cParticle[j].GetBestPosition();
  113. for(i=0; i<dimension; i++)
  114. avgPosition[i] += bestPos[i];
  115. }
  116. for(i=0; i<dimension; i++)
  117. avgPosition[i] /= nParticleNum;
  118. }
  120. /*返回粒子群中各个粒子适应度的平均值*/
  121. float CParticleSwarm::GetGroupAverageFitness()
  122. {
  123. float avg = 0.0;
  124. for(int i=0; i<nParticleNum; i++)
  125. avg += cParticle[i].GetBestFitness();
  126. return (avg/nParticleNum);
  127. }
  129. /*返回粒子群中各个粒子最优适应度的中位索引号*/
  130. int CParticleSwarm::GetGroupMedianIndex()
  131. {
  132. int i,j,k,index;
  133. float temp;
  134. float *pfData = new float[nParticleNum];
  135. int* pIndex = new int[nParticleNum];
  136. for(i=0; i<nParticleNum; i++)
  137. {
  138. pfData[i] = cParticle[i].GetBestFitness();
  139. pIndex[i] = i;
  140. }
  141. for(i=0; i<=nParticleNum/2; i++)
  142. {
  143. k = nParticleNum-i;
  144. temp = pfData[0];
  145. index = 0;
  146. //寻找序列中最大值以及其索引号
  147. for(j=1; j<k; j++)
  148. {
  149. if(pfData[j]>temp)
  150. {
  151. temp = pfData[j];
  152. index = j;
  153. }
  154. }
  155. //将序列尾部的值写入到当前序列中最大值处
  156. pfData[index] = pfData[k-1];//将序列中的最大值逐个覆盖
  157. pIndex[index] = k-1;
  158. }
  159. //粒子群中各个粒子最优适应度的中位数
  160. index = pIndex[nParticleNum/2];
  162. delete []pfData;
  163. delete []pIndex;
  165. return index;
  166. }
  168. /*计算粒子群中各个粒子最优适应度的中位数，然后返回对应粒子的最优位置*/
  169. void CParticleSwarm::GetGroupMedianPosition(float* midPosition)
  170. {
  171. int i,j,k,index;
  172. float temp, *pos;
  173. float *pfData = new float[nParticleNum];
  174. int* pIndex = new int[nParticleNum];
  175. for(i=0; i<nParticleNum; i++)
  176. {
  177. pfData[i] = cParticle[i].GetBestFitness();
  178. pIndex[i] = i;
  179. }
  180. for(i=0; i<=nParticleNum/2; i++)
  181. {
  182. k = nParticleNum-i;
  183. temp = pfData[0];
  184. index = 0;
  185. //寻找序列中最大值以及其索引号
  186. for(j=1; j<k; j++)
  187. {
  188. if(pfData[j]>temp)
  189. {
  190. temp = pfData[j];
  191. index = j;
  192. }
  193. }
  194. //将序列尾部的值写入到当前序列中最大值处
  195. pfData[index] = pfData[k-1];//将序列中的最大值逐个覆盖
  196. pIndex[index] = k-1;
  197. }
  198. //粒子群中各个粒子最优适应度的中位数
  199. index = pIndex[nParticleNum/2];
  200. //中位数对应粒子的最优位置
  201. pos = cParticle[index].GetBestPosition();
  202. int dimension = cParticle[index].GetDimension();
  204. for(i=0; i<dimension; i++)
  205. midPosition[i] = pos[i];
  207. delete []pfData;
  208. delete []pIndex;
  209. }
  211. /*返回全局最优粒子的适应度*/
  212. float CParticleSwarm::GetGroupBestFitness()
  213. {
  214. return cParticle[nGroupBestIndex].GetBestFitness();
  215. }
  217. /*返回全局最优粒子的位置*/
  218. void CParticleSwarm::GetGroupBestPosition(float* bestPosition)
  219. {
  220. int dimension = cParticle[nGroupBestIndex].GetDimension();
  221. float *gBestPos;
  222. gBestPos = cParticle[nGroupBestIndex].GetBestPosition();
  223. for(int i=0; i<dimension; i++)
  224. bestPosition[i] = gBestPos[i];
  225. }
  227. /*检查粒子的速度信息是否越界*/
  228. void CParticleSwarm::CheckVelocity(float *velocity)
  229. {
  230. int dimension = cParticle[0].GetDimension();
  231. for(int i=0; i<dimension; i++)
  232. {
  233. //速度越界检查
  234. if(velocity[i]>pfMaxVelocity[i])//速度超过上界
  235. velocity[i] = pfMaxVelocity[i];
  236. if(velocity[i]<-pfMaxVelocity[i])//速度越过下界
  237. velocity[i] = -pfMaxVelocity[i];
  238. }
  239. }
  241. /*检查粒子的位置信息是否越界*/
  242. void CParticleSwarm::CheckPosition(float *position)
  243. {
  244. int dimension = cParticle[0].GetDimension();
  245. for(int i=0; i<dimension; i++)
  246. {
  247. //位置越界检查
  248. if(position[i]>pfMaxPosition[i])//位置超过上界
  249. position[i] = 2*pfMaxPosition[i]-position[i];
  250. if(position[i]<pfMinPosition[i])//位置越过下界
  251. position[i] = 2*pfMinPosition[i]-position[i];
  252. }
  253. }
  255. /*随机初始化粒子群*/
  256. void CParticleSwarm::Randomize()
  257. {
  258. if(!nParticleNum) return;
  259. static int kk=(unsigned)time(NULL);
  260. srand((unsigned)time(NULL)+kk++);
  262. int dimension = cParticle[0].GetDimension();
  264. nGroupBestIndex = 0;
  265. for(int i=0; i<nParticleNum; i++)
  266. {
  267. //初始化粒子的位置信息
  268. InitialPosition(i, dimension);
  269. //计算粒子群的适应度
  270. cParticle[i].CalculateFitness();
  271. //将粒子当前的适应度设置成粒子的最好适应度
  272. cParticle[i].SetBestFitness(cParticle[i].GetFitness());
  273. //查找初始粒子群中的最优粒子
  274. if(cParticle[i].GetFitness()<cParticle[nGroupBestIndex].GetFitness())
  275. nGroupBestIndex = i;
  276. }
  277. }
  279. /*生成新一代的粒子群*/
  280. void CParticleSwarm::ParticleFly()
  281. {
  282. if(!nParticleNum) return;
  283. static int tt=(unsigned)time(NULL);
  284. srand((unsigned)time(NULL)+tt++);
  286. int dimension = cParticle[0].GetDimension();
  288. for(int i=0; i<nParticleNum; i++)
  289. {
  290. //更新第i个粒子的位置信息
  291. UpdatePosition(i, dimension);
  292. //计算新一代粒子群的适应度值
  293. cParticle[i].CalculateFitness();
  294. //更新粒子的最优位置信息
  295. cParticle[i].UpdateBestPosition();
  296. }
  297. //跟新粒子群中全局最优粒子的索引号
  298. UpdateGroupBestIndex();
  299. }
  301. /*粒子群迭代进化(对于不同的实现算法可重载该函数实现)*/
  302. void CParticleSwarm::RunEpoch(int iteration)
  303. {
  304. //初始化粒子群
  305. Randomize();
  306. //粒子种群进化
  307. for(int i=0; i<iteration; i++)
  308. ParticleFly();
  309. }
  310. void CParticleSwarm::RunEpoch(float fitError)
  311. {
  312. //初始化粒子群
  313. Randomize();
  314. //粒子种群进化
  315. for(int i=0; ; i++)
  316. {
  317. ParticleFly();
  318. if(cParticle[nGroupBestIndex].GetBestFitness()<fitError)
  319. break;
  320. }
  321. }
  323. /*随机初始化粒子的位置信息(对于不同的更新算法可重载该函数实现)*/
  324. void CParticleSwarm::InitialPosition(int particleIndex, int dimension)
  325. {
  326. float *pos = new float[dimension];
  327. float *vel = new float[dimension];
  329. for(int i=0; i<dimension; i++)
  330. {
  331. //随机初始化粒子群的位置信息
  332. pos[i] = (float)rand()/(float)RAND_MAX
  333. *(pfMaxPosition[i]-pfMinPosition[i])+pfMinPosition[i];
  334. //随机初始化粒子群的速度信息
  335. vel[i] = (float)rand()/(float)RAND_MAX
  336. *pfMaxVelocity[i]-pfMaxVelocity[i]/2;
  337. }
  338. //设置初始粒子群的位置信息
  339. cParticle[particleIndex].SetPosition(pos);
  340. //设置初始粒子群的最优位置信息
  341. cParticle[particleIndex].SetBestPosition(pos);
  342. //设置初始粒子群的速度信息
  343. cParticle[particleIndex].SetVelocity(vel);
  345. delete []pos;
  346. delete []vel;
  347. }
  349. /*更新粒子的位置信息(对于不同的更新算法只需重载该函数实现即可)*/
  350. void CParticleSwarm::UpdatePosition(int particleIndex, int dimension)
  351. {
  352. float *pos, *bestPos, *gbestPos, *vel;
  353. //获取当前粒子的位置信息
  354. pos = cParticle[particleIndex].GetPosition();
  355. //获取局部最优粒子
  356. bestPos = cParticle[particleIndex].GetBestPosition();
  357. //全局最优粒子
  358. gbestPos = cParticle[nGroupBestIndex].GetBestPosition();
  359. //当前粒子的速度信息
  360. vel = cParticle[particleIndex].GetVelocity();
  361. for(int i=0; i<dimension; i++)
  362. {
  363. //更新粒子速度信息
  364. vel[i] = fMomentum*vel[i]/*惯性项*/
  365. +(float)rand()/(float)RAND_MAX*fC1*(bestPos[i]-pos[i])/*认知项*/
  366. +(float)rand()/(float)RAND_MAX*fC2*(gbestPos[i]-pos[i])/*社会项*/;
  367. }
  368. //检查粒子的速度信息是否越界
  369. CheckVelocity(vel);
  371. //位置信息更新
  372. for(i=0; i<dimension; i++)
  373. pos[i] += vel[i];//position += velocity;
  374. //检查粒子的位置信息是否越界
  375. CheckPosition(pos);
  376. }
复制代码
  1. /***********************************************************************************
  2. MyParticle.h - 自定义粒子类头文件
  3. ************************************************************************************
  4. 类说明：
  5. 该类派生于粒子抽象基类，提供了一个自定义粒子类派生模式；
  6. 该类对粒子抽象基类中的成员变量进行内存分配；
  7. 该类实现了基类中计算粒子适应度的纯虚函数（针对不同实际问题只需修改该适应度函数）；
  8. ************************************************************************************
  9. 作者：贾家磊，jiajialei816@163.com，中国地质大学（北京）地震勘探实验室，2011/11/30
  10. ************************************************************************************/
  11. #ifndef _MY_PARTICLE_H_JIAJIALEI
  12. #define _MY_PARTICLE_H_JIAJIALEI
  14. #include "Particle.h"
  16. class CMyParticle:public CParticle
  17. {
  18. public:
  19. ////////////////////
  20. //构造与析构部分
  21. ////////////////////
  23. //自定义粒子类缺省构造函数
  24. CMyParticle():CParticle() {};
  25. //自定义粒子类带参数构造函数
  26. CMyParticle(int dimension);
  27. //自定义粒子类析构函数
  28. virtual ~CMyParticle();
  30. ////////////////////
  31. //内存分配部分
  32. ////////////////////
  34. //设置自定义粒子维度并进行基类成员变量内存分配
  35. virtual void SetDimension(int dimension);
  37. ////////////////////
  38. //方法实现部分
  39. ////////////////////
  41. //计算自定义粒子的适应度（针对不同实际问题只需修改该函数）
  42. virtual void CalculateFitness();
  43. };
  44. #endif//_MY_PARTICLE_H_JIAJIALEI
复制代码
  1. /***********************************************************************************
  2. MyParticle.cpp - 自定义粒子类的实现文件
  3. ************************************************************************************
  4. 类说明：
  5. 该类派生于粒子抽象基类，提供了一个自定义粒子类派生模式；
  6. 该类对粒子抽象基类中的成员变量进行内存分配；
  7. 该类实现了基类中计算粒子适应度的纯虚函数（针对不同实际问题只需修改该适应度函数）；
  8. ************************************************************************************
  9. 作者：贾家磊，jiajialei816@163.com，中国地质大学（北京）地震勘探实验室，2011/11/30
  10. ************************************************************************************/
  11. #include "MyParticle.h"
  13. /*自定义粒子类带参数构造函数(分配内存空间)*/
  14. CMyParticle::CMyParticle(int dimension):CParticle(dimension)
  15. {
  16. pfPosition = new float[nDimension];
  17. pfVelocity = new float[nDimension];
  18. pfBestPosition = new float[nDimension];
  19. }
  21. /*析构自定义粒子*/
  22. CMyParticle::~CMyParticle()
  23. {
  24. if(nDimension)
  25. {
  26. delete []pfPosition;
  27. delete []pfVelocity;
  28. delete []pfBestPosition;
  29. }
  30. }
  32. /*设置自定义粒子维度并进行基类成员变量内存分配*/
  33. void CMyParticle::SetDimension(int dimension)
  34. {
  35. if(nDimension)
  36. {
  37. delete []pfPosition;
  38. delete []pfVelocity;
  39. delete []pfBestPosition;
  40. }
  41. nDimension = dimension;
  42. pfPosition = new float[nDimension];
  43. pfVelocity = new float[nDimension];
  44. pfBestPosition = new float[nDimension];
  45. }
  47. /*计算自定义粒子的适应度（针对不同实际问题只需修改该函数）*/
  48. #include "math.h"
  49. void CMyParticle::CalculateFitness()
  50. {
  51. //针对实际问题需完成的...
  52. // Particle::fFitness = 1.1f;
  53. }
复制代码
  1. /***********************************************************************************
  2. PSO.h - 标准粒子群算法类头文件
  3. ************************************************************************************
  4. 类说明：
  5. 该类派生于粒子群基类，提供了一个自定义粒子群类派生模式；
  6. 该类对粒子群基类中的成员变量进行内存分配；
  7. 该类实现了基类的标准粒子群算法
  8. ************************************************************************************
  9. 作者：贾家磊，jiajialei816@163.com，中国地质大学（北京）地震勘探实验室，2011/11/30
  10. ************************************************************************************/
  11. #ifndef _PSO_H_JIAJIALEI
  12. #define _PSO_H_JIAJIALEI
  14. #include "MyParticle.h"
  15. #include "ParticleSwarm.h"
  17. class CPSO : public CParticleSwarm
  18. {
  19. public:
  20. ////////////////////
  21. //构造与析构部分
  22. ////////////////////
  24. //标准粒子群类缺省构造函数
  25. CPSO():CParticleSwarm() {};
  26. //标准粒子群类带参数构造函数
  27. CPSO(int dimension, int particleNum);
  28. //标准粒子群类析构函数
  29. virtual ~CPSO();
  30. };
  32. #endif//_ADAPTIVE_EXTENDED_PSO_H_JIAJIALEI
复制代码
  1. /***********************************************************************************
  2. PSO.cpp - 标准粒子群算法类的实现文件
  3. ************************************************************************************
  4. 类说明：
  5. 该类派生于粒子群基类，提供了一个自定义粒子群类派生模式；
  6. 该类对粒子群基类中的成员变量进行内存分配；
  7. 该类实现了基类的标准粒子群算法
  8. ************************************************************************************
  9. 作者：贾家磊，jiajialei816@163.com，中国地质大学（北京）地震勘探实验室，2011/11/30
  10. ************************************************************************************/
  12. #include "PSO.h"
  14. /*设置标准粒子群并进行基类成员变量内存分配*/
  15. CPSO::CPSO(int dimension, int particleNum)
  16. :CParticleSwarm(dimension, particleNum)
  17. {
  18. cParticle = new CMyParticle[particleNum];
  19. for(int i=0; i<particleNum; i++)
  20. cParticle[i].SetDimension(dimension);//单个粒子分配内存
  22. pfMinPosition = new float[dimension];
  23. pfMaxPosition = new float[dimension];
  24. pfMaxVelocity = new float[dimension];
  25. }
  27. /*标准粒子群类析构函数*/
  28. CPSO::~CPSO()
  29. {
  30. if(nParticleNum)
  31. delete []cParticle;
  32. if(pfMinPosition != NULL)
  33. delete []pfMinPosition;
  34. if(pfMaxPosition != NULL)
  35. delete []pfMaxPosition;
  36. if(pfMaxVelocity != NULL)
  37. delete []pfMaxVelocity;
  38. }
共1条评分 ，财富+30
allex02 财富 +30 优秀文章，支持！ 2011-12-06
评价一下你浏览此帖子的感受

精彩
感动
搞笑
开心
愤怒
无聊
灌水
回复
举报
分享到 淘江湖 新浪 QQ微博 QQ空间 开心 人人 豆瓣 网易微博 百度 鲜果 白社会 飞信
离线pawaluodi
临时会员
发帖
1
财富
0
威望
0
交易币
0
只看该作者 1楼 发表于: 2011-12-03 | 石油求职招聘就上: 阿果石油英才网
不错，顶一下，建议把计算后的效果对比分享一下
回复
举报
离线rongloer
果园新丁
发帖
30
财富
22
威望
0
交易币
0
只看该作者 2楼 发表于: 2011-12-03 | 石油求职招聘就上: 阿果石油英才网
支持一下
回复
举报
离线wh200500337
果园新丁
发帖
88
财富
240
威望
3
交易币
0
只看该作者 3楼 发表于: 2011-12-03 | 石油求职招聘就上: 阿果石油英才网
有我在的贴子或许会成为水贴，但没我在的帖子注定成不了神贴！
回复
举报
离线jiajialei816
果园新丁
发帖
50
财富
893
威望
0
交易币
0
只看该作者 4楼 发表于: 2011-12-03 | 石油求职招聘就上: 阿果石油英才网
这些类提供了一个开发粒子群优化算法的一个平台，只要派生自定义粒子群算法类，然后重载里面的几个函数就能实现自己想要的算法，后面将陆续给出实例

内容来自[短消息]
回复
举报
离线lvyang06
果园新丁
发帖
45
财富
142
威望
0
交易币
0
只看该作者 5楼 发表于: 2011-12-04 | 石油求职招聘就上: 阿果石油英才网
神贴。。
回复
举报
离线sdzxxyhpl
果园常客
发帖
242
财富
912
威望
0
交易币
0
只看该作者 6楼 发表于: 2011-12-05 | 石油求职招聘就上: 阿果石油英才网
真心不懂在说啥。。。
加油加油!!!
回复
举报
离线jiajialei816
果园新丁
发帖
50
财富
893
威望
0
交易币
0
只看该作者 7楼 发表于: 2011-12-08 | 石油求职招聘就上: 阿果石油英才网
利用上述粒子群算法c++类实现的地震波阻抗反演测试，效果图：
回复
举报
离线wh200500337
果园新丁
发帖
88
财富
240
威望
3
交易币
0
只看该作者 8楼 发表于: 2011-12-09 | 石油求职招聘就上: 阿果石油英才网
看懂没大家，反正我是看懂了，预测效果与实际效果一致性高，匹配好
回复
举报
发帖 回复
返回列表

网站事务咨询:QQ：1392013 | 26189883
阿果石油网为免费个人网站，为石油人提供免费的在线即时技术交流场所，拒绝任何人以任何形式在本论坛发表与中华人民共和国法律相抵触的言论和行为!
如有言论或会员共享的资料涉及到您的权益，请立即通知网站管理员，本站将在第一时间给予配合处理，谢谢！