x
Yes
No
Do you want to visit DriveHQ English website?
首页
产品服务
价格
免费试用
下载客户端
关于我们
云文件服务
|
云备份服务
|
FTP服务
|
企业邮箱服务
|
网站托管
|
客户端软件
云文件服务
云备份服务
FTP服务
企业级邮箱服务
网站托管
客户端软件
common_factor_rt.hpp - Hosted on DriveHQ Cloud IT Platform
返回上层目录
上传
下载
共享
发布
新建文件夹
新建文件
复制
剪切
删除
粘贴
评论
升级服务
路径: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\math\common_factor_rt.hpp
旋转
特效
属性
历史版本
// Boost common_factor_rt.hpp header file ----------------------------------// // (C) Copyright Daryle Walker and Paul Moore 2001-2002. Permission to copy, // use, modify, sell and distribute this software is granted provided this // copyright notice appears in all copies. This software is provided "as is" // without express or implied warranty, and with no claim as to its suitability // for any purpose. // See http://www.boost.org for updates, documentation, and revision history. #ifndef BOOST_MATH_COMMON_FACTOR_RT_HPP #define BOOST_MATH_COMMON_FACTOR_RT_HPP #include
// self include #include
// for BOOST_NESTED_TEMPLATE, etc. #include
// for std::numeric_limits #include
namespace boost { namespace math { // Forward declarations for function templates -----------------------------// template < typename IntegerType > IntegerType gcd( IntegerType const &a, IntegerType const &b ); template < typename IntegerType > IntegerType lcm( IntegerType const &a, IntegerType const &b ); // Greatest common divisor evaluator class declaration ---------------------// template < typename IntegerType > class gcd_evaluator { public: // Types typedef IntegerType result_type, first_argument_type, second_argument_type; // Function object interface result_type operator ()( first_argument_type const &a, second_argument_type const &b ) const; }; // boost::math::gcd_evaluator // Least common multiple evaluator class declaration -----------------------// template < typename IntegerType > class lcm_evaluator { public: // Types typedef IntegerType result_type, first_argument_type, second_argument_type; // Function object interface result_type operator ()( first_argument_type const &a, second_argument_type const &b ) const; }; // boost::math::lcm_evaluator // Implementation details --------------------------------------------------// namespace detail { // Greatest common divisor for rings (including unsigned integers) template < typename RingType > RingType gcd_euclidean ( RingType a, RingType b ) { // Avoid repeated construction #ifndef __BORLANDC__ RingType const zero = static_cast
( 0 ); #else RingType zero = static_cast
( 0 ); #endif // Reduce by GCD-remainder property [GCD(a,b) == GCD(b,a MOD b)] while ( true ) { if ( a == zero ) return b; b %= a; if ( b == zero ) return a; a %= b; } } // Greatest common divisor for (signed) integers template < typename IntegerType > inline IntegerType gcd_integer ( IntegerType const & a, IntegerType const & b ) { // Avoid repeated construction IntegerType const zero = static_cast
( 0 ); IntegerType const result = gcd_euclidean( a, b ); return ( result < zero ) ? -result : result; } // Greatest common divisor for unsigned binary integers template < typename BuiltInUnsigned > BuiltInUnsigned gcd_binary ( BuiltInUnsigned u, BuiltInUnsigned v ) { if ( u && v ) { // Shift out common factors of 2 unsigned shifts = 0; while ( !(u & 1u) && !(v & 1u) ) { ++shifts; u >>= 1; v >>= 1; } // Start with the still-even one, if any BuiltInUnsigned r[] = { u, v }; unsigned which = static_cast
( u & 1u ); // Whittle down the values via their differences do { #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) while ( !(r[ which ] & 1u) ) { r[ which ] = (r[which] >> 1); } #else // Remove factors of two from the even one while ( !(r[ which ] & 1u) ) { r[ which ] >>= 1; } #endif // Replace the larger of the two with their difference if ( r[!which] > r[which] ) { which ^= 1u; } r[ which ] -= r[ !which ]; } while ( r[which] ); // Shift-in the common factor of 2 to the residues' GCD return r[ !which ] << shifts; } else { // At least one input is zero, return the other // (adding since zero is the additive identity) // or zero if both are zero. return u + v; } } // Least common multiple for rings (including unsigned integers) template < typename RingType > inline RingType lcm_euclidean ( RingType const & a, RingType const & b ) { RingType const zero = static_cast
( 0 ); RingType const temp = gcd_euclidean( a, b ); return ( temp != zero ) ? ( a / temp * b ) : zero; } // Least common multiple for (signed) integers template < typename IntegerType > inline IntegerType lcm_integer ( IntegerType const & a, IntegerType const & b ) { // Avoid repeated construction IntegerType const zero = static_cast
( 0 ); IntegerType const result = lcm_euclidean( a, b ); return ( result < zero ) ? -result : result; } // Function objects to find the best way of computing GCD or LCM #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template < typename T, bool IsSpecialized, bool IsSigned > struct gcd_optimal_evaluator_helper_t { T operator ()( T const &a, T const &b ) { return gcd_euclidean( a, b ); } }; template < typename T > struct gcd_optimal_evaluator_helper_t< T, true, true > { T operator ()( T const &a, T const &b ) { return gcd_integer( a, b ); } }; #else template < bool IsSpecialized, bool IsSigned > struct gcd_optimal_evaluator_helper2_t { template < typename T > struct helper { T operator ()( T const &a, T const &b ) { return gcd_euclidean( a, b ); } }; }; template < > struct gcd_optimal_evaluator_helper2_t< true, true > { template < typename T > struct helper { T operator ()( T const &a, T const &b ) { return gcd_integer( a, b ); } }; }; template < typename T, bool IsSpecialized, bool IsSigned > struct gcd_optimal_evaluator_helper_t : gcd_optimal_evaluator_helper2_t
::BOOST_NESTED_TEMPLATE helper
{ }; #endif template < typename T > struct gcd_optimal_evaluator { T operator ()( T const &a, T const &b ) { typedef ::std::numeric_limits
limits_type; typedef gcd_optimal_evaluator_helper_t
helper_type; helper_type solver; return solver( a, b ); } }; #else // BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS template < typename T > struct gcd_optimal_evaluator { T operator ()( T const &a, T const &b ) { return gcd_integer( a, b ); } }; #endif // Specialize for the built-in integers #define BOOST_PRIVATE_GCD_UF( Ut ) \ template < > struct gcd_optimal_evaluator
\ { Ut operator ()( Ut a, Ut b ) const { return gcd_binary( a, b ); } } BOOST_PRIVATE_GCD_UF( unsigned char ); BOOST_PRIVATE_GCD_UF( unsigned short ); BOOST_PRIVATE_GCD_UF( unsigned ); BOOST_PRIVATE_GCD_UF( unsigned long ); #ifdef BOOST_HAS_LONG_LONG BOOST_PRIVATE_GCD_UF( unsigned long long ); #elif defined(BOOST_HAS_MS_INT64) BOOST_PRIVATE_GCD_UF( unsigned __int64 ); #endif #undef BOOST_PRIVATE_GCD_UF #define BOOST_PRIVATE_GCD_SF( St, Ut ) \ template < > struct gcd_optimal_evaluator
\ { St operator ()( St a, St b ) const { Ut const a_abs = \ static_cast
( a < 0 ? -a : +a ), b_abs = static_cast
( \ b < 0 ? -b : +b ); return static_cast
( \ gcd_optimal_evaluator
()(a_abs, b_abs) ); } } BOOST_PRIVATE_GCD_SF( signed char, unsigned char ); BOOST_PRIVATE_GCD_SF( short, unsigned short ); BOOST_PRIVATE_GCD_SF( int, unsigned ); BOOST_PRIVATE_GCD_SF( long, unsigned long ); BOOST_PRIVATE_GCD_SF( char, unsigned char ); // should work even if unsigned #ifdef BOOST_HAS_LONG_LONG BOOST_PRIVATE_GCD_SF( long long, unsigned long long ); #elif defined(BOOST_HAS_MS_INT64) BOOST_PRIVATE_GCD_SF( __int64, unsigned __int64 ); #endif #undef BOOST_PRIVATE_GCD_SF #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template < typename T, bool IsSpecialized, bool IsSigned > struct lcm_optimal_evaluator_helper_t { T operator ()( T const &a, T const &b ) { return lcm_euclidean( a, b ); } }; template < typename T > struct lcm_optimal_evaluator_helper_t< T, true, true > { T operator ()( T const &a, T const &b ) { return lcm_integer( a, b ); } }; #else template < bool IsSpecialized, bool IsSigned > struct lcm_optimal_evaluator_helper2_t { template < typename T > struct helper { T operator ()( T const &a, T const &b ) { return lcm_euclidean( a, b ); } }; }; template < > struct lcm_optimal_evaluator_helper2_t< true, true > { template < typename T > struct helper { T operator ()( T const &a, T const &b ) { return lcm_integer( a, b ); } }; }; template < typename T, bool IsSpecialized, bool IsSigned > struct lcm_optimal_evaluator_helper_t : lcm_optimal_evaluator_helper2_t
::BOOST_NESTED_TEMPLATE helper
{ }; #endif template < typename T > struct lcm_optimal_evaluator { T operator ()( T const &a, T const &b ) { typedef ::std::numeric_limits
limits_type; typedef lcm_optimal_evaluator_helper_t
helper_type; helper_type solver; return solver( a, b ); } }; #else // BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS template < typename T > struct lcm_optimal_evaluator { T operator ()( T const &a, T const &b ) { return lcm_integer( a, b ); } }; #endif // Functions to find the GCD or LCM in the best way template < typename T > inline T gcd_optimal ( T const & a, T const & b ) { gcd_optimal_evaluator
solver; return solver( a, b ); } template < typename T > inline T lcm_optimal ( T const & a, T const & b ) { lcm_optimal_evaluator
solver; return solver( a, b ); } } // namespace detail // Greatest common divisor evaluator member function definition ------------// template < typename IntegerType > inline typename gcd_evaluator
::result_type gcd_evaluator
::operator () ( first_argument_type const & a, second_argument_type const & b ) const { return detail::gcd_optimal( a, b ); } // Least common multiple evaluator member function definition --------------// template < typename IntegerType > inline typename lcm_evaluator
::result_type lcm_evaluator
::operator () ( first_argument_type const & a, second_argument_type const & b ) const { return detail::lcm_optimal( a, b ); } // Greatest common divisor and least common multiple function definitions --// template < typename IntegerType > inline IntegerType gcd ( IntegerType const & a, IntegerType const & b ) { gcd_evaluator
solver; return solver( a, b ); } template < typename IntegerType > inline IntegerType lcm ( IntegerType const & a, IntegerType const & b ) { lcm_evaluator
solver; return solver( a, b ); } } // namespace math } // namespace boost #endif // BOOST_MATH_COMMON_FACTOR_RT_HPP
common_factor_rt.hpp
网页地址
文件地址
上一页
3/8
下一页
下载
( 13 KB )
Comments
Total ratings:
0
Average rating:
无评论
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.