manim 0.18.0.post0__py3-none-any.whl → 0.18.1__py3-none-any.whl

manim/mobject/graphing/coordinate_systems.py

@@ -1,6 +1,5 @@
 """Mobjects that represent coordinate systems."""
 
-
 from __future__ import annotations
 
 __all__ = [
@@ -55,7 +54,7 @@ from manim.utils.space_ops import angle_of_vector
 
 if TYPE_CHECKING:
     from manim.mobject.mobject import Mobject
-    from manim.typing import ManimFloat, Point2D, Point3D, Vector3
+    from manim.typing import ManimFloat, Point2D, Point3D, Vector3D
 
     LineType = TypeVar("LineType", bound=Line)
 
@@ -305,7 +304,7 @@ class CoordinateSystem:
         label
             The label. Defaults to :class:`~.MathTex` for ``str`` and ``float`` inputs.
         edge
-            The edge of the x-axis to which the label will be added, by default ``UR``.
+            The edge of the y-axis to which the label will be added, by default ``UR``.
         direction
             Allows for further positioning of the label from an edge, by default ``UR``
         buff
@@ -441,8 +440,7 @@ class CoordinateSystem:
         line_config: dict | None = ...,
         color: ParsableManimColor | None = ...,
         stroke_width: float = ...,
-    ) -> DashedLine:
-        ...
+    ) -> DashedLine: ...
 
     @overload
     def get_line_from_axis_to_point(
@@ -453,8 +451,7 @@ class CoordinateSystem:
         line_config: dict | None = ...,
         color: ParsableManimColor | None = ...,
         stroke_width: float = ...,
-    ) -> LineType:
-        ...
+    ) -> LineType: ...
 
     def get_line_from_axis_to_point(  # type: ignore[no-untyped-def]
         self,
@@ -855,9 +852,11 @@ class CoordinateSystem:
         function: Callable[[float], float],
         u_range: Sequence[float] | None = None,
         v_range: Sequence[float] | None = None,
-        colorscale: Sequence[ParsableManimColor]
-        | Sequence[tuple[ParsableManimColor, float]]
-        | None = None,
+        colorscale: (
+            Sequence[ParsableManimColor]
+            | Sequence[tuple[ParsableManimColor, float]]
+            | None
+        ) = None,
         colorscale_axis: int = 2,
         **kwargs: Any,
     ) -> Surface | OpenGLSurface:
@@ -2342,7 +2341,7 @@ class ThreeDAxes(Axes):
         y_length: float | None = config.frame_height + 2.5,
         z_length: float | None = config.frame_height - 1.5,
         z_axis_config: dict[str, Any] | None = None,
-        z_normal: Vector3 = DOWN,
+        z_normal: Vector3D = DOWN,
         num_axis_pieces: int = 20,
         light_source: Sequence[float] = 9 * DOWN + 7 * LEFT + 10 * OUT,
         # opengl stuff (?)
@@ -2433,7 +2432,7 @@ class ThreeDAxes(Axes):
         direction: Sequence[float] = UR,
         buff: float = SMALL_BUFF,
         rotation: float = PI / 2,
-        rotation_axis: Vector3 = OUT,
+        rotation_axis: Vector3D = OUT,
         **kwargs,
     ) -> Mobject:
         """Generate a y-axis label.
@@ -2480,11 +2479,11 @@ class ThreeDAxes(Axes):
     def get_z_axis_label(
         self,
         label: float | str | Mobject,
-        edge: Vector3 = OUT,
-        direction: Vector3 = RIGHT,
+        edge: Vector3D = OUT,
+        direction: Vector3D = RIGHT,
         buff: float = SMALL_BUFF,
         rotation: float = PI / 2,
-        rotation_axis: Vector3 = RIGHT,
+        rotation_axis: Vector3D = RIGHT,
         **kwargs: Any,
     ) -> Mobject:
         """Generate a z-axis label.
@@ -2571,7 +2570,7 @@ class ThreeDAxes(Axes):
                     self.set_camera_orientation(phi=2*PI/5, theta=PI/5)
                     axes = ThreeDAxes()
                     labels = axes.get_axis_labels(
-                        Tex("x-axis").scale(0.7), Text("y-axis").scale(0.45), Text("z-axis").scale(0.45)
+                        Text("x-axis").scale(0.7), Text("y-axis").scale(0.45), Text("z-axis").scale(0.45)
                     )
                     self.add(axes, labels)
         """
@@ -2653,14 +2652,12 @@ class NumberPlane(Axes):
 
     def __init__(
         self,
-        x_range: Sequence[float]
-        | None = (
+        x_range: Sequence[float] | None = (
             -config["frame_x_radius"],
             config["frame_x_radius"],
             1,
         ),
-        y_range: Sequence[float]
-        | None = (
+        y_range: Sequence[float] | None = (
             -config["frame_y_radius"],
             config["frame_y_radius"],
             1,

manim/mobject/graphing/functions.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 __all__ = ["ParametricFunction", "FunctionGraph", "ImplicitFunction"]
 
 
-from typing import Callable, Iterable, Sequence
+from typing import TYPE_CHECKING, Callable, Iterable, Sequence
 
 import numpy as np
 from isosurfaces import plot_isoline
@@ -14,6 +14,10 @@ from manim import config
 from manim.mobject.graphing.scale import LinearBase, _ScaleBase
 from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
 from manim.mobject.types.vectorized_mobject import VMobject
+
+if TYPE_CHECKING:
+    from manim.typing import Point2D, Point3D
+
 from manim.utils.color import YELLOW
 
 
@@ -23,9 +27,9 @@ class ParametricFunction(VMobject, metaclass=ConvertToOpenGL):
     Parameters
     ----------
     function
-        The function to be plotted in the form of ``(lambda x: x**2)``
+        The function to be plotted in the form of ``(lambda t: (x(t), y(t), z(t)))``
     t_range
-        Determines the length that the function spans. By default ``[0, 1]``
+        Determines the length that the function spans in the form of (t_min, t_max, step=0.01). By default ``[0, 1]``
     scaling
         Scaling class applied to the points of the function. Default of :class:`~.LinearBase`.
     use_smoothing
@@ -49,10 +53,10 @@ class ParametricFunction(VMobject, metaclass=ConvertToOpenGL):
 
         class PlotParametricFunction(Scene):
             def func(self, t):
-                return np.array((np.sin(2 * t), np.sin(3 * t), 0))
+                return (np.sin(2 * t), np.sin(3 * t), 0)
 
             def construct(self):
-                func = ParametricFunction(self.func, t_range = np.array([0, TAU]), fill_opacity=0).set_color(RED)
+                func = ParametricFunction(self.func, t_range = (0, TAU), fill_opacity=0).set_color(RED)
                 self.add(func.scale(3))
 
     .. manim:: ThreeDParametricSpring
@@ -61,11 +65,11 @@ class ParametricFunction(VMobject, metaclass=ConvertToOpenGL):
         class ThreeDParametricSpring(ThreeDScene):
             def construct(self):
                 curve1 = ParametricFunction(
-                    lambda u: np.array([
+                    lambda u: (
                         1.2 * np.cos(u),
                         1.2 * np.sin(u),
                         u * 0.05
-                    ]), color=RED, t_range = np.array([-3*TAU, 5*TAU, 0.01])
+                    ), color=RED, t_range = (-3*TAU, 5*TAU, 0.01)
                 ).set_shade_in_3d(True)
                 axes = ThreeDAxes()
                 self.add(axes, curve1)
@@ -97,8 +101,8 @@ class ParametricFunction(VMobject, metaclass=ConvertToOpenGL):
 
     def __init__(
         self,
-        function: Callable[[float, float], float],
-        t_range: Sequence[float] | None = None,
+        function: Callable[[float], Point3D],
+        t_range: Point2D | Point3D = (0, 1),
         scaling: _ScaleBase = LinearBase(),
         dt: float = 1e-8,
         discontinuities: Iterable[float] | None = None,
@@ -107,7 +111,7 @@ class ParametricFunction(VMobject, metaclass=ConvertToOpenGL):
         **kwargs,
     ):
         self.function = function
-        t_range = [0, 1, 0.01] if t_range is None else t_range
+        t_range = (0, 1, 0.01) if t_range is None else t_range
         if len(t_range) == 2:
             t_range = np.array([*t_range, 0.01])
 

manim/mobject/graphing/number_line.py

@@ -475,7 +475,7 @@ class NumberLine(Line):
         num_mob.next_to(self.number_to_point(x), direction=direction, buff=buff)
         if x < 0 and self.label_direction[0] == 0:
             # Align without the minus sign
-            num_mob.shift(num_mob[0].get_width() * LEFT / 2)
+            num_mob.shift(num_mob[0].width * LEFT / 2)
         return num_mob
 
     def get_number_mobjects(self, *numbers, **kwargs) -> VGroup: