[Boost-commit] svn:boost r41142 - in trunk: boost/math/concepts boost/math/special_functions boost/math/special_functions/detail boost/math/tools libs/math/test libs/math/test/compile_test

From: john_at_[hidden]
Date: 2007-11-16 06:30:47

Author: johnmaddock
Date: 2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
New Revision: 41142
URL: http://svn.boost.org/trac/boost/changeset/41142

Log:
Added workarounds for IBM xlc C++: the compiler can't resolve an overloaded function template to a function pointer unless the template arguments are explicitly provided.
Fixed some bugs uncovered by the above workaround: some forward declarations didn't match the actual definition!
Hopefully fixed remaining Sun compiler issues: mostly fixed by above fixes anyway.
Text files modified: 
   trunk/boost/math/concepts/std_real_concept.hpp             |     5                                         
   trunk/boost/math/special_functions/cos_pi.hpp              |    19 +                                       
   trunk/boost/math/special_functions/detail/gamma_inva.hpp   |    74 +++++++-                                
   trunk/boost/math/special_functions/detail/ibeta_inv_ab.hpp |   198 +++++++++++++++++-----                  
   trunk/boost/math/special_functions/math_fwd.hpp            |    12                                         
   trunk/boost/math/special_functions/sin_pi.hpp              |    19 +                                       
   trunk/boost/math/special_functions/sinc.hpp                |     2                                         
   trunk/boost/math/special_functions/sinhc.hpp               |     2                                         
   trunk/boost/math/tools/config.hpp                          |     4                                         
   trunk/libs/math/test/compile_test/instantiate.hpp          |   354 +++++++++++++++++++++++++++++++++++++++ 
   trunk/libs/math/test/log1p_expm1_test.cpp                  |     8                                         
   trunk/libs/math/test/test_bessel_i.cpp                     |     8                                         
   trunk/libs/math/test/test_bessel_j.cpp                     |    12 +                                       
   trunk/libs/math/test/test_bessel_k.cpp                     |     8                                         
   trunk/libs/math/test/test_bessel_y.cpp                     |    12 +                                       
   trunk/libs/math/test/test_beta.cpp                         |     4                                         
   trunk/libs/math/test/test_binomial_coeff.cpp               |     4                                         
   trunk/libs/math/test/test_carlson.cpp                      |    16 +                                       
   trunk/libs/math/test/test_cbrt.cpp                         |     4                                         
   trunk/libs/math/test/test_digamma.cpp                      |     4                                         
   trunk/libs/math/test/test_ellint_1.cpp                     |     8                                         
   trunk/libs/math/test/test_ellint_2.cpp                     |     8                                         
   trunk/libs/math/test/test_ellint_3.cpp                     |     8                                         
   trunk/libs/math/test/test_erf.cpp                          |    16 +                                       
   trunk/libs/math/test/test_gamma.cpp                        |    12 +                                       
   trunk/libs/math/test/test_hermite.cpp                      |     4                                         
   trunk/libs/math/test/test_ibeta.cpp                        |    16 +                                       
   trunk/libs/math/test/test_ibeta_inv.cpp                    |     8                                         
   trunk/libs/math/test/test_ibeta_inv_ab.cpp                 |    21 ++                                      
   trunk/libs/math/test/test_igamma.cpp                       |    16 +                                       
   trunk/libs/math/test/test_igamma_inv.cpp                   |     8                                         
   trunk/libs/math/test/test_igamma_inva.cpp                  |    10 +                                       
   trunk/libs/math/test/test_instantiate1.cpp                 |     1                                         
   trunk/libs/math/test/test_instantiate2.cpp                 |     1                                         
   trunk/libs/math/test/test_laguerre.cpp                     |     8                                         
   trunk/libs/math/test/test_legendre.cpp                     |    12 +                                       
   trunk/libs/math/test/test_minima.cpp                       |     8                                         
   trunk/libs/math/test/test_remez.cpp                        |     8                                         
   trunk/libs/math/test/test_spherical_harmonic.cpp           |     8                                         
   trunk/libs/math/test/test_tgamma_ratio.cpp                 |     8                                         
   40 files changed, 881 insertions(+), 77 deletions(-)

