boost.cxx 0.0.2 → 1.90.1

package/boost/numeric/interval/detail/sparc_rounding_control.hpp

@@ -0,0 +1,112 @@
+/* Boost interval/detail/sparc_rounding_control.hpp 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)
+ *
+ * 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 */

package/boost/numeric/interval/detail/test_input.hpp

@@ -0,0 +1,76 @@
+/* Boost interval/detail/test_input.hpp 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_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

package/boost/numeric/interval/detail/x86_rounding_control.hpp

@@ -0,0 +1,108 @@
+/* Boost interval/detail/x86_rounding_control.hpp 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_DETAIL_X86_ROUNDING_CONTROL_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_X86_ROUNDING_CONTROL_HPP
+
+#if defined(__GNUC__) || defined(__BORLANDC__) && defined(__clang__)
+#  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) || defined (__SUNPRO_CC)
+#  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_control 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 */

package/boost/numeric/interval/detail/x86gcc_rounding_control.hpp

@@ -0,0 +1,51 @@
+/* Boost interval/detail/x86gcc_rounding_control.hpp 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_DETAIL_X86GCC_ROUNDING_CONTROL_HPP
+#define BOOST_NUMERIC_INTERVAL_DETAIL_X86GCC_ROUNDING_CONTROL_HPP
+
+#if !defined(__GNUC__) && !(defined(__BORLANDC__) && defined(__clang__))
+#  error This header only works with GNU CC.
+#endif
+
+#if !defined(__i386__) && !defined(__x86_64__)
+#  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 */

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

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

package/boost/numeric/interval/hw_rounding.hpp

@@ -0,0 +1,73 @@
+/* Boost interval/hw_rounding.hpp template implementation file
+ *
+ * Copyright 2002 Hervé Brö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/config.hpp>
+#include <boost/numeric/interval/rounding.hpp>
+#include <boost/numeric/interval/rounded_arith.hpp>
+
+#define BOOST_NUMERIC_INTERVAL_NO_HARDWARE
+
+// define appropriate specialization of rounding_control for built-in types
+#if defined(__x86_64__) && !defined(BOOST_NO_FENV_H)
+#  include <boost/numeric/interval/detail/c99_rounding_control.hpp>
+#elif defined(__i386__) || defined(_M_IX86) || defined(__BORLANDC__) && !defined(__clang__) || defined(_M_X64)
+#  include <boost/numeric/interval/detail/x86_rounding_control.hpp>
+#elif defined(__i386) && defined(__SUNPRO_CC)
+#  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(BOOST_NO_FENV_H)
+#  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