极限的性质【上】《用Manim可视化》

通过前面的极限的定义，现在是计算极限的时候了。然而，在此之前，我们需要一些极限的性质，这将使我们的工作变得简单一些。我们先来看看这些。

极限的性质：

1.常数对极限的影响

1.首先，我们假设 $\mathop {\lim }\limits_{x \to a} f\left( x \right)$ 和 $\mathop {\lim }\limits_{x \to a}g\left( x \right)$ 存在，那就是c是常数，那

$\mathop {\lim }\limits_{x \to a} \left[ {cf\left( x \right)} \right] = c\mathop {\lim }\limits_{x \to a} f\left( x \right)$

换句话说，我们可以将一个乘法常数从极限中“分解”出来。

通过一下图像都能证实上面的性质。但前提是，该函数在极限位置存在极限。

实现代码：

from manim import *  

class LimitVisualization(Scene):  
    def construct(self):  
        # 创建坐标轴  
        axes = Axes(  
            x_range=[-1, 7, 1],  # x轴范围从-1到7，步长为1  
            y_range=[-1, 7, 1],  # y轴范围从-1到7，步长为1  
            axis_config={"color": BLUE},  # 坐标轴颜色设置为蓝色  
        )  

        # 定义函数 f(x) 及其缩放版本 cf(x)  
        def f(x):  
            return x**2 - 1  # 这里定义了一个简单的二次函数 f(x)  

        c = 3  # 常数乘数  
        def cf(x):  
            return c * f(x)  # 定义缩放过的函数 cf(x)  

        # 创建图形  
        f_graph = axes.plot(f, color=YELLOW, x_range=[-1, 9])  # 绘制 f(x) 的图形，颜色为黄色  
        cf_graph = axes.plot(cf, color=RED, x_range=[-1, 9])  # 绘制 cf(x) 的图形，颜色为红色  

        # 创建标签  
        f_label = axes.get_graph_label(f_graph, label='f(x)', x_val=3)  # 给 f(x) 添加标签  
        cf_label = axes.get_graph_label(cf_graph, label='cf(x)', x_val=2)  # 给 cf(x) 添加标签  

        # 在极限点 a 创建一个点  
        a = 1.5  # 定义 x 接近的点  
        limit_dot_f = Dot(axes.c2p(a, f(a)), color=YELLOW)  # f(a) 处的点，颜色为黄色  
        limit_dot_cf = Dot(axes.c2p(a, cf(a)), color=RED)  # cf(a) 处的点，颜色为红色  
        f01 = f(a)  # 计算 f(a) 的值  
        f02 = cf(a)  # 计算 cf(a) 的值  

        # 创建极限值的注释  
        limit_text_f = MathTex(r"\lim_{x \to a} f(x) = ", f01).next_to(limit_dot_f, RIGHT)  # f(x) 的极限注释  
        limit_text_cf = MathTex(r"\lim_{x \to a} cf(x) = ", f02).next_to(limit_dot_cf, RIGHT)  # cf(x) 的极限注释  
        
        # 添加关于 c 的说明  
        tex = MathTex(r"\lim_{x \to a} cf(x) = c\lim_{x \to a} f(x)  \\ c=3 ", color=GOLD).next_to(axes.c2p(4, 3 + 3))  
        self.add(tex)  # 将 c 的文本添加到场景中  

        # 将所有元素添加到场景中  
        self.play(Create(axes), Create(f_graph), Create(cf_graph))  # 创建坐标轴和函数图形  
        self.play(Write(f_label), Write(cf_label))  # 写入标签  
        self.play(Create(limit_dot_f), Create(limit_dot_cf))  # 创建极限点  
        self.play(Write(limit_text_f), Write(limit_text_cf))  # 写入极限值注释  

        # 等待展示极限点  
        self.wait(2)  

        # 高亮显式极限值  
        self.play(limit_dot_f.animate.set_color(ORANGE), limit_dot_cf.animate.set_color(ORANGE))  # 将极限点颜色改为橙色  
        self.wait(2)  

        # 淡出所有元素  
        self.play(FadeOut(axes), FadeOut(f_graph), FadeOut(cf_graph), FadeOut(limit_dot_f), FadeOut(limit_dot_cf), FadeOut(limit_text_f), FadeOut(limit_text_cf))

代码解释：

