RK4（四阶龙格-库塔）：公式逐项推导 + 12 组实测实验 + 深度学习/智能驾驶三大落地场景

一文吃透 RK4（四阶龙格-库塔）：公式逐项推导 + 12 组实测实验 + 深度学习/智能驾驶三大落地场景（附完整可运行代码）

导读：RK4 是数值积分的"默认武器"------从单摆仿真到 Neural ODE，从 MPC 轨迹预测到卡尔曼跟踪滤波，处处都是它。本文第 1 章把公式逐项拆开讲透 （四个斜率探针在干什么、权重为什么是 1:2:2:1、误差为什么是四阶），第 3~4 章讲透它在深度学习 （Neural ODE = 可微分 RK4、扩散模型采样器）与智能驾驶 （MPC 预测内核 / CTRV 跟踪预测 / IDM 交通仿真）的落地方式，第 5 章给出 12 组全部真实运行的实验结果（含 12 张标注初始点★与 RK4 终态▲的配图）：同样 6 步 RK4 比欧拉准 289 倍、单摆能量守恒到 0.0000%、CTRV 预测误差 3.2e-09 米、IDM 城市跟驰三段式收敛......

阅读收获：一套能默写的 RK4 公式与误差阶直觉 + 可直接复制运行的最小示例 ×3 + 一张"场景→方法"选型表 + 8 条实战避坑。

文中所有代码片段均可直接复制运行。

RK4 公式详解
- 1.1 问题设定：ODE 初值问题
- 1.2 基线：欧拉法（一阶）
- 1.3 RK4 公式（经典四阶龙格-库塔）
- 1.4 误差阶数：为什么叫"四阶"
- 1.5 可直接运行的最小示例
- 1.6 算法流程
应用场景总览
深度学习中的应用
- 3.1 核心思想：把"网络层"换成"连续动力系统"
- 3.2 深度学习生态中的 RK4 谱系
- 3.3 可直接运行的最小 Neural ODE 示例
- 3.4 为什么深度学习偏爱 RK4
智能驾驶场景中的应用
- 4.1 规划/MPC 内核：自行车模型
- 4.2 感知跟踪内核：CTRV 模型
- 4.3 仿真内核：IDM 跟驰模型
- 4.4 可直接运行的智驾示例
十二组实验与实测结果
完整实验脚本（逐行详细注释，可直接运行）
实战注意事项与避坑
参考文献

1. RK4 公式详解

1.1 问题设定：ODE 初值问题

一切数值积分的起点是常微分方程（ODE）的初值问题：

d y d t = f ( t , y ) , y ( t 0 ) = y 0 \frac{dy}{dt} = f(t, y), \qquad y(t_0) = y_0 dtdy=f(t,y),y(t0)=y0

符号说明 ： t t t 是自变量（通常是时间）； y y y 是状态（可以是标量、向量、矩阵、张量）； f f f 是"右端函数"，给出任意时刻任意状态下的变化率（斜率） ； y 0 y_0 y0 是初始条件（初始点）。

绝大多数实际问题的 f f f 太复杂，没有解析解 → 只能数值积分 ：把时间切成步长 h h h 的网格 t n = t 0 + n h t_n = t_0 + n h tn=t0+nh，从已知的初始点 y 0 y_0 y0 出发，一步一步把 y y y "推"向未来。所有积分方法的区别只在于：每步内怎样估计"这一步的平均斜率"。

1.2 基线：欧拉法（一阶）

y n + 1 = y n + h ⋅ f ( t n , y n ) y_{n+1} = y_n + h \cdot f(t_n, y_n) yn+1=yn+h⋅f(tn,yn)

只用起点一个斜率，并假设整个步长内斜率不变。只要 f f f 在步内变化，这个假设就错 → 局部截断误差 O ( h 2 ) O(h^2) O(h2)、全局误差 O ( h 1 ) O(h^1) O(h1)：步长减半误差只减半。

1.3 RK4 公式（经典四阶龙格-库塔）

k 1 = f ( t n , y n ) k_1 = f(t_n,\; y_n) k1=f(tn,yn)

k 2 = f ⁣ ( t n + h 2 , y n + h 2 k 1 ) k_2 = f\!\left(t_n + \tfrac{h}{2},\; y_n + \tfrac{h}{2} k_1\right) k2=f(tn+2h,yn+2hk1)

k 3 = f ⁣ ( t n + h 2 , y n + h 2 k 2 ) k_3 = f\!\left(t_n + \tfrac{h}{2},\; y_n + \tfrac{h}{2} k_2\right) k3=f(tn+2h,yn+2hk2)

k 4 = f ⁣ ( t n + h , y n + h k 3 ) k_4 = f\!\left(t_n + h,\; y_n + h\, k_3\right) k4=f(tn+h,yn+hk3)

y n + 1 = y n + h 6 ( k 1 + 2 k 2 + 2 k 3 + k 4 ) y_{n+1} = y_n + \frac{h}{6}\left(k_1 + 2k_2 + 2k_3 + k_4\right) yn+1=yn+6h(k1+2k2+2k3+k4)

逐项解释（四个斜率探针）：

斜率	在何处取值	作用
k 1 k_1 k1	步的起点 ( t n , y n ) (t_n, y_n) (tn,yn)	与欧拉法相同的信息；最不可靠（步内斜率会变）
k 2 k_2 k2	中点：先用 k 1 k_1 k1 走半步到试验点，在该点取斜率	第一次修正"斜率不变"的错误假设
k 3 k_3 k3	中点：改用更准的 k 2 k_2 k2 再走半步，重新取中点斜率	自我校正：用修正后的信息再修正一次
k 4 k_4 k4	终点：用 k 3 k_3 k3 走满一步到终点，取终点斜率	捕捉步长末端的斜率变化趋势
加权平均	( k 1 + 2 k 2 + 2 k 3 + k 4 ) / 6 (k_1 + 2k_2 + 2k_3 + k_4)/6 (k1+2k2+2k3+k4)/6	中点信息更可靠 → 权重翻倍（1:2:2:1 即 Simpson 积分权重）

几何直觉：

复制代码

 y
 │            ⌒ 真实解曲线
 │          /   ↖ k4: 用k3走到终点取斜率
 │        /  •───↖ k3: 用k2修正后再探中点
 │      / •──────↖ k2: 用k1探中点
 │    •──────────↖ k1: 起点斜率(=欧拉)
 │  y_n
 └──┬────┬────┬──→ t
   t_n  t+h/2  t+h
   四次"斜率侦察"的加权平均 ≈ 这一步的真实平均斜率

为什么权重是 1:2:2:1 ：把一步内的平均斜率看作对斜率函数在 $t n , t n + 1$ $t_n, t_{n+1}$ $tn,tn+1$ 上的积分，Simpson 公式 ∫ a b g ≈ b − a 6 $g ( a ) + 4 g ( a + b 2 ) + g ( b )$ \int_a^b g \approx \frac{b-a}{6} $g(a) + 4g(\\frac{a+b}{2}) + g(b)$ ∫abg≈6b−a $g(a)+4g(2a+b)+g(b)$ 中点权重为 4；RK4 用两个中点探针 k 2 , k 3 k_2, k_3 k2,k3 分摊这个 4（各得 2）→ 权重 (1,2,2,1)/6。这正是它能精确积分到四阶项的原因。

1.4 误差阶数：为什么叫"四阶"

局部截断误差 O ( h 5 ) O(h^5) O(h5)：单步内，RK4 的增量与真解的泰勒展开逐项匹配到 h 4 h^4 h4 项 ，第一个不匹配的项是 h 5 h^5 h5 量级；
全局误差 O ( h 4 ) O(h^4) O(h4)：共 N = T / h N = T/h N=T/h 步，误差累积 N ⋅ O ( h 5 ) = O ( h 4 ) N \cdot O(h^5) = O(h^4) N⋅O(h5)=O(h4)；
工程直觉 ：步长减半 → 全局误差变为 1 / 2 4 = 1 / 16 1/2^4 = 1/16 1/24=1/16（本文实验 5 实测 log-log 斜率 4.04，理论 4）；
性价比 ：每步 4 次 f f f 求值看似贵，但达到同一精度所需步长远少于欧拉 → 总计算量反而更少（实验 1：同样 6 步，RK4 误差比欧拉小 289 倍）。

方法	每步 f 求值	全局误差阶	步长减半误差变化
欧拉	1	O ( h 1 ) O(h^1) O(h1)	×1/2
中点法（RK2）	2	O ( h 2 ) O(h^2) O(h2)	×1/4
RK4	4	O ( h 4 ) O(h^4) O(h4)	×1/16

1.5 可直接运行的最小示例

python 复制代码

import numpy as np                       # 只依赖 numpy，复制即可运行

def f(t, y):
    """右端函数: dy/dt = -y (指数衰减)，解析解 y(t)=e^{-t} 用于验收"""
    return -y

def rk4_step(f, t, y, h):
    """RK4 单步: 从 (t, y) 前进 h。四个斜率探针 + Simpson 加权"""
    k1 = f(t, y)                 # 探针1: 起点斜率
    k2 = f(t + h/2, y + h/2*k1)  # 探针2: 用k1走半步, 取中点斜率
    k3 = f(t + h/2, y + h/2*k2)  # 探针3: 用k2再走半步, 校正中点斜率
    k4 = f(t + h,   y + h*k3)    # 探针4: 用k3走满步, 取终点斜率
    return y + h/6*(k1 + 2*k2 + 2*k3 + k4)   # 加权平均(中点权重×2)

y, t, h = 1.0, 0.0, 0.1          # 初始点 y(0)=1; 步长 0.1
for _ in range(10):              # 积分到 t=1.0 (共10步)
    y = rk4_step(f, t, y, h)
    t += h                       # 用累加演示; 长积分建议 t = t0 + n*h 防浮点累积

err = abs(y - np.exp(-1.0))      # 与解析解对比
print(f"RK4: y(1) = {y:.12f} | 解析 = {np.exp(-1.0):.12f} | 误差 = {err:.2e}")
assert err < 1e-8                # 验收: 10步就达到1e-9级精度(欧拉同步骤约1e-2)

1.6 算法流程

复制代码

输入: f, t0, y0, 步长h, 步数N
y ← y0;  t ← t0
for n = 1..N:
    k1 ← f(t, y)
    k2 ← f(t+h/2, y+(h/2)k1)
    k3 ← f(t+h/2, y+(h/2)k2)
    k4 ← f(t+h,   y+h·k3)
    y  ← y + (h/6)(k1+2k2+2k3+k4)
    t  ← t0 + n·h
输出: 轨迹 [(t_n, y_n)]

1.7 向量状态与额外参数：RK4 的"类型无感"

RK4 公式只用到"状态的加法与数乘"，因此对状态类型与额外参数完全无感：

标量 → 向量（耦合多变量系统） ： y ∈ R n y \in \mathbb{R}^n y∈Rn、 f f f 返回同维向量时， k 1 . . k 4 k_1..k_4 k1..k4 均为向量、加权平均逐分量成立 → Lorenz 三变量耦合、全路网车辆状态、甚至矩阵状态（EKF 的协方差矩阵 P P P 的预测步本身就是矩阵 ODE）都可直接积分（实验 12）；
额外参数 θ ：右端函数签名 f ( t , y , h e t a ) f(t, y, heta) f(t,y,heta)，而积分器只认 ( t , y ) (t, y) (t,y) → 用闭包/functools.partial/可调用类把 θ 固定掉：

python 复制代码

import functools, numpy as np

def f_raw(t, z, m, c, k):            # 带额外参数 m,c,k 的右端函数
    x, v = z
    return np.array([v, -(c*v + k*x)/m])

f1 = lambda t, z: f_raw(t, z, 1.0, 0.63, 10.0)              # 方式1: lambda 闭包
f2 = functools.partial(f_raw, m=1.0, c=0.63, k=10.0)        # 方式2: partial(推荐)

class F:                                                     # 方式3: 可调用类
    def __init__(self, m, c, k): self.m, self.c, self.k = m, c, k
    def __call__(self, t, z): return f_raw(t, z, self.m, self.c, self.k)
f3 = F(1.0, 0.63, 10.0)
# 三者签名均为 (t, z) → 可原样喂给任何 (f,t,y,h) 签名的 RK4 积分器

参数扫描 ：循环内换参数重新 partial 即可（实验 10 用同一积分器跑 ζ=0.2/1.0/2.0 三工况）。

1.8 高阶 ODE：状态增广（伴随形式）

n 阶显式 ODE y ( n ) = g ( t , y , y ′ , ... , y ( n − 1 ) ) y^{(n)} = g(t, y, y', \dots, y^{(n-1)}) y(n)=g(t,y,y′,...,y(n−1)) 引入状态向量 z = ( y , y ′ , ... , y ( n − 1 ) ) ∈ R n z = (y, y', \dots, y^{(n-1)}) \in \mathbb{R}^n z=(y,y′,...,y(n−1))∈Rn，等价化为 n 个一阶方程（伴随形式 / companion form）：

