[Boost-commit] svn:boost r41162 - in branches/proto/v3: . boost boost/math/concepts boost/math/special_functions boost/math/special_functions/detail boost/math/tools boost/thread/pthread libs/math/test libs/math/test/compile_test libs/regex/src libs/thread/build libs/thread/src/pthread libs/xpressive/test more status tools/build/v2/tools

From: eric_at_[hidden]
Date: 2007-11-16 19:34:42

Author: eric_niebler
Date: 2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
New Revision: 41162
URL: http://svn.boost.org/trac/boost/changeset/41162

Log:
Merged revisions 41141-41160 via svnmerge from 
https://svn.boost.org/svn/boost/trunk

........
  r41142 | johnmaddock | 2007-11-16 03:30:43 -0800 (Fri, 16 Nov 2007) | 3 lines
  
  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.
........
  r41143 | johnmaddock | 2007-11-16 04:00:32 -0800 (Fri, 16 Nov 2007) | 1 line
  
  Disabled use of MS-specific narrow character functions when _WIN32_WCE is defined.
........
  r41144 | garcia | 2007-11-16 04:37:08 -0800 (Fri, 16 Nov 2007) | 2 lines
  
  Added flyweignt and Unordered Containers.
........
  r41145 | garcia | 2007-11-16 05:22:09 -0800 (Fri, 16 Nov 2007) | 2 lines
  
  Initial Revision.
........
  r41146 | garcia | 2007-11-16 05:23:41 -0800 (Fri, 16 Nov 2007) | 2 lines
  
  Review Wizard Report.
........
  r41147 | bemandawes | 2007-11-16 07:14:54 -0800 (Fri, 16 Nov 2007) | 1 line
  
  Add some filesystem markup
........
  r41149 | grafik | 2007-11-16 08:15:35 -0800 (Fri, 16 Nov 2007) | 1 line
  
  Add support for msvc-9.0, thanks to John Pavel.
........
  r41151 | noel_belcourt | 2007-11-16 09:30:57 -0800 (Fri, 16 Nov 2007) | 4 lines
  
  Make vacpp toolset recognize and support version
  numbers.  Also perform minimal options processing.
........
  r41153 | hkaiser | 2007-11-16 10:44:56 -0800 (Fri, 16 Nov 2007) | 1 line
  
  Wave: Added identifying comment into the main header
........
  r41154 | danieljames | 2007-11-16 10:46:36 -0800 (Fri, 16 Nov 2007) | 2 lines
  
  Move the bug and feature request pages to the new site. Refs #1259. Fixes #1369.
........
  r41155 | eric_niebler | 2007-11-16 11:24:52 -0800 (Fri, 16 Nov 2007) | 1 line
  
  add comment pointing to BOOST_FOREACH's online docs
........
  r41158 | djenkins | 2007-11-16 13:25:07 -0800 (Fri, 16 Nov 2007) | 1 line
  
  Remove extraneous comments
........
  r41160 | anthonyw | 2007-11-16 14:51:52 -0800 (Fri, 16 Nov 2007) | 1 line
  
  New implementation of pthread_once based on Mike Burrows' algorithm
........

Added:
   branches/proto/v3/libs/thread/src/pthread/once.cpp
      - copied unchanged from r41160, /trunk/libs/thread/src/pthread/once.cpp
   branches/proto/v3/more/report-nov-2007.html
      - copied unchanged from r41160, /trunk/more/report-nov-2007.html
Removed:
   branches/proto/v3/more/bugs.htm
   branches/proto/v3/more/requesting_new_features.htm
Properties modified: 
   branches/proto/v3/   (props changed)
