update boost

linx64/include/boost/geometry/strategy/cartesian/area.hpp

@@ -0,0 +1,144 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2016-2020.
+// Modifications copyright (c) 2016-2020, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_AREA_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_AREA_HPP
+
+
+//#include <boost/geometry/arithmetic/determinant.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/strategy/area.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace area
+{
+
+/*!
+\brief Cartesian area calculation
+\ingroup strategies
+\details Calculates cartesian area using the trapezoidal rule
+\tparam CalculationType \tparam_calculation
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.area.area_2_with_strategy area (with strategy)]
+}
+
+*/
+template
+<
+    typename CalculationType = void
+>
+class cartesian
+{
+public :
+    template <typename Geometry>
+    struct result_type
+        : strategy::area::detail::result_type
+            <
+                Geometry,
+                CalculationType
+            >
+    {};
+
+    template <typename Geometry>
+    class state
+    {
+        friend class cartesian;
+
+        typedef typename result_type<Geometry>::type return_type;
+
+    public:
+        inline state()
+            : sum(0)
+        {
+            // Strategy supports only 2D areas
+            assert_dimension<Geometry, 2>();
+        }
+
+    private:
+        inline return_type area() const
+        {
+            return_type const two = 2;
+            return sum / two;
+        }
+
+        return_type sum;
+    };
+
+    template <typename PointOfSegment, typename Geometry>
+    static inline void apply(PointOfSegment const& p1,
+                             PointOfSegment const& p2,
+                             state<Geometry>& st)
+    {
+        typedef typename state<Geometry>::return_type return_type;
+
+        // Below formulas are equivalent, however the two lower ones
+        // suffer less from accuracy loss for great values of coordinates.
+        // See: https://svn.boost.org/trac/boost/ticket/11928
+
+        // SUM += x2 * y1 - x1 * y2;
+        // state.sum += detail::determinant<return_type>(p2, p1);
+
+        // SUM += (x2 - x1) * (y2 + y1)
+        //state.sum += (return_type(get<0>(p2)) - return_type(get<0>(p1)))
+        //           * (return_type(get<1>(p2)) + return_type(get<1>(p1)));
+
+        // SUM += (x1 + x2) * (y1 - y2)
+        st.sum += (return_type(get<0>(p1)) + return_type(get<0>(p2)))
+                * (return_type(get<1>(p1)) - return_type(get<1>(p2)));
+    }
+
+    template <typename Geometry>
+    static inline auto result(state<Geometry>& st)
+    {
+        return st.area();
+    }
+
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+    template <>
+    struct default_strategy<cartesian_tag>
+    {
+        typedef strategy::area::cartesian<> type;
+    };
+
+} // namespace services
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::area
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_AREA_HPP

linx64/include/boost/geometry/strategy/cartesian/area_box.hpp

@@ -0,0 +1,57 @@
+// Boost.Geometry
+
+// Copyright (c) 2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_AREA_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_AREA_BOX_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/strategy/area.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace area
+{
+
+template
+<
+    typename CalculationType = void
+>
+class cartesian_box
+{
+public:
+    template <typename Box>
+    struct result_type
+        : strategy::area::detail::result_type
+            <
+                Box,
+                CalculationType
+            >
+    {};
+
+    template <typename Box>
+    static inline auto apply(Box const& box)
+    {
+        typedef typename result_type<Box>::type return_type;
+
+        return return_type(get<max_corner, 0>(box) - get<min_corner, 0>(box))
+             * return_type(get<max_corner, 1>(box) - get<min_corner, 1>(box));
+    }
+};
+
+
+}} // namespace strategy::area
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_AREA_BOX_HPP

linx64/include/boost/geometry/strategy/cartesian/envelope.hpp

@@ -0,0 +1,120 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015-2020.
+// Modifications copyright (c) 2015-2020, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_HPP
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+#include <boost/geometry/algorithms/detail/envelope/initialize.hpp>
+
+#include <boost/geometry/strategy/cartesian/envelope_box.hpp>
+#include <boost/geometry/strategy/cartesian/envelope_segment.hpp>
+#include <boost/geometry/strategy/cartesian/expand_box.hpp>
+#include <boost/geometry/strategy/cartesian/expand_segment.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace envelope
+{
+
+template <typename CalculationType = void>
+class cartesian
+{
+public:
+    typedef cartesian_tag cs_tag;
+
+    // Linestring, Ring, Polygon
+
+    template <typename Range>
+    static inline typename boost::range_iterator<Range const>::type begin(Range const& range)
+    {
+        return boost::begin(range);
+    }
+
+    template <typename Range>
+    static inline typename boost::range_iterator<Range const>::type end(Range const& range)
+    {
+        return boost::end(range);
+    }
+
+    // MultiLinestring, MultiPolygon
+
+    template <typename Box>
+    struct multi_state
+    {
+        multi_state()
+            : m_initialized(false)
+        {}
+
+        void apply(Box const& single_box)
+        {
+            if (! m_initialized)
+            {
+                m_box = single_box;
+                m_initialized = true;
+            }
+            else
+            {
+                strategy::expand::cartesian_box::apply(m_box, single_box);
+            }
+        }
+
+        void result(Box & box)
+        {
+            if (m_initialized)
+            {
+                box = m_box;
+            }
+            else
+            {
+                geometry::detail::envelope::initialize<Box, 0, dimension<Box>::value>::apply(box);
+            }
+        }
+
+    private:
+        bool m_initialized;
+        Box m_box;
+    };
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename Tag, typename CalculationType>
+struct default_strategy<Tag, cartesian_tag, CalculationType>
+{
+    typedef strategy::envelope::cartesian<CalculationType> type;
+};
+
+} // namespace services
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::envelope
+
+}} //namepsace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_HPP

