[Boost-commit] svn:boost r44090 - in sandbox/math_toolkit: boost/math/concepts boost/math/distributions boost/math/policies boost/math/special_functions boost/math/special_functions/detail boost/math/tools libs/math/doc/sf_and_dist libs/math/example libs/math/test libs/math/test/compile_test

From: john_at_[hidden]
Date: 2008-04-07 11:43:16

Author: johnmaddock
Date: 2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
New Revision: 44090
URL: http://svn.boost.org/trac/boost/changeset/44090

Log:
Merged changes from Trunk.
Added:
   sandbox/math_toolkit/libs/math/test/compile_test/compl_abs_incl_test.cpp
      - copied unchanged from r44056, /trunk/libs/math/test/compile_test/compl_abs_incl_test.cpp
   sandbox/math_toolkit/libs/math/test/compile_test/compl_acos_incl_test.cpp
      - copied unchanged from r44056, /trunk/libs/math/test/compile_test/compl_acos_incl_test.cpp
   sandbox/math_toolkit/libs/math/test/compile_test/compl_acosh_incl_test.cpp
      - copied unchanged from r44056, /trunk/libs/math/test/compile_test/compl_acosh_incl_test.cpp
   sandbox/math_toolkit/libs/math/test/compile_test/compl_asin_incl_test.cpp
      - copied unchanged from r44056, /trunk/libs/math/test/compile_test/compl_asin_incl_test.cpp
   sandbox/math_toolkit/libs/math/test/compile_test/compl_asinh_incl_test.cpp
      - copied unchanged from r44056, /trunk/libs/math/test/compile_test/compl_asinh_incl_test.cpp
   sandbox/math_toolkit/libs/math/test/compile_test/compl_atan_incl_test.cpp
      - copied unchanged from r44056, /trunk/libs/math/test/compile_test/compl_atan_incl_test.cpp
   sandbox/math_toolkit/libs/math/test/compile_test/compl_atanh_incl_test.cpp
      - copied unchanged from r44056, /trunk/libs/math/test/compile_test/compl_atanh_incl_test.cpp
   sandbox/math_toolkit/libs/math/test/compile_test/dist_find_location_incl_test.cpp
      - copied unchanged from r44056, /trunk/libs/math/test/compile_test/dist_find_location_incl_test.cpp
   sandbox/math_toolkit/libs/math/test/compile_test/dist_find_scale_incl_test.cpp
      - copied unchanged from r44056, /trunk/libs/math/test/compile_test/dist_find_scale_incl_test.cpp
Text files modified: 
   sandbox/math_toolkit/boost/math/concepts/real_concept.hpp                        |    37 +++                                     
   sandbox/math_toolkit/boost/math/concepts/std_real_concept.hpp                    |    33 +++                                     
   sandbox/math_toolkit/boost/math/distributions/binomial.hpp                       |     2                                         
   sandbox/math_toolkit/boost/math/distributions/find_location.hpp                  |     2                                         
   sandbox/math_toolkit/boost/math/distributions/find_scale.hpp                     |     2                                         
   sandbox/math_toolkit/boost/math/distributions/poisson.hpp                        |    17 -                                       
   sandbox/math_toolkit/boost/math/policies/error_handling.hpp                      |    17 +                                       
   sandbox/math_toolkit/boost/math/special_functions/cos_pi.hpp                     |    18 +                                       
   sandbox/math_toolkit/boost/math/special_functions/detail/gamma_inva.hpp          |    74 ++++++-                                 
   sandbox/math_toolkit/boost/math/special_functions/detail/ibeta_inv_ab.hpp        |   198 +++++++++++++++++-----                  
   sandbox/math_toolkit/boost/math/special_functions/detail/unchecked_factorial.hpp |     2                                         
   sandbox/math_toolkit/boost/math/special_functions/fpclassify.hpp                 |     2                                         
   sandbox/math_toolkit/boost/math/special_functions/math_fwd.hpp                   |    12                                         
   sandbox/math_toolkit/boost/math/special_functions/sin_pi.hpp                     |    16 +                                       
   sandbox/math_toolkit/boost/math/special_functions/sinc.hpp                       |     2                                         
   sandbox/math_toolkit/boost/math/special_functions/sinhc.hpp                      |     2                                         
   sandbox/math_toolkit/boost/math/tools/config.hpp                                 |     9                                         
   sandbox/math_toolkit/boost/math/tools/roots.hpp                                  |     7                                         
   sandbox/math_toolkit/boost/math/tools/test_data.hpp                              |     1                                         
   sandbox/math_toolkit/boost/math/tools/traits.hpp                                 |     4                                         
   sandbox/math_toolkit/libs/math/doc/sf_and_dist/concepts.qbk                      |     2                                         
   sandbox/math_toolkit/libs/math/doc/sf_and_dist/credits.qbk                       |     4                                         
   sandbox/math_toolkit/libs/math/doc/sf_and_dist/ellint_legendre.qbk               |     2                                         
   sandbox/math_toolkit/libs/math/doc/sf_and_dist/math.qbk                          |     6                                         
   sandbox/math_toolkit/libs/math/doc/sf_and_dist/references.qbk                    |     2                                         
   sandbox/math_toolkit/libs/math/doc/sf_and_dist/roadmap.qbk                       |     2                                         
   sandbox/math_toolkit/libs/math/example/find_mean_and_sd_normal.cpp               |     2                                         
   sandbox/math_toolkit/libs/math/example/policy_eg_8.cpp                           |     2                                         
   sandbox/math_toolkit/libs/math/test/Jamfile.v2                                   |    25 +-                                      
   sandbox/math_toolkit/libs/math/test/compile_test/instantiate.hpp                 |   356 ++++++++++++++++++++++++++++++++++++++++
   sandbox/math_toolkit/libs/math/test/compile_test/sf_bessel_incl_test.cpp         |     2                                         
   sandbox/math_toolkit/libs/math/test/compile_test/sf_cos_pi_incl_test.cpp         |     2                                         
   sandbox/math_toolkit/libs/math/test/compile_test/sf_digamma_incl_test.cpp        |     2                                         
   sandbox/math_toolkit/libs/math/test/compile_test/sf_sin_pi_incl_test.cpp         |     2                                         
   sandbox/math_toolkit/libs/math/test/log1p_expm1_test.cpp                         |    12 +                                       
   sandbox/math_toolkit/libs/math/test/test_bernoulli.cpp                           |     6                                         
   sandbox/math_toolkit/libs/math/test/test_bessel_i.cpp                            |     8                                         
   sandbox/math_toolkit/libs/math/test/test_bessel_j.cpp                            |    12 +                                       
   sandbox/math_toolkit/libs/math/test/test_bessel_k.cpp                            |     8                                         
   sandbox/math_toolkit/libs/math/test/test_bessel_y.cpp                            |    12 +                                       
   sandbox/math_toolkit/libs/math/test/test_beta.cpp                                |     4                                         
   sandbox/math_toolkit/libs/math/test/test_beta_dist.cpp                           |     6                                         
   sandbox/math_toolkit/libs/math/test/test_binomial.cpp                            |     6                                         
   sandbox/math_toolkit/libs/math/test/test_binomial_coeff.cpp                      |     4                                         
   sandbox/math_toolkit/libs/math/test/test_carlson.cpp                             |    16 +                                       
   sandbox/math_toolkit/libs/math/test/test_cbrt.cpp                                |     4                                         
   sandbox/math_toolkit/libs/math/test/test_classify.cpp                            |     2                                         
   sandbox/math_toolkit/libs/math/test/test_digamma.cpp                             |     4                                         
   sandbox/math_toolkit/libs/math/test/test_ellint_1.cpp                            |     8                                         
   sandbox/math_toolkit/libs/math/test/test_ellint_2.cpp                            |     8                                         
   sandbox/math_toolkit/libs/math/test/test_ellint_3.cpp                            |     8                                         
   sandbox/math_toolkit/libs/math/test/test_erf.cpp                                 |    23 ++                                      
   sandbox/math_toolkit/libs/math/test/test_error_handling.cpp                      |     2                                         
   sandbox/math_toolkit/libs/math/test/test_find_location.cpp                       |     2                                         
   sandbox/math_toolkit/libs/math/test/test_find_scale.cpp                          |     2                                         
   sandbox/math_toolkit/libs/math/test/test_gamma.cpp                               |    12 +                                       
   sandbox/math_toolkit/libs/math/test/test_hermite.cpp                             |     4                                         
   sandbox/math_toolkit/libs/math/test/test_ibeta.cpp                               |    16 +                                       
   sandbox/math_toolkit/libs/math/test/test_ibeta_inv.cpp                           |     8                                         
   sandbox/math_toolkit/libs/math/test/test_ibeta_inv_ab.cpp                        |    21 ++                                      
   sandbox/math_toolkit/libs/math/test/test_igamma.cpp                              |    16 +                                       
   sandbox/math_toolkit/libs/math/test/test_igamma_inv.cpp                          |     8                                         
   sandbox/math_toolkit/libs/math/test/test_igamma_inva.cpp                         |    12 +                                       
   sandbox/math_toolkit/libs/math/test/test_instantiate1.cpp                        |     1                                         
   sandbox/math_toolkit/libs/math/test/test_instantiate2.cpp                        |     1                                         
   sandbox/math_toolkit/libs/math/test/test_laguerre.cpp                            |    22 ++                                      
   sandbox/math_toolkit/libs/math/test/test_legendre.cpp                            |    16 +                                       
   sandbox/math_toolkit/libs/math/test/test_minima.cpp                              |     8                                         
   sandbox/math_toolkit/libs/math/test/test_negative_binomial.cpp                   |     6                                         
   sandbox/math_toolkit/libs/math/test/test_poisson.cpp                             |     2                                         
   sandbox/math_toolkit/libs/math/test/test_policy_sf.cpp                           |     2                                         
   sandbox/math_toolkit/libs/math/test/test_remez.cpp                               |     8                                         
   sandbox/math_toolkit/libs/math/test/test_spherical_harmonic.cpp                  |     8                                         
   sandbox/math_toolkit/libs/math/test/test_students_t.cpp                          |     2                                         
   sandbox/math_toolkit/libs/math/test/test_tgamma_ratio.cpp                        |     8                                         
   75 files changed, 1044 insertions(+), 162 deletions(-)

Modified: sandbox/math_toolkit/boost/math/concepts/real_concept.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/concepts/real_concept.hpp	(original)
+++ sandbox/math_toolkit/boost/math/concepts/real_concept.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -176,11 +176,18 @@
 #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
 // I've seen std::fmod(long double) crash on some platforms
 // so use fmodl instead:
+#ifdef _WIN32_WCE
+//
+// Ugly workaround for macro fmodl:
+//
+inline long double call_fmodl(long double a, long double b)
+{  return fmodl(a, b); }
 inline real_concept fmod(real_concept a, real_concept b)
-{ return fmodl(a.value(), b.value()); }
+{ return call_fmodl(a.value(), b.value()); }
 #else
 inline real_concept fmod(real_concept a, real_concept b)
-{ return std::fmod(a.value(), b.value()); }
+{ return fmodl(a.value(), b.value()); }
+#endif
 #endif
 inline real_concept cosh(real_concept a)
 { return std::cosh(a.value()); }
@@ -290,7 +297,7 @@
 }
 
 template <>
