Squashed 'boost/' content from commit b4feb19f2

git-subtree-dir: boost
git-subtree-split: b4feb19f287ee92d87a9624b5d36b7cf46aeadeb

libs/math/test/compile_test/compl_abs_incl_test.cpp

@@ -0,0 +1,28 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/complex/fabs.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/complex/fabs.hpp>
+
+inline void check_result_imp(std::complex<float>, std::complex<float>){}
+inline void check_result_imp(std::complex<double>, std::complex<double>){}
+inline void check_result_imp(std::complex<long double>, std::complex<long double>){}
+
+#include "test_compile_result.hpp"
+
+
+
+void compile_and_link_test()
+{
+   check_result<float >(boost::math::fabs(std::complex<float>()));
+   check_result<double >(boost::math::fabs(std::complex<double>()));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::fabs(std::complex<long double>()));
+#endif
+}
+
+

libs/math/test/compile_test/compl_acos_incl_test.cpp

@@ -0,0 +1,28 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/complex/acos.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/complex/acos.hpp>
+
+inline void check_result_imp(std::complex<float>, std::complex<float>){}
+inline void check_result_imp(std::complex<double>, std::complex<double>){}
+inline void check_result_imp(std::complex<long double>, std::complex<long double>){}
+
+#include "test_compile_result.hpp"
+
+
+
+void compile_and_link_test()
+{
+   check_result<std::complex<float> >(boost::math::acos(std::complex<float>()));
+   check_result<std::complex<double> >(boost::math::acos(std::complex<double>()));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<std::complex<long double> >(boost::math::acos(std::complex<long double>()));
+#endif
+}
+
+

libs/math/test/compile_test/compl_acosh_incl_test.cpp

@@ -0,0 +1,28 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/complex/acosh.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/complex/acosh.hpp>
+
+inline void check_result_imp(std::complex<float>, std::complex<float>){}
+inline void check_result_imp(std::complex<double>, std::complex<double>){}
+inline void check_result_imp(std::complex<long double>, std::complex<long double>){}
+
+#include "test_compile_result.hpp"
+
+
+
+void compile_and_link_test()
+{
+   check_result<std::complex<float> >(boost::math::acosh(std::complex<float>()));
+   check_result<std::complex<double> >(boost::math::acosh(std::complex<double>()));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<std::complex<long double> >(boost::math::acosh(std::complex<long double>()));
+#endif
+}
+
+

libs/math/test/compile_test/compl_asin_incl_test.cpp

@@ -0,0 +1,28 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/complex/asin.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/complex/asin.hpp>
+
+inline void check_result_imp(std::complex<float>, std::complex<float>){}
+inline void check_result_imp(std::complex<double>, std::complex<double>){}
+inline void check_result_imp(std::complex<long double>, std::complex<long double>){}
+
+#include "test_compile_result.hpp"
+
+
+
+void compile_and_link_test()
+{
+   check_result<std::complex<float> >(boost::math::asin(std::complex<float>()));
+   check_result<std::complex<double> >(boost::math::asin(std::complex<double>()));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<std::complex<long double> >(boost::math::asin(std::complex<long double>()));
+#endif
+}
+
+

libs/math/test/compile_test/compl_asinh_incl_test.cpp

@@ -0,0 +1,28 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/complex/asinh.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/complex/asinh.hpp>
+
+inline void check_result_imp(std::complex<float>, std::complex<float>){}
+inline void check_result_imp(std::complex<double>, std::complex<double>){}
+inline void check_result_imp(std::complex<long double>, std::complex<long double>){}
+
+#include "test_compile_result.hpp"
+
+
+
+void compile_and_link_test()
+{
+   check_result<std::complex<float> >(boost::math::asinh(std::complex<float>()));
+   check_result<std::complex<double> >(boost::math::asinh(std::complex<double>()));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<std::complex<long double> >(boost::math::asinh(std::complex<long double>()));
+#endif
+}
+
+

libs/math/test/compile_test/compl_atan_incl_test.cpp

@@ -0,0 +1,28 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/complex/atan.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/complex/atan.hpp>
+
+inline void check_result_imp(std::complex<float>, std::complex<float>){}
+inline void check_result_imp(std::complex<double>, std::complex<double>){}
+inline void check_result_imp(std::complex<long double>, std::complex<long double>){}
+
+#include "test_compile_result.hpp"
+
+
+
+void compile_and_link_test()
+{
+   check_result<std::complex<float> >(boost::math::atan(std::complex<float>()));
+   check_result<std::complex<double> >(boost::math::atan(std::complex<double>()));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<std::complex<long double> >(boost::math::atan(std::complex<long double>()));
+#endif
+}
+
+

libs/math/test/compile_test/compl_atanh_incl_test.cpp

@@ -0,0 +1,28 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/complex/atanh.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/complex/atanh.hpp>
+
+inline void check_result_imp(std::complex<float>, std::complex<float>){}
+inline void check_result_imp(std::complex<double>, std::complex<double>){}
+inline void check_result_imp(std::complex<long double>, std::complex<long double>){}
+
+#include "test_compile_result.hpp"
+
+
+
+void compile_and_link_test()
+{
+   check_result<std::complex<float> >(boost::math::atanh(std::complex<float>()));
+   check_result<std::complex<double> >(boost::math::atanh(std::complex<double>()));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<std::complex<long double> >(boost::math::atanh(std::complex<long double>()));
+#endif
+}
+
+

libs/math/test/compile_test/constants_incl_test.cpp

@@ -0,0 +1,24 @@
+//  Copyright John Maddock 2012.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/bessel.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/constants/constants.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::constants::pi<float>());
+   check_result<double>(boost::math::constants::pi<double>());
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::constants::pi<long double>());
+#endif
+
+}

libs/math/test/compile_test/cstdfloat_concept_check_1.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2014.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_MATH_ASSERT_UNDEFINED_POLICY false
+
+#include <boost/cstdfloat.hpp>
+#include "poison.hpp"
+#include <boost/math/concepts/distributions.hpp>
+
+#include "instantiate.hpp"
+
+int main(int
+#ifdef BOOST_FLOAT128_C
+   argc
+#endif
+   , char*[])
+{
+#ifdef BOOST_FLOAT128_C
+   if(argc > 1000)
+      instantiate(BOOST_FLOAT128_C(1.23));
+#endif
+}
+

libs/math/test/compile_test/cstdfloat_concept_check_2.cpp

