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

manim/mobject/opengl/opengl_image_mobject.py

@@ -29,7 +29,7 @@ class OpenGLImageMobject(OpenGLTexturedSurface):
     ):
         self.image = filename_or_array
         self.resampling_algorithm = resampling_algorithm
-        if type(filename_or_array) == np.ndarray:
+        if isinstance(filename_or_array, np.ndarray):
             self.size = self.image.shape[1::-1]
         elif isinstance(filename_or_array, (str, Path)):
             path = get_full_raster_image_path(filename_or_array)

manim/mobject/opengl/opengl_mobject.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import copy
+import inspect
 import itertools as it
 import random
 import sys
@@ -10,13 +11,19 @@ from typing import Iterable, Sequence
 
 import moderngl
 import numpy as np
-from colour import Color
 
 from manim import config, logger
 from manim.constants import *
+from manim.renderer.shader_wrapper import get_colormap_code
 from manim.utils.bezier import integer_interpolate, interpolate
-from manim.utils.color import *
-from manim.utils.color import Colors
+from manim.utils.color import (
+    WHITE,
+    ManimColor,
+    ParsableManimColor,
+    color_gradient,
+    color_to_rgb,
+    rgb_to_hex,
+)
 from manim.utils.config_ops import _Data, _Uniforms
 
 # from ..utils.iterables import batch_by_property
@@ -31,7 +38,6 @@ from manim.utils.iterables import (
     uniq_chain,
 )
 from manim.utils.paths import straight_path
