chore: import upstream snapshot with attribution

geometry/CMakeLists.txt

@@ -0,0 +1,18 @@
+# If necessary, use the RELATIVE flag, otherwise each source file may be listed
+# with full pathname. RELATIVE may makes it easier to extract an executable name
+# automatically.
+file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
+# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
+# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
+foreach( testsourcefile ${APP_SOURCES} )
+    # I used a simple string replace, to cut off .cpp.
+    string( REPLACE ".cpp" "" testname ${testsourcefile} )
+    add_executable( ${testname} ${testsourcefile} )
+
+    set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX)
+    if(OpenMP_CXX_FOUND)
+        target_link_libraries(${testname} OpenMP::OpenMP_CXX)
+    endif()
+    install(TARGETS ${testname} DESTINATION "bin/geometry")
+
+endforeach( testsourcefile ${APP_SOURCES} )

geometry/graham_scan_algorithm.cpp

@@ -0,0 +1,76 @@
+/******************************************************************************
+ * @file
+ * @brief Implementation of the [Convex
+ * Hull](https://en.wikipedia.org/wiki/Convex_hull) implementation using [Graham
+ * Scan](https://en.wikipedia.org/wiki/Graham_scan)
+ * @details
+ * In geometry, the convex hull or convex envelope or convex closure of a shape
+ * is the smallest convex set that contains it. The convex hull may be defined
+ * either as the intersection of all convex sets containing a given subset of a
+ * Euclidean space, or equivalently as the set of all convex combinations of
+ * points in the subset. For a bounded subset of the plane, the convex hull may
+ * be visualized as the shape enclosed by a rubber band stretched around the
+ * subset.
+ *
+ * The worst case time complexity of Jarvis’s Algorithm is O(n^2). Using
+ * Graham’s scan algorithm, we can find Convex Hull in O(nLogn) time.
+ *
+ * ### Implementation
+ *
+ * Sort points
+ * We first find the bottom-most point. The idea is to pre-process
+ * points be sorting them with respect to the bottom-most point. Once the points
+ * are sorted, they form a simple closed path.
+ * The sorting criteria is to use the orientation to compare angles without
+ * actually computing them (See the compare() function below) because
+ * computation of actual angles would be inefficient since trigonometric
+ * functions are not simple to evaluate.
+ *
+ * Accept or Reject Points
+ * Once we have the closed path, the next step is to traverse the path and
+ * remove concave points on this path using orientation. The first two points in
+ * sorted array are always part of Convex Hull. For remaining points, we keep
+ * track of recent three points, and find the angle formed by them. Let the
+ * three points be prev(p), curr(c) and next(n). If the orientation of these
+ * points (considering them in the same order) is not counterclockwise, we
+ * discard c, otherwise we keep it.
+ *
+ * @author [Lajat Manekar](https://github.com/Lazeeez)
+ *
+ *******************************************************************************/
+#include <cassert>   /// for std::assert
+#include <iostream>  /// for IO Operations
+#include <vector>    /// for std::vector
+
+#include "./graham_scan_functions.hpp"  /// for all the functions used
+
+/*******************************************************************************
+ * @brief Self-test implementations
+ * @returns void
+ *******************************************************************************/
+static void test() {
+    std::vector<geometry::grahamscan::Point> points = {
+        {0, 3}, {1, 1}, {2, 2}, {4, 4}, {0, 0}, {1, 2}, {3, 1}, {3, 3}};
+    std::vector<geometry::grahamscan::Point> expected_result = {
+        {0, 3}, {4, 4}, {3, 1}, {0, 0}};
+    std::vector<geometry::grahamscan::Point> derived_result;
+    std::vector<geometry::grahamscan::Point> res;
+
+    derived_result = geometry::grahamscan::convexHull(points, points.size());
+
+    std::cout << "1st test: ";
+    for (int i = 0; i < expected_result.size(); i++) {
+        assert(derived_result[i].x == expected_result[i].x);
+        assert(derived_result[i].y == expected_result[i].y);
+    }
+    std::cout << "passed!" << std::endl;
+}
+
+/*******************************************************************************
+ * @brief Main function
+ * @returns 0 on exit
+ *******************************************************************************/
+int main() {
+    test();  // run self-test implementations
+    return 0;
+}