linx64/include/boost/geometry/strategy/cartesian/envelope_box.hpp

@@ -0,0 +1,123 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015-2020.
+// Modifications copyright (c) 2015-2020, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_BOX_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/views/detail/indexed_point_view.hpp>
+
+#include <boost/geometry/algorithms/detail/convert_point_to_point.hpp>
+#include <boost/geometry/algorithms/detail/normalize.hpp>
+#include <boost/geometry/algorithms/detail/envelope/transform_units.hpp>
+
+#include <boost/geometry/algorithms/dispatch/envelope.hpp>
+
+#include <boost/geometry/strategy/cartesian/expand_box.hpp>
+
+#include <boost/geometry/strategy/envelope.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace envelope
+{
+
+
+template
+<
+    std::size_t Index,
+    std::size_t Dimension,
+    std::size_t DimensionCount
+>
+struct envelope_indexed_box
+{
+    template <typename BoxIn, typename BoxOut>
+    static inline void apply(BoxIn const& box_in, BoxOut& mbr)
+    {
+        detail::indexed_point_view<BoxIn const, Index> box_in_corner(box_in);
+        detail::indexed_point_view<BoxOut, Index> mbr_corner(mbr);
+
+        detail::conversion::point_to_point
+            <
+                detail::indexed_point_view<BoxIn const, Index>,
+                detail::indexed_point_view<BoxOut, Index>,
+                Dimension,
+                DimensionCount
+            >::apply(box_in_corner, mbr_corner);
+    }
+};
+
+
+}} // namespace detail::envelope
+#endif // DOXYGEN_NO_DETAIL
+
+
+namespace strategy { namespace envelope
+{
+
+
+struct cartesian_box
+{
+    typedef cartesian_tag cs_tag;
+
+    template<typename BoxIn, typename BoxOut>
+    static inline void apply(BoxIn const& box_in, BoxOut& mbr)
+    {
+        geometry::detail::envelope::envelope_indexed_box
+            <
+                min_corner, 0, dimension<BoxIn>::value
+            >::apply(box_in, mbr);
+
+        geometry::detail::envelope::envelope_indexed_box
+            <
+                max_corner, 0, dimension<BoxIn>::value
+            >::apply(box_in, mbr);
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<box_tag, cartesian_tag, CalculationType>
+{
+    typedef strategy::envelope::cartesian_box type;
+};
+
+}
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::envelope
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_BOX_HPP

linx64/include/boost/geometry/strategy/cartesian/envelope_boxes.hpp

@@ -0,0 +1,66 @@
+// Boost.Geometry
+
+// Copyright (c) 2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_BOXES_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_BOXES_HPP
+
+#include <boost/geometry/algorithms/detail/envelope/initialize.hpp>
+#include <boost/geometry/strategy/cartesian/expand_box.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace envelope
+{
+
+class cartesian_boxes
+{
+public:
+    template <typename Box>
+    class state
+    {
+        friend cartesian_boxes;
+
+        Box m_box;
+        bool m_initialized = false;
+    };
+
+    template <typename Box>
+    static void apply(state<Box> & st, Box const& box)
+    {
+        if (! st.m_initialized)
+        {
+            st.m_box = box;
+            st.m_initialized = true;
+        }
+        else
+        {
+            strategy::expand::cartesian_box::apply(st.m_box, box);
+        }
+    }
+
+    template <typename Box>
+    static void result(state<Box> const& st, Box & box)
+    {
+        if (st.m_initialized)
+        {
+            box = st.m_box;
+        }
+        else
+        {
+            geometry::detail::envelope::initialize<Box, 0, dimension<Box>::value>::apply(box);
+        }
+    }
+};
+
+}} // namespace strategy::envelope
+
+}} //namepsace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_BOXES_HPP

linx64/include/boost/geometry/strategy/cartesian/envelope_multipoint.hpp

