1 /* Decimal number arithmetic module for the decNumber C Library.
2 Copyright (C) 2005-2013 Free Software Foundation, Inc.
3 Contributed by IBM Corporation. Author Mike Cowlishaw.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 Under Section 7 of GPL version 3, you are granted additional
18 permissions described in the GCC Runtime Library Exception, version
19 3.1, as published by the Free Software Foundation.
21 You should have received a copy of the GNU General Public License and
22 a copy of the GCC Runtime Library Exception along with this program;
23 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 <http://www.gnu.org/licenses/>. */
26 /* ------------------------------------------------------------------ */
27 /* Decimal Number arithmetic module */
28 /* ------------------------------------------------------------------ */
29 /* This module comprises the routines for arbitrary-precision General */
30 /* Decimal Arithmetic as defined in the specification which may be */
31 /* found on the General Decimal Arithmetic pages. It implements both */
32 /* the full ('extended') arithmetic and the simpler ('subset') */
37 /* 1. This code is ANSI C89 except: */
39 /* a) C99 line comments (double forward slash) are used. (Most C */
40 /* compilers accept these. If yours does not, a simple script */
41 /* can be used to convert them to ANSI C comments.) */
43 /* b) Types from C99 stdint.h are used. If you do not have this */
44 /* header file, see the User's Guide section of the decNumber */
45 /* documentation; this lists the necessary definitions. */
47 /* c) If DECDPUN>4 or DECUSE64=1, the C99 64-bit int64_t and */
48 /* uint64_t types may be used. To avoid these, set DECUSE64=0 */
49 /* and DECDPUN<=4 (see documentation). */
51 /* The code also conforms to C99 restrictions; in particular, */
52 /* strict aliasing rules are observed. */
54 /* 2. The decNumber format which this library uses is optimized for */
55 /* efficient processing of relatively short numbers; in particular */
56 /* it allows the use of fixed sized structures and minimizes copy */
57 /* and move operations. It does, however, support arbitrary */
58 /* precision (up to 999,999,999 digits) and arbitrary exponent */
59 /* range (Emax in the range 0 through 999,999,999 and Emin in the */
60 /* range -999,999,999 through 0). Mathematical functions (for */
61 /* example decNumberExp) as identified below are restricted more */
62 /* tightly: digits, emax, and -emin in the context must be <= */
63 /* DEC_MAX_MATH (999999), and their operand(s) must be within */
66 /* 3. Logical functions are further restricted; their operands must */
67 /* be finite, positive, have an exponent of zero, and all digits */
68 /* must be either 0 or 1. The result will only contain digits */
69 /* which are 0 or 1 (and will have exponent=0 and a sign of 0). */
71 /* 4. Operands to operator functions are never modified unless they */
72 /* are also specified to be the result number (which is always */
73 /* permitted). Other than that case, operands must not overlap. */
75 /* 5. Error handling: the type of the error is ORed into the status */
76 /* flags in the current context (decContext structure). The */
77 /* SIGFPE signal is then raised if the corresponding trap-enabler */
78 /* flag in the decContext is set (is 1). */
80 /* It is the responsibility of the caller to clear the status */
81 /* flags as required. */
83 /* The result of any routine which returns a number will always */
84 /* be a valid number (which may be a special value, such as an */
85 /* Infinity or NaN). */
87 /* 6. The decNumber format is not an exchangeable concrete */
88 /* representation as it comprises fields which may be machine- */
89 /* dependent (packed or unpacked, or special length, for example). */
90 /* Canonical conversions to and from strings are provided; other */
91 /* conversions are available in separate modules. */
93 /* 7. Normally, input operands are assumed to be valid. Set DECCHECK */
94 /* to 1 for extended operand checking (including NULL operands). */
95 /* Results are undefined if a badly-formed structure (or a NULL */
96 /* pointer to a structure) is provided, though with DECCHECK */
97 /* enabled the operator routines are protected against exceptions. */
98 /* (Except if the result pointer is NULL, which is unrecoverable.) */
100 /* However, the routines will never cause exceptions if they are */
101 /* given well-formed operands, even if the value of the operands */
102 /* is inappropriate for the operation and DECCHECK is not set. */
103 /* (Except for SIGFPE, as and where documented.) */
105 /* 8. Subset arithmetic is available only if DECSUBSET is set to 1. */
106 /* ------------------------------------------------------------------ */
107 /* Implementation notes for maintenance of this module: */
109 /* 1. Storage leak protection: Routines which use malloc are not */
110 /* permitted to use return for fastpath or error exits (i.e., */
111 /* they follow strict structured programming conventions). */
112 /* Instead they have a do{}while(0); construct surrounding the */
113 /* code which is protected -- break may be used to exit this. */
114 /* Other routines can safely use the return statement inline. */
116 /* Storage leak accounting can be enabled using DECALLOC. */
118 /* 2. All loops use the for(;;) construct. Any do construct does */
119 /* not loop; it is for allocation protection as just described. */
121 /* 3. Setting status in the context must always be the very last */
122 /* action in a routine, as non-0 status may raise a trap and hence */
123 /* the call to set status may not return (if the handler uses long */
124 /* jump). Therefore all cleanup must be done first. In general, */
125 /* to achieve this status is accumulated and is only applied just */
126 /* before return by calling decContextSetStatus (via decStatus). */
128 /* Routines which allocate storage cannot, in general, use the */
129 /* 'top level' routines which could cause a non-returning */
130 /* transfer of control. The decXxxxOp routines are safe (do not */
131 /* call decStatus even if traps are set in the context) and should */
132 /* be used instead (they are also a little faster). */
134 /* 4. Exponent checking is minimized by allowing the exponent to */
135 /* grow outside its limits during calculations, provided that */
136 /* the decFinalize function is called later. Multiplication and */
137 /* division, and intermediate calculations in exponentiation, */
138 /* require more careful checks because of the risk of 31-bit */
139 /* overflow (the most negative valid exponent is -1999999997, for */
140 /* a 999999999-digit number with adjusted exponent of -999999999). */
142 /* 5. Rounding is deferred until finalization of results, with any */
143 /* 'off to the right' data being represented as a single digit */
144 /* residue (in the range -1 through 9). This avoids any double- */
145 /* rounding when more than one shortening takes place (for */
146 /* example, when a result is subnormal). */
148 /* 6. The digits count is allowed to rise to a multiple of DECDPUN */
149 /* during many operations, so whole Units are handled and exact */
150 /* accounting of digits is not needed. The correct digits value */
151 /* is found by decGetDigits, which accounts for leading zeros. */
152 /* This must be called before any rounding if the number of digits */
153 /* is not known exactly. */
155 /* 7. The multiply-by-reciprocal 'trick' is used for partitioning */
156 /* numbers up to four digits, using appropriate constants. This */
157 /* is not useful for longer numbers because overflow of 32 bits */
158 /* would lead to 4 multiplies, which is almost as expensive as */
159 /* a divide (unless a floating-point or 64-bit multiply is */
160 /* assumed to be available). */
162 /* 8. Unusual abbreviations that may be used in the commentary: */
163 /* lhs -- left hand side (operand, of an operation) */
164 /* lsd -- least significant digit (of coefficient) */
165 /* lsu -- least significant Unit (of coefficient) */
166 /* msd -- most significant digit (of coefficient) */
167 /* msi -- most significant item (in an array) */
168 /* msu -- most significant Unit (of coefficient) */
169 /* rhs -- right hand side (operand, of an operation) */
170 /* +ve -- positive */
171 /* -ve -- negative */
172 /* ** -- raise to the power */
173 /* ------------------------------------------------------------------ */
175 #include <stdlib.h> /* for malloc, free, etc. */
176 #include <stdio.h> /* for printf [if needed] */
177 #include <string.h> /* for strcpy */
178 #include <ctype.h> /* for lower */
179 #include "dconfig.h" /* for GCC definitions */
180 #include "decNumber.h" /* base number library */
181 #include "decNumberLocal.h" /* decNumber local types, etc. */
184 /* Public lookup table used by the D2U macro */
185 const uByte d2utable
[DECMAXD2U
+1]=D2UTABLE
;
187 #define DECVERB 1 /* set to 1 for verbose DECCHECK */
188 #define powers DECPOWERS /* old internal name */
190 /* Local constants */
191 #define DIVIDE 0x80 /* Divide operators */
192 #define REMAINDER 0x40 /* .. */
193 #define DIVIDEINT 0x20 /* .. */
194 #define REMNEAR 0x10 /* .. */
195 #define COMPARE 0x01 /* Compare operators */
196 #define COMPMAX 0x02 /* .. */
197 #define COMPMIN 0x03 /* .. */
198 #define COMPTOTAL 0x04 /* .. */
199 #define COMPNAN 0x05 /* .. [NaN processing] */
200 #define COMPSIG 0x06 /* .. [signaling COMPARE] */
201 #define COMPMAXMAG 0x07 /* .. */
202 #define COMPMINMAG 0x08 /* .. */
204 #define DEC_sNaN 0x40000000 /* local status: sNaN signal */
205 #define BADINT (Int)0x80000000 /* most-negative Int; error indicator */
206 /* Next two indicate an integer >= 10**6, and its parity (bottom bit) */
207 #define BIGEVEN (Int)0x80000002
208 #define BIGODD (Int)0x80000003
210 static Unit uarrone
[1]={1}; /* Unit array of 1, used for incrementing */
212 /* Granularity-dependent code */
214 #define eInt Int /* extended integer */
215 #define ueInt uInt /* unsigned extended integer */
216 /* Constant multipliers for divide-by-power-of five using reciprocal */
217 /* multiply, after removing powers of 2 by shifting, and final shift */
218 /* of 17 [we only need up to **4] */
219 static const uInt multies
[]={131073, 26215, 5243, 1049, 210};
220 /* QUOT10 -- macro to return the quotient of unit u divided by 10**n */
221 #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
223 /* For DECDPUN>4 non-ANSI-89 64-bit types are needed. */
225 #error decNumber.c: DECUSE64 must be 1 when DECDPUN>4
227 #define eInt Long /* extended integer */
228 #define ueInt uLong /* unsigned extended integer */
232 static decNumber
* decAddOp(decNumber
*, const decNumber
*, const decNumber
*,
233 decContext
*, uByte
, uInt
*);
234 static Flag
decBiStr(const char *, const char *, const char *);
235 static uInt
decCheckMath(const decNumber
*, decContext
*, uInt
*);
236 static void decApplyRound(decNumber
*, decContext
*, Int
, uInt
*);
237 static Int
decCompare(const decNumber
*lhs
, const decNumber
*rhs
, Flag
);
238 static decNumber
* decCompareOp(decNumber
*, const decNumber
*,
239 const decNumber
*, decContext
*,
241 static void decCopyFit(decNumber
*, const decNumber
*, decContext
*,
243 static decNumber
* decDecap(decNumber
*, Int
);
244 static decNumber
* decDivideOp(decNumber
*, const decNumber
*,
245 const decNumber
*, decContext
*, Flag
, uInt
*);
246 static decNumber
* decExpOp(decNumber
*, const decNumber
*,
247 decContext
*, uInt
*);
248 static void decFinalize(decNumber
*, decContext
*, Int
*, uInt
*);
249 static Int
decGetDigits(Unit
*, Int
);
250 static Int
decGetInt(const decNumber
*);
251 static decNumber
* decLnOp(decNumber
*, const decNumber
*,
252 decContext
*, uInt
*);
253 static decNumber
* decMultiplyOp(decNumber
*, const decNumber
*,
254 const decNumber
*, decContext
*,
256 static decNumber
* decNaNs(decNumber
*, const decNumber
*,
257 const decNumber
*, decContext
*, uInt
*);
258 static decNumber
* decQuantizeOp(decNumber
*, const decNumber
*,
259 const decNumber
*, decContext
*, Flag
,
261 static void decReverse(Unit
*, Unit
*);
262 static void decSetCoeff(decNumber
*, decContext
*, const Unit
*,
264 static void decSetMaxValue(decNumber
*, decContext
*);
265 static void decSetOverflow(decNumber
*, decContext
*, uInt
*);
266 static void decSetSubnormal(decNumber
*, decContext
*, Int
*, uInt
*);
267 static Int
decShiftToLeast(Unit
*, Int
, Int
);
268 static Int
decShiftToMost(Unit
*, Int
, Int
);
269 static void decStatus(decNumber
*, uInt
, decContext
*);
270 static void decToString(const decNumber
*, char[], Flag
);
271 static decNumber
* decTrim(decNumber
*, decContext
*, Flag
, Flag
, Int
*);
272 static Int
decUnitAddSub(const Unit
*, Int
, const Unit
*, Int
, Int
,
274 static Int
decUnitCompare(const Unit
*, Int
, const Unit
*, Int
, Int
);
277 /* decFinish == decFinalize when no subset arithmetic needed */
278 #define decFinish(a,b,c,d) decFinalize(a,b,c,d)
280 static void decFinish(decNumber
*, decContext
*, Int
*, uInt
*);
281 static decNumber
* decRoundOperand(const decNumber
*, decContext
*, uInt
*);
285 /* masked special-values bits */
286 #define SPECIALARG (rhs->bits & DECSPECIAL)
287 #define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL)
289 /* Diagnostic macros, etc. */
291 /* Handle malloc/free accounting. If enabled, our accountable routines */
292 /* are used; otherwise the code just goes straight to the system malloc */
293 /* and free routines. */
294 #define malloc(a) decMalloc(a)
295 #define free(a) decFree(a)
296 #define DECFENCE 0x5a /* corruption detector */
297 /* 'Our' malloc and free: */
298 static void *decMalloc(size_t);
299 static void decFree(void *);
300 uInt decAllocBytes
=0; /* count of bytes allocated */
301 /* Note that DECALLOC code only checks for storage buffer overflow. */
302 /* To check for memory leaks, the decAllocBytes variable must be */
303 /* checked to be 0 at appropriate times (e.g., after the test */
304 /* harness completes a set of tests). This checking may be unreliable */
305 /* if the testing is done in a multi-thread environment. */
309 /* Optional checking routines. Enabling these means that decNumber */
310 /* and decContext operands to operator routines are checked for */
311 /* correctness. This roughly doubles the execution time of the */
312 /* fastest routines (and adds 600+ bytes), so should not normally be */
313 /* used in 'production'. */
314 /* decCheckInexact is used to check that inexact results have a full */
315 /* complement of digits (where appropriate -- this is not the case */
316 /* for Quantize, for example) */
317 #define DECUNRESU ((decNumber *)(void *)0xffffffff)
318 #define DECUNUSED ((const decNumber *)(void *)0xffffffff)
319 #define DECUNCONT ((decContext *)(void *)(0xffffffff))
320 static Flag
decCheckOperands(decNumber
*, const decNumber
*,
321 const decNumber
*, decContext
*);
322 static Flag
decCheckNumber(const decNumber
*);
323 static void decCheckInexact(const decNumber
*, decContext
*);
326 #if DECTRACE || DECCHECK
327 /* Optional trace/debugging routines (may or may not be used) */
328 void decNumberShow(const decNumber
*); /* displays the components of a number */
329 static void decDumpAr(char, const Unit
*, Int
);
332 /* ================================================================== */
334 /* ================================================================== */
336 /* ------------------------------------------------------------------ */
337 /* from-int32 -- conversion from Int or uInt */
339 /* dn is the decNumber to receive the integer */
340 /* in or uin is the integer to be converted */
343 /* No error is possible. */
344 /* ------------------------------------------------------------------ */
345 decNumber
* decNumberFromInt32(decNumber
*dn
, Int in
) {
348 else { /* negative (possibly BADINT) */
349 if (in
==BADINT
) unsig
=(uInt
)1073741824*2; /* special case */
350 else unsig
=-in
; /* invert */
352 /* in is now positive */
353 decNumberFromUInt32(dn
, unsig
);
354 if (in
<0) dn
->bits
=DECNEG
; /* sign needed */
356 } /* decNumberFromInt32 */
358 decNumber
* decNumberFromUInt32(decNumber
*dn
, uInt uin
) {
359 Unit
*up
; /* work pointer */
360 decNumberZero(dn
); /* clean */
361 if (uin
==0) return dn
; /* [or decGetDigits bad call] */
362 for (up
=dn
->lsu
; uin
>0; up
++) {
363 *up
=(Unit
)(uin
%(DECDPUNMAX
+1));
364 uin
=uin
/(DECDPUNMAX
+1);
366 dn
->digits
=decGetDigits(dn
->lsu
, up
-dn
->lsu
);
368 } /* decNumberFromUInt32 */
370 /* ------------------------------------------------------------------ */
371 /* to-int32 -- conversion to Int or uInt */
373 /* dn is the decNumber to convert */
374 /* set is the context for reporting errors */
375 /* returns the converted decNumber, or 0 if Invalid is set */
377 /* Invalid is set if the decNumber does not have exponent==0 or if */
378 /* it is a NaN, Infinite, or out-of-range. */
379 /* ------------------------------------------------------------------ */
380 Int
decNumberToInt32(const decNumber
*dn
, decContext
*set
) {
382 if (decCheckOperands(DECUNRESU
, DECUNUSED
, dn
, set
)) return 0;
385 /* special or too many digits, or bad exponent */
386 if (dn
->bits
&DECSPECIAL
|| dn
->digits
>10 || dn
->exponent
!=0) ; /* bad */
387 else { /* is a finite integer with 10 or fewer digits */
389 const Unit
*up
; /* .. */
390 uInt hi
=0, lo
; /* .. */
391 up
=dn
->lsu
; /* -> lsu */
392 lo
=*up
; /* get 1 to 9 digits */
393 #if DECDPUN>1 /* split to higher */
398 /* collect remaining Units, if any, into hi */
399 for (d
=DECDPUN
; d
<dn
->digits
; up
++, d
+=DECDPUN
) hi
+=*up
*powers
[d
-1];
400 /* now low has the lsd, hi the remainder */
401 if (hi
>214748364 || (hi
==214748364 && lo
>7)) { /* out of range? */
402 /* most-negative is a reprieve */
403 if (dn
->bits
&DECNEG
&& hi
==214748364 && lo
==8) return 0x80000000;
404 /* bad -- drop through */
406 else { /* in-range always */
408 if (dn
->bits
&DECNEG
) return -i
;
412 decContextSetStatus(set
, DEC_Invalid_operation
); /* [may not return] */
414 } /* decNumberToInt32 */
416 uInt
decNumberToUInt32(const decNumber
*dn
, decContext
*set
) {
418 if (decCheckOperands(DECUNRESU
, DECUNUSED
, dn
, set
)) return 0;
420 /* special or too many digits, or bad exponent, or negative (<0) */
421 if (dn
->bits
&DECSPECIAL
|| dn
->digits
>10 || dn
->exponent
!=0
422 || (dn
->bits
&DECNEG
&& !ISZERO(dn
))); /* bad */
423 else { /* is a finite integer with 10 or fewer digits */
425 const Unit
*up
; /* .. */
426 uInt hi
=0, lo
; /* .. */
427 up
=dn
->lsu
; /* -> lsu */
428 lo
=*up
; /* get 1 to 9 digits */
429 #if DECDPUN>1 /* split to higher */
434 /* collect remaining Units, if any, into hi */
435 for (d
=DECDPUN
; d
<dn
->digits
; up
++, d
+=DECDPUN
) hi
+=*up
*powers
[d
-1];
437 /* now low has the lsd, hi the remainder */
438 if (hi
>429496729 || (hi
==429496729 && lo
>5)) ; /* no reprieve possible */
439 else return X10(hi
)+lo
;
441 decContextSetStatus(set
, DEC_Invalid_operation
); /* [may not return] */
443 } /* decNumberToUInt32 */
445 /* ------------------------------------------------------------------ */
446 /* to-scientific-string -- conversion to numeric string */
447 /* to-engineering-string -- conversion to numeric string */
449 /* decNumberToString(dn, string); */
450 /* decNumberToEngString(dn, string); */
452 /* dn is the decNumber to convert */
453 /* string is the string where the result will be laid out */
455 /* string must be at least dn->digits+14 characters long */
457 /* No error is possible, and no status can be set. */
458 /* ------------------------------------------------------------------ */
459 char * decNumberToString(const decNumber
*dn
, char *string
){
460 decToString(dn
, string
, 0);
462 } /* DecNumberToString */
464 char * decNumberToEngString(const decNumber
*dn
, char *string
){
465 decToString(dn
, string
, 1);
467 } /* DecNumberToEngString */
469 /* ------------------------------------------------------------------ */
470 /* to-number -- conversion from numeric string */
472 /* decNumberFromString -- convert string to decNumber */
473 /* dn -- the number structure to fill */
474 /* chars[] -- the string to convert ('\0' terminated) */
475 /* set -- the context used for processing any error, */
476 /* determining the maximum precision available */
477 /* (set.digits), determining the maximum and minimum */
478 /* exponent (set.emax and set.emin), determining if */
479 /* extended values are allowed, and checking the */
480 /* rounding mode if overflow occurs or rounding is */
483 /* The length of the coefficient and the size of the exponent are */
484 /* checked by this routine, so the correct error (Underflow or */
485 /* Overflow) can be reported or rounding applied, as necessary. */
487 /* If bad syntax is detected, the result will be a quiet NaN. */
488 /* ------------------------------------------------------------------ */
489 decNumber
* decNumberFromString(decNumber
*dn
, const char chars
[],
491 Int exponent
=0; /* working exponent [assume 0] */
492 uByte bits
=0; /* working flags [assume +ve] */
493 Unit
*res
; /* where result will be built */
494 Unit resbuff
[SD2U(DECBUFFER
+9)];/* local buffer in case need temporary */
495 /* [+9 allows for ln() constants] */
496 Unit
*allocres
=NULL
; /* -> allocated result, iff allocated */
497 Int d
=0; /* count of digits found in decimal part */
498 const char *dotchar
=NULL
; /* where dot was found */
499 const char *cfirst
=chars
; /* -> first character of decimal part */
500 const char *last
=NULL
; /* -> last digit of decimal part */
501 const char *c
; /* work */
504 Int cut
, out
; /* .. */
506 Int residue
; /* rounding residue */
507 uInt status
=0; /* error code */
510 if (decCheckOperands(DECUNRESU
, DECUNUSED
, DECUNUSED
, set
))
511 return decNumberZero(dn
);
514 do { /* status & malloc protection */
515 for (c
=chars
;; c
++) { /* -> input character */
516 if (*c
>='0' && *c
<='9') { /* test for Arabic digit */
518 d
++; /* count of real digits */
519 continue; /* still in decimal part */
521 if (*c
=='.' && dotchar
==NULL
) { /* first '.' */
522 dotchar
=c
; /* record offset into decimal part */
523 if (c
==cfirst
) cfirst
++; /* first digit must follow */
525 if (c
==chars
) { /* first in string... */
526 if (*c
=='-') { /* valid - sign */
530 if (*c
=='+') { /* valid + sign */
534 /* *c is not a digit, or a valid +, -, or '.' */
538 if (last
==NULL
) { /* no digits yet */
539 status
=DEC_Conversion_syntax
;/* assume the worst */
540 if (*c
=='\0') break; /* and no more to come... */
542 /* if subset then infinities and NaNs are not allowed */
543 if (!set
->extended
) break; /* hopeless */
545 /* Infinities and NaNs are possible, here */
546 if (dotchar
!=NULL
) break; /* .. unless had a dot */
547 decNumberZero(dn
); /* be optimistic */
548 if (decBiStr(c
, "infinity", "INFINITY")
549 || decBiStr(c
, "inf", "INF")) {
550 dn
->bits
=bits
| DECINF
;
551 status
=0; /* is OK */
552 break; /* all done */
555 /* 2003.09.10 NaNs are now permitted to have a sign */
556 dn
->bits
=bits
| DECNAN
; /* assume simple NaN */
557 if (*c
=='s' || *c
=='S') { /* looks like an sNaN */
559 dn
->bits
=bits
| DECSNAN
;
561 if (*c
!='n' && *c
!='N') break; /* check caseless "NaN" */
563 if (*c
!='a' && *c
!='A') break; /* .. */
565 if (*c
!='n' && *c
!='N') break; /* .. */
567 /* now either nothing, or nnnn payload, expected */
568 /* -> start of integer and skip leading 0s [including plain 0] */
569 for (cfirst
=c
; *cfirst
=='0';) cfirst
++;
570 if (*cfirst
=='\0') { /* "NaN" or "sNaN", maybe with all 0s */
571 status
=0; /* it's good */
574 /* something other than 0s; setup last and d as usual [no dots] */
575 for (c
=cfirst
;; c
++, d
++) {
576 if (*c
<'0' || *c
>'9') break; /* test for Arabic digit */
579 if (*c
!='\0') break; /* not all digits */
580 if (d
>set
->digits
-1) {
581 /* [NB: payload in a decNumber can be full length unless */
582 /* clamped, in which case can only be digits-1] */
583 if (set
->clamp
) break;
584 if (d
>set
->digits
) break;
585 } /* too many digits? */
586 /* good; drop through to convert the integer to coefficient */
587 status
=0; /* syntax is OK */
588 bits
=dn
->bits
; /* for copy-back */
591 else if (*c
!='\0') { /* more to process... */
592 /* had some digits; exponent is only valid sequence now */
593 Flag nege
; /* 1=negative exponent */
594 const char *firstexp
; /* -> first significant exponent digit */
595 status
=DEC_Conversion_syntax
;/* assume the worst */
596 if (*c
!='e' && *c
!='E') break;
597 /* Found 'e' or 'E' -- now process explicit exponent */
598 /* 1998.07.11: sign no longer required */
600 c
++; /* to (possible) sign */
601 if (*c
=='-') {nege
=1; c
++;}
602 else if (*c
=='+') c
++;
605 for (; *c
=='0' && *(c
+1)!='\0';) c
++; /* strip insignificant zeros */
606 firstexp
=c
; /* save exponent digit place */
608 if (*c
<'0' || *c
>'9') break; /* not a digit */
609 exponent
=X10(exponent
)+(Int
)*c
-(Int
)'0';
611 /* if not now on a '\0', *c must not be a digit */
614 /* (this next test must be after the syntax checks) */
615 /* if it was too long the exponent may have wrapped, so check */
616 /* carefully and set it to a certain overflow if wrap possible */
617 if (c
>=firstexp
+9+1) {
618 if (c
>firstexp
+9+1 || *firstexp
>'1') exponent
=DECNUMMAXE
*2;
619 /* [up to 1999999999 is OK, for example 1E-1000000998] */
621 if (nege
) exponent
=-exponent
; /* was negative */
622 status
=0; /* is OK */
623 } /* stuff after digits */
625 /* Here when whole string has been inspected; syntax is good */
626 /* cfirst->first digit (never dot), last->last digit (ditto) */
628 /* strip leading zeros/dot [leave final 0 if all 0's] */
629 if (*cfirst
=='0') { /* [cfirst has stepped over .] */
630 for (c
=cfirst
; c
<last
; c
++, cfirst
++) {
631 if (*c
=='.') continue; /* ignore dots */
632 if (*c
!='0') break; /* non-zero found */
633 d
--; /* 0 stripped */
636 /* make a rapid exit for easy zeros if !extended */
637 if (*cfirst
=='0' && !set
->extended
) {
638 decNumberZero(dn
); /* clean result */
639 break; /* [could be return] */
642 } /* at least one leading 0 */
644 /* Handle decimal point... */
645 if (dotchar
!=NULL
&& dotchar
<last
) /* non-trailing '.' found? */
646 exponent
-=(last
-dotchar
); /* adjust exponent */
647 /* [we can now ignore the .] */
649 /* OK, the digits string is good. Assemble in the decNumber, or in */
650 /* a temporary units array if rounding is needed */
651 if (d
<=set
->digits
) res
=dn
->lsu
; /* fits into supplied decNumber */
652 else { /* rounding needed */
653 Int needbytes
=D2U(d
)*sizeof(Unit
);/* bytes needed */
654 res
=resbuff
; /* assume use local buffer */
655 if (needbytes
>(Int
)sizeof(resbuff
)) { /* too big for local */
656 allocres
=(Unit
*)malloc(needbytes
);
657 if (allocres
==NULL
) {status
|=DEC_Insufficient_storage
; break;}
661 /* res now -> number lsu, buffer, or allocated storage for Unit array */
663 /* Place the coefficient into the selected Unit array */
664 /* [this is often 70% of the cost of this function when DECDPUN>1] */
666 out
=0; /* accumulator */
667 up
=res
+D2U(d
)-1; /* -> msu */
668 cut
=d
-(up
-res
)*DECDPUN
; /* digits in top unit */
669 for (c
=cfirst
;; c
++) { /* along the digits */
670 if (*c
=='.') continue; /* ignore '.' [don't decrement cut] */
671 out
=X10(out
)+(Int
)*c
-(Int
)'0';
672 if (c
==last
) break; /* done [never get to trailing '.'] */
674 if (cut
>0) continue; /* more for this unit */
675 *up
=(Unit
)out
; /* write unit */
676 up
--; /* prepare for unit below.. */
677 cut
=DECDPUN
; /* .. */
680 *up
=(Unit
)out
; /* write lsu */
685 for (c
=last
; c
>=cfirst
; c
--) { /* over each character, from least */
686 if (*c
=='.') continue; /* ignore . [don't step up] */
687 *up
=(Unit
)((Int
)*c
-(Int
)'0');
693 dn
->exponent
=exponent
;
696 /* if not in number (too long) shorten into the number */
699 decSetCoeff(dn
, set
, res
, d
, &residue
, &status
);
700 /* always check for overflow or subnormal and round as needed */
701 decFinalize(dn
, set
, &residue
, &status
);
703 else { /* no rounding, but may still have overflow or subnormal */
704 /* [these tests are just for performance; finalize repeats them] */
705 if ((dn
->exponent
-1<set
->emin
-dn
->digits
)
706 || (dn
->exponent
-1>set
->emax
-set
->digits
)) {
708 decFinalize(dn
, set
, &residue
, &status
);
711 /* decNumberShow(dn); */
712 } while(0); /* [for break] */
714 free(allocres
); /* drop any storage used */
715 if (status
!=0) decStatus(dn
, status
, set
);
717 } /* decNumberFromString */
719 /* ================================================================== */
721 /* ================================================================== */
723 /* ------------------------------------------------------------------ */
724 /* decNumberAbs -- absolute value operator */
726 /* This computes C = abs(A) */
728 /* res is C, the result. C may be A */
730 /* set is the context */
732 /* See also decNumberCopyAbs for a quiet bitwise version of this. */
733 /* C must have space for set->digits digits. */
734 /* ------------------------------------------------------------------ */
735 /* This has the same effect as decNumberPlus unless A is negative, */
736 /* in which case it has the same effect as decNumberMinus. */
737 /* ------------------------------------------------------------------ */
738 decNumber
* decNumberAbs(decNumber
*res
, const decNumber
*rhs
,
740 decNumber dzero
; /* for 0 */
741 uInt status
=0; /* accumulator */
744 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
747 decNumberZero(&dzero
); /* set 0 */
748 dzero
.exponent
=rhs
->exponent
; /* [no coefficient expansion] */
749 decAddOp(res
, &dzero
, rhs
, set
, (uByte
)(rhs
->bits
& DECNEG
), &status
);
750 if (status
!=0) decStatus(res
, status
, set
);
752 decCheckInexact(res
, set
);
757 /* ------------------------------------------------------------------ */
758 /* decNumberAdd -- add two Numbers */
760 /* This computes C = A + B */
762 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */
765 /* set is the context */
767 /* C must have space for set->digits digits. */
768 /* ------------------------------------------------------------------ */
769 /* This just calls the routine shared with Subtract */
770 decNumber
* decNumberAdd(decNumber
*res
, const decNumber
*lhs
,
771 const decNumber
*rhs
, decContext
*set
) {
772 uInt status
=0; /* accumulator */
773 decAddOp(res
, lhs
, rhs
, set
, 0, &status
);
774 if (status
!=0) decStatus(res
, status
, set
);
776 decCheckInexact(res
, set
);
781 /* ------------------------------------------------------------------ */
782 /* decNumberAnd -- AND two Numbers, digitwise */
784 /* This computes C = A & B */
786 /* res is C, the result. C may be A and/or B (e.g., X=X&X) */
789 /* set is the context (used for result length and error report) */
791 /* C must have space for set->digits digits. */
793 /* Logical function restrictions apply (see above); a NaN is */
794 /* returned with Invalid_operation if a restriction is violated. */
795 /* ------------------------------------------------------------------ */
796 decNumber
* decNumberAnd(decNumber
*res
, const decNumber
*lhs
,
797 const decNumber
*rhs
, decContext
*set
) {
798 const Unit
*ua
, *ub
; /* -> operands */
799 const Unit
*msua
, *msub
; /* -> operand msus */
800 Unit
*uc
, *msuc
; /* -> result and its msu */
801 Int msudigs
; /* digits in res msu */
803 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
806 if (lhs
->exponent
!=0 || decNumberIsSpecial(lhs
) || decNumberIsNegative(lhs
)
807 || rhs
->exponent
!=0 || decNumberIsSpecial(rhs
) || decNumberIsNegative(rhs
)) {
808 decStatus(res
, DEC_Invalid_operation
, set
);
812 /* operands are valid */
813 ua
=lhs
->lsu
; /* bottom-up */
814 ub
=rhs
->lsu
; /* .. */
815 uc
=res
->lsu
; /* .. */
816 msua
=ua
+D2U(lhs
->digits
)-1; /* -> msu of lhs */
817 msub
=ub
+D2U(rhs
->digits
)-1; /* -> msu of rhs */
818 msuc
=uc
+D2U(set
->digits
)-1; /* -> msu of result */
819 msudigs
=MSUDIGITS(set
->digits
); /* [faster than remainder] */
820 for (; uc
<=msuc
; ua
++, ub
++, uc
++) { /* Unit loop */
821 Unit a
, b
; /* extract units */
826 *uc
=0; /* can now write back */
827 if (a
|b
) { /* maybe 1 bits to examine */
829 *uc
=0; /* can now write back */
830 /* This loop could be unrolled and/or use BIN2BCD tables */
831 for (i
=0; i
<DECDPUN
; i
++) {
832 if (a
&b
&1) *uc
=*uc
+(Unit
)powers
[i
]; /* effect AND */
838 decStatus(res
, DEC_Invalid_operation
, set
);
841 if (uc
==msuc
&& i
==msudigs
-1) break; /* just did final digit */
845 /* [here uc-1 is the msu of the result] */
846 res
->digits
=decGetDigits(res
->lsu
, uc
-res
->lsu
);
847 res
->exponent
=0; /* integer */
848 res
->bits
=0; /* sign=0 */
849 return res
; /* [no status to set] */
852 /* ------------------------------------------------------------------ */
853 /* decNumberCompare -- compare two Numbers */
855 /* This computes C = A ? B */
857 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
860 /* set is the context */
862 /* C must have space for one digit (or NaN). */
863 /* ------------------------------------------------------------------ */
864 decNumber
* decNumberCompare(decNumber
*res
, const decNumber
*lhs
,
865 const decNumber
*rhs
, decContext
*set
) {
866 uInt status
=0; /* accumulator */
867 decCompareOp(res
, lhs
, rhs
, set
, COMPARE
, &status
);
868 if (status
!=0) decStatus(res
, status
, set
);
870 } /* decNumberCompare */
872 /* ------------------------------------------------------------------ */
873 /* decNumberCompareSignal -- compare, signalling on all NaNs */
875 /* This computes C = A ? B */
877 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
880 /* set is the context */
882 /* C must have space for one digit (or NaN). */
883 /* ------------------------------------------------------------------ */
884 decNumber
* decNumberCompareSignal(decNumber
*res
, const decNumber
*lhs
,
885 const decNumber
*rhs
, decContext
*set
) {
886 uInt status
=0; /* accumulator */
887 decCompareOp(res
, lhs
, rhs
, set
, COMPSIG
, &status
);
888 if (status
!=0) decStatus(res
, status
, set
);
890 } /* decNumberCompareSignal */
892 /* ------------------------------------------------------------------ */
893 /* decNumberCompareTotal -- compare two Numbers, using total ordering */
895 /* This computes C = A ? B, under total ordering */
897 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
900 /* set is the context */
902 /* C must have space for one digit; the result will always be one of */
904 /* ------------------------------------------------------------------ */
905 decNumber
* decNumberCompareTotal(decNumber
*res
, const decNumber
*lhs
,
906 const decNumber
*rhs
, decContext
*set
) {
907 uInt status
=0; /* accumulator */
908 decCompareOp(res
, lhs
, rhs
, set
, COMPTOTAL
, &status
);
909 if (status
!=0) decStatus(res
, status
, set
);
911 } /* decNumberCompareTotal */
913 /* ------------------------------------------------------------------ */
914 /* decNumberCompareTotalMag -- compare, total ordering of magnitudes */
916 /* This computes C = |A| ? |B|, under total ordering */
918 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
921 /* set is the context */
923 /* C must have space for one digit; the result will always be one of */
925 /* ------------------------------------------------------------------ */
926 decNumber
* decNumberCompareTotalMag(decNumber
*res
, const decNumber
*lhs
,
927 const decNumber
*rhs
, decContext
*set
) {
928 uInt status
=0; /* accumulator */
929 uInt needbytes
; /* for space calculations */
930 decNumber bufa
[D2N(DECBUFFER
+1)];/* +1 in case DECBUFFER=0 */
931 decNumber
*allocbufa
=NULL
; /* -> allocated bufa, iff allocated */
932 decNumber bufb
[D2N(DECBUFFER
+1)];
933 decNumber
*allocbufb
=NULL
; /* -> allocated bufb, iff allocated */
934 decNumber
*a
, *b
; /* temporary pointers */
937 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
940 do { /* protect allocated storage */
941 /* if either is negative, take a copy and absolute */
942 if (decNumberIsNegative(lhs
)) { /* lhs<0 */
944 needbytes
=sizeof(decNumber
)+(D2U(lhs
->digits
)-1)*sizeof(Unit
);
945 if (needbytes
>sizeof(bufa
)) { /* need malloc space */
946 allocbufa
=(decNumber
*)malloc(needbytes
);
947 if (allocbufa
==NULL
) { /* hopeless -- abandon */
948 status
|=DEC_Insufficient_storage
;
950 a
=allocbufa
; /* use the allocated space */
952 decNumberCopy(a
, lhs
); /* copy content */
953 a
->bits
&=~DECNEG
; /* .. and clear the sign */
954 lhs
=a
; /* use copy from here on */
956 if (decNumberIsNegative(rhs
)) { /* rhs<0 */
958 needbytes
=sizeof(decNumber
)+(D2U(rhs
->digits
)-1)*sizeof(Unit
);
959 if (needbytes
>sizeof(bufb
)) { /* need malloc space */
960 allocbufb
=(decNumber
*)malloc(needbytes
);
961 if (allocbufb
==NULL
) { /* hopeless -- abandon */
962 status
|=DEC_Insufficient_storage
;
964 b
=allocbufb
; /* use the allocated space */
966 decNumberCopy(b
, rhs
); /* copy content */
967 b
->bits
&=~DECNEG
; /* .. and clear the sign */
968 rhs
=b
; /* use copy from here on */
970 decCompareOp(res
, lhs
, rhs
, set
, COMPTOTAL
, &status
);
971 } while(0); /* end protected */
973 free(allocbufa
); /* drop any storage used */
974 free(allocbufb
); /* .. */
975 if (status
!=0) decStatus(res
, status
, set
);
977 } /* decNumberCompareTotalMag */
979 /* ------------------------------------------------------------------ */
980 /* decNumberDivide -- divide one number by another */
982 /* This computes C = A / B */
984 /* res is C, the result. C may be A and/or B (e.g., X=X/X) */
987 /* set is the context */
989 /* C must have space for set->digits digits. */
990 /* ------------------------------------------------------------------ */
991 decNumber
* decNumberDivide(decNumber
*res
, const decNumber
*lhs
,
992 const decNumber
*rhs
, decContext
*set
) {
993 uInt status
=0; /* accumulator */
994 decDivideOp(res
, lhs
, rhs
, set
, DIVIDE
, &status
);
995 if (status
!=0) decStatus(res
, status
, set
);
997 decCheckInexact(res
, set
);
1000 } /* decNumberDivide */
1002 /* ------------------------------------------------------------------ */
1003 /* decNumberDivideInteger -- divide and return integer quotient */
1005 /* This computes C = A # B, where # is the integer divide operator */
1007 /* res is C, the result. C may be A and/or B (e.g., X=X#X) */
1010 /* set is the context */
1012 /* C must have space for set->digits digits. */
1013 /* ------------------------------------------------------------------ */
1014 decNumber
* decNumberDivideInteger(decNumber
*res
, const decNumber
*lhs
,
1015 const decNumber
*rhs
, decContext
*set
) {
1016 uInt status
=0; /* accumulator */
1017 decDivideOp(res
, lhs
, rhs
, set
, DIVIDEINT
, &status
);
1018 if (status
!=0) decStatus(res
, status
, set
);
1020 } /* decNumberDivideInteger */
1022 /* ------------------------------------------------------------------ */
1023 /* decNumberExp -- exponentiation */
1025 /* This computes C = exp(A) */
1027 /* res is C, the result. C may be A */
1029 /* set is the context; note that rounding mode has no effect */
1031 /* C must have space for set->digits digits. */
1033 /* Mathematical function restrictions apply (see above); a NaN is */
1034 /* returned with Invalid_operation if a restriction is violated. */
1036 /* Finite results will always be full precision and Inexact, except */
1037 /* when A is a zero or -Infinity (giving 1 or 0 respectively). */
1039 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */
1040 /* almost always be correctly rounded, but may be up to 1 ulp in */
1041 /* error in rare cases. */
1042 /* ------------------------------------------------------------------ */
1043 /* This is a wrapper for decExpOp which can handle the slightly wider */
1044 /* (double) range needed by Ln (which has to be able to calculate */
1045 /* exp(-a) where a can be the tiniest number (Ntiny). */
1046 /* ------------------------------------------------------------------ */
1047 decNumber
* decNumberExp(decNumber
*res
, const decNumber
*rhs
,
1049 uInt status
=0; /* accumulator */
1051 decNumber
*allocrhs
=NULL
; /* non-NULL if rounded rhs allocated */
1055 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
1058 /* Check restrictions; these restrictions ensure that if h=8 (see */
1059 /* decExpOp) then the result will either overflow or underflow to 0. */
1060 /* Other math functions restrict the input range, too, for inverses. */
1061 /* If not violated then carry out the operation. */
1062 if (!decCheckMath(rhs
, set
, &status
)) do { /* protect allocation */
1064 if (!set
->extended
) {
1065 /* reduce operand and set lostDigits status, as needed */
1066 if (rhs
->digits
>set
->digits
) {
1067 allocrhs
=decRoundOperand(rhs
, set
, &status
);
1068 if (allocrhs
==NULL
) break;
1073 decExpOp(res
, rhs
, set
, &status
);
1074 } while(0); /* end protected */
1077 free(allocrhs
); /* drop any storage used */
1079 /* apply significant status */
1080 if (status
!=0) decStatus(res
, status
, set
);
1082 decCheckInexact(res
, set
);
1085 } /* decNumberExp */
1087 /* ------------------------------------------------------------------ */
1088 /* decNumberFMA -- fused multiply add */
1090 /* This computes D = (A * B) + C with only one rounding */
1092 /* res is D, the result. D may be A or B or C (e.g., X=FMA(X,X,X)) */
1095 /* fhs is C [far hand side] */
1096 /* set is the context */
1098 /* Mathematical function restrictions apply (see above); a NaN is */
1099 /* returned with Invalid_operation if a restriction is violated. */
1101 /* C must have space for set->digits digits. */
1102 /* ------------------------------------------------------------------ */
1103 decNumber
* decNumberFMA(decNumber
*res
, const decNumber
*lhs
,
1104 const decNumber
*rhs
, const decNumber
*fhs
,
1106 uInt status
=0; /* accumulator */
1107 decContext dcmul
; /* context for the multiplication */
1108 uInt needbytes
; /* for space calculations */
1109 decNumber bufa
[D2N(DECBUFFER
*2+1)];
1110 decNumber
*allocbufa
=NULL
; /* -> allocated bufa, iff allocated */
1111 decNumber
*acc
; /* accumulator pointer */
1112 decNumber dzero
; /* work */
1115 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
1116 if (decCheckOperands(res
, fhs
, DECUNUSED
, set
)) return res
;
1119 do { /* protect allocated storage */
1121 if (!set
->extended
) { /* [undefined if subset] */
1122 status
|=DEC_Invalid_operation
;
1125 /* Check math restrictions [these ensure no overflow or underflow] */
1126 if ((!decNumberIsSpecial(lhs
) && decCheckMath(lhs
, set
, &status
))
1127 || (!decNumberIsSpecial(rhs
) && decCheckMath(rhs
, set
, &status
))
1128 || (!decNumberIsSpecial(fhs
) && decCheckMath(fhs
, set
, &status
))) break;
1129 /* set up context for multiply */
1131 dcmul
.digits
=lhs
->digits
+rhs
->digits
; /* just enough */
1132 /* [The above may be an over-estimate for subset arithmetic, but that's OK] */
1133 dcmul
.emax
=DEC_MAX_EMAX
; /* effectively unbounded .. */
1134 dcmul
.emin
=DEC_MIN_EMIN
; /* [thanks to Math restrictions] */
1135 /* set up decNumber space to receive the result of the multiply */
1136 acc
=bufa
; /* may fit */
1137 needbytes
=sizeof(decNumber
)+(D2U(dcmul
.digits
)-1)*sizeof(Unit
);
1138 if (needbytes
>sizeof(bufa
)) { /* need malloc space */
1139 allocbufa
=(decNumber
*)malloc(needbytes
);
1140 if (allocbufa
==NULL
) { /* hopeless -- abandon */
1141 status
|=DEC_Insufficient_storage
;
1143 acc
=allocbufa
; /* use the allocated space */
1145 /* multiply with extended range and necessary precision */
1146 /*printf("emin=%ld\n", dcmul.emin); */
1147 decMultiplyOp(acc
, lhs
, rhs
, &dcmul
, &status
);
1148 /* Only Invalid operation (from sNaN or Inf * 0) is possible in */
1149 /* status; if either is seen than ignore fhs (in case it is */
1150 /* another sNaN) and set acc to NaN unless we had an sNaN */
1151 /* [decMultiplyOp leaves that to caller] */
1152 /* Note sNaN has to go through addOp to shorten payload if */
1154 if ((status
&DEC_Invalid_operation
)!=0) {
1155 if (!(status
&DEC_sNaN
)) { /* but be true invalid */
1156 decNumberZero(res
); /* acc not yet set */
1160 decNumberZero(&dzero
); /* make 0 (any non-NaN would do) */
1161 fhs
=&dzero
; /* use that */
1164 else { /* multiply was OK */
1165 if (status
!=0) printf("Status=%08lx after FMA multiply\n", (LI
)status
);
1168 /* add the third operand and result -> res, and all is done */
1169 decAddOp(res
, acc
, fhs
, set
, 0, &status
);
1170 } while(0); /* end protected */
1172 free(allocbufa
); /* drop any storage used */
1173 if (status
!=0) decStatus(res
, status
, set
);
1175 decCheckInexact(res
, set
);
1178 } /* decNumberFMA */
1180 /* ------------------------------------------------------------------ */
1181 /* decNumberInvert -- invert a Number, digitwise */
1183 /* This computes C = ~A */
1185 /* res is C, the result. C may be A (e.g., X=~X) */
1187 /* set is the context (used for result length and error report) */
1189 /* C must have space for set->digits digits. */
1191 /* Logical function restrictions apply (see above); a NaN is */
1192 /* returned with Invalid_operation if a restriction is violated. */
1193 /* ------------------------------------------------------------------ */
1194 decNumber
* decNumberInvert(decNumber
*res
, const decNumber
*rhs
,
1196 const Unit
*ua
, *msua
; /* -> operand and its msu */
1197 Unit
*uc
, *msuc
; /* -> result and its msu */
1198 Int msudigs
; /* digits in res msu */
1200 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
1203 if (rhs
->exponent
!=0 || decNumberIsSpecial(rhs
) || decNumberIsNegative(rhs
)) {
1204 decStatus(res
, DEC_Invalid_operation
, set
);
1207 /* operand is valid */
1208 ua
=rhs
->lsu
; /* bottom-up */
1209 uc
=res
->lsu
; /* .. */
1210 msua
=ua
+D2U(rhs
->digits
)-1; /* -> msu of rhs */
1211 msuc
=uc
+D2U(set
->digits
)-1; /* -> msu of result */
1212 msudigs
=MSUDIGITS(set
->digits
); /* [faster than remainder] */
1213 for (; uc
<=msuc
; ua
++, uc
++) { /* Unit loop */
1214 Unit a
; /* extract unit */
1215 Int i
, j
; /* work */
1218 *uc
=0; /* can now write back */
1219 /* always need to examine all bits in rhs */
1220 /* This loop could be unrolled and/or use BIN2BCD tables */
1221 for (i
=0; i
<DECDPUN
; i
++) {
1222 if ((~a
)&1) *uc
=*uc
+(Unit
)powers
[i
]; /* effect INVERT */
1226 decStatus(res
, DEC_Invalid_operation
, set
);
1229 if (uc
==msuc
&& i
==msudigs
-1) break; /* just did final digit */
1232 /* [here uc-1 is the msu of the result] */
1233 res
->digits
=decGetDigits(res
->lsu
, uc
-res
->lsu
);
1234 res
->exponent
=0; /* integer */
1235 res
->bits
=0; /* sign=0 */
1236 return res
; /* [no status to set] */
1237 } /* decNumberInvert */
1239 /* ------------------------------------------------------------------ */
1240 /* decNumberLn -- natural logarithm */
1242 /* This computes C = ln(A) */
1244 /* res is C, the result. C may be A */
1246 /* set is the context; note that rounding mode has no effect */
1248 /* C must have space for set->digits digits. */
1250 /* Notable cases: */
1251 /* A<0 -> Invalid */
1252 /* A=0 -> -Infinity (Exact) */
1253 /* A=+Infinity -> +Infinity (Exact) */
1254 /* A=1 exactly -> 0 (Exact) */
1256 /* Mathematical function restrictions apply (see above); a NaN is */
1257 /* returned with Invalid_operation if a restriction is violated. */
1259 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */
1260 /* almost always be correctly rounded, but may be up to 1 ulp in */
1261 /* error in rare cases. */
1262 /* ------------------------------------------------------------------ */
1263 /* This is a wrapper for decLnOp which can handle the slightly wider */
1264 /* (+11) range needed by Ln, Log10, etc. (which may have to be able */
1265 /* to calculate at p+e+2). */
1266 /* ------------------------------------------------------------------ */
1267 decNumber
* decNumberLn(decNumber
*res
, const decNumber
*rhs
,
1269 uInt status
=0; /* accumulator */
1271 decNumber
*allocrhs
=NULL
; /* non-NULL if rounded rhs allocated */
1275 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
1278 /* Check restrictions; this is a math function; if not violated */
1279 /* then carry out the operation. */
1280 if (!decCheckMath(rhs
, set
, &status
)) do { /* protect allocation */
1282 if (!set
->extended
) {
1283 /* reduce operand and set lostDigits status, as needed */
1284 if (rhs
->digits
>set
->digits
) {
1285 allocrhs
=decRoundOperand(rhs
, set
, &status
);
1286 if (allocrhs
==NULL
) break;
1289 /* special check in subset for rhs=0 */
1290 if (ISZERO(rhs
)) { /* +/- zeros -> error */
1291 status
|=DEC_Invalid_operation
;
1295 decLnOp(res
, rhs
, set
, &status
);
1296 } while(0); /* end protected */
1299 free(allocrhs
); /* drop any storage used */
1301 /* apply significant status */
1302 if (status
!=0) decStatus(res
, status
, set
);
1304 decCheckInexact(res
, set
);
1309 /* ------------------------------------------------------------------ */
1310 /* decNumberLogB - get adjusted exponent, by 754 rules */
1312 /* This computes C = adjustedexponent(A) */
1314 /* res is C, the result. C may be A */
1316 /* set is the context, used only for digits and status */
1318 /* C must have space for 10 digits (A might have 10**9 digits and */
1319 /* an exponent of +999999999, or one digit and an exponent of */
1322 /* This returns the adjusted exponent of A after (in theory) padding */
1323 /* with zeros on the right to set->digits digits while keeping the */
1324 /* same value. The exponent is not limited by emin/emax. */
1326 /* Notable cases: */
1327 /* A<0 -> Use |A| */
1328 /* A=0 -> -Infinity (Division by zero) */
1329 /* A=Infinite -> +Infinity (Exact) */
1330 /* A=1 exactly -> 0 (Exact) */
1331 /* NaNs are propagated as usual */
1332 /* ------------------------------------------------------------------ */
1333 decNumber
* decNumberLogB(decNumber
*res
, const decNumber
*rhs
,
1335 uInt status
=0; /* accumulator */
1338 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
1341 /* NaNs as usual; Infinities return +Infinity; 0->oops */
1342 if (decNumberIsNaN(rhs
)) decNaNs(res
, rhs
, NULL
, set
, &status
);
1343 else if (decNumberIsInfinite(rhs
)) decNumberCopyAbs(res
, rhs
);
1344 else if (decNumberIsZero(rhs
)) {
1345 decNumberZero(res
); /* prepare for Infinity */
1346 res
->bits
=DECNEG
|DECINF
; /* -Infinity */
1347 status
|=DEC_Division_by_zero
; /* as per 754 */
1349 else { /* finite non-zero */
1350 Int ae
=rhs
->exponent
+rhs
->digits
-1; /* adjusted exponent */
1351 decNumberFromInt32(res
, ae
); /* lay it out */
1354 if (status
!=0) decStatus(res
, status
, set
);
1356 } /* decNumberLogB */
1358 /* ------------------------------------------------------------------ */
1359 /* decNumberLog10 -- logarithm in base 10 */
1361 /* This computes C = log10(A) */
1363 /* res is C, the result. C may be A */
1365 /* set is the context; note that rounding mode has no effect */
1367 /* C must have space for set->digits digits. */
1369 /* Notable cases: */
1370 /* A<0 -> Invalid */
1371 /* A=0 -> -Infinity (Exact) */
1372 /* A=+Infinity -> +Infinity (Exact) */
1373 /* A=10**n (if n is an integer) -> n (Exact) */
1375 /* Mathematical function restrictions apply (see above); a NaN is */
1376 /* returned with Invalid_operation if a restriction is violated. */
1378 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */
1379 /* almost always be correctly rounded, but may be up to 1 ulp in */
1380 /* error in rare cases. */
1381 /* ------------------------------------------------------------------ */
1382 /* This calculates ln(A)/ln(10) using appropriate precision. For */
1383 /* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the */
1384 /* requested digits and t is the number of digits in the exponent */
1385 /* (maximum 6). For ln(10) it is p + 3; this is often handled by the */
1386 /* fastpath in decLnOp. The final division is done to the requested */
1388 /* ------------------------------------------------------------------ */
1389 decNumber
* decNumberLog10(decNumber
*res
, const decNumber
*rhs
,
1391 uInt status
=0, ignore
=0; /* status accumulators */
1392 uInt needbytes
; /* for space calculations */
1393 Int p
; /* working precision */
1394 Int t
; /* digits in exponent of A */
1396 /* buffers for a and b working decimals */
1397 /* (adjustment calculator, same size) */
1398 decNumber bufa
[D2N(DECBUFFER
+2)];
1399 decNumber
*allocbufa
=NULL
; /* -> allocated bufa, iff allocated */
1400 decNumber
*a
=bufa
; /* temporary a */
1401 decNumber bufb
[D2N(DECBUFFER
+2)];
1402 decNumber
*allocbufb
=NULL
; /* -> allocated bufb, iff allocated */
1403 decNumber
*b
=bufb
; /* temporary b */
1404 decNumber bufw
[D2N(10)]; /* working 2-10 digit number */
1405 decNumber
*w
=bufw
; /* .. */
1407 decNumber
*allocrhs
=NULL
; /* non-NULL if rounded rhs allocated */
1410 decContext aset
; /* working context */
1413 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
1416 /* Check restrictions; this is a math function; if not violated */
1417 /* then carry out the operation. */
1418 if (!decCheckMath(rhs
, set
, &status
)) do { /* protect malloc */
1420 if (!set
->extended
) {
1421 /* reduce operand and set lostDigits status, as needed */
1422 if (rhs
->digits
>set
->digits
) {
1423 allocrhs
=decRoundOperand(rhs
, set
, &status
);
1424 if (allocrhs
==NULL
) break;
1427 /* special check in subset for rhs=0 */
1428 if (ISZERO(rhs
)) { /* +/- zeros -> error */
1429 status
|=DEC_Invalid_operation
;
1434 decContextDefault(&aset
, DEC_INIT_DECIMAL64
); /* clean context */
1436 /* handle exact powers of 10; only check if +ve finite */
1437 if (!(rhs
->bits
&(DECNEG
|DECSPECIAL
)) && !ISZERO(rhs
)) {
1438 Int residue
=0; /* (no residue) */
1439 uInt copystat
=0; /* clean status */
1441 /* round to a single digit... */
1443 decCopyFit(w
, rhs
, &aset
, &residue
, ©stat
); /* copy & shorten */
1444 /* if exact and the digit is 1, rhs is a power of 10 */
1445 if (!(copystat
&DEC_Inexact
) && w
->lsu
[0]==1) {
1446 /* the exponent, conveniently, is the power of 10; making */
1447 /* this the result needs a little care as it might not fit, */
1448 /* so first convert it into the working number, and then move */
1450 decNumberFromInt32(w
, w
->exponent
);
1452 decCopyFit(res
, w
, set
, &residue
, &status
); /* copy & round */
1453 decFinish(res
, set
, &residue
, &status
); /* cleanup/set flags */
1455 } /* not a power of 10 */
1456 } /* not a candidate for exact */
1458 /* simplify the information-content calculation to use 'total */
1459 /* number of digits in a, including exponent' as compared to the */
1460 /* requested digits, as increasing this will only rarely cost an */
1461 /* iteration in ln(a) anyway */
1462 t
=6; /* it can never be >6 */
1464 /* allocate space when needed... */
1465 p
=(rhs
->digits
+t
>set
->digits
?rhs
->digits
+t
:set
->digits
)+3;
1466 needbytes
=sizeof(decNumber
)+(D2U(p
)-1)*sizeof(Unit
);
1467 if (needbytes
>sizeof(bufa
)) { /* need malloc space */
1468 allocbufa
=(decNumber
*)malloc(needbytes
);
1469 if (allocbufa
==NULL
) { /* hopeless -- abandon */
1470 status
|=DEC_Insufficient_storage
;
1472 a
=allocbufa
; /* use the allocated space */
1474 aset
.digits
=p
; /* as calculated */
1475 aset
.emax
=DEC_MAX_MATH
; /* usual bounds */
1476 aset
.emin
=-DEC_MAX_MATH
; /* .. */
1477 aset
.clamp
=0; /* and no concrete format */
1478 decLnOp(a
, rhs
, &aset
, &status
); /* a=ln(rhs) */
1480 /* skip the division if the result so far is infinite, NaN, or */
1481 /* zero, or there was an error; note NaN from sNaN needs copy */
1482 if (status
&DEC_NaNs
&& !(status
&DEC_sNaN
)) break;
1483 if (a
->bits
&DECSPECIAL
|| ISZERO(a
)) {
1484 decNumberCopy(res
, a
); /* [will fit] */
1487 /* for ln(10) an extra 3 digits of precision are needed */
1489 needbytes
=sizeof(decNumber
)+(D2U(p
)-1)*sizeof(Unit
);
1490 if (needbytes
>sizeof(bufb
)) { /* need malloc space */
1491 allocbufb
=(decNumber
*)malloc(needbytes
);
1492 if (allocbufb
==NULL
) { /* hopeless -- abandon */
1493 status
|=DEC_Insufficient_storage
;
1495 b
=allocbufb
; /* use the allocated space */
1497 decNumberZero(w
); /* set up 10... */
1499 w
->lsu
[1]=1; w
->lsu
[0]=0; /* .. */
1501 w
->lsu
[0]=10; /* .. */
1503 w
->digits
=2; /* .. */
1506 decLnOp(b
, w
, &aset
, &ignore
); /* b=ln(10) */
1508 aset
.digits
=set
->digits
; /* for final divide */
1509 decDivideOp(res
, a
, b
, &aset
, DIVIDE
, &status
); /* into result */
1510 } while(0); /* [for break] */
1512 free(allocbufa
); /* drop any storage used */
1513 free(allocbufb
); /* .. */
1515 free(allocrhs
); /* .. */
1517 /* apply significant status */
1518 if (status
!=0) decStatus(res
, status
, set
);
1520 decCheckInexact(res
, set
);
1523 } /* decNumberLog10 */
1525 /* ------------------------------------------------------------------ */
1526 /* decNumberMax -- compare two Numbers and return the maximum */
1528 /* This computes C = A ? B, returning the maximum by 754 rules */
1530 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1533 /* set is the context */
1535 /* C must have space for set->digits digits. */
1536 /* ------------------------------------------------------------------ */
1537 decNumber
* decNumberMax(decNumber
*res
, const decNumber
*lhs
,
1538 const decNumber
*rhs
, decContext
*set
) {
1539 uInt status
=0; /* accumulator */
1540 decCompareOp(res
, lhs
, rhs
, set
, COMPMAX
, &status
);
1541 if (status
!=0) decStatus(res
, status
, set
);
1543 decCheckInexact(res
, set
);
1546 } /* decNumberMax */
1548 /* ------------------------------------------------------------------ */
1549 /* decNumberMaxMag -- compare and return the maximum by magnitude */
1551 /* This computes C = A ? B, returning the maximum by 754 rules */
1553 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1556 /* set is the context */
1558 /* C must have space for set->digits digits. */
1559 /* ------------------------------------------------------------------ */
1560 decNumber
* decNumberMaxMag(decNumber
*res
, const decNumber
*lhs
,
1561 const decNumber
*rhs
, decContext
*set
) {
1562 uInt status
=0; /* accumulator */
1563 decCompareOp(res
, lhs
, rhs
, set
, COMPMAXMAG
, &status
);
1564 if (status
!=0) decStatus(res
, status
, set
);
1566 decCheckInexact(res
, set
);
1569 } /* decNumberMaxMag */
1571 /* ------------------------------------------------------------------ */
1572 /* decNumberMin -- compare two Numbers and return the minimum */
1574 /* This computes C = A ? B, returning the minimum by 754 rules */
1576 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1579 /* set is the context */
1581 /* C must have space for set->digits digits. */
1582 /* ------------------------------------------------------------------ */
1583 decNumber
* decNumberMin(decNumber
*res
, const decNumber
*lhs
,
1584 const decNumber
*rhs
, decContext
*set
) {
1585 uInt status
=0; /* accumulator */
1586 decCompareOp(res
, lhs
, rhs
, set
, COMPMIN
, &status
);
1587 if (status
!=0) decStatus(res
, status
, set
);
1589 decCheckInexact(res
, set
);
1592 } /* decNumberMin */
1594 /* ------------------------------------------------------------------ */
1595 /* decNumberMinMag -- compare and return the minimum by magnitude */
1597 /* This computes C = A ? B, returning the minimum by 754 rules */
1599 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1602 /* set is the context */
1604 /* C must have space for set->digits digits. */
1605 /* ------------------------------------------------------------------ */
1606 decNumber
* decNumberMinMag(decNumber
*res
, const decNumber
*lhs
,
1607 const decNumber
*rhs
, decContext
*set
) {
1608 uInt status
=0; /* accumulator */
1609 decCompareOp(res
, lhs
, rhs
, set
, COMPMINMAG
, &status
);
1610 if (status
!=0) decStatus(res
, status
, set
);
1612 decCheckInexact(res
, set
);
1615 } /* decNumberMinMag */
1617 /* ------------------------------------------------------------------ */
1618 /* decNumberMinus -- prefix minus operator */
1620 /* This computes C = 0 - A */
1622 /* res is C, the result. C may be A */
1624 /* set is the context */
1626 /* See also decNumberCopyNegate for a quiet bitwise version of this. */
1627 /* C must have space for set->digits digits. */
1628 /* ------------------------------------------------------------------ */
1629 /* Simply use AddOp for the subtract, which will do the necessary. */
1630 /* ------------------------------------------------------------------ */
1631 decNumber
* decNumberMinus(decNumber
*res
, const decNumber
*rhs
,
1634 uInt status
=0; /* accumulator */
1637 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
1640 decNumberZero(&dzero
); /* make 0 */
1641 dzero
.exponent
=rhs
->exponent
; /* [no coefficient expansion] */
1642 decAddOp(res
, &dzero
, rhs
, set
, DECNEG
, &status
);
1643 if (status
!=0) decStatus(res
, status
, set
);
1645 decCheckInexact(res
, set
);
1648 } /* decNumberMinus */
1650 /* ------------------------------------------------------------------ */
1651 /* decNumberNextMinus -- next towards -Infinity */
1653 /* This computes C = A - infinitesimal, rounded towards -Infinity */
1655 /* res is C, the result. C may be A */
1657 /* set is the context */
1659 /* This is a generalization of 754 NextDown. */
1660 /* ------------------------------------------------------------------ */
1661 decNumber
* decNumberNextMinus(decNumber
*res
, const decNumber
*rhs
,
1663 decNumber dtiny
; /* constant */
1664 decContext workset
=*set
; /* work */
1665 uInt status
=0; /* accumulator */
1667 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
1670 /* +Infinity is the special case */
1671 if ((rhs
->bits
&(DECINF
|DECNEG
))==DECINF
) {
1672 decSetMaxValue(res
, set
); /* is +ve */
1673 /* there is no status to set */
1676 decNumberZero(&dtiny
); /* start with 0 */
1677 dtiny
.lsu
[0]=1; /* make number that is .. */
1678 dtiny
.exponent
=DEC_MIN_EMIN
-1; /* .. smaller than tiniest */
1679 workset
.round
=DEC_ROUND_FLOOR
;
1680 decAddOp(res
, rhs
, &dtiny
, &workset
, DECNEG
, &status
);
1681 status
&=DEC_Invalid_operation
|DEC_sNaN
; /* only sNaN Invalid please */
1682 if (status
!=0) decStatus(res
, status
, set
);
1684 } /* decNumberNextMinus */
1686 /* ------------------------------------------------------------------ */
1687 /* decNumberNextPlus -- next towards +Infinity */
1689 /* This computes C = A + infinitesimal, rounded towards +Infinity */
1691 /* res is C, the result. C may be A */
1693 /* set is the context */
1695 /* This is a generalization of 754 NextUp. */
1696 /* ------------------------------------------------------------------ */
1697 decNumber
* decNumberNextPlus(decNumber
*res
, const decNumber
*rhs
,
1699 decNumber dtiny
; /* constant */
1700 decContext workset
=*set
; /* work */
1701 uInt status
=0; /* accumulator */
1703 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
1706 /* -Infinity is the special case */
1707 if ((rhs
->bits
&(DECINF
|DECNEG
))==(DECINF
|DECNEG
)) {
1708 decSetMaxValue(res
, set
);
1709 res
->bits
=DECNEG
; /* negative */
1710 /* there is no status to set */
1713 decNumberZero(&dtiny
); /* start with 0 */
1714 dtiny
.lsu
[0]=1; /* make number that is .. */
1715 dtiny
.exponent
=DEC_MIN_EMIN
-1; /* .. smaller than tiniest */
1716 workset
.round
=DEC_ROUND_CEILING
;
1717 decAddOp(res
, rhs
, &dtiny
, &workset
, 0, &status
);
1718 status
&=DEC_Invalid_operation
|DEC_sNaN
; /* only sNaN Invalid please */
1719 if (status
!=0) decStatus(res
, status
, set
);
1721 } /* decNumberNextPlus */
1723 /* ------------------------------------------------------------------ */
1724 /* decNumberNextToward -- next towards rhs */
1726 /* This computes C = A +/- infinitesimal, rounded towards */
1727 /* +/-Infinity in the direction of B, as per 754-1985 nextafter */
1728 /* modified during revision but dropped from 754-2008. */
1730 /* res is C, the result. C may be A or B. */
1733 /* set is the context */
1735 /* This is a generalization of 754-1985 NextAfter. */
1736 /* ------------------------------------------------------------------ */
1737 decNumber
* decNumberNextToward(decNumber
*res
, const decNumber
*lhs
,
1738 const decNumber
*rhs
, decContext
*set
) {
1739 decNumber dtiny
; /* constant */
1740 decContext workset
=*set
; /* work */
1741 Int result
; /* .. */
1742 uInt status
=0; /* accumulator */
1744 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
1747 if (decNumberIsNaN(lhs
) || decNumberIsNaN(rhs
)) {
1748 decNaNs(res
, lhs
, rhs
, set
, &status
);
1750 else { /* Is numeric, so no chance of sNaN Invalid, etc. */
1751 result
=decCompare(lhs
, rhs
, 0); /* sign matters */
1752 if (result
==BADINT
) status
|=DEC_Insufficient_storage
; /* rare */
1753 else { /* valid compare */
1754 if (result
==0) decNumberCopySign(res
, lhs
, rhs
); /* easy */
1755 else { /* differ: need NextPlus or NextMinus */
1756 uByte sub
; /* add or subtract */
1757 if (result
<0) { /* lhs<rhs, do nextplus */
1758 /* -Infinity is the special case */
1759 if ((lhs
->bits
&(DECINF
|DECNEG
))==(DECINF
|DECNEG
)) {
1760 decSetMaxValue(res
, set
);
1761 res
->bits
=DECNEG
; /* negative */
1762 return res
; /* there is no status to set */
1764 workset
.round
=DEC_ROUND_CEILING
;
1765 sub
=0; /* add, please */
1767 else { /* lhs>rhs, do nextminus */
1768 /* +Infinity is the special case */
1769 if ((lhs
->bits
&(DECINF
|DECNEG
))==DECINF
) {
1770 decSetMaxValue(res
, set
);
1771 return res
; /* there is no status to set */
1773 workset
.round
=DEC_ROUND_FLOOR
;
1774 sub
=DECNEG
; /* subtract, please */
1776 decNumberZero(&dtiny
); /* start with 0 */
1777 dtiny
.lsu
[0]=1; /* make number that is .. */
1778 dtiny
.exponent
=DEC_MIN_EMIN
-1; /* .. smaller than tiniest */
1779 decAddOp(res
, lhs
, &dtiny
, &workset
, sub
, &status
); /* + or - */
1780 /* turn off exceptions if the result is a normal number */
1781 /* (including Nmin), otherwise let all status through */
1782 if (decNumberIsNormal(res
, set
)) status
=0;
1786 if (status
!=0) decStatus(res
, status
, set
);
1788 } /* decNumberNextToward */
1790 /* ------------------------------------------------------------------ */
1791 /* decNumberOr -- OR two Numbers, digitwise */
1793 /* This computes C = A | B */
1795 /* res is C, the result. C may be A and/or B (e.g., X=X|X) */
1798 /* set is the context (used for result length and error report) */
1800 /* C must have space for set->digits digits. */
1802 /* Logical function restrictions apply (see above); a NaN is */
1803 /* returned with Invalid_operation if a restriction is violated. */
1804 /* ------------------------------------------------------------------ */
1805 decNumber
* decNumberOr(decNumber
*res
, const decNumber
*lhs
,
1806 const decNumber
*rhs
, decContext
*set
) {
1807 const Unit
*ua
, *ub
; /* -> operands */
1808 const Unit
*msua
, *msub
; /* -> operand msus */
1809 Unit
*uc
, *msuc
; /* -> result and its msu */
1810 Int msudigs
; /* digits in res msu */
1812 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
1815 if (lhs
->exponent
!=0 || decNumberIsSpecial(lhs
) || decNumberIsNegative(lhs
)
1816 || rhs
->exponent
!=0 || decNumberIsSpecial(rhs
) || decNumberIsNegative(rhs
)) {
1817 decStatus(res
, DEC_Invalid_operation
, set
);
1820 /* operands are valid */
1821 ua
=lhs
->lsu
; /* bottom-up */
1822 ub
=rhs
->lsu
; /* .. */
1823 uc
=res
->lsu
; /* .. */
1824 msua
=ua
+D2U(lhs
->digits
)-1; /* -> msu of lhs */
1825 msub
=ub
+D2U(rhs
->digits
)-1; /* -> msu of rhs */
1826 msuc
=uc
+D2U(set
->digits
)-1; /* -> msu of result */
1827 msudigs
=MSUDIGITS(set
->digits
); /* [faster than remainder] */
1828 for (; uc
<=msuc
; ua
++, ub
++, uc
++) { /* Unit loop */
1829 Unit a
, b
; /* extract units */
1834 *uc
=0; /* can now write back */
1835 if (a
|b
) { /* maybe 1 bits to examine */
1837 /* This loop could be unrolled and/or use BIN2BCD tables */
1838 for (i
=0; i
<DECDPUN
; i
++) {
1839 if ((a
|b
)&1) *uc
=*uc
+(Unit
)powers
[i
]; /* effect OR */
1845 decStatus(res
, DEC_Invalid_operation
, set
);
1848 if (uc
==msuc
&& i
==msudigs
-1) break; /* just did final digit */
1852 /* [here uc-1 is the msu of the result] */
1853 res
->digits
=decGetDigits(res
->lsu
, uc
-res
->lsu
);
1854 res
->exponent
=0; /* integer */
1855 res
->bits
=0; /* sign=0 */
1856 return res
; /* [no status to set] */
1859 /* ------------------------------------------------------------------ */
1860 /* decNumberPlus -- prefix plus operator */
1862 /* This computes C = 0 + A */
1864 /* res is C, the result. C may be A */
1866 /* set is the context */
1868 /* See also decNumberCopy for a quiet bitwise version of this. */
1869 /* C must have space for set->digits digits. */
1870 /* ------------------------------------------------------------------ */
1871 /* This simply uses AddOp; Add will take fast path after preparing A. */
1872 /* Performance is a concern here, as this routine is often used to */
1873 /* check operands and apply rounding and overflow/underflow testing. */
1874 /* ------------------------------------------------------------------ */
1875 decNumber
* decNumberPlus(decNumber
*res
, const decNumber
*rhs
,
1878 uInt status
=0; /* accumulator */
1880 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
1883 decNumberZero(&dzero
); /* make 0 */
1884 dzero
.exponent
=rhs
->exponent
; /* [no coefficient expansion] */
1885 decAddOp(res
, &dzero
, rhs
, set
, 0, &status
);
1886 if (status
!=0) decStatus(res
, status
, set
);
1888 decCheckInexact(res
, set
);
1891 } /* decNumberPlus */
1893 /* ------------------------------------------------------------------ */
1894 /* decNumberMultiply -- multiply two Numbers */
1896 /* This computes C = A x B */
1898 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */
1901 /* set is the context */
1903 /* C must have space for set->digits digits. */
1904 /* ------------------------------------------------------------------ */
1905 decNumber
* decNumberMultiply(decNumber
*res
, const decNumber
*lhs
,
1906 const decNumber
*rhs
, decContext
*set
) {
1907 uInt status
=0; /* accumulator */
1908 decMultiplyOp(res
, lhs
, rhs
, set
, &status
);
1909 if (status
!=0) decStatus(res
, status
, set
);
1911 decCheckInexact(res
, set
);
1914 } /* decNumberMultiply */
1916 /* ------------------------------------------------------------------ */
1917 /* decNumberPower -- raise a number to a power */
1919 /* This computes C = A ** B */
1921 /* res is C, the result. C may be A and/or B (e.g., X=X**X) */
1924 /* set is the context */
1926 /* C must have space for set->digits digits. */
1928 /* Mathematical function restrictions apply (see above); a NaN is */
1929 /* returned with Invalid_operation if a restriction is violated. */
1931 /* However, if 1999999997<=B<=999999999 and B is an integer then the */
1932 /* restrictions on A and the context are relaxed to the usual bounds, */
1933 /* for compatibility with the earlier (integer power only) version */
1934 /* of this function. */
1936 /* When B is an integer, the result may be exact, even if rounded. */
1938 /* The final result is rounded according to the context; it will */
1939 /* almost always be correctly rounded, but may be up to 1 ulp in */
1940 /* error in rare cases. */
1941 /* ------------------------------------------------------------------ */
1942 decNumber
* decNumberPower(decNumber
*res
, const decNumber
*lhs
,
1943 const decNumber
*rhs
, decContext
*set
) {
1945 decNumber
*alloclhs
=NULL
; /* non-NULL if rounded lhs allocated */
1946 decNumber
*allocrhs
=NULL
; /* .., rhs */
1948 decNumber
*allocdac
=NULL
; /* -> allocated acc buffer, iff used */
1949 decNumber
*allocinv
=NULL
; /* -> allocated 1/x buffer, iff used */
1950 Int reqdigits
=set
->digits
; /* requested DIGITS */
1951 Int n
; /* rhs in binary */
1952 Flag rhsint
=0; /* 1 if rhs is an integer */
1953 Flag useint
=0; /* 1 if can use integer calculation */
1954 Flag isoddint
=0; /* 1 if rhs is an integer and odd */
1957 Int dropped
; /* .. */
1959 uInt needbytes
; /* buffer size needed */
1960 Flag seenbit
; /* seen a bit while powering */
1961 Int residue
=0; /* rounding residue */
1962 uInt status
=0; /* accumulators */
1963 uByte bits
=0; /* result sign if errors */
1964 decContext aset
; /* working context */
1965 decNumber dnOne
; /* work value 1... */
1966 /* local accumulator buffer [a decNumber, with digits+elength+1 digits] */
1967 decNumber dacbuff
[D2N(DECBUFFER
+9)];
1968 decNumber
*dac
=dacbuff
; /* -> result accumulator */
1969 /* same again for possible 1/lhs calculation */
1970 decNumber invbuff
[D2N(DECBUFFER
+9)];
1973 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
1976 do { /* protect allocated storage */
1978 if (!set
->extended
) { /* reduce operands and set status, as needed */
1979 if (lhs
->digits
>reqdigits
) {
1980 alloclhs
=decRoundOperand(lhs
, set
, &status
);
1981 if (alloclhs
==NULL
) break;
1984 if (rhs
->digits
>reqdigits
) {
1985 allocrhs
=decRoundOperand(rhs
, set
, &status
);
1986 if (allocrhs
==NULL
) break;
1991 /* [following code does not require input rounding] */
1993 /* handle NaNs and rhs Infinity (lhs infinity is harder) */
1995 if (decNumberIsNaN(lhs
) || decNumberIsNaN(rhs
)) { /* NaNs */
1996 decNaNs(res
, lhs
, rhs
, set
, &status
);
1998 if (decNumberIsInfinite(rhs
)) { /* rhs Infinity */
1999 Flag rhsneg
=rhs
->bits
&DECNEG
; /* save rhs sign */
2000 if (decNumberIsNegative(lhs
) /* lhs<0 */
2001 && !decNumberIsZero(lhs
)) /* .. */
2002 status
|=DEC_Invalid_operation
;
2003 else { /* lhs >=0 */
2004 decNumberZero(&dnOne
); /* set up 1 */
2006 decNumberCompare(dac
, lhs
, &dnOne
, set
); /* lhs ? 1 */
2007 decNumberZero(res
); /* prepare for 0/1/Infinity */
2008 if (decNumberIsNegative(dac
)) { /* lhs<1 */
2009 if (rhsneg
) res
->bits
|=DECINF
; /* +Infinity [else is +0] */
2011 else if (dac
->lsu
[0]==0) { /* lhs=1 */
2012 /* 1**Infinity is inexact, so return fully-padded 1.0000 */
2013 Int shift
=set
->digits
-1;
2014 *res
->lsu
=1; /* was 0, make int 1 */
2015 res
->digits
=decShiftToMost(res
->lsu
, 1, shift
);
2016 res
->exponent
=-shift
; /* make 1.0000... */
2017 status
|=DEC_Inexact
|DEC_Rounded
; /* deemed inexact */
2020 if (!rhsneg
) res
->bits
|=DECINF
; /* +Infinity [else is +0] */
2024 /* [lhs infinity drops through] */
2027 /* Original rhs may be an integer that fits and is in range */
2029 if (n
!=BADINT
) { /* it is an integer */
2030 rhsint
=1; /* record the fact for 1**n */
2031 isoddint
=(Flag
)n
&1; /* [works even if big] */
2032 if (n
!=BIGEVEN
&& n
!=BIGODD
) /* can use integer path? */
2033 useint
=1; /* looks good */
2036 if (decNumberIsNegative(lhs
) /* -x .. */
2037 && isoddint
) bits
=DECNEG
; /* .. to an odd power */
2039 /* handle LHS infinity */
2040 if (decNumberIsInfinite(lhs
)) { /* [NaNs already handled] */
2041 uByte rbits
=rhs
->bits
; /* save */
2042 decNumberZero(res
); /* prepare */
2043 if (n
==0) *res
->lsu
=1; /* [-]Inf**0 => 1 */
2045 /* -Inf**nonint -> error */
2046 if (!rhsint
&& decNumberIsNegative(lhs
)) {
2047 status
|=DEC_Invalid_operation
; /* -Inf**nonint is error */
2049 if (!(rbits
& DECNEG
)) bits
|=DECINF
; /* was not a **-n */
2050 /* [otherwise will be 0 or -0] */
2055 /* similarly handle LHS zero */
2056 if (decNumberIsZero(lhs
)) {
2057 if (n
==0) { /* 0**0 => Error */
2059 if (!set
->extended
) { /* [unless subset] */
2061 *res
->lsu
=1; /* return 1 */
2064 status
|=DEC_Invalid_operation
;
2067 uByte rbits
=rhs
->bits
; /* save */
2068 if (rbits
& DECNEG
) { /* was a 0**(-n) */
2070 if (!set
->extended
) { /* [bad if subset] */
2071 status
|=DEC_Invalid_operation
;
2076 decNumberZero(res
); /* prepare */
2077 /* [otherwise will be 0 or -0] */
2082 /* here both lhs and rhs are finite; rhs==0 is handled in the */
2083 /* integer path. Next handle the non-integer cases */
2084 if (!useint
) { /* non-integral rhs */
2085 /* any -ve lhs is bad, as is either operand or context out of */
2087 if (decNumberIsNegative(lhs
)) {
2088 status
|=DEC_Invalid_operation
;
2090 if (decCheckMath(lhs
, set
, &status
)
2091 || decCheckMath(rhs
, set
, &status
)) break; /* variable status */
2093 decContextDefault(&aset
, DEC_INIT_DECIMAL64
); /* clean context */
2094 aset
.emax
=DEC_MAX_MATH
; /* usual bounds */
2095 aset
.emin
=-DEC_MAX_MATH
; /* .. */
2096 aset
.clamp
=0; /* and no concrete format */
2098 /* calculate the result using exp(ln(lhs)*rhs), which can */
2099 /* all be done into the accumulator, dac. The precision needed */
2100 /* is enough to contain the full information in the lhs (which */
2101 /* is the total digits, including exponent), or the requested */
2102 /* precision, if larger, + 4; 6 is used for the exponent */
2103 /* maximum length, and this is also used when it is shorter */
2104 /* than the requested digits as it greatly reduces the >0.5 ulp */
2105 /* cases at little cost (because Ln doubles digits each */
2106 /* iteration so a few extra digits rarely causes an extra */
2108 aset
.digits
=MAXI(lhs
->digits
, set
->digits
)+6+4;
2109 } /* non-integer rhs */
2111 else { /* rhs is in-range integer */
2112 if (n
==0) { /* x**0 = 1 */
2113 /* (0**0 was handled above) */
2114 decNumberZero(res
); /* result=1 */
2115 *res
->lsu
=1; /* .. */
2117 /* rhs is a non-zero integer */
2118 if (n
<0) n
=-n
; /* use abs(n) */
2120 aset
=*set
; /* clone the context */
2121 aset
.round
=DEC_ROUND_HALF_EVEN
; /* internally use balanced */
2122 /* calculate the working DIGITS */
2123 aset
.digits
=reqdigits
+(rhs
->digits
+rhs
->exponent
)+2;
2125 if (!set
->extended
) aset
.digits
--; /* use classic precision */
2127 /* it's an error if this is more than can be handled */
2128 if (aset
.digits
>DECNUMMAXP
) {status
|=DEC_Invalid_operation
; break;}
2129 } /* integer path */
2131 /* aset.digits is the count of digits for the accumulator needed */
2132 /* if accumulator is too long for local storage, then allocate */
2133 needbytes
=sizeof(decNumber
)+(D2U(aset
.digits
)-1)*sizeof(Unit
);
2134 /* [needbytes also used below if 1/lhs needed] */
2135 if (needbytes
>sizeof(dacbuff
)) {
2136 allocdac
=(decNumber
*)malloc(needbytes
);
2137 if (allocdac
==NULL
) { /* hopeless -- abandon */
2138 status
|=DEC_Insufficient_storage
;
2140 dac
=allocdac
; /* use the allocated space */
2142 /* here, aset is set up and accumulator is ready for use */
2144 if (!useint
) { /* non-integral rhs */
2145 /* x ** y; special-case x=1 here as it will otherwise always */
2146 /* reduce to integer 1; decLnOp has a fastpath which detects */
2147 /* the case of x=1 */
2148 decLnOp(dac
, lhs
, &aset
, &status
); /* dac=ln(lhs) */
2149 /* [no error possible, as lhs 0 already handled] */
2150 if (ISZERO(dac
)) { /* x==1, 1.0, etc. */
2151 /* need to return fully-padded 1.0000 etc., but rhsint->1 */
2152 *dac
->lsu
=1; /* was 0, make int 1 */
2153 if (!rhsint
) { /* add padding */
2154 Int shift
=set
->digits
-1;
2155 dac
->digits
=decShiftToMost(dac
->lsu
, 1, shift
);
2156 dac
->exponent
=-shift
; /* make 1.0000... */
2157 status
|=DEC_Inexact
|DEC_Rounded
; /* deemed inexact */
2161 decMultiplyOp(dac
, dac
, rhs
, &aset
, &status
); /* dac=dac*rhs */
2162 decExpOp(dac
, dac
, &aset
, &status
); /* dac=exp(dac) */
2164 /* and drop through for final rounding */
2165 } /* non-integer rhs */
2167 else { /* carry on with integer */
2168 decNumberZero(dac
); /* acc=1 */
2169 *dac
->lsu
=1; /* .. */
2171 /* if a negative power the constant 1 is needed, and if not subset */
2172 /* invert the lhs now rather than inverting the result later */
2173 if (decNumberIsNegative(rhs
)) { /* was a **-n [hence digits>0] */
2174 decNumber
*inv
=invbuff
; /* asssume use fixed buffer */
2175 decNumberCopy(&dnOne
, dac
); /* dnOne=1; [needed now or later] */
2177 if (set
->extended
) { /* need to calculate 1/lhs */
2179 /* divide lhs into 1, putting result in dac [dac=1/dac] */
2180 decDivideOp(dac
, &dnOne
, lhs
, &aset
, DIVIDE
, &status
);
2181 /* now locate or allocate space for the inverted lhs */
2182 if (needbytes
>sizeof(invbuff
)) {
2183 allocinv
=(decNumber
*)malloc(needbytes
);
2184 if (allocinv
==NULL
) { /* hopeless -- abandon */
2185 status
|=DEC_Insufficient_storage
;
2187 inv
=allocinv
; /* use the allocated space */
2189 /* [inv now points to big-enough buffer or allocated storage] */
2190 decNumberCopy(inv
, dac
); /* copy the 1/lhs */
2191 decNumberCopy(dac
, &dnOne
); /* restore acc=1 */
2192 lhs
=inv
; /* .. and go forward with new lhs */
2198 /* Raise-to-the-power loop... */
2199 seenbit
=0; /* set once a 1-bit is encountered */
2200 for (i
=1;;i
++){ /* for each bit [top bit ignored] */
2201 /* abandon if had overflow or terminal underflow */
2202 if (status
& (DEC_Overflow
|DEC_Underflow
)) { /* interesting? */
2203 if (status
&DEC_Overflow
|| ISZERO(dac
)) break;
2205 /* [the following two lines revealed an optimizer bug in a C++ */
2206 /* compiler, with symptom: 5**3 -> 25, when n=n+n was used] */
2207 n
=n
<<1; /* move next bit to testable position */
2208 if (n
<0) { /* top bit is set */
2209 seenbit
=1; /* OK, significant bit seen */
2210 decMultiplyOp(dac
, dac
, lhs
, &aset
, &status
); /* dac=dac*x */
2212 if (i
==31) break; /* that was the last bit */
2213 if (!seenbit
) continue; /* no need to square 1 */
2214 decMultiplyOp(dac
, dac
, dac
, &aset
, &status
); /* dac=dac*dac [square] */
2215 } /*i*/ /* 32 bits */
2217 /* complete internal overflow or underflow processing */
2218 if (status
& (DEC_Overflow
|DEC_Underflow
)) {
2220 /* If subset, and power was negative, reverse the kind of -erflow */
2221 /* [1/x not yet done] */
2222 if (!set
->extended
&& decNumberIsNegative(rhs
)) {
2223 if (status
& DEC_Overflow
)
2224 status
^=DEC_Overflow
| DEC_Underflow
| DEC_Subnormal
;
2225 else { /* trickier -- Underflow may or may not be set */
2226 status
&=~(DEC_Underflow
| DEC_Subnormal
); /* [one or both] */
2227 status
|=DEC_Overflow
;
2231 dac
->bits
=(dac
->bits
& ~DECNEG
) | bits
; /* force correct sign */
2232 /* round subnormals [to set.digits rather than aset.digits] */
2233 /* or set overflow result similarly as required */
2234 decFinalize(dac
, set
, &residue
, &status
);
2235 decNumberCopy(res
, dac
); /* copy to result (is now OK length) */
2240 if (!set
->extended
&& /* subset math */
2241 decNumberIsNegative(rhs
)) { /* was a **-n [hence digits>0] */
2242 /* so divide result into 1 [dac=1/dac] */
2243 decDivideOp(dac
, &dnOne
, dac
, &aset
, DIVIDE
, &status
);
2246 } /* rhs integer path */
2248 /* reduce result to the requested length and copy to result */
2249 decCopyFit(res
, dac
, set
, &residue
, &status
);
2250 decFinish(res
, set
, &residue
, &status
); /* final cleanup */
2252 if (!set
->extended
) decTrim(res
, set
, 0, 1, &dropped
); /* trailing zeros */
2254 } while(0); /* end protected */
2256 free(allocdac
); /* drop any storage used */
2257 free(allocinv
); /* .. */
2259 free(alloclhs
); /* .. */
2260 free(allocrhs
); /* .. */
2262 if (status
!=0) decStatus(res
, status
, set
);
2264 decCheckInexact(res
, set
);
2267 } /* decNumberPower */
2269 /* ------------------------------------------------------------------ */
2270 /* decNumberQuantize -- force exponent to requested value */
2272 /* This computes C = op(A, B), where op adjusts the coefficient */
2273 /* of C (by rounding or shifting) such that the exponent (-scale) */
2274 /* of C has exponent of B. The numerical value of C will equal A, */
2275 /* except for the effects of any rounding that occurred. */
2277 /* res is C, the result. C may be A or B */
2278 /* lhs is A, the number to adjust */
2279 /* rhs is B, the number with exponent to match */
2280 /* set is the context */
2282 /* C must have space for set->digits digits. */
2284 /* Unless there is an error or the result is infinite, the exponent */
2285 /* after the operation is guaranteed to be equal to that of B. */
2286 /* ------------------------------------------------------------------ */
2287 decNumber
* decNumberQuantize(decNumber
*res
, const decNumber
*lhs
,
2288 const decNumber
*rhs
, decContext
*set
) {
2289 uInt status
=0; /* accumulator */
2290 decQuantizeOp(res
, lhs
, rhs
, set
, 1, &status
);
2291 if (status
!=0) decStatus(res
, status
, set
);
2293 } /* decNumberQuantize */
2295 /* ------------------------------------------------------------------ */
2296 /* decNumberReduce -- remove trailing zeros */
2298 /* This computes C = 0 + A, and normalizes the result */
2300 /* res is C, the result. C may be A */
2302 /* set is the context */
2304 /* C must have space for set->digits digits. */
2305 /* ------------------------------------------------------------------ */
2306 /* Previously known as Normalize */
2307 decNumber
* decNumberNormalize(decNumber
*res
, const decNumber
*rhs
,
2309 return decNumberReduce(res
, rhs
, set
);
2310 } /* decNumberNormalize */
2312 decNumber
* decNumberReduce(decNumber
*res
, const decNumber
*rhs
,
2315 decNumber
*allocrhs
=NULL
; /* non-NULL if rounded rhs allocated */
2317 uInt status
=0; /* as usual */
2318 Int residue
=0; /* as usual */
2319 Int dropped
; /* work */
2322 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
2325 do { /* protect allocated storage */
2327 if (!set
->extended
) {
2328 /* reduce operand and set lostDigits status, as needed */
2329 if (rhs
->digits
>set
->digits
) {
2330 allocrhs
=decRoundOperand(rhs
, set
, &status
);
2331 if (allocrhs
==NULL
) break;
2336 /* [following code does not require input rounding] */
2338 /* Infinities copy through; NaNs need usual treatment */
2339 if (decNumberIsNaN(rhs
)) {
2340 decNaNs(res
, rhs
, NULL
, set
, &status
);
2344 /* reduce result to the requested length and copy to result */
2345 decCopyFit(res
, rhs
, set
, &residue
, &status
); /* copy & round */
2346 decFinish(res
, set
, &residue
, &status
); /* cleanup/set flags */
2347 decTrim(res
, set
, 1, 0, &dropped
); /* normalize in place */
2349 } while(0); /* end protected */
2352 free(allocrhs
); /* .. */
2354 if (status
!=0) decStatus(res
, status
, set
);/* then report status */
2356 } /* decNumberReduce */
2358 /* ------------------------------------------------------------------ */
2359 /* decNumberRescale -- force exponent to requested value */
2361 /* This computes C = op(A, B), where op adjusts the coefficient */
2362 /* of C (by rounding or shifting) such that the exponent (-scale) */
2363 /* of C has the value B. The numerical value of C will equal A, */
2364 /* except for the effects of any rounding that occurred. */
2366 /* res is C, the result. C may be A or B */
2367 /* lhs is A, the number to adjust */
2368 /* rhs is B, the requested exponent */
2369 /* set is the context */
2371 /* C must have space for set->digits digits. */
2373 /* Unless there is an error or the result is infinite, the exponent */
2374 /* after the operation is guaranteed to be equal to B. */
2375 /* ------------------------------------------------------------------ */
2376 decNumber
* decNumberRescale(decNumber
*res
, const decNumber
*lhs
,
2377 const decNumber
*rhs
, decContext
*set
) {
2378 uInt status
=0; /* accumulator */
2379 decQuantizeOp(res
, lhs
, rhs
, set
, 0, &status
);
2380 if (status
!=0) decStatus(res
, status
, set
);
2382 } /* decNumberRescale */
2384 /* ------------------------------------------------------------------ */
2385 /* decNumberRemainder -- divide and return remainder */
2387 /* This computes C = A % B */
2389 /* res is C, the result. C may be A and/or B (e.g., X=X%X) */
2392 /* set is the context */
2394 /* C must have space for set->digits digits. */
2395 /* ------------------------------------------------------------------ */
2396 decNumber
* decNumberRemainder(decNumber
*res
, const decNumber
*lhs
,
2397 const decNumber
*rhs
, decContext
*set
) {
2398 uInt status
=0; /* accumulator */
2399 decDivideOp(res
, lhs
, rhs
, set
, REMAINDER
, &status
);
2400 if (status
!=0) decStatus(res
, status
, set
);
2402 decCheckInexact(res
, set
);
2405 } /* decNumberRemainder */
2407 /* ------------------------------------------------------------------ */
2408 /* decNumberRemainderNear -- divide and return remainder from nearest */
2410 /* This computes C = A % B, where % is the IEEE remainder operator */
2412 /* res is C, the result. C may be A and/or B (e.g., X=X%X) */
2415 /* set is the context */
2417 /* C must have space for set->digits digits. */
2418 /* ------------------------------------------------------------------ */
2419 decNumber
* decNumberRemainderNear(decNumber
*res
, const decNumber
*lhs
,
2420 const decNumber
*rhs
, decContext
*set
) {
2421 uInt status
=0; /* accumulator */
2422 decDivideOp(res
, lhs
, rhs
, set
, REMNEAR
, &status
);
2423 if (status
!=0) decStatus(res
, status
, set
);
2425 decCheckInexact(res
, set
);
2428 } /* decNumberRemainderNear */
2430 /* ------------------------------------------------------------------ */
2431 /* decNumberRotate -- rotate the coefficient of a Number left/right */
2433 /* This computes C = A rot B (in base ten and rotating set->digits */
2436 /* res is C, the result. C may be A and/or B (e.g., X=XrotX) */
2438 /* rhs is B, the number of digits to rotate (-ve to right) */
2439 /* set is the context */
2441 /* The digits of the coefficient of A are rotated to the left (if B */
2442 /* is positive) or to the right (if B is negative) without adjusting */
2443 /* the exponent or the sign of A. If lhs->digits is less than */
2444 /* set->digits the coefficient is padded with zeros on the left */
2445 /* before the rotate. Any leading zeros in the result are removed */
2448 /* B must be an integer (q=0) and in the range -set->digits through */
2450 /* C must have space for set->digits digits. */
2451 /* NaNs are propagated as usual. Infinities are unaffected (but */
2452 /* B must be valid). No status is set unless B is invalid or an */
2453 /* operand is an sNaN. */
2454 /* ------------------------------------------------------------------ */
2455 decNumber
* decNumberRotate(decNumber
*res
, const decNumber
*lhs
,
2456 const decNumber
*rhs
, decContext
*set
) {
2457 uInt status
=0; /* accumulator */
2458 Int rotate
; /* rhs as an Int */
2461 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
2464 /* NaNs propagate as normal */
2465 if (decNumberIsNaN(lhs
) || decNumberIsNaN(rhs
))
2466 decNaNs(res
, lhs
, rhs
, set
, &status
);
2467 /* rhs must be an integer */
2468 else if (decNumberIsInfinite(rhs
) || rhs
->exponent
!=0)
2469 status
=DEC_Invalid_operation
;
2470 else { /* both numeric, rhs is an integer */
2471 rotate
=decGetInt(rhs
); /* [cannot fail] */
2472 if (rotate
==BADINT
/* something bad .. */
2473 || rotate
==BIGODD
|| rotate
==BIGEVEN
/* .. very big .. */
2474 || abs(rotate
)>set
->digits
) /* .. or out of range */
2475 status
=DEC_Invalid_operation
;
2476 else { /* rhs is OK */
2477 decNumberCopy(res
, lhs
);
2478 /* convert -ve rotate to equivalent positive rotation */
2479 if (rotate
<0) rotate
=set
->digits
+rotate
;
2480 if (rotate
!=0 && rotate
!=set
->digits
/* zero or full rotation */
2481 && !decNumberIsInfinite(res
)) { /* lhs was infinite */
2482 /* left-rotate to do; 0 < rotate < set->digits */
2483 uInt units
, shift
; /* work */
2484 uInt msudigits
; /* digits in result msu */
2485 Unit
*msu
=res
->lsu
+D2U(res
->digits
)-1; /* current msu */
2486 Unit
*msumax
=res
->lsu
+D2U(set
->digits
)-1; /* rotation msu */
2487 for (msu
++; msu
<=msumax
; msu
++) *msu
=0; /* ensure high units=0 */
2488 res
->digits
=set
->digits
; /* now full-length */
2489 msudigits
=MSUDIGITS(res
->digits
); /* actual digits in msu */
2491 /* rotation here is done in-place, in three steps */
2492 /* 1. shift all to least up to one unit to unit-align final */
2493 /* lsd [any digits shifted out are rotated to the left, */
2494 /* abutted to the original msd (which may require split)] */
2496 /* [if there are no whole units left to rotate, the */
2497 /* rotation is now complete] */
2499 /* 2. shift to least, from below the split point only, so that */
2500 /* the final msd is in the right place in its Unit [any */
2501 /* digits shifted out will fit exactly in the current msu, */
2502 /* left aligned, no split required] */
2504 /* 3. rotate all the units by reversing left part, right */
2505 /* part, and then whole */
2507 /* example: rotate right 8 digits (2 units + 2), DECDPUN=3. */
2509 /* start: 00a bcd efg hij klm npq */
2511 /* 1a 000 0ab cde fgh|ijk lmn [pq saved] */
2512 /* 1b 00p qab cde fgh|ijk lmn */
2514 /* 2a 00p qab cde fgh|00i jkl [mn saved] */
2515 /* 2b mnp qab cde fgh|00i jkl */
2517 /* 3a fgh cde qab mnp|00i jkl */
2518 /* 3b fgh cde qab mnp|jkl 00i */
2519 /* 3c 00i jkl mnp qab cde fgh */
2521 /* Step 1: amount to shift is the partial right-rotate count */
2522 rotate
=set
->digits
-rotate
; /* make it right-rotate */
2523 units
=rotate
/DECDPUN
; /* whole units to rotate */
2524 shift
=rotate
%DECDPUN
; /* left-over digits count */
2525 if (shift
>0) { /* not an exact number of units */
2526 uInt save
=res
->lsu
[0]%powers
[shift
]; /* save low digit(s) */
2527 decShiftToLeast(res
->lsu
, D2U(res
->digits
), shift
);
2528 if (shift
>msudigits
) { /* msumax-1 needs >0 digits */
2529 uInt rem
=save
%powers
[shift
-msudigits
];/* split save */
2530 *msumax
=(Unit
)(save
/powers
[shift
-msudigits
]); /* and insert */
2531 *(msumax
-1)=*(msumax
-1)
2532 +(Unit
)(rem
*powers
[DECDPUN
-(shift
-msudigits
)]); /* .. */
2534 else { /* all fits in msumax */
2535 *msumax
=*msumax
+(Unit
)(save
*powers
[msudigits
-shift
]); /* [maybe *1] */
2537 } /* digits shift needed */
2539 /* If whole units to rotate... */
2540 if (units
>0) { /* some to do */
2541 /* Step 2: the units to touch are the whole ones in rotate, */
2542 /* if any, and the shift is DECDPUN-msudigits (which may be */
2544 shift
=DECDPUN
-msudigits
;
2545 if (shift
>0) { /* not an exact number of units */
2546 uInt save
=res
->lsu
[0]%powers
[shift
]; /* save low digit(s) */
2547 decShiftToLeast(res
->lsu
, units
, shift
);
2548 *msumax
=*msumax
+(Unit
)(save
*powers
[msudigits
]);
2549 } /* partial shift needed */
2551 /* Step 3: rotate the units array using triple reverse */
2552 /* (reversing is easy and fast) */
2553 decReverse(res
->lsu
+units
, msumax
); /* left part */
2554 decReverse(res
->lsu
, res
->lsu
+units
-1); /* right part */
2555 decReverse(res
->lsu
, msumax
); /* whole */
2556 } /* whole units to rotate */
2557 /* the rotation may have left an undetermined number of zeros */
2558 /* on the left, so true length needs to be calculated */
2559 res
->digits
=decGetDigits(res
->lsu
, msumax
-res
->lsu
+1);
2560 } /* rotate needed */
2563 if (status
!=0) decStatus(res
, status
, set
);
2565 } /* decNumberRotate */
2567 /* ------------------------------------------------------------------ */
2568 /* decNumberSameQuantum -- test for equal exponents */
2570 /* res is the result number, which will contain either 0 or 1 */
2571 /* lhs is a number to test */
2572 /* rhs is the second (usually a pattern) */
2574 /* No errors are possible and no context is needed. */
2575 /* ------------------------------------------------------------------ */
2576 decNumber
* decNumberSameQuantum(decNumber
*res
, const decNumber
*lhs
,
2577 const decNumber
*rhs
) {
2578 Unit ret
=0; /* return value */
2581 if (decCheckOperands(res
, lhs
, rhs
, DECUNCONT
)) return res
;
2585 if (decNumberIsNaN(lhs
) && decNumberIsNaN(rhs
)) ret
=1;
2586 else if (decNumberIsInfinite(lhs
) && decNumberIsInfinite(rhs
)) ret
=1;
2587 /* [anything else with a special gives 0] */
2589 else if (lhs
->exponent
==rhs
->exponent
) ret
=1;
2591 decNumberZero(res
); /* OK to overwrite an operand now */
2594 } /* decNumberSameQuantum */
2596 /* ------------------------------------------------------------------ */
2597 /* decNumberScaleB -- multiply by a power of 10 */
2599 /* This computes C = A x 10**B where B is an integer (q=0) with */
2600 /* maximum magnitude 2*(emax+digits) */
2602 /* res is C, the result. C may be A or B */
2603 /* lhs is A, the number to adjust */
2604 /* rhs is B, the requested power of ten to use */
2605 /* set is the context */
2607 /* C must have space for set->digits digits. */
2609 /* The result may underflow or overflow. */
2610 /* ------------------------------------------------------------------ */
2611 decNumber
* decNumberScaleB(decNumber
*res
, const decNumber
*lhs
,
2612 const decNumber
*rhs
, decContext
*set
) {
2613 Int reqexp
; /* requested exponent change [B] */
2614 uInt status
=0; /* accumulator */
2615 Int residue
; /* work */
2618 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
2621 /* Handle special values except lhs infinite */
2622 if (decNumberIsNaN(lhs
) || decNumberIsNaN(rhs
))
2623 decNaNs(res
, lhs
, rhs
, set
, &status
);
2624 /* rhs must be an integer */
2625 else if (decNumberIsInfinite(rhs
) || rhs
->exponent
!=0)
2626 status
=DEC_Invalid_operation
;
2628 /* lhs is a number; rhs is a finite with q==0 */
2629 reqexp
=decGetInt(rhs
); /* [cannot fail] */
2630 if (reqexp
==BADINT
/* something bad .. */
2631 || reqexp
==BIGODD
|| reqexp
==BIGEVEN
/* .. very big .. */
2632 || abs(reqexp
)>(2*(set
->digits
+set
->emax
))) /* .. or out of range */
2633 status
=DEC_Invalid_operation
;
2634 else { /* rhs is OK */
2635 decNumberCopy(res
, lhs
); /* all done if infinite lhs */
2636 if (!decNumberIsInfinite(res
)) { /* prepare to scale */
2637 res
->exponent
+=reqexp
; /* adjust the exponent */
2639 decFinalize(res
, set
, &residue
, &status
); /* .. and check */
2643 if (status
!=0) decStatus(res
, status
, set
);
2645 } /* decNumberScaleB */
2647 /* ------------------------------------------------------------------ */
2648 /* decNumberShift -- shift the coefficient of a Number left or right */
2650 /* This computes C = A << B or C = A >> -B (in base ten). */
2652 /* res is C, the result. C may be A and/or B (e.g., X=X<<X) */
2654 /* rhs is B, the number of digits to shift (-ve to right) */
2655 /* set is the context */
2657 /* The digits of the coefficient of A are shifted to the left (if B */
2658 /* is positive) or to the right (if B is negative) without adjusting */
2659 /* the exponent or the sign of A. */
2661 /* B must be an integer (q=0) and in the range -set->digits through */
2663 /* C must have space for set->digits digits. */
2664 /* NaNs are propagated as usual. Infinities are unaffected (but */
2665 /* B must be valid). No status is set unless B is invalid or an */
2666 /* operand is an sNaN. */
2667 /* ------------------------------------------------------------------ */
2668 decNumber
* decNumberShift(decNumber
*res
, const decNumber
*lhs
,
2669 const decNumber
*rhs
, decContext
*set
) {
2670 uInt status
=0; /* accumulator */
2671 Int shift
; /* rhs as an Int */
2674 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
2677 /* NaNs propagate as normal */
2678 if (decNumberIsNaN(lhs
) || decNumberIsNaN(rhs
))
2679 decNaNs(res
, lhs
, rhs
, set
, &status
);
2680 /* rhs must be an integer */
2681 else if (decNumberIsInfinite(rhs
) || rhs
->exponent
!=0)
2682 status
=DEC_Invalid_operation
;
2683 else { /* both numeric, rhs is an integer */
2684 shift
=decGetInt(rhs
); /* [cannot fail] */
2685 if (shift
==BADINT
/* something bad .. */
2686 || shift
==BIGODD
|| shift
==BIGEVEN
/* .. very big .. */
2687 || abs(shift
)>set
->digits
) /* .. or out of range */
2688 status
=DEC_Invalid_operation
;
2689 else { /* rhs is OK */
2690 decNumberCopy(res
, lhs
);
2691 if (shift
!=0 && !decNumberIsInfinite(res
)) { /* something to do */
2692 if (shift
>0) { /* to left */
2693 if (shift
==set
->digits
) { /* removing all */
2694 *res
->lsu
=0; /* so place 0 */
2695 res
->digits
=1; /* .. */
2698 /* first remove leading digits if necessary */
2699 if (res
->digits
+shift
>set
->digits
) {
2700 decDecap(res
, res
->digits
+shift
-set
->digits
);
2701 /* that updated res->digits; may have gone to 1 (for a */
2702 /* single digit or for zero */
2704 if (res
->digits
>1 || *res
->lsu
) /* if non-zero.. */
2705 res
->digits
=decShiftToMost(res
->lsu
, res
->digits
, shift
);
2706 } /* partial left */
2708 else { /* to right */
2709 if (-shift
>=res
->digits
) { /* discarding all */
2710 *res
->lsu
=0; /* so place 0 */
2711 res
->digits
=1; /* .. */
2714 decShiftToLeast(res
->lsu
, D2U(res
->digits
), -shift
);
2715 res
->digits
-=(-shift
);
2718 } /* non-0 non-Inf shift */
2721 if (status
!=0) decStatus(res
, status
, set
);
2723 } /* decNumberShift */
2725 /* ------------------------------------------------------------------ */
2726 /* decNumberSquareRoot -- square root operator */
2728 /* This computes C = squareroot(A) */
2730 /* res is C, the result. C may be A */
2732 /* set is the context; note that rounding mode has no effect */
2734 /* C must have space for set->digits digits. */
2735 /* ------------------------------------------------------------------ */
2736 /* This uses the following varying-precision algorithm in: */
2738 /* Properly Rounded Variable Precision Square Root, T. E. Hull and */
2739 /* A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, */
2740 /* pp229-237, ACM, September 1985. */
2742 /* The square-root is calculated using Newton's method, after which */
2743 /* a check is made to ensure the result is correctly rounded. */
2745 /* % [Reformatted original Numerical Turing source code follows.] */
2746 /* function sqrt(x : real) : real */
2747 /* % sqrt(x) returns the properly rounded approximation to the square */
2748 /* % root of x, in the precision of the calling environment, or it */
2749 /* % fails if x < 0. */
2750 /* % t e hull and a abrham, august, 1984 */
2751 /* if x <= 0 then */
2758 /* var f := setexp(x, 0) % fraction part of x [0.1 <= x < 1] */
2759 /* var e := getexp(x) % exponent part of x */
2760 /* var approx : real */
2761 /* if e mod 2 = 0 then */
2762 /* approx := .259 + .819 * f % approx to root of f */
2764 /* f := f/l0 % adjustments */
2765 /* e := e + 1 % for odd */
2766 /* approx := .0819 + 2.59 * f % exponent */
2770 /* const maxp := currentprecision + 2 */
2772 /* p := min(2*p - 2, maxp) % p = 4,6,10, . . . , maxp */
2774 /* approx := .5 * (approx + f/approx) */
2775 /* exit when p = maxp */
2778 /* % approx is now within 1 ulp of the properly rounded square root */
2779 /* % of f; to ensure proper rounding, compare squares of (approx - */
2780 /* % l/2 ulp) and (approx + l/2 ulp) with f. */
2781 /* p := currentprecision */
2783 /* precision p + 2 */
2784 /* const approxsubhalf := approx - setexp(.5, -p) */
2785 /* if mulru(approxsubhalf, approxsubhalf) > f then */
2786 /* approx := approx - setexp(.l, -p + 1) */
2788 /* const approxaddhalf := approx + setexp(.5, -p) */
2789 /* if mulrd(approxaddhalf, approxaddhalf) < f then */
2790 /* approx := approx + setexp(.l, -p + 1) */
2794 /* result setexp(approx, e div 2) % fix exponent */
2796 /* ------------------------------------------------------------------ */
2797 decNumber
* decNumberSquareRoot(decNumber
*res
, const decNumber
*rhs
,
2799 decContext workset
, approxset
; /* work contexts */
2800 decNumber dzero
; /* used for constant zero */
2801 Int maxp
; /* largest working precision */
2802 Int workp
; /* working precision */
2803 Int residue
=0; /* rounding residue */
2804 uInt status
=0, ignore
=0; /* status accumulators */
2805 uInt rstatus
; /* .. */
2806 Int exp
; /* working exponent */
2807 Int ideal
; /* ideal (preferred) exponent */
2808 Int needbytes
; /* work */
2809 Int dropped
; /* .. */
2812 decNumber
*allocrhs
=NULL
; /* non-NULL if rounded rhs allocated */
2814 /* buffer for f [needs +1 in case DECBUFFER 0] */
2815 decNumber buff
[D2N(DECBUFFER
+1)];
2816 /* buffer for a [needs +2 to match likely maxp] */
2817 decNumber bufa
[D2N(DECBUFFER
+2)];
2818 /* buffer for temporary, b [must be same size as a] */
2819 decNumber bufb
[D2N(DECBUFFER
+2)];
2820 decNumber
*allocbuff
=NULL
; /* -> allocated buff, iff allocated */
2821 decNumber
*allocbufa
=NULL
; /* -> allocated bufa, iff allocated */
2822 decNumber
*allocbufb
=NULL
; /* -> allocated bufb, iff allocated */
2823 decNumber
*f
=buff
; /* reduced fraction */
2824 decNumber
*a
=bufa
; /* approximation to result */
2825 decNumber
*b
=bufb
; /* intermediate result */
2826 /* buffer for temporary variable, up to 3 digits */
2827 decNumber buft
[D2N(3)];
2828 decNumber
*t
=buft
; /* up-to-3-digit constant or work */
2831 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
2834 do { /* protect allocated storage */
2836 if (!set
->extended
) {
2837 /* reduce operand and set lostDigits status, as needed */
2838 if (rhs
->digits
>set
->digits
) {
2839 allocrhs
=decRoundOperand(rhs
, set
, &status
);
2840 if (allocrhs
==NULL
) break;
2841 /* [Note: 'f' allocation below could reuse this buffer if */
2842 /* used, but as this is rare they are kept separate for clarity.] */
2847 /* [following code does not require input rounding] */
2849 /* handle infinities and NaNs */
2851 if (decNumberIsInfinite(rhs
)) { /* an infinity */
2852 if (decNumberIsNegative(rhs
)) status
|=DEC_Invalid_operation
;
2853 else decNumberCopy(res
, rhs
); /* +Infinity */
2855 else decNaNs(res
, rhs
, NULL
, set
, &status
); /* a NaN */
2859 /* calculate the ideal (preferred) exponent [floor(exp/2)] */
2860 /* [It would be nicer to write: ideal=rhs->exponent>>1, but this */
2861 /* generates a compiler warning. Generated code is the same.] */
2862 ideal
=(rhs
->exponent
&~1)/2; /* target */
2866 decNumberCopy(res
, rhs
); /* could be 0 or -0 */
2867 res
->exponent
=ideal
; /* use the ideal [safe] */
2868 /* use decFinish to clamp any out-of-range exponent, etc. */
2869 decFinish(res
, set
, &residue
, &status
);
2873 /* any other -x is an oops */
2874 if (decNumberIsNegative(rhs
)) {
2875 status
|=DEC_Invalid_operation
;
2879 /* space is needed for three working variables */
2880 /* f -- the same precision as the RHS, reduced to 0.01->0.99... */
2881 /* a -- Hull's approximation -- precision, when assigned, is */
2882 /* currentprecision+1 or the input argument precision, */
2883 /* whichever is larger (+2 for use as temporary) */
2884 /* b -- intermediate temporary result (same size as a) */
2885 /* if any is too long for local storage, then allocate */
2886 workp
=MAXI(set
->digits
+1, rhs
->digits
); /* actual rounding precision */
2887 workp
=MAXI(workp
, 7); /* at least 7 for low cases */
2888 maxp
=workp
+2; /* largest working precision */
2890 needbytes
=sizeof(decNumber
)+(D2U(rhs
->digits
)-1)*sizeof(Unit
);
2891 if (needbytes
>(Int
)sizeof(buff
)) {
2892 allocbuff
=(decNumber
*)malloc(needbytes
);
2893 if (allocbuff
==NULL
) { /* hopeless -- abandon */
2894 status
|=DEC_Insufficient_storage
;
2896 f
=allocbuff
; /* use the allocated space */
2898 /* a and b both need to be able to hold a maxp-length number */
2899 needbytes
=sizeof(decNumber
)+(D2U(maxp
)-1)*sizeof(Unit
);
2900 if (needbytes
>(Int
)sizeof(bufa
)) { /* [same applies to b] */
2901 allocbufa
=(decNumber
*)malloc(needbytes
);
2902 allocbufb
=(decNumber
*)malloc(needbytes
);
2903 if (allocbufa
==NULL
|| allocbufb
==NULL
) { /* hopeless */
2904 status
|=DEC_Insufficient_storage
;
2906 a
=allocbufa
; /* use the allocated spaces */
2907 b
=allocbufb
; /* .. */
2910 /* copy rhs -> f, save exponent, and reduce so 0.1 <= f < 1 */
2911 decNumberCopy(f
, rhs
);
2912 exp
=f
->exponent
+f
->digits
; /* adjusted to Hull rules */
2913 f
->exponent
=-(f
->digits
); /* to range */
2915 /* set up working context */
2916 decContextDefault(&workset
, DEC_INIT_DECIMAL64
);
2917 workset
.emax
=DEC_MAX_EMAX
;
2918 workset
.emin
=DEC_MIN_EMIN
;
2920 /* [Until further notice, no error is possible and status bits */
2921 /* (Rounded, etc.) should be ignored, not accumulated.] */
2923 /* Calculate initial approximation, and allow for odd exponent */
2924 workset
.digits
=workp
; /* p for initial calculation */
2925 t
->bits
=0; t
->digits
=3;
2926 a
->bits
=0; a
->digits
=3;
2927 if ((exp
& 1)==0) { /* even exponent */
2928 /* Set t=0.259, a=0.819 */
2935 t
->lsu
[0]=59; t
->lsu
[1]=2;
2936 a
->lsu
[0]=19; a
->lsu
[1]=8;
2938 t
->lsu
[0]=9; t
->lsu
[1]=5; t
->lsu
[2]=2;
2939 a
->lsu
[0]=9; a
->lsu
[1]=1; a
->lsu
[2]=8;
2942 else { /* odd exponent */
2943 /* Set t=0.0819, a=2.59 */
2944 f
->exponent
--; /* f=f/10 */
2952 t
->lsu
[0]=19; t
->lsu
[1]=8;
2953 a
->lsu
[0]=59; a
->lsu
[1]=2;
2955 t
->lsu
[0]=9; t
->lsu
[1]=1; t
->lsu
[2]=8;
2956 a
->lsu
[0]=9; a
->lsu
[1]=5; a
->lsu
[2]=2;
2960 decMultiplyOp(a
, a
, f
, &workset
, &ignore
); /* a=a*f */
2961 decAddOp(a
, a
, t
, &workset
, 0, &ignore
); /* ..+t */
2962 /* [a is now the initial approximation for sqrt(f), calculated with */
2963 /* currentprecision, which is also a's precision.] */
2965 /* the main calculation loop */
2966 decNumberZero(&dzero
); /* make 0 */
2967 decNumberZero(t
); /* set t = 0.5 */
2968 t
->lsu
[0]=5; /* .. */
2969 t
->exponent
=-1; /* .. */
2970 workset
.digits
=3; /* initial p */
2971 for (; workset
.digits
<maxp
;) {
2972 /* set p to min(2*p - 2, maxp) [hence 3; or: 4, 6, 10, ... , maxp] */
2973 workset
.digits
=MINI(workset
.digits
*2-2, maxp
);
2974 /* a = 0.5 * (a + f/a) */
2975 /* [calculated at p then rounded to currentprecision] */
2976 decDivideOp(b
, f
, a
, &workset
, DIVIDE
, &ignore
); /* b=f/a */
2977 decAddOp(b
, b
, a
, &workset
, 0, &ignore
); /* b=b+a */
2978 decMultiplyOp(a
, b
, t
, &workset
, &ignore
); /* a=b*0.5 */
2981 /* Here, 0.1 <= a < 1 [Hull], and a has maxp digits */
2982 /* now reduce to length, etc.; this needs to be done with a */
2983 /* having the correct exponent so as to handle subnormals */
2985 approxset
=*set
; /* get emin, emax, etc. */
2986 approxset
.round
=DEC_ROUND_HALF_EVEN
;
2987 a
->exponent
+=exp
/2; /* set correct exponent */
2988 rstatus
=0; /* clear status */
2989 residue
=0; /* .. and accumulator */
2990 decCopyFit(a
, a
, &approxset
, &residue
, &rstatus
); /* reduce (if needed) */
2991 decFinish(a
, &approxset
, &residue
, &rstatus
); /* clean and finalize */
2993 /* Overflow was possible if the input exponent was out-of-range, */
2994 /* in which case quit */
2995 if (rstatus
&DEC_Overflow
) {
2996 status
=rstatus
; /* use the status as-is */
2997 decNumberCopy(res
, a
); /* copy to result */
3001 /* Preserve status except Inexact/Rounded */
3002 status
|=(rstatus
& ~(DEC_Rounded
|DEC_Inexact
));
3004 /* Carry out the Hull correction */
3005 a
->exponent
-=exp
/2; /* back to 0.1->1 */
3007 /* a is now at final precision and within 1 ulp of the properly */
3008 /* rounded square root of f; to ensure proper rounding, compare */
3009 /* squares of (a - l/2 ulp) and (a + l/2 ulp) with f. */
3010 /* Here workset.digits=maxp and t=0.5, and a->digits determines */
3012 workset
.digits
--; /* maxp-1 is OK now */
3013 t
->exponent
=-a
->digits
-1; /* make 0.5 ulp */
3014 decAddOp(b
, a
, t
, &workset
, DECNEG
, &ignore
); /* b = a - 0.5 ulp */
3015 workset
.round
=DEC_ROUND_UP
;
3016 decMultiplyOp(b
, b
, b
, &workset
, &ignore
); /* b = mulru(b, b) */
3017 decCompareOp(b
, f
, b
, &workset
, COMPARE
, &ignore
); /* b ? f, reversed */
3018 if (decNumberIsNegative(b
)) { /* f < b [i.e., b > f] */
3019 /* this is the more common adjustment, though both are rare */
3020 t
->exponent
++; /* make 1.0 ulp */
3021 t
->lsu
[0]=1; /* .. */
3022 decAddOp(a
, a
, t
, &workset
, DECNEG
, &ignore
); /* a = a - 1 ulp */
3023 /* assign to approx [round to length] */
3024 approxset
.emin
-=exp
/2; /* adjust to match a */
3025 approxset
.emax
-=exp
/2;
3026 decAddOp(a
, &dzero
, a
, &approxset
, 0, &ignore
);
3029 decAddOp(b
, a
, t
, &workset
, 0, &ignore
); /* b = a + 0.5 ulp */
3030 workset
.round
=DEC_ROUND_DOWN
;
3031 decMultiplyOp(b
, b
, b
, &workset
, &ignore
); /* b = mulrd(b, b) */
3032 decCompareOp(b
, b
, f
, &workset
, COMPARE
, &ignore
); /* b ? f */
3033 if (decNumberIsNegative(b
)) { /* b < f */
3034 t
->exponent
++; /* make 1.0 ulp */
3035 t
->lsu
[0]=1; /* .. */
3036 decAddOp(a
, a
, t
, &workset
, 0, &ignore
); /* a = a + 1 ulp */
3037 /* assign to approx [round to length] */
3038 approxset
.emin
-=exp
/2; /* adjust to match a */
3039 approxset
.emax
-=exp
/2;
3040 decAddOp(a
, &dzero
, a
, &approxset
, 0, &ignore
);
3043 /* [no errors are possible in the above, and rounding/inexact during */
3044 /* estimation are irrelevant, so status was not accumulated] */
3046 /* Here, 0.1 <= a < 1 (still), so adjust back */
3047 a
->exponent
+=exp
/2; /* set correct exponent */
3049 /* count droppable zeros [after any subnormal rounding] by */
3050 /* trimming a copy */
3051 decNumberCopy(b
, a
);
3052 decTrim(b
, set
, 1, 1, &dropped
); /* [drops trailing zeros] */
3054 /* Set Inexact and Rounded. The answer can only be exact if */
3055 /* it is short enough so that squaring it could fit in workp */
3056 /* digits, so this is the only (relatively rare) condition that */
3057 /* a careful check is needed */
3058 if (b
->digits
*2-1 > workp
) { /* cannot fit */
3059 status
|=DEC_Inexact
|DEC_Rounded
;
3061 else { /* could be exact/unrounded */
3062 uInt mstatus
=0; /* local status */
3063 decMultiplyOp(b
, b
, b
, &workset
, &mstatus
); /* try the multiply */
3064 if (mstatus
&DEC_Overflow
) { /* result just won't fit */
3065 status
|=DEC_Inexact
|DEC_Rounded
;
3067 else { /* plausible */
3068 decCompareOp(t
, b
, rhs
, &workset
, COMPARE
, &mstatus
); /* b ? rhs */
3069 if (!ISZERO(t
)) status
|=DEC_Inexact
|DEC_Rounded
; /* not equal */
3070 else { /* is Exact */
3071 /* here, dropped is the count of trailing zeros in 'a' */
3072 /* use closest exponent to ideal... */
3073 Int todrop
=ideal
-a
->exponent
; /* most that can be dropped */
3074 if (todrop
<0) status
|=DEC_Rounded
; /* ideally would add 0s */
3075 else { /* unrounded */
3076 /* there are some to drop, but emax may not allow all */
3077 Int maxexp
=set
->emax
-set
->digits
+1;
3078 Int maxdrop
=maxexp
-a
->exponent
;
3079 if (todrop
>maxdrop
&& set
->clamp
) { /* apply clamping */
3081 status
|=DEC_Clamped
;
3083 if (dropped
<todrop
) { /* clamp to those available */
3085 status
|=DEC_Clamped
;
3087 if (todrop
>0) { /* have some to drop */
3088 decShiftToLeast(a
->lsu
, D2U(a
->digits
), todrop
);
3089 a
->exponent
+=todrop
; /* maintain numerical value */
3090 a
->digits
-=todrop
; /* new length */
3097 /* double-check Underflow, as perhaps the result could not have */
3098 /* been subnormal (initial argument too big), or it is now Exact */
3099 if (status
&DEC_Underflow
) {
3100 Int ae
=rhs
->exponent
+rhs
->digits
-1; /* adjusted exponent */
3101 /* check if truly subnormal */
3102 #if DECEXTFLAG /* DEC_Subnormal too */
3103 if (ae
>=set
->emin
*2) status
&=~(DEC_Subnormal
|DEC_Underflow
);
3105 if (ae
>=set
->emin
*2) status
&=~DEC_Underflow
;
3107 /* check if truly inexact */
3108 if (!(status
&DEC_Inexact
)) status
&=~DEC_Underflow
;
3111 decNumberCopy(res
, a
); /* a is now the result */
3112 } while(0); /* end protected */
3114 free(allocbuff
); /* drop any storage used */
3115 free(allocbufa
); /* .. */
3116 free(allocbufb
); /* .. */
3118 free(allocrhs
); /* .. */
3120 if (status
!=0) decStatus(res
, status
, set
);/* then report status */
3122 decCheckInexact(res
, set
);
3125 } /* decNumberSquareRoot */
3127 /* ------------------------------------------------------------------ */
3128 /* decNumberSubtract -- subtract two Numbers */
3130 /* This computes C = A - B */
3132 /* res is C, the result. C may be A and/or B (e.g., X=X-X) */
3135 /* set is the context */
3137 /* C must have space for set->digits digits. */
3138 /* ------------------------------------------------------------------ */
3139 decNumber
* decNumberSubtract(decNumber
*res
, const decNumber
*lhs
,
3140 const decNumber
*rhs
, decContext
*set
) {
3141 uInt status
=0; /* accumulator */
3143 decAddOp(res
, lhs
, rhs
, set
, DECNEG
, &status
);
3144 if (status
!=0) decStatus(res
, status
, set
);
3146 decCheckInexact(res
, set
);
3149 } /* decNumberSubtract */
3151 /* ------------------------------------------------------------------ */
3152 /* decNumberToIntegralExact -- round-to-integral-value with InExact */
3153 /* decNumberToIntegralValue -- round-to-integral-value */
3155 /* res is the result */
3156 /* rhs is input number */
3157 /* set is the context */
3159 /* res must have space for any value of rhs. */
3161 /* This implements the IEEE special operators and therefore treats */
3162 /* special values as valid. For finite numbers it returns */
3163 /* rescale(rhs, 0) if rhs->exponent is <0. */
3164 /* Otherwise the result is rhs (so no error is possible, except for */
3167 /* The context is used for rounding mode and status after sNaN, but */
3168 /* the digits setting is ignored. The Exact version will signal */
3169 /* Inexact if the result differs numerically from rhs; the other */
3170 /* never signals Inexact. */
3171 /* ------------------------------------------------------------------ */
3172 decNumber
* decNumberToIntegralExact(decNumber
*res
, const decNumber
*rhs
,
3175 decContext workset
; /* working context */
3176 uInt status
=0; /* accumulator */
3179 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
3182 /* handle infinities and NaNs */
3184 if (decNumberIsInfinite(rhs
)) decNumberCopy(res
, rhs
); /* an Infinity */
3185 else decNaNs(res
, rhs
, NULL
, set
, &status
); /* a NaN */
3188 /* have a finite number; no error possible (res must be big enough) */
3189 if (rhs
->exponent
>=0) return decNumberCopy(res
, rhs
);
3190 /* that was easy, but if negative exponent there is work to do... */
3191 workset
=*set
; /* clone rounding, etc. */
3192 workset
.digits
=rhs
->digits
; /* no length rounding */
3193 workset
.traps
=0; /* no traps */
3194 decNumberZero(&dn
); /* make a number with exponent 0 */
3195 decNumberQuantize(res
, rhs
, &dn
, &workset
);
3196 status
|=workset
.status
;
3198 if (status
!=0) decStatus(res
, status
, set
);
3200 } /* decNumberToIntegralExact */
3202 decNumber
* decNumberToIntegralValue(decNumber
*res
, const decNumber
*rhs
,
3204 decContext workset
=*set
; /* working context */
3205 workset
.traps
=0; /* no traps */
3206 decNumberToIntegralExact(res
, rhs
, &workset
);
3207 /* this never affects set, except for sNaNs; NaN will have been set */
3208 /* or propagated already, so no need to call decStatus */
3209 set
->status
|=workset
.status
&DEC_Invalid_operation
;
3211 } /* decNumberToIntegralValue */
3213 /* ------------------------------------------------------------------ */
3214 /* decNumberXor -- XOR two Numbers, digitwise */
3216 /* This computes C = A ^ B */
3218 /* res is C, the result. C may be A and/or B (e.g., X=X^X) */
3221 /* set is the context (used for result length and error report) */
3223 /* C must have space for set->digits digits. */
3225 /* Logical function restrictions apply (see above); a NaN is */
3226 /* returned with Invalid_operation if a restriction is violated. */
3227 /* ------------------------------------------------------------------ */
3228 decNumber
* decNumberXor(decNumber
*res
, const decNumber
*lhs
,
3229 const decNumber
*rhs
, decContext
*set
) {
3230 const Unit
*ua
, *ub
; /* -> operands */
3231 const Unit
*msua
, *msub
; /* -> operand msus */
3232 Unit
*uc
, *msuc
; /* -> result and its msu */
3233 Int msudigs
; /* digits in res msu */
3235 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
3238 if (lhs
->exponent
!=0 || decNumberIsSpecial(lhs
) || decNumberIsNegative(lhs
)
3239 || rhs
->exponent
!=0 || decNumberIsSpecial(rhs
) || decNumberIsNegative(rhs
)) {
3240 decStatus(res
, DEC_Invalid_operation
, set
);
3243 /* operands are valid */
3244 ua
=lhs
->lsu
; /* bottom-up */
3245 ub
=rhs
->lsu
; /* .. */
3246 uc
=res
->lsu
; /* .. */
3247 msua
=ua
+D2U(lhs
->digits
)-1; /* -> msu of lhs */
3248 msub
=ub
+D2U(rhs
->digits
)-1; /* -> msu of rhs */
3249 msuc
=uc
+D2U(set
->digits
)-1; /* -> msu of result */
3250 msudigs
=MSUDIGITS(set
->digits
); /* [faster than remainder] */
3251 for (; uc
<=msuc
; ua
++, ub
++, uc
++) { /* Unit loop */
3252 Unit a
, b
; /* extract units */
3257 *uc
=0; /* can now write back */
3258 if (a
|b
) { /* maybe 1 bits to examine */
3260 /* This loop could be unrolled and/or use BIN2BCD tables */
3261 for (i
=0; i
<DECDPUN
; i
++) {
3262 if ((a
^b
)&1) *uc
=*uc
+(Unit
)powers
[i
]; /* effect XOR */
3268 decStatus(res
, DEC_Invalid_operation
, set
);
3271 if (uc
==msuc
&& i
==msudigs
-1) break; /* just did final digit */
3275 /* [here uc-1 is the msu of the result] */
3276 res
->digits
=decGetDigits(res
->lsu
, uc
-res
->lsu
);
3277 res
->exponent
=0; /* integer */
3278 res
->bits
=0; /* sign=0 */
3279 return res
; /* [no status to set] */
3280 } /* decNumberXor */
3283 /* ================================================================== */
3284 /* Utility routines */
3285 /* ================================================================== */
3287 /* ------------------------------------------------------------------ */
3288 /* decNumberClass -- return the decClass of a decNumber */
3289 /* dn -- the decNumber to test */
3290 /* set -- the context to use for Emin */
3291 /* returns the decClass enum */
3292 /* ------------------------------------------------------------------ */
3293 enum decClass
decNumberClass(const decNumber
*dn
, decContext
*set
) {
3294 if (decNumberIsSpecial(dn
)) {
3295 if (decNumberIsQNaN(dn
)) return DEC_CLASS_QNAN
;
3296 if (decNumberIsSNaN(dn
)) return DEC_CLASS_SNAN
;
3297 /* must be an infinity */
3298 if (decNumberIsNegative(dn
)) return DEC_CLASS_NEG_INF
;
3299 return DEC_CLASS_POS_INF
;
3302 if (decNumberIsNormal(dn
, set
)) { /* most common */
3303 if (decNumberIsNegative(dn
)) return DEC_CLASS_NEG_NORMAL
;
3304 return DEC_CLASS_POS_NORMAL
;
3306 /* is subnormal or zero */
3307 if (decNumberIsZero(dn
)) { /* most common */
3308 if (decNumberIsNegative(dn
)) return DEC_CLASS_NEG_ZERO
;
3309 return DEC_CLASS_POS_ZERO
;
3311 if (decNumberIsNegative(dn
)) return DEC_CLASS_NEG_SUBNORMAL
;
3312 return DEC_CLASS_POS_SUBNORMAL
;
3313 } /* decNumberClass */
3315 /* ------------------------------------------------------------------ */
3316 /* decNumberClassToString -- convert decClass to a string */
3318 /* eclass is a valid decClass */
3319 /* returns a constant string describing the class (max 13+1 chars) */
3320 /* ------------------------------------------------------------------ */
3321 const char *decNumberClassToString(enum decClass eclass
) {
3322 if (eclass
==DEC_CLASS_POS_NORMAL
) return DEC_ClassString_PN
;
3323 if (eclass
==DEC_CLASS_NEG_NORMAL
) return DEC_ClassString_NN
;
3324 if (eclass
==DEC_CLASS_POS_ZERO
) return DEC_ClassString_PZ
;
3325 if (eclass
==DEC_CLASS_NEG_ZERO
) return DEC_ClassString_NZ
;
3326 if (eclass
==DEC_CLASS_POS_SUBNORMAL
) return DEC_ClassString_PS
;
3327 if (eclass
==DEC_CLASS_NEG_SUBNORMAL
) return DEC_ClassString_NS
;
3328 if (eclass
==DEC_CLASS_POS_INF
) return DEC_ClassString_PI
;
3329 if (eclass
==DEC_CLASS_NEG_INF
) return DEC_ClassString_NI
;
3330 if (eclass
==DEC_CLASS_QNAN
) return DEC_ClassString_QN
;
3331 if (eclass
==DEC_CLASS_SNAN
) return DEC_ClassString_SN
;
3332 return DEC_ClassString_UN
; /* Unknown */
3333 } /* decNumberClassToString */
3335 /* ------------------------------------------------------------------ */
3336 /* decNumberCopy -- copy a number */
3338 /* dest is the target decNumber */
3339 /* src is the source decNumber */
3342 /* (dest==src is allowed and is a no-op) */
3343 /* All fields are updated as required. This is a utility operation, */
3344 /* so special values are unchanged and no error is possible. */
3345 /* ------------------------------------------------------------------ */
3346 decNumber
* decNumberCopy(decNumber
*dest
, const decNumber
*src
) {
3349 if (src
==NULL
) return decNumberZero(dest
);
3352 if (dest
==src
) return dest
; /* no copy required */
3354 /* Use explicit assignments here as structure assignment could copy */
3355 /* more than just the lsu (for small DECDPUN). This would not affect */
3356 /* the value of the results, but could disturb test harness spill */
3358 dest
->bits
=src
->bits
;
3359 dest
->exponent
=src
->exponent
;
3360 dest
->digits
=src
->digits
;
3361 dest
->lsu
[0]=src
->lsu
[0];
3362 if (src
->digits
>DECDPUN
) { /* more Units to come */
3363 const Unit
*smsup
, *s
; /* work */
3365 /* memcpy for the remaining Units would be safe as they cannot */
3366 /* overlap. However, this explicit loop is faster in short cases. */
3367 d
=dest
->lsu
+1; /* -> first destination */
3368 smsup
=src
->lsu
+D2U(src
->digits
); /* -> source msu+1 */
3369 for (s
=src
->lsu
+1; s
<smsup
; s
++, d
++) *d
=*s
;
3372 } /* decNumberCopy */
3374 /* ------------------------------------------------------------------ */
3375 /* decNumberCopyAbs -- quiet absolute value operator */
3377 /* This sets C = abs(A) */
3379 /* res is C, the result. C may be A */
3382 /* C must have space for set->digits digits. */
3383 /* No exception or error can occur; this is a quiet bitwise operation.*/
3384 /* See also decNumberAbs for a checking version of this. */
3385 /* ------------------------------------------------------------------ */
3386 decNumber
* decNumberCopyAbs(decNumber
*res
, const decNumber
*rhs
) {
3388 if (decCheckOperands(res
, DECUNUSED
, rhs
, DECUNCONT
)) return res
;
3390 decNumberCopy(res
, rhs
);
3391 res
->bits
&=~DECNEG
; /* turn off sign */
3393 } /* decNumberCopyAbs */
3395 /* ------------------------------------------------------------------ */
3396 /* decNumberCopyNegate -- quiet negate value operator */
3398 /* This sets C = negate(A) */
3400 /* res is C, the result. C may be A */
3403 /* C must have space for set->digits digits. */
3404 /* No exception or error can occur; this is a quiet bitwise operation.*/
3405 /* See also decNumberMinus for a checking version of this. */
3406 /* ------------------------------------------------------------------ */
3407 decNumber
* decNumberCopyNegate(decNumber
*res
, const decNumber
*rhs
) {
3409 if (decCheckOperands(res
, DECUNUSED
, rhs
, DECUNCONT
)) return res
;
3411 decNumberCopy(res
, rhs
);
3412 res
->bits
^=DECNEG
; /* invert the sign */
3414 } /* decNumberCopyNegate */
3416 /* ------------------------------------------------------------------ */
3417 /* decNumberCopySign -- quiet copy and set sign operator */
3419 /* This sets C = A with the sign of B */
3421 /* res is C, the result. C may be A */
3425 /* C must have space for set->digits digits. */
3426 /* No exception or error can occur; this is a quiet bitwise operation.*/
3427 /* ------------------------------------------------------------------ */
3428 decNumber
* decNumberCopySign(decNumber
*res
, const decNumber
*lhs
,
3429 const decNumber
*rhs
) {
3430 uByte sign
; /* rhs sign */
3432 if (decCheckOperands(res
, DECUNUSED
, rhs
, DECUNCONT
)) return res
;
3434 sign
=rhs
->bits
& DECNEG
; /* save sign bit */
3435 decNumberCopy(res
, lhs
);
3436 res
->bits
&=~DECNEG
; /* clear the sign */
3437 res
->bits
|=sign
; /* set from rhs */
3439 } /* decNumberCopySign */
3441 /* ------------------------------------------------------------------ */
3442 /* decNumberGetBCD -- get the coefficient in BCD8 */
3443 /* dn is the source decNumber */
3444 /* bcd is the uInt array that will receive dn->digits BCD bytes, */
3445 /* most-significant at offset 0 */
3448 /* bcd must have at least dn->digits bytes. No error is possible; if */
3449 /* dn is a NaN or Infinite, digits must be 1 and the coefficient 0. */
3450 /* ------------------------------------------------------------------ */
3451 uByte
* decNumberGetBCD(const decNumber
*dn
, uByte
*bcd
) {
3452 uByte
*ub
=bcd
+dn
->digits
-1; /* -> lsd */
3453 const Unit
*up
=dn
->lsu
; /* Unit pointer, -> lsu */
3455 #if DECDPUN==1 /* trivial simple copy */
3456 for (; ub
>=bcd
; ub
--, up
++) *ub
=*up
;
3457 #else /* chopping needed */
3458 uInt u
=*up
; /* work */
3459 uInt cut
=DECDPUN
; /* downcounter through unit */
3460 for (; ub
>=bcd
; ub
--) {
3461 *ub
=(uByte
)(u
%10); /* [*6554 trick inhibits, here] */
3464 if (cut
>0) continue; /* more in this unit */
3471 } /* decNumberGetBCD */
3473 /* ------------------------------------------------------------------ */
3474 /* decNumberSetBCD -- set (replace) the coefficient from BCD8 */
3475 /* dn is the target decNumber */
3476 /* bcd is the uInt array that will source n BCD bytes, most- */
3477 /* significant at offset 0 */
3478 /* n is the number of digits in the source BCD array (bcd) */
3481 /* dn must have space for at least n digits. No error is possible; */
3482 /* if dn is a NaN, or Infinite, or is to become a zero, n must be 1 */
3483 /* and bcd[0] zero. */
3484 /* ------------------------------------------------------------------ */
3485 decNumber
* decNumberSetBCD(decNumber
*dn
, const uByte
*bcd
, uInt n
) {
3486 Unit
*up
=dn
->lsu
+D2U(dn
->digits
)-1; /* -> msu [target pointer] */
3487 const uByte
*ub
=bcd
; /* -> source msd */
3489 #if DECDPUN==1 /* trivial simple copy */
3490 for (; ub
<bcd
+n
; ub
++, up
--) *up
=*ub
;
3491 #else /* some assembly needed */
3492 /* calculate how many digits in msu, and hence first cut */
3493 Int cut
=MSUDIGITS(n
); /* [faster than remainder] */
3494 for (;up
>=dn
->lsu
; up
--) { /* each Unit from msu */
3495 *up
=0; /* will take <=DECDPUN digits */
3496 for (; cut
>0; ub
++, cut
--) *up
=X10(*up
)+*ub
;
3497 cut
=DECDPUN
; /* next Unit has all digits */
3500 dn
->digits
=n
; /* set digit count */
3502 } /* decNumberSetBCD */
3504 /* ------------------------------------------------------------------ */
3505 /* decNumberIsNormal -- test normality of a decNumber */
3506 /* dn is the decNumber to test */
3507 /* set is the context to use for Emin */
3508 /* returns 1 if |dn| is finite and >=Nmin, 0 otherwise */
3509 /* ------------------------------------------------------------------ */
3510 Int
decNumberIsNormal(const decNumber
*dn
, decContext
*set
) {
3511 Int ae
; /* adjusted exponent */
3513 if (decCheckOperands(DECUNRESU
, DECUNUSED
, dn
, set
)) return 0;
3516 if (decNumberIsSpecial(dn
)) return 0; /* not finite */
3517 if (decNumberIsZero(dn
)) return 0; /* not non-zero */
3519 ae
=dn
->exponent
+dn
->digits
-1; /* adjusted exponent */
3520 if (ae
<set
->emin
) return 0; /* is subnormal */
3522 } /* decNumberIsNormal */
3524 /* ------------------------------------------------------------------ */
3525 /* decNumberIsSubnormal -- test subnormality of a decNumber */
3526 /* dn is the decNumber to test */
3527 /* set is the context to use for Emin */
3528 /* returns 1 if |dn| is finite, non-zero, and <Nmin, 0 otherwise */
3529 /* ------------------------------------------------------------------ */
3530 Int
decNumberIsSubnormal(const decNumber
*dn
, decContext
*set
) {
3531 Int ae
; /* adjusted exponent */
3533 if (decCheckOperands(DECUNRESU
, DECUNUSED
, dn
, set
)) return 0;
3536 if (decNumberIsSpecial(dn
)) return 0; /* not finite */
3537 if (decNumberIsZero(dn
)) return 0; /* not non-zero */
3539 ae
=dn
->exponent
+dn
->digits
-1; /* adjusted exponent */
3540 if (ae
<set
->emin
) return 1; /* is subnormal */
3542 } /* decNumberIsSubnormal */
3544 /* ------------------------------------------------------------------ */
3545 /* decNumberTrim -- remove insignificant zeros */
3547 /* dn is the number to trim */
3550 /* All fields are updated as required. This is a utility operation, */
3551 /* so special values are unchanged and no error is possible. The */
3552 /* zeros are removed unconditionally. */
3553 /* ------------------------------------------------------------------ */
3554 decNumber
* decNumberTrim(decNumber
*dn
) {
3555 Int dropped
; /* work */
3556 decContext set
; /* .. */
3558 if (decCheckOperands(DECUNRESU
, DECUNUSED
, dn
, DECUNCONT
)) return dn
;
3560 decContextDefault(&set
, DEC_INIT_BASE
); /* clamp=0 */
3561 return decTrim(dn
, &set
, 0, 1, &dropped
);
3562 } /* decNumberTrim */
3564 /* ------------------------------------------------------------------ */
3565 /* decNumberVersion -- return the name and version of this module */
3567 /* No error is possible. */
3568 /* ------------------------------------------------------------------ */
3569 const char * decNumberVersion(void) {
3571 } /* decNumberVersion */
3573 /* ------------------------------------------------------------------ */
3574 /* decNumberZero -- set a number to 0 */
3576 /* dn is the number to set, with space for one digit */
3579 /* No error is possible. */
3580 /* ------------------------------------------------------------------ */
3581 /* Memset is not used as it is much slower in some environments. */
3582 decNumber
* decNumberZero(decNumber
*dn
) {
3585 if (decCheckOperands(dn
, DECUNUSED
, DECUNUSED
, DECUNCONT
)) return dn
;
3593 } /* decNumberZero */
3595 /* ================================================================== */
3596 /* Local routines */
3597 /* ================================================================== */
3599 /* ------------------------------------------------------------------ */
3600 /* decToString -- lay out a number into a string */
3602 /* dn is the number to lay out */
3603 /* string is where to lay out the number */
3604 /* eng is 1 if Engineering, 0 if Scientific */
3606 /* string must be at least dn->digits+14 characters long */
3607 /* No error is possible. */
3609 /* Note that this routine can generate a -0 or 0.000. These are */
3610 /* never generated in subset to-number or arithmetic, but can occur */
3611 /* in non-subset arithmetic (e.g., -1*0 or 1.234-1.234). */
3612 /* ------------------------------------------------------------------ */
3613 /* If DECCHECK is enabled the string "?" is returned if a number is */
3615 static void decToString(const decNumber
*dn
, char *string
, Flag eng
) {
3616 Int exp
=dn
->exponent
; /* local copy */
3617 Int e
; /* E-part value */
3618 Int pre
; /* digits before the '.' */
3619 Int cut
; /* for counting digits in a Unit */
3620 char *c
=string
; /* work [output pointer] */
3621 const Unit
*up
=dn
->lsu
+D2U(dn
->digits
)-1; /* -> msu [input pointer] */
3622 uInt u
, pow
; /* work */
3625 if (decCheckOperands(DECUNRESU
, dn
, DECUNUSED
, DECUNCONT
)) {
3626 strcpy(string
, "?");
3630 if (decNumberIsNegative(dn
)) { /* Negatives get a minus */
3634 if (dn
->bits
&DECSPECIAL
) { /* Is a special value */
3635 if (decNumberIsInfinite(dn
)) {
3637 strcpy(c
+3, "inity");
3640 if (dn
->bits
&DECSNAN
) { /* signalling NaN */
3645 c
+=3; /* step past */
3646 /* if not a clean non-zero coefficient, that's all there is in a */
3648 if (exp
!=0 || (*dn
->lsu
==0 && dn
->digits
==1)) return;
3649 /* [drop through to add integer] */
3652 /* calculate how many digits in msu, and hence first cut */
3653 cut
=MSUDIGITS(dn
->digits
); /* [faster than remainder] */
3654 cut
--; /* power of ten for digit */
3656 if (exp
==0) { /* simple integer [common fastpath] */
3657 for (;up
>=dn
->lsu
; up
--) { /* each Unit from msu */
3658 u
=*up
; /* contains DECDPUN digits to lay out */
3659 for (; cut
>=0; c
++, cut
--) TODIGIT(u
, cut
, c
, pow
);
3660 cut
=DECDPUN
-1; /* next Unit has all digits */
3662 *c
='\0'; /* terminate the string */
3665 /* non-0 exponent -- assume plain form */
3666 pre
=dn
->digits
+exp
; /* digits before '.' */
3668 if ((exp
>0) || (pre
<-5)) { /* need exponential form */
3669 e
=exp
+dn
->digits
-1; /* calculate E value */
3670 pre
=1; /* assume one digit before '.' */
3671 if (eng
&& (e
!=0)) { /* engineering: may need to adjust */
3672 Int adj
; /* adjustment */
3673 /* The C remainder operator is undefined for negative numbers, so */
3674 /* a positive remainder calculation must be used here */
3677 if (adj
!=0) adj
=3-adj
;
3683 /* if dealing with zero still produce an exponent which is a */
3684 /* multiple of three, as expected, but there will only be the */
3685 /* one zero before the E, still. Otherwise note the padding. */
3686 if (!ISZERO(dn
)) pre
+=adj
;
3687 else { /* is zero */
3688 if (adj
!=0) { /* 0.00Esnn needed */
3694 } /* need exponent */
3696 /* lay out the digits of the coefficient, adding 0s and . as needed */
3698 if (pre
>0) { /* xxx.xxx or xx00 (engineering) form */
3700 for (; pre
>0; pre
--, c
++, cut
--) {
3701 if (cut
<0) { /* need new Unit */
3702 if (up
==dn
->lsu
) break; /* out of input digits (pre>digits) */
3707 TODIGIT(u
, cut
, c
, pow
);
3709 if (n
<dn
->digits
) { /* more to come, after '.' */
3711 for (;; c
++, cut
--) {
3712 if (cut
<0) { /* need new Unit */
3713 if (up
==dn
->lsu
) break; /* out of input digits */
3718 TODIGIT(u
, cut
, c
, pow
);
3721 else for (; pre
>0; pre
--, c
++) *c
='0'; /* 0 padding (for engineering) needed */
3723 else { /* 0.xxx or 0.000xxx form */
3726 for (; pre
<0; pre
++, c
++) *c
='0'; /* add any 0's after '.' */
3727 for (; ; c
++, cut
--) {
3728 if (cut
<0) { /* need new Unit */
3729 if (up
==dn
->lsu
) break; /* out of input digits */
3734 TODIGIT(u
, cut
, c
, pow
);
3738 /* Finally add the E-part, if needed. It will never be 0, has a
3739 base maximum and minimum of +999999999 through -999999999, but
3740 could range down to -1999999998 for anormal numbers */
3742 Flag had
=0; /* 1=had non-zero */
3744 *c
='+'; c
++; /* assume positive */
3747 *(c
-1)='-'; /* oops, need - */
3748 u
=-e
; /* uInt, please */
3750 /* lay out the exponent [_itoa or equivalent is not ANSI C] */
3751 for (cut
=9; cut
>=0; cut
--) {
3752 TODIGIT(u
, cut
, c
, pow
);
3753 if (*c
=='0' && !had
) continue; /* skip leading zeros */
3754 had
=1; /* had non-0 */
3755 c
++; /* step for next */
3758 *c
='\0'; /* terminate the string (all paths) */
3762 /* ------------------------------------------------------------------ */
3763 /* decAddOp -- add/subtract operation */
3765 /* This computes C = A + B */
3767 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */
3770 /* set is the context */
3771 /* negate is DECNEG if rhs should be negated, or 0 otherwise */
3772 /* status accumulates status for the caller */
3774 /* C must have space for set->digits digits. */
3775 /* Inexact in status must be 0 for correct Exact zero sign in result */
3776 /* ------------------------------------------------------------------ */
3777 /* If possible, the coefficient is calculated directly into C. */
3779 /* -- a digits+1 calculation is needed because the numbers are */
3780 /* unaligned and span more than set->digits digits */
3781 /* -- a carry to digits+1 digits looks possible */
3782 /* -- C is the same as A or B, and the result would destructively */
3783 /* overlap the A or B coefficient */
3784 /* then the result must be calculated into a temporary buffer. In */
3785 /* this case a local (stack) buffer is used if possible, and only if */
3786 /* too long for that does malloc become the final resort. */
3788 /* Misalignment is handled as follows: */
3789 /* Apad: (AExp>BExp) Swap operands and proceed as for BExp>AExp. */
3790 /* BPad: Apply the padding by a combination of shifting (whole */
3791 /* units) and multiplication (part units). */
3793 /* Addition, especially x=x+1, is speed-critical. */
3794 /* The static buffer is larger than might be expected to allow for */
3795 /* calls from higher-level funtions (notable exp). */
3796 /* ------------------------------------------------------------------ */
3797 static decNumber
* decAddOp(decNumber
*res
, const decNumber
*lhs
,
3798 const decNumber
*rhs
, decContext
*set
,
3799 uByte negate
, uInt
*status
) {
3801 decNumber
*alloclhs
=NULL
; /* non-NULL if rounded lhs allocated */
3802 decNumber
*allocrhs
=NULL
; /* .., rhs */
3804 Int rhsshift
; /* working shift (in Units) */
3805 Int maxdigits
; /* longest logical length */
3806 Int mult
; /* multiplier */
3807 Int residue
; /* rounding accumulator */
3808 uByte bits
; /* result bits */
3809 Flag diffsign
; /* non-0 if arguments have different sign */
3810 Unit
*acc
; /* accumulator for result */
3811 Unit accbuff
[SD2U(DECBUFFER
*2+20)]; /* local buffer [*2+20 reduces many */
3812 /* allocations when called from */
3813 /* other operations, notable exp] */
3814 Unit
*allocacc
=NULL
; /* -> allocated acc buffer, iff allocated */
3815 Int reqdigits
=set
->digits
; /* local copy; requested DIGITS */
3816 Int padding
; /* work */
3819 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
3822 do { /* protect allocated storage */
3824 if (!set
->extended
) {
3825 /* reduce operands and set lostDigits status, as needed */
3826 if (lhs
->digits
>reqdigits
) {
3827 alloclhs
=decRoundOperand(lhs
, set
, status
);
3828 if (alloclhs
==NULL
) break;
3831 if (rhs
->digits
>reqdigits
) {
3832 allocrhs
=decRoundOperand(rhs
, set
, status
);
3833 if (allocrhs
==NULL
) break;
3838 /* [following code does not require input rounding] */
3840 /* note whether signs differ [used all paths] */
3841 diffsign
=(Flag
)((lhs
->bits
^rhs
->bits
^negate
)&DECNEG
);
3843 /* handle infinities and NaNs */
3844 if (SPECIALARGS
) { /* a special bit set */
3845 if (SPECIALARGS
& (DECSNAN
| DECNAN
)) /* a NaN */
3846 decNaNs(res
, lhs
, rhs
, set
, status
);
3847 else { /* one or two infinities */
3848 if (decNumberIsInfinite(lhs
)) { /* LHS is infinity */
3849 /* two infinities with different signs is invalid */
3850 if (decNumberIsInfinite(rhs
) && diffsign
) {
3851 *status
|=DEC_Invalid_operation
;
3854 bits
=lhs
->bits
& DECNEG
; /* get sign from LHS */
3856 else bits
=(rhs
->bits
^negate
) & DECNEG
;/* RHS must be Infinity */
3859 res
->bits
=bits
; /* set +/- infinity */
3864 /* Quick exit for add 0s; return the non-0, modified as need be */
3866 Int adjust
; /* work */
3867 Int lexp
=lhs
->exponent
; /* save in case LHS==RES */
3868 bits
=lhs
->bits
; /* .. */
3869 residue
=0; /* clear accumulator */
3870 decCopyFit(res
, rhs
, set
, &residue
, status
); /* copy (as needed) */
3871 res
->bits
^=negate
; /* flip if rhs was negated */
3873 if (set
->extended
) { /* exponents on zeros count */
3875 /* exponent will be the lower of the two */
3876 adjust
=lexp
-res
->exponent
; /* adjustment needed [if -ve] */
3877 if (ISZERO(res
)) { /* both 0: special IEEE 754 rules */
3878 if (adjust
<0) res
->exponent
=lexp
; /* set exponent */
3879 /* 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0 */
3881 if (set
->round
!=DEC_ROUND_FLOOR
) res
->bits
=0;
3882 else res
->bits
=DECNEG
; /* preserve 0 sign */
3885 else { /* non-0 res */
3886 if (adjust
<0) { /* 0-padding needed */
3887 if ((res
->digits
-adjust
)>set
->digits
) {
3888 adjust
=res
->digits
-set
->digits
; /* to fit exactly */
3889 *status
|=DEC_Rounded
; /* [but exact] */
3891 res
->digits
=decShiftToMost(res
->lsu
, res
->digits
, -adjust
);
3892 res
->exponent
+=adjust
; /* set the exponent. */
3898 decFinish(res
, set
, &residue
, status
); /* clean and finalize */
3901 if (ISZERO(rhs
)) { /* [lhs is non-zero] */
3902 Int adjust
; /* work */
3903 Int rexp
=rhs
->exponent
; /* save in case RHS==RES */
3904 bits
=rhs
->bits
; /* be clean */
3905 residue
=0; /* clear accumulator */
3906 decCopyFit(res
, lhs
, set
, &residue
, status
); /* copy (as needed) */
3908 if (set
->extended
) { /* exponents on zeros count */
3910 /* exponent will be the lower of the two */
3911 /* [0-0 case handled above] */
3912 adjust
=rexp
-res
->exponent
; /* adjustment needed [if -ve] */
3913 if (adjust
<0) { /* 0-padding needed */
3914 if ((res
->digits
-adjust
)>set
->digits
) {
3915 adjust
=res
->digits
-set
->digits
; /* to fit exactly */
3916 *status
|=DEC_Rounded
; /* [but exact] */
3918 res
->digits
=decShiftToMost(res
->lsu
, res
->digits
, -adjust
);
3919 res
->exponent
+=adjust
; /* set the exponent. */
3924 decFinish(res
, set
, &residue
, status
); /* clean and finalize */
3927 /* [NB: both fastpath and mainpath code below assume these cases */
3928 /* (notably 0-0) have already been handled] */
3930 /* calculate the padding needed to align the operands */
3931 padding
=rhs
->exponent
-lhs
->exponent
;
3933 /* Fastpath cases where the numbers are aligned and normal, the RHS */
3934 /* is all in one unit, no operand rounding is needed, and no carry, */
3935 /* lengthening, or borrow is needed */
3937 && rhs
->digits
<=DECDPUN
3938 && rhs
->exponent
>=set
->emin
/* [some normals drop through] */
3939 && rhs
->exponent
<=set
->emax
-set
->digits
+1 /* [could clamp] */
3940 && rhs
->digits
<=reqdigits
3941 && lhs
->digits
<=reqdigits
) {
3942 Int partial
=*lhs
->lsu
;
3943 if (!diffsign
) { /* adding */
3945 if ((partial
<=DECDPUNMAX
) /* result fits in unit */
3946 && (lhs
->digits
>=DECDPUN
|| /* .. and no digits-count change */
3947 partial
<(Int
)powers
[lhs
->digits
])) { /* .. */
3948 if (res
!=lhs
) decNumberCopy(res
, lhs
); /* not in place */
3949 *res
->lsu
=(Unit
)partial
; /* [copy could have overwritten RHS] */
3952 /* else drop out for careful add */
3954 else { /* signs differ */
3956 if (partial
>0) { /* no borrow needed, and non-0 result */
3957 if (res
!=lhs
) decNumberCopy(res
, lhs
); /* not in place */
3958 *res
->lsu
=(Unit
)partial
;
3959 /* this could have reduced digits [but result>0] */
3960 res
->digits
=decGetDigits(res
->lsu
, D2U(res
->digits
));
3963 /* else drop out for careful subtract */
3967 /* Now align (pad) the lhs or rhs so they can be added or */
3968 /* subtracted, as necessary. If one number is much larger than */
3969 /* the other (that is, if in plain form there is a least one */
3970 /* digit between the lowest digit of one and the highest of the */
3971 /* other) padding with up to DIGITS-1 trailing zeros may be */
3972 /* needed; then apply rounding (as exotic rounding modes may be */
3973 /* affected by the residue). */
3974 rhsshift
=0; /* rhs shift to left (padding) in Units */
3975 bits
=lhs
->bits
; /* assume sign is that of LHS */
3976 mult
=1; /* likely multiplier */
3978 /* [if padding==0 the operands are aligned; no padding is needed] */
3980 /* some padding needed; always pad the RHS, as any required */
3981 /* padding can then be effected by a simple combination of */
3982 /* shifts and a multiply */
3984 if (padding
<0) { /* LHS needs the padding */
3986 padding
=-padding
; /* will be +ve */
3987 bits
=(uByte
)(rhs
->bits
^negate
); /* assumed sign is now that of RHS */
3988 t
=lhs
; lhs
=rhs
; rhs
=t
;
3992 /* If, after pad, rhs would be longer than lhs by digits+1 or */
3993 /* more then lhs cannot affect the answer, except as a residue, */
3994 /* so only need to pad up to a length of DIGITS+1. */
3995 if (rhs
->digits
+padding
> lhs
->digits
+reqdigits
+1) {
3996 /* The RHS is sufficient */
3997 /* for residue use the relative sign indication... */
3998 Int shift
=reqdigits
-rhs
->digits
; /* left shift needed */
3999 residue
=1; /* residue for rounding */
4000 if (diffsign
) residue
=-residue
; /* signs differ */
4001 /* copy, shortening if necessary */
4002 decCopyFit(res
, rhs
, set
, &residue
, status
);
4003 /* if it was already shorter, then need to pad with zeros */
4005 res
->digits
=decShiftToMost(res
->lsu
, res
->digits
, shift
);
4006 res
->exponent
-=shift
; /* adjust the exponent. */
4008 /* flip the result sign if unswapped and rhs was negated */
4009 if (!swapped
) res
->bits
^=negate
;
4010 decFinish(res
, set
, &residue
, status
); /* done */
4013 /* LHS digits may affect result */
4014 rhsshift
=D2U(padding
+1)-1; /* this much by Unit shift .. */
4015 mult
=powers
[padding
-(rhsshift
*DECDPUN
)]; /* .. this by multiplication */
4016 } /* padding needed */
4018 if (diffsign
) mult
=-mult
; /* signs differ */
4020 /* determine the longer operand */
4021 maxdigits
=rhs
->digits
+padding
; /* virtual length of RHS */
4022 if (lhs
->digits
>maxdigits
) maxdigits
=lhs
->digits
;
4024 /* Decide on the result buffer to use; if possible place directly */
4026 acc
=res
->lsu
; /* assume add direct to result */
4027 /* If destructive overlap, or the number is too long, or a carry or */
4028 /* borrow to DIGITS+1 might be possible, a buffer must be used. */
4029 /* [Might be worth more sophisticated tests when maxdigits==reqdigits] */
4030 if ((maxdigits
>=reqdigits
) /* is, or could be, too large */
4031 || (res
==rhs
&& rhsshift
>0)) { /* destructive overlap */
4032 /* buffer needed, choose it; units for maxdigits digits will be */
4033 /* needed, +1 Unit for carry or borrow */
4034 Int need
=D2U(maxdigits
)+1;
4035 acc
=accbuff
; /* assume use local buffer */
4036 if (need
*sizeof(Unit
)>sizeof(accbuff
)) {
4037 /* printf("malloc add %ld %ld\n", need, sizeof(accbuff)); */
4038 allocacc
=(Unit
*)malloc(need
*sizeof(Unit
));
4039 if (allocacc
==NULL
) { /* hopeless -- abandon */
4040 *status
|=DEC_Insufficient_storage
;
4046 res
->bits
=(uByte
)(bits
&DECNEG
); /* it's now safe to overwrite.. */
4047 res
->exponent
=lhs
->exponent
; /* .. operands (even if aliased) */
4050 decDumpAr('A', lhs
->lsu
, D2U(lhs
->digits
));
4051 decDumpAr('B', rhs
->lsu
, D2U(rhs
->digits
));
4052 printf(" :h: %ld %ld\n", rhsshift
, mult
);
4055 /* add [A+B*m] or subtract [A+B*(-m)] */
4056 res
->digits
=decUnitAddSub(lhs
->lsu
, D2U(lhs
->digits
),
4057 rhs
->lsu
, D2U(rhs
->digits
),
4058 rhsshift
, acc
, mult
)
4059 *DECDPUN
; /* [units -> digits] */
4060 if (res
->digits
<0) { /* borrowed... */
4061 res
->digits
=-res
->digits
;
4062 res
->bits
^=DECNEG
; /* flip the sign */
4065 decDumpAr('+', acc
, D2U(res
->digits
));
4068 /* If a buffer was used the result must be copied back, possibly */
4069 /* shortening. (If no buffer was used then the result must have */
4070 /* fit, so can't need rounding and residue must be 0.) */
4071 residue
=0; /* clear accumulator */
4072 if (acc
!=res
->lsu
) {
4074 if (set
->extended
) { /* round from first significant digit */
4076 /* remove leading zeros that were added due to rounding up to */
4077 /* integral Units -- before the test for rounding. */
4078 if (res
->digits
>reqdigits
)
4079 res
->digits
=decGetDigits(acc
, D2U(res
->digits
));
4080 decSetCoeff(res
, set
, acc
, res
->digits
, &residue
, status
);
4083 else { /* subset arithmetic rounds from original significant digit */
4084 /* May have an underestimate. This only occurs when both */
4085 /* numbers fit in DECDPUN digits and are padding with a */
4086 /* negative multiple (-10, -100...) and the top digit(s) become */
4087 /* 0. (This only matters when using X3.274 rules where the */
4088 /* leading zero could be included in the rounding.) */
4089 if (res
->digits
<maxdigits
) {
4090 *(acc
+D2U(res
->digits
))=0; /* ensure leading 0 is there */
4091 res
->digits
=maxdigits
;
4094 /* remove leading zeros that added due to rounding up to */
4095 /* integral Units (but only those in excess of the original */
4096 /* maxdigits length, unless extended) before test for rounding. */
4097 if (res
->digits
>reqdigits
) {
4098 res
->digits
=decGetDigits(acc
, D2U(res
->digits
));
4099 if (res
->digits
<maxdigits
) res
->digits
=maxdigits
;
4102 decSetCoeff(res
, set
, acc
, res
->digits
, &residue
, status
);
4103 /* Now apply rounding if needed before removing leading zeros. */
4104 /* This is safe because subnormals are not a possibility */
4106 decApplyRound(res
, set
, residue
, status
);
4107 residue
=0; /* did what needed to be done */
4113 /* strip leading zeros [these were left on in case of subset subtract] */
4114 res
->digits
=decGetDigits(res
->lsu
, D2U(res
->digits
));
4116 /* apply checks and rounding */
4117 decFinish(res
, set
, &residue
, status
);
4119 /* "When the sum of two operands with opposite signs is exactly */
4120 /* zero, the sign of that sum shall be '+' in all rounding modes */
4121 /* except round toward -Infinity, in which mode that sign shall be */
4122 /* '-'." [Subset zeros also never have '-', set by decFinish.] */
4123 if (ISZERO(res
) && diffsign
4127 && (*status
&DEC_Inexact
)==0) {
4128 if (set
->round
==DEC_ROUND_FLOOR
) res
->bits
|=DECNEG
; /* sign - */
4129 else res
->bits
&=~DECNEG
; /* sign + */
4131 } while(0); /* end protected */
4133 free(allocacc
); /* drop any storage used */
4135 free(allocrhs
); /* .. */
4136 free(alloclhs
); /* .. */
4141 /* ------------------------------------------------------------------ */
4142 /* decDivideOp -- division operation */
4144 /* This routine performs the calculations for all four division */
4145 /* operators (divide, divideInteger, remainder, remainderNear). */
4149 /* res is C, the result. C may be A and/or B (e.g., X=X/X) */
4152 /* set is the context */
4153 /* op is DIVIDE, DIVIDEINT, REMAINDER, or REMNEAR respectively. */
4154 /* status is the usual accumulator */
4156 /* C must have space for set->digits digits. */
4158 /* ------------------------------------------------------------------ */
4159 /* The underlying algorithm of this routine is the same as in the */
4160 /* 1981 S/370 implementation, that is, non-restoring long division */
4161 /* with bi-unit (rather than bi-digit) estimation for each unit */
4162 /* multiplier. In this pseudocode overview, complications for the */
4163 /* Remainder operators and division residues for exact rounding are */
4164 /* omitted for clarity. */
4166 /* Prepare operands and handle special values */
4167 /* Test for x/0 and then 0/x */
4168 /* Exp =Exp1 - Exp2 */
4169 /* Exp =Exp +len(var1) -len(var2) */
4170 /* Sign=Sign1 * Sign2 */
4171 /* Pad accumulator (Var1) to double-length with 0's (pad1) */
4172 /* Pad Var2 to same length as Var1 */
4173 /* msu2pair/plus=1st 2 or 1 units of var2, +1 to allow for round */
4175 /* Do until (have=digits+1 OR residue=0) */
4176 /* if exp<0 then if integer divide/residue then leave */
4179 /* compare numbers */
4180 /* if <0 then leave inner_loop */
4181 /* if =0 then (* quick exit without subtract *) do */
4182 /* this_unit=this_unit+1; output this_unit */
4183 /* leave outer_loop; end */
4184 /* Compare lengths of numbers (mantissae): */
4185 /* If same then tops2=msu2pair -- {units 1&2 of var2} */
4186 /* else tops2=msu2plus -- {0, unit 1 of var2} */
4187 /* tops1=first_unit_of_Var1*10**DECDPUN +second_unit_of_var1 */
4188 /* mult=tops1/tops2 -- Good and safe guess at divisor */
4189 /* if mult=0 then mult=1 */
4190 /* this_unit=this_unit+mult */
4192 /* end inner_loop */
4193 /* if have\=0 | this_unit\=0 then do */
4194 /* output this_unit */
4195 /* have=have+1; end */
4198 /* end outer_loop */
4199 /* exp=exp+1 -- set the proper exponent */
4200 /* if have=0 then generate answer=0 */
4201 /* Return (Result is defined by Var1) */
4203 /* ------------------------------------------------------------------ */
4204 /* Two working buffers are needed during the division; one (digits+ */
4205 /* 1) to accumulate the result, and the other (up to 2*digits+1) for */
4206 /* long subtractions. These are acc and var1 respectively. */
4207 /* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/
4208 /* The static buffers may be larger than might be expected to allow */
4209 /* for calls from higher-level funtions (notable exp). */
4210 /* ------------------------------------------------------------------ */
4211 static decNumber
* decDivideOp(decNumber
*res
,
4212 const decNumber
*lhs
, const decNumber
*rhs
,
4213 decContext
*set
, Flag op
, uInt
*status
) {
4215 decNumber
*alloclhs
=NULL
; /* non-NULL if rounded lhs allocated */
4216 decNumber
*allocrhs
=NULL
; /* .., rhs */
4218 Unit accbuff
[SD2U(DECBUFFER
+DECDPUN
+10)]; /* local buffer */
4219 Unit
*acc
=accbuff
; /* -> accumulator array for result */
4220 Unit
*allocacc
=NULL
; /* -> allocated buffer, iff allocated */
4221 Unit
*accnext
; /* -> where next digit will go */
4222 Int acclength
; /* length of acc needed [Units] */
4223 Int accunits
; /* count of units accumulated */
4224 Int accdigits
; /* count of digits accumulated */
4226 Unit varbuff
[SD2U(DECBUFFER
*2+DECDPUN
)]; /* buffer for var1 */
4227 Unit
*var1
=varbuff
; /* -> var1 array for long subtraction */
4228 Unit
*varalloc
=NULL
; /* -> allocated buffer, iff used */
4229 Unit
*msu1
; /* -> msu of var1 */
4231 const Unit
*var2
; /* -> var2 array */
4232 const Unit
*msu2
; /* -> msu of var2 */
4233 Int msu2plus
; /* msu2 plus one [does not vary] */
4234 eInt msu2pair
; /* msu2 pair plus one [does not vary] */
4236 Int var1units
, var2units
; /* actual lengths */
4237 Int var2ulen
; /* logical length (units) */
4238 Int var1initpad
=0; /* var1 initial padding (digits) */
4239 Int maxdigits
; /* longest LHS or required acc length */
4240 Int mult
; /* multiplier for subtraction */
4241 Unit thisunit
; /* current unit being accumulated */
4242 Int residue
; /* for rounding */
4243 Int reqdigits
=set
->digits
; /* requested DIGITS */
4244 Int exponent
; /* working exponent */
4245 Int maxexponent
=0; /* DIVIDE maximum exponent if unrounded */
4246 uByte bits
; /* working sign */
4247 Unit
*target
; /* work */
4248 const Unit
*source
; /* .. */
4249 uInt
const *pow
; /* .. */
4250 Int shift
, cut
; /* .. */
4252 Int dropped
; /* work */
4256 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
4259 do { /* protect allocated storage */
4261 if (!set
->extended
) {
4262 /* reduce operands and set lostDigits status, as needed */
4263 if (lhs
->digits
>reqdigits
) {
4264 alloclhs
=decRoundOperand(lhs
, set
, status
);
4265 if (alloclhs
==NULL
) break;
4268 if (rhs
->digits
>reqdigits
) {
4269 allocrhs
=decRoundOperand(rhs
, set
, status
);
4270 if (allocrhs
==NULL
) break;
4275 /* [following code does not require input rounding] */
4277 bits
=(lhs
->bits
^rhs
->bits
)&DECNEG
; /* assumed sign for divisions */
4279 /* handle infinities and NaNs */
4280 if (SPECIALARGS
) { /* a special bit set */
4281 if (SPECIALARGS
& (DECSNAN
| DECNAN
)) { /* one or two NaNs */
4282 decNaNs(res
, lhs
, rhs
, set
, status
);
4285 /* one or two infinities */
4286 if (decNumberIsInfinite(lhs
)) { /* LHS (dividend) is infinite */
4287 if (decNumberIsInfinite(rhs
) || /* two infinities are invalid .. */
4288 op
& (REMAINDER
| REMNEAR
)) { /* as is remainder of infinity */
4289 *status
|=DEC_Invalid_operation
;
4292 /* [Note that infinity/0 raises no exceptions] */
4294 res
->bits
=bits
|DECINF
; /* set +/- infinity */
4297 else { /* RHS (divisor) is infinite */
4299 if (op
&(REMAINDER
|REMNEAR
)) {
4300 /* result is [finished clone of] lhs */
4301 decCopyFit(res
, lhs
, set
, &residue
, status
);
4303 else { /* a division */
4305 res
->bits
=bits
; /* set +/- zero */
4306 /* for DIVIDEINT the exponent is always 0. For DIVIDE, result */
4307 /* is a 0 with infinitely negative exponent, clamped to minimum */
4309 res
->exponent
=set
->emin
-set
->digits
+1;
4310 *status
|=DEC_Clamped
;
4313 decFinish(res
, set
, &residue
, status
);
4318 /* handle 0 rhs (x/0) */
4319 if (ISZERO(rhs
)) { /* x/0 is always exceptional */
4321 decNumberZero(res
); /* [after lhs test] */
4322 *status
|=DEC_Division_undefined
;/* 0/0 will become NaN */
4326 if (op
&(REMAINDER
|REMNEAR
)) *status
|=DEC_Invalid_operation
;
4328 *status
|=DEC_Division_by_zero
; /* x/0 */
4329 res
->bits
=bits
|DECINF
; /* .. is +/- Infinity */
4334 /* handle 0 lhs (0/x) */
4335 if (ISZERO(lhs
)) { /* 0/x [x!=0] */
4337 if (!set
->extended
) decNumberZero(res
);
4342 exponent
=lhs
->exponent
-rhs
->exponent
; /* ideal exponent */
4343 decNumberCopy(res
, lhs
); /* [zeros always fit] */
4344 res
->bits
=bits
; /* sign as computed */
4345 res
->exponent
=exponent
; /* exponent, too */
4346 decFinalize(res
, set
, &residue
, status
); /* check exponent */
4348 else if (op
&DIVIDEINT
) {
4349 decNumberZero(res
); /* integer 0 */
4350 res
->bits
=bits
; /* sign as computed */
4352 else { /* a remainder */
4353 exponent
=rhs
->exponent
; /* [save in case overwrite] */
4354 decNumberCopy(res
, lhs
); /* [zeros always fit] */
4355 if (exponent
<res
->exponent
) res
->exponent
=exponent
; /* use lower */
4362 /* Precalculate exponent. This starts off adjusted (and hence fits */
4363 /* in 31 bits) and becomes the usual unadjusted exponent as the */
4364 /* division proceeds. The order of evaluation is important, here, */
4365 /* to avoid wrap. */
4366 exponent
=(lhs
->exponent
+lhs
->digits
)-(rhs
->exponent
+rhs
->digits
);
4368 /* If the working exponent is -ve, then some quick exits are */
4369 /* possible because the quotient is known to be <1 */
4370 /* [for REMNEAR, it needs to be < -1, as -0.5 could need work] */
4371 if (exponent
<0 && !(op
==DIVIDE
)) {
4373 decNumberZero(res
); /* integer part is 0 */
4377 res
->bits
=bits
; /* set +/- zero */
4379 /* fastpath remainders so long as the lhs has the smaller */
4380 /* (or equal) exponent */
4381 if (lhs
->exponent
<=rhs
->exponent
) {
4382 if (op
&REMAINDER
|| exponent
<-1) {
4383 /* It is REMAINDER or safe REMNEAR; result is [finished */
4384 /* clone of] lhs (r = x - 0*y) */
4386 decCopyFit(res
, lhs
, set
, &residue
, status
);
4387 decFinish(res
, set
, &residue
, status
);
4390 /* [unsafe REMNEAR drops through] */
4394 /* Long (slow) division is needed; roll up the sleeves... */
4396 /* The accumulator will hold the quotient of the division. */
4397 /* If it needs to be too long for stack storage, then allocate. */
4398 acclength
=D2U(reqdigits
+DECDPUN
); /* in Units */
4399 if (acclength
*sizeof(Unit
)>sizeof(accbuff
)) {
4400 /* printf("malloc dvacc %ld units\n", acclength); */
4401 allocacc
=(Unit
*)malloc(acclength
*sizeof(Unit
));
4402 if (allocacc
==NULL
) { /* hopeless -- abandon */
4403 *status
|=DEC_Insufficient_storage
;
4405 acc
=allocacc
; /* use the allocated space */
4408 /* var1 is the padded LHS ready for subtractions. */
4409 /* If it needs to be too long for stack storage, then allocate. */
4410 /* The maximum units needed for var1 (long subtraction) is: */
4412 /* (rhs->digits+reqdigits-1) -- to allow full slide to right */
4413 /* or (lhs->digits) -- to allow for long lhs */
4414 /* whichever is larger */
4415 /* +1 -- for rounding of slide to right */
4416 /* +1 -- for leading 0s */
4417 /* +1 -- for pre-adjust if a remainder or DIVIDEINT */
4418 /* [Note: unused units do not participate in decUnitAddSub data] */
4419 maxdigits
=rhs
->digits
+reqdigits
-1;
4420 if (lhs
->digits
>maxdigits
) maxdigits
=lhs
->digits
;
4421 var1units
=D2U(maxdigits
)+2;
4422 /* allocate a guard unit above msu1 for REMAINDERNEAR */
4423 if (!(op
&DIVIDE
)) var1units
++;
4424 if ((var1units
+1)*sizeof(Unit
)>sizeof(varbuff
)) {
4425 /* printf("malloc dvvar %ld units\n", var1units+1); */
4426 varalloc
=(Unit
*)malloc((var1units
+1)*sizeof(Unit
));
4427 if (varalloc
==NULL
) { /* hopeless -- abandon */
4428 *status
|=DEC_Insufficient_storage
;
4430 var1
=varalloc
; /* use the allocated space */
4433 /* Extend the lhs and rhs to full long subtraction length. The lhs */
4434 /* is truly extended into the var1 buffer, with 0 padding, so a */
4435 /* subtract in place is always possible. The rhs (var2) has */
4436 /* virtual padding (implemented by decUnitAddSub). */
4437 /* One guard unit was allocated above msu1 for rem=rem+rem in */
4438 /* REMAINDERNEAR. */
4439 msu1
=var1
+var1units
-1; /* msu of var1 */
4440 source
=lhs
->lsu
+D2U(lhs
->digits
)-1; /* msu of input array */
4441 for (target
=msu1
; source
>=lhs
->lsu
; source
--, target
--) *target
=*source
;
4442 for (; target
>=var1
; target
--) *target
=0;
4444 /* rhs (var2) is left-aligned with var1 at the start */
4445 var2ulen
=var1units
; /* rhs logical length (units) */
4446 var2units
=D2U(rhs
->digits
); /* rhs actual length (units) */
4447 var2
=rhs
->lsu
; /* -> rhs array */
4448 msu2
=var2
+var2units
-1; /* -> msu of var2 [never changes] */
4449 /* now set up the variables which will be used for estimating the */
4450 /* multiplication factor. If these variables are not exact, add */
4451 /* 1 to make sure that the multiplier is never overestimated. */
4452 msu2plus
=*msu2
; /* it's value .. */
4453 if (var2units
>1) msu2plus
++; /* .. +1 if any more */
4454 msu2pair
=(eInt
)*msu2
*(DECDPUNMAX
+1);/* top two pair .. */
4455 if (var2units
>1) { /* .. [else treat 2nd as 0] */
4456 msu2pair
+=*(msu2
-1); /* .. */
4457 if (var2units
>2) msu2pair
++; /* .. +1 if any more */
4460 /* The calculation is working in units, which may have leading zeros, */
4461 /* but the exponent was calculated on the assumption that they are */
4462 /* both left-aligned. Adjust the exponent to compensate: add the */
4463 /* number of leading zeros in var1 msu and subtract those in var2 msu. */
4464 /* [This is actually done by counting the digits and negating, as */
4465 /* lead1=DECDPUN-digits1, and similarly for lead2.] */
4466 for (pow
=&powers
[1]; *msu1
>=*pow
; pow
++) exponent
--;
4467 for (pow
=&powers
[1]; *msu2
>=*pow
; pow
++) exponent
++;
4469 /* Now, if doing an integer divide or remainder, ensure that */
4470 /* the result will be Unit-aligned. To do this, shift the var1 */
4471 /* accumulator towards least if need be. (It's much easier to */
4472 /* do this now than to reassemble the residue afterwards, if */
4473 /* doing a remainder.) Also ensure the exponent is not negative. */
4476 /* save the initial 'false' padding of var1, in digits */
4477 var1initpad
=(var1units
-D2U(lhs
->digits
))*DECDPUN
;
4478 /* Determine the shift to do. */
4479 if (exponent
<0) cut
=-exponent
;
4480 else cut
=DECDPUN
-exponent
%DECDPUN
;
4481 decShiftToLeast(var1
, var1units
, cut
);
4482 exponent
+=cut
; /* maintain numerical value */
4483 var1initpad
-=cut
; /* .. and reduce padding */
4484 /* clean any most-significant units which were just emptied */
4485 for (u
=msu1
; cut
>=DECDPUN
; cut
-=DECDPUN
, u
--) *u
=0;
4487 else { /* is DIVIDE */
4488 maxexponent
=lhs
->exponent
-rhs
->exponent
; /* save */
4489 /* optimization: if the first iteration will just produce 0, */
4490 /* preadjust to skip it [valid for DIVIDE only] */
4492 var2ulen
--; /* shift down */
4493 exponent
-=DECDPUN
; /* update the exponent */
4497 /* ---- start the long-division loops ------------------------------ */
4498 accunits
=0; /* no units accumulated yet */
4499 accdigits
=0; /* .. or digits */
4500 accnext
=acc
+acclength
-1; /* -> msu of acc [NB: allows digits+1] */
4501 for (;;) { /* outer forever loop */
4502 thisunit
=0; /* current unit assumed 0 */
4503 /* find the next unit */
4504 for (;;) { /* inner forever loop */
4505 /* strip leading zero units [from either pre-adjust or from */
4506 /* subtract last time around]. Leave at least one unit. */
4507 for (; *msu1
==0 && msu1
>var1
; msu1
--) var1units
--;
4509 if (var1units
<var2ulen
) break; /* var1 too low for subtract */
4510 if (var1units
==var2ulen
) { /* unit-by-unit compare needed */
4511 /* compare the two numbers, from msu */
4512 const Unit
*pv1
, *pv2
;
4513 Unit v2
; /* units to compare */
4514 pv2
=msu2
; /* -> msu */
4515 for (pv1
=msu1
; ; pv1
--, pv2
--) {
4516 /* v1=*pv1 -- always OK */
4517 v2
=0; /* assume in padding */
4518 if (pv2
>=var2
) v2
=*pv2
; /* in range */
4519 if (*pv1
!=v2
) break; /* no longer the same */
4520 if (pv1
==var1
) break; /* done; leave pv1 as is */
4522 /* here when all inspected or a difference seen */
4523 if (*pv1
<v2
) break; /* var1 too low to subtract */
4524 if (*pv1
==v2
) { /* var1 == var2 */
4525 /* reach here if var1 and var2 are identical; subtraction */
4526 /* would increase digit by one, and the residue will be 0 so */
4527 /* the calculation is done; leave the loop with residue=0. */
4528 thisunit
++; /* as though subtracted */
4529 *var1
=0; /* set var1 to 0 */
4530 var1units
=1; /* .. */
4531 break; /* from inner */
4532 } /* var1 == var2 */
4533 /* *pv1>v2. Prepare for real subtraction; the lengths are equal */
4534 /* Estimate the multiplier (there's always a msu1-1)... */
4535 /* Bring in two units of var2 to provide a good estimate. */
4536 mult
=(Int
)(((eInt
)*msu1
*(DECDPUNMAX
+1)+*(msu1
-1))/msu2pair
);
4537 } /* lengths the same */
4538 else { /* var1units > var2ulen, so subtraction is safe */
4539 /* The var2 msu is one unit towards the lsu of the var1 msu, */
4540 /* so only one unit for var2 can be used. */
4541 mult
=(Int
)(((eInt
)*msu1
*(DECDPUNMAX
+1)+*(msu1
-1))/msu2plus
);
4543 if (mult
==0) mult
=1; /* must always be at least 1 */
4544 /* subtraction needed; var1 is > var2 */
4545 thisunit
=(Unit
)(thisunit
+mult
); /* accumulate */
4546 /* subtract var1-var2, into var1; only the overlap needs */
4547 /* processing, as this is an in-place calculation */
4548 shift
=var2ulen
-var2units
;
4550 decDumpAr('1', &var1
[shift
], var1units
-shift
);
4551 decDumpAr('2', var2
, var2units
);
4552 printf("m=%ld\n", -mult
);
4554 decUnitAddSub(&var1
[shift
], var1units
-shift
,
4556 &var1
[shift
], -mult
);
4558 decDumpAr('#', &var1
[shift
], var1units
-shift
);
4560 /* var1 now probably has leading zeros; these are removed at the */
4561 /* top of the inner loop. */
4564 /* The next unit has been calculated in full; unless it's a */
4565 /* leading zero, add to acc */
4566 if (accunits
!=0 || thisunit
!=0) { /* is first or non-zero */
4567 *accnext
=thisunit
; /* store in accumulator */
4568 /* account exactly for the new digits */
4570 accdigits
++; /* at least one */
4571 for (pow
=&powers
[1]; thisunit
>=*pow
; pow
++) accdigits
++;
4573 else accdigits
+=DECDPUN
;
4574 accunits
++; /* update count */
4575 accnext
--; /* ready for next */
4576 if (accdigits
>reqdigits
) break; /* have enough digits */
4579 /* if the residue is zero, the operation is done (unless divide */
4580 /* or divideInteger and still not enough digits yet) */
4581 if (*var1
==0 && var1units
==1) { /* residue is 0 */
4582 if (op
&(REMAINDER
|REMNEAR
)) break;
4583 if ((op
&DIVIDE
) && (exponent
<=maxexponent
)) break;
4584 /* [drop through if divideInteger] */
4586 /* also done enough if calculating remainder or integer */
4587 /* divide and just did the last ('units') unit */
4588 if (exponent
==0 && !(op
&DIVIDE
)) break;
4590 /* to get here, var1 is less than var2, so divide var2 by the per- */
4591 /* Unit power of ten and go for the next digit */
4592 var2ulen
--; /* shift down */
4593 exponent
-=DECDPUN
; /* update the exponent */
4596 /* ---- division is complete --------------------------------------- */
4597 /* here: acc has at least reqdigits+1 of good results (or fewer */
4598 /* if early stop), starting at accnext+1 (its lsu) */
4599 /* var1 has any residue at the stopping point */
4600 /* accunits is the number of digits collected in acc */
4601 if (accunits
==0) { /* acc is 0 */
4602 accunits
=1; /* show have a unit .. */
4603 accdigits
=1; /* .. */
4604 *accnext
=0; /* .. whose value is 0 */
4606 else accnext
++; /* back to last placed */
4607 /* accnext now -> lowest unit of result */
4609 residue
=0; /* assume no residue */
4611 /* record the presence of any residue, for rounding */
4612 if (*var1
!=0 || var1units
>1) residue
=1;
4613 else { /* no residue */
4614 /* Had an exact division; clean up spurious trailing 0s. */
4615 /* There will be at most DECDPUN-1, from the final multiply, */
4616 /* and then only if the result is non-0 (and even) and the */
4617 /* exponent is 'loose'. */
4620 if (!(lsu
&0x01) && (lsu
!=0)) {
4621 /* count the trailing zeros */
4623 for (;; drop
++) { /* [will terminate because lsu!=0] */
4624 if (exponent
>=maxexponent
) break; /* don't chop real 0s */
4626 if ((lsu
-QUOT10(lsu
, drop
+1)
4627 *powers
[drop
+1])!=0) break; /* found non-0 digit */
4629 if (lsu
%powers
[drop
+1]!=0) break; /* found non-0 digit */
4634 accunits
=decShiftToLeast(accnext
, accunits
, drop
);
4635 accdigits
=decGetDigits(accnext
, accunits
);
4636 accunits
=D2U(accdigits
);
4637 /* [exponent was adjusted in the loop] */
4639 } /* neither odd nor 0 */
4641 } /* exact divide */
4643 else /* op!=DIVIDE */ {
4644 /* check for coefficient overflow */
4645 if (accdigits
+exponent
>reqdigits
) {
4646 *status
|=DEC_Division_impossible
;
4649 if (op
& (REMAINDER
|REMNEAR
)) {
4650 /* [Here, the exponent will be 0, because var1 was adjusted */
4651 /* appropriately.] */
4652 Int postshift
; /* work */
4653 Flag wasodd
=0; /* integer was odd */
4654 Unit
*quotlsu
; /* for save */
4655 Int quotdigits
; /* .. */
4657 bits
=lhs
->bits
; /* remainder sign is always as lhs */
4659 /* Fastpath when residue is truly 0 is worthwhile [and */
4660 /* simplifies the code below] */
4661 if (*var1
==0 && var1units
==1) { /* residue is 0 */
4662 Int exp
=lhs
->exponent
; /* save min(exponents) */
4663 if (rhs
->exponent
<exp
) exp
=rhs
->exponent
;
4664 decNumberZero(res
); /* 0 coefficient */
4668 res
->exponent
=exp
; /* .. with proper exponent */
4669 res
->bits
=(uByte
)(bits
&DECNEG
); /* [cleaned] */
4670 decFinish(res
, set
, &residue
, status
); /* might clamp */
4673 /* note if the quotient was odd */
4674 if (*accnext
& 0x01) wasodd
=1; /* acc is odd */
4675 quotlsu
=accnext
; /* save in case need to reinspect */
4676 quotdigits
=accdigits
; /* .. */
4678 /* treat the residue, in var1, as the value to return, via acc */
4679 /* calculate the unused zero digits. This is the smaller of: */
4680 /* var1 initial padding (saved above) */
4681 /* var2 residual padding, which happens to be given by: */
4682 postshift
=var1initpad
+exponent
-lhs
->exponent
+rhs
->exponent
;
4683 /* [the 'exponent' term accounts for the shifts during divide] */
4684 if (var1initpad
<postshift
) postshift
=var1initpad
;
4686 /* shift var1 the requested amount, and adjust its digits */
4687 var1units
=decShiftToLeast(var1
, var1units
, postshift
);
4689 accdigits
=decGetDigits(var1
, var1units
);
4690 accunits
=D2U(accdigits
);
4692 exponent
=lhs
->exponent
; /* exponent is smaller of lhs & rhs */
4693 if (rhs
->exponent
<exponent
) exponent
=rhs
->exponent
;
4695 /* Now correct the result if doing remainderNear; if it */
4696 /* (looking just at coefficients) is > rhs/2, or == rhs/2 and */
4697 /* the integer was odd then the result should be rem-rhs. */
4699 Int compare
, tarunits
; /* work */
4701 /* calculate remainder*2 into the var1 buffer (which has */
4702 /* 'headroom' of an extra unit and hence enough space) */
4703 /* [a dedicated 'double' loop would be faster, here] */
4704 tarunits
=decUnitAddSub(accnext
, accunits
, accnext
, accunits
,
4706 /* decDumpAr('r', accnext, tarunits); */
4708 /* Here, accnext (var1) holds tarunits Units with twice the */
4709 /* remainder's coefficient, which must now be compared to the */
4710 /* RHS. The remainder's exponent may be smaller than the RHS's. */
4711 compare
=decUnitCompare(accnext
, tarunits
, rhs
->lsu
, D2U(rhs
->digits
),
4712 rhs
->exponent
-exponent
);
4713 if (compare
==BADINT
) { /* deep trouble */
4714 *status
|=DEC_Insufficient_storage
;
4717 /* now restore the remainder by dividing by two; the lsu */
4718 /* is known to be even. */
4719 for (up
=accnext
; up
<accnext
+tarunits
; up
++) {
4720 Int half
; /* half to add to lower unit */
4722 *up
/=2; /* [shift] */
4723 if (!half
) continue;
4724 *(up
-1)+=(DECDPUNMAX
+1)/2;
4726 /* [accunits still describes the original remainder length] */
4728 if (compare
>0 || (compare
==0 && wasodd
)) { /* adjustment needed */
4729 Int exp
, expunits
, exprem
; /* work */
4730 /* This is effectively causing round-up of the quotient, */
4731 /* so if it was the rare case where it was full and all */
4732 /* nines, it would overflow and hence division-impossible */
4733 /* should be raised */
4734 Flag allnines
=0; /* 1 if quotient all nines */
4735 if (quotdigits
==reqdigits
) { /* could be borderline */
4736 for (up
=quotlsu
; ; up
++) {
4737 if (quotdigits
>DECDPUN
) {
4738 if (*up
!=DECDPUNMAX
) break;/* non-nines */
4740 else { /* this is the last Unit */
4741 if (*up
==powers
[quotdigits
]-1) allnines
=1;
4744 quotdigits
-=DECDPUN
; /* checked those digits */
4746 } /* borderline check */
4748 *status
|=DEC_Division_impossible
;
4751 /* rem-rhs is needed; the sign will invert. Again, var1 */
4752 /* can safely be used for the working Units array. */
4753 exp
=rhs
->exponent
-exponent
; /* RHS padding needed */
4754 /* Calculate units and remainder from exponent. */
4755 expunits
=exp
/DECDPUN
;
4757 /* subtract [A+B*(-m)]; the result will always be negative */
4758 accunits
=-decUnitAddSub(accnext
, accunits
,
4759 rhs
->lsu
, D2U(rhs
->digits
),
4760 expunits
, accnext
, -(Int
)powers
[exprem
]);
4761 accdigits
=decGetDigits(accnext
, accunits
); /* count digits exactly */
4762 accunits
=D2U(accdigits
); /* and recalculate the units for copy */
4763 /* [exponent is as for original remainder] */
4764 bits
^=DECNEG
; /* flip the sign */
4767 } /* REMAINDER or REMNEAR */
4770 /* Set exponent and bits */
4771 res
->exponent
=exponent
;
4772 res
->bits
=(uByte
)(bits
&DECNEG
); /* [cleaned] */
4774 /* Now the coefficient. */
4775 decSetCoeff(res
, set
, accnext
, accdigits
, &residue
, status
);
4777 decFinish(res
, set
, &residue
, status
); /* final cleanup */
4780 /* If a divide then strip trailing zeros if subset [after round] */
4781 if (!set
->extended
&& (op
==DIVIDE
)) decTrim(res
, set
, 0, 1, &dropped
);
4783 } while(0); /* end protected */
4785 free(varalloc
); /* drop any storage used */
4786 free(allocacc
); /* .. */
4788 free(allocrhs
); /* .. */
4789 free(alloclhs
); /* .. */
4794 /* ------------------------------------------------------------------ */
4795 /* decMultiplyOp -- multiplication operation */
4797 /* This routine performs the multiplication C=A x B. */
4799 /* res is C, the result. C may be A and/or B (e.g., X=X*X) */
4802 /* set is the context */
4803 /* status is the usual accumulator */
4805 /* C must have space for set->digits digits. */
4807 /* ------------------------------------------------------------------ */
4808 /* 'Classic' multiplication is used rather than Karatsuba, as the */
4809 /* latter would give only a minor improvement for the short numbers */
4810 /* expected to be handled most (and uses much more memory). */
4812 /* There are two major paths here: the general-purpose ('old code') */
4813 /* path which handles all DECDPUN values, and a fastpath version */
4814 /* which is used if 64-bit ints are available, DECDPUN<=4, and more */
4815 /* than two calls to decUnitAddSub would be made. */
4817 /* The fastpath version lumps units together into 8-digit or 9-digit */
4818 /* chunks, and also uses a lazy carry strategy to minimise expensive */
4819 /* 64-bit divisions. The chunks are then broken apart again into */
4820 /* units for continuing processing. Despite this overhead, the */
4821 /* fastpath can speed up some 16-digit operations by 10x (and much */
4822 /* more for higher-precision calculations). */
4824 /* A buffer always has to be used for the accumulator; in the */
4825 /* fastpath, buffers are also always needed for the chunked copies of */
4826 /* of the operand coefficients. */
4827 /* Static buffers are larger than needed just for multiply, to allow */
4828 /* for calls from other operations (notably exp). */
4829 /* ------------------------------------------------------------------ */
4830 #define FASTMUL (DECUSE64 && DECDPUN<5)
4831 static decNumber
* decMultiplyOp(decNumber
*res
, const decNumber
*lhs
,
4832 const decNumber
*rhs
, decContext
*set
,
4834 Int accunits
; /* Units of accumulator in use */
4835 Int exponent
; /* work */
4836 Int residue
=0; /* rounding residue */
4837 uByte bits
; /* result sign */
4838 Unit
*acc
; /* -> accumulator Unit array */
4839 Int needbytes
; /* size calculator */
4840 void *allocacc
=NULL
; /* -> allocated accumulator, iff allocated */
4841 Unit accbuff
[SD2U(DECBUFFER
*4+1)]; /* buffer (+1 for DECBUFFER==0, */
4842 /* *4 for calls from other operations) */
4843 const Unit
*mer
, *mermsup
; /* work */
4844 Int madlength
; /* Units in multiplicand */
4845 Int shift
; /* Units to shift multiplicand by */
4848 /* if DECDPUN is 1 or 3 work in base 10**9, otherwise */
4849 /* (DECDPUN is 2 or 4) then work in base 10**8 */
4850 #if DECDPUN & 1 /* odd */
4851 #define FASTBASE 1000000000 /* base */
4852 #define FASTDIGS 9 /* digits in base */
4853 #define FASTLAZY 18 /* carry resolution point [1->18] */
4855 #define FASTBASE 100000000
4857 #define FASTLAZY 1844 /* carry resolution point [1->1844] */
4859 /* three buffers are used, two for chunked copies of the operands */
4860 /* (base 10**8 or base 10**9) and one base 2**64 accumulator with */
4861 /* lazy carry evaluation */
4862 uInt zlhibuff
[(DECBUFFER
*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
4863 uInt
*zlhi
=zlhibuff
; /* -> lhs array */
4864 uInt
*alloclhi
=NULL
; /* -> allocated buffer, iff allocated */
4865 uInt zrhibuff
[(DECBUFFER
*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
4866 uInt
*zrhi
=zrhibuff
; /* -> rhs array */
4867 uInt
*allocrhi
=NULL
; /* -> allocated buffer, iff allocated */
4868 uLong zaccbuff
[(DECBUFFER
*2+1)/4+2]; /* buffer (+1 for DECBUFFER==0) */
4869 /* [allocacc is shared for both paths, as only one will run] */
4870 uLong
*zacc
=zaccbuff
; /* -> accumulator array for exact result */
4872 Int zoff
; /* accumulator offset */
4874 uInt
*lip
, *rip
; /* item pointers */
4875 uInt
*lmsi
, *rmsi
; /* most significant items */
4876 Int ilhs
, irhs
, iacc
; /* item counts in the arrays */
4877 Int lazy
; /* lazy carry counter */
4878 uLong lcarry
; /* uLong carry */
4879 uInt carry
; /* carry (NB not uLong) */
4880 Int count
; /* work */
4881 const Unit
*cup
; /* .. */
4888 decNumber
*alloclhs
=NULL
; /* -> allocated buffer, iff allocated */
4889 decNumber
*allocrhs
=NULL
; /* -> allocated buffer, iff allocated */
4893 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
4896 /* precalculate result sign */
4897 bits
=(uByte
)((lhs
->bits
^rhs
->bits
)&DECNEG
);
4899 /* handle infinities and NaNs */
4900 if (SPECIALARGS
) { /* a special bit set */
4901 if (SPECIALARGS
& (DECSNAN
| DECNAN
)) { /* one or two NaNs */
4902 decNaNs(res
, lhs
, rhs
, set
, status
);
4904 /* one or two infinities; Infinity * 0 is invalid */
4905 if (((lhs
->bits
& DECINF
)==0 && ISZERO(lhs
))
4906 ||((rhs
->bits
& DECINF
)==0 && ISZERO(rhs
))) {
4907 *status
|=DEC_Invalid_operation
;
4910 res
->bits
=bits
|DECINF
; /* infinity */
4913 /* For best speed, as in DMSRCN [the original Rexx numerics */
4914 /* module], use the shorter number as the multiplier (rhs) and */
4915 /* the longer as the multiplicand (lhs) to minimise the number of */
4916 /* adds (partial products) */
4917 if (lhs
->digits
<rhs
->digits
) { /* swap... */
4918 const decNumber
*hold
=lhs
;
4923 do { /* protect allocated storage */
4925 if (!set
->extended
) {
4926 /* reduce operands and set lostDigits status, as needed */
4927 if (lhs
->digits
>set
->digits
) {
4928 alloclhs
=decRoundOperand(lhs
, set
, status
);
4929 if (alloclhs
==NULL
) break;
4932 if (rhs
->digits
>set
->digits
) {
4933 allocrhs
=decRoundOperand(rhs
, set
, status
);
4934 if (allocrhs
==NULL
) break;
4939 /* [following code does not require input rounding] */
4941 #if FASTMUL /* fastpath can be used */
4942 /* use the fast path if there are enough digits in the shorter */
4943 /* operand to make the setup and takedown worthwhile */
4944 #define NEEDTWO (DECDPUN*2) /* within two decUnitAddSub calls */
4945 if (rhs
->digits
>NEEDTWO
) { /* use fastpath... */
4946 /* calculate the number of elements in each array */
4947 ilhs
=(lhs
->digits
+FASTDIGS
-1)/FASTDIGS
; /* [ceiling] */
4948 irhs
=(rhs
->digits
+FASTDIGS
-1)/FASTDIGS
; /* .. */
4951 /* allocate buffers if required, as usual */
4952 needbytes
=ilhs
*sizeof(uInt
);
4953 if (needbytes
>(Int
)sizeof(zlhibuff
)) {
4954 alloclhi
=(uInt
*)malloc(needbytes
);
4956 needbytes
=irhs
*sizeof(uInt
);
4957 if (needbytes
>(Int
)sizeof(zrhibuff
)) {
4958 allocrhi
=(uInt
*)malloc(needbytes
);
4961 /* Allocating the accumulator space needs a special case when */
4962 /* DECDPUN=1 because when converting the accumulator to Units */
4963 /* after the multiplication each 8-byte item becomes 9 1-byte */
4964 /* units. Therefore iacc extra bytes are needed at the front */
4965 /* (rounded up to a multiple of 8 bytes), and the uLong */
4966 /* accumulator starts offset the appropriate number of units */
4967 /* to the right to avoid overwrite during the unchunking. */
4968 needbytes
=iacc
*sizeof(uLong
);
4970 zoff
=(iacc
+7)/8; /* items to offset by */
4973 if (needbytes
>(Int
)sizeof(zaccbuff
)) {
4974 allocacc
=(uLong
*)malloc(needbytes
);
4975 zacc
=(uLong
*)allocacc
;}
4976 if (zlhi
==NULL
||zrhi
==NULL
||zacc
==NULL
) {
4977 *status
|=DEC_Insufficient_storage
;
4980 acc
=(Unit
*)zacc
; /* -> target Unit array */
4982 zacc
+=zoff
; /* start uLong accumulator to right */
4985 /* assemble the chunked copies of the left and right sides */
4986 for (count
=lhs
->digits
, cup
=lhs
->lsu
, lip
=zlhi
; count
>0; lip
++)
4987 for (p
=0, *lip
=0; p
<FASTDIGS
&& count
>0;
4988 p
+=DECDPUN
, cup
++, count
-=DECDPUN
)
4989 *lip
+=*cup
*powers
[p
];
4990 lmsi
=lip
-1; /* save -> msi */
4991 for (count
=rhs
->digits
, cup
=rhs
->lsu
, rip
=zrhi
; count
>0; rip
++)
4992 for (p
=0, *rip
=0; p
<FASTDIGS
&& count
>0;
4993 p
+=DECDPUN
, cup
++, count
-=DECDPUN
)
4994 *rip
+=*cup
*powers
[p
];
4995 rmsi
=rip
-1; /* save -> msi */
4997 /* zero the accumulator */
4998 for (lp
=zacc
; lp
<zacc
+iacc
; lp
++) *lp
=0;
5000 /* Start the multiplication */
5001 /* Resolving carries can dominate the cost of accumulating the */
5002 /* partial products, so this is only done when necessary. */
5003 /* Each uLong item in the accumulator can hold values up to */
5004 /* 2**64-1, and each partial product can be as large as */
5005 /* (10**FASTDIGS-1)**2. When FASTDIGS=9, this can be added to */
5006 /* itself 18.4 times in a uLong without overflowing, so during */
5007 /* the main calculation resolution is carried out every 18th */
5008 /* add -- every 162 digits. Similarly, when FASTDIGS=8, the */
5009 /* partial products can be added to themselves 1844.6 times in */
5010 /* a uLong without overflowing, so intermediate carry */
5011 /* resolution occurs only every 14752 digits. Hence for common */
5012 /* short numbers usually only the one final carry resolution */
5014 /* (The count is set via FASTLAZY to simplify experiments to */
5015 /* measure the value of this approach: a 35% improvement on a */
5016 /* [34x34] multiply.) */
5017 lazy
=FASTLAZY
; /* carry delay count */
5018 for (rip
=zrhi
; rip
<=rmsi
; rip
++) { /* over each item in rhs */
5019 lp
=zacc
+(rip
-zrhi
); /* where to add the lhs */
5020 for (lip
=zlhi
; lip
<=lmsi
; lip
++, lp
++) { /* over each item in lhs */
5021 *lp
+=(uLong
)(*lip
)*(*rip
); /* [this should in-line] */
5024 if (lazy
>0 && rip
!=rmsi
) continue;
5025 lazy
=FASTLAZY
; /* reset delay count */
5026 /* spin up the accumulator resolving overflows */
5027 for (lp
=zacc
; lp
<zacc
+iacc
; lp
++) {
5028 if (*lp
<FASTBASE
) continue; /* it fits */
5029 lcarry
=*lp
/FASTBASE
; /* top part [slow divide] */
5030 /* lcarry can exceed 2**32-1, so check again; this check */
5031 /* and occasional extra divide (slow) is well worth it, as */
5032 /* it allows FASTLAZY to be increased to 18 rather than 4 */
5033 /* in the FASTDIGS=9 case */
5034 if (lcarry
<FASTBASE
) carry
=(uInt
)lcarry
; /* [usual] */
5035 else { /* two-place carry [fairly rare] */
5036 uInt carry2
=(uInt
)(lcarry
/FASTBASE
); /* top top part */
5037 *(lp
+2)+=carry2
; /* add to item+2 */
5038 *lp
-=((uLong
)FASTBASE
*FASTBASE
*carry2
); /* [slow] */
5039 carry
=(uInt
)(lcarry
-((uLong
)FASTBASE
*carry2
)); /* [inline] */
5041 *(lp
+1)+=carry
; /* add to item above [inline] */
5042 *lp
-=((uLong
)FASTBASE
*carry
); /* [inline] */
5043 } /* carry resolution */
5046 /* The multiplication is complete; time to convert back into */
5047 /* units. This can be done in-place in the accumulator and in */
5048 /* 32-bit operations, because carries were resolved after the */
5049 /* final add. This needs N-1 divides and multiplies for */
5050 /* each item in the accumulator (which will become up to N */
5051 /* units, where 2<=N<=9). */
5052 for (lp
=zacc
, up
=acc
; lp
<zacc
+iacc
; lp
++) {
5053 uInt item
=(uInt
)*lp
; /* decapitate to uInt */
5054 for (p
=0; p
<FASTDIGS
-DECDPUN
; p
+=DECDPUN
, up
++) {
5055 uInt part
=item
/(DECDPUNMAX
+1);
5056 *up
=(Unit
)(item
-(part
*(DECDPUNMAX
+1)));
5059 *up
=(Unit
)item
; up
++; /* [final needs no division] */
5061 accunits
=up
-acc
; /* count of units */
5063 else { /* here to use units directly, without chunking ['old code'] */
5066 /* if accumulator will be too long for local storage, then allocate */
5067 acc
=accbuff
; /* -> assume buffer for accumulator */
5068 needbytes
=(D2U(lhs
->digits
)+D2U(rhs
->digits
))*sizeof(Unit
);
5069 if (needbytes
>(Int
)sizeof(accbuff
)) {
5070 allocacc
=(Unit
*)malloc(needbytes
);
5071 if (allocacc
==NULL
) {*status
|=DEC_Insufficient_storage
; break;}
5072 acc
=(Unit
*)allocacc
; /* use the allocated space */
5075 /* Now the main long multiplication loop */
5076 /* Unlike the equivalent in the IBM Java implementation, there */
5077 /* is no advantage in calculating from msu to lsu. So, do it */
5078 /* by the book, as it were. */
5079 /* Each iteration calculates ACC=ACC+MULTAND*MULT */
5080 accunits
=1; /* accumulator starts at '0' */
5081 *acc
=0; /* .. (lsu=0) */
5082 shift
=0; /* no multiplicand shift at first */
5083 madlength
=D2U(lhs
->digits
); /* this won't change */
5084 mermsup
=rhs
->lsu
+D2U(rhs
->digits
); /* -> msu+1 of multiplier */
5086 for (mer
=rhs
->lsu
; mer
<mermsup
; mer
++) {
5087 /* Here, *mer is the next Unit in the multiplier to use */
5088 /* If non-zero [optimization] add it... */
5089 if (*mer
!=0) accunits
=decUnitAddSub(&acc
[shift
], accunits
-shift
,
5090 lhs
->lsu
, madlength
, 0,
5093 else { /* extend acc with a 0; it will be used shortly */
5094 *(acc
+accunits
)=0; /* [this avoids length of <=0 later] */
5097 /* multiply multiplicand by 10**DECDPUN for next Unit to left */
5098 shift
++; /* add this for 'logical length' */
5101 } /* unchunked units */
5103 /* common end-path */
5105 decDumpAr('*', acc
, accunits
); /* Show exact result */
5108 /* acc now contains the exact result of the multiplication, */
5109 /* possibly with a leading zero unit; build the decNumber from */
5110 /* it, noting if any residue */
5111 res
->bits
=bits
; /* set sign */
5112 res
->digits
=decGetDigits(acc
, accunits
); /* count digits exactly */
5114 /* There can be a 31-bit wrap in calculating the exponent. */
5115 /* This can only happen if both input exponents are negative and */
5116 /* both their magnitudes are large. If there was a wrap, set a */
5117 /* safe very negative exponent, from which decFinalize() will */
5118 /* raise a hard underflow shortly. */
5119 exponent
=lhs
->exponent
+rhs
->exponent
; /* calculate exponent */
5120 if (lhs
->exponent
<0 && rhs
->exponent
<0 && exponent
>0)
5121 exponent
=-2*DECNUMMAXE
; /* force underflow */
5122 res
->exponent
=exponent
; /* OK to overwrite now */
5125 /* Set the coefficient. If any rounding, residue records */
5126 decSetCoeff(res
, set
, acc
, res
->digits
, &residue
, status
);
5127 decFinish(res
, set
, &residue
, status
); /* final cleanup */
5128 } while(0); /* end protected */
5130 free(allocacc
); /* drop any storage used */
5132 free(allocrhs
); /* .. */
5133 free(alloclhs
); /* .. */
5136 free(allocrhi
); /* .. */
5137 free(alloclhi
); /* .. */
5140 } /* decMultiplyOp */
5142 /* ------------------------------------------------------------------ */
5143 /* decExpOp -- effect exponentiation */
5145 /* This computes C = exp(A) */
5147 /* res is C, the result. C may be A */
5149 /* set is the context; note that rounding mode has no effect */
5151 /* C must have space for set->digits digits. status is updated but */
5156 /* digits, emax, and -emin in the context must be less than */
5157 /* 2*DEC_MAX_MATH (1999998), and the rhs must be within these */
5158 /* bounds or a zero. This is an internal routine, so these */
5159 /* restrictions are contractual and not enforced. */
5161 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */
5162 /* almost always be correctly rounded, but may be up to 1 ulp in */
5163 /* error in rare cases. */
5165 /* Finite results will always be full precision and Inexact, except */
5166 /* when A is a zero or -Infinity (giving 1 or 0 respectively). */
5167 /* ------------------------------------------------------------------ */
5168 /* This approach used here is similar to the algorithm described in */
5170 /* Variable Precision Exponential Function, T. E. Hull and */
5171 /* A. Abrham, ACM Transactions on Mathematical Software, Vol 12 #2, */
5172 /* pp79-91, ACM, June 1986. */
5174 /* with the main difference being that the iterations in the series */
5175 /* evaluation are terminated dynamically (which does not require the */
5176 /* extra variable-precision variables which are expensive in this */
5179 /* The error analysis in Hull & Abrham's paper applies except for the */
5180 /* round-off error accumulation during the series evaluation. This */
5181 /* code does not precalculate the number of iterations and so cannot */
5182 /* use Horner's scheme. Instead, the accumulation is done at double- */
5183 /* precision, which ensures that the additions of the terms are exact */
5184 /* and do not accumulate round-off (and any round-off errors in the */
5185 /* terms themselves move 'to the right' faster than they can */
5186 /* accumulate). This code also extends the calculation by allowing, */
5187 /* in the spirit of other decNumber operators, the input to be more */
5188 /* precise than the result (the precision used is based on the more */
5189 /* precise of the input or requested result). */
5191 /* Implementation notes: */
5193 /* 1. This is separated out as decExpOp so it can be called from */
5194 /* other Mathematical functions (notably Ln) with a wider range */
5195 /* than normal. In particular, it can handle the slightly wider */
5196 /* (double) range needed by Ln (which has to be able to calculate */
5197 /* exp(-x) where x can be the tiniest number (Ntiny). */
5199 /* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop */
5200 /* iterations by appoximately a third with additional (although */
5201 /* diminishing) returns as the range is reduced to even smaller */
5202 /* fractions. However, h (the power of 10 used to correct the */
5203 /* result at the end, see below) must be kept <=8 as otherwise */
5204 /* the final result cannot be computed. Hence the leverage is a */
5205 /* sliding value (8-h), where potentially the range is reduced */
5206 /* more for smaller values. */
5208 /* The leverage that can be applied in this way is severely */
5209 /* limited by the cost of the raise-to-the power at the end, */
5210 /* which dominates when the number of iterations is small (less */
5211 /* than ten) or when rhs is short. As an example, the adjustment */
5212 /* x**10,000,000 needs 31 multiplications, all but one full-width. */
5214 /* 3. The restrictions (especially precision) could be raised with */
5215 /* care, but the full decNumber range seems very hard within the */
5216 /* 32-bit limits. */
5218 /* 4. The working precisions for the static buffers are twice the */
5219 /* obvious size to allow for calls from decNumberPower. */
5220 /* ------------------------------------------------------------------ */
5221 decNumber
* decExpOp(decNumber
*res
, const decNumber
*rhs
,
5222 decContext
*set
, uInt
*status
) {
5223 uInt ignore
=0; /* working status */
5224 Int h
; /* adjusted exponent for 0.xxxx */
5225 Int p
; /* working precision */
5226 Int residue
; /* rounding residue */
5227 uInt needbytes
; /* for space calculations */
5228 const decNumber
*x
=rhs
; /* (may point to safe copy later) */
5229 decContext aset
, tset
, dset
; /* working contexts */
5230 Int comp
; /* work */
5232 /* the argument is often copied to normalize it, so (unusually) it */
5233 /* is treated like other buffers, using DECBUFFER, +1 in case */
5234 /* DECBUFFER is 0 */
5235 decNumber bufr
[D2N(DECBUFFER
*2+1)];
5236 decNumber
*allocrhs
=NULL
; /* non-NULL if rhs buffer allocated */
5238 /* the working precision will be no more than set->digits+8+1 */
5239 /* so for on-stack buffers DECBUFFER+9 is used, +1 in case DECBUFFER */
5240 /* is 0 (and twice that for the accumulator) */
5242 /* buffer for t, term (working precision plus) */
5243 decNumber buft
[D2N(DECBUFFER
*2+9+1)];
5244 decNumber
*allocbuft
=NULL
; /* -> allocated buft, iff allocated */
5245 decNumber
*t
=buft
; /* term */
5246 /* buffer for a, accumulator (working precision * 2), at least 9 */
5247 decNumber bufa
[D2N(DECBUFFER
*4+18+1)];
5248 decNumber
*allocbufa
=NULL
; /* -> allocated bufa, iff allocated */
5249 decNumber
*a
=bufa
; /* accumulator */
5250 /* decNumber for the divisor term; this needs at most 9 digits */
5251 /* and so can be fixed size [16 so can use standard context] */
5252 decNumber bufd
[D2N(16)];
5253 decNumber
*d
=bufd
; /* divisor */
5254 decNumber numone
; /* constant 1 */
5257 Int iterations
=0; /* for later sanity check */
5258 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
5261 do { /* protect allocated storage */
5262 if (SPECIALARG
) { /* handle infinities and NaNs */
5263 if (decNumberIsInfinite(rhs
)) { /* an infinity */
5264 if (decNumberIsNegative(rhs
)) /* -Infinity -> +0 */
5266 else decNumberCopy(res
, rhs
); /* +Infinity -> self */
5268 else decNaNs(res
, rhs
, NULL
, set
, status
); /* a NaN */
5271 if (ISZERO(rhs
)) { /* zeros -> exact 1 */
5272 decNumberZero(res
); /* make clean 1 */
5273 *res
->lsu
=1; /* .. */
5274 break;} /* [no status to set] */
5276 /* e**x when 0 < x < 0.66 is < 1+3x/2, hence can fast-path */
5277 /* positive and negative tiny cases which will result in inexact */
5278 /* 1. This also allows the later add-accumulate to always be */
5279 /* exact (because its length will never be more than twice the */
5280 /* working precision). */
5281 /* The comparator (tiny) needs just one digit, so use the */
5282 /* decNumber d for it (reused as the divisor, etc., below); its */
5283 /* exponent is such that if x is positive it will have */
5284 /* set->digits-1 zeros between the decimal point and the digit, */
5285 /* which is 4, and if x is negative one more zero there as the */
5286 /* more precise result will be of the form 0.9999999 rather than */
5287 /* 1.0000001. Hence, tiny will be 0.0000004 if digits=7 and x>0 */
5288 /* or 0.00000004 if digits=7 and x<0. If RHS not larger than */
5289 /* this then the result will be 1.000000 */
5290 decNumberZero(d
); /* clean */
5291 *d
->lsu
=4; /* set 4 .. */
5292 d
->exponent
=-set
->digits
; /* * 10**(-d) */
5293 if (decNumberIsNegative(rhs
)) d
->exponent
--; /* negative case */
5294 comp
=decCompare(d
, rhs
, 1); /* signless compare */
5296 *status
|=DEC_Insufficient_storage
;
5298 if (comp
>=0) { /* rhs < d */
5299 Int shift
=set
->digits
-1;
5300 decNumberZero(res
); /* set 1 */
5301 *res
->lsu
=1; /* .. */
5302 res
->digits
=decShiftToMost(res
->lsu
, 1, shift
);
5303 res
->exponent
=-shift
; /* make 1.0000... */
5304 *status
|=DEC_Inexact
| DEC_Rounded
; /* .. inexactly */
5307 /* set up the context to be used for calculating a, as this is */
5308 /* used on both paths below */
5309 decContextDefault(&aset
, DEC_INIT_DECIMAL64
);
5310 /* accumulator bounds are as requested (could underflow) */
5311 aset
.emax
=set
->emax
; /* usual bounds */
5312 aset
.emin
=set
->emin
; /* .. */
5313 aset
.clamp
=0; /* and no concrete format */
5315 /* calculate the adjusted (Hull & Abrham) exponent (where the */
5316 /* decimal point is just to the left of the coefficient msd) */
5317 h
=rhs
->exponent
+rhs
->digits
;
5318 /* if h>8 then 10**h cannot be calculated safely; however, when */
5319 /* h=8 then exp(|rhs|) will be at least exp(1E+7) which is at */
5320 /* least 6.59E+4342944, so (due to the restriction on Emax/Emin) */
5321 /* overflow (or underflow to 0) is guaranteed -- so this case can */
5322 /* be handled by simply forcing the appropriate excess */
5323 if (h
>8) { /* overflow/underflow */
5324 /* set up here so Power call below will over or underflow to */
5325 /* zero; set accumulator to either 2 or 0.02 */
5326 /* [stack buffer for a is always big enough for this] */
5328 *a
->lsu
=2; /* not 1 but < exp(1) */
5329 if (decNumberIsNegative(rhs
)) a
->exponent
=-2; /* make 0.02 */
5330 h
=8; /* clamp so 10**h computable */
5331 p
=9; /* set a working precision */
5334 Int maxlever
=(rhs
->digits
>8?1:0);
5335 /* [could/should increase this for precisions >40 or so, too] */
5337 /* if h is 8, cannot normalize to a lower upper limit because */
5338 /* the final result will not be computable (see notes above), */
5339 /* but leverage can be applied whenever h is less than 8. */
5340 /* Apply as much as possible, up to a MAXLEVER digits, which */
5341 /* sets the tradeoff against the cost of the later a**(10**h). */
5342 /* As h is increased, the working precision below also */
5343 /* increases to compensate for the "constant digits at the */
5344 /* front" effect. */
5345 Int lever
=MINI(8-h
, maxlever
); /* leverage attainable */
5346 Int use
=-rhs
->digits
-lever
; /* exponent to use for RHS */
5347 h
+=lever
; /* apply leverage selected */
5348 if (h
<0) { /* clamp */
5349 use
+=h
; /* [may end up subnormal] */
5352 /* Take a copy of RHS if it needs normalization (true whenever x>=1) */
5353 if (rhs
->exponent
!=use
) {
5354 decNumber
*newrhs
=bufr
; /* assume will fit on stack */
5355 needbytes
=sizeof(decNumber
)+(D2U(rhs
->digits
)-1)*sizeof(Unit
);
5356 if (needbytes
>sizeof(bufr
)) { /* need malloc space */
5357 allocrhs
=(decNumber
*)malloc(needbytes
);
5358 if (allocrhs
==NULL
) { /* hopeless -- abandon */
5359 *status
|=DEC_Insufficient_storage
;
5361 newrhs
=allocrhs
; /* use the allocated space */
5363 decNumberCopy(newrhs
, rhs
); /* copy to safe space */
5364 newrhs
->exponent
=use
; /* normalize; now <1 */
5365 x
=newrhs
; /* ready for use */
5366 /* decNumberShow(x); */
5369 /* Now use the usual power series to evaluate exp(x). The */
5370 /* series starts as 1 + x + x^2/2 ... so prime ready for the */
5371 /* third term by setting the term variable t=x, the accumulator */
5372 /* a=1, and the divisor d=2. */
5374 /* First determine the working precision. From Hull & Abrham */
5375 /* this is set->digits+h+2. However, if x is 'over-precise' we */
5376 /* need to allow for all its digits to potentially participate */
5377 /* (consider an x where all the excess digits are 9s) so in */
5378 /* this case use x->digits+h+2 */
5379 p
=MAXI(x
->digits
, set
->digits
)+h
+2; /* [h<=8] */
5381 /* a and t are variable precision, and depend on p, so space */
5382 /* must be allocated for them if necessary */
5384 /* the accumulator needs to be able to hold 2p digits so that */
5385 /* the additions on the second and subsequent iterations are */
5386 /* sufficiently exact. */
5387 needbytes
=sizeof(decNumber
)+(D2U(p
*2)-1)*sizeof(Unit
);
5388 if (needbytes
>sizeof(bufa
)) { /* need malloc space */
5389 allocbufa
=(decNumber
*)malloc(needbytes
);
5390 if (allocbufa
==NULL
) { /* hopeless -- abandon */
5391 *status
|=DEC_Insufficient_storage
;
5393 a
=allocbufa
; /* use the allocated space */
5395 /* the term needs to be able to hold p digits (which is */
5396 /* guaranteed to be larger than x->digits, so the initial copy */
5397 /* is safe); it may also be used for the raise-to-power */
5398 /* calculation below, which needs an extra two digits */
5399 needbytes
=sizeof(decNumber
)+(D2U(p
+2)-1)*sizeof(Unit
);
5400 if (needbytes
>sizeof(buft
)) { /* need malloc space */
5401 allocbuft
=(decNumber
*)malloc(needbytes
);
5402 if (allocbuft
==NULL
) { /* hopeless -- abandon */
5403 *status
|=DEC_Insufficient_storage
;
5405 t
=allocbuft
; /* use the allocated space */
5408 decNumberCopy(t
, x
); /* term=x */
5409 decNumberZero(a
); *a
->lsu
=1; /* accumulator=1 */
5410 decNumberZero(d
); *d
->lsu
=2; /* divisor=2 */
5411 decNumberZero(&numone
); *numone
.lsu
=1; /* constant 1 for increment */
5413 /* set up the contexts for calculating a, t, and d */
5414 decContextDefault(&tset
, DEC_INIT_DECIMAL64
);
5416 /* accumulator bounds are set above, set precision now */
5417 aset
.digits
=p
*2; /* double */
5418 /* term bounds avoid any underflow or overflow */
5420 tset
.emin
=DEC_MIN_EMIN
; /* [emax is plenty] */
5421 /* [dset.digits=16, etc., are sufficient] */
5423 /* finally ready to roll */
5428 /* only the status from the accumulation is interesting */
5429 /* [but it should remain unchanged after first add] */
5430 decAddOp(a
, a
, t
, &aset
, 0, status
); /* a=a+t */
5431 decMultiplyOp(t
, t
, x
, &tset
, &ignore
); /* t=t*x */
5432 decDivideOp(t
, t
, d
, &tset
, DIVIDE
, &ignore
); /* t=t/d */
5433 /* the iteration ends when the term cannot affect the result, */
5434 /* if rounded to p digits, which is when its value is smaller */
5435 /* than the accumulator by p+1 digits. There must also be */
5436 /* full precision in a. */
5437 if (((a
->digits
+a
->exponent
)>=(t
->digits
+t
->exponent
+p
+1))
5438 && (a
->digits
>=p
)) break;
5439 decAddOp(d
, d
, &numone
, &dset
, 0, &ignore
); /* d=d+1 */
5443 /* just a sanity check; comment out test to show always */
5445 printf("Exp iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5446 (LI
)iterations
, (LI
)*status
, (LI
)p
, (LI
)x
->digits
);
5450 /* apply postconditioning: a=a**(10**h) -- this is calculated */
5451 /* at a slightly higher precision than Hull & Abrham suggest */
5453 Int seenbit
=0; /* set once a 1-bit is seen */
5454 Int i
; /* counter */
5455 Int n
=powers
[h
]; /* always positive */
5456 aset
.digits
=p
+2; /* sufficient precision */
5457 /* avoid the overhead and many extra digits of decNumberPower */
5458 /* as all that is needed is the short 'multipliers' loop; here */
5459 /* accumulate the answer into t */
5460 decNumberZero(t
); *t
->lsu
=1; /* acc=1 */
5461 for (i
=1;;i
++){ /* for each bit [top bit ignored] */
5462 /* abandon if have had overflow or terminal underflow */
5463 if (*status
& (DEC_Overflow
|DEC_Underflow
)) { /* interesting? */
5464 if (*status
&DEC_Overflow
|| ISZERO(t
)) break;}
5465 n
=n
<<1; /* move next bit to testable position */
5466 if (n
<0) { /* top bit is set */
5467 seenbit
=1; /* OK, have a significant bit */
5468 decMultiplyOp(t
, t
, a
, &aset
, status
); /* acc=acc*x */
5470 if (i
==31) break; /* that was the last bit */
5471 if (!seenbit
) continue; /* no need to square 1 */
5472 decMultiplyOp(t
, t
, t
, &aset
, status
); /* acc=acc*acc [square] */
5473 } /*i*/ /* 32 bits */
5474 /* decNumberShow(t); */
5475 a
=t
; /* and carry on using t instead of a */
5478 /* Copy and round the result to res */
5479 residue
=1; /* indicate dirt to right .. */
5480 if (ISZERO(a
)) residue
=0; /* .. unless underflowed to 0 */
5481 aset
.digits
=set
->digits
; /* [use default rounding] */
5482 decCopyFit(res
, a
, &aset
, &residue
, status
); /* copy & shorten */
5483 decFinish(res
, set
, &residue
, status
); /* cleanup/set flags */
5484 } while(0); /* end protected */
5486 free(allocrhs
); /* drop any storage used */
5487 free(allocbufa
); /* .. */
5488 free(allocbuft
); /* .. */
5489 /* [status is handled by caller] */
5493 /* ------------------------------------------------------------------ */
5494 /* Initial-estimate natural logarithm table */
5496 /* LNnn -- 90-entry 16-bit table for values from .10 through .99. */
5497 /* The result is a 4-digit encode of the coefficient (c=the */
5498 /* top 14 bits encoding 0-9999) and a 2-digit encode of the */
5499 /* exponent (e=the bottom 2 bits encoding 0-3) */
5501 /* The resulting value is given by: */
5503 /* v = -c * 10**(-e-3) */
5505 /* where e and c are extracted from entry k = LNnn[x-10] */
5506 /* where x is truncated (NB) into the range 10 through 99, */
5507 /* and then c = k>>2 and e = k&3. */
5508 /* ------------------------------------------------------------------ */
5509 const uShort LNnn
[90]={9016, 8652, 8316, 8008, 7724, 7456, 7208,
5510 6972, 6748, 6540, 6340, 6148, 5968, 5792, 5628, 5464, 5312,
5511 5164, 5020, 4884, 4748, 4620, 4496, 4376, 4256, 4144, 4032,
5512 39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629,
5513 29777, 28945, 28129, 27329, 26545, 25777, 25021, 24281, 23553, 22837,
5514 22137, 21445, 20769, 20101, 19445, 18801, 18165, 17541, 16925, 16321,
5515 15721, 15133, 14553, 13985, 13421, 12865, 12317, 11777, 11241, 10717,
5516 10197, 9685, 9177, 8677, 8185, 7697, 7213, 6737, 6269, 5801,
5517 5341, 4889, 4437, 39930, 35534, 31186, 26886, 22630, 18418, 14254,
5518 10130, 6046, 20055};
5520 /* ------------------------------------------------------------------ */
5521 /* decLnOp -- effect natural logarithm */
5523 /* This computes C = ln(A) */
5525 /* res is C, the result. C may be A */
5527 /* set is the context; note that rounding mode has no effect */
5529 /* C must have space for set->digits digits. */
5531 /* Notable cases: */
5532 /* A<0 -> Invalid */
5533 /* A=0 -> -Infinity (Exact) */
5534 /* A=+Infinity -> +Infinity (Exact) */
5535 /* A=1 exactly -> 0 (Exact) */
5537 /* Restrictions (as for Exp): */
5539 /* digits, emax, and -emin in the context must be less than */
5540 /* DEC_MAX_MATH+11 (1000010), and the rhs must be within these */
5541 /* bounds or a zero. This is an internal routine, so these */
5542 /* restrictions are contractual and not enforced. */
5544 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */
5545 /* almost always be correctly rounded, but may be up to 1 ulp in */
5546 /* error in rare cases. */
5547 /* ------------------------------------------------------------------ */
5548 /* The result is calculated using Newton's method, with each */
5549 /* iteration calculating a' = a + x * exp(-a) - 1. See, for example, */
5550 /* Epperson 1989. */
5552 /* The iteration ends when the adjustment x*exp(-a)-1 is tiny enough. */
5553 /* This has to be calculated at the sum of the precision of x and the */
5554 /* working precision. */
5556 /* Implementation notes: */
5558 /* 1. This is separated out as decLnOp so it can be called from */
5559 /* other Mathematical functions (e.g., Log 10) with a wider range */
5560 /* than normal. In particular, it can handle the slightly wider */
5561 /* (+9+2) range needed by a power function. */
5563 /* 2. The speed of this function is about 10x slower than exp, as */
5564 /* it typically needs 4-6 iterations for short numbers, and the */
5565 /* extra precision needed adds a squaring effect, twice. */
5567 /* 3. Fastpaths are included for ln(10) and ln(2), up to length 40, */
5568 /* as these are common requests. ln(10) is used by log10(x). */
5570 /* 4. An iteration might be saved by widening the LNnn table, and */
5571 /* would certainly save at least one if it were made ten times */
5572 /* bigger, too (for truncated fractions 0.100 through 0.999). */
5573 /* However, for most practical evaluations, at least four or five */
5574 /* iterations will be neede -- so this would only speed up by */
5575 /* 20-25% and that probably does not justify increasing the table */
5578 /* 5. The static buffers are larger than might be expected to allow */
5579 /* for calls from decNumberPower. */
5580 /* ------------------------------------------------------------------ */
5581 decNumber
* decLnOp(decNumber
*res
, const decNumber
*rhs
,
5582 decContext
*set
, uInt
*status
) {
5583 uInt ignore
=0; /* working status accumulator */
5584 uInt needbytes
; /* for space calculations */
5585 Int residue
; /* rounding residue */
5586 Int r
; /* rhs=f*10**r [see below] */
5587 Int p
; /* working precision */
5588 Int pp
; /* precision for iteration */
5591 /* buffers for a (accumulator, typically precision+2) and b */
5592 /* (adjustment calculator, same size) */
5593 decNumber bufa
[D2N(DECBUFFER
+12)];
5594 decNumber
*allocbufa
=NULL
; /* -> allocated bufa, iff allocated */
5595 decNumber
*a
=bufa
; /* accumulator/work */
5596 decNumber bufb
[D2N(DECBUFFER
*2+2)];
5597 decNumber
*allocbufb
=NULL
; /* -> allocated bufa, iff allocated */
5598 decNumber
*b
=bufb
; /* adjustment/work */
5600 decNumber numone
; /* constant 1 */
5601 decNumber cmp
; /* work */
5602 decContext aset
, bset
; /* working contexts */
5605 Int iterations
=0; /* for later sanity check */
5606 if (decCheckOperands(res
, DECUNUSED
, rhs
, set
)) return res
;
5609 do { /* protect allocated storage */
5610 if (SPECIALARG
) { /* handle infinities and NaNs */
5611 if (decNumberIsInfinite(rhs
)) { /* an infinity */
5612 if (decNumberIsNegative(rhs
)) /* -Infinity -> error */
5613 *status
|=DEC_Invalid_operation
;
5614 else decNumberCopy(res
, rhs
); /* +Infinity -> self */
5616 else decNaNs(res
, rhs
, NULL
, set
, status
); /* a NaN */
5619 if (ISZERO(rhs
)) { /* +/- zeros -> -Infinity */
5620 decNumberZero(res
); /* make clean */
5621 res
->bits
=DECINF
|DECNEG
; /* set - infinity */
5622 break;} /* [no status to set] */
5624 /* Non-zero negatives are bad... */
5625 if (decNumberIsNegative(rhs
)) { /* -x -> error */
5626 *status
|=DEC_Invalid_operation
;
5629 /* Here, rhs is positive, finite, and in range */
5631 /* lookaside fastpath code for ln(2) and ln(10) at common lengths */
5632 if (rhs
->exponent
==0 && set
->digits
<=40) {
5634 if (rhs
->lsu
[0]==0 && rhs
->lsu
[1]==1 && rhs
->digits
==2) { /* ln(10) */
5636 if (rhs
->lsu
[0]==10 && rhs
->digits
==2) { /* ln(10) */
5638 aset
=*set
; aset
.round
=DEC_ROUND_HALF_EVEN
;
5639 #define LN10 "2.302585092994045684017991454684364207601"
5640 decNumberFromString(res
, LN10
, &aset
);
5641 *status
|=(DEC_Inexact
| DEC_Rounded
); /* is inexact */
5643 if (rhs
->lsu
[0]==2 && rhs
->digits
==1) { /* ln(2) */
5644 aset
=*set
; aset
.round
=DEC_ROUND_HALF_EVEN
;
5645 #define LN2 "0.6931471805599453094172321214581765680755"
5646 decNumberFromString(res
, LN2
, &aset
);
5647 *status
|=(DEC_Inexact
| DEC_Rounded
);
5649 } /* integer and short */
5651 /* Determine the working precision. This is normally the */
5652 /* requested precision + 2, with a minimum of 9. However, if */
5653 /* the rhs is 'over-precise' then allow for all its digits to */
5654 /* potentially participate (consider an rhs where all the excess */
5655 /* digits are 9s) so in this case use rhs->digits+2. */
5656 p
=MAXI(rhs
->digits
, MAXI(set
->digits
, 7))+2;
5658 /* Allocate space for the accumulator and the high-precision */
5659 /* adjustment calculator, if necessary. The accumulator must */
5660 /* be able to hold p digits, and the adjustment up to */
5661 /* rhs->digits+p digits. They are also made big enough for 16 */
5662 /* digits so that they can be used for calculating the initial */
5664 needbytes
=sizeof(decNumber
)+(D2U(MAXI(p
,16))-1)*sizeof(Unit
);
5665 if (needbytes
>sizeof(bufa
)) { /* need malloc space */
5666 allocbufa
=(decNumber
*)malloc(needbytes
);
5667 if (allocbufa
==NULL
) { /* hopeless -- abandon */
5668 *status
|=DEC_Insufficient_storage
;
5670 a
=allocbufa
; /* use the allocated space */
5673 needbytes
=sizeof(decNumber
)+(D2U(MAXI(pp
,16))-1)*sizeof(Unit
);
5674 if (needbytes
>sizeof(bufb
)) { /* need malloc space */
5675 allocbufb
=(decNumber
*)malloc(needbytes
);
5676 if (allocbufb
==NULL
) { /* hopeless -- abandon */
5677 *status
|=DEC_Insufficient_storage
;
5679 b
=allocbufb
; /* use the allocated space */
5682 /* Prepare an initial estimate in acc. Calculate this by */
5683 /* considering the coefficient of x to be a normalized fraction, */
5684 /* f, with the decimal point at far left and multiplied by */
5685 /* 10**r. Then, rhs=f*10**r and 0.1<=f<1, and */
5686 /* ln(x) = ln(f) + ln(10)*r */
5687 /* Get the initial estimate for ln(f) from a small lookup */
5688 /* table (see above) indexed by the first two digits of f, */
5691 decContextDefault(&aset
, DEC_INIT_DECIMAL64
); /* 16-digit extended */
5692 r
=rhs
->exponent
+rhs
->digits
; /* 'normalised' exponent */
5693 decNumberFromInt32(a
, r
); /* a=r */
5694 decNumberFromInt32(b
, 2302585); /* b=ln(10) (2.302585) */
5695 b
->exponent
=-6; /* .. */
5696 decMultiplyOp(a
, a
, b
, &aset
, &ignore
); /* a=a*b */
5697 /* now get top two digits of rhs into b by simple truncate and */
5698 /* force to integer */
5699 residue
=0; /* (no residue) */
5700 aset
.digits
=2; aset
.round
=DEC_ROUND_DOWN
;
5701 decCopyFit(b
, rhs
, &aset
, &residue
, &ignore
); /* copy & shorten */
5702 b
->exponent
=0; /* make integer */
5703 t
=decGetInt(b
); /* [cannot fail] */
5704 if (t
<10) t
=X10(t
); /* adjust single-digit b */
5705 t
=LNnn
[t
-10]; /* look up ln(b) */
5706 decNumberFromInt32(b
, t
>>2); /* b=ln(b) coefficient */
5707 b
->exponent
=-(t
&3)-3; /* set exponent */
5708 b
->bits
=DECNEG
; /* ln(0.10)->ln(0.99) always -ve */
5709 aset
.digits
=16; aset
.round
=DEC_ROUND_HALF_EVEN
; /* restore */
5710 decAddOp(a
, a
, b
, &aset
, 0, &ignore
); /* acc=a+b */
5711 /* the initial estimate is now in a, with up to 4 digits correct. */
5712 /* When rhs is at or near Nmax the estimate will be low, so we */
5713 /* will approach it from below, avoiding overflow when calling exp. */
5715 decNumberZero(&numone
); *numone
.lsu
=1; /* constant 1 for adjustment */
5717 /* accumulator bounds are as requested (could underflow, but */
5718 /* cannot overflow) */
5719 aset
.emax
=set
->emax
;
5720 aset
.emin
=set
->emin
;
5721 aset
.clamp
=0; /* no concrete format */
5722 /* set up a context to be used for the multiply and subtract */
5724 bset
.emax
=DEC_MAX_MATH
*2; /* use double bounds for the */
5725 bset
.emin
=-DEC_MAX_MATH
*2; /* adjustment calculation */
5726 /* [see decExpOp call below] */
5727 /* for each iteration double the number of digits to calculate, */
5728 /* up to a maximum of p */
5729 pp
=9; /* initial precision */
5730 /* [initially 9 as then the sequence starts 7+2, 16+2, and */
5731 /* 34+2, which is ideal for standard-sized numbers] */
5732 aset
.digits
=pp
; /* working context */
5733 bset
.digits
=pp
+rhs
->digits
; /* wider context */
5734 for (;;) { /* iterate */
5737 if (iterations
>24) break; /* consider 9 * 2**24 */
5739 /* calculate the adjustment (exp(-a)*x-1) into b. This is a */
5740 /* catastrophic subtraction but it really is the difference */
5741 /* from 1 that is of interest. */
5742 /* Use the internal entry point to Exp as it allows the double */
5743 /* range for calculating exp(-a) when a is the tiniest subnormal. */
5744 a
->bits
^=DECNEG
; /* make -a */
5745 decExpOp(b
, a
, &bset
, &ignore
); /* b=exp(-a) */
5746 a
->bits
^=DECNEG
; /* restore sign of a */
5747 /* now multiply by rhs and subtract 1, at the wider precision */
5748 decMultiplyOp(b
, b
, rhs
, &bset
, &ignore
); /* b=b*rhs */
5749 decAddOp(b
, b
, &numone
, &bset
, DECNEG
, &ignore
); /* b=b-1 */
5751 /* the iteration ends when the adjustment cannot affect the */
5752 /* result by >=0.5 ulp (at the requested digits), which */
5753 /* is when its value is smaller than the accumulator by */
5754 /* set->digits+1 digits (or it is zero) -- this is a looser */
5755 /* requirement than for Exp because all that happens to the */
5756 /* accumulator after this is the final rounding (but note that */
5757 /* there must also be full precision in a, or a=0). */
5759 if (decNumberIsZero(b
) ||
5760 (a
->digits
+a
->exponent
)>=(b
->digits
+b
->exponent
+set
->digits
+1)) {
5761 if (a
->digits
==p
) break;
5762 if (decNumberIsZero(a
)) {
5763 decCompareOp(&cmp
, rhs
, &numone
, &aset
, COMPARE
, &ignore
); /* rhs=1 ? */
5764 if (cmp
.lsu
[0]==0) a
->exponent
=0; /* yes, exact 0 */
5765 else *status
|=(DEC_Inexact
| DEC_Rounded
); /* no, inexact */
5768 /* force padding if adjustment has gone to 0 before full length */
5769 if (decNumberIsZero(b
)) b
->exponent
=a
->exponent
-p
;
5772 /* not done yet ... */
5773 decAddOp(a
, a
, b
, &aset
, 0, &ignore
); /* a=a+b for next estimate */
5774 if (pp
==p
) continue; /* precision is at maximum */
5775 /* lengthen the next calculation */
5776 pp
=pp
*2; /* double precision */
5777 if (pp
>p
) pp
=p
; /* clamp to maximum */
5778 aset
.digits
=pp
; /* working context */
5779 bset
.digits
=pp
+rhs
->digits
; /* wider context */
5780 } /* Newton's iteration */
5783 /* just a sanity check; remove the test to show always */
5785 printf("Ln iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5786 (LI
)iterations
, (LI
)*status
, (LI
)p
, (LI
)rhs
->digits
);
5789 /* Copy and round the result to res */
5790 residue
=1; /* indicate dirt to right */
5791 if (ISZERO(a
)) residue
=0; /* .. unless underflowed to 0 */
5792 aset
.digits
=set
->digits
; /* [use default rounding] */
5793 decCopyFit(res
, a
, &aset
, &residue
, status
); /* copy & shorten */
5794 decFinish(res
, set
, &residue
, status
); /* cleanup/set flags */
5795 } while(0); /* end protected */
5797 free(allocbufa
); /* drop any storage used */
5798 free(allocbufb
); /* .. */
5799 /* [status is handled by caller] */
5803 /* ------------------------------------------------------------------ */
5804 /* decQuantizeOp -- force exponent to requested value */
5806 /* This computes C = op(A, B), where op adjusts the coefficient */
5807 /* of C (by rounding or shifting) such that the exponent (-scale) */
5808 /* of C has the value B or matches the exponent of B. */
5809 /* The numerical value of C will equal A, except for the effects of */
5810 /* any rounding that occurred. */
5812 /* res is C, the result. C may be A or B */
5813 /* lhs is A, the number to adjust */
5814 /* rhs is B, the requested exponent */
5815 /* set is the context */
5816 /* quant is 1 for quantize or 0 for rescale */
5817 /* status is the status accumulator (this can be called without */
5818 /* risk of control loss) */
5820 /* C must have space for set->digits digits. */
5822 /* Unless there is an error or the result is infinite, the exponent */
5823 /* after the operation is guaranteed to be that requested. */
5824 /* ------------------------------------------------------------------ */
5825 static decNumber
* decQuantizeOp(decNumber
*res
, const decNumber
*lhs
,
5826 const decNumber
*rhs
, decContext
*set
,
5827 Flag quant
, uInt
*status
) {
5829 decNumber
*alloclhs
=NULL
; /* non-NULL if rounded lhs allocated */
5830 decNumber
*allocrhs
=NULL
; /* .., rhs */
5832 const decNumber
*inrhs
=rhs
; /* save original rhs */
5833 Int reqdigits
=set
->digits
; /* requested DIGITS */
5834 Int reqexp
; /* requested exponent [-scale] */
5835 Int residue
=0; /* rounding residue */
5836 Int etiny
=set
->emin
-(reqdigits
-1);
5839 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
5842 do { /* protect allocated storage */
5844 if (!set
->extended
) {
5845 /* reduce operands and set lostDigits status, as needed */
5846 if (lhs
->digits
>reqdigits
) {
5847 alloclhs
=decRoundOperand(lhs
, set
, status
);
5848 if (alloclhs
==NULL
) break;
5851 if (rhs
->digits
>reqdigits
) { /* [this only checks lostDigits] */
5852 allocrhs
=decRoundOperand(rhs
, set
, status
);
5853 if (allocrhs
==NULL
) break;
5858 /* [following code does not require input rounding] */
5860 /* Handle special values */
5862 /* NaNs get usual processing */
5863 if (SPECIALARGS
& (DECSNAN
| DECNAN
))
5864 decNaNs(res
, lhs
, rhs
, set
, status
);
5865 /* one infinity but not both is bad */
5866 else if ((lhs
->bits
^ rhs
->bits
) & DECINF
)
5867 *status
|=DEC_Invalid_operation
;
5868 /* both infinity: return lhs */
5869 else decNumberCopy(res
, lhs
); /* [nop if in place] */
5873 /* set requested exponent */
5874 if (quant
) reqexp
=inrhs
->exponent
; /* quantize -- match exponents */
5875 else { /* rescale -- use value of rhs */
5876 /* Original rhs must be an integer that fits and is in range, */
5877 /* which could be from -1999999997 to +999999999, thanks to */
5879 reqexp
=decGetInt(inrhs
); /* [cannot fail] */
5883 if (!set
->extended
) etiny
=set
->emin
; /* no subnormals */
5886 if (reqexp
==BADINT
/* bad (rescale only) or .. */
5887 || reqexp
==BIGODD
|| reqexp
==BIGEVEN
/* very big (ditto) or .. */
5888 || (reqexp
<etiny
) /* < lowest */
5889 || (reqexp
>set
->emax
)) { /* > emax */
5890 *status
|=DEC_Invalid_operation
;
5893 /* the RHS has been processed, so it can be overwritten now if necessary */
5894 if (ISZERO(lhs
)) { /* zero coefficient unchanged */
5895 decNumberCopy(res
, lhs
); /* [nop if in place] */
5896 res
->exponent
=reqexp
; /* .. just set exponent */
5898 if (!set
->extended
) res
->bits
=0; /* subset specification; no -0 */
5901 else { /* non-zero lhs */
5902 Int adjust
=reqexp
-lhs
->exponent
; /* digit adjustment needed */
5903 /* if adjusted coefficient will definitely not fit, give up now */
5904 if ((lhs
->digits
-adjust
)>reqdigits
) {
5905 *status
|=DEC_Invalid_operation
;
5909 if (adjust
>0) { /* increasing exponent */
5910 /* this will decrease the length of the coefficient by adjust */
5911 /* digits, and must round as it does so */
5912 decContext workset
; /* work */
5913 workset
=*set
; /* clone rounding, etc. */
5914 workset
.digits
=lhs
->digits
-adjust
; /* set requested length */
5915 /* [note that the latter can be <1, here] */
5916 decCopyFit(res
, lhs
, &workset
, &residue
, status
); /* fit to result */
5917 decApplyRound(res
, &workset
, residue
, status
); /* .. and round */
5918 residue
=0; /* [used] */
5919 /* If just rounded a 999s case, exponent will be off by one; */
5920 /* adjust back (after checking space), if so. */
5921 if (res
->exponent
>reqexp
) {
5922 /* re-check needed, e.g., for quantize(0.9999, 0.001) under */
5923 /* set->digits==3 */
5924 if (res
->digits
==reqdigits
) { /* cannot shift by 1 */
5925 *status
&=~(DEC_Inexact
| DEC_Rounded
); /* [clean these] */
5926 *status
|=DEC_Invalid_operation
;
5929 res
->digits
=decShiftToMost(res
->lsu
, res
->digits
, 1); /* shift */
5930 res
->exponent
--; /* (re)adjust the exponent. */
5933 if (ISZERO(res
) && !set
->extended
) res
->bits
=0; /* subset; no -0 */
5936 else /* adjust<=0 */ { /* decreasing or = exponent */
5937 /* this will increase the length of the coefficient by -adjust */
5938 /* digits, by adding zero or more trailing zeros; this is */
5939 /* already checked for fit, above */
5940 decNumberCopy(res
, lhs
); /* [it will fit] */
5941 /* if padding needed (adjust<0), add it now... */
5943 res
->digits
=decShiftToMost(res
->lsu
, res
->digits
, -adjust
);
5944 res
->exponent
+=adjust
; /* adjust the exponent */
5949 /* Check for overflow [do not use Finalize in this case, as an */
5950 /* overflow here is a "don't fit" situation] */
5951 if (res
->exponent
>set
->emax
-res
->digits
+1) { /* too big */
5952 *status
|=DEC_Invalid_operation
;
5956 decFinalize(res
, set
, &residue
, status
); /* set subnormal flags */
5957 *status
&=~DEC_Underflow
; /* suppress Underflow [as per 754] */
5959 } while(0); /* end protected */
5962 free(allocrhs
); /* drop any storage used */
5963 free(alloclhs
); /* .. */
5966 } /* decQuantizeOp */
5968 /* ------------------------------------------------------------------ */
5969 /* decCompareOp -- compare, min, or max two Numbers */
5971 /* This computes C = A ? B and carries out one of four operations: */
5972 /* COMPARE -- returns the signum (as a number) giving the */
5973 /* result of a comparison unless one or both */
5974 /* operands is a NaN (in which case a NaN results) */
5975 /* COMPSIG -- as COMPARE except that a quiet NaN raises */
5976 /* Invalid operation. */
5977 /* COMPMAX -- returns the larger of the operands, using the */
5978 /* 754 maxnum operation */
5979 /* COMPMAXMAG -- ditto, comparing absolute values */
5980 /* COMPMIN -- the 754 minnum operation */
5981 /* COMPMINMAG -- ditto, comparing absolute values */
5982 /* COMTOTAL -- returns the signum (as a number) giving the */
5983 /* result of a comparison using 754 total ordering */
5985 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
5988 /* set is the context */
5989 /* op is the operation flag */
5990 /* status is the usual accumulator */
5992 /* C must have space for one digit for COMPARE or set->digits for */
5993 /* COMPMAX, COMPMIN, COMPMAXMAG, or COMPMINMAG. */
5994 /* ------------------------------------------------------------------ */
5995 /* The emphasis here is on speed for common cases, and avoiding */
5996 /* coefficient comparison if possible. */
5997 /* ------------------------------------------------------------------ */
5998 decNumber
* decCompareOp(decNumber
*res
, const decNumber
*lhs
,
5999 const decNumber
*rhs
, decContext
*set
,
6000 Flag op
, uInt
*status
) {
6002 decNumber
*alloclhs
=NULL
; /* non-NULL if rounded lhs allocated */
6003 decNumber
*allocrhs
=NULL
; /* .., rhs */
6005 Int result
=0; /* default result value */
6006 uByte merged
; /* work */
6009 if (decCheckOperands(res
, lhs
, rhs
, set
)) return res
;
6012 do { /* protect allocated storage */
6014 if (!set
->extended
) {
6015 /* reduce operands and set lostDigits status, as needed */
6016 if (lhs
->digits
>set
->digits
) {
6017 alloclhs
=decRoundOperand(lhs
, set
, status
);
6018 if (alloclhs
==NULL
) {result
=BADINT
; break;}
6021 if (rhs
->digits
>set
->digits
) {
6022 allocrhs
=decRoundOperand(rhs
, set
, status
);
6023 if (allocrhs
==NULL
) {result
=BADINT
; break;}
6028 /* [following code does not require input rounding] */
6030 /* If total ordering then handle differing signs 'up front' */
6031 if (op
==COMPTOTAL
) { /* total ordering */
6032 if (decNumberIsNegative(lhs
) & !decNumberIsNegative(rhs
)) {
6036 if (!decNumberIsNegative(lhs
) & decNumberIsNegative(rhs
)) {
6042 /* handle NaNs specially; let infinities drop through */
6043 /* This assumes sNaN (even just one) leads to NaN. */
6044 merged
=(lhs
->bits
| rhs
->bits
) & (DECSNAN
| DECNAN
);
6045 if (merged
) { /* a NaN bit set */
6046 if (op
==COMPARE
); /* result will be NaN */
6047 else if (op
==COMPSIG
) /* treat qNaN as sNaN */
6048 *status
|=DEC_Invalid_operation
| DEC_sNaN
;
6049 else if (op
==COMPTOTAL
) { /* total ordering, always finite */
6050 /* signs are known to be the same; compute the ordering here */
6051 /* as if the signs are both positive, then invert for negatives */
6052 if (!decNumberIsNaN(lhs
)) result
=-1;
6053 else if (!decNumberIsNaN(rhs
)) result
=+1;
6054 /* here if both NaNs */
6055 else if (decNumberIsSNaN(lhs
) && decNumberIsQNaN(rhs
)) result
=-1;
6056 else if (decNumberIsQNaN(lhs
) && decNumberIsSNaN(rhs
)) result
=+1;
6057 else { /* both NaN or both sNaN */
6058 /* now it just depends on the payload */
6059 result
=decUnitCompare(lhs
->lsu
, D2U(lhs
->digits
),
6060 rhs
->lsu
, D2U(rhs
->digits
), 0);
6061 /* [Error not possible, as these are 'aligned'] */
6062 } /* both same NaNs */
6063 if (decNumberIsNegative(lhs
)) result
=-result
;
6067 else if (merged
& DECSNAN
); /* sNaN -> qNaN */
6068 else { /* here if MIN or MAX and one or two quiet NaNs */
6069 /* min or max -- 754 rules ignore single NaN */
6070 if (!decNumberIsNaN(lhs
) || !decNumberIsNaN(rhs
)) {
6071 /* just one NaN; force choice to be the non-NaN operand */
6073 if (lhs
->bits
& DECNAN
) result
=-1; /* pick rhs */
6074 else result
=+1; /* pick lhs */
6078 op
=COMPNAN
; /* use special path */
6079 decNaNs(res
, lhs
, rhs
, set
, status
); /* propagate NaN */
6083 if (op
==COMPMAXMAG
|| op
==COMPMINMAG
) result
=decCompare(lhs
, rhs
, 1);
6084 else result
=decCompare(lhs
, rhs
, 0); /* sign matters */
6085 } while(0); /* end protected */
6087 if (result
==BADINT
) *status
|=DEC_Insufficient_storage
; /* rare */
6089 if (op
==COMPARE
|| op
==COMPSIG
||op
==COMPTOTAL
) { /* returning signum */
6090 if (op
==COMPTOTAL
&& result
==0) {
6091 /* operands are numerically equal or same NaN (and same sign, */
6092 /* tested first); if identical, leave result 0 */
6093 if (lhs
->exponent
!=rhs
->exponent
) {
6094 if (lhs
->exponent
<rhs
->exponent
) result
=-1;
6096 if (decNumberIsNegative(lhs
)) result
=-result
;
6098 } /* total-order by exponent */
6099 decNumberZero(res
); /* [always a valid result] */
6100 if (result
!=0) { /* must be -1 or +1 */
6102 if (result
<0) res
->bits
=DECNEG
;
6105 else if (op
==COMPNAN
); /* special, drop through */
6106 else { /* MAX or MIN, non-NaN result */
6107 Int residue
=0; /* rounding accumulator */
6108 /* choose the operand for the result */
6109 const decNumber
*choice
;
6110 if (result
==0) { /* operands are numerically equal */
6111 /* choose according to sign then exponent (see 754) */
6112 uByte slhs
=(lhs
->bits
& DECNEG
);
6113 uByte srhs
=(rhs
->bits
& DECNEG
);
6115 if (!set
->extended
) { /* subset: force left-hand */
6121 if (slhs
!=srhs
) { /* signs differ */
6122 if (slhs
) result
=-1; /* rhs is max */
6123 else result
=+1; /* lhs is max */
6125 else if (slhs
&& srhs
) { /* both negative */
6126 if (lhs
->exponent
<rhs
->exponent
) result
=+1;
6128 /* [if equal, use lhs, technically identical] */
6130 else { /* both positive */
6131 if (lhs
->exponent
>rhs
->exponent
) result
=+1;
6135 } /* numerically equal */
6136 /* here result will be non-0; reverse if looking for MIN */
6137 if (op
==COMPMIN
|| op
==COMPMINMAG
) result
=-result
;
6138 choice
=(result
>0 ? lhs
: rhs
); /* choose */
6139 /* copy chosen to result, rounding if need be */
6140 decCopyFit(res
, choice
, set
, &residue
, status
);
6141 decFinish(res
, set
, &residue
, status
);
6145 free(allocrhs
); /* free any storage used */
6146 free(alloclhs
); /* .. */
6149 } /* decCompareOp */
6151 /* ------------------------------------------------------------------ */
6152 /* decCompare -- compare two decNumbers by numerical value */
6154 /* This routine compares A ? B without altering them. */
6156 /* Arg1 is A, a decNumber which is not a NaN */
6157 /* Arg2 is B, a decNumber which is not a NaN */
6158 /* Arg3 is 1 for a sign-independent compare, 0 otherwise */
6160 /* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */
6161 /* (the only possible failure is an allocation error) */
6162 /* ------------------------------------------------------------------ */
6163 static Int
decCompare(const decNumber
*lhs
, const decNumber
*rhs
,
6165 Int result
; /* result value */
6166 Int sigr
; /* rhs signum */
6167 Int compare
; /* work */
6169 result
=1; /* assume signum(lhs) */
6170 if (ISZERO(lhs
)) result
=0;
6172 if (ISZERO(rhs
)) return result
; /* LHS wins or both 0 */
6173 /* RHS is non-zero */
6174 if (result
==0) return -1; /* LHS is 0; RHS wins */
6175 /* [here, both non-zero, result=1] */
6177 else { /* signs matter */
6178 if (result
&& decNumberIsNegative(lhs
)) result
=-1;
6179 sigr
=1; /* compute signum(rhs) */
6180 if (ISZERO(rhs
)) sigr
=0;
6181 else if (decNumberIsNegative(rhs
)) sigr
=-1;
6182 if (result
> sigr
) return +1; /* L > R, return 1 */
6183 if (result
< sigr
) return -1; /* L < R, return -1 */
6184 if (result
==0) return 0; /* both 0 */
6187 /* signums are the same; both are non-zero */
6188 if ((lhs
->bits
| rhs
->bits
) & DECINF
) { /* one or more infinities */
6189 if (decNumberIsInfinite(rhs
)) {
6190 if (decNumberIsInfinite(lhs
)) result
=0;/* both infinite */
6191 else result
=-result
; /* only rhs infinite */
6195 /* must compare the coefficients, allowing for exponents */
6196 if (lhs
->exponent
>rhs
->exponent
) { /* LHS exponent larger */
6197 /* swap sides, and sign */
6198 const decNumber
*temp
=lhs
;
6203 compare
=decUnitCompare(lhs
->lsu
, D2U(lhs
->digits
),
6204 rhs
->lsu
, D2U(rhs
->digits
),
6205 rhs
->exponent
-lhs
->exponent
);
6206 if (compare
!=BADINT
) compare
*=result
; /* comparison succeeded */
6210 /* ------------------------------------------------------------------ */
6211 /* decUnitCompare -- compare two >=0 integers in Unit arrays */
6213 /* This routine compares A ? B*10**E where A and B are unit arrays */
6214 /* A is a plain integer */
6215 /* B has an exponent of E (which must be non-negative) */
6217 /* Arg1 is A first Unit (lsu) */
6218 /* Arg2 is A length in Units */
6219 /* Arg3 is B first Unit (lsu) */
6220 /* Arg4 is B length in Units */
6221 /* Arg5 is E (0 if the units are aligned) */
6223 /* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */
6224 /* (the only possible failure is an allocation error, which can */
6225 /* only occur if E!=0) */
6226 /* ------------------------------------------------------------------ */
6227 static Int
decUnitCompare(const Unit
*a
, Int alength
,
6228 const Unit
*b
, Int blength
, Int exp
) {
6229 Unit
*acc
; /* accumulator for result */
6230 Unit accbuff
[SD2U(DECBUFFER
*2+1)]; /* local buffer */
6231 Unit
*allocacc
=NULL
; /* -> allocated acc buffer, iff allocated */
6232 Int accunits
, need
; /* units in use or needed for acc */
6233 const Unit
*l
, *r
, *u
; /* work */
6234 Int expunits
, exprem
, result
; /* .. */
6236 if (exp
==0) { /* aligned; fastpath */
6237 if (alength
>blength
) return 1;
6238 if (alength
<blength
) return -1;
6239 /* same number of units in both -- need unit-by-unit compare */
6242 for (;l
>=a
; l
--, r
--) {
6243 if (*l
>*r
) return 1;
6244 if (*l
<*r
) return -1;
6246 return 0; /* all units match */
6249 /* Unaligned. If one is >1 unit longer than the other, padded */
6250 /* approximately, then can return easily */
6251 if (alength
>blength
+(Int
)D2U(exp
)) return 1;
6252 if (alength
+1<blength
+(Int
)D2U(exp
)) return -1;
6254 /* Need to do a real subtract. For this, a result buffer is needed */
6255 /* even though only the sign is of interest. Its length needs */
6256 /* to be the larger of alength and padded blength, +2 */
6257 need
=blength
+D2U(exp
); /* maximum real length of B */
6258 if (need
<alength
) need
=alength
;
6260 acc
=accbuff
; /* assume use local buffer */
6261 if (need
*sizeof(Unit
)>sizeof(accbuff
)) {
6262 allocacc
=(Unit
*)malloc(need
*sizeof(Unit
));
6263 if (allocacc
==NULL
) return BADINT
; /* hopeless -- abandon */
6266 /* Calculate units and remainder from exponent. */
6267 expunits
=exp
/DECDPUN
;
6269 /* subtract [A+B*(-m)] */
6270 accunits
=decUnitAddSub(a
, alength
, b
, blength
, expunits
, acc
,
6271 -(Int
)powers
[exprem
]);
6272 /* [UnitAddSub result may have leading zeros, even on zero] */
6273 if (accunits
<0) result
=-1; /* negative result */
6274 else { /* non-negative result */
6275 /* check units of the result before freeing any storage */
6276 for (u
=acc
; u
<acc
+accunits
-1 && *u
==0;) u
++;
6277 result
=(*u
==0 ? 0 : +1);
6279 /* clean up and return the result */
6280 free(allocacc
); /* drop any storage used */
6282 } /* decUnitCompare */
6284 /* ------------------------------------------------------------------ */
6285 /* decUnitAddSub -- add or subtract two >=0 integers in Unit arrays */
6287 /* This routine performs the calculation: */
6291 /* Where M is in the range -DECDPUNMAX through +DECDPUNMAX. */
6293 /* A may be shorter or longer than B. */
6295 /* Leading zeros are not removed after a calculation. The result is */
6296 /* either the same length as the longer of A and B (adding any */
6297 /* shift), or one Unit longer than that (if a Unit carry occurred). */
6299 /* A and B content are not altered unless C is also A or B. */
6300 /* C may be the same array as A or B, but only if no zero padding is */
6301 /* requested (that is, C may be B only if bshift==0). */
6302 /* C is filled from the lsu; only those units necessary to complete */
6303 /* the calculation are referenced. */
6305 /* Arg1 is A first Unit (lsu) */
6306 /* Arg2 is A length in Units */
6307 /* Arg3 is B first Unit (lsu) */
6308 /* Arg4 is B length in Units */
6309 /* Arg5 is B shift in Units (>=0; pads with 0 units if positive) */
6310 /* Arg6 is C first Unit (lsu) */
6311 /* Arg7 is M, the multiplier */
6313 /* returns the count of Units written to C, which will be non-zero */
6314 /* and negated if the result is negative. That is, the sign of the */
6315 /* returned Int is the sign of the result (positive for zero) and */
6316 /* the absolute value of the Int is the count of Units. */
6318 /* It is the caller's responsibility to make sure that C size is */
6319 /* safe, allowing space if necessary for a one-Unit carry. */
6321 /* This routine is severely performance-critical; *any* change here */
6322 /* must be measured (timed) to assure no performance degradation. */
6323 /* In particular, trickery here tends to be counter-productive, as */
6324 /* increased complexity of code hurts register optimizations on */
6325 /* register-poor architectures. Avoiding divisions is nearly */
6326 /* always a Good Idea, however. */
6328 /* Special thanks to Rick McGuire (IBM Cambridge, MA) and Dave Clark */
6329 /* (IBM Warwick, UK) for some of the ideas used in this routine. */
6330 /* ------------------------------------------------------------------ */
6331 static Int
decUnitAddSub(const Unit
*a
, Int alength
,
6332 const Unit
*b
, Int blength
, Int bshift
,
6334 const Unit
*alsu
=a
; /* A lsu [need to remember it] */
6335 Unit
*clsu
=c
; /* C ditto */
6336 Unit
*minC
; /* low water mark for C */
6337 Unit
*maxC
; /* high water mark for C */
6338 eInt carry
=0; /* carry integer (could be Long) */
6340 #if DECDPUN<=4 /* myriadal, millenary, etc. */
6341 Int est
; /* estimated quotient */
6345 if (alength
<1 || blength
<1)
6346 printf("decUnitAddSub: alen blen m %ld %ld [%ld]\n", alength
, blength
, m
);
6349 maxC
=c
+alength
; /* A is usually the longer */
6350 minC
=c
+blength
; /* .. and B the shorter */
6351 if (bshift
!=0) { /* B is shifted; low As copy across */
6353 /* if in place [common], skip copy unless there's a gap [rare] */
6354 if (a
==c
&& bshift
<=alength
) {
6358 else for (; c
<clsu
+bshift
; a
++, c
++) { /* copy needed */
6359 if (a
<alsu
+alength
) *c
=*a
;
6363 if (minC
>maxC
) { /* swap */
6369 /* For speed, do the addition as two loops; the first where both A */
6370 /* and B contribute, and the second (if necessary) where only one or */
6371 /* other of the numbers contribute. */
6372 /* Carry handling is the same (i.e., duplicated) in each case. */
6373 for (; c
<minC
; c
++) {
6376 carry
+=((eInt
)*b
)*m
; /* [special-casing m=1/-1 */
6377 b
++; /* here is not a win] */
6378 /* here carry is new Unit of digits; it could be +ve or -ve */
6379 if ((ueInt
)carry
<=DECDPUNMAX
) { /* fastpath 0-DECDPUNMAX */
6384 #if DECDPUN==4 /* use divide-by-multiply */
6386 est
=(((ueInt
)carry
>>11)*53687)>>18;
6387 *c
=(Unit
)(carry
-est
*(DECDPUNMAX
+1)); /* remainder */
6388 carry
=est
; /* likely quotient [89%] */
6389 if (*c
<DECDPUNMAX
+1) continue; /* estimate was correct */
6395 carry
=carry
+(eInt
)(DECDPUNMAX
+1)*(DECDPUNMAX
+1); /* make positive */
6396 est
=(((ueInt
)carry
>>11)*53687)>>18;
6397 *c
=(Unit
)(carry
-est
*(DECDPUNMAX
+1));
6398 carry
=est
-(DECDPUNMAX
+1); /* correctly negative */
6399 if (*c
<DECDPUNMAX
+1) continue; /* was OK */
6404 est
=(((ueInt
)carry
>>3)*16777)>>21;
6405 *c
=(Unit
)(carry
-est
*(DECDPUNMAX
+1)); /* remainder */
6406 carry
=est
; /* likely quotient [99%] */
6407 if (*c
<DECDPUNMAX
+1) continue; /* estimate was correct */
6413 carry
=carry
+(eInt
)(DECDPUNMAX
+1)*(DECDPUNMAX
+1); /* make positive */
6414 est
=(((ueInt
)carry
>>3)*16777)>>21;
6415 *c
=(Unit
)(carry
-est
*(DECDPUNMAX
+1));
6416 carry
=est
-(DECDPUNMAX
+1); /* correctly negative */
6417 if (*c
<DECDPUNMAX
+1) continue; /* was OK */
6421 /* Can use QUOT10 as carry <= 4 digits */
6423 est
=QUOT10(carry
, DECDPUN
);
6424 *c
=(Unit
)(carry
-est
*(DECDPUNMAX
+1)); /* remainder */
6425 carry
=est
; /* quotient */
6429 carry
=carry
+(eInt
)(DECDPUNMAX
+1)*(DECDPUNMAX
+1); /* make positive */
6430 est
=QUOT10(carry
, DECDPUN
);
6431 *c
=(Unit
)(carry
-est
*(DECDPUNMAX
+1));
6432 carry
=est
-(DECDPUNMAX
+1); /* correctly negative */
6434 /* remainder operator is undefined if negative, so must test */
6435 if ((ueInt
)carry
<(DECDPUNMAX
+1)*2) { /* fastpath carry +1 */
6436 *c
=(Unit
)(carry
-(DECDPUNMAX
+1)); /* [helps additions] */
6441 *c
=(Unit
)(carry
%(DECDPUNMAX
+1));
6442 carry
=carry
/(DECDPUNMAX
+1);
6446 carry
=carry
+(eInt
)(DECDPUNMAX
+1)*(DECDPUNMAX
+1); /* make positive */
6447 *c
=(Unit
)(carry
%(DECDPUNMAX
+1));
6448 carry
=carry
/(DECDPUNMAX
+1)-(DECDPUNMAX
+1);
6452 /* now may have one or other to complete */
6453 /* [pretest to avoid loop setup/shutdown] */
6454 if (c
<maxC
) for (; c
<maxC
; c
++) {
6455 if (a
<alsu
+alength
) { /* still in A */
6459 else { /* inside B */
6460 carry
+=((eInt
)*b
)*m
;
6463 /* here carry is new Unit of digits; it could be +ve or -ve and */
6464 /* magnitude up to DECDPUNMAX squared */
6465 if ((ueInt
)carry
<=DECDPUNMAX
) { /* fastpath 0-DECDPUNMAX */
6470 /* result for this unit is negative or >DECDPUNMAX */
6471 #if DECDPUN==4 /* use divide-by-multiply */
6473 est
=(((ueInt
)carry
>>11)*53687)>>18;
6474 *c
=(Unit
)(carry
-est
*(DECDPUNMAX
+1)); /* remainder */
6475 carry
=est
; /* likely quotient [79.7%] */
6476 if (*c
<DECDPUNMAX
+1) continue; /* estimate was correct */
6482 carry
=carry
+(eInt
)(DECDPUNMAX
+1)*(DECDPUNMAX
+1); /* make positive */
6483 est
=(((ueInt
)carry
>>11)*53687)>>18;
6484 *c
=(Unit
)(carry
-est
*(DECDPUNMAX
+1));
6485 carry
=est
-(DECDPUNMAX
+1); /* correctly negative */
6486 if (*c
<DECDPUNMAX
+1) continue; /* was OK */
6491 est
=(((ueInt
)carry
>>3)*16777)>>21;
6492 *c
=(Unit
)(carry
-est
*(DECDPUNMAX
+1)); /* remainder */
6493 carry
=est
; /* likely quotient [99%] */
6494 if (*c
<DECDPUNMAX
+1) continue; /* estimate was correct */
6500 carry
=carry
+(eInt
)(DECDPUNMAX
+1)*(DECDPUNMAX
+1); /* make positive */
6501 est
=(((ueInt
)carry
>>3)*16777)>>21;
6502 *c
=(Unit
)(carry
-est
*(DECDPUNMAX
+1));
6503 carry
=est
-(DECDPUNMAX
+1); /* correctly negative */
6504 if (*c
<DECDPUNMAX
+1) continue; /* was OK */
6509 est
=QUOT10(carry
, DECDPUN
);
6510 *c
=(Unit
)(carry
-est
*(DECDPUNMAX
+1)); /* remainder */
6511 carry
=est
; /* quotient */
6515 carry
=carry
+(eInt
)(DECDPUNMAX
+1)*(DECDPUNMAX
+1); /* make positive */
6516 est
=QUOT10(carry
, DECDPUN
);
6517 *c
=(Unit
)(carry
-est
*(DECDPUNMAX
+1));
6518 carry
=est
-(DECDPUNMAX
+1); /* correctly negative */
6520 if ((ueInt
)carry
<(DECDPUNMAX
+1)*2){ /* fastpath carry 1 */
6521 *c
=(Unit
)(carry
-(DECDPUNMAX
+1));
6525 /* remainder operator is undefined if negative, so must test */
6527 *c
=(Unit
)(carry
%(DECDPUNMAX
+1));
6528 carry
=carry
/(DECDPUNMAX
+1);
6532 carry
=carry
+(eInt
)(DECDPUNMAX
+1)*(DECDPUNMAX
+1); /* make positive */
6533 *c
=(Unit
)(carry
%(DECDPUNMAX
+1));
6534 carry
=carry
/(DECDPUNMAX
+1)-(DECDPUNMAX
+1);
6538 /* OK, all A and B processed; might still have carry or borrow */
6539 /* return number of Units in the result, negated if a borrow */
6540 if (carry
==0) return c
-clsu
; /* no carry, so no more to do */
6541 if (carry
>0) { /* positive carry */
6542 *c
=(Unit
)carry
; /* place as new unit */
6546 /* -ve carry: it's a borrow; complement needed */
6547 add
=1; /* temporary carry... */
6548 for (c
=clsu
; c
<maxC
; c
++) {
6549 add
=DECDPUNMAX
+add
-*c
;
6550 if (add
<=DECDPUNMAX
) {
6559 /* add an extra unit iff it would be non-zero */
6561 printf("UAS borrow: add %ld, carry %ld\n", add
, carry
);
6563 if ((add
-carry
-1)!=0) {
6564 *c
=(Unit
)(add
-carry
-1);
6565 c
++; /* interesting, include it */
6567 return clsu
-c
; /* -ve result indicates borrowed */
6568 } /* decUnitAddSub */
6570 /* ------------------------------------------------------------------ */
6571 /* decTrim -- trim trailing zeros or normalize */
6573 /* dn is the number to trim or normalize */
6574 /* set is the context to use to check for clamp */
6575 /* all is 1 to remove all trailing zeros, 0 for just fraction ones */
6576 /* noclamp is 1 to unconditional (unclamped) trim */
6577 /* dropped returns the number of discarded trailing zeros */
6580 /* If clamp is set in the context then the number of zeros trimmed */
6581 /* may be limited if the exponent is high. */
6582 /* All fields are updated as required. This is a utility operation, */
6583 /* so special values are unchanged and no error is possible. */
6584 /* ------------------------------------------------------------------ */
6585 static decNumber
* decTrim(decNumber
*dn
, decContext
*set
, Flag all
,
6586 Flag noclamp
, Int
*dropped
) {
6587 Int d
, exp
; /* work */
6589 Unit
*up
; /* -> current Unit */
6592 if (decCheckOperands(dn
, DECUNUSED
, DECUNUSED
, DECUNCONT
)) return dn
;
6595 *dropped
=0; /* assume no zeros dropped */
6596 if ((dn
->bits
& DECSPECIAL
) /* fast exit if special .. */
6597 || (*dn
->lsu
& 0x01)) return dn
; /* .. or odd */
6598 if (ISZERO(dn
)) { /* .. or 0 */
6599 dn
->exponent
=0; /* (sign is preserved) */
6603 /* have a finite number which is even */
6605 cut
=1; /* digit (1-DECDPUN) in Unit */
6606 up
=dn
->lsu
; /* -> current Unit */
6607 for (d
=0; d
<dn
->digits
-1; d
++) { /* [don't strip the final digit] */
6608 /* slice by powers */
6610 uInt quot
=QUOT10(*up
, cut
);
6611 if ((*up
-quot
*powers
[cut
])!=0) break; /* found non-0 digit */
6613 if (*up
%powers
[cut
]!=0) break; /* found non-0 digit */
6615 /* have a trailing 0 */
6616 if (!all
) { /* trimming */
6617 /* [if exp>0 then all trailing 0s are significant for trim] */
6618 if (exp
<=0) { /* if digit might be significant */
6619 if (exp
==0) break; /* then quit */
6620 exp
++; /* next digit might be significant */
6623 cut
++; /* next power */
6624 if (cut
>DECDPUN
) { /* need new Unit */
6629 if (d
==0) return dn
; /* none to drop */
6631 /* may need to limit drop if clamping */
6632 if (set
->clamp
&& !noclamp
) {
6633 Int maxd
=set
->emax
-set
->digits
+1-dn
->exponent
;
6634 if (maxd
<=0) return dn
; /* nothing possible */
6638 /* effect the drop */
6639 decShiftToLeast(dn
->lsu
, D2U(dn
->digits
), d
);
6640 dn
->exponent
+=d
; /* maintain numerical value */
6641 dn
->digits
-=d
; /* new length */
6642 *dropped
=d
; /* report the count */
6646 /* ------------------------------------------------------------------ */
6647 /* decReverse -- reverse a Unit array in place */
6649 /* ulo is the start of the array */
6650 /* uhi is the end of the array (highest Unit to include) */
6652 /* The units ulo through uhi are reversed in place (if the number */
6653 /* of units is odd, the middle one is untouched). Note that the */
6654 /* digit(s) in each unit are unaffected. */
6655 /* ------------------------------------------------------------------ */
6656 static void decReverse(Unit
*ulo
, Unit
*uhi
) {
6658 for (; ulo
<uhi
; ulo
++, uhi
--) {
6666 /* ------------------------------------------------------------------ */
6667 /* decShiftToMost -- shift digits in array towards most significant */
6669 /* uar is the array */
6670 /* digits is the count of digits in use in the array */
6671 /* shift is the number of zeros to pad with (least significant); */
6672 /* it must be zero or positive */
6674 /* returns the new length of the integer in the array, in digits */
6676 /* No overflow is permitted (that is, the uar array must be known to */
6677 /* be large enough to hold the result, after shifting). */
6678 /* ------------------------------------------------------------------ */
6679 static Int
decShiftToMost(Unit
*uar
, Int digits
, Int shift
) {
6680 Unit
*target
, *source
, *first
; /* work */
6681 Int cut
; /* odd 0's to add */
6682 uInt next
; /* work */
6684 if (shift
==0) return digits
; /* [fastpath] nothing to do */
6685 if ((digits
+shift
)<=DECDPUN
) { /* [fastpath] single-unit case */
6686 *uar
=(Unit
)(*uar
*powers
[shift
]);
6687 return digits
+shift
;
6690 next
=0; /* all paths */
6691 source
=uar
+D2U(digits
)-1; /* where msu comes from */
6692 target
=source
+D2U(shift
); /* where upper part of first cut goes */
6693 cut
=DECDPUN
-MSUDIGITS(shift
); /* where to slice */
6694 if (cut
==0) { /* unit-boundary case */
6695 for (; source
>=uar
; source
--, target
--) *target
=*source
;
6698 first
=uar
+D2U(digits
+shift
)-1; /* where msu of source will end up */
6699 for (; source
>=uar
; source
--, target
--) {
6700 /* split the source Unit and accumulate remainder for next */
6702 uInt quot
=QUOT10(*source
, cut
);
6703 uInt rem
=*source
-quot
*powers
[cut
];
6706 uInt rem
=*source
%powers
[cut
];
6707 next
+=*source
/powers
[cut
];
6709 if (target
<=first
) *target
=(Unit
)next
; /* write to target iff valid */
6710 next
=rem
*powers
[DECDPUN
-cut
]; /* save remainder for next Unit */
6714 /* propagate any partial unit to one below and clear the rest */
6715 for (; target
>=uar
; target
--) {
6719 return digits
+shift
;
6720 } /* decShiftToMost */
6722 /* ------------------------------------------------------------------ */
6723 /* decShiftToLeast -- shift digits in array towards least significant */
6725 /* uar is the array */
6726 /* units is length of the array, in units */
6727 /* shift is the number of digits to remove from the lsu end; it */
6728 /* must be zero or positive and <= than units*DECDPUN. */
6730 /* returns the new length of the integer in the array, in units */
6732 /* Removed digits are discarded (lost). Units not required to hold */
6733 /* the final result are unchanged. */
6734 /* ------------------------------------------------------------------ */
6735 static Int
decShiftToLeast(Unit
*uar
, Int units
, Int shift
) {
6736 Unit
*target
, *up
; /* work */
6737 Int cut
, count
; /* work */
6738 Int quot
, rem
; /* for division */
6740 if (shift
==0) return units
; /* [fastpath] nothing to do */
6741 if (shift
==units
*DECDPUN
) { /* [fastpath] little to do */
6742 *uar
=0; /* all digits cleared gives zero */
6743 return 1; /* leaves just the one */
6746 target
=uar
; /* both paths */
6747 cut
=MSUDIGITS(shift
);
6748 if (cut
==DECDPUN
) { /* unit-boundary case; easy */
6750 for (; up
<uar
+units
; target
++, up
++) *target
=*up
;
6755 up
=uar
+D2U(shift
-cut
); /* source; correct to whole Units */
6756 count
=units
*DECDPUN
-shift
; /* the maximum new length */
6758 quot
=QUOT10(*up
, cut
);
6760 quot
=*up
/powers
[cut
];
6762 for (; ; target
++) {
6764 count
-=(DECDPUN
-cut
);
6765 if (count
<=0) break;
6769 quot
=QUOT10(quot
, cut
);
6770 rem
=*up
-quot
*powers
[cut
];
6772 rem
=quot
%powers
[cut
];
6773 quot
=quot
/powers
[cut
];
6775 *target
=(Unit
)(*target
+rem
*powers
[DECDPUN
-cut
]);
6777 if (count
<=0) break;
6779 return target
-uar
+1;
6780 } /* decShiftToLeast */
6783 /* ------------------------------------------------------------------ */
6784 /* decRoundOperand -- round an operand [used for subset only] */
6786 /* dn is the number to round (dn->digits is > set->digits) */
6787 /* set is the relevant context */
6788 /* status is the status accumulator */
6790 /* returns an allocated decNumber with the rounded result. */
6792 /* lostDigits and other status may be set by this. */
6794 /* Since the input is an operand, it must not be modified. */
6795 /* Instead, return an allocated decNumber, rounded as required. */
6796 /* It is the caller's responsibility to free the allocated storage. */
6798 /* If no storage is available then the result cannot be used, so NULL */
6800 /* ------------------------------------------------------------------ */
6801 static decNumber
*decRoundOperand(const decNumber
*dn
, decContext
*set
,
6803 decNumber
*res
; /* result structure */
6804 uInt newstatus
=0; /* status from round */
6805 Int residue
=0; /* rounding accumulator */
6807 /* Allocate storage for the returned decNumber, big enough for the */
6808 /* length specified by the context */
6809 res
=(decNumber
*)malloc(sizeof(decNumber
)
6810 +(D2U(set
->digits
)-1)*sizeof(Unit
));
6812 *status
|=DEC_Insufficient_storage
;
6815 decCopyFit(res
, dn
, set
, &residue
, &newstatus
);
6816 decApplyRound(res
, set
, residue
, &newstatus
);
6818 /* If that set Inexact then "lost digits" is raised... */
6819 if (newstatus
& DEC_Inexact
) newstatus
|=DEC_Lost_digits
;
6822 } /* decRoundOperand */
6825 /* ------------------------------------------------------------------ */
6826 /* decCopyFit -- copy a number, truncating the coefficient if needed */
6828 /* dest is the target decNumber */
6829 /* src is the source decNumber */
6830 /* set is the context [used for length (digits) and rounding mode] */
6831 /* residue is the residue accumulator */
6832 /* status contains the current status to be updated */
6834 /* (dest==src is allowed and will be a no-op if fits) */
6835 /* All fields are updated as required. */
6836 /* ------------------------------------------------------------------ */
6837 static void decCopyFit(decNumber
*dest
, const decNumber
*src
,
6838 decContext
*set
, Int
*residue
, uInt
*status
) {
6839 dest
->bits
=src
->bits
;
6840 dest
->exponent
=src
->exponent
;
6841 decSetCoeff(dest
, set
, src
->lsu
, src
->digits
, residue
, status
);
6844 /* ------------------------------------------------------------------ */
6845 /* decSetCoeff -- set the coefficient of a number */
6847 /* dn is the number whose coefficient array is to be set. */
6848 /* It must have space for set->digits digits */
6849 /* set is the context [for size] */
6850 /* lsu -> lsu of the source coefficient [may be dn->lsu] */
6851 /* len is digits in the source coefficient [may be dn->digits] */
6852 /* residue is the residue accumulator. This has values as in */
6853 /* decApplyRound, and will be unchanged unless the */
6854 /* target size is less than len. In this case, the */
6855 /* coefficient is truncated and the residue is updated to */
6856 /* reflect the previous residue and the dropped digits. */
6857 /* status is the status accumulator, as usual */
6859 /* The coefficient may already be in the number, or it can be an */
6860 /* external intermediate array. If it is in the number, lsu must == */
6861 /* dn->lsu and len must == dn->digits. */
6863 /* Note that the coefficient length (len) may be < set->digits, and */
6864 /* in this case this merely copies the coefficient (or is a no-op */
6865 /* if dn->lsu==lsu). */
6867 /* Note also that (only internally, from decQuantizeOp and */
6868 /* decSetSubnormal) the value of set->digits may be less than one, */
6869 /* indicating a round to left. This routine handles that case */
6870 /* correctly; caller ensures space. */
6872 /* dn->digits, dn->lsu (and as required), and dn->exponent are */
6873 /* updated as necessary. dn->bits (sign) is unchanged. */
6875 /* DEC_Rounded status is set if any digits are discarded. */
6876 /* DEC_Inexact status is set if any non-zero digits are discarded, or */
6877 /* incoming residue was non-0 (implies rounded) */
6878 /* ------------------------------------------------------------------ */
6879 /* mapping array: maps 0-9 to canonical residues, so that a residue */
6880 /* can be adjusted in the range [-1, +1] and achieve correct rounding */
6881 /* 0 1 2 3 4 5 6 7 8 9 */
6882 static const uByte resmap
[10]={0, 3, 3, 3, 3, 5, 7, 7, 7, 7};
6883 static void decSetCoeff(decNumber
*dn
, decContext
*set
, const Unit
*lsu
,
6884 Int len
, Int
*residue
, uInt
*status
) {
6885 Int discard
; /* number of digits to discard */
6886 uInt cut
; /* cut point in Unit */
6887 const Unit
*up
; /* work */
6888 Unit
*target
; /* .. */
6894 discard
=len
-set
->digits
; /* digits to discard */
6895 if (discard
<=0) { /* no digits are being discarded */
6896 if (dn
->lsu
!=lsu
) { /* copy needed */
6897 /* copy the coefficient array to the result number; no shift needed */
6898 count
=len
; /* avoids D2U */
6900 for (target
=dn
->lsu
; count
>0; target
++, up
++, count
-=DECDPUN
)
6902 dn
->digits
=len
; /* set the new length */
6904 /* dn->exponent and residue are unchanged, record any inexactitude */
6905 if (*residue
!=0) *status
|=(DEC_Inexact
| DEC_Rounded
);
6909 /* some digits must be discarded ... */
6910 dn
->exponent
+=discard
; /* maintain numerical value */
6911 *status
|=DEC_Rounded
; /* accumulate Rounded status */
6912 if (*residue
>1) *residue
=1; /* previous residue now to right, so reduce */
6914 if (discard
>len
) { /* everything, +1, is being discarded */
6915 /* guard digit is 0 */
6916 /* residue is all the number [NB could be all 0s] */
6917 if (*residue
<=0) { /* not already positive */
6918 count
=len
; /* avoids D2U */
6919 for (up
=lsu
; count
>0; up
++, count
-=DECDPUN
) if (*up
!=0) { /* found non-0 */
6921 break; /* no need to check any others */
6924 if (*residue
!=0) *status
|=DEC_Inexact
; /* record inexactitude */
6925 *dn
->lsu
=0; /* coefficient will now be 0 */
6926 dn
->digits
=1; /* .. */
6928 } /* total discard */
6930 /* partial discard [most common case] */
6931 /* here, at least the first (most significant) discarded digit exists */
6933 /* spin up the number, noting residue during the spin, until get to */
6934 /* the Unit with the first discarded digit. When reach it, extract */
6935 /* it and remember its position */
6937 for (up
=lsu
;; up
++) {
6939 if (count
>=discard
) break; /* full ones all checked */
6940 if (*up
!=0) *residue
=1;
6943 /* here up -> Unit with first discarded digit */
6944 cut
=discard
-(count
-DECDPUN
)-1;
6945 if (cut
==DECDPUN
-1) { /* unit-boundary case (fast) */
6946 Unit half
=(Unit
)powers
[DECDPUN
]>>1;
6947 /* set residue directly */
6949 if (*up
>half
) *residue
=7;
6950 else *residue
+=5; /* add sticky bit */
6953 if (*up
!=0) *residue
=3; /* [else is 0, leave as sticky bit] */
6955 if (set
->digits
<=0) { /* special for Quantize/Subnormal :-( */
6956 *dn
->lsu
=0; /* .. result is 0 */
6957 dn
->digits
=1; /* .. */
6959 else { /* shift to least */
6960 count
=set
->digits
; /* now digits to end up with */
6961 dn
->digits
=count
; /* set the new length */
6962 up
++; /* move to next */
6963 /* on unit boundary, so shift-down copy loop is simple */
6964 for (target
=dn
->lsu
; count
>0; target
++, up
++, count
-=DECDPUN
)
6967 } /* unit-boundary case */
6969 else { /* discard digit is in low digit(s), and not top digit */
6970 uInt discard1
; /* first discarded digit */
6971 uInt quot
, rem
; /* for divisions */
6972 if (cut
==0) quot
=*up
; /* is at bottom of unit */
6973 else /* cut>0 */ { /* it's not at bottom of unit */
6975 quot
=QUOT10(*up
, cut
);
6976 rem
=*up
-quot
*powers
[cut
];
6978 rem
=*up
%powers
[cut
];
6979 quot
=*up
/powers
[cut
];
6981 if (rem
!=0) *residue
=1;
6983 /* discard digit is now at bottom of quot */
6985 temp
=(quot
*6554)>>16; /* fast /10 */
6986 /* Vowels algorithm here not a win (9 instructions) */
6987 discard1
=quot
-X10(temp
);
6993 /* here, discard1 is the guard digit, and residue is everything */
6994 /* else [use mapping array to accumulate residue safely] */
6995 *residue
+=resmap
[discard1
];
6996 cut
++; /* update cut */
6997 /* here: up -> Unit of the array with bottom digit */
6998 /* cut is the division point for each Unit */
6999 /* quot holds the uncut high-order digits for the current unit */
7000 if (set
->digits
<=0) { /* special for Quantize/Subnormal :-( */
7001 *dn
->lsu
=0; /* .. result is 0 */
7002 dn
->digits
=1; /* .. */
7004 else { /* shift to least needed */
7005 count
=set
->digits
; /* now digits to end up with */
7006 dn
->digits
=count
; /* set the new length */
7007 /* shift-copy the coefficient array to the result number */
7008 for (target
=dn
->lsu
; ; target
++) {
7010 count
-=(DECDPUN
-cut
);
7011 if (count
<=0) break;
7015 quot
=QUOT10(quot
, cut
);
7016 rem
=*up
-quot
*powers
[cut
];
7018 rem
=quot
%powers
[cut
];
7019 quot
=quot
/powers
[cut
];
7021 *target
=(Unit
)(*target
+rem
*powers
[DECDPUN
-cut
]);
7023 if (count
<=0) break;
7024 } /* shift-copy loop */
7025 } /* shift to least */
7026 } /* not unit boundary */
7028 if (*residue
!=0) *status
|=DEC_Inexact
; /* record inexactitude */
7032 /* ------------------------------------------------------------------ */
7033 /* decApplyRound -- apply pending rounding to a number */
7035 /* dn is the number, with space for set->digits digits */
7036 /* set is the context [for size and rounding mode] */
7037 /* residue indicates pending rounding, being any accumulated */
7038 /* guard and sticky information. It may be: */
7039 /* 6-9: rounding digit is >5 */
7040 /* 5: rounding digit is exactly half-way */
7041 /* 1-4: rounding digit is <5 and >0 */
7042 /* 0: the coefficient is exact */
7043 /* -1: as 1, but the hidden digits are subtractive, that */
7044 /* is, of the opposite sign to dn. In this case the */
7045 /* coefficient must be non-0. This case occurs when */
7046 /* subtracting a small number (which can be reduced to */
7047 /* a sticky bit); see decAddOp. */
7048 /* status is the status accumulator, as usual */
7050 /* This routine applies rounding while keeping the length of the */
7051 /* coefficient constant. The exponent and status are unchanged */
7054 /* -- the coefficient was increased and is all nines (in which */
7055 /* case Overflow could occur, and is handled directly here so */
7056 /* the caller does not need to re-test for overflow) */
7058 /* -- the coefficient was decreased and becomes all nines (in which */
7059 /* case Underflow could occur, and is also handled directly). */
7061 /* All fields in dn are updated as required. */
7063 /* ------------------------------------------------------------------ */
7064 static void decApplyRound(decNumber
*dn
, decContext
*set
, Int residue
,
7066 Int bump
; /* 1 if coefficient needs to be incremented */
7067 /* -1 if coefficient needs to be decremented */
7069 if (residue
==0) return; /* nothing to apply */
7071 bump
=0; /* assume a smooth ride */
7073 /* now decide whether, and how, to round, depending on mode */
7074 switch (set
->round
) {
7075 case DEC_ROUND_05UP
: { /* round zero or five up (for reround) */
7076 /* This is the same as DEC_ROUND_DOWN unless there is a */
7077 /* positive residue and the lsd of dn is 0 or 5, in which case */
7078 /* it is bumped; when residue is <0, the number is therefore */
7079 /* bumped down unless the final digit was 1 or 6 (in which */
7080 /* case it is bumped down and then up -- a no-op) */
7081 Int lsd5
=*dn
->lsu
%5; /* get lsd and quintate */
7082 if (residue
<0 && lsd5
!=1) bump
=-1;
7083 else if (residue
>0 && lsd5
==0) bump
=1;
7084 /* [bump==1 could be applied directly; use common path for clarity] */
7087 case DEC_ROUND_DOWN
: {
7088 /* no change, except if negative residue */
7089 if (residue
<0) bump
=-1;
7092 case DEC_ROUND_HALF_DOWN
: {
7093 if (residue
>5) bump
=1;
7096 case DEC_ROUND_HALF_EVEN
: {
7097 if (residue
>5) bump
=1; /* >0.5 goes up */
7098 else if (residue
==5) { /* exactly 0.5000... */
7099 /* 0.5 goes up iff [new] lsd is odd */
7100 if (*dn
->lsu
& 0x01) bump
=1;
7104 case DEC_ROUND_HALF_UP
: {
7105 if (residue
>=5) bump
=1;
7108 case DEC_ROUND_UP
: {
7109 if (residue
>0) bump
=1;
7112 case DEC_ROUND_CEILING
: {
7113 /* same as _UP for positive numbers, and as _DOWN for negatives */
7114 /* [negative residue cannot occur on 0] */
7115 if (decNumberIsNegative(dn
)) {
7116 if (residue
<0) bump
=-1;
7119 if (residue
>0) bump
=1;
7123 case DEC_ROUND_FLOOR
: {
7124 /* same as _UP for negative numbers, and as _DOWN for positive */
7125 /* [negative residue cannot occur on 0] */
7126 if (!decNumberIsNegative(dn
)) {
7127 if (residue
<0) bump
=-1;
7130 if (residue
>0) bump
=1;
7134 default: { /* e.g., DEC_ROUND_MAX */
7135 *status
|=DEC_Invalid_context
;
7136 #if DECTRACE || (DECCHECK && DECVERB)
7137 printf("Unknown rounding mode: %d\n", set
->round
);
7142 /* now bump the number, up or down, if need be */
7143 if (bump
==0) return; /* no action required */
7145 /* Simply use decUnitAddSub unless bumping up and the number is */
7146 /* all nines. In this special case set to 100... explicitly */
7147 /* and adjust the exponent by one (as otherwise could overflow */
7149 /* Similarly handle all-nines result if bumping down. */
7151 Unit
*up
; /* work */
7152 uInt count
=dn
->digits
; /* digits to be checked */
7153 for (up
=dn
->lsu
; ; up
++) {
7154 if (count
<=DECDPUN
) {
7155 /* this is the last Unit (the msu) */
7156 if (*up
!=powers
[count
]-1) break; /* not still 9s */
7157 /* here if it, too, is all nines */
7158 *up
=(Unit
)powers
[count
-1]; /* here 999 -> 100 etc. */
7159 for (up
=up
-1; up
>=dn
->lsu
; up
--) *up
=0; /* others all to 0 */
7160 dn
->exponent
++; /* and bump exponent */
7161 /* [which, very rarely, could cause Overflow...] */
7162 if ((dn
->exponent
+dn
->digits
)>set
->emax
+1) {
7163 decSetOverflow(dn
, set
, status
);
7167 /* a full unit to check, with more to come */
7168 if (*up
!=DECDPUNMAX
) break; /* not still 9s */
7173 /* here checking for a pre-bump of 1000... (leading 1, all */
7174 /* other digits zero) */
7175 Unit
*up
, *sup
; /* work */
7176 uInt count
=dn
->digits
; /* digits to be checked */
7177 for (up
=dn
->lsu
; ; up
++) {
7178 if (count
<=DECDPUN
) {
7179 /* this is the last Unit (the msu) */
7180 if (*up
!=powers
[count
-1]) break; /* not 100.. */
7181 /* here if have the 1000... case */
7182 sup
=up
; /* save msu pointer */
7183 *up
=(Unit
)powers
[count
]-1; /* here 100 in msu -> 999 */
7184 /* others all to all-nines, too */
7185 for (up
=up
-1; up
>=dn
->lsu
; up
--) *up
=(Unit
)powers
[DECDPUN
]-1;
7186 dn
->exponent
--; /* and bump exponent */
7188 /* iff the number was at the subnormal boundary (exponent=etiny) */
7189 /* then the exponent is now out of range, so it will in fact get */
7190 /* clamped to etiny and the final 9 dropped. */
7191 /* printf(">> emin=%d exp=%d sdig=%d\n", set->emin, */
7192 /* dn->exponent, set->digits); */
7193 if (dn
->exponent
+1==set
->emin
-set
->digits
+1) {
7194 if (count
==1 && dn
->digits
==1) *sup
=0; /* here 9 -> 0[.9] */
7196 *sup
=(Unit
)powers
[count
-1]-1; /* here 999.. in msu -> 99.. */
7200 *status
|=DEC_Underflow
| DEC_Subnormal
| DEC_Inexact
| DEC_Rounded
;
7205 /* a full unit to check, with more to come */
7206 if (*up
!=0) break; /* not still 0s */
7212 /* Actual bump needed. Do it. */
7213 decUnitAddSub(dn
->lsu
, D2U(dn
->digits
), uarrone
, 1, 0, dn
->lsu
, bump
);
7214 } /* decApplyRound */
7217 /* ------------------------------------------------------------------ */
7218 /* decFinish -- finish processing a number */
7220 /* dn is the number */
7221 /* set is the context */
7222 /* residue is the rounding accumulator (as in decApplyRound) */
7223 /* status is the accumulator */
7225 /* This finishes off the current number by: */
7226 /* 1. If not extended: */
7227 /* a. Converting a zero result to clean '0' */
7228 /* b. Reducing positive exponents to 0, if would fit in digits */
7229 /* 2. Checking for overflow and subnormals (always) */
7230 /* Note this is just Finalize when no subset arithmetic. */
7231 /* All fields are updated as required. */
7232 /* ------------------------------------------------------------------ */
7233 static void decFinish(decNumber
*dn
, decContext
*set
, Int
*residue
,
7235 if (!set
->extended
) {
7236 if ISZERO(dn
) { /* value is zero */
7237 dn
->exponent
=0; /* clean exponent .. */
7238 dn
->bits
=0; /* .. and sign */
7239 return; /* no error possible */
7241 if (dn
->exponent
>=0) { /* non-negative exponent */
7242 /* >0; reduce to integer if possible */
7243 if (set
->digits
>= (dn
->exponent
+dn
->digits
)) {
7244 dn
->digits
=decShiftToMost(dn
->lsu
, dn
->digits
, dn
->exponent
);
7250 decFinalize(dn
, set
, residue
, status
);
7254 /* ------------------------------------------------------------------ */
7255 /* decFinalize -- final check, clamp, and round of a number */
7257 /* dn is the number */
7258 /* set is the context */
7259 /* residue is the rounding accumulator (as in decApplyRound) */
7260 /* status is the status accumulator */
7262 /* This finishes off the current number by checking for subnormal */
7263 /* results, applying any pending rounding, checking for overflow, */
7264 /* and applying any clamping. */
7265 /* Underflow and overflow conditions are raised as appropriate. */
7266 /* All fields are updated as required. */
7267 /* ------------------------------------------------------------------ */
7268 static void decFinalize(decNumber
*dn
, decContext
*set
, Int
*residue
,
7270 Int shift
; /* shift needed if clamping */
7271 Int tinyexp
=set
->emin
-dn
->digits
+1; /* precalculate subnormal boundary */
7273 /* Must be careful, here, when checking the exponent as the */
7274 /* adjusted exponent could overflow 31 bits [because it may already */
7275 /* be up to twice the expected]. */
7277 /* First test for subnormal. This must be done before any final */
7278 /* round as the result could be rounded to Nmin or 0. */
7279 if (dn
->exponent
<=tinyexp
) { /* prefilter */
7282 /* A very nasty case here is dn == Nmin and residue<0 */
7283 if (dn
->exponent
<tinyexp
) {
7284 /* Go handle subnormals; this will apply round if needed. */
7285 decSetSubnormal(dn
, set
, residue
, status
);
7288 /* Equals case: only subnormal if dn=Nmin and negative residue */
7289 decNumberZero(&nmin
);
7291 nmin
.exponent
=set
->emin
;
7292 comp
=decCompare(dn
, &nmin
, 1); /* (signless compare) */
7293 if (comp
==BADINT
) { /* oops */
7294 *status
|=DEC_Insufficient_storage
; /* abandon... */
7297 if (*residue
<0 && comp
==0) { /* neg residue and dn==Nmin */
7298 decApplyRound(dn
, set
, *residue
, status
); /* might force down */
7299 decSetSubnormal(dn
, set
, residue
, status
);
7304 /* now apply any pending round (this could raise overflow). */
7305 if (*residue
!=0) decApplyRound(dn
, set
, *residue
, status
);
7307 /* Check for overflow [redundant in the 'rare' case] or clamp */
7308 if (dn
->exponent
<=set
->emax
-set
->digits
+1) return; /* neither needed */
7311 /* here when might have an overflow or clamp to do */
7312 if (dn
->exponent
>set
->emax
-dn
->digits
+1) { /* too big */
7313 decSetOverflow(dn
, set
, status
);
7316 /* here when the result is normal but in clamp range */
7317 if (!set
->clamp
) return;
7319 /* here when need to apply the IEEE exponent clamp (fold-down) */
7320 shift
=dn
->exponent
-(set
->emax
-set
->digits
+1);
7322 /* shift coefficient (if non-zero) */
7324 dn
->digits
=decShiftToMost(dn
->lsu
, dn
->digits
, shift
);
7326 dn
->exponent
-=shift
; /* adjust the exponent to match */
7327 *status
|=DEC_Clamped
; /* and record the dirty deed */
7331 /* ------------------------------------------------------------------ */
7332 /* decSetOverflow -- set number to proper overflow value */
7334 /* dn is the number (used for sign [only] and result) */
7335 /* set is the context [used for the rounding mode, etc.] */
7336 /* status contains the current status to be updated */
7338 /* This sets the sign of a number and sets its value to either */
7339 /* Infinity or the maximum finite value, depending on the sign of */
7340 /* dn and the rounding mode, following IEEE 754 rules. */
7341 /* ------------------------------------------------------------------ */
7342 static void decSetOverflow(decNumber
*dn
, decContext
*set
, uInt
*status
) {
7343 Flag needmax
=0; /* result is maximum finite value */
7344 uByte sign
=dn
->bits
&DECNEG
; /* clean and save sign bit */
7346 if (ISZERO(dn
)) { /* zero does not overflow magnitude */
7347 Int emax
=set
->emax
; /* limit value */
7348 if (set
->clamp
) emax
-=set
->digits
-1; /* lower if clamping */
7349 if (dn
->exponent
>emax
) { /* clamp required */
7351 *status
|=DEC_Clamped
;
7357 switch (set
->round
) {
7358 case DEC_ROUND_DOWN
: {
7359 needmax
=1; /* never Infinity */
7361 case DEC_ROUND_05UP
: {
7362 needmax
=1; /* never Infinity */
7364 case DEC_ROUND_CEILING
: {
7365 if (sign
) needmax
=1; /* Infinity if non-negative */
7367 case DEC_ROUND_FLOOR
: {
7368 if (!sign
) needmax
=1; /* Infinity if negative */
7370 default: break; /* Infinity in all other cases */
7373 decSetMaxValue(dn
, set
);
7374 dn
->bits
=sign
; /* set sign */
7376 else dn
->bits
=sign
|DECINF
; /* Value is +/-Infinity */
7377 *status
|=DEC_Overflow
| DEC_Inexact
| DEC_Rounded
;
7378 } /* decSetOverflow */
7380 /* ------------------------------------------------------------------ */
7381 /* decSetMaxValue -- set number to +Nmax (maximum normal value) */
7383 /* dn is the number to set */
7384 /* set is the context [used for digits and emax] */
7386 /* This sets the number to the maximum positive value. */
7387 /* ------------------------------------------------------------------ */
7388 static void decSetMaxValue(decNumber
*dn
, decContext
*set
) {
7389 Unit
*up
; /* work */
7390 Int count
=set
->digits
; /* nines to add */
7392 /* fill in all nines to set maximum value */
7393 for (up
=dn
->lsu
; ; up
++) {
7394 if (count
>DECDPUN
) *up
=DECDPUNMAX
; /* unit full o'nines */
7395 else { /* this is the msu */
7396 *up
=(Unit
)(powers
[count
]-1);
7399 count
-=DECDPUN
; /* filled those digits */
7401 dn
->bits
=0; /* + sign */
7402 dn
->exponent
=set
->emax
-set
->digits
+1;
7403 } /* decSetMaxValue */
7405 /* ------------------------------------------------------------------ */
7406 /* decSetSubnormal -- process value whose exponent is <Emin */
7408 /* dn is the number (used as input as well as output; it may have */
7409 /* an allowed subnormal value, which may need to be rounded) */
7410 /* set is the context [used for the rounding mode] */
7411 /* residue is any pending residue */
7412 /* status contains the current status to be updated */
7414 /* If subset mode, set result to zero and set Underflow flags. */
7416 /* Value may be zero with a low exponent; this does not set Subnormal */
7417 /* but the exponent will be clamped to Etiny. */
7419 /* Otherwise ensure exponent is not out of range, and round as */
7420 /* necessary. Underflow is set if the result is Inexact. */
7421 /* ------------------------------------------------------------------ */
7422 static void decSetSubnormal(decNumber
*dn
, decContext
*set
, Int
*residue
,
7424 decContext workset
; /* work */
7425 Int etiny
, adjust
; /* .. */
7428 /* simple set to zero and 'hard underflow' for subset */
7429 if (!set
->extended
) {
7431 /* always full overflow */
7432 *status
|=DEC_Underflow
| DEC_Subnormal
| DEC_Inexact
| DEC_Rounded
;
7437 /* Full arithmetic -- allow subnormals, rounded to minimum exponent */
7438 /* (Etiny) if needed */
7439 etiny
=set
->emin
-(set
->digits
-1); /* smallest allowed exponent */
7441 if ISZERO(dn
) { /* value is zero */
7442 /* residue can never be non-zero here */
7445 printf("++ Subnormal 0 residue %ld\n", (LI
)*residue
);
7446 *status
|=DEC_Invalid_operation
;
7449 if (dn
->exponent
<etiny
) { /* clamp required */
7451 *status
|=DEC_Clamped
;
7456 *status
|=DEC_Subnormal
; /* have a non-zero subnormal */
7457 adjust
=etiny
-dn
->exponent
; /* calculate digits to remove */
7458 if (adjust
<=0) { /* not out of range; unrounded */
7459 /* residue can never be non-zero here, except in the Nmin-residue */
7460 /* case (which is a subnormal result), so can take fast-path here */
7461 /* it may already be inexact (from setting the coefficient) */
7462 if (*status
&DEC_Inexact
) *status
|=DEC_Underflow
;
7466 /* adjust>0, so need to rescale the result so exponent becomes Etiny */
7467 /* [this code is similar to that in rescale] */
7468 workset
=*set
; /* clone rounding, etc. */
7469 workset
.digits
=dn
->digits
-adjust
; /* set requested length */
7470 workset
.emin
-=adjust
; /* and adjust emin to match */
7471 /* [note that the latter can be <1, here, similar to Rescale case] */
7472 decSetCoeff(dn
, &workset
, dn
->lsu
, dn
->digits
, residue
, status
);
7473 decApplyRound(dn
, &workset
, *residue
, status
);
7475 /* Use 754 default rule: Underflow is set iff Inexact */
7476 /* [independent of whether trapped] */
7477 if (*status
&DEC_Inexact
) *status
|=DEC_Underflow
;
7479 /* if rounded up a 999s case, exponent will be off by one; adjust */
7480 /* back if so [it will fit, because it was shortened earlier] */
7481 if (dn
->exponent
>etiny
) {
7482 dn
->digits
=decShiftToMost(dn
->lsu
, dn
->digits
, 1);
7483 dn
->exponent
--; /* (re)adjust the exponent. */
7486 /* if rounded to zero, it is by definition clamped... */
7487 if (ISZERO(dn
)) *status
|=DEC_Clamped
;
7488 } /* decSetSubnormal */
7490 /* ------------------------------------------------------------------ */
7491 /* decCheckMath - check entry conditions for a math function */
7493 /* This checks the context and the operand */
7495 /* rhs is the operand to check */
7496 /* set is the context to check */
7497 /* status is unchanged if both are good */
7499 /* returns non-zero if status is changed, 0 otherwise */
7501 /* Restrictions enforced: */
7503 /* digits, emax, and -emin in the context must be less than */
7504 /* DEC_MAX_MATH (999999), and A must be within these bounds if */
7505 /* non-zero. Invalid_operation is set in the status if a */
7506 /* restriction is violated. */
7507 /* ------------------------------------------------------------------ */
7508 static uInt
decCheckMath(const decNumber
*rhs
, decContext
*set
,
7510 uInt save
=*status
; /* record */
7511 if (set
->digits
>DEC_MAX_MATH
7512 || set
->emax
>DEC_MAX_MATH
7513 || -set
->emin
>DEC_MAX_MATH
) *status
|=DEC_Invalid_context
;
7514 else if ((rhs
->digits
>DEC_MAX_MATH
7515 || rhs
->exponent
+rhs
->digits
>DEC_MAX_MATH
+1
7516 || rhs
->exponent
+rhs
->digits
<2*(1-DEC_MAX_MATH
))
7517 && !ISZERO(rhs
)) *status
|=DEC_Invalid_operation
;
7518 return (*status
!=save
);
7519 } /* decCheckMath */
7521 /* ------------------------------------------------------------------ */
7522 /* decGetInt -- get integer from a number */
7524 /* dn is the number [which will not be altered] */
7526 /* returns one of: */
7527 /* BADINT if there is a non-zero fraction */
7528 /* the converted integer */
7529 /* BIGEVEN if the integer is even and magnitude > 2*10**9 */
7530 /* BIGODD if the integer is odd and magnitude > 2*10**9 */
7532 /* This checks and gets a whole number from the input decNumber. */
7533 /* The sign can be determined from dn by the caller when BIGEVEN or */
7534 /* BIGODD is returned. */
7535 /* ------------------------------------------------------------------ */
7536 static Int
decGetInt(const decNumber
*dn
) {
7537 Int theInt
; /* result accumulator */
7538 const Unit
*up
; /* work */
7539 Int got
; /* digits (real or not) processed */
7540 Int ilength
=dn
->digits
+dn
->exponent
; /* integral length */
7541 Flag neg
=decNumberIsNegative(dn
); /* 1 if -ve */
7543 /* The number must be an integer that fits in 10 digits */
7544 /* Assert, here, that 10 is enough for any rescale Etiny */
7545 #if DEC_MAX_EMAX > 999999999
7546 #error GetInt may need updating [for Emax]
7548 #if DEC_MIN_EMIN < -999999999
7549 #error GetInt may need updating [for Emin]
7551 if (ISZERO(dn
)) return 0; /* zeros are OK, with any exponent */
7553 up
=dn
->lsu
; /* ready for lsu */
7554 theInt
=0; /* ready to accumulate */
7555 if (dn
->exponent
>=0) { /* relatively easy */
7556 /* no fractional part [usual]; allow for positive exponent */
7559 else { /* -ve exponent; some fractional part to check and discard */
7560 Int count
=-dn
->exponent
; /* digits to discard */
7561 /* spin up whole units until reach the Unit with the unit digit */
7562 for (; count
>=DECDPUN
; up
++) {
7563 if (*up
!=0) return BADINT
; /* non-zero Unit to discard */
7566 if (count
==0) got
=0; /* [a multiple of DECDPUN] */
7567 else { /* [not multiple of DECDPUN] */
7569 /* slice off fraction digits and check for non-zero */
7571 theInt
=QUOT10(*up
, count
);
7572 rem
=*up
-theInt
*powers
[count
];
7574 rem
=*up
%powers
[count
]; /* slice off discards */
7575 theInt
=*up
/powers
[count
];
7577 if (rem
!=0) return BADINT
; /* non-zero fraction */
7579 got
=DECDPUN
-count
; /* number of digits so far */
7580 up
++; /* ready for next */
7583 /* now it's known there's no fractional part */
7585 /* tricky code now, to accumulate up to 9.3 digits */
7586 if (got
==0) {theInt
=*up
; got
+=DECDPUN
; up
++;} /* ensure lsu is there */
7590 /* collect any remaining unit(s) */
7591 for (; got
<ilength
; up
++) {
7592 theInt
+=*up
*powers
[got
];
7595 if (ilength
==10) { /* need to check for wrap */
7596 if (theInt
/(Int
)powers
[got
-DECDPUN
]!=(Int
)*(up
-1)) ilength
=11;
7597 /* [that test also disallows the BADINT result case] */
7598 else if (neg
&& theInt
>1999999997) ilength
=11;
7599 else if (!neg
&& theInt
>999999999) ilength
=11;
7600 if (ilength
==11) theInt
=save
; /* restore correct low bit */
7604 if (ilength
>10) { /* too big */
7605 if (theInt
&1) return BIGODD
; /* bottom bit 1 */
7606 return BIGEVEN
; /* bottom bit 0 */
7609 if (neg
) theInt
=-theInt
; /* apply sign */
7613 /* ------------------------------------------------------------------ */
7614 /* decDecap -- decapitate the coefficient of a number */
7616 /* dn is the number to be decapitated */
7617 /* drop is the number of digits to be removed from the left of dn; */
7618 /* this must be <= dn->digits (if equal, the coefficient is */
7621 /* Returns dn; dn->digits will be <= the initial digits less drop */
7622 /* (after removing drop digits there may be leading zero digits */
7623 /* which will also be removed). Only dn->lsu and dn->digits change. */
7624 /* ------------------------------------------------------------------ */
7625 static decNumber
*decDecap(decNumber
*dn
, Int drop
) {
7626 Unit
*msu
; /* -> target cut point */
7628 if (drop
>=dn
->digits
) { /* losing the whole thing */
7630 if (drop
>dn
->digits
)
7631 printf("decDecap called with drop>digits [%ld>%ld]\n",
7632 (LI
)drop
, (LI
)dn
->digits
);
7638 msu
=dn
->lsu
+D2U(dn
->digits
-drop
)-1; /* -> likely msu */
7639 cut
=MSUDIGITS(dn
->digits
-drop
); /* digits to be in use in msu */
7640 if (cut
!=DECDPUN
) *msu
%=powers
[cut
]; /* clear left digits */
7641 /* that may have left leading zero digits, so do a proper count... */
7642 dn
->digits
=decGetDigits(dn
->lsu
, msu
-dn
->lsu
+1);
7646 /* ------------------------------------------------------------------ */
7647 /* decBiStr -- compare string with pairwise options */
7649 /* targ is the string to compare */
7650 /* str1 is one of the strings to compare against (length may be 0) */
7651 /* str2 is the other; it must be the same length as str1 */
7653 /* returns 1 if strings compare equal, (that is, it is the same */
7654 /* length as str1 and str2, and each character of targ is in either */
7655 /* str1 or str2 in the corresponding position), or 0 otherwise */
7657 /* This is used for generic caseless compare, including the awkward */
7658 /* case of the Turkish dotted and dotless Is. Use as (for example): */
7659 /* if (decBiStr(test, "mike", "MIKE")) ... */
7660 /* ------------------------------------------------------------------ */
7661 static Flag
decBiStr(const char *targ
, const char *str1
, const char *str2
) {
7662 for (;;targ
++, str1
++, str2
++) {
7663 if (*targ
!=*str1
&& *targ
!=*str2
) return 0;
7664 /* *targ has a match in one (or both, if terminator) */
7665 if (*targ
=='\0') break;
7670 /* ------------------------------------------------------------------ */
7671 /* decNaNs -- handle NaN operand or operands */
7673 /* res is the result number */
7674 /* lhs is the first operand */
7675 /* rhs is the second operand, or NULL if none */
7676 /* context is used to limit payload length */
7677 /* status contains the current status */
7678 /* returns res in case convenient */
7680 /* Called when one or both operands is a NaN, and propagates the */
7681 /* appropriate result to res. When an sNaN is found, it is changed */
7682 /* to a qNaN and Invalid operation is set. */
7683 /* ------------------------------------------------------------------ */
7684 static decNumber
* decNaNs(decNumber
*res
, const decNumber
*lhs
,
7685 const decNumber
*rhs
, decContext
*set
,
7687 /* This decision tree ends up with LHS being the source pointer, */
7688 /* and status updated if need be */
7689 if (lhs
->bits
& DECSNAN
)
7690 *status
|=DEC_Invalid_operation
| DEC_sNaN
;
7691 else if (rhs
==NULL
);
7692 else if (rhs
->bits
& DECSNAN
) {
7694 *status
|=DEC_Invalid_operation
| DEC_sNaN
;
7696 else if (lhs
->bits
& DECNAN
);
7699 /* propagate the payload */
7700 if (lhs
->digits
<=set
->digits
) decNumberCopy(res
, lhs
); /* easy */
7701 else { /* too long */
7704 /* copy safe number of units, then decapitate */
7705 res
->bits
=lhs
->bits
; /* need sign etc. */
7706 uresp1
=res
->lsu
+D2U(set
->digits
);
7707 for (ur
=res
->lsu
, ul
=lhs
->lsu
; ur
<uresp1
; ur
++, ul
++) *ur
=*ul
;
7708 res
->digits
=D2U(set
->digits
)*DECDPUN
;
7709 /* maybe still too long */
7710 if (res
->digits
>set
->digits
) decDecap(res
, res
->digits
-set
->digits
);
7713 res
->bits
&=~DECSNAN
; /* convert any sNaN to NaN, while */
7714 res
->bits
|=DECNAN
; /* .. preserving sign */
7715 res
->exponent
=0; /* clean exponent */
7716 /* [coefficient was copied/decapitated] */
7720 /* ------------------------------------------------------------------ */
7721 /* decStatus -- apply non-zero status */
7723 /* dn is the number to set if error */
7724 /* status contains the current status (not yet in context) */
7725 /* set is the context */
7727 /* If the status is an error status, the number is set to a NaN, */
7728 /* unless the error was an overflow, divide-by-zero, or underflow, */
7729 /* in which case the number will have already been set. */
7731 /* The context status is then updated with the new status. Note that */
7732 /* this may raise a signal, so control may never return from this */
7733 /* routine (hence resources must be recovered before it is called). */
7734 /* ------------------------------------------------------------------ */
7735 static void decStatus(decNumber
*dn
, uInt status
, decContext
*set
) {
7736 if (status
& DEC_NaNs
) { /* error status -> NaN */
7737 /* if cause was an sNaN, clear and propagate [NaN is already set up] */
7738 if (status
& DEC_sNaN
) status
&=~DEC_sNaN
;
7740 decNumberZero(dn
); /* other error: clean throughout */
7741 dn
->bits
=DECNAN
; /* and make a quiet NaN */
7744 decContextSetStatus(set
, status
); /* [may not return] */
7748 /* ------------------------------------------------------------------ */
7749 /* decGetDigits -- count digits in a Units array */
7751 /* uar is the Unit array holding the number (this is often an */
7752 /* accumulator of some sort) */
7753 /* len is the length of the array in units [>=1] */
7755 /* returns the number of (significant) digits in the array */
7757 /* All leading zeros are excluded, except the last if the array has */
7758 /* only zero Units. */
7759 /* ------------------------------------------------------------------ */
7760 /* This may be called twice during some operations. */
7761 static Int
decGetDigits(Unit
*uar
, Int len
) {
7762 Unit
*up
=uar
+(len
-1); /* -> msu */
7763 Int digits
=(len
-1)*DECDPUN
+1; /* possible digits excluding msu */
7765 uInt
const *pow
; /* work */
7767 /* (at least 1 in final msu) */
7769 if (len
<1) printf("decGetDigits called with len<1 [%ld]\n", (LI
)len
);
7772 for (; up
>=uar
; up
--) {
7773 if (*up
==0) { /* unit is all 0s */
7774 if (digits
==1) break; /* a zero has one digit */
7775 digits
-=DECDPUN
; /* adjust for 0 unit */
7777 /* found the first (most significant) non-zero Unit */
7778 #if DECDPUN>1 /* not done yet */
7779 if (*up
<10) break; /* is 1-9 */
7781 #if DECDPUN>2 /* not done yet */
7782 if (*up
<100) break; /* is 10-99 */
7784 #if DECDPUN>3 /* not done yet */
7785 if (*up
<1000) break; /* is 100-999 */
7787 #if DECDPUN>4 /* count the rest ... */
7788 for (pow
=&powers
[4]; *up
>=*pow
; pow
++) digits
++;
7796 } /* decGetDigits */
7798 #if DECTRACE | DECCHECK
7799 /* ------------------------------------------------------------------ */
7800 /* decNumberShow -- display a number [debug aid] */
7801 /* dn is the number to show */
7803 /* Shows: sign, exponent, coefficient (msu first), digits */
7804 /* or: sign, special-value */
7805 /* ------------------------------------------------------------------ */
7806 /* this is public so other modules can use it */
7807 void decNumberShow(const decNumber
*dn
) {
7808 const Unit
*up
; /* work */
7811 char isign
='+'; /* main sign */
7815 if (decNumberIsNegative(dn
)) isign
='-';
7816 printf(" >> %c ", isign
);
7817 if (dn
->bits
&DECSPECIAL
) { /* Is a special value */
7818 if (decNumberIsInfinite(dn
)) printf("Infinity");
7820 if (dn
->bits
&DECSNAN
) printf("sNaN"); /* signalling NaN */
7823 /* if coefficient and exponent are 0, no more to do */
7824 if (dn
->exponent
==0 && dn
->digits
==1 && *dn
->lsu
==0) {
7827 /* drop through to report other information */
7831 /* now carefully display the coefficient */
7832 up
=dn
->lsu
+D2U(dn
->digits
)-1; /* msu */
7833 printf("%ld", (LI
)*up
);
7834 for (up
=up
-1; up
>=dn
->lsu
; up
--) {
7837 for (cut
=DECDPUN
-1; cut
>=0; cut
--) {
7840 printf("%ld", (LI
)d
);
7843 if (dn
->exponent
!=0) {
7845 if (dn
->exponent
<0) esign
='-';
7846 printf(" E%c%ld", esign
, (LI
)abs(dn
->exponent
));
7848 printf(" [%ld]\n", (LI
)dn
->digits
);
7849 } /* decNumberShow */
7852 #if DECTRACE || DECCHECK
7853 /* ------------------------------------------------------------------ */
7854 /* decDumpAr -- display a unit array [debug/check aid] */
7855 /* name is a single-character tag name */
7856 /* ar is the array to display */
7857 /* len is the length of the array in Units */
7858 /* ------------------------------------------------------------------ */
7859 static void decDumpAr(char name
, const Unit
*ar
, Int len
) {
7881 printf(" :%c: ", name
);
7882 for (i
=len
-1; i
>=0; i
--) {
7883 if (i
==len
-1) printf("%ld ", (LI
)ar
[i
]);
7884 else printf(spec
, ar
[i
]);
7891 /* ------------------------------------------------------------------ */
7892 /* decCheckOperands -- check operand(s) to a routine */
7893 /* res is the result structure (not checked; it will be set to */
7894 /* quiet NaN if error found (and it is not NULL)) */
7895 /* lhs is the first operand (may be DECUNRESU) */
7896 /* rhs is the second (may be DECUNUSED) */
7897 /* set is the context (may be DECUNCONT) */
7898 /* returns 0 if both operands, and the context are clean, or 1 */
7899 /* otherwise (in which case the context will show an error, */
7900 /* unless NULL). Note that res is not cleaned; caller should */
7901 /* handle this so res=NULL case is safe. */
7902 /* The caller is expected to abandon immediately if 1 is returned. */
7903 /* ------------------------------------------------------------------ */
7904 static Flag
decCheckOperands(decNumber
*res
, const decNumber
*lhs
,
7905 const decNumber
*rhs
, decContext
*set
) {
7907 if (set
==NULL
) { /* oops; hopeless */
7908 #if DECTRACE || DECVERB
7909 printf("Reference to context is NULL.\n");
7913 else if (set
!=DECUNCONT
7914 && (set
->digits
<1 || set
->round
>=DEC_ROUND_MAX
)) {
7916 #if DECTRACE || DECVERB
7917 printf("Bad context [digits=%ld round=%ld].\n",
7918 (LI
)set
->digits
, (LI
)set
->round
);
7925 /* this one not DECVERB as standard tests include NULL */
7926 printf("Reference to result is NULL.\n");
7929 if (!bad
&& lhs
!=DECUNUSED
) bad
=(decCheckNumber(lhs
));
7930 if (!bad
&& rhs
!=DECUNUSED
) bad
=(decCheckNumber(rhs
));
7933 if (set
!=DECUNCONT
) decContextSetStatus(set
, DEC_Invalid_operation
);
7934 if (res
!=DECUNRESU
&& res
!=NULL
) {
7936 res
->bits
=DECNAN
; /* qNaN */
7940 } /* decCheckOperands */
7942 /* ------------------------------------------------------------------ */
7943 /* decCheckNumber -- check a number */
7944 /* dn is the number to check */
7945 /* returns 0 if the number is clean, or 1 otherwise */
7947 /* The number is considered valid if it could be a result from some */
7948 /* operation in some valid context. */
7949 /* ------------------------------------------------------------------ */
7950 static Flag
decCheckNumber(const decNumber
*dn
) {
7951 const Unit
*up
; /* work */
7952 uInt maxuint
; /* .. */
7953 Int ae
, d
, digits
; /* .. */
7954 Int emin
, emax
; /* .. */
7956 if (dn
==NULL
) { /* hopeless */
7958 /* this one not DECVERB as standard tests include NULL */
7959 printf("Reference to decNumber is NULL.\n");
7963 /* check special values */
7964 if (dn
->bits
& DECSPECIAL
) {
7965 if (dn
->exponent
!=0) {
7966 #if DECTRACE || DECVERB
7967 printf("Exponent %ld (not 0) for a special value [%02x].\n",
7968 (LI
)dn
->exponent
, dn
->bits
);
7972 /* 2003.09.08: NaNs may now have coefficients, so next tests Inf only */
7973 if (decNumberIsInfinite(dn
)) {
7974 if (dn
->digits
!=1) {
7975 #if DECTRACE || DECVERB
7976 printf("Digits %ld (not 1) for an infinity.\n", (LI
)dn
->digits
);
7980 #if DECTRACE || DECVERB
7981 printf("LSU %ld (not 0) for an infinity.\n", (LI
)*dn
->lsu
);
7983 decDumpAr('I', dn
->lsu
, D2U(dn
->digits
));
7986 /* 2002.12.26: negative NaNs can now appear through proposed IEEE */
7987 /* concrete formats (decimal64, etc.). */
7991 /* check the coefficient */
7992 if (dn
->digits
<1 || dn
->digits
>DECNUMMAXP
) {
7993 #if DECTRACE || DECVERB
7994 printf("Digits %ld in number.\n", (LI
)dn
->digits
);
8000 for (up
=dn
->lsu
; d
>0; up
++) {
8001 if (d
>DECDPUN
) maxuint
=DECDPUNMAX
;
8002 else { /* reached the msu */
8003 maxuint
=powers
[d
]-1;
8004 if (dn
->digits
>1 && *up
<powers
[d
-1]) {
8005 #if DECTRACE || DECVERB
8006 printf("Leading 0 in number.\n");
8012 #if DECTRACE || DECVERB
8013 printf("Bad Unit [%08lx] in %ld-digit number at offset %ld [maxuint %ld].\n",
8014 (LI
)*up
, (LI
)dn
->digits
, (LI
)(up
-dn
->lsu
), (LI
)maxuint
);
8020 /* check the exponent. Note that input operands can have exponents */
8021 /* which are out of the set->emin/set->emax and set->digits range */
8022 /* (just as they can have more digits than set->digits). */
8023 ae
=dn
->exponent
+dn
->digits
-1; /* adjusted exponent */
8027 if (ae
<emin
-(digits
-1)) {
8028 #if DECTRACE || DECVERB
8029 printf("Adjusted exponent underflow [%ld].\n", (LI
)ae
);
8034 #if DECTRACE || DECVERB
8035 printf("Adjusted exponent overflow [%ld].\n", (LI
)ae
);
8040 return 0; /* it's OK */
8041 } /* decCheckNumber */
8043 /* ------------------------------------------------------------------ */
8044 /* decCheckInexact -- check a normal finite inexact result has digits */
8045 /* dn is the number to check */
8046 /* set is the context (for status and precision) */
8047 /* sets Invalid operation, etc., if some digits are missing */
8048 /* [this check is not made for DECSUBSET compilation or when */
8049 /* subnormal is not set] */
8050 /* ------------------------------------------------------------------ */
8051 static void decCheckInexact(const decNumber
*dn
, decContext
*set
) {
8052 #if !DECSUBSET && DECEXTFLAG
8053 if ((set
->status
& (DEC_Inexact
|DEC_Subnormal
))==DEC_Inexact
8054 && (set
->digits
!=dn
->digits
) && !(dn
->bits
& DECSPECIAL
)) {
8055 #if DECTRACE || DECVERB
8056 printf("Insufficient digits [%ld] on normal Inexact result.\n",
8060 decContextSetStatus(set
, DEC_Invalid_operation
);
8063 /* next is a noop for quiet compiler */
8064 if (dn
!=NULL
&& dn
->digits
==0) set
->status
|=DEC_Invalid_operation
;
8067 } /* decCheckInexact */
8073 /* ------------------------------------------------------------------ */
8074 /* decMalloc -- accountable allocation routine */
8075 /* n is the number of bytes to allocate */
8077 /* Semantics is the same as the stdlib malloc routine, but bytes */
8078 /* allocated are accounted for globally, and corruption fences are */
8079 /* added before and after the 'actual' storage. */
8080 /* ------------------------------------------------------------------ */
8081 /* This routine allocates storage with an extra twelve bytes; 8 are */
8082 /* at the start and hold: */
8083 /* 0-3 the original length requested */
8084 /* 4-7 buffer corruption detection fence (DECFENCE, x4) */
8085 /* The 4 bytes at the end also hold a corruption fence (DECFENCE, x4) */
8086 /* ------------------------------------------------------------------ */
8087 static void *decMalloc(size_t n
) {
8088 uInt size
=n
+12; /* true size */
8089 void *alloc
; /* -> allocated storage */
8090 uByte
*b
, *b0
; /* work */
8091 uInt uiwork
; /* for macros */
8093 alloc
=malloc(size
); /* -> allocated storage */
8094 if (alloc
==NULL
) return NULL
; /* out of strorage */
8095 b0
=(uByte
*)alloc
; /* as bytes */
8096 decAllocBytes
+=n
; /* account for storage */
8097 UBFROMUI(alloc
, n
); /* save n */
8098 /* printf(" alloc ++ dAB: %ld (%ld)\n", (LI)decAllocBytes, (LI)n); */
8099 for (b
=b0
+4; b
<b0
+8; b
++) *b
=DECFENCE
;
8100 for (b
=b0
+n
+8; b
<b0
+n
+12; b
++) *b
=DECFENCE
;
8101 return b0
+8; /* -> play area */
8104 /* ------------------------------------------------------------------ */
8105 /* decFree -- accountable free routine */
8106 /* alloc is the storage to free */
8108 /* Semantics is the same as the stdlib malloc routine, except that */
8109 /* the global storage accounting is updated and the fences are */
8110 /* checked to ensure that no routine has written 'out of bounds'. */
8111 /* ------------------------------------------------------------------ */
8112 /* This routine first checks that the fences have not been corrupted. */
8113 /* It then frees the storage using the 'truw' storage address (that */
8114 /* is, offset by 8). */
8115 /* ------------------------------------------------------------------ */
8116 static void decFree(void *alloc
) {
8117 uInt n
; /* original length */
8118 uByte
*b
, *b0
; /* work */
8119 uInt uiwork
; /* for macros */
8121 if (alloc
==NULL
) return; /* allowed; it's a nop */
8122 b0
=(uByte
*)alloc
; /* as bytes */
8123 b0
-=8; /* -> true start of storage */
8124 n
=UBTOUI(b0
); /* lift length */
8125 for (b
=b0
+4; b
<b0
+8; b
++) if (*b
!=DECFENCE
)
8126 printf("=== Corrupt byte [%02x] at offset %d from %ld ===\n", *b
,
8128 for (b
=b0
+n
+8; b
<b0
+n
+12; b
++) if (*b
!=DECFENCE
)
8129 printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b
,
8130 b
-b0
-8, (LI
)b0
, (LI
)n
);
8131 free(b0
); /* drop the storage */
8132 decAllocBytes
-=n
; /* account for storage */
8133 /* printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n); */
8135 #define malloc(a) decMalloc(a)
8136 #define free(a) decFree(a)
This page took 0.394607 seconds and 4 git commands to generate.