@@ -0,0 +1,26 @@
+//  Copyright John Maddock 2014.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_MATH_ASSERT_UNDEFINED_POLICY false
+
+#include <boost/cstdfloat.hpp>
+#include "poison.hpp"
+#include <boost/math/concepts/distributions.hpp>
+
+#include "instantiate.hpp"
+
+
+int main(int 
+#ifdef BOOST_FLOAT80_C
+      argc
+#endif
+   , char*[])
+{
+#ifdef BOOST_FLOAT80_C
+   if(argc > 1000)
+      instantiate(BOOST_FLOAT80_C(1.23));
+#endif
+}
+

libs/math/test/compile_test/cstdfloat_concept_check_3.cpp

@@ -0,0 +1,26 @@
+//  Copyright John Maddock 2014.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_MATH_ASSERT_UNDEFINED_POLICY false
+
+#include <boost/cstdfloat.hpp>
+#include "poison.hpp"
+#include <boost/math/concepts/distributions.hpp>
+
+#include "instantiate.hpp"
+
+
+int main(int
+#ifdef BOOST_FLOAT64_C
+   argc
+#endif
+  , char*[])
+{
+#ifdef BOOST_FLOAT64_C
+   if(argc > 1000)
+      instantiate(BOOST_FLOAT64_C(1.23));
+#endif
+}
+

libs/math/test/compile_test/cstdfloat_concept_check_4.cpp

@@ -0,0 +1,26 @@
+//  Copyright John Maddock 2014.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_MATH_ASSERT_UNDEFINED_POLICY false
+
+#include <boost/cstdfloat.hpp>
+#include "poison.hpp"
+#include <boost/math/concepts/distributions.hpp>
+
+#include "instantiate.hpp"
+
+
+int main(int 
+#ifdef BOOST_FLOAT32_C
+   argc
+#endif
+   , char*[])
+{
+#ifdef BOOST_FLOAT32_C
+   if(argc > 1000)
+      instantiate(BOOST_FLOAT32_C(1.23));
+#endif
+}
+

libs/math/test/compile_test/dist_bernoulli_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/bernoulli.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/bernoulli.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(bernoulli)
+}
+
+template class boost::math::bernoulli_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::bernoulli_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::bernoulli_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_beta_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/beta.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/beta.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(beta)
+}
+
+template class boost::math::beta_distribution<double, boost::math::policies::policy<> >;
+template class boost::math::beta_distribution<float, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::beta_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_binomial_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/binomial.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/binomial.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(binomial)
+}
+
+template class boost::math::binomial_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::binomial_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::binomial_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_cauchy_incl_test.cpp

@@ -0,0 +1,26 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/cauchy.hpp>
+// #includes all the files that it needs to.
+//
+#define BOOST_MATH_ASSERT_UNDEFINED_POLICY false
+#include <boost/math/distributions/cauchy.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(cauchy)
+}
+
+template class boost::math::cauchy_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::cauchy_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::cauchy_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_chi_squared_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/chi_squared.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/chi_squared.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(chi_squared)
+}
+
+template class boost::math::chi_squared_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::chi_squared_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::chi_squared_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_complement_incl_test.cpp

@@ -0,0 +1,22 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/complement.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/complement.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   boost::math::complement(f, f);
+   boost::math::complement(f, f, d);
+   boost::math::complement(f, f, d, l);
+   boost::math::complement(f, f, d, l, i);
+}

libs/math/test/compile_test/dist_exponential_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/exponential.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/exponential.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(exponential)
+}
+
+template class boost::math::exponential_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::exponential_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::exponential_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_extreme_val_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/extreme_value.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/extreme_value.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(extreme_value)
+}
+
+template class boost::math::extreme_value_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::extreme_value_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::extreme_value_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_find_location_incl_test.cpp

@@ -0,0 +1,61 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/find_location.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/find_location.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+template <class T, class Policy = boost::math::policies::policy<> >
+class test_distribution
+{
+public:
+   typedef T value_type;
+   typedef Policy policy_type;
+   test_distribution(){}
+};
+
+template <class T, class Policy>
+T quantile(const test_distribution<T, Policy>&, T)
+{
+   return 0;
+}
+
+template <class T, class Policy>
+T quantile(const boost::math::complemented2_type<test_distribution<T, Policy>, T>&)
+{
+   return 0;
+}
+
+namespace boost{ namespace math{ namespace tools{
+
+   template <class T, class Policy> struct is_distribution<test_distribution<T, Policy> > : public mpl::true_{};
+   template <class T, class Policy> struct is_scaled_distribution<test_distribution<T, Policy> > : public mpl::true_{};
+
+}}}
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::find_location<test_distribution<float> >(f, f, f, boost::math::policies::policy<>()));
+   check_result<double>(boost::math::find_location<test_distribution<double> >(d, d, d, boost::math::policies::policy<>()));
+   check_result<long double>(boost::math::find_location<test_distribution<long double> >(l, l, l, boost::math::policies::policy<>()));
+
+   check_result<float>(boost::math::find_location<test_distribution<float> >(f, f, f));
+   check_result<double>(boost::math::find_location<test_distribution<double> >(d, d, d));
+   check_result<long double>(boost::math::find_location<test_distribution<long double> >(l, l, l));
+
+   check_result<float>(boost::math::find_location<test_distribution<float> >(boost::math::complement(f, f, f, boost::math::policies::policy<>())));
+   check_result<double>(boost::math::find_location<test_distribution<double> >(boost::math::complement(d, d, d, boost::math::policies::policy<>())));
+   check_result<long double>(boost::math::find_location<test_distribution<long double> >(boost::math::complement(l, l, l, boost::math::policies::policy<>())));
+
+   check_result<float>(boost::math::find_location<test_distribution<float> >(boost::math::complement(f, f, f)));
+   check_result<double>(boost::math::find_location<test_distribution<double> >(boost::math::complement(d, d, d)));
+   check_result<long double>(boost::math::find_location<test_distribution<long double> >(boost::math::complement(l, l, l)));
+}

libs/math/test/compile_test/dist_find_scale_incl_test.cpp

