Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. // <decimal> -*- C++ -*-
  2.  
  3. // Copyright (C) 2009-2013 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 */
  486.