Merge remote-tracking branch 'origin/master' into oxidize_cucumber

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Unreleased
   - Changes from 5.27.1
     - Features
+      - REMOVED: Remove all core-CH left-overs [#6920](https://github.com/Project-OSRM/osrm-backend/pull/6920)
       - ADDED: Add support for a keepalive_timeout flag. [#6674](https://github.com/Project-OSRM/osrm-backend/pull/6674)
       - ADDED: Add support for a default_radius flag. [#6575](https://github.com/Project-OSRM/osrm-backend/pull/6575)
       - ADDED: Add support for disabling feature datasets. [#6666](https://github.com/Project-OSRM/osrm-backend/pull/6666)
@@ -22,6 +23,10 @@
     - NodeJS:
       - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
     - Misc:
+      - CHANGED: Use custom struct instead of std::pair in QueryHeap. [#6921](https://github.com/Project-OSRM/osrm-backend/pull/6921)
+      - CHANGED: Use std::string_view::starts_with instead of boost::starts_with. [#6918](https://github.com/Project-OSRM/osrm-backend/pull/6918)
+      - CHANGED: Get rid of boost::math::constants::* and M_PI in favor of std::numbers. [#6916](https://github.com/Project-OSRM/osrm-backend/pull/6916)
+      - CHANGED: Make constants in PackedVector constexpr. [#6917](https://github.com/Project-OSRM/osrm-backend/pull/6917)
       - CHANGED: Use std::variant instead of mapbox::util::variant. [#6903](https://github.com/Project-OSRM/osrm-backend/pull/6903)
       - CHANGED: Bump rapidjson to version f9d53419e912910fd8fa57d5705fa41425428c35 [#6906](https://github.com/Project-OSRM/osrm-backend/pull/6906)
       - CHANGED: Bump mapbox/variant to version 1.2.0 [#6898](https://github.com/Project-OSRM/osrm-backend/pull/6898)

CMakeLists.txt

@@ -266,7 +266,6 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
   add_dependency_defines(-DBOOST_LIB_DIAGNOSTIC)
   add_dependency_defines(-D_CRT_SECURE_NO_WARNINGS)
   add_dependency_defines(-DNOMINMAX) # avoid min and max macros that can break compilation
-  add_dependency_defines(-D_USE_MATH_DEFINES) #needed for M_PI with cmath.h
   add_dependency_defines(-D_WIN32_WINNT=0x0501)
   add_dependency_defines(-DXML_STATIC)
   find_library(ws2_32_LIBRARY_PATH ws2_32)

docs/nodejs/api.md

@@ -21,7 +21,7 @@ var osrm = new OSRM('network.osrm');
 **Parameters**
 
 -   `options` **([Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object) \| [String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String))** Options for creating an OSRM object or string to the `.osrm` file. (optional, default `{shared_memory:true}`)
-    -   `options.algorithm` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', 'CoreCH' or 'MLD'. Default is 'CH'.
+    -   `options.algorithm` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', or 'MLD'. Default is 'CH'.
                Make sure you prepared the dataset with the correct toolchain.
     -   `options.shared_memory` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Connects to the persistent shared memory datastore.
                This requires you to run `osrm-datastore` prior to creating an `OSRM` object.

include/engine/engine_config.hpp

@@ -54,14 +54,10 @@ namespace osrm::engine
  *
  * In addition, shared memory can be used for datasets loaded with osrm-datastore.
  *
- * You can chose between three algorithms:
+ * You can chose between two algorithms:
  *  - Algorithm::CH
  *      Contraction Hierarchies, extremely fast queries but slow pre-processing. The default right
  * now.
- *  - Algorithm::CoreCH
- *      Deprecated, to be removed in v6.0
- *      Contraction Hierachies with partial contraction for faster pre-processing but slower
- * queries.
  *  - Algorithm::MLD
  *      Multi Level Dijkstra, moderately fast in both pre-processing and query.
  *
@@ -74,7 +70,6 @@ struct EngineConfig final
     enum class Algorithm
     {
         CH,
-        CoreCH, // Deprecated, will be removed in v6.0
         MLD
     };
 

include/engine/map_matching/bayes_classifier.hpp

@@ -6,7 +6,7 @@
 #include <utility>
 #include <vector>
 
-#include <boost/math/constants/constants.hpp>
+#include <numbers>
 
 namespace osrm::engine::map_matching
 {
@@ -21,10 +21,8 @@ struct NormalDistribution
     // FIXME implement log-probability version since it's faster
     double Density(const double val) const
     {
-        using namespace boost::math::constants;
-
         const double x = val - mean;
-        return 1.0 / (std::sqrt(two_pi<double>()) * standard_deviation) *
+        return 1.0 / (std::sqrt(2 * std::numbers::pi) * standard_deviation) *
                std::exp(-x * x / (standard_deviation * standard_deviation));
     }
 

include/engine/map_matching/hidden_markov_model.hpp

@@ -4,7 +4,7 @@
 #include "util/integer_range.hpp"
 
 #include <boost/assert.hpp>
-#include <boost/math/constants/constants.hpp>
+#include <numbers>
 
 #include <cmath>
 
@@ -14,7 +14,7 @@
 namespace osrm::engine::map_matching
 {
 
-static const double log_2_pi = std::log(2. * boost::math::constants::pi<double>());
+static const double log_2_pi = std::log(2. * std::numbers::pi);
 static const double IMPOSSIBLE_LOG_PROB = -std::numeric_limits<double>::infinity();
 static const double MINIMAL_LOG_PROB = std::numeric_limits<double>::lowest();
 static const std::size_t INVALID_STATE = std::numeric_limits<std::size_t>::max();

include/engine/map_matching/matching_confidence.hpp

@@ -2,7 +2,7 @@
 #define ENGINE_MAP_MATCHING_CONFIDENCE_HPP
 
 #include "engine/map_matching/bayes_classifier.hpp"
-
+#include <boost/assert.hpp>
 #include <cmath>
 
 namespace osrm::engine::map_matching

include/engine/search_engine_data.hpp

@@ -12,7 +12,6 @@ namespace osrm::engine
 
 // Algorithm-dependent heaps
 // - CH algorithms use CH heaps
-// - CoreCH algorithms use CH
 // - MLD algorithms use MLD heaps
 
 template <typename Algorithm> struct SearchEngineData

include/nodejs/node_osrm_support.hpp

@@ -296,24 +296,19 @@ inline engine_config_ptr argumentsToEngineConfig(const Napi::CallbackInfo &args)
         {
             engine_config->algorithm = osrm::EngineConfig::Algorithm::CH;
         }
-        else if (algorithm_str == "CoreCH")
-        {
-            engine_config->algorithm = osrm::EngineConfig::Algorithm::CH;
-        }
         else if (algorithm_str == "MLD")
         {
             engine_config->algorithm = osrm::EngineConfig::Algorithm::MLD;
         }
         else
         {
-            ThrowError(args.Env(), "algorithm option must be one of 'CH', 'CoreCH', or 'MLD'.");
+            ThrowError(args.Env(), "algorithm option must be one of 'CH', or 'MLD'.");
             return engine_config_ptr();
         }
     }
     else if (!algorithm.IsUndefined())
     {
-        ThrowError(args.Env(),
+        ThrowError(args.Env(), "algorithm option must be a string and one of 'CH', or 'MLD'.");
-                   "algorithm option must be a string and one of 'CH', 'CoreCH', or 'MLD'.");
         return engine_config_ptr();
     }
 

include/util/cheap_ruler.hpp

@@ -4,6 +4,7 @@
 #include <cmath>
 #include <cstdint>
 #include <limits>
+#include <numbers>
 #include <tuple>
 #include <utility>
 
@@ -37,7 +38,7 @@ class CheapRuler
     static constexpr double FE = 1.0 / 298.257223563; // flattening
 
     static constexpr double E2 = FE * (2 - FE);
-    static constexpr double RAD = M_PI / 180.0;
+    static constexpr double RAD = std::numbers::pi / 180.0;
 
   public:
     explicit CheapRuler(double latitude)

include/util/coordinate_calculation.hpp

@@ -3,7 +3,7 @@
 
 #include "util/coordinate.hpp"
 
-#include <boost/math/constants/constants.hpp>
+#include <numbers>
 
 #include <algorithm>
 #include <cmath>
@@ -23,17 +23,9 @@ const constexpr double RAD_TO_DEGREE = 1. / DEGREE_TO_RAD;
 // The IUGG value for the equatorial radius is 6378.137 km (3963.19 miles)
 const constexpr long double EARTH_RADIUS = 6372797.560856;
 
-inline double degToRad(const double degree)
+inline double degToRad(const double degree) { return degree * (std::numbers::pi / 180.0); }
-{
-    using namespace boost::math::constants;
-    return degree * (pi<double>() / 180.0);
-}
 
-inline double radToDeg(const double radian)
+inline double radToDeg(const double radian) { return radian * (180.0 * std::numbers::inv_pi); }
-{
-    using namespace boost::math::constants;
-    return radian * (180.0 * (1. / pi<double>()));
-}
 } // namespace detail
 
 const constexpr static double METERS_PER_DEGREE_LAT = 110567.0;

include/util/guidance/name_announcements.hpp

@@ -8,8 +8,6 @@
 
 #include "util/typedefs.hpp"
 
-#include <boost/algorithm/string.hpp>
-
 #include <algorithm>
 #include <string>
 #include <tuple>
@@ -126,8 +124,7 @@ inline bool requiresNameAnnounced(const StringView &from_name,
 
     // check similarity of names
     const auto names_are_empty = from_name.empty() && to_name.empty();
-    const auto name_is_contained =
+    const auto name_is_contained = from_name.starts_with(to_name) || to_name.starts_with(from_name);
-        boost::starts_with(from_name, to_name) || boost::starts_with(to_name, from_name);
 
     const auto checkForPrefixOrSuffixChange = [](const std::string_view first,
                                                  const std::string_view second,

include/util/packed_vector.hpp

@@ -153,8 +153,7 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
     // number of words per block
     static constexpr std::size_t BLOCK_WORDS = (Bits * BLOCK_ELEMENTS) / WORD_BITS;
 
-    // C++14 does not allow operator[] to be constexpr, this is fixed in C++17.
+    static constexpr std::array<WordT, BLOCK_ELEMENTS> initialize_lower_mask()
-    static /* constexpr */ std::array<WordT, BLOCK_ELEMENTS> initialize_lower_mask()
     {
         std::array<WordT, BLOCK_ELEMENTS> lower_mask;
 
@@ -170,7 +169,7 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
         return lower_mask;
     }
 
-    static /* constexpr */ std::array<WordT, BLOCK_ELEMENTS> initialize_upper_mask()
+    static constexpr std::array<WordT, BLOCK_ELEMENTS> initialize_upper_mask()
     {
         std::array<WordT, BLOCK_ELEMENTS> upper_mask;
 
@@ -194,7 +193,7 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
         return upper_mask;
     }
 
-    static /* constexpr */ std::array<std::uint8_t, BLOCK_ELEMENTS> initialize_lower_offset()
+    static constexpr std::array<std::uint8_t, BLOCK_ELEMENTS> initialize_lower_offset()
     {
         std::array<std::uint8_t, WORD_BITS> lower_offset;
 
@@ -209,7 +208,7 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
         return lower_offset;
     }
 
-    static /* constexpr */ std::array<std::uint8_t, BLOCK_ELEMENTS> initialize_upper_offset()
+    static constexpr std::array<std::uint8_t, BLOCK_ELEMENTS> initialize_upper_offset()
     {
         std::array<std::uint8_t, BLOCK_ELEMENTS> upper_offset;
 
@@ -232,7 +231,7 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
         return upper_offset;
     }
 
-    static /* constexpr */ std::array<std::uint8_t, BLOCK_ELEMENTS> initialize_word_offset()
+    static constexpr std::array<std::uint8_t, BLOCK_ELEMENTS> initialize_word_offset()
     {
         std::array<std::uint8_t, BLOCK_ELEMENTS> word_offset;
 
@@ -246,28 +245,15 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
         return word_offset;
     }
 
-    // For now we need to call these on object creation
-    void initialize()
-    {
-        lower_mask = initialize_lower_mask();
-        upper_mask = initialize_upper_mask();
-        lower_offset = initialize_lower_offset();
-        upper_offset = initialize_upper_offset();
-        word_offset = initialize_word_offset();
-    }
-
     // mask for the lower/upper word of a record
-    // TODO: With C++17 these could be constexpr
+    static constexpr std::array<WordT, BLOCK_ELEMENTS> lower_mask = initialize_lower_mask();
-    /* static constexpr */ std::array<WordT, BLOCK_ELEMENTS>
+    static constexpr std::array<WordT, BLOCK_ELEMENTS> upper_mask = initialize_upper_mask();
-        lower_mask /* = initialize_lower_mask()*/;
+    static constexpr std::array<std::uint8_t, BLOCK_ELEMENTS> lower_offset =
-    /* static constexpr */ std::array<WordT, BLOCK_ELEMENTS>
+        initialize_lower_offset();
-        upper_mask /* = initialize_upper_mask()*/;
+    static constexpr std::array<std::uint8_t, BLOCK_ELEMENTS> upper_offset =
-    /* static constexpr */ std::array<std::uint8_t, BLOCK_ELEMENTS>
+        initialize_upper_offset();
-        lower_offset /* = initialize_lower_offset()*/;
-    /* static constexpr */ std::array<std::uint8_t, BLOCK_ELEMENTS>
-        upper_offset /* = initialize_upper_offset()*/;
     // in which word of the block is the element
-    /* static constexpr */ std::array<std::uint8_t, BLOCK_ELEMENTS> word_offset =
+    static constexpr std::array<std::uint8_t, BLOCK_ELEMENTS> word_offset =
         initialize_word_offset();
 
     struct InternalIndex
@@ -378,27 +364,21 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
 
     PackedVector(std::initializer_list<T> list)
     {
-        initialize();
         reserve(list.size());
         for (const auto value : list)
             push_back(value);
     }
 
-    PackedVector() { initialize(); };
+    PackedVector(){};
     PackedVector(const PackedVector &) = default;
     PackedVector(PackedVector &&) = default;
     PackedVector &operator=(const PackedVector &) = default;
     PackedVector &operator=(PackedVector &&) = default;
 
-    PackedVector(std::size_t size)
+    PackedVector(std::size_t size) { resize(size); }
-    {
-        initialize();
-        resize(size);
-    }
 
     PackedVector(std::size_t size, T initial_value)
     {
-        initialize();
         resize(size);
         fill(initial_value);
     }
@@ -406,7 +386,6 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
     PackedVector(util::ViewOrVector<WordT, Ownership> vec_, std::size_t num_elements)
         : vec(std::move(vec_)), num_elements(num_elements)
     {
-        initialize();
     }
 
     // forces the efficient read-only lookup

include/util/query_heap.hpp

@@ -193,7 +193,20 @@ template <typename NodeID,
 class QueryHeap
 {
   private:
-    using HeapData = std::pair<Weight, Key>;
+    struct HeapData
+    {
+        Weight weight;
+        Key index;
+
+        bool operator>(const HeapData &other) const
+        {
+            if (weight == other.weight)
+            {
+                return index > other.index;
+            }
+            return weight > other.weight;
+        }
+    };
     using HeapContainer = boost::heap::d_ary_heap<HeapData,
                                                   boost::heap::arity<4>,
                                                   boost::heap::mutable_<true>,
@@ -232,7 +245,7 @@ class QueryHeap
     {
         BOOST_ASSERT(node < std::numeric_limits<NodeID>::max());
         const auto index = static_cast<Key>(inserted_nodes.size());
-        const auto handle = heap.push(std::make_pair(weight, index));
+        const auto handle = heap.emplace(HeapData{weight, index});
         inserted_nodes.emplace_back(HeapNode{handle, node, weight, data});
         node_index[node] = index;
     }
@@ -315,19 +328,19 @@ class QueryHeap
     NodeID Min() const
     {
         BOOST_ASSERT(!heap.empty());
-        return inserted_nodes[heap.top().second].node;
+        return inserted_nodes[heap.top().index].node;
     }
 
     Weight MinKey() const
     {
         BOOST_ASSERT(!heap.empty());
-        return heap.top().first;
+        return heap.top().weight;
     }
 
     NodeID DeleteMin()
     {
         BOOST_ASSERT(!heap.empty());
-        const Key removedIndex = heap.top().second;
+        const Key removedIndex = heap.top().index;
         heap.pop();
         inserted_nodes[removedIndex].handle = heap.s_handle_from_iterator(heap.end());
         return inserted_nodes[removedIndex].node;
@@ -336,7 +349,7 @@ class QueryHeap
     HeapNode &DeleteMinGetHeapNode()
     {
         BOOST_ASSERT(!heap.empty());
-        const Key removedIndex = heap.top().second;
+        const Key removedIndex = heap.top().index;
         heap.pop();
         inserted_nodes[removedIndex].handle = heap.s_handle_from_iterator(heap.end());
         return inserted_nodes[removedIndex];
@@ -357,13 +370,13 @@ class QueryHeap
         const auto index = node_index.peek_index(node);
         auto &reference = inserted_nodes[index];
         reference.weight = weight;
-        heap.increase(reference.handle, std::make_pair(weight, index));
+        heap.increase(reference.handle, HeapData{weight, static_cast<Key>(index)});
     }
 
     void DecreaseKey(const HeapNode &heapNode)
     {
         BOOST_ASSERT(!WasRemoved(heapNode.node));
-        heap.increase(heapNode.handle, std::make_pair(heapNode.weight, (*heapNode.handle).second));
+        heap.increase(heapNode.handle, HeapData{heapNode.weight, (*heapNode.handle).index});
     }
 
   private:

include/util/trigonometry_table.hpp

@@ -6,7 +6,7 @@
 
 #include <limits>
 
-#include <boost/math/constants/constants.hpp>
+#include <numbers>
 
 namespace osrm::util
 {
@@ -356,25 +356,21 @@ constexpr unsigned short atan_table[4096] = {
     0xffe0, 0xffea, 0xfff4, 0xffff};
 
 // max value is pi/4
-#ifdef _MSC_VER // TODO: remove as soon as boost allows C++14 features with Visual Studio
+const constexpr double SCALING_FACTOR = 4. * std::numbers::inv_pi * 0xFFFF;
-const constexpr double SCALING_FACTOR = 4. / M_PI * 0xFFFF;
-#else
-const constexpr double SCALING_FACTOR = 4. / boost::math::constants::pi<double>() * 0xFFFF;
-#endif
 
 inline double atan2_lookup(double y, double x)
 {
-    using namespace boost::math::constants;
+    static constexpr auto half_pi = std::numbers::pi * 0.5;
 
     if (std::abs(x) < std::numeric_limits<double>::epsilon())
     {
         if (y >= 0.)
         {
-            return half_pi<double>();
+            return half_pi;
         }
         else
         {
-            return -half_pi<double>();
+            return -half_pi;
         }
     }
 
@@ -405,25 +401,25 @@ inline double atan2_lookup(double y, double x)
     case 0:
         break;
     case 1:
-        angle = pi<double>() - angle;
+        angle = std::numbers::pi - angle;
         break;
     case 2:
         angle = -angle;
         break;
     case 3:
-        angle = -pi<double>() + angle;
+        angle = -std::numbers::pi + angle;
         break;
     case 4:
-        angle = half_pi<double>() - angle;
+        angle = half_pi - angle;
         break;
     case 5:
-        angle = half_pi<double>() + angle;
+        angle = half_pi + angle;
         break;
     case 6:
-        angle = -half_pi<double>() + angle;
+        angle = -half_pi + angle;
         break;
     case 7:
-        angle = -half_pi<double>() - angle;
+        angle = -half_pi - angle;
         break;
     }
     return angle;

include/util/web_mercator.hpp

@@ -3,7 +3,7 @@
 
 #include "util/coordinate.hpp"
 
-#include <boost/math/constants/constants.hpp>
+#include <numbers>
 
 namespace osrm::util::web_mercator
 {
@@ -14,7 +14,7 @@ const constexpr double RAD_TO_DEGREE = 1. / DEGREE_TO_RAD;
 // radius used by WGS84
 const constexpr double EARTH_RADIUS_WGS84 = 6378137.0;
 // earth circumference devided by 2
-const constexpr double MAXEXTENT = EARTH_RADIUS_WGS84 * boost::math::constants::pi<double>();
+const constexpr double MAXEXTENT = EARTH_RADIUS_WGS84 * std::numbers::pi;
 // ^ math functions are not constexpr since they have side-effects (setting errno) :(
 const constexpr double EPSG3857_MAX_LATITUDE = 85.051128779806592378; // 90(4*atan(exp(pi))/pi-1)
 const constexpr double MAX_LONGITUDE = 180.0;
@@ -103,8 +103,8 @@ inline void pixelToDegree(const double shift, double &x, double &y)
     const double b = shift / 2.0;
     x = (x - b) / shift * 360.0;
     // FIXME needs to be simplified
-    const double g = (y - b) / -(shift / (2 * M_PI)) / detail::DEGREE_TO_RAD;
+    const double g = (y - b) / -(shift * 0.5 * std::numbers::inv_pi) / detail::DEGREE_TO_RAD;
-    static_assert(detail::DEGREE_TO_RAD / (2 * M_PI) - 1 / 360. < 0.0001, "");
+    static_assert(detail::DEGREE_TO_RAD * 0.5 * std::numbers::inv_pi - 1 / 360. < 0.0001, "");
     y = static_cast<double>(yToLat(g));
 }
 

scripts/ci/windows-build.bat

@@ -58,7 +58,6 @@ IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
 SET test_region=monaco
 SET test_region_ch=ch\monaco
-SET test_region_corech=corech\monaco
 SET test_region_mld=mld\monaco
 SET test_osm=%test_region%.osm.pbf
 COPY %PROJECT_DIR%\test\data\%test_region%.osm.pbf %test_osm% 
@@ -68,18 +67,13 @@ IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 MKDIR ch
 XCOPY %test_region%.osrm.* ch\
 XCOPY %test_region%.osrm ch\
-MKDIR corech
-XCOPY %test_region%.osrm.* corech\
-XCOPY %test_region%.osrm corech\
 MKDIR mld
 XCOPY %test_region%.osrm.* mld\
 XCOPY %test_region%.osrm mld\
 %CONFIGURATION%\osrm-contract.exe %test_region_ch%.osrm
-%CONFIGURATION%\osrm-contract.exe --core 0.8 %test_region_corech%.osrm
 %CONFIGURATION%\osrm-partition.exe %test_region_mld%.osrm
 %CONFIGURATION%\osrm-customize.exe %test_region_mld%.osrm
 XCOPY /Y ch\*.* ..\test\data\ch\
-XCOPY /Y corech\*.* ..\test\data\corech\
 XCOPY /Y mld\*.* ..\test\data\mld\
 unit_tests\%CONFIGURATION%\library-tests.exe
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR

src/extractor/intersection/intersection_analysis.cpp

@@ -6,6 +6,7 @@
 #include "util/coordinate_calculation.hpp"
 
 #include <boost/optional/optional_io.hpp>
+#include <numbers>
 
 namespace osrm::extractor::intersection
 {
@@ -79,11 +80,11 @@ namespace
 {
 double findAngleBisector(double alpha, double beta)
 {
-    alpha *= M_PI / 180.;
+    alpha *= std::numbers::pi / 180.;
-    beta *= M_PI / 180.;
+    beta *= std::numbers::pi / 180.;
     const auto average =
-        180. * std::atan2(std::sin(alpha) + std::sin(beta), std::cos(alpha) + std::cos(beta)) /
+        180. * std::atan2(std::sin(alpha) + std::sin(beta), std::cos(alpha) + std::cos(beta)) *
-        M_PI;
+        std::numbers::inv_pi;
     return std::fmod(average + 360., 360.);
 }
 

src/extractor/intersection/mergable_road_detector.cpp

@@ -351,7 +351,7 @@ bool MergableRoadDetector::IsCircularShape(const NodeID intersection_node,
     //      ----         ----
     //          \       /
     //           -------
-    const auto constexpr CIRCULAR_POLYGON_ISOPERIMETRIC_LOWER_BOUND = 0.85 / (4 * M_PI);
+    const auto constexpr CIRCULAR_POLYGON_ISOPERIMETRIC_LOWER_BOUND = 0.85 / (4 * std::numbers::pi);
     if (connect_again && coordinates_to_the_left.front() == coordinates_to_the_left.back())
     { // if the left and right roads connect again and are closed polygons ...
         const auto area = util::coordinate_calculation::computeArea(coordinates_to_the_left);
@@ -359,7 +359,7 @@ bool MergableRoadDetector::IsCircularShape(const NodeID intersection_node,
         const auto area_to_squared_perimeter_ratio = std::abs(area) / (perimeter * perimeter);
 
         // then don't merge roads if A/L² is greater than the lower bound
-        BOOST_ASSERT(area_to_squared_perimeter_ratio <= 1. / (4 * M_PI));
+        BOOST_ASSERT(area_to_squared_perimeter_ratio <= 1. / (4 * std::numbers::pi));
         if (area_to_squared_perimeter_ratio >= CIRCULAR_POLYGON_ISOPERIMETRIC_LOWER_BOUND)
             return true;
     }

src/guidance/roundabout_handler.cpp

@@ -337,7 +337,7 @@ RoundaboutType RoundaboutHandler::getRoundaboutType(const NodeID nid) const
         return RoundaboutType::RoundaboutIntersection;
     }
 
-    const double radius = roundabout_length / (2 * M_PI);
+    const double radius = roundabout_length * 0.5 * std::numbers::inv_pi;
 
     // Looks like a rotary: large roundabout with dedicated name
     // do we have a dedicated name for the rotary, if not its a roundabout

src/nodejs/node_osrm.cpp

@@ -64,7 +64,7 @@ Napi::Object Engine::Init(Napi::Env env, Napi::Object exports)
  * ```
  *
  * @param {Object|String} [options={shared_memory: true}] Options for creating an OSRM object or string to the `.osrm` file.
- * @param {String} [options.algorithm] The algorithm to use for routing. Can be 'CH', 'CoreCH' or 'MLD'. Default is 'CH'.
+ * @param {String} [options.algorithm] The algorithm to use for routing. Can be 'CH', or 'MLD'. Default is 'CH'.
  *        Make sure you prepared the dataset with the correct toolchain.
  * @param {Boolean} [options.shared_memory] Connects to the persistent shared memory datastore.
  *        This requires you to run `osrm-datastore` prior to creating an `OSRM` object.

src/osrm/osrm.cpp

@@ -36,13 +36,6 @@ OSRM::OSRM(engine::EngineConfig &config)
 
     // Now, check that the algorithm requested can be used with the data
     // that's available.
-
-    if (config.algorithm == EngineConfig::Algorithm::CoreCH)
-    {
-        util::Log(logWARNING) << "Using CoreCH is deprecated. Falling back to CH";
-        config.algorithm = EngineConfig::Algorithm::CH;
-    }
-
     switch (config.algorithm)
     {
     case EngineConfig::Algorithm::CH:

src/tools/routed.cpp

@@ -61,7 +61,7 @@ std::istream &operator>>(std::istream &in, EngineConfig::Algorithm &algorithm)
     in >> token;
     boost::to_lower(token);
 
-    if (token == "ch" || token == "corech")
+    if (token == "ch")
         algorithm = EngineConfig::Algorithm::CH;
     else if (token == "mld")
         algorithm = EngineConfig::Algorithm::MLD;
@@ -159,7 +159,7 @@ inline unsigned generateServerProgramOptions(const int argc,
         ("algorithm,a",
          value<EngineConfig::Algorithm>(&config.algorithm)
              ->default_value(EngineConfig::Algorithm::CH, "CH"),
-         "Algorithm to use for the data. Can be CH, CoreCH, MLD.") //
+         "Algorithm to use for the data. Can be CH, MLD.") //
         ("disable-feature-dataset",
          value<std::vector<storage::FeatureDataset>>(&config.disable_feature_dataset)->multitoken(),
          "Disables a feature dataset from being loaded into memory if not needed. Options: "

src/util/coordinate_calculation.cpp

@@ -146,7 +146,6 @@ double bearing(const Coordinate coordinate_1, const Coordinate coordinate_2)
 
 double computeAngle(const Coordinate first, const Coordinate second, const Coordinate third)
 {
-    using namespace boost::math::constants;
     using namespace coordinate_calculation;
 
     if (first == second || second == third)
@@ -163,7 +162,7 @@ double computeAngle(const Coordinate first, const Coordinate second, const Coord
     const double v2y =
         web_mercator::latToY(toFloating(third.lat)) - web_mercator::latToY(toFloating(second.lat));
 
-    double angle = (atan2_lookup(v2y, v2x) - atan2_lookup(v1y, v1x)) * 180. / pi<double>();
+    double angle = (atan2_lookup(v2y, v2x) - atan2_lookup(v1y, v1x)) * 180. * std::numbers::inv_pi;
 
     while (angle < 0.)
     {

test/data/Makefile

@@ -14,20 +14,16 @@ PROFILE:=$(PROFILE_ROOT)/car.lua
 
 all: data
 
-data: ch/$(DATA_NAME).osrm.hsgr corech/$(DATA_NAME).osrm.hsgr mld/$(DATA_NAME).osrm.partition
+data: ch/$(DATA_NAME).osrm.hsgr mld/$(DATA_NAME).osrm.partition
 
 clean:
 	-rm -r $(DATA_NAME).*
-	-rm -r ch corech mld
+	-rm -r ch mld
 
 ch/$(DATA_NAME).osrm: $(DATA_NAME).osrm
 	mkdir -p ch
 	cp $(DATA_NAME).osrm.* ch/
 
-corech/$(DATA_NAME).osrm: $(DATA_NAME).osrm
-	mkdir -p corech
-	cp $(DATA_NAME).osrm.* corech/
-
 mld/$(DATA_NAME).osrm: $(DATA_NAME).osrm
 	mkdir -p mld
 	cp $(DATA_NAME).osrm.* mld/
@@ -42,10 +38,6 @@ ch/$(DATA_NAME).osrm.hsgr: ch/$(DATA_NAME).osrm $(PROFILE) $(OSRM_CONTRACT)
 	@echo "Running osrm-contract..."
 	$(TIMER) "osrm-contract\t$@" $(OSRM_CONTRACT) $<
 
-corech/$(DATA_NAME).osrm.hsgr: corech/$(DATA_NAME).osrm $(PROFILE) $(OSRM_CONTRACT)
-	@echo "Running osrm-contract..."
-	$(TIMER) "osrm-contract\t$@" $(OSRM_CONTRACT) --core=0.5 $<
-
 mld/$(DATA_NAME).osrm.partition: mld/$(DATA_NAME).osrm $(PROFILE) $(OSRM_PARTITION)
 	@echo "Running osrm-partition..."
 	$(TIMER) "osrm-partition\t$@" $(OSRM_PARTITION) $<
@@ -61,11 +53,6 @@ benchmark: data $(DATA_NAME).requests
 	$(TIMER) "queries\tCH" "cat $(DATA_NAME).requests | xargs curl &> /dev/null"
 	@cat osrm-routed.pid | xargs kill
 	@rm osrm-routed.pid
-	@/bin/sh -c '$(OSRM_ROUTED) --algorithm=CoreCH corech/$(DATA_NAME).osrm > /dev/null & echo "$$!" > osrm-routed.pid'
-	@sleep 1
-	$(TIMER) "queries\tCoreCH" "cat $(DATA_NAME).requests | xargs curl &> /dev/null"
-	@cat osrm-routed.pid | xargs kill
-	@rm osrm-routed.pid
 	@/bin/sh -c '$(OSRM_ROUTED) --algorithm=MLD mld/$(DATA_NAME).osrm > /dev/null & echo "$$!" > osrm-routed.pid'
 	@sleep 1
 	$(TIMER) "queries\tMLD" "cat $(DATA_NAME).requests | xargs curl &> /dev/null"

test/nodejs/constants.js

@@ -16,12 +16,10 @@ exports.test_tile = {'at': [17059, 11948, 15], 'size': 159125};
 if (process.env.OSRM_DATA_PATH !== undefined) {
     exports.data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "ch/monaco.osrm");
     exports.mld_data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "mld/monaco.osrm");
-    exports.corech_data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "corech/monaco.osrm");
     exports.test_memory_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "test_memory");
     console.log('Setting custom data path to ' + exports.data_path);
 } else {
     exports.data_path = path.resolve(path.join(__dirname, "../data/ch/monaco.osrm"));
     exports.mld_data_path = path.resolve(path.join(__dirname, "../data/mld/monaco.osrm"));
-    exports.corech_data_path = path.resolve(path.join(__dirname, "../data/corech/monaco.osrm"));
     exports.test_memory_path = path.resolve(path.join(__dirname, "../data/test_memory"));
 }

test/nodejs/index.js

@@ -3,7 +3,6 @@ var test = require('tape');
 var monaco_path = require('./constants').data_path;
 var test_memory_file = require('./constants').test_memory_file;
 var monaco_mld_path = require('./constants').mld_data_path;
-var monaco_corech_path = require('./constants').corech_data_path;
 
 test('constructor: throws if new keyword is not used', function(assert) {
     assert.plan(1);
@@ -65,13 +64,13 @@ test('constructor: throws if given a non-string/obj argument', function(assert)
 test('constructor: throws if given an unkown algorithm', function(assert) {
     assert.plan(1);
     assert.throws(function() { new OSRM({algorithm: 'Foo', shared_memory: true}); },
-        /algorithm option must be one of 'CH', 'CoreCH', or 'MLD'/);
+        /algorithm option must be one of 'CH', or 'MLD'/);
 });
 
 test('constructor: throws if given an invalid algorithm', function(assert) {
     assert.plan(1);
     assert.throws(function() { new OSRM({algorithm: 3, shared_memory: true}); },
-        /algorithm option must be a string and one of 'CH', 'CoreCH', or 'MLD'/);
+        /algorithm option must be a string and one of 'CH', or 'MLD'/);
 });
 
 test('constructor: loads MLD if given as algorithm', function(assert) {
@@ -86,22 +85,8 @@ test('constructor: loads CH if given as algorithm', function(assert) {
     assert.ok(osrm);
 });
 
-test('constructor: loads CoreCH if given as algorithm', function(assert) {
-    assert.plan(1);
-    var osrm = new OSRM({algorithm: 'CoreCH', path: monaco_corech_path});
-    assert.ok(osrm);
-});
-
-test('constructor: autoswitches to CoreCH for a CH dataset if capable', function(assert) {
-    assert.plan(1);
-    var osrm = new OSRM({algorithm: 'CH', path: monaco_corech_path});
-    assert.ok(osrm);
-});
-
 test('constructor: throws if data doesn\'t match algorithm', function(assert) {
-    assert.plan(3);
+    assert.plan(1);
-    assert.throws(function() { new OSRM({algorithm: 'CoreCH', path: monaco_mld_path}); }, /Could not find any metrics for CH/, 'CoreCH with MLD data');
-    assert.ok(new OSRM({algorithm: 'CoreCH', path: monaco_path}), 'CoreCH with CH data');
     assert.throws(function() { new OSRM({algorithm: 'MLD', path: monaco_path}); }, /Could not find any metrics for MLD/, 'MLD with CH data');
 });
 

test/nodejs/route.js

@@ -2,7 +2,6 @@ var OSRM = require('../../');
 var test = require('tape');
 var monaco_path = require('./constants').data_path;
 var monaco_mld_path = require('./constants').mld_data_path;
-var monaco_corech_path = require('./constants').corech_data_path;
 var three_test_coordinates = require('./constants').three_test_coordinates;
 var two_test_coordinates = require('./constants').two_test_coordinates;
 const flatbuffers = require('../../features/support/flatbuffers').flatbuffers;
@@ -76,32 +75,6 @@ test('route: routes Monaco on MLD', function(assert) {
     });
 });
 
-test('route: routes Monaco on CoreCH', function(assert) {
-    assert.plan(5);
-    var osrm = new OSRM({path: monaco_corech_path, algorithm: 'CoreCH'});
-    osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, route) {
-        assert.ifError(err);
-        assert.ok(route.waypoints);
-        assert.ok(route.routes);
-        assert.ok(route.routes.length);
-        assert.ok(route.routes[0].geometry);
-    });
-});
-
-test('route: routes Monaco and returns a JSON buffer', function(assert) {
-    assert.plan(6);
-    var osrm = new OSRM({path: monaco_corech_path, algorithm: 'CoreCH'});
-    osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, { format: 'json_buffer'}, function(err, result) {
-        assert.ifError(err);
-        assert.ok(result instanceof Buffer);
-        const route = JSON.parse(result);
-        assert.ok(route.waypoints);
-        assert.ok(route.routes);
-        assert.ok(route.routes.length);
-        assert.ok(route.routes[0].geometry);
-    });
-});
-
 test('route: throws with too few or invalid args', function(assert) {
     assert.plan(4);
     var osrm = new OSRM(monaco_path);

unit_tests/library/algorithm.cpp

@@ -14,14 +14,6 @@ BOOST_AUTO_TEST_CASE(test_incompatible_with_mld)
         osrm::exception);
 }
 
-BOOST_AUTO_TEST_CASE(test_compatible_with_corech_fallback)
-{
-    // Note - this tests that given the CoreCH algorithm config option, configuration falls back to
-    // CH and is compatible with CH data
-    BOOST_CHECK_NO_THROW(
-        getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CoreCH));
-}
-
 BOOST_AUTO_TEST_CASE(test_incompatible_with_ch)
 {
     // Can't use the CH algorithm with MLD data

unit_tests/library/options.cpp

@@ -18,16 +18,6 @@ BOOST_AUTO_TEST_CASE(test_ch)
     OSRM osrm{config};
 }
 
-BOOST_AUTO_TEST_CASE(test_corech)
-{
-    using namespace osrm;
-    EngineConfig config;
-    config.use_shared_memory = false;
-    config.storage_config = storage::StorageConfig(OSRM_TEST_DATA_DIR "/corech/monaco.osrm");
-    config.algorithm = EngineConfig::Algorithm::CoreCH;
-    OSRM osrm{config};
-}
-
 BOOST_AUTO_TEST_CASE(test_mld)
 {
     using namespace osrm;

unit_tests/library/tile.cpp

@@ -198,18 +198,6 @@ void test_tile_ch(bool use_string_only_api)
 BOOST_AUTO_TEST_CASE(test_tile_ch_old_api) { test_tile_ch(true); }
 BOOST_AUTO_TEST_CASE(test_tile_ch_new_api) { test_tile_ch(false); }
 
-void test_tile_corech(bool use_string_only_api)
-{
-    // Note: this tests that given the CoreCH algorithm config option, configuration falls back to
-    // CH and is compatible with CH data
-    using namespace osrm;
-    auto osrm =
-        getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CoreCH);
-    validate_tile(osrm, use_string_only_api);
-}
-BOOST_AUTO_TEST_CASE(test_tile_corech_old_api) { test_tile_corech(true); }
-BOOST_AUTO_TEST_CASE(test_tile_corech_new_api) { test_tile_corech(false); }
-
 void test_tile_mld(bool use_string_only_api)
 {
     using namespace osrm;
@@ -347,14 +335,6 @@ BOOST_AUTO_TEST_CASE(test_tile_turns_ch_new_api)
 {
     test_tile_turns_ch(osrm::EngineConfig::Algorithm::CH, false);
 }
-BOOST_AUTO_TEST_CASE(test_tile_turns_corech_old_api)
-{
-    test_tile_turns_ch(osrm::EngineConfig::Algorithm::CoreCH, true);
-}
-BOOST_AUTO_TEST_CASE(test_tile_turns_corech_new_api)
-{
-    test_tile_turns_ch(osrm::EngineConfig::Algorithm::CoreCH, false);
-}
 
 void test_tile_turns_mld(bool use_string_only_api)
 {
@@ -432,14 +412,6 @@ BOOST_AUTO_TEST_CASE(test_tile_speeds_ch_new_api)
 {
     test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CH, false);
 }
-BOOST_AUTO_TEST_CASE(test_tile_speeds_corech_old_api)
-{
-    test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CoreCH, true);
-}
-BOOST_AUTO_TEST_CASE(test_tile_speeds_corech_new_api)
-{
-    test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CoreCH, false);
-}
 
 void test_tile_speeds_mld(bool use_string_only_api)
 {
@@ -501,14 +473,6 @@ BOOST_AUTO_TEST_CASE(test_tile_node_ch_new_api)
 {
     test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CH, false);
 }
-BOOST_AUTO_TEST_CASE(test_tile_node_corech_old_api)
-{
-    test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CoreCH, true);
-}
-BOOST_AUTO_TEST_CASE(test_tile_node_corech_new_api)
-{
-    test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CoreCH, false);
-}
 
 void test_tile_nodes_mld(bool use_string_only_api)
 {