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

e2D/__init__.py

@@ -17,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)
@@ -32,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":
@@ -42,13 +42,13 @@ 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
@@ -93,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
@@ -112,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))
@@ -171,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:
@@ -202,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
@@ -518,9 +512,9 @@ def weighted_color_fade(colors_dict:dict) -> tuple[float, float, float]:
     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:
+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 sqrd else distance
+    return (distance ** .5) if rooted else distance
 
 def lerp(starting, ending, step=.1) -> float:
     return starting + (ending - starting) * step

e2D/__init__.pyi

@@ -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.
         """
         ...
 
@@ -391,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
 
@@ -483,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.
 
@@ -493,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)
@@ -581,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": ...
@@ -889,18 +889,18 @@ def weighted_color_fade(colors_dict:dict) -> tuple[float, float, float]:
     """
     ...
 
-def color_distance(starting_c: list|tuple, final_c: list|tuple, sqrd:bool=True) -> float:
+def color_distance(starting_c: list|tuple, final_c: list|tuple, rooted:bool=True) -> float:
     """
     # Calculate the distance between two colors in RGB space.
 
     ## 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
+        rooted (bool, optional): If True, return the rooted distance. If False, return
                                the actual distance. Default is True.
 
     ## Returns:
-        float: The squared distance between the two colors if `sqrd` is True, otherwise
+        float: The squared distance between the two colors if `rooted` is False, otherwise
                the actual distance.
 
     ## Example:
@@ -912,7 +912,7 @@ def color_distance(starting_c: list|tuple, final_c: list|tuple, sqrd:bool=True)
 
         print(f"Squared Distance: {squared_distance}")
 
-        distance = color_distance(starting_c, final_c, sqrd=False)
+        distance = color_distance(starting_c, final_c, rooted=True)
 
         print(f"Actual Distance: {distance}")
 
@@ -924,9 +924,9 @@ def color_distance(starting_c: list|tuple, final_c: list|tuple, sqrd:bool=True)
         components for each color. The squared distance is obtained by taking the square
         root of this sum.
 
-        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.
+        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.
     """
     ...
 

e2D/envs.py

@@ -5,7 +5,7 @@ from .utils import *
 import pygame as pg
 
 """  CODE EXAMPLE FOR RootEnv
-from e2D.envs import *
+from e2D.envs import * #type: ignore
 
 class Env(DefEnv):
     def __init__(self) -> None:

e2D/plots.py

@@ -127,8 +127,8 @@ class MathFunction(Function):
                  id:int|str,
                  function:Callable[[int|float, int|float], int|float],
                  domain:list[float]=[-np.inf, np.inf],
-                 codomain:list[float]=[-np.inf, np.inf], colo
-                 :list[float]|tuple[float,float,float]=(255,255,255)) -> None:
+                 codomain:list[float]=[-np.inf, np.inf],
+                 color:list[float]|tuple[float,float,float]=(255,255,255)) -> None:
         super().__init__()
         self.id = id
         self.color = color
@@ -398,7 +398,7 @@ class Plot:
         self.focus_using_corners(top_left_plot_coord, bottom_right_plot_coord)
 
     def set_borders_by_position_and_zoom(self) -> None:
-        self.top_left_plot_coord = self.current_offset - 2**(-.1*self.current_zoom) * self.__y_axis_multiplier__
+        self.top_left_plot_coord = self.current_offset - 2**(self.current_zoom.mult(-.1)) * self.__y_axis_multiplier__
         self.bottom_right_plot_coord = self.current_offset + 2**(-.1*self.current_zoom) * self.__y_axis_multiplier__
         self.top_left_x, self.top_left_y = self.top_left_plot_coord
         self.bottom_right_x, self.bottom_right_y = self.bottom_right_plot_coord

e2D/utils.py

@@ -3,6 +3,8 @@ from typing import Any, Callable, Literal
 import pygame as pg
 from e2D import *
 
+import math as _mt
+
 pg.font.init()
 
 __KEY_MODE_TYPES_DICT__ = dict(zip(["pressed", "just_pressed", "just_released"], range(3)))
@@ -95,6 +97,7 @@ class Util:
         self.rootEnv = None
         self.surface : pg.Surface
         self.id : int|str
+        self.is_hovered :bool= False
     def draw(self) -> None: pass
     def update(self) -> None: pass
 
@@ -153,14 +156,15 @@ class InputCell(Util):
             if self.border_width:
                 pg.draw.rect(self.text_surface, self.border_color, self.margin_rect, self.border_width, -1, *self.border_radius)
         else:
-            pg.draw.rect(self.text_surface, [127 + 127 * _mt.sin(self.rootEnv.get_time_from_start() * 10)]*3, self.margin_rect, self.border_width if self.border_width else 10, -1, *self.border_radius)
+            pg.draw.rect(self.text_surface, [127 + 127 * _mt.sin(self.rootEnv.runtime_seconds * 10)]*3, self.margin_rect, self.border_width if self.border_width else 10, -1, *self.border_radius)
 
         self.surface.blit(self.text_surface, self.position())
         
     def update(self) -> None:
+        self.is_hovered = self.position.x < self.rootEnv.mouse.position.x < self.position.x + self.size.x and\
+                          self.position.y < self.rootEnv.mouse.position.y < self.position.y + self.size.y
         if self.rootEnv.mouse.get_key(0, "just_pressed"):
-            if self.position.x < self.rootEnv.mouse.position.x < self.position.x + self.size.x and\
-               self.position.y < self.rootEnv.mouse.position.y < self.position.y + self.size.y:
+            if self.is_hovered:
                 self.rootEnv.selected_util = self if self.rootEnv.selected_util != self else None
                 self.update_text()
         if self.rootEnv.selected_util == self:

e2D/winrec.py

@@ -18,7 +18,7 @@ class WinRec:
         return self.rootEnv.current_frame/self.fps
 
     def draw(self, draw_on_screen=False) -> None:
-        text = f"[cfps:{self.rootEnv.current_frame} || realtime:{round(self.get_rec_seconds(),2)} || apptime:{round(self.rootEnv.get_time_from_start(),2)}]"
+        text = f"[cfps:{self.rootEnv.current_frame} || realtime:{round(self.get_rec_seconds(),2)} || apptime:{round(self.rootEnv.runtime_seconds,2)}]"
         pg.display.set_caption(text)
         if draw_on_screen: self.rootEnv.print(text, self.rootEnv.screen_size, pivot_position='bottom_right')
     

{e2D-1.4.13.dist-info → e2D-1.4.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e2D
-Version: 1.4.13
+Version: 1.4.14
 Summary: Python library for 2D games. Streamlines dev with keyboard/mouse input, vector calculations, color manipulation, and collision detection. Simplify game creation and unleash creativity!
 Home-page: https://github.com/marick-py/e2D
 Author: Riccardo Mariani

e2D-1.4.14.dist-info/RECORD

@@ -0,0 +1,11 @@
+e2D/__init__.py,sha256=klic-pOCE3h0JqwhpkKz6euZLS7wrvKQEUPTKTR9YRI,23066
+e2D/__init__.pyi,sha256=rMceBt26-bozw_Xt3JQWfQ_20G8RAkE2j4CqIf7PIuQ,48013
+e2D/envs.py,sha256=Kf6f9szesdI9xado9u1FiDOBEVusbJDAvU-i9rMESws,6306
+e2D/plots.py,sha256=S4YWKJVrb1bfJGxUebFy4167coCb4oTdcNl_DKcJtlA,36075
+e2D/utils.py,sha256=tDs_Fl_8YBQoJaATQmgmFD50oNu39i4bCmvxxU16cS0,14152
+e2D/winrec.py,sha256=EFFfWYbk27NhS-rWD-BLChXvLjFW1uYZ5LkRGMj_Xo0,1116
+e2D-1.4.14.dist-info/LICENSE,sha256=wymkNVDvj3qmjdO_rAhkRPM4t5y3_SqffGsFdgfvznU,1066
+e2D-1.4.14.dist-info/METADATA,sha256=LxDaWfll8xiSRggk4Wv6r8Nv6BdDgu7SgajDuxcXwaU,9611
+e2D-1.4.14.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+e2D-1.4.14.dist-info/top_level.txt,sha256=3vKZ-CGzNlTCpzVMmM0Ht76krCofKw7hZ0wBf-dnKdM,4
+e2D-1.4.14.dist-info/RECORD,,

{e2D-1.4.13.dist-info → e2D-1.4.14.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.4.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

e2D/cvb.py

@@ -1,831 +0,0 @@
-from __future__ import annotations
-
-__all__ = ['cV2', 'cVector2D']
-
-class Vector2D:
-    round_values_on_print :int|float= 2
-    def __init__(self:"Vector2D", x:int|float=0.0, y:int|float=0.0) -> None:
-        """
-        # Initialize a 2D vector with the specified x and y components.
-
-        ## Parameters:
-            x (int | float, optional): The x-component of the vector. Default is 0.
-            y (int | float, optional): The y-component of the vector. Default is 0.
-
-        ## Example:
-            vector1 = Vector2D()        # Creates a vector with x=0 and y=0
-            vector2 = Vector2D(3, -2.5) # Creates a vector with x=3 and y=-2.5
-
-        ## Explanation:
-            This constructor initializes a 2D vector with the specified x and y components.
-
-            If no arguments are provided, the default values for x and y are both set to 0.
-
-            The x and y components can be integers or floating-point numbers.
-
-            Example usage is shown in the "Example" section above.
-        """
-        self.x = x
-        self.y = y
-    
-    def set(self:"Vector2D", x:int|float=0, y:int|float=0) -> None:
-        """
-        # Change the components of the Vector2D other without creating a new one.
-
-        ## Parameters:
-            x (int | float, optional): The new x-component to set. Default is 0.
-            y (int | float, optional): The new y-component to set. Default is 0.
-
-        ## Example:
-            vector = Vector2D(1, 2)
-            vector.set(3, -4)
-            print(vector.x, vector.y)  # Output: 3, -4
-
-        ## Explanation:
-            The method updates the x and y components of the Vector2D other to the specified values.
-
-            If no arguments are provided, the default values for x and y are both set to 0.
-
-            The x and y components can be integers or floating-point numbers.
-
-            The method does not return any value, but it modifies the Vector2D other in place.
-
-            Example usage is shown in the "Example" section above.
-        """
-        self.x = x
-        self.y = y
-
-    def distance_to(self:"Vector2D", other:"float|int|Vector2D|list|tuple", sqrd: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.
-                                    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.
-
-        ## Example:
-            point1 = Vector2D(0, 0)
-
-            point2 = Vector2D(3, 4)
-
-            squared_distance = point1.distance_to(point2)
-
-            print(f"Squared Distance: {squared_distance}")
-
-            distance = point1.distance_to(point2, squared=False)
-
-            print(f"Actual Distance: {distance}")
-
-            This will calculate the squared and actual distances between the two points.
-
-        ## Explanation:
-            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.
-        """
-        other = self.__normalize__(other)
-        d = (self.x - other.x)**2 + (self.y - other.y)**2
-        return (d**(1/2) if sqrd else d)
-
-    def angle_to(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> int|float:
-        """
-        # Calculate the angle between the current Vector2D other and another other.
-
-        ## Parameters:
-            other (float or int or Vector2D or list|tuple): The other other to which the angle is calculated.
-
-        ## Returns:
-            int|float: The angle in radians between the current Vector2D other and the other other.
-
-        ## Example:
-            point1 = Vector2D(0, 0)
-
-            point2 = Vector2D(1, 1)
-
-            angle = point1.angle_to(point2)
-
-            print(f"Angle in radians: {angle}")
-
-            This will calculate the angle in radians between the two points.
-
-        ## Explanation:
-            The function calculates the angle in radians between the current Vector2D other (self) and another other
-            (other) using the `atan2` function from the `math` module.
-
-            The result is returned as the angle in radians.
-        """
-        other = self.__normalize__(other)
-        return _mt.atan2(other.y - self.y, other.x - self.x)
-
-    def point_from_degs(self:"Vector2D", degs:int|float, radius:int|float) -> "Vector2D":
-        """
-        # Calculate a new Vector2D point from the current point based on an angle in degs and a radius.
-
-        ## Parameters:
-            rad (int|float): The angle in degs.
-            radius (int|float): The distance from the current point.
-
-        ## Returns:
-            Vector2D: A new Vector2D point calculated from the current point.
-
-        ## Example:
-            point1 = Vector2D(0, 0)
-
-            angle = 45
-
-            distance = 5
-
-            new_point = point1.point_from_degs(angle, distance)
-
-            print(new_point.x, new_point.y)
-
-            This will calculate a new point 5 units away from point1 at a 45-degree angle.
-
-        ## Explanation:
-            The function calculates a new Vector2D point based on an angle in degs (degs) and a distance (radius)
-            from the current Vector2D point.
-
-            It computes the new x and y coordinates of the point using the trigonometric functions `cos` and `sin`
-            to determine the horizontal and vertical components of the new point.
-
-            The result is returned as a new Vector2D point with the calculated coordinates.
-        """
-        x = radius * _mt.cos(_mt.radians(degs)) + self.x
-        y = radius * _mt.sin(_mt.radians(degs)) + self.y
-        return Vector2D(x, y)
-    
-    def point_from_rads(self:"Vector2D", rad:int|float, radius:int|float) -> "Vector2D":
-        """
-        # Calculate a new Vector2D point from the current point based on an angle in radians and a radius.
-
-        ## Parameters:
-            rad (int|float): The angle in radians.
-            radius (int|float): The distance from the current point.
-
-        ## Returns:
-            Vector2D: A new Vector2D point calculated from the current point.
-
-        ## Example:
-            point1 = Vector2D(0, 0)
-
-            angle = 45
-
-            distance = 5
-
-            new_point = point1.point_from_degs(_mt.radians(angle), distance)
-
-            print(new_point.x, new_point.y)
-
-            This will calculate a new point 5 units away from point1 at a 45-degree angle.
-
-        ## Explanation:
-            The function calculates a new Vector2D point based on an angle in radians (rad) and a distance (radius)
-            from the current Vector2D point.
-
-            It computes the new x and y coordinates of the point using the trigonometric functions `cos` and `sin`
-            to determine the horizontal and vertical components of the new point.
-
-            The result is returned as a new Vector2D point with the calculated coordinates.
-        """
-        x = radius * _mt.cos(rad) + self.x
-        y = radius * _mt.sin(rad) + self.y
-        return Vector2D(x, y)
-
-    def copy(self:"Vector2D") -> "Vector2D":
-        """
-        # Create a copy of the current Vector2D other.
-
-        ## Returns:
-            Vector2D: A new Vector2D other with the same x and y coordinates as the current other.
-
-        ## Example:
-            point1 = Vector2D(1, 2)
-
-            point2 = point1.copy()
-
-            print(point2.x, point2.y)
-
-            This will print the x and y coordinates of the copied Vector2D other (1, 2).
-
-        ## Explanation:
-            The function creates a new Vector2D other with the same x and y coordinates as the current other.
-
-            The result is returned as a new Vector2D other, effectively making a copy of the original other.
-        """
-        return Vector2D(self.x, self.y)
-
-    def sign(self:"Vector2D") -> "Vector2D":
-        """
-        # Perform an "absolute round" operation on the Vector2D other.
-
-        ## Parameters:
-            n (int|float, optional): The numeric value to scale the "absolute rounded" vector. Default is 1.
-
-        ## Returns:
-            Vector2D: The "absolute rounded" Vector2D other scaled by the provided numeric value.
-
-        ## Example:
-            vector1 = Vector2D(3.3, -4.7)
-
-            result1 = vector1.absolute_round(0.5)
-
-            print(result1.x, result1.y)
-
-            vector2 = Vector2D(-2.8, 1.1)
-
-            result2 = vector2.absolute_round()
-
-            print(result2.x, result2.y)
-
-        ## Explanation:
-            The function performs an "absolute round" operation on the Vector2D other.
-
-            The "absolute round" operation involves taking the absolute values of both the x and y components of the Vector2D other,
-            and then scaling the resulting vector by the provided numeric value (n).
-
-            The default value of n is 1, which means the "absolute rounded" vector will have the same magnitude as the original vector.
-
-            If the provided numeric value (n) is 0, the function returns a Vector2D other with zeros for both components.
-
-            If the provided numeric value (n) is negative, the resulting "absolute rounded" vector will point in the opposite direction
-            as the original vector but will have the same magnitude.
-
-            Note: The "absolute round" operation does not perform standard mathematical rounding; instead, it ensures the resulting
-            vector points in the same direction as the original vector but has non-negative components.
-        """
-        return self.no_zero_div_error(abs(self), "zero")
-
-    def floor(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
-        return self.__floor__(n)
-
-    def ceil(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
-        return self.__ceil__(n)
-    
-    def round(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
-        return self.__round__(n)
-
-    def randomize(start:"int|float|Vector2D|None"=None, end:"int|float|Vector2D|None"=None) -> "Vector2D": #type: ignore
-        """
-        # Generate a random Vector2D point within the specified range.
-
-        ## Parameters:
-            start (int|float or Vector2D or None, optional): The starting point of the range.
-                                                        Default is None, which corresponds to (0, 0).
-                                                        If numeric, both x and y will have the same value.
-            end (int|float or Vector2D or None, optional): The ending point of the range.
-                                                        Default is None, which corresponds to (1, 1).
-                                                        If numeric, both x and y will have the same value.
-
-        ## Returns:
-            Vector2D: A new random Vector2D point within the specified range.
-
-        ## Example:
-            random_point = randomize(Vector2D(10, 20), Vector2D(50, 70))
-
-            print(random_point.x, random_point.y)
-
-            This will print a random point between (10, 20) and (50, 70).
-
-        ## Explanation:
-            The function generates a random Vector2D point within the specified range defined by `start` and `end`.
-
-            If `start` and `end` are numeric values (int or float), both x and y coordinates will have the same value.
-
-            If `start` and `end` are None, the default range is assumed to be (0, 0) to (1, 1).
-
-            The function first checks if `start` and `end` are Vector2D others. If not, it creates new Vector2D others
-            based on the numeric values provided or the default values.
-
-            It then generates random x and y coordinates in the range [0, 1) using the `random()` function from the `random` module.
-            These random values are then scaled by (end - start) and added to the start point to obtain the final random Vector2D point.
-        """
-        if not any(isinstance(start, cls) for cls in {Vector2D, V2}):
-            if type(start) in int|float: start = Vector2D(start, start) #type: ignore
-            elif type(start) == None: start = Vector2D(0,0)
-            else: raise Exception(f"\nArg start must be in [Vector2D, int, float, tuple, list] not a [{type(start)}]\n")
-        if not any(isinstance(end, cls) for cls in {Vector2D, V2}):
-            if type(end) in int|float: end = Vector2D(end, end) #type: ignore
-            elif type(end) == None: end = Vector2D(1,1)
-            else: raise Exception(f"\nArg end must be in [Vector2D, int, float, tuple, list] not a [{type(end)}]\n")
-        return start + Vector2D(_rnd.random(), _rnd.random()) * (end - start) #type: ignore
-    
-    def dot_product(self, other:"float|int|Vector2D|list|tuple") -> float:
-        other = self.__normalize__(other)
-        """
-        # Calculate the dot product of the current vector with another vector.
-
-        ## Parameters:
-            other (Vector2D): The other vector for the dot product calculation.
-
-        ## Returns:
-            float: The dot product value.
-
-        ## Example:
-            v1 = Vector2D(2, 3)
-            v2 = Vector2D(4, -1)
-            result = v1.dot_product(v2)
-            print(result)  # Output: 5
-
-        ## Explanation:
-            The dot product of two vectors (A and B) is given by the formula: dot_product = A.x * B.x + A.y * B.y
-
-            The method takes another vector (other) as input and returns the dot product value.
-
-            Example usage is shown in the "Example" section above.
-        """
-        return self.x * other.x + self.y * other.y
-
-    def normalize(self) -> "Vector2D":
-        """
-        # Vector Normalization
-
-        ## Returns:
-            Vector2D: A new vector with the same direction as the current vector but with a magnitude of 1.
-
-        ## Raises:
-            ValueError: If the magnitude of the current vector is zero (zero vector).
-
-        ## Example:
-            v = Vector2D(3, 4)
-            normalized_v = v.normalize()  # Normalize the vector (3, 4)
-            print(normalized_v)  # Output: (0.6, 0.8)
-
-        ## Explanation:
-            This method calculates the normalized version of the current vector, which means a new vector with the same direction as the original but with a magnitude of 1.
-
-            The method first calculates the magnitude of the current vector using the 'magnitude' method.
-
-            If the magnitude is zero (zero vector), a ValueError is raised, as normalization is not defined for zero vectors.
-
-            The normalized vector is obtained by dividing each component of the current vector by its magnitude.
-
-            The resulting normalized vector is returned.
-
-            Example usage is shown in the "Example" section above.
-        """
-        mag = self.length()
-        if mag == 0:
-            return self
-        return Vector2D(self.x / mag, self.y / mag)
-
-    def projection(self, other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        """
-        # Vector Projection
-
-        ## Parameters:
-            other (float, int, Vector2D, V2, list, tuple): The vector onto which to project.
-
-        ## Returns:
-            Vector2D or V2: The projection of the current vector onto the 'other' vector.
-
-        ## Raises:
-            ValueError: If 'other' is a zero vector.
-
-        ## Example:
-            v1 = Vector2D(3, 4)
-            v2 = Vector2D(1, 0)
-            projection_v = v1.projection(v2)  # Calculate the projection of v1 onto v2
-            print(projection_v)  # Output: (3.0, 0.0)
-
-        ## Explanation:
-            This method calculates the projection of the current vector onto the 'other' vector.
-            The projection is a vector that represents the component of the current vector in the direction of the 'other' vector.
-
-            If 'other' is not a Vector2D instance, it will be converted to one using the '__normalize__' method.
-            The method first normalizes the 'other' vector using the '__normalize__' method of the vector.
-
-            Next, it calculates the dot product of the current vector and the normalized 'other' vector using the 'dot_product' method.
-            It also calculates the squared magnitude of the 'other' vector using the 'magnitude' method.
-
-            If the magnitude of 'other' is zero (a zero vector), a ValueError is raised, as projection is not defined for zero vectors.
-
-            The projection is then obtained by scaling the 'other' vector by the dot product divided by the squared magnitude.
-
-            The resulting projection vector is returned.
-
-            Example usage is shown in the "Example" section above.
-        """
-        other = self.__normalize__(other)
-        dot_product = self.dot_product(other)
-        magnitude_product = other.length() ** 2
-        if magnitude_product == 0:
-            raise ValueError("Cannot calculate projection for zero vectors.")
-        return other * (dot_product / magnitude_product)
-
-    def reflection(self, normal:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        """
-        # Vector Reflection
-
-        ## Parameters:
-            normal (float, int, Vector2D, V2, list, tuple): The normal vector representing the surface of reflection.
-
-        ## Returns:
-            Vector2D or V2: The reflected vector.
-
-        ## Example:
-            incident_vector = Vector2D(3, 4)
-            normal_vector = Vector2D(1, 0)
-            reflected_vector = incident_vector.reflection(normal_vector)  # Calculate the reflection of the incident vector over the given normal
-            print(reflected_vector)  # Output: (-3.0, 4.0)
-
-        ## Explanation:
-            This method calculates the reflection of the current vector over the given normal vector.
-            The normal vector represents the surface of reflection, and it should be normalized (unit vector).
-
-            The method first normalizes the 'normal' vector using the '__normalize__' method of the vector.
-            Next, it calculates the projection of the current vector onto the 'normal' vector using the 'projection' method.
-            The reflected vector is obtained by subtracting twice the projection from the current vector.
-
-            The resulting reflected vector is returned.
-
-            Example usage is shown in the "Example" section above.
-        """
-        normal = self.__normalize__(normal)
-        projection = self.projection(normal)
-        return self - projection * 2
-
-    def cartesian_to_polar(self) -> tuple:
-        """
-        # Convert Cartesian Coordinates to Polar Coordinates
-
-        ## Returns:
-            tuple: A tuple containing the radial distance (magnitude) 'r' and the angle 'theta' in radians.
-
-        ## Example:
-            v = Vector2D(3, 4)
-            r, theta = v.cartesian_to_polar()  # Convert Cartesian coordinates (3, 4) to polar
-            print(r, theta)  # Output: (5.0, 0.9272952180016122)
-
-        ## Explanation:
-            This method converts Cartesian coordinates (x, y) to polar coordinates (r, theta).
-            'r' is the radial distance (magnitude) from the origin to the point, and 'theta' is the angle
-            (in radians) measured from the positive x-axis to the point.
-
-            The method calculates the radial distance 'r' using the 'magnitude' method of the vector.
-            The angle 'theta' is calculated using the arctan2 function, which takes the y and x components of the vector.
-
-            The resulting 'r' and 'theta' are returned as a tuple.
-
-            Example usage is shown in the "Example" section above.
-        """
-        r = self.length()
-        theta = _mt.atan2(self.y, self.x)
-        return r, theta
-
-    @classmethod
-    def polar_to_cartesian(cls, r: float|int, theta: float|int) -> "Vector2D":
-        """
-        # Convert Polar Coordinates to Cartesian Coordinates
-
-        ## Parameters:
-            r (float or int): The radial distance (magnitude) from the origin to the point.
-            theta (float or int): The angle (in radians or degrees) measured from the positive x-axis to the point.
-
-        ## Returns:
-            Vector2D or V2: A new vector representing the Cartesian coordinates (x, y) of the point.
-
-        ## Example:
-            cartesian_point = Vector2D.polar_to_cartesian(5, math.pi/4)  # Convert polar coordinates (r=5, theta=45 degrees) to Cartesian
-            print(cartesian_point)  # Output: (3.5355339059327378, 3.5355339059327373)
-
-        ## Explanation:
-            This class method converts polar coordinates (r, theta) to Cartesian coordinates (x, y).
-            'r' is the radial distance (magnitude) from the origin to the point, and 'theta' is the angle
-            (in radians or degrees) measured from the positive x-axis to the point.
-
-            The method calculates the x and y components using trigonometric functions (cosine and sine) based on 'r' and 'theta'.
-
-            Example usage is shown in the "Example" section above.
-        """
-        x = r * _mt.cos(theta)
-        y = r * _mt.sin(theta)
-        return cls(x, y)
-
-    def cartesian_to_complex(self) -> complex:
-        return self.x + self.y * 1j
-
-    @classmethod
-    def complex_to_cartesian(cls, complex_n: complex) -> "Vector2D":
-        return cls(complex_n.real, complex_n.imag)
-
-    def length(self) -> float:
-        return (self.x ** 2 + self.y ** 2) ** .5
-
-    def lerp(self, other:"float|int|Vector2D|list|tuple", t: float) -> "Vector2D":
-        """
-        # Linear Interpolation (LERP)
-
-        ## Parameters:
-            other (float, int, Vector2D, V2, list, tuple): The vector to interpolate towards.
-            t (float): The interpolation parameter. Must be between 0 and 1.
-
-        ## Returns:
-            Vector2D or V2: The result of the linear interpolation.
-
-        ## Raises:
-            ValueError: If t is not within the range [0, 1].
-
-        ## Example:
-            v1 = Vector2D(1, 2)
-            v2 = Vector2D(5, 7)
-            interpolated_v = v1.lerp(v2, 0.5)  # Linearly interpolate between v1 and v2 with t = 0.5
-            print(interpolated_v)  # Output: (3.0, 4.5)
-
-        ## Explanation:
-            This method performs linear interpolation between the current vector and the 'other' vector.
-            The 't' parameter represents the interpolation parameter, which controls how much the interpolation
-            leans towards the 'other' vector. When 't' is 0, the result will be equal to the current vector (self).
-            When 't' is 1, the result will be equal to the 'other' vector. For intermediate values of 't', the
-            result will be a linear combination of the two vectors, smoothly transitioning between them.
-
-            If 'other' is not a Vector2D instance, it will be converted to one using the '__normalize__' method.
-            If 't' is not within the range [0, 1], a ValueError is raised.
-
-            Example usage is shown in the "Example" section above.
-        """
-        other = self.__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: int|float, center:"float|int|Vector2D|list|tuple|None"=None) -> "Vector2D":
-        """
-        # Rotate the vector by a given angle around the origin or a specified center.
-
-        ## Parameters:
-            angle (int or float): The angle of rotation in radians or degrees, depending on the trigonometric functions used.
-            center (float, int, Vector2D, V2, list, tuple, or None): The center of rotation.
-                If None, the vector is rotated around the origin (0, 0).
-
-        ## Returns:
-            Vector2D or V2: The rotated vector.
-
-        ## Example:
-            v = Vector2D(3, 4)
-            rotated_v = v.rotate(math.pi / 4)  # Rotate 45 degrees around the origin
-            print(rotated_v)  # Output: (0.7071067811865476, 5.656854249492381)
-            
-            center = Vector2D(1, 1)
-            rotated_v = v.rotate(math.pi / 4, center)  # Rotate 45 degrees around the center (1, 1)
-            print(rotated_v)  # Output: (1.7071067811865475, 2.656854249492381)
-
-        ## Explanation:
-            This method rotates the vector by the specified angle around the given center.
-            If no center is provided, the vector is rotated around the origin (0, 0).
-
-            The method calculates the trigonometric functions (cosine and sine) of the angle to perform the rotation.
-            The translated vector is obtained by subtracting the center from the current vector.
-            The rotated vector is then obtained by applying the rotation transformation to the translated vector.
-            The center is added back to the rotated vector to obtain the final result.
-
-            Example usage is shown in the "Example" section above.
-        """
-        if center is None: center = V2z
-        else: center = self.__normalize__(center)
-        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
-
-    def no_zero_div_error(self:"Vector2D", n:"int|float|Vector2D", error_mode:str="zero") -> "Vector2D":
-        """
-        # Handle division between the Vector2D other and a numeric value or another Vector2D other.
-
-        ## Parameters:
-            n (int|float or Vector2D): The numeric value or Vector2D other for division.
-            error_mode (str, optional): The mode to handle division by zero scenarios.
-                                        - "zero" (default): Return a Vector2D other with zeros for both components.
-                                        - "null": Return a Vector2D other with the original x or y component if available,
-                                                otherwise, return NaN (Not a Number) for the component.
-
-        ## Returns:
-            Vector2D: A new Vector2D other after division or handling division by zero scenarios.
-
-        ## Example:
-            vector1 = Vector2D(3, 4)
-
-            result1 = vector1.no_zero_div_error(2)
-
-            print(result1.x, result1.y)
-
-            vector2 = Vector2D(5, 0)
-
-            result2 = vector1.no_zero_div_error(vector2, error_mode="null")
-
-            print(result2.x, result2.y)
-
-        ## Explanation:
-            The function handles division between the Vector2D other and a numeric value or another Vector2D other.
-
-            If n is a numeric value (int or float):
-                - If n is zero, the function returns a Vector2D other with zeros for both components if error_mode is "zero".
-                - If error_mode is "null", the function returns a Vector2D other with the original x or y component if available,
-                otherwise, return NaN (Not a Number) for the component.
-
-            If n is a Vector2D other:
-                - If n's x or y component is zero, the function returns a Vector2D other with zeros for the corresponding component
-                if error_mode is "zero".
-                - If error_mode is "null", the function returns a Vector2D other with the original x or y component if available,
-                otherwise, return NaN (Not a Number) for the component.
-
-            If n is neither a numeric value nor a Vector2D other, the function raises an exception.
-        """
-        if any(isinstance(n, cls) for cls in {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))
-            else:
-                return self / n
-        elif any(isinstance(n, cls) for cls in {Vector2D, V2}):
-            return Vector2D((0 if error_mode == "zero" else (self.x if error_mode == "null" else _mt.nan)) if n.x == 0 else self.x / n.x, (0 if error_mode == "zero" else (self.y if error_mode == "null" else _mt.nan)) if n.y == 0 else self.y / n.y) #type: ignore
-        else:
-            raise Exception(f"\nArg n must be in [Vector2D, int, float, tuple, list] not a [{type(n)}]\n")
-
-    def min(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(min(self.x, other.x), min(self.y, other.y))
-    
-    def max(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(max(self.x, other.x), max(self.y, other.y))
-
-    def advanced_stringify(self:"Vector2D", precision:float|None=None, use_scientific_notation:bool=False, return_as_list=False) -> str:
-        precision = self.round_values_on_print if precision == None else precision
-        def optimize(value) -> str:
-            abs_value = abs(value)
-            if abs_value < 1/10**precision and abs_value != 0:
-                return f"{value:.{precision}e}"
-            elif abs_value < 10**precision:
-                return f"{value:.{precision}f}".rstrip('0').rstrip('.')
-            else:
-                return f"{value:.{precision}e}"
-        if return_as_list:
-            return [optimize(self.x), optimize(self.y)] if use_scientific_notation else [f"{self.x:.{precision}f}", f"{self.y:.{precision}f}"] #type: ignore
-        return f"{optimize(self.x)}, {optimize(self.y)}" if use_scientific_notation else f"{self.x:.{precision}f}, {self.y:.{precision}f}"
-
-    def __str__(self:"Vector2D") -> str:
-        return f"{self.x:.{self.round_values_on_print}f}, {self.y:.{self.round_values_on_print}f}"
-
-    def __repr__(self:"Vector2D") -> str:
-        return f"x:{self.x:.{self.round_values_on_print}f}\ty:{self.y:.{self.round_values_on_print}f}"
-
-    def __call__(self:"Vector2D", return_tuple=False) -> list|tuple:
-        return (self.x, self.y) if return_tuple else [self.x, self.y]
-
-    # normal operations     Vector2D + a
-    def __add__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(self.x + other.x, self.y + other.y)
-    
-    def __sub__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(self.x - other.x, self.y - other.y)
-    
-    def __mul__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(self.x * other.x, self.y * other.y)
-
-    def __mod__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(self.x % other.x, self.y % other.y)
-    
-    def __pow__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(self.x ** other.x, self.y ** other.y)
-
-    def __truediv__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(self.x / other.x, self.y / other.y)
-
-    def __floordiv__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(self.x // other.x, self.y // other.y)
-    
-    # right operations      a + Vector2D
-    def __radd__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        return self.__add__(other)
-    
-    def __rsub__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(other.x - self.x, other.y - self.y)
-    
-    def __rmul__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        return self.__mul__(other)
-
-    def __rmod__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(other.x % self.x, other.y % self.y)
-    
-    def __rpow__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(other.x ** self.x, other.y ** self.y)
-
-    def __rtruediv__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(other.x / self.x, other.y / self.y)
-
-    def __rfloordiv__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        return Vector2D(other.x // self.x, other.y // self.y)
-    
-    # in-place operations   Vector2D += a
-    def __iadd__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        self.x += other.x
-        self.y += other.y
-        return self
-
-    def __isub__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        self.x -= other.x
-        self.y -= other.y
-        return self
-    
-    def __imul__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        self.x *= other.x
-        self.y *= other.y
-        return self
-
-    def __itruediv__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        self.x /= other.x
-        self.y /= other.y
-        return self
-    
-    def __imod__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        self.x %= other.x
-        self.y %= other.y
-        return self
-    
-    def __ipow__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        self.x **= other.x
-        self.y **= other.y
-        return self
-
-    def __ifloordiv__(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> "Vector2D":
-        other = self.__normalize__(other)
-        self.x //= other.x
-        self.y //= other.y
-        return self
-
-    # comparasion
-    def __eq__(self, other) -> bool:
-        try: other = self.__normalize__(other)
-        except: return False
-        return self.x == other.x and self.y == other.y
-
-    def __ne__(self, other) -> bool:
-        return not self.__eq__(other)
-
-    def __abs__(self:"Vector2D") -> "Vector2D":
-        return Vector2D(abs(self.x), abs(self.y))
-
-    def __round__(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
-        n = self.__normalize__(n)
-        return Vector2D(round(self.x / n.x) * n.x, round(self.y / n.y) * n.y)
-
-    def __floor__(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
-        n = self.__normalize__(n)
-        return Vector2D(_mt.floor(self.x / n.x) * n.x, _mt.floor(self.y / n.y) * n.y)
-
-    def __ceil__(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
-        n = self.__normalize__(n)
-        return Vector2D(_mt.ceil(self.x / n.x) * n.x, _mt.ceil(self.y / n.y) * n.y)
-    
-    def __float__(self:"Vector2D") -> "Vector2D":
-        return Vector2D(float(self.x), float(self.y))
-
-    def __getitem__(self:"Vector2D", n) -> int|float:
-        if n in [0, "x"]:
-            return self.x
-        elif n in [1, "y"]:
-            return self.y
-        else:
-            raise IndexError("V2 has only x,y...")
-    
-    def __normalize__(self:"Vector2D", other) -> "Vector2D":
-        if not isinstance(other, Vector2D):
-            if any(isinstance(other, cls) for cls in {int, float}):
-                return Vector2D(other, other)
-            elif any(isinstance(other, cls) for cls in {list, tuple}):
-                return Vector2D(*other[:2])
-            else:
-                raise TypeError(f"The value {other} is not a num type: [{int|float}] nor an array type: [{list|tuple}]")
-        return other
-
-try:
-    from .Cmain import * #type: ignore
-    cV2 = Vector2D
-    cVector2D = Vector2D
-except Exception as err:
-    print(Warning(f"Unable to load the C-version on Vector2D: \n\t{err}"))
-    cV2 = None
-    cVector2D = None

e2D-1.4.13.dist-info/RECORD

@@ -1,12 +0,0 @@
-e2D/__init__.py,sha256=0bgnk4XOipVE1FAeOSwkJ85I8sXzLPEj8TnrNXGP7bw,23188
-e2D/__init__.pyi,sha256=vJjIrU1F8qLyyL5OcFyW56reghTOu4qQ7xqwwYesBzA,47925
-e2D/cvb.py,sha256=xMpwUBE1G2TOdah-x62W_6yXZey-n1p0OkvfiijZfNY,37445
-e2D/envs.py,sha256=yh_NBLSgZFi3zwGbSzR7tZTRDn2hKzC-oQNTWQRS7VA,6292
-e2D/plots.py,sha256=qNQZTwpYqDyonXGv_cDt-R3nGvu3xR7RSFDRdJma4rA,36069
-e2D/utils.py,sha256=7SkfQj5Y6J3_pW9ssWMKVDSawrDANv3GtehGRVeH96k,14048
-e2D/winrec.py,sha256=QMcQrED4xC8o5KAHEbhOR03lJ_-XRNAtUI3y-cRHsck,1122
-e2D-1.4.13.dist-info/LICENSE,sha256=wymkNVDvj3qmjdO_rAhkRPM4t5y3_SqffGsFdgfvznU,1066
-e2D-1.4.13.dist-info/METADATA,sha256=1kkNPGcb63ZzfUf-HluW5dwHCkTAcSJ_NrmLT7brPV0,9611
-e2D-1.4.13.dist-info/WHEEL,sha256=a7TGlA-5DaHMRrarXjVbQagU3Man_dCnGIWMJr5kRWo,91
-e2D-1.4.13.dist-info/top_level.txt,sha256=3vKZ-CGzNlTCpzVMmM0Ht76krCofKw7hZ0wBf-dnKdM,4
-e2D-1.4.13.dist-info/RECORD,,