Mercurial > hg > CbC > CbC_gcc

comparison libdecnumber/decNumber.c @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children 77e2b8dfacca
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
1 /* Decimal number arithmetic module for the decNumber C Library.
2 Copyright (C) 2005, 2007, 2009 Free Software Foundation, Inc.
3 Contributed by IBM Corporation. Author Mike Cowlishaw.
4
5 This file is part of GCC.
6
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
10 version.
11
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
15 for more details.
16
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.
20
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/>. */
25
26 /* ------------------------------------------------------------------ */
27 /* Decimal Number arithmetic module */
28 /* ------------------------------------------------------------------ */
29 /* This module comprises the routines for General Decimal Arithmetic */
30 /* as defined in the specification which may be found on the */
31 /* http://www2.hursley.ibm.com/decimal web pages. It implements both */
32 /* the full ('extended') arithmetic and the simpler ('subset') */
33 /* arithmetic. */
34 /* */
35 /* Usage notes: */
36 /* */
37 /* 1. This code is ANSI C89 except: */
38 /* */
39 /* If DECDPUN>4 or DECUSE64=1, the C99 64-bit int64_t and */
40 /* uint64_t types may be used. To avoid these, set DECUSE64=0 */
41 /* and DECDPUN<=4 (see documentation). */
42 /* */
43 /* 2. The decNumber format which this library uses is optimized for */
44 /* efficient processing of relatively short numbers; in particular */
45 /* it allows the use of fixed sized structures and minimizes copy */
46 /* and move operations. It does, however, support arbitrary */
47 /* precision (up to 999,999,999 digits) and arbitrary exponent */
48 /* range (Emax in the range 0 through 999,999,999 and Emin in the */
49 /* range -999,999,999 through 0). Mathematical functions (for */
50 /* example decNumberExp) as identified below are restricted more */
51 /* tightly: digits, emax, and -emin in the context must be <= */
52 /* DEC_MAX_MATH (999999), and their operand(s) must be within */
53 /* these bounds. */
54 /* */
55 /* 3. Logical functions are further restricted; their operands must */
56 /* be finite, positive, have an exponent of zero, and all digits */
57 /* must be either 0 or 1. The result will only contain digits */
58 /* which are 0 or 1 (and will have exponent=0 and a sign of 0). */
59 /* */
60 /* 4. Operands to operator functions are never modified unless they */
61 /* are also specified to be the result number (which is always */
62 /* permitted). Other than that case, operands must not overlap. */
63 /* */
64 /* 5. Error handling: the type of the error is ORed into the status */
65 /* flags in the current context (decContext structure). The */
66 /* SIGFPE signal is then raised if the corresponding trap-enabler */
67 /* flag in the decContext is set (is 1). */
68 /* */
69 /* It is the responsibility of the caller to clear the status */
70 /* flags as required. */
71 /* */
72 /* The result of any routine which returns a number will always */
73 /* be a valid number (which may be a special value, such as an */
74 /* Infinity or NaN). */
75 /* */
76 /* 6. The decNumber format is not an exchangeable concrete */
77 /* representation as it comprises fields which may be machine- */
78 /* dependent (packed or unpacked, or special length, for example). */
79 /* Canonical conversions to and from strings are provided; other */
80 /* conversions are available in separate modules. */
81 /* */
82 /* 7. Normally, input operands are assumed to be valid. Set DECCHECK */
83 /* to 1 for extended operand checking (including NULL operands). */
84 /* Results are undefined if a badly-formed structure (or a NULL */
85 /* pointer to a structure) is provided, though with DECCHECK */
86 /* enabled the operator routines are protected against exceptions. */
87 /* (Except if the result pointer is NULL, which is unrecoverable.) */
88 /* */
89 /* However, the routines will never cause exceptions if they are */
90 /* given well-formed operands, even if the value of the operands */
91 /* is inappropriate for the operation and DECCHECK is not set. */
92 /* (Except for SIGFPE, as and where documented.) */
93 /* */
94 /* 8. Subset arithmetic is available only if DECSUBSET is set to 1. */
95 /* ------------------------------------------------------------------ */
96 /* Implementation notes for maintenance of this module: */
97 /* */
98 /* 1. Storage leak protection: Routines which use malloc are not */
99 /* permitted to use return for fastpath or error exits (i.e., */
100 /* they follow strict structured programming conventions). */
101 /* Instead they have a do{}while(0); construct surrounding the */
102 /* code which is protected -- break may be used to exit this. */
103 /* Other routines can safely use the return statement inline. */
104 /* */
105 /* Storage leak accounting can be enabled using DECALLOC. */
106 /* */
107 /* 2. All loops use the for(;;) construct. Any do construct does */
108 /* not loop; it is for allocation protection as just described. */
109 /* */
110 /* 3. Setting status in the context must always be the very last */
111 /* action in a routine, as non-0 status may raise a trap and hence */
112 /* the call to set status may not return (if the handler uses long */
113 /* jump). Therefore all cleanup must be done first. In general, */
114 /* to achieve this status is accumulated and is only applied just */
115 /* before return by calling decContextSetStatus (via decStatus). */
116 /* */
117 /* Routines which allocate storage cannot, in general, use the */
118 /* 'top level' routines which could cause a non-returning */
119 /* transfer of control. The decXxxxOp routines are safe (do not */
120 /* call decStatus even if traps are set in the context) and should */
121 /* be used instead (they are also a little faster). */
122 /* */
123 /* 4. Exponent checking is minimized by allowing the exponent to */
124 /* grow outside its limits during calculations, provided that */
125 /* the decFinalize function is called later. Multiplication and */
126 /* division, and intermediate calculations in exponentiation, */
127 /* require more careful checks because of the risk of 31-bit */
128 /* overflow (the most negative valid exponent is -1999999997, for */
129 /* a 999999999-digit number with adjusted exponent of -999999999). */
130 /* */
131 /* 5. Rounding is deferred until finalization of results, with any */
132 /* 'off to the right' data being represented as a single digit */
133 /* residue (in the range -1 through 9). This avoids any double- */
134 /* rounding when more than one shortening takes place (for */
135 /* example, when a result is subnormal). */
136 /* */
137 /* 6. The digits count is allowed to rise to a multiple of DECDPUN */
138 /* during many operations, so whole Units are handled and exact */
139 /* accounting of digits is not needed. The correct digits value */
140 /* is found by decGetDigits, which accounts for leading zeros. */
141 /* This must be called before any rounding if the number of digits */
142 /* is not known exactly. */
143 /* */
144 /* 7. The multiply-by-reciprocal 'trick' is used for partitioning */
145 /* numbers up to four digits, using appropriate constants. This */
146 /* is not useful for longer numbers because overflow of 32 bits */
147 /* would lead to 4 multiplies, which is almost as expensive as */
148 /* a divide (unless a floating-point or 64-bit multiply is */
149 /* assumed to be available). */
150 /* */
151 /* 8. Unusual abbreviations that may be used in the commentary: */
152 /* lhs -- left hand side (operand, of an operation) */
153 /* lsd -- least significant digit (of coefficient) */
154 /* lsu -- least significant Unit (of coefficient) */
155 /* msd -- most significant digit (of coefficient) */
156 /* msi -- most significant item (in an array) */
157 /* msu -- most significant Unit (of coefficient) */
158 /* rhs -- right hand side (operand, of an operation) */
159 /* +ve -- positive */
160 /* -ve -- negative */
161 /* ** -- raise to the power */
162 /* ------------------------------------------------------------------ */
163
164 #include <stdlib.h> /* for malloc, free, etc. */
165 #include <stdio.h> /* for printf [if needed] */
166 #include <string.h> /* for strcpy */
167 #include <ctype.h> /* for lower */
168 #include "dconfig.h" /* for GCC definitions */
169 #include "decNumber.h" /* base number library */
170 #include "decNumberLocal.h" /* decNumber local types, etc. */
171
172 /* Constants */
173 /* Public lookup table used by the D2U macro */
174 const uByte d2utable[DECMAXD2U+1]=D2UTABLE;
175
176 #define DECVERB 1 /* set to 1 for verbose DECCHECK */
177 #define powers DECPOWERS /* old internal name */
178
179 /* Local constants */
180 #define DIVIDE 0x80 /* Divide operators */
181 #define REMAINDER 0x40 /* .. */
182 #define DIVIDEINT 0x20 /* .. */
183 #define REMNEAR 0x10 /* .. */
184 #define COMPARE 0x01 /* Compare operators */
185 #define COMPMAX 0x02 /* .. */
186 #define COMPMIN 0x03 /* .. */
187 #define COMPTOTAL 0x04 /* .. */
188 #define COMPNAN 0x05 /* .. [NaN processing] */
189 #define COMPSIG 0x06 /* .. [signaling COMPARE] */
190 #define COMPMAXMAG 0x07 /* .. */
191 #define COMPMINMAG 0x08 /* .. */
192
193 #define DEC_sNaN 0x40000000 /* local status: sNaN signal */
194 #define BADINT (Int)0x80000000 /* most-negative Int; error indicator */
195 /* Next two indicate an integer >= 10**6, and its parity (bottom bit) */
196 #define BIGEVEN (Int)0x80000002
197 #define BIGODD (Int)0x80000003
198
199 static Unit uarrone[1]={1}; /* Unit array of 1, used for incrementing */
200
201 /* Granularity-dependent code */
202 #if DECDPUN<=4
203 #define eInt Int /* extended integer */
204 #define ueInt uInt /* unsigned extended integer */
205 /* Constant multipliers for divide-by-power-of five using reciprocal */
206 /* multiply, after removing powers of 2 by shifting, and final shift */
207 /* of 17 [we only need up to **4] */
208 static const uInt multies[]={131073, 26215, 5243, 1049, 210};
209 /* QUOT10 -- macro to return the quotient of unit u divided by 10**n */
210 #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
211 #else
212 /* For DECDPUN>4 non-ANSI-89 64-bit types are needed. */
213 #if !DECUSE64
214 #error decNumber.c: DECUSE64 must be 1 when DECDPUN>4
215 #endif
216 #define eInt Long /* extended integer */
217 #define ueInt uLong /* unsigned extended integer */
218 #endif
219
220 /* Local routines */
221 static decNumber * decAddOp(decNumber *, const decNumber *, const decNumber *,
222 decContext *, uByte, uInt *);
223 static Flag decBiStr(const char *, const char *, const char *);
224 static uInt decCheckMath(const decNumber *, decContext *, uInt *);
225 static void decApplyRound(decNumber *, decContext *, Int, uInt *);
226 static Int decCompare(const decNumber *lhs, const decNumber *rhs, Flag);
227 static decNumber * decCompareOp(decNumber *, const decNumber *,
228 const decNumber *, decContext *,
229 Flag, uInt *);
230 static void decCopyFit(decNumber *, const decNumber *, decContext *,
231 Int *, uInt *);
232 static decNumber * decDecap(decNumber *, Int);
233 static decNumber * decDivideOp(decNumber *, const decNumber *,
234 const decNumber *, decContext *, Flag, uInt *);
235 static decNumber * decExpOp(decNumber *, const decNumber *,
236 decContext *, uInt *);
237 static void decFinalize(decNumber *, decContext *, Int *, uInt *);
238 static Int decGetDigits(Unit *, Int);
239 static Int decGetInt(const decNumber *);
240 static decNumber * decLnOp(decNumber *, const decNumber *,
241 decContext *, uInt *);
242 static decNumber * decMultiplyOp(decNumber *, const decNumber *,
243 const decNumber *, decContext *,
244 uInt *);
245 static decNumber * decNaNs(decNumber *, const decNumber *,
246 const decNumber *, decContext *, uInt *);
247 static decNumber * decQuantizeOp(decNumber *, const decNumber *,
248 const decNumber *, decContext *, Flag,
249 uInt *);
250 static void decReverse(Unit *, Unit *);
251 static void decSetCoeff(decNumber *, decContext *, const Unit *,
252 Int, Int *, uInt *);
253 static void decSetMaxValue(decNumber *, decContext *);
254 static void decSetOverflow(decNumber *, decContext *, uInt *);
255 static void decSetSubnormal(decNumber *, decContext *, Int *, uInt *);
256 static Int decShiftToLeast(Unit *, Int, Int);
257 static Int decShiftToMost(Unit *, Int, Int);
258 static void decStatus(decNumber *, uInt, decContext *);
259 static void decToString(const decNumber *, char[], Flag);
260 static decNumber * decTrim(decNumber *, decContext *, Flag, Int *);
261 static Int decUnitAddSub(const Unit *, Int, const Unit *, Int, Int,
262 Unit *, Int);
263 static Int decUnitCompare(const Unit *, Int, const Unit *, Int, Int);
264
265 #if !DECSUBSET
266 /* decFinish == decFinalize when no subset arithmetic needed */
267 #define decFinish(a,b,c,d) decFinalize(a,b,c,d)
268 #else
269 static void decFinish(decNumber *, decContext *, Int *, uInt *);
270 static decNumber * decRoundOperand(const decNumber *, decContext *, uInt *);
271 #endif
272
273 /* Local macros */
274 /* masked special-values bits */
275 #define SPECIALARG (rhs->bits & DECSPECIAL)
276 #define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL)
277
278 /* Diagnostic macros, etc. */
279 #if DECALLOC
280 /* Handle malloc/free accounting. If enabled, our accountable routines */
281 /* are used; otherwise the code just goes straight to the system malloc */
282 /* and free routines. */
283 #define malloc(a) decMalloc(a)
284 #define free(a) decFree(a)
285 #define DECFENCE 0x5a /* corruption detector */
286 /* 'Our' malloc and free: */
287 static void *decMalloc(size_t);
288 static void decFree(void *);
289 uInt decAllocBytes=0; /* count of bytes allocated */
290 /* Note that DECALLOC code only checks for storage buffer overflow. */
291 /* To check for memory leaks, the decAllocBytes variable must be */
292 /* checked to be 0 at appropriate times (e.g., after the test */
293 /* harness completes a set of tests). This checking may be unreliable */
294 /* if the testing is done in a multi-thread environment. */
295 #endif
296
297 #if DECCHECK
298 /* Optional checking routines. Enabling these means that decNumber */
299 /* and decContext operands to operator routines are checked for */
300 /* correctness. This roughly doubles the execution time of the */
301 /* fastest routines (and adds 600+ bytes), so should not normally be */
302 /* used in 'production'. */
303 /* decCheckInexact is used to check that inexact results have a full */
304 /* complement of digits (where appropriate -- this is not the case */
305 /* for Quantize, for example) */
306 #define DECUNRESU ((decNumber *)(void *)0xffffffff)
307 #define DECUNUSED ((const decNumber *)(void *)0xffffffff)
308 #define DECUNCONT ((decContext *)(void *)(0xffffffff))
309 static Flag decCheckOperands(decNumber *, const decNumber *,
310 const decNumber *, decContext *);
311 static Flag decCheckNumber(const decNumber *);
312 static void decCheckInexact(const decNumber *, decContext *);
313 #endif
314
315 #if DECTRACE || DECCHECK
316 /* Optional trace/debugging routines (may or may not be used) */
317 void decNumberShow(const decNumber *); /* displays the components of a number */
318 static void decDumpAr(char, const Unit *, Int);
319 #endif
320
321 /* ================================================================== */
322 /* Conversions */
323 /* ================================================================== */
324
325 /* ------------------------------------------------------------------ */
326 /* from-int32 -- conversion from Int or uInt */
327 /* */
328 /* dn is the decNumber to receive the integer */
329 /* in or uin is the integer to be converted */
330 /* returns dn */
331 /* */
332 /* No error is possible. */
333 /* ------------------------------------------------------------------ */
334 decNumber * decNumberFromInt32(decNumber *dn, Int in) {
335 uInt unsig;
336 if (in>=0) unsig=in;
337 else { /* negative (possibly BADINT) */
338 if (in==BADINT) unsig=(uInt)1073741824*2; /* special case */
339 else unsig=-in; /* invert */
340 }
341 /* in is now positive */
342 decNumberFromUInt32(dn, unsig);
343 if (in<0) dn->bits=DECNEG; /* sign needed */
344 return dn;
345 } /* decNumberFromInt32 */
346
347 decNumber * decNumberFromUInt32(decNumber *dn, uInt uin) {
348 Unit *up; /* work pointer */
349 decNumberZero(dn); /* clean */
350 if (uin==0) return dn; /* [or decGetDigits bad call] */
351 for (up=dn->lsu; uin>0; up++) {
352 *up=(Unit)(uin%(DECDPUNMAX+1));
353 uin=uin/(DECDPUNMAX+1);
354 }
355 dn->digits=decGetDigits(dn->lsu, up-dn->lsu);
356 return dn;
357 } /* decNumberFromUInt32 */
358
359 /* ------------------------------------------------------------------ */
360 /* to-int32 -- conversion to Int or uInt */
361 /* */
362 /* dn is the decNumber to convert */
363 /* set is the context for reporting errors */
364 /* returns the converted decNumber, or 0 if Invalid is set */
365 /* */
366 /* Invalid is set if the decNumber does not have exponent==0 or if */
367 /* it is a NaN, Infinite, or out-of-range. */
368 /* ------------------------------------------------------------------ */
369 Int decNumberToInt32(const decNumber *dn, decContext *set) {
370 #if DECCHECK
371 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
372 #endif
373
374 /* special or too many digits, or bad exponent */
375 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; /* bad */
376 else { /* is a finite integer with 10 or fewer digits */
377 Int d; /* work */
378 const Unit *up; /* .. */
379 uInt hi=0, lo; /* .. */
380 up=dn->lsu; /* -> lsu */
381 lo=*up; /* get 1 to 9 digits */
382 #if DECDPUN>1 /* split to higher */
383 hi=lo/10;
384 lo=lo%10;
385 #endif
386 up++;
387 /* collect remaining Units, if any, into hi */
388 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
389 /* now low has the lsd, hi the remainder */
390 if (hi>214748364 || (hi==214748364 && lo>7)) { /* out of range? */
391 /* most-negative is a reprieve */
392 if (dn->bits&DECNEG && hi==214748364 && lo==8) return 0x80000000;
393 /* bad -- drop through */
394 }
395 else { /* in-range always */
396 Int i=X10(hi)+lo;
397 if (dn->bits&DECNEG) return -i;
398 return i;
399 }
400 } /* integer */
401 decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
402 return 0;
403 } /* decNumberToInt32 */
404
405 uInt decNumberToUInt32(const decNumber *dn, decContext *set) {
406 #if DECCHECK
407 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
408 #endif
409 /* special or too many digits, or bad exponent, or negative (<0) */
410 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0
411 || (dn->bits&DECNEG && !ISZERO(dn))); /* bad */
412 else { /* is a finite integer with 10 or fewer digits */
413 Int d; /* work */
414 const Unit *up; /* .. */
415 uInt hi=0, lo; /* .. */
416 up=dn->lsu; /* -> lsu */
417 lo=*up; /* get 1 to 9 digits */
418 #if DECDPUN>1 /* split to higher */
419 hi=lo/10;
420 lo=lo%10;
421 #endif
422 up++;
423 /* collect remaining Units, if any, into hi */
424 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
425
426 /* now low has the lsd, hi the remainder */
427 if (hi>429496729 || (hi==429496729 && lo>5)) ; /* no reprieve possible */
428 else return X10(hi)+lo;
429 } /* integer */
430 decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
431 return 0;
432 } /* decNumberToUInt32 */
433
434 /* ------------------------------------------------------------------ */
435 /* to-scientific-string -- conversion to numeric string */
436 /* to-engineering-string -- conversion to numeric string */
437 /* */
438 /* decNumberToString(dn, string); */
439 /* decNumberToEngString(dn, string); */
440 /* */
441 /* dn is the decNumber to convert */
442 /* string is the string where the result will be laid out */
443 /* */
444 /* string must be at least dn->digits+14 characters long */
445 /* */
446 /* No error is possible, and no status can be set. */
447 /* ------------------------------------------------------------------ */
448 char * decNumberToString(const decNumber *dn, char *string){
449 decToString(dn, string, 0);
450 return string;
451 } /* DecNumberToString */
452
453 char * decNumberToEngString(const decNumber *dn, char *string){
454 decToString(dn, string, 1);
455 return string;
456 } /* DecNumberToEngString */
457
458 /* ------------------------------------------------------------------ */
459 /* to-number -- conversion from numeric string */
460 /* */
461 /* decNumberFromString -- convert string to decNumber */
462 /* dn -- the number structure to fill */
463 /* chars[] -- the string to convert ('\0' terminated) */
464 /* set -- the context used for processing any error, */
465 /* determining the maximum precision available */
466 /* (set.digits), determining the maximum and minimum */
467 /* exponent (set.emax and set.emin), determining if */
468 /* extended values are allowed, and checking the */
469 /* rounding mode if overflow occurs or rounding is */
470 /* needed. */
471 /* */
472 /* The length of the coefficient and the size of the exponent are */
473 /* checked by this routine, so the correct error (Underflow or */
474 /* Overflow) can be reported or rounding applied, as necessary. */
475 /* */
476 /* If bad syntax is detected, the result will be a quiet NaN. */
477 /* ------------------------------------------------------------------ */
478 decNumber * decNumberFromString(decNumber *dn, const char chars[],
479 decContext *set) {
480 Int exponent=0; /* working exponent [assume 0] */
481 uByte bits=0; /* working flags [assume +ve] */
482 Unit *res; /* where result will be built */
483 Unit resbuff[SD2U(DECBUFFER+9)];/* local buffer in case need temporary */
484 /* [+9 allows for ln() constants] */
485 Unit *allocres=NULL; /* -> allocated result, iff allocated */
486 Int d=0; /* count of digits found in decimal part */
487 const char *dotchar=NULL; /* where dot was found */
488 const char *cfirst=chars; /* -> first character of decimal part */
489 const char *last=NULL; /* -> last digit of decimal part */
490 const char *c; /* work */
491 Unit *up; /* .. */
492 #if DECDPUN>1
493 Int cut, out; /* .. */
494 #endif
495 Int residue; /* rounding residue */
496 uInt status=0; /* error code */
497
498 #if DECCHECK
499 if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set))
500 return decNumberZero(dn);
501 #endif
502
503 do { /* status & malloc protection */
504 for (c=chars;; c++) { /* -> input character */
505 if (*c>='0' && *c<='9') { /* test for Arabic digit */
506 last=c;
507 d++; /* count of real digits */
508 continue; /* still in decimal part */
509 }
510 if (*c=='.' && dotchar==NULL) { /* first '.' */
511 dotchar=c; /* record offset into decimal part */
512 if (c==cfirst) cfirst++; /* first digit must follow */
513 continue;}
514 if (c==chars) { /* first in string... */
515 if (*c=='-') { /* valid - sign */
516 cfirst++;
517 bits=DECNEG;
518 continue;}
519 if (*c=='+') { /* valid + sign */
520 cfirst++;
521 continue;}
522 }
523 /* *c is not a digit, or a valid +, -, or '.' */
524 break;
525 } /* c */
526
527 if (last==NULL) { /* no digits yet */
528 status=DEC_Conversion_syntax;/* assume the worst */
529 if (*c=='\0') break; /* and no more to come... */
530 #if DECSUBSET
531 /* if subset then infinities and NaNs are not allowed */
532 if (!set->extended) break; /* hopeless */
533 #endif
534 /* Infinities and NaNs are possible, here */
535 if (dotchar!=NULL) break; /* .. unless had a dot */
536 decNumberZero(dn); /* be optimistic */
537 if (decBiStr(c, "infinity", "INFINITY")
538 || decBiStr(c, "inf", "INF")) {
539 dn->bits=bits | DECINF;
540 status=0; /* is OK */
541 break; /* all done */
542 }
543 /* a NaN expected */
544 /* 2003.09.10 NaNs are now permitted to have a sign */
545 dn->bits=bits | DECNAN; /* assume simple NaN */
546 if (*c=='s' || *c=='S') { /* looks like an sNaN */
547 c++;
548 dn->bits=bits | DECSNAN;
549 }
550 if (*c!='n' && *c!='N') break; /* check caseless "NaN" */
551 c++;
552 if (*c!='a' && *c!='A') break; /* .. */
553 c++;
554 if (*c!='n' && *c!='N') break; /* .. */
555 c++;
556 /* now either nothing, or nnnn payload, expected */
557 /* -> start of integer and skip leading 0s [including plain 0] */
558 for (cfirst=c; *cfirst=='0';) cfirst++;
559 if (*cfirst=='\0') { /* "NaN" or "sNaN", maybe with all 0s */
560 status=0; /* it's good */
561 break; /* .. */
562 }
563 /* something other than 0s; setup last and d as usual [no dots] */
564 for (c=cfirst;; c++, d++) {
565 if (*c<'0' || *c>'9') break; /* test for Arabic digit */
566 last=c;
567 }
568 if (*c!='\0') break; /* not all digits */
569 if (d>set->digits-1) {
570 /* [NB: payload in a decNumber can be full length unless */
571 /* clamped, in which case can only be digits-1] */
572 if (set->clamp) break;
573 if (d>set->digits) break;
574 } /* too many digits? */
575 /* good; drop through to convert the integer to coefficient */
576 status=0; /* syntax is OK */
577 bits=dn->bits; /* for copy-back */
578 } /* last==NULL */
579
580 else if (*c!='\0') { /* more to process... */
581 /* had some digits; exponent is only valid sequence now */
582 Flag nege; /* 1=negative exponent */
583 const char *firstexp; /* -> first significant exponent digit */
584 status=DEC_Conversion_syntax;/* assume the worst */
585 if (*c!='e' && *c!='E') break;
586 /* Found 'e' or 'E' -- now process explicit exponent */
587 /* 1998.07.11: sign no longer required */
588 nege=0;
589 c++; /* to (possible) sign */
590 if (*c=='-') {nege=1; c++;}
591 else if (*c=='+') c++;
592 if (*c=='\0') break;
593
594 for (; *c=='0' && *(c+1)!='\0';) c++; /* strip insignificant zeros */
595 firstexp=c; /* save exponent digit place */
596 for (; ;c++) {
597 if (*c<'0' || *c>'9') break; /* not a digit */
598 exponent=X10(exponent)+(Int)*c-(Int)'0';
599 } /* c */
600 /* if not now on a '\0', *c must not be a digit */
601 if (*c!='\0') break;
602
603 /* (this next test must be after the syntax checks) */
604 /* if it was too long the exponent may have wrapped, so check */
605 /* carefully and set it to a certain overflow if wrap possible */
606 if (c>=firstexp+9+1) {
607 if (c>firstexp+9+1 || *firstexp>'1') exponent=DECNUMMAXE*2;
608 /* [up to 1999999999 is OK, for example 1E-1000000998] */
609 }
610 if (nege) exponent=-exponent; /* was negative */
611 status=0; /* is OK */
612 } /* stuff after digits */
613
614 /* Here when whole string has been inspected; syntax is good */
615 /* cfirst->first digit (never dot), last->last digit (ditto) */
616
617 /* strip leading zeros/dot [leave final 0 if all 0's] */
618 if (*cfirst=='0') { /* [cfirst has stepped over .] */
619 for (c=cfirst; c<last; c++, cfirst++) {
620 if (*c=='.') continue; /* ignore dots */
621 if (*c!='0') break; /* non-zero found */
622 d--; /* 0 stripped */
623 } /* c */
624 #if DECSUBSET
625 /* make a rapid exit for easy zeros if !extended */
626 if (*cfirst=='0' && !set->extended) {
627 decNumberZero(dn); /* clean result */
628 break; /* [could be return] */
629 }
630 #endif
631 } /* at least one leading 0 */
632
633 /* Handle decimal point... */
634 if (dotchar!=NULL && dotchar<last) /* non-trailing '.' found? */
635 exponent-=(last-dotchar); /* adjust exponent */
636 /* [we can now ignore the .] */
637
638 /* OK, the digits string is good. Assemble in the decNumber, or in */
639 /* a temporary units array if rounding is needed */
640 if (d<=set->digits) res=dn->lsu; /* fits into supplied decNumber */
641 else { /* rounding needed */
642 Int needbytes=D2U(d)*sizeof(Unit);/* bytes needed */
643 res=resbuff; /* assume use local buffer */
644 if (needbytes>(Int)sizeof(resbuff)) { /* too big for local */
645 allocres=(Unit *)malloc(needbytes);
646 if (allocres==NULL) {status|=DEC_Insufficient_storage; break;}
647 res=allocres;
648 }
649 }
650 /* res now -> number lsu, buffer, or allocated storage for Unit array */
651
652 /* Place the coefficient into the selected Unit array */
653 /* [this is often 70% of the cost of this function when DECDPUN>1] */
654 #if DECDPUN>1
655 out=0; /* accumulator */
656 up=res+D2U(d)-1; /* -> msu */
657 cut=d-(up-res)*DECDPUN; /* digits in top unit */
658 for (c=cfirst;; c++) { /* along the digits */
659 if (*c=='.') continue; /* ignore '.' [don't decrement cut] */
660 out=X10(out)+(Int)*c-(Int)'0';
661 if (c==last) break; /* done [never get to trailing '.'] */
662 cut--;
663 if (cut>0) continue; /* more for this unit */
664 *up=(Unit)out; /* write unit */
665 up--; /* prepare for unit below.. */
666 cut=DECDPUN; /* .. */
667 out=0; /* .. */
668 } /* c */
669 *up=(Unit)out; /* write lsu */
670
671 #else
672 /* DECDPUN==1 */
673 up=res; /* -> lsu */
674 for (c=last; c>=cfirst; c--) { /* over each character, from least */
675 if (*c=='.') continue; /* ignore . [don't step up] */
676 *up=(Unit)((Int)*c-(Int)'0');
677 up++;
678 } /* c */
679 #endif
680
681 dn->bits=bits;
682 dn->exponent=exponent;
683 dn->digits=d;
684
685 /* if not in number (too long) shorten into the number */
686 if (d>set->digits) {
687 residue=0;
688 decSetCoeff(dn, set, res, d, &residue, &status);
689 /* always check for overflow or subnormal and round as needed */
690 decFinalize(dn, set, &residue, &status);
691 }
692 else { /* no rounding, but may still have overflow or subnormal */
693 /* [these tests are just for performance; finalize repeats them] */
694 if ((dn->exponent-1<set->emin-dn->digits)
695 || (dn->exponent-1>set->emax-set->digits)) {
696 residue=0;
697 decFinalize(dn, set, &residue, &status);
698 }
699 }
700 /* decNumberShow(dn); */
701 } while(0); /* [for break] */
702
703 if (allocres!=NULL) free(allocres); /* drop any storage used */
704 if (status!=0) decStatus(dn, status, set);
705 return dn;
706 } /* decNumberFromString */
707
708 /* ================================================================== */
709 /* Operators */
710 /* ================================================================== */
711
712 /* ------------------------------------------------------------------ */
713 /* decNumberAbs -- absolute value operator */
714 /* */
715 /* This computes C = abs(A) */
716 /* */
717 /* res is C, the result. C may be A */
718 /* rhs is A */
719 /* set is the context */
720 /* */
721 /* See also decNumberCopyAbs for a quiet bitwise version of this. */
722 /* C must have space for set->digits digits. */
723 /* ------------------------------------------------------------------ */
724 /* This has the same effect as decNumberPlus unless A is negative, */
725 /* in which case it has the same effect as decNumberMinus. */
726 /* ------------------------------------------------------------------ */
727 decNumber * decNumberAbs(decNumber *res, const decNumber *rhs,
728 decContext *set) {
729 decNumber dzero; /* for 0 */
730 uInt status=0; /* accumulator */
731
732 #if DECCHECK
733 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
734 #endif
735
736 decNumberZero(&dzero); /* set 0 */
737 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */
738 decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status);
739 if (status!=0) decStatus(res, status, set);
740 #if DECCHECK
741 decCheckInexact(res, set);
742 #endif
743 return res;
744 } /* decNumberAbs */
745
746 /* ------------------------------------------------------------------ */
747 /* decNumberAdd -- add two Numbers */
748 /* */
749 /* This computes C = A + B */
750 /* */
751 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */
752 /* lhs is A */
753 /* rhs is B */
754 /* set is the context */
755 /* */
756 /* C must have space for set->digits digits. */
757 /* ------------------------------------------------------------------ */
758 /* This just calls the routine shared with Subtract */
759 decNumber * decNumberAdd(decNumber *res, const decNumber *lhs,
760 const decNumber *rhs, decContext *set) {
761 uInt status=0; /* accumulator */
762 decAddOp(res, lhs, rhs, set, 0, &status);
763 if (status!=0) decStatus(res, status, set);
764 #if DECCHECK
765 decCheckInexact(res, set);
766 #endif
767 return res;
768 } /* decNumberAdd */
769
770 /* ------------------------------------------------------------------ */
771 /* decNumberAnd -- AND two Numbers, digitwise */
772 /* */
773 /* This computes C = A & B */
774 /* */
775 /* res is C, the result. C may be A and/or B (e.g., X=X&X) */
776 /* lhs is A */
777 /* rhs is B */
778 /* set is the context (used for result length and error report) */
779 /* */
780 /* C must have space for set->digits digits. */
781 /* */
782 /* Logical function restrictions apply (see above); a NaN is */
783 /* returned with Invalid_operation if a restriction is violated. */
784 /* ------------------------------------------------------------------ */
785 decNumber * decNumberAnd(decNumber *res, const decNumber *lhs,
786 const decNumber *rhs, decContext *set) {
787 const Unit *ua, *ub; /* -> operands */
788 const Unit *msua, *msub; /* -> operand msus */
789 Unit *uc, *msuc; /* -> result and its msu */
790 Int msudigs; /* digits in res msu */
791 #if DECCHECK
792 if (decCheckOperands(res, lhs, rhs, set)) return res;
793 #endif
794
795 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
796 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
797 decStatus(res, DEC_Invalid_operation, set);
798 return res;
799 }
800
801 /* operands are valid */
802 ua=lhs->lsu; /* bottom-up */
803 ub=rhs->lsu; /* .. */
804 uc=res->lsu; /* .. */
805 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */
806 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */
807 msuc=uc+D2U(set->digits)-1; /* -> msu of result */
808 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */
809 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */
810 Unit a, b; /* extract units */
811 if (ua>msua) a=0;
812 else a=*ua;
813 if (ub>msub) b=0;
814 else b=*ub;
815 *uc=0; /* can now write back */
816 if (a|b) { /* maybe 1 bits to examine */
817 Int i, j;
818 *uc=0; /* can now write back */
819 /* This loop could be unrolled and/or use BIN2BCD tables */
820 for (i=0; i<DECDPUN; i++) {
821 if (a&b&1) *uc=*uc+(Unit)powers[i]; /* effect AND */
822 j=a%10;
823 a=a/10;
824 j|=b%10;
825 b=b/10;
826 if (j>1) {
827 decStatus(res, DEC_Invalid_operation, set);
828 return res;
829 }
830 if (uc==msuc && i==msudigs-1) break; /* just did final digit */
831 } /* each digit */
832 } /* both OK */
833 } /* each unit */
834 /* [here uc-1 is the msu of the result] */
835 res->digits=decGetDigits(res->lsu, uc-res->lsu);
836 res->exponent=0; /* integer */
837 res->bits=0; /* sign=0 */
838 return res; /* [no status to set] */
839 } /* decNumberAnd */
840
841 /* ------------------------------------------------------------------ */
842 /* decNumberCompare -- compare two Numbers */
843 /* */
844 /* This computes C = A ? B */
845 /* */
846 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
847 /* lhs is A */
848 /* rhs is B */
849 /* set is the context */
850 /* */
851 /* C must have space for one digit (or NaN). */
852 /* ------------------------------------------------------------------ */
853 decNumber * decNumberCompare(decNumber *res, const decNumber *lhs,
854 const decNumber *rhs, decContext *set) {
855 uInt status=0; /* accumulator */
856 decCompareOp(res, lhs, rhs, set, COMPARE, &status);
857 if (status!=0) decStatus(res, status, set);
858 return res;
859 } /* decNumberCompare */
860
861 /* ------------------------------------------------------------------ */
862 /* decNumberCompareSignal -- compare, signalling on all NaNs */
863 /* */
864 /* This computes C = A ? B */
865 /* */
866 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
867 /* lhs is A */
868 /* rhs is B */
869 /* set is the context */
870 /* */
871 /* C must have space for one digit (or NaN). */
872 /* ------------------------------------------------------------------ */
873 decNumber * decNumberCompareSignal(decNumber *res, const decNumber *lhs,
874 const decNumber *rhs, decContext *set) {
875 uInt status=0; /* accumulator */
876 decCompareOp(res, lhs, rhs, set, COMPSIG, &status);
877 if (status!=0) decStatus(res, status, set);
878 return res;
879 } /* decNumberCompareSignal */
880
881 /* ------------------------------------------------------------------ */
882 /* decNumberCompareTotal -- compare two Numbers, using total ordering */
883 /* */
884 /* This computes C = A ? B, under total ordering */
885 /* */
886 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
887 /* lhs is A */
888 /* rhs is B */
889 /* set is the context */
890 /* */
891 /* C must have space for one digit; the result will always be one of */
892 /* -1, 0, or 1. */
893 /* ------------------------------------------------------------------ */
894 decNumber * decNumberCompareTotal(decNumber *res, const decNumber *lhs,
895 const decNumber *rhs, decContext *set) {
896 uInt status=0; /* accumulator */
897 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
898 if (status!=0) decStatus(res, status, set);
899 return res;
900 } /* decNumberCompareTotal */
901
902 /* ------------------------------------------------------------------ */
903 /* decNumberCompareTotalMag -- compare, total ordering of magnitudes */
904 /* */
905 /* This computes C = |A| ? |B|, under total ordering */
906 /* */
907 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
908 /* lhs is A */
909 /* rhs is B */
910 /* set is the context */
911 /* */
912 /* C must have space for one digit; the result will always be one of */
913 /* -1, 0, or 1. */
914 /* ------------------------------------------------------------------ */
915 decNumber * decNumberCompareTotalMag(decNumber *res, const decNumber *lhs,
916 const decNumber *rhs, decContext *set) {
917 uInt status=0; /* accumulator */
918 uInt needbytes; /* for space calculations */
919 decNumber bufa[D2N(DECBUFFER+1)];/* +1 in case DECBUFFER=0 */
920 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
921 decNumber bufb[D2N(DECBUFFER+1)];
922 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */
923 decNumber *a, *b; /* temporary pointers */
924
925 #if DECCHECK
926 if (decCheckOperands(res, lhs, rhs, set)) return res;
927 #endif
928
929 do { /* protect allocated storage */
930 /* if either is negative, take a copy and absolute */
931 if (decNumberIsNegative(lhs)) { /* lhs<0 */
932 a=bufa;
933 needbytes=sizeof(decNumber)+(D2U(lhs->digits)-1)*sizeof(Unit);
934 if (needbytes>sizeof(bufa)) { /* need malloc space */
935 allocbufa=(decNumber *)malloc(needbytes);
936 if (allocbufa==NULL) { /* hopeless -- abandon */
937 status|=DEC_Insufficient_storage;
938 break;}
939 a=allocbufa; /* use the allocated space */
940 }
941 decNumberCopy(a, lhs); /* copy content */
942 a->bits&=~DECNEG; /* .. and clear the sign */
943 lhs=a; /* use copy from here on */
944 }
945 if (decNumberIsNegative(rhs)) { /* rhs<0 */
946 b=bufb;
947 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
948 if (needbytes>sizeof(bufb)) { /* need malloc space */
949 allocbufb=(decNumber *)malloc(needbytes);
950 if (allocbufb==NULL) { /* hopeless -- abandon */
951 status|=DEC_Insufficient_storage;
952 break;}
953 b=allocbufb; /* use the allocated space */
954 }
955 decNumberCopy(b, rhs); /* copy content */
956 b->bits&=~DECNEG; /* .. and clear the sign */
957 rhs=b; /* use copy from here on */
958 }
959 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
960 } while(0); /* end protected */
961
962 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
963 if (allocbufb!=NULL) free(allocbufb); /* .. */
964 if (status!=0) decStatus(res, status, set);
965 return res;
966 } /* decNumberCompareTotalMag */
967
968 /* ------------------------------------------------------------------ */
969 /* decNumberDivide -- divide one number by another */
970 /* */
971 /* This computes C = A / B */
972 /* */
973 /* res is C, the result. C may be A and/or B (e.g., X=X/X) */
974 /* lhs is A */
975 /* rhs is B */
976 /* set is the context */
977 /* */
978 /* C must have space for set->digits digits. */
979 /* ------------------------------------------------------------------ */
980 decNumber * decNumberDivide(decNumber *res, const decNumber *lhs,
981 const decNumber *rhs, decContext *set) {
982 uInt status=0; /* accumulator */
983 decDivideOp(res, lhs, rhs, set, DIVIDE, &status);
984 if (status!=0) decStatus(res, status, set);
985 #if DECCHECK
986 decCheckInexact(res, set);
987 #endif
988 return res;
989 } /* decNumberDivide */
990
991 /* ------------------------------------------------------------------ */
992 /* decNumberDivideInteger -- divide and return integer quotient */
993 /* */
994 /* This computes C = A # B, where # is the integer divide operator */
995 /* */
996 /* res is C, the result. C may be A and/or B (e.g., X=X#X) */
997 /* lhs is A */
998 /* rhs is B */
999 /* set is the context */
1000 /* */
1001 /* C must have space for set->digits digits. */
1002 /* ------------------------------------------------------------------ */
1003 decNumber * decNumberDivideInteger(decNumber *res, const decNumber *lhs,
1004 const decNumber *rhs, decContext *set) {
1005 uInt status=0; /* accumulator */
1006 decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status);
1007 if (status!=0) decStatus(res, status, set);
1008 return res;
1009 } /* decNumberDivideInteger */
1010
1011 /* ------------------------------------------------------------------ */
1012 /* decNumberExp -- exponentiation */
1013 /* */
1014 /* This computes C = exp(A) */
1015 /* */
1016 /* res is C, the result. C may be A */
1017 /* rhs is A */
1018 /* set is the context; note that rounding mode has no effect */
1019 /* */
1020 /* C must have space for set->digits digits. */
1021 /* */
1022 /* Mathematical function restrictions apply (see above); a NaN is */
1023 /* returned with Invalid_operation if a restriction is violated. */
1024 /* */
1025 /* Finite results will always be full precision and Inexact, except */
1026 /* when A is a zero or -Infinity (giving 1 or 0 respectively). */
1027 /* */
1028 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */
1029 /* almost always be correctly rounded, but may be up to 1 ulp in */
1030 /* error in rare cases. */
1031 /* ------------------------------------------------------------------ */
1032 /* This is a wrapper for decExpOp which can handle the slightly wider */
1033 /* (double) range needed by Ln (which has to be able to calculate */
1034 /* exp(-a) where a can be the tiniest number (Ntiny). */
1035 /* ------------------------------------------------------------------ */
1036 decNumber * decNumberExp(decNumber *res, const decNumber *rhs,
1037 decContext *set) {
1038 uInt status=0; /* accumulator */
1039 #if DECSUBSET
1040 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
1041 #endif
1042
1043 #if DECCHECK
1044 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1045 #endif
1046
1047 /* Check restrictions; these restrictions ensure that if h=8 (see */
1048 /* decExpOp) then the result will either overflow or underflow to 0. */
1049 /* Other math functions restrict the input range, too, for inverses. */
1050 /* If not violated then carry out the operation. */
1051 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1052 #if DECSUBSET
1053 if (!set->extended) {
1054 /* reduce operand and set lostDigits status, as needed */
1055 if (rhs->digits>set->digits) {
1056 allocrhs=decRoundOperand(rhs, set, &status);
1057 if (allocrhs==NULL) break;
1058 rhs=allocrhs;
1059 }
1060 }
1061 #endif
1062 decExpOp(res, rhs, set, &status);
1063 } while(0); /* end protected */
1064
1065 #if DECSUBSET
1066 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */
1067 #endif
1068 /* apply significant status */
1069 if (status!=0) decStatus(res, status, set);
1070 #if DECCHECK
1071 decCheckInexact(res, set);
1072 #endif
1073 return res;
1074 } /* decNumberExp */
1075
1076 /* ------------------------------------------------------------------ */
1077 /* decNumberFMA -- fused multiply add */
1078 /* */
1079 /* This computes D = (A * B) + C with only one rounding */
1080 /* */
1081 /* res is D, the result. D may be A or B or C (e.g., X=FMA(X,X,X)) */
1082 /* lhs is A */
1083 /* rhs is B */
1084 /* fhs is C [far hand side] */
1085 /* set is the context */
1086 /* */
1087 /* Mathematical function restrictions apply (see above); a NaN is */
1088 /* returned with Invalid_operation if a restriction is violated. */
1089 /* */
1090 /* C must have space for set->digits digits. */
1091 /* ------------------------------------------------------------------ */
1092 decNumber * decNumberFMA(decNumber *res, const decNumber *lhs,
1093 const decNumber *rhs, const decNumber *fhs,
1094 decContext *set) {
1095 uInt status=0; /* accumulator */
1096 decContext dcmul; /* context for the multiplication */
1097 uInt needbytes; /* for space calculations */
1098 decNumber bufa[D2N(DECBUFFER*2+1)];
1099 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
1100 decNumber *acc; /* accumulator pointer */
1101 decNumber dzero; /* work */
1102
1103 #if DECCHECK
1104 if (decCheckOperands(res, lhs, rhs, set)) return res;
1105 if (decCheckOperands(res, fhs, DECUNUSED, set)) return res;
1106 #endif
1107
1108 do { /* protect allocated storage */
1109 #if DECSUBSET
1110 if (!set->extended) { /* [undefined if subset] */
1111 status|=DEC_Invalid_operation;
1112 break;}
1113 #endif
1114 /* Check math restrictions [these ensure no overflow or underflow] */
1115 if ((!decNumberIsSpecial(lhs) && decCheckMath(lhs, set, &status))
1116 || (!decNumberIsSpecial(rhs) && decCheckMath(rhs, set, &status))
1117 || (!decNumberIsSpecial(fhs) && decCheckMath(fhs, set, &status))) break;
1118 /* set up context for multiply */
1119 dcmul=*set;
1120 dcmul.digits=lhs->digits+rhs->digits; /* just enough */
1121 /* [The above may be an over-estimate for subset arithmetic, but that's OK] */
1122 dcmul.emax=DEC_MAX_EMAX; /* effectively unbounded .. */
1123 dcmul.emin=DEC_MIN_EMIN; /* [thanks to Math restrictions] */
1124 /* set up decNumber space to receive the result of the multiply */
1125 acc=bufa; /* may fit */
1126 needbytes=sizeof(decNumber)+(D2U(dcmul.digits)-1)*sizeof(Unit);
1127 if (needbytes>sizeof(bufa)) { /* need malloc space */
1128 allocbufa=(decNumber *)malloc(needbytes);
1129 if (allocbufa==NULL) { /* hopeless -- abandon */
1130 status|=DEC_Insufficient_storage;
1131 break;}
1132 acc=allocbufa; /* use the allocated space */
1133 }
1134 /* multiply with extended range and necessary precision */
1135 /*printf("emin=%ld\n", dcmul.emin); */
1136 decMultiplyOp(acc, lhs, rhs, &dcmul, &status);
1137 /* Only Invalid operation (from sNaN or Inf * 0) is possible in */
1138 /* status; if either is seen than ignore fhs (in case it is */
1139 /* another sNaN) and set acc to NaN unless we had an sNaN */
1140 /* [decMultiplyOp leaves that to caller] */
1141 /* Note sNaN has to go through addOp to shorten payload if */
1142 /* necessary */
1143 if ((status&DEC_Invalid_operation)!=0) {
1144 if (!(status&DEC_sNaN)) { /* but be true invalid */
1145 decNumberZero(res); /* acc not yet set */
1146 res->bits=DECNAN;
1147 break;
1148 }
1149 decNumberZero(&dzero); /* make 0 (any non-NaN would do) */
1150 fhs=&dzero; /* use that */
1151 }
1152 #if DECCHECK
1153 else { /* multiply was OK */
1154 if (status!=0) printf("Status=%08lx after FMA multiply\n", status);
1155 }
1156 #endif
1157 /* add the third operand and result -> res, and all is done */
1158 decAddOp(res, acc, fhs, set, 0, &status);
1159 } while(0); /* end protected */
1160
1161 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
1162 if (status!=0) decStatus(res, status, set);
1163 #if DECCHECK
1164 decCheckInexact(res, set);
1165 #endif
1166 return res;
1167 } /* decNumberFMA */
1168
1169 /* ------------------------------------------------------------------ */
1170 /* decNumberInvert -- invert a Number, digitwise */
1171 /* */
1172 /* This computes C = ~A */
1173 /* */
1174 /* res is C, the result. C may be A (e.g., X=~X) */
1175 /* rhs is A */
1176 /* set is the context (used for result length and error report) */
1177 /* */
1178 /* C must have space for set->digits digits. */
1179 /* */
1180 /* Logical function restrictions apply (see above); a NaN is */
1181 /* returned with Invalid_operation if a restriction is violated. */
1182 /* ------------------------------------------------------------------ */
1183 decNumber * decNumberInvert(decNumber *res, const decNumber *rhs,
1184 decContext *set) {
1185 const Unit *ua, *msua; /* -> operand and its msu */
1186 Unit *uc, *msuc; /* -> result and its msu */
1187 Int msudigs; /* digits in res msu */
1188 #if DECCHECK
1189 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1190 #endif
1191
1192 if (rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1193 decStatus(res, DEC_Invalid_operation, set);
1194 return res;
1195 }
1196 /* operand is valid */
1197 ua=rhs->lsu; /* bottom-up */
1198 uc=res->lsu; /* .. */
1199 msua=ua+D2U(rhs->digits)-1; /* -> msu of rhs */
1200 msuc=uc+D2U(set->digits)-1; /* -> msu of result */
1201 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */
1202 for (; uc<=msuc; ua++, uc++) { /* Unit loop */
1203 Unit a; /* extract unit */
1204 Int i, j; /* work */
1205 if (ua>msua) a=0;
1206 else a=*ua;
1207 *uc=0; /* can now write back */
1208 /* always need to examine all bits in rhs */
1209 /* This loop could be unrolled and/or use BIN2BCD tables */
1210 for (i=0; i<DECDPUN; i++) {
1211 if ((~a)&1) *uc=*uc+(Unit)powers[i]; /* effect INVERT */
1212 j=a%10;
1213 a=a/10;
1214 if (j>1) {
1215 decStatus(res, DEC_Invalid_operation, set);
1216 return res;
1217 }
1218 if (uc==msuc && i==msudigs-1) break; /* just did final digit */
1219 } /* each digit */
1220 } /* each unit */
1221 /* [here uc-1 is the msu of the result] */
1222 res->digits=decGetDigits(res->lsu, uc-res->lsu);
1223 res->exponent=0; /* integer */
1224 res->bits=0; /* sign=0 */
1225 return res; /* [no status to set] */
1226 } /* decNumberInvert */
1227
1228 /* ------------------------------------------------------------------ */
1229 /* decNumberLn -- natural logarithm */
1230 /* */
1231 /* This computes C = ln(A) */
1232 /* */
1233 /* res is C, the result. C may be A */
1234 /* rhs is A */
1235 /* set is the context; note that rounding mode has no effect */
1236 /* */
1237 /* C must have space for set->digits digits. */
1238 /* */
1239 /* Notable cases: */
1240 /* A<0 -> Invalid */
1241 /* A=0 -> -Infinity (Exact) */
1242 /* A=+Infinity -> +Infinity (Exact) */
1243 /* A=1 exactly -> 0 (Exact) */
1244 /* */
1245 /* Mathematical function restrictions apply (see above); a NaN is */
1246 /* returned with Invalid_operation if a restriction is violated. */
1247 /* */
1248 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */
1249 /* almost always be correctly rounded, but may be up to 1 ulp in */
1250 /* error in rare cases. */
1251 /* ------------------------------------------------------------------ */
1252 /* This is a wrapper for decLnOp which can handle the slightly wider */
1253 /* (+11) range needed by Ln, Log10, etc. (which may have to be able */
1254 /* to calculate at p+e+2). */
1255 /* ------------------------------------------------------------------ */
1256 decNumber * decNumberLn(decNumber *res, const decNumber *rhs,
1257 decContext *set) {
1258 uInt status=0; /* accumulator */
1259 #if DECSUBSET
1260 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
1261 #endif
1262
1263 #if DECCHECK
1264 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1265 #endif
1266
1267 /* Check restrictions; this is a math function; if not violated */
1268 /* then carry out the operation. */
1269 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1270 #if DECSUBSET
1271 if (!set->extended) {
1272 /* reduce operand and set lostDigits status, as needed */
1273 if (rhs->digits>set->digits) {
1274 allocrhs=decRoundOperand(rhs, set, &status);
1275 if (allocrhs==NULL) break;
1276 rhs=allocrhs;
1277 }
1278 /* special check in subset for rhs=0 */
1279 if (ISZERO(rhs)) { /* +/- zeros -> error */
1280 status|=DEC_Invalid_operation;
1281 break;}
1282 } /* extended=0 */
1283 #endif
1284 decLnOp(res, rhs, set, &status);
1285 } while(0); /* end protected */
1286
1287 #if DECSUBSET
1288 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */
1289 #endif
1290 /* apply significant status */
1291 if (status!=0) decStatus(res, status, set);
1292 #if DECCHECK
1293 decCheckInexact(res, set);
1294 #endif
1295 return res;
1296 } /* decNumberLn */
1297
1298 /* ------------------------------------------------------------------ */
1299 /* decNumberLogB - get adjusted exponent, by 754r rules */
1300 /* */
1301 /* This computes C = adjustedexponent(A) */
1302 /* */
1303 /* res is C, the result. C may be A */
1304 /* rhs is A */
1305 /* set is the context, used only for digits and status */
1306 /* */
1307 /* C must have space for 10 digits (A might have 10**9 digits and */
1308 /* an exponent of +999999999, or one digit and an exponent of */
1309 /* -1999999999). */
1310 /* */
1311 /* This returns the adjusted exponent of A after (in theory) padding */
1312 /* with zeros on the right to set->digits digits while keeping the */
1313 /* same value. The exponent is not limited by emin/emax. */
1314 /* */
1315 /* Notable cases: */
1316 /* A<0 -> Use |A| */
1317 /* A=0 -> -Infinity (Division by zero) */
1318 /* A=Infinite -> +Infinity (Exact) */
1319 /* A=1 exactly -> 0 (Exact) */
1320 /* NaNs are propagated as usual */
1321 /* ------------------------------------------------------------------ */
1322 decNumber * decNumberLogB(decNumber *res, const decNumber *rhs,
1323 decContext *set) {
1324 uInt status=0; /* accumulator */
1325
1326 #if DECCHECK
1327 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1328 #endif
1329
1330 /* NaNs as usual; Infinities return +Infinity; 0->oops */
1331 if (decNumberIsNaN(rhs)) decNaNs(res, rhs, NULL, set, &status);
1332 else if (decNumberIsInfinite(rhs)) decNumberCopyAbs(res, rhs);
1333 else if (decNumberIsZero(rhs)) {
1334 decNumberZero(res); /* prepare for Infinity */
1335 res->bits=DECNEG|DECINF; /* -Infinity */
1336 status|=DEC_Division_by_zero; /* as per 754r */
1337 }
1338 else { /* finite non-zero */
1339 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */
1340 decNumberFromInt32(res, ae); /* lay it out */
1341 }
1342
1343 if (status!=0) decStatus(res, status, set);
1344 return res;
1345 } /* decNumberLogB */
1346
1347 /* ------------------------------------------------------------------ */
1348 /* decNumberLog10 -- logarithm in base 10 */
1349 /* */
1350 /* This computes C = log10(A) */
1351 /* */
1352 /* res is C, the result. C may be A */
1353 /* rhs is A */
1354 /* set is the context; note that rounding mode has no effect */
1355 /* */
1356 /* C must have space for set->digits digits. */
1357 /* */
1358 /* Notable cases: */
1359 /* A<0 -> Invalid */
1360 /* A=0 -> -Infinity (Exact) */
1361 /* A=+Infinity -> +Infinity (Exact) */
1362 /* A=10**n (if n is an integer) -> n (Exact) */
1363 /* */
1364 /* Mathematical function restrictions apply (see above); a NaN is */
1365 /* returned with Invalid_operation if a restriction is violated. */
1366 /* */
1367 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */
1368 /* almost always be correctly rounded, but may be up to 1 ulp in */
1369 /* error in rare cases. */
1370 /* ------------------------------------------------------------------ */
1371 /* This calculates ln(A)/ln(10) using appropriate precision. For */
1372 /* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the */
1373 /* requested digits and t is the number of digits in the exponent */
1374 /* (maximum 6). For ln(10) it is p + 3; this is often handled by the */
1375 /* fastpath in decLnOp. The final division is done to the requested */
1376 /* precision. */
1377 /* ------------------------------------------------------------------ */
1378 decNumber * decNumberLog10(decNumber *res, const decNumber *rhs,
1379 decContext *set) {
1380 uInt status=0, ignore=0; /* status accumulators */
1381 uInt needbytes; /* for space calculations */
1382 Int p; /* working precision */
1383 Int t; /* digits in exponent of A */
1384
1385 /* buffers for a and b working decimals */
1386 /* (adjustment calculator, same size) */
1387 decNumber bufa[D2N(DECBUFFER+2)];
1388 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
1389 decNumber *a=bufa; /* temporary a */
1390 decNumber bufb[D2N(DECBUFFER+2)];
1391 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */
1392 decNumber *b=bufb; /* temporary b */
1393 decNumber bufw[D2N(10)]; /* working 2-10 digit number */
1394 decNumber *w=bufw; /* .. */
1395 #if DECSUBSET
1396 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
1397 #endif
1398
1399 decContext aset; /* working context */
1400
1401 #if DECCHECK
1402 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1403 #endif
1404
1405 /* Check restrictions; this is a math function; if not violated */
1406 /* then carry out the operation. */
1407 if (!decCheckMath(rhs, set, &status)) do { /* protect malloc */
1408 #if DECSUBSET
1409 if (!set->extended) {
1410 /* reduce operand and set lostDigits status, as needed */
1411 if (rhs->digits>set->digits) {
1412 allocrhs=decRoundOperand(rhs, set, &status);
1413 if (allocrhs==NULL) break;
1414 rhs=allocrhs;
1415 }
1416 /* special check in subset for rhs=0 */
1417 if (ISZERO(rhs)) { /* +/- zeros -> error */
1418 status|=DEC_Invalid_operation;
1419 break;}
1420 } /* extended=0 */
1421 #endif
1422
1423 decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
1424
1425 /* handle exact powers of 10; only check if +ve finite */
1426 if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) {
1427 Int residue=0; /* (no residue) */
1428 uInt copystat=0; /* clean status */
1429
1430 /* round to a single digit... */
1431 aset.digits=1;
1432 decCopyFit(w, rhs, &aset, &residue, &copystat); /* copy & shorten */
1433 /* if exact and the digit is 1, rhs is a power of 10 */
1434 if (!(copystat&DEC_Inexact) && w->lsu[0]==1) {
1435 /* the exponent, conveniently, is the power of 10; making */
1436 /* this the result needs a little care as it might not fit, */
1437 /* so first convert it into the working number, and then move */
1438 /* to res */
1439 decNumberFromInt32(w, w->exponent);
1440 residue=0;
1441 decCopyFit(res, w, set, &residue, &status); /* copy & round */
1442 decFinish(res, set, &residue, &status); /* cleanup/set flags */
1443 break;
1444 } /* not a power of 10 */
1445 } /* not a candidate for exact */
1446
1447 /* simplify the information-content calculation to use 'total */
1448 /* number of digits in a, including exponent' as compared to the */
1449 /* requested digits, as increasing this will only rarely cost an */
1450 /* iteration in ln(a) anyway */
1451 t=6; /* it can never be >6 */
1452
1453 /* allocate space when needed... */
1454 p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3;
1455 needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1456 if (needbytes>sizeof(bufa)) { /* need malloc space */
1457 allocbufa=(decNumber *)malloc(needbytes);
1458 if (allocbufa==NULL) { /* hopeless -- abandon */
1459 status|=DEC_Insufficient_storage;
1460 break;}
1461 a=allocbufa; /* use the allocated space */
1462 }
1463 aset.digits=p; /* as calculated */
1464 aset.emax=DEC_MAX_MATH; /* usual bounds */
1465 aset.emin=-DEC_MAX_MATH; /* .. */
1466 aset.clamp=0; /* and no concrete format */
1467 decLnOp(a, rhs, &aset, &status); /* a=ln(rhs) */
1468
1469 /* skip the division if the result so far is infinite, NaN, or */
1470 /* zero, or there was an error; note NaN from sNaN needs copy */
1471 if (status&DEC_NaNs && !(status&DEC_sNaN)) break;
1472 if (a->bits&DECSPECIAL || ISZERO(a)) {
1473 decNumberCopy(res, a); /* [will fit] */
1474 break;}
1475
1476 /* for ln(10) an extra 3 digits of precision are needed */
1477 p=set->digits+3;
1478 needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1479 if (needbytes>sizeof(bufb)) { /* need malloc space */
1480 allocbufb=(decNumber *)malloc(needbytes);
1481 if (allocbufb==NULL) { /* hopeless -- abandon */
1482 status|=DEC_Insufficient_storage;
1483 break;}
1484 b=allocbufb; /* use the allocated space */
1485 }
1486 decNumberZero(w); /* set up 10... */
1487 #if DECDPUN==1
1488 w->lsu[1]=1; w->lsu[0]=0; /* .. */
1489 #else
1490 w->lsu[0]=10; /* .. */
1491 #endif
1492 w->digits=2; /* .. */
1493
1494 aset.digits=p;
1495 decLnOp(b, w, &aset, &ignore); /* b=ln(10) */
1496
1497 aset.digits=set->digits; /* for final divide */
1498 decDivideOp(res, a, b, &aset, DIVIDE, &status); /* into result */
1499 } while(0); /* [for break] */
1500
1501 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
1502 if (allocbufb!=NULL) free(allocbufb); /* .. */
1503 #if DECSUBSET
1504 if (allocrhs !=NULL) free(allocrhs); /* .. */
1505 #endif
1506 /* apply significant status */
1507 if (status!=0) decStatus(res, status, set);
1508 #if DECCHECK
1509 decCheckInexact(res, set);
1510 #endif
1511 return res;
1512 } /* decNumberLog10 */
1513
1514 /* ------------------------------------------------------------------ */
1515 /* decNumberMax -- compare two Numbers and return the maximum */
1516 /* */
1517 /* This computes C = A ? B, returning the maximum by 754R rules */
1518 /* */
1519 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1520 /* lhs is A */
1521 /* rhs is B */
1522 /* set is the context */
1523 /* */
1524 /* C must have space for set->digits digits. */
1525 /* ------------------------------------------------------------------ */
1526 decNumber * decNumberMax(decNumber *res, const decNumber *lhs,
1527 const decNumber *rhs, decContext *set) {
1528 uInt status=0; /* accumulator */
1529 decCompareOp(res, lhs, rhs, set, COMPMAX, &status);
1530 if (status!=0) decStatus(res, status, set);
1531 #if DECCHECK
1532 decCheckInexact(res, set);
1533 #endif
1534 return res;
1535 } /* decNumberMax */
1536
1537 /* ------------------------------------------------------------------ */
1538 /* decNumberMaxMag -- compare and return the maximum by magnitude */
1539 /* */
1540 /* This computes C = A ? B, returning the maximum by 754R rules */
1541 /* */
1542 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1543 /* lhs is A */
1544 /* rhs is B */
1545 /* set is the context */
1546 /* */
1547 /* C must have space for set->digits digits. */
1548 /* ------------------------------------------------------------------ */
1549 decNumber * decNumberMaxMag(decNumber *res, const decNumber *lhs,
1550 const decNumber *rhs, decContext *set) {
1551 uInt status=0; /* accumulator */
1552 decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status);
1553 if (status!=0) decStatus(res, status, set);
1554 #if DECCHECK
1555 decCheckInexact(res, set);
1556 #endif
1557 return res;
1558 } /* decNumberMaxMag */
1559
1560 /* ------------------------------------------------------------------ */
1561 /* decNumberMin -- compare two Numbers and return the minimum */
1562 /* */
1563 /* This computes C = A ? B, returning the minimum by 754R rules */
1564 /* */
1565 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1566 /* lhs is A */
1567 /* rhs is B */
1568 /* set is the context */
1569 /* */
1570 /* C must have space for set->digits digits. */
1571 /* ------------------------------------------------------------------ */
1572 decNumber * decNumberMin(decNumber *res, const decNumber *lhs,
1573 const decNumber *rhs, decContext *set) {
1574 uInt status=0; /* accumulator */
1575 decCompareOp(res, lhs, rhs, set, COMPMIN, &status);
1576 if (status!=0) decStatus(res, status, set);
1577 #if DECCHECK
1578 decCheckInexact(res, set);
1579 #endif
1580 return res;
1581 } /* decNumberMin */
1582
1583 /* ------------------------------------------------------------------ */
1584 /* decNumberMinMag -- compare and return the minimum by magnitude */
1585 /* */
1586 /* This computes C = A ? B, returning the minimum by 754R rules */
1587 /* */
1588 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1589 /* lhs is A */
1590 /* rhs is B */
1591 /* set is the context */
1592 /* */
1593 /* C must have space for set->digits digits. */
1594 /* ------------------------------------------------------------------ */
1595 decNumber * decNumberMinMag(decNumber *res, const decNumber *lhs,
1596 const decNumber *rhs, decContext *set) {
1597 uInt status=0; /* accumulator */
1598 decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status);
1599 if (status!=0) decStatus(res, status, set);
1600 #if DECCHECK
1601 decCheckInexact(res, set);
1602 #endif
1603 return res;
1604 } /* decNumberMinMag */
1605
1606 /* ------------------------------------------------------------------ */
1607 /* decNumberMinus -- prefix minus operator */
1608 /* */
1609 /* This computes C = 0 - A */
1610 /* */
1611 /* res is C, the result. C may be A */
1612 /* rhs is A */
1613 /* set is the context */
1614 /* */
1615 /* See also decNumberCopyNegate for a quiet bitwise version of this. */
1616 /* C must have space for set->digits digits. */
1617 /* ------------------------------------------------------------------ */
1618 /* Simply use AddOp for the subtract, which will do the necessary. */
1619 /* ------------------------------------------------------------------ */
1620 decNumber * decNumberMinus(decNumber *res, const decNumber *rhs,
1621 decContext *set) {
1622 decNumber dzero;
1623 uInt status=0; /* accumulator */
1624
1625 #if DECCHECK
1626 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1627 #endif
1628
1629 decNumberZero(&dzero); /* make 0 */
1630 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */
1631 decAddOp(res, &dzero, rhs, set, DECNEG, &status);
1632 if (status!=0) decStatus(res, status, set);
1633 #if DECCHECK
1634 decCheckInexact(res, set);
1635 #endif
1636 return res;
1637 } /* decNumberMinus */
1638
1639 /* ------------------------------------------------------------------ */
1640 /* decNumberNextMinus -- next towards -Infinity */
1641 /* */
1642 /* This computes C = A - infinitesimal, rounded towards -Infinity */
1643 /* */
1644 /* res is C, the result. C may be A */
1645 /* rhs is A */
1646 /* set is the context */
1647 /* */
1648 /* This is a generalization of 754r NextDown. */
1649 /* ------------------------------------------------------------------ */
1650 decNumber * decNumberNextMinus(decNumber *res, const decNumber *rhs,
1651 decContext *set) {
1652 decNumber dtiny; /* constant */
1653 decContext workset=*set; /* work */
1654 uInt status=0; /* accumulator */
1655 #if DECCHECK
1656 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1657 #endif
1658
1659 /* +Infinity is the special case */
1660 if ((rhs->bits&(DECINF|DECNEG))==DECINF) {
1661 decSetMaxValue(res, set); /* is +ve */
1662 /* there is no status to set */
1663 return res;
1664 }
1665 decNumberZero(&dtiny); /* start with 0 */
1666 dtiny.lsu[0]=1; /* make number that is .. */
1667 dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */
1668 workset.round=DEC_ROUND_FLOOR;
1669 decAddOp(res, rhs, &dtiny, &workset, DECNEG, &status);
1670 status&=DEC_Invalid_operation|DEC_sNaN; /* only sNaN Invalid please */
1671 if (status!=0) decStatus(res, status, set);
1672 return res;
1673 } /* decNumberNextMinus */
1674
1675 /* ------------------------------------------------------------------ */
1676 /* decNumberNextPlus -- next towards +Infinity */
1677 /* */
1678 /* This computes C = A + infinitesimal, rounded towards +Infinity */
1679 /* */
1680 /* res is C, the result. C may be A */
1681 /* rhs is A */
1682 /* set is the context */
1683 /* */
1684 /* This is a generalization of 754r NextUp. */
1685 /* ------------------------------------------------------------------ */
1686 decNumber * decNumberNextPlus(decNumber *res, const decNumber *rhs,
1687 decContext *set) {
1688 decNumber dtiny; /* constant */
1689 decContext workset=*set; /* work */
1690 uInt status=0; /* accumulator */
1691 #if DECCHECK
1692 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1693 #endif
1694
1695 /* -Infinity is the special case */
1696 if ((rhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1697 decSetMaxValue(res, set);
1698 res->bits=DECNEG; /* negative */
1699 /* there is no status to set */
1700 return res;
1701 }
1702 decNumberZero(&dtiny); /* start with 0 */
1703 dtiny.lsu[0]=1; /* make number that is .. */
1704 dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */
1705 workset.round=DEC_ROUND_CEILING;
1706 decAddOp(res, rhs, &dtiny, &workset, 0, &status);
1707 status&=DEC_Invalid_operation|DEC_sNaN; /* only sNaN Invalid please */
1708 if (status!=0) decStatus(res, status, set);
1709 return res;
1710 } /* decNumberNextPlus */
1711
1712 /* ------------------------------------------------------------------ */
1713 /* decNumberNextToward -- next towards rhs */
1714 /* */
1715 /* This computes C = A +/- infinitesimal, rounded towards */
1716 /* +/-Infinity in the direction of B, as per 754r nextafter rules */
1717 /* */
1718 /* res is C, the result. C may be A or B. */
1719 /* lhs is A */
1720 /* rhs is B */
1721 /* set is the context */
1722 /* */
1723 /* This is a generalization of 754r NextAfter. */
1724 /* ------------------------------------------------------------------ */
1725 decNumber * decNumberNextToward(decNumber *res, const decNumber *lhs,
1726 const decNumber *rhs, decContext *set) {
1727 decNumber dtiny; /* constant */
1728 decContext workset=*set; /* work */
1729 Int result; /* .. */
1730 uInt status=0; /* accumulator */
1731 #if DECCHECK
1732 if (decCheckOperands(res, lhs, rhs, set)) return res;
1733 #endif
1734
1735 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) {
1736 decNaNs(res, lhs, rhs, set, &status);
1737 }
1738 else { /* Is numeric, so no chance of sNaN Invalid, etc. */
1739 result=decCompare(lhs, rhs, 0); /* sign matters */
1740 if (result==BADINT) status|=DEC_Insufficient_storage; /* rare */
1741 else { /* valid compare */
1742 if (result==0) decNumberCopySign(res, lhs, rhs); /* easy */
1743 else { /* differ: need NextPlus or NextMinus */
1744 uByte sub; /* add or subtract */
1745 if (result<0) { /* lhs<rhs, do nextplus */
1746 /* -Infinity is the special case */
1747 if ((lhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1748 decSetMaxValue(res, set);
1749 res->bits=DECNEG; /* negative */
1750 return res; /* there is no status to set */
1751 }
1752 workset.round=DEC_ROUND_CEILING;
1753 sub=0; /* add, please */
1754 } /* plus */
1755 else { /* lhs>rhs, do nextminus */
1756 /* +Infinity is the special case */
1757 if ((lhs->bits&(DECINF|DECNEG))==DECINF) {
1758 decSetMaxValue(res, set);
1759 return res; /* there is no status to set */
1760 }
1761 workset.round=DEC_ROUND_FLOOR;
1762 sub=DECNEG; /* subtract, please */
1763 } /* minus */
1764 decNumberZero(&dtiny); /* start with 0 */
1765 dtiny.lsu[0]=1; /* make number that is .. */
1766 dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */
1767 decAddOp(res, lhs, &dtiny, &workset, sub, &status); /* + or - */
1768 /* turn off exceptions if the result is a normal number */
1769 /* (including Nmin), otherwise let all status through */
1770 if (decNumberIsNormal(res, set)) status=0;
1771 } /* unequal */
1772 } /* compare OK */
1773 } /* numeric */
1774 if (status!=0) decStatus(res, status, set);
1775 return res;
1776 } /* decNumberNextToward */
1777
1778 /* ------------------------------------------------------------------ */
1779 /* decNumberOr -- OR two Numbers, digitwise */
1780 /* */
1781 /* This computes C = A | B */
1782 /* */
1783 /* res is C, the result. C may be A and/or B (e.g., X=X|X) */
1784 /* lhs is A */
1785 /* rhs is B */
1786 /* set is the context (used for result length and error report) */
1787 /* */
1788 /* C must have space for set->digits digits. */
1789 /* */
1790 /* Logical function restrictions apply (see above); a NaN is */
1791 /* returned with Invalid_operation if a restriction is violated. */
1792 /* ------------------------------------------------------------------ */
1793 decNumber * decNumberOr(decNumber *res, const decNumber *lhs,
1794 const decNumber *rhs, decContext *set) {
1795 const Unit *ua, *ub; /* -> operands */
1796 const Unit *msua, *msub; /* -> operand msus */
1797 Unit *uc, *msuc; /* -> result and its msu */
1798 Int msudigs; /* digits in res msu */
1799 #if DECCHECK
1800 if (decCheckOperands(res, lhs, rhs, set)) return res;
1801 #endif
1802
1803 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
1804 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1805 decStatus(res, DEC_Invalid_operation, set);
1806 return res;
1807 }
1808 /* operands are valid */
1809 ua=lhs->lsu; /* bottom-up */
1810 ub=rhs->lsu; /* .. */
1811 uc=res->lsu; /* .. */
1812 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */
1813 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */
1814 msuc=uc+D2U(set->digits)-1; /* -> msu of result */
1815 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */
1816 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */
1817 Unit a, b; /* extract units */
1818 if (ua>msua) a=0;
1819 else a=*ua;
1820 if (ub>msub) b=0;
1821 else b=*ub;
1822 *uc=0; /* can now write back */
1823 if (a|b) { /* maybe 1 bits to examine */
1824 Int i, j;
1825 /* This loop could be unrolled and/or use BIN2BCD tables */
1826 for (i=0; i<DECDPUN; i++) {
1827 if ((a|b)&1) *uc=*uc+(Unit)powers[i]; /* effect OR */
1828 j=a%10;
1829 a=a/10;
1830 j|=b%10;
1831 b=b/10;
1832 if (j>1) {
1833 decStatus(res, DEC_Invalid_operation, set);
1834 return res;
1835 }
1836 if (uc==msuc && i==msudigs-1) break; /* just did final digit */
1837 } /* each digit */
1838 } /* non-zero */
1839 } /* each unit */
1840 /* [here uc-1 is the msu of the result] */
1841 res->digits=decGetDigits(res->lsu, uc-res->lsu);
1842 res->exponent=0; /* integer */
1843 res->bits=0; /* sign=0 */
1844 return res; /* [no status to set] */
1845 } /* decNumberOr */
1846
1847 /* ------------------------------------------------------------------ */
1848 /* decNumberPlus -- prefix plus operator */
1849 /* */
1850 /* This computes C = 0 + A */
1851 /* */
1852 /* res is C, the result. C may be A */
1853 /* rhs is A */
1854 /* set is the context */
1855 /* */
1856 /* See also decNumberCopy for a quiet bitwise version of this. */
1857 /* C must have space for set->digits digits. */
1858 /* ------------------------------------------------------------------ */
1859 /* This simply uses AddOp; Add will take fast path after preparing A. */
1860 /* Performance is a concern here, as this routine is often used to */
1861 /* check operands and apply rounding and overflow/underflow testing. */
1862 /* ------------------------------------------------------------------ */
1863 decNumber * decNumberPlus(decNumber *res, const decNumber *rhs,
1864 decContext *set) {
1865 decNumber dzero;
1866 uInt status=0; /* accumulator */
1867 #if DECCHECK
1868 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1869 #endif
1870
1871 decNumberZero(&dzero); /* make 0 */
1872 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */
1873 decAddOp(res, &dzero, rhs, set, 0, &status);
1874 if (status!=0) decStatus(res, status, set);
1875 #if DECCHECK
1876 decCheckInexact(res, set);
1877 #endif
1878 return res;
1879 } /* decNumberPlus */
1880
1881 /* ------------------------------------------------------------------ */
1882 /* decNumberMultiply -- multiply two Numbers */
1883 /* */
1884 /* This computes C = A x B */
1885 /* */
1886 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */
1887 /* lhs is A */
1888 /* rhs is B */
1889 /* set is the context */
1890 /* */
1891 /* C must have space for set->digits digits. */
1892 /* ------------------------------------------------------------------ */
1893 decNumber * decNumberMultiply(decNumber *res, const decNumber *lhs,
1894 const decNumber *rhs, decContext *set) {
1895 uInt status=0; /* accumulator */
1896 decMultiplyOp(res, lhs, rhs, set, &status);
1897 if (status!=0) decStatus(res, status, set);
1898 #if DECCHECK
1899 decCheckInexact(res, set);
1900 #endif
1901 return res;
1902 } /* decNumberMultiply */
1903
1904 /* ------------------------------------------------------------------ */
1905 /* decNumberPower -- raise a number to a power */
1906 /* */
1907 /* This computes C = A ** B */
1908 /* */
1909 /* res is C, the result. C may be A and/or B (e.g., X=X**X) */
1910 /* lhs is A */
1911 /* rhs is B */
1912 /* set is the context */
1913 /* */
1914 /* C must have space for set->digits digits. */
1915 /* */
1916 /* Mathematical function restrictions apply (see above); a NaN is */
1917 /* returned with Invalid_operation if a restriction is violated. */
1918 /* */
1919 /* However, if 1999999997<=B<=999999999 and B is an integer then the */
1920 /* restrictions on A and the context are relaxed to the usual bounds, */
1921 /* for compatibility with the earlier (integer power only) version */
1922 /* of this function. */
1923 /* */
1924 /* When B is an integer, the result may be exact, even if rounded. */
1925 /* */
1926 /* The final result is rounded according to the context; it will */
1927 /* almost always be correctly rounded, but may be up to 1 ulp in */
1928 /* error in rare cases. */
1929 /* ------------------------------------------------------------------ */
1930 decNumber * decNumberPower(decNumber *res, const decNumber *lhs,
1931 const decNumber *rhs, decContext *set) {
1932 #if DECSUBSET
1933 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
1934 decNumber *allocrhs=NULL; /* .., rhs */
1935 #endif
1936 decNumber *allocdac=NULL; /* -> allocated acc buffer, iff used */
1937 decNumber *allocinv=NULL; /* -> allocated 1/x buffer, iff used */
1938 Int reqdigits=set->digits; /* requested DIGITS */
1939 Int n; /* rhs in binary */
1940 Flag rhsint=0; /* 1 if rhs is an integer */
1941 Flag useint=0; /* 1 if can use integer calculation */
1942 Flag isoddint=0; /* 1 if rhs is an integer and odd */
1943 Int i; /* work */
1944 #if DECSUBSET
1945 Int dropped; /* .. */
1946 #endif
1947 uInt needbytes; /* buffer size needed */
1948 Flag seenbit; /* seen a bit while powering */
1949 Int residue=0; /* rounding residue */
1950 uInt status=0; /* accumulators */
1951 uByte bits=0; /* result sign if errors */
1952 decContext aset; /* working context */
1953 decNumber dnOne; /* work value 1... */
1954 /* local accumulator buffer [a decNumber, with digits+elength+1 digits] */
1955 decNumber dacbuff[D2N(DECBUFFER+9)];
1956 decNumber *dac=dacbuff; /* -> result accumulator */
1957 /* same again for possible 1/lhs calculation */
1958 decNumber invbuff[D2N(DECBUFFER+9)];
1959
1960 #if DECCHECK
1961 if (decCheckOperands(res, lhs, rhs, set)) return res;
1962 #endif
1963
1964 do { /* protect allocated storage */
1965 #if DECSUBSET
1966 if (!set->extended) { /* reduce operands and set status, as needed */
1967 if (lhs->digits>reqdigits) {
1968 alloclhs=decRoundOperand(lhs, set, &status);
1969 if (alloclhs==NULL) break;
1970 lhs=alloclhs;
1971 }
1972 if (rhs->digits>reqdigits) {
1973 allocrhs=decRoundOperand(rhs, set, &status);
1974 if (allocrhs==NULL) break;
1975 rhs=allocrhs;
1976 }
1977 }
1978 #endif
1979 /* [following code does not require input rounding] */
1980
1981 /* handle NaNs and rhs Infinity (lhs infinity is harder) */
1982 if (SPECIALARGS) {
1983 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { /* NaNs */
1984 decNaNs(res, lhs, rhs, set, &status);
1985 break;}
1986 if (decNumberIsInfinite(rhs)) { /* rhs Infinity */
1987 Flag rhsneg=rhs->bits&DECNEG; /* save rhs sign */
1988 if (decNumberIsNegative(lhs) /* lhs<0 */
1989 && !decNumberIsZero(lhs)) /* .. */
1990 status|=DEC_Invalid_operation;
1991 else { /* lhs >=0 */
1992 decNumberZero(&dnOne); /* set up 1 */
1993 dnOne.lsu[0]=1;
1994 decNumberCompare(dac, lhs, &dnOne, set); /* lhs ? 1 */
1995 decNumberZero(res); /* prepare for 0/1/Infinity */
1996 if (decNumberIsNegative(dac)) { /* lhs<1 */
1997 if (rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */
1998 }
1999 else if (dac->lsu[0]==0) { /* lhs=1 */
2000 /* 1**Infinity is inexact, so return fully-padded 1.0000 */
2001 Int shift=set->digits-1;
2002 *res->lsu=1; /* was 0, make int 1 */
2003 res->digits=decShiftToMost(res->lsu, 1, shift);
2004 res->exponent=-shift; /* make 1.0000... */
2005 status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */
2006 }
2007 else { /* lhs>1 */
2008 if (!rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */
2009 }
2010 } /* lhs>=0 */
2011 break;}
2012 /* [lhs infinity drops through] */
2013 } /* specials */
2014
2015 /* Original rhs may be an integer that fits and is in range */
2016 n=decGetInt(rhs);
2017 if (n!=BADINT) { /* it is an integer */
2018 rhsint=1; /* record the fact for 1**n */
2019 isoddint=(Flag)n&1; /* [works even if big] */
2020 if (n!=BIGEVEN && n!=BIGODD) /* can use integer path? */
2021 useint=1; /* looks good */
2022 }
2023
2024 if (decNumberIsNegative(lhs) /* -x .. */
2025 && isoddint) bits=DECNEG; /* .. to an odd power */
2026
2027 /* handle LHS infinity */
2028 if (decNumberIsInfinite(lhs)) { /* [NaNs already handled] */
2029 uByte rbits=rhs->bits; /* save */
2030 decNumberZero(res); /* prepare */
2031 if (n==0) *res->lsu=1; /* [-]Inf**0 => 1 */
2032 else {
2033 /* -Inf**nonint -> error */
2034 if (!rhsint && decNumberIsNegative(lhs)) {
2035 status|=DEC_Invalid_operation; /* -Inf**nonint is error */
2036 break;}
2037 if (!(rbits & DECNEG)) bits|=DECINF; /* was not a **-n */
2038 /* [otherwise will be 0 or -0] */
2039 res->bits=bits;
2040 }
2041 break;}
2042
2043 /* similarly handle LHS zero */
2044 if (decNumberIsZero(lhs)) {
2045 if (n==0) { /* 0**0 => Error */
2046 #if DECSUBSET
2047 if (!set->extended) { /* [unless subset] */
2048 decNumberZero(res);
2049 *res->lsu=1; /* return 1 */
2050 break;}
2051 #endif
2052 status|=DEC_Invalid_operation;
2053 }
2054 else { /* 0**x */
2055 uByte rbits=rhs->bits; /* save */
2056 if (rbits & DECNEG) { /* was a 0**(-n) */
2057 #if DECSUBSET
2058 if (!set->extended) { /* [bad if subset] */
2059 status|=DEC_Invalid_operation;
2060 break;}
2061 #endif
2062 bits|=DECINF;
2063 }
2064 decNumberZero(res); /* prepare */
2065 /* [otherwise will be 0 or -0] */
2066 res->bits=bits;
2067 }
2068 break;}
2069
2070 /* here both lhs and rhs are finite; rhs==0 is handled in the */
2071 /* integer path. Next handle the non-integer cases */
2072 if (!useint) { /* non-integral rhs */
2073 /* any -ve lhs is bad, as is either operand or context out of */
2074 /* bounds */
2075 if (decNumberIsNegative(lhs)) {
2076 status|=DEC_Invalid_operation;
2077 break;}
2078 if (decCheckMath(lhs, set, &status)
2079 || decCheckMath(rhs, set, &status)) break; /* variable status */
2080
2081 decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
2082 aset.emax=DEC_MAX_MATH; /* usual bounds */
2083 aset.emin=-DEC_MAX_MATH; /* .. */
2084 aset.clamp=0; /* and no concrete format */
2085
2086 /* calculate the result using exp(ln(lhs)*rhs), which can */
2087 /* all be done into the accumulator, dac. The precision needed */
2088 /* is enough to contain the full information in the lhs (which */
2089 /* is the total digits, including exponent), or the requested */
2090 /* precision, if larger, + 4; 6 is used for the exponent */
2091 /* maximum length, and this is also used when it is shorter */
2092 /* than the requested digits as it greatly reduces the >0.5 ulp */
2093 /* cases at little cost (because Ln doubles digits each */
2094 /* iteration so a few extra digits rarely causes an extra */
2095 /* iteration) */
2096 aset.digits=MAXI(lhs->digits, set->digits)+6+4;
2097 } /* non-integer rhs */
2098
2099 else { /* rhs is in-range integer */
2100 if (n==0) { /* x**0 = 1 */
2101 /* (0**0 was handled above) */
2102 decNumberZero(res); /* result=1 */
2103 *res->lsu=1; /* .. */
2104 break;}
2105 /* rhs is a non-zero integer */
2106 if (n<0) n=-n; /* use abs(n) */
2107
2108 aset=*set; /* clone the context */
2109 aset.round=DEC_ROUND_HALF_EVEN; /* internally use balanced */
2110 /* calculate the working DIGITS */
2111 aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2;
2112 #if DECSUBSET
2113 if (!set->extended) aset.digits--; /* use classic precision */
2114 #endif
2115 /* it's an error if this is more than can be handled */
2116 if (aset.digits>DECNUMMAXP) {status|=DEC_Invalid_operation; break;}
2117 } /* integer path */
2118
2119 /* aset.digits is the count of digits for the accumulator needed */
2120 /* if accumulator is too long for local storage, then allocate */
2121 needbytes=sizeof(decNumber)+(D2U(aset.digits)-1)*sizeof(Unit);
2122 /* [needbytes also used below if 1/lhs needed] */
2123 if (needbytes>sizeof(dacbuff)) {
2124 allocdac=(decNumber *)malloc(needbytes);
2125 if (allocdac==NULL) { /* hopeless -- abandon */
2126 status|=DEC_Insufficient_storage;
2127 break;}
2128 dac=allocdac; /* use the allocated space */
2129 }
2130 /* here, aset is set up and accumulator is ready for use */
2131
2132 if (!useint) { /* non-integral rhs */
2133 /* x ** y; special-case x=1 here as it will otherwise always */
2134 /* reduce to integer 1; decLnOp has a fastpath which detects */
2135 /* the case of x=1 */
2136 decLnOp(dac, lhs, &aset, &status); /* dac=ln(lhs) */
2137 /* [no error possible, as lhs 0 already handled] */
2138 if (ISZERO(dac)) { /* x==1, 1.0, etc. */
2139 /* need to return fully-padded 1.0000 etc., but rhsint->1 */
2140 *dac->lsu=1; /* was 0, make int 1 */
2141 if (!rhsint) { /* add padding */
2142 Int shift=set->digits-1;
2143 dac->digits=decShiftToMost(dac->lsu, 1, shift);
2144 dac->exponent=-shift; /* make 1.0000... */
2145 status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */
2146 }
2147 }
2148 else {
2149 decMultiplyOp(dac, dac, rhs, &aset, &status); /* dac=dac*rhs */
2150 decExpOp(dac, dac, &aset, &status); /* dac=exp(dac) */
2151 }
2152 /* and drop through for final rounding */
2153 } /* non-integer rhs */
2154
2155 else { /* carry on with integer */
2156 decNumberZero(dac); /* acc=1 */
2157 *dac->lsu=1; /* .. */
2158
2159 /* if a negative power the constant 1 is needed, and if not subset */
2160 /* invert the lhs now rather than inverting the result later */
2161 if (decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */
2162 decNumber *inv=invbuff; /* asssume use fixed buffer */
2163 decNumberCopy(&dnOne, dac); /* dnOne=1; [needed now or later] */
2164 #if DECSUBSET
2165 if (set->extended) { /* need to calculate 1/lhs */
2166 #endif
2167 /* divide lhs into 1, putting result in dac [dac=1/dac] */
2168 decDivideOp(dac, &dnOne, lhs, &aset, DIVIDE, &status);
2169 /* now locate or allocate space for the inverted lhs */
2170 if (needbytes>sizeof(invbuff)) {
2171 allocinv=(decNumber *)malloc(needbytes);
2172 if (allocinv==NULL) { /* hopeless -- abandon */
2173 status|=DEC_Insufficient_storage;
2174 break;}
2175 inv=allocinv; /* use the allocated space */
2176 }
2177 /* [inv now points to big-enough buffer or allocated storage] */
2178 decNumberCopy(inv, dac); /* copy the 1/lhs */
2179 decNumberCopy(dac, &dnOne); /* restore acc=1 */
2180 lhs=inv; /* .. and go forward with new lhs */
2181 #if DECSUBSET
2182 }
2183 #endif
2184 }
2185
2186 /* Raise-to-the-power loop... */
2187 seenbit=0; /* set once a 1-bit is encountered */
2188 for (i=1;;i++){ /* for each bit [top bit ignored] */
2189 /* abandon if had overflow or terminal underflow */
2190 if (status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
2191 if (status&DEC_Overflow || ISZERO(dac)) break;
2192 }
2193 /* [the following two lines revealed an optimizer bug in a C++ */
2194 /* compiler, with symptom: 5**3 -> 25, when n=n+n was used] */
2195 n=n<<1; /* move next bit to testable position */
2196 if (n<0) { /* top bit is set */
2197 seenbit=1; /* OK, significant bit seen */
2198 decMultiplyOp(dac, dac, lhs, &aset, &status); /* dac=dac*x */
2199 }
2200 if (i==31) break; /* that was the last bit */
2201 if (!seenbit) continue; /* no need to square 1 */
2202 decMultiplyOp(dac, dac, dac, &aset, &status); /* dac=dac*dac [square] */
2203 } /*i*/ /* 32 bits */
2204
2205 /* complete internal overflow or underflow processing */
2206 if (status & (DEC_Overflow|DEC_Underflow)) {
2207 #if DECSUBSET
2208 /* If subset, and power was negative, reverse the kind of -erflow */
2209 /* [1/x not yet done] */
2210 if (!set->extended && decNumberIsNegative(rhs)) {
2211 if (status & DEC_Overflow)
2212 status^=DEC_Overflow | DEC_Underflow | DEC_Subnormal;
2213 else { /* trickier -- Underflow may or may not be set */
2214 status&=~(DEC_Underflow | DEC_Subnormal); /* [one or both] */
2215 status|=DEC_Overflow;
2216 }
2217 }
2218 #endif
2219 dac->bits=(dac->bits & ~DECNEG) | bits; /* force correct sign */
2220 /* round subnormals [to set.digits rather than aset.digits] */
2221 /* or set overflow result similarly as required */
2222 decFinalize(dac, set, &residue, &status);
2223 decNumberCopy(res, dac); /* copy to result (is now OK length) */
2224 break;
2225 }
2226
2227 #if DECSUBSET
2228 if (!set->extended && /* subset math */
2229 decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */
2230 /* so divide result into 1 [dac=1/dac] */
2231 decDivideOp(dac, &dnOne, dac, &aset, DIVIDE, &status);
2232 }
2233 #endif
2234 } /* rhs integer path */
2235
2236 /* reduce result to the requested length and copy to result */
2237 decCopyFit(res, dac, set, &residue, &status);
2238 decFinish(res, set, &residue, &status); /* final cleanup */
2239 #if DECSUBSET
2240 if (!set->extended) decTrim(res, set, 0, &dropped); /* trailing zeros */
2241 #endif
2242 } while(0); /* end protected */
2243
2244 if (allocdac!=NULL) free(allocdac); /* drop any storage used */
2245 if (allocinv!=NULL) free(allocinv); /* .. */
2246 #if DECSUBSET
2247 if (alloclhs!=NULL) free(alloclhs); /* .. */
2248 if (allocrhs!=NULL) free(allocrhs); /* .. */
2249 #endif
2250 if (status!=0) decStatus(res, status, set);
2251 #if DECCHECK
2252 decCheckInexact(res, set);
2253 #endif
2254 return res;
2255 } /* decNumberPower */
2256
2257 /* ------------------------------------------------------------------ */
2258 /* decNumberQuantize -- force exponent to requested value */
2259 /* */
2260 /* This computes C = op(A, B), where op adjusts the coefficient */
2261 /* of C (by rounding or shifting) such that the exponent (-scale) */
2262 /* of C has exponent of B. The numerical value of C will equal A, */
2263 /* except for the effects of any rounding that occurred. */
2264 /* */
2265 /* res is C, the result. C may be A or B */
2266 /* lhs is A, the number to adjust */
2267 /* rhs is B, the number with exponent to match */
2268 /* set is the context */
2269 /* */
2270 /* C must have space for set->digits digits. */
2271 /* */
2272 /* Unless there is an error or the result is infinite, the exponent */
2273 /* after the operation is guaranteed to be equal to that of B. */
2274 /* ------------------------------------------------------------------ */
2275 decNumber * decNumberQuantize(decNumber *res, const decNumber *lhs,
2276 const decNumber *rhs, decContext *set) {
2277 uInt status=0; /* accumulator */
2278 decQuantizeOp(res, lhs, rhs, set, 1, &status);
2279 if (status!=0) decStatus(res, status, set);
2280 return res;
2281 } /* decNumberQuantize */
2282
2283 /* ------------------------------------------------------------------ */
2284 /* decNumberReduce -- remove trailing zeros */
2285 /* */
2286 /* This computes C = 0 + A, and normalizes the result */
2287 /* */
2288 /* res is C, the result. C may be A */
2289 /* rhs is A */
2290 /* set is the context */
2291 /* */
2292 /* C must have space for set->digits digits. */
2293 /* ------------------------------------------------------------------ */
2294 /* Previously known as Normalize */
2295 decNumber * decNumberNormalize(decNumber *res, const decNumber *rhs,
2296 decContext *set) {
2297 return decNumberReduce(res, rhs, set);
2298 } /* decNumberNormalize */
2299
2300 decNumber * decNumberReduce(decNumber *res, const decNumber *rhs,
2301 decContext *set) {
2302 #if DECSUBSET
2303 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
2304 #endif
2305 uInt status=0; /* as usual */
2306 Int residue=0; /* as usual */
2307 Int dropped; /* work */
2308
2309 #if DECCHECK
2310 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2311 #endif
2312
2313 do { /* protect allocated storage */
2314 #if DECSUBSET
2315 if (!set->extended) {
2316 /* reduce operand and set lostDigits status, as needed */
2317 if (rhs->digits>set->digits) {
2318 allocrhs=decRoundOperand(rhs, set, &status);
2319 if (allocrhs==NULL) break;
2320 rhs=allocrhs;
2321 }
2322 }
2323 #endif
2324 /* [following code does not require input rounding] */
2325
2326 /* Infinities copy through; NaNs need usual treatment */
2327 if (decNumberIsNaN(rhs)) {
2328 decNaNs(res, rhs, NULL, set, &status);
2329 break;
2330 }
2331
2332 /* reduce result to the requested length and copy to result */
2333 decCopyFit(res, rhs, set, &residue, &status); /* copy & round */
2334 decFinish(res, set, &residue, &status); /* cleanup/set flags */
2335 decTrim(res, set, 1, &dropped); /* normalize in place */
2336 } while(0); /* end protected */
2337
2338 #if DECSUBSET
2339 if (allocrhs !=NULL) free(allocrhs); /* .. */
2340 #endif
2341 if (status!=0) decStatus(res, status, set);/* then report status */
2342 return res;
2343 } /* decNumberReduce */
2344
2345 /* ------------------------------------------------------------------ */
2346 /* decNumberRescale -- force exponent to requested value */
2347 /* */
2348 /* This computes C = op(A, B), where op adjusts the coefficient */
2349 /* of C (by rounding or shifting) such that the exponent (-scale) */
2350 /* of C has the value B. The numerical value of C will equal A, */
2351 /* except for the effects of any rounding that occurred. */
2352 /* */
2353 /* res is C, the result. C may be A or B */
2354 /* lhs is A, the number to adjust */
2355 /* rhs is B, the requested exponent */
2356 /* set is the context */
2357 /* */
2358 /* C must have space for set->digits digits. */
2359 /* */
2360 /* Unless there is an error or the result is infinite, the exponent */
2361 /* after the operation is guaranteed to be equal to B. */
2362 /* ------------------------------------------------------------------ */
2363 decNumber * decNumberRescale(decNumber *res, const decNumber *lhs,
2364 const decNumber *rhs, decContext *set) {
2365 uInt status=0; /* accumulator */
2366 decQuantizeOp(res, lhs, rhs, set, 0, &status);
2367 if (status!=0) decStatus(res, status, set);
2368 return res;
2369 } /* decNumberRescale */
2370
2371 /* ------------------------------------------------------------------ */
2372 /* decNumberRemainder -- divide and return remainder */
2373 /* */
2374 /* This computes C = A % B */
2375 /* */
2376 /* res is C, the result. C may be A and/or B (e.g., X=X%X) */
2377 /* lhs is A */
2378 /* rhs is B */
2379 /* set is the context */
2380 /* */
2381 /* C must have space for set->digits digits. */
2382 /* ------------------------------------------------------------------ */
2383 decNumber * decNumberRemainder(decNumber *res, const decNumber *lhs,
2384 const decNumber *rhs, decContext *set) {
2385 uInt status=0; /* accumulator */
2386 decDivideOp(res, lhs, rhs, set, REMAINDER, &status);
2387 if (status!=0) decStatus(res, status, set);
2388 #if DECCHECK
2389 decCheckInexact(res, set);
2390 #endif
2391 return res;
2392 } /* decNumberRemainder */
2393
2394 /* ------------------------------------------------------------------ */
2395 /* decNumberRemainderNear -- divide and return remainder from nearest */
2396 /* */
2397 /* This computes C = A % B, where % is the IEEE remainder operator */
2398 /* */
2399 /* res is C, the result. C may be A and/or B (e.g., X=X%X) */
2400 /* lhs is A */
2401 /* rhs is B */
2402 /* set is the context */
2403 /* */
2404 /* C must have space for set->digits digits. */
2405 /* ------------------------------------------------------------------ */
2406 decNumber * decNumberRemainderNear(decNumber *res, const decNumber *lhs,
2407 const decNumber *rhs, decContext *set) {
2408 uInt status=0; /* accumulator */
2409 decDivideOp(res, lhs, rhs, set, REMNEAR, &status);
2410 if (status!=0) decStatus(res, status, set);
2411 #if DECCHECK
2412 decCheckInexact(res, set);
2413 #endif
2414 return res;
2415 } /* decNumberRemainderNear */
2416
2417 /* ------------------------------------------------------------------ */
2418 /* decNumberRotate -- rotate the coefficient of a Number left/right */
2419 /* */
2420 /* This computes C = A rot B (in base ten and rotating set->digits */
2421 /* digits). */
2422 /* */
2423 /* res is C, the result. C may be A and/or B (e.g., X=XrotX) */
2424 /* lhs is A */
2425 /* rhs is B, the number of digits to rotate (-ve to right) */
2426 /* set is the context */
2427 /* */
2428 /* The digits of the coefficient of A are rotated to the left (if B */
2429 /* is positive) or to the right (if B is negative) without adjusting */
2430 /* the exponent or the sign of A. If lhs->digits is less than */
2431 /* set->digits the coefficient is padded with zeros on the left */
2432 /* before the rotate. Any leading zeros in the result are removed */
2433 /* as usual. */
2434 /* */
2435 /* B must be an integer (q=0) and in the range -set->digits through */
2436 /* +set->digits. */
2437 /* C must have space for set->digits digits. */
2438 /* NaNs are propagated as usual. Infinities are unaffected (but */
2439 /* B must be valid). No status is set unless B is invalid or an */
2440 /* operand is an sNaN. */
2441 /* ------------------------------------------------------------------ */
2442 decNumber * decNumberRotate(decNumber *res, const decNumber *lhs,
2443 const decNumber *rhs, decContext *set) {
2444 uInt status=0; /* accumulator */
2445 Int rotate; /* rhs as an Int */
2446
2447 #if DECCHECK
2448 if (decCheckOperands(res, lhs, rhs, set)) return res;
2449 #endif
2450
2451 /* NaNs propagate as normal */
2452 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2453 decNaNs(res, lhs, rhs, set, &status);
2454 /* rhs must be an integer */
2455 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2456 status=DEC_Invalid_operation;
2457 else { /* both numeric, rhs is an integer */
2458 rotate=decGetInt(rhs); /* [cannot fail] */
2459 if (rotate==BADINT /* something bad .. */
2460 || rotate==BIGODD || rotate==BIGEVEN /* .. very big .. */
2461 || abs(rotate)>set->digits) /* .. or out of range */
2462 status=DEC_Invalid_operation;
2463 else { /* rhs is OK */
2464 decNumberCopy(res, lhs);
2465 /* convert -ve rotate to equivalent positive rotation */
2466 if (rotate<0) rotate=set->digits+rotate;
2467 if (rotate!=0 && rotate!=set->digits /* zero or full rotation */
2468 && !decNumberIsInfinite(res)) { /* lhs was infinite */
2469 /* left-rotate to do; 0 < rotate < set->digits */
2470 uInt units, shift; /* work */
2471 uInt msudigits; /* digits in result msu */
2472 Unit *msu=res->lsu+D2U(res->digits)-1; /* current msu */
2473 Unit *msumax=res->lsu+D2U(set->digits)-1; /* rotation msu */
2474 for (msu++; msu<=msumax; msu++) *msu=0; /* ensure high units=0 */
2475 res->digits=set->digits; /* now full-length */
2476 msudigits=MSUDIGITS(res->digits); /* actual digits in msu */
2477
2478 /* rotation here is done in-place, in three steps */
2479 /* 1. shift all to least up to one unit to unit-align final */
2480 /* lsd [any digits shifted out are rotated to the left, */
2481 /* abutted to the original msd (which may require split)] */
2482 /* */
2483 /* [if there are no whole units left to rotate, the */
2484 /* rotation is now complete] */
2485 /* */
2486 /* 2. shift to least, from below the split point only, so that */
2487 /* the final msd is in the right place in its Unit [any */
2488 /* digits shifted out will fit exactly in the current msu, */
2489 /* left aligned, no split required] */
2490 /* */
2491 /* 3. rotate all the units by reversing left part, right */
2492 /* part, and then whole */
2493 /* */
2494 /* example: rotate right 8 digits (2 units + 2), DECDPUN=3. */
2495 /* */
2496 /* start: 00a bcd efg hij klm npq */
2497 /* */
2498 /* 1a 000 0ab cde fgh|ijk lmn [pq saved] */
2499 /* 1b 00p qab cde fgh|ijk lmn */
2500 /* */
2501 /* 2a 00p qab cde fgh|00i jkl [mn saved] */
2502 /* 2b mnp qab cde fgh|00i jkl */
2503 /* */
2504 /* 3a fgh cde qab mnp|00i jkl */
2505 /* 3b fgh cde qab mnp|jkl 00i */
2506 /* 3c 00i jkl mnp qab cde fgh */
2507
2508 /* Step 1: amount to shift is the partial right-rotate count */
2509 rotate=set->digits-rotate; /* make it right-rotate */
2510 units=rotate/DECDPUN; /* whole units to rotate */
2511 shift=rotate%DECDPUN; /* left-over digits count */
2512 if (shift>0) { /* not an exact number of units */
2513 uInt save=res->lsu[0]%powers[shift]; /* save low digit(s) */
2514 decShiftToLeast(res->lsu, D2U(res->digits), shift);
2515 if (shift>msudigits) { /* msumax-1 needs >0 digits */
2516 uInt rem=save%powers[shift-msudigits];/* split save */
2517 *msumax=(Unit)(save/powers[shift-msudigits]); /* and insert */
2518 *(msumax-1)=*(msumax-1)
2519 +(Unit)(rem*powers[DECDPUN-(shift-msudigits)]); /* .. */
2520 }
2521 else { /* all fits in msumax */
2522 *msumax=*msumax+(Unit)(save*powers[msudigits-shift]); /* [maybe *1] */
2523 }
2524 } /* digits shift needed */
2525
2526 /* If whole units to rotate... */
2527 if (units>0) { /* some to do */
2528 /* Step 2: the units to touch are the whole ones in rotate, */
2529 /* if any, and the shift is DECDPUN-msudigits (which may be */
2530 /* 0, again) */
2531 shift=DECDPUN-msudigits;
2532 if (shift>0) { /* not an exact number of units */
2533 uInt save=res->lsu[0]%powers[shift]; /* save low digit(s) */
2534 decShiftToLeast(res->lsu, units, shift);
2535 *msumax=*msumax+(Unit)(save*powers[msudigits]);
2536 } /* partial shift needed */
2537
2538 /* Step 3: rotate the units array using triple reverse */
2539 /* (reversing is easy and fast) */
2540 decReverse(res->lsu+units, msumax); /* left part */
2541 decReverse(res->lsu, res->lsu+units-1); /* right part */
2542 decReverse(res->lsu, msumax); /* whole */
2543 } /* whole units to rotate */
2544 /* the rotation may have left an undetermined number of zeros */
2545 /* on the left, so true length needs to be calculated */
2546 res->digits=decGetDigits(res->lsu, msumax-res->lsu+1);
2547 } /* rotate needed */
2548 } /* rhs OK */
2549 } /* numerics */
2550 if (status!=0) decStatus(res, status, set);
2551 return res;
2552 } /* decNumberRotate */
2553
2554 /* ------------------------------------------------------------------ */
2555 /* decNumberSameQuantum -- test for equal exponents */
2556 /* */
2557 /* res is the result number, which will contain either 0 or 1 */
2558 /* lhs is a number to test */
2559 /* rhs is the second (usually a pattern) */
2560 /* */
2561 /* No errors are possible and no context is needed. */
2562 /* ------------------------------------------------------------------ */
2563 decNumber * decNumberSameQuantum(decNumber *res, const decNumber *lhs,
2564 const decNumber *rhs) {
2565 Unit ret=0; /* return value */
2566
2567 #if DECCHECK
2568 if (decCheckOperands(res, lhs, rhs, DECUNCONT)) return res;
2569 #endif
2570
2571 if (SPECIALARGS) {
2572 if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1;
2573 else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1;
2574 /* [anything else with a special gives 0] */
2575 }
2576 else if (lhs->exponent==rhs->exponent) ret=1;
2577
2578 decNumberZero(res); /* OK to overwrite an operand now */
2579 *res->lsu=ret;
2580 return res;
2581 } /* decNumberSameQuantum */
2582
2583 /* ------------------------------------------------------------------ */
2584 /* decNumberScaleB -- multiply by a power of 10 */
2585 /* */
2586 /* This computes C = A x 10**B where B is an integer (q=0) with */
2587 /* maximum magnitude 2*(emax+digits) */
2588 /* */
2589 /* res is C, the result. C may be A or B */
2590 /* lhs is A, the number to adjust */
2591 /* rhs is B, the requested power of ten to use */
2592 /* set is the context */
2593 /* */
2594 /* C must have space for set->digits digits. */
2595 /* */
2596 /* The result may underflow or overflow. */
2597 /* ------------------------------------------------------------------ */
2598 decNumber * decNumberScaleB(decNumber *res, const decNumber *lhs,
2599 const decNumber *rhs, decContext *set) {
2600 Int reqexp; /* requested exponent change [B] */
2601 uInt status=0; /* accumulator */
2602 Int residue; /* work */
2603
2604 #if DECCHECK
2605 if (decCheckOperands(res, lhs, rhs, set)) return res;
2606 #endif
2607
2608 /* Handle special values except lhs infinite */
2609 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2610 decNaNs(res, lhs, rhs, set, &status);
2611 /* rhs must be an integer */
2612 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2613 status=DEC_Invalid_operation;
2614 else {
2615 /* lhs is a number; rhs is a finite with q==0 */
2616 reqexp=decGetInt(rhs); /* [cannot fail] */
2617 if (reqexp==BADINT /* something bad .. */
2618 || reqexp==BIGODD || reqexp==BIGEVEN /* .. very big .. */
2619 || abs(reqexp)>(2*(set->digits+set->emax))) /* .. or out of range */
2620 status=DEC_Invalid_operation;
2621 else { /* rhs is OK */
2622 decNumberCopy(res, lhs); /* all done if infinite lhs */
2623 if (!decNumberIsInfinite(res)) { /* prepare to scale */
2624 res->exponent+=reqexp; /* adjust the exponent */
2625 residue=0;
2626 decFinalize(res, set, &residue, &status); /* .. and check */
2627 } /* finite LHS */
2628 } /* rhs OK */
2629 } /* rhs finite */
2630 if (status!=0) decStatus(res, status, set);
2631 return res;
2632 } /* decNumberScaleB */
2633
2634 /* ------------------------------------------------------------------ */
2635 /* decNumberShift -- shift the coefficient of a Number left or right */
2636 /* */
2637 /* This computes C = A << B or C = A >> -B (in base ten). */
2638 /* */
2639 /* res is C, the result. C may be A and/or B (e.g., X=X<<X) */
2640 /* lhs is A */
2641 /* rhs is B, the number of digits to shift (-ve to right) */
2642 /* set is the context */
2643 /* */
2644 /* The digits of the coefficient of A are shifted to the left (if B */
2645 /* is positive) or to the right (if B is negative) without adjusting */
2646 /* the exponent or the sign of A. */
2647 /* */
2648 /* B must be an integer (q=0) and in the range -set->digits through */
2649 /* +set->digits. */
2650 /* C must have space for set->digits digits. */
2651 /* NaNs are propagated as usual. Infinities are unaffected (but */
2652 /* B must be valid). No status is set unless B is invalid or an */
2653 /* operand is an sNaN. */
2654 /* ------------------------------------------------------------------ */
2655 decNumber * decNumberShift(decNumber *res, const decNumber *lhs,
2656 const decNumber *rhs, decContext *set) {
2657 uInt status=0; /* accumulator */
2658 Int shift; /* rhs as an Int */
2659
2660 #if DECCHECK
2661 if (decCheckOperands(res, lhs, rhs, set)) return res;
2662 #endif
2663
2664 /* NaNs propagate as normal */
2665 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2666 decNaNs(res, lhs, rhs, set, &status);
2667 /* rhs must be an integer */
2668 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2669 status=DEC_Invalid_operation;
2670 else { /* both numeric, rhs is an integer */
2671 shift=decGetInt(rhs); /* [cannot fail] */
2672 if (shift==BADINT /* something bad .. */
2673 || shift==BIGODD || shift==BIGEVEN /* .. very big .. */
2674 || abs(shift)>set->digits) /* .. or out of range */
2675 status=DEC_Invalid_operation;
2676 else { /* rhs is OK */
2677 decNumberCopy(res, lhs);
2678 if (shift!=0 && !decNumberIsInfinite(res)) { /* something to do */
2679 if (shift>0) { /* to left */
2680 if (shift==set->digits) { /* removing all */
2681 *res->lsu=0; /* so place 0 */
2682 res->digits=1; /* .. */
2683 }
2684 else { /* */
2685 /* first remove leading digits if necessary */
2686 if (res->digits+shift>set->digits) {
2687 decDecap(res, res->digits+shift-set->digits);
2688 /* that updated res->digits; may have gone to 1 (for a */
2689 /* single digit or for zero */
2690 }
2691 if (res->digits>1 || *res->lsu) /* if non-zero.. */
2692 res->digits=decShiftToMost(res->lsu, res->digits, shift);
2693 } /* partial left */
2694 } /* left */
2695 else { /* to right */
2696 if (-shift>=res->digits) { /* discarding all */
2697 *res->lsu=0; /* so place 0 */
2698 res->digits=1; /* .. */
2699 }
2700 else {
2701 decShiftToLeast(res->lsu, D2U(res->digits), -shift);
2702 res->digits-=(-shift);
2703 }
2704 } /* to right */
2705 } /* non-0 non-Inf shift */
2706 } /* rhs OK */
2707 } /* numerics */
2708 if (status!=0) decStatus(res, status, set);
2709 return res;
2710 } /* decNumberShift */
2711
2712 /* ------------------------------------------------------------------ */
2713 /* decNumberSquareRoot -- square root operator */
2714 /* */
2715 /* This computes C = squareroot(A) */
2716 /* */
2717 /* res is C, the result. C may be A */
2718 /* rhs is A */
2719 /* set is the context; note that rounding mode has no effect */
2720 /* */
2721 /* C must have space for set->digits digits. */
2722 /* ------------------------------------------------------------------ */
2723 /* This uses the following varying-precision algorithm in: */
2724 /* */
2725 /* Properly Rounded Variable Precision Square Root, T. E. Hull and */
2726 /* A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, */
2727 /* pp229-237, ACM, September 1985. */
2728 /* */
2729 /* The square-root is calculated using Newton's method, after which */
2730 /* a check is made to ensure the result is correctly rounded. */
2731 /* */
2732 /* % [Reformatted original Numerical Turing source code follows.] */
2733 /* function sqrt(x : real) : real */
2734 /* % sqrt(x) returns the properly rounded approximation to the square */
2735 /* % root of x, in the precision of the calling environment, or it */
2736 /* % fails if x < 0. */
2737 /* % t e hull and a abrham, august, 1984 */
2738 /* if x <= 0 then */
2739 /* if x < 0 then */
2740 /* assert false */
2741 /* else */
2742 /* result 0 */
2743 /* end if */
2744 /* end if */
2745 /* var f := setexp(x, 0) % fraction part of x [0.1 <= x < 1] */
2746 /* var e := getexp(x) % exponent part of x */
2747 /* var approx : real */
2748 /* if e mod 2 = 0 then */
2749 /* approx := .259 + .819 * f % approx to root of f */
2750 /* else */
2751 /* f := f/l0 % adjustments */
2752 /* e := e + 1 % for odd */
2753 /* approx := .0819 + 2.59 * f % exponent */
2754 /* end if */
2755 /* */
2756 /* var p:= 3 */
2757 /* const maxp := currentprecision + 2 */
2758 /* loop */
2759 /* p := min(2*p - 2, maxp) % p = 4,6,10, . . . , maxp */
2760 /* precision p */
2761 /* approx := .5 * (approx + f/approx) */
2762 /* exit when p = maxp */
2763 /* end loop */
2764 /* */
2765 /* % approx is now within 1 ulp of the properly rounded square root */
2766 /* % of f; to ensure proper rounding, compare squares of (approx - */
2767 /* % l/2 ulp) and (approx + l/2 ulp) with f. */
2768 /* p := currentprecision */
2769 /* begin */
2770 /* precision p + 2 */
2771 /* const approxsubhalf := approx - setexp(.5, -p) */
2772 /* if mulru(approxsubhalf, approxsubhalf) > f then */
2773 /* approx := approx - setexp(.l, -p + 1) */
2774 /* else */
2775 /* const approxaddhalf := approx + setexp(.5, -p) */
2776 /* if mulrd(approxaddhalf, approxaddhalf) < f then */
2777 /* approx := approx + setexp(.l, -p + 1) */
2778 /* end if */
2779 /* end if */
2780 /* end */
2781 /* result setexp(approx, e div 2) % fix exponent */
2782 /* end sqrt */
2783 /* ------------------------------------------------------------------ */
2784 decNumber * decNumberSquareRoot(decNumber *res, const decNumber *rhs,
2785 decContext *set) {
2786 decContext workset, approxset; /* work contexts */
2787 decNumber dzero; /* used for constant zero */
2788 Int maxp; /* largest working precision */
2789 Int workp; /* working precision */
2790 Int residue=0; /* rounding residue */
2791 uInt status=0, ignore=0; /* status accumulators */
2792 uInt rstatus; /* .. */
2793 Int exp; /* working exponent */
2794 Int ideal; /* ideal (preferred) exponent */
2795 Int needbytes; /* work */
2796 Int dropped; /* .. */
2797
2798 #if DECSUBSET
2799 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
2800 #endif
2801 /* buffer for f [needs +1 in case DECBUFFER 0] */
2802 decNumber buff[D2N(DECBUFFER+1)];
2803 /* buffer for a [needs +2 to match likely maxp] */
2804 decNumber bufa[D2N(DECBUFFER+2)];
2805 /* buffer for temporary, b [must be same size as a] */
2806 decNumber bufb[D2N(DECBUFFER+2)];
2807 decNumber *allocbuff=NULL; /* -> allocated buff, iff allocated */
2808 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
2809 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */
2810 decNumber *f=buff; /* reduced fraction */
2811 decNumber *a=bufa; /* approximation to result */
2812 decNumber *b=bufb; /* intermediate result */
2813 /* buffer for temporary variable, up to 3 digits */
2814 decNumber buft[D2N(3)];
2815 decNumber *t=buft; /* up-to-3-digit constant or work */
2816
2817 #if DECCHECK
2818 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2819 #endif
2820
2821 do { /* protect allocated storage */
2822 #if DECSUBSET
2823 if (!set->extended) {
2824 /* reduce operand and set lostDigits status, as needed */
2825 if (rhs->digits>set->digits) {
2826 allocrhs=decRoundOperand(rhs, set, &status);
2827 if (allocrhs==NULL) break;
2828 /* [Note: 'f' allocation below could reuse this buffer if */
2829 /* used, but as this is rare they are kept separate for clarity.] */
2830 rhs=allocrhs;
2831 }
2832 }
2833 #endif
2834 /* [following code does not require input rounding] */
2835
2836 /* handle infinities and NaNs */
2837 if (SPECIALARG) {
2838 if (decNumberIsInfinite(rhs)) { /* an infinity */
2839 if (decNumberIsNegative(rhs)) status|=DEC_Invalid_operation;
2840 else decNumberCopy(res, rhs); /* +Infinity */
2841 }
2842 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
2843 break;
2844 }
2845
2846 /* calculate the ideal (preferred) exponent [floor(exp/2)] */
2847 /* [We would like to write: ideal=rhs->exponent>>1, but this */
2848 /* generates a compiler warning. Generated code is the same.] */
2849 ideal=(rhs->exponent&~1)/2; /* target */
2850
2851 /* handle zeros */
2852 if (ISZERO(rhs)) {
2853 decNumberCopy(res, rhs); /* could be 0 or -0 */
2854 res->exponent=ideal; /* use the ideal [safe] */
2855 /* use decFinish to clamp any out-of-range exponent, etc. */
2856 decFinish(res, set, &residue, &status);
2857 break;
2858 }
2859
2860 /* any other -x is an oops */
2861 if (decNumberIsNegative(rhs)) {
2862 status|=DEC_Invalid_operation;
2863 break;
2864 }
2865
2866 /* space is needed for three working variables */
2867 /* f -- the same precision as the RHS, reduced to 0.01->0.99... */
2868 /* a -- Hull's approximation -- precision, when assigned, is */
2869 /* currentprecision+1 or the input argument precision, */
2870 /* whichever is larger (+2 for use as temporary) */
2871 /* b -- intermediate temporary result (same size as a) */
2872 /* if any is too long for local storage, then allocate */
2873 workp=MAXI(set->digits+1, rhs->digits); /* actual rounding precision */
2874 maxp=workp+2; /* largest working precision */
2875
2876 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
2877 if (needbytes>(Int)sizeof(buff)) {
2878 allocbuff=(decNumber *)malloc(needbytes);
2879 if (allocbuff==NULL) { /* hopeless -- abandon */
2880 status|=DEC_Insufficient_storage;
2881 break;}
2882 f=allocbuff; /* use the allocated space */
2883 }
2884 /* a and b both need to be able to hold a maxp-length number */
2885 needbytes=sizeof(decNumber)+(D2U(maxp)-1)*sizeof(Unit);
2886 if (needbytes>(Int)sizeof(bufa)) { /* [same applies to b] */
2887 allocbufa=(decNumber *)malloc(needbytes);
2888 allocbufb=(decNumber *)malloc(needbytes);
2889 if (allocbufa==NULL || allocbufb==NULL) { /* hopeless */
2890 status|=DEC_Insufficient_storage;
2891 break;}
2892 a=allocbufa; /* use the allocated spaces */
2893 b=allocbufb; /* .. */
2894 }
2895
2896 /* copy rhs -> f, save exponent, and reduce so 0.1 <= f < 1 */
2897 decNumberCopy(f, rhs);
2898 exp=f->exponent+f->digits; /* adjusted to Hull rules */
2899 f->exponent=-(f->digits); /* to range */
2900
2901 /* set up working context */
2902 decContextDefault(&workset, DEC_INIT_DECIMAL64);
2903
2904 /* [Until further notice, no error is possible and status bits */
2905 /* (Rounded, etc.) should be ignored, not accumulated.] */
2906
2907 /* Calculate initial approximation, and allow for odd exponent */
2908 workset.digits=workp; /* p for initial calculation */
2909 t->bits=0; t->digits=3;
2910 a->bits=0; a->digits=3;
2911 if ((exp & 1)==0) { /* even exponent */
2912 /* Set t=0.259, a=0.819 */
2913 t->exponent=-3;
2914 a->exponent=-3;
2915 #if DECDPUN>=3
2916 t->lsu[0]=259;
2917 a->lsu[0]=819;
2918 #elif DECDPUN==2
2919 t->lsu[0]=59; t->lsu[1]=2;
2920 a->lsu[0]=19; a->lsu[1]=8;
2921 #else
2922 t->lsu[0]=9; t->lsu[1]=5; t->lsu[2]=2;
2923 a->lsu[0]=9; a->lsu[1]=1; a->lsu[2]=8;
2924 #endif
2925 }
2926 else { /* odd exponent */
2927 /* Set t=0.0819, a=2.59 */
2928 f->exponent--; /* f=f/10 */
2929 exp++; /* e=e+1 */
2930 t->exponent=-4;
2931 a->exponent=-2;
2932 #if DECDPUN>=3
2933 t->lsu[0]=819;
2934 a->lsu[0]=259;
2935 #elif DECDPUN==2
2936 t->lsu[0]=19; t->lsu[1]=8;
2937 a->lsu[0]=59; a->lsu[1]=2;
2938 #else
2939 t->lsu[0]=9; t->lsu[1]=1; t->lsu[2]=8;
2940 a->lsu[0]=9; a->lsu[1]=5; a->lsu[2]=2;
2941 #endif
2942 }
2943 decMultiplyOp(a, a, f, &workset, &ignore); /* a=a*f */
2944 decAddOp(a, a, t, &workset, 0, &ignore); /* ..+t */
2945 /* [a is now the initial approximation for sqrt(f), calculated with */
2946 /* currentprecision, which is also a's precision.] */
2947
2948 /* the main calculation loop */
2949 decNumberZero(&dzero); /* make 0 */
2950 decNumberZero(t); /* set t = 0.5 */
2951 t->lsu[0]=5; /* .. */
2952 t->exponent=-1; /* .. */
2953 workset.digits=3; /* initial p */
2954 for (;;) {
2955 /* set p to min(2*p - 2, maxp) [hence 3; or: 4, 6, 10, ... , maxp] */
2956 workset.digits=workset.digits*2-2;
2957 if (workset.digits>maxp) workset.digits=maxp;
2958 /* a = 0.5 * (a + f/a) */
2959 /* [calculated at p then rounded to currentprecision] */
2960 decDivideOp(b, f, a, &workset, DIVIDE, &ignore); /* b=f/a */
2961 decAddOp(b, b, a, &workset, 0, &ignore); /* b=b+a */
2962 decMultiplyOp(a, b, t, &workset, &ignore); /* a=b*0.5 */
2963 if (a->digits==maxp) break; /* have required digits */
2964 } /* loop */
2965
2966 /* Here, 0.1 <= a < 1 [Hull], and a has maxp digits */
2967 /* now reduce to length, etc.; this needs to be done with a */
2968 /* having the correct exponent so as to handle subnormals */
2969 /* correctly */
2970 approxset=*set; /* get emin, emax, etc. */
2971 approxset.round=DEC_ROUND_HALF_EVEN;
2972 a->exponent+=exp/2; /* set correct exponent */
2973
2974 rstatus=0; /* clear status */
2975 residue=0; /* .. and accumulator */
2976 decCopyFit(a, a, &approxset, &residue, &rstatus); /* reduce (if needed) */
2977 decFinish(a, &approxset, &residue, &rstatus); /* clean and finalize */
2978
2979 /* Overflow was possible if the input exponent was out-of-range, */
2980 /* in which case quit */
2981 if (rstatus&DEC_Overflow) {
2982 status=rstatus; /* use the status as-is */
2983 decNumberCopy(res, a); /* copy to result */
2984 break;
2985 }
2986
2987 /* Preserve status except Inexact/Rounded */
2988 status|=(rstatus & ~(DEC_Rounded|DEC_Inexact));
2989
2990 /* Carry out the Hull correction */
2991 a->exponent-=exp/2; /* back to 0.1->1 */
2992
2993 /* a is now at final precision and within 1 ulp of the properly */
2994 /* rounded square root of f; to ensure proper rounding, compare */
2995 /* squares of (a - l/2 ulp) and (a + l/2 ulp) with f. */
2996 /* Here workset.digits=maxp and t=0.5, and a->digits determines */
2997 /* the ulp */
2998 workset.digits--; /* maxp-1 is OK now */
2999 t->exponent=-a->digits-1; /* make 0.5 ulp */
3000 decAddOp(b, a, t, &workset, DECNEG, &ignore); /* b = a - 0.5 ulp */
3001 workset.round=DEC_ROUND_UP;
3002 decMultiplyOp(b, b, b, &workset, &ignore); /* b = mulru(b, b) */
3003 decCompareOp(b, f, b, &workset, COMPARE, &ignore); /* b ? f, reversed */
3004 if (decNumberIsNegative(b)) { /* f < b [i.e., b > f] */
3005 /* this is the more common adjustment, though both are rare */
3006 t->exponent++; /* make 1.0 ulp */
3007 t->lsu[0]=1; /* .. */
3008 decAddOp(a, a, t, &workset, DECNEG, &ignore); /* a = a - 1 ulp */
3009 /* assign to approx [round to length] */
3010 approxset.emin-=exp/2; /* adjust to match a */
3011 approxset.emax-=exp/2;
3012 decAddOp(a, &dzero, a, &approxset, 0, &ignore);
3013 }
3014 else {
3015 decAddOp(b, a, t, &workset, 0, &ignore); /* b = a + 0.5 ulp */
3016 workset.round=DEC_ROUND_DOWN;
3017 decMultiplyOp(b, b, b, &workset, &ignore); /* b = mulrd(b, b) */
3018 decCompareOp(b, b, f, &workset, COMPARE, &ignore); /* b ? f */
3019 if (decNumberIsNegative(b)) { /* b < f */
3020 t->exponent++; /* make 1.0 ulp */
3021 t->lsu[0]=1; /* .. */
3022 decAddOp(a, a, t, &workset, 0, &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);
3027 }
3028 }
3029 /* [no errors are possible in the above, and rounding/inexact during */
3030 /* estimation are irrelevant, so status was not accumulated] */
3031
3032 /* Here, 0.1 <= a < 1 (still), so adjust back */
3033 a->exponent+=exp/2; /* set correct exponent */
3034
3035 /* count droppable zeros [after any subnormal rounding] by */
3036 /* trimming a copy */
3037 decNumberCopy(b, a);
3038 decTrim(b, set, 1, &dropped); /* [drops trailing zeros] */
3039
3040 /* Set Inexact and Rounded. The answer can only be exact if */
3041 /* it is short enough so that squaring it could fit in workp digits, */
3042 /* and it cannot have trailing zeros due to clamping, so these are */
3043 /* the only (relatively rare) conditions a careful check is needed */
3044 if (b->digits*2-1 > workp && !set->clamp) { /* cannot fit */
3045 status|=DEC_Inexact|DEC_Rounded;
3046 }
3047 else { /* could be exact/unrounded */
3048 uInt mstatus=0; /* local status */
3049 decMultiplyOp(b, b, b, &workset, &mstatus); /* try the multiply */
3050 if (mstatus&DEC_Overflow) { /* result just won't fit */
3051 status|=DEC_Inexact|DEC_Rounded;
3052 }
3053 else { /* plausible */
3054 decCompareOp(t, b, rhs, &workset, COMPARE, &mstatus); /* b ? rhs */
3055 if (!ISZERO(t)) status|=DEC_Inexact|DEC_Rounded; /* not equal */
3056 else { /* is Exact */
3057 /* here, dropped is the count of trailing zeros in 'a' */
3058 /* use closest exponent to ideal... */
3059 Int todrop=ideal-a->exponent; /* most that can be dropped */
3060 if (todrop<0) status|=DEC_Rounded; /* ideally would add 0s */
3061 else { /* unrounded */
3062 if (dropped<todrop) { /* clamp to those available */
3063 todrop=dropped;
3064 status|=DEC_Clamped;
3065 }
3066 if (todrop>0) { /* have some to drop */
3067 decShiftToLeast(a->lsu, D2U(a->digits), todrop);
3068 a->exponent+=todrop; /* maintain numerical value */
3069 a->digits-=todrop; /* new length */
3070 }
3071 }
3072 }
3073 }
3074 }
3075
3076 /* double-check Underflow, as perhaps the result could not have */
3077 /* been subnormal (initial argument too big), or it is now Exact */
3078 if (status&DEC_Underflow) {
3079 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */
3080 /* check if truly subnormal */
3081 #if DECEXTFLAG /* DEC_Subnormal too */
3082 if (ae>=set->emin*2) status&=~(DEC_Subnormal|DEC_Underflow);
3083 #else
3084 if (ae>=set->emin*2) status&=~DEC_Underflow;
3085 #endif
3086 /* check if truly inexact */
3087 if (!(status&DEC_Inexact)) status&=~DEC_Underflow;
3088 }
3089
3090 decNumberCopy(res, a); /* a is now the result */
3091 } while(0); /* end protected */
3092
3093 if (allocbuff!=NULL) free(allocbuff); /* drop any storage used */
3094 if (allocbufa!=NULL) free(allocbufa); /* .. */
3095 if (allocbufb!=NULL) free(allocbufb); /* .. */
3096 #if DECSUBSET
3097 if (allocrhs !=NULL) free(allocrhs); /* .. */
3098 #endif
3099 if (status!=0) decStatus(res, status, set);/* then report status */
3100 #if DECCHECK
3101 decCheckInexact(res, set);
3102 #endif
3103 return res;
3104 } /* decNumberSquareRoot */
3105
3106 /* ------------------------------------------------------------------ */
3107 /* decNumberSubtract -- subtract two Numbers */
3108 /* */
3109 /* This computes C = A - B */
3110 /* */
3111 /* res is C, the result. C may be A and/or B (e.g., X=X-X) */
3112 /* lhs is A */
3113 /* rhs is B */
3114 /* set is the context */
3115 /* */
3116 /* C must have space for set->digits digits. */
3117 /* ------------------------------------------------------------------ */
3118 decNumber * decNumberSubtract(decNumber *res, const decNumber *lhs,
3119 const decNumber *rhs, decContext *set) {
3120 uInt status=0; /* accumulator */
3121
3122 decAddOp(res, lhs, rhs, set, DECNEG, &status);
3123 if (status!=0) decStatus(res, status, set);
3124 #if DECCHECK
3125 decCheckInexact(res, set);
3126 #endif
3127 return res;
3128 } /* decNumberSubtract */
3129
3130 /* ------------------------------------------------------------------ */
3131 /* decNumberToIntegralExact -- round-to-integral-value with InExact */
3132 /* decNumberToIntegralValue -- round-to-integral-value */
3133 /* */
3134 /* res is the result */
3135 /* rhs is input number */
3136 /* set is the context */
3137 /* */
3138 /* res must have space for any value of rhs. */
3139 /* */
3140 /* This implements the IEEE special operators and therefore treats */
3141 /* special values as valid. For finite numbers it returns */
3142 /* rescale(rhs, 0) if rhs->exponent is <0. */
3143 /* Otherwise the result is rhs (so no error is possible, except for */
3144 /* sNaN). */
3145 /* */
3146 /* The context is used for rounding mode and status after sNaN, but */
3147 /* the digits setting is ignored. The Exact version will signal */
3148 /* Inexact if the result differs numerically from rhs; the other */
3149 /* never signals Inexact. */
3150 /* ------------------------------------------------------------------ */
3151 decNumber * decNumberToIntegralExact(decNumber *res, const decNumber *rhs,
3152 decContext *set) {
3153 decNumber dn;
3154 decContext workset; /* working context */
3155 uInt status=0; /* accumulator */
3156
3157 #if DECCHECK
3158 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
3159 #endif
3160
3161 /* handle infinities and NaNs */
3162 if (SPECIALARG) {
3163 if (decNumberIsInfinite(rhs)) decNumberCopy(res, rhs); /* an Infinity */
3164 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
3165 }
3166 else { /* finite */
3167 /* have a finite number; no error possible (res must be big enough) */
3168 if (rhs->exponent>=0) return decNumberCopy(res, rhs);
3169 /* that was easy, but if negative exponent there is work to do... */
3170 workset=*set; /* clone rounding, etc. */
3171 workset.digits=rhs->digits; /* no length rounding */
3172 workset.traps=0; /* no traps */
3173 decNumberZero(&dn); /* make a number with exponent 0 */
3174 decNumberQuantize(res, rhs, &dn, &workset);
3175 status|=workset.status;
3176 }
3177 if (status!=0) decStatus(res, status, set);
3178 return res;
3179 } /* decNumberToIntegralExact */
3180
3181 decNumber * decNumberToIntegralValue(decNumber *res, const decNumber *rhs,
3182 decContext *set) {
3183 decContext workset=*set; /* working context */
3184 workset.traps=0; /* no traps */
3185 decNumberToIntegralExact(res, rhs, &workset);
3186 /* this never affects set, except for sNaNs; NaN will have been set */
3187 /* or propagated already, so no need to call decStatus */
3188 set->status|=workset.status&DEC_Invalid_operation;
3189 return res;
3190 } /* decNumberToIntegralValue */
3191
3192 /* ------------------------------------------------------------------ */
3193 /* decNumberXor -- XOR two Numbers, digitwise */
3194 /* */
3195 /* This computes C = A ^ B */
3196 /* */
3197 /* res is C, the result. C may be A and/or B (e.g., X=X^X) */
3198 /* lhs is A */
3199 /* rhs is B */
3200 /* set is the context (used for result length and error report) */
3201 /* */
3202 /* C must have space for set->digits digits. */
3203 /* */
3204 /* Logical function restrictions apply (see above); a NaN is */
3205 /* returned with Invalid_operation if a restriction is violated. */
3206 /* ------------------------------------------------------------------ */
3207 decNumber * decNumberXor(decNumber *res, const decNumber *lhs,
3208 const decNumber *rhs, decContext *set) {
3209 const Unit *ua, *ub; /* -> operands */
3210 const Unit *msua, *msub; /* -> operand msus */
3211 Unit *uc, *msuc; /* -> result and its msu */
3212 Int msudigs; /* digits in res msu */
3213 #if DECCHECK
3214 if (decCheckOperands(res, lhs, rhs, set)) return res;
3215 #endif
3216
3217 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
3218 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
3219 decStatus(res, DEC_Invalid_operation, set);
3220 return res;
3221 }
3222 /* operands are valid */
3223 ua=lhs->lsu; /* bottom-up */
3224 ub=rhs->lsu; /* .. */
3225 uc=res->lsu; /* .. */
3226 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */
3227 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */
3228 msuc=uc+D2U(set->digits)-1; /* -> msu of result */
3229 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */
3230 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */
3231 Unit a, b; /* extract units */
3232 if (ua>msua) a=0;
3233 else a=*ua;
3234 if (ub>msub) b=0;
3235 else b=*ub;
3236 *uc=0; /* can now write back */
3237 if (a|b) { /* maybe 1 bits to examine */
3238 Int i, j;
3239 /* This loop could be unrolled and/or use BIN2BCD tables */
3240 for (i=0; i<DECDPUN; i++) {
3241 if ((a^b)&1) *uc=*uc+(Unit)powers[i]; /* effect XOR */
3242 j=a%10;
3243 a=a/10;
3244 j|=b%10;
3245 b=b/10;
3246 if (j>1) {
3247 decStatus(res, DEC_Invalid_operation, set);
3248 return res;
3249 }
3250 if (uc==msuc && i==msudigs-1) break; /* just did final digit */
3251 } /* each digit */
3252 } /* non-zero */
3253 } /* each unit */
3254 /* [here uc-1 is the msu of the result] */
3255 res->digits=decGetDigits(res->lsu, uc-res->lsu);
3256 res->exponent=0; /* integer */
3257 res->bits=0; /* sign=0 */
3258 return res; /* [no status to set] */
3259 } /* decNumberXor */
3260
3261
3262 /* ================================================================== */
3263 /* Utility routines */
3264 /* ================================================================== */
3265
3266 /* ------------------------------------------------------------------ */
3267 /* decNumberClass -- return the decClass of a decNumber */
3268 /* dn -- the decNumber to test */
3269 /* set -- the context to use for Emin */
3270 /* returns the decClass enum */
3271 /* ------------------------------------------------------------------ */
3272 enum decClass decNumberClass(const decNumber *dn, decContext *set) {
3273 if (decNumberIsSpecial(dn)) {
3274 if (decNumberIsQNaN(dn)) return DEC_CLASS_QNAN;
3275 if (decNumberIsSNaN(dn)) return DEC_CLASS_SNAN;
3276 /* must be an infinity */
3277 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_INF;
3278 return DEC_CLASS_POS_INF;
3279 }
3280 /* is finite */
3281 if (decNumberIsNormal(dn, set)) { /* most common */
3282 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_NORMAL;
3283 return DEC_CLASS_POS_NORMAL;
3284 }
3285 /* is subnormal or zero */
3286 if (decNumberIsZero(dn)) { /* most common */
3287 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_ZERO;
3288 return DEC_CLASS_POS_ZERO;
3289 }
3290 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_SUBNORMAL;
3291 return DEC_CLASS_POS_SUBNORMAL;
3292 } /* decNumberClass */
3293
3294 /* ------------------------------------------------------------------ */
3295 /* decNumberClassToString -- convert decClass to a string */
3296 /* */
3297 /* eclass is a valid decClass */
3298 /* returns a constant string describing the class (max 13+1 chars) */
3299 /* ------------------------------------------------------------------ */
3300 const char *decNumberClassToString(enum decClass eclass) {
3301 if (eclass==DEC_CLASS_POS_NORMAL) return DEC_ClassString_PN;
3302 if (eclass==DEC_CLASS_NEG_NORMAL) return DEC_ClassString_NN;
3303 if (eclass==DEC_CLASS_POS_ZERO) return DEC_ClassString_PZ;
3304 if (eclass==DEC_CLASS_NEG_ZERO) return DEC_ClassString_NZ;
3305 if (eclass==DEC_CLASS_POS_SUBNORMAL) return DEC_ClassString_PS;
3306 if (eclass==DEC_CLASS_NEG_SUBNORMAL) return DEC_ClassString_NS;
3307 if (eclass==DEC_CLASS_POS_INF) return DEC_ClassString_PI;
3308 if (eclass==DEC_CLASS_NEG_INF) return DEC_ClassString_NI;
3309 if (eclass==DEC_CLASS_QNAN) return DEC_ClassString_QN;
3310 if (eclass==DEC_CLASS_SNAN) return DEC_ClassString_SN;
3311 return DEC_ClassString_UN; /* Unknown */
3312 } /* decNumberClassToString */
3313
3314 /* ------------------------------------------------------------------ */
3315 /* decNumberCopy -- copy a number */
3316 /* */
3317 /* dest is the target decNumber */
3318 /* src is the source decNumber */
3319 /* returns dest */
3320 /* */
3321 /* (dest==src is allowed and is a no-op) */
3322 /* All fields are updated as required. This is a utility operation, */
3323 /* so special values are unchanged and no error is possible. */
3324 /* ------------------------------------------------------------------ */
3325 decNumber * decNumberCopy(decNumber *dest, const decNumber *src) {
3326
3327 #if DECCHECK
3328 if (src==NULL) return decNumberZero(dest);
3329 #endif
3330
3331 if (dest==src) return dest; /* no copy required */
3332
3333 /* Use explicit assignments here as structure assignment could copy */
3334 /* more than just the lsu (for small DECDPUN). This would not affect */
3335 /* the value of the results, but could disturb test harness spill */
3336 /* checking. */
3337 dest->bits=src->bits;
3338 dest->exponent=src->exponent;
3339 dest->digits=src->digits;
3340 dest->lsu[0]=src->lsu[0];
3341 if (src->digits>DECDPUN) { /* more Units to come */
3342 const Unit *smsup, *s; /* work */
3343 Unit *d; /* .. */
3344 /* memcpy for the remaining Units would be safe as they cannot */
3345 /* overlap. However, this explicit loop is faster in short cases. */
3346 d=dest->lsu+1; /* -> first destination */
3347 smsup=src->lsu+D2U(src->digits); /* -> source msu+1 */
3348 for (s=src->lsu+1; s<smsup; s++, d++) *d=*s;
3349 }
3350 return dest;
3351 } /* decNumberCopy */
3352
3353 /* ------------------------------------------------------------------ */
3354 /* decNumberCopyAbs -- quiet absolute value operator */
3355 /* */
3356 /* This sets C = abs(A) */
3357 /* */
3358 /* res is C, the result. C may be A */
3359 /* rhs is A */
3360 /* */
3361 /* C must have space for set->digits digits. */
3362 /* No exception or error can occur; this is a quiet bitwise operation.*/
3363 /* See also decNumberAbs for a checking version of this. */
3364 /* ------------------------------------------------------------------ */
3365 decNumber * decNumberCopyAbs(decNumber *res, const decNumber *rhs) {
3366 #if DECCHECK
3367 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3368 #endif
3369 decNumberCopy(res, rhs);
3370 res->bits&=~DECNEG; /* turn off sign */
3371 return res;
3372 } /* decNumberCopyAbs */
3373
3374 /* ------------------------------------------------------------------ */
3375 /* decNumberCopyNegate -- quiet negate value operator */
3376 /* */
3377 /* This sets C = negate(A) */
3378 /* */
3379 /* res is C, the result. C may be A */
3380 /* rhs is A */
3381 /* */
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 decNumberMinus for a checking version of this. */
3385 /* ------------------------------------------------------------------ */
3386 decNumber * decNumberCopyNegate(decNumber *res, const decNumber *rhs) {
3387 #if DECCHECK
3388 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3389 #endif
3390 decNumberCopy(res, rhs);
3391 res->bits^=DECNEG; /* invert the sign */
3392 return res;
3393 } /* decNumberCopyNegate */
3394
3395 /* ------------------------------------------------------------------ */
3396 /* decNumberCopySign -- quiet copy and set sign operator */
3397 /* */
3398 /* This sets C = A with the sign of B */
3399 /* */
3400 /* res is C, the result. C may be A */
3401 /* lhs is A */
3402 /* rhs is B */
3403 /* */
3404 /* C must have space for set->digits digits. */
3405 /* No exception or error can occur; this is a quiet bitwise operation.*/
3406 /* ------------------------------------------------------------------ */
3407 decNumber * decNumberCopySign(decNumber *res, const decNumber *lhs,
3408 const decNumber *rhs) {
3409 uByte sign; /* rhs sign */
3410 #if DECCHECK
3411 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3412 #endif
3413 sign=rhs->bits & DECNEG; /* save sign bit */
3414 decNumberCopy(res, lhs);
3415 res->bits&=~DECNEG; /* clear the sign */
3416 res->bits|=sign; /* set from rhs */
3417 return res;
3418 } /* decNumberCopySign */
3419
3420 /* ------------------------------------------------------------------ */
3421 /* decNumberGetBCD -- get the coefficient in BCD8 */
3422 /* dn is the source decNumber */
3423 /* bcd is the uInt array that will receive dn->digits BCD bytes, */
3424 /* most-significant at offset 0 */
3425 /* returns bcd */
3426 /* */
3427 /* bcd must have at least dn->digits bytes. No error is possible; if */
3428 /* dn is a NaN or Infinite, digits must be 1 and the coefficient 0. */
3429 /* ------------------------------------------------------------------ */
3430 uByte * decNumberGetBCD(const decNumber *dn, uint8_t *bcd) {
3431 uByte *ub=bcd+dn->digits-1; /* -> lsd */
3432 const Unit *up=dn->lsu; /* Unit pointer, -> lsu */
3433
3434 #if DECDPUN==1 /* trivial simple copy */
3435 for (; ub>=bcd; ub--, up++) *ub=*up;
3436 #else /* chopping needed */
3437 uInt u=*up; /* work */
3438 uInt cut=DECDPUN; /* downcounter through unit */
3439 for (; ub>=bcd; ub--) {
3440 *ub=(uByte)(u%10); /* [*6554 trick inhibits, here] */
3441 u=u/10;
3442 cut--;
3443 if (cut>0) continue; /* more in this unit */
3444 up++;
3445 u=*up;
3446 cut=DECDPUN;
3447 }
3448 #endif
3449 return bcd;
3450 } /* decNumberGetBCD */
3451
3452 /* ------------------------------------------------------------------ */
3453 /* decNumberSetBCD -- set (replace) the coefficient from BCD8 */
3454 /* dn is the target decNumber */
3455 /* bcd is the uInt array that will source n BCD bytes, most- */
3456 /* significant at offset 0 */
3457 /* n is the number of digits in the source BCD array (bcd) */
3458 /* returns dn */
3459 /* */
3460 /* dn must have space for at least n digits. No error is possible; */
3461 /* if dn is a NaN, or Infinite, or is to become a zero, n must be 1 */
3462 /* and bcd[0] zero. */
3463 /* ------------------------------------------------------------------ */
3464 decNumber * decNumberSetBCD(decNumber *dn, const uByte *bcd, uInt n) {
3465 Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [target pointer] */
3466 const uByte *ub=bcd; /* -> source msd */
3467
3468 #if DECDPUN==1 /* trivial simple copy */
3469 for (; ub<bcd+n; ub++, up--) *up=*ub;
3470 #else /* some assembly needed */
3471 /* calculate how many digits in msu, and hence first cut */
3472 Int cut=MSUDIGITS(n); /* [faster than remainder] */
3473 for (;up>=dn->lsu; up--) { /* each Unit from msu */
3474 *up=0; /* will take <=DECDPUN digits */
3475 for (; cut>0; ub++, cut--) *up=X10(*up)+*ub;
3476 cut=DECDPUN; /* next Unit has all digits */
3477 }
3478 #endif
3479 dn->digits=n; /* set digit count */
3480 return dn;
3481 } /* decNumberSetBCD */
3482
3483 /* ------------------------------------------------------------------ */
3484 /* decNumberIsNormal -- test normality of a decNumber */
3485 /* dn is the decNumber to test */
3486 /* set is the context to use for Emin */
3487 /* returns 1 if |dn| is finite and >=Nmin, 0 otherwise */
3488 /* ------------------------------------------------------------------ */
3489 Int decNumberIsNormal(const decNumber *dn, decContext *set) {
3490 Int ae; /* adjusted exponent */
3491 #if DECCHECK
3492 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3493 #endif
3494
3495 if (decNumberIsSpecial(dn)) return 0; /* not finite */
3496 if (decNumberIsZero(dn)) return 0; /* not non-zero */
3497
3498 ae=dn->exponent+dn->digits-1; /* adjusted exponent */
3499 if (ae<set->emin) return 0; /* is subnormal */
3500 return 1;
3501 } /* decNumberIsNormal */
3502
3503 /* ------------------------------------------------------------------ */
3504 /* decNumberIsSubnormal -- test subnormality of a decNumber */
3505 /* dn is the decNumber to test */
3506 /* set is the context to use for Emin */
3507 /* returns 1 if |dn| is finite, non-zero, and <Nmin, 0 otherwise */
3508 /* ------------------------------------------------------------------ */
3509 Int decNumberIsSubnormal(const decNumber *dn, decContext *set) {
3510 Int ae; /* adjusted exponent */
3511 #if DECCHECK
3512 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3513 #endif
3514
3515 if (decNumberIsSpecial(dn)) return 0; /* not finite */
3516 if (decNumberIsZero(dn)) return 0; /* not non-zero */
3517
3518 ae=dn->exponent+dn->digits-1; /* adjusted exponent */
3519 if (ae<set->emin) return 1; /* is subnormal */
3520 return 0;
3521 } /* decNumberIsSubnormal */
3522
3523 /* ------------------------------------------------------------------ */
3524 /* decNumberTrim -- remove insignificant zeros */
3525 /* */
3526 /* dn is the number to trim */
3527 /* returns dn */
3528 /* */
3529 /* All fields are updated as required. This is a utility operation, */
3530 /* so special values are unchanged and no error is possible. */
3531 /* ------------------------------------------------------------------ */
3532 decNumber * decNumberTrim(decNumber *dn) {
3533 Int dropped; /* work */
3534 decContext set; /* .. */
3535 #if DECCHECK
3536 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, DECUNCONT)) return dn;
3537 #endif
3538 decContextDefault(&set, DEC_INIT_BASE); /* clamp=0 */
3539 return decTrim(dn, &set, 0, &dropped);
3540 } /* decNumberTrim */
3541
3542 /* ------------------------------------------------------------------ */
3543 /* decNumberVersion -- return the name and version of this module */
3544 /* */
3545 /* No error is possible. */
3546 /* ------------------------------------------------------------------ */
3547 const char * decNumberVersion(void) {
3548 return DECVERSION;
3549 } /* decNumberVersion */
3550
3551 /* ------------------------------------------------------------------ */
3552 /* decNumberZero -- set a number to 0 */
3553 /* */
3554 /* dn is the number to set, with space for one digit */
3555 /* returns dn */
3556 /* */
3557 /* No error is possible. */
3558 /* ------------------------------------------------------------------ */
3559 /* Memset is not used as it is much slower in some environments. */
3560 decNumber * decNumberZero(decNumber *dn) {
3561
3562 #if DECCHECK
3563 if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
3564 #endif
3565
3566 dn->bits=0;
3567 dn->exponent=0;
3568 dn->digits=1;
3569 dn->lsu[0]=0;
3570 return dn;
3571 } /* decNumberZero */
3572
3573 /* ================================================================== */
3574 /* Local routines */
3575 /* ================================================================== */
3576
3577 /* ------------------------------------------------------------------ */
3578 /* decToString -- lay out a number into a string */
3579 /* */
3580 /* dn is the number to lay out */
3581 /* string is where to lay out the number */
3582 /* eng is 1 if Engineering, 0 if Scientific */
3583 /* */
3584 /* string must be at least dn->digits+14 characters long */
3585 /* No error is possible. */
3586 /* */
3587 /* Note that this routine can generate a -0 or 0.000. These are */
3588 /* never generated in subset to-number or arithmetic, but can occur */
3589 /* in non-subset arithmetic (e.g., -1*0 or 1.234-1.234). */
3590 /* ------------------------------------------------------------------ */
3591 /* If DECCHECK is enabled the string "?" is returned if a number is */
3592 /* invalid. */
3593 static void decToString(const decNumber *dn, char *string, Flag eng) {
3594 Int exp=dn->exponent; /* local copy */
3595 Int e; /* E-part value */
3596 Int pre; /* digits before the '.' */
3597 Int cut; /* for counting digits in a Unit */
3598 char *c=string; /* work [output pointer] */
3599 const Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [input pointer] */
3600 uInt u, pow; /* work */
3601
3602 #if DECCHECK
3603 if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) {
3604 strcpy(string, "?");
3605 return;}
3606 #endif
3607
3608 if (decNumberIsNegative(dn)) { /* Negatives get a minus */
3609 *c='-';
3610 c++;
3611 }
3612 if (dn->bits&DECSPECIAL) { /* Is a special value */
3613 if (decNumberIsInfinite(dn)) {
3614 strcpy(c, "Inf");
3615 strcpy(c+3, "inity");
3616 return;}
3617 /* a NaN */
3618 if (dn->bits&DECSNAN) { /* signalling NaN */
3619 *c='s';
3620 c++;
3621 }
3622 strcpy(c, "NaN");
3623 c+=3; /* step past */
3624 /* if not a clean non-zero coefficient, that's all there is in a */
3625 /* NaN string */
3626 if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return;
3627 /* [drop through to add integer] */
3628 }
3629
3630 /* calculate how many digits in msu, and hence first cut */
3631 cut=MSUDIGITS(dn->digits); /* [faster than remainder] */
3632 cut--; /* power of ten for digit */
3633
3634 if (exp==0) { /* simple integer [common fastpath] */
3635 for (;up>=dn->lsu; up--) { /* each Unit from msu */
3636 u=*up; /* contains DECDPUN digits to lay out */
3637 for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow);
3638 cut=DECDPUN-1; /* next Unit has all digits */
3639 }
3640 *c='\0'; /* terminate the string */
3641 return;}
3642
3643 /* non-0 exponent -- assume plain form */
3644 pre=dn->digits+exp; /* digits before '.' */
3645 e=0; /* no E */
3646 if ((exp>0) || (pre<-5)) { /* need exponential form */
3647 e=exp+dn->digits-1; /* calculate E value */
3648 pre=1; /* assume one digit before '.' */
3649 if (eng && (e!=0)) { /* engineering: may need to adjust */
3650 Int adj; /* adjustment */
3651 /* The C remainder operator is undefined for negative numbers, so */
3652 /* a positive remainder calculation must be used here */
3653 if (e<0) {
3654 adj=(-e)%3;
3655 if (adj!=0) adj=3-adj;
3656 }
3657 else { /* e>0 */
3658 adj=e%3;
3659 }
3660 e=e-adj;
3661 /* if dealing with zero still produce an exponent which is a */
3662 /* multiple of three, as expected, but there will only be the */
3663 /* one zero before the E, still. Otherwise note the padding. */
3664 if (!ISZERO(dn)) pre+=adj;
3665 else { /* is zero */
3666 if (adj!=0) { /* 0.00Esnn needed */
3667 e=e+3;
3668 pre=-(2-adj);
3669 }
3670 } /* zero */
3671 } /* eng */
3672 } /* need exponent */
3673
3674 /* lay out the digits of the coefficient, adding 0s and . as needed */
3675 u=*up;
3676 if (pre>0) { /* xxx.xxx or xx00 (engineering) form */
3677 Int n=pre;
3678 for (; pre>0; pre--, c++, cut--) {
3679 if (cut<0) { /* need new Unit */
3680 if (up==dn->lsu) break; /* out of input digits (pre>digits) */
3681 up--;
3682 cut=DECDPUN-1;
3683 u=*up;
3684 }
3685 TODIGIT(u, cut, c, pow);
3686 }
3687 if (n<dn->digits) { /* more to come, after '.' */
3688 *c='.'; c++;
3689 for (;; c++, cut--) {
3690 if (cut<0) { /* need new Unit */
3691 if (up==dn->lsu) break; /* out of input digits */
3692 up--;
3693 cut=DECDPUN-1;
3694 u=*up;
3695 }
3696 TODIGIT(u, cut, c, pow);
3697 }
3698 }
3699 else for (; pre>0; pre--, c++) *c='0'; /* 0 padding (for engineering) needed */
3700 }
3701 else { /* 0.xxx or 0.000xxx form */
3702 *c='0'; c++;
3703 *c='.'; c++;
3704 for (; pre<0; pre++, c++) *c='0'; /* add any 0's after '.' */
3705 for (; ; c++, cut--) {
3706 if (cut<0) { /* need new Unit */
3707 if (up==dn->lsu) break; /* out of input digits */
3708 up--;
3709 cut=DECDPUN-1;
3710 u=*up;
3711 }
3712 TODIGIT(u, cut, c, pow);
3713 }
3714 }
3715
3716 /* Finally add the E-part, if needed. It will never be 0, has a
3717 base maximum and minimum of +999999999 through -999999999, but
3718 could range down to -1999999998 for anormal numbers */
3719 if (e!=0) {
3720 Flag had=0; /* 1=had non-zero */
3721 *c='E'; c++;
3722 *c='+'; c++; /* assume positive */
3723 u=e; /* .. */
3724 if (e<0) {
3725 *(c-1)='-'; /* oops, need - */
3726 u=-e; /* uInt, please */
3727 }
3728 /* lay out the exponent [_itoa or equivalent is not ANSI C] */
3729 for (cut=9; cut>=0; cut--) {
3730 TODIGIT(u, cut, c, pow);
3731 if (*c=='0' && !had) continue; /* skip leading zeros */
3732 had=1; /* had non-0 */
3733 c++; /* step for next */
3734 } /* cut */
3735 }
3736 *c='\0'; /* terminate the string (all paths) */
3737 return;
3738 } /* decToString */
3739
3740 /* ------------------------------------------------------------------ */
3741 /* decAddOp -- add/subtract operation */
3742 /* */
3743 /* This computes C = A + B */
3744 /* */
3745 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */
3746 /* lhs is A */
3747 /* rhs is B */
3748 /* set is the context */
3749 /* negate is DECNEG if rhs should be negated, or 0 otherwise */
3750 /* status accumulates status for the caller */
3751 /* */
3752 /* C must have space for set->digits digits. */
3753 /* Inexact in status must be 0 for correct Exact zero sign in result */
3754 /* ------------------------------------------------------------------ */
3755 /* If possible, the coefficient is calculated directly into C. */
3756 /* However, if: */
3757 /* -- a digits+1 calculation is needed because the numbers are */
3758 /* unaligned and span more than set->digits digits */
3759 /* -- a carry to digits+1 digits looks possible */
3760 /* -- C is the same as A or B, and the result would destructively */
3761 /* overlap the A or B coefficient */
3762 /* then the result must be calculated into a temporary buffer. In */
3763 /* this case a local (stack) buffer is used if possible, and only if */
3764 /* too long for that does malloc become the final resort. */
3765 /* */
3766 /* Misalignment is handled as follows: */
3767 /* Apad: (AExp>BExp) Swap operands and proceed as for BExp>AExp. */
3768 /* BPad: Apply the padding by a combination of shifting (whole */
3769 /* units) and multiplication (part units). */
3770 /* */
3771 /* Addition, especially x=x+1, is speed-critical. */
3772 /* The static buffer is larger than might be expected to allow for */
3773 /* calls from higher-level funtions (notable exp). */
3774 /* ------------------------------------------------------------------ */
3775 static decNumber * decAddOp(decNumber *res, const decNumber *lhs,
3776 const decNumber *rhs, decContext *set,
3777 uByte negate, uInt *status) {
3778 #if DECSUBSET
3779 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
3780 decNumber *allocrhs=NULL; /* .., rhs */
3781 #endif
3782 Int rhsshift; /* working shift (in Units) */
3783 Int maxdigits; /* longest logical length */
3784 Int mult; /* multiplier */
3785 Int residue; /* rounding accumulator */
3786 uByte bits; /* result bits */
3787 Flag diffsign; /* non-0 if arguments have different sign */
3788 Unit *acc; /* accumulator for result */
3789 Unit accbuff[SD2U(DECBUFFER*2+20)]; /* local buffer [*2+20 reduces many */
3790 /* allocations when called from */
3791 /* other operations, notable exp] */
3792 Unit *allocacc=NULL; /* -> allocated acc buffer, iff allocated */
3793 Int reqdigits=set->digits; /* local copy; requested DIGITS */
3794 Int padding; /* work */
3795
3796 #if DECCHECK
3797 if (decCheckOperands(res, lhs, rhs, set)) return res;
3798 #endif
3799
3800 do { /* protect allocated storage */
3801 #if DECSUBSET
3802 if (!set->extended) {
3803 /* reduce operands and set lostDigits status, as needed */
3804 if (lhs->digits>reqdigits) {
3805 alloclhs=decRoundOperand(lhs, set, status);
3806 if (alloclhs==NULL) break;
3807 lhs=alloclhs;
3808 }
3809 if (rhs->digits>reqdigits) {
3810 allocrhs=decRoundOperand(rhs, set, status);
3811 if (allocrhs==NULL) break;
3812 rhs=allocrhs;
3813 }
3814 }
3815 #endif
3816 /* [following code does not require input rounding] */
3817
3818 /* note whether signs differ [used all paths] */
3819 diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG);
3820
3821 /* handle infinities and NaNs */
3822 if (SPECIALARGS) { /* a special bit set */
3823 if (SPECIALARGS & (DECSNAN | DECNAN)) /* a NaN */
3824 decNaNs(res, lhs, rhs, set, status);
3825 else { /* one or two infinities */
3826 if (decNumberIsInfinite(lhs)) { /* LHS is infinity */
3827 /* two infinities with different signs is invalid */
3828 if (decNumberIsInfinite(rhs) && diffsign) {
3829 *status|=DEC_Invalid_operation;
3830 break;
3831 }
3832 bits=lhs->bits & DECNEG; /* get sign from LHS */
3833 }
3834 else bits=(rhs->bits^negate) & DECNEG;/* RHS must be Infinity */
3835 bits|=DECINF;
3836 decNumberZero(res);
3837 res->bits=bits; /* set +/- infinity */
3838 } /* an infinity */
3839 break;
3840 }
3841
3842 /* Quick exit for add 0s; return the non-0, modified as need be */
3843 if (ISZERO(lhs)) {
3844 Int adjust; /* work */
3845 Int lexp=lhs->exponent; /* save in case LHS==RES */
3846 bits=lhs->bits; /* .. */
3847 residue=0; /* clear accumulator */
3848 decCopyFit(res, rhs, set, &residue, status); /* copy (as needed) */
3849 res->bits^=negate; /* flip if rhs was negated */
3850 #if DECSUBSET
3851 if (set->extended) { /* exponents on zeros count */
3852 #endif
3853 /* exponent will be the lower of the two */
3854 adjust=lexp-res->exponent; /* adjustment needed [if -ve] */
3855 if (ISZERO(res)) { /* both 0: special IEEE 854 rules */
3856 if (adjust<0) res->exponent=lexp; /* set exponent */
3857 /* 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0 */
3858 if (diffsign) {
3859 if (set->round!=DEC_ROUND_FLOOR) res->bits=0;
3860 else res->bits=DECNEG; /* preserve 0 sign */
3861 }
3862 }
3863 else { /* non-0 res */
3864 if (adjust<0) { /* 0-padding needed */
3865 if ((res->digits-adjust)>set->digits) {
3866 adjust=res->digits-set->digits; /* to fit exactly */
3867 *status|=DEC_Rounded; /* [but exact] */
3868 }
3869 res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
3870 res->exponent+=adjust; /* set the exponent. */
3871 }
3872 } /* non-0 res */
3873 #if DECSUBSET
3874 } /* extended */
3875 #endif
3876 decFinish(res, set, &residue, status); /* clean and finalize */
3877 break;}
3878
3879 if (ISZERO(rhs)) { /* [lhs is non-zero] */
3880 Int adjust; /* work */
3881 Int rexp=rhs->exponent; /* save in case RHS==RES */
3882 bits=rhs->bits; /* be clean */
3883 residue=0; /* clear accumulator */
3884 decCopyFit(res, lhs, set, &residue, status); /* copy (as needed) */
3885 #if DECSUBSET
3886 if (set->extended) { /* exponents on zeros count */
3887 #endif
3888 /* exponent will be the lower of the two */
3889 /* [0-0 case handled above] */
3890 adjust=rexp-res->exponent; /* adjustment needed [if -ve] */
3891 if (adjust<0) { /* 0-padding needed */
3892 if ((res->digits-adjust)>set->digits) {
3893 adjust=res->digits-set->digits; /* to fit exactly */
3894 *status|=DEC_Rounded; /* [but exact] */
3895 }
3896 res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
3897 res->exponent+=adjust; /* set the exponent. */
3898 }
3899 #if DECSUBSET
3900 } /* extended */
3901 #endif
3902 decFinish(res, set, &residue, status); /* clean and finalize */
3903 break;}
3904
3905 /* [NB: both fastpath and mainpath code below assume these cases */
3906 /* (notably 0-0) have already been handled] */
3907
3908 /* calculate the padding needed to align the operands */
3909 padding=rhs->exponent-lhs->exponent;
3910
3911 /* Fastpath cases where the numbers are aligned and normal, the RHS */
3912 /* is all in one unit, no operand rounding is needed, and no carry, */
3913 /* lengthening, or borrow is needed */
3914 if (padding==0
3915 && rhs->digits<=DECDPUN
3916 && rhs->exponent>=set->emin /* [some normals drop through] */
3917 && rhs->exponent<=set->emax-set->digits+1 /* [could clamp] */
3918 && rhs->digits<=reqdigits
3919 && lhs->digits<=reqdigits) {
3920 Int partial=*lhs->lsu;
3921 if (!diffsign) { /* adding */
3922 partial+=*rhs->lsu;
3923 if ((partial<=DECDPUNMAX) /* result fits in unit */
3924 && (lhs->digits>=DECDPUN || /* .. and no digits-count change */
3925 partial<(Int)powers[lhs->digits])) { /* .. */
3926 if (res!=lhs) decNumberCopy(res, lhs); /* not in place */
3927 *res->lsu=(Unit)partial; /* [copy could have overwritten RHS] */
3928 break;
3929 }
3930 /* else drop out for careful add */
3931 }
3932 else { /* signs differ */
3933 partial-=*rhs->lsu;
3934 if (partial>0) { /* no borrow needed, and non-0 result */
3935 if (res!=lhs) decNumberCopy(res, lhs); /* not in place */
3936 *res->lsu=(Unit)partial;
3937 /* this could have reduced digits [but result>0] */
3938 res->digits=decGetDigits(res->lsu, D2U(res->digits));
3939 break;
3940 }
3941 /* else drop out for careful subtract */
3942 }
3943 }
3944
3945 /* Now align (pad) the lhs or rhs so they can be added or */
3946 /* subtracted, as necessary. If one number is much larger than */
3947 /* the other (that is, if in plain form there is a least one */
3948 /* digit between the lowest digit of one and the highest of the */
3949 /* other) padding with up to DIGITS-1 trailing zeros may be */
3950 /* needed; then apply rounding (as exotic rounding modes may be */
3951 /* affected by the residue). */
3952 rhsshift=0; /* rhs shift to left (padding) in Units */
3953 bits=lhs->bits; /* assume sign is that of LHS */
3954 mult=1; /* likely multiplier */
3955
3956 /* [if padding==0 the operands are aligned; no padding is needed] */
3957 if (padding!=0) {
3958 /* some padding needed; always pad the RHS, as any required */
3959 /* padding can then be effected by a simple combination of */
3960 /* shifts and a multiply */
3961 Flag swapped=0;
3962 if (padding<0) { /* LHS needs the padding */
3963 const decNumber *t;
3964 padding=-padding; /* will be +ve */
3965 bits=(uByte)(rhs->bits^negate); /* assumed sign is now that of RHS */
3966 t=lhs; lhs=rhs; rhs=t;
3967 swapped=1;
3968 }
3969
3970 /* If, after pad, rhs would be longer than lhs by digits+1 or */
3971 /* more then lhs cannot affect the answer, except as a residue, */
3972 /* so only need to pad up to a length of DIGITS+1. */
3973 if (rhs->digits+padding > lhs->digits+reqdigits+1) {
3974 /* The RHS is sufficient */
3975 /* for residue use the relative sign indication... */
3976 Int shift=reqdigits-rhs->digits; /* left shift needed */
3977 residue=1; /* residue for rounding */
3978 if (diffsign) residue=-residue; /* signs differ */
3979 /* copy, shortening if necessary */
3980 decCopyFit(res, rhs, set, &residue, status);
3981 /* if it was already shorter, then need to pad with zeros */
3982 if (shift>0) {
3983 res->digits=decShiftToMost(res->lsu, res->digits, shift);
3984 res->exponent-=shift; /* adjust the exponent. */
3985 }
3986 /* flip the result sign if unswapped and rhs was negated */
3987 if (!swapped) res->bits^=negate;
3988 decFinish(res, set, &residue, status); /* done */
3989 break;}
3990
3991 /* LHS digits may affect result */
3992 rhsshift=D2U(padding+1)-1; /* this much by Unit shift .. */
3993 mult=powers[padding-(rhsshift*DECDPUN)]; /* .. this by multiplication */
3994 } /* padding needed */
3995
3996 if (diffsign) mult=-mult; /* signs differ */
3997
3998 /* determine the longer operand */
3999 maxdigits=rhs->digits+padding; /* virtual length of RHS */
4000 if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4001
4002 /* Decide on the result buffer to use; if possible place directly */
4003 /* into result. */
4004 acc=res->lsu; /* assume add direct to result */
4005 /* If destructive overlap, or the number is too long, or a carry or */
4006 /* borrow to DIGITS+1 might be possible, a buffer must be used. */
4007 /* [Might be worth more sophisticated tests when maxdigits==reqdigits] */
4008 if ((maxdigits>=reqdigits) /* is, or could be, too large */
4009 || (res==rhs && rhsshift>0)) { /* destructive overlap */
4010 /* buffer needed, choose it; units for maxdigits digits will be */
4011 /* needed, +1 Unit for carry or borrow */
4012 Int need=D2U(maxdigits)+1;
4013 acc=accbuff; /* assume use local buffer */
4014 if (need*sizeof(Unit)>sizeof(accbuff)) {
4015 /* printf("malloc add %ld %ld\n", need, sizeof(accbuff)); */
4016 allocacc=(Unit *)malloc(need*sizeof(Unit));
4017 if (allocacc==NULL) { /* hopeless -- abandon */
4018 *status|=DEC_Insufficient_storage;
4019 break;}
4020 acc=allocacc;
4021 }
4022 }
4023
4024 res->bits=(uByte)(bits&DECNEG); /* it's now safe to overwrite.. */
4025 res->exponent=lhs->exponent; /* .. operands (even if aliased) */
4026
4027 #if DECTRACE
4028 decDumpAr('A', lhs->lsu, D2U(lhs->digits));
4029 decDumpAr('B', rhs->lsu, D2U(rhs->digits));
4030 printf(" :h: %ld %ld\n", rhsshift, mult);
4031 #endif
4032
4033 /* add [A+B*m] or subtract [A+B*(-m)] */
4034 res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits),
4035 rhs->lsu, D2U(rhs->digits),
4036 rhsshift, acc, mult)
4037 *DECDPUN; /* [units -> digits] */
4038 if (res->digits<0) { /* borrowed... */
4039 res->digits=-res->digits;
4040 res->bits^=DECNEG; /* flip the sign */
4041 }
4042 #if DECTRACE
4043 decDumpAr('+', acc, D2U(res->digits));
4044 #endif
4045
4046 /* If a buffer was used the result must be copied back, possibly */
4047 /* shortening. (If no buffer was used then the result must have */
4048 /* fit, so can't need rounding and residue must be 0.) */
4049 residue=0; /* clear accumulator */
4050 if (acc!=res->lsu) {
4051 #if DECSUBSET
4052 if (set->extended) { /* round from first significant digit */
4053 #endif
4054 /* remove leading zeros that were added due to rounding up to */
4055 /* integral Units -- before the test for rounding. */
4056 if (res->digits>reqdigits)
4057 res->digits=decGetDigits(acc, D2U(res->digits));
4058 decSetCoeff(res, set, acc, res->digits, &residue, status);
4059 #if DECSUBSET
4060 }
4061 else { /* subset arithmetic rounds from original significant digit */
4062 /* May have an underestimate. This only occurs when both */
4063 /* numbers fit in DECDPUN digits and are padding with a */
4064 /* negative multiple (-10, -100...) and the top digit(s) become */
4065 /* 0. (This only matters when using X3.274 rules where the */
4066 /* leading zero could be included in the rounding.) */
4067 if (res->digits<maxdigits) {
4068 *(acc+D2U(res->digits))=0; /* ensure leading 0 is there */
4069 res->digits=maxdigits;
4070 }
4071 else {
4072 /* remove leading zeros that added due to rounding up to */
4073 /* integral Units (but only those in excess of the original */
4074 /* maxdigits length, unless extended) before test for rounding. */
4075 if (res->digits>reqdigits) {
4076 res->digits=decGetDigits(acc, D2U(res->digits));
4077 if (res->digits<maxdigits) res->digits=maxdigits;
4078 }
4079 }
4080 decSetCoeff(res, set, acc, res->digits, &residue, status);
4081 /* Now apply rounding if needed before removing leading zeros. */
4082 /* This is safe because subnormals are not a possibility */
4083 if (residue!=0) {
4084 decApplyRound(res, set, residue, status);
4085 residue=0; /* did what needed to be done */
4086 }
4087 } /* subset */
4088 #endif
4089 } /* used buffer */
4090
4091 /* strip leading zeros [these were left on in case of subset subtract] */
4092 res->digits=decGetDigits(res->lsu, D2U(res->digits));
4093
4094 /* apply checks and rounding */
4095 decFinish(res, set, &residue, status);
4096
4097 /* "When the sum of two operands with opposite signs is exactly */
4098 /* zero, the sign of that sum shall be '+' in all rounding modes */
4099 /* except round toward -Infinity, in which mode that sign shall be */
4100 /* '-'." [Subset zeros also never have '-', set by decFinish.] */
4101 if (ISZERO(res) && diffsign
4102 #if DECSUBSET
4103 && set->extended
4104 #endif
4105 && (*status&DEC_Inexact)==0) {
4106 if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG; /* sign - */
4107 else res->bits&=~DECNEG; /* sign + */
4108 }
4109 } while(0); /* end protected */
4110
4111 if (allocacc!=NULL) free(allocacc); /* drop any storage used */
4112 #if DECSUBSET
4113 if (allocrhs!=NULL) free(allocrhs); /* .. */
4114 if (alloclhs!=NULL) free(alloclhs); /* .. */
4115 #endif
4116 return res;
4117 } /* decAddOp */
4118
4119 /* ------------------------------------------------------------------ */
4120 /* decDivideOp -- division operation */
4121 /* */
4122 /* This routine performs the calculations for all four division */
4123 /* operators (divide, divideInteger, remainder, remainderNear). */
4124 /* */
4125 /* C=A op B */
4126 /* */
4127 /* res is C, the result. C may be A and/or B (e.g., X=X/X) */
4128 /* lhs is A */
4129 /* rhs is B */
4130 /* set is the context */
4131 /* op is DIVIDE, DIVIDEINT, REMAINDER, or REMNEAR respectively. */
4132 /* status is the usual accumulator */
4133 /* */
4134 /* C must have space for set->digits digits. */
4135 /* */
4136 /* ------------------------------------------------------------------ */
4137 /* The underlying algorithm of this routine is the same as in the */
4138 /* 1981 S/370 implementation, that is, non-restoring long division */
4139 /* with bi-unit (rather than bi-digit) estimation for each unit */
4140 /* multiplier. In this pseudocode overview, complications for the */
4141 /* Remainder operators and division residues for exact rounding are */
4142 /* omitted for clarity. */
4143 /* */
4144 /* Prepare operands and handle special values */
4145 /* Test for x/0 and then 0/x */
4146 /* Exp =Exp1 - Exp2 */
4147 /* Exp =Exp +len(var1) -len(var2) */
4148 /* Sign=Sign1 * Sign2 */
4149 /* Pad accumulator (Var1) to double-length with 0's (pad1) */
4150 /* Pad Var2 to same length as Var1 */
4151 /* msu2pair/plus=1st 2 or 1 units of var2, +1 to allow for round */
4152 /* have=0 */
4153 /* Do until (have=digits+1 OR residue=0) */
4154 /* if exp<0 then if integer divide/residue then leave */
4155 /* this_unit=0 */
4156 /* Do forever */
4157 /* compare numbers */
4158 /* if <0 then leave inner_loop */
4159 /* if =0 then (* quick exit without subtract *) do */
4160 /* this_unit=this_unit+1; output this_unit */
4161 /* leave outer_loop; end */
4162 /* Compare lengths of numbers (mantissae): */
4163 /* If same then tops2=msu2pair -- {units 1&2 of var2} */
4164 /* else tops2=msu2plus -- {0, unit 1 of var2} */
4165 /* tops1=first_unit_of_Var1*10**DECDPUN +second_unit_of_var1 */
4166 /* mult=tops1/tops2 -- Good and safe guess at divisor */
4167 /* if mult=0 then mult=1 */
4168 /* this_unit=this_unit+mult */
4169 /* subtract */
4170 /* end inner_loop */
4171 /* if have\=0 | this_unit\=0 then do */
4172 /* output this_unit */
4173 /* have=have+1; end */
4174 /* var2=var2/10 */
4175 /* exp=exp-1 */
4176 /* end outer_loop */
4177 /* exp=exp+1 -- set the proper exponent */
4178 /* if have=0 then generate answer=0 */
4179 /* Return (Result is defined by Var1) */
4180 /* */
4181 /* ------------------------------------------------------------------ */
4182 /* Two working buffers are needed during the division; one (digits+ */
4183 /* 1) to accumulate the result, and the other (up to 2*digits+1) for */
4184 /* long subtractions. These are acc and var1 respectively. */
4185 /* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/
4186 /* The static buffers may be larger than might be expected to allow */
4187 /* for calls from higher-level funtions (notable exp). */
4188 /* ------------------------------------------------------------------ */
4189 static decNumber * decDivideOp(decNumber *res,
4190 const decNumber *lhs, const decNumber *rhs,
4191 decContext *set, Flag op, uInt *status) {
4192 #if DECSUBSET
4193 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
4194 decNumber *allocrhs=NULL; /* .., rhs */
4195 #endif
4196 Unit accbuff[SD2U(DECBUFFER+DECDPUN+10)]; /* local buffer */
4197 Unit *acc=accbuff; /* -> accumulator array for result */
4198 Unit *allocacc=NULL; /* -> allocated buffer, iff allocated */
4199 Unit *accnext; /* -> where next digit will go */
4200 Int acclength; /* length of acc needed [Units] */
4201 Int accunits; /* count of units accumulated */
4202 Int accdigits; /* count of digits accumulated */
4203
4204 Unit varbuff[SD2U(DECBUFFER*2+DECDPUN)*sizeof(Unit)]; /* buffer for var1 */
4205 Unit *var1=varbuff; /* -> var1 array for long subtraction */
4206 Unit *varalloc=NULL; /* -> allocated buffer, iff used */
4207 Unit *msu1; /* -> msu of var1 */
4208
4209 const Unit *var2; /* -> var2 array */
4210 const Unit *msu2; /* -> msu of var2 */
4211 Int msu2plus; /* msu2 plus one [does not vary] */
4212 eInt msu2pair; /* msu2 pair plus one [does not vary] */
4213
4214 Int var1units, var2units; /* actual lengths */
4215 Int var2ulen; /* logical length (units) */
4216 Int var1initpad=0; /* var1 initial padding (digits) */
4217 Int maxdigits; /* longest LHS or required acc length */
4218 Int mult; /* multiplier for subtraction */
4219 Unit thisunit; /* current unit being accumulated */
4220 Int residue; /* for rounding */
4221 Int reqdigits=set->digits; /* requested DIGITS */
4222 Int exponent; /* working exponent */
4223 Int maxexponent=0; /* DIVIDE maximum exponent if unrounded */
4224 uByte bits; /* working sign */
4225 Unit *target; /* work */
4226 const Unit *source; /* .. */
4227 uInt const *pow; /* .. */
4228 Int shift, cut; /* .. */
4229 #if DECSUBSET
4230 Int dropped; /* work */
4231 #endif
4232
4233 #if DECCHECK
4234 if (decCheckOperands(res, lhs, rhs, set)) return res;
4235 #endif
4236
4237 do { /* protect allocated storage */
4238 #if DECSUBSET
4239 if (!set->extended) {
4240 /* reduce operands and set lostDigits status, as needed */
4241 if (lhs->digits>reqdigits) {
4242 alloclhs=decRoundOperand(lhs, set, status);
4243 if (alloclhs==NULL) break;
4244 lhs=alloclhs;
4245 }
4246 if (rhs->digits>reqdigits) {
4247 allocrhs=decRoundOperand(rhs, set, status);
4248 if (allocrhs==NULL) break;
4249 rhs=allocrhs;
4250 }
4251 }
4252 #endif
4253 /* [following code does not require input rounding] */
4254
4255 bits=(lhs->bits^rhs->bits)&DECNEG; /* assumed sign for divisions */
4256
4257 /* handle infinities and NaNs */
4258 if (SPECIALARGS) { /* a special bit set */
4259 if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
4260 decNaNs(res, lhs, rhs, set, status);
4261 break;
4262 }
4263 /* one or two infinities */
4264 if (decNumberIsInfinite(lhs)) { /* LHS (dividend) is infinite */
4265 if (decNumberIsInfinite(rhs) || /* two infinities are invalid .. */
4266 op & (REMAINDER | REMNEAR)) { /* as is remainder of infinity */
4267 *status|=DEC_Invalid_operation;
4268 break;
4269 }
4270 /* [Note that infinity/0 raises no exceptions] */
4271 decNumberZero(res);
4272 res->bits=bits|DECINF; /* set +/- infinity */
4273 break;
4274 }
4275 else { /* RHS (divisor) is infinite */
4276 residue=0;
4277 if (op&(REMAINDER|REMNEAR)) {
4278 /* result is [finished clone of] lhs */
4279 decCopyFit(res, lhs, set, &residue, status);
4280 }
4281 else { /* a division */
4282 decNumberZero(res);
4283 res->bits=bits; /* set +/- zero */
4284 /* for DIVIDEINT the exponent is always 0. For DIVIDE, result */
4285 /* is a 0 with infinitely negative exponent, clamped to minimum */
4286 if (op&DIVIDE) {
4287 res->exponent=set->emin-set->digits+1;
4288 *status|=DEC_Clamped;
4289 }
4290 }
4291 decFinish(res, set, &residue, status);
4292 break;
4293 }
4294 }
4295
4296 /* handle 0 rhs (x/0) */
4297 if (ISZERO(rhs)) { /* x/0 is always exceptional */
4298 if (ISZERO(lhs)) {
4299 decNumberZero(res); /* [after lhs test] */
4300 *status|=DEC_Division_undefined;/* 0/0 will become NaN */
4301 }
4302 else {
4303 decNumberZero(res);
4304 if (op&(REMAINDER|REMNEAR)) *status|=DEC_Invalid_operation;
4305 else {
4306 *status|=DEC_Division_by_zero; /* x/0 */
4307 res->bits=bits|DECINF; /* .. is +/- Infinity */
4308 }
4309 }
4310 break;}
4311
4312 /* handle 0 lhs (0/x) */
4313 if (ISZERO(lhs)) { /* 0/x [x!=0] */
4314 #if DECSUBSET
4315 if (!set->extended) decNumberZero(res);
4316 else {
4317 #endif
4318 if (op&DIVIDE) {
4319 residue=0;
4320 exponent=lhs->exponent-rhs->exponent; /* ideal exponent */
4321 decNumberCopy(res, lhs); /* [zeros always fit] */
4322 res->bits=bits; /* sign as computed */
4323 res->exponent=exponent; /* exponent, too */
4324 decFinalize(res, set, &residue, status); /* check exponent */
4325 }
4326 else if (op&DIVIDEINT) {
4327 decNumberZero(res); /* integer 0 */
4328 res->bits=bits; /* sign as computed */
4329 }
4330 else { /* a remainder */
4331 exponent=rhs->exponent; /* [save in case overwrite] */
4332 decNumberCopy(res, lhs); /* [zeros always fit] */
4333 if (exponent<res->exponent) res->exponent=exponent; /* use lower */
4334 }
4335 #if DECSUBSET
4336 }
4337 #endif
4338 break;}
4339
4340 /* Precalculate exponent. This starts off adjusted (and hence fits */
4341 /* in 31 bits) and becomes the usual unadjusted exponent as the */
4342 /* division proceeds. The order of evaluation is important, here, */
4343 /* to avoid wrap. */
4344 exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits);
4345
4346 /* If the working exponent is -ve, then some quick exits are */
4347 /* possible because the quotient is known to be <1 */
4348 /* [for REMNEAR, it needs to be < -1, as -0.5 could need work] */
4349 if (exponent<0 && !(op==DIVIDE)) {
4350 if (op&DIVIDEINT) {
4351 decNumberZero(res); /* integer part is 0 */
4352 #if DECSUBSET
4353 if (set->extended)
4354 #endif
4355 res->bits=bits; /* set +/- zero */
4356 break;}
4357 /* fastpath remainders so long as the lhs has the smaller */
4358 /* (or equal) exponent */
4359 if (lhs->exponent<=rhs->exponent) {
4360 if (op&REMAINDER || exponent<-1) {
4361 /* It is REMAINDER or safe REMNEAR; result is [finished */
4362 /* clone of] lhs (r = x - 0*y) */
4363 residue=0;
4364 decCopyFit(res, lhs, set, &residue, status);
4365 decFinish(res, set, &residue, status);
4366 break;
4367 }
4368 /* [unsafe REMNEAR drops through] */
4369 }
4370 } /* fastpaths */
4371
4372 /* Long (slow) division is needed; roll up the sleeves... */
4373
4374 /* The accumulator will hold the quotient of the division. */
4375 /* If it needs to be too long for stack storage, then allocate. */
4376 acclength=D2U(reqdigits+DECDPUN); /* in Units */
4377 if (acclength*sizeof(Unit)>sizeof(accbuff)) {
4378 /* printf("malloc dvacc %ld units\n", acclength); */
4379 allocacc=(Unit *)malloc(acclength*sizeof(Unit));
4380 if (allocacc==NULL) { /* hopeless -- abandon */
4381 *status|=DEC_Insufficient_storage;
4382 break;}
4383 acc=allocacc; /* use the allocated space */
4384 }
4385
4386 /* var1 is the padded LHS ready for subtractions. */
4387 /* If it needs to be too long for stack storage, then allocate. */
4388 /* The maximum units needed for var1 (long subtraction) is: */
4389 /* Enough for */
4390 /* (rhs->digits+reqdigits-1) -- to allow full slide to right */
4391 /* or (lhs->digits) -- to allow for long lhs */
4392 /* whichever is larger */
4393 /* +1 -- for rounding of slide to right */
4394 /* +1 -- for leading 0s */
4395 /* +1 -- for pre-adjust if a remainder or DIVIDEINT */
4396 /* [Note: unused units do not participate in decUnitAddSub data] */
4397 maxdigits=rhs->digits+reqdigits-1;
4398 if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4399 var1units=D2U(maxdigits)+2;
4400 /* allocate a guard unit above msu1 for REMAINDERNEAR */
4401 if (!(op&DIVIDE)) var1units++;
4402 if ((var1units+1)*sizeof(Unit)>sizeof(varbuff)) {
4403 /* printf("malloc dvvar %ld units\n", var1units+1); */
4404 varalloc=(Unit *)malloc((var1units+1)*sizeof(Unit));
4405 if (varalloc==NULL) { /* hopeless -- abandon */
4406 *status|=DEC_Insufficient_storage;
4407 break;}
4408 var1=varalloc; /* use the allocated space */
4409 }
4410
4411 /* Extend the lhs and rhs to full long subtraction length. The lhs */
4412 /* is truly extended into the var1 buffer, with 0 padding, so a */
4413 /* subtract in place is always possible. The rhs (var2) has */
4414 /* virtual padding (implemented by decUnitAddSub). */
4415 /* One guard unit was allocated above msu1 for rem=rem+rem in */
4416 /* REMAINDERNEAR. */
4417 msu1=var1+var1units-1; /* msu of var1 */
4418 source=lhs->lsu+D2U(lhs->digits)-1; /* msu of input array */
4419 for (target=msu1; source>=lhs->lsu; source--, target--) *target=*source;
4420 for (; target>=var1; target--) *target=0;
4421
4422 /* rhs (var2) is left-aligned with var1 at the start */
4423 var2ulen=var1units; /* rhs logical length (units) */
4424 var2units=D2U(rhs->digits); /* rhs actual length (units) */
4425 var2=rhs->lsu; /* -> rhs array */
4426 msu2=var2+var2units-1; /* -> msu of var2 [never changes] */
4427 /* now set up the variables which will be used for estimating the */
4428 /* multiplication factor. If these variables are not exact, add */
4429 /* 1 to make sure that the multiplier is never overestimated. */
4430 msu2plus=*msu2; /* it's value .. */
4431 if (var2units>1) msu2plus++; /* .. +1 if any more */
4432 msu2pair=(eInt)*msu2*(DECDPUNMAX+1);/* top two pair .. */
4433 if (var2units>1) { /* .. [else treat 2nd as 0] */
4434 msu2pair+=*(msu2-1); /* .. */
4435 if (var2units>2) msu2pair++; /* .. +1 if any more */
4436 }
4437
4438 /* The calculation is working in units, which may have leading zeros, */
4439 /* but the exponent was calculated on the assumption that they are */
4440 /* both left-aligned. Adjust the exponent to compensate: add the */
4441 /* number of leading zeros in var1 msu and subtract those in var2 msu. */
4442 /* [This is actually done by counting the digits and negating, as */
4443 /* lead1=DECDPUN-digits1, and similarly for lead2.] */
4444 for (pow=&powers[1]; *msu1>=*pow; pow++) exponent--;
4445 for (pow=&powers[1]; *msu2>=*pow; pow++) exponent++;
4446
4447 /* Now, if doing an integer divide or remainder, ensure that */
4448 /* the result will be Unit-aligned. To do this, shift the var1 */
4449 /* accumulator towards least if need be. (It's much easier to */
4450 /* do this now than to reassemble the residue afterwards, if */
4451 /* doing a remainder.) Also ensure the exponent is not negative. */
4452 if (!(op&DIVIDE)) {
4453 Unit *u; /* work */
4454 /* save the initial 'false' padding of var1, in digits */
4455 var1initpad=(var1units-D2U(lhs->digits))*DECDPUN;
4456 /* Determine the shift to do. */
4457 if (exponent<0) cut=-exponent;
4458 else cut=DECDPUN-exponent%DECDPUN;
4459 decShiftToLeast(var1, var1units, cut);
4460 exponent+=cut; /* maintain numerical value */
4461 var1initpad-=cut; /* .. and reduce padding */
4462 /* clean any most-significant units which were just emptied */
4463 for (u=msu1; cut>=DECDPUN; cut-=DECDPUN, u--) *u=0;
4464 } /* align */
4465 else { /* is DIVIDE */
4466 maxexponent=lhs->exponent-rhs->exponent; /* save */
4467 /* optimization: if the first iteration will just produce 0, */
4468 /* preadjust to skip it [valid for DIVIDE only] */
4469 if (*msu1<*msu2) {
4470 var2ulen--; /* shift down */
4471 exponent-=DECDPUN; /* update the exponent */
4472 }
4473 }
4474
4475 /* ---- start the long-division loops ------------------------------ */
4476 accunits=0; /* no units accumulated yet */
4477 accdigits=0; /* .. or digits */
4478 accnext=acc+acclength-1; /* -> msu of acc [NB: allows digits+1] */
4479 for (;;) { /* outer forever loop */
4480 thisunit=0; /* current unit assumed 0 */
4481 /* find the next unit */
4482 for (;;) { /* inner forever loop */
4483 /* strip leading zero units [from either pre-adjust or from */
4484 /* subtract last time around]. Leave at least one unit. */
4485 for (; *msu1==0 && msu1>var1; msu1--) var1units--;
4486
4487 if (var1units<var2ulen) break; /* var1 too low for subtract */
4488 if (var1units==var2ulen) { /* unit-by-unit compare needed */
4489 /* compare the two numbers, from msu */
4490 const Unit *pv1, *pv2;
4491 Unit v2; /* units to compare */
4492 pv2=msu2; /* -> msu */
4493 for (pv1=msu1; ; pv1--, pv2--) {
4494 /* v1=*pv1 -- always OK */
4495 v2=0; /* assume in padding */
4496 if (pv2>=var2) v2=*pv2; /* in range */
4497 if (*pv1!=v2) break; /* no longer the same */
4498 if (pv1==var1) break; /* done; leave pv1 as is */
4499 }
4500 /* here when all inspected or a difference seen */
4501 if (*pv1<v2) break; /* var1 too low to subtract */
4502 if (*pv1==v2) { /* var1 == var2 */
4503 /* reach here if var1 and var2 are identical; subtraction */
4504 /* would increase digit by one, and the residue will be 0 so */
4505 /* the calculation is done; leave the loop with residue=0. */
4506 thisunit++; /* as though subtracted */
4507 *var1=0; /* set var1 to 0 */
4508 var1units=1; /* .. */
4509 break; /* from inner */
4510 } /* var1 == var2 */
4511 /* *pv1>v2. Prepare for real subtraction; the lengths are equal */
4512 /* Estimate the multiplier (there's always a msu1-1)... */
4513 /* Bring in two units of var2 to provide a good estimate. */
4514 mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2pair);
4515 } /* lengths the same */
4516 else { /* var1units > var2ulen, so subtraction is safe */
4517 /* The var2 msu is one unit towards the lsu of the var1 msu, */
4518 /* so only one unit for var2 can be used. */
4519 mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2plus);
4520 }
4521 if (mult==0) mult=1; /* must always be at least 1 */
4522 /* subtraction needed; var1 is > var2 */
4523 thisunit=(Unit)(thisunit+mult); /* accumulate */
4524 /* subtract var1-var2, into var1; only the overlap needs */
4525 /* processing, as this is an in-place calculation */
4526 shift=var2ulen-var2units;
4527 #if DECTRACE
4528 decDumpAr('1', &var1[shift], var1units-shift);
4529 decDumpAr('2', var2, var2units);
4530 printf("m=%ld\n", -mult);
4531 #endif
4532 decUnitAddSub(&var1[shift], var1units-shift,
4533 var2, var2units, 0,
4534 &var1[shift], -mult);
4535 #if DECTRACE
4536 decDumpAr('#', &var1[shift], var1units-shift);
4537 #endif
4538 /* var1 now probably has leading zeros; these are removed at the */
4539 /* top of the inner loop. */
4540 } /* inner loop */
4541
4542 /* The next unit has been calculated in full; unless it's a */
4543 /* leading zero, add to acc */
4544 if (accunits!=0 || thisunit!=0) { /* is first or non-zero */
4545 *accnext=thisunit; /* store in accumulator */
4546 /* account exactly for the new digits */
4547 if (accunits==0) {
4548 accdigits++; /* at least one */
4549 for (pow=&powers[1]; thisunit>=*pow; pow++) accdigits++;
4550 }
4551 else accdigits+=DECDPUN;
4552 accunits++; /* update count */
4553 accnext--; /* ready for next */
4554 if (accdigits>reqdigits) break; /* have enough digits */
4555 }
4556
4557 /* if the residue is zero, the operation is done (unless divide */
4558 /* or divideInteger and still not enough digits yet) */
4559 if (*var1==0 && var1units==1) { /* residue is 0 */
4560 if (op&(REMAINDER|REMNEAR)) break;
4561 if ((op&DIVIDE) && (exponent<=maxexponent)) break;
4562 /* [drop through if divideInteger] */
4563 }
4564 /* also done enough if calculating remainder or integer */
4565 /* divide and just did the last ('units') unit */
4566 if (exponent==0 && !(op&DIVIDE)) break;
4567
4568 /* to get here, var1 is less than var2, so divide var2 by the per- */
4569 /* Unit power of ten and go for the next digit */
4570 var2ulen--; /* shift down */
4571 exponent-=DECDPUN; /* update the exponent */
4572 } /* outer loop */
4573
4574 /* ---- division is complete --------------------------------------- */
4575 /* here: acc has at least reqdigits+1 of good results (or fewer */
4576 /* if early stop), starting at accnext+1 (its lsu) */
4577 /* var1 has any residue at the stopping point */
4578 /* accunits is the number of digits collected in acc */
4579 if (accunits==0) { /* acc is 0 */
4580 accunits=1; /* show have a unit .. */
4581 accdigits=1; /* .. */
4582 *accnext=0; /* .. whose value is 0 */
4583 }
4584 else accnext++; /* back to last placed */
4585 /* accnext now -> lowest unit of result */
4586
4587 residue=0; /* assume no residue */
4588 if (op&DIVIDE) {
4589 /* record the presence of any residue, for rounding */
4590 if (*var1!=0 || var1units>1) residue=1;
4591 else { /* no residue */
4592 /* Had an exact division; clean up spurious trailing 0s. */
4593 /* There will be at most DECDPUN-1, from the final multiply, */
4594 /* and then only if the result is non-0 (and even) and the */
4595 /* exponent is 'loose'. */
4596 #if DECDPUN>1
4597 Unit lsu=*accnext;
4598 if (!(lsu&0x01) && (lsu!=0)) {
4599 /* count the trailing zeros */
4600 Int drop=0;
4601 for (;; drop++) { /* [will terminate because lsu!=0] */
4602 if (exponent>=maxexponent) break; /* don't chop real 0s */
4603 #if DECDPUN<=4
4604 if ((lsu-QUOT10(lsu, drop+1)
4605 *powers[drop+1])!=0) break; /* found non-0 digit */
4606 #else
4607 if (lsu%powers[drop+1]!=0) break; /* found non-0 digit */
4608 #endif
4609 exponent++;
4610 }
4611 if (drop>0) {
4612 accunits=decShiftToLeast(accnext, accunits, drop);
4613 accdigits=decGetDigits(accnext, accunits);
4614 accunits=D2U(accdigits);
4615 /* [exponent was adjusted in the loop] */
4616 }
4617 } /* neither odd nor 0 */
4618 #endif
4619 } /* exact divide */
4620 } /* divide */
4621 else /* op!=DIVIDE */ {
4622 /* check for coefficient overflow */
4623 if (accdigits+exponent>reqdigits) {
4624 *status|=DEC_Division_impossible;
4625 break;
4626 }
4627 if (op & (REMAINDER|REMNEAR)) {
4628 /* [Here, the exponent will be 0, because var1 was adjusted */
4629 /* appropriately.] */
4630 Int postshift; /* work */
4631 Flag wasodd=0; /* integer was odd */
4632 Unit *quotlsu; /* for save */
4633 Int quotdigits; /* .. */
4634
4635 bits=lhs->bits; /* remainder sign is always as lhs */
4636
4637 /* Fastpath when residue is truly 0 is worthwhile [and */
4638 /* simplifies the code below] */
4639 if (*var1==0 && var1units==1) { /* residue is 0 */
4640 Int exp=lhs->exponent; /* save min(exponents) */
4641 if (rhs->exponent<exp) exp=rhs->exponent;
4642 decNumberZero(res); /* 0 coefficient */
4643 #if DECSUBSET
4644 if (set->extended)
4645 #endif
4646 res->exponent=exp; /* .. with proper exponent */
4647 res->bits=(uByte)(bits&DECNEG); /* [cleaned] */
4648 decFinish(res, set, &residue, status); /* might clamp */
4649 break;
4650 }
4651 /* note if the quotient was odd */
4652 if (*accnext & 0x01) wasodd=1; /* acc is odd */
4653 quotlsu=accnext; /* save in case need to reinspect */
4654 quotdigits=accdigits; /* .. */
4655
4656 /* treat the residue, in var1, as the value to return, via acc */
4657 /* calculate the unused zero digits. This is the smaller of: */
4658 /* var1 initial padding (saved above) */
4659 /* var2 residual padding, which happens to be given by: */
4660 postshift=var1initpad+exponent-lhs->exponent+rhs->exponent;
4661 /* [the 'exponent' term accounts for the shifts during divide] */
4662 if (var1initpad<postshift) postshift=var1initpad;
4663
4664 /* shift var1 the requested amount, and adjust its digits */
4665 var1units=decShiftToLeast(var1, var1units, postshift);
4666 accnext=var1;
4667 accdigits=decGetDigits(var1, var1units);
4668 accunits=D2U(accdigits);
4669
4670 exponent=lhs->exponent; /* exponent is smaller of lhs & rhs */
4671 if (rhs->exponent<exponent) exponent=rhs->exponent;
4672
4673 /* Now correct the result if doing remainderNear; if it */
4674 /* (looking just at coefficients) is > rhs/2, or == rhs/2 and */
4675 /* the integer was odd then the result should be rem-rhs. */
4676 if (op&REMNEAR) {
4677 Int compare, tarunits; /* work */
4678 Unit *up; /* .. */
4679 /* calculate remainder*2 into the var1 buffer (which has */
4680 /* 'headroom' of an extra unit and hence enough space) */
4681 /* [a dedicated 'double' loop would be faster, here] */
4682 tarunits=decUnitAddSub(accnext, accunits, accnext, accunits,
4683 0, accnext, 1);
4684 /* decDumpAr('r', accnext, tarunits); */
4685
4686 /* Here, accnext (var1) holds tarunits Units with twice the */
4687 /* remainder's coefficient, which must now be compared to the */
4688 /* RHS. The remainder's exponent may be smaller than the RHS's. */
4689 compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits),
4690 rhs->exponent-exponent);
4691 if (compare==BADINT) { /* deep trouble */
4692 *status|=DEC_Insufficient_storage;
4693 break;}
4694
4695 /* now restore the remainder by dividing by two; the lsu */
4696 /* is known to be even. */
4697 for (up=accnext; up<accnext+tarunits; up++) {
4698 Int half; /* half to add to lower unit */
4699 half=*up & 0x01;
4700 *up/=2; /* [shift] */
4701 if (!half) continue;
4702 *(up-1)+=(DECDPUNMAX+1)/2;
4703 }
4704 /* [accunits still describes the original remainder length] */
4705
4706 if (compare>0 || (compare==0 && wasodd)) { /* adjustment needed */
4707 Int exp, expunits, exprem; /* work */
4708 /* This is effectively causing round-up of the quotient, */
4709 /* so if it was the rare case where it was full and all */
4710 /* nines, it would overflow and hence division-impossible */
4711 /* should be raised */
4712 Flag allnines=0; /* 1 if quotient all nines */
4713 if (quotdigits==reqdigits) { /* could be borderline */
4714 for (up=quotlsu; ; up++) {
4715 if (quotdigits>DECDPUN) {
4716 if (*up!=DECDPUNMAX) break;/* non-nines */
4717 }
4718 else { /* this is the last Unit */
4719 if (*up==powers[quotdigits]-1) allnines=1;
4720 break;
4721 }
4722 quotdigits-=DECDPUN; /* checked those digits */
4723 } /* up */
4724 } /* borderline check */
4725 if (allnines) {
4726 *status|=DEC_Division_impossible;
4727 break;}
4728
4729 /* rem-rhs is needed; the sign will invert. Again, var1 */
4730 /* can safely be used for the working Units array. */
4731 exp=rhs->exponent-exponent; /* RHS padding needed */
4732 /* Calculate units and remainder from exponent. */
4733 expunits=exp/DECDPUN;
4734 exprem=exp%DECDPUN;
4735 /* subtract [A+B*(-m)]; the result will always be negative */
4736 accunits=-decUnitAddSub(accnext, accunits,
4737 rhs->lsu, D2U(rhs->digits),
4738 expunits, accnext, -(Int)powers[exprem]);
4739 accdigits=decGetDigits(accnext, accunits); /* count digits exactly */
4740 accunits=D2U(accdigits); /* and recalculate the units for copy */
4741 /* [exponent is as for original remainder] */
4742 bits^=DECNEG; /* flip the sign */
4743 }
4744 } /* REMNEAR */
4745 } /* REMAINDER or REMNEAR */
4746 } /* not DIVIDE */
4747
4748 /* Set exponent and bits */
4749 res->exponent=exponent;
4750 res->bits=(uByte)(bits&DECNEG); /* [cleaned] */
4751
4752 /* Now the coefficient. */
4753 decSetCoeff(res, set, accnext, accdigits, &residue, status);
4754
4755 decFinish(res, set, &residue, status); /* final cleanup */
4756
4757 #if DECSUBSET
4758 /* If a divide then strip trailing zeros if subset [after round] */
4759 if (!set->extended && (op==DIVIDE)) decTrim(res, set, 0, &dropped);
4760 #endif
4761 } while(0); /* end protected */
4762
4763 if (varalloc!=NULL) free(varalloc); /* drop any storage used */
4764 if (allocacc!=NULL) free(allocacc); /* .. */
4765 #if DECSUBSET
4766 if (allocrhs!=NULL) free(allocrhs); /* .. */
4767 if (alloclhs!=NULL) free(alloclhs); /* .. */
4768 #endif
4769 return res;
4770 } /* decDivideOp */
4771
4772 /* ------------------------------------------------------------------ */
4773 /* decMultiplyOp -- multiplication operation */
4774 /* */
4775 /* This routine performs the multiplication C=A x B. */
4776 /* */
4777 /* res is C, the result. C may be A and/or B (e.g., X=X*X) */
4778 /* lhs is A */
4779 /* rhs is B */
4780 /* set is the context */
4781 /* status is the usual accumulator */
4782 /* */
4783 /* C must have space for set->digits digits. */
4784 /* */
4785 /* ------------------------------------------------------------------ */
4786 /* 'Classic' multiplication is used rather than Karatsuba, as the */
4787 /* latter would give only a minor improvement for the short numbers */
4788 /* expected to be handled most (and uses much more memory). */
4789 /* */
4790 /* There are two major paths here: the general-purpose ('old code') */
4791 /* path which handles all DECDPUN values, and a fastpath version */
4792 /* which is used if 64-bit ints are available, DECDPUN<=4, and more */
4793 /* than two calls to decUnitAddSub would be made. */
4794 /* */
4795 /* The fastpath version lumps units together into 8-digit or 9-digit */
4796 /* chunks, and also uses a lazy carry strategy to minimise expensive */
4797 /* 64-bit divisions. The chunks are then broken apart again into */
4798 /* units for continuing processing. Despite this overhead, the */
4799 /* fastpath can speed up some 16-digit operations by 10x (and much */
4800 /* more for higher-precision calculations). */
4801 /* */
4802 /* A buffer always has to be used for the accumulator; in the */
4803 /* fastpath, buffers are also always needed for the chunked copies of */
4804 /* of the operand coefficients. */
4805 /* Static buffers are larger than needed just for multiply, to allow */
4806 /* for calls from other operations (notably exp). */
4807 /* ------------------------------------------------------------------ */
4808 #define FASTMUL (DECUSE64 && DECDPUN<5)
4809 static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,
4810 const decNumber *rhs, decContext *set,
4811 uInt *status) {
4812 Int accunits; /* Units of accumulator in use */
4813 Int exponent; /* work */
4814 Int residue=0; /* rounding residue */
4815 uByte bits; /* result sign */
4816 Unit *acc; /* -> accumulator Unit array */
4817 Int needbytes; /* size calculator */
4818 void *allocacc=NULL; /* -> allocated accumulator, iff allocated */
4819 Unit accbuff[SD2U(DECBUFFER*4+1)]; /* buffer (+1 for DECBUFFER==0, */
4820 /* *4 for calls from other operations) */
4821 const Unit *mer, *mermsup; /* work */
4822 Int madlength; /* Units in multiplicand */
4823 Int shift; /* Units to shift multiplicand by */
4824
4825 #if FASTMUL
4826 /* if DECDPUN is 1 or 3 work in base 10**9, otherwise */
4827 /* (DECDPUN is 2 or 4) then work in base 10**8 */
4828 #if DECDPUN & 1 /* odd */
4829 #define FASTBASE 1000000000 /* base */
4830 #define FASTDIGS 9 /* digits in base */
4831 #define FASTLAZY 18 /* carry resolution point [1->18] */
4832 #else
4833 #define FASTBASE 100000000
4834 #define FASTDIGS 8
4835 #define FASTLAZY 1844 /* carry resolution point [1->1844] */
4836 #endif
4837 /* three buffers are used, two for chunked copies of the operands */
4838 /* (base 10**8 or base 10**9) and one base 2**64 accumulator with */
4839 /* lazy carry evaluation */
4840 uInt zlhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
4841 uInt *zlhi=zlhibuff; /* -> lhs array */
4842 uInt *alloclhi=NULL; /* -> allocated buffer, iff allocated */
4843 uInt zrhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
4844 uInt *zrhi=zrhibuff; /* -> rhs array */
4845 uInt *allocrhi=NULL; /* -> allocated buffer, iff allocated */
4846 uLong zaccbuff[(DECBUFFER*2+1)/4+2]; /* buffer (+1 for DECBUFFER==0) */
4847 /* [allocacc is shared for both paths, as only one will run] */
4848 uLong *zacc=zaccbuff; /* -> accumulator array for exact result */
4849 #if DECDPUN==1
4850 Int zoff; /* accumulator offset */
4851 #endif
4852 uInt *lip, *rip; /* item pointers */
4853 uInt *lmsi, *rmsi; /* most significant items */
4854 Int ilhs, irhs, iacc; /* item counts in the arrays */
4855 Int lazy; /* lazy carry counter */
4856 uLong lcarry; /* uLong carry */
4857 uInt carry; /* carry (NB not uLong) */
4858 Int count; /* work */
4859 const Unit *cup; /* .. */
4860 Unit *up; /* .. */
4861 uLong *lp; /* .. */
4862 Int p; /* .. */
4863 #endif
4864
4865 #if DECSUBSET
4866 decNumber *alloclhs=NULL; /* -> allocated buffer, iff allocated */
4867 decNumber *allocrhs=NULL; /* -> allocated buffer, iff allocated */
4868 #endif
4869
4870 #if DECCHECK
4871 if (decCheckOperands(res, lhs, rhs, set)) return res;
4872 #endif
4873
4874 /* precalculate result sign */
4875 bits=(uByte)((lhs->bits^rhs->bits)&DECNEG);
4876
4877 /* handle infinities and NaNs */
4878 if (SPECIALARGS) { /* a special bit set */
4879 if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
4880 decNaNs(res, lhs, rhs, set, status);
4881 return res;}
4882 /* one or two infinities; Infinity * 0 is invalid */
4883 if (((lhs->bits & DECINF)==0 && ISZERO(lhs))
4884 ||((rhs->bits & DECINF)==0 && ISZERO(rhs))) {
4885 *status|=DEC_Invalid_operation;
4886 return res;}
4887 decNumberZero(res);
4888 res->bits=bits|DECINF; /* infinity */
4889 return res;}
4890
4891 /* For best speed, as in DMSRCN [the original Rexx numerics */
4892 /* module], use the shorter number as the multiplier (rhs) and */
4893 /* the longer as the multiplicand (lhs) to minimise the number of */
4894 /* adds (partial products) */
4895 if (lhs->digits<rhs->digits) { /* swap... */
4896 const decNumber *hold=lhs;
4897 lhs=rhs;
4898 rhs=hold;
4899 }
4900
4901 do { /* protect allocated storage */
4902 #if DECSUBSET
4903 if (!set->extended) {
4904 /* reduce operands and set lostDigits status, as needed */
4905 if (lhs->digits>set->digits) {
4906 alloclhs=decRoundOperand(lhs, set, status);
4907 if (alloclhs==NULL) break;
4908 lhs=alloclhs;
4909 }
4910 if (rhs->digits>set->digits) {
4911 allocrhs=decRoundOperand(rhs, set, status);
4912 if (allocrhs==NULL) break;
4913 rhs=allocrhs;
4914 }
4915 }
4916 #endif
4917 /* [following code does not require input rounding] */
4918
4919 #if FASTMUL /* fastpath can be used */
4920 /* use the fast path if there are enough digits in the shorter */
4921 /* operand to make the setup and takedown worthwhile */
4922 #define NEEDTWO (DECDPUN*2) /* within two decUnitAddSub calls */
4923 if (rhs->digits>NEEDTWO) { /* use fastpath... */
4924 /* calculate the number of elements in each array */
4925 ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; /* [ceiling] */
4926 irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; /* .. */
4927 iacc=ilhs+irhs;
4928
4929 /* allocate buffers if required, as usual */
4930 needbytes=ilhs*sizeof(uInt);
4931 if (needbytes>(Int)sizeof(zlhibuff)) {
4932 alloclhi=(uInt *)malloc(needbytes);
4933 zlhi=alloclhi;}
4934 needbytes=irhs*sizeof(uInt);
4935 if (needbytes>(Int)sizeof(zrhibuff)) {
4936 allocrhi=(uInt *)malloc(needbytes);
4937 zrhi=allocrhi;}
4938
4939 /* Allocating the accumulator space needs a special case when */
4940 /* DECDPUN=1 because when converting the accumulator to Units */
4941 /* after the multiplication each 8-byte item becomes 9 1-byte */
4942 /* units. Therefore iacc extra bytes are needed at the front */
4943 /* (rounded up to a multiple of 8 bytes), and the uLong */
4944 /* accumulator starts offset the appropriate number of units */
4945 /* to the right to avoid overwrite during the unchunking. */
4946 needbytes=iacc*sizeof(uLong);
4947 #if DECDPUN==1
4948 zoff=(iacc+7)/8; /* items to offset by */
4949 needbytes+=zoff*8;
4950 #endif
4951 if (needbytes>(Int)sizeof(zaccbuff)) {
4952 allocacc=(uLong *)malloc(needbytes);
4953 zacc=(uLong *)allocacc;}
4954 if (zlhi==NULL||zrhi==NULL||zacc==NULL) {
4955 *status|=DEC_Insufficient_storage;
4956 break;}
4957
4958 acc=(Unit *)zacc; /* -> target Unit array */
4959 #if DECDPUN==1
4960 zacc+=zoff; /* start uLong accumulator to right */
4961 #endif
4962
4963 /* assemble the chunked copies of the left and right sides */
4964 for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++)
4965 for (p=0, *lip=0; p<FASTDIGS && count>0;
4966 p+=DECDPUN, cup++, count-=DECDPUN)
4967 *lip+=*cup*powers[p];
4968 lmsi=lip-1; /* save -> msi */
4969 for (count=rhs->digits, cup=rhs->lsu, rip=zrhi; count>0; rip++)
4970 for (p=0, *rip=0; p<FASTDIGS && count>0;
4971 p+=DECDPUN, cup++, count-=DECDPUN)
4972 *rip+=*cup*powers[p];
4973 rmsi=rip-1; /* save -> msi */
4974
4975 /* zero the accumulator */
4976 for (lp=zacc; lp<zacc+iacc; lp++) *lp=0;
4977
4978 /* Start the multiplication */
4979 /* Resolving carries can dominate the cost of accumulating the */
4980 /* partial products, so this is only done when necessary. */
4981 /* Each uLong item in the accumulator can hold values up to */
4982 /* 2**64-1, and each partial product can be as large as */
4983 /* (10**FASTDIGS-1)**2. When FASTDIGS=9, this can be added to */
4984 /* itself 18.4 times in a uLong without overflowing, so during */
4985 /* the main calculation resolution is carried out every 18th */
4986 /* add -- every 162 digits. Similarly, when FASTDIGS=8, the */
4987 /* partial products can be added to themselves 1844.6 times in */
4988 /* a uLong without overflowing, so intermediate carry */
4989 /* resolution occurs only every 14752 digits. Hence for common */
4990 /* short numbers usually only the one final carry resolution */
4991 /* occurs. */
4992 /* (The count is set via FASTLAZY to simplify experiments to */
4993 /* measure the value of this approach: a 35% improvement on a */
4994 /* [34x34] multiply.) */
4995 lazy=FASTLAZY; /* carry delay count */
4996 for (rip=zrhi; rip<=rmsi; rip++) { /* over each item in rhs */
4997 lp=zacc+(rip-zrhi); /* where to add the lhs */
4998 for (lip=zlhi; lip<=lmsi; lip++, lp++) { /* over each item in lhs */
4999 *lp+=(uLong)(*lip)*(*rip); /* [this should in-line] */
5000 } /* lip loop */
5001 lazy--;
5002 if (lazy>0 && rip!=rmsi) continue;
5003 lazy=FASTLAZY; /* reset delay count */
5004 /* spin up the accumulator resolving overflows */
5005 for (lp=zacc; lp<zacc+iacc; lp++) {
5006 if (*lp<FASTBASE) continue; /* it fits */
5007 lcarry=*lp/FASTBASE; /* top part [slow divide] */
5008 /* lcarry can exceed 2**32-1, so check again; this check */
5009 /* and occasional extra divide (slow) is well worth it, as */
5010 /* it allows FASTLAZY to be increased to 18 rather than 4 */
5011 /* in the FASTDIGS=9 case */
5012 if (lcarry<FASTBASE) carry=(uInt)lcarry; /* [usual] */
5013 else { /* two-place carry [fairly rare] */
5014 uInt carry2=(uInt)(lcarry/FASTBASE); /* top top part */
5015 *(lp+2)+=carry2; /* add to item+2 */
5016 *lp-=((uLong)FASTBASE*FASTBASE*carry2); /* [slow] */
5017 carry=(uInt)(lcarry-((uLong)FASTBASE*carry2)); /* [inline] */
5018 }
5019 *(lp+1)+=carry; /* add to item above [inline] */
5020 *lp-=((uLong)FASTBASE*carry); /* [inline] */
5021 } /* carry resolution */
5022 } /* rip loop */
5023
5024 /* The multiplication is complete; time to convert back into */
5025 /* units. This can be done in-place in the accumulator and in */
5026 /* 32-bit operations, because carries were resolved after the */
5027 /* final add. This needs N-1 divides and multiplies for */
5028 /* each item in the accumulator (which will become up to N */
5029 /* units, where 2<=N<=9). */
5030 for (lp=zacc, up=acc; lp<zacc+iacc; lp++) {
5031 uInt item=(uInt)*lp; /* decapitate to uInt */
5032 for (p=0; p<FASTDIGS-DECDPUN; p+=DECDPUN, up++) {
5033 uInt part=item/(DECDPUNMAX+1);
5034 *up=(Unit)(item-(part*(DECDPUNMAX+1)));
5035 item=part;
5036 } /* p */
5037 *up=(Unit)item; up++; /* [final needs no division] */
5038 } /* lp */
5039 accunits=up-acc; /* count of units */
5040 }
5041 else { /* here to use units directly, without chunking ['old code'] */
5042 #endif
5043
5044 /* if accumulator will be too long for local storage, then allocate */
5045 acc=accbuff; /* -> assume buffer for accumulator */
5046 needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit);
5047 if (needbytes>(Int)sizeof(accbuff)) {
5048 allocacc=(Unit *)malloc(needbytes);
5049 if (allocacc==NULL) {*status|=DEC_Insufficient_storage; break;}
5050 acc=(Unit *)allocacc; /* use the allocated space */
5051 }
5052
5053 /* Now the main long multiplication loop */
5054 /* Unlike the equivalent in the IBM Java implementation, there */
5055 /* is no advantage in calculating from msu to lsu. So, do it */
5056 /* by the book, as it were. */
5057 /* Each iteration calculates ACC=ACC+MULTAND*MULT */
5058 accunits=1; /* accumulator starts at '0' */
5059 *acc=0; /* .. (lsu=0) */
5060 shift=0; /* no multiplicand shift at first */
5061 madlength=D2U(lhs->digits); /* this won't change */
5062 mermsup=rhs->lsu+D2U(rhs->digits); /* -> msu+1 of multiplier */
5063
5064 for (mer=rhs->lsu; mer<mermsup; mer++) {
5065 /* Here, *mer is the next Unit in the multiplier to use */
5066 /* If non-zero [optimization] add it... */
5067 if (*mer!=0) accunits=decUnitAddSub(&acc[shift], accunits-shift,
5068 lhs->lsu, madlength, 0,
5069 &acc[shift], *mer)
5070 + shift;
5071 else { /* extend acc with a 0; it will be used shortly */
5072 *(acc+accunits)=0; /* [this avoids length of <=0 later] */
5073 accunits++;
5074 }
5075 /* multiply multiplicand by 10**DECDPUN for next Unit to left */
5076 shift++; /* add this for 'logical length' */
5077 } /* n */
5078 #if FASTMUL
5079 } /* unchunked units */
5080 #endif
5081 /* common end-path */
5082 #if DECTRACE
5083 decDumpAr('*', acc, accunits); /* Show exact result */
5084 #endif
5085
5086 /* acc now contains the exact result of the multiplication, */
5087 /* possibly with a leading zero unit; build the decNumber from */
5088 /* it, noting if any residue */
5089 res->bits=bits; /* set sign */
5090 res->digits=decGetDigits(acc, accunits); /* count digits exactly */
5091
5092 /* There can be a 31-bit wrap in calculating the exponent. */
5093 /* This can only happen if both input exponents are negative and */
5094 /* both their magnitudes are large. If there was a wrap, set a */
5095 /* safe very negative exponent, from which decFinalize() will */
5096 /* raise a hard underflow shortly. */
5097 exponent=lhs->exponent+rhs->exponent; /* calculate exponent */
5098 if (lhs->exponent<0 && rhs->exponent<0 && exponent>0)
5099 exponent=-2*DECNUMMAXE; /* force underflow */
5100 res->exponent=exponent; /* OK to overwrite now */
5101
5102
5103 /* Set the coefficient. If any rounding, residue records */
5104 decSetCoeff(res, set, acc, res->digits, &residue, status);
5105 decFinish(res, set, &residue, status); /* final cleanup */
5106 } while(0); /* end protected */
5107
5108 if (allocacc!=NULL) free(allocacc); /* drop any storage used */
5109 #if DECSUBSET
5110 if (allocrhs!=NULL) free(allocrhs); /* .. */
5111 if (alloclhs!=NULL) free(alloclhs); /* .. */
5112 #endif
5113 #if FASTMUL
5114 if (allocrhi!=NULL) free(allocrhi); /* .. */
5115 if (alloclhi!=NULL) free(alloclhi); /* .. */
5116 #endif
5117 return res;
5118 } /* decMultiplyOp */
5119
5120 /* ------------------------------------------------------------------ */
5121 /* decExpOp -- effect exponentiation */
5122 /* */
5123 /* This computes C = exp(A) */
5124 /* */
5125 /* res is C, the result. C may be A */
5126 /* rhs is A */
5127 /* set is the context; note that rounding mode has no effect */
5128 /* */
5129 /* C must have space for set->digits digits. status is updated but */
5130 /* not set. */
5131 /* */
5132 /* Restrictions: */
5133 /* */
5134 /* digits, emax, and -emin in the context must be less than */
5135 /* 2*DEC_MAX_MATH (1999998), and the rhs must be within these */
5136 /* bounds or a zero. This is an internal routine, so these */
5137 /* restrictions are contractual and not enforced. */
5138 /* */
5139 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */
5140 /* almost always be correctly rounded, but may be up to 1 ulp in */
5141 /* error in rare cases. */
5142 /* */
5143 /* Finite results will always be full precision and Inexact, except */
5144 /* when A is a zero or -Infinity (giving 1 or 0 respectively). */
5145 /* ------------------------------------------------------------------ */
5146 /* This approach used here is similar to the algorithm described in */
5147 /* */
5148 /* Variable Precision Exponential Function, T. E. Hull and */
5149 /* A. Abrham, ACM Transactions on Mathematical Software, Vol 12 #2, */
5150 /* pp79-91, ACM, June 1986. */
5151 /* */
5152 /* with the main difference being that the iterations in the series */
5153 /* evaluation are terminated dynamically (which does not require the */
5154 /* extra variable-precision variables which are expensive in this */
5155 /* context). */
5156 /* */
5157 /* The error analysis in Hull & Abrham's paper applies except for the */
5158 /* round-off error accumulation during the series evaluation. This */
5159 /* code does not precalculate the number of iterations and so cannot */
5160 /* use Horner's scheme. Instead, the accumulation is done at double- */
5161 /* precision, which ensures that the additions of the terms are exact */
5162 /* and do not accumulate round-off (and any round-off errors in the */
5163 /* terms themselves move 'to the right' faster than they can */
5164 /* accumulate). This code also extends the calculation by allowing, */
5165 /* in the spirit of other decNumber operators, the input to be more */
5166 /* precise than the result (the precision used is based on the more */
5167 /* precise of the input or requested result). */
5168 /* */
5169 /* Implementation notes: */
5170 /* */
5171 /* 1. This is separated out as decExpOp so it can be called from */
5172 /* other Mathematical functions (notably Ln) with a wider range */
5173 /* than normal. In particular, it can handle the slightly wider */
5174 /* (double) range needed by Ln (which has to be able to calculate */
5175 /* exp(-x) where x can be the tiniest number (Ntiny). */
5176 /* */
5177 /* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop */
5178 /* iterations by appoximately a third with additional (although */
5179 /* diminishing) returns as the range is reduced to even smaller */
5180 /* fractions. However, h (the power of 10 used to correct the */
5181 /* result at the end, see below) must be kept <=8 as otherwise */
5182 /* the final result cannot be computed. Hence the leverage is a */
5183 /* sliding value (8-h), where potentially the range is reduced */
5184 /* more for smaller values. */
5185 /* */
5186 /* The leverage that can be applied in this way is severely */
5187 /* limited by the cost of the raise-to-the power at the end, */
5188 /* which dominates when the number of iterations is small (less */
5189 /* than ten) or when rhs is short. As an example, the adjustment */
5190 /* x**10,000,000 needs 31 multiplications, all but one full-width. */
5191 /* */
5192 /* 3. The restrictions (especially precision) could be raised with */
5193 /* care, but the full decNumber range seems very hard within the */
5194 /* 32-bit limits. */
5195 /* */
5196 /* 4. The working precisions for the static buffers are twice the */
5197 /* obvious size to allow for calls from decNumberPower. */
5198 /* ------------------------------------------------------------------ */
5199 decNumber * decExpOp(decNumber *res, const decNumber *rhs,
5200 decContext *set, uInt *status) {
5201 uInt ignore=0; /* working status */
5202 Int h; /* adjusted exponent for 0.xxxx */
5203 Int p; /* working precision */
5204 Int residue; /* rounding residue */
5205 uInt needbytes; /* for space calculations */
5206 const decNumber *x=rhs; /* (may point to safe copy later) */
5207 decContext aset, tset, dset; /* working contexts */
5208 Int comp; /* work */
5209
5210 /* the argument is often copied to normalize it, so (unusually) it */
5211 /* is treated like other buffers, using DECBUFFER, +1 in case */
5212 /* DECBUFFER is 0 */
5213 decNumber bufr[D2N(DECBUFFER*2+1)];
5214 decNumber *allocrhs=NULL; /* non-NULL if rhs buffer allocated */
5215
5216 /* the working precision will be no more than set->digits+8+1 */
5217 /* so for on-stack buffers DECBUFFER+9 is used, +1 in case DECBUFFER */
5218 /* is 0 (and twice that for the accumulator) */
5219
5220 /* buffer for t, term (working precision plus) */
5221 decNumber buft[D2N(DECBUFFER*2+9+1)];
5222 decNumber *allocbuft=NULL; /* -> allocated buft, iff allocated */
5223 decNumber *t=buft; /* term */
5224 /* buffer for a, accumulator (working precision * 2), at least 9 */
5225 decNumber bufa[D2N(DECBUFFER*4+18+1)];
5226 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
5227 decNumber *a=bufa; /* accumulator */
5228 /* decNumber for the divisor term; this needs at most 9 digits */
5229 /* and so can be fixed size [16 so can use standard context] */
5230 decNumber bufd[D2N(16)];
5231 decNumber *d=bufd; /* divisor */
5232 decNumber numone; /* constant 1 */
5233
5234 #if DECCHECK
5235 Int iterations=0; /* for later sanity check */
5236 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5237 #endif
5238
5239 do { /* protect allocated storage */
5240 if (SPECIALARG) { /* handle infinities and NaNs */
5241 if (decNumberIsInfinite(rhs)) { /* an infinity */
5242 if (decNumberIsNegative(rhs)) /* -Infinity -> +0 */
5243 decNumberZero(res);
5244 else decNumberCopy(res, rhs); /* +Infinity -> self */
5245 }
5246 else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5247 break;}
5248
5249 if (ISZERO(rhs)) { /* zeros -> exact 1 */
5250 decNumberZero(res); /* make clean 1 */
5251 *res->lsu=1; /* .. */
5252 break;} /* [no status to set] */
5253
5254 /* e**x when 0 < x < 0.66 is < 1+3x/2, hence can fast-path */
5255 /* positive and negative tiny cases which will result in inexact */
5256 /* 1. This also allows the later add-accumulate to always be */
5257 /* exact (because its length will never be more than twice the */
5258 /* working precision). */
5259 /* The comparator (tiny) needs just one digit, so use the */
5260 /* decNumber d for it (reused as the divisor, etc., below); its */
5261 /* exponent is such that if x is positive it will have */
5262 /* set->digits-1 zeros between the decimal point and the digit, */
5263 /* which is 4, and if x is negative one more zero there as the */
5264 /* more precise result will be of the form 0.9999999 rather than */
5265 /* 1.0000001. Hence, tiny will be 0.0000004 if digits=7 and x>0 */
5266 /* or 0.00000004 if digits=7 and x<0. If RHS not larger than */
5267 /* this then the result will be 1.000000 */
5268 decNumberZero(d); /* clean */
5269 *d->lsu=4; /* set 4 .. */
5270 d->exponent=-set->digits; /* * 10**(-d) */
5271 if (decNumberIsNegative(rhs)) d->exponent--; /* negative case */
5272 comp=decCompare(d, rhs, 1); /* signless compare */
5273 if (comp==BADINT) {
5274 *status|=DEC_Insufficient_storage;
5275 break;}
5276 if (comp>=0) { /* rhs < d */
5277 Int shift=set->digits-1;
5278 decNumberZero(res); /* set 1 */
5279 *res->lsu=1; /* .. */
5280 res->digits=decShiftToMost(res->lsu, 1, shift);
5281 res->exponent=-shift; /* make 1.0000... */
5282 *status|=DEC_Inexact | DEC_Rounded; /* .. inexactly */
5283 break;} /* tiny */
5284
5285 /* set up the context to be used for calculating a, as this is */
5286 /* used on both paths below */
5287 decContextDefault(&aset, DEC_INIT_DECIMAL64);
5288 /* accumulator bounds are as requested (could underflow) */
5289 aset.emax=set->emax; /* usual bounds */
5290 aset.emin=set->emin; /* .. */
5291 aset.clamp=0; /* and no concrete format */
5292
5293 /* calculate the adjusted (Hull & Abrham) exponent (where the */
5294 /* decimal point is just to the left of the coefficient msd) */
5295 h=rhs->exponent+rhs->digits;
5296 /* if h>8 then 10**h cannot be calculated safely; however, when */
5297 /* h=8 then exp(|rhs|) will be at least exp(1E+7) which is at */
5298 /* least 6.59E+4342944, so (due to the restriction on Emax/Emin) */
5299 /* overflow (or underflow to 0) is guaranteed -- so this case can */
5300 /* be handled by simply forcing the appropriate excess */
5301 if (h>8) { /* overflow/underflow */
5302 /* set up here so Power call below will over or underflow to */
5303 /* zero; set accumulator to either 2 or 0.02 */
5304 /* [stack buffer for a is always big enough for this] */
5305 decNumberZero(a);
5306 *a->lsu=2; /* not 1 but < exp(1) */
5307 if (decNumberIsNegative(rhs)) a->exponent=-2; /* make 0.02 */
5308 h=8; /* clamp so 10**h computable */
5309 p=9; /* set a working precision */
5310 }
5311 else { /* h<=8 */
5312 Int maxlever=(rhs->digits>8?1:0);
5313 /* [could/should increase this for precisions >40 or so, too] */
5314
5315 /* if h is 8, cannot normalize to a lower upper limit because */
5316 /* the final result will not be computable (see notes above), */
5317 /* but leverage can be applied whenever h is less than 8. */
5318 /* Apply as much as possible, up to a MAXLEVER digits, which */
5319 /* sets the tradeoff against the cost of the later a**(10**h). */
5320 /* As h is increased, the working precision below also */
5321 /* increases to compensate for the "constant digits at the */
5322 /* front" effect. */
5323 Int lever=MINI(8-h, maxlever); /* leverage attainable */
5324 Int use=-rhs->digits-lever; /* exponent to use for RHS */
5325 h+=lever; /* apply leverage selected */
5326 if (h<0) { /* clamp */
5327 use+=h; /* [may end up subnormal] */
5328 h=0;
5329 }
5330 /* Take a copy of RHS if it needs normalization (true whenever x>=1) */
5331 if (rhs->exponent!=use) {
5332 decNumber *newrhs=bufr; /* assume will fit on stack */
5333 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
5334 if (needbytes>sizeof(bufr)) { /* need malloc space */
5335 allocrhs=(decNumber *)malloc(needbytes);
5336 if (allocrhs==NULL) { /* hopeless -- abandon */
5337 *status|=DEC_Insufficient_storage;
5338 break;}
5339 newrhs=allocrhs; /* use the allocated space */
5340 }
5341 decNumberCopy(newrhs, rhs); /* copy to safe space */
5342 newrhs->exponent=use; /* normalize; now <1 */
5343 x=newrhs; /* ready for use */
5344 /* decNumberShow(x); */
5345 }
5346
5347 /* Now use the usual power series to evaluate exp(x). The */
5348 /* series starts as 1 + x + x^2/2 ... so prime ready for the */
5349 /* third term by setting the term variable t=x, the accumulator */
5350 /* a=1, and the divisor d=2. */
5351
5352 /* First determine the working precision. From Hull & Abrham */
5353 /* this is set->digits+h+2. However, if x is 'over-precise' we */
5354 /* need to allow for all its digits to potentially participate */
5355 /* (consider an x where all the excess digits are 9s) so in */
5356 /* this case use x->digits+h+2 */
5357 p=MAXI(x->digits, set->digits)+h+2; /* [h<=8] */
5358
5359 /* a and t are variable precision, and depend on p, so space */
5360 /* must be allocated for them if necessary */
5361
5362 /* the accumulator needs to be able to hold 2p digits so that */
5363 /* the additions on the second and subsequent iterations are */
5364 /* sufficiently exact. */
5365 needbytes=sizeof(decNumber)+(D2U(p*2)-1)*sizeof(Unit);
5366 if (needbytes>sizeof(bufa)) { /* need malloc space */
5367 allocbufa=(decNumber *)malloc(needbytes);
5368 if (allocbufa==NULL) { /* hopeless -- abandon */
5369 *status|=DEC_Insufficient_storage;
5370 break;}
5371 a=allocbufa; /* use the allocated space */
5372 }
5373 /* the term needs to be able to hold p digits (which is */
5374 /* guaranteed to be larger than x->digits, so the initial copy */
5375 /* is safe); it may also be used for the raise-to-power */
5376 /* calculation below, which needs an extra two digits */
5377 needbytes=sizeof(decNumber)+(D2U(p+2)-1)*sizeof(Unit);
5378 if (needbytes>sizeof(buft)) { /* need malloc space */
5379 allocbuft=(decNumber *)malloc(needbytes);
5380 if (allocbuft==NULL) { /* hopeless -- abandon */
5381 *status|=DEC_Insufficient_storage;
5382 break;}
5383 t=allocbuft; /* use the allocated space */
5384 }
5385
5386 decNumberCopy(t, x); /* term=x */
5387 decNumberZero(a); *a->lsu=1; /* accumulator=1 */
5388 decNumberZero(d); *d->lsu=2; /* divisor=2 */
5389 decNumberZero(&numone); *numone.lsu=1; /* constant 1 for increment */
5390
5391 /* set up the contexts for calculating a, t, and d */
5392 decContextDefault(&tset, DEC_INIT_DECIMAL64);
5393 dset=tset;
5394 /* accumulator bounds are set above, set precision now */
5395 aset.digits=p*2; /* double */
5396 /* term bounds avoid any underflow or overflow */
5397 tset.digits=p;
5398 tset.emin=DEC_MIN_EMIN; /* [emax is plenty] */
5399 /* [dset.digits=16, etc., are sufficient] */
5400
5401 /* finally ready to roll */
5402 for (;;) {
5403 #if DECCHECK
5404 iterations++;
5405 #endif
5406 /* only the status from the accumulation is interesting */
5407 /* [but it should remain unchanged after first add] */
5408 decAddOp(a, a, t, &aset, 0, status); /* a=a+t */
5409 decMultiplyOp(t, t, x, &tset, &ignore); /* t=t*x */
5410 decDivideOp(t, t, d, &tset, DIVIDE, &ignore); /* t=t/d */
5411 /* the iteration ends when the term cannot affect the result, */
5412 /* if rounded to p digits, which is when its value is smaller */
5413 /* than the accumulator by p+1 digits. There must also be */
5414 /* full precision in a. */
5415 if (((a->digits+a->exponent)>=(t->digits+t->exponent+p+1))
5416 && (a->digits>=p)) break;
5417 decAddOp(d, d, &numone, &dset, 0, &ignore); /* d=d+1 */
5418 } /* iterate */
5419
5420 #if DECCHECK
5421 /* just a sanity check; comment out test to show always */
5422 if (iterations>p+3)
5423 printf("Exp iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5424 iterations, *status, p, x->digits);
5425 #endif
5426 } /* h<=8 */
5427
5428 /* apply postconditioning: a=a**(10**h) -- this is calculated */
5429 /* at a slightly higher precision than Hull & Abrham suggest */
5430 if (h>0) {
5431 Int seenbit=0; /* set once a 1-bit is seen */
5432 Int i; /* counter */
5433 Int n=powers[h]; /* always positive */
5434 aset.digits=p+2; /* sufficient precision */
5435 /* avoid the overhead and many extra digits of decNumberPower */
5436 /* as all that is needed is the short 'multipliers' loop; here */
5437 /* accumulate the answer into t */
5438 decNumberZero(t); *t->lsu=1; /* acc=1 */
5439 for (i=1;;i++){ /* for each bit [top bit ignored] */
5440 /* abandon if have had overflow or terminal underflow */
5441 if (*status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
5442 if (*status&DEC_Overflow || ISZERO(t)) break;}
5443 n=n<<1; /* move next bit to testable position */
5444 if (n<0) { /* top bit is set */
5445 seenbit=1; /* OK, have a significant bit */
5446 decMultiplyOp(t, t, a, &aset, status); /* acc=acc*x */
5447 }
5448 if (i==31) break; /* that was the last bit */
5449 if (!seenbit) continue; /* no need to square 1 */
5450 decMultiplyOp(t, t, t, &aset, status); /* acc=acc*acc [square] */
5451 } /*i*/ /* 32 bits */
5452 /* decNumberShow(t); */
5453 a=t; /* and carry on using t instead of a */
5454 }
5455
5456 /* Copy and round the result to res */
5457 residue=1; /* indicate dirt to right .. */
5458 if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */
5459 aset.digits=set->digits; /* [use default rounding] */
5460 decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5461 decFinish(res, set, &residue, status); /* cleanup/set flags */
5462 } while(0); /* end protected */
5463
5464 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */
5465 if (allocbufa!=NULL) free(allocbufa); /* .. */
5466 if (allocbuft!=NULL) free(allocbuft); /* .. */
5467 /* [status is handled by caller] */
5468 return res;
5469 } /* decExpOp */
5470
5471 /* ------------------------------------------------------------------ */
5472 /* Initial-estimate natural logarithm table */
5473 /* */
5474 /* LNnn -- 90-entry 16-bit table for values from .10 through .99. */
5475 /* The result is a 4-digit encode of the coefficient (c=the */
5476 /* top 14 bits encoding 0-9999) and a 2-digit encode of the */
5477 /* exponent (e=the bottom 2 bits encoding 0-3) */
5478 /* */
5479 /* The resulting value is given by: */
5480 /* */
5481 /* v = -c * 10**(-e-3) */
5482 /* */
5483 /* where e and c are extracted from entry k = LNnn[x-10] */
5484 /* where x is truncated (NB) into the range 10 through 99, */
5485 /* and then c = k>>2 and e = k&3. */
5486 /* ------------------------------------------------------------------ */
5487 const uShort LNnn[90]={9016, 8652, 8316, 8008, 7724, 7456, 7208,
5488 6972, 6748, 6540, 6340, 6148, 5968, 5792, 5628, 5464, 5312,
5489 5164, 5020, 4884, 4748, 4620, 4496, 4376, 4256, 4144, 4032,
5490 39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629,
5491 29777, 28945, 28129, 27329, 26545, 25777, 25021, 24281, 23553, 22837,
5492 22137, 21445, 20769, 20101, 19445, 18801, 18165, 17541, 16925, 16321,
5493 15721, 15133, 14553, 13985, 13421, 12865, 12317, 11777, 11241, 10717,
5494 10197, 9685, 9177, 8677, 8185, 7697, 7213, 6737, 6269, 5801,
5495 5341, 4889, 4437, 39930, 35534, 31186, 26886, 22630, 18418, 14254,
5496 10130, 6046, 20055};
5497
5498 /* ------------------------------------------------------------------ */
5499 /* decLnOp -- effect natural logarithm */
5500 /* */
5501 /* This computes C = ln(A) */
5502 /* */
5503 /* res is C, the result. C may be A */
5504 /* rhs is A */
5505 /* set is the context; note that rounding mode has no effect */
5506 /* */
5507 /* C must have space for set->digits digits. */
5508 /* */
5509 /* Notable cases: */
5510 /* A<0 -> Invalid */
5511 /* A=0 -> -Infinity (Exact) */
5512 /* A=+Infinity -> +Infinity (Exact) */
5513 /* A=1 exactly -> 0 (Exact) */
5514 /* */
5515 /* Restrictions (as for Exp): */
5516 /* */
5517 /* digits, emax, and -emin in the context must be less than */
5518 /* DEC_MAX_MATH+11 (1000010), and the rhs must be within these */
5519 /* bounds or a zero. This is an internal routine, so these */
5520 /* restrictions are contractual and not enforced. */
5521 /* */
5522 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */
5523 /* almost always be correctly rounded, but may be up to 1 ulp in */
5524 /* error in rare cases. */
5525 /* ------------------------------------------------------------------ */
5526 /* The result is calculated using Newton's method, with each */
5527 /* iteration calculating a' = a + x * exp(-a) - 1. See, for example, */
5528 /* Epperson 1989. */
5529 /* */
5530 /* The iteration ends when the adjustment x*exp(-a)-1 is tiny enough. */
5531 /* This has to be calculated at the sum of the precision of x and the */
5532 /* working precision. */
5533 /* */
5534 /* Implementation notes: */
5535 /* */
5536 /* 1. This is separated out as decLnOp so it can be called from */
5537 /* other Mathematical functions (e.g., Log 10) with a wider range */
5538 /* than normal. In particular, it can handle the slightly wider */
5539 /* (+9+2) range needed by a power function. */
5540 /* */
5541 /* 2. The speed of this function is about 10x slower than exp, as */
5542 /* it typically needs 4-6 iterations for short numbers, and the */
5543 /* extra precision needed adds a squaring effect, twice. */
5544 /* */
5545 /* 3. Fastpaths are included for ln(10) and ln(2), up to length 40, */
5546 /* as these are common requests. ln(10) is used by log10(x). */
5547 /* */
5548 /* 4. An iteration might be saved by widening the LNnn table, and */
5549 /* would certainly save at least one if it were made ten times */
5550 /* bigger, too (for truncated fractions 0.100 through 0.999). */
5551 /* However, for most practical evaluations, at least four or five */
5552 /* iterations will be neede -- so this would only speed up by */
5553 /* 20-25% and that probably does not justify increasing the table */
5554 /* size. */
5555 /* */
5556 /* 5. The static buffers are larger than might be expected to allow */
5557 /* for calls from decNumberPower. */
5558 /* ------------------------------------------------------------------ */
5559 decNumber * decLnOp(decNumber *res, const decNumber *rhs,
5560 decContext *set, uInt *status) {
5561 uInt ignore=0; /* working status accumulator */
5562 uInt needbytes; /* for space calculations */
5563 Int residue; /* rounding residue */
5564 Int r; /* rhs=f*10**r [see below] */
5565 Int p; /* working precision */
5566 Int pp; /* precision for iteration */
5567 Int t; /* work */
5568
5569 /* buffers for a (accumulator, typically precision+2) and b */
5570 /* (adjustment calculator, same size) */
5571 decNumber bufa[D2N(DECBUFFER+12)];
5572 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
5573 decNumber *a=bufa; /* accumulator/work */
5574 decNumber bufb[D2N(DECBUFFER*2+2)];
5575 decNumber *allocbufb=NULL; /* -> allocated bufa, iff allocated */
5576 decNumber *b=bufb; /* adjustment/work */
5577
5578 decNumber numone; /* constant 1 */
5579 decNumber cmp; /* work */
5580 decContext aset, bset; /* working contexts */
5581
5582 #if DECCHECK
5583 Int iterations=0; /* for later sanity check */
5584 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5585 #endif
5586
5587 do { /* protect allocated storage */
5588 if (SPECIALARG) { /* handle infinities and NaNs */
5589 if (decNumberIsInfinite(rhs)) { /* an infinity */
5590 if (decNumberIsNegative(rhs)) /* -Infinity -> error */
5591 *status|=DEC_Invalid_operation;
5592 else decNumberCopy(res, rhs); /* +Infinity -> self */
5593 }
5594 else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5595 break;}
5596
5597 if (ISZERO(rhs)) { /* +/- zeros -> -Infinity */
5598 decNumberZero(res); /* make clean */
5599 res->bits=DECINF|DECNEG; /* set - infinity */
5600 break;} /* [no status to set] */
5601
5602 /* Non-zero negatives are bad... */
5603 if (decNumberIsNegative(rhs)) { /* -x -> error */
5604 *status|=DEC_Invalid_operation;
5605 break;}
5606
5607 /* Here, rhs is positive, finite, and in range */
5608
5609 /* lookaside fastpath code for ln(2) and ln(10) at common lengths */
5610 if (rhs->exponent==0 && set->digits<=40) {
5611 #if DECDPUN==1
5612 if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { /* ln(10) */
5613 #else
5614 if (rhs->lsu[0]==10 && rhs->digits==2) { /* ln(10) */
5615 #endif
5616 aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5617 #define LN10 "2.302585092994045684017991454684364207601"
5618 decNumberFromString(res, LN10, &aset);
5619 *status|=(DEC_Inexact | DEC_Rounded); /* is inexact */
5620 break;}
5621 if (rhs->lsu[0]==2 && rhs->digits==1) { /* ln(2) */
5622 aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5623 #define LN2 "0.6931471805599453094172321214581765680755"
5624 decNumberFromString(res, LN2, &aset);
5625 *status|=(DEC_Inexact | DEC_Rounded);
5626 break;}
5627 } /* integer and short */
5628
5629 /* Determine the working precision. This is normally the */
5630 /* requested precision + 2, with a minimum of 9. However, if */
5631 /* the rhs is 'over-precise' then allow for all its digits to */
5632 /* potentially participate (consider an rhs where all the excess */
5633 /* digits are 9s) so in this case use rhs->digits+2. */
5634 p=MAXI(rhs->digits, MAXI(set->digits, 7))+2;
5635
5636 /* Allocate space for the accumulator and the high-precision */
5637 /* adjustment calculator, if necessary. The accumulator must */
5638 /* be able to hold p digits, and the adjustment up to */
5639 /* rhs->digits+p digits. They are also made big enough for 16 */
5640 /* digits so that they can be used for calculating the initial */
5641 /* estimate. */
5642 needbytes=sizeof(decNumber)+(D2U(MAXI(p,16))-1)*sizeof(Unit);
5643 if (needbytes>sizeof(bufa)) { /* need malloc space */
5644 allocbufa=(decNumber *)malloc(needbytes);
5645 if (allocbufa==NULL) { /* hopeless -- abandon */
5646 *status|=DEC_Insufficient_storage;
5647 break;}
5648 a=allocbufa; /* use the allocated space */
5649 }
5650 pp=p+rhs->digits;
5651 needbytes=sizeof(decNumber)+(D2U(MAXI(pp,16))-1)*sizeof(Unit);
5652 if (needbytes>sizeof(bufb)) { /* need malloc space */
5653 allocbufb=(decNumber *)malloc(needbytes);
5654 if (allocbufb==NULL) { /* hopeless -- abandon */
5655 *status|=DEC_Insufficient_storage;
5656 break;}
5657 b=allocbufb; /* use the allocated space */
5658 }
5659
5660 /* Prepare an initial estimate in acc. Calculate this by */
5661 /* considering the coefficient of x to be a normalized fraction, */
5662 /* f, with the decimal point at far left and multiplied by */
5663 /* 10**r. Then, rhs=f*10**r and 0.1<=f<1, and */
5664 /* ln(x) = ln(f) + ln(10)*r */
5665 /* Get the initial estimate for ln(f) from a small lookup */
5666 /* table (see above) indexed by the first two digits of f, */
5667 /* truncated. */
5668
5669 decContextDefault(&aset, DEC_INIT_DECIMAL64); /* 16-digit extended */
5670 r=rhs->exponent+rhs->digits; /* 'normalised' exponent */
5671 decNumberFromInt32(a, r); /* a=r */
5672 decNumberFromInt32(b, 2302585); /* b=ln(10) (2.302585) */
5673 b->exponent=-6; /* .. */
5674 decMultiplyOp(a, a, b, &aset, &ignore); /* a=a*b */
5675 /* now get top two digits of rhs into b by simple truncate and */
5676 /* force to integer */
5677 residue=0; /* (no residue) */
5678 aset.digits=2; aset.round=DEC_ROUND_DOWN;
5679 decCopyFit(b, rhs, &aset, &residue, &ignore); /* copy & shorten */
5680 b->exponent=0; /* make integer */
5681 t=decGetInt(b); /* [cannot fail] */
5682 if (t<10) t=X10(t); /* adjust single-digit b */
5683 t=LNnn[t-10]; /* look up ln(b) */
5684 decNumberFromInt32(b, t>>2); /* b=ln(b) coefficient */
5685 b->exponent=-(t&3)-3; /* set exponent */
5686 b->bits=DECNEG; /* ln(0.10)->ln(0.99) always -ve */
5687 aset.digits=16; aset.round=DEC_ROUND_HALF_EVEN; /* restore */
5688 decAddOp(a, a, b, &aset, 0, &ignore); /* acc=a+b */
5689 /* the initial estimate is now in a, with up to 4 digits correct. */
5690 /* When rhs is at or near Nmax the estimate will be low, so we */
5691 /* will approach it from below, avoiding overflow when calling exp. */
5692
5693 decNumberZero(&numone); *numone.lsu=1; /* constant 1 for adjustment */
5694
5695 /* accumulator bounds are as requested (could underflow, but */
5696 /* cannot overflow) */
5697 aset.emax=set->emax;
5698 aset.emin=set->emin;
5699 aset.clamp=0; /* no concrete format */
5700 /* set up a context to be used for the multiply and subtract */
5701 bset=aset;
5702 bset.emax=DEC_MAX_MATH*2; /* use double bounds for the */
5703 bset.emin=-DEC_MAX_MATH*2; /* adjustment calculation */
5704 /* [see decExpOp call below] */
5705 /* for each iteration double the number of digits to calculate, */
5706 /* up to a maximum of p */
5707 pp=9; /* initial precision */
5708 /* [initially 9 as then the sequence starts 7+2, 16+2, and */
5709 /* 34+2, which is ideal for standard-sized numbers] */
5710 aset.digits=pp; /* working context */
5711 bset.digits=pp+rhs->digits; /* wider context */
5712 for (;;) { /* iterate */
5713 #if DECCHECK
5714 iterations++;
5715 if (iterations>24) break; /* consider 9 * 2**24 */
5716 #endif
5717 /* calculate the adjustment (exp(-a)*x-1) into b. This is a */
5718 /* catastrophic subtraction but it really is the difference */
5719 /* from 1 that is of interest. */
5720 /* Use the internal entry point to Exp as it allows the double */
5721 /* range for calculating exp(-a) when a is the tiniest subnormal. */
5722 a->bits^=DECNEG; /* make -a */
5723 decExpOp(b, a, &bset, &ignore); /* b=exp(-a) */
5724 a->bits^=DECNEG; /* restore sign of a */
5725 /* now multiply by rhs and subtract 1, at the wider precision */
5726 decMultiplyOp(b, b, rhs, &bset, &ignore); /* b=b*rhs */
5727 decAddOp(b, b, &numone, &bset, DECNEG, &ignore); /* b=b-1 */
5728
5729 /* the iteration ends when the adjustment cannot affect the */
5730 /* result by >=0.5 ulp (at the requested digits), which */
5731 /* is when its value is smaller than the accumulator by */
5732 /* set->digits+1 digits (or it is zero) -- this is a looser */
5733 /* requirement than for Exp because all that happens to the */
5734 /* accumulator after this is the final rounding (but note that */
5735 /* there must also be full precision in a, or a=0). */
5736
5737 if (decNumberIsZero(b) ||
5738 (a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) {
5739 if (a->digits==p) break;
5740 if (decNumberIsZero(a)) {
5741 decCompareOp(&cmp, rhs, &numone, &aset, COMPARE, &ignore); /* rhs=1 ? */
5742 if (cmp.lsu[0]==0) a->exponent=0; /* yes, exact 0 */
5743 else *status|=(DEC_Inexact | DEC_Rounded); /* no, inexact */
5744 break;
5745 }
5746 /* force padding if adjustment has gone to 0 before full length */
5747 if (decNumberIsZero(b)) b->exponent=a->exponent-p;
5748 }
5749
5750 /* not done yet ... */
5751 decAddOp(a, a, b, &aset, 0, &ignore); /* a=a+b for next estimate */
5752 if (pp==p) continue; /* precision is at maximum */
5753 /* lengthen the next calculation */
5754 pp=pp*2; /* double precision */
5755 if (pp>p) pp=p; /* clamp to maximum */
5756 aset.digits=pp; /* working context */
5757 bset.digits=pp+rhs->digits; /* wider context */
5758 } /* Newton's iteration */
5759
5760 #if DECCHECK
5761 /* just a sanity check; remove the test to show always */
5762 if (iterations>24)
5763 printf("Ln iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5764 iterations, *status, p, rhs->digits);
5765 #endif
5766
5767 /* Copy and round the result to res */
5768 residue=1; /* indicate dirt to right */
5769 if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */
5770 aset.digits=set->digits; /* [use default rounding] */
5771 decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5772 decFinish(res, set, &residue, status); /* cleanup/set flags */
5773 } while(0); /* end protected */
5774
5775 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
5776 if (allocbufb!=NULL) free(allocbufb); /* .. */
5777 /* [status is handled by caller] */
5778 return res;
5779 } /* decLnOp */
5780
5781 /* ------------------------------------------------------------------ */
5782 /* decQuantizeOp -- force exponent to requested value */
5783 /* */
5784 /* This computes C = op(A, B), where op adjusts the coefficient */
5785 /* of C (by rounding or shifting) such that the exponent (-scale) */
5786 /* of C has the value B or matches the exponent of B. */
5787 /* The numerical value of C will equal A, except for the effects of */
5788 /* any rounding that occurred. */
5789 /* */
5790 /* res is C, the result. C may be A or B */
5791 /* lhs is A, the number to adjust */
5792 /* rhs is B, the requested exponent */
5793 /* set is the context */
5794 /* quant is 1 for quantize or 0 for rescale */
5795 /* status is the status accumulator (this can be called without */
5796 /* risk of control loss) */
5797 /* */
5798 /* C must have space for set->digits digits. */
5799 /* */
5800 /* Unless there is an error or the result is infinite, the exponent */
5801 /* after the operation is guaranteed to be that requested. */
5802 /* ------------------------------------------------------------------ */
5803 static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs,
5804 const decNumber *rhs, decContext *set,
5805 Flag quant, uInt *status) {
5806 #if DECSUBSET
5807 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
5808 decNumber *allocrhs=NULL; /* .., rhs */
5809 #endif
5810 const decNumber *inrhs=rhs; /* save original rhs */
5811 Int reqdigits=set->digits; /* requested DIGITS */
5812 Int reqexp; /* requested exponent [-scale] */
5813 Int residue=0; /* rounding residue */
5814 Int etiny=set->emin-(reqdigits-1);
5815
5816 #if DECCHECK
5817 if (decCheckOperands(res, lhs, rhs, set)) return res;
5818 #endif
5819
5820 do { /* protect allocated storage */
5821 #if DECSUBSET
5822 if (!set->extended) {
5823 /* reduce operands and set lostDigits status, as needed */
5824 if (lhs->digits>reqdigits) {
5825 alloclhs=decRoundOperand(lhs, set, status);
5826 if (alloclhs==NULL) break;
5827 lhs=alloclhs;
5828 }
5829 if (rhs->digits>reqdigits) { /* [this only checks lostDigits] */
5830 allocrhs=decRoundOperand(rhs, set, status);
5831 if (allocrhs==NULL) break;
5832 rhs=allocrhs;
5833 }
5834 }
5835 #endif
5836 /* [following code does not require input rounding] */
5837
5838 /* Handle special values */
5839 if (SPECIALARGS) {
5840 /* NaNs get usual processing */
5841 if (SPECIALARGS & (DECSNAN | DECNAN))
5842 decNaNs(res, lhs, rhs, set, status);
5843 /* one infinity but not both is bad */
5844 else if ((lhs->bits ^ rhs->bits) & DECINF)
5845 *status|=DEC_Invalid_operation;
5846 /* both infinity: return lhs */
5847 else decNumberCopy(res, lhs); /* [nop if in place] */
5848 break;
5849 }
5850
5851 /* set requested exponent */
5852 if (quant) reqexp=inrhs->exponent; /* quantize -- match exponents */
5853 else { /* rescale -- use value of rhs */
5854 /* Original rhs must be an integer that fits and is in range, */
5855 /* which could be from -1999999997 to +999999999, thanks to */
5856 /* subnormals */
5857 reqexp=decGetInt(inrhs); /* [cannot fail] */
5858 }
5859
5860 #if DECSUBSET
5861 if (!set->extended) etiny=set->emin; /* no subnormals */
5862 #endif
5863
5864 if (reqexp==BADINT /* bad (rescale only) or .. */
5865 || reqexp==BIGODD || reqexp==BIGEVEN /* very big (ditto) or .. */
5866 || (reqexp<etiny) /* < lowest */
5867 || (reqexp>set->emax)) { /* > emax */
5868 *status|=DEC_Invalid_operation;
5869 break;}
5870
5871 /* the RHS has been processed, so it can be overwritten now if necessary */
5872 if (ISZERO(lhs)) { /* zero coefficient unchanged */
5873 decNumberCopy(res, lhs); /* [nop if in place] */
5874 res->exponent=reqexp; /* .. just set exponent */
5875 #if DECSUBSET
5876 if (!set->extended) res->bits=0; /* subset specification; no -0 */
5877 #endif
5878 }
5879 else { /* non-zero lhs */
5880 Int adjust=reqexp-lhs->exponent; /* digit adjustment needed */
5881 /* if adjusted coefficient will definitely not fit, give up now */
5882 if ((lhs->digits-adjust)>reqdigits) {
5883 *status|=DEC_Invalid_operation;
5884 break;
5885 }
5886
5887 if (adjust>0) { /* increasing exponent */
5888 /* this will decrease the length of the coefficient by adjust */
5889 /* digits, and must round as it does so */
5890 decContext workset; /* work */
5891 workset=*set; /* clone rounding, etc. */
5892 workset.digits=lhs->digits-adjust; /* set requested length */
5893 /* [note that the latter can be <1, here] */
5894 decCopyFit(res, lhs, &workset, &residue, status); /* fit to result */
5895 decApplyRound(res, &workset, residue, status); /* .. and round */
5896 residue=0; /* [used] */
5897 /* If just rounded a 999s case, exponent will be off by one; */
5898 /* adjust back (after checking space), if so. */
5899 if (res->exponent>reqexp) {
5900 /* re-check needed, e.g., for quantize(0.9999, 0.001) under */
5901 /* set->digits==3 */
5902 if (res->digits==reqdigits) { /* cannot shift by 1 */
5903 *status&=~(DEC_Inexact | DEC_Rounded); /* [clean these] */
5904 *status|=DEC_Invalid_operation;
5905 break;
5906 }
5907 res->digits=decShiftToMost(res->lsu, res->digits, 1); /* shift */
5908 res->exponent--; /* (re)adjust the exponent. */
5909 }
5910 #if DECSUBSET
5911 if (ISZERO(res) && !set->extended) res->bits=0; /* subset; no -0 */
5912 #endif
5913 } /* increase */
5914 else /* adjust<=0 */ { /* decreasing or = exponent */
5915 /* this will increase the length of the coefficient by -adjust */
5916 /* digits, by adding zero or more trailing zeros; this is */
5917 /* already checked for fit, above */
5918 decNumberCopy(res, lhs); /* [it will fit] */
5919 /* if padding needed (adjust<0), add it now... */
5920 if (adjust<0) {
5921 res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
5922 res->exponent+=adjust; /* adjust the exponent */
5923 }
5924 } /* decrease */
5925 } /* non-zero */
5926
5927 /* Check for overflow [do not use Finalize in this case, as an */
5928 /* overflow here is a "don't fit" situation] */
5929 if (res->exponent>set->emax-res->digits+1) { /* too big */
5930 *status|=DEC_Invalid_operation;
5931 break;
5932 }
5933 else {
5934 decFinalize(res, set, &residue, status); /* set subnormal flags */
5935 *status&=~DEC_Underflow; /* suppress Underflow [754r] */
5936 }
5937 } while(0); /* end protected */
5938
5939 #if DECSUBSET
5940 if (allocrhs!=NULL) free(allocrhs); /* drop any storage used */
5941 if (alloclhs!=NULL) free(alloclhs); /* .. */
5942 #endif
5943 return res;
5944 } /* decQuantizeOp */
5945
5946 /* ------------------------------------------------------------------ */
5947 /* decCompareOp -- compare, min, or max two Numbers */
5948 /* */
5949 /* This computes C = A ? B and carries out one of four operations: */
5950 /* COMPARE -- returns the signum (as a number) giving the */
5951 /* result of a comparison unless one or both */
5952 /* operands is a NaN (in which case a NaN results) */
5953 /* COMPSIG -- as COMPARE except that a quiet NaN raises */
5954 /* Invalid operation. */
5955 /* COMPMAX -- returns the larger of the operands, using the */
5956 /* 754r maxnum operation */
5957 /* COMPMAXMAG -- ditto, comparing absolute values */
5958 /* COMPMIN -- the 754r minnum operation */
5959 /* COMPMINMAG -- ditto, comparing absolute values */
5960 /* COMTOTAL -- returns the signum (as a number) giving the */
5961 /* result of a comparison using 754r total ordering */
5962 /* */
5963 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
5964 /* lhs is A */
5965 /* rhs is B */
5966 /* set is the context */
5967 /* op is the operation flag */
5968 /* status is the usual accumulator */
5969 /* */
5970 /* C must have space for one digit for COMPARE or set->digits for */
5971 /* COMPMAX, COMPMIN, COMPMAXMAG, or COMPMINMAG. */
5972 /* ------------------------------------------------------------------ */
5973 /* The emphasis here is on speed for common cases, and avoiding */
5974 /* coefficient comparison if possible. */
5975 /* ------------------------------------------------------------------ */
5976 decNumber * decCompareOp(decNumber *res, const decNumber *lhs,
5977 const decNumber *rhs, decContext *set,
5978 Flag op, uInt *status) {
5979 #if DECSUBSET
5980 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
5981 decNumber *allocrhs=NULL; /* .., rhs */
5982 #endif
5983 Int result=0; /* default result value */
5984 uByte merged; /* work */
5985
5986 #if DECCHECK
5987 if (decCheckOperands(res, lhs, rhs, set)) return res;
5988 #endif
5989
5990 do { /* protect allocated storage */
5991 #if DECSUBSET
5992 if (!set->extended) {
5993 /* reduce operands and set lostDigits status, as needed */
5994 if (lhs->digits>set->digits) {
5995 alloclhs=decRoundOperand(lhs, set, status);
5996 if (alloclhs==NULL) {result=BADINT; break;}
5997 lhs=alloclhs;
5998 }
5999 if (rhs->digits>set->digits) {
6000 allocrhs=decRoundOperand(rhs, set, status);
6001 if (allocrhs==NULL) {result=BADINT; break;}
6002 rhs=allocrhs;
6003 }
6004 }
6005 #endif
6006 /* [following code does not require input rounding] */
6007
6008 /* If total ordering then handle differing signs 'up front' */
6009 if (op==COMPTOTAL) { /* total ordering */
6010 if (decNumberIsNegative(lhs) & !decNumberIsNegative(rhs)) {
6011 result=-1;
6012 break;
6013 }
6014 if (!decNumberIsNegative(lhs) & decNumberIsNegative(rhs)) {
6015 result=+1;
6016 break;
6017 }
6018 }
6019
6020 /* handle NaNs specially; let infinities drop through */
6021 /* This assumes sNaN (even just one) leads to NaN. */
6022 merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN);
6023 if (merged) { /* a NaN bit set */
6024 if (op==COMPARE); /* result will be NaN */
6025 else if (op==COMPSIG) /* treat qNaN as sNaN */
6026 *status|=DEC_Invalid_operation | DEC_sNaN;
6027 else if (op==COMPTOTAL) { /* total ordering, always finite */
6028 /* signs are known to be the same; compute the ordering here */
6029 /* as if the signs are both positive, then invert for negatives */
6030 if (!decNumberIsNaN(lhs)) result=-1;
6031 else if (!decNumberIsNaN(rhs)) result=+1;
6032 /* here if both NaNs */
6033 else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1;
6034 else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1;
6035 else { /* both NaN or both sNaN */
6036 /* now it just depends on the payload */
6037 result=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6038 rhs->lsu, D2U(rhs->digits), 0);
6039 /* [Error not possible, as these are 'aligned'] */
6040 } /* both same NaNs */
6041 if (decNumberIsNegative(lhs)) result=-result;
6042 break;
6043 } /* total order */
6044
6045 else if (merged & DECSNAN); /* sNaN -> qNaN */
6046 else { /* here if MIN or MAX and one or two quiet NaNs */
6047 /* min or max -- 754r rules ignore single NaN */
6048 if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) {
6049 /* just one NaN; force choice to be the non-NaN operand */
6050 op=COMPMAX;
6051 if (lhs->bits & DECNAN) result=-1; /* pick rhs */
6052 else result=+1; /* pick lhs */
6053 break;
6054 }
6055 } /* max or min */
6056 op=COMPNAN; /* use special path */
6057 decNaNs(res, lhs, rhs, set, status); /* propagate NaN */
6058 break;
6059 }
6060 /* have numbers */
6061 if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1);
6062 else result=decCompare(lhs, rhs, 0); /* sign matters */
6063 } while(0); /* end protected */
6064
6065 if (result==BADINT) *status|=DEC_Insufficient_storage; /* rare */
6066 else {
6067 if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { /* returning signum */
6068 if (op==COMPTOTAL && result==0) {
6069 /* operands are numerically equal or same NaN (and same sign, */
6070 /* tested first); if identical, leave result 0 */
6071 if (lhs->exponent!=rhs->exponent) {
6072 if (lhs->exponent<rhs->exponent) result=-1;
6073 else result=+1;
6074 if (decNumberIsNegative(lhs)) result=-result;
6075 } /* lexp!=rexp */
6076 } /* total-order by exponent */
6077 decNumberZero(res); /* [always a valid result] */
6078 if (result!=0) { /* must be -1 or +1 */
6079 *res->lsu=1;
6080 if (result<0) res->bits=DECNEG;
6081 }
6082 }
6083 else if (op==COMPNAN); /* special, drop through */
6084 else { /* MAX or MIN, non-NaN result */
6085 Int residue=0; /* rounding accumulator */
6086 /* choose the operand for the result */
6087 const decNumber *choice;
6088 if (result==0) { /* operands are numerically equal */
6089 /* choose according to sign then exponent (see 754r) */
6090 uByte slhs=(lhs->bits & DECNEG);
6091 uByte srhs=(rhs->bits & DECNEG);
6092 #if DECSUBSET
6093 if (!set->extended) { /* subset: force left-hand */
6094 op=COMPMAX;
6095 result=+1;
6096 }
6097 else
6098 #endif
6099 if (slhs!=srhs) { /* signs differ */
6100 if (slhs) result=-1; /* rhs is max */
6101 else result=+1; /* lhs is max */
6102 }
6103 else if (slhs && srhs) { /* both negative */
6104 if (lhs->exponent<rhs->exponent) result=+1;
6105 else result=-1;
6106 /* [if equal, use lhs, technically identical] */
6107 }
6108 else { /* both positive */
6109 if (lhs->exponent>rhs->exponent) result=+1;
6110 else result=-1;
6111 /* [ditto] */
6112 }
6113 } /* numerically equal */
6114 /* here result will be non-0; reverse if looking for MIN */
6115 if (op==COMPMIN || op==COMPMINMAG) result=-result;
6116 choice=(result>0 ? lhs : rhs); /* choose */
6117 /* copy chosen to result, rounding if need be */
6118 decCopyFit(res, choice, set, &residue, status);
6119 decFinish(res, set, &residue, status);
6120 }
6121 }
6122 #if DECSUBSET
6123 if (allocrhs!=NULL) free(allocrhs); /* free any storage used */
6124 if (alloclhs!=NULL) free(alloclhs); /* .. */
6125 #endif
6126 return res;
6127 } /* decCompareOp */
6128
6129 /* ------------------------------------------------------------------ */
6130 /* decCompare -- compare two decNumbers by numerical value */
6131 /* */
6132 /* This routine compares A ? B without altering them. */
6133 /* */
6134 /* Arg1 is A, a decNumber which is not a NaN */
6135 /* Arg2 is B, a decNumber which is not a NaN */
6136 /* Arg3 is 1 for a sign-independent compare, 0 otherwise */
6137 /* */
6138 /* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */
6139 /* (the only possible failure is an allocation error) */
6140 /* ------------------------------------------------------------------ */
6141 static Int decCompare(const decNumber *lhs, const decNumber *rhs,
6142 Flag abs) {
6143 Int result; /* result value */
6144 Int sigr; /* rhs signum */
6145 Int compare; /* work */
6146
6147 result=1; /* assume signum(lhs) */
6148 if (ISZERO(lhs)) result=0;
6149 if (abs) {
6150 if (ISZERO(rhs)) return result; /* LHS wins or both 0 */
6151 /* RHS is non-zero */
6152 if (result==0) return -1; /* LHS is 0; RHS wins */
6153 /* [here, both non-zero, result=1] */
6154 }
6155 else { /* signs matter */
6156 if (result && decNumberIsNegative(lhs)) result=-1;
6157 sigr=1; /* compute signum(rhs) */
6158 if (ISZERO(rhs)) sigr=0;
6159 else if (decNumberIsNegative(rhs)) sigr=-1;
6160 if (result > sigr) return +1; /* L > R, return 1 */
6161 if (result < sigr) return -1; /* L < R, return -1 */
6162 if (result==0) return 0; /* both 0 */
6163 }
6164
6165 /* signums are the same; both are non-zero */
6166 if ((lhs->bits | rhs->bits) & DECINF) { /* one or more infinities */
6167 if (decNumberIsInfinite(rhs)) {
6168 if (decNumberIsInfinite(lhs)) result=0;/* both infinite */
6169 else result=-result; /* only rhs infinite */
6170 }
6171 return result;
6172 }
6173 /* must compare the coefficients, allowing for exponents */
6174 if (lhs->exponent>rhs->exponent) { /* LHS exponent larger */
6175 /* swap sides, and sign */
6176 const decNumber *temp=lhs;
6177 lhs=rhs;
6178 rhs=temp;
6179 result=-result;
6180 }
6181 compare=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6182 rhs->lsu, D2U(rhs->digits),
6183 rhs->exponent-lhs->exponent);
6184 if (compare!=BADINT) compare*=result; /* comparison succeeded */
6185 return compare;
6186 } /* decCompare */
6187
6188 /* ------------------------------------------------------------------ */
6189 /* decUnitCompare -- compare two >=0 integers in Unit arrays */
6190 /* */
6191 /* This routine compares A ? B*10**E where A and B are unit arrays */
6192 /* A is a plain integer */
6193 /* B has an exponent of E (which must be non-negative) */
6194 /* */
6195 /* Arg1 is A first Unit (lsu) */
6196 /* Arg2 is A length in Units */
6197 /* Arg3 is B first Unit (lsu) */
6198 /* Arg4 is B length in Units */
6199 /* Arg5 is E (0 if the units are aligned) */
6200 /* */
6201 /* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */
6202 /* (the only possible failure is an allocation error, which can */
6203 /* only occur if E!=0) */
6204 /* ------------------------------------------------------------------ */
6205 static Int decUnitCompare(const Unit *a, Int alength,
6206 const Unit *b, Int blength, Int exp) {
6207 Unit *acc; /* accumulator for result */
6208 Unit accbuff[SD2U(DECBUFFER*2+1)]; /* local buffer */
6209 Unit *allocacc=NULL; /* -> allocated acc buffer, iff allocated */
6210 Int accunits, need; /* units in use or needed for acc */
6211 const Unit *l, *r, *u; /* work */
6212 Int expunits, exprem, result; /* .. */
6213
6214 if (exp==0) { /* aligned; fastpath */
6215 if (alength>blength) return 1;
6216 if (alength<blength) return -1;
6217 /* same number of units in both -- need unit-by-unit compare */
6218 l=a+alength-1;
6219 r=b+alength-1;
6220 for (;l>=a; l--, r--) {
6221 if (*l>*r) return 1;
6222 if (*l<*r) return -1;
6223 }
6224 return 0; /* all units match */
6225 } /* aligned */
6226
6227 /* Unaligned. If one is >1 unit longer than the other, padded */
6228 /* approximately, then can return easily */
6229 if (alength>blength+(Int)D2U(exp)) return 1;
6230 if (alength+1<blength+(Int)D2U(exp)) return -1;
6231
6232 /* Need to do a real subtract. For this, a result buffer is needed */
6233 /* even though only the sign is of interest. Its length needs */
6234 /* to be the larger of alength and padded blength, +2 */
6235 need=blength+D2U(exp); /* maximum real length of B */
6236 if (need<alength) need=alength;
6237 need+=2;
6238 acc=accbuff; /* assume use local buffer */
6239 if (need*sizeof(Unit)>sizeof(accbuff)) {
6240 allocacc=(Unit *)malloc(need*sizeof(Unit));
6241 if (allocacc==NULL) return BADINT; /* hopeless -- abandon */
6242 acc=allocacc;
6243 }
6244 /* Calculate units and remainder from exponent. */
6245 expunits=exp/DECDPUN;
6246 exprem=exp%DECDPUN;
6247 /* subtract [A+B*(-m)] */
6248 accunits=decUnitAddSub(a, alength, b, blength, expunits, acc,
6249 -(Int)powers[exprem]);
6250 /* [UnitAddSub result may have leading zeros, even on zero] */
6251 if (accunits<0) result=-1; /* negative result */
6252 else { /* non-negative result */
6253 /* check units of the result before freeing any storage */
6254 for (u=acc; u<acc+accunits-1 && *u==0;) u++;
6255 result=(*u==0 ? 0 : +1);
6256 }
6257 /* clean up and return the result */
6258 if (allocacc!=NULL) free(allocacc); /* drop any storage used */
6259 return result;
6260 } /* decUnitCompare */
6261
6262 /* ------------------------------------------------------------------ */
6263 /* decUnitAddSub -- add or subtract two >=0 integers in Unit arrays */
6264 /* */
6265 /* This routine performs the calculation: */
6266 /* */
6267 /* C=A+(B*M) */
6268 /* */
6269 /* Where M is in the range -DECDPUNMAX through +DECDPUNMAX. */
6270 /* */
6271 /* A may be shorter or longer than B. */
6272 /* */
6273 /* Leading zeros are not removed after a calculation. The result is */
6274 /* either the same length as the longer of A and B (adding any */
6275 /* shift), or one Unit longer than that (if a Unit carry occurred). */
6276 /* */
6277 /* A and B content are not altered unless C is also A or B. */
6278 /* C may be the same array as A or B, but only if no zero padding is */
6279 /* requested (that is, C may be B only if bshift==0). */
6280 /* C is filled from the lsu; only those units necessary to complete */
6281 /* the calculation are referenced. */
6282 /* */
6283 /* Arg1 is A first Unit (lsu) */
6284 /* Arg2 is A length in Units */
6285 /* Arg3 is B first Unit (lsu) */
6286 /* Arg4 is B length in Units */
6287 /* Arg5 is B shift in Units (>=0; pads with 0 units if positive) */
6288 /* Arg6 is C first Unit (lsu) */
6289 /* Arg7 is M, the multiplier */
6290 /* */
6291 /* returns the count of Units written to C, which will be non-zero */
6292 /* and negated if the result is negative. That is, the sign of the */
6293 /* returned Int is the sign of the result (positive for zero) and */
6294 /* the absolute value of the Int is the count of Units. */
6295 /* */
6296 /* It is the caller's responsibility to make sure that C size is */
6297 /* safe, allowing space if necessary for a one-Unit carry. */
6298 /* */
6299 /* This routine is severely performance-critical; *any* change here */
6300 /* must be measured (timed) to assure no performance degradation. */
6301 /* In particular, trickery here tends to be counter-productive, as */
6302 /* increased complexity of code hurts register optimizations on */
6303 /* register-poor architectures. Avoiding divisions is nearly */
6304 /* always a Good Idea, however. */
6305 /* */
6306 /* Special thanks to Rick McGuire (IBM Cambridge, MA) and Dave Clark */
6307 /* (IBM Warwick, UK) for some of the ideas used in this routine. */
6308 /* ------------------------------------------------------------------ */
6309 static Int decUnitAddSub(const Unit *a, Int alength,
6310 const Unit *b, Int blength, Int bshift,
6311 Unit *c, Int m) {
6312 const Unit *alsu=a; /* A lsu [need to remember it] */
6313 Unit *clsu=c; /* C ditto */
6314 Unit *minC; /* low water mark for C */
6315 Unit *maxC; /* high water mark for C */
6316 eInt carry=0; /* carry integer (could be Long) */
6317 Int add; /* work */
6318 #if DECDPUN<=4 /* myriadal, millenary, etc. */
6319 Int est; /* estimated quotient */
6320 #endif
6321
6322 #if DECTRACE
6323 if (alength<1 || blength<1)
6324 printf("decUnitAddSub: alen blen m %ld %ld [%ld]\n", alength, blength, m);
6325 #endif
6326
6327 maxC=c+alength; /* A is usually the longer */
6328 minC=c+blength; /* .. and B the shorter */
6329 if (bshift!=0) { /* B is shifted; low As copy across */
6330 minC+=bshift;
6331 /* if in place [common], skip copy unless there's a gap [rare] */
6332 if (a==c && bshift<=alength) {
6333 c+=bshift;
6334 a+=bshift;
6335 }
6336 else for (; c<clsu+bshift; a++, c++) { /* copy needed */
6337 if (a<alsu+alength) *c=*a;
6338 else *c=0;
6339 }
6340 }
6341 if (minC>maxC) { /* swap */
6342 Unit *hold=minC;
6343 minC=maxC;
6344 maxC=hold;
6345 }
6346
6347 /* For speed, do the addition as two loops; the first where both A */
6348 /* and B contribute, and the second (if necessary) where only one or */
6349 /* other of the numbers contribute. */
6350 /* Carry handling is the same (i.e., duplicated) in each case. */
6351 for (; c<minC; c++) {
6352 carry+=*a;
6353 a++;
6354 carry+=((eInt)*b)*m; /* [special-casing m=1/-1 */
6355 b++; /* here is not a win] */
6356 /* here carry is new Unit of digits; it could be +ve or -ve */
6357 if ((ueInt)carry<=DECDPUNMAX) { /* fastpath 0-DECDPUNMAX */
6358 *c=(Unit)carry;
6359 carry=0;
6360 continue;
6361 }
6362 #if DECDPUN==4 /* use divide-by-multiply */
6363 if (carry>=0) {
6364 est=(((ueInt)carry>>11)*53687)>>18;
6365 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6366 carry=est; /* likely quotient [89%] */
6367 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */
6368 carry++;
6369 *c-=DECDPUNMAX+1;
6370 continue;
6371 }
6372 /* negative case */
6373 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6374 est=(((ueInt)carry>>11)*53687)>>18;
6375 *c=(Unit)(carry-est*(DECDPUNMAX+1));
6376 carry=est-(DECDPUNMAX+1); /* correctly negative */
6377 if (*c<DECDPUNMAX+1) continue; /* was OK */
6378 carry++;
6379 *c-=DECDPUNMAX+1;
6380 #elif DECDPUN==3
6381 if (carry>=0) {
6382 est=(((ueInt)carry>>3)*16777)>>21;
6383 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6384 carry=est; /* likely quotient [99%] */
6385 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */
6386 carry++;
6387 *c-=DECDPUNMAX+1;
6388 continue;
6389 }
6390 /* negative case */
6391 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6392 est=(((ueInt)carry>>3)*16777)>>21;
6393 *c=(Unit)(carry-est*(DECDPUNMAX+1));
6394 carry=est-(DECDPUNMAX+1); /* correctly negative */
6395 if (*c<DECDPUNMAX+1) continue; /* was OK */
6396 carry++;
6397 *c-=DECDPUNMAX+1;
6398 #elif DECDPUN<=2
6399 /* Can use QUOT10 as carry <= 4 digits */
6400 if (carry>=0) {
6401 est=QUOT10(carry, DECDPUN);
6402 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6403 carry=est; /* quotient */
6404 continue;
6405 }
6406 /* negative case */
6407 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6408 est=QUOT10(carry, DECDPUN);
6409 *c=(Unit)(carry-est*(DECDPUNMAX+1));
6410 carry=est-(DECDPUNMAX+1); /* correctly negative */
6411 #else
6412 /* remainder operator is undefined if negative, so must test */
6413 if ((ueInt)carry<(DECDPUNMAX+1)*2) { /* fastpath carry +1 */
6414 *c=(Unit)(carry-(DECDPUNMAX+1)); /* [helps additions] */
6415 carry=1;
6416 continue;
6417 }
6418 if (carry>=0) {
6419 *c=(Unit)(carry%(DECDPUNMAX+1));
6420 carry=carry/(DECDPUNMAX+1);
6421 continue;
6422 }
6423 /* negative case */
6424 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6425 *c=(Unit)(carry%(DECDPUNMAX+1));
6426 carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6427 #endif
6428 } /* c */
6429
6430 /* now may have one or other to complete */
6431 /* [pretest to avoid loop setup/shutdown] */
6432 if (c<maxC) for (; c<maxC; c++) {
6433 if (a<alsu+alength) { /* still in A */
6434 carry+=*a;
6435 a++;
6436 }
6437 else { /* inside B */
6438 carry+=((eInt)*b)*m;
6439 b++;
6440 }
6441 /* here carry is new Unit of digits; it could be +ve or -ve and */
6442 /* magnitude up to DECDPUNMAX squared */
6443 if ((ueInt)carry<=DECDPUNMAX) { /* fastpath 0-DECDPUNMAX */
6444 *c=(Unit)carry;
6445 carry=0;
6446 continue;
6447 }
6448 /* result for this unit is negative or >DECDPUNMAX */
6449 #if DECDPUN==4 /* use divide-by-multiply */
6450 if (carry>=0) {
6451 est=(((ueInt)carry>>11)*53687)>>18;
6452 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6453 carry=est; /* likely quotient [79.7%] */
6454 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */
6455 carry++;
6456 *c-=DECDPUNMAX+1;
6457 continue;
6458 }
6459 /* negative case */
6460 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6461 est=(((ueInt)carry>>11)*53687)>>18;
6462 *c=(Unit)(carry-est*(DECDPUNMAX+1));
6463 carry=est-(DECDPUNMAX+1); /* correctly negative */
6464 if (*c<DECDPUNMAX+1) continue; /* was OK */
6465 carry++;
6466 *c-=DECDPUNMAX+1;
6467 #elif DECDPUN==3
6468 if (carry>=0) {
6469 est=(((ueInt)carry>>3)*16777)>>21;
6470 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6471 carry=est; /* likely quotient [99%] */
6472 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */
6473 carry++;
6474 *c-=DECDPUNMAX+1;
6475 continue;
6476 }
6477 /* negative case */
6478 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6479 est=(((ueInt)carry>>3)*16777)>>21;
6480 *c=(Unit)(carry-est*(DECDPUNMAX+1));
6481 carry=est-(DECDPUNMAX+1); /* correctly negative */
6482 if (*c<DECDPUNMAX+1) continue; /* was OK */
6483 carry++;
6484 *c-=DECDPUNMAX+1;
6485 #elif DECDPUN<=2
6486 if (carry>=0) {
6487 est=QUOT10(carry, DECDPUN);
6488 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6489 carry=est; /* quotient */
6490 continue;
6491 }
6492 /* negative case */
6493 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6494 est=QUOT10(carry, DECDPUN);
6495 *c=(Unit)(carry-est*(DECDPUNMAX+1));
6496 carry=est-(DECDPUNMAX+1); /* correctly negative */
6497 #else
6498 if ((ueInt)carry<(DECDPUNMAX+1)*2){ /* fastpath carry 1 */
6499 *c=(Unit)(carry-(DECDPUNMAX+1));
6500 carry=1;
6501 continue;
6502 }
6503 /* remainder operator is undefined if negative, so must test */
6504 if (carry>=0) {
6505 *c=(Unit)(carry%(DECDPUNMAX+1));
6506 carry=carry/(DECDPUNMAX+1);
6507 continue;
6508 }
6509 /* negative case */
6510 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6511 *c=(Unit)(carry%(DECDPUNMAX+1));
6512 carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6513 #endif
6514 } /* c */
6515
6516 /* OK, all A and B processed; might still have carry or borrow */
6517 /* return number of Units in the result, negated if a borrow */
6518 if (carry==0) return c-clsu; /* no carry, so no more to do */
6519 if (carry>0) { /* positive carry */
6520 *c=(Unit)carry; /* place as new unit */
6521 c++; /* .. */
6522 return c-clsu;
6523 }
6524 /* -ve carry: it's a borrow; complement needed */
6525 add=1; /* temporary carry... */
6526 for (c=clsu; c<maxC; c++) {
6527 add=DECDPUNMAX+add-*c;
6528 if (add<=DECDPUNMAX) {
6529 *c=(Unit)add;
6530 add=0;
6531 }
6532 else {
6533 *c=0;
6534 add=1;
6535 }
6536 }
6537 /* add an extra unit iff it would be non-zero */
6538 #if DECTRACE
6539 printf("UAS borrow: add %ld, carry %ld\n", add, carry);
6540 #endif
6541 if ((add-carry-1)!=0) {
6542 *c=(Unit)(add-carry-1);
6543 c++; /* interesting, include it */
6544 }
6545 return clsu-c; /* -ve result indicates borrowed */
6546 } /* decUnitAddSub */
6547
6548 /* ------------------------------------------------------------------ */
6549 /* decTrim -- trim trailing zeros or normalize */
6550 /* */
6551 /* dn is the number to trim or normalize */
6552 /* set is the context to use to check for clamp */
6553 /* all is 1 to remove all trailing zeros, 0 for just fraction ones */
6554 /* dropped returns the number of discarded trailing zeros */
6555 /* returns dn */
6556 /* */
6557 /* If clamp is set in the context then the number of zeros trimmed */
6558 /* may be limited if the exponent is high. */
6559 /* All fields are updated as required. This is a utility operation, */
6560 /* so special values are unchanged and no error is possible. */
6561 /* ------------------------------------------------------------------ */
6562 static decNumber * decTrim(decNumber *dn, decContext *set, Flag all,
6563 Int *dropped) {
6564 Int d, exp; /* work */
6565 uInt cut; /* .. */
6566 Unit *up; /* -> current Unit */
6567
6568 #if DECCHECK
6569 if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
6570 #endif
6571
6572 *dropped=0; /* assume no zeros dropped */
6573 if ((dn->bits & DECSPECIAL) /* fast exit if special .. */
6574 || (*dn->lsu & 0x01)) return dn; /* .. or odd */
6575 if (ISZERO(dn)) { /* .. or 0 */
6576 dn->exponent=0; /* (sign is preserved) */
6577 return dn;
6578 }
6579
6580 /* have a finite number which is even */
6581 exp=dn->exponent;
6582 cut=1; /* digit (1-DECDPUN) in Unit */
6583 up=dn->lsu; /* -> current Unit */
6584 for (d=0; d<dn->digits-1; d++) { /* [don't strip the final digit] */
6585 /* slice by powers */
6586 #if DECDPUN<=4
6587 uInt quot=QUOT10(*up, cut);
6588 if ((*up-quot*powers[cut])!=0) break; /* found non-0 digit */
6589 #else
6590 if (*up%powers[cut]!=0) break; /* found non-0 digit */
6591 #endif
6592 /* have a trailing 0 */
6593 if (!all) { /* trimming */
6594 /* [if exp>0 then all trailing 0s are significant for trim] */
6595 if (exp<=0) { /* if digit might be significant */
6596 if (exp==0) break; /* then quit */
6597 exp++; /* next digit might be significant */
6598 }
6599 }
6600 cut++; /* next power */
6601 if (cut>DECDPUN) { /* need new Unit */
6602 up++;
6603 cut=1;
6604 }
6605 } /* d */
6606 if (d==0) return dn; /* none to drop */
6607
6608 /* may need to limit drop if clamping */
6609 if (set->clamp) {
6610 Int maxd=set->emax-set->digits+1-dn->exponent;
6611 if (maxd<=0) return dn; /* nothing possible */
6612 if (d>maxd) d=maxd;
6613 }
6614
6615 /* effect the drop */
6616 decShiftToLeast(dn->lsu, D2U(dn->digits), d);
6617 dn->exponent+=d; /* maintain numerical value */
6618 dn->digits-=d; /* new length */
6619 *dropped=d; /* report the count */
6620 return dn;
6621 } /* decTrim */
6622
6623 /* ------------------------------------------------------------------ */
6624 /* decReverse -- reverse a Unit array in place */
6625 /* */
6626 /* ulo is the start of the array */
6627 /* uhi is the end of the array (highest Unit to include) */
6628 /* */
6629 /* The units ulo through uhi are reversed in place (if the number */
6630 /* of units is odd, the middle one is untouched). Note that the */
6631 /* digit(s) in each unit are unaffected. */
6632 /* ------------------------------------------------------------------ */
6633 static void decReverse(Unit *ulo, Unit *uhi) {
6634 Unit temp;
6635 for (; ulo<uhi; ulo++, uhi--) {
6636 temp=*ulo;
6637 *ulo=*uhi;
6638 *uhi=temp;
6639 }
6640 return;
6641 } /* decReverse */
6642
6643 /* ------------------------------------------------------------------ */
6644 /* decShiftToMost -- shift digits in array towards most significant */
6645 /* */
6646 /* uar is the array */
6647 /* digits is the count of digits in use in the array */
6648 /* shift is the number of zeros to pad with (least significant); */
6649 /* it must be zero or positive */
6650 /* */
6651 /* returns the new length of the integer in the array, in digits */
6652 /* */
6653 /* No overflow is permitted (that is, the uar array must be known to */
6654 /* be large enough to hold the result, after shifting). */
6655 /* ------------------------------------------------------------------ */
6656 static Int decShiftToMost(Unit *uar, Int digits, Int shift) {
6657 Unit *target, *source, *first; /* work */
6658 Int cut; /* odd 0's to add */
6659 uInt next; /* work */
6660
6661 if (shift==0) return digits; /* [fastpath] nothing to do */
6662 if ((digits+shift)<=DECDPUN) { /* [fastpath] single-unit case */
6663 *uar=(Unit)(*uar*powers[shift]);
6664 return digits+shift;
6665 }
6666
6667 next=0; /* all paths */
6668 source=uar+D2U(digits)-1; /* where msu comes from */
6669 target=source+D2U(shift); /* where upper part of first cut goes */
6670 cut=DECDPUN-MSUDIGITS(shift); /* where to slice */
6671 if (cut==0) { /* unit-boundary case */
6672 for (; source>=uar; source--, target--) *target=*source;
6673 }
6674 else {
6675 first=uar+D2U(digits+shift)-1; /* where msu of source will end up */
6676 for (; source>=uar; source--, target--) {
6677 /* split the source Unit and accumulate remainder for next */
6678 #if DECDPUN<=4
6679 uInt quot=QUOT10(*source, cut);
6680 uInt rem=*source-quot*powers[cut];
6681 next+=quot;
6682 #else
6683 uInt rem=*source%powers[cut];
6684 next+=*source/powers[cut];
6685 #endif
6686 if (target<=first) *target=(Unit)next; /* write to target iff valid */
6687 next=rem*powers[DECDPUN-cut]; /* save remainder for next Unit */
6688 }
6689 } /* shift-move */
6690
6691 /* propagate any partial unit to one below and clear the rest */
6692 for (; target>=uar; target--) {
6693 *target=(Unit)next;
6694 next=0;
6695 }
6696 return digits+shift;
6697 } /* decShiftToMost */
6698
6699 /* ------------------------------------------------------------------ */
6700 /* decShiftToLeast -- shift digits in array towards least significant */
6701 /* */
6702 /* uar is the array */
6703 /* units is length of the array, in units */
6704 /* shift is the number of digits to remove from the lsu end; it */
6705 /* must be zero or positive and <= than units*DECDPUN. */
6706 /* */
6707 /* returns the new length of the integer in the array, in units */
6708 /* */
6709 /* Removed digits are discarded (lost). Units not required to hold */
6710 /* the final result are unchanged. */
6711 /* ------------------------------------------------------------------ */
6712 static Int decShiftToLeast(Unit *uar, Int units, Int shift) {
6713 Unit *target, *up; /* work */
6714 Int cut, count; /* work */
6715 Int quot, rem; /* for division */
6716
6717 if (shift==0) return units; /* [fastpath] nothing to do */
6718 if (shift==units*DECDPUN) { /* [fastpath] little to do */
6719 *uar=0; /* all digits cleared gives zero */
6720 return 1; /* leaves just the one */
6721 }
6722
6723 target=uar; /* both paths */
6724 cut=MSUDIGITS(shift);
6725 if (cut==DECDPUN) { /* unit-boundary case; easy */
6726 up=uar+D2U(shift);
6727 for (; up<uar+units; target++, up++) *target=*up;
6728 return target-uar;
6729 }
6730
6731 /* messier */
6732 up=uar+D2U(shift-cut); /* source; correct to whole Units */
6733 count=units*DECDPUN-shift; /* the maximum new length */
6734 #if DECDPUN<=4
6735 quot=QUOT10(*up, cut);
6736 #else
6737 quot=*up/powers[cut];
6738 #endif
6739 for (; ; target++) {
6740 *target=(Unit)quot;
6741 count-=(DECDPUN-cut);
6742 if (count<=0) break;
6743 up++;
6744 quot=*up;
6745 #if DECDPUN<=4
6746 quot=QUOT10(quot, cut);
6747 rem=*up-quot*powers[cut];
6748 #else
6749 rem=quot%powers[cut];
6750 quot=quot/powers[cut];
6751 #endif
6752 *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
6753 count-=cut;
6754 if (count<=0) break;
6755 }
6756 return target-uar+1;
6757 } /* decShiftToLeast */
6758
6759 #if DECSUBSET
6760 /* ------------------------------------------------------------------ */
6761 /* decRoundOperand -- round an operand [used for subset only] */
6762 /* */
6763 /* dn is the number to round (dn->digits is > set->digits) */
6764 /* set is the relevant context */
6765 /* status is the status accumulator */
6766 /* */
6767 /* returns an allocated decNumber with the rounded result. */
6768 /* */
6769 /* lostDigits and other status may be set by this. */
6770 /* */
6771 /* Since the input is an operand, it must not be modified. */
6772 /* Instead, return an allocated decNumber, rounded as required. */
6773 /* It is the caller's responsibility to free the allocated storage. */
6774 /* */
6775 /* If no storage is available then the result cannot be used, so NULL */
6776 /* is returned. */
6777 /* ------------------------------------------------------------------ */
6778 static decNumber *decRoundOperand(const decNumber *dn, decContext *set,
6779 uInt *status) {
6780 decNumber *res; /* result structure */
6781 uInt newstatus=0; /* status from round */
6782 Int residue=0; /* rounding accumulator */
6783
6784 /* Allocate storage for the returned decNumber, big enough for the */
6785 /* length specified by the context */
6786 res=(decNumber *)malloc(sizeof(decNumber)
6787 +(D2U(set->digits)-1)*sizeof(Unit));
6788 if (res==NULL) {
6789 *status|=DEC_Insufficient_storage;
6790 return NULL;
6791 }
6792 decCopyFit(res, dn, set, &residue, &newstatus);
6793 decApplyRound(res, set, residue, &newstatus);
6794
6795 /* If that set Inexact then "lost digits" is raised... */
6796 if (newstatus & DEC_Inexact) newstatus|=DEC_Lost_digits;
6797 *status|=newstatus;
6798 return res;
6799 } /* decRoundOperand */
6800 #endif
6801
6802 /* ------------------------------------------------------------------ */
6803 /* decCopyFit -- copy a number, truncating the coefficient if needed */
6804 /* */
6805 /* dest is the target decNumber */
6806 /* src is the source decNumber */
6807 /* set is the context [used for length (digits) and rounding mode] */
6808 /* residue is the residue accumulator */
6809 /* status contains the current status to be updated */
6810 /* */
6811 /* (dest==src is allowed and will be a no-op if fits) */
6812 /* All fields are updated as required. */
6813 /* ------------------------------------------------------------------ */
6814 static void decCopyFit(decNumber *dest, const decNumber *src,
6815 decContext *set, Int *residue, uInt *status) {
6816 dest->bits=src->bits;
6817 dest->exponent=src->exponent;
6818 decSetCoeff(dest, set, src->lsu, src->digits, residue, status);
6819 } /* decCopyFit */
6820
6821 /* ------------------------------------------------------------------ */
6822 /* decSetCoeff -- set the coefficient of a number */
6823 /* */
6824 /* dn is the number whose coefficient array is to be set. */
6825 /* It must have space for set->digits digits */
6826 /* set is the context [for size] */
6827 /* lsu -> lsu of the source coefficient [may be dn->lsu] */
6828 /* len is digits in the source coefficient [may be dn->digits] */
6829 /* residue is the residue accumulator. This has values as in */
6830 /* decApplyRound, and will be unchanged unless the */
6831 /* target size is less than len. In this case, the */
6832 /* coefficient is truncated and the residue is updated to */
6833 /* reflect the previous residue and the dropped digits. */
6834 /* status is the status accumulator, as usual */
6835 /* */
6836 /* The coefficient may already be in the number, or it can be an */
6837 /* external intermediate array. If it is in the number, lsu must == */
6838 /* dn->lsu and len must == dn->digits. */
6839 /* */
6840 /* Note that the coefficient length (len) may be < set->digits, and */
6841 /* in this case this merely copies the coefficient (or is a no-op */
6842 /* if dn->lsu==lsu). */
6843 /* */
6844 /* Note also that (only internally, from decQuantizeOp and */
6845 /* decSetSubnormal) the value of set->digits may be less than one, */
6846 /* indicating a round to left. This routine handles that case */
6847 /* correctly; caller ensures space. */
6848 /* */
6849 /* dn->digits, dn->lsu (and as required), and dn->exponent are */
6850 /* updated as necessary. dn->bits (sign) is unchanged. */
6851 /* */
6852 /* DEC_Rounded status is set if any digits are discarded. */
6853 /* DEC_Inexact status is set if any non-zero digits are discarded, or */
6854 /* incoming residue was non-0 (implies rounded) */
6855 /* ------------------------------------------------------------------ */
6856 /* mapping array: maps 0-9 to canonical residues, so that a residue */
6857 /* can be adjusted in the range [-1, +1] and achieve correct rounding */
6858 /* 0 1 2 3 4 5 6 7 8 9 */
6859 static const uByte resmap[10]={0, 3, 3, 3, 3, 5, 7, 7, 7, 7};
6860 static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu,
6861 Int len, Int *residue, uInt *status) {
6862 Int discard; /* number of digits to discard */
6863 uInt cut; /* cut point in Unit */
6864 const Unit *up; /* work */
6865 Unit *target; /* .. */
6866 Int count; /* .. */
6867 #if DECDPUN<=4
6868 uInt temp; /* .. */
6869 #endif
6870
6871 discard=len-set->digits; /* digits to discard */
6872 if (discard<=0) { /* no digits are being discarded */
6873 if (dn->lsu!=lsu) { /* copy needed */
6874 /* copy the coefficient array to the result number; no shift needed */
6875 count=len; /* avoids D2U */
6876 up=lsu;
6877 for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
6878 *target=*up;
6879 dn->digits=len; /* set the new length */
6880 }
6881 /* dn->exponent and residue are unchanged, record any inexactitude */
6882 if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded);
6883 return;
6884 }
6885
6886 /* some digits must be discarded ... */
6887 dn->exponent+=discard; /* maintain numerical value */
6888 *status|=DEC_Rounded; /* accumulate Rounded status */
6889 if (*residue>1) *residue=1; /* previous residue now to right, so reduce */
6890
6891 if (discard>len) { /* everything, +1, is being discarded */
6892 /* guard digit is 0 */
6893 /* residue is all the number [NB could be all 0s] */
6894 if (*residue<=0) { /* not already positive */
6895 count=len; /* avoids D2U */
6896 for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { /* found non-0 */
6897 *residue=1;
6898 break; /* no need to check any others */
6899 }
6900 }
6901 if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
6902 *dn->lsu=0; /* coefficient will now be 0 */
6903 dn->digits=1; /* .. */
6904 return;
6905 } /* total discard */
6906
6907 /* partial discard [most common case] */
6908 /* here, at least the first (most significant) discarded digit exists */
6909
6910 /* spin up the number, noting residue during the spin, until get to */
6911 /* the Unit with the first discarded digit. When reach it, extract */
6912 /* it and remember its position */
6913 count=0;
6914 for (up=lsu;; up++) {
6915 count+=DECDPUN;
6916 if (count>=discard) break; /* full ones all checked */
6917 if (*up!=0) *residue=1;
6918 } /* up */
6919
6920 /* here up -> Unit with first discarded digit */
6921 cut=discard-(count-DECDPUN)-1;
6922 if (cut==DECDPUN-1) { /* unit-boundary case (fast) */
6923 Unit half=(Unit)powers[DECDPUN]>>1;
6924 /* set residue directly */
6925 if (*up>=half) {
6926 if (*up>half) *residue=7;
6927 else *residue+=5; /* add sticky bit */
6928 }
6929 else { /* <half */
6930 if (*up!=0) *residue=3; /* [else is 0, leave as sticky bit] */
6931 }
6932 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */
6933 *dn->lsu=0; /* .. result is 0 */
6934 dn->digits=1; /* .. */
6935 }
6936 else { /* shift to least */
6937 count=set->digits; /* now digits to end up with */
6938 dn->digits=count; /* set the new length */
6939 up++; /* move to next */
6940 /* on unit boundary, so shift-down copy loop is simple */
6941 for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
6942 *target=*up;
6943 }
6944 } /* unit-boundary case */
6945
6946 else { /* discard digit is in low digit(s), and not top digit */
6947 uInt discard1; /* first discarded digit */
6948 uInt quot, rem; /* for divisions */
6949 if (cut==0) quot=*up; /* is at bottom of unit */
6950 else /* cut>0 */ { /* it's not at bottom of unit */
6951 #if DECDPUN<=4
6952 quot=QUOT10(*up, cut);
6953 rem=*up-quot*powers[cut];
6954 #else
6955 rem=*up%powers[cut];
6956 quot=*up/powers[cut];
6957 #endif
6958 if (rem!=0) *residue=1;
6959 }
6960 /* discard digit is now at bottom of quot */
6961 #if DECDPUN<=4
6962 temp=(quot*6554)>>16; /* fast /10 */
6963 /* Vowels algorithm here not a win (9 instructions) */
6964 discard1=quot-X10(temp);
6965 quot=temp;
6966 #else
6967 discard1=quot%10;
6968 quot=quot/10;
6969 #endif
6970 /* here, discard1 is the guard digit, and residue is everything */
6971 /* else [use mapping array to accumulate residue safely] */
6972 *residue+=resmap[discard1];
6973 cut++; /* update cut */
6974 /* here: up -> Unit of the array with bottom digit */
6975 /* cut is the division point for each Unit */
6976 /* quot holds the uncut high-order digits for the current unit */
6977 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */
6978 *dn->lsu=0; /* .. result is 0 */
6979 dn->digits=1; /* .. */
6980 }
6981 else { /* shift to least needed */
6982 count=set->digits; /* now digits to end up with */
6983 dn->digits=count; /* set the new length */
6984 /* shift-copy the coefficient array to the result number */
6985 for (target=dn->lsu; ; target++) {
6986 *target=(Unit)quot;
6987 count-=(DECDPUN-cut);
6988 if (count<=0) break;
6989 up++;
6990 quot=*up;
6991 #if DECDPUN<=4
6992 quot=QUOT10(quot, cut);
6993 rem=*up-quot*powers[cut];
6994 #else
6995 rem=quot%powers[cut];
6996 quot=quot/powers[cut];
6997 #endif
6998 *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
6999 count-=cut;
7000 if (count<=0) break;
7001 } /* shift-copy loop */
7002 } /* shift to least */
7003 } /* not unit boundary */
7004
7005 if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
7006 return;
7007 } /* decSetCoeff */
7008
7009 /* ------------------------------------------------------------------ */
7010 /* decApplyRound -- apply pending rounding to a number */
7011 /* */
7012 /* dn is the number, with space for set->digits digits */
7013 /* set is the context [for size and rounding mode] */
7014 /* residue indicates pending rounding, being any accumulated */
7015 /* guard and sticky information. It may be: */
7016 /* 6-9: rounding digit is >5 */
7017 /* 5: rounding digit is exactly half-way */
7018 /* 1-4: rounding digit is <5 and >0 */
7019 /* 0: the coefficient is exact */
7020 /* -1: as 1, but the hidden digits are subtractive, that */
7021 /* is, of the opposite sign to dn. In this case the */
7022 /* coefficient must be non-0. This case occurs when */
7023 /* subtracting a small number (which can be reduced to */
7024 /* a sticky bit); see decAddOp. */
7025 /* status is the status accumulator, as usual */
7026 /* */
7027 /* This routine applies rounding while keeping the length of the */
7028 /* coefficient constant. The exponent and status are unchanged */
7029 /* except if: */
7030 /* */
7031 /* -- the coefficient was increased and is all nines (in which */
7032 /* case Overflow could occur, and is handled directly here so */
7033 /* the caller does not need to re-test for overflow) */
7034 /* */
7035 /* -- the coefficient was decreased and becomes all nines (in which */
7036 /* case Underflow could occur, and is also handled directly). */
7037 /* */
7038 /* All fields in dn are updated as required. */
7039 /* */
7040 /* ------------------------------------------------------------------ */
7041 static void decApplyRound(decNumber *dn, decContext *set, Int residue,
7042 uInt *status) {
7043 Int bump; /* 1 if coefficient needs to be incremented */
7044 /* -1 if coefficient needs to be decremented */
7045
7046 if (residue==0) return; /* nothing to apply */
7047
7048 bump=0; /* assume a smooth ride */
7049
7050 /* now decide whether, and how, to round, depending on mode */
7051 switch (set->round) {
7052 case DEC_ROUND_05UP: { /* round zero or five up (for reround) */
7053 /* This is the same as DEC_ROUND_DOWN unless there is a */
7054 /* positive residue and the lsd of dn is 0 or 5, in which case */
7055 /* it is bumped; when residue is <0, the number is therefore */
7056 /* bumped down unless the final digit was 1 or 6 (in which */
7057 /* case it is bumped down and then up -- a no-op) */
7058 Int lsd5=*dn->lsu%5; /* get lsd and quintate */
7059 if (residue<0 && lsd5!=1) bump=-1;
7060 else if (residue>0 && lsd5==0) bump=1;
7061 /* [bump==1 could be applied directly; use common path for clarity] */
7062 break;} /* r-05 */
7063
7064 case DEC_ROUND_DOWN: {
7065 /* no change, except if negative residue */
7066 if (residue<0) bump=-1;
7067 break;} /* r-d */
7068
7069 case DEC_ROUND_HALF_DOWN: {
7070 if (residue>5) bump=1;
7071 break;} /* r-h-d */
7072
7073 case DEC_ROUND_HALF_EVEN: {
7074 if (residue>5) bump=1; /* >0.5 goes up */
7075 else if (residue==5) { /* exactly 0.5000... */
7076 /* 0.5 goes up iff [new] lsd is odd */
7077 if (*dn->lsu & 0x01) bump=1;
7078 }
7079 break;} /* r-h-e */
7080
7081 case DEC_ROUND_HALF_UP: {
7082 if (residue>=5) bump=1;
7083 break;} /* r-h-u */
7084
7085 case DEC_ROUND_UP: {
7086 if (residue>0) bump=1;
7087 break;} /* r-u */
7088
7089 case DEC_ROUND_CEILING: {
7090 /* same as _UP for positive numbers, and as _DOWN for negatives */
7091 /* [negative residue cannot occur on 0] */
7092 if (decNumberIsNegative(dn)) {
7093 if (residue<0) bump=-1;
7094 }
7095 else {
7096 if (residue>0) bump=1;
7097 }
7098 break;} /* r-c */
7099
7100 case DEC_ROUND_FLOOR: {
7101 /* same as _UP for negative numbers, and as _DOWN for positive */
7102 /* [negative residue cannot occur on 0] */
7103 if (!decNumberIsNegative(dn)) {
7104 if (residue<0) bump=-1;
7105 }
7106 else {
7107 if (residue>0) bump=1;
7108 }
7109 break;} /* r-f */
7110
7111 default: { /* e.g., DEC_ROUND_MAX */
7112 *status|=DEC_Invalid_context;
7113 #if DECTRACE || (DECCHECK && DECVERB)
7114 printf("Unknown rounding mode: %d\n", set->round);
7115 #endif
7116 break;}
7117 } /* switch */
7118
7119 /* now bump the number, up or down, if need be */
7120 if (bump==0) return; /* no action required */
7121
7122 /* Simply use decUnitAddSub unless bumping up and the number is */
7123 /* all nines. In this special case set to 100... explicitly */
7124 /* and adjust the exponent by one (as otherwise could overflow */
7125 /* the array) */
7126 /* Similarly handle all-nines result if bumping down. */
7127 if (bump>0) {
7128 Unit *up; /* work */
7129 uInt count=dn->digits; /* digits to be checked */
7130 for (up=dn->lsu; ; up++) {
7131 if (count<=DECDPUN) {
7132 /* this is the last Unit (the msu) */
7133 if (*up!=powers[count]-1) break; /* not still 9s */
7134 /* here if it, too, is all nines */
7135 *up=(Unit)powers[count-1]; /* here 999 -> 100 etc. */
7136 for (up=up-1; up>=dn->lsu; up--) *up=0; /* others all to 0 */
7137 dn->exponent++; /* and bump exponent */
7138 /* [which, very rarely, could cause Overflow...] */
7139 if ((dn->exponent+dn->digits)>set->emax+1) {
7140 decSetOverflow(dn, set, status);
7141 }
7142 return; /* done */
7143 }
7144 /* a full unit to check, with more to come */
7145 if (*up!=DECDPUNMAX) break; /* not still 9s */
7146 count-=DECDPUN;
7147 } /* up */
7148 } /* bump>0 */
7149 else { /* -1 */
7150 /* here checking for a pre-bump of 1000... (leading 1, all */
7151 /* other digits zero) */
7152 Unit *up, *sup; /* work */
7153 uInt count=dn->digits; /* digits to be checked */
7154 for (up=dn->lsu; ; up++) {
7155 if (count<=DECDPUN) {
7156 /* this is the last Unit (the msu) */
7157 if (*up!=powers[count-1]) break; /* not 100.. */
7158 /* here if have the 1000... case */
7159 sup=up; /* save msu pointer */
7160 *up=(Unit)powers[count]-1; /* here 100 in msu -> 999 */
7161 /* others all to all-nines, too */
7162 for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1;
7163 dn->exponent--; /* and bump exponent */
7164
7165 /* iff the number was at the subnormal boundary (exponent=etiny) */
7166 /* then the exponent is now out of range, so it will in fact get */
7167 /* clamped to etiny and the final 9 dropped. */
7168 /* printf(">> emin=%d exp=%d sdig=%d\n", set->emin, */
7169 /* dn->exponent, set->digits); */
7170 if (dn->exponent+1==set->emin-set->digits+1) {
7171 if (count==1 && dn->digits==1) *sup=0; /* here 9 -> 0[.9] */
7172 else {
7173 *sup=(Unit)powers[count-1]-1; /* here 999.. in msu -> 99.. */
7174 dn->digits--;
7175 }
7176 dn->exponent++;
7177 *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7178 }
7179 return; /* done */
7180 }
7181
7182 /* a full unit to check, with more to come */
7183 if (*up!=0) break; /* not still 0s */
7184 count-=DECDPUN;
7185 } /* up */
7186
7187 } /* bump<0 */
7188
7189 /* Actual bump needed. Do it. */
7190 decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump);
7191 } /* decApplyRound */
7192
7193 #if DECSUBSET
7194 /* ------------------------------------------------------------------ */
7195 /* decFinish -- finish processing a number */
7196 /* */
7197 /* dn is the number */
7198 /* set is the context */
7199 /* residue is the rounding accumulator (as in decApplyRound) */
7200 /* status is the accumulator */
7201 /* */
7202 /* This finishes off the current number by: */
7203 /* 1. If not extended: */
7204 /* a. Converting a zero result to clean '0' */
7205 /* b. Reducing positive exponents to 0, if would fit in digits */
7206 /* 2. Checking for overflow and subnormals (always) */
7207 /* Note this is just Finalize when no subset arithmetic. */
7208 /* All fields are updated as required. */
7209 /* ------------------------------------------------------------------ */
7210 static void decFinish(decNumber *dn, decContext *set, Int *residue,
7211 uInt *status) {
7212 if (!set->extended) {
7213 if ISZERO(dn) { /* value is zero */
7214 dn->exponent=0; /* clean exponent .. */
7215 dn->bits=0; /* .. and sign */
7216 return; /* no error possible */
7217 }
7218 if (dn->exponent>=0) { /* non-negative exponent */
7219 /* >0; reduce to integer if possible */
7220 if (set->digits >= (dn->exponent+dn->digits)) {
7221 dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent);
7222 dn->exponent=0;
7223 }
7224 }
7225 } /* !extended */
7226
7227 decFinalize(dn, set, residue, status);
7228 } /* decFinish */
7229 #endif
7230
7231 /* ------------------------------------------------------------------ */
7232 /* decFinalize -- final check, clamp, and round of a number */
7233 /* */
7234 /* dn is the number */
7235 /* set is the context */
7236 /* residue is the rounding accumulator (as in decApplyRound) */
7237 /* status is the status accumulator */
7238 /* */
7239 /* This finishes off the current number by checking for subnormal */
7240 /* results, applying any pending rounding, checking for overflow, */
7241 /* and applying any clamping. */
7242 /* Underflow and overflow conditions are raised as appropriate. */
7243 /* All fields are updated as required. */
7244 /* ------------------------------------------------------------------ */
7245 static void decFinalize(decNumber *dn, decContext *set, Int *residue,
7246 uInt *status) {
7247 Int shift; /* shift needed if clamping */
7248 Int tinyexp=set->emin-dn->digits+1; /* precalculate subnormal boundary */
7249
7250 /* Must be careful, here, when checking the exponent as the */
7251 /* adjusted exponent could overflow 31 bits [because it may already */
7252 /* be up to twice the expected]. */
7253
7254 /* First test for subnormal. This must be done before any final */
7255 /* round as the result could be rounded to Nmin or 0. */
7256 if (dn->exponent<=tinyexp) { /* prefilter */
7257 Int comp;
7258 decNumber nmin;
7259 /* A very nasty case here is dn == Nmin and residue<0 */
7260 if (dn->exponent<tinyexp) {
7261 /* Go handle subnormals; this will apply round if needed. */
7262 decSetSubnormal(dn, set, residue, status);
7263 return;
7264 }
7265 /* Equals case: only subnormal if dn=Nmin and negative residue */
7266 decNumberZero(&nmin);
7267 nmin.lsu[0]=1;
7268 nmin.exponent=set->emin;
7269 comp=decCompare(dn, &nmin, 1); /* (signless compare) */
7270 if (comp==BADINT) { /* oops */
7271 *status|=DEC_Insufficient_storage; /* abandon... */
7272 return;
7273 }
7274 if (*residue<0 && comp==0) { /* neg residue and dn==Nmin */
7275 decApplyRound(dn, set, *residue, status); /* might force down */
7276 decSetSubnormal(dn, set, residue, status);
7277 return;
7278 }
7279 }
7280
7281 /* now apply any pending round (this could raise overflow). */
7282 if (*residue!=0) decApplyRound(dn, set, *residue, status);
7283
7284 /* Check for overflow [redundant in the 'rare' case] or clamp */
7285 if (dn->exponent<=set->emax-set->digits+1) return; /* neither needed */
7286
7287
7288 /* here when might have an overflow or clamp to do */
7289 if (dn->exponent>set->emax-dn->digits+1) { /* too big */
7290 decSetOverflow(dn, set, status);
7291 return;
7292 }
7293 /* here when the result is normal but in clamp range */
7294 if (!set->clamp) return;
7295
7296 /* here when need to apply the IEEE exponent clamp (fold-down) */
7297 shift=dn->exponent-(set->emax-set->digits+1);
7298
7299 /* shift coefficient (if non-zero) */
7300 if (!ISZERO(dn)) {
7301 dn->digits=decShiftToMost(dn->lsu, dn->digits, shift);
7302 }
7303 dn->exponent-=shift; /* adjust the exponent to match */
7304 *status|=DEC_Clamped; /* and record the dirty deed */
7305 return;
7306 } /* decFinalize */
7307
7308 /* ------------------------------------------------------------------ */
7309 /* decSetOverflow -- set number to proper overflow value */
7310 /* */
7311 /* dn is the number (used for sign [only] and result) */
7312 /* set is the context [used for the rounding mode, etc.] */
7313 /* status contains the current status to be updated */
7314 /* */
7315 /* This sets the sign of a number and sets its value to either */
7316 /* Infinity or the maximum finite value, depending on the sign of */
7317 /* dn and the rounding mode, following IEEE 854 rules. */
7318 /* ------------------------------------------------------------------ */
7319 static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) {
7320 Flag needmax=0; /* result is maximum finite value */
7321 uByte sign=dn->bits&DECNEG; /* clean and save sign bit */
7322
7323 if (ISZERO(dn)) { /* zero does not overflow magnitude */
7324 Int emax=set->emax; /* limit value */
7325 if (set->clamp) emax-=set->digits-1; /* lower if clamping */
7326 if (dn->exponent>emax) { /* clamp required */
7327 dn->exponent=emax;
7328 *status|=DEC_Clamped;
7329 }
7330 return;
7331 }
7332
7333 decNumberZero(dn);
7334 switch (set->round) {
7335 case DEC_ROUND_DOWN: {
7336 needmax=1; /* never Infinity */
7337 break;} /* r-d */
7338 case DEC_ROUND_05UP: {
7339 needmax=1; /* never Infinity */
7340 break;} /* r-05 */
7341 case DEC_ROUND_CEILING: {
7342 if (sign) needmax=1; /* Infinity if non-negative */
7343 break;} /* r-c */
7344 case DEC_ROUND_FLOOR: {
7345 if (!sign) needmax=1; /* Infinity if negative */
7346 break;} /* r-f */
7347 default: break; /* Infinity in all other cases */
7348 }
7349 if (needmax) {
7350 decSetMaxValue(dn, set);
7351 dn->bits=sign; /* set sign */
7352 }
7353 else dn->bits=sign|DECINF; /* Value is +/-Infinity */
7354 *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded;
7355 } /* decSetOverflow */
7356
7357 /* ------------------------------------------------------------------ */
7358 /* decSetMaxValue -- set number to +Nmax (maximum normal value) */
7359 /* */
7360 /* dn is the number to set */
7361 /* set is the context [used for digits and emax] */
7362 /* */
7363 /* This sets the number to the maximum positive value. */
7364 /* ------------------------------------------------------------------ */
7365 static void decSetMaxValue(decNumber *dn, decContext *set) {
7366 Unit *up; /* work */
7367 Int count=set->digits; /* nines to add */
7368 dn->digits=count;
7369 /* fill in all nines to set maximum value */
7370 for (up=dn->lsu; ; up++) {
7371 if (count>DECDPUN) *up=DECDPUNMAX; /* unit full o'nines */
7372 else { /* this is the msu */
7373 *up=(Unit)(powers[count]-1);
7374 break;
7375 }
7376 count-=DECDPUN; /* filled those digits */
7377 } /* up */
7378 dn->bits=0; /* + sign */
7379 dn->exponent=set->emax-set->digits+1;
7380 } /* decSetMaxValue */
7381
7382 /* ------------------------------------------------------------------ */
7383 /* decSetSubnormal -- process value whose exponent is <Emin */
7384 /* */
7385 /* dn is the number (used as input as well as output; it may have */
7386 /* an allowed subnormal value, which may need to be rounded) */
7387 /* set is the context [used for the rounding mode] */
7388 /* residue is any pending residue */
7389 /* status contains the current status to be updated */
7390 /* */
7391 /* If subset mode, set result to zero and set Underflow flags. */
7392 /* */
7393 /* Value may be zero with a low exponent; this does not set Subnormal */
7394 /* but the exponent will be clamped to Etiny. */
7395 /* */
7396 /* Otherwise ensure exponent is not out of range, and round as */
7397 /* necessary. Underflow is set if the result is Inexact. */
7398 /* ------------------------------------------------------------------ */
7399 static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue,
7400 uInt *status) {
7401 Int dnexp; /* saves original exponent */
7402 decContext workset; /* work */
7403 Int etiny, adjust; /* .. */
7404
7405 #if DECSUBSET
7406 /* simple set to zero and 'hard underflow' for subset */
7407 if (!set->extended) {
7408 decNumberZero(dn);
7409 /* always full overflow */
7410 *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7411 return;
7412 }
7413 #endif
7414
7415 /* Full arithmetic -- allow subnormals, rounded to minimum exponent */
7416 /* (Etiny) if needed */
7417 etiny=set->emin-(set->digits-1); /* smallest allowed exponent */
7418
7419 if ISZERO(dn) { /* value is zero */
7420 /* residue can never be non-zero here */
7421 #if DECCHECK
7422 if (*residue!=0) {
7423 printf("++ Subnormal 0 residue %ld\n", (LI)*residue);
7424 *status|=DEC_Invalid_operation;
7425 }
7426 #endif
7427 if (dn->exponent<etiny) { /* clamp required */
7428 dn->exponent=etiny;
7429 *status|=DEC_Clamped;
7430 }
7431 return;
7432 }
7433
7434 *status|=DEC_Subnormal; /* have a non-zero subnormal */
7435 adjust=etiny-dn->exponent; /* calculate digits to remove */
7436 if (adjust<=0) { /* not out of range; unrounded */
7437 /* residue can never be non-zero here, except in the Nmin-residue */
7438 /* case (which is a subnormal result), so can take fast-path here */
7439 /* it may already be inexact (from setting the coefficient) */
7440 if (*status&DEC_Inexact) *status|=DEC_Underflow;
7441 return;
7442 }
7443
7444 /* adjust>0, so need to rescale the result so exponent becomes Etiny */
7445 /* [this code is similar to that in rescale] */
7446 dnexp=dn->exponent; /* save exponent */
7447 workset=*set; /* clone rounding, etc. */
7448 workset.digits=dn->digits-adjust; /* set requested length */
7449 workset.emin-=adjust; /* and adjust emin to match */
7450 /* [note that the latter can be <1, here, similar to Rescale case] */
7451 decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status);
7452 decApplyRound(dn, &workset, *residue, status);
7453
7454 /* Use 754R/854 default rule: Underflow is set iff Inexact */
7455 /* [independent of whether trapped] */
7456 if (*status&DEC_Inexact) *status|=DEC_Underflow;
7457
7458 /* if rounded up a 999s case, exponent will be off by one; adjust */
7459 /* back if so [it will fit, because it was shortened earlier] */
7460 if (dn->exponent>etiny) {
7461 dn->digits=decShiftToMost(dn->lsu, dn->digits, 1);
7462 dn->exponent--; /* (re)adjust the exponent. */
7463 }
7464
7465 /* if rounded to zero, it is by definition clamped... */
7466 if (ISZERO(dn)) *status|=DEC_Clamped;
7467 } /* decSetSubnormal */
7468
7469 /* ------------------------------------------------------------------ */
7470 /* decCheckMath - check entry conditions for a math function */
7471 /* */
7472 /* This checks the context and the operand */
7473 /* */
7474 /* rhs is the operand to check */
7475 /* set is the context to check */
7476 /* status is unchanged if both are good */
7477 /* */
7478 /* returns non-zero if status is changed, 0 otherwise */
7479 /* */
7480 /* Restrictions enforced: */
7481 /* */
7482 /* digits, emax, and -emin in the context must be less than */
7483 /* DEC_MAX_MATH (999999), and A must be within these bounds if */
7484 /* non-zero. Invalid_operation is set in the status if a */
7485 /* restriction is violated. */
7486 /* ------------------------------------------------------------------ */
7487 static uInt decCheckMath(const decNumber *rhs, decContext *set,
7488 uInt *status) {
7489 uInt save=*status; /* record */
7490 if (set->digits>DEC_MAX_MATH
7491 || set->emax>DEC_MAX_MATH
7492 || -set->emin>DEC_MAX_MATH) *status|=DEC_Invalid_context;
7493 else if ((rhs->digits>DEC_MAX_MATH
7494 || rhs->exponent+rhs->digits>DEC_MAX_MATH+1
7495 || rhs->exponent+rhs->digits<2*(1-DEC_MAX_MATH))
7496 && !ISZERO(rhs)) *status|=DEC_Invalid_operation;
7497 return (*status!=save);
7498 } /* decCheckMath */
7499
7500 /* ------------------------------------------------------------------ */
7501 /* decGetInt -- get integer from a number */
7502 /* */
7503 /* dn is the number [which will not be altered] */
7504 /* */
7505 /* returns one of: */
7506 /* BADINT if there is a non-zero fraction */
7507 /* the converted integer */
7508 /* BIGEVEN if the integer is even and magnitude > 2*10**9 */
7509 /* BIGODD if the integer is odd and magnitude > 2*10**9 */
7510 /* */
7511 /* This checks and gets a whole number from the input decNumber. */
7512 /* The sign can be determined from dn by the caller when BIGEVEN or */
7513 /* BIGODD is returned. */
7514 /* ------------------------------------------------------------------ */
7515 static Int decGetInt(const decNumber *dn) {
7516 Int theInt; /* result accumulator */
7517 const Unit *up; /* work */
7518 Int got; /* digits (real or not) processed */
7519 Int ilength=dn->digits+dn->exponent; /* integral length */
7520 Flag neg=decNumberIsNegative(dn); /* 1 if -ve */
7521
7522 /* The number must be an integer that fits in 10 digits */
7523 /* Assert, here, that 10 is enough for any rescale Etiny */
7524 #if DEC_MAX_EMAX > 999999999
7525 #error GetInt may need updating [for Emax]
7526 #endif
7527 #if DEC_MIN_EMIN < -999999999
7528 #error GetInt may need updating [for Emin]
7529 #endif
7530 if (ISZERO(dn)) return 0; /* zeros are OK, with any exponent */
7531
7532 up=dn->lsu; /* ready for lsu */
7533 theInt=0; /* ready to accumulate */
7534 if (dn->exponent>=0) { /* relatively easy */
7535 /* no fractional part [usual]; allow for positive exponent */
7536 got=dn->exponent;
7537 }
7538 else { /* -ve exponent; some fractional part to check and discard */
7539 Int count=-dn->exponent; /* digits to discard */
7540 /* spin up whole units until reach the Unit with the unit digit */
7541 for (; count>=DECDPUN; up++) {
7542 if (*up!=0) return BADINT; /* non-zero Unit to discard */
7543 count-=DECDPUN;
7544 }
7545 if (count==0) got=0; /* [a multiple of DECDPUN] */
7546 else { /* [not multiple of DECDPUN] */
7547 Int rem; /* work */
7548 /* slice off fraction digits and check for non-zero */
7549 #if DECDPUN<=4
7550 theInt=QUOT10(*up, count);
7551 rem=*up-theInt*powers[count];
7552 #else
7553 rem=*up%powers[count]; /* slice off discards */
7554 theInt=*up/powers[count];
7555 #endif
7556 if (rem!=0) return BADINT; /* non-zero fraction */
7557 /* it looks good */
7558 got=DECDPUN-count; /* number of digits so far */
7559 up++; /* ready for next */
7560 }
7561 }
7562 /* now it's known there's no fractional part */
7563
7564 /* tricky code now, to accumulate up to 9.3 digits */
7565 if (got==0) {theInt=*up; got+=DECDPUN; up++;} /* ensure lsu is there */
7566
7567 if (ilength<11) {
7568 Int save=theInt;
7569 /* collect any remaining unit(s) */
7570 for (; got<ilength; up++) {
7571 theInt+=*up*powers[got];
7572 got+=DECDPUN;
7573 }
7574 if (ilength==10) { /* need to check for wrap */
7575 if (theInt/(Int)powers[got-DECDPUN]!=(Int)*(up-1)) ilength=11;
7576 /* [that test also disallows the BADINT result case] */
7577 else if (neg && theInt>1999999997) ilength=11;
7578 else if (!neg && theInt>999999999) ilength=11;
7579 if (ilength==11) theInt=save; /* restore correct low bit */
7580 }
7581 }
7582
7583 if (ilength>10) { /* too big */
7584 if (theInt&1) return BIGODD; /* bottom bit 1 */
7585 return BIGEVEN; /* bottom bit 0 */
7586 }
7587
7588 if (neg) theInt=-theInt; /* apply sign */
7589 return theInt;
7590 } /* decGetInt */
7591
7592 /* ------------------------------------------------------------------ */
7593 /* decDecap -- decapitate the coefficient of a number */
7594 /* */
7595 /* dn is the number to be decapitated */
7596 /* drop is the number of digits to be removed from the left of dn; */
7597 /* this must be <= dn->digits (if equal, the coefficient is */
7598 /* set to 0) */
7599 /* */
7600 /* Returns dn; dn->digits will be <= the initial digits less drop */
7601 /* (after removing drop digits there may be leading zero digits */
7602 /* which will also be removed). Only dn->lsu and dn->digits change. */
7603 /* ------------------------------------------------------------------ */
7604 static decNumber *decDecap(decNumber *dn, Int drop) {
7605 Unit *msu; /* -> target cut point */
7606 Int cut; /* work */
7607 if (drop>=dn->digits) { /* losing the whole thing */
7608 #if DECCHECK
7609 if (drop>dn->digits)
7610 printf("decDecap called with drop>digits [%ld>%ld]\n",
7611 (LI)drop, (LI)dn->digits);
7612 #endif
7613 dn->lsu[0]=0;
7614 dn->digits=1;
7615 return dn;
7616 }
7617 msu=dn->lsu+D2U(dn->digits-drop)-1; /* -> likely msu */
7618 cut=MSUDIGITS(dn->digits-drop); /* digits to be in use in msu */
7619 if (cut!=DECDPUN) *msu%=powers[cut]; /* clear left digits */
7620 /* that may have left leading zero digits, so do a proper count... */
7621 dn->digits=decGetDigits(dn->lsu, msu-dn->lsu+1);
7622 return dn;
7623 } /* decDecap */
7624
7625 /* ------------------------------------------------------------------ */
7626 /* decBiStr -- compare string with pairwise options */
7627 /* */
7628 /* targ is the string to compare */
7629 /* str1 is one of the strings to compare against (length may be 0) */
7630 /* str2 is the other; it must be the same length as str1 */
7631 /* */
7632 /* returns 1 if strings compare equal, (that is, it is the same */
7633 /* length as str1 and str2, and each character of targ is in either */
7634 /* str1 or str2 in the corresponding position), or 0 otherwise */
7635 /* */
7636 /* This is used for generic caseless compare, including the awkward */
7637 /* case of the Turkish dotted and dotless Is. Use as (for example): */
7638 /* if (decBiStr(test, "mike", "MIKE")) ... */
7639 /* ------------------------------------------------------------------ */
7640 static Flag decBiStr(const char *targ, const char *str1, const char *str2) {
7641 for (;;targ++, str1++, str2++) {
7642 if (*targ!=*str1 && *targ!=*str2) return 0;
7643 /* *targ has a match in one (or both, if terminator) */
7644 if (*targ=='\0') break;
7645 } /* forever */
7646 return 1;
7647 } /* decBiStr */
7648
7649 /* ------------------------------------------------------------------ */
7650 /* decNaNs -- handle NaN operand or operands */
7651 /* */
7652 /* res is the result number */
7653 /* lhs is the first operand */
7654 /* rhs is the second operand, or NULL if none */
7655 /* context is used to limit payload length */
7656 /* status contains the current status */
7657 /* returns res in case convenient */
7658 /* */
7659 /* Called when one or both operands is a NaN, and propagates the */
7660 /* appropriate result to res. When an sNaN is found, it is changed */
7661 /* to a qNaN and Invalid operation is set. */
7662 /* ------------------------------------------------------------------ */
7663 static decNumber * decNaNs(decNumber *res, const decNumber *lhs,
7664 const decNumber *rhs, decContext *set,
7665 uInt *status) {
7666 /* This decision tree ends up with LHS being the source pointer, */
7667 /* and status updated if need be */
7668 if (lhs->bits & DECSNAN)
7669 *status|=DEC_Invalid_operation | DEC_sNaN;
7670 else if (rhs==NULL);
7671 else if (rhs->bits & DECSNAN) {
7672 lhs=rhs;
7673 *status|=DEC_Invalid_operation | DEC_sNaN;
7674 }
7675 else if (lhs->bits & DECNAN);
7676 else lhs=rhs;
7677
7678 /* propagate the payload */
7679 if (lhs->digits<=set->digits) decNumberCopy(res, lhs); /* easy */
7680 else { /* too long */
7681 const Unit *ul;
7682 Unit *ur, *uresp1;
7683 /* copy safe number of units, then decapitate */
7684 res->bits=lhs->bits; /* need sign etc. */
7685 uresp1=res->lsu+D2U(set->digits);
7686 for (ur=res->lsu, ul=lhs->lsu; ur<uresp1; ur++, ul++) *ur=*ul;
7687 res->digits=D2U(set->digits)*DECDPUN;
7688 /* maybe still too long */
7689 if (res->digits>set->digits) decDecap(res, res->digits-set->digits);
7690 }
7691
7692 res->bits&=~DECSNAN; /* convert any sNaN to NaN, while */
7693 res->bits|=DECNAN; /* .. preserving sign */
7694 res->exponent=0; /* clean exponent */
7695 /* [coefficient was copied/decapitated] */
7696 return res;
7697 } /* decNaNs */
7698
7699 /* ------------------------------------------------------------------ */
7700 /* decStatus -- apply non-zero status */
7701 /* */
7702 /* dn is the number to set if error */
7703 /* status contains the current status (not yet in context) */
7704 /* set is the context */
7705 /* */
7706 /* If the status is an error status, the number is set to a NaN, */
7707 /* unless the error was an overflow, divide-by-zero, or underflow, */
7708 /* in which case the number will have already been set. */
7709 /* */
7710 /* The context status is then updated with the new status. Note that */
7711 /* this may raise a signal, so control may never return from this */
7712 /* routine (hence resources must be recovered before it is called). */
7713 /* ------------------------------------------------------------------ */
7714 static void decStatus(decNumber *dn, uInt status, decContext *set) {
7715 if (status & DEC_NaNs) { /* error status -> NaN */
7716 /* if cause was an sNaN, clear and propagate [NaN is already set up] */
7717 if (status & DEC_sNaN) status&=~DEC_sNaN;
7718 else {
7719 decNumberZero(dn); /* other error: clean throughout */
7720 dn->bits=DECNAN; /* and make a quiet NaN */
7721 }
7722 }
7723 decContextSetStatus(set, status); /* [may not return] */
7724 return;
7725 } /* decStatus */
7726
7727 /* ------------------------------------------------------------------ */
7728 /* decGetDigits -- count digits in a Units array */
7729 /* */
7730 /* uar is the Unit array holding the number (this is often an */
7731 /* accumulator of some sort) */
7732 /* len is the length of the array in units [>=1] */
7733 /* */
7734 /* returns the number of (significant) digits in the array */
7735 /* */
7736 /* All leading zeros are excluded, except the last if the array has */
7737 /* only zero Units. */
7738 /* ------------------------------------------------------------------ */
7739 /* This may be called twice during some operations. */
7740 static Int decGetDigits(Unit *uar, Int len) {
7741 Unit *up=uar+(len-1); /* -> msu */
7742 Int digits=(len-1)*DECDPUN+1; /* possible digits excluding msu */
7743 #if DECDPUN>4
7744 uInt const *pow; /* work */
7745 #endif
7746 /* (at least 1 in final msu) */
7747 #if DECCHECK
7748 if (len<1) printf("decGetDigits called with len<1 [%ld]\n", (LI)len);
7749 #endif
7750
7751 for (; up>=uar; up--) {
7752 if (*up==0) { /* unit is all 0s */
7753 if (digits==1) break; /* a zero has one digit */
7754 digits-=DECDPUN; /* adjust for 0 unit */
7755 continue;}
7756 /* found the first (most significant) non-zero Unit */
7757 #if DECDPUN>1 /* not done yet */
7758 if (*up<10) break; /* is 1-9 */
7759 digits++;
7760 #if DECDPUN>2 /* not done yet */
7761 if (*up<100) break; /* is 10-99 */
7762 digits++;
7763 #if DECDPUN>3 /* not done yet */
7764 if (*up<1000) break; /* is 100-999 */
7765 digits++;
7766 #if DECDPUN>4 /* count the rest ... */
7767 for (pow=&powers[4]; *up>=*pow; pow++) digits++;
7768 #endif
7769 #endif
7770 #endif
7771 #endif
7772 break;
7773 } /* up */
7774 return digits;
7775 } /* decGetDigits */
7776
7777 #if DECTRACE | DECCHECK
7778 /* ------------------------------------------------------------------ */
7779 /* decNumberShow -- display a number [debug aid] */
7780 /* dn is the number to show */
7781 /* */
7782 /* Shows: sign, exponent, coefficient (msu first), digits */
7783 /* or: sign, special-value */
7784 /* ------------------------------------------------------------------ */
7785 /* this is public so other modules can use it */
7786 void decNumberShow(const decNumber *dn) {
7787 const Unit *up; /* work */
7788 uInt u, d; /* .. */
7789 Int cut; /* .. */
7790 char isign='+'; /* main sign */
7791 if (dn==NULL) {
7792 printf("NULL\n");
7793 return;}
7794 if (decNumberIsNegative(dn)) isign='-';
7795 printf(" >> %c ", isign);
7796 if (dn->bits&DECSPECIAL) { /* Is a special value */
7797 if (decNumberIsInfinite(dn)) printf("Infinity");
7798 else { /* a NaN */
7799 if (dn->bits&DECSNAN) printf("sNaN"); /* signalling NaN */
7800 else printf("NaN");
7801 }
7802 /* if coefficient and exponent are 0, no more to do */
7803 if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) {
7804 printf("\n");
7805 return;}
7806 /* drop through to report other information */
7807 printf(" ");
7808 }
7809
7810 /* now carefully display the coefficient */
7811 up=dn->lsu+D2U(dn->digits)-1; /* msu */
7812 printf("%ld", (LI)*up);
7813 for (up=up-1; up>=dn->lsu; up--) {
7814 u=*up;
7815 printf(":");
7816 for (cut=DECDPUN-1; cut>=0; cut--) {
7817 d=u/powers[cut];
7818 u-=d*powers[cut];
7819 printf("%ld", (LI)d);
7820 } /* cut */
7821 } /* up */
7822 if (dn->exponent!=0) {
7823 char esign='+';
7824 if (dn->exponent<0) esign='-';
7825 printf(" E%c%ld", esign, (LI)abs(dn->exponent));
7826 }
7827 printf(" [%ld]\n", (LI)dn->digits);
7828 } /* decNumberShow */
7829 #endif
7830
7831 #if DECTRACE || DECCHECK
7832 /* ------------------------------------------------------------------ */
7833 /* decDumpAr -- display a unit array [debug/check aid] */
7834 /* name is a single-character tag name */
7835 /* ar is the array to display */
7836 /* len is the length of the array in Units */
7837 /* ------------------------------------------------------------------ */
7838 static void decDumpAr(char name, const Unit *ar, Int len) {
7839 Int i;
7840 const char *spec;
7841 #if DECDPUN==9
7842 spec="%09d ";
7843 #elif DECDPUN==8
7844 spec="%08d ";
7845 #elif DECDPUN==7
7846 spec="%07d ";
7847 #elif DECDPUN==6
7848 spec="%06d ";
7849 #elif DECDPUN==5
7850 spec="%05d ";
7851 #elif DECDPUN==4
7852 spec="%04d ";
7853 #elif DECDPUN==3
7854 spec="%03d ";
7855 #elif DECDPUN==2
7856 spec="%02d ";
7857 #else
7858 spec="%d ";
7859 #endif
7860 printf(" :%c: ", name);
7861 for (i=len-1; i>=0; i--) {
7862 if (i==len-1) printf("%ld ", (LI)ar[i]);
7863 else printf(spec, ar[i]);
7864 }
7865 printf("\n");
7866 return;}
7867 #endif
7868
7869 #if DECCHECK
7870 /* ------------------------------------------------------------------ */
7871 /* decCheckOperands -- check operand(s) to a routine */
7872 /* res is the result structure (not checked; it will be set to */
7873 /* quiet NaN if error found (and it is not NULL)) */
7874 /* lhs is the first operand (may be DECUNRESU) */
7875 /* rhs is the second (may be DECUNUSED) */
7876 /* set is the context (may be DECUNCONT) */
7877 /* returns 0 if both operands, and the context are clean, or 1 */
7878 /* otherwise (in which case the context will show an error, */
7879 /* unless NULL). Note that res is not cleaned; caller should */
7880 /* handle this so res=NULL case is safe. */
7881 /* The caller is expected to abandon immediately if 1 is returned. */
7882 /* ------------------------------------------------------------------ */
7883 static Flag decCheckOperands(decNumber *res, const decNumber *lhs,
7884 const decNumber *rhs, decContext *set) {
7885 Flag bad=0;
7886 if (set==NULL) { /* oops; hopeless */
7887 #if DECTRACE || DECVERB
7888 printf("Reference to context is NULL.\n");
7889 #endif
7890 bad=1;
7891 return 1;}
7892 else if (set!=DECUNCONT
7893 && (set->digits<1 || set->round>=DEC_ROUND_MAX)) {
7894 bad=1;
7895 #if DECTRACE || DECVERB
7896 printf("Bad context [digits=%ld round=%ld].\n",
7897 (LI)set->digits, (LI)set->round);
7898 #endif
7899 }
7900 else {
7901 if (res==NULL) {
7902 bad=1;
7903 #if DECTRACE
7904 /* this one not DECVERB as standard tests include NULL */
7905 printf("Reference to result is NULL.\n");
7906 #endif
7907 }
7908 if (!bad && lhs!=DECUNUSED) bad=(decCheckNumber(lhs));
7909 if (!bad && rhs!=DECUNUSED) bad=(decCheckNumber(rhs));
7910 }
7911 if (bad) {
7912 if (set!=DECUNCONT) decContextSetStatus(set, DEC_Invalid_operation);
7913 if (res!=DECUNRESU && res!=NULL) {
7914 decNumberZero(res);
7915 res->bits=DECNAN; /* qNaN */
7916 }
7917 }
7918 return bad;
7919 } /* decCheckOperands */
7920
7921 /* ------------------------------------------------------------------ */
7922 /* decCheckNumber -- check a number */
7923 /* dn is the number to check */
7924 /* returns 0 if the number is clean, or 1 otherwise */
7925 /* */
7926 /* The number is considered valid if it could be a result from some */
7927 /* operation in some valid context. */
7928 /* ------------------------------------------------------------------ */
7929 static Flag decCheckNumber(const decNumber *dn) {
7930 const Unit *up; /* work */
7931 uInt maxuint; /* .. */
7932 Int ae, d, digits; /* .. */
7933 Int emin, emax; /* .. */
7934
7935 if (dn==NULL) { /* hopeless */
7936 #if DECTRACE
7937 /* this one not DECVERB as standard tests include NULL */
7938 printf("Reference to decNumber is NULL.\n");
7939 #endif
7940 return 1;}
7941
7942 /* check special values */
7943 if (dn->bits & DECSPECIAL) {
7944 if (dn->exponent!=0) {
7945 #if DECTRACE || DECVERB
7946 printf("Exponent %ld (not 0) for a special value [%02x].\n",
7947 (LI)dn->exponent, dn->bits);
7948 #endif
7949 return 1;}
7950
7951 /* 2003.09.08: NaNs may now have coefficients, so next tests Inf only */
7952 if (decNumberIsInfinite(dn)) {
7953 if (dn->digits!=1) {
7954 #if DECTRACE || DECVERB
7955 printf("Digits %ld (not 1) for an infinity.\n", (LI)dn->digits);
7956 #endif
7957 return 1;}
7958 if (*dn->lsu!=0) {
7959 #if DECTRACE || DECVERB
7960 printf("LSU %ld (not 0) for an infinity.\n", (LI)*dn->lsu);
7961 #endif
7962 decDumpAr('I', dn->lsu, D2U(dn->digits));
7963 return 1;}
7964 } /* Inf */
7965 /* 2002.12.26: negative NaNs can now appear through proposed IEEE */
7966 /* concrete formats (decimal64, etc.). */
7967 return 0;
7968 }
7969
7970 /* check the coefficient */
7971 if (dn->digits<1 || dn->digits>DECNUMMAXP) {
7972 #if DECTRACE || DECVERB
7973 printf("Digits %ld in number.\n", (LI)dn->digits);
7974 #endif
7975 return 1;}
7976
7977 d=dn->digits;
7978
7979 for (up=dn->lsu; d>0; up++) {
7980 if (d>DECDPUN) maxuint=DECDPUNMAX;
7981 else { /* reached the msu */
7982 maxuint=powers[d]-1;
7983 if (dn->digits>1 && *up<powers[d-1]) {
7984 #if DECTRACE || DECVERB
7985 printf("Leading 0 in number.\n");
7986 decNumberShow(dn);
7987 #endif
7988 return 1;}
7989 }
7990 if (*up>maxuint) {
7991 #if DECTRACE || DECVERB
7992 printf("Bad Unit [%08lx] in %ld-digit number at offset %ld [maxuint %ld].\n",
7993 (LI)*up, (LI)dn->digits, (LI)(up-dn->lsu), (LI)maxuint);
7994 #endif
7995 return 1;}
7996 d-=DECDPUN;
7997 }
7998
7999 /* check the exponent. Note that input operands can have exponents */
8000 /* which are out of the set->emin/set->emax and set->digits range */
8001 /* (just as they can have more digits than set->digits). */
8002 ae=dn->exponent+dn->digits-1; /* adjusted exponent */
8003 emax=DECNUMMAXE;
8004 emin=DECNUMMINE;
8005 digits=DECNUMMAXP;
8006 if (ae<emin-(digits-1)) {
8007 #if DECTRACE || DECVERB
8008 printf("Adjusted exponent underflow [%ld].\n", (LI)ae);
8009 decNumberShow(dn);
8010 #endif
8011 return 1;}
8012 if (ae>+emax) {
8013 #if DECTRACE || DECVERB
8014 printf("Adjusted exponent overflow [%ld].\n", (LI)ae);
8015 decNumberShow(dn);
8016 #endif
8017 return 1;}
8018
8019 return 0; /* it's OK */
8020 } /* decCheckNumber */
8021
8022 /* ------------------------------------------------------------------ */
8023 /* decCheckInexact -- check a normal finite inexact result has digits */
8024 /* dn is the number to check */
8025 /* set is the context (for status and precision) */
8026 /* sets Invalid operation, etc., if some digits are missing */
8027 /* [this check is not made for DECSUBSET compilation or when */
8028 /* subnormal is not set] */
8029 /* ------------------------------------------------------------------ */
8030 static void decCheckInexact(const decNumber *dn, decContext *set) {
8031 #if !DECSUBSET && DECEXTFLAG
8032 if ((set->status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact
8033 && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) {
8034 #if DECTRACE || DECVERB
8035 printf("Insufficient digits [%ld] on normal Inexact result.\n",
8036 (LI)dn->digits);
8037 decNumberShow(dn);
8038 #endif
8039 decContextSetStatus(set, DEC_Invalid_operation);
8040 }
8041 #else
8042 /* next is a noop for quiet compiler */
8043 if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation;
8044 #endif
8045 return;
8046 } /* decCheckInexact */
8047 #endif
8048
8049 #if DECALLOC
8050 #undef malloc
8051 #undef free
8052 /* ------------------------------------------------------------------ */
8053 /* decMalloc -- accountable allocation routine */
8054 /* n is the number of bytes to allocate */
8055 /* */
8056 /* Semantics is the same as the stdlib malloc routine, but bytes */
8057 /* allocated are accounted for globally, and corruption fences are */
8058 /* added before and after the 'actual' storage. */
8059 /* ------------------------------------------------------------------ */
8060 /* This routine allocates storage with an extra twelve bytes; 8 are */
8061 /* at the start and hold: */
8062 /* 0-3 the original length requested */
8063 /* 4-7 buffer corruption detection fence (DECFENCE, x4) */
8064 /* The 4 bytes at the end also hold a corruption fence (DECFENCE, x4) */
8065 /* ------------------------------------------------------------------ */
8066 static void *decMalloc(size_t n) {
8067 uInt size=n+12; /* true size */
8068 void *alloc; /* -> allocated storage */
8069 uInt *j; /* work */
8070 uByte *b, *b0; /* .. */
8071
8072 alloc=malloc(size); /* -> allocated storage */
8073 if (alloc==NULL) return NULL; /* out of strorage */
8074 b0=(uByte *)alloc; /* as bytes */
8075 decAllocBytes+=n; /* account for storage */
8076 j=(uInt *)alloc; /* -> first four bytes */
8077 *j=n; /* save n */
8078 /* printf(" alloc ++ dAB: %ld (%d)\n", decAllocBytes, n); */
8079 for (b=b0+4; b<b0+8; b++) *b=DECFENCE;
8080 for (b=b0+n+8; b<b0+n+12; b++) *b=DECFENCE;
8081 return b0+8; /* -> play area */
8082 } /* decMalloc */
8083
8084 /* ------------------------------------------------------------------ */
8085 /* decFree -- accountable free routine */
8086 /* alloc is the storage to free */
8087 /* */
8088 /* Semantics is the same as the stdlib malloc routine, except that */
8089 /* the global storage accounting is updated and the fences are */
8090 /* checked to ensure that no routine has written 'out of bounds'. */
8091 /* ------------------------------------------------------------------ */
8092 /* This routine first checks that the fences have not been corrupted. */
8093 /* It then frees the storage using the 'truw' storage address (that */
8094 /* is, offset by 8). */
8095 /* ------------------------------------------------------------------ */
8096 static void decFree(void *alloc) {
8097 uInt *j, n; /* pointer, original length */
8098 uByte *b, *b0; /* work */
8099
8100 if (alloc==NULL) return; /* allowed; it's a nop */
8101 b0=(uByte *)alloc; /* as bytes */
8102 b0-=8; /* -> true start of storage */
8103 j=(uInt *)b0; /* -> first four bytes */
8104 n=*j; /* lift */
8105 for (b=b0+4; b<b0+8; b++) if (*b!=DECFENCE)
8106 printf("=== Corrupt byte [%02x] at offset %d from %ld ===\n", *b,
8107 b-b0-8, (Int)b0);
8108 for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE)
8109 printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b,
8110 b-b0-8, (Int)b0, n);
8111 free(b0); /* drop the storage */
8112 decAllocBytes-=n; /* account for storage */
8113 /* printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n); */
8114 } /* decFree */
8115 #define malloc(a) decMalloc(a)
8116 #define free(a) decFree(a)
8117 #endif