Modified: trunk/boost/math/concepts/std_real_concept.hpp
==============================================================================
--- trunk/boost/math/concepts/std_real_concept.hpp	(original)
+++ trunk/boost/math/concepts/std_real_concept.hpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -231,8 +231,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)

Modified: trunk/boost/math/special_functions/cos_pi.hpp
==============================================================================
--- trunk/boost/math/special_functions/cos_pi.hpp	(original)
+++ trunk/boost/math/special_functions/cos_pi.hpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -9,12 +9,13 @@
 #include <cmath>
 #include <boost/math/tools/config.hpp>
 #include <boost/math/tools/real_cast.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>
-T cos_pi(T x)
+T cos_pi_imp(T x)
 {
    BOOST_MATH_STD_USING // ADL of std names
    // cos of pi*x:
@@ -42,10 +43,20 @@
    return invert ? -rem : rem;
 }
 
+}
+
 template <class T, class Policy>
-inline T cos_pi(T x, const Policy&)
+inline typename tools::promote_args<T>::type cos_pi(T x, const Policy&)
+{
+   typedef typename tools::promote_args<T>::type result_type;
+   return boost::math::detail::cos_pi_imp<result_type>(x);
+}
+
+template <class T>
+inline typename tools::promote_args<T>::type cos_pi(T x)
 {
-   return cos_pi(x);
+   typedef typename tools::promote_args<T>::type result_type;
+   return boost::math::detail::cos_pi_imp<result_type>(x);
 }
 
 } // namespace math

Modified: trunk/boost/math/special_functions/detail/gamma_inva.hpp
==============================================================================
--- trunk/boost/math/special_functions/detail/gamma_inva.hpp	(original)
+++ trunk/boost/math/special_functions/detail/gamma_inva.hpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -146,28 +146,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: trunk/boost/math/special_functions/detail/ibeta_inv_ab.hpp
==============================================================================
--- trunk/boost/math/special_functions/detail/ibeta_inv_ab.hpp	(original)
+++ trunk/boost/math/special_functions/detail/ibeta_inv_ab.hpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -155,52 +155,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: trunk/boost/math/special_functions/math_fwd.hpp
==============================================================================
--- trunk/boost/math/special_functions/math_fwd.hpp	(original)
+++ trunk/boost/math/special_functions/math_fwd.hpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -595,16 +595,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);
@@ -898,10 +898,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: trunk/boost/math/special_functions/sin_pi.hpp
==============================================================================
--- trunk/boost/math/special_functions/sin_pi.hpp	(original)
+++ trunk/boost/math/special_functions/sin_pi.hpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -9,12 +9,13 @@
 #include <cmath>
 #include <boost/math/tools/config.hpp>
 #include <boost/math/tools/real_cast.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>
-T sin_pi(T x)
+T sin_pi_imp(T x)
 {
    BOOST_MATH_STD_USING // ADL of std names
    // sin of pi*x:
@@ -42,10 +43,20 @@
    return invert ? -rem : rem;
 }
 
+}
+
 template <class T, class Policy>
-inline T sin_pi(T x, const Policy&)
+inline typename tools::promote_args<T>::type sin_pi(T x, const Policy&)
+{
+   typedef typename tools::promote_args<T>::type result_type;
+   return boost::math::detail::sin_pi_imp<result_type>(x);
+}
+
+template <class T>
+inline typename tools::promote_args<T>::type sin_pi(T x)
 {
-   return boost::math::sin_pi(x);
+   typedef typename tools::promote_args<T>::type result_type;
+   return boost::math::detail::sin_pi_imp<result_type>(x);
 }
 
 } // namespace math