Text files modified: 
   branches/proto/v3/boost/foreach.hpp                                    |     1                                         
   branches/proto/v3/boost/math/concepts/std_real_concept.hpp             |     5                                         
   branches/proto/v3/boost/math/special_functions/cos_pi.hpp              |    19 +                                       
   branches/proto/v3/boost/math/special_functions/detail/gamma_inva.hpp   |    74 +++++++-                                
   branches/proto/v3/boost/math/special_functions/detail/ibeta_inv_ab.hpp |   198 +++++++++++++++++-----                  
   branches/proto/v3/boost/math/special_functions/math_fwd.hpp            |    12                                         
   branches/proto/v3/boost/math/special_functions/sin_pi.hpp              |    19 +                                       
   branches/proto/v3/boost/math/special_functions/sinc.hpp                |     2                                         
   branches/proto/v3/boost/math/special_functions/sinhc.hpp               |     2                                         
   branches/proto/v3/boost/math/tools/config.hpp                          |     4                                         
   branches/proto/v3/boost/thread/pthread/once.hpp                        |    70 +++++--                                 
   branches/proto/v3/boost/thread/pthread/pthread_mutex_scoped_lock.hpp   |    16 +                                       
   branches/proto/v3/boost/wave.hpp                                       |     2                                         
   branches/proto/v3/libs/math/test/compile_test/instantiate.hpp          |   354 +++++++++++++++++++++++++++++++++++++++ 
   branches/proto/v3/libs/math/test/log1p_expm1_test.cpp                  |     8                                         
   branches/proto/v3/libs/math/test/test_bessel_i.cpp                     |     8                                         
   branches/proto/v3/libs/math/test/test_bessel_j.cpp                     |    12 +                                       
   branches/proto/v3/libs/math/test/test_bessel_k.cpp                     |     8                                         
   branches/proto/v3/libs/math/test/test_bessel_y.cpp                     |    12 +                                       
   branches/proto/v3/libs/math/test/test_beta.cpp                         |     4                                         
   branches/proto/v3/libs/math/test/test_binomial_coeff.cpp               |     4                                         
   branches/proto/v3/libs/math/test/test_carlson.cpp                      |    16 +                                       
   branches/proto/v3/libs/math/test/test_cbrt.cpp                         |     4                                         
   branches/proto/v3/libs/math/test/test_digamma.cpp                      |     4                                         
   branches/proto/v3/libs/math/test/test_ellint_1.cpp                     |     8                                         
   branches/proto/v3/libs/math/test/test_ellint_2.cpp                     |     8                                         
   branches/proto/v3/libs/math/test/test_ellint_3.cpp                     |     8                                         
   branches/proto/v3/libs/math/test/test_erf.cpp                          |    16 +                                       
   branches/proto/v3/libs/math/test/test_gamma.cpp                        |    12 +                                       
   branches/proto/v3/libs/math/test/test_hermite.cpp                      |     4                                         
   branches/proto/v3/libs/math/test/test_ibeta.cpp                        |    16 +                                       
   branches/proto/v3/libs/math/test/test_ibeta_inv.cpp                    |     8                                         
   branches/proto/v3/libs/math/test/test_ibeta_inv_ab.cpp                 |    21 ++                                      
   branches/proto/v3/libs/math/test/test_igamma.cpp                       |    16 +                                       
   branches/proto/v3/libs/math/test/test_igamma_inv.cpp                   |     8                                         
   branches/proto/v3/libs/math/test/test_igamma_inva.cpp                  |    10 +                                       
   branches/proto/v3/libs/math/test/test_instantiate1.cpp                 |     1                                         
   branches/proto/v3/libs/math/test/test_instantiate2.cpp                 |     1                                         
   branches/proto/v3/libs/math/test/test_laguerre.cpp                     |     8                                         
   branches/proto/v3/libs/math/test/test_legendre.cpp                     |    12 +                                       
   branches/proto/v3/libs/math/test/test_minima.cpp                       |     8                                         
   branches/proto/v3/libs/math/test/test_remez.cpp                        |     8                                         
   branches/proto/v3/libs/math/test/test_spherical_harmonic.cpp           |     8                                         
   branches/proto/v3/libs/math/test/test_tgamma_ratio.cpp                 |     8                                         
   branches/proto/v3/libs/regex/src/cregex.cpp                            |     2                                         
   branches/proto/v3/libs/regex/src/posix_api.cpp                         |     4                                         
   branches/proto/v3/libs/thread/build/Jamfile.v2                         |     1                                         
   branches/proto/v3/libs/xpressive/test/test_symbols.cpp                 |     3                                         
   branches/proto/v3/more/formal_review_schedule.html                     |    35 +++                                     
   branches/proto/v3/status/explicit-failures-markup.xml                  |    13 +                                       
   branches/proto/v3/tools/build/v2/tools/builtin.jam                     |     4                                         
   branches/proto/v3/tools/build/v2/tools/msvc.jam                        |    26 ++                                      
   branches/proto/v3/tools/build/v2/tools/vacpp.jam                       |     8                                         
   53 files changed, 1030 insertions(+), 113 deletions(-)

Modified: branches/proto/v3/boost/foreach.hpp
==============================================================================
--- branches/proto/v3/boost/foreach.hpp	(original)
+++ branches/proto/v3/boost/foreach.hpp	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -5,6 +5,7 @@
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
+// See http://www.boost.org/libs/foreach for documentation
 //
 // Credits:
 //  Anson Tsao        - for the initial inspiration and several good suggestions.

Modified: branches/proto/v3/boost/math/concepts/std_real_concept.hpp
==============================================================================
--- branches/proto/v3/boost/math/concepts/std_real_concept.hpp	(original)
+++ branches/proto/v3/boost/math/concepts/std_real_concept.hpp	2007-11-16 19:34:37 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: branches/proto/v3/boost/math/special_functions/cos_pi.hpp
==============================================================================
--- branches/proto/v3/boost/math/special_functions/cos_pi.hpp	(original)
+++ branches/proto/v3/boost/math/special_functions/cos_pi.hpp	2007-11-16 19:34:37 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: branches/proto/v3/boost/math/special_functions/detail/gamma_inva.hpp
==============================================================================
--- branches/proto/v3/boost/math/special_functions/detail/gamma_inva.hpp	(original)
+++ branches/proto/v3/boost/math/special_functions/detail/gamma_inva.hpp	2007-11-16 19:34:37 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: branches/proto/v3/boost/math/special_functions/detail/ibeta_inv_ab.hpp
==============================================================================
--- branches/proto/v3/boost/math/special_functions/detail/ibeta_inv_ab.hpp	(original)
+++ branches/proto/v3/boost/math/special_functions/detail/ibeta_inv_ab.hpp	2007-11-16 19:34:37 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: branches/proto/v3/boost/math/special_functions/math_fwd.hpp
==============================================================================
--- branches/proto/v3/boost/math/special_functions/math_fwd.hpp	(original)
+++ branches/proto/v3/boost/math/special_functions/math_fwd.hpp	2007-11-16 19:34:37 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: branches/proto/v3/boost/math/special_functions/sin_pi.hpp
==============================================================================
--- branches/proto/v3/boost/math/special_functions/sin_pi.hpp	(original)
+++ branches/proto/v3/boost/math/special_functions/sin_pi.hpp	2007-11-16 19:34:37 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: branches/proto/v3/boost/math/special_functions/sinc.hpp
==============================================================================
--- branches/proto/v3/boost/math/special_functions/sinc.hpp	(original)
+++ branches/proto/v3/boost/math/special_functions/sinc.hpp	2007-11-16 19:34:37 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: branches/proto/v3/boost/math/special_functions/sinhc.hpp
==============================================================================
--- branches/proto/v3/boost/math/special_functions/sinhc.hpp	(original)
+++ branches/proto/v3/boost/math/special_functions/sinhc.hpp	2007-11-16 19:34:37 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: branches/proto/v3/boost/math/tools/config.hpp
==============================================================================
--- branches/proto/v3/boost/math/tools/config.hpp	(original)
+++ branches/proto/v3/boost/math/tools/config.hpp	2007-11-16 19:34:37 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: branches/proto/v3/boost/thread/pthread/once.hpp
==============================================================================
--- branches/proto/v3/boost/thread/pthread/once.hpp	(original)
+++ branches/proto/v3/boost/thread/pthread/once.hpp	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -14,42 +14,72 @@
 #include <pthread.h>
 #include <boost/assert.hpp>
 #include "pthread_mutex_scoped_lock.hpp"
+#include <boost/cstdint.hpp>
+#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
 
 namespace boost {
 
     struct once_flag
     {
-        pthread_mutex_t mutex;
-        unsigned long flag;
+        boost::uintmax_t epoch;
     };
 
-#define BOOST_ONCE_INIT {PTHREAD_MUTEX_INITIALIZER,0}
+    namespace detail
+    {
+        BOOST_THREAD_DECL boost::uintmax_t& get_once_per_thread_epoch();
+        extern BOOST_THREAD_DECL boost::uintmax_t once_global_epoch;
+        extern BOOST_THREAD_DECL pthread_mutex_t once_epoch_mutex;
+        extern BOOST_THREAD_DECL pthread_cond_t once_epoch_cv;
+    }
+    
+#define BOOST_ONCE_INITIAL_FLAG_VALUE -1
+#define BOOST_ONCE_INIT {BOOST_ONCE_INITIAL_FLAG_VALUE}
 
+
+    // Based on Mike Burrows fast_pthread_once algorithm as described in
+    // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2444.html
     template<typename Function>
     void call_once(once_flag& flag,Function f)
     {
-        unsigned long const function_complete_flag_value=0xc15730e2ul;
-
-#ifdef BOOST_PTHREAD_HAS_ATOMICS
-        if(::boost::detail::interlocked_read_acquire(&flag.flag)!=function_complete_flag_value)
+        static boost::uintmax_t const uninitialized_flag=BOOST_ONCE_INITIAL_FLAG_VALUE;
+        static boost::uintmax_t const being_initialized=uninitialized_flag-1;
+        boost::uintmax_t const epoch=flag.epoch;
+        boost::uintmax_t& this_thread_epoch=detail::get_once_per_thread_epoch();
+        
+        if(epoch>this_thread_epoch)
         {
-#endif
-            pthread::pthread_mutex_scoped_lock const lock(&flag.mutex);
-            if(flag.flag!=function_complete_flag_value)
+            pthread::pthread_mutex_scoped_lock lk(&detail::once_epoch_mutex);
+
+            while(flag.epoch>=being_initialized)
             {
-                f();
-#ifdef BOOST_PTHREAD_HAS_ATOMICS
-                ::boost::detail::interlocked_write_release(&flag.flag,function_complete_flag_value);
-#else
-                flag.flag=function_complete_flag_value;
-#endif
+                if(flag.epoch==uninitialized_flag)
+                {
+                    flag.epoch=being_initialized;
+                    try
+                    {
+                        pthread::pthread_mutex_scoped_unlock relocker(&detail::once_epoch_mutex);
+                        f();
+                    }
+                    catch(...)
+                    {
+                        flag.epoch=uninitialized_flag;
+                        BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));
+                        throw;
+                    }
+                    flag.epoch=++detail::once_global_epoch;
+                    BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));
+                }
+                else
+                {
+                    while(flag.epoch==being_initialized)
+                    {
+                        BOOST_VERIFY(!pthread_cond_wait(&detail::once_epoch_cv,&detail::once_epoch_mutex));
+                    }
+                }
             }
