最优化理论及应用实验

Question

19:38
D
D 51
0N
实验1-粒子群优化.pdf
实验一
用粒子群优化求下面2个函数的最小值
（1）Griewank函数（n-2)
E-II
）=1+2000
Ras(x)=20+x1+x-10(CO 2X,+ COs2元xz)
提交内容
（1）用C.C++，
JAVA写的实验源代码
1/1
全部工具

Answer 1

引自免费微信小程序：皆我百晓生

针对您的问题，您需要使用粒子群优化算法（PSO）来分别求解Griewank函数和Rastrigin函数在二维空间中的最小值，并用Java实现该算法。以下是基于粒子群优化算法的Java源代码示例：

import java.util.Random;

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

    public Particle(int dimensions) {
        this.position = new double[dimensions];
        this.velocity = new double[dimensions];
        Random rand = new Random();
        for (int i = 0; i < dimensions; i++) {
            position[i] = rand.nextDouble() * 10 - 5; // 初始化位置范围-5到5
            velocity[i] = rand.nextDouble() * 2 - 1; // 初始化速度范围-1到1
        }
    }

    // 更新粒子状态
    public void update(double w, double c1, double c2, double globalBestFitness, double[] globalBestPosition) {
        for (int i = 0; i < position.length; i++) {
            velocity[i] = w * velocity[i] + c1 * random() * (personalBestPosition[i] - position[i]) + 
                          c2 * random() * (globalBestPosition[i] - position[i]);
            position[i] += velocity[i];

            // 对于 Griewank 函数和 Rastrigin 函数，我们需要确保粒子的位置限制在一定范围内，比如 [-5, 5]
            position[i] = Math.min(Math.max(position[i], -5), 5);
        }

        // 这里计算当前粒子的新适应度值并更新个体最优
        // 假设我们有一个 calculateFitness 函数用于计算适应度
        double currentFitness = calculateFitness(Griewank, position); // 对于 Griewank 函数
        // 或者
        // double currentFitness = calculateFitness(Rastrigin, position); // 对于 Rastrigin 函数
        if (currentFitness < personalBest) {
            personalBest = currentFitness;
            personalBestPosition = position.clone();
        }
    }

    private double random() {
        return new Random().nextDouble();
    }

    // Griewank 函数计算
    static double Griewank(double[] x) {
        int n = x.length;
        double sum1 = 0.0, prod = 1.0;
        for (int i = 0; i < n; i++) {
            sum1 += x[i] * x[i] / 4000.0;
            prod *= Math.cos(x[i] / Math.sqrt(i + 1));
        }
        return 1 + sum1 - prod;
    }

    // Rastrigin 函数计算
    static double Rastrigin(double[] x) {
        double sum = 20 + x[0] * x[0] + x[1] * x[1];
        sum -= 10 * (Math.cos(2 * Math.PI * x[0]) + Math.cos(2 * Math.PI * x[1]));
        return sum;
    }
}

// 定义粒子群类
class Swarm {
    Particle[] particles;
    double globalBestFitness;
    double[] globalBestPosition;

    public Swarm(int particleCount, int dimensions) {
        this.particles = new Particle[particleCount];
        for (int i = 0; i < particleCount; i++) {
            particles[i] = new Particle(dimensions);
        }
    }

    // PSO主循环
    public void run(int maxIterations, double w, double c1, double c2) {
        for (int iter = 0; iter < maxIterations; iter++) {
            for (Particle p : particles) {
                p.update(w, c1, c2, globalBestFitness, globalBestPosition);
                
                // 更新全局最优解
                if (p.personalBest < globalBestFitness) {
                    globalBestFitness = p.personalBest;
                    globalBestPosition = p.personalBestPosition.clone();
                }
            }
        }
    }
}

public class ParticleSwarmOptimization {
    public static void main(String[] args) {
        int particleCount = 50; // 粒子数量
        int dimensions = 2; // 维度
        int maxIterations = 500; // 最大迭代次数
        double w = 0.729; // 惯性权重
        double c1 = 1.49445; // 认知参数
        double c2 = 1.49445; // 社会参数

        Swarm swarm = new Swarm(particleCount, dimensions);
        swarm.run(maxIterations, w, c1, c2);

        System.out.println("全局最优解：");
        System.out.println("适应度：" + swarm.globalBestFitness);
        System.out.println("位置：" + Arrays.toString(swarm.globalBestPosition));
    }
}

这段代码首先定义了一个Particle类表示每个粒子，包含了粒子的位置、速度以及个体最优位置和适应度。然后定义了粒子群Swarm类进行整个优化过程。最后，在ParticleSwarmOptimization类中初始化粒子群并运行PSO算法以寻找Griewank和Rastrigin函数的最小值。

请根据实验要求调整上述代码中的最大迭代次数、粒子数量和其他相关参数。同时，请注意在实际项目中，你需要实现一个calculateFitness方法来计算给定位置下的具体适应度值，这里为了简洁起见，直接在Particle类中实现了这两个目标函数的计算方法。