visus
/
toolchain-gcc-arm-embedded
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
Branch: main
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'main'
${ noResults }
toolchain-gcc-arm-embedded/arm-none-eabi/include/c++/10.2.1/ratio

577 lines
20KB
Raw Permalink Blame History 

  1. // ratio -*- C++ -*-

  2. 

  3. // Copyright (C) 2008-2020 Free Software Foundation, Inc.

  4. //

  5. // This file is part of the GNU ISO C++ Library.  This library is free

  6. // software; you can redistribute it and/or modify it under the

  7. // terms of the GNU General Public License as published by the

  8. // Free Software Foundation; either version 3, or (at your option)

  9. // any later version.

  10. 

  11. // This library is distributed in the hope that it will be useful,

  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of

  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  14. // GNU General Public License for more details.

  15. 

  16. // Under Section 7 of GPL version 3, you are granted additional

  17. // permissions described in the GCC Runtime Library Exception, version

  18. // 3.1, as published by the Free Software Foundation.

  19. 

  20. // You should have received a copy of the GNU General Public License and

  21. // a copy of the GCC Runtime Library Exception along with this program;

  22. // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

  23. // <http://www.gnu.org/licenses/>.

  24. 

  25. /** @file include/ratio

  26.  *  This is a Standard C++ Library header.

  27.  *  @ingroup ratio

  28.  */

  29. 

  30. #ifndef _GLIBCXX_RATIO

  31. #define _GLIBCXX_RATIO 1

  32. 

  33. #pragma GCC system_header

  34. 

  35. #if __cplusplus < 201103L

  36. # include <bits/c++0x_warning.h>

  37. #else

  38. 

  39. #include <type_traits>

  40. #include <cstdint>		// intmax_t, uintmax_t

  41. 

  42. namespace std _GLIBCXX_VISIBILITY(default)

  43. {

  44. _GLIBCXX_BEGIN_NAMESPACE_VERSION

  45. 

  46.   /**

  47.    * @defgroup ratio Rational Arithmetic

  48.    * @ingroup utilities

  49.    *

  50.    * Compile time representation of finite rational numbers.

  51.    * @{

  52.    */

  53. 

  54.   /// @cond undocumented

  55. 

  56.   template<intmax_t _Pn>

  57.     struct __static_sign

  58.     : integral_constant<intmax_t, (_Pn < 0) ? -1 : 1>

  59.     { };

  60. 

  61.   template<intmax_t _Pn>

  62.     struct __static_abs

  63.     : integral_constant<intmax_t, _Pn * __static_sign<_Pn>::value>

  64.     { };

  65. 

  66.   template<intmax_t _Pn, intmax_t _Qn>

  67.     struct __static_gcd

  68.     : __static_gcd<_Qn, (_Pn % _Qn)>

  69.     { };

  70. 

  71.   template<intmax_t _Pn>

  72.     struct __static_gcd<_Pn, 0>

  73.     : integral_constant<intmax_t, __static_abs<_Pn>::value>

  74.     { };

  75. 

  76.   template<intmax_t _Qn>

  77.     struct __static_gcd<0, _Qn>

  78.     : integral_constant<intmax_t, __static_abs<_Qn>::value>

  79.     { };

  80. 

  81.   // Let c = 2^(half # of bits in an intmax_t)

  82.   // then we find a1, a0, b1, b0 s.t. N = a1*c + a0, M = b1*c + b0

  83.   // The multiplication of N and M becomes,

  84.   // N * M = (a1 * b1)c^2 + (a0 * b1 + b0 * a1)c + a0 * b0

  85.   // Multiplication is safe if each term and the sum of the terms

  86.   // is representable by intmax_t.

  87.   template<intmax_t _Pn, intmax_t _Qn>

  88.     struct __safe_multiply

  89.     {

  90.     private:

  91.       static const uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);

  92. 

  93.       static const uintmax_t __a0 = __static_abs<_Pn>::value % __c;

  94.       static const uintmax_t __a1 = __static_abs<_Pn>::value / __c;

  95.       static const uintmax_t __b0 = __static_abs<_Qn>::value % __c;

  96.       static const uintmax_t __b1 = __static_abs<_Qn>::value / __c;

  97. 

  98.       static_assert(__a1 == 0 || __b1 == 0,

  99. 		    "overflow in multiplication");

  100.       static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1),

  101. 		    "overflow in multiplication");

  102.       static_assert(__b0 * __a0 <= __INTMAX_MAX__,

  103. 		    "overflow in multiplication");

  104.       static_assert((__a0 * __b1 + __b0 * __a1) * __c

  105. 		    <= __INTMAX_MAX__ -  __b0 * __a0,

  106. 		    "overflow in multiplication");

  107. 

  108.     public:

  109.       static const intmax_t value = _Pn * _Qn;

  110.     };

  111. 

  112.   // Some double-precision utilities, where numbers are represented as

  113.   // __hi*2^(8*sizeof(uintmax_t)) + __lo.

  114.   template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>

  115.     struct __big_less

  116.     : integral_constant<bool, (__hi1 < __hi2

  117. 			       || (__hi1 == __hi2 && __lo1 < __lo2))>

  118.     { };

  119. 

  120.   template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>

  121.     struct __big_add

  122.     {

  123.       static constexpr uintmax_t __lo = __lo1 + __lo2;

  124.       static constexpr uintmax_t __hi = (__hi1 + __hi2 +

  125. 					 (__lo1 + __lo2 < __lo1)); // carry

  126.     };

  127. 

  128.   // Subtract a number from a bigger one.

  129.   template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>

  130.     struct __big_sub

  131.     {

  132.       static_assert(!__big_less<__hi1, __lo1, __hi2, __lo2>::value,

  133. 		    "Internal library error");

  134.       static constexpr uintmax_t __lo = __lo1 - __lo2;

  135.       static constexpr uintmax_t __hi = (__hi1 - __hi2 -

  136. 					 (__lo1 < __lo2)); // carry

  137.     };

  138. 

  139.   // Same principle as __safe_multiply.

  140.   template<uintmax_t __x, uintmax_t __y>

  141.     struct __big_mul

  142.     {

  143.     private:

  144.       static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);

  145.       static constexpr uintmax_t __x0 = __x % __c;

  146.       static constexpr uintmax_t __x1 = __x / __c;

  147.       static constexpr uintmax_t __y0 = __y % __c;

  148.       static constexpr uintmax_t __y1 = __y / __c;

  149.       static constexpr uintmax_t __x0y0 = __x0 * __y0;

  150.       static constexpr uintmax_t __x0y1 = __x0 * __y1;

  151.       static constexpr uintmax_t __x1y0 = __x1 * __y0;

  152.       static constexpr uintmax_t __x1y1 = __x1 * __y1;

  153.       static constexpr uintmax_t __mix = __x0y1 + __x1y0; // possible carry...

  154.       static constexpr uintmax_t __mix_lo = __mix * __c;

  155.       static constexpr uintmax_t __mix_hi

  156.       = __mix / __c + ((__mix < __x0y1) ? __c : 0); // ... added here

  157.       typedef __big_add<__mix_hi, __mix_lo, __x1y1, __x0y0> _Res;

  158.     public:

  159.       static constexpr uintmax_t __hi = _Res::__hi;

  160.       static constexpr uintmax_t __lo = _Res::__lo;

  161.     };

  162. 

  163.   // Adapted from __udiv_qrnnd_c in longlong.h

  164.   // This version assumes that the high bit of __d is 1.

  165.   template<uintmax_t __n1, uintmax_t __n0, uintmax_t __d>

  166.     struct __big_div_impl

  167.     {

  168.     private:

  169.       static_assert(__d >= (uintmax_t(1) << (sizeof(intmax_t) * 8 - 1)),

  170. 		    "Internal library error");

  171.       static_assert(__n1 < __d, "Internal library error");

  172.       static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);

  173.       static constexpr uintmax_t __d1 = __d / __c;

  174.       static constexpr uintmax_t __d0 = __d % __c;

  175. 

  176.       static constexpr uintmax_t __q1x = __n1 / __d1;

  177.       static constexpr uintmax_t __r1x = __n1 % __d1;

  178.       static constexpr uintmax_t __m = __q1x * __d0;

  179.       static constexpr uintmax_t __r1y = __r1x * __c + __n0 / __c;

  180.       static constexpr uintmax_t __r1z = __r1y + __d;

  181.       static constexpr uintmax_t __r1

  182.       = ((__r1y < __m) ? ((__r1z >= __d) && (__r1z < __m))

  183. 	 ? (__r1z + __d) : __r1z : __r1y) - __m;

  184.       static constexpr uintmax_t __q1

  185.       = __q1x - ((__r1y < __m)

  186. 		 ? ((__r1z >= __d) && (__r1z < __m)) ? 2 : 1 : 0);

  187.       static constexpr uintmax_t __q0x = __r1 / __d1;

  188.       static constexpr uintmax_t __r0x = __r1 % __d1;

  189.       static constexpr uintmax_t __n = __q0x * __d0;

  190.       static constexpr uintmax_t __r0y = __r0x * __c + __n0 % __c;

  191.       static constexpr uintmax_t __r0z = __r0y + __d;

  192.       static constexpr uintmax_t __r0

  193.       = ((__r0y < __n) ? ((__r0z >= __d) && (__r0z < __n))

  194. 	 ? (__r0z + __d) : __r0z : __r0y) - __n;

  195.       static constexpr uintmax_t __q0

  196.       = __q0x - ((__r0y < __n) ? ((__r0z >= __d)

  197. 				  && (__r0z < __n)) ? 2 : 1 : 0);

  198. 

  199.     public:

  200.       static constexpr uintmax_t __quot = __q1 * __c + __q0;

  201.       static constexpr uintmax_t __rem = __r0;

  202. 

  203.     private:

  204.       typedef __big_mul<__quot, __d> _Prod;

  205.       typedef __big_add<_Prod::__hi, _Prod::__lo, 0, __rem> _Sum;

  206.       static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0,

  207. 		    "Internal library error");

  208.   };

  209. 

  210.   template<uintmax_t __n1, uintmax_t __n0, uintmax_t __d>

  211.     struct __big_div

  212.     {

  213.     private:

  214.       static_assert(__d != 0, "Internal library error");

  215.       static_assert(sizeof (uintmax_t) == sizeof (unsigned long long),

  216. 		    "This library calls __builtin_clzll on uintmax_t, which "

  217. 		    "is unsafe on your platform. Please complain to "

  218. 		    "http://gcc.gnu.org/bugzilla/");

  219.       static constexpr int __shift = __builtin_clzll(__d);

  220.       static constexpr int __coshift_ = sizeof(uintmax_t) * 8 - __shift;

  221.       static constexpr int __coshift = (__shift != 0) ? __coshift_ : 0;

  222.       static constexpr uintmax_t __c1 = uintmax_t(1) << __shift;

  223.       static constexpr uintmax_t __c2 = uintmax_t(1) << __coshift;

  224.       static constexpr uintmax_t __new_d = __d * __c1;

  225.       static constexpr uintmax_t __new_n0 = __n0 * __c1;

  226.       static constexpr uintmax_t __n1_shifted = (__n1 % __d) * __c1;

  227.       static constexpr uintmax_t __n0_top = (__shift != 0) ? (__n0 / __c2) : 0;

  228.       static constexpr uintmax_t __new_n1 = __n1_shifted + __n0_top;

  229.       typedef __big_div_impl<__new_n1, __new_n0, __new_d> _Res;

  230. 

  231.     public:

  232.       static constexpr uintmax_t __quot_hi = __n1 / __d;

  233.       static constexpr uintmax_t __quot_lo = _Res::__quot;

  234.       static constexpr uintmax_t __rem = _Res::__rem / __c1;

  235. 

  236.     private:

  237.       typedef __big_mul<__quot_lo, __d> _P0;

  238.       typedef __big_mul<__quot_hi, __d> _P1;

  239.       typedef __big_add<_P0::__hi, _P0::__lo, _P1::__lo, __rem> _Sum;

  240.       // No overflow.

  241.       static_assert(_P1::__hi == 0, "Internal library error");

  242.       static_assert(_Sum::__hi >= _P0::__hi, "Internal library error");

  243.       // Matches the input data.

  244.       static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0,

  245. 		    "Internal library error");

  246.       static_assert(__rem < __d, "Internal library error");

  247.     };

  248. 

  249.   /// @endcond

  250. 

  251.   /**

  252.    *  @brief Provides compile-time rational arithmetic.

  253.    *

  254.    *  This class template represents any finite rational number with a

  255.    *  numerator and denominator representable by compile-time constants of

  256.    *  type intmax_t. The ratio is simplified when instantiated.

  257.    *

  258.    *  For example:

  259.    *  @code

  260.    *    std::ratio<7,-21>::num == -1;

  261.    *    std::ratio<7,-21>::den == 3;

  262.    *  @endcode

  263.    *

  264.   */

  265.   template<intmax_t _Num, intmax_t _Den = 1>

  266.     struct ratio

  267.     {

  268.       static_assert(_Den != 0, "denominator cannot be zero");

  269.       static_assert(_Num >= -__INTMAX_MAX__ && _Den >= -__INTMAX_MAX__,

  270. 		    "out of range");

  271. 

  272.       // Note: sign(N) * abs(N) == N

  273.       static constexpr intmax_t num =

  274.         _Num * __static_sign<_Den>::value / __static_gcd<_Num, _Den>::value;

  275. 

  276.       static constexpr intmax_t den =

  277.         __static_abs<_Den>::value / __static_gcd<_Num, _Den>::value;

  278. 

  279.       typedef ratio<num, den> type;

  280.     };

  281. 

  282.   template<intmax_t _Num, intmax_t _Den>

  283.     constexpr intmax_t ratio<_Num, _Den>::num;

  284. 

  285.   template<intmax_t _Num, intmax_t _Den>

  286.     constexpr intmax_t ratio<_Num, _Den>::den;

  287. 

  288.   /// @cond undocumented

  289. 

  290.   template<typename _R1, typename _R2>

  291.     struct __ratio_multiply

  292.     {

  293.     private:

  294.       static const intmax_t __gcd1 =

  295.         __static_gcd<_R1::num, _R2::den>::value;

  296.       static const intmax_t __gcd2 =

  297.         __static_gcd<_R2::num, _R1::den>::value;

  298. 

  299.     public:

  300.       typedef ratio<

  301.         __safe_multiply<(_R1::num / __gcd1),

  302.                         (_R2::num / __gcd2)>::value,

  303.         __safe_multiply<(_R1::den / __gcd2),

  304.                         (_R2::den / __gcd1)>::value> type;

  305. 

  306.       static constexpr intmax_t num = type::num;

  307.       static constexpr intmax_t den = type::den;

  308.     };

  309. 

  310.   template<typename _R1, typename _R2>

  311.     constexpr intmax_t __ratio_multiply<_R1, _R2>::num;

  312. 

  313.   template<typename _R1, typename _R2>

  314.     constexpr intmax_t __ratio_multiply<_R1, _R2>::den;

  315. 

  316.   /// @endcond

  317. 

  318.   /// ratio_multiply

  319.   template<typename _R1, typename _R2>

  320.     using ratio_multiply = typename __ratio_multiply<_R1, _R2>::type;

  321. 

  322.   /// @cond undocumented

  323. 

  324.   template<typename _R1, typename _R2>

  325.     struct __ratio_divide

  326.     {

  327.       static_assert(_R2::num != 0, "division by 0");

  328. 

  329.       typedef typename __ratio_multiply<

  330.         _R1,

  331.         ratio<_R2::den, _R2::num>>::type type;

  332. 

  333.       static constexpr intmax_t num = type::num;

  334.       static constexpr intmax_t den = type::den;

  335.     };

  336. 

  337.   template<typename _R1, typename _R2>

  338.     constexpr intmax_t __ratio_divide<_R1, _R2>::num;

  339. 

  340.   template<typename _R1, typename _R2>

  341.     constexpr intmax_t __ratio_divide<_R1, _R2>::den;

  342. 

  343.   /// @endcond

  344. 

  345.   /// ratio_divide

  346.   template<typename _R1, typename _R2>

  347.     using ratio_divide = typename __ratio_divide<_R1, _R2>::type;

  348. 

  349.   /// ratio_equal

  350.   template<typename _R1, typename _R2>

  351.     struct ratio_equal

  352.     : integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den>

  353.     { };

  354. 

  355.   /// ratio_not_equal

  356.   template<typename _R1, typename _R2>

  357.     struct ratio_not_equal

  358.     : integral_constant<bool, !ratio_equal<_R1, _R2>::value>

  359.     { };

  360. 

  361.   /// @cond undocumented

  362. 

  363.   // Both numbers are positive.

  364.   template<typename _R1, typename _R2,

  365.            typename _Left = __big_mul<_R1::num,_R2::den>,

  366.            typename _Right = __big_mul<_R2::num,_R1::den> >

  367.     struct __ratio_less_impl_1

  368.     : integral_constant<bool, __big_less<_Left::__hi, _Left::__lo,

  369.            _Right::__hi, _Right::__lo>::value>

  370.     { };

  371. 

  372.   template<typename _R1, typename _R2,

  373. 	   bool = (_R1::num == 0 || _R2::num == 0

  374. 		   || (__static_sign<_R1::num>::value

  375. 		       != __static_sign<_R2::num>::value)),

  376. 	   bool = (__static_sign<_R1::num>::value == -1

  377. 		   && __static_sign<_R2::num>::value == -1)>

  378.     struct __ratio_less_impl

  379.     : __ratio_less_impl_1<_R1, _R2>::type

  380.     { };

  381. 

  382.   template<typename _R1, typename _R2>

  383.     struct __ratio_less_impl<_R1, _R2, true, false>

  384.     : integral_constant<bool, _R1::num < _R2::num>

  385.     { };

  386. 

  387.   template<typename _R1, typename _R2>

  388.     struct __ratio_less_impl<_R1, _R2, false, true>

  389.     : __ratio_less_impl_1<ratio<-_R2::num, _R2::den>,

  390.            ratio<-_R1::num, _R1::den> >::type

  391.     { };

  392. 

  393.   /// @endcond

  394. 

  395.   /// ratio_less

  396.   template<typename _R1, typename _R2>

  397.     struct ratio_less

  398.     : __ratio_less_impl<_R1, _R2>::type

  399.     { };

  400. 

  401.   /// ratio_less_equal

  402.   template<typename _R1, typename _R2>

  403.     struct ratio_less_equal

  404.     : integral_constant<bool, !ratio_less<_R2, _R1>::value>

  405.     { };

  406. 

  407.   /// ratio_greater

  408.   template<typename _R1, typename _R2>

  409.     struct ratio_greater

  410.     : integral_constant<bool, ratio_less<_R2, _R1>::value>

  411.     { };

  412. 

  413.   /// ratio_greater_equal

  414.   template<typename _R1, typename _R2>

  415.     struct ratio_greater_equal

  416.     : integral_constant<bool, !ratio_less<_R1, _R2>::value>

  417.     { };

  418. 

  419. #if __cplusplus > 201402L

  420.   template <typename _R1, typename _R2>

  421.     inline constexpr bool ratio_equal_v = ratio_equal<_R1, _R2>::value;

  422.   template <typename _R1, typename _R2>

  423.     inline constexpr bool ratio_not_equal_v = ratio_not_equal<_R1, _R2>::value;

  424.   template <typename _R1, typename _R2>

  425.     inline constexpr bool ratio_less_v = ratio_less<_R1, _R2>::value;

  426.   template <typename _R1, typename _R2>

  427.     inline constexpr bool ratio_less_equal_v =

  428.       ratio_less_equal<_R1, _R2>::value;

  429.   template <typename _R1, typename _R2>

  430.     inline constexpr bool ratio_greater_v = ratio_greater<_R1, _R2>::value;

  431.   template <typename _R1, typename _R2>

  432.     inline constexpr bool ratio_greater_equal_v

  433.     = ratio_greater_equal<_R1, _R2>::value;

  434. #endif // C++17

  435. 

  436.   /// @cond undocumented

  437. 

  438.   template<typename _R1, typename _R2,

  439.       bool = (_R1::num >= 0),

  440.       bool = (_R2::num >= 0),

  441.       bool = ratio_less<ratio<__static_abs<_R1::num>::value, _R1::den>,

  442.         ratio<__static_abs<_R2::num>::value, _R2::den> >::value>

  443.     struct __ratio_add_impl

  444.     {

  445.     private:

  446.       typedef typename __ratio_add_impl<

  447.         ratio<-_R1::num, _R1::den>,

  448.         ratio<-_R2::num, _R2::den> >::type __t;

  449.     public:

  450.       typedef ratio<-__t::num, __t::den> type;

  451.     };

  452. 

  453.   // True addition of nonnegative numbers.

  454.   template<typename _R1, typename _R2, bool __b>

  455.     struct __ratio_add_impl<_R1, _R2, true, true, __b>

  456.     {

  457.     private:

  458.       static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value;

  459.       static constexpr uintmax_t __d2 = _R2::den / __g;

  460.       typedef __big_mul<_R1::den, __d2> __d;

  461.       typedef __big_mul<_R1::num, _R2::den / __g> __x;

  462.       typedef __big_mul<_R2::num, _R1::den / __g> __y;

  463.       typedef __big_add<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n;

  464.       static_assert(__n::__hi >= __x::__hi, "Internal library error");

  465.       typedef __big_div<__n::__hi, __n::__lo, __g> __ng;

  466.       static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value;

  467.       typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final;

  468.       static_assert(__n_final::__rem == 0, "Internal library error");

  469.       static_assert(__n_final::__quot_hi == 0 &&

  470.         __n_final::__quot_lo <= __INTMAX_MAX__, "overflow in addition");

  471.       typedef __big_mul<_R1::den / __g2, __d2> __d_final;

  472.       static_assert(__d_final::__hi == 0 &&

  473.         __d_final::__lo <= __INTMAX_MAX__, "overflow in addition");

  474.     public:

  475.       typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;

  476.     };

  477. 

  478.   template<typename _R1, typename _R2>

  479.     struct __ratio_add_impl<_R1, _R2, false, true, true>

  480.     : __ratio_add_impl<_R2, _R1>

  481.     { };

  482. 

  483.   // True subtraction of nonnegative numbers yielding a nonnegative result.

  484.   template<typename _R1, typename _R2>

  485.     struct __ratio_add_impl<_R1, _R2, true, false, false>

  486.     {

  487.     private:

  488.       static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value;

  489.       static constexpr uintmax_t __d2 = _R2::den / __g;

  490.       typedef __big_mul<_R1::den, __d2> __d;

  491.       typedef __big_mul<_R1::num, _R2::den / __g> __x;

  492.       typedef __big_mul<-_R2::num, _R1::den / __g> __y;

  493.       typedef __big_sub<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n;

  494.       typedef __big_div<__n::__hi, __n::__lo, __g> __ng;

  495.       static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value;

  496.       typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final;

  497.       static_assert(__n_final::__rem == 0, "Internal library error");

  498.       static_assert(__n_final::__quot_hi == 0 &&

  499.         __n_final::__quot_lo <= __INTMAX_MAX__, "overflow in addition");

  500.       typedef __big_mul<_R1::den / __g2, __d2> __d_final;

  501.       static_assert(__d_final::__hi == 0 &&

  502.         __d_final::__lo <= __INTMAX_MAX__, "overflow in addition");

  503.     public:

  504.       typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;

  505.     };

  506. 

  507.   template<typename _R1, typename _R2>

  508.     struct __ratio_add

  509.     {

  510.       typedef typename __ratio_add_impl<_R1, _R2>::type type;

  511.       static constexpr intmax_t num = type::num;

  512.       static constexpr intmax_t den = type::den;

  513.     };

  514. 

  515.   template<typename _R1, typename _R2>

  516.     constexpr intmax_t __ratio_add<_R1, _R2>::num;

  517. 

  518.   template<typename _R1, typename _R2>

  519.     constexpr intmax_t __ratio_add<_R1, _R2>::den;

  520. 

  521.   /// @endcond

  522. 

  523.   /// ratio_add

  524.   template<typename _R1, typename _R2>

  525.     using ratio_add = typename __ratio_add<_R1, _R2>::type;

  526. 

  527.   /// @cond undocumented

  528. 

  529.   template<typename _R1, typename _R2>

  530.     struct __ratio_subtract

  531.     {

  532.       typedef typename __ratio_add<

  533.         _R1,

  534.         ratio<-_R2::num, _R2::den>>::type type;

  535. 

  536.       static constexpr intmax_t num = type::num;

  537.       static constexpr intmax_t den = type::den;

  538.     };

  539. 

  540.   template<typename _R1, typename _R2>

  541.     constexpr intmax_t __ratio_subtract<_R1, _R2>::num;

  542. 

  543.   template<typename _R1, typename _R2>

  544.     constexpr intmax_t __ratio_subtract<_R1, _R2>::den;

  545. 

  546.   /// @endcond

  547. 

  548.   /// ratio_subtract

  549.   template<typename _R1, typename _R2>

  550.     using ratio_subtract = typename __ratio_subtract<_R1, _R2>::type;

  551. 

  552. 

  553.   typedef ratio<1,       1000000000000000000> atto;

  554.   typedef ratio<1,          1000000000000000> femto;

  555.   typedef ratio<1,             1000000000000> pico;

  556.   typedef ratio<1,                1000000000> nano;

  557.   typedef ratio<1,                   1000000> micro;

  558.   typedef ratio<1,                      1000> milli;

  559.   typedef ratio<1,                       100> centi;

  560.   typedef ratio<1,                        10> deci;

  561.   typedef ratio<                       10, 1> deca;

  562.   typedef ratio<                      100, 1> hecto;

  563.   typedef ratio<                     1000, 1> kilo;

  564.   typedef ratio<                  1000000, 1> mega;

  565.   typedef ratio<               1000000000, 1> giga;

  566.   typedef ratio<            1000000000000, 1> tera;

  567.   typedef ratio<         1000000000000000, 1> peta;

  568.   typedef ratio<      1000000000000000000, 1> exa;

  569. 

  570.   // @} group ratio

  571. _GLIBCXX_END_NAMESPACE_VERSION

  572. } // namespace

  573. 

  574. #endif // C++11

  575. 

  576. #endif //_GLIBCXX_RATIO