-#ifdef BOOST_PTHREAD_HAS_ATOMICS
+            this_thread_epoch=detail::once_global_epoch;
         }
-#endif
     }
-    
-
 }
 
 #endif

Modified: branches/proto/v3/boost/thread/pthread/pthread_mutex_scoped_lock.hpp
==============================================================================
--- branches/proto/v3/boost/thread/pthread/pthread_mutex_scoped_lock.hpp	(original)
+++ branches/proto/v3/boost/thread/pthread/pthread_mutex_scoped_lock.hpp	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -28,6 +28,22 @@
             }
             
         };
+
+        class pthread_mutex_scoped_unlock
+        {
+            pthread_mutex_t* m;
+        public:
+            explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_):
+                m(m_)
+            {
+                BOOST_VERIFY(!pthread_mutex_unlock(m));
+            }
+            ~pthread_mutex_scoped_unlock()
+            {
+                BOOST_VERIFY(!pthread_mutex_lock(m));
+            }
+            
+        };
     }
 }
 

Modified: branches/proto/v3/boost/wave.hpp
==============================================================================
--- branches/proto/v3/boost/wave.hpp	(original)
+++ branches/proto/v3/boost/wave.hpp	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -3,6 +3,8 @@
 
     http://www.boost.org/
 
+    See http://www.boost.org/libs/wave for documentation
+
     Copyright (c) 2001-2007 Hartmut Kaiser. Distributed under the Boost
     Software License, Version 1.0. (See accompanying file
     LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

Modified: branches/proto/v3/libs/math/test/compile_test/instantiate.hpp
==============================================================================
--- branches/proto/v3/libs/math/test/compile_test/instantiate.hpp	(original)
+++ branches/proto/v3/libs/math/test/compile_test/instantiate.hpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/log1p_expm1_test.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/log1p_expm1_test.cpp	(original)
+++ branches/proto/v3/libs/math/test/log1p_expm1_test.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_bessel_i.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_bessel_i.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_bessel_i.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_bessel_j.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_bessel_j.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_bessel_j.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_bessel_k.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_bessel_k.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_bessel_k.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_bessel_y.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_bessel_y.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_bessel_y.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_beta.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_beta.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_beta.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_binomial_coeff.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_binomial_coeff.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_binomial_coeff.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_carlson.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_carlson.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_carlson.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_cbrt.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_cbrt.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_cbrt.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_digamma.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_digamma.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_digamma.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_ellint_1.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_ellint_1.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_ellint_1.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_ellint_2.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_ellint_2.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_ellint_2.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_ellint_3.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_ellint_3.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_ellint_3.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_erf.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_erf.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_erf.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_gamma.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_gamma.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_gamma.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_hermite.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_hermite.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_hermite.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_ibeta.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_ibeta.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_ibeta.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_ibeta_inv.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_ibeta_inv.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_ibeta_inv.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_ibeta_inv_ab.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_ibeta_inv_ab.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_ibeta_inv_ab.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_igamma.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_igamma.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_igamma.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_igamma_inv.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_igamma_inv.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_igamma_inv.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_igamma_inva.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_igamma_inva.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_igamma_inva.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_instantiate1.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_instantiate1.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_instantiate1.cpp	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -12,6 +12,7 @@
    if(argc > 10000)
    {
       instantiate(double(0));
+      instantiate_mixed(double(0));
       other_test();
    }
 }

Modified: branches/proto/v3/libs/math/test/test_instantiate2.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_instantiate2.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_instantiate2.cpp	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -8,6 +8,7 @@
 void other_test()
 {
    instantiate(double(0));
+   instantiate_mixed(double(0));
 }
 
 

Modified: branches/proto/v3/libs/math/test/test_laguerre.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_laguerre.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_laguerre.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_legendre.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_legendre.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_legendre.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_minima.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_minima.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_minima.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_remez.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_remez.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_remez.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_spherical_harmonic.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_spherical_harmonic.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_spherical_harmonic.cpp	2007-11-16 19:34:37 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: branches/proto/v3/libs/math/test/test_tgamma_ratio.cpp
==============================================================================
--- branches/proto/v3/libs/math/test/test_tgamma_ratio.cpp	(original)
+++ branches/proto/v3/libs/math/test/test_tgamma_ratio.cpp	2007-11-16 19:34:37 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;
 

Modified: branches/proto/v3/libs/regex/src/cregex.cpp
==============================================================================
--- branches/proto/v3/libs/regex/src/cregex.cpp	(original)
+++ branches/proto/v3/libs/regex/src/cregex.cpp	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -354,7 +354,7 @@
 
       while(dstart != dend)
       {
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE)
          (::sprintf_s)(buf, sizeof(buf), "%s%s%s", dstart.path(), directory_iterator::separator(), ptr);
 #else
          (std::sprintf)(buf, "%s%s%s", dstart.path(), directory_iterator::separator(), ptr);

