|
111
|
1 // <decimal> -*- C++ -*-
|
|
|
2
|
|
145
|
3 // Copyright (C) 2009-2020 Free Software Foundation, Inc.
|
|
111
|
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 _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|
|
46
|
|
|
47 /**
|
|
|
48 * @defgroup decimal Decimal Floating-Point Arithmetic
|
|
|
49 * @ingroup numerics
|
|
|
50 *
|
|
|
51 * Classes and functions for decimal floating-point arithmetic.
|
|
|
52 * @{
|
|
|
53 */
|
|
|
54
|
|
|
55 /** @namespace std::decimal
|
|
|
56 * @brief ISO/IEC TR 24733 Decimal floating-point arithmetic.
|
|
|
57 */
|
|
|
58 namespace decimal
|
|
|
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 #if __cplusplus >= 201103L
|
|
|
254 // 3.2.2.5 Conversion to integral type.
|
|
|
255 // Note: explicit per n3407.
|
|
|
256 explicit operator long long() const { return (long long)__val; }
|
|
|
257 #endif
|
|
|
258
|
|
|
259 // 3.2.2.6 Increment and decrement operators.
|
|
|
260 decimal32& operator++()
|
|
|
261 {
|
|
|
262 __val += 1;
|
|
|
263 return *this;
|
|
|
264 }
|
|
|
265
|
|
|
266 decimal32 operator++(int)
|
|
|
267 {
|
|
|
268 decimal32 __tmp = *this;
|
|
|
269 __val += 1;
|
|
|
270 return __tmp;
|
|
|
271 }
|
|
|
272
|
|
|
273 decimal32& operator--()
|
|
|
274 {
|
|
|
275 __val -= 1;
|
|
|
276 return *this;
|
|
|
277 }
|
|
|
278
|
|
|
279 decimal32 operator--(int)
|
|
|
280 {
|
|
|
281 decimal32 __tmp = *this;
|
|
|
282 __val -= 1;
|
|
|
283 return __tmp;
|
|
|
284 }
|
|
|
285
|
|
|
286 // 3.2.2.7 Compound assignment.
|
|
|
287 #define _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(_Op) \
|
|
|
288 decimal32& operator _Op(decimal32 __rhs); \
|
|
|
289 decimal32& operator _Op(decimal64 __rhs); \
|
|
|
290 decimal32& operator _Op(decimal128 __rhs); \
|
|
|
291 decimal32& operator _Op(int __rhs); \
|
|
|
292 decimal32& operator _Op(unsigned int __rhs); \
|
|
|
293 decimal32& operator _Op(long __rhs); \
|
|
|
294 decimal32& operator _Op(unsigned long __rhs); \
|
|
|
295 decimal32& operator _Op(long long __rhs); \
|
|
|
296 decimal32& operator _Op(unsigned long long __rhs);
|
|
|
297
|
|
|
298 _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(+=)
|
|
|
299 _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(-=)
|
|
|
300 _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(*=)
|
|
|
301 _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(/=)
|
|
|
302 #undef _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT
|
|
|
303
|
|
|
304 private:
|
|
|
305 __decfloat32 __val;
|
|
|
306
|
|
|
307 public:
|
|
|
308 __decfloat32 __getval(void) { return __val; }
|
|
|
309 void __setval(__decfloat32 __x) { __val = __x; }
|
|
|
310 };
|
|
|
311
|
|
|
312 /// 3.2.3 Class decimal64.
|
|
|
313 class decimal64
|
|
|
314 {
|
|
|
315 public:
|
|
|
316 typedef float __decfloat64 __attribute__((mode(DD)));
|
|
|
317
|
|
|
318 // 3.2.3.2 Construct/copy/destroy.
|
|
|
319 decimal64() : __val(0.e-398dd) {}
|
|
|
320
|
|
|
321 // 3.2.3.3 Conversion from floating-point type.
|
|
|
322 decimal64(decimal32 d32);
|
|
|
323 explicit decimal64(decimal128 d128);
|
|
|
324 explicit decimal64(float __r) : __val(__r) {}
|
|
|
325 explicit decimal64(double __r) : __val(__r) {}
|
|
|
326 explicit decimal64(long double __r) : __val(__r) {}
|
|
|
327
|
|
|
328 // 3.2.3.4 Conversion from integral type.
|
|
|
329 decimal64(int __z) : __val(__z) {}
|
|
|
330 decimal64(unsigned int __z) : __val(__z) {}
|
|
|
331 decimal64(long __z) : __val(__z) {}
|
|
|
332 decimal64(unsigned long __z) : __val(__z) {}
|
|
|
333 decimal64(long long __z) : __val(__z) {}
|
|
|
334 decimal64(unsigned long long __z) : __val(__z) {}
|
|
|
335
|
|
|
336 /// Conforming extension: Conversion from scalar decimal type.
|
|
|
337 decimal64(__decfloat64 __z) : __val(__z) {}
|
|
|
338
|
|
|
339 #if __cplusplus >= 201103L
|
|
|
340 // 3.2.3.5 Conversion to integral type.
|
|
|
341 // Note: explicit per n3407.
|
|
|
342 explicit operator long long() const { return (long long)__val; }
|
|
|
343 #endif
|
|
|
344
|
|
|
345 // 3.2.3.6 Increment and decrement operators.
|
|
|
346 decimal64& operator++()
|
|
|
347 {
|
|
|
348 __val += 1;
|
|
|
349 return *this;
|
|
|
350 }
|
|
|
351
|
|
|
352 decimal64 operator++(int)
|
|
|
353 {
|
|
|
354 decimal64 __tmp = *this;
|
|
|
355 __val += 1;
|
|
|
356 return __tmp;
|
|
|
357 }
|
|
|
358
|
|
|
359 decimal64& operator--()
|
|
|
360 {
|
|
|
361 __val -= 1;
|
|
|
362 return *this;
|
|
|
363 }
|
|
|
364
|
|
|
365 decimal64 operator--(int)
|
|
|
366 {
|
|
|
367 decimal64 __tmp = *this;
|
|
|
368 __val -= 1;
|
|
|
369 return __tmp;
|
|
|
370 }
|
|
|
371
|
|
|
372 // 3.2.3.7 Compound assignment.
|
|
|
373 #define _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(_Op) \
|
|
|
374 decimal64& operator _Op(decimal32 __rhs); \
|
|
|
375 decimal64& operator _Op(decimal64 __rhs); \
|
|
|
376 decimal64& operator _Op(decimal128 __rhs); \
|
|
|
377 decimal64& operator _Op(int __rhs); \
|
|
|
378 decimal64& operator _Op(unsigned int __rhs); \
|
|
|
379 decimal64& operator _Op(long __rhs); \
|
|
|
380 decimal64& operator _Op(unsigned long __rhs); \
|
|
|
381 decimal64& operator _Op(long long __rhs); \
|
|
|
382 decimal64& operator _Op(unsigned long long __rhs);
|
|
|
383
|
|
|
384 _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(+=)
|
|
|
385 _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(-=)
|
|
|
386 _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(*=)
|
|
|
387 _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(/=)
|
|
|
388 #undef _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT
|
|
|
389
|
|
|
390 private:
|
|
|
391 __decfloat64 __val;
|
|
|
392
|
|
|
393 public:
|
|
|
394 __decfloat64 __getval(void) { return __val; }
|
|
|
395 void __setval(__decfloat64 __x) { __val = __x; }
|
|
|
396 };
|
|
|
397
|
|
|
398 /// 3.2.4 Class decimal128.
|
|
|
399 class decimal128
|
|
|
400 {
|
|
|
401 public:
|
|
|
402 typedef float __decfloat128 __attribute__((mode(TD)));
|
|
|
403
|
|
|
404 // 3.2.4.2 Construct/copy/destroy.
|
|
|
405 decimal128() : __val(0.e-6176DL) {}
|
|
|
406
|
|
|
407 // 3.2.4.3 Conversion from floating-point type.
|
|
|
408 decimal128(decimal32 d32);
|
|
|
409 decimal128(decimal64 d64);
|
|
|
410 explicit decimal128(float __r) : __val(__r) {}
|
|
|
411 explicit decimal128(double __r) : __val(__r) {}
|
|
|
412 explicit decimal128(long double __r) : __val(__r) {}
|
|
|
413
|
|
|
414
|
|
|
415 // 3.2.4.4 Conversion from integral type.
|
|
|
416 decimal128(int __z) : __val(__z) {}
|
|
|
417 decimal128(unsigned int __z) : __val(__z) {}
|
|
|
418 decimal128(long __z) : __val(__z) {}
|
|
|
419 decimal128(unsigned long __z) : __val(__z) {}
|
|
|
420 decimal128(long long __z) : __val(__z) {}
|
|
|
421 decimal128(unsigned long long __z) : __val(__z) {}
|
|
|
422
|
|
|
423 /// Conforming extension: Conversion from scalar decimal type.
|
|
|
424 decimal128(__decfloat128 __z) : __val(__z) {}
|
|
|
425
|
|
|
426 #if __cplusplus >= 201103L
|
|
|
427 // 3.2.4.5 Conversion to integral type.
|
|
|
428 // Note: explicit per n3407.
|
|
|
429 explicit operator long long() const { return (long long)__val; }
|
|
|
430 #endif
|
|
|
431
|
|
|
432 // 3.2.4.6 Increment and decrement operators.
|
|
|
433 decimal128& operator++()
|
|
|
434 {
|
|
|
435 __val += 1;
|
|
|
436 return *this;
|
|
|
437 }
|
|
|
438
|
|
|
439 decimal128 operator++(int)
|
|
|
440 {
|
|
|
441 decimal128 __tmp = *this;
|
|
|
442 __val += 1;
|
|
|
443 return __tmp;
|
|
|
444 }
|
|
|
445
|
|
|
446 decimal128& operator--()
|
|
|
447 {
|
|
|
448 __val -= 1;
|
|
|
449 return *this;
|
|
|
450 }
|
|
|
451
|
|
|
452 decimal128 operator--(int)
|
|
|
453 {
|
|
|
454 decimal128 __tmp = *this;
|
|
|
455 __val -= 1;
|
|
|
456 return __tmp;
|
|
|
457 }
|
|
|
458
|
|
|
459 // 3.2.4.7 Compound assignment.
|
|
|
460 #define _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(_Op) \
|
|
|
461 decimal128& operator _Op(decimal32 __rhs); \
|
|
|
462 decimal128& operator _Op(decimal64 __rhs); \
|
|
|
463 decimal128& operator _Op(decimal128 __rhs); \
|
|
|
464 decimal128& operator _Op(int __rhs); \
|
|
|
465 decimal128& operator _Op(unsigned int __rhs); \
|
|
|
466 decimal128& operator _Op(long __rhs); \
|
|
|
467 decimal128& operator _Op(unsigned long __rhs); \
|
|
|
468 decimal128& operator _Op(long long __rhs); \
|
|
|
469 decimal128& operator _Op(unsigned long long __rhs);
|
|
|
470
|
|
|
471 _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(+=)
|
|
|
472 _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(-=)
|
|
|
473 _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(*=)
|
|
|
474 _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(/=)
|
|
|
475 #undef _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT
|
|
|
476
|
|
|
477 private:
|
|
|
478 __decfloat128 __val;
|
|
|
479
|
|
|
480 public:
|
|
|
481 __decfloat128 __getval(void) { return __val; }
|
|
|
482 void __setval(__decfloat128 __x) { __val = __x; }
|
|
|
483 };
|
|
|
484
|
|
|
485 #define _GLIBCXX_USE_DECIMAL_ 1
|
|
|
486 } // namespace decimal
|
|
|
487 // @} group decimal
|
|
|
488
|
|
|
489 _GLIBCXX_END_NAMESPACE_VERSION
|
|
|
490 } // namespace std
|
|
|
491
|
|
|
492 #include <decimal/decimal.h>
|
|
|
493
|
|
|
494 #endif /* _GLIBCXX_DECIMAL */
|
