@lakutata/math 0.0.0-stage → 3.1.5

package/vendor/boost/math/include/boost/math/special_functions.hpp

@@ -0,0 +1,86 @@
+//  Copyright John Maddock 2006, 2007, 2012, 2014.
+//  Copyright Paul A. Bristow 2006, 2007, 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)
+
+// This file includes *all* the special functions.
+// this may be useful if many are used
+// - to avoid including each function individually.
+
+#ifndef BOOST_MATH_SPECIAL_FUNCTIONS_HPP
+#define BOOST_MATH_SPECIAL_FUNCTIONS_HPP
+
+#include <boost/math/special_functions/airy.hpp>
+#include <boost/math/special_functions/acosh.hpp>
+#include <boost/math/special_functions/asinh.hpp>
+#include <boost/math/special_functions/atanh.hpp>
+#include <boost/math/special_functions/bernoulli.hpp>
+#include <boost/math/special_functions/bessel.hpp>
+#include <boost/math/special_functions/bessel_prime.hpp>
+#include <boost/math/special_functions/beta.hpp>
+#include <boost/math/special_functions/binomial.hpp>
+#include <boost/math/special_functions/cbrt.hpp>
+#include <boost/math/special_functions/cos_pi.hpp>
+#include <boost/math/special_functions/chebyshev.hpp>
+#include <boost/math/special_functions/digamma.hpp>
+#include <boost/math/special_functions/ellint_1.hpp>
+#include <boost/math/special_functions/ellint_2.hpp>
+#include <boost/math/special_functions/ellint_3.hpp>
+#include <boost/math/special_functions/ellint_d.hpp>
+#include <boost/math/special_functions/jacobi_theta.hpp>
+#include <boost/math/special_functions/jacobi_zeta.hpp>
+#include <boost/math/special_functions/heuman_lambda.hpp>
+#include <boost/math/special_functions/ellint_rc.hpp>
+#include <boost/math/special_functions/ellint_rd.hpp>
+#include <boost/math/special_functions/ellint_rf.hpp>
+#include <boost/math/special_functions/ellint_rj.hpp>
+#include <boost/math/special_functions/ellint_rg.hpp>
+#include <boost/math/special_functions/erf.hpp>
+#include <boost/math/special_functions/expint.hpp>
+#include <boost/math/special_functions/expm1.hpp>
+#include <boost/math/special_functions/factorials.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/math/special_functions/gamma.hpp>
+#include <boost/math/special_functions/hermite.hpp>
+#include <boost/math/special_functions/hypot.hpp>
+#include <boost/math/special_functions/hypergeometric_1F0.hpp>
+#include <boost/math/special_functions/hypergeometric_0F1.hpp>
+#include <boost/math/special_functions/hypergeometric_2F0.hpp>
+#include <boost/math/special_functions/hypergeometric_1F1.hpp>
+#include <boost/math/special_functions/hypergeometric_pFq.hpp>
+#include <boost/math/special_functions/jacobi_elliptic.hpp>
+#include <boost/math/special_functions/laguerre.hpp>
+#include <boost/math/special_functions/lanczos.hpp>
+#include <boost/math/special_functions/legendre.hpp>
+#include <boost/math/special_functions/log1p.hpp>
+#include <boost/math/special_functions/math_fwd.hpp>
+#include <boost/math/special_functions/next.hpp>
+#include <boost/math/special_functions/owens_t.hpp>
+#include <boost/math/special_functions/polygamma.hpp>
+#include <boost/math/special_functions/powm1.hpp>
+#include <boost/math/special_functions/sign.hpp>
+#include <boost/math/special_functions/sin_pi.hpp>
+#include <boost/math/special_functions/sinc.hpp>
+#include <boost/math/special_functions/sinhc.hpp>
+#include <boost/math/special_functions/spherical_harmonic.hpp>
+#include <boost/math/special_functions/sqrt1pm1.hpp>
+#include <boost/math/special_functions/zeta.hpp>
+#include <boost/math/special_functions/modf.hpp>
+#include <boost/math/special_functions/round.hpp>
+#include <boost/math/special_functions/trunc.hpp>
+#include <boost/math/special_functions/pow.hpp>
+#include <boost/math/special_functions/next.hpp>
+#include <boost/math/special_functions/owens_t.hpp>
+#include <boost/math/special_functions/hankel.hpp>
+#include <boost/math/special_functions/ulp.hpp>
+#include <boost/math/special_functions/relative_difference.hpp>
+#include <boost/math/special_functions/lambert_w.hpp>
+#include <boost/math/special_functions/gegenbauer.hpp>
+#include <boost/math/special_functions/jacobi.hpp>
+#ifndef BOOST_MATH_NO_EXCEPTIONS
+#include <boost/math/special_functions/legendre_stieltjes.hpp>
+#endif
+
+#endif // BOOST_MATH_SPECIAL_FUNCTIONS_HPP

package/vendor/boost/math/include/boost/math/statistics/anderson_darling.hpp

@@ -0,0 +1,112 @@
+/*
+ * Copyright Nick Thompson, 2019
+ * 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_STATISTICS_ANDERSON_DARLING_HPP
+#define BOOST_MATH_STATISTICS_ANDERSON_DARLING_HPP
+
+#include <cmath>
+#include <algorithm>
+#include <boost/math/statistics/univariate_statistics.hpp>
+#include <boost/math/special_functions/erf.hpp>
+
+namespace boost { namespace math { namespace statistics {
+
+template<class RandomAccessContainer>
+auto anderson_darling_normality_statistic(RandomAccessContainer const & v,
+                                          typename RandomAccessContainer::value_type mu = std::numeric_limits<typename RandomAccessContainer::value_type>::quiet_NaN(),
+                                          typename RandomAccessContainer::value_type sd = std::numeric_limits<typename RandomAccessContainer::value_type>::quiet_NaN())
+{
+    using Real = typename RandomAccessContainer::value_type;
+    using std::log;
+    using std::sqrt;
+    using boost::math::erfc;
+
+    if (std::isnan(mu)) {
+        mu = boost::math::statistics::mean(v);
+    }
+    if (std::isnan(sd)) {
+        sd = sqrt(boost::math::statistics::sample_variance(v));
+    }
+
+    typedef boost::math::policies::policy<
+          boost::math::policies::promote_float<false>,
+          boost::math::policies::promote_double<false> >
+          no_promote_policy;
+
+    // This is where Knuth's literate programming could really come in handy!
+    // I need some LaTeX. The idea is that before any observation, the ecdf is identically zero.
+    // So we need to compute:
+    // \int_{-\infty}^{v_0} \frac{F(x)F'(x)}{1- F(x)} \, \mathrm{d}x, where F(x) := \frac{1}{2}[1+\erf(\frac{x-\mu}{\sigma \sqrt{2}})]
+    // Astonishingly, there is an analytic evaluation to this integral, as you can validate with the following Mathematica command:
+    // Integrate[(1/2 (1 + Erf[(x - mu)/Sqrt[2*sigma^2]])*Exp[-(x - mu)^2/(2*sigma^2)]*1/Sqrt[2*\[Pi]*sigma^2])/(1 - 1/2 (1 + Erf[(x - mu)/Sqrt[2*sigma^2]])),
+    // {x, -Infinity, x0}, Assumptions -> {x0 \[Element] Reals && mu \[Element] Reals && sigma > 0}]
+    // This gives (for s = x-mu/sqrt(2sigma^2))
+    // -1/2 + erf(s) + log(2/(1+erf(s)))
+
+
+    Real inv_var_scale = 1/(sd*sqrt(Real(2)));
+    Real s0 = (v[0] - mu)*inv_var_scale;
+    Real erfcs0 = erfc(s0, no_promote_policy());
+    // Note that if erfcs0 == 0, then left_tail = inf (numerically), and hence the entire integral is numerically infinite:
+    if (erfcs0 <= 0) {
+        return std::numeric_limits<Real>::infinity();
+    }
+
+    // Note that we're going to add erfcs0/2 when we compute the integral over [x_0, x_1], so drop it here:
+    Real left_tail = -1 + log(Real(2));
+
+
+    // For the right tail, the ecdf is identically 1.
+    // Hence we need the integral:
+    // \int_{v_{n-1}}^{\infty} \frac{(1-F(x))F'(x)}{F(x)} \, \mathrm{d}x
+    // This also has an analytic evaluation! It can be found via the following Mathematica command:
+    // Integrate[(E^(-(z^2/2)) *(1 - 1/2 (1 + Erf[z/Sqrt[2]])))/(Sqrt[2 \[Pi]] (1/2 (1 + Erf[z/Sqrt[2]]))),
+    // {z, zn, \[Infinity]}, Assumptions -> {zn \[Element] Reals && mu \[Element] Reals}]
+    // This gives (for sf = xf-mu/sqrt(2sigma^2))
+    // -1/2 + erf(sf)/2 + 2log(2/(1+erf(sf)))
+
+    Real sf = (v[v.size()-1] - mu)*inv_var_scale;
+    //Real erfcsf = erfc<Real>(sf, no_promote_policy());
+    // This is the actual value of the tail integral. However, the -erfcsf/2 cancels from the integral over [v_{n-2}, v_{n-1}]:
+    //Real right_tail = -erfcsf/2 + log(Real(2)) - log(2-erfcsf);
+
+    // Use erfc(-x) = 2 - erfc(x)
+    Real erfcmsf = erfc<Real>(-sf, no_promote_policy());
+    // Again if this is precisely zero then the integral is numerically infinite:
+    if (erfcmsf == 0) {
+        return std::numeric_limits<Real>::infinity();
+    }
+    Real right_tail = log(2/erfcmsf);
+
+    // Now we need each integral:
+    // \int_{v_i}^{v_{i+1}} \frac{(i+1/n - F(x))^2F'(x)}{F(x)(1-F(x))}  \, \mathrm{d}x
+    // Again we get an analytical evaluation via the following Mathematica command:
+    // Integrate[((E^(-(z^2/2))/Sqrt[2 \[Pi]])*(k1 - F[z])^2)/(F[z]*(1 - F[z])),
+    // {z, z1, z2}, Assumptions -> {z1 \[Element] Reals && z2 \[Element] Reals &&k1 \[Element] Reals}] // FullSimplify
+
+    Real integrals = 0;
+    int64_t N = v.size();
+    for (int64_t i = 0; i < N - 1; ++i) {
+        if (v[i] > v[i+1]) {
+            throw std::domain_error("Input data must be sorted in increasing order v[0] <= v[1] <= . . .  <= v[n-1]");
+        }
+
+        Real k = (i+1)/Real(N);
+        Real s1 = (v[i+1]-mu)*inv_var_scale;
+        Real erfcs1 = erfc<Real>(s1, no_promote_policy());
+        Real term = k*(k*log(erfcs0*(-2 + erfcs1)/(erfcs1*(-2 + erfcs0))) + 2*log(erfcs1/erfcs0));
+
+        integrals += term;
+        s0 = s1;
+        erfcs0 = erfcs1;
+    }
+    integrals -= log(erfcs0);
+    return v.size()*(left_tail + right_tail + integrals);
+}
+
+}}}
+#endif

package/vendor/boost/math/include/boost/math/statistics/bivariate_statistics.hpp

@@ -0,0 +1,470 @@
+//  (C) Copyright Nick Thompson 2018.
+//  (C) Copyright Matt Borland 2021.
+//  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_STATISTICS_BIVARIATE_STATISTICS_HPP
+#define BOOST_MATH_STATISTICS_BIVARIATE_STATISTICS_HPP
+
+#include <iterator>
+#include <tuple>
+#include <type_traits>
+#include <stdexcept>
+#include <vector>
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <boost/math/tools/assert.hpp>
+#include <boost/math/tools/config.hpp>
+
+#ifdef BOOST_MATH_EXEC_COMPATIBLE
+#include <execution>
+#include <future>
+#include <thread>
+#endif
+
+namespace boost{ namespace math{ namespace statistics { namespace detail {
+
+// See Equation III.9 of "Numerically Stable, Single-Pass, Parallel Statistics Algorithms", Bennet et al.
+template<typename ReturnType, typename ForwardIterator>
+ReturnType means_and_covariance_seq_impl(ForwardIterator u_begin, ForwardIterator u_end, ForwardIterator v_begin, ForwardIterator v_end)
+{
+    using Real = typename std::tuple_element<0, ReturnType>::type;
+
+    Real cov = 0;
+    ForwardIterator u_it = u_begin;
+    ForwardIterator v_it = v_begin;
+    Real mu_u = *u_it++;
+    Real mu_v = *v_it++;
+    std::size_t i = 1;
+
+    while(u_it != u_end && v_it != v_end)
+    {
+        Real u_temp = (*u_it++ - mu_u)/(i+1);
+        Real v_temp = *v_it++ - mu_v;
+        cov += i*u_temp*v_temp;
+        mu_u = mu_u + u_temp;
+        mu_v = mu_v + v_temp/(i+1);
+        i = i + 1;
+    }
+
+    if(u_it != u_end || v_it != v_end)
+    {
+        throw std::domain_error("The size of each sample set must be the same to compute covariance");
+    }
+
+    return std::make_tuple(mu_u, mu_v, cov/i, Real(i));
+}
+
+#ifdef BOOST_MATH_EXEC_COMPATIBLE
+
+// Numerically stable parallel computation of (co-)variance
+// https://dl.acm.org/doi/10.1145/3221269.3223036
+template<typename ReturnType, typename ForwardIterator>
+ReturnType means_and_covariance_parallel_impl(ForwardIterator u_begin, ForwardIterator u_end, ForwardIterator v_begin, ForwardIterator v_end)
+{
+    using Real = typename std::tuple_element<0, ReturnType>::type;
+
+    const auto u_elements = std::distance(u_begin, u_end);
+    const auto v_elements = std::distance(v_begin, v_end);
+
+    if(u_elements != v_elements)
+    {
+        throw std::domain_error("The size of each sample set must be the same to compute covariance");
+    }
+
+    const unsigned max_concurrency = std::thread::hardware_concurrency() == 0 ? 2u : std::thread::hardware_concurrency();
+    unsigned num_threads = 2u;
+    
+    // 5.16 comes from benchmarking. See boost/math/reporting/performance/bivariate_statistics_performance.cpp
+    // Threading is faster for: 10 + 5.16e-3 N/j <= 5.16e-3N => N >= 10^4j/5.16(j-1).
+    const auto parallel_lower_bound = 10e4*max_concurrency/(5.16*(max_concurrency-1));
+    const auto parallel_upper_bound = 10e4*2/5.16; // j = 2
+
+    // https://lemire.me/blog/2020/01/30/cost-of-a-thread-in-c-under-linux/
+    if(u_elements < parallel_lower_bound)
+    {
+        return means_and_covariance_seq_impl<ReturnType>(u_begin, u_end, v_begin, v_end);
+    }
+    else if(u_elements >= parallel_upper_bound)
+    {
+        num_threads = max_concurrency;
+    }
+    else
+    {
+        for(unsigned i = 3; i < max_concurrency; ++i)
+        {
+            if(parallel_lower_bound < 10e4*i/(5.16*(i-1)))
+            {
+                num_threads = i;
+                break;
+            }
+        }
+    }
+
+    std::vector<std::future<ReturnType>> future_manager;
+    const auto elements_per_thread = std::ceil(static_cast<double>(u_elements)/num_threads);
+
+    ForwardIterator u_it = u_begin;
+    ForwardIterator v_it = v_begin;
+
+    for(std::size_t i = 0; i < num_threads - 1; ++i)
+    {
+        future_manager.emplace_back(std::async(std::launch::async | std::launch::deferred, [u_it, v_it, elements_per_thread]() -> ReturnType
+        {
+            return means_and_covariance_seq_impl<ReturnType>(u_it, std::next(u_it, elements_per_thread), v_it, std::next(v_it, elements_per_thread));
+        }));
+        u_it = std::next(u_it, elements_per_thread);
+        v_it = std::next(v_it, elements_per_thread);
+    }
+
+    future_manager.emplace_back(std::async(std::launch::async | std::launch::deferred, [u_it, u_end, v_it, v_end]() -> ReturnType
+    {
+        return means_and_covariance_seq_impl<ReturnType>(u_it, u_end, v_it, v_end);
+    }));
+
+    ReturnType temp = future_manager[0].get();
+    Real mu_u_a = std::get<0>(temp);
+    Real mu_v_a = std::get<1>(temp);
+    Real cov_a = std::get<2>(temp);
+    Real n_a = std::get<3>(temp);
+
+    for(std::size_t i = 1; i < future_manager.size(); ++i)
+    {
+        temp = future_manager[i].get();
+        Real mu_u_b = std::get<0>(temp);
+        Real mu_v_b = std::get<1>(temp);
+        Real cov_b = std::get<2>(temp);
+        Real n_b = std::get<3>(temp);
+
+        const Real n_ab = n_a + n_b;
+        const Real delta_u = mu_u_b - mu_u_a;
+        const Real delta_v = mu_v_b - mu_v_a;
+
+        cov_a = cov_a + cov_b + (-delta_u)*(-delta_v)*((n_a*n_b)/n_ab);
+        mu_u_a = mu_u_a + delta_u*(n_b/n_ab);
+        mu_v_a = mu_v_a + delta_v*(n_b/n_ab);
+        n_a = n_ab;
+    }
+
+    return std::make_tuple(mu_u_a, mu_v_a, cov_a, n_a);
+}
+
+#endif // BOOST_MATH_EXEC_COMPATIBLE
+
+template<typename ReturnType, typename ForwardIterator>
+ReturnType correlation_coefficient_seq_impl(ForwardIterator u_begin, ForwardIterator u_end, ForwardIterator v_begin, ForwardIterator v_end)
+{
+    using Real = typename std::tuple_element<0, ReturnType>::type;
+    using std::sqrt;
+
+    Real cov = 0;
+    ForwardIterator u_it = u_begin;
+    ForwardIterator v_it = v_begin;
+    Real mu_u = *u_it++;
+    Real mu_v = *v_it++;
+    Real Qu = 0;
+    Real Qv = 0;
+    std::size_t i = 1;
+
+    while(u_it != u_end && v_it != v_end)
+    {
+        Real u_tmp = *u_it++ - mu_u;
+        Real v_tmp = *v_it++ - mu_v;
+        Qu = Qu + (i*u_tmp*u_tmp)/(i+1);
+        Qv = Qv + (i*v_tmp*v_tmp)/(i+1);
+        cov += i*u_tmp*v_tmp/(i+1);
+        mu_u = mu_u + u_tmp/(i+1);
+        mu_v = mu_v + v_tmp/(i+1);
+        ++i;
+    }
+
+
+    // If one dataset is constant, then the correlation coefficient is undefined.
+    // See https://stats.stackexchange.com/questions/23676/normalized-correlation-with-a-constant-vector
+    // Thanks to zbjornson for pointing this out.
+    if (Qu == 0 || Qv == 0)
+    {
+        return std::make_tuple(mu_u, Qu, mu_v, Qv, cov, std::numeric_limits<Real>::quiet_NaN(), Real(i));
+    }
+
+    // Make sure rho in [-1, 1], even in the presence of numerical noise.
+    Real rho = cov/sqrt(Qu*Qv);
+    if (rho > 1) {
+        rho = 1;
+    }
+    if (rho < -1) {
+        rho = -1;
+    }
+
+    return std::make_tuple(mu_u, Qu, mu_v, Qv, cov, rho, Real(i));
+}
+
+#ifdef BOOST_MATH_EXEC_COMPATIBLE
+
+// Numerically stable parallel computation of (co-)variance:
+// https://dl.acm.org/doi/10.1145/3221269.3223036
+//
+// Parallel computation of variance:
+// http://i.stanford.edu/pub/cstr/reports/cs/tr/79/773/CS-TR-79-773.pdf
+template<typename ReturnType, typename ForwardIterator>
+ReturnType correlation_coefficient_parallel_impl(ForwardIterator u_begin, ForwardIterator u_end, ForwardIterator v_begin, ForwardIterator v_end)
+{
+    using Real = typename std::tuple_element<0, ReturnType>::type;
+
+    const auto u_elements = std::distance(u_begin, u_end);
+    const auto v_elements = std::distance(v_begin, v_end);
+
+    if(u_elements != v_elements)
+    {
+        throw std::domain_error("The size of each sample set must be the same to compute covariance");
+    }
+
+    const unsigned max_concurrency = std::thread::hardware_concurrency() == 0 ? 2u : std::thread::hardware_concurrency();
+    unsigned num_threads = 2u;
+    
+    // 3.25 comes from benchmarking. See boost/math/reporting/performance/bivariate_statistics_performance.cpp
+    // Threading is faster for: 10 + 3.25e-3 N/j <= 3.25e-3N => N >= 10^4j/3.25(j-1).
+    const auto parallel_lower_bound = 10e4*max_concurrency/(3.25*(max_concurrency-1));
+    const auto parallel_upper_bound = 10e4*2/3.25; // j = 2
+
+    // https://lemire.me/blog/2020/01/30/cost-of-a-thread-in-c-under-linux/
+    if(u_elements < parallel_lower_bound)
+    {
+        return correlation_coefficient_seq_impl<ReturnType>(u_begin, u_end, v_begin, v_end);
+    }
+    else if(u_elements >= parallel_upper_bound)
+    {
+        num_threads = max_concurrency;
+    }
+    else
+    {
+        for(unsigned i = 3; i < max_concurrency; ++i)
+        {
+            if(parallel_lower_bound < 10e4*i/(3.25*(i-1)))
+            {
+                num_threads = i;
+                break;
+            }
+        }
+    }
+
+    std::vector<std::future<ReturnType>> future_manager;
+    const auto elements_per_thread = std::ceil(static_cast<double>(u_elements)/num_threads);
+
+    ForwardIterator u_it = u_begin;
+    ForwardIterator v_it = v_begin;
+
+    for(std::size_t i = 0; i < num_threads - 1; ++i)
+    {
+        future_manager.emplace_back(std::async(std::launch::async | std::launch::deferred, [u_it, v_it, elements_per_thread]() -> ReturnType
+        {
+            return correlation_coefficient_seq_impl<ReturnType>(u_it, std::next(u_it, elements_per_thread), v_it, std::next(v_it, elements_per_thread));
+        }));
+        u_it = std::next(u_it, elements_per_thread);
+        v_it = std::next(v_it, elements_per_thread);
+    }
+
+    future_manager.emplace_back(std::async(std::launch::async | std::launch::deferred, [u_it, u_end, v_it, v_end]() -> ReturnType
+    {
+        return correlation_coefficient_seq_impl<ReturnType>(u_it, u_end, v_it, v_end);
+    }));
+
+    ReturnType temp = future_manager[0].get();
+    Real mu_u_a = std::get<0>(temp);
+    Real Qu_a = std::get<1>(temp);
+    Real mu_v_a = std::get<2>(temp);
+    Real Qv_a = std::get<3>(temp);
+    Real cov_a = std::get<4>(temp);
+    Real n_a = std::get<6>(temp);
+
+    for(std::size_t i = 1; i < future_manager.size(); ++i)
+    {
+        temp = future_manager[i].get();
+        Real mu_u_b = std::get<0>(temp);
+        Real Qu_b = std::get<1>(temp);
+        Real mu_v_b = std::get<2>(temp);
+        Real Qv_b = std::get<3>(temp);
+        Real cov_b = std::get<4>(temp);
+        Real n_b = std::get<6>(temp);
+
+        const Real n_ab = n_a + n_b;
+        const Real delta_u = mu_u_b - mu_u_a;
+        const Real delta_v = mu_v_b - mu_v_a;
+
+        cov_a = cov_a + cov_b + (-delta_u)*(-delta_v)*((n_a*n_b)/n_ab);
+        mu_u_a = mu_u_a + delta_u*(n_b/n_ab);
+        mu_v_a = mu_v_a + delta_v*(n_b/n_ab);
+        Qu_a = Qu_a + Qu_b + delta_u*delta_u*((n_a*n_b)/n_ab);
+        Qv_b = Qv_a + Qv_b + delta_v*delta_v*((n_a*n_b)/n_ab);
+        n_a = n_ab;
+    }
+
+    // If one dataset is constant, then the correlation coefficient is undefined.
+    // See https://stats.stackexchange.com/questions/23676/normalized-correlation-with-a-constant-vector
+    // Thanks to zbjornson for pointing this out.
+    if (Qu_a == 0 || Qv_a == 0)
+    {
+        return std::make_tuple(mu_u_a, Qu_a, mu_v_a, Qv_a, cov_a, std::numeric_limits<Real>::quiet_NaN(), n_a);
+    }
+
+    // Make sure rho in [-1, 1], even in the presence of numerical noise.
+    Real rho = cov_a/sqrt(Qu_a*Qv_a);
+    if (rho > 1) {
+        rho = 1;
+    }
+    if (rho < -1) {
+        rho = -1;
+    }
+
+    return std::make_tuple(mu_u_a, Qu_a, mu_v_a, Qv_a, cov_a, rho, n_a);
+}
+
+#endif // BOOST_MATH_EXEC_COMPATIBLE
+
+} // namespace detail
+
+#ifdef BOOST_MATH_EXEC_COMPATIBLE
+
+template<typename ExecutionPolicy, typename Container, typename Real = typename Container::value_type>
+inline auto means_and_covariance(ExecutionPolicy&& exec, Container const & u, Container const & v)
+{
+    if constexpr (std::is_same_v<std::remove_reference_t<decltype(exec)>, decltype(std::execution::seq)>)
+    {
+        if constexpr (std::is_integral_v<Real>)
+        {
+            using ReturnType = std::tuple<double, double, double, double>;
+            ReturnType temp = detail::means_and_covariance_seq_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v));
+            return std::make_tuple(std::get<0>(temp), std::get<1>(temp), std::get<2>(temp));
+        }
+        else
+        {
+            using ReturnType = std::tuple<Real, Real, Real, Real>;
+            ReturnType temp = detail::means_and_covariance_seq_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v));
+            return std::make_tuple(std::get<0>(temp), std::get<1>(temp), std::get<2>(temp));
+        }
+    }
+    else
+    {
+        if constexpr (std::is_integral_v<Real>)
+        {
+            using ReturnType = std::tuple<double, double, double, double>;
+            ReturnType temp = detail::means_and_covariance_parallel_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v));
+            return std::make_tuple(std::get<0>(temp), std::get<1>(temp), std::get<2>(temp));
+        }
+        else
+        {
+            using ReturnType = std::tuple<Real, Real, Real, Real>;
+            ReturnType temp = detail::means_and_covariance_parallel_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v));
+            return std::make_tuple(std::get<0>(temp), std::get<1>(temp), std::get<2>(temp));
+        }
+    }
+}
+
+template<typename Container>
+inline auto means_and_covariance(Container const & u, Container const & v)
+{
+    return means_and_covariance(std::execution::seq, u, v);
+}
+
+template<typename ExecutionPolicy, typename Container>
+inline auto covariance(ExecutionPolicy&& exec, Container const & u, Container const & v)
+{
+    return std::get<2>(means_and_covariance(exec, u, v));
+}
+
+template<typename Container>
+inline auto covariance(Container const & u, Container const & v)
+{
+    return covariance(std::execution::seq, u, v);
+}
+
+template<typename ExecutionPolicy, typename Container, typename Real = typename Container::value_type>
+inline auto correlation_coefficient(ExecutionPolicy&& exec, Container const & u, Container const & v)
+{
+    if constexpr (std::is_same_v<std::remove_reference_t<decltype(exec)>, decltype(std::execution::seq)>)
+    {
+        if constexpr (std::is_integral_v<Real>)
+        {
+            using ReturnType = std::tuple<double, double, double, double, double, double, double>;
+            return std::get<5>(detail::correlation_coefficient_seq_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v)));
+        }
+        else
+        {
+            using ReturnType = std::tuple<Real, Real, Real, Real, Real, Real, Real>;
+            return std::get<5>(detail::correlation_coefficient_seq_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v)));
+        }
+    }
+    else
+    {
+        if constexpr (std::is_integral_v<Real>)
+        {
+            using ReturnType = std::tuple<double, double, double, double, double, double, double>;
+            return std::get<5>(detail::correlation_coefficient_parallel_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v)));
+        }
+        else
+        {
+            using ReturnType = std::tuple<Real, Real, Real, Real, Real, Real, Real>;
+            return std::get<5>(detail::correlation_coefficient_parallel_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v)));
+        }
+    }
+}
+
+template<typename Container, typename Real = typename Container::value_type>
+inline auto correlation_coefficient(Container const & u, Container const & v)
+{
+    return correlation_coefficient(std::execution::seq, u, v);
+}
+
+#else // C++11 and single threaded bindings
+
+template<typename Container, typename Real = typename Container::value_type, typename std::enable_if<std::is_integral<Real>::value, bool>::type = true>
+inline auto means_and_covariance(Container const & u, Container const & v) -> std::tuple<double, double, double>
+{
+    using ReturnType = std::tuple<double, double, double, double>;
+    ReturnType temp = detail::means_and_covariance_seq_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v));
+    return std::make_tuple(std::get<0>(temp), std::get<1>(temp), std::get<2>(temp));
+}
+
+template<typename Container, typename Real = typename Container::value_type, typename std::enable_if<!std::is_integral<Real>::value, bool>::type = true>
+inline auto means_and_covariance(Container const & u, Container const & v) -> std::tuple<Real, Real, Real>
+{
+    using ReturnType = std::tuple<Real, Real, Real, Real>;
+    ReturnType temp = detail::means_and_covariance_seq_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v));
+    return std::make_tuple(std::get<0>(temp), std::get<1>(temp), std::get<2>(temp));
+}
+
+template<typename Container, typename Real = typename Container::value_type, typename std::enable_if<std::is_integral<Real>::value, bool>::type = true>
+inline double covariance(Container const & u, Container const & v)
+{
+    using ReturnType = std::tuple<double, double, double, double>;
+    return std::get<2>(detail::means_and_covariance_seq_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v)));
+}
+
+template<typename Container, typename Real = typename Container::value_type, typename std::enable_if<!std::is_integral<Real>::value, bool>::type = true>
+inline Real covariance(Container const & u, Container const & v)
+{
+    using ReturnType = std::tuple<Real, Real, Real, Real>;
+    return std::get<2>(detail::means_and_covariance_seq_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v)));
+}
+
+template<typename Container, typename Real = typename Container::value_type, typename std::enable_if<std::is_integral<Real>::value, bool>::type = true>
+inline double correlation_coefficient(Container const & u, Container const & v)
+{
+    using ReturnType = std::tuple<double, double, double, double, double, double, double>;
+    return std::get<5>(detail::correlation_coefficient_seq_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v)));
+}
+
+template<typename Container, typename Real = typename Container::value_type, typename std::enable_if<!std::is_integral<Real>::value, bool>::type = true>
+inline Real correlation_coefficient(Container const & u, Container const & v)
+{
+    using ReturnType = std::tuple<Real, Real, Real, Real, Real, Real, Real>;
+    return std::get<5>(detail::correlation_coefficient_seq_impl<ReturnType>(std::begin(u), std::end(u), std::begin(v), std::end(v)));
+}
+
+#endif
+
+}}} // namespace boost::math::statistics
+
+#endif