粒子群优化算法（C++实现）

以下是粒子群优化算法的C实现：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define N 20 // 粒子数
#define D 10 // 每个粒子的维度
#define MAX_ITER 100 // 最大迭代次数

// 定义粒子结构体
typedef struct
{
    double pos[D]; // 粒子位置
    double vel[D]; // 粒子速度
    double pbest[D]; // 个体最优解
    double fitness; // 适应度函数值
} Particle;

// 定义全局最优解和其适应度函数值
double gbest[D];
double gbest_fitness;

// 定义适应度函数
double fitness_func(double x[D])
{
    double sum = 0;
    for (int i = 0; i < D; i++)
    {
        sum += x[i] * x[i];
    }
    return sum;
}

// 初始化粒子位置和速度
void init_particles(Particle particles[])
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < D; j++)
        {
            particles[i].pos[j] = (double)rand() / RAND_MAX * 20 - 10; // 位置范围为[-10, 10]
            particles[i].vel[j] = (double)rand() / RAND_MAX * 4 - 2; // 速度范围为[-2, 2]
        }
        particles[i].fitness = fitness_func(particles[i].pos); // 计算适应度函数值
        for (int j = 0; j < D; j++)
        {
            particles[i].pbest[j] = particles[i].pos[j]; // 个体最优解初始值为当前位置
        }
        if (i == 0 || particles[i].fitness < gbest_fitness)
        {
            gbest_fitness = particles[i].fitness;
            for (int j = 0; j < D; j++)
            {
                gbest[j] = particles[i].pos[j]; // 全局最优解初始值为第一个粒子的位置
            }
        }
    }
}

// 更新粒子位置和速度
void update_particles(Particle particles[])
{
    double w = 0.8; // 惯性权重
    double c1 = 1.5; // 自我学习因子
    double c2 = 1.5; // 社会学习因子

    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < D; j++)
        {
            particles[i].vel[j] = w * particles[i].vel[j] + c1 * (particles[i].pbest[j] - particles[i].pos[j]) * (double)rand() / RAND_MAX + c2 * (gbest[j] - particles[i].pos[j]) * (double)rand() / RAND_MAX;
            particles[i].pos[j] += particles[i].vel[j];
            if (particles[i].pos[j] < -10)
            {
                particles[i].pos[j] = -10;
                particles[i].vel[j] = -particles[i].vel[j];
            }
            if (particles[i].pos[j] > 10)
            {
                particles[i].pos[j] = 10;
                particles[i].vel[j] = -particles[i].vel[j];
            }
        }
        particles[i].fitness = fitness_func(particles[i].pos);
        if (particles[i].fitness < fitness_func(particles[i].pbest))
        {
            for (int j = 0; j < D; j++)
            {
                particles[i].pbest[j] = particles[i].pos[j]; // 更新个体最优解
            }
        }
        if (particles[i].fitness < gbest_fitness)
        {
            gbest_fitness = particles[i].fitness;
            for (int j = 0; j < D; j++)
            {
                gbest[j] = particles[i].pos[j]; // 更新全局最优解
            }
        }
    }
}

int main()
{
    Particle particles[N];

    srand(1); // 随机数种子

    init_particles(particles); // 初始化粒子

    for (int iter = 0; iter < MAX_ITER; iter++)
    {
        update_particles(particles); // 更新粒子
        printf("Iteration %d: %lf\n", iter, gbest_fitness); // 输出每次迭代的全局最优解的适应度函数值
    }

    return 0;
}

在程序中，粒子群优化算法的主要步骤包括：

1. 定义粒子结构体，包括位置、速度、个体最优解、适应度函数值等信息。
2. 初始化粒子位置和速度，计算适应度函数值，并为每个粒子设置个体最优解和全局最优解。
3. 迭代更新粒子位置和速度，计算适应度函数值，并更新个体最优解和全局最优解。
4. 输出每次迭代的全局最优解的适应度函数值。

需要注意的是，粒子位置和速度的更新需要考虑边界情况，即当粒子位置超出范围时需要将其限制在范围内，并将速度取反以保证粒子不会继续朝超出范围的方向移动。此外，粒子速度的更新需要加入随机项以增加搜索的多样性。

在本例中，适应度函数为$x_1^2+x_2^2+\cdots+x_{10}^2$，即10维欧几里得距离的平方。程序输出每次迭代的全局最优解的适应度函数值，可以看到随着迭代次数的增加，适应度函数值逐渐趋近于0，即全局最优解接近于$(0, 0, \cdots, 0)$。