mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2024-12-23 21:25:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

add math tgamma

Browse source
This commit is contained in:
bolero-MURAKAMI 2013-04-22 23:55:30 +09:00
parent f461643582
commit a55c430f09
10 changed files with 224 additions and 40 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
sprout/container/begin.hpp
View file

@ -28,6 +28,12 @@ namespace sprout {
//
// begin
//
// effect:
// ADL callable range_begin(cont) -> range_begin(cont)
// otherwise -> sprout::container_range_traits<Container>::range_begin(cont)
// [default]
// cont.begin()
//
template<typename Container>
inline SPROUT_CONSTEXPR typename sprout::container_traits<Container>::iterator
begin(Container& cont) {
@ -59,14 +65,12 @@ namespace sprout {
template<typename Container>
inline SPROUT_CONSTEXPR typename sprout::container_traits<Container const>::iterator
cbegin(Container const& cont) {
using sprout::container_detail::range_begin;
using sprout_adl::range_begin;
return range_begin(cont);
return sprout::begin(cont);
}
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR typename sprout::container_traits<T const[N]>::iterator
cbegin(T const (& arr)[N]) {
return sprout::container_detail::range_begin(arr);
return sprout::begin(arr);
}
} // namespace sprout

12
sprout/container/end.hpp
View file

@ -28,6 +28,12 @@ namespace sprout {
//
// end
//
// effect:
// ADL callable range_end(cont) -> range_end(cont)
// otherwise -> sprout::container_range_traits<Container>::range_end(cont)
// [default]
// cont.end()
//
template<typename Container>
inline SPROUT_CONSTEXPR typename sprout::container_traits<Container>::iterator
end(Container& cont) {
@ -59,14 +65,12 @@ namespace sprout {
template<typename Container>
inline SPROUT_CONSTEXPR typename sprout::container_traits<Container const>::iterator
cend(Container const& cont) {
using sprout::container_detail::range_end;
using sprout_adl::range_end;
return range_end(cont);
return sprout::end(cont);
}
template<typename T, std::size_t N>
inline SPROUT_CONSTEXPR typename sprout::container_traits<T const[N]>::iterator
cend(T const (& arr)[N]) {
return sprout::container_detail::range_end(arr);
return sprout::end(arr);
}
} // namespace sprout

7
sprout/functional/hash/to_hash.hpp
View file

@ -15,6 +15,13 @@ namespace sprout {
//
// to_hash
//
// effect:
// ADL callable hash_value(v) -> hash_value(v)
// otherwise -> sprout::hash_value_traits<T>::hash_value(v)
// [default]
// v is Arithmetic || Enum || Pointer || Array -> implementation-defined
// otherwise -> std::hash<T>()(v)
//
template<typename T>
inline SPROUT_CONSTEXPR std::size_t
to_hash(T&& v) {

7
sprout/generator/generated_value.hpp
View file

@ -71,6 +71,13 @@ namespace sprout {
//
// generated_value
//
// effect:
// ADL callable get_generated_value(t) -> get_generated_value(t)
// otherwise -> sprout::generators::generator_access_traits<T>::get_generated_value(t)
// [default]
// member callable t.generated_value() -> t.generated_value()
// otherwise -> sprout::tuples::get<0>(t)
//
template<typename T>
inline SPROUT_CONSTEXPR decltype(sprout_generator_detail::call_get_generated_value(std::declval<T>()))
generated_value(T&& t)

7
sprout/generator/next_generator.hpp
View file

@ -71,6 +71,13 @@ namespace sprout {
//
// next_generator
//
// effect:
// ADL callable get_next_generator(t) -> get_next_generator(t)
// otherwise -> sprout::generators::generator_access_traits<T>::get_next_generator(t)
// [default]
// member callable t.next_generator() -> t.next_generator()
// otherwise -> sprout::tuples::get<0>(t)
//
template<typename T>
inline SPROUT_CONSTEXPR decltype(sprout_generator_detail::call_get_next_generator(std::declval<T>()))
next_generator(T&& t)

1
sprout/math/cmath.hpp
View file

@ -8,6 +8,7 @@
#include <sprout/math/exponential.hpp>
#include <sprout/math/power.hpp>
#include <sprout/math/error.hpp>
#include <sprout/math/gamma.hpp>
#include <sprout/math/nearest.hpp>
#include <sprout/math/remainders.hpp>
#include <sprout/math/minmax.hpp>

7
sprout/math/gamma.hpp Normal file
View file

@ -0,0 +1,7 @@
#ifndef SPROUT_MATH_GAMMA_HPP
#define SPROUT_MATH_GAMMA_HPP
#include <sprout/config.hpp>
#include <sprout/math/tgamma.hpp>
#endif // #ifndef SPROUT_MATH_GAMMA_HPP

141
sprout/math/tgamma.hpp Normal file
View file

@ -0,0 +1,141 @@
#ifndef SPROUT_MATH_TGAMMA_HPP
#define SPROUT_MATH_TGAMMA_HPP
#include <cstddef>
#include <limits>
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/math/detail/config.hpp>
#include <sprout/math/detail/float_compute.hpp>
#include <sprout/math/factorial.hpp>
#include <sprout/math/iround.hpp>
#include <sprout/math/trunc.hpp>
#include <sprout/algorithm/clamp.hpp>
#include <sprout/type_traits/enabler_if.hpp>
#include HDR_ALGORITHM_MIN_MAX_SSCRISK_CEL_OR_SPROUT
namespace sprout {
namespace math {
namespace detail {
template<typename T>
inline SPROUT_CONSTEXPR T
tgamma_impl_y(T w) {
return ((((((((((((
-1.99542863674e-7 * w + 1.337767384067e-6) * w
- 2.591225267689e-6) * w - 1.7545539395205e-5) * w
+ 1.45596568617526e-4) * w - 3.60837876648255e-4) * w
- 8.04329819255744e-4) * w + 0.008023273027855346) * w
- 0.017645244547851414) * w - 0.024552490005641278) * w
+ 0.19109110138763841) * w - 0.233093736421782878) * w
- 0.422784335098466784) * w + 0.99999999999999999
;
}
template<typename T>
inline SPROUT_CONSTEXPR T
tgamma_impl_t_pos(T x, std::size_t n, std::size_t last) {
return last - n == 1
? x - static_cast<T>(n)
: sprout::math::detail::tgamma_impl_t_pos(x, n, n + (last - n) / 2)
* sprout::math::detail::tgamma_impl_t_pos(x, n + (last - n) / 2, last)
;
}
template<typename T>
inline SPROUT_CONSTEXPR T
tgamma_impl_t_neg(T x, std::size_t n, std::size_t last) {
return last - n == 1
? x + static_cast<T>(n)
: sprout::math::detail::tgamma_impl_t_neg(x, n, n + (last - n) / 2)
* sprout::math::detail::tgamma_impl_t_neg(x, n + (last - n) / 2, last)
;
}
template<typename T>
inline SPROUT_CONSTEXPR T
tgamma_impl_t_pos_rec(T x, std::size_t n, std::size_t last) {
return last - n == 1
? T(1) / (x - static_cast<T>(n))
: sprout::math::detail::tgamma_impl_t_pos_rec(x, n, n + (last - n) / 2)
* sprout::math::detail::tgamma_impl_t_pos_rec(x, n + (last - n) / 2, last)
;
}
template<typename T>
inline SPROUT_CONSTEXPR T
tgamma_impl_t_neg_rec(T x, std::size_t n, std::size_t last) {
return last - n == 1
? T(1) / (x + static_cast<T>(n))
: sprout::math::detail::tgamma_impl_t_neg_rec(x, n, n + (last - n) / 2)
* sprout::math::detail::tgamma_impl_t_neg_rec(x, n + (last - n) / 2, last)
;
}
template<typename T>
inline SPROUT_CONSTEXPR T
tgamma_impl_2_pos(T x, T y, T t) {
return t == 0 ? std::numeric_limits<T>::infinity()
: (x - T(1)) / y / t
;
}
template<typename T>
inline SPROUT_CONSTEXPR T
tgamma_impl_2_neg(T x, T y, T t) {
return t == 0 ? T(0)
: T(1) / y * t
;
}
template<typename T>
inline SPROUT_CONSTEXPR T
tgamma_impl_1(T x, int n) {
return n == 1 ? (x - T(1)) / sprout::math::detail::tgamma_impl_y(x - (n + 2))
: n == 0 ? T(1) / sprout::math::detail::tgamma_impl_y(x - (n + 2))
: n == static_cast<int>(sprout::math::factorial_limit<T>())
? sprout::math::detail::tgamma_impl_2_pos(x, sprout::math::detail::tgamma_impl_y(x - (n + 2)), sprout::math::detail::tgamma_impl_t_pos_rec(x, 2, n + 1))
: n == -static_cast<int>(sprout::math::factorial_limit<T>())
// ? sprout::math::detail::tgamma_impl_2_neg(x, sprout::math::detail::tgamma_impl_y(x - (n + 2)), sprout::math::detail::tgamma_impl_t_neg_rec(x, 0, -n))
? T(1) / sprout::math::detail::tgamma_impl_y(x - (n + 2)) * sprout::math::detail::tgamma_impl_t_neg_rec(x, 0, -n)
: n > 1 ? (x - T(1)) / sprout::math::detail::tgamma_impl_y(x - (n + 2)) * sprout::math::detail::tgamma_impl_t_pos(x, 2, n + 1)
: T(1) / sprout::math::detail::tgamma_impl_y(x - (n + 2)) / sprout::math::detail::tgamma_impl_t_neg(x, 0, -n)
;
}
template<typename T>
inline SPROUT_CONSTEXPR T
tgamma_impl(T x) {
return sprout::math::detail::tgamma_impl_1(
x,
sprout::clamp(
sprout::math::iround(x - T(2)),
-static_cast<int>(sprout::math::factorial_limit<T>()),
static_cast<int>(sprout::math::factorial_limit<T>())
)
);
}
template<
typename FloatType,
typename sprout::enabler_if<std::is_floating_point<FloatType>::value>::type = sprout::enabler
>
inline SPROUT_CONSTEXPR FloatType
tgamma(FloatType x) {
typedef typename sprout::math::detail::float_compute<FloatType>::type type;
return x == 0 ? std::numeric_limits<FloatType>::infinity()
: x == -std::numeric_limits<FloatType>::infinity() ? std::numeric_limits<FloatType>::quiet_NaN()
: x == std::numeric_limits<FloatType>::infinity() ? std::numeric_limits<FloatType>::infinity()
: x < 0 && x == std::trunc(x) ? std::numeric_limits<FloatType>::quiet_NaN()
: static_cast<FloatType>(sprout::math::detail::tgamma_impl(static_cast<type>(x)))
;
}
template<
typename IntType,
typename sprout::enabler_if<std::is_integral<IntType>::value>::type = sprout::enabler
>
inline SPROUT_CONSTEXPR double
tgamma(IntType x) {
return sprout::math::detail::tgamma(static_cast<double>(x));
}
} // namespace detail
using NS_SPROUT_MATH_DETAIL::tgamma;
} // namespace math
using sprout::math::tgamma;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_TGAMMA_HPP

6
sprout/tuple/tuple/get.hpp
View file

@ -98,6 +98,12 @@ namespace sprout {
//
// get
//
// effect:
// ADL callable tuple_get<I>(t) -> tuple_get<I>(t)
// otherwise -> sprout::tuples::tuple_access_traits<T>::tuple_get<I>(t)
// [default]
// std::get<I>(t)
//
template<std::size_t I, typename T>
inline SPROUT_CONSTEXPR decltype(sprout_tuple_detail::call_tuple_get<I>(std::declval<T>()))
get(T&& t)