--- gecode-release-6.2.0/gecode/float.hh.orig	2019-04-10 07:29:50.000000000 -0600
+++ gecode-release-6.2.0/gecode/float.hh	2021-01-14 08:53:23.620668408 -0700
@@ -77,7 +77,7 @@
 #endif
 
 // Include interval implementation
-#include <gecode/third-party/boost/numeric/interval.hpp>
+#include <boost/numeric/interval.hpp>
 
 /**
  * \namespace Gecode::Float
@@ -135,13 +135,13 @@ namespace Gecode { namespace Float {
    *
    */
   /// Rounding Base class (safe version)
-  typedef gecode_boost::numeric::interval_lib::save_state< gecode_boost::numeric::interval_lib::rounded_arith_std<FloatNum> >
+  typedef boost::numeric::interval_lib::save_state< boost::numeric::interval_lib::rounded_arith_std<FloatNum> >
 	RoundingBase;
 
 #else
 
   /// Rounding Base class (optimized version)
-  typedef gecode_boost::numeric::interval_lib::rounded_arith_opp<FloatNum>
+  typedef boost::numeric::interval_lib::rounded_arith_opp<FloatNum>
     RoundingBase;
 
 #endif
@@ -413,13 +413,13 @@ namespace Gecode {
     friend FloatVal Float::hull(const FloatNum& x, const FloatNum& y);
   protected:
     /// Used rounding policies
-    typedef gecode_boost::numeric::interval_lib::save_state<Float::Rounding> R;
+    typedef boost::numeric::interval_lib::save_state<Float::Rounding> R;
     /// Used checking policy
-    typedef gecode_boost::numeric::interval_lib::checking_strict<FloatNum> P;
+    typedef boost::numeric::interval_lib::checking_strict<FloatNum> P;
     /// Implementation type for float value
-    typedef gecode_boost::numeric::interval
+    typedef boost::numeric::interval
       <FloatNum,
-       gecode_boost::numeric::interval_lib::policies<R, P> >
+       boost::numeric::interval_lib::policies<R, P> >
     FloatValImpType;
     /// Implementation of float value
     FloatValImpType x;
--- gecode-release-6.2.0/gecode/float/num.hpp.orig	2019-04-10 07:29:50.000000000 -0600
+++ gecode-release-6.2.0/gecode/float/num.hpp	2021-01-14 08:54:06.372574304 -0700
@@ -35,27 +35,27 @@ namespace Gecode {
 
   forceinline FloatNum
   pi_half_lower(void) {
-    return gecode_boost::numeric::interval_lib::constants::pi_half_lower<FloatNum>();
+    return boost::numeric::interval_lib::constants::pi_half_lower<FloatNum>();
   }
   forceinline FloatNum
   pi_half_upper(void) {
-    return gecode_boost::numeric::interval_lib::constants::pi_half_upper<FloatNum>();
+    return boost::numeric::interval_lib::constants::pi_half_upper<FloatNum>();
   }
   forceinline FloatNum
   pi_lower(void) {
-    return gecode_boost::numeric::interval_lib::constants::pi_lower<FloatNum>();
+    return boost::numeric::interval_lib::constants::pi_lower<FloatNum>();
   }
   forceinline FloatNum
   pi_upper(void) {
-    return gecode_boost::numeric::interval_lib::constants::pi_upper<FloatNum>();
+    return boost::numeric::interval_lib::constants::pi_upper<FloatNum>();
   }
   forceinline FloatNum
   pi_twice_lower(void) {
-    return gecode_boost::numeric::interval_lib::constants::pi_twice_lower<FloatNum>();
+    return boost::numeric::interval_lib::constants::pi_twice_lower<FloatNum>();
   }
   forceinline FloatNum
   pi_twice_upper(void) {
-    return gecode_boost::numeric::interval_lib::constants::pi_twice_upper<FloatNum>();
+    return boost::numeric::interval_lib::constants::pi_twice_upper<FloatNum>();
   }
 }
 
--- gecode-release-6.2.0/gecode/float/val.hpp.orig	2019-04-10 07:29:50.000000000 -0600
+++ gecode-release-6.2.0/gecode/float/val.hpp	2021-01-14 08:55:39.813368656 -0700
@@ -76,29 +76,29 @@ namespace Gecode {
   }
   forceinline FloatNum
   FloatVal::size(void) const {
-    return gecode_boost::numeric::width(x);
+    return boost::numeric::width(x);
   }
   forceinline FloatNum
   FloatVal::med(void) const {
-    return gecode_boost::numeric::median(x);
+    return boost::numeric::median(x);
   }
 
   forceinline bool
   FloatVal::tight(void) const {
-    return (gecode_boost::numeric::singleton(x) ||
+    return (boost::numeric::singleton(x) ||
             (nextafter(x.lower(),x.upper()) == x.upper()));
   }
   forceinline bool
   FloatVal::singleton(void) const {
-    return gecode_boost::numeric::singleton(x);
+    return boost::numeric::singleton(x);
   }
   forceinline bool
   FloatVal::in(FloatNum n) const {
-    return gecode_boost::numeric::in(n,x);
+    return boost::numeric::in(n,x);
   }
   forceinline bool
   FloatVal::zero_in(void) const {
-    return gecode_boost::numeric::zero_in(x);
+    return boost::numeric::zero_in(x);
   }
 
   forceinline FloatVal
@@ -107,17 +107,17 @@ namespace Gecode {
   }
   forceinline FloatVal
   FloatVal::pi_half(void) {
-    FloatVal p(gecode_boost::numeric::interval_lib::pi_half<FloatValImpType>());
+    FloatVal p(boost::numeric::interval_lib::pi_half<FloatValImpType>());
     return p;
   }
   forceinline FloatVal
   FloatVal::pi(void) {
-    FloatVal p(gecode_boost::numeric::interval_lib::pi<FloatValImpType>());
+    FloatVal p(boost::numeric::interval_lib::pi<FloatValImpType>());
     return p;
   }
   forceinline FloatVal
   FloatVal::pi_twice(void) {
-    FloatVal p(gecode_boost::numeric::interval_lib::pi_twice<FloatValImpType>());
+    FloatVal p(boost::numeric::interval_lib::pi_twice<FloatValImpType>());
     return p;
   }
 
@@ -226,7 +226,7 @@ namespace Gecode {
   operator <(const FloatVal& x, const FloatVal& y) {
     try {
       return x.x < y.x;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -234,7 +234,7 @@ namespace Gecode {
   operator <(const FloatVal& x, const FloatNum& y) {
     try {
       return x.x < y;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -243,7 +243,7 @@ namespace Gecode {
   operator <=(const FloatVal& x, const FloatVal& y) {
     try {
       return x.x <= y.x;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -251,7 +251,7 @@ namespace Gecode {
   operator <=(const FloatVal& x, const FloatNum& y) {
     try {
       return x.x <= y;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -260,7 +260,7 @@ namespace Gecode {
   operator >(const FloatVal& x, const FloatVal& y) {
     try {
       return x.x > y.x;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -268,7 +268,7 @@ namespace Gecode {
   operator >(const FloatVal& x, const FloatNum& y) {
     try {
       return x.x > y;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -277,7 +277,7 @@ namespace Gecode {
   operator >=(const FloatVal& x, const FloatVal& y) {
     try {
       return x.x >= y.x;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -285,7 +285,7 @@ namespace Gecode {
   operator >=(const FloatVal& x, const FloatNum& y) {
     try {
       return x.x >= y;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -294,13 +294,13 @@ namespace Gecode {
   operator ==(const FloatVal& x, const FloatVal& y) {
     try {
       return x.x == y.x;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
   inline bool
   operator ==(const FloatVal& x, const FloatNum& y) {
-    if (!gecode_boost::numeric::interval_lib::checking_strict<FloatNum>
+    if (!boost::numeric::interval_lib::checking_strict<FloatNum>
         ::is_empty(x.x.lower(), x.x.upper())) {
       if ((x.x.lower() == y) && (x.x.upper() == y))
         return true;
@@ -317,7 +317,7 @@ namespace Gecode {
   operator !=(const FloatVal& x, const FloatVal& y) {
     try {
       return x.x != y.x;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -325,7 +325,7 @@ namespace Gecode {
   operator !=(const FloatVal& x, const FloatNum& y) {
     try {
       return x.x != y;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }