/usr/include/boost/math/special_functions
Edit: /usr/include/boost/math/special_functions/bernoulli.hpp (5389B)
///////////////////////////////////////////////////////////////////////////////
// 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 boost::integral_constant& 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 boost::integral_constant& 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 boost::integral_constant::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 boost::integral_constant::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_