/usr/include/boost/math/special_functions
Edit: /usr/include/boost/math/special_functions/polygamma.hpp (3209B)
///////////////////////////////////////////////////////////////////////////////
// Copyright 2013 Nikhar Agrawal
// Copyright 2013 Christopher Kormanyos
// Copyright 2014 John Maddock
// Copyright 2013 Paul Bristow
// 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_POLYGAMMA_2013_07_30_HPP_
#define _BOOST_POLYGAMMA_2013_07_30_HPP_
#include
#include
#include
namespace boost { namespace math {
template
inline typename tools::promote_args::type polygamma(const int n, T x, const Policy& pol)
{
//
// Filter off special cases right at the start:
//
if(n == 0)
return boost::math::digamma(x, pol);
if(n == 1)
return boost::math::trigamma(x, pol);
//
// We've found some standard library functions to misbehave if any FPU exception flags
// are set prior to their call, this code will clear those flags, then reset them
// on exit:
//
BOOST_FPU_EXCEPTION_GUARD
//
// The type of the result - the common type of T and U after
// any integer types have been promoted to double:
//
typedef typename tools::promote_args::type result_type;
//
// The type used for the calculation. This may be a wider type than
// the result in order to ensure full precision:
//
typedef typename policies::evaluation::type value_type;
//
// The type of the policy to forward to the actual implementation.
// We disable promotion of float and double as that's [possibly]
// happened already in the line above. Also reset to the default
// any policies we don't use (reduces code bloat if we're called
// multiple times with differing policies we don't actually use).
// Also normalise the type, again to reduce code bloat in case we're
// called multiple times with functionally identical policies that happen
// to be different types.
//
typedef typename policies::normalise<
Policy,
policies::promote_float,
policies::promote_double,
policies::discrete_quantile<>,
policies::assert_undefined<> >::type forwarding_policy;
//
// Whew. Now we can make the actual call to the implementation.
// Arguments are explicitly cast to the evaluation type, and the result
// passed through checked_narrowing_cast which handles things like overflow
// according to the policy passed:
//
return policies::checked_narrowing_cast(
detail::polygamma_imp(n, static_cast(x), forwarding_policy()),
"boost::math::polygamma<%1%>(int, %1%)");
}
template
inline typename tools::promote_args::type polygamma(const int n, T x)
{
return boost::math::polygamma(n, x, policies::policy<>());
}
} } // namespace boost::math
#endif // _BOOST_BERNOULLI_2013_05_30_HPP_