用manim证明函数的左右极限

http://t.csdnimg.cn/2pVdFhttp://t.csdnimg.cn/2pVdF在上一节的最后两个示例中，我们看到了两个不存在的限制。然而，对于每个例子来说，每个限制不存在的原因是不同的。

我们看一下下面的例子：

$\mathop {\lim }\limits_{t \to 0} \,\,\cos \left( {\frac{\pi }{t}} \right)$

极限不存在，因为函数没有固定为单个值 t 走近 t=0。越接近 t=0 我们移动得越厉害，函数振荡得越厉害，为了存在一个极限，函数必须稳定到一个单一的值。

from manim import *  

class CosLimit(Scene):  
    def construct(self):  
        # 设置坐标轴  
        axes = Axes(  
            x_range=[-0.25, 0.25, 0.1],  # x 显示范围  
            y_range=[-1, 1.5, 1],        # y 显示范围  
            axis_config={"color": BLUE},  # 坐标轴颜色  
        )  
        
        # 创建函数: cos(pi/t)  
        cos_function = axes.plot(lambda t: np.cos(np.pi / t), x_range=[-0.5, 0.5], color=RED,stroke_width=5)  
        
        # 标签设置  
        function_label = axes.get_graph_label(cos_function, label='\\cos\\left(\\frac{\\pi}{t}\\right)')  
        
        # 添加坐标轴和函数到场景中  
        self.play(Create(axes), Create(cos_function), Write(function_label))  
        self.wait(2)  # 等待 2 秒以观察结果  

        # 创建两个点  
        point1 = Dot(axes.c2p(0.1, np.cos(np.pi / 0.1)), color=RED)  # 第一个点的初始位置  
        point2 = Dot(axes.c2p(-0.1, np.cos(np.pi / -0.1)), color=GREEN)  # 第二个点的初始位置  
        
        # 添加点到场景  
        self.play(Create(point1), Create(point2))  
        self.wait(1)  # 等待 1 秒以观察点  

        # 动画：使两个点移动到极限位置 (0, np.cos(+-inf))  
        self.play(  
            point1.animate.move_to(axes.c2p(0, 1)),  # 第一个点移动到 (0, 1)  
            point2.animate.move_to(axes.c2p(0, 1)),  # 第二个点移动到 (0, 1)  
            run_time=3  # 动画运行时间  
        )  
        self.wait(2)  # 等待 2 秒以观察点的移动  

        # 结束场景  
        self.play(FadeOut(axes), 
                  FadeOut(cos_function), FadeOut(function_label),
                  FadeOut(point1), FadeOut(point2))

运行结果：

接下来优化一下改代码：

from manim import *  

class CosLimitFollow(Scene):  
    def construct(self):  
        # 设置坐标轴  
        axes = Axes(  
            x_range=[-0.5, 0.5, 0.1],  # x 显示范围  
            y_range=[-1, 1, 1],        # y 显示范围  
            axis_config={"color": BLUE},  # 坐标轴颜色  
        )  
        
        # 创建函数: cos(pi/t)  
        cos_function = axes.plot(lambda t: np.cos(np.pi / t), x_range=[-0.5, 0.5], color=WHITE)  
        
        # 标签设置  
        function_label = axes.get_graph_label(cos_function, label='\\cos\\left(\\frac{\\pi}{t}\\right)')  
        
        # 添加坐标轴和函数到场景中  
        self.play(Create(axes), Create(cos_function), Write(function_label))  
        self.wait(2)  # 等待 2 秒以观察结果  

        # 根据函数设置点的起始位置  
        t1 = 0.1  # 第一个点的初始 t 值  
        t2 = -0.1  # 第二个点的初始 t 值  
        point1 = Dot(axes.c2p(t1, np.cos(np.pi / t1)), color=RED)  # 第一个点在初始位置  
        point2 = Dot(axes.c2p(t2, np.cos(np.pi / t2)), color=GREEN)  # 第二个点在初始位置  
        
        # 添加点到场景  
        self.play(Create(point1), Create(point2))  
        self.wait(1)  # 等待 1 秒以观察点  

        # 动画：使两个点沿着函数移动，分别朝向 t = 0  
        self.play(  
            point1.animate.move_to(axes.c2p(0.1, np.cos(np.pi / 0.1))),  # 第一个点沿 x = 0.1 移动  
            point2.animate.move_to(axes.c2p(-0.1, np.cos(np.pi / -0.1))),  # 第二个点沿 x = -0.1 移动  
            run_time=3  # 动画运行时间  
        )  

        # 设置持续时间，让点在轨迹上移动  
        t_values = np.linspace(0.1, 0, 100)  # 针对第一个点，t 从 0.1 值线性变化到 0  
        point1_path = [axes.c2p(t, np.cos(np.pi / t)) for t in t_values]  # 创建路径  
        
        t_values = np.linspace(-0.1, 0, 100)  # 针对第二个点，t 从 -0.1 线性变化到 0  
        point2_path = [axes.c2p(t, np.cos(np.pi / t)) for t in t_values]  # 创建路径  

        # 沿着轨迹移动点  
        point1.animate.move_to(point1_path[-1])  # 移动到极限位置  
        point2.animate.move_to(point2_path[-1])  # 移动到极限位置  
        
        # 移动动画  
        self.play(  
            *[point1.animate.move_to(point) for point in point1_path],   
            *[point2.animate.move_to(point) for point in point2_path],   
            run_time=6  # 总移动时间  
        )  

        self.wait(2)  # 等待 2 秒以观察点的移动  

        # 结束场景  
        self.play(FadeOut(axes), FadeOut(cos_function), 
                  FadeOut(function_label), 
                  FadeOut(point1), FadeOut(point2))