导入库：首先导入Manim库，为后续绘图准备。
创建场景：定义了一个名为LimitVisualization的类，继承自Scene，表示一个图形场景。
构建设备：construct方法用于构建整个场景，包括图表、文本等。
创建坐标轴：调用Axes类创建坐标轴，设置x和y的范围及颜色。
定义函数：定义了函数f(x)和其缩放形式cf(x)。这里，f(x)是一个简单的二次函数。
绘制图表：使用plot方法绘制两条函数曲线。
创建标签：给每条曲线添加标签，以便于识别。
绘制极限点：在定义的点a的横坐标处绘制两个极限点，分别对应f(a)和cf(a)的值。
添加极限值注释：在极限点旁边添加文本显示极限的实际值，同时展示常数c的影响。
动态展示：使用play方法依次展示坐标轴、图形、标签和极限点等元素，并设置等待时间。
高亮极限点：在等待后，将极限点颜色高亮显示，以便更好地观察。
淡出效果：最后，使用FadeOut方法将所有元素逐步淡出，完成动画的呈现。

2.函数极限的相加

假设 $\mathop {\lim }\limits_{x \to a} f\left( x \right)$ 和 $\mathop {\lim }\limits_{x \to a}g\left( x \right)$ 存在，那么

$\mathop {\lim }\limits_{x \to a} \left[ {f\left( x \right) \pm g\left( x \right)} \right] = \mathop {\lim }\limits_{x \to a} f\left( x \right) \pm \mathop {\lim }\limits_{x \to a} g\left( x \right)$

所以，要求和或差的极限我们需要做的就是求各个部分的极限然后用合适的符号把它们组合在一起。这也不局限于两个函数。无论我们用“+”或“-”分隔多少函数，这个事实都是有效的。

通过一下图像都能证实上面的性质。但前提是，该函数在极限位置存在极限。

实现代码：

from manim import *  

class LimitPropertyVisualization(Scene):  
    def construct(self):  
        # 创建坐标轴  
        axes = Axes(  
            x_range=[-1, 4,0.5],  
            y_range=[-6, 9, 1],
            y_length=8,
            axis_config={"color": BLUE},  
        )  

        # 定义函数 f(x) 和 g(x)  
        def f(x):  
            return x**2 - 1  

        def g(x):  
            return x**3 - 4*x - 1  

        # 定义常量 a  
        a =1.5  # 所考察的点  

        # 创建图形  
        f_graph = axes.plot(f, color=YELLOW, x_range=[0, 3])  
        g_graph = axes.plot(g, color=RED, x_range=[0, 3])  

        # 计算极限值  
        limit_f_a = f(a)  
        limit_g_a = g(a)  
        limit_sum_a = limit_f_a + limit_g_a  

        # 创建合并函数的图形  
        combined_graph = axes.plot(lambda x: f(x) + g(x), color=GREEN, x_range=[0, 3])  

        # 创建极限点  
        limit_dot_f = Dot(axes.c2p(a, limit_f_a), color=YELLOW)  
        limit_dot_g = Dot(axes.c2p(a, limit_g_a), color=RED)  
        limit_dot_sum = Dot(axes.c2p(a, limit_sum_a), color=GREEN)
        LiD=Dot(axes.c2p(1.5,0),radius=0.15,color=RED)
        self.add(LiD)

        # 创建极限值注释  
        limit_text_f = MathTex(r"\lim_{x \to a} f(x) = ", limit_f_a).next_to(limit_dot_f, RIGHT)  
        limit_text_g = MathTex(r"\lim_{x \to a} g(x) = ", limit_g_a).next_to(limit_dot_g, RIGHT)  
        limit_text_sum = MathTex(r"\lim_{x \to a} (f(x) + g(x)) = ", limit_sum_a).next_to(limit_dot_sum, UR)  

        # 添加所有元素  
        self.play(Create(axes), Create(f_graph), Create(g_graph))  
        self.play(Create(combined_graph))  
        self.play(Create(limit_dot_f), Create(limit_dot_g), Create(limit_dot_sum))  
        self.play(Write(limit_text_f), Write(limit_text_g), Write(limit_text_sum))  

        # 等待展示  
        self.wait(2)  

        # 高亮极限点  
        self.play(limit_dot_f.animate.set_color(ORANGE), limit_dot_g.animate.set_color(ORANGE), limit_dot_sum.animate.set_color(ORANGE))  
        self.wait(2)  

        # 淡出所有元素  
        self.play(FadeOut(axes), FadeOut(f_graph), FadeOut(g_graph), FadeOut(combined_graph),  
                  FadeOut(limit_dot_f), FadeOut(limit_dot_g), FadeOut(limit_dot_sum),  
                  FadeOut(limit_text_f), FadeOut(limit_text_g), FadeOut(limit_text_sum))

