]>
Commit | Line | Data |
---|---|---|
1 | ||
2 | /////////////////////////////////////////////////////////////////////////////// | |
3 | // Copyright 2013 Nikhar Agrawal | |
4 | // Copyright 2013 Christopher Kormanyos | |
5 | // Copyright 2014 John Maddock | |
6 | // Copyright 2013 Paul Bristow | |
7 | // Distributed under the Boost | |
8 | // Software License, Version 1.0. (See accompanying file | |
9 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
10 | ||
11 | #ifndef _BOOST_POLYGAMMA_2013_07_30_HPP_ | |
12 | #define _BOOST_POLYGAMMA_2013_07_30_HPP_ | |
13 | ||
14 | #include <boost/math/special_functions/factorials.hpp> | |
15 | #include <boost/math/special_functions/detail/polygamma.hpp> | |
16 | #include <boost/math/special_functions/trigamma.hpp> | |
17 | ||
18 | namespace boost { namespace math { | |
19 | ||
20 | ||
21 | template<class T, class Policy> | |
22 | inline typename tools::promote_args<T>::type polygamma(const int n, T x, const Policy& pol) | |
23 | { | |
24 | // | |
25 | // Filter off special cases right at the start: | |
26 | // | |
27 | if(n == 0) | |
28 | return boost::math::digamma(x, pol); | |
29 | if(n == 1) | |
30 | return boost::math::trigamma(x, pol); | |
31 | // | |
32 | // We've found some standard library functions to misbehave if any FPU exception flags | |
33 | // are set prior to their call, this code will clear those flags, then reset them | |
34 | // on exit: | |
35 | // | |
36 | BOOST_FPU_EXCEPTION_GUARD | |
37 | // | |
38 | // The type of the result - the common type of T and U after | |
39 | // any integer types have been promoted to double: | |
40 | // | |
41 | typedef typename tools::promote_args<T>::type result_type; | |
42 | // | |
43 | // The type used for the calculation. This may be a wider type than | |
44 | // the result in order to ensure full precision: | |
45 | // | |
46 | typedef typename policies::evaluation<result_type, Policy>::type value_type; | |
47 | // | |
48 | // The type of the policy to forward to the actual implementation. | |
49 | // We disable promotion of float and double as that's [possibly] | |
50 | // happened already in the line above. Also reset to the default | |
51 | // any policies we don't use (reduces code bloat if we're called | |
52 | // multiple times with differing policies we don't actually use). | |
53 | // Also normalise the type, again to reduce code bloat in case we're | |
54 | // called multiple times with functionally identical policies that happen | |
55 | // to be different types. | |
56 | // | |
57 | typedef typename policies::normalise< | |
58 | Policy, | |
59 | policies::promote_float<false>, | |
60 | policies::promote_double<false>, | |
61 | policies::discrete_quantile<>, | |
62 | policies::assert_undefined<> >::type forwarding_policy; | |
63 | // | |
64 | // Whew. Now we can make the actual call to the implementation. | |
65 | // Arguments are explicitly cast to the evaluation type, and the result | |
66 | // passed through checked_narrowing_cast which handles things like overflow | |
67 | // according to the policy passed: | |
68 | // | |
69 | return policies::checked_narrowing_cast<result_type, forwarding_policy>( | |
70 | detail::polygamma_imp(n, static_cast<value_type>(x), forwarding_policy()), | |
71 | "boost::math::polygamma<%1%>(int, %1%)"); | |
72 | } | |
73 | ||
74 | template<class T> | |
75 | inline typename tools::promote_args<T>::type polygamma(const int n, T x) | |
76 | { | |
77 | return boost::math::polygamma(n, x, policies::policy<>()); | |
78 | } | |
79 | ||
80 | } } // namespace boost::math | |
81 | ||
82 | #endif // _BOOST_BERNOULLI_2013_05_30_HPP_ | |
83 |