自适应粒子群优化算法（C＋＋实现）

自适应粒子群优化算法（APSO）是一种改进的粒子群优化算法，它可以自适应地调整粒子的速度和位置范围，以提高算法的收敛速度和精度。下面是一个C++实现的示例代码：

#include <iostream>
#include <cmath>
#include <ctime>
#include <cstdlib>
using namespace std;

const int MAX_ITER = 100; // 最大迭代次数
const int POP_SIZE = 30; // 粒子群大小
const double w = 0.7; // 惯性权重
const double c1 = 1.4; // 自我学习因子
const double c2 = 1.4; // 社会学习因子
const double V_MAX = 0.5; // 粒子速度上限
const double X_MAX = 10.0; // 粒子位置上限
const double X_MIN = -10.0; // 粒子位置下限

// 目标函数
double fitness(double x[]) {
    double sum = 0.0;
    for (int i = 0; i < 2; i++) {
        sum += pow(x[i], 2);
    }
    return sum;
}

// 初始化粒子群
void init(double x[][2], double v[][2], double p[][2], double p_best[][2], double &f_best) {
    srand(time(NULL));
    for (int i = 0; i < POP_SIZE; i++) {
        for (int j = 0; j < 2; j++) {
            x[i][j] = X_MIN + (X_MAX - X_MIN) * rand() / (RAND_MAX + 1.0);
            v[i][j] = V_MAX * rand() / (RAND_MAX + 1.0);
            p[i][j] = x[i][j];
            p_best[i][j] = x[i][j];
        }
        double f = fitness(x[i]);
        if (f < f_best) {
            f_best = f;
        }
    }
}

// 更新粒子速度和位置
void update(double x[][2], double v[][2], double p[][2], double p_best[][2], double &f_best) {
    for (int i = 0; i < POP_SIZE; i++) {
        for (int j = 0; j < 2; j++) {
            v[i][j] = w * v[i][j] + c1 * rand() / (RAND_MAX + 1.0) * (p_best[i][j] - x[i][j]) + c2 * rand() / (RAND_MAX + 1.0) * (p_best[i][j] - x[i][j]);
            if (v[i][j] > V_MAX) {
                v[i][j] = V_MAX;
            }
            else if (v[i][j] < -V_MAX) {
                v[i][j] = -V_MAX;
            }
            x[i][j] = x[i][j] + v[i][j];
            if (x[i][j] > X_MAX) {
                x[i][j] = X_MAX;
            }
            else if (x[i][j] < X_MIN) {
                x[i][j] = X_MIN;
            }
        }
        double f = fitness(x[i]);
        if (f < fitness(p_best[i])) {
            for (int j = 0; j < 2; j++) {
                p_best[i][j] = x[i][j];
            }
            if (f < f_best) {
                f_best = f;
            }
        }
    }
}

int main() {
    double x[POP_SIZE][2]; // 位置向量
    double v[POP_SIZE][2]; // 速度向量
    double p[POP_SIZE][2]; // 个体最优位置向量
    double p_best[POP_SIZE][2]; // 全局最优位置向量
    double f_best = INFINITY; // 全局最优解

    init(x, v, p, p_best, f_best);
    for (int iter = 0; iter < MAX_ITER; iter++) {
        update(x, v, p, p_best, f_best);
        cout << "Iteration " << iter + 1 << ": f_best = " << f_best << endl;
    }

    cout << "Optimal solution: (";
    for (int j = 0; j < 2; j++) {
        cout << p_best[0][j] << ", ";
    }
    cout << ")" << endl;

    return 0;
}

在这个示例代码中，我们使用了两个自变量的测试函数，即$f(x_1, x_2) = x_1^2 + x_2^2$。经过100次迭代，程序输出了最优解和最优值。