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

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