@@ -0,0 +1,62 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/find_scale.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/find_scale.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+template <class T, class Policy = boost::math::policies::policy<> >
+class test_distribution
+{
+public:
+   typedef T value_type;
+   typedef Policy policy_type;
+   test_distribution(){}
+};
+
+template <class T, class Policy>
+T quantile(const test_distribution<T, Policy>&, T)
+{
+   return 0;
+}
+
+template <class T, class Policy>
+T quantile(const boost::math::complemented2_type<test_distribution<T, Policy>, T>&)
+{
+   return 0;
+}
+
+namespace boost{ namespace math{ namespace tools{
+
+   template <class T, class Policy> struct is_distribution<test_distribution<T, Policy> > : public mpl::true_{};
+   template <class T, class Policy> struct is_scaled_distribution<test_distribution<T, Policy> > : public mpl::true_{};
+
+}}}
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::find_scale<test_distribution<float> >(f, f, f, boost::math::policies::policy<>()));
+   check_result<double>(boost::math::find_scale<test_distribution<double> >(d, d, d, boost::math::policies::policy<>()));
+   check_result<long double>(boost::math::find_scale<test_distribution<long double> >(l, l, l, boost::math::policies::policy<>()));
+
+   check_result<float>(boost::math::find_scale<test_distribution<float> >(f, f, f));
+   check_result<double>(boost::math::find_scale<test_distribution<double> >(d, d, d));
+   check_result<long double>(boost::math::find_scale<test_distribution<long double> >(l, l, l));
+
+   check_result<float>(boost::math::find_scale<test_distribution<float> >(boost::math::complement(f, f, f, boost::math::policies::policy<>())));
+   check_result<double>(boost::math::find_scale<test_distribution<double> >(boost::math::complement(d, d, d, boost::math::policies::policy<>())));
+   check_result<long double>(boost::math::find_scale<test_distribution<long double> >(boost::math::complement(l, l, l, boost::math::policies::policy<>())));
+
+   check_result<float>(boost::math::find_scale<test_distribution<float> >(boost::math::complement(f, f, f)));
+   check_result<double>(boost::math::find_scale<test_distribution<double> >(boost::math::complement(d, d, d)));
+   check_result<long double>(boost::math::find_scale<test_distribution<long double> >(boost::math::complement(l, l, l)));
+}
+

libs/math/test/compile_test/dist_fisher_f_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/fisher_f.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/fisher_f.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(fisher_f)
+}
+
+template class boost::math::fisher_f_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::fisher_f_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::fisher_f_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_gamma_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/gamma.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/gamma.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(gamma)
+}
+
+template class boost::math::gamma_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::gamma_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::gamma_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_hyperexponential_incl_test.cpp

@@ -0,0 +1,26 @@
+//  Copyright 2014 Marco Guazzone (marco.guazzone@gmail.com)
+//
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/hyperexponential.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/hyperexponential.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(hyperexponential)
+}
+
+template class boost::math::hyperexponential_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::hyperexponential_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::hyperexponential_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_hypergeo_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2008.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/hypergeometric.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/hypergeometric.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(hypergeometric)
+}
+
+template class boost::math::hypergeometric_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::hypergeometric_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::hypergeometric_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_inv_chi_sq_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/gamma.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/inverse_chi_squared.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(inverse_chi_squared)
+}
+
+template class boost::math::inverse_chi_squared_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::inverse_chi_squared_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::inverse_chi_squared_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_inv_gamma_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/gamma.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/inverse_gamma.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(inverse_gamma)
+}
+
+template class boost::math::inverse_gamma_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::inverse_gamma_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::inverse_gamma_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_laplace_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2008.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/laplace.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/laplace.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(laplace)
+}
+
+template class boost::math::laplace_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::laplace_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::laplace_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_logistic_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2008.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/logistic.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/logistic.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(logistic)
+}
+
+template class boost::math::logistic_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::logistic_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::logistic_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_lognormal_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/lognormal.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/lognormal.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(lognormal)
+}
+
+template class boost::math::lognormal_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::lognormal_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::lognormal_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_nc_beta_incl_test.cpp

@@ -0,0 +1,29 @@
+//  Copyright John Maddock 2008.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/non_central_beta.hpp>
+// #includes all the files that it needs to.
+//
+// This must appear *before* any #includes, and precludes pch usage:
+//
+#define BOOST_MATH_ASSERT_UNDEFINED_POLICY false
+//
+#include <boost/math/distributions/non_central_beta.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(non_central_beta)
+}
+
+template class boost::math::non_central_beta_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::non_central_beta_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::non_central_beta_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_nc_chi_squ_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2008.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/non_central_chi_squared.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/non_central_chi_squared.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(non_central_chi_squared)
+}
+
+template class boost::math::non_central_chi_squared_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::non_central_chi_squared_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::non_central_chi_squared_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_nc_f_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2008.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/non_central_f.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/non_central_f.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(non_central_f)
+}
+
+template class boost::math::non_central_f_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::non_central_f_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::non_central_f_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_nc_t_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2008.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/non_central_t.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/non_central_t.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(non_central_t)
+}
+
+template class boost::math::non_central_t_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::non_central_t_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::non_central_t_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_neg_binom_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/negative_binomial.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/negative_binomial.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(negative_binomial)
+}
+
+template class boost::math::negative_binomial_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::negative_binomial_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::negative_binomial_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_normal_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/normal.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/normal.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(normal)
+}
+
+template class boost::math::normal_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::normal_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::normal_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_pareto_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/pareto.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/pareto.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(pareto)
+}
+
+template class boost::math::pareto_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::pareto_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::pareto_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_poisson_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/poisson.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/poisson.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(poisson)
+}
+
+template class boost::math::poisson_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::poisson_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::poisson_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_skew_norm_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/students_t.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/skew_normal.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(skew_normal)
+}
+
+template class boost::math::skew_normal_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::skew_normal_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::skew_normal_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_students_t_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/students_t.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/students_t.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(students_t)
+}
+
+template class boost::math::students_t_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::students_t_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::students_t_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_triangular_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/triangular.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/triangular.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(triangular)
+}
+
+template class boost::math::triangular_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::triangular_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::triangular_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_uniform_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/uniform.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/uniform.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(uniform)
+}
+
+template class boost::math::uniform_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::uniform_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::uniform_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/dist_weibull_incl_test.cpp

@@ -0,0 +1,25 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/weibull.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/weibull.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   TEST_DIST_FUNC(weibull)
+}
+
+template class boost::math::weibull_distribution<float, boost::math::policies::policy<> >;
+template class boost::math::weibull_distribution<double, boost::math::policies::policy<> >;
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+template class boost::math::weibull_distribution<long double, boost::math::policies::policy<> >;
+#endif

libs/math/test/compile_test/distribution_concept_check.cpp

