Boost-Commit :

Date view	Thread view	Subject view	Author view

From: john_at_[hidden]
Date: 2008-08-10 05:12:05

Author: johnmaddock
Date: 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
New Revision: 48054
URL: http://svn.boost.org/trac/boost/changeset/48054

Log:
Added <cmath> support to the TR1 library.
Added Borland and Sun workaround headers to the TR1 lib.
Added a "no tr1" version of cmath to Boost.Config and made use of it throughout Boost.Math.
Added:
   trunk/boost/config/no_tr1/cmath.hpp (contents, props changed)
   trunk/boost/tr1/cmath.hpp (contents, props changed)
   trunk/boost/tr1/tr1/bcc32/unordere.h (contents, props changed)
   trunk/boost/tr1/tr1/cmath (contents, props changed)
   trunk/boost/tr1/tr1/sun/cmath.SUNWCCh (contents, props changed)
   trunk/boost/tr1/tr1/sun/unordered_map.SUNWCCh (contents, props changed)
   trunk/boost/tr1/tr1/sun/unordered_set.SUNWCCh (contents, props changed)
   trunk/libs/tr1/test/std_headers/test_cmath.cpp (contents, props changed)
   trunk/libs/tr1/test/test_cmath.cpp (contents, props changed)
Text files modified:
   trunk/boost/math/bindings/rr.hpp | 2
   trunk/boost/math/complex/details.hpp | 2
   trunk/boost/math/concepts/real_concept.hpp | 2
   trunk/boost/math/concepts/std_real_concept.hpp | 2
   trunk/boost/math/distributions/cauchy.hpp | 2
   trunk/boost/math/distributions/exponential.hpp | 2
   trunk/boost/math/distributions/extreme_value.hpp | 2
   trunk/boost/math/distributions/rayleigh.hpp | 2
   trunk/boost/math/policies/error_handling.hpp | 2
   trunk/boost/math/special_functions/acosh.hpp | 2
   trunk/boost/math/special_functions/asinh.hpp | 2
   trunk/boost/math/special_functions/atanh.hpp | 2
   trunk/boost/math/special_functions/beta.hpp | 2
   trunk/boost/math/special_functions/cos_pi.hpp | 2
   trunk/boost/math/special_functions/detail/unchecked_factorial.hpp | 2
   trunk/boost/math/special_functions/expm1.hpp | 2
   trunk/boost/math/special_functions/factorials.hpp | 2
   trunk/boost/math/special_functions/fpclassify.hpp | 2
   trunk/boost/math/special_functions/gamma.hpp | 2
   trunk/boost/math/special_functions/hypot.hpp | 2
   trunk/boost/math/special_functions/log1p.hpp | 2
   trunk/boost/math/special_functions/sin_pi.hpp | 2
   trunk/boost/math/special_functions/sinc.hpp | 2
   trunk/boost/math/special_functions/sinhc.hpp | 2
   trunk/boost/math/tools/config.hpp | 2
   trunk/boost/math/tools/fraction.hpp | 2
   trunk/boost/math/tools/minima.hpp | 2
   trunk/boost/math/tools/roots.hpp | 2
   trunk/boost/math/tools/series.hpp | 2
   trunk/boost/math/tools/stats.hpp | 2
   trunk/libs/tr1/doc/tr1.qbk | 269 ++++++++++++++++++++++++++++++++++++++-
   31 files changed, 291 insertions(+), 38 deletions(-)

Added: trunk/boost/config/no_tr1/cmath.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/config/no_tr1/cmath.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -0,0 +1,28 @@
+// (C) Copyright John Maddock 2008.
+// 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)
+//
+// The aim of this header is just to include <cmath> but to do
+// so in a way that does not result in recursive inclusion of
+// the Boost TR1 components if boost/tr1/tr1/cmath is in the
+// include search path. We have to do this to avoid circular
+// dependencies:
+//
+
+#ifndef BOOST_CONFIG_CMATH
+# define BOOST_CONFIG_CMATH
+
+# ifndef BOOST_TR1_NO_RECURSION
+# define BOOST_TR1_NO_RECURSION
+# define BOOST_CONFIG_NO_CMATH_RECURSION
+# endif
+
+# include <cmath>
+
+# ifdef BOOST_CONFIG_NO_CMATH_RECURSION
+# undef BOOST_TR1_NO_RECURSION
+# undef BOOST_CONFIG_NO_CMATH_RECURSION
+# endif
+
+#endif

Modified: trunk/boost/math/bindings/rr.hpp
==============================================================================
--- trunk/boost/math/bindings/rr.hpp (original)
+++ trunk/boost/math/bindings/rr.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -14,7 +14,7 @@

#include <ostream>
#include <istream>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <NTL/RR.h>

#ifndef BOOST_MATH_NTL_RR_HPP

Modified: trunk/boost/math/complex/details.hpp
==============================================================================
--- trunk/boost/math/complex/details.hpp (original)
+++ trunk/boost/math/complex/details.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -15,7 +15,7 @@
#include <boost/config/no_tr1/complex.hpp>
#include <boost/limits.hpp>
#include <math.h> // isnan where available
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>

#ifdef BOOST_NO_STDC_NAMESPACE
namespace std{ using ::sqrt; }

Modified: trunk/boost/math/concepts/real_concept.hpp
==============================================================================
--- trunk/boost/math/concepts/real_concept.hpp (original)
+++ trunk/boost/math/concepts/real_concept.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -32,7 +32,7 @@
#endif
#include <ostream>
#include <istream>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <math.h> // fmodl

#ifndef BOOST_MATH_REAL_CONCEPT_HPP

Modified: trunk/boost/math/concepts/std_real_concept.hpp
==============================================================================
--- trunk/boost/math/concepts/std_real_concept.hpp (original)
+++ trunk/boost/math/concepts/std_real_concept.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -24,7 +24,7 @@

#include <ostream>
#include <istream>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <math.h> // fmodl

#ifndef BOOST_MATH_STD_REAL_CONCEPT_HPP

Modified: trunk/boost/math/distributions/cauchy.hpp
==============================================================================
--- trunk/boost/math/distributions/cauchy.hpp (original)
+++ trunk/boost/math/distributions/cauchy.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -17,7 +17,7 @@
#include <boost/math/constants/constants.hpp>
#include <boost/math/distributions/complement.hpp>
#include <boost/math/distributions/detail/common_error_handling.hpp>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>

#include <utility>

Modified: trunk/boost/math/distributions/exponential.hpp
==============================================================================
--- trunk/boost/math/distributions/exponential.hpp (original)
+++ trunk/boost/math/distributions/exponential.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -12,7 +12,7 @@
#include <boost/math/special_functions/expm1.hpp>
#include <boost/math/distributions/complement.hpp>
#include <boost/math/distributions/detail/common_error_handling.hpp>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>

#ifdef BOOST_MSVC
# pragma warning(push)

Modified: trunk/boost/math/distributions/extreme_value.hpp
==============================================================================
--- trunk/boost/math/distributions/extreme_value.hpp (original)
+++ trunk/boost/math/distributions/extreme_value.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -12,7 +12,7 @@
#include <boost/math/special_functions/expm1.hpp>
#include <boost/math/distributions/complement.hpp>
#include <boost/math/distributions/detail/common_error_handling.hpp>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>

//
// This is the maximum extreme value distribution, see

Modified: trunk/boost/math/distributions/rayleigh.hpp
==============================================================================
--- trunk/boost/math/distributions/rayleigh.hpp (original)
+++ trunk/boost/math/distributions/rayleigh.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -12,7 +12,7 @@
#include <boost/math/special_functions/expm1.hpp>
#include <boost/math/distributions/complement.hpp>
#include <boost/math/distributions/detail/common_error_handling.hpp>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>

#ifdef BOOST_MSVC
# pragma warning(push)

Modified: trunk/boost/math/policies/error_handling.hpp
==============================================================================
--- trunk/boost/math/policies/error_handling.hpp (original)
+++ trunk/boost/math/policies/error_handling.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -12,7 +12,7 @@
#include <iomanip>
#include <string>
#include <cerrno>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <stdexcept>
#include <boost/math/tools/config.hpp>
#include <boost/math/policies/policy.hpp>

