import numpy as np


def PSO_multi_obj(fitness_func, n_particles, n_dims, n_objs, max_iter=100, w=0.7, c1=1.4, c2=1.4):
    # 定义初始的粒子群
    swarm_position = np.empty((n_particles, n_dims))
    for i in range(n_particles):
        swarm_position[i] = individuals['chrom'][i]

    # 定义粒子群速度
    swarm_velocity = np.zeros((n_particles, n_dims))

    # 定义粒子群最优位置
    swarm_best_position = swarm_position.copy()

    # 计算初始粒子群适应度
    swarm_fitness = np.empty((n_particles, n_objs))
    for i in range(n_particles):
        swarm_fitness[i] = fitness_func(individuals['chrom'][i])

    # 定义每个粒子历史最优位置
    particle_best_position = swarm_position.copy()

    # 定义每个粒子历史最优适应度
    particle_best_fitness = swarm_fitness.copy()

    # 定义全局最优位置
    global_best_position = swarm_best_position[np.argmin(swarm_fitness)]

    # 定义全局最优适应度
    global_best_fitness = np.min(swarm_fitness)

    # 进行迭代
    for t in range(max_iter):
        # 更新粒子群速度和位置
        swarm_velocity = w * swarm_velocity + \
                         c1 * np.random.rand(n_particles, n_dims) * (particle_best_position - swarm_position) + \
                         c2 * np.random.rand(n_particles, n_dims) * (global_best_position - swarm_position)
        swarm_position += swarm_velocity

        # 将超出边界的位置调整到边界内
        for i in range(n_particles):
            for j in range(n_dims):
                if swarm_position[i][j] < bound[j][0]:
                    swarm_position[i][j] = bound[j][0]
                if swarm_position[i][j] > bound[j][1]:
                    swarm_position[i][j] = bound[j][1]

        # 计算新的适应度
        for i in range(n_particles):
            fitness = fitness_func(swarm_position[i])
            swarm_fitness[i] = fitness

        # 更新粒子历史最优位置
        for i in range(n_particles):
            if np.min(swarm_fitness[i]) < np.min(particle_best_fitness[i]):
                particle_best_fitness[i] = swarm_fitness[i]
                particle_best_position[i] = swarm_position[i]


        # 更新粒子群最优位置
        for i in range(n_particles):
            if np.min(particle_best_fitness[i]) < np.min(swarm_fitness[i]):
                swarm_best_position[i] = particle_best_position[i]

        # 更新全局最优位置
        if np.min(swarm_fitness) < global_best_fitness:
            global_best_fitness = np.min(swarm_fitness)
            global_best_position = swarm_position[np.argmin(swarm_fitness)]

        # 记录每一次迭代的全局最优适应度
        trace.append(global_best_fitness)

    # 返回最终的全局最优位置和适应度
    return global_best_position