@@ -0,0 +1,64 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_MATH_ASSERT_UNDEFINED_POLICY false
+
+#include <boost/math/distributions.hpp>
+#include <boost/math/concepts/distributions.hpp>
+
+
+template <class RealType>
+void instantiate(RealType)
+{
+   using namespace boost;
+   using namespace boost::math;
+   using namespace boost::math::concepts;
+
+   typedef policies::policy<policies::digits2<std::numeric_limits<RealType>::digits - 2> > custom_policy;
+
+   function_requires<DistributionConcept<bernoulli_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<beta_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<binomial_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<cauchy_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<chi_squared_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<exponential_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<extreme_value_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<fisher_f_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<gamma_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<geometric_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<hypergeometric_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<hypergeometric_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<inverse_chi_squared_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<inverse_gamma_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<inverse_gaussian_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<laplace_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<logistic_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<lognormal_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<negative_binomial_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<non_central_beta_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<non_central_chi_squared_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<non_central_f_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<non_central_t_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<normal_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<pareto_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<poisson_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<rayleigh_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<skew_normal_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<students_t_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<triangular_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<uniform_distribution<RealType, custom_policy> > >();
+   function_requires<DistributionConcept<weibull_distribution<RealType, custom_policy> > >();
+}
+
+
+int main()
+{
+   instantiate(float(0));
+   instantiate(double(0));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   instantiate((long double)(0));
+#endif
+}
+

libs/math/test/compile_test/generate.sh

@@ -0,0 +1,46 @@
+for file in ../../../../boost/math/tools/*.hpp; do 
+cat > tools_$(basename $file .hpp)_inc_test.cpp  << EOF; 
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/tools/$(basename $file)>
+// #includes all the files that it needs to.
+//
+#include <boost/math/tools/$(basename $file .hpp).hpp>
+
+EOF
+done
+
+for file in ../../../../boost/math/distributions/*.hpp; do 
+cat > dist_$(basename $file .hpp)_incl_test.cpp  << EOF; 
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/distributions/$(basename $file)>
+// #includes all the files that it needs to.
+//
+#include <boost/math/distributions/$(basename $file .hpp).hpp>
+
+EOF
+done
+
+for file in ../../../../boost/math/special_functions/*.hpp; do 
+cat > sf_$(basename $file .hpp)_incl_test.cpp  << EOF; 
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/$(basename $file)>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/$(basename $file .hpp).hpp>
+
+EOF
+done
+
+

libs/math/test/compile_test/main.cpp

@@ -0,0 +1,13 @@
+//  Copyright John Maddock 2009.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+extern void compile_and_link_test();
+
+int main(int argc, char* /*argv*/ [])
+{
+   if(argc > 1000)
+      compile_and_link_test(); // should never actually be called.
+   return 0;
+}

libs/math/test/compile_test/poison.hpp

@@ -0,0 +1,96 @@
+//  Copyright John Maddock 2013.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MATH_COMPILE_POISON_HPP
+#define BOOST_MATH_COMPILE_POISON_HPP
+
+#include <cmath>
+#include <math.h>
+//
+// We have to include this *before* poisoning the macros
+// as it needs to be able to use them!
+//
+#include <boost/math/special_functions/fpclassify.hpp>
+
+//
+// Poison all the function-like macros in C99 so if we accidentally call them
+// in an unsafe manner, we'll get compiler errors.  Of course these shouldn't be
+// macros in C++ at all...
+//
+
+#ifdef fpclassify
+#undef fpclassify
+#endif
+
+#define fpclassify(x) this_should_not_compile(x)}}}}}}}}}}}}}}}}}}}
+
+#ifdef isfinite
+#undef isfinite
+#endif
+
+#define isfinite(x) this_should_not_compile(x)}}}}}}}}}}}}}}}}}}}
+
+#ifdef isinf
+#undef isinf
+#endif
+
+#define isinf(x) this_should_not_compile(x)}}}}}}}}}}}}}}}}}}}
+
+#ifdef isnan
+#undef isnan
+#endif
+
+#define isnan(x) this_should_not_compile(x)}}}}}}}}}}}}}}}}}}}
+
+#ifdef isnormal
+#undef isnormal
+#endif
+
+#define isnormal(x) this_should_not_compile(x)}}}}}}}}}}}}}}}}}}}
+
+#ifdef signbit
+#undef signbit
+#endif
+
+#define signbit(x) this_should_not_compile(x)}}}}}}}}}}}}}}}}}}}
+
+#ifdef isgreater
+#undef isgreater
+#endif
+
+#define isgreater(x) this_should_not_compile(x)}}}}}}}}}}}}}}}}}}}
+
+#ifdef isgreaterequal
+#undef isgreaterequal
+#endif
+
+#define isgreaterequal(x) this_should_not_compile(x)}}}}}}}}}}}}}}}}}}}
+
+#ifdef isless
+#undef isless
+#endif
+
+#define isless(x) this_should_not_compile(x)}}}}}}}}}}}}}}}}}}}
+
+#ifdef islessequal
+#undef islessequal
+#endif
+
+#define islessequal(x) this_should_not_compile(x)}}}}}}}}}}}}}}}}}}}
+
+#ifdef islessgreater
+#undef islessgreater
+#endif
+
+#define islessgreater(x) this_should_not_compile(x)}}}}}}}}}}}}}}}}}}}
+
+#ifdef isunordered
+#undef isunordered
+#endif
+
+#define isunordered(x) this_should_not_compile(x)}}}}}}}}}}}}}}}}}}}
+
+#endif
+

libs/math/test/compile_test/sf_airy_incl_test.cpp

@@ -0,0 +1,42 @@
+//  Copyright John Maddock 2012.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/bessel.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/airy.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::airy_ai<float>(f));
+   check_result<double>(boost::math::airy_ai<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::airy_ai<long double>(l));
+#endif
+
+   check_result<float>(boost::math::airy_bi<float>(f));
+   check_result<double>(boost::math::airy_bi<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::airy_bi<long double>(l));
+#endif
+
+   check_result<float>(boost::math::airy_ai_prime<float>(f));
+   check_result<double>(boost::math::airy_ai_prime<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::airy_ai_prime<long double>(l));
+#endif
+
+   check_result<float>(boost::math::airy_bi_prime<float>(f));
+   check_result<double>(boost::math::airy_bi_prime<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::airy_bi_prime<long double>(l));
+#endif
+
+}

libs/math/test/compile_test/sf_bernoulli_incl_test.cpp

@@ -0,0 +1,29 @@
+//  Copyright John Maddock 2012.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/bernoulli.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/bernoulli.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::bernoulli_b2n<float>(i));
+   check_result<double>(boost::math::bernoulli_b2n<double>(i));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::bernoulli_b2n<long double>(i));
+#endif
+
+   check_result<float>(boost::math::tangent_t2n<float>(i));
+   check_result<double>(boost::math::tangent_t2n<double>(i));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::tangent_t2n<long double>(i));
+#endif
+}

libs/math/test/compile_test/sf_bessel_deriv_incl_test.cpp

