区间粒子群算法代码，有注释

以下是一个简单的区间粒子群算法（Interval Particle Swarm Optimization，IPSO）代码示例，附有注释：

import random

# 定义区间粒子类
class IntervalParticle:
    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.pbest = []  # 粒子历史最优位置
        self.pbest_fitness = None  # 粒子历史最优的适应度值
        self.fitness = None  # 粒子当前适应度值

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

    # 更新粒子速度和位置
    def update(self, w, c1, c2, gbest):
        for i in range(self.dim):
            r1 = random.uniform(0, 1)
            r2 = random.uniform(0, 1)
            self.velocity[i] = w * self.velocity[i] + c1 * r1 * (self.pbest[i] - self.position[i]) + c2 * r2 * (gbest[i] - self.position[i])
            self.position[i] = self.position[i] + self.velocity[i]

            # 粒子位置需要在区间内
            if self.position[i] < self.lower_bound[i]:
                self.position[i] = self.lower_bound[i]
                self.velocity[i] *= -1
            elif self.position[i] > self.upper_bound[i]:
                self.position[i] = self.upper_bound[i]
                self.velocity[i] *= -1

    # 更新粒子历史最优位置和适应度值
    def update_pbest(self):
        if self.pbest_fitness is None or self.fitness < self.pbest_fitness:
            self.pbest = self.position.copy()
            self.pbest_fitness = self.fitness

# 定义区间粒子群类
class IntervalPSO:
    def __init__(self, dim, lower_bound, upper_bound, num_particles, max_iter):
        self.dim = dim  # 粒子维度
        self.lower_bound = lower_bound  # 粒子位置下界
        self.upper_bound = upper_bound  # 粒子位置上界
        self.num_particles = num_particles  # 粒子数目
        self.max_iter = max_iter  # 最大迭代次数
        self.particles = []  # 粒子列表
        self.gbest = None  # 全局最优位置
        self.gbest_fitness = None  # 全局最优适应度值

        # 初始化粒子群
        for i in range(num_particles):
            self.particles.append(IntervalParticle(dim, lower_bound, upper_bound))

    # 计算粒子适应度值
    def evaluate_fitness(self, func):
        for particle in self.particles:
            particle.fitness = func(particle.position)

    # 更新全局最优位置和适应度值
    def update_gbest(self):
        for particle in self.particles:
            if self.gbest_fitness is None or particle.pbest_fitness < self.gbest_fitness:
                self.gbest = particle.pbest.copy()
                self.gbest_fitness = particle.pbest_fitness

    # 运行区间粒子群算法
    def run(self, func, w=0.8, c1=1.5, c2=1.5):
        # 初始化全局最优位置和适应度值
        self.evaluate_fitness(func)
        self.update_gbest()

        # 迭代
        for iter in range(self.max_iter):
            for particle in self.particles:
                # 更新粒子速度和位置
                particle.update(w, c1, c2, self.gbest)
                # 更新粒子历史最优位置和适应度值
                particle.update_pbest()
            # 更新全局最优位置和适应度值
            self.update_gbest()

        return self.gbest, self.gbest_fitness

在这个示例中，我们首先定义了一个 IntervalParticle 类来表示一个区间粒子，其中包含了粒子的位置、速度、历史最优位置、历史最优适应度值和当前适应度值等属性，以及更新位置和速度、更新历史最优位置和适应度值的方法。然后我们定义了一个 IntervalPSO 类来表示一个区间粒子群，其中包含了粒子数目、最大迭代次数、粒子列表、全局最优位置和适应度值等属性，以及计算适应度值、更新全局最优位置和运行算法的方法。

在运行算法时，我们首先需要初始化全局最优位置和适应度值，然后进行迭代。在每一次迭代中，我们遍历每个粒子，更新其速度和位置，更新其历史最优位置和适应度值，然后更新全局最优位置和适应度值。最后返回全局最优位置和适应度值作为算法的输出。