粒子群算法C++实现

粒子群算法（Particle Swarm Optimization，PSO）是一种基于群体智能的优化算法，用于解决优化问题。下面是粒子群算法的C++实现的基本步骤：

1. 初始化粒子群：定义粒子的位置和速度，并为每个粒子随机分配初始位置和速度。
2. 计算适应度值：根据问题的适应度函数，计算每个粒子的适应度值。
3. 更新个体最优解：对于每个粒子，根据当前位置和历史最优位置，更新个体最优解。
4. 更新全局最优解：从所有粒子的个体最优解中选择全局最优解。
5. 更新速度和位置：根据粒子群算法的公式，更新每个粒子的速度和位置。
6. 判断终止条件：根据预设的终止条件，判断是否终止算法。如果满足条件，则结束算法；否则，返回步骤3。

以下是一个简单的粒子群算法的C++实现示例：

cpp
#include <iostream>
#include <vector>
#include <cmath>
#include <cstdlib>
#include <ctime>

// 定义粒子结构体
struct Particle {
std::vector<double> position; // 粒子位置
std::vector<double> velocity; // 粒子速度
double fitness; // 适应度值
std::vector<double> bestPosition; // 个体最优位置
double bestFitness; // 个体最优适应度值
};

// 定义粒子群算法类
class PSO {
public:
PSO(int numParticles, int numDimensions, double inertiaWeight, double cognitiveWeight, double socialWeight, double minRange, double maxRange)
: numParticles(numParticles), numDimensions(numDimensions), inertiaWeight(inertiaWeight),
cognitiveWeight(cognitiveWeight), socialWeight(socialWeight), minRange(minRange), maxRange(maxRange) {
// 初始化粒子群
particles.resize(numParticles);
for (int i = 0; i < numParticles; ++i) {
particles[i].position.resize(numDimensions);
particles[i].velocity.resize(numDimensions);
particles[i].bestPosition.resize(numDimensions);
for (int j = 0; j < numDimensions; ++j) {
particles[i].position[j] = getRandomNumber(minRange, maxRange);
particles[i].velocity[j] = getRandomNumber(minRange, maxRange);
}
particles[i].fitness = calculateFitness(particles[i].position);
particles[i].bestPosition = particles[i].position;
particles[i].bestFitness = particles[i].fitness;
}
// 初始化全局最优解
globalBestPosition.resize(numDimensions);
globalBestFitness = std::numeric_limits<double>::max();
}

// 粒子群算法迭代更新
void update() {
for (int i = 0; i < numParticles; ++i) {
for (int j = 0; j < numDimensions; ++j) {
// 更新速度
double r1 = getRandomNumber(0, 1);
double r2 = getRandomNumber(0, 1);
particles[i].velocity[j] = inertiaWeight * particles[i].velocity[j]
+ cognitiveWeight * r1 * (particles[i].bestPosition[j] - particles[i].position[j])
+ socialWeight * r2 * (globalBestPosition[j] - particles[i].position[j]);
// 更新位置
particles[i].position[j] = particles[i].position[j] + particles[i].velocity[j];
// 限制位置在范围内
if (particles[i].position[j] < minRange) {
particles[i].position[j] = minRange;
}
if (particles[i].position[j] > maxRange) {
particles[i].position[j] = maxRange;
}
}
// 更新适应度值
particles[i].fitness = calculateFitness(particles[i].position);
// 更新个体最优解
if (particles[i].fitness < particles[i].bestFitness) {
particles[i].bestPosition = particles[i].position;
particles[i].bestFitness = particles[i].fitness;
}
// 更新全局最优解
if (particles[i].fitness < globalBestFitness) {
globalBestPosition = particles[i].position;
globalBestFitness = particles[i].fitness;
}
}
}

// 获取全局最优解
std::vector<double> getGlobalBestPosition() const {
return globalBestPosition;
}

// 获取全局最优适应度值
double getGlobalBestFitness() const {
return globalBestFitness;
}

private:
int numParticles; // 粒子数量
int numDimensions; // 粒子维度
double inertiaWeight; // 惯性权重
double cognitiveWeight; // 认知权重
double socialWeight; // 社会权重
double minRange; // 位置范围最小值
double maxRange; // 位置范围最大值
std::vector<Particle> particles; // 粒子群
std::vector<double> globalBestPosition; // 全局最优位置
double globalBestFitness; // 全局最优适应度值

// 计算适应度值（示例中使用的是一个简单的适应度函数，可根据实际问题进行修改）
double calculateFitness(const std::vector<double>& position) {
double fitness = 0.0;
for (int i = 0; i < numDimensions; ++i) {
fitness += std::pow(position[i], 2);
}
return fitness;
}

// 生成指定范围内的随机数
double getRandomNumber(double min, double max) {
return min + static_cast<double>(rand()) / (RAND_MAX / (max - min));
}
};

int main() {
srand(static_cast<unsigned int>(time(nullptr)));

int numParticles = 50; // 粒子数量
int numDimensions = 2; // 粒子维度
double inertiaWeight = 0.7; // 惯性权重
double cognitiveWeight = 1.4; // 认知权重
double socialWeight = 1.4; // 社会权重
double minRange = -10.0; // 位置范围最小值
double maxRange = 10.0; // 位置范围最大值

PSO pso(numParticles, numDimensions, inertiaWeight, cognitiveWeight, socialWeight, minRange, maxRange);

int maxIterations = 100; // 最大迭代次数
for (int i = 0; i < maxIterations; ++i) {
pso.update();
std::cout << "Iteration " << i + 1 << ": Best Fitness = " << pso.getGlobalBestFitness() << std::endl;
}

std::cout << "Global Best Position: ";
std::vector<double> globalBestPosition = pso.getGlobalBestPosition();
for (int i = 0; i < numDimensions; ++i) {
std::cout << globalBestPosition[i] << " ";
}
std::cout << std::endl;

return 0;
}