@lakutata/math 0.0.0-stage → 3.1.5

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

@@ -0,0 +1,161 @@
+//  (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_Z_TEST_HPP
+#define BOOST_MATH_STATISTICS_Z_TEST_HPP
+
+#include <boost/math/distributions/normal.hpp>
+#include <boost/math/statistics/univariate_statistics.hpp>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+#include <cmath>
+
+namespace boost { namespace math { namespace statistics { namespace detail {
+
+template<typename ReturnType, typename T>
+ReturnType one_sample_z_test_impl(T sample_mean, T sample_variance, T sample_size, T assumed_mean)
+{
+    using Real = typename std::tuple_element<0, ReturnType>::type;
+    using std::sqrt;
+    using no_promote_policy = boost::math::policies::policy<boost::math::policies::promote_float<false>, boost::math::policies::promote_double<false>>;
+
+    Real test_statistic = (sample_mean - assumed_mean) / (sample_variance / sqrt(sample_size));
+    auto z = boost::math::normal_distribution<Real, no_promote_policy>(sample_size - 1);
+    Real pvalue;
+    if(test_statistic > 0)
+    {
+        pvalue = 2*boost::math::cdf<Real>(z, -test_statistic);
+    }
+    else
+    {
+        pvalue = 2*boost::math::cdf<Real>(z, test_statistic);
+    }
+
+    return std::make_pair(test_statistic, pvalue);
+}
+
+template<typename ReturnType, typename ForwardIterator>
+ReturnType one_sample_z_test_impl(ForwardIterator begin, ForwardIterator end, typename std::iterator_traits<ForwardIterator>::value_type assumed_mean) 
+{
+    using Real = typename std::tuple_element<0, ReturnType>::type;
+    std::pair<Real, Real> temp = mean_and_sample_variance(begin, end);
+    Real mu = std::get<0>(temp);
+    Real s_sq = std::get<1>(temp);
+    return one_sample_z_test_impl<ReturnType>(mu, s_sq, Real(std::distance(begin, end)), Real(assumed_mean));
+}
+
+template<typename ReturnType, typename T>
+ReturnType two_sample_z_test_impl(T mean_1, T variance_1, T size_1, T mean_2, T variance_2, T size_2)
+{
+    using Real = typename std::tuple_element<0, ReturnType>::type;
+    using std::sqrt;
+    using no_promote_policy = boost::math::policies::policy<boost::math::policies::promote_float<false>, boost::math::policies::promote_double<false>>;
+
+    Real test_statistic = (mean_1 - mean_2) / sqrt(variance_1/size_1 + variance_2/size_2);
+    auto z = boost::math::normal_distribution<Real, no_promote_policy>(size_1 + size_2 - 1);
+    Real pvalue;
+    if(test_statistic > 0)
+    {
+        pvalue = 2*boost::math::cdf<Real>(z, -test_statistic);
+    }
+    else
+    {
+        pvalue = 2*boost::math::cdf<Real>(z, test_statistic);
+    }
+
+    return std::make_pair(test_statistic, pvalue);
+}
+
+template<typename ReturnType, typename ForwardIterator>
+ReturnType two_sample_z_test_impl(ForwardIterator begin_1, ForwardIterator end_1, ForwardIterator begin_2, ForwardIterator end_2)
+{
+    using Real = typename std::tuple_element<0, ReturnType>::type;
+    using std::sqrt;
+    auto n1 = std::distance(begin_1, end_1);
+    auto n2 = std::distance(begin_2, end_2);
+
+    ReturnType temp_1 = mean_and_sample_variance(begin_1, end_1);
+    Real mean_1 = std::get<0>(temp_1);
+    Real variance_1 = std::get<1>(temp_1);
+
+    ReturnType temp_2 = mean_and_sample_variance(begin_2, end_2);
+    Real mean_2 = std::get<0>(temp_2);
+    Real variance_2 = std::get<1>(temp_2);
+
+    return two_sample_z_test_impl<ReturnType>(mean_1, variance_1, Real(n1), mean_2, variance_2, Real(n2));
+}
+
+} // detail
+
+template<typename Real, typename std::enable_if<std::is_integral<Real>::value, bool>::type = true>
+inline auto one_sample_z_test(Real sample_mean, Real sample_variance, Real sample_size, Real assumed_mean) -> std::pair<double, double>
+{
+    return detail::one_sample_z_test_impl<std::pair<double, double>>(sample_mean, sample_variance, sample_size, assumed_mean);
+}
+
+template<typename Real, typename std::enable_if<!std::is_integral<Real>::value, bool>::type = true>
+inline auto one_sample_z_test(Real sample_mean, Real sample_variance, Real sample_size, Real assumed_mean) -> std::pair<Real, Real>
+{
+    return detail::one_sample_z_test_impl<std::pair<Real, Real>>(sample_mean, sample_variance, sample_size, assumed_mean);
+}
+
+template<typename ForwardIterator, typename Real = typename std::iterator_traits<ForwardIterator>::value_type, 
+         typename std::enable_if<std::is_integral<Real>::value, bool>::type = true>
+inline auto one_sample_z_test(ForwardIterator begin, ForwardIterator end, Real assumed_mean) -> std::pair<double, double>
+{
+    return detail::one_sample_z_test_impl<std::pair<double, double>>(begin, end, assumed_mean);
+}
+
+template<typename ForwardIterator, typename Real = typename std::iterator_traits<ForwardIterator>::value_type, 
+         typename std::enable_if<!std::is_integral<Real>::value, bool>::type = true>
+inline auto one_sample_z_test(ForwardIterator begin, ForwardIterator end, Real assumed_mean) -> std::pair<Real, Real>
+{
+    return detail::one_sample_z_test_impl<std::pair<Real, Real>>(begin, end, assumed_mean);
+}
+
+template<typename Container, typename Real = typename Container::value_type,
+         typename std::enable_if<std::is_integral<Real>::value, bool>::type = true>
+inline auto one_sample_z_test(Container const & v, Real assumed_mean) -> std::pair<double, double>
+{
+    return detail::one_sample_z_test_impl<std::pair<double, double>>(std::begin(v), std::end(v), assumed_mean);
+}
+
+template<typename Container, typename Real = typename Container::value_type,
+         typename std::enable_if<!std::is_integral<Real>::value, bool>::type = true>
+inline auto one_sample_z_test(Container const & v, Real assumed_mean) -> std::pair<Real, Real>
+{
+    return detail::one_sample_z_test_impl<std::pair<Real, Real>>(std::begin(v), std::end(v), assumed_mean);
+}
+
+template<typename ForwardIterator, typename Real = typename std::iterator_traits<ForwardIterator>::value_type, 
+         typename std::enable_if<std::is_integral<Real>::value, bool>::type = true>
+inline auto two_sample_z_test(ForwardIterator begin_1, ForwardIterator end_1, ForwardIterator begin_2, ForwardIterator end_2) -> std::pair<double, double>
+{
+    return detail::two_sample_z_test_impl<std::pair<double, double>>(begin_1, end_1, begin_2, end_2);
+}
+
+template<typename ForwardIterator, typename Real = typename std::iterator_traits<ForwardIterator>::value_type, 
+         typename std::enable_if<!std::is_integral<Real>::value, bool>::type = true>
+inline auto two_sample_z_test(ForwardIterator begin_1, ForwardIterator end_1, ForwardIterator begin_2, ForwardIterator end_2) -> std::pair<Real, Real>
+{
+    return detail::two_sample_z_test_impl<std::pair<Real, Real>>(begin_1, end_1, begin_2, end_2);
+}
+
+template<typename Container, typename Real = typename Container::value_type, typename std::enable_if<std::is_integral<Real>::value, bool>::type = true>
+inline auto two_sample_z_test(Container const & u, Container const & v) -> std::pair<double, double>
+{
+    return detail::two_sample_z_test_impl<std::pair<double, double>>(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 auto two_sample_z_test(Container const & u, Container const & v) -> std::pair<Real, Real>
+{
+    return detail::two_sample_z_test_impl<std::pair<Real, Real>>(std::begin(u), std::end(u), std::begin(v), std::end(v));
+}
+
+}}} // boost::math::statistics
+
+#endif // BOOST_MATH_STATISTICS_Z_TEST_HPP

package/vendor/boost/math/include/boost/math/tools/agm.hpp

@@ -0,0 +1,47 @@
+//  (C) Copyright Nick Thompson 2020.
+//  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_TOOLS_AGM_HPP
+#define BOOST_MATH_TOOLS_AGM_HPP
+#include <limits>
+#include <cmath>
+
+namespace boost { namespace math { namespace tools {
+
+template<typename Real>
+Real agm(Real a, Real g)
+{
+    using std::sqrt;
+    
+    if (a < g)
+    {
+        // Mathematica, mpfr, and mpmath are all symmetric functions:
+        return agm(g, a);
+    }
+    // Use: M(rx, ry) = rM(x,y)
+    if (a <= 0 || g <= 0) {
+        if (a < 0 || g < 0) {
+            return std::numeric_limits<Real>::quiet_NaN();
+        }
+        return Real(0);
+    }
+
+    // The number of correct digits doubles on each iteration.
+    // Divide by 512 for some leeway:
+    const Real scale = sqrt(std::numeric_limits<Real>::epsilon())/512;
+    while (a-g > scale*g)
+    {
+        Real anp1 = (a + g)/2;
+        g = sqrt(a*g);
+        a = anp1;
+    }
+
+    // Final cleanup iteration recovers down to ~2ULPs:
+    return (a + g)/2;
+}
+
+
+}}}
+#endif

package/vendor/boost/math/include/boost/math/tools/array.hpp

@@ -0,0 +1,41 @@
+//  Copyright (c) 2024 Matt Borland
+//  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)
+//
+//  Regular use of std::array functions can not be used on 
+//  GPU platforms like CUDA since they are missing the __device__ marker
+//  Alias as needed to get correct support
+
+#ifndef BOOST_MATH_TOOLS_ARRAY_HPP
+#define BOOST_MATH_TOOLS_ARRAY_HPP
+
+#include <boost/math/tools/config.hpp>
+
+#ifdef BOOST_MATH_ENABLE_CUDA
+
+#include <cuda/std/array>
+
+namespace boost {
+namespace math {
+
+using cuda::std::array;
+
+} // namespace math
+} // namespace boost
+
+#else
+
+#include <array>
+
+namespace boost {
+namespace math {
+
+using std::array;
+
+} // namespace math
+} // namespace boost
+
+#endif // BOOST_MATH_ENABLE_CUDA
+
+#endif // BOOST_MATH_TOOLS_ARRAY_HPP

package/vendor/boost/math/include/boost/math/tools/assert.hpp

@@ -0,0 +1,49 @@
+//  (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)
+//
+// We deliberately use assert in here:
+//
+// boost-no-inspect
+
+#ifndef BOOST_MATH_TOOLS_ASSERT_HPP
+#define BOOST_MATH_TOOLS_ASSERT_HPP
+
+#include <boost/math/tools/config.hpp>
+
+#ifdef BOOST_MATH_HAS_GPU_SUPPORT
+
+// Run time asserts are generally unsupported
+
+#define BOOST_MATH_ASSERT(expr)
+#define BOOST_MATH_ASSERT_MSG(expr, msg)
+#define BOOST_MATH_STATIC_ASSERT(expr) static_assert(expr, #expr " failed")
+#define BOOST_MATH_STATIC_ASSERT_MSG(expr, msg) static_assert(expr, msg)
+
+#else
+
+#include <boost/math/tools/is_standalone.hpp>
+
+#ifndef BOOST_MATH_STANDALONE
+
+#include <boost/assert.hpp>
+#include <boost/static_assert.hpp>
+#define BOOST_MATH_ASSERT(expr) BOOST_ASSERT(expr)
+#define BOOST_MATH_ASSERT_MSG(expr, msg) BOOST_ASSERT_MSG(expr, msg)
+#define BOOST_MATH_STATIC_ASSERT(expr) BOOST_STATIC_ASSERT(expr)
+#define BOOST_MATH_STATIC_ASSERT_MSG(expr, msg) BOOST_STATIC_ASSERT_MSG(expr, msg)
+
+#else // Standalone mode - use cassert
+
+#include <cassert>
+#define BOOST_MATH_ASSERT(expr) assert(expr)
+#define BOOST_MATH_ASSERT_MSG(expr, msg) assert((expr)&&(msg))
+#define BOOST_MATH_STATIC_ASSERT(expr) static_assert(expr, #expr " failed")
+#define BOOST_MATH_STATIC_ASSERT_MSG(expr, msg) static_assert(expr, msg)
+
+#endif // Is standalone
+
+#endif // BOOST_MATH_HAS_GPU_SUPPORT
+
+#endif // BOOST_MATH_TOOLS_ASSERT_HPP

package/vendor/boost/math/include/boost/math/tools/atomic.hpp

@@ -0,0 +1,50 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2017 John Maddock
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MATH_ATOMIC_DETAIL_HPP
+#define BOOST_MATH_ATOMIC_DETAIL_HPP
+
+#include <boost/math/tools/config.hpp>
+#include <boost/math/tools/cxx03_warn.hpp>
+
+#ifdef BOOST_MATH_HAS_THREADS
+#include <atomic>
+
+namespace boost {
+   namespace math {
+      namespace detail {
+#if (ATOMIC_INT_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
+         typedef std::atomic<int> atomic_counter_type;
+         typedef std::atomic<unsigned> atomic_unsigned_type;
+         typedef int atomic_integer_type;
+         typedef unsigned atomic_unsigned_integer_type;
+#elif (ATOMIC_SHORT_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
+         typedef std::atomic<short> atomic_counter_type;
+         typedef std::atomic<unsigned short> atomic_unsigned_type;
+         typedef short atomic_integer_type;
+         typedef unsigned short atomic_unsigned_type;
+#elif (ATOMIC_LONG_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
+         typedef std::atomic<long> atomic_unsigned_integer_type;
+         typedef std::atomic<unsigned long> atomic_unsigned_type;
+         typedef unsigned long atomic_unsigned_type;
+         typedef long atomic_integer_type;
+#elif (ATOMIC_LLONG_LOCK_FREE == 2) && !defined(BOOST_MATH_NO_ATOMIC_INT)
+         typedef std::atomic<long long> atomic_unsigned_integer_type;
+         typedef std::atomic<unsigned long long> atomic_unsigned_type;
+         typedef long long atomic_integer_type;
+         typedef unsigned long long atomic_unsigned_integer_type;
+#elif !defined(BOOST_MATH_NO_ATOMIC_INT)
+#  define BOOST_MATH_NO_ATOMIC_INT
+#endif
+      } // Namespace detail
+   } // Namespace math
+} // Namespace boost
+
+#else
+#  define BOOST_MATH_NO_ATOMIC_INT
+#endif // BOOST_MATH_HAS_THREADS
+
+#endif // BOOST_MATH_ATOMIC_DETAIL_HPP

package/vendor/boost/math/include/boost/math/tools/big_constant.hpp

@@ -0,0 +1,110 @@
+
+//  Copyright (c) 2011 John Maddock
+//  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_TOOLS_BIG_CONSTANT_HPP
+#define BOOST_MATH_TOOLS_BIG_CONSTANT_HPP
+
+#include <boost/math/tools/config.hpp>
+
+// On NVRTC we don't need any of this
+// We just have a simple definition of the macro since the largest float
+// type on the platform is a 64-bit double
+#ifndef BOOST_MATH_HAS_NVRTC 
+
+#ifndef BOOST_MATH_STANDALONE
+#include <boost/lexical_cast.hpp>
+#endif
+
+#include <cstdlib>
+#include <type_traits>
+#include <limits>
+
+namespace boost{ namespace math{ 
+
+namespace tools{
+
+template <class T>
+struct numeric_traits : public std::numeric_limits< T > {};
+
+#ifdef BOOST_MATH_USE_FLOAT128
+typedef __float128 largest_float;
+#define BOOST_MATH_LARGEST_FLOAT_C(x) x##Q
+template <>
+struct numeric_traits<__float128>
+{
+   static const int digits = 113;
+   static const int digits10 = 33;
+   static const int max_exponent = 16384;
+   static const bool is_specialized = true;
+};
+#elif LDBL_DIG > DBL_DIG
+typedef long double largest_float;
+#define BOOST_MATH_LARGEST_FLOAT_C(x) x##L
+#else
+typedef double largest_float;
+#define BOOST_MATH_LARGEST_FLOAT_C(x) x
+#endif
+
+template <class T>
+BOOST_MATH_GPU_ENABLED constexpr T make_big_value(largest_float v, const char*, std::true_type const&, std::false_type const&) BOOST_MATH_NOEXCEPT(T)
+{
+   return static_cast<T>(v);
+}
+template <class T>
+BOOST_MATH_GPU_ENABLED constexpr T make_big_value(largest_float v, const char*, std::true_type const&, std::true_type const&) BOOST_MATH_NOEXCEPT(T)
+{
+   return static_cast<T>(v);
+}
+#ifndef BOOST_MATH_NO_LEXICAL_CAST
+template <class T>
+inline T make_big_value(largest_float, const char* s, std::false_type const&, std::false_type const&)
+{
+   return boost::lexical_cast<T>(s);
+}
+#else
+template <typename T>
+inline T make_big_value(largest_float, const char*, std::false_type const&, std::false_type const&)
+{
+   static_assert(sizeof(T) == 0, "Type is unsupported in standalone mode. Please disable and try again.");
+}
+#endif
+template <class T>
+inline constexpr T make_big_value(largest_float, const char* s, std::false_type const&, std::true_type const&) BOOST_MATH_NOEXCEPT(T)
+{
+   return T(s);
+}
+
+//
+// For constants which might fit in a long double (if it's big enough):
+//
+// Note that gcc-13 has std::is_convertible<long double, std::float64_t>::value false, likewise
+// std::is_constructible<std::float64_t, long double>::value, even though the conversions do
+// actually work.  Workaround is the || std::is_floating_point<T>::value part which thankfully is true.
+//
+#define BOOST_MATH_BIG_CONSTANT(T, D, x)\
+   boost::math::tools::make_big_value<T>(\
+      BOOST_MATH_LARGEST_FLOAT_C(x), \
+      BOOST_MATH_STRINGIZE(x), \
+      std::integral_constant<bool, (std::is_convertible<boost::math::tools::largest_float, T>::value || std::is_floating_point<T>::value) && \
+      ((D <= boost::math::tools::numeric_traits<boost::math::tools::largest_float>::digits) \
+          || std::is_floating_point<T>::value \
+          || (boost::math::tools::numeric_traits<T>::is_specialized && \
+          (boost::math::tools::numeric_traits<T>::digits10 <= boost::math::tools::numeric_traits<boost::math::tools::largest_float>::digits10))) >(), \
+      std::is_constructible<T, const char*>())
+//
+// For constants too huge for any conceivable long double (and which generate compiler errors if we try and declare them as such):
+//
+#define BOOST_MATH_HUGE_CONSTANT(T, D, x)\
+   boost::math::tools::make_big_value<T>(0.0L, BOOST_MATH_STRINGIZE(x), \
+   std::integral_constant<bool, std::is_floating_point<T>::value || (boost::math::tools::numeric_traits<T>::is_specialized && boost::math::tools::numeric_traits<T>::max_exponent <= boost::math::tools::numeric_traits<boost::math::tools::largest_float>::max_exponent && boost::math::tools::numeric_traits<T>::digits <= boost::math::tools::numeric_traits<boost::math::tools::largest_float>::digits)>(), \
+   std::is_constructible<T, const char*>())
+
+}}} // namespaces
+
+#endif // BOOST_MATH_HAS_NVRTC
+
+#endif
+

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

@@ -0,0 +1,96 @@
+//  (C) Copyright Nick Thompson 2018.
+//  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_TOOLS_BIVARIATE_STATISTICS_HPP
+#define BOOST_MATH_TOOLS_BIVARIATE_STATISTICS_HPP
+
+#include <iterator>
+#include <tuple>
+#include <limits>
+#include <boost/math/tools/assert.hpp>
+#include <boost/math/tools/header_deprecated.hpp>
+
+BOOST_MATH_HEADER_DEPRECATED("<boost/math/statistics/bivariate_statistics.hpp>");
+
+namespace boost{ namespace math{ namespace tools {
+
+template<class Container>
+auto means_and_covariance(Container const & u, Container const & v)
+{
+    using Real = typename Container::value_type;
+    using std::size;
+    BOOST_MATH_ASSERT_MSG(size(u) == size(v), "The size of each vector must be the same to compute covariance.");
+    BOOST_MATH_ASSERT_MSG(size(u) > 0, "Computing covariance requires at least one sample.");
+
+    // See Equation III.9 of "Numerically Stable, Single-Pass, Parallel Statistics Algorithms", Bennet et al.
+    Real cov = 0;
+    Real mu_u = u[0];
+    Real mu_v = v[0];
+
+    for(size_t i = 1; i < size(u); ++i)
+    {
+        Real u_tmp = (u[i] - mu_u)/(i+1);
+        Real v_tmp = v[i] - mu_v;
+        cov += i*u_tmp*v_tmp;
+        mu_u = mu_u + u_tmp;
+        mu_v = mu_v + v_tmp/(i+1);
+    }
+
+    return std::make_tuple(mu_u, mu_v, cov/size(u));
+}
+
+template<class Container>
+auto covariance(Container const & u, Container const & v)
+{
+    auto [mu_u, mu_v, cov] = boost::math::tools::means_and_covariance(u, v);
+    return cov;
+}
+
+template<class Container>
+auto correlation_coefficient(Container const & u, Container const & v)
+{
+    using Real = typename Container::value_type;
+    using std::size;
+    BOOST_MATH_ASSERT_MSG(size(u) == size(v), "The size of each vector must be the same to compute covariance.");
+    BOOST_MATH_ASSERT_MSG(size(u) > 0, "Computing covariance requires at least two samples.");
+
+    Real cov = 0;
+    Real mu_u = u[0];
+    Real mu_v = v[0];
+    Real Qu = 0;
+    Real Qv = 0;
+
+    for(size_t i = 1; i < size(u); ++i)
+    {
+        Real u_tmp = u[i] - mu_u;
+        Real v_tmp = v[i] - 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);
+    }
+
+    // If one dataset is constant, then they have no correlation:
+    // 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::numeric_limits<Real>::quiet_NaN();
+    }
+
+    // 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 rho;
+}
+
+}}}
+#endif