@crossbind/port-geos-linuxmusl 0.0.0-stage → 2.0.0-beta.64

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/linearref/LocationIndexedLine.h

@@ -0,0 +1,277 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: linearref/LocationIndexedLine.java r466
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Geometry.h>
+#include <geos/linearref/ExtractLineByLocation.h>
+#include <geos/linearref/LinearLocation.h>
+#include <geos/linearref/LocationIndexOfPoint.h>
+#include <geos/linearref/LocationIndexOfLine.h>
+#include <geos/util/IllegalArgumentException.h>
+
+namespace geos {
+namespace linearref { // geos::linearref
+
+/**
+ * \brief
+ * Supports linear referencing along a linear
+ * [Geometry](@ref geom::Geometry) using
+ * [LinearLocations](@ref LinearLocation) as the index.
+ */
+class GEOS_DLL LocationIndexedLine {
+private:
+    const geom::Geometry* linearGeom;
+
+    void
+    checkGeometryType()
+    {
+        if(!linearGeom->isLineal()) {
+            throw util::IllegalArgumentException("Input geometry must be linear");
+        }
+    }
+
+public:
+
+    /**
+     * \brief
+     * Constructs an object which allows linear referencing along
+     * a given linear [Geometry](@ref geom::Geometry).
+     *
+     * @param p_linearGeom the linear geometry to reference along
+     */
+    LocationIndexedLine(const geom::Geometry* p_linearGeom)
+        : linearGeom(p_linearGeom)
+    {
+        checkGeometryType();
+    }
+
+    /**
+     * \brief
+     * Computes the [Coordinate](@ref geom::Coordinate) for the point
+     * on the line at the given index.
+     *
+     * If the index is out of range the first or last point on the
+     * line will be returned.
+     * The Z-ordinate of the computed point will be interpolated from
+     * the Z-ordinates of the line segment containing it, if they exist.
+     *
+     * @param index the index of the desired point
+     * @return the Coordinate at the given index
+     */
+    geom::Coordinate
+    extractPoint(const LinearLocation& index) const
+    {
+        return index.getCoordinate(linearGeom);
+    }
+
+
+    /**
+     * \brief
+     * Computes the [Coordinate](@ref geom::Coordinate) for the point
+     * on the line at the given index, offset by the given distance.
+     *
+     * If the index is out of range the first or last point on the
+     * line will be returned.
+     * The computed point is offset to the left of the line if the offset
+     * distance is positive, to the right if negative.
+     *
+     * The Z-ordinate of the computed point will be interpolated from
+     * the Z-ordinates of the line segment containing it, if they exist.
+     *
+     * @param index the index of the desired point
+     * @param offsetDistance the distance the point is offset from the segment
+     *                       (positive is to the left, negative is to the right)
+     * @return the Coordinate at the given index
+     */
+    geom::Coordinate
+    extractPoint(const LinearLocation& index,
+                 double offsetDistance) const
+    {
+        geom::Coordinate ret;
+        index.getSegment(linearGeom)->pointAlongOffset(
+            index.getSegmentFraction(), offsetDistance, ret
+        );
+        return ret;
+    }
+
+    /**
+     * \brief
+     * Computes the [LineString](@ref geom::LineString) for the interval
+     * on the line between the given indices.
+     *
+     * If the endIndex lies before the startIndex,
+     * the computed geometry is reversed.
+     *
+     * @param startIndex the index of the start of the interval
+     * @param endIndex the index of the end of the interval
+     * @return the linear interval between the indices
+     */
+    std::unique_ptr<geom::Geometry>
+    extractLine(const LinearLocation& startIndex,
+                const LinearLocation& endIndex) const
+    {
+        return ExtractLineByLocation::extract(linearGeom, startIndex, endIndex);
+    }
+
+
+    /**
+     * \brief
+     * Computes the index for a given point on the line.
+     *
+     * The supplied point does not <i>necessarily</i> have to lie precisely
+     * on the line, but if it is far from the line the accuracy and
+     * performance of this function is not guaranteed.
+     * Use {@link #project} to compute a guaranteed result for points
+     * which may be far from the line.
+     *
+     * @param pt a point on the line
+     * @return the index of the point
+     *
+     * @see project
+     */
+    LinearLocation
+    indexOf(const geom::Coordinate& pt) const
+    {
+        return LocationIndexOfPoint::indexOf(linearGeom, pt);
+    }
+
+    /**
+     * \brief
+     * Finds the index for a point on the line
+     * which is greater than the given index.
+     *
+     * If no such index exists, returns <tt>minIndex</tt>.
+     * This method can be used to determine all indexes for
+     * a point which occurs more than once on a non-simple line.
+     * It can also be used to disambiguate cases where the given point lies
+     * slightly off the line and is equidistant from two different
+     * points on the line.
+     *
+     * The supplied point does not <i>necessarily</i> have to lie precisely
+     * on the line, but if it is far from the line the accuracy and
+     * performance of this function is not guaranteed.
+     * Use {@link #project} to compute a guaranteed result for points
+     * which may be far from the line.
+     *
+     * @param pt a point on the line
+     * @param minIndex the value the returned index must be greater than
+     * @return the index of the point greater than the given minimum index
+     *
+     * @see project
+     */
+    LinearLocation
+    indexOfAfter(const geom::Coordinate& pt,
+                 const LinearLocation& minIndex) const
+    {
+        return LocationIndexOfPoint::indexOfAfter(linearGeom, pt, &minIndex);
+    }
+
+    /**
+     * \brief
+     * Computes the indices for a subline of the line.
+     *
+     * (The subline must <b>conform</b> to the line; that is,
+     * all vertices in the subline (except possibly the first and last)
+     * must be vertices of the line and occur in the same order).
+     *
+     * @param subLine a subLine of the line
+     * @return a pair of indices for the start and end of the subline.
+     */
+    LinearLocation*
+    indicesOf(const geom::Geometry* subLine) const
+    {
+        return LocationIndexOfLine::indicesOf(linearGeom, subLine);
+    }
+
+
+    /**
+     * \brief
+     * Computes the index for the closest point on the line to the given point.
+     *
+     * If more than one point has the closest distance the first one along
+     * the line is returned.
+     * (The point does not necessarily have to lie precisely on the line.)
+     *
+     * @param pt a point on the line
+     * @return the index of the point
+     */
+    LinearLocation
+    project(const geom::Coordinate& pt) const
+    {
+        return LocationIndexOfPoint::indexOf(linearGeom, pt);
+    }
+
+    /**
+     * \brief
+     * Returns the index of the start of the line
+     *
+     * @return the start index
+     */
+    LinearLocation
+    getStartIndex() const
+    {
+        return LinearLocation();
+    }
+
+    /**
+     * \brief
+     * Returns the index of the end of the line
+     *
+     * @return the end index
+     */
+    LinearLocation
+    getEndIndex() const
+    {
+        return LinearLocation::getEndLocation(linearGeom);
+    }
+
+    /**
+     * \brief
+     * Tests whether an index is in the valid index range for the line.
+     *
+     * @param index the index to test
+     * @return `true` if the index is in the valid range
+     */
+    bool
+    isValidIndex(const LinearLocation& index) const
+    {
+        return index.isValid(linearGeom);
+    }
+
+
+    /**
+     * \brief
+     * Computes a valid index for this line
+     * by clamping the given index to the valid range of index values
+     *
+     * @return a valid index value
+     */
+    LinearLocation
+    clampIndex(const LinearLocation& index) const
+    {
+        LinearLocation loc = index;
+        loc.clamp(linearGeom);
+        return loc;
+    }
+};
+
+} // geos::linearref
+} // geos

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/math/DD.h