Modified: branches/proto/v3/libs/regex/src/posix_api.cpp
==============================================================================
--- branches/proto/v3/libs/regex/src/posix_api.cpp	(original)
+++ branches/proto/v3/libs/regex/src/posix_api.cpp	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -164,7 +164,7 @@
       {
          if(std::strcmp(e->re_endp, names[i]) == 0)
          {
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE)
             (::sprintf_s)(localbuf, 5, "%d", i);
 #else
             (std::sprintf)(localbuf, "%d", i);
@@ -174,7 +174,7 @@
             return std::strlen(localbuf) + 1;
          }
       }
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE)
       (::sprintf_s)(localbuf, 5, "%d", 0);
 #else
       (std::sprintf)(localbuf, "%d", 0);

Modified: branches/proto/v3/libs/thread/build/Jamfile.v2
==============================================================================
--- branches/proto/v3/libs/thread/build/Jamfile.v2	(original)
+++ branches/proto/v3/libs/thread/build/Jamfile.v2	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -191,6 +191,7 @@
       pthread/thread.cpp
       pthread/exceptions.cpp
       pthread/tss.cpp
+      pthread/once.cpp
     : ## requirements ##
       <threadapi>pthread
     ;

Modified: branches/proto/v3/libs/xpressive/test/test_symbols.cpp
==============================================================================
--- branches/proto/v3/libs/xpressive/test/test_symbols.cpp	(original)
+++ branches/proto/v3/libs/xpressive/test/test_symbols.cpp	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -282,9 +282,6 @@
 
     std::wstring str(L"Chicago \u041c\u043E\u0441\u043A\u0432\u0430");
     City result1, result2;
-    //int result1p;
-    // ERROR "error C2039: 'population' : is not a member of 'boost::proto::expr<Tag,Args>'	c:\boost\libs\xpressive\test\test_symbols.cpp	277"
-    //sregex rx = (a1= map1)[ xp::ref(result1p) = a1.population ];
     wsregex rx = (a1= map1)[ xp::ref(result1) = a1 ] >> +_s
         >> (a1= map1)[ xp::ref(result2) = a1 ];
     if(!regex_match(str, rx))

