Merged latest version of the boost 1.63.0 vendor drop

git-svn-id: svn+ssh://svn.code.sf.net/p/wsjt/wsjt/branches/wsjtx@7593 ab8295b8-cf94-4d9e-aec4-7959e3be5d79

boost/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

boost/boost/numeric/interval/ext/integer.hpp

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

boost/boost/numeric/interval/ext/x86_fast_rounding_control.hpp

@@ -0,0 +1,70 @@
+/* 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é 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_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

boost/boost/numeric/interval/io.hpp

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

boost/boost/numeric/interval/limits.hpp

@@ -0,0 +1,49 @@
+/* Boost interval/limits.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_LIMITS_HPP
+#define BOOST_NUMERIC_INTERVAL_LIMITS_HPP
+
+
+#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 // BOOST_NUMERIC_INTERVAL_LIMITS_HPP