contrib/llvm-project/libcxx/include/ratio

   1 // -*- C++ -*-
   2 //===---------------------------- ratio -----------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef _LIBCPP_RATIO
  11 #define _LIBCPP_RATIO
  12
  13 /*
  14     ratio synopsis
  15
  16 namespace std
  17 {
  18
  19 template <intmax_t N, intmax_t D = 1>
  20 class ratio
  21 {
  22 public:
  23     static constexpr intmax_t num;
  24     static constexpr intmax_t den;
  25     typedef ratio<num, den> type;
  26 };
  27
  28 // ratio arithmetic
  29 template <class R1, class R2> using ratio_add = ...;
  30 template <class R1, class R2> using ratio_subtract = ...;
  31 template <class R1, class R2> using ratio_multiply = ...;
  32 template <class R1, class R2> using ratio_divide = ...;
  33
  34 // ratio comparison
  35 template <class R1, class R2> struct ratio_equal;
  36 template <class R1, class R2> struct ratio_not_equal;
  37 template <class R1, class R2> struct ratio_less;
  38 template <class R1, class R2> struct ratio_less_equal;
  39 template <class R1, class R2> struct ratio_greater;
  40 template <class R1, class R2> struct ratio_greater_equal;
  41
  42 // convenience SI typedefs
  43 typedef ratio<1, 1000000000000000000000000> yocto;  // not supported
  44 typedef ratio<1,    1000000000000000000000> zepto;  // not supported
  45 typedef ratio<1,       1000000000000000000> atto;
  46 typedef ratio<1,          1000000000000000> femto;
  47 typedef ratio<1,             1000000000000> pico;
  48 typedef ratio<1,                1000000000> nano;
  49 typedef ratio<1,                   1000000> micro;
  50 typedef ratio<1,                      1000> milli;
  51 typedef ratio<1,                       100> centi;
  52 typedef ratio<1,                        10> deci;
  53 typedef ratio<                       10, 1> deca;
  54 typedef ratio<                      100, 1> hecto;
  55 typedef ratio<                     1000, 1> kilo;
  56 typedef ratio<                  1000000, 1> mega;
  57 typedef ratio<               1000000000, 1> giga;
  58 typedef ratio<            1000000000000, 1> tera;
  59 typedef ratio<         1000000000000000, 1> peta;
  60 typedef ratio<      1000000000000000000, 1> exa;
  61 typedef ratio<   1000000000000000000000, 1> zetta;  // not supported
  62 typedef ratio<1000000000000000000000000, 1> yotta;  // not supported
  63
  64   // 20.11.5, ratio comparison
  65   template <class R1, class R2> inline constexpr bool ratio_equal_v
  66     = ratio_equal<R1, R2>::value;                                       // C++17
  67   template <class R1, class R2> inline constexpr bool ratio_not_equal_v
  68     = ratio_not_equal<R1, R2>::value;                                   // C++17
  69   template <class R1, class R2> inline constexpr bool ratio_less_v
  70     = ratio_less<R1, R2>::value;                                        // C++17
  71   template <class R1, class R2> inline constexpr bool ratio_less_equal_v
  72     = ratio_less_equal<R1, R2>::value;                                  // C++17
  73   template <class R1, class R2> inline constexpr bool ratio_greater_v
  74     = ratio_greater<R1, R2>::value;                                     // C++17
  75   template <class R1, class R2> inline constexpr bool ratio_greater_equal_v
  76     = ratio_greater_equal<R1, R2>::value;                               // C++17
  77 }
  78 */
  79
  80 #include <__config>
  81 #include <cstdint>
  82 #include <climits>
  83 #include <type_traits>
  84
  85 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
  86 #pragma GCC system_header
  87 #endif
  88
  89 _LIBCPP_PUSH_MACROS
  90 #include <__undef_macros>
  91
  92
  93 _LIBCPP_BEGIN_NAMESPACE_STD
  94
  95 // __static_gcd
  96
  97 template <intmax_t _Xp, intmax_t _Yp>
  98 struct __static_gcd
  99 {
 100     static const intmax_t value = __static_gcd<_Yp, _Xp % _Yp>::value;
 101 };
 102
 103 template <intmax_t _Xp>
 104 struct __static_gcd<_Xp, 0>
 105 {
 106     static const intmax_t value = _Xp;
 107 };
 108
 109 template <>
 110 struct __static_gcd<0, 0>
 111 {
 112     static const intmax_t value = 1;
 113 };
 114
 115 // __static_lcm
 116
 117 template <intmax_t _Xp, intmax_t _Yp>
 118 struct __static_lcm
 119 {
 120     static const intmax_t value = _Xp / __static_gcd<_Xp, _Yp>::value * _Yp;
 121 };
 122
 123 template <intmax_t _Xp>
 124 struct __static_abs
 125 {
 126     static const intmax_t value = _Xp < 0 ? -_Xp : _Xp;
 127 };
 128
 129 template <intmax_t _Xp>
 130 struct __static_sign
 131 {
 132     static const intmax_t value = _Xp == 0 ? 0 : (_Xp < 0 ? -1 : 1);
 133 };
 134
 135 template <intmax_t _Xp, intmax_t _Yp, intmax_t = __static_sign<_Yp>::value>
 136 class __ll_add;
 137
 138 template <intmax_t _Xp, intmax_t _Yp>
 139 class __ll_add<_Xp, _Yp, 1>
 140 {
 141     static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
 142     static const intmax_t max = -min;
 143
 144     static_assert(_Xp <= max - _Yp, "overflow in __ll_add");
 145 public:
 146     static const intmax_t value = _Xp + _Yp;
 147 };
 148
 149 template <intmax_t _Xp, intmax_t _Yp>
 150 class __ll_add<_Xp, _Yp, 0>
 151 {
 152 public:
 153     static const intmax_t value = _Xp;
 154 };
 155
 156 template <intmax_t _Xp, intmax_t _Yp>
 157 class __ll_add<_Xp, _Yp, -1>
 158 {
 159     static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
 160     static const intmax_t max = -min;
 161
 162     static_assert(min - _Yp <= _Xp, "overflow in __ll_add");
 163 public:
 164     static const intmax_t value = _Xp + _Yp;
 165 };
 166
 167 template <intmax_t _Xp, intmax_t _Yp, intmax_t = __static_sign<_Yp>::value>
 168 class __ll_sub;
 169
 170 template <intmax_t _Xp, intmax_t _Yp>
 171 class __ll_sub<_Xp, _Yp, 1>
 172 {
 173     static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
 174     static const intmax_t max = -min;
 175
 176     static_assert(min + _Yp <= _Xp, "overflow in __ll_sub");
 177 public:
 178     static const intmax_t value = _Xp - _Yp;
 179 };
 180
 181 template <intmax_t _Xp, intmax_t _Yp>
 182 class __ll_sub<_Xp, _Yp, 0>
 183 {
 184 public:
 185     static const intmax_t value = _Xp;
 186 };
 187
 188 template <intmax_t _Xp, intmax_t _Yp>
 189 class __ll_sub<_Xp, _Yp, -1>
 190 {
 191     static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
 192     static const intmax_t max = -min;
 193
 194     static_assert(_Xp <= max + _Yp, "overflow in __ll_sub");
 195 public:
 196     static const intmax_t value = _Xp - _Yp;
 197 };
 198
 199 template <intmax_t _Xp, intmax_t _Yp>
 200 class __ll_mul
 201 {
 202     static const intmax_t nan = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1));
 203     static const intmax_t min = nan + 1;
 204     static const intmax_t max = -min;
 205     static const intmax_t __a_x = __static_abs<_Xp>::value;
 206     static const intmax_t __a_y = __static_abs<_Yp>::value;
 207
 208     static_assert(_Xp != nan && _Yp != nan && __a_x <= max / __a_y, "overflow in __ll_mul");
 209 public:
 210     static const intmax_t value = _Xp * _Yp;
 211 };
 212
 213 template <intmax_t _Yp>
 214 class __ll_mul<0, _Yp>
 215 {
 216 public:
 217     static const intmax_t value = 0;
 218 };
 219
 220 template <intmax_t _Xp>
 221 class __ll_mul<_Xp, 0>
 222 {
 223 public:
 224     static const intmax_t value = 0;
 225 };
 226
 227 template <>
 228 class __ll_mul<0, 0>
 229 {
 230 public:
 231     static const intmax_t value = 0;
 232 };
 233
 234 // Not actually used but left here in case needed in future maintenance
 235 template <intmax_t _Xp, intmax_t _Yp>
 236 class __ll_div
 237 {
 238     static const intmax_t nan = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1));
 239     static const intmax_t min = nan + 1;
 240     static const intmax_t max = -min;
 241
 242     static_assert(_Xp != nan && _Yp != nan && _Yp != 0, "overflow in __ll_div");
 243 public:
 244     static const intmax_t value = _Xp / _Yp;
 245 };
 246
 247 template <intmax_t _Num, intmax_t _Den = 1>
 248 class _LIBCPP_TEMPLATE_VIS ratio
 249 {
 250     static_assert(__static_abs<_Num>::value >= 0, "ratio numerator is out of range");
 251     static_assert(_Den != 0, "ratio divide by 0");
 252     static_assert(__static_abs<_Den>::value >  0, "ratio denominator is out of range");
 253     static _LIBCPP_CONSTEXPR const intmax_t __na = __static_abs<_Num>::value;
 254     static _LIBCPP_CONSTEXPR const intmax_t __da = __static_abs<_Den>::value;
 255     static _LIBCPP_CONSTEXPR const intmax_t __s = __static_sign<_Num>::value * __static_sign<_Den>::value;
 256     static _LIBCPP_CONSTEXPR const intmax_t __gcd = __static_gcd<__na, __da>::value;
 257 public:
 258     static _LIBCPP_CONSTEXPR const intmax_t num = __s * __na / __gcd;
 259     static _LIBCPP_CONSTEXPR const intmax_t den = __da / __gcd;
 260
 261     typedef ratio<num, den> type;
 262 };
 263
 264 template <intmax_t _Num, intmax_t _Den>
 265 _LIBCPP_CONSTEXPR const intmax_t ratio<_Num, _Den>::num;
 266
 267 template <intmax_t _Num, intmax_t _Den>
 268 _LIBCPP_CONSTEXPR const intmax_t ratio<_Num, _Den>::den;
 269
 270 template <class _Tp>                    struct __is_ratio                     : false_type {};
 271 template <intmax_t _Num, intmax_t _Den> struct __is_ratio<ratio<_Num, _Den> > : true_type  {};
 272
 273 typedef ratio<1LL, 1000000000000000000LL> atto;
 274 typedef ratio<1LL,    1000000000000000LL> femto;
 275 typedef ratio<1LL,       1000000000000LL> pico;
 276 typedef ratio<1LL,          1000000000LL> nano;
 277 typedef ratio<1LL,             1000000LL> micro;
 278 typedef ratio<1LL,                1000LL> milli;
 279 typedef ratio<1LL,                 100LL> centi;
 280 typedef ratio<1LL,                  10LL> deci;
 281 typedef ratio<                 10LL, 1LL> deca;
 282 typedef ratio<                100LL, 1LL> hecto;
 283 typedef ratio<               1000LL, 1LL> kilo;
 284 typedef ratio<            1000000LL, 1LL> mega;
 285 typedef ratio<         1000000000LL, 1LL> giga;
 286 typedef ratio<      1000000000000LL, 1LL> tera;
 287 typedef ratio<   1000000000000000LL, 1LL> peta;
 288 typedef ratio<1000000000000000000LL, 1LL> exa;
 289
 290 template <class _R1, class _R2>
 291 struct __ratio_multiply
 292 {
 293 private:
 294     static const intmax_t __gcd_n1_d2 = __static_gcd<_R1::num, _R2::den>::value;
 295     static const intmax_t __gcd_d1_n2 = __static_gcd<_R1::den, _R2::num>::value;
 296 public:
 297     typedef typename ratio
 298         <
 299             __ll_mul<_R1::num / __gcd_n1_d2, _R2::num / __gcd_d1_n2>::value,
 300             __ll_mul<_R2::den / __gcd_n1_d2, _R1::den / __gcd_d1_n2>::value
 301         >::type type;
 302 };
 303
 304 #ifndef _LIBCPP_CXX03_LANG
 305
 306 template <class _R1, class _R2> using ratio_multiply
 307                                     = typename __ratio_multiply<_R1, _R2>::type;
 308
 309 #else  // _LIBCPP_CXX03_LANG
 310
 311 template <class _R1, class _R2>
 312 struct _LIBCPP_TEMPLATE_VIS ratio_multiply
 313     : public __ratio_multiply<_R1, _R2>::type {};
 314
 315 #endif  // _LIBCPP_CXX03_LANG
 316
 317 template <class _R1, class _R2>
 318 struct __ratio_divide
 319 {
 320 private:
 321     static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
 322     static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
 323 public:
 324     typedef typename ratio
 325         <
 326             __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
 327             __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value
 328         >::type type;
 329 };
 330
 331 #ifndef _LIBCPP_CXX03_LANG
 332
 333 template <class _R1, class _R2> using ratio_divide
 334                                       = typename __ratio_divide<_R1, _R2>::type;
 335
 336 #else  // _LIBCPP_CXX03_LANG
 337
 338 template <class _R1, class _R2>
 339 struct _LIBCPP_TEMPLATE_VIS ratio_divide
 340     : public __ratio_divide<_R1, _R2>::type {};
 341
 342 #endif  // _LIBCPP_CXX03_LANG
 343
 344 template <class _R1, class _R2>
 345 struct __ratio_add
 346 {
 347 private:
 348     static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
 349     static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
 350 public:
 351     typedef typename ratio_multiply
 352         <
 353             ratio<__gcd_n1_n2, _R1::den / __gcd_d1_d2>,
 354             ratio
 355             <
 356                 __ll_add
 357                 <
 358                     __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
 359                     __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value
 360                 >::value,
 361                 _R2::den
 362             >
 363         >::type type;
 364 };
 365
 366 #ifndef _LIBCPP_CXX03_LANG
 367
 368 template <class _R1, class _R2> using ratio_add
 369                                          = typename __ratio_add<_R1, _R2>::type;
 370
 371 #else  // _LIBCPP_CXX03_LANG
 372
 373 template <class _R1, class _R2>
 374 struct _LIBCPP_TEMPLATE_VIS ratio_add
 375     : public __ratio_add<_R1, _R2>::type {};
 376
 377 #endif  // _LIBCPP_CXX03_LANG
 378
 379 template <class _R1, class _R2>
 380 struct __ratio_subtract
 381 {
 382 private:
 383     static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
 384     static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
 385 public:
 386     typedef typename ratio_multiply
 387         <
 388             ratio<__gcd_n1_n2, _R1::den / __gcd_d1_d2>,
 389             ratio
 390             <
 391                 __ll_sub
 392                 <
 393                     __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
 394                     __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value
 395                 >::value,
 396                 _R2::den
 397             >
 398         >::type type;
 399 };
 400
 401 #ifndef _LIBCPP_CXX03_LANG
 402
 403 template <class _R1, class _R2> using ratio_subtract
 404                                     = typename __ratio_subtract<_R1, _R2>::type;
 405
 406 #else  // _LIBCPP_CXX03_LANG
 407
 408 template <class _R1, class _R2>
 409 struct _LIBCPP_TEMPLATE_VIS ratio_subtract
 410     : public __ratio_subtract<_R1, _R2>::type {};
 411
 412 #endif  // _LIBCPP_CXX03_LANG
 413
 414 // ratio_equal
 415
 416 template <class _R1, class _R2>
 417 struct _LIBCPP_TEMPLATE_VIS ratio_equal
 418     : public _LIBCPP_BOOL_CONSTANT((_R1::num == _R2::num && _R1::den == _R2::den)) {};
 419
 420 template <class _R1, class _R2>
 421 struct _LIBCPP_TEMPLATE_VIS ratio_not_equal
 422     : public _LIBCPP_BOOL_CONSTANT((!ratio_equal<_R1, _R2>::value)) {};
 423
 424 // ratio_less
 425
 426 template <class _R1, class _R2, bool _Odd = false,
 427           intmax_t _Q1 = _R1::num / _R1::den, intmax_t _M1 = _R1::num % _R1::den,
 428           intmax_t _Q2 = _R2::num / _R2::den, intmax_t _M2 = _R2::num % _R2::den>
 429 struct __ratio_less1
 430 {
 431     static const bool value = _Odd ? _Q2 < _Q1 : _Q1 < _Q2;
 432 };
 433
 434 template <class _R1, class _R2, bool _Odd, intmax_t _Qp>
 435 struct __ratio_less1<_R1, _R2, _Odd, _Qp, 0, _Qp, 0>
 436 {
 437     static const bool value = false;
 438 };
 439
 440 template <class _R1, class _R2, bool _Odd, intmax_t _Qp, intmax_t _M2>
 441 struct __ratio_less1<_R1, _R2, _Odd, _Qp, 0, _Qp, _M2>
 442 {
 443     static const bool value = !_Odd;
 444 };
 445
 446 template <class _R1, class _R2, bool _Odd, intmax_t _Qp, intmax_t _M1>
 447 struct __ratio_less1<_R1, _R2, _Odd, _Qp, _M1, _Qp, 0>
 448 {
 449     static const bool value = _Odd;
 450 };
 451
 452 template <class _R1, class _R2, bool _Odd, intmax_t _Qp, intmax_t _M1,
 453                                                         intmax_t _M2>
 454 struct __ratio_less1<_R1, _R2, _Odd, _Qp, _M1, _Qp, _M2>
 455 {
 456     static const bool value = __ratio_less1<ratio<_R1::den, _M1>,
 457                                             ratio<_R2::den, _M2>, !_Odd>::value;
 458 };
 459
 460 template <class _R1, class _R2, intmax_t _S1 = __static_sign<_R1::num>::value,
 461                                 intmax_t _S2 = __static_sign<_R2::num>::value>
 462 struct __ratio_less
 463 {
 464     static const bool value = _S1 < _S2;
 465 };
 466
 467 template <class _R1, class _R2>
 468 struct __ratio_less<_R1, _R2, 1LL, 1LL>
 469 {
 470     static const bool value = __ratio_less1<_R1, _R2>::value;
 471 };
 472
 473 template <class _R1, class _R2>
 474 struct __ratio_less<_R1, _R2, -1LL, -1LL>
 475 {
 476     static const bool value = __ratio_less1<ratio<-_R2::num, _R2::den>, ratio<-_R1::num, _R1::den> >::value;
 477 };
 478
 479 template <class _R1, class _R2>
 480 struct _LIBCPP_TEMPLATE_VIS ratio_less
 481     : public _LIBCPP_BOOL_CONSTANT((__ratio_less<_R1, _R2>::value)) {};
 482
 483 template <class _R1, class _R2>
 484 struct _LIBCPP_TEMPLATE_VIS ratio_less_equal
 485     : public _LIBCPP_BOOL_CONSTANT((!ratio_less<_R2, _R1>::value)) {};
 486
 487 template <class _R1, class _R2>
 488 struct _LIBCPP_TEMPLATE_VIS ratio_greater
 489     : public _LIBCPP_BOOL_CONSTANT((ratio_less<_R2, _R1>::value)) {};
 490
 491 template <class _R1, class _R2>
 492 struct _LIBCPP_TEMPLATE_VIS ratio_greater_equal
 493     : public _LIBCPP_BOOL_CONSTANT((!ratio_less<_R1, _R2>::value)) {};
 494
 495 template <class _R1, class _R2>
 496 struct __ratio_gcd
 497 {
 498     typedef ratio<__static_gcd<_R1::num, _R2::num>::value,
 499                   __static_lcm<_R1::den, _R2::den>::value> type;
 500 };
 501
 502 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 503 template <class _R1, class _R2>
 504 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool ratio_equal_v
 505     = ratio_equal<_R1, _R2>::value;
 506
 507 template <class _R1, class _R2>
 508 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool ratio_not_equal_v
 509     = ratio_not_equal<_R1, _R2>::value;
 510
 511 template <class _R1, class _R2>
 512 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool ratio_less_v
 513     = ratio_less<_R1, _R2>::value;
 514
 515 template <class _R1, class _R2>
 516 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool ratio_less_equal_v
 517     = ratio_less_equal<_R1, _R2>::value;
 518
 519 template <class _R1, class _R2>
 520 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool ratio_greater_v
 521     = ratio_greater<_R1, _R2>::value;
 522
 523 template <class _R1, class _R2>
 524 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool ratio_greater_equal_v
 525     = ratio_greater_equal<_R1, _R2>::value;
 526 #endif
 527
 528 _LIBCPP_END_NAMESPACE_STD
 529
 530 _LIBCPP_POP_MACROS
 531
 532 #endif  // _LIBCPP_RATIO