[core] Check for NaNs in mbgl::util::{min,max,clamp}

2 files changed, 22 insertions, 20 deletions

diff --git a/include/mbgl/util/math.hpp b/include/mbgl/util/math.hpp
index 08625ffc0c..87f9caf478 100644
--- a/include/mbgl/util/math.hpp
+++ b/include/mbgl/util/math.hpp
@@ -3,6 +3,7 @@
 
 #include <cmath>
 #include <array>
+#include <limits>
 
 #include <mbgl/util/vec.hpp>
 
@@ -11,33 +12,33 @@ namespace util {
 
 
 template <typename T>
-inline T max(T a, T b) {
-    return b > a ? b : a;
+typename std::enable_if_t<std::is_integral<T>::value, T> max(T a, T b) {
+    return std::max(a, b);
 }
 
 template <typename T>
-inline T max(T a, T b, T c) {
-    return max(max(a, b), c);
+typename std::enable_if_t<std::is_floating_point<T>::value, T> max(T a, T b) {
+    return std::fmax(a, b);
 }
 
-template <typename T>
-inline T max(T a, T b, T c, T d) {
-    return max(max(a, b), max(c, d));
+template <typename T, typename... Ts>
+typename std::enable_if_t<std::is_arithmetic<T>::value, T> max(T a, T b, Ts... args) {
+    return max(a, max(b, args...));
 }
 
 template <typename T>
-inline T min(T a, T b) {
-    return b < a ? b : a;
+typename std::enable_if_t<std::is_integral<T>::value, T> min(T a, T b) {
+    return std::min(a, b);
 }
 
 template <typename T>
-inline T min(T a, T b, T c) {
-    return min(min(a, b), c);
+typename std::enable_if_t<std::is_floating_point<T>::value, T> min(T a, T b) {
+    return std::fmin(a, b);
 }
 
-template <typename T>
-inline T min(T a, T b, T c, T d) {
-    return min(min(a, b), min(c, d));
+template <typename T, typename... Ts>
+typename std::enable_if_t<std::is_arithmetic<T>::value, T> min(T a, T b, Ts... args) {
+    return min(a, min(b, args...));
 }
 
 // Find the angle of the two vectors, solving the formula for the cross product
@@ -113,8 +114,8 @@ inline S unit(const S& a) {
 }
 
 template <typename T>
-T clamp(T value, T min, T max) {
-    return value < min ? min : (value > max ? max : value);
+T clamp(T value, T min_, T max_) {
+    return max(min_, min(max_, value));
 }
 
 // Constrains n to the given range (including min, excluding max) via modular
diff --git a/include/mbgl/util/projection.hpp b/include/mbgl/util/projection.hpp
index bee5eac8ae..09c8ce74ab 100644
--- a/include/mbgl/util/projection.hpp
+++ b/include/mbgl/util/projection.hpp
@@ -3,6 +3,7 @@
 
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/geo.hpp>
+#include <mbgl/util/math.hpp>
 
 #include <cmath>
 
@@ -13,16 +14,16 @@ class Projection {
 public:
     static inline double getMetersPerPixelAtLatitude(double lat, double zoom) {
         const double mapPixelWidthAtZoom = std::pow(2.0, zoom) * util::tileSize;
-        const double constrainedLatitude = ::fmin(::fmax(lat, -util::LATITUDE_MAX), util::LATITUDE_MAX);
+        const double constrainedLatitude = util::clamp(lat, -util::LATITUDE_MAX, util::LATITUDE_MAX);
 
         return std::cos(constrainedLatitude * util::DEG2RAD) * util::M2PI * util::EARTH_RADIUS_M / mapPixelWidthAtZoom;
     }
 
     static inline ProjectedMeters projectedMetersForLatLng(const LatLng& latLng) {
-        const double constrainedLatitude = ::fmin(::fmax(latLng.latitude, -util::LATITUDE_MAX), util::LATITUDE_MAX);
+        const double constrainedLatitude = util::clamp(latLng.latitude, -util::LATITUDE_MAX, util::LATITUDE_MAX);
 
         const double m = 1 - 1e-15;
-        const double f = ::fmin(::fmax(std::sin(util::DEG2RAD * constrainedLatitude), -m), m);
+        const double f = util::clamp(std::sin(util::DEG2RAD * constrainedLatitude), -m, m);
 
         const double easting  = util::EARTH_RADIUS_M * latLng.longitude * util::DEG2RAD;
         const double northing = 0.5 * util::EARTH_RADIUS_M * std::log((1 + f) / (1 - f));
@@ -34,7 +35,7 @@ public:
         double latitude = (2 * std::atan(std::exp(projectedMeters.northing / util::EARTH_RADIUS_M)) - (M_PI / 2)) * util::RAD2DEG;
         double longitude = projectedMeters.easting * util::RAD2DEG / util::EARTH_RADIUS_M;
 
-        latitude = ::fmin(::fmax(latitude, -util::LATITUDE_MAX), util::LATITUDE_MAX);
+        latitude = util::clamp(latitude, -util::LATITUDE_MAX, util::LATITUDE_MAX);
 
         return LatLng(latitude, longitude);
     }