Paradiseo-eo sources added

git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@40 331e1502-861f-0410-8da2-ba01fb791d7f

trunk/paradiseo-eo/contrib/boost/numeric/interval/CVS/Entries

@@ -0,0 +1,17 @@
+/arith.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/arith2.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/arith3.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/checking.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/compare.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/constants.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/hw_rounding.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/interval.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/io.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/limits.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/policies.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/rounded_arith.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/rounded_transc.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/rounding.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/transc.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/utility.hpp/1.1/Thu Oct  6 12:13:52 2005//
+D

trunk/paradiseo-eo/contrib/boost/numeric/interval/CVS/Entries.Log

@@ -0,0 +1,3 @@
+A D/compare////
+A D/detail////
+A D/ext////

trunk/paradiseo-eo/contrib/boost/numeric/interval/CVS/Repository

@@ -0,0 +1 @@
+eo/contrib/boost/numeric/interval

trunk/paradiseo-eo/contrib/boost/numeric/interval/CVS/Root

@@ -0,0 +1 @@
+:ext:evomarc@eodev.cvs.sourceforge.net:/cvsroot/eodev

trunk/paradiseo-eo/contrib/boost/numeric/interval/arith.hpp

@@ -0,0 +1,305 @@
+/* Boost interval/arith.hpp template implementation file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002-2003 Hervé Brö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 <boost/config.hpp>
+#include <boost/numeric/interval/interval.hpp>
+#include <boost/numeric/interval/detail/bugs.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+#include <boost/numeric/interval/detail/division.hpp>
+#include <algorithm>
+
+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 (in_zero(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 (in_zero(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

trunk/paradiseo-eo/contrib/boost/numeric/interval/arith2.hpp

@@ -0,0 +1,212 @@
+/* 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é Brö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 <boost/config.hpp>
+#include <boost/numeric/interval/detail/interval_prototype.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+#include <boost/numeric/interval/detail/bugs.hpp>
+#include <boost/numeric/interval/detail/division.hpp>
+#include <boost/numeric/interval/arith.hpp>
+#include <boost/numeric/interval/policies.hpp>
+#include <algorithm>
+#include <cmath>
+
+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 (in_zero(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 (in_zero(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_aux(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_aux;
+  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_aux(-x.upper(), pwr, rnd);
+    T yu = pow_aux(-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_aux(-x.lower(), pwr, rnd), pow_aux(x.upper(), pwr, rnd), true);
+    } else {         // [-1,1]^2
+      return I(static_cast<T>(0), pow_aux(max BOOST_PREVENT_MACRO_SUBSTITUTION(-x.lower(), x.upper()), pwr, rnd), true);
+    }
+  } else {                                // [1,2]
+    return I(pow_aux(x.lower(), pwr, rnd), pow_aux(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 numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_INTERVAL_ARITH2_HPP

trunk/paradiseo-eo/contrib/boost/numeric/interval/arith3.hpp

@@ -0,0 +1,69 @@
+/* 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

trunk/paradiseo-eo/contrib/boost/numeric/interval/checking.hpp

@@ -0,0 +1,130 @@
+/* Boost interval/checking.hpp template implementation file
+ *
+ * Copyright 2002 Hervé Brö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 <stdexcept>
+#include <string>
+#include <cassert>
+#include <boost/limits.hpp>
+
+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

trunk/paradiseo-eo/contrib/boost/numeric/interval/compare.hpp

@@ -0,0 +1,19 @@
+/* Boost interval/compare.hpp template implementation file
+ *
+ * Copyright 2002 Hervé Brö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/possible.hpp>
+#include <boost/numeric/interval/compare/explicit.hpp>
+#include <boost/numeric/interval/compare/lexicographic.hpp>
+#include <boost/numeric/interval/compare/set.hpp>
+
+#endif // BOOST_NUMERIC_INTERVAL_COMPARE_HPP

trunk/paradiseo-eo/contrib/boost/numeric/interval/compare/CVS/Entries

@@ -0,0 +1,7 @@
+/certain.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/explicit.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/lexicographic.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/possible.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/set.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/tribool.hpp/1.1/Thu Oct  6 12:13:52 2005//
+D

trunk/paradiseo-eo/contrib/boost/numeric/interval/compare/CVS/Repository

@@ -0,0 +1 @@
+eo/contrib/boost/numeric/interval/compare

trunk/paradiseo-eo/contrib/boost/numeric/interval/compare/CVS/Root

@@ -0,0 +1 @@
+:ext:evomarc@eodev.cvs.sourceforge.net:/cvsroot/eodev

trunk/paradiseo-eo/contrib/boost/numeric/interval/compare/certain.hpp

@@ -0,0 +1,113 @@
+/* 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

trunk/paradiseo-eo/contrib/boost/numeric/interval/compare/explicit.hpp

@@ -0,0 +1,248 @@
+/* Boost interval/compare/explicit.hpp template implementation file
+ *
+ * Copyright 2000 Jens Maurer
+ * Copyright 2002 Hervé Brö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

trunk/paradiseo-eo/contrib/boost/numeric/interval/compare/lexicographic.hpp

@@ -0,0 +1,122 @@
+/* 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

trunk/paradiseo-eo/contrib/boost/numeric/interval/compare/possible.hpp

@@ -0,0 +1,113 @@
+/* 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

trunk/paradiseo-eo/contrib/boost/numeric/interval/compare/set.hpp

@@ -0,0 +1,101 @@
+/* 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

trunk/paradiseo-eo/contrib/boost/numeric/interval/compare/tribool.hpp

@@ -0,0 +1,138 @@
+/* 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/numeric/interval/detail/interval_prototype.hpp>
+#include <boost/numeric/interval/detail/test_input.hpp>
+#include <boost/logic/tribool.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

trunk/paradiseo-eo/contrib/boost/numeric/interval/constants.hpp

@@ -0,0 +1,85 @@
+/* Boost interval/constants.hpp template implementation file
+ *
+ * Copyright 2002 Hervé Brö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

trunk/paradiseo-eo/contrib/boost/numeric/interval/detail/CVS/Entries

@@ -0,0 +1,13 @@
+/bcc_rounding_control.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/bugs.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/c99_rounding_control.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/c99sub_rounding_control.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/division.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/interval_prototype.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/msvc_rounding_control.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/ppc_rounding_control.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/sparc_rounding_control.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/test_input.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/x86_rounding_control.hpp/1.1/Thu Oct  6 12:13:52 2005//
+/x86gcc_rounding_control.hpp/1.1/Thu Oct  6 12:13:52 2005//
+D