[Boost-commit] svn:boost r74167 - in sandbox/big_number: boost/math/big_number boost/math/concepts libs/math/test

Subject: [Boost-commit] svn:boost r74167 - in sandbox/big_number: boost/math/big_number boost/math/concepts libs/math/test
From: john_at_[hidden]
Date: 2011-08-30 14:08:57

Author: johnmaddock
Date: 2011-08-30 14:08:56 EDT (Tue, 30 Aug 2011)
New Revision: 74167
URL: http://svn.boost.org/trac/boost/changeset/74167

Log:
Added fpclassify routines.
Text files modified: 
   sandbox/big_number/boost/math/big_number/default_ops.hpp         |    67 ++++++++++++++++++++++++++++++++++++++++
   sandbox/big_number/boost/math/big_number/e_float.hpp             |     5 ++                                      
   sandbox/big_number/boost/math/big_number/mpfr.hpp                |     6 +++                                     
   sandbox/big_number/boost/math/concepts/big_number_architypes.hpp |     5 ++                                      
   sandbox/big_number/libs/math/test/test_numeric_limits.cpp        |    48 ++++++++++++++++++++++++++++            
   5 files changed, 130 insertions(+), 1 deletions(-)

Modified: sandbox/big_number/boost/math/big_number/default_ops.hpp
==============================================================================
--- sandbox/big_number/boost/math/big_number/default_ops.hpp	(original)
+++ sandbox/big_number/boost/math/big_number/default_ops.hpp	2011-08-30 14:08:56 EDT (Tue, 30 Aug 2011)
@@ -7,6 +7,7 @@
 #define BOOST_MATH_BIG_NUM_DEF_OPS
 
 #include <boost/math/big_number/big_number_base.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
 
 namespace boost{ namespace math{ namespace big_num_default_ops{
 
@@ -343,6 +344,11 @@
       result->negate();
 }
 
+template <class Backend>
+inline int eval_fpclassify(const Backend& arg)
+{
+   return is_zero(arg) ? FP_ZERO : FP_NORMAL;
+}
 //
 // These have to implemented by the backend, declared here so that our macro generated code compiles OK.
 //
@@ -376,6 +382,67 @@
 
 }
 
+//
+// Default versions of floating point classification routines:
+//
+template <class Backend>
+inline int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(const big_number<Backend>& arg)
+{
+   using big_num_default_ops::eval_fpclassify;
+   return eval_fpclassify(arg.backend());
+}
+template <class Exp>
+inline int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::big_number_exp<Exp>& arg)
+{
+   typedef typename expression_type<Exp>::type value_type;
+   return fpclassify(value_type(arg));
+}
+template <class Backend>
+inline bool isfinite BOOST_PREVENT_MACRO_SUBSTITUTION(const big_number<Backend>& arg)
+{
+   int v = fpclassify(arg);
+   return (v != FP_INFINITE) && (v != FP_NAN);
+}
+template <class Exp>
+inline bool isfinite BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::big_number_exp<Exp>& arg)
+{
+   typedef typename expression_type<Exp>::type value_type;
+   return isfinite(value_type(arg));
+}
+template <class Backend>
+inline bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION(const big_number<Backend>& arg)
+{
+   return fpclassify(arg) == FP_NAN;
+}
+template <class Exp>
+inline bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::big_number_exp<Exp>& arg)
+{
+   typedef typename expression_type<Exp>::type value_type;
+   return isnan(value_type(arg));
+}
+template <class Backend>
+inline bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION(const big_number<Backend>& arg)
+{
+   return fpclassify(arg) == FP_INFINITE;
+}
+template <class Exp>
+inline bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::big_number_exp<Exp>& arg)
+{
+   typedef typename expression_type<Exp>::type value_type;
+   return isinf(value_type(arg));
+}
+template <class Backend>
+inline bool isnormal BOOST_PREVENT_MACRO_SUBSTITUTION(const big_number<Backend>& arg)
+{
+   return fpclassify(arg) == FP_NORMAL;
+}
+template <class Exp>
+inline bool isnormal BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::big_number_exp<Exp>& arg)
+{
+   typedef typename expression_type<Exp>::type value_type;
+   return isnormal(value_type(arg));
+}
+
 #define UNARY_OP_FUNCTOR(func)\
 namespace detail{\
 template <class Backend>\

Modified: sandbox/big_number/boost/math/big_number/e_float.hpp
==============================================================================
--- sandbox/big_number/boost/math/big_number/e_float.hpp	(original)
+++ sandbox/big_number/boost/math/big_number/e_float.hpp	2011-08-30 14:08:56 EDT (Tue, 30 Aug 2011)
@@ -69,7 +69,10 @@
 {
    *result = val.data().extract_long_double();
 }
-
+inline int eval_fpclassify(const arithmetic_backend<efx::e_float>& val)
+{
+   return val.data().isinf() ? FP_INFINITE : val.data().isnan() ? FP_NAN : val.data().iszero() ? FP_ZERO : FP_NORMAL;
+}
 
 
 }} // namespaces