然而，我们看一下面的内容，

$\mathop {\lim }\limits_{t \to 0} H\left( t \right)\hspace{0.25in}{\mbox{where,}}\hspace{0.25in}H\left( t \right) = \left\{ \begin{array}{ll}0 & {\mbox{if }}t < 0\\ 1 & {\mbox{if }}t \ge 0\end{array} \right.$

它极限不存在，是因为当我们向 t 移动时函数没有稳定到一个数字 t=0 而是因为它取决于 t 的哪一边，变成了两个不同的数。

我们看一下它的图像。下面是用 Manim 库实现你所要求的阶跃函数 H(t) 的图像，

from manim import *  

class StepFunctionLimit10(Scene):  
    def construct(self):  
        # 设置坐标轴  
        axes = Axes(  
            x_range=[-1, 1, 0.5],  # x 显示范围  
            y_range=[-0.5, 1.5, 1],  # y 显示范围  
            axis_config={"color": BLUE},  # 坐标轴颜色  
        ).add_coordinates()  
        
        # 定义阶跃函数 H(t)  
        def H0(t):  
            return 0   # H(t) 定义为阶跃函数 
        
        def H1(t):  
            return 1   # H(t) 定义为阶跃函数 
        
        
        
        # 创建阶跃函数的离散图像  
        step_graph = axes.plot(lambda t: H0(t), x_range=[-1, 0], color=RED, use_smoothing=False)
        
        step_graph1 = axes.plot(lambda t: H1(t), x_range=[0, 1], color=RED, use_smoothing=False) 
        
        
        
        # 防止函数线段连起来，添加跳跃  
        self.play(Create(axes), Create(step_graph),Create(step_graph1))  # 添加坐标轴和阶跃函数到场景中  
        self.wait(2)  # 等待 2 秒以观察结果  
        
        texM=MathTex(r"\hspace{0.25in}H\left( t \right) = \left\{ \begin{array}{ll}0 & {\mbox{if }}t < 0\\ 1 & {\mbox{if }}t \ge 0\end{array}\right.")
        texM.set_color(BLUE).move_to(axes.c2p(-0.5, 1))
        self.add(texM)
        # 创建两个点，分别在函数的不同位置  
        point1 = Dot(axes.c2p(-0.5, H0(-0.5)), color=WHITE)  # 第一个点的初始位置  
        point2 = Dot(axes.c2p(0.5, H1(0.5)), color=GOLD)  # 第二个点的初始位置  
        
        # 添加点到场景  
        self.play(Create(point1), Create(point2))  
        self.wait(1)  # 等待 1 秒以观察点的变化  

        # 动画：使两个点同时走向极限位置 (0, 1)  
        self.play(  
            point1.animate.move_to(axes.c2p(0, H0(0))),  # 第一个点移动到 (0, 1)  
            point2.animate.move_to(axes.c2p(0, H1(0))),  # 第二个点移动到 (0, 1)  
            run_time=3  # 动画运行时间  
        )  

        self.wait(2)  # 等待 2 秒以观察点的移动  

        # 结束场景  
        self.play(FadeOut(axes), FadeOut(step_graph), FadeOut(point1), FadeOut(point2))

在这种情况下，函数是一个很好的函数，不像第一个函数。唯一的问题是，当我们接近 t 时 t=0，函数向两边的不同数字移动。我们想要一种方法来区分这两个例子。

我们用片面的限制来做这件事。顾名思义，由于片面的限制，我们将只看到所讨论点的一面。下面是两个单面极限的定义。

右边的极限

定义：

$f(a+0)=\lim_{x \to a^{ +} } f(x)=L$

$\forall \epsilon >0 ,\exists \delta >0,\forall x ,0<x-a<\delta$ 有 $|f(x)-A|<\epsilon$

前提是我们能使 f(x）的值差不多 L 对于所有的x足够接近a 与 x > a,而不让x是a

左边的极限

定义：

$f(a-0)=\lim_{x \to a^{ -} } f(x)=L$

$\forall \epsilon >0 ,\exists \delta >0,\forall x ,-\delta<x-a<0$ 有 $|f(x)-A|<\epsilon$

前提是我们能使 f(x）的值差不多 L 对于所有的x足够接近a 与 x< a,而不让x是a

注意，符号的变化非常小，如果您不注意，实际上可能会错过。唯一的区别是位在限制的“lim”部分之下。对于右极限 $x \mapsto a^{+}$ ,(注意“+”)这意味着我们知道只会看 x>a 。同样的，对于右极限 $x \mapsto a^{1}$ ,(注意“-”)这意味着我们知道只会看 x<a。