summaryrefslogtreecommitdiff log msg author committer range
blob: 6b7815d5e07fdebe558bc515836bb137937f5509 (plain)
 ```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 ``` `````` /////////////////////////////////////////////////////////////////////////////// // 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_ ``````