geometry/graham_scan_functions.hpp

@@ -0,0 +1,210 @@
+/******************************************************************************
+ * @file
+ * @brief Implementation of the [Convex
+ * Hull](https://en.wikipedia.org/wiki/Convex_hull) implementation using [Graham
+ * Scan](https://en.wikipedia.org/wiki/Graham_scan)
+ * @details
+ * In geometry, the convex hull or convex envelope or convex closure of a shape
+ * is the smallest convex set that contains it. The convex hull may be defined
+ * either as the intersection of all convex sets containing a given subset of a
+ * Euclidean space, or equivalently as the set of all convex combinations of
+ * points in the subset. For a bounded subset of the plane, the convex hull may
+ * be visualized as the shape enclosed by a rubber band stretched around the
+ * subset.
+ *
+ * The worst case time complexity of Jarvis’s Algorithm is O(n^2). Using
+ * Graham’s scan algorithm, we can find Convex Hull in O(nLogn) time.
+ *
+ * ### Implementation
+ *
+ * Sort points
+ * We first find the bottom-most point. The idea is to pre-process
+ * points be sorting them with respect to the bottom-most point. Once the points
+ * are sorted, they form a simple closed path.
+ * The sorting criteria is to use the orientation to compare angles without
+ * actually computing them (See the compare() function below) because
+ * computation of actual angles would be inefficient since trigonometric
+ * functions are not simple to evaluate.
+ *
+ * Accept or Reject Points
+ * Once we have the closed path, the next step is to traverse the path and
+ * remove concave points on this path using orientation. The first two points in
+ * sorted array are always part of Convex Hull. For remaining points, we keep
+ * track of recent three points, and find the angle formed by them. Let the
+ * three points be prev(p), curr(c) and next(n). If orientation of these points
+ * (considering them in same order) is not counterclockwise, we discard c,
+ * otherwise we keep it.
+ *
+ * @author [Lajat Manekar](https://github.com/Lazeeez)
+ *
+ *******************************************************************************/
+#include <algorithm>  /// for std::swap
+#include <cstdint>
+#include <cstdlib>    /// for mathematics and datatype conversion
+#include <iostream>   /// for IO operations
+#include <stack>      /// for std::stack
+#include <vector>     /// for std::vector
+
+/******************************************************************************
+ * @namespace geometry
+ * @brief geometric algorithms
+ *******************************************************************************/
+namespace geometry {
+
+/******************************************************************************
+ * @namespace graham scan
+ * @brief convex hull algorithm
+ *******************************************************************************/
+namespace grahamscan {
+
+/******************************************************************************
+ * @struct Point
+ * @brief for X and Y co-ordinates of the co-ordinate.
+ *******************************************************************************/
+struct Point {
+    int x, y;
+};
+
+// A global point needed for sorting points with reference
+// to  the first point Used in compare function of qsort()
+
+Point p0;
+
+/******************************************************************************
+ * @brief A utility function to find next to top in a stack.
+ * @param S Stack to be used for the process.
+ * @returns @param Point Co-ordinates of the Point <int, int>
+ *******************************************************************************/
+Point nextToTop(std::stack<Point> *S) {
+    Point p = S->top();
+    S->pop();
+    Point res = S->top();
+    S->push(p);
+    return res;
+}
+
+/******************************************************************************
+ * @brief A utility function to return square of distance between p1 and p2.
+ * @param p1 Co-ordinates of Point 1 <int, int>.
+ * @param p2 Co-ordinates of Point 2 <int, int>.
+ * @returns @param int distance between p1 and p2.
+ *******************************************************************************/
+int distSq(Point p1, Point p2) {
+    return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
+}
+
+/******************************************************************************
+ * @brief To find orientation of ordered triplet (p, q, r).
+ * @param p Co-ordinates of Point p <int, int>.
+ * @param q Co-ordinates of Point q <int, int>.
+ * @param r Co-ordinates of Point r <int, int>.
+ * @returns @param int 0 --> p, q and r are collinear, 1 --> Clockwise,
+ * 2 --> Counterclockwise
+ *******************************************************************************/
+int orientation(Point p, Point q, Point r) {
+    int val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+
+    if (val == 0) {
+        return 0;  // collinear
+    }
+    return (val > 0) ? 1 : 2;  // clock or counter-clock wise
+}
+
+/******************************************************************************
+ * @brief A function used by library function qsort() to sort an array of
+ * points with respect to the first point
+ * @param vp1 Co-ordinates of Point 1 <int, int>.
+ * @param vp2 Co-ordinates of Point 2 <int, int>.
+ * @returns @param int distance between p1 and p2.
+ *******************************************************************************/
+int compare(const void *vp1, const void *vp2) {
+    auto *p1 = static_cast<const Point *>(vp1);
+    auto *p2 = static_cast<const Point *>(vp2);
+
+    // Find orientation
+    int o = orientation(p0, *p1, *p2);
+    if (o == 0) {
+        return (distSq(p0, *p2) >= distSq(p0, *p1)) ? -1 : 1;
+    }
+
+    return (o == 2) ? -1 : 1;
+}
+
+/******************************************************************************
+ * @brief Prints convex hull of a set of n points.
+ * @param points vector of Point<int, int> with co-ordinates.
+ * @param size Size of the vector.
+ * @returns @param vector vector of Conver Hull.
+ *******************************************************************************/
+std::vector<Point> convexHull(std::vector<Point> points, uint64_t size) {
+    // Find the bottom-most point
+    int ymin = points[0].y, min = 0;
+    for (int i = 1; i < size; i++) {
+        int y = points[i].y;
+
+        // Pick the bottom-most or chose the left-most point in case of tie
+        if ((y < ymin) || (ymin == y && points[i].x < points[min].x)) {
+            ymin = points[i].y, min = i;
+        }
+    }
+
+    // Place the bottom-most point at first position
+    std::swap(points[0], points[min]);
+
+    // Sort n-1 points with respect to the first point. A point p1 comes
+    // before p2 in sorted output if p2 has larger polar angle
+    // (in counterclockwise direction) than p1.
+    p0 = points[0];
+    qsort(&points[1], size - 1, sizeof(Point), compare);
+
+    // If two or more points make same angle with p0, Remove all but the one
+    // that is farthest from p0 Remember that, in above sorting, our criteria
+    // was to keep the farthest point at the end when more than one points have
+    // same angle.
+    int m = 1;  // Initialize size of modified array
+    for (int i = 1; i < size; i++) {
+        // Keep removing i while angle of i and i+1 is same with respect to p0
+        while (i < size - 1 && orientation(p0, points[i], points[i + 1]) == 0) {
+            i++;
+        }
+
+        points[m] = points[i];
+        m++;  // Update size of modified array
+    }
+
+    // If modified array of points has less than 3 points, convex hull is not
+    // possible
+    if (m < 3) {
+        return {};
+    };
+
+    // Create an empty stack and push first three points to it.
+    std::stack<Point> St;
+    St.push(points[0]);
+    St.push(points[1]);
+    St.push(points[2]);
+
+    // Process remaining n-3 points
+    for (int i = 3; i < m; i++) {
+        // Keep removing top while the angle formed by
+        // points next-to-top, top, and points[i] makes
+        // a non-left turn
+        while (St.size() > 1 &&
+               orientation(nextToTop(&St), St.top(), points[i]) != 2) {
+            St.pop();
+        }
+        St.push(points[i]);
+    }
+
+    std::vector<Point> result;
+    // Now stack has the output points, push them into the resultant vector
+    while (!St.empty()) {
+        Point p = St.top();
+        result.push_back(p);
+        St.pop();
+    }
+
+    return result;  // return resultant vector with Convex Hull co-ordinates.
+}
+}  // namespace grahamscan
+}  // namespace geometry