代码解释：

导入库：使用Manim库进行动画生成。
创建类：定义类LimitPropertyVisualization，继承自Scene，表示一个动画场景。
构建坐标轴：创建x和y的坐标轴，以适应函数范围。
定义函数：定义两个函数 f(x) 和 g(x)。
计算极限值：计算在点 a=1.5 处的极限值。
绘制图形：绘制上面定义的函数和它们的总和。
创建极限点：在图上标记出每个函数的极限值，并且在总和函数的极限值也进行标记。
添加注释：为每个极限点添加相应的文本注释，显示其极限值。
动画效果：通过play方法逐步展示图形和注释，以便观众理解极限的性质。
高亮显示：在等待一段时间后，将极限点的颜色改变以进行高亮显示，最后淡出所有元素。

3.函数相乘的极限

$\mathop {\lim }\limits_{x \to a} \left[ {f\left( x \right)g\left( x \right)} \right] = \mathop {\lim }\limits_{x \to a} f\left( x \right)\,\,\,\mathop {\lim }\limits_{x \to a} g\left( x \right)$ ，求乘积的极限就像求和或差的极限一样。只要取出碎片的极限，然后把它们拼回去。同样，与和或差一样，这一事实不仅限于两个函数。

这个一个很好用的方法，如果让你找一个很复杂的极限的值，也许你找不到，但你可以把他分解出好几个极限来处理，这样很容易找到对应的值。

这是该性质的实现图形

实现代码如下：

from manim import *  

class LimitProductPropertyVisualization(Scene):  
    def construct(self):  
        # 创建坐标轴  
        axes = Axes(  
            x_range=[-1, 4,0.5],  
            y_range=[-6, 9, 1],
            y_length=8,
            axis_config={"color": BLUE},  
        )  

        # 定义函数 f(x) 和 g(x)  
        def f(x):  
            return x**2 - 1  

        def g(x):  
            return x**3 - 4*x - 1  

        # 定义常量 a  
        a = 2  # 所考察的点  

        # 创建图形  
        f_graph = axes.plot(f, color=YELLOW, x_range=[0, 3])  
        g_graph = axes.plot(g, color=RED, x_range=[0, 3])  

        # 计算极限值  
        limit_f_a = f(a)  
        limit_g_a = g(a)  
        limit_product_a = limit_f_a * limit_g_a  

        # 创建乘积函数的图形  
        product_graph = axes.plot(lambda x: f(x) * g(x), color=GREEN, x_range=[0, 3])  

        # 创建极限点  
        limit_dot_f = Dot(axes.c2p(a, limit_f_a), color=YELLOW)  
        limit_dot_g = Dot(axes.c2p(a, limit_g_a), color=RED)  
        limit_dot_product = Dot(axes.c2p(a, limit_product_a), color=GREEN)  

        # 创建极限值注释  
        limit_text_f = MathTex(r"\lim_{x \to a} f(x) = ", limit_f_a).next_to(limit_dot_f, RIGHT)  
        limit_text_g = MathTex(r"\lim_{x \to a} g(x) = ", limit_g_a).next_to(limit_dot_g, UR)  
        limit_text_product = MathTex(r"\lim_{x \to a} (f(x)g(x)) = ", limit_product_a).next_to(limit_dot_product, UR)  

        # 添加所有元素  
        self.play(Create(axes), Create(f_graph), Create(g_graph))  
        self.play(Create(product_graph))  
        self.play(Create(limit_dot_f), Create(limit_dot_g), Create(limit_dot_product))  
        self.play(Write(limit_text_f), Write(limit_text_g), Write(limit_text_product))  

        # 等待展示  
        self.wait(2)  

        # 高亮极限点  
        self.play(limit_dot_f.animate.set_color(ORANGE), limit_dot_g.animate.set_color(ORANGE), limit_dot_product.animate.set_color(ORANGE))  
        self.wait(2)  

        # 淡出所有元素  
        self.play(FadeOut(axes), FadeOut(f_graph), FadeOut(g_graph), FadeOut(product_graph),  
                  FadeOut(limit_dot_f), FadeOut(limit_dot_g), FadeOut(limit_dot_product),  
                  FadeOut(limit_text_f), FadeOut(limit_text_g), FadeOut(limit_text_product))

代码解释：

