[Boost-commit] svn:boost r42244 - in sandbox/math_toolkit: boost/math/special_functions libs/math/test

From: john_at_[hidden]
Date: 2007-12-22 14:01:38

Author: johnmaddock
Date: 2007-12-22 14:01:37 EST (Sat, 22 Dec 2007)
New Revision: 42244
URL: http://svn.boost.org/trac/boost/changeset/42244

Log:
Added trunc, round and fmod family of functions.
Added:
   sandbox/math_toolkit/boost/math/special_functions/modf.hpp   (contents, props changed)
   sandbox/math_toolkit/boost/math/special_functions/round.hpp   (contents, props changed)
   sandbox/math_toolkit/boost/math/special_functions/trunc.hpp   (contents, props changed)
   sandbox/math_toolkit/libs/math/test/test_round.cpp   (contents, props changed)
Text files modified: 
   sandbox/math_toolkit/libs/math/test/Jamfile.v2 |     1 +                                       
   1 files changed, 1 insertions(+), 0 deletions(-)

Added: sandbox/math_toolkit/boost/math/special_functions/modf.hpp
==============================================================================
--- (empty file)
+++ sandbox/math_toolkit/boost/math/special_functions/modf.hpp	2007-12-22 14:01:37 EST (Sat, 22 Dec 2007)
@@ -0,0 +1,50 @@
+//  Copyright John Maddock 2007.
+//  Use, modification and distribution are subject to 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_MATH_MODF_HPP
+#define BOOST_MATH_MODF_HPP
+
+#ifdef _MSC_VER
+#pragma once
+#endif
+
+#include <boost/math/tools/config.hpp>
+#include <boost/math/special_functions/trunc.hpp>
+
+namespace boost{ namespace math{
+
+template <class T>
+inline T modf(const T& v, T* ipart)
+{
+   *ipart = trunc(v);
+   return v - *ipart;
+}
+
+template <class T>
+inline T modf(const T& v, int* ipart)
+{
+   *ipart = itrunc(v);
+   return v - *ipart;
+}
+
+template <class T>
+inline T modf(const T& v, long* ipart)
+{
+   *ipart = ltrunc(v);
+   return v - *ipart;
+}
+
+#ifdef BOOST_HAS_LONG_LONG
+template <class T>
+inline T modf(const T& v, long long* ipart)
+{
+   *ipart = lltrunc(v);
+   return v - *ipart;
+}
+#endif
+
+}} // namespaces
+
+#endif // BOOST_MATH_MODF_HPP

Added: sandbox/math_toolkit/boost/math/special_functions/round.hpp
==============================================================================
--- (empty file)
+++ sandbox/math_toolkit/boost/math/special_functions/round.hpp	2007-12-22 14:01:37 EST (Sat, 22 Dec 2007)
@@ -0,0 +1,56 @@
+//  Copyright John Maddock 2007.
+//  Use, modification and distribution are subject to 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_MATH_ROUND_HPP
+#define BOOST_MATH_ROUND_HPP
+
+#ifdef _MSC_VER
+#pragma once
+#endif
+
+#include <boost/math/tools/config.hpp>
+
+namespace boost{ namespace math{
+
+template <class T>
+inline T round(const T& v)
+{
+   BOOST_MATH_STD_USING
+   return floor(v + 0.5f);
+}
+//
+// The following functions will not compile unless T has an
+// implicit convertion to the integer types.  For user-defined
+// number types this will likely not be the case.  In that case
+// these functions should either be specialized for the UDT in
+// question, or else overloads should be placed in the same 
+// namespace as the UDT: these will then be found via argument
+// dependent lookup.  See our concept archetypes for examples.
+//
+template <class T>
+inline int iround(const T& v)
+{
+   return static_cast<int>(boost::math::round(v));
+}
+
+template <class T>
+inline long lround(const T& v)
+{
+   return static_cast<long int>(boost::math::round(v));
+}
+
+#ifdef BOOST_HAS_LONG_LONG
+
+template <class T>
+inline long long llround(const T& v)
+{
+   return static_cast<long long>(boost::math::round(v));
+}
+
+#endif
+
+}} // namespaces
+
+#endif // BOOST_MATH_ROUND_HPP

