@cpp.js/package-geos 1.0.0-beta.20 → 1.0.0-beta.21

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/math/DD.h

@@ -1,199 +0,0 @@
-/**********************************************************************
- *
- * 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>
-
-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;
-
-
-    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);
-
-        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 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
-

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/namespaces.h

@@ -1,317 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2001-2002 Vivid Solutions Inc.
- * Copyright (C) 2005-2006 Refractions Research Inc.
- * Copyright (C) 2019      Nicklas Larsson
- *
- * 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.
- *
- **********************************************************************/
-
-#pragma once
-
-namespace geos {
-
-/// \brief
-/// Contains classes and interfaces implementing fundamental computational
-/// geometry algorithms.
-///
-/// ### Robustness
-///
-/// Geometrical algorithms involve a combination of combinatorial and numerical
-/// computation. As with all numerical computation using finite-precision
-/// numbers, the algorithms chosen are susceptible to problems of robustness.
-/// A robustness problem occurs when a numerical calculation produces an
-/// incorrect answer for some inputs due to round-off errors.  Robustness
-/// problems are especially serious in geometric computation, since they can
-/// result in errors during topology building.
-///
-/// There are many approaches to dealing with the problem of robustness in
-/// geometrical computation. Not surprisingly, most robust algorithms are
-/// substantially more complex and less performant than the non-robust
-/// versions. Fortunately, JTS is sensitive to robustness problems in only a
-/// few key functions (such as line intersection and the point-in-polygon
-/// test). There are efficient robust algorithms available for these
-/// functions, and these algorithms are implemented in JTS.
-///
-/// ### Computational Performance
-///
-/// Runtime performance is an important consideration for a production-quality
-/// implementation of geometric algorithms. The most computationally intensive
-/// algorithm used in JTS is intersection detection. JTS methods need to
-/// determine both all intersection between the line segments in a single
-/// Geometry (self-intersection) and all intersections between the line
-/// segments of two different Geometries.
-///
-/// The obvious naive algorithm for intersection detection (comparing every
-/// segment with every other) has unacceptably slow performance. There is a
-/// large literature of faster algorithms for intersection detection.
-/// Unfortunately, many of them involve substantial code complexity. JTS tries
-/// to balance code simplicity with performance gains. It uses some simple
-/// techniques to produce substantial performance gains for common types of
-/// input data.
-///
-/// ### Package Specification
-///
-/// - Java Topology Suite Technical Specifications
-/// - <A HREF="http://www.opengis.org/techno/specs.htm">
-///       OpenGIS Simple Features Specification for SQL</A>
-    namespace algorithm { // geos::algorithm
-
-    /// Classes to compute distance metrics between geometries.
-    namespace distance {}
-
-    /// Classes which determine the Location of points in geometries.
-    namespace locate {}
-} // namespace geos::algorithm
-
-namespace geom { // geos.geom
-
-    /// \brief
-    /// Contains classes and interfaces implementing algorithms that optimize
-    /// the performance of repeated calls to specific geometric operations.
-    namespace prep {}
-
-    /// \brief
-    /// Provides classes that parse and modify Geometry objects.
-    namespace util {}
-} // namespace geos.geom
-
-/// \brief
-/// Contains classes that implement topology graphs.
-///
-/// The Java Topology Suite (JTS) is a Java API that implements a core set of
-/// spatial data operations using an explicit precision model and robust
-/// geometric algorithms. JTS is int ended to be used in the development of
-/// applications that support the validation, cleaning, integration and
-/// querying of spatial datasets.
-///
-/// JTS attempts to implement the OpenGIS Simple Features Specification (SFS)
-/// as accurately as possible.  In some cases the SFS is unclear or omits a
-/// specification; in this case JTS attempts to choose a reasonable and
-/// consistent alternative.  Differences from and elaborations of the SFS are
-/// documented in this specification.
-///
-/// ### Package Specification
-///
-/// - Java Topology Suite Technical Specifications
-/// - <A HREF="http://www.opengis.org/techno/specs.htm">
-///   OpenGIS Simple Features Specification for SQL</A>
-namespace geomgraph { // geos.geomgraph
-
-    /// \brief
-    /// Contains classes that implement indexes for performing noding on
-    /// geometry graph edges.
-    namespace index {}
-} // namespace geos.geomgraph
-
-
-/// Provides classes for various kinds of spatial indexes.
-namespace index { // geos.index
-
-    /// Contains classes that implement a Binary Interval Tree index
-    namespace bintree {}
-
-    /// Contains classes that implement Monotone Chains
-    namespace chain {}
-
-    /// \brief Contains classes that implement a static index on a set of
-    /// 1-dimensional intervals, using an R-Tree packed based on the order of
-    /// the interval midpoints.
-    namespace intervalrtree {}
-
-    /// Contains classes that implement a Quadtree spatial index
-    namespace quadtree {}
-
-    /// \brief Contains 2-D and 1-D versions of the Sort-Tile-Recursive (STR)
-    /// tree, a query-only R-tree.
-    namespace strtree {}
-
-    /// \brief Contains classes which implement a sweepline algorithm for
-    /// scanning geometric data structures.
-    namespace sweepline {}
-} // namespace geos.index
-
-/// \brief
-/// Contains the interfaces for converting JTS objects to and from other
-/// formats.
-///
-/// The Java Topology Suite (JTS) is a Java API that implements a core set of
-/// spatial data operations usin g an explicit precision model and robust
-/// geometric algorithms. JTS is intended to be used in the devel opment of
-/// applications that support the validation, cleaning, integration and
-/// querying of spatial data sets.
-///
-/// JTS attempts to implement the OpenGIS Simple Features Specification (SFS)
-/// as accurately as possible.  In some cases the SFS is unclear or omits a
-/// specification; in this case JTS attempts to choose a reasonable and
-/// consistent alternative.  Differences from and elaborations of the SFS are
-/// documented in this specification.
-///
-/// ### Package Specification
-///
-/// - Java Topology Suite Technical Specifications
-/// - <A HREF="http://www.opengis.org/techno/specs.htm">
-///   OpenGIS Simple Features Specification for SQL</A>
-///
-namespace io {}
-
-/// \brief Contains classes and interfaces implementing linear referencing on
-/// linear geometries.
-namespace linearref {}
-
-/// \brief Classes to compute nodings for arrangements of line segments and
-/// line segment sequences.
-namespace noding { // geos.noding
-
-    /// \brief Contains classes to implement the Snap Rounding algorithm for
-    /// noding linestrings.
-    namespace snapround {}
-} // namespace geos.noding
-
-/// Provides classes for implementing operations on geometries.
-namespace operation { // geos.operation
-
-    /// Provides classes for computing buffers of geometries
-    namespace buffer {}
-
-    /// Provides classes for computing the distance between geometries.
-    namespace distance {}
-
-    /// \brief Provides classes for computing the intersection of a Geometry
-    /// and a clipping Rectangle.
-    namespace intersection {}
-
-    /// Line merging package.
-    namespace linemerge {}
-
-    /// \brief
-    /// Contains classes that perform a topological overlay to compute boolean
-    /// spatial functions.
-    ///
-    /// The Overlay Algorithm is used in spatial analysis methods for computing
-    /// set-theoretic operations (boolean combinations) of input
-    /// [Geometrys](\ref geom::Geometry).
-    /// The algorithm for computing the overlay uses the intersection operations
-    /// supported by topology graphs. To compute an overlay it is necessary to
-    /// explicitly compute the resultant graph formed by the computed
-    /// intersections.
-    ///
-    /// The algorithm to compute a set-theoretic spatial analysis method has the
-    /// following steps:
-    ///
-    /// - Build topology graphs of the two input geometries. For each geometry
-    ///   all self-intersection nodes are computed and added to the graph.
-    /// - Compute nodes for all intersections between edges and nodes of the
-    ///   graphs.
-    /// - Compute the labeling for the computed nodes by merging the labels from
-    ///   the input graphs.
-    /// - Compute new edges between the compute intersection nodes.
-    ///   Label the edges appropriately.
-    /// - Build the resultant graph from the new nodes and edges.
-    /// - Compute the labeling for isolated components of the graph. Add the
-    ///   isolated components to the resultant graph.
-    /// - Compute the result of the boolean combination by selecting the node
-    ///   and edges with the appropriate labels. Polygonize areas and sew linear
-    ///   geometries together.
-    ///
-    /// ### Package Specification
-    ///
-    /// - Java Topology Suite Technical Specifications
-    /// - <A HREF="http://www.opengis.org/techno/specs.htm">
-    ///   OpenGIS Simple Features Specification for SQL</A>
-    namespace overlay {}
-
-    /// An API for polygonizing sets of lines.
-    namespace polygonize {}
-
-    /// \brief Classes which implement topological predicates optimized for
-    /// particular kinds of geometries.
-    namespace predicate {}
-
-    /// \brief Contains classes to implement the computation of the spatial
-    /// relationships of `Geometry`s.
-    ///
-    /// The `relate` algorithm computes the `IntersectionMatrix` describing the
-    /// relationship of two `Geometry`s. The algorithm for computing `relate`
-    /// uses the intersection operations supported by topology graphs. Although
-    /// the `relate` result depends on the resultant graph formed by the
-    /// computed intersections, there is no need to explicitly compute the
-    /// entire graph. It is sufficient to compute the local structure of the
-    /// graph at each intersection node.
-    ///
-    /// The algorithm to compute `relate` has the following steps:
-    ///
-    /// - Build topology graphs of the two input geometries. For each geometry
-    ///   all self-intersection nodes are computed and added to the graph.
-    /// - Compute nodes for all intersections between edges and nodes of the
-    ///   graphs.
-    /// - Compute the labeling for the computed nodes by merging the labels
-    ///   from the input graphs.
-    /// - Compute the labeling for isolated components of the graph (see below)
-    /// - Compute the `IntersectionMatrix` from the labels on the nodes and
-    ///   edges.
-    ///
-    /// ### Labeling isolated components
-    ///
-    /// Isolated components are components (edges or nodes) of an input
-    /// `Geometry` which do not contain any intersections with the other input
-    /// `Geometry`. The topological relationship of these components to the
-    /// other input `Geometry` must be computed in order to determine the
-    /// complete labeling of the component. This can be done by testing whether
-    /// the component lies in the interior or exterior of the other `Geometry`.
-    /// If the other `Geometry` is 1-dimensional, the isolated component must
-    /// lie in the exterior (since otherwise it would have an intersection with
-    /// an edge of the `Geometry`). If the other `Geometry` is 2-dimensional,
-    /// a Point-In-Polygon test can be used to determine whether the isolated
-    /// component is in the interior or exterior.
-    ///
-    /// ### Package Specification
-    ///
-    /// - Java Topology Suite Technical Specifications
-    /// - <A HREF="http://www.opengis.org/techno/specs.htm">
-    ///    OpenGIS Simple Features Specification for SQL</A>
-    namespace relate {}
-
-    /// Find shared paths among two linear Geometry objects.
-    namespace sharedpaths {}
-
-    /// Classes to perform efficient unioning of collections of geometries.
-    namespace geounion {}
-
-    /// Provides classes for testing the validity of geometries.
-    namespace valid {}
-} // namespace geos.operation
-
-/// Contains classes to implement a planar graph data structure.
-namespace planargraph { // geos::planargraph
-
-    /// Planargraph algorithms.
-    namespace algorithm {}
-} // namespace geos::planargraph
-
-/// Provides classes for manipulating the precision model of Geometries.
-namespace precision {}
-
-/// Classes which implement algorithms for simplifying or generalizing geometries.
-namespace simplify {}
-
-/// Classes to compute Delaunay triangulations.
-namespace triangulate { // geos.triangulate
-
-    /// \brief Classes to implement a topological subdivision of quadeges, to
-    /// support creating triangulations and Voronoi diagrams.
-    namespace quadedge {}
-} // namespace geos.triangulate
-
-/// Utility classes for GEOS.
-namespace util {}
-
-} // namespace geos
-

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/noding/MCIndexSegmentSetMutualIntersector.h

