龙格积分python

龙格-库塔（Runge-Kutta）方法是一种常用的数值积分方法，用于求解常微分方程。它通过逐步逼近解函数的值，从而得到数值解。以下是两种使用Python实现龙格-库塔方法的例子：

1. 求解一阶常微分方程：

def runge_kutta(f, x0, y0, h, n):
    """
    使用龙格-库塔方法求解一阶常微分方程
    
    参数：
    f: 函数，表示微分方程的右侧函数
    x0: 初始自变量的值
    y0: 初始因变量的值
    h: 步长
    n: 迭代次数
    
    返回值：
    x: 自变量的数组
    y: 因变量的数组
    """
    x = [x0]
    y = [y0]
    for i in range(n):
        k1 = h * f(x[i], y[i])
        k2 = h * f(x[i] + h/2, y[i] + k1/2)
        k3 = h * f(x[i] + h/2, y[i] + k2/2)
        k4 = h * f(x[i] + h, y[i] + k3)
        x.append(x[i] + h)
        y.append(y[i] + (k1 + 2*k2 + 2*k3 + k4) / 6)
    return x, y

# 示例：求解微分方程 dy/dx = x^2 + y^2，初始条件为 x=0, y=1
def f(x, y):
    return x**2 + y**2

x, y = runge_kutta(f, 0, 1, 0.1, 10)
print("x:", x)
print("y:", y)

2. 求解二阶常微分方程组：

def runge_kutta_system(f, g, x0, y0, z0, h, n):
    """
    使用龙格-库塔方法求解二阶常微分方程组
    
    参数：
    f: 函数，表示第一个方程的右侧函数
    g: 函数，表示第二个方程的右侧函数
    x0: 初始自变量的值
    y0: 初始因变量1的值
    z0: 初始因变量2的值
    h: 步长
    n: 迭代次数
    
    返回值：
    x: 自变量的数组
    y: 因变量1的数组
    z: 因变量2的数组
    """
    x = [x0]
    y = [y0]
    z = [z0]
    for i in range(n):
        k1 = h * f(x[i], y[i], z[i])
        l1 = h * g(x[i], y[i], z[i])
        k2 = h * f(x[i] + h/2, y[i] + k1/2, z[i] + l1/2)
        l2 = h * g(x[i] + h/2, y[i] + k1/2, z[i] + l1/2)
        k3 = h * f(x[i] + h/2, y[i] + k2/2, z[i] + l2/2)
        l3 = h * g(x[i] + h/2, y[i] + k2/2, z[i] + l2/2)
        k4 = h * f(x[i] + h, y[i] + k3, z[i] + l3)
        l4 = h * g(x[i] + h, y[i] + k3, z[i] + l3)
        x.append(x[i] + h)
        y.append(y[i] + (k1 + 2*k2 + 2*k3 + k4) / 6)
        z.append(z[i] + (l1 + 2*l2 + 2*l3 + l4) / 6)
    return x, y, z

# 示例：求解微分方程组 d^2y/dx^2 + dy/dx + y = 0，初始条件为 x=0, y=1, dy/dx=0
def f(x, y, z):
    return -z - y

def g(x, y, z):
    return z

x, y, z = runge_kutta_system(f, g, 0, 1, 0, 0.1, 10)
print("x:", x)
print("y:", y)
print("z:", z)