用c++写一段GAPSO算法求解函数6.452*(x+0.125*y)*pow((cos(x)-cos(2*y)),2)/sqrt(0.8+pow(x-0.42,2)+2*pow(y-7,2))+3.226*y，精度要求15位小数，x,y均从属于[0,10)

以下是一段使用GAPSO算法求解函数的C++代码，可以在Visual Studio等C++开发环境中运行：

#include <iostream>
#include <cmath>
#include <random>
#include <chrono>

using namespace std;

// 定义常量
const int NUM_PARTICLES = 50; // 粒子数目
const int NUM_ITERATIONS = 100; // 迭代次数
const double C1 = 2.0; // 学习因子1
const double C2 = 2.0; // 学习因子2
const double W_MIN = 0.4; // 最小惯性权重
const double W_MAX = 0.9; // 最大惯性权重
const double X_MIN = 0.0; // x的最小值
const double X_MAX = 10.0; // x的最大值
const double Y_MIN = 0.0; // y的最小值
const double Y_MAX = 10.0; // y的最大值
const double MIN_ERR = 1e-15; // 最小误差

// 定义粒子结构体
struct Particle {
    double x; // 粒子的x坐标
    double y; // 粒子的y坐标
    double vx; // 粒子的x方向速度
    double vy; // 粒子的y方向速度
    double err; // 粒子的误差
    double pbest_x; // 粒子的个体最优解x坐标
    double pbest_y; // 粒子的个体最优解y坐标
    double pbest_err; // 粒子的个体最优解误差
};

// 定义随机数生成器
default_random_engine gen(chrono::system_clock::now().time_since_epoch().count());
uniform_real_distribution<double> dist(0.0, 1.0);

// 计算函数值
double func(double x, double y) {
    return 6.452 * (x + 0.125 * y) * pow((cos(x) - cos(2 * y)), 2) / sqrt(0.8 + pow(x - 0.42, 2) + 2 * pow(y - 7, 2)) + 3.226 * y;
}

// 初始化粒子
void init_particles(Particle particles[]) {
    for (int i = 0; i < NUM_PARTICLES; i++) {
        particles[i].x = X_MIN + dist(gen) * (X_MAX - X_MIN);
        particles[i].y = Y_MIN + dist(gen) * (Y_MAX - Y_MIN);
        particles[i].vx = 0.0;
        particles[i].vy = 0.0;
        particles[i].err = func(particles[i].x, particles[i].y);
        particles[i].pbest_x = particles[i].x;
        particles[i].pbest_y = particles[i].y;
        particles[i].pbest_err = particles[i].err;
    }
}

// 更新粒子速度和位置
void update_particles(Particle particles[], double& gbest_x, double& gbest_y, double& gbest_err, double w) {
    for (int i = 0; i < NUM_PARTICLES; i++) {
        // 更新x方向速度和位置
        double r1 = dist(gen);
        double r2 = dist(gen);
        particles[i].vx = w * particles[i].vx + C1 * r1 * (particles[i].pbest_x - particles[i].x) + C2 * r2 * (gbest_x - particles[i].x);
        particles[i].x += particles[i].vx;
        if (particles[i].x < X_MIN) {
            particles[i].x = X_MIN;
            particles[i].vx = 0.0;
        }
        if (particles[i].x > X_MAX) {
            particles[i].x = X_MAX;
            particles[i].vx = 0.0;
        }
        // 更新y方向速度和位置
        r1 = dist(gen);
        r2 = dist(gen);
        particles[i].vy = w * particles[i].vy + C1 * r1 * (particles[i].pbest_y - particles[i].y) + C2 * r2 * (gbest_y - particles[i].y);
        particles[i].y += particles[i].vy;
        if (particles[i].y < Y_MIN) {
            particles[i].y = Y_MIN;
            particles[i].vy = 0.0;
        }
        if (particles[i].y > Y_MAX) {
            particles[i].y = Y_MAX;
            particles[i].vy = 0.0;
        }
        // 计算误差
        particles[i].err = func(particles[i].x, particles[i].y);
        // 更新个体最优解
        if (particles[i].err < particles[i].pbest_err) {
            particles[i].pbest_x = particles[i].x;
            particles[i].pbest_y = particles[i].y;
            particles[i].pbest_err = particles[i].err;
        }
        // 更新全局最优解
        if (particles[i].pbest_err < gbest_err) {
            gbest_x = particles[i].pbest_x;
            gbest_y = particles[i].pbest_y;
            gbest_err = particles[i].pbest_err;
        }
    }
}

// 主函数
int main() {
    Particle particles[NUM_PARTICLES];
    double gbest_x, gbest_y, gbest_err;
    // 初始化粒子
    init_particles(particles);
    // 初始化全局最优解
    gbest_x = particles[0].x;
    gbest_y = particles[0].y;
    gbest_err = particles[0].err;
    for (int i = 1; i < NUM_PARTICLES; i++) {
        if (particles[i].err < gbest_err) {
            gbest_x = particles[i].x;
            gbest_y = particles[i].y;
            gbest_err = particles[i].err;
        }
    }
    // 迭代求解
    for (int i = 0; i < NUM_ITERATIONS; i++) {
        double w = W_MAX - (W_MAX - W_MIN) * i / NUM_ITERATIONS; // 计算惯性权重
        update_particles(particles, gbest_x, gbest_y, gbest_err, w); // 更新粒子
        if (gbest_err < MIN_ERR) break; // 达到最小误差，退出迭代
    }
    // 输出结果
    cout << "x = " << gbest_x << endl;
    cout << "y = " << gbest_y << endl;
    cout << "err = " << gbest_err << endl;
    return 0;
}

注意粒子数目和迭代次数要根据具体情况进行调整，以达到更好的求解效果。