adding a geometry module

Author: meg-1

Diff for: geometry/__init__.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Angle:
+    """
+    representation of an Angle in degrees (unit of measurement)
+    """
+
+    degrees: float

Diff for: geometry/angles/__init__.py

@@ -0,0 +1,63 @@
+from ..shape_types.closed_shapes import closedShape
+import math
+
+
+class Circle(closedShape):
+
+    """
+    a structure which represents a
+    geometrical circle on a 2D surface
+
+    >>> circle_one = Circle(5)
+    >>> circle_one.get_diameter()
+    10
+    >>> circle_one.perimeter()
+    31.41592653589793
+    >>> circle_one.is_similar(None)
+    Traceback (most recent call last):
+    NotImplementedError: Not Implemented
+    >>> circle_one.split()
+    Traceback (most recent call last):
+    NotImplementedError: Not Implemented
+    >>> circle_one.max_parts(54)
+    1486.0
+    >>> circle_one.max_parts(7)
+    29.0
+    >>> circle_one.max_parts(22.5)
+    265.375
+    >>> circle_one.max_parts(-222)
+    -1
+    >>> circle_one.max_parts("-222")
+    Traceback (most recent call last):
+    TypeError: num_cuts must be a numeric value.
+    """
+
+    def __init__(self, radius):
+        self.radius = radius
+        self.origin = 0
+
+    def get_diameter(self):
+        return self.radius * 2
+
+    def perimeter(self):
+        return 2 * math.pi * self.radius
+
+    def area(self):
+        return math.pi * (self.radius**2)
+
+    def is_similar(self, compared_shape):
+        raise NotImplementedError("Not Implemented")
+
+    def split(self):
+        raise NotImplementedError("Not Implemented")
+
+    def max_parts(self, num_cuts: float) -> float:
+        """
+        returns the maximum amount of
+        parts a circle can be divided
+        by if cut 'num_cuts' times
+        """
+
+        if not isinstance(num_cuts, (int, float)):
+            raise TypeError("num_cuts must be a numeric value.")
+        return ((num_cuts + 2 + num_cuts**2) * 0.5) if num_cuts >= 0 else -1

Diff for: geometry/angles/angle.py

@@ -0,0 +1,36 @@
+from ..shape_types.closed_shapes import closedShape
+import math
+
+
+class Ellipse(closedShape):
+
+    """
+    a structure which represents a
+    geometrical ellipse on a 2D surface
+
+    >>> ellipse_one = Ellipse(5, 10)
+    >>> ellipse_one.perimeter()
+    47.12388980384689
+    >>> ellipse_one.is_similar(None)
+    Traceback (most recent call last):
+    NotImplementedError: Not Implemented
+    >>> ellipse_one.split()
+    Traceback (most recent call last):
+    NotImplementedError: Not Implemented
+    """
+
+    def __init__(self, major_radius, minor_radius):
+        self.major_radius: float = major_radius
+        self.minor_radius: float = minor_radius
+
+    def perimeter(self):
+        return math.pi * (self.major_radius + self.minor_radius)
+
+    def area(self):
+        return math.pi * self.major_radius * self.minor_radius
+
+    def is_similar(self, compared_shape):
+        raise NotImplementedError("Not Implemented")
+
+    def split(self):
+        raise NotImplementedError("Not Implemented")

Diff for: geometry/coordinate_plane/__init__.py

@@ -0,0 +1,68 @@
+from ..shape_types.closed_shapes import closedShape
+from ..side import Side
+from ..shape_types.intersecting_self_shapes import intersectSelfShape
+from ...angles.angle import Angle
+
+
+class Polygon(closedShape, intersectSelfShape):
+
+    """
+    an abstract class which represents a
+    set of polygons on a 2D surface
+
+    >>> polygon_one = Polygon()
+    >>> side_length = 15
+    >>> angle_degrees = 60
+    >>> side_one = Side([], Angle(angle_degrees), side_length)
+    >>> side_two = Side([], Angle(angle_degrees), side_length)
+    >>> side_three = Side([], Angle(angle_degrees), side_length)
+    >>> side_one.adjacent_sides.append(side_two)
+    >>> side_one.adjacent_sides.append(side_three)
+    >>> side_two.adjacent_sides.append(side_three)
+    >>> side_two.adjacent_sides.append(side_one)
+    >>> side_three.adjacent_sides.append(side_one)
+    >>> side_three.adjacent_sides.append(side_two)
+    >>> polygon_one.add_side(side_one)
+    >>> polygon_one.add_side(side_two)
+    >>> polygon_one.add_side(side_three)
+    >>> polygon_one.set_side(0, side_one)
+    >>> polygon_one.set_side(1, side_two)
+    >>> polygon_one.set_side(2, side_three)
+    >>> side_one_data = polygon_one.get_side(0)
+    >>> print(side_one_data.length)
+    15
+    >>> print(side_one_data.angle.degrees)
+    60
+    >>> polygon_one.area()
+
+    >>> polygon_one.is_similar(None)
+
+    >>> polygon_one.split()
+
+    >>> polygon_one.perimeter()
+
+    """
+
+    def __init__(self):
+        self.sides: list[Side] = []
+
+    def get_side(self, index):
+        return self.sides[index]
+
+    def set_side(self, index, side):
+        self.sides[index] = side
+
+    def add_side(self, side):
+        self.sides.append(side)
+
+    def area(self):
+        pass
+
+    def is_similar(self, compared_shape):
+        pass
+
+    def perimeter(self):
+        pass
+
+    def split(self):
+        pass