Modified: trunk/boost/math/special_functions/acosh.hpp
==============================================================================
--- trunk/boost/math/special_functions/acosh.hpp (original)
+++ trunk/boost/math/special_functions/acosh.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -14,7 +14,7 @@
#pragma once
#endif

-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <boost/config.hpp>
#include <boost/math/tools/precision.hpp>
#include <boost/math/policies/error_handling.hpp>

Modified: trunk/boost/math/special_functions/asinh.hpp
==============================================================================
--- trunk/boost/math/special_functions/asinh.hpp (original)
+++ trunk/boost/math/special_functions/asinh.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -15,7 +15,7 @@
#endif

-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <boost/config.hpp>
#include <boost/math/tools/precision.hpp>
#include <boost/math/special_functions/math_fwd.hpp>

Modified: trunk/boost/math/special_functions/atanh.hpp
==============================================================================
--- trunk/boost/math/special_functions/atanh.hpp (original)
+++ trunk/boost/math/special_functions/atanh.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -15,7 +15,7 @@
#endif

-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <boost/config.hpp>
#include <boost/math/tools/precision.hpp>
#include <boost/math/policies/error_handling.hpp>

Modified: trunk/boost/math/special_functions/beta.hpp
==============================================================================
--- trunk/boost/math/special_functions/beta.hpp (original)
+++ trunk/boost/math/special_functions/beta.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -20,7 +20,7 @@
#include <boost/math/special_functions/trunc.hpp>
#include <boost/math/tools/roots.hpp>
#include <boost/static_assert.hpp>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>

