Python使用SymPy自动计算抛物线求根、判别式与顶点

from manim import *
import math

class PainfulDemo(Scene):
    def construct(self):
        a, c = 1, 2
        b_tracker = ValueTracker(-3)
        axes = Axes(x_range=[-5,5], y_range=[-1,6])

        # 抛物线
        graph = always_redraw(lambda: axes.plot(
            lambda x: a*x**2 + b_tracker.get_value()*x + c
        ))

        # 计算交点 —— 这里就是噩梦开始的地方
        def get_roots():
            b = b_tracker.get_value()
            disc = b**2 - 4*a*c
            if disc >= 0:
                root1 = (-b + math.sqrt(disc)) / (2*a)   # 负数平方根直接报错
                root2 = (-b - math.sqrt(disc)) / (2*a)
                return [root1, root2]
            else:
                return []  # 如果忘了判断，上面一行就炸了

        dots = always_redraw(lambda: VGroup(*[
            Dot(axes.coords_to_point(r, 0)) for r in get_roots()
        ]))
        self.add(axes, graph, dots)
        self.play(b_tracker.animate.set_value(3), run_time=5)
        self.wait(1)

import sympy as sp

x = sp.Symbol('x', real=True)
a_val, c_val = 1, 2
b_sym = sp.Symbol('b')

# 定义二次函数
expr = a_val * x**2 + b_sym * x + c_val

# 1. 判别式
delta = b_sym**2 - 4 * a_val * c_val   # b² - 8

# 2. 求根 —— 一行搞定，自动给出含根号的精确解
roots = sp.solve(expr, x)              
# 输出：[-b/2 - sqrt(b**2 - 8)/2, -b/2 + sqrt(b**2 - 8)/2]

# 3. 求顶点（导数求极值）
vertex_x = sp.solve(sp.diff(expr, x), x)[0]   # -b/2
vertex_y = expr.subs(x, vertex_x)             # 代入得到顶点纵坐标

from manim import *
import sympy as sp

class QuadraticRootDance(Scene):
    def construct(self):
        # ========== SymPy 符号准备 ==========
        x_sym = sp.Symbol("x", real=True)
        a_val, c_val = 1, 2  # 固定 a, c，只让 b 变化
        b_sym = sp.Symbol("b")
        expr = a_val * x_sym**2 + b_sym * x_sym + c_val

        # 判别式表达式
        delta_expr = b_sym**2 - 4 * a_val * c_val  # b² - 8
        # 顶点 x 坐标（求导）
        vertex_x_expr = sp.solve(sp.diff(expr, x_sym), x_sym)[0]  # -b/2
        # 顶点 y 坐标
        vertex_y_expr = expr.subs(x_sym, vertex_x_expr)

        # ========== Manim 场景搭建 ==========
        axes = Axes(
            x_range=[-5, 5, 1],
            y_range=[-1, 7, 1],
            axis_config={"include_numbers": True, "font_size": 18},
            tips=False,
        ).add_coordinates()
        self.play(Create(axes))

        b_tracker = ValueTracker(-3)  # b 初始值 -3

        # 抛物线：always_redraw 保证系数一更新图像就重绘
        graph = always_redraw(
            lambda: axes.plot(
                lambda x: a_val * x**2 + b_tracker.get_value() * x + c_val, color=BLUE
            )
        )
        self.add(graph)

        # 交点集合（实心圆点）
        roots_dots = always_redraw(
            lambda: self.get_roots_dots(axes, b_tracker, x_sym, expr)
        )
        self.add(roots_dots)

        # 顶点标记
        vertex_dot = always_redraw(
            lambda: self.get_vertex_dot(axes, b_tracker, vertex_x_expr, vertex_y_expr)
        )
        self.add(vertex_dot)

        # 动态文本：判别式 & 交点个数
        info_text = always_redraw(
            lambda: self.get_info_text(b_tracker, delta_expr, x_sym, expr)
        )
        info_text.to_corner(UR)
        self.add(info_text)

        # 动画：b 从 -3 滑到 3
        self.play(b_tracker.animate.set_value(3), run_time=5, rate_func=linear)
        self.wait()

    # ---------- 辅助方法（内部封装 SymPy 计算）----------
    def get_roots_dots(self, axes, tracker, x_sym, expr):
        """返回当前参数下所有实根对应的 Dot"""
        b_val = tracker.get_value()
        # 用 SymPy 解方程，并数值化
        roots = sp.solve(expr.subs("b", b_val), x_sym)
        real_roots = []
        for r in roots:
            r_num = complex(r.evalf())  # 转为 Python 复数判断虚实
            if abs(r_num.imag) < 1e-8:  # 虚部为 0 -> 实根
                real_roots.append(r_num.real)
        # 为每个实根创建红点
        dot_group = VGroup()
        for rx in real_roots:
            dot_group.add(Dot(axes.coords_to_point(rx, 0), color=RED))
        return dot_group

    def get_vertex_dot(self, axes, tracker, vx_expr, vy_expr):
        """返回顶点位置的 Dot"""
        b_val = tracker.get_value()
        vx = float(vx_expr.subs("b", b_val).evalf())
        vy = float(vy_expr.subs("b", b_val).evalf())
        return Dot(axes.coords_to_point(vx, vy), color=YELLOW)

    def get_info_text(self, tracker, delta_expr, x_sym, expr):
        """生成判别式与交点个数的信息文本"""
        b_val = tracker.get_value()
        delta_val = float(delta_expr.subs("b", b_val).evalf())
        # 判断实根个数（用 solve 求全部根，再筛实根）
        roots = sp.solve(expr.subs("b", b_val), x_sym)
        real_count = sum(1 for r in roots if abs(complex(r.evalf()).imag) < 1e-8)

        text1 = MathTex(
            f"\\Delta = {delta_val:.2f}",
            tex_to_color_map={f"\\Delta = {delta_val:.2f}": GREEN},
            font_size=24,
        )
        text2 = MathTex(
            f"\\text{{交点个数：}}{real_count}",
            tex_template=TexTemplateLibrary.ctex,
            font_size=24,
        )
        text = VGroup(text1, text2).arrange(RIGHT, buff=1).shift(UP)
        return text