e2D 1.0.6__py3-none-any.whl → 1.1.1__py3-none-any.whl

e2D/__init__.py

@@ -7,26 +7,77 @@ HALF_PI = PI/2
 QUARTER_PI = PI/4
 DOUBLE_PI = PI*2
 
+# regular expression to remove comments:
+# """([\s\S]*?)"""
+
+# 
 
 class Vector2D:
-    def __init__(self, x:int|float=0, y:int|float=0) -> None:
+    def __init__(self:"V2|Vector2D", x:int|float=0, y:int|float=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:"V2|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.
 
-    def distance_to(self, object:"float|int|Vector2D|V2|list|tuple", squared:bool=True) -> int|float:
+            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:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple", squared:bool=True) -> int|float:
         """
-        # Calculate the distance between the current Vector2D object and another object.
+        # Calculate the distance between the current Vector2D other and another other.
 
-        # Parameters:
-            object (float or int or Vector2D or list|tuple): The other object to which the distance is calculated.
+        ## 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 object and the other object if `squared` 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:
+        ## Example:
             point1 = Vector2D(0, 0)
 
             point2 = Vector2D(3, 4)
@@ -41,27 +92,27 @@ class Vector2D:
 
             This will calculate the squared and actual distances between the two points.
 
-        # Explanation:
-            The function calculates the squared distance between the current Vector2D object (self) and another object
-            (object) using the formula: (self.x - object.x)**2 + (self.y - object.y)**2.
+        ## 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.
         """
-        object = self.__normalize__(object)
-        d = (self.x - object.x)**2 + (self.y - object.y)**2
+        other = self.__normalize__(other)
+        d = (self.x - other.x)**2 + (self.y - other.y)**2
         return (d**(1/2) if squared else d)
 
-    def angle_to(self, object:"float|int|Vector2D|V2|list|tuple") -> int|float:
+    def angle_to(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> int|float:
         """
-        # Calculate the angle between the current Vector2D object and another object.
+        # Calculate the angle between the current Vector2D other and another other.
 
-        # Parameters:
-            object (float or int or Vector2D or list|tuple): The other object to which the angle is calculated.
+        ## 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 object and the other object.
+        ## Returns:
+            int|float: The angle in radians between the current Vector2D other and the other other.
 
-        # Example:
+        ## Example:
             point1 = Vector2D(0, 0)
 
             point2 = Vector2D(1, 1)
@@ -72,27 +123,27 @@ class Vector2D:
 
             This will calculate the angle in radians between the two points.
 
-        # Explanation:
-            The function calculates the angle in radians between the current Vector2D object (self) and another object
-            (object) using the `atan2` function from the `math` module.
+        ## 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.
         """
-        object = self.__normalize__(object)
-        return _mt.atan2(object.y - self.y, object.x - self.x)
+        other = self.__normalize__(other)
+        return _mt.atan2(other.y - self.y, other.x - self.x)
 
-    def point_from_degs(self, degs:int|float, radius:int|float) -> "Vector2D|V2":
+    def point_from_degs(self:"V2|Vector2D", degs:int|float, radius:int|float) -> "Vector2D|V2":
         """
         # Calculate a new Vector2D point from the current point based on an angle in degs and a radius.
 
-        # Parameters:
+        ## Parameters:
             rad (int|float): The angle in degs.
             radius (int|float): The distance from the current point.
 
-        # Returns:
+        ## Returns:
             Vector2D: A new Vector2D point calculated from the current point.
 
-        # Example:
+        ## Example:
             point1 = Vector2D(0, 0)
 
             angle = 45
@@ -105,7 +156,7 @@ class Vector2D:
 
             This will calculate a new point 5 units away from point1 at a 45-degree angle.
 
-        # Explanation:
+        ## Explanation:
             The function calculates a new Vector2D point based on an angle in degs (degs) and a distance (radius)
             from the current Vector2D point.
 
@@ -118,18 +169,18 @@ class Vector2D:
         y = radius * _mt.sin(_mt.radians(degs)) + self.y
         return Vector2D(x, y)
     
-    def point_from_rads(self, rad:int|float, radius:int|float) -> "Vector2D|V2":
+    def point_from_rads(self:"V2|Vector2D", rad:int|float, radius:int|float) -> "Vector2D|V2":
         """
         # Calculate a new Vector2D point from the current point based on an angle in radians and a radius.
 
-        # Parameters:
+        ## Parameters:
             rad (int|float): The angle in radians.
             radius (int|float): The distance from the current point.
 
-        # Returns:
+        ## Returns:
             Vector2D: A new Vector2D point calculated from the current point.
 
-        # Example:
+        ## Example:
             point1 = Vector2D(0, 0)
 
             angle = 45
@@ -142,7 +193,7 @@ class Vector2D:
 
             This will calculate a new point 5 units away from point1 at a 45-degree angle.
 
-        # Explanation:
+        ## Explanation:
             The function calculates a new Vector2D point based on an angle in radians (rad) and a distance (radius)
             from the current Vector2D point.
 
@@ -155,40 +206,40 @@ class Vector2D:
         y = radius * _mt.sin(rad) + self.y
         return Vector2D(x, y)
 
-    def copy(self) -> "Vector2D|V2":
+    def copy(self:"V2|Vector2D") -> "Vector2D|V2":
         """
-        # Create a copy of the current Vector2D object.
+        # Create a copy of the current Vector2D other.
 
-        # Returns:
-            Vector2D: A new Vector2D object with the same x and y coordinates as the current object.
+        ## Returns:
+            Vector2D: A new Vector2D other with the same x and y coordinates as the current other.
 
-        # Example:
+        ## 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 object (1, 2).
+            This will print the x and y coordinates of the copied Vector2D other (1, 2).
 
-        # Explanation:
-            The function creates a new Vector2D object with the same x and y coordinates as the current object.
+        ## 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 object, effectively making a copy of the original object.
+            The result is returned as a new Vector2D other, effectively making a copy of the original other.
         """
         return Vector2D(self.x, self.y)
 
-    def absolute_round(self, n=1) -> "Vector2D|V2":
+    def absolute_round(self:"V2|Vector2D", n=1) -> "Vector2D|V2":
         """
-        # Perform an "absolute round" operation on the Vector2D object.
+        # Perform an "absolute round" operation on the Vector2D other.
 
-        # Parameters:
+        ## Parameters:
             n (int|float, optional): The numeric value to scale the "absolute rounded" vector. Default is 1.
 
-        # Returns:
-            Vector2D: The "absolute rounded" Vector2D object scaled by the provided numeric value.
+        ## Returns:
+            Vector2D: The "absolute rounded" Vector2D other scaled by the provided numeric value.
 
-        # Example:
+        ## Example:
             vector1 = Vector2D(3.3, -4.7)
 
             result1 = vector1.absolute_round(0.5)
@@ -201,15 +252,15 @@ class Vector2D:
 
             print(result2.x, result2.y)
 
-        # Explanation:
-            The function performs an "absolute round" operation on the Vector2D object.
+        ## 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 object,
+            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 object with zeros for both components.
+            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.
@@ -220,17 +271,17 @@ class Vector2D:
         s_abs = abs(self)
         return self.no_zero_div_error(s_abs, "zero") * n
 
-    def floor(self, n:int|float=1) -> "Vector2D|V2":
+    def floor(self:"V2|Vector2D", n:int|float=1) -> "Vector2D|V2":
         """
-        # Round down the components of the Vector2D object to the nearest integer or the specified numeric value.
+        # Round down the components of the Vector2D other to the nearest integer or the specified numeric value.
 
-        # Parameters:
+        ## Parameters:
             n (int|float, optional): The numeric value to round down the components. Default is 1.
 
-        # Returns:
-            Vector2D: A new Vector2D object with the components rounded down to the nearest integer or the specified numeric value.
+        ## Returns:
+            Vector2D: A new Vector2D other with the components rounded down to the nearest integer or the specified numeric value.
 
-        # Example:
+        ## Example:
             vector1 = Vector2D(3.3, 4.7)
 
             result1 = vector1.floor()
@@ -243,15 +294,15 @@ class Vector2D:
 
             print(result2.x, result2.y)
 
-        # Explanation:
-            The function rounds down the components of the Vector2D object to the nearest integer or the specified numeric value.
+        ## Explanation:
+            The function rounds down the components of the Vector2D other to the nearest integer or the specified numeric value.
 
-            If the provided numeric value (n) is positive, the components of the resulting Vector2D object will be rounded down to
+            If the provided numeric value (n) is positive, the components of the resulting Vector2D other will be rounded down to
             the nearest multiple of the provided numeric value.
 
             If the provided numeric value (n) is negative, the function behaves the same as when n is positive.
 
-            If the provided numeric value (n) is 0, the function returns a Vector2D object with zeros for both components.
+            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 not an integer, it will be converted to an integer before performing the rounding.
 
@@ -260,17 +311,17 @@ class Vector2D:
         """
         return self.__floor__(n)
 
-    def ceil(self, n:int|float=1) -> "Vector2D|V2":
+    def ceil(self:"V2|Vector2D", n:int|float=1) -> "Vector2D|V2":
         """
-        # Round up the components of the Vector2D object to the nearest integer or the specified numeric value.
+        # Round up the components of the Vector2D other to the nearest integer or the specified numeric value.
 
-        # Parameters:
+        ## Parameters:
             n (int|float, optional): The numeric value to round up the components. Default is 1.
 
-        # Returns:
-            Vector2D: A new Vector2D object with the components rounded up to the nearest integer or the specified numeric value.
+        ## Returns:
+            Vector2D: A new Vector2D other with the components rounded up to the nearest integer or the specified numeric value.
 
-        # Example:
+        ## Example:
             vector1 = Vector2D(3.3, 4.7)
 
             result1 = vector1.ceil()
@@ -283,15 +334,15 @@ class Vector2D:
 
             print(result2.x, result2.y)
 
-        # Explanation:
-            The function rounds up the components of the Vector2D object to the nearest integer or the specified numeric value.
+        ## Explanation:
+            The function rounds up the components of the Vector2D other to the nearest integer or the specified numeric value.
 
-            If the provided numeric value (n) is positive, the components of the resulting Vector2D object will be rounded up to
+            If the provided numeric value (n) is positive, the components of the resulting Vector2D other will be rounded up to
             the nearest multiple of the provided numeric value.
 
             If the provided numeric value (n) is negative, the function behaves the same as when n is positive.
 
-            If the provided numeric value (n) is 0, the function returns a Vector2D object with zeros for both components.
+            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 not an integer, it will be converted to an integer before performing the rounding.
 
@@ -304,7 +355,7 @@ class Vector2D:
         """
         # Generate a random Vector2D point within the specified range.
 
-        # Parameters:
+        ## 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.
@@ -312,24 +363,24 @@ class Vector2D:
                                                         Default is None, which corresponds to (1, 1).
                                                         If numeric, both x and y will have the same value.
 
-        # Returns:
+        ## Returns:
             Vector2D: A new random Vector2D point within the specified range.
 
-        # Example:
+        ## 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:
+        ## 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 objects. If not, it creates new Vector2D objects
+            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.
@@ -345,17 +396,17 @@ class Vector2D:
             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)
 
-    def mid_point_to(self, *objects) -> float:
+    def mid_point_to(self:"V2|Vector2D", *others) -> float:
         """
-        # Calculate the midpoint between the current Vector2D object and one or more other Vector2D objects.
+        # Calculate the midpoint between the current Vector2D other and one or more other Vector2D others.
 
-        # Parameters:
-            *objects (Vector2D): Variable number of Vector2D objects representing other points.
+        ## Parameters:
+            *others (Vector2D): Variable number of Vector2D others representing other points.
 
-        # Returns:
-            Vector2D: A new Vector2D object representing the midpoint.
+        ## Returns:
+            Vector2D: A new Vector2D other representing the midpoint.
 
-        # Example:
+        ## Example:
             point1 = Vector2D(1, 2)
 
             point2 = Vector2D(3, 4)
@@ -366,122 +417,326 @@ class Vector2D:
 
             This will print the midpoint between point1 and point2.
 
-        # Explanation:
-            The function calculates the midpoint between the current Vector2D object (self)
-            and one or more other Vector2D objects (provided as *objects).
+        ## Explanation:
+            The function calculates the midpoint between the current Vector2D other (self)
+            and one or more other Vector2D others (provided as *others).
 
-            It first sums up all the Vector2D objects (including self) and then divides the sum by
-            the total number of points (len(objects) + 1) to find the average point, which represents the midpoint.
+            It first sums up all the Vector2D others (including self) and then divides the sum by
+            the total number of points (len(others) + 1) to find the average point, which represents the midpoint.
 
-            The result is returned as a new Vector2D object.
+            The result is returned as a new Vector2D other.
+        """
+        return sum(list(others) + [self]) / (len(others)+1)
+    
+    def dot_product(self, other:"float|int|Vector2D|V2|list|tuple") -> float:
+        other = self.__normalize__(other)
         """
-        return sum(list(objects) + [self]) / (len(objects)+1)
+        # Calculate the dot product of the current vector with another vector.
+
+        ## Parameters:
+            other (Vector2D): The other vector for the dot product calculation.
 
-    # Vector2D(x,y) | [(Vector2D(x1,y1), Vector2D(x2,y2)), (Vector2D(x3,y3), Vector2D(x4,y4))]
-    def inter_points(self:"Vector2D|V2", self_final_point:"Vector2D|V2", lines:list[tuple["Vector2D|V2", "Vector2D|V2"]], sort:bool=False, return_empty:bool=False) -> list["Vector2D|V2|None"]:
+        ## 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.
         """
-        # Calculate the intersection points between a ray and a list of line segments.
+        return self.x * other.x + self.y * other.y
+    
+    def magnitude(self) -> float:
+        """
+        # Vector Magnitude (Length)
 
-        # Parameters:
-            self (Vector2D): The starting point of the ray.
-            self_final_point (Vector2D): The ending point of the ray.
-            lines (list[tuple[Vector2D, Vector2D]]): A list of line segments represented by tuples of two Vector2D points.
-            sort (bool, optional): If True, sort the intersection points by their distance to the starting point (self).
-                                Default is False.
-            return_empty (bool, optional): If True, include None in the result for lines with no intersection points.
-                                        Default is False.
+        ## Returns:
+            float: The magnitude (length) of the vector.
 
-        # Returns:
-            list[Vector2D|None]: A list of intersection points as Vector2D objects.
-                                If return_empty is True, the list may also include None for lines without intersections.
+        ## Example:
+            v = Vector2D(3, 4)
+            magnitude_v = v.magnitude()  # Calculate the magnitude of the vector (3, 4)
+            print(magnitude_v)  # Output: 5.0
 
-        # Example:
-            point1 = Vector2D(1, 2)
+        ## Explanation:
+            This method calculates the magnitude (length) of the vector.
+            The magnitude of a 2D vector (x, y) is the square root of the sum of the squares of its components.
 
-            point2 = Vector2D(3, 4)
+            The method uses the formula: magnitude = sqrt(x^2 + y^2).
+
+            The resulting magnitude is returned as a floating-point value.
+
+            Example usage is shown in the "Example" section above.
+        """
+        return (self.x ** 2 + self.y ** 2) ** .5
 
-            lines = [(Vector2D(2, 1), Vector2D(2, 5)), (Vector2D(0, 3), Vector2D(5, 3))]
+    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.
 
-            intersections = point1.inter_points(point2, lines)
+        ## Raises:
+            ValueError: If the magnitude of the current vector is zero (zero vector).
 
-            print(intersections)
+        ## Example:
+            v = Vector2D(3, 4)
+            normalized_v = v.normalize()  # Normalize the vector (3, 4)
+            print(normalized_v)  # Output: (0.6, 0.8)
 
-        # Explanation:
-            The function calculates the intersection points between the ray defined by the starting point (self)
-            and the ending point (self_final_point) and a list of line segments (lines).
+        ## 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.
 
-            It uses the lineLineIntersect function to check for intersection between the ray and each line segment.
+            The method first calculates the magnitude of the current vector using the 'magnitude' method.
 
-            If sort is True, the intersection points are sorted by their distance to the starting point (self).
+            If the magnitude is zero (zero vector), a ValueError is raised, as normalization is not defined for zero vectors.
 
-            If return_empty is True, the function includes None in the result for lines without intersection points.
+            The normalized vector is obtained by dividing each component of the current vector by its magnitude.
 
-            The function returns a list of intersection points as Vector2D objects.
+            The resulting normalized vector is returned.
+
+            Example usage is shown in the "Example" section above.
         """
-        ray = self() + self_final_point() #type: ignore
-        def lineLineIntersect(P0, P1, Q0, Q1) -> tuple[int|float, int|float] | None:
-            d = (P1[0]-P0[0]) * (Q1[1]-Q0[1]) + (P1[1]-P0[1]) * (Q0[0]-Q1[0])
-            if d == 0:
-                return None
-            t = ((Q0[0]-P0[0]) * (Q1[1]-Q0[1]) +
-                 (Q0[1]-P0[1]) * (Q0[0]-Q1[0])) / d
-            u = ((Q0[0]-P0[0]) * (P1[1]-P0[1]) +
-                 (Q0[1]-P0[1]) * (P0[0]-P1[0])) / d
-            if 0 <= t <= 1 and 0 <= u <= 1:
-                return P1[0] * t + P0[0] * (1-t), P1[1] * t + P0[1] * (1-t)
-            return None
-        collisions = [Vector2D(*line) if line else None for line in [lineLineIntersect(line1[1](), line1[0](), ray[:2], ray[2:]) for line1 in lines] if line or return_empty]
-        if sort:
-            collisions.sort(key=lambda x: self.distance_to(x, False)) #type: ignore
-        return collisions
+        mag = self.magnitude()
+        if mag == 0:
+            raise ValueError("Cannot normalize zero vector.")
+        return Vector2D(self.x / mag, self.y / mag)
+
+    def projection(self, other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
+        """
+        # 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.
 
-    def normalize(self, max:int|float=1, min:int|float=0) -> "Vector2D|V2":
+            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.magnitude() ** 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|V2|list|tuple") -> "Vector2D|V2":
         """
-        # Normalize the Vector2D object to a new magnitude defined by max while preserving its direction.
+        # Vector Reflection
 
-        # Parameters:
-            max (int|float, optional): The new magnitude to which the Vector2D object will be scaled.
-                                      Default is 1.
-            min (int|float, optional): The minimum magnitude. If provided, the Vector2D object will not be scaled
-                                      below this value. Default is 0.
+        ## Parameters:
+            normal (float, int, Vector2D, V2, list, tuple): The normal vector representing the surface of reflection.
 
-        # Returns:
-            Vector2D: A new Vector2D object with the scaled magnitude.
+        ## Returns:
+            Vector2D or V2: The reflected vector.
 
-        # Example:
-            vector = Vector2D(3, 4)
+        ## 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)
 
-            normalized_vector = vector.normalize(5, 2)
+        ## 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).
 
-            print(normalized_vector.x, normalized_vector.y)
+            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.
 
-        # Explanation:
-            The function scales the Vector2D object to a new magnitude defined by max while preserving its direction.
+            The resulting reflected vector is returned.
 
-            It first calculates the current magnitude of the Vector2D object using distance_to method.
+            Example usage is shown in the "Example" section above.
+        """
+        normal = self.__normalize__(normal)
+        projection = self.projection(normal)
+        return self - projection * 2
 
-            If the current magnitude is not zero, it creates a new Vector2D object with magnitude max using
-            point_from_degs method and the angle_to method to preserve the direction.
+    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.magnitude()
+        theta = _mt.atan2(self.y, self.x)
+        return r, theta
 
-            If the current magnitude is zero, it returns a new zero vector (VectorZero.copy()).
+    @classmethod
+    def polar_to_cartesian(cls, r: float|int, theta: float|int) -> "Vector2D|V2":
         """
-        return Vector2D(min, min).point_from_degs(Vector2D(min, min).angle_to(self), max) if Vector2D(min, min).distance_to(self) != 0 else VectorZero.copy()
+        # 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 lerp(self, other:"float|int|Vector2D|V2|list|tuple", t: float) -> "Vector2D|V2":
+        """
+        # 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|V2|list|tuple|None"=None) -> "Vector2D|V2":
+        """
+        # 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|V2", n:"int|float|Vector2D|V2", error_mode:str="zero") -> "Vector2D|V2":
         """
-        # Handle division between the Vector2D object and a numeric value or another Vector2D object.
+        # 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 object for division.
+        ## 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 object with zeros for both components.
-                                        - "null": Return a Vector2D object with the original x or y component if available,
+                                        - "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 object after division or handling division by zero scenarios.
+        ## Returns:
+            Vector2D: A new Vector2D other after division or handling division by zero scenarios.
 
-        # Example:
+        ## Example:
             vector1 = Vector2D(3, 4)
 
             result1 = vector1.no_zero_div_error(2)
@@ -494,21 +749,21 @@ class Vector2D:
 
             print(result2.x, result2.y)
 
-        # Explanation:
-            The function handles division between the Vector2D object and a numeric value or another Vector2D object.
+        ## 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 object with zeros for both components if error_mode is "zero".
-                - If error_mode is "null", the function returns a Vector2D object with the original x or y component if available,
+                - 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 object:
-                - If n's x or y component is zero, the function returns a Vector2D object with zeros for the corresponding 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 object with the original x or y component if available,
+                - 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 object, the function raises an exception.
+            If n is neither a numeric value nor a Vector2D other, the function raises an exception.
         """
         if isinstance(n, int|float):
             if n == 0:
@@ -520,62 +775,95 @@ class Vector2D:
         else:
             raise Exception(f"\nArg n must be in [Vector2D, int, float, tuple, list] not a [{type(n)}]\n")
 
-    def __str__(self) -> str:
+    def __str__(self:"V2|Vector2D") -> str:
         return f"{self.x}, {self.y}"
 
-    def __sub__(self, object:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
-        object = self.__normalize__(object)
-        return Vector2D(self.x - object.x, self.y - object.y)
+    def __sub__(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
+        other = self.__normalize__(other)
+        return Vector2D(self.x - other.x, self.y - other.y)
 
-    def __add__(self, object:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
-        object = self.__normalize__(object)
-        return Vector2D(self.x + object.x, self.y + object.y)
+    def __add__(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
+        other = self.__normalize__(other)
+        return Vector2D(self.x + other.x, self.y + other.y)
 
-    def __mod__(self, object:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
-        object = self.__normalize__(object)
-        return Vector2D(self.x % object.x, self.y % object.y)
+    def __mod__(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
+        other = self.__normalize__(other)
+        return Vector2D(self.x % other.x, self.y % other.y)
 
-    def __radd__(self, object:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
-        return self.__add__(object)
+    def __radd__(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
+        return self.__add__(other)
 
-    def __repr__(self) -> str:
+    def __repr__(self:"V2|Vector2D") -> str:
         return f"x:{self.x}\ty:{self.y}"
 
-    def __call__(self, return_tuple=False) -> list|tuple:
+    def __call__(self:"V2|Vector2D", return_tuple=False) -> list|tuple:
         return (self.x, self.y) if return_tuple else [self.x, self.y]
 
-    def __truediv__(self, object:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
-        object = self.__normalize__(object)
-        return Vector2D(self.x / object.x, self.y / object.y)
+    def __truediv__(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
+        other = self.__normalize__(other)
+        return Vector2D(self.x / other.x, self.y / other.y)
 
-    def __floordiv__(self, object:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
-        object = self.__normalize__(object)
-        return Vector2D(self.x // object.x, self.y // object.y)
+    def __floordiv__(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
+        other = self.__normalize__(other)
+        return Vector2D(self.x // other.x, self.y // other.y)
+    
+    def __iadd__(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D":
+        other = self.__normalize__(other)
+        self.x += other.x
+        self.y += other.y
+        return self
+
+    def __isub__(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D":
+        other = self.__normalize__(other)
+        self.x -= other.x
+        self.y -= other.y
+        return self
+    
+    def __imul__(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D":
+        other = self.__normalize__(other)
+        self.x *= other.x
+        self.y *= other.y
+        return self
     
-    def __abs__(self) -> "Vector2D|V2":
+    def __itruediv__(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D":
+        other = self.__normalize__(other)
+        self.x /= other.x
+        self.y /= other.y
+        return self
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Vector2D|V2|list|tuple):
+            return False
+        other = self.__normalize__(other)
+        return self.x == other.x and self.y == other.y
+
+    def __ne__(self, other) -> bool:
+        return not self.__eq__(other)
+
+    def __abs__(self:"V2|Vector2D") -> "Vector2D|V2":
         return Vector2D(abs(self.x), abs(self.y))
 
-    def __round__(self, n:int|float=1) -> "Vector2D|V2":
+    def __round__(self:"V2|Vector2D", n:int|float=1) -> "Vector2D|V2":
         return Vector2D(round(self.x / n) * n, round(self.y / n) * n)
 
-    def __floor__(self, n:int|float=1) -> "Vector2D|V2":
+    def __floor__(self:"V2|Vector2D", n:int|float=1) -> "Vector2D|V2":
         return Vector2D(_mt.floor(self.x / n) * n, _mt.floor(self.y / n) * n)
 
-    def __ceil__(self, n:int|float=1) -> "Vector2D|V2":
+    def __ceil__(self:"V2|Vector2D", n:int|float=1) -> "Vector2D|V2":
         return Vector2D(_mt.ceil(self.x / n) * n, _mt.ceil(self.y / n) * n)
 
-    def __mul__(self, object:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
-        object = self.__normalize__(object)
-        return Vector2D(self.x * object.x, self.y * object.y)
+    def __mul__(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
+        other = self.__normalize__(other)
+        return Vector2D(self.x * other.x, self.y * other.y)
 
-    def __pow__(self, object:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
-        object = self.__normalize__(object)
-        return Vector2D(self.x ** object.x, self.y ** object.y)
+    def __pow__(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
+        other = self.__normalize__(other)
+        return Vector2D(self.x ** other.x, self.y ** other.y)
     
-    def __float__(self) -> "Vector2D|V2":
+    def __float__(self:"V2|Vector2D") -> "Vector2D|V2":
         return Vector2D(float(self.x), float(self.y))
 
-    def __getitem__(self, n) -> int|float:
+    def __getitem__(self:"V2|Vector2D", n) -> int|float:
         if n in [0, "x"]:
             return self.x
         elif n in [1, "y"]:
@@ -583,18 +871,40 @@ class Vector2D:
         else:
             raise IndexError("V2 has only x,y...")
     
-    def __normalize__(self, object) -> "Vector2D|V2":
-        if not isinstance(object, Vector2D):
-            if isinstance(object, int|float):
-                return Vector2D(object, object)
-            elif isinstance(object, list|tuple):
-                return Vector2D(*object[:2])
+    def __normalize__(self:"V2|Vector2D", other) -> "Vector2D|V2":
+        if not isinstance(other, Vector2D):
+            if isinstance(other, int|float):
+                return Vector2D(other, other)
+            elif isinstance(other, list|tuple):
+                return Vector2D(*other[:2])
             else:
-                raise TypeError(f"The value {object} is not a num type: [{int|float}] nor an array type: [{list|tuple}]")
-        return object
+                raise TypeError(f"The value {other} is not a num type: [{int|float}] nor an array type: [{list|tuple}]")
+        return other
 
 class V2(Vector2D):
-    def  __init__(self, x: int|float = 0, y: int|float = 0) -> None:
+    def  __init__(self:"V2|Vector2D", x: int|float = 0, y: int|float = 0) -> None:
+        """
+        # Initialize a 2D vector (V2) 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 = V2()        # Creates a V2 other with x=0 and y=0
+            vector2 = V2(3, -2.5) # Creates a V2 other with x=3 and y=-2.5
+
+        ## Explanation:
+            This class is an alias for the Vector2D class, with the benefit of using a shorter name (V2).
+
+            The constructor initializes a V2 other 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.
+        """
         super().__init__(x, y)
 
 V2inf = Vector2D(float('inf'), float('inf'))
@@ -608,7 +918,7 @@ def color_fade(starting_c:list|tuple, final_c:list|tuple, index:int|float, max_i
     """
     # Calculate the color at a specific index of a color fade between two given colors.
 
-    # Parameters:
+    ## 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
@@ -616,10 +926,10 @@ def color_fade(starting_c:list|tuple, final_c:list|tuple, index:int|float, max_i
         max_index (int or float): The maximum index of the color fade, indicating the endpoint
                                   position between the starting and final colors.
 
-    # Returns:
+    ## Returns:
         tuple: The RGB values of the color at the specified index as a tuple.
 
-    # Example:
+    ## Example:
         starting_c = (255, 0, 0)
 
         final_c = (0, 0, 255)
@@ -640,14 +950,14 @@ def weighted_color_fade(colors_dict:dict) -> tuple:
     """
     # Calculate the weighted color based on a dictionary of colors and their corresponding weights.
 
-    # Parameters:
+    ## Parameters:
         colors_dict (dict): A dictionary where keys represent RGB color values as tuples,
                             and values represent the weights (floats) for each color.
 
-    # Returns:
+    ## Returns:
         tuple: The RGB values of the calculated weighted color as a tuple.
 
-    # Example:
+    ## Example:
         colors_dict = {
         
             (255, 255, 255): 0.1,
@@ -672,15 +982,15 @@ def angular_interpolation(starting_angle:int|float, final_angle:int|float, step:
     """
     # Perform angular interpolation between two angles using the shortest distance.
 
-    # Parameters:
+    ## Parameters:
         starting_angle (int or float): The initial angle in radians.
         final_angle (int or float): The target angle in radians to interpolate towards.
         step (int or float, optional): The step size for interpolation in radians. Default is 0.1.
 
-    # Returns:
+    ## Returns:
         float: The interpolated angle as a result of angular interpolation.
 
-    # Example:
+    ## Example:
         starting_angle = 1.0
 
         final_angle = 5.0
@@ -691,7 +1001,7 @@ def angular_interpolation(starting_angle:int|float, final_angle:int|float, step:
 
         This will print the interpolated angle using angular interpolation.
 
-    # Explanation:
+    ## Explanation:
         The function calculates three distances between the `starting_angle` and the
         `final_angle`. These distances represent possible angular interpolations:
             1. The direct interpolation from `starting_angle` to `final_angle`.
@@ -714,17 +1024,17 @@ def color_distance(starting_c:list|tuple, final_c:list|tuple, sqrd:bool=True) ->
     """
     # Calculate the distance between two colors in RGB space.
 
-    # Parameters:
+    ## 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.
 
-    # Returns:
+    ## Returns:
         float: The squared distance between the two colors if `sqrd` is True, otherwise
                the actual distance.
 
-    # Example:
+    ## Example:
         starting_c = [255, 0, 0]
 
         final_c = [0, 255, 0]
@@ -739,7 +1049,7 @@ def color_distance(starting_c:list|tuple, final_c:list|tuple, sqrd:bool=True) ->
 
         This will calculate the squared and actual distances between the colors.
 
-    # Explanation:
+    ## 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
@@ -752,17 +1062,17 @@ def color_distance(starting_c:list|tuple, final_c:list|tuple, sqrd:bool=True) ->
     distance = sum([(starting_c[i]-final_c[i])**2 for i in range(3)])
     return (distance ** .5) if sqrd else distance
 
-def avg_position(*objects:"Vector2D|V2") -> Vector2D|V2:
+def avg_position(*others:"Vector2D|V2") -> Vector2D|V2:
     """
-    # Calculate the average position for a variable number of Vector2D objects.
+    # Calculate the average position for a variable number of Vector2D others.
 
-    # Parameters:
-        *objects (Vector2D): Variable number of Vector2D objects representing positions.
+    ## Parameters:
+        *others (Vector2D): Variable number of Vector2D others representing positions.
 
-    # Returns:
-        Vector2D: The average position as a new Vector2D object.
+    ## Returns:
+        Vector2D: The average position as a new Vector2D other.
 
-    # Example:
+    ## Example:
         position1 = Vector2D(10, 20)
 
         position2 = Vector2D(30, 40)
@@ -773,38 +1083,98 @@ def avg_position(*objects:"Vector2D|V2") -> Vector2D|V2:
 
         print(average_pos)
 
-        This will print the average position of the three Vector2D objects.
+        This will print the average position of the three Vector2D others.
+
+    ## Explanation:
+        The function takes a variable number of Vector2D others as input, representing positions.
+        It calculates the sum of all the Vector2D others using the `sum` function and then divides
+        it by the total number of others (length of `others`) to find the average position.
 
-    # Explanation:
-        The function takes a variable number of Vector2D objects as input, representing positions.
-        It calculates the sum of all the Vector2D objects using the `sum` function and then divides
-        it by the total number of objects (length of `objects`) to find the average position.
+        The result is returned as a new Vector2D other representing the average position.
+    """
+    return sum(others) / len(others) #type: ignore
 
-        The result is returned as a new Vector2D object representing the average position.
+def inter_points(ray:list["Vector2D|V2"]|tuple["Vector2D|V2", "Vector2D|V2"], lines:list[tuple["Vector2D|V2", "Vector2D|V2"]], return_inter_lines:bool=False, sort:bool=False, return_empty:bool=False) -> list[tuple[Vector2D | None, tuple[Vector2D | V2, Vector2D | V2]]] | list[Vector2D | None]:
     """
-    return sum(list(objects)) / (len(objects)) # type: ignore
+    # Find intersection points between a ray or line segment and multiple line segments.
+
+    ## Parameters:
+        ray (list[Vector2D|V2] | tuple[Vector2D|V2, Vector2D|V2]): The ray or line segment represented by two endpoints
+            (start and end points).
+        lines (list[tuple[Vector2D|V2, Vector2D|V2]]): A list of line segments represented by tuples of their endpoints.
+        return_inter_lines (bool, optional): If True, return a list of tuples containing the intersection points and the
+            corresponding intersecting line segment. Default is False.
+        sort (bool, optional): If True, sort the intersection points by their distance from the ray's start point.
+            Default is False.
+        return_empty (bool, optional): If True, include None for line segments with no intersection. Default is False.
+
+    ## Returns:
+        list[tuple[Vector2D | None, tuple[Vector2D | V2, Vector2D | V2]]] | list[Vector2D | None]:
+        - If return_inter_lines is True, returns a list of tuples, each containing:
+            - The intersection point (Vector2D) if it exists, or None otherwise.
+            - The corresponding intersecting line segment (tuple[Vector2D | V2, Vector2D | V2]).
+        - If return_inter_lines is False, returns a list of intersection points (Vector2D) if they exist, or None otherwise.
+
+    # Example:
+        ray = [Vector2D(1, 2), Vector2D(5, 3)]
+        lines = [(Vector2D(2, 2), Vector2D(4, 4)), (Vector2D(3, 3), Vector2D(6, 2))]
+        result = inter_points(ray, lines, return_inter_lines=True, sort=True)
+        print(result)
+
+    ## Explanation:
+        The function finds the intersection points (if any) between the given ray (or line segment) and the provided list
+        of line segments. The intersection points are returned in a list.
+
+        If return_inter_lines is True, the function returns a list of tuples, where each tuple contains the intersection point
+        (Vector2D) and the corresponding intersecting line segment (tuple[Vector2D | V2, Vector2D | V2]). If return_inter_lines
+        is False, the function returns only a list of intersection points (Vector2D) without the corresponding line segments.
+
+        If sort is True, the intersection points are sorted by their distance from the ray's start point. If sort is False,
+        the intersection points are returned in the order they were found.
+
+        If return_empty is True, the function includes None for line segments with no intersection. If return_empty is False,
+        line segments with no intersection are omitted from the result.
+
+        Example usage is shown in the "Example" section above.
+    """
+    def lineLineIntersect(P0:"V2|Vector2D", P1:"V2|Vector2D", Q0:"V2|Vector2D", Q1:"V2|Vector2D") -> "Vector2D | None":
+        d = (P1.x-P0.x) * (Q1.y-Q0.y) + (P1.y-P0.y) * (Q0.x-Q1.x)
+        if d == 0:
+            return None
+        t = ((Q0.x-P0.x) * (Q1.y-Q0.y) + (Q0.y-P0.y) * (Q0.x-Q1.x)) / d
+        u = ((Q0.x-P0.x) * (P1.y-P0.y) + (Q0.y-P0.y) * (P0.x-P1.x)) / d
+        if 0 <= t <= 1 and 0 <= u <= 1:
+            return Vector2D(P1.x * t + P0.x * (1-t), P1.y * t + P0.y * (1-t))
+        return None
+    
+    if return_inter_lines:
+        collisions = [(lineLineIntersect(line[1], line[0], ray[1], ray[0]), line) for line in lines if (line!=None or return_empty)]
+        return sorted(collisions, key=lambda x: ray[0].distance_to(x[0], False) if x[0] != None else _mt.inf) if sort else collisions
+    else:
+        collisions = [lineLineIntersect(line[1], line[0], ray[1], ray[0]) for line in lines if (line!=None or return_empty)]
+        return sorted(collisions, key=lambda x: ray[0].distance_to(x, False) if x != None else _mt.inf) if sort else collisions
 
 def get_points(position:Vector2D|V2, size:Vector2D|V2, rotation:int|float=0, pos_in_middle:bool=True, return_list:bool=False, clockwise_return:bool=False) -> tuple["Vector2D|V2", "Vector2D|V2", "Vector2D|V2", "Vector2D|V2"] | tuple[list[int|float]|tuple[int|float], list[int|float]|tuple[int|float], list[int|float]|tuple[int|float], list[int|float]|tuple[int|float]]:
     """
     # Generate points for a rectangle based on the given parameters.
 
-    # Parameters:
+    ## Parameters:
         position (Vector2D): The center position of the rectangle.
         size (Vector2D): The size of the rectangle (width and height).
         rotation (int|float, optional): The rotation angle in degrees. Default is 0.
         pos_in_middle (bool, optional): If True, the points represent corners of the rectangle.
                                         If False, the points represent the rectangle's edges.
                                         Default is True.
-        return_list (bool, optional): If True, return the points as lists instead of Vector2D objects.
+        return_list (bool, optional): If True, return the points as lists instead of Vector2D others.
                                       Default is False.
         clockwise_return (bool, optional): If True, return the points in clockwise order (A, B, D, C).
                                            If False, return the points in counterclockwise order (A, B, C, D).
                                            Default is False.
 
-    # Returns:
+    ## Returns:
         tuple: A tuple containing the four points of the rectangle.
 
-    # Example:
+    ## Example:
         position = Vector2D(100, 100)
 
         size = Vector2D(50, 30)
@@ -817,12 +1187,12 @@ def get_points(position:Vector2D|V2, size:Vector2D|V2, rotation:int|float=0, pos
 
         This will print the four points of the rotated rectangle.
 
-    # Explanation:
+    ## Explanation:
         The function calculates the four points (A, B, C, D) of the rectangle based on the center position,
         size, rotation, and pos_in_middle parameters. The points represent the rectangle's corners if pos_in_middle
         is True, and the edges if pos_in_middle is False.
 
-        The points are returned as Vector2D objects unless the return_list parameter is set to True. In that case,
+        The points are returned as Vector2D others unless the return_list parameter is set to True. In that case,
         the points will be returned as lists.
 
         The clockwise_return parameter determines the order of the points. If True, the points will be returned in
@@ -845,7 +1215,7 @@ def get_lines(position:Vector2D|V2, size:Vector2D|V2, rotation:int|float=0, pos_
     """
     # Generate lines representing the sides of a rectangle based on the given parameters.
 
-    # Parameters:
+    ## Parameters:
         position (Vector2D): The center position of the rectangle.
         size (Vector2D): The size of the rectangle (width and height).
         rotation (int|float, optional): The rotation angle in degrees. Default is 0.
@@ -853,11 +1223,11 @@ def get_lines(position:Vector2D|V2, size:Vector2D|V2, rotation:int|float=0, pos_
                                         If False, the points represent the rectangle's edges.
                                         Default is True.
 
-    # Returns:
-        list[list[Vector2D]]: A list of lists, where each sublist contains two Vector2D objects
+    ## Returns:
+        list[list[Vector2D]]: A list of lists, where each sublist contains two Vector2D others
                               representing the start and end points of a line segment.
 
-    # Example:
+    ## Example:
         position = Vector2D(100, 100)
 
         size = Vector2D(50, 30)
@@ -870,11 +1240,11 @@ def get_lines(position:Vector2D|V2, size:Vector2D|V2, rotation:int|float=0, pos_
 
         This will print the four line segments representing the sides of the rotated rectangle.
 
-    # Explanation:
+    ## Explanation:
         The function calculates the four points (A, B, C, D) of the rectangle using the `get_points` function
         based on the center position, size, rotation, and pos_in_middle parameters.
 
-        The function then returns a list of lists, where each sublist contains two Vector2D objects representing
+        The function then returns a list of lists, where each sublist contains two Vector2D others representing
         the start and end points of a line segment forming the sides of the rectangle.
     """
     A, B, C, D = get_points(position, size, rotation, pos_in_middle)
@@ -884,15 +1254,15 @@ def distance_line_point(line_point_a:Vector2D|V2, line_point_b:Vector2D|V2, poin
     """
     # Calculate the distance between a line segment and a point.
 
-    # Parameters:
+    ## Parameters:
         line_point_a (Vector2D): The starting point of the line segment.
         line_point_b (Vector2D): The ending point of the line segment.
         point_c (Vector2D): The point to which the distance is calculated.
 
-    # Returns:
+    ## Returns:
         float: The distance between the line segment and the point.
 
-    # Example:
+    ## Example:
         line_point_a = Vector2D(0, 0)
         
         line_point_b = Vector2D(10, 0)
@@ -905,7 +1275,7 @@ def distance_line_point(line_point_a:Vector2D|V2, line_point_b:Vector2D|V2, poin
 
         This will print the distance between the line segment and the point.
 
-    # Explanation:
+    ## Explanation:
         The function calculates the distance between a line segment defined by two points (line_point_a and line_point_b)
         and a third point (point_c).