@@ -1,131 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2006 Refractions Research Inc.
- *
- * 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.
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/noding/SegmentSetMutualIntersector.h> // inherited
-#include <geos/index/chain/MonotoneChainOverlapAction.h> // inherited
-#include <geos/index/chain/MonotoneChain.h> // inherited
-#include <geos/index/strtree/TemplateSTRtree.h> // inherited
-
-namespace geos {
-namespace index {
-class SpatialIndex;
-}
-namespace noding {
-class SegmentString;
-class SegmentIntersector;
-}
-}
-
-//using namespace geos::index::strtree;
-
-namespace geos {
-namespace noding { // geos::noding
-
-/** \brief
- * Intersects two sets of [SegmentStrings](@ref SegmentString) using a index based
- * on [MonotoneChains](@ref index::chain::MonotoneChain) and a
- * [SpatialIndex](@ref index::SpatialIndex).
- *
- * @version 1.7
- */
-class MCIndexSegmentSetMutualIntersector : public SegmentSetMutualIntersector {
-public:
-
-    MCIndexSegmentSetMutualIntersector(double p_tolerance)
-        : monoChains()
-        , indexCounter(0)
-        , processCounter(0)
-        , nOverlaps(0)
-        , overlapTolerance(p_tolerance)
-        , indexBuilt(false)
-    {}
-
-    MCIndexSegmentSetMutualIntersector()
-        : MCIndexSegmentSetMutualIntersector(0.0)
-    {}
-
-    ~MCIndexSegmentSetMutualIntersector() override
-    {};
-
-    index::SpatialIndex*
-    getIndex()
-    {
-        return &index;
-    }
-
-    void setBaseSegments(SegmentString::ConstVect* segStrings) override;
-
-    // NOTE: re-populates the MonotoneChain vector with newly created chains
-    void process(SegmentString::ConstVect* segStrings) override;
-
-    class SegmentOverlapAction : public index::chain::MonotoneChainOverlapAction {
-    private:
-        SegmentIntersector& si;
-
-        // Declare type as noncopyable
-        SegmentOverlapAction(const SegmentOverlapAction& other) = delete;
-        SegmentOverlapAction& operator=(const SegmentOverlapAction& rhs) = delete;
-
-    public:
-        SegmentOverlapAction(SegmentIntersector& p_si) :
-            index::chain::MonotoneChainOverlapAction(), si(p_si)
-        {}
-
-        void overlap(const index::chain::MonotoneChain& mc1, std::size_t start1,
-                     const index::chain::MonotoneChain& mc2, std::size_t start2) override;
-    };
-
-    /**
-     * Disable copy construction and assignment. Apparently needed to make this
-     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
-     */
-    MCIndexSegmentSetMutualIntersector(const MCIndexSegmentSetMutualIntersector&) = delete;
-    MCIndexSegmentSetMutualIntersector& operator=(const MCIndexSegmentSetMutualIntersector&) = delete;
-
-private:
-
-    typedef std::vector<index::chain::MonotoneChain> MonoChains;
-    MonoChains monoChains;
-
-    /*
-     * The index::SpatialIndex used should be something that supports
-     * envelope (range) queries efficiently (such as a index::quadtree::Quadtree
-     * or index::strtree::STRtree).
-     */
-    index::strtree::TemplateSTRtree<const index::chain::MonotoneChain*> index;
-    int indexCounter;
-    int processCounter;
-    // statistics
-    int nOverlaps;
-    double overlapTolerance;
-
-    /* memory management helper, holds MonotoneChain objects used
-     * in the SpatialIndex. It's cleared when the SpatialIndex is
-     */
-    bool indexBuilt;
-    MonoChains indexChains;
-
-    void addToIndex(SegmentString* segStr);
-
-    void intersectChains();
-
-    void addToMonoChains(SegmentString* segStr);
-
-};
-
-} // namespace geos::noding
-} // namespace geos
-