CUDA 13.2 samples update (#432)

- Added Python samples for CUDA Python 1.0 release
- Renamed top-level `Samples` directory to `cpp` to accommodate Python samples.

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval.hpp

@@ -0,0 +1,29 @@
+/* Boost interval.hpp header file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_HPP
+#define BOOST_NUMERIC_INTERVAL_HPP
+
+#include <boost/limits.hpp>
+#include <boost/numeric/interval/arith.hpp>
+#include <boost/numeric/interval/arith2.hpp>
+#include <boost/numeric/interval/arith3.hpp>
+#include <boost/numeric/interval/checking.hpp>
+#include <boost/numeric/interval/compare.hpp>
+#include <boost/numeric/interval/constants.hpp>
+#include <boost/numeric/interval/hw_rounding.hpp>
+#include <boost/numeric/interval/interval.hpp>
+#include <boost/numeric/interval/policies.hpp>
+#include <boost/numeric/interval/rounded_arith.hpp>
+#include <boost/numeric/interval/rounded_transc.hpp>
+#include <boost/numeric/interval/transc.hpp>
+#include <boost/numeric/interval/utility.hpp>
+
+#endif // BOOST_NUMERIC_INTERVAL_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/arith.hpp

@@ -0,0 +1,280 @@
+/* Boost interval/arith.hpp template implementation file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002-2003 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_ARITH_HPP
+#define BOOST_NUMERIC_INTERVAL_ARITH_HPP
+
+#include <algorithm>
+#include <boost/config.hpp>
+#include <boost/numeric/interval/detail/bugs.hpp>
+#include <boost/numeric/interval/detail/division.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+#include <boost/numeric/interval/interval.hpp>
+
+namespace boost {
+namespace numeric {
+
+/*
+ * Basic arithmetic operators
+ */
+
+template <class T, class Policies> inline const interval<T, Policies> &operator+(const interval<T, Policies> &x)
+{
+    return x;
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator-(const interval<T, Policies> &x)
+{
+    if (interval_lib::detail::test_input(x))
+        return interval<T, Policies>::empty();
+    return interval<T, Policies>(-x.upper(), -x.lower(), true);
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> &interval<T, Policies>::operator+=(const interval<T, Policies> &r)
+{
+    if (interval_lib::detail::test_input(*this, r))
+        set_empty();
+    else {
+        typename Policies::rounding rnd;
+        set(rnd.add_down(low, r.low), rnd.add_up(up, r.up));
+    }
+    return *this;
+}
+
+template <class T, class Policies> inline interval<T, Policies> &interval<T, Policies>::operator+=(const T &r)
+{
+    if (interval_lib::detail::test_input(*this, r))
+        set_empty();
+    else {
+        typename Policies::rounding rnd;
+        set(rnd.add_down(low, r), rnd.add_up(up, r));
+    }
+    return *this;
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> &interval<T, Policies>::operator-=(const interval<T, Policies> &r)
+{
+    if (interval_lib::detail::test_input(*this, r))
+        set_empty();
+    else {
+        typename Policies::rounding rnd;
+        set(rnd.sub_down(low, r.up), rnd.sub_up(up, r.low));
+    }
+    return *this;
+}
+
+template <class T, class Policies> inline interval<T, Policies> &interval<T, Policies>::operator-=(const T &r)
+{
+    if (interval_lib::detail::test_input(*this, r))
+        set_empty();
+    else {
+        typename Policies::rounding rnd;
+        set(rnd.sub_down(low, r), rnd.sub_up(up, r));
+    }
+    return *this;
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> &interval<T, Policies>::operator*=(const interval<T, Policies> &r)
+{
+    return *this = *this * r;
+}
+
+template <class T, class Policies> inline interval<T, Policies> &interval<T, Policies>::operator*=(const T &r)
+{
+    return *this = r * *this;
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> &interval<T, Policies>::operator/=(const interval<T, Policies> &r)
+{
+    return *this = *this / r;
+}
+
+template <class T, class Policies> inline interval<T, Policies> &interval<T, Policies>::operator/=(const T &r)
+{
+    return *this = *this / r;
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> operator+(const interval<T, Policies> &x, const interval<T, Policies> &y)
+{
+    if (interval_lib::detail::test_input(x, y))
+        return interval<T, Policies>::empty();
+    typename Policies::rounding rnd;
+    return interval<T, Policies>(rnd.add_down(x.lower(), y.lower()), rnd.add_up(x.upper(), y.upper()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator+(const T &x, const interval<T, Policies> &y)
+{
+    if (interval_lib::detail::test_input(x, y))
+        return interval<T, Policies>::empty();
+    typename Policies::rounding rnd;
+    return interval<T, Policies>(rnd.add_down(x, y.lower()), rnd.add_up(x, y.upper()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator+(const interval<T, Policies> &x, const T &y)
+{
+    return y + x;
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> operator-(const interval<T, Policies> &x, const interval<T, Policies> &y)
+{
+    if (interval_lib::detail::test_input(x, y))
+        return interval<T, Policies>::empty();
+    typename Policies::rounding rnd;
+    return interval<T, Policies>(rnd.sub_down(x.lower(), y.upper()), rnd.sub_up(x.upper(), y.lower()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator-(const T &x, const interval<T, Policies> &y)
+{
+    if (interval_lib::detail::test_input(x, y))
+        return interval<T, Policies>::empty();
+    typename Policies::rounding rnd;
+    return interval<T, Policies>(rnd.sub_down(x, y.upper()), rnd.sub_up(x, y.lower()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator-(const interval<T, Policies> &x, const T &y)
+{
+    if (interval_lib::detail::test_input(x, y))
+        return interval<T, Policies>::empty();
+    typename Policies::rounding rnd;
+    return interval<T, Policies>(rnd.sub_down(x.lower(), y), rnd.sub_up(x.upper(), y), true);
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> operator*(const interval<T, Policies> &x, const interval<T, Policies> &y)
+{
+    BOOST_USING_STD_MIN();
+    BOOST_USING_STD_MAX();
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x, y))
+        return I::empty();
+    typename Policies::rounding rnd;
+    const T                    &xl = x.lower();
+    const T                    &xu = x.upper();
+    const T                    &yl = y.lower();
+    const T                    &yu = y.upper();
+
+    if (interval_lib::user::is_neg(xl))
+        if (interval_lib::user::is_pos(xu))
+            if (interval_lib::user::is_neg(yl))
+                if (interval_lib::user::is_pos(yu)) // M * M
+                    return I(min BOOST_PREVENT_MACRO_SUBSTITUTION(rnd.mul_down(xl, yu), rnd.mul_down(xu, yl)),
+                             max BOOST_PREVENT_MACRO_SUBSTITUTION(rnd.mul_up(xl, yl), rnd.mul_up(xu, yu)),
+                             true);
+                else // M * N
+                    return I(rnd.mul_down(xu, yl), rnd.mul_up(xl, yl), true);
+            else if (interval_lib::user::is_pos(yu)) // M * P
+                return I(rnd.mul_down(xl, yu), rnd.mul_up(xu, yu), true);
+            else // M * Z
+                return I(static_cast<T>(0), static_cast<T>(0), true);
+        else if (interval_lib::user::is_neg(yl))
+            if (interval_lib::user::is_pos(yu)) // N * M
+                return I(rnd.mul_down(xl, yu), rnd.mul_up(xl, yl), true);
+            else // N * N
+                return I(rnd.mul_down(xu, yu), rnd.mul_up(xl, yl), true);
+        else if (interval_lib::user::is_pos(yu)) // N * P
+            return I(rnd.mul_down(xl, yu), rnd.mul_up(xu, yl), true);
+        else // N * Z
+            return I(static_cast<T>(0), static_cast<T>(0), true);
+    else if (interval_lib::user::is_pos(xu))
+        if (interval_lib::user::is_neg(yl))
+            if (interval_lib::user::is_pos(yu)) // P * M
+                return I(rnd.mul_down(xu, yl), rnd.mul_up(xu, yu), true);
+            else // P * N
+                return I(rnd.mul_down(xu, yl), rnd.mul_up(xl, yu), true);
+        else if (interval_lib::user::is_pos(yu)) // P * P
+            return I(rnd.mul_down(xl, yl), rnd.mul_up(xu, yu), true);
+        else // P * Z
+            return I(static_cast<T>(0), static_cast<T>(0), true);
+    else // Z * ?
+        return I(static_cast<T>(0), static_cast<T>(0), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator*(const T &x, const interval<T, Policies> &y)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x, y))
+        return I::empty();
+    typename Policies::rounding rnd;
+    const T                    &yl = y.lower();
+    const T                    &yu = y.upper();
+    // x is supposed not to be infinite
+    if (interval_lib::user::is_neg(x))
+        return I(rnd.mul_down(x, yu), rnd.mul_up(x, yl), true);
+    else if (interval_lib::user::is_zero(x))
+        return I(static_cast<T>(0), static_cast<T>(0), true);
+    else
+        return I(rnd.mul_down(x, yl), rnd.mul_up(x, yu), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator*(const interval<T, Policies> &x, const T &y)
+{
+    return y * x;
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> operator/(const interval<T, Policies> &x, const interval<T, Policies> &y)
+{
+    if (interval_lib::detail::test_input(x, y))
+        return interval<T, Policies>::empty();
+    if (zero_in(y))
+        if (!interval_lib::user::is_zero(y.lower()))
+            if (!interval_lib::user::is_zero(y.upper()))
+                return interval_lib::detail::div_zero(x);
+            else
+                return interval_lib::detail::div_negative(x, y.lower());
+        else if (!interval_lib::user::is_zero(y.upper()))
+            return interval_lib::detail::div_positive(x, y.upper());
+        else
+            return interval<T, Policies>::empty();
+    else
+        return interval_lib::detail::div_non_zero(x, y);
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator/(const T &x, const interval<T, Policies> &y)
+{
+    if (interval_lib::detail::test_input(x, y))
+        return interval<T, Policies>::empty();
+    if (zero_in(y))
+        if (!interval_lib::user::is_zero(y.lower()))
+            if (!interval_lib::user::is_zero(y.upper()))
+                return interval_lib::detail::div_zero<T, Policies>(x);
+            else
+                return interval_lib::detail::div_negative<T, Policies>(x, y.lower());
+        else if (!interval_lib::user::is_zero(y.upper()))
+            return interval_lib::detail::div_positive<T, Policies>(x, y.upper());
+        else
+            return interval<T, Policies>::empty();
+    else
+        return interval_lib::detail::div_non_zero(x, y);
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator/(const interval<T, Policies> &x, const T &y)
+{
+    if (interval_lib::detail::test_input(x, y) || interval_lib::user::is_zero(y))
+        return interval<T, Policies>::empty();
+    typename Policies::rounding rnd;
+    const T                    &xl = x.lower();
+    const T                    &xu = x.upper();
+    if (interval_lib::user::is_neg(y))
+        return interval<T, Policies>(rnd.div_down(xu, y), rnd.div_up(xl, y), true);
+    else
+        return interval<T, Policies>(rnd.div_down(xl, y), rnd.div_up(xu, y), true);
+}
+
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_ARITH_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/arith2.hpp

@@ -0,0 +1,312 @@
+/* Boost interval/arith2.hpp template implementation file
+ *
+ * This header provides some auxiliary arithmetic
+ * functions: fmod, sqrt, square, pov, inverse and
+ * a multi-interval division.
+ *
+ * Copyright 2002-2003 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_ARITH2_HPP
+#define BOOST_NUMERIC_INTERVAL_ARITH2_HPP
+
+#include <algorithm>
+#include <boost/config.hpp>
+#include <boost/config/no_tr1/cmath.hpp>
+#include <boost/numeric/interval/arith.hpp>
+#include <boost/numeric/interval/detail/bugs.hpp>
+#include <boost/numeric/interval/detail/division.hpp>
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+#include <boost/numeric/interval/policies.hpp>
+#include <cassert>
+
+namespace boost {
+namespace numeric {
+
+template <class T, class Policies>
+inline interval<T, Policies> fmod(const interval<T, Policies> &x, const interval<T, Policies> &y)
+{
+    if (interval_lib::detail::test_input(x, y))
+        return interval<T, Policies>::empty();
+    typename Policies::rounding                                           rnd;
+    typedef typename interval_lib::unprotect<interval<T, Policies>>::type I;
+    T const &yb = interval_lib::user::is_neg(x.lower()) ? y.lower() : y.upper();
+    T        n  = rnd.int_down(rnd.div_down(x.lower(), yb));
+    return (const I &)x - n * (const I &)y;
+}
+
+template <class T, class Policies> inline interval<T, Policies> fmod(const interval<T, Policies> &x, const T &y)
+{
+    if (interval_lib::detail::test_input(x, y))
+        return interval<T, Policies>::empty();
+    typename Policies::rounding                                           rnd;
+    typedef typename interval_lib::unprotect<interval<T, Policies>>::type I;
+    T                                                                     n = rnd.int_down(rnd.div_down(x.lower(), y));
+    return (const I &)x - n * I(y);
+}
+
+template <class T, class Policies> inline interval<T, Policies> fmod(const T &x, const interval<T, Policies> &y)
+{
+    if (interval_lib::detail::test_input(x, y))
+        return interval<T, Policies>::empty();
+    typename Policies::rounding                                           rnd;
+    typedef typename interval_lib::unprotect<interval<T, Policies>>::type I;
+    T const &yb = interval_lib::user::is_neg(x) ? y.lower() : y.upper();
+    T        n  = rnd.int_down(rnd.div_down(x, yb));
+    return x - n * (const I &)y;
+}
+
+namespace interval_lib {
+
+template <class T, class Policies>
+inline interval<T, Policies> division_part1(const interval<T, Policies> &x, const interval<T, Policies> &y, bool &b)
+{
+    typedef interval<T, Policies> I;
+    b = false;
+    if (detail::test_input(x, y))
+        return I::empty();
+    if (zero_in(y))
+        if (!user::is_zero(y.lower()))
+            if (!user::is_zero(y.upper()))
+                return detail::div_zero_part1(x, y, b);
+            else
+                return detail::div_negative(x, y.lower());
+        else if (!user::is_zero(y.upper()))
+            return detail::div_positive(x, y.upper());
+        else
+            return I::empty();
+    else
+        return detail::div_non_zero(x, y);
+}
+
+template <class T, class Policies>
+inline interval<T, Policies>
+division_part2(const interval<T, Policies> &x, const interval<T, Policies> &y, bool b = true)
+{
+    if (!b)
+        return interval<T, Policies>::empty();
+    return detail::div_zero_part2(x, y);
+}
+
+template <class T, class Policies> inline interval<T, Policies> multiplicative_inverse(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (detail::test_input(x))
+        return I::empty();
+    T                           one = static_cast<T>(1);
+    typename Policies::rounding rnd;
+    if (zero_in(x)) {
+        typedef typename Policies::checking checking;
+        if (!user::is_zero(x.lower()))
+            if (!user::is_zero(x.upper()))
+                return I::whole();
+            else
+                return I(checking::neg_inf(), rnd.div_up(one, x.lower()), true);
+        else if (!user::is_zero(x.upper()))
+            return I(rnd.div_down(one, x.upper()), checking::pos_inf(), true);
+        else
+            return I::empty();
+    }
+    else
+        return I(rnd.div_down(one, x.upper()), rnd.div_up(one, x.lower()), true);
+}
+
+namespace detail {
+
+template <class T, class Rounding> inline T pow_dn(const T &x_, int pwr, Rounding &rnd) // x and pwr are positive
+{
+    T x = x_;
+    T y = (pwr & 1) ? x_ : static_cast<T>(1);
+    pwr >>= 1;
+    while (pwr > 0) {
+        x = rnd.mul_down(x, x);
+        if (pwr & 1)
+            y = rnd.mul_down(x, y);
+        pwr >>= 1;
+    }
+    return y;
+}
+
+template <class T, class Rounding> inline T pow_up(const T &x_, int pwr, Rounding &rnd) // x and pwr are positive
+{
+    T x = x_;
+    T y = (pwr & 1) ? x_ : static_cast<T>(1);
+    pwr >>= 1;
+    while (pwr > 0) {
+        x = rnd.mul_up(x, x);
+        if (pwr & 1)
+            y = rnd.mul_up(x, y);
+        pwr >>= 1;
+    }
+    return y;
+}
+
+} // namespace detail
+} // namespace interval_lib
+
+template <class T, class Policies> inline interval<T, Policies> pow(const interval<T, Policies> &x, int pwr)
+{
+    BOOST_USING_STD_MAX();
+    using interval_lib::detail::pow_dn;
+    using interval_lib::detail::pow_up;
+    typedef interval<T, Policies> I;
+
+    if (interval_lib::detail::test_input(x))
+        return I::empty();
+
+    if (pwr == 0)
+        if (interval_lib::user::is_zero(x.lower()) && interval_lib::user::is_zero(x.upper()))
+            return I::empty();
+        else
+            return I(static_cast<T>(1));
+    else if (pwr < 0)
+        return interval_lib::multiplicative_inverse(pow(x, -pwr));
+
+    typename Policies::rounding rnd;
+
+    if (interval_lib::user::is_neg(x.upper())) { // [-2,-1]
+        T yl = pow_dn(static_cast<T>(-x.upper()), pwr, rnd);
+        T yu = pow_up(static_cast<T>(-x.lower()), pwr, rnd);
+        if (pwr & 1) // [-2,-1]^1
+            return I(-yu, -yl, true);
+        else // [-2,-1]^2
+            return I(yl, yu, true);
+    }
+    else if (interval_lib::user::is_neg(x.lower())) { // [-1,1]
+        if (pwr & 1) {                                // [-1,1]^1
+            return I(-pow_up(-x.lower(), pwr, rnd), pow_up(x.upper(), pwr, rnd), true);
+        }
+        else { // [-1,1]^2
+            return I(static_cast<T>(0),
+                     pow_up(max BOOST_PREVENT_MACRO_SUBSTITUTION(static_cast<T>(-x.lower()), x.upper()), pwr, rnd),
+                     true);
+        }
+    }
+    else { // [1,2]
+        return I(pow_dn(x.lower(), pwr, rnd), pow_up(x.upper(), pwr, rnd), true);
+    }
+}
+
+template <class T, class Policies> inline interval<T, Policies> sqrt(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x) || interval_lib::user::is_neg(x.upper()))
+        return I::empty();
+    typename Policies::rounding rnd;
+    T l = !interval_lib::user::is_pos(x.lower()) ? static_cast<T>(0) : rnd.sqrt_down(x.lower());
+    return I(l, rnd.sqrt_up(x.upper()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> square(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x))
+        return I::empty();
+    typename Policies::rounding rnd;
+    const T                    &xl = x.lower();
+    const T                    &xu = x.upper();
+    if (interval_lib::user::is_neg(xu))
+        return I(rnd.mul_down(xu, xu), rnd.mul_up(xl, xl), true);
+    else if (interval_lib::user::is_pos(x.lower()))
+        return I(rnd.mul_down(xl, xl), rnd.mul_up(xu, xu), true);
+    else
+        return I(static_cast<T>(0), (-xl > xu ? rnd.mul_up(xl, xl) : rnd.mul_up(xu, xu)), true);
+}
+
+namespace interval_lib {
+namespace detail {
+
+template <class I> inline I root_aux(typename I::base_type const &x, int k) // x and k are bigger than one
+{
+    typedef typename I::base_type T;
+    T                             tk(k);
+    I                             y(static_cast<T>(1), x, true);
+    for (;;) {
+        T y0 = median(y);
+        I yy = intersect(y, y0 - (pow(I(y0, y0, true), k) - x) / (tk * pow(y, k - 1)));
+        if (equal(y, yy))
+            return y;
+        y = yy;
+    }
+}
+
+template <class I>
+inline // x is positive and k bigger than one
+    typename I::base_type
+    root_aux_dn(typename I::base_type const &x, int k)
+{
+    typedef typename I::base_type   T;
+    typedef typename I::traits_type Policies;
+    typename Policies::rounding     rnd;
+    T                               one(1);
+    if (x > one)
+        return root_aux<I>(x, k).lower();
+    if (x == one)
+        return one;
+    return rnd.div_down(one, root_aux<I>(rnd.div_up(one, x), k).upper());
+}
+
+template <class I>
+inline // x is positive and k bigger than one
+    typename I::base_type
+    root_aux_up(typename I::base_type const &x, int k)
+{
+    typedef typename I::base_type   T;
+    typedef typename I::traits_type Policies;
+    typename Policies::rounding     rnd;
+    T                               one(1);
+    if (x > one)
+        return root_aux<I>(x, k).upper();
+    if (x == one)
+        return one;
+    return rnd.div_up(one, root_aux<I>(rnd.div_down(one, x), k).lower());
+}
+
+} // namespace detail
+} // namespace interval_lib
+
+template <class T, class Policies> inline interval<T, Policies> nth_root(interval<T, Policies> const &x, int k)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x))
+        return I::empty();
+    assert(k > 0);
+    if (k == 1)
+        return x;
+    typename Policies::rounding                       rnd;
+    typedef typename interval_lib::unprotect<I>::type R;
+    if (!interval_lib::user::is_pos(x.upper())) {
+        if (interval_lib::user::is_zero(x.upper())) {
+            T zero(0);
+            if (!(k & 1) || interval_lib::user::is_zero(x.lower())) // [-1,0]^/2 or [0,0]
+                return I(zero, zero, true);
+            else // [-1,0]^/3
+                return I(-interval_lib::detail::root_aux_up<R>(-x.lower(), k), zero, true);
+        }
+        else if (!(k & 1)) // [-2,-1]^/2
+            return I::empty();
+        else { // [-2,-1]^/3
+            return I(-interval_lib::detail::root_aux_up<R>(-x.lower(), k),
+                     -interval_lib::detail::root_aux_dn<R>(-x.upper(), k),
+                     true);
+        }
+    }
+    T u = interval_lib::detail::root_aux_up<R>(x.upper(), k);
+    if (!interval_lib::user::is_pos(x.lower()))
+        if (!(k & 1) || interval_lib::user::is_zero(x.lower())) // [-1,1]^/2 or [0,1]
+            return I(static_cast<T>(0), u, true);
+        else // [-1,1]^/3
+            return I(-interval_lib::detail::root_aux_up<R>(-x.lower(), k), u, true);
+    else // [1,2]
+        return I(interval_lib::detail::root_aux_dn<R>(x.lower(), k), u, true);
+}
+
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_ARITH2_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/arith3.hpp

@@ -0,0 +1,65 @@
+/* Boost interval/arith3.hpp template implementation file
+ *
+ * This headers provides arithmetical functions
+ * which compute an interval given some base
+ * numbers. The resulting interval encloses the
+ * real result of the arithmetic operation.
+ *
+ * Copyright 2003 Guillaume Melquiond
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_ARITH3_HPP
+#define BOOST_NUMERIC_INTERVAL_ARITH3_HPP
+
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+
+template <class I> inline I add(const typename I::base_type &x, const typename I::base_type &y)
+{
+    typedef typename I::traits_type Policies;
+    if (detail::test_input<typename I::base_type, Policies>(x, y))
+        return I::empty();
+    typename Policies::rounding rnd;
+    return I(rnd.add_down(x, y), rnd.add_up(x, y), true);
+}
+
+template <class I> inline I sub(const typename I::base_type &x, const typename I::base_type &y)
+{
+    typedef typename I::traits_type Policies;
+    if (detail::test_input<typename I::base_type, Policies>(x, y))
+        return I::empty();
+    typename Policies::rounding rnd;
+    return I(rnd.sub_down(x, y), rnd.sub_up(x, y), true);
+}
+
+template <class I> inline I mul(const typename I::base_type &x, const typename I::base_type &y)
+{
+    typedef typename I::traits_type Policies;
+    if (detail::test_input<typename I::base_type, Policies>(x, y))
+        return I::empty();
+    typename Policies::rounding rnd;
+    return I(rnd.mul_down(x, y), rnd.mul_up(x, y), true);
+}
+
+template <class I> inline I div(const typename I::base_type &x, const typename I::base_type &y)
+{
+    typedef typename I::traits_type Policies;
+    if (detail::test_input<typename I::base_type, Policies>(x, y) || user::is_zero(y))
+        return I::empty();
+    typename Policies::rounding rnd;
+    return I(rnd.div_down(x, y), rnd.div_up(x, y), true);
+}
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_ARITH3_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/checking.hpp

@@ -0,0 +1,109 @@
+/* Boost interval/checking.hpp template implementation file
+ *
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_CHECKING_HPP
+#define BOOST_NUMERIC_INTERVAL_CHECKING_HPP
+
+#include <boost/limits.hpp>
+#include <cassert>
+#include <stdexcept>
+#include <string>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+
+struct exception_create_empty
+{
+    void operator()() { throw std::runtime_error("boost::interval: empty interval created"); }
+};
+
+struct exception_invalid_number
+{
+    void operator()() { throw std::invalid_argument("boost::interval: invalid number"); }
+};
+
+template <class T> struct checking_base
+{
+    static T pos_inf()
+    {
+        assert(std::numeric_limits<T>::has_infinity);
+        return std::numeric_limits<T>::infinity();
+    }
+    static T neg_inf()
+    {
+        assert(std::numeric_limits<T>::has_infinity);
+        return -std::numeric_limits<T>::infinity();
+    }
+    static T nan()
+    {
+        assert(std::numeric_limits<T>::has_quiet_NaN);
+        return std::numeric_limits<T>::quiet_NaN();
+    }
+    static bool is_nan(const T &x) { return std::numeric_limits<T>::has_quiet_NaN && (x != x); }
+    static T    empty_lower()
+    {
+        return (std::numeric_limits<T>::has_quiet_NaN ? std::numeric_limits<T>::quiet_NaN() : static_cast<T>(1));
+    }
+    static T empty_upper()
+    {
+        return (std::numeric_limits<T>::has_quiet_NaN ? std::numeric_limits<T>::quiet_NaN() : static_cast<T>(0));
+    }
+    static bool is_empty(const T &l, const T &u)
+    {
+        return !(l <= u); // safety for partial orders
+    }
+};
+
+template <class T, class Checking = checking_base<T>, class Exception = exception_create_empty>
+struct checking_no_empty : Checking
+{
+    static T nan()
+    {
+        assert(false);
+        return Checking::nan();
+    }
+    static T empty_lower()
+    {
+        Exception()();
+        return Checking::empty_lower();
+    }
+    static T empty_upper()
+    {
+        Exception()();
+        return Checking::empty_upper();
+    }
+    static bool is_empty(const T &, const T &) { return false; }
+};
+
+template <class T, class Checking = checking_base<T>> struct checking_no_nan : Checking
+{
+    static bool is_nan(const T &) { return false; }
+};
+
+template <class T, class Checking = checking_base<T>, class Exception = exception_invalid_number>
+struct checking_catch_nan : Checking
+{
+    static bool is_nan(const T &x)
+    {
+        if (Checking::is_nan(x))
+            Exception()();
+        return false;
+    }
+};
+
+template <class T> struct checking_strict : checking_no_nan<T, checking_no_empty<T>>
+{
+};
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_CHECKING_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/compare.hpp

@@ -0,0 +1,19 @@
+/* Boost interval/compare.hpp template implementation file
+ *
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_HPP
+#define BOOST_NUMERIC_INTERVAL_COMPARE_HPP
+
+#include <boost/numeric/interval/compare/certain.hpp>
+#include <boost/numeric/interval/compare/explicit.hpp>
+#include <boost/numeric/interval/compare/lexicographic.hpp>
+#include <boost/numeric/interval/compare/possible.hpp>
+#include <boost/numeric/interval/compare/set.hpp>
+
+#endif // BOOST_NUMERIC_INTERVAL_COMPARE_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/compare/certain.hpp

@@ -0,0 +1,119 @@
+/* Boost interval/compare/certain.hpp template implementation file
+ *
+ * Copyright 2003 Guillaume Melquiond
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_CERTAIN_HPP
+#define BOOST_NUMERIC_INTERVAL_COMPARE_CERTAIN_HPP
+
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace compare {
+namespace certain {
+
+template <class T, class Policies1, class Policies2>
+inline bool operator<(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.upper() < y.lower();
+}
+
+template <class T, class Policies> inline bool operator<(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.upper() < y;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator<=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.upper() <= y.lower();
+}
+
+template <class T, class Policies> inline bool operator<=(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.upper() <= y;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator>(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() > y.upper();
+}
+
+template <class T, class Policies> inline bool operator>(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() > y;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator>=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() >= y.upper();
+}
+
+template <class T, class Policies> inline bool operator>=(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() >= y;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator==(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.upper() == y.lower() && x.lower() == y.upper();
+}
+
+template <class T, class Policies> inline bool operator==(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.upper() == y && x.lower() == y;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator!=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.upper() < y.lower() || x.lower() > y.upper();
+}
+
+template <class T, class Policies> inline bool operator!=(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.upper() < y || x.lower() > y;
+}
+
+} // namespace certain
+} // namespace compare
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_INTERVAL_COMPARE_CERTAIN_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/compare/explicit.hpp

@@ -0,0 +1,224 @@
+/* Boost interval/compare/explicit.hpp template implementation file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_EXPLICIT_HPP
+#define BOOST_NUMERIC_INTERVAL_COMPARE_EXPLICIT_HPP
+
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+
+/*
+ * Certainly... operations
+ */
+
+template <class T, class Policies1, class Policies2>
+inline bool cerlt(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return x.upper() < y.lower();
+}
+
+template <class T, class Policies> inline bool cerlt(const interval<T, Policies> &x, const T &y)
+{
+    return x.upper() < y;
+}
+
+template <class T, class Policies> inline bool cerlt(const T &x, const interval<T, Policies> &y)
+{
+    return x < y.lower();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool cerle(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return x.upper() <= y.lower();
+}
+
+template <class T, class Policies> inline bool cerle(const interval<T, Policies> &x, const T &y)
+{
+    return x.upper() <= y;
+}
+
+template <class T, class Policies> inline bool cerle(const T &x, const interval<T, Policies> &y)
+{
+    return x <= y.lower();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool cergt(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return x.lower() > y.upper();
+}
+
+template <class T, class Policies> inline bool cergt(const interval<T, Policies> &x, const T &y)
+{
+    return x.lower() > y;
+}
+
+template <class T, class Policies> inline bool cergt(const T &x, const interval<T, Policies> &y)
+{
+    return x > y.upper();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool cerge(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return x.lower() >= y.upper();
+}
+
+template <class T, class Policies> inline bool cerge(const interval<T, Policies> &x, const T &y)
+{
+    return x.lower() >= y;
+}
+
+template <class T, class Policies> inline bool cerge(const T &x, const interval<T, Policies> &y)
+{
+    return x >= y.upper();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool cereq(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return x.lower() == y.upper() && y.lower() == x.upper();
+}
+
+template <class T, class Policies> inline bool cereq(const interval<T, Policies> &x, const T &y)
+{
+    return x.lower() == y && x.upper() == y;
+}
+
+template <class T, class Policies> inline bool cereq(const T &x, const interval<T, Policies> &y)
+{
+    return x == y.lower() && x == y.upper();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool cerne(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return x.upper() < y.lower() || y.upper() < x.lower();
+}
+
+template <class T, class Policies> inline bool cerne(const interval<T, Policies> &x, const T &y)
+{
+    return x.upper() < y || y < x.lower();
+}
+
+template <class T, class Policies> inline bool cerne(const T &x, const interval<T, Policies> &y)
+{
+    return x < y.lower() || y.upper() < x;
+}
+
+/*
+ * Possibly... comparisons
+ */
+
+template <class T, class Policies1, class Policies2>
+inline bool poslt(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return x.lower() < y.upper();
+}
+
+template <class T, class Policies> inline bool poslt(const interval<T, Policies> &x, const T &y)
+{
+    return x.lower() < y;
+}
+
+template <class T, class Policies> inline bool poslt(const T &x, const interval<T, Policies> &y)
+{
+    return x < y.upper();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool posle(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return x.lower() <= y.upper();
+}
+
+template <class T, class Policies> inline bool posle(const interval<T, Policies> &x, const T &y)
+{
+    return x.lower() <= y;
+}
+
+template <class T, class Policies> inline bool posle(const T &x, const interval<T, Policies> &y)
+{
+    return x <= y.upper();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool posgt(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return x.upper() > y.lower();
+}
+
+template <class T, class Policies> inline bool posgt(const interval<T, Policies> &x, const T &y)
+{
+    return x.upper() > y;
+}
+
+template <class T, class Policies> inline bool posgt(const T &x, const interval<T, Policies> &y)
+{
+    return x > y.lower();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool posge(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return x.upper() >= y.lower();
+}
+
+template <class T, class Policies> inline bool posge(const interval<T, Policies> &x, const T &y)
+{
+    return x.upper() >= y;
+}
+
+template <class T, class Policies> inline bool posge(const T &x, const interval<T, Policies> &y)
+{
+    return x >= y.lower();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool poseq(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return x.upper() >= y.lower() && y.upper() >= x.lower();
+}
+
+template <class T, class Policies> inline bool poseq(const interval<T, Policies> &x, const T &y)
+{
+    return x.upper() >= y && y >= x.lower();
+}
+
+template <class T, class Policies> inline bool poseq(const T &x, const interval<T, Policies> &y)
+{
+    return x >= y.lower() && y.upper() >= x;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool posne(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return x.upper() != y.lower() || y.upper() != x.lower();
+}
+
+template <class T, class Policies> inline bool posne(const interval<T, Policies> &x, const T &y)
+{
+    return x.upper() != y || y != x.lower();
+}
+
+template <class T, class Policies> inline bool posne(const T &x, const interval<T, Policies> &y)
+{
+    return x != y.lower() || y.upper() != x;
+}
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_COMPARE_EXPLICIT_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/compare/lexicographic.hpp

@@ -0,0 +1,128 @@
+/* Boost interval/compare/lexicographic.hpp template implementation file
+ *
+ * Copyright 2002-2003 Guillaume Melquiond
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_LEXICOGRAPHIC_HPP
+#define BOOST_NUMERIC_INTERVAL_COMPARE_LEXICOGRAPHIC_HPP
+
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace compare {
+namespace lexicographic {
+
+template <class T, class Policies1, class Policies2>
+inline bool operator<(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    const T &xl = x.lower();
+    const T &yl = y.lower();
+    return xl < yl || (xl == yl && x.upper() < y.upper());
+}
+
+template <class T, class Policies> inline bool operator<(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() < y;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator<=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    const T &xl = x.lower();
+    const T &yl = y.lower();
+    return xl < yl || (xl == yl && x.upper() <= y.upper());
+}
+
+template <class T, class Policies> inline bool operator<=(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    const T &xl = x.lower();
+    return xl < y || (xl == y && x.upper() <= y);
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator>(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    const T &xl = x.lower();
+    const T &yl = y.lower();
+    return xl > yl || (xl == yl && x.upper() > y.upper());
+}
+
+template <class T, class Policies> inline bool operator>(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    const T &xl = x.lower();
+    return xl > y || (xl == y && x.upper() > y);
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator>=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    const T &xl = x.lower();
+    const T &yl = y.lower();
+    return xl > yl || (xl == yl && x.upper() >= y.upper());
+}
+
+template <class T, class Policies> inline bool operator>=(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() >= y;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator==(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() == y.lower() && x.upper() == y.upper();
+}
+
+template <class T, class Policies> inline bool operator==(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() == y && x.upper() == y;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator!=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() != y.lower() || x.upper() != y.upper();
+}
+
+template <class T, class Policies> inline bool operator!=(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() != y || x.upper() != y;
+}
+
+} // namespace lexicographic
+} // namespace compare
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_COMPARE_LEXICOGRAPHIC_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/compare/possible.hpp

@@ -0,0 +1,119 @@
+/* Boost interval/compare/possible.hpp template implementation file
+ *
+ * Copyright 2003 Guillaume Melquiond
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_POSSIBLE_HPP
+#define BOOST_NUMERIC_INTERVAL_COMPARE_POSSIBLE_HPP
+
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace compare {
+namespace possible {
+
+template <class T, class Policies1, class Policies2>
+inline bool operator<(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() < y.upper();
+}
+
+template <class T, class Policies> inline bool operator<(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() < y;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator<=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() <= y.upper();
+}
+
+template <class T, class Policies> inline bool operator<=(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() <= y;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator>(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.upper() > y.lower();
+}
+
+template <class T, class Policies> inline bool operator>(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.upper() > y;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator>=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.upper() >= y.lower();
+}
+
+template <class T, class Policies> inline bool operator>=(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.upper() >= y;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator==(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() <= y.upper() && x.upper() >= y.lower();
+}
+
+template <class T, class Policies> inline bool operator==(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() <= y && x.upper() >= y;
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator!=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() != y.upper() || x.upper() != y.lower();
+}
+
+template <class T, class Policies> inline bool operator!=(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    return x.lower() != y || x.upper() != y;
+}
+
+} // namespace possible
+} // namespace compare
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_INTERVAL_COMPARE_POSSIBLE_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/compare/set.hpp

@@ -0,0 +1,95 @@
+/* Boost interval/compare/set.hpp template implementation file
+ *
+ * Copyright 2002-2003 Guillaume Melquiond
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_SET_HPP
+#define BOOST_NUMERIC_INTERVAL_COMPARE_SET_HPP
+
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+#include <boost/numeric/interval/utility.hpp>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace compare {
+namespace set {
+
+template <class T, class Policies1, class Policies2>
+inline bool operator<(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return proper_subset(x, y);
+}
+
+template <class T, class Policies> inline bool operator<(const interval<T, Policies> &x, const T &y)
+{
+    throw comparison_error();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator<=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return subset(x, y);
+}
+
+template <class T, class Policies> inline bool operator<=(const interval<T, Policies> &x, const T &y)
+{
+    throw comparison_error();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator>(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return proper_subset(y, x);
+}
+
+template <class T, class Policies> inline bool operator>(const interval<T, Policies> &x, const T &y)
+{
+    throw comparison_error();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator>=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return subset(y, x);
+}
+
+template <class T, class Policies> inline bool operator>=(const interval<T, Policies> &x, const T &y)
+{
+    throw comparison_error();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator==(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return equal(y, x);
+}
+
+template <class T, class Policies> inline bool operator==(const interval<T, Policies> &x, const T &y)
+{
+    throw comparison_error();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool operator!=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    return !equal(y, x);
+}
+
+template <class T, class Policies> inline bool operator!=(const interval<T, Policies> &x, const T &y)
+{
+    throw comparison_error();
+}
+
+} // namespace set
+} // namespace compare
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_COMPARE_SET_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/compare/tribool.hpp

@@ -0,0 +1,168 @@
+/* Boost interval/compare/tribool.hpp template implementation file
+ *
+ * Copyright 2002-2003 Guillaume Melquiond
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_COMPARE_TRIBOOL_HPP
+#define BOOST_NUMERIC_INTERVAL_COMPARE_TRIBOOL_HPP
+
+#include <boost/logic/tribool.hpp>
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace compare {
+namespace tribool {
+
+template <class T, class Policies1, class Policies2>
+inline logic::tribool operator<(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    if (x.upper() < y.lower())
+        return true;
+    if (x.lower() >= y.upper())
+        return false;
+    return logic::indeterminate;
+}
+
+template <class T, class Policies> inline logic::tribool operator<(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    if (x.upper() < y)
+        return true;
+    if (x.lower() >= y)
+        return false;
+    return logic::indeterminate;
+}
+
+template <class T, class Policies1, class Policies2>
+inline logic::tribool operator<=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    if (x.upper() <= y.lower())
+        return true;
+    if (x.lower() > y.upper())
+        return false;
+    return logic::indeterminate;
+}
+
+template <class T, class Policies> inline logic::tribool operator<=(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    if (x.upper() <= y)
+        return true;
+    if (x.lower() > y)
+        return false;
+    return logic::indeterminate;
+}
+
+template <class T, class Policies1, class Policies2>
+inline logic::tribool operator>(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    if (x.lower() > y.upper())
+        return true;
+    if (x.upper() <= y.lower())
+        return false;
+    return logic::indeterminate;
+}
+
+template <class T, class Policies> inline logic::tribool operator>(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    if (x.lower() > y)
+        return true;
+    if (x.upper() <= y)
+        return false;
+    return logic::indeterminate;
+}
+
+template <class T, class Policies1, class Policies2>
+inline logic::tribool operator>=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    if (x.lower() >= y.upper())
+        return true;
+    if (x.upper() < y.lower())
+        return false;
+    return logic::indeterminate;
+}
+
+template <class T, class Policies> inline logic::tribool operator>=(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    if (x.lower() >= y)
+        return true;
+    if (x.upper() < y)
+        return false;
+    return logic::indeterminate;
+}
+
+template <class T, class Policies1, class Policies2>
+inline logic::tribool operator==(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    if (x.upper() == y.lower() && x.lower() == y.upper())
+        return true;
+    if (x.upper() < y.lower() || x.lower() > y.upper())
+        return false;
+    return logic::indeterminate;
+}
+
+template <class T, class Policies> inline logic::tribool operator==(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    if (x.upper() == y && x.lower() == y)
+        return true;
+    if (x.upper() < y || x.lower() > y)
+        return false;
+    return logic::indeterminate;
+}
+
+template <class T, class Policies1, class Policies2>
+inline logic::tribool operator!=(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    if (x.upper() < y.lower() || x.lower() > y.upper())
+        return true;
+    if (x.upper() == y.lower() && x.lower() == y.upper())
+        return false;
+    return logic::indeterminate;
+}
+
+template <class T, class Policies> inline logic::tribool operator!=(const interval<T, Policies> &x, const T &y)
+{
+    if (detail::test_input(x, y))
+        throw comparison_error();
+    if (x.upper() < y || x.lower() > y)
+        return true;
+    if (x.upper() == y && x.lower() == y)
+        return false;
+    return logic::indeterminate;
+}
+
+} // namespace tribool
+} // namespace compare
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_INTERVAL_COMPARE_TRIBOOL_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/constants.hpp

@@ -0,0 +1,79 @@
+/* Boost interval/constants.hpp template implementation file
+ *
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_CONSTANTS_HPP
+#define BOOST_NUMERIC_INTERVAL_CONSTANTS_HPP
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace constants {
+
+// These constants should be exactly computed.
+// Decimal representations wouldn't do it since the standard doesn't
+// specify the rounding (even nearest) that should be used.
+
+static const float  pi_f_l = 13176794.0f / (1 << 22);
+static const float  pi_f_u = 13176795.0f / (1 << 22);
+static const double pi_d_l = (3373259426.0 + 273688.0 / (1 << 21)) / (1 << 30);
+static const double pi_d_u = (3373259426.0 + 273689.0 / (1 << 21)) / (1 << 30);
+
+template <class T> inline T pi_lower() { return 3; }
+template <class T> inline T pi_upper() { return 4; }
+template <class T> inline T pi_half_lower() { return 1; }
+template <class T> inline T pi_half_upper() { return 2; }
+template <class T> inline T pi_twice_lower() { return 6; }
+template <class T> inline T pi_twice_upper() { return 7; }
+
+template <> inline float pi_lower<float>() { return pi_f_l; }
+template <> inline float pi_upper<float>() { return pi_f_u; }
+template <> inline float pi_half_lower<float>() { return pi_f_l / 2; }
+template <> inline float pi_half_upper<float>() { return pi_f_u / 2; }
+template <> inline float pi_twice_lower<float>() { return pi_f_l * 2; }
+template <> inline float pi_twice_upper<float>() { return pi_f_u * 2; }
+
+template <> inline double pi_lower<double>() { return pi_d_l; }
+template <> inline double pi_upper<double>() { return pi_d_u; }
+template <> inline double pi_half_lower<double>() { return pi_d_l / 2; }
+template <> inline double pi_half_upper<double>() { return pi_d_u / 2; }
+template <> inline double pi_twice_lower<double>() { return pi_d_l * 2; }
+template <> inline double pi_twice_upper<double>() { return pi_d_u * 2; }
+
+template <> inline long double pi_lower<long double>() { return pi_d_l; }
+template <> inline long double pi_upper<long double>() { return pi_d_u; }
+template <> inline long double pi_half_lower<long double>() { return pi_d_l / 2; }
+template <> inline long double pi_half_upper<long double>() { return pi_d_u / 2; }
+template <> inline long double pi_twice_lower<long double>() { return pi_d_l * 2; }
+template <> inline long double pi_twice_upper<long double>() { return pi_d_u * 2; }
+
+} // namespace constants
+
+template <class I> inline I pi()
+{
+    typedef typename I::base_type T;
+    return I(constants::pi_lower<T>(), constants::pi_upper<T>(), true);
+}
+
+template <class I> inline I pi_half()
+{
+    typedef typename I::base_type T;
+    return I(constants::pi_half_lower<T>(), constants::pi_half_upper<T>(), true);
+}
+
+template <class I> inline I pi_twice()
+{
+    typedef typename I::base_type T;
+    return I(constants::pi_twice_lower<T>(), constants::pi_twice_upper<T>(), true);
+}
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_CONSTANTS_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/alpha_rounding_control.hpp

@@ -0,0 +1,110 @@
+/* Boost interval/detail/alpha_rounding_control.hpp file
+ *
+ * Copyright 2005 Felix H<>fling, Guillaume Melquiond
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_ALPHA_ROUNDING_CONTROL_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_ALPHA_ROUNDING_CONTROL_HPP
+
+#if !defined(alpha) && !defined(__alpha__)
+#error This header only works on Alpha CPUs.
+#endif
+
+#if defined(__GNUC__) || defined(__digital__) || defined(__DECCXX)
+
+#include <float.h> // write_rnd() and read_rnd()
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+
+namespace detail {
+#if defined(__GNUC__)
+typedef union
+{
+    ::boost::long_long_type imode;
+    double                  dmode;
+} rounding_mode_struct;
+
+// set bits 59-58 (DYN),
+// clear all exception bits and disable overflow (51) and inexact exceptions (62)
+static const rounding_mode_struct mode_upward      = {0x4C08000000000000LL};
+static const rounding_mode_struct mode_downward    = {0x4408000000000000LL};
+static const rounding_mode_struct mode_to_nearest  = {0x4808000000000000LL};
+static const rounding_mode_struct mode_toward_zero = {0x4008000000000000LL};
+
+struct alpha_rounding_control
+{
+    typedef double rounding_mode;
+
+    static void set_rounding_mode(const rounding_mode mode) { __asm__ __volatile__("mt_fpcr %0" : : "f"(mode)); }
+
+    static void get_rounding_mode(rounding_mode &mode) { __asm__ __volatile__("mf_fpcr %0" : "=f"(mode)); }
+
+    static void downward() { set_rounding_mode(mode_downward.dmode); }
+    static void upward() { set_rounding_mode(mode_upward.dmode); }
+    static void to_nearest() { set_rounding_mode(mode_to_nearest.dmode); }
+    static void toward_zero() { set_rounding_mode(mode_toward_zero.dmode); }
+};
+#elif defined(__digital__) || defined(__DECCXX)
+
+#if defined(__DECCXX) && !(defined(__FLT_ROUNDS) && __FLT_ROUNDS == -1)
+#error Dynamic rounding mode not enabled. See cxx man page for details.
+#endif
+
+struct alpha_rounding_control
+{
+    typedef unsigned int rounding_mode;
+
+    static void set_rounding_mode(const rounding_mode &mode) { write_rnd(mode); }
+    static void get_rounding_mode(rounding_mode &mode) { mode = read_rnd(); }
+
+    static void downward() { set_rounding_mode(FP_RND_RM); }
+    static void upward() { set_rounding_mode(FP_RND_RP); }
+    static void to_nearest() { set_rounding_mode(FP_RND_RN); }
+    static void toward_zero() { set_rounding_mode(FP_RND_RZ); }
+};
+#endif
+} // namespace detail
+
+extern "C"
+{
+    float       rintf(float);
+    double      rint(double);
+    long double rintl(long double);
+}
+
+template <> struct rounding_control<float> : detail::alpha_rounding_control
+{
+    static float force_rounding(const float r)
+    {
+        volatile float _r = r;
+        return _r;
+    }
+    static float to_int(const float &x) { return rintf(x); }
+};
+
+template <> struct rounding_control<double> : detail::alpha_rounding_control
+{
+    static const double &force_rounding(const double &r) { return r; }
+    static double        to_int(const double &r) { return rint(r); }
+};
+
+template <> struct rounding_control<long double> : detail::alpha_rounding_control
+{
+    static const long double &force_rounding(const long double &r) { return r; }
+    static long double        to_int(const long double &r) { return rintl(r); }
+};
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#undef BOOST_NUMERIC_INTERVAL_NO_HARDWARE
+#endif
+
+#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_ALPHA_ROUNDING_CONTROL_HPP */

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/bcc_rounding_control.hpp

@@ -0,0 +1,62 @@
+/* Boost interval/detail/bcc_rounding_control.hpp file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_BCC_ROUNDING_CONTROL_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_BCC_ROUNDING_CONTROL_HPP
+
+#ifndef __BORLANDC__
+#error This header is only intended for Borland C++.
+#endif
+
+#ifndef _M_IX86
+#error This header only works on x86 CPUs.
+#endif
+
+#include <float.h> // Borland C++ rounding control
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace detail {
+
+#ifndef BOOST_NUMERIC_INTERVAL_KEEP_EXCEPTIONS_FOR_BCC
+extern "C"
+{
+    unsigned int _RTLENTRY _fm_init(void);
+}
+
+struct borland_workaround
+{
+    borland_workaround() { _fm_init(); }
+};
+
+static borland_workaround borland_workaround_exec;
+#endif // BOOST_NUMERIC_INTERVAL_KEEP_EXCEPTIONS_FOR_BCC
+
+__inline double rint(double)
+{
+    __emit__(0xD9);
+    __emit__(0xFC); /* asm FRNDINT */
+}
+
+struct x86_rounding
+{
+    typedef unsigned int rounding_mode;
+    static void          get_rounding_mode(rounding_mode &mode) { mode = _control87(0, 0); }
+    static void          set_rounding_mode(const rounding_mode mode) { _control87(mode, 0xffff); }
+    static double        to_int(const double &x) { return rint(x); }
+};
+
+} // namespace detail
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_BCC_ROUNDING_CONTROL_HPP */

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/bugs.hpp

@@ -0,0 +1,80 @@
+/* Boost interval/detail/bugs.hpp file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_BUGS
+#define BOOST_NUMERIC_INTERVAL_DETAIL_BUGS
+
+#include <boost/config.hpp>
+
+#if defined(__GLIBC__) && (defined(__USE_MISC) || defined(__USE_XOPEN_EXTENDED) || defined(__USE_ISOC99)) \
+    && !defined(__ICC)
+#define BOOST_HAS_INV_HYPERBOLIC
+#endif
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+#define BOOST_NUMERIC_INTERVAL_using_math(a) using ::a
+#ifdef BOOST_HAS_INV_HYPERBOLIC
+#define BOOST_NUMERIC_INTERVAL_using_ahyp(a) using ::a
+#endif
+#else
+#define BOOST_NUMERIC_INTERVAL_using_math(a) using std::a
+#if defined(BOOST_HAS_INV_HYPERBOLIC)
+#if defined(__GLIBCPP__) || defined(__GLIBCXX__)
+#define BOOST_NUMERIC_INTERVAL_using_ahyp(a) using ::a
+#else
+#define BOOST_NUMERIC_INTERVAL_using_ahyp(a) using std::a
+#endif
+#endif
+#endif
+
+#if defined(__COMO__) || defined(BOOST_INTEL)
+#define BOOST_NUMERIC_INTERVAL_using_max(a) using std::a
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+#define BOOST_NUMERIC_INTERVAL_using_max(a) using ::a
+#else
+#define BOOST_NUMERIC_INTERVAL_using_max(a) using std::a
+#endif
+
+#ifndef BOOST_NUMERIC_INTERVAL_using_ahyp
+#define BOOST_NUMERIC_INTERVAL_using_ahyp(a)
+#endif
+
+#if defined(__GNUC__) && (__GNUC__ <= 2)
+// cf PR c++/1981 for a description of the bug
+#include <algorithm>
+#include <boost/config/no_tr1/cmath.hpp>
+namespace boost {
+namespace numeric {
+using std::acos;
+using std::asin;
+using std::atan;
+using std::ceil;
+using std::cos;
+using std::cosh;
+using std::exp;
+using std::floor;
+using std::log;
+using std::max;
+using std::min;
+using std::sinh;
+using std::sqrt;
+using std::tan;
+using std::tanh;
+#undef BOOST_NUMERIC_INTERVAL_using_max
+#undef BOOST_NUMERIC_INTERVAL_using_math
+#define BOOST_NUMERIC_INTERVAL_using_max(a)
+#define BOOST_NUMERIC_INTERVAL_using_math(a)
+#undef BOOST_NUMERIC_INTERVAL_using_ahyp
+#define BOOST_NUMERIC_INTERVAL_using_ahyp(a)
+} // namespace numeric
+} // namespace boost
+#endif
+
+#endif // BOOST_NUMERIC_INTERVAL_DETAIL_BUGS

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/c99_rounding_control.hpp

@@ -0,0 +1,50 @@
+/* Boost interval/detail/c99_rounding_control.hpp file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_C99_ROUNDING_CONTROL_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_C99_ROUNDING_CONTROL_HPP
+
+#include <boost/numeric/interval/detail/c99sub_rounding_control.hpp>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace detail {
+
+struct c99_rounding_control : c99_rounding
+{
+    template <class T> static T force_rounding(const T &r)
+    {
+        volatile T r_ = r;
+        return r_;
+    }
+};
+
+} // namespace detail
+
+template <> struct rounding_control<float> : detail::c99_rounding_control
+{
+};
+
+template <> struct rounding_control<double> : detail::c99_rounding_control
+{
+};
+
+template <> struct rounding_control<long double> : detail::c99_rounding_control
+{
+};
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#undef BOOST_NUMERIC_INTERVAL_NO_HARDWARE
+
+#endif // BOOST_NUMERIC_INTERVAL_DETAIL_C99_ROUNDING_CONTROL_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/c99sub_rounding_control.hpp

@@ -0,0 +1,45 @@
+/* Boost interval/detail/c99sub_rounding_control.hpp file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_C99SUB_ROUNDING_CONTROL_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_C99SUB_ROUNDING_CONTROL_HPP
+
+#include <fenv.h> // ISO C 99 rounding mode control
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace detail {
+
+extern "C"
+{
+    double rint(double);
+}
+
+struct c99_rounding
+{
+    typedef int rounding_mode;
+
+    static void set_rounding_mode(const rounding_mode mode) { fesetround(mode); }
+    static void get_rounding_mode(rounding_mode &mode) { mode = fegetround(); }
+    static void downward() { set_rounding_mode(FE_DOWNWARD); }
+    static void upward() { set_rounding_mode(FE_UPWARD); }
+    static void to_nearest() { set_rounding_mode(FE_TONEAREST); }
+    static void toward_zero() { set_rounding_mode(FE_TOWARDZERO); }
+
+    template <class T> static T to_int(const T &r) { return rint(r); }
+};
+
+} // namespace detail
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_DETAIL_C99SUB_ROUBDING_CONTROL_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/division.hpp

@@ -0,0 +1,198 @@
+/* Boost interval/detail/division.hpp file
+ *
+ * Copyright 2003 Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_DIVISION_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_DIVISION_HPP
+
+#include <algorithm>
+#include <boost/numeric/interval/detail/bugs.hpp>
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+#include <boost/numeric/interval/rounded_arith.hpp>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace detail {
+
+template <class T, class Policies>
+inline interval<T, Policies> div_non_zero(const interval<T, Policies> &x, const interval<T, Policies> &y)
+{
+    // assert(!in_zero(y));
+    typename Policies::rounding   rnd;
+    typedef interval<T, Policies> I;
+    const T                      &xl = x.lower();
+    const T                      &xu = x.upper();
+    const T                      &yl = y.lower();
+    const T                      &yu = y.upper();
+    if (::boost::numeric::interval_lib::user::is_neg(xu))
+        if (::boost::numeric::interval_lib::user::is_neg(yu))
+            return I(rnd.div_down(xu, yl), rnd.div_up(xl, yu), true);
+        else
+            return I(rnd.div_down(xl, yl), rnd.div_up(xu, yu), true);
+    else if (::boost::numeric::interval_lib::user::is_neg(xl))
+        if (::boost::numeric::interval_lib::user::is_neg(yu))
+            return I(rnd.div_down(xu, yu), rnd.div_up(xl, yu), true);
+        else
+            return I(rnd.div_down(xl, yl), rnd.div_up(xu, yl), true);
+    else if (::boost::numeric::interval_lib::user::is_neg(yu))
+        return I(rnd.div_down(xu, yu), rnd.div_up(xl, yl), true);
+    else
+        return I(rnd.div_down(xl, yu), rnd.div_up(xu, yl), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> div_non_zero(const T &x, const interval<T, Policies> &y)
+{
+    // assert(!in_zero(y));
+    typename Policies::rounding   rnd;
+    typedef interval<T, Policies> I;
+    const T                      &yl = y.lower();
+    const T                      &yu = y.upper();
+    if (::boost::numeric::interval_lib::user::is_neg(x))
+        return I(rnd.div_down(x, yl), rnd.div_up(x, yu), true);
+    else
+        return I(rnd.div_down(x, yu), rnd.div_up(x, yl), true);
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> div_positive(const interval<T, Policies> &x, const T &yu)
+{
+    // assert(::boost::numeric::interval_lib::user::is_pos(yu));
+    if (::boost::numeric::interval_lib::user::is_zero(x.lower())
+        && ::boost::numeric::interval_lib::user::is_zero(x.upper()))
+        return x;
+    typename Policies::rounding         rnd;
+    typedef interval<T, Policies>       I;
+    const T                            &xl = x.lower();
+    const T                            &xu = x.upper();
+    typedef typename Policies::checking checking;
+    if (::boost::numeric::interval_lib::user::is_neg(xu))
+        return I(checking::neg_inf(), rnd.div_up(xu, yu), true);
+    else if (::boost::numeric::interval_lib::user::is_neg(xl))
+        return I(checking::neg_inf(), checking::pos_inf(), true);
+    else
+        return I(rnd.div_down(xl, yu), checking::pos_inf(), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> div_positive(const T &x, const T &yu)
+{
+    // assert(::boost::numeric::interval_lib::user::is_pos(yu));
+    typedef interval<T, Policies> I;
+    if (::boost::numeric::interval_lib::user::is_zero(x))
+        return I(static_cast<T>(0), static_cast<T>(0), true);
+    typename Policies::rounding         rnd;
+    typedef typename Policies::checking checking;
+    if (::boost::numeric::interval_lib::user::is_neg(x))
+        return I(checking::neg_inf(), rnd.div_up(x, yu), true);
+    else
+        return I(rnd.div_down(x, yu), checking::pos_inf(), true);
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> div_negative(const interval<T, Policies> &x, const T &yl)
+{
+    // assert(::boost::numeric::interval_lib::user::is_neg(yl));
+    if (::boost::numeric::interval_lib::user::is_zero(x.lower())
+        && ::boost::numeric::interval_lib::user::is_zero(x.upper()))
+        return x;
+    typename Policies::rounding         rnd;
+    typedef interval<T, Policies>       I;
+    const T                            &xl = x.lower();
+    const T                            &xu = x.upper();
+    typedef typename Policies::checking checking;
+    if (::boost::numeric::interval_lib::user::is_neg(xu))
+        return I(rnd.div_down(xu, yl), checking::pos_inf(), true);
+    else if (::boost::numeric::interval_lib::user::is_neg(xl))
+        return I(checking::neg_inf(), checking::pos_inf(), true);
+    else
+        return I(checking::neg_inf(), rnd.div_up(xl, yl), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> div_negative(const T &x, const T &yl)
+{
+    // assert(::boost::numeric::interval_lib::user::is_neg(yl));
+    typedef interval<T, Policies> I;
+    if (::boost::numeric::interval_lib::user::is_zero(x))
+        return I(static_cast<T>(0), static_cast<T>(0), true);
+    typename Policies::rounding         rnd;
+    typedef typename Policies::checking checking;
+    if (::boost::numeric::interval_lib::user::is_neg(x))
+        return I(rnd.div_down(x, yl), checking::pos_inf(), true);
+    else
+        return I(checking::neg_inf(), rnd.div_up(x, yl), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> div_zero(const interval<T, Policies> &x)
+{
+    if (::boost::numeric::interval_lib::user::is_zero(x.lower())
+        && ::boost::numeric::interval_lib::user::is_zero(x.upper()))
+        return x;
+    else
+        return interval<T, Policies>::whole();
+}
+
+template <class T, class Policies> inline interval<T, Policies> div_zero(const T &x)
+{
+    if (::boost::numeric::interval_lib::user::is_zero(x))
+        return interval<T, Policies>(static_cast<T>(0), static_cast<T>(0), true);
+    else
+        return interval<T, Policies>::whole();
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> div_zero_part1(const interval<T, Policies> &x, const interval<T, Policies> &y, bool &b)
+{
+    // assert(::boost::numeric::interval_lib::user::is_neg(y.lower()) &&
+    // ::boost::numeric::interval_lib::user::is_pos(y.upper()));
+    if (::boost::numeric::interval_lib::user::is_zero(x.lower())
+        && ::boost::numeric::interval_lib::user::is_zero(x.upper())) {
+        b = false;
+        return x;
+    }
+    typename Policies::rounding         rnd;
+    typedef interval<T, Policies>       I;
+    const T                            &xl = x.lower();
+    const T                            &xu = x.upper();
+    const T                            &yl = y.lower();
+    const T                            &yu = y.upper();
+    typedef typename Policies::checking checking;
+    if (::boost::numeric::interval_lib::user::is_neg(xu)) {
+        b = true;
+        return I(checking::neg_inf(), rnd.div_up(xu, yu), true);
+    }
+    else if (::boost::numeric::interval_lib::user::is_neg(xl)) {
+        b = false;
+        return I(checking::neg_inf(), checking::pos_inf(), true);
+    }
+    else {
+        b = true;
+        return I(checking::neg_inf(), rnd.div_up(xl, yl), true);
+    }
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> div_zero_part2(const interval<T, Policies> &x, const interval<T, Policies> &y)
+{
+    // assert(::boost::numeric::interval_lib::user::is_neg(y.lower()) &&
+    // ::boost::numeric::interval_lib::user::is_pos(y.upper()) && (div_zero_part1(x, y, b), b));
+    typename Policies::rounding         rnd;
+    typedef interval<T, Policies>       I;
+    typedef typename Policies::checking checking;
+    if (::boost::numeric::interval_lib::user::is_neg(x.upper()))
+        return I(rnd.div_down(x.upper(), y.lower()), checking::pos_inf(), true);
+    else
+        return I(rnd.div_down(x.lower(), y.upper()), checking::pos_inf(), true);
+}
+
+} // namespace detail
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_DETAIL_DIVISION_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/ia64_rounding_control.hpp

@@ -0,0 +1,79 @@
+/* Boost interval/detail/ia64_rounding_control.hpp file
+ *
+ * Copyright 2006-2007 Boris Gubenko
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_IA64_ROUNDING_CONTROL_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_IA64_ROUNDING_CONTROL_HPP
+
+#if !defined(ia64) && !defined(__ia64) && !defined(__ia64__)
+#error This header only works on ia64 CPUs.
+#endif
+
+#if defined(__hpux)
+
+#include <fenv.h>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace detail {
+
+
+struct ia64_rounding_control
+{
+    typedef unsigned int rounding_mode;
+
+    static void set_rounding_mode(const rounding_mode &mode) { fesetround(mode); }
+    static void get_rounding_mode(rounding_mode &mode) { mode = fegetround(); }
+
+    static void downward() { set_rounding_mode(FE_DOWNWARD); }
+    static void upward() { set_rounding_mode(FE_UPWARD); }
+    static void to_nearest() { set_rounding_mode(FE_TONEAREST); }
+    static void toward_zero() { set_rounding_mode(FE_TOWARDZERO); }
+};
+
+} // namespace detail
+
+extern "C"
+{
+    float       rintf(float);
+    double      rint(double);
+    long double rintl(long double);
+}
+
+template <> struct rounding_control<float> : detail::ia64_rounding_control
+{
+    static float force_rounding(const float r)
+    {
+        volatile float _r = r;
+        return _r;
+    }
+    static float to_int(const float &x) { return rintf(x); }
+};
+
+template <> struct rounding_control<double> : detail::ia64_rounding_control
+{
+    static const double &force_rounding(const double &r) { return r; }
+    static double        to_int(const double &r) { return rint(r); }
+};
+
+template <> struct rounding_control<long double> : detail::ia64_rounding_control
+{
+    static const long double &force_rounding(const long double &r) { return r; }
+    static long double        to_int(const long double &r) { return rintl(r); }
+};
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#undef BOOST_NUMERIC_INTERVAL_NO_HARDWARE
+
+#endif /* __hpux */
+
+#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_IA64_ROUNDING_CONTROL_HPP */

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/interval_prototype.hpp

@@ -0,0 +1,39 @@
+/* Boost interval/detail/interval_prototype.hpp file
+ *
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_INTERVAL_PROTOTYPE_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_INTERVAL_PROTOTYPE_HPP
+
+namespace boost {
+namespace numeric {
+
+namespace interval_lib {
+
+template <class T> struct rounded_math;
+template <class T> struct checking_strict;
+class comparison_error;
+template <class Rounding, class Checking> struct policies;
+
+/*
+ * default policies class
+ */
+
+template <class T> struct default_policies
+{
+    typedef policies<rounded_math<T>, checking_strict<T>> type;
+};
+
+} // namespace interval_lib
+
+template <class T, class Policies = typename interval_lib::default_policies<T>::type> class interval;
+
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_DETAIL_INTERVAL_PROTOTYPE_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/msvc_rounding_control.hpp

@@ -0,0 +1,152 @@
+/* Boost interval/detail/msvc_rounding_control.hpp file
+ *
+ * Copyright 2000 Maarten Keijzer
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_MSVC_ROUNDING_CONTROL_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_MSVC_ROUNDING_CONTROL_HPP
+
+#ifndef _MSC_VER
+#error This header is only intended for MSVC, but might work for Borland as well
+#endif
+
+#include <float.h> // MSVC rounding control
+
+// Although the function is called _control87, it seems to work for
+// other FPUs too, so it does not have to be changed to _controlfp.
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace detail {
+
+extern "C"
+{
+    double rint(double);
+}
+
+struct x86_rounding
+{
+    static unsigned int hard2msvc(unsigned short m)
+    {
+        unsigned int n = 0;
+        if (m & 0x01)
+            n |= _EM_INVALID;
+        if (m & 0x02)
+            n |= _EM_DENORMAL;
+        if (m & 0x04)
+            n |= _EM_ZERODIVIDE;
+        if (m & 0x08)
+            n |= _EM_OVERFLOW;
+        if (m & 0x10)
+            n |= _EM_UNDERFLOW;
+        if (m & 0x20)
+            n |= _EM_INEXACT;
+        switch (m & 0x300) {
+        case 0x000:
+            n |= _PC_24;
+            break;
+        case 0x200:
+            n |= _PC_53;
+            break;
+        case 0x300:
+            n |= _PC_64;
+            break;
+        }
+        switch (m & 0xC00) {
+        case 0x000:
+            n |= _RC_NEAR;
+            break;
+        case 0x400:
+            n |= _RC_DOWN;
+            break;
+        case 0x800:
+            n |= _RC_UP;
+            break;
+        case 0xC00:
+            n |= _RC_CHOP;
+            break;
+        }
+        if (m & 0x1000)
+            n |= _IC_AFFINE; // only useful on 287
+        return n;
+    }
+
+    static unsigned short msvc2hard(unsigned int n)
+    {
+        unsigned short m = 0;
+        if (n & _EM_INVALID)
+            m |= 0x01;
+        if (n & _EM_DENORMAL)
+            m |= 0x02;
+        if (n & _EM_ZERODIVIDE)
+            m |= 0x04;
+        if (n & _EM_OVERFLOW)
+            m |= 0x08;
+        if (n & _EM_UNDERFLOW)
+            m |= 0x10;
+        if (n & _EM_INEXACT)
+            m |= 0x20;
+        switch (n & _MCW_RC) {
+        case _RC_NEAR:
+            m |= 0x000;
+            break;
+        case _RC_DOWN:
+            m |= 0x400;
+            break;
+        case _RC_UP:
+            m |= 0x800;
+            break;
+        case _RC_CHOP:
+            m |= 0xC00;
+            break;
+        }
+        switch (n & _MCW_PC) {
+        case _PC_24:
+            m |= 0x000;
+            break;
+        case _PC_53:
+            m |= 0x200;
+            break;
+        case _PC_64:
+            m |= 0x300;
+            break;
+        }
+        if ((n & _MCW_IC) == _IC_AFFINE)
+            m |= 0x1000;
+        return m;
+    }
+
+    typedef unsigned short rounding_mode;
+    static void            get_rounding_mode(rounding_mode &mode) { mode = msvc2hard(_control87(0, 0)); }
+    static void            set_rounding_mode(const rounding_mode mode)
+    {
+        _control87(hard2msvc(mode),
+                   _MCW_EM
+                       | _MCW_RC
+// This is updated as per fix in boost 1.58
+#if !defined(_M_AMD64) && !defined(_M_ARM)
+                       // x64 ignores _MCW_PC and _MCW_IC, and the Debug CRT library actually
+                       // asserts when these are passed to _control87.
+                       // MSDN says on '_control87' that changing precision (_MCW_PC) or
+                       // infinity (_MCW_IC) handling is not supported on the ARM and x64
+                       // architectures and that _control87 raises an assertion
+                       // and the invalid parameter handler is invoked.
+                       | _MCW_PC | _MCW_IC
+#endif
+        );
+    }
+    static double to_int(const double &x) { return rint(x); }
+};
+
+} // namespace detail
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_MSVC_ROUNDING_CONTROL_HPP */

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/ppc_rounding_control.hpp

@@ -0,0 +1,93 @@
+/* Boost interval/detail/ppc_rounding_control.hpp file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2005 Guillaume Melquiond
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_PPC_ROUNDING_CONTROL_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_PPC_ROUNDING_CONTROL_HPP
+
+#if !defined(powerpc) && !defined(__powerpc__) && !defined(__ppc__)
+#error This header only works on PPC CPUs.
+#endif
+
+#if defined(__GNUC__) || (__IBMCPP__ >= 700)
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace detail {
+
+typedef union
+{
+    ::boost::long_long_type imode;
+    double                  dmode;
+} rounding_mode_struct;
+
+static const rounding_mode_struct mode_upward      = {static_cast<boost::long_long_type>(0xFFF8000000000002LL)};
+static const rounding_mode_struct mode_downward    = {static_cast<boost::long_long_type>(0xFFF8000000000003LL)};
+static const rounding_mode_struct mode_to_nearest  = {static_cast<boost::long_long_type>(0xFFF8000000000000LL)};
+static const rounding_mode_struct mode_toward_zero = {static_cast<boost::long_long_type>(0xFFF8000000000001LL)};
+
+struct ppc_rounding_control
+{
+    typedef double rounding_mode;
+
+    static void set_rounding_mode(const rounding_mode mode) { __asm__ __volatile__("mtfsf 255,%0" : : "f"(mode)); }
+
+    static void get_rounding_mode(rounding_mode &mode) { __asm__ __volatile__("mffs %0" : "=f"(mode)); }
+
+    static void downward() { set_rounding_mode(mode_downward.dmode); }
+    static void upward() { set_rounding_mode(mode_upward.dmode); }
+    static void to_nearest() { set_rounding_mode(mode_to_nearest.dmode); }
+    static void toward_zero() { set_rounding_mode(mode_toward_zero.dmode); }
+};
+
+} // namespace detail
+
+// Do not declare the following C99 symbols if <math.h> provides them.
+// Otherwise, conflicts may occur, due to differences between prototypes.
+#if !defined(_ISOC99_SOURCE) && !defined(__USE_ISOC99)
+extern "C"
+{
+    float  rintf(float);
+    double rint(double);
+}
+#endif
+
+template <> struct rounding_control<float> : detail::ppc_rounding_control
+{
+    static float force_rounding(const float r)
+    {
+        float tmp;
+        __asm__ __volatile__("frsp %0, %1" : "=f"(tmp) : "f"(r));
+        return tmp;
+    }
+    static float to_int(const float &x) { return rintf(x); }
+};
+
+template <> struct rounding_control<double> : detail::ppc_rounding_control
+{
+    static const double &force_rounding(const double &r) { return r; }
+    static double        to_int(const double &r) { return rint(r); }
+};
+
+template <> struct rounding_control<long double> : detail::ppc_rounding_control
+{
+    static const long double &force_rounding(const long double &r) { return r; }
+    static long double        to_int(const long double &r) { return rint(static_cast<double>(r)); }
+};
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#undef BOOST_NUMERIC_INTERVAL_NO_HARDWARE
+#endif
+
+#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_PPC_ROUNDING_CONTROL_HPP */

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/sparc_rounding_control.hpp

@@ -0,0 +1,107 @@
+/* Boost interval/detail/sparc_rounding_control.hpp file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * The basic code in this file was kindly provided by Jeremy Siek.
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_SPARC_ROUNDING_CONTROL_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_SPARC_ROUNDING_CONTROL_HPP
+
+#if !defined(sparc) && !defined(__sparc__)
+#error This header is only intended for SPARC CPUs.
+#endif
+
+#ifdef __SUNPRO_CC
+#include <ieeefp.h>
+#endif
+
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace detail {
+
+struct sparc_rounding_control
+{
+    typedef unsigned int rounding_mode;
+
+    static void set_rounding_mode(const rounding_mode &mode)
+    {
+#if defined(__GNUC__)
+        __asm__ __volatile__("ld %0, %%fsr" : : "m"(mode));
+#elif defined(__SUNPRO_CC)
+        fpsetround(fp_rnd(mode));
+#elif defined(__KCC)
+        asm("sethi %hi(mode), %o1");
+        asm("ld [%o1+%lo(mode)], %fsr");
+#else
+#error Unsupported compiler for Sparc rounding control.
+#endif
+    }
+
+    static void get_rounding_mode(rounding_mode &mode)
+    {
+#if defined(__GNUC__)
+        __asm__ __volatile__("st %%fsr, %0" : "=m"(mode));
+#elif defined(__SUNPRO_CC)
+        mode = fpgetround();
+#elif defined(__KCC)
+#error KCC on Sun SPARC get_round_mode: please fix me
+        asm("st %fsr, [mode]");
+#else
+#error Unsupported compiler for Sparc rounding control.
+#endif
+    }
+
+#if defined(__SUNPRO_CC)
+    static void downward() { set_rounding_mode(FP_RM); }
+    static void upward() { set_rounding_mode(FP_RP); }
+    static void to_nearest() { set_rounding_mode(FP_RN); }
+    static void toward_zero() { set_rounding_mode(FP_RZ); }
+#else
+    static void downward() { set_rounding_mode(0xc0000000); }
+    static void upward() { set_rounding_mode(0x80000000); }
+    static void to_nearest() { set_rounding_mode(0x00000000); }
+    static void toward_zero() { set_rounding_mode(0x40000000); }
+#endif
+};
+
+} // namespace detail
+
+extern "C"
+{
+    float  rintf(float);
+    double rint(double);
+}
+
+template <> struct rounding_control<float> : detail::sparc_rounding_control
+{
+    static const float &force_rounding(const float &x) { return x; }
+    static float        to_int(const float &x) { return rintf(x); }
+};
+
+template <> struct rounding_control<double> : detail::sparc_rounding_control
+{
+    static const double &force_rounding(const double &x) { return x; }
+    static double        to_int(const double &x) { return rint(x); }
+};
+
+template <> struct rounding_control<long double> : detail::sparc_rounding_control
+{
+    static const long double &force_rounding(const long double &x) { return x; }
+    static long double        to_int(const long double &x) { return rint(x); }
+};
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#undef BOOST_NUMERIC_INTERVAL_NO_HARDWARE
+
+#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_SPARC_ROUNDING_CONTROL_HPP */

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/test_input.hpp

@@ -0,0 +1,73 @@
+/* Boost interval/detail/test_input.hpp file
+ *
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_TEST_INPUT_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_TEST_INPUT_HPP
+
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace user {
+
+template <class T> inline bool is_zero(T const &v) { return v == static_cast<T>(0); }
+
+template <class T> inline bool is_neg(T const &v) { return v < static_cast<T>(0); }
+
+template <class T> inline bool is_pos(T const &v) { return v > static_cast<T>(0); }
+
+} // namespace user
+
+namespace detail {
+
+template <class T, class Policies> inline bool test_input(const interval<T, Policies> &x)
+{
+    typedef typename Policies::checking checking;
+    return checking::is_empty(x.lower(), x.upper());
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool test_input(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    typedef typename Policies1::checking checking1;
+    typedef typename Policies2::checking checking2;
+    return checking1::is_empty(x.lower(), x.upper()) || checking2::is_empty(y.lower(), y.upper());
+}
+
+template <class T, class Policies> inline bool test_input(const T &x, const interval<T, Policies> &y)
+{
+    typedef typename Policies::checking checking;
+    return checking::is_nan(x) || checking::is_empty(y.lower(), y.upper());
+}
+
+template <class T, class Policies> inline bool test_input(const interval<T, Policies> &x, const T &y)
+{
+    typedef typename Policies::checking checking;
+    return checking::is_empty(x.lower(), x.upper()) || checking::is_nan(y);
+}
+
+template <class T, class Policies> inline bool test_input(const T &x)
+{
+    typedef typename Policies::checking checking;
+    return checking::is_nan(x);
+}
+
+template <class T, class Policies> inline bool test_input(const T &x, const T &y)
+{
+    typedef typename Policies::checking checking;
+    return checking::is_nan(x) || checking::is_nan(y);
+}
+
+} // namespace detail
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_DETAIL_TEST_INPUT_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/x86_rounding_control.hpp

@@ -0,0 +1,110 @@
+/* Boost interval/detail/x86_rounding_control.hpp file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_X86_ROUNDING_CONTROL_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_X86_ROUNDING_CONTROL_HPP
+
+#ifdef __GNUC__
+#include <boost/numeric/interval/detail/x86gcc_rounding_control.hpp>
+#elif defined(__BORLANDC__)
+#include <boost/numeric/interval/detail/bcc_rounding_control.hpp>
+#elif defined(_MSC_VER)
+#include <boost/numeric/interval/detail/msvc_rounding_control.hpp>
+#elif defined(__MWERKS__) || defined(__ICC)
+#define BOOST_NUMERIC_INTERVAL_USE_C99_SUBSYSTEM
+#include <boost/numeric/interval/detail/c99sub_rounding_control.hpp>
+#else
+#error Unsupported C++ compiler.
+#endif
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+
+namespace detail {
+
+#ifdef BOOST_NUMERIC_INTERVAL_USE_C99_SUBSYSTEM
+typedef c99_rounding x86_rounding_control;
+#undef BOOST_NUMERIC_INTERVAL_USE_C99_SUBSYSTEM
+#else
+struct fpu_rounding_modes
+{
+    unsigned short to_nearest;
+    unsigned short downward;
+    unsigned short upward;
+    unsigned short toward_zero;
+};
+
+// exceptions masked, extended precision
+// hardware default is 0x037f (0x1000 only has a meaning on 287)
+static const fpu_rounding_modes rnd_mode = {0x137f, 0x177f, 0x1b7f, 0x1f7f};
+
+struct x86_rounding_control : x86_rounding
+{
+    static void to_nearest() { set_rounding_mode(rnd_mode.to_nearest); }
+    static void downward() { set_rounding_mode(rnd_mode.downward); }
+    static void upward() { set_rounding_mode(rnd_mode.upward); }
+    static void toward_zero() { set_rounding_mode(rnd_mode.toward_zero); }
+};
+#endif // BOOST_NUMERIC_INTERVAL_USE_C99_SUBSYSTEM
+
+} // namespace detail
+
+template <> struct rounding_control<float> : detail::x86_rounding_control
+{
+    static float force_rounding(const float &r)
+    {
+        volatile float r_ = r;
+        return r_;
+    }
+};
+
+template <> struct rounding_control<double> : detail::x86_rounding_control
+{
+    /*static double force_rounding(double r)
+    { asm volatile ("" : "+m"(r) : ); return r; }*/
+    static double force_rounding(const double &r)
+    {
+        volatile double r_ = r;
+        return r_;
+    }
+};
+
+namespace detail {
+
+template <bool> struct x86_rounding_control_long_double;
+
+template <> struct x86_rounding_control_long_double<false> : x86_rounding_control
+{
+    static long double force_rounding(long double const &r)
+    {
+        volatile long double r_ = r;
+        return r_;
+    }
+};
+
+template <> struct x86_rounding_control_long_double<true> : x86_rounding_control
+{
+    static long double const &force_rounding(long double const &r) { return r; }
+};
+
+} // namespace detail
+
+template <> struct rounding_control<long double> : detail::x86_rounding_control_long_double<(sizeof(long double) >= 10)>
+{
+};
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#undef BOOST_NUMERIC_INTERVAL_NO_HARDWARE
+
+#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_X86_ROUNDING_CONTROL_HPP */

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/detail/x86gcc_rounding_control.hpp

@@ -0,0 +1,48 @@
+/* Boost interval/detail/x86gcc_rounding_control.hpp file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_DETAIL_X86GCC_ROUNDING_CONTROL_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_X86GCC_ROUNDING_CONTROL_HPP
+
+#ifndef __GNUC__
+#error This header only works with GNU CC.
+#endif
+
+#ifndef __i386__
+#error This header only works on x86 CPUs.
+#endif
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+namespace detail {
+
+struct x86_rounding
+{
+    typedef unsigned short rounding_mode;
+
+    static void set_rounding_mode(const rounding_mode &mode) { __asm__ __volatile__("fldcw %0" : : "m"(mode)); }
+
+    static void get_rounding_mode(rounding_mode &mode) { __asm__ __volatile__("fnstcw %0" : "=m"(mode)); }
+
+    template <class T> static T to_int(T r)
+    {
+        T r_;
+        __asm__("frndint" : "=&t"(r_) : "0"(r));
+        return r_;
+    }
+};
+
+} // namespace detail
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif /* BOOST_NUMERIC_INTERVAL_DETAIL_X86GCC_ROUNDING_CONTROL_HPP */

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/ext/integer.hpp

@@ -0,0 +1,62 @@
+/* Boost interval/ext/integer.hpp template implementation file
+ *
+ * Copyright 2003 Guillaume Melquiond
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_EXT_INTEGER_HPP
+#define BOOST_NUMERIC_INTERVAL_EXT_INTEGER_HPP
+
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+
+namespace boost {
+namespace numeric {
+
+template <class T, class Policies> inline interval<T, Policies> operator+(const interval<T, Policies> &x, int y)
+{
+    return x + static_cast<T>(y);
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator+(int x, const interval<T, Policies> &y)
+{
+    return static_cast<T>(x) + y;
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator-(const interval<T, Policies> &x, int y)
+{
+    return x - static_cast<T>(y);
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator-(int x, const interval<T, Policies> &y)
+{
+    return static_cast<T>(x) - y;
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator*(const interval<T, Policies> &x, int y)
+{
+    return x * static_cast<T>(y);
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator*(int x, const interval<T, Policies> &y)
+{
+    return static_cast<T>(x) * y;
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator/(const interval<T, Policies> &x, int y)
+{
+    return x / static_cast<T>(y);
+}
+
+template <class T, class Policies> inline interval<T, Policies> operator/(int x, const interval<T, Policies> &y)
+{
+    return static_cast<T>(x) / y;
+}
+
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_EXT_INTEGER_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/ext/x86_fast_rounding_control.hpp

@@ -0,0 +1,66 @@
+/* Boost interval/detail/x86gcc_rounding_control.hpp file
+ *
+ * This header provides a rounding control policy
+ * that avoids flushing results to memory. In
+ * order for this optimization to be reliable, it
+ * should be used only when no underflow or
+ * overflow would happen without it. Indeed, only
+ * values in range are correctly rounded.
+ *
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_EXT_X86_FAST_ROUNDING_CONTROL_HPP
+#define BOOST_NUMERIC_INTERVAL_EXT_X86_FAST_ROUNDING_CONTROL_HPP
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+
+namespace detail {
+
+// exceptions masked, expected precision (the mask is 0x0300)
+static const fpu_rounding_modes rnd_mode_f = {0x107f, 0x147f, 0x187f, 0x1c7f};
+static const fpu_rounding_modes rnd_mode_d = {0x127f, 0x167f, 0x1a7f, 0x1e7f};
+static const fpu_rounding_modes rnd_mode_l = {0x137f, 0x177f, 0x1b7f, 0x1f7f};
+
+} // namespace detail
+
+template <class T> struct x86_fast_rounding_control;
+
+template <> struct x86_fast_rounding_control<float> : detail::x86_rounding
+{
+    static void         to_nearest() { set_rounding_mode(detail::rnd_mode_f.to_nearest); }
+    static void         downward() { set_rounding_mode(detail::rnd_mode_f.downward); }
+    static void         upward() { set_rounding_mode(detail::rnd_mode_f.upward); }
+    static void         toward_zero() { set_rounding_mode(detail::rnd_mode_f.toward_zero); }
+    static const float &force_rounding(const float &r) { return r; }
+};
+
+template <> struct x86_fast_rounding_control<double> : detail::x86_rounding
+{
+    static void          to_nearest() { set_rounding_mode(detail::rnd_mode_d.to_nearest); }
+    static void          downward() { set_rounding_mode(detail::rnd_mode_d.downward); }
+    static void          upward() { set_rounding_mode(detail::rnd_mode_d.upward); }
+    static void          toward_zero() { set_rounding_mode(detail::rnd_mode_d.toward_zero); }
+    static const double &force_rounding(const double &r) { return r; }
+};
+
+template <> struct x86_fast_rounding_control<long double> : detail::x86_rounding
+{
+    static void               to_nearest() { set_rounding_mode(detail::rnd_mode_l.to_nearest); }
+    static void               downward() { set_rounding_mode(detail::rnd_mode_l.downward); }
+    static void               upward() { set_rounding_mode(detail::rnd_mode_l.upward); }
+    static void               toward_zero() { set_rounding_mode(detail::rnd_mode_l.toward_zero); }
+    static const long double &force_rounding(const long double &r) { return r; }
+};
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_EXT_X86_FAST_ROUNDING_CONTROL_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/hw_rounding.hpp

@@ -0,0 +1,67 @@
+/* Boost interval/hw_rounding.hpp template implementation file
+ *
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2005 Guillaume Melquiond
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_HW_ROUNDING_HPP
+#define BOOST_NUMERIC_INTERVAL_HW_ROUNDING_HPP
+
+#include <boost/numeric/interval/rounded_arith.hpp>
+#include <boost/numeric/interval/rounding.hpp>
+
+#define BOOST_NUMERIC_INTERVAL_NO_HARDWARE
+
+// define appropriate specialization of rounding_control for built-in types
+#if defined(__x86_64__) && defined(__USE_ISOC99)
+#include <boost/numeric/interval/detail/c99_rounding_control.hpp>
+#elif defined(__i386__) || defined(_M_IX86) || defined(__BORLANDC__) || defined(_M_X64)
+#include <boost/numeric/interval/detail/x86_rounding_control.hpp>
+#elif defined(powerpc) || defined(__powerpc__) || defined(__ppc__)
+#include <boost/numeric/interval/detail/ppc_rounding_control.hpp>
+#elif defined(sparc) || defined(__sparc__)
+#include <boost/numeric/interval/detail/sparc_rounding_control.hpp>
+#elif defined(alpha) || defined(__alpha__)
+#include <boost/numeric/interval/detail/alpha_rounding_control.hpp>
+#elif defined(ia64) || defined(__ia64) || defined(__ia64__)
+#include <boost/numeric/interval/detail/ia64_rounding_control.hpp>
+#endif
+
+#if defined(BOOST_NUMERIC_INTERVAL_NO_HARDWARE) && (defined(__USE_ISOC99) || defined(__MSL__))
+#include <boost/numeric/interval/detail/c99_rounding_control.hpp>
+#endif
+
+#if defined(BOOST_NUMERIC_INTERVAL_NO_HARDWARE)
+#undef BOOST_NUMERIC_INTERVAL_NO_HARDWARE
+#error Boost.Numeric.Interval: Please specify rounding control mechanism.
+#endif
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+
+/*
+ * Three specializations of rounded_math<T>
+ */
+
+template <> struct rounded_math<float> : save_state<rounded_arith_opp<float>>
+{
+};
+
+template <> struct rounded_math<double> : save_state<rounded_arith_opp<double>>
+{
+};
+
+template <> struct rounded_math<long double> : save_state<rounded_arith_opp<long double>>
+{
+};
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_HW_ROUNDING_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/interval.hpp

@@ -0,0 +1,484 @@
+/* Boost interval/interval.hpp header file
+ *
+ * Copyright 2002-2003 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_INTERVAL_HPP
+#define BOOST_NUMERIC_INTERVAL_INTERVAL_HPP
+
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+#include <stdexcept>
+#include <string>
+
+namespace boost {
+namespace numeric {
+
+namespace interval_lib {
+
+class comparison_error : public std::runtime_error
+{
+public:
+    comparison_error()
+        : std::runtime_error("boost::interval: uncertain comparison")
+    {
+    }
+};
+
+} // namespace interval_lib
+
+/*
+ * interval class
+ */
+
+template <class T, class Policies> class interval
+{
+private:
+    struct interval_holder;
+    struct number_holder;
+
+public:
+    typedef T        base_type;
+    typedef Policies traits_type;
+
+    T const &lower() const;
+    T const &upper() const;
+
+    interval();
+    interval(T const &v);
+    template <class T1> interval(T1 const &v);
+    interval(T const &l, T const &u);
+    template <class T1, class T2> interval(T1 const &l, T2 const &u);
+    interval(interval<T, Policies> const &r);
+    template <class Policies1> interval(interval<T, Policies1> const &r);
+    template <class T1, class Policies1> interval(interval<T1, Policies1> const &r);
+
+    interval                                      &operator=(T const &v);
+    template <class T1> interval                  &operator=(T1 const &v);
+    interval                                      &operator=(interval<T, Policies> const &r);
+    template <class Policies1> interval           &operator=(interval<T, Policies1> const &r);
+    template <class T1, class Policies1> interval &operator=(interval<T1, Policies1> const &r);
+
+    void assign(const T &l, const T &u);
+
+    static interval empty();
+    static interval whole();
+    static interval hull(const T &x, const T &y);
+
+    interval &operator+=(const T &r);
+    interval &operator+=(const interval &r);
+    interval &operator-=(const T &r);
+    interval &operator-=(const interval &r);
+    interval &operator*=(const T &r);
+    interval &operator*=(const interval &r);
+    interval &operator/=(const T &r);
+    interval &operator/=(const interval &r);
+
+    bool operator<(const interval_holder &r) const;
+    bool operator>(const interval_holder &r) const;
+    bool operator<=(const interval_holder &r) const;
+    bool operator>=(const interval_holder &r) const;
+    bool operator==(const interval_holder &r) const;
+    bool operator!=(const interval_holder &r) const;
+
+    bool operator<(const number_holder &r) const;
+    bool operator>(const number_holder &r) const;
+    bool operator<=(const number_holder &r) const;
+    bool operator>=(const number_holder &r) const;
+    bool operator==(const number_holder &r) const;
+    bool operator!=(const number_holder &r) const;
+
+    // the following is for internal use only, it is not a published interface
+    // nevertheless, it's public because friends don't always work correctly.
+    interval(const T &l, const T &u, bool)
+        : low(l)
+        , up(u)
+    {
+    }
+    void set_empty();
+    void set_whole();
+    void set(const T &l, const T &u);
+
+private:
+    struct interval_holder
+    {
+        template <class Policies2>
+        interval_holder(const interval<T, Policies2> &r)
+            : low(r.lower())
+            , up(r.upper())
+        {
+            typedef typename Policies2::checking checking2;
+            if (checking2::is_empty(low, up))
+                throw interval_lib::comparison_error();
+        }
+
+        const T &low;
+        const T &up;
+    };
+
+    struct number_holder
+    {
+        number_holder(const T &r)
+            : val(r)
+        {
+            typedef typename Policies::checking checking;
+            if (checking::is_nan(r))
+                throw interval_lib::comparison_error();
+        }
+
+        const T &val;
+    };
+
+    typedef typename Policies::checking checking;
+    typedef typename Policies::rounding rounding;
+
+    T low;
+    T up;
+};
+
+template <class T, class Policies>
+inline interval<T, Policies>::interval()
+    : low(static_cast<T>(0))
+    , up(static_cast<T>(0))
+{
+}
+
+template <class T, class Policies>
+inline interval<T, Policies>::interval(T const &v)
+    : low(v)
+    , up(v)
+{
+    if (checking::is_nan(v))
+        set_empty();
+}
+
+template <class T, class Policies> template <class T1> inline interval<T, Policies>::interval(T1 const &v)
+{
+    if (checking::is_nan(v))
+        set_empty();
+    else {
+        rounding rnd;
+        low = rnd.conv_down(v);
+        up  = rnd.conv_up(v);
+    }
+}
+
+template <class T, class Policies>
+template <class T1, class T2>
+inline interval<T, Policies>::interval(T1 const &l, T2 const &u)
+{
+    if (checking::is_nan(l) || checking::is_nan(u) || !(l <= u))
+        set_empty();
+    else {
+        rounding rnd;
+        low = rnd.conv_down(l);
+        up  = rnd.conv_up(u);
+    }
+}
+
+template <class T, class Policies>
+inline interval<T, Policies>::interval(T const &l, T const &u)
+    : low(l)
+    , up(u)
+{
+    if (checking::is_nan(l) || checking::is_nan(u) || !(l <= u))
+        set_empty();
+}
+
+
+template <class T, class Policies>
+inline interval<T, Policies>::interval(interval<T, Policies> const &r)
+    : low(r.lower())
+    , up(r.upper())
+{
+}
+
+template <class T, class Policies>
+template <class Policies1>
+inline interval<T, Policies>::interval(interval<T, Policies1> const &r)
+    : low(r.lower())
+    , up(r.upper())
+{
+    typedef typename Policies1::checking checking1;
+    if (checking1::is_empty(r.lower(), r.upper()))
+        set_empty();
+}
+
+template <class T, class Policies>
+template <class T1, class Policies1>
+inline interval<T, Policies>::interval(interval<T1, Policies1> const &r)
+{
+    typedef typename Policies1::checking checking1;
+    if (checking1::is_empty(r.lower(), r.upper()))
+        set_empty();
+    else {
+        rounding rnd;
+        low = rnd.conv_down(r.lower());
+        up  = rnd.conv_up(r.upper());
+    }
+}
+
+template <class T, class Policies> inline interval<T, Policies> &interval<T, Policies>::operator=(T const &v)
+{
+    if (checking::is_nan(v))
+        set_empty();
+    else
+        low = up = v;
+    return *this;
+}
+
+template <class T, class Policies>
+template <class T1>
+inline interval<T, Policies> &interval<T, Policies>::operator=(T1 const &v)
+{
+    if (checking::is_nan(v))
+        set_empty();
+    else {
+        rounding rnd;
+        low = rnd.conv_down(v);
+        up  = rnd.conv_up(v);
+    }
+    return *this;
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> &interval<T, Policies>::operator=(interval<T, Policies> const &r)
+{
+    low = r.lower();
+    up  = r.upper();
+    return *this;
+}
+
+template <class T, class Policies>
+template <class Policies1>
+inline interval<T, Policies> &interval<T, Policies>::operator=(interval<T, Policies1> const &r)
+{
+    typedef typename Policies1::checking checking1;
+    if (checking1::is_empty(r.lower(), r.upper()))
+        set_empty();
+    else {
+        low = r.lower();
+        up  = r.upper();
+    }
+    return *this;
+}
+
+template <class T, class Policies>
+template <class T1, class Policies1>
+inline interval<T, Policies> &interval<T, Policies>::operator=(interval<T1, Policies1> const &r)
+{
+    typedef typename Policies1::checking checking1;
+    if (checking1::is_empty(r.lower(), r.upper()))
+        set_empty();
+    else {
+        rounding rnd;
+        low = rnd.conv_down(r.lower());
+        up  = rnd.conv_up(r.upper());
+    }
+    return *this;
+}
+
+template <class T, class Policies> inline void interval<T, Policies>::assign(const T &l, const T &u)
+{
+    if (checking::is_nan(l) || checking::is_nan(u) || !(l <= u))
+        set_empty();
+    else
+        set(l, u);
+}
+
+template <class T, class Policies> inline void interval<T, Policies>::set(const T &l, const T &u)
+{
+    low = l;
+    up  = u;
+}
+
+template <class T, class Policies> inline void interval<T, Policies>::set_empty()
+{
+    low = checking::empty_lower();
+    up  = checking::empty_upper();
+}
+
+template <class T, class Policies> inline void interval<T, Policies>::set_whole()
+{
+    low = checking::neg_inf();
+    up  = checking::pos_inf();
+}
+
+template <class T, class Policies> inline interval<T, Policies> interval<T, Policies>::hull(const T &x, const T &y)
+{
+    bool bad_x = checking::is_nan(x);
+    bool bad_y = checking::is_nan(y);
+    if (bad_x)
+        if (bad_y)
+            return interval::empty();
+        else
+            return interval(y, y, true);
+    else if (bad_y)
+        return interval(x, x, true);
+    if (x <= y)
+        return interval(x, y, true);
+    else
+        return interval(y, x, true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> interval<T, Policies>::empty()
+{
+    return interval<T, Policies>(checking::empty_lower(), checking::empty_upper(), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> interval<T, Policies>::whole()
+{
+    return interval<T, Policies>(checking::neg_inf(), checking::pos_inf(), true);
+}
+
+template <class T, class Policies> inline const T &interval<T, Policies>::lower() const { return low; }
+
+template <class T, class Policies> inline const T &interval<T, Policies>::upper() const { return up; }
+
+/*
+ * interval/interval comparisons
+ */
+
+template <class T, class Policies> inline bool interval<T, Policies>::operator<(const interval_holder &r) const
+{
+    if (!checking::is_empty(low, up)) {
+        if (up < r.low)
+            return true;
+        else if (low >= r.up)
+            return false;
+    }
+    throw interval_lib::comparison_error();
+}
+
+template <class T, class Policies> inline bool interval<T, Policies>::operator>(const interval_holder &r) const
+{
+    if (!checking::is_empty(low, up)) {
+        if (low > r.up)
+            return true;
+        else if (up <= r.low)
+            return false;
+    }
+    throw interval_lib::comparison_error();
+}
+
+template <class T, class Policies> inline bool interval<T, Policies>::operator<=(const interval_holder &r) const
+{
+    if (!checking::is_empty(low, up)) {
+        if (up <= r.low)
+            return true;
+        else if (low > r.up)
+            return false;
+    }
+    throw interval_lib::comparison_error();
+}
+
+template <class T, class Policies> inline bool interval<T, Policies>::operator>=(const interval_holder &r) const
+{
+    if (!checking::is_empty(low, up)) {
+        if (low >= r.up)
+            return true;
+        else if (up < r.low)
+            return false;
+    }
+    throw interval_lib::comparison_error();
+}
+
+template <class T, class Policies> inline bool interval<T, Policies>::operator==(const interval_holder &r) const
+{
+    if (!checking::is_empty(low, up)) {
+        if (up == r.low && low == r.up)
+            return true;
+        else if (up < r.low || low > r.up)
+            return false;
+    }
+    throw interval_lib::comparison_error();
+}
+
+template <class T, class Policies> inline bool interval<T, Policies>::operator!=(const interval_holder &r) const
+{
+    if (!checking::is_empty(low, up)) {
+        if (up < r.low || low > r.up)
+            return true;
+        else if (up == r.low && low == r.up)
+            return false;
+    }
+    throw interval_lib::comparison_error();
+}
+
+/*
+ * interval/number comparisons
+ */
+
+template <class T, class Policies> inline bool interval<T, Policies>::operator<(const number_holder &r) const
+{
+    if (!checking::is_empty(low, up)) {
+        if (up < r.val)
+            return true;
+        else if (low >= r.val)
+            return false;
+    }
+    throw interval_lib::comparison_error();
+}
+
+template <class T, class Policies> inline bool interval<T, Policies>::operator>(const number_holder &r) const
+{
+    if (!checking::is_empty(low, up)) {
+        if (low > r.val)
+            return true;
+        else if (up <= r.val)
+            return false;
+    }
+    throw interval_lib::comparison_error();
+}
+
+template <class T, class Policies> inline bool interval<T, Policies>::operator<=(const number_holder &r) const
+{
+    if (!checking::is_empty(low, up)) {
+        if (up <= r.val)
+            return true;
+        else if (low > r.val)
+            return false;
+    }
+    throw interval_lib::comparison_error();
+}
+
+template <class T, class Policies> inline bool interval<T, Policies>::operator>=(const number_holder &r) const
+{
+    if (!checking::is_empty(low, up)) {
+        if (low >= r.val)
+            return true;
+        else if (up < r.val)
+            return false;
+    }
+    throw interval_lib::comparison_error();
+}
+
+template <class T, class Policies> inline bool interval<T, Policies>::operator==(const number_holder &r) const
+{
+    if (!checking::is_empty(low, up)) {
+        if (up == r.val && low == r.val)
+            return true;
+        else if (up < r.val || low > r.val)
+            return false;
+    }
+    throw interval_lib::comparison_error();
+}
+
+template <class T, class Policies> inline bool interval<T, Policies>::operator!=(const number_holder &r) const
+{
+    if (!checking::is_empty(low, up)) {
+        if (up < r.val || low > r.val)
+            return true;
+        else if (up == r.val && low == r.val)
+            return false;
+    }
+    throw interval_lib::comparison_error();
+}
+
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_INTERVAL_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/io.hpp

@@ -0,0 +1,40 @@
+/* Boost interval/io.hpp header file
+ *
+ * This file is only meant to provide a quick
+ * implementation of the output operator. It is
+ * provided for test programs that aren't even
+ * interested in the precision of the results.
+ * A real progam should define its own operators
+ * and never include this header.
+ *
+ * Copyright 2003 Guillaume Melquiond
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_IO_HPP
+#define BOOST_NUMERIC_INTERVAL_IO_HPP
+
+#include <boost/numeric/interval/interval.hpp>
+#include <boost/numeric/interval/utility.hpp>
+#include <ostream>
+
+namespace boost {
+namespace numeric {
+
+template <class CharType, class CharTraits, class T, class Policies>
+std::basic_ostream<CharType, CharTraits> &operator<<(std::basic_ostream<CharType, CharTraits> &stream,
+                                                     interval<T, Policies> const              &value)
+{
+    if (empty(value))
+        return stream << "[]";
+    else
+        return stream << '[' << lower(value) << ',' << upper(value) << ']';
+}
+
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_IO_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/limits.hpp

@@ -0,0 +1,50 @@
+/* Boost interval/limits.hpp template implementation file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002-2003 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_LIMITS_HPP
+#define BOOST_NUMERIC_INTERVAL_LIMITS_HPP
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+#include <boost/config.hpp>
+#include <boost/limits.hpp>
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+
+namespace std {
+
+template <class T, class Policies>
+class numeric_limits<boost::numeric::interval<T, Policies>> : public numeric_limits<T>
+{
+private:
+    typedef boost::numeric::interval<T, Policies> I;
+    typedef numeric_limits<T>                     bl;
+
+public:
+    static I min BOOST_PREVENT_MACRO_SUBSTITUTION() throw() { return I((bl::min)(), (bl::min)()); }
+    static I max BOOST_PREVENT_MACRO_SUBSTITUTION() throw() { return I((bl::max)(), (bl::max)()); }
+    static I     epsilon() throw() { return I(bl::epsilon(), bl::epsilon()); }
+
+    BOOST_STATIC_CONSTANT(float_round_style, round_style = round_indeterminate);
+    BOOST_STATIC_CONSTANT(bool, is_iec559 = false);
+
+    static I infinity() throw() { return I::whole(); }
+    static I quiet_NaN() throw() { return I::empty(); }
+    static I signaling_NaN() throw() { return I(bl::signaling_NaN(), bl::signaling_Nan()); }
+    static I denorm_min() throw() { return I(bl::denorm_min(), bl::denorm_min()); }
+
+private:
+    static I round_error(); // hide this on purpose, not yet implemented
+};
+
+} // namespace std
+
+#endif
+
+#endif // BOOST_NUMERIC_INTERVAL_LIMITS_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/policies.hpp

@@ -0,0 +1,74 @@
+/* Boost interval/policies.hpp template implementation file
+ *
+ * Copyright 2003 Guillaume Melquiond
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_POLICIES_HPP
+#define BOOST_NUMERIC_INTERVAL_POLICIES_HPP
+
+#include <boost/numeric/interval/interval.hpp>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+
+/*
+ * policies class
+ */
+
+template <class Rounding, class Checking> struct policies
+{
+    typedef Rounding rounding;
+    typedef Checking checking;
+};
+
+/*
+ * policies switching classes
+ */
+
+template <class OldInterval, class NewRounding> class change_rounding
+{
+    typedef typename OldInterval::base_type   T;
+    typedef typename OldInterval::traits_type p;
+    typedef typename p::checking              checking;
+
+public:
+    typedef interval<T, policies<NewRounding, checking>> type;
+};
+
+template <class OldInterval, class NewChecking> class change_checking
+{
+    typedef typename OldInterval::base_type   T;
+    typedef typename OldInterval::traits_type p;
+    typedef typename p::rounding              rounding;
+
+public:
+    typedef interval<T, policies<rounding, NewChecking>> type;
+};
+
+/*
+ * Protect / unprotect: control whether the rounding mode is set/reset
+ * at each operation, rather than once and for all.
+ */
+
+template <class OldInterval> class unprotect
+{
+    typedef typename OldInterval::base_type   T;
+    typedef typename OldInterval::traits_type p;
+    typedef typename p::rounding              r;
+    typedef typename r::unprotected_rounding  newRounding;
+
+public:
+    typedef typename change_rounding<OldInterval, newRounding>::type type;
+};
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_INTERVAL_POLICIES_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/rounded_arith.hpp

@@ -0,0 +1,158 @@
+/* Boost interval/rounded_arith.hpp template implementation file
+ *
+ * Copyright 2002-2003 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_ROUNDED_ARITH_HPP
+#define BOOST_NUMERIC_INTERVAL_ROUNDED_ARITH_HPP
+
+#include <boost/config/no_tr1/cmath.hpp>
+#include <boost/numeric/interval/detail/bugs.hpp>
+#include <boost/numeric/interval/rounding.hpp>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+
+/*
+ * Three classes of rounding: exact, std, opp
+ * See documentation for details.
+ */
+
+template <class T, class Rounding> struct rounded_arith_exact : Rounding
+{
+    void                 init() {}
+    template <class U> T conv_down(U const &v) { return v; }
+    template <class U> T conv_up(U const &v) { return v; }
+    T                    add_down(const T &x, const T &y) { return x + y; }
+    T                    add_up(const T &x, const T &y) { return x + y; }
+    T                    sub_down(const T &x, const T &y) { return x - y; }
+    T                    sub_up(const T &x, const T &y) { return x - y; }
+    T                    mul_down(const T &x, const T &y) { return x * y; }
+    T                    mul_up(const T &x, const T &y) { return x * y; }
+    T                    div_down(const T &x, const T &y) { return x / y; }
+    T                    div_up(const T &x, const T &y) { return x / y; }
+    T                    median(const T &x, const T &y) { return (x + y) / 2; }
+    T                    sqrt_down(const T &x)
+    {
+        BOOST_NUMERIC_INTERVAL_using_math(sqrt);
+        return sqrt(x);
+    }
+    T sqrt_up(const T &x)
+    {
+        BOOST_NUMERIC_INTERVAL_using_math(sqrt);
+        return sqrt(x);
+    }
+    T int_down(const T &x)
+    {
+        BOOST_NUMERIC_INTERVAL_using_math(floor);
+        return floor(x);
+    }
+    T int_up(const T &x)
+    {
+        BOOST_NUMERIC_INTERVAL_using_math(ceil);
+        return ceil(x);
+    }
+};
+
+template <class T, class Rounding> struct rounded_arith_std : Rounding
+{
+#define BOOST_DN(EXPR) \
+    this->downward();  \
+    return this->force_rounding(EXPR)
+#define BOOST_NR(EXPR)  \
+    this->to_nearest(); \
+    return this->force_rounding(EXPR)
+#define BOOST_UP(EXPR) \
+    this->upward();    \
+    return this->force_rounding(EXPR)
+    void                 init() {}
+    template <class U> T conv_down(U const &v) { BOOST_DN(v); }
+    template <class U> T conv_up(U const &v) { BOOST_UP(v); }
+    T                    add_down(const T &x, const T &y) { BOOST_DN(x + y); }
+    T                    sub_down(const T &x, const T &y) { BOOST_DN(x - y); }
+    T                    mul_down(const T &x, const T &y) { BOOST_DN(x * y); }
+    T                    div_down(const T &x, const T &y) { BOOST_DN(x / y); }
+    T                    add_up(const T &x, const T &y) { BOOST_UP(x + y); }
+    T                    sub_up(const T &x, const T &y) { BOOST_UP(x - y); }
+    T                    mul_up(const T &x, const T &y) { BOOST_UP(x * y); }
+    T                    div_up(const T &x, const T &y) { BOOST_UP(x / y); }
+    T                    median(const T &x, const T &y) { BOOST_NR((x + y) / 2); }
+    T                    sqrt_down(const T &x)
+    {
+        BOOST_NUMERIC_INTERVAL_using_math(sqrt);
+        BOOST_DN(sqrt(x));
+    }
+    T sqrt_up(const T &x)
+    {
+        BOOST_NUMERIC_INTERVAL_using_math(sqrt);
+        BOOST_UP(sqrt(x));
+    }
+    T int_down(const T &x)
+    {
+        this->downward();
+        return to_int(x);
+    }
+    T int_up(const T &x)
+    {
+        this->upward();
+        return to_int(x);
+    }
+#undef BOOST_DN
+#undef BOOST_NR
+#undef BOOST_UP
+};
+
+template <class T, class Rounding> struct rounded_arith_opp : Rounding
+{
+    void init() { this->upward(); }
+#define BOOST_DN(EXPR)                \
+    this->downward();                 \
+    T r = this->force_rounding(EXPR); \
+    this->upward();                   \
+    return r
+#define BOOST_NR(EXPR)                \
+    this->to_nearest();               \
+    T r = this->force_rounding(EXPR); \
+    this->upward();                   \
+    return r
+#define BOOST_UP(EXPR)     return this->force_rounding(EXPR)
+#define BOOST_UP_NEG(EXPR) return -this->force_rounding(EXPR)
+    template <class U> T conv_down(U const &v) { BOOST_UP_NEG(-v); }
+    template <class U> T conv_up(U const &v) { BOOST_UP(v); }
+    T                    add_down(const T &x, const T &y) { BOOST_UP_NEG((-x) - y); }
+    T                    sub_down(const T &x, const T &y) { BOOST_UP_NEG(y - x); }
+    T                    mul_down(const T &x, const T &y) { BOOST_UP_NEG(x * (-y)); }
+    T                    div_down(const T &x, const T &y) { BOOST_UP_NEG(x / (-y)); }
+    T                    add_up(const T &x, const T &y) { BOOST_UP(x + y); }
+    T                    sub_up(const T &x, const T &y) { BOOST_UP(x - y); }
+    T                    mul_up(const T &x, const T &y) { BOOST_UP(x * y); }
+    T                    div_up(const T &x, const T &y) { BOOST_UP(x / y); }
+    T                    median(const T &x, const T &y) { BOOST_NR((x + y) / 2); }
+    T                    sqrt_down(const T &x)
+    {
+        BOOST_NUMERIC_INTERVAL_using_math(sqrt);
+        BOOST_DN(sqrt(x));
+    }
+    T sqrt_up(const T &x)
+    {
+        BOOST_NUMERIC_INTERVAL_using_math(sqrt);
+        BOOST_UP(sqrt(x));
+    }
+    T int_down(const T &x) { return -to_int(-x); }
+    T int_up(const T &x) { return to_int(x); }
+#undef BOOST_DN
+#undef BOOST_NR
+#undef BOOST_UP
+#undef BOOST_UP_NEG
+};
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_ROUNDED_ARITH_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/rounded_transc.hpp

@@ -0,0 +1,164 @@
+/* Boost interval/rounded_transc.hpp template implementation file
+ *
+ * Copyright 2002-2003 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_ROUNDED_TRANSC_HPP
+#define BOOST_NUMERIC_INTERVAL_ROUNDED_TRANSC_HPP
+
+#include <boost/config/no_tr1/cmath.hpp>
+#include <boost/numeric/interval/detail/bugs.hpp>
+#include <boost/numeric/interval/rounding.hpp>
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+
+template <class T, class Rounding> struct rounded_transc_exact : Rounding
+{
+#define BOOST_NUMERIC_INTERVAL_new_func(f)    \
+    T f##_down(const T &x)                    \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_math(f); \
+        return f(x);                          \
+    }                                         \
+    T f##_up(const T &x)                      \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_math(f); \
+        return f(x);                          \
+    }
+    BOOST_NUMERIC_INTERVAL_new_func(exp) BOOST_NUMERIC_INTERVAL_new_func(log) BOOST_NUMERIC_INTERVAL_new_func(sin)
+        BOOST_NUMERIC_INTERVAL_new_func(cos) BOOST_NUMERIC_INTERVAL_new_func(tan) BOOST_NUMERIC_INTERVAL_new_func(asin)
+            BOOST_NUMERIC_INTERVAL_new_func(acos) BOOST_NUMERIC_INTERVAL_new_func(atan)
+                BOOST_NUMERIC_INTERVAL_new_func(sinh) BOOST_NUMERIC_INTERVAL_new_func(cosh)
+                    BOOST_NUMERIC_INTERVAL_new_func(tanh)
+#undef BOOST_NUMERIC_INTERVAL_new_func
+#define BOOST_NUMERIC_INTERVAL_new_func(f)    \
+    T f##_down(const T &x)                    \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
+        return f(x);                          \
+    }                                         \
+    T f##_up(const T &x)                      \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
+        return f(x);                          \
+    }
+                        BOOST_NUMERIC_INTERVAL_new_func(asinh) BOOST_NUMERIC_INTERVAL_new_func(acosh)
+                            BOOST_NUMERIC_INTERVAL_new_func(atanh)
+#undef BOOST_NUMERIC_INTERVAL_new_func
+};
+
+template <class T, class Rounding> struct rounded_transc_std : Rounding
+{
+#define BOOST_NUMERIC_INTERVAL_new_func(f)    \
+    T f##_down(const T &x)                    \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_math(f); \
+        this->downward();                     \
+        return this->force_rounding(f(x));    \
+    }                                         \
+    T f##_up(const T &x)                      \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_math(f); \
+        this->upward();                       \
+        return this->force_rounding(f(x));    \
+    }
+    BOOST_NUMERIC_INTERVAL_new_func(exp) BOOST_NUMERIC_INTERVAL_new_func(log) BOOST_NUMERIC_INTERVAL_new_func(sin)
+        BOOST_NUMERIC_INTERVAL_new_func(cos) BOOST_NUMERIC_INTERVAL_new_func(tan) BOOST_NUMERIC_INTERVAL_new_func(asin)
+            BOOST_NUMERIC_INTERVAL_new_func(acos) BOOST_NUMERIC_INTERVAL_new_func(atan)
+                BOOST_NUMERIC_INTERVAL_new_func(sinh) BOOST_NUMERIC_INTERVAL_new_func(cosh)
+                    BOOST_NUMERIC_INTERVAL_new_func(tanh)
+#undef BOOST_NUMERIC_INTERVAL_new_func
+#define BOOST_NUMERIC_INTERVAL_new_func(f)    \
+    T f##_down(const T &x)                    \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
+        this->downward();                     \
+        return this->force_rounding(f(x));    \
+    }                                         \
+    T f##_up(const T &x)                      \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
+        this->upward();                       \
+        return this->force_rounding(f(x));    \
+    }
+                        BOOST_NUMERIC_INTERVAL_new_func(asinh) BOOST_NUMERIC_INTERVAL_new_func(acosh)
+                            BOOST_NUMERIC_INTERVAL_new_func(atanh)
+#undef BOOST_NUMERIC_INTERVAL_new_func
+};
+
+template <class T, class Rounding> struct rounded_transc_opp : Rounding
+{
+#define BOOST_NUMERIC_INTERVAL_new_func(f)    \
+    T f##_down(const T &x)                    \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_math(f); \
+        this->downward();                     \
+        T y = this->force_rounding(f(x));     \
+        this->upward();                       \
+        return y;                             \
+    }                                         \
+    T f##_up(const T &x)                      \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_math(f); \
+        return this->force_rounding(f(x));    \
+    }
+    BOOST_NUMERIC_INTERVAL_new_func(exp) BOOST_NUMERIC_INTERVAL_new_func(log) BOOST_NUMERIC_INTERVAL_new_func(cos)
+        BOOST_NUMERIC_INTERVAL_new_func(acos) BOOST_NUMERIC_INTERVAL_new_func(cosh)
+#undef BOOST_NUMERIC_INTERVAL_new_func
+#define BOOST_NUMERIC_INTERVAL_new_func(f)    \
+    T f##_down(const T &x)                    \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_math(f); \
+        return -this->force_rounding(-f(x));  \
+    }                                         \
+    T f##_up(const T &x)                      \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_math(f); \
+        return this->force_rounding(f(x));    \
+    }
+            BOOST_NUMERIC_INTERVAL_new_func(sin) BOOST_NUMERIC_INTERVAL_new_func(tan)
+                BOOST_NUMERIC_INTERVAL_new_func(asin) BOOST_NUMERIC_INTERVAL_new_func(atan)
+                    BOOST_NUMERIC_INTERVAL_new_func(sinh) BOOST_NUMERIC_INTERVAL_new_func(tanh)
+#undef BOOST_NUMERIC_INTERVAL_new_func
+#define BOOST_NUMERIC_INTERVAL_new_func(f)    \
+    T f##_down(const T &x)                    \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
+        this->downward();                     \
+        T y = this->force_rounding(f(x));     \
+        this->upward();                       \
+        return y;                             \
+    }                                         \
+    T f##_up(const T &x)                      \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
+        return this->force_rounding(f(x));    \
+    }
+                        BOOST_NUMERIC_INTERVAL_new_func(asinh) BOOST_NUMERIC_INTERVAL_new_func(atanh)
+#undef BOOST_NUMERIC_INTERVAL_new_func
+#define BOOST_NUMERIC_INTERVAL_new_func(f)    \
+    T f##_down(const T &x)                    \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
+        return -this->force_rounding(-f(x));  \
+    }                                         \
+    T f##_up(const T &x)                      \
+    {                                         \
+        BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
+        return this->force_rounding(f(x));    \
+    }
+                            BOOST_NUMERIC_INTERVAL_new_func(acosh)
+#undef BOOST_NUMERIC_INTERVAL_new_func
+};
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_ROUNDED_TRANSC_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/rounding.hpp

@@ -0,0 +1,91 @@
+/* Boost interval/rounding.hpp template implementation file
+ *
+ * Copyright 2002-2003 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_ROUNDING_HPP
+#define BOOST_NUMERIC_INTERVAL_ROUNDING_HPP
+
+namespace boost {
+namespace numeric {
+namespace interval_lib {
+
+/*
+ * Default rounding_control class (does nothing)
+ */
+
+template <class T> struct rounding_control
+{
+    typedef int     rounding_mode;
+    static void     get_rounding_mode(rounding_mode &) {}
+    static void     set_rounding_mode(rounding_mode) {}
+    static void     upward() {}
+    static void     downward() {}
+    static void     to_nearest() {}
+    static const T &to_int(const T &x) { return x; }
+    static const T &force_rounding(const T &x) { return x; }
+};
+
+/*
+ * A few rounding control classes (exact/std/opp: see documentation)
+ *   rounded_arith_* control the rounding of the arithmetic operators
+ *   rounded_transc_* control the rounding of the transcendental functions
+ */
+
+template <class T, class Rounding = rounding_control<T>> struct rounded_arith_exact;
+
+template <class T, class Rounding = rounding_control<T>> struct rounded_arith_std;
+
+template <class T, class Rounding = rounding_control<T>> struct rounded_arith_opp;
+
+template <class T, class Rounding> struct rounded_transc_dummy;
+
+template <class T, class Rounding = rounded_arith_exact<T>> struct rounded_transc_exact;
+
+template <class T, class Rounding = rounded_arith_std<T>> struct rounded_transc_std;
+
+template <class T, class Rounding = rounded_arith_opp<T>> struct rounded_transc_opp;
+
+/*
+ * State-saving classes: allow to set and reset rounding control
+ */
+
+namespace detail {
+
+template <class Rounding> struct save_state_unprotected : Rounding
+{
+    typedef save_state_unprotected<Rounding> unprotected_rounding;
+};
+
+} // namespace detail
+
+template <class Rounding> struct save_state : Rounding
+{
+    typename Rounding::rounding_mode mode;
+    save_state()
+    {
+        this->get_rounding_mode(mode);
+        this->init();
+    }
+    ~save_state() { this->set_rounding_mode(mode); }
+    typedef detail::save_state_unprotected<Rounding> unprotected_rounding;
+};
+
+template <class Rounding> struct save_state_nothing : Rounding
+{
+    typedef save_state_nothing<Rounding> unprotected_rounding;
+};
+
+template <class T> struct rounded_math : save_state_nothing<rounded_arith_exact<T>>
+{
+};
+
+} // namespace interval_lib
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_ROUNDING_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/transc.hpp

@@ -0,0 +1,205 @@
+/* Boost interval/transc.hpp template implementation file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_TRANSC_HPP
+#define BOOST_NUMERIC_INTERVAL_TRANSC_HPP
+
+#include <algorithm>
+#include <boost/config.hpp>
+#include <boost/numeric/interval/arith.hpp>
+#include <boost/numeric/interval/arith2.hpp>
+#include <boost/numeric/interval/constants.hpp>
+#include <boost/numeric/interval/detail/bugs.hpp>
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+#include <boost/numeric/interval/rounding.hpp>
+
+namespace boost {
+namespace numeric {
+
+template <class T, class Policies> inline interval<T, Policies> exp(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x))
+        return I::empty();
+    typename Policies::rounding rnd;
+    return I(rnd.exp_down(x.lower()), rnd.exp_up(x.upper()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> log(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x) || !interval_lib::user::is_pos(x.upper()))
+        return I::empty();
+    typename Policies::rounding         rnd;
+    typedef typename Policies::checking checking;
+    T l = !interval_lib::user::is_pos(x.lower()) ? checking::neg_inf() : rnd.log_down(x.lower());
+    return I(l, rnd.log_up(x.upper()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> cos(const interval<T, Policies> &x)
+{
+    if (interval_lib::detail::test_input(x))
+        return interval<T, Policies>::empty();
+    typename Policies::rounding                       rnd;
+    typedef interval<T, Policies>                     I;
+    typedef typename interval_lib::unprotect<I>::type R;
+
+    // get lower bound within [0, pi]
+    const R pi2 = interval_lib::pi_twice<R>();
+    R       tmp = fmod((const R &)x, pi2);
+    if (width(tmp) >= pi2.lower())
+        return I(static_cast<T>(-1), static_cast<T>(1), true); // we are covering a full period
+    if (tmp.lower() >= interval_lib::constants::pi_upper<T>())
+        return -cos(tmp - interval_lib::pi<R>());
+    T l = tmp.lower();
+    T u = tmp.upper();
+
+    BOOST_USING_STD_MIN();
+    // separate into monotone subintervals
+    if (u <= interval_lib::constants::pi_lower<T>())
+        return I(rnd.cos_down(u), rnd.cos_up(l), true);
+    else if (u <= pi2.lower())
+        return I(static_cast<T>(-1),
+                 rnd.cos_up(min BOOST_PREVENT_MACRO_SUBSTITUTION(rnd.sub_down(pi2.lower(), u), l)),
+                 true);
+    else
+        return I(static_cast<T>(-1), static_cast<T>(1), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> sin(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x))
+        return I::empty();
+    typename Policies::rounding                       rnd;
+    typedef typename interval_lib::unprotect<I>::type R;
+    I                                                 r = cos((const R &)x - interval_lib::pi_half<R>());
+    (void)&rnd;
+    return r;
+}
+
+template <class T, class Policies> inline interval<T, Policies> tan(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x))
+        return I::empty();
+    typename Policies::rounding                       rnd;
+    typedef typename interval_lib::unprotect<I>::type R;
+
+    // get lower bound within [-pi/2, pi/2]
+    const R pi        = interval_lib::pi<R>();
+    R       tmp       = fmod((const R &)x, pi);
+    const T pi_half_d = interval_lib::constants::pi_half_lower<T>();
+    if (tmp.lower() >= pi_half_d)
+        tmp -= pi;
+    if (tmp.lower() <= -pi_half_d || tmp.upper() >= pi_half_d)
+        return I::whole();
+    return I(rnd.tan_down(tmp.lower()), rnd.tan_up(tmp.upper()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> asin(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x) || x.upper() < static_cast<T>(-1) || x.lower() > static_cast<T>(1))
+        return I::empty();
+    typename Policies::rounding rnd;
+    T l = (x.lower() <= static_cast<T>(-1)) ? -interval_lib::constants::pi_half_upper<T>() : rnd.asin_down(x.lower());
+    T u = (x.upper() >= static_cast<T>(1)) ? interval_lib::constants::pi_half_upper<T>() : rnd.asin_up(x.upper());
+    return I(l, u, true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> acos(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x) || x.upper() < static_cast<T>(-1) || x.lower() > static_cast<T>(1))
+        return I::empty();
+    typename Policies::rounding rnd;
+    T                           l = (x.upper() >= static_cast<T>(1)) ? static_cast<T>(0) : rnd.acos_down(x.upper());
+    T u = (x.lower() <= static_cast<T>(-1)) ? interval_lib::constants::pi_upper<T>() : rnd.acos_up(x.lower());
+    return I(l, u, true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> atan(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x))
+        return I::empty();
+    typename Policies::rounding rnd;
+    return I(rnd.atan_down(x.lower()), rnd.atan_up(x.upper()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> sinh(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x))
+        return I::empty();
+    typename Policies::rounding rnd;
+    return I(rnd.sinh_down(x.lower()), rnd.sinh_up(x.upper()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> cosh(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x))
+        return I::empty();
+    typename Policies::rounding rnd;
+    if (interval_lib::user::is_neg(x.upper()))
+        return I(rnd.cosh_down(x.upper()), rnd.cosh_up(x.lower()), true);
+    else if (!interval_lib::user::is_neg(x.lower()))
+        return I(rnd.cosh_down(x.lower()), rnd.cosh_up(x.upper()), true);
+    else
+        return I(static_cast<T>(0), rnd.cosh_up(-x.lower() > x.upper() ? x.lower() : x.upper()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> tanh(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x))
+        return I::empty();
+    typename Policies::rounding rnd;
+    return I(rnd.tanh_down(x.lower()), rnd.tanh_up(x.upper()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> asinh(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x))
+        return I::empty();
+    typename Policies::rounding rnd;
+    return I(rnd.asinh_down(x.lower()), rnd.asinh_up(x.upper()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> acosh(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x) || x.upper() < static_cast<T>(1))
+        return I::empty();
+    typename Policies::rounding rnd;
+    T                           l = x.lower() <= static_cast<T>(1) ? static_cast<T>(0) : rnd.acosh_down(x.lower());
+    return I(l, rnd.acosh_up(x.upper()), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> atanh(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x) || x.upper() < static_cast<T>(-1) || x.lower() > static_cast<T>(1))
+        return I::empty();
+    typename Policies::rounding         rnd;
+    typedef typename Policies::checking checking;
+    T l = (x.lower() <= static_cast<T>(-1)) ? checking::neg_inf() : rnd.atanh_down(x.lower());
+    T u = (x.upper() >= static_cast<T>(1)) ? checking::pos_inf() : rnd.atanh_up(x.upper());
+    return I(l, u, true);
+}
+
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_TRANSC_HPP

cpp/2_Concepts_and_Techniques/interval/boost/numeric/interval/utility.hpp

@@ -0,0 +1,327 @@
+/* Boost interval/utility.hpp template implementation file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002-2003 Herv<72> Br<42>nnimann, Guillaume Melquiond, Sylvain Pion
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or
+ * copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_INTERVAL_UTILITY_HPP
+#define BOOST_NUMERIC_INTERVAL_UTILITY_HPP
+
+#include <algorithm>
+#include <boost/config.hpp>
+#include <boost/numeric/interval/detail/bugs.hpp>
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+#include <utility>
+
+/*
+ * Implementation of simple functions
+ */
+
+namespace boost {
+namespace numeric {
+
+/*
+ * Utility Functions
+ */
+
+template <class T, class Policies> inline const T &lower(const interval<T, Policies> &x) { return x.lower(); }
+
+template <class T, class Policies> inline const T &upper(const interval<T, Policies> &x) { return x.upper(); }
+
+template <class T, class Policies> inline T checked_lower(const interval<T, Policies> &x)
+{
+    if (empty(x)) {
+        typedef typename Policies::checking checking;
+        return checking::nan();
+    }
+    return x.lower();
+}
+
+template <class T, class Policies> inline T checked_upper(const interval<T, Policies> &x)
+{
+    if (empty(x)) {
+        typedef typename Policies::checking checking;
+        return checking::nan();
+    }
+    return x.upper();
+}
+
+template <class T, class Policies> inline T width(const interval<T, Policies> &x)
+{
+    if (interval_lib::detail::test_input(x))
+        return static_cast<T>(0);
+    typename Policies::rounding rnd;
+    return rnd.sub_up(x.upper(), x.lower());
+}
+
+template <class T, class Policies> inline T median(const interval<T, Policies> &x)
+{
+    if (interval_lib::detail::test_input(x)) {
+        typedef typename Policies::checking checking;
+        return checking::nan();
+    }
+    typename Policies::rounding rnd;
+    return rnd.median(x.lower(), x.upper());
+}
+
+template <class T, class Policies> inline interval<T, Policies> widen(const interval<T, Policies> &x, const T &v)
+{
+    if (interval_lib::detail::test_input(x))
+        return interval<T, Policies>::empty();
+    typename Policies::rounding rnd;
+    return interval<T, Policies>(rnd.sub_down(x.lower(), v), rnd.add_up(x.upper(), v), true);
+}
+
+/*
+ * Set-like operations
+ */
+
+template <class T, class Policies> inline bool empty(const interval<T, Policies> &x)
+{
+    return interval_lib::detail::test_input(x);
+}
+
+template <class T, class Policies> inline bool zero_in(const interval<T, Policies> &x)
+{
+    if (interval_lib::detail::test_input(x))
+        return false;
+    return (!interval_lib::user::is_pos(x.lower())) && (!interval_lib::user::is_neg(x.upper()));
+}
+
+template <class T, class Policies> inline bool in_zero(const interval<T, Policies> &x) // DEPRECATED
+{
+    return zero_in<T, Policies>(x);
+}
+
+template <class T, class Policies> inline bool in(const T &x, const interval<T, Policies> &y)
+{
+    if (interval_lib::detail::test_input(x, y))
+        return false;
+    return y.lower() <= x && x <= y.upper();
+}
+
+template <class T, class Policies> inline bool subset(const interval<T, Policies> &x, const interval<T, Policies> &y)
+{
+    if (empty(x))
+        return true;
+    return !empty(y) && y.lower() <= x.lower() && x.upper() <= y.upper();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool proper_subset(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (empty(y))
+        return false;
+    if (empty(x))
+        return true;
+    return y.lower() <= x.lower() && x.upper() <= y.upper() && (y.lower() != x.lower() || x.upper() != y.upper());
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool overlap(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (interval_lib::detail::test_input(x, y))
+        return false;
+    return x.lower() <= y.lower() && y.lower() <= x.upper() || y.lower() <= x.lower() && x.lower() <= y.upper();
+}
+
+template <class T, class Policies> inline bool singleton(const interval<T, Policies> &x)
+{
+    return !empty(x) && x.lower() == x.upper();
+}
+
+template <class T, class Policies1, class Policies2>
+inline bool equal(const interval<T, Policies1> &x, const interval<T, Policies2> &y)
+{
+    if (empty(x))
+        return empty(y);
+    return !empty(y) && x.lower() == y.lower() && x.upper() == y.upper();
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> intersect(const interval<T, Policies> &x, const interval<T, Policies> &y)
+{
+    BOOST_USING_STD_MIN();
+    BOOST_USING_STD_MAX();
+    if (interval_lib::detail::test_input(x, y))
+        return interval<T, Policies>::empty();
+    const T &l = max BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y.lower());
+    const T &u = min BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y.upper());
+    if (l <= u)
+        return interval<T, Policies>(l, u, true);
+    else
+        return interval<T, Policies>::empty();
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> hull(const interval<T, Policies> &x, const interval<T, Policies> &y)
+{
+    BOOST_USING_STD_MIN();
+    BOOST_USING_STD_MAX();
+    bool bad_x = interval_lib::detail::test_input(x);
+    bool bad_y = interval_lib::detail::test_input(y);
+    if (bad_x)
+        if (bad_y)
+            return interval<T, Policies>::empty();
+        else
+            return y;
+    else if (bad_y)
+        return x;
+    return interval<T, Policies>(min BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y.lower()),
+                                 max BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y.upper()),
+                                 true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> hull(const interval<T, Policies> &x, const T &y)
+{
+    BOOST_USING_STD_MIN();
+    BOOST_USING_STD_MAX();
+    bool bad_x = interval_lib::detail::test_input(x);
+    bool bad_y = interval_lib::detail::test_input<T, Policies>(y);
+    if (bad_y)
+        if (bad_x)
+            return interval<T, Policies>::empty();
+        else
+            return x;
+    else if (bad_x)
+        return interval<T, Policies>(y, y, true);
+    return interval<T, Policies>(
+        min BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y), max BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y), true);
+}
+
+template <class T, class Policies> inline interval<T, Policies> hull(const T &x, const interval<T, Policies> &y)
+{
+    BOOST_USING_STD_MIN();
+    BOOST_USING_STD_MAX();
+    bool bad_x = interval_lib::detail::test_input<T, Policies>(x);
+    bool bad_y = interval_lib::detail::test_input(y);
+    if (bad_x)
+        if (bad_y)
+            return interval<T, Policies>::empty();
+        else
+            return y;
+    else if (bad_y)
+        return interval<T, Policies>(x, x, true);
+    return interval<T, Policies>(
+        min BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.lower()), max BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.upper()), true);
+}
+
+template <class T> inline interval<T> hull(const T &x, const T &y) { return interval<T>::hull(x, y); }
+
+template <class T, class Policies>
+inline std::pair<interval<T, Policies>, interval<T, Policies>> bisect(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x))
+        return std::pair<I, I>(I::empty(), I::empty());
+    const T m = median(x);
+    return std::pair<I, I>(I(x.lower(), m, true), I(m, x.upper(), true));
+}
+
+/*
+ * Elementary functions
+ */
+
+template <class T, class Policies> inline T norm(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x)) {
+        typedef typename Policies::checking checking;
+        return checking::nan();
+    }
+    BOOST_USING_STD_MAX();
+    return max BOOST_PREVENT_MACRO_SUBSTITUTION(static_cast<T>(-x.lower()), x.upper());
+}
+
+template <class T, class Policies> inline interval<T, Policies> abs(const interval<T, Policies> &x)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x))
+        return I::empty();
+    if (!interval_lib::user::is_neg(x.lower()))
+        return x;
+    if (!interval_lib::user::is_pos(x.upper()))
+        return -x;
+    BOOST_USING_STD_MAX();
+    return I(static_cast<T>(0), max BOOST_PREVENT_MACRO_SUBSTITUTION(static_cast<T>(-x.lower()), x.upper()), true);
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> max BOOST_PREVENT_MACRO_SUBSTITUTION(const interval<T, Policies> &x,
+                                                                  const interval<T, Policies> &y)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x, y))
+        return I::empty();
+    BOOST_USING_STD_MAX();
+    return I(max BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y.lower()),
+             max BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y.upper()),
+             true);
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> max BOOST_PREVENT_MACRO_SUBSTITUTION(const interval<T, Policies> &x, const T &y)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x, y))
+        return I::empty();
+    BOOST_USING_STD_MAX();
+    return I(
+        max BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y), max BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y), true);
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> max BOOST_PREVENT_MACRO_SUBSTITUTION(const T &x, const interval<T, Policies> &y)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x, y))
+        return I::empty();
+    BOOST_USING_STD_MAX();
+    return I(
+        max BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.lower()), max BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.upper()), true);
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> min BOOST_PREVENT_MACRO_SUBSTITUTION(const interval<T, Policies> &x,
+                                                                  const interval<T, Policies> &y)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x, y))
+        return I::empty();
+    BOOST_USING_STD_MIN();
+    return I(min BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y.lower()),
+             min BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y.upper()),
+             true);
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> min BOOST_PREVENT_MACRO_SUBSTITUTION(const interval<T, Policies> &x, const T &y)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x, y))
+        return I::empty();
+    BOOST_USING_STD_MIN();
+    return I(
+        min BOOST_PREVENT_MACRO_SUBSTITUTION(x.lower(), y), min BOOST_PREVENT_MACRO_SUBSTITUTION(x.upper(), y), true);
+}
+
+template <class T, class Policies>
+inline interval<T, Policies> min BOOST_PREVENT_MACRO_SUBSTITUTION(const T &x, const interval<T, Policies> &y)
+{
+    typedef interval<T, Policies> I;
+    if (interval_lib::detail::test_input(x, y))
+        return I::empty();
+    BOOST_USING_STD_MIN();
+    return I(
+        min BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.lower()), min BOOST_PREVENT_MACRO_SUBSTITUTION(x, y.upper()), true);
+}
+
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_UTILITY_HPP