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

manim/mobject/graphing/coordinate_systems.py

@@ -1,6 +1,5 @@
 """Mobjects that represent coordinate systems."""
 
-
 from __future__ import annotations
 
 __all__ = [
@@ -14,7 +13,8 @@ __all__ = [
 
 import fractions as fr
 import numbers
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Sequence, TypeVar, overload
+from collections.abc import Iterable, Sequence
+from typing import TYPE_CHECKING, Any, Callable, TypeVar, overload
 
 import numpy as np
 from typing_extensions import Self
@@ -27,6 +27,7 @@ from manim.mobject.geometry.polygram import Polygon, Rectangle, RegularPolygon
 from manim.mobject.graphing.functions import ImplicitFunction, ParametricFunction
 from manim.mobject.graphing.number_line import NumberLine
 from manim.mobject.graphing.scale import LinearBase
+from manim.mobject.mobject import Mobject
 from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
 from manim.mobject.opengl.opengl_surface import OpenGLSurface
 from manim.mobject.text.tex_mobject import MathTex
@@ -47,6 +48,7 @@ from manim.utils.color import (
     ManimColor,
     ParsableManimColor,
     color_gradient,
+    interpolate_color,
     invert_color,
 )
 from manim.utils.config_ops import merge_dicts_recursively, update_dict_recursively
@@ -55,7 +57,14 @@ 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,
+        Point2DLike,
+        Point3D,
+        Point3DLike,
+        Vector3D,
+    )
 
     LineType = TypeVar("LineType", bound=Line)
 
@@ -96,10 +105,10 @@ class CoordinateSystem:
                     )
 
                 # Extra lines and labels for point (1,1)
-                graphs += grid.get_horizontal_line(grid.c2p(1, 1, 0), color=BLUE)
-                graphs += grid.get_vertical_line(grid.c2p(1, 1, 0), color=BLUE)
-                graphs += Dot(point=grid.c2p(1, 1, 0), color=YELLOW)
-                graphs += Tex("(1,1)").scale(0.75).next_to(grid.c2p(1, 1, 0))
+                graphs += grid.get_horizontal_line(grid @ (1, 1, 0), color=BLUE)
+                graphs += grid.get_vertical_line(grid @ (1, 1, 0), color=BLUE)
+                graphs += Dot(point=grid @ (1, 1, 0), color=YELLOW)
+                graphs += Tex("(1,1)").scale(0.75).next_to(grid @ (1, 1, 0))
                 title = Title(
                     # spaces between braces to prevent SyntaxError
                     r"Graphs of $y=x^{ {1}\over{n} }$ and $y=x^n (n=1,2,3,...,20)$",
@@ -145,10 +154,10 @@ class CoordinateSystem:
         self.y_length = y_length
         self.num_sampled_graph_points_per_tick = 10
 
-    def coords_to_point(self, *coords: Sequence[ManimFloat]):
+    def coords_to_point(self, *coords: ManimFloat):
         raise NotImplementedError()
 
-    def point_to_coords(self, point: Point3D):
+    def point_to_coords(self, point: Point3DLike):
         raise NotImplementedError()
 
     def polar_to_point(self, radius: float, azimuth: float) -> Point2D:
@@ -182,7 +191,7 @@ class CoordinateSystem:
         """
         return self.coords_to_point(radius * np.cos(azimuth), radius * np.sin(azimuth))
 
-    def point_to_polar(self, point: np.ndarray) -> Point2D:
+    def point_to_polar(self, point: Point2DLike) -> Point2D:
         r"""Gets polar coordinates from a point.
 
         Parameters
@@ -204,7 +213,7 @@ class CoordinateSystem:
         """Abbreviation for :meth:`coords_to_point`"""
         return self.coords_to_point(*coords)
 
-    def p2c(self, point: Point3D):
+    def p2c(self, point: Point3DLike):
         """Abbreviation for :meth:`point_to_coords`"""
         return self.point_to_coords(point)
 
@@ -305,7 +314,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
@@ -332,7 +341,6 @@ class CoordinateSystem:
                     )
                     self.add(ax, y_label)
         """
-
         return self._get_axis_label(
             label, self.get_y_axis(), edge, direction, buff=buff, **kwargs
         )
@@ -365,7 +373,6 @@ class CoordinateSystem:
         :class:`~.Mobject`
             The positioned label along the given axis.
         """
-
         label = self.x_axis._create_label_tex(label)
         label.next_to(axis.get_edge_center(edge), direction=direction, buff=buff)
         label.shift_onto_screen(buff=MED_SMALL_BUFF)