Diff for: geometry/lines/__init__.py

@@ -0,0 +1,41 @@
+from .polygon import Polygon
+from ..side import Side
+from ...angles.angle import Angle
+
+
+class Rectangle(Polygon):
+    """
+    a structure which represents a
+    geometrical rectangle on a 2D surface
+
+    >>> rectangle_one = Rectangle(5, 10)
+    >>> rectangle_one.perimeter()
+    30
+    >>> rectangle_one.area()
+    50
+    >>> rectangle_one.is_similar(None)
+    Traceback (most recent call last):
+    NotImplementedError: Not Implemented
+    >>> rectangle_one.split()
+    Traceback (most recent call last):
+    NotImplementedError: Not Implemented
+    """
+
+    def __init__(self, short_side_length, long_side_length):
+        super().__init__()
+        self.short_side = Side([], Angle(90), short_side_length)
+        self.long_side = Side([], Angle(90), long_side_length)
+        super().add_side(self.short_side)
+        super().add_side(self.long_side)
+
+    def perimeter(self):
+        return (self.short_side.length + self.long_side.length) * 2
+
+    def area(self):
+        return self.short_side.length * self.long_side.length
+
+    def is_similar(self, compared_shape):
+        raise NotImplementedError("Not Implemented")
+
+    def split(self):
+        raise NotImplementedError("Not Implemented")

Diff for: geometry/shapes/__init__.py

@@ -0,0 +1,35 @@
+from .rectangle import Rectangle
+
+
+class Square(Rectangle):
+    """
+    a structure which represents a
+    geometrical square on a 2D surface
+
+    >>> square_one = Square(5)
+    >>> square_one.perimeter()
+    20
+    >>> square_one.area()
+    25
+    >>> square_one.is_similar(None)
+    Traceback (most recent call last):
+    NotImplementedError: Not Implemented
+    >>> square_one.split()
+    Traceback (most recent call last):
+    NotImplementedError: Not Implemented
+    """
+
+    def __init__(self, side_length):
+        super().__init__(side_length, side_length)
+
+    def perimeter(self):
+        return super().perimeter()
+
+    def area(self):
+        return super().area()
+
+    def is_similar(self, compared_shape):
+        raise NotImplementedError("Not Implemented")
+
+    def split(self):
+        raise NotImplementedError("Not Implemented")

Diff for: geometry/shapes/ellipses/__init__.py

@@ -0,0 +1,32 @@
+from abc import ABC, abstractmethod
+
+
+class shape(ABC):
+
+    """
+    interface which represents a geometrical shape
+    at a global level
+    """
+
+    @abstractmethod
+    def is_similar(self, compared_shape):
+        """
+        a method for comparing with another shape,
+        which also implements this interface
+        """
+        pass
+
+    @abstractmethod
+    def split(self):
+        """
+        a method for splitting a shape
+        into a certain quantity of pieces,
+        following a specific algorithm
+        """
+        pass
+
+    """
+	to do: create a factory method for creating a specific shape
+	@abstractmethod
+	def create_shape(self):
+		pass"""

Diff for: geometry/shapes/ellipses/circle.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+from ..shape import shape
+
+
+class closedShape(shape, ABC):
+    """
+    an interface which represents shapes
+    that start and end at the same point [closed shape]
+    more info: https://en.wikipedia.org/wiki/Polygon
+    """
+
+    @abstractmethod
+    def perimeter(self):
+        pass
+
+    @abstractmethod
+    def area(self):
+        pass
+
+    @abstractmethod
+    def is_similar(self, compared_shape):
+        pass
+
+    @abstractmethod
+    def split(self):
+        pass

Diff for: geometry/shapes/ellipses/ellipse.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+from ..shape import shape
+
+
+class intersectSelfShape(shape, ABC):
+    """
+    an interface which represents polygons
+    some of whose edges cross each other [self intersecting shapes]
+    more info: https://en.wikipedia.org/wiki/Polygon
+    """
+
+    @abstractmethod
+    def perimeter(self):
+        pass
+
+    @abstractmethod
+    def area(self):
+        pass
+
+    @abstractmethod
+    def is_similar(self, compared_shape):
+        pass
+
+    @abstractmethod
+    def split(self):
+        pass

Diff for: geometry/shapes/polygon/__init__.py

@@ -0,0 +1,18 @@
+from abc import abstractmethod
+import shape
+
+
+class OpenShape(shape, ABC):
+    """
+    an interface which represents shapes or figures
+    with different starting and ending points [open shapes]
+    more info: https://en.wikipedia.org/wiki/Polygon
+    """
+
+    @abstractmethod
+    def is_similar(self, compared_shape):
+        pass
+
+    @abstractmethod
+    def split(self):
+        pass

Diff for: geometry/shapes/polygon/polygon.py

@@ -0,0 +1,16 @@
+from ..angles.angle import Angle
+from dataclasses import dataclass
+
+
+@dataclass
+class Side:
+
+    """
+    represents a side of a shape [such as polygon, e.t.c.]
+    adjacent_sides: a list of sides which are adjacent to the current side
+    angle: the angle between adjacent sides
+    """
+
+    adjacent_sides: list[float]
+    angle: Angle
+    length: float