@@ -0,0 +1,203 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 Crunchy Data
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************/
+
+/**
+ * Implements extended-precision floating-point numbers
+ * which maintain 106 bits (approximately 30 decimal digits) of precision.
+ * <p>
+ * A DoubleDouble uses a representation containing two double-precision values.
+ * A number x is represented as a pair of doubles, x.hi and x.lo,
+ * such that the number represented by x is x.hi + x.lo, where
+ * <pre>
+ *    |x.lo| &lt;= 0.5*ulp(x.hi)
+ * </pre>
+ * and ulp(y) means "unit in the last place of y".
+ * The basic arithmetic operations are implemented using
+ * convenient properties of IEEE-754 floating-point arithmetic.
+ * <p>
+ * The range of values which can be represented is the same as in IEEE-754.
+ * The precision of the representable numbers
+ * is twice as great as IEEE-754 double precision.
+ * <p>
+ * The correctness of the arithmetic algorithms relies on operations
+ * being performed with standard IEEE-754 double precision and rounding.
+ * This is the Java standard arithmetic model, but for performance reasons
+ * Java implementations are not
+ * constrained to using this standard by default.
+ * Some processors (notably the Intel Pentium architecture) perform
+ * floating point operations in (non-IEEE-754-standard) extended-precision.
+ * A JVM implementation may choose to use the non-standard extended-precision
+ * as its default arithmetic mode.
+ * To prevent this from happening, this code uses the
+ * Java <tt>strictfp</tt> modifier,
+ * which forces all operations to take place in the standard IEEE-754 rounding model.
+ * <p>
+ * The API provides both a set of value-oriented operations
+ * and a set of mutating operations.
+ * Value-oriented operations treat DoubleDouble values as
+ * immutable; operations on them return new objects carrying the result
+ * of the operation.  This provides a simple and safe semantics for
+ * writing DoubleDouble expressions.  However, there is a performance
+ * penalty for the object allocations required.
+ * The mutable interface updates object values in-place.
+ * It provides optimum memory performance, but requires
+ * care to ensure that aliasing errors are not created
+ * and constant values are not changed.
+ * <p>
+ * For example, the following code example constructs three DD instances:
+ * two to hold the input values and one to hold the result of the addition.
+ * <pre>
+ *     DD a = new DD(2.0);
+ *     DD b = new DD(3.0);
+ *     DD c = a.add(b);
+ * </pre>
+ * In contrast, the following approach uses only one object:
+ * <pre>
+ *     DD a = new DD(2.0);
+ *     a.selfAdd(3.0);
+ * </pre>
+ * <p>
+ * This implementation uses algorithms originally designed variously by
+ * Knuth, Kahan, Dekker, and Linnainmaa.
+ * Douglas Priest developed the first C implementation of these techniques.
+ * Other more recent C++ implementation are due to Keith M. Briggs and David Bailey et al.
+ *
+ * <h3>References</h3>
+ * <ul>
+ * <li>Priest, D., <i>Algorithms for Arbitrary Precision Floating Point Arithmetic</i>,
+ * in P. Kornerup and D. Matula, Eds., Proc. 10th Symposium on Computer Arithmetic,
+ * IEEE Computer Society Press, Los Alamitos, Calif., 1991.
+ * <li>Yozo Hida, Xiaoye S. Li and David H. Bailey,
+ * <i>Quad-Double Arithmetic: Algorithms, Implementation, and Application</i>,
+ * manuscript, Oct 2000; Lawrence Berkeley National Laboratory Report BNL-46996.
+ * <li>David Bailey, <i>High Precision Software Directory</i>;
+ * <tt>http://crd.lbl.gov/~dhbailey/mpdist/index.html</tt>
+ * </ul>
+ *
+ *
+ * @author Martin Davis
+ *
+ */
+
+#pragma once
+
+#include <cmath>
+#include <geos/export.h>
+
+namespace geos {
+namespace math { // geos.math
+
+/**
+ * \class DD
+ *
+ * \brief
+ * Wrapper for DoubleDouble higher precision mathematics
+ * operations.
+ */
+class GEOS_DLL DD {
+    private:
+        static constexpr double SPLIT = 134217729.0; // 2^27+1, for IEEE double
+        double hi;
+        double lo;
+
+        int signum() const;
+        DD rint() const;
+
+        void setNaN();
+
+    public:
+        DD(double p_hi, double p_lo) : hi(p_hi), lo(p_lo) {};
+        DD(double x) : hi(x), lo(0.0) {};
+        DD() : hi(0.0), lo(0.0) {};
+
+        bool operator==(const DD &rhs) const
+        {
+            return hi == rhs.hi && lo == rhs.lo;
+        }
+
+        bool operator!=(const DD &rhs) const
+        {
+            return hi != rhs.hi || lo != rhs.lo;
+        }
+
+        bool operator<(const DD &rhs) const
+        {
+            return (hi < rhs.hi) || (hi == rhs.hi && lo < rhs.lo);
+        }
+
+        bool operator<=(const DD &rhs) const
+        {
+            return (hi < rhs.hi) || (hi == rhs.hi && lo <= rhs.lo);
+        }
+
+        bool operator>(const DD &rhs) const
+        {
+            return (hi > rhs.hi) || (hi == rhs.hi && lo > rhs.lo);
+        }
+
+        bool operator>=(const DD &rhs) const
+        {
+            return (hi > rhs.hi) || (hi == rhs.hi && lo >= rhs.lo);
+        }
+
+        friend GEOS_DLL DD operator+ (const DD &lhs, const DD &rhs);
+        friend GEOS_DLL DD operator+ (const DD &lhs, double rhs);
+        friend GEOS_DLL DD operator- (const DD &lhs, const DD &rhs);
+        friend GEOS_DLL DD operator- (const DD &lhs, double rhs);
+        friend GEOS_DLL DD operator* (const DD &lhs, const DD &rhs);
+        friend GEOS_DLL DD operator* (const DD &lhs, double rhs);
+        friend GEOS_DLL DD operator/ (const DD &lhs, const DD &rhs);
+        friend GEOS_DLL DD operator/ (const DD &lhs, double rhs);
+        friend GEOS_DLL DD operator- (const DD& x);
+
+        static DD determinant(const DD &x1, const DD &y1, const DD &x2, const DD &y2);
+        static DD determinant(double x1, double y1, double x2, double y2);
+        static DD abs(const DD &d);
+        static DD pow(const DD &d, int exp);
+        static DD trunc(const DD &d);
+
+        bool isInf() const;
+        bool isNaN() const;
+        bool isNegative() const;
+        bool isPositive() const;
+        bool isZero() const;
+        double doubleValue() const;
+        double ToDouble() const { return doubleValue(); }
+        int intValue() const;
+        DD negate() const;
+        DD reciprocal() const;
+        DD floor() const;
+        DD ceil() const;
+
+        void selfAdd(const DD &d);
+        void selfAdd(double p_hi, double p_lo);
+        void selfAdd(double y);
+
+        void selfSubtract(const DD &d);
+        void selfSubtract(double p_hi, double p_lo);
+        void selfSubtract(double y);
+
+        void selfMultiply(double p_hi, double p_lo);
+        void selfMultiply(const DD &d);
+        void selfMultiply(double y);
+
+        void selfDivide(double p_hi, double p_lo);
+        void selfDivide(const DD &d);
+        void selfDivide(double y);
+};
+
+
+} // namespace geos::math
+} // namespace geos
+