Modified: trunk/boost/math/special_functions/sinc.hpp
==============================================================================
--- trunk/boost/math/special_functions/sinc.hpp	(original)
+++ trunk/boost/math/special_functions/sinc.hpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -48,7 +48,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: trunk/boost/math/special_functions/sinhc.hpp
==============================================================================
--- trunk/boost/math/special_functions/sinhc.hpp	(original)
+++ trunk/boost/math/special_functions/sinhc.hpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -47,7 +47,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: trunk/boost/math/tools/config.hpp
==============================================================================
--- trunk/boost/math/tools/config.hpp	(original)
+++ trunk/boost/math/tools/config.hpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -55,6 +55,10 @@
 #  define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
 #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"

Modified: trunk/libs/math/test/compile_test/instantiate.hpp
==============================================================================
--- trunk/libs/math/test/compile_test/instantiate.hpp	(original)
+++ trunk/libs/math/test/compile_test/instantiate.hpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -141,7 +141,7 @@
    (boost::math::isfinite)(v1);
    (boost::math::isnormal)(v1);
    (boost::math::isnan)(v1);
-   boost::math::isinf(v1);
+   (boost::math::isinf)(v1);
    boost::math::log1p(v1);
    boost::math::expm1(v1);
    boost::math::cbrt(v1);
@@ -382,5 +382,357 @@
    test::sph_neumann(i, i);
 }
 
+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;
+   long double lr = 0.5L;
+
+   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: trunk/libs/math/test/log1p_expm1_test.cpp
==============================================================================
--- trunk/libs/math/test/log1p_expm1_test.cpp	(original)
+++ trunk/libs/math/test/log1p_expm1_test.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -78,7 +78,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 +92,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: trunk/libs/math/test/test_bessel_i.cpp
==============================================================================
--- trunk/libs/math/test/test_bessel_i.cpp	(original)
+++ trunk/libs/math/test/test_bessel_i.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -113,7 +113,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;
 
@@ -157,7 +161,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: trunk/libs/math/test/test_bessel_j.cpp
==============================================================================
--- trunk/libs/math/test/test_bessel_j.cpp	(original)
+++ trunk/libs/math/test/test_bessel_j.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_bessel_k.cpp
==============================================================================
--- trunk/libs/math/test/test_bessel_k.cpp	(original)
+++ trunk/libs/math/test/test_bessel_k.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_bessel_y.cpp
==============================================================================
--- trunk/libs/math/test/test_bessel_y.cpp	(original)
+++ trunk/libs/math/test/test_bessel_y.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_beta.cpp
==============================================================================
--- trunk/libs/math/test/test_beta.cpp	(original)
+++ trunk/libs/math/test/test_beta.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_binomial_coeff.cpp
==============================================================================
--- trunk/libs/math/test/test_binomial_coeff.cpp	(original)
+++ trunk/libs/math/test/test_binomial_coeff.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -104,7 +104,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: trunk/libs/math/test/test_carlson.cpp
==============================================================================
--- trunk/libs/math/test/test_carlson.cpp	(original)
+++ trunk/libs/math/test/test_carlson.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_cbrt.cpp
==============================================================================
--- trunk/libs/math/test/test_cbrt.cpp	(original)
+++ trunk/libs/math/test/test_cbrt.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_digamma.cpp
==============================================================================
--- trunk/libs/math/test/test_digamma.cpp	(original)
+++ trunk/libs/math/test/test_digamma.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_ellint_1.cpp
==============================================================================
--- trunk/libs/math/test/test_ellint_1.cpp	(original)
+++ trunk/libs/math/test/test_ellint_1.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_ellint_2.cpp
==============================================================================
--- trunk/libs/math/test/test_ellint_2.cpp	(original)
+++ trunk/libs/math/test/test_ellint_2.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_ellint_3.cpp
==============================================================================
--- trunk/libs/math/test/test_ellint_3.cpp	(original)
+++ trunk/libs/math/test/test_ellint_3.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_erf.cpp
==============================================================================
--- trunk/libs/math/test/test_erf.cpp	(original)
+++ trunk/libs/math/test/test_erf.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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),
@@ -200,7 +208,11 @@
    //
    // test erf_inv against data:
    //
