manim 0.18.1__py3-none-any.whl → 0.19.0__py3-none-any.whl

manim/mobject/graphing/coordinate_systems.py

@@ -13,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
@@ -26,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
@@ -46,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
@@ -54,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, Vector3D
+    from manim.typing import (
+        ManimFloat,
+        Point2D,
+        Point2DLike,
+        Point3D,
+        Point3DLike,
+        Vector3D,
+    )
 
     LineType = TypeVar("LineType", bound=Line)
 
@@ -95,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)$",
@@ -144,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:
@@ -181,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
@@ -203,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)
 
@@ -331,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
         )
@@ -364,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)
@@ -393,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.
@@ -404,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:
@@ -489,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:
@@ -559,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:
@@ -603,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),
@@ -616,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.
@@ -629,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`.
 
@@ -688,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
@@ -707,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(
@@ -939,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
@@ -975,7 +1046,6 @@ class CoordinateSystem:
 
                     self.add(ax, curve, sq)
         """
-
         if hasattr(graph, "underlying_function"):
             return graph.function(x)
         else:
@@ -1031,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
         ----------
@@ -1068,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,
@@ -1076,7 +1146,6 @@ class CoordinateSystem:
 
                     self.add(ax, sin, label)
         """
-
         if dot_config is None:
             dot_config = {}
         if color is None:
@@ -1196,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:
@@ -1386,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)
@@ -1418,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(
@@ -1694,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(
@@ -1756,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,
@@ -1779,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.
@@ -1940,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)
@@ -1979,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
         ----------
@@ -2007,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.  ],
@@ -2182,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),
@@ -2469,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
         )
@@ -2520,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
         )
@@ -2574,7 +2645,6 @@ class ThreeDAxes(Axes):
                     )
                     self.add(axes, labels)
         """
-
         self.axis_labels = VGroup(
             self.get_x_axis_label(x_label),
             self.get_y_axis_label(y_label),
@@ -2798,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
@@ -3166,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"],
@@ -3179,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"],
@@ -3192,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"],
@@ -3310,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)
 
@@ -3318,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
@@ -3331,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)
 
@@ -3369,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()
@@ -3400,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 TYPE_CHECKING, Callable, Iterable, Sequence
+from collections.abc import Iterable, Sequence
+from typing import TYPE_CHECKING, Callable
 
 import numpy as np
 from isosurfaces import plot_isoline
@@ -16,7 +17,9 @@ 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 typing_extensions import Self
+
+    from manim.typing import Point3D, Point3DLike
 
 from manim.utils.color import YELLOW
 
@@ -101,8 +104,8 @@ class ParametricFunction(VMobject, metaclass=ConvertToOpenGL):
 
     def __init__(
         self,
-        function: Callable[[float], Point3D],
-        t_range: Point2D | Point3D = (0, 1),
+        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,
@@ -110,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
 
@@ -125,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,

manim/mobject/graphing/number_line.py

@@ -2,15 +2,18 @@
 
 from __future__ import annotations
 
+from manim.mobject.mobject import Mobject
 from manim.mobject.opengl.opengl_vectorized_mobject import OpenGLVMobject
 
 __all__ = ["NumberLine", "UnitInterval"]
 
 
-from typing import TYPE_CHECKING, Callable, Iterable, Sequence
+from collections.abc import Iterable, Sequence
+from typing import TYPE_CHECKING, Callable
 
 if TYPE_CHECKING:
     from manim.mobject.geometry.tips import ArrowTip
+    from manim.typing import Point3DLike
 
 import numpy as np
 
@@ -274,7 +277,8 @@ class NumberLine(Line):
 
     def add_ticks(self):
         """Adds ticks to the number line. Ticks can be accessed after creation
-        via ``self.ticks``."""
+        via ``self.ticks``.
+        """
         ticks = VGroup()
         elongated_tick_size = self.tick_size * self.longer_tick_multiple
         elongated_tick_offsets = self.numbers_with_elongated_ticks - self.x_min
@@ -343,6 +347,7 @@ class NumberLine(Line):
     def number_to_point(self, number: float | np.ndarray) -> np.ndarray:
         """Accepts a value along the number line and returns a point with
         respect to the scene.
+        Equivalent to `NumberLine @ number`
 
         Parameters
         ----------
@@ -363,7 +368,9 @@ class NumberLine(Line):
             array([0., 0., 0.])
             >>> number_line.number_to_point(1)
             array([1., 0., 0.])
-            >>> number_line.number_to_point([1,2,3])
+            >>> number_line @ 1
+            array([1., 0., 0.])
+            >>> number_line.number_to_point([1, 2, 3])
             array([[1., 0., 0.],
                    [2., 0., 0.],
                    [3., 0., 0.]])
@@ -395,11 +402,11 @@ class NumberLine(Line):
 
             >>> from manim import NumberLine
             >>> number_line = NumberLine()
-            >>> number_line.point_to_number((0,0,0))
-            0.0
-            >>> number_line.point_to_number((1,0,0))
-            1.0
-            >>> number_line.point_to_number([[0.5,0,0],[1,0,0],[1.5,0,0]])
+            >>> number_line.point_to_number((0, 0, 0))
+            np.float64(0.0)
+            >>> number_line.point_to_number((1, 0, 0))
+            np.float64(1.0)
+            >>> number_line.point_to_number([[0.5, 0, 0], [1, 0, 0], [1.5, 0, 0]])
             array([0.5, 1. , 1.5])
 
         """
@@ -574,7 +581,6 @@ class NumberLine(Line):
         AttributeError
             If the label does not have a ``font_size`` attribute, an ``AttributeError`` is raised.
         """
-
         direction = self.label_direction if direction is None else direction
         buff = self.line_to_number_buff if buff is None else buff
         font_size = self.font_size if font_size is None else font_size
@@ -641,6 +647,14 @@ class NumberLine(Line):
             return 0
         return len(step.split(".")[-1])
 
+    def __matmul__(self, other: float):
+        return self.n2p(other)
+
+    def __rmatmul__(self, other: Point3DLike | Mobject):
+        if isinstance(other, Mobject):
+            other = other.get_center()
+        return self.p2n(other)
+
 
 class UnitInterval(NumberLine):
     def __init__(

manim/mobject/graphing/probability.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 __all__ = ["SampleSpace", "BarChart"]
 
 
-from typing import Iterable, MutableSequence, Sequence
+from collections.abc import Iterable, MutableSequence, Sequence
 
 import numpy as np
 
@@ -319,7 +319,6 @@ class BarChart(Axes):
         Primarily used when the bars are initialized with ``self._add_bars``
         or updated via ``self.change_bar_values``.
         """
-
         self.bars.set_color_by_gradient(*self.bar_colors)
 
     def _add_x_axis_labels(self):
@@ -329,7 +328,6 @@ class BarChart(Axes):
 
         UP for negative values and DOWN for positive values.
         """
-
         val_range = np.arange(
             0.5, len(self.bar_names), 1
         )  # 0.5 shifted so that labels are centered, not on ticks
@@ -339,10 +337,7 @@ class BarChart(Axes):
         for i, (value, bar_name) in enumerate(zip(val_range, self.bar_names)):
             # to accommodate negative bars, the label may need to be
             # below or above the x_axis depending on the value of the bar
-            if self.values[i] < 0:
-                direction = UP
-            else:
-                direction = DOWN
+            direction = UP if self.values[i] < 0 else DOWN
             bar_name_label = self.x_axis.label_constructor(bar_name)
 
             bar_name_label.font_size = self.x_axis.font_size
@@ -372,7 +367,6 @@ class BarChart(Axes):
         Rectangle
             A positioned rectangle representing a bar on the chart.
         """
-
         # bar measurements relative to the axis
 
         # distance from between the y-axis and the top of the bar
@@ -435,7 +429,6 @@ class BarChart(Axes):
 
                     self.add(chart, c_bar_lbls)
         """
-
         bar_labels = VGroup()
         for bar, value in zip(self.bars, self.values):
             bar_lbl = label_constructor(str(value))
@@ -483,7 +476,6 @@ class BarChart(Axes):
                     chart.change_bar_values(list(reversed(values)))
                     self.add(chart.get_bar_labels(font_size=24))
         """
-
         for i, (bar, value) in enumerate(zip(self.bars, values)):
             chart_val = self.values[i]