@@ -0,0 +1,83 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2018-2020, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_MULTIPOINT_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_MULTIPOINT_HPP
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/envelope/initialize.hpp>
+
+#include <boost/geometry/strategy/cartesian/envelope.hpp>
+#include <boost/geometry/strategy/cartesian/envelope_point.hpp>
+#include <boost/geometry/strategy/cartesian/expand_point.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace envelope
+{
+
+class cartesian_multipoint
+{
+public:
+    template <typename MultiPoint, typename Box>
+    static inline void apply(MultiPoint const& multipoint, Box& mbr)
+    {
+        apply(boost::begin(multipoint), boost::end(multipoint), mbr);
+    }
+
+private:
+    template <typename Iterator, typename Box>
+    static inline void apply(Iterator it,
+                             Iterator last,
+                             Box& mbr)
+    {
+        geometry::detail::envelope::initialize<Box, 0, dimension<Box>::value>::apply(mbr);
+
+        if (it != last)
+        {
+            strategy::envelope::cartesian_point::apply(*it, mbr);
+
+            for (++it; it != last; ++it)
+            {
+                strategy::expand::cartesian_point::apply(mbr, *it);
+            }
+        }
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<multi_point_tag, cartesian_tag, CalculationType>
+{
+    typedef strategy::envelope::cartesian_multipoint type;
+};
+
+
+} // namespace services
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::envelope
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_MULTIPOINT_HPP

linx64/include/boost/geometry/strategy/cartesian/envelope_point.hpp

@@ -0,0 +1,111 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015, 2016, 2017, 2018.
+// Modifications copyright (c) 2015-2018, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_POINT_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_POINT_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/views/detail/indexed_point_view.hpp>
+
+#include <boost/geometry/algorithms/detail/convert_point_to_point.hpp>
+
+#include <boost/geometry/strategy/envelope.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace envelope
+{
+
+template <std::size_t Dimension, std::size_t DimensionCount>
+struct envelope_one_point
+{
+    template <std::size_t Index, typename Point, typename Box>
+    static inline void apply(Point const& point, Box& mbr)
+    {
+        detail::indexed_point_view<Box, Index> box_corner(mbr);
+        detail::conversion::point_to_point
+            <
+                Point,
+                detail::indexed_point_view<Box, Index>,
+                Dimension,
+                DimensionCount
+            >::apply(point, box_corner);
+    }
+
+    template <typename Point, typename Box>
+    static inline void apply(Point const& point, Box& mbr)
+    {
+        apply<min_corner>(point, mbr);
+        apply<max_corner>(point, mbr);
+    }
+};
+
+
+}} // namespace detail::envelope
+#endif // DOXYGEN_NO_DETAIL
+
+
+namespace strategy { namespace envelope
+{
+
+struct cartesian_point
+{
+    template <typename Point, typename Box>
+    static inline void apply(Point const& point, Box& mbr)
+    {
+        geometry::detail::envelope::envelope_one_point
+            <
+                0, dimension<Point>::value
+            >::apply(point, mbr);
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<point_tag, cartesian_tag, CalculationType>
+{
+    typedef strategy::envelope::cartesian_point type;
+};
+
+
+}
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::envelope
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_POINT_HPP

linx64/include/boost/geometry/strategy/cartesian/envelope_range.hpp

@@ -0,0 +1,56 @@
+// Boost.Geometry
+
+// Copyright (c) 2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_RANGE_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_RANGE_HPP
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+#include <boost/geometry/algorithms/detail/envelope/initialize.hpp>
+#include <boost/geometry/strategy/cartesian/envelope_point.hpp>
+#include <boost/geometry/strategy/cartesian/expand_point.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace envelope
+{
+
+class cartesian_range
+{
+public:
+    template <typename Range, typename Box>
+    static inline void apply(Range const& range, Box& mbr)
+    {
+        auto it = boost::begin(range);
+        auto const end = boost::end(range);
+        if (it == end)
+        {
+            // initialize box (assign inverse)
+            geometry::detail::envelope::initialize<Box>::apply(mbr);
+            return;
+        }
+
+        // initialize box with the first point
+        envelope::cartesian_point::apply(*it, mbr);
+
+        // consider now the remaining points in the range (if any)
+        for (++it; it != end; ++it)
+        {
+            expand::cartesian_point::apply(mbr, *it);
+        }
+    }
+};
+
+}} // namespace strategy::envelope
+
+}} //namepsace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_RANGE_HPP

linx64/include/boost/geometry/strategy/cartesian/envelope_segment.hpp

@@ -0,0 +1,93 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2017-2018 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_SEGMENT_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_SEGMENT_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/strategy/cartesian/envelope_point.hpp>
+#include <boost/geometry/strategy/cartesian/expand_point.hpp>
+#include <boost/geometry/strategy/envelope.hpp>
+
+namespace boost { namespace geometry { namespace strategy { namespace envelope
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <std::size_t Dimension, std::size_t DimensionCount>
+struct envelope_one_segment
+{
+    template<typename Point, typename Box>
+    static inline void apply(Point const& p1,
+                             Point const& p2,
+                             Box& mbr)
+    {
+        geometry::detail::envelope::envelope_one_point
+            <
+                Dimension, DimensionCount
+            >::apply(p1, mbr);
+
+        strategy::expand::detail::point_loop
+            <
+                Dimension, DimensionCount
+            >::apply(mbr, p2);
+    }
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+template
+<
+    typename CalculationType = void
+>
+class cartesian_segment
+{
+public:
+    template <typename Point, typename Box>
+    static inline void apply(Point const& point1, Point const& point2, Box& box)
+    {
+        strategy::envelope::detail::envelope_one_segment
+            <
+                0,
+                dimension<Point>::value
+            >::apply(point1, point2, box);
+    }
+
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<segment_tag, cartesian_tag, CalculationType>
+{
+    typedef strategy::envelope::cartesian_segment<CalculationType> type;
+};
+
+}
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::envelope
+
+}} //namepsace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_ENVELOPE_SEGMENT_HPP

linx64/include/boost/geometry/strategy/cartesian/expand_box.hpp

@@ -0,0 +1,69 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015, 2016, 2017.
+// Modifications copyright (c) 2015-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_EXPAND_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_EXPAND_BOX_HPP
+
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/expand/indexed.hpp>
+
+#include <boost/geometry/strategy/expand.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace expand
+{
+
+struct cartesian_box
+{
+    template <typename BoxOut, typename BoxIn>
+    static void apply(BoxOut & box_out, BoxIn const& box_in)
+    {
+        geometry::detail::expand::expand_indexed
+            <
+                0, dimension<BoxIn>::value
+            >::apply(box_out, box_in);
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<box_tag, cartesian_tag, CalculationType>
+{
+    typedef cartesian_box type;
+};
+
+
+} // namespace services
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::expand
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_EXPAND_BOX_HPP

linx64/include/boost/geometry/strategy/cartesian/expand_point.hpp

@@ -0,0 +1,125 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015-2018.
+// Modifications copyright (c) 2015-2018, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_EXPAND_POINT_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_EXPAND_POINT_HPP
+
+#include <cstddef>
+#include <functional>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+#include <boost/geometry/strategy/expand.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace expand
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <std::size_t Dimension, std::size_t DimensionCount>
+struct point_loop
+{
+    template <typename Box, typename Point>
+    static inline void apply(Box& box, Point const& source)
+    {
+        typedef typename select_coordinate_type
+            <
+                Point, Box
+            >::type coordinate_type;
+
+        std::less<coordinate_type> less;
+        std::greater<coordinate_type> greater;
+
+        coordinate_type const coord = get<Dimension>(source);
+
+        if (less(coord, get<min_corner, Dimension>(box)))
+        {
+            set<min_corner, Dimension>(box, coord);
+        }
+
+        if (greater(coord, get<max_corner, Dimension>(box)))
+        {
+            set<max_corner, Dimension>(box, coord);
+        }
+
+        point_loop<Dimension + 1, DimensionCount>::apply(box, source);
+    }
+};
+
+
+template <std::size_t DimensionCount>
+struct point_loop<DimensionCount, DimensionCount>
+{
+    template <typename Box, typename Point>
+    static inline void apply(Box&, Point const&) {}
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+struct cartesian_point
+{
+    template <typename Box, typename Point>
+    static void apply(Box & box, Point const& point)
+    {
+        expand::detail::point_loop
+            <
+                0, dimension<Point>::value
+            >::apply(box, point);
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<point_tag, cartesian_tag, CalculationType>
+{
+    typedef cartesian_point type;
+};
+
+
+} // namespace services
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::expand
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_EXPAND_POINT_HPP

linx64/include/boost/geometry/strategy/cartesian/expand_segment.hpp

@@ -0,0 +1,71 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015, 2016, 2017, 2018.
+// Modifications copyright (c) 2015-2018, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_EXPAND_SEGMENT_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_EXPAND_SEGMENT_HPP
+
+
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/expand/indexed.hpp>
+
+#include <boost/geometry/strategy/expand.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace expand
+{
+
+class cartesian_segment
+{
+public:
+    template <typename Box, typename Segment>
+    static void apply(Box & box, Segment const& segment)
+    {
+        geometry::detail::expand::expand_indexed
+            <
+                0, dimension<Segment>::value
+            >::apply(box, segment);
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<segment_tag, cartesian_tag, CalculationType>
+{
+    typedef cartesian_segment type;
+};
+
+
+} // namespace services
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::expand
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_EXPAND_SEGMENT_HPP

linx64/include/boost/geometry/strategy/cartesian/in_circle_robust.hpp

@@ -0,0 +1,64 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2019 Tinko Bartels, Berlin, Germany.
+
+// Contributed and/or modified by Tinko Bartels,
+//   as part of Google Summer of Code 2019 program.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_IN_CIRCLE_ROBUST_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_IN_CIRCLE_ROBUST_HPP
+
+#include<boost/geometry/util/precise_math.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace in_circle
+{
+
+/*!
+\brief Adaptive precision predicate to check whether a fourth point lies inside the circumcircle of the first three points:
+    inside (>0), outside (< 0), on the boundary (0).
+\ingroup strategies
+\tparam CalculationType \tparam_calculation (numeric_limits<ct>::epsilon() and numeric_limits<ct>::digits must be supported for calculation type ct)
+\tparam Robustness std::size_t value from 0 (fastest) to 2 (default, most precise).
+\details This predicate determines whether a fourth point lies inside the circumcircle of the first three points using an algorithm that is adapted from incircle as described in "Adaptive Precision Floating-Point Arithmetic and Fast Robust Geometric Predicates" by Jonathan Richard Shewchuk ( https://dl.acm.org/citation.cfm?doid=237218.237337 ). More information and copies of the paper can also be found at https://www.cs.cmu.edu/~quake/robust.html . It is designed to be adaptive in the sense that it should be fast for inputs that lead to correct results with plain float operations but robust for inputs that require higher precision arithmetics.
+ */
+template <typename CalculationType = double, std::size_t Robustness = 2>
+class in_circle_robust
+{
+public:
+    template <typename P1, typename P2, typename P3, typename P>
+    static inline int apply(P1 const& p1, P2 const& p2, P3 const& p3, P const& p)
+    {
+        std::array<CalculationType, 2> pa {
+            { boost::geometry::get<0>(p1), boost::geometry::get<1>(p1) }};
+        std::array<CalculationType, 2> pb {
+            { boost::geometry::get<0>(p2), boost::geometry::get<1>(p2) }};
+        std::array<CalculationType, 2> pc {
+            { boost::geometry::get<0>(p3), boost::geometry::get<1>(p3) }};
+        std::array<CalculationType, 2> pd {
+            { boost::geometry::get<0>(p), boost::geometry::get<1>(p) }};
+        CalculationType det =
+            boost::geometry::detail::precise_math::incircle
+                <
+                    CalculationType,
+                    Robustness
+                >(pa, pb, pc, pd);
+        return det > 0 ? 1
+                       : det < 0 ? -1 : 0;
+    }
+
+};
+
+} // namespace in_circle
+
+} // namespace strategy
+
+}} // namespace boost::geometry::strategy
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_IN_CIRCLE_ROBUST_HPP

linx64/include/boost/geometry/strategy/cartesian/precise_area.hpp

@@ -0,0 +1,117 @@
+// Boost.Geometry
+
+// Copyright (c) 2020, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_PRECISE_AREA_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_PRECISE_AREA_HPP
+
+#include <boost/mpl/if.hpp>
+
+//#include <boost/geometry/arithmetic/determinant.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/strategy/area.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+#include <boost/geometry/util/precise_math.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace area
+{
+
+/*!
+\brief Cartesian area calculation
+\ingroup strategies
+\details Calculates cartesian area using the trapezoidal rule and precise
+         summation (useful to increase precision with floating point arithmetic)
+\tparam CalculationType \tparam_calculation
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.area.area_2_with_strategy area (with strategy)]
+}
+
+*/
+template
+<
+    typename CalculationType = void
+>
+class precise_cartesian
+{
+public :
+    template <typename Geometry>
+    struct result_type
+        : strategy::area::detail::result_type
+            <
+                Geometry,
+                CalculationType
+            >
+    {};
+
+    template <typename Geometry>
+    class state
+    {
+        friend class precise_cartesian;
+
+        typedef typename result_type<Geometry>::type return_type;
+
+    public:
+        inline state()
+            : sum1(0)
+            , sum2(0)
+        {
+            // Strategy supports only 2D areas
+            assert_dimension<Geometry, 2>();
+        }
+
+    private:
+        inline return_type area() const
+        {
+            return_type const two = 2;
+            return (sum1 + sum2) / two;
+        }
+
+        return_type sum1;
+        return_type sum2;
+    };
+
+    template <typename PointOfSegment, typename Geometry>
+    static inline void apply(PointOfSegment const& p1,
+                             PointOfSegment const& p2,
+                             state<Geometry>& st)
+    {
+        typedef typename state<Geometry>::return_type return_type;
+
+        auto const det = (return_type(get<0>(p1)) + return_type(get<0>(p2)))
+                * (return_type(get<1>(p1)) - return_type(get<1>(p2)));
+
+        auto const res = boost::geometry::detail::precise_math::two_sum(st.sum1, det);
+
+        st.sum1 = res[0];
+        st.sum2 += res[1];
+    }
+
+    template <typename Geometry>
+    static inline auto result(state<Geometry>& st)
+    {
+        return st.area();
+    }
+
+};
+
+
+}} // namespace strategy::area
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_PRECISE_AREA_HPP

linx64/include/boost/geometry/strategy/cartesian/side_by_triangle.hpp

@@ -0,0 +1,258 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015-2023.
+// Modifications copyright (c) 2015-2023, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_SIDE_BY_TRIANGLE_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_SIDE_BY_TRIANGLE_HPP
+
+
+#include <type_traits>
+
+#include <boost/geometry/core/config.hpp>
+#include <boost/geometry/arithmetic/determinant.hpp>
+
+#include <boost/geometry/core/access.hpp>
+
+#include <boost/geometry/strategies/cartesian/point_in_point.hpp>
+#include <boost/geometry/strategies/compare.hpp>
+#include <boost/geometry/strategies/side.hpp>
+
+#include <boost/geometry/util/select_calculation_type.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace side
+{
+
+/*!
+\brief Check at which side of a segment a point lies:
+    left of segment (> 0), right of segment (< 0), on segment (0)
+\ingroup strategies
+\tparam CalculationType \tparam_calculation
+ */
+template <typename CalculationType = void>
+class side_by_triangle
+{
+    template <typename Policy>
+    struct eps_policy
+    {
+        eps_policy() {}
+        template <typename Type>
+        eps_policy(Type const& a, Type const& b, Type const& c, Type const& d)
+            : policy(a, b, c, d)
+        {}
+        Policy policy;
+    };
+
+    struct eps_empty
+    {
+        eps_empty() {}
+        template <typename Type>
+        eps_empty(Type const&, Type const&, Type const&, Type const&) {}
+    };
+
+public :
+    using cs_tag = cartesian_tag;
+
+    // Template member function, because it is not always trivial
+    // or convenient to explicitly mention the typenames in the
+    // strategy-struct itself.
+
+    // Types can be all three different. Therefore it is
+    // not implemented (anymore) as "segment"
+
+    template
+    <
+        typename CoordinateType,
+        typename PromotedType,
+        typename P1,
+        typename P2,
+        typename P,
+        typename EpsPolicy
+    >
+    static inline
+    PromotedType side_value(P1 const& p1, P2 const& p2, P const& p, EpsPolicy & eps_policy)
+    {
+        CoordinateType const x = get<0>(p);
+        CoordinateType const y = get<1>(p);
+
+        CoordinateType const sx1 = get<0>(p1);
+        CoordinateType const sy1 = get<1>(p1);
+        CoordinateType const sx2 = get<0>(p2);
+        CoordinateType const sy2 = get<1>(p2);
+
+        PromotedType const dx = sx2 - sx1;
+        PromotedType const dy = sy2 - sy1;
+        PromotedType const dpx = x - sx1;
+        PromotedType const dpy = y - sy1;
+
+        eps_policy = EpsPolicy(dx, dy, dpx, dpy);
+
+        return geometry::detail::determinant<PromotedType>
+                (
+                    dx, dy,
+                    dpx, dpy
+                );
+
+    }
+
+    template
+    <
+        typename CoordinateType,
+        typename PromotedType,
+        typename P1,
+        typename P2,
+        typename P
+    >
+    static inline
+    PromotedType side_value(P1 const& p1, P2 const& p2, P const& p)
+    {
+        eps_empty dummy;
+        return side_value<CoordinateType, PromotedType>(p1, p2, p, dummy);
+    }
+
+
+    template
+    <
+        typename CoordinateType,
+        typename PromotedType,
+        bool AreAllIntegralCoordinates
+    >
+    struct compute_side_value
+    {
+        template <typename P1, typename P2, typename P, typename EpsPolicy>
+        static inline PromotedType apply(P1 const& p1, P2 const& p2, P const& p, EpsPolicy & epsp)
+        {
+            return side_value<CoordinateType, PromotedType>(p1, p2, p, epsp);
+        }
+    };
+
+    template <typename CoordinateType, typename PromotedType>
+    struct compute_side_value<CoordinateType, PromotedType, false>
+    {
+        template <typename P1, typename P2, typename P, typename EpsPolicy>
+        static inline PromotedType apply(P1 const& p1, P2 const& p2, P const& p, EpsPolicy & epsp)
+        {
+            // For robustness purposes, first check if any two points are
+            // the same; in this case simply return that the points are
+            // collinear
+            if (equals_point_point(p1, p2)
+                || equals_point_point(p1, p)
+                || equals_point_point(p2, p))
+            {
+                return PromotedType(0);
+            }
+
+            // The side_by_triangle strategy computes the signed area of
+            // the point triplet (p1, p2, p); as such it is (in theory)
+            // invariant under cyclic permutations of its three arguments.
+            //
+            // In the context of numerical errors that arise in
+            // floating-point computations, and in order to make the strategy
+            // consistent with respect to cyclic permutations of its three
+            // arguments, we cyclically permute them so that the first
+            // argument is always the lexicographically smallest point.
+
+            using less = compare::cartesian<compare::less, compare::equals_epsilon>;
+
+            if (less::apply(p, p1))
+            {
+                if (less::apply(p, p2))
+                {
+                    // p is the lexicographically smallest
+                    return side_value<CoordinateType, PromotedType>(p, p1, p2, epsp);
+                }
+                else
+                {
+                    // p2 is the lexicographically smallest
+                    return side_value<CoordinateType, PromotedType>(p2, p, p1, epsp);
+                }
+            }
+
+            if (less::apply(p1, p2))
+            {
+                // p1 is the lexicographically smallest
+                return side_value<CoordinateType, PromotedType>(p1, p2, p, epsp);
+            }
+            else
+            {
+                // p2 is the lexicographically smallest
+                return side_value<CoordinateType, PromotedType>(p2, p, p1, epsp);
+            }
+        }
+    };
+
+
+    template <typename P1, typename P2, typename P>
+    static inline int apply(P1 const& p1, P2 const& p2, P const& p)
+    {
+        using coor_t = typename select_calculation_type_alt<CalculationType, P1, P2, P>::type;
+
+        // Promote float->double, small int->int
+        using promoted_t = typename select_most_precise<coor_t, double>::type;
+
+        bool const are_all_integral_coordinates =
+            std::is_integral<typename coordinate_type<P1>::type>::value
+            && std::is_integral<typename coordinate_type<P2>::type>::value
+            && std::is_integral<typename coordinate_type<P>::type>::value;
+
+        eps_policy< math::detail::equals_factor_policy<promoted_t> > epsp;
+        promoted_t s = compute_side_value
+            <
+                coor_t, promoted_t, are_all_integral_coordinates
+            >::apply(p1, p2, p, epsp);
+
+        promoted_t const zero = promoted_t();
+        return math::detail::equals_by_policy(s, zero, epsp.policy) ? 0
+            : s > zero ? 1
+            : -1;
+    }
+
+private:
+    template <typename P1, typename P2>
+    static inline bool equals_point_point(P1 const& p1, P2 const& p2)
+    {
+        return strategy::within::cartesian_point_point::apply(p1, p2);
+    }
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<cartesian_tag, CalculationType>
+{
+    using type = side_by_triangle<CalculationType>;
+};
+
+}
+
+#endif
+
+}} // namespace strategy::side
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_SIDE_BY_TRIANGLE_HPP

linx64/include/boost/geometry/strategy/cartesian/side_non_robust.hpp

@@ -0,0 +1,99 @@
+// Boost.Geometry
+
+// Copyright (c) 2020-2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_SIDE_NON_ROBUST_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_SIDE_NON_ROBUST_HPP
+
+#include <boost/geometry/util/select_most_precise.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+#include <boost/geometry/util/precise_math.hpp>
+
+#include <boost/geometry/arithmetic/determinant.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace side
+{
+
+/*!
+\brief Predicate to check at which side of a segment a point lies:
+    left of segment (>0), right of segment (< 0), on segment (0).
+\ingroup strategies
+\tparam CalculationType \tparam_calculation
+\details This predicate determines at which side of a segment a point lies
+*/
+template
+<
+    typename CalculationType = void
+>
+struct side_non_robust
+{
+public:
+    //! \brief Computes double the signed area of the CCW triangle p1, p2, p
+    template
+    <
+        typename P1,
+        typename P2,
+        typename P
+    >
+    static inline int apply(P1 const& p1, P2 const& p2, P const& p)
+    {
+        typedef typename select_calculation_type_alt
+            <
+                CalculationType,
+                P1,
+                P2,
+                P
+            >::type CoordinateType;
+        typedef typename select_most_precise
+            <
+                CoordinateType,
+                double
+            >::type PromotedType;
+
+        CoordinateType const x = get<0>(p);
+        CoordinateType const y = get<1>(p);
+
+        CoordinateType const sx1 = get<0>(p1);
+        CoordinateType const sy1 = get<1>(p1);
+        CoordinateType const sx2 = get<0>(p2);
+        CoordinateType const sy2 = get<1>(p2);
+
+        //non-robust 1
+        //the following is 2x slower in some generic cases when compiled with g++
+        //(tested versions 9 and 10)
+        //
+        //auto detleft = (sx1 - x) * (sy2 - y);
+        //auto detright = (sy1 - y) * (sx2 - x);
+        //return detleft > detright ? 1 : (detleft < detright ? -1 : 0 );
+
+        //non-robust 2
+        PromotedType const dx = sx2 - sx1;
+        PromotedType const dy = sy2 - sy1;
+        PromotedType const dpx = x - sx1;
+        PromotedType const dpy = y - sy1;
+
+        PromotedType sv = geometry::detail::determinant<PromotedType>
+                (
+                    dx, dy,
+                    dpx, dpy
+                );
+        PromotedType const zero = PromotedType();
+
+        return sv == zero ? 0 : sv > zero ? 1 : -1;
+    }
+
+};
+
+}} // namespace strategy::side
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_SIDE_NON_ROBUST_HPP

linx64/include/boost/geometry/strategy/cartesian/side_robust.hpp

@@ -0,0 +1,185 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2019 Tinko Bartels, Berlin, Germany.
+
+// Contributed and/or modified by Tinko Bartels,
+//   as part of Google Summer of Code 2019 program.
+
+// This file was modified by Oracle on 2021.
+// Modifications copyright (c) 2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_CARTESIAN_SIDE_ROBUST_HPP
+#define BOOST_GEOMETRY_STRATEGY_CARTESIAN_SIDE_ROBUST_HPP
+
+#include <boost/geometry/core/config.hpp>
+#include <boost/geometry/strategy/cartesian/side_non_robust.hpp>
+
+#include <boost/geometry/strategies/side.hpp>
+
+#include <boost/geometry/util/select_most_precise.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+#include <boost/geometry/util/precise_math.hpp>
+#include <boost/geometry/util/math.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace side
+{
+
+struct epsilon_equals_policy
+{
+public:
+    template <typename Policy, typename T1, typename T2>
+    static bool apply(T1 const& a, T2 const& b, Policy const& policy)
+    {
+        return boost::geometry::math::detail::equals_by_policy(a, b, policy);
+    }
+};
+
+struct fp_equals_policy
+{
+public:
+    template <typename Policy, typename T1, typename T2>
+    static bool apply(T1 const& a, T2 const& b, Policy const&)
+    {
+        return a == b;
+    }
+};
+
+
+/*!
+\brief Adaptive precision predicate to check at which side of a segment a point lies:
+    left of segment (>0), right of segment (< 0), on segment (0).
+\ingroup strategies
+\tparam CalculationType \tparam_calculation (numeric_limits<ct>::epsilon() and numeric_limits<ct>::digits must be supported for calculation type ct)
+\tparam Robustness std::size_t value from 0 (fastest) to 3 (default, guarantees correct results).
+\details This predicate determines at which side of a segment a point lies using an algorithm that is adapted from orient2d as described in "Adaptive Precision Floating-Point Arithmetic and Fast Robust Geometric Predicates" by Jonathan Richard Shewchuk ( https://dl.acm.org/citation.cfm?doid=237218.237337 ). More information and copies of the paper can also be found at https://www.cs.cmu.edu/~quake/robust.html . It is designed to be adaptive in the sense that it should be fast for inputs that lead to correct results with plain float operations but robust for inputs that require higher precision arithmetics.
+ */
+template
+<
+    typename CalculationType = void,
+    typename EqualsPolicy = epsilon_equals_policy,
+    std::size_t Robustness = 3
+>
+struct side_robust
+{
+
+    template <typename CT>
+    struct epsilon_policy
+    {
+        using Policy = boost::geometry::math::detail::equals_factor_policy<CT>;
+
+        epsilon_policy() {}
+
+        template <typename Type>
+        epsilon_policy(Type const& a, Type const& b, Type const& c, Type const& d)
+            : m_policy(a, b, c, d)
+        {}
+        Policy m_policy;
+
+    public:
+
+        template <typename T1, typename T2>
+        bool apply(T1 a, T2 b) const
+        {
+            return EqualsPolicy::apply(a, b, m_policy);
+        }
+    };
+
+public:
+
+    typedef cartesian_tag cs_tag;
+
+    //! \brief Computes the sign of the CCW triangle p1, p2, p
+    template
+    <
+        typename PromotedType,
+        typename P1,
+        typename P2,
+        typename P,
+        typename EpsPolicyInternal,
+        std::enable_if_t<std::is_fundamental<PromotedType>::value, int> = 0
+    >
+    static inline PromotedType side_value(P1 const& p1,
+                                          P2 const& p2,
+                                          P const& p,
+                                          EpsPolicyInternal& eps_policy)
+    {
+        using vec2d = ::boost::geometry::detail::precise_math::vec2d<PromotedType>;
+        vec2d pa;
+        pa.x = get<0>(p1);
+        pa.y = get<1>(p1);
+        vec2d pb;
+        pb.x = get<0>(p2);
+        pb.y = get<1>(p2);
+        vec2d pc;
+        pc.x = get<0>(p);
+        pc.y = get<1>(p);
+        return ::boost::geometry::detail::precise_math::orient2d
+            <PromotedType, Robustness>(pa, pb, pc, eps_policy);
+    }
+
+    template
+    <
+        typename PromotedType,
+        typename P1,
+        typename P2,
+        typename P,
+        typename EpsPolicyInternal,
+        std::enable_if_t<!std::is_fundamental<PromotedType>::value, int> = 0
+    >
+    static inline auto side_value(P1 const& p1, P2 const& p2, P const& p,
+                                  EpsPolicyInternal&)
+    {
+        return side_non_robust<>::apply(p1, p2, p);
+    }
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+    template
+    <
+        typename P1,
+        typename P2,
+        typename P
+    >
+    static inline int apply(P1 const& p1, P2 const& p2, P const& p)
+    {
+        using coordinate_type = typename select_calculation_type_alt
+            <
+                CalculationType,
+                P1,
+                P2,
+                P
+            >::type;
+
+        using promoted_type = typename select_most_precise
+            <
+                coordinate_type,
+                double
+            >::type;
+
+        epsilon_policy<promoted_type> epsp;
+        promoted_type sv = side_value<promoted_type>(p1, p2, p, epsp);
+        promoted_type const zero = promoted_type();
+
+        return epsp.apply(sv, zero) ? 0
+            : sv > zero ? 1
+            : -1;
+    }
+
+#endif
+
+};
+
+}} // namespace strategy::side
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGY_CARTESIAN_SIDE_ROBUST_HPP