导入库：使用Manim库进行动画生成。
创建类：定义类LimitProductPropertyVisualization，继承自Scene，表示一个动画场景。
构建坐标轴：创建x和y的坐标轴，以适应函数范围。
定义函数：定义两个函数 f(x) 和 g(x)g(x)。
计算极限值：计算在点 a=2 处的极限值。
绘制图形：绘制上面定义的函数 f(x)、g(x) 以及它们的乘积函数。
创建极限点：在图上标记出每个函数的极限值，并且在乘积函数的极限值也进行标记。
添加注释：为每个极限点添加相应的文本注释，显示其极限值。
动画效果：通过play方法逐步展示图形和注释，以便观众理解极限的性质。
高亮显示：在等待一段时间后，将极限点的颜色改变以进行高亮显示，最后淡出所有元素。

4.函数相处的极限

$\displaystyle \mathop {\lim }\limits_{x \to a} \left[ {\frac{{f\left( x \right)}}{{g\left( x \right)}}} \right] = \frac{{\mathop {\lim }\limits_{x \to a} f\left( x \right)}}{{\mathop {\lim }\limits_{x \to a} g\left( x \right)}}{\rm{,}}\,\,\,\,\,$ 条件是 $\mathop {\lim }\limits_{x \to a} g\left( x \right) \ne 0$ 。正如在表述中提到的，当求商的极限时，我们只需要考虑分母的极限为零。如果它是0我们就会得到除以0的错误我们需要避免这种情况。

这个一个很好用的方法，如果让你找一个很复杂的极限的值，也许你找不到，但你可以把他分解出好几个极限来处理，这样很容易找到对应的值。

这是该性质的实现图形

实现代码：

from manim import *  

class LimitQuotientPropertyVisualization(Scene):  
    def construct(self):  
        # 创建坐标轴  
        axes = Axes(  
            x_range=[-1, 6, 1],  
            y_range=[-10, 10, 5],  
            axis_config={"color": BLUE},  
        )  

        # 定义函数 f(x) 和 g(x)  
        def f(x):  
            return x**2 - 1  

        def g(x):  
            return x**3 - 4*x - 1  

        # 定义常量 a  
        a = 2  # 所考察的点  

        # 创建图形  
        f_graph = axes.plot(f, color=YELLOW, x_range=[-3, 3])  
        g_graph = axes.plot(g, color=RED, x_range=[-3, 3])  

        # 计算极限值  
        limit_f_a = f(a)  
        limit_g_a = g(a)  
        limit_quotient_a = limit_f_a / limit_g_a  

        # 创建商函数的图形  
        quotient_graph = axes.plot(lambda x: f(x) / g(x), color=GREEN, x_range=[-3, 3])  

        # 创建极限点  
        limit_dot_f = Dot(axes.c2p(a, limit_f_a), color=YELLOW)  
        limit_dot_g = Dot(axes.c2p(a, limit_g_a), color=RED)  
        limit_dot_quotient = Dot(axes.c2p(a, limit_quotient_a), color=GREEN)  

        # 创建极限值注释  
        limit_text_f = MathTex(r"\lim_{x \to a} f(x) = ", limit_f_a).next_to(limit_dot_f, RIGHT)  
        limit_text_g = MathTex(r"\lim_{x \to a} g(x) = ", limit_g_a).next_to(limit_dot_g, RIGHT)  
        limit_text_quotient = MathTex(r"\lim_{x \to a} \left(\frac{f(x)}{g(x)}\right) = ", limit_quotient_a).next_to(limit_dot_quotient, DR)  

        # 添加所有元素  
        self.play(Create(axes), Create(f_graph), Create(g_graph))  
        self.play(Create(quotient_graph))  
        self.play(Create(limit_dot_f), Create(limit_dot_g), Create(limit_dot_quotient))  
        self.play(Write(limit_text_f), Write(limit_text_g), Write(limit_text_quotient))  

        # 等待展示  
        self.wait(2)  

        # 高亮极限点  
        self.play(limit_dot_f.animate.set_color(ORANGE), limit_dot_g.animate.set_color(ORANGE), limit_dot_quotient.animate.set_color(ORANGE))  
        self.wait(2)  

        # 淡出所有元素  
        self.play(FadeOut(axes), FadeOut(f_graph), FadeOut(g_graph), FadeOut(quotient_graph),  
                  FadeOut(limit_dot_f), FadeOut(limit_dot_g), FadeOut(limit_dot_quotient),  
                  FadeOut(limit_text_f), FadeOut(limit_text_g), FadeOut(limit_text_quotient))
        
%manim  -qm -v  WARNING LimitQuotientPropertyVisualization