并行粒子群算法在Julia中的实现

using Distributed
addprocs(4)  # 添加4个工作进程

@everywhere function pso(fitness_func, n_particles, n_iterations, bounds)
    # 初始化粒子位置和速度
    particles = rand(n_particles, length(bounds)) .* (bounds[:, 2] - bounds[:, 1]) .+ bounds[:, 1]
    velocities = zeros(n_particles, length(bounds))
    personal_best_positions = copy(particles)
    personal_best_scores = zeros(n_particles)

    # 初始化全局最优位置和分数
    global_best_position = zeros(length(bounds))
    global_best_score = Inf

    for iter in 1:n_iterations
        @distributed for i in 1:n_particles
            # 更新速度和位置
            velocities[i, :] .= velocities[i, :] .+ 
                                rand() * (personal_best_positions[i, :] .- particles[i, :]) .+ 
                                rand() * (global_best_position .- particles[i, :])
            particles[i, :] .= particles[i, :] .+ velocities[i, :]

            # 计算适应度
            score = fitness_func(particles[i, :])

            # 更新个人最优
            if score < personal_best_scores[i]
                personal_best_scores[i] = score
                personal_best_positions[i, :] = particles[i, :]
            end

            # 更新全局最优
            if score < global_best_score
                global_best_score = score
                global_best_position = particles[i, :]
            end
        end
    end

    return global_best_position, global_best_score
end

# 示例适应度函数
function rastrigin(x)
    A = 10
    n = length(x)
    return A * n + sum(x.^2 .- A * cos.(2 * π * x))
end

bounds = [(-5.12, 5.12)] * 10  # 10维问题
n_particles = 30
n_iterations = 100

best_position, best_score = pso(rastrigin, n_particles, n_iterations, bounds)
println("Best position: ", best_position)
println("Best score: ", best_score)