Modified: sandbox/big_number/boost/math/big_number/mpfr.hpp
==============================================================================
--- sandbox/big_number/boost/math/big_number/mpfr.hpp	(original)
+++ sandbox/big_number/boost/math/big_number/mpfr.hpp	2011-08-30 14:08:56 EDT (Tue, 30 Aug 2011)
@@ -642,6 +642,12 @@
    return ldexp(result, val, -*e);
 }
 
+template <unsigned Digits10>
+inline int eval_fpclassify(const mpfr_real_backend<Digits10>& val)
+{
+   return mpfr_inf_p(val.data()) ? FP_INFINITE : mpfr_nan_p(val.data()) ? FP_NAN : mpfr_zero_p(val.data()) ? FP_ZERO : FP_NORMAL;
+}
+
 typedef big_number<mpfr_real_backend<50> >    mpfr_real_50;
 typedef big_number<mpfr_real_backend<100> >   mpfr_real_100;
 typedef big_number<mpfr_real_backend<500> >   mpfr_real_500;

Modified: sandbox/big_number/boost/math/concepts/big_number_architypes.hpp
==============================================================================
--- sandbox/big_number/boost/math/concepts/big_number_architypes.hpp	(original)
+++ sandbox/big_number/boost/math/concepts/big_number_architypes.hpp	2011-08-30 14:08:56 EDT (Tue, 30 Aug 2011)
@@ -183,6 +183,11 @@
    result = std::fabs(arg.m_value);
 }
 
+inline int eval_fpclassify(const big_number_backend_real_architype& arg)
+{
+   return boost::math::fpclassify(arg.m_value);
+}
+
 typedef boost::math::big_number<big_number_backend_real_architype> big_number_real_architype;
 
 }}} // namespaces

Modified: sandbox/big_number/libs/math/test/test_numeric_limits.cpp
==============================================================================
--- sandbox/big_number/libs/math/test/test_numeric_limits.cpp	(original)
+++ sandbox/big_number/libs/math/test/test_numeric_limits.cpp	2011-08-30 14:08:56 EDT (Tue, 30 Aug 2011)
@@ -79,6 +79,54 @@
    PRINT(traps);
    PRINT(tinyness_before);
    PRINT(round_style);
+
+   if(std::numeric_limits<Number>::is_specialized)
+   {
+      if(std::numeric_limits<Number>::has_quiet_NaN)
+      {
+         BOOST_TEST((boost::math::isnan)(std::numeric_limits<Number>::quiet_NaN()));
+         BOOST_TEST(FP_NAN == (boost::math::fpclassify)(std::numeric_limits<Number>::quiet_NaN()));
+         BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::quiet_NaN()));
+         BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::quiet_NaN()));
+         BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::quiet_NaN()));
+      }
+      if(std::numeric_limits<Number>::has_signaling_NaN)
+      {
+         BOOST_TEST((boost::math::isnan)(std::numeric_limits<Number>::signaling_NaN()));
+         BOOST_TEST(FP_NAN == (boost::math::fpclassify)(std::numeric_limits<Number>::signaling_NaN()));
+         BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::signaling_NaN()));
+         BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::signaling_NaN()));
+         BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::signaling_NaN()));
+      }
+      if(std::numeric_limits<Number>::has_infinity)
+      {
+         BOOST_TEST((boost::math::isinf)(std::numeric_limits<Number>::infinity()));
+         BOOST_TEST(FP_INFINITE == (boost::math::fpclassify)(std::numeric_limits<Number>::infinity()));
+         BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::infinity()));
+         BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::infinity()));
+         BOOST_TEST(!(boost::math::isnan)(std::numeric_limits<Number>::infinity()));
+      }
+      if(std::numeric_limits<Number>::has_denorm)
+      {
+         BOOST_TEST(FP_SUBNORMAL == (boost::math::fpclassify)(std::numeric_limits<Number>::denorm_min()));
+         BOOST_TEST((boost::math::isfinite)(std::numeric_limits<Number>::denorm_min()));
+         BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::denorm_min()));
+         BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::denorm_min()));
+         BOOST_TEST(!(boost::math::isnan)(std::numeric_limits<Number>::denorm_min()));
+      }
+   }
+   Number n = 0;
+   BOOST_TEST((boost::math::fpclassify)(n) == FP_ZERO);
+   BOOST_TEST((boost::math::isfinite)(n));
+   BOOST_TEST(!(boost::math::isnormal)(n));
+   BOOST_TEST(!(boost::math::isinf)(n));
+   BOOST_TEST(!(boost::math::isnan)(n));
+   n = 2;
+   BOOST_TEST((boost::math::fpclassify)(n) == FP_NORMAL);
+   BOOST_TEST((boost::math::isfinite)(n));
+   BOOST_TEST((boost::math::isnormal)(n));
+   BOOST_TEST(!(boost::math::isinf)(n));
+   BOOST_TEST(!(boost::math::isnan)(n));
 }