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

以下是粒子群优化算法的C语言实现示例：

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

#define POP_SIZE 50  // 种群大小
#define DIM 2  // 问题维度
#define MAX_ITER 100  // 最大迭代次数

#define V_MAX 0.5  // 粒子速度上限
#define C1 2.0  // 自我认知因子
#define C2 2.0  // 社会经验因子

double f(double x[]);  // 适应度函数
void init(double pop[][DIM], double vel[][DIM], double p_best[][DIM], double *g_best);  // 初始化种群
void update(double pop[][DIM], double vel[][DIM], double p_best[][DIM], double *g_best);  // 更新粒子位置和速度
void evaluate(double pop[][DIM], double p_best[][DIM], double *g_best);  // 计算适应度值
double rand_01();  // 生成0到1之间的随机数

int main()
{
    double pop[POP_SIZE][DIM];  // 种群
    double vel[POP_SIZE][DIM];  // 速度
    double p_best[POP_SIZE][DIM];  // 个体最优位置
    double g_best[DIM];  // 全局最优位置
    int iter;  // 迭代次数

    init(pop, vel, p_best, g_best);

    for (iter = 0; iter < MAX_ITER; iter++) {
        update(pop, vel, p_best, g_best);
        evaluate(pop, p_best, g_best);
        printf("iter: %d, g_best: (%f, %f), f(g_best): %f\n", iter, g_best[0], g_best[1], f(g_best));
    }

    return 0;
}

double f(double x[])
{
    // 适应度函数，这里以(x1-2)^2+(x2-3)^2为例
    return pow(x[0]-2, 2) + pow(x[1]-3, 2);
}

void init(double pop[][DIM], double vel[][DIM], double p_best[][DIM], double *g_best)
{
    // 初始化种群
    int i, j;
    for (i = 0; i < POP_SIZE; i++) {
        for (j = 0; j < DIM; j++) {
            pop[i][j] = rand_01() * 10 - 5;  // 随机生成[-5, 5]之间的初始位置
            vel[i][j] = rand_01() * V_MAX - V_MAX/2;  // 随机生成[-V_MAX/2, V_MAX/2]之间的初始速度
            p_best[i][j] = pop[i][j];  // 个体最优位置初始为当前位置
        }
    }
    g_best[0] = pop[0][0];
    g_best[1] = pop[0][1];
}

void update(double pop[][DIM], double vel[][DIM], double p_best[][DIM], double *g_best)
{
    // 更新粒子位置和速度
    int i, j;
    for (i = 0; i < POP_SIZE; i++) {
        for (j = 0; j < DIM; j++) {
            vel[i][j] = vel[i][j] + C1 * rand_01() * (p_best[i][j] - pop[i][j]) + C2 * rand_01() * (g_best[j] - pop[i][j]);  // 更新速度
            if (vel[i][j] > V_MAX) {
                vel[i][j] = V_MAX;  // 速度上限限制
            } else if (vel[i][j] < -V_MAX) {
                vel[i][j] = -V_MAX;
            }
            pop[i][j] = pop[i][j] + vel[i][j];  // 更新位置
        }
    }
}

void evaluate(double pop[][DIM], double p_best[][DIM], double *g_best)
{
    // 计算适应度值
    int i, j;
    double f_val;
    for (i = 0; i < POP_SIZE; i++) {
        f_val = f(pop[i]);
        if (f_val < f(p_best[i])) {  // 更新个体最优位置
            for (j = 0; j < DIM; j++) {
                p_best[i][j] = pop[i][j];
            }
        }
        if (f_val < f(g_best)) {  // 更新全局最优位置
            g_best[0] = pop[i][0];
            g_best[1] = pop[i][1];
        }
    }
}

double rand_01()
{
    // 生成0到1之间的随机数
    return rand() / (double)RAND_MAX;
}

其中，`f()`函数为适应度函数，`init()`函数为种群初始化函数，`update()`函数为粒子位置和速度更新函数，`evaluate()`函数为适应度值计算函数，`rand_01()`函数为生成0到1之间的随机数函数。在`main()`函数中，先进行种群初始化，然后进行粒子位置和速度的更新和适应度值的计算，最后输出结果。