]>
Commit | Line | Data |
---|---|---|
1 | ||
2 | /////////////////////////////////////////////////////////////////////////////// | |
3 | // Copyright 2013 Nikhar Agrawal | |
4 | // Copyright 2013 Christopher Kormanyos | |
5 | // Copyright 2013 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_BERNOULLI_B2N_2013_05_30_HPP_ | |
12 | #define _BOOST_BERNOULLI_B2N_2013_05_30_HPP_ | |
13 | ||
14 | #include <boost/math/special_functions/math_fwd.hpp> | |
15 | #include <boost/math/special_functions/detail/unchecked_bernoulli.hpp> | |
16 | #include <boost/math/special_functions/detail/bernoulli_details.hpp> | |
17 | ||
18 | namespace boost { namespace math { | |
19 | ||
20 | namespace detail { | |
21 | ||
22 | template <class T, class OutputIterator, class Policy, int N> | |
23 | OutputIterator bernoulli_number_imp(OutputIterator out, std::size_t start, std::size_t n, const Policy& pol, const mpl::int_<N>& tag) | |
24 | { | |
25 | for(std::size_t i = start; (i <= max_bernoulli_b2n<T>::value) && (i < start + n); ++i) | |
26 | { | |
27 | *out = unchecked_bernoulli_imp<T>(i, tag); | |
28 | ++out; | |
29 | } | |
30 | ||
31 | for(std::size_t i = (std::max)(static_cast<std::size_t>(max_bernoulli_b2n<T>::value + 1), start); i < start + n; ++i) | |
32 | { | |
33 | // We must overflow: | |
34 | *out = (i & 1 ? 1 : -1) * policies::raise_overflow_error<T>("boost::math::bernoulli_b2n<%1%>(n)", 0, T(i), pol); | |
35 | ++out; | |
36 | } | |
37 | return out; | |
38 | } | |
39 | ||
40 | template <class T, class OutputIterator, class Policy> | |
41 | OutputIterator bernoulli_number_imp(OutputIterator out, std::size_t start, std::size_t n, const Policy& pol, const mpl::int_<0>& tag) | |
42 | { | |
43 | for(std::size_t i = start; (i <= max_bernoulli_b2n<T>::value) && (i < start + n); ++i) | |
44 | { | |
45 | *out = unchecked_bernoulli_imp<T>(i, tag); | |
46 | ++out; | |
47 | } | |
48 | // | |
49 | // Short circuit return so we don't grab the mutex below unless we have to: | |
50 | // | |
51 | if(start + n <= max_bernoulli_b2n<T>::value) | |
52 | return out; | |
53 | ||
54 | return get_bernoulli_numbers_cache<T, Policy>().copy_bernoulli_numbers(out, start, n, pol); | |
55 | } | |
56 | ||
57 | } // namespace detail | |
58 | ||
59 | template <class T, class Policy> | |
60 | inline T bernoulli_b2n(const int i, const Policy &pol) | |
61 | { | |
62 | typedef mpl::int_<detail::bernoulli_imp_variant<T>::value> tag_type; | |
63 | if(i < 0) | |
64 | return policies::raise_domain_error<T>("boost::math::bernoulli_b2n<%1%>", "Index should be >= 0 but got %1%", T(i), pol); | |
65 | ||
66 | T result = static_cast<T>(0); // The = 0 is just to silence compiler warnings :-( | |
67 | boost::math::detail::bernoulli_number_imp<T>(&result, static_cast<std::size_t>(i), 1u, pol, tag_type()); | |
68 | return result; | |
69 | } | |
70 | ||
71 | template <class T> | |
72 | inline T bernoulli_b2n(const int i) | |
73 | { | |
74 | return boost::math::bernoulli_b2n<T>(i, policies::policy<>()); | |
75 | } | |
76 | ||
77 | template <class T, class OutputIterator, class Policy> | |
78 | inline OutputIterator bernoulli_b2n(const int start_index, | |
79 | const unsigned number_of_bernoullis_b2n, | |
80 | OutputIterator out_it, | |
81 | const Policy& pol) | |
82 | { | |
83 | typedef mpl::int_<detail::bernoulli_imp_variant<T>::value> tag_type; | |
84 | if(start_index < 0) | |
85 | { | |
86 | *out_it = policies::raise_domain_error<T>("boost::math::bernoulli_b2n<%1%>", "Index should be >= 0 but got %1%", T(start_index), pol); | |
87 | return ++out_it; | |
88 | } | |
89 | ||
90 | return boost::math::detail::bernoulli_number_imp<T>(out_it, start_index, number_of_bernoullis_b2n, pol, tag_type()); | |
91 | } | |
92 | ||
93 | template <class T, class OutputIterator> | |
94 | inline OutputIterator bernoulli_b2n(const int start_index, | |
95 | const unsigned number_of_bernoullis_b2n, | |
96 | OutputIterator out_it) | |
97 | { | |
98 | return boost::math::bernoulli_b2n<T, OutputIterator>(start_index, number_of_bernoullis_b2n, out_it, policies::policy<>()); | |
99 | } | |
100 | ||
101 | template <class T, class Policy> | |
102 | inline T tangent_t2n(const int i, const Policy &pol) | |
103 | { | |
104 | if(i < 0) | |
105 | return policies::raise_domain_error<T>("boost::math::tangent_t2n<%1%>", "Index should be >= 0 but got %1%", T(i), pol); | |
106 | ||
107 | T result; | |
108 | boost::math::detail::get_bernoulli_numbers_cache<T, Policy>().copy_tangent_numbers(&result, i, 1, pol); | |
109 | return result; | |
110 | } | |
111 | ||
112 | template <class T> | |
113 | inline T tangent_t2n(const int i) | |
114 | { | |
115 | return boost::math::tangent_t2n<T>(i, policies::policy<>()); | |
116 | } | |
117 | ||
118 | template <class T, class OutputIterator, class Policy> | |
119 | inline OutputIterator tangent_t2n(const int start_index, | |
120 | const unsigned number_of_tangent_t2n, | |
121 | OutputIterator out_it, | |
122 | const Policy& pol) | |
123 | { | |
124 | if(start_index < 0) | |
125 | { | |
126 | *out_it = policies::raise_domain_error<T>("boost::math::tangent_t2n<%1%>", "Index should be >= 0 but got %1%", T(start_index), pol); | |
127 | return ++out_it; | |
128 | } | |
129 | ||
130 | return boost::math::detail::get_bernoulli_numbers_cache<T, Policy>().copy_tangent_numbers(out_it, start_index, number_of_tangent_t2n, pol); | |
131 | } | |
132 | ||
133 | template <class T, class OutputIterator> | |
134 | inline OutputIterator tangent_t2n(const int start_index, | |
135 | const unsigned number_of_tangent_t2n, | |
136 | OutputIterator out_it) | |
137 | { | |
138 | return boost::math::tangent_t2n<T, OutputIterator>(start_index, number_of_tangent_t2n, out_it, policies::policy<>()); | |
139 | } | |
140 | ||
141 | } } // namespace boost::math | |
142 | ||
143 | #endif // _BOOST_BERNOULLI_B2N_2013_05_30_HPP_ |