Index: gecode-5.1.0/Makefile.in
===================================================================
--- gecode-5.1.0.orig/Makefile.in	2017-07-16 12:34:55.314660449 +0300
+++ gecode-5.1.0/Makefile.in	2017-07-27 22:11:22.357083203 +0300
@@ -989,8 +989,7 @@
 	numeric/interval.hpp \
 	LICENSE_1_0.txt \
 	limits.hpp non_type.hpp type.hpp
-THIRDHDR = \
-	$(BOOSTHDR:%=gecode/third-party/boost/%)
+THIRDHDR =
 
 #
 # COLLECTING ALL
Index: gecode-5.1.0/gecode/float.hh
===================================================================
--- gecode-5.1.0.orig/gecode/float.hh	2017-04-10 14:21:37.000000000 +0300
+++ gecode-5.1.0/gecode/float.hh	2017-07-27 22:14:12.143438116 +0300
@@ -81,7 +81,7 @@
 #endif
 
 // Include interval implementation
-#include <gecode/third-party/boost/numeric/interval.hpp>
+#include <boost/numeric/interval.hpp>
 
 /**
  * \namespace Gecode::Float
@@ -139,13 +139,13 @@
    *
    */
   /// Rounding Base class (safe version)
-  typedef gecode_boost::numeric::interval_lib::rounded_arith_std<FloatNum>
+  typedef 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
@@ -417,13 +417,13 @@
     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;
Index: gecode-5.1.0/gecode/float/num.hpp
===================================================================
--- gecode-5.1.0.orig/gecode/float/num.hpp	2014-10-03 16:34:37.000000000 +0300
+++ gecode-5.1.0/gecode/float/num.hpp	2017-07-27 22:12:59.613849388 +0300
@@ -39,27 +39,27 @@
 
   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>();
   }
 }
 
Index: gecode-5.1.0/gecode/float/val.hpp
===================================================================
--- gecode-5.1.0.orig/gecode/float/val.hpp	2016-06-20 17:44:21.000000000 +0300
+++ gecode-5.1.0/gecode/float/val.hpp	2017-07-27 22:12:42.778409132 +0300
@@ -80,29 +80,29 @@
   }
   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
@@ -111,17 +111,17 @@
   }
   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;
   }
 
@@ -230,7 +230,7 @@
   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;
     }
   }
@@ -238,7 +238,7 @@
   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;
     }
   }
@@ -247,7 +247,7 @@
   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;
     }
   }
@@ -255,7 +255,7 @@
   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;
     }
   }
@@ -264,7 +264,7 @@
   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;
     }
   }
@@ -272,7 +272,7 @@
   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;
     }
   }
@@ -281,7 +281,7 @@
   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;
     }
   }
@@ -289,7 +289,7 @@
   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;
     }
   }
@@ -298,13 +298,13 @@
   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;
@@ -321,7 +321,7 @@
   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;
     }
   }
@@ -329,7 +329,7 @@
   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;
     }
   }
