Python使用SymPy自动求解追及问题的方程

class PainfulCatchUp(Scene):
    def construct(self):
        # 手动列方程并求解
        # 设 t 为乙出发后的时间，甲的位置：2*(t+?)，乙的位置：10+5*t
        # 如果同时出发：2t = 10+5t → t = -10/3 负数无意义
        # 改甲先出发2秒：2(t+2) = 10+5t → 2t+4=10+5t → -3t=6 → t=-2 还是负
        # 必须反复调整题设，手算满足实际情况的初始条件
        # 这里干脆让乙追甲，甲在乙前面：
        # 甲在x=10以v=2向前，乙在x=0以v=5同时出发 → 5t = 10+2t → 3t=10 → t=10/3
        v1, v2 = 2, 5
        t_meet = 10/3   # 手动解出的结果
        meet_x = 5 * t_meet  # 再手动算相遇位置

        # 甲和乙的轨迹只能硬编码
        def pos1(t):
            return 10 + v1 * t
        def pos2(t):
            return v2 * t

        # 然后创建动画……

import sympy as sp

# 符号定义：t 为乙出发后经过的时间
t = sp.symbols('t', positive=True)
v1, v2 = 2, 5          # 速度
s0 = 10                # 初始距离（甲在乙前面10米）

# 甲的位置：先出发0秒（即同时出发），位置 = s0 + v1*t
pos1 = s0 + v1 * t
# 乙的位置：从0开始，位置 = v2*t
pos2 = v2 * t

# 相遇条件：位置相等
eq = sp.Eq(pos1, pos2)
solution = sp.solve(eq, t)
# 输出: [10/3]

t_delay = 2  # 甲早出发2秒
pos1 = s0 + v1 * (t + t_delay)   # 甲多走2秒
eq = sp.Eq(pos1, pos2)
solution = sp.solve(eq, t)
# 输出: [14/3]

from manim import *
import sympy as sp


class CatchUpLab(Scene):
    def construct(self):
        # ========== 题目参数（任意修改这里即可） ==========
        v1 = 1.5  # 甲的速度
        v2 = 2.5  # 乙的速度
        init_gap = 8  # 初始距离（甲在乙前面）
        delay = 1  # 甲早出发的时间

        # ========== SymPy 自动求解 ==========
        t = sp.symbols("t", positive=True)
        pos1_expr = init_gap + v1 * (t + delay)  # 甲的位置
        pos2_expr = v2 * t  # 乙的位置
        eq = sp.Eq(pos1_expr, pos2_expr)
        t_meet = sp.solve(eq, t)[0]  # 精确解
        meet_x = float(pos2_expr.subs(t, t_meet))  # 相遇位置

        # 为了动画流畅，预先计算两个运动函数（可以直接用lambda）
        def pos1_func(time):
            return init_gap + v1 * (time + delay)

        def pos2_func(time):
            return v2 * time

        # ========== 场景搭建 ==========
        axes = NumberLine(
            x_range=[0, 30, 5],
            length=8,
            include_numbers=True,
            label_direction=DOWN,
        )
        self.play(Create(axes))

        # 甲和乙的点
        dot1 = Dot(color=RED, radius=0.2)
        dot2 = Dot(color=BLUE, radius=0.2)
        # 初始放置
        dot1.move_to(axes.number_to_point(pos1_func(0)))
        dot2.move_to(axes.number_to_point(pos2_func(0)))
        self.add(dot1, dot2)

        # 标签
        label1 = Text("甲", color=RED).next_to(dot1, UP * 2)
        label2 = Text("乙", color=BLUE).next_to(dot2, UP * 2)
        self.add(label1, label2)

        # 轨迹虚线（预留）
        trace1 = TracedPath(dot1.get_center, stroke_color=RED, stroke_width=2)
        trace2 = TracedPath(dot2.get_center, stroke_color=BLUE, stroke_width=2)
        self.add(trace1, trace2)

        # 相遇点标记（先隐藏，等追到时再显示）
        meet_dot = Dot(point=axes.number_to_point(meet_x), color=YELLOW)
        meet_label = Text(f"相遇点: {meet_x:.2f}", font_size=24, color=YELLOW)
        meet_label.next_to(meet_dot, UP * 1.5)

        # 动态更新的时间显示
        time_text = MathTex("t=0.0").shift(UL * 2)
        self.add(time_text)

        # 追击动画
        total_time = float(t_meet) + 2  # 多跑2秒

        def update_dots(mob, alpha):
            # alpha 从0到1，对应时间从0到total_time
            t_now = alpha * total_time
            dot1.move_to(axes.number_to_point(pos1_func(t_now)))
            dot2.move_to(axes.number_to_point(pos2_func(t_now)))
            # 更新标签位置
            label1.next_to(dot1, UP * 2)
            label2.next_to(dot2, UP * 2)
            # 更新时间显示
            time_text.become(MathTex(f"t={t_now:.1f}").shift(UL * 2))
            # 判断是否到达相遇点
            if t_now >= float(t_meet):
                self.add(meet_dot, meet_label)  # 显示相遇标记

        self.play(
            UpdateFromAlphaFunc(
                VGroup(dot1, dot2, label1, label2, time_text),
                update_dots,
                run_time=total_time,
                rate_func=linear,
            )
        )
        self.wait(1)