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;