@@ -394,7 +401,9 @@ class CoordinateSystem:
             ax = ThreeDAxes()
             x_labels = range(-4, 5)
             z_labels = range(-4, 4, 2)
-            ax.add_coordinates(x_labels, None, z_labels)  # default y labels, custom x & z labels
+            ax.add_coordinates(
+                x_labels, None, z_labels
+            )  # default y labels, custom x & z labels
             ax.add_coordinates(x_labels)  # only x labels
 
         You can also specifically control the position and value of the labels using a dict.
@@ -405,11 +414,18 @@ class CoordinateSystem:
             x_pos = [x for x in range(1, 8)]
 
             # strings are automatically converted into a Tex mobject.
-            x_vals = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+            x_vals = [
+                "Monday",
+                "Tuesday",
+                "Wednesday",
+                "Thursday",
+                "Friday",
+                "Saturday",
+                "Sunday",
+            ]
             x_dict = dict(zip(x_pos, x_vals))
             ax.add_coordinates(x_dict)
         """
-
         self.coordinate_labels = VGroup()
         # if nothing is passed to axes_numbers, produce axes with default labelling
         if not axes_numbers:
@@ -441,8 +457,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 +468,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,
@@ -492,7 +506,6 @@ class CoordinateSystem:
             :meth:`~.CoordinateSystem.get_vertical_line`
             :meth:`~.CoordinateSystem.get_horizontal_line`
         """
-
         line_config = line_config if line_config is not None else {}
 
         if color is None:
@@ -562,14 +575,13 @@ class CoordinateSystem:
             class GetHorizontalLineExample(Scene):
                 def construct(self):
                     ax = Axes().add_coordinates()
-                    point = ax.c2p(-4, 1.5)
+                    point = ax @ (-4, 1.5)
 
                     dot = Dot(point)
                     line = ax.get_horizontal_line(point, line_func=Line)
 
                     self.add(ax, line, dot)
         """
-
         return self.get_line_from_axis_to_point(1, point, **kwargs)
 
     def get_lines_to_point(self, point: Sequence[float], **kwargs) -> VGroup:
@@ -606,7 +618,6 @@ class CoordinateSystem:
                     lines_2 = ax.get_lines_to_point(circ.get_corner(DL), color=BLUE_B)
                     self.add(ax, lines_1, lines_2, circ)
         """
-
         return VGroup(
             self.get_horizontal_line(point, **kwargs),
             self.get_vertical_line(point, **kwargs),
@@ -619,6 +630,8 @@ class CoordinateSystem:
         function: Callable[[float], float],
         x_range: Sequence[float] | None = None,
         use_vectorized: bool = False,
+        colorscale: Union[Iterable[Color], Iterable[Color, float]] | None = None,
+        colorscale_axis: int = 1,
         **kwargs: Any,
     ) -> ParametricFunction:
         """Generates a curve based on a function.
@@ -632,6 +645,12 @@ class CoordinateSystem:
         use_vectorized
             Whether to pass in the generated t value array to the function. Only use this if your function supports it.
             Output should be a numpy array of shape ``[y_0, y_1, ...]``
+        colorscale
+            Colors of the function. Optional parameter used when coloring a function by values. Passing a list of colors
+            and a colorscale_axis will color the function by y-value. Passing a list of tuples in the form ``(color, pivot)``
+            allows user-defined pivots where the color transitions.
+        colorscale_axis
+            Defines the axis on which the colorscale is applied (0 = x, 1 = y), default is y-axis (1).
         kwargs
             Additional parameters to be passed to :class:`~.ParametricFunction`.
 
@@ -691,7 +710,6 @@ class CoordinateSystem:
 
                     self.add(axes, curves)
         """
-
         t_range = np.array(self.x_range, dtype=float)
         if x_range is not None:
             t_range[: len(x_range)] = x_range
@@ -710,7 +728,57 @@ class CoordinateSystem:
             use_vectorized=use_vectorized,
             **kwargs,
         )
+
         graph.underlying_function = function
