l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.6/include/decimal/decimal

   1 // <decimal> -*- C++ -*-
   2
   3 // Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
   4 // This file is part of the GNU ISO C++ Library.  This library is free
   5 // software; you can redistribute it and/or modify it under the
   6 // terms of the GNU General Public License as published by the
   7 // Free Software Foundation; either version 3, or (at your option)
   8 // any later version.
   9
  10 // This library is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // Under Section 7 of GPL version 3, you are granted additional
  16 // permissions described in the GCC Runtime Library Exception, version
  17 // 3.1, as published by the Free Software Foundation.
  18
  19 // You should have received a copy of the GNU General Public License and
  20 // a copy of the GCC Runtime Library Exception along with this program;
  21 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  22 // <http://www.gnu.org/licenses/>.
  23
  24 /** @file decimal/decimal
  25  *  This is a Standard C++ Library header.
  26  */
  27
  28 // ISO/IEC TR 24733
  29 // Written by Janis Johnson <janis187@us.ibm.com>
  30
  31 #ifndef _GLIBCXX_DECIMAL
  32 #define _GLIBCXX_DECIMAL 1
  33
  34 #pragma GCC system_header
  35
  36 #include <bits/c++config.h>
  37
  38 #ifndef _GLIBCXX_USE_DECIMAL_FLOAT
  39 #error This file requires compiler and library support for ISO/IEC TR 24733 \
  40 that is currently not available.
  41 #endif
  42
  43 namespace std _GLIBCXX_VISIBILITY(default)
  44 {
  45   /**
  46     * @defgroup decimal Decimal Floating-Point Arithmetic
  47     * @ingroup numerics
  48     *
  49     * Classes and functions for decimal floating-point arithmetic.
  50     * @{
  51     */
  52
  53   /** @namespace std::decimal
  54     * @brief ISO/IEC TR 24733 Decimal floating-point arithmetic.
  55     */
  56 namespace decimal
  57 {
  58   _GLIBCXX_BEGIN_NAMESPACE_VERSION
  59
  60   class decimal32;
  61   class decimal64;
  62   class decimal128;
  63
  64   // 3.2.5  Initialization from coefficient and exponent.
  65   static decimal32 make_decimal32(long long __coeff, int __exp);
  66   static decimal32 make_decimal32(unsigned long long __coeff, int __exp);
  67   static decimal64 make_decimal64(long long __coeff, int __exp);
  68   static decimal64 make_decimal64(unsigned long long __coeff, int __exp);
  69   static decimal128 make_decimal128(long long __coeff, int __exp);
  70   static decimal128 make_decimal128(unsigned long long __coeff, int __exp);
  71
  72   /// Non-conforming extension: Conversion to integral type.
  73   long long decimal32_to_long_long(decimal32 __d);
  74   long long decimal64_to_long_long(decimal64 __d);
  75   long long decimal128_to_long_long(decimal128 __d);
  76   long long decimal_to_long_long(decimal32 __d);
  77   long long decimal_to_long_long(decimal64 __d);
  78   long long decimal_to_long_long(decimal128 __d);
  79
  80   // 3.2.6  Conversion to generic floating-point type.
  81   float decimal32_to_float(decimal32 __d);
  82   float decimal64_to_float(decimal64 __d);
  83   float decimal128_to_float(decimal128 __d);
  84   float decimal_to_float(decimal32 __d);
  85   float decimal_to_float(decimal64 __d);
  86   float decimal_to_float(decimal128 __d);
  87
  88   double decimal32_to_double(decimal32 __d);
  89   double decimal64_to_double(decimal64 __d);
  90   double decimal128_to_double(decimal128 __d);
  91   double decimal_to_double(decimal32 __d);
  92   double decimal_to_double(decimal64 __d);
  93   double decimal_to_double(decimal128 __d);
  94
  95   long double decimal32_to_long_double(decimal32 __d);
  96   long double decimal64_to_long_double(decimal64 __d);
  97   long double decimal128_to_long_double(decimal128 __d);
  98   long double decimal_to_long_double(decimal32 __d);
  99   long double decimal_to_long_double(decimal64 __d);
 100   long double decimal_to_long_double(decimal128 __d);
 101
 102   // 3.2.7  Unary arithmetic operators.
 103   decimal32  operator+(decimal32 __rhs);
 104   decimal64  operator+(decimal64 __rhs);
 105   decimal128 operator+(decimal128 __rhs);
 106   decimal32  operator-(decimal32 __rhs);
 107   decimal64  operator-(decimal64 __rhs);
 108   decimal128 operator-(decimal128 __rhs);
 109
 110   // 3.2.8  Binary arithmetic operators.
 111 #define _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(_Op, _T1, _T2, _T3) \
 112   _T1 operator _Op(_T2 __lhs, _T3 __rhs);
 113 #define _DECLARE_DECIMAL_BINARY_OP_WITH_INT(_Op, _Tp)           \
 114   _Tp operator _Op(_Tp __lhs, int __rhs);                       \
 115   _Tp operator _Op(_Tp __lhs, unsigned int __rhs);              \
 116   _Tp operator _Op(_Tp __lhs, long __rhs);                      \
 117   _Tp operator _Op(_Tp __lhs, unsigned long __rhs);             \
 118   _Tp operator _Op(_Tp __lhs, long long __rhs);                 \
 119   _Tp operator _Op(_Tp __lhs, unsigned long long __rhs);        \
 120   _Tp operator _Op(int __lhs, _Tp __rhs);                       \
 121   _Tp operator _Op(unsigned int __lhs, _Tp __rhs);              \
 122   _Tp operator _Op(long __lhs, _Tp __rhs);                      \
 123   _Tp operator _Op(unsigned long __lhs, _Tp __rhs);             \
 124   _Tp operator _Op(long long __lhs, _Tp __rhs);                 \
 125   _Tp operator _Op(unsigned long long __lhs, _Tp __rhs);
 126
 127   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal32, decimal32, decimal32)
 128   _DECLARE_DECIMAL_BINARY_OP_WITH_INT(+, decimal32)
 129   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal32, decimal64)
 130   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal32)
 131   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal64)
 132   _DECLARE_DECIMAL_BINARY_OP_WITH_INT(+, decimal64)
 133   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal32, decimal128)
 134   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal64, decimal128)
 135   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal32)
 136   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal64)
 137   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal128)
 138   _DECLARE_DECIMAL_BINARY_OP_WITH_INT(+, decimal128)
 139
 140   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal32, decimal32, decimal32)
 141   _DECLARE_DECIMAL_BINARY_OP_WITH_INT(-, decimal32)
 142   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal32, decimal64)
 143   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal32)
 144   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal64)
 145   _DECLARE_DECIMAL_BINARY_OP_WITH_INT(-, decimal64)
 146   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal32, decimal128)
 147   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal64, decimal128)
 148   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal32)
 149   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal64)
 150   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal128)
 151   _DECLARE_DECIMAL_BINARY_OP_WITH_INT(-, decimal128)
 152
 153   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal32, decimal32, decimal32)
 154   _DECLARE_DECIMAL_BINARY_OP_WITH_INT(*, decimal32)
 155   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal32, decimal64)
 156   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal32)
 157   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal64)
 158   _DECLARE_DECIMAL_BINARY_OP_WITH_INT(*, decimal64)
 159   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal32, decimal128)
 160   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal64, decimal128)
 161   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal32)
 162   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal64)
 163   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal128)
 164   _DECLARE_DECIMAL_BINARY_OP_WITH_INT(*, decimal128)
 165
 166   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal32, decimal32, decimal32)
 167   _DECLARE_DECIMAL_BINARY_OP_WITH_INT(/, decimal32)
 168   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal32, decimal64)
 169   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal32)
 170   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal64)
 171   _DECLARE_DECIMAL_BINARY_OP_WITH_INT(/, decimal64)
 172   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal32, decimal128)
 173   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal64, decimal128)
 174   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal32)
 175   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal64)
 176   _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal128)
 177   _DECLARE_DECIMAL_BINARY_OP_WITH_INT(/, decimal128)
 178
 179 #undef _DECLARE_DECIMAL_BINARY_OP_WITH_DEC
 180 #undef _DECLARE_DECIMAL_BINARY_OP_WITH_INT
 181
 182   // 3.2.9  Comparison operators.
 183 #define _DECLARE_DECIMAL_COMPARISON(_Op, _Tp)                           \
 184   bool operator _Op(_Tp __lhs, decimal32 __rhs);                        \
 185   bool operator _Op(_Tp __lhs, decimal64 __rhs);                        \
 186   bool operator _Op(_Tp __lhs, decimal128 __rhs);                       \
 187   bool operator _Op(_Tp __lhs, int __rhs);                              \
 188   bool operator _Op(_Tp __lhs, unsigned int __rhs);                     \
 189   bool operator _Op(_Tp __lhs, long __rhs);                             \
 190   bool operator _Op(_Tp __lhs, unsigned long __rhs);                    \
 191   bool operator _Op(_Tp __lhs, long long __rhs);                        \
 192   bool operator _Op(_Tp __lhs, unsigned long long __rhs);               \
 193   bool operator _Op(int __lhs, _Tp __rhs);                              \
 194   bool operator _Op(unsigned int __lhs, _Tp __rhs);                     \
 195   bool operator _Op(long __lhs, _Tp __rhs);                             \
 196   bool operator _Op(unsigned long __lhs, _Tp __rhs);                    \
 197   bool operator _Op(long long __lhs, _Tp __rhs);                        \
 198   bool operator _Op(unsigned long long __lhs, _Tp __rhs);
 199
 200   _DECLARE_DECIMAL_COMPARISON(==, decimal32)
 201   _DECLARE_DECIMAL_COMPARISON(==, decimal64)
 202   _DECLARE_DECIMAL_COMPARISON(==, decimal128)
 203
 204   _DECLARE_DECIMAL_COMPARISON(!=, decimal32)
 205   _DECLARE_DECIMAL_COMPARISON(!=, decimal64)
 206   _DECLARE_DECIMAL_COMPARISON(!=, decimal128)
 207
 208   _DECLARE_DECIMAL_COMPARISON(<, decimal32)
 209   _DECLARE_DECIMAL_COMPARISON(<, decimal64)
 210   _DECLARE_DECIMAL_COMPARISON(<, decimal128)
 211
 212   _DECLARE_DECIMAL_COMPARISON(>=, decimal32)
 213   _DECLARE_DECIMAL_COMPARISON(>=, decimal64)
 214   _DECLARE_DECIMAL_COMPARISON(>=, decimal128)
 215
 216   _DECLARE_DECIMAL_COMPARISON(>, decimal32)
 217   _DECLARE_DECIMAL_COMPARISON(>, decimal64)
 218   _DECLARE_DECIMAL_COMPARISON(>, decimal128)
 219
 220   _DECLARE_DECIMAL_COMPARISON(>=, decimal32)
 221   _DECLARE_DECIMAL_COMPARISON(>=, decimal64)
 222   _DECLARE_DECIMAL_COMPARISON(>=, decimal128)
 223
 224 #undef _DECLARE_DECIMAL_COMPARISON
 225
 226   /// 3.2.2  Class decimal32.
 227   class decimal32
 228   {
 229   public:
 230     typedef float __decfloat32 __attribute__((mode(SD)));
 231
 232     // 3.2.2.2  Construct/copy/destroy.
 233     decimal32()                                 : __val(0.e-101DF) {}
 234
 235     // 3.2.2.3  Conversion from floating-point type.
 236     explicit decimal32(decimal64 __d64);
 237     explicit decimal32(decimal128 __d128);
 238     explicit decimal32(float __r)               : __val(__r) {}
 239     explicit decimal32(double __r)              : __val(__r) {}
 240     explicit decimal32(long double __r)         : __val(__r) {}
 241
 242     // 3.2.2.4  Conversion from integral type.
 243     decimal32(int __z)                          : __val(__z) {}
 244     decimal32(unsigned int __z)                 : __val(__z) {}
 245     decimal32(long __z)                         : __val(__z) {}
 246     decimal32(unsigned long __z)                : __val(__z) {}
 247     decimal32(long long __z)                    : __val(__z) {}
 248     decimal32(unsigned long long __z)           : __val(__z) {}
 249
 250     /// Conforming extension: Conversion from scalar decimal type.
 251     decimal32(__decfloat32 __z)                 : __val(__z) {}
 252
 253     // 3.2.2.5  Conversion to integral type. (DISABLED)
 254     //operator long long() const { return (long long)__val; }
 255
 256     // 3.2.2.6  Increment and decrement operators.
 257     decimal32& operator++()
 258     {
 259       __val += 1;
 260       return *this;
 261     }
 262
 263     decimal32 operator++(int)
 264     {
 265       decimal32 __tmp = *this;
 266       __val += 1;
 267       return __tmp;
 268     }
 269
 270     decimal32& operator--()
 271     {
 272       __val -= 1;
 273       return *this;
 274     }
 275
 276     decimal32   operator--(int)
 277     {
 278       decimal32 __tmp = *this;
 279       __val -= 1;
 280       return __tmp;
 281     }
 282
 283     // 3.2.2.7  Compound assignment.
 284 #define _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(_Op)     \
 285     decimal32& operator _Op(decimal32 __rhs);           \
 286     decimal32& operator _Op(decimal64 __rhs);           \
 287     decimal32& operator _Op(decimal128 __rhs);          \
 288     decimal32& operator _Op(int __rhs);                 \
 289     decimal32& operator _Op(unsigned int __rhs);        \
 290     decimal32& operator _Op(long __rhs);                \
 291     decimal32& operator _Op(unsigned long __rhs);       \
 292     decimal32& operator _Op(long long __rhs);           \
 293     decimal32& operator _Op(unsigned long long __rhs);
 294
 295     _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(+=)
 296     _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(-=)
 297     _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(*=)
 298     _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(/=)
 299 #undef _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT
 300
 301   private:
 302     __decfloat32 __val;
 303
 304   public:
 305     __decfloat32 __getval(void) { return __val; }
 306     void __setval(__decfloat32 __x) { __val = __x; }
 307   };
 308
 309   /// 3.2.3  Class decimal64.
 310   class decimal64
 311   {
 312   public:
 313     typedef float __decfloat64 __attribute__((mode(DD)));
 314
 315     // 3.2.3.2  Construct/copy/destroy.
 316     decimal64()                                 : __val(0.e-398dd) {}
 317
 318     // 3.2.3.3  Conversion from floating-point type.
 319              decimal64(decimal32 d32);
 320     explicit decimal64(decimal128 d128);
 321     explicit decimal64(float __r)               : __val(__r) {}
 322     explicit decimal64(double __r)              : __val(__r) {}
 323     explicit decimal64(long double __r)         : __val(__r) {}
 324
 325     // 3.2.3.4  Conversion from integral type.
 326     decimal64(int __z)                          : __val(__z) {}
 327     decimal64(unsigned int __z)                 : __val(__z) {}
 328     decimal64(long __z)                         : __val(__z) {}
 329     decimal64(unsigned long __z)                : __val(__z) {}
 330     decimal64(long long __z)                    : __val(__z) {}
 331     decimal64(unsigned long long __z)           : __val(__z) {}
 332
 333     /// Conforming extension: Conversion from scalar decimal type.
 334     decimal64(__decfloat64 __z)                 : __val(__z) {}
 335
 336     // 3.2.3.5  Conversion to integral type. (DISABLED)
 337     //operator long long() const { return (long long)__val; }
 338
 339     // 3.2.3.6  Increment and decrement operators.
 340     decimal64& operator++()
 341     {
 342       __val += 1;
 343       return *this;
 344     }
 345
 346     decimal64 operator++(int)
 347     {
 348       decimal64 __tmp = *this;
 349       __val += 1;
 350       return __tmp;
 351     }
 352
 353     decimal64& operator--()
 354     {
 355       __val -= 1;
 356       return *this;
 357     }
 358
 359     decimal64 operator--(int)
 360     {
 361       decimal64 __tmp = *this;
 362       __val -= 1;
 363       return __tmp;
 364     }
 365
 366     // 3.2.3.7  Compound assignment.
 367 #define _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(_Op)     \
 368     decimal64& operator _Op(decimal32 __rhs);           \
 369     decimal64& operator _Op(decimal64 __rhs);           \
 370     decimal64& operator _Op(decimal128 __rhs);          \
 371     decimal64& operator _Op(int __rhs);                 \
 372     decimal64& operator _Op(unsigned int __rhs);        \
 373     decimal64& operator _Op(long __rhs);                \
 374     decimal64& operator _Op(unsigned long __rhs);       \
 375     decimal64& operator _Op(long long __rhs);           \
 376     decimal64& operator _Op(unsigned long long __rhs);
 377
 378     _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(+=)
 379     _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(-=)
 380     _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(*=)
 381     _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(/=)
 382 #undef _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT
 383
 384   private:
 385     __decfloat64 __val;
 386
 387   public:
 388     __decfloat64 __getval(void) { return __val; }
 389     void __setval(__decfloat64 __x) { __val = __x; }
 390   };
 391
 392   /// 3.2.4  Class decimal128.
 393   class decimal128
 394   {
 395   public:
 396     typedef float __decfloat128 __attribute__((mode(TD)));
 397
 398     // 3.2.4.2  Construct/copy/destroy.
 399     decimal128()                                : __val(0.e-6176DL) {}
 400
 401     // 3.2.4.3  Conversion from floating-point type.
 402              decimal128(decimal32 d32);
 403              decimal128(decimal64 d64);
 404     explicit decimal128(float __r)              : __val(__r) {}
 405     explicit decimal128(double __r)             : __val(__r) {}
 406     explicit decimal128(long double __r)        : __val(__r) {}
 407
 408
 409     // 3.2.4.4  Conversion from integral type.
 410     decimal128(int __z)                         : __val(__z) {}
 411     decimal128(unsigned int __z)                : __val(__z) {}
 412     decimal128(long __z)                        : __val(__z) {}
 413     decimal128(unsigned long __z)               : __val(__z) {}
 414     decimal128(long long __z)                   : __val(__z) {}
 415     decimal128(unsigned long long __z)          : __val(__z) {}
 416
 417     /// Conforming extension: Conversion from scalar decimal type.
 418     decimal128(__decfloat128 __z)               : __val(__z) {}
 419
 420     // 3.2.4.5  Conversion to integral type. (DISABLED)
 421     //operator long long() const { return (long long)__val; }
 422
 423     // 3.2.4.6  Increment and decrement operators.
 424     decimal128& operator++()
 425     {
 426       __val += 1;
 427       return *this;
 428     }
 429
 430     decimal128 operator++(int)
 431     {
 432       decimal128 __tmp = *this;
 433       __val += 1;
 434       return __tmp;
 435     }
 436
 437     decimal128& operator--()
 438     {
 439       __val -= 1;
 440       return *this;
 441     }
 442
 443     decimal128   operator--(int)
 444     {
 445       decimal128 __tmp = *this;
 446       __val -= 1;
 447       return __tmp;
 448     }
 449
 450     // 3.2.4.7  Compound assignment.
 451 #define _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(_Op)    \
 452     decimal128& operator _Op(decimal32 __rhs);          \
 453     decimal128& operator _Op(decimal64 __rhs);          \
 454     decimal128& operator _Op(decimal128 __rhs);         \
 455     decimal128& operator _Op(int __rhs);                \
 456     decimal128& operator _Op(unsigned int __rhs);       \
 457     decimal128& operator _Op(long __rhs);               \
 458     decimal128& operator _Op(unsigned long __rhs);      \
 459     decimal128& operator _Op(long long __rhs);          \
 460     decimal128& operator _Op(unsigned long long __rhs);
 461
 462     _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(+=)
 463     _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(-=)
 464     _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(*=)
 465     _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(/=)
 466 #undef _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT
 467
 468   private:
 469     __decfloat128 __val;
 470
 471   public:
 472     __decfloat128 __getval(void) { return __val; }
 473     void __setval(__decfloat128 __x) { __val = __x; }
 474   };
 475
 476 #define _GLIBCXX_USE_DECIMAL_ 1
 477
 478   _GLIBCXX_END_NAMESPACE_VERSION
 479 } // namespace decimal
 480   // @} group decimal
 481 } // namespace std
 482
 483 #include <decimal/decimal.h>
 484
 485 #endif /* _GLIBCXX_DECIMAL */