Deleted: branches/proto/v3/more/bugs.htm
==============================================================================
--- branches/proto/v3/more/bugs.htm	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
+++ (empty file)
@@ -1,118 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head>
-  <meta http-equiv="Content-Language" content="en-us">
-
-  <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-
-  <meta name="GENERATOR" content="Microsoft FrontPage 5.0">
-
-  <meta name="ProgId" content="FrontPage.Editor.Document">
-  <title>Bugs</title>
-</head>
-
-
-<body bgcolor="#ffffff" text="#000000">
-
-<table border="1" bgcolor="#007f7f" cellpadding="2">
-
-  <tbody><tr>
-    <td bgcolor="#ffffff">
-    <img src="../boost.png" alt="boost.png (6897 bytes)" width="277" height="86"></td>
-    <td>Home</td>
-    <td><a href="../libs/libraries.htm"><font face="Arial" color="#ffffff"><big>
-    Libraries</big></font></a></td>
-    <td><a href="../people/people.htm"><font face="Arial" color="#ffffff"><big>
-    People</big></font></a></td>
-    <td>FAQ</td>
-    <td>More</td>
-  </tr>
-</tbody>
-</table>
-
-<h1>What to do about Boost bugs</h1>
-
-<ol>
-
-  <li>Make sure the bug isn't already fixed in the latest sources. The most 
-  recent version of everything on the Boost web site is available from
-  the <a href="http://www.boost.org/more/getting_started.html#CVS">boost public
-  CVS repository</a>.<br>
-<br>
- </li>
-  <li>If you are a Boost user, or a Boost developer that doesn't have a CVS 
-  write access: <br>
-<br>
- <ol>
-    <li>Submit a bug report to either
-    boost-users list,
-    <a href="http://www.boost.org/more/mailing_lists.htm#main">boost mailing 
-    list</a>, or our <a href="http://svn.boost.org/trac/boost/report">bug 
-    tracking facility</a>; submitting it to either of the mailing 
-    lists is a preferred way - because many of the Boost developers read the 
-    lists on a daily basis, this way you are likely to get a quicker response, 
-    and the discussions that often arise there from (possible) bug reports are 
-    quite interesting and educational as well;<br>
-<br>
- </li>
-    <li>If you have a proposed patch to the code, post it along with your bug 
-    report, preferably in the <em>unified diffs</em> format (<code>cvs diff -du</code>);
-     if you can, send a patch relative to the current CVS state. A canonical
-example of creating a patch file follows (let's assume that you've found
-a bug in the file <code>intentional_bug.hpp</code>:<br>
-<br>
-        <ol>
-          <li>Download the latest version of <code>intentional_bug.hpp</code> from CVS.</li>
-          <li>Make sure that the bug is still present in the code.</li>
-          <li>Copy the file <code>intentional_bug.hpp</code> to a file called <code>intentional_bug.hpp.orig</code>.</li>
-          <li>Apply your changes to <code>intentional_bug.hpp</code>.</li>
-          <li>Run "<code>diff -du intentional_bug.hpp.orig intentional_bug.hpp &gt; intentional_bug.hpp.patch</code>" from the command prompt.</li>
-          <li>Submit the patch file together with an explanation of the bug
-and the proposed fix; and don't forget to include the word <b>patch</b> or <b>bug</b>
-in the subject if you're submitting to the boost mailing list.<br>
-            <br>
-</li>
-        </ol>
-
- </li>
-
-  </ol>
-  </li>
-  <li>If you are a Boost developer, and you have a CVS write access: <br>
-<br>
- <ol>
-    <li>If the bug is trivial (e.g. misspelled name, missed <code>typename</code>, 
-    etc.), and you are willing to make a fix, either make your changes locally 
-    and contact the library author(s)/maintainer(s) about it, or go ahead and 
-    check the fix into CVS, but post a notification about it to the
-    <a href="http://www.boost.org/more/mailing_lists.htm#main">boost mailing 
-    list</a> (if the author is not very active on the list, you also might want 
-    to consider <code>cc</code>'ing him as well); <br>
-<br>
- </li>
-    <li>If the bug is non-trivial, and/or you don't have the time and resources to fix it, 
-    submit a bug report (see p. 2 above); chances are that the maintainer(s) 
-    will respond promptly and take care of the problem; <br>
-<br>
- </li>
-    <li>Otherwise, create a temporary branch in CVS, make your changes there, and 
-    ask the library author(s)/maintainer(s) to review them; if they are ok with 
-    the new code, either you or they can integrate the fixes into the main 
-    trunk. </li>
-  </ol>
-  </li>
-</ol>
-
-<hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->18 January, 2002<!--webbot bot="Timestamp" i-checksum="38453" endspan -->
-</p>
-
-<p>© Copyright Aleksey Gurtovoy 
-2002</p>
-<p> Distributed under the Boost Software License, Version 1.0. 
-(See accompanying file LICENSE_1_0.txt or 
-copy at www.boost.org/LICENSE_1_0.txt)
-</p>
-
-<br>
-
-</body></html>
-

Modified: branches/proto/v3/more/formal_review_schedule.html
==============================================================================
--- branches/proto/v3/more/formal_review_schedule.html	(original)
+++ branches/proto/v3/more/formal_review_schedule.html	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -96,7 +96,7 @@
     <td><a href="http://boost-consulting.com/vault/index.php?&amp;direction=0&order=&directory=X-Files">
         Boost Sandbox Vault</a></td>
     <td>John Torjo</td>
-    <td>January 14, 2007 - January 18, 2007</td>
+    <td>January 14, 2008 - January 18, 2008</td>
   </tr>
 
   <tr>
@@ -143,7 +143,32 @@
     <td>-</td>
   </tr>
 
+  <tr>
+    <td>Flyweight</td>
+    <td>Joaqu&iacute;n M&ordf; L&oacute;pez Mu&ntilde;oz</td>
+    <td><a href="http://www.boost-consulting.com/vault/index.php?action=downloadfile&filename=flyweight.zip&directory=Patterns">
+    Boost Sandbox Vault</a></td>
+    <td>Needed</td>
+    <td>-</td>
+  </tr>
 
+  <tr>
+    <td>Unordered Containers</td>
+    <td>Daniel James</td>
+    <td>Boost Sandbox Vault</td>
+    <td>Needed</td>
+    <td>-</td>
+  </tr>
+
+<!--
+  <tr>
+    <td></td>  Library Name
+    <td>John Torjo</td> Library Author
+    <td></td> URL
+    <td></td> Review Manager (or "NEEDED")
+    <td>-</td> Review Dates (or "-")
+  </tr>
+-->
 
 </table>
 
@@ -160,6 +185,14 @@
   </tr>
 
   <tr>
+    <td>Review Wizard Status Report</td>
+    <td></td>
+    <td>Ronald Garcia</td>
+    <td>2007 November 16</td>
+    <td>Report</td>
+  </tr>
+
+  <tr>
     <td>Exception</td>
     <td>Emil Dotchevski</td>
     <td>Tobias Schwinger</td>

Deleted: branches/proto/v3/more/requesting_new_features.htm
==============================================================================
--- branches/proto/v3/more/requesting_new_features.htm	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
+++ (empty file)
@@ -1,56 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Language" content="en-us">
-<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
-<title>Requesting New Features</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<table border="1" bgcolor="#007F7F" cellpadding="2">
-  <tr>
-    <td bgcolor="#FFFFFF">
-    <img src="../boost.png" alt="boost.png (6897 bytes)" width="277" height="86"></td>
-    <td>Home</td>
-    <td><a href="../libs/libraries.htm"><font face="Arial" color="#FFFFFF"><big>
-    Libraries</big></font></a></td>
-    <td><a href="../people/people.htm"><font face="Arial" color="#FFFFFF"><big>
-    People</big></font></a></td>
-    <td>FAQ</td>
-    <td>More</td>
-  </tr>
-</table>
-<h1>Requesting new features for Boost libraries</h1>
-<p>If you have an idea for a feature or improvement to an existing Boost library 
-- go ahead and post it to either
-boost-users list 
-or boost mailing list 
-(if you are posting for the first time, please read our
-discussion policy 
-before you actually post). </p>
-<p>You can also use our <a href="http://sourceforge.net/tracker/?group_id=7586">
-feature request tracking facility</a> at SourceForge, but experience has shown 
-that posting to either of the mailing lists is usually a more effective way to 
-get attention of boost developers. </p>
-<p>If your proposal has its merits, it's very likely that it will generate a 
-constructive discussion that might actually result in (sometimes substantial) 
-improvement of the library - and your name being put on the library's
-<a href="http://www.boost.org/more/lib_guide.htm#Acknowledgements">
-Acknowledgements</a> section! </p>
-<hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->26 November, 2003<!--webbot bot="Timestamp" i-checksum="39365" endspan -->
-</p>
-
-<p>© Copyright Aleksey Gurtovoy 
-2002</p>
-<p> Distributed under the Boost Software License, Version 1.0. 
-(See accompanying file LICENSE_1_0.txt or 
-copy at www.boost.org/LICENSE_1_0.txt)
-</p>
-
-</body>
-
-</html>
\ No newline at end of file

Modified: branches/proto/v3/status/explicit-failures-markup.xml
==============================================================================
--- branches/proto/v3/status/explicit-failures-markup.xml	(original)
+++ branches/proto/v3/status/explicit-failures-markup.xml	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -1296,6 +1296,19 @@
                 More recent version of the library should work OK.
             </note>
         </mark-unusable>
+        <mark-unusable>
+            <toolset name="msvc-8.0~wm5~stlport5.1"/>
+            <note author="Beman Dawes">
+                Due to lack of C library featues, this toolset is not supported.
+            </note>
+        </mark-unusable>
+        <mark-expected-failures>
+          <toolset name="sun-5.7"/>
+          <toolset name="sun-5.8"/>
+          <note author="Beman Dawes">
+              The library works well with versions of this compiler 5.9 and later 
+          </note>
+        </mark-expected-failures>
         <mark-expected-failures>
           <test name="fstream_test"/>
           <toolset name="msvc-6.5*"/>

Modified: branches/proto/v3/tools/build/v2/tools/builtin.jam
==============================================================================
--- branches/proto/v3/tools/build/v2/tools/builtin.jam	(original)
+++ branches/proto/v3/tools/build/v2/tools/builtin.jam	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -1,5 +1,5 @@
 # Copyright 2002, 2003, 2004, 2005 Dave Abrahams 
-# Copyright 2002, 2005, 2006 Rene Rivera 
+# Copyright 2002, 2005, 2006, 2007 Rene Rivera 
 # Copyright 2006 Juergen Hunold 
 # Copyright 2005 Toon Knapen 
 # Copyright 2002, 2003, 2004, 2005, 2006 Vladimir Prus 
@@ -214,6 +214,8 @@
     i386 i486 i586 i686
     pentium pentium-mmx pentiumpro pentium2 pentium3 pentium3m pentium-m pentium4 pentium4m
     prescott nocona
+    conroe conroe-xe conroe-l allendale mermon mermon-xe kentsfield kentsfield-xe
+    penryn wolfdale yorksfield nehalem
     k6 k6-2 k6-3 athlon athlon-tbird athlon-4 athlon-xp athlon-mp
     k8 opteron athlon64 athlon-fx
     winchip-c6 winchip2

Modified: branches/proto/v3/tools/build/v2/tools/msvc.jam
==============================================================================
--- branches/proto/v3/tools/build/v2/tools/msvc.jam	(original)
+++ branches/proto/v3/tools/build/v2/tools/msvc.jam	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -3,6 +3,7 @@
 # Copyright (c) 2005 Alexey Pakhunov.
 # Copyright (c) 2006 Bojan Resnik.
 # Copyright (c) 2006 Ilya Sokolov.
+# Copyright (c) 2007 Rene Rivera
 #
 # Use, modification and distribution is subject to the Boost Software
 # License Version 1.0. (See accompanying file LICENSE_1_0.txt or
@@ -231,6 +232,10 @@
         {
             # Even if version is not explicitly specified, try to detect the version
             # from the path.
+            if [ MATCH "(Microsoft Visual Studio 9)" : $(command) ]
+            {
+                version = 9.0 ;
+            }
             if [ MATCH "(Microsoft Visual Studio 8)" : $(command) ]
             {
                 version = 8.0 ;
@@ -299,8 +304,9 @@
                 if ! $(below-8.0)
                 {
                     cpu = i386 amd64 ia64 ;
-                    # Whereas http://msdn2.microsoft.com/en-us/library/x4d2c09s(VS.80).aspx
-                    # say about x86_ipf, that seem to be doc bug,
+                    # Whereas http://msdn2.microsoft.com/en-us/library/x4d2c09s(VS.80).aspx or
+                    # http://msdn2.microsoft.com/en-us/library/x4d2c09s(vs.90).aspx
+                    # say about x86_IPF, that seem to be doc bug,
                     # and x86_ia64 is right one.
                     setup-option = x86 x86_amd64 x86_ia64 ;
                     
@@ -394,13 +400,16 @@
 }
 
 
-# Supported CPU types
+# Supported CPU types (only Itanium optimization options are supported from
+# VC++ 2005 on). See http://msdn2.microsoft.com/en-us/library/h66s5s0e(vs.90).aspx
 cpu-type-g5 = i586 pentium pentium-mmx ;
 cpu-type-g6 = 
     i686 pentiumpro pentium2 pentium3 pentium3m pentium-m k6 k6-2 k6-3 
     winchip-c6 winchip2 c3 c3-2 ;
 
-cpu-type-em64t = prescott nocona ;
+cpu-type-em64t = prescott nocona   
+    conroe conroe-xe conroe-l allendale mermon mermon-xe kentsfield kentsfield-xe
+    penryn wolfdale yorksfield nehalem ;
 cpu-type-amd64 = k8 opteron athlon64 athlon-fx ;
 
 cpu-type-g7 = 
@@ -465,12 +474,12 @@
     }
     else
     {
-        # 8.0 adds some more options
+        # 8.0 and above adds some more options
         flags $(toolset).compile CFLAGS $(condition)/$(cpu-arch-amd64)/<instruction-set> : /favor:blend ;
         flags $(toolset).compile CFLAGS $(condition)/$(cpu-arch-amd64)/<instruction-set>$(cpu-type-em64t) : /favor:EM64T ;
         flags $(toolset).compile CFLAGS $(condition)/$(cpu-arch-amd64)/<instruction-set>$(cpu-type-amd64) : /favor:AMD64 ;
 
-        # 8.0 only has multi-threaded static RTL
+        # 8.0 and above only has multi-threaded static RTL
         flags $(toolset).compile CFLAGS $(condition)/<runtime-debugging>off/<runtime-link>static/<threading>single : /MT ;
         flags $(toolset).compile CFLAGS $(condition)/<runtime-debugging>on/<runtime-link>static/<threading>single : /MTd ;
     }
@@ -916,13 +925,14 @@
 
 .ProgramFiles = [ path.make [ common.get-program-files-dir ] ] ;
 
-.known-versions = 8.0 8.0express 7.1 7.1toolkit 7.0 6.0 ;
+.known-versions = 9.0 9.0express 8.0 8.0express 7.1 7.1toolkit 7.0 6.0 ;
 
 # Version aliases
 .version-alias-6 = 6.0 ;
 .version-alias-6.5 = 6.0 ;
 .version-alias-7 = 7.0 ;
 .version-alias-8 = 8.0 ;
+.version-alias-9 = 9.0 ;
  
 # Name of the registry key that contains Visual C++ installation path
 #   (relative to "HKEY_LOCAL_MACHINE\SOFTWARE\\Microsoft"
@@ -931,6 +941,8 @@
 .version-7.1-reg = "VisualStudio\\7.1\\Setup\\VC" ;
 .version-8.0-reg = "VisualStudio\\8.0\\Setup\\VC" ;
 .version-8.0express-reg = "VCExpress\\8.0\\Setup\\VC" ;
+.version-9.0-reg = "VisualStudio\\9.0\\Setup\\VC" ;
+.version-9.0express-reg = "VCExpress\\9.0\\Setup\\VC" ;
 
 # Visual C++ Toolkit 2003 do not store its installation path in the registry.
 # The environment variable 'VCToolkitInstallDir' and the default installation 

Modified: branches/proto/v3/tools/build/v2/tools/vacpp.jam
==============================================================================
--- branches/proto/v3/tools/build/v2/tools/vacpp.jam	(original)
+++ branches/proto/v3/tools/build/v2/tools/vacpp.jam	2007-11-16 19:34:37 EST (Fri, 16 Nov 2007)
@@ -18,11 +18,17 @@
 toolset.inherit vacpp : unix ;
 generators.override vacpp.prebuilt : builtin.lib-generator ;
 generators.override vacpp.searched-lib-generator : searched-lib-generator ;
-feature.subfeature toolset vacpp : version ;
 
 # Configure the vacpp toolset
 rule init ( version ? : command * : options * )
 {
+    local condition = [ 
+        common.check-init-parameters vacpp : version $(version) ] ;
+              
+    command = [ common.get-invocation-command vacpp : xlC
+        : $(command) : "/usr/vacpp/bin/xlC" ] ;
+                              
+    common.handle-options vacpp : $(condition) : $(command) : $(options) ;
 }
 
 # Declare generators