+
+        if colorscale:
+            if type(colorscale[0]) in (list, tuple):
+                new_colors, pivots = [
+                    [i for i, j in colorscale],
+                    [j for i, j in colorscale],
+                ]
+            else:
+                new_colors = colorscale
+
+                ranges = [self.x_range, self.y_range]
+                pivot_min = ranges[colorscale_axis][0]
+                pivot_max = ranges[colorscale_axis][1]
+                pivot_frequency = (pivot_max - pivot_min) / (len(new_colors) - 1)
+                pivots = np.arange(
+                    start=pivot_min,
+                    stop=pivot_max + pivot_frequency,
+                    step=pivot_frequency,
+                )
+
+            resolution = 0.01 if len(x_range) == 2 else x_range[2]
+            sample_points = np.arange(x_range[0], x_range[1] + resolution, resolution)
+            color_list = []
+            for samp_x in sample_points:
+                axis_value = (samp_x, function(samp_x))[colorscale_axis]
+                if axis_value <= pivots[0]:
+                    color_list.append(new_colors[0])
+                elif axis_value >= pivots[-1]:
+                    color_list.append(new_colors[-1])
+                else:
+                    for i, pivot in enumerate(pivots):
+                        if pivot > axis_value:
+                            color_index = (axis_value - pivots[i - 1]) / (
+                                pivots[i] - pivots[i - 1]
+                            )
+                            color_index = min(color_index, 1)
+                            mob_color = interpolate_color(
+                                new_colors[i - 1],
+                                new_colors[i],
+                                color_index,
+                            )
+                            color_list.append(mob_color)
+                            break
+            if config.renderer == RendererType.OPENGL:
+                graph.set_color(color_list)
+            else:
+                graph.set_stroke(color_list)
+                graph.set_sheen_direction(RIGHT)
+
         return graph
 
     def plot_implicit_curve(
@@ -855,9 +923,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:
@@ -940,7 +1010,7 @@ class CoordinateSystem:
         self,
         x: float,
         graph: ParametricFunction | VMobject,
-    ) -> np.ndarray:
+    ) -> Point3D:
         """Returns the coordinates of the point on a ``graph`` corresponding to an ``x`` value.
 
         Parameters
@@ -976,7 +1046,6 @@ class CoordinateSystem:
 
                     self.add(ax, curve, sq)
         """
-
         if hasattr(graph, "underlying_function"):
             return graph.function(x)
         else:
@@ -1032,7 +1101,7 @@ class CoordinateSystem:
         dot: bool = False,
         dot_config: dict[str, Any] | None = None,
     ) -> Mobject:
-        """Creates a properly positioned label for the passed graph, with an optional dot.
+        r"""Creates a properly positioned label for the passed graph, with an optional dot.
 
         Parameters
         ----------
