粒子群算法例子

        粒子群算法（Particle Swarm Optimization，PSO）是一种群体智能算法，灵感来自鸟群和鱼群等社会性群体的行为。

        在PSO中，个体被称为粒子，它们通过在搜索空间中移动来寻找最优解。每个粒子在搜索空间中的位置表示一个潜在解，而其速度表示搜索的方向和距离。

        PSO的基本思想是通过模拟个体间的信息共享和合作，使得整个群体逐渐收敛到最优解附近。每个粒子通过与其个体经验最优解和群体经验最优解相比较，不断调整自己的速度和位置，从而实现全局搜索和局部搜索的平衡。

        以下是一个简单的用 Java 实现的粒子群算法的示例。这个例子是一个简化的版本，用于最小化一个函数。

import java.util.Random;

public class ParticleSwarmOptimization {

    static class Particle {
        double[] position;
        double[] velocity;
        double[] personalBest;
        double fitness;

        Particle(int dimension) {
            position = new double[dimension];
            velocity = new double[dimension];
            personalBest = new double[dimension];
            initialize();
        }

        void initialize() {
            Random rand = new Random();
            for (int i = 0; i < position.length; i++) {
                position[i] = rand.nextDouble() * 10; // Initialize positions randomly
                velocity[i] = rand.nextDouble(); // Initialize velocities randomly
                personalBest[i] = position[i];
            }
            fitness = evaluateFitness(position);
        }
    }

    static double evaluateFitness(double[] position) {
        // This is the function to be minimized, you can replace it with your own
        // For example, you can use the Rosenbrock function: f(x, y) = (a - x)^2 + b * (y - x^2)^2
        double a = 1;
        double b = 100;
        double x = position[0];
        double y = position[1];
        return Math.pow(a - x, 2) + b * Math.pow(y - x * x, 2);
    }

    public static void main(String[] args) {
        int numParticles = 30;
        int numDimensions = 2;
        int maxIterations = 100;
        double inertiaWeight = 0.7;
        double cognitiveWeight = 1.5;
        double socialWeight = 1.5;

        Particle[] particles = new Particle[numParticles];
        double[] globalBest = new double[numDimensions];
        double globalBestFitness = Double.MAX_VALUE;

        // Initialize particles
        for (int i = 0; i < numParticles; i++) {
            particles[i] = new Particle(numDimensions);
        }

        // Main loop
        for (int iteration = 0; iteration < maxIterations; iteration++) {
            // Update particle positions and velocities
            for (Particle particle : particles) {
                for (int d = 0; d < numDimensions; d++) {
                    double inertiaTerm = inertiaWeight * particle.velocity[d];
                    double cognitiveTerm = cognitiveWeight
                            * Math.random() * (particle.personalBest[d] - particle.position[d]);
                    double socialTerm = socialWeight
                            * Math.random() * (globalBest[d] - particle.position[d]);

                    particle.velocity[d] = inertiaTerm + cognitiveTerm + socialTerm;
                    particle.position[d] += particle.velocity[d];
                }

                // Update fitness
                particle.fitness = evaluateFitness(particle.position);

                // Update personal best
                if (particle.fitness < evaluateFitness(particle.personalBest)) {
                    System.arraycopy(particle.position, 0, particle.personalBest, 0, numDimensions);
                }

                // Update global best
                if (particle.fitness < globalBestFitness) {
                    globalBestFitness = particle.fitness;
                    System.arraycopy(particle.position, 0, globalBest, 0, numDimensions);
                }
            }

            // Output the best fitness value in each iteration
            System.out.println("Iteration " + iteration + ": Best Fitness = " + globalBestFitness);
        }

        // Output the final result
        System.out.println("Optimal Solution:");
        for (int d = 0; d < numDimensions; d++) {
            System.out.println("x[" + d + "] = " + globalBest[d]);
        }
        System.out.println("Minimum Fitness = " + globalBestFitness);
    }
}