-from manim.utils.simple_functions import get_parameters
 from manim.utils.space_ops import (
     angle_between_vectors,
     normalize,
@@ -146,7 +152,7 @@ class OpenGLMobject:
         self.init_updaters()
         # self.init_event_listners()
         self.init_points()
-        self.color = Color(color) if color else None
+        self.color = ManimColor.parse(color)
         self.init_colors()
 
         self.shader_indices = None
@@ -203,10 +209,10 @@ class OpenGLMobject:
             >>> from manim import Square, GREEN
             >>> Square.set_default(color=GREEN, fill_opacity=0.25)
             >>> s = Square(); s.color, s.fill_opacity
-            (<Color #83c167>, 0.25)
+            (ManimColor('#83C167'), 0.25)
             >>> Square.set_default()
             >>> s = Square(); s.color, s.fill_opacity
-            (<Color white>, 0.0)
+            (ManimColor('#FFFFFF'), 0.0)
 
         .. manim:: ChangedDefaultTextcolor
             :save_last_frame:
@@ -1377,7 +1383,7 @@ class OpenGLMobject:
         return list(it.chain(*(sm.get_updaters() for sm in self.get_family())))
 
     def add_updater(self, update_function, index=None, call_updater=False):
-        if "dt" in get_parameters(update_function):
+        if "dt" in inspect.signature(update_function).parameters:
             updater_list = self.time_based_updaters
         else:
             updater_list = self.non_time_updaters
@@ -1971,12 +1977,12 @@ class OpenGLMobject:
         for mob in self.get_family(recurse):
             mob.data[name] = rgbas.copy()
 
-    def set_color(self, color, opacity=None, recurse=True):
+    def set_color(self, color: ParsableManimColor | None, opacity=None, recurse=True):
         self.set_rgba_array(color, opacity, recurse=False)
         # Recurse to submobjects differently from how set_rgba_array
         # in case they implement set_color differently
         if color is not None:
-            self.color = Color(color)
+            self.color: ManimColor = ManimColor.parse(color)
         if opacity is not None:
             self.opacity = opacity
         if recurse:
@@ -2037,7 +2043,7 @@ class OpenGLMobject:
     # Background rectangle
 
     def add_background_rectangle(
-        self, color: Colors | None = None, opacity: float = 0.75, **kwargs
+        self, color: ParsableManimColor | None = None, opacity: float = 0.75, **kwargs
     ):
         # TODO, this does not behave well when the mobject has points,
         # since it gets displayed on top
@@ -2725,7 +2731,7 @@ class OpenGLMobject:
 
 class OpenGLGroup(OpenGLMobject):
     def __init__(self, *mobjects, **kwargs):
-        if not all([isinstance(m, OpenGLMobject) for m in mobjects]):
+        if not all(isinstance(m, OpenGLMobject) for m in mobjects):
             raise Exception("All submobjects must be of type OpenGLMobject")
         super().__init__(**kwargs)
         self.add(*mobjects)

manim/mobject/opengl/opengl_point_cloud_mobject.py

@@ -162,7 +162,7 @@ class OpenGLPMobject(OpenGLMobject):
 
 class OpenGLPGroup(OpenGLPMobject):
     def __init__(self, *pmobs, **kwargs):
-        if not all([isinstance(m, OpenGLPMobject) for m in pmobs]):
+        if not all(isinstance(m, OpenGLPMobject) for m in pmobs):
             raise Exception("All submobjects must be of type OpenglPMObject")
         super().__init__(**kwargs)
         self.add(*pmobs)

manim/mobject/opengl/opengl_surface.py

@@ -380,7 +380,7 @@ class OpenGLTexturedSurface(OpenGLSurface):
 
         if not isinstance(uv_surface, OpenGLSurface):
             raise Exception("uv_surface must be of type OpenGLSurface")
-        if type(image_file) == np.ndarray:
+        if isinstance(image_file, np.ndarray):
             image_file = change_to_rgba_array(image_file)
 
         # Set texture information

manim/mobject/opengl/opengl_vectorized_mobject.py

@@ -3,11 +3,10 @@ from __future__ import annotations
 import itertools as it
 import operator as op
 from functools import reduce, wraps
-from typing import Callable, Iterable, Optional, Sequence
+from typing import Callable, Iterable, Sequence
 
 import moderngl
 import numpy as np
-from colour import Color
 
 from manim import config
 from manim.constants import *
@@ -23,7 +22,7 @@ from manim.utils.bezier import (
     proportions_along_bezier_curve_for_point,
     quadratic_bezier_remap,
 )
-from manim.utils.color import *
+from manim.utils.color import BLACK, WHITE, ManimColor, ParsableManimColor
 from manim.utils.config_ops import _Data
 from manim.utils.iterables import listify, make_even, resize_with_interpolation
 from manim.utils.space_ops import (
@@ -81,9 +80,9 @@ class OpenGLVMobject(OpenGLMobject):
 
     def __init__(
         self,
-        fill_color: Color | None = None,
+        fill_color: ParsableManimColor | None = None,
         fill_opacity: float = 0.0,
-        stroke_color: Color | None = None,
+        stroke_color: ParsableManimColor | None = None,
         stroke_opacity: float = 1.0,
         stroke_width: float = DEFAULT_STROKE_WIDTH,
         draw_stroke_behind_fill: bool = False,
@@ -137,6 +136,7 @@ class OpenGLVMobject(OpenGLMobject):
         self.needs_new_triangulation = True
         self.triangulation = np.zeros(0, dtype="i4")
         self.orientation = 1
+
         self.fill_data = None
         self.stroke_data = None
         self.fill_shader_wrapper = None
@@ -146,10 +146,10 @@ class OpenGLVMobject(OpenGLMobject):
         super().__init__(**kwargs)
         self.refresh_unit_normal()
 
-        if fill_color:
-            self.fill_color = Color(fill_color)
-        if stroke_color:
-            self.stroke_color = Color(stroke_color)
+        if fill_color is not None:
+            self.fill_color = ManimColor.parse(fill_color)
+        if stroke_color is not None:
+            self.stroke_color = ManimColor.parse(stroke_color)
 
     def get_group_class(self):
         return OpenGLVGroup
@@ -184,7 +184,7 @@ class OpenGLVMobject(OpenGLMobject):
 
     def set_fill(
         self,
-        color: Color | None = None,
+        color: ParsableManimColor | None = None,
         opacity: float | None = None,
         recurse: bool = True,
     ) -> OpenGLVMobject:
@@ -350,14 +350,15 @@ class OpenGLVMobject(OpenGLMobject):
         super().fade(darkness, recurse)
         return self
 
+    # Todo im not quite sure why we are doing this
     def get_fill_colors(self):
-        return [Color(rgb_to_hex(rgba[:3])) for rgba in self.fill_rgba]
+        return [ManimColor.from_rgb(rgba[:3]) for rgba in self.fill_rgba]
 
     def get_fill_opacities(self):
         return self.fill_rgba[:, 3]
 
     def get_stroke_colors(self):
-        return [Color(rgb_to_hex(rgba[:3])) for rgba in self.stroke_rgba]
+        return [ManimColor.from_rgb(rgba[:3]) for rgba in self.stroke_rgba]
 
     def get_stroke_opacities(self):
         return self.stroke_rgba[:, 3]
@@ -1283,14 +1284,17 @@ class OpenGLVMobject(OpenGLMobject):
         for _ in range(-diff):
             ipc[np.argmax(ipc)] -= 1
 
-        new_points = []
+        new_length = sum(x + 1 for x in ipc)
+        new_points = np.empty((new_length, nppc, 3))
+        i = 0
         for group, n_inserts in zip(bezier_groups, ipc):
             # What was once a single quadratic curve defined
             # by "group" will now be broken into n_inserts + 1
             # smaller quadratic curves
             alphas = np.linspace(0, 1, n_inserts + 2)
             for a1, a2 in zip(alphas, alphas[1:]):
-                new_points += partial_quadratic_bezier_points(group, a1, a2)
+                new_points[i] = partial_quadratic_bezier_points(group, a1, a2)
+                i = i + 1
         return np.vstack(new_points)
 
     def interpolate(self, mobject1, mobject2, alpha, *args, **kwargs):
@@ -1301,7 +1305,7 @@ class OpenGLVMobject(OpenGLMobject):
             if self.has_fill():
                 tri1 = mobject1.get_triangulation()
                 tri2 = mobject2.get_triangulation()
-                if len(tri1) != len(tri1) or not np.all(tri1 == tri2):
+                if len(tri1) != len(tri2) or not np.all(tri1 == tri2):
                     self.refresh_triangulation()
         return self
 
@@ -1676,7 +1680,7 @@ class OpenGLVGroup(OpenGLVMobject):
     """
 
     def __init__(self, *vmobjects, **kwargs):
-        if not all([isinstance(m, OpenGLVMobject) for m in vmobjects]):
+        if not all(isinstance(m, OpenGLVMobject) for m in vmobjects):
             raise Exception("All submobjects must be of type OpenGLVMobject")
         super().__init__(**kwargs)
         self.add(*vmobjects)
@@ -1881,7 +1885,7 @@ class OpenGLDashedVMobject(OpenGLVMobject):
         vmobject: OpenGLVMobject,
         num_dashes: int = 15,
         dashed_ratio: float = 0.5,
-        color: Color = WHITE,
+        color: ParsableManimColor = WHITE,
         **kwargs,
     ):
         self.dashed_ratio = dashed_ratio

manim/mobject/svg/brace.py

@@ -335,10 +335,12 @@ class ArcBrace(Brace):
 
     def __init__(
         self,
-        arc: Arc = Arc(start_angle=-1, angle=2, radius=1),
+        arc: Arc | None = None,
         direction: Sequence[float] = RIGHT,
         **kwargs,
     ):
+        if arc is None:
+            arc = Arc(start_angle=-1, angle=2, radius=1)
         arc_end_angle = arc.start_angle + arc.angle
         line = Line(UP * arc.start_angle, UP * arc_end_angle)
         scale_shift = RIGHT * np.log(arc.radius)

manim/mobject/svg/svg_mobject.py

@@ -280,7 +280,7 @@ class SVGMobject(VMobject, metaclass=ConvertToOpenGL):
                 mob = self.polyline_to_mobject(shape)
             elif isinstance(shape, se.Text):
                 mob = self.text_to_mobject(shape)
-            elif isinstance(shape, se.Use) or type(shape) == se.SVGElement:
+            elif isinstance(shape, se.Use) or type(shape) is se.SVGElement:
                 continue
             else:
                 logger.warning(f"Unsupported element type: {type(shape)}")
@@ -510,17 +510,15 @@ class VMobjectFromSVGPath(VMobject, metaclass=ConvertToOpenGL):
         all_points: list[np.ndarray] = []
         last_move = None
         curve_start = None
+        last_true_move = None
 
-        # These lambdas behave the same as similar functions in
-        # vectorized_mobject, except they add to a list of points instead
-        # of updating this Mobject's numpy array of points. This way,
-        # we don't observe O(n^2) behavior for complex paths due to
-        # numpy's need to re-allocate memory on every append.
-        def move_pen(pt):
-            nonlocal last_move, curve_start
+        def move_pen(pt, *, true_move: bool = False):
+            nonlocal last_move, curve_start, last_true_move
             last_move = pt
             if curve_start is None:
                 curve_start = last_move
+            if true_move:
+                last_true_move = last_move
 
         if self.n_points_per_curve == 4:
 
@@ -568,7 +566,7 @@ class VMobjectFromSVGPath(VMobject, metaclass=ConvertToOpenGL):
         for segment in self.path_obj:
             segment_class = segment.__class__
             if segment_class == se.Move:
-                move_pen(_convert_point_to_3d(*segment.end))
+                move_pen(_convert_point_to_3d(*segment.end), true_move=True)
             elif segment_class == se.Line:
                 add_line(last_move, _convert_point_to_3d(*segment.end))
             elif segment_class == se.QuadraticBezier:
@@ -588,8 +586,8 @@ class VMobjectFromSVGPath(VMobject, metaclass=ConvertToOpenGL):
                 # If the SVG path naturally ends at the beginning of the curve,
                 # we do *not* need to draw a closing line. To account for floating
                 # point precision, we use a small value to compare the two points.
-                if abs(np.linalg.norm(last_move - curve_start)) > 0.0001:
-                    add_line(last_move, curve_start)
+                if abs(np.linalg.norm(last_move - last_true_move)) > 0.0001:
+                    add_line(last_move, last_true_move)
                 curve_start = None
             else:
                 raise AssertionError(f"Not implemented: {segment_class}")

manim/mobject/table.py

@@ -67,8 +67,6 @@ __all__ = [
 import itertools as it
 from typing import Callable, Iterable, Sequence
 
-from colour import Color
-
 from manim.mobject.geometry.line import Line
 from manim.mobject.geometry.polygram import Polygon
 from manim.mobject.geometry.shape_matchers import BackgroundRectangle
@@ -82,13 +80,50 @@ from ..animation.composition import AnimationGroup
 from ..animation.creation import Create, Write
 from ..animation.fading import FadeIn
 from ..mobject.types.vectorized_mobject import VGroup, VMobject
-from ..utils.color import BLACK, YELLOW
+from ..utils.color import BLACK, YELLOW, ManimColor, ParsableManimColor
 from .utils import get_vectorized_mobject_class
 
 
 class Table(VGroup):
     """A mobject that displays a table on the screen.
 
+    Parameters
+    ----------
+    table
+        A 2D array or list of lists. Content of the table has to be a valid input
+        for the callable set in ``element_to_mobject``.
+    row_labels
+        List of :class:`~.VMobject` representing the labels of each row.
+    col_labels
+        List of :class:`~.VMobject` representing the labels of each column.
+    top_left_entry
+        The top-left entry of the table, can only be specified if row and
+        column labels are given.
+    v_buff
+        Vertical buffer passed to :meth:`~.Mobject.arrange_in_grid`, by default 0.8.
+    h_buff
+        Horizontal buffer passed to :meth:`~.Mobject.arrange_in_grid`, by default 1.3.
+    include_outer_lines
+        ``True`` if the table should include outer lines, by default False.
+    add_background_rectangles_to_entries
+        ``True`` if background rectangles should be added to entries, by default ``False``.
+    entries_background_color
+        Background color of entries if ``add_background_rectangles_to_entries`` is ``True``.
+    include_background_rectangle
+        ``True`` if the table should have a background rectangle, by default ``False``.
+    background_rectangle_color
+        Background color of table if ``include_background_rectangle`` is ``True``.
+    element_to_mobject
+        The :class:`~.Mobject` class applied to the table entries. by default :class:`~.Paragraph`. For common choices, see :mod:`~.text_mobject`/:mod:`~.tex_mobject`.
+    element_to_mobject_config
+        Custom configuration passed to :attr:`element_to_mobject`, by default {}.
+    arrange_in_grid_config
+        Dict passed to :meth:`~.Mobject.arrange_in_grid`, customizes the arrangement of the table.
+    line_config
+        Dict passed to :class:`~.Line`, customizes the lines of the table.
+    kwargs
+        Additional arguments to be passed to :class:`~.VGroup`.
+
     Examples
     --------
 
@@ -160,9 +195,9 @@ class Table(VGroup):
         h_buff: float = 1.3,
         include_outer_lines: bool = False,
         add_background_rectangles_to_entries: bool = False,
-        entries_background_color: Color = BLACK,
+        entries_background_color: ParsableManimColor = BLACK,
         include_background_rectangle: bool = False,
-        background_rectangle_color: Color = BLACK,
+        background_rectangle_color: ParsableManimColor = BLACK,
         element_to_mobject: Callable[
             [float | str | VMobject],
             VMobject,
@@ -172,45 +207,6 @@ class Table(VGroup):
         line_config: dict = {},
         **kwargs,
     ):
-        """
-        Parameters
-        ----------
-        table
-            A 2D array or list of lists. Content of the table has to be a valid input
-            for the callable set in ``element_to_mobject``.
-        row_labels
-            List of :class:`~.VMobject` representing the labels of each row.
-        col_labels
-            List of :class:`~.VMobject` representing the labels of each column.
-        top_left_entry
-            The top-left entry of the table, can only be specified if row and
-            column labels are given.
-        v_buff
-            Vertical buffer passed to :meth:`~.Mobject.arrange_in_grid`, by default 0.8.
-        h_buff
-            Horizontal buffer passed to :meth:`~.Mobject.arrange_in_grid`, by default 1.3.
-        include_outer_lines
-            ``True`` if the table should include outer lines, by default False.
-        add_background_rectangles_to_entries
-            ``True`` if background rectangles should be added to entries, by default ``False``.
-        entries_background_color
-            Background color of entries if ``add_background_rectangles_to_entries`` is ``True``.
-        include_background_rectangle
-            ``True`` if the table should have a background rectangle, by default ``False``.
-        background_rectangle_color
-            Background color of table if ``include_background_rectangle`` is ``True``.
-        element_to_mobject
-            The :class:`~.Mobject` class applied to the table entries. by default :class:`~.Paragraph`. For common choices, see :mod:`~.text_mobject`/:mod:`~.tex_mobject`.
-        element_to_mobject_config
-            Custom configuration passed to :attr:`element_to_mobject`, by default {}.
-        arrange_in_grid_config
-            Dict passed to :meth:`~.Mobject.arrange_in_grid`, customizes the arrangement of the table.
-        line_config
-            Dict passed to :class:`~.Line`, customizes the lines of the table.
-        kwargs
-            Additional arguments to be passed to :class:`~.VGroup`.
-        """
-
         self.row_labels = row_labels
         self.col_labels = col_labels
         self.top_left_entry = top_left_entry
@@ -220,9 +216,9 @@ class Table(VGroup):
         self.h_buff = h_buff
         self.include_outer_lines = include_outer_lines
         self.add_background_rectangles_to_entries = add_background_rectangles_to_entries
-        self.entries_background_color = entries_background_color
+        self.entries_background_color = ManimColor(entries_background_color)
         self.include_background_rectangle = include_background_rectangle
-        self.background_rectangle_color = background_rectangle_color
+        self.background_rectangle_color = ManimColor(background_rectangle_color)
         self.element_to_mobject = element_to_mobject
         self.element_to_mobject_config = element_to_mobject_config
         self.arrange_in_grid_config = arrange_in_grid_config
@@ -506,7 +502,7 @@ class Table(VGroup):
         """
         return VGroup(*(VGroup(*row) for row in self.mob_table))
 
-    def set_column_colors(self, *colors: Iterable[Color]) -> Table:
+    def set_column_colors(self, *colors: Iterable[ParsableManimColor]) -> Table:
         """Set individual colors for each column of the table.
 
         Parameters
@@ -535,7 +531,7 @@ class Table(VGroup):
             column.set_color(color)
         return self
 
-    def set_row_colors(self, *colors: Iterable[Color]) -> Table:
+    def set_row_colors(self, *colors: Iterable[ParsableManimColor]) -> Table:
         """Set individual colors for each row of the table.
 
         Parameters
@@ -754,10 +750,10 @@ class Table(VGroup):
                 label_group.add(*label)
         return label_group
 
-    def add_background_to_entries(self, color: Color = BLACK) -> Table:
+    def add_background_to_entries(self, color: ParsableManimColor = BLACK) -> Table:
         """Adds a black :class:`~.BackgroundRectangle` to each entry of the table."""
         for mob in self.get_entries():
-            mob.add_background_rectangle(color=color)
+            mob.add_background_rectangle(color=ManimColor(color))
         return self
 
     def get_cell(self, pos: Sequence[int] = (1, 1), **kwargs) -> Polygon:
@@ -818,7 +814,7 @@ class Table(VGroup):
         return rec
 
     def get_highlighted_cell(
-        self, pos: Sequence[int] = (1, 1), color: Color = YELLOW, **kwargs
+        self, pos: Sequence[int] = (1, 1), color: ParsableManimColor = YELLOW, **kwargs
     ) -> BackgroundRectangle:
         """Returns a :class:`~.BackgroundRectangle` of the cell at the given position.
 
@@ -850,11 +846,11 @@ class Table(VGroup):
                     self.add(table)
         """
         cell = self.get_cell(pos)
-        bg_cell = BackgroundRectangle(cell, color=color, **kwargs)
+        bg_cell = BackgroundRectangle(cell, color=ManimColor(color), **kwargs)
         return bg_cell
 
     def add_highlighted_cell(
-        self, pos: Sequence[int] = (1, 1), color: Color = YELLOW, **kwargs
+        self, pos: Sequence[int] = (1, 1), color: ParsableManimColor = YELLOW, **kwargs
     ) -> Table:
         """Highlights one cell at a specific position on the table by adding a :class:`~.BackgroundRectangle`.
 
@@ -884,7 +880,7 @@ class Table(VGroup):
                     table.add_highlighted_cell((2,2), color=GREEN)
                     self.add(table)
         """
-        bg_cell = self.get_highlighted_cell(pos, color=color, **kwargs)
+        bg_cell = self.get_highlighted_cell(pos, color=ManimColor(color), **kwargs)
         self.add_to_back(bg_cell)
         entry = self.get_entries(pos)
         entry.background_rectangle = bg_cell

manim/mobject/text/numbers.py

@@ -22,6 +22,34 @@ string_to_mob_map = {}
 class DecimalNumber(VMobject, metaclass=ConvertToOpenGL):
     """An mobject representing a decimal number.
 
+    Parameters
+    ----------
+    number
+        The numeric value to be displayed. It can later be modified using :meth:`.set_value`.
+    num_decimal_places
+        The number of decimal places after the decimal separator. Values are automatically rounded.
+    mob_class
+        The class for rendering digits and units, by default :class:`.MathTex`.
+    include_sign
+        Set to ``True`` to include a sign for positive numbers and zero.
+    group_with_commas
+        When ``True`` thousands groups are separated by commas for readability.
+    digit_buff_per_font_unit
+        Additional spacing between digits. Scales with font size.
+    show_ellipsis
+        When a number has been truncated by rounding, indicate with an ellipsis (``...``).
+    unit
+        A unit string which can be placed to the right of the numerical values.
+    unit_buff_per_font_unit
+        An additional spacing between the numerical values and the unit. A value
+        of ``unit_buff_per_font_unit=0.003`` gives a decent spacing. Scales with font size.
+    include_background_rectangle
+        Adds a background rectangle to increase contrast on busy scenes.
+    edge_to_fix
+        Assuring right- or left-alignment of the full object.
+    font_size
+        Size of the font.
+
     Examples
     --------
 
@@ -34,6 +62,8 @@ class DecimalNumber(VMobject, metaclass=ConvertToOpenGL):
                     show_ellipsis=True,
                     num_decimal_places=3,
                     include_sign=True,
+                    unit=r"\text{M-Units}",
+                    unit_buff_per_font_unit=0.003
                 )
                 square = Square().to_edge(UP)
 
@@ -59,6 +89,7 @@ class DecimalNumber(VMobject, metaclass=ConvertToOpenGL):
         digit_buff_per_font_unit: float = 0.001,
         show_ellipsis: bool = False,
         unit: str | None = None,  # Aligned to bottom unless it starts with "^"
+        unit_buff_per_font_unit: float = 0,
         include_background_rectangle: bool = False,
         edge_to_fix: Sequence[float] = LEFT,
         font_size: float = DEFAULT_FONT_SIZE,
@@ -66,7 +97,7 @@ class DecimalNumber(VMobject, metaclass=ConvertToOpenGL):
         fill_opacity: float = 1.0,
         **kwargs,
     ):
-        super().__init__(**kwargs)
+        super().__init__(**kwargs, stroke_width=stroke_width)
         self.number = number
         self.num_decimal_places = num_decimal_places
         self.include_sign = include_sign
@@ -75,10 +106,10 @@ class DecimalNumber(VMobject, metaclass=ConvertToOpenGL):
         self.digit_buff_per_font_unit = digit_buff_per_font_unit
         self.show_ellipsis = show_ellipsis
         self.unit = unit
+        self.unit_buff_per_font_unit = unit_buff_per_font_unit
         self.include_background_rectangle = include_background_rectangle
         self.edge_to_fix = edge_to_fix
         self._font_size = font_size
-        self.stroke_width = stroke_width
         self.fill_opacity = fill_opacity
 
         self.initial_config = kwargs.copy()
@@ -90,6 +121,7 @@ class DecimalNumber(VMobject, metaclass=ConvertToOpenGL):
                 "digit_buff_per_font_unit": digit_buff_per_font_unit,
                 "show_ellipsis": show_ellipsis,
                 "unit": unit,
+                "unit_buff_per_font_unit": unit_buff_per_font_unit,
                 "include_background_rectangle": include_background_rectangle,
                 "edge_to_fix": edge_to_fix,
                 "font_size": font_size,
@@ -131,15 +163,25 @@ class DecimalNumber(VMobject, metaclass=ConvertToOpenGL):
                 self._string_to_mob("\\dots", SingleStringMathTex, color=self.color),
             )
 
-        if self.unit is not None:
-            self.unit_sign = self._string_to_mob(self.unit, SingleStringMathTex)
-            self.add(self.unit_sign)
-
         self.arrange(
             buff=self.digit_buff_per_font_unit * self._font_size,
             aligned_edge=DOWN,
         )
 
+        if self.unit is not None:
+            self.unit_sign = self._string_to_mob(self.unit, SingleStringMathTex)
+            self.add(
+                self.unit_sign.next_to(
+                    self,
+                    direction=RIGHT,
+                    buff=(self.unit_buff_per_font_unit + self.digit_buff_per_font_unit)
+                    * self._font_size,
+                    aligned_edge=DOWN,
+                )
+            )
+
+        self.move_to(ORIGIN)
+
         # Handle alignment of parts that should be aligned
         # to the bottom
         for i, c in enumerate(num_string):