-inline concepts::real_concept epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(concepts::real_concept))
+inline concepts::real_concept epsilon<concepts::real_concept>(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(concepts::real_concept))
 {
 #ifdef __SUNPRO_CC
    return std::numeric_limits<concepts::real_concept_base_type>::epsilon();
@@ -322,12 +329,20 @@
 {
    return iround(v.value(), pol);
 }
+inline int iround(const concepts::real_concept& v)
+{
+   return iround(v.value(), policies::policy<>());
+}
 
 template <class Policy>
 inline long lround(const concepts::real_concept& v, const Policy& pol)
 {
    return lround(v.value(), pol);
 }
+inline long lround(const concepts::real_concept& v)
+{
+   return lround(v.value(), policies::policy<>());
+}
 
 #ifdef BOOST_HAS_LONG_LONG
 
@@ -336,6 +351,10 @@
 {
    return llround(v.value(), pol);
 }
+inline long long llround(const concepts::real_concept& v)
+{
+   return llround(v.value(), policies::policy<>());
+}
 
 #endif
 
@@ -344,12 +363,20 @@
 {
    return itrunc(v.value(), pol);
 }
+inline int itrunc(const concepts::real_concept& v)
+{
+   return itrunc(v.value(), policies::policy<>());
+}
 
 template <class Policy>
 inline long ltrunc(const concepts::real_concept& v, const Policy& pol)
 {
    return ltrunc(v.value(), pol);
 }
+inline long ltrunc(const concepts::real_concept& v)
+{
+   return ltrunc(v.value(), policies::policy<>());
+}
 
 #ifdef BOOST_HAS_LONG_LONG
 
@@ -358,6 +385,10 @@
 {
    return lltrunc(v.value(), pol);
 }
+inline long long lltrunc(const concepts::real_concept& v)
+{
+   return lltrunc(v.value(), policies::policy<>());
+}
 
 #endif
 

Modified: sandbox/math_toolkit/boost/math/concepts/std_real_concept.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/concepts/std_real_concept.hpp	(original)
+++ sandbox/math_toolkit/boost/math/concepts/std_real_concept.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -20,9 +20,7 @@
 #include <boost/limits.hpp>
 #include <boost/math/tools/precision.hpp>
 #include <boost/math/policies/policy.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/math_fwd.hpp>
 
 #include <ostream>
 #include <istream>
@@ -205,8 +203,13 @@
 { return std::tan(a.value()); }
 inline boost::math::concepts::std_real_concept pow(boost::math::concepts::std_real_concept a, boost::math::concepts::std_real_concept b)
 { return std::pow(a.value(), b.value()); }
+#if !defined(__SUNPRO_CC)
 inline boost::math::concepts::std_real_concept pow(boost::math::concepts::std_real_concept a, int b)
 { return std::pow(a.value(), b); }
+#else
+inline boost::math::concepts::std_real_concept pow(boost::math::concepts::std_real_concept a, int b)
+{ return std::pow(a.value(), static_cast<long double>(b)); }
+#endif
 inline boost::math::concepts::std_real_concept sin(boost::math::concepts::std_real_concept a)
 { return std::sin(a.value()); }
 inline boost::math::concepts::std_real_concept sinh(boost::math::concepts::std_real_concept a)
@@ -287,12 +290,20 @@
 {
    return iround(v.value(), pol);
 }
+inline int iround(const concepts::std_real_concept& v)
+{
+   return iround(v.value(), policies::policy<>());
+}
 
 template <class Policy>
 inline long lround(const concepts::std_real_concept& v, const Policy& pol)
 {
    return lround(v.value(), pol);
 }
+inline long lround(const concepts::std_real_concept& v)
+{
+   return lround(v.value(), policies::policy<>());
+}
 
 #ifdef BOOST_HAS_LONG_LONG
 
@@ -301,6 +312,10 @@
 {
    return llround(v.value(), pol);
 }
+inline long long llround(const concepts::std_real_concept& v)
+{
+   return llround(v.value(), policies::policy<>());
+}
 
 #endif
 
@@ -309,12 +324,20 @@
 {
    return itrunc(v.value(), pol);
 }
+inline int itrunc(const concepts::std_real_concept& v)
+{
+   return itrunc(v.value(), policies::policy<>());
+}
 
 template <class Policy>
 inline long ltrunc(const concepts::std_real_concept& v, const Policy& pol)
 {
    return ltrunc(v.value(), pol);
 }
+inline long ltrunc(const concepts::std_real_concept& v)
+{
+   return ltrunc(v.value(), policies::policy<>());
+}
 
 #ifdef BOOST_HAS_LONG_LONG
 
@@ -323,6 +346,10 @@
 {
    return lltrunc(v.value(), pol);
 }
+inline long long lltrunc(const concepts::std_real_concept& v)
+{
+   return lltrunc(v.value(), policies::policy<>());
+}
 
 #endif
 

Modified: sandbox/math_toolkit/boost/math/distributions/binomial.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/binomial.hpp	(original)
+++ sandbox/math_toolkit/boost/math/distributions/binomial.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -25,7 +25,7 @@
 // The number of light bulbs that burn out in a certain amount of time.
 // The number of roadkill found per unit length of road
 
-// http:/en.wikipedia.org/wiki/binomial_distribution
+// http://en.wikipedia.org/wiki/binomial_distribution
 
 // Given a sample of N measured values k[i],
 // we wish to estimate the value of the parameter x (mean)

Modified: sandbox/math_toolkit/boost/math/distributions/find_location.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/find_location.hpp	(original)
+++ sandbox/math_toolkit/boost/math/distributions/find_location.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -13,6 +13,8 @@
 #include <boost/math/policies/policy.hpp>
 #include <boost/math/tools/traits.hpp>
 #include <boost/static_assert.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/math/policies/error_handling.hpp>
 // using boost::math::policies::policy;
 // using boost::math::complement; // will be needed by users who want complement,
 // but NOT placed here to avoid putting it in global scope.

Modified: sandbox/math_toolkit/boost/math/distributions/find_scale.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/find_scale.hpp	(original)
+++ sandbox/math_toolkit/boost/math/distributions/find_scale.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -14,6 +14,8 @@
 // using boost::math::policies::policy;
 #include <boost/math/tools/traits.hpp>
 #include <boost/static_assert.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/math/policies/error_handling.hpp>
 // using boost::math::complement; // will be needed by users who want complement,
 // but NOT placed here to avoid putting it in global scope.
 

Modified: sandbox/math_toolkit/boost/math/distributions/poisson.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/poisson.hpp	(original)
+++ sandbox/math_toolkit/boost/math/distributions/poisson.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -335,22 +335,7 @@
       { // mean ^ k = 1, and k! = 1, so can simplify.
         return exp(-mean);
       }
-      using boost::math::unchecked_factorial;
-      RealType floork = floor(k);
-      if ((floork == k) // integral
-        && k < max_factorial<RealType>::value)
-      { // k is small enough (for float 34, double 170 ...) to use factorial(k).
-        return exp(-mean) * pow(mean, k) /
-          unchecked_factorial<RealType>(itrunc(floork, Policy()));
-      }
-      else
-      { // Need to use log(factorial(k)) = lgamma(k+1)
-        // (e ^ -mean * mean ^ k) / k!
-        // == exp(log(e ^ -mean) + log (mean ^ k) - lgamma(k+1))
-        // exp( -mean + log(mean) * k - lgamma(k+1))
-        return exp(-mean + log(mean) * k - boost::math::lgamma(k+1, Policy()));
-        // return gamma_p_derivative(k+1, mean); // equivalent & also passes tests.
-      }
+      return boost::math::gamma_p_derivative(k+1, mean, Policy());
     } // pdf
 
     template <class RealType, class Policy>

