585da50d7d
This PR adds the code of Boost.Math as of version 1.89 into the third-party directory, as discussed in a recent RFC [1]. The goal is for this code to be used as a back-end for the C++17 Math Special Functions. As explained in third-paty/README.md, this code is cleared for usage inside libc++ for the Math Special functions, however the LLVM Foundation should be consulted before using this code anywhere else in the LLVM project, due to the fact that it is under the Boost Software License (as opposed to the usual LLVM license). See the RFC [1] for more details. [1]: https://discourse.llvm.org/t/rfc-libc-taking-a-dependency-on-boost-math-for-the-c-17-math-special-functions
88 lines
2.9 KiB
C++
88 lines
2.9 KiB
C++
// 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)
|
|
|
|
#ifndef BOOST_MATH_SF_BINOMIAL_HPP
|
|
#define BOOST_MATH_SF_BINOMIAL_HPP
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma once
|
|
#endif
|
|
|
|
#include <boost/math/tools/config.hpp>
|
|
#include <boost/math/tools/type_traits.hpp>
|
|
#include <boost/math/special_functions/math_fwd.hpp>
|
|
#include <boost/math/special_functions/factorials.hpp>
|
|
#include <boost/math/special_functions/beta.hpp>
|
|
#include <boost/math/policies/error_handling.hpp>
|
|
|
|
namespace boost{ namespace math{
|
|
|
|
template <class T, class Policy>
|
|
BOOST_MATH_GPU_ENABLED T binomial_coefficient(unsigned n, unsigned k, const Policy& pol)
|
|
{
|
|
static_assert(!boost::math::is_integral<T>::value, "Type T must not be an integral type");
|
|
BOOST_MATH_STD_USING
|
|
constexpr auto function = "boost::math::binomial_coefficient<%1%>(unsigned, unsigned)";
|
|
if(k > n)
|
|
return policies::raise_domain_error<T>(function, "The binomial coefficient is undefined for k > n, but got k = %1%.", static_cast<T>(k), pol);
|
|
T result; // LCOV_EXCL_LINE
|
|
if((k == 0) || (k == n))
|
|
return static_cast<T>(1);
|
|
if((k == 1) || (k == n-1))
|
|
return static_cast<T>(n);
|
|
|
|
if(n <= max_factorial<T>::value)
|
|
{
|
|
// Use fast table lookup:
|
|
result = unchecked_factorial<T>(n);
|
|
result /= unchecked_factorial<T>(n-k);
|
|
result /= unchecked_factorial<T>(k);
|
|
}
|
|
else
|
|
{
|
|
// Use the beta function:
|
|
if(k < n - k)
|
|
result = static_cast<T>(k * boost::math::beta(static_cast<T>(k), static_cast<T>(n-k+1), pol));
|
|
else
|
|
result = static_cast<T>((n - k) * boost::math::beta(static_cast<T>(k+1), static_cast<T>(n-k), pol));
|
|
if(result == 0)
|
|
return policies::raise_overflow_error<T>(function, nullptr, pol);
|
|
result = 1 / result;
|
|
}
|
|
// convert to nearest integer:
|
|
return ceil(result - 0.5f);
|
|
}
|
|
//
|
|
// Type float can only store the first 35 factorials, in order to
|
|
// increase the chance that we can use a table driven implementation
|
|
// we'll promote to double:
|
|
//
|
|
template <>
|
|
BOOST_MATH_GPU_ENABLED inline float binomial_coefficient<float, policies::policy<> >(unsigned n, unsigned k, const policies::policy<>&)
|
|
{
|
|
typedef policies::normalise<
|
|
policies::policy<>,
|
|
policies::promote_float<true>,
|
|
policies::promote_double<false>,
|
|
policies::discrete_quantile<>,
|
|
policies::assert_undefined<> >::type forwarding_policy;
|
|
return policies::checked_narrowing_cast<float, forwarding_policy>(binomial_coefficient<double>(n, k, forwarding_policy()), "boost::math::binomial_coefficient<%1%>(unsigned,unsigned)");
|
|
}
|
|
|
|
template <class T>
|
|
BOOST_MATH_GPU_ENABLED inline T binomial_coefficient(unsigned n, unsigned k)
|
|
{
|
|
return binomial_coefficient<T>(n, k, policies::policy<>());
|
|
}
|
|
|
|
} // namespace math
|
|
} // namespace boost
|
|
|
|
|
|
#endif // BOOST_MATH_SF_BINOMIAL_HPP
|
|
|
|
|
|
|