geometry/jarvis_algorithm.cpp

@@ -0,0 +1,179 @@
+/**
+ * @file
+ * @brief Implementation of [Jarvis’s](https://en.wikipedia.org/wiki/Gift_wrapping_algorithm) algorithm.
+ *
+ * @details
+ * Given a set of points in the plane. the convex hull of the set
+ * is the smallest convex polygon that contains all the points of it.
+ *
+ * ### Algorithm
+ * The idea of Jarvis’s Algorithm is simple, we start from the leftmost point
+ * (or point with minimum x coordinate value) and we
+ * keep wrapping points in counterclockwise direction.
+ *
+ * The idea is to use orientation() here. Next point is selected as the
+ * point that beats all other points at counterclockwise orientation, i.e.,
+ * next point is q if for any other point r,
+ * we have “orientation(p, q, r) = counterclockwise”.
+ *
+ * For Example,
+ * If points = {{0, 3}, {2, 2}, {1, 1}, {2, 1},
+                      {3, 0}, {0, 0}, {3, 3}};
+ *
+ * then the convex hull is
+ * (0, 3), (0, 0), (3, 0), (3, 3)
+ *
+ * @author [Rishabh Agarwal](https://github.com/rishabh-997)
+ */
+
+#include <vector>
+#include <cassert>
+#include <iostream>
+
+/**
+ *  @namespace geometry
+ *  @brief Geometry algorithms
+ */
+namespace geometry {
+    /**
+     * @namespace jarvis
+     * @brief Functions for [Jarvis’s](https://en.wikipedia.org/wiki/Gift_wrapping_algorithm) algorithm
+     */
+    namespace jarvis {
+        /**
+         * Structure defining the x and y co-ordinates of the given
+         * point in space
+         */
+        struct Point {
+            int x, y;
+        };
+
+        /**
+         * Class which can be called from main and is globally available
+         * throughout the code
+         */
+        class Convexhull {
+            std::vector<Point> points;
+            int size;
+
+        public:
+            /**
+             * Constructor of given class
+             *
+             * @param pointList list of all points in the space
+             * @param n number of points in space
+             */
+            explicit Convexhull(const std::vector<Point> &pointList) {
+                points = pointList;
+                size = points.size();
+            }
+
+            /**
+             * Creates convex hull of a set of n points.
+             * There must be 3 points at least for the convex hull to exist
+             *
+             * @returns an vector array containing points in space
+             * which enclose all given points thus forming a hull
+             */
+            std::vector<Point> getConvexHull() const {
+                // Initialize Result
+                std::vector<Point> hull;
+
+                // Find the leftmost point
+                int leftmost_point = 0;
+                for (int i = 1; i < size; i++) {
+                    if (points[i].x < points[leftmost_point].x) {
+                        leftmost_point = i;
+                    }
+                }
+                // Start from leftmost point, keep moving counterclockwise
+                // until reach the start point again.  This loop runs O(h)
+                // times where h is number of points in result or output.
+                int p = leftmost_point, q = 0;
+                do {
+                    // Add current point to result
+                    hull.push_back(points[p]);
+
+                    // Search for a point 'q' such that orientation(p, x, q)
+                    // is counterclockwise for all points 'x'. The idea
+                    // is to keep track of last visited most counter clock-
+                    // wise point in q. If any point 'i' is more counter clock-
+                    // wise than q, then update q.
+                    q = (p + 1) % size;
+                    for (int i = 0; i < size; i++) {
+                        // If i is more counterclockwise than current q, then
+                        // update q
+                        if (orientation(points[p], points[i], points[q]) == 2) {
+                            q = i;
+                        }
+                    }
+
+                    // Now q is the most counterclockwise with respect to p
+                    // Set p as q for next iteration, so that q is added to
+                    // result 'hull'
+                    p = q;
+
+                } while (p != leftmost_point);        // While we don't come to first point
+
+                return hull;
+            }
+
+            /**
+             * This function returns the geometric orientation for the three points
+             * in a space, ie, whether they are linear ir clockwise or
+             * anti-clockwise
+             * @param p first point selected
+             * @param q adjacent point for q
+             * @param r adjacent point for q
+             *
+             * @returns 0 -> Linear
+             * @returns 1 -> Clock Wise
+             * @returns 2 -> Anti Clock Wise
+             */
+            static int orientation(const Point &p, const Point &q, const Point &r) {
+                int val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+
+                if (val == 0) {
+                    return 0;
+                }
+                return (val > 0) ? 1 : 2;
+            }
+
+        };
+
+    } // namespace jarvis
+} // namespace geometry
+
+/**
+ * Test function
+ * @returns void
+ */
+static void test() {
+    std::vector<geometry::jarvis::Point> points = {{0, 3},
+                                                   {2, 2},
+                                                   {1, 1},
+                                                   {2, 1},
+                                                   {3, 0},
+                                                   {0, 0},
+                                                   {3, 3}
+    };
+    geometry::jarvis::Convexhull hull(points);
+    std::vector<geometry::jarvis::Point> actualPoint;
+    actualPoint = hull.getConvexHull();
+
+    std::vector<geometry::jarvis::Point> expectedPoint = {{0, 3},
+                                                          {0, 0},
+                                                          {3, 0},
+                                                          {3, 3}};
+    for (int i = 0; i < expectedPoint.size(); i++) {
+        assert(actualPoint[i].x == expectedPoint[i].x);
+        assert(actualPoint[i].y == expectedPoint[i].y);
+    }
+    std::cout << "Test implementations passed!\n";
+}
+
+/** Driver Code */
+int main() {
+    test();
+    return 0;
+}