Modified: sandbox/math_toolkit/boost/math/policies/error_handling.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/policies/error_handling.hpp	(original)
+++ sandbox/math_toolkit/boost/math/policies/error_handling.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -65,12 +65,21 @@
 
 namespace detail
 {
+//
+// Helper function to avoid binding rvalue to non-const-reference,
+// in other words a warning suppression mechansim:
+//
+template <class Formatter, class Group>
+inline std::string do_format(Formatter f, const Group& g)
+{
+   return (f % g).str();
+}
 
 template <class E, class T>
 void raise_error(const char* function, const char* message)
 {
   if(function == 0)
-       function = "Unknown function";
+       function = "Unknown function operating on type %1%";
   if(message == 0)
        message = "Cause unknown";
 
@@ -87,9 +96,9 @@
 void raise_error(const char* function, const char* message, const T& val)
 {
   if(function == 0)
-       function = "Unknown function";
+     function = "Unknown function operating on type %1%";
   if(message == 0)
-       message = "Cause unknown";
+     message = "Cause unknown: error caused by bad argument with value %1%";
 
   std::string msg("Error in function ");
   msg += (boost::format(function) % typeid(T).name()).str();
@@ -97,7 +106,7 @@
   msg += message;
 
   int prec = 2 + (boost::math::policies::digits<T, boost::math::policies::policy<> >() * 30103UL) / 100000UL;
-  msg = (boost::format(msg) % boost::io::group(std::setprecision(prec), val)).str();
+  msg = do_format(boost::format(msg), boost::io::group(std::setprecision(prec), val));
 
   E e(msg);
   boost::throw_exception(e);

Modified: sandbox/math_toolkit/boost/math/special_functions/cos_pi.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/cos_pi.hpp	(original)
+++ sandbox/math_toolkit/boost/math/special_functions/cos_pi.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -13,12 +13,13 @@
 #include <cmath>
 #include <boost/math/tools/config.hpp>
 #include <boost/math/special_functions/trunc.hpp>
+#include <boost/math/tools/promotion.hpp>
 #include <boost/math/constants/constants.hpp>
 
-namespace boost{ namespace math{
+namespace boost{ namespace math{ namespace detail{
 
 template <class T, class Policy>
-T cos_pi(T x, const Policy& pol)
+T cos_pi_imp(T x, const Policy& pol)
 {
    BOOST_MATH_STD_USING // ADL of std names
    // cos of pi*x:
@@ -46,10 +47,19 @@
    return invert ? -rem : rem;
 }
 
+} // namespace detail
+
+template <class T, class Policy>
+inline typename tools::promote_args<T>::type cos_pi(T x, const Policy& pol)
+{
+   typedef typename tools::promote_args<T>::type result_type;
+   return boost::math::detail::cos_pi_imp<result_type>(x, pol);
+}
+
 template <class T>
-inline T cos_pi(T x)
+inline typename tools::promote_args<T>::type cos_pi(T x)
 {
-   return cos_pi(x, policies::policy<>());
+   return boost::math::cos_pi(x, policies::policy<>());
 }
 
 } // namespace math

Modified: sandbox/math_toolkit/boost/math/special_functions/detail/gamma_inva.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/detail/gamma_inva.hpp	(original)
+++ sandbox/math_toolkit/boost/math/special_functions/detail/gamma_inva.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -150,28 +150,78 @@
 
 } // namespace detail
 
-template <class T, class Policy>
-inline T gamma_p_inva(T x, T p, const Policy& pol)
+template <class T1, class T2, class Policy>
+inline typename tools::promote_args<T1, T2>::type 
+   gamma_p_inva(T1 x, T2 p, const Policy& pol)
 {
-   return detail::gamma_inva_imp(x, p, 1 - p, pol);
+   typedef typename tools::promote_args<T1, T2>::type result_type;
+   typedef typename policies::evaluation<result_type, Policy>::type value_type;
+   typedef typename policies::normalise<
+      Policy, 
+      policies::promote_float<false>, 
+      policies::promote_double<false>, 
+      policies::discrete_quantile<>,
+      policies::assert_undefined<> >::type forwarding_policy;
+
+   if(p == 0)
+   {
+      return tools::max_value<result_type>();
+   }
+   if(p == 1)
+   {
+      return tools::min_value<result_type>();
+   }
+
+   return policies::checked_narrowing_cast<result_type, forwarding_policy>(
+      detail::gamma_inva_imp(
+         static_cast<value_type>(x), 
+         static_cast<value_type>(p), 
+         1 - static_cast<value_type>(p), 
+         pol), "boost::math::gamma_p_inva<%1%>(%1%, %1%)");
 }
 
-template <class T, class Policy>
-inline T gamma_q_inva(T x, T q, const Policy& pol)
+template <class T1, class T2, class Policy>
+inline typename tools::promote_args<T1, T2>::type 
+   gamma_q_inva(T1 x, T2 q, const Policy& pol)
 {
-   return detail::gamma_inva_imp(x, 1 - q, q, pol);
+   typedef typename tools::promote_args<T1, T2>::type result_type;
+   typedef typename policies::evaluation<result_type, Policy>::type value_type;
+   typedef typename policies::normalise<
+      Policy, 
+      policies::promote_float<false>, 
+      policies::promote_double<false>, 
+      policies::discrete_quantile<>,
+      policies::assert_undefined<> >::type forwarding_policy;
+
+   if(q == 1)
+   {
+      return tools::max_value<result_type>();
+   }
+   if(q == 0)
+   {
+      return tools::min_value<result_type>();
+   }
+
+   return policies::checked_narrowing_cast<result_type, forwarding_policy>(
+      detail::gamma_inva_imp(
+         static_cast<value_type>(x), 
+         1 - static_cast<value_type>(q), 
+         static_cast<value_type>(q), 
+         pol), "boost::math::gamma_q_inva<%1%>(%1%, %1%)");
 }
 
-template <class T>
-inline T gamma_p_inva(T x, T p)
+template <class T1, class T2>
+inline typename tools::promote_args<T1, T2>::type 
+   gamma_p_inva(T1 x, T2 p)
 {
-   return detail::gamma_inva_imp(x, p, 1 - p, policies::policy<>());
+   return boost::math::gamma_p_inva(x, p, policies::policy<>());
 }
 
-template <class T>
-inline T gamma_q_inva(T x, T q)
+template <class T1, class T2>
+inline typename tools::promote_args<T1, T2>::type
+   gamma_q_inva(T1 x, T2 q)
 {
-   return detail::gamma_inva_imp(x, 1 - q, q, policies::policy<>());
+   return boost::math::gamma_q_inva(x, q, policies::policy<>());
 }
 
 } // namespace math

Modified: sandbox/math_toolkit/boost/math/special_functions/detail/ibeta_inv_ab.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/detail/ibeta_inv_ab.hpp	(original)
+++ sandbox/math_toolkit/boost/math/special_functions/detail/ibeta_inv_ab.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -159,52 +159,160 @@
 
 } // namespace detail
 
-template <class T, class Policy>
-inline T ibeta_inva(T b, T x, T p, const Policy& pol)
+template <class RT1, class RT2, class RT3, class Policy>
+typename tools::promote_args<RT1, RT2, RT3>::type 
+      ibeta_inva(RT1 b, RT2 x, RT3 p, const Policy& pol)
+{
+   typedef typename tools::promote_args<RT1, RT2, RT3>::type result_type;
+   typedef typename policies::evaluation<result_type, Policy>::type value_type;
+   typedef typename policies::normalise<
+      Policy, 
+      policies::promote_float<false>, 
+      policies::promote_double<false>, 
+      policies::discrete_quantile<>,
+      policies::assert_undefined<> >::type forwarding_policy;
+
+   if(p == 0)
+   {
+      return tools::max_value<result_type>();
+   }
+   if(p == 1)
+   {
+      return tools::min_value<result_type>();
+   }
+
+   return policies::checked_narrowing_cast<result_type, forwarding_policy>(
+      detail::ibeta_inv_ab_imp(
+         static_cast<value_type>(b), 
+         static_cast<value_type>(x), 
+         static_cast<value_type>(p), 
+         1 - static_cast<value_type>(p), 
+         false, pol), 
+      "boost::math::ibeta_inva<%1%>(%1%,%1%,%1%)");
+}
+
+template <class RT1, class RT2, class RT3, class Policy>
+typename tools::promote_args<RT1, RT2, RT3>::type 
+      ibetac_inva(RT1 b, RT2 x, RT3 q, const Policy& pol)
+{
+   typedef typename tools::promote_args<RT1, RT2, RT3>::type result_type;
+   typedef typename policies::evaluation<result_type, Policy>::type value_type;
+   typedef typename policies::normalise<
+      Policy, 
+      policies::promote_float<false>, 
+      policies::promote_double<false>, 
+      policies::discrete_quantile<>,
+      policies::assert_undefined<> >::type forwarding_policy;
+
+   if(q == 1)
+   {
+      return tools::max_value<result_type>();
+   }
+   if(q == 0)
+   {
+      return tools::min_value<result_type>();
+   }
+
+   return policies::checked_narrowing_cast<result_type, forwarding_policy>(
+      detail::ibeta_inv_ab_imp(
+         static_cast<value_type>(b), 
+         static_cast<value_type>(x), 
+         1 - static_cast<value_type>(q), 
+         static_cast<value_type>(q), 
+         false, pol),
+      "boost::math::ibetac_inva<%1%>(%1%,%1%,%1%)");
+}
+
+template <class RT1, class RT2, class RT3, class Policy>
+typename tools::promote_args<RT1, RT2, RT3>::type 
+      ibeta_invb(RT1 a, RT2 x, RT3 p, const Policy& pol)
+{
+   typedef typename tools::promote_args<RT1, RT2, RT3>::type result_type;
+   typedef typename policies::evaluation<result_type, Policy>::type value_type;
+   typedef typename policies::normalise<
+      Policy, 
+      policies::promote_float<false>, 
+      policies::promote_double<false>, 
+      policies::discrete_quantile<>,
+      policies::assert_undefined<> >::type forwarding_policy;
+
+   if(p == 0)
+   {
+      return tools::min_value<result_type>();
+   }
+   if(p == 1)
+   {
+      return tools::max_value<result_type>();
+   }
+
+   return policies::checked_narrowing_cast<result_type, forwarding_policy>(
+      detail::ibeta_inv_ab_imp(
+         static_cast<value_type>(a), 
+         static_cast<value_type>(x), 
+         static_cast<value_type>(p), 
+         1 - static_cast<value_type>(p), 
+         true, pol),
+      "boost::math::ibeta_invb<%1%>(%1%,%1%,%1%)");
+}
+
+template <class RT1, class RT2, class RT3, class Policy>
+typename tools::promote_args<RT1, RT2, RT3>::type 
+      ibetac_invb(RT1 a, RT2 x, RT3 q, const Policy& pol)
+{
+   typedef typename tools::promote_args<RT1, RT2, RT3>::type result_type;
+   typedef typename policies::evaluation<result_type, Policy>::type value_type;
+   typedef typename policies::normalise<
+      Policy, 
+      policies::promote_float<false>, 
+      policies::promote_double<false>, 
+      policies::discrete_quantile<>,
+      policies::assert_undefined<> >::type forwarding_policy;
+
+   if(q == 1)
+   {
+      return tools::min_value<result_type>();
+   }
+   if(q == 0)
+   {
+      return tools::max_value<result_type>();
+   }
+
+   return policies::checked_narrowing_cast<result_type, forwarding_policy>(
+      detail::ibeta_inv_ab_imp(
+         static_cast<value_type>(a), 
+         static_cast<value_type>(x), 
+         1 - static_cast<value_type>(q), 
+         static_cast<value_type>(q), 
+         true, pol),
+         "boost::math::ibetac_invb<%1%>(%1%,%1%,%1%)");
+}
+
+template <class RT1, class RT2, class RT3>
+inline typename tools::promote_args<RT1, RT2, RT3>::type 
+         ibeta_inva(RT1 b, RT2 x, RT3 p)
+{
+   return boost::math::ibeta_inva(b, x, p, policies::policy<>());
+}
+
+template <class RT1, class RT2, class RT3>
+inline typename tools::promote_args<RT1, RT2, RT3>::type 
+         ibetac_inva(RT1 b, RT2 x, RT3 q)
+{
+   return boost::math::ibetac_inva(b, x, q, policies::policy<>());
+}
+
+template <class RT1, class RT2, class RT3>
+inline typename tools::promote_args<RT1, RT2, RT3>::type 
+         ibeta_invb(RT1 a, RT2 x, RT3 p)
+{
+   return boost::math::ibeta_invb(a, x, p, policies::policy<>());
+}
+
+template <class RT1, class RT2, class RT3>
+inline typename tools::promote_args<RT1, RT2, RT3>::type 
+         ibetac_invb(RT1 a, RT2 x, RT3 q)
 {
-   return detail::ibeta_inv_ab_imp(b, x, p, 1 - p, false, pol);
-}
-
-template <class T, class Policy>
-inline T ibetac_inva(T b, T x, T q, const Policy& pol)
-{
-   return detail::ibeta_inv_ab_imp(b, x, 1 - q, q, false, pol);
-}
-
-template <class T, class Policy>
-inline T ibeta_invb(T b, T x, T p, const Policy& pol)
-{
-   return detail::ibeta_inv_ab_imp(b, x, p, 1 - p, true, pol);
-}
-
-template <class T, class Policy>
-inline T ibetac_invb(T b, T x, T q, const Policy& pol)
-{
-   return detail::ibeta_inv_ab_imp(b, x, 1 - q, q, true, pol);
-}
-
-template <class T>
-inline T ibeta_inva(T b, T x, T p)
-{
-   return detail::ibeta_inv_ab_imp(b, x, p, 1 - p, false, policies::policy<>());
-}
-
-template <class T>
-inline T ibetac_inva(T b, T x, T q)
-{
-   return detail::ibeta_inv_ab_imp(b, x, 1 - q, q, false, policies::policy<>());
-}
-
-template <class T>
-inline T ibeta_invb(T b, T x, T p)
-{
-   return detail::ibeta_inv_ab_imp(b, x, p, 1 - p, true, policies::policy<>());
-}
-
-template <class T>
-inline T ibetac_invb(T b, T x, T q)
-{
-   return detail::ibeta_inv_ab_imp(b, x, 1 - q, q, true, policies::policy<>());
+   return boost::math::ibetac_invb(a, x, q, policies::policy<>());
 }
 
 } // namespace math

Modified: sandbox/math_toolkit/boost/math/special_functions/detail/unchecked_factorial.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/detail/unchecked_factorial.hpp	(original)
+++ sandbox/math_toolkit/boost/math/special_functions/detail/unchecked_factorial.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -267,7 +267,7 @@
 };
 
 template <>
-inline double unchecked_factorial(unsigned i BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(double))
+inline double unchecked_factorial<double>(unsigned i BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(double))
 {
    return static_cast<double>(boost::math::unchecked_factorial<long double>(i));
 }

Modified: sandbox/math_toolkit/boost/math/special_functions/fpclassify.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/fpclassify.hpp	(original)
+++ sandbox/math_toolkit/boost/math/special_functions/fpclassify.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -38,7 +38,7 @@
 #define BOOST_HAS_FPCLASSIFY
 
 #ifndef fpclassify
-#  if (defined(__GLIBCPP__) || defined(__GLIBCXX__)) && defined(_GLIBCXX_USE_C99_MATH) && (!_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
+#  if (defined(__GLIBCPP__) || defined(__GLIBCXX__)) && defined(_GLIBCXX_USE_C99_MATH) && !(defined(_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC) && (_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC != 0))
 #     define BOOST_FPCLASSIFY_PREFIX ::std::
 #  else
 #     undef BOOST_HAS_FPCLASSIFY

Modified: sandbox/math_toolkit/boost/math/special_functions/math_fwd.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/math_fwd.hpp	(original)
+++ sandbox/math_toolkit/boost/math/special_functions/math_fwd.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -599,16 +599,16 @@
    typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_neumann(unsigned v, T x);
 
    template <class T, class Policy>
-   T sin_pi(T x, const Policy&);
+   typename tools::promote_args<T>::type sin_pi(T x, const Policy&);
 
    template <class T>
-   T sin_pi(T x);
+   typename tools::promote_args<T>::type sin_pi(T x);
 
    template <class T, class Policy>
-   T cos_pi(T x, const Policy&);
+   typename tools::promote_args<T>::type cos_pi(T x, const Policy&);
 
    template <class T>
-   T cos_pi(T x);
+   typename tools::promote_args<T>::type cos_pi(T x);
 
    template <class T>
    int fpclassify BOOST_NO_MACRO_EXPAND(T t);
@@ -952,10 +952,10 @@
    sph_neumann(unsigned v, T x){ return boost::math::sph_neumann(v, x, Policy()); }\
 \
    template <class T>\
-   inline T sin_pi(T x){ return boost::math::sin_pi(x); }\
+   inline typename boost::math::tools::promote_args<T>::type sin_pi(T x){ return boost::math::sin_pi(x); }\
 \
    template <class T>\
-   inline T cos_pi(T x){ return boost::math::cos_pi(x); }\
+   inline typename boost::math::tools::promote_args<T>::type cos_pi(T x){ return boost::math::cos_pi(x); }\
 \
    using boost::math::fpclassify;\
    using boost::math::isfinite;\

Modified: sandbox/math_toolkit/boost/math/special_functions/sin_pi.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/sin_pi.hpp	(original)
+++ sandbox/math_toolkit/boost/math/special_functions/sin_pi.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -13,12 +13,13 @@
 #include <cmath>
 #include <boost/math/tools/config.hpp>
 #include <boost/math/special_functions/trunc.hpp>
+#include <boost/math/tools/promotion.hpp>
 #include <boost/math/constants/constants.hpp>
 
-namespace boost{ namespace math{
+namespace boost{ namespace math{ namespace detail{
 
 template <class T, class Policy>
-T sin_pi(T x, const Policy& pol)
+T sin_pi_imp(T x, const Policy& pol)
 {
    BOOST_MATH_STD_USING // ADL of std names
    if(x < 0)
@@ -48,8 +49,17 @@
    return invert ? -rem : rem;
 }
 
+} // namespace detail
+
+template <class T, class Policy>
+inline typename tools::promote_args<T>::type sin_pi(T x, const Policy& pol)
+{
+   typedef typename tools::promote_args<T>::type result_type;
+   return boost::math::detail::sin_pi_imp<result_type>(x, pol);
+}
+
 template <class T>
-inline T sin_pi(T x)
+inline typename tools::promote_args<T>::type sin_pi(T x)
 {
    return boost::math::sin_pi(x, policies::policy<>());
 }

Modified: sandbox/math_toolkit/boost/math/special_functions/sinc.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/sinc.hpp	(original)
+++ sandbox/math_toolkit/boost/math/special_functions/sinc.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -52,7 +52,7 @@
         template<typename T>
         inline T    sinc_pi_imp(const T x)
         {
-#ifdef    BOOST_NO_STDC_NAMESPACE
+#if defined(BOOST_NO_STDC_NAMESPACE) && !defined(__SUNPRO_CC)
             using    ::abs;
             using    ::sin;
             using    ::sqrt;

Modified: sandbox/math_toolkit/boost/math/special_functions/sinhc.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/sinhc.hpp	(original)
+++ sandbox/math_toolkit/boost/math/special_functions/sinhc.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -51,7 +51,7 @@
         template<typename T>
         inline T    sinhc_pi_imp(const T x)
         {
-#ifdef    BOOST_NO_STDC_NAMESPACE
+#if defined(BOOST_NO_STDC_NAMESPACE) && !defined(__SUNPRO_CC)
             using    ::abs;
             using    ::sinh;
             using    ::sqrt;

Modified: sandbox/math_toolkit/boost/math/tools/config.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/tools/config.hpp	(original)
+++ sandbox/math_toolkit/boost/math/tools/config.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -64,6 +64,10 @@
 #  define BOOST_MATH_CONTROL_FP _control87(MCW_EM,MCW_EM)
 #endif
 
+#ifdef __IBMCPP__
+#  define BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS
+#endif
+
 #if defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590)
 
 #  include "boost/type.hpp"
@@ -100,8 +104,9 @@
 
 #endif // defined BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
 
-#if BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590)
-// Sun's compiler emits a hard error if a constant underflows:
+#if BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) || defined(__hppa)
+// Sun's compiler emits a hard error if a constant underflows,
+// as does aCC on PA-RISC:
 #  define BOOST_MATH_SMALL_CONSTANT(x) 0
 #else
 #  define BOOST_MATH_SMALL_CONSTANT(x) x

Modified: sandbox/math_toolkit/boost/math/tools/roots.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/tools/roots.hpp	(original)
+++ sandbox/math_toolkit/boost/math/tools/roots.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -37,6 +37,10 @@
 
 namespace detail{
 
+template <class Tuple, class T>
+inline void unpack_0(const Tuple& t, T& val)
+{ val = std::tr1::get<0>(t); }
+
 template <class F, class T>
 void handle_zero_derivative(F f,
                             T& last_f0,
@@ -59,7 +63,8 @@
       {
          guess = min;
       }
-      last_f0 = std::tr1::get<0>(f(guess));
+      unpack_0(f(guess), last_f0);
+      //last_f0 = std::tr1::get<0>(f(guess));
       delta = guess - result;
    }
    if(sign(last_f0) * sign(f0) < 0)

Modified: sandbox/math_toolkit/boost/math/tools/test_data.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/tools/test_data.hpp	(original)
+++ sandbox/math_toolkit/boost/math/tools/test_data.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -31,6 +31,7 @@
 
 #include <set>
 #include <vector>
+#include <iostream>
 
 #ifdef BOOST_MSVC
 #  pragma warning(push)

Modified: sandbox/math_toolkit/boost/math/tools/traits.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/tools/traits.hpp	(original)
+++ sandbox/math_toolkit/boost/math/tools/traits.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -33,8 +33,8 @@
 
 namespace detail{
 
-BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_value_type, value_type, true);
-BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_policy_type, policy_type, true);
+BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_value_type, value_type, true)
+BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_policy_type, policy_type, true)
 
 template<class D>
 char cdf(const D& ...);

Modified: sandbox/math_toolkit/libs/math/doc/sf_and_dist/concepts.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/sf_and_dist/concepts.qbk	(original)
+++ sandbox/math_toolkit/libs/math/doc/sf_and_dist/concepts.qbk	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -124,7 +124,7 @@
 when code tries to use these functions, /unless/ you explicitly specialise them.
 For example if the precision of RealType varies at runtime, then
 `numeric_limits` support may not be appropriate, see 
-[@../../../../../boost/math/tools/ntl.hpp boost/math/tools/ntl.hpp] for examples.
+[@../../../../../boost/math/bindings/rr.hpp boost/math/bindings/rr.hpp] for examples.
 
 [warning
 If `std::numeric_limits<>` is *not specialized*

Modified: sandbox/math_toolkit/libs/math/doc/sf_and_dist/credits.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/sf_and_dist/credits.qbk	(original)
+++ sandbox/math_toolkit/libs/math/doc/sf_and_dist/credits.qbk	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -22,14 +22,14 @@
 
 Professor Nico Temme for advice on the inverse incomplete beta function.
 
-[@http:www.shoup.net Victor Shoup for NTL], 
+[@http://www.shoup.net Victor Shoup for NTL], 
 without which it would have much difficult to 
 produce high accuracy constants, and especially
 the tables of accurate values for testing.
 
 We are grateful to Joel Guzman for helping us stress-test
 his 
-[@http:www.boost.org/tools/quickbook/index.htm Boost.Quickbook] 
+[@http://www.boost.org/tools/quickbook/index.htm Boost.Quickbook] 
 program used to generate the html and pdf versions
 of this document, adding several new features en route.
 

Modified: sandbox/math_toolkit/libs/math/doc/sf_and_dist/ellint_legendre.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/sf_and_dist/ellint_legendre.qbk	(original)
+++ sandbox/math_toolkit/libs/math/doc/sf_and_dist/ellint_legendre.qbk	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -188,7 +188,7 @@
 [heading Testing]
 
 The tests use a mixture of spot test values calculated using the online
-calculator at [http://@functions.wolfram.com
+calculator at [@http://functions.wolfram.com
 functions.wolfram.com], and random test data generated using
 NTL::RR at 1000-bit precision and this implementation.
 

Modified: sandbox/math_toolkit/libs/math/doc/sf_and_dist/math.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/sf_and_dist/math.qbk	(original)
+++ sandbox/math_toolkit/libs/math/doc/sf_and_dist/math.qbk	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -34,7 +34,7 @@
 [include html4_symbols.qbk] [/ just for testing]
 [/include latin1_symbols.qbk] [/ just for testing]
 [include common_overviews.qbk] [/ overviews that appear in more than one place!]
-[include roadmap.qbk]
+[include roadmap.qbk] [/ for history]
 
 [def __effects [*Effects: ]]
 [def __formula [*Formula: ]]
@@ -295,6 +295,10 @@
 ] [/ caution]
 ] [/ template discrete_quantile_warning]
 
+This manual is also available in 
+[@http:svn.boost.org/svn/boost/sandbox/pdf/math/release/math.pdf 
+printer friendly PDF format].
+
 [section:main_overview Overview]
 
 [include overview.qbk]

Modified: sandbox/math_toolkit/libs/math/doc/sf_and_dist/references.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/sf_and_dist/references.qbk	(original)
+++ sandbox/math_toolkit/libs/math/doc/sf_and_dist/references.qbk	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -54,7 +54,7 @@
 
 [@http://www.csit.fsu.edu/~burkardt/cpp_src/dcdflib/dcdflib.html C++ version].
 
-[@lib.stat.cmu.edu/general/cdflib  CDFLIB Library of Fortran Routines for Cumulative Distribution functions.]
+[@http://lib.stat.cmu.edu/general/cdflib  CDFLIB Library of Fortran Routines for Cumulative Distribution functions.]
 
 [@http://www.csit.fsu.edu/~burkardt/f_src/dcdflib/dcdflib.html DCDFLIB C++ version]
 DCDFLIB is a library of C++ routines, using double precision arithmetic, for evaluating cumulative probability density functions.

Modified: sandbox/math_toolkit/libs/math/doc/sf_and_dist/roadmap.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/sf_and_dist/roadmap.qbk	(original)
+++ sandbox/math_toolkit/libs/math/doc/sf_and_dist/roadmap.qbk	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -59,7 +59,7 @@
 
 SVN Revisions:
 
-Sandbox and trunk last synchonised at revision: 40161.
+Sandbox and trunk last synchonised at revision: 41065.
 
 ]
 [/ 

Modified: sandbox/math_toolkit/libs/math/example/find_mean_and_sd_normal.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/example/find_mean_and_sd_normal.cpp	(original)
+++ sandbox/math_toolkit/libs/math/example/find_mean_and_sd_normal.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -205,7 +205,7 @@
 
 See [link math_toolkit.dist.stat_tut.weg.cs_eg.chi_sq_intervals Confidence Intervals on the standard deviation]
 for a worked example
-[@../../example/chi_square_std_dev_test.cpp chi_square_std_dev_test.cpp]
+[@../../../example/chi_square_std_dev_test.cpp chi_square_std_dev_test.cpp]
 of estimating these intervals.
 
 

Modified: sandbox/math_toolkit/libs/math/example/policy_eg_8.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/example/policy_eg_8.cpp	(original)
+++ sandbox/math_toolkit/libs/math/example/policy_eg_8.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -25,7 +25,7 @@
 These are forward declared, but not defined in
 boost/math/policies/error_handling.hpp like this:
 
-   namespace boost{ namespace math{ namespace policy{
+   namespace boost{ namespace math{ namespace policies{
 
    template <class T>
    T user_domain_error(const char* function, const char* message, const T& val);

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	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -387,6 +387,13 @@
 run test_policy_2.cpp ;
 run test_policy_sf.cpp ;
 
+compile  compile_test/compl_abs_incl_test.cpp ;
+compile  compile_test/compl_acos_incl_test.cpp ;
+compile  compile_test/compl_acosh_incl_test.cpp ;
+compile  compile_test/compl_asin_incl_test.cpp ;
+compile  compile_test/compl_asinh_incl_test.cpp ;
+compile  compile_test/compl_atan_incl_test.cpp ;
+compile  compile_test/compl_atanh_incl_test.cpp ;
 compile  compile_test/dist_bernoulli_incl_test.cpp ;
 compile  compile_test/dist_beta_incl_test.cpp ;
 compile  compile_test/dist_binomial_incl_test.cpp ;
@@ -395,6 +402,8 @@
 compile  compile_test/dist_complement_incl_test.cpp ;
 compile  compile_test/dist_exponential_incl_test.cpp ;
 compile  compile_test/dist_extreme_val_incl_test.cpp ;
+compile  compile_test/dist_find_location_incl_test.cpp ;
+compile  compile_test/dist_find_scale_incl_test.cpp ;
 compile  compile_test/dist_fisher_f_incl_test.cpp ;
 compile  compile_test/dist_gamma_incl_test.cpp ;
 compile  compile_test/dist_lognormal_incl_test.cpp ;
@@ -465,19 +474,3 @@
 compile  compile_test/tools_test_inc_test.cpp ;
 compile  compile_test/tools_toms748_inc_test.cpp ;
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

Modified: sandbox/math_toolkit/libs/math/test/compile_test/instantiate.hpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/compile_test/instantiate.hpp	(original)
+++ sandbox/math_toolkit/libs/math/test/compile_test/instantiate.hpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -479,5 +479,361 @@
    test::pow<2>(v1);
 }
 
+template <class RealType>
+void instantiate_mixed(RealType)
+{
+   using namespace boost;
+   using namespace boost::math;
+
+   int i = 1;
+   long l = 1;
+   short s = 1;
+   float fr = 0.5F;
+   double dr = 0.5;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   long double lr = 0.5L;
+#else
+   double lr = 0.5L;
+#endif
+
+   boost::math::tgamma(i);
+   boost::math::tgamma1pm1(i);
+   boost::math::lgamma(i);
+   boost::math::lgamma(i, &i);
+   boost::math::digamma(i);
+   boost::math::tgamma_ratio(i, l);
+   boost::math::tgamma_ratio(fr, lr);
+   boost::math::tgamma_delta_ratio(i, s);
+   boost::math::tgamma_delta_ratio(fr, lr);
+   boost::math::rising_factorial(s, i);
+   boost::math::falling_factorial(s, i);
+   boost::math::tgamma(i, l);
+   boost::math::tgamma(fr, lr);
+   boost::math::tgamma_lower(i, s);
+   boost::math::tgamma_lower(fr, lr);
+   boost::math::gamma_p(i, s);
+   boost::math::gamma_p(fr, lr);
+   boost::math::gamma_q(i, s);
+   boost::math::gamma_q(fr, lr);
+   boost::math::gamma_p_inv(i, fr);
+   boost::math::gamma_q_inv(s, fr);
+   boost::math::gamma_p_inva(i, lr);
+   boost::math::gamma_q_inva(i, lr);
+   boost::math::erf(i);
+   boost::math::erfc(i);
+   boost::math::erf_inv(i);
+   boost::math::erfc_inv(i);
+   boost::math::beta(i, s);
+   boost::math::beta(fr, lr);
+   boost::math::beta(i, s, l);
+   boost::math::beta(fr, dr, lr);
+   boost::math::betac(l, i, s);
+   boost::math::betac(fr, dr, lr);
+   boost::math::ibeta(l, i, s);
+   boost::math::ibeta(fr, dr, lr);
+   boost::math::ibetac(l, i, s);
+   boost::math::ibetac(fr, dr, lr);
+   boost::math::ibeta_inv(l, s, i);
+   boost::math::ibeta_inv(fr, dr, lr);
+   boost::math::ibetac_inv(l, i, s);
+   boost::math::ibetac_inv(fr, dr, lr);
+   boost::math::ibeta_inva(l, i, s);
+   boost::math::ibeta_inva(fr, dr, lr);
+   boost::math::ibetac_inva(l, i, s);
+   boost::math::ibetac_inva(fr, dr, lr);
+   boost::math::ibeta_invb(l, i, s);
+   boost::math::ibeta_invb(fr, dr, lr);
+   boost::math::ibetac_invb(l, i, s);
+   boost::math::ibetac_invb(fr, dr, lr);
+   boost::math::gamma_p_derivative(i, l);
+   boost::math::gamma_p_derivative(fr, lr);
+   boost::math::ibeta_derivative(l, i, s);
+   boost::math::ibeta_derivative(fr, dr, lr);
+   (boost::math::fpclassify)(i);
+   (boost::math::isfinite)(s);
+   (boost::math::isnormal)(l);
+   (boost::math::isnan)(i);
+   (boost::math::isinf)(l);
+   boost::math::log1p(i);
+   boost::math::expm1(s);
+   boost::math::cbrt(l);
+   boost::math::sqrt1pm1(s);
+   boost::math::powm1(i, s);
+   boost::math::powm1(fr, lr);
+   //boost::math::legendre_p(1, i);
+   boost::math::legendre_p(1, 0, s);
+   boost::math::legendre_q(1, i);
+   boost::math::laguerre(1, i);
+   boost::math::laguerre(2, 1, i);
+   boost::math::laguerre(2u, 1u, s);
+   boost::math::hermite(1, s);
+   boost::math::spherical_harmonic_r(2, 1, s, i);
+   boost::math::spherical_harmonic_i(2, 1, fr, lr);
+   boost::math::ellint_1(i);
+   boost::math::ellint_1(i, s);
+   boost::math::ellint_1(fr, lr);
+   boost::math::ellint_2(i);
+   boost::math::ellint_2(i, l);
+   boost::math::ellint_2(fr, lr);
+   boost::math::ellint_3(i, l);
+   boost::math::ellint_3(fr, lr);
+   boost::math::ellint_3(s, l, i);
+   boost::math::ellint_3(fr, dr, lr);
+   boost::math::ellint_rc(i, s);
+   boost::math::ellint_rc(fr, lr);
+   boost::math::ellint_rd(s, i, l);
+   boost::math::ellint_rd(fr, lr, dr);
+   boost::math::ellint_rf(s, l, i);
+   boost::math::ellint_rf(fr, dr, lr);
+   boost::math::ellint_rj(i, i, s, l);
+   boost::math::ellint_rj(i, fr, dr, lr);
+   boost::math::hypot(i, s);
+   boost::math::hypot(fr, lr);
+   boost::math::sinc_pi(i);
+   boost::math::sinhc_pi(i);
+   boost::math::asinh(s);
+   boost::math::acosh(l);
+   boost::math::atanh(l);
+   boost::math::sin_pi(s);
+   boost::math::cos_pi(s);
+   boost::math::cyl_neumann(fr, dr);
+   boost::math::cyl_neumann(i, s);
+   boost::math::cyl_bessel_j(fr, lr);
+   boost::math::cyl_bessel_j(i, s);
+   boost::math::cyl_bessel_i(fr, lr);
+   boost::math::cyl_bessel_i(i, s);
+   boost::math::cyl_bessel_k(fr, lr);
+   boost::math::cyl_bessel_k(i, s);
+   boost::math::sph_bessel(i, fr);
+   boost::math::sph_bessel(i, 1);
+   boost::math::sph_neumann(i, lr);
+   boost::math::sph_neumann(i, i);
+
+   boost::math::policies::policy<> pol;
+
+
+   boost::math::tgamma(i, pol);
+   boost::math::tgamma1pm1(i, pol);
+   boost::math::lgamma(i, pol);
+   boost::math::lgamma(i, &i, pol);
+   boost::math::digamma(i, pol);
+   boost::math::tgamma_ratio(i, l, pol);
+   boost::math::tgamma_ratio(fr, lr, pol);
+   boost::math::tgamma_delta_ratio(i, s, pol);
+   boost::math::tgamma_delta_ratio(fr, lr, pol);
+   boost::math::rising_factorial(s, i, pol);
+   boost::math::falling_factorial(s, i, pol);
+   boost::math::tgamma(i, l, pol);
+   boost::math::tgamma(fr, lr, pol);
+   boost::math::tgamma_lower(i, s, pol);
+   boost::math::tgamma_lower(fr, lr, pol);
+   boost::math::gamma_p(i, s, pol);
+   boost::math::gamma_p(fr, lr, pol);
+   boost::math::gamma_q(i, s, pol);
+   boost::math::gamma_q(fr, lr, pol);
+   boost::math::gamma_p_inv(i, fr, pol);
+   boost::math::gamma_q_inv(s, fr, pol);
+   boost::math::gamma_p_inva(i, lr, pol);
+   boost::math::gamma_q_inva(i, lr, pol);
+   boost::math::erf(i, pol);
+   boost::math::erfc(i, pol);
+   boost::math::erf_inv(i, pol);
+   boost::math::erfc_inv(i, pol);
+   boost::math::beta(i, s, pol);
+   boost::math::beta(fr, lr, pol);
+   boost::math::beta(i, s, l, pol);
+   boost::math::beta(fr, dr, lr, pol);
+   boost::math::betac(l, i, s, pol);
+   boost::math::betac(fr, dr, lr, pol);
+   boost::math::ibeta(l, i, s, pol);
+   boost::math::ibeta(fr, dr, lr, pol);
+   boost::math::ibetac(l, i, s, pol);
+   boost::math::ibetac(fr, dr, lr, pol);
+   boost::math::ibeta_inv(l, s, i, pol);
+   boost::math::ibeta_inv(fr, dr, lr, pol);
+   boost::math::ibetac_inv(l, i, s, pol);
+   boost::math::ibetac_inv(fr, dr, lr, pol);
+   boost::math::ibeta_inva(l, i, s, pol);
+   boost::math::ibeta_inva(fr, dr, lr, pol);
+   boost::math::ibetac_inva(l, i, s, pol);
+   boost::math::ibetac_inva(fr, dr, lr, pol);
+   boost::math::ibeta_invb(l, i, s, pol);
+   boost::math::ibeta_invb(fr, dr, lr, pol);
+   boost::math::ibetac_invb(l, i, s, pol);
+   boost::math::ibetac_invb(fr, dr, lr, pol);
+   boost::math::gamma_p_derivative(i, l, pol);
+   boost::math::gamma_p_derivative(fr, lr, pol);
+   boost::math::ibeta_derivative(l, i, s, pol);
+   boost::math::ibeta_derivative(fr, dr, lr, pol);
+   boost::math::log1p(i, pol);
+   boost::math::expm1(s, pol);
+   boost::math::cbrt(l, pol);
+   boost::math::sqrt1pm1(s, pol);
+   boost::math::powm1(i, s, pol);
+   boost::math::powm1(fr, lr, pol);
+   //boost::math::legendre_p(1, i, pol);
+   boost::math::legendre_p(1, 0, s, pol);
+   boost::math::legendre_q(1, i, pol);
+   boost::math::laguerre(1, i, pol);
+   boost::math::laguerre(2, 1, i, pol);
+   boost::math::laguerre(2u, 1u, s, pol);
+   boost::math::hermite(1, s, pol);
+   boost::math::spherical_harmonic_r(2, 1, s, i, pol);
+   boost::math::spherical_harmonic_i(2, 1, fr, lr, pol);
+   boost::math::ellint_1(i, pol);
+   boost::math::ellint_1(i, s, pol);
+   boost::math::ellint_1(fr, lr, pol);
+   boost::math::ellint_2(i, pol);
+   boost::math::ellint_2(i, l, pol);
+   boost::math::ellint_2(fr, lr, pol);
+   boost::math::ellint_3(i, l, pol);
+   boost::math::ellint_3(fr, lr, pol);
+   boost::math::ellint_3(s, l, i, pol);
+   boost::math::ellint_3(fr, dr, lr, pol);
+   boost::math::ellint_rc(i, s, pol);
+   boost::math::ellint_rc(fr, lr, pol);
+   boost::math::ellint_rd(s, i, l, pol);
+   boost::math::ellint_rd(fr, lr, dr, pol);
+   boost::math::ellint_rf(s, l, i, pol);
+   boost::math::ellint_rf(fr, dr, lr, pol);
+   boost::math::ellint_rj(i, i, s, l, pol);
+   boost::math::ellint_rj(i, fr, dr, lr, pol);
+   boost::math::hypot(i, s, pol);
+   boost::math::hypot(fr, lr, pol);
+   boost::math::sinc_pi(i, pol);
+   boost::math::sinhc_pi(i, pol);
+   boost::math::asinh(s, pol);
+   boost::math::acosh(l, pol);
+   boost::math::atanh(l, pol);
+   boost::math::sin_pi(s, pol);
+   boost::math::cos_pi(s, pol);
+   boost::math::cyl_neumann(fr, dr, pol);
+   boost::math::cyl_neumann(i, s, pol);
+   boost::math::cyl_bessel_j(fr, lr, pol);
+   boost::math::cyl_bessel_j(i, s, pol);
+   boost::math::cyl_bessel_i(fr, lr, pol);
+   boost::math::cyl_bessel_i(i, s, pol);
+   boost::math::cyl_bessel_k(fr, lr, pol);
+   boost::math::cyl_bessel_k(i, s, pol);
+   boost::math::sph_bessel(i, fr, pol);
+   boost::math::sph_bessel(i, 1, pol);
+   boost::math::sph_neumann(i, lr, pol);
+   boost::math::sph_neumann(i, i, pol);
+
+
+   test::tgamma(i);
+   test::tgamma1pm1(i);
+   test::lgamma(i);
+   test::lgamma(i, &i);
+   test::digamma(i);
+   test::tgamma_ratio(i, l);
+   test::tgamma_ratio(fr, lr);
+   test::tgamma_delta_ratio(i, s);
+   test::tgamma_delta_ratio(fr, lr);
+   test::rising_factorial(s, i);
+   test::falling_factorial(s, i);
+   test::tgamma(i, l);
+   test::tgamma(fr, lr);
+   test::tgamma_lower(i, s);
+   test::tgamma_lower(fr, lr);
+   test::gamma_p(i, s);
+   test::gamma_p(fr, lr);
+   test::gamma_q(i, s);
+   test::gamma_q(fr, lr);
+   test::gamma_p_inv(i, fr);
+   test::gamma_q_inv(s, fr);
+   test::gamma_p_inva(i, lr);
+   test::gamma_q_inva(i, lr);
+   test::erf(i);
+   test::erfc(i);
+   test::erf_inv(i);
+   test::erfc_inv(i);
+   test::beta(i, s);
+   test::beta(fr, lr);
+   test::beta(i, s, l);
+   test::beta(fr, dr, lr);
+   test::betac(l, i, s);
+   test::betac(fr, dr, lr);
+   test::ibeta(l, i, s);
+   test::ibeta(fr, dr, lr);
+   test::ibetac(l, i, s);
+   test::ibetac(fr, dr, lr);
+   test::ibeta_inv(l, s, i);
+   test::ibeta_inv(fr, dr, lr);
+   test::ibetac_inv(l, i, s);
+   test::ibetac_inv(fr, dr, lr);
+   test::ibeta_inva(l, i, s);
+   test::ibeta_inva(fr, dr, lr);
+   test::ibetac_inva(l, i, s);
+   test::ibetac_inva(fr, dr, lr);
+   test::ibeta_invb(l, i, s);
+   test::ibeta_invb(fr, dr, lr);
+   test::ibetac_invb(l, i, s);
+   test::ibetac_invb(fr, dr, lr);
+   test::gamma_p_derivative(i, l);
+   test::gamma_p_derivative(fr, lr);
+   test::ibeta_derivative(l, i, s);
+   test::ibeta_derivative(fr, dr, lr);
+   (test::fpclassify)(i);
+   (test::isfinite)(s);
+   (test::isnormal)(l);
+   (test::isnan)(i);
+   (test::isinf)(l);
+   test::log1p(i);
+   test::expm1(s);
+   test::cbrt(l);
+   test::sqrt1pm1(s);
+   test::powm1(i, s);
+   test::powm1(fr, lr);
+   //test::legendre_p(1, i);
+   test::legendre_p(1, 0, s);
+   test::legendre_q(1, i);
+   test::laguerre(1, i);
+   test::laguerre(2, 1, i);
+   test::laguerre(2u, 1u, s);
+   test::hermite(1, s);
+   test::spherical_harmonic_r(2, 1, s, i);
+   test::spherical_harmonic_i(2, 1, fr, lr);
+   test::ellint_1(i);
+   test::ellint_1(i, s);
+   test::ellint_1(fr, lr);
+   test::ellint_2(i);
+   test::ellint_2(i, l);
+   test::ellint_2(fr, lr);
+   test::ellint_3(i, l);
+   test::ellint_3(fr, lr);
+   test::ellint_3(s, l, i);
+   test::ellint_3(fr, dr, lr);
+   test::ellint_rc(i, s);
+   test::ellint_rc(fr, lr);
+   test::ellint_rd(s, i, l);
+   test::ellint_rd(fr, lr, dr);
+   test::ellint_rf(s, l, i);
+   test::ellint_rf(fr, dr, lr);
+   test::ellint_rj(i, i, s, l);
+   test::ellint_rj(i, fr, dr, lr);
+   test::hypot(i, s);
+   test::hypot(fr, lr);
+   test::sinc_pi(i);
+   test::sinhc_pi(i);
+   test::asinh(s);
+   test::acosh(l);
+   test::atanh(l);
+   test::sin_pi(s);
+   test::cos_pi(s);
+   test::cyl_neumann(fr, dr);
+   test::cyl_neumann(i, s);
+   test::cyl_bessel_j(fr, lr);
+   test::cyl_bessel_j(i, s);
+   test::cyl_bessel_i(fr, lr);
+   test::cyl_bessel_i(i, s);
+   test::cyl_bessel_k(fr, lr);
+   test::cyl_bessel_k(i, s);
+   test::sph_bessel(i, fr);
+   test::sph_bessel(i, 1);
+   test::sph_neumann(i, lr);
+   test::sph_neumann(i, i);
+}
+
 
 #endif // BOOST_LIBS_MATH_TEST_INSTANTIATE_HPP

Modified: sandbox/math_toolkit/libs/math/test/compile_test/sf_bessel_incl_test.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/compile_test/sf_bessel_incl_test.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/compile_test/sf_bessel_incl_test.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
-// Basic sanity check that header <boost/math/special_functions/erf.hpp>
+// Basic sanity check that header <boost/math/special_functions/bessel.hpp>
 // #includes all the files that it needs to.
 //
 #include <boost/math/special_functions/bessel.hpp>

Modified: sandbox/math_toolkit/libs/math/test/compile_test/sf_cos_pi_incl_test.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/compile_test/sf_cos_pi_incl_test.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/compile_test/sf_cos_pi_incl_test.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
-// Basic sanity check that header <boost/math/special_functions/erf.hpp>
+// Basic sanity check that header <boost/math/special_functions/cos_pi.hpp>
 // #includes all the files that it needs to.
 //
 #include <boost/math/special_functions/cos_pi.hpp>

Modified: sandbox/math_toolkit/libs/math/test/compile_test/sf_digamma_incl_test.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/compile_test/sf_digamma_incl_test.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/compile_test/sf_digamma_incl_test.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -20,4 +20,4 @@
 #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
    check_result<long double>(boost::math::digamma<long double>(l));
 #endif
-}
\ No newline at end of file
+}

Modified: sandbox/math_toolkit/libs/math/test/compile_test/sf_sin_pi_incl_test.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/compile_test/sf_sin_pi_incl_test.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/compile_test/sf_sin_pi_incl_test.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
-// Basic sanity check that header <boost/math/special_functions/erf.hpp>
+// Basic sanity check that header <boost/math/special_functions/sin_pi.hpp>
 // #includes all the files that it needs to.
 //
 #include <boost/math/special_functions/sin_pi.hpp>

Modified: sandbox/math_toolkit/libs/math/test/log1p_expm1_test.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/log1p_expm1_test.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/log1p_expm1_test.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -70,7 +70,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = &boost::math::log1p<value_type>;
+#else
    pg funcp = &boost::math::log1p;
+#endif
 
    boost::math::tools::test_result<value_type> result;
    std::cout << "Testing " << test_name << " with type " << type_name
@@ -78,7 +82,11 @@
    //
    // test log1p against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::log1p<value_type>;
+#else
    funcp = &boost::math::log1p;
+#endif
    result = boost::math::tools::test(
       data, 
          bind_func(funcp, 0), 
@@ -88,7 +96,11 @@
    //
    // test expm1 against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::expm1<value_type>;
+#else
    funcp = boost::math::expm1;
+#endif
    result = boost::math::tools::test(
       data, 
       bind_func(funcp, 0), 

Modified: sandbox/math_toolkit/libs/math/test/test_bernoulli.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_bernoulli.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_bernoulli.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -13,12 +13,12 @@
 // Default domain error policy is
 // #define BOOST_MATH_DOMAIN_ERROR_POLICY throw_on_error
 
-#include <boost/math/distributions/bernoulli.hpp> // for bernoulli_distribution
-using boost::math::bernoulli_distribution;
-
 #include <boost/math/concepts/real_concept.hpp> // for real_concept
 using ::boost::math::concepts::real_concept;
 
+#include <boost/math/distributions/bernoulli.hpp> // for bernoulli_distribution
+using boost::math::bernoulli_distribution;
+
 #include <boost/test/included/test_exec_monitor.hpp> // for test_main
 #include <boost/test/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE_FRACTION, BOOST_CHECK_EQUAL...
 

Modified: sandbox/math_toolkit/libs/math/test/test_bessel_i.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_bessel_i.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_bessel_i.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -114,7 +114,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::cyl_bessel_i<value_type, value_type>;
+#else
    pg funcp = boost::math::cyl_bessel_i;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -158,7 +162,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = cyl_bessel_i_int_wrapper<value_type>;
+#else
    pg funcp = cyl_bessel_i_int_wrapper;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 

Modified: sandbox/math_toolkit/libs/math/test/test_bessel_j.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_bessel_j.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_bessel_j.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -292,7 +292,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::cyl_bessel_j<value_type, value_type>;
+#else
    pg funcp = boost::math::cyl_bessel_j;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -341,7 +345,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = cyl_bessel_j_int_wrapper<value_type>;
+#else
    pg funcp = cyl_bessel_j_int_wrapper;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -366,7 +374,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(unsigned, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::sph_bessel<value_type>;
+#else
    pg funcp = boost::math::sph_bessel;
+#endif
 
    typedef int (*cast_t)(value_type);
 

Modified: sandbox/math_toolkit/libs/math/test/test_bessel_k.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_bessel_k.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_bessel_k.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -110,7 +110,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::cyl_bessel_k<value_type, value_type>;
+#else
    pg funcp = boost::math::cyl_bessel_k;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -152,7 +156,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = cyl_bessel_k_int_wrapper<value_type>;
+#else
    pg funcp = cyl_bessel_k_int_wrapper;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 

Modified: sandbox/math_toolkit/libs/math/test/test_bessel_y.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_bessel_y.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_bessel_y.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -251,7 +251,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::cyl_neumann<value_type, value_type>;
+#else
    pg funcp = boost::math::cyl_neumann;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -299,7 +303,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = cyl_neumann_int_wrapper<value_type>;
+#else
    pg funcp = cyl_neumann_int_wrapper;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -324,7 +332,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(unsigned, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::sph_neumann<value_type>;
+#else
    pg funcp = boost::math::sph_neumann;
+#endif
 
    typedef int (*cast_t)(value_type);
 

Modified: sandbox/math_toolkit/libs/math/test/test_beta.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_beta.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_beta.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -117,7 +117,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::beta<value_type, value_type>;
+#else
    pg funcp = boost::math::beta;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 

Modified: sandbox/math_toolkit/libs/math/test/test_beta_dist.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_beta_dist.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_beta_dist.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -30,13 +30,13 @@
 #  pragma warning(disable: 4127) // conditional expression is constant.
 #endif
 
+#include <boost/math/concepts/real_concept.hpp> // for real_concept
+using ::boost::math::concepts::real_concept;
+
 #include <boost/math/distributions/beta.hpp> // for beta_distribution
 using boost::math::beta_distribution;
 using boost::math::beta;
 
-#include <boost/math/concepts/real_concept.hpp> // for real_concept
-using ::boost::math::concepts::real_concept;
-
 #include <boost/test/included/test_exec_monitor.hpp> // for test_main
 #include <boost/test/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE_FRACTION
 

Modified: sandbox/math_toolkit/libs/math/test/test_binomial.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_binomial.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_binomial.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -23,12 +23,12 @@
 #  pragma warning(disable: 4127) // conditional expression is constant.
 #endif
 
-#include <boost/math/distributions/binomial.hpp> // for binomial_distribution
-using boost::math::binomial_distribution;
-
 #include <boost/math/concepts/real_concept.hpp> // for real_concept
 using ::boost::math::concepts::real_concept;
 
+#include <boost/math/distributions/binomial.hpp> // for binomial_distribution
+using boost::math::binomial_distribution;
+
 #include <boost/test/included/test_exec_monitor.hpp> // for test_main
 #include <boost/test/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE
 

Modified: sandbox/math_toolkit/libs/math/test/test_binomial_coeff.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_binomial_coeff.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_binomial_coeff.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -105,7 +105,11 @@
    using namespace std;
 
    typedef T (*func_t)(T, T);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   func_t f = &binomial_wrapper<T>;
+#else
    func_t f = &binomial_wrapper;
+#endif
 
 #include "binomial_data.ipp"
 

Modified: sandbox/math_toolkit/libs/math/test/test_carlson.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_carlson.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_carlson.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -129,7 +129,11 @@
 
    std::cout << "Testing: " << test << std::endl;
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+    value_type (*fp)(value_type, value_type, value_type) = boost::math::ellint_rf<value_type, value_type, value_type>;
+#else
     value_type (*fp)(value_type, value_type, value_type) = boost::math::ellint_rf;
+#endif
     boost::math::tools::test_result<value_type> result;
  
     result = boost::math::tools::test(
@@ -151,7 +155,11 @@
 
    std::cout << "Testing: " << test << std::endl;
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+    value_type (*fp)(value_type, value_type) = boost::math::ellint_rc<value_type, value_type>;
+#else
     value_type (*fp)(value_type, value_type) = boost::math::ellint_rc;
+#endif
     boost::math::tools::test_result<value_type> result;
  
     result = boost::math::tools::test(
@@ -173,7 +181,11 @@
 
    std::cout << "Testing: " << test << std::endl;
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+    value_type (*fp)(value_type, value_type, value_type, value_type) = boost::math::ellint_rj<value_type, value_type, value_type, value_type>;
+#else
     value_type (*fp)(value_type, value_type, value_type, value_type) = boost::math::ellint_rj;
+#endif
     boost::math::tools::test_result<value_type> result;
  
     result = boost::math::tools::test(
@@ -195,7 +207,11 @@
 
    std::cout << "Testing: " << test << std::endl;
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+    value_type (*fp)(value_type, value_type, value_type) = boost::math::ellint_rd<value_type, value_type, value_type>;
+#else
     value_type (*fp)(value_type, value_type, value_type) = boost::math::ellint_rd;
+#endif
     boost::math::tools::test_result<value_type> result;
  
     result = boost::math::tools::test(

Modified: sandbox/math_toolkit/libs/math/test/test_cbrt.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_cbrt.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_cbrt.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -77,7 +77,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::cbrt<value_type>;
+#else
    pg funcp = boost::math::cbrt;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 

Modified: sandbox/math_toolkit/libs/math/test/test_classify.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_classify.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_classify.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -7,8 +7,8 @@
 #include <cmath>
 #include <math.h>
 #include <boost/limits.hpp>
-#include <boost/math/special_functions/fpclassify.hpp>
 #include <boost/math/concepts/real_concept.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
 #include <boost/test/included/test_exec_monitor.hpp>
 
 #ifdef _MSC_VER

Modified: sandbox/math_toolkit/libs/math/test/test_digamma.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_digamma.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_digamma.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -70,7 +70,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::digamma<value_type>;
+#else
    pg funcp = boost::math::digamma;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 

Modified: sandbox/math_toolkit/libs/math/test/test_ellint_1.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_ellint_1.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_ellint_1.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -97,7 +97,11 @@
 
    std::cout << "Testing: " << test << std::endl;
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+    value_type (*fp2)(value_type, value_type) = boost::math::ellint_1<value_type, value_type>;
+#else
     value_type (*fp2)(value_type, value_type) = boost::math::ellint_1;
+#endif
     boost::math::tools::test_result<value_type> result;
 
     result = boost::math::tools::test(
@@ -120,7 +124,11 @@
 
    std::cout << "Testing: " << test << std::endl;
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   value_type (*fp1)(value_type) = boost::math::ellint_1<value_type>;
+#else
    value_type (*fp1)(value_type) = boost::math::ellint_1;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(fp1, 0),

Modified: sandbox/math_toolkit/libs/math/test/test_ellint_2.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_ellint_2.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_ellint_2.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -97,7 +97,11 @@
 
    std::cout << "Testing: " << test << std::endl;
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+    value_type (*fp2)(value_type, value_type) = boost::math::ellint_2<value_type, value_type>;
+#else
     value_type (*fp2)(value_type, value_type) = boost::math::ellint_2;
+#endif
     boost::math::tools::test_result<value_type> result;
 
     result = boost::math::tools::test(
@@ -119,7 +123,11 @@
 
    std::cout << "Testing: " << test << std::endl;
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   value_type (*fp1)(value_type) = boost::math::ellint_2<value_type>;
+#else
    value_type (*fp1)(value_type) = boost::math::ellint_2;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(fp1, 0),

Modified: sandbox/math_toolkit/libs/math/test/test_ellint_3.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_ellint_3.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_ellint_3.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -110,7 +110,11 @@
 
    std::cout << "Testing: " << test << std::endl;
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+    value_type (*fp2)(value_type, value_type, value_type) = boost::math::ellint_3<value_type, value_type, value_type>;
+#else
     value_type (*fp2)(value_type, value_type, value_type) = boost::math::ellint_3;
+#endif
     boost::math::tools::test_result<value_type> result;
 
     result = boost::math::tools::test(
@@ -132,7 +136,11 @@
 
    std::cout << "Testing: " << test << std::endl;
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+    value_type (*fp2)(value_type, value_type) = boost::math::ellint_3<value_type, value_type>;
+#else
     value_type (*fp2)(value_type, value_type) = boost::math::ellint_3;
+#endif
     boost::math::tools::test_result<value_type> result;
 
     result = boost::math::tools::test(

Modified: sandbox/math_toolkit/libs/math/test/test_erf.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_erf.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_erf.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -138,7 +138,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::erf<value_type>;
+#else
    pg funcp = boost::math::erf;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -166,7 +170,11 @@
    //
    // test erfc against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::erfc<value_type>;
+#else
    funcp = boost::math::erfc;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0),
@@ -192,7 +200,6 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type);
-   pg funcp = boost::math::erf;
 
    boost::math::tools::test_result<value_type> result;
    std::cout << "Testing " << test_name << " with type " << type_name
@@ -200,7 +207,11 @@
    //
    // test erf_inv against data:
    //
-   funcp = boost::math::erf_inv;
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::erf_inv<value_type>;
+#else
+   pg funcp = boost::math::erf_inv;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0),
@@ -216,7 +227,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::erf<value_type>;
+#else
    pg funcp = boost::math::erf;
+#endif
 
    boost::math::tools::test_result<value_type> result;
    std::cout << "Testing " << test_name << " with type " << type_name
@@ -224,7 +239,11 @@
    //
    // test erfc_inv against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::erfc_inv<value_type>;
+#else
    funcp = boost::math::erfc_inv;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0),

Modified: sandbox/math_toolkit/libs/math/test/test_error_handling.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_error_handling.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_error_handling.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -55,9 +55,9 @@
 
 }}} // namespaces
 
+#include <boost/math/concepts/real_concept.hpp>
 #include <boost/math/policies/policy.hpp>
 #include <boost/math/policies/error_handling.hpp>
-#include <boost/math/concepts/real_concept.hpp>
 #include <boost/test/included/test_exec_monitor.hpp> // for test_main
 //
 // Define some policies:

Modified: sandbox/math_toolkit/libs/math/test/test_find_location.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_find_location.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_find_location.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -13,6 +13,7 @@
 // Default domain error policy is
 // #define BOOST_MATH_DOMAIN_ERROR_POLICY throw_on_error
 
+#include <boost/math/concepts/real_concept.hpp> // for real_concept
 #include <boost/math/distributions/normal.hpp> // for normal_distribution
   using boost::math::normal; // Default type double.
   using boost::math::normal_distribution; // All floating-point types.
@@ -28,7 +29,6 @@
 
 #include <boost/test/included/test_exec_monitor.hpp> // for test_main
 #include <boost/test/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE_FRACTION, BOOST_CHECK_EQUAL...
-#include <boost/math/concepts/real_concept.hpp> // for real_concept
 
 #include <iostream>
   using std::cout; using std::endl; using std::fixed;

Modified: sandbox/math_toolkit/libs/math/test/test_find_scale.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_find_scale.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_find_scale.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -13,6 +13,7 @@
 // Default distribution domain error policy is
 // #define BOOST_MATH_DOMAIN_ERROR_POLICY throw_on_error
 
+#include <boost/math/concepts/real_concept.hpp> // for real_concept
 #include <boost/math/distributions/normal.hpp> // for normal_distribution
   using boost::math::normal; // Default type double.
   using boost::math::normal_distribution; // All floating-point types.
@@ -28,7 +29,6 @@
 
 #include <boost/test/included/test_exec_monitor.hpp> // for test_main
 #include <boost/test/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE_FRACTION, BOOST_CHECK_EQUAL...
-#include <boost/math/concepts/real_concept.hpp> // for real_concept
 
 #include <iostream>
   using std::cout; using std::endl; using std::fixed;

Modified: sandbox/math_toolkit/libs/math/test/test_gamma.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_gamma.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_gamma.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -299,7 +299,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::tgamma<value_type>;
+#else
    pg funcp = boost::math::tgamma;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -327,7 +331,11 @@
    //
    // test lgamma against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::lgamma<value_type>;
+#else
    funcp = boost::math::lgamma;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0),
@@ -354,7 +362,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::tgamma1pm1<value_type>;
+#else
    pg funcp = boost::math::tgamma1pm1;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 

Modified: sandbox/math_toolkit/libs/math/test/test_hermite.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_hermite.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_hermite.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -99,7 +99,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(unsigned, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::hermite<value_type>;
+#else
    pg funcp = boost::math::hermite;
+#endif
 
    typedef unsigned (*cast_t)(value_type);
 

Modified: sandbox/math_toolkit/libs/math/test/test_ibeta.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_ibeta.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_ibeta.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -289,7 +289,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::beta<value_type, value_type, value_type>;
+#else
    pg funcp = boost::math::beta;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -305,21 +309,33 @@
       extract_result(3));
    handle_test_result(result, data[result.worst()], result.worst(), type_name, "boost::math::beta", test_name);
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::betac<value_type, value_type, value_type>;
+#else
    funcp = boost::math::betac;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0, 1, 2),
       extract_result(4));
    handle_test_result(result, data[result.worst()], result.worst(), type_name, "boost::math::betac", test_name);
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::ibeta<value_type, value_type, value_type>;
+#else
    funcp = boost::math::ibeta;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0, 1, 2),
       extract_result(5));
    handle_test_result(result, data[result.worst()], result.worst(), type_name, "boost::math::ibeta", test_name);
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::ibetac<value_type, value_type, value_type>;
+#else
    funcp = boost::math::ibetac;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0, 1, 2),

Modified: sandbox/math_toolkit/libs/math/test/test_ibeta_inv.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_ibeta_inv.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_ibeta_inv.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -234,7 +234,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::ibeta_inv<value_type, value_type, value_type>;
+#else
    pg funcp = boost::math::ibeta_inv;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -252,7 +256,11 @@
    //
    // test ibetac_inv(T, T, T) against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::ibetac_inv<value_type, value_type, value_type>;
+#else
    funcp = boost::math::ibetac_inv;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0, 1, 2),

Modified: sandbox/math_toolkit/libs/math/test/test_ibeta_inv_ab.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_ibeta_inv_ab.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_ibeta_inv_ab.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -3,6 +3,8 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
+
 #include <boost/math/concepts/real_concept.hpp>
 #include <boost/test/included/test_exec_monitor.hpp>
 #include <boost/test/floating_point_comparison.hpp>
@@ -181,7 +183,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::ibeta_inva<value_type, value_type, value_type>;
+#else
    pg funcp = boost::math::ibeta_inva;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -199,7 +205,11 @@
    //
    // test ibetac_inva(T, T, T) against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::ibetac_inva<value_type, value_type, value_type>;
+#else
    funcp = boost::math::ibetac_inva;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0, 1, 2),
@@ -208,7 +218,11 @@
    //
    // test ibeta_invb(T, T, T) against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::ibeta_invb<value_type, value_type, value_type>;
+#else
    funcp = boost::math::ibeta_invb;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0, 1, 2),
@@ -217,7 +231,11 @@
    //
    // test ibetac_invb(T, T, T) against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::ibetac_invb<value_type, value_type, value_type>;
+#else
    funcp = boost::math::ibetac_invb;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0, 1, 2),
@@ -295,6 +313,3 @@
    return 0;
 }
 
-
-
-

Modified: sandbox/math_toolkit/libs/math/test/test_igamma.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_igamma.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_igamma.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -311,7 +311,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::tgamma<value_type, value_type>;
+#else
    pg funcp = boost::math::tgamma;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -331,7 +335,11 @@
       //
       // test tgamma_lower(T, T) against data:
       //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+      funcp = boost::math::tgamma_lower<value_type, value_type>;
+#else
       funcp = boost::math::tgamma_lower;
+#endif
       result = boost::math::tools::test(
          data,
          bind_func(funcp, 0, 1),
@@ -341,7 +349,11 @@
    //
    // test gamma_q(T, T) against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::gamma_q<value_type, value_type>;
+#else
    funcp = boost::math::gamma_q;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0, 1),
@@ -364,7 +376,11 @@
    //
    // test gamma_p(T, T) against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::gamma_p<value_type, value_type>;
+#else
    funcp = boost::math::gamma_p;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0, 1),

Modified: sandbox/math_toolkit/libs/math/test/test_igamma_inv.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_igamma_inv.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_igamma_inv.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -279,7 +279,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::gamma_p_inv<value_type, value_type>;
+#else
    pg funcp = boost::math::gamma_p_inv;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -297,7 +301,11 @@
    //
    // test gamma_q_inv(T, T) against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::gamma_q_inv<value_type, value_type>;
+#else
    funcp = boost::math::gamma_q_inv;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0, 1),

Modified: sandbox/math_toolkit/libs/math/test/test_igamma_inva.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_igamma_inva.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_igamma_inva.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -3,6 +3,8 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
+
 #include <boost/math/concepts/real_concept.hpp>
 #include <boost/math/special_functions/gamma.hpp>
 #include <boost/test/included/test_exec_monitor.hpp>
@@ -168,7 +170,7 @@
       }
       else if(1 == data[i][5])
          BOOST_CHECK_EQUAL(boost::math::gamma_p_inva(data[i][1], data[i][5]), boost::math::tools::min_value<value_type>());
-      else if(data[i][3] > 2 * boost::math::tools::min_value<value_type>())
+      else if(data[i][5] > 2 * boost::math::tools::min_value<value_type>())
       {
          // not enough bits in our input to get back to x, but we should be in
          // the same ball park:
@@ -205,7 +207,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::gamma_p_inva<value_type, value_type>;
+#else
    pg funcp = boost::math::gamma_p_inva;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -223,7 +229,11 @@
    //
    // test gamma_q_inva(T, T) against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::gamma_q_inva<value_type, value_type>;
+#else
    funcp = boost::math::gamma_q_inva;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0, 1),

Modified: sandbox/math_toolkit/libs/math/test/test_instantiate1.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_instantiate1.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_instantiate1.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -12,6 +12,7 @@
    if(argc > 10000)
    {
       instantiate(double(0));
+      instantiate_mixed(double(0));
       other_test();
    }
 }

Modified: sandbox/math_toolkit/libs/math/test/test_instantiate2.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_instantiate2.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_instantiate2.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -8,6 +8,7 @@
 void other_test()
 {
    instantiate(double(0));
+   instantiate_mixed(double(0));
 }
 
 

Modified: sandbox/math_toolkit/libs/math/test/test_laguerre.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_laguerre.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_laguerre.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -103,6 +103,20 @@
       "real_concept",                // test type(s)
       ".*",                          // test data group
       ".*", 40000, 1000);            // test function
+   add_expected_result(
+      ".*",                          // compiler
+      ".*",                          // stdlib
+      "IBM Aix",                     // platform
+      largest_type,                  // test type(s)
+      ".*",                          // test data group
+      ".*", 5000, 500);            // test function
+   add_expected_result(
+      ".*",                          // compiler
+      ".*",                          // stdlib
+      "IBM Aix",                     // platform
+      "real_concept",                // test type(s)
+      ".*",                          // test data group
+      ".*", 5000, 500);            // test function
 
    //
    // Catch all cases come last:
@@ -137,7 +151,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(unsigned, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::laguerre<value_type>;
+#else
    pg funcp = boost::math::laguerre;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -163,7 +181,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(unsigned, unsigned, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::laguerre<unsigned, value_type>;
+#else
    pg funcp = boost::math::laguerre;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 

Modified: sandbox/math_toolkit/libs/math/test/test_legendre.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_legendre.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_legendre.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -113,7 +113,7 @@
       ".*",                          // platform
       largest_type,                  // test type(s)
       "Legendre Polynomials.*Large.*",      // test data group
-      "boost::math::legendre_p", 400, 200);  // test function
+      "boost::math::legendre_p", 500, 200);  // test function
    add_expected_result(
       ".*",                          // compiler
       ".*",                          // stdlib
@@ -149,7 +149,7 @@
       ".*",                          // platform
       "real_concept",                  // test type(s)
       "Legendre Polynomials.*Large.*",      // test data group
-      "boost::math::legendre_p", 400, 200);  // test function
+      "boost::math::legendre_p", 500, 200);  // test function
    add_expected_result(
       ".*",                          // compiler
       ".*",                          // stdlib
@@ -193,7 +193,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(int, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::legendre_p<value_type>;
+#else
    pg funcp = boost::math::legendre_p;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -220,7 +224,11 @@
 #endif
 
    typedef value_type (*pg2)(unsigned, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg2 funcp2 = boost::math::legendre_q<value_type>;
+#else
    pg2 funcp2 = boost::math::legendre_q;
+#endif
 
    //
    // test legendre_q against data:
@@ -252,7 +260,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(int, int, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::legendre_p<value_type>;
+#else
    pg funcp = boost::math::legendre_p;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 

Modified: sandbox/math_toolkit/libs/math/test/test_minima.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_minima.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_minima.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -29,11 +29,19 @@
    BOOST_CHECK_CLOSE(m.second, T(4), T(0.001));
 
    T (*fp)(T);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   fp = boost::math::lgamma<T>;
+#else
    fp = boost::math::lgamma;
+#endif
 
    m = boost::math::tools::brent_find_minima(fp, T(0.5), T(10), 50);
    BOOST_CHECK_CLOSE(m.first, T(1.461632), T(0.1));
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   fp = boost::math::tgamma<T>;
+#else
    fp = boost::math::tgamma;
+#endif
    m = boost::math::tools::brent_find_minima(fp, T(0.5), T(10), 50);
    BOOST_CHECK_CLOSE(m.first, T(1.461632), T(0.1));
 }

Modified: sandbox/math_toolkit/libs/math/test/test_negative_binomial.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_negative_binomial.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_negative_binomial.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -26,15 +26,15 @@
 #  define TEST_REAL_CONCEPT
 #endif
 
+#include <boost/math/concepts/real_concept.hpp> // for real_concept
+using ::boost::math::concepts::real_concept;
+
 #include <boost/math/distributions/negative_binomial.hpp> // for negative_binomial_distribution
 using boost::math::negative_binomial_distribution;
 
 #include <boost/math/special_functions/gamma.hpp>
   using boost::math::lgamma;  // log gamma
 
-#include <boost/math/concepts/real_concept.hpp> // for real_concept
-using ::boost::math::concepts::real_concept;
-
 #include <boost/test/included/test_exec_monitor.hpp> // for test_main
 #include <boost/test/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE
 

Modified: sandbox/math_toolkit/libs/math/test/test_poisson.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_poisson.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_poisson.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -26,9 +26,9 @@
 #include <boost/test/included/test_exec_monitor.hpp> // Boost.Test
 #include <boost/test/floating_point_comparison.hpp>
 
+#include <boost/math/concepts/real_concept.hpp> // for real_concept
 #include <boost/math/distributions/poisson.hpp>
     using boost::math::poisson_distribution;
-#include <boost/math/concepts/real_concept.hpp> // for real_concept
 #include <boost/math/tools/test.hpp> // for real_concept
 
 #include <boost/math/special_functions/gamma.hpp> // for (incomplete) gamma.

Modified: sandbox/math_toolkit/libs/math/test/test_policy_sf.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_policy_sf.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_policy_sf.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -21,7 +21,7 @@
 
    typedef boost::math::policies::policy<> policy;
 
-   BOOST_MATH_DECLARE_SPECIAL_FUNCTIONS(policy);
+   BOOST_MATH_DECLARE_SPECIAL_FUNCTIONS(policy)
 
 }
 

Modified: sandbox/math_toolkit/libs/math/test/test_remez.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_remez.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_remez.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -18,7 +18,11 @@
 
 void test_polynomial()
 {
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   double (*f)(double) = boost::math::expm1<double>;
+#else
    double (*f)(double) = boost::math::expm1;
+#endif
    std::cout << "Testing expm1 approximation, pinned to origin, abolute error, 6 term polynomial\n";
    boost::math::tools::remez_minimax<double> approx1(f, 6, 0, -1, 1, true, false);
    std::cout << "Interpolation Error: " << approx1.max_error() << std::endl;
@@ -98,7 +102,11 @@
 
 void test_rational()
 {
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   double (*f)(double) = boost::math::expm1<double>;
+#else
    double (*f)(double) = boost::math::expm1;
+#endif
    std::cout << "Testing expm1 approximation, pinned to origin, abolute error, 3+3 term rational\n";
    boost::math::tools::remez_minimax<double> approx1(f, 3, 3, -1, 1, true, false);
    std::cout << "Interpolation Error: " << approx1.max_error() << std::endl;

Modified: sandbox/math_toolkit/libs/math/test/test_spherical_harmonic.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_spherical_harmonic.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_spherical_harmonic.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -101,7 +101,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(unsigned, int, value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::spherical_harmonic_r<value_type, value_type>;
+#else
    pg funcp = boost::math::spherical_harmonic_r;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -117,7 +121,11 @@
       extract_result(4));
    handle_test_result(result, data[result.worst()], result.worst(), type_name, "boost::math::spherical_harmonic_r", test_name);
 
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::spherical_harmonic_i<value_type, value_type>;
+#else
    funcp = boost::math::spherical_harmonic_i;
+#endif
    //
    // test Spheric Harmonic against data:
    //

Modified: sandbox/math_toolkit/libs/math/test/test_students_t.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_students_t.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_students_t.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -17,9 +17,9 @@
 #include <boost/test/included/test_exec_monitor.hpp> // Boost.Test
 #include <boost/test/floating_point_comparison.hpp>
 
+#include <boost/math/concepts/real_concept.hpp> // for real_concept
 #include <boost/math/distributions/students_t.hpp>
     using boost::math::students_t_distribution;
-#include <boost/math/concepts/real_concept.hpp> // for real_concept
 #include <boost/math/tools/test.hpp> // for real_concept
 
 #include <iostream>

Modified: sandbox/math_toolkit/libs/math/test/test_tgamma_ratio.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_tgamma_ratio.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_tgamma_ratio.cpp	2008-04-07 11:43:09 EDT (Mon, 07 Apr 2008)
@@ -143,7 +143,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::tgamma_delta_ratio<value_type, value_type>;
+#else
    pg funcp = boost::math::tgamma_delta_ratio;
+#endif
 
    boost::math::tools::test_result<value_type> result;
 
@@ -172,7 +176,11 @@
    typedef typename row_type::value_type value_type;
 
    typedef value_type (*pg)(value_type, value_type);
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   pg funcp = boost::math::tgamma_ratio<value_type, value_type>;
+#else
    pg funcp = boost::math::tgamma_ratio;
+#endif
 
    boost::math::tools::test_result<value_type> result;