@@ -0,0 +1,53 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/bessel.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/bessel_prime.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::cyl_bessel_j_prime<float>(f, f));
+   check_result<double>(boost::math::cyl_bessel_j_prime<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::cyl_bessel_j_prime<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::cyl_neumann_prime<float>(f, f));
+   check_result<double>(boost::math::cyl_neumann_prime<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::cyl_neumann_prime<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::cyl_bessel_i_prime<float>(f, f));
+   check_result<double>(boost::math::cyl_bessel_i_prime<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::cyl_bessel_i_prime<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::cyl_bessel_k_prime<float>(f, f));
+   check_result<double>(boost::math::cyl_bessel_k_prime<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::cyl_bessel_k_prime<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::sph_bessel_prime<float>(u, f));
+   check_result<double>(boost::math::sph_bessel_prime<double>(u, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::sph_bessel_prime<long double>(u, l));
+#endif
+
+   check_result<float>(boost::math::sph_neumann_prime<float>(u, f));
+   check_result<double>(boost::math::sph_neumann_prime<double>(u, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::sph_neumann_prime<long double>(u, l));
+#endif
+}

libs/math/test/compile_test/sf_bessel_incl_test.cpp

@@ -0,0 +1,53 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/bessel.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/bessel.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::cyl_bessel_j<float>(f, f));
+   check_result<double>(boost::math::cyl_bessel_j<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::cyl_bessel_j<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::cyl_neumann<float>(f, f));
+   check_result<double>(boost::math::cyl_neumann<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::cyl_neumann<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::cyl_bessel_i<float>(f, f));
+   check_result<double>(boost::math::cyl_bessel_i<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::cyl_bessel_i<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::cyl_bessel_k<float>(f, f));
+   check_result<double>(boost::math::cyl_bessel_k<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::cyl_bessel_k<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::sph_bessel<float>(u, f));
+   check_result<double>(boost::math::sph_bessel<double>(u, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::sph_bessel<long double>(u, l));
+#endif
+
+   check_result<float>(boost::math::sph_neumann<float>(u, f));
+   check_result<double>(boost::math::sph_neumann<double>(u, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::sph_neumann<long double>(u, l));
+#endif
+}

libs/math/test/compile_test/sf_beta_incl_test.cpp

@@ -0,0 +1,42 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/beta.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/beta.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::beta<float, float>(f, f));
+   check_result<double>(boost::math::beta<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::beta<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::ibeta<float>(f, f, f));
+   check_result<double>(boost::math::ibeta<double>(d, d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ibeta<long double>(l, l, l));
+#endif
+
+   check_result<float>(boost::math::ibeta_inv<float>(f, f, f));
+   check_result<double>(boost::math::ibeta_inv<double>(d, d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ibeta_inv<long double>(l, l, l));
+#endif
+
+   check_result<float>(boost::math::ibeta_inva<float>(f, f, f));
+   check_result<double>(boost::math::ibeta_inva<double>(d, d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ibeta_inva<long double>(l, l, l));
+#endif
+}
+

libs/math/test/compile_test/sf_binomial_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/binomial.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/binomial.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::binomial_coefficient<float>(u, u));
+   check_result<double>(boost::math::binomial_coefficient<double>(u, u));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::binomial_coefficient<long double>(u, u));
+#endif
+}

libs/math/test/compile_test/sf_cbrt_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/cbrt.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/cbrt.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::cbrt<float>(f));
+   check_result<double>(boost::math::cbrt<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::cbrt<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_cos_pi_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/cos_pi.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/cos_pi.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::cos_pi<float>(f));
+   check_result<double>(boost::math::cos_pi<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::cos_pi<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_digamma_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/digamma.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/digamma.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::digamma<float>(f));
+   check_result<double>(boost::math::digamma<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::digamma<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_ellint_1_incl_test.cpp

@@ -0,0 +1,29 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/ellint_1.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/ellint_1.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::ellint_1<float>(f, f));
+   check_result<double>(boost::math::ellint_1<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ellint_1<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::ellint_1<float>(f));
+   check_result<double>(boost::math::ellint_1<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ellint_1<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_ellint_2_incl_test.cpp

@@ -0,0 +1,29 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/ellint_2.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/ellint_2.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::ellint_2<float>(f, f));
+   check_result<double>(boost::math::ellint_2<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ellint_2<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::ellint_2<float>(f));
+   check_result<double>(boost::math::ellint_2<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ellint_2<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_ellint_3_incl_test.cpp

@@ -0,0 +1,29 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/ellint_3.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/ellint_3.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::ellint_3<float>(f, f));
+   check_result<double>(boost::math::ellint_3<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ellint_3<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::ellint_3<float>(f, f, f));
+   check_result<double>(boost::math::ellint_3<double>(d, d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ellint_3<long double>(l, l, l));
+#endif
+}

libs/math/test/compile_test/sf_ellint_d_incl_test.cpp

@@ -0,0 +1,29 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/ellint_d.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/ellint_d.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::ellint_d<float>(f, f));
+   check_result<double>(boost::math::ellint_d<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ellint_d<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::ellint_d<float>(f));
+   check_result<double>(boost::math::ellint_d<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ellint_d<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_ellint_rc_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/ellint_rc.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/ellint_rc.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::ellint_rc<float>(f, f));
+   check_result<double>(boost::math::ellint_rc<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ellint_rc<long double>(l, l));
+#endif
+}

libs/math/test/compile_test/sf_ellint_rd_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/ellint_rd.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/ellint_rd.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::ellint_rd<float>(f, f, f));
+   check_result<double>(boost::math::ellint_rd<double>(d, d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ellint_rd<long double>(l, l, l));
+#endif
+}

libs/math/test/compile_test/sf_ellint_rf_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/ellint_rf.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/ellint_rf.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::ellint_rf<float>(f, f, f));
+   check_result<double>(boost::math::ellint_rf<double>(d, d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ellint_rf<long double>(l, l, l));
+#endif
+}

libs/math/test/compile_test/sf_ellint_rg_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/ellint_rf.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/ellint_rg.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::ellint_rg<float>(f, f, f));
+   check_result<double>(boost::math::ellint_rg<double>(d, d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ellint_rg<long double>(l, l, l));
+#endif
+}

libs/math/test/compile_test/sf_ellint_rj_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/ellint_rj.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/ellint_rj.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::ellint_rj<float>(f, f, f, f));
+   check_result<double>(boost::math::ellint_rj<double>(d, d, d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ellint_rj<long double>(l, l, l, l));
+#endif
+}

libs/math/test/compile_test/sf_erf_incl_test.cpp

@@ -0,0 +1,41 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/erf.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/erf.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::erf<float>(f));
+   check_result<double>(boost::math::erf<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::erf<long double>(l));
+#endif
+
+   check_result<float>(boost::math::erfc<float>(f));
+   check_result<double>(boost::math::erfc<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::erfc<long double>(l));
+#endif
+
+   check_result<float>(boost::math::erf_inv<float>(f));
+   check_result<double>(boost::math::erf_inv<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::erf_inv<long double>(l));
+#endif
+
+   check_result<float>(boost::math::erfc_inv<float>(f));
+   check_result<double>(boost::math::erfc_inv<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::erfc_inv<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_expint_incl_test.cpp

@@ -0,0 +1,28 @@
+//  Copyright John Maddock 2007.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/expint.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/expint.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::expint(f));
+   check_result<double>(boost::math::expint(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::expint(l));
+#endif
+   check_result<float>(boost::math::expint(u, f));
+   check_result<double>(boost::math::expint(u, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::expint(u, l));
+#endif
+}

libs/math/test/compile_test/sf_expm1_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/expm1.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/expm1.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::expm1<float>(f));
+   check_result<double>(boost::math::expm1<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::expm1<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_factorials_incl_test.cpp

@@ -0,0 +1,42 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/factorials.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/factorials.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::factorial<float>(u));
+   check_result<double>(boost::math::factorial<double>(u));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::factorial<long double>(u));
+#endif
+
+   check_result<float>(boost::math::double_factorial<float>(u));
+   check_result<double>(boost::math::double_factorial<double>(u));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::double_factorial<long double>(u));
+#endif
+
+   check_result<float>(boost::math::rising_factorial<float>(f, i));
+   check_result<double>(boost::math::rising_factorial<double>(d, i));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::rising_factorial<long double>(l, i));
+#endif
+
+   check_result<float>(boost::math::falling_factorial<float>(f, u));
+   check_result<double>(boost::math::falling_factorial<double>(d, u));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::falling_factorial<long double>(l, u));
+#endif
+}
+

libs/math/test/compile_test/sf_fpclassify_incl_test.cpp

@@ -0,0 +1,43 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/fpclassify.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/fpclassify.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<int>(boost::math::fpclassify BOOST_NO_MACRO_EXPAND<float>(f));
+   check_result<int>(boost::math::fpclassify BOOST_NO_MACRO_EXPAND<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<int>(boost::math::fpclassify BOOST_NO_MACRO_EXPAND<long double>(l));
+#endif
+
+   check_result<bool>(boost::math::isfinite BOOST_NO_MACRO_EXPAND<float>(f));
+   check_result<bool>(boost::math::isfinite BOOST_NO_MACRO_EXPAND<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<bool>(boost::math::isfinite BOOST_NO_MACRO_EXPAND<long double>(l));
+#endif
+
+   check_result<bool>(boost::math::isinf BOOST_NO_MACRO_EXPAND<float>(f));
+   check_result<bool>(boost::math::isinf BOOST_NO_MACRO_EXPAND<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<bool>(boost::math::isinf BOOST_NO_MACRO_EXPAND<long double>(l));
+#endif
+
+   check_result<bool>(boost::math::isnormal BOOST_NO_MACRO_EXPAND<float>(f));
+   check_result<bool>(boost::math::isnormal BOOST_NO_MACRO_EXPAND<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<bool>(boost::math::isnormal BOOST_NO_MACRO_EXPAND<long double>(l));
+#endif
+}
+
+

libs/math/test/compile_test/sf_gamma_incl_test.cpp

@@ -0,0 +1,83 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/gamma.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/gamma.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::tgamma<float>(f));
+   check_result<double>(boost::math::tgamma<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::tgamma<long double>(l));
+#endif
+
+   check_result<float>(boost::math::lgamma<float>(f));
+   check_result<double>(boost::math::lgamma<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::lgamma<long double>(l));
+#endif
+
+   check_result<float>(boost::math::gamma_p<float>(f, f));
+   check_result<double>(boost::math::gamma_p<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::gamma_p<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::gamma_q<float>(f, f));
+   check_result<double>(boost::math::gamma_q<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::gamma_q<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::gamma_p_inv<float>(f, f));
+   check_result<double>(boost::math::gamma_p_inv<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::gamma_p_inv<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::gamma_q_inv<float>(f, f));
+   check_result<double>(boost::math::gamma_q_inv<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::gamma_q_inv<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::gamma_p_inva<float>(f, f));
+   check_result<double>(boost::math::gamma_p_inva<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::gamma_p_inva<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::gamma_q_inva<float>(f, f));
+   check_result<double>(boost::math::gamma_q_inva<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::gamma_q_inva<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::gamma_p_derivative<float>(f, f));
+   check_result<double>(boost::math::gamma_p_derivative<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::gamma_p_derivative<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::tgamma_ratio<float>(f, f));
+   check_result<double>(boost::math::tgamma_ratio<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::tgamma_ratio<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::tgamma_delta_ratio<float>(f, f));
+   check_result<double>(boost::math::tgamma_delta_ratio<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::tgamma_delta_ratio<long double>(l, l));
+#endif
+}

libs/math/test/compile_test/sf_hankel_incl_test.cpp

@@ -0,0 +1,46 @@
+//  Copyright John Maddock 2012.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/bessel.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/hankel.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+inline void check_result_imp(std::complex<float>, std::complex<float>){}
+inline void check_result_imp(std::complex<double>, std::complex<double>){}
+inline void check_result_imp(std::complex<long double>, std::complex<long double>){}
+
+void compile_and_link_test()
+{
+   check_result<std::complex<float> >(boost::math::cyl_hankel_1<float>(f, f));
+   check_result<std::complex<double> >(boost::math::cyl_hankel_1<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<std::complex<long double> >(boost::math::cyl_hankel_1<long double>(l, l));
+#endif
+
+   check_result<std::complex<float> >(boost::math::cyl_hankel_2<float>(f, f));
+   check_result<std::complex<double> >(boost::math::cyl_hankel_2<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<std::complex<long double> >(boost::math::cyl_hankel_2<long double>(l, l));
+#endif
+
+   check_result<std::complex<float> >(boost::math::sph_hankel_1<float>(f, f));
+   check_result<std::complex<double> >(boost::math::sph_hankel_1<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<std::complex<long double> >(boost::math::sph_hankel_1<long double>(l, l));
+#endif
+
+   check_result<std::complex<float> >(boost::math::sph_hankel_2<float>(f, f));
+   check_result<std::complex<double> >(boost::math::sph_hankel_2<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<std::complex<long double> >(boost::math::sph_hankel_2<long double>(l, l));
+#endif
+
+}

libs/math/test/compile_test/sf_hermite_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/hermite.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/hermite.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::hermite<float>(u, f));
+   check_result<double>(boost::math::hermite<double>(u, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::hermite<long double>(u, l));
+#endif
+}

libs/math/test/compile_test/sf_heuman_lambda_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2015.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/ellint_d.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/heuman_lambda.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::heuman_lambda<float>(f, f));
+   check_result<double>(boost::math::heuman_lambda<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::heuman_lambda<long double>(l, l));
+#endif
+}

libs/math/test/compile_test/sf_hypot_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/hypot.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/hypot.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::hypot<float>(f, f));
+   check_result<double>(boost::math::hypot<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::hypot<long double>(l, l));
+#endif
+}

libs/math/test/compile_test/sf_jacobi_incl_test.cpp

@@ -0,0 +1,96 @@
+//  Copyright John Maddock 2012.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/bessel.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/jacobi_elliptic.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::jacobi_elliptic<float>(f, f, static_cast<float*>(0), static_cast<float*>(0)));
+   check_result<double>(boost::math::jacobi_elliptic<double>(d, d, static_cast<double*>(0), static_cast<double*>(0)));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_elliptic<long double>(l, l, static_cast<long double*>(0), static_cast<long double*>(0)));
+#endif
+
+   check_result<float>(boost::math::jacobi_sn<float>(f, f));
+   check_result<double>(boost::math::jacobi_sn<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_sn<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::jacobi_cn<float>(f, f));
+   check_result<double>(boost::math::jacobi_cn<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_cn<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::jacobi_dn<float>(f, f));
+   check_result<double>(boost::math::jacobi_dn<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_dn<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::jacobi_cd<float>(f, f));
+   check_result<double>(boost::math::jacobi_cd<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_cd<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::jacobi_dc<float>(f, f));
+   check_result<double>(boost::math::jacobi_dc<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_dc<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::jacobi_ns<float>(f, f));
+   check_result<double>(boost::math::jacobi_ns<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_ns<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::jacobi_sd<float>(f, f));
+   check_result<double>(boost::math::jacobi_sd<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_sd<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::jacobi_ds<float>(f, f));
+   check_result<double>(boost::math::jacobi_ds<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_ds<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::jacobi_nc<float>(f, f));
+   check_result<double>(boost::math::jacobi_nc<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_nc<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::jacobi_nd<float>(f, f));
+   check_result<double>(boost::math::jacobi_nd<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_nd<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::jacobi_sc<float>(f, f));
+   check_result<double>(boost::math::jacobi_sc<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_sc<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::jacobi_cs<float>(f, f));
+   check_result<double>(boost::math::jacobi_cs<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_cs<long double>(l, l));
+#endif
+
+}

libs/math/test/compile_test/sf_jacobi_zeta_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/ellint_d.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/jacobi_zeta.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::jacobi_zeta<float>(f, f));
+   check_result<double>(boost::math::jacobi_zeta<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::jacobi_zeta<long double>(l, l));
+#endif
+}

libs/math/test/compile_test/sf_laguerre_incl_test.cpp

@@ -0,0 +1,32 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/laguerre.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/laguerre.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::laguerre<float>(u, f));
+   check_result<double>(boost::math::laguerre<double>(u, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::laguerre<long double>(u, l));
+#endif
+
+   typedef boost::math::policies::policy<> def_pol;
+   def_pol p;
+
+   check_result<float>(boost::math::laguerre<float, def_pol>(u, u, f, p));
+   check_result<double>(boost::math::laguerre<double, def_pol>(u, u, d, p));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::laguerre<long double, def_pol>(u, u, l, p));
+#endif
+}

libs/math/test/compile_test/sf_lanczos_incl_test.cpp

@@ -0,0 +1,10 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/lanczos.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/lanczos.hpp>
+

libs/math/test/compile_test/sf_legendre_incl_test.cpp

@@ -0,0 +1,35 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/legendre.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/legendre.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::legendre_p<float>(i, f));
+   check_result<double>(boost::math::legendre_p<double>(i, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::legendre_p<long double>(i, l));
+#endif
+
+   check_result<float>(boost::math::legendre_p<float>(i, i, f));
+   check_result<double>(boost::math::legendre_p<double>(i, i, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::legendre_p<long double>(i, i, l));
+#endif
+
+   check_result<float>(boost::math::legendre_q<float>(u, f));
+   check_result<double>(boost::math::legendre_q<double>(u, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::legendre_q<long double>(u, l));
+#endif
+}

libs/math/test/compile_test/sf_log1p_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/log1p.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/log1p.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::log1p<float>(f));
+   check_result<double>(boost::math::log1p<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::log1p<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_math_fwd_incl_test.cpp

@@ -0,0 +1,10 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/math_fwd.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/math_fwd.hpp>
+

libs/math/test/compile_test/sf_modf_incl_test.cpp

@@ -0,0 +1,50 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/modf.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/modf.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+float ff;
+double dd;
+long double lldd;
+
+int ii;
+long ll;
+#ifdef BOOST_HAS_LONG_LONG
+boost::long_long_type llll;
+#endif
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::modf(f, &ff));
+   check_result<double>(boost::math::modf(d, &dd));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::modf(l, &lldd));
+#endif
+   check_result<float>(boost::math::modf(f, &ii));
+   check_result<double>(boost::math::modf(d, &ii));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::modf(l, &ii));
+#endif
+   check_result<float>(boost::math::modf(f, &ll));
+   check_result<double>(boost::math::modf(d, &ll));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::modf(l, &ll));
+#endif
+#ifdef BOOST_HAS_LONG_LONG
+   check_result<float>(boost::math::modf(f, &llll));
+   check_result<double>(boost::math::modf(d, &llll));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::modf(l, &llll));
+#endif
+#endif
+}

libs/math/test/compile_test/sf_next_incl_test.cpp

@@ -0,0 +1,48 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/next.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/next.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::nextafter<float>(f, f));
+   check_result<double>(boost::math::nextafter<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::nextafter<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::float_next<float>(f));
+   check_result<double>(boost::math::float_next<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::float_next<long double>(l));
+#endif
+
+   check_result<float>(boost::math::float_prior<float>(f));
+   check_result<double>(boost::math::float_prior<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::float_prior<long double>(l));
+#endif
+
+   check_result<float>(boost::math::float_distance<float>(f, f));
+   check_result<double>(boost::math::float_distance<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::float_distance<long double>(l, l));
+#endif
+
+   check_result<float>(boost::math::float_advance<float>(f, 2));
+   check_result<double>(boost::math::float_advance<double>(d, 2));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::float_advance<long double>(l, 2));
+#endif
+
+}

libs/math/test/compile_test/sf_owens_t_incl_test.cpp

@@ -0,0 +1,24 @@
+//  Copyright John Maddock 2012.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/bessel.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/owens_t.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::owens_t<float>(f, f));
+   check_result<double>(boost::math::owens_t<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::owens_t<long double>(l, l));
+#endif
+
+}

libs/math/test/compile_test/sf_polygamma_incl_test.cpp

@@ -0,0 +1,28 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/digamma.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/polygamma.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::trigamma<float>(f));
+   check_result<double>(boost::math::trigamma<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::trigamma<long double>(l));
+#endif
+   check_result<float>(boost::math::polygamma<float>(1, f));
+   check_result<double>(boost::math::polygamma<double>(1, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::polygamma<long double>(1, l));
+#endif
+}

libs/math/test/compile_test/sf_powm1_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/powm1.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/powm1.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::powm1<float>(f, f));
+   check_result<double>(boost::math::powm1<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::powm1<long double>(l, l));
+#endif
+}

libs/math/test/compile_test/sf_relative_distance_incl_test.cpp

@@ -0,0 +1,28 @@
+//  Copyright John Maddock 2015.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/next.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/relative_difference.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::relative_difference<float>(f, f));
+   check_result<double>(boost::math::relative_difference<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::relative_difference<long double>(l, l));
+#endif
+   check_result<float>(boost::math::epsilon_difference<float>(f, f));
+   check_result<double>(boost::math::epsilon_difference<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::epsilon_difference<long double>(l, l));
+#endif
+}

libs/math/test/compile_test/sf_round_incl_test.cpp

@@ -0,0 +1,40 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/round.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/round.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::round<float>(f));
+   check_result<double>(boost::math::round<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::round<long double>(l));
+#endif
+   check_result<int>(boost::math::iround<float>(f));
+   check_result<int>(boost::math::iround<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<int>(boost::math::iround<long double>(l));
+#endif
+   check_result<long>(boost::math::lround<float>(f));
+   check_result<long>(boost::math::lround<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long>(boost::math::lround<long double>(l));
+#endif
+#ifdef BOOST_HAS_LONG_LONG
+   check_result<boost::long_long_type>(boost::math::llround<float>(f));
+   check_result<boost::long_long_type>(boost::math::llround<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<boost::long_long_type>(boost::math::llround<long double>(l));
+#endif
+#endif
+}

libs/math/test/compile_test/sf_sign_incl_test.cpp

@@ -0,0 +1,35 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/sign.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/sign.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<int>(boost::math::sign<float>(f));
+   check_result<int>(boost::math::sign<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<int>(boost::math::sign<long double>(l));
+#endif
+
+   check_result<int>(boost::math::signbit<float>(f));
+   check_result<int>(boost::math::signbit<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<int>(boost::math::signbit<long double>(l));
+#endif
+
+   check_result<float>(boost::math::copysign<float>(f, f));
+   check_result<double>(boost::math::copysign<double>(d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::copysign<long double>(l, l));
+#endif
+}

libs/math/test/compile_test/sf_sin_pi_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/sin_pi.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/sin_pi.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::sin_pi<float>(f));
+   check_result<double>(boost::math::sin_pi<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::sin_pi<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_sinc_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/sinc.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/sinc.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::sinc_pi<float>(f));
+   check_result<double>(boost::math::sinc_pi<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::sinc_pi<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_sinhc_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/sinhc.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/sinhc.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::sinhc_pi<float>(f));
+   check_result<double>(boost::math::sinhc_pi<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::sinhc_pi<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_sph_harm_incl_test.cpp

@@ -0,0 +1,43 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/spherical_harmonic.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/spherical_harmonic.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+inline void check_result_imp(std::complex<float>, std::complex<float>){}
+inline void check_result_imp(std::complex<double>, std::complex<double>){}
+inline void check_result_imp(std::complex<long double>, std::complex<long double>){}
+
+#include "test_compile_result.hpp"
+
+
+
+void compile_and_link_test()
+{
+   check_result<std::complex<float> >(boost::math::spherical_harmonic<float>(u, i, f, f));
+   check_result<std::complex<double> >(boost::math::spherical_harmonic<double>(u, i, d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<std::complex<long double> >(boost::math::spherical_harmonic<long double>(u, i, l, l));
+#endif
+
+   check_result<float>(boost::math::spherical_harmonic_r<float>(u, i, f, f));
+   check_result<double>(boost::math::spherical_harmonic_r<double>(u, i, d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::spherical_harmonic_r<long double>(u, i, l, l));
+#endif
+
+   check_result<float>(boost::math::spherical_harmonic_i<float>(u, i, f, f));
+   check_result<double>(boost::math::spherical_harmonic_i<double>(u, i, d, d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::spherical_harmonic_i<long double>(u, i, l, l));
+#endif
+}
+
+

libs/math/test/compile_test/sf_sqrt1pm1_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/sqrt1pm1.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/sqrt1pm1.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::sqrt1pm1<float>(f));
+   check_result<double>(boost::math::sqrt1pm1<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::sqrt1pm1<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_trunc_incl_test.cpp

@@ -0,0 +1,40 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/trunc.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/trunc.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::trunc<float>(f));
+   check_result<double>(boost::math::trunc<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::trunc<long double>(l));
+#endif
+   check_result<int>(boost::math::itrunc<float>(f));
+   check_result<int>(boost::math::itrunc<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<int>(boost::math::itrunc<long double>(l));
+#endif
+   check_result<long>(boost::math::ltrunc<float>(f));
+   check_result<long>(boost::math::ltrunc<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long>(boost::math::ltrunc<long double>(l));
+#endif
+#ifdef BOOST_HAS_LONG_LONG
+   check_result<boost::long_long_type>(boost::math::lltrunc<float>(f));
+   check_result<boost::long_long_type>(boost::math::lltrunc<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<boost::long_long_type>(boost::math::lltrunc<long double>(l));
+#endif
+#endif
+}

libs/math/test/compile_test/sf_ulp_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/next.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/ulp.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::ulp<float>(f));
+   check_result<double>(boost::math::ulp<double>(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::ulp<long double>(l));
+#endif
+}

libs/math/test/compile_test/sf_zeta_incl_test.cpp

@@ -0,0 +1,23 @@
+//  Copyright John Maddock 2007.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Basic sanity check that header <boost/math/special_functions/zeta.hpp>
+// #includes all the files that it needs to.
+//
+#include <boost/math/special_functions/zeta.hpp>
+//
+// Note this header includes no other headers, this is
+// important if this test is to be meaningful:
+//
+#include "test_compile_result.hpp"
+
+void compile_and_link_test()
+{
+   check_result<float>(boost::math::zeta(f));
+   check_result<double>(boost::math::zeta(d));
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+   check_result<long double>(boost::math::zeta(l));
+#endif
+}