z 1 ′ = z 2 , z 2 ′ = z 3 , ... , z n − 1 ′ = z n , z n ′ = g ( t , z 1 , ... , z n ) z_1' = z_2, \quad z_2' = z_3, \quad \dots, \quad z_{n-1}' = z_n, \quad z_n' = g(t, z_1, \dots, z_n) z1′=z2,z2′=z3,...,zn−1′=zn,zn′=g(t,z1,...,zn)

前 n−1 个方程是导数的"定义式"，只有最后一个携带物理信息。RK4 无需任何修改 ：增广后就是一阶向量系统（1.7 节机制原样适用），误差阶仍为全局 O ( h 4 ) O(h^4) O(h4)。

阶数	典型应用场景	增广状态
2 阶	弹簧-质量-阻尼、单摆、RLC 电路、轨道力学 $\ddot{r}=-\mu r/\lvert r
vert^3$	$x , x ˙$ $x, \\dot{x}$ $x,x˙$
3 阶	智驾 jerk 限制速度规划（S 曲线）、含执行器动态的系统	$s , v , a$ $s, v, a$ $s,v,a$
n 阶	梁振动模态、高阶被控对象	$y , ... , y ( n - 1 )$ $y, \\dots, y\^{(n-1)}$ $y,...,y(n-1)$

两个易错点 ：① 初始条件必须给全 y ( t 0 ) , y ′ ( t 0 ) , ... , y ( n − 1 ) ( t 0 ) y(t_0), y'(t_0), \dots, y^{(n-1)}(t_0) y(t0),y′(t0),...,y(n−1)(t0) 组成 z 0 z_0 z0，少给一个就是另一个问题；② 状态顺序必须与伴随形式一致（把 $v , x$ $v, x$ $v,x$ 当 $x , v$ $x, v$ $x,v$ 用 = 解了另一个方程）。

可直接运行的二阶增广示例（含解析解验收）：

python 复制代码

import numpy as np, math
m, c, k = 1.0, 0.632, 10.0                  # ζ = c/(2√(km)) ≈ 0.1 → 欠阻尼
def f(t, z):                                # 增广后 z=[x, v], 二阶→两个一阶
    x, v = z
    return np.array([v, -(c*v + k*x)/m])    # 第二行 = 原方程解出 x''
def rk4_step(f, t, y, h):
    k1=f(t,y); k2=f(t+h/2,y+h/2*k1); k3=f(t+h/2,y+h/2*k2); k4=f(t+h,y+h*k3)
    return y + h/6*(k1+2*k2+2*k3+k4)
z, t, h = np.array([1.0, 0.0]), 0.0, 0.01   # ★ 初始条件给全: x0=1, v0=0
for _ in range(1000):
    z = rk4_step(f, t, z, h); t += h
w = math.sqrt(k/m); zeta = c/(2*math.sqrt(k*m)); wd = w*math.sqrt(1-zeta**2)
x_exact = math.exp(-zeta*w*t)*(math.cos(wd*t) + zeta*w/wd*math.sin(wd*t))
print(f"RK4 x(10)={z[0]:.8f} | 解析={x_exact:.8f} | 误差={abs(z[0]-x_exact):.2e}")

2. 应用场景总览

领域	典型场景	本文实验
数学/物理仿真	轨道力学、单摆/多体、电路瞬态、化学动力学	实验 1~5
生态学/流行病	Lotka-Volterra、SIR 模型	实验 4
深度学习	Neural ODE、扩散模型采样器、可微物理仿真、PINN	实验 6
智能驾驶-规划	MPC/轨迹规划的预测内核（自行车/动力学模型前推）	实验 7
智能驾驶-感知	目标跟踪滤波（EKF/UKF）的非线性预测步（CTRV/CTRA）	实验 8
智能驾驶-仿真	微观交通流（IDM/MOBIL 跟驰换道）、仿真引擎时间步进	实验 9
高阶 ODE（2/3 阶）	弹簧-质量-阻尼、单摆、jerk 限制速度规划（S 曲线）	实验 10~11
耦合多变量非线性系统	Lorenz 混沌、多体动力学、反应网络	实验 12

RK4 成为"默认选择"的三个原因：显式（无需求解方程/迭代）、自启动 （单步法，不需历史点）、对状态类型无感 （ y y y 是向量/矩阵/张量都照样积分------这是它能进入深度学习计算图的前提）。

3. 深度学习中的应用

3.1 核心思想：把"网络层"换成"连续动力系统"

ResNet 视角 ：残差块 h l + 1 = h l + f l ( h l ) h_{l+1} = h_l + f_l(h_l) hl+1=hl+fl(hl) 恰好是 ODE 的一步欧拉离散（步长=1）。

Neural ODE（Chen et al., NeurIPS 2018）：把离散层堆叠连续化：

d h ( t ) d t = f θ ( h ( t ) , t ) , h ( t 1 ) = h ( t 0 ) + ∫ t 0 t 1 f θ ( h , t ) d t \frac{dh(t)}{dt} = f_\theta\big(h(t), t\big), \qquad h(t_1) = h(t_0) + \int_{t_0}^{t_1} f_\theta(h, t)\,dt dtdh(t)=fθ(h(t),t),h(t1)=h(t0)+∫t0t1fθ(h,t)dt

前向传播 = 用数值积分器（RK4 或自适应 RK45）从 t 0 t_0 t0 积到 t 1 t_1 t1；反向传播 = autograd 直接穿透整个 RK4 计算图（RK4 每步都是可微张量运算），或用伴随法（adjoint）以 O(1) 内存求梯度。深度、步长、精度从此成为可调超参数而非固定架构。

3.2 深度学习生态中的 RK4 谱系

技术	与 RK 家族的关系
ResNet / 残差网络	一步欧拉法的固定步长离散
Neural ODE / 连续规范化流	RK4 / 自适应 RK45 积分 + 可微训练
扩散模型采样器	概率流 ODE 的积分器：DDIM≈欧拉、Heun=RK2、DPM-Solver（高阶线性多步）
可微物理仿真（机器人/智驾）	RK4 嵌入训练回路做时间推进（梯度穿透仿真器）
PINN / 物理信息神经网络	时间维推进或配点残差常用 RK 离散

3.3 可直接运行的最小 Neural ODE 示例

python 复制代码

import torch, torch.nn as nn, numpy as np      # 依赖: torch，复制即可运行
torch.manual_seed(0)

# ---- 观测数据: 真实系统 dz/dt = A z (螺旋收敛), 取25个时刻的点 ----
A = torch.tensor([[-0.1, 1.0], [-1.0, -0.1]])   # 旋转+收缩 → 螺旋
z0 = torch.tensor([2.0, 0.0])                   # ★ 初始点
ts = torch.linspace(0, 6, 25)
with torch.no_grad():                            # 解析解 z(t)=expm(A t) z0
    data = torch.stack([torch.linalg.matrix_exp(A*t) @ z0 for t in ts])

# ---- 待学习向量场 f_θ (小MLP) 与 RK4 积分器(可微!) ----
f_theta = nn.Sequential(nn.Linear(2, 32), nn.Tanh(), nn.Linear(32, 2))

def rk4_rollout(f, z0, n_steps=60, T=6.0):
    """从 z0 用 RK4 积分 n_steps 步到 T, 返回整条轨迹 (可微)"""
    h = T / n_steps
    z, traj = z0, [z0]
    for _ in range(n_steps):
        k1 = f(z); k2 = f(z + h/2*k1)
        k3 = f(z + h/2*k2); k4 = f(z + h*k3)
        z = z + h/6*(k1 + 2*k2 + 2*k3 + k4)      # RK4 更新
        traj.append(z)
    return torch.stack(traj)

opt = torch.optim.Adam(f_theta.parameters(), lr=8e-3)
idx = np.linspace(0, 60, 25).round().astype(int)  # 观测点在RK4网格上的索引
for it in range(401):
    opt.zero_grad()
    traj = rk4_rollout(f_theta, z0)               # 前向 = RK4 积分
    loss = ((traj[idx] - data)**2).sum(1).mean()  # 观测点 MSE
    loss.backward()                               # 梯度穿透全部60个RK4步
    opt.step()
    if it % 100 == 0:
        print(f"iter {it}: loss = {loss.item():.5f}")

with torch.no_grad():
    dev = (rk4_rollout(f_theta, z0)[idx] - data).abs().max().item()
print(f"训练完成: 初始点{tuple(z0.tolist())} → RK4积分 → 最大偏差 {dev:.3f}")

3.4 为什么深度学习偏爱 RK4 而不是更高阶方法

RK4 是"精度/可微性/实现复杂度"的平衡点：更高阶（RK8）或自适应步长会增加计算图分支（步数随状态变化 → 批处理困难）；而 RK4 固定步数、全张量运算，对 GPU 与 autograd 最友好。

4. 智能驾驶场景中的应用

4.1 规划/MPC 内核：车辆运动学自行车模型

状态 s = $x , y , ψ , v$ s = $x, y, \\psi, v$ s= $x,y,ψ,v$ （位置、航向、车速），控制输入 u = $a , δ$ u = $a, \\delta$ u= $a,δ$ （加速度、前轮转角），轴距 L L L：

x ˙ = v cos ⁡ ψ , y ˙ = v sin ⁡ ψ , ψ ˙ = v tan ⁡ δ L , v ˙ = a \dot{x} = v\cos\psi, \quad \dot{y} = v\sin\psi, \quad \dot{\psi} = \frac{v\tan\delta}{L}, \quad \dot{v} = a x˙=vcosψ,y˙=vsinψ,ψ˙=Lvtanδ,v˙=a

MPC 每个控制周期（如 10~50 ms）都要把该模型沿候选控制序列前推整个预测时域（如 3~5 s）：积分器精度直接决定规划轨迹的可信度（实验 7 实测：粗欧拉 h=0.1 在 12 s 内漂移 0.41 m------对车道级规划不可接受）。

4.2 感知跟踪内核：CTRV 运动模型（卡尔曼滤波预测步）

状态 s = $p x , p y , v , φ , ω$ s = $p_x, p_y, v, \\varphi, \\omega$ s= $px,py,v,φ,ω$ （位置、速度、航向、转率），"匀转率匀速"假设：

p ˙ x = v cos ⁡ φ , p ˙ y = v sin ⁡ φ , v ˙ = 0 , φ ˙ = ω , ω ˙ = 0 \dot{p}_x = v\cos\varphi, \quad \dot{p}_y = v\sin\varphi, \quad \dot{v} = 0, \quad \dot{\varphi} = \omega, \quad \dot{\omega} = 0 p˙x=vcosφ,p˙y=vsinφ,v˙=0,φ˙=ω,ω˙=0

EKF/UKF 的预测步需要把目标状态前推一个滤波周期；该模型有圆弧解析解可作真值（实验 8 实测：RK4 h=0.1 误差 3.2e-09 m，欧拉同步骤 0.57 m------跟踪门限通常只有几米，但误差累积会污染协方差估计）。

4.3 仿真内核：IDM 智能驾驶员跟驰模型

SUMO/CARLA 交通流的标准跟驰模型，纯 ODE（自车速度 v v v、车距 g g g、速差 Δ v = v − v l e a d \Delta v = v - v_{lead} Δv=v−vlead）：

d v d t = a $1 - ( v v 0 ) δ - ( s * ( v , Δ v ) g ) 2$ \frac{dv}{dt} = a\left $1 - \\left(\\frac{v}{v_0}\\right)\^{\\delta} - \\left(\\frac{s\^\*(v, \\Delta v)}{g}\\right)\^{2}\\right$ dtdv=a $1-(v0v)δ-(gs*(v,Δv))2$

s ∗ = s 0 + max ⁡ ⁣ ( 0 , v T + v Δ v 2 a b ) s^* = s_0 + \max\!\left(0,\; v T + \frac{v\,\Delta v}{2\sqrt{a b}}\right) s∗=s0+max(0,vT+2ab vΔv)

符号说明 ： v 0 v_0 v0 期望车速、 a a a 最大加速度、 b b b 舒适减速度、 s 0 s_0 s0 最小车距、 T T T 安全时距、 δ \delta δ（≈4）自由流指数； s ∗ s^* s∗ 为"期望安全车距"。三项分别对应：自由流加速、接近前车减速、紧急逼近强制动。仿真引擎以 RK4 对全路网车辆的耦合 ODE 系统做时间步进（实验 9）。

4.4 可直接运行的智驾示例：自行车模型 5 秒轨迹前推

python 复制代码

import numpy as np, math      # 只依赖 numpy，复制即可运行

