The Tor Browser / file comparison

comparison: intl/icu/source/i18n/decNumber.c

intl/icu/source/i18n/decNumber.c

branch
TOR_BUG_3246
changeset 4
fc2d59ddac77
equal deleted inserted replaced
-1:000000000000 0:9ff15d70469d
1 /* ------------------------------------------------------------------ */
2 /* Decimal Number arithmetic module */
3 /* ------------------------------------------------------------------ */
4 /* Copyright (c) IBM Corporation, 2000-2012. All rights reserved. */
5 /* */
6 /* This software is made available under the terms of the */
7 /* ICU License -- ICU 1.8.1 and later. */
8 /* */
9 /* The description and User's Guide ("The decNumber C Library") for */
10 /* this software is called decNumber.pdf. This document is */
11 /* available, together with arithmetic and format specifications, */
12 /* testcases, and Web links, on the General Decimal Arithmetic page. */
13 /* */
14 /* Please send comments, suggestions, and corrections to the author: */
15 /* mfc@uk.ibm.com */
16 /* Mike Cowlishaw, IBM Fellow */
17 /* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
18 /* ------------------------------------------------------------------ */
19
20 /* Modified version, for use from within ICU.
21 * Renamed public functions, to avoid an unwanted export of the
22 * standard names from the ICU library.
23 *
24 * Use ICU's uprv_malloc() and uprv_free()
25 *
26 * Revert comment syntax to plain C
27 *
28 * Remove a few compiler warnings.
29 */
30
31 /* This module comprises the routines for arbitrary-precision General */
32 /* Decimal Arithmetic as defined in the specification which may be */
33 /* found on the General Decimal Arithmetic pages. It implements both */
34 /* the full ('extended') arithmetic and the simpler ('subset') */
35 /* arithmetic. */
36 /* */
37 /* Usage notes: */
38 /* */
39 /* 1. This code is ANSI C89 except: */
40 /* */
41 /* a) C99 line comments (double forward slash) are used. (Most C */
42 /* compilers accept these. If yours does not, a simple script */
43 /* can be used to convert them to ANSI C comments.) */
44 /* */
45 /* b) Types from C99 stdint.h are used. If you do not have this */
46 /* header file, see the User's Guide section of the decNumber */
47 /* documentation; this lists the necessary definitions. */
48 /* */
49 /* c) If DECDPUN>4 or DECUSE64=1, the C99 64-bit int64_t and */
50 /* uint64_t types may be used. To avoid these, set DECUSE64=0 */
51 /* and DECDPUN<=4 (see documentation). */
52 /* */
53 /* The code also conforms to C99 restrictions; in particular, */
54 /* strict aliasing rules are observed. */
55 /* */
56 /* 2. The decNumber format which this library uses is optimized for */
57 /* efficient processing of relatively short numbers; in particular */
58 /* it allows the use of fixed sized structures and minimizes copy */
59 /* and move operations. It does, however, support arbitrary */
60 /* precision (up to 999,999,999 digits) and arbitrary exponent */
61 /* range (Emax in the range 0 through 999,999,999 and Emin in the */
62 /* range -999,999,999 through 0). Mathematical functions (for */
63 /* example decNumberExp) as identified below are restricted more */
64 /* tightly: digits, emax, and -emin in the context must be <= */
65 /* DEC_MAX_MATH (999999), and their operand(s) must be within */
66 /* these bounds. */
67 /* */
68 /* 3. Logical functions are further restricted; their operands must */
69 /* be finite, positive, have an exponent of zero, and all digits */
70 /* must be either 0 or 1. The result will only contain digits */
71 /* which are 0 or 1 (and will have exponent=0 and a sign of 0). */
72 /* */
73 /* 4. Operands to operator functions are never modified unless they */
74 /* are also specified to be the result number (which is always */
75 /* permitted). Other than that case, operands must not overlap. */
76 /* */
77 /* 5. Error handling: the type of the error is ORed into the status */
78 /* flags in the current context (decContext structure). The */
79 /* SIGFPE signal is then raised if the corresponding trap-enabler */
80 /* flag in the decContext is set (is 1). */
81 /* */
82 /* It is the responsibility of the caller to clear the status */
83 /* flags as required. */
84 /* */
85 /* The result of any routine which returns a number will always */
86 /* be a valid number (which may be a special value, such as an */
87 /* Infinity or NaN). */
88 /* */
89 /* 6. The decNumber format is not an exchangeable concrete */
90 /* representation as it comprises fields which may be machine- */
91 /* dependent (packed or unpacked, or special length, for example). */
92 /* Canonical conversions to and from strings are provided; other */
93 /* conversions are available in separate modules. */
94 /* */
95 /* 7. Normally, input operands are assumed to be valid. Set DECCHECK */
96 /* to 1 for extended operand checking (including NULL operands). */
97 /* Results are undefined if a badly-formed structure (or a NULL */
98 /* pointer to a structure) is provided, though with DECCHECK */
99 /* enabled the operator routines are protected against exceptions. */
100 /* (Except if the result pointer is NULL, which is unrecoverable.) */
101 /* */
102 /* However, the routines will never cause exceptions if they are */
103 /* given well-formed operands, even if the value of the operands */
104 /* is inappropriate for the operation and DECCHECK is not set. */
105 /* (Except for SIGFPE, as and where documented.) */
106 /* */
107 /* 8. Subset arithmetic is available only if DECSUBSET is set to 1. */
108 /* ------------------------------------------------------------------ */
109 /* Implementation notes for maintenance of this module: */
110 /* */
111 /* 1. Storage leak protection: Routines which use malloc are not */
112 /* permitted to use return for fastpath or error exits (i.e., */
113 /* they follow strict structured programming conventions). */
114 /* Instead they have a do{}while(0); construct surrounding the */
115 /* code which is protected -- break may be used to exit this. */
116 /* Other routines can safely use the return statement inline. */
117 /* */
118 /* Storage leak accounting can be enabled using DECALLOC. */
119 /* */
120 /* 2. All loops use the for(;;) construct. Any do construct does */
121 /* not loop; it is for allocation protection as just described. */
122 /* */
123 /* 3. Setting status in the context must always be the very last */
124 /* action in a routine, as non-0 status may raise a trap and hence */
125 /* the call to set status may not return (if the handler uses long */
126 /* jump). Therefore all cleanup must be done first. In general, */
127 /* to achieve this status is accumulated and is only applied just */
128 /* before return by calling decContextSetStatus (via decStatus). */
129 /* */
130 /* Routines which allocate storage cannot, in general, use the */
131 /* 'top level' routines which could cause a non-returning */
132 /* transfer of control. The decXxxxOp routines are safe (do not */
133 /* call decStatus even if traps are set in the context) and should */
134 /* be used instead (they are also a little faster). */
135 /* */
136 /* 4. Exponent checking is minimized by allowing the exponent to */
137 /* grow outside its limits during calculations, provided that */
138 /* the decFinalize function is called later. Multiplication and */
139 /* division, and intermediate calculations in exponentiation, */
140 /* require more careful checks because of the risk of 31-bit */
141 /* overflow (the most negative valid exponent is -1999999997, for */
142 /* a 999999999-digit number with adjusted exponent of -999999999). */
143 /* */
144 /* 5. Rounding is deferred until finalization of results, with any */
145 /* 'off to the right' data being represented as a single digit */
146 /* residue (in the range -1 through 9). This avoids any double- */
147 /* rounding when more than one shortening takes place (for */
148 /* example, when a result is subnormal). */
149 /* */
150 /* 6. The digits count is allowed to rise to a multiple of DECDPUN */
151 /* during many operations, so whole Units are handled and exact */
152 /* accounting of digits is not needed. The correct digits value */
153 /* is found by decGetDigits, which accounts for leading zeros. */
154 /* This must be called before any rounding if the number of digits */
155 /* is not known exactly. */
156 /* */
157 /* 7. The multiply-by-reciprocal 'trick' is used for partitioning */
158 /* numbers up to four digits, using appropriate constants. This */
159 /* is not useful for longer numbers because overflow of 32 bits */
160 /* would lead to 4 multiplies, which is almost as expensive as */
161 /* a divide (unless a floating-point or 64-bit multiply is */
162 /* assumed to be available). */
163 /* */
164 /* 8. Unusual abbreviations that may be used in the commentary: */
165 /* lhs -- left hand side (operand, of an operation) */
166 /* lsd -- least significant digit (of coefficient) */
167 /* lsu -- least significant Unit (of coefficient) */
168 /* msd -- most significant digit (of coefficient) */
169 /* msi -- most significant item (in an array) */
170 /* msu -- most significant Unit (of coefficient) */
171 /* rhs -- right hand side (operand, of an operation) */
172 /* +ve -- positive */
173 /* -ve -- negative */
174 /* ** -- raise to the power */
175 /* ------------------------------------------------------------------ */
176
177 #include <stdlib.h> /* for malloc, free, etc. */
178 /* #include <stdio.h> */ /* for printf [if needed] */
179 #include <string.h> /* for strcpy */
180 #include <ctype.h> /* for lower */
181 #include "cmemory.h" /* for uprv_malloc, etc., in ICU */
182 #include "decNumber.h" /* base number library */
183 #include "decNumberLocal.h" /* decNumber local types, etc. */
184 #include "uassert.h"
185
186 /* Constants */
187 /* Public lookup table used by the D2U macro */
188 static const uByte d2utable[DECMAXD2U+1]=D2UTABLE;
189
190 #define DECVERB 1 /* set to 1 for verbose DECCHECK */
191 #define powers DECPOWERS /* old internal name */
192
193 /* Local constants */
194 #define DIVIDE 0x80 /* Divide operators */
195 #define REMAINDER 0x40 /* .. */
196 #define DIVIDEINT 0x20 /* .. */
197 #define REMNEAR 0x10 /* .. */
198 #define COMPARE 0x01 /* Compare operators */
199 #define COMPMAX 0x02 /* .. */
200 #define COMPMIN 0x03 /* .. */
201 #define COMPTOTAL 0x04 /* .. */
202 #define COMPNAN 0x05 /* .. [NaN processing] */
203 #define COMPSIG 0x06 /* .. [signaling COMPARE] */
204 #define COMPMAXMAG 0x07 /* .. */
205 #define COMPMINMAG 0x08 /* .. */
206
207 #define DEC_sNaN 0x40000000 /* local status: sNaN signal */
208 #define BADINT (Int)0x80000000 /* most-negative Int; error indicator */
209 /* Next two indicate an integer >= 10**6, and its parity (bottom bit) */
210 #define BIGEVEN (Int)0x80000002
211 #define BIGODD (Int)0x80000003
212
213 static const Unit uarrone[1]={1}; /* Unit array of 1, used for incrementing */
214
215 /* ------------------------------------------------------------------ */
216 /* round-for-reround digits */
217 /* ------------------------------------------------------------------ */
218 static const uByte DECSTICKYTAB[10]={1,1,2,3,4,6,6,7,8,9}; /* used if sticky */
219
220 /* ------------------------------------------------------------------ */
221 /* Powers of ten (powers[n]==10**n, 0<=n<=9) */
222 /* ------------------------------------------------------------------ */
223 static const uInt DECPOWERS[10]={1, 10, 100, 1000, 10000, 100000, 1000000,
224 10000000, 100000000, 1000000000};
225
226
227 /* Granularity-dependent code */
228 #if DECDPUN<=4
229 #define eInt Int /* extended integer */
230 #define ueInt uInt /* unsigned extended integer */
231 /* Constant multipliers for divide-by-power-of five using reciprocal */
232 /* multiply, after removing powers of 2 by shifting, and final shift */
233 /* of 17 [we only need up to **4] */
234 static const uInt multies[]={131073, 26215, 5243, 1049, 210};
235 /* QUOT10 -- macro to return the quotient of unit u divided by 10**n */
236 #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
237 #else
238 /* For DECDPUN>4 non-ANSI-89 64-bit types are needed. */
239 #if !DECUSE64
240 #error decNumber.c: DECUSE64 must be 1 when DECDPUN>4
241 #endif
242 #define eInt Long /* extended integer */
243 #define ueInt uLong /* unsigned extended integer */
244 #endif
245
246 /* Local routines */
247 static decNumber * decAddOp(decNumber *, const decNumber *, const decNumber *,
248 decContext *, uByte, uInt *);
249 static Flag decBiStr(const char *, const char *, const char *);
250 static uInt decCheckMath(const decNumber *, decContext *, uInt *);
251 static void decApplyRound(decNumber *, decContext *, Int, uInt *);
252 static Int decCompare(const decNumber *lhs, const decNumber *rhs, Flag);
253 static decNumber * decCompareOp(decNumber *, const decNumber *,
254 const decNumber *, decContext *,
255 Flag, uInt *);
256 static void decCopyFit(decNumber *, const decNumber *, decContext *,
257 Int *, uInt *);
258 static decNumber * decDecap(decNumber *, Int);
259 static decNumber * decDivideOp(decNumber *, const decNumber *,
260 const decNumber *, decContext *, Flag, uInt *);
261 static decNumber * decExpOp(decNumber *, const decNumber *,
262 decContext *, uInt *);
263 static void decFinalize(decNumber *, decContext *, Int *, uInt *);
264 static Int decGetDigits(Unit *, Int);
265 static Int decGetInt(const decNumber *);
266 static decNumber * decLnOp(decNumber *, const decNumber *,
267 decContext *, uInt *);
268 static decNumber * decMultiplyOp(decNumber *, const decNumber *,
269 const decNumber *, decContext *,
270 uInt *);
271 static decNumber * decNaNs(decNumber *, const decNumber *,
272 const decNumber *, decContext *, uInt *);
273 static decNumber * decQuantizeOp(decNumber *, const decNumber *,
274 const decNumber *, decContext *, Flag,
275 uInt *);
276 static void decReverse(Unit *, Unit *);
277 static void decSetCoeff(decNumber *, decContext *, const Unit *,
278 Int, Int *, uInt *);
279 static void decSetMaxValue(decNumber *, decContext *);
280 static void decSetOverflow(decNumber *, decContext *, uInt *);
281 static void decSetSubnormal(decNumber *, decContext *, Int *, uInt *);
282 static Int decShiftToLeast(Unit *, Int, Int);
283 static Int decShiftToMost(Unit *, Int, Int);
284 static void decStatus(decNumber *, uInt, decContext *);
285 static void decToString(const decNumber *, char[], Flag);
286 static decNumber * decTrim(decNumber *, decContext *, Flag, Flag, Int *);
287 static Int decUnitAddSub(const Unit *, Int, const Unit *, Int, Int,
288 Unit *, Int);
289 static Int decUnitCompare(const Unit *, Int, const Unit *, Int, Int);
290
291 #if !DECSUBSET
292 /* decFinish == decFinalize when no subset arithmetic needed */
293 #define decFinish(a,b,c,d) decFinalize(a,b,c,d)
294 #else
295 static void decFinish(decNumber *, decContext *, Int *, uInt *);
296 static decNumber * decRoundOperand(const decNumber *, decContext *, uInt *);
297 #endif
298
299 /* Local macros */
300 /* masked special-values bits */
301 #define SPECIALARG (rhs->bits & DECSPECIAL)
302 #define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL)
303
304 /* For use in ICU */
305 #define malloc(a) uprv_malloc(a)
306 #define free(a) uprv_free(a)
307
308 /* Diagnostic macros, etc. */
309 #if DECALLOC
310 /* Handle malloc/free accounting. If enabled, our accountable routines */
311 /* are used; otherwise the code just goes straight to the system malloc */
312 /* and free routines. */
313 #define malloc(a) decMalloc(a)
314 #define free(a) decFree(a)
315 #define DECFENCE 0x5a /* corruption detector */
316 /* 'Our' malloc and free: */
317 static void *decMalloc(size_t);
318 static void decFree(void *);
319 uInt decAllocBytes=0; /* count of bytes allocated */
320 /* Note that DECALLOC code only checks for storage buffer overflow. */
321 /* To check for memory leaks, the decAllocBytes variable must be */
322 /* checked to be 0 at appropriate times (e.g., after the test */
323 /* harness completes a set of tests). This checking may be unreliable */
324 /* if the testing is done in a multi-thread environment. */
325 #endif
326
327 #if DECCHECK
328 /* Optional checking routines. Enabling these means that decNumber */
329 /* and decContext operands to operator routines are checked for */
330 /* correctness. This roughly doubles the execution time of the */
331 /* fastest routines (and adds 600+ bytes), so should not normally be */
332 /* used in 'production'. */
333 /* decCheckInexact is used to check that inexact results have a full */
334 /* complement of digits (where appropriate -- this is not the case */
335 /* for Quantize, for example) */
336 #define DECUNRESU ((decNumber *)(void *)0xffffffff)
337 #define DECUNUSED ((const decNumber *)(void *)0xffffffff)
338 #define DECUNCONT ((decContext *)(void *)(0xffffffff))
339 static Flag decCheckOperands(decNumber *, const decNumber *,
340 const decNumber *, decContext *);
341 static Flag decCheckNumber(const decNumber *);
342 static void decCheckInexact(const decNumber *, decContext *);
343 #endif
344
345 #if DECTRACE || DECCHECK
346 /* Optional trace/debugging routines (may or may not be used) */
347 void decNumberShow(const decNumber *); /* displays the components of a number */
348 static void decDumpAr(char, const Unit *, Int);
349 #endif
350
351 /* ================================================================== */
352 /* Conversions */
353 /* ================================================================== */
354
355 /* ------------------------------------------------------------------ */
356 /* from-int32 -- conversion from Int or uInt */
357 /* */
358 /* dn is the decNumber to receive the integer */
359 /* in or uin is the integer to be converted */
360 /* returns dn */
361 /* */
362 /* No error is possible. */
363 /* ------------------------------------------------------------------ */
364 U_CAPI decNumber * U_EXPORT2 uprv_decNumberFromInt32(decNumber *dn, Int in) {
365 uInt unsig;
366 if (in>=0) unsig=in;
367 else { /* negative (possibly BADINT) */
368 if (in==BADINT) unsig=(uInt)1073741824*2; /* special case */
369 else unsig=-in; /* invert */
370 }
371 /* in is now positive */
372 uprv_decNumberFromUInt32(dn, unsig);
373 if (in<0) dn->bits=DECNEG; /* sign needed */
374 return dn;
375 } /* decNumberFromInt32 */
376
377 U_CAPI decNumber * U_EXPORT2 uprv_decNumberFromUInt32(decNumber *dn, uInt uin) {
378 Unit *up; /* work pointer */
379 uprv_decNumberZero(dn); /* clean */
380 if (uin==0) return dn; /* [or decGetDigits bad call] */
381 for (up=dn->lsu; uin>0; up++) {
382 *up=(Unit)(uin%(DECDPUNMAX+1));
383 uin=uin/(DECDPUNMAX+1);
384 }
385 dn->digits=decGetDigits(dn->lsu, up-dn->lsu);
386 return dn;
387 } /* decNumberFromUInt32 */
388
389 /* ------------------------------------------------------------------ */
390 /* to-int32 -- conversion to Int or uInt */
391 /* */
392 /* dn is the decNumber to convert */
393 /* set is the context for reporting errors */
394 /* returns the converted decNumber, or 0 if Invalid is set */
395 /* */
396 /* Invalid is set if the decNumber does not have exponent==0 or if */
397 /* it is a NaN, Infinite, or out-of-range. */
398 /* ------------------------------------------------------------------ */
399 U_CAPI Int U_EXPORT2 uprv_decNumberToInt32(const decNumber *dn, decContext *set) {
400 #if DECCHECK
401 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
402 #endif
403
404 /* special or too many digits, or bad exponent */
405 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; /* bad */
406 else { /* is a finite integer with 10 or fewer digits */
407 Int d; /* work */
408 const Unit *up; /* .. */
409 uInt hi=0, lo; /* .. */
410 up=dn->lsu; /* -> lsu */
411 lo=*up; /* get 1 to 9 digits */
412 #if DECDPUN>1 /* split to higher */
413 hi=lo/10;
414 lo=lo%10;
415 #endif
416 up++;
417 /* collect remaining Units, if any, into hi */
418 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
419 /* now low has the lsd, hi the remainder */
420 if (hi>214748364 || (hi==214748364 && lo>7)) { /* out of range? */
421 /* most-negative is a reprieve */
422 if (dn->bits&DECNEG && hi==214748364 && lo==8) return 0x80000000;
423 /* bad -- drop through */
424 }
425 else { /* in-range always */
426 Int i=X10(hi)+lo;
427 if (dn->bits&DECNEG) return -i;
428 return i;
429 }
430 } /* integer */
431 uprv_decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
432 return 0;
433 } /* decNumberToInt32 */
434
435 U_CAPI uInt U_EXPORT2 uprv_decNumberToUInt32(const decNumber *dn, decContext *set) {
436 #if DECCHECK
437 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
438 #endif
439 /* special or too many digits, or bad exponent, or negative (<0) */
440 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0
441 || (dn->bits&DECNEG && !ISZERO(dn))); /* bad */
442 else { /* is a finite integer with 10 or fewer digits */
443 Int d; /* work */
444 const Unit *up; /* .. */
445 uInt hi=0, lo; /* .. */
446 up=dn->lsu; /* -> lsu */
447 lo=*up; /* get 1 to 9 digits */
448 #if DECDPUN>1 /* split to higher */
449 hi=lo/10;
450 lo=lo%10;
451 #endif
452 up++;
453 /* collect remaining Units, if any, into hi */
454 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
455
456 /* now low has the lsd, hi the remainder */
457 if (hi>429496729 || (hi==429496729 && lo>5)) ; /* no reprieve possible */
458 else return X10(hi)+lo;
459 } /* integer */
460 uprv_decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
461 return 0;
462 } /* decNumberToUInt32 */
463
464 /* ------------------------------------------------------------------ */
465 /* to-scientific-string -- conversion to numeric string */
466 /* to-engineering-string -- conversion to numeric string */
467 /* */
468 /* decNumberToString(dn, string); */
469 /* decNumberToEngString(dn, string); */
470 /* */
471 /* dn is the decNumber to convert */
472 /* string is the string where the result will be laid out */
473 /* */
474 /* string must be at least dn->digits+14 characters long */
475 /* */
476 /* No error is possible, and no status can be set. */
477 /* ------------------------------------------------------------------ */
478 U_CAPI char * U_EXPORT2 uprv_decNumberToString(const decNumber *dn, char *string){
479 decToString(dn, string, 0);
480 return string;
481 } /* DecNumberToString */
482
483 U_CAPI char * U_EXPORT2 uprv_decNumberToEngString(const decNumber *dn, char *string){
484 decToString(dn, string, 1);
485 return string;
486 } /* DecNumberToEngString */
487
488 /* ------------------------------------------------------------------ */
489 /* to-number -- conversion from numeric string */
490 /* */
491 /* decNumberFromString -- convert string to decNumber */
492 /* dn -- the number structure to fill */
493 /* chars[] -- the string to convert ('\0' terminated) */
494 /* set -- the context used for processing any error, */
495 /* determining the maximum precision available */
496 /* (set.digits), determining the maximum and minimum */
497 /* exponent (set.emax and set.emin), determining if */
498 /* extended values are allowed, and checking the */
499 /* rounding mode if overflow occurs or rounding is */
500 /* needed. */
501 /* */
502 /* The length of the coefficient and the size of the exponent are */
503 /* checked by this routine, so the correct error (Underflow or */
504 /* Overflow) can be reported or rounding applied, as necessary. */
505 /* */
506 /* If bad syntax is detected, the result will be a quiet NaN. */
507 /* ------------------------------------------------------------------ */
508 U_CAPI decNumber * U_EXPORT2 uprv_decNumberFromString(decNumber *dn, const char chars[],
509 decContext *set) {
510 Int exponent=0; /* working exponent [assume 0] */
511 uByte bits=0; /* working flags [assume +ve] */
512 Unit *res; /* where result will be built */
513 Unit resbuff[SD2U(DECBUFFER+9)];/* local buffer in case need temporary */
514 /* [+9 allows for ln() constants] */
515 Unit *allocres=NULL; /* -> allocated result, iff allocated */
516 Int d=0; /* count of digits found in decimal part */
517 const char *dotchar=NULL; /* where dot was found */
518 const char *cfirst=chars; /* -> first character of decimal part */
519 const char *last=NULL; /* -> last digit of decimal part */
520 const char *c; /* work */
521 Unit *up; /* .. */
522 #if DECDPUN>1
523 Int cut, out; /* .. */
524 #endif
525 Int residue; /* rounding residue */
526 uInt status=0; /* error code */
527
528 #if DECCHECK
529 if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set))
530 return uprv_decNumberZero(dn);
531 #endif
532
533 do { /* status & malloc protection */
534 for (c=chars;; c++) { /* -> input character */
535 if (*c>='0' && *c<='9') { /* test for Arabic digit */
536 last=c;
537 d++; /* count of real digits */
538 continue; /* still in decimal part */
539 }
540 if (*c=='.' && dotchar==NULL) { /* first '.' */
541 dotchar=c; /* record offset into decimal part */
542 if (c==cfirst) cfirst++; /* first digit must follow */
543 continue;}
544 if (c==chars) { /* first in string... */
545 if (*c=='-') { /* valid - sign */
546 cfirst++;
547 bits=DECNEG;
548 continue;}
549 if (*c=='+') { /* valid + sign */
550 cfirst++;
551 continue;}
552 }
553 /* *c is not a digit, or a valid +, -, or '.' */
554 break;
555 } /* c */
556
557 if (last==NULL) { /* no digits yet */
558 status=DEC_Conversion_syntax;/* assume the worst */
559 if (*c=='\0') break; /* and no more to come... */
560 #if DECSUBSET
561 /* if subset then infinities and NaNs are not allowed */
562 if (!set->extended) break; /* hopeless */
563 #endif
564 /* Infinities and NaNs are possible, here */
565 if (dotchar!=NULL) break; /* .. unless had a dot */
566 uprv_decNumberZero(dn); /* be optimistic */
567 if (decBiStr(c, "infinity", "INFINITY")
568 || decBiStr(c, "inf", "INF")) {
569 dn->bits=bits | DECINF;
570 status=0; /* is OK */
571 break; /* all done */
572 }
573 /* a NaN expected */
574 /* 2003.09.10 NaNs are now permitted to have a sign */
575 dn->bits=bits | DECNAN; /* assume simple NaN */
576 if (*c=='s' || *c=='S') { /* looks like an sNaN */
577 c++;
578 dn->bits=bits | DECSNAN;
579 }
580 if (*c!='n' && *c!='N') break; /* check caseless "NaN" */
581 c++;
582 if (*c!='a' && *c!='A') break; /* .. */
583 c++;
584 if (*c!='n' && *c!='N') break; /* .. */
585 c++;
586 /* now either nothing, or nnnn payload, expected */
587 /* -> start of integer and skip leading 0s [including plain 0] */
588 for (cfirst=c; *cfirst=='0';) cfirst++;
589 if (*cfirst=='\0') { /* "NaN" or "sNaN", maybe with all 0s */
590 status=0; /* it's good */
591 break; /* .. */
592 }
593 /* something other than 0s; setup last and d as usual [no dots] */
594 for (c=cfirst;; c++, d++) {
595 if (*c<'0' || *c>'9') break; /* test for Arabic digit */
596 last=c;
597 }
598 if (*c!='\0') break; /* not all digits */
599 if (d>set->digits-1) {
600 /* [NB: payload in a decNumber can be full length unless */
601 /* clamped, in which case can only be digits-1] */
602 if (set->clamp) break;
603 if (d>set->digits) break;
604 } /* too many digits? */
605 /* good; drop through to convert the integer to coefficient */
606 status=0; /* syntax is OK */
607 bits=dn->bits; /* for copy-back */
608 } /* last==NULL */
609
610 else if (*c!='\0') { /* more to process... */
611 /* had some digits; exponent is only valid sequence now */
612 Flag nege; /* 1=negative exponent */
613 const char *firstexp; /* -> first significant exponent digit */
614 status=DEC_Conversion_syntax;/* assume the worst */
615 if (*c!='e' && *c!='E') break;
616 /* Found 'e' or 'E' -- now process explicit exponent */
617 /* 1998.07.11: sign no longer required */
618 nege=0;
619 c++; /* to (possible) sign */
620 if (*c=='-') {nege=1; c++;}
621 else if (*c=='+') c++;
622 if (*c=='\0') break;
623
624 for (; *c=='0' && *(c+1)!='\0';) c++; /* strip insignificant zeros */
625 firstexp=c; /* save exponent digit place */
626 for (; ;c++) {
627 if (*c<'0' || *c>'9') break; /* not a digit */
628 exponent=X10(exponent)+(Int)*c-(Int)'0';
629 } /* c */
630 /* if not now on a '\0', *c must not be a digit */
631 if (*c!='\0') break;
632
633 /* (this next test must be after the syntax checks) */
634 /* if it was too long the exponent may have wrapped, so check */
635 /* carefully and set it to a certain overflow if wrap possible */
636 if (c>=firstexp+9+1) {
637 if (c>firstexp+9+1 || *firstexp>'1') exponent=DECNUMMAXE*2;
638 /* [up to 1999999999 is OK, for example 1E-1000000998] */
639 }
640 if (nege) exponent=-exponent; /* was negative */
641 status=0; /* is OK */
642 } /* stuff after digits */
643
644 /* Here when whole string has been inspected; syntax is good */
645 /* cfirst->first digit (never dot), last->last digit (ditto) */
646
647 /* strip leading zeros/dot [leave final 0 if all 0's] */
648 if (*cfirst=='0') { /* [cfirst has stepped over .] */
649 for (c=cfirst; c<last; c++, cfirst++) {
650 if (*c=='.') continue; /* ignore dots */
651 if (*c!='0') break; /* non-zero found */
652 d--; /* 0 stripped */
653 } /* c */
654 #if DECSUBSET
655 /* make a rapid exit for easy zeros if !extended */
656 if (*cfirst=='0' && !set->extended) {
657 uprv_decNumberZero(dn); /* clean result */
658 break; /* [could be return] */
659 }
660 #endif
661 } /* at least one leading 0 */
662
663 /* Handle decimal point... */
664 if (dotchar!=NULL && dotchar<last) /* non-trailing '.' found? */
665 exponent-=(last-dotchar); /* adjust exponent */
666 /* [we can now ignore the .] */
667
668 /* OK, the digits string is good. Assemble in the decNumber, or in */
669 /* a temporary units array if rounding is needed */
670 if (d<=set->digits) res=dn->lsu; /* fits into supplied decNumber */
671 else { /* rounding needed */
672 Int needbytes=D2U(d)*sizeof(Unit);/* bytes needed */
673 res=resbuff; /* assume use local buffer */
674 if (needbytes>(Int)sizeof(resbuff)) { /* too big for local */
675 allocres=(Unit *)malloc(needbytes);
676 if (allocres==NULL) {status|=DEC_Insufficient_storage; break;}
677 res=allocres;
678 }
679 }
680 /* res now -> number lsu, buffer, or allocated storage for Unit array */
681
682 /* Place the coefficient into the selected Unit array */
683 /* [this is often 70% of the cost of this function when DECDPUN>1] */
684 #if DECDPUN>1
685 out=0; /* accumulator */
686 up=res+D2U(d)-1; /* -> msu */
687 cut=d-(up-res)*DECDPUN; /* digits in top unit */
688 for (c=cfirst;; c++) { /* along the digits */
689 if (*c=='.') continue; /* ignore '.' [don't decrement cut] */
690 out=X10(out)+(Int)*c-(Int)'0';
691 if (c==last) break; /* done [never get to trailing '.'] */
692 cut--;
693 if (cut>0) continue; /* more for this unit */
694 *up=(Unit)out; /* write unit */
695 up--; /* prepare for unit below.. */
696 cut=DECDPUN; /* .. */
697 out=0; /* .. */
698 } /* c */
699 *up=(Unit)out; /* write lsu */
700
701 #else
702 /* DECDPUN==1 */
703 up=res; /* -> lsu */
704 for (c=last; c>=cfirst; c--) { /* over each character, from least */
705 if (*c=='.') continue; /* ignore . [don't step up] */
706 *up=(Unit)((Int)*c-(Int)'0');
707 up++;
708 } /* c */
709 #endif
710
711 dn->bits=bits;
712 dn->exponent=exponent;
713 dn->digits=d;
714
715 /* if not in number (too long) shorten into the number */
716 if (d>set->digits) {
717 residue=0;
718 decSetCoeff(dn, set, res, d, &residue, &status);
719 /* always check for overflow or subnormal and round as needed */
720 decFinalize(dn, set, &residue, &status);
721 }
722 else { /* no rounding, but may still have overflow or subnormal */
723 /* [these tests are just for performance; finalize repeats them] */
724 if ((dn->exponent-1<set->emin-dn->digits)
725 || (dn->exponent-1>set->emax-set->digits)) {
726 residue=0;
727 decFinalize(dn, set, &residue, &status);
728 }
729 }
730 /* decNumberShow(dn); */
731 } while(0); /* [for break] */
732
733 if (allocres!=NULL) free(allocres); /* drop any storage used */
734 if (status!=0) decStatus(dn, status, set);
735 return dn;
736 } /* decNumberFromString */
737
738 /* ================================================================== */
739 /* Operators */
740 /* ================================================================== */
741
742 /* ------------------------------------------------------------------ */
743 /* decNumberAbs -- absolute value operator */
744 /* */
745 /* This computes C = abs(A) */
746 /* */
747 /* res is C, the result. C may be A */
748 /* rhs is A */
749 /* set is the context */
750 /* */
751 /* See also decNumberCopyAbs for a quiet bitwise version of this. */
752 /* C must have space for set->digits digits. */
753 /* ------------------------------------------------------------------ */
754 /* This has the same effect as decNumberPlus unless A is negative, */
755 /* in which case it has the same effect as decNumberMinus. */
756 /* ------------------------------------------------------------------ */
757 U_CAPI decNumber * U_EXPORT2 uprv_decNumberAbs(decNumber *res, const decNumber *rhs,
758 decContext *set) {
759 decNumber dzero; /* for 0 */
760 uInt status=0; /* accumulator */
761
762 #if DECCHECK
763 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
764 #endif
765
766 uprv_decNumberZero(&dzero); /* set 0 */
767 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */
768 decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status);
769 if (status!=0) decStatus(res, status, set);
770 #if DECCHECK
771 decCheckInexact(res, set);
772 #endif
773 return res;
774 } /* decNumberAbs */
775
776 /* ------------------------------------------------------------------ */
777 /* decNumberAdd -- add two Numbers */
778 /* */
779 /* This computes C = A + B */
780 /* */
781 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */
782 /* lhs is A */
783 /* rhs is B */
784 /* set is the context */
785 /* */
786 /* C must have space for set->digits digits. */
787 /* ------------------------------------------------------------------ */
788 /* This just calls the routine shared with Subtract */
789 U_CAPI decNumber * U_EXPORT2 uprv_decNumberAdd(decNumber *res, const decNumber *lhs,
790 const decNumber *rhs, decContext *set) {
791 uInt status=0; /* accumulator */
792 decAddOp(res, lhs, rhs, set, 0, &status);
793 if (status!=0) decStatus(res, status, set);
794 #if DECCHECK
795 decCheckInexact(res, set);
796 #endif
797 return res;
798 } /* decNumberAdd */
799
800 /* ------------------------------------------------------------------ */
801 /* decNumberAnd -- AND two Numbers, digitwise */
802 /* */
803 /* This computes C = A & B */
804 /* */
805 /* res is C, the result. C may be A and/or B (e.g., X=X&X) */
806 /* lhs is A */
807 /* rhs is B */
808 /* set is the context (used for result length and error report) */
809 /* */
810 /* C must have space for set->digits digits. */
811 /* */
812 /* Logical function restrictions apply (see above); a NaN is */
813 /* returned with Invalid_operation if a restriction is violated. */
814 /* ------------------------------------------------------------------ */
815 U_CAPI decNumber * U_EXPORT2 uprv_decNumberAnd(decNumber *res, const decNumber *lhs,
816 const decNumber *rhs, decContext *set) {
817 const Unit *ua, *ub; /* -> operands */
818 const Unit *msua, *msub; /* -> operand msus */
819 Unit *uc, *msuc; /* -> result and its msu */
820 Int msudigs; /* digits in res msu */
821 #if DECCHECK
822 if (decCheckOperands(res, lhs, rhs, set)) return res;
823 #endif
824
825 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
826 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
827 decStatus(res, DEC_Invalid_operation, set);
828 return res;
829 }
830
831 /* operands are valid */
832 ua=lhs->lsu; /* bottom-up */
833 ub=rhs->lsu; /* .. */
834 uc=res->lsu; /* .. */
835 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */
836 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */
837 msuc=uc+D2U(set->digits)-1; /* -> msu of result */
838 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */
839 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */
840 Unit a, b; /* extract units */
841 if (ua>msua) a=0;
842 else a=*ua;
843 if (ub>msub) b=0;
844 else b=*ub;
845 *uc=0; /* can now write back */
846 if (a|b) { /* maybe 1 bits to examine */
847 Int i, j;
848 *uc=0; /* can now write back */
849 /* This loop could be unrolled and/or use BIN2BCD tables */
850 for (i=0; i<DECDPUN; i++) {
851 if (a&b&1) *uc=*uc+(Unit)powers[i]; /* effect AND */
852 j=a%10;
853 a=a/10;
854 j|=b%10;
855 b=b/10;
856 if (j>1) {
857 decStatus(res, DEC_Invalid_operation, set);
858 return res;
859 }
860 if (uc==msuc && i==msudigs-1) break; /* just did final digit */
861 } /* each digit */
862 } /* both OK */
863 } /* each unit */
864 /* [here uc-1 is the msu of the result] */
865 res->digits=decGetDigits(res->lsu, uc-res->lsu);
866 res->exponent=0; /* integer */
867 res->bits=0; /* sign=0 */
868 return res; /* [no status to set] */
869 } /* decNumberAnd */
870
871 /* ------------------------------------------------------------------ */
872 /* decNumberCompare -- compare two Numbers */
873 /* */
874 /* This computes C = A ? B */
875 /* */
876 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
877 /* lhs is A */
878 /* rhs is B */
879 /* set is the context */
880 /* */
881 /* C must have space for one digit (or NaN). */
882 /* ------------------------------------------------------------------ */
883 U_CAPI decNumber * U_EXPORT2 uprv_decNumberCompare(decNumber *res, const decNumber *lhs,
884 const decNumber *rhs, decContext *set) {
885 uInt status=0; /* accumulator */
886 decCompareOp(res, lhs, rhs, set, COMPARE, &status);
887 if (status!=0) decStatus(res, status, set);
888 return res;
889 } /* decNumberCompare */
890
891 /* ------------------------------------------------------------------ */
892 /* decNumberCompareSignal -- compare, signalling on all NaNs */
893 /* */
894 /* This computes C = A ? B */
895 /* */
896 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
897 /* lhs is A */
898 /* rhs is B */
899 /* set is the context */
900 /* */
901 /* C must have space for one digit (or NaN). */
902 /* ------------------------------------------------------------------ */
903 U_CAPI decNumber * U_EXPORT2 uprv_decNumberCompareSignal(decNumber *res, const decNumber *lhs,
904 const decNumber *rhs, decContext *set) {
905 uInt status=0; /* accumulator */
906 decCompareOp(res, lhs, rhs, set, COMPSIG, &status);
907 if (status!=0) decStatus(res, status, set);
908 return res;
909 } /* decNumberCompareSignal */
910
911 /* ------------------------------------------------------------------ */
912 /* decNumberCompareTotal -- compare two Numbers, using total ordering */
913 /* */
914 /* This computes C = A ? B, under total ordering */
915 /* */
916 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
917 /* lhs is A */
918 /* rhs is B */
919 /* set is the context */
920 /* */
921 /* C must have space for one digit; the result will always be one of */
922 /* -1, 0, or 1. */
923 /* ------------------------------------------------------------------ */
924 U_CAPI decNumber * U_EXPORT2 uprv_decNumberCompareTotal(decNumber *res, const decNumber *lhs,
925 const decNumber *rhs, decContext *set) {
926 uInt status=0; /* accumulator */
927 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
928 if (status!=0) decStatus(res, status, set);
929 return res;
930 } /* decNumberCompareTotal */
931
932 /* ------------------------------------------------------------------ */
933 /* decNumberCompareTotalMag -- compare, total ordering of magnitudes */
934 /* */
935 /* This computes C = |A| ? |B|, under total ordering */
936 /* */
937 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
938 /* lhs is A */
939 /* rhs is B */
940 /* set is the context */
941 /* */
942 /* C must have space for one digit; the result will always be one of */
943 /* -1, 0, or 1. */
944 /* ------------------------------------------------------------------ */
945 U_CAPI decNumber * U_EXPORT2 uprv_decNumberCompareTotalMag(decNumber *res, const decNumber *lhs,
946 const decNumber *rhs, decContext *set) {
947 uInt status=0; /* accumulator */
948 uInt needbytes; /* for space calculations */
949 decNumber bufa[D2N(DECBUFFER+1)];/* +1 in case DECBUFFER=0 */
950 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
951 decNumber bufb[D2N(DECBUFFER+1)];
952 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */
953 decNumber *a, *b; /* temporary pointers */
954
955 #if DECCHECK
956 if (decCheckOperands(res, lhs, rhs, set)) return res;
957 #endif
958
959 do { /* protect allocated storage */
960 /* if either is negative, take a copy and absolute */
961 if (decNumberIsNegative(lhs)) { /* lhs<0 */
962 a=bufa;
963 needbytes=sizeof(decNumber)+(D2U(lhs->digits)-1)*sizeof(Unit);
964 if (needbytes>sizeof(bufa)) { /* need malloc space */
965 allocbufa=(decNumber *)malloc(needbytes);
966 if (allocbufa==NULL) { /* hopeless -- abandon */
967 status|=DEC_Insufficient_storage;
968 break;}
969 a=allocbufa; /* use the allocated space */
970 }
971 uprv_decNumberCopy(a, lhs); /* copy content */
972 a->bits&=~DECNEG; /* .. and clear the sign */
973 lhs=a; /* use copy from here on */
974 }
975 if (decNumberIsNegative(rhs)) { /* rhs<0 */
976 b=bufb;
977 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
978 if (needbytes>sizeof(bufb)) { /* need malloc space */
979 allocbufb=(decNumber *)malloc(needbytes);
980 if (allocbufb==NULL) { /* hopeless -- abandon */
981 status|=DEC_Insufficient_storage;
982 break;}
983 b=allocbufb; /* use the allocated space */
984 }
985 uprv_decNumberCopy(b, rhs); /* copy content */
986 b->bits&=~DECNEG; /* .. and clear the sign */
987 rhs=b; /* use copy from here on */
988 }
989 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
990 } while(0); /* end protected */
991
992 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
993 if (allocbufb!=NULL) free(allocbufb); /* .. */
994 if (status!=0) decStatus(res, status, set);
995 return res;
996 } /* decNumberCompareTotalMag */
997
998 /* ------------------------------------------------------------------ */
999 /* decNumberDivide -- divide one number by another */
1000 /* */
1001 /* This computes C = A / B */
1002 /* */
1003 /* res is C, the result. C may be A and/or B (e.g., X=X/X) */
1004 /* lhs is A */
1005 /* rhs is B */
1006 /* set is the context */
1007 /* */
1008 /* C must have space for set->digits digits. */
1009 /* ------------------------------------------------------------------ */
1010 U_CAPI decNumber * U_EXPORT2 uprv_decNumberDivide(decNumber *res, const decNumber *lhs,
1011 const decNumber *rhs, decContext *set) {
1012 uInt status=0; /* accumulator */
1013 decDivideOp(res, lhs, rhs, set, DIVIDE, &status);
1014 if (status!=0) decStatus(res, status, set);
1015 #if DECCHECK
1016 decCheckInexact(res, set);
1017 #endif
1018 return res;
1019 } /* decNumberDivide */
1020
1021 /* ------------------------------------------------------------------ */
1022 /* decNumberDivideInteger -- divide and return integer quotient */
1023 /* */
1024 /* This computes C = A # B, where # is the integer divide operator */
1025 /* */
1026 /* res is C, the result. C may be A and/or B (e.g., X=X#X) */
1027 /* lhs is A */
1028 /* rhs is B */
1029 /* set is the context */
1030 /* */
1031 /* C must have space for set->digits digits. */
1032 /* ------------------------------------------------------------------ */
1033 U_CAPI decNumber * U_EXPORT2 uprv_decNumberDivideInteger(decNumber *res, const decNumber *lhs,
1034 const decNumber *rhs, decContext *set) {
1035 uInt status=0; /* accumulator */
1036 decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status);
1037 if (status!=0) decStatus(res, status, set);
1038 return res;
1039 } /* decNumberDivideInteger */
1040
1041 /* ------------------------------------------------------------------ */
1042 /* decNumberExp -- exponentiation */
1043 /* */
1044 /* This computes C = exp(A) */
1045 /* */
1046 /* res is C, the result. C may be A */
1047 /* rhs is A */
1048 /* set is the context; note that rounding mode has no effect */
1049 /* */
1050 /* C must have space for set->digits digits. */
1051 /* */
1052 /* Mathematical function restrictions apply (see above); a NaN is */
1053 /* returned with Invalid_operation if a restriction is violated. */
1054 /* */
1055 /* Finite results will always be full precision and Inexact, except */
1056 /* when A is a zero or -Infinity (giving 1 or 0 respectively). */
1057 /* */
1058 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */
1059 /* almost always be correctly rounded, but may be up to 1 ulp in */
1060 /* error in rare cases. */
1061 /* ------------------------------------------------------------------ */
1062 /* This is a wrapper for decExpOp which can handle the slightly wider */
1063 /* (double) range needed by Ln (which has to be able to calculate */
1064 /* exp(-a) where a can be the tiniest number (Ntiny). */
1065 /* ------------------------------------------------------------------ */
1066 U_CAPI decNumber * U_EXPORT2 uprv_decNumberExp(decNumber *res, const decNumber *rhs,
1067 decContext *set) {
1068 uInt status=0; /* accumulator */
1069 #if DECSUBSET
1070 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
1071 #endif
1072
1073 #if DECCHECK
1074 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1075 #endif
1076
1077 /* Check restrictions; these restrictions ensure that if h=8 (see */
1078 /* decExpOp) then the result will either overflow or underflow to 0. */
1079 /* Other math functions restrict the input range, too, for inverses. */
1080 /* If not violated then carry out the operation. */
1081 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1082 #if DECSUBSET
1083 if (!set->extended) {
1084 /* reduce operand and set lostDigits status, as needed */
1085 if (rhs->digits>set->digits) {
1086 allocrhs=decRoundOperand(rhs, set, &status);
1087 if (allocrhs==NULL) break;
1088 rhs=allocrhs;
1089 }
1090 }
1091 #endif
1092 decExpOp(res, rhs, set, &status);
1093 } while(0); /* end protected */
1094
1095 #if DECSUBSET
1096 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */
1097 #endif
1098 /* apply significant status */
1099 if (status!=0) decStatus(res, status, set);
1100 #if DECCHECK
1101 decCheckInexact(res, set);
1102 #endif
1103 return res;
1104 } /* decNumberExp */
1105
1106 /* ------------------------------------------------------------------ */
1107 /* decNumberFMA -- fused multiply add */
1108 /* */
1109 /* This computes D = (A * B) + C with only one rounding */
1110 /* */
1111 /* res is D, the result. D may be A or B or C (e.g., X=FMA(X,X,X)) */
1112 /* lhs is A */
1113 /* rhs is B */
1114 /* fhs is C [far hand side] */
1115 /* set is the context */
1116 /* */
1117 /* Mathematical function restrictions apply (see above); a NaN is */
1118 /* returned with Invalid_operation if a restriction is violated. */
1119 /* */
1120 /* C must have space for set->digits digits. */
1121 /* ------------------------------------------------------------------ */
1122 U_CAPI decNumber * U_EXPORT2 uprv_decNumberFMA(decNumber *res, const decNumber *lhs,
1123 const decNumber *rhs, const decNumber *fhs,
1124 decContext *set) {
1125 uInt status=0; /* accumulator */
1126 decContext dcmul; /* context for the multiplication */
1127 uInt needbytes; /* for space calculations */
1128 decNumber bufa[D2N(DECBUFFER*2+1)];
1129 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
1130 decNumber *acc; /* accumulator pointer */
1131 decNumber dzero; /* work */
1132
1133 #if DECCHECK
1134 if (decCheckOperands(res, lhs, rhs, set)) return res;
1135 if (decCheckOperands(res, fhs, DECUNUSED, set)) return res;
1136 #endif
1137
1138 do { /* protect allocated storage */
1139 #if DECSUBSET
1140 if (!set->extended) { /* [undefined if subset] */
1141 status|=DEC_Invalid_operation;
1142 break;}
1143 #endif
1144 /* Check math restrictions [these ensure no overflow or underflow] */
1145 if ((!decNumberIsSpecial(lhs) && decCheckMath(lhs, set, &status))
1146 || (!decNumberIsSpecial(rhs) && decCheckMath(rhs, set, &status))
1147 || (!decNumberIsSpecial(fhs) && decCheckMath(fhs, set, &status))) break;
1148 /* set up context for multiply */
1149 dcmul=*set;
1150 dcmul.digits=lhs->digits+rhs->digits; /* just enough */
1151 /* [The above may be an over-estimate for subset arithmetic, but that's OK] */
1152 dcmul.emax=DEC_MAX_EMAX; /* effectively unbounded .. */
1153 dcmul.emin=DEC_MIN_EMIN; /* [thanks to Math restrictions] */
1154 /* set up decNumber space to receive the result of the multiply */
1155 acc=bufa; /* may fit */
1156 needbytes=sizeof(decNumber)+(D2U(dcmul.digits)-1)*sizeof(Unit);
1157 if (needbytes>sizeof(bufa)) { /* need malloc space */
1158 allocbufa=(decNumber *)malloc(needbytes);
1159 if (allocbufa==NULL) { /* hopeless -- abandon */
1160 status|=DEC_Insufficient_storage;
1161 break;}
1162 acc=allocbufa; /* use the allocated space */
1163 }
1164 /* multiply with extended range and necessary precision */
1165 /*printf("emin=%ld\n", dcmul.emin); */
1166 decMultiplyOp(acc, lhs, rhs, &dcmul, &status);
1167 /* Only Invalid operation (from sNaN or Inf * 0) is possible in */
1168 /* status; if either is seen than ignore fhs (in case it is */
1169 /* another sNaN) and set acc to NaN unless we had an sNaN */
1170 /* [decMultiplyOp leaves that to caller] */
1171 /* Note sNaN has to go through addOp to shorten payload if */
1172 /* necessary */
1173 if ((status&DEC_Invalid_operation)!=0) {
1174 if (!(status&DEC_sNaN)) { /* but be true invalid */
1175 uprv_decNumberZero(res); /* acc not yet set */
1176 res->bits=DECNAN;
1177 break;
1178 }
1179 uprv_decNumberZero(&dzero); /* make 0 (any non-NaN would do) */
1180 fhs=&dzero; /* use that */
1181 }
1182 #if DECCHECK
1183 else { /* multiply was OK */
1184 if (status!=0) printf("Status=%08lx after FMA multiply\n", (LI)status);
1185 }
1186 #endif
1187 /* add the third operand and result -> res, and all is done */
1188 decAddOp(res, acc, fhs, set, 0, &status);
1189 } while(0); /* end protected */
1190
1191 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
1192 if (status!=0) decStatus(res, status, set);
1193 #if DECCHECK
1194 decCheckInexact(res, set);
1195 #endif
1196 return res;
1197 } /* decNumberFMA */
1198
1199 /* ------------------------------------------------------------------ */
1200 /* decNumberInvert -- invert a Number, digitwise */
1201 /* */
1202 /* This computes C = ~A */
1203 /* */
1204 /* res is C, the result. C may be A (e.g., X=~X) */
1205 /* rhs is A */
1206 /* set is the context (used for result length and error report) */
1207 /* */
1208 /* C must have space for set->digits digits. */
1209 /* */
1210 /* Logical function restrictions apply (see above); a NaN is */
1211 /* returned with Invalid_operation if a restriction is violated. */
1212 /* ------------------------------------------------------------------ */
1213 U_CAPI decNumber * U_EXPORT2 uprv_decNumberInvert(decNumber *res, const decNumber *rhs,
1214 decContext *set) {
1215 const Unit *ua, *msua; /* -> operand and its msu */
1216 Unit *uc, *msuc; /* -> result and its msu */
1217 Int msudigs; /* digits in res msu */
1218 #if DECCHECK
1219 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1220 #endif
1221
1222 if (rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1223 decStatus(res, DEC_Invalid_operation, set);
1224 return res;
1225 }
1226 /* operand is valid */
1227 ua=rhs->lsu; /* bottom-up */
1228 uc=res->lsu; /* .. */
1229 msua=ua+D2U(rhs->digits)-1; /* -> msu of rhs */
1230 msuc=uc+D2U(set->digits)-1; /* -> msu of result */
1231 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */
1232 for (; uc<=msuc; ua++, uc++) { /* Unit loop */
1233 Unit a; /* extract unit */
1234 Int i, j; /* work */
1235 if (ua>msua) a=0;
1236 else a=*ua;
1237 *uc=0; /* can now write back */
1238 /* always need to examine all bits in rhs */
1239 /* This loop could be unrolled and/or use BIN2BCD tables */
1240 for (i=0; i<DECDPUN; i++) {
1241 if ((~a)&1) *uc=*uc+(Unit)powers[i]; /* effect INVERT */
1242 j=a%10;
1243 a=a/10;
1244 if (j>1) {
1245 decStatus(res, DEC_Invalid_operation, set);
1246 return res;
1247 }
1248 if (uc==msuc && i==msudigs-1) break; /* just did final digit */
1249 } /* each digit */
1250 } /* each unit */
1251 /* [here uc-1 is the msu of the result] */
1252 res->digits=decGetDigits(res->lsu, uc-res->lsu);
1253 res->exponent=0; /* integer */
1254 res->bits=0; /* sign=0 */
1255 return res; /* [no status to set] */
1256 } /* decNumberInvert */
1257
1258 /* ------------------------------------------------------------------ */
1259 /* decNumberLn -- natural logarithm */
1260 /* */
1261 /* This computes C = ln(A) */
1262 /* */
1263 /* res is C, the result. C may be A */
1264 /* rhs is A */
1265 /* set is the context; note that rounding mode has no effect */
1266 /* */
1267 /* C must have space for set->digits digits. */
1268 /* */
1269 /* Notable cases: */
1270 /* A<0 -> Invalid */
1271 /* A=0 -> -Infinity (Exact) */
1272 /* A=+Infinity -> +Infinity (Exact) */
1273 /* A=1 exactly -> 0 (Exact) */
1274 /* */
1275 /* Mathematical function restrictions apply (see above); a NaN is */
1276 /* returned with Invalid_operation if a restriction is violated. */
1277 /* */
1278 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */
1279 /* almost always be correctly rounded, but may be up to 1 ulp in */
1280 /* error in rare cases. */
1281 /* ------------------------------------------------------------------ */
1282 /* This is a wrapper for decLnOp which can handle the slightly wider */
1283 /* (+11) range needed by Ln, Log10, etc. (which may have to be able */
1284 /* to calculate at p+e+2). */
1285 /* ------------------------------------------------------------------ */
1286 U_CAPI decNumber * U_EXPORT2 uprv_decNumberLn(decNumber *res, const decNumber *rhs,
1287 decContext *set) {
1288 uInt status=0; /* accumulator */
1289 #if DECSUBSET
1290 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
1291 #endif
1292
1293 #if DECCHECK
1294 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1295 #endif
1296
1297 /* Check restrictions; this is a math function; if not violated */
1298 /* then carry out the operation. */
1299 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1300 #if DECSUBSET
1301 if (!set->extended) {
1302 /* reduce operand and set lostDigits status, as needed */
1303 if (rhs->digits>set->digits) {
1304 allocrhs=decRoundOperand(rhs, set, &status);
1305 if (allocrhs==NULL) break;
1306 rhs=allocrhs;
1307 }
1308 /* special check in subset for rhs=0 */
1309 if (ISZERO(rhs)) { /* +/- zeros -> error */
1310 status|=DEC_Invalid_operation;
1311 break;}
1312 } /* extended=0 */
1313 #endif
1314 decLnOp(res, rhs, set, &status);
1315 } while(0); /* end protected */
1316
1317 #if DECSUBSET
1318 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */
1319 #endif
1320 /* apply significant status */
1321 if (status!=0) decStatus(res, status, set);
1322 #if DECCHECK
1323 decCheckInexact(res, set);
1324 #endif
1325 return res;
1326 } /* decNumberLn */
1327
1328 /* ------------------------------------------------------------------ */
1329 /* decNumberLogB - get adjusted exponent, by 754 rules */
1330 /* */
1331 /* This computes C = adjustedexponent(A) */
1332 /* */
1333 /* res is C, the result. C may be A */
1334 /* rhs is A */
1335 /* set is the context, used only for digits and status */
1336 /* */
1337 /* C must have space for 10 digits (A might have 10**9 digits and */
1338 /* an exponent of +999999999, or one digit and an exponent of */
1339 /* -1999999999). */
1340 /* */
1341 /* This returns the adjusted exponent of A after (in theory) padding */
1342 /* with zeros on the right to set->digits digits while keeping the */
1343 /* same value. The exponent is not limited by emin/emax. */
1344 /* */
1345 /* Notable cases: */
1346 /* A<0 -> Use |A| */
1347 /* A=0 -> -Infinity (Division by zero) */
1348 /* A=Infinite -> +Infinity (Exact) */
1349 /* A=1 exactly -> 0 (Exact) */
1350 /* NaNs are propagated as usual */
1351 /* ------------------------------------------------------------------ */
1352 U_CAPI decNumber * U_EXPORT2 uprv_decNumberLogB(decNumber *res, const decNumber *rhs,
1353 decContext *set) {
1354 uInt status=0; /* accumulator */
1355
1356 #if DECCHECK
1357 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1358 #endif
1359
1360 /* NaNs as usual; Infinities return +Infinity; 0->oops */
1361 if (decNumberIsNaN(rhs)) decNaNs(res, rhs, NULL, set, &status);
1362 else if (decNumberIsInfinite(rhs)) uprv_decNumberCopyAbs(res, rhs);
1363 else if (decNumberIsZero(rhs)) {
1364 uprv_decNumberZero(res); /* prepare for Infinity */
1365 res->bits=DECNEG|DECINF; /* -Infinity */
1366 status|=DEC_Division_by_zero; /* as per 754 */
1367 }
1368 else { /* finite non-zero */
1369 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */
1370 uprv_decNumberFromInt32(res, ae); /* lay it out */
1371 }
1372
1373 if (status!=0) decStatus(res, status, set);
1374 return res;
1375 } /* decNumberLogB */
1376
1377 /* ------------------------------------------------------------------ */
1378 /* decNumberLog10 -- logarithm in base 10 */
1379 /* */
1380 /* This computes C = log10(A) */
1381 /* */
1382 /* res is C, the result. C may be A */
1383 /* rhs is A */
1384 /* set is the context; note that rounding mode has no effect */
1385 /* */
1386 /* C must have space for set->digits digits. */
1387 /* */
1388 /* Notable cases: */
1389 /* A<0 -> Invalid */
1390 /* A=0 -> -Infinity (Exact) */
1391 /* A=+Infinity -> +Infinity (Exact) */
1392 /* A=10**n (if n is an integer) -> n (Exact) */
1393 /* */
1394 /* Mathematical function restrictions apply (see above); a NaN is */
1395 /* returned with Invalid_operation if a restriction is violated. */
1396 /* */
1397 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */
1398 /* almost always be correctly rounded, but may be up to 1 ulp in */
1399 /* error in rare cases. */
1400 /* ------------------------------------------------------------------ */
1401 /* This calculates ln(A)/ln(10) using appropriate precision. For */
1402 /* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the */
1403 /* requested digits and t is the number of digits in the exponent */
1404 /* (maximum 6). For ln(10) it is p + 3; this is often handled by the */
1405 /* fastpath in decLnOp. The final division is done to the requested */
1406 /* precision. */
1407 /* ------------------------------------------------------------------ */
1408 #if defined(__clang__) || U_GCC_MAJOR_MINOR >= 406
1409 #pragma GCC diagnostic push
1410 #pragma GCC diagnostic ignored "-Warray-bounds"
1411 #endif
1412 U_CAPI decNumber * U_EXPORT2 uprv_decNumberLog10(decNumber *res, const decNumber *rhs,
1413 decContext *set) {
1414 uInt status=0, ignore=0; /* status accumulators */
1415 uInt needbytes; /* for space calculations */
1416 Int p; /* working precision */
1417 Int t; /* digits in exponent of A */
1418
1419 /* buffers for a and b working decimals */
1420 /* (adjustment calculator, same size) */
1421 decNumber bufa[D2N(DECBUFFER+2)];
1422 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
1423 decNumber *a=bufa; /* temporary a */
1424 decNumber bufb[D2N(DECBUFFER+2)];
1425 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */
1426 decNumber *b=bufb; /* temporary b */
1427 decNumber bufw[D2N(10)]; /* working 2-10 digit number */
1428 decNumber *w=bufw; /* .. */
1429 #if DECSUBSET
1430 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
1431 #endif
1432
1433 decContext aset; /* working context */
1434
1435 #if DECCHECK
1436 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1437 #endif
1438
1439 /* Check restrictions; this is a math function; if not violated */
1440 /* then carry out the operation. */
1441 if (!decCheckMath(rhs, set, &status)) do { /* protect malloc */
1442 #if DECSUBSET
1443 if (!set->extended) {
1444 /* reduce operand and set lostDigits status, as needed */
1445 if (rhs->digits>set->digits) {
1446 allocrhs=decRoundOperand(rhs, set, &status);
1447 if (allocrhs==NULL) break;
1448 rhs=allocrhs;
1449 }
1450 /* special check in subset for rhs=0 */
1451 if (ISZERO(rhs)) { /* +/- zeros -> error */
1452 status|=DEC_Invalid_operation;
1453 break;}
1454 } /* extended=0 */
1455 #endif
1456
1457 uprv_decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
1458
1459 /* handle exact powers of 10; only check if +ve finite */
1460 if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) {
1461 Int residue=0; /* (no residue) */
1462 uInt copystat=0; /* clean status */
1463
1464 /* round to a single digit... */
1465 aset.digits=1;
1466 decCopyFit(w, rhs, &aset, &residue, &copystat); /* copy & shorten */
1467 /* if exact and the digit is 1, rhs is a power of 10 */
1468 if (!(copystat&DEC_Inexact) && w->lsu[0]==1) {
1469 /* the exponent, conveniently, is the power of 10; making */
1470 /* this the result needs a little care as it might not fit, */
1471 /* so first convert it into the working number, and then move */
1472 /* to res */
1473 uprv_decNumberFromInt32(w, w->exponent);
1474 residue=0;
1475 decCopyFit(res, w, set, &residue, &status); /* copy & round */
1476 decFinish(res, set, &residue, &status); /* cleanup/set flags */
1477 break;
1478 } /* not a power of 10 */
1479 } /* not a candidate for exact */
1480
1481 /* simplify the information-content calculation to use 'total */
1482 /* number of digits in a, including exponent' as compared to the */
1483 /* requested digits, as increasing this will only rarely cost an */
1484 /* iteration in ln(a) anyway */
1485 t=6; /* it can never be >6 */
1486
1487 /* allocate space when needed... */
1488 p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3;
1489 needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1490 if (needbytes>sizeof(bufa)) { /* need malloc space */
1491 allocbufa=(decNumber *)malloc(needbytes);
1492 if (allocbufa==NULL) { /* hopeless -- abandon */
1493 status|=DEC_Insufficient_storage;
1494 break;}
1495 a=allocbufa; /* use the allocated space */
1496 }
1497 aset.digits=p; /* as calculated */
1498 aset.emax=DEC_MAX_MATH; /* usual bounds */
1499 aset.emin=-DEC_MAX_MATH; /* .. */
1500 aset.clamp=0; /* and no concrete format */
1501 decLnOp(a, rhs, &aset, &status); /* a=ln(rhs) */
1502
1503 /* skip the division if the result so far is infinite, NaN, or */
1504 /* zero, or there was an error; note NaN from sNaN needs copy */
1505 if (status&DEC_NaNs && !(status&DEC_sNaN)) break;
1506 if (a->bits&DECSPECIAL || ISZERO(a)) {
1507 uprv_decNumberCopy(res, a); /* [will fit] */
1508 break;}
1509
1510 /* for ln(10) an extra 3 digits of precision are needed */
1511 p=set->digits+3;
1512 needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1513 if (needbytes>sizeof(bufb)) { /* need malloc space */
1514 allocbufb=(decNumber *)malloc(needbytes);
1515 if (allocbufb==NULL) { /* hopeless -- abandon */
1516 status|=DEC_Insufficient_storage;
1517 break;}
1518 b=allocbufb; /* use the allocated space */
1519 }
1520 uprv_decNumberZero(w); /* set up 10... */
1521 #if DECDPUN==1
1522 w->lsu[1]=1; w->lsu[0]=0; /* .. */
1523 #else
1524 w->lsu[0]=10; /* .. */
1525 #endif
1526 w->digits=2; /* .. */
1527
1528 aset.digits=p;
1529 decLnOp(b, w, &aset, &ignore); /* b=ln(10) */
1530
1531 aset.digits=set->digits; /* for final divide */
1532 decDivideOp(res, a, b, &aset, DIVIDE, &status); /* into result */
1533 } while(0); /* [for break] */
1534
1535 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
1536 if (allocbufb!=NULL) free(allocbufb); /* .. */
1537 #if DECSUBSET
1538 if (allocrhs !=NULL) free(allocrhs); /* .. */
1539 #endif
1540 /* apply significant status */
1541 if (status!=0) decStatus(res, status, set);
1542 #if DECCHECK
1543 decCheckInexact(res, set);
1544 #endif
1545 return res;
1546 } /* decNumberLog10 */
1547 #if defined(__clang__) || U_GCC_MAJOR_MINOR >= 406
1548 #pragma GCC diagnostic pop
1549 #endif
1550
1551 /* ------------------------------------------------------------------ */
1552 /* decNumberMax -- compare two Numbers and return the maximum */
1553 /* */
1554 /* This computes C = A ? B, returning the maximum by 754 rules */
1555 /* */
1556 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1557 /* lhs is A */
1558 /* rhs is B */
1559 /* set is the context */
1560 /* */
1561 /* C must have space for set->digits digits. */
1562 /* ------------------------------------------------------------------ */
1563 U_CAPI decNumber * U_EXPORT2 uprv_decNumberMax(decNumber *res, const decNumber *lhs,
1564 const decNumber *rhs, decContext *set) {
1565 uInt status=0; /* accumulator */
1566 decCompareOp(res, lhs, rhs, set, COMPMAX, &status);
1567 if (status!=0) decStatus(res, status, set);
1568 #if DECCHECK
1569 decCheckInexact(res, set);
1570 #endif
1571 return res;
1572 } /* decNumberMax */
1573
1574 /* ------------------------------------------------------------------ */
1575 /* decNumberMaxMag -- compare and return the maximum by magnitude */
1576 /* */
1577 /* This computes C = A ? B, returning the maximum by 754 rules */
1578 /* */
1579 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1580 /* lhs is A */
1581 /* rhs is B */
1582 /* set is the context */
1583 /* */
1584 /* C must have space for set->digits digits. */
1585 /* ------------------------------------------------------------------ */
1586 U_CAPI decNumber * U_EXPORT2 uprv_decNumberMaxMag(decNumber *res, const decNumber *lhs,
1587 const decNumber *rhs, decContext *set) {
1588 uInt status=0; /* accumulator */
1589 decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status);
1590 if (status!=0) decStatus(res, status, set);
1591 #if DECCHECK
1592 decCheckInexact(res, set);
1593 #endif
1594 return res;
1595 } /* decNumberMaxMag */
1596
1597 /* ------------------------------------------------------------------ */
1598 /* decNumberMin -- compare two Numbers and return the minimum */
1599 /* */
1600 /* This computes C = A ? B, returning the minimum by 754 rules */
1601 /* */
1602 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1603 /* lhs is A */
1604 /* rhs is B */
1605 /* set is the context */
1606 /* */
1607 /* C must have space for set->digits digits. */
1608 /* ------------------------------------------------------------------ */
1609 U_CAPI decNumber * U_EXPORT2 uprv_decNumberMin(decNumber *res, const decNumber *lhs,
1610 const decNumber *rhs, decContext *set) {
1611 uInt status=0; /* accumulator */
1612 decCompareOp(res, lhs, rhs, set, COMPMIN, &status);
1613 if (status!=0) decStatus(res, status, set);
1614 #if DECCHECK
1615 decCheckInexact(res, set);
1616 #endif
1617 return res;
1618 } /* decNumberMin */
1619
1620 /* ------------------------------------------------------------------ */
1621 /* decNumberMinMag -- compare and return the minimum by magnitude */
1622 /* */
1623 /* This computes C = A ? B, returning the minimum by 754 rules */
1624 /* */
1625 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1626 /* lhs is A */
1627 /* rhs is B */
1628 /* set is the context */
1629 /* */
1630 /* C must have space for set->digits digits. */
1631 /* ------------------------------------------------------------------ */
1632 U_CAPI decNumber * U_EXPORT2 uprv_decNumberMinMag(decNumber *res, const decNumber *lhs,
1633 const decNumber *rhs, decContext *set) {
1634 uInt status=0; /* accumulator */
1635 decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status);
1636 if (status!=0) decStatus(res, status, set);
1637 #if DECCHECK
1638 decCheckInexact(res, set);
1639 #endif
1640 return res;
1641 } /* decNumberMinMag */
1642
1643 /* ------------------------------------------------------------------ */
1644 /* decNumberMinus -- prefix minus operator */
1645 /* */
1646 /* This computes C = 0 - A */
1647 /* */
1648 /* res is C, the result. C may be A */
1649 /* rhs is A */
1650 /* set is the context */
1651 /* */
1652 /* See also decNumberCopyNegate for a quiet bitwise version of this. */
1653 /* C must have space for set->digits digits. */
1654 /* ------------------------------------------------------------------ */
1655 /* Simply use AddOp for the subtract, which will do the necessary. */
1656 /* ------------------------------------------------------------------ */
1657 U_CAPI decNumber * U_EXPORT2 uprv_decNumberMinus(decNumber *res, const decNumber *rhs,
1658 decContext *set) {
1659 decNumber dzero;
1660 uInt status=0; /* accumulator */
1661
1662 #if DECCHECK
1663 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1664 #endif
1665
1666 uprv_decNumberZero(&dzero); /* make 0 */
1667 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */
1668 decAddOp(res, &dzero, rhs, set, DECNEG, &status);
1669 if (status!=0) decStatus(res, status, set);
1670 #if DECCHECK
1671 decCheckInexact(res, set);
1672 #endif
1673 return res;
1674 } /* decNumberMinus */
1675
1676 /* ------------------------------------------------------------------ */
1677 /* decNumberNextMinus -- next towards -Infinity */
1678 /* */
1679 /* This computes C = A - infinitesimal, rounded towards -Infinity */
1680 /* */
1681 /* res is C, the result. C may be A */
1682 /* rhs is A */
1683 /* set is the context */
1684 /* */
1685 /* This is a generalization of 754 NextDown. */
1686 /* ------------------------------------------------------------------ */
1687 U_CAPI decNumber * U_EXPORT2 uprv_decNumberNextMinus(decNumber *res, const decNumber *rhs,
1688 decContext *set) {
1689 decNumber dtiny; /* constant */
1690 decContext workset=*set; /* work */
1691 uInt status=0; /* accumulator */
1692 #if DECCHECK
1693 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1694 #endif
1695
1696 /* +Infinity is the special case */
1697 if ((rhs->bits&(DECINF|DECNEG))==DECINF) {
1698 decSetMaxValue(res, set); /* is +ve */
1699 /* there is no status to set */
1700 return res;
1701 }
1702 uprv_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_FLOOR;
1706 decAddOp(res, rhs, &dtiny, &workset, DECNEG, &status);
1707 status&=DEC_Invalid_operation|DEC_sNaN; /* only sNaN Invalid please */
1708 if (status!=0) decStatus(res, status, set);
1709 return res;
1710 } /* decNumberNextMinus */
1711
1712 /* ------------------------------------------------------------------ */
1713 /* decNumberNextPlus -- next towards +Infinity */
1714 /* */
1715 /* This computes C = A + infinitesimal, rounded towards +Infinity */
1716 /* */
1717 /* res is C, the result. C may be A */
1718 /* rhs is A */
1719 /* set is the context */
1720 /* */
1721 /* This is a generalization of 754 NextUp. */
1722 /* ------------------------------------------------------------------ */
1723 U_CAPI decNumber * U_EXPORT2 uprv_decNumberNextPlus(decNumber *res, const decNumber *rhs,
1724 decContext *set) {
1725 decNumber dtiny; /* constant */
1726 decContext workset=*set; /* work */
1727 uInt status=0; /* accumulator */
1728 #if DECCHECK
1729 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1730 #endif
1731
1732 /* -Infinity is the special case */
1733 if ((rhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1734 decSetMaxValue(res, set);
1735 res->bits=DECNEG; /* negative */
1736 /* there is no status to set */
1737 return res;
1738 }
1739 uprv_decNumberZero(&dtiny); /* start with 0 */
1740 dtiny.lsu[0]=1; /* make number that is .. */
1741 dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */
1742 workset.round=DEC_ROUND_CEILING;
1743 decAddOp(res, rhs, &dtiny, &workset, 0, &status);
1744 status&=DEC_Invalid_operation|DEC_sNaN; /* only sNaN Invalid please */
1745 if (status!=0) decStatus(res, status, set);
1746 return res;
1747 } /* decNumberNextPlus */
1748
1749 /* ------------------------------------------------------------------ */
1750 /* decNumberNextToward -- next towards rhs */
1751 /* */
1752 /* This computes C = A +/- infinitesimal, rounded towards */
1753 /* +/-Infinity in the direction of B, as per 754-1985 nextafter */
1754 /* modified during revision but dropped from 754-2008. */
1755 /* */
1756 /* res is C, the result. C may be A or B. */
1757 /* lhs is A */
1758 /* rhs is B */
1759 /* set is the context */
1760 /* */
1761 /* This is a generalization of 754-1985 NextAfter. */
1762 /* ------------------------------------------------------------------ */
1763 U_CAPI decNumber * U_EXPORT2 uprv_decNumberNextToward(decNumber *res, const decNumber *lhs,
1764 const decNumber *rhs, decContext *set) {
1765 decNumber dtiny; /* constant */
1766 decContext workset=*set; /* work */
1767 Int result; /* .. */
1768 uInt status=0; /* accumulator */
1769 #if DECCHECK
1770 if (decCheckOperands(res, lhs, rhs, set)) return res;
1771 #endif
1772
1773 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) {
1774 decNaNs(res, lhs, rhs, set, &status);
1775 }
1776 else { /* Is numeric, so no chance of sNaN Invalid, etc. */
1777 result=decCompare(lhs, rhs, 0); /* sign matters */
1778 if (result==BADINT) status|=DEC_Insufficient_storage; /* rare */
1779 else { /* valid compare */
1780 if (result==0) uprv_decNumberCopySign(res, lhs, rhs); /* easy */
1781 else { /* differ: need NextPlus or NextMinus */
1782 uByte sub; /* add or subtract */
1783 if (result<0) { /* lhs<rhs, do nextplus */
1784 /* -Infinity is the special case */
1785 if ((lhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1786 decSetMaxValue(res, set);
1787 res->bits=DECNEG; /* negative */
1788 return res; /* there is no status to set */
1789 }
1790 workset.round=DEC_ROUND_CEILING;
1791 sub=0; /* add, please */
1792 } /* plus */
1793 else { /* lhs>rhs, do nextminus */
1794 /* +Infinity is the special case */
1795 if ((lhs->bits&(DECINF|DECNEG))==DECINF) {
1796 decSetMaxValue(res, set);
1797 return res; /* there is no status to set */
1798 }
1799 workset.round=DEC_ROUND_FLOOR;
1800 sub=DECNEG; /* subtract, please */
1801 } /* minus */
1802 uprv_decNumberZero(&dtiny); /* start with 0 */
1803 dtiny.lsu[0]=1; /* make number that is .. */
1804 dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */
1805 decAddOp(res, lhs, &dtiny, &workset, sub, &status); /* + or - */
1806 /* turn off exceptions if the result is a normal number */
1807 /* (including Nmin), otherwise let all status through */
1808 if (uprv_decNumberIsNormal(res, set)) status=0;
1809 } /* unequal */
1810 } /* compare OK */
1811 } /* numeric */
1812 if (status!=0) decStatus(res, status, set);
1813 return res;
1814 } /* decNumberNextToward */
1815
1816 /* ------------------------------------------------------------------ */
1817 /* decNumberOr -- OR two Numbers, digitwise */
1818 /* */
1819 /* This computes C = A | B */
1820 /* */
1821 /* res is C, the result. C may be A and/or B (e.g., X=X|X) */
1822 /* lhs is A */
1823 /* rhs is B */
1824 /* set is the context (used for result length and error report) */
1825 /* */
1826 /* C must have space for set->digits digits. */
1827 /* */
1828 /* Logical function restrictions apply (see above); a NaN is */
1829 /* returned with Invalid_operation if a restriction is violated. */
1830 /* ------------------------------------------------------------------ */
1831 U_CAPI decNumber * U_EXPORT2 uprv_decNumberOr(decNumber *res, const decNumber *lhs,
1832 const decNumber *rhs, decContext *set) {
1833 const Unit *ua, *ub; /* -> operands */
1834 const Unit *msua, *msub; /* -> operand msus */
1835 Unit *uc, *msuc; /* -> result and its msu */
1836 Int msudigs; /* digits in res msu */
1837 #if DECCHECK
1838 if (decCheckOperands(res, lhs, rhs, set)) return res;
1839 #endif
1840
1841 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
1842 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1843 decStatus(res, DEC_Invalid_operation, set);
1844 return res;
1845 }
1846 /* operands are valid */
1847 ua=lhs->lsu; /* bottom-up */
1848 ub=rhs->lsu; /* .. */
1849 uc=res->lsu; /* .. */
1850 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */
1851 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */
1852 msuc=uc+D2U(set->digits)-1; /* -> msu of result */
1853 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */
1854 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */
1855 Unit a, b; /* extract units */
1856 if (ua>msua) a=0;
1857 else a=*ua;
1858 if (ub>msub) b=0;
1859 else b=*ub;
1860 *uc=0; /* can now write back */
1861 if (a|b) { /* maybe 1 bits to examine */
1862 Int i, j;
1863 /* This loop could be unrolled and/or use BIN2BCD tables */
1864 for (i=0; i<DECDPUN; i++) {
1865 if ((a|b)&1) *uc=*uc+(Unit)powers[i]; /* effect OR */
1866 j=a%10;
1867 a=a/10;
1868 j|=b%10;
1869 b=b/10;
1870 if (j>1) {
1871 decStatus(res, DEC_Invalid_operation, set);
1872 return res;
1873 }
1874 if (uc==msuc && i==msudigs-1) break; /* just did final digit */
1875 } /* each digit */
1876 } /* non-zero */
1877 } /* each unit */
1878 /* [here uc-1 is the msu of the result] */
1879 res->digits=decGetDigits(res->lsu, uc-res->lsu);
1880 res->exponent=0; /* integer */
1881 res->bits=0; /* sign=0 */
1882 return res; /* [no status to set] */
1883 } /* decNumberOr */
1884
1885 /* ------------------------------------------------------------------ */
1886 /* decNumberPlus -- prefix plus operator */
1887 /* */
1888 /* This computes C = 0 + A */
1889 /* */
1890 /* res is C, the result. C may be A */
1891 /* rhs is A */
1892 /* set is the context */
1893 /* */
1894 /* See also decNumberCopy for a quiet bitwise version of this. */
1895 /* C must have space for set->digits digits. */
1896 /* ------------------------------------------------------------------ */
1897 /* This simply uses AddOp; Add will take fast path after preparing A. */
1898 /* Performance is a concern here, as this routine is often used to */
1899 /* check operands and apply rounding and overflow/underflow testing. */
1900 /* ------------------------------------------------------------------ */
1901 U_CAPI decNumber * U_EXPORT2 uprv_decNumberPlus(decNumber *res, const decNumber *rhs,
1902 decContext *set) {
1903 decNumber dzero;
1904 uInt status=0; /* accumulator */
1905 #if DECCHECK
1906 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1907 #endif
1908
1909 uprv_decNumberZero(&dzero); /* make 0 */
1910 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */
1911 decAddOp(res, &dzero, rhs, set, 0, &status);
1912 if (status!=0) decStatus(res, status, set);
1913 #if DECCHECK
1914 decCheckInexact(res, set);
1915 #endif
1916 return res;
1917 } /* decNumberPlus */
1918
1919 /* ------------------------------------------------------------------ */
1920 /* decNumberMultiply -- multiply two Numbers */
1921 /* */
1922 /* This computes C = A x B */
1923 /* */
1924 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */
1925 /* lhs is A */
1926 /* rhs is B */
1927 /* set is the context */
1928 /* */
1929 /* C must have space for set->digits digits. */
1930 /* ------------------------------------------------------------------ */
1931 U_CAPI decNumber * U_EXPORT2 uprv_decNumberMultiply(decNumber *res, const decNumber *lhs,
1932 const decNumber *rhs, decContext *set) {
1933 uInt status=0; /* accumulator */
1934 decMultiplyOp(res, lhs, rhs, set, &status);
1935 if (status!=0) decStatus(res, status, set);
1936 #if DECCHECK
1937 decCheckInexact(res, set);
1938 #endif
1939 return res;
1940 } /* decNumberMultiply */
1941
1942 /* ------------------------------------------------------------------ */
1943 /* decNumberPower -- raise a number to a power */
1944 /* */
1945 /* This computes C = A ** B */
1946 /* */
1947 /* res is C, the result. C may be A and/or B (e.g., X=X**X) */
1948 /* lhs is A */
1949 /* rhs is B */
1950 /* set is the context */
1951 /* */
1952 /* C must have space for set->digits digits. */
1953 /* */
1954 /* Mathematical function restrictions apply (see above); a NaN is */
1955 /* returned with Invalid_operation if a restriction is violated. */
1956 /* */
1957 /* However, if 1999999997<=B<=999999999 and B is an integer then the */
1958 /* restrictions on A and the context are relaxed to the usual bounds, */
1959 /* for compatibility with the earlier (integer power only) version */
1960 /* of this function. */
1961 /* */
1962 /* When B is an integer, the result may be exact, even if rounded. */
1963 /* */
1964 /* The final result is rounded according to the context; it will */
1965 /* almost always be correctly rounded, but may be up to 1 ulp in */
1966 /* error in rare cases. */
1967 /* ------------------------------------------------------------------ */
1968 U_CAPI decNumber * U_EXPORT2 uprv_decNumberPower(decNumber *res, const decNumber *lhs,
1969 const decNumber *rhs, decContext *set) {
1970 #if DECSUBSET
1971 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
1972 decNumber *allocrhs=NULL; /* .., rhs */
1973 #endif
1974 decNumber *allocdac=NULL; /* -> allocated acc buffer, iff used */
1975 decNumber *allocinv=NULL; /* -> allocated 1/x buffer, iff used */
1976 Int reqdigits=set->digits; /* requested DIGITS */
1977 Int n; /* rhs in binary */
1978 Flag rhsint=0; /* 1 if rhs is an integer */
1979 Flag useint=0; /* 1 if can use integer calculation */
1980 Flag isoddint=0; /* 1 if rhs is an integer and odd */
1981 Int i; /* work */
1982 #if DECSUBSET
1983 Int dropped; /* .. */
1984 #endif
1985 uInt needbytes; /* buffer size needed */
1986 Flag seenbit; /* seen a bit while powering */
1987 Int residue=0; /* rounding residue */
1988 uInt status=0; /* accumulators */
1989 uByte bits=0; /* result sign if errors */
1990 decContext aset; /* working context */
1991 decNumber dnOne; /* work value 1... */
1992 /* local accumulator buffer [a decNumber, with digits+elength+1 digits] */
1993 decNumber dacbuff[D2N(DECBUFFER+9)];
1994 decNumber *dac=dacbuff; /* -> result accumulator */
1995 /* same again for possible 1/lhs calculation */
1996 decNumber invbuff[D2N(DECBUFFER+9)];
1997
1998 #if DECCHECK
1999 if (decCheckOperands(res, lhs, rhs, set)) return res;
2000 #endif
2001
2002 do { /* protect allocated storage */
2003 #if DECSUBSET
2004 if (!set->extended) { /* reduce operands and set status, as needed */
2005 if (lhs->digits>reqdigits) {
2006 alloclhs=decRoundOperand(lhs, set, &status);
2007 if (alloclhs==NULL) break;
2008 lhs=alloclhs;
2009 }
2010 if (rhs->digits>reqdigits) {
2011 allocrhs=decRoundOperand(rhs, set, &status);
2012 if (allocrhs==NULL) break;
2013 rhs=allocrhs;
2014 }
2015 }
2016 #endif
2017 /* [following code does not require input rounding] */
2018
2019 /* handle NaNs and rhs Infinity (lhs infinity is harder) */
2020 if (SPECIALARGS) {
2021 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { /* NaNs */
2022 decNaNs(res, lhs, rhs, set, &status);
2023 break;}
2024 if (decNumberIsInfinite(rhs)) { /* rhs Infinity */
2025 Flag rhsneg=rhs->bits&DECNEG; /* save rhs sign */
2026 if (decNumberIsNegative(lhs) /* lhs<0 */
2027 && !decNumberIsZero(lhs)) /* .. */
2028 status|=DEC_Invalid_operation;
2029 else { /* lhs >=0 */
2030 uprv_decNumberZero(&dnOne); /* set up 1 */
2031 dnOne.lsu[0]=1;
2032 uprv_decNumberCompare(dac, lhs, &dnOne, set); /* lhs ? 1 */
2033 uprv_decNumberZero(res); /* prepare for 0/1/Infinity */
2034 if (decNumberIsNegative(dac)) { /* lhs<1 */
2035 if (rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */
2036 }
2037 else if (dac->lsu[0]==0) { /* lhs=1 */
2038 /* 1**Infinity is inexact, so return fully-padded 1.0000 */
2039 Int shift=set->digits-1;
2040 *res->lsu=1; /* was 0, make int 1 */
2041 res->digits=decShiftToMost(res->lsu, 1, shift);
2042 res->exponent=-shift; /* make 1.0000... */
2043 status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */
2044 }
2045 else { /* lhs>1 */
2046 if (!rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */
2047 }
2048 } /* lhs>=0 */
2049 break;}
2050 /* [lhs infinity drops through] */
2051 } /* specials */
2052
2053 /* Original rhs may be an integer that fits and is in range */
2054 n=decGetInt(rhs);
2055 if (n!=BADINT) { /* it is an integer */
2056 rhsint=1; /* record the fact for 1**n */
2057 isoddint=(Flag)n&1; /* [works even if big] */
2058 if (n!=BIGEVEN && n!=BIGODD) /* can use integer path? */
2059 useint=1; /* looks good */
2060 }
2061
2062 if (decNumberIsNegative(lhs) /* -x .. */
2063 && isoddint) bits=DECNEG; /* .. to an odd power */
2064
2065 /* handle LHS infinity */
2066 if (decNumberIsInfinite(lhs)) { /* [NaNs already handled] */
2067 uByte rbits=rhs->bits; /* save */
2068 uprv_decNumberZero(res); /* prepare */
2069 if (n==0) *res->lsu=1; /* [-]Inf**0 => 1 */
2070 else {
2071 /* -Inf**nonint -> error */
2072 if (!rhsint && decNumberIsNegative(lhs)) {
2073 status|=DEC_Invalid_operation; /* -Inf**nonint is error */
2074 break;}
2075 if (!(rbits & DECNEG)) bits|=DECINF; /* was not a **-n */
2076 /* [otherwise will be 0 or -0] */
2077 res->bits=bits;
2078 }
2079 break;}
2080
2081 /* similarly handle LHS zero */
2082 if (decNumberIsZero(lhs)) {
2083 if (n==0) { /* 0**0 => Error */
2084 #if DECSUBSET
2085 if (!set->extended) { /* [unless subset] */
2086 uprv_decNumberZero(res);
2087 *res->lsu=1; /* return 1 */
2088 break;}
2089 #endif
2090 status|=DEC_Invalid_operation;
2091 }
2092 else { /* 0**x */
2093 uByte rbits=rhs->bits; /* save */
2094 if (rbits & DECNEG) { /* was a 0**(-n) */
2095 #if DECSUBSET
2096 if (!set->extended) { /* [bad if subset] */
2097 status|=DEC_Invalid_operation;
2098 break;}
2099 #endif
2100 bits|=DECINF;
2101 }
2102 uprv_decNumberZero(res); /* prepare */
2103 /* [otherwise will be 0 or -0] */
2104 res->bits=bits;
2105 }
2106 break;}
2107
2108 /* here both lhs and rhs are finite; rhs==0 is handled in the */
2109 /* integer path. Next handle the non-integer cases */
2110 if (!useint) { /* non-integral rhs */
2111 /* any -ve lhs is bad, as is either operand or context out of */
2112 /* bounds */
2113 if (decNumberIsNegative(lhs)) {
2114 status|=DEC_Invalid_operation;
2115 break;}
2116 if (decCheckMath(lhs, set, &status)
2117 || decCheckMath(rhs, set, &status)) break; /* variable status */
2118
2119 uprv_decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
2120 aset.emax=DEC_MAX_MATH; /* usual bounds */
2121 aset.emin=-DEC_MAX_MATH; /* .. */
2122 aset.clamp=0; /* and no concrete format */
2123
2124 /* calculate the result using exp(ln(lhs)*rhs), which can */
2125 /* all be done into the accumulator, dac. The precision needed */
2126 /* is enough to contain the full information in the lhs (which */
2127 /* is the total digits, including exponent), or the requested */
2128 /* precision, if larger, + 4; 6 is used for the exponent */
2129 /* maximum length, and this is also used when it is shorter */
2130 /* than the requested digits as it greatly reduces the >0.5 ulp */
2131 /* cases at little cost (because Ln doubles digits each */
2132 /* iteration so a few extra digits rarely causes an extra */
2133 /* iteration) */
2134 aset.digits=MAXI(lhs->digits, set->digits)+6+4;
2135 } /* non-integer rhs */
2136
2137 else { /* rhs is in-range integer */
2138 if (n==0) { /* x**0 = 1 */
2139 /* (0**0 was handled above) */
2140 uprv_decNumberZero(res); /* result=1 */
2141 *res->lsu=1; /* .. */
2142 break;}
2143 /* rhs is a non-zero integer */
2144 if (n<0) n=-n; /* use abs(n) */
2145
2146 aset=*set; /* clone the context */
2147 aset.round=DEC_ROUND_HALF_EVEN; /* internally use balanced */
2148 /* calculate the working DIGITS */
2149 aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2;
2150 #if DECSUBSET
2151 if (!set->extended) aset.digits--; /* use classic precision */
2152 #endif
2153 /* it's an error if this is more than can be handled */
2154 if (aset.digits>DECNUMMAXP) {status|=DEC_Invalid_operation; break;}
2155 } /* integer path */
2156
2157 /* aset.digits is the count of digits for the accumulator needed */
2158 /* if accumulator is too long for local storage, then allocate */
2159 needbytes=sizeof(decNumber)+(D2U(aset.digits)-1)*sizeof(Unit);
2160 /* [needbytes also used below if 1/lhs needed] */
2161 if (needbytes>sizeof(dacbuff)) {
2162 allocdac=(decNumber *)malloc(needbytes);
2163 if (allocdac==NULL) { /* hopeless -- abandon */
2164 status|=DEC_Insufficient_storage;
2165 break;}
2166 dac=allocdac; /* use the allocated space */
2167 }
2168 /* here, aset is set up and accumulator is ready for use */
2169
2170 if (!useint) { /* non-integral rhs */
2171 /* x ** y; special-case x=1 here as it will otherwise always */
2172 /* reduce to integer 1; decLnOp has a fastpath which detects */
2173 /* the case of x=1 */
2174 decLnOp(dac, lhs, &aset, &status); /* dac=ln(lhs) */
2175 /* [no error possible, as lhs 0 already handled] */
2176 if (ISZERO(dac)) { /* x==1, 1.0, etc. */
2177 /* need to return fully-padded 1.0000 etc., but rhsint->1 */
2178 *dac->lsu=1; /* was 0, make int 1 */
2179 if (!rhsint) { /* add padding */
2180 Int shift=set->digits-1;
2181 dac->digits=decShiftToMost(dac->lsu, 1, shift);
2182 dac->exponent=-shift; /* make 1.0000... */
2183 status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */
2184 }
2185 }
2186 else {
2187 decMultiplyOp(dac, dac, rhs, &aset, &status); /* dac=dac*rhs */
2188 decExpOp(dac, dac, &aset, &status); /* dac=exp(dac) */
2189 }
2190 /* and drop through for final rounding */
2191 } /* non-integer rhs */
2192
2193 else { /* carry on with integer */
2194 uprv_decNumberZero(dac); /* acc=1 */
2195 *dac->lsu=1; /* .. */
2196
2197 /* if a negative power the constant 1 is needed, and if not subset */
2198 /* invert the lhs now rather than inverting the result later */
2199 if (decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */
2200 decNumber *inv=invbuff; /* asssume use fixed buffer */
2201 uprv_decNumberCopy(&dnOne, dac); /* dnOne=1; [needed now or later] */
2202 #if DECSUBSET
2203 if (set->extended) { /* need to calculate 1/lhs */
2204 #endif
2205 /* divide lhs into 1, putting result in dac [dac=1/dac] */
2206 decDivideOp(dac, &dnOne, lhs, &aset, DIVIDE, &status);
2207 /* now locate or allocate space for the inverted lhs */
2208 if (needbytes>sizeof(invbuff)) {
2209 allocinv=(decNumber *)malloc(needbytes);
2210 if (allocinv==NULL) { /* hopeless -- abandon */
2211 status|=DEC_Insufficient_storage;
2212 break;}
2213 inv=allocinv; /* use the allocated space */
2214 }
2215 /* [inv now points to big-enough buffer or allocated storage] */
2216 uprv_decNumberCopy(inv, dac); /* copy the 1/lhs */
2217 uprv_decNumberCopy(dac, &dnOne); /* restore acc=1 */
2218 lhs=inv; /* .. and go forward with new lhs */
2219 #if DECSUBSET
2220 }
2221 #endif
2222 }
2223
2224 /* Raise-to-the-power loop... */
2225 seenbit=0; /* set once a 1-bit is encountered */
2226 for (i=1;;i++){ /* for each bit [top bit ignored] */
2227 /* abandon if had overflow or terminal underflow */
2228 if (status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
2229 if (status&DEC_Overflow || ISZERO(dac)) break;
2230 }
2231 /* [the following two lines revealed an optimizer bug in a C++ */
2232 /* compiler, with symptom: 5**3 -> 25, when n=n+n was used] */
2233 n=n<<1; /* move next bit to testable position */
2234 if (n<0) { /* top bit is set */
2235 seenbit=1; /* OK, significant bit seen */
2236 decMultiplyOp(dac, dac, lhs, &aset, &status); /* dac=dac*x */
2237 }
2238 if (i==31) break; /* that was the last bit */
2239 if (!seenbit) continue; /* no need to square 1 */
2240 decMultiplyOp(dac, dac, dac, &aset, &status); /* dac=dac*dac [square] */
2241 } /*i*/ /* 32 bits */
2242
2243 /* complete internal overflow or underflow processing */
2244 if (status & (DEC_Overflow|DEC_Underflow)) {
2245 #if DECSUBSET
2246 /* If subset, and power was negative, reverse the kind of -erflow */
2247 /* [1/x not yet done] */
2248 if (!set->extended && decNumberIsNegative(rhs)) {
2249 if (status & DEC_Overflow)
2250 status^=DEC_Overflow | DEC_Underflow | DEC_Subnormal;
2251 else { /* trickier -- Underflow may or may not be set */
2252 status&=~(DEC_Underflow | DEC_Subnormal); /* [one or both] */
2253 status|=DEC_Overflow;
2254 }
2255 }
2256 #endif
2257 dac->bits=(dac->bits & ~DECNEG) | bits; /* force correct sign */
2258 /* round subnormals [to set.digits rather than aset.digits] */
2259 /* or set overflow result similarly as required */
2260 decFinalize(dac, set, &residue, &status);
2261 uprv_decNumberCopy(res, dac); /* copy to result (is now OK length) */
2262 break;
2263 }
2264
2265 #if DECSUBSET
2266 if (!set->extended && /* subset math */
2267 decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */
2268 /* so divide result into 1 [dac=1/dac] */
2269 decDivideOp(dac, &dnOne, dac, &aset, DIVIDE, &status);
2270 }
2271 #endif
2272 } /* rhs integer path */
2273
2274 /* reduce result to the requested length and copy to result */
2275 decCopyFit(res, dac, set, &residue, &status);
2276 decFinish(res, set, &residue, &status); /* final cleanup */
2277 #if DECSUBSET
2278 if (!set->extended) decTrim(res, set, 0, 1, &dropped); /* trailing zeros */
2279 #endif
2280 } while(0); /* end protected */
2281
2282 if (allocdac!=NULL) free(allocdac); /* drop any storage used */
2283 if (allocinv!=NULL) free(allocinv); /* .. */
2284 #if DECSUBSET
2285 if (alloclhs!=NULL) free(alloclhs); /* .. */
2286 if (allocrhs!=NULL) free(allocrhs); /* .. */
2287 #endif
2288 if (status!=0) decStatus(res, status, set);
2289 #if DECCHECK
2290 decCheckInexact(res, set);
2291 #endif
2292 return res;
2293 } /* decNumberPower */
2294
2295 /* ------------------------------------------------------------------ */
2296 /* decNumberQuantize -- force exponent to requested value */
2297 /* */
2298 /* This computes C = op(A, B), where op adjusts the coefficient */
2299 /* of C (by rounding or shifting) such that the exponent (-scale) */
2300 /* of C has exponent of B. The numerical value of C will equal A, */
2301 /* except for the effects of any rounding that occurred. */
2302 /* */
2303 /* res is C, the result. C may be A or B */
2304 /* lhs is A, the number to adjust */
2305 /* rhs is B, the number with exponent to match */
2306 /* set is the context */
2307 /* */
2308 /* C must have space for set->digits digits. */
2309 /* */
2310 /* Unless there is an error or the result is infinite, the exponent */
2311 /* after the operation is guaranteed to be equal to that of B. */
2312 /* ------------------------------------------------------------------ */
2313 U_CAPI decNumber * U_EXPORT2 uprv_decNumberQuantize(decNumber *res, const decNumber *lhs,
2314 const decNumber *rhs, decContext *set) {
2315 uInt status=0; /* accumulator */
2316 decQuantizeOp(res, lhs, rhs, set, 1, &status);
2317 if (status!=0) decStatus(res, status, set);
2318 return res;
2319 } /* decNumberQuantize */
2320
2321 /* ------------------------------------------------------------------ */
2322 /* decNumberReduce -- remove trailing zeros */
2323 /* */
2324 /* This computes C = 0 + A, and normalizes the result */
2325 /* */
2326 /* res is C, the result. C may be A */
2327 /* rhs is A */
2328 /* set is the context */
2329 /* */
2330 /* C must have space for set->digits digits. */
2331 /* ------------------------------------------------------------------ */
2332 /* Previously known as Normalize */
2333 U_CAPI decNumber * U_EXPORT2 uprv_decNumberNormalize(decNumber *res, const decNumber *rhs,
2334 decContext *set) {
2335 return uprv_decNumberReduce(res, rhs, set);
2336 } /* decNumberNormalize */
2337
2338 U_CAPI decNumber * U_EXPORT2 uprv_decNumberReduce(decNumber *res, const decNumber *rhs,
2339 decContext *set) {
2340 #if DECSUBSET
2341 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
2342 #endif
2343 uInt status=0; /* as usual */
2344 Int residue=0; /* as usual */
2345 Int dropped; /* work */
2346
2347 #if DECCHECK
2348 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2349 #endif
2350
2351 do { /* protect allocated storage */
2352 #if DECSUBSET
2353 if (!set->extended) {
2354 /* reduce operand and set lostDigits status, as needed */
2355 if (rhs->digits>set->digits) {
2356 allocrhs=decRoundOperand(rhs, set, &status);
2357 if (allocrhs==NULL) break;
2358 rhs=allocrhs;
2359 }
2360 }
2361 #endif
2362 /* [following code does not require input rounding] */
2363
2364 /* Infinities copy through; NaNs need usual treatment */
2365 if (decNumberIsNaN(rhs)) {
2366 decNaNs(res, rhs, NULL, set, &status);
2367 break;
2368 }
2369
2370 /* reduce result to the requested length and copy to result */
2371 decCopyFit(res, rhs, set, &residue, &status); /* copy & round */
2372 decFinish(res, set, &residue, &status); /* cleanup/set flags */
2373 decTrim(res, set, 1, 0, &dropped); /* normalize in place */
2374 /* [may clamp] */
2375 } while(0); /* end protected */
2376
2377 #if DECSUBSET
2378 if (allocrhs !=NULL) free(allocrhs); /* .. */
2379 #endif
2380 if (status!=0) decStatus(res, status, set);/* then report status */
2381 return res;
2382 } /* decNumberReduce */
2383
2384 /* ------------------------------------------------------------------ */
2385 /* decNumberRescale -- force exponent to requested value */
2386 /* */
2387 /* This computes C = op(A, B), where op adjusts the coefficient */
2388 /* of C (by rounding or shifting) such that the exponent (-scale) */
2389 /* of C has the value B. The numerical value of C will equal A, */
2390 /* except for the effects of any rounding that occurred. */
2391 /* */
2392 /* res is C, the result. C may be A or B */
2393 /* lhs is A, the number to adjust */
2394 /* rhs is B, the requested exponent */
2395 /* set is the context */
2396 /* */
2397 /* C must have space for set->digits digits. */
2398 /* */
2399 /* Unless there is an error or the result is infinite, the exponent */
2400 /* after the operation is guaranteed to be equal to B. */
2401 /* ------------------------------------------------------------------ */
2402 U_CAPI decNumber * U_EXPORT2 uprv_decNumberRescale(decNumber *res, const decNumber *lhs,
2403 const decNumber *rhs, decContext *set) {
2404 uInt status=0; /* accumulator */
2405 decQuantizeOp(res, lhs, rhs, set, 0, &status);
2406 if (status!=0) decStatus(res, status, set);
2407 return res;
2408 } /* decNumberRescale */
2409
2410 /* ------------------------------------------------------------------ */
2411 /* decNumberRemainder -- divide and return remainder */
2412 /* */
2413 /* This computes C = A % B */
2414 /* */
2415 /* res is C, the result. C may be A and/or B (e.g., X=X%X) */
2416 /* lhs is A */
2417 /* rhs is B */
2418 /* set is the context */
2419 /* */
2420 /* C must have space for set->digits digits. */
2421 /* ------------------------------------------------------------------ */
2422 U_CAPI decNumber * U_EXPORT2 uprv_decNumberRemainder(decNumber *res, const decNumber *lhs,
2423 const decNumber *rhs, decContext *set) {
2424 uInt status=0; /* accumulator */
2425 decDivideOp(res, lhs, rhs, set, REMAINDER, &status);
2426 if (status!=0) decStatus(res, status, set);
2427 #if DECCHECK
2428 decCheckInexact(res, set);
2429 #endif
2430 return res;
2431 } /* decNumberRemainder */
2432
2433 /* ------------------------------------------------------------------ */
2434 /* decNumberRemainderNear -- divide and return remainder from nearest */
2435 /* */
2436 /* This computes C = A % B, where % is the IEEE remainder operator */
2437 /* */
2438 /* res is C, the result. C may be A and/or B (e.g., X=X%X) */
2439 /* lhs is A */
2440 /* rhs is B */
2441 /* set is the context */
2442 /* */
2443 /* C must have space for set->digits digits. */
2444 /* ------------------------------------------------------------------ */
2445 U_CAPI decNumber * U_EXPORT2 uprv_decNumberRemainderNear(decNumber *res, const decNumber *lhs,
2446 const decNumber *rhs, decContext *set) {
2447 uInt status=0; /* accumulator */
2448 decDivideOp(res, lhs, rhs, set, REMNEAR, &status);
2449 if (status!=0) decStatus(res, status, set);
2450 #if DECCHECK
2451 decCheckInexact(res, set);
2452 #endif
2453 return res;
2454 } /* decNumberRemainderNear */
2455
2456 /* ------------------------------------------------------------------ */
2457 /* decNumberRotate -- rotate the coefficient of a Number left/right */
2458 /* */
2459 /* This computes C = A rot B (in base ten and rotating set->digits */
2460 /* digits). */
2461 /* */
2462 /* res is C, the result. C may be A and/or B (e.g., X=XrotX) */
2463 /* lhs is A */
2464 /* rhs is B, the number of digits to rotate (-ve to right) */
2465 /* set is the context */
2466 /* */
2467 /* The digits of the coefficient of A are rotated to the left (if B */
2468 /* is positive) or to the right (if B is negative) without adjusting */
2469 /* the exponent or the sign of A. If lhs->digits is less than */
2470 /* set->digits the coefficient is padded with zeros on the left */
2471 /* before the rotate. Any leading zeros in the result are removed */
2472 /* as usual. */
2473 /* */
2474 /* B must be an integer (q=0) and in the range -set->digits through */
2475 /* +set->digits. */
2476 /* C must have space for set->digits digits. */
2477 /* NaNs are propagated as usual. Infinities are unaffected (but */
2478 /* B must be valid). No status is set unless B is invalid or an */
2479 /* operand is an sNaN. */
2480 /* ------------------------------------------------------------------ */
2481 U_CAPI decNumber * U_EXPORT2 uprv_decNumberRotate(decNumber *res, const decNumber *lhs,
2482 const decNumber *rhs, decContext *set) {
2483 uInt status=0; /* accumulator */
2484 Int rotate; /* rhs as an Int */
2485
2486 #if DECCHECK
2487 if (decCheckOperands(res, lhs, rhs, set)) return res;
2488 #endif
2489
2490 /* NaNs propagate as normal */
2491 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2492 decNaNs(res, lhs, rhs, set, &status);
2493 /* rhs must be an integer */
2494 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2495 status=DEC_Invalid_operation;
2496 else { /* both numeric, rhs is an integer */
2497 rotate=decGetInt(rhs); /* [cannot fail] */
2498 if (rotate==BADINT /* something bad .. */
2499 || rotate==BIGODD || rotate==BIGEVEN /* .. very big .. */
2500 || abs(rotate)>set->digits) /* .. or out of range */
2501 status=DEC_Invalid_operation;
2502 else { /* rhs is OK */
2503 uprv_decNumberCopy(res, lhs);
2504 /* convert -ve rotate to equivalent positive rotation */
2505 if (rotate<0) rotate=set->digits+rotate;
2506 if (rotate!=0 && rotate!=set->digits /* zero or full rotation */
2507 && !decNumberIsInfinite(res)) { /* lhs was infinite */
2508 /* left-rotate to do; 0 < rotate < set->digits */
2509 uInt units, shift; /* work */
2510 uInt msudigits; /* digits in result msu */
2511 Unit *msu=res->lsu+D2U(res->digits)-1; /* current msu */
2512 Unit *msumax=res->lsu+D2U(set->digits)-1; /* rotation msu */
2513 for (msu++; msu<=msumax; msu++) *msu=0; /* ensure high units=0 */
2514 res->digits=set->digits; /* now full-length */
2515 msudigits=MSUDIGITS(res->digits); /* actual digits in msu */
2516
2517 /* rotation here is done in-place, in three steps */
2518 /* 1. shift all to least up to one unit to unit-align final */
2519 /* lsd [any digits shifted out are rotated to the left, */
2520 /* abutted to the original msd (which may require split)] */
2521 /* */
2522 /* [if there are no whole units left to rotate, the */
2523 /* rotation is now complete] */
2524 /* */
2525 /* 2. shift to least, from below the split point only, so that */
2526 /* the final msd is in the right place in its Unit [any */
2527 /* digits shifted out will fit exactly in the current msu, */
2528 /* left aligned, no split required] */
2529 /* */
2530 /* 3. rotate all the units by reversing left part, right */
2531 /* part, and then whole */
2532 /* */
2533 /* example: rotate right 8 digits (2 units + 2), DECDPUN=3. */
2534 /* */
2535 /* start: 00a bcd efg hij klm npq */
2536 /* */
2537 /* 1a 000 0ab cde fgh|ijk lmn [pq saved] */
2538 /* 1b 00p qab cde fgh|ijk lmn */
2539 /* */
2540 /* 2a 00p qab cde fgh|00i jkl [mn saved] */
2541 /* 2b mnp qab cde fgh|00i jkl */
2542 /* */
2543 /* 3a fgh cde qab mnp|00i jkl */
2544 /* 3b fgh cde qab mnp|jkl 00i */
2545 /* 3c 00i jkl mnp qab cde fgh */
2546
2547 /* Step 1: amount to shift is the partial right-rotate count */
2548 rotate=set->digits-rotate; /* make it right-rotate */
2549 units=rotate/DECDPUN; /* whole units to rotate */
2550 shift=rotate%DECDPUN; /* left-over digits count */
2551 if (shift>0) { /* not an exact number of units */
2552 uInt save=res->lsu[0]%powers[shift]; /* save low digit(s) */
2553 decShiftToLeast(res->lsu, D2U(res->digits), shift);
2554 if (shift>msudigits) { /* msumax-1 needs >0 digits */
2555 uInt rem=save%powers[shift-msudigits];/* split save */
2556 *msumax=(Unit)(save/powers[shift-msudigits]); /* and insert */
2557 *(msumax-1)=*(msumax-1)
2558 +(Unit)(rem*powers[DECDPUN-(shift-msudigits)]); /* .. */
2559 }
2560 else { /* all fits in msumax */
2561 *msumax=*msumax+(Unit)(save*powers[msudigits-shift]); /* [maybe *1] */
2562 }
2563 } /* digits shift needed */
2564
2565 /* If whole units to rotate... */
2566 if (units>0) { /* some to do */
2567 /* Step 2: the units to touch are the whole ones in rotate, */
2568 /* if any, and the shift is DECDPUN-msudigits (which may be */
2569 /* 0, again) */
2570 shift=DECDPUN-msudigits;
2571 if (shift>0) { /* not an exact number of units */
2572 uInt save=res->lsu[0]%powers[shift]; /* save low digit(s) */
2573 decShiftToLeast(res->lsu, units, shift);
2574 *msumax=*msumax+(Unit)(save*powers[msudigits]);
2575 } /* partial shift needed */
2576
2577 /* Step 3: rotate the units array using triple reverse */
2578 /* (reversing is easy and fast) */
2579 decReverse(res->lsu+units, msumax); /* left part */
2580 decReverse(res->lsu, res->lsu+units-1); /* right part */
2581 decReverse(res->lsu, msumax); /* whole */
2582 } /* whole units to rotate */
2583 /* the rotation may have left an undetermined number of zeros */
2584 /* on the left, so true length needs to be calculated */
2585 res->digits=decGetDigits(res->lsu, msumax-res->lsu+1);
2586 } /* rotate needed */
2587 } /* rhs OK */
2588 } /* numerics */
2589 if (status!=0) decStatus(res, status, set);
2590 return res;
2591 } /* decNumberRotate */
2592
2593 /* ------------------------------------------------------------------ */
2594 /* decNumberSameQuantum -- test for equal exponents */
2595 /* */
2596 /* res is the result number, which will contain either 0 or 1 */
2597 /* lhs is a number to test */
2598 /* rhs is the second (usually a pattern) */
2599 /* */
2600 /* No errors are possible and no context is needed. */
2601 /* ------------------------------------------------------------------ */
2602 U_CAPI decNumber * U_EXPORT2 uprv_decNumberSameQuantum(decNumber *res, const decNumber *lhs,
2603 const decNumber *rhs) {
2604 Unit ret=0; /* return value */
2605
2606 #if DECCHECK
2607 if (decCheckOperands(res, lhs, rhs, DECUNCONT)) return res;
2608 #endif
2609
2610 if (SPECIALARGS) {
2611 if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1;
2612 else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1;
2613 /* [anything else with a special gives 0] */
2614 }
2615 else if (lhs->exponent==rhs->exponent) ret=1;
2616
2617 uprv_decNumberZero(res); /* OK to overwrite an operand now */
2618 *res->lsu=ret;
2619 return res;
2620 } /* decNumberSameQuantum */
2621
2622 /* ------------------------------------------------------------------ */
2623 /* decNumberScaleB -- multiply by a power of 10 */
2624 /* */
2625 /* This computes C = A x 10**B where B is an integer (q=0) with */
2626 /* maximum magnitude 2*(emax+digits) */
2627 /* */
2628 /* res is C, the result. C may be A or B */
2629 /* lhs is A, the number to adjust */
2630 /* rhs is B, the requested power of ten to use */
2631 /* set is the context */
2632 /* */
2633 /* C must have space for set->digits digits. */
2634 /* */
2635 /* The result may underflow or overflow. */
2636 /* ------------------------------------------------------------------ */
2637 U_CAPI decNumber * U_EXPORT2 uprv_decNumberScaleB(decNumber *res, const decNumber *lhs,
2638 const decNumber *rhs, decContext *set) {
2639 Int reqexp; /* requested exponent change [B] */
2640 uInt status=0; /* accumulator */
2641 Int residue; /* work */
2642
2643 #if DECCHECK
2644 if (decCheckOperands(res, lhs, rhs, set)) return res;
2645 #endif
2646
2647 /* Handle special values except lhs infinite */
2648 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2649 decNaNs(res, lhs, rhs, set, &status);
2650 /* rhs must be an integer */
2651 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2652 status=DEC_Invalid_operation;
2653 else {
2654 /* lhs is a number; rhs is a finite with q==0 */
2655 reqexp=decGetInt(rhs); /* [cannot fail] */
2656 if (reqexp==BADINT /* something bad .. */
2657 || reqexp==BIGODD || reqexp==BIGEVEN /* .. very big .. */
2658 || abs(reqexp)>(2*(set->digits+set->emax))) /* .. or out of range */
2659 status=DEC_Invalid_operation;
2660 else { /* rhs is OK */
2661 uprv_decNumberCopy(res, lhs); /* all done if infinite lhs */
2662 if (!decNumberIsInfinite(res)) { /* prepare to scale */
2663 res->exponent+=reqexp; /* adjust the exponent */
2664 residue=0;
2665 decFinalize(res, set, &residue, &status); /* .. and check */
2666 } /* finite LHS */
2667 } /* rhs OK */
2668 } /* rhs finite */
2669 if (status!=0) decStatus(res, status, set);
2670 return res;
2671 } /* decNumberScaleB */
2672
2673 /* ------------------------------------------------------------------ */
2674 /* decNumberShift -- shift the coefficient of a Number left or right */
2675 /* */
2676 /* This computes C = A << B or C = A >> -B (in base ten). */
2677 /* */
2678 /* res is C, the result. C may be A and/or B (e.g., X=X<<X) */
2679 /* lhs is A */
2680 /* rhs is B, the number of digits to shift (-ve to right) */
2681 /* set is the context */
2682 /* */
2683 /* The digits of the coefficient of A are shifted to the left (if B */
2684 /* is positive) or to the right (if B is negative) without adjusting */
2685 /* the exponent or the sign of A. */
2686 /* */
2687 /* B must be an integer (q=0) and in the range -set->digits through */
2688 /* +set->digits. */
2689 /* C must have space for set->digits digits. */
2690 /* NaNs are propagated as usual. Infinities are unaffected (but */
2691 /* B must be valid). No status is set unless B is invalid or an */
2692 /* operand is an sNaN. */
2693 /* ------------------------------------------------------------------ */
2694 U_CAPI decNumber * U_EXPORT2 uprv_decNumberShift(decNumber *res, const decNumber *lhs,
2695 const decNumber *rhs, decContext *set) {
2696 uInt status=0; /* accumulator */
2697 Int shift; /* rhs as an Int */
2698
2699 #if DECCHECK
2700 if (decCheckOperands(res, lhs, rhs, set)) return res;
2701 #endif
2702
2703 /* NaNs propagate as normal */
2704 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2705 decNaNs(res, lhs, rhs, set, &status);
2706 /* rhs must be an integer */
2707 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2708 status=DEC_Invalid_operation;
2709 else { /* both numeric, rhs is an integer */
2710 shift=decGetInt(rhs); /* [cannot fail] */
2711 if (shift==BADINT /* something bad .. */
2712 || shift==BIGODD || shift==BIGEVEN /* .. very big .. */
2713 || abs(shift)>set->digits) /* .. or out of range */
2714 status=DEC_Invalid_operation;
2715 else { /* rhs is OK */
2716 uprv_decNumberCopy(res, lhs);
2717 if (shift!=0 && !decNumberIsInfinite(res)) { /* something to do */
2718 if (shift>0) { /* to left */
2719 if (shift==set->digits) { /* removing all */
2720 *res->lsu=0; /* so place 0 */
2721 res->digits=1; /* .. */
2722 }
2723 else { /* */
2724 /* first remove leading digits if necessary */
2725 if (res->digits+shift>set->digits) {
2726 decDecap(res, res->digits+shift-set->digits);
2727 /* that updated res->digits; may have gone to 1 (for a */
2728 /* single digit or for zero */
2729 }
2730 if (res->digits>1 || *res->lsu) /* if non-zero.. */
2731 res->digits=decShiftToMost(res->lsu, res->digits, shift);
2732 } /* partial left */
2733 } /* left */
2734 else { /* to right */
2735 if (-shift>=res->digits) { /* discarding all */
2736 *res->lsu=0; /* so place 0 */
2737 res->digits=1; /* .. */
2738 }
2739 else {
2740 decShiftToLeast(res->lsu, D2U(res->digits), -shift);
2741 res->digits-=(-shift);
2742 }
2743 } /* to right */
2744 } /* non-0 non-Inf shift */
2745 } /* rhs OK */
2746 } /* numerics */
2747 if (status!=0) decStatus(res, status, set);
2748 return res;
2749 } /* decNumberShift */
2750
2751 /* ------------------------------------------------------------------ */
2752 /* decNumberSquareRoot -- square root operator */
2753 /* */
2754 /* This computes C = squareroot(A) */
2755 /* */
2756 /* res is C, the result. C may be A */
2757 /* rhs is A */
2758 /* set is the context; note that rounding mode has no effect */
2759 /* */
2760 /* C must have space for set->digits digits. */
2761 /* ------------------------------------------------------------------ */
2762 /* This uses the following varying-precision algorithm in: */
2763 /* */
2764 /* Properly Rounded Variable Precision Square Root, T. E. Hull and */
2765 /* A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, */
2766 /* pp229-237, ACM, September 1985. */
2767 /* */
2768 /* The square-root is calculated using Newton's method, after which */
2769 /* a check is made to ensure the result is correctly rounded. */
2770 /* */
2771 /* % [Reformatted original Numerical Turing source code follows.] */
2772 /* function sqrt(x : real) : real */
2773 /* % sqrt(x) returns the properly rounded approximation to the square */
2774 /* % root of x, in the precision of the calling environment, or it */
2775 /* % fails if x < 0. */
2776 /* % t e hull and a abrham, august, 1984 */
2777 /* if x <= 0 then */
2778 /* if x < 0 then */
2779 /* assert false */
2780 /* else */
2781 /* result 0 */
2782 /* end if */
2783 /* end if */
2784 /* var f := setexp(x, 0) % fraction part of x [0.1 <= x < 1] */
2785 /* var e := getexp(x) % exponent part of x */
2786 /* var approx : real */
2787 /* if e mod 2 = 0 then */
2788 /* approx := .259 + .819 * f % approx to root of f */
2789 /* else */
2790 /* f := f/l0 % adjustments */
2791 /* e := e + 1 % for odd */
2792 /* approx := .0819 + 2.59 * f % exponent */
2793 /* end if */
2794 /* */
2795 /* var p:= 3 */
2796 /* const maxp := currentprecision + 2 */
2797 /* loop */
2798 /* p := min(2*p - 2, maxp) % p = 4,6,10, . . . , maxp */
2799 /* precision p */
2800 /* approx := .5 * (approx + f/approx) */
2801 /* exit when p = maxp */
2802 /* end loop */
2803 /* */
2804 /* % approx is now within 1 ulp of the properly rounded square root */
2805 /* % of f; to ensure proper rounding, compare squares of (approx - */
2806 /* % l/2 ulp) and (approx + l/2 ulp) with f. */
2807 /* p := currentprecision */
2808 /* begin */
2809 /* precision p + 2 */
2810 /* const approxsubhalf := approx - setexp(.5, -p) */
2811 /* if mulru(approxsubhalf, approxsubhalf) > f then */
2812 /* approx := approx - setexp(.l, -p + 1) */
2813 /* else */
2814 /* const approxaddhalf := approx + setexp(.5, -p) */
2815 /* if mulrd(approxaddhalf, approxaddhalf) < f then */
2816 /* approx := approx + setexp(.l, -p + 1) */
2817 /* end if */
2818 /* end if */
2819 /* end */
2820 /* result setexp(approx, e div 2) % fix exponent */
2821 /* end sqrt */
2822 /* ------------------------------------------------------------------ */
2823 #if defined(__clang__) || U_GCC_MAJOR_MINOR >= 406
2824 #pragma GCC diagnostic push
2825 #pragma GCC diagnostic ignored "-Warray-bounds"
2826 #endif
2827 U_CAPI decNumber * U_EXPORT2 uprv_decNumberSquareRoot(decNumber *res, const decNumber *rhs,
2828 decContext *set) {
2829 decContext workset, approxset; /* work contexts */
2830 decNumber dzero; /* used for constant zero */
2831 Int maxp; /* largest working precision */
2832 Int workp; /* working precision */
2833 Int residue=0; /* rounding residue */
2834 uInt status=0, ignore=0; /* status accumulators */
2835 uInt rstatus; /* .. */
2836 Int exp; /* working exponent */
2837 Int ideal; /* ideal (preferred) exponent */
2838 Int needbytes; /* work */
2839 Int dropped; /* .. */
2840
2841 #if DECSUBSET
2842 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
2843 #endif
2844 /* buffer for f [needs +1 in case DECBUFFER 0] */
2845 decNumber buff[D2N(DECBUFFER+1)];
2846 /* buffer for a [needs +2 to match likely maxp] */
2847 decNumber bufa[D2N(DECBUFFER+2)];
2848 /* buffer for temporary, b [must be same size as a] */
2849 decNumber bufb[D2N(DECBUFFER+2)];
2850 decNumber *allocbuff=NULL; /* -> allocated buff, iff allocated */
2851 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
2852 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */
2853 decNumber *f=buff; /* reduced fraction */
2854 decNumber *a=bufa; /* approximation to result */
2855 decNumber *b=bufb; /* intermediate result */
2856 /* buffer for temporary variable, up to 3 digits */
2857 decNumber buft[D2N(3)];
2858 decNumber *t=buft; /* up-to-3-digit constant or work */
2859
2860 #if DECCHECK
2861 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2862 #endif
2863
2864 do { /* protect allocated storage */
2865 #if DECSUBSET
2866 if (!set->extended) {
2867 /* reduce operand and set lostDigits status, as needed */
2868 if (rhs->digits>set->digits) {
2869 allocrhs=decRoundOperand(rhs, set, &status);
2870 if (allocrhs==NULL) break;
2871 /* [Note: 'f' allocation below could reuse this buffer if */
2872 /* used, but as this is rare they are kept separate for clarity.] */
2873 rhs=allocrhs;
2874 }
2875 }
2876 #endif
2877 /* [following code does not require input rounding] */
2878
2879 /* handle infinities and NaNs */
2880 if (SPECIALARG) {
2881 if (decNumberIsInfinite(rhs)) { /* an infinity */
2882 if (decNumberIsNegative(rhs)) status|=DEC_Invalid_operation;
2883 else uprv_decNumberCopy(res, rhs); /* +Infinity */
2884 }
2885 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
2886 break;
2887 }
2888
2889 /* calculate the ideal (preferred) exponent [floor(exp/2)] */
2890 /* [It would be nicer to write: ideal=rhs->exponent>>1, but this */
2891 /* generates a compiler warning. Generated code is the same.] */
2892 ideal=(rhs->exponent&~1)/2; /* target */
2893
2894 /* handle zeros */
2895 if (ISZERO(rhs)) {
2896 uprv_decNumberCopy(res, rhs); /* could be 0 or -0 */
2897 res->exponent=ideal; /* use the ideal [safe] */
2898 /* use decFinish to clamp any out-of-range exponent, etc. */
2899 decFinish(res, set, &residue, &status);
2900 break;
2901 }
2902
2903 /* any other -x is an oops */
2904 if (decNumberIsNegative(rhs)) {
2905 status|=DEC_Invalid_operation;
2906 break;
2907 }
2908
2909 /* space is needed for three working variables */
2910 /* f -- the same precision as the RHS, reduced to 0.01->0.99... */
2911 /* a -- Hull's approximation -- precision, when assigned, is */
2912 /* currentprecision+1 or the input argument precision, */
2913 /* whichever is larger (+2 for use as temporary) */
2914 /* b -- intermediate temporary result (same size as a) */
2915 /* if any is too long for local storage, then allocate */
2916 workp=MAXI(set->digits+1, rhs->digits); /* actual rounding precision */
2917 workp=MAXI(workp, 7); /* at least 7 for low cases */
2918 maxp=workp+2; /* largest working precision */
2919
2920 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
2921 if (needbytes>(Int)sizeof(buff)) {
2922 allocbuff=(decNumber *)malloc(needbytes);
2923 if (allocbuff==NULL) { /* hopeless -- abandon */
2924 status|=DEC_Insufficient_storage;
2925 break;}
2926 f=allocbuff; /* use the allocated space */
2927 }
2928 /* a and b both need to be able to hold a maxp-length number */
2929 needbytes=sizeof(decNumber)+(D2U(maxp)-1)*sizeof(Unit);
2930 if (needbytes>(Int)sizeof(bufa)) { /* [same applies to b] */
2931 allocbufa=(decNumber *)malloc(needbytes);
2932 allocbufb=(decNumber *)malloc(needbytes);
2933 if (allocbufa==NULL || allocbufb==NULL) { /* hopeless */
2934 status|=DEC_Insufficient_storage;
2935 break;}
2936 a=allocbufa; /* use the allocated spaces */
2937 b=allocbufb; /* .. */
2938 }
2939
2940 /* copy rhs -> f, save exponent, and reduce so 0.1 <= f < 1 */
2941 uprv_decNumberCopy(f, rhs);
2942 exp=f->exponent+f->digits; /* adjusted to Hull rules */
2943 f->exponent=-(f->digits); /* to range */
2944
2945 /* set up working context */
2946 uprv_decContextDefault(&workset, DEC_INIT_DECIMAL64);
2947 workset.emax=DEC_MAX_EMAX;
2948 workset.emin=DEC_MIN_EMIN;
2949
2950 /* [Until further notice, no error is possible and status bits */
2951 /* (Rounded, etc.) should be ignored, not accumulated.] */
2952
2953 /* Calculate initial approximation, and allow for odd exponent */
2954 workset.digits=workp; /* p for initial calculation */
2955 t->bits=0; t->digits=3;
2956 a->bits=0; a->digits=3;
2957 if ((exp & 1)==0) { /* even exponent */
2958 /* Set t=0.259, a=0.819 */
2959 t->exponent=-3;
2960 a->exponent=-3;
2961 #if DECDPUN>=3
2962 t->lsu[0]=259;
2963 a->lsu[0]=819;
2964 #elif DECDPUN==2
2965 t->lsu[0]=59; t->lsu[1]=2;
2966 a->lsu[0]=19; a->lsu[1]=8;
2967 #else
2968 t->lsu[0]=9; t->lsu[1]=5; t->lsu[2]=2;
2969 a->lsu[0]=9; a->lsu[1]=1; a->lsu[2]=8;
2970 #endif
2971 }
2972 else { /* odd exponent */
2973 /* Set t=0.0819, a=2.59 */
2974 f->exponent--; /* f=f/10 */
2975 exp++; /* e=e+1 */
2976 t->exponent=-4;
2977 a->exponent=-2;
2978 #if DECDPUN>=3
2979 t->lsu[0]=819;
2980 a->lsu[0]=259;
2981 #elif DECDPUN==2
2982 t->lsu[0]=19; t->lsu[1]=8;
2983 a->lsu[0]=59; a->lsu[1]=2;
2984 #else
2985 t->lsu[0]=9; t->lsu[1]=1; t->lsu[2]=8;
2986 a->lsu[0]=9; a->lsu[1]=5; a->lsu[2]=2;
2987 #endif
2988 }
2989
2990 decMultiplyOp(a, a, f, &workset, &ignore); /* a=a*f */
2991 decAddOp(a, a, t, &workset, 0, &ignore); /* ..+t */
2992 /* [a is now the initial approximation for sqrt(f), calculated with */
2993 /* currentprecision, which is also a's precision.] */
2994
2995 /* the main calculation loop */
2996 uprv_decNumberZero(&dzero); /* make 0 */
2997 uprv_decNumberZero(t); /* set t = 0.5 */
2998 t->lsu[0]=5; /* .. */
2999 t->exponent=-1; /* .. */
3000 workset.digits=3; /* initial p */
3001 for (; workset.digits<maxp;) {
3002 /* set p to min(2*p - 2, maxp) [hence 3; or: 4, 6, 10, ... , maxp] */
3003 workset.digits=MINI(workset.digits*2-2, maxp);
3004 /* a = 0.5 * (a + f/a) */
3005 /* [calculated at p then rounded to currentprecision] */
3006 decDivideOp(b, f, a, &workset, DIVIDE, &ignore); /* b=f/a */
3007 decAddOp(b, b, a, &workset, 0, &ignore); /* b=b+a */
3008 decMultiplyOp(a, b, t, &workset, &ignore); /* a=b*0.5 */
3009 } /* loop */
3010
3011 /* Here, 0.1 <= a < 1 [Hull], and a has maxp digits */
3012 /* now reduce to length, etc.; this needs to be done with a */
3013 /* having the correct exponent so as to handle subnormals */
3014 /* correctly */
3015 approxset=*set; /* get emin, emax, etc. */
3016 approxset.round=DEC_ROUND_HALF_EVEN;
3017 a->exponent+=exp/2; /* set correct exponent */
3018 rstatus=0; /* clear status */
3019 residue=0; /* .. and accumulator */
3020 decCopyFit(a, a, &approxset, &residue, &rstatus); /* reduce (if needed) */
3021 decFinish(a, &approxset, &residue, &rstatus); /* clean and finalize */
3022
3023 /* Overflow was possible if the input exponent was out-of-range, */
3024 /* in which case quit */
3025 if (rstatus&DEC_Overflow) {
3026 status=rstatus; /* use the status as-is */
3027 uprv_decNumberCopy(res, a); /* copy to result */
3028 break;
3029 }
3030
3031 /* Preserve status except Inexact/Rounded */
3032 status|=(rstatus & ~(DEC_Rounded|DEC_Inexact));
3033
3034 /* Carry out the Hull correction */
3035 a->exponent-=exp/2; /* back to 0.1->1 */
3036
3037 /* a is now at final precision and within 1 ulp of the properly */
3038 /* rounded square root of f; to ensure proper rounding, compare */
3039 /* squares of (a - l/2 ulp) and (a + l/2 ulp) with f. */
3040 /* Here workset.digits=maxp and t=0.5, and a->digits determines */
3041 /* the ulp */
3042 workset.digits--; /* maxp-1 is OK now */
3043 t->exponent=-a->digits-1; /* make 0.5 ulp */
3044 decAddOp(b, a, t, &workset, DECNEG, &ignore); /* b = a - 0.5 ulp */
3045 workset.round=DEC_ROUND_UP;
3046 decMultiplyOp(b, b, b, &workset, &ignore); /* b = mulru(b, b) */
3047 decCompareOp(b, f, b, &workset, COMPARE, &ignore); /* b ? f, reversed */
3048 if (decNumberIsNegative(b)) { /* f < b [i.e., b > f] */
3049 /* this is the more common adjustment, though both are rare */
3050 t->exponent++; /* make 1.0 ulp */
3051 t->lsu[0]=1; /* .. */
3052 decAddOp(a, a, t, &workset, DECNEG, &ignore); /* a = a - 1 ulp */
3053 /* assign to approx [round to length] */
3054 approxset.emin-=exp/2; /* adjust to match a */
3055 approxset.emax-=exp/2;
3056 decAddOp(a, &dzero, a, &approxset, 0, &ignore);
3057 }
3058 else {
3059 decAddOp(b, a, t, &workset, 0, &ignore); /* b = a + 0.5 ulp */
3060 workset.round=DEC_ROUND_DOWN;
3061 decMultiplyOp(b, b, b, &workset, &ignore); /* b = mulrd(b, b) */
3062 decCompareOp(b, b, f, &workset, COMPARE, &ignore); /* b ? f */
3063 if (decNumberIsNegative(b)) { /* b < f */
3064 t->exponent++; /* make 1.0 ulp */
3065 t->lsu[0]=1; /* .. */
3066 decAddOp(a, a, t, &workset, 0, &ignore); /* a = a + 1 ulp */
3067 /* assign to approx [round to length] */
3068 approxset.emin-=exp/2; /* adjust to match a */
3069 approxset.emax-=exp/2;
3070 decAddOp(a, &dzero, a, &approxset, 0, &ignore);
3071 }
3072 }
3073 /* [no errors are possible in the above, and rounding/inexact during */
3074 /* estimation are irrelevant, so status was not accumulated] */
3075
3076 /* Here, 0.1 <= a < 1 (still), so adjust back */
3077 a->exponent+=exp/2; /* set correct exponent */
3078
3079 /* count droppable zeros [after any subnormal rounding] by */
3080 /* trimming a copy */
3081 uprv_decNumberCopy(b, a);
3082 decTrim(b, set, 1, 1, &dropped); /* [drops trailing zeros] */
3083
3084 /* Set Inexact and Rounded. The answer can only be exact if */
3085 /* it is short enough so that squaring it could fit in workp */
3086 /* digits, so this is the only (relatively rare) condition that */
3087 /* a careful check is needed */
3088 if (b->digits*2-1 > workp) { /* cannot fit */
3089 status|=DEC_Inexact|DEC_Rounded;
3090 }
3091 else { /* could be exact/unrounded */
3092 uInt mstatus=0; /* local status */
3093 decMultiplyOp(b, b, b, &workset, &mstatus); /* try the multiply */
3094 if (mstatus&DEC_Overflow) { /* result just won't fit */
3095 status|=DEC_Inexact|DEC_Rounded;
3096 }
3097 else { /* plausible */
3098 decCompareOp(t, b, rhs, &workset, COMPARE, &mstatus); /* b ? rhs */
3099 if (!ISZERO(t)) status|=DEC_Inexact|DEC_Rounded; /* not equal */
3100 else { /* is Exact */
3101 /* here, dropped is the count of trailing zeros in 'a' */
3102 /* use closest exponent to ideal... */
3103 Int todrop=ideal-a->exponent; /* most that can be dropped */
3104 if (todrop<0) status|=DEC_Rounded; /* ideally would add 0s */
3105 else { /* unrounded */
3106 /* there are some to drop, but emax may not allow all */
3107 Int maxexp=set->emax-set->digits+1;
3108 Int maxdrop=maxexp-a->exponent;
3109 if (todrop>maxdrop && set->clamp) { /* apply clamping */
3110 todrop=maxdrop;
3111 status|=DEC_Clamped;
3112 }
3113 if (dropped<todrop) { /* clamp to those available */
3114 todrop=dropped;
3115 status|=DEC_Clamped;
3116 }
3117 if (todrop>0) { /* have some to drop */
3118 decShiftToLeast(a->lsu, D2U(a->digits), todrop);
3119 a->exponent+=todrop; /* maintain numerical value */
3120 a->digits-=todrop; /* new length */
3121 }
3122 }
3123 }
3124 }
3125 }
3126
3127 /* double-check Underflow, as perhaps the result could not have */
3128 /* been subnormal (initial argument too big), or it is now Exact */
3129 if (status&DEC_Underflow) {
3130 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */
3131 /* check if truly subnormal */
3132 #if DECEXTFLAG /* DEC_Subnormal too */
3133 if (ae>=set->emin*2) status&=~(DEC_Subnormal|DEC_Underflow);
3134 #else
3135 if (ae>=set->emin*2) status&=~DEC_Underflow;
3136 #endif
3137 /* check if truly inexact */
3138 if (!(status&DEC_Inexact)) status&=~DEC_Underflow;
3139 }
3140
3141 uprv_decNumberCopy(res, a); /* a is now the result */
3142 } while(0); /* end protected */
3143
3144 if (allocbuff!=NULL) free(allocbuff); /* drop any storage used */
3145 if (allocbufa!=NULL) free(allocbufa); /* .. */
3146 if (allocbufb!=NULL) free(allocbufb); /* .. */
3147 #if DECSUBSET
3148 if (allocrhs !=NULL) free(allocrhs); /* .. */
3149 #endif
3150 if (status!=0) decStatus(res, status, set);/* then report status */
3151 #if DECCHECK
3152 decCheckInexact(res, set);
3153 #endif
3154 return res;
3155 } /* decNumberSquareRoot */
3156 #if defined(__clang__) || U_GCC_MAJOR_MINOR >= 406
3157 #pragma GCC diagnostic pop
3158 #endif
3159
3160 /* ------------------------------------------------------------------ */
3161 /* decNumberSubtract -- subtract two Numbers */
3162 /* */
3163 /* This computes C = A - B */
3164 /* */
3165 /* res is C, the result. C may be A and/or B (e.g., X=X-X) */
3166 /* lhs is A */
3167 /* rhs is B */
3168 /* set is the context */
3169 /* */
3170 /* C must have space for set->digits digits. */
3171 /* ------------------------------------------------------------------ */
3172 U_CAPI decNumber * U_EXPORT2 uprv_decNumberSubtract(decNumber *res, const decNumber *lhs,
3173 const decNumber *rhs, decContext *set) {
3174 uInt status=0; /* accumulator */
3175
3176 decAddOp(res, lhs, rhs, set, DECNEG, &status);
3177 if (status!=0) decStatus(res, status, set);
3178 #if DECCHECK
3179 decCheckInexact(res, set);
3180 #endif
3181 return res;
3182 } /* decNumberSubtract */
3183
3184 /* ------------------------------------------------------------------ */
3185 /* decNumberToIntegralExact -- round-to-integral-value with InExact */
3186 /* decNumberToIntegralValue -- round-to-integral-value */
3187 /* */
3188 /* res is the result */
3189 /* rhs is input number */
3190 /* set is the context */
3191 /* */
3192 /* res must have space for any value of rhs. */
3193 /* */
3194 /* This implements the IEEE special operators and therefore treats */
3195 /* special values as valid. For finite numbers it returns */
3196 /* rescale(rhs, 0) if rhs->exponent is <0. */
3197 /* Otherwise the result is rhs (so no error is possible, except for */
3198 /* sNaN). */
3199 /* */
3200 /* The context is used for rounding mode and status after sNaN, but */
3201 /* the digits setting is ignored. The Exact version will signal */
3202 /* Inexact if the result differs numerically from rhs; the other */
3203 /* never signals Inexact. */
3204 /* ------------------------------------------------------------------ */
3205 U_CAPI decNumber * U_EXPORT2 uprv_decNumberToIntegralExact(decNumber *res, const decNumber *rhs,
3206 decContext *set) {
3207 decNumber dn;
3208 decContext workset; /* working context */
3209 uInt status=0; /* accumulator */
3210
3211 #if DECCHECK
3212 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
3213 #endif
3214
3215 /* handle infinities and NaNs */
3216 if (SPECIALARG) {
3217 if (decNumberIsInfinite(rhs)) uprv_decNumberCopy(res, rhs); /* an Infinity */
3218 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
3219 }
3220 else { /* finite */
3221 /* have a finite number; no error possible (res must be big enough) */
3222 if (rhs->exponent>=0) return uprv_decNumberCopy(res, rhs);
3223 /* that was easy, but if negative exponent there is work to do... */
3224 workset=*set; /* clone rounding, etc. */
3225 workset.digits=rhs->digits; /* no length rounding */
3226 workset.traps=0; /* no traps */
3227 uprv_decNumberZero(&dn); /* make a number with exponent 0 */
3228 uprv_decNumberQuantize(res, rhs, &dn, &workset);
3229 status|=workset.status;
3230 }
3231 if (status!=0) decStatus(res, status, set);
3232 return res;
3233 } /* decNumberToIntegralExact */
3234
3235 U_CAPI decNumber * U_EXPORT2 uprv_decNumberToIntegralValue(decNumber *res, const decNumber *rhs,
3236 decContext *set) {
3237 decContext workset=*set; /* working context */
3238 workset.traps=0; /* no traps */
3239 uprv_decNumberToIntegralExact(res, rhs, &workset);
3240 /* this never affects set, except for sNaNs; NaN will have been set */
3241 /* or propagated already, so no need to call decStatus */
3242 set->status|=workset.status&DEC_Invalid_operation;
3243 return res;
3244 } /* decNumberToIntegralValue */
3245
3246 /* ------------------------------------------------------------------ */
3247 /* decNumberXor -- XOR two Numbers, digitwise */
3248 /* */
3249 /* This computes C = A ^ B */
3250 /* */
3251 /* res is C, the result. C may be A and/or B (e.g., X=X^X) */
3252 /* lhs is A */
3253 /* rhs is B */
3254 /* set is the context (used for result length and error report) */
3255 /* */
3256 /* C must have space for set->digits digits. */
3257 /* */
3258 /* Logical function restrictions apply (see above); a NaN is */
3259 /* returned with Invalid_operation if a restriction is violated. */
3260 /* ------------------------------------------------------------------ */
3261 U_CAPI decNumber * U_EXPORT2 uprv_decNumberXor(decNumber *res, const decNumber *lhs,
3262 const decNumber *rhs, decContext *set) {
3263 const Unit *ua, *ub; /* -> operands */
3264 const Unit *msua, *msub; /* -> operand msus */
3265 Unit *uc, *msuc; /* -> result and its msu */
3266 Int msudigs; /* digits in res msu */
3267 #if DECCHECK
3268 if (decCheckOperands(res, lhs, rhs, set)) return res;
3269 #endif
3270
3271 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
3272 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
3273 decStatus(res, DEC_Invalid_operation, set);
3274 return res;
3275 }
3276 /* operands are valid */
3277 ua=lhs->lsu; /* bottom-up */
3278 ub=rhs->lsu; /* .. */
3279 uc=res->lsu; /* .. */
3280 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */
3281 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */
3282 msuc=uc+D2U(set->digits)-1; /* -> msu of result */
3283 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */
3284 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */
3285 Unit a, b; /* extract units */
3286 if (ua>msua) a=0;
3287 else a=*ua;
3288 if (ub>msub) b=0;
3289 else b=*ub;
3290 *uc=0; /* can now write back */
3291 if (a|b) { /* maybe 1 bits to examine */
3292 Int i, j;
3293 /* This loop could be unrolled and/or use BIN2BCD tables */
3294 for (i=0; i<DECDPUN; i++) {
3295 if ((a^b)&1) *uc=*uc+(Unit)powers[i]; /* effect XOR */
3296 j=a%10;
3297 a=a/10;
3298 j|=b%10;
3299 b=b/10;
3300 if (j>1) {
3301 decStatus(res, DEC_Invalid_operation, set);
3302 return res;
3303 }
3304 if (uc==msuc && i==msudigs-1) break; /* just did final digit */
3305 } /* each digit */
3306 } /* non-zero */
3307 } /* each unit */
3308 /* [here uc-1 is the msu of the result] */
3309 res->digits=decGetDigits(res->lsu, uc-res->lsu);
3310 res->exponent=0; /* integer */
3311 res->bits=0; /* sign=0 */
3312 return res; /* [no status to set] */
3313 } /* decNumberXor */
3314
3315
3316 /* ================================================================== */
3317 /* Utility routines */
3318 /* ================================================================== */
3319
3320 /* ------------------------------------------------------------------ */
3321 /* decNumberClass -- return the decClass of a decNumber */
3322 /* dn -- the decNumber to test */
3323 /* set -- the context to use for Emin */
3324 /* returns the decClass enum */
3325 /* ------------------------------------------------------------------ */
3326 enum decClass uprv_decNumberClass(const decNumber *dn, decContext *set) {
3327 if (decNumberIsSpecial(dn)) {
3328 if (decNumberIsQNaN(dn)) return DEC_CLASS_QNAN;
3329 if (decNumberIsSNaN(dn)) return DEC_CLASS_SNAN;
3330 /* must be an infinity */
3331 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_INF;
3332 return DEC_CLASS_POS_INF;
3333 }
3334 /* is finite */
3335 if (uprv_decNumberIsNormal(dn, set)) { /* most common */
3336 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_NORMAL;
3337 return DEC_CLASS_POS_NORMAL;
3338 }
3339 /* is subnormal or zero */
3340 if (decNumberIsZero(dn)) { /* most common */
3341 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_ZERO;
3342 return DEC_CLASS_POS_ZERO;
3343 }
3344 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_SUBNORMAL;
3345 return DEC_CLASS_POS_SUBNORMAL;
3346 } /* decNumberClass */
3347
3348 /* ------------------------------------------------------------------ */
3349 /* decNumberClassToString -- convert decClass to a string */
3350 /* */
3351 /* eclass is a valid decClass */
3352 /* returns a constant string describing the class (max 13+1 chars) */
3353 /* ------------------------------------------------------------------ */
3354 const char *uprv_decNumberClassToString(enum decClass eclass) {
3355 if (eclass==DEC_CLASS_POS_NORMAL) return DEC_ClassString_PN;
3356 if (eclass==DEC_CLASS_NEG_NORMAL) return DEC_ClassString_NN;
3357 if (eclass==DEC_CLASS_POS_ZERO) return DEC_ClassString_PZ;
3358 if (eclass==DEC_CLASS_NEG_ZERO) return DEC_ClassString_NZ;
3359 if (eclass==DEC_CLASS_POS_SUBNORMAL) return DEC_ClassString_PS;
3360 if (eclass==DEC_CLASS_NEG_SUBNORMAL) return DEC_ClassString_NS;
3361 if (eclass==DEC_CLASS_POS_INF) return DEC_ClassString_PI;
3362 if (eclass==DEC_CLASS_NEG_INF) return DEC_ClassString_NI;
3363 if (eclass==DEC_CLASS_QNAN) return DEC_ClassString_QN;
3364 if (eclass==DEC_CLASS_SNAN) return DEC_ClassString_SN;
3365 return DEC_ClassString_UN; /* Unknown */
3366 } /* decNumberClassToString */
3367
3368 /* ------------------------------------------------------------------ */
3369 /* decNumberCopy -- copy a number */
3370 /* */
3371 /* dest is the target decNumber */
3372 /* src is the source decNumber */
3373 /* returns dest */
3374 /* */
3375 /* (dest==src is allowed and is a no-op) */
3376 /* All fields are updated as required. This is a utility operation, */
3377 /* so special values are unchanged and no error is possible. */
3378 /* ------------------------------------------------------------------ */
3379 U_CAPI decNumber * U_EXPORT2 uprv_decNumberCopy(decNumber *dest, const decNumber *src) {
3380
3381 #if DECCHECK
3382 if (src==NULL) return uprv_decNumberZero(dest);
3383 #endif
3384
3385 if (dest==src) return dest; /* no copy required */
3386
3387 /* Use explicit assignments here as structure assignment could copy */
3388 /* more than just the lsu (for small DECDPUN). This would not affect */
3389 /* the value of the results, but could disturb test harness spill */
3390 /* checking. */
3391 dest->bits=src->bits;
3392 dest->exponent=src->exponent;
3393 dest->digits=src->digits;
3394 dest->lsu[0]=src->lsu[0];
3395 if (src->digits>DECDPUN) { /* more Units to come */
3396 const Unit *smsup, *s; /* work */
3397 Unit *d; /* .. */
3398 /* memcpy for the remaining Units would be safe as they cannot */
3399 /* overlap. However, this explicit loop is faster in short cases. */
3400 d=dest->lsu+1; /* -> first destination */
3401 smsup=src->lsu+D2U(src->digits); /* -> source msu+1 */
3402 for (s=src->lsu+1; s<smsup; s++, d++) *d=*s;
3403 }
3404 return dest;
3405 } /* decNumberCopy */
3406
3407 /* ------------------------------------------------------------------ */
3408 /* decNumberCopyAbs -- quiet absolute value operator */
3409 /* */
3410 /* This sets C = abs(A) */
3411 /* */
3412 /* res is C, the result. C may be A */
3413 /* rhs is A */
3414 /* */
3415 /* C must have space for set->digits digits. */
3416 /* No exception or error can occur; this is a quiet bitwise operation.*/
3417 /* See also decNumberAbs for a checking version of this. */
3418 /* ------------------------------------------------------------------ */
3419 U_CAPI decNumber * U_EXPORT2 uprv_decNumberCopyAbs(decNumber *res, const decNumber *rhs) {
3420 #if DECCHECK
3421 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3422 #endif
3423 uprv_decNumberCopy(res, rhs);
3424 res->bits&=~DECNEG; /* turn off sign */
3425 return res;
3426 } /* decNumberCopyAbs */
3427
3428 /* ------------------------------------------------------------------ */
3429 /* decNumberCopyNegate -- quiet negate value operator */
3430 /* */
3431 /* This sets C = negate(A) */
3432 /* */
3433 /* res is C, the result. C may be A */
3434 /* rhs is A */
3435 /* */
3436 /* C must have space for set->digits digits. */
3437 /* No exception or error can occur; this is a quiet bitwise operation.*/
3438 /* See also decNumberMinus for a checking version of this. */
3439 /* ------------------------------------------------------------------ */
3440 U_CAPI decNumber * U_EXPORT2 uprv_decNumberCopyNegate(decNumber *res, const decNumber *rhs) {
3441 #if DECCHECK
3442 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3443 #endif
3444 uprv_decNumberCopy(res, rhs);
3445 res->bits^=DECNEG; /* invert the sign */
3446 return res;
3447 } /* decNumberCopyNegate */
3448
3449 /* ------------------------------------------------------------------ */
3450 /* decNumberCopySign -- quiet copy and set sign operator */
3451 /* */
3452 /* This sets C = A with the sign of B */
3453 /* */
3454 /* res is C, the result. C may be A */
3455 /* lhs is A */
3456 /* rhs is B */
3457 /* */
3458 /* C must have space for set->digits digits. */
3459 /* No exception or error can occur; this is a quiet bitwise operation.*/
3460 /* ------------------------------------------------------------------ */
3461 U_CAPI decNumber * U_EXPORT2 uprv_decNumberCopySign(decNumber *res, const decNumber *lhs,
3462 const decNumber *rhs) {
3463 uByte sign; /* rhs sign */
3464 #if DECCHECK
3465 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3466 #endif
3467 sign=rhs->bits & DECNEG; /* save sign bit */
3468 uprv_decNumberCopy(res, lhs);
3469 res->bits&=~DECNEG; /* clear the sign */
3470 res->bits|=sign; /* set from rhs */
3471 return res;
3472 } /* decNumberCopySign */
3473
3474 /* ------------------------------------------------------------------ */
3475 /* decNumberGetBCD -- get the coefficient in BCD8 */
3476 /* dn is the source decNumber */
3477 /* bcd is the uInt array that will receive dn->digits BCD bytes, */
3478 /* most-significant at offset 0 */
3479 /* returns bcd */
3480 /* */
3481 /* bcd must have at least dn->digits bytes. No error is possible; if */
3482 /* dn is a NaN or Infinite, digits must be 1 and the coefficient 0. */
3483 /* ------------------------------------------------------------------ */
3484 U_CAPI uByte * U_EXPORT2 uprv_decNumberGetBCD(const decNumber *dn, uByte *bcd) {
3485 uByte *ub=bcd+dn->digits-1; /* -> lsd */
3486 const Unit *up=dn->lsu; /* Unit pointer, -> lsu */
3487
3488 #if DECDPUN==1 /* trivial simple copy */
3489 for (; ub>=bcd; ub--, up++) *ub=*up;
3490 #else /* chopping needed */
3491 uInt u=*up; /* work */
3492 uInt cut=DECDPUN; /* downcounter through unit */
3493 for (; ub>=bcd; ub--) {
3494 *ub=(uByte)(u%10); /* [*6554 trick inhibits, here] */
3495 u=u/10;
3496 cut--;
3497 if (cut>0) continue; /* more in this unit */
3498 up++;
3499 u=*up;
3500 cut=DECDPUN;
3501 }
3502 #endif
3503 return bcd;
3504 } /* decNumberGetBCD */
3505
3506 /* ------------------------------------------------------------------ */
3507 /* decNumberSetBCD -- set (replace) the coefficient from BCD8 */
3508 /* dn is the target decNumber */
3509 /* bcd is the uInt array that will source n BCD bytes, most- */
3510 /* significant at offset 0 */
3511 /* n is the number of digits in the source BCD array (bcd) */
3512 /* returns dn */
3513 /* */
3514 /* dn must have space for at least n digits. No error is possible; */
3515 /* if dn is a NaN, or Infinite, or is to become a zero, n must be 1 */
3516 /* and bcd[0] zero. */
3517 /* ------------------------------------------------------------------ */
3518 U_CAPI decNumber * U_EXPORT2 uprv_decNumberSetBCD(decNumber *dn, const uByte *bcd, uInt n) {
3519 Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [target pointer] */
3520 const uByte *ub=bcd; /* -> source msd */
3521
3522 #if DECDPUN==1 /* trivial simple copy */
3523 for (; ub<bcd+n; ub++, up--) *up=*ub;
3524 #else /* some assembly needed */
3525 /* calculate how many digits in msu, and hence first cut */
3526 Int cut=MSUDIGITS(n); /* [faster than remainder] */
3527 for (;up>=dn->lsu; up--) { /* each Unit from msu */
3528 *up=0; /* will take <=DECDPUN digits */
3529 for (; cut>0; ub++, cut--) *up=X10(*up)+*ub;
3530 cut=DECDPUN; /* next Unit has all digits */
3531 }
3532 #endif
3533 dn->digits=n; /* set digit count */
3534 return dn;
3535 } /* decNumberSetBCD */
3536
3537 /* ------------------------------------------------------------------ */
3538 /* decNumberIsNormal -- test normality of a decNumber */
3539 /* dn is the decNumber to test */
3540 /* set is the context to use for Emin */
3541 /* returns 1 if |dn| is finite and >=Nmin, 0 otherwise */
3542 /* ------------------------------------------------------------------ */
3543 Int uprv_decNumberIsNormal(const decNumber *dn, decContext *set) {
3544 Int ae; /* adjusted exponent */
3545 #if DECCHECK
3546 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3547 #endif
3548
3549 if (decNumberIsSpecial(dn)) return 0; /* not finite */
3550 if (decNumberIsZero(dn)) return 0; /* not non-zero */
3551
3552 ae=dn->exponent+dn->digits-1; /* adjusted exponent */
3553 if (ae<set->emin) return 0; /* is subnormal */
3554 return 1;
3555 } /* decNumberIsNormal */
3556
3557 /* ------------------------------------------------------------------ */
3558 /* decNumberIsSubnormal -- test subnormality of a decNumber */
3559 /* dn is the decNumber to test */
3560 /* set is the context to use for Emin */
3561 /* returns 1 if |dn| is finite, non-zero, and <Nmin, 0 otherwise */
3562 /* ------------------------------------------------------------------ */
3563 Int uprv_decNumberIsSubnormal(const decNumber *dn, decContext *set) {
3564 Int ae; /* adjusted exponent */
3565 #if DECCHECK
3566 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3567 #endif
3568
3569 if (decNumberIsSpecial(dn)) return 0; /* not finite */
3570 if (decNumberIsZero(dn)) return 0; /* not non-zero */
3571
3572 ae=dn->exponent+dn->digits-1; /* adjusted exponent */
3573 if (ae<set->emin) return 1; /* is subnormal */
3574 return 0;
3575 } /* decNumberIsSubnormal */
3576
3577 /* ------------------------------------------------------------------ */
3578 /* decNumberTrim -- remove insignificant zeros */
3579 /* */
3580 /* dn is the number to trim */
3581 /* returns dn */
3582 /* */
3583 /* All fields are updated as required. This is a utility operation, */
3584 /* so special values are unchanged and no error is possible. The */
3585 /* zeros are removed unconditionally. */
3586 /* ------------------------------------------------------------------ */
3587 U_CAPI decNumber * U_EXPORT2 uprv_decNumberTrim(decNumber *dn) {
3588 Int dropped; /* work */
3589 decContext set; /* .. */
3590 #if DECCHECK
3591 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, DECUNCONT)) return dn;
3592 #endif
3593 uprv_decContextDefault(&set, DEC_INIT_BASE); /* clamp=0 */
3594 return decTrim(dn, &set, 0, 1, &dropped);
3595 } /* decNumberTrim */
3596
3597 /* ------------------------------------------------------------------ */
3598 /* decNumberVersion -- return the name and version of this module */
3599 /* */
3600 /* No error is possible. */
3601 /* ------------------------------------------------------------------ */
3602 const char * uprv_decNumberVersion(void) {
3603 return DECVERSION;
3604 } /* decNumberVersion */
3605
3606 /* ------------------------------------------------------------------ */
3607 /* decNumberZero -- set a number to 0 */
3608 /* */
3609 /* dn is the number to set, with space for one digit */
3610 /* returns dn */
3611 /* */
3612 /* No error is possible. */
3613 /* ------------------------------------------------------------------ */
3614 /* Memset is not used as it is much slower in some environments. */
3615 U_CAPI decNumber * U_EXPORT2 uprv_decNumberZero(decNumber *dn) {
3616
3617 #if DECCHECK
3618 if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
3619 #endif
3620
3621 dn->bits=0;
3622 dn->exponent=0;
3623 dn->digits=1;
3624 dn->lsu[0]=0;
3625 return dn;
3626 } /* decNumberZero */
3627
3628 /* ================================================================== */
3629 /* Local routines */
3630 /* ================================================================== */
3631
3632 /* ------------------------------------------------------------------ */
3633 /* decToString -- lay out a number into a string */
3634 /* */
3635 /* dn is the number to lay out */
3636 /* string is where to lay out the number */
3637 /* eng is 1 if Engineering, 0 if Scientific */
3638 /* */
3639 /* string must be at least dn->digits+14 characters long */
3640 /* No error is possible. */
3641 /* */
3642 /* Note that this routine can generate a -0 or 0.000. These are */
3643 /* never generated in subset to-number or arithmetic, but can occur */
3644 /* in non-subset arithmetic (e.g., -1*0 or 1.234-1.234). */
3645 /* ------------------------------------------------------------------ */
3646 /* If DECCHECK is enabled the string "?" is returned if a number is */
3647 /* invalid. */
3648 static void decToString(const decNumber *dn, char *string, Flag eng) {
3649 Int exp=dn->exponent; /* local copy */
3650 Int e; /* E-part value */
3651 Int pre; /* digits before the '.' */
3652 Int cut; /* for counting digits in a Unit */
3653 char *c=string; /* work [output pointer] */
3654 const Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [input pointer] */
3655 uInt u, pow; /* work */
3656
3657 #if DECCHECK
3658 if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) {
3659 strcpy(string, "?");
3660 return;}
3661 #endif
3662
3663 if (decNumberIsNegative(dn)) { /* Negatives get a minus */
3664 *c='-';
3665 c++;
3666 }
3667 if (dn->bits&DECSPECIAL) { /* Is a special value */
3668 if (decNumberIsInfinite(dn)) {
3669 strcpy(c, "Inf");
3670 strcpy(c+3, "inity");
3671 return;}
3672 /* a NaN */
3673 if (dn->bits&DECSNAN) { /* signalling NaN */
3674 *c='s';
3675 c++;
3676 }
3677 strcpy(c, "NaN");
3678 c+=3; /* step past */
3679 /* if not a clean non-zero coefficient, that's all there is in a */
3680 /* NaN string */
3681 if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return;
3682 /* [drop through to add integer] */
3683 }
3684
3685 /* calculate how many digits in msu, and hence first cut */
3686 cut=MSUDIGITS(dn->digits); /* [faster than remainder] */
3687 cut--; /* power of ten for digit */
3688
3689 if (exp==0) { /* simple integer [common fastpath] */
3690 for (;up>=dn->lsu; up--) { /* each Unit from msu */
3691 u=*up; /* contains DECDPUN digits to lay out */
3692 for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow);
3693 cut=DECDPUN-1; /* next Unit has all digits */
3694 }
3695 *c='\0'; /* terminate the string */
3696 return;}
3697
3698 /* non-0 exponent -- assume plain form */
3699 pre=dn->digits+exp; /* digits before '.' */
3700 e=0; /* no E */
3701 if ((exp>0) || (pre<-5)) { /* need exponential form */
3702 e=exp+dn->digits-1; /* calculate E value */
3703 pre=1; /* assume one digit before '.' */
3704 if (eng && (e!=0)) { /* engineering: may need to adjust */
3705 Int adj; /* adjustment */
3706 /* The C remainder operator is undefined for negative numbers, so */
3707 /* a positive remainder calculation must be used here */
3708 if (e<0) {
3709 adj=(-e)%3;
3710 if (adj!=0) adj=3-adj;
3711 }
3712 else { /* e>0 */
3713 adj=e%3;
3714 }
3715 e=e-adj;
3716 /* if dealing with zero still produce an exponent which is a */
3717 /* multiple of three, as expected, but there will only be the */
3718 /* one zero before the E, still. Otherwise note the padding. */
3719 if (!ISZERO(dn)) pre+=adj;
3720 else { /* is zero */
3721 if (adj!=0) { /* 0.00Esnn needed */
3722 e=e+3;
3723 pre=-(2-adj);
3724 }
3725 } /* zero */
3726 } /* eng */
3727 } /* need exponent */
3728
3729 /* lay out the digits of the coefficient, adding 0s and . as needed */
3730 u=*up;
3731 if (pre>0) { /* xxx.xxx or xx00 (engineering) form */
3732 Int n=pre;
3733 for (; pre>0; pre--, c++, cut--) {
3734 if (cut<0) { /* need new Unit */
3735 if (up==dn->lsu) break; /* out of input digits (pre>digits) */
3736 up--;
3737 cut=DECDPUN-1;
3738 u=*up;
3739 }
3740 TODIGIT(u, cut, c, pow);
3741 }
3742 if (n<dn->digits) { /* more to come, after '.' */
3743 *c='.'; c++;
3744 for (;; c++, cut--) {
3745 if (cut<0) { /* need new Unit */
3746 if (up==dn->lsu) break; /* out of input digits */
3747 up--;
3748 cut=DECDPUN-1;
3749 u=*up;
3750 }
3751 TODIGIT(u, cut, c, pow);
3752 }
3753 }
3754 else for (; pre>0; pre--, c++) *c='0'; /* 0 padding (for engineering) needed */
3755 }
3756 else { /* 0.xxx or 0.000xxx form */
3757 *c='0'; c++;
3758 *c='.'; c++;
3759 for (; pre<0; pre++, c++) *c='0'; /* add any 0's after '.' */
3760 for (; ; c++, cut--) {
3761 if (cut<0) { /* need new Unit */
3762 if (up==dn->lsu) break; /* out of input digits */
3763 up--;
3764 cut=DECDPUN-1;
3765 u=*up;
3766 }
3767 TODIGIT(u, cut, c, pow);
3768 }
3769 }
3770
3771 /* Finally add the E-part, if needed. It will never be 0, has a
3772 base maximum and minimum of +999999999 through -999999999, but
3773 could range down to -1999999998 for anormal numbers */
3774 if (e!=0) {
3775 Flag had=0; /* 1=had non-zero */
3776 *c='E'; c++;
3777 *c='+'; c++; /* assume positive */
3778 u=e; /* .. */
3779 if (e<0) {
3780 *(c-1)='-'; /* oops, need - */
3781 u=-e; /* uInt, please */
3782 }
3783 /* lay out the exponent [_itoa or equivalent is not ANSI C] */
3784 for (cut=9; cut>=0; cut--) {
3785 TODIGIT(u, cut, c, pow);
3786 if (*c=='0' && !had) continue; /* skip leading zeros */
3787 had=1; /* had non-0 */
3788 c++; /* step for next */
3789 } /* cut */
3790 }
3791 *c='\0'; /* terminate the string (all paths) */
3792 return;
3793 } /* decToString */
3794
3795 /* ------------------------------------------------------------------ */
3796 /* decAddOp -- add/subtract operation */
3797 /* */
3798 /* This computes C = A + B */
3799 /* */
3800 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */
3801 /* lhs is A */
3802 /* rhs is B */
3803 /* set is the context */
3804 /* negate is DECNEG if rhs should be negated, or 0 otherwise */
3805 /* status accumulates status for the caller */
3806 /* */
3807 /* C must have space for set->digits digits. */
3808 /* Inexact in status must be 0 for correct Exact zero sign in result */
3809 /* ------------------------------------------------------------------ */
3810 /* If possible, the coefficient is calculated directly into C. */
3811 /* However, if: */
3812 /* -- a digits+1 calculation is needed because the numbers are */
3813 /* unaligned and span more than set->digits digits */
3814 /* -- a carry to digits+1 digits looks possible */
3815 /* -- C is the same as A or B, and the result would destructively */
3816 /* overlap the A or B coefficient */
3817 /* then the result must be calculated into a temporary buffer. In */
3818 /* this case a local (stack) buffer is used if possible, and only if */
3819 /* too long for that does malloc become the final resort. */
3820 /* */
3821 /* Misalignment is handled as follows: */
3822 /* Apad: (AExp>BExp) Swap operands and proceed as for BExp>AExp. */
3823 /* BPad: Apply the padding by a combination of shifting (whole */
3824 /* units) and multiplication (part units). */
3825 /* */
3826 /* Addition, especially x=x+1, is speed-critical. */
3827 /* The static buffer is larger than might be expected to allow for */
3828 /* calls from higher-level funtions (notable exp). */
3829 /* ------------------------------------------------------------------ */
3830 static decNumber * decAddOp(decNumber *res, const decNumber *lhs,
3831 const decNumber *rhs, decContext *set,
3832 uByte negate, uInt *status) {
3833 #if DECSUBSET
3834 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
3835 decNumber *allocrhs=NULL; /* .., rhs */
3836 #endif
3837 Int rhsshift; /* working shift (in Units) */
3838 Int maxdigits; /* longest logical length */
3839 Int mult; /* multiplier */
3840 Int residue; /* rounding accumulator */
3841 uByte bits; /* result bits */
3842 Flag diffsign; /* non-0 if arguments have different sign */
3843 Unit *acc; /* accumulator for result */
3844 Unit accbuff[SD2U(DECBUFFER*2+20)]; /* local buffer [*2+20 reduces many */
3845 /* allocations when called from */
3846 /* other operations, notable exp] */
3847 Unit *allocacc=NULL; /* -> allocated acc buffer, iff allocated */
3848 Int reqdigits=set->digits; /* local copy; requested DIGITS */
3849 Int padding; /* work */
3850
3851 #if DECCHECK
3852 if (decCheckOperands(res, lhs, rhs, set)) return res;
3853 #endif
3854
3855 do { /* protect allocated storage */
3856 #if DECSUBSET
3857 if (!set->extended) {
3858 /* reduce operands and set lostDigits status, as needed */
3859 if (lhs->digits>reqdigits) {
3860 alloclhs=decRoundOperand(lhs, set, status);
3861 if (alloclhs==NULL) break;
3862 lhs=alloclhs;
3863 }
3864 if (rhs->digits>reqdigits) {
3865 allocrhs=decRoundOperand(rhs, set, status);
3866 if (allocrhs==NULL) break;
3867 rhs=allocrhs;
3868 }
3869 }
3870 #endif
3871 /* [following code does not require input rounding] */
3872
3873 /* note whether signs differ [used all paths] */
3874 diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG);
3875
3876 /* handle infinities and NaNs */
3877 if (SPECIALARGS) { /* a special bit set */
3878 if (SPECIALARGS & (DECSNAN | DECNAN)) /* a NaN */
3879 decNaNs(res, lhs, rhs, set, status);
3880 else { /* one or two infinities */
3881 if (decNumberIsInfinite(lhs)) { /* LHS is infinity */
3882 /* two infinities with different signs is invalid */
3883 if (decNumberIsInfinite(rhs) && diffsign) {
3884 *status|=DEC_Invalid_operation;
3885 break;
3886 }
3887 bits=lhs->bits & DECNEG; /* get sign from LHS */
3888 }
3889 else bits=(rhs->bits^negate) & DECNEG;/* RHS must be Infinity */
3890 bits|=DECINF;
3891 uprv_decNumberZero(res);
3892 res->bits=bits; /* set +/- infinity */
3893 } /* an infinity */
3894 break;
3895 }
3896
3897 /* Quick exit for add 0s; return the non-0, modified as need be */
3898 if (ISZERO(lhs)) {
3899 Int adjust; /* work */
3900 Int lexp=lhs->exponent; /* save in case LHS==RES */
3901 bits=lhs->bits; /* .. */
3902 residue=0; /* clear accumulator */
3903 decCopyFit(res, rhs, set, &residue, status); /* copy (as needed) */
3904 res->bits^=negate; /* flip if rhs was negated */
3905 #if DECSUBSET
3906 if (set->extended) { /* exponents on zeros count */
3907 #endif
3908 /* exponent will be the lower of the two */
3909 adjust=lexp-res->exponent; /* adjustment needed [if -ve] */
3910 if (ISZERO(res)) { /* both 0: special IEEE 754 rules */
3911 if (adjust<0) res->exponent=lexp; /* set exponent */
3912 /* 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0 */
3913 if (diffsign) {
3914 if (set->round!=DEC_ROUND_FLOOR) res->bits=0;
3915 else res->bits=DECNEG; /* preserve 0 sign */
3916 }
3917 }
3918 else { /* non-0 res */
3919 if (adjust<0) { /* 0-padding needed */
3920 if ((res->digits-adjust)>set->digits) {
3921 adjust=res->digits-set->digits; /* to fit exactly */
3922 *status|=DEC_Rounded; /* [but exact] */
3923 }
3924 res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
3925 res->exponent+=adjust; /* set the exponent. */
3926 }
3927 } /* non-0 res */
3928 #if DECSUBSET
3929 } /* extended */
3930 #endif
3931 decFinish(res, set, &residue, status); /* clean and finalize */
3932 break;}
3933
3934 if (ISZERO(rhs)) { /* [lhs is non-zero] */
3935 Int adjust; /* work */
3936 Int rexp=rhs->exponent; /* save in case RHS==RES */
3937 bits=rhs->bits; /* be clean */
3938 residue=0; /* clear accumulator */
3939 decCopyFit(res, lhs, set, &residue, status); /* copy (as needed) */
3940 #if DECSUBSET
3941 if (set->extended) { /* exponents on zeros count */
3942 #endif
3943 /* exponent will be the lower of the two */
3944 /* [0-0 case handled above] */
3945 adjust=rexp-res->exponent; /* adjustment needed [if -ve] */
3946 if (adjust<0) { /* 0-padding needed */
3947 if ((res->digits-adjust)>set->digits) {
3948 adjust=res->digits-set->digits; /* to fit exactly */
3949 *status|=DEC_Rounded; /* [but exact] */
3950 }
3951 res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
3952 res->exponent+=adjust; /* set the exponent. */
3953 }
3954 #if DECSUBSET
3955 } /* extended */
3956 #endif
3957 decFinish(res, set, &residue, status); /* clean and finalize */
3958 break;}
3959
3960 /* [NB: both fastpath and mainpath code below assume these cases */
3961 /* (notably 0-0) have already been handled] */
3962
3963 /* calculate the padding needed to align the operands */
3964 padding=rhs->exponent-lhs->exponent;
3965
3966 /* Fastpath cases where the numbers are aligned and normal, the RHS */
3967 /* is all in one unit, no operand rounding is needed, and no carry, */
3968 /* lengthening, or borrow is needed */
3969 if (padding==0
3970 && rhs->digits<=DECDPUN
3971 && rhs->exponent>=set->emin /* [some normals drop through] */
3972 && rhs->exponent<=set->emax-set->digits+1 /* [could clamp] */
3973 && rhs->digits<=reqdigits
3974 && lhs->digits<=reqdigits) {
3975 Int partial=*lhs->lsu;
3976 if (!diffsign) { /* adding */
3977 partial+=*rhs->lsu;
3978 if ((partial<=DECDPUNMAX) /* result fits in unit */
3979 && (lhs->digits>=DECDPUN || /* .. and no digits-count change */
3980 partial<(Int)powers[lhs->digits])) { /* .. */
3981 if (res!=lhs) uprv_decNumberCopy(res, lhs); /* not in place */
3982 *res->lsu=(Unit)partial; /* [copy could have overwritten RHS] */
3983 break;
3984 }
3985 /* else drop out for careful add */
3986 }
3987 else { /* signs differ */
3988 partial-=*rhs->lsu;
3989 if (partial>0) { /* no borrow needed, and non-0 result */
3990 if (res!=lhs) uprv_decNumberCopy(res, lhs); /* not in place */
3991 *res->lsu=(Unit)partial;
3992 /* this could have reduced digits [but result>0] */
3993 res->digits=decGetDigits(res->lsu, D2U(res->digits));
3994 break;
3995 }
3996 /* else drop out for careful subtract */
3997 }
3998 }
3999
4000 /* Now align (pad) the lhs or rhs so they can be added or */
4001 /* subtracted, as necessary. If one number is much larger than */
4002 /* the other (that is, if in plain form there is a least one */
4003 /* digit between the lowest digit of one and the highest of the */
4004 /* other) padding with up to DIGITS-1 trailing zeros may be */
4005 /* needed; then apply rounding (as exotic rounding modes may be */
4006 /* affected by the residue). */
4007 rhsshift=0; /* rhs shift to left (padding) in Units */
4008 bits=lhs->bits; /* assume sign is that of LHS */
4009 mult=1; /* likely multiplier */
4010
4011 /* [if padding==0 the operands are aligned; no padding is needed] */
4012 if (padding!=0) {
4013 /* some padding needed; always pad the RHS, as any required */
4014 /* padding can then be effected by a simple combination of */
4015 /* shifts and a multiply */
4016 Flag swapped=0;
4017 if (padding<0) { /* LHS needs the padding */
4018 const decNumber *t;
4019 padding=-padding; /* will be +ve */
4020 bits=(uByte)(rhs->bits^negate); /* assumed sign is now that of RHS */
4021 t=lhs; lhs=rhs; rhs=t;
4022 swapped=1;
4023 }
4024
4025 /* If, after pad, rhs would be longer than lhs by digits+1 or */
4026 /* more then lhs cannot affect the answer, except as a residue, */
4027 /* so only need to pad up to a length of DIGITS+1. */
4028 if (rhs->digits+padding > lhs->digits+reqdigits+1) {
4029 /* The RHS is sufficient */
4030 /* for residue use the relative sign indication... */
4031 Int shift=reqdigits-rhs->digits; /* left shift needed */
4032 residue=1; /* residue for rounding */
4033 if (diffsign) residue=-residue; /* signs differ */
4034 /* copy, shortening if necessary */
4035 decCopyFit(res, rhs, set, &residue, status);
4036 /* if it was already shorter, then need to pad with zeros */
4037 if (shift>0) {
4038 res->digits=decShiftToMost(res->lsu, res->digits, shift);
4039 res->exponent-=shift; /* adjust the exponent. */
4040 }
4041 /* flip the result sign if unswapped and rhs was negated */
4042 if (!swapped) res->bits^=negate;
4043 decFinish(res, set, &residue, status); /* done */
4044 break;}
4045
4046 /* LHS digits may affect result */
4047 rhsshift=D2U(padding+1)-1; /* this much by Unit shift .. */
4048 mult=powers[padding-(rhsshift*DECDPUN)]; /* .. this by multiplication */
4049 } /* padding needed */
4050
4051 if (diffsign) mult=-mult; /* signs differ */
4052
4053 /* determine the longer operand */
4054 maxdigits=rhs->digits+padding; /* virtual length of RHS */
4055 if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4056
4057 /* Decide on the result buffer to use; if possible place directly */
4058 /* into result. */
4059 acc=res->lsu; /* assume add direct to result */
4060 /* If destructive overlap, or the number is too long, or a carry or */
4061 /* borrow to DIGITS+1 might be possible, a buffer must be used. */
4062 /* [Might be worth more sophisticated tests when maxdigits==reqdigits] */
4063 if ((maxdigits>=reqdigits) /* is, or could be, too large */
4064 || (res==rhs && rhsshift>0)) { /* destructive overlap */
4065 /* buffer needed, choose it; units for maxdigits digits will be */
4066 /* needed, +1 Unit for carry or borrow */
4067 Int need=D2U(maxdigits)+1;
4068 acc=accbuff; /* assume use local buffer */
4069 if (need*sizeof(Unit)>sizeof(accbuff)) {
4070 /* printf("malloc add %ld %ld\n", need, sizeof(accbuff)); */
4071 allocacc=(Unit *)malloc(need*sizeof(Unit));
4072 if (allocacc==NULL) { /* hopeless -- abandon */
4073 *status|=DEC_Insufficient_storage;
4074 break;}
4075 acc=allocacc;
4076 }
4077 }
4078
4079 res->bits=(uByte)(bits&DECNEG); /* it's now safe to overwrite.. */
4080 res->exponent=lhs->exponent; /* .. operands (even if aliased) */
4081
4082 #if DECTRACE
4083 decDumpAr('A', lhs->lsu, D2U(lhs->digits));
4084 decDumpAr('B', rhs->lsu, D2U(rhs->digits));
4085 printf(" :h: %ld %ld\n", rhsshift, mult);
4086 #endif
4087
4088 /* add [A+B*m] or subtract [A+B*(-m)] */
4089 U_ASSERT(rhs->digits > 0);
4090 U_ASSERT(lhs->digits > 0);
4091 res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits),
4092 rhs->lsu, D2U(rhs->digits),
4093 rhsshift, acc, mult)
4094 *DECDPUN; /* [units -> digits] */
4095 if (res->digits<0) { /* borrowed... */
4096 res->digits=-res->digits;
4097 res->bits^=DECNEG; /* flip the sign */
4098 }
4099 #if DECTRACE
4100 decDumpAr('+', acc, D2U(res->digits));
4101 #endif
4102
4103 /* If a buffer was used the result must be copied back, possibly */
4104 /* shortening. (If no buffer was used then the result must have */
4105 /* fit, so can't need rounding and residue must be 0.) */
4106 residue=0; /* clear accumulator */
4107 if (acc!=res->lsu) {
4108 #if DECSUBSET
4109 if (set->extended) { /* round from first significant digit */
4110 #endif
4111 /* remove leading zeros that were added due to rounding up to */
4112 /* integral Units -- before the test for rounding. */
4113 if (res->digits>reqdigits)
4114 res->digits=decGetDigits(acc, D2U(res->digits));
4115 decSetCoeff(res, set, acc, res->digits, &residue, status);
4116 #if DECSUBSET
4117 }
4118 else { /* subset arithmetic rounds from original significant digit */
4119 /* May have an underestimate. This only occurs when both */
4120 /* numbers fit in DECDPUN digits and are padding with a */
4121 /* negative multiple (-10, -100...) and the top digit(s) become */
4122 /* 0. (This only matters when using X3.274 rules where the */
4123 /* leading zero could be included in the rounding.) */
4124 if (res->digits<maxdigits) {
4125 *(acc+D2U(res->digits))=0; /* ensure leading 0 is there */
4126 res->digits=maxdigits;
4127 }
4128 else {
4129 /* remove leading zeros that added due to rounding up to */
4130 /* integral Units (but only those in excess of the original */
4131 /* maxdigits length, unless extended) before test for rounding. */
4132 if (res->digits>reqdigits) {
4133 res->digits=decGetDigits(acc, D2U(res->digits));
4134 if (res->digits<maxdigits) res->digits=maxdigits;
4135 }
4136 }
4137 decSetCoeff(res, set, acc, res->digits, &residue, status);
4138 /* Now apply rounding if needed before removing leading zeros. */
4139 /* This is safe because subnormals are not a possibility */
4140 if (residue!=0) {
4141 decApplyRound(res, set, residue, status);
4142 residue=0; /* did what needed to be done */
4143 }
4144 } /* subset */
4145 #endif
4146 } /* used buffer */
4147
4148 /* strip leading zeros [these were left on in case of subset subtract] */
4149 res->digits=decGetDigits(res->lsu, D2U(res->digits));
4150
4151 /* apply checks and rounding */
4152 decFinish(res, set, &residue, status);
4153
4154 /* "When the sum of two operands with opposite signs is exactly */
4155 /* zero, the sign of that sum shall be '+' in all rounding modes */
4156 /* except round toward -Infinity, in which mode that sign shall be */
4157 /* '-'." [Subset zeros also never have '-', set by decFinish.] */
4158 if (ISZERO(res) && diffsign
4159 #if DECSUBSET
4160 && set->extended
4161 #endif
4162 && (*status&DEC_Inexact)==0) {
4163 if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG; /* sign - */
4164 else res->bits&=~DECNEG; /* sign + */
4165 }
4166 } while(0); /* end protected */
4167
4168 if (allocacc!=NULL) free(allocacc); /* drop any storage used */
4169 #if DECSUBSET
4170 if (allocrhs!=NULL) free(allocrhs); /* .. */
4171 if (alloclhs!=NULL) free(alloclhs); /* .. */
4172 #endif
4173 return res;
4174 } /* decAddOp */
4175
4176 /* ------------------------------------------------------------------ */
4177 /* decDivideOp -- division operation */
4178 /* */
4179 /* This routine performs the calculations for all four division */
4180 /* operators (divide, divideInteger, remainder, remainderNear). */
4181 /* */
4182 /* C=A op B */
4183 /* */
4184 /* res is C, the result. C may be A and/or B (e.g., X=X/X) */
4185 /* lhs is A */
4186 /* rhs is B */
4187 /* set is the context */
4188 /* op is DIVIDE, DIVIDEINT, REMAINDER, or REMNEAR respectively. */
4189 /* status is the usual accumulator */
4190 /* */
4191 /* C must have space for set->digits digits. */
4192 /* */
4193 /* ------------------------------------------------------------------ */
4194 /* The underlying algorithm of this routine is the same as in the */
4195 /* 1981 S/370 implementation, that is, non-restoring long division */
4196 /* with bi-unit (rather than bi-digit) estimation for each unit */
4197 /* multiplier. In this pseudocode overview, complications for the */
4198 /* Remainder operators and division residues for exact rounding are */
4199 /* omitted for clarity. */
4200 /* */
4201 /* Prepare operands and handle special values */
4202 /* Test for x/0 and then 0/x */
4203 /* Exp =Exp1 - Exp2 */
4204 /* Exp =Exp +len(var1) -len(var2) */
4205 /* Sign=Sign1 * Sign2 */
4206 /* Pad accumulator (Var1) to double-length with 0's (pad1) */
4207 /* Pad Var2 to same length as Var1 */
4208 /* msu2pair/plus=1st 2 or 1 units of var2, +1 to allow for round */
4209 /* have=0 */
4210 /* Do until (have=digits+1 OR residue=0) */
4211 /* if exp<0 then if integer divide/residue then leave */
4212 /* this_unit=0 */
4213 /* Do forever */
4214 /* compare numbers */
4215 /* if <0 then leave inner_loop */
4216 /* if =0 then (* quick exit without subtract *) do */
4217 /* this_unit=this_unit+1; output this_unit */
4218 /* leave outer_loop; end */
4219 /* Compare lengths of numbers (mantissae): */
4220 /* If same then tops2=msu2pair -- {units 1&2 of var2} */
4221 /* else tops2=msu2plus -- {0, unit 1 of var2} */
4222 /* tops1=first_unit_of_Var1*10**DECDPUN +second_unit_of_var1 */
4223 /* mult=tops1/tops2 -- Good and safe guess at divisor */
4224 /* if mult=0 then mult=1 */
4225 /* this_unit=this_unit+mult */
4226 /* subtract */
4227 /* end inner_loop */
4228 /* if have\=0 | this_unit\=0 then do */
4229 /* output this_unit */
4230 /* have=have+1; end */
4231 /* var2=var2/10 */
4232 /* exp=exp-1 */
4233 /* end outer_loop */
4234 /* exp=exp+1 -- set the proper exponent */
4235 /* if have=0 then generate answer=0 */
4236 /* Return (Result is defined by Var1) */
4237 /* */
4238 /* ------------------------------------------------------------------ */
4239 /* Two working buffers are needed during the division; one (digits+ */
4240 /* 1) to accumulate the result, and the other (up to 2*digits+1) for */
4241 /* long subtractions. These are acc and var1 respectively. */
4242 /* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/
4243 /* The static buffers may be larger than might be expected to allow */
4244 /* for calls from higher-level funtions (notable exp). */
4245 /* ------------------------------------------------------------------ */
4246 static decNumber * decDivideOp(decNumber *res,
4247 const decNumber *lhs, const decNumber *rhs,
4248 decContext *set, Flag op, uInt *status) {
4249 #if DECSUBSET
4250 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
4251 decNumber *allocrhs=NULL; /* .., rhs */
4252 #endif
4253 Unit accbuff[SD2U(DECBUFFER+DECDPUN+10)]; /* local buffer */
4254 Unit *acc=accbuff; /* -> accumulator array for result */
4255 Unit *allocacc=NULL; /* -> allocated buffer, iff allocated */
4256 Unit *accnext; /* -> where next digit will go */
4257 Int acclength; /* length of acc needed [Units] */
4258 Int accunits; /* count of units accumulated */
4259 Int accdigits; /* count of digits accumulated */
4260
4261 Unit varbuff[SD2U(DECBUFFER*2+DECDPUN)]; /* buffer for var1 */
4262 Unit *var1=varbuff; /* -> var1 array for long subtraction */
4263 Unit *varalloc=NULL; /* -> allocated buffer, iff used */
4264 Unit *msu1; /* -> msu of var1 */
4265
4266 const Unit *var2; /* -> var2 array */
4267 const Unit *msu2; /* -> msu of var2 */
4268 Int msu2plus; /* msu2 plus one [does not vary] */
4269 eInt msu2pair; /* msu2 pair plus one [does not vary] */
4270
4271 Int var1units, var2units; /* actual lengths */
4272 Int var2ulen; /* logical length (units) */
4273 Int var1initpad=0; /* var1 initial padding (digits) */
4274 Int maxdigits; /* longest LHS or required acc length */
4275 Int mult; /* multiplier for subtraction */
4276 Unit thisunit; /* current unit being accumulated */
4277 Int residue; /* for rounding */
4278 Int reqdigits=set->digits; /* requested DIGITS */
4279 Int exponent; /* working exponent */
4280 Int maxexponent=0; /* DIVIDE maximum exponent if unrounded */
4281 uByte bits; /* working sign */
4282 Unit *target; /* work */
4283 const Unit *source; /* .. */
4284 uInt const *pow; /* .. */
4285 Int shift, cut; /* .. */
4286 #if DECSUBSET
4287 Int dropped; /* work */
4288 #endif
4289
4290 #if DECCHECK
4291 if (decCheckOperands(res, lhs, rhs, set)) return res;
4292 #endif
4293
4294 do { /* protect allocated storage */
4295 #if DECSUBSET
4296 if (!set->extended) {
4297 /* reduce operands and set lostDigits status, as needed */
4298 if (lhs->digits>reqdigits) {
4299 alloclhs=decRoundOperand(lhs, set, status);
4300 if (alloclhs==NULL) break;
4301 lhs=alloclhs;
4302 }
4303 if (rhs->digits>reqdigits) {
4304 allocrhs=decRoundOperand(rhs, set, status);
4305 if (allocrhs==NULL) break;
4306 rhs=allocrhs;
4307 }
4308 }
4309 #endif
4310 /* [following code does not require input rounding] */
4311
4312 bits=(lhs->bits^rhs->bits)&DECNEG; /* assumed sign for divisions */
4313
4314 /* handle infinities and NaNs */
4315 if (SPECIALARGS) { /* a special bit set */
4316 if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
4317 decNaNs(res, lhs, rhs, set, status);
4318 break;
4319 }
4320 /* one or two infinities */
4321 if (decNumberIsInfinite(lhs)) { /* LHS (dividend) is infinite */
4322 if (decNumberIsInfinite(rhs) || /* two infinities are invalid .. */
4323 op & (REMAINDER | REMNEAR)) { /* as is remainder of infinity */
4324 *status|=DEC_Invalid_operation;
4325 break;
4326 }
4327 /* [Note that infinity/0 raises no exceptions] */
4328 uprv_decNumberZero(res);
4329 res->bits=bits|DECINF; /* set +/- infinity */
4330 break;
4331 }
4332 else { /* RHS (divisor) is infinite */
4333 residue=0;
4334 if (op&(REMAINDER|REMNEAR)) {
4335 /* result is [finished clone of] lhs */
4336 decCopyFit(res, lhs, set, &residue, status);
4337 }
4338 else { /* a division */
4339 uprv_decNumberZero(res);
4340 res->bits=bits; /* set +/- zero */
4341 /* for DIVIDEINT the exponent is always 0. For DIVIDE, result */
4342 /* is a 0 with infinitely negative exponent, clamped to minimum */
4343 if (op&DIVIDE) {
4344 res->exponent=set->emin-set->digits+1;
4345 *status|=DEC_Clamped;
4346 }
4347 }
4348 decFinish(res, set, &residue, status);
4349 break;
4350 }
4351 }
4352
4353 /* handle 0 rhs (x/0) */
4354 if (ISZERO(rhs)) { /* x/0 is always exceptional */
4355 if (ISZERO(lhs)) {
4356 uprv_decNumberZero(res); /* [after lhs test] */
4357 *status|=DEC_Division_undefined;/* 0/0 will become NaN */
4358 }
4359 else {
4360 uprv_decNumberZero(res);
4361 if (op&(REMAINDER|REMNEAR)) *status|=DEC_Invalid_operation;
4362 else {
4363 *status|=DEC_Division_by_zero; /* x/0 */
4364 res->bits=bits|DECINF; /* .. is +/- Infinity */
4365 }
4366 }
4367 break;}
4368
4369 /* handle 0 lhs (0/x) */
4370 if (ISZERO(lhs)) { /* 0/x [x!=0] */
4371 #if DECSUBSET
4372 if (!set->extended) uprv_decNumberZero(res);
4373 else {
4374 #endif
4375 if (op&DIVIDE) {
4376 residue=0;
4377 exponent=lhs->exponent-rhs->exponent; /* ideal exponent */
4378 uprv_decNumberCopy(res, lhs); /* [zeros always fit] */
4379 res->bits=bits; /* sign as computed */
4380 res->exponent=exponent; /* exponent, too */
4381 decFinalize(res, set, &residue, status); /* check exponent */
4382 }
4383 else if (op&DIVIDEINT) {
4384 uprv_decNumberZero(res); /* integer 0 */
4385 res->bits=bits; /* sign as computed */
4386 }
4387 else { /* a remainder */
4388 exponent=rhs->exponent; /* [save in case overwrite] */
4389 uprv_decNumberCopy(res, lhs); /* [zeros always fit] */
4390 if (exponent<res->exponent) res->exponent=exponent; /* use lower */
4391 }
4392 #if DECSUBSET
4393 }
4394 #endif
4395 break;}
4396
4397 /* Precalculate exponent. This starts off adjusted (and hence fits */
4398 /* in 31 bits) and becomes the usual unadjusted exponent as the */
4399 /* division proceeds. The order of evaluation is important, here, */
4400 /* to avoid wrap. */
4401 exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits);
4402
4403 /* If the working exponent is -ve, then some quick exits are */
4404 /* possible because the quotient is known to be <1 */
4405 /* [for REMNEAR, it needs to be < -1, as -0.5 could need work] */
4406 if (exponent<0 && !(op==DIVIDE)) {
4407 if (op&DIVIDEINT) {
4408 uprv_decNumberZero(res); /* integer part is 0 */
4409 #if DECSUBSET
4410 if (set->extended)
4411 #endif
4412 res->bits=bits; /* set +/- zero */
4413 break;}
4414 /* fastpath remainders so long as the lhs has the smaller */
4415 /* (or equal) exponent */
4416 if (lhs->exponent<=rhs->exponent) {
4417 if (op&REMAINDER || exponent<-1) {
4418 /* It is REMAINDER or safe REMNEAR; result is [finished */
4419 /* clone of] lhs (r = x - 0*y) */
4420 residue=0;
4421 decCopyFit(res, lhs, set, &residue, status);
4422 decFinish(res, set, &residue, status);
4423 break;
4424 }
4425 /* [unsafe REMNEAR drops through] */
4426 }
4427 } /* fastpaths */
4428
4429 /* Long (slow) division is needed; roll up the sleeves... */
4430
4431 /* The accumulator will hold the quotient of the division. */
4432 /* If it needs to be too long for stack storage, then allocate. */
4433 acclength=D2U(reqdigits+DECDPUN); /* in Units */
4434 if (acclength*sizeof(Unit)>sizeof(accbuff)) {
4435 /* printf("malloc dvacc %ld units\n", acclength); */
4436 allocacc=(Unit *)malloc(acclength*sizeof(Unit));
4437 if (allocacc==NULL) { /* hopeless -- abandon */
4438 *status|=DEC_Insufficient_storage;
4439 break;}
4440 acc=allocacc; /* use the allocated space */
4441 }
4442
4443 /* var1 is the padded LHS ready for subtractions. */
4444 /* If it needs to be too long for stack storage, then allocate. */
4445 /* The maximum units needed for var1 (long subtraction) is: */
4446 /* Enough for */
4447 /* (rhs->digits+reqdigits-1) -- to allow full slide to right */
4448 /* or (lhs->digits) -- to allow for long lhs */
4449 /* whichever is larger */
4450 /* +1 -- for rounding of slide to right */
4451 /* +1 -- for leading 0s */
4452 /* +1 -- for pre-adjust if a remainder or DIVIDEINT */
4453 /* [Note: unused units do not participate in decUnitAddSub data] */
4454 maxdigits=rhs->digits+reqdigits-1;
4455 if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4456 var1units=D2U(maxdigits)+2;
4457 /* allocate a guard unit above msu1 for REMAINDERNEAR */
4458 if (!(op&DIVIDE)) var1units++;
4459 if ((var1units+1)*sizeof(Unit)>sizeof(varbuff)) {
4460 /* printf("malloc dvvar %ld units\n", var1units+1); */
4461 varalloc=(Unit *)malloc((var1units+1)*sizeof(Unit));
4462 if (varalloc==NULL) { /* hopeless -- abandon */
4463 *status|=DEC_Insufficient_storage;
4464 break;}
4465 var1=varalloc; /* use the allocated space */
4466 }
4467
4468 /* Extend the lhs and rhs to full long subtraction length. The lhs */
4469 /* is truly extended into the var1 buffer, with 0 padding, so a */
4470 /* subtract in place is always possible. The rhs (var2) has */
4471 /* virtual padding (implemented by decUnitAddSub). */
4472 /* One guard unit was allocated above msu1 for rem=rem+rem in */
4473 /* REMAINDERNEAR. */
4474 msu1=var1+var1units-1; /* msu of var1 */
4475 source=lhs->lsu+D2U(lhs->digits)-1; /* msu of input array */
4476 for (target=msu1; source>=lhs->lsu; source--, target--) *target=*source;
4477 for (; target>=var1; target--) *target=0;
4478
4479 /* rhs (var2) is left-aligned with var1 at the start */
4480 var2ulen=var1units; /* rhs logical length (units) */
4481 var2units=D2U(rhs->digits); /* rhs actual length (units) */
4482 var2=rhs->lsu; /* -> rhs array */
4483 msu2=var2+var2units-1; /* -> msu of var2 [never changes] */
4484 /* now set up the variables which will be used for estimating the */
4485 /* multiplication factor. If these variables are not exact, add */
4486 /* 1 to make sure that the multiplier is never overestimated. */
4487 msu2plus=*msu2; /* it's value .. */
4488 if (var2units>1) msu2plus++; /* .. +1 if any more */
4489 msu2pair=(eInt)*msu2*(DECDPUNMAX+1);/* top two pair .. */
4490 if (var2units>1) { /* .. [else treat 2nd as 0] */
4491 msu2pair+=*(msu2-1); /* .. */
4492 if (var2units>2) msu2pair++; /* .. +1 if any more */
4493 }
4494
4495 /* The calculation is working in units, which may have leading zeros, */
4496 /* but the exponent was calculated on the assumption that they are */
4497 /* both left-aligned. Adjust the exponent to compensate: add the */
4498 /* number of leading zeros in var1 msu and subtract those in var2 msu. */
4499 /* [This is actually done by counting the digits and negating, as */
4500 /* lead1=DECDPUN-digits1, and similarly for lead2.] */
4501 for (pow=&powers[1]; *msu1>=*pow; pow++) exponent--;
4502 for (pow=&powers[1]; *msu2>=*pow; pow++) exponent++;
4503
4504 /* Now, if doing an integer divide or remainder, ensure that */
4505 /* the result will be Unit-aligned. To do this, shift the var1 */
4506 /* accumulator towards least if need be. (It's much easier to */
4507 /* do this now than to reassemble the residue afterwards, if */
4508 /* doing a remainder.) Also ensure the exponent is not negative. */
4509 if (!(op&DIVIDE)) {
4510 Unit *u; /* work */
4511 /* save the initial 'false' padding of var1, in digits */
4512 var1initpad=(var1units-D2U(lhs->digits))*DECDPUN;
4513 /* Determine the shift to do. */
4514 if (exponent<0) cut=-exponent;
4515 else cut=DECDPUN-exponent%DECDPUN;
4516 decShiftToLeast(var1, var1units, cut);
4517 exponent+=cut; /* maintain numerical value */
4518 var1initpad-=cut; /* .. and reduce padding */
4519 /* clean any most-significant units which were just emptied */
4520 for (u=msu1; cut>=DECDPUN; cut-=DECDPUN, u--) *u=0;
4521 } /* align */
4522 else { /* is DIVIDE */
4523 maxexponent=lhs->exponent-rhs->exponent; /* save */
4524 /* optimization: if the first iteration will just produce 0, */
4525 /* preadjust to skip it [valid for DIVIDE only] */
4526 if (*msu1<*msu2) {
4527 var2ulen--; /* shift down */
4528 exponent-=DECDPUN; /* update the exponent */
4529 }
4530 }
4531
4532 /* ---- start the long-division loops ------------------------------ */
4533 accunits=0; /* no units accumulated yet */
4534 accdigits=0; /* .. or digits */
4535 accnext=acc+acclength-1; /* -> msu of acc [NB: allows digits+1] */
4536 for (;;) { /* outer forever loop */
4537 thisunit=0; /* current unit assumed 0 */
4538 /* find the next unit */
4539 for (;;) { /* inner forever loop */
4540 /* strip leading zero units [from either pre-adjust or from */
4541 /* subtract last time around]. Leave at least one unit. */
4542 for (; *msu1==0 && msu1>var1; msu1--) var1units--;
4543
4544 if (var1units<var2ulen) break; /* var1 too low for subtract */
4545 if (var1units==var2ulen) { /* unit-by-unit compare needed */
4546 /* compare the two numbers, from msu */
4547 const Unit *pv1, *pv2;
4548 Unit v2; /* units to compare */
4549 pv2=msu2; /* -> msu */
4550 for (pv1=msu1; ; pv1--, pv2--) {
4551 /* v1=*pv1 -- always OK */
4552 v2=0; /* assume in padding */
4553 if (pv2>=var2) v2=*pv2; /* in range */
4554 if (*pv1!=v2) break; /* no longer the same */
4555 if (pv1==var1) break; /* done; leave pv1 as is */
4556 }
4557 /* here when all inspected or a difference seen */
4558 if (*pv1<v2) break; /* var1 too low to subtract */
4559 if (*pv1==v2) { /* var1 == var2 */
4560 /* reach here if var1 and var2 are identical; subtraction */
4561 /* would increase digit by one, and the residue will be 0 so */
4562 /* the calculation is done; leave the loop with residue=0. */
4563 thisunit++; /* as though subtracted */
4564 *var1=0; /* set var1 to 0 */
4565 var1units=1; /* .. */
4566 break; /* from inner */
4567 } /* var1 == var2 */
4568 /* *pv1>v2. Prepare for real subtraction; the lengths are equal */
4569 /* Estimate the multiplier (there's always a msu1-1)... */
4570 /* Bring in two units of var2 to provide a good estimate. */
4571 mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2pair);
4572 } /* lengths the same */
4573 else { /* var1units > var2ulen, so subtraction is safe */
4574 /* The var2 msu is one unit towards the lsu of the var1 msu, */
4575 /* so only one unit for var2 can be used. */
4576 mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2plus);
4577 }
4578 if (mult==0) mult=1; /* must always be at least 1 */
4579 /* subtraction needed; var1 is > var2 */
4580 thisunit=(Unit)(thisunit+mult); /* accumulate */
4581 /* subtract var1-var2, into var1; only the overlap needs */
4582 /* processing, as this is an in-place calculation */
4583 shift=var2ulen-var2units;
4584 #if DECTRACE
4585 decDumpAr('1', &var1[shift], var1units-shift);
4586 decDumpAr('2', var2, var2units);
4587 printf("m=%ld\n", -mult);
4588 #endif
4589 decUnitAddSub(&var1[shift], var1units-shift,
4590 var2, var2units, 0,
4591 &var1[shift], -mult);
4592 #if DECTRACE
4593 decDumpAr('#', &var1[shift], var1units-shift);
4594 #endif
4595 /* var1 now probably has leading zeros; these are removed at the */
4596 /* top of the inner loop. */
4597 } /* inner loop */
4598
4599 /* The next unit has been calculated in full; unless it's a */
4600 /* leading zero, add to acc */
4601 if (accunits!=0 || thisunit!=0) { /* is first or non-zero */
4602 *accnext=thisunit; /* store in accumulator */
4603 /* account exactly for the new digits */
4604 if (accunits==0) {
4605 accdigits++; /* at least one */
4606 for (pow=&powers[1]; thisunit>=*pow; pow++) accdigits++;
4607 }
4608 else accdigits+=DECDPUN;
4609 accunits++; /* update count */
4610 accnext--; /* ready for next */
4611 if (accdigits>reqdigits) break; /* have enough digits */
4612 }
4613
4614 /* if the residue is zero, the operation is done (unless divide */
4615 /* or divideInteger and still not enough digits yet) */
4616 if (*var1==0 && var1units==1) { /* residue is 0 */
4617 if (op&(REMAINDER|REMNEAR)) break;
4618 if ((op&DIVIDE) && (exponent<=maxexponent)) break;
4619 /* [drop through if divideInteger] */
4620 }
4621 /* also done enough if calculating remainder or integer */
4622 /* divide and just did the last ('units') unit */
4623 if (exponent==0 && !(op&DIVIDE)) break;
4624
4625 /* to get here, var1 is less than var2, so divide var2 by the per- */
4626 /* Unit power of ten and go for the next digit */
4627 var2ulen--; /* shift down */
4628 exponent-=DECDPUN; /* update the exponent */
4629 } /* outer loop */
4630
4631 /* ---- division is complete --------------------------------------- */
4632 /* here: acc has at least reqdigits+1 of good results (or fewer */
4633 /* if early stop), starting at accnext+1 (its lsu) */
4634 /* var1 has any residue at the stopping point */
4635 /* accunits is the number of digits collected in acc */
4636 if (accunits==0) { /* acc is 0 */
4637 accunits=1; /* show have a unit .. */
4638 accdigits=1; /* .. */
4639 *accnext=0; /* .. whose value is 0 */
4640 }
4641 else accnext++; /* back to last placed */
4642 /* accnext now -> lowest unit of result */
4643
4644 residue=0; /* assume no residue */
4645 if (op&DIVIDE) {
4646 /* record the presence of any residue, for rounding */
4647 if (*var1!=0 || var1units>1) residue=1;
4648 else { /* no residue */
4649 /* Had an exact division; clean up spurious trailing 0s. */
4650 /* There will be at most DECDPUN-1, from the final multiply, */
4651 /* and then only if the result is non-0 (and even) and the */
4652 /* exponent is 'loose'. */
4653 #if DECDPUN>1
4654 Unit lsu=*accnext;
4655 if (!(lsu&0x01) && (lsu!=0)) {
4656 /* count the trailing zeros */
4657 Int drop=0;
4658 for (;; drop++) { /* [will terminate because lsu!=0] */
4659 if (exponent>=maxexponent) break; /* don't chop real 0s */
4660 #if DECDPUN<=4
4661 if ((lsu-QUOT10(lsu, drop+1)
4662 *powers[drop+1])!=0) break; /* found non-0 digit */
4663 #else
4664 if (lsu%powers[drop+1]!=0) break; /* found non-0 digit */
4665 #endif
4666 exponent++;
4667 }
4668 if (drop>0) {
4669 accunits=decShiftToLeast(accnext, accunits, drop);
4670 accdigits=decGetDigits(accnext, accunits);
4671 accunits=D2U(accdigits);
4672 /* [exponent was adjusted in the loop] */
4673 }
4674 } /* neither odd nor 0 */
4675 #endif
4676 } /* exact divide */
4677 } /* divide */
4678 else /* op!=DIVIDE */ {
4679 /* check for coefficient overflow */
4680 if (accdigits+exponent>reqdigits) {
4681 *status|=DEC_Division_impossible;
4682 break;
4683 }
4684 if (op & (REMAINDER|REMNEAR)) {
4685 /* [Here, the exponent will be 0, because var1 was adjusted */
4686 /* appropriately.] */
4687 Int postshift; /* work */
4688 Flag wasodd=0; /* integer was odd */
4689 Unit *quotlsu; /* for save */
4690 Int quotdigits; /* .. */
4691
4692 bits=lhs->bits; /* remainder sign is always as lhs */
4693
4694 /* Fastpath when residue is truly 0 is worthwhile [and */
4695 /* simplifies the code below] */
4696 if (*var1==0 && var1units==1) { /* residue is 0 */
4697 Int exp=lhs->exponent; /* save min(exponents) */
4698 if (rhs->exponent<exp) exp=rhs->exponent;
4699 uprv_decNumberZero(res); /* 0 coefficient */
4700 #if DECSUBSET
4701 if (set->extended)
4702 #endif
4703 res->exponent=exp; /* .. with proper exponent */
4704 res->bits=(uByte)(bits&DECNEG); /* [cleaned] */
4705 decFinish(res, set, &residue, status); /* might clamp */
4706 break;
4707 }
4708 /* note if the quotient was odd */
4709 if (*accnext & 0x01) wasodd=1; /* acc is odd */
4710 quotlsu=accnext; /* save in case need to reinspect */
4711 quotdigits=accdigits; /* .. */
4712
4713 /* treat the residue, in var1, as the value to return, via acc */
4714 /* calculate the unused zero digits. This is the smaller of: */
4715 /* var1 initial padding (saved above) */
4716 /* var2 residual padding, which happens to be given by: */
4717 postshift=var1initpad+exponent-lhs->exponent+rhs->exponent;
4718 /* [the 'exponent' term accounts for the shifts during divide] */
4719 if (var1initpad<postshift) postshift=var1initpad;
4720
4721 /* shift var1 the requested amount, and adjust its digits */
4722 var1units=decShiftToLeast(var1, var1units, postshift);
4723 accnext=var1;
4724 accdigits=decGetDigits(var1, var1units);
4725 accunits=D2U(accdigits);
4726
4727 exponent=lhs->exponent; /* exponent is smaller of lhs & rhs */
4728 if (rhs->exponent<exponent) exponent=rhs->exponent;
4729
4730 /* Now correct the result if doing remainderNear; if it */
4731 /* (looking just at coefficients) is > rhs/2, or == rhs/2 and */
4732 /* the integer was odd then the result should be rem-rhs. */
4733 if (op&REMNEAR) {
4734 Int compare, tarunits; /* work */
4735 Unit *up; /* .. */
4736 /* calculate remainder*2 into the var1 buffer (which has */
4737 /* 'headroom' of an extra unit and hence enough space) */
4738 /* [a dedicated 'double' loop would be faster, here] */
4739 tarunits=decUnitAddSub(accnext, accunits, accnext, accunits,
4740 0, accnext, 1);
4741 /* decDumpAr('r', accnext, tarunits); */
4742
4743 /* Here, accnext (var1) holds tarunits Units with twice the */
4744 /* remainder's coefficient, which must now be compared to the */
4745 /* RHS. The remainder's exponent may be smaller than the RHS's. */
4746 compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits),
4747 rhs->exponent-exponent);
4748 if (compare==BADINT) { /* deep trouble */
4749 *status|=DEC_Insufficient_storage;
4750 break;}
4751
4752 /* now restore the remainder by dividing by two; the lsu */
4753 /* is known to be even. */
4754 for (up=accnext; up<accnext+tarunits; up++) {
4755 Int half; /* half to add to lower unit */
4756 half=*up & 0x01;
4757 *up/=2; /* [shift] */
4758 if (!half) continue;
4759 *(up-1)+=(DECDPUNMAX+1)/2;
4760 }
4761 /* [accunits still describes the original remainder length] */
4762
4763 if (compare>0 || (compare==0 && wasodd)) { /* adjustment needed */
4764 Int exp, expunits, exprem; /* work */
4765 /* This is effectively causing round-up of the quotient, */
4766 /* so if it was the rare case where it was full and all */
4767 /* nines, it would overflow and hence division-impossible */
4768 /* should be raised */
4769 Flag allnines=0; /* 1 if quotient all nines */
4770 if (quotdigits==reqdigits) { /* could be borderline */
4771 for (up=quotlsu; ; up++) {
4772 if (quotdigits>DECDPUN) {
4773 if (*up!=DECDPUNMAX) break;/* non-nines */
4774 }
4775 else { /* this is the last Unit */
4776 if (*up==powers[quotdigits]-1) allnines=1;
4777 break;
4778 }
4779 quotdigits-=DECDPUN; /* checked those digits */
4780 } /* up */
4781 } /* borderline check */
4782 if (allnines) {
4783 *status|=DEC_Division_impossible;
4784 break;}
4785
4786 /* rem-rhs is needed; the sign will invert. Again, var1 */
4787 /* can safely be used for the working Units array. */
4788 exp=rhs->exponent-exponent; /* RHS padding needed */
4789 /* Calculate units and remainder from exponent. */
4790 expunits=exp/DECDPUN;
4791 exprem=exp%DECDPUN;
4792 /* subtract [A+B*(-m)]; the result will always be negative */
4793 accunits=-decUnitAddSub(accnext, accunits,
4794 rhs->lsu, D2U(rhs->digits),
4795 expunits, accnext, -(Int)powers[exprem]);
4796 accdigits=decGetDigits(accnext, accunits); /* count digits exactly */
4797 accunits=D2U(accdigits); /* and recalculate the units for copy */
4798 /* [exponent is as for original remainder] */
4799 bits^=DECNEG; /* flip the sign */
4800 }
4801 } /* REMNEAR */
4802 } /* REMAINDER or REMNEAR */
4803 } /* not DIVIDE */
4804
4805 /* Set exponent and bits */
4806 res->exponent=exponent;
4807 res->bits=(uByte)(bits&DECNEG); /* [cleaned] */
4808
4809 /* Now the coefficient. */
4810 decSetCoeff(res, set, accnext, accdigits, &residue, status);
4811
4812 decFinish(res, set, &residue, status); /* final cleanup */
4813
4814 #if DECSUBSET
4815 /* If a divide then strip trailing zeros if subset [after round] */
4816 if (!set->extended && (op==DIVIDE)) decTrim(res, set, 0, 1, &dropped);
4817 #endif
4818 } while(0); /* end protected */
4819
4820 if (varalloc!=NULL) free(varalloc); /* drop any storage used */
4821 if (allocacc!=NULL) free(allocacc); /* .. */
4822 #if DECSUBSET
4823 if (allocrhs!=NULL) free(allocrhs); /* .. */
4824 if (alloclhs!=NULL) free(alloclhs); /* .. */
4825 #endif
4826 return res;
4827 } /* decDivideOp */
4828
4829 /* ------------------------------------------------------------------ */
4830 /* decMultiplyOp -- multiplication operation */
4831 /* */
4832 /* This routine performs the multiplication C=A x B. */
4833 /* */
4834 /* res is C, the result. C may be A and/or B (e.g., X=X*X) */
4835 /* lhs is A */
4836 /* rhs is B */
4837 /* set is the context */
4838 /* status is the usual accumulator */
4839 /* */
4840 /* C must have space for set->digits digits. */
4841 /* */
4842 /* ------------------------------------------------------------------ */
4843 /* 'Classic' multiplication is used rather than Karatsuba, as the */
4844 /* latter would give only a minor improvement for the short numbers */
4845 /* expected to be handled most (and uses much more memory). */
4846 /* */
4847 /* There are two major paths here: the general-purpose ('old code') */
4848 /* path which handles all DECDPUN values, and a fastpath version */
4849 /* which is used if 64-bit ints are available, DECDPUN<=4, and more */
4850 /* than two calls to decUnitAddSub would be made. */
4851 /* */
4852 /* The fastpath version lumps units together into 8-digit or 9-digit */
4853 /* chunks, and also uses a lazy carry strategy to minimise expensive */
4854 /* 64-bit divisions. The chunks are then broken apart again into */
4855 /* units for continuing processing. Despite this overhead, the */
4856 /* fastpath can speed up some 16-digit operations by 10x (and much */
4857 /* more for higher-precision calculations). */
4858 /* */
4859 /* A buffer always has to be used for the accumulator; in the */
4860 /* fastpath, buffers are also always needed for the chunked copies of */
4861 /* of the operand coefficients. */
4862 /* Static buffers are larger than needed just for multiply, to allow */
4863 /* for calls from other operations (notably exp). */
4864 /* ------------------------------------------------------------------ */
4865 #define FASTMUL (DECUSE64 && DECDPUN<5)
4866 static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,
4867 const decNumber *rhs, decContext *set,
4868 uInt *status) {
4869 Int accunits; /* Units of accumulator in use */
4870 Int exponent; /* work */
4871 Int residue=0; /* rounding residue */
4872 uByte bits; /* result sign */
4873 Unit *acc; /* -> accumulator Unit array */
4874 Int needbytes; /* size calculator */
4875 void *allocacc=NULL; /* -> allocated accumulator, iff allocated */
4876 Unit accbuff[SD2U(DECBUFFER*4+1)]; /* buffer (+1 for DECBUFFER==0, */
4877 /* *4 for calls from other operations) */
4878 const Unit *mer, *mermsup; /* work */
4879 Int madlength; /* Units in multiplicand */
4880 Int shift; /* Units to shift multiplicand by */
4881
4882 #if FASTMUL
4883 /* if DECDPUN is 1 or 3 work in base 10**9, otherwise */
4884 /* (DECDPUN is 2 or 4) then work in base 10**8 */
4885 #if DECDPUN & 1 /* odd */
4886 #define FASTBASE 1000000000 /* base */
4887 #define FASTDIGS 9 /* digits in base */
4888 #define FASTLAZY 18 /* carry resolution point [1->18] */
4889 #else
4890 #define FASTBASE 100000000
4891 #define FASTDIGS 8
4892 #define FASTLAZY 1844 /* carry resolution point [1->1844] */
4893 #endif
4894 /* three buffers are used, two for chunked copies of the operands */
4895 /* (base 10**8 or base 10**9) and one base 2**64 accumulator with */
4896 /* lazy carry evaluation */
4897 uInt zlhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
4898 uInt *zlhi=zlhibuff; /* -> lhs array */
4899 uInt *alloclhi=NULL; /* -> allocated buffer, iff allocated */
4900 uInt zrhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
4901 uInt *zrhi=zrhibuff; /* -> rhs array */
4902 uInt *allocrhi=NULL; /* -> allocated buffer, iff allocated */
4903 uLong zaccbuff[(DECBUFFER*2+1)/4+2]; /* buffer (+1 for DECBUFFER==0) */
4904 /* [allocacc is shared for both paths, as only one will run] */
4905 uLong *zacc=zaccbuff; /* -> accumulator array for exact result */
4906 #if DECDPUN==1
4907 Int zoff; /* accumulator offset */
4908 #endif
4909 uInt *lip, *rip; /* item pointers */
4910 uInt *lmsi, *rmsi; /* most significant items */
4911 Int ilhs, irhs, iacc; /* item counts in the arrays */
4912 Int lazy; /* lazy carry counter */
4913 uLong lcarry; /* uLong carry */
4914 uInt carry; /* carry (NB not uLong) */
4915 Int count; /* work */
4916 const Unit *cup; /* .. */
4917 Unit *up; /* .. */
4918 uLong *lp; /* .. */
4919 Int p; /* .. */
4920 #endif
4921
4922 #if DECSUBSET
4923 decNumber *alloclhs=NULL; /* -> allocated buffer, iff allocated */
4924 decNumber *allocrhs=NULL; /* -> allocated buffer, iff allocated */
4925 #endif
4926
4927 #if DECCHECK
4928 if (decCheckOperands(res, lhs, rhs, set)) return res;
4929 #endif
4930
4931 /* precalculate result sign */
4932 bits=(uByte)((lhs->bits^rhs->bits)&DECNEG);
4933
4934 /* handle infinities and NaNs */
4935 if (SPECIALARGS) { /* a special bit set */
4936 if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
4937 decNaNs(res, lhs, rhs, set, status);
4938 return res;}
4939 /* one or two infinities; Infinity * 0 is invalid */
4940 if (((lhs->bits & DECINF)==0 && ISZERO(lhs))
4941 ||((rhs->bits & DECINF)==0 && ISZERO(rhs))) {
4942 *status|=DEC_Invalid_operation;
4943 return res;}
4944 uprv_decNumberZero(res);
4945 res->bits=bits|DECINF; /* infinity */
4946 return res;}
4947
4948 /* For best speed, as in DMSRCN [the original Rexx numerics */
4949 /* module], use the shorter number as the multiplier (rhs) and */
4950 /* the longer as the multiplicand (lhs) to minimise the number of */
4951 /* adds (partial products) */
4952 if (lhs->digits<rhs->digits) { /* swap... */
4953 const decNumber *hold=lhs;
4954 lhs=rhs;
4955 rhs=hold;
4956 }
4957
4958 do { /* protect allocated storage */
4959 #if DECSUBSET
4960 if (!set->extended) {
4961 /* reduce operands and set lostDigits status, as needed */
4962 if (lhs->digits>set->digits) {
4963 alloclhs=decRoundOperand(lhs, set, status);
4964 if (alloclhs==NULL) break;
4965 lhs=alloclhs;
4966 }
4967 if (rhs->digits>set->digits) {
4968 allocrhs=decRoundOperand(rhs, set, status);
4969 if (allocrhs==NULL) break;
4970 rhs=allocrhs;
4971 }
4972 }
4973 #endif
4974 /* [following code does not require input rounding] */
4975
4976 #if FASTMUL /* fastpath can be used */
4977 /* use the fast path if there are enough digits in the shorter */
4978 /* operand to make the setup and takedown worthwhile */
4979 #define NEEDTWO (DECDPUN*2) /* within two decUnitAddSub calls */
4980 if (rhs->digits>NEEDTWO) { /* use fastpath... */
4981 /* calculate the number of elements in each array */
4982 ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; /* [ceiling] */
4983 irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; /* .. */
4984 iacc=ilhs+irhs;
4985
4986 /* allocate buffers if required, as usual */
4987 needbytes=ilhs*sizeof(uInt);
4988 if (needbytes>(Int)sizeof(zlhibuff)) {
4989 alloclhi=(uInt *)malloc(needbytes);
4990 zlhi=alloclhi;}
4991 needbytes=irhs*sizeof(uInt);
4992 if (needbytes>(Int)sizeof(zrhibuff)) {
4993 allocrhi=(uInt *)malloc(needbytes);
4994 zrhi=allocrhi;}
4995
4996 /* Allocating the accumulator space needs a special case when */
4997 /* DECDPUN=1 because when converting the accumulator to Units */
4998 /* after the multiplication each 8-byte item becomes 9 1-byte */
4999 /* units. Therefore iacc extra bytes are needed at the front */
5000 /* (rounded up to a multiple of 8 bytes), and the uLong */
5001 /* accumulator starts offset the appropriate number of units */
5002 /* to the right to avoid overwrite during the unchunking. */
5003
5004 /* Make sure no signed int overflow below. This is always true */
5005 /* if the given numbers have less digits than DEC_MAX_DIGITS. */
5006 U_ASSERT(iacc <= INT32_MAX/sizeof(uLong));
5007 needbytes=iacc*sizeof(uLong);
5008 #if DECDPUN==1
5009 zoff=(iacc+7)/8; /* items to offset by */
5010 needbytes+=zoff*8;
5011 #endif
5012 if (needbytes>(Int)sizeof(zaccbuff)) {
5013 allocacc=(uLong *)malloc(needbytes);
5014 zacc=(uLong *)allocacc;}
5015 if (zlhi==NULL||zrhi==NULL||zacc==NULL) {
5016 *status|=DEC_Insufficient_storage;
5017 break;}
5018
5019 acc=(Unit *)zacc; /* -> target Unit array */
5020 #if DECDPUN==1
5021 zacc+=zoff; /* start uLong accumulator to right */
5022 #endif
5023
5024 /* assemble the chunked copies of the left and right sides */
5025 for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++)
5026 for (p=0, *lip=0; p<FASTDIGS && count>0;
5027 p+=DECDPUN, cup++, count-=DECDPUN)
5028 *lip+=*cup*powers[p];
5029 lmsi=lip-1; /* save -> msi */
5030 for (count=rhs->digits, cup=rhs->lsu, rip=zrhi; count>0; rip++)
5031 for (p=0, *rip=0; p<FASTDIGS && count>0;
5032 p+=DECDPUN, cup++, count-=DECDPUN)
5033 *rip+=*cup*powers[p];
5034 rmsi=rip-1; /* save -> msi */
5035
5036 /* zero the accumulator */
5037 for (lp=zacc; lp<zacc+iacc; lp++) *lp=0;
5038
5039 /* Start the multiplication */
5040 /* Resolving carries can dominate the cost of accumulating the */
5041 /* partial products, so this is only done when necessary. */
5042 /* Each uLong item in the accumulator can hold values up to */
5043 /* 2**64-1, and each partial product can be as large as */
5044 /* (10**FASTDIGS-1)**2. When FASTDIGS=9, this can be added to */
5045 /* itself 18.4 times in a uLong without overflowing, so during */
5046 /* the main calculation resolution is carried out every 18th */
5047 /* add -- every 162 digits. Similarly, when FASTDIGS=8, the */
5048 /* partial products can be added to themselves 1844.6 times in */
5049 /* a uLong without overflowing, so intermediate carry */
5050 /* resolution occurs only every 14752 digits. Hence for common */
5051 /* short numbers usually only the one final carry resolution */
5052 /* occurs. */
5053 /* (The count is set via FASTLAZY to simplify experiments to */
5054 /* measure the value of this approach: a 35% improvement on a */
5055 /* [34x34] multiply.) */
5056 lazy=FASTLAZY; /* carry delay count */
5057 for (rip=zrhi; rip<=rmsi; rip++) { /* over each item in rhs */
5058 lp=zacc+(rip-zrhi); /* where to add the lhs */
5059 for (lip=zlhi; lip<=lmsi; lip++, lp++) { /* over each item in lhs */
5060 *lp+=(uLong)(*lip)*(*rip); /* [this should in-line] */
5061 } /* lip loop */
5062 lazy--;
5063 if (lazy>0 && rip!=rmsi) continue;
5064 lazy=FASTLAZY; /* reset delay count */
5065 /* spin up the accumulator resolving overflows */
5066 for (lp=zacc; lp<zacc+iacc; lp++) {
5067 if (*lp<FASTBASE) continue; /* it fits */
5068 lcarry=*lp/FASTBASE; /* top part [slow divide] */
5069 /* lcarry can exceed 2**32-1, so check again; this check */
5070 /* and occasional extra divide (slow) is well worth it, as */
5071 /* it allows FASTLAZY to be increased to 18 rather than 4 */
5072 /* in the FASTDIGS=9 case */
5073 if (lcarry<FASTBASE) carry=(uInt)lcarry; /* [usual] */
5074 else { /* two-place carry [fairly rare] */
5075 uInt carry2=(uInt)(lcarry/FASTBASE); /* top top part */
5076 *(lp+2)+=carry2; /* add to item+2 */
5077 *lp-=((uLong)FASTBASE*FASTBASE*carry2); /* [slow] */
5078 carry=(uInt)(lcarry-((uLong)FASTBASE*carry2)); /* [inline] */
5079 }
5080 *(lp+1)+=carry; /* add to item above [inline] */
5081 *lp-=((uLong)FASTBASE*carry); /* [inline] */
5082 } /* carry resolution */
5083 } /* rip loop */
5084
5085 /* The multiplication is complete; time to convert back into */
5086 /* units. This can be done in-place in the accumulator and in */
5087 /* 32-bit operations, because carries were resolved after the */
5088 /* final add. This needs N-1 divides and multiplies for */
5089 /* each item in the accumulator (which will become up to N */
5090 /* units, where 2<=N<=9). */
5091 for (lp=zacc, up=acc; lp<zacc+iacc; lp++) {
5092 uInt item=(uInt)*lp; /* decapitate to uInt */
5093 for (p=0; p<FASTDIGS-DECDPUN; p+=DECDPUN, up++) {
5094 uInt part=item/(DECDPUNMAX+1);
5095 *up=(Unit)(item-(part*(DECDPUNMAX+1)));
5096 item=part;
5097 } /* p */
5098 *up=(Unit)item; up++; /* [final needs no division] */
5099 } /* lp */
5100 accunits=up-acc; /* count of units */
5101 }
5102 else { /* here to use units directly, without chunking ['old code'] */
5103 #endif
5104
5105 /* if accumulator will be too long for local storage, then allocate */
5106 acc=accbuff; /* -> assume buffer for accumulator */
5107 needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit);
5108 if (needbytes>(Int)sizeof(accbuff)) {
5109 allocacc=(Unit *)malloc(needbytes);
5110 if (allocacc==NULL) {*status|=DEC_Insufficient_storage; break;}
5111 acc=(Unit *)allocacc; /* use the allocated space */
5112 }
5113
5114 /* Now the main long multiplication loop */
5115 /* Unlike the equivalent in the IBM Java implementation, there */
5116 /* is no advantage in calculating from msu to lsu. So, do it */
5117 /* by the book, as it were. */
5118 /* Each iteration calculates ACC=ACC+MULTAND*MULT */
5119 accunits=1; /* accumulator starts at '0' */
5120 *acc=0; /* .. (lsu=0) */
5121 shift=0; /* no multiplicand shift at first */
5122 madlength=D2U(lhs->digits); /* this won't change */
5123 mermsup=rhs->lsu+D2U(rhs->digits); /* -> msu+1 of multiplier */
5124
5125 for (mer=rhs->lsu; mer<mermsup; mer++) {
5126 /* Here, *mer is the next Unit in the multiplier to use */
5127 /* If non-zero [optimization] add it... */
5128 if (*mer!=0) accunits=decUnitAddSub(&acc[shift], accunits-shift,
5129 lhs->lsu, madlength, 0,
5130 &acc[shift], *mer)
5131 + shift;
5132 else { /* extend acc with a 0; it will be used shortly */
5133 *(acc+accunits)=0; /* [this avoids length of <=0 later] */
5134 accunits++;
5135 }
5136 /* multiply multiplicand by 10**DECDPUN for next Unit to left */
5137 shift++; /* add this for 'logical length' */
5138 } /* n */
5139 #if FASTMUL
5140 } /* unchunked units */
5141 #endif
5142 /* common end-path */
5143 #if DECTRACE
5144 decDumpAr('*', acc, accunits); /* Show exact result */
5145 #endif
5146
5147 /* acc now contains the exact result of the multiplication, */
5148 /* possibly with a leading zero unit; build the decNumber from */
5149 /* it, noting if any residue */
5150 res->bits=bits; /* set sign */
5151 res->digits=decGetDigits(acc, accunits); /* count digits exactly */
5152
5153 /* There can be a 31-bit wrap in calculating the exponent. */
5154 /* This can only happen if both input exponents are negative and */
5155 /* both their magnitudes are large. If there was a wrap, set a */
5156 /* safe very negative exponent, from which decFinalize() will */
5157 /* raise a hard underflow shortly. */
5158 exponent=lhs->exponent+rhs->exponent; /* calculate exponent */
5159 if (lhs->exponent<0 && rhs->exponent<0 && exponent>0)
5160 exponent=-2*DECNUMMAXE; /* force underflow */
5161 res->exponent=exponent; /* OK to overwrite now */
5162
5163
5164 /* Set the coefficient. If any rounding, residue records */
5165 decSetCoeff(res, set, acc, res->digits, &residue, status);
5166 decFinish(res, set, &residue, status); /* final cleanup */
5167 } while(0); /* end protected */
5168
5169 if (allocacc!=NULL) free(allocacc); /* drop any storage used */
5170 #if DECSUBSET
5171 if (allocrhs!=NULL) free(allocrhs); /* .. */
5172 if (alloclhs!=NULL) free(alloclhs); /* .. */
5173 #endif
5174 #if FASTMUL
5175 if (allocrhi!=NULL) free(allocrhi); /* .. */
5176 if (alloclhi!=NULL) free(alloclhi); /* .. */
5177 #endif
5178 return res;
5179 } /* decMultiplyOp */
5180
5181 /* ------------------------------------------------------------------ */
5182 /* decExpOp -- effect exponentiation */
5183 /* */
5184 /* This computes C = exp(A) */
5185 /* */
5186 /* res is C, the result. C may be A */
5187 /* rhs is A */
5188 /* set is the context; note that rounding mode has no effect */
5189 /* */
5190 /* C must have space for set->digits digits. status is updated but */
5191 /* not set. */
5192 /* */
5193 /* Restrictions: */
5194 /* */
5195 /* digits, emax, and -emin in the context must be less than */
5196 /* 2*DEC_MAX_MATH (1999998), and the rhs must be within these */
5197 /* bounds or a zero. This is an internal routine, so these */
5198 /* restrictions are contractual and not enforced. */
5199 /* */
5200 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */
5201 /* almost always be correctly rounded, but may be up to 1 ulp in */
5202 /* error in rare cases. */
5203 /* */
5204 /* Finite results will always be full precision and Inexact, except */
5205 /* when A is a zero or -Infinity (giving 1 or 0 respectively). */
5206 /* ------------------------------------------------------------------ */
5207 /* This approach used here is similar to the algorithm described in */
5208 /* */
5209 /* Variable Precision Exponential Function, T. E. Hull and */
5210 /* A. Abrham, ACM Transactions on Mathematical Software, Vol 12 #2, */
5211 /* pp79-91, ACM, June 1986. */
5212 /* */
5213 /* with the main difference being that the iterations in the series */
5214 /* evaluation are terminated dynamically (which does not require the */
5215 /* extra variable-precision variables which are expensive in this */
5216 /* context). */
5217 /* */
5218 /* The error analysis in Hull & Abrham's paper applies except for the */
5219 /* round-off error accumulation during the series evaluation. This */
5220 /* code does not precalculate the number of iterations and so cannot */
5221 /* use Horner's scheme. Instead, the accumulation is done at double- */
5222 /* precision, which ensures that the additions of the terms are exact */
5223 /* and do not accumulate round-off (and any round-off errors in the */
5224 /* terms themselves move 'to the right' faster than they can */
5225 /* accumulate). This code also extends the calculation by allowing, */
5226 /* in the spirit of other decNumber operators, the input to be more */
5227 /* precise than the result (the precision used is based on the more */
5228 /* precise of the input or requested result). */
5229 /* */
5230 /* Implementation notes: */
5231 /* */
5232 /* 1. This is separated out as decExpOp so it can be called from */
5233 /* other Mathematical functions (notably Ln) with a wider range */
5234 /* than normal. In particular, it can handle the slightly wider */
5235 /* (double) range needed by Ln (which has to be able to calculate */
5236 /* exp(-x) where x can be the tiniest number (Ntiny). */
5237 /* */
5238 /* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop */
5239 /* iterations by appoximately a third with additional (although */
5240 /* diminishing) returns as the range is reduced to even smaller */
5241 /* fractions. However, h (the power of 10 used to correct the */
5242 /* result at the end, see below) must be kept <=8 as otherwise */
5243 /* the final result cannot be computed. Hence the leverage is a */
5244 /* sliding value (8-h), where potentially the range is reduced */
5245 /* more for smaller values. */
5246 /* */
5247 /* The leverage that can be applied in this way is severely */
5248 /* limited by the cost of the raise-to-the power at the end, */
5249 /* which dominates when the number of iterations is small (less */
5250 /* than ten) or when rhs is short. As an example, the adjustment */
5251 /* x**10,000,000 needs 31 multiplications, all but one full-width. */
5252 /* */
5253 /* 3. The restrictions (especially precision) could be raised with */
5254 /* care, but the full decNumber range seems very hard within the */
5255 /* 32-bit limits. */
5256 /* */
5257 /* 4. The working precisions for the static buffers are twice the */
5258 /* obvious size to allow for calls from decNumberPower. */
5259 /* ------------------------------------------------------------------ */
5260 decNumber * decExpOp(decNumber *res, const decNumber *rhs,
5261 decContext *set, uInt *status) {
5262 uInt ignore=0; /* working status */
5263 Int h; /* adjusted exponent for 0.xxxx */
5264 Int p; /* working precision */
5265 Int residue; /* rounding residue */
5266 uInt needbytes; /* for space calculations */
5267 const decNumber *x=rhs; /* (may point to safe copy later) */
5268 decContext aset, tset, dset; /* working contexts */
5269 Int comp; /* work */
5270
5271 /* the argument is often copied to normalize it, so (unusually) it */
5272 /* is treated like other buffers, using DECBUFFER, +1 in case */
5273 /* DECBUFFER is 0 */
5274 decNumber bufr[D2N(DECBUFFER*2+1)];
5275 decNumber *allocrhs=NULL; /* non-NULL if rhs buffer allocated */
5276
5277 /* the working precision will be no more than set->digits+8+1 */
5278 /* so for on-stack buffers DECBUFFER+9 is used, +1 in case DECBUFFER */
5279 /* is 0 (and twice that for the accumulator) */
5280
5281 /* buffer for t, term (working precision plus) */
5282 decNumber buft[D2N(DECBUFFER*2+9+1)];
5283 decNumber *allocbuft=NULL; /* -> allocated buft, iff allocated */
5284 decNumber *t=buft; /* term */
5285 /* buffer for a, accumulator (working precision * 2), at least 9 */
5286 decNumber bufa[D2N(DECBUFFER*4+18+1)];
5287 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
5288 decNumber *a=bufa; /* accumulator */
5289 /* decNumber for the divisor term; this needs at most 9 digits */
5290 /* and so can be fixed size [16 so can use standard context] */
5291 decNumber bufd[D2N(16)];
5292 decNumber *d=bufd; /* divisor */
5293 decNumber numone; /* constant 1 */
5294
5295 #if DECCHECK
5296 Int iterations=0; /* for later sanity check */
5297 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5298 #endif
5299
5300 do { /* protect allocated storage */
5301 if (SPECIALARG) { /* handle infinities and NaNs */
5302 if (decNumberIsInfinite(rhs)) { /* an infinity */
5303 if (decNumberIsNegative(rhs)) /* -Infinity -> +0 */
5304 uprv_decNumberZero(res);
5305 else uprv_decNumberCopy(res, rhs); /* +Infinity -> self */
5306 }
5307 else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5308 break;}
5309
5310 if (ISZERO(rhs)) { /* zeros -> exact 1 */
5311 uprv_decNumberZero(res); /* make clean 1 */
5312 *res->lsu=1; /* .. */
5313 break;} /* [no status to set] */
5314
5315 /* e**x when 0 < x < 0.66 is < 1+3x/2, hence can fast-path */
5316 /* positive and negative tiny cases which will result in inexact */
5317 /* 1. This also allows the later add-accumulate to always be */
5318 /* exact (because its length will never be more than twice the */
5319 /* working precision). */
5320 /* The comparator (tiny) needs just one digit, so use the */
5321 /* decNumber d for it (reused as the divisor, etc., below); its */
5322 /* exponent is such that if x is positive it will have */
5323 /* set->digits-1 zeros between the decimal point and the digit, */
5324 /* which is 4, and if x is negative one more zero there as the */
5325 /* more precise result will be of the form 0.9999999 rather than */
5326 /* 1.0000001. Hence, tiny will be 0.0000004 if digits=7 and x>0 */
5327 /* or 0.00000004 if digits=7 and x<0. If RHS not larger than */
5328 /* this then the result will be 1.000000 */
5329 uprv_decNumberZero(d); /* clean */
5330 *d->lsu=4; /* set 4 .. */
5331 d->exponent=-set->digits; /* * 10**(-d) */
5332 if (decNumberIsNegative(rhs)) d->exponent--; /* negative case */
5333 comp=decCompare(d, rhs, 1); /* signless compare */
5334 if (comp==BADINT) {
5335 *status|=DEC_Insufficient_storage;
5336 break;}
5337 if (comp>=0) { /* rhs < d */
5338 Int shift=set->digits-1;
5339 uprv_decNumberZero(res); /* set 1 */
5340 *res->lsu=1; /* .. */
5341 res->digits=decShiftToMost(res->lsu, 1, shift);
5342 res->exponent=-shift; /* make 1.0000... */
5343 *status|=DEC_Inexact | DEC_Rounded; /* .. inexactly */
5344 break;} /* tiny */
5345
5346 /* set up the context to be used for calculating a, as this is */
5347 /* used on both paths below */
5348 uprv_decContextDefault(&aset, DEC_INIT_DECIMAL64);
5349 /* accumulator bounds are as requested (could underflow) */
5350 aset.emax=set->emax; /* usual bounds */
5351 aset.emin=set->emin; /* .. */
5352 aset.clamp=0; /* and no concrete format */
5353
5354 /* calculate the adjusted (Hull & Abrham) exponent (where the */
5355 /* decimal point is just to the left of the coefficient msd) */
5356 h=rhs->exponent+rhs->digits;
5357 /* if h>8 then 10**h cannot be calculated safely; however, when */
5358 /* h=8 then exp(|rhs|) will be at least exp(1E+7) which is at */
5359 /* least 6.59E+4342944, so (due to the restriction on Emax/Emin) */
5360 /* overflow (or underflow to 0) is guaranteed -- so this case can */
5361 /* be handled by simply forcing the appropriate excess */
5362 if (h>8) { /* overflow/underflow */
5363 /* set up here so Power call below will over or underflow to */
5364 /* zero; set accumulator to either 2 or 0.02 */
5365 /* [stack buffer for a is always big enough for this] */
5366 uprv_decNumberZero(a);
5367 *a->lsu=2; /* not 1 but < exp(1) */
5368 if (decNumberIsNegative(rhs)) a->exponent=-2; /* make 0.02 */
5369 h=8; /* clamp so 10**h computable */
5370 p=9; /* set a working precision */
5371 }
5372 else { /* h<=8 */
5373 Int maxlever=(rhs->digits>8?1:0);
5374 /* [could/should increase this for precisions >40 or so, too] */
5375
5376 /* if h is 8, cannot normalize to a lower upper limit because */
5377 /* the final result will not be computable (see notes above), */
5378 /* but leverage can be applied whenever h is less than 8. */
5379 /* Apply as much as possible, up to a MAXLEVER digits, which */
5380 /* sets the tradeoff against the cost of the later a**(10**h). */
5381 /* As h is increased, the working precision below also */
5382 /* increases to compensate for the "constant digits at the */
5383 /* front" effect. */
5384 Int lever=MINI(8-h, maxlever); /* leverage attainable */
5385 Int use=-rhs->digits-lever; /* exponent to use for RHS */
5386 h+=lever; /* apply leverage selected */
5387 if (h<0) { /* clamp */
5388 use+=h; /* [may end up subnormal] */
5389 h=0;
5390 }
5391 /* Take a copy of RHS if it needs normalization (true whenever x>=1) */
5392 if (rhs->exponent!=use) {
5393 decNumber *newrhs=bufr; /* assume will fit on stack */
5394 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
5395 if (needbytes>sizeof(bufr)) { /* need malloc space */
5396 allocrhs=(decNumber *)malloc(needbytes);
5397 if (allocrhs==NULL) { /* hopeless -- abandon */
5398 *status|=DEC_Insufficient_storage;
5399 break;}
5400 newrhs=allocrhs; /* use the allocated space */
5401 }
5402 uprv_decNumberCopy(newrhs, rhs); /* copy to safe space */
5403 newrhs->exponent=use; /* normalize; now <1 */
5404 x=newrhs; /* ready for use */
5405 /* decNumberShow(x); */
5406 }
5407
5408 /* Now use the usual power series to evaluate exp(x). The */
5409 /* series starts as 1 + x + x^2/2 ... so prime ready for the */
5410 /* third term by setting the term variable t=x, the accumulator */
5411 /* a=1, and the divisor d=2. */
5412
5413 /* First determine the working precision. From Hull & Abrham */
5414 /* this is set->digits+h+2. However, if x is 'over-precise' we */
5415 /* need to allow for all its digits to potentially participate */
5416 /* (consider an x where all the excess digits are 9s) so in */
5417 /* this case use x->digits+h+2 */
5418 p=MAXI(x->digits, set->digits)+h+2; /* [h<=8] */
5419
5420 /* a and t are variable precision, and depend on p, so space */
5421 /* must be allocated for them if necessary */
5422
5423 /* the accumulator needs to be able to hold 2p digits so that */
5424 /* the additions on the second and subsequent iterations are */
5425 /* sufficiently exact. */
5426 needbytes=sizeof(decNumber)+(D2U(p*2)-1)*sizeof(Unit);
5427 if (needbytes>sizeof(bufa)) { /* need malloc space */
5428 allocbufa=(decNumber *)malloc(needbytes);
5429 if (allocbufa==NULL) { /* hopeless -- abandon */
5430 *status|=DEC_Insufficient_storage;
5431 break;}
5432 a=allocbufa; /* use the allocated space */
5433 }
5434 /* the term needs to be able to hold p digits (which is */
5435 /* guaranteed to be larger than x->digits, so the initial copy */
5436 /* is safe); it may also be used for the raise-to-power */
5437 /* calculation below, which needs an extra two digits */
5438 needbytes=sizeof(decNumber)+(D2U(p+2)-1)*sizeof(Unit);
5439 if (needbytes>sizeof(buft)) { /* need malloc space */
5440 allocbuft=(decNumber *)malloc(needbytes);
5441 if (allocbuft==NULL) { /* hopeless -- abandon */
5442 *status|=DEC_Insufficient_storage;
5443 break;}
5444 t=allocbuft; /* use the allocated space */
5445 }
5446
5447 uprv_decNumberCopy(t, x); /* term=x */
5448 uprv_decNumberZero(a); *a->lsu=1; /* accumulator=1 */
5449 uprv_decNumberZero(d); *d->lsu=2; /* divisor=2 */
5450 uprv_decNumberZero(&numone); *numone.lsu=1; /* constant 1 for increment */
5451
5452 /* set up the contexts for calculating a, t, and d */
5453 uprv_decContextDefault(&tset, DEC_INIT_DECIMAL64);
5454 dset=tset;
5455 /* accumulator bounds are set above, set precision now */
5456 aset.digits=p*2; /* double */
5457 /* term bounds avoid any underflow or overflow */
5458 tset.digits=p;
5459 tset.emin=DEC_MIN_EMIN; /* [emax is plenty] */
5460 /* [dset.digits=16, etc., are sufficient] */
5461
5462 /* finally ready to roll */
5463 for (;;) {
5464 #if DECCHECK
5465 iterations++;
5466 #endif
5467 /* only the status from the accumulation is interesting */
5468 /* [but it should remain unchanged after first add] */
5469 decAddOp(a, a, t, &aset, 0, status); /* a=a+t */
5470 decMultiplyOp(t, t, x, &tset, &ignore); /* t=t*x */
5471 decDivideOp(t, t, d, &tset, DIVIDE, &ignore); /* t=t/d */
5472 /* the iteration ends when the term cannot affect the result, */
5473 /* if rounded to p digits, which is when its value is smaller */
5474 /* than the accumulator by p+1 digits. There must also be */
5475 /* full precision in a. */
5476 if (((a->digits+a->exponent)>=(t->digits+t->exponent+p+1))
5477 && (a->digits>=p)) break;
5478 decAddOp(d, d, &numone, &dset, 0, &ignore); /* d=d+1 */
5479 } /* iterate */
5480
5481 #if DECCHECK
5482 /* just a sanity check; comment out test to show always */
5483 if (iterations>p+3)
5484 printf("Exp iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5485 (LI)iterations, (LI)*status, (LI)p, (LI)x->digits);
5486 #endif
5487 } /* h<=8 */
5488
5489 /* apply postconditioning: a=a**(10**h) -- this is calculated */
5490 /* at a slightly higher precision than Hull & Abrham suggest */
5491 if (h>0) {
5492 Int seenbit=0; /* set once a 1-bit is seen */
5493 Int i; /* counter */
5494 Int n=powers[h]; /* always positive */
5495 aset.digits=p+2; /* sufficient precision */
5496 /* avoid the overhead and many extra digits of decNumberPower */
5497 /* as all that is needed is the short 'multipliers' loop; here */
5498 /* accumulate the answer into t */
5499 uprv_decNumberZero(t); *t->lsu=1; /* acc=1 */
5500 for (i=1;;i++){ /* for each bit [top bit ignored] */
5501 /* abandon if have had overflow or terminal underflow */
5502 if (*status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
5503 if (*status&DEC_Overflow || ISZERO(t)) break;}
5504 n=n<<1; /* move next bit to testable position */
5505 if (n<0) { /* top bit is set */
5506 seenbit=1; /* OK, have a significant bit */
5507 decMultiplyOp(t, t, a, &aset, status); /* acc=acc*x */
5508 }
5509 if (i==31) break; /* that was the last bit */
5510 if (!seenbit) continue; /* no need to square 1 */
5511 decMultiplyOp(t, t, t, &aset, status); /* acc=acc*acc [square] */
5512 } /*i*/ /* 32 bits */
5513 /* decNumberShow(t); */
5514 a=t; /* and carry on using t instead of a */
5515 }
5516
5517 /* Copy and round the result to res */
5518 residue=1; /* indicate dirt to right .. */
5519 if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */
5520 aset.digits=set->digits; /* [use default rounding] */
5521 decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5522 decFinish(res, set, &residue, status); /* cleanup/set flags */
5523 } while(0); /* end protected */
5524
5525 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */
5526 if (allocbufa!=NULL) free(allocbufa); /* .. */
5527 if (allocbuft!=NULL) free(allocbuft); /* .. */
5528 /* [status is handled by caller] */
5529 return res;
5530 } /* decExpOp */
5531
5532 /* ------------------------------------------------------------------ */
5533 /* Initial-estimate natural logarithm table */
5534 /* */
5535 /* LNnn -- 90-entry 16-bit table for values from .10 through .99. */
5536 /* The result is a 4-digit encode of the coefficient (c=the */
5537 /* top 14 bits encoding 0-9999) and a 2-digit encode of the */
5538 /* exponent (e=the bottom 2 bits encoding 0-3) */
5539 /* */
5540 /* The resulting value is given by: */
5541 /* */
5542 /* v = -c * 10**(-e-3) */
5543 /* */
5544 /* where e and c are extracted from entry k = LNnn[x-10] */
5545 /* where x is truncated (NB) into the range 10 through 99, */
5546 /* and then c = k>>2 and e = k&3. */
5547 /* ------------------------------------------------------------------ */
5548 static const uShort LNnn[90]={9016, 8652, 8316, 8008, 7724, 7456, 7208,
5549 6972, 6748, 6540, 6340, 6148, 5968, 5792, 5628, 5464, 5312,
5550 5164, 5020, 4884, 4748, 4620, 4496, 4376, 4256, 4144, 4032,
5551 39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629,
5552 29777, 28945, 28129, 27329, 26545, 25777, 25021, 24281, 23553, 22837,
5553 22137, 21445, 20769, 20101, 19445, 18801, 18165, 17541, 16925, 16321,
5554 15721, 15133, 14553, 13985, 13421, 12865, 12317, 11777, 11241, 10717,
5555 10197, 9685, 9177, 8677, 8185, 7697, 7213, 6737, 6269, 5801,
5556 5341, 4889, 4437, 39930, 35534, 31186, 26886, 22630, 18418, 14254,
5557 10130, 6046, 20055};
5558
5559 /* ------------------------------------------------------------------ */
5560 /* decLnOp -- effect natural logarithm */
5561 /* */
5562 /* This computes C = ln(A) */
5563 /* */
5564 /* res is C, the result. C may be A */
5565 /* rhs is A */
5566 /* set is the context; note that rounding mode has no effect */
5567 /* */
5568 /* C must have space for set->digits digits. */
5569 /* */
5570 /* Notable cases: */
5571 /* A<0 -> Invalid */
5572 /* A=0 -> -Infinity (Exact) */
5573 /* A=+Infinity -> +Infinity (Exact) */
5574 /* A=1 exactly -> 0 (Exact) */
5575 /* */
5576 /* Restrictions (as for Exp): */
5577 /* */
5578 /* digits, emax, and -emin in the context must be less than */
5579 /* DEC_MAX_MATH+11 (1000010), and the rhs must be within these */
5580 /* bounds or a zero. This is an internal routine, so these */
5581 /* restrictions are contractual and not enforced. */
5582 /* */
5583 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */
5584 /* almost always be correctly rounded, but may be up to 1 ulp in */
5585 /* error in rare cases. */
5586 /* ------------------------------------------------------------------ */
5587 /* The result is calculated using Newton's method, with each */
5588 /* iteration calculating a' = a + x * exp(-a) - 1. See, for example, */
5589 /* Epperson 1989. */
5590 /* */
5591 /* The iteration ends when the adjustment x*exp(-a)-1 is tiny enough. */
5592 /* This has to be calculated at the sum of the precision of x and the */
5593 /* working precision. */
5594 /* */
5595 /* Implementation notes: */
5596 /* */
5597 /* 1. This is separated out as decLnOp so it can be called from */
5598 /* other Mathematical functions (e.g., Log 10) with a wider range */
5599 /* than normal. In particular, it can handle the slightly wider */
5600 /* (+9+2) range needed by a power function. */
5601 /* */
5602 /* 2. The speed of this function is about 10x slower than exp, as */
5603 /* it typically needs 4-6 iterations for short numbers, and the */
5604 /* extra precision needed adds a squaring effect, twice. */
5605 /* */
5606 /* 3. Fastpaths are included for ln(10) and ln(2), up to length 40, */
5607 /* as these are common requests. ln(10) is used by log10(x). */
5608 /* */
5609 /* 4. An iteration might be saved by widening the LNnn table, and */
5610 /* would certainly save at least one if it were made ten times */
5611 /* bigger, too (for truncated fractions 0.100 through 0.999). */
5612 /* However, for most practical evaluations, at least four or five */
5613 /* iterations will be neede -- so this would only speed up by */
5614 /* 20-25% and that probably does not justify increasing the table */
5615 /* size. */
5616 /* */
5617 /* 5. The static buffers are larger than might be expected to allow */
5618 /* for calls from decNumberPower. */
5619 /* ------------------------------------------------------------------ */
5620 #if defined(__clang__) || U_GCC_MAJOR_MINOR >= 406
5621 #pragma GCC diagnostic push
5622 #pragma GCC diagnostic ignored "-Warray-bounds"
5623 #endif
5624 decNumber * decLnOp(decNumber *res, const decNumber *rhs,
5625 decContext *set, uInt *status) {
5626 uInt ignore=0; /* working status accumulator */
5627 uInt needbytes; /* for space calculations */
5628 Int residue; /* rounding residue */
5629 Int r; /* rhs=f*10**r [see below] */
5630 Int p; /* working precision */
5631 Int pp; /* precision for iteration */
5632 Int t; /* work */
5633
5634 /* buffers for a (accumulator, typically precision+2) and b */
5635 /* (adjustment calculator, same size) */
5636 decNumber bufa[D2N(DECBUFFER+12)];
5637 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
5638 decNumber *a=bufa; /* accumulator/work */
5639 decNumber bufb[D2N(DECBUFFER*2+2)];
5640 decNumber *allocbufb=NULL; /* -> allocated bufa, iff allocated */
5641 decNumber *b=bufb; /* adjustment/work */
5642
5643 decNumber numone; /* constant 1 */
5644 decNumber cmp; /* work */
5645 decContext aset, bset; /* working contexts */
5646
5647 #if DECCHECK
5648 Int iterations=0; /* for later sanity check */
5649 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5650 #endif
5651
5652 do { /* protect allocated storage */
5653 if (SPECIALARG) { /* handle infinities and NaNs */
5654 if (decNumberIsInfinite(rhs)) { /* an infinity */
5655 if (decNumberIsNegative(rhs)) /* -Infinity -> error */
5656 *status|=DEC_Invalid_operation;
5657 else uprv_decNumberCopy(res, rhs); /* +Infinity -> self */
5658 }
5659 else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5660 break;}
5661
5662 if (ISZERO(rhs)) { /* +/- zeros -> -Infinity */
5663 uprv_decNumberZero(res); /* make clean */
5664 res->bits=DECINF|DECNEG; /* set - infinity */
5665 break;} /* [no status to set] */
5666
5667 /* Non-zero negatives are bad... */
5668 if (decNumberIsNegative(rhs)) { /* -x -> error */
5669 *status|=DEC_Invalid_operation;
5670 break;}
5671
5672 /* Here, rhs is positive, finite, and in range */
5673
5674 /* lookaside fastpath code for ln(2) and ln(10) at common lengths */
5675 if (rhs->exponent==0 && set->digits<=40) {
5676 #if DECDPUN==1
5677 if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { /* ln(10) */
5678 #else
5679 if (rhs->lsu[0]==10 && rhs->digits==2) { /* ln(10) */
5680 #endif
5681 aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5682 #define LN10 "2.302585092994045684017991454684364207601"
5683 uprv_decNumberFromString(res, LN10, &aset);
5684 *status|=(DEC_Inexact | DEC_Rounded); /* is inexact */
5685 break;}
5686 if (rhs->lsu[0]==2 && rhs->digits==1) { /* ln(2) */
5687 aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5688 #define LN2 "0.6931471805599453094172321214581765680755"
5689 uprv_decNumberFromString(res, LN2, &aset);
5690 *status|=(DEC_Inexact | DEC_Rounded);
5691 break;}
5692 } /* integer and short */
5693
5694 /* Determine the working precision. This is normally the */
5695 /* requested precision + 2, with a minimum of 9. However, if */
5696 /* the rhs is 'over-precise' then allow for all its digits to */
5697 /* potentially participate (consider an rhs where all the excess */
5698 /* digits are 9s) so in this case use rhs->digits+2. */
5699 p=MAXI(rhs->digits, MAXI(set->digits, 7))+2;
5700
5701 /* Allocate space for the accumulator and the high-precision */
5702 /* adjustment calculator, if necessary. The accumulator must */
5703 /* be able to hold p digits, and the adjustment up to */
5704 /* rhs->digits+p digits. They are also made big enough for 16 */
5705 /* digits so that they can be used for calculating the initial */
5706 /* estimate. */
5707 needbytes=sizeof(decNumber)+(D2U(MAXI(p,16))-1)*sizeof(Unit);
5708 if (needbytes>sizeof(bufa)) { /* need malloc space */
5709 allocbufa=(decNumber *)malloc(needbytes);
5710 if (allocbufa==NULL) { /* hopeless -- abandon */
5711 *status|=DEC_Insufficient_storage;
5712 break;}
5713 a=allocbufa; /* use the allocated space */
5714 }
5715 pp=p+rhs->digits;
5716 needbytes=sizeof(decNumber)+(D2U(MAXI(pp,16))-1)*sizeof(Unit);
5717 if (needbytes>sizeof(bufb)) { /* need malloc space */
5718 allocbufb=(decNumber *)malloc(needbytes);
5719 if (allocbufb==NULL) { /* hopeless -- abandon */
5720 *status|=DEC_Insufficient_storage;
5721 break;}
5722 b=allocbufb; /* use the allocated space */
5723 }
5724
5725 /* Prepare an initial estimate in acc. Calculate this by */
5726 /* considering the coefficient of x to be a normalized fraction, */
5727 /* f, with the decimal point at far left and multiplied by */
5728 /* 10**r. Then, rhs=f*10**r and 0.1<=f<1, and */
5729 /* ln(x) = ln(f) + ln(10)*r */
5730 /* Get the initial estimate for ln(f) from a small lookup */
5731 /* table (see above) indexed by the first two digits of f, */
5732 /* truncated. */
5733
5734 uprv_decContextDefault(&aset, DEC_INIT_DECIMAL64); /* 16-digit extended */
5735 r=rhs->exponent+rhs->digits; /* 'normalised' exponent */
5736 uprv_decNumberFromInt32(a, r); /* a=r */
5737 uprv_decNumberFromInt32(b, 2302585); /* b=ln(10) (2.302585) */
5738 b->exponent=-6; /* .. */
5739 decMultiplyOp(a, a, b, &aset, &ignore); /* a=a*b */
5740 /* now get top two digits of rhs into b by simple truncate and */
5741 /* force to integer */
5742 residue=0; /* (no residue) */
5743 aset.digits=2; aset.round=DEC_ROUND_DOWN;
5744 decCopyFit(b, rhs, &aset, &residue, &ignore); /* copy & shorten */
5745 b->exponent=0; /* make integer */
5746 t=decGetInt(b); /* [cannot fail] */
5747 if (t<10) t=X10(t); /* adjust single-digit b */
5748 t=LNnn[t-10]; /* look up ln(b) */
5749 uprv_decNumberFromInt32(b, t>>2); /* b=ln(b) coefficient */
5750 b->exponent=-(t&3)-3; /* set exponent */
5751 b->bits=DECNEG; /* ln(0.10)->ln(0.99) always -ve */
5752 aset.digits=16; aset.round=DEC_ROUND_HALF_EVEN; /* restore */
5753 decAddOp(a, a, b, &aset, 0, &ignore); /* acc=a+b */
5754 /* the initial estimate is now in a, with up to 4 digits correct. */
5755 /* When rhs is at or near Nmax the estimate will be low, so we */
5756 /* will approach it from below, avoiding overflow when calling exp. */
5757
5758 uprv_decNumberZero(&numone); *numone.lsu=1; /* constant 1 for adjustment */
5759
5760 /* accumulator bounds are as requested (could underflow, but */
5761 /* cannot overflow) */
5762 aset.emax=set->emax;
5763 aset.emin=set->emin;
5764 aset.clamp=0; /* no concrete format */
5765 /* set up a context to be used for the multiply and subtract */
5766 bset=aset;
5767 bset.emax=DEC_MAX_MATH*2; /* use double bounds for the */
5768 bset.emin=-DEC_MAX_MATH*2; /* adjustment calculation */
5769 /* [see decExpOp call below] */
5770 /* for each iteration double the number of digits to calculate, */
5771 /* up to a maximum of p */
5772 pp=9; /* initial precision */
5773 /* [initially 9 as then the sequence starts 7+2, 16+2, and */
5774 /* 34+2, which is ideal for standard-sized numbers] */
5775 aset.digits=pp; /* working context */
5776 bset.digits=pp+rhs->digits; /* wider context */
5777 for (;;) { /* iterate */
5778 #if DECCHECK
5779 iterations++;
5780 if (iterations>24) break; /* consider 9 * 2**24 */
5781 #endif
5782 /* calculate the adjustment (exp(-a)*x-1) into b. This is a */
5783 /* catastrophic subtraction but it really is the difference */
5784 /* from 1 that is of interest. */
5785 /* Use the internal entry point to Exp as it allows the double */
5786 /* range for calculating exp(-a) when a is the tiniest subnormal. */
5787 a->bits^=DECNEG; /* make -a */
5788 decExpOp(b, a, &bset, &ignore); /* b=exp(-a) */
5789 a->bits^=DECNEG; /* restore sign of a */
5790 /* now multiply by rhs and subtract 1, at the wider precision */
5791 decMultiplyOp(b, b, rhs, &bset, &ignore); /* b=b*rhs */
5792 decAddOp(b, b, &numone, &bset, DECNEG, &ignore); /* b=b-1 */
5793
5794 /* the iteration ends when the adjustment cannot affect the */
5795 /* result by >=0.5 ulp (at the requested digits), which */
5796 /* is when its value is smaller than the accumulator by */
5797 /* set->digits+1 digits (or it is zero) -- this is a looser */
5798 /* requirement than for Exp because all that happens to the */
5799 /* accumulator after this is the final rounding (but note that */
5800 /* there must also be full precision in a, or a=0). */
5801
5802 if (decNumberIsZero(b) ||
5803 (a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) {
5804 if (a->digits==p) break;
5805 if (decNumberIsZero(a)) {
5806 decCompareOp(&cmp, rhs, &numone, &aset, COMPARE, &ignore); /* rhs=1 ? */
5807 if (cmp.lsu[0]==0) a->exponent=0; /* yes, exact 0 */
5808 else *status|=(DEC_Inexact | DEC_Rounded); /* no, inexact */
5809 break;
5810 }
5811 /* force padding if adjustment has gone to 0 before full length */
5812 if (decNumberIsZero(b)) b->exponent=a->exponent-p;
5813 }
5814
5815 /* not done yet ... */
5816 decAddOp(a, a, b, &aset, 0, &ignore); /* a=a+b for next estimate */
5817 if (pp==p) continue; /* precision is at maximum */
5818 /* lengthen the next calculation */
5819 pp=pp*2; /* double precision */
5820 if (pp>p) pp=p; /* clamp to maximum */
5821 aset.digits=pp; /* working context */
5822 bset.digits=pp+rhs->digits; /* wider context */
5823 } /* Newton's iteration */
5824
5825 #if DECCHECK
5826 /* just a sanity check; remove the test to show always */
5827 if (iterations>24)
5828 printf("Ln iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5829 (LI)iterations, (LI)*status, (LI)p, (LI)rhs->digits);
5830 #endif
5831
5832 /* Copy and round the result to res */
5833 residue=1; /* indicate dirt to right */
5834 if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */
5835 aset.digits=set->digits; /* [use default rounding] */
5836 decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5837 decFinish(res, set, &residue, status); /* cleanup/set flags */
5838 } while(0); /* end protected */
5839
5840 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
5841 if (allocbufb!=NULL) free(allocbufb); /* .. */
5842 /* [status is handled by caller] */
5843 return res;
5844 } /* decLnOp */
5845 #if defined(__clang__) || U_GCC_MAJOR_MINOR >= 406
5846 #pragma GCC diagnostic pop
5847 #endif
5848
5849 /* ------------------------------------------------------------------ */
5850 /* decQuantizeOp -- force exponent to requested value */
5851 /* */
5852 /* This computes C = op(A, B), where op adjusts the coefficient */
5853 /* of C (by rounding or shifting) such that the exponent (-scale) */
5854 /* of C has the value B or matches the exponent of B. */
5855 /* The numerical value of C will equal A, except for the effects of */
5856 /* any rounding that occurred. */
5857 /* */
5858 /* res is C, the result. C may be A or B */
5859 /* lhs is A, the number to adjust */
5860 /* rhs is B, the requested exponent */
5861 /* set is the context */
5862 /* quant is 1 for quantize or 0 for rescale */
5863 /* status is the status accumulator (this can be called without */
5864 /* risk of control loss) */
5865 /* */
5866 /* C must have space for set->digits digits. */
5867 /* */
5868 /* Unless there is an error or the result is infinite, the exponent */
5869 /* after the operation is guaranteed to be that requested. */
5870 /* ------------------------------------------------------------------ */
5871 static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs,
5872 const decNumber *rhs, decContext *set,
5873 Flag quant, uInt *status) {
5874 #if DECSUBSET
5875 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
5876 decNumber *allocrhs=NULL; /* .., rhs */
5877 #endif
5878 const decNumber *inrhs=rhs; /* save original rhs */
5879 Int reqdigits=set->digits; /* requested DIGITS */
5880 Int reqexp; /* requested exponent [-scale] */
5881 Int residue=0; /* rounding residue */
5882 Int etiny=set->emin-(reqdigits-1);
5883
5884 #if DECCHECK
5885 if (decCheckOperands(res, lhs, rhs, set)) return res;
5886 #endif
5887
5888 do { /* protect allocated storage */
5889 #if DECSUBSET
5890 if (!set->extended) {
5891 /* reduce operands and set lostDigits status, as needed */
5892 if (lhs->digits>reqdigits) {
5893 alloclhs=decRoundOperand(lhs, set, status);
5894 if (alloclhs==NULL) break;
5895 lhs=alloclhs;
5896 }
5897 if (rhs->digits>reqdigits) { /* [this only checks lostDigits] */
5898 allocrhs=decRoundOperand(rhs, set, status);
5899 if (allocrhs==NULL) break;
5900 rhs=allocrhs;
5901 }
5902 }
5903 #endif
5904 /* [following code does not require input rounding] */
5905
5906 /* Handle special values */
5907 if (SPECIALARGS) {
5908 /* NaNs get usual processing */
5909 if (SPECIALARGS & (DECSNAN | DECNAN))
5910 decNaNs(res, lhs, rhs, set, status);
5911 /* one infinity but not both is bad */
5912 else if ((lhs->bits ^ rhs->bits) & DECINF)
5913 *status|=DEC_Invalid_operation;
5914 /* both infinity: return lhs */
5915 else uprv_decNumberCopy(res, lhs); /* [nop if in place] */
5916 break;
5917 }
5918
5919 /* set requested exponent */
5920 if (quant) reqexp=inrhs->exponent; /* quantize -- match exponents */
5921 else { /* rescale -- use value of rhs */
5922 /* Original rhs must be an integer that fits and is in range, */
5923 /* which could be from -1999999997 to +999999999, thanks to */
5924 /* subnormals */
5925 reqexp=decGetInt(inrhs); /* [cannot fail] */
5926 }
5927
5928 #if DECSUBSET
5929 if (!set->extended) etiny=set->emin; /* no subnormals */
5930 #endif
5931
5932 if (reqexp==BADINT /* bad (rescale only) or .. */
5933 || reqexp==BIGODD || reqexp==BIGEVEN /* very big (ditto) or .. */
5934 || (reqexp<etiny) /* < lowest */
5935 || (reqexp>set->emax)) { /* > emax */
5936 *status|=DEC_Invalid_operation;
5937 break;}
5938
5939 /* the RHS has been processed, so it can be overwritten now if necessary */
5940 if (ISZERO(lhs)) { /* zero coefficient unchanged */
5941 uprv_decNumberCopy(res, lhs); /* [nop if in place] */
5942 res->exponent=reqexp; /* .. just set exponent */
5943 #if DECSUBSET
5944 if (!set->extended) res->bits=0; /* subset specification; no -0 */
5945 #endif
5946 }
5947 else { /* non-zero lhs */
5948 Int adjust=reqexp-lhs->exponent; /* digit adjustment needed */
5949 /* if adjusted coefficient will definitely not fit, give up now */
5950 if ((lhs->digits-adjust)>reqdigits) {
5951 *status|=DEC_Invalid_operation;
5952 break;
5953 }
5954
5955 if (adjust>0) { /* increasing exponent */
5956 /* this will decrease the length of the coefficient by adjust */
5957 /* digits, and must round as it does so */
5958 decContext workset; /* work */
5959 workset=*set; /* clone rounding, etc. */
5960 workset.digits=lhs->digits-adjust; /* set requested length */
5961 /* [note that the latter can be <1, here] */
5962 decCopyFit(res, lhs, &workset, &residue, status); /* fit to result */
5963 decApplyRound(res, &workset, residue, status); /* .. and round */
5964 residue=0; /* [used] */
5965 /* If just rounded a 999s case, exponent will be off by one; */
5966 /* adjust back (after checking space), if so. */
5967 if (res->exponent>reqexp) {
5968 /* re-check needed, e.g., for quantize(0.9999, 0.001) under */
5969 /* set->digits==3 */
5970 if (res->digits==reqdigits) { /* cannot shift by 1 */
5971 *status&=~(DEC_Inexact | DEC_Rounded); /* [clean these] */
5972 *status|=DEC_Invalid_operation;
5973 break;
5974 }
5975 res->digits=decShiftToMost(res->lsu, res->digits, 1); /* shift */
5976 res->exponent--; /* (re)adjust the exponent. */
5977 }
5978 #if DECSUBSET
5979 if (ISZERO(res) && !set->extended) res->bits=0; /* subset; no -0 */
5980 #endif
5981 } /* increase */
5982 else /* adjust<=0 */ { /* decreasing or = exponent */
5983 /* this will increase the length of the coefficient by -adjust */
5984 /* digits, by adding zero or more trailing zeros; this is */
5985 /* already checked for fit, above */
5986 uprv_decNumberCopy(res, lhs); /* [it will fit] */
5987 /* if padding needed (adjust<0), add it now... */
5988 if (adjust<0) {
5989 res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
5990 res->exponent+=adjust; /* adjust the exponent */
5991 }
5992 } /* decrease */
5993 } /* non-zero */
5994
5995 /* Check for overflow [do not use Finalize in this case, as an */
5996 /* overflow here is a "don't fit" situation] */
5997 if (res->exponent>set->emax-res->digits+1) { /* too big */
5998 *status|=DEC_Invalid_operation;
5999 break;
6000 }
6001 else {
6002 decFinalize(res, set, &residue, status); /* set subnormal flags */
6003 *status&=~DEC_Underflow; /* suppress Underflow [as per 754] */
6004 }
6005 } while(0); /* end protected */
6006
6007 #if DECSUBSET
6008 if (allocrhs!=NULL) free(allocrhs); /* drop any storage used */
6009 if (alloclhs!=NULL) free(alloclhs); /* .. */
6010 #endif
6011 return res;
6012 } /* decQuantizeOp */
6013
6014 /* ------------------------------------------------------------------ */
6015 /* decCompareOp -- compare, min, or max two Numbers */
6016 /* */
6017 /* This computes C = A ? B and carries out one of four operations: */
6018 /* COMPARE -- returns the signum (as a number) giving the */
6019 /* result of a comparison unless one or both */
6020 /* operands is a NaN (in which case a NaN results) */
6021 /* COMPSIG -- as COMPARE except that a quiet NaN raises */
6022 /* Invalid operation. */
6023 /* COMPMAX -- returns the larger of the operands, using the */
6024 /* 754 maxnum operation */
6025 /* COMPMAXMAG -- ditto, comparing absolute values */
6026 /* COMPMIN -- the 754 minnum operation */
6027 /* COMPMINMAG -- ditto, comparing absolute values */
6028 /* COMTOTAL -- returns the signum (as a number) giving the */
6029 /* result of a comparison using 754 total ordering */
6030 /* */
6031 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */
6032 /* lhs is A */
6033 /* rhs is B */
6034 /* set is the context */
6035 /* op is the operation flag */
6036 /* status is the usual accumulator */
6037 /* */
6038 /* C must have space for one digit for COMPARE or set->digits for */
6039 /* COMPMAX, COMPMIN, COMPMAXMAG, or COMPMINMAG. */
6040 /* ------------------------------------------------------------------ */
6041 /* The emphasis here is on speed for common cases, and avoiding */
6042 /* coefficient comparison if possible. */
6043 /* ------------------------------------------------------------------ */
6044 static decNumber * decCompareOp(decNumber *res, const decNumber *lhs,
6045 const decNumber *rhs, decContext *set,
6046 Flag op, uInt *status) {
6047 #if DECSUBSET
6048 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
6049 decNumber *allocrhs=NULL; /* .., rhs */
6050 #endif
6051 Int result=0; /* default result value */
6052 uByte merged; /* work */
6053
6054 #if DECCHECK
6055 if (decCheckOperands(res, lhs, rhs, set)) return res;
6056 #endif
6057
6058 do { /* protect allocated storage */
6059 #if DECSUBSET
6060 if (!set->extended) {
6061 /* reduce operands and set lostDigits status, as needed */
6062 if (lhs->digits>set->digits) {
6063 alloclhs=decRoundOperand(lhs, set, status);
6064 if (alloclhs==NULL) {result=BADINT; break;}
6065 lhs=alloclhs;
6066 }
6067 if (rhs->digits>set->digits) {
6068 allocrhs=decRoundOperand(rhs, set, status);
6069 if (allocrhs==NULL) {result=BADINT; break;}
6070 rhs=allocrhs;
6071 }
6072 }
6073 #endif
6074 /* [following code does not require input rounding] */
6075
6076 /* If total ordering then handle differing signs 'up front' */
6077 if (op==COMPTOTAL) { /* total ordering */
6078 if (decNumberIsNegative(lhs) && !decNumberIsNegative(rhs)) {
6079 result=-1;
6080 break;
6081 }
6082 if (!decNumberIsNegative(lhs) && decNumberIsNegative(rhs)) {
6083 result=+1;
6084 break;
6085 }
6086 }
6087
6088 /* handle NaNs specially; let infinities drop through */
6089 /* This assumes sNaN (even just one) leads to NaN. */
6090 merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN);
6091 if (merged) { /* a NaN bit set */
6092 if (op==COMPARE); /* result will be NaN */
6093 else if (op==COMPSIG) /* treat qNaN as sNaN */
6094 *status|=DEC_Invalid_operation | DEC_sNaN;
6095 else if (op==COMPTOTAL) { /* total ordering, always finite */
6096 /* signs are known to be the same; compute the ordering here */
6097 /* as if the signs are both positive, then invert for negatives */
6098 if (!decNumberIsNaN(lhs)) result=-1;
6099 else if (!decNumberIsNaN(rhs)) result=+1;
6100 /* here if both NaNs */
6101 else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1;
6102 else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1;
6103 else { /* both NaN or both sNaN */
6104 /* now it just depends on the payload */
6105 result=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6106 rhs->lsu, D2U(rhs->digits), 0);
6107 /* [Error not possible, as these are 'aligned'] */
6108 } /* both same NaNs */
6109 if (decNumberIsNegative(lhs)) result=-result;
6110 break;
6111 } /* total order */
6112
6113 else if (merged & DECSNAN); /* sNaN -> qNaN */
6114 else { /* here if MIN or MAX and one or two quiet NaNs */
6115 /* min or max -- 754 rules ignore single NaN */
6116 if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) {
6117 /* just one NaN; force choice to be the non-NaN operand */
6118 op=COMPMAX;
6119 if (lhs->bits & DECNAN) result=-1; /* pick rhs */
6120 else result=+1; /* pick lhs */
6121 break;
6122 }
6123 } /* max or min */
6124 op=COMPNAN; /* use special path */
6125 decNaNs(res, lhs, rhs, set, status); /* propagate NaN */
6126 break;
6127 }
6128 /* have numbers */
6129 if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1);
6130 else result=decCompare(lhs, rhs, 0); /* sign matters */
6131 } while(0); /* end protected */
6132
6133 if (result==BADINT) *status|=DEC_Insufficient_storage; /* rare */
6134 else {
6135 if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { /* returning signum */
6136 if (op==COMPTOTAL && result==0) {
6137 /* operands are numerically equal or same NaN (and same sign, */
6138 /* tested first); if identical, leave result 0 */
6139 if (lhs->exponent!=rhs->exponent) {
6140 if (lhs->exponent<rhs->exponent) result=-1;
6141 else result=+1;
6142 if (decNumberIsNegative(lhs)) result=-result;
6143 } /* lexp!=rexp */
6144 } /* total-order by exponent */
6145 uprv_decNumberZero(res); /* [always a valid result] */
6146 if (result!=0) { /* must be -1 or +1 */
6147 *res->lsu=1;
6148 if (result<0) res->bits=DECNEG;
6149 }
6150 }
6151 else if (op==COMPNAN); /* special, drop through */
6152 else { /* MAX or MIN, non-NaN result */
6153 Int residue=0; /* rounding accumulator */
6154 /* choose the operand for the result */
6155 const decNumber *choice;
6156 if (result==0) { /* operands are numerically equal */
6157 /* choose according to sign then exponent (see 754) */
6158 uByte slhs=(lhs->bits & DECNEG);
6159 uByte srhs=(rhs->bits & DECNEG);
6160 #if DECSUBSET
6161 if (!set->extended) { /* subset: force left-hand */
6162 op=COMPMAX;
6163 result=+1;
6164 }
6165 else
6166 #endif
6167 if (slhs!=srhs) { /* signs differ */
6168 if (slhs) result=-1; /* rhs is max */
6169 else result=+1; /* lhs is max */
6170 }
6171 else if (slhs && srhs) { /* both negative */
6172 if (lhs->exponent<rhs->exponent) result=+1;
6173 else result=-1;
6174 /* [if equal, use lhs, technically identical] */
6175 }
6176 else { /* both positive */
6177 if (lhs->exponent>rhs->exponent) result=+1;
6178 else result=-1;
6179 /* [ditto] */
6180 }
6181 } /* numerically equal */
6182 /* here result will be non-0; reverse if looking for MIN */
6183 if (op==COMPMIN || op==COMPMINMAG) result=-result;
6184 choice=(result>0 ? lhs : rhs); /* choose */
6185 /* copy chosen to result, rounding if need be */
6186 decCopyFit(res, choice, set, &residue, status);
6187 decFinish(res, set, &residue, status);
6188 }
6189 }
6190 #if DECSUBSET
6191 if (allocrhs!=NULL) free(allocrhs); /* free any storage used */
6192 if (alloclhs!=NULL) free(alloclhs); /* .. */
6193 #endif
6194 return res;
6195 } /* decCompareOp */
6196
6197 /* ------------------------------------------------------------------ */
6198 /* decCompare -- compare two decNumbers by numerical value */
6199 /* */
6200 /* This routine compares A ? B without altering them. */
6201 /* */
6202 /* Arg1 is A, a decNumber which is not a NaN */
6203 /* Arg2 is B, a decNumber which is not a NaN */
6204 /* Arg3 is 1 for a sign-independent compare, 0 otherwise */
6205 /* */
6206 /* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */
6207 /* (the only possible failure is an allocation error) */
6208 /* ------------------------------------------------------------------ */
6209 static Int decCompare(const decNumber *lhs, const decNumber *rhs,
6210 Flag abs_c) {
6211 Int result; /* result value */
6212 Int sigr; /* rhs signum */
6213 Int compare; /* work */
6214
6215 result=1; /* assume signum(lhs) */
6216 if (ISZERO(lhs)) result=0;
6217 if (abs_c) {
6218 if (ISZERO(rhs)) return result; /* LHS wins or both 0 */
6219 /* RHS is non-zero */
6220 if (result==0) return -1; /* LHS is 0; RHS wins */
6221 /* [here, both non-zero, result=1] */
6222 }
6223 else { /* signs matter */
6224 if (result && decNumberIsNegative(lhs)) result=-1;
6225 sigr=1; /* compute signum(rhs) */
6226 if (ISZERO(rhs)) sigr=0;
6227 else if (decNumberIsNegative(rhs)) sigr=-1;
6228 if (result > sigr) return +1; /* L > R, return 1 */
6229 if (result < sigr) return -1; /* L < R, return -1 */
6230 if (result==0) return 0; /* both 0 */
6231 }
6232
6233 /* signums are the same; both are non-zero */
6234 if ((lhs->bits | rhs->bits) & DECINF) { /* one or more infinities */
6235 if (decNumberIsInfinite(rhs)) {
6236 if (decNumberIsInfinite(lhs)) result=0;/* both infinite */
6237 else result=-result; /* only rhs infinite */
6238 }
6239 return result;
6240 }
6241 /* must compare the coefficients, allowing for exponents */
6242 if (lhs->exponent>rhs->exponent) { /* LHS exponent larger */
6243 /* swap sides, and sign */
6244 const decNumber *temp=lhs;
6245 lhs=rhs;
6246 rhs=temp;
6247 result=-result;
6248 }
6249 compare=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6250 rhs->lsu, D2U(rhs->digits),
6251 rhs->exponent-lhs->exponent);
6252 if (compare!=BADINT) compare*=result; /* comparison succeeded */
6253 return compare;
6254 } /* decCompare */
6255
6256 /* ------------------------------------------------------------------ */
6257 /* decUnitCompare -- compare two >=0 integers in Unit arrays */
6258 /* */
6259 /* This routine compares A ? B*10**E where A and B are unit arrays */
6260 /* A is a plain integer */
6261 /* B has an exponent of E (which must be non-negative) */
6262 /* */
6263 /* Arg1 is A first Unit (lsu) */
6264 /* Arg2 is A length in Units */
6265 /* Arg3 is B first Unit (lsu) */
6266 /* Arg4 is B length in Units */
6267 /* Arg5 is E (0 if the units are aligned) */
6268 /* */
6269 /* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */
6270 /* (the only possible failure is an allocation error, which can */
6271 /* only occur if E!=0) */
6272 /* ------------------------------------------------------------------ */
6273 static Int decUnitCompare(const Unit *a, Int alength,
6274 const Unit *b, Int blength, Int exp) {
6275 Unit *acc; /* accumulator for result */
6276 Unit accbuff[SD2U(DECBUFFER*2+1)]; /* local buffer */
6277 Unit *allocacc=NULL; /* -> allocated acc buffer, iff allocated */
6278 Int accunits, need; /* units in use or needed for acc */
6279 const Unit *l, *r, *u; /* work */
6280 Int expunits, exprem, result; /* .. */
6281
6282 if (exp==0) { /* aligned; fastpath */
6283 if (alength>blength) return 1;
6284 if (alength<blength) return -1;
6285 /* same number of units in both -- need unit-by-unit compare */
6286 l=a+alength-1;
6287 r=b+alength-1;
6288 for (;l>=a; l--, r--) {
6289 if (*l>*r) return 1;
6290 if (*l<*r) return -1;
6291 }
6292 return 0; /* all units match */
6293 } /* aligned */
6294
6295 /* Unaligned. If one is >1 unit longer than the other, padded */
6296 /* approximately, then can return easily */
6297 if (alength>blength+(Int)D2U(exp)) return 1;
6298 if (alength+1<blength+(Int)D2U(exp)) return -1;
6299
6300 /* Need to do a real subtract. For this, a result buffer is needed */
6301 /* even though only the sign is of interest. Its length needs */
6302 /* to be the larger of alength and padded blength, +2 */
6303 need=blength+D2U(exp); /* maximum real length of B */
6304 if (need<alength) need=alength;
6305 need+=2;
6306 acc=accbuff; /* assume use local buffer */
6307 if (need*sizeof(Unit)>sizeof(accbuff)) {
6308 allocacc=(Unit *)malloc(need*sizeof(Unit));
6309 if (allocacc==NULL) return BADINT; /* hopeless -- abandon */
6310 acc=allocacc;
6311 }
6312 /* Calculate units and remainder from exponent. */
6313 expunits=exp/DECDPUN;
6314 exprem=exp%DECDPUN;
6315 /* subtract [A+B*(-m)] */
6316 accunits=decUnitAddSub(a, alength, b, blength, expunits, acc,
6317 -(Int)powers[exprem]);
6318 /* [UnitAddSub result may have leading zeros, even on zero] */
6319 if (accunits<0) result=-1; /* negative result */
6320 else { /* non-negative result */
6321 /* check units of the result before freeing any storage */
6322 for (u=acc; u<acc+accunits-1 && *u==0;) u++;
6323 result=(*u==0 ? 0 : +1);
6324 }
6325 /* clean up and return the result */
6326 if (allocacc!=NULL) free(allocacc); /* drop any storage used */
6327 return result;
6328 } /* decUnitCompare */
6329
6330 /* ------------------------------------------------------------------ */
6331 /* decUnitAddSub -- add or subtract two >=0 integers in Unit arrays */
6332 /* */
6333 /* This routine performs the calculation: */
6334 /* */
6335 /* C=A+(B*M) */
6336 /* */
6337 /* Where M is in the range -DECDPUNMAX through +DECDPUNMAX. */
6338 /* */
6339 /* A may be shorter or longer than B. */
6340 /* */
6341 /* Leading zeros are not removed after a calculation. The result is */
6342 /* either the same length as the longer of A and B (adding any */
6343 /* shift), or one Unit longer than that (if a Unit carry occurred). */
6344 /* */
6345 /* A and B content are not altered unless C is also A or B. */
6346 /* C may be the same array as A or B, but only if no zero padding is */
6347 /* requested (that is, C may be B only if bshift==0). */
6348 /* C is filled from the lsu; only those units necessary to complete */
6349 /* the calculation are referenced. */
6350 /* */
6351 /* Arg1 is A first Unit (lsu) */
6352 /* Arg2 is A length in Units */
6353 /* Arg3 is B first Unit (lsu) */
6354 /* Arg4 is B length in Units */
6355 /* Arg5 is B shift in Units (>=0; pads with 0 units if positive) */
6356 /* Arg6 is C first Unit (lsu) */
6357 /* Arg7 is M, the multiplier */
6358 /* */
6359 /* returns the count of Units written to C, which will be non-zero */
6360 /* and negated if the result is negative. That is, the sign of the */
6361 /* returned Int is the sign of the result (positive for zero) and */
6362 /* the absolute value of the Int is the count of Units. */
6363 /* */
6364 /* It is the caller's responsibility to make sure that C size is */
6365 /* safe, allowing space if necessary for a one-Unit carry. */
6366 /* */
6367 /* This routine is severely performance-critical; *any* change here */
6368 /* must be measured (timed) to assure no performance degradation. */
6369 /* In particular, trickery here tends to be counter-productive, as */
6370 /* increased complexity of code hurts register optimizations on */
6371 /* register-poor architectures. Avoiding divisions is nearly */
6372 /* always a Good Idea, however. */
6373 /* */
6374 /* Special thanks to Rick McGuire (IBM Cambridge, MA) and Dave Clark */
6375 /* (IBM Warwick, UK) for some of the ideas used in this routine. */
6376 /* ------------------------------------------------------------------ */
6377 static Int decUnitAddSub(const Unit *a, Int alength,
6378 const Unit *b, Int blength, Int bshift,
6379 Unit *c, Int m) {
6380 const Unit *alsu=a; /* A lsu [need to remember it] */
6381 Unit *clsu=c; /* C ditto */
6382 Unit *minC; /* low water mark for C */
6383 Unit *maxC; /* high water mark for C */
6384 eInt carry=0; /* carry integer (could be Long) */
6385 Int add; /* work */
6386 #if DECDPUN<=4 /* myriadal, millenary, etc. */
6387 Int est; /* estimated quotient */
6388 #endif
6389
6390 #if DECTRACE
6391 if (alength<1 || blength<1)
6392 printf("decUnitAddSub: alen blen m %ld %ld [%ld]\n", alength, blength, m);
6393 #endif
6394
6395 maxC=c+alength; /* A is usually the longer */
6396 minC=c+blength; /* .. and B the shorter */
6397 if (bshift!=0) { /* B is shifted; low As copy across */
6398 minC+=bshift;
6399 /* if in place [common], skip copy unless there's a gap [rare] */
6400 if (a==c && bshift<=alength) {
6401 c+=bshift;
6402 a+=bshift;
6403 }
6404 else for (; c<clsu+bshift; a++, c++) { /* copy needed */
6405 if (a<alsu+alength) *c=*a;
6406 else *c=0;
6407 }
6408 }
6409 if (minC>maxC) { /* swap */
6410 Unit *hold=minC;
6411 minC=maxC;
6412 maxC=hold;
6413 }
6414
6415 /* For speed, do the addition as two loops; the first where both A */
6416 /* and B contribute, and the second (if necessary) where only one or */
6417 /* other of the numbers contribute. */
6418 /* Carry handling is the same (i.e., duplicated) in each case. */
6419 for (; c<minC; c++) {
6420 carry+=*a;
6421 a++;
6422 carry+=((eInt)*b)*m; /* [special-casing m=1/-1 */
6423 b++; /* here is not a win] */
6424 /* here carry is new Unit of digits; it could be +ve or -ve */
6425 if ((ueInt)carry<=DECDPUNMAX) { /* fastpath 0-DECDPUNMAX */
6426 *c=(Unit)carry;
6427 carry=0;
6428 continue;
6429 }
6430 #if DECDPUN==4 /* use divide-by-multiply */
6431 if (carry>=0) {
6432 est=(((ueInt)carry>>11)*53687)>>18;
6433 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6434 carry=est; /* likely quotient [89%] */
6435 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */
6436 carry++;
6437 *c-=DECDPUNMAX+1;
6438 continue;
6439 }
6440 /* negative case */
6441 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6442 est=(((ueInt)carry>>11)*53687)>>18;
6443 *c=(Unit)(carry-est*(DECDPUNMAX+1));
6444 carry=est-(DECDPUNMAX+1); /* correctly negative */
6445 if (*c<DECDPUNMAX+1) continue; /* was OK */
6446 carry++;
6447 *c-=DECDPUNMAX+1;
6448 #elif DECDPUN==3
6449 if (carry>=0) {
6450 est=(((ueInt)carry>>3)*16777)>>21;
6451 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6452 carry=est; /* likely quotient [99%] */
6453 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */
6454 carry++;
6455 *c-=DECDPUNMAX+1;
6456 continue;
6457 }
6458 /* negative case */
6459 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6460 est=(((ueInt)carry>>3)*16777)>>21;
6461 *c=(Unit)(carry-est*(DECDPUNMAX+1));
6462 carry=est-(DECDPUNMAX+1); /* correctly negative */
6463 if (*c<DECDPUNMAX+1) continue; /* was OK */
6464 carry++;
6465 *c-=DECDPUNMAX+1;
6466 #elif DECDPUN<=2
6467 /* Can use QUOT10 as carry <= 4 digits */
6468 if (carry>=0) {
6469 est=QUOT10(carry, DECDPUN);
6470 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6471 carry=est; /* quotient */
6472 continue;
6473 }
6474 /* negative case */
6475 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6476 est=QUOT10(carry, DECDPUN);
6477 *c=(Unit)(carry-est*(DECDPUNMAX+1));
6478 carry=est-(DECDPUNMAX+1); /* correctly negative */
6479 #else
6480 /* remainder operator is undefined if negative, so must test */
6481 if ((ueInt)carry<(DECDPUNMAX+1)*2) { /* fastpath carry +1 */
6482 *c=(Unit)(carry-(DECDPUNMAX+1)); /* [helps additions] */
6483 carry=1;
6484 continue;
6485 }
6486 if (carry>=0) {
6487 *c=(Unit)(carry%(DECDPUNMAX+1));
6488 carry=carry/(DECDPUNMAX+1);
6489 continue;
6490 }
6491 /* negative case */
6492 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6493 *c=(Unit)(carry%(DECDPUNMAX+1));
6494 carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6495 #endif
6496 } /* c */
6497
6498 /* now may have one or other to complete */
6499 /* [pretest to avoid loop setup/shutdown] */
6500 if (c<maxC) for (; c<maxC; c++) {
6501 if (a<alsu+alength) { /* still in A */
6502 carry+=*a;
6503 a++;
6504 }
6505 else { /* inside B */
6506 carry+=((eInt)*b)*m;
6507 b++;
6508 }
6509 /* here carry is new Unit of digits; it could be +ve or -ve and */
6510 /* magnitude up to DECDPUNMAX squared */
6511 if ((ueInt)carry<=DECDPUNMAX) { /* fastpath 0-DECDPUNMAX */
6512 *c=(Unit)carry;
6513 carry=0;
6514 continue;
6515 }
6516 /* result for this unit is negative or >DECDPUNMAX */
6517 #if DECDPUN==4 /* use divide-by-multiply */
6518 if (carry>=0) {
6519 est=(((ueInt)carry>>11)*53687)>>18;
6520 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6521 carry=est; /* likely quotient [79.7%] */
6522 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */
6523 carry++;
6524 *c-=DECDPUNMAX+1;
6525 continue;
6526 }
6527 /* negative case */
6528 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6529 est=(((ueInt)carry>>11)*53687)>>18;
6530 *c=(Unit)(carry-est*(DECDPUNMAX+1));
6531 carry=est-(DECDPUNMAX+1); /* correctly negative */
6532 if (*c<DECDPUNMAX+1) continue; /* was OK */
6533 carry++;
6534 *c-=DECDPUNMAX+1;
6535 #elif DECDPUN==3
6536 if (carry>=0) {
6537 est=(((ueInt)carry>>3)*16777)>>21;
6538 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6539 carry=est; /* likely quotient [99%] */
6540 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */
6541 carry++;
6542 *c-=DECDPUNMAX+1;
6543 continue;
6544 }
6545 /* negative case */
6546 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6547 est=(((ueInt)carry>>3)*16777)>>21;
6548 *c=(Unit)(carry-est*(DECDPUNMAX+1));
6549 carry=est-(DECDPUNMAX+1); /* correctly negative */
6550 if (*c<DECDPUNMAX+1) continue; /* was OK */
6551 carry++;
6552 *c-=DECDPUNMAX+1;
6553 #elif DECDPUN<=2
6554 if (carry>=0) {
6555 est=QUOT10(carry, DECDPUN);
6556 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6557 carry=est; /* quotient */
6558 continue;
6559 }
6560 /* negative case */
6561 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6562 est=QUOT10(carry, DECDPUN);
6563 *c=(Unit)(carry-est*(DECDPUNMAX+1));
6564 carry=est-(DECDPUNMAX+1); /* correctly negative */
6565 #else
6566 if ((ueInt)carry<(DECDPUNMAX+1)*2){ /* fastpath carry 1 */
6567 *c=(Unit)(carry-(DECDPUNMAX+1));
6568 carry=1;
6569 continue;
6570 }
6571 /* remainder operator is undefined if negative, so must test */
6572 if (carry>=0) {
6573 *c=(Unit)(carry%(DECDPUNMAX+1));
6574 carry=carry/(DECDPUNMAX+1);
6575 continue;
6576 }
6577 /* negative case */
6578 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6579 *c=(Unit)(carry%(DECDPUNMAX+1));
6580 carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6581 #endif
6582 } /* c */
6583
6584 /* OK, all A and B processed; might still have carry or borrow */
6585 /* return number of Units in the result, negated if a borrow */
6586 if (carry==0) return c-clsu; /* no carry, so no more to do */
6587 if (carry>0) { /* positive carry */
6588 *c=(Unit)carry; /* place as new unit */
6589 c++; /* .. */
6590 return c-clsu;
6591 }
6592 /* -ve carry: it's a borrow; complement needed */
6593 add=1; /* temporary carry... */
6594 for (c=clsu; c<maxC; c++) {
6595 add=DECDPUNMAX+add-*c;
6596 if (add<=DECDPUNMAX) {
6597 *c=(Unit)add;
6598 add=0;
6599 }
6600 else {
6601 *c=0;
6602 add=1;
6603 }
6604 }
6605 /* add an extra unit iff it would be non-zero */
6606 #if DECTRACE
6607 printf("UAS borrow: add %ld, carry %ld\n", add, carry);
6608 #endif
6609 if ((add-carry-1)!=0) {
6610 *c=(Unit)(add-carry-1);
6611 c++; /* interesting, include it */
6612 }
6613 return clsu-c; /* -ve result indicates borrowed */
6614 } /* decUnitAddSub */
6615
6616 /* ------------------------------------------------------------------ */
6617 /* decTrim -- trim trailing zeros or normalize */
6618 /* */
6619 /* dn is the number to trim or normalize */
6620 /* set is the context to use to check for clamp */
6621 /* all is 1 to remove all trailing zeros, 0 for just fraction ones */
6622 /* noclamp is 1 to unconditional (unclamped) trim */
6623 /* dropped returns the number of discarded trailing zeros */
6624 /* returns dn */
6625 /* */
6626 /* If clamp is set in the context then the number of zeros trimmed */
6627 /* may be limited if the exponent is high. */
6628 /* All fields are updated as required. This is a utility operation, */
6629 /* so special values are unchanged and no error is possible. */
6630 /* ------------------------------------------------------------------ */
6631 static decNumber * decTrim(decNumber *dn, decContext *set, Flag all,
6632 Flag noclamp, Int *dropped) {
6633 Int d, exp; /* work */
6634 uInt cut; /* .. */
6635 Unit *up; /* -> current Unit */
6636
6637 #if DECCHECK
6638 if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
6639 #endif
6640
6641 *dropped=0; /* assume no zeros dropped */
6642 if ((dn->bits & DECSPECIAL) /* fast exit if special .. */
6643 || (*dn->lsu & 0x01)) return dn; /* .. or odd */
6644 if (ISZERO(dn)) { /* .. or 0 */
6645 dn->exponent=0; /* (sign is preserved) */
6646 return dn;
6647 }
6648
6649 /* have a finite number which is even */
6650 exp=dn->exponent;
6651 cut=1; /* digit (1-DECDPUN) in Unit */
6652 up=dn->lsu; /* -> current Unit */
6653 for (d=0; d<dn->digits-1; d++) { /* [don't strip the final digit] */
6654 /* slice by powers */
6655 #if DECDPUN<=4
6656 uInt quot=QUOT10(*up, cut);
6657 if ((*up-quot*powers[cut])!=0) break; /* found non-0 digit */
6658 #else
6659 if (*up%powers[cut]!=0) break; /* found non-0 digit */
6660 #endif
6661 /* have a trailing 0 */
6662 if (!all) { /* trimming */
6663 /* [if exp>0 then all trailing 0s are significant for trim] */
6664 if (exp<=0) { /* if digit might be significant */
6665 if (exp==0) break; /* then quit */
6666 exp++; /* next digit might be significant */
6667 }
6668 }
6669 cut++; /* next power */
6670 if (cut>DECDPUN) { /* need new Unit */
6671 up++;
6672 cut=1;
6673 }
6674 } /* d */
6675 if (d==0) return dn; /* none to drop */
6676
6677 /* may need to limit drop if clamping */
6678 if (set->clamp && !noclamp) {
6679 Int maxd=set->emax-set->digits+1-dn->exponent;
6680 if (maxd<=0) return dn; /* nothing possible */
6681 if (d>maxd) d=maxd;
6682 }
6683
6684 /* effect the drop */
6685 decShiftToLeast(dn->lsu, D2U(dn->digits), d);
6686 dn->exponent+=d; /* maintain numerical value */
6687 dn->digits-=d; /* new length */
6688 *dropped=d; /* report the count */
6689 return dn;
6690 } /* decTrim */
6691
6692 /* ------------------------------------------------------------------ */
6693 /* decReverse -- reverse a Unit array in place */
6694 /* */
6695 /* ulo is the start of the array */
6696 /* uhi is the end of the array (highest Unit to include) */
6697 /* */
6698 /* The units ulo through uhi are reversed in place (if the number */
6699 /* of units is odd, the middle one is untouched). Note that the */
6700 /* digit(s) in each unit are unaffected. */
6701 /* ------------------------------------------------------------------ */
6702 static void decReverse(Unit *ulo, Unit *uhi) {
6703 Unit temp;
6704 for (; ulo<uhi; ulo++, uhi--) {
6705 temp=*ulo;
6706 *ulo=*uhi;
6707 *uhi=temp;
6708 }
6709 return;
6710 } /* decReverse */
6711
6712 /* ------------------------------------------------------------------ */
6713 /* decShiftToMost -- shift digits in array towards most significant */
6714 /* */
6715 /* uar is the array */
6716 /* digits is the count of digits in use in the array */
6717 /* shift is the number of zeros to pad with (least significant); */
6718 /* it must be zero or positive */
6719 /* */
6720 /* returns the new length of the integer in the array, in digits */
6721 /* */
6722 /* No overflow is permitted (that is, the uar array must be known to */
6723 /* be large enough to hold the result, after shifting). */
6724 /* ------------------------------------------------------------------ */
6725 static Int decShiftToMost(Unit *uar, Int digits, Int shift) {
6726 Unit *target, *source, *first; /* work */
6727 Int cut; /* odd 0's to add */
6728 uInt next; /* work */
6729
6730 if (shift==0) return digits; /* [fastpath] nothing to do */
6731 if ((digits+shift)<=DECDPUN) { /* [fastpath] single-unit case */
6732 *uar=(Unit)(*uar*powers[shift]);
6733 return digits+shift;
6734 }
6735
6736 next=0; /* all paths */
6737 source=uar+D2U(digits)-1; /* where msu comes from */
6738 target=source+D2U(shift); /* where upper part of first cut goes */
6739 cut=DECDPUN-MSUDIGITS(shift); /* where to slice */
6740 if (cut==0) { /* unit-boundary case */
6741 for (; source>=uar; source--, target--) *target=*source;
6742 }
6743 else {
6744 first=uar+D2U(digits+shift)-1; /* where msu of source will end up */
6745 for (; source>=uar; source--, target--) {
6746 /* split the source Unit and accumulate remainder for next */
6747 #if DECDPUN<=4
6748 uInt quot=QUOT10(*source, cut);
6749 uInt rem=*source-quot*powers[cut];
6750 next+=quot;
6751 #else
6752 uInt rem=*source%powers[cut];
6753 next+=*source/powers[cut];
6754 #endif
6755 if (target<=first) *target=(Unit)next; /* write to target iff valid */
6756 next=rem*powers[DECDPUN-cut]; /* save remainder for next Unit */
6757 }
6758 } /* shift-move */
6759
6760 /* propagate any partial unit to one below and clear the rest */
6761 for (; target>=uar; target--) {
6762 *target=(Unit)next;
6763 next=0;
6764 }
6765 return digits+shift;
6766 } /* decShiftToMost */
6767
6768 /* ------------------------------------------------------------------ */
6769 /* decShiftToLeast -- shift digits in array towards least significant */
6770 /* */
6771 /* uar is the array */
6772 /* units is length of the array, in units */
6773 /* shift is the number of digits to remove from the lsu end; it */
6774 /* must be zero or positive and <= than units*DECDPUN. */
6775 /* */
6776 /* returns the new length of the integer in the array, in units */
6777 /* */
6778 /* Removed digits are discarded (lost). Units not required to hold */
6779 /* the final result are unchanged. */
6780 /* ------------------------------------------------------------------ */
6781 static Int decShiftToLeast(Unit *uar, Int units, Int shift) {
6782 Unit *target, *up; /* work */
6783 Int cut, count; /* work */
6784 Int quot, rem; /* for division */
6785
6786 if (shift==0) return units; /* [fastpath] nothing to do */
6787 if (shift==units*DECDPUN) { /* [fastpath] little to do */
6788 *uar=0; /* all digits cleared gives zero */
6789 return 1; /* leaves just the one */
6790 }
6791
6792 target=uar; /* both paths */
6793 cut=MSUDIGITS(shift);
6794 if (cut==DECDPUN) { /* unit-boundary case; easy */
6795 up=uar+D2U(shift);
6796 for (; up<uar+units; target++, up++) *target=*up;
6797 return target-uar;
6798 }
6799
6800 /* messier */
6801 up=uar+D2U(shift-cut); /* source; correct to whole Units */
6802 count=units*DECDPUN-shift; /* the maximum new length */
6803 #if DECDPUN<=4
6804 quot=QUOT10(*up, cut);
6805 #else
6806 quot=*up/powers[cut];
6807 #endif
6808 for (; ; target++) {
6809 *target=(Unit)quot;
6810 count-=(DECDPUN-cut);
6811 if (count<=0) break;
6812 up++;
6813 quot=*up;
6814 #if DECDPUN<=4
6815 quot=QUOT10(quot, cut);
6816 rem=*up-quot*powers[cut];
6817 #else
6818 rem=quot%powers[cut];
6819 quot=quot/powers[cut];
6820 #endif
6821 *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
6822 count-=cut;
6823 if (count<=0) break;
6824 }
6825 return target-uar+1;
6826 } /* decShiftToLeast */
6827
6828 #if DECSUBSET
6829 /* ------------------------------------------------------------------ */
6830 /* decRoundOperand -- round an operand [used for subset only] */
6831 /* */
6832 /* dn is the number to round (dn->digits is > set->digits) */
6833 /* set is the relevant context */
6834 /* status is the status accumulator */
6835 /* */
6836 /* returns an allocated decNumber with the rounded result. */
6837 /* */
6838 /* lostDigits and other status may be set by this. */
6839 /* */
6840 /* Since the input is an operand, it must not be modified. */
6841 /* Instead, return an allocated decNumber, rounded as required. */
6842 /* It is the caller's responsibility to free the allocated storage. */
6843 /* */
6844 /* If no storage is available then the result cannot be used, so NULL */
6845 /* is returned. */
6846 /* ------------------------------------------------------------------ */
6847 static decNumber *decRoundOperand(const decNumber *dn, decContext *set,
6848 uInt *status) {
6849 decNumber *res; /* result structure */
6850 uInt newstatus=0; /* status from round */
6851 Int residue=0; /* rounding accumulator */
6852
6853 /* Allocate storage for the returned decNumber, big enough for the */
6854 /* length specified by the context */
6855 res=(decNumber *)malloc(sizeof(decNumber)
6856 +(D2U(set->digits)-1)*sizeof(Unit));
6857 if (res==NULL) {
6858 *status|=DEC_Insufficient_storage;
6859 return NULL;
6860 }
6861 decCopyFit(res, dn, set, &residue, &newstatus);
6862 decApplyRound(res, set, residue, &newstatus);
6863
6864 /* If that set Inexact then "lost digits" is raised... */
6865 if (newstatus & DEC_Inexact) newstatus|=DEC_Lost_digits;
6866 *status|=newstatus;
6867 return res;
6868 } /* decRoundOperand */
6869 #endif
6870
6871 /* ------------------------------------------------------------------ */
6872 /* decCopyFit -- copy a number, truncating the coefficient if needed */
6873 /* */
6874 /* dest is the target decNumber */
6875 /* src is the source decNumber */
6876 /* set is the context [used for length (digits) and rounding mode] */
6877 /* residue is the residue accumulator */
6878 /* status contains the current status to be updated */
6879 /* */
6880 /* (dest==src is allowed and will be a no-op if fits) */
6881 /* All fields are updated as required. */
6882 /* ------------------------------------------------------------------ */
6883 static void decCopyFit(decNumber *dest, const decNumber *src,
6884 decContext *set, Int *residue, uInt *status) {
6885 dest->bits=src->bits;
6886 dest->exponent=src->exponent;
6887 decSetCoeff(dest, set, src->lsu, src->digits, residue, status);
6888 } /* decCopyFit */
6889
6890 /* ------------------------------------------------------------------ */
6891 /* decSetCoeff -- set the coefficient of a number */
6892 /* */
6893 /* dn is the number whose coefficient array is to be set. */
6894 /* It must have space for set->digits digits */
6895 /* set is the context [for size] */
6896 /* lsu -> lsu of the source coefficient [may be dn->lsu] */
6897 /* len is digits in the source coefficient [may be dn->digits] */
6898 /* residue is the residue accumulator. This has values as in */
6899 /* decApplyRound, and will be unchanged unless the */
6900 /* target size is less than len. In this case, the */
6901 /* coefficient is truncated and the residue is updated to */
6902 /* reflect the previous residue and the dropped digits. */
6903 /* status is the status accumulator, as usual */
6904 /* */
6905 /* The coefficient may already be in the number, or it can be an */
6906 /* external intermediate array. If it is in the number, lsu must == */
6907 /* dn->lsu and len must == dn->digits. */
6908 /* */
6909 /* Note that the coefficient length (len) may be < set->digits, and */
6910 /* in this case this merely copies the coefficient (or is a no-op */
6911 /* if dn->lsu==lsu). */
6912 /* */
6913 /* Note also that (only internally, from decQuantizeOp and */
6914 /* decSetSubnormal) the value of set->digits may be less than one, */
6915 /* indicating a round to left. This routine handles that case */
6916 /* correctly; caller ensures space. */
6917 /* */
6918 /* dn->digits, dn->lsu (and as required), and dn->exponent are */
6919 /* updated as necessary. dn->bits (sign) is unchanged. */
6920 /* */
6921 /* DEC_Rounded status is set if any digits are discarded. */
6922 /* DEC_Inexact status is set if any non-zero digits are discarded, or */
6923 /* incoming residue was non-0 (implies rounded) */
6924 /* ------------------------------------------------------------------ */
6925 /* mapping array: maps 0-9 to canonical residues, so that a residue */
6926 /* can be adjusted in the range [-1, +1] and achieve correct rounding */
6927 /* 0 1 2 3 4 5 6 7 8 9 */
6928 static const uByte resmap[10]={0, 3, 3, 3, 3, 5, 7, 7, 7, 7};
6929 static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu,
6930 Int len, Int *residue, uInt *status) {
6931 Int discard; /* number of digits to discard */
6932 uInt cut; /* cut point in Unit */
6933 const Unit *up; /* work */
6934 Unit *target; /* .. */
6935 Int count; /* .. */
6936 #if DECDPUN<=4
6937 uInt temp; /* .. */
6938 #endif
6939
6940 discard=len-set->digits; /* digits to discard */
6941 if (discard<=0) { /* no digits are being discarded */
6942 if (dn->lsu!=lsu) { /* copy needed */
6943 /* copy the coefficient array to the result number; no shift needed */
6944 count=len; /* avoids D2U */
6945 up=lsu;
6946 for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
6947 *target=*up;
6948 dn->digits=len; /* set the new length */
6949 }
6950 /* dn->exponent and residue are unchanged, record any inexactitude */
6951 if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded);
6952 return;
6953 }
6954
6955 /* some digits must be discarded ... */
6956 dn->exponent+=discard; /* maintain numerical value */
6957 *status|=DEC_Rounded; /* accumulate Rounded status */
6958 if (*residue>1) *residue=1; /* previous residue now to right, so reduce */
6959
6960 if (discard>len) { /* everything, +1, is being discarded */
6961 /* guard digit is 0 */
6962 /* residue is all the number [NB could be all 0s] */
6963 if (*residue<=0) { /* not already positive */
6964 count=len; /* avoids D2U */
6965 for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { /* found non-0 */
6966 *residue=1;
6967 break; /* no need to check any others */
6968 }
6969 }
6970 if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
6971 *dn->lsu=0; /* coefficient will now be 0 */
6972 dn->digits=1; /* .. */
6973 return;
6974 } /* total discard */
6975
6976 /* partial discard [most common case] */
6977 /* here, at least the first (most significant) discarded digit exists */
6978
6979 /* spin up the number, noting residue during the spin, until get to */
6980 /* the Unit with the first discarded digit. When reach it, extract */
6981 /* it and remember its position */
6982 count=0;
6983 for (up=lsu;; up++) {
6984 count+=DECDPUN;
6985 if (count>=discard) break; /* full ones all checked */
6986 if (*up!=0) *residue=1;
6987 } /* up */
6988
6989 /* here up -> Unit with first discarded digit */
6990 cut=discard-(count-DECDPUN)-1;
6991 if (cut==DECDPUN-1) { /* unit-boundary case (fast) */
6992 Unit half=(Unit)powers[DECDPUN]>>1;
6993 /* set residue directly */
6994 if (*up>=half) {
6995 if (*up>half) *residue=7;
6996 else *residue+=5; /* add sticky bit */
6997 }
6998 else { /* <half */
6999 if (*up!=0) *residue=3; /* [else is 0, leave as sticky bit] */
7000 }
7001 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */
7002 *dn->lsu=0; /* .. result is 0 */
7003 dn->digits=1; /* .. */
7004 }
7005 else { /* shift to least */
7006 count=set->digits; /* now digits to end up with */
7007 dn->digits=count; /* set the new length */
7008 up++; /* move to next */
7009 /* on unit boundary, so shift-down copy loop is simple */
7010 for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
7011 *target=*up;
7012 }
7013 } /* unit-boundary case */
7014
7015 else { /* discard digit is in low digit(s), and not top digit */
7016 uInt discard1; /* first discarded digit */
7017 uInt quot, rem; /* for divisions */
7018 if (cut==0) quot=*up; /* is at bottom of unit */
7019 else /* cut>0 */ { /* it's not at bottom of unit */
7020 #if DECDPUN<=4
7021 U_ASSERT(/* cut >= 0 &&*/ cut <= 4);
7022 quot=QUOT10(*up, cut);
7023 rem=*up-quot*powers[cut];
7024 #else
7025 rem=*up%powers[cut];
7026 quot=*up/powers[cut];
7027 #endif
7028 if (rem!=0) *residue=1;
7029 }
7030 /* discard digit is now at bottom of quot */
7031 #if DECDPUN<=4
7032 temp=(quot*6554)>>16; /* fast /10 */
7033 /* Vowels algorithm here not a win (9 instructions) */
7034 discard1=quot-X10(temp);
7035 quot=temp;
7036 #else
7037 discard1=quot%10;
7038 quot=quot/10;
7039 #endif
7040 /* here, discard1 is the guard digit, and residue is everything */
7041 /* else [use mapping array to accumulate residue safely] */
7042 *residue+=resmap[discard1];
7043 cut++; /* update cut */
7044 /* here: up -> Unit of the array with bottom digit */
7045 /* cut is the division point for each Unit */
7046 /* quot holds the uncut high-order digits for the current unit */
7047 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */
7048 *dn->lsu=0; /* .. result is 0 */
7049 dn->digits=1; /* .. */
7050 }
7051 else { /* shift to least needed */
7052 count=set->digits; /* now digits to end up with */
7053 dn->digits=count; /* set the new length */
7054 /* shift-copy the coefficient array to the result number */
7055 for (target=dn->lsu; ; target++) {
7056 *target=(Unit)quot;
7057 count-=(DECDPUN-cut);
7058 if (count<=0) break;
7059 up++;
7060 quot=*up;
7061 #if DECDPUN<=4
7062 quot=QUOT10(quot, cut);
7063 rem=*up-quot*powers[cut];
7064 #else
7065 rem=quot%powers[cut];
7066 quot=quot/powers[cut];
7067 #endif
7068 *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
7069 count-=cut;
7070 if (count<=0) break;
7071 } /* shift-copy loop */
7072 } /* shift to least */
7073 } /* not unit boundary */
7074
7075 if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
7076 return;
7077 } /* decSetCoeff */
7078
7079 /* ------------------------------------------------------------------ */
7080 /* decApplyRound -- apply pending rounding to a number */
7081 /* */
7082 /* dn is the number, with space for set->digits digits */
7083 /* set is the context [for size and rounding mode] */
7084 /* residue indicates pending rounding, being any accumulated */
7085 /* guard and sticky information. It may be: */
7086 /* 6-9: rounding digit is >5 */
7087 /* 5: rounding digit is exactly half-way */
7088 /* 1-4: rounding digit is <5 and >0 */
7089 /* 0: the coefficient is exact */
7090 /* -1: as 1, but the hidden digits are subtractive, that */
7091 /* is, of the opposite sign to dn. In this case the */
7092 /* coefficient must be non-0. This case occurs when */
7093 /* subtracting a small number (which can be reduced to */
7094 /* a sticky bit); see decAddOp. */
7095 /* status is the status accumulator, as usual */
7096 /* */
7097 /* This routine applies rounding while keeping the length of the */
7098 /* coefficient constant. The exponent and status are unchanged */
7099 /* except if: */
7100 /* */
7101 /* -- the coefficient was increased and is all nines (in which */
7102 /* case Overflow could occur, and is handled directly here so */
7103 /* the caller does not need to re-test for overflow) */
7104 /* */
7105 /* -- the coefficient was decreased and becomes all nines (in which */
7106 /* case Underflow could occur, and is also handled directly). */
7107 /* */
7108 /* All fields in dn are updated as required. */
7109 /* */
7110 /* ------------------------------------------------------------------ */
7111 static void decApplyRound(decNumber *dn, decContext *set, Int residue,
7112 uInt *status) {
7113 Int bump; /* 1 if coefficient needs to be incremented */
7114 /* -1 if coefficient needs to be decremented */
7115
7116 if (residue==0) return; /* nothing to apply */
7117
7118 bump=0; /* assume a smooth ride */
7119
7120 /* now decide whether, and how, to round, depending on mode */
7121 switch (set->round) {
7122 case DEC_ROUND_05UP: { /* round zero or five up (for reround) */
7123 /* This is the same as DEC_ROUND_DOWN unless there is a */
7124 /* positive residue and the lsd of dn is 0 or 5, in which case */
7125 /* it is bumped; when residue is <0, the number is therefore */
7126 /* bumped down unless the final digit was 1 or 6 (in which */
7127 /* case it is bumped down and then up -- a no-op) */
7128 Int lsd5=*dn->lsu%5; /* get lsd and quintate */
7129 if (residue<0 && lsd5!=1) bump=-1;
7130 else if (residue>0 && lsd5==0) bump=1;
7131 /* [bump==1 could be applied directly; use common path for clarity] */
7132 break;} /* r-05 */
7133
7134 case DEC_ROUND_DOWN: {
7135 /* no change, except if negative residue */
7136 if (residue<0) bump=-1;
7137 break;} /* r-d */
7138
7139 case DEC_ROUND_HALF_DOWN: {
7140 if (residue>5) bump=1;
7141 break;} /* r-h-d */
7142
7143 case DEC_ROUND_HALF_EVEN: {
7144 if (residue>5) bump=1; /* >0.5 goes up */
7145 else if (residue==5) { /* exactly 0.5000... */
7146 /* 0.5 goes up iff [new] lsd is odd */
7147 if (*dn->lsu & 0x01) bump=1;
7148 }
7149 break;} /* r-h-e */
7150
7151 case DEC_ROUND_HALF_UP: {
7152 if (residue>=5) bump=1;
7153 break;} /* r-h-u */
7154
7155 case DEC_ROUND_UP: {
7156 if (residue>0) bump=1;
7157 break;} /* r-u */
7158
7159 case DEC_ROUND_CEILING: {
7160 /* same as _UP for positive numbers, and as _DOWN for negatives */
7161 /* [negative residue cannot occur on 0] */
7162 if (decNumberIsNegative(dn)) {
7163 if (residue<0) bump=-1;
7164 }
7165 else {
7166 if (residue>0) bump=1;
7167 }
7168 break;} /* r-c */
7169
7170 case DEC_ROUND_FLOOR: {
7171 /* same as _UP for negative numbers, and as _DOWN for positive */
7172 /* [negative residue cannot occur on 0] */
7173 if (!decNumberIsNegative(dn)) {
7174 if (residue<0) bump=-1;
7175 }
7176 else {
7177 if (residue>0) bump=1;
7178 }
7179 break;} /* r-f */
7180
7181 default: { /* e.g., DEC_ROUND_MAX */
7182 *status|=DEC_Invalid_context;
7183 #if DECTRACE || (DECCHECK && DECVERB)
7184 printf("Unknown rounding mode: %d\n", set->round);
7185 #endif
7186 break;}
7187 } /* switch */
7188
7189 /* now bump the number, up or down, if need be */
7190 if (bump==0) return; /* no action required */
7191
7192 /* Simply use decUnitAddSub unless bumping up and the number is */
7193 /* all nines. In this special case set to 100... explicitly */
7194 /* and adjust the exponent by one (as otherwise could overflow */
7195 /* the array) */
7196 /* Similarly handle all-nines result if bumping down. */
7197 if (bump>0) {
7198 Unit *up; /* work */
7199 uInt count=dn->digits; /* digits to be checked */
7200 for (up=dn->lsu; ; up++) {
7201 if (count<=DECDPUN) {
7202 /* this is the last Unit (the msu) */
7203 if (*up!=powers[count]-1) break; /* not still 9s */
7204 /* here if it, too, is all nines */
7205 *up=(Unit)powers[count-1]; /* here 999 -> 100 etc. */
7206 for (up=up-1; up>=dn->lsu; up--) *up=0; /* others all to 0 */
7207 dn->exponent++; /* and bump exponent */
7208 /* [which, very rarely, could cause Overflow...] */
7209 if ((dn->exponent+dn->digits)>set->emax+1) {
7210 decSetOverflow(dn, set, status);
7211 }
7212 return; /* done */
7213 }
7214 /* a full unit to check, with more to come */
7215 if (*up!=DECDPUNMAX) break; /* not still 9s */
7216 count-=DECDPUN;
7217 } /* up */
7218 } /* bump>0 */
7219 else { /* -1 */
7220 /* here checking for a pre-bump of 1000... (leading 1, all */
7221 /* other digits zero) */
7222 Unit *up, *sup; /* work */
7223 uInt count=dn->digits; /* digits to be checked */
7224 for (up=dn->lsu; ; up++) {
7225 if (count<=DECDPUN) {
7226 /* this is the last Unit (the msu) */
7227 if (*up!=powers[count-1]) break; /* not 100.. */
7228 /* here if have the 1000... case */
7229 sup=up; /* save msu pointer */
7230 *up=(Unit)powers[count]-1; /* here 100 in msu -> 999 */
7231 /* others all to all-nines, too */
7232 for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1;
7233 dn->exponent--; /* and bump exponent */
7234
7235 /* iff the number was at the subnormal boundary (exponent=etiny) */
7236 /* then the exponent is now out of range, so it will in fact get */
7237 /* clamped to etiny and the final 9 dropped. */
7238 /* printf(">> emin=%d exp=%d sdig=%d\n", set->emin, */
7239 /* dn->exponent, set->digits); */
7240 if (dn->exponent+1==set->emin-set->digits+1) {
7241 if (count==1 && dn->digits==1) *sup=0; /* here 9 -> 0[.9] */
7242 else {
7243 *sup=(Unit)powers[count-1]-1; /* here 999.. in msu -> 99.. */
7244 dn->digits--;
7245 }
7246 dn->exponent++;
7247 *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7248 }
7249 return; /* done */
7250 }
7251
7252 /* a full unit to check, with more to come */
7253 if (*up!=0) break; /* not still 0s */
7254 count-=DECDPUN;
7255 } /* up */
7256
7257 } /* bump<0 */
7258
7259 /* Actual bump needed. Do it. */
7260 decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump);
7261 } /* decApplyRound */
7262
7263 #if DECSUBSET
7264 /* ------------------------------------------------------------------ */
7265 /* decFinish -- finish processing a number */
7266 /* */
7267 /* dn is the number */
7268 /* set is the context */
7269 /* residue is the rounding accumulator (as in decApplyRound) */
7270 /* status is the accumulator */
7271 /* */
7272 /* This finishes off the current number by: */
7273 /* 1. If not extended: */
7274 /* a. Converting a zero result to clean '0' */
7275 /* b. Reducing positive exponents to 0, if would fit in digits */
7276 /* 2. Checking for overflow and subnormals (always) */
7277 /* Note this is just Finalize when no subset arithmetic. */
7278 /* All fields are updated as required. */
7279 /* ------------------------------------------------------------------ */
7280 static void decFinish(decNumber *dn, decContext *set, Int *residue,
7281 uInt *status) {
7282 if (!set->extended) {
7283 if ISZERO(dn) { /* value is zero */
7284 dn->exponent=0; /* clean exponent .. */
7285 dn->bits=0; /* .. and sign */
7286 return; /* no error possible */
7287 }
7288 if (dn->exponent>=0) { /* non-negative exponent */
7289 /* >0; reduce to integer if possible */
7290 if (set->digits >= (dn->exponent+dn->digits)) {
7291 dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent);
7292 dn->exponent=0;
7293 }
7294 }
7295 } /* !extended */
7296
7297 decFinalize(dn, set, residue, status);
7298 } /* decFinish */
7299 #endif
7300
7301 /* ------------------------------------------------------------------ */
7302 /* decFinalize -- final check, clamp, and round of a number */
7303 /* */
7304 /* dn is the number */
7305 /* set is the context */
7306 /* residue is the rounding accumulator (as in decApplyRound) */
7307 /* status is the status accumulator */
7308 /* */
7309 /* This finishes off the current number by checking for subnormal */
7310 /* results, applying any pending rounding, checking for overflow, */
7311 /* and applying any clamping. */
7312 /* Underflow and overflow conditions are raised as appropriate. */
7313 /* All fields are updated as required. */
7314 /* ------------------------------------------------------------------ */
7315 static void decFinalize(decNumber *dn, decContext *set, Int *residue,
7316 uInt *status) {
7317 Int shift; /* shift needed if clamping */
7318 Int tinyexp=set->emin-dn->digits+1; /* precalculate subnormal boundary */
7319
7320 /* Must be careful, here, when checking the exponent as the */
7321 /* adjusted exponent could overflow 31 bits [because it may already */
7322 /* be up to twice the expected]. */
7323
7324 /* First test for subnormal. This must be done before any final */
7325 /* round as the result could be rounded to Nmin or 0. */
7326 if (dn->exponent<=tinyexp) { /* prefilter */
7327 Int comp;
7328 decNumber nmin;
7329 /* A very nasty case here is dn == Nmin and residue<0 */
7330 if (dn->exponent<tinyexp) {
7331 /* Go handle subnormals; this will apply round if needed. */
7332 decSetSubnormal(dn, set, residue, status);
7333 return;
7334 }
7335 /* Equals case: only subnormal if dn=Nmin and negative residue */
7336 uprv_decNumberZero(&nmin);
7337 nmin.lsu[0]=1;
7338 nmin.exponent=set->emin;
7339 comp=decCompare(dn, &nmin, 1); /* (signless compare) */
7340 if (comp==BADINT) { /* oops */
7341 *status|=DEC_Insufficient_storage; /* abandon... */
7342 return;
7343 }
7344 if (*residue<0 && comp==0) { /* neg residue and dn==Nmin */
7345 decApplyRound(dn, set, *residue, status); /* might force down */
7346 decSetSubnormal(dn, set, residue, status);
7347 return;
7348 }
7349 }
7350
7351 /* now apply any pending round (this could raise overflow). */
7352 if (*residue!=0) decApplyRound(dn, set, *residue, status);
7353
7354 /* Check for overflow [redundant in the 'rare' case] or clamp */
7355 if (dn->exponent<=set->emax-set->digits+1) return; /* neither needed */
7356
7357
7358 /* here when might have an overflow or clamp to do */
7359 if (dn->exponent>set->emax-dn->digits+1) { /* too big */
7360 decSetOverflow(dn, set, status);
7361 return;
7362 }
7363 /* here when the result is normal but in clamp range */
7364 if (!set->clamp) return;
7365
7366 /* here when need to apply the IEEE exponent clamp (fold-down) */
7367 shift=dn->exponent-(set->emax-set->digits+1);
7368
7369 /* shift coefficient (if non-zero) */
7370 if (!ISZERO(dn)) {
7371 dn->digits=decShiftToMost(dn->lsu, dn->digits, shift);
7372 }
7373 dn->exponent-=shift; /* adjust the exponent to match */
7374 *status|=DEC_Clamped; /* and record the dirty deed */
7375 return;
7376 } /* decFinalize */
7377
7378 /* ------------------------------------------------------------------ */
7379 /* decSetOverflow -- set number to proper overflow value */
7380 /* */
7381 /* dn is the number (used for sign [only] and result) */
7382 /* set is the context [used for the rounding mode, etc.] */
7383 /* status contains the current status to be updated */
7384 /* */
7385 /* This sets the sign of a number and sets its value to either */
7386 /* Infinity or the maximum finite value, depending on the sign of */
7387 /* dn and the rounding mode, following IEEE 754 rules. */
7388 /* ------------------------------------------------------------------ */
7389 static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) {
7390 Flag needmax=0; /* result is maximum finite value */
7391 uByte sign=dn->bits&DECNEG; /* clean and save sign bit */
7392
7393 if (ISZERO(dn)) { /* zero does not overflow magnitude */
7394 Int emax=set->emax; /* limit value */
7395 if (set->clamp) emax-=set->digits-1; /* lower if clamping */
7396 if (dn->exponent>emax) { /* clamp required */
7397 dn->exponent=emax;
7398 *status|=DEC_Clamped;
7399 }
7400 return;
7401 }
7402
7403 uprv_decNumberZero(dn);
7404 switch (set->round) {
7405 case DEC_ROUND_DOWN: {
7406 needmax=1; /* never Infinity */
7407 break;} /* r-d */
7408 case DEC_ROUND_05UP: {
7409 needmax=1; /* never Infinity */
7410 break;} /* r-05 */
7411 case DEC_ROUND_CEILING: {
7412 if (sign) needmax=1; /* Infinity if non-negative */
7413 break;} /* r-c */
7414 case DEC_ROUND_FLOOR: {
7415 if (!sign) needmax=1; /* Infinity if negative */
7416 break;} /* r-f */
7417 default: break; /* Infinity in all other cases */
7418 }
7419 if (needmax) {
7420 decSetMaxValue(dn, set);
7421 dn->bits=sign; /* set sign */
7422 }
7423 else dn->bits=sign|DECINF; /* Value is +/-Infinity */
7424 *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded;
7425 } /* decSetOverflow */
7426
7427 /* ------------------------------------------------------------------ */
7428 /* decSetMaxValue -- set number to +Nmax (maximum normal value) */
7429 /* */
7430 /* dn is the number to set */
7431 /* set is the context [used for digits and emax] */
7432 /* */
7433 /* This sets the number to the maximum positive value. */
7434 /* ------------------------------------------------------------------ */
7435 static void decSetMaxValue(decNumber *dn, decContext *set) {
7436 Unit *up; /* work */
7437 Int count=set->digits; /* nines to add */
7438 dn->digits=count;
7439 /* fill in all nines to set maximum value */
7440 for (up=dn->lsu; ; up++) {
7441 if (count>DECDPUN) *up=DECDPUNMAX; /* unit full o'nines */
7442 else { /* this is the msu */
7443 *up=(Unit)(powers[count]-1);
7444 break;
7445 }
7446 count-=DECDPUN; /* filled those digits */
7447 } /* up */
7448 dn->bits=0; /* + sign */
7449 dn->exponent=set->emax-set->digits+1;
7450 } /* decSetMaxValue */
7451
7452 /* ------------------------------------------------------------------ */
7453 /* decSetSubnormal -- process value whose exponent is <Emin */
7454 /* */
7455 /* dn is the number (used as input as well as output; it may have */
7456 /* an allowed subnormal value, which may need to be rounded) */
7457 /* set is the context [used for the rounding mode] */
7458 /* residue is any pending residue */
7459 /* status contains the current status to be updated */
7460 /* */
7461 /* If subset mode, set result to zero and set Underflow flags. */
7462 /* */
7463 /* Value may be zero with a low exponent; this does not set Subnormal */
7464 /* but the exponent will be clamped to Etiny. */
7465 /* */
7466 /* Otherwise ensure exponent is not out of range, and round as */
7467 /* necessary. Underflow is set if the result is Inexact. */
7468 /* ------------------------------------------------------------------ */
7469 static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue,
7470 uInt *status) {
7471 decContext workset; /* work */
7472 Int etiny, adjust; /* .. */
7473
7474 #if DECSUBSET
7475 /* simple set to zero and 'hard underflow' for subset */
7476 if (!set->extended) {
7477 uprv_decNumberZero(dn);
7478 /* always full overflow */
7479 *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7480 return;
7481 }
7482 #endif
7483
7484 /* Full arithmetic -- allow subnormals, rounded to minimum exponent */
7485 /* (Etiny) if needed */
7486 etiny=set->emin-(set->digits-1); /* smallest allowed exponent */
7487
7488 if ISZERO(dn) { /* value is zero */
7489 /* residue can never be non-zero here */
7490 #if DECCHECK
7491 if (*residue!=0) {
7492 printf("++ Subnormal 0 residue %ld\n", (LI)*residue);
7493 *status|=DEC_Invalid_operation;
7494 }
7495 #endif
7496 if (dn->exponent<etiny) { /* clamp required */
7497 dn->exponent=etiny;
7498 *status|=DEC_Clamped;
7499 }
7500 return;
7501 }
7502
7503 *status|=DEC_Subnormal; /* have a non-zero subnormal */
7504 adjust=etiny-dn->exponent; /* calculate digits to remove */
7505 if (adjust<=0) { /* not out of range; unrounded */
7506 /* residue can never be non-zero here, except in the Nmin-residue */
7507 /* case (which is a subnormal result), so can take fast-path here */
7508 /* it may already be inexact (from setting the coefficient) */
7509 if (*status&DEC_Inexact) *status|=DEC_Underflow;
7510 return;
7511 }
7512
7513 /* adjust>0, so need to rescale the result so exponent becomes Etiny */
7514 /* [this code is similar to that in rescale] */
7515 workset=*set; /* clone rounding, etc. */
7516 workset.digits=dn->digits-adjust; /* set requested length */
7517 workset.emin-=adjust; /* and adjust emin to match */
7518 /* [note that the latter can be <1, here, similar to Rescale case] */
7519 decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status);
7520 decApplyRound(dn, &workset, *residue, status);
7521
7522 /* Use 754 default rule: Underflow is set iff Inexact */
7523 /* [independent of whether trapped] */
7524 if (*status&DEC_Inexact) *status|=DEC_Underflow;
7525
7526 /* if rounded up a 999s case, exponent will be off by one; adjust */
7527 /* back if so [it will fit, because it was shortened earlier] */
7528 if (dn->exponent>etiny) {
7529 dn->digits=decShiftToMost(dn->lsu, dn->digits, 1);
7530 dn->exponent--; /* (re)adjust the exponent. */
7531 }
7532
7533 /* if rounded to zero, it is by definition clamped... */
7534 if (ISZERO(dn)) *status|=DEC_Clamped;
7535 } /* decSetSubnormal */
7536
7537 /* ------------------------------------------------------------------ */
7538 /* decCheckMath - check entry conditions for a math function */
7539 /* */
7540 /* This checks the context and the operand */
7541 /* */
7542 /* rhs is the operand to check */
7543 /* set is the context to check */
7544 /* status is unchanged if both are good */
7545 /* */
7546 /* returns non-zero if status is changed, 0 otherwise */
7547 /* */
7548 /* Restrictions enforced: */
7549 /* */
7550 /* digits, emax, and -emin in the context must be less than */
7551 /* DEC_MAX_MATH (999999), and A must be within these bounds if */
7552 /* non-zero. Invalid_operation is set in the status if a */
7553 /* restriction is violated. */
7554 /* ------------------------------------------------------------------ */
7555 static uInt decCheckMath(const decNumber *rhs, decContext *set,
7556 uInt *status) {
7557 uInt save=*status; /* record */
7558 if (set->digits>DEC_MAX_MATH
7559 || set->emax>DEC_MAX_MATH
7560 || -set->emin>DEC_MAX_MATH) *status|=DEC_Invalid_context;
7561 else if ((rhs->digits>DEC_MAX_MATH
7562 || rhs->exponent+rhs->digits>DEC_MAX_MATH+1
7563 || rhs->exponent+rhs->digits<2*(1-DEC_MAX_MATH))
7564 && !ISZERO(rhs)) *status|=DEC_Invalid_operation;
7565 return (*status!=save);
7566 } /* decCheckMath */
7567
7568 /* ------------------------------------------------------------------ */
7569 /* decGetInt -- get integer from a number */
7570 /* */
7571 /* dn is the number [which will not be altered] */
7572 /* */
7573 /* returns one of: */
7574 /* BADINT if there is a non-zero fraction */
7575 /* the converted integer */
7576 /* BIGEVEN if the integer is even and magnitude > 2*10**9 */
7577 /* BIGODD if the integer is odd and magnitude > 2*10**9 */
7578 /* */
7579 /* This checks and gets a whole number from the input decNumber. */
7580 /* The sign can be determined from dn by the caller when BIGEVEN or */
7581 /* BIGODD is returned. */
7582 /* ------------------------------------------------------------------ */
7583 static Int decGetInt(const decNumber *dn) {
7584 Int theInt; /* result accumulator */
7585 const Unit *up; /* work */
7586 Int got; /* digits (real or not) processed */
7587 Int ilength=dn->digits+dn->exponent; /* integral length */
7588 Flag neg=decNumberIsNegative(dn); /* 1 if -ve */
7589
7590 /* The number must be an integer that fits in 10 digits */
7591 /* Assert, here, that 10 is enough for any rescale Etiny */
7592 #if DEC_MAX_EMAX > 999999999
7593 #error GetInt may need updating [for Emax]
7594 #endif
7595 #if DEC_MIN_EMIN < -999999999
7596 #error GetInt may need updating [for Emin]
7597 #endif
7598 if (ISZERO(dn)) return 0; /* zeros are OK, with any exponent */
7599
7600 up=dn->lsu; /* ready for lsu */
7601 theInt=0; /* ready to accumulate */
7602 if (dn->exponent>=0) { /* relatively easy */
7603 /* no fractional part [usual]; allow for positive exponent */
7604 got=dn->exponent;
7605 }
7606 else { /* -ve exponent; some fractional part to check and discard */
7607 Int count=-dn->exponent; /* digits to discard */
7608 /* spin up whole units until reach the Unit with the unit digit */
7609 for (; count>=DECDPUN; up++) {
7610 if (*up!=0) return BADINT; /* non-zero Unit to discard */
7611 count-=DECDPUN;
7612 }
7613 if (count==0) got=0; /* [a multiple of DECDPUN] */
7614 else { /* [not multiple of DECDPUN] */
7615 Int rem; /* work */
7616 /* slice off fraction digits and check for non-zero */
7617 #if DECDPUN<=4
7618 theInt=QUOT10(*up, count);
7619 rem=*up-theInt*powers[count];
7620 #else
7621 rem=*up%powers[count]; /* slice off discards */
7622 theInt=*up/powers[count];
7623 #endif
7624 if (rem!=0) return BADINT; /* non-zero fraction */
7625 /* it looks good */
7626 got=DECDPUN-count; /* number of digits so far */
7627 up++; /* ready for next */
7628 }
7629 }
7630 /* now it's known there's no fractional part */
7631
7632 /* tricky code now, to accumulate up to 9.3 digits */
7633 if (got==0) {theInt=*up; got+=DECDPUN; up++;} /* ensure lsu is there */
7634
7635 if (ilength<11) {
7636 Int save=theInt;
7637 /* collect any remaining unit(s) */
7638 for (; got<ilength; up++) {
7639 theInt+=*up*powers[got];
7640 got+=DECDPUN;
7641 }
7642 if (ilength==10) { /* need to check for wrap */
7643 if (theInt/(Int)powers[got-DECDPUN]!=(Int)*(up-1)) ilength=11;
7644 /* [that test also disallows the BADINT result case] */
7645 else if (neg && theInt>1999999997) ilength=11;
7646 else if (!neg && theInt>999999999) ilength=11;
7647 if (ilength==11) theInt=save; /* restore correct low bit */
7648 }
7649 }
7650
7651 if (ilength>10) { /* too big */
7652 if (theInt&1) return BIGODD; /* bottom bit 1 */
7653 return BIGEVEN; /* bottom bit 0 */
7654 }
7655
7656 if (neg) theInt=-theInt; /* apply sign */
7657 return theInt;
7658 } /* decGetInt */
7659
7660 /* ------------------------------------------------------------------ */
7661 /* decDecap -- decapitate the coefficient of a number */
7662 /* */
7663 /* dn is the number to be decapitated */
7664 /* drop is the number of digits to be removed from the left of dn; */
7665 /* this must be <= dn->digits (if equal, the coefficient is */
7666 /* set to 0) */
7667 /* */
7668 /* Returns dn; dn->digits will be <= the initial digits less drop */
7669 /* (after removing drop digits there may be leading zero digits */
7670 /* which will also be removed). Only dn->lsu and dn->digits change. */
7671 /* ------------------------------------------------------------------ */
7672 static decNumber *decDecap(decNumber *dn, Int drop) {
7673 Unit *msu; /* -> target cut point */
7674 Int cut; /* work */
7675 if (drop>=dn->digits) { /* losing the whole thing */
7676 #if DECCHECK
7677 if (drop>dn->digits)
7678 printf("decDecap called with drop>digits [%ld>%ld]\n",
7679 (LI)drop, (LI)dn->digits);
7680 #endif
7681 dn->lsu[0]=0;
7682 dn->digits=1;
7683 return dn;
7684 }
7685 msu=dn->lsu+D2U(dn->digits-drop)-1; /* -> likely msu */
7686 cut=MSUDIGITS(dn->digits-drop); /* digits to be in use in msu */
7687 if (cut!=DECDPUN) *msu%=powers[cut]; /* clear left digits */
7688 /* that may have left leading zero digits, so do a proper count... */
7689 dn->digits=decGetDigits(dn->lsu, msu-dn->lsu+1);
7690 return dn;
7691 } /* decDecap */
7692
7693 /* ------------------------------------------------------------------ */
7694 /* decBiStr -- compare string with pairwise options */
7695 /* */
7696 /* targ is the string to compare */
7697 /* str1 is one of the strings to compare against (length may be 0) */
7698 /* str2 is the other; it must be the same length as str1 */
7699 /* */
7700 /* returns 1 if strings compare equal, (that is, it is the same */
7701 /* length as str1 and str2, and each character of targ is in either */
7702 /* str1 or str2 in the corresponding position), or 0 otherwise */
7703 /* */
7704 /* This is used for generic caseless compare, including the awkward */
7705 /* case of the Turkish dotted and dotless Is. Use as (for example): */
7706 /* if (decBiStr(test, "mike", "MIKE")) ... */
7707 /* ------------------------------------------------------------------ */
7708 static Flag decBiStr(const char *targ, const char *str1, const char *str2) {
7709 for (;;targ++, str1++, str2++) {
7710 if (*targ!=*str1 && *targ!=*str2) return 0;
7711 /* *targ has a match in one (or both, if terminator) */
7712 if (*targ=='\0') break;
7713 } /* forever */
7714 return 1;
7715 } /* decBiStr */
7716
7717 /* ------------------------------------------------------------------ */
7718 /* decNaNs -- handle NaN operand or operands */
7719 /* */
7720 /* res is the result number */
7721 /* lhs is the first operand */
7722 /* rhs is the second operand, or NULL if none */
7723 /* context is used to limit payload length */
7724 /* status contains the current status */
7725 /* returns res in case convenient */
7726 /* */
7727 /* Called when one or both operands is a NaN, and propagates the */
7728 /* appropriate result to res. When an sNaN is found, it is changed */
7729 /* to a qNaN and Invalid operation is set. */
7730 /* ------------------------------------------------------------------ */
7731 static decNumber * decNaNs(decNumber *res, const decNumber *lhs,
7732 const decNumber *rhs, decContext *set,
7733 uInt *status) {
7734 /* This decision tree ends up with LHS being the source pointer, */
7735 /* and status updated if need be */
7736 if (lhs->bits & DECSNAN)
7737 *status|=DEC_Invalid_operation | DEC_sNaN;
7738 else if (rhs==NULL);
7739 else if (rhs->bits & DECSNAN) {
7740 lhs=rhs;
7741 *status|=DEC_Invalid_operation | DEC_sNaN;
7742 }
7743 else if (lhs->bits & DECNAN);
7744 else lhs=rhs;
7745
7746 /* propagate the payload */
7747 if (lhs->digits<=set->digits) uprv_decNumberCopy(res, lhs); /* easy */
7748 else { /* too long */
7749 const Unit *ul;
7750 Unit *ur, *uresp1;
7751 /* copy safe number of units, then decapitate */
7752 res->bits=lhs->bits; /* need sign etc. */
7753 uresp1=res->lsu+D2U(set->digits);
7754 for (ur=res->lsu, ul=lhs->lsu; ur<uresp1; ur++, ul++) *ur=*ul;
7755 res->digits=D2U(set->digits)*DECDPUN;
7756 /* maybe still too long */
7757 if (res->digits>set->digits) decDecap(res, res->digits-set->digits);
7758 }
7759
7760 res->bits&=~DECSNAN; /* convert any sNaN to NaN, while */
7761 res->bits|=DECNAN; /* .. preserving sign */
7762 res->exponent=0; /* clean exponent */
7763 /* [coefficient was copied/decapitated] */
7764 return res;
7765 } /* decNaNs */
7766
7767 /* ------------------------------------------------------------------ */
7768 /* decStatus -- apply non-zero status */
7769 /* */
7770 /* dn is the number to set if error */
7771 /* status contains the current status (not yet in context) */
7772 /* set is the context */
7773 /* */
7774 /* If the status is an error status, the number is set to a NaN, */
7775 /* unless the error was an overflow, divide-by-zero, or underflow, */
7776 /* in which case the number will have already been set. */
7777 /* */
7778 /* The context status is then updated with the new status. Note that */
7779 /* this may raise a signal, so control may never return from this */
7780 /* routine (hence resources must be recovered before it is called). */
7781 /* ------------------------------------------------------------------ */
7782 static void decStatus(decNumber *dn, uInt status, decContext *set) {
7783 if (status & DEC_NaNs) { /* error status -> NaN */
7784 /* if cause was an sNaN, clear and propagate [NaN is already set up] */
7785 if (status & DEC_sNaN) status&=~DEC_sNaN;
7786 else {
7787 uprv_decNumberZero(dn); /* other error: clean throughout */
7788 dn->bits=DECNAN; /* and make a quiet NaN */
7789 }
7790 }
7791 uprv_decContextSetStatus(set, status); /* [may not return] */
7792 return;
7793 } /* decStatus */
7794
7795 /* ------------------------------------------------------------------ */
7796 /* decGetDigits -- count digits in a Units array */
7797 /* */
7798 /* uar is the Unit array holding the number (this is often an */
7799 /* accumulator of some sort) */
7800 /* len is the length of the array in units [>=1] */
7801 /* */
7802 /* returns the number of (significant) digits in the array */
7803 /* */
7804 /* All leading zeros are excluded, except the last if the array has */
7805 /* only zero Units. */
7806 /* ------------------------------------------------------------------ */
7807 /* This may be called twice during some operations. */
7808 static Int decGetDigits(Unit *uar, Int len) {
7809 Unit *up=uar+(len-1); /* -> msu */
7810 Int digits=(len-1)*DECDPUN+1; /* possible digits excluding msu */
7811 #if DECDPUN>4
7812 uInt const *pow; /* work */
7813 #endif
7814 /* (at least 1 in final msu) */
7815 #if DECCHECK
7816 if (len<1) printf("decGetDigits called with len<1 [%ld]\n", (LI)len);
7817 #endif
7818
7819 for (; up>=uar; up--) {
7820 if (*up==0) { /* unit is all 0s */
7821 if (digits==1) break; /* a zero has one digit */
7822 digits-=DECDPUN; /* adjust for 0 unit */
7823 continue;}
7824 /* found the first (most significant) non-zero Unit */
7825 #if DECDPUN>1 /* not done yet */
7826 if (*up<10) break; /* is 1-9 */
7827 digits++;
7828 #if DECDPUN>2 /* not done yet */
7829 if (*up<100) break; /* is 10-99 */
7830 digits++;
7831 #if DECDPUN>3 /* not done yet */
7832 if (*up<1000) break; /* is 100-999 */
7833 digits++;
7834 #if DECDPUN>4 /* count the rest ... */
7835 for (pow=&powers[4]; *up>=*pow; pow++) digits++;
7836 #endif
7837 #endif
7838 #endif
7839 #endif
7840 break;
7841 } /* up */
7842 return digits;
7843 } /* decGetDigits */
7844
7845 #if DECTRACE | DECCHECK
7846 /* ------------------------------------------------------------------ */
7847 /* decNumberShow -- display a number [debug aid] */
7848 /* dn is the number to show */
7849 /* */
7850 /* Shows: sign, exponent, coefficient (msu first), digits */
7851 /* or: sign, special-value */
7852 /* ------------------------------------------------------------------ */
7853 /* this is public so other modules can use it */
7854 void uprv_decNumberShow(const decNumber *dn) {
7855 const Unit *up; /* work */
7856 uInt u, d; /* .. */
7857 Int cut; /* .. */
7858 char isign='+'; /* main sign */
7859 if (dn==NULL) {
7860 printf("NULL\n");
7861 return;}
7862 if (decNumberIsNegative(dn)) isign='-';
7863 printf(" >> %c ", isign);
7864 if (dn->bits&DECSPECIAL) { /* Is a special value */
7865 if (decNumberIsInfinite(dn)) printf("Infinity");
7866 else { /* a NaN */
7867 if (dn->bits&DECSNAN) printf("sNaN"); /* signalling NaN */
7868 else printf("NaN");
7869 }
7870 /* if coefficient and exponent are 0, no more to do */
7871 if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) {
7872 printf("\n");
7873 return;}
7874 /* drop through to report other information */
7875 printf(" ");
7876 }
7877
7878 /* now carefully display the coefficient */
7879 up=dn->lsu+D2U(dn->digits)-1; /* msu */
7880 printf("%ld", (LI)*up);
7881 for (up=up-1; up>=dn->lsu; up--) {
7882 u=*up;
7883 printf(":");
7884 for (cut=DECDPUN-1; cut>=0; cut--) {
7885 d=u/powers[cut];
7886 u-=d*powers[cut];
7887 printf("%ld", (LI)d);
7888 } /* cut */
7889 } /* up */
7890 if (dn->exponent!=0) {
7891 char esign='+';
7892 if (dn->exponent<0) esign='-';
7893 printf(" E%c%ld", esign, (LI)abs(dn->exponent));
7894 }
7895 printf(" [%ld]\n", (LI)dn->digits);
7896 } /* decNumberShow */
7897 #endif
7898
7899 #if DECTRACE || DECCHECK
7900 /* ------------------------------------------------------------------ */
7901 /* decDumpAr -- display a unit array [debug/check aid] */
7902 /* name is a single-character tag name */
7903 /* ar is the array to display */
7904 /* len is the length of the array in Units */
7905 /* ------------------------------------------------------------------ */
7906 static void decDumpAr(char name, const Unit *ar, Int len) {
7907 Int i;
7908 const char *spec;
7909 #if DECDPUN==9
7910 spec="%09d ";
7911 #elif DECDPUN==8
7912 spec="%08d ";
7913 #elif DECDPUN==7
7914 spec="%07d ";
7915 #elif DECDPUN==6
7916 spec="%06d ";
7917 #elif DECDPUN==5
7918 spec="%05d ";
7919 #elif DECDPUN==4
7920 spec="%04d ";
7921 #elif DECDPUN==3
7922 spec="%03d ";
7923 #elif DECDPUN==2
7924 spec="%02d ";
7925 #else
7926 spec="%d ";
7927 #endif
7928 printf(" :%c: ", name);
7929 for (i=len-1; i>=0; i--) {
7930 if (i==len-1) printf("%ld ", (LI)ar[i]);
7931 else printf(spec, ar[i]);
7932 }
7933 printf("\n");
7934 return;}
7935 #endif
7936
7937 #if DECCHECK
7938 /* ------------------------------------------------------------------ */
7939 /* decCheckOperands -- check operand(s) to a routine */
7940 /* res is the result structure (not checked; it will be set to */
7941 /* quiet NaN if error found (and it is not NULL)) */
7942 /* lhs is the first operand (may be DECUNRESU) */
7943 /* rhs is the second (may be DECUNUSED) */
7944 /* set is the context (may be DECUNCONT) */
7945 /* returns 0 if both operands, and the context are clean, or 1 */
7946 /* otherwise (in which case the context will show an error, */
7947 /* unless NULL). Note that res is not cleaned; caller should */
7948 /* handle this so res=NULL case is safe. */
7949 /* The caller is expected to abandon immediately if 1 is returned. */
7950 /* ------------------------------------------------------------------ */
7951 static Flag decCheckOperands(decNumber *res, const decNumber *lhs,
7952 const decNumber *rhs, decContext *set) {
7953 Flag bad=0;
7954 if (set==NULL) { /* oops; hopeless */
7955 #if DECTRACE || DECVERB
7956 printf("Reference to context is NULL.\n");
7957 #endif
7958 bad=1;
7959 return 1;}
7960 else if (set!=DECUNCONT
7961 && (set->digits<1 || set->round>=DEC_ROUND_MAX)) {
7962 bad=1;
7963 #if DECTRACE || DECVERB
7964 printf("Bad context [digits=%ld round=%ld].\n",
7965 (LI)set->digits, (LI)set->round);
7966 #endif
7967 }
7968 else {
7969 if (res==NULL) {
7970 bad=1;
7971 #if DECTRACE
7972 /* this one not DECVERB as standard tests include NULL */
7973 printf("Reference to result is NULL.\n");
7974 #endif
7975 }
7976 if (!bad && lhs!=DECUNUSED) bad=(decCheckNumber(lhs));
7977 if (!bad && rhs!=DECUNUSED) bad=(decCheckNumber(rhs));
7978 }
7979 if (bad) {
7980 if (set!=DECUNCONT) uprv_decContextSetStatus(set, DEC_Invalid_operation);
7981 if (res!=DECUNRESU && res!=NULL) {
7982 uprv_decNumberZero(res);
7983 res->bits=DECNAN; /* qNaN */
7984 }
7985 }
7986 return bad;
7987 } /* decCheckOperands */
7988
7989 /* ------------------------------------------------------------------ */
7990 /* decCheckNumber -- check a number */
7991 /* dn is the number to check */
7992 /* returns 0 if the number is clean, or 1 otherwise */
7993 /* */
7994 /* The number is considered valid if it could be a result from some */
7995 /* operation in some valid context. */
7996 /* ------------------------------------------------------------------ */
7997 static Flag decCheckNumber(const decNumber *dn) {
7998 const Unit *up; /* work */
7999 uInt maxuint; /* .. */
8000 Int ae, d, digits; /* .. */
8001 Int emin, emax; /* .. */
8002
8003 if (dn==NULL) { /* hopeless */
8004 #if DECTRACE
8005 /* this one not DECVERB as standard tests include NULL */
8006 printf("Reference to decNumber is NULL.\n");
8007 #endif
8008 return 1;}
8009
8010 /* check special values */
8011 if (dn->bits & DECSPECIAL) {
8012 if (dn->exponent!=0) {
8013 #if DECTRACE || DECVERB
8014 printf("Exponent %ld (not 0) for a special value [%02x].\n",
8015 (LI)dn->exponent, dn->bits);
8016 #endif
8017 return 1;}
8018
8019 /* 2003.09.08: NaNs may now have coefficients, so next tests Inf only */
8020 if (decNumberIsInfinite(dn)) {
8021 if (dn->digits!=1) {
8022 #if DECTRACE || DECVERB
8023 printf("Digits %ld (not 1) for an infinity.\n", (LI)dn->digits);
8024 #endif
8025 return 1;}
8026 if (*dn->lsu!=0) {
8027 #if DECTRACE || DECVERB
8028 printf("LSU %ld (not 0) for an infinity.\n", (LI)*dn->lsu);
8029 #endif
8030 decDumpAr('I', dn->lsu, D2U(dn->digits));
8031 return 1;}
8032 } /* Inf */
8033 /* 2002.12.26: negative NaNs can now appear through proposed IEEE */
8034 /* concrete formats (decimal64, etc.). */
8035 return 0;
8036 }
8037
8038 /* check the coefficient */
8039 if (dn->digits<1 || dn->digits>DECNUMMAXP) {
8040 #if DECTRACE || DECVERB
8041 printf("Digits %ld in number.\n", (LI)dn->digits);
8042 #endif
8043 return 1;}
8044
8045 d=dn->digits;
8046
8047 for (up=dn->lsu; d>0; up++) {
8048 if (d>DECDPUN) maxuint=DECDPUNMAX;
8049 else { /* reached the msu */
8050 maxuint=powers[d]-1;
8051 if (dn->digits>1 && *up<powers[d-1]) {
8052 #if DECTRACE || DECVERB
8053 printf("Leading 0 in number.\n");
8054 uprv_decNumberShow(dn);
8055 #endif
8056 return 1;}
8057 }
8058 if (*up>maxuint) {
8059 #if DECTRACE || DECVERB
8060 printf("Bad Unit [%08lx] in %ld-digit number at offset %ld [maxuint %ld].\n",
8061 (LI)*up, (LI)dn->digits, (LI)(up-dn->lsu), (LI)maxuint);
8062 #endif
8063 return 1;}
8064 d-=DECDPUN;
8065 }
8066
8067 /* check the exponent. Note that input operands can have exponents */
8068 /* which are out of the set->emin/set->emax and set->digits range */
8069 /* (just as they can have more digits than set->digits). */
8070 ae=dn->exponent+dn->digits-1; /* adjusted exponent */
8071 emax=DECNUMMAXE;
8072 emin=DECNUMMINE;
8073 digits=DECNUMMAXP;
8074 if (ae<emin-(digits-1)) {
8075 #if DECTRACE || DECVERB
8076 printf("Adjusted exponent underflow [%ld].\n", (LI)ae);
8077 uprv_decNumberShow(dn);
8078 #endif
8079 return 1;}
8080 if (ae>+emax) {
8081 #if DECTRACE || DECVERB
8082 printf("Adjusted exponent overflow [%ld].\n", (LI)ae);
8083 uprv_decNumberShow(dn);
8084 #endif
8085 return 1;}
8086
8087 return 0; /* it's OK */
8088 } /* decCheckNumber */
8089
8090 /* ------------------------------------------------------------------ */
8091 /* decCheckInexact -- check a normal finite inexact result has digits */
8092 /* dn is the number to check */
8093 /* set is the context (for status and precision) */
8094 /* sets Invalid operation, etc., if some digits are missing */
8095 /* [this check is not made for DECSUBSET compilation or when */
8096 /* subnormal is not set] */
8097 /* ------------------------------------------------------------------ */
8098 static void decCheckInexact(const decNumber *dn, decContext *set) {
8099 #if !DECSUBSET && DECEXTFLAG
8100 if ((set->status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact
8101 && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) {
8102 #if DECTRACE || DECVERB
8103 printf("Insufficient digits [%ld] on normal Inexact result.\n",
8104 (LI)dn->digits);
8105 uprv_decNumberShow(dn);
8106 #endif
8107 uprv_decContextSetStatus(set, DEC_Invalid_operation);
8108 }
8109 #else
8110 /* next is a noop for quiet compiler */
8111 if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation;
8112 #endif
8113 return;
8114 } /* decCheckInexact */
8115 #endif
8116
8117 #if DECALLOC
8118 #undef malloc
8119 #undef free
8120 /* ------------------------------------------------------------------ */
8121 /* decMalloc -- accountable allocation routine */
8122 /* n is the number of bytes to allocate */
8123 /* */
8124 /* Semantics is the same as the stdlib malloc routine, but bytes */
8125 /* allocated are accounted for globally, and corruption fences are */
8126 /* added before and after the 'actual' storage. */
8127 /* ------------------------------------------------------------------ */
8128 /* This routine allocates storage with an extra twelve bytes; 8 are */
8129 /* at the start and hold: */
8130 /* 0-3 the original length requested */
8131 /* 4-7 buffer corruption detection fence (DECFENCE, x4) */
8132 /* The 4 bytes at the end also hold a corruption fence (DECFENCE, x4) */
8133 /* ------------------------------------------------------------------ */
8134 static void *decMalloc(size_t n) {
8135 uInt size=n+12; /* true size */
8136 void *alloc; /* -> allocated storage */
8137 uByte *b, *b0; /* work */
8138 uInt uiwork; /* for macros */
8139
8140 alloc=malloc(size); /* -> allocated storage */
8141 if (alloc==NULL) return NULL; /* out of strorage */
8142 b0=(uByte *)alloc; /* as bytes */
8143 decAllocBytes+=n; /* account for storage */
8144 UBFROMUI(alloc, n); /* save n */
8145 /* printf(" alloc ++ dAB: %ld (%ld)\n", (LI)decAllocBytes, (LI)n); */
8146 for (b=b0+4; b<b0+8; b++) *b=DECFENCE;
8147 for (b=b0+n+8; b<b0+n+12; b++) *b=DECFENCE;
8148 return b0+8; /* -> play area */
8149 } /* decMalloc */
8150
8151 /* ------------------------------------------------------------------ */
8152 /* decFree -- accountable free routine */
8153 /* alloc is the storage to free */
8154 /* */
8155 /* Semantics is the same as the stdlib malloc routine, except that */
8156 /* the global storage accounting is updated and the fences are */
8157 /* checked to ensure that no routine has written 'out of bounds'. */
8158 /* ------------------------------------------------------------------ */
8159 /* This routine first checks that the fences have not been corrupted. */
8160 /* It then frees the storage using the 'truw' storage address (that */
8161 /* is, offset by 8). */
8162 /* ------------------------------------------------------------------ */
8163 static void decFree(void *alloc) {
8164 uInt n; /* original length */
8165 uByte *b, *b0; /* work */
8166 uInt uiwork; /* for macros */
8167
8168 if (alloc==NULL) return; /* allowed; it's a nop */
8169 b0=(uByte *)alloc; /* as bytes */
8170 b0-=8; /* -> true start of storage */
8171 n=UBTOUI(b0); /* lift length */
8172 for (b=b0+4; b<b0+8; b++) if (*b!=DECFENCE)
8173 printf("=== Corrupt byte [%02x] at offset %d from %ld ===\n", *b,
8174 b-b0-8, (LI)b0);
8175 for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE)
8176 printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b,
8177 b-b0-8, (LI)b0, (LI)n);
8178 free(b0); /* drop the storage */
8179 decAllocBytes-=n; /* account for storage */
8180 /* printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n); */
8181 } /* decFree */
8182 #define malloc(a) decMalloc(a)
8183 #define free(a) decFree(a)
8184 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial