e2D 1.4.12__py3-none-any.whl → 1.4.14__py3-none-any.whl

e2D/__init__.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 import math as _mt
 import random as _rnd
+from typing import Any, Generator, Literal
 
 PI = _mt.pi
-HALF_PI = PI/2
-QUARTER_PI = PI/4
-DOUBLE_PI = PI*2
+PI_HALF = PI/2
+PI_QUARTER = PI/4
+PI_DOUBLE = PI*2
 
 sign = lambda val: -1 if val < 0 else (1 if val > 0 else 0)
 
@@ -16,9 +17,9 @@ class Vector2D:
         self.x = x
         self.y = y
 
-    def distance_to(self, other, sqrd=True) -> int|float:
+    def distance_to(self, other, rooted=True) -> int|float:
         d = (self.x - other.x)**2 + (self.y - other.y)**2
-        return (d**(1/2) if sqrd else d)
+        return d**(1/2) if rooted else d
 
     def angle_to(self, other) -> int|float:
         return _mt.atan2(other.y - self.y, other.x - self.x)
@@ -31,8 +32,8 @@ class Vector2D:
         return _mt.atan2(self.y, self.x)
 
     @angle.setter
-    def angle(self, argv) -> None:
-        print(argv)
+    def angle(self, new_angle) -> None:
+        self.rotate(new_angle - self.angle)
 
     @property
     def copy(self) -> "Vector2D":
@@ -41,16 +42,20 @@ class Vector2D:
     @property
     def sign(self) -> "Vector2D":
         return Vector2D(sign(self.x), sign(self.y))
-    
+
     @property
     def normalize(self) -> "Vector2D":
         if (mag:=self.length) == 0:
             return self.copy
         return Vector2D(self.x / mag, self.y / mag)
-    
+
     @property
     def length(self) -> float:
         return (self.x ** 2 + self.y ** 2) ** .5
+    
+    @property
+    def length_sqrd(self) -> float:
+        return self.x ** 2 + self.y ** 2
 
     def floor(self, n=1) -> "Vector2D":
         return self.__floor__(n)
@@ -88,16 +93,12 @@ class Vector2D:
     def reflection(self, normal) -> "Vector2D":
         return self - self.projection(normal) * 2
 
-    def cartesian_to_polar(self) -> tuple:
-        r = self.length
-        theta = _mt.atan2(self.y, self.x)
-        return r, theta
+    def cartesian_to_polar(self) -> tuple[float, float]:
+        return self.length, _mt.atan2(self.y, self.x)
 
     @classmethod
     def polar_to_cartesian(cls, r, theta) -> "Vector2D":
-        x = r * _mt.cos(theta)
-        y = r * _mt.sin(theta)
-        return cls(x, y)
+        return cls(r * _mt.cos(theta), r * _mt.sin(theta))
 
     def cartesian_to_complex(self) -> complex:
         return self.x + self.y * 1j
@@ -107,19 +108,17 @@ class Vector2D:
         return cls(complex_n.real, complex_n.imag)
 
     def lerp(self, other, t=.1) -> "Vector2D":
-        other = Vector2D.__normalize__(other)
-        if not 0 <= t <= 1:
-            raise ValueError("t must be between 0 and 1 for linear interpolation.")
         return Vector2D(self.x + (other.x - self.x) * t, self.y + (other.y - self.y) * t)
 
-    def rotate(self, angle, center=None) -> "Vector2D":
-        if center is None: center = Vector2D.zero()
+    def rotate(self, angle, center=None) -> None:
+        if center == None: center = Vector2D.zero()
         translated = self - center
         cos_angle = _mt.cos(angle)
         sin_angle = _mt.sin(angle)
-        return Vector2D(translated.x * cos_angle - translated.y * sin_angle, translated.x * sin_angle + translated.y * cos_angle) + center
+        self.x = translated.x * cos_angle - translated.y * sin_angle + center.x
+        self.y = translated.x * sin_angle + translated.y * cos_angle + center.y
 
-    def no_zero_div_error(self, n, error_mode="zero") -> "Vector2D":
+    def no_zero_div_error(self, n, error_mode=Literal["zero", "null", "nan"]) -> "Vector2D":
         if isinstance(n, (int, float)):
             if n == 0:
                 return Vector2D(0 if error_mode ==  "zero" else (self.x if error_mode == "null" else _mt.nan), 0 if error_mode == "zero" else (self.y if error_mode == "null" else _mt.nan))
@@ -166,20 +165,20 @@ class Vector2D:
     def sub(self, both=.0, x=.0, y=.0) -> Vector2D:
         return Vector2D(self.x - (x + both), self.y - (y + both))
     
-    def mult(self, both=.0, x=.0, y=.0) -> Vector2D:
-        return Vector2D(self.x * (x + both), self.y * (y + both))
+    def mult(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
+        return Vector2D(self.x * x * both, self.y * y * both)
     
-    def pow(self, both=.0, x=.0, y=.0) -> Vector2D:
+    def pow(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
         return Vector2D(self.x ** (x + both), self.y ** (y + both))
     
-    def mod(self, both=.0, x=.0, y=.0) -> Vector2D:
+    def mod(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
         return Vector2D(self.x % (x + both), self.y % (y + both))
     
-    def div(self, both=.0, x=.0, y=.0) -> Vector2D:
-        return Vector2D(self.x / (x + both), self.y / (y + both))
+    def div(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
+        return Vector2D(self.x / x / both, self.y / y / both)
     
-    def fdiv(self, both=.0, x=.0, y=.0) -> Vector2D:
-        return Vector2D(self.x // (x + both), self.y // (y + both))
+    def fdiv(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
+        return Vector2D(self.x // x // both, self.y // y // both)
 
     # fast inplace operations     Vector2D.ioperation(both,x,y)
     def set(self, both=.0, x=.0, y=.0) -> Vector2D:
@@ -197,29 +196,29 @@ class Vector2D:
         self.y -= y + both
         return self
     
-    def imult(self, both=.0, x=.0, y=.0) -> Vector2D:
-        self.x *= x + both
-        self.y *= y + both
+    def imult(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
+        self.x *= x * both
+        self.y *= y * both
         return self
     
-    def ipow(self, both=.0, x=.0, y=.0) -> Vector2D:
+    def ipow(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
         self.x **= x + both
         self.y **= y + both
         return self
     
-    def imod(self, both=.0, x=.0, y=.0) -> Vector2D:
+    def imod(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
         self.x %= x + both
         self.y %= y + both
         return self
     
-    def idiv(self, both=.0, x=.0, y=.0) -> Vector2D:
-        self.x /= x + both
-        self.y /= y + both
+    def idiv(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
+        self.x /= x * both
+        self.y /= y * both
         return self
     
-    def ifdiv(self, both=.0, x=.0, y=.0) -> Vector2D:
-        self.x //= x + both
-        self.y //= y + both
+    def ifdiv(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
+        self.x //= x * both
+        self.y //= y * both
         return self
 
     # normal operations     Vector2D + a
@@ -356,6 +355,10 @@ class Vector2D:
         else:
             raise IndexError("V2 has only x,y...")
     
+    def __iter__(self) -> Generator[float, Any, None]:
+        yield self.x
+        yield self.y
+    
     @classmethod
     def __normalize__(cls, other) -> "Vector2D":
         if isinstance(other, Vector2D):
@@ -496,22 +499,22 @@ VECTORS_8_DIRECTIONS_NORM = (V2right, V2down_right_norm, V2down, V2down_left_nor
 def rgb(r:float, g:float, b:float) -> tuple[float, float, float]:
     return (r,g,b)
 
-# def color_lerp(current_c:list|tuple, final_c:list|tuple, step=.1) -> tuple[float, float, float]:
-#     return tuple(c + (final_c[i] - c) * step for i,c in enumerate(current_c)) #type: ignore
+def color_lerp(current_c:list|tuple, final_c:list|tuple, step=.1) -> tuple[float, float, float]:
+    return tuple(c + (final_c[i] - c) * step for i,c in enumerate(current_c)) #type: ignore
 
-# def color_fade(starting_c:list|tuple, final_c:list|tuple, index, max_index) -> tuple[float, float, float]:
-#     return tuple((starting_c[i] - final_c[i]) / max_index * (max_index - index) + final_c[i] for i in range(3)) #type: ignore
+def color_fade(starting_c:list|tuple, final_c:list|tuple, index, max_index) -> tuple[float, float, float]:
+    return tuple((starting_c[i] - final_c[i]) / max_index * (max_index - index) + final_c[i] for i in range(3)) #type: ignore
 
-# def weighted_color_fade(colors_dict:dict) -> tuple[float, float, float]:
-#     colors = colors_dict.keys()
-#     weights = colors_dict.values()
+def weighted_color_fade(colors_dict:dict) -> tuple[float, float, float]:
+    colors = colors_dict.keys()
+    weights = colors_dict.values()
 
-#     if float("inf") in weights: return list(colors)[list(weights).index(float("inf"))]
-#     return tuple(sum(n[i]*w for n,w in zip(colors, weights)) / sum(weights) for i in range(3)) #type: ignore
+    if float("inf") in weights: return list(colors)[list(weights).index(float("inf"))]
+    return tuple(sum(n[i]*w for n,w in zip(colors, weights)) / sum(weights) for i in range(3)) #type: ignore
 
-# def color_distance(starting_c:list|tuple, final_c:list|tuple, sqrd) -> float:
-#     distance = sum([(starting_c[i]-final_c[i])**2 for i in range(3)])
-#     return (distance ** .5) if sqrd else distance
+def color_distance(starting_c:list|tuple, final_c:list|tuple, rooted) -> float:
+    distance = sum([(starting_c[i]-final_c[i])**2 for i in range(3)])
+    return (distance ** .5) if rooted else distance
 
 def lerp(starting, ending, step=.1) -> float:
     return starting + (ending - starting) * step
@@ -522,7 +525,7 @@ def angular_interpolation(starting_angle, final_angle, step=.1) -> float:
     # return starting_angle + min((delta, delta - DOUBLE_PI, delta + DOUBLE_PI), key=abs) * step
     
     # math way
-    shortest_angle = ((((final_angle - starting_angle) % DOUBLE_PI) + DOUBLE_PI * 1.5) % DOUBLE_PI) - PI
+    shortest_angle = ((((final_angle - starting_angle) % PI_DOUBLE) + PI_DOUBLE * 1.5) % PI_DOUBLE) - PI
     return starting_angle + shortest_angle * step
 
 def bezier_cubic_interpolation(t, p0, p1) -> float:

e2D/__init__.pyi

@@ -1,10 +1,10 @@
 from __future__ import annotations
-from typing import Callable, Literal
+from typing import Any, Callable, Generator, Literal
 
 PI : float
-HALF_PI : float
-QUARTER_PI : float
-DOUBLE_PI : float
+PI_HALF : float
+PI_QUARTER : float
+PI_DOUBLE : float
 
 # regular expression to remove comments:
 # """([\s\S]*?)"""
@@ -39,31 +39,31 @@ class Vector2D:
         self.x : int|float
         self.y : int|float
 
-    def distance_to(self:"Vector2D", other:"Vector2D", sqrd:bool=True) -> int|float:
+    def distance_to(self:"Vector2D", other:"Vector2D", rooted:bool=True) -> int|float:
         """
         # Calculate the distance between the current Vector2D other and another other.
 
         ## Parameters:
             other (float or int or Vector2D or list|tuple): The other other to which the distance is calculated.
-            squared (bool, optional): If True, return the squared distance. If False, return the actual distance.
+            rooted (bool, optional): If True, return the normal distance. If False, return the square distance.
                                       Default is True.
 
         ## Returns:
-            int|float: The squared distance between the current Vector2D other and the other other if `squared` is True,
-                      otherwise the actual distance.
+            int|float: The distance between the current Vector2D other and the other other if `rooted` is True,
+                      otherwise the squared distance.
 
         ## Example:
             point1 = Vector2D(0, 0)
 
             point2 = Vector2D(3, 4)
 
-            squared_distance = point1.distance_to(point2)
+            normal_distance = point1.distance_to(point2)
 
-            print(f"Squared Distance: {squared_distance}")
+            print(f"Normal Distance: {normal_distance}")
 
-            distance = point1.distance_to(point2, squared=False)
+            squared_distance = point1.distance_to(point2, rooted=False)
 
-            print(f"Actual Distance: {distance}")
+            print(f"Squared  Distance: {distance}")
 
             This will calculate the squared and actual distances between the two points.
 
@@ -71,7 +71,7 @@ class Vector2D:
             The function calculates the squared distance between the current Vector2D other (self) and another other
             (other) using the formula: (self.x - other.x)**2 + (self.y - other.y)**2.
 
-            The result is returned as the squared distance if `squared` is True, or as the actual distance if `squared` is False.
+            The result is returned as the squared distance if `rooted` is False, or as the actual distance if `rooted` is True.
         """
         ...
 
@@ -246,6 +246,10 @@ class Vector2D:
     def length(self:"Vector2D") -> float:
         ...
 
+    @property
+    def length_sqrd(self:"Vector2D") -> float:
+        ...
+
     def floor(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
         ...
 
@@ -387,7 +391,7 @@ class Vector2D:
         """
         ...
 
-    def cartesian_to_polar(self:"Vector2D") -> tuple:
+    def cartesian_to_polar(self:"Vector2D") -> tuple[float, float]:
         """
         # Convert Cartesian Coordinates to Polar Coordinates
 
@@ -479,7 +483,7 @@ class Vector2D:
         """
         ...
 
-    def rotate(self:"Vector2D", angle: int|float, center:"Vector2D|None"=None) -> "Vector2D":
+    def rotate(self:"Vector2D", angle: int|float, center:"Vector2D|None"=None) -> None:
         """
         # Rotate the vector by a given angle around the origin or a specified center.
 
@@ -489,7 +493,7 @@ class Vector2D:
                 If None, the vector is rotated around the origin (0, 0).
 
         ## Returns:
-            Vector2D or V2: The rotated vector.
+            None
 
         ## Example:
             v = Vector2D(3, 4)
@@ -577,32 +581,32 @@ class Vector2D:
     
     def sub(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
     
-    def mult(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
+    def mult(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def pow(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
+    def pow(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def mod(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
+    def mod(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def div(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
+    def div(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def fdiv(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
+    def fdiv(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
 
     # fast inplace operations     Vector2D.ioperation(both,x,y)
-    def set(self, both=int|float, x:int|float, y:int|float) -> Vector2D: ...
+    def set(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
 
-    def iadd(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def iadd(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
     
-    def isub(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def isub(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
     
-    def imult(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def imult(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def ipow(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def ipow(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def imod(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def imod(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def idiv(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def idiv(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def ifdiv(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def ifdiv(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
 
     # normal operations     Vector2D + a
     def __add__(self:"Vector2D", other:"int|float|Vector2D|list|tuple") -> "Vector2D": ...
@@ -664,7 +668,9 @@ class Vector2D:
 
     def __float__(self:"Vector2D") -> "Vector2D": ...
 
-    def __getitem__(self:"Vector2D", n) -> int|float: ...
+    def __getitem__(self:"Vector2D", n:Literal[0,1,"x","y"]) -> int|float: ...
+
+    def __iter__(self:"Vector2D") -> Generator[float, Any, None]: ...
     
     @classmethod
     def __normalize__(cls, other:"Vector2D|int|float|tuple|list") -> "Vector2D": ...
@@ -796,138 +802,133 @@ def rgb(r:float, g:float, b:float) -> tuple[float, float, float]:
 
 def lerp(starting: int|float, ending: int|float, step: int|float=.1) -> float: ...
 
-# def color_lerp(current_c: list|tuple, final_c: list|tuple, step: int|float=.1) -> tuple[float, float, float]:
-#     """
-#     # Linearly interpolate between two colors.
+def color_lerp(current_c: list|tuple, final_c: list|tuple, step: int|float=.1) -> tuple[float, float, float]:
+    """
+    # Linearly interpolate between two colors.
 
-#     ## Parameters:
-#         current_c (tuple or list): The RGB values of the current color as a tuple or list.
-#         final_c (tuple or list): The RGB values of the target color as a tuple or list.
-#         step (int or float): The interpolation step, ranging from 0.0 (current color) to 1.0 (target color).
+    ## Parameters:
+        current_c (tuple or list): The RGB values of the current color as a tuple or list.
+        final_c (tuple or list): The RGB values of the target color as a tuple or list.
+        step (int or float): The interpolation step, ranging from 0.0 (current color) to 1.0 (target color).
 
-#     ## Returns:
-#         tuple: The RGB values of the interpolated color as a tuple.
+    ## Returns:
+        tuple: The RGB values of the interpolated color as a tuple.
 
-#     ## Example:
-#         current_c = (255, 0, 0)
+    ## Example:
+        current_c = (255, 0, 0)
 
-#         final_c = (0, 0, 255)
+        final_c = (0, 0, 255)
 
-#         step = 0.5
+        step = 0.5
 
-#         interpolated_color = color_lerp(current_c, final_c, step)
+        interpolated_color = color_lerp(current_c, final_c, step)
 
-#         print(f"At step {step}: RGB {interpolated_color}")
+        print(f"At step {step}: RGB {interpolated_color}")
         
-#     This will calculate the color at an interpolation step of 0.5 between (255, 0, 0) and (0, 0, 255).
-#     """
-#     return tuple(c + (final_c[i] - c) * step for i,c in enumerate(current_c)) #type: ignore
+    This will calculate the color at an interpolation step of 0.5 between (255, 0, 0) and (0, 0, 255).
+    """
+    ...
 
-# def color_fade(starting_c: list|tuple, final_c: list|tuple, index: int|float, max_index: int|float) -> tuple[float, float, float]:
-#     """
-#     # Calculate the color at a specific index of a color fade between two given colors.
+def color_fade(starting_c: list|tuple, final_c: list|tuple, index: int|float, max_index: int|float) -> tuple[float, float, float]:
+    """
+    # Calculate the color at a specific index of a color fade between two given colors.
 
-#     ## Parameters:
-#         starting_c (tuple or list): The RGB values of the starting color as a tuple or list.
-#         final_c (tuple or list): The RGB values of the final color as a tuple or list.
-#         index (int or float): The current index of the color fade, representing a position
-#                               between the starting and final colors.
-#         max_index (int or float): The maximum index of the color fade, indicating the endpoint
-#                                   position between the starting and final colors.
+    ## Parameters:
+        starting_c (tuple or list): The RGB values of the starting color as a tuple or list.
+        final_c (tuple or list): The RGB values of the final color as a tuple or list.
+        index (int or float): The current index of the color fade, representing a position
+                              between the starting and final colors.
+        max_index (int or float): The maximum index of the color fade, indicating the endpoint
+                                  position between the starting and final colors.
 
-#     ## Returns:
-#         tuple: The RGB values of the color at the specified index as a tuple.
+    ## Returns:
+        tuple: The RGB values of the color at the specified index as a tuple.
 
-#     ## Example:
-#         starting_c = (255, 0, 0)
+    ## Example:
+        starting_c = (255, 0, 0)
 
-#         final_c = (0, 0, 255)
+        final_c = (0, 0, 255)
 
-#         max_index = 100
+        max_index = 100
 
-#         for i in range(max_index + 1):
+        for i in range(max_index + 1):
         
-#             color_at_index = color_fade(starting_c, final_c, i, max_index)
+            color_at_index = color_fade(starting_c, final_c, i, max_index)
 
-#             print(f"At index {i}: RGB {color_at_index}")
+            print(f"At index {i}: RGB {color_at_index}")
             
-#         This will print the colors transitioning from (255, 0, 0) to (0, 0, 255).
-#     """
-#     return tuple((starting_c[i] - final_c[i]) / max_index * (max_index - index) + final_c[i] for i in range(3)) #type: ignore
+        This will print the colors transitioning from (255, 0, 0) to (0, 0, 255).
+    """
+    ...
 
-# def weighted_color_fade(colors_dict:dict) -> tuple[float, float, float]:
-#     """
-#     # Calculate the weighted color based on a dictionary of colors and their corresponding weights.
+def weighted_color_fade(colors_dict:dict) -> tuple[float, float, float]:
+    """
+    # Calculate the weighted color based on a dictionary of colors and their corresponding weights.
 
-#     ## Parameters:
-#         colors_dict (dict): A dictionary where keys represent RGB color values as tuples,
-#                             and values represent the weights (floats) for each color.
+    ## Parameters:
+        colors_dict (dict): A dictionary where keys represent RGB color values as tuples,
+                            and values represent the weights (floats) for each color.
 
-#     ## Returns:
-#         tuple: The RGB values of the calculated weighted color as a tuple.
+    ## Returns:
+        tuple: The RGB values of the calculated weighted color as a tuple.
 
-#     ## Example:
-#         colors_dict = {
+    ## Example:
+        colors_dict = {
         
-#             (255, 255, 255): 0.1,
+            (255, 255, 255): 0.1,
 
-#             (0, 0, 0): 0.9,
+            (0, 0, 0): 0.9,
 
-#         }
+        }
 
-#         weighted_color = weighted_color_fade(colors_dict)
+        weighted_color = weighted_color_fade(colors_dict)
 
-#         print(f"Weighted color: RGB {weighted_color}")
+        print(f"Weighted color: RGB {weighted_color}")
 
-#         This will print the weighted color based on the provided dictionary.
-#     """
-#     colors = colors_dict.keys()
-#     weights = colors_dict.values()
-
-#     if float("inf") in weights: return list(colors)[list(weights).index(float("inf"))]
-#     return tuple(sum(n[i]*w for n,w in zip(colors, weights)) / sum(weights) for i in range(3)) #type: ignore
-
-# def color_distance(starting_c: list|tuple, final_c: list|tuple, sqrd:bool=True) -> float:
-#     """
-#     # Calculate the distance between two colors in RGB space.
+        This will print the weighted color based on the provided dictionary.
+    """
+    ...
 
-#     ## Parameters:
-#         starting_c (list or tuple): The RGB values of the starting color.
-#         final_c (list or tuple): The RGB values of the final color.
-#         sqrd (bool, optional): If True, return the squared distance. If False, return
-#                                the actual distance. Default is True.
+def color_distance(starting_c: list|tuple, final_c: list|tuple, rooted:bool=True) -> float:
+    """
+    # Calculate the distance between two colors in RGB space.
 
-#     ## Returns:
-#         float: The squared distance between the two colors if `sqrd` is True, otherwise
-#                the actual distance.
+    ## Parameters:
+        starting_c (list or tuple): The RGB values of the starting color.
+        final_c (list or tuple): The RGB values of the final color.
+        rooted (bool, optional): If True, return the rooted distance. If False, return
+                               the actual distance. Default is True.
 
-#     ## Example:
-#         starting_c = [255, 0, 0]
+    ## Returns:
+        float: The squared distance between the two colors if `rooted` is False, otherwise
+               the actual distance.
 
-#         final_c = [0, 255, 0]
+    ## Example:
+        starting_c = [255, 0, 0]
 
-#         squared_distance = color_distance(starting_c, final_c)
+        final_c = [0, 255, 0]
 
-#         print(f"Squared Distance: {squared_distance}")
+        squared_distance = color_distance(starting_c, final_c)
 
-#         distance = color_distance(starting_c, final_c, sqrd=False)
+        print(f"Squared Distance: {squared_distance}")
 
-#         print(f"Actual Distance: {distance}")
+        distance = color_distance(starting_c, final_c, rooted=True)
 
-#         This will calculate the squared and actual distances between the colors.
+        print(f"Actual Distance: {distance}")
 
-#     ## Explanation:
-#         The function first calculates the squared distance between the two colors in RGB
-#         space. It does this by computing the sum of the squared differences of the RGB
-#         components for each color. The squared distance is obtained by taking the square
-#         root of this sum.
+        This will calculate the squared and actual distances between the colors.
 
-#         The `sqrd` parameter allows the user to choose between returning the squared
-#         distance or the actual distance. If `sqrd` is True, the function returns the
-#         squared distance, and if `sqrd` is False, it returns the actual distance.
-#     """
-#     distance = sum([(starting_c[i]-final_c[i])**2 for i in range(3)])
-#     return (distance ** .5) if sqrd else distance
+    ## Explanation:
+        The function first calculates the squared distance between the two colors in RGB
+        space. It does this by computing the sum of the squared differences of the RGB
+        components for each color. The squared distance is obtained by taking the square
+        root of this sum.
+
+        The `rooted` parameter allows the user to choose between returning the squared
+        distance or the actual distance. If `rooted` is True, the function returns the
+        actual distance, and if `rooted` is False, it returns the squared distance.
+    """
+    ...
 
 def angular_interpolation(starting_angle: int|float, final_angle: int|float, step: int|float=.1) -> float:
     """