用python代码求解

好的，我将为您提供一个Python代码示例，用于实现复化梯形公式、复化Simpson公式和Romberg求积公式的数值积分计算。我们将针对您提供的四个积分进行计算，并比较不同的步长对结果的影响。

首先，我们需要导入一些必要的库：

import numpy as np

def trapezoidal_rule(f, a, b, n):
    h = (b - a) / n
    x = np.linspace(a, b, n+1)
    y = f(x)
    return h * (0.5 * y[0] + 0.5 * y[-1] + np.sum(y[1:-1]))

def simpsons_rule(f, a, b, n):
    if n % 2 != 0:
        raise ValueError("n must be even for Simpson's rule")
    h = (b - a) / n
    x = np.linspace(a, b, n+1)
    y = f(x)
    return h / 3 * (y[0] + y[-1] + 4 * np.sum(y[1:-1:2]) + 2 * np.sum(y[2:-1:2]))

def romberg_integration(f, a, b, tol=1e-6):
    def richardson_extrapolation(R, k, j):
        R[k][j] = (4**j * R[k-1][j-1] - R[k-1][j-2]) / (4**j - 1)
    
    R = [[0] * 10 for _ in range(10)]
    R[0][0] = trapezoidal_rule(f, a, b, 1)
    k = 1
    while True:
        R[k][0] = trapezoidal_rule(f, a, b, 2**k)
        for j in range(1, k+1):
            richardson_extrapolation(R, k, j)
        if abs(R[k][k] - R[k-1][k-1]) < tol:
            break
        k += 1
    return R[k][k]

# 定义被积函数
f1 = lambda x: 4 * np.sin(np.pi * x) / (np.pi * x)
f2 = lambda x: np.sin(x) / x
f3 = lambda x: np.exp(-x**2) / (1 + x**4)
f4 = lambda x: np.log(1 + x) / (1 + x)

# 积分区间
a1, b1 = 1/4, 2
a2, b2 = 1, 10
a3, b3 = 0, 1
a4, b4 = 0, 1

# 不同步长下的积分计算
n_values = [10, 20]
for n in n_values:
    print(f"Step size h = {n}")
    # 计算第一个积分
    I1_trapezoidal = trapezoidal_rule(f1, a1, b1, n)
    I1_simpson = simpsons_rule(f1, a1, b1, n)
    I1_romberg = romberg_integration(f1, a1, b1)
    print(f"I1 (Trapezoidal): {I1_trapezoidal:.7f}, (Simpson): {I1_simpson:.7f}, (Romberg): {I1_romberg:.7f}")

    # 计算第二个积分
    I2_trapezoidal = trapezoidal_rule(f2, a2, b2, n)
    I2_simpson = simpsons_rule(f2, a2, b2, n)
    I2_romberg = romberg_integration(f2, a2, b2)
    print(f"I2 (Trapezoidal): {I2_trapezoidal:.7f}, (Simpson): {I2_simpson:.7f}, (Romberg): {I2_romberg:.7f}")

    # 计算第三个积分
    I3_trapezoidal = trapezoidal_rule(f3, a3, b3, n)
    I3_simpson = simpsons_rule(f3, a3, b3, n)
    I3_romberg = romberg_integration(f3, a3, b3)
    print(f"I3 (Trapezoidal): {I3_trapezoidal:.7f}, (Simpson): {I3_simpson:.7f}, (Romberg): {I3_romberg:.7f}")

    # 计算第四个积分
    I4_trapezoidal = trapezoidal_rule(f4, a4, b4, n)
    I4_simpson = simpsons_rule(f4, a4, b4, n)
    I4_romberg = romberg_integration(f4, a4, b4)
    print(f"I4 (Trapezoidal): {I4_trapezoidal:.7f}, (Simpson): {I4_simpson:.7f}, (Romberg): {I4_romberg:.7f}\n")

### 说明
1. **复化梯形公式 (`trapezoidal_rule`)**：使用梯形法则进行数值积分。
2. **复化Simpson公式 (`simpsons_rule`)**：使用Simpson法则进行数值积分。
3. **Romberg求积公式 (`romberg_integration`)**：使用Richardson外推法进行数值积分。

### 运行结果
运行上述代码后，您将得到不同步长下每个积分的计算结果，并可以观察到不同方法之间的差异。

希望这个代码示例能帮助您理解和实现数值积分的不同方法。如果您有任何进一步的问题，请随时告诉我！