libstdc++-v3/include/decimal/decimal.h

   1 // decimal classes -*- C++ -*-
   2
   3 // Copyright (C) 2009 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 bits/decimal.h
  26  *  This is an internal header file, included by other library headers.
  27  *  You should not attempt to use it directly.
  28  */
  29
  30 // ISO/IEC TR 24733
  31 // Written by Janis Johnson <janis187@us.ibm.com>
  32
  33 #ifndef _GLIBCXX_DECIMAL_IMPL
  34 #define _GLIBCXX_DECIMAL_IMPL 1
  35
  36 #pragma GCC system_header
  37
  38 namespace std
  39 {
  40 namespace decimal
  41 {
  42   // ISO/IEC TR 24733  3.2.[234].1  Construct/copy/destroy.
  43
  44   inline decimal32::decimal32(decimal64 r)      : __val(r.__getval()) {}
  45   inline decimal32::decimal32(decimal128 r)     : __val(r.__getval()) {}
  46   inline decimal64::decimal64(decimal32 r)      : __val(r.__getval()) {}
  47   inline decimal64::decimal64(decimal128 r)     : __val(r.__getval()) {}
  48   inline decimal128::decimal128(decimal32 r)    : __val(r.__getval()) {}
  49   inline decimal128::decimal128(decimal64 r)    : __val(r.__getval()) {}
  50
  51   // ISO/IEC TR 24733  3.2.[234].6  Compound assignment.
  52
  53 #define _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC(_Op1, _Op2, _T1, _T2)   \
  54   inline _T1& _T1::operator _Op1(_T2 __rhs)                             \
  55   {                                                                     \
  56     __setval(__getval() _Op2 __rhs.__getval());                         \
  57     return *this;                                                       \
  58   }
  59
  60 #define _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, _T2)   \
  61   inline _T1& _T1::operator _Op1(_T2 __rhs)                             \
  62   {                                                                     \
  63     __setval(__getval() _Op2 __rhs);                                    \
  64     return *this;                                                       \
  65   }
  66
  67 #define _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(_O1, _O2, _T1)             \
  68   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC(_O1,_O2,_T1, decimal32)       \
  69   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC(_O1,_O2,_T1, decimal64)       \
  70   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC(_O1,_O2,_T1, decimal128)      \
  71   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_O1,_O2,_T1, int)             \
  72   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_O1,_O2,_T1, unsigned int)    \
  73   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_O1,_O2,_T1, long)            \
  74   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_O1,_O2,_T1, unsigned long)   \
  75   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_O1,_O2,_T1, long long)       \
  76   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_O1,_O2,_T1, unsigned long long)
  77
  78   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(+=, +, decimal32)
  79   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(-=, -, decimal32)
  80   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(*=, *, decimal32)
  81   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(/=, /, decimal32)
  82
  83   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(+=, +, decimal64)
  84   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(-=, -, decimal64)
  85   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(*=, *, decimal64)
  86   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(/=, /, decimal64)
  87
  88   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(+=, +, decimal128)
  89   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(-=, -, decimal128)
  90   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(*=, *, decimal128)
  91   _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(/=, /, decimal128)
  92
  93 #undef _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC
  94 #undef _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT
  95 #undef _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS
  96
  97   // Extension: Conversion to integral type.
  98
  99   inline long long decimal32_to_long_long(decimal32 __d)
 100   {
 101     return (long long)__d.__getval();
 102   }
 103
 104   inline long long decimal64_to_long_long(decimal64 __d)
 105   {
 106     return (long long)__d.__getval();
 107   }
 108
 109   inline long long decimal128_to_long_long(decimal128 __d)
 110   {
 111     return (long long)__d.__getval();
 112   }
 113
 114   inline long long decimal_to_long_long(decimal32 __d)
 115   {
 116     return (long long)__d.__getval();
 117   }
 118
 119   inline long long decimal_to_long_long(decimal64 __d)
 120   {
 121     return (long long)__d.__getval();
 122   }
 123
 124   inline long long decimal_to_long_long(decimal128 __d)
 125   {
 126     return (long long)__d.__getval();
 127   }
 128
 129   // ISO/IEC TR 24733  3.2.5  Initialization from coefficient and exponent.
 130
 131   static decimal32 make_decimal32(long long __coeff, int __exponent)
 132   {
 133     decimal32 __decexp = 1, __multiplier;
 134
 135     if (__exponent < 0)
 136       {
 137         __multiplier = 1.E-1DF;
 138         __exponent = -__exponent;
 139       }
 140     else
 141       __multiplier = 1.E1DF;
 142
 143     for (int i = 0; i < __exponent; i++)
 144       __decexp *= __multiplier;
 145
 146     return __coeff * __decexp;
 147   }
 148
 149   static decimal32 make_decimal32(unsigned long long __coeff, int __exponent)
 150   {
 151     decimal32 __decexp = 1, __multiplier;
 152
 153     if (__exponent < 0)
 154       {
 155         __multiplier = 1.E-1DF;
 156         __exponent = -__exponent;
 157       }
 158     else
 159       __multiplier = 1.E1DF;
 160
 161     for (int i = 0; i < __exponent; i++)
 162       __decexp *= __multiplier;
 163
 164     return __coeff * __decexp;
 165   }
 166
 167   static decimal64 make_decimal64(long long __coeff, int __exponent)
 168   {
 169     decimal64 __decexp = 1, __multiplier;
 170
 171     if (__exponent < 0)
 172       {
 173         __multiplier = 1.E-1DD;
 174         __exponent = -__exponent;
 175       }
 176     else
 177       __multiplier = 1.E1DD;
 178
 179     for (int i = 0; i < __exponent; i++)
 180       __decexp *= __multiplier;
 181
 182     return __coeff * __decexp;
 183   }
 184
 185   static decimal64 make_decimal64(unsigned long long __coeff, int __exponent)
 186   {
 187     decimal64 __decexp = 1, __multiplier;
 188
 189     if (__exponent < 0)
 190       {
 191         __multiplier = 1.E-1DD;
 192         __exponent = -__exponent;
 193       }
 194     else
 195       __multiplier = 1.E1DD;
 196
 197     for (int i = 0; i < __exponent; i++)
 198       __decexp *= __multiplier;
 199
 200     return __coeff * __decexp;
 201   }
 202
 203   static decimal128 make_decimal128(long long __coeff, int __exponent)
 204   {
 205     decimal128 __decexp = 1, __multiplier;
 206
 207     if (__exponent < 0)
 208       {
 209         __multiplier = 1.E-1DL;
 210         __exponent = -__exponent;
 211       }
 212     else
 213       __multiplier = 1.E1DL;
 214
 215     for (int i = 0; i < __exponent; i++)
 216       __decexp *= __multiplier;
 217
 218     return __coeff * __decexp;
 219   }
 220
 221   static decimal128 make_decimal128(unsigned long long __coeff, int __exponent)
 222   {
 223     decimal128 __decexp = 1, __multiplier;
 224
 225     if (__exponent < 0)
 226       {
 227         __multiplier = 1.E-1DL;
 228         __exponent = -__exponent;
 229       }
 230     else
 231       __multiplier = 1.E1DL;
 232
 233     for (int i = 0; i < __exponent; i++)
 234       __decexp *= __multiplier;
 235
 236     return __coeff * __decexp;
 237   }
 238
 239   // ISO/IEC TR 24733  3.2.6  Conversion to generic floating-point type.
 240
 241   inline float decimal32_to_float(decimal32 __d)
 242   {
 243     return (float)__d.__getval();
 244   }
 245
 246   inline float decimal64_to_float(decimal64 __d)
 247   {
 248     return (float)__d.__getval();
 249   }
 250
 251   inline float decimal128_to_float(decimal128 __d)
 252   {
 253     return (float)__d.__getval();
 254   }
 255
 256   inline float decimal_to_float(decimal32 __d)
 257   {
 258     return (float)__d.__getval();
 259   }
 260
 261   inline float decimal_to_float(decimal64 __d)
 262   {
 263     return (float)__d.__getval();
 264   }
 265
 266   inline float decimal_to_float(decimal128 __d)
 267   {
 268     return (float)__d.__getval();
 269   }
 270
 271   inline double decimal32_to_double(decimal32 __d)
 272   {
 273     return (double)__d.__getval();
 274   }
 275
 276   inline double decimal64_to_double(decimal64 __d)
 277   {
 278     return (double)__d.__getval();
 279   }
 280
 281   inline double decimal128_to_double(decimal128 __d)
 282   {
 283     return (double)__d.__getval();
 284   }
 285
 286   inline double decimal_to_double(decimal32 __d)
 287   {
 288     return (double)__d.__getval();
 289   }
 290
 291   inline double decimal_to_double(decimal64 __d)
 292   {
 293     return (double)__d.__getval();
 294   }
 295
 296   inline double decimal_to_double(decimal128 __d)
 297   {
 298     return (double)__d.__getval();
 299   }
 300
 301   inline long double decimal32_to_long_double(decimal32 __d)
 302   {
 303     return (long double)__d.__getval();
 304   }
 305
 306   inline long double decimal64_to_long_double(decimal64 __d)
 307   {
 308     return (long double)__d.__getval();
 309   }
 310
 311   inline long double decimal128_to_long_double(decimal128 __d)
 312   {
 313     return (long double)__d.__getval();
 314   }
 315
 316   inline long double decimal_to_long_double(decimal32 __d)
 317   {
 318     return (long double)__d.__getval();
 319   }
 320
 321   inline long double decimal_to_long_double(decimal64 __d)
 322   {
 323     return (long double)__d.__getval();
 324   }
 325
 326   inline long double decimal_to_long_double(decimal128 __d)
 327   {
 328     return (long double)__d.__getval();
 329   }
 330
 331   // ISO/IEC TR 24733  3.2.7  Unary arithmetic operators.
 332
 333 #define _DEFINE_DECIMAL_UNARY_OP(_Op, _T)       \
 334   inline _T operator _Op(_T __rhs)              \
 335   {                                             \
 336     _T __tmp;                                   \
 337     __tmp.__setval(0 _Op __rhs.__getval());     \
 338     return __tmp;                               \
 339   }
 340
 341   _DEFINE_DECIMAL_UNARY_OP(+, decimal32)
 342   _DEFINE_DECIMAL_UNARY_OP(+, decimal64)
 343   _DEFINE_DECIMAL_UNARY_OP(+, decimal128)
 344   _DEFINE_DECIMAL_UNARY_OP(-, decimal32)
 345   _DEFINE_DECIMAL_UNARY_OP(-, decimal64)
 346   _DEFINE_DECIMAL_UNARY_OP(-, decimal128)
 347
 348 #undef _DEFINE_DECIMAL_UNARY_OP
 349
 350   // ISO/IEC TR 24733  3.2.8  Binary arithmetic operators.
 351
 352 #define _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(_Op, _T1, _T2, _T3)  \
 353   inline _T1 operator _Op(_T2 lhs, _T3 __rhs)                   \
 354   {                                                             \
 355     _T1 retval;                                                 \
 356     retval.__setval(lhs.__getval() _Op __rhs.__getval());       \
 357     return retval;                                              \
 358   }
 359
 360 #define _DEFINE_DECIMAL_BINARY_OP_BOTH(_Op, _T1, _T2, _T3)      \
 361   inline _T1 operator _Op(_T2 lhs, _T3 __rhs)                   \
 362   {                                                             \
 363     _T1 retval;                                                 \
 364     retval.__setval(lhs.__getval() _Op __rhs.__getval());       \
 365     return retval;                                              \
 366   }
 367
 368 #define _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, _T2)            \
 369   inline _T1 operator _Op(_T1 lhs, _T2 __rhs)                   \
 370   {                                                             \
 371     _T1 retval;                                                 \
 372     retval.__setval(lhs.__getval() _Op __rhs);                  \
 373     return retval;                                              \
 374   }
 375
 376 #define _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, _T2)            \
 377   inline _T1 operator _Op(_T2 lhs, _T1 __rhs)                   \
 378   {                                                             \
 379     _T1 retval;                                                 \
 380     retval.__setval(lhs _Op __rhs.__getval());                  \
 381     return retval;                                              \
 382   }
 383
 384 #define _DEFINE_DECIMAL_BINARY_OP_WITH_INT(_Op,_Tp)             \
 385   _DEFINE_DECIMAL_BINARY_OP_LHS(_Op,_Tp, int);                  \
 386   _DEFINE_DECIMAL_BINARY_OP_LHS(_Op,_Tp, unsigned int);         \
 387   _DEFINE_DECIMAL_BINARY_OP_LHS(_Op,_Tp, long);                 \
 388   _DEFINE_DECIMAL_BINARY_OP_LHS(_Op,_Tp, unsigned long);        \
 389   _DEFINE_DECIMAL_BINARY_OP_LHS(_Op,_Tp, long long);            \
 390   _DEFINE_DECIMAL_BINARY_OP_LHS(_Op,_Tp, unsigned long long);   \
 391   _DEFINE_DECIMAL_BINARY_OP_RHS(_Op,_Tp, int);                  \
 392   _DEFINE_DECIMAL_BINARY_OP_RHS(_Op,_Tp, unsigned int);         \
 393   _DEFINE_DECIMAL_BINARY_OP_RHS(_Op,_Tp, long);                 \
 394   _DEFINE_DECIMAL_BINARY_OP_RHS(_Op,_Tp, unsigned long);        \
 395   _DEFINE_DECIMAL_BINARY_OP_RHS(_Op,_Tp, long long);            \
 396   _DEFINE_DECIMAL_BINARY_OP_RHS(_Op,_Tp, unsigned long long);   \
 397
 398   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal32, decimal32, decimal32)
 399   _DEFINE_DECIMAL_BINARY_OP_WITH_INT(+, decimal32)
 400   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal32, decimal64)
 401   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal32)
 402   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal64)
 403   _DEFINE_DECIMAL_BINARY_OP_WITH_INT(+, decimal64)
 404   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal32, decimal128)
 405   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal64, decimal128)
 406   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal32)
 407   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal64)
 408   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal128)
 409   _DEFINE_DECIMAL_BINARY_OP_WITH_INT(+, decimal128)
 410
 411   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal32, decimal32, decimal32)
 412   _DEFINE_DECIMAL_BINARY_OP_WITH_INT(-, decimal32)
 413   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal32, decimal64)
 414   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal32)
 415   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal64)
 416   _DEFINE_DECIMAL_BINARY_OP_WITH_INT(-, decimal64)
 417   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal32, decimal128)
 418   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal64, decimal128)
 419   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal32)
 420   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal64)
 421   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal128)
 422   _DEFINE_DECIMAL_BINARY_OP_WITH_INT(-, decimal128)
 423
 424   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal32, decimal32, decimal32)
 425   _DEFINE_DECIMAL_BINARY_OP_WITH_INT(*, decimal32)
 426   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal32, decimal64)
 427   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal32)
 428   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal64)
 429   _DEFINE_DECIMAL_BINARY_OP_WITH_INT(*, decimal64)
 430   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal32, decimal128)
 431   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal64, decimal128)
 432   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal32)
 433   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal64)
 434   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal128)
 435   _DEFINE_DECIMAL_BINARY_OP_WITH_INT(*, decimal128)
 436
 437   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal32, decimal32, decimal32)
 438   _DEFINE_DECIMAL_BINARY_OP_WITH_INT(/, decimal32)
 439   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal32, decimal64)
 440   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal32)
 441   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal64)
 442   _DEFINE_DECIMAL_BINARY_OP_WITH_INT(/, decimal64)
 443   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal32, decimal128)
 444   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal64, decimal128)
 445   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal32)
 446   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal64)
 447   _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal128)
 448   _DEFINE_DECIMAL_BINARY_OP_WITH_INT(/, decimal128)
 449
 450 #undef _DEFINE_DECIMAL_BINARY_OP_WITH_DEC
 451 #undef _DEFINE_DECIMAL_BINARY_OP_BOTH
 452 #undef _DEFINE_DECIMAL_BINARY_OP_LHS
 453 #undef _DEFINE_DECIMAL_BINARY_OP_RHS
 454 #undef _DEFINE_DECIMAL_BINARY_OP_WITH_INT
 455
 456   // ISO/IEC TR 24733  3.2.9  Comparison operators.
 457
 458 #define _DEFINE_DECIMAL_COMPARISON_BOTH(_Op, _T1, _T2)  \
 459   inline bool operator _Op(_T1 lhs, _T2 __rhs)          \
 460   {                                                     \
 461     return lhs.__getval() _Op __rhs.__getval();         \
 462   }
 463
 464 #define _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _T1, _T2)   \
 465   inline bool operator _Op(_T1 lhs, _T2 __rhs)          \
 466   {                                                     \
 467     return lhs.__getval() _Op __rhs;                    \
 468   }
 469 #define _DEFINE_DECIMAL_COMPARISON_RHS(_Op, _T1, _T2)   \
 470   inline bool operator _Op(_T1 lhs, _T2 __rhs)          \
 471   {                                                     \
 472     return lhs _Op __rhs.__getval();                    \
 473   }
 474
 475 #define _DEFINE_DECIMAL_COMPARISONS(_Op, _Tp)                   \
 476   _DEFINE_DECIMAL_COMPARISON_BOTH(_Op, _Tp, decimal32)          \
 477   _DEFINE_DECIMAL_COMPARISON_BOTH(_Op, _Tp, decimal64)          \
 478   _DEFINE_DECIMAL_COMPARISON_BOTH(_Op, _Tp, decimal128)         \
 479   _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, int)                 \
 480   _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, unsigned int)        \
 481   _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, long)                \
 482   _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, unsigned long)       \
 483   _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, long long)           \
 484   _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, unsigned long long)  \
 485   _DEFINE_DECIMAL_COMPARISON_RHS(_Op, int, _Tp)                 \
 486   _DEFINE_DECIMAL_COMPARISON_RHS(_Op, unsigned int, _Tp)        \
 487   _DEFINE_DECIMAL_COMPARISON_RHS(_Op, long, _Tp)                \
 488   _DEFINE_DECIMAL_COMPARISON_RHS(_Op, unsigned long, _Tp)       \
 489   _DEFINE_DECIMAL_COMPARISON_RHS(_Op, long long, _Tp)           \
 490   _DEFINE_DECIMAL_COMPARISON_RHS(_Op, unsigned long long, _Tp)
 491
 492   _DEFINE_DECIMAL_COMPARISONS(==, decimal32)
 493   _DEFINE_DECIMAL_COMPARISONS(==, decimal64)
 494   _DEFINE_DECIMAL_COMPARISONS(==, decimal128)
 495   _DEFINE_DECIMAL_COMPARISONS(!=, decimal32)
 496   _DEFINE_DECIMAL_COMPARISONS(!=, decimal64)
 497   _DEFINE_DECIMAL_COMPARISONS(!=, decimal128)
 498   _DEFINE_DECIMAL_COMPARISONS(<,  decimal32)
 499   _DEFINE_DECIMAL_COMPARISONS(<,  decimal64)
 500   _DEFINE_DECIMAL_COMPARISONS(<,  decimal128)
 501   _DEFINE_DECIMAL_COMPARISONS(<=, decimal32)
 502   _DEFINE_DECIMAL_COMPARISONS(<=, decimal64)
 503   _DEFINE_DECIMAL_COMPARISONS(<=, decimal128)
 504   _DEFINE_DECIMAL_COMPARISONS(>,  decimal32)
 505   _DEFINE_DECIMAL_COMPARISONS(>,  decimal64)
 506   _DEFINE_DECIMAL_COMPARISONS(>,  decimal128)
 507   _DEFINE_DECIMAL_COMPARISONS(>=, decimal32)
 508   _DEFINE_DECIMAL_COMPARISONS(>=, decimal64)
 509   _DEFINE_DECIMAL_COMPARISONS(>=, decimal128)
 510
 511 #undef _DEFINE_DECIMAL_COMPARISON_BOTH
 512 #undef _DEFINE_DECIMAL_COMPARISON_LHS
 513 #undef _DEFINE_DECIMAL_COMPARISON_RHS
 514 #undef _DEFINE_DECIMAL_COMPARISONS
 515
 516 } // namespace decimal
 517 } // namespace std
 518
 519 #endif /* _GLIBCXX_DECIMAL_IMPL */