@@ -1069,7 +1138,7 @@ class CoordinateSystem:
                     sin = ax.plot(lambda x: np.sin(x), color=PURPLE_B)
                     label = ax.get_graph_label(
                         graph=sin,
-                        label= MathTex(r"\\frac{\\pi}{2}"),
+                        label= MathTex(r"\frac{\pi}{2}"),
                         x_val=PI / 2,
                         dot=True,
                         direction=UR,
@@ -1077,7 +1146,6 @@ class CoordinateSystem:
 
                     self.add(ax, sin, label)
         """
-
         if dot_config is None:
             dot_config = {}
         if color is None:
@@ -1197,7 +1265,6 @@ class CoordinateSystem:
                         ax, bounding_line, quadratic, rects_right, rects_left, bounded_rects
                     )
         """
-
         # setting up x_range, overwrite user's third input
         if x_range is None:
             if bounded_graph is None:
@@ -1387,7 +1454,6 @@ class CoordinateSystem:
             ax.angle_of_tangent(x=3, graph=curve)
             # 1.4056476493802699
         """
-
         p0 = np.array([*self.input_to_graph_coords(x, graph)])
         p1 = np.array([*self.input_to_graph_coords(x + dx, graph)])
         return angle_of_vector(p1 - p0)
@@ -1419,7 +1485,6 @@ class CoordinateSystem:
             ax.slope_of_tangent(x=-2, graph=curve)
             # -3.5000000259052038
         """
-
         return np.tan(self.angle_of_tangent(x, graph, **kwargs))
 
     def plot_derivative_graph(
@@ -1695,7 +1760,6 @@ class CoordinateSystem:
 
                     self.add(ax, curve, lines)
         """
-
         x_range = x_range if x_range is not None else self.x_range
 
         return VGroup(
@@ -1757,7 +1821,6 @@ class CoordinateSystem:
                     t_label = axes.get_T_label(x_val=4, graph=func, label=Tex("x-value"))
                     self.add(axes, func, t_label)
         """
-
         T_label_group = VGroup()
         triangle = RegularPolygon(n=3, start_angle=np.pi / 2, stroke_width=0).set_fill(
             color=triangle_color,
@@ -1780,6 +1843,14 @@ class CoordinateSystem:
 
         return T_label_group
 
+    def __matmul__(self, coord: Point3DLike | Mobject):
+        if isinstance(coord, Mobject):
+            coord = coord.get_center()
+        return self.coords_to_point(*coord)
+
+    def __rmatmul__(self, point: Point3DLike):
+        return self.point_to_coords(point)
+
 
 class Axes(VGroup, CoordinateSystem, metaclass=ConvertToOpenGL):
     """Creates a set of axes.
@@ -1941,7 +2012,6 @@ class Axes(VGroup, CoordinateSystem, metaclass=ConvertToOpenGL):
                 )
             )
         """
-
         for default_config, passed_config in zip(default_configs, passed_configs):
             if passed_config is not None:
                 update_dict_recursively(default_config, passed_config)
@@ -1980,6 +2050,7 @@ class Axes(VGroup, CoordinateSystem, metaclass=ConvertToOpenGL):
         self, *coords: float | Sequence[float] | Sequence[Sequence[float]] | np.ndarray
     ) -> np.ndarray:
         """Accepts coordinates from the axes and returns a point with respect to the scene.
+        Equivalent to `ax @ (coord1)`
 
         Parameters
         ----------
@@ -2008,6 +2079,8 @@ class Axes(VGroup, CoordinateSystem, metaclass=ConvertToOpenGL):
             >>> ax = Axes()
             >>> np.around(ax.coords_to_point(1, 0, 0), 2)
             array([0.86, 0.  , 0.  ])
+            >>> np.around(ax @ (1, 0, 0), 2)
+            array([0.86, 0.  , 0.  ])
             >>> np.around(ax.coords_to_point([[0, 1], [1, 1], [1, 0]]), 2)
             array([[0.  , 0.75, 0.  ],
                    [0.86, 0.75, 0.  ],
@@ -2183,7 +2256,6 @@ class Axes(VGroup, CoordinateSystem, metaclass=ConvertToOpenGL):
                     )
                     self.add(ax, labels)
         """
-
         self.axis_labels = VGroup(
             self.get_x_axis_label(x_label),
             self.get_y_axis_label(y_label),
@@ -2342,7 +2414,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 +2505,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.
@@ -2470,7 +2542,6 @@ class ThreeDAxes(Axes):
                     self.set_camera_orientation(phi=2*PI/5, theta=PI/5)
                     self.add(ax, lab)
         """
-
         positioned_label = self._get_axis_label(
             label, self.get_y_axis(), edge, direction, buff=buff, **kwargs
         )
@@ -2480,11 +2551,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.
@@ -2521,7 +2592,6 @@ class ThreeDAxes(Axes):
                     self.set_camera_orientation(phi=2*PI/5, theta=PI/5)
                     self.add(ax, lab)
         """
-
         positioned_label = self._get_axis_label(
             label, self.get_z_axis(), edge, direction, buff=buff, **kwargs
         )
@@ -2571,11 +2641,10 @@ 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)
         """
-
         self.axis_labels = VGroup(
             self.get_x_axis_label(x_label),
             self.get_y_axis_label(y_label),
@@ -2653,14 +2722,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,
@@ -2801,7 +2868,6 @@ class NumberPlane(Axes):
             The first (i.e the non-faded lines parallel to `axis_parallel_to`) and second
              (i.e the faded lines parallel to `axis_parallel_to`) sets of lines, respectively.
         """
-
         line = Line(axis_parallel_to.get_start(), axis_parallel_to.get_end())
         if ratio_faded_lines == 0:  # don't show faded lines
             ratio_faded_lines = 1  # i.e. set ratio to 1
@@ -3169,7 +3235,7 @@ class PolarPlane(Axes):
         elif self.azimuth_units == "degrees":
             a_tex = [
                 MathTex(
-                    f'{360 * i["label"]:g}' + r"^{\circ}",
+                    f"{360 * i['label']:g}" + r"^{\circ}",
                     font_size=self.azimuth_label_font_size,
                 ).next_to(
                     i["point"],
@@ -3182,7 +3248,7 @@ class PolarPlane(Axes):
         elif self.azimuth_units == "gradians":
             a_tex = [
                 MathTex(
-                    f'{400 * i["label"]:g}' + r"^{g}",
+                    f"{400 * i['label']:g}" + r"^{g}",
                     font_size=self.azimuth_label_font_size,
                 ).next_to(
                     i["point"],
@@ -3195,7 +3261,7 @@ class PolarPlane(Axes):
         elif self.azimuth_units is None:
             a_tex = [
                 MathTex(
-                    f'{i["label"]:g}',
+                    f"{i['label']:g}",
                     font_size=self.azimuth_label_font_size,
                 ).next_to(
                     i["point"],
@@ -3313,7 +3379,6 @@ class ComplexPlane(NumberPlane):
         np.ndarray
             The point on the plane.
         """
-
         number = complex(number)
         return self.coords_to_point(number.real, number.imag)
 
@@ -3321,7 +3386,7 @@ class ComplexPlane(NumberPlane):
         """Abbreviation for :meth:`number_to_point`."""
         return self.number_to_point(number)
 
-    def point_to_number(self, point: Point3D) -> complex:
+    def point_to_number(self, point: Point3DLike) -> complex:
         """Accepts a point and returns a complex number equivalent to that point on the plane.
 
         Parameters
@@ -3334,11 +3399,10 @@ class ComplexPlane(NumberPlane):
         complex
             A complex number consisting of real and imaginary components.
         """
-
         x, y = self.point_to_coords(point)
         return complex(x, y)
 
-    def p2n(self, point: Point3D) -> complex:
+    def p2n(self, point: Point3DLike) -> complex:
         """Abbreviation for :meth:`point_to_number`."""
         return self.point_to_number(point)
 
@@ -3372,7 +3436,6 @@ class ComplexPlane(NumberPlane):
         :class:`~.VGroup`
             A :class:`~.VGroup` containing the positioned label mobjects.
         """
-
         # TODO: Make this work the same as coord_sys.add_coordinates()
         if len(numbers) == 0:
             numbers = self._get_default_coordinate_values()
@@ -3403,6 +3466,5 @@ class ComplexPlane(NumberPlane):
         kwargs
             Additional arguments to be passed to :meth:`~.NumberLine.get_number_mobject`, i.e. :class:`~.DecimalNumber`.
         """
-
         self.add(self.get_coordinate_labels(*numbers, **kwargs))
         return self

manim/mobject/graphing/functions.py

@@ -5,7 +5,8 @@ from __future__ import annotations
 __all__ = ["ParametricFunction", "FunctionGraph", "ImplicitFunction"]
 
 
-from typing import Callable, Iterable, Sequence
+from collections.abc import Iterable, Sequence
+from typing import TYPE_CHECKING, Callable
 
 import numpy as np
 from isosurfaces import plot_isoline
@@ -14,6 +15,12 @@ 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 typing_extensions import Self
+
+    from manim.typing import Point3D, Point3DLike
+
 from manim.utils.color import YELLOW
 
 
@@ -23,9 +30,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 +56,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 +68,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 +104,8 @@ class ParametricFunction(VMobject, metaclass=ConvertToOpenGL):
 
     def __init__(
         self,
-        function: Callable[[float, float], float],
-        t_range: Sequence[float] | None = None,
+        function: Callable[[float], Point3DLike],
+        t_range: tuple[float, float] | tuple[float, float, float] = (0, 1),
         scaling: _ScaleBase = LinearBase(),
         dt: float = 1e-8,
         discontinuities: Iterable[float] | None = None,
@@ -106,10 +113,13 @@ class ParametricFunction(VMobject, metaclass=ConvertToOpenGL):
         use_vectorized: bool = False,
         **kwargs,
     ):
-        self.function = function
-        t_range = [0, 1, 0.01] if t_range is None else t_range
+        def internal_parametric_function(t: float) -> Point3D:
+            """Wrap ``function``'s output inside a NumPy array."""
+            return np.asarray(function(t))
+
+        self.function = internal_parametric_function
         if len(t_range) == 2:
-            t_range = np.array([*t_range, 0.01])
+            t_range = (*t_range, 0.01)
 
         self.scaling = scaling
 
@@ -121,13 +131,13 @@ class ParametricFunction(VMobject, metaclass=ConvertToOpenGL):
 
         super().__init__(**kwargs)
 
-    def get_function(self):
+    def get_function(self) -> Callable[[float], Point3D]:
         return self.function
 
-    def get_point_from_function(self, t):
+    def get_point_from_function(self, t: float) -> Point3D:
         return self.function(t)
 
-    def generate_points(self):
+    def generate_points(self) -> Self:
         if self.discontinuities is not None:
             discontinuities = filter(
                 lambda t: self.t_min <= t <= self.t_max,