L = 2.8                       # 轴距(m)
def steer(t):  return 0.1 * math.sin(2*math.pi*t/8)   # 前轮转角输入(rad)
def accel(t):  return 0.5 if t < 2 else 0.0           # 加速度输入(m/s²)

def f_bicycle(t, s):
    """状态 s=[x, y, ψ, v] 的导数 (运动学自行车模型)"""
    x, y, psi, v = s
    return np.array([v*math.cos(psi),          # ẋ
                     v*math.sin(psi),          # ẏ
                     v*math.tan(steer(t))/L,   # ψ̇ (横摆角速度)
                     accel(t)])                # v̇

def rk4_step(f, t, y, h):
    k1 = f(t, y); k2 = f(t+h/2, y+h/2*k1)
    k3 = f(t+h/2, y+h/2*k2); k4 = f(t+h, y+h*k3)
    return y + h/6*(k1 + 2*k2 + 2*k3 + k4)

s = np.array([0.0, 0.0, 0.0, 5.0])   # ★ 初始点: 原点, 朝东(ψ=0), 5 m/s
t, h = 0.0, 0.01                     # 积分步长 10ms (典型控制周期内细分)
for _ in range(500):                 # 前推 5 秒
    s = rk4_step(f_bicycle, t, s, h)
    t += h
print(f"RK4终态(t=5s): x={s[0]:.2f} m, y={s[1]:.2f} m, "
      f"航向={math.degrees(s[2]):.1f}°, 车速={s[3]:.2f} m/s")
# 预期输出: x≈27.3 m, y≈2.0 m, 航向≈8.6°, 车速=6.0 m/s

5. 十二组实验与实测结果

全部实验已在 RTX 5070 Ti Laptop（PyTorch 2.14 / numpy 2.5）实际运行；每张图统一标注**初始点（红星★）**与 RK4 处理后的终态（绿三角▲）。

#	场景	初始点 → RK4 终态	关键实测数字	图
1	指数衰减 dy/dt=−y	(0, 1) → y(3)=0.0499	同 6 步：RK4 误差 1.2e-04 vs 欧拉 3.4e-02（小 289 倍）	`figures/rk4_decay.png`
2	Logistic 种群增长	y(0)=0.5 → 9.99	t=8：RK4 误差 4.2e-05 vs 欧拉 9.4e-03	`figures/rk4_logistic.png`
3	单摆（二阶→一阶系统）	(θ=2.5, ω=0) → (2.35, −1.40)	20s 能量漂移：欧拉 +99.4% vs RK4 0.0000%	`figures/rk4_pendulum.png`
4	Lotka-Volterra 捕食模型	(猎物10, 捕食者10) → 闭合轨道	轨道闭合度：RK4 每圈重过初始点(残差 8.8e-02)，欧拉螺旋发散	`figures/rk4_lotka.png`
5	收敛阶数实测	---	log-log 斜率：欧拉 1.02 / RK4 4.04（理论 1 / 4）	`figures/rk4_convergence.png`
6	Neural ODE（深度学习）	z0=(2,0) → 螺旋收敛终态	autograd 穿透 60 步 RK4 训练，观测点最大偏差 0.10	`figures/rk4_neural_ode.png`
7	智驾·自行车模型轨迹预测	(0,0,ψ=0,5m/s) → (74.0m, 22.4m, 37.6°, 7m/s)	粗欧拉(h=0.1)12s 漂移 0.41 m	`figures/rk4_bicycle.png`
8	智驾·CTRV 跟踪预测	(0,0,8m/s,φ=0,ω=0.2) → (40.0m, 41.2m)	RK4 最大误差 3.2e-09 m vs 欧拉 0.57 m	`figures/rk4_ctrv.png`
9	智驾·IDM 城市跟驰	自车 20m/s、车距 40m → v=12.0m/s、车距 20.3m（平衡 20.0m）	紧急制动最小车距 13.0m（>s0=2m，安全）；三段式收敛	`figures/rk4_idm.png`
10	二阶 ODE 状态增广 + 多参数传递（弹簧-质量-阻尼）	(x=1, v=0) → 欠/临界/过阻尼三终态	ζ=0.2 时 RK4 vs 解析解最大误差 1.5e-08 m ；`functools.partial` 传参	`figures/rk4_second_order.png`
11	三阶 ODE：jerk 限制 S 曲线（智驾速度规划）	(s,v,a)=(0,0,0) → (48.0m, 0, 0) 精确回静止	直接积分跨跳变退化 1 阶（误差比 2.0）；分段+冻结右端后精确到 5e-13	`figures/rk4_third_order.png`
12	耦合多变量：Lorenz 混沌系统	(1,1,1) → 吸引子 (-4.3,-2.6,24.9)	1e-5 初差 → 21.6s 后轨迹距离 >1（蝴蝶效应）	`figures/rk4_lorenz.png`

图形阅读指南：

