PKG: Add package lpconvexhull

Author: Shaikh-Ubaid

integration_tests/lpconvexhull/__init__.py

@@ -0,0 +1 @@
+from .lpconvexhull_main import convex_hull

integration_tests/lpconvexhull/lpconvexhull_main.py

@@ -0,0 +1,56 @@
+from lpython import i32
+from .utils import min, distance
+
+def orientation(p: tuple[i32, i32], q: tuple[i32, i32], r: tuple[i32, i32]) -> i32:
+    # Function to find the orientation of triplet (p, q, r)
+    # Returns the following values:
+    # 0: Colinear
+    # 1: Clockwise
+    # 2: Counterclockwise
+    value: i32 = (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1])
+    if value == 0:
+        return 0  # Colinear
+    elif value > 0:
+        return 1  # Clockwise
+    else:
+        return 2  # Counterclockwise
+
+
+def convex_hull(points: list[tuple[i32, i32]]) -> list[tuple[i32, i32]]:
+    """Finds the convex hull of a set of points.
+
+    Args:
+        points: A list of points.
+
+    Returns:
+        A list of points that form the convex hull.
+    """
+
+    n: i32 = len(points)
+    if n < 3:
+        return [(-1, -1)]  # Convex hull not possible
+
+    # Find the leftmost point
+    leftmost: tuple[i32, i32] = min(points)
+    hull: list[tuple[i32, i32]] = []
+
+    p: tuple[i32, i32] = leftmost
+
+    while True:
+        hull.append(p)
+        q: tuple[i32, i32] = points[0]
+
+        r: tuple[i32, i32]
+        for r in points:
+            if r == p or r == q:
+                continue
+            direction: i32 = orientation(p, q, r)
+            if direction == 1 or (direction == 0 and distance(p, r) > distance(p, q)):
+                q = r
+
+        p = q
+
+        if p == leftmost:
+            break
+
+    return hull

integration_tests/lpconvexhull/utils.py

@@ -0,0 +1,29 @@
+from lpython import i32, f64
+
+def min(points: list[tuple[i32, i32]]) -> tuple[i32, i32]:
+    """Finds the left-most point in a list of points.
+
+    Args:
+        points: A list of points.
+
+    Returns:
+        The left-most point in the list.
+    """
+
+    left_most_point: tuple[i32, i32] = points[0]
+    point: tuple[i32, i32]
+    for point in points:
+        if point[0] < left_most_point[0]:
+            left_most_point = point
+
+    return left_most_point
+
+
+def distance(p: tuple[i32, i32], q: tuple[i32, i32]) -> f64:
+    # Function to calculate the Euclidean distance between two points
+    x1: i32; y1: i32
+    x2: i32; y2: i32
+
+    x1, y1 = p
+    x2, y2 = q
+    return f64((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5