/////////////////////////////////////////////////////////////////////////////// // Copyright 2013 Nikhar Agrawal // Copyright 2013 Christopher Kormanyos // Copyright 2013 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_BERNOULLI_B2N_2013_05_30_HPP_ #define _BOOST_BERNOULLI_B2N_2013_05_30_HPP_ #include #include #include namespace boost { namespace math { namespace detail { template OutputIterator bernoulli_number_imp(OutputIterator out, std::size_t start, std::size_t n, const Policy& pol, const mpl::int_& tag) { for(std::size_t i = start; (i <= max_bernoulli_b2n::value) && (i < start + n); ++i) { *out = unchecked_bernoulli_imp(i, tag); ++out; } for(std::size_t i = (std::max)(static_cast(max_bernoulli_b2n::value + 1), start); i < start + n; ++i) { // We must overflow: *out = (i & 1 ? 1 : -1) * policies::raise_overflow_error("boost::math::bernoulli_b2n<%1%>(n)", 0, T(i), pol); ++out; } return out; } template OutputIterator bernoulli_number_imp(OutputIterator out, std::size_t start, std::size_t n, const Policy& pol, const mpl::int_<0>& tag) { for(std::size_t i = start; (i <= max_bernoulli_b2n::value) && (i < start + n); ++i) { *out = unchecked_bernoulli_imp(i, tag); ++out; } // // Short circuit return so we don't grab the mutex below unless we have to: // if(start + n <= max_bernoulli_b2n::value) return out; return get_bernoulli_numbers_cache().copy_bernoulli_numbers(out, start, n, pol); } } // namespace detail template inline T bernoulli_b2n(const int i, const Policy &pol) { typedef mpl::int_::value> tag_type; if(i < 0) return policies::raise_domain_error("boost::math::bernoulli_b2n<%1%>", "Index should be >= 0 but got %1%", T(i), pol); T result = static_cast(0); // The = 0 is just to silence compiler warnings :-( boost::math::detail::bernoulli_number_imp(&result, static_cast(i), 1u, pol, tag_type()); return result; } template inline T bernoulli_b2n(const int i) { return boost::math::bernoulli_b2n(i, policies::policy<>()); } template inline OutputIterator bernoulli_b2n(const int start_index, const unsigned number_of_bernoullis_b2n, OutputIterator out_it, const Policy& pol) { typedef mpl::int_::value> tag_type; if(start_index < 0) { *out_it = policies::raise_domain_error("boost::math::bernoulli_b2n<%1%>", "Index should be >= 0 but got %1%", T(start_index), pol); return ++out_it; } return boost::math::detail::bernoulli_number_imp(out_it, start_index, number_of_bernoullis_b2n, pol, tag_type()); } template inline OutputIterator bernoulli_b2n(const int start_index, const unsigned number_of_bernoullis_b2n, OutputIterator out_it) { return boost::math::bernoulli_b2n(start_index, number_of_bernoullis_b2n, out_it, policies::policy<>()); } template inline T tangent_t2n(const int i, const Policy &pol) { if(i < 0) return policies::raise_domain_error("boost::math::tangent_t2n<%1%>", "Index should be >= 0 but got %1%", T(i), pol); T result; boost::math::detail::get_bernoulli_numbers_cache().copy_tangent_numbers(&result, i, 1, pol); return result; } template inline T tangent_t2n(const int i) { return boost::math::tangent_t2n(i, policies::policy<>()); } template inline OutputIterator tangent_t2n(const int start_index, const unsigned number_of_tangent_t2n, OutputIterator out_it, const Policy& pol) { if(start_index < 0) { *out_it = policies::raise_domain_error("boost::math::tangent_t2n<%1%>", "Index should be >= 0 but got %1%", T(start_index), pol); return ++out_it; } return boost::math::detail::get_bernoulli_numbers_cache().copy_tangent_numbers(out_it, start_index, number_of_tangent_t2n, pol); } template inline OutputIterator tangent_t2n(const int start_index, const unsigned number_of_tangent_t2n, OutputIterator out_it) { return boost::math::tangent_t2n(start_index, number_of_tangent_t2n, out_it, policies::policy<>()); } } } // namespace boost::math #endif // _BOOST_BERNOULLI_B2N_2013_05_30_HPP_