rk4_decay/logistic：黑线解析解、蓝线 RK4、红虚线欧拉；红星=初始点，绿三角=RK4 终态；
rk4_pendulum：左相图（θ-ω 平面）欧拉螺旋发散 vs RK4 闭合；右能量漂移曲线；
rk4_lotka：左相平面闭合轨道；右猎物/捕食者周期振荡时间序列；
rk4_convergence：log-log 误差-步长曲线，斜率即收敛阶（附 h¹/h⁴ 参考线）；
rk4_neural_ode：左相平面=观测数据点+学习轨迹+学到的向量场 quiver，红星初始点、绿三角终态；右训练损失曲线；
rk4_bicycle：左蛇形机动轨迹+航向箭头；右欧拉偏差累积曲线；
rk4_ctrv：左圆弧轨迹与预测点；右误差累积（log 轴）；
rk4_idm：速度收敛 / 车距三段式（收敛→制动下探→恢复平衡，标注最小车距点）/ 道路位置。
rk4_second_order：左三种阻尼比位移曲线（含解析解点线、各终态▲）；右相平面 (x, x') 螺旋收敛；
rk4_third_order：s/v/a/j 四联时间序列（S 曲线特征：加速度连续无折角），标注初始点★与终态▲；
rk4_lorenz：左吸引子 x-z 投影（颜色=时间）；右混沌发散曲线（1e-5 初差指数放大）。

6. 完整实验脚本（逐行详细注释，可直接运行）

以下为 rk4_experiments.py 全文：12 组实验 + 12 张配图，每行关键代码均有注释。

依赖：numpy、matplotlib、torch（实验 6 使用）。保存后直接 python rk4_experiments.py 运行，图形输出到 figures/rk4_*.png。

python 复制代码

# -*- coding: utf-8 -*-
"""
RK4（四阶龙格-库塔法）原理与多场景应用实验
==========================================

--------------------------------------------------------------------------
背景知识：RK4 是什么
--------------------------------------------------------------------------
RK4 求解常微分方程（ODE）初值问题：

    dy/dt = f(t, y),   y(t0) = y0

从 t_n 走一步 h 到 t_{n+1} 的更新公式（四个斜率的加权平均）：

    k1 = f(t_n,        y_n)                 ← 起点斜率
    k2 = f(t_n + h/2,  y_n + h·k1/2)        ← 用k1预估中点，取中点斜率
    k3 = f(t_n + h/2,  y_n + h·k2/2)        ← 用k2再预估中点，取中点斜率
    k4 = f(t_n + h,    y_n + h·k3)          ← 用k3预估终点，取终点斜率
    y_{n+1} = y_n + h/6·(k1 + 2k2 + 2k3 + k4)   ← 加权平均(中点权重×2)

直觉：欧拉法只用起点斜率（一阶，误差 O(h²)/步）；RK4 采样 4 个斜率，
恰好在泰勒展开意义上匹配到 h⁴ 项 → 局部误差 O(h⁵)，全局误差 O(h⁴)。
"步长减半，误差变 1/16"（实验 5 用 log-log 斜率实测验证）。

为什么是工程默认选择：
  * 精度/成本比极高：每步只需 4 次 f 求值，无需求导（牛顿法类不用）；
  * 显式方法，实现 10 行代码；步长固定时无需迭代求解；
  * 对 y 是向量/矩阵/张量一视同仁 → 可直接用 PyTorch 张量实现，
    让整个积分过程可微（autograd 穿透 RK4）→ 这是 Neural ODE 的基石。

--------------------------------------------------------------------------
应用场景总览（本脚本逐一实验）
--------------------------------------------------------------------------
  [经典物理/数学]
  实验1  指数衰减 ODE          ------ RK4 vs 欧拉 vs 解析解（精度直观对比）
  实验2  Logistic 种群增长     ------ 非线性 ODE 的求解
  实验3  单摆（二阶ODE→一阶系统）------ 相图 + 能量守恒（欧拉发散/RK4守恒）
  实验4  Lotka-Volterra 捕食模型 ------ 生态学的闭合相轨道
  实验5  收敛阶数实测           ------ log-log 误差曲线斜率 = 4 的验证

  [深度学习]
  实验6  Neural ODE（神经常微分方程, Chen et al. 2018）：
         把"网络层"换成"连续动力系统 dh/dt = f_θ(h)"，用 RK4 积分前向，
         autograd 反向传播训练 f_θ ------ 可微分 ODE 求解器 = 深度学习模型。
         相关谱系：ResNet 的残差块 h_{t+1}=h_t+f(h_t) 正是"一步欧拉法"，
         Neural ODE 把它连续化并用 RK4 精确积分；扩散模型的采样器
         （Heun=RK2、DPM-Solver）本质也是 ODE 数值积分。

  [智能驾驶]
  实验7  车辆运动学自行车模型轨迹预测 ------ 规划/MPC 的预测内核：
         状态 (x, y, ψ, v)，输入 (加速度 a, 前轮转角 δ)，RK4 推演未来轨迹
  实验8  CTRV 匀转率运动模型 ------ 目标跟踪卡尔曼滤波的非线性预测步：
         状态 (px, py, v, φ, ω)，对比解析解验证精度
  实验9  IDM 智能驾驶员跟驰模型 ------ 微观交通仿真（SUMO/ CARLA 交通流内核）：
         dv/dt = f(车速, 车距, 速差)，仿真跟车收敛与紧急制动场景

运行环境：conda env `dl`（Python 3.12 + PyTorch 2.14 + numpy + matplotlib）
运行方式：python rk4_experiments.py
所有图形保存至 figures/rk4_*.png，每张图标注【初始点】与【RK4 终态】。
"""

import math
import time
import numpy as np
import matplotlib
matplotlib.use("Agg")                            # 无界面后端，直接存文件
import matplotlib.pyplot as plt
import torch
import torch.nn as nn

# 中文字体与负号显示（Windows 自带微软雅黑）
plt.rcParams["font.sans-serif"] = ["Microsoft YaHei"]
plt.rcParams["axes.unicode_minus"] = False

np.random.seed(42)
torch.manual_seed(42)

print(f"numpy {np.__version__} | torch {torch.__version__}")
print("=" * 70)

# ======================================================================
# 通用工具：欧拉法 / RK4 / 积分循环
# ----------------------------------------------------------------------
# 两个方法签名完全一致 (f, t, y, h) → y_next，可以直接互换传入积分器，
# 这体现了数值积分方法的"插件式"设计------换方法不改调用代码。
# ======================================================================

def euler_step(f, t, y, h):
    """显式欧拉：只用起点斜率，一阶精度 O(h)"""
    return y + h * f(t, y)

def rk4_step(f, t, y, h):
    """经典四阶龙格-库塔：4 次求值，加权平均 (1:2:2:1)/6，四阶精度 O(h⁴)"""
    k1 = f(t, y)                       # 起点斜率
    k2 = f(t + h / 2, y + h * k1 / 2)  # 中点斜率(用k1预估)
    k3 = f(t + h / 2, y + h * k2 / 2)  # 中点斜率(用k2再预估,更准)
    k4 = f(t + h, y + h * k3)          # 终点斜率(用k3预估)
    return y + h / 6 * (k1 + 2 * k2 + 2 * k3 + k4)

def integrate(method, f, t0, y0, T, h):
    """从 (t0, y0) 积分到 t0+T，返回时间序列与状态轨迹。
    y 是 numpy 数组 → method 对任意维系统通用（标量/二维/四维/五维）"""
    n = int(round(T / h))
    ts = np.empty(n + 1); ys = np.empty((n + 1,) + y0.shape)
    t, y = t0, y0.copy()
    ts[0], ys[0] = t, y
    for i in range(n):
        y = method(f, t, y, h)
        t = t0 + (i + 1) * h           # 用 t0+i·h 而非累加，避免浮点误差累积
        ts[i + 1], ys[i + 1] = t, y.copy()
    return ts, ys

def annotate_initial_final(ax, traj, label_init="初始点", label_final="RK4终态", fmt="{:.2f}"):
    """在图上标注初始点(红星)与 RK4 处理后的终态(绿方块)------所有场景统一风格"""
    ax.plot(*traj[0][:2], "r*", ms=14, zorder=5, label=label_init)
    ax.plot(*traj[-1][:2], "g^", ms=11, zorder=5, label=label_final)

# ======================================================================
# 实验 1：指数衰减 ------ dy/dt = -y, y(0)=1（解析解 y = e^(-t)）
# ----------------------------------------------------------------------
# 最简单的线性 ODE，有精确解析解 → 可以量化每种方法的误差。
# 故意用很大的步长 h=0.5 让差异肉眼可见：
#   欧拉在粗步长下明显"跑偏"，RK4 几乎贴着解析解走。
# ======================================================================
print("\n【实验 1】指数衰减 ODE：dy/dt = -y（RK4 vs 欧拉 vs 解析解）")
print("-" * 70)

f_decay = lambda t, y: -y                          # 右端项 f(t,y) = -y
y0 = np.array([1.0])                               # 初始条件 y(0) = 1
T, h_big = 3.0, 0.5                                # 积分区间 [0,3]，粗步长0.5

ts_e, ys_e = integrate(euler_step, f_decay, 0, y0, T, h_big)
ts_r, ys_r = integrate(rk4_step,  f_decay, 0, y0, T, h_big)
ts_f = np.linspace(0, T, 300)                      # 解析解参考曲线(密集采样)
y_exact = np.exp(-ts_f)

err_e = abs(ys_e[-1, 0] - math.exp(-T))
err_r = abs(ys_r[-1, 0] - math.exp(-T))
print(f"初始点: t=0, y=1.0")
print(f"t=3 解析解: {math.exp(-T):.6f}")
print(f"欧拉 (h=0.5): y(3) = {ys_e[-1,0]:.6f}  误差 = {err_e:.2e}")
print(f"RK4  (h=0.5): y(3) = {ys_r[-1,0]:.6f}  误差 = {err_r:.2e}")
print(f"RK4 误差比欧拉小 {err_e/err_r:.0f} 倍（同样只走了 {int(T/h_big)} 步）")

fig, ax = plt.subplots(figsize=(7.5, 5))
ax.plot(ts_f, y_exact, "k-", lw=2, label="解析解 $y=e^{-t}$")
ax.plot(ts_e, ys_e[:, 0], "o--", color="#d62728", lw=1.5, label=f"欧拉 h={h_big} (误差{err_e:.1e})")
ax.plot(ts_r, ys_r[:, 0], "s-", color="#1f77b4", lw=1.5, label=f"RK4 h={h_big} (误差{err_r:.1e})")
ax.plot(0, 1.0, "r*", ms=16, zorder=5, label="初始点 (0, 1)")
ax.plot(T, ys_r[-1, 0], "g^", ms=12, zorder=5,
        label=f"RK4终态 y(3)={ys_r[-1,0]:.4f}")
ax.annotate(f"解析 $e^{{-3}}$={math.exp(-T):.4f}", (T, math.exp(-T)),
            xytext=(T - 1.5, math.exp(-T) + 0.12), arrowprops=dict(arrowstyle="->"), fontsize=9)
ax.set_xlabel("t"); ax.set_ylabel("y(t)"); ax.grid(alpha=0.3); ax.legend(fontsize=9)
ax.set_title("实验1 指数衰减：粗步长(h=0.5)下 欧拉 vs RK4 vs 解析解")
fig.tight_layout(); fig.savefig("figures/rk4_decay.png", dpi=150); plt.close(fig)
print("图已保存: figures/rk4_decay.png")

# ======================================================================
# 实验 2：Logistic 种群增长 ------ dy/dt = r·y·(1 - y/K)
# ----------------------------------------------------------------------
# 非线性 ODE 的经典代表（种群/扩散/饱和增长）。
# 解析解 y(t) = K / (1 + ((K-y0)/y0)·e^(-rt))，用它量化 RK4 误差。
# 非线性项 y² 让欧拉在拐点附近系统性地"过冲"，RK4 依然精准。
# ======================================================================
print("\n【实验 2】Logistic 种群增长（非线性 ODE）")
print("-" * 70)

r_rate, K_cap, y0_log = 1.2, 10.0, 0.5             # 增长率r、容量K、初始种群
f_logistic = lambda t, y: r_rate * y * (1 - y / K_cap)
logistic_exact = lambda t: K_cap / (1 + ((K_cap - y0_log) / y0_log) * np.exp(-r_rate * t))

T2, h2 = 8.0, 0.4
ts_e2, ys_e2 = integrate(euler_step, f_logistic, 0, np.array([y0_log]), T2, h2)
ts_r2, ys_r2 = integrate(rk4_step,  f_logistic, 0, np.array([y0_log]), T2, h2)
err_e2 = abs(ys_e2[-1, 0] - logistic_exact(T2))
err_r2 = abs(ys_r2[-1, 0] - logistic_exact(T2))
print(f"初始点: y(0) = {y0_log} (种群刚引入)")
print(f"t={T2}: 解析 = {logistic_exact(T2):.6f} | 欧拉误差 = {err_e2:.2e} | RK4误差 = {err_r2:.2e}")

fig, ax = plt.subplots(figsize=(7.5, 5))
tf = np.linspace(0, T2, 400)
ax.plot(tf, logistic_exact(tf), "k-", lw=2, label="解析解")
ax.plot(ts_e2, ys_e2[:, 0], "o--", color="#d62728", lw=1.2, ms=4, label=f"欧拉 h={h2}")
ax.plot(ts_r2, ys_r2[:, 0], "s-", color="#1f77b4", lw=1.5, ms=5, label=f"RK4 h={h2}")
ax.axhline(K_cap, color="gray", ls=":", label=f"环境容量 K={K_cap}")
ax.plot(0, y0_log, "r*", ms=16, zorder=5, label=f"初始点 (0, {y0_log})")
ax.plot(T2, ys_r2[-1, 0], "g^", ms=12, zorder=5, label=f"RK4终态 y({T2:.0f})={ys_r2[-1,0]:.3f}")
ax.set_xlabel("t"); ax.set_ylabel("种群 y(t)"); ax.grid(alpha=0.3); ax.legend(fontsize=9)
ax.set_title("实验2 Logistic 增长：非线性 ODE 的 RK4 求解")
fig.tight_layout(); fig.savefig("figures/rk4_logistic.png", dpi=150); plt.close(fig)
print("图已保存: figures/rk4_logistic.png")

# ======================================================================
# 实验 3：单摆（二阶 ODE → 一阶系统）------ 相图与能量守恒
# ----------------------------------------------------------------------
# 二阶 ODE  θ'' = -(g/L)·sinθ  的标准处理：升维成两个一阶方程
#     dθ/dt = ω
#     dω/dt = -(g/L)·sinθ
# 状态向量 y = [θ, ω]，RK4 直接对向量积分（f 返回数组即可）。
# 无阻尼单摆机械能守恒：E = ½L²ω² + gL(1-cosθ) 应恒定。
#   欧拉法每一步都沿"当前斜率"外切 → 能量单调增加 → 相图向外螺旋发散；
#   RK4 能量误差 O(h⁴) → 相图闭合。这是"保结构"差异最直观的演示。
# ======================================================================
print("\n【实验 3】单摆：相图与能量守恒（欧拉发散 vs RK4 闭合）")
print("-" * 70)

g_acc, L_pen = 9.81, 1.0
f_pend = lambda t, y: np.array([y[1], -(g_acc / L_pen) * math.sin(y[0])])
theta0, omega0 = 2.5, 0.0                          # 大摆角初始(非线性区), 静止释放
y0_p = np.array([theta0, omega0])
energy = lambda y: 0.5 * L_pen**2 * y[:, 1]**2 + g_acc * L_pen * (1 - np.cos(y[:, 0]))

T3, h3 = 20.0, 0.02
ts_e3, ys_e3 = integrate(euler_step, f_pend, 0, y0_p, T3, h3)
ts_r3, ys_r3 = integrate(rk4_step,  f_pend, 0, y0_p, T3, h3)
E0 = energy(y0_p[None, :])[0]
drift_e = (energy(ys_e3) - E0) / E0 * 100          # 能量漂移百分比
drift_r = (energy(ys_r3) - E0) / E0 * 100
print(f"初始点: θ={theta0} rad, ω=0 (静止释放大摆角)")
print(f"20 秒后能量漂移: 欧拉 = {drift_e[-1]:+.2f}% (发散) | RK4 = {drift_r[-1]:+.4f}% (守恒)")
print(f"RK4终态: θ={ys_r3[-1,0]:.4f} rad, ω={ys_r3[-1,1]:.4f} rad/s")

fig, axes = plt.subplots(1, 2, figsize=(12, 5))
axes[0].plot(ys_e3[:, 0], ys_e3[:, 1], color="#d62728", lw=0.8, label="欧拉相轨(向外发散)")
axes[0].plot(ys_r3[:, 0], ys_r3[:, 1], color="#1f77b4", lw=1.2, label="RK4相轨(闭合)")
axes[0].plot(theta0, omega0, "r*", ms=16, zorder=5, label=f"初始点 ({theta0}, 0)")
axes[0].plot(ys_r3[-1, 0], ys_r3[-1, 1], "g^", ms=11, zorder=5, label="RK4终态(t=20s)")
axes[0].set_xlabel("θ (rad)"); axes[0].set_ylabel("ω (rad/s)")
axes[0].set_title("相图：状态(θ,ω)的轨迹"); axes[0].legend(fontsize=8); axes[0].grid(alpha=0.3)
axes[1].plot(ts_e3, drift_e, color="#d62728", label="欧拉能量漂移")
axes[1].plot(ts_r3, drift_r, color="#1f77b4", label="RK4能量漂移")
axes[1].set_xlabel("t (s)"); axes[1].set_ylabel("能量偏差 (%)")
axes[1].set_title("机械能守恒检验"); axes[1].legend(fontsize=9); axes[1].grid(alpha=0.3)
fig.suptitle("实验3 无阻尼单摆：RK4 保结构 vs 欧拉能量爆炸", y=1.0)
fig.tight_layout(); fig.savefig("figures/rk4_pendulum.png", dpi=150); plt.close(fig)
print("图已保存: figures/rk4_pendulum.png")

# ======================================================================
# 实验 4：Lotka-Volterra 捕食者-猎物模型（生态学）
# ----------------------------------------------------------------------
#   dx/dt = αx - βxy   (猎物: 自然增长 - 被捕食)
#   dy/dt = δxy - γy   (捕食者: 靠吃猎物增长 - 自然死亡)
# 相平面上轨道是闭合环（周期振荡），对数值方法的"不增不减"要求苛刻：
#   欧拉 → 螺旋向外（能量注入）；RK4 → 轨道几乎精确闭合。
# ======================================================================
print("\n【实验 4】Lotka-Volterra 捕食-猎物模型（生态学）")
print("-" * 70)

alpha, beta, delta, gamma_ = 1.1, 0.4, 0.1, 0.4
f_lv = lambda t, z: np.array([alpha * z[0] - beta * z[0] * z[1],
                              delta * z[0] * z[1] - gamma_ * z[1]])
z0_lv = np.array([10.0, 10.0])                     # 初始: 猎物10, 捕食者10
T4, h4 = 30.0, 0.01
ts_e4, ys_e4 = integrate(euler_step, f_lv, 0, z0_lv, T4, h4)
ts_r4, ys_r4 = integrate(rk4_step,  f_lv, 0, z0_lv, T4, h4)
# 轨道闭合度指标：t≥5s 后轨迹"最接近初始点"的距离。
# 闭合轨道每绕一圈都会回到初始点附近(距离→0)；螺旋发散的欧拉轨道
# 半径不断增大，回来时离初始点越来越远(距离不趋于0)。
d_e = np.linalg.norm(ys_e4[ts_e4 >= 5] - z0_lv, axis=1)
d_r = np.linalg.norm(ys_r4[ts_r4 >= 5] - z0_lv, axis=1)
print(f"初始点: 猎物={z0_lv[0]}, 捕食者={z0_lv[1]}")
print(f"RK4终态(t=30): 猎物={ys_r4[-1,0]:.3f}, 捕食者={ys_r4[-1,1]:.3f}")
print(f"轨道闭合度(t≥5s 轨迹距初始点的最近距离):")
print(f"  欧拉 = {d_e.min():.3f} (螺旋发散,每圈离初始点越来越远) | RK4 = {d_r.min():.2e} (轨道闭合,每圈重过初始点附近,残差为采样分辨率量级)")

fig, axes = plt.subplots(1, 2, figsize=(12, 5))
axes[0].plot(ys_e4[:, 0], ys_e4[:, 1], color="#d62728", lw=0.7, label="欧拉(螺旋发散)")
axes[0].plot(ys_r4[:, 0], ys_r4[:, 1], color="#1f77b4", lw=1.2, label="RK4(闭合轨道)")
axes[0].plot(*z0_lv, "r*", ms=16, zorder=5, label="初始点 (10, 10)")
axes[0].plot(ys_r4[-1, 0], ys_r4[-1, 1], "g^", ms=11, zorder=5, label="RK4终态(t=30)")
axes[0].set_xlabel("猎物 x"); axes[0].set_ylabel("捕食者 y")
axes[0].set_title("相平面轨道"); axes[0].legend(fontsize=8); axes[0].grid(alpha=0.3)
axes[1].plot(ts_r4[::10], ys_r4[::10, 0], color="#1f77b4", label="猎物(RK4)")
axes[1].plot(ts_r4[::10], ys_r4[::10, 1], color="#ff7f0e", label="捕食者(RK4)")
axes[1].plot(0, z0_lv[0], "r*", ms=13, zorder=5)
axes[1].set_xlabel("t"); axes[1].set_ylabel("种群数量")
axes[1].set_title("时间序列：周期振荡（捕食者滞后于猎物）")
axes[1].legend(fontsize=9); axes[1].grid(alpha=0.3)
fig.suptitle("实验4 Lotka-Volterra：RK4 保持闭合生态轨道", y=1.0)
fig.tight_layout(); fig.savefig("figures/rk4_lotka.png", dpi=150); plt.close(fig)
print("图已保存: figures/rk4_lotka.png")

# ======================================================================
# 实验 5：收敛阶数实测 ------ "RK4 为什么叫四阶"
# ----------------------------------------------------------------------
# 对 dy/dt=-y 逐步减半步长 h，测 t=1 处的全局误差：
#   理论：欧拉 err ∝ h¹ (log-log 斜率=1)，RK4 err ∝ h⁴ (斜率=4)。
# log-log 图上用最小二乘拟合斜率，直接验证收敛阶数。
# ======================================================================
print("\n【实验 5】收敛阶数实测（log-log 斜率 = 阶数）")
print("-" * 70)

hs = np.array([0.2, 0.1, 0.05, 0.025, 0.0125, 0.00625])
exact1 = math.exp(-1.0)
errs_euler, errs_rk4 = [], []
for h in hs:
    _, ye = integrate(euler_step, f_decay, 0, np.array([1.0]), 1.0, h)
    _, yr = integrate(rk4_step,  f_decay, 0, np.array([1.0]), 1.0, h)
    errs_euler.append(abs(ye[-1, 0] - exact1))
    errs_rk4.append(abs(yr[-1, 0] - exact1))
slope_e = np.polyfit(np.log(hs), np.log(errs_euler), 1)[0]
slope_r = np.polyfit(np.log(hs), np.log(errs_rk4), 1)[0]
print(f"步长序列: {hs.tolist()}")
print(f"欧拉误差: {[f'{e:.2e}' for e in errs_euler]}")
print(f"RK4 误差: {[f'{e:.2e}' for e in errs_rk4]}")
print(f"拟合收敛阶: 欧拉 = {slope_e:.2f} (理论1) | RK4 = {slope_r:.2f} (理论4)")
print(f"→ 步长减半: 欧拉误差减半(×1/2)，RK4误差变1/16(×1/16)")

fig, ax = plt.subplots(figsize=(7.5, 5))
ax.loglog(hs, errs_euler, "o--", color="#d62728", label=f"欧拉 (斜率{slope_e:.2f})")
ax.loglog(hs, errs_rk4, "s-", color="#1f77b4", label=f"RK4 (斜率{slope_r:.2f})")
ax.loglog(hs, hs * errs_euler[0] / hs[0], color="#d62728", lw=0.8, ls=":", label="参考线 ∝ h¹")
ax.loglog(hs, hs**4 * errs_rk4[0] / hs[0]**4, color="#1f77b4", lw=0.8, ls=":", label="参考线 ∝ h⁴")
ax.set_xlabel("步长 h"); ax.set_ylabel(r"$|y(1) - e^{-1}|$ 全局误差")
ax.set_title("实验5 收敛阶数：log-log 斜率 = 方法阶数"); ax.legend(fontsize=9); ax.grid(alpha=0.3, which="both")
fig.tight_layout(); fig.savefig("figures/rk4_convergence.png", dpi=150); plt.close(fig)
print("图已保存: figures/rk4_convergence.png")

# ======================================================================
# 实验 6：深度学习应用 ------ Neural ODE（神经常微分方程）
# ----------------------------------------------------------------------
# 思想（Chen et al., NeurIPS 2018 最佳论文）：
#   传统网络: 离散层堆叠   h_{l+1} = h_l + f_l(h_l)   ← 恰是"一步欧拉法"
#   Neural ODE: 连续化     dh/dt = f_θ(h, t)          ← 用 RK4 从 t0 积分到 t1
# 前向 = RK4 积分；损失对 θ 的梯度 = autograd 直接穿透整个 RK4 计算图
#   （RK4 的每一步都是可微张量运算 → 积分器本身就是网络的一部分）。
# 本实验：用 RK4-Neural ODE 拟合一条螺旋轨迹数据，
#   学出向量场 f_θ，展示【初始点 z0 → RK4 积分 → 预测轨迹】全过程。
# ----------------------------------------------------------------------
# 与深度学习生态的联系：
#   * ResNet = 欧拉离散化的 Neural ODE（深度=步长）；
#   * 扩散模型采样器 DDIM/Heun(=RK2)/DPM-Solver = 概率流 ODE 的数值积分；
#   * 可微物理仿真（机器人/自动驾驶）= RK4 嵌入训练回路。
# ======================================================================
print("\n【实验 6】Neural ODE：RK4 作为可微分层拟合螺旋动力学")
print("-" * 70)

DEV = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# ---- 构造"真实世界"：一个产生螺旋收敛轨迹的线性系统 dz/dt = A z ----
A_true = torch.tensor([[-0.1, 1.0],
                       [-1.0, -0.1]])                # 旋转+收缩 → 螺旋线
z0_true = torch.tensor([2.0, 0.0])                  # ★ 初始点
T_END, N_STEP = 6.0, 60                             # 积分区间[0,6]，RK4固定60步
t_eval = torch.linspace(0, T_END, 25)               # 25 个"观测时刻"
# 解析轨迹 z(t) = expm(A t) z0（矩阵指数，作为观测数据来源）
with torch.no_grad():
    data_traj = torch.stack([torch.linalg.matrix_exp(A_true * t) @ z0_true for t in t_eval])
eval_idx = np.linspace(0, N_STEP, len(t_eval)).round().astype(int)  # 观测点在RK4网格上的索引

# ---- 待学习的向量场 f_θ：小 MLP（这就是 Neural ODE 的"参数"）----
class VectorField(nn.Module):
    def __init__(self, dim=2, hid=32):
        super().__init__()
        self.net = nn.Sequential(nn.Linear(dim, hid), nn.Tanh(),
                                 nn.Linear(hid, hid), nn.Tanh(),
                                 nn.Linear(hid, dim))
    def forward(self, z):
        return self.net(z)

model6 = VectorField().to(DEV)

def rk4_integrate_torch(f, z0, n_steps, dt):
    """RK4 积分器（torch 版）------每一步都是可微运算，autograd 可穿透。
    返回 (n_steps+1, 2) 的整条轨迹（含初始点）"""
    z, traj = z0, [z0]
    for _ in range(n_steps):
        k1 = f(z)
        k2 = f(z + dt / 2 * k1)
        k3 = f(z + dt / 2 * k2)
        k4 = f(z + dt * k3)
        z = z + dt / 6 * (k1 + 2 * k2 + 2 * k3 + k4)
        traj.append(z)
    return torch.stack(traj)

opt = torch.optim.Adam(model6.parameters(), lr=8e-3)
dt = T_END / N_STEP
losses = []
for it in range(401):
    opt.zero_grad()
    traj = rk4_integrate_torch(model6, z0_true.to(DEV), N_STEP, dt)   # 前向=RK4积分
    loss = ((traj[eval_idx] - data_traj.to(DEV)) ** 2).sum(1).mean()  # 观测点MSE
    loss.backward()                                                   # 梯度穿透RK4!
    opt.step()
    losses.append(loss.item())
    if it % 100 == 0:
        print(f"  iter {it:4d}  loss = {loss.item():.6f}")

with torch.no_grad():
    traj_learned = rk4_integrate_torch(model6, z0_true.to(DEV), N_STEP, dt).cpu()
    max_dev = (traj_learned[eval_idx] - data_traj).abs().max().item()
print(f"训练完成: 观测点最大偏差 = {max_dev:.4f}（初始点 → RK4 积分 → 拟合整条轨迹）")

fig, axes = plt.subplots(1, 2, figsize=(12, 5.2))
# 左：相平面 ------ 真实数据、学到的轨迹、向量场、初始点/终态
gd = 2.6
gx, gy = np.meshgrid(np.linspace(-gd, gd, 16), np.linspace(-gd, gd, 16))
pts = torch.tensor(np.stack([gx.ravel(), gy.ravel()], 1), dtype=torch.float32).to(DEV)
with torch.no_grad():
    vec = model6(pts).cpu().numpy()
uv = vec / (np.linalg.norm(vec, axis=1, keepdims=True) + 1e-8)        # 单位化便于显示
axes[0].quiver(gx.ravel(), gy.ravel(), uv[:, 0], uv[:, 1], color="gray", alpha=0.45, label="学到的向量场 $f_θ$")
axes[0].plot(data_traj[:, 0], data_traj[:, 1], "ko", ms=4, label="观测数据(真实螺旋)")
axes[0].plot(traj_learned[:, 0], traj_learned[:, 1], color="#1f77b4", lw=2, label="Neural ODE + RK4 预测")
axes[0].plot(*z0_true.numpy(), "r*", ms=18, zorder=6, label=f"初始点 z0=({z0_true[0]:.0f},{z0_true[1]:.0f})")
axes[0].plot(traj_learned[-1, 0], traj_learned[-1, 1], "g^", ms=12, zorder=6,
             label=f"RK4终态 t={T_END:.0f}")
axes[0].set_xlabel("$z_1$"); axes[0].set_ylabel("$z_2$")
axes[0].set_title("相平面：数据 / 学习轨迹 / 向量场"); axes[0].legend(fontsize=7.5, loc="upper left")
axes[0].grid(alpha=0.3)
# 右：训练损失
axes[1].semilogy(losses, color="#1f77b4")
axes[1].set_xlabel("迭代次数"); axes[1].set_ylabel("MSE 损失(log)")
axes[1].set_title("训练曲线（梯度穿透 RK4 计算图）"); axes[1].grid(alpha=0.3)
fig.suptitle("实验6 Neural ODE：RK4 = 可微分的'网络层'", y=1.0)
fig.tight_layout(); fig.savefig("figures/rk4_neural_ode.png", dpi=150); plt.close(fig)
print("图已保存: figures/rk4_neural_ode.png")

# ======================================================================
# 实验 7：智能驾驶 ------ 车辆运动学自行车模型轨迹预测
# ----------------------------------------------------------------------
# 规划/MPC 的核心内核：给定当前状态与未来输入序列，向前推演轨迹。
# 运动学自行车模型（低速场景，忽略轮胎侧偏）：
#     ẋ   = v·cosψ        (纵向位置)
#     ẏ   = v·sinψ        (横向位置)
#     ψ̇   = v·tanδ / L    (航向角, L=轴距, δ=前轮转角)
#     v̇   = a             (车速, a=加速度)
# 场景：车辆以 5 m/s 起步、加速 0.5 m/s²，前轮转角正弦摆动 12 秒
#   → RK4(h=0.01) 作为"真值"，对比粗步长欧拉(h=0.1)的轨迹漂移。
#   MPC 每个控制周期都要积分一次这样的模型，精度直接影响规划质量。
# ======================================================================
print("\n【实验 7】智驾-自行车模型：轨迹预测（MPC/规划内核）")
print("-" * 70)

L_wb = 2.8                                          # 轴距(m)，典型轿车
delta_max, T_steer = 0.12, 8.0                      # 前轮转角幅值(rad)、摆动周期(s)
steer = lambda t: delta_max * math.sin(2 * math.pi * t / T_steer)   # 转角输入序列
accel = lambda t: 0.5 if t < 4 else 0.0             # 前4秒加速0.5m/s²，之后匀速

def f_bicycle(t, s):
    """状态 s = [x, y, ψ, v]；返回导数（自行车模型右端项）"""
    x, y, psi, v = s
    return np.array([v * math.cos(psi),               # ẋ
                     v * math.sin(psi),               # ẏ
                     v * math.tan(steer(t)) / L_wb,   # ψ̇
                     accel(t)])                       # v̇

s0_car = np.array([0.0, 0.0, 0.0, 5.0])             # ★ 初始点: 原点, 朝东, 5 m/s
T7 = 12.0
ts_r7, ys_r7 = integrate(rk4_step,   f_bicycle, 0, s0_car, T7, 0.01)   # 高精度参考
ts_e7, ys_e7 = integrate(euler_step, f_bicycle, 0, s0_car, T7, 0.1)    # 粗步长欧拉

dev = np.linalg.norm(ys_r7[::10, :2] - ys_e7[:, :2], axis=1)           # 位置偏差(m)
print(f"初始点: x=0, y=0, ψ=0, v=5 m/s")
print(f"RK4终态(t=12s): x={ys_r7[-1,0]:.2f} m, y={ys_r7[-1,1]:.2f} m, "
      f"ψ={math.degrees(ys_r7[-1,2]):.1f}°, v={ys_r7[-1,3]:.2f} m/s")
print(f"欧拉(h=0.1)与RK4(h=0.01)的最大位置偏差 = {dev.max():.2f} m ← 规划不可接受!")

fig, axes = plt.subplots(1, 2, figsize=(12.5, 5.2))
axes[0].plot(ys_r7[:, 0], ys_r7[:, 1], color="#1f77b4", lw=2, label="RK4 h=0.01 (规划基准)")
axes[0].plot(ys_e7[:, 0], ys_e7[:, 1], "o--", color="#d62728", ms=3, lw=1, label="欧拉 h=0.1")
axes[0].plot(*s0_car[:2], "r*", ms=18, zorder=6, label="初始点 (0,0)")
axes[0].plot(ys_r7[-1, 0], ys_r7[-1, 1], "g^", ms=12, zorder=6,
             label=f"RK4终态 ({ys_r7[-1,0]:.1f},{ys_r7[-1,1]:.1f})")
# 画几个航向箭头示意车辆姿态
for i in range(0, len(ts_r7), 120):
    axes[0].annotate("", xy=(ys_r7[i,0]+1.2*math.cos(ys_r7[i,2]), ys_r7[i,1]+1.2*math.sin(ys_r7[i,2])),
                     xytext=(ys_r7[i,0], ys_r7[i,1]),
                     arrowprops=dict(arrowstyle="->", color="#1f77b4", alpha=0.5, lw=1))
axes[0].set_xlabel("x (m)"); axes[0].set_ylabel("y (m)"); axes[0].set_aspect("equal")
axes[0].set_title("预测轨迹（蛇形机动 12s）"); axes[0].legend(fontsize=8); axes[0].grid(alpha=0.3)
axes[1].plot(ts_e7, dev, color="#d62728", lw=1.5)
axes[1].set_xlabel("t (s)"); axes[1].set_ylabel("位置偏差 (m)")
axes[1].set_title("粗步长欧拉 vs RK4 的偏差随时间累积"); axes[1].grid(alpha=0.3)
fig.suptitle("实验7 智驾轨迹预测：积分器精度 = 规划质量", y=1.0)
fig.tight_layout(); fig.savefig("figures/rk4_bicycle.png", dpi=150); plt.close(fig)
print("图已保存: figures/rk4_bicycle.png")

# ======================================================================
# 实验 8：智能驾驶 ------ CTRV 模型（目标跟踪卡尔曼滤波的预测步）
# ----------------------------------------------------------------------
# 跟踪雷达/视觉目标时，卡尔曼滤波的"预测步"要把目标状态向前推 Δt：
#   CTRV（Constant Turn Rate and Velocity，匀转率匀速）模型：
#     ṗx = v·cosφ,  ṗy = v·sinφ,  v̇ = 0,  φ̇ = ω,  ω̇ = 0
#   状态 = [px, py, v, φ, ω]（5 维）------滤波周期 0.1s 内车辆近似匀转。
# 常转角下该 ODE 有解析解（圆弧），正好用来量化 RK4/欧拉的预测误差。
# 场景：他车以 8 m/s、0.2 rad/s 左转 8 秒（约 1.5 圈半径 40m 的圆弧）。
# ======================================================================
print("\n【实验 8】智驾-CTRV 模型：跟踪滤波的非线性预测步")
print("-" * 70)

def f_ctrv(t, s):
    """状态 s = [px, py, v, φ, ω]"""
    return np.array([s[2] * math.cos(s[3]),        # ṗx
                     s[2] * math.sin(s[3]),        # ṗy
                     0.0,                          # v̇  = 0 (匀速)
                     s[4],                         # φ̇  = ω (匀转)
                     0.0])                         # ω̇  = 0

v0, omega0, phi0 = 8.0, 0.2, 0.0                   # 8 m/s, 0.2 rad/s 左转, 朝东
s0_ctrv = np.array([0.0, 0.0, v0, phi0, omega0])   # ★ 初始点在原点

def ctrv_exact(t):
    """CTRV 解析解：匀速圆周运动（半径 R = v/ω）"""
    R = v0 / omega0
    return np.array([R * (math.sin(phi0 + omega0 * t) - math.sin(phi0)),
                     R * (math.cos(phi0) - math.cos(phi0 + omega0 * t))])

T8, h8 = 8.0, 0.1                                  # 滤波周期 0.1s
ts_r8, ys_r8 = integrate(rk4_step,   f_ctrv, 0, s0_ctrv, T8, h8)
ts_e8, ys_e8 = integrate(euler_step, f_ctrv, 0, s0_ctrv, T8, h8)
err_r8 = np.linalg.norm(ys_r8[:, :2] - np.array([ctrv_exact(t) for t in ts_r8]), axis=1)
err_e8 = np.linalg.norm(ys_e8[:, :2] - np.array([ctrv_exact(t) for t in ts_e8]), axis=1)
print(f"初始点: px=0, py=0, v=8 m/s, φ=0, ω=0.2 rad/s (半径 R={v0/omega0:.0f} m 的圆弧)")
print(f"RK4终态(t=8s): px={ys_r8[-1,0]:.3f}, py={ys_r8[-1,1]:.3f} | 解析解误差 = {err_r8[-1]:.2e} m")
print(f"8秒最大位置误差: RK4 = {err_r8.max():.2e} m | 欧拉 = {err_e8.max():.3f} m")

fig, axes = plt.subplots(1, 2, figsize=(12.5, 5.2))
tt = np.linspace(0, T8, 400)
arc = np.array([ctrv_exact(t) for t in tt])
axes[0].plot(arc[:, 0], arc[:, 1], "k-", lw=2, label="解析解(圆弧)")
axes[0].plot(ys_e8[:, 0], ys_e8[:, 1], "o--", color="#d62728", ms=3, lw=1, label="欧拉 h=0.1")
axes[0].plot(ys_r8[::2, 0], ys_r8[::2, 1], "s", color="#1f77b4", ms=3, label="RK4 h=0.1 (每0.2s一个预测点)")
axes[0].plot(*s0_ctrv[:2], "r*", ms=18, zorder=6, label="初始点 (0,0)")
axes[0].plot(ys_r8[-1, 0], ys_r8[-1, 1], "g^", ms=12, zorder=6,
             label=f"RK4终态 ({ys_r8[-1,0]:.1f},{ys_r8[-1,1]:.1f})")
axes[0].set_xlabel("px (m)"); axes[0].set_ylabel("py (m)"); axes[0].set_aspect("equal")
axes[0].set_title("他车转弯轨迹预测（跟踪滤波预测步）"); axes[0].legend(fontsize=8); axes[0].grid(alpha=0.3)
axes[1].semilogy(ts_r8, np.maximum(err_r8, 1e-16), color="#1f77b4", label=f"RK4 (max {err_r8.max():.1e} m)")
axes[1].semilogy(ts_e8, err_e8, color="#d62728", label=f"欧拉 (max {err_e8.max():.2f} m)")
axes[1].set_xlabel("t (s)"); axes[1].set_ylabel("位置误差 (m, log)")
axes[1].set_title("预测误差随滤波步数累积"); axes[1].legend(fontsize=9); axes[1].grid(alpha=0.3)
fig.suptitle("实验8 CTRV 跟踪预测：RK4 误差 ~1e-9 m 级 vs 欧拉 分米级漂移", y=1.0)
fig.tight_layout(); fig.savefig("figures/rk4_ctrv.png", dpi=150); plt.close(fig)
print("图已保存: figures/rk4_ctrv.png")

# ======================================================================
# 实验 9：智能驾驶 ------ IDM 智能驾驶员跟驰模型（微观交通仿真）
# ----------------------------------------------------------------------
# SUMO/CARLA 交通流的标准跟驰模型，纯 ODE：
#   dv/dt = a·[1 - (v/v0)⁴ - (s*(v,Δv)/g)²]
#   s* = s0 + max(0, v·T + v·Δv/(2√(ab)))     ← 期望安全车距
#   其中 g=实际车距, Δv=自车-前车速度差, v0=期望车速,
#        a=最大加速度, b=舒适减速度, T=安全时距, s0=最小车距
# 场景：前车 25 m/s 匀速，自车 30 m/s 从 20 m 车距追上 →
#   自车自动减速收敛到平衡车距；t=12s 前车紧急制动 3 秒 → 自车跟随减速。
# 4 维状态 [x_ego, v_ego, x_lead, v_lead] 联合积分（RK4 h=0.01）。
# ======================================================================
print("\n【实验 9】智驾-IDM 跟驰模型：微观交通仿真")
print("-" * 70)

A_MAX, B_COMF, S_MIN, T_GAP, V_DES, DELTA = 1.4, 2.0, 2.0, 1.5, 30.0, 4
V_LEAD = 12.0                                       # 前车城市巡航速度(m/s)
# 场景选低速的原因：IDM 的自由流项 (v/v0)⁴ 在低速时很小 → 车距吸引力强，
# 收敛到平衡车距的过程干净可见；高速大车距时该项接近1，收敛极慢(物理特性)。

def f_idm(t, s):
    x_e, v_e, x_l, v_l = s
    gap = x_l - x_e - 5.0                          # 车距(减车身长5m)
    dv = v_e - v_l                                 # 速度差(正=在逼近)
    s_star = S_MIN + max(0.0, v_e * T_GAP + v_e * dv / (2 * math.sqrt(A_MAX * B_COMF)))
    a_ego = A_MAX * (1 - (v_e / V_DES) ** DELTA - (s_star / max(gap, 0.1)) ** 2)
    # 前车加速度剖面: 20~23s 紧急制动(-2 m/s²)，之后加速(1 m/s²)回到巡航速度
    if 20.0 <= t < 23.0:
        a_l = -2.0
    elif t >= 23.0 and v_l < V_LEAD:
        a_l = 1.0
    else:
        a_l = 0.0
    return np.array([v_e, a_ego, v_l, a_l])

s0_idm = np.array([0.0, 20.0, 45.0, V_LEAD])       # ★ 初始点: 自车0m@20m/s, 前车45m@12m/s(车距40m)
T9, h9 = 45.0, 0.01                                # 仿真45s: 覆盖 收敛→制动→再收敛 三阶段
ts9, ys9 = integrate(rk4_step, f_idm, 0, s0_idm, T9, h9)
gap9 = ys9[:, 2] - ys9[:, 0] - 5.0
gap_eq = S_MIN + V_LEAD * T_GAP                    # 平衡车距 = s0 + v_lead·T
i_mingap = int(gap9.argmin())                      # 最小车距出现的时刻索引
min_gap = gap9[i_mingap]
print(f"初始点: 自车 x=0, v=20 m/s | 前车 x=45, v=12 m/s | 初始车距 = {45-5:.0f} m")
print(f"RK4终态(t=45s): 自车 v={ys9[-1,1]:.2f} m/s, 车距 = {gap9[-1]:.2f} m (平衡车距 {gap_eq:.1f} m)")
print(f"全程最小车距 = {min_gap:.2f} m @ t={ts9[i_mingap]:.1f}s ({'安全 ✓' if min_gap > S_MIN else '危险 ✗'})")

fig, axes = plt.subplots(1, 3, figsize=(15.5, 4.8))
# --- 子图1: 速度收敛 ---
axes[0].plot(ts9, ys9[:, 1], color="#1f77b4", lw=1.6, label="自车 v (IDM+RK4)")
axes[0].plot(ts9, ys9[:, 3], color="#ff7f0e", lw=1.6, label="前车 v")
axes[0].axvspan(20, 23, color="red", alpha=0.12, label="前车紧急制动 (-2 m/s²)")
axes[0].axvspan(23, 29, color="orange", alpha=0.10, label="前车恢复加速 (+1 m/s²)")
axes[0].plot(0, s0_idm[1], "r*", ms=16, zorder=6, label=f"初始点 v={s0_idm[1]:.0f} m/s")
axes[0].plot(T9, ys9[-1, 1], "g^", ms=12, zorder=6, label=f"RK4终态 v={ys9[-1,1]:.1f} m/s")
axes[0].set_xlabel("t (s)"); axes[0].set_ylabel("速度 (m/s)")
axes[0].set_title("速度：自车跟随前车制动与恢复"); axes[0].legend(fontsize=7.5, loc="lower left"); axes[0].grid(alpha=0.3)
# --- 子图2: 车距动态（标注最小车距点） ---
axes[1].plot(ts9, gap9, color="#2ca02c", lw=1.6, label="实际车距 g(t)")
axes[1].axhline(gap_eq, color="gray", ls=":", lw=1.2, label=f"平衡车距 {gap_eq:.0f} m")
axes[1].axhline(S_MIN, color="red", ls="--", lw=1, label=f"IDM 最小车距 s0={S_MIN} m")
axes[1].axvspan(20, 23, color="red", alpha=0.12)
axes[1].plot(0, gap9[0], "r*", ms=16, zorder=6, label=f"初始车距 {gap9[0]:.0f} m")
axes[1].plot(ts9[i_mingap], min_gap, "rv", ms=10, zorder=6,
             label=f"最小车距 {min_gap:.1f} m @ t={ts9[i_mingap]:.0f}s")
axes[1].plot(T9, gap9[-1], "g^", ms=12, zorder=6, label=f"RK4终态车距 {gap9[-1]:.1f} m")
axes[1].annotate(f"{min_gap:.1f} m", (ts9[i_mingap], min_gap), xytext=(ts9[i_mingap] - 9, min_gap - 6),
                 arrowprops=dict(arrowstyle="->", color="red"), color="red", fontsize=9)
axes[1].set_xlabel("t (s)"); axes[1].set_ylabel("车距 (m)"); axes[1].set_ylim(0, 48)
axes[1].set_title("车距：收敛→制动下探→恢复平衡（三段式）"); axes[1].legend(fontsize=7.5, loc="upper right"); axes[1].grid(alpha=0.3)
# --- 子图3: 道路位置 ---
axes[2].plot(ts9, ys9[:, 0], color="#1f77b4", lw=1.6, label="自车位置")
axes[2].plot(ts9, ys9[:, 2], color="#ff7f0e", lw=1.6, label="前车位置")
axes[2].plot(0, s0_idm[0], "r*", ms=16, zorder=6, label="初始位置 (0 / 100 m)")
axes[2].plot(0, s0_idm[2], "r*", ms=16, zorder=6)
axes[2].plot(T9, ys9[-1, 0], "g^", ms=12, zorder=6, label=f"RK4终态 自车 {ys9[-1,0]:.0f} m")
axes[2].plot(T9, ys9[-1, 2], "g^", ms=12, zorder=6)
axes[2].axvspan(20, 23, color="red", alpha=0.12)
axes[2].set_xlabel("t (s)"); axes[2].set_ylabel("位置 (m)")
axes[2].set_title("道路位置：全程无碰撞"); axes[2].legend(fontsize=8, loc="upper left"); axes[2].grid(alpha=0.3)
# ⚠ suptitle 的 y 必须 ≤1 且给 tight_layout 留出顶部空间(rect)，否则标题被裁切
fig.suptitle("实验9 IDM 城市跟驰仿真：RK4 积分 45 秒（初始点★ → RK4终态▲）", y=1.0)
fig.tight_layout(rect=[0, 0, 1, 0.94])
fig.savefig("figures/rk4_idm.png", dpi=150); plt.close(fig)
print("图已保存: figures/rk4_idm.png")

# ======================================================================
# 实验 10：二阶 ODE → 一阶系统（状态增广）+ 多参数传递
# ----------------------------------------------------------------------
# 弹簧-质量-阻尼自由振动: m·x'' + c·x' + k·x = 0   （二阶 ODE）
# 状态增广（伴随形式）: 令 z = [x, v]，其中 v = x'，则等价于一阶系统
#     x' = v                      ← "定义式"(v 就是 x 的导数)
#     v' = -(c·v + k·x)/m         ← 携带物理信息的方程(原二阶方程解出 x'')
# 多参数传递演示: f 的签名是 f(t, z, m, c, k) ------ 积分器只认 (t, y)，
#   用 functools.partial 把 m,c,k 固定成关键字参数 → 得到 (t, z) 签名。
# 参数扫描: 阻尼比 ζ = c/(2√(km)) 取 0.2 / 1.0 / 2.0 →
#   欠阻尼(振荡衰减) / 临界阻尼(最快无振荡回零) / 过阻尼(缓慢回零)。
# 欠阻尼有解析解可验收 RK4 精度:
#   x(t) = e^{-ζωt}[cos(ωd t) + (ζω/ωd)·sin(ωd t)],  ω=√(k/m), ωd=ω√(1-ζ²)
# ======================================================================
print("\n【实验 10】二阶 ODE 状态增广 + 多参数传递（弹簧-质量-阻尼）")
print("-" * 70)

import functools

def f_smd(t, z, m, c, k):
    """弹簧-质量-阻尼右端项(带额外参数 m,c,k): 状态 z=[x, v] 的伴随形式"""
    x, v = z
    return np.array([v, -(c * v + k * x) / m])   # [x', v']

m_s, k_s = 1.0, 10.0
omega_n = math.sqrt(k_s / m_s)                   # 固有频率 ω=√(k/m)
z0_s = np.array([1.0, 0.0])                      # ★ 初始点: 位移1m, 速度0
T10, h10 = 10.0, 0.01
results10 = {}
for zeta in [0.2, 1.0, 2.0]:
    c_s = 2 * zeta * math.sqrt(k_s * m_s)        # 由阻尼比反推阻尼系数 c=2ζ√(km)
    f_p = functools.partial(f_smd, m=m_s, c=c_s, k=k_s)  # 固定参数→(t,z)签名
    ts10, zs10 = integrate(rk4_step, f_p, 0, z0_s, T10, h10)
    results10[zeta] = (ts10, zs10)

# 欠阻尼解析解验收
zeta_t = 0.2
wd = omega_n * math.sqrt(1 - zeta_t ** 2)        # 阻尼振动频率 ωd
ts_u, zs_u = results10[zeta_t]
x_exact10 = np.exp(-zeta_t * omega_n * ts_u) * (np.cos(wd * ts_u) + zeta_t * omega_n / wd * np.sin(wd * ts_u))
err10 = np.abs(zs_u[:, 0] - x_exact10).max()
print(f"初始点: x=1 m, v=0 | ω=√(k/m)={omega_n:.2f} rad/s")
print(f"RK4 vs 解析解(ζ=0.2, 1000步): 最大误差 = {err10:.2e} m")
for zeta, (ts_, zs_) in results10.items():
    tag = {0.2: "欠阻尼(振荡衰减)", 1.0: "临界阻尼(最快回零)", 2.0: "过阻尼(缓慢回零)"}[zeta]
    print(f"  ζ={zeta}: {tag} | RK4终态 x(10)={zs_[-1,0]:+.4f} m, v(10)={zs_[-1,1]:+.4f} m/s")

fig, axes = plt.subplots(1, 2, figsize=(12, 4.8))
for zeta, color in zip([0.2, 1.0, 2.0], ["#1f77b4", "#2ca02c", "#d62728"]):
    ts_, zs_ = results10[zeta]
    axes[0].plot(ts_, zs_[:, 0], color=color, lw=1.5, label=f"ζ={zeta} RK4")
    axes[0].plot(T10, zs_[-1, 0], "^", color=color, ms=9, zorder=6)   # 各参数终态
axes[0].plot(ts_u, x_exact10, "k:", lw=1.2, label="解析解(ζ=0.2)")
axes[0].plot(0, 1.0, "r*", ms=16, zorder=6, label="初始点 (x=1, v=0)")
axes[0].set_xlabel("t (s)"); axes[0].set_ylabel("位移 x (m)")
axes[0].set_title("三种阻尼工况（参数扫描，同一积分器）"); axes[0].legend(fontsize=8); axes[0].grid(alpha=0.3)
axes[1].plot(zs_u[:, 0], zs_u[:, 1], color="#1f77b4", lw=1.2, label="相轨迹(螺旋收敛到原点)")
axes[1].plot(z0_s[0], z0_s[1], "r*", ms=16, zorder=6, label="初始点 (1, 0)")
axes[1].plot(zs_u[-1, 0], zs_u[-1, 1], "g^", ms=11, zorder=6, label=f"RK4终态 ({zs_u[-1,0]:.3f}, {zs_u[-1,1]:.3f})")
axes[1].set_xlabel("x (m)"); axes[1].set_ylabel("v = x' (m/s)")
axes[1].set_title("相平面 (x, x')：增广状态的轨迹"); axes[1].legend(fontsize=8); axes[1].grid(alpha=0.3)
fig.suptitle("实验10 二阶ODE→伴随形式一阶系统 + functools.partial 传参", y=1.0)
fig.tight_layout(rect=[0, 0, 1, 0.94]); fig.savefig("figures/rk4_second_order.png", dpi=150); plt.close(fig)
print("图已保存: figures/rk4_second_order.png")

# ======================================================================
# 实验 11：三阶 ODE ------ jerk 限制的 S 曲线速度规划（智驾舒适性规划）
# ----------------------------------------------------------------------
# 三阶 ODE: s''' = j(t)   (jerk = 加加速度 = 加速度对时间的导数)
# 状态增广 z = [s, v, a] (位置/速度/加速度)，伴随形式:
#     s' = v ;  v' = a ;  a' = j(t)
# 前两个方程是定义式，第三个携带输入信息 ------ 与二阶增广完全同构。
# 场景: 舒适限制的加减速（jerk=±2 m/s³）: 6 段对称 jerk 剖面
#   [0,1)+2 / [1,3)0 / [3,4)-2  → a: 0→2→2→0, v 增到 6 m/s (S形加速)
#   [4,8)0 巡航 / [8,12) 镜像减速段 → v 回到 0 (停车)
# 验证①: v、a 曲线连续光滑（S 曲线特征: 加速度无折角，乘客无冲击感）;
# 验证②: 无解析解 → 自收敛检验: 比较 h 与 h/2 的解，误差比应≈16(四阶)。
# ======================================================================
print("\n【实验 11】三阶 ODE：jerk 限制 S 曲线速度规划（智驾）")
print("-" * 70)

J_MAX = 2.0                                       # jerk 限值 (m/s³)
def jerk_profile(t):
    """6 段对称 jerk 剖面: 加速段(0-4s) + 巡航(4-8s) + 镜像减速段(8-12s)"""
    if t < 1.0:  return J_MAX                     # a: 0→2 (斜率限制)
    if t < 3.0:  return 0.0                       # a: 保持 2
    if t < 4.0:  return -J_MAX                    # a: 2→0 (光滑封顶)
    if t < 8.0:  return 0.0                       # 巡航 v=6 m/s
    if t < 9.0:  return -J_MAX                    # a: 0→-2
    if t < 11.0: return 0.0                       # a: 保持 -2
    if t < 12.0: return J_MAX                     # a: -2→0 (光滑落地)
    return 0.0

def f_scurve(t, z):
    """三阶系统伴随形式: 状态 z=[s, v, a]"""
    s, v, a = z
    return np.array([v, a, jerk_profile(t)])     # [s', v', a']

z0_sc = np.array([0.0, 0.0, 0.0])                # ★ 初始点: 静止停在原点
T11 = 12.0
JUMPS = [0.0, 1.0, 3.0, 4.0, 8.0, 9.0, 11.0, 12.0]  # jerk 切换时刻 = 右端函数不连续点

def integrate_piecewise(f_maker, y0, jumps, h):
    """分段积分: 在不连续点处切开、每段独立积分。
    ⚠ 关键细节: 每段必须用"冻结"在本段内部的右端函数 f_seg ------
    若直接用全局 f，段末最后一步的 k4 探针落在 t=b 上，会采样到
    【下一段】的 jerk 值 → 每个边界引入 O(h) 局部误差 → 整体退化为1阶。
    f_maker(a, b) 返回该段专用的右端函数(输入取段中点, 段内 jerk 为常数)。"""
    t, y = jumps[0], y0.copy()
    tt, yy = [t], [y.copy()]
    for a, b in zip(jumps[:-1], jumps[1:]):      # 逐段 [a, b)
        f_seg = f_maker(a, b)                    # 本段冻结右端函数
        n = int(round((b - a) / h))
        for i in range(n):
            y = rk4_step(f_seg, t, y, h)
            t = a + (i + 1) * h                  # 段内时间从段起点算，防浮点累积
            tt.append(t); yy.append(y.copy())
    return np.array(tt), np.array(yy)

# 段专用右端函数工厂: jerk 取段中点值(段内为常数), k1~k4 全部只用本段物理
f_seg_maker = lambda a, b: (lambda t, z: np.array([z[1], z[2], jerk_profile(0.5 * (a + b))]))

def err_between(h_coarse, h_fine, piecewise):
    """自收敛检验: 粗/细两套步长的解在公共时间点上的最大差(位置分量)"""
    if piecewise:
        _, yc = integrate_piecewise(f_seg_maker, z0_sc, JUMPS, h_coarse)
        _, yf = integrate_piecewise(f_seg_maker, z0_sc, JUMPS, h_fine)
    else:
        _, yc = integrate(rk4_step, f_scurve, 0, z0_sc, T11, h_coarse)
        _, yf = integrate(rk4_step, f_scurve, 0, z0_sc, T11, h_fine)
    return np.abs(yf[::2, 0] - yc[:, 0]).max()   # 细解每隔一步=粗解时间点

# 对照: 直接积分(步会跨 jerk 切换点) vs 分段积分(在切换点切开)
n1, n2 = err_between(0.02, 0.01, False), err_between(0.01, 0.005, False)
p1, p2 = err_between(0.02, 0.01, True),  err_between(0.01, 0.005, True)
ts11, zs11 = integrate_piecewise(f_seg_maker, z0_sc, JUMPS, 0.01)  # 作图/终态用分段版
print(f"初始点: s=0, v=0, a=0 (静止)")
print(f"RK4终态(t=12s, 分段积分): s={zs11[-1,0]:.2f} m, v={zs11[-1,1]:.6f} m/s, a={zs11[-1,2]:.6f} m/s² (回到静止)")
print(f"峰值 v = {zs11[:,1].max():.2f} m/s | 峰值 |a| = {np.abs(zs11[:,2]).max():.2f} m/s² (≤ 限值2)")
print(f"不连续点处理对照(步长减半的误差变化):")
print(f"  直接积分(跨不连续点): 误差比 = {n1/n2:.1f} (≈2 → 退化1阶) | 绝对误差 {n1:.1e}→{n2:.1e}")
print(f"  分段积分(切开+冻结右端): 绝对误差 {p1:.1e}→{p2:.1e} ← 已达浮点舍入地板")
print(f"    (分段常值 jerk → 被积函数为≤2次多项式, RK4 精确积分, 故无阶数可言只剩舍入误差)")

fig, axes = plt.subplots(4, 1, figsize=(10, 9), sharex=True)
j_prof = np.array([jerk_profile(t) for t in ts11])
for ax, dat, name, unit in zip(axes,
                               [zs11[:, 0], zs11[:, 1], zs11[:, 2], j_prof],
                               ["位置 s", "速度 v", "加速度 a", "jerk j (输入)"],
                               ["m", "m/s", "m/s²", "m/s³"]):
    ax.plot(ts11, dat, color="#1f77b4", lw=1.6)
    ax.set_ylabel(f"{name} ({unit})"); ax.grid(alpha=0.3)
axes[0].plot(0, 0, "r*", ms=16, zorder=6, label="初始点 (s=v=a=0)")
axes[0].plot(T11, zs11[-1, 0], "g^", ms=12, zorder=6, label=f"RK4终态 s={zs11[-1,0]:.1f} m")
axes[0].legend(fontsize=8, loc="lower right")
axes[3].set_xlabel("t (s)")
axes[1].annotate("S形: a 连续无折角", (2, 1.2), fontsize=9, color="#2ca02c")
fig.suptitle("实验11 三阶ODE(s'''=j)状态增广 [s,v,a]：jerk 限制 S 曲线", y=0.995)
fig.tight_layout(rect=[0, 0, 1, 0.96]); fig.savefig("figures/rk4_third_order.png", dpi=150); plt.close(fig)
print("图已保存: figures/rk4_third_order.png")

# ======================================================================
# 实验 12：耦合多变量非线性系统 ------ Lorenz 混沌系统（向量状态 + 参数）
# ----------------------------------------------------------------------
# Lorenz 方程（3 个耦合的一阶非线性 ODE，参数 σ, ρ, β）:
#     x' = σ(y - x)
#     y' = x(ρ - z) - y
#     z' = x·y - β·z
# 演示两点:
#   ① RK4 对"向量状态 + 多参数 + 非线性耦合"原样适用: f 返回 3 维向量即可，
#      公式逐分量成立（k1~k4 都是向量，加权平均也是向量运算）;
#   ② 混沌敏感性(蝴蝶效应): 初值差 1e-5 的两条轨迹指数发散 ------
#      对混沌系统，数值实验有意义的是吸引子的几何形状/统计特性，
#      而不是长时间单条轨迹的"精确复现"（任何积分器都做不到）。
# ======================================================================
print("\n【实验 12】耦合多变量系统：Lorenz 吸引子（向量状态 + 参数 + 混沌敏感性）")
print("-" * 70)

def f_lorenz(t, z, sigma=10.0, rho=28.0, beta=8.0 / 3.0):
    """Lorenz 右端项: 3 维向量状态 + 3 个物理参数(关键字传参)"""
    x, y, w = z
    return np.array([sigma * (y - x),          # x' = σ(y-x)
                     x * (rho - w) - y,        # y' = x(ρ-z)-y
                     x * y - beta * w])        # z' = xy-βz

z0_lz = np.array([1.0, 1.0, 1.0])               # ★ 初始点
z0_lz2 = z0_lz + np.array([1e-5, 0.0, 0.0])     # 蝴蝶: 初值扰动 1e-5
T12, h12 = 30.0, 0.005
f_lz = functools.partial(f_lorenz, sigma=10.0, rho=28.0, beta=8.0 / 3.0)  # 固定参数
ts12, zs12 = integrate(rk4_step, f_lz, 0, z0_lz, T12, h12)
_, zs12b = integrate(rk4_step, f_lz, 0, z0_lz2, T12, h12)
div = np.linalg.norm(zs12 - zs12b, axis=1)      # 两条轨迹的距离随时间变化
t_div = ts12[div > 1.0][0] if (div > 1.0).any() else float("nan")
print(f"初始点: (1,1,1) 与 (1+1e-5, 1, 1)")
print(f"RK4终态(t=30): ({zs12[-1,0]:.2f}, {zs12[-1,1]:.2f}, {zs12[-1,2]:.2f})")
print(f"初值差 1e-5 → 轨迹距离>1 的时刻: t≈{t_div:.1f}s (蝴蝶效应, 指数发散)")

fig, axes = plt.subplots(1, 2, figsize=(12.5, 5))
sc = axes[0].scatter(zs12[::5, 0], zs12[::5, 2], c=ts12[::5], cmap="viridis", s=2)
axes[0].plot(z0_lz[0], z0_lz[2], "r*", ms=16, zorder=6, label="初始点 (x=1, z=1)")
axes[0].plot(zs12[-1, 0], zs12[-1, 2], "g^", ms=11, zorder=6,
             label=f"RK4终态 ({zs12[-1,0]:.1f}, {zs12[-1,2]:.1f})")
axes[0].set_xlabel("x"); axes[0].set_ylabel("z")
axes[0].set_title("Lorenz 吸引子 (x-z 投影, 颜色=时间)"); axes[0].legend(fontsize=8); axes[0].grid(alpha=0.3)
fig.colorbar(sc, ax=axes[0], label="t (s)")
axes[1].semilogy(ts12, np.maximum(div, 1e-12), color="#d62728", lw=1.5, label="两轨迹距离")
axes[1].axhline(1.0, color="gray", ls=":", label="距离=1 参考线")
axes[1].set_xlabel("t (s)"); axes[1].set_ylabel("轨迹距离 (log)")
axes[1].set_title(f"混沌敏感性: 1e-5 初差 → {t_div:.0f}s 后差 >1"); axes[1].legend(fontsize=8); axes[1].grid(alpha=0.3)
fig.suptitle("实验12 RK4 原样积分耦合多变量非线性系统（3维向量状态+3参数）", y=1.0)
fig.tight_layout(rect=[0, 0, 1, 0.94]); fig.savefig("figures/rk4_lorenz.png", dpi=150); plt.close(fig)
print("图已保存: figures/rk4_lorenz.png")

print("\n" + "=" * 70)
print("全部 12 组实验完成，图形清单:")
for name in ["rk4_decay", "rk4_logistic", "rk4_pendulum", "rk4_lotka",
             "rk4_convergence", "rk4_neural_ode", "rk4_bicycle", "rk4_ctrv", "rk4_idm",
             "rk4_second_order", "rk4_third_order", "rk4_lorenz"]:
    print(f"  figures/{name}.png")

7. 实战注意事项与避坑

刚性（stiff）系统别用 RK4 ：化学动力学、 stiff 电路等快慢时间尺度悬殊的系统，显式 RK4 需要极小步长才稳定 → 换隐式方法（Radau/BDF，scipy.integrate.solve_ivp(method="Radau")）；
步长不是越小越好 ：h 过小时舍入误差累积 + 计算量浪费；工程上用自适应步长（RK45 Dormand-Prince：每步用 4 阶/5 阶两个结果估计误差自动调 h）；
右端函数不连续要分段积分：控制输入切换、IDM 前车制动事件等跳变点处，让 RK4 跨跳变积分会退化阶数 → 在事件时刻切开，分段各自积分（实验 9 的制动剖面即分段定义）；
MPC/控制中积分步长 ≠ 控制周期：控制周期 50 ms 内可用 RK4 细分 5~10 个子步，兼顾实时性与精度（实验 7 用 h=0.01 作基准）；
torch 中 RK4 的显存：autograd 穿透 N 步积分会保留 O(N) 计算图 → 长时域用伴随法（adjoint）或梯度检查点；
浮点精度地板：实验 5 中 RK4 误差最低到 ~1e-12 即触底（float64 舍入极限），再减小 h 误差反而回升；GPU 训练场景注意 float32 的地板约 1e-7；
保结构问题选专用积分器：长时间哈密顿系统（行星轨道）RK4 仍有微小能量漂移 → 辛积分器（leapfrog/Verlet）更合适；RK4 适合中短时域工程仿真；
事件检测 ：碰撞/到达目标面等条件用 root-finding（solve_ivp 的 events 参数）在步内插值定位，不要靠"刚好落在网格点上"。
高阶 ODE 状态增广两件事 ：初始条件必须给全（ y 0 , y 0 ′ , ... , y 0 ( n − 1 ) y_0, y'_0, \dots, y^{(n-1)}_0 y0,y0′,...,y0(n−1)）；状态顺序必须与伴随形式一致（把 $v , x$ $v, x$ $v,x$ 当 $x , v$ $x, v$ $x,v$ 用 = 解了另一个方程）；
右端函数不连续（控制切换/jerk 跳变）必须分段积分，且每段冻结段内右端函数：否则段末最后一步的 k4 探针落在边界 t=b 上采样到下一段的值，每个跳变点引入 O(h) 误差 → 整体退化 1 阶（实验 11 实测：直接积分误差比 2.0，分段+冻结后精确到 5e-13）；
混沌系统（Lorenz 等）不要追求长时轨迹复现：初值/步长的微小差异指数放大（实验 12：1e-5 初差 21.6s 后轨迹距离 >1）；有意义的是吸引子几何与统计特性。

8. 参考文献

Runge C. Ueber die numerische Auflösung von Differentialgleichungen. Mathematische Annalen, 1895.（龙格原始论文）
Kutta W. Beitrag zur näherungsweisen Integration totaler Differentialgleichungen. Z. Math. Phys., 1901.（库塔给出 RK4 经典形式）
Chen R T Q, et al. Neural Ordinary Differential Equations . NeurIPS 2018 (Best Paper). arXiv:1806.07366
Treiber M, Hennecke A, Helbing D. Congested Traffic States in Empirical Observations and Microscopic Simulations (IDM) . Phys. Rev. E, 2000. arXiv:cond-mat/0002177
Rajamani R. Vehicle Dynamics and Control. Springer, 2012.（自行车模型/车辆动力学标准参考）
Song J, et al. Denoising Diffusion Implicit Models (DDIM) . ICLR 2021. arXiv:2010.02502；Lu C, et al. DPM-Solver . NeurIPS 2022. arXiv:2206.00927（扩散采样器 = ODE 积分器）
Dormand J R, Prince P J. A family of embedded Runge-Kutta formulae. J. Comput. Appl. Math., 1980.（自适应 RK45）

本文所有实验数字均为 RTX 5070 Ti Laptop / PyTorch 2.14+cu130 实际运行输出，随机种子已固定，可直接复现。配图共 9 张（figures/rk4_*.png），发布时上传 CSDN 图床后按第 5 章清单插入。

标签：数值分析 Runge-Kutta ODE 深度学习 Neural ODE 智能驾驶 MPC 卡尔曼滤波 交通仿真 PyTorch