diff options
author | Remko Tronçon <git@el-tramo.be> | 2012-12-23 13:16:26 (GMT) |
---|---|---|
committer | Remko Tronçon <git@el-tramo.be> | 2012-12-23 14:43:26 (GMT) |
commit | 491ddd570a752cf9bda85933bed0c6942e39b1f9 (patch) | |
tree | 10c25c1be8cc08d0497df1dccd56a10fbb30beee /3rdParty/Boost/src/boost/math/common_factor_ct.hpp | |
parent | da7d7a0ca71b80281aa9ff2526290b61ccb0cc60 (diff) | |
download | swift-contrib-491ddd570a752cf9bda85933bed0c6942e39b1f9.zip swift-contrib-491ddd570a752cf9bda85933bed0c6942e39b1f9.tar.bz2 |
Update Boost to 1.52.0.
Change-Id: I1e56bea2600bf2ed9c5b3aba8c4f9d2a0f350e77
Diffstat (limited to '3rdParty/Boost/src/boost/math/common_factor_ct.hpp')
-rw-r--r-- | 3rdParty/Boost/src/boost/math/common_factor_ct.hpp | 180 |
1 files changed, 180 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/math/common_factor_ct.hpp b/3rdParty/Boost/src/boost/math/common_factor_ct.hpp new file mode 100644 index 0000000..848c925 --- /dev/null +++ b/3rdParty/Boost/src/boost/math/common_factor_ct.hpp @@ -0,0 +1,180 @@ +// Boost common_factor_ct.hpp header file ----------------------------------// + +// (C) Copyright Daryle Walker and Stephen Cleary 2001-2002. +// 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) + +// See http://www.boost.org for updates, documentation, and revision history. + +#ifndef BOOST_MATH_COMMON_FACTOR_CT_HPP +#define BOOST_MATH_COMMON_FACTOR_CT_HPP + +#include <boost/math_fwd.hpp> // self include +#include <boost/config.hpp> // for BOOST_STATIC_CONSTANT, etc. +#include <boost/mpl/integral_c.hpp> + +namespace boost +{ +namespace math +{ + +// Implementation details --------------------------------------------------// + +namespace detail +{ +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + // Build GCD with Euclid's recursive algorithm + template < static_gcd_type Value1, static_gcd_type Value2 > + struct static_gcd_helper_t + { + private: + BOOST_STATIC_CONSTANT( static_gcd_type, new_value1 = Value2 ); + BOOST_STATIC_CONSTANT( static_gcd_type, new_value2 = Value1 % Value2 ); + + #ifndef __BORLANDC__ + #define BOOST_DETAIL_GCD_HELPER_VAL(Value) static_cast<static_gcd_type>(Value) + #else + typedef static_gcd_helper_t self_type; + #define BOOST_DETAIL_GCD_HELPER_VAL(Value) (self_type:: Value ) + #endif + + typedef static_gcd_helper_t< BOOST_DETAIL_GCD_HELPER_VAL(new_value1), + BOOST_DETAIL_GCD_HELPER_VAL(new_value2) > next_step_type; + + #undef BOOST_DETAIL_GCD_HELPER_VAL + + public: + BOOST_STATIC_CONSTANT( static_gcd_type, value = next_step_type::value ); + }; + + // Non-recursive case + template < static_gcd_type Value1 > + struct static_gcd_helper_t< Value1, 0UL > + { + BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 ); + }; +#else + // Use inner class template workaround from Peter Dimov + template < static_gcd_type Value1 > + struct static_gcd_helper2_t + { + template < static_gcd_type Value2 > + struct helper + { + BOOST_STATIC_CONSTANT( static_gcd_type, value + = static_gcd_helper2_t<Value2>::BOOST_NESTED_TEMPLATE + helper<Value1 % Value2>::value ); + }; + + template < > + struct helper< 0UL > + { + BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 ); + }; + }; + + // Special case + template < > + struct static_gcd_helper2_t< 0UL > + { + template < static_gcd_type Value2 > + struct helper + { + BOOST_STATIC_CONSTANT( static_gcd_type, value = Value2 ); + }; + }; + + // Build the GCD from the above template(s) + template < static_gcd_type Value1, static_gcd_type Value2 > + struct static_gcd_helper_t + { + BOOST_STATIC_CONSTANT( static_gcd_type, value + = static_gcd_helper2_t<Value1>::BOOST_NESTED_TEMPLATE + helper<Value2>::value ); + }; +#endif + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + // Build the LCM from the GCD + template < static_gcd_type Value1, static_gcd_type Value2 > + struct static_lcm_helper_t + { + typedef static_gcd_helper_t<Value1, Value2> gcd_type; + + BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 / gcd_type::value + * Value2 ); + }; + + // Special case for zero-GCD values + template < > + struct static_lcm_helper_t< 0UL, 0UL > + { + BOOST_STATIC_CONSTANT( static_gcd_type, value = 0UL ); + }; +#else + // Adapt GCD's inner class template workaround for LCM + template < static_gcd_type Value1 > + struct static_lcm_helper2_t + { + template < static_gcd_type Value2 > + struct helper + { + typedef static_gcd_helper_t<Value1, Value2> gcd_type; + + BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 + / gcd_type::value * Value2 ); + }; + + template < > + struct helper< 0UL > + { + BOOST_STATIC_CONSTANT( static_gcd_type, value = 0UL ); + }; + }; + + // Special case + template < > + struct static_lcm_helper2_t< 0UL > + { + template < static_gcd_type Value2 > + struct helper + { + BOOST_STATIC_CONSTANT( static_gcd_type, value = 0UL ); + }; + }; + + // Build the LCM from the above template(s) + template < static_gcd_type Value1, static_gcd_type Value2 > + struct static_lcm_helper_t + { + BOOST_STATIC_CONSTANT( static_gcd_type, value + = static_lcm_helper2_t<Value1>::BOOST_NESTED_TEMPLATE + helper<Value2>::value ); + }; +#endif + +} // namespace detail + + +// Compile-time greatest common divisor evaluator class declaration --------// + +template < static_gcd_type Value1, static_gcd_type Value2 > +struct static_gcd : public mpl::integral_c<static_gcd_type, (detail::static_gcd_helper_t<Value1, Value2>::value) > +{ +}; // boost::math::static_gcd + + +// Compile-time least common multiple evaluator class declaration ----------// + +template < static_gcd_type Value1, static_gcd_type Value2 > +struct static_lcm : public mpl::integral_c<static_gcd_type, (detail::static_lcm_helper_t<Value1, Value2>::value) > +{ +}; // boost::math::static_lcm + + +} // namespace math +} // namespace boost + + +#endif // BOOST_MATH_COMMON_FACTOR_CT_HPP |