namespace boost{ namespace math{

Modified: trunk/boost/math/special_functions/cos_pi.hpp
==============================================================================
--- trunk/boost/math/special_functions/cos_pi.hpp (original)
+++ trunk/boost/math/special_functions/cos_pi.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -10,7 +10,7 @@
#pragma once
#endif

-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <boost/math/tools/config.hpp>
#include <boost/math/special_functions/trunc.hpp>
#include <boost/math/tools/promotion.hpp>

Modified: trunk/boost/math/special_functions/detail/unchecked_factorial.hpp
==============================================================================
--- trunk/boost/math/special_functions/detail/unchecked_factorial.hpp (original)
+++ trunk/boost/math/special_functions/detail/unchecked_factorial.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -19,7 +19,7 @@
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <boost/math/special_functions/math_fwd.hpp>

namespace boost { namespace math

Modified: trunk/boost/math/special_functions/expm1.hpp
==============================================================================
--- trunk/boost/math/special_functions/expm1.hpp (original)
+++ trunk/boost/math/special_functions/expm1.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -10,7 +10,7 @@
#pragma once
#endif

-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <math.h> // platform's ::expm1
#include <boost/limits.hpp>
#include <boost/math/tools/config.hpp>

Modified: trunk/boost/math/special_functions/factorials.hpp
==============================================================================
--- trunk/boost/math/special_functions/factorials.hpp (original)
+++ trunk/boost/math/special_functions/factorials.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -22,7 +22,7 @@
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>

namespace boost { namespace math
{

Modified: trunk/boost/math/special_functions/fpclassify.hpp
==============================================================================
--- trunk/boost/math/special_functions/fpclassify.hpp (original)
+++ trunk/boost/math/special_functions/fpclassify.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -11,7 +11,7 @@
#endif

#include <math.h>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <boost/limits.hpp>
#include <boost/math/tools/real_cast.hpp>
#include <boost/type_traits/is_floating_point.hpp>

Modified: trunk/boost/math/special_functions/gamma.hpp
==============================================================================
--- trunk/boost/math/special_functions/gamma.hpp (original)
+++ trunk/boost/math/special_functions/gamma.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -45,7 +45,7 @@
#include <boost/mpl/greater.hpp>
#include <boost/mpl/equal_to.hpp>

-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <algorithm>

#ifdef BOOST_MATH_INSTRUMENT

Modified: trunk/boost/math/special_functions/hypot.hpp
==============================================================================
--- trunk/boost/math/special_functions/hypot.hpp (original)
+++ trunk/boost/math/special_functions/hypot.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -14,7 +14,7 @@
#include <boost/math/tools/precision.hpp>
#include <boost/math/policies/error_handling.hpp>
#include <boost/math/special_functions/math_fwd.hpp>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <algorithm> // for swap

#ifdef BOOST_NO_STDC_NAMESPACE

Modified: trunk/boost/math/special_functions/log1p.hpp
==============================================================================
--- trunk/boost/math/special_functions/log1p.hpp (original)
+++ trunk/boost/math/special_functions/log1p.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -10,7 +10,7 @@
#pragma once
#endif

-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <math.h> // platform's ::log1p
#include <boost/limits.hpp>
#include <boost/math/tools/config.hpp>

Modified: trunk/boost/math/special_functions/sin_pi.hpp
==============================================================================
--- trunk/boost/math/special_functions/sin_pi.hpp (original)
+++ trunk/boost/math/special_functions/sin_pi.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -10,7 +10,7 @@
#pragma once
#endif

-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <boost/math/tools/config.hpp>
#include <boost/math/special_functions/trunc.hpp>
#include <boost/math/tools/promotion.hpp>

Modified: trunk/boost/math/special_functions/sinc.hpp
==============================================================================
--- trunk/boost/math/special_functions/sinc.hpp (original)
+++ trunk/boost/math/special_functions/sinc.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -19,7 +19,7 @@
#include <boost/math/tools/precision.hpp>
#include <boost/math/policies/policy.hpp>
#include <boost/math/special_functions/math_fwd.hpp>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <boost/limits.hpp>
#include <string>
#include <stdexcept>

Modified: trunk/boost/math/special_functions/sinhc.hpp
==============================================================================
--- trunk/boost/math/special_functions/sinhc.hpp (original)
+++ trunk/boost/math/special_functions/sinhc.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -18,7 +18,7 @@
#include <boost/math/tools/config.hpp>
#include <boost/math/tools/precision.hpp>
#include <boost/math/special_functions/math_fwd.hpp>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <boost/limits.hpp>
#include <string>
#include <stdexcept>

Modified: trunk/boost/math/tools/config.hpp
==============================================================================
--- trunk/boost/math/tools/config.hpp (original)
+++ trunk/boost/math/tools/config.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -14,7 +14,7 @@
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <algorithm> // for min and max
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <climits>
#if (defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__))
# include <math.h>

Modified: trunk/boost/math/tools/fraction.hpp
==============================================================================
--- trunk/boost/math/tools/fraction.hpp (original)
+++ trunk/boost/math/tools/fraction.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -10,7 +10,7 @@
#pragma once
#endif

-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <boost/cstdint.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/mpl/if.hpp>

Modified: trunk/boost/math/tools/minima.hpp
==============================================================================
--- trunk/boost/math/tools/minima.hpp (original)
+++ trunk/boost/math/tools/minima.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -12,7 +12,7 @@
#endif

#include <utility>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <boost/math/tools/precision.hpp>
#include <boost/math/policies/policy.hpp>
#include <boost/cstdint.hpp>

Modified: trunk/boost/math/tools/roots.hpp
==============================================================================
--- trunk/boost/math/tools/roots.hpp (original)
+++ trunk/boost/math/tools/roots.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -11,7 +11,7 @@
#endif

#include <utility>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <stdexcept>

#include <boost/tr1/tuple.hpp>

Modified: trunk/boost/math/tools/series.hpp
==============================================================================
--- trunk/boost/math/tools/series.hpp (original)
+++ trunk/boost/math/tools/series.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -10,7 +10,7 @@
#pragma once
#endif

-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <boost/cstdint.hpp>
#include <boost/math/tools/config.hpp>

Modified: trunk/boost/math/tools/stats.hpp
==============================================================================
--- trunk/boost/math/tools/stats.hpp (original)
+++ trunk/boost/math/tools/stats.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -10,7 +10,7 @@
#pragma once
#endif

-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
#include <boost/cstdint.hpp>
#include <boost/math/tools/precision.hpp>

Added: trunk/boost/tr1/cmath.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/tr1/cmath.hpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -0,0 +1,267 @@
+// (C) Copyright John Maddock 2008.
+// 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_TR1_CMATH_HPP_INCLUDED
+# define BOOST_TR1_CMATH_HPP_INCLUDED
+# include <boost/tr1/detail/config.hpp>
+
+#ifdef BOOST_HAS_TR1_CMATH
+
+# ifdef BOOST_HAS_INCLUDE_NEXT
+# include_next BOOST_TR1_HEADER(cmath)
+# else
+# include <boost/tr1/detail/config_all.hpp>
+# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(cmath))
+# endif
+
+#else
+
+#include <boost/math/tr1.hpp>
+
+namespace std{ namespace tr1{
+
+using boost::math::tr1::assoc_laguerre;
+using boost::math::tr1::assoc_laguerref;
+using boost::math::tr1::assoc_laguerrel;
+// [5.2.1.2] associated Legendre functions:
+using boost::math::tr1::assoc_legendre;
+using boost::math::tr1::assoc_legendref;
+using boost::math::tr1::assoc_legendrel;
+// [5.2.1.3] beta function:
+using boost::math::tr1::beta;
+using boost::math::tr1::betaf;
+using boost::math::tr1::betal;
+// [5.2.1.4] (complete) elliptic integral of the first kind:
+using boost::math::tr1::comp_ellint_1;
+using boost::math::tr1::comp_ellint_1f;
+using boost::math::tr1::comp_ellint_1l;
+// [5.2.1.5] (complete) elliptic integral of the second kind:
+using boost::math::tr1::comp_ellint_2;
+using boost::math::tr1::comp_ellint_2f;
+using boost::math::tr1::comp_ellint_2l;
+// [5.2.1.6] (complete) elliptic integral of the third kind:
+using boost::math::tr1::comp_ellint_3;
+using boost::math::tr1::comp_ellint_3f;
+using boost::math::tr1::comp_ellint_3l;
+#if 0
+// [5.2.1.7] confluent hypergeometric functions:
+using boost::math::tr1::conf_hyperg;
+using boost::math::tr1::conf_hypergf;
+using boost::math::tr1::conf_hypergl;
+#endif
+// [5.2.1.8] regular modified cylindrical Bessel functions:
+using boost::math::tr1::cyl_bessel_i;
+using boost::math::tr1::cyl_bessel_if;
+using boost::math::tr1::cyl_bessel_il;
+// [5.2.1.9] cylindrical Bessel functions (of the first kind):
+using boost::math::tr1::cyl_bessel_j;
+using boost::math::tr1::cyl_bessel_jf;
+using boost::math::tr1::cyl_bessel_jl;
+// [5.2.1.10] irregular modified cylindrical Bessel functions:
+using boost::math::tr1::cyl_bessel_k;
+using boost::math::tr1::cyl_bessel_kf;
+using boost::math::tr1::cyl_bessel_kl;
+// [5.2.1.11] cylindrical Neumann functions;
+// cylindrical Bessel functions (of the second kind):
+using boost::math::tr1::cyl_neumann;
+using boost::math::tr1::cyl_neumannf;
+using boost::math::tr1::cyl_neumannl;
+// [5.2.1.12] (incomplete) elliptic integral of the first kind:
+using boost::math::tr1::ellint_1;
+using boost::math::tr1::ellint_1f;
+using boost::math::tr1::ellint_1l;
+// [5.2.1.13] (incomplete) elliptic integral of the second kind:
+using boost::math::tr1::ellint_2;
+using boost::math::tr1::ellint_2f;
+using boost::math::tr1::ellint_2l;
+// [5.2.1.14] (incomplete) elliptic integral of the third kind:
+using boost::math::tr1::ellint_3;
+using boost::math::tr1::ellint_3f;
+using boost::math::tr1::ellint_3l;
+// [5.2.1.15] exponential integral:
+using boost::math::tr1::expint;
+using boost::math::tr1::expintf;
+using boost::math::tr1::expintl;
+// [5.2.1.16] Hermite polynomials:
+using boost::math::tr1::hermite;
+using boost::math::tr1::hermitef;
+using boost::math::tr1::hermitel;
+#if 0
+// [5.2.1.17] hypergeometric functions:
+using boost::math::tr1::hyperg;
+using boost::math::tr1::hypergf;
+using boost::math::tr1::hypergl;
+#endif
+// [5.2.1.18] Laguerre polynomials:
+using boost::math::tr1::laguerre;
+using boost::math::tr1::laguerref;
+using boost::math::tr1::laguerrel;
+// [5.2.1.19] Legendre polynomials:
+using boost::math::tr1::legendre;
+using boost::math::tr1::legendref;
+using boost::math::tr1::legendrel;
+// [5.2.1.20] Riemann zeta function:
+using boost::math::tr1::riemann_zeta;
+using boost::math::tr1::riemann_zetaf;
+using boost::math::tr1::riemann_zetal;
+// [5.2.1.21] spherical Bessel functions (of the first kind):
+using boost::math::tr1::sph_bessel;
+using boost::math::tr1::sph_besself;
+using boost::math::tr1::sph_bessell;
+// [5.2.1.22] spherical associated Legendre functions:
+using boost::math::tr1::sph_legendre;
+using boost::math::tr1::sph_legendref;
+using boost::math::tr1::sph_legendrel;
+// [5.2.1.23] spherical Neumann functions;
+// spherical Bessel functions (of the second kind):
+using boost::math::tr1::sph_neumann;
+using boost::math::tr1::sph_neumannf;
+using boost::math::tr1::sph_neumannl;
+
+// types
+using boost::math::tr1::double_t;
+using boost::math::tr1::float_t;
+// functions
+using boost::math::tr1::acosh;
+using boost::math::tr1::acoshf;
+using boost::math::tr1::acoshl;
+using boost::math::tr1::asinh;
+using boost::math::tr1::asinhf;
+using boost::math::tr1::asinhl;
+using boost::math::tr1::atanh;
+using boost::math::tr1::atanhf;
+using boost::math::tr1::atanhl;
+using boost::math::tr1::cbrt;
+using boost::math::tr1::cbrtf;
+using boost::math::tr1::cbrtl;
+using boost::math::tr1::copysign;
+using boost::math::tr1::copysignf;
+using boost::math::tr1::copysignl;
+using boost::math::tr1::erf;
+using boost::math::tr1::erff;
+using boost::math::tr1::erfl;
+using boost::math::tr1::erfc;
+using boost::math::tr1::erfcf;
+using boost::math::tr1::erfcl;
+#if 0
+using boost::math::tr1::exp2;
+using boost::math::tr1::exp2f;
+using boost::math::tr1::exp2l;
+#endif
+using boost::math::tr1::expm1;
+using boost::math::tr1::expm1f;
+using boost::math::tr1::expm1l;
+#if 0
+using boost::math::tr1::fdim;
+using boost::math::tr1::fdimf;
+using boost::math::tr1::fdiml;
+using boost::math::tr1::fma;
+using boost::math::tr1::fmaf;
+using boost::math::tr1::fmal;
+#endif
+using boost::math::tr1::fmax;
+using boost::math::tr1::fmaxf;
+using boost::math::tr1::fmaxl;
+using boost::math::tr1::fmin;
+using boost::math::tr1::fminf;
+using boost::math::tr1::fminl;
+using boost::math::tr1::hypot;
+using boost::math::tr1::hypotf;
+using boost::math::tr1::hypotl;
+#if 0
+using boost::math::tr1::ilogb;
+using boost::math::tr1::ilogbf;
+using boost::math::tr1::ilogbl;
+#endif
+using boost::math::tr1::lgamma;
+using boost::math::tr1::lgammaf;
+using boost::math::tr1::lgammal;
+#if 0
+using boost::math::tr1::llrint;
+using boost::math::tr1::llrintf;
+using boost::math::tr1::llrintl;
+#endif
+using boost::math::tr1::llround;
+using boost::math::tr1::llroundf;
+using boost::math::tr1::llroundl;
+using boost::math::tr1::log1p;
+using boost::math::tr1::log1pf;
+using boost::math::tr1::log1pl;
+#if 0
+using boost::math::tr1::log2;
+using boost::math::tr1::log2f;
+using boost::math::tr1::log2l;
+using boost::math::tr1::logb;
+using boost::math::tr1::logbf;
+using boost::math::tr1::logbl;
+using boost::math::tr1::lrint;
+using boost::math::tr1::lrintf;
+using boost::math::tr1::lrintl;
+#endif
+using boost::math::tr1::lround;
+using boost::math::tr1::lroundf;
+using boost::math::tr1::lroundl;
+#if 0
+using boost::math::tr1::nan;
+using boost::math::tr1::nanf;
+using boost::math::tr1::nanl;
+using boost::math::tr1::nearbyint;
+using boost::math::tr1::nearbyintf;
+using boost::math::tr1::nearbyintl;
+#endif
+using boost::math::tr1::nextafter;
+using boost::math::tr1::nextafterf;
+using boost::math::tr1::nextafterl;
+using boost::math::tr1::nexttoward;
+using boost::math::tr1::nexttowardf;
+using boost::math::tr1::nexttowardl;
+#if 0
+using boost::math::tr1::remainder;
+using boost::math::tr1::remainderf;
+using boost::math::tr1::remainderl;
+using boost::math::tr1::remquo;
+using boost::math::tr1::remquof;
+using boost::math::tr1::remquol;
+using boost::math::tr1::rint;
+using boost::math::tr1::rintf;
+using boost::math::tr1::rintl;
+#endif
+using boost::math::tr1::round;
+using boost::math::tr1::roundf;
+using boost::math::tr1::roundl;
+#if 0
+using boost::math::tr1::scalbln;
+using boost::math::tr1::scalblnf;
+using boost::math::tr1::scalblnl;
+using boost::math::tr1::scalbn;
+using boost::math::tr1::scalbnf;
+using boost::math::tr1::scalbnl;
+#endif
+using boost::math::tr1::tgamma;
+using boost::math::tr1::tgammaf;
+using boost::math::tr1::tgammal;
+using boost::math::tr1::trunc;
+using boost::math::tr1::truncf;
+using boost::math::tr1::truncl;
+// C99 macros defined as C++ templates
+using boost::math::tr1::signbit;
+using boost::math::tr1::fpclassify;
+using boost::math::tr1::isfinite;
+using boost::math::tr1::isinf;
+using boost::math::tr1::isnan;
+using boost::math::tr1::isnormal;
+#if 0
+using boost::math::tr1::isgreater;
+using boost::math::tr1::isgreaterequal;
+using boost::math::tr1::isless;
+using boost::math::tr1::islessequal;
+using boost::math::tr1::islessgreater;
+using boost::math::tr1::isunordered;
+#endif
+} } // namespaces
+
+#endif // BOOST_HAS_TR1_CMATH
+
+#endif // BOOST_TR1_CMATH_HPP_INCLUDED

Added: trunk/boost/tr1/tr1/bcc32/unordere.h
==============================================================================
--- (empty file)
+++ trunk/boost/tr1/tr1/bcc32/unordere.h 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -0,0 +1,15 @@
+// (C) Copyright John Maddock 2008.
+// 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)
+
+//
+// Forwarding header for Borland C++:
+//
+#if !defined(BOOST_TR1_UNORDERED_H_INCLUDED)
+# define BOOST_TR1_UNORDERED_H_INCLUDED
+# include <unordered_set.>
+# include <unordered_map.>
+#endif
+
+

Added: trunk/boost/tr1/tr1/cmath
==============================================================================
--- (empty file)
+++ trunk/boost/tr1/tr1/cmath 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -0,0 +1,41 @@
+// (C) Copyright John Maddock 2008.
+// 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)
+
+
+#if !defined(BOOST_TR1_CMATH_INCLUDED) || defined(BOOST_TR1_NO_RECURSION)
+#ifndef BOOST_TR1_CMATH_INCLUDED
+# define BOOST_TR1_CMATH_INCLUDED
+#endif
+# ifdef BOOST_TR1_NO_CMATH_RECURSION2
+# define BOOST_TR1_NO_CMATH_RECURSION3
+# elif defined(BOOST_TR1_NO_CMATH_RECURSION)
+# define BOOST_TR1_NO_CMATH_RECURSION2
+# elif !defined(BOOST_TR1_NO_RECURSION)
+# define BOOST_TR1_NO_RECURSION
+# define BOOST_TR1_NO_CMATH_RECURSION
+# endif
+# include <boost/tr1/detail/config_all.hpp>
+# ifdef BOOST_HAS_INCLUDE_NEXT
+# include_next <cmath>
+# else
+# include BOOST_TR1_STD_HEADER(cmath)
+# endif
+#ifdef BOOST_TR1_NO_CMATH_RECURSION3
+# undef BOOST_TR1_NO_CMATH_RECURSION3
+#elif defined(BOOST_TR1_NO_CMATH_RECURSION2)
+# undef BOOST_TR1_NO_CMATH_RECURSION2
+#elif defined(BOOST_TR1_NO_CMATH_RECURSION)
+# undef BOOST_TR1_NO_RECURSION
+# undef BOOST_TR1_NO_CMATH_RECURSION
+# endif
+#endif
+
+#if !defined(BOOST_TR1_FULL_CMATH_INCLUDED) && !defined(BOOST_TR1_NO_RECURSION)
+# define BOOST_TR1_FULL_CMATH_INCLUDED
+# define BOOST_TR1_NO_RECURSION
+# include <boost/tr1/cmath.hpp>
+# undef BOOST_TR1_NO_RECURSION
+#endif
+

Added: trunk/boost/tr1/tr1/sun/cmath.SUNWCCh
==============================================================================
--- (empty file)
+++ trunk/boost/tr1/tr1/sun/cmath.SUNWCCh 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -0,0 +1,7 @@
+// (C) Copyright John Maddock 2008.
+// 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 "../cmath"
+
+

Added: trunk/boost/tr1/tr1/sun/unordered_map.SUNWCCh
==============================================================================
--- (empty file)
+++ trunk/boost/tr1/tr1/sun/unordered_map.SUNWCCh 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -0,0 +1,7 @@
+// (C) Copyright John Maddock 2008.
+// 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 "../unordered_map"
+
+

Added: trunk/boost/tr1/tr1/sun/unordered_set.SUNWCCh
==============================================================================
--- (empty file)
+++ trunk/boost/tr1/tr1/sun/unordered_set.SUNWCCh 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -0,0 +1,7 @@
+// (C) Copyright John Maddock 2008.
+// 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 "../unordered_set"
+
+

Modified: trunk/libs/tr1/doc/tr1.qbk
==============================================================================
--- trunk/libs/tr1/doc/tr1.qbk (original)
+++ trunk/libs/tr1/doc/tr1.qbk 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -1464,16 +1464,15 @@

[endsect]

-[endsect]
-
-[section:unsupported TR By Subject: Unsupported Features]
-
[section:special Mathematical Special Functions.]

The TR adds 23 special functions (plus float and long double overloads)
-to header <cmath>. However, at present there is no Boost License
-compatible implementation of these functions, so these are [*unsupported
-by this implementation] unless your standard library supports them itself.
+to header <cmath>.
+
+Refer to the
+[@../../libs/math/doc/sf_and_dist/html/math_toolkit/main_overview/tr1.html Math Library docs]
+for more information.
+

