]>
Commit | Line | Data |
---|---|---|
4cdc8761 BK |
1 | // <decimal> -*- C++ -*- |
2 | ||
3 | // Copyright (C) 2009 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 | ||
f910786b | 24 | /** @file decimal/decimal |
4cdc8761 BK |
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 | |
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 | class decimal32; | |
59 | class decimal64; | |
60 | class decimal128; | |
61 | ||
62 | // 3.2.5 Initialization from coefficient and exponent. | |
63 | static decimal32 make_decimal32(long long __coeff, int __exp); | |
64 | static decimal32 make_decimal32(unsigned long long __coeff, int __exp); | |
65 | static decimal64 make_decimal64(long long __coeff, int __exp); | |
66 | static decimal64 make_decimal64(unsigned long long __coeff, int __exp); | |
67 | static decimal128 make_decimal128(long long __coeff, int __exp); | |
68 | static decimal128 make_decimal128(unsigned long long __coeff, int __exp); | |
69 | ||
70 | /// Non-conforming extension: Conversion to integral type. | |
71 | long long decimal32_to_long_long(decimal32 __d); | |
72 | long long decimal64_to_long_long(decimal64 __d); | |
73 | long long decimal128_to_long_long(decimal128 __d); | |
74 | long long decimal_to_long_long(decimal32 __d); | |
75 | long long decimal_to_long_long(decimal64 __d); | |
76 | long long decimal_to_long_long(decimal128 __d); | |
77 | ||
78 | // 3.2.6 Conversion to generic floating-point type. | |
79 | float decimal32_to_float(decimal32 __d); | |
80 | float decimal64_to_float(decimal64 __d); | |
81 | float decimal128_to_float(decimal128 __d); | |
82 | float decimal_to_float(decimal32 __d); | |
83 | float decimal_to_float(decimal64 __d); | |
84 | float decimal_to_float(decimal128 __d); | |
85 | ||
86 | double decimal32_to_double(decimal32 __d); | |
87 | double decimal64_to_double(decimal64 __d); | |
88 | double decimal128_to_double(decimal128 __d); | |
89 | double decimal_to_double(decimal32 __d); | |
90 | double decimal_to_double(decimal64 __d); | |
91 | double decimal_to_double(decimal128 __d); | |
92 | ||
93 | long double decimal32_to_long_double(decimal32 __d); | |
94 | long double decimal64_to_long_double(decimal64 __d); | |
95 | long double decimal128_to_long_double(decimal128 __d); | |
96 | long double decimal_to_long_double(decimal32 __d); | |
97 | long double decimal_to_long_double(decimal64 __d); | |
98 | long double decimal_to_long_double(decimal128 __d); | |
99 | ||
100 | // 3.2.7 Unary arithmetic operators. | |
101 | decimal32 operator+(decimal32 __rhs); | |
102 | decimal64 operator+(decimal64 __rhs); | |
103 | decimal128 operator+(decimal128 __rhs); | |
104 | decimal32 operator-(decimal32 __rhs); | |
105 | decimal64 operator-(decimal64 __rhs); | |
106 | decimal128 operator-(decimal128 __rhs); | |
107 | ||
108 | // 3.2.8 Binary arithmetic operators. | |
109 | #define _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(_Op, _T1, _T2, _T3) \ | |
dd6c7cdf | 110 | _T1 operator _Op(_T2 __lhs, _T3 __rhs); |
4cdc8761 | 111 | #define _DECLARE_DECIMAL_BINARY_OP_WITH_INT(_Op, _Tp) \ |
dd6c7cdf PC |
112 | _Tp operator _Op(_Tp __lhs, int __rhs); \ |
113 | _Tp operator _Op(_Tp __lhs, unsigned int __rhs); \ | |
114 | _Tp operator _Op(_Tp __lhs, long __rhs); \ | |
115 | _Tp operator _Op(_Tp __lhs, unsigned long __rhs); \ | |
116 | _Tp operator _Op(_Tp __lhs, long long __rhs); \ | |
117 | _Tp operator _Op(_Tp __lhs, unsigned long long __rhs); \ | |
118 | _Tp operator _Op(int __lhs, _Tp __rhs); \ | |
119 | _Tp operator _Op(unsigned int __lhs, _Tp __rhs); \ | |
120 | _Tp operator _Op(long __lhs, _Tp __rhs); \ | |
121 | _Tp operator _Op(unsigned long __lhs, _Tp __rhs); \ | |
122 | _Tp operator _Op(long long __lhs, _Tp __rhs); \ | |
123 | _Tp operator _Op(unsigned long long __lhs, _Tp __rhs); | |
4cdc8761 BK |
124 | |
125 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal32, decimal32, decimal32) | |
126 | _DECLARE_DECIMAL_BINARY_OP_WITH_INT(+, decimal32) | |
127 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal32, decimal64) | |
128 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal32) | |
129 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal64) | |
130 | _DECLARE_DECIMAL_BINARY_OP_WITH_INT(+, decimal64) | |
131 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal32, decimal128) | |
132 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal64, decimal128) | |
133 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal32) | |
134 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal64) | |
135 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal128) | |
136 | _DECLARE_DECIMAL_BINARY_OP_WITH_INT(+, decimal128) | |
137 | ||
138 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal32, decimal32, decimal32) | |
139 | _DECLARE_DECIMAL_BINARY_OP_WITH_INT(-, decimal32) | |
140 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal32, decimal64) | |
141 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal32) | |
142 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal64) | |
143 | _DECLARE_DECIMAL_BINARY_OP_WITH_INT(-, decimal64) | |
144 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal32, decimal128) | |
145 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal64, decimal128) | |
146 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal32) | |
147 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal64) | |
148 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal128) | |
149 | _DECLARE_DECIMAL_BINARY_OP_WITH_INT(-, decimal128) | |
150 | ||
151 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal32, decimal32, decimal32) | |
152 | _DECLARE_DECIMAL_BINARY_OP_WITH_INT(*, decimal32) | |
153 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal32, decimal64) | |
154 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal32) | |
155 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal64) | |
156 | _DECLARE_DECIMAL_BINARY_OP_WITH_INT(*, decimal64) | |
157 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal32, decimal128) | |
158 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal64, decimal128) | |
159 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal32) | |
160 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal64) | |
161 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal128) | |
162 | _DECLARE_DECIMAL_BINARY_OP_WITH_INT(*, decimal128) | |
163 | ||
164 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal32, decimal32, decimal32) | |
165 | _DECLARE_DECIMAL_BINARY_OP_WITH_INT(/, decimal32) | |
166 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal32, decimal64) | |
167 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal32) | |
168 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal64) | |
169 | _DECLARE_DECIMAL_BINARY_OP_WITH_INT(/, decimal64) | |
170 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal32, decimal128) | |
171 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal64, decimal128) | |
172 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal32) | |
173 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal64) | |
174 | _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal128) | |
175 | _DECLARE_DECIMAL_BINARY_OP_WITH_INT(/, decimal128) | |
176 | ||
177 | #undef _DECLARE_DECIMAL_BINARY_OP_WITH_DEC | |
178 | #undef _DECLARE_DECIMAL_BINARY_OP_WITH_INT | |
179 | ||
180 | // 3.2.9 Comparison operators. | |
dd6c7cdf PC |
181 | #define _DECLARE_DECIMAL_COMPARISON(_Op, _Tp) \ |
182 | bool operator _Op(_Tp __lhs, decimal32 __rhs); \ | |
183 | bool operator _Op(_Tp __lhs, decimal64 __rhs); \ | |
184 | bool operator _Op(_Tp __lhs, decimal128 __rhs); \ | |
185 | bool operator _Op(_Tp __lhs, int __rhs); \ | |
186 | bool operator _Op(_Tp __lhs, unsigned int __rhs); \ | |
187 | bool operator _Op(_Tp __lhs, long __rhs); \ | |
188 | bool operator _Op(_Tp __lhs, unsigned long __rhs); \ | |
189 | bool operator _Op(_Tp __lhs, long long __rhs); \ | |
190 | bool operator _Op(_Tp __lhs, unsigned long long __rhs); \ | |
191 | bool operator _Op(int __lhs, _Tp __rhs); \ | |
192 | bool operator _Op(unsigned int __lhs, _Tp __rhs); \ | |
193 | bool operator _Op(long __lhs, _Tp __rhs); \ | |
194 | bool operator _Op(unsigned long __lhs, _Tp __rhs); \ | |
195 | bool operator _Op(long long __lhs, _Tp __rhs); \ | |
196 | bool operator _Op(unsigned long long __lhs, _Tp __rhs); | |
4cdc8761 BK |
197 | |
198 | _DECLARE_DECIMAL_COMPARISON(==, decimal32) | |
199 | _DECLARE_DECIMAL_COMPARISON(==, decimal64) | |
200 | _DECLARE_DECIMAL_COMPARISON(==, decimal128) | |
201 | ||
202 | _DECLARE_DECIMAL_COMPARISON(!=, decimal32) | |
203 | _DECLARE_DECIMAL_COMPARISON(!=, decimal64) | |
204 | _DECLARE_DECIMAL_COMPARISON(!=, decimal128) | |
205 | ||
206 | _DECLARE_DECIMAL_COMPARISON(<, decimal32) | |
207 | _DECLARE_DECIMAL_COMPARISON(<, decimal64) | |
208 | _DECLARE_DECIMAL_COMPARISON(<, decimal128) | |
209 | ||
210 | _DECLARE_DECIMAL_COMPARISON(>=, decimal32) | |
211 | _DECLARE_DECIMAL_COMPARISON(>=, decimal64) | |
212 | _DECLARE_DECIMAL_COMPARISON(>=, decimal128) | |
213 | ||
214 | _DECLARE_DECIMAL_COMPARISON(>, decimal32) | |
215 | _DECLARE_DECIMAL_COMPARISON(>, decimal64) | |
216 | _DECLARE_DECIMAL_COMPARISON(>, decimal128) | |
217 | ||
218 | _DECLARE_DECIMAL_COMPARISON(>=, decimal32) | |
219 | _DECLARE_DECIMAL_COMPARISON(>=, decimal64) | |
220 | _DECLARE_DECIMAL_COMPARISON(>=, decimal128) | |
221 | ||
222 | #undef _DECLARE_DECIMAL_COMPARISON | |
223 | ||
224 | /// 3.2.2 Class decimal32. | |
225 | class decimal32 | |
226 | { | |
227 | public: | |
228 | typedef float __decfloat32 __attribute__((mode(SD))); | |
229 | ||
230 | // 3.2.2.2 Construct/copy/destroy. | |
231 | decimal32() : __val(0.e-101DF) {} | |
232 | ||
233 | // 3.2.2.3 Conversion from floating-point type. | |
234 | explicit decimal32(decimal64 __d64); | |
235 | explicit decimal32(decimal128 __d128); | |
236 | explicit decimal32(float __r) : __val(__r) {} | |
237 | explicit decimal32(double __r) : __val(__r) {} | |
238 | explicit decimal32(long double __r) : __val(__r) {} | |
239 | ||
240 | // 3.2.2.4 Conversion from integral type. | |
241 | decimal32(int __z) : __val(__z) {} | |
242 | decimal32(unsigned int __z) : __val(__z) {} | |
243 | decimal32(long __z) : __val(__z) {} | |
244 | decimal32(unsigned long __z) : __val(__z) {} | |
245 | decimal32(long long __z) : __val(__z) {} | |
246 | decimal32(unsigned long long __z) : __val(__z) {} | |
247 | ||
248 | /// Conforming extension: Conversion from scalar decimal type. | |
249 | decimal32(__decfloat32 __z) : __val(__z) {} | |
250 | ||
251 | // 3.2.2.5 Conversion to integral type. (DISABLED) | |
252 | //operator long long() const { return (long long)__val; } | |
253 | ||
254 | // 3.2.2.6 Increment and decrement operators. | |
255 | decimal32& operator++() | |
256 | { | |
257 | __val += 1; | |
258 | return *this; | |
259 | } | |
260 | ||
261 | decimal32 operator++(int) | |
262 | { | |
263 | decimal32 __tmp = *this; | |
264 | __val += 1; | |
265 | return __tmp; | |
266 | } | |
267 | ||
268 | decimal32& operator--() | |
269 | { | |
270 | __val -= 1; | |
271 | return *this; | |
272 | } | |
273 | ||
274 | decimal32 operator--(int) | |
275 | { | |
276 | decimal32 __tmp = *this; | |
277 | __val -= 1; | |
278 | return __tmp; | |
279 | } | |
280 | ||
281 | // 3.2.2.7 Compound assignment. | |
282 | #define _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(_Op) \ | |
283 | decimal32& operator _Op(decimal32 __rhs); \ | |
284 | decimal32& operator _Op(decimal64 __rhs); \ | |
285 | decimal32& operator _Op(decimal128 __rhs); \ | |
286 | decimal32& operator _Op(int __rhs); \ | |
287 | decimal32& operator _Op(unsigned int __rhs); \ | |
288 | decimal32& operator _Op(long __rhs); \ | |
289 | decimal32& operator _Op(unsigned long __rhs); \ | |
290 | decimal32& operator _Op(long long __rhs); \ | |
291 | decimal32& operator _Op(unsigned long long __rhs); | |
292 | ||
293 | _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(+=) | |
294 | _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(-=) | |
295 | _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(*=) | |
296 | _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(/=) | |
297 | #undef _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT | |
298 | ||
299 | private: | |
300 | __decfloat32 __val; | |
301 | ||
302 | public: | |
303 | __decfloat32 __getval(void) { return __val; } | |
304 | void __setval(__decfloat32 __x) { __val = __x; } | |
305 | }; | |
306 | ||
307 | /// 3.2.3 Class decimal64. | |
308 | class decimal64 | |
309 | { | |
310 | public: | |
311 | typedef float __decfloat64 __attribute__((mode(DD))); | |
312 | ||
313 | // 3.2.3.2 Construct/copy/destroy. | |
314 | decimal64() : __val(0.e-398dd) {} | |
315 | ||
316 | // 3.2.3.3 Conversion from floating-point type. | |
317 | decimal64(decimal32 d32); | |
318 | explicit decimal64(decimal128 d128); | |
319 | explicit decimal64(float __r) : __val(__r) {} | |
320 | explicit decimal64(double __r) : __val(__r) {} | |
321 | explicit decimal64(long double __r) : __val(__r) {} | |
322 | ||
323 | // 3.2.3.4 Conversion from integral type. | |
324 | decimal64(int __z) : __val(__z) {} | |
325 | decimal64(unsigned int __z) : __val(__z) {} | |
326 | decimal64(long __z) : __val(__z) {} | |
327 | decimal64(unsigned long __z) : __val(__z) {} | |
328 | decimal64(long long __z) : __val(__z) {} | |
329 | decimal64(unsigned long long __z) : __val(__z) {} | |
330 | ||
331 | /// Conforming extension: Conversion from scalar decimal type. | |
332 | decimal64(__decfloat64 __z) : __val(__z) {} | |
333 | ||
334 | // 3.2.3.5 Conversion to integral type. (DISABLED) | |
335 | //operator long long() const { return (long long)__val; } | |
336 | ||
337 | // 3.2.3.6 Increment and decrement operators. | |
338 | decimal64& operator++() | |
339 | { | |
340 | __val += 1; | |
341 | return *this; | |
342 | } | |
343 | ||
344 | decimal64 operator++(int) | |
345 | { | |
346 | decimal64 __tmp = *this; | |
347 | __val += 1; | |
348 | return __tmp; | |
349 | } | |
350 | ||
351 | decimal64& operator--() | |
352 | { | |
353 | __val -= 1; | |
354 | return *this; | |
355 | } | |
356 | ||
357 | decimal64 operator--(int) | |
358 | { | |
359 | decimal64 __tmp = *this; | |
360 | __val -= 1; | |
361 | return __tmp; | |
362 | } | |
363 | ||
364 | // 3.2.3.7 Compound assignment. | |
365 | #define _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(_Op) \ | |
366 | decimal64& operator _Op(decimal32 __rhs); \ | |
367 | decimal64& operator _Op(decimal64 __rhs); \ | |
368 | decimal64& operator _Op(decimal128 __rhs); \ | |
369 | decimal64& operator _Op(int __rhs); \ | |
370 | decimal64& operator _Op(unsigned int __rhs); \ | |
371 | decimal64& operator _Op(long __rhs); \ | |
372 | decimal64& operator _Op(unsigned long __rhs); \ | |
373 | decimal64& operator _Op(long long __rhs); \ | |
374 | decimal64& operator _Op(unsigned long long __rhs); | |
375 | ||
376 | _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(+=) | |
377 | _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(-=) | |
378 | _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(*=) | |
379 | _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(/=) | |
380 | #undef _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT | |
381 | ||
382 | private: | |
383 | __decfloat64 __val; | |
384 | ||
385 | public: | |
386 | __decfloat64 __getval(void) { return __val; } | |
387 | void __setval(__decfloat64 __x) { __val = __x; } | |
388 | }; | |
389 | ||
390 | /// 3.2.4 Class decimal128. | |
391 | class decimal128 | |
392 | { | |
393 | public: | |
394 | typedef float __decfloat128 __attribute__((mode(TD))); | |
395 | ||
396 | // 3.2.4.2 Construct/copy/destroy. | |
397 | decimal128() : __val(0.e-6176DL) {} | |
398 | ||
399 | // 3.2.4.3 Conversion from floating-point type. | |
400 | decimal128(decimal32 d32); | |
401 | decimal128(decimal64 d64); | |
402 | explicit decimal128(float __r) : __val(__r) {} | |
403 | explicit decimal128(double __r) : __val(__r) {} | |
404 | explicit decimal128(long double __r) : __val(__r) {} | |
405 | ||
406 | ||
407 | // 3.2.4.4 Conversion from integral type. | |
408 | decimal128(int __z) : __val(__z) {} | |
409 | decimal128(unsigned int __z) : __val(__z) {} | |
410 | decimal128(long __z) : __val(__z) {} | |
411 | decimal128(unsigned long __z) : __val(__z) {} | |
412 | decimal128(long long __z) : __val(__z) {} | |
413 | decimal128(unsigned long long __z) : __val(__z) {} | |
414 | ||
415 | /// Conforming extension: Conversion from scalar decimal type. | |
416 | decimal128(__decfloat128 __z) : __val(__z) {} | |
417 | ||
418 | // 3.2.4.5 Conversion to integral type. (DISABLED) | |
419 | //operator long long() const { return (long long)__val; } | |
420 | ||
421 | // 3.2.4.6 Increment and decrement operators. | |
422 | decimal128& operator++() | |
423 | { | |
424 | __val += 1; | |
425 | return *this; | |
426 | } | |
427 | ||
428 | decimal128 operator++(int) | |
429 | { | |
430 | decimal128 __tmp = *this; | |
431 | __val += 1; | |
432 | return __tmp; | |
433 | } | |
434 | ||
435 | decimal128& operator--() | |
436 | { | |
437 | __val -= 1; | |
438 | return *this; | |
439 | } | |
440 | ||
441 | decimal128 operator--(int) | |
442 | { | |
443 | decimal128 __tmp = *this; | |
444 | __val -= 1; | |
445 | return __tmp; | |
446 | } | |
447 | ||
448 | // 3.2.4.7 Compound assignment. | |
449 | #define _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(_Op) \ | |
450 | decimal128& operator _Op(decimal32 __rhs); \ | |
451 | decimal128& operator _Op(decimal64 __rhs); \ | |
452 | decimal128& operator _Op(decimal128 __rhs); \ | |
453 | decimal128& operator _Op(int __rhs); \ | |
454 | decimal128& operator _Op(unsigned int __rhs); \ | |
455 | decimal128& operator _Op(long __rhs); \ | |
456 | decimal128& operator _Op(unsigned long __rhs); \ | |
457 | decimal128& operator _Op(long long __rhs); \ | |
458 | decimal128& operator _Op(unsigned long long __rhs); | |
459 | ||
460 | _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(+=) | |
461 | _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(-=) | |
462 | _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(*=) | |
463 | _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(/=) | |
464 | #undef _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT | |
465 | ||
466 | private: | |
467 | __decfloat128 __val; | |
468 | ||
469 | public: | |
470 | __decfloat128 __getval(void) { return __val; } | |
471 | void __setval(__decfloat128 __x) { __val = __x; } | |
472 | }; | |
473 | ||
474 | #define _GLIBCXX_USE_DECIMAL_ 1 | |
475 | ||
476 | } // namespace decimal | |
477 | // @} group decimal | |
478 | } // namespace std | |
479 | ||
480 | #include <decimal/decimal.h> | |
481 | ||
482 | #endif /* _GLIBCXX_DECIMAL */ |