Added: sandbox/math_toolkit/boost/math/special_functions/trunc.hpp
==============================================================================
--- (empty file)
+++ sandbox/math_toolkit/boost/math/special_functions/trunc.hpp	2007-12-22 14:01:37 EST (Sat, 22 Dec 2007)
@@ -0,0 +1,56 @@
+//  Copyright John Maddock 2007.
+//  Use, modification and distribution are subject to 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_MATH_TRUNC_HPP
+#define BOOST_MATH_TRUNC_HPP
+
+#ifdef _MSC_VER
+#pragma once
+#endif
+
+#include <boost/math/tools/config.hpp>
+
+namespace boost{ namespace math{
+
+template <class T>
+inline T trunc(const T& v)
+{
+   BOOST_MATH_STD_USING
+   return (v >= 0) ? floor(v) : ceil(v);
+}
+//
+// The following functions will not compile unless T has an
+// implicit convertion to the integer types.  For user-defined
+// number types this will likely not be the case.  In that case
+// these functions should either be specialized for the UDT in
+// question, or else overloads should be placed in the same 
+// namespace as the UDT: these will then be found via argument
+// dependent lookup.  See our concept archetypes for examples.
+//
+template <class T>
+inline int itrunc(const T& v)
+{
+   return static_cast<int>(boost::math::trunc(v));
+}
+
+template <class T>
+inline long ltrunc(const T& v)
+{
+   return static_cast<long int>(boost::math::trunc(v));
+}
+
+#ifdef BOOST_HAS_LONG_LONG
+
+template <class T>
+inline long long lltrunc(const T& v)
+{
+   return static_cast<long long>(boost::math::trunc(v));
+}
+
+#endif
+
+}} // namespaces
+
+#endif // BOOST_MATH_TRUNC_HPP

Modified: sandbox/math_toolkit/libs/math/test/Jamfile.v2
==============================================================================
--- sandbox/math_toolkit/libs/math/test/Jamfile.v2	(original)
+++ sandbox/math_toolkit/libs/math/test/Jamfile.v2	2007-12-22 14:01:37 EST (Sat, 22 Dec 2007)
@@ -299,6 +299,7 @@
 
 run test_remez.cpp ;
 run test_roots.cpp ;
+run test_round.cpp ;
 run test_spherical_harmonic.cpp ;
 run test_students_t.cpp ;
 run test_tgamma_ratio.cpp ;

