使用遗传算法或模拟退火算法求解下列优化问题。 求一元函数f( x) = x²sin( 30x) + 1.5在区间[—1，2]上的最大值。

首先，我们需要定义适应度函数。由于问题是求最大值，因此我们可以将适应度函数定义为 f(x) 本身。

然后，我们可以使用遗传算法或模拟退火算法来搜索最大值。下面是使用遗传算法的步骤：

1. 初始化种群。我们可以从区间 [-1, 2] 中随机生成一些个体作为初始种群。

2. 评估适应度。对于每个个体 x，计算其适应度 f(x)。

3. 选择。使用轮盘赌选择算子选择一些个体作为下一代的父母。

4. 交叉。使用单点交叉算子对父母进行交叉操作，生成新的子代。

5. 变异。使用变异算子对子代进行变异操作，生成更多的个体。

6. 评估适应度。对于每个个体 x，计算其适应度 f(x)。

7. 选择。使用精英选择算子从父代和子代中选择一些最优秀的个体作为下一代的种群。

8. 重复步骤 4-7，直到达到终止条件（例如达到最大迭代次数或找到满足条件的解）。

下面是 Python 代码实现：

import random
import math

# 定义适应度函数
def fitness(x):
    return x**2 * math.sin(30 * x) + 1.5

# 定义单点交叉算子
def crossover(parent1, parent2):
    point = random.randint(0, len(parent1) - 1)
    child1 = parent1[:point] + parent2[point:]
    child2 = parent2[:point] + parent1[point:]
    return child1, child2

# 定义变异算子
def mutation(individual, p):
    for i in range(len(individual)):
        if random.random() < p:
            individual[i] = random.uniform(-1, 2)
    return individual

# 初始化种群
pop_size = 50
population = [[random.uniform(-1, 2)] for _ in range(pop_size)]

# 遗传算法主循环
max_iter = 1000
p_crossover = 0.8
p_mutation = 0.1
elite_size = 5

for i in range(max_iter):
    # 评估适应度
    fitnesses = [fitness(x) for x in population]
    
    # 选择
    elite_indices = sorted(range(pop_size), key=lambda i: fitnesses[i], reverse=True)[:elite_size]
    parents = [population[i] for i in elite_indices]
    offspring_size = pop_size - elite_size
    offspring = []
    while len(offspring) < offspring_size:
        parent1, parent2 = random.choices(parents, k=2)
        if random.random() < p_crossover:
            child1, child2 = crossover(parent1, parent2)
        else:
            child1, child2 = parent1, parent2
        child1 = mutation(child1, p_mutation)
        child2 = mutation(child2, p_mutation)
        offspring.append(child1)
        if len(offspring) < offspring_size:
            offspring.append(child2)
    
    # 更新种群
    population = parents + offspring

# 输出最优解
best_index = max(range(pop_size), key=lambda i: fitnesses[i])
print("Best solution: x = {}, f(x) = {}".format(population[best_index][0], fitnesses[best_index]))

下面是使用模拟退火算法的步骤：

1. 初始化温度和初始解。将温度设置为一个较高的值，例如 1000，然后从区间 [-1, 2] 中随机生成一个初始解 x。

2. 生成新解。在当前解 x 的邻域内随机生成一个新解 x_new。

3. 计算能量差。计算新解 x_new 的适应度 f(x_new) 和当前解 x 的适应度 f(x)，并计算能量差 ΔE = f(x_new) - f(x)。

4. 判断是否接受新解。根据 Metropolis 准则，如果 ΔE < 0，则接受新解。否则，以概率 exp(-ΔE/T) 接受新解（其中 T 是当前温度）。

5. 降温。使用一定的降温策略降低温度 T。

6. 重复步骤 2-5，直到达到终止条件（例如达到最大迭代次数或找到满足条件的解）。

下面是 Python 代码实现：

# 定义初始解和温度
x = random.uniform(-1, 2)
T = 1000

# 模拟退火主循环
max_iter = 1000
min_T = 0.1
alpha = 0.99

for i in range(max_iter):
    # 生成新解
    x_new = x + random.uniform(-0.1, 0.1)
    
    # 计算能量差
    delta_E = fitness(x_new) - fitness(x)
    
    # 判断是否接受新解
    if delta_E < 0 or random.random() < math.exp(-delta_E / T):
        x = x_new
    
    # 降温
    T *= alpha
    if T < min_T:
        break

# 输出最优解
print("Best solution: x = {}, f(x) = {}".format(x, fitness(x)))

需要注意的是，遗传算法和模拟退火算法都不能保证找到全局最优解，只能找到局部最优解。因此，可以尝试多次运行算法，选择最优的解作为最终结果。