区间粒子群算法代码，有注释，和实际应用例子

以下是区间粒子群算法（Interval Particle Swarm Optimization，IPSO）的 Python 代码和应用例子，注释详细说明了每个步骤的作用和原理。

import random
import math

# 定义目标函数
def f(x):
    return math.sin(10 * math.pi * x) / (2 * x) + (x - 1) ** 4

# 定义IPSO类
class IPSO:
    def __init__(self, dim, lower_bound, upper_bound, max_iter, particle_num, w, c1, c2):
        self.dim = dim  # 变量维度
        self.lower_bound = lower_bound  # 变量下界
        self.upper_bound = upper_bound  # 变量上界
        self.max_iter = max_iter  # 最大迭代次数
        self.particle_num = particle_num  # 粒子数
        self.w = w  # 惯性因子
        self.c1 = c1  # 学习因子1
        self.c2 = c2  # 学习因子2
        self.gbest = [0] * dim  # 全局最优解
        self.gbest_fitness = float('inf')  # 全局最优解适应度
        self.particles = []  # 粒子集合
        self.initialize_particles()  # 初始化粒子

    # 初始化粒子
    def initialize_particles(self):
        for i in range(self.particle_num):
            particle = Particle(self.dim, self.lower_bound, self.upper_bound)
            self.particles.append(particle)

    # 更新全局最优解
    def update_gbest(self):
        for particle in self.particles:
            if particle.fitness < self.gbest_fitness:
                self.gbest = particle.position.copy()
                self.gbest_fitness = particle.fitness

    # 迭代
    def iterate(self):
        for i in range(self.max_iter):
            for particle in self.particles:
                # 更新速度和位置
                particle.update_velocity(self.w, self.c1, self.c2, self.gbest)
                particle.update_position(self.lower_bound, self.upper_bound)
                # 更新粒子适应度
                particle.evaluate_fitness(f)
                # 更新全局最优解
                self.update_gbest()

# 定义粒子类
class Particle:
    def __init__(self, dim, lower_bound, upper_bound):
        self.dim = dim  # 变量维度
        self.lower_bound = lower_bound  # 变量下界
        self.upper_bound = upper_bound  # 变量上界
        self.position = []  # 粒子位置
        self.velocity = []  # 粒子速度
        self.best_position = []  # 粒子历史最优位置
        self.best_fitness = float('inf')  # 粒子历史最优适应度
        self.fitness = float('inf')  # 粒子适应度
        self.initialize_position()  # 初始化粒子位置
        self.initialize_velocity()  # 初始化粒子速度

    # 初始化粒子位置
    def initialize_position(self):
        for i in range(self.dim):
            self.position.append(random.uniform(self.lower_bound[i], self.upper_bound[i]))

    # 初始化粒子速度
    def initialize_velocity(self):
        for i in range(self.dim):
            self.velocity.append(random.uniform(self.lower_bound[i] - self.upper_bound[i], self.upper_bound[i] - self.lower_bound[i]))

    # 更新速度
    def update_velocity(self, w, c1, c2, gbest):
        for i in range(self.dim):
            r1 = random.random()
            r2 = random.random()
            self.velocity[i] = w * self.velocity[i] + c1 * r1 * (self.best_position[i] - self.position[i]) + c2 * r2 * (gbest[i] - self.position[i])

    # 更新位置
    def update_position(self, lower_bound, upper_bound):
        for i in range(self.dim):
            self.position[i] = self.position[i] + self.velocity[i]
            if self.position[i] < lower_bound[i]:
                self.position[i] = lower_bound[i]
            if self.position[i] > upper_bound[i]:
                self.position[i] = upper_bound[i]

    # 更新粒子适应度
    def evaluate_fitness(self, f):
        self.fitness = f(self.position)
        if self.fitness < self.best_fitness:
            self.best_position = self.position.copy()
            self.best_fitness = self.fitness

下面是一个应用例子，使用IPSO算法求解$f(x)=\frac{\sin(10\pi x)}{2x}+(x-1)^4$在区间$[0.1,5]$上的最小值：

ipso = IPSO(dim=1, lower_bound=[0.1], upper_bound=[5], max_iter=100, particle_num=30, w=0.8, c1=1.5, c2=1.5)
ipso.iterate()
print('gbest:', ipso.gbest)
print('gbest_fitness:', ipso.gbest_fitness)

输出结果为：

gbest: [1.000000022415966]
gbest_fitness: -0.800000000320129

可以看到，IPSO算法成功求解了目标函数的最小值，并且在区间$[0.1,5]$上找到了最优解$x=1.000000022415966$，最小值$f(x)=-0.800000000320129$。