N-archive/suyu
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu.git synced 2024-12-25 18:00:59 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
suyu/externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/ratio.hpp
Crimson-Hawk f1e4595ebf Initial commit
2024-03-05 16:42:40 +08:00

293 lines
8.7 KiB
C++
Executable file
Raw Blame History

// ratio.hpp ---------------------------------------------------------------//
// Copyright 2008 Howard Hinnant
// Copyright 2008 Beman Dawes
// Copyright 2009 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
/*
This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
Many thanks to Howard for making his code available under the Boost license.
The original code was modified to conform to Boost conventions and to section
20.4 Compile-time rational arithmetic [ratio], of the C++ committee working
paper N2798.
See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
time2_demo contained this comment:
Much thanks to Andrei Alexandrescu,
Walter Brown,
Peter Dimov,
Jeff Garland,
Terry Golubiewski,
Daniel Krugler,
Anthony Williams.
*/
// The way overflow is managed for ratio_less is taken from llvm/libcxx/include/ratio
#ifndef BOOST_RATIO_RATIO_HPP
#define BOOST_RATIO_RATIO_HPP
#include <boost/ratio/config.hpp>
#include <boost/ratio/detail/mpl/abs.hpp>
#include <boost/ratio/detail/mpl/sign.hpp>
#include <boost/ratio/detail/mpl/gcd.hpp>
#include <boost/ratio/detail/mpl/lcm.hpp>
#include <cstdlib>
#include <climits>
#include <limits>
#include <boost/cstdint.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/core/enable_if.hpp>
#include <boost/integer_traits.hpp>
#include <boost/ratio/ratio_fwd.hpp>
#include <boost/ratio/detail/overflow_helpers.hpp>
#ifdef BOOST_RATIO_EXTENSIONS
#include <boost/rational.hpp>
#include <boost/ratio/mpl/rational_c_tag.hpp>
#endif
//
// We simply cannot include this header on gcc without getting copious warnings of the kind:
//
// boost/integer.hpp:77:30: warning: use of C99 long long integer constant
//
// And yet there is no other reasonable implementation, so we declare this a system header
// to suppress these warnings.
//
#if defined(__GNUC__) && (__GNUC__ >= 4)
#pragma GCC system_header
#endif
namespace boost
{
//----------------------------------------------------------------------------//
// //
// 20.6.1 Class template ratio [ratio.ratio] //
// //
//----------------------------------------------------------------------------//
template <boost::intmax_t N, boost::intmax_t D>
class ratio
{
static const boost::intmax_t ABS_N = mpl::abs_c<boost::intmax_t, N>::value;
static const boost::intmax_t ABS_D = mpl::abs_c<boost::intmax_t, D>::value;
BOOST_RATIO_STATIC_ASSERT(ABS_N >= 0, BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE, ());
BOOST_RATIO_STATIC_ASSERT(ABS_D > 0, BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE, ());
BOOST_RATIO_STATIC_ASSERT(D != 0, BOOST_RATIO_DIVIDE_BY_0 , ());
static const boost::intmax_t SIGN_N = mpl::sign_c<boost::intmax_t,N>::value
* mpl::sign_c<boost::intmax_t,D>::value;
static const boost::intmax_t GCD = mpl::gcd_c<boost::intmax_t, ABS_N, ABS_D>::value;
public:
BOOST_STATIC_CONSTEXPR boost::intmax_t num = SIGN_N * ABS_N / GCD;
BOOST_STATIC_CONSTEXPR boost::intmax_t den = ABS_D / GCD;
#ifdef BOOST_RATIO_EXTENSIONS
typedef mpl::rational_c_tag tag;
typedef boost::rational<boost::intmax_t> value_type;
typedef boost::intmax_t num_type;
typedef boost::intmax_t den_type;
ratio()
{}
template <boost::intmax_t _N2, boost::intmax_t _D2>
ratio(const ratio<_N2, _D2>&,
typename enable_if_c
<
(ratio<_N2, _D2>::num == num &&
ratio<_N2, _D2>::den == den)
>::type* = 0)
{}
template <boost::intmax_t _N2, boost::intmax_t _D2>
typename enable_if_c
<
(ratio<_N2, _D2>::num == num &&
ratio<_N2, _D2>::den == den),
ratio&
>::type
operator=(const ratio<_N2, _D2>&) {return *this;}
static value_type value() {return value_type(num,den);}
value_type operator()() const {return value();}
#endif
typedef ratio<num, den> type;
};
#if defined(BOOST_NO_CXX11_CONSTEXPR)
template <boost::intmax_t N, boost::intmax_t D>
const boost::intmax_t ratio<N, D>::num;
template <boost::intmax_t N, boost::intmax_t D>
const boost::intmax_t ratio<N, D>::den;
#endif
//----------------------------------------------------------------------------//
// //
// 20.6.2 Arithmetic on ratio types [ratio.arithmetic] //
// //
//----------------------------------------------------------------------------//
template <class R1, class R2>
struct ratio_add
: boost::ratio_detail::ratio_add<R1, R2>::type
{
};
template <class R1, class R2>
struct ratio_subtract
: boost::ratio_detail::ratio_subtract<R1, R2>::type
{
};
template <class R1, class R2>
struct ratio_multiply
: boost::ratio_detail::ratio_multiply<R1, R2>::type
{
};
template <class R1, class R2>
struct ratio_divide
: boost::ratio_detail::ratio_divide<R1, R2>::type
{
};
//----------------------------------------------------------------------------//
// //
// 20.6.3 Comparision of ratio types [ratio.comparison] //
// //
//----------------------------------------------------------------------------//
// ratio_equal
template <class R1, class R2>
struct ratio_equal
: public boost::integral_constant<bool,
(R1::num == R2::num && R1::den == R2::den)>
{};
template <class R1, class R2>
struct ratio_not_equal
: public boost::integral_constant<bool, !ratio_equal<R1, R2>::value>
{};
// ratio_less
template <class R1, class R2>
struct ratio_less
: boost::integral_constant<bool, boost::ratio_detail::ratio_less<R1, R2>::value>
{};
template <class R1, class R2>
struct ratio_less_equal
: boost::integral_constant<bool, !ratio_less<R2, R1>::value>
{};
template <class R1, class R2>
struct ratio_greater
: boost::integral_constant<bool, ratio_less<R2, R1>::value>
{};
template <class R1, class R2>
struct ratio_greater_equal
: boost::integral_constant<bool, !ratio_less<R1, R2>::value>
{};
template <class R1, class R2>
struct ratio_gcd :
ratio<mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value,
mpl::lcm_c<boost::intmax_t, R1::den, R2::den>::value>::type
{
};
//----------------------------------------------------------------------------//
// //
// More arithmetic on ratio types [ratio.arithmetic] //
// //
//----------------------------------------------------------------------------//
#ifdef BOOST_RATIO_EXTENSIONS
template <class R>
struct ratio_negate
: ratio<-R::num, R::den>::type
{
};
template <class R>
struct ratio_abs
: ratio<mpl::abs_c<boost::intmax_t, R::num>::value, R::den>::type
{
};
template <class R>
struct ratio_sign
: mpl::sign_c<boost::intmax_t, R::num>
{
};
template <class R>
struct ratio_inverse
: ratio<R::den, R::num>::type
{
};
template <class R1, class R2>
struct ratio_lcm :
ratio<mpl::lcm_c<boost::intmax_t, R1::num, R2::num>::value,
mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value>::type
{
};
template <class R1, class R2>
struct ratio_modulo :
ratio<(R1::num * R2::den) % (R2::num * R1::den), R1::den * R2::den>::type
{
};
namespace detail {
template <class R1, class R2, bool r1ltr2>
struct ratio_min : R1 {};
template <class R1, class R2>
struct ratio_min<R1,R2,false> : R2 {};
template <class R1, class R2, bool r1ltr2>
struct ratio_max : R2 {};
template <class R1, class R2>
struct ratio_max<R1,R2,false> : R1 {};
}
template <class R1, class R2>
struct ratio_min : detail::ratio_min<R1, R2, ratio_less<R1,R2>::value>::type
{
};
template <class R1, class R2>
struct ratio_max : detail::ratio_max<R1, R2, ratio_less<R1,R2>::value>::type
{
};
template<typename R, int p>
struct ratio_power :
ratio_multiply<
typename ratio_power<R, p%2>::type,
typename ratio_power<typename ratio_multiply<R, R>::type, p/2>::type
>::type
{};
template<typename R>
struct ratio_power<R, 0> : ratio<1>::type {};
template<typename R>
struct ratio_power<R, 1> : R {};
template<typename R>
struct ratio_power<R, -1> : ratio_divide<ratio<1>, R>::type {};
#endif
} // namespace boost
#endif // BOOST_RATIO_RATIO_HPP
Reference in a new issue View git blame Copy permalink