一，介绍
在这个上下文中，函数是指变量之间的数学关系。当我们可视化这些函数时，我们使用对象来表示这些函数的图形。
函数
-
FunctionGraph（函数图）
- 这个类表示一个由显式方程
定义的函数图。
- 它是
ParametricFunction的一种特殊类型，默认情况下会跨越整个场景的长度。这意味着它扩展到可见区域，使得轻松观察函数在指定范围内的行为成为可能。
-
ImplicitFunction（隐式函数）
- 这个类表示由隐式形式定义的函数，通常为
例如，一个圆可以表示为
。
- 与显式函数不同，显式函数是通过将 y用 x 表示出来，隐式函数则直接描述 x 和 y 之间的关系。
-
ParametricFunction（参数函数）
- 这个类表示由参数方程定义的曲线。它不是用 y作为 x的函数，而是定义 x 和 y 都是一个第三变量（通常是 t）的函数。
- 一个典型的参数函数可能看起来像
其中 t 在某个区间内变化。
二，应用
1.FunctionGraph（函数图）
用于显式函数，默认情况下跨越整个场景。
构造函数如下：
FunctionGraph(function, x_range=None, color=ManimColor('#FFFF00'), **kwargs)FunctionGraph 是 Manim 中用于创建函数图形的一个类。它用于可视化数学函数，通常是由显式方程 y=f(x) 定义的。
参数解释
-
function: 这是一个函数对象，它定义了 yy 如何根据 xx 变化。通常这个函数接收一个数字并返回一个数字，例如
lambda x: x**2。 -
x_range: 这是一个可选参数，用于定义函数图形的 xx 轴范围。它通常是一个包含最小值和最大值的元组，例如
(x_min, x_max)。 -
color: 这用于设置函数图形的颜色，默认为一种淡黄色（
ManimColor('#FFFF00')）。你可以使用任何有效的颜色。 -
kwargs: 额外的关键字参数，这些参数可以传递给父类，用于控制其他属性，比如线宽、透明度等。
示例1：
from manim import *
class DrawFunctionGraph(Scene):
def construct(self):
ax=Axes().add_coordinates()
# 定义函数
function = lambda x: x ** 2
# 创建 FunctionGraph 对象
graph = FunctionGraph(function, x_range=(-3, 3), color=YELLOW)
# 绘制图形
self.add(ax,graph) 代码说明
- 首先，定义了一个场景
DrawFunctionGraph。 - 在场景中，定义了一个表示
的 Lambda 函数。
- 使用
FunctionGraph创建一个图形，设定 xx 的范围为[−3,3]，颜色设置为黄色。 - 使用
Create动画展示图形，并等待两秒钟以便查看结果。
运行结果：
示例2：
class ExampleFunctionGraph(Scene):
def construct(self):
ax=Axes().add_coordinates()
cos_func = FunctionGraph(
lambda t: np.cos(t) + 0.5 * np.cos(7 * t) + (1 / 7) * np.cos(14 * t),
color=RED,
).move_to([0, 2, 0])
sin_func_1 = FunctionGraph(
lambda t: np.sin(t) + 0.5 * np.sin(7 * t) + (1 / 7) * np.sin(14 * t),
color=BLUE,
).move_to([0, 0, 0])
sin_func_2 = FunctionGraph(
lambda t: np.sin(t) + 0.5 * np.sin(7 * t) + (1 / 7) * np.sin(14 * t),
x_range=[-4, 4],
color=GREEN,
).move_to([0, -2, 0])
self.add(NumberPlane(),ax,cos_func, sin_func_1, sin_func_2)运行结果：
2.ImplicitFunction（隐式函数）
ImplicitFunction表示 x 和 y 之间的关系，而不需要将其中一个解出作为另一个的函数。
构造函数如下：
ImplicitFunction(func, x_range=None, y_range=None, min_depth=5, max_quads=1500,
use_smoothing=True, **kwargs)ImplicitFunction 是 Manim 中用于绘制隐式函数图形的类。与显式函数不同，隐式函数通常以方程的形式 F(x,y)=0 给出。这个类根据指定的函数和范围来绘制图形。
参数解释
-
func: 这是一个接收两个参数 x 和 y的函数，表示隐式方程 F(x,y)=0。
-
x_range: 可选参数，定义 x 轴的范围，格式为一个包含最小值和最大值的元组，例如
(-3, 3)。 -
y_range: 可选参数，定义 yy 轴的范围，格式同样为一个包含最小值和最大值的元组。
-
min_depth: 在计算隐式结构的过程中，递归的最小深度，默认为 5。这个值越大，允许的细节级别越高。
-
max_quads: 可选参数，控制绘制的最大四边形数量，默认为 1500。这有助于控制画布上绘制的多边形数量，以提高性能。
-
use_smoothing: 布尔值，指示是否对图形进行平滑处理，默认为
True。如果设置为False，图形可能会更为锐利，但可能出现锯齿边缘。 -
kwargs: 额外的关键字参数，用来设定其他属性，例如颜色、线宽等。
示例代码1：
下面的代码示例展示了如何使用 ImplicitFunction 绘制一个圆的隐式方程 。
from manim import *
class DrawImplicitFunction(Scene):
def construct(self):
ax=Axes().add_coordinates()
# 定义隐式函数
func = lambda x, y: x**2 + y**2 - 4
# 创建 ImplicitFunction 对象
implicit_func_graph = ImplicitFunction(func,
x_range=(-2, 2),
y_range=(-2, 2),
min_depth=5,
max_quads=4050,
color=BLUE,
use_smoothing=True)
# 绘制图形
self.add(NumberPlane(),ax)
self.play(Create(implicit_func_graph))
self.wait(2) 运行结果：
示例2
class ImplicitFunctionExample(Scene):
def construct(self):
graph = ImplicitFunction(
lambda x, y: x * y ** 2 - x ** 2 * y - 2,
color=RED
)
self.add(NumberPlane(), graph)运行结果：
3.ParametricFunction（参数函数）
ParametricFunction通过将 x 和 y 作为第三变量的函数来表示曲线。
ParametricFunction(function, t_range=(0, 1), scaling=
<manim.mobject.graphing.scale.LinearBase object>,
dt=1e-08, discontinuities=None, use_smoothing=True,
use_vectorized=False, **kwargs)ParametricFunction 是 Manim 中用于绘制参数方程的类。这种类型的函数通常表示为一组方程 (x(t),y(t))(x(t),y(t))，其中 tt 是参数。
参数解释
-
function: 这是一个接受一个参数 tt 的函数，返回一个长度为 2 的元组或列表，表示点 (x(t),y(t))。
-
t_range: 定义参数 tt 的范围，格式为一个包含最小值和最大值的元组，例如
(0, 1)。 -
scaling: 用于缩放图形的尺度对象，默认为线性缩放。你可以用不同的缩放方式改变图形的大小。
-
dt: 用于数值计算时的微小增量，默认为 1e−08，在处理参数方程时可用于控制精度。
-
discontinuities: 可选参数，定义在绘制中要跳过的点。如果函数在某些点上不连续，可以通过这个参数进行指定，以避免在这些不连续点绘制出无效的部分。
-
use_smoothing: 布尔值，指示是否对图形进行平滑处理，默认为
True。如果设置为False，图形可能会更为锐利，但可能会出现锯齿边缘。 -
use_vectorized: 布尔值，指示是否使用向量化函数进行绘制，默认为
False。使用向量化可以提高绘制效率和质量。 -
kwargs: 额外的关键字参数，用于设定其他属性，比如颜色、线宽、样式等。
示例1:
下面的代码示例展示了如何使用 ParametricFunction 绘制一个单位圆的参数方程。
from manim import *
class DrawParametricFunction11(Scene):
def construct(self):
# 定义参数方程，返回心形曲线的 x 和 y 坐标
def heart_shape(t):
x = 1.5 * np.sin(t)**3
y = 1.5 * np.cos(t) - 1.5* np.cos(2 * t) - 1 * np.cos(3 * t) - np.cos(4 * t)
return np.array([x, y, 0]) # 返回一个三维点
# 创建 ParametricFunction 对象，使用所有参数
heart_curve = ParametricFunction(
heart_shape,
t_range=(0, 2 * PI), # 参数 t 的范围
scaling=LinearBase(), # 使用线性缩放
dt=1e-08, # 微小增量
discontinuities=None, # 无需跳过不连续点
use_smoothing=True, # 启用平滑
use_vectorized=False, # 不使用向量化绘制
color=RED, # 颜色设定为红色
stroke_width=4 # 线宽设定为4
)
# 绘制图形
self.add(NumberPlane())
self.play(Create(heart_curve))
self.wait(2) 运行结果：
示例2
from manim import *
class DrawParametricFunction(Scene):
def construct(self):
# 定义参数方程
def parametric_circle(t):
x = 2 * np.sin(t)**3
y = 1 * np.cos(t) - 1.5 * np.cos(2 * t) - 0.5 * np.cos(3 * t) - np.cos(4 * t)
return np.array([x, y, 0]) # 返回一个三维点
# 创建 ParametricFunction 对象
parametric_circle_graph = ParametricFunction(parametric_circle,
t_range=(0, 2 * PI),
color=YELLOW)
# 绘制图形
self.play(Create(parametric_circle_graph))
self.wait(2) 运行结果：
示例3：
from manim import *
class PlotParametricFunction(Scene):
def func(self, t):
return (np.sin(2 * t), np.sin(3 * t), 0)
def construct(self):
func = ParametricFunction(self.func, t_range = (0, TAU), fill_opacity=0).set_color(RED)
self.add(func.scale(3)) 运行结果：
示例4：
from manim import *
class ThreeDParametricSpring01(ThreeDScene):
def construct(self):
curve1 = ParametricFunction(
lambda u: (
1.2 * np.cos(u),
1.2 * np.sin(u),
u * 0.05
),
color=RED,
stroke_width=7 , # 线宽设定为7
t_range=(-3 * TAU, 5 * TAU, 0.01)
).set_shade_in_3d(True)
axes = ThreeDAxes()
# 创建坐标标签
x_label = MathTex("X").scale(0.7).next_to(axes.x_axis.get_end(), UP)
y_label = MathTex("Y").scale(0.7).next_to(axes.y_axis.get_end(), RIGHT)
z_label = MathTex("Z").scale(0.7).next_to(axes.z_axis.get_end(), OUT)
# 添加坐标系和标签到场景中
self.add(axes, x_label, y_label, z_label)
self.add(axes)
# 调整摄像机的方位，以 45 度的角度观察
self.set_camera_orientation(phi=25 * DEGREES, theta=-35 * DEGREES)
self.play(Create(curve1))
self.wait()运行结果：
示例4：
class DiscontinuousExample(Scene):
def construct(self):
ax1 = NumberPlane((-3, 3), (-4, 4))
ax2 = NumberPlane((-3, 3), (-4, 4))
VGroup(ax1, ax2).arrange()
discontinuous_function = lambda x: (0.5*x **4 - 0.05) / (x **4 - 0.002)
incorrect = ax1.plot(discontinuous_function, color=RED)
correct = ax2.plot(
discontinuous_function,
discontinuities=[-4, 4],
dt=0.5,
color=GREEN,
)
self.add(ax1, ax2, incorrect, correct) 运行结果：
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