geometry/line_segment_intersection.cpp

@@ -0,0 +1,104 @@
+/**
+ * @file
+ * @brief check whether two line segments intersect each other
+ * or not.
+ */
+#include <algorithm>
+#include <iostream>
+
+/**
+ * Define a Point.
+ */
+struct Point {
+    int x;  /// Point respect to x coordinate
+    int y;  /// Point respect to y coordinate
+};
+
+/**
+ * intersect returns true if segments of two line intersects and
+ * false if they do not. It calls the subroutines direction
+ * which computes the orientation.
+ */
+struct SegmentIntersection {
+    inline bool intersect(Point first_point, Point second_point,
+                          Point third_point, Point forth_point) {
+        int direction1 = direction(third_point, forth_point, first_point);
+        int direction2 = direction(third_point, forth_point, second_point);
+        int direction3 = direction(first_point, second_point, third_point);
+        int direction4 = direction(first_point, second_point, forth_point);
+
+        if ((direction1 < 0 || direction2 > 0) &&
+            (direction3 < 0 || direction4 > 0))
+            return true;
+
+        else if (direction1 == 0 &&
+                 on_segment(third_point, forth_point, first_point))
+            return true;
+
+        else if (direction2 == 0 &&
+                 on_segment(third_point, forth_point, second_point))
+            return true;
+
+        else if (direction3 == 0 &&
+                 on_segment(first_point, second_point, third_point))
+            return true;
+
+        else if (direction3 == 0 &&
+                 on_segment(first_point, second_point, forth_point))
+            return true;
+
+        else
+            return false;
+    }
+
+    /**
+     * We will find direction of line here respect to @first_point.
+     * Here @second_point and @third_point is first and second points
+     * of the line respectively. we want a method to determine which way a
+     * given angle these three points turns. If returned number is negative,
+     * then the angle is counter-clockwise. That means the line is going to
+     * right to left. We will fount angle as clockwise if the method returns
+     * positive number.
+     */
+    inline int direction(Point first_point, Point second_point,
+                         Point third_point) {
+        return ((third_point.x - first_point.x) *
+                (second_point.y - first_point.y)) -
+               ((second_point.x - first_point.x) *
+                (third_point.y - first_point.y));
+    }
+
+    /**
+     * This method determines whether a point known to be colinear
+     * with a segment lies on that segment.
+     */
+    inline bool on_segment(Point first_point, Point second_point,
+                           Point third_point) {
+        if (std::min(first_point.x, second_point.x) <= third_point.x &&
+            third_point.x <= std::max(first_point.x, second_point.x) &&
+            std::min(first_point.y, second_point.y) <= third_point.y &&
+            third_point.y <= std::max(first_point.y, second_point.y))
+            return true;
+
+        else
+            return false;
+    }
+};
+
+/**
+ * This is the main function to test whether the algorithm is
+ * working well.
+ */
+int main() {
+    SegmentIntersection segment;
+    Point first_point, second_point, third_point, forth_point;
+
+    std::cin >> first_point.x >> first_point.y;
+    std::cin >> second_point.x >> second_point.y;
+    std::cin >> third_point.x >> third_point.y;
+    std::cin >> forth_point.x >> forth_point.y;
+
+    printf("%d", segment.intersect(first_point, second_point, third_point,
+                                   forth_point));
+    std::cout << std::endl;
+}