@@ -16,9 +16,9 @@
 #include <af/dim4.hpp>
 
 #include <array>
-#include <cfloat>
 #include <cmath>
 #include <cstring>
+#include <limits>
 #include <vector>
 
 using af::dim4;
@@ -27,6 +27,7 @@ using std::array;
 using std::log;
 using std::max;
 using std::min;
+using std::numeric_limits;
 using std::pow;
 using std::round;
 using std::sqrt;
@@ -47,17 +48,17 @@ static const float LMEDSOutlierRatio = 0.4f;
 
 template<typename T>
 struct EPS {
-    T eps() { return FLT_EPSILON; }
+    T eps() { return numeric_limits<float>::epsilon(); }
 };
 
 template<>
 struct EPS<float> {
-    static float eps() { return FLT_EPSILON; }
+    static float eps() { return numeric_limits<float>::epsilon(); }
 };
 
 template<>
 struct EPS<double> {
-    static double eps() { return DBL_EPSILON; }
+    static double eps() { return numeric_limits<double>::epsilon(); }
 };
 
 template<typename T, int M, int N>
@@ -138,7 +139,7 @@ unsigned updateIterations(float inlier_ratio, unsigned iter) {
     float wn = pow(1 - w, 4.f);
 
     float d = 1.f - wn;
-    if (d < FLT_MIN) { return 0; }
+    if (d < numeric_limits<float>::min()) { return 0; }
 
     d = log(d);
 
@@ -284,7 +285,7 @@ int findBestHomography(Array<T>& bestH, const Array<float>& x_src,
     unsigned iter    = iterations;
     unsigned bestIdx = 0;
     int bestInliers  = 0;
-    float minMedian  = FLT_MAX;
+    float minMedian  = numeric_limits<float>::max();
 
     for (unsigned i = 0; i < iter; i++) {
         const unsigned Hidx = Hdims[0] * i;
@@ -344,7 +345,8 @@ int findBestHomography(Array<T>& bestH, const Array<float>& x_src,
                 median = (median + err[nsamples / 2 - 1]) * 0.5f;
             }
 
-            if (median < minMedian && median > FLT_EPSILON) {
+            if (median < minMedian &&
+                median > numeric_limits<float>::epsilon()) {
                 minMedian = median;
                 bestIdx   = i;
             }
 
@@ -20,8 +20,8 @@
 #include <resize.hpp>
 #include <sort_index.hpp>
 
-#include <cfloat>
 #include <cstring>
+#include <limits>
 #include <vector>
 
 using af::dim4;
@@ -330,8 +330,9 @@ void interpolateExtrema(float* x_out, float* y_out, unsigned* layer_out,
         float det = dxx * dyy - dxy * dxy;
 
         // add FLT_EPSILON for double-precision compatibility
-        if (det <= 0 || tr * tr * edge_thr >=
-                            (edge_thr + 1) * (edge_thr + 1) * det + FLT_EPSILON)
+        if (det <= 0 ||
+            tr * tr * edge_thr >= (edge_thr + 1) * (edge_thr + 1) * det +
+                                      std::numeric_limits<float>::epsilon())
             continue;
 
         if (*counter < max_feat) {
@@ -692,7 +693,7 @@ void computeGLOHDescriptor(float* desc_out, const unsigned desc_len,
                                      (float)(GLOHRadii[1] - GLOHRadii[0])
                            : min(2 + (r - GLOHRadii[1]) /
                                          (float)(GLOHRadii[2] - GLOHRadii[1]),
-                                 3.f - FLT_EPSILON));
+                                 3.f - std::numeric_limits<float>::epsilon()));
 
             if (r <= GLOHRadii[rb - 1] && y > 0 && y < idims[0] - 1 && x > 0 &&
                 x < idims[1] - 1) {
 
@@ -14,7 +14,7 @@
 #include <af/dim4.hpp>
 #include <algorithm>
 
-#include <cfloat>
+#include <limits>
 
 using af::dim4;
 
@@ -39,7 +39,8 @@ int homography(Array<T> &bestH, const Array<float> &x_src,
         iter = ::std::min(
             iter, (unsigned)(log(1.f - LMEDSConfidence) /
                              log(1.f - pow(1.f - LMEDSOutlierRatio, 4.f))));
-        err = createValueArray<float>(af::dim4(nsamples, iter), FLT_MAX);
+        err = createValueArray<float>(af::dim4(nsamples, iter),
+                                      std::numeric_limits<float>::max());
     }
 
     af::dim4 rdims(4, iter);
 
@@ -14,8 +14,10 @@
 #include <af/dim4.hpp>
 
 #include <algorithm>
+#include <limits>
 
 using af::dim4;
+using std::numeric_limits;
 
 namespace opencl {
 
@@ -39,7 +41,8 @@ int homography(Array<T> &bestH, const Array<float> &x_src,
             ::std::min(iter, static_cast<unsigned>(
                                  log(1.f - LMEDSConfidence) /
                                  log(1.f - pow(1.f - LMEDSOutlierRatio, 4.f))));
-        err = createValueArray<float>(af::dim4(nsamples, iter), FLT_MAX);
+        err = createValueArray<float>(af::dim4(nsamples, iter),
+                                      numeric_limits<float>::max());
     } else {
         // Avoid passing "null" cl_mem object to kernels
         err = createEmptyArray<float>(af::dim4(1));
 
@@ -19,6 +19,7 @@
 #include <memory.hpp>
 #include <af/defines.h>
 
+#include <limits>
 #include <string>
 #include <vector>
 
@@ -36,8 +37,10 @@ std::array<Kernel, 5> getHomographyKernels(const af_homography_type htype) {
         DefineKeyValue(T, dtype_traits<T>::getName()),
     };
     options.emplace_back(getTypeBuildDefinition<T>());
-    options.emplace_back(DefineKeyValue(
-        EPS, (std::is_same<T, double>::value ? DBL_EPSILON : FLT_EPSILON)));
+    options.emplace_back(
+        DefineKeyValue(EPS, (std::is_same<T, double>::value
+                                 ? std::numeric_limits<double>::epsilon()
+                                 : std::numeric_limits<float>::epsilon())));
     if (htype == AF_HOMOGRAPHY_RANSAC) {
         options.emplace_back(DefineKey(RANSAC));
     }