做物理模拟动画时,我遇到过一个坑。
当时想做一个弹簧振子的 Manim 动画:一个小球连接在弹簧上,在平衡位置附近往复振动。
我一开始的思路是——手动写欧拉法迭代。
1 2 3 4 5 6 7 8 9 10 11 12 13
| x = 1.0 v = 0.0 dt = 0.02 k = 2.0 m = 1.0
positions = [] for i in range(300): a = -k/m * x v += a * dt x += v * dt positions.append(x)
|
这段代码跑起来之后,小球确实动起来了。但看了几秒之后——小球越振幅度越大,能量明显不守恒。
欧拉法的数值误差在逐帧累积,像个隐形的外力在不断推着小球。
我当然可以换龙格-库塔法,但那意味着更复杂的代码、更长的调试时间。我只是想做一个弹簧振子动画,为什么要从数值分析开始写起?
直到我开始用 SymPy 的 dsolve,才发现原来我根本不需要自己写数值积分。
1. 痛点场景还原
在 Manim 中做物理模拟动画,常见的“手工数值积分”方案有三大痛点:
| 痛点 |
具体表现 |
| 数值误差累积 |
欧拉法能量不守恒,弹簧振子越振越离谱 |
| 步长调参折磨 |
dt 设太小渲染慢,设太大精度炸,反复试错 |
| 无法利用解析解 |
明明简谐振子有精确的 cos(ωt) 解析表达式,却硬要用数值去逼近 |
更关键的是,Manim 的动画是基于 ValueTracker 的时间驱动的。
我们真正需要的是一个函数 x(t),能根据当前时刻 t 精确返回小球的位置。
这和 SymPy 的解析解简直是天作之合。
1 2 3 4
| def get_position(t): return ???
|
SymPy 的 dsolve 可以帮我们求出这个解析的 x(t),然后通过 lambdify 把它转成 NumPy 函数,直接注入 ValueTracker 的更新逻辑中。全程无误差累积,因为每一帧的位置都是独立计算的。
2. SymPy 解决方案
2.1 dsolve:符号求解微分方程
SymPy 的 dsolve 可以求解常微分方程(ODE)的解析解。以弹簧振子(简谐振动)为例:
运动方程:mdt2d2x+kx=0,即 dt2d2x+ω02x=0,其中 ω0=mk 是系统的固有角频率。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
| import sympy as sp
t = sp.Symbol('t', real=True) x = sp.Function('x')(t) m, k = sp.symbols('m k', positive=True) omega = sp.sqrt(k/m)
ode = sp.Eq(m * sp.diff(x, t, 2) + k * x, 0)
initial_conditions = { x.subs(t, 0): 1, sp.diff(x, t).subs(t, 0): 0 }
solution = sp.dsolve(ode, ics=initial_conditions) print(solution)
|
SymPy 直接给出了解析解:x(t)=cos(ωt),这就是我们熟知的简谐振动公式。
2.2 lambdify:符号表达式 → 高性能数值函数
有了符号表达式 x(t)=cos(ωt),下一步是把它变成 Manim 可以每秒调用几十次的快速函数。lambdify 就是干这个的:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
| import numpy as np
x_expr = solution.rhs
x_expr_sub = x_expr.subs({k: 4, m: 1})
x_func = sp.lambdify(t, x_expr_sub, modules='numpy')
print(x_func(0)) print(x_func(np.pi/4)) print(x_func(np.pi/2))
|
lambdify 的三个关键优势:
- 速度快:底层转成 NumPy 运算,支持向量化,比 SymPy 的
.subs() 快几个数量级
- 无缝衔接:返回的就是标准 Python 可调用对象,直接用在任何需要函数的地方
- 支持数组输入:可以一次计算整段时间的所有位置,便于做轨迹预览
2.3 扩展到阻尼振动和单摆
对于更复杂的微分方程,dsolve + lambdify 的组合依然好用:
欠阻尼振动(dt2d2x+2βdtdx+ω02x=0):
1 2 3 4 5 6 7 8 9 10 11 12
| beta, omega0 = sp.symbols('beta omega0', positive=True)
ode_damped = sp.Eq(sp.diff(x, t, 2) + 2*beta*sp.diff(x, t) + omega0**2*x, 0) sol_damped = sp.dsolve(ode_damped, ics={ x.subs(t, 0): 1, sp.diff(x, t).subs(t, 0): 0 })
x_damped_expr = sol_damped.rhs.subs({beta: 0.3, omega0: 2}) x_damped_func = sp.lambdify(t, x_damped_expr, 'numpy')
|
小角度单摆(θ′′+Lgsin(θ)=0,小角度近似 sin(θ)≈θ):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
| g_val, L_val = 9.8, 2.0 omega = sp.sqrt(g_val/L_val)
A, B = sp.symbols('A B') theta_expr = A * sp.cos(omega * t) + B * sp.sin(omega * t)
theta_0 = sp.pi / 6 dtheta_expr = sp.diff(theta_expr, t)
eq1 = sp.Eq(theta_expr.subs(t, 0), theta_0)
eq2 = sp.Eq(dtheta_expr.subs(t, 0), 0)
solution = sp.solve([eq1, eq2], [A, B]) print(f"A = {solution[A]}, B = {solution[B]}")
theta_final = theta_expr.subs(solution) print(f"θ(t) = {theta_final}")
theta_func = sp.lambdify(t, theta_final, 'numpy')
|
3. Manim 联动实战
下面是一个弹簧振子动画的核心代码示例。
核心思路是:**用 SymPy 解出 **x(t),用 lambdify 转成快速函数,再通过 ValueTracker 的追踪器模式驱动小球运动。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
| from manim import * import sympy as sp import numpy as np class SpringOscillator(Scene): def construct(self): t_sym = sp.Symbol("t", real=True) m_sym, k_sym = sp.symbols("m k", positive=True) A, B = sp.symbols("A B") omega = sp.sqrt(k_sym / m_sym) x_expr = A * sp.cos(omega * t_sym) + B * sp.sin(omega * t_sym) eq1 = sp.Eq(x_expr.subs(t_sym, 0), 2) eq2 = sp.Eq(sp.diff(x_expr, t_sym).subs(t_sym, 0), 0) sol_const = sp.solve([eq1, eq2], [A, B]) x_final = x_expr.subs(sol_const).subs({m_sym: 1, k_sym: 4}) x_func = sp.lambdify(t_sym, x_final, "numpy") number_line = NumberLine(x_range=[-3, 3, 1], length=8).shift(DOWN * 1.5) self.play(Create(number_line)) fixed_point = number_line.number_to_point(-3) + UP * 0.8 ball = Circle(radius=0.2, color=RED, fill_opacity=0.8) ball.move_to(number_line.number_to_point(x_func(0)) + UP * 0.8) self.play(DrawBorderThenFill(ball)) time_tracker = ValueTracker(0) ball.add_updater(lambda m: m.set_x( number_line.number_to_point( x_func(time_tracker.get_value()) )[0] )) self.play( time_tracker.animate.set_value(5), run_time=5, rate_func=linear, ) self.wait(1)
|
4. 效果展示说明
运行上面的脚本,你会看到这样的动画流程:
观察重点:
- 小球的运动完全符合余弦规律:在两端停顿、中间最快,完美再现简谐振动
- 弹簧长度随小球位置实时变化,视觉上非常自然
- 整个过程没有任何数值积分代码——你写的只是方程和初始条件,剩下的交给
SymPy
换成阻尼振动有多容易?
只需要改两行代码:
1 2 3 4 5
| ode_damped = sp.Eq( sp.diff(x_sym, t_sym, 2) + 0.6*sp.diff(x_sym, t_sym) + 4*x_sym, 0 )
|
小球的振幅会逐渐减小,直到停在平衡位置。而这一切,你不需要修改任何动画逻辑——因为 x_func 这个黑盒函数的内部实现已经被 SymPy 替换了。
5. 本期小结
核心公式:dsolve → lambdify → ValueTracker
| 步骤 |
工具 |
作用 |
| 1. 定义微分方程 |
sp.Eq(sp.diff(...)) |
用符号表达物理规律 |
| 2. 求解析解 |
sp.dsolve(ode, ics=...) |
得出 x(t) 的封闭表达式 |
| 3. 编译为快函数 |
sp.lambdify(t, expr, 'numpy') |
符号表达式 → 每秒可调用千次的 NumPy 函数 |
| 4. 驱动 Manim 动画 |
ValueTracker + add_updater |
每帧把虚拟时间 t 喂给函数,更新物体位置 |
主观感受,仅供参考。本文采用 本文采用 CC BY-NC-SA 4.0 许可 协议,
完整转载请注明来自
数学动画引擎。