+#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
+   funcp = boost::math::erf_inv<value_type>;
+#else
    funcp = boost::math::erf_inv;
+#endif
    result = boost::math::tools::test(
       data,
       bind_func(funcp, 0),
@@ -224,7 +236,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: trunk/libs/math/test/test_gamma.cpp
==============================================================================
--- trunk/libs/math/test/test_gamma.cpp	(original)
+++ trunk/libs/math/test/test_gamma.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_hermite.cpp
==============================================================================
--- trunk/libs/math/test/test_hermite.cpp	(original)
+++ trunk/libs/math/test/test_hermite.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_ibeta.cpp
==============================================================================
--- trunk/libs/math/test/test_ibeta.cpp	(original)
+++ trunk/libs/math/test/test_ibeta.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_ibeta_inv.cpp
==============================================================================
--- trunk/libs/math/test/test_ibeta_inv.cpp	(original)
+++ trunk/libs/math/test/test_ibeta_inv.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_ibeta_inv_ab.cpp
==============================================================================
--- trunk/libs/math/test/test_ibeta_inv_ab.cpp	(original)
+++ trunk/libs/math/test/test_ibeta_inv_ab.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_igamma.cpp
==============================================================================
--- trunk/libs/math/test/test_igamma.cpp	(original)
+++ trunk/libs/math/test/test_igamma.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_igamma_inv.cpp
==============================================================================
--- trunk/libs/math/test/test_igamma_inv.cpp	(original)
+++ trunk/libs/math/test/test_igamma_inv.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_igamma_inva.cpp
==============================================================================
--- trunk/libs/math/test/test_igamma_inva.cpp	(original)
+++ trunk/libs/math/test/test_igamma_inva.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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>
@@ -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: trunk/libs/math/test/test_instantiate1.cpp
==============================================================================
--- trunk/libs/math/test/test_instantiate1.cpp	(original)
+++ trunk/libs/math/test/test_instantiate1.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -12,6 +12,7 @@
    if(argc > 10000)
    {
       instantiate(double(0));
+      instantiate_mixed(double(0));
       other_test();
    }
 }

Modified: trunk/libs/math/test/test_instantiate2.cpp
==============================================================================
--- trunk/libs/math/test/test_instantiate2.cpp	(original)
+++ trunk/libs/math/test/test_instantiate2.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -8,6 +8,7 @@
 void other_test()
 {
    instantiate(double(0));
+   instantiate_mixed(double(0));
 }
 
 

Modified: trunk/libs/math/test/test_laguerre.cpp
==============================================================================
--- trunk/libs/math/test/test_laguerre.cpp	(original)
+++ trunk/libs/math/test/test_laguerre.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -137,7 +137,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 +167,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: trunk/libs/math/test/test_legendre.cpp
==============================================================================
--- trunk/libs/math/test/test_legendre.cpp	(original)
+++ trunk/libs/math/test/test_legendre.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_minima.cpp
==============================================================================
--- trunk/libs/math/test/test_minima.cpp	(original)
+++ trunk/libs/math/test/test_minima.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_remez.cpp
==============================================================================
--- trunk/libs/math/test/test_remez.cpp	(original)
+++ trunk/libs/math/test/test_remez.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_spherical_harmonic.cpp
==============================================================================
--- trunk/libs/math/test/test_spherical_harmonic.cpp	(original)
+++ trunk/libs/math/test/test_spherical_harmonic.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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: trunk/libs/math/test/test_tgamma_ratio.cpp
==============================================================================
--- trunk/libs/math/test/test_tgamma_ratio.cpp	(original)
+++ trunk/libs/math/test/test_tgamma_ratio.cpp	2007-11-16 06:30:43 EST (Fri, 16 Nov 2007)
@@ -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;