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>
bernoulli_b2n(const int i,const Policy & pol)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>
bernoulli_b2n(const int i)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>
bernoulli_b2n(const int start_index,const unsigned number_of_bernoullis_b2n,OutputIterator out_it,const Policy & pol)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>
bernoulli_b2n(const int start_index,const unsigned number_of_bernoullis_b2n,OutputIterator out_it)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>
tangent_t2n(const int i,const Policy & pol)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>
tangent_t2n(const int i)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>
tangent_t2n(const int start_index,const unsigned number_of_tangent_t2n,OutputIterator out_it,const Policy & pol)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>
tangent_t2n(const int start_index,const unsigned number_of_tangent_t2n,OutputIterator out_it)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_
144