Java实现粒子群算法

粒子群算法是一种优化算法，可以用于解决许多问题，例如函数优化、组合优化和机器学习等。下面是Java实现粒子群算法的步骤：

// 定义粒子类
class Particle {
    double[] position; // 粒子位置
    double[] velocity; // 粒子速度
    double[] pBest; // 个体最优位置
    double fitness; // 适应度值

    public Particle(int dim) {
        position = new double[dim];
        velocity = new double[dim];
        pBest = new double[dim];
        fitness = Double.MAX_VALUE;
    }
}

// 定义粒子群类
class PSO {
    int swarmSize; // 粒子群大小
    int maxIter; // 最大迭代次数
    double w; // 惯性权重
    double c1, c2; // 学习因子
    double[] gBest; // 全局最优位置
    double gBestFitness; // 全局最优适应度值
    Particle[] swarm; // 粒子群

    public PSO(int swarmSize, int maxIter, double w, double c1, double c2) {
        this.swarmSize = swarmSize;
        this.maxIter = maxIter;
        this.w = w;
        this.c1 = c1;
        this.c2 = c2;
        swarm = new Particle[swarmSize];
        gBest = new double[swarm[0].position.length];
        gBestFitness = Double.MAX_VALUE;
        for (int i = 0; i < swarmSize; i++) {
            swarm[i] = new Particle(gBest.length);
            for (int j = 0; j < gBest.length; j++) {
                swarm[i].position[j] = Math.random() * 10; // 初始化粒子位置
                swarm[i].velocity[j] = Math.random() * 2; // 初始化粒子速度
            }
        }
    }

    // 更新粒子位置和速度
    public void update() {
        for (int i = 0; i < swarmSize; i++) {
            Particle p = swarm[i];
            for (int j = 0; j < p.position.length; j++) {
                // 更新速度
                p.velocity[j] = w * p.velocity[j] + c1 * Math.random() * (p.pBest[j] - p.position[j])
                        + c2 * Math.random() * (gBest[j] - p.position[j]);
                // 更新位置
                p.position[j] += p.velocity[j];
            }
            // 更新个体最优位置
            double fitness = evaluate(p.position);
            if (fitness < p.fitness) {
                p.fitness = fitness;
                System.arraycopy(p.position, 0, p.pBest, 0, p.position.length);
            }
            // 更新全局最优位置
            if (fitness < gBestFitness) {
                gBestFitness = fitness;
                System.arraycopy(p.position, 0, gBest, 0, p.position.length);
            }
        }
    }

    // 计算适应度值
    public double evaluate(double[] x) {
        // TODO: 根据具体问题实现适应度函数
        return 0;
    }

    // 运行粒子群算法
    public void run() {
        for (int i = 0; i < maxIter; i++) {
            update();
        }
    }
}

// 使用粒子群算法解决函数优化问题的例子
public class Main {
    public static void main(String[] args) {
        PSO pso = new PSO(30, 100, 0.6, 1.5, 1.5);
        pso.run();
        System.out.println("最优解：" + Arrays.toString(pso.gBest));
        System.out.println("最优适应度值：" + pso.gBestFitness);
    }
}