    namespace std {
    namespace tr1 {
@@ -1600,10 +1599,264 @@

[*Standard Conformity:]
-['[*Not Supported.]]
+The following functions are not supported in the Boost version of this component:
+
+ // [5.2.1.7] confluent hypergeometric functions:
+ double conf_hyperg(double a, double c, double x);
+ float conf_hypergf(float a, float c, float x);
+ long double conf_hypergl(long double a, long double c, long double x);
+
+ // [5.2.1.17] hypergeometric functions:
+ double hyperg(double a, double b, double c, double x);
+ float hypergf(float a, float b, float c, float x);
+ long double hypergl(long double a, long double b, long double c, long double x);

[endsect]

+[section:c99_special C99 Mathematical Special Functions.]
+
+The TR adds a number of special functions which were first introduced in the C99 standard
+to header <cmath>.
+
+Refer to the
+[@../../libs/math/doc/sf_and_dist/html/math_toolkit/main_overview/tr1.html Math Library docs]
+for more information.
+
+
+ namespace std {
+ namespace tr1 {
+
+ // types
+ typedef floating-type double_t;
+ typedef floating-type float_t;
+
+ // functions
+ double acosh(double x);
+ float acoshf(float x);
+ long double acoshl(long double x);
+
+ double asinh(double x);
+ float asinhf(float x);
+ long double asinhl(long double x);
+
+ double atanh(double x);
+ float atanhf(float x);
+ long double atanhl(long double x);
+
+ double cbrt(double x);
+ float cbrtf(float x);
+ long double cbrtl(long double x);
+
+ double copysign(double x, double y);
+ float copysignf(float x, float y);
+ long double copysignl(long double x, long double y);
+
+ double erf(double x);
+ float erff(float x);
+ long double erfl(long double x);
+
+ double erfc(double x);
+ float erfcf(float x);
+ long double erfcl(long double x);
+
+ double exp2(double x);
+ float exp2f(float x);
+ long double exp2l(long double x);
+
+ double expm1(double x);
+ float expm1f(float x);
+ long double expm1l(long double x);
+
+ double fdim(double x, double y);
+ float fdimf(float x, float y);
+ long double fdiml(long double x, long double y);
+
+ double fma(double x, double y, double z);
+ float fmaf(float x, float y, float z);
+ long double fmal(long double x, long double y, long double z);
+
+ double fmax(double x, double y);
+ float fmaxf(float x, float y);
+ long double fmaxl(long double x, long double y);
+
+ double fmin(double x, double y);
+ float fminf(float x, float y);
+ long double fminl(long double x, long double y);
+
+ double hypot(double x, double y);
+ float hypotf(float x, float y);
+ long double hypotl(long double x, long double y);
+
+ int ilogb(double x);
+ int ilogbf(float x);
+ int ilogbl(long double x);
+
+ double lgamma(double x);
+ float lgammaf(float x);
+ long double lgammal(long double x);
+
+ long long llrint(double x);
+ long long llrintf(float x);
+ long long llrintl(long double x);
+
+ long long llround(double x);
+ long long llroundf(float x);
+ long long llroundl(long double x);
+
+ double log1p(double x);
+ float log1pf(float x);
+ long double log1pl(long double x);
+
+ double log2(double x);
+ float log2f(float x);
+ long double log2l(long double x);
+
+ double logb(double x);
+ float logbf(float x);
+ long double logbl(long double x);
+
+ long lrint(double x);
+ long lrintf(float x);
+ long lrintl(long double x);
+
+ long lround(double x);
+ long lroundf(float x);
+ long lroundl(long double x);
+
+ double nan(const char *str);
+ float nanf(const char *str);
+ long double nanl(const char *str);
+
+ double nearbyint(double x);
+ float nearbyintf(float x);
+ long double nearbyintl(long double x);
+
+ double nextafter(double x, double y);
+ float nextafterf(float x, float y);
+ long double nextafterl(long double x, long double y);
+
+ double nexttoward(double x, long double y);
+ float nexttowardf(float x, long double y);
+ long double nexttowardl(long double x, long double y);
+
+ double remainder(double x, double y);
+ float remainderf(float x, float y);
+ long double remainderl(long double x, long double y);
+
+ double remquo(double x, double y, int *pquo);
+ float remquof(float x, float y, int *pquo);
+ long double remquol(long double x, long double y, int *pquo);
+
+ double rint(double x);
+ float rintf(float x);
+ long double rintl(long double x);
+
+ double round(double x);
+ float roundf(float x);
+ long double roundl(long double x);
+
+ double scalbln(double x, long ex);
+ float scalblnf(float x, long ex);
+ long double scalblnl(long double x, long ex);
+ double scalbn(double x, int ex);
+ float scalbnf(float x, int ex);
+ long double scalbnl(long double x, int ex);
+
+ double tgamma(double x);
+ float tgammaf(float x);
+ long double tgammal(long double x);
+
+ double trunc(double x);
+ float truncf(float x);
+ long double truncl(long double x);
+
+ // C99 macros defined as C++ templates
+ template<class T> bool signbit(T x);
+ template<class T> int fpclassify(T x);
+ template<class T> bool isfinite(T x);
+ template<class T> bool isinf(T x);
+ template<class T> bool isnan(T x);
+ template<class T> bool isnormal(T x);
+ template<class T> bool isgreater(T x, T y);
+ template<class T> bool isgreaterequal(T x, T y);
+ template<class T> bool isless(T x, T y);
+ template<class T> bool islessequal(T x, T y);
+ template<class T> bool islessgreater(T x, T y);
+ template<class T> bool isunordered(T x, T y);
+
+ }} // namespaces
+
+[*Standard Conformity:]
+The following functions are not supported in the Boost version of this component:
+
+ double exp2(double x);
+ float exp2f(float x);
+ long double exp2l(long double x);
+
+ double fdim(double x, double y);
+ float fdimf(float x, float y);
+ long double fdiml(long double x, long double y);
+
+ double fma(double x, double y, double z);
+ float fmaf(float x, float y, float z);
+ long double fmal(long double x, long double y, long double z);
+
+ int ilogb(double x);
+ int ilogbf(float x);
+ int ilogbl(long double x);
+
+ long long llrint(double x);
+ long long llrintf(float x);
+ long long llrintl(long double x);
+
+ double log2(double x);
+ float log2f(float x);
+ long double log2l(long double x);
+
+ double logb(double x);
+ float logbf(float x);
+ long double logbl(long double x);
+
+ long lrint(double x);
+ long lrintf(float x);
+ long lrintl(long double x);
+
+ double nan(const char *str);
+ float nanf(const char *str);
+ long double nanl(const char *str);
+
+ double nearbyint(double x);
+ float nearbyintf(float x);
+ long double nearbyintl(long double x);
+
+ double remainder(double x, double y);
+ float remainderf(float x, float y);
+ long double remainderl(long double x, long double y);
+
+ double remquo(double x, double y, int *pquo);
+ float remquof(float x, float y, int *pquo);
+ long double remquol(long double x, long double y, int *pquo);
+
+ double rint(double x);
+ float rintf(float x);
+ long double rintl(long double x);
+
+ double scalbln(double x, long ex);
+ float scalblnf(float x, long ex);
+ long double scalblnl(long double x, long ex);
+ double scalbn(double x, int ex);
+ float scalbnf(float x, int ex);
+ long double scalbnl(long double x, int ex);
+
+ // C99 macros defined as C++ templates
+ template<class T> bool isgreater(T x, T y);
+ template<class T> bool isgreaterequal(T x, T y);
+ template<class T> bool isless(T x, T y);
+ template<class T> bool islessequal(T x, T y);
+ template<class T> bool islessgreater(T x, T y);
+ template<class T> bool isunordered(T x, T y);
+
+[endsect]
[endsect]

[section:header_list TR1 By Header]

Added: trunk/libs/tr1/test/std_headers/test_cmath.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/tr1/test/std_headers/test_cmath.cpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -0,0 +1,8 @@
+// (C) Copyright John Maddock 2008.
+// 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 <cmath>
+
+

Added: trunk/libs/tr1/test/test_cmath.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/tr1/test/test_cmath.cpp 2008-08-10 05:12:02 EDT (Sun, 10 Aug 2008)
@@ -0,0 +1,414 @@
+// (C) Copyright John Maddock 2008.
+// 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)
+
+// These are the headers included by the Boost.TR1 implementation,
+// by including these directly we probe for problems with cyclic
+// dependencies when the TR1 headers are in the include search path.
+
+#ifdef TEST_STD_HEADERS
+#include <cmath>
+#else
+#include <boost/tr1/cmath.hpp>
+#endif
+
+#include "verify_return.hpp"
+
+int main(int argc, const char* [])
+{
+ if(argc > 500)
+ {
+ float f = 0;
+ double d = 0;
+ long double ld = 0;
+ unsigned ui = 0;
+ int i = 0;
+ long int li = 0;
+ bool b = false;
+ const char* nan_str = "";
+#ifdef BOOST_HAS_LONG_LONG
+ long long lli = 0;
+#endif
+
+ verify_return_type(std::tr1::acosh(d), d);
+ verify_return_type(std::tr1::acosh(f), f);
+ verify_return_type(std::tr1::acosh(ld), ld);
+ verify_return_type(std::tr1::acoshf(f), f);
+ verify_return_type(std::tr1::acoshl(ld), ld);
+ verify_return_type(std::tr1::asinh(d), d);
+ verify_return_type(std::tr1::asinh(f), f);
+ verify_return_type(std::tr1::asinh(ld), ld);
+ verify_return_type(std::tr1::asinhf(f), f);
+ verify_return_type(std::tr1::asinhl(ld), ld);
+ verify_return_type(std::tr1::atanh(d), d);
+ verify_return_type(std::tr1::atanh(f), f);
+ verify_return_type(std::tr1::atanh(ld), ld);
+ verify_return_type(std::tr1::atanhf(f), f);
+ verify_return_type(std::tr1::atanhl(ld), ld);
+ verify_return_type(std::tr1::cbrt(d), d);
+ verify_return_type(std::tr1::cbrt(f), f);
+ verify_return_type(std::tr1::cbrt(ld), ld);
+ verify_return_type(std::tr1::cbrtf(f), f);
+ verify_return_type(std::tr1::cbrtl(ld), ld);
+ verify_return_type(std::tr1::copysign(d, d), d);
+ verify_return_type(std::tr1::copysign(f, f), f);
+ verify_return_type(std::tr1::copysign(ld, ld), ld);
+ verify_return_type(std::tr1::copysignf(f, f), f);
+ verify_return_type(std::tr1::copysignl(ld, ld), ld);
+ verify_return_type(std::tr1::erf(d), d);
+ verify_return_type(std::tr1::erf(f), f);
+ verify_return_type(std::tr1::erf(ld), ld);
+ verify_return_type(std::tr1::erff(f), f);
+ verify_return_type(std::tr1::erfl(ld), ld);
+ verify_return_type(std::tr1::erfc(d), d);
+ verify_return_type(std::tr1::erfc(f), f);
+ verify_return_type(std::tr1::erfc(ld), ld);
+ verify_return_type(std::tr1::erfcf(f), f);
+ verify_return_type(std::tr1::erfcl(ld), ld);
+#if 0
+ verify_return_type(std::tr1::exp2(d), d);
+ verify_return_type(std::tr1::exp2(f), f);
+ verify_return_type(std::tr1::exp2(ld), ld);
+ verify_return_type(std::tr1::exp2f(f), f);
+ verify_return_type(std::tr1::exp2l(ld), ld);
+#endif
+ verify_return_type(std::tr1::expm1(d), d);
+ verify_return_type(std::tr1::expm1(f), f);
+ verify_return_type(std::tr1::expm1(ld), ld);
+ verify_return_type(std::tr1::expm1f(f), f);
+ verify_return_type(std::tr1::expm1l(ld), ld);
+#if 0
+ verify_return_type(std::tr1::fdim(d, d), d);
+ verify_return_type(std::tr1::fdim(f, f), f);
+ verify_return_type(std::tr1::fdim(ld, ld), ld);
+ verify_return_type(std::tr1::fdimf(f, f), f);
+ verify_return_type(std::tr1::fdiml(ld, ld), ld);
+ verify_return_type(std::tr1::fma(d, d, d), d);
+ verify_return_type(std::tr1::fma(f, f, f), f);
+ verify_return_type(std::tr1::fma(ld, ld, ld), ld);
+ verify_return_type(std::tr1::fmaf(f, f, f), f);
+ verify_return_type(std::tr1::fmal(ld, ld, ld), ld);
+#endif
+ verify_return_type(std::tr1::fmax(d, d), d);
+ verify_return_type(std::tr1::fmax(f, f), f);
+ verify_return_type(std::tr1::fmax(ld, ld), ld);
+ verify_return_type(std::tr1::fmaxf(f, f), f);
+ verify_return_type(std::tr1::fmaxl(ld, ld), ld);
+ verify_return_type(std::tr1::fmin(d, d), d);
+ verify_return_type(std::tr1::fmin(f, f), f);
+ verify_return_type(std::tr1::fmin(ld, ld), ld);
+ verify_return_type(std::tr1::fminf(f, f), f);
+ verify_return_type(std::tr1::fminl(ld, ld), ld);
+ verify_return_type(std::tr1::hypot(d, d), d);
+ verify_return_type(std::tr1::hypot(f, f), f);
+ verify_return_type(std::tr1::hypot(ld, ld), ld);
+ verify_return_type(std::tr1::hypotf(f, f), f);
+ verify_return_type(std::tr1::hypotl(ld, ld), ld);
+#if 0
+ verify_return_type(std::tr1::ilogb(d), d);
+ verify_return_type(std::tr1::ilogb(f), f);
+ verify_return_type(std::tr1::ilogb(ld), ld);
+ verify_return_type(std::tr1::ilogbf(f), f);
+ verify_return_type(std::tr1::ilogbl(ld), ld);
+#endif
+ verify_return_type(std::tr1::lgamma(d), d);
+ verify_return_type(std::tr1::lgamma(f), f);
+ verify_return_type(std::tr1::lgamma(ld), ld);
+ verify_return_type(std::tr1::lgammaf(f), f);
+ verify_return_type(std::tr1::lgammal(ld), ld);
+#if 0
+ verify_return_type(std::tr1::llrint(d), d);
+ verify_return_type(std::tr1::llrint(f), f);
+ verify_return_type(std::tr1::llrint(ld), ld);
+ verify_return_type(std::tr1::llrintf(f), f);
+ verify_return_type(std::tr1::llrintl(ld), ld);
+#endif
+#ifdef BOOST_HAS_LONG_LONG
+ verify_return_type(std::tr1::llround(d), lli);
+ verify_return_type(std::tr1::llround(f), lli);
+ verify_return_type(std::tr1::llround(ld), lli);
+ verify_return_type(std::tr1::llroundf(f), lli);
+ verify_return_type(std::tr1::llroundl(ld), lli);
+#endif
+ verify_return_type(std::tr1::log1p(d), d);
+ verify_return_type(std::tr1::log1p(f), f);
+ verify_return_type(std::tr1::log1p(ld), ld);
+ verify_return_type(std::tr1::log1pf(f), f);
+ verify_return_type(std::tr1::log1pl(ld), ld);
+#if 0
+ verify_return_type(std::tr1::log2(d), d);
+ verify_return_type(std::tr1::log2(f), f);
+ verify_return_type(std::tr1::log2(ld), ld);
+ verify_return_type(std::tr1::log2f(f), f);
+ verify_return_type(std::tr1::log2l(ld), ld);
+ verify_return_type(std::tr1::logb(d), d);
+ verify_return_type(std::tr1::logb(f), f);
+ verify_return_type(std::tr1::logb(ld), ld);
+ verify_return_type(std::tr1::logbf(f), f);
+ verify_return_type(std::tr1::logbl(ld), ld);
+ verify_return_type(std::tr1::lrint(d), d);
+ verify_return_type(std::tr1::lrint(f), f);
+ verify_return_type(std::tr1::lrint(ld), ld);
+ verify_return_type(std::tr1::lrintf(f), f);
+ verify_return_type(std::tr1::lrintl(ld), ld);
+#endif
+ verify_return_type(std::tr1::lround(d), li);
+ verify_return_type(std::tr1::lround(f), li);
+ verify_return_type(std::tr1::lround(ld), li);
+ verify_return_type(std::tr1::lroundf(f), li);
+ verify_return_type(std::tr1::lroundl(ld), li);
+#if 0
+ verify_return_type(std::tr1::nan(nan_str), d);
+ verify_return_type(std::tr1::nanf(nan_str), f);
+ verify_return_type(std::tr1::nanl(nan_str), ld);
+ verify_return_type(std::tr1::nearbyint(d), d);
+ verify_return_type(std::tr1::nearbyint(f), f);
+ verify_return_type(std::tr1::nearbyint(ld), ld);
+ verify_return_type(std::tr1::nearbyintf(f), f);
+ verify_return_type(std::tr1::nearbyintl(ld), ld);
+#endif
+ verify_return_type(std::tr1::nextafter(d, d), d);
+ verify_return_type(std::tr1::nextafter(f, f), f);
+ verify_return_type(std::tr1::nextafter(ld, ld), ld);
+ verify_return_type(std::tr1::nextafterf(f, f), f);
+ verify_return_type(std::tr1::nextafterl(ld, ld), ld);
+ verify_return_type(std::tr1::nexttoward(d, ld), d);
+ verify_return_type(std::tr1::nexttoward(f, ld), f);
+ verify_return_type(std::tr1::nexttoward(ld, ld), ld);
+ verify_return_type(std::tr1::nexttowardf(f, ld), f);
+ verify_return_type(std::tr1::nexttowardl(ld, ld), ld);
+#if 0
+ verify_return_type(std::tr1::remainder(d, d), d);
+ verify_return_type(std::tr1::remainder(f, f), f);
+ verify_return_type(std::tr1::remainder(ld, ld), ld);
+ verify_return_type(std::tr1::remainderf(f, f), f);
+ verify_return_type(std::tr1::remainderl(ld, ld), ld);
+ verify_return_type(std::tr1::remquo(d, d, &i), d);
+ verify_return_type(std::tr1::remquo(f, f, &i), f);
+ verify_return_type(std::tr1::remquo(ld, ld, &i), ld);
+ verify_return_type(std::tr1::remquof(f, f, &i), f);
+ verify_return_type(std::tr1::remquol(ld, ld, &i), ld);
+ verify_return_type(std::tr1::rint(d), d);
+ verify_return_type(std::tr1::rint(f), f);
+ verify_return_type(std::tr1::rint(ld), ld);
+ verify_return_type(std::tr1::rintf(f), f);
+ verify_return_type(std::tr1::rintl(ld), ld);
+#endif
+ verify_return_type(std::tr1::round(d), d);
+ verify_return_type(std::tr1::round(f), f);
+ verify_return_type(std::tr1::round(ld), ld);
+ verify_return_type(std::tr1::roundf(f), f);
+ verify_return_type(std::tr1::roundl(ld), ld);
+#if 0
+ verify_return_type(std::tr1::scalbln(d, li), d);
+ verify_return_type(std::tr1::scalbln(f, li), f);
+ verify_return_type(std::tr1::scalbln(ld, li), ld);
+ verify_return_type(std::tr1::scalblnf(f, li), f);
+ verify_return_type(std::tr1::scalblnl(ld, li), ld);
+ verify_return_type(std::tr1::scalbn(d, i), d);
+ verify_return_type(std::tr1::scalbn(f, i), f);
+ verify_return_type(std::tr1::scalbn(ld, i), ld);
+ verify_return_type(std::tr1::scalbnf(f, i), f);
+ verify_return_type(std::tr1::scalbnl(ld, i), ld);
+#endif
+ verify_return_type(std::tr1::tgamma(d), d);
+ verify_return_type(std::tr1::tgamma(f), f);
+ verify_return_type(std::tr1::tgamma(ld), ld);
+ verify_return_type(std::tr1::tgammaf(f), f);
+ verify_return_type(std::tr1::tgammal(ld), ld);
+ verify_return_type(std::tr1::trunc(d), d);
+ verify_return_type(std::tr1::trunc(f), f);
+ verify_return_type(std::tr1::trunc(ld), ld);
+ verify_return_type(std::tr1::truncf(f), f);
+ verify_return_type(std::tr1::truncl(ld), ld);
+ verify_return_type(std::tr1::signbit(d), b);
+ verify_return_type(std::tr1::signbit(f), b);
+ verify_return_type(std::tr1::signbit(ld), b);
+ verify_return_type(std::tr1::fpclassify(d), i);
+ verify_return_type(std::tr1::fpclassify(f), i);
+ verify_return_type(std::tr1::fpclassify(ld), i);
+ verify_return_type(std::tr1::isfinite(d), b);
+ verify_return_type(std::tr1::isfinite(f), b);
+ verify_return_type(std::tr1::isfinite(ld), b);
+ verify_return_type(std::tr1::isinf(d), b);
+ verify_return_type(std::tr1::isinf(f), b);
+ verify_return_type(std::tr1::isinf(ld), b);
+ verify_return_type(std::tr1::isnan(d), b);
+ verify_return_type(std::tr1::isnan(f), b);
+ verify_return_type(std::tr1::isnan(ld), b);
+ verify_return_type(std::tr1::isnormal(d), b);
+ verify_return_type(std::tr1::isnormal(f), b);
+ verify_return_type(std::tr1::isnormal(ld), b);
+#if 0
+ verify_return_type(std::tr1::isgreater(d, d), b);
+ verify_return_type(std::tr1::isgreater(f, f), b);
+ verify_return_type(std::tr1::isgreater(ld, ld), b);
+ verify_return_type(std::tr1::isgreaterequal(d, d), b);
+ verify_return_type(std::tr1::isgreaterequal(f, f), b);
+ verify_return_type(std::tr1::isgreaterequal(ld, ld), b);
+ verify_return_type(std::tr1::isless(d, d), b);
+ verify_return_type(std::tr1::isless(f, f), b);
+ verify_return_type(std::tr1::isless(ld, ld), b);
+ verify_return_type(std::tr1::islessequal(d, d), b);
+ verify_return_type(std::tr1::islessequal(f, f), b);
+ verify_return_type(std::tr1::islessequal(ld, ld), b);
+ verify_return_type(std::tr1::islessgreater(d, d), b);
+ verify_return_type(std::tr1::islessgreater(f, f), b);
+ verify_return_type(std::tr1::islessgreater(ld, ld), b);
+ verify_return_type(std::tr1::isunordered(d, d), b);
+ verify_return_type(std::tr1::isunordered(f, f), b);
+ verify_return_type(std::tr1::isunordered(ld, ld), b);
+#endif
+
+ // [5.2.1.1] associated Laguerre polynomials:
+ verify_return_type(std::tr1::assoc_laguerre(ui, ui, d), d);
+ verify_return_type(std::tr1::assoc_laguerre(ui, ui, f), f);
+ verify_return_type(std::tr1::assoc_laguerre(ui, ui, ld), ld);
+ verify_return_type(std::tr1::assoc_laguerref(ui, ui, f), f);
+ verify_return_type(std::tr1::assoc_laguerrel(ui, ui, ld), ld);
+ // [5.2.1.2] associated Legendre functions:
+ verify_return_type(std::tr1::assoc_legendre(ui, ui, d), d);
+ verify_return_type(std::tr1::assoc_legendre(ui, ui, f), f);
+ verify_return_type(std::tr1::assoc_legendre(ui, ui, ld), ld);
+ verify_return_type(std::tr1::assoc_legendref(ui, ui, f), f);
+ verify_return_type(std::tr1::assoc_legendrel(ui, ui, ld), ld);
+ // [5.2.1.3] beta function:
+ verify_return_type(std::tr1::beta(d, d), d);
+ verify_return_type(std::tr1::beta(f, f), f);
+ verify_return_type(std::tr1::beta(ld, ld), ld);
+ verify_return_type(std::tr1::betaf(f, f), f);
+ verify_return_type(std::tr1::betal(ld, ld), ld);
+ // [5.2.1.4] (complete) elliptic integral of the first kind:
+ verify_return_type(std::tr1::comp_ellint_1(d), d);
+ verify_return_type(std::tr1::comp_ellint_1(f), f);
+ verify_return_type(std::tr1::comp_ellint_1(ld), ld);
+ verify_return_type(std::tr1::comp_ellint_1f(f), f);
+ verify_return_type(std::tr1::comp_ellint_1l(ld), ld);
+ // [5.2.1.5] (complete) elliptic integral of the second kind:
+ verify_return_type(std::tr1::comp_ellint_2(d), d);
+ verify_return_type(std::tr1::comp_ellint_2(f), f);
+ verify_return_type(std::tr1::comp_ellint_2(ld), ld);
+ verify_return_type(std::tr1::comp_ellint_2f(f), f);
+ verify_return_type(std::tr1::comp_ellint_2l(ld), ld);
+ // [5.2.1.6] (complete) elliptic integral of the third kind:
+ verify_return_type(std::tr1::comp_ellint_3(d, d), d);
+ verify_return_type(std::tr1::comp_ellint_3(f, f), f);
+ verify_return_type(std::tr1::comp_ellint_3(ld, ld), ld);
+ verify_return_type(std::tr1::comp_ellint_3f(f, f), f);
+ verify_return_type(std::tr1::comp_ellint_3l(ld, ld), ld);
+#if 0
+ // [5.2.1.7] confluent hypergeometric functions:
+ verify_return_type(std::tr1::conf_hyperg(d, d, d), d);
+ verify_return_type(std::tr1::conf_hyperg(f, f, f), f);
+ verify_return_type(std::tr1::conf_hyperg(ld, ld, ld), ld);
+ verify_return_type(std::tr1::conf_hypergf(f, f, f), f);
+ verify_return_type(std::tr1::conf_hypergl(ld, ld, ld), ld);
+#endif
+ // [5.2.1.8] regular modified cylindrical Bessel functions:
+ verify_return_type(std::tr1::cyl_bessel_i(d, d), d);
+ verify_return_type(std::tr1::cyl_bessel_i(f, f), f);
+ verify_return_type(std::tr1::cyl_bessel_i(ld, ld), ld);
+ verify_return_type(std::tr1::cyl_bessel_if(f, f), f);
+ verify_return_type(std::tr1::cyl_bessel_il(ld, ld), ld);
+ // [5.2.1.9] cylindrical Bessel functions (of the first kind):
+ verify_return_type(std::tr1::cyl_bessel_j(d, d), d);
+ verify_return_type(std::tr1::cyl_bessel_j(f, f), f);
+ verify_return_type(std::tr1::cyl_bessel_j(ld, ld), ld);
+ verify_return_type(std::tr1::cyl_bessel_jf(f, f), f);
+ verify_return_type(std::tr1::cyl_bessel_jl(ld, ld), ld);
+ // [5.2.1.10] irregular modified cylindrical Bessel functions:
+ verify_return_type(std::tr1::cyl_bessel_k(d, d), d);
+ verify_return_type(std::tr1::cyl_bessel_k(f, f), f);
+ verify_return_type(std::tr1::cyl_bessel_k(ld, ld), ld);
+ verify_return_type(std::tr1::cyl_bessel_kf(f, f), f);
+ verify_return_type(std::tr1::cyl_bessel_kl(ld, ld), ld);
+ // [5.2.1.11] cylindrical Neumann functions;
+ // cylindrical Bessel functions (of the second kind):
+ verify_return_type(std::tr1::cyl_neumann(d, d), d);
+ verify_return_type(std::tr1::cyl_neumann(f, f), f);
+ verify_return_type(std::tr1::cyl_neumann(ld, ld), ld);
+ verify_return_type(std::tr1::cyl_neumannf(f, f), f);
+ verify_return_type(std::tr1::cyl_neumannl(ld, ld), ld);
+ // [5.2.1.12] (incomplete) elliptic integral of the first kind:
+ verify_return_type(std::tr1::ellint_1(d, d), d);
+ verify_return_type(std::tr1::ellint_1(f, f), f);
+ verify_return_type(std::tr1::ellint_1(ld, ld), ld);
+ verify_return_type(std::tr1::ellint_1f(f, f), f);
+ verify_return_type(std::tr1::ellint_1l(ld, ld), ld);
+ // [5.2.1.13] (incomplete) elliptic integral of the second kind:
+ verify_return_type(std::tr1::ellint_2(d, d), d);
+ verify_return_type(std::tr1::ellint_2(f, f), f);
+ verify_return_type(std::tr1::ellint_2(ld, ld), ld);
+ verify_return_type(std::tr1::ellint_2f(f, f), f);
+ verify_return_type(std::tr1::ellint_2l(ld, ld), ld);
+ // [5.2.1.14] (incomplete) elliptic integral of the third kind:
+ verify_return_type(std::tr1::ellint_3(d, d, d), d);
+ verify_return_type(std::tr1::ellint_3(f, f, f), f);
+ verify_return_type(std::tr1::ellint_3(ld, ld, ld), ld);
+ verify_return_type(std::tr1::ellint_3f(f, f, f), f);
+ verify_return_type(std::tr1::ellint_3l(ld, ld, ld), ld);
+ // [5.2.1.15] exponential integral:
+ verify_return_type(std::tr1::expint(d), d);
+ verify_return_type(std::tr1::expint(f), f);
+ verify_return_type(std::tr1::expint(ld), ld);
+ verify_return_type(std::tr1::expintf(f), f);
+ verify_return_type(std::tr1::expintl(ld), ld);
+ // [5.2.1.16] Hermite polynomials:
+ verify_return_type(std::tr1::hermite(ui, d), d);
+ verify_return_type(std::tr1::hermite(ui, f), f);
+ verify_return_type(std::tr1::hermite(ui, ld), ld);
+ verify_return_type(std::tr1::hermitef(ui, f), f);
+ verify_return_type(std::tr1::hermitel(ui, ld), ld);
+ // [5.2.1.17] hypergeometric functions:
+#if 0
+ verify_return_type(std::tr1::hyperg(d, d, d, d), d);
+ verify_return_type(std::tr1::hyperg(f, f, f, f), f);
+ verify_return_type(std::tr1::hyperg(ld, ld, ld, ld), ld);
+ verify_return_type(std::tr1::hypergf(f, f, f, f), f);
+ verify_return_type(std::tr1::hypergl(ld, ld, ld, ld), ld);
+#endif
+ // [5.2.1.18] Laguerre polynomials:
+ verify_return_type(std::tr1::laguerre(ui, d), d);
+ verify_return_type(std::tr1::laguerre(ui, f), f);
+ verify_return_type(std::tr1::laguerre(ui, ld), ld);
+ verify_return_type(std::tr1::laguerref(ui, f), f);
+ verify_return_type(std::tr1::laguerrel(ui, ld), ld);
+ // [5.2.1.19] Legendre polynomials:
+ verify_return_type(std::tr1::legendre(ui, d), d);
+ verify_return_type(std::tr1::legendre(ui, f), f);
+ verify_return_type(std::tr1::legendre(ui, ld), ld);
+ verify_return_type(std::tr1::legendref(ui, f), f);
+ verify_return_type(std::tr1::legendrel(ui, ld), ld);
+ // [5.2.1.20] Riemann zeta function:
+ verify_return_type(std::tr1::riemann_zeta(d), d);
+ verify_return_type(std::tr1::riemann_zeta(f), f);
+ verify_return_type(std::tr1::riemann_zeta(ld), ld);
+ verify_return_type(std::tr1::riemann_zetaf(f), f);
+ verify_return_type(std::tr1::riemann_zetal(ld), ld);
+ // [5.2.1.21] spherical Bessel functions (of the first kind):
+ verify_return_type(std::tr1::sph_bessel(ui, d), d);
+ verify_return_type(std::tr1::sph_bessel(ui, f), f);
+ verify_return_type(std::tr1::sph_bessel(ui, ld), ld);
+ verify_return_type(std::tr1::sph_besself(ui, f), f);
+ verify_return_type(std::tr1::sph_bessell(ui, ld), ld);
+ // [5.2.1.22] spherical associated Legendre functions:
+ verify_return_type(std::tr1::sph_legendre(ui, ui, d), d);
+ verify_return_type(std::tr1::sph_legendre(ui, ui, f), f);
+ verify_return_type(std::tr1::sph_legendre(ui, ui, ld), ld);
+ verify_return_type(std::tr1::sph_legendref(ui, ui, f), f);
+ verify_return_type(std::tr1::sph_legendrel(ui, ui, ld), ld);
+ // [5.2.1.23] spherical Neumann functions;
+ // spherical Bessel functions (of the second kind):
+ verify_return_type(std::tr1::sph_neumann(ui, d), d);
+ verify_return_type(std::tr1::sph_neumann(ui, f), f);
+ verify_return_type(std::tr1::sph_neumann(ui, ld), ld);
+ verify_return_type(std::tr1::sph_neumannf(ui, f), f);
+ verify_return_type(std::tr1::sph_neumannl(ui, ld), ld);
+ }
+ return 0;
+}
+
+
+
+

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk