upper = np.inf

`upper = np.inf` 是将 `np.inf` 赋值给变量 `upper`。在NumPy中，`np.inf` 表示正无穷大的特殊值。

在代码中，`upper` 变量被用作积分的上限限制，即定义了从0到正无穷的积分范围。将 `np.inf` 赋值给 `upper` 变量后，积分函数 `quad()` 将使用正无穷作为积分的上限。

这样就可以计算具有无穷上限的定积分。

相关问题

粒子群算法的python代码实例

粒子群算法（Particle Swarm Optimization, PSO）是一种启发式优化算法，用于解决优化问题。下面是一个简单的粒子群算法的Python代码实例：

import numpy as np

# 定义目标函数（这里以求解最小值为例）
def objective_function(x):
    return x**2

# 粒子群算法类
class ParticleSwarmOptimization:
    def __init__(self, num_particles, num_dimensions, max_iterations, lower_bound, upper_bound):
        self.num_particles = num_particles  # 粒子数量
        self.num_dimensions = num_dimensions  # 维度数量
        self.max_iterations = max_iterations  # 最大迭代次数
        self.lower_bound = lower_bound  # 变量下界
        self.upper_bound = upper_bound  # 变量上界
        self.particles = np.random.uniform(low=self.lower_bound, high=self.upper_bound,
                                           size=(self.num_particles, self.num_dimensions))  # 初始化粒子位置
        self.velocities = np.zeros_like(self.particles)  # 初始化粒子速度
        self.best_positions = self.particles.copy()  # 最佳位置
        self.best_values = np.zeros(self.num_particles) + np.inf  # 最佳值
        self.global_best_position = None  # 全局最佳位置
        self.global_best_value = np.inf  # 全局最佳值

    # 更新粒子位置和速度
    def update(self):
        for i in range(self.num_particles):
            for j in range(self.num_dimensions):
                r1 = np.random.random()
                r2 = np.random.random()
                # 更新粒子速度
                self.velocities[i][j] = self.velocities[i][j] + 2 * r1 * (self.best_positions[i][j] - self.particles[i][j]) \
                                        + 2 * r2 * (self.global_best_position[j] - self.particles[i][j])
                # 限制粒子速度范围
                self.velocities[i][j] = np.maximum(self.velocities[i][j], self.lower_bound)
                self.velocities[i][j] = np.minimum(self.velocities[i][j], self.upper_bound)
                # 更新粒子位置
                self.particles[i][j] = self.particles[i][j] + self.velocities[i][j]
                # 限制粒子位置范围
                self.particles[i][j] = np.maximum(self.particles[i][j], self.lower_bound)
                self.particles[i][j] = np.minimum(self.particles[i][j], self.upper_bound)

    # 计算适应值
    def evaluate(self):
        for i in range(self.num_particles):
            fitness = objective_function(self.particles[i])
            if fitness < self.best_values[i]:
                self.best_values[i] = fitness
                self.best_positions[i] = self.particles[i]
            if fitness < self.global_best_value:
                self.global_best_value = fitness
                self.global_best_position = self.particles[i]

    # 执行粒子群算法
    def optimize(self):
        for _ in range(self.max_iterations):
            self.update()
            self.evaluate()

# 设置参数并运行粒子群算法
num_particles = 50  # 粒子数量
num_dimensions = 1  # 维度数量
max_iterations = 100  # 最大迭代次数
lower_bound = -10  # 变量下界
upper_bound = 10  # 变量上界

pso = ParticleSwarmOptimization(num_particles, num_dimensions, max_iterations, lower_bound, upper_bound)
pso.optimize()

# 输出结果
print("最优解:", pso.global_best_position)
print("最优值:", pso.global_best_value)

这个代码实例演示了如何使用粒子群算法求解一个简单的一维优化问题。你可以根据自己的需求，修改目标函数和参数设置来解决不同的优化问题。

利用Cubic映射模式进行初始化鲸鱼算法的代码实现

以下是利用Cubic映射模式进行初始化鲸鱼算法的Python代码实现：

import numpy as np

# 定义鲸鱼算法的目标函数
def objective_function(x):
    return np.sum(x**2)

# 定义Cubic映射模式的初始化方法
def cubic_initialization(search_space, num_whales):
    dim = search_space.shape[0]
    lower_bounds = search_space[:, 0]
    upper_bounds = search_space[:, 1]
    whale_positions = np.zeros((num_whales, dim))

    for i in range(dim):
        lb = lower_bounds[i]
        ub = upper_bounds[i]
        delta = (ub - lb) / num_whales
        for j in range(num_whales):
            r = np.random.rand()
            whale_positions[j, i] = lb + (r + j) * delta

    return whale_positions

# 定义鲸鱼算法的主函数
def whale_algorithm(search_space, max_iter, num_whales):
    # 初始化鲸鱼群体
    whale_positions = cubic_initialization(search_space, num_whales)
    # 记录全局最优解
    global_best_position = None
    global_best_fitness = np.inf

    for i in range(max_iter):
        # 更新每条鲸鱼的位置
        for j in range(num_whales):
            # 计算当前鲸鱼的适应度值
            fitness = objective_function(whale_positions[j])
            # 如果当前适应度值优于个体最优解，则进行更新
            if fitness < whale_fitness[j]:
                whale_fitness[j] = fitness
                whale_best_position[j] = whale_positions[j]
            # 如果当前适应度值优于全局最优解，则进行更新
            if fitness < global_best_fitness:
                global_best_fitness = fitness
                global_best_position = whale_positions[j]
        
        # 对每条鲸鱼进行迁徙操作
        for j in range(num_whales):
            # 计算当前鲸鱼与全局最优解的距离和方向
            distance = np.linalg.norm(whale_positions[j] - global_best_position)
            direction = global_best_position - whale_positions[j]
            # 计算当前鲸鱼的运动速度
            a = 2 * np.random.rand() - 1
            c = 2 * np.random.rand()
            b = 1
            l = np.random.rand()
            p = np.random.rand()
            if p < 0.5:
                if np.abs(a) < 1:
                    new_position = global_best_position - a * distance * direction
                else:
                    rand_whale = np.random.randint(num_whales)
                    new_position = whale_positions[rand_whale] - a * distance * direction
            else:
                new_position = distance * np.exp(b * l) * np.cos(2 * np.pi * l) + global_best_position
            
            # 进行边界约束
            new_position = np.maximum(new_position, search_space[:, 0])
            new_position = np.minimum(new_position, search_space[:, 1])

            # 更新当前鲸鱼的位置
            whale_positions[j] = new_position

    return global_best_position, global_best_fitness

这段代码实现了鲸鱼算法的主要逻辑，其中利用了Cubic映射模式进行初始化。具体而言，通过调用`cubic_initialization`函数，对搜索空间进行分割，并在每个分割区域内随机生成初始解。然后，在每次迭代过程中，根据当前鲸鱼的位置和全局最优解的位置，计算运动速度，并进行位置更新。最终返回全局最优解的位置和适应度值。

需要注意的是，这段代码仅供参考，具体实现可能需要根据具体问题进行调整。