Added: sandbox/math_toolkit/libs/math/test/test_round.cpp
==============================================================================
--- (empty file)
+++ sandbox/math_toolkit/libs/math/test/test_round.cpp	2007-12-22 14:01:37 EST (Sat, 22 Dec 2007)
@@ -0,0 +1,176 @@
+//  (C) Copyright John Maddock 2007.
+//  Use, modification and distribution are subject to 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)
+
+#include <boost/math/concepts/real_concept.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+#include <boost/math/special_functions/round.hpp>
+#include <boost/math/special_functions/trunc.hpp>
+#include <boost/math/special_functions/modf.hpp>
+#include <boost/math/special_functions/sign.hpp>
+#include <boost/random/mersenne_twister.hpp>
+
+boost::mt19937 rng;
+
+template <class T>
+T get_random()
+{
+   //
+   // Fill all the bits in T with random values, 
+   // likewise set the exponent to a random value
+   // that will still fit inside a T, and always
+   // have a remainder as well as an integer part.
+   //
+   int bits = boost::math::tools::digits<T>();
+   int shift = 0;
+   int exponent = rng() % (bits - 4);
+   T result = 0;
+   while(bits > 0)
+   {
+      result += ldexp(static_cast<T>(rng()), shift);
+      shift += std::numeric_limits<int>::digits;
+      bits -= std::numeric_limits<int>::digits;
+   }
+   return rng() & 1u ? -ldexp(frexp(result, &bits), exponent) : ldexp(frexp(result, &bits), exponent);
+}
+
+template <class T, class U>
+void check_within_half(T a, U u)
+{
+   if(fabs(a-u) > 0.5f)
+   {
+      BOOST_ERROR("Rounded result differed by more than 0.5 from the original");
+      std::cerr << "Values were: " << std::setprecision(35) << std::setw(40)
+         << std::left << a << u << std::endl;
+   }
+}
+
+//
+// We may not have an abs overload for long long so provide a fall back:
+//
+template <class T>
+inline T safe_abs(T const& v ...)
+{
+   return v < 0 ? -v : v;
+}
+
+template <class T, class U>
+void check_trunc_result(T a, U u)
+{
+   BOOST_MATH_STD_USING
+   using ::abs;
+   if(fabs(a-u) >= 1)
+   {
+      BOOST_ERROR("Rounded result differed by more than 1 from the original");
+      std::cerr << "Values were: " << std::setprecision(35) << std::setw(40)
+         << std::left << a << u << std::endl;
+   }
+   if(abs(a) < safe_abs(u))
+   {
+      BOOST_ERROR("Truncated result had larger absolute value than the original");
+      std::cerr << "Values were: " << std::setprecision(35) << std::setw(40)
+         << std::left << a << u << std::endl;
+   }
+}
+
+template <class T, class U>
+void check_modf_result(T a, T fract, U ipart)
+{
+   BOOST_MATH_STD_USING
+   if(fract + ipart != a)
+   {
+      BOOST_ERROR("Fractional and integer results do not add up to the original value");
+      std::cerr << "Values were: " << std::setprecision(35) << " "
+         << std::left << a << ipart << " " << fract << std::endl;
+   }
+   if((boost::math::sign(a) != boost::math::sign(fract)) && boost::math::sign(fract))
+   {
+      BOOST_ERROR("Original and fractional parts have differing signs");
+      std::cerr << "Values were: " << std::setprecision(35) << " "
+         << std::left << a << ipart << " " << fract << std::endl;
+   }
+   if((boost::math::sign(a) != boost::math::sign(ipart)) && boost::math::sign(ipart))
+   {
+      BOOST_ERROR("Original and integer parts have differing signs");
+      std::cerr << "Values were: " << std::setprecision(35) << " "
+         << std::left << a << ipart << " " << ipart << std::endl;
+   }
+   if(fabs(a-ipart) >= 1)
+   {
+      BOOST_ERROR("Rounded result differed by more than 1 from the original");
+      std::cerr << "Values were: " << std::setprecision(35) << std::setw(40)
+         << std::left << a << ipart << std::endl;
+   }
+}
+
+template <class T>
+void test_round(T, const char* name)
+{
+   BOOST_MATH_STD_USING
+
+   for(int i = 0; i < 1000; ++i)
+   {
+      T arg = get_random<T>();
+      T r = boost::math::round(arg);
+      check_within_half(arg, r);
+      r = boost::math::trunc(arg);
+      check_trunc_result(arg, r);
+      T frac = boost::math::modf(arg, &r);
+      check_modf_result(arg, frac, r);
+
+      if(abs(r) < (std::numeric_limits<int>::max)())
+      {
+         int i = boost::math::iround(arg);
+         check_within_half(arg, i);
+         i = boost::math::itrunc(arg);
+         check_trunc_result(arg, i);
+         r = boost::math::modf(arg, &i);
+         check_modf_result(arg, r, i);
+      }
+      
+      if(abs(r) < (std::numeric_limits<long>::max)())
+      {
+         long l = boost::math::lround(arg);
+         check_within_half(arg, l);
+         l = boost::math::ltrunc(arg);
+         check_trunc_result(arg, l);
+         r = boost::math::modf(arg, &l);
+         check_modf_result(arg, r, l);
+      }
+
+#ifdef BOOST_HAS_LONG_LONG
+      if(abs(r) < (std::numeric_limits<long long>::max)())
+      {
+         long long ll = boost::math::llround(arg);
+         check_within_half(arg, ll);
+         ll = boost::math::lltrunc(arg);
+         check_trunc_result(arg, ll);
+         r = boost::math::modf(arg, &ll);
+         check_modf_result(arg, r, ll);
+      }
+#endif
+   }
+}
+
+int test_main(int, char* [])
+{
+   test_round(0.1F, "float");
+   test_round(0.1, "double");
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   test_round(0.1L, "long double");
+   //test_round(boost::math::concepts::real_concept(0.1), "real_concept");
+#else
+   std::cout << "<note>The long double tests have been disabled on this platform "
+      "either because the long double overloads of the usual math functions are "
+      "not available at all, or because they are too inaccurate for these tests "
+      "to pass.</note>" << std::cout;
+#endif
+   return 0;
+}
+
+
+
+
+