libdecnumber/decNumber.c

   1 /* Decimal number arithmetic module for the decNumber C Library.
   2    Copyright (C) 2005-2013 Free Software Foundation, Inc.
   3    Contributed by IBM Corporation.  Author Mike Cowlishaw.
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it under
   8    the terms of the GNU General Public License as published by the Free
   9    Software Foundation; either version 3, or (at your option) any later
  10    version.
  11
  12    GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13    WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15    for more details.
  16
  17 Under Section 7 of GPL version 3, you are granted additional
  18 permissions described in the GCC Runtime Library Exception, version
  19 3.1, as published by the Free Software Foundation.
  20
  21 You should have received a copy of the GNU General Public License and
  22 a copy of the GCC Runtime Library Exception along with this program;
  23 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24 <http://www.gnu.org/licenses/>.  */
  25
  26 /* ------------------------------------------------------------------ */
  27 /* Decimal Number arithmetic module                                   */
  28 /* ------------------------------------------------------------------ */
  29 /* This module comprises the routines for arbitrary-precision General */
  30 /* Decimal Arithmetic as defined in the specification which may be    */
  31 /* found on the General Decimal Arithmetic pages.  It implements both */
  32 /* the full ('extended') arithmetic and the simpler ('subset')        */
  33 /* arithmetic.                                                        */
  34 /*                                                                    */
  35 /* Usage notes:                                                       */
  36 /*                                                                    */
  37 /* 1. This code is ANSI C89 except:                                   */
  38 /*                                                                    */
  39 /*    a) C99 line comments (double forward slash) are used.  (Most C  */
  40 /*       compilers accept these.  If yours does not, a simple script  */
  41 /*       can be used to convert them to ANSI C comments.)             */
  42 /*                                                                    */
  43 /*    b) Types from C99 stdint.h are used.  If you do not have this   */
  44 /*       header file, see the User's Guide section of the decNumber   */
  45 /*       documentation; this lists the necessary definitions.         */
  46 /*                                                                    */
  47 /*    c) If DECDPUN>4 or DECUSE64=1, the C99 64-bit int64_t and       */
  48 /*       uint64_t types may be used.  To avoid these, set DECUSE64=0  */
  49 /*       and DECDPUN<=4 (see documentation).                          */
  50 /*                                                                    */
  51 /*    The code also conforms to C99 restrictions; in particular,      */
  52 /*    strict aliasing rules are observed.                             */
  53 /*                                                                    */
  54 /* 2. The decNumber format which this library uses is optimized for   */
  55 /*    efficient processing of relatively short numbers; in particular */
  56 /*    it allows the use of fixed sized structures and minimizes copy  */
  57 /*    and move operations.  It does, however, support arbitrary       */
  58 /*    precision (up to 999,999,999 digits) and arbitrary exponent     */
  59 /*    range (Emax in the range 0 through 999,999,999 and Emin in the  */
  60 /*    range -999,999,999 through 0).  Mathematical functions (for     */
  61 /*    example decNumberExp) as identified below are restricted more   */
  62 /*    tightly: digits, emax, and -emin in the context must be <=      */
  63 /*    DEC_MAX_MATH (999999), and their operand(s) must be within      */
  64 /*    these bounds.                                                   */
  65 /*                                                                    */
  66 /* 3. Logical functions are further restricted; their operands must   */
  67 /*    be finite, positive, have an exponent of zero, and all digits   */
  68 /*    must be either 0 or 1.  The result will only contain digits     */
  69 /*    which are 0 or 1 (and will have exponent=0 and a sign of 0).    */
  70 /*                                                                    */
  71 /* 4. Operands to operator functions are never modified unless they   */
  72 /*    are also specified to be the result number (which is always     */
  73 /*    permitted).  Other than that case, operands must not overlap.   */
  74 /*                                                                    */
  75 /* 5. Error handling: the type of the error is ORed into the status   */
  76 /*    flags in the current context (decContext structure).  The       */
  77 /*    SIGFPE signal is then raised if the corresponding trap-enabler  */
  78 /*    flag in the decContext is set (is 1).                           */
  79 /*                                                                    */
  80 /*    It is the responsibility of the caller to clear the status      */
  81 /*    flags as required.                                              */
  82 /*                                                                    */
  83 /*    The result of any routine which returns a number will always    */
  84 /*    be a valid number (which may be a special value, such as an     */
  85 /*    Infinity or NaN).                                               */
  86 /*                                                                    */
  87 /* 6. The decNumber format is not an exchangeable concrete            */
  88 /*    representation as it comprises fields which may be machine-     */
  89 /*    dependent (packed or unpacked, or special length, for example). */
  90 /*    Canonical conversions to and from strings are provided; other   */
  91 /*    conversions are available in separate modules.                  */
  92 /*                                                                    */
  93 /* 7. Normally, input operands are assumed to be valid.  Set DECCHECK */
  94 /*    to 1 for extended operand checking (including NULL operands).   */
  95 /*    Results are undefined if a badly-formed structure (or a NULL    */
  96 /*    pointer to a structure) is provided, though with DECCHECK       */
  97 /*    enabled the operator routines are protected against exceptions. */
  98 /*    (Except if the result pointer is NULL, which is unrecoverable.) */
  99 /*                                                                    */
 100 /*    However, the routines will never cause exceptions if they are   */
 101 /*    given well-formed operands, even if the value of the operands   */
 102 /*    is inappropriate for the operation and DECCHECK is not set.     */
 103 /*    (Except for SIGFPE, as and where documented.)                   */
 104 /*                                                                    */
 105 /* 8. Subset arithmetic is available only if DECSUBSET is set to 1.   */
 106 /* ------------------------------------------------------------------ */
 107 /* Implementation notes for maintenance of this module:               */
 108 /*                                                                    */
 109 /* 1. Storage leak protection:  Routines which use malloc are not     */
 110 /*    permitted to use return for fastpath or error exits (i.e.,      */
 111 /*    they follow strict structured programming conventions).         */
 112 /*    Instead they have a do{}while(0); construct surrounding the     */
 113 /*    code which is protected -- break may be used to exit this.      */
 114 /*    Other routines can safely use the return statement inline.      */
 115 /*                                                                    */
 116 /*    Storage leak accounting can be enabled using DECALLOC.          */
 117 /*                                                                    */
 118 /* 2. All loops use the for(;;) construct.  Any do construct does     */
 119 /*    not loop; it is for allocation protection as just described.    */
 120 /*                                                                    */
 121 /* 3. Setting status in the context must always be the very last      */
 122 /*    action in a routine, as non-0 status may raise a trap and hence */
 123 /*    the call to set status may not return (if the handler uses long */
 124 /*    jump).  Therefore all cleanup must be done first.  In general,  */
 125 /*    to achieve this status is accumulated and is only applied just  */
 126 /*    before return by calling decContextSetStatus (via decStatus).   */
 127 /*                                                                    */
 128 /*    Routines which allocate storage cannot, in general, use the     */
 129 /*    'top level' routines which could cause a non-returning          */
 130 /*    transfer of control.  The decXxxxOp routines are safe (do not   */
 131 /*    call decStatus even if traps are set in the context) and should */
 132 /*    be used instead (they are also a little faster).                */
 133 /*                                                                    */
 134 /* 4. Exponent checking is minimized by allowing the exponent to      */
 135 /*    grow outside its limits during calculations, provided that      */
 136 /*    the decFinalize function is called later.  Multiplication and   */
 137 /*    division, and intermediate calculations in exponentiation,      */
 138 /*    require more careful checks because of the risk of 31-bit       */
 139 /*    overflow (the most negative valid exponent is -1999999997, for  */
 140 /*    a 999999999-digit number with adjusted exponent of -999999999). */
 141 /*                                                                    */
 142 /* 5. Rounding is deferred until finalization of results, with any    */
 143 /*    'off to the right' data being represented as a single digit     */
 144 /*    residue (in the range -1 through 9).  This avoids any double-   */
 145 /*    rounding when more than one shortening takes place (for         */
 146 /*    example, when a result is subnormal).                           */
 147 /*                                                                    */
 148 /* 6. The digits count is allowed to rise to a multiple of DECDPUN    */
 149 /*    during many operations, so whole Units are handled and exact    */
 150 /*    accounting of digits is not needed.  The correct digits value   */
 151 /*    is found by decGetDigits, which accounts for leading zeros.     */
 152 /*    This must be called before any rounding if the number of digits */
 153 /*    is not known exactly.                                           */
 154 /*                                                                    */
 155 /* 7. The multiply-by-reciprocal 'trick' is used for partitioning     */
 156 /*    numbers up to four digits, using appropriate constants.  This   */
 157 /*    is not useful for longer numbers because overflow of 32 bits    */
 158 /*    would lead to 4 multiplies, which is almost as expensive as     */
 159 /*    a divide (unless a floating-point or 64-bit multiply is         */
 160 /*    assumed to be available).                                       */
 161 /*                                                                    */
 162 /* 8. Unusual abbreviations that may be used in the commentary:       */
 163 /*      lhs -- left hand side (operand, of an operation)              */
 164 /*      lsd -- least significant digit (of coefficient)               */
 165 /*      lsu -- least significant Unit (of coefficient)                */
 166 /*      msd -- most significant digit (of coefficient)                */
 167 /*      msi -- most significant item (in an array)                    */
 168 /*      msu -- most significant Unit (of coefficient)                 */
 169 /*      rhs -- right hand side (operand, of an operation)             */
 170 /*      +ve -- positive                                               */
 171 /*      -ve -- negative                                               */
 172 /*      **  -- raise to the power                                     */
 173 /* ------------------------------------------------------------------ */
 174
 175 #include <stdlib.h>                /* for malloc, free, etc. */
 176 #include <stdio.h>                 /* for printf [if needed] */
 177 #include <string.h>                /* for strcpy */
 178 #include <ctype.h>                 /* for lower */
 179 #include "dconfig.h"               /* for GCC definitions */
 180 #include "decNumber.h"             /* base number library */
 181 #include "decNumberLocal.h"        /* decNumber local types, etc. */
 182
 183 /* Constants */
 184 /* Public lookup table used by the D2U macro */
 185 const uByte d2utable[DECMAXD2U+1]=D2UTABLE;
 186
 187 #define DECVERB     1              /* set to 1 for verbose DECCHECK */
 188 #define powers      DECPOWERS      /* old internal name */
 189
 190 /* Local constants */
 191 #define DIVIDE      0x80           /* Divide operators */
 192 #define REMAINDER   0x40           /* .. */
 193 #define DIVIDEINT   0x20           /* .. */
 194 #define REMNEAR     0x10           /* .. */
 195 #define COMPARE     0x01           /* Compare operators */
 196 #define COMPMAX     0x02           /* .. */
 197 #define COMPMIN     0x03           /* .. */
 198 #define COMPTOTAL   0x04           /* .. */
 199 #define COMPNAN     0x05           /* .. [NaN processing] */
 200 #define COMPSIG     0x06           /* .. [signaling COMPARE] */
 201 #define COMPMAXMAG  0x07           /* .. */
 202 #define COMPMINMAG  0x08           /* .. */
 203
 204 #define DEC_sNaN     0x40000000    /* local status: sNaN signal */
 205 #define BADINT  (Int)0x80000000    /* most-negative Int; error indicator */
 206 /* Next two indicate an integer >= 10**6, and its parity (bottom bit) */
 207 #define BIGEVEN (Int)0x80000002
 208 #define BIGODD  (Int)0x80000003
 209
 210 static Unit uarrone[1]={1};   /* Unit array of 1, used for incrementing */
 211
 212 /* Granularity-dependent code */
 213 #if DECDPUN<=4
 214   #define eInt  Int           /* extended integer */
 215   #define ueInt uInt          /* unsigned extended integer */
 216   /* Constant multipliers for divide-by-power-of five using reciprocal */
 217   /* multiply, after removing powers of 2 by shifting, and final shift */
 218   /* of 17 [we only need up to **4] */
 219   static const uInt multies[]={131073, 26215, 5243, 1049, 210};
 220   /* QUOT10 -- macro to return the quotient of unit u divided by 10**n */
 221   #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
 222 #else
 223   /* For DECDPUN>4 non-ANSI-89 64-bit types are needed. */
 224   #if !DECUSE64
 225     #error decNumber.c: DECUSE64 must be 1 when DECDPUN>4
 226   #endif
 227   #define eInt  Long          /* extended integer */
 228   #define ueInt uLong         /* unsigned extended integer */
 229 #endif
 230
 231 /* Local routines */
 232 static decNumber * decAddOp(decNumber *, const decNumber *, const decNumber *,
 233                               decContext *, uByte, uInt *);
 234 static Flag        decBiStr(const char *, const char *, const char *);
 235 static uInt        decCheckMath(const decNumber *, decContext *, uInt *);
 236 static void        decApplyRound(decNumber *, decContext *, Int, uInt *);
 237 static Int         decCompare(const decNumber *lhs, const decNumber *rhs, Flag);
 238 static decNumber * decCompareOp(decNumber *, const decNumber *,
 239                               const decNumber *, decContext *,
 240                               Flag, uInt *);
 241 static void        decCopyFit(decNumber *, const decNumber *, decContext *,
 242                               Int *, uInt *);
 243 static decNumber * decDecap(decNumber *, Int);
 244 static decNumber * decDivideOp(decNumber *, const decNumber *,
 245                               const decNumber *, decContext *, Flag, uInt *);
 246 static decNumber * decExpOp(decNumber *, const decNumber *,
 247                               decContext *, uInt *);
 248 static void        decFinalize(decNumber *, decContext *, Int *, uInt *);
 249 static Int         decGetDigits(Unit *, Int);
 250 static Int         decGetInt(const decNumber *);
 251 static decNumber * decLnOp(decNumber *, const decNumber *,
 252                               decContext *, uInt *);
 253 static decNumber * decMultiplyOp(decNumber *, const decNumber *,
 254                               const decNumber *, decContext *,
 255                               uInt *);
 256 static decNumber * decNaNs(decNumber *, const decNumber *,
 257                               const decNumber *, decContext *, uInt *);
 258 static decNumber * decQuantizeOp(decNumber *, const decNumber *,
 259                               const decNumber *, decContext *, Flag,
 260                               uInt *);
 261 static void        decReverse(Unit *, Unit *);
 262 static void        decSetCoeff(decNumber *, decContext *, const Unit *,
 263                               Int, Int *, uInt *);
 264 static void        decSetMaxValue(decNumber *, decContext *);
 265 static void        decSetOverflow(decNumber *, decContext *, uInt *);
 266 static void        decSetSubnormal(decNumber *, decContext *, Int *, uInt *);
 267 static Int         decShiftToLeast(Unit *, Int, Int);
 268 static Int         decShiftToMost(Unit *, Int, Int);
 269 static void        decStatus(decNumber *, uInt, decContext *);
 270 static void        decToString(const decNumber *, char[], Flag);
 271 static decNumber * decTrim(decNumber *, decContext *, Flag, Flag, Int *);
 272 static Int         decUnitAddSub(const Unit *, Int, const Unit *, Int, Int,
 273                               Unit *, Int);
 274 static Int         decUnitCompare(const Unit *, Int, const Unit *, Int, Int);
 275
 276 #if !DECSUBSET
 277 /* decFinish == decFinalize when no subset arithmetic needed */
 278 #define decFinish(a,b,c,d) decFinalize(a,b,c,d)
 279 #else
 280 static void        decFinish(decNumber *, decContext *, Int *, uInt *);
 281 static decNumber * decRoundOperand(const decNumber *, decContext *, uInt *);
 282 #endif
 283
 284 /* Local macros */
 285 /* masked special-values bits */
 286 #define SPECIALARG  (rhs->bits & DECSPECIAL)
 287 #define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL)
 288
 289 /* Diagnostic macros, etc. */
 290 #if DECALLOC
 291 /* Handle malloc/free accounting.  If enabled, our accountable routines */
 292 /* are used; otherwise the code just goes straight to the system malloc */
 293 /* and free routines. */
 294 #define malloc(a) decMalloc(a)
 295 #define free(a) decFree(a)
 296 #define DECFENCE 0x5a              /* corruption detector */
 297 /* 'Our' malloc and free: */
 298 static void *decMalloc(size_t);
 299 static void  decFree(void *);
 300 uInt decAllocBytes=0;              /* count of bytes allocated */
 301 /* Note that DECALLOC code only checks for storage buffer overflow. */
 302 /* To check for memory leaks, the decAllocBytes variable must be */
 303 /* checked to be 0 at appropriate times (e.g., after the test */
 304 /* harness completes a set of tests).  This checking may be unreliable */
 305 /* if the testing is done in a multi-thread environment. */
 306 #endif
 307
 308 #if DECCHECK
 309 /* Optional checking routines.  Enabling these means that decNumber */
 310 /* and decContext operands to operator routines are checked for */
 311 /* correctness.  This roughly doubles the execution time of the */
 312 /* fastest routines (and adds 600+ bytes), so should not normally be */
 313 /* used in 'production'. */
 314 /* decCheckInexact is used to check that inexact results have a full */
 315 /* complement of digits (where appropriate -- this is not the case */
 316 /* for Quantize, for example) */
 317 #define DECUNRESU ((decNumber *)(void *)0xffffffff)
 318 #define DECUNUSED ((const decNumber *)(void *)0xffffffff)
 319 #define DECUNCONT ((decContext *)(void *)(0xffffffff))
 320 static Flag decCheckOperands(decNumber *, const decNumber *,
 321                              const decNumber *, decContext *);
 322 static Flag decCheckNumber(const decNumber *);
 323 static void decCheckInexact(const decNumber *, decContext *);
 324 #endif
 325
 326 #if DECTRACE || DECCHECK
 327 /* Optional trace/debugging routines (may or may not be used) */
 328 void decNumberShow(const decNumber *);  /* displays the components of a number */
 329 static void decDumpAr(char, const Unit *, Int);
 330 #endif
 331
 332 /* ================================================================== */
 333 /* Conversions                                                        */
 334 /* ================================================================== */
 335
 336 /* ------------------------------------------------------------------ */
 337 /* from-int32 -- conversion from Int or uInt                          */
 338 /*                                                                    */
 339 /*  dn is the decNumber to receive the integer                        */
 340 /*  in or uin is the integer to be converted                          */
 341 /*  returns dn                                                        */
 342 /*                                                                    */
 343 /* No error is possible.                                              */
 344 /* ------------------------------------------------------------------ */
 345 decNumber * decNumberFromInt32(decNumber *dn, Int in) {
 346   uInt unsig;
 347   if (in>=0) unsig=in;
 348    else {                               /* negative (possibly BADINT) */
 349     if (in==BADINT) unsig=(uInt)1073741824*2; /* special case */
 350      else unsig=-in;                    /* invert */
 351     }
 352   /* in is now positive */
 353   decNumberFromUInt32(dn, unsig);
 354   if (in<0) dn->bits=DECNEG;            /* sign needed */
 355   return dn;
 356   } /* decNumberFromInt32 */
 357
 358 decNumber * decNumberFromUInt32(decNumber *dn, uInt uin) {
 359   Unit *up;                             /* work pointer */
 360   decNumberZero(dn);                    /* clean */
 361   if (uin==0) return dn;                /* [or decGetDigits bad call] */
 362   for (up=dn->lsu; uin>0; up++) {
 363     *up=(Unit)(uin%(DECDPUNMAX+1));
 364     uin=uin/(DECDPUNMAX+1);
 365     }
 366   dn->digits=decGetDigits(dn->lsu, up-dn->lsu);
 367   return dn;
 368   } /* decNumberFromUInt32 */
 369
 370 /* ------------------------------------------------------------------ */
 371 /* to-int32 -- conversion to Int or uInt                              */
 372 /*                                                                    */
 373 /*  dn is the decNumber to convert                                    */
 374 /*  set is the context for reporting errors                           */
 375 /*  returns the converted decNumber, or 0 if Invalid is set           */
 376 /*                                                                    */
 377 /* Invalid is set if the decNumber does not have exponent==0 or if    */
 378 /* it is a NaN, Infinite, or out-of-range.                            */
 379 /* ------------------------------------------------------------------ */
 380 Int decNumberToInt32(const decNumber *dn, decContext *set) {
 381   #if DECCHECK
 382   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
 383   #endif
 384
 385   /* special or too many digits, or bad exponent */
 386   if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; /* bad */
 387    else { /* is a finite integer with 10 or fewer digits */
 388     Int d;                         /* work */
 389     const Unit *up;                /* .. */
 390     uInt hi=0, lo;                 /* .. */
 391     up=dn->lsu;                    /* -> lsu */
 392     lo=*up;                        /* get 1 to 9 digits */
 393     #if DECDPUN>1                  /* split to higher */
 394       hi=lo/10;
 395       lo=lo%10;
 396     #endif
 397     up++;
 398     /* collect remaining Units, if any, into hi */
 399     for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
 400     /* now low has the lsd, hi the remainder */
 401     if (hi>214748364 || (hi==214748364 && lo>7)) { /* out of range? */
 402       /* most-negative is a reprieve */
 403       if (dn->bits&DECNEG && hi==214748364 && lo==8) return 0x80000000;
 404       /* bad -- drop through */
 405       }
 406      else { /* in-range always */
 407       Int i=X10(hi)+lo;
 408       if (dn->bits&DECNEG) return -i;
 409       return i;
 410       }
 411     } /* integer */
 412   decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
 413   return 0;
 414   } /* decNumberToInt32 */
 415
 416 uInt decNumberToUInt32(const decNumber *dn, decContext *set) {
 417   #if DECCHECK
 418   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
 419   #endif
 420   /* special or too many digits, or bad exponent, or negative (<0) */
 421   if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0
 422     || (dn->bits&DECNEG && !ISZERO(dn)));                   /* bad */
 423    else { /* is a finite integer with 10 or fewer digits */
 424     Int d;                         /* work */
 425     const Unit *up;                /* .. */
 426     uInt hi=0, lo;                 /* .. */
 427     up=dn->lsu;                    /* -> lsu */
 428     lo=*up;                        /* get 1 to 9 digits */
 429     #if DECDPUN>1                  /* split to higher */
 430       hi=lo/10;
 431       lo=lo%10;
 432     #endif
 433     up++;
 434     /* collect remaining Units, if any, into hi */
 435     for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
 436
 437     /* now low has the lsd, hi the remainder */
 438     if (hi>429496729 || (hi==429496729 && lo>5)) ; /* no reprieve possible */
 439      else return X10(hi)+lo;
 440     } /* integer */
 441   decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
 442   return 0;
 443   } /* decNumberToUInt32 */
 444
 445 /* ------------------------------------------------------------------ */
 446 /* to-scientific-string -- conversion to numeric string               */
 447 /* to-engineering-string -- conversion to numeric string              */
 448 /*                                                                    */
 449 /*   decNumberToString(dn, string);                                   */
 450 /*   decNumberToEngString(dn, string);                                */
 451 /*                                                                    */
 452 /*  dn is the decNumber to convert                                    */
 453 /*  string is the string where the result will be laid out            */
 454 /*                                                                    */
 455 /*  string must be at least dn->digits+14 characters long             */
 456 /*                                                                    */
 457 /*  No error is possible, and no status can be set.                   */
 458 /* ------------------------------------------------------------------ */
 459 char * decNumberToString(const decNumber *dn, char *string){
 460   decToString(dn, string, 0);
 461   return string;
 462   } /* DecNumberToString */
 463
 464 char * decNumberToEngString(const decNumber *dn, char *string){
 465   decToString(dn, string, 1);
 466   return string;
 467   } /* DecNumberToEngString */
 468
 469 /* ------------------------------------------------------------------ */
 470 /* to-number -- conversion from numeric string                        */
 471 /*                                                                    */
 472 /* decNumberFromString -- convert string to decNumber                 */
 473 /*   dn        -- the number structure to fill                        */
 474 /*   chars[]   -- the string to convert ('\0' terminated)             */
 475 /*   set       -- the context used for processing any error,          */
 476 /*                determining the maximum precision available         */
 477 /*                (set.digits), determining the maximum and minimum   */
 478 /*                exponent (set.emax and set.emin), determining if    */
 479 /*                extended values are allowed, and checking the       */
 480 /*                rounding mode if overflow occurs or rounding is     */
 481 /*                needed.                                             */
 482 /*                                                                    */
 483 /* The length of the coefficient and the size of the exponent are     */
 484 /* checked by this routine, so the correct error (Underflow or        */
 485 /* Overflow) can be reported or rounding applied, as necessary.       */
 486 /*                                                                    */
 487 /* If bad syntax is detected, the result will be a quiet NaN.         */
 488 /* ------------------------------------------------------------------ */
 489 decNumber * decNumberFromString(decNumber *dn, const char chars[],
 490                                 decContext *set) {
 491   Int   exponent=0;                /* working exponent [assume 0] */
 492   uByte bits=0;                    /* working flags [assume +ve] */
 493   Unit  *res;                      /* where result will be built */
 494   Unit  resbuff[SD2U(DECBUFFER+9)];/* local buffer in case need temporary */
 495                                    /* [+9 allows for ln() constants] */
 496   Unit  *allocres=NULL;            /* -> allocated result, iff allocated */
 497   Int   d=0;                       /* count of digits found in decimal part */
 498   const char *dotchar=NULL;        /* where dot was found */
 499   const char *cfirst=chars;        /* -> first character of decimal part */
 500   const char *last=NULL;           /* -> last digit of decimal part */
 501   const char *c;                   /* work */
 502   Unit  *up;                       /* .. */
 503   #if DECDPUN>1
 504   Int   cut, out;                  /* .. */
 505   #endif
 506   Int   residue;                   /* rounding residue */
 507   uInt  status=0;                  /* error code */
 508
 509   #if DECCHECK
 510   if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set))
 511     return decNumberZero(dn);
 512   #endif
 513
 514   do {                             /* status & malloc protection */
 515     for (c=chars;; c++) {          /* -> input character */
 516       if (*c>='0' && *c<='9') {    /* test for Arabic digit */
 517         last=c;
 518         d++;                       /* count of real digits */
 519         continue;                  /* still in decimal part */
 520         }
 521       if (*c=='.' && dotchar==NULL) { /* first '.' */
 522         dotchar=c;                 /* record offset into decimal part */
 523         if (c==cfirst) cfirst++;   /* first digit must follow */
 524         continue;}
 525       if (c==chars) {              /* first in string... */
 526         if (*c=='-') {             /* valid - sign */
 527           cfirst++;
 528           bits=DECNEG;
 529           continue;}
 530         if (*c=='+') {             /* valid + sign */
 531           cfirst++;
 532           continue;}
 533         }
 534       /* *c is not a digit, or a valid +, -, or '.' */
 535       break;
 536       } /* c */
 537
 538     if (last==NULL) {              /* no digits yet */
 539       status=DEC_Conversion_syntax;/* assume the worst */
 540       if (*c=='\0') break;         /* and no more to come... */
 541       #if DECSUBSET
 542       /* if subset then infinities and NaNs are not allowed */
 543       if (!set->extended) break;   /* hopeless */
 544       #endif
 545       /* Infinities and NaNs are possible, here */
 546       if (dotchar!=NULL) break;    /* .. unless had a dot */
 547       decNumberZero(dn);           /* be optimistic */
 548       if (decBiStr(c, "infinity", "INFINITY")
 549        || decBiStr(c, "inf", "INF")) {
 550         dn->bits=bits | DECINF;
 551         status=0;                  /* is OK */
 552         break; /* all done */
 553         }
 554       /* a NaN expected */
 555       /* 2003.09.10 NaNs are now permitted to have a sign */
 556       dn->bits=bits | DECNAN;      /* assume simple NaN */
 557       if (*c=='s' || *c=='S') {    /* looks like an sNaN */
 558         c++;
 559         dn->bits=bits | DECSNAN;
 560         }
 561       if (*c!='n' && *c!='N') break;    /* check caseless "NaN" */
 562       c++;
 563       if (*c!='a' && *c!='A') break;    /* .. */
 564       c++;
 565       if (*c!='n' && *c!='N') break;    /* .. */
 566       c++;
 567       /* now either nothing, or nnnn payload, expected */
 568       /* -> start of integer and skip leading 0s [including plain 0] */
 569       for (cfirst=c; *cfirst=='0';) cfirst++;
 570       if (*cfirst=='\0') {         /* "NaN" or "sNaN", maybe with all 0s */
 571         status=0;                  /* it's good */
 572         break;                     /* .. */
 573         }
 574       /* something other than 0s; setup last and d as usual [no dots] */
 575       for (c=cfirst;; c++, d++) {
 576         if (*c<'0' || *c>'9') break; /* test for Arabic digit */
 577         last=c;
 578         }
 579       if (*c!='\0') break;         /* not all digits */
 580       if (d>set->digits-1) {
 581         /* [NB: payload in a decNumber can be full length unless */
 582         /* clamped, in which case can only be digits-1] */
 583         if (set->clamp) break;
 584         if (d>set->digits) break;
 585         } /* too many digits? */
 586       /* good; drop through to convert the integer to coefficient */
 587       status=0;                    /* syntax is OK */
 588       bits=dn->bits;               /* for copy-back */
 589       } /* last==NULL */
 590
 591      else if (*c!='\0') {          /* more to process... */
 592       /* had some digits; exponent is only valid sequence now */
 593       Flag nege;                   /* 1=negative exponent */
 594       const char *firstexp;        /* -> first significant exponent digit */
 595       status=DEC_Conversion_syntax;/* assume the worst */
 596       if (*c!='e' && *c!='E') break;
 597       /* Found 'e' or 'E' -- now process explicit exponent */
 598       /* 1998.07.11: sign no longer required */
 599       nege=0;
 600       c++;                         /* to (possible) sign */
 601       if (*c=='-') {nege=1; c++;}
 602        else if (*c=='+') c++;
 603       if (*c=='\0') break;
 604
 605       for (; *c=='0' && *(c+1)!='\0';) c++;  /* strip insignificant zeros */
 606       firstexp=c;                            /* save exponent digit place */
 607       for (; ;c++) {
 608         if (*c<'0' || *c>'9') break;         /* not a digit */
 609         exponent=X10(exponent)+(Int)*c-(Int)'0';
 610         } /* c */
 611       /* if not now on a '\0', *c must not be a digit */
 612       if (*c!='\0') break;
 613
 614       /* (this next test must be after the syntax checks) */
 615       /* if it was too long the exponent may have wrapped, so check */
 616       /* carefully and set it to a certain overflow if wrap possible */
 617       if (c>=firstexp+9+1) {
 618         if (c>firstexp+9+1 || *firstexp>'1') exponent=DECNUMMAXE*2;
 619         /* [up to 1999999999 is OK, for example 1E-1000000998] */
 620         }
 621       if (nege) exponent=-exponent;     /* was negative */
 622       status=0;                         /* is OK */
 623       } /* stuff after digits */
 624
 625     /* Here when whole string has been inspected; syntax is good */
 626     /* cfirst->first digit (never dot), last->last digit (ditto) */
 627
 628     /* strip leading zeros/dot [leave final 0 if all 0's] */
 629     if (*cfirst=='0') {                 /* [cfirst has stepped over .] */
 630       for (c=cfirst; c<last; c++, cfirst++) {
 631         if (*c=='.') continue;          /* ignore dots */
 632         if (*c!='0') break;             /* non-zero found */
 633         d--;                            /* 0 stripped */
 634         } /* c */
 635       #if DECSUBSET
 636       /* make a rapid exit for easy zeros if !extended */
 637       if (*cfirst=='0' && !set->extended) {
 638         decNumberZero(dn);              /* clean result */
 639         break;                          /* [could be return] */
 640         }
 641       #endif
 642       } /* at least one leading 0 */
 643
 644     /* Handle decimal point... */
 645     if (dotchar!=NULL && dotchar<last)  /* non-trailing '.' found? */
 646       exponent-=(last-dotchar);         /* adjust exponent */
 647     /* [we can now ignore the .] */
 648
 649     /* OK, the digits string is good.  Assemble in the decNumber, or in */
 650     /* a temporary units array if rounding is needed */
 651     if (d<=set->digits) res=dn->lsu;    /* fits into supplied decNumber */
 652      else {                             /* rounding needed */
 653       Int needbytes=D2U(d)*sizeof(Unit);/* bytes needed */
 654       res=resbuff;                      /* assume use local buffer */
 655       if (needbytes>(Int)sizeof(resbuff)) { /* too big for local */
 656         allocres=(Unit *)malloc(needbytes);
 657         if (allocres==NULL) {status|=DEC_Insufficient_storage; break;}
 658         res=allocres;
 659         }
 660       }
 661     /* res now -> number lsu, buffer, or allocated storage for Unit array */
 662
 663     /* Place the coefficient into the selected Unit array */
 664     /* [this is often 70% of the cost of this function when DECDPUN>1] */
 665     #if DECDPUN>1
 666     out=0;                         /* accumulator */
 667     up=res+D2U(d)-1;               /* -> msu */
 668     cut=d-(up-res)*DECDPUN;        /* digits in top unit */
 669     for (c=cfirst;; c++) {         /* along the digits */
 670       if (*c=='.') continue;       /* ignore '.' [don't decrement cut] */
 671       out=X10(out)+(Int)*c-(Int)'0';
 672       if (c==last) break;          /* done [never get to trailing '.'] */
 673       cut--;
 674       if (cut>0) continue;         /* more for this unit */
 675       *up=(Unit)out;               /* write unit */
 676       up--;                        /* prepare for unit below.. */
 677       cut=DECDPUN;                 /* .. */
 678       out=0;                       /* .. */
 679       } /* c */
 680     *up=(Unit)out;                 /* write lsu */
 681
 682     #else
 683     /* DECDPUN==1 */
 684     up=res;                        /* -> lsu */
 685     for (c=last; c>=cfirst; c--) { /* over each character, from least */
 686       if (*c=='.') continue;       /* ignore . [don't step up] */
 687       *up=(Unit)((Int)*c-(Int)'0');
 688       up++;
 689       } /* c */
 690     #endif
 691
 692     dn->bits=bits;
 693     dn->exponent=exponent;
 694     dn->digits=d;
 695
 696     /* if not in number (too long) shorten into the number */
 697     if (d>set->digits) {
 698       residue=0;
 699       decSetCoeff(dn, set, res, d, &residue, &status);
 700       /* always check for overflow or subnormal and round as needed */
 701       decFinalize(dn, set, &residue, &status);
 702       }
 703      else { /* no rounding, but may still have overflow or subnormal */
 704       /* [these tests are just for performance; finalize repeats them] */
 705       if ((dn->exponent-1<set->emin-dn->digits)
 706        || (dn->exponent-1>set->emax-set->digits)) {
 707         residue=0;
 708         decFinalize(dn, set, &residue, &status);
 709         }
 710       }
 711     /* decNumberShow(dn); */
 712     } while(0);                         /* [for break] */
 713
 714   free(allocres);       /* drop any storage used */
 715   if (status!=0) decStatus(dn, status, set);
 716   return dn;
 717   } /* decNumberFromString */
 718
 719 /* ================================================================== */
 720 /* Operators                                                          */
 721 /* ================================================================== */
 722
 723 /* ------------------------------------------------------------------ */
 724 /* decNumberAbs -- absolute value operator                            */
 725 /*                                                                    */
 726 /*   This computes C = abs(A)                                         */
 727 /*                                                                    */
 728 /*   res is C, the result.  C may be A                                */
 729 /*   rhs is A                                                         */
 730 /*   set is the context                                               */
 731 /*                                                                    */
 732 /* See also decNumberCopyAbs for a quiet bitwise version of this.     */
 733 /* C must have space for set->digits digits.                          */
 734 /* ------------------------------------------------------------------ */
 735 /* This has the same effect as decNumberPlus unless A is negative,    */
 736 /* in which case it has the same effect as decNumberMinus.            */
 737 /* ------------------------------------------------------------------ */
 738 decNumber * decNumberAbs(decNumber *res, const decNumber *rhs,
 739                          decContext *set) {
 740   decNumber dzero;                      /* for 0 */
 741   uInt status=0;                        /* accumulator */
 742
 743   #if DECCHECK
 744   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
 745   #endif
 746
 747   decNumberZero(&dzero);                /* set 0 */
 748   dzero.exponent=rhs->exponent;         /* [no coefficient expansion] */
 749   decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status);
 750   if (status!=0) decStatus(res, status, set);
 751   #if DECCHECK
 752   decCheckInexact(res, set);
 753   #endif
 754   return res;
 755   } /* decNumberAbs */
 756
 757 /* ------------------------------------------------------------------ */
 758 /* decNumberAdd -- add two Numbers                                    */
 759 /*                                                                    */
 760 /*   This computes C = A + B                                          */
 761 /*                                                                    */
 762 /*   res is C, the result.  C may be A and/or B (e.g., X=X+X)         */
 763 /*   lhs is A                                                         */
 764 /*   rhs is B                                                         */
 765 /*   set is the context                                               */
 766 /*                                                                    */
 767 /* C must have space for set->digits digits.                          */
 768 /* ------------------------------------------------------------------ */
 769 /* This just calls the routine shared with Subtract                   */
 770 decNumber * decNumberAdd(decNumber *res, const decNumber *lhs,
 771                          const decNumber *rhs, decContext *set) {
 772   uInt status=0;                        /* accumulator */
 773   decAddOp(res, lhs, rhs, set, 0, &status);
 774   if (status!=0) decStatus(res, status, set);
 775   #if DECCHECK
 776   decCheckInexact(res, set);
 777   #endif
 778   return res;
 779   } /* decNumberAdd */
 780
 781 /* ------------------------------------------------------------------ */
 782 /* decNumberAnd -- AND two Numbers, digitwise                         */
 783 /*                                                                    */
 784 /*   This computes C = A & B                                          */
 785 /*                                                                    */
 786 /*   res is C, the result.  C may be A and/or B (e.g., X=X&X)         */
 787 /*   lhs is A                                                         */
 788 /*   rhs is B                                                         */
 789 /*   set is the context (used for result length and error report)     */
 790 /*                                                                    */
 791 /* C must have space for set->digits digits.                          */
 792 /*                                                                    */
 793 /* Logical function restrictions apply (see above); a NaN is          */
 794 /* returned with Invalid_operation if a restriction is violated.      */
 795 /* ------------------------------------------------------------------ */
 796 decNumber * decNumberAnd(decNumber *res, const decNumber *lhs,
 797                          const decNumber *rhs, decContext *set) {
 798   const Unit *ua, *ub;                  /* -> operands */
 799   const Unit *msua, *msub;              /* -> operand msus */
 800   Unit *uc,  *msuc;                     /* -> result and its msu */
 801   Int   msudigs;                        /* digits in res msu */
 802   #if DECCHECK
 803   if (decCheckOperands(res, lhs, rhs, set)) return res;
 804   #endif
 805
 806   if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
 807    || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
 808     decStatus(res, DEC_Invalid_operation, set);
 809     return res;
 810     }
 811
 812   /* operands are valid */
 813   ua=lhs->lsu;                          /* bottom-up */
 814   ub=rhs->lsu;                          /* .. */
 815   uc=res->lsu;                          /* .. */
 816   msua=ua+D2U(lhs->digits)-1;           /* -> msu of lhs */
 817   msub=ub+D2U(rhs->digits)-1;           /* -> msu of rhs */
 818   msuc=uc+D2U(set->digits)-1;           /* -> msu of result */
 819   msudigs=MSUDIGITS(set->digits);       /* [faster than remainder] */
 820   for (; uc<=msuc; ua++, ub++, uc++) {  /* Unit loop */
 821     Unit a, b;                          /* extract units */
 822     if (ua>msua) a=0;
 823      else a=*ua;
 824     if (ub>msub) b=0;
 825      else b=*ub;
 826     *uc=0;                              /* can now write back */
 827     if (a|b) {                          /* maybe 1 bits to examine */
 828       Int i, j;
 829       *uc=0;                            /* can now write back */
 830       /* This loop could be unrolled and/or use BIN2BCD tables */
 831       for (i=0; i<DECDPUN; i++) {
 832         if (a&b&1) *uc=*uc+(Unit)powers[i];  /* effect AND */
 833         j=a%10;
 834         a=a/10;
 835         j|=b%10;
 836         b=b/10;
 837         if (j>1) {
 838           decStatus(res, DEC_Invalid_operation, set);
 839           return res;
 840           }
 841         if (uc==msuc && i==msudigs-1) break; /* just did final digit */
 842         } /* each digit */
 843       } /* both OK */
 844     } /* each unit */
 845   /* [here uc-1 is the msu of the result] */
 846   res->digits=decGetDigits(res->lsu, uc-res->lsu);
 847   res->exponent=0;                      /* integer */
 848   res->bits=0;                          /* sign=0 */
 849   return res;  /* [no status to set] */
 850   } /* decNumberAnd */
 851
 852 /* ------------------------------------------------------------------ */
 853 /* decNumberCompare -- compare two Numbers                            */
 854 /*                                                                    */
 855 /*   This computes C = A ? B                                          */
 856 /*                                                                    */
 857 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
 858 /*   lhs is A                                                         */
 859 /*   rhs is B                                                         */
 860 /*   set is the context                                               */
 861 /*                                                                    */
 862 /* C must have space for one digit (or NaN).                          */
 863 /* ------------------------------------------------------------------ */
 864 decNumber * decNumberCompare(decNumber *res, const decNumber *lhs,
 865                              const decNumber *rhs, decContext *set) {
 866   uInt status=0;                        /* accumulator */
 867   decCompareOp(res, lhs, rhs, set, COMPARE, &status);
 868   if (status!=0) decStatus(res, status, set);
 869   return res;
 870   } /* decNumberCompare */
 871
 872 /* ------------------------------------------------------------------ */
 873 /* decNumberCompareSignal -- compare, signalling on all NaNs          */
 874 /*                                                                    */
 875 /*   This computes C = A ? B                                          */
 876 /*                                                                    */
 877 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
 878 /*   lhs is A                                                         */
 879 /*   rhs is B                                                         */
 880 /*   set is the context                                               */
 881 /*                                                                    */
 882 /* C must have space for one digit (or NaN).                          */
 883 /* ------------------------------------------------------------------ */
 884 decNumber * decNumberCompareSignal(decNumber *res, const decNumber *lhs,
 885                                    const decNumber *rhs, decContext *set) {
 886   uInt status=0;                        /* accumulator */
 887   decCompareOp(res, lhs, rhs, set, COMPSIG, &status);
 888   if (status!=0) decStatus(res, status, set);
 889   return res;
 890   } /* decNumberCompareSignal */
 891
 892 /* ------------------------------------------------------------------ */
 893 /* decNumberCompareTotal -- compare two Numbers, using total ordering */
 894 /*                                                                    */
 895 /*   This computes C = A ? B, under total ordering                    */
 896 /*                                                                    */
 897 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
 898 /*   lhs is A                                                         */
 899 /*   rhs is B                                                         */
 900 /*   set is the context                                               */
 901 /*                                                                    */
 902 /* C must have space for one digit; the result will always be one of  */
 903 /* -1, 0, or 1.                                                       */
 904 /* ------------------------------------------------------------------ */
 905 decNumber * decNumberCompareTotal(decNumber *res, const decNumber *lhs,
 906                                   const decNumber *rhs, decContext *set) {
 907   uInt status=0;                        /* accumulator */
 908   decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
 909   if (status!=0) decStatus(res, status, set);
 910   return res;
 911   } /* decNumberCompareTotal */
 912
 913 /* ------------------------------------------------------------------ */
 914 /* decNumberCompareTotalMag -- compare, total ordering of magnitudes  */
 915 /*                                                                    */
 916 /*   This computes C = |A| ? |B|, under total ordering                */
 917 /*                                                                    */
 918 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
 919 /*   lhs is A                                                         */
 920 /*   rhs is B                                                         */
 921 /*   set is the context                                               */
 922 /*                                                                    */
 923 /* C must have space for one digit; the result will always be one of  */
 924 /* -1, 0, or 1.                                                       */
 925 /* ------------------------------------------------------------------ */
 926 decNumber * decNumberCompareTotalMag(decNumber *res, const decNumber *lhs,
 927                                      const decNumber *rhs, decContext *set) {
 928   uInt status=0;                   /* accumulator */
 929   uInt needbytes;                  /* for space calculations */
 930   decNumber bufa[D2N(DECBUFFER+1)];/* +1 in case DECBUFFER=0 */
 931   decNumber *allocbufa=NULL;       /* -> allocated bufa, iff allocated */
 932   decNumber bufb[D2N(DECBUFFER+1)];
 933   decNumber *allocbufb=NULL;       /* -> allocated bufb, iff allocated */
 934   decNumber *a, *b;                /* temporary pointers */
 935
 936   #if DECCHECK
 937   if (decCheckOperands(res, lhs, rhs, set)) return res;
 938   #endif
 939
 940   do {                                  /* protect allocated storage */
 941     /* if either is negative, take a copy and absolute */
 942     if (decNumberIsNegative(lhs)) {     /* lhs<0 */
 943       a=bufa;
 944       needbytes=sizeof(decNumber)+(D2U(lhs->digits)-1)*sizeof(Unit);
 945       if (needbytes>sizeof(bufa)) {     /* need malloc space */
 946         allocbufa=(decNumber *)malloc(needbytes);
 947         if (allocbufa==NULL) {          /* hopeless -- abandon */
 948           status|=DEC_Insufficient_storage;
 949           break;}
 950         a=allocbufa;                    /* use the allocated space */
 951         }
 952       decNumberCopy(a, lhs);            /* copy content */
 953       a->bits&=~DECNEG;                 /* .. and clear the sign */
 954       lhs=a;                            /* use copy from here on */
 955       }
 956     if (decNumberIsNegative(rhs)) {     /* rhs<0 */
 957       b=bufb;
 958       needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
 959       if (needbytes>sizeof(bufb)) {     /* need malloc space */
 960         allocbufb=(decNumber *)malloc(needbytes);
 961         if (allocbufb==NULL) {          /* hopeless -- abandon */
 962           status|=DEC_Insufficient_storage;
 963           break;}
 964         b=allocbufb;                    /* use the allocated space */
 965         }
 966       decNumberCopy(b, rhs);            /* copy content */
 967       b->bits&=~DECNEG;                 /* .. and clear the sign */
 968       rhs=b;                            /* use copy from here on */
 969       }
 970     decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
 971     } while(0);                         /* end protected */
 972
 973   free(allocbufa); /* drop any storage used */
 974   free(allocbufb); /* .. */
 975   if (status!=0) decStatus(res, status, set);
 976   return res;
 977   } /* decNumberCompareTotalMag */
 978
 979 /* ------------------------------------------------------------------ */
 980 /* decNumberDivide -- divide one number by another                    */
 981 /*                                                                    */
 982 /*   This computes C = A / B                                          */
 983 /*                                                                    */
 984 /*   res is C, the result.  C may be A and/or B (e.g., X=X/X)         */
 985 /*   lhs is A                                                         */
 986 /*   rhs is B                                                         */
 987 /*   set is the context                                               */
 988 /*                                                                    */
 989 /* C must have space for set->digits digits.                          */
 990 /* ------------------------------------------------------------------ */
 991 decNumber * decNumberDivide(decNumber *res, const decNumber *lhs,
 992                             const decNumber *rhs, decContext *set) {
 993   uInt status=0;                        /* accumulator */
 994   decDivideOp(res, lhs, rhs, set, DIVIDE, &status);
 995   if (status!=0) decStatus(res, status, set);
 996   #if DECCHECK
 997   decCheckInexact(res, set);
 998   #endif
 999   return res;
1000   } /* decNumberDivide */
1001
1002 /* ------------------------------------------------------------------ */
1003 /* decNumberDivideInteger -- divide and return integer quotient       */
1004 /*                                                                    */
1005 /*   This computes C = A # B, where # is the integer divide operator  */
1006 /*                                                                    */
1007 /*   res is C, the result.  C may be A and/or B (e.g., X=X#X)         */
1008 /*   lhs is A                                                         */
1009 /*   rhs is B                                                         */
1010 /*   set is the context                                               */
1011 /*                                                                    */
1012 /* C must have space for set->digits digits.                          */
1013 /* ------------------------------------------------------------------ */
1014 decNumber * decNumberDivideInteger(decNumber *res, const decNumber *lhs,
1015                                    const decNumber *rhs, decContext *set) {
1016   uInt status=0;                        /* accumulator */
1017   decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status);
1018   if (status!=0) decStatus(res, status, set);
1019   return res;
1020   } /* decNumberDivideInteger */
1021
1022 /* ------------------------------------------------------------------ */
1023 /* decNumberExp -- exponentiation                                     */
1024 /*                                                                    */
1025 /*   This computes C = exp(A)                                         */
1026 /*                                                                    */
1027 /*   res is C, the result.  C may be A                                */
1028 /*   rhs is A                                                         */
1029 /*   set is the context; note that rounding mode has no effect        */
1030 /*                                                                    */
1031 /* C must have space for set->digits digits.                          */
1032 /*                                                                    */
1033 /* Mathematical function restrictions apply (see above); a NaN is     */
1034 /* returned with Invalid_operation if a restriction is violated.      */
1035 /*                                                                    */
1036 /* Finite results will always be full precision and Inexact, except   */
1037 /* when A is a zero or -Infinity (giving 1 or 0 respectively).        */
1038 /*                                                                    */
1039 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
1040 /* almost always be correctly rounded, but may be up to 1 ulp in      */
1041 /* error in rare cases.                                               */
1042 /* ------------------------------------------------------------------ */
1043 /* This is a wrapper for decExpOp which can handle the slightly wider */
1044 /* (double) range needed by Ln (which has to be able to calculate     */
1045 /* exp(-a) where a can be the tiniest number (Ntiny).                 */
1046 /* ------------------------------------------------------------------ */
1047 decNumber * decNumberExp(decNumber *res, const decNumber *rhs,
1048                          decContext *set) {
1049   uInt status=0;                        /* accumulator */
1050   #if DECSUBSET
1051   decNumber *allocrhs=NULL;        /* non-NULL if rounded rhs allocated */
1052   #endif
1053
1054   #if DECCHECK
1055   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1056   #endif
1057
1058   /* Check restrictions; these restrictions ensure that if h=8 (see */
1059   /* decExpOp) then the result will either overflow or underflow to 0. */
1060   /* Other math functions restrict the input range, too, for inverses. */
1061   /* If not violated then carry out the operation. */
1062   if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1063     #if DECSUBSET
1064     if (!set->extended) {
1065       /* reduce operand and set lostDigits status, as needed */
1066       if (rhs->digits>set->digits) {
1067         allocrhs=decRoundOperand(rhs, set, &status);
1068         if (allocrhs==NULL) break;
1069         rhs=allocrhs;
1070         }
1071       }
1072     #endif
1073     decExpOp(res, rhs, set, &status);
1074     } while(0);                         /* end protected */
1075
1076   #if DECSUBSET
1077   free(allocrhs);       /* drop any storage used */
1078   #endif
1079   /* apply significant status */
1080   if (status!=0) decStatus(res, status, set);
1081   #if DECCHECK
1082   decCheckInexact(res, set);
1083   #endif
1084   return res;
1085   } /* decNumberExp */
1086
1087 /* ------------------------------------------------------------------ */
1088 /* decNumberFMA -- fused multiply add                                 */
1089 /*                                                                    */
1090 /*   This computes D = (A * B) + C with only one rounding             */
1091 /*                                                                    */
1092 /*   res is D, the result.  D may be A or B or C (e.g., X=FMA(X,X,X)) */
1093 /*   lhs is A                                                         */
1094 /*   rhs is B                                                         */
1095 /*   fhs is C [far hand side]                                         */
1096 /*   set is the context                                               */
1097 /*                                                                    */
1098 /* Mathematical function restrictions apply (see above); a NaN is     */
1099 /* returned with Invalid_operation if a restriction is violated.      */
1100 /*                                                                    */
1101 /* C must have space for set->digits digits.                          */
1102 /* ------------------------------------------------------------------ */
1103 decNumber * decNumberFMA(decNumber *res, const decNumber *lhs,
1104                          const decNumber *rhs, const decNumber *fhs,
1105                          decContext *set) {
1106   uInt status=0;                   /* accumulator */
1107   decContext dcmul;                /* context for the multiplication */
1108   uInt needbytes;                  /* for space calculations */
1109   decNumber bufa[D2N(DECBUFFER*2+1)];
1110   decNumber *allocbufa=NULL;       /* -> allocated bufa, iff allocated */
1111   decNumber *acc;                  /* accumulator pointer */
1112   decNumber dzero;                 /* work */
1113
1114   #if DECCHECK
1115   if (decCheckOperands(res, lhs, rhs, set)) return res;
1116   if (decCheckOperands(res, fhs, DECUNUSED, set)) return res;
1117   #endif
1118
1119   do {                                  /* protect allocated storage */
1120     #if DECSUBSET
1121     if (!set->extended) {               /* [undefined if subset] */
1122       status|=DEC_Invalid_operation;
1123       break;}
1124     #endif
1125     /* Check math restrictions [these ensure no overflow or underflow] */
1126     if ((!decNumberIsSpecial(lhs) && decCheckMath(lhs, set, &status))
1127      || (!decNumberIsSpecial(rhs) && decCheckMath(rhs, set, &status))
1128      || (!decNumberIsSpecial(fhs) && decCheckMath(fhs, set, &status))) break;
1129     /* set up context for multiply */
1130     dcmul=*set;
1131     dcmul.digits=lhs->digits+rhs->digits; /* just enough */
1132     /* [The above may be an over-estimate for subset arithmetic, but that's OK] */
1133     dcmul.emax=DEC_MAX_EMAX;            /* effectively unbounded .. */
1134     dcmul.emin=DEC_MIN_EMIN;            /* [thanks to Math restrictions] */
1135     /* set up decNumber space to receive the result of the multiply */
1136     acc=bufa;                           /* may fit */
1137     needbytes=sizeof(decNumber)+(D2U(dcmul.digits)-1)*sizeof(Unit);
1138     if (needbytes>sizeof(bufa)) {       /* need malloc space */
1139       allocbufa=(decNumber *)malloc(needbytes);
1140       if (allocbufa==NULL) {            /* hopeless -- abandon */
1141         status|=DEC_Insufficient_storage;
1142         break;}
1143       acc=allocbufa;                    /* use the allocated space */
1144       }
1145     /* multiply with extended range and necessary precision */
1146     /*printf("emin=%ld\n", dcmul.emin); */
1147     decMultiplyOp(acc, lhs, rhs, &dcmul, &status);
1148     /* Only Invalid operation (from sNaN or Inf * 0) is possible in */
1149     /* status; if either is seen than ignore fhs (in case it is */
1150     /* another sNaN) and set acc to NaN unless we had an sNaN */
1151     /* [decMultiplyOp leaves that to caller] */
1152     /* Note sNaN has to go through addOp to shorten payload if */
1153     /* necessary */
1154     if ((status&DEC_Invalid_operation)!=0) {
1155       if (!(status&DEC_sNaN)) {         /* but be true invalid */
1156         decNumberZero(res);             /* acc not yet set */
1157         res->bits=DECNAN;
1158         break;
1159         }
1160       decNumberZero(&dzero);            /* make 0 (any non-NaN would do) */
1161       fhs=&dzero;                       /* use that */
1162       }
1163     #if DECCHECK
1164      else { /* multiply was OK */
1165       if (status!=0) printf("Status=%08lx after FMA multiply\n", (LI)status);
1166       }
1167     #endif
1168     /* add the third operand and result -> res, and all is done */
1169     decAddOp(res, acc, fhs, set, 0, &status);
1170     } while(0);                         /* end protected */
1171
1172   free(allocbufa); /* drop any storage used */
1173   if (status!=0) decStatus(res, status, set);
1174   #if DECCHECK
1175   decCheckInexact(res, set);
1176   #endif
1177   return res;
1178   } /* decNumberFMA */
1179
1180 /* ------------------------------------------------------------------ */
1181 /* decNumberInvert -- invert a Number, digitwise                      */
1182 /*                                                                    */
1183 /*   This computes C = ~A                                             */
1184 /*                                                                    */
1185 /*   res is C, the result.  C may be A (e.g., X=~X)                   */
1186 /*   rhs is A                                                         */
1187 /*   set is the context (used for result length and error report)     */
1188 /*                                                                    */
1189 /* C must have space for set->digits digits.                          */
1190 /*                                                                    */
1191 /* Logical function restrictions apply (see above); a NaN is          */
1192 /* returned with Invalid_operation if a restriction is violated.      */
1193 /* ------------------------------------------------------------------ */
1194 decNumber * decNumberInvert(decNumber *res, const decNumber *rhs,
1195                             decContext *set) {
1196   const Unit *ua, *msua;                /* -> operand and its msu */
1197   Unit  *uc, *msuc;                     /* -> result and its msu */
1198   Int   msudigs;                        /* digits in res msu */
1199   #if DECCHECK
1200   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1201   #endif
1202
1203   if (rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1204     decStatus(res, DEC_Invalid_operation, set);
1205     return res;
1206     }
1207   /* operand is valid */
1208   ua=rhs->lsu;                          /* bottom-up */
1209   uc=res->lsu;                          /* .. */
1210   msua=ua+D2U(rhs->digits)-1;           /* -> msu of rhs */
1211   msuc=uc+D2U(set->digits)-1;           /* -> msu of result */
1212   msudigs=MSUDIGITS(set->digits);       /* [faster than remainder] */
1213   for (; uc<=msuc; ua++, uc++) {        /* Unit loop */
1214     Unit a;                             /* extract unit */
1215     Int  i, j;                          /* work */
1216     if (ua>msua) a=0;
1217      else a=*ua;
1218     *uc=0;                              /* can now write back */
1219     /* always need to examine all bits in rhs */
1220     /* This loop could be unrolled and/or use BIN2BCD tables */
1221     for (i=0; i<DECDPUN; i++) {
1222       if ((~a)&1) *uc=*uc+(Unit)powers[i];   /* effect INVERT */
1223       j=a%10;
1224       a=a/10;
1225       if (j>1) {
1226         decStatus(res, DEC_Invalid_operation, set);
1227         return res;
1228         }
1229       if (uc==msuc && i==msudigs-1) break;   /* just did final digit */
1230       } /* each digit */
1231     } /* each unit */
1232   /* [here uc-1 is the msu of the result] */
1233   res->digits=decGetDigits(res->lsu, uc-res->lsu);
1234   res->exponent=0;                      /* integer */
1235   res->bits=0;                          /* sign=0 */
1236   return res;  /* [no status to set] */
1237   } /* decNumberInvert */
1238
1239 /* ------------------------------------------------------------------ */
1240 /* decNumberLn -- natural logarithm                                   */
1241 /*                                                                    */
1242 /*   This computes C = ln(A)                                          */
1243 /*                                                                    */
1244 /*   res is C, the result.  C may be A                                */
1245 /*   rhs is A                                                         */
1246 /*   set is the context; note that rounding mode has no effect        */
1247 /*                                                                    */
1248 /* C must have space for set->digits digits.                          */
1249 /*                                                                    */
1250 /* Notable cases:                                                     */
1251 /*   A<0 -> Invalid                                                   */
1252 /*   A=0 -> -Infinity (Exact)                                         */
1253 /*   A=+Infinity -> +Infinity (Exact)                                 */
1254 /*   A=1 exactly -> 0 (Exact)                                         */
1255 /*                                                                    */
1256 /* Mathematical function restrictions apply (see above); a NaN is     */
1257 /* returned with Invalid_operation if a restriction is violated.      */
1258 /*                                                                    */
1259 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
1260 /* almost always be correctly rounded, but may be up to 1 ulp in      */
1261 /* error in rare cases.                                               */
1262 /* ------------------------------------------------------------------ */
1263 /* This is a wrapper for decLnOp which can handle the slightly wider  */
1264 /* (+11) range needed by Ln, Log10, etc. (which may have to be able   */
1265 /* to calculate at p+e+2).                                            */
1266 /* ------------------------------------------------------------------ */
1267 decNumber * decNumberLn(decNumber *res, const decNumber *rhs,
1268                         decContext *set) {
1269   uInt status=0;                   /* accumulator */
1270   #if DECSUBSET
1271   decNumber *allocrhs=NULL;        /* non-NULL if rounded rhs allocated */
1272   #endif
1273
1274   #if DECCHECK
1275   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1276   #endif
1277
1278   /* Check restrictions; this is a math function; if not violated */
1279   /* then carry out the operation. */
1280   if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1281     #if DECSUBSET
1282     if (!set->extended) {
1283       /* reduce operand and set lostDigits status, as needed */
1284       if (rhs->digits>set->digits) {
1285         allocrhs=decRoundOperand(rhs, set, &status);
1286         if (allocrhs==NULL) break;
1287         rhs=allocrhs;
1288         }
1289       /* special check in subset for rhs=0 */
1290       if (ISZERO(rhs)) {                /* +/- zeros -> error */
1291         status|=DEC_Invalid_operation;
1292         break;}
1293       } /* extended=0 */
1294     #endif
1295     decLnOp(res, rhs, set, &status);
1296     } while(0);                         /* end protected */
1297
1298   #if DECSUBSET
1299   free(allocrhs);       /* drop any storage used */
1300   #endif
1301   /* apply significant status */
1302   if (status!=0) decStatus(res, status, set);
1303   #if DECCHECK
1304   decCheckInexact(res, set);
1305   #endif
1306   return res;
1307   } /* decNumberLn */
1308
1309 /* ------------------------------------------------------------------ */
1310 /* decNumberLogB - get adjusted exponent, by 754 rules                */
1311 /*                                                                    */
1312 /*   This computes C = adjustedexponent(A)                            */
1313 /*                                                                    */
1314 /*   res is C, the result.  C may be A                                */
1315 /*   rhs is A                                                         */
1316 /*   set is the context, used only for digits and status              */
1317 /*                                                                    */
1318 /* C must have space for 10 digits (A might have 10**9 digits and     */
1319 /* an exponent of +999999999, or one digit and an exponent of         */
1320 /* -1999999999).                                                      */
1321 /*                                                                    */
1322 /* This returns the adjusted exponent of A after (in theory) padding  */
1323 /* with zeros on the right to set->digits digits while keeping the    */
1324 /* same value.  The exponent is not limited by emin/emax.             */
1325 /*                                                                    */
1326 /* Notable cases:                                                     */
1327 /*   A<0 -> Use |A|                                                   */
1328 /*   A=0 -> -Infinity (Division by zero)                              */
1329 /*   A=Infinite -> +Infinity (Exact)                                  */
1330 /*   A=1 exactly -> 0 (Exact)                                         */
1331 /*   NaNs are propagated as usual                                     */
1332 /* ------------------------------------------------------------------ */
1333 decNumber * decNumberLogB(decNumber *res, const decNumber *rhs,
1334                           decContext *set) {
1335   uInt status=0;                   /* accumulator */
1336
1337   #if DECCHECK
1338   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1339   #endif
1340
1341   /* NaNs as usual; Infinities return +Infinity; 0->oops */
1342   if (decNumberIsNaN(rhs)) decNaNs(res, rhs, NULL, set, &status);
1343    else if (decNumberIsInfinite(rhs)) decNumberCopyAbs(res, rhs);
1344    else if (decNumberIsZero(rhs)) {
1345     decNumberZero(res);                 /* prepare for Infinity */
1346     res->bits=DECNEG|DECINF;            /* -Infinity */
1347     status|=DEC_Division_by_zero;       /* as per 754 */
1348     }
1349    else { /* finite non-zero */
1350     Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */
1351     decNumberFromInt32(res, ae);        /* lay it out */
1352     }
1353
1354   if (status!=0) decStatus(res, status, set);
1355   return res;
1356   } /* decNumberLogB */
1357
1358 /* ------------------------------------------------------------------ */
1359 /* decNumberLog10 -- logarithm in base 10                             */
1360 /*                                                                    */
1361 /*   This computes C = log10(A)                                       */
1362 /*                                                                    */
1363 /*   res is C, the result.  C may be A                                */
1364 /*   rhs is A                                                         */
1365 /*   set is the context; note that rounding mode has no effect        */
1366 /*                                                                    */
1367 /* C must have space for set->digits digits.                          */
1368 /*                                                                    */
1369 /* Notable cases:                                                     */
1370 /*   A<0 -> Invalid                                                   */
1371 /*   A=0 -> -Infinity (Exact)                                         */
1372 /*   A=+Infinity -> +Infinity (Exact)                                 */
1373 /*   A=10**n (if n is an integer) -> n (Exact)                        */
1374 /*                                                                    */
1375 /* Mathematical function restrictions apply (see above); a NaN is     */
1376 /* returned with Invalid_operation if a restriction is violated.      */
1377 /*                                                                    */
1378 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
1379 /* almost always be correctly rounded, but may be up to 1 ulp in      */
1380 /* error in rare cases.                                               */
1381 /* ------------------------------------------------------------------ */
1382 /* This calculates ln(A)/ln(10) using appropriate precision.  For     */
1383 /* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the      */
1384 /* requested digits and t is the number of digits in the exponent     */
1385 /* (maximum 6).  For ln(10) it is p + 3; this is often handled by the */
1386 /* fastpath in decLnOp.  The final division is done to the requested  */
1387 /* precision.                                                         */
1388 /* ------------------------------------------------------------------ */
1389 decNumber * decNumberLog10(decNumber *res, const decNumber *rhs,
1390                           decContext *set) {
1391   uInt status=0, ignore=0;         /* status accumulators */
1392   uInt needbytes;                  /* for space calculations */
1393   Int p;                           /* working precision */
1394   Int t;                           /* digits in exponent of A */
1395
1396   /* buffers for a and b working decimals */
1397   /* (adjustment calculator, same size) */
1398   decNumber bufa[D2N(DECBUFFER+2)];
1399   decNumber *allocbufa=NULL;       /* -> allocated bufa, iff allocated */
1400   decNumber *a=bufa;               /* temporary a */
1401   decNumber bufb[D2N(DECBUFFER+2)];
1402   decNumber *allocbufb=NULL;       /* -> allocated bufb, iff allocated */
1403   decNumber *b=bufb;               /* temporary b */
1404   decNumber bufw[D2N(10)];         /* working 2-10 digit number */
1405   decNumber *w=bufw;               /* .. */
1406   #if DECSUBSET
1407   decNumber *allocrhs=NULL;        /* non-NULL if rounded rhs allocated */
1408   #endif
1409
1410   decContext aset;                 /* working context */
1411
1412   #if DECCHECK
1413   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1414   #endif
1415
1416   /* Check restrictions; this is a math function; if not violated */
1417   /* then carry out the operation. */
1418   if (!decCheckMath(rhs, set, &status)) do { /* protect malloc */
1419     #if DECSUBSET
1420     if (!set->extended) {
1421       /* reduce operand and set lostDigits status, as needed */
1422       if (rhs->digits>set->digits) {
1423         allocrhs=decRoundOperand(rhs, set, &status);
1424         if (allocrhs==NULL) break;
1425         rhs=allocrhs;
1426         }
1427       /* special check in subset for rhs=0 */
1428       if (ISZERO(rhs)) {                /* +/- zeros -> error */
1429         status|=DEC_Invalid_operation;
1430         break;}
1431       } /* extended=0 */
1432     #endif
1433
1434     decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
1435
1436     /* handle exact powers of 10; only check if +ve finite */
1437     if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) {
1438       Int residue=0;               /* (no residue) */
1439       uInt copystat=0;             /* clean status */
1440
1441       /* round to a single digit... */
1442       aset.digits=1;
1443       decCopyFit(w, rhs, &aset, &residue, &copystat); /* copy & shorten */
1444       /* if exact and the digit is 1, rhs is a power of 10 */
1445       if (!(copystat&DEC_Inexact) && w->lsu[0]==1) {
1446         /* the exponent, conveniently, is the power of 10; making */
1447         /* this the result needs a little care as it might not fit, */
1448         /* so first convert it into the working number, and then move */
1449         /* to res */
1450         decNumberFromInt32(w, w->exponent);
1451         residue=0;
1452         decCopyFit(res, w, set, &residue, &status); /* copy & round */
1453         decFinish(res, set, &residue, &status);     /* cleanup/set flags */
1454         break;
1455         } /* not a power of 10 */
1456       } /* not a candidate for exact */
1457
1458     /* simplify the information-content calculation to use 'total */
1459     /* number of digits in a, including exponent' as compared to the */
1460     /* requested digits, as increasing this will only rarely cost an */
1461     /* iteration in ln(a) anyway */
1462     t=6;                                /* it can never be >6 */
1463
1464     /* allocate space when needed... */
1465     p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3;
1466     needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1467     if (needbytes>sizeof(bufa)) {       /* need malloc space */
1468       allocbufa=(decNumber *)malloc(needbytes);
1469       if (allocbufa==NULL) {            /* hopeless -- abandon */
1470         status|=DEC_Insufficient_storage;
1471         break;}
1472       a=allocbufa;                      /* use the allocated space */
1473       }
1474     aset.digits=p;                      /* as calculated */
1475     aset.emax=DEC_MAX_MATH;             /* usual bounds */
1476     aset.emin=-DEC_MAX_MATH;            /* .. */
1477     aset.clamp=0;                       /* and no concrete format */
1478     decLnOp(a, rhs, &aset, &status);    /* a=ln(rhs) */
1479
1480     /* skip the division if the result so far is infinite, NaN, or */
1481     /* zero, or there was an error; note NaN from sNaN needs copy */
1482     if (status&DEC_NaNs && !(status&DEC_sNaN)) break;
1483     if (a->bits&DECSPECIAL || ISZERO(a)) {
1484       decNumberCopy(res, a);            /* [will fit] */
1485       break;}
1486
1487     /* for ln(10) an extra 3 digits of precision are needed */
1488     p=set->digits+3;
1489     needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1490     if (needbytes>sizeof(bufb)) {       /* need malloc space */
1491       allocbufb=(decNumber *)malloc(needbytes);
1492       if (allocbufb==NULL) {            /* hopeless -- abandon */
1493         status|=DEC_Insufficient_storage;
1494         break;}
1495       b=allocbufb;                      /* use the allocated space */
1496       }
1497     decNumberZero(w);                   /* set up 10... */
1498     #if DECDPUN==1
1499     w->lsu[1]=1; w->lsu[0]=0;           /* .. */
1500     #else
1501     w->lsu[0]=10;                       /* .. */
1502     #endif
1503     w->digits=2;                        /* .. */
1504
1505     aset.digits=p;
1506     decLnOp(b, w, &aset, &ignore);      /* b=ln(10) */
1507
1508     aset.digits=set->digits;            /* for final divide */
1509     decDivideOp(res, a, b, &aset, DIVIDE, &status); /* into result */
1510     } while(0);                         /* [for break] */
1511
1512   free(allocbufa); /* drop any storage used */
1513   free(allocbufb); /* .. */
1514   #if DECSUBSET
1515   free(allocrhs);       /* .. */
1516   #endif
1517   /* apply significant status */
1518   if (status!=0) decStatus(res, status, set);
1519   #if DECCHECK
1520   decCheckInexact(res, set);
1521   #endif
1522   return res;
1523   } /* decNumberLog10 */
1524
1525 /* ------------------------------------------------------------------ */
1526 /* decNumberMax -- compare two Numbers and return the maximum         */
1527 /*                                                                    */
1528 /*   This computes C = A ? B, returning the maximum by 754 rules      */
1529 /*                                                                    */
1530 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
1531 /*   lhs is A                                                         */
1532 /*   rhs is B                                                         */
1533 /*   set is the context                                               */
1534 /*                                                                    */
1535 /* C must have space for set->digits digits.                          */
1536 /* ------------------------------------------------------------------ */
1537 decNumber * decNumberMax(decNumber *res, const decNumber *lhs,
1538                          const decNumber *rhs, decContext *set) {
1539   uInt status=0;                        /* accumulator */
1540   decCompareOp(res, lhs, rhs, set, COMPMAX, &status);
1541   if (status!=0) decStatus(res, status, set);
1542   #if DECCHECK
1543   decCheckInexact(res, set);
1544   #endif
1545   return res;
1546   } /* decNumberMax */
1547
1548 /* ------------------------------------------------------------------ */
1549 /* decNumberMaxMag -- compare and return the maximum by magnitude     */
1550 /*                                                                    */
1551 /*   This computes C = A ? B, returning the maximum by 754 rules      */
1552 /*                                                                    */
1553 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
1554 /*   lhs is A                                                         */
1555 /*   rhs is B                                                         */
1556 /*   set is the context                                               */
1557 /*                                                                    */
1558 /* C must have space for set->digits digits.                          */
1559 /* ------------------------------------------------------------------ */
1560 decNumber * decNumberMaxMag(decNumber *res, const decNumber *lhs,
1561                          const decNumber *rhs, decContext *set) {
1562   uInt status=0;                        /* accumulator */
1563   decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status);
1564   if (status!=0) decStatus(res, status, set);
1565   #if DECCHECK
1566   decCheckInexact(res, set);
1567   #endif
1568   return res;
1569   } /* decNumberMaxMag */
1570
1571 /* ------------------------------------------------------------------ */
1572 /* decNumberMin -- compare two Numbers and return the minimum         */
1573 /*                                                                    */
1574 /*   This computes C = A ? B, returning the minimum by 754 rules      */
1575 /*                                                                    */
1576 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
1577 /*   lhs is A                                                         */
1578 /*   rhs is B                                                         */
1579 /*   set is the context                                               */
1580 /*                                                                    */
1581 /* C must have space for set->digits digits.                          */
1582 /* ------------------------------------------------------------------ */
1583 decNumber * decNumberMin(decNumber *res, const decNumber *lhs,
1584                          const decNumber *rhs, decContext *set) {
1585   uInt status=0;                        /* accumulator */
1586   decCompareOp(res, lhs, rhs, set, COMPMIN, &status);
1587   if (status!=0) decStatus(res, status, set);
1588   #if DECCHECK
1589   decCheckInexact(res, set);
1590   #endif
1591   return res;
1592   } /* decNumberMin */
1593
1594 /* ------------------------------------------------------------------ */
1595 /* decNumberMinMag -- compare and return the minimum by magnitude     */
1596 /*                                                                    */
1597 /*   This computes C = A ? B, returning the minimum by 754 rules      */
1598 /*                                                                    */
1599 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
1600 /*   lhs is A                                                         */
1601 /*   rhs is B                                                         */
1602 /*   set is the context                                               */
1603 /*                                                                    */
1604 /* C must have space for set->digits digits.                          */
1605 /* ------------------------------------------------------------------ */
1606 decNumber * decNumberMinMag(decNumber *res, const decNumber *lhs,
1607                          const decNumber *rhs, decContext *set) {
1608   uInt status=0;                        /* accumulator */
1609   decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status);
1610   if (status!=0) decStatus(res, status, set);
1611   #if DECCHECK
1612   decCheckInexact(res, set);
1613   #endif
1614   return res;
1615   } /* decNumberMinMag */
1616
1617 /* ------------------------------------------------------------------ */
1618 /* decNumberMinus -- prefix minus operator                            */
1619 /*                                                                    */
1620 /*   This computes C = 0 - A                                          */
1621 /*                                                                    */
1622 /*   res is C, the result.  C may be A                                */
1623 /*   rhs is A                                                         */
1624 /*   set is the context                                               */
1625 /*                                                                    */
1626 /* See also decNumberCopyNegate for a quiet bitwise version of this.  */
1627 /* C must have space for set->digits digits.                          */
1628 /* ------------------------------------------------------------------ */
1629 /* Simply use AddOp for the subtract, which will do the necessary.    */
1630 /* ------------------------------------------------------------------ */
1631 decNumber * decNumberMinus(decNumber *res, const decNumber *rhs,
1632                            decContext *set) {
1633   decNumber dzero;
1634   uInt status=0;                        /* accumulator */
1635
1636   #if DECCHECK
1637   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1638   #endif
1639
1640   decNumberZero(&dzero);                /* make 0 */
1641   dzero.exponent=rhs->exponent;         /* [no coefficient expansion] */
1642   decAddOp(res, &dzero, rhs, set, DECNEG, &status);
1643   if (status!=0) decStatus(res, status, set);
1644   #if DECCHECK
1645   decCheckInexact(res, set);
1646   #endif
1647   return res;
1648   } /* decNumberMinus */
1649
1650 /* ------------------------------------------------------------------ */
1651 /* decNumberNextMinus -- next towards -Infinity                       */
1652 /*                                                                    */
1653 /*   This computes C = A - infinitesimal, rounded towards -Infinity   */
1654 /*                                                                    */
1655 /*   res is C, the result.  C may be A                                */
1656 /*   rhs is A                                                         */
1657 /*   set is the context                                               */
1658 /*                                                                    */
1659 /* This is a generalization of 754 NextDown.                          */
1660 /* ------------------------------------------------------------------ */
1661 decNumber * decNumberNextMinus(decNumber *res, const decNumber *rhs,
1662                                decContext *set) {
1663   decNumber dtiny;                           /* constant */
1664   decContext workset=*set;                   /* work */
1665   uInt status=0;                             /* accumulator */
1666   #if DECCHECK
1667   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1668   #endif
1669
1670   /* +Infinity is the special case */
1671   if ((rhs->bits&(DECINF|DECNEG))==DECINF) {
1672     decSetMaxValue(res, set);                /* is +ve */
1673     /* there is no status to set */
1674     return res;
1675     }
1676   decNumberZero(&dtiny);                     /* start with 0 */
1677   dtiny.lsu[0]=1;                            /* make number that is .. */
1678   dtiny.exponent=DEC_MIN_EMIN-1;             /* .. smaller than tiniest */
1679   workset.round=DEC_ROUND_FLOOR;
1680   decAddOp(res, rhs, &dtiny, &workset, DECNEG, &status);
1681   status&=DEC_Invalid_operation|DEC_sNaN;    /* only sNaN Invalid please */
1682   if (status!=0) decStatus(res, status, set);
1683   return res;
1684   } /* decNumberNextMinus */
1685
1686 /* ------------------------------------------------------------------ */
1687 /* decNumberNextPlus -- next towards +Infinity                        */
1688 /*                                                                    */
1689 /*   This computes C = A + infinitesimal, rounded towards +Infinity   */
1690 /*                                                                    */
1691 /*   res is C, the result.  C may be A                                */
1692 /*   rhs is A                                                         */
1693 /*   set is the context                                               */
1694 /*                                                                    */
1695 /* This is a generalization of 754 NextUp.                            */
1696 /* ------------------------------------------------------------------ */
1697 decNumber * decNumberNextPlus(decNumber *res, const decNumber *rhs,
1698                               decContext *set) {
1699   decNumber dtiny;                           /* constant */
1700   decContext workset=*set;                   /* work */
1701   uInt status=0;                             /* accumulator */
1702   #if DECCHECK
1703   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1704   #endif
1705
1706   /* -Infinity is the special case */
1707   if ((rhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1708     decSetMaxValue(res, set);
1709     res->bits=DECNEG;                        /* negative */
1710     /* there is no status to set */
1711     return res;
1712     }
1713   decNumberZero(&dtiny);                     /* start with 0 */
1714   dtiny.lsu[0]=1;                            /* make number that is .. */
1715   dtiny.exponent=DEC_MIN_EMIN-1;             /* .. smaller than tiniest */
1716   workset.round=DEC_ROUND_CEILING;
1717   decAddOp(res, rhs, &dtiny, &workset, 0, &status);
1718   status&=DEC_Invalid_operation|DEC_sNaN;    /* only sNaN Invalid please */
1719   if (status!=0) decStatus(res, status, set);
1720   return res;
1721   } /* decNumberNextPlus */
1722
1723 /* ------------------------------------------------------------------ */
1724 /* decNumberNextToward -- next towards rhs                            */
1725 /*                                                                    */
1726 /*   This computes C = A +/- infinitesimal, rounded towards           */
1727 /*   +/-Infinity in the direction of B, as per 754-1985 nextafter     */
1728 /*   modified during revision but dropped from 754-2008.              */
1729 /*                                                                    */
1730 /*   res is C, the result.  C may be A or B.                          */
1731 /*   lhs is A                                                         */
1732 /*   rhs is B                                                         */
1733 /*   set is the context                                               */
1734 /*                                                                    */
1735 /* This is a generalization of 754-1985 NextAfter.                    */
1736 /* ------------------------------------------------------------------ */
1737 decNumber * decNumberNextToward(decNumber *res, const decNumber *lhs,
1738                                 const decNumber *rhs, decContext *set) {
1739   decNumber dtiny;                           /* constant */
1740   decContext workset=*set;                   /* work */
1741   Int result;                                /* .. */
1742   uInt status=0;                             /* accumulator */
1743   #if DECCHECK
1744   if (decCheckOperands(res, lhs, rhs, set)) return res;
1745   #endif
1746
1747   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) {
1748     decNaNs(res, lhs, rhs, set, &status);
1749     }
1750    else { /* Is numeric, so no chance of sNaN Invalid, etc. */
1751     result=decCompare(lhs, rhs, 0);     /* sign matters */
1752     if (result==BADINT) status|=DEC_Insufficient_storage; /* rare */
1753      else { /* valid compare */
1754       if (result==0) decNumberCopySign(res, lhs, rhs); /* easy */
1755        else { /* differ: need NextPlus or NextMinus */
1756         uByte sub;                      /* add or subtract */
1757         if (result<0) {                 /* lhs<rhs, do nextplus */
1758           /* -Infinity is the special case */
1759           if ((lhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1760             decSetMaxValue(res, set);
1761             res->bits=DECNEG;           /* negative */
1762             return res;                 /* there is no status to set */
1763             }
1764           workset.round=DEC_ROUND_CEILING;
1765           sub=0;                        /* add, please */
1766           } /* plus */
1767          else {                         /* lhs>rhs, do nextminus */
1768           /* +Infinity is the special case */
1769           if ((lhs->bits&(DECINF|DECNEG))==DECINF) {
1770             decSetMaxValue(res, set);
1771             return res;                 /* there is no status to set */
1772             }
1773           workset.round=DEC_ROUND_FLOOR;
1774           sub=DECNEG;                   /* subtract, please */
1775           } /* minus */
1776         decNumberZero(&dtiny);          /* start with 0 */
1777         dtiny.lsu[0]=1;                 /* make number that is .. */
1778         dtiny.exponent=DEC_MIN_EMIN-1;  /* .. smaller than tiniest */
1779         decAddOp(res, lhs, &dtiny, &workset, sub, &status); /* + or - */
1780         /* turn off exceptions if the result is a normal number */
1781         /* (including Nmin), otherwise let all status through */
1782         if (decNumberIsNormal(res, set)) status=0;
1783         } /* unequal */
1784       } /* compare OK */
1785     } /* numeric */
1786   if (status!=0) decStatus(res, status, set);
1787   return res;
1788   } /* decNumberNextToward */
1789
1790 /* ------------------------------------------------------------------ */
1791 /* decNumberOr -- OR two Numbers, digitwise                           */
1792 /*                                                                    */
1793 /*   This computes C = A | B                                          */
1794 /*                                                                    */
1795 /*   res is C, the result.  C may be A and/or B (e.g., X=X|X)         */
1796 /*   lhs is A                                                         */
1797 /*   rhs is B                                                         */
1798 /*   set is the context (used for result length and error report)     */
1799 /*                                                                    */
1800 /* C must have space for set->digits digits.                          */
1801 /*                                                                    */
1802 /* Logical function restrictions apply (see above); a NaN is          */
1803 /* returned with Invalid_operation if a restriction is violated.      */
1804 /* ------------------------------------------------------------------ */
1805 decNumber * decNumberOr(decNumber *res, const decNumber *lhs,
1806                         const decNumber *rhs, decContext *set) {
1807   const Unit *ua, *ub;                  /* -> operands */
1808   const Unit *msua, *msub;              /* -> operand msus */
1809   Unit  *uc, *msuc;                     /* -> result and its msu */
1810   Int   msudigs;                        /* digits in res msu */
1811   #if DECCHECK
1812   if (decCheckOperands(res, lhs, rhs, set)) return res;
1813   #endif
1814
1815   if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
1816    || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1817     decStatus(res, DEC_Invalid_operation, set);
1818     return res;
1819     }
1820   /* operands are valid */
1821   ua=lhs->lsu;                          /* bottom-up */
1822   ub=rhs->lsu;                          /* .. */
1823   uc=res->lsu;                          /* .. */
1824   msua=ua+D2U(lhs->digits)-1;           /* -> msu of lhs */
1825   msub=ub+D2U(rhs->digits)-1;           /* -> msu of rhs */
1826   msuc=uc+D2U(set->digits)-1;           /* -> msu of result */
1827   msudigs=MSUDIGITS(set->digits);       /* [faster than remainder] */
1828   for (; uc<=msuc; ua++, ub++, uc++) {  /* Unit loop */
1829     Unit a, b;                          /* extract units */
1830     if (ua>msua) a=0;
1831      else a=*ua;
1832     if (ub>msub) b=0;
1833      else b=*ub;
1834     *uc=0;                              /* can now write back */
1835     if (a|b) {                          /* maybe 1 bits to examine */
1836       Int i, j;
1837       /* This loop could be unrolled and/or use BIN2BCD tables */
1838       for (i=0; i<DECDPUN; i++) {
1839         if ((a|b)&1) *uc=*uc+(Unit)powers[i];     /* effect OR */
1840         j=a%10;
1841         a=a/10;
1842         j|=b%10;
1843         b=b/10;
1844         if (j>1) {
1845           decStatus(res, DEC_Invalid_operation, set);
1846           return res;
1847           }
1848         if (uc==msuc && i==msudigs-1) break;      /* just did final digit */
1849         } /* each digit */
1850       } /* non-zero */
1851     } /* each unit */
1852   /* [here uc-1 is the msu of the result] */
1853   res->digits=decGetDigits(res->lsu, uc-res->lsu);
1854   res->exponent=0;                      /* integer */
1855   res->bits=0;                          /* sign=0 */
1856   return res;  /* [no status to set] */
1857   } /* decNumberOr */
1858
1859 /* ------------------------------------------------------------------ */
1860 /* decNumberPlus -- prefix plus operator                              */
1861 /*                                                                    */
1862 /*   This computes C = 0 + A                                          */
1863 /*                                                                    */
1864 /*   res is C, the result.  C may be A                                */
1865 /*   rhs is A                                                         */
1866 /*   set is the context                                               */
1867 /*                                                                    */
1868 /* See also decNumberCopy for a quiet bitwise version of this.        */
1869 /* C must have space for set->digits digits.                          */
1870 /* ------------------------------------------------------------------ */
1871 /* This simply uses AddOp; Add will take fast path after preparing A. */
1872 /* Performance is a concern here, as this routine is often used to    */
1873 /* check operands and apply rounding and overflow/underflow testing.  */
1874 /* ------------------------------------------------------------------ */
1875 decNumber * decNumberPlus(decNumber *res, const decNumber *rhs,
1876                           decContext *set) {
1877   decNumber dzero;
1878   uInt status=0;                        /* accumulator */
1879   #if DECCHECK
1880   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1881   #endif
1882
1883   decNumberZero(&dzero);                /* make 0 */
1884   dzero.exponent=rhs->exponent;         /* [no coefficient expansion] */
1885   decAddOp(res, &dzero, rhs, set, 0, &status);
1886   if (status!=0) decStatus(res, status, set);
1887   #if DECCHECK
1888   decCheckInexact(res, set);
1889   #endif
1890   return res;
1891   } /* decNumberPlus */
1892
1893 /* ------------------------------------------------------------------ */
1894 /* decNumberMultiply -- multiply two Numbers                          */
1895 /*                                                                    */
1896 /*   This computes C = A x B                                          */
1897 /*                                                                    */
1898 /*   res is C, the result.  C may be A and/or B (e.g., X=X+X)         */
1899 /*   lhs is A                                                         */
1900 /*   rhs is B                                                         */
1901 /*   set is the context                                               */
1902 /*                                                                    */
1903 /* C must have space for set->digits digits.                          */
1904 /* ------------------------------------------------------------------ */
1905 decNumber * decNumberMultiply(decNumber *res, const decNumber *lhs,
1906                               const decNumber *rhs, decContext *set) {
1907   uInt status=0;                   /* accumulator */
1908   decMultiplyOp(res, lhs, rhs, set, &status);
1909   if (status!=0) decStatus(res, status, set);
1910   #if DECCHECK
1911   decCheckInexact(res, set);
1912   #endif
1913   return res;
1914   } /* decNumberMultiply */
1915
1916 /* ------------------------------------------------------------------ */
1917 /* decNumberPower -- raise a number to a power                        */
1918 /*                                                                    */
1919 /*   This computes C = A ** B                                         */
1920 /*                                                                    */
1921 /*   res is C, the result.  C may be A and/or B (e.g., X=X**X)        */
1922 /*   lhs is A                                                         */
1923 /*   rhs is B                                                         */
1924 /*   set is the context                                               */
1925 /*                                                                    */
1926 /* C must have space for set->digits digits.                          */
1927 /*                                                                    */
1928 /* Mathematical function restrictions apply (see above); a NaN is     */
1929 /* returned with Invalid_operation if a restriction is violated.      */
1930 /*                                                                    */
1931 /* However, if 1999999997<=B<=999999999 and B is an integer then the  */
1932 /* restrictions on A and the context are relaxed to the usual bounds, */
1933 /* for compatibility with the earlier (integer power only) version    */
1934 /* of this function.                                                  */
1935 /*                                                                    */
1936 /* When B is an integer, the result may be exact, even if rounded.    */
1937 /*                                                                    */
1938 /* The final result is rounded according to the context; it will      */
1939 /* almost always be correctly rounded, but may be up to 1 ulp in      */
1940 /* error in rare cases.                                               */
1941 /* ------------------------------------------------------------------ */
1942 decNumber * decNumberPower(decNumber *res, const decNumber *lhs,
1943                            const decNumber *rhs, decContext *set) {
1944   #if DECSUBSET
1945   decNumber *alloclhs=NULL;        /* non-NULL if rounded lhs allocated */
1946   decNumber *allocrhs=NULL;        /* .., rhs */
1947   #endif
1948   decNumber *allocdac=NULL;        /* -> allocated acc buffer, iff used */
1949   decNumber *allocinv=NULL;        /* -> allocated 1/x buffer, iff used */
1950   Int   reqdigits=set->digits;     /* requested DIGITS */
1951   Int   n;                         /* rhs in binary */
1952   Flag  rhsint=0;                  /* 1 if rhs is an integer */
1953   Flag  useint=0;                  /* 1 if can use integer calculation */
1954   Flag  isoddint=0;                /* 1 if rhs is an integer and odd */
1955   Int   i;                         /* work */
1956   #if DECSUBSET
1957   Int   dropped;                   /* .. */
1958   #endif
1959   uInt  needbytes;                 /* buffer size needed */
1960   Flag  seenbit;                   /* seen a bit while powering */
1961   Int   residue=0;                 /* rounding residue */
1962   uInt  status=0;                  /* accumulators */
1963   uByte bits=0;                    /* result sign if errors */
1964   decContext aset;                 /* working context */
1965   decNumber dnOne;                 /* work value 1... */
1966   /* local accumulator buffer [a decNumber, with digits+elength+1 digits] */
1967   decNumber dacbuff[D2N(DECBUFFER+9)];
1968   decNumber *dac=dacbuff;          /* -> result accumulator */
1969   /* same again for possible 1/lhs calculation */
1970   decNumber invbuff[D2N(DECBUFFER+9)];
1971
1972   #if DECCHECK
1973   if (decCheckOperands(res, lhs, rhs, set)) return res;
1974   #endif
1975
1976   do {                             /* protect allocated storage */
1977     #if DECSUBSET
1978     if (!set->extended) { /* reduce operands and set status, as needed */
1979       if (lhs->digits>reqdigits) {
1980         alloclhs=decRoundOperand(lhs, set, &status);
1981         if (alloclhs==NULL) break;
1982         lhs=alloclhs;
1983         }
1984       if (rhs->digits>reqdigits) {
1985         allocrhs=decRoundOperand(rhs, set, &status);
1986         if (allocrhs==NULL) break;
1987         rhs=allocrhs;
1988         }
1989       }
1990     #endif
1991     /* [following code does not require input rounding] */
1992
1993     /* handle NaNs and rhs Infinity (lhs infinity is harder) */
1994     if (SPECIALARGS) {
1995       if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { /* NaNs */
1996         decNaNs(res, lhs, rhs, set, &status);
1997         break;}
1998       if (decNumberIsInfinite(rhs)) {   /* rhs Infinity */
1999         Flag rhsneg=rhs->bits&DECNEG;   /* save rhs sign */
2000         if (decNumberIsNegative(lhs)    /* lhs<0 */
2001          && !decNumberIsZero(lhs))      /* .. */
2002           status|=DEC_Invalid_operation;
2003          else {                         /* lhs >=0 */
2004           decNumberZero(&dnOne);        /* set up 1 */
2005           dnOne.lsu[0]=1;
2006           decNumberCompare(dac, lhs, &dnOne, set); /* lhs ? 1 */
2007           decNumberZero(res);           /* prepare for 0/1/Infinity */
2008           if (decNumberIsNegative(dac)) {    /* lhs<1 */
2009             if (rhsneg) res->bits|=DECINF;   /* +Infinity [else is +0] */
2010             }
2011            else if (dac->lsu[0]==0) {        /* lhs=1 */
2012             /* 1**Infinity is inexact, so return fully-padded 1.0000 */
2013             Int shift=set->digits-1;
2014             *res->lsu=1;                     /* was 0, make int 1 */
2015             res->digits=decShiftToMost(res->lsu, 1, shift);
2016             res->exponent=-shift;            /* make 1.0000... */
2017             status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */
2018             }
2019            else {                            /* lhs>1 */
2020             if (!rhsneg) res->bits|=DECINF;  /* +Infinity [else is +0] */
2021             }
2022           } /* lhs>=0 */
2023         break;}
2024       /* [lhs infinity drops through] */
2025       } /* specials */
2026
2027     /* Original rhs may be an integer that fits and is in range */
2028     n=decGetInt(rhs);
2029     if (n!=BADINT) {                    /* it is an integer */
2030       rhsint=1;                         /* record the fact for 1**n */
2031       isoddint=(Flag)n&1;               /* [works even if big] */
2032       if (n!=BIGEVEN && n!=BIGODD)      /* can use integer path? */
2033         useint=1;                       /* looks good */
2034       }
2035
2036     if (decNumberIsNegative(lhs)        /* -x .. */
2037       && isoddint) bits=DECNEG;         /* .. to an odd power */
2038
2039     /* handle LHS infinity */
2040     if (decNumberIsInfinite(lhs)) {     /* [NaNs already handled] */
2041       uByte rbits=rhs->bits;            /* save */
2042       decNumberZero(res);               /* prepare */
2043       if (n==0) *res->lsu=1;            /* [-]Inf**0 => 1 */
2044        else {
2045         /* -Inf**nonint -> error */
2046         if (!rhsint && decNumberIsNegative(lhs)) {
2047           status|=DEC_Invalid_operation;     /* -Inf**nonint is error */
2048           break;}
2049         if (!(rbits & DECNEG)) bits|=DECINF; /* was not a **-n */
2050         /* [otherwise will be 0 or -0] */
2051         res->bits=bits;
2052         }
2053       break;}
2054
2055     /* similarly handle LHS zero */
2056     if (decNumberIsZero(lhs)) {
2057       if (n==0) {                            /* 0**0 => Error */
2058         #if DECSUBSET
2059         if (!set->extended) {                /* [unless subset] */
2060           decNumberZero(res);
2061           *res->lsu=1;                       /* return 1 */
2062           break;}
2063         #endif
2064         status|=DEC_Invalid_operation;
2065         }
2066        else {                                /* 0**x */
2067         uByte rbits=rhs->bits;               /* save */
2068         if (rbits & DECNEG) {                /* was a 0**(-n) */
2069           #if DECSUBSET
2070           if (!set->extended) {              /* [bad if subset] */
2071             status|=DEC_Invalid_operation;
2072             break;}
2073           #endif
2074           bits|=DECINF;
2075           }
2076         decNumberZero(res);                  /* prepare */
2077         /* [otherwise will be 0 or -0] */
2078         res->bits=bits;
2079         }
2080       break;}
2081
2082     /* here both lhs and rhs are finite; rhs==0 is handled in the */
2083     /* integer path.  Next handle the non-integer cases */
2084     if (!useint) {                      /* non-integral rhs */
2085       /* any -ve lhs is bad, as is either operand or context out of */
2086       /* bounds */
2087       if (decNumberIsNegative(lhs)) {
2088         status|=DEC_Invalid_operation;
2089         break;}
2090       if (decCheckMath(lhs, set, &status)
2091        || decCheckMath(rhs, set, &status)) break; /* variable status */
2092
2093       decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
2094       aset.emax=DEC_MAX_MATH;           /* usual bounds */
2095       aset.emin=-DEC_MAX_MATH;          /* .. */
2096       aset.clamp=0;                     /* and no concrete format */
2097
2098       /* calculate the result using exp(ln(lhs)*rhs), which can */
2099       /* all be done into the accumulator, dac.  The precision needed */
2100       /* is enough to contain the full information in the lhs (which */
2101       /* is the total digits, including exponent), or the requested */
2102       /* precision, if larger, + 4; 6 is used for the exponent */
2103       /* maximum length, and this is also used when it is shorter */
2104       /* than the requested digits as it greatly reduces the >0.5 ulp */
2105       /* cases at little cost (because Ln doubles digits each */
2106       /* iteration so a few extra digits rarely causes an extra */
2107       /* iteration) */
2108       aset.digits=MAXI(lhs->digits, set->digits)+6+4;
2109       } /* non-integer rhs */
2110
2111      else { /* rhs is in-range integer */
2112       if (n==0) {                       /* x**0 = 1 */
2113         /* (0**0 was handled above) */
2114         decNumberZero(res);             /* result=1 */
2115         *res->lsu=1;                    /* .. */
2116         break;}
2117       /* rhs is a non-zero integer */
2118       if (n<0) n=-n;                    /* use abs(n) */
2119
2120       aset=*set;                        /* clone the context */
2121       aset.round=DEC_ROUND_HALF_EVEN;   /* internally use balanced */
2122       /* calculate the working DIGITS */
2123       aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2;
2124       #if DECSUBSET
2125       if (!set->extended) aset.digits--;     /* use classic precision */
2126       #endif
2127       /* it's an error if this is more than can be handled */
2128       if (aset.digits>DECNUMMAXP) {status|=DEC_Invalid_operation; break;}
2129       } /* integer path */
2130
2131     /* aset.digits is the count of digits for the accumulator needed */
2132     /* if accumulator is too long for local storage, then allocate */
2133     needbytes=sizeof(decNumber)+(D2U(aset.digits)-1)*sizeof(Unit);
2134     /* [needbytes also used below if 1/lhs needed] */
2135     if (needbytes>sizeof(dacbuff)) {
2136       allocdac=(decNumber *)malloc(needbytes);
2137       if (allocdac==NULL) {   /* hopeless -- abandon */
2138         status|=DEC_Insufficient_storage;
2139         break;}
2140       dac=allocdac;           /* use the allocated space */
2141       }
2142     /* here, aset is set up and accumulator is ready for use */
2143
2144     if (!useint) {                           /* non-integral rhs */
2145       /* x ** y; special-case x=1 here as it will otherwise always */
2146       /* reduce to integer 1; decLnOp has a fastpath which detects */
2147       /* the case of x=1 */
2148       decLnOp(dac, lhs, &aset, &status);     /* dac=ln(lhs) */
2149       /* [no error possible, as lhs 0 already handled] */
2150       if (ISZERO(dac)) {                     /* x==1, 1.0, etc. */
2151         /* need to return fully-padded 1.0000 etc., but rhsint->1 */
2152         *dac->lsu=1;                         /* was 0, make int 1 */
2153         if (!rhsint) {                       /* add padding */
2154           Int shift=set->digits-1;
2155           dac->digits=decShiftToMost(dac->lsu, 1, shift);
2156           dac->exponent=-shift;              /* make 1.0000... */
2157           status|=DEC_Inexact|DEC_Rounded;   /* deemed inexact */
2158           }
2159         }
2160        else {
2161         decMultiplyOp(dac, dac, rhs, &aset, &status);  /* dac=dac*rhs */
2162         decExpOp(dac, dac, &aset, &status);            /* dac=exp(dac) */
2163         }
2164       /* and drop through for final rounding */
2165       } /* non-integer rhs */
2166
2167      else {                             /* carry on with integer */
2168       decNumberZero(dac);               /* acc=1 */
2169       *dac->lsu=1;                      /* .. */
2170
2171       /* if a negative power the constant 1 is needed, and if not subset */
2172       /* invert the lhs now rather than inverting the result later */
2173       if (decNumberIsNegative(rhs)) {   /* was a **-n [hence digits>0] */
2174         decNumber *inv=invbuff;         /* asssume use fixed buffer */
2175         decNumberCopy(&dnOne, dac);     /* dnOne=1;  [needed now or later] */
2176         #if DECSUBSET
2177         if (set->extended) {            /* need to calculate 1/lhs */
2178         #endif
2179           /* divide lhs into 1, putting result in dac [dac=1/dac] */
2180           decDivideOp(dac, &dnOne, lhs, &aset, DIVIDE, &status);
2181           /* now locate or allocate space for the inverted lhs */
2182           if (needbytes>sizeof(invbuff)) {
2183             allocinv=(decNumber *)malloc(needbytes);
2184             if (allocinv==NULL) {       /* hopeless -- abandon */
2185               status|=DEC_Insufficient_storage;
2186               break;}
2187             inv=allocinv;               /* use the allocated space */
2188             }
2189           /* [inv now points to big-enough buffer or allocated storage] */
2190           decNumberCopy(inv, dac);      /* copy the 1/lhs */
2191           decNumberCopy(dac, &dnOne);   /* restore acc=1 */
2192           lhs=inv;                      /* .. and go forward with new lhs */
2193         #if DECSUBSET
2194           }
2195         #endif
2196         }
2197
2198       /* Raise-to-the-power loop... */
2199       seenbit=0;                   /* set once a 1-bit is encountered */
2200       for (i=1;;i++){              /* for each bit [top bit ignored] */
2201         /* abandon if had overflow or terminal underflow */
2202         if (status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
2203           if (status&DEC_Overflow || ISZERO(dac)) break;
2204           }
2205         /* [the following two lines revealed an optimizer bug in a C++ */
2206         /* compiler, with symptom: 5**3 -> 25, when n=n+n was used] */
2207         n=n<<1;                    /* move next bit to testable position */
2208         if (n<0) {                 /* top bit is set */
2209           seenbit=1;               /* OK, significant bit seen */
2210           decMultiplyOp(dac, dac, lhs, &aset, &status); /* dac=dac*x */
2211           }
2212         if (i==31) break;          /* that was the last bit */
2213         if (!seenbit) continue;    /* no need to square 1 */
2214         decMultiplyOp(dac, dac, dac, &aset, &status); /* dac=dac*dac [square] */
2215         } /*i*/ /* 32 bits */
2216
2217       /* complete internal overflow or underflow processing */
2218       if (status & (DEC_Overflow|DEC_Underflow)) {
2219         #if DECSUBSET
2220         /* If subset, and power was negative, reverse the kind of -erflow */
2221         /* [1/x not yet done] */
2222         if (!set->extended && decNumberIsNegative(rhs)) {
2223           if (status & DEC_Overflow)
2224             status^=DEC_Overflow | DEC_Underflow | DEC_Subnormal;
2225            else { /* trickier -- Underflow may or may not be set */
2226             status&=~(DEC_Underflow | DEC_Subnormal); /* [one or both] */
2227             status|=DEC_Overflow;
2228             }
2229           }
2230         #endif
2231         dac->bits=(dac->bits & ~DECNEG) | bits; /* force correct sign */
2232         /* round subnormals [to set.digits rather than aset.digits] */
2233         /* or set overflow result similarly as required */
2234         decFinalize(dac, set, &residue, &status);
2235         decNumberCopy(res, dac);   /* copy to result (is now OK length) */
2236         break;
2237         }
2238
2239       #if DECSUBSET
2240       if (!set->extended &&                  /* subset math */
2241           decNumberIsNegative(rhs)) {        /* was a **-n [hence digits>0] */
2242         /* so divide result into 1 [dac=1/dac] */
2243         decDivideOp(dac, &dnOne, dac, &aset, DIVIDE, &status);
2244         }
2245       #endif
2246       } /* rhs integer path */
2247
2248     /* reduce result to the requested length and copy to result */
2249     decCopyFit(res, dac, set, &residue, &status);
2250     decFinish(res, set, &residue, &status);  /* final cleanup */
2251     #if DECSUBSET
2252     if (!set->extended) decTrim(res, set, 0, 1, &dropped); /* trailing zeros */
2253     #endif
2254     } while(0);                         /* end protected */
2255
2256   free(allocdac);       /* drop any storage used */
2257   free(allocinv);       /* .. */
2258   #if DECSUBSET
2259   free(alloclhs);       /* .. */
2260   free(allocrhs);       /* .. */
2261   #endif
2262   if (status!=0) decStatus(res, status, set);
2263   #if DECCHECK
2264   decCheckInexact(res, set);
2265   #endif
2266   return res;
2267   } /* decNumberPower */
2268
2269 /* ------------------------------------------------------------------ */
2270 /* decNumberQuantize -- force exponent to requested value             */
2271 /*                                                                    */
2272 /*   This computes C = op(A, B), where op adjusts the coefficient     */
2273 /*   of C (by rounding or shifting) such that the exponent (-scale)   */
2274 /*   of C has exponent of B.  The numerical value of C will equal A,  */
2275 /*   except for the effects of any rounding that occurred.            */
2276 /*                                                                    */
2277 /*   res is C, the result.  C may be A or B                           */
2278 /*   lhs is A, the number to adjust                                   */
2279 /*   rhs is B, the number with exponent to match                      */
2280 /*   set is the context                                               */
2281 /*                                                                    */
2282 /* C must have space for set->digits digits.                          */
2283 /*                                                                    */
2284 /* Unless there is an error or the result is infinite, the exponent   */
2285 /* after the operation is guaranteed to be equal to that of B.        */
2286 /* ------------------------------------------------------------------ */
2287 decNumber * decNumberQuantize(decNumber *res, const decNumber *lhs,
2288                               const decNumber *rhs, decContext *set) {
2289   uInt status=0;                        /* accumulator */
2290   decQuantizeOp(res, lhs, rhs, set, 1, &status);
2291   if (status!=0) decStatus(res, status, set);
2292   return res;
2293   } /* decNumberQuantize */
2294
2295 /* ------------------------------------------------------------------ */
2296 /* decNumberReduce -- remove trailing zeros                           */
2297 /*                                                                    */
2298 /*   This computes C = 0 + A, and normalizes the result               */
2299 /*                                                                    */
2300 /*   res is C, the result.  C may be A                                */
2301 /*   rhs is A                                                         */
2302 /*   set is the context                                               */
2303 /*                                                                    */
2304 /* C must have space for set->digits digits.                          */
2305 /* ------------------------------------------------------------------ */
2306 /* Previously known as Normalize */
2307 decNumber * decNumberNormalize(decNumber *res, const decNumber *rhs,
2308                                decContext *set) {
2309   return decNumberReduce(res, rhs, set);
2310   } /* decNumberNormalize */
2311
2312 decNumber * decNumberReduce(decNumber *res, const decNumber *rhs,
2313                             decContext *set) {
2314   #if DECSUBSET
2315   decNumber *allocrhs=NULL;        /* non-NULL if rounded rhs allocated */
2316   #endif
2317   uInt status=0;                   /* as usual */
2318   Int  residue=0;                  /* as usual */
2319   Int  dropped;                    /* work */
2320
2321   #if DECCHECK
2322   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2323   #endif
2324
2325   do {                             /* protect allocated storage */
2326     #if DECSUBSET
2327     if (!set->extended) {
2328       /* reduce operand and set lostDigits status, as needed */
2329       if (rhs->digits>set->digits) {
2330         allocrhs=decRoundOperand(rhs, set, &status);
2331         if (allocrhs==NULL) break;
2332         rhs=allocrhs;
2333         }
2334       }
2335     #endif
2336     /* [following code does not require input rounding] */
2337
2338     /* Infinities copy through; NaNs need usual treatment */
2339     if (decNumberIsNaN(rhs)) {
2340       decNaNs(res, rhs, NULL, set, &status);
2341       break;
2342       }
2343
2344     /* reduce result to the requested length and copy to result */
2345     decCopyFit(res, rhs, set, &residue, &status); /* copy & round */
2346     decFinish(res, set, &residue, &status);       /* cleanup/set flags */
2347     decTrim(res, set, 1, 0, &dropped);            /* normalize in place */
2348                                                   /* [may clamp] */
2349     } while(0);                              /* end protected */
2350
2351   #if DECSUBSET
2352   free(allocrhs);            /* .. */
2353   #endif
2354   if (status!=0) decStatus(res, status, set);/* then report status */
2355   return res;
2356   } /* decNumberReduce */
2357
2358 /* ------------------------------------------------------------------ */
2359 /* decNumberRescale -- force exponent to requested value              */
2360 /*                                                                    */
2361 /*   This computes C = op(A, B), where op adjusts the coefficient     */
2362 /*   of C (by rounding or shifting) such that the exponent (-scale)   */
2363 /*   of C has the value B.  The numerical value of C will equal A,    */
2364 /*   except for the effects of any rounding that occurred.            */
2365 /*                                                                    */
2366 /*   res is C, the result.  C may be A or B                           */
2367 /*   lhs is A, the number to adjust                                   */
2368 /*   rhs is B, the requested exponent                                 */
2369 /*   set is the context                                               */
2370 /*                                                                    */
2371 /* C must have space for set->digits digits.                          */
2372 /*                                                                    */
2373 /* Unless there is an error or the result is infinite, the exponent   */
2374 /* after the operation is guaranteed to be equal to B.                */
2375 /* ------------------------------------------------------------------ */
2376 decNumber * decNumberRescale(decNumber *res, const decNumber *lhs,
2377                              const decNumber *rhs, decContext *set) {
2378   uInt status=0;                        /* accumulator */
2379   decQuantizeOp(res, lhs, rhs, set, 0, &status);
2380   if (status!=0) decStatus(res, status, set);
2381   return res;
2382   } /* decNumberRescale */
2383
2384 /* ------------------------------------------------------------------ */
2385 /* decNumberRemainder -- divide and return remainder                  */
2386 /*                                                                    */
2387 /*   This computes C = A % B                                          */
2388 /*                                                                    */
2389 /*   res is C, the result.  C may be A and/or B (e.g., X=X%X)         */
2390 /*   lhs is A                                                         */
2391 /*   rhs is B                                                         */
2392 /*   set is the context                                               */
2393 /*                                                                    */
2394 /* C must have space for set->digits digits.                          */
2395 /* ------------------------------------------------------------------ */
2396 decNumber * decNumberRemainder(decNumber *res, const decNumber *lhs,
2397                                const decNumber *rhs, decContext *set) {
2398   uInt status=0;                        /* accumulator */
2399   decDivideOp(res, lhs, rhs, set, REMAINDER, &status);
2400   if (status!=0) decStatus(res, status, set);
2401   #if DECCHECK
2402   decCheckInexact(res, set);
2403   #endif
2404   return res;
2405   } /* decNumberRemainder */
2406
2407 /* ------------------------------------------------------------------ */
2408 /* decNumberRemainderNear -- divide and return remainder from nearest */
2409 /*                                                                    */
2410 /*   This computes C = A % B, where % is the IEEE remainder operator  */
2411 /*                                                                    */
2412 /*   res is C, the result.  C may be A and/or B (e.g., X=X%X)         */
2413 /*   lhs is A                                                         */
2414 /*   rhs is B                                                         */
2415 /*   set is the context                                               */
2416 /*                                                                    */
2417 /* C must have space for set->digits digits.                          */
2418 /* ------------------------------------------------------------------ */
2419 decNumber * decNumberRemainderNear(decNumber *res, const decNumber *lhs,
2420                                    const decNumber *rhs, decContext *set) {
2421   uInt status=0;                        /* accumulator */
2422   decDivideOp(res, lhs, rhs, set, REMNEAR, &status);
2423   if (status!=0) decStatus(res, status, set);
2424   #if DECCHECK
2425   decCheckInexact(res, set);
2426   #endif
2427   return res;
2428   } /* decNumberRemainderNear */
2429
2430 /* ------------------------------------------------------------------ */
2431 /* decNumberRotate -- rotate the coefficient of a Number left/right   */
2432 /*                                                                    */
2433 /*   This computes C = A rot B  (in base ten and rotating set->digits */
2434 /*   digits).                                                         */
2435 /*                                                                    */
2436 /*   res is C, the result.  C may be A and/or B (e.g., X=XrotX)       */
2437 /*   lhs is A                                                         */
2438 /*   rhs is B, the number of digits to rotate (-ve to right)          */
2439 /*   set is the context                                               */
2440 /*                                                                    */
2441 /* The digits of the coefficient of A are rotated to the left (if B   */
2442 /* is positive) or to the right (if B is negative) without adjusting  */
2443 /* the exponent or the sign of A.  If lhs->digits is less than        */
2444 /* set->digits the coefficient is padded with zeros on the left       */
2445 /* before the rotate.  Any leading zeros in the result are removed    */
2446 /* as usual.                                                          */
2447 /*                                                                    */
2448 /* B must be an integer (q=0) and in the range -set->digits through   */
2449 /* +set->digits.                                                      */
2450 /* C must have space for set->digits digits.                          */
2451 /* NaNs are propagated as usual.  Infinities are unaffected (but      */
2452 /* B must be valid).  No status is set unless B is invalid or an      */
2453 /* operand is an sNaN.                                                */
2454 /* ------------------------------------------------------------------ */
2455 decNumber * decNumberRotate(decNumber *res, const decNumber *lhs,
2456                            const decNumber *rhs, decContext *set) {
2457   uInt status=0;              /* accumulator */
2458   Int  rotate;                /* rhs as an Int */
2459
2460   #if DECCHECK
2461   if (decCheckOperands(res, lhs, rhs, set)) return res;
2462   #endif
2463
2464   /* NaNs propagate as normal */
2465   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2466     decNaNs(res, lhs, rhs, set, &status);
2467    /* rhs must be an integer */
2468    else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2469     status=DEC_Invalid_operation;
2470    else { /* both numeric, rhs is an integer */
2471     rotate=decGetInt(rhs);                   /* [cannot fail] */
2472     if (rotate==BADINT                       /* something bad .. */
2473      || rotate==BIGODD || rotate==BIGEVEN    /* .. very big .. */
2474      || abs(rotate)>set->digits)             /* .. or out of range */
2475       status=DEC_Invalid_operation;
2476      else {                                  /* rhs is OK */
2477       decNumberCopy(res, lhs);
2478       /* convert -ve rotate to equivalent positive rotation */
2479       if (rotate<0) rotate=set->digits+rotate;
2480       if (rotate!=0 && rotate!=set->digits   /* zero or full rotation */
2481        && !decNumberIsInfinite(res)) {       /* lhs was infinite */
2482         /* left-rotate to do; 0 < rotate < set->digits */
2483         uInt units, shift;                   /* work */
2484         uInt msudigits;                      /* digits in result msu */
2485         Unit *msu=res->lsu+D2U(res->digits)-1;    /* current msu */
2486         Unit *msumax=res->lsu+D2U(set->digits)-1; /* rotation msu */
2487         for (msu++; msu<=msumax; msu++) *msu=0;   /* ensure high units=0 */
2488         res->digits=set->digits;                  /* now full-length */
2489         msudigits=MSUDIGITS(res->digits);         /* actual digits in msu */
2490
2491         /* rotation here is done in-place, in three steps */
2492         /* 1. shift all to least up to one unit to unit-align final */
2493         /*    lsd [any digits shifted out are rotated to the left, */
2494         /*    abutted to the original msd (which may require split)] */
2495         /* */
2496         /*    [if there are no whole units left to rotate, the */
2497         /*    rotation is now complete] */
2498         /* */
2499         /* 2. shift to least, from below the split point only, so that */
2500         /*    the final msd is in the right place in its Unit [any */
2501         /*    digits shifted out will fit exactly in the current msu, */
2502         /*    left aligned, no split required] */
2503         /* */
2504         /* 3. rotate all the units by reversing left part, right */
2505         /*    part, and then whole */
2506         /* */
2507         /* example: rotate right 8 digits (2 units + 2), DECDPUN=3. */
2508         /* */
2509         /*   start: 00a bcd efg hij klm npq */
2510         /* */
2511         /*      1a  000 0ab cde fgh|ijk lmn [pq saved] */
2512         /*      1b  00p qab cde fgh|ijk lmn */
2513         /* */
2514         /*      2a  00p qab cde fgh|00i jkl [mn saved] */
2515         /*      2b  mnp qab cde fgh|00i jkl */
2516         /* */
2517         /*      3a  fgh cde qab mnp|00i jkl */
2518         /*      3b  fgh cde qab mnp|jkl 00i */
2519         /*      3c  00i jkl mnp qab cde fgh */
2520
2521         /* Step 1: amount to shift is the partial right-rotate count */
2522         rotate=set->digits-rotate;      /* make it right-rotate */
2523         units=rotate/DECDPUN;           /* whole units to rotate */
2524         shift=rotate%DECDPUN;           /* left-over digits count */
2525         if (shift>0) {                  /* not an exact number of units */
2526           uInt save=res->lsu[0]%powers[shift];    /* save low digit(s) */
2527           decShiftToLeast(res->lsu, D2U(res->digits), shift);
2528           if (shift>msudigits) {        /* msumax-1 needs >0 digits */
2529             uInt rem=save%powers[shift-msudigits];/* split save */
2530             *msumax=(Unit)(save/powers[shift-msudigits]); /* and insert */
2531             *(msumax-1)=*(msumax-1)
2532                        +(Unit)(rem*powers[DECDPUN-(shift-msudigits)]); /* .. */
2533             }
2534            else { /* all fits in msumax */
2535             *msumax=*msumax+(Unit)(save*powers[msudigits-shift]); /* [maybe *1] */
2536             }
2537           } /* digits shift needed */
2538
2539         /* If whole units to rotate... */
2540         if (units>0) {                  /* some to do */
2541           /* Step 2: the units to touch are the whole ones in rotate, */
2542           /*   if any, and the shift is DECDPUN-msudigits (which may be */
2543           /*   0, again) */
2544           shift=DECDPUN-msudigits;
2545           if (shift>0) {                /* not an exact number of units */
2546             uInt save=res->lsu[0]%powers[shift];  /* save low digit(s) */
2547             decShiftToLeast(res->lsu, units, shift);
2548             *msumax=*msumax+(Unit)(save*powers[msudigits]);
2549             } /* partial shift needed */
2550
2551           /* Step 3: rotate the units array using triple reverse */
2552           /* (reversing is easy and fast) */
2553           decReverse(res->lsu+units, msumax);     /* left part */
2554           decReverse(res->lsu, res->lsu+units-1); /* right part */
2555           decReverse(res->lsu, msumax);           /* whole */
2556           } /* whole units to rotate */
2557         /* the rotation may have left an undetermined number of zeros */
2558         /* on the left, so true length needs to be calculated */
2559         res->digits=decGetDigits(res->lsu, msumax-res->lsu+1);
2560         } /* rotate needed */
2561       } /* rhs OK */
2562     } /* numerics */
2563   if (status!=0) decStatus(res, status, set);
2564   return res;
2565   } /* decNumberRotate */
2566
2567 /* ------------------------------------------------------------------ */
2568 /* decNumberSameQuantum -- test for equal exponents                   */
2569 /*                                                                    */
2570 /*   res is the result number, which will contain either 0 or 1       */
2571 /*   lhs is a number to test                                          */
2572 /*   rhs is the second (usually a pattern)                            */
2573 /*                                                                    */
2574 /* No errors are possible and no context is needed.                   */
2575 /* ------------------------------------------------------------------ */
2576 decNumber * decNumberSameQuantum(decNumber *res, const decNumber *lhs,
2577                                  const decNumber *rhs) {
2578   Unit ret=0;                      /* return value */
2579
2580   #if DECCHECK
2581   if (decCheckOperands(res, lhs, rhs, DECUNCONT)) return res;
2582   #endif
2583
2584   if (SPECIALARGS) {
2585     if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1;
2586      else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1;
2587      /* [anything else with a special gives 0] */
2588     }
2589    else if (lhs->exponent==rhs->exponent) ret=1;
2590
2591   decNumberZero(res);              /* OK to overwrite an operand now */
2592   *res->lsu=ret;
2593   return res;
2594   } /* decNumberSameQuantum */
2595
2596 /* ------------------------------------------------------------------ */
2597 /* decNumberScaleB -- multiply by a power of 10                       */
2598 /*                                                                    */
2599 /* This computes C = A x 10**B where B is an integer (q=0) with       */
2600 /* maximum magnitude 2*(emax+digits)                                  */
2601 /*                                                                    */
2602 /*   res is C, the result.  C may be A or B                           */
2603 /*   lhs is A, the number to adjust                                   */
2604 /*   rhs is B, the requested power of ten to use                      */
2605 /*   set is the context                                               */
2606 /*                                                                    */
2607 /* C must have space for set->digits digits.                          */
2608 /*                                                                    */
2609 /* The result may underflow or overflow.                              */
2610 /* ------------------------------------------------------------------ */
2611 decNumber * decNumberScaleB(decNumber *res, const decNumber *lhs,
2612                             const decNumber *rhs, decContext *set) {
2613   Int  reqexp;                /* requested exponent change [B] */
2614   uInt status=0;              /* accumulator */
2615   Int  residue;               /* work */
2616
2617   #if DECCHECK
2618   if (decCheckOperands(res, lhs, rhs, set)) return res;
2619   #endif
2620
2621   /* Handle special values except lhs infinite */
2622   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2623     decNaNs(res, lhs, rhs, set, &status);
2624     /* rhs must be an integer */
2625    else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2626     status=DEC_Invalid_operation;
2627    else {
2628     /* lhs is a number; rhs is a finite with q==0 */
2629     reqexp=decGetInt(rhs);                   /* [cannot fail] */
2630     if (reqexp==BADINT                       /* something bad .. */
2631      || reqexp==BIGODD || reqexp==BIGEVEN    /* .. very big .. */
2632      || abs(reqexp)>(2*(set->digits+set->emax))) /* .. or out of range */
2633       status=DEC_Invalid_operation;
2634      else {                                  /* rhs is OK */
2635       decNumberCopy(res, lhs);               /* all done if infinite lhs */
2636       if (!decNumberIsInfinite(res)) {       /* prepare to scale */
2637         res->exponent+=reqexp;               /* adjust the exponent */
2638         residue=0;
2639         decFinalize(res, set, &residue, &status); /* .. and check */
2640         } /* finite LHS */
2641       } /* rhs OK */
2642     } /* rhs finite */
2643   if (status!=0) decStatus(res, status, set);
2644   return res;
2645   } /* decNumberScaleB */
2646
2647 /* ------------------------------------------------------------------ */
2648 /* decNumberShift -- shift the coefficient of a Number left or right  */
2649 /*                                                                    */
2650 /*   This computes C = A << B or C = A >> -B  (in base ten).          */
2651 /*                                                                    */
2652 /*   res is C, the result.  C may be A and/or B (e.g., X=X<<X)        */
2653 /*   lhs is A                                                         */
2654 /*   rhs is B, the number of digits to shift (-ve to right)           */
2655 /*   set is the context                                               */
2656 /*                                                                    */
2657 /* The digits of the coefficient of A are shifted to the left (if B   */
2658 /* is positive) or to the right (if B is negative) without adjusting  */
2659 /* the exponent or the sign of A.                                     */
2660 /*                                                                    */
2661 /* B must be an integer (q=0) and in the range -set->digits through   */
2662 /* +set->digits.                                                      */
2663 /* C must have space for set->digits digits.                          */
2664 /* NaNs are propagated as usual.  Infinities are unaffected (but      */
2665 /* B must be valid).  No status is set unless B is invalid or an      */
2666 /* operand is an sNaN.                                                */
2667 /* ------------------------------------------------------------------ */
2668 decNumber * decNumberShift(decNumber *res, const decNumber *lhs,
2669                            const decNumber *rhs, decContext *set) {
2670   uInt status=0;              /* accumulator */
2671   Int  shift;                 /* rhs as an Int */
2672
2673   #if DECCHECK
2674   if (decCheckOperands(res, lhs, rhs, set)) return res;
2675   #endif
2676
2677   /* NaNs propagate as normal */
2678   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2679     decNaNs(res, lhs, rhs, set, &status);
2680    /* rhs must be an integer */
2681    else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2682     status=DEC_Invalid_operation;
2683    else { /* both numeric, rhs is an integer */
2684     shift=decGetInt(rhs);                    /* [cannot fail] */
2685     if (shift==BADINT                        /* something bad .. */
2686      || shift==BIGODD || shift==BIGEVEN      /* .. very big .. */
2687      || abs(shift)>set->digits)              /* .. or out of range */
2688       status=DEC_Invalid_operation;
2689      else {                                  /* rhs is OK */
2690       decNumberCopy(res, lhs);
2691       if (shift!=0 && !decNumberIsInfinite(res)) { /* something to do */
2692         if (shift>0) {                       /* to left */
2693           if (shift==set->digits) {          /* removing all */
2694             *res->lsu=0;                     /* so place 0 */
2695             res->digits=1;                   /* .. */
2696             }
2697            else {                            /* */
2698             /* first remove leading digits if necessary */
2699             if (res->digits+shift>set->digits) {
2700               decDecap(res, res->digits+shift-set->digits);
2701               /* that updated res->digits; may have gone to 1 (for a */
2702               /* single digit or for zero */
2703               }
2704             if (res->digits>1 || *res->lsu)  /* if non-zero.. */
2705               res->digits=decShiftToMost(res->lsu, res->digits, shift);
2706             } /* partial left */
2707           } /* left */
2708          else { /* to right */
2709           if (-shift>=res->digits) {         /* discarding all */
2710             *res->lsu=0;                     /* so place 0 */
2711             res->digits=1;                   /* .. */
2712             }
2713            else {
2714             decShiftToLeast(res->lsu, D2U(res->digits), -shift);
2715             res->digits-=(-shift);
2716             }
2717           } /* to right */
2718         } /* non-0 non-Inf shift */
2719       } /* rhs OK */
2720     } /* numerics */
2721   if (status!=0) decStatus(res, status, set);
2722   return res;
2723   } /* decNumberShift */
2724
2725 /* ------------------------------------------------------------------ */
2726 /* decNumberSquareRoot -- square root operator                        */
2727 /*                                                                    */
2728 /*   This computes C = squareroot(A)                                  */
2729 /*                                                                    */
2730 /*   res is C, the result.  C may be A                                */
2731 /*   rhs is A                                                         */
2732 /*   set is the context; note that rounding mode has no effect        */
2733 /*                                                                    */
2734 /* C must have space for set->digits digits.                          */
2735 /* ------------------------------------------------------------------ */
2736 /* This uses the following varying-precision algorithm in:            */
2737 /*                                                                    */
2738 /*   Properly Rounded Variable Precision Square Root, T. E. Hull and  */
2739 /*   A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, */
2740 /*   pp229-237, ACM, September 1985.                                  */
2741 /*                                                                    */
2742 /* The square-root is calculated using Newton's method, after which   */
2743 /* a check is made to ensure the result is correctly rounded.         */
2744 /*                                                                    */
2745 /* % [Reformatted original Numerical Turing source code follows.]     */
2746 /* function sqrt(x : real) : real                                     */
2747 /* % sqrt(x) returns the properly rounded approximation to the square */
2748 /* % root of x, in the precision of the calling environment, or it    */
2749 /* % fails if x < 0.                                                  */
2750 /* % t e hull and a abrham, august, 1984                              */
2751 /* if x <= 0 then                                                     */
2752 /*   if x < 0 then                                                    */
2753 /*     assert false                                                   */
2754 /*   else                                                             */
2755 /*     result 0                                                       */
2756 /*   end if                                                           */
2757 /* end if                                                             */
2758 /* var f := setexp(x, 0)  % fraction part of x   [0.1 <= x < 1]       */
2759 /* var e := getexp(x)     % exponent part of x                        */
2760 /* var approx : real                                                  */
2761 /* if e mod 2 = 0  then                                               */
2762 /*   approx := .259 + .819 * f   % approx to root of f                */
2763 /* else                                                               */
2764 /*   f := f/l0                   % adjustments                        */
2765 /*   e := e + 1                  %   for odd                          */
2766 /*   approx := .0819 + 2.59 * f  %   exponent                         */
2767 /* end if                                                             */
2768 /*                                                                    */
2769 /* var p:= 3                                                          */
2770 /* const maxp := currentprecision + 2                                 */
2771 /* loop                                                               */
2772 /*   p := min(2*p - 2, maxp)     % p = 4,6,10, . . . , maxp           */
2773 /*   precision p                                                      */
2774 /*   approx := .5 * (approx + f/approx)                               */
2775 /*   exit when p = maxp                                               */
2776 /* end loop                                                           */
2777 /*                                                                    */
2778 /* % approx is now within 1 ulp of the properly rounded square root   */
2779 /* % of f; to ensure proper rounding, compare squares of (approx -    */
2780 /* % l/2 ulp) and (approx + l/2 ulp) with f.                          */
2781 /* p := currentprecision                                              */
2782 /* begin                                                              */
2783 /*   precision p + 2                                                  */
2784 /*   const approxsubhalf := approx - setexp(.5, -p)                   */
2785 /*   if mulru(approxsubhalf, approxsubhalf) > f then                  */
2786 /*     approx := approx - setexp(.l, -p + 1)                          */
2787 /*   else                                                             */
2788 /*     const approxaddhalf := approx + setexp(.5, -p)                 */
2789 /*     if mulrd(approxaddhalf, approxaddhalf) < f then                */
2790 /*       approx := approx + setexp(.l, -p + 1)                        */
2791 /*     end if                                                         */
2792 /*   end if                                                           */
2793 /* end                                                                */
2794 /* result setexp(approx, e div 2)  % fix exponent                     */
2795 /* end sqrt                                                           */
2796 /* ------------------------------------------------------------------ */
2797 decNumber * decNumberSquareRoot(decNumber *res, const decNumber *rhs,
2798                                 decContext *set) {
2799   decContext workset, approxset;   /* work contexts */
2800   decNumber dzero;                 /* used for constant zero */
2801   Int  maxp;                       /* largest working precision */
2802   Int  workp;                      /* working precision */
2803   Int  residue=0;                  /* rounding residue */
2804   uInt status=0, ignore=0;         /* status accumulators */
2805   uInt rstatus;                    /* .. */
2806   Int  exp;                        /* working exponent */
2807   Int  ideal;                      /* ideal (preferred) exponent */
2808   Int  needbytes;                  /* work */
2809   Int  dropped;                    /* .. */
2810
2811   #if DECSUBSET
2812   decNumber *allocrhs=NULL;        /* non-NULL if rounded rhs allocated */
2813   #endif
2814   /* buffer for f [needs +1 in case DECBUFFER 0] */
2815   decNumber buff[D2N(DECBUFFER+1)];
2816   /* buffer for a [needs +2 to match likely maxp] */
2817   decNumber bufa[D2N(DECBUFFER+2)];
2818   /* buffer for temporary, b [must be same size as a] */
2819   decNumber bufb[D2N(DECBUFFER+2)];
2820   decNumber *allocbuff=NULL;       /* -> allocated buff, iff allocated */
2821   decNumber *allocbufa=NULL;       /* -> allocated bufa, iff allocated */
2822   decNumber *allocbufb=NULL;       /* -> allocated bufb, iff allocated */
2823   decNumber *f=buff;               /* reduced fraction */
2824   decNumber *a=bufa;               /* approximation to result */
2825   decNumber *b=bufb;               /* intermediate result */
2826   /* buffer for temporary variable, up to 3 digits */
2827   decNumber buft[D2N(3)];
2828   decNumber *t=buft;               /* up-to-3-digit constant or work */
2829
2830   #if DECCHECK
2831   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2832   #endif
2833
2834   do {                             /* protect allocated storage */
2835     #if DECSUBSET
2836     if (!set->extended) {
2837       /* reduce operand and set lostDigits status, as needed */
2838       if (rhs->digits>set->digits) {
2839         allocrhs=decRoundOperand(rhs, set, &status);
2840         if (allocrhs==NULL) break;
2841         /* [Note: 'f' allocation below could reuse this buffer if */
2842         /* used, but as this is rare they are kept separate for clarity.] */
2843         rhs=allocrhs;
2844         }
2845       }
2846     #endif
2847     /* [following code does not require input rounding] */
2848
2849     /* handle infinities and NaNs */
2850     if (SPECIALARG) {
2851       if (decNumberIsInfinite(rhs)) {         /* an infinity */
2852         if (decNumberIsNegative(rhs)) status|=DEC_Invalid_operation;
2853          else decNumberCopy(res, rhs);        /* +Infinity */
2854         }
2855        else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
2856       break;
2857       }
2858
2859     /* calculate the ideal (preferred) exponent [floor(exp/2)] */
2860     /* [It would be nicer to write: ideal=rhs->exponent>>1, but this */
2861     /* generates a compiler warning.  Generated code is the same.] */
2862     ideal=(rhs->exponent&~1)/2;         /* target */
2863
2864     /* handle zeros */
2865     if (ISZERO(rhs)) {
2866       decNumberCopy(res, rhs);          /* could be 0 or -0 */
2867       res->exponent=ideal;              /* use the ideal [safe] */
2868       /* use decFinish to clamp any out-of-range exponent, etc. */
2869       decFinish(res, set, &residue, &status);
2870       break;
2871       }
2872
2873     /* any other -x is an oops */
2874     if (decNumberIsNegative(rhs)) {
2875       status|=DEC_Invalid_operation;
2876       break;
2877       }
2878
2879     /* space is needed for three working variables */
2880     /*   f -- the same precision as the RHS, reduced to 0.01->0.99... */
2881     /*   a -- Hull's approximation -- precision, when assigned, is */
2882     /*        currentprecision+1 or the input argument precision, */
2883     /*        whichever is larger (+2 for use as temporary) */
2884     /*   b -- intermediate temporary result (same size as a) */
2885     /* if any is too long for local storage, then allocate */
2886     workp=MAXI(set->digits+1, rhs->digits);  /* actual rounding precision */
2887     workp=MAXI(workp, 7);                    /* at least 7 for low cases */
2888     maxp=workp+2;                            /* largest working precision */
2889
2890     needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
2891     if (needbytes>(Int)sizeof(buff)) {
2892       allocbuff=(decNumber *)malloc(needbytes);
2893       if (allocbuff==NULL) {  /* hopeless -- abandon */
2894         status|=DEC_Insufficient_storage;
2895         break;}
2896       f=allocbuff;            /* use the allocated space */
2897       }
2898     /* a and b both need to be able to hold a maxp-length number */
2899     needbytes=sizeof(decNumber)+(D2U(maxp)-1)*sizeof(Unit);
2900     if (needbytes>(Int)sizeof(bufa)) {            /* [same applies to b] */
2901       allocbufa=(decNumber *)malloc(needbytes);
2902       allocbufb=(decNumber *)malloc(needbytes);
2903       if (allocbufa==NULL || allocbufb==NULL) {   /* hopeless */
2904         status|=DEC_Insufficient_storage;
2905         break;}
2906       a=allocbufa;            /* use the allocated spaces */
2907       b=allocbufb;            /* .. */
2908       }
2909
2910     /* copy rhs -> f, save exponent, and reduce so 0.1 <= f < 1 */
2911     decNumberCopy(f, rhs);
2912     exp=f->exponent+f->digits;               /* adjusted to Hull rules */
2913     f->exponent=-(f->digits);                /* to range */
2914
2915     /* set up working context */
2916     decContextDefault(&workset, DEC_INIT_DECIMAL64);
2917     workset.emax=DEC_MAX_EMAX;
2918     workset.emin=DEC_MIN_EMIN;
2919
2920     /* [Until further notice, no error is possible and status bits */
2921     /* (Rounded, etc.) should be ignored, not accumulated.] */
2922
2923     /* Calculate initial approximation, and allow for odd exponent */
2924     workset.digits=workp;                    /* p for initial calculation */
2925     t->bits=0; t->digits=3;
2926     a->bits=0; a->digits=3;
2927     if ((exp & 1)==0) {                      /* even exponent */
2928       /* Set t=0.259, a=0.819 */
2929       t->exponent=-3;
2930       a->exponent=-3;
2931       #if DECDPUN>=3
2932         t->lsu[0]=259;
2933         a->lsu[0]=819;
2934       #elif DECDPUN==2
2935         t->lsu[0]=59; t->lsu[1]=2;
2936         a->lsu[0]=19; a->lsu[1]=8;
2937       #else
2938         t->lsu[0]=9; t->lsu[1]=5; t->lsu[2]=2;
2939         a->lsu[0]=9; a->lsu[1]=1; a->lsu[2]=8;
2940       #endif
2941       }
2942      else {                                  /* odd exponent */
2943       /* Set t=0.0819, a=2.59 */
2944       f->exponent--;                         /* f=f/10 */
2945       exp++;                                 /* e=e+1 */
2946       t->exponent=-4;
2947       a->exponent=-2;
2948       #if DECDPUN>=3
2949         t->lsu[0]=819;
2950         a->lsu[0]=259;
2951       #elif DECDPUN==2
2952         t->lsu[0]=19; t->lsu[1]=8;
2953         a->lsu[0]=59; a->lsu[1]=2;
2954       #else
2955         t->lsu[0]=9; t->lsu[1]=1; t->lsu[2]=8;
2956         a->lsu[0]=9; a->lsu[1]=5; a->lsu[2]=2;
2957       #endif
2958       }
2959
2960     decMultiplyOp(a, a, f, &workset, &ignore);    /* a=a*f */
2961     decAddOp(a, a, t, &workset, 0, &ignore);      /* ..+t */
2962     /* [a is now the initial approximation for sqrt(f), calculated with */
2963     /* currentprecision, which is also a's precision.] */
2964
2965     /* the main calculation loop */
2966     decNumberZero(&dzero);                   /* make 0 */
2967     decNumberZero(t);                        /* set t = 0.5 */
2968     t->lsu[0]=5;                             /* .. */
2969     t->exponent=-1;                          /* .. */
2970     workset.digits=3;                        /* initial p */
2971     for (; workset.digits<maxp;) {
2972       /* set p to min(2*p - 2, maxp)  [hence 3; or: 4, 6, 10, ... , maxp] */
2973       workset.digits=MINI(workset.digits*2-2, maxp);
2974       /* a = 0.5 * (a + f/a) */
2975       /* [calculated at p then rounded to currentprecision] */
2976       decDivideOp(b, f, a, &workset, DIVIDE, &ignore); /* b=f/a */
2977       decAddOp(b, b, a, &workset, 0, &ignore);         /* b=b+a */
2978       decMultiplyOp(a, b, t, &workset, &ignore);       /* a=b*0.5 */
2979       } /* loop */
2980
2981     /* Here, 0.1 <= a < 1 [Hull], and a has maxp digits */
2982     /* now reduce to length, etc.; this needs to be done with a */
2983     /* having the correct exponent so as to handle subnormals */
2984     /* correctly */
2985     approxset=*set;                          /* get emin, emax, etc. */
2986     approxset.round=DEC_ROUND_HALF_EVEN;
2987     a->exponent+=exp/2;                      /* set correct exponent */
2988     rstatus=0;                               /* clear status */
2989     residue=0;                               /* .. and accumulator */
2990     decCopyFit(a, a, &approxset, &residue, &rstatus);  /* reduce (if needed) */
2991     decFinish(a, &approxset, &residue, &rstatus);      /* clean and finalize */
2992
2993     /* Overflow was possible if the input exponent was out-of-range, */
2994     /* in which case quit */
2995     if (rstatus&DEC_Overflow) {
2996       status=rstatus;                        /* use the status as-is */
2997       decNumberCopy(res, a);                 /* copy to result */
2998       break;
2999       }
3000
3001     /* Preserve status except Inexact/Rounded */
3002     status|=(rstatus & ~(DEC_Rounded|DEC_Inexact));
3003
3004     /* Carry out the Hull correction */
3005     a->exponent-=exp/2;                      /* back to 0.1->1 */
3006
3007     /* a is now at final precision and within 1 ulp of the properly */
3008     /* rounded square root of f; to ensure proper rounding, compare */
3009     /* squares of (a - l/2 ulp) and (a + l/2 ulp) with f. */
3010     /* Here workset.digits=maxp and t=0.5, and a->digits determines */
3011     /* the ulp */
3012     workset.digits--;                             /* maxp-1 is OK now */
3013     t->exponent=-a->digits-1;                     /* make 0.5 ulp */
3014     decAddOp(b, a, t, &workset, DECNEG, &ignore); /* b = a - 0.5 ulp */
3015     workset.round=DEC_ROUND_UP;
3016     decMultiplyOp(b, b, b, &workset, &ignore);    /* b = mulru(b, b) */
3017     decCompareOp(b, f, b, &workset, COMPARE, &ignore); /* b ? f, reversed */
3018     if (decNumberIsNegative(b)) {                 /* f < b [i.e., b > f] */
3019       /* this is the more common adjustment, though both are rare */
3020       t->exponent++;                              /* make 1.0 ulp */
3021       t->lsu[0]=1;                                /* .. */
3022       decAddOp(a, a, t, &workset, DECNEG, &ignore); /* a = a - 1 ulp */
3023       /* assign to approx [round to length] */
3024       approxset.emin-=exp/2;                      /* adjust to match a */
3025       approxset.emax-=exp/2;
3026       decAddOp(a, &dzero, a, &approxset, 0, &ignore);
3027       }
3028      else {
3029       decAddOp(b, a, t, &workset, 0, &ignore);    /* b = a + 0.5 ulp */
3030       workset.round=DEC_ROUND_DOWN;
3031       decMultiplyOp(b, b, b, &workset, &ignore);  /* b = mulrd(b, b) */
3032       decCompareOp(b, b, f, &workset, COMPARE, &ignore);   /* b ? f */
3033       if (decNumberIsNegative(b)) {               /* b < f */
3034         t->exponent++;                            /* make 1.0 ulp */
3035         t->lsu[0]=1;                              /* .. */
3036         decAddOp(a, a, t, &workset, 0, &ignore);  /* a = a + 1 ulp */
3037         /* assign to approx [round to length] */
3038         approxset.emin-=exp/2;                    /* adjust to match a */
3039         approxset.emax-=exp/2;
3040         decAddOp(a, &dzero, a, &approxset, 0, &ignore);
3041         }
3042       }
3043     /* [no errors are possible in the above, and rounding/inexact during */
3044     /* estimation are irrelevant, so status was not accumulated] */
3045
3046     /* Here, 0.1 <= a < 1  (still), so adjust back */
3047     a->exponent+=exp/2;                      /* set correct exponent */
3048
3049     /* count droppable zeros [after any subnormal rounding] by */
3050     /* trimming a copy */
3051     decNumberCopy(b, a);
3052     decTrim(b, set, 1, 1, &dropped);         /* [drops trailing zeros] */
3053
3054     /* Set Inexact and Rounded.  The answer can only be exact if */
3055     /* it is short enough so that squaring it could fit in workp */
3056     /* digits, so this is the only (relatively rare) condition that */
3057     /* a careful check is needed */
3058     if (b->digits*2-1 > workp) {             /* cannot fit */
3059       status|=DEC_Inexact|DEC_Rounded;
3060       }
3061      else {                                  /* could be exact/unrounded */
3062       uInt mstatus=0;                        /* local status */
3063       decMultiplyOp(b, b, b, &workset, &mstatus); /* try the multiply */
3064       if (mstatus&DEC_Overflow) {            /* result just won't fit */
3065         status|=DEC_Inexact|DEC_Rounded;
3066         }
3067        else {                                /* plausible */
3068         decCompareOp(t, b, rhs, &workset, COMPARE, &mstatus); /* b ? rhs */
3069         if (!ISZERO(t)) status|=DEC_Inexact|DEC_Rounded; /* not equal */
3070          else {                              /* is Exact */
3071           /* here, dropped is the count of trailing zeros in 'a' */
3072           /* use closest exponent to ideal... */
3073           Int todrop=ideal-a->exponent;      /* most that can be dropped */
3074           if (todrop<0) status|=DEC_Rounded; /* ideally would add 0s */
3075            else {                            /* unrounded */
3076             /* there are some to drop, but emax may not allow all */
3077             Int maxexp=set->emax-set->digits+1;
3078             Int maxdrop=maxexp-a->exponent;
3079             if (todrop>maxdrop && set->clamp) { /* apply clamping */
3080               todrop=maxdrop;
3081               status|=DEC_Clamped;
3082               }
3083             if (dropped<todrop) {            /* clamp to those available */
3084               todrop=dropped;
3085               status|=DEC_Clamped;
3086               }
3087             if (todrop>0) {                  /* have some to drop */
3088               decShiftToLeast(a->lsu, D2U(a->digits), todrop);
3089               a->exponent+=todrop;           /* maintain numerical value */
3090               a->digits-=todrop;             /* new length */
3091               }
3092             }
3093           }
3094         }
3095       }
3096
3097     /* double-check Underflow, as perhaps the result could not have */
3098     /* been subnormal (initial argument too big), or it is now Exact */
3099     if (status&DEC_Underflow) {
3100       Int ae=rhs->exponent+rhs->digits-1;    /* adjusted exponent */
3101       /* check if truly subnormal */
3102       #if DECEXTFLAG                         /* DEC_Subnormal too */
3103         if (ae>=set->emin*2) status&=~(DEC_Subnormal|DEC_Underflow);
3104       #else
3105         if (ae>=set->emin*2) status&=~DEC_Underflow;
3106       #endif
3107       /* check if truly inexact */
3108       if (!(status&DEC_Inexact)) status&=~DEC_Underflow;
3109       }
3110
3111     decNumberCopy(res, a);                   /* a is now the result */
3112     } while(0);                              /* end protected */
3113
3114   free(allocbuff);      /* drop any storage used */
3115   free(allocbufa);      /* .. */
3116   free(allocbufb);      /* .. */
3117   #if DECSUBSET
3118   free(allocrhs);            /* .. */
3119   #endif
3120   if (status!=0) decStatus(res, status, set);/* then report status */
3121   #if DECCHECK
3122   decCheckInexact(res, set);
3123   #endif
3124   return res;
3125   } /* decNumberSquareRoot */
3126
3127 /* ------------------------------------------------------------------ */
3128 /* decNumberSubtract -- subtract two Numbers                          */
3129 /*                                                                    */
3130 /*   This computes C = A - B                                          */
3131 /*                                                                    */
3132 /*   res is C, the result.  C may be A and/or B (e.g., X=X-X)         */
3133 /*   lhs is A                                                         */
3134 /*   rhs is B                                                         */
3135 /*   set is the context                                               */
3136 /*                                                                    */
3137 /* C must have space for set->digits digits.                          */
3138 /* ------------------------------------------------------------------ */
3139 decNumber * decNumberSubtract(decNumber *res, const decNumber *lhs,
3140                               const decNumber *rhs, decContext *set) {
3141   uInt status=0;                        /* accumulator */
3142
3143   decAddOp(res, lhs, rhs, set, DECNEG, &status);
3144   if (status!=0) decStatus(res, status, set);
3145   #if DECCHECK
3146   decCheckInexact(res, set);
3147   #endif
3148   return res;
3149   } /* decNumberSubtract */
3150
3151 /* ------------------------------------------------------------------ */
3152 /* decNumberToIntegralExact -- round-to-integral-value with InExact   */
3153 /* decNumberToIntegralValue -- round-to-integral-value                */
3154 /*                                                                    */
3155 /*   res is the result                                                */
3156 /*   rhs is input number                                              */
3157 /*   set is the context                                               */
3158 /*                                                                    */
3159 /* res must have space for any value of rhs.                          */
3160 /*                                                                    */
3161 /* This implements the IEEE special operators and therefore treats    */
3162 /* special values as valid.  For finite numbers it returns            */
3163 /* rescale(rhs, 0) if rhs->exponent is <0.                            */
3164 /* Otherwise the result is rhs (so no error is possible, except for   */
3165 /* sNaN).                                                             */
3166 /*                                                                    */
3167 /* The context is used for rounding mode and status after sNaN, but   */
3168 /* the digits setting is ignored.  The Exact version will signal      */
3169 /* Inexact if the result differs numerically from rhs; the other      */
3170 /* never signals Inexact.                                             */
3171 /* ------------------------------------------------------------------ */
3172 decNumber * decNumberToIntegralExact(decNumber *res, const decNumber *rhs,
3173                                      decContext *set) {
3174   decNumber dn;
3175   decContext workset;              /* working context */
3176   uInt status=0;                   /* accumulator */
3177
3178   #if DECCHECK
3179   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
3180   #endif
3181
3182   /* handle infinities and NaNs */
3183   if (SPECIALARG) {
3184     if (decNumberIsInfinite(rhs)) decNumberCopy(res, rhs); /* an Infinity */
3185      else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
3186     }
3187    else { /* finite */
3188     /* have a finite number; no error possible (res must be big enough) */
3189     if (rhs->exponent>=0) return decNumberCopy(res, rhs);
3190     /* that was easy, but if negative exponent there is work to do... */
3191     workset=*set;                  /* clone rounding, etc. */
3192     workset.digits=rhs->digits;    /* no length rounding */
3193     workset.traps=0;               /* no traps */
3194     decNumberZero(&dn);            /* make a number with exponent 0 */
3195     decNumberQuantize(res, rhs, &dn, &workset);
3196     status|=workset.status;
3197     }
3198   if (status!=0) decStatus(res, status, set);
3199   return res;
3200   } /* decNumberToIntegralExact */
3201
3202 decNumber * decNumberToIntegralValue(decNumber *res, const decNumber *rhs,
3203                                      decContext *set) {
3204   decContext workset=*set;         /* working context */
3205   workset.traps=0;                 /* no traps */
3206   decNumberToIntegralExact(res, rhs, &workset);
3207   /* this never affects set, except for sNaNs; NaN will have been set */
3208   /* or propagated already, so no need to call decStatus */
3209   set->status|=workset.status&DEC_Invalid_operation;
3210   return res;
3211   } /* decNumberToIntegralValue */
3212
3213 /* ------------------------------------------------------------------ */
3214 /* decNumberXor -- XOR two Numbers, digitwise                         */
3215 /*                                                                    */
3216 /*   This computes C = A ^ B                                          */
3217 /*                                                                    */
3218 /*   res is C, the result.  C may be A and/or B (e.g., X=X^X)         */
3219 /*   lhs is A                                                         */
3220 /*   rhs is B                                                         */
3221 /*   set is the context (used for result length and error report)     */
3222 /*                                                                    */
3223 /* C must have space for set->digits digits.                          */
3224 /*                                                                    */
3225 /* Logical function restrictions apply (see above); a NaN is          */
3226 /* returned with Invalid_operation if a restriction is violated.      */
3227 /* ------------------------------------------------------------------ */
3228 decNumber * decNumberXor(decNumber *res, const decNumber *lhs,
3229                          const decNumber *rhs, decContext *set) {
3230   const Unit *ua, *ub;                  /* -> operands */
3231   const Unit *msua, *msub;              /* -> operand msus */
3232   Unit  *uc, *msuc;                     /* -> result and its msu */
3233   Int   msudigs;                        /* digits in res msu */
3234   #if DECCHECK
3235   if (decCheckOperands(res, lhs, rhs, set)) return res;
3236   #endif
3237
3238   if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
3239    || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
3240     decStatus(res, DEC_Invalid_operation, set);
3241     return res;
3242     }
3243   /* operands are valid */
3244   ua=lhs->lsu;                          /* bottom-up */
3245   ub=rhs->lsu;                          /* .. */
3246   uc=res->lsu;                          /* .. */
3247   msua=ua+D2U(lhs->digits)-1;           /* -> msu of lhs */
3248   msub=ub+D2U(rhs->digits)-1;           /* -> msu of rhs */
3249   msuc=uc+D2U(set->digits)-1;           /* -> msu of result */
3250   msudigs=MSUDIGITS(set->digits);       /* [faster than remainder] */
3251   for (; uc<=msuc; ua++, ub++, uc++) {  /* Unit loop */
3252     Unit a, b;                          /* extract units */
3253     if (ua>msua) a=0;
3254      else a=*ua;
3255     if (ub>msub) b=0;
3256      else b=*ub;
3257     *uc=0;                              /* can now write back */
3258     if (a|b) {                          /* maybe 1 bits to examine */
3259       Int i, j;
3260       /* This loop could be unrolled and/or use BIN2BCD tables */
3261       for (i=0; i<DECDPUN; i++) {
3262         if ((a^b)&1) *uc=*uc+(Unit)powers[i];     /* effect XOR */
3263         j=a%10;
3264         a=a/10;
3265         j|=b%10;
3266         b=b/10;
3267         if (j>1) {
3268           decStatus(res, DEC_Invalid_operation, set);
3269           return res;
3270           }
3271         if (uc==msuc && i==msudigs-1) break;      /* just did final digit */
3272         } /* each digit */
3273       } /* non-zero */
3274     } /* each unit */
3275   /* [here uc-1 is the msu of the result] */
3276   res->digits=decGetDigits(res->lsu, uc-res->lsu);
3277   res->exponent=0;                      /* integer */
3278   res->bits=0;                          /* sign=0 */
3279   return res;  /* [no status to set] */
3280   } /* decNumberXor */
3281
3282
3283 /* ================================================================== */
3284 /* Utility routines                                                   */
3285 /* ================================================================== */
3286
3287 /* ------------------------------------------------------------------ */
3288 /* decNumberClass -- return the decClass of a decNumber               */
3289 /*   dn -- the decNumber to test                                      */
3290 /*   set -- the context to use for Emin                               */
3291 /*   returns the decClass enum                                        */
3292 /* ------------------------------------------------------------------ */
3293 enum decClass decNumberClass(const decNumber *dn, decContext *set) {
3294   if (decNumberIsSpecial(dn)) {
3295     if (decNumberIsQNaN(dn)) return DEC_CLASS_QNAN;
3296     if (decNumberIsSNaN(dn)) return DEC_CLASS_SNAN;
3297     /* must be an infinity */
3298     if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_INF;
3299     return DEC_CLASS_POS_INF;
3300     }
3301   /* is finite */
3302   if (decNumberIsNormal(dn, set)) { /* most common */
3303     if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_NORMAL;
3304     return DEC_CLASS_POS_NORMAL;
3305     }
3306   /* is subnormal or zero */
3307   if (decNumberIsZero(dn)) {    /* most common */
3308     if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_ZERO;
3309     return DEC_CLASS_POS_ZERO;
3310     }
3311   if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_SUBNORMAL;
3312   return DEC_CLASS_POS_SUBNORMAL;
3313   } /* decNumberClass */
3314
3315 /* ------------------------------------------------------------------ */
3316 /* decNumberClassToString -- convert decClass to a string             */
3317 /*                                                                    */
3318 /*  eclass is a valid decClass                                        */
3319 /*  returns a constant string describing the class (max 13+1 chars)   */
3320 /* ------------------------------------------------------------------ */
3321 const char *decNumberClassToString(enum decClass eclass) {
3322   if (eclass==DEC_CLASS_POS_NORMAL)    return DEC_ClassString_PN;
3323   if (eclass==DEC_CLASS_NEG_NORMAL)    return DEC_ClassString_NN;
3324   if (eclass==DEC_CLASS_POS_ZERO)      return DEC_ClassString_PZ;
3325   if (eclass==DEC_CLASS_NEG_ZERO)      return DEC_ClassString_NZ;
3326   if (eclass==DEC_CLASS_POS_SUBNORMAL) return DEC_ClassString_PS;
3327   if (eclass==DEC_CLASS_NEG_SUBNORMAL) return DEC_ClassString_NS;
3328   if (eclass==DEC_CLASS_POS_INF)       return DEC_ClassString_PI;
3329   if (eclass==DEC_CLASS_NEG_INF)       return DEC_ClassString_NI;
3330   if (eclass==DEC_CLASS_QNAN)          return DEC_ClassString_QN;
3331   if (eclass==DEC_CLASS_SNAN)          return DEC_ClassString_SN;
3332   return DEC_ClassString_UN;           /* Unknown */
3333   } /* decNumberClassToString */
3334
3335 /* ------------------------------------------------------------------ */
3336 /* decNumberCopy -- copy a number                                     */
3337 /*                                                                    */
3338 /*   dest is the target decNumber                                     */
3339 /*   src  is the source decNumber                                     */
3340 /*   returns dest                                                     */
3341 /*                                                                    */
3342 /* (dest==src is allowed and is a no-op)                              */
3343 /* All fields are updated as required.  This is a utility operation,  */
3344 /* so special values are unchanged and no error is possible.          */
3345 /* ------------------------------------------------------------------ */
3346 decNumber * decNumberCopy(decNumber *dest, const decNumber *src) {
3347
3348   #if DECCHECK
3349   if (src==NULL) return decNumberZero(dest);
3350   #endif
3351
3352   if (dest==src) return dest;                /* no copy required */
3353
3354   /* Use explicit assignments here as structure assignment could copy */
3355   /* more than just the lsu (for small DECDPUN).  This would not affect */
3356   /* the value of the results, but could disturb test harness spill */
3357   /* checking. */
3358   dest->bits=src->bits;
3359   dest->exponent=src->exponent;
3360   dest->digits=src->digits;
3361   dest->lsu[0]=src->lsu[0];
3362   if (src->digits>DECDPUN) {                 /* more Units to come */
3363     const Unit *smsup, *s;                   /* work */
3364     Unit  *d;                                /* .. */
3365     /* memcpy for the remaining Units would be safe as they cannot */
3366     /* overlap.  However, this explicit loop is faster in short cases. */
3367     d=dest->lsu+1;                           /* -> first destination */
3368     smsup=src->lsu+D2U(src->digits);         /* -> source msu+1 */
3369     for (s=src->lsu+1; s<smsup; s++, d++) *d=*s;
3370     }
3371   return dest;
3372   } /* decNumberCopy */
3373
3374 /* ------------------------------------------------------------------ */
3375 /* decNumberCopyAbs -- quiet absolute value operator                  */
3376 /*                                                                    */
3377 /*   This sets C = abs(A)                                             */
3378 /*                                                                    */
3379 /*   res is C, the result.  C may be A                                */
3380 /*   rhs is A                                                         */
3381 /*                                                                    */
3382 /* C must have space for set->digits digits.                          */
3383 /* No exception or error can occur; this is a quiet bitwise operation.*/
3384 /* See also decNumberAbs for a checking version of this.              */
3385 /* ------------------------------------------------------------------ */
3386 decNumber * decNumberCopyAbs(decNumber *res, const decNumber *rhs) {
3387   #if DECCHECK
3388   if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3389   #endif
3390   decNumberCopy(res, rhs);
3391   res->bits&=~DECNEG;                   /* turn off sign */
3392   return res;
3393   } /* decNumberCopyAbs */
3394
3395 /* ------------------------------------------------------------------ */
3396 /* decNumberCopyNegate -- quiet negate value operator                 */
3397 /*                                                                    */
3398 /*   This sets C = negate(A)                                          */
3399 /*                                                                    */
3400 /*   res is C, the result.  C may be A                                */
3401 /*   rhs is A                                                         */
3402 /*                                                                    */
3403 /* C must have space for set->digits digits.                          */
3404 /* No exception or error can occur; this is a quiet bitwise operation.*/
3405 /* See also decNumberMinus for a checking version of this.            */
3406 /* ------------------------------------------------------------------ */
3407 decNumber * decNumberCopyNegate(decNumber *res, const decNumber *rhs) {
3408   #if DECCHECK
3409   if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3410   #endif
3411   decNumberCopy(res, rhs);
3412   res->bits^=DECNEG;                    /* invert the sign */
3413   return res;
3414   } /* decNumberCopyNegate */
3415
3416 /* ------------------------------------------------------------------ */
3417 /* decNumberCopySign -- quiet copy and set sign operator              */
3418 /*                                                                    */
3419 /*   This sets C = A with the sign of B                               */
3420 /*                                                                    */
3421 /*   res is C, the result.  C may be A                                */
3422 /*   lhs is A                                                         */
3423 /*   rhs is B                                                         */
3424 /*                                                                    */
3425 /* C must have space for set->digits digits.                          */
3426 /* No exception or error can occur; this is a quiet bitwise operation.*/
3427 /* ------------------------------------------------------------------ */
3428 decNumber * decNumberCopySign(decNumber *res, const decNumber *lhs,
3429                               const decNumber *rhs) {
3430   uByte sign;                           /* rhs sign */
3431   #if DECCHECK
3432   if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3433   #endif
3434   sign=rhs->bits & DECNEG;              /* save sign bit */
3435   decNumberCopy(res, lhs);
3436   res->bits&=~DECNEG;                   /* clear the sign */
3437   res->bits|=sign;                      /* set from rhs */
3438   return res;
3439   } /* decNumberCopySign */
3440
3441 /* ------------------------------------------------------------------ */
3442 /* decNumberGetBCD -- get the coefficient in BCD8                     */
3443 /*   dn is the source decNumber                                       */
3444 /*   bcd is the uInt array that will receive dn->digits BCD bytes,    */
3445 /*     most-significant at offset 0                                   */
3446 /*   returns bcd                                                      */
3447 /*                                                                    */
3448 /* bcd must have at least dn->digits bytes.  No error is possible; if */
3449 /* dn is a NaN or Infinite, digits must be 1 and the coefficient 0.   */
3450 /* ------------------------------------------------------------------ */
3451 uByte * decNumberGetBCD(const decNumber *dn, uByte *bcd) {
3452   uByte *ub=bcd+dn->digits-1;      /* -> lsd */
3453   const Unit *up=dn->lsu;          /* Unit pointer, -> lsu */
3454
3455   #if DECDPUN==1                   /* trivial simple copy */
3456     for (; ub>=bcd; ub--, up++) *ub=*up;
3457   #else                            /* chopping needed */
3458     uInt u=*up;                    /* work */
3459     uInt cut=DECDPUN;              /* downcounter through unit */
3460     for (; ub>=bcd; ub--) {
3461       *ub=(uByte)(u%10);           /* [*6554 trick inhibits, here] */
3462       u=u/10;
3463       cut--;
3464       if (cut>0) continue;         /* more in this unit */
3465       up++;
3466       u=*up;
3467       cut=DECDPUN;
3468       }
3469   #endif
3470   return bcd;
3471   } /* decNumberGetBCD */
3472
3473 /* ------------------------------------------------------------------ */
3474 /* decNumberSetBCD -- set (replace) the coefficient from BCD8         */
3475 /*   dn is the target decNumber                                       */
3476 /*   bcd is the uInt array that will source n BCD bytes, most-        */
3477 /*     significant at offset 0                                        */
3478 /*   n is the number of digits in the source BCD array (bcd)          */
3479 /*   returns dn                                                       */
3480 /*                                                                    */
3481 /* dn must have space for at least n digits.  No error is possible;   */
3482 /* if dn is a NaN, or Infinite, or is to become a zero, n must be 1   */
3483 /* and bcd[0] zero.                                                   */
3484 /* ------------------------------------------------------------------ */
3485 decNumber * decNumberSetBCD(decNumber *dn, const uByte *bcd, uInt n) {
3486   Unit *up=dn->lsu+D2U(dn->digits)-1;   /* -> msu [target pointer] */
3487   const uByte *ub=bcd;                  /* -> source msd */
3488
3489   #if DECDPUN==1                        /* trivial simple copy */
3490     for (; ub<bcd+n; ub++, up--) *up=*ub;
3491   #else                                 /* some assembly needed */
3492     /* calculate how many digits in msu, and hence first cut */
3493     Int cut=MSUDIGITS(n);               /* [faster than remainder] */
3494     for (;up>=dn->lsu; up--) {          /* each Unit from msu */
3495       *up=0;                            /* will take <=DECDPUN digits */
3496       for (; cut>0; ub++, cut--) *up=X10(*up)+*ub;
3497       cut=DECDPUN;                      /* next Unit has all digits */
3498       }
3499   #endif
3500   dn->digits=n;                         /* set digit count */
3501   return dn;
3502   } /* decNumberSetBCD */
3503
3504 /* ------------------------------------------------------------------ */
3505 /* decNumberIsNormal -- test normality of a decNumber                 */
3506 /*   dn is the decNumber to test                                      */
3507 /*   set is the context to use for Emin                               */
3508 /*   returns 1 if |dn| is finite and >=Nmin, 0 otherwise              */
3509 /* ------------------------------------------------------------------ */
3510 Int decNumberIsNormal(const decNumber *dn, decContext *set) {
3511   Int ae;                               /* adjusted exponent */
3512   #if DECCHECK
3513   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3514   #endif
3515
3516   if (decNumberIsSpecial(dn)) return 0; /* not finite */
3517   if (decNumberIsZero(dn)) return 0;    /* not non-zero */
3518
3519   ae=dn->exponent+dn->digits-1;         /* adjusted exponent */
3520   if (ae<set->emin) return 0;           /* is subnormal */
3521   return 1;
3522   } /* decNumberIsNormal */
3523
3524 /* ------------------------------------------------------------------ */
3525 /* decNumberIsSubnormal -- test subnormality of a decNumber           */
3526 /*   dn is the decNumber to test                                      */
3527 /*   set is the context to use for Emin                               */
3528 /*   returns 1 if |dn| is finite, non-zero, and <Nmin, 0 otherwise    */
3529 /* ------------------------------------------------------------------ */
3530 Int decNumberIsSubnormal(const decNumber *dn, decContext *set) {
3531   Int ae;                               /* adjusted exponent */
3532   #if DECCHECK
3533   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3534   #endif
3535
3536   if (decNumberIsSpecial(dn)) return 0; /* not finite */
3537   if (decNumberIsZero(dn)) return 0;    /* not non-zero */
3538
3539   ae=dn->exponent+dn->digits-1;         /* adjusted exponent */
3540   if (ae<set->emin) return 1;           /* is subnormal */
3541   return 0;
3542   } /* decNumberIsSubnormal */
3543
3544 /* ------------------------------------------------------------------ */
3545 /* decNumberTrim -- remove insignificant zeros                        */
3546 /*                                                                    */
3547 /*   dn is the number to trim                                         */
3548 /*   returns dn                                                       */
3549 /*                                                                    */
3550 /* All fields are updated as required.  This is a utility operation,  */
3551 /* so special values are unchanged and no error is possible.  The     */
3552 /* zeros are removed unconditionally.                                 */
3553 /* ------------------------------------------------------------------ */
3554 decNumber * decNumberTrim(decNumber *dn) {
3555   Int  dropped;                    /* work */
3556   decContext set;                  /* .. */
3557   #if DECCHECK
3558   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, DECUNCONT)) return dn;
3559   #endif
3560   decContextDefault(&set, DEC_INIT_BASE);    /* clamp=0 */
3561   return decTrim(dn, &set, 0, 1, &dropped);
3562   } /* decNumberTrim */
3563
3564 /* ------------------------------------------------------------------ */
3565 /* decNumberVersion -- return the name and version of this module     */
3566 /*                                                                    */
3567 /* No error is possible.                                              */
3568 /* ------------------------------------------------------------------ */
3569 const char * decNumberVersion(void) {
3570   return DECVERSION;
3571   } /* decNumberVersion */
3572
3573 /* ------------------------------------------------------------------ */
3574 /* decNumberZero -- set a number to 0                                 */
3575 /*                                                                    */
3576 /*   dn is the number to set, with space for one digit                */
3577 /*   returns dn                                                       */
3578 /*                                                                    */
3579 /* No error is possible.                                              */
3580 /* ------------------------------------------------------------------ */
3581 /* Memset is not used as it is much slower in some environments. */
3582 decNumber * decNumberZero(decNumber *dn) {
3583
3584   #if DECCHECK
3585   if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
3586   #endif
3587
3588   dn->bits=0;
3589   dn->exponent=0;
3590   dn->digits=1;
3591   dn->lsu[0]=0;
3592   return dn;
3593   } /* decNumberZero */
3594
3595 /* ================================================================== */
3596 /* Local routines                                                     */
3597 /* ================================================================== */
3598
3599 /* ------------------------------------------------------------------ */
3600 /* decToString -- lay out a number into a string                      */
3601 /*                                                                    */
3602 /*   dn     is the number to lay out                                  */
3603 /*   string is where to lay out the number                            */
3604 /*   eng    is 1 if Engineering, 0 if Scientific                      */
3605 /*                                                                    */
3606 /* string must be at least dn->digits+14 characters long              */
3607 /* No error is possible.                                              */
3608 /*                                                                    */
3609 /* Note that this routine can generate a -0 or 0.000.  These are      */
3610 /* never generated in subset to-number or arithmetic, but can occur   */
3611 /* in non-subset arithmetic (e.g., -1*0 or 1.234-1.234).              */
3612 /* ------------------------------------------------------------------ */
3613 /* If DECCHECK is enabled the string "?" is returned if a number is */
3614 /* invalid. */
3615 static void decToString(const decNumber *dn, char *string, Flag eng) {
3616   Int exp=dn->exponent;       /* local copy */
3617   Int e;                      /* E-part value */
3618   Int pre;                    /* digits before the '.' */
3619   Int cut;                    /* for counting digits in a Unit */
3620   char *c=string;             /* work [output pointer] */
3621   const Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [input pointer] */
3622   uInt u, pow;                /* work */
3623
3624   #if DECCHECK
3625   if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) {
3626     strcpy(string, "?");
3627     return;}
3628   #endif
3629
3630   if (decNumberIsNegative(dn)) {   /* Negatives get a minus */
3631     *c='-';
3632     c++;
3633     }
3634   if (dn->bits&DECSPECIAL) {       /* Is a special value */
3635     if (decNumberIsInfinite(dn)) {
3636       strcpy(c,   "Inf");
3637       strcpy(c+3, "inity");
3638       return;}
3639     /* a NaN */
3640     if (dn->bits&DECSNAN) {        /* signalling NaN */
3641       *c='s';
3642       c++;
3643       }
3644     strcpy(c, "NaN");
3645     c+=3;                          /* step past */
3646     /* if not a clean non-zero coefficient, that's all there is in a */
3647     /* NaN string */
3648     if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return;
3649     /* [drop through to add integer] */
3650     }
3651
3652   /* calculate how many digits in msu, and hence first cut */
3653   cut=MSUDIGITS(dn->digits);       /* [faster than remainder] */
3654   cut--;                           /* power of ten for digit */
3655
3656   if (exp==0) {                    /* simple integer [common fastpath] */
3657     for (;up>=dn->lsu; up--) {     /* each Unit from msu */
3658       u=*up;                       /* contains DECDPUN digits to lay out */
3659       for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow);
3660       cut=DECDPUN-1;               /* next Unit has all digits */
3661       }
3662     *c='\0';                       /* terminate the string */
3663     return;}
3664
3665   /* non-0 exponent -- assume plain form */
3666   pre=dn->digits+exp;              /* digits before '.' */
3667   e=0;                             /* no E */
3668   if ((exp>0) || (pre<-5)) {       /* need exponential form */
3669     e=exp+dn->digits-1;            /* calculate E value */
3670     pre=1;                         /* assume one digit before '.' */
3671     if (eng && (e!=0)) {           /* engineering: may need to adjust */
3672       Int adj;                     /* adjustment */
3673       /* The C remainder operator is undefined for negative numbers, so */
3674       /* a positive remainder calculation must be used here */
3675       if (e<0) {
3676         adj=(-e)%3;
3677         if (adj!=0) adj=3-adj;
3678         }
3679        else { /* e>0 */
3680         adj=e%3;
3681         }
3682       e=e-adj;
3683       /* if dealing with zero still produce an exponent which is a */
3684       /* multiple of three, as expected, but there will only be the */
3685       /* one zero before the E, still.  Otherwise note the padding. */
3686       if (!ISZERO(dn)) pre+=adj;
3687        else {  /* is zero */
3688         if (adj!=0) {              /* 0.00Esnn needed */
3689           e=e+3;
3690           pre=-(2-adj);
3691           }
3692         } /* zero */
3693       } /* eng */
3694     } /* need exponent */
3695
3696   /* lay out the digits of the coefficient, adding 0s and . as needed */
3697   u=*up;
3698   if (pre>0) {                     /* xxx.xxx or xx00 (engineering) form */
3699     Int n=pre;
3700     for (; pre>0; pre--, c++, cut--) {
3701       if (cut<0) {                 /* need new Unit */
3702         if (up==dn->lsu) break;    /* out of input digits (pre>digits) */
3703         up--;
3704         cut=DECDPUN-1;
3705         u=*up;
3706         }
3707       TODIGIT(u, cut, c, pow);
3708       }
3709     if (n<dn->digits) {            /* more to come, after '.' */
3710       *c='.'; c++;
3711       for (;; c++, cut--) {
3712         if (cut<0) {               /* need new Unit */
3713           if (up==dn->lsu) break;  /* out of input digits */
3714           up--;
3715           cut=DECDPUN-1;
3716           u=*up;
3717           }
3718         TODIGIT(u, cut, c, pow);
3719         }
3720       }
3721      else for (; pre>0; pre--, c++) *c='0'; /* 0 padding (for engineering) needed */
3722     }
3723    else {                          /* 0.xxx or 0.000xxx form */
3724     *c='0'; c++;
3725     *c='.'; c++;
3726     for (; pre<0; pre++, c++) *c='0';   /* add any 0's after '.' */
3727     for (; ; c++, cut--) {
3728       if (cut<0) {                 /* need new Unit */
3729         if (up==dn->lsu) break;    /* out of input digits */
3730         up--;
3731         cut=DECDPUN-1;
3732         u=*up;
3733         }
3734       TODIGIT(u, cut, c, pow);
3735       }
3736     }
3737
3738   /* Finally add the E-part, if needed.  It will never be 0, has a
3739      base maximum and minimum of +999999999 through -999999999, but
3740      could range down to -1999999998 for anormal numbers */
3741   if (e!=0) {
3742     Flag had=0;               /* 1=had non-zero */
3743     *c='E'; c++;
3744     *c='+'; c++;              /* assume positive */
3745     u=e;                      /* .. */
3746     if (e<0) {
3747       *(c-1)='-';             /* oops, need - */
3748       u=-e;                   /* uInt, please */
3749       }
3750     /* lay out the exponent [_itoa or equivalent is not ANSI C] */
3751     for (cut=9; cut>=0; cut--) {
3752       TODIGIT(u, cut, c, pow);
3753       if (*c=='0' && !had) continue;    /* skip leading zeros */
3754       had=1;                            /* had non-0 */
3755       c++;                              /* step for next */
3756       } /* cut */
3757     }
3758   *c='\0';          /* terminate the string (all paths) */
3759   return;
3760   } /* decToString */
3761
3762 /* ------------------------------------------------------------------ */
3763 /* decAddOp -- add/subtract operation                                 */
3764 /*                                                                    */
3765 /*   This computes C = A + B                                          */
3766 /*                                                                    */
3767 /*   res is C, the result.  C may be A and/or B (e.g., X=X+X)         */
3768 /*   lhs is A                                                         */
3769 /*   rhs is B                                                         */
3770 /*   set is the context                                               */
3771 /*   negate is DECNEG if rhs should be negated, or 0 otherwise        */
3772 /*   status accumulates status for the caller                         */
3773 /*                                                                    */
3774 /* C must have space for set->digits digits.                          */
3775 /* Inexact in status must be 0 for correct Exact zero sign in result  */
3776 /* ------------------------------------------------------------------ */
3777 /* If possible, the coefficient is calculated directly into C.        */
3778 /* However, if:                                                       */
3779 /*   -- a digits+1 calculation is needed because the numbers are      */
3780 /*      unaligned and span more than set->digits digits               */
3781 /*   -- a carry to digits+1 digits looks possible                     */
3782 /*   -- C is the same as A or B, and the result would destructively   */
3783 /*      overlap the A or B coefficient                                */
3784 /* then the result must be calculated into a temporary buffer.  In    */
3785 /* this case a local (stack) buffer is used if possible, and only if  */
3786 /* too long for that does malloc become the final resort.             */
3787 /*                                                                    */
3788 /* Misalignment is handled as follows:                                */
3789 /*   Apad: (AExp>BExp) Swap operands and proceed as for BExp>AExp.    */
3790 /*   BPad: Apply the padding by a combination of shifting (whole      */
3791 /*         units) and multiplication (part units).                    */
3792 /*                                                                    */
3793 /* Addition, especially x=x+1, is speed-critical.                     */
3794 /* The static buffer is larger than might be expected to allow for    */
3795 /* calls from higher-level funtions (notable exp).                    */
3796 /* ------------------------------------------------------------------ */
3797 static decNumber * decAddOp(decNumber *res, const decNumber *lhs,
3798                             const decNumber *rhs, decContext *set,
3799                             uByte negate, uInt *status) {
3800   #if DECSUBSET
3801   decNumber *alloclhs=NULL;        /* non-NULL if rounded lhs allocated */
3802   decNumber *allocrhs=NULL;        /* .., rhs */
3803   #endif
3804   Int   rhsshift;                  /* working shift (in Units) */
3805   Int   maxdigits;                 /* longest logical length */
3806   Int   mult;                      /* multiplier */
3807   Int   residue;                   /* rounding accumulator */
3808   uByte bits;                      /* result bits */
3809   Flag  diffsign;                  /* non-0 if arguments have different sign */
3810   Unit  *acc;                      /* accumulator for result */
3811   Unit  accbuff[SD2U(DECBUFFER*2+20)]; /* local buffer [*2+20 reduces many */
3812                                    /* allocations when called from */
3813                                    /* other operations, notable exp] */
3814   Unit  *allocacc=NULL;            /* -> allocated acc buffer, iff allocated */
3815   Int   reqdigits=set->digits;     /* local copy; requested DIGITS */
3816   Int   padding;                   /* work */
3817
3818   #if DECCHECK
3819   if (decCheckOperands(res, lhs, rhs, set)) return res;
3820   #endif
3821
3822   do {                             /* protect allocated storage */
3823     #if DECSUBSET
3824     if (!set->extended) {
3825       /* reduce operands and set lostDigits status, as needed */
3826       if (lhs->digits>reqdigits) {
3827         alloclhs=decRoundOperand(lhs, set, status);
3828         if (alloclhs==NULL) break;
3829         lhs=alloclhs;
3830         }
3831       if (rhs->digits>reqdigits) {
3832         allocrhs=decRoundOperand(rhs, set, status);
3833         if (allocrhs==NULL) break;
3834         rhs=allocrhs;
3835         }
3836       }
3837     #endif
3838     /* [following code does not require input rounding] */
3839
3840     /* note whether signs differ [used all paths] */
3841     diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG);
3842
3843     /* handle infinities and NaNs */
3844     if (SPECIALARGS) {                  /* a special bit set */
3845       if (SPECIALARGS & (DECSNAN | DECNAN))  /* a NaN */
3846         decNaNs(res, lhs, rhs, set, status);
3847        else { /* one or two infinities */
3848         if (decNumberIsInfinite(lhs)) { /* LHS is infinity */
3849           /* two infinities with different signs is invalid */
3850           if (decNumberIsInfinite(rhs) && diffsign) {
3851             *status|=DEC_Invalid_operation;
3852             break;
3853             }
3854           bits=lhs->bits & DECNEG;      /* get sign from LHS */
3855           }
3856          else bits=(rhs->bits^negate) & DECNEG;/* RHS must be Infinity */
3857         bits|=DECINF;
3858         decNumberZero(res);
3859         res->bits=bits;                 /* set +/- infinity */
3860         } /* an infinity */
3861       break;
3862       }
3863
3864     /* Quick exit for add 0s; return the non-0, modified as need be */
3865     if (ISZERO(lhs)) {
3866       Int adjust;                       /* work */
3867       Int lexp=lhs->exponent;           /* save in case LHS==RES */
3868       bits=lhs->bits;                   /* .. */
3869       residue=0;                        /* clear accumulator */
3870       decCopyFit(res, rhs, set, &residue, status); /* copy (as needed) */
3871       res->bits^=negate;                /* flip if rhs was negated */
3872       #if DECSUBSET
3873       if (set->extended) {              /* exponents on zeros count */
3874       #endif
3875         /* exponent will be the lower of the two */
3876         adjust=lexp-res->exponent;      /* adjustment needed [if -ve] */
3877         if (ISZERO(res)) {              /* both 0: special IEEE 754 rules */
3878           if (adjust<0) res->exponent=lexp;  /* set exponent */
3879           /* 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0 */
3880           if (diffsign) {
3881             if (set->round!=DEC_ROUND_FLOOR) res->bits=0;
3882              else res->bits=DECNEG;     /* preserve 0 sign */
3883             }
3884           }
3885          else { /* non-0 res */
3886           if (adjust<0) {     /* 0-padding needed */
3887             if ((res->digits-adjust)>set->digits) {
3888               adjust=res->digits-set->digits;     /* to fit exactly */
3889               *status|=DEC_Rounded;               /* [but exact] */
3890               }
3891             res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
3892             res->exponent+=adjust;                /* set the exponent. */
3893             }
3894           } /* non-0 res */
3895       #if DECSUBSET
3896         } /* extended */
3897       #endif
3898       decFinish(res, set, &residue, status);      /* clean and finalize */
3899       break;}
3900
3901     if (ISZERO(rhs)) {                  /* [lhs is non-zero] */
3902       Int adjust;                       /* work */
3903       Int rexp=rhs->exponent;           /* save in case RHS==RES */
3904       bits=rhs->bits;                   /* be clean */
3905       residue=0;                        /* clear accumulator */
3906       decCopyFit(res, lhs, set, &residue, status); /* copy (as needed) */
3907       #if DECSUBSET
3908       if (set->extended) {              /* exponents on zeros count */
3909       #endif
3910         /* exponent will be the lower of the two */
3911         /* [0-0 case handled above] */
3912         adjust=rexp-res->exponent;      /* adjustment needed [if -ve] */
3913         if (adjust<0) {     /* 0-padding needed */
3914           if ((res->digits-adjust)>set->digits) {
3915             adjust=res->digits-set->digits;     /* to fit exactly */
3916             *status|=DEC_Rounded;               /* [but exact] */
3917             }
3918           res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
3919           res->exponent+=adjust;                /* set the exponent. */
3920           }
3921       #if DECSUBSET
3922         } /* extended */
3923       #endif
3924       decFinish(res, set, &residue, status);      /* clean and finalize */
3925       break;}
3926
3927     /* [NB: both fastpath and mainpath code below assume these cases */
3928     /* (notably 0-0) have already been handled] */
3929
3930     /* calculate the padding needed to align the operands */
3931     padding=rhs->exponent-lhs->exponent;
3932
3933     /* Fastpath cases where the numbers are aligned and normal, the RHS */
3934     /* is all in one unit, no operand rounding is needed, and no carry, */
3935     /* lengthening, or borrow is needed */
3936     if (padding==0
3937         && rhs->digits<=DECDPUN
3938         && rhs->exponent>=set->emin     /* [some normals drop through] */
3939         && rhs->exponent<=set->emax-set->digits+1 /* [could clamp] */
3940         && rhs->digits<=reqdigits
3941         && lhs->digits<=reqdigits) {
3942       Int partial=*lhs->lsu;
3943       if (!diffsign) {                  /* adding */
3944         partial+=*rhs->lsu;
3945         if ((partial<=DECDPUNMAX)       /* result fits in unit */
3946          && (lhs->digits>=DECDPUN ||    /* .. and no digits-count change */
3947              partial<(Int)powers[lhs->digits])) { /* .. */
3948           if (res!=lhs) decNumberCopy(res, lhs);  /* not in place */
3949           *res->lsu=(Unit)partial;      /* [copy could have overwritten RHS] */
3950           break;
3951           }
3952         /* else drop out for careful add */
3953         }
3954        else {                           /* signs differ */
3955         partial-=*rhs->lsu;
3956         if (partial>0) { /* no borrow needed, and non-0 result */
3957           if (res!=lhs) decNumberCopy(res, lhs);  /* not in place */
3958           *res->lsu=(Unit)partial;
3959           /* this could have reduced digits [but result>0] */
3960           res->digits=decGetDigits(res->lsu, D2U(res->digits));
3961           break;
3962           }
3963         /* else drop out for careful subtract */
3964         }
3965       }
3966
3967     /* Now align (pad) the lhs or rhs so they can be added or */
3968     /* subtracted, as necessary.  If one number is much larger than */
3969     /* the other (that is, if in plain form there is a least one */
3970     /* digit between the lowest digit of one and the highest of the */
3971     /* other) padding with up to DIGITS-1 trailing zeros may be */
3972     /* needed; then apply rounding (as exotic rounding modes may be */
3973     /* affected by the residue). */
3974     rhsshift=0;               /* rhs shift to left (padding) in Units */
3975     bits=lhs->bits;           /* assume sign is that of LHS */
3976     mult=1;                   /* likely multiplier */
3977
3978     /* [if padding==0 the operands are aligned; no padding is needed] */
3979     if (padding!=0) {
3980       /* some padding needed; always pad the RHS, as any required */
3981       /* padding can then be effected by a simple combination of */
3982       /* shifts and a multiply */
3983       Flag swapped=0;
3984       if (padding<0) {                  /* LHS needs the padding */
3985         const decNumber *t;
3986         padding=-padding;               /* will be +ve */
3987         bits=(uByte)(rhs->bits^negate); /* assumed sign is now that of RHS */
3988         t=lhs; lhs=rhs; rhs=t;
3989         swapped=1;
3990         }
3991
3992       /* If, after pad, rhs would be longer than lhs by digits+1 or */
3993       /* more then lhs cannot affect the answer, except as a residue, */
3994       /* so only need to pad up to a length of DIGITS+1. */
3995       if (rhs->digits+padding > lhs->digits+reqdigits+1) {
3996         /* The RHS is sufficient */
3997         /* for residue use the relative sign indication... */
3998         Int shift=reqdigits-rhs->digits;     /* left shift needed */
3999         residue=1;                           /* residue for rounding */
4000         if (diffsign) residue=-residue;      /* signs differ */
4001         /* copy, shortening if necessary */
4002         decCopyFit(res, rhs, set, &residue, status);
4003         /* if it was already shorter, then need to pad with zeros */
4004         if (shift>0) {
4005           res->digits=decShiftToMost(res->lsu, res->digits, shift);
4006           res->exponent-=shift;              /* adjust the exponent. */
4007           }
4008         /* flip the result sign if unswapped and rhs was negated */
4009         if (!swapped) res->bits^=negate;
4010         decFinish(res, set, &residue, status);    /* done */
4011         break;}
4012
4013       /* LHS digits may affect result */
4014       rhsshift=D2U(padding+1)-1;        /* this much by Unit shift .. */
4015       mult=powers[padding-(rhsshift*DECDPUN)]; /* .. this by multiplication */
4016       } /* padding needed */
4017
4018     if (diffsign) mult=-mult;           /* signs differ */
4019
4020     /* determine the longer operand */
4021     maxdigits=rhs->digits+padding;      /* virtual length of RHS */
4022     if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4023
4024     /* Decide on the result buffer to use; if possible place directly */
4025     /* into result. */
4026     acc=res->lsu;                       /* assume add direct to result */
4027     /* If destructive overlap, or the number is too long, or a carry or */
4028     /* borrow to DIGITS+1 might be possible, a buffer must be used. */
4029     /* [Might be worth more sophisticated tests when maxdigits==reqdigits] */
4030     if ((maxdigits>=reqdigits)          /* is, or could be, too large */
4031      || (res==rhs && rhsshift>0)) {     /* destructive overlap */
4032       /* buffer needed, choose it; units for maxdigits digits will be */
4033       /* needed, +1 Unit for carry or borrow */
4034       Int need=D2U(maxdigits)+1;
4035       acc=accbuff;                      /* assume use local buffer */
4036       if (need*sizeof(Unit)>sizeof(accbuff)) {
4037         /* printf("malloc add %ld %ld\n", need, sizeof(accbuff)); */
4038         allocacc=(Unit *)malloc(need*sizeof(Unit));
4039         if (allocacc==NULL) {           /* hopeless -- abandon */
4040           *status|=DEC_Insufficient_storage;
4041           break;}
4042         acc=allocacc;
4043         }
4044       }
4045
4046     res->bits=(uByte)(bits&DECNEG);     /* it's now safe to overwrite.. */
4047     res->exponent=lhs->exponent;        /* .. operands (even if aliased) */
4048
4049     #if DECTRACE
4050       decDumpAr('A', lhs->lsu, D2U(lhs->digits));
4051       decDumpAr('B', rhs->lsu, D2U(rhs->digits));
4052       printf("  :h: %ld %ld\n", rhsshift, mult);
4053     #endif
4054
4055     /* add [A+B*m] or subtract [A+B*(-m)] */
4056     res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits),
4057                               rhs->lsu, D2U(rhs->digits),
4058                               rhsshift, acc, mult)
4059                *DECDPUN;           /* [units -> digits] */
4060     if (res->digits<0) {           /* borrowed... */
4061       res->digits=-res->digits;
4062       res->bits^=DECNEG;           /* flip the sign */
4063       }
4064     #if DECTRACE
4065       decDumpAr('+', acc, D2U(res->digits));
4066     #endif
4067
4068     /* If a buffer was used the result must be copied back, possibly */
4069     /* shortening.  (If no buffer was used then the result must have */
4070     /* fit, so can't need rounding and residue must be 0.) */
4071     residue=0;                     /* clear accumulator */
4072     if (acc!=res->lsu) {
4073       #if DECSUBSET
4074       if (set->extended) {         /* round from first significant digit */
4075       #endif
4076         /* remove leading zeros that were added due to rounding up to */
4077         /* integral Units -- before the test for rounding. */
4078         if (res->digits>reqdigits)
4079           res->digits=decGetDigits(acc, D2U(res->digits));
4080         decSetCoeff(res, set, acc, res->digits, &residue, status);
4081       #if DECSUBSET
4082         }
4083        else { /* subset arithmetic rounds from original significant digit */
4084         /* May have an underestimate.  This only occurs when both */
4085         /* numbers fit in DECDPUN digits and are padding with a */
4086         /* negative multiple (-10, -100...) and the top digit(s) become */
4087         /* 0.  (This only matters when using X3.274 rules where the */
4088         /* leading zero could be included in the rounding.) */
4089         if (res->digits<maxdigits) {
4090           *(acc+D2U(res->digits))=0; /* ensure leading 0 is there */
4091           res->digits=maxdigits;
4092           }
4093          else {
4094           /* remove leading zeros that added due to rounding up to */
4095           /* integral Units (but only those in excess of the original */
4096           /* maxdigits length, unless extended) before test for rounding. */
4097           if (res->digits>reqdigits) {
4098             res->digits=decGetDigits(acc, D2U(res->digits));
4099             if (res->digits<maxdigits) res->digits=maxdigits;
4100             }
4101           }
4102         decSetCoeff(res, set, acc, res->digits, &residue, status);
4103         /* Now apply rounding if needed before removing leading zeros. */
4104         /* This is safe because subnormals are not a possibility */
4105         if (residue!=0) {
4106           decApplyRound(res, set, residue, status);
4107           residue=0;                 /* did what needed to be done */
4108           }
4109         } /* subset */
4110       #endif
4111       } /* used buffer */
4112
4113     /* strip leading zeros [these were left on in case of subset subtract] */
4114     res->digits=decGetDigits(res->lsu, D2U(res->digits));
4115
4116     /* apply checks and rounding */
4117     decFinish(res, set, &residue, status);
4118
4119     /* "When the sum of two operands with opposite signs is exactly */
4120     /* zero, the sign of that sum shall be '+' in all rounding modes */
4121     /* except round toward -Infinity, in which mode that sign shall be */
4122     /* '-'."  [Subset zeros also never have '-', set by decFinish.] */
4123     if (ISZERO(res) && diffsign
4124      #if DECSUBSET
4125      && set->extended
4126      #endif
4127      && (*status&DEC_Inexact)==0) {
4128       if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG;   /* sign - */
4129                                   else res->bits&=~DECNEG;  /* sign + */
4130       }
4131     } while(0);                              /* end protected */
4132
4133   free(allocacc);            /* drop any storage used */
4134   #if DECSUBSET
4135   free(allocrhs);            /* .. */
4136   free(alloclhs);            /* .. */
4137   #endif
4138   return res;
4139   } /* decAddOp */
4140
4141 /* ------------------------------------------------------------------ */
4142 /* decDivideOp -- division operation                                  */
4143 /*                                                                    */
4144 /*  This routine performs the calculations for all four division      */
4145 /*  operators (divide, divideInteger, remainder, remainderNear).      */
4146 /*                                                                    */
4147 /*  C=A op B                                                          */
4148 /*                                                                    */
4149 /*   res is C, the result.  C may be A and/or B (e.g., X=X/X)         */
4150 /*   lhs is A                                                         */
4151 /*   rhs is B                                                         */
4152 /*   set is the context                                               */
4153 /*   op  is DIVIDE, DIVIDEINT, REMAINDER, or REMNEAR respectively.    */
4154 /*   status is the usual accumulator                                  */
4155 /*                                                                    */
4156 /* C must have space for set->digits digits.                          */
4157 /*                                                                    */
4158 /* ------------------------------------------------------------------ */
4159 /*   The underlying algorithm of this routine is the same as in the   */
4160 /*   1981 S/370 implementation, that is, non-restoring long division  */
4161 /*   with bi-unit (rather than bi-digit) estimation for each unit     */
4162 /*   multiplier.  In this pseudocode overview, complications for the  */
4163 /*   Remainder operators and division residues for exact rounding are */
4164 /*   omitted for clarity.                                             */
4165 /*                                                                    */
4166 /*     Prepare operands and handle special values                     */
4167 /*     Test for x/0 and then 0/x                                      */
4168 /*     Exp =Exp1 - Exp2                                               */
4169 /*     Exp =Exp +len(var1) -len(var2)                                 */
4170 /*     Sign=Sign1 * Sign2                                             */
4171 /*     Pad accumulator (Var1) to double-length with 0's (pad1)        */
4172 /*     Pad Var2 to same length as Var1                                */
4173 /*     msu2pair/plus=1st 2 or 1 units of var2, +1 to allow for round  */
4174 /*     have=0                                                         */
4175 /*     Do until (have=digits+1 OR residue=0)                          */
4176 /*       if exp<0 then if integer divide/residue then leave           */
4177 /*       this_unit=0                                                  */
4178 /*       Do forever                                                   */
4179 /*          compare numbers                                           */
4180 /*          if <0 then leave inner_loop                               */
4181 /*          if =0 then (* quick exit without subtract *) do           */
4182 /*             this_unit=this_unit+1; output this_unit                */
4183 /*             leave outer_loop; end                                  */
4184 /*          Compare lengths of numbers (mantissae):                   */
4185 /*          If same then tops2=msu2pair -- {units 1&2 of var2}        */
4186 /*                  else tops2=msu2plus -- {0, unit 1 of var2}        */
4187 /*          tops1=first_unit_of_Var1*10**DECDPUN +second_unit_of_var1 */
4188 /*          mult=tops1/tops2  -- Good and safe guess at divisor       */
4189 /*          if mult=0 then mult=1                                     */
4190 /*          this_unit=this_unit+mult                                  */
4191 /*          subtract                                                  */
4192 /*          end inner_loop                                            */
4193 /*        if have\=0 | this_unit\=0 then do                           */
4194 /*          output this_unit                                          */
4195 /*          have=have+1; end                                          */
4196 /*        var2=var2/10                                                */
4197 /*        exp=exp-1                                                   */
4198 /*        end outer_loop                                              */
4199 /*     exp=exp+1   -- set the proper exponent                         */
4200 /*     if have=0 then generate answer=0                               */
4201 /*     Return (Result is defined by Var1)                             */
4202 /*                                                                    */
4203 /* ------------------------------------------------------------------ */
4204 /* Two working buffers are needed during the division; one (digits+   */
4205 /* 1) to accumulate the result, and the other (up to 2*digits+1) for  */
4206 /* long subtractions.  These are acc and var1 respectively.           */
4207 /* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/
4208 /* The static buffers may be larger than might be expected to allow   */
4209 /* for calls from higher-level funtions (notable exp).                */
4210 /* ------------------------------------------------------------------ */
4211 static decNumber * decDivideOp(decNumber *res,
4212                                const decNumber *lhs, const decNumber *rhs,
4213                                decContext *set, Flag op, uInt *status) {
4214   #if DECSUBSET
4215   decNumber *alloclhs=NULL;        /* non-NULL if rounded lhs allocated */
4216   decNumber *allocrhs=NULL;        /* .., rhs */
4217   #endif
4218   Unit  accbuff[SD2U(DECBUFFER+DECDPUN+10)]; /* local buffer */
4219   Unit  *acc=accbuff;              /* -> accumulator array for result */
4220   Unit  *allocacc=NULL;            /* -> allocated buffer, iff allocated */
4221   Unit  *accnext;                  /* -> where next digit will go */
4222   Int   acclength;                 /* length of acc needed [Units] */
4223   Int   accunits;                  /* count of units accumulated */
4224   Int   accdigits;                 /* count of digits accumulated */
4225
4226   Unit  varbuff[SD2U(DECBUFFER*2+DECDPUN)];  /* buffer for var1 */
4227   Unit  *var1=varbuff;             /* -> var1 array for long subtraction */
4228   Unit  *varalloc=NULL;            /* -> allocated buffer, iff used */
4229   Unit  *msu1;                     /* -> msu of var1 */
4230
4231   const Unit *var2;                /* -> var2 array */
4232   const Unit *msu2;                /* -> msu of var2 */
4233   Int   msu2plus;                  /* msu2 plus one [does not vary] */
4234   eInt  msu2pair;                  /* msu2 pair plus one [does not vary] */
4235
4236   Int   var1units, var2units;      /* actual lengths */
4237   Int   var2ulen;                  /* logical length (units) */
4238   Int   var1initpad=0;             /* var1 initial padding (digits) */
4239   Int   maxdigits;                 /* longest LHS or required acc length */
4240   Int   mult;                      /* multiplier for subtraction */
4241   Unit  thisunit;                  /* current unit being accumulated */
4242   Int   residue;                   /* for rounding */
4243   Int   reqdigits=set->digits;     /* requested DIGITS */
4244   Int   exponent;                  /* working exponent */
4245   Int   maxexponent=0;             /* DIVIDE maximum exponent if unrounded */
4246   uByte bits;                      /* working sign */
4247   Unit  *target;                   /* work */
4248   const Unit *source;              /* .. */
4249   uInt  const *pow;                /* .. */
4250   Int   shift, cut;                /* .. */
4251   #if DECSUBSET
4252   Int   dropped;                   /* work */
4253   #endif
4254
4255   #if DECCHECK
4256   if (decCheckOperands(res, lhs, rhs, set)) return res;
4257   #endif
4258
4259   do {                             /* protect allocated storage */
4260     #if DECSUBSET
4261     if (!set->extended) {
4262       /* reduce operands and set lostDigits status, as needed */
4263       if (lhs->digits>reqdigits) {
4264         alloclhs=decRoundOperand(lhs, set, status);
4265         if (alloclhs==NULL) break;
4266         lhs=alloclhs;
4267         }
4268       if (rhs->digits>reqdigits) {
4269         allocrhs=decRoundOperand(rhs, set, status);
4270         if (allocrhs==NULL) break;
4271         rhs=allocrhs;
4272         }
4273       }
4274     #endif
4275     /* [following code does not require input rounding] */
4276
4277     bits=(lhs->bits^rhs->bits)&DECNEG;  /* assumed sign for divisions */
4278
4279     /* handle infinities and NaNs */
4280     if (SPECIALARGS) {                  /* a special bit set */
4281       if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
4282         decNaNs(res, lhs, rhs, set, status);
4283         break;
4284         }
4285       /* one or two infinities */
4286       if (decNumberIsInfinite(lhs)) {   /* LHS (dividend) is infinite */
4287         if (decNumberIsInfinite(rhs) || /* two infinities are invalid .. */
4288             op & (REMAINDER | REMNEAR)) { /* as is remainder of infinity */
4289           *status|=DEC_Invalid_operation;
4290           break;
4291           }
4292         /* [Note that infinity/0 raises no exceptions] */
4293         decNumberZero(res);
4294         res->bits=bits|DECINF;          /* set +/- infinity */
4295         break;
4296         }
4297        else {                           /* RHS (divisor) is infinite */
4298         residue=0;
4299         if (op&(REMAINDER|REMNEAR)) {
4300           /* result is [finished clone of] lhs */
4301           decCopyFit(res, lhs, set, &residue, status);
4302           }
4303          else {  /* a division */
4304           decNumberZero(res);
4305           res->bits=bits;               /* set +/- zero */
4306           /* for DIVIDEINT the exponent is always 0.  For DIVIDE, result */
4307           /* is a 0 with infinitely negative exponent, clamped to minimum */
4308           if (op&DIVIDE) {
4309             res->exponent=set->emin-set->digits+1;
4310             *status|=DEC_Clamped;
4311             }
4312           }
4313         decFinish(res, set, &residue, status);
4314         break;
4315         }
4316       }
4317
4318     /* handle 0 rhs (x/0) */
4319     if (ISZERO(rhs)) {                  /* x/0 is always exceptional */
4320       if (ISZERO(lhs)) {
4321         decNumberZero(res);             /* [after lhs test] */
4322         *status|=DEC_Division_undefined;/* 0/0 will become NaN */
4323         }
4324        else {
4325         decNumberZero(res);
4326         if (op&(REMAINDER|REMNEAR)) *status|=DEC_Invalid_operation;
4327          else {
4328           *status|=DEC_Division_by_zero; /* x/0 */
4329           res->bits=bits|DECINF;         /* .. is +/- Infinity */
4330           }
4331         }
4332       break;}
4333
4334     /* handle 0 lhs (0/x) */
4335     if (ISZERO(lhs)) {                  /* 0/x [x!=0] */
4336       #if DECSUBSET
4337       if (!set->extended) decNumberZero(res);
4338        else {
4339       #endif
4340         if (op&DIVIDE) {
4341           residue=0;
4342           exponent=lhs->exponent-rhs->exponent; /* ideal exponent */
4343           decNumberCopy(res, lhs);      /* [zeros always fit] */
4344           res->bits=bits;               /* sign as computed */
4345           res->exponent=exponent;       /* exponent, too */
4346           decFinalize(res, set, &residue, status);   /* check exponent */
4347           }
4348          else if (op&DIVIDEINT) {
4349           decNumberZero(res);           /* integer 0 */
4350           res->bits=bits;               /* sign as computed */
4351           }
4352          else {                         /* a remainder */
4353           exponent=rhs->exponent;       /* [save in case overwrite] */
4354           decNumberCopy(res, lhs);      /* [zeros always fit] */
4355           if (exponent<res->exponent) res->exponent=exponent; /* use lower */
4356           }
4357       #if DECSUBSET
4358         }
4359       #endif
4360       break;}
4361
4362     /* Precalculate exponent.  This starts off adjusted (and hence fits */
4363     /* in 31 bits) and becomes the usual unadjusted exponent as the */
4364     /* division proceeds.  The order of evaluation is important, here, */
4365     /* to avoid wrap. */
4366     exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits);
4367
4368     /* If the working exponent is -ve, then some quick exits are */
4369     /* possible because the quotient is known to be <1 */
4370     /* [for REMNEAR, it needs to be < -1, as -0.5 could need work] */
4371     if (exponent<0 && !(op==DIVIDE)) {
4372       if (op&DIVIDEINT) {
4373         decNumberZero(res);                  /* integer part is 0 */
4374         #if DECSUBSET
4375         if (set->extended)
4376         #endif
4377           res->bits=bits;                    /* set +/- zero */
4378         break;}
4379       /* fastpath remainders so long as the lhs has the smaller */
4380       /* (or equal) exponent */
4381       if (lhs->exponent<=rhs->exponent) {
4382         if (op&REMAINDER || exponent<-1) {
4383           /* It is REMAINDER or safe REMNEAR; result is [finished */
4384           /* clone of] lhs  (r = x - 0*y) */
4385           residue=0;
4386           decCopyFit(res, lhs, set, &residue, status);
4387           decFinish(res, set, &residue, status);
4388           break;
4389           }
4390         /* [unsafe REMNEAR drops through] */
4391         }
4392       } /* fastpaths */
4393
4394     /* Long (slow) division is needed; roll up the sleeves... */
4395
4396     /* The accumulator will hold the quotient of the division. */
4397     /* If it needs to be too long for stack storage, then allocate. */
4398     acclength=D2U(reqdigits+DECDPUN);   /* in Units */
4399     if (acclength*sizeof(Unit)>sizeof(accbuff)) {
4400       /* printf("malloc dvacc %ld units\n", acclength); */
4401       allocacc=(Unit *)malloc(acclength*sizeof(Unit));
4402       if (allocacc==NULL) {             /* hopeless -- abandon */
4403         *status|=DEC_Insufficient_storage;
4404         break;}
4405       acc=allocacc;                     /* use the allocated space */
4406       }
4407
4408     /* var1 is the padded LHS ready for subtractions. */
4409     /* If it needs to be too long for stack storage, then allocate. */
4410     /* The maximum units needed for var1 (long subtraction) is: */
4411     /* Enough for */
4412     /*     (rhs->digits+reqdigits-1) -- to allow full slide to right */
4413     /* or  (lhs->digits)             -- to allow for long lhs */
4414     /* whichever is larger */
4415     /*   +1                -- for rounding of slide to right */
4416     /*   +1                -- for leading 0s */
4417     /*   +1                -- for pre-adjust if a remainder or DIVIDEINT */
4418     /* [Note: unused units do not participate in decUnitAddSub data] */
4419     maxdigits=rhs->digits+reqdigits-1;
4420     if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4421     var1units=D2U(maxdigits)+2;
4422     /* allocate a guard unit above msu1 for REMAINDERNEAR */
4423     if (!(op&DIVIDE)) var1units++;
4424     if ((var1units+1)*sizeof(Unit)>sizeof(varbuff)) {
4425       /* printf("malloc dvvar %ld units\n", var1units+1); */
4426       varalloc=(Unit *)malloc((var1units+1)*sizeof(Unit));
4427       if (varalloc==NULL) {             /* hopeless -- abandon */
4428         *status|=DEC_Insufficient_storage;
4429         break;}
4430       var1=varalloc;                    /* use the allocated space */
4431       }
4432
4433     /* Extend the lhs and rhs to full long subtraction length.  The lhs */
4434     /* is truly extended into the var1 buffer, with 0 padding, so a */
4435     /* subtract in place is always possible.  The rhs (var2) has */
4436     /* virtual padding (implemented by decUnitAddSub). */
4437     /* One guard unit was allocated above msu1 for rem=rem+rem in */
4438     /* REMAINDERNEAR. */
4439     msu1=var1+var1units-1;              /* msu of var1 */
4440     source=lhs->lsu+D2U(lhs->digits)-1; /* msu of input array */
4441     for (target=msu1; source>=lhs->lsu; source--, target--) *target=*source;
4442     for (; target>=var1; target--) *target=0;
4443
4444     /* rhs (var2) is left-aligned with var1 at the start */
4445     var2ulen=var1units;                 /* rhs logical length (units) */
4446     var2units=D2U(rhs->digits);         /* rhs actual length (units) */
4447     var2=rhs->lsu;                      /* -> rhs array */
4448     msu2=var2+var2units-1;              /* -> msu of var2 [never changes] */
4449     /* now set up the variables which will be used for estimating the */
4450     /* multiplication factor.  If these variables are not exact, add */
4451     /* 1 to make sure that the multiplier is never overestimated. */
4452     msu2plus=*msu2;                     /* it's value .. */
4453     if (var2units>1) msu2plus++;        /* .. +1 if any more */
4454     msu2pair=(eInt)*msu2*(DECDPUNMAX+1);/* top two pair .. */
4455     if (var2units>1) {                  /* .. [else treat 2nd as 0] */
4456       msu2pair+=*(msu2-1);              /* .. */
4457       if (var2units>2) msu2pair++;      /* .. +1 if any more */
4458       }
4459
4460     /* The calculation is working in units, which may have leading zeros, */
4461     /* but the exponent was calculated on the assumption that they are */
4462     /* both left-aligned.  Adjust the exponent to compensate: add the */
4463     /* number of leading zeros in var1 msu and subtract those in var2 msu. */
4464     /* [This is actually done by counting the digits and negating, as */
4465     /* lead1=DECDPUN-digits1, and similarly for lead2.] */
4466     for (pow=&powers[1]; *msu1>=*pow; pow++) exponent--;
4467     for (pow=&powers[1]; *msu2>=*pow; pow++) exponent++;
4468
4469     /* Now, if doing an integer divide or remainder, ensure that */
4470     /* the result will be Unit-aligned.  To do this, shift the var1 */
4471     /* accumulator towards least if need be.  (It's much easier to */
4472     /* do this now than to reassemble the residue afterwards, if */
4473     /* doing a remainder.)  Also ensure the exponent is not negative. */
4474     if (!(op&DIVIDE)) {
4475       Unit *u;                          /* work */
4476       /* save the initial 'false' padding of var1, in digits */
4477       var1initpad=(var1units-D2U(lhs->digits))*DECDPUN;
4478       /* Determine the shift to do. */
4479       if (exponent<0) cut=-exponent;
4480        else cut=DECDPUN-exponent%DECDPUN;
4481       decShiftToLeast(var1, var1units, cut);
4482       exponent+=cut;                    /* maintain numerical value */
4483       var1initpad-=cut;                 /* .. and reduce padding */
4484       /* clean any most-significant units which were just emptied */
4485       for (u=msu1; cut>=DECDPUN; cut-=DECDPUN, u--) *u=0;
4486       } /* align */
4487      else { /* is DIVIDE */
4488       maxexponent=lhs->exponent-rhs->exponent;    /* save */
4489       /* optimization: if the first iteration will just produce 0, */
4490       /* preadjust to skip it [valid for DIVIDE only] */
4491       if (*msu1<*msu2) {
4492         var2ulen--;                     /* shift down */
4493         exponent-=DECDPUN;              /* update the exponent */
4494         }
4495       }
4496
4497     /* ---- start the long-division loops ------------------------------ */
4498     accunits=0;                         /* no units accumulated yet */
4499     accdigits=0;                        /* .. or digits */
4500     accnext=acc+acclength-1;            /* -> msu of acc [NB: allows digits+1] */
4501     for (;;) {                          /* outer forever loop */
4502       thisunit=0;                       /* current unit assumed 0 */
4503       /* find the next unit */
4504       for (;;) {                        /* inner forever loop */
4505         /* strip leading zero units [from either pre-adjust or from */
4506         /* subtract last time around].  Leave at least one unit. */
4507         for (; *msu1==0 && msu1>var1; msu1--) var1units--;
4508
4509         if (var1units<var2ulen) break;       /* var1 too low for subtract */
4510         if (var1units==var2ulen) {           /* unit-by-unit compare needed */
4511           /* compare the two numbers, from msu */
4512           const Unit *pv1, *pv2;
4513           Unit v2;                           /* units to compare */
4514           pv2=msu2;                          /* -> msu */
4515           for (pv1=msu1; ; pv1--, pv2--) {
4516             /* v1=*pv1 -- always OK */
4517             v2=0;                            /* assume in padding */
4518             if (pv2>=var2) v2=*pv2;          /* in range */
4519             if (*pv1!=v2) break;             /* no longer the same */
4520             if (pv1==var1) break;            /* done; leave pv1 as is */
4521             }
4522           /* here when all inspected or a difference seen */
4523           if (*pv1<v2) break;                /* var1 too low to subtract */
4524           if (*pv1==v2) {                    /* var1 == var2 */
4525             /* reach here if var1 and var2 are identical; subtraction */
4526             /* would increase digit by one, and the residue will be 0 so */
4527             /* the calculation is done; leave the loop with residue=0. */
4528             thisunit++;                      /* as though subtracted */
4529             *var1=0;                         /* set var1 to 0 */
4530             var1units=1;                     /* .. */
4531             break;  /* from inner */
4532             } /* var1 == var2 */
4533           /* *pv1>v2.  Prepare for real subtraction; the lengths are equal */
4534           /* Estimate the multiplier (there's always a msu1-1)... */
4535           /* Bring in two units of var2 to provide a good estimate. */
4536           mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2pair);
4537           } /* lengths the same */
4538          else { /* var1units > var2ulen, so subtraction is safe */
4539           /* The var2 msu is one unit towards the lsu of the var1 msu, */
4540           /* so only one unit for var2 can be used. */
4541           mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2plus);
4542           }
4543         if (mult==0) mult=1;                 /* must always be at least 1 */
4544         /* subtraction needed; var1 is > var2 */
4545         thisunit=(Unit)(thisunit+mult);      /* accumulate */
4546         /* subtract var1-var2, into var1; only the overlap needs */
4547         /* processing, as this is an in-place calculation */
4548         shift=var2ulen-var2units;
4549         #if DECTRACE
4550           decDumpAr('1', &var1[shift], var1units-shift);
4551           decDumpAr('2', var2, var2units);
4552           printf("m=%ld\n", -mult);
4553         #endif
4554         decUnitAddSub(&var1[shift], var1units-shift,
4555                       var2, var2units, 0,
4556                       &var1[shift], -mult);
4557         #if DECTRACE
4558           decDumpAr('#', &var1[shift], var1units-shift);
4559         #endif
4560         /* var1 now probably has leading zeros; these are removed at the */
4561         /* top of the inner loop. */
4562         } /* inner loop */
4563
4564       /* The next unit has been calculated in full; unless it's a */
4565       /* leading zero, add to acc */
4566       if (accunits!=0 || thisunit!=0) {      /* is first or non-zero */
4567         *accnext=thisunit;                   /* store in accumulator */
4568         /* account exactly for the new digits */
4569         if (accunits==0) {
4570           accdigits++;                       /* at least one */
4571           for (pow=&powers[1]; thisunit>=*pow; pow++) accdigits++;
4572           }
4573          else accdigits+=DECDPUN;
4574         accunits++;                          /* update count */
4575         accnext--;                           /* ready for next */
4576         if (accdigits>reqdigits) break;      /* have enough digits */
4577         }
4578
4579       /* if the residue is zero, the operation is done (unless divide */
4580       /* or divideInteger and still not enough digits yet) */
4581       if (*var1==0 && var1units==1) {        /* residue is 0 */
4582         if (op&(REMAINDER|REMNEAR)) break;
4583         if ((op&DIVIDE) && (exponent<=maxexponent)) break;
4584         /* [drop through if divideInteger] */
4585         }
4586       /* also done enough if calculating remainder or integer */
4587       /* divide and just did the last ('units') unit */
4588       if (exponent==0 && !(op&DIVIDE)) break;
4589
4590       /* to get here, var1 is less than var2, so divide var2 by the per- */
4591       /* Unit power of ten and go for the next digit */
4592       var2ulen--;                            /* shift down */
4593       exponent-=DECDPUN;                     /* update the exponent */
4594       } /* outer loop */
4595
4596     /* ---- division is complete --------------------------------------- */
4597     /* here: acc      has at least reqdigits+1 of good results (or fewer */
4598     /*                if early stop), starting at accnext+1 (its lsu) */
4599     /*       var1     has any residue at the stopping point */
4600     /*       accunits is the number of digits collected in acc */
4601     if (accunits==0) {             /* acc is 0 */
4602       accunits=1;                  /* show have a unit .. */
4603       accdigits=1;                 /* .. */
4604       *accnext=0;                  /* .. whose value is 0 */
4605       }
4606      else accnext++;               /* back to last placed */
4607     /* accnext now -> lowest unit of result */
4608
4609     residue=0;                     /* assume no residue */
4610     if (op&DIVIDE) {
4611       /* record the presence of any residue, for rounding */
4612       if (*var1!=0 || var1units>1) residue=1;
4613        else { /* no residue */
4614         /* Had an exact division; clean up spurious trailing 0s. */
4615         /* There will be at most DECDPUN-1, from the final multiply, */
4616         /* and then only if the result is non-0 (and even) and the */
4617         /* exponent is 'loose'. */
4618         #if DECDPUN>1
4619         Unit lsu=*accnext;
4620         if (!(lsu&0x01) && (lsu!=0)) {
4621           /* count the trailing zeros */
4622           Int drop=0;
4623           for (;; drop++) {    /* [will terminate because lsu!=0] */
4624             if (exponent>=maxexponent) break;     /* don't chop real 0s */
4625             #if DECDPUN<=4
4626               if ((lsu-QUOT10(lsu, drop+1)
4627                   *powers[drop+1])!=0) break;     /* found non-0 digit */
4628             #else
4629               if (lsu%powers[drop+1]!=0) break;   /* found non-0 digit */
4630             #endif
4631             exponent++;
4632             }
4633           if (drop>0) {
4634             accunits=decShiftToLeast(accnext, accunits, drop);
4635             accdigits=decGetDigits(accnext, accunits);
4636             accunits=D2U(accdigits);
4637             /* [exponent was adjusted in the loop] */
4638             }
4639           } /* neither odd nor 0 */
4640         #endif
4641         } /* exact divide */
4642       } /* divide */
4643      else /* op!=DIVIDE */ {
4644       /* check for coefficient overflow */
4645       if (accdigits+exponent>reqdigits) {
4646         *status|=DEC_Division_impossible;
4647         break;
4648         }
4649       if (op & (REMAINDER|REMNEAR)) {
4650         /* [Here, the exponent will be 0, because var1 was adjusted */
4651         /* appropriately.] */
4652         Int postshift;                       /* work */
4653         Flag wasodd=0;                       /* integer was odd */
4654         Unit *quotlsu;                       /* for save */
4655         Int  quotdigits;                     /* .. */
4656
4657         bits=lhs->bits;                      /* remainder sign is always as lhs */
4658
4659         /* Fastpath when residue is truly 0 is worthwhile [and */
4660         /* simplifies the code below] */
4661         if (*var1==0 && var1units==1) {      /* residue is 0 */
4662           Int exp=lhs->exponent;             /* save min(exponents) */
4663           if (rhs->exponent<exp) exp=rhs->exponent;
4664           decNumberZero(res);                /* 0 coefficient */
4665           #if DECSUBSET
4666           if (set->extended)
4667           #endif
4668           res->exponent=exp;                 /* .. with proper exponent */
4669           res->bits=(uByte)(bits&DECNEG);          /* [cleaned] */
4670           decFinish(res, set, &residue, status);   /* might clamp */
4671           break;
4672           }
4673         /* note if the quotient was odd */
4674         if (*accnext & 0x01) wasodd=1;       /* acc is odd */
4675         quotlsu=accnext;                     /* save in case need to reinspect */
4676         quotdigits=accdigits;                /* .. */
4677
4678         /* treat the residue, in var1, as the value to return, via acc */
4679         /* calculate the unused zero digits.  This is the smaller of: */
4680         /*   var1 initial padding (saved above) */
4681         /*   var2 residual padding, which happens to be given by: */
4682         postshift=var1initpad+exponent-lhs->exponent+rhs->exponent;
4683         /* [the 'exponent' term accounts for the shifts during divide] */
4684         if (var1initpad<postshift) postshift=var1initpad;
4685
4686         /* shift var1 the requested amount, and adjust its digits */
4687         var1units=decShiftToLeast(var1, var1units, postshift);
4688         accnext=var1;
4689         accdigits=decGetDigits(var1, var1units);
4690         accunits=D2U(accdigits);
4691
4692         exponent=lhs->exponent;         /* exponent is smaller of lhs & rhs */
4693         if (rhs->exponent<exponent) exponent=rhs->exponent;
4694
4695         /* Now correct the result if doing remainderNear; if it */
4696         /* (looking just at coefficients) is > rhs/2, or == rhs/2 and */
4697         /* the integer was odd then the result should be rem-rhs. */
4698         if (op&REMNEAR) {
4699           Int compare, tarunits;        /* work */
4700           Unit *up;                     /* .. */
4701           /* calculate remainder*2 into the var1 buffer (which has */
4702           /* 'headroom' of an extra unit and hence enough space) */
4703           /* [a dedicated 'double' loop would be faster, here] */
4704           tarunits=decUnitAddSub(accnext, accunits, accnext, accunits,
4705                                  0, accnext, 1);
4706           /* decDumpAr('r', accnext, tarunits); */
4707
4708           /* Here, accnext (var1) holds tarunits Units with twice the */
4709           /* remainder's coefficient, which must now be compared to the */
4710           /* RHS.  The remainder's exponent may be smaller than the RHS's. */
4711           compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits),
4712                                  rhs->exponent-exponent);
4713           if (compare==BADINT) {             /* deep trouble */
4714             *status|=DEC_Insufficient_storage;
4715             break;}
4716
4717           /* now restore the remainder by dividing by two; the lsu */
4718           /* is known to be even. */
4719           for (up=accnext; up<accnext+tarunits; up++) {
4720             Int half;              /* half to add to lower unit */
4721             half=*up & 0x01;
4722             *up/=2;                /* [shift] */
4723             if (!half) continue;
4724             *(up-1)+=(DECDPUNMAX+1)/2;
4725             }
4726           /* [accunits still describes the original remainder length] */
4727
4728           if (compare>0 || (compare==0 && wasodd)) { /* adjustment needed */
4729             Int exp, expunits, exprem;       /* work */
4730             /* This is effectively causing round-up of the quotient, */
4731             /* so if it was the rare case where it was full and all */
4732             /* nines, it would overflow and hence division-impossible */
4733             /* should be raised */
4734             Flag allnines=0;                 /* 1 if quotient all nines */
4735             if (quotdigits==reqdigits) {     /* could be borderline */
4736               for (up=quotlsu; ; up++) {
4737                 if (quotdigits>DECDPUN) {
4738                   if (*up!=DECDPUNMAX) break;/* non-nines */
4739                   }
4740                  else {                      /* this is the last Unit */
4741                   if (*up==powers[quotdigits]-1) allnines=1;
4742                   break;
4743                   }
4744                 quotdigits-=DECDPUN;         /* checked those digits */
4745                 } /* up */
4746               } /* borderline check */
4747             if (allnines) {
4748               *status|=DEC_Division_impossible;
4749               break;}
4750
4751             /* rem-rhs is needed; the sign will invert.  Again, var1 */
4752             /* can safely be used for the working Units array. */
4753             exp=rhs->exponent-exponent;      /* RHS padding needed */
4754             /* Calculate units and remainder from exponent. */
4755             expunits=exp/DECDPUN;
4756             exprem=exp%DECDPUN;
4757             /* subtract [A+B*(-m)]; the result will always be negative */
4758             accunits=-decUnitAddSub(accnext, accunits,
4759                                     rhs->lsu, D2U(rhs->digits),
4760                                     expunits, accnext, -(Int)powers[exprem]);
4761             accdigits=decGetDigits(accnext, accunits); /* count digits exactly */
4762             accunits=D2U(accdigits);    /* and recalculate the units for copy */
4763             /* [exponent is as for original remainder] */
4764             bits^=DECNEG;               /* flip the sign */
4765             }
4766           } /* REMNEAR */
4767         } /* REMAINDER or REMNEAR */
4768       } /* not DIVIDE */
4769
4770     /* Set exponent and bits */
4771     res->exponent=exponent;
4772     res->bits=(uByte)(bits&DECNEG);          /* [cleaned] */
4773
4774     /* Now the coefficient. */
4775     decSetCoeff(res, set, accnext, accdigits, &residue, status);
4776
4777     decFinish(res, set, &residue, status);   /* final cleanup */
4778
4779     #if DECSUBSET
4780     /* If a divide then strip trailing zeros if subset [after round] */
4781     if (!set->extended && (op==DIVIDE)) decTrim(res, set, 0, 1, &dropped);
4782     #endif
4783     } while(0);                              /* end protected */
4784
4785   free(varalloc);       /* drop any storage used */
4786   free(allocacc);       /* .. */
4787   #if DECSUBSET
4788   free(allocrhs);       /* .. */
4789   free(alloclhs);       /* .. */
4790   #endif
4791   return res;
4792   } /* decDivideOp */
4793
4794 /* ------------------------------------------------------------------ */
4795 /* decMultiplyOp -- multiplication operation                          */
4796 /*                                                                    */
4797 /*  This routine performs the multiplication C=A x B.                 */
4798 /*                                                                    */
4799 /*   res is C, the result.  C may be A and/or B (e.g., X=X*X)         */
4800 /*   lhs is A                                                         */
4801 /*   rhs is B                                                         */
4802 /*   set is the context                                               */
4803 /*   status is the usual accumulator                                  */
4804 /*                                                                    */
4805 /* C must have space for set->digits digits.                          */
4806 /*                                                                    */
4807 /* ------------------------------------------------------------------ */
4808 /* 'Classic' multiplication is used rather than Karatsuba, as the     */
4809 /* latter would give only a minor improvement for the short numbers   */
4810 /* expected to be handled most (and uses much more memory).           */
4811 /*                                                                    */
4812 /* There are two major paths here: the general-purpose ('old code')   */
4813 /* path which handles all DECDPUN values, and a fastpath version      */
4814 /* which is used if 64-bit ints are available, DECDPUN<=4, and more   */
4815 /* than two calls to decUnitAddSub would be made.                     */
4816 /*                                                                    */
4817 /* The fastpath version lumps units together into 8-digit or 9-digit  */
4818 /* chunks, and also uses a lazy carry strategy to minimise expensive  */
4819 /* 64-bit divisions.  The chunks are then broken apart again into     */
4820 /* units for continuing processing.  Despite this overhead, the       */
4821 /* fastpath can speed up some 16-digit operations by 10x (and much    */
4822 /* more for higher-precision calculations).                           */
4823 /*                                                                    */
4824 /* A buffer always has to be used for the accumulator; in the         */
4825 /* fastpath, buffers are also always needed for the chunked copies of */
4826 /* of the operand coefficients.                                       */
4827 /* Static buffers are larger than needed just for multiply, to allow  */
4828 /* for calls from other operations (notably exp).                     */
4829 /* ------------------------------------------------------------------ */
4830 #define FASTMUL (DECUSE64 && DECDPUN<5)
4831 static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,
4832                                  const decNumber *rhs, decContext *set,
4833                                  uInt *status) {
4834   Int    accunits;                 /* Units of accumulator in use */
4835   Int    exponent;                 /* work */
4836   Int    residue=0;                /* rounding residue */
4837   uByte  bits;                     /* result sign */
4838   Unit  *acc;                      /* -> accumulator Unit array */
4839   Int    needbytes;                /* size calculator */
4840   void  *allocacc=NULL;            /* -> allocated accumulator, iff allocated */
4841   Unit  accbuff[SD2U(DECBUFFER*4+1)]; /* buffer (+1 for DECBUFFER==0, */
4842                                    /* *4 for calls from other operations) */
4843   const Unit *mer, *mermsup;       /* work */
4844   Int   madlength;                 /* Units in multiplicand */
4845   Int   shift;                     /* Units to shift multiplicand by */
4846
4847   #if FASTMUL
4848     /* if DECDPUN is 1 or 3 work in base 10**9, otherwise */
4849     /* (DECDPUN is 2 or 4) then work in base 10**8 */
4850     #if DECDPUN & 1                /* odd */
4851       #define FASTBASE 1000000000  /* base */
4852       #define FASTDIGS          9  /* digits in base */
4853       #define FASTLAZY         18  /* carry resolution point [1->18] */
4854     #else
4855       #define FASTBASE  100000000
4856       #define FASTDIGS          8
4857       #define FASTLAZY       1844  /* carry resolution point [1->1844] */
4858     #endif
4859     /* three buffers are used, two for chunked copies of the operands */
4860     /* (base 10**8 or base 10**9) and one base 2**64 accumulator with */
4861     /* lazy carry evaluation */
4862     uInt   zlhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
4863     uInt  *zlhi=zlhibuff;                 /* -> lhs array */
4864     uInt  *alloclhi=NULL;                 /* -> allocated buffer, iff allocated */
4865     uInt   zrhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
4866     uInt  *zrhi=zrhibuff;                 /* -> rhs array */
4867     uInt  *allocrhi=NULL;                 /* -> allocated buffer, iff allocated */
4868     uLong  zaccbuff[(DECBUFFER*2+1)/4+2]; /* buffer (+1 for DECBUFFER==0) */
4869     /* [allocacc is shared for both paths, as only one will run] */
4870     uLong *zacc=zaccbuff;          /* -> accumulator array for exact result */
4871     #if DECDPUN==1
4872     Int    zoff;                   /* accumulator offset */
4873     #endif
4874     uInt  *lip, *rip;              /* item pointers */
4875     uInt  *lmsi, *rmsi;            /* most significant items */
4876     Int    ilhs, irhs, iacc;       /* item counts in the arrays */
4877     Int    lazy;                   /* lazy carry counter */
4878     uLong  lcarry;                 /* uLong carry */
4879     uInt   carry;                  /* carry (NB not uLong) */
4880     Int    count;                  /* work */
4881     const  Unit *cup;              /* .. */
4882     Unit  *up;                     /* .. */
4883     uLong *lp;                     /* .. */
4884     Int    p;                      /* .. */
4885   #endif
4886
4887   #if DECSUBSET
4888     decNumber *alloclhs=NULL;      /* -> allocated buffer, iff allocated */
4889     decNumber *allocrhs=NULL;      /* -> allocated buffer, iff allocated */
4890   #endif
4891
4892   #if DECCHECK
4893   if (decCheckOperands(res, lhs, rhs, set)) return res;
4894   #endif
4895
4896   /* precalculate result sign */
4897   bits=(uByte)((lhs->bits^rhs->bits)&DECNEG);
4898
4899   /* handle infinities and NaNs */
4900   if (SPECIALARGS) {               /* a special bit set */
4901     if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
4902       decNaNs(res, lhs, rhs, set, status);
4903       return res;}
4904     /* one or two infinities; Infinity * 0 is invalid */
4905     if (((lhs->bits & DECINF)==0 && ISZERO(lhs))
4906       ||((rhs->bits & DECINF)==0 && ISZERO(rhs))) {
4907       *status|=DEC_Invalid_operation;
4908       return res;}
4909     decNumberZero(res);
4910     res->bits=bits|DECINF;         /* infinity */
4911     return res;}
4912
4913   /* For best speed, as in DMSRCN [the original Rexx numerics */
4914   /* module], use the shorter number as the multiplier (rhs) and */
4915   /* the longer as the multiplicand (lhs) to minimise the number of */
4916   /* adds (partial products) */
4917   if (lhs->digits<rhs->digits) {   /* swap... */
4918     const decNumber *hold=lhs;
4919     lhs=rhs;
4920     rhs=hold;
4921     }
4922
4923   do {                             /* protect allocated storage */
4924     #if DECSUBSET
4925     if (!set->extended) {
4926       /* reduce operands and set lostDigits status, as needed */
4927       if (lhs->digits>set->digits) {
4928         alloclhs=decRoundOperand(lhs, set, status);
4929         if (alloclhs==NULL) break;
4930         lhs=alloclhs;
4931         }
4932       if (rhs->digits>set->digits) {
4933         allocrhs=decRoundOperand(rhs, set, status);
4934         if (allocrhs==NULL) break;
4935         rhs=allocrhs;
4936         }
4937       }
4938     #endif
4939     /* [following code does not require input rounding] */
4940
4941     #if FASTMUL                    /* fastpath can be used */
4942     /* use the fast path if there are enough digits in the shorter */
4943     /* operand to make the setup and takedown worthwhile */
4944     #define NEEDTWO (DECDPUN*2)    /* within two decUnitAddSub calls */
4945     if (rhs->digits>NEEDTWO) {     /* use fastpath... */
4946       /* calculate the number of elements in each array */
4947       ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; /* [ceiling] */
4948       irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; /* .. */
4949       iacc=ilhs+irhs;
4950
4951       /* allocate buffers if required, as usual */
4952       needbytes=ilhs*sizeof(uInt);
4953       if (needbytes>(Int)sizeof(zlhibuff)) {
4954         alloclhi=(uInt *)malloc(needbytes);
4955         zlhi=alloclhi;}
4956       needbytes=irhs*sizeof(uInt);
4957       if (needbytes>(Int)sizeof(zrhibuff)) {
4958         allocrhi=(uInt *)malloc(needbytes);
4959         zrhi=allocrhi;}
4960
4961       /* Allocating the accumulator space needs a special case when */
4962       /* DECDPUN=1 because when converting the accumulator to Units */
4963       /* after the multiplication each 8-byte item becomes 9 1-byte */
4964       /* units.  Therefore iacc extra bytes are needed at the front */
4965       /* (rounded up to a multiple of 8 bytes), and the uLong */
4966       /* accumulator starts offset the appropriate number of units */
4967       /* to the right to avoid overwrite during the unchunking. */
4968       needbytes=iacc*sizeof(uLong);
4969       #if DECDPUN==1
4970       zoff=(iacc+7)/8;        /* items to offset by */
4971       needbytes+=zoff*8;
4972       #endif
4973       if (needbytes>(Int)sizeof(zaccbuff)) {
4974         allocacc=(uLong *)malloc(needbytes);
4975         zacc=(uLong *)allocacc;}
4976       if (zlhi==NULL||zrhi==NULL||zacc==NULL) {
4977         *status|=DEC_Insufficient_storage;
4978         break;}
4979
4980       acc=(Unit *)zacc;       /* -> target Unit array */
4981       #if DECDPUN==1
4982       zacc+=zoff;             /* start uLong accumulator to right */
4983       #endif
4984
4985       /* assemble the chunked copies of the left and right sides */
4986       for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++)
4987         for (p=0, *lip=0; p<FASTDIGS && count>0;
4988              p+=DECDPUN, cup++, count-=DECDPUN)
4989           *lip+=*cup*powers[p];
4990       lmsi=lip-1;     /* save -> msi */
4991       for (count=rhs->digits, cup=rhs->lsu, rip=zrhi; count>0; rip++)
4992         for (p=0, *rip=0; p<FASTDIGS && count>0;
4993              p+=DECDPUN, cup++, count-=DECDPUN)
4994           *rip+=*cup*powers[p];
4995       rmsi=rip-1;     /* save -> msi */
4996
4997       /* zero the accumulator */
4998       for (lp=zacc; lp<zacc+iacc; lp++) *lp=0;
4999
5000       /* Start the multiplication */
5001       /* Resolving carries can dominate the cost of accumulating the */
5002       /* partial products, so this is only done when necessary. */
5003       /* Each uLong item in the accumulator can hold values up to */
5004       /* 2**64-1, and each partial product can be as large as */
5005       /* (10**FASTDIGS-1)**2.  When FASTDIGS=9, this can be added to */
5006       /* itself 18.4 times in a uLong without overflowing, so during */
5007       /* the main calculation resolution is carried out every 18th */
5008       /* add -- every 162 digits.  Similarly, when FASTDIGS=8, the */
5009       /* partial products can be added to themselves 1844.6 times in */
5010       /* a uLong without overflowing, so intermediate carry */
5011       /* resolution occurs only every 14752 digits.  Hence for common */
5012       /* short numbers usually only the one final carry resolution */
5013       /* occurs. */
5014       /* (The count is set via FASTLAZY to simplify experiments to */
5015       /* measure the value of this approach: a 35% improvement on a */
5016       /* [34x34] multiply.) */
5017       lazy=FASTLAZY;                         /* carry delay count */
5018       for (rip=zrhi; rip<=rmsi; rip++) {     /* over each item in rhs */
5019         lp=zacc+(rip-zrhi);                  /* where to add the lhs */
5020         for (lip=zlhi; lip<=lmsi; lip++, lp++) { /* over each item in lhs */
5021           *lp+=(uLong)(*lip)*(*rip);         /* [this should in-line] */
5022           } /* lip loop */
5023         lazy--;
5024         if (lazy>0 && rip!=rmsi) continue;
5025         lazy=FASTLAZY;                       /* reset delay count */
5026         /* spin up the accumulator resolving overflows */
5027         for (lp=zacc; lp<zacc+iacc; lp++) {
5028           if (*lp<FASTBASE) continue;        /* it fits */
5029           lcarry=*lp/FASTBASE;               /* top part [slow divide] */
5030           /* lcarry can exceed 2**32-1, so check again; this check */
5031           /* and occasional extra divide (slow) is well worth it, as */
5032           /* it allows FASTLAZY to be increased to 18 rather than 4 */
5033           /* in the FASTDIGS=9 case */
5034           if (lcarry<FASTBASE) carry=(uInt)lcarry;  /* [usual] */
5035            else { /* two-place carry [fairly rare] */
5036             uInt carry2=(uInt)(lcarry/FASTBASE);    /* top top part */
5037             *(lp+2)+=carry2;                        /* add to item+2 */
5038             *lp-=((uLong)FASTBASE*FASTBASE*carry2); /* [slow] */
5039             carry=(uInt)(lcarry-((uLong)FASTBASE*carry2)); /* [inline] */
5040             }
5041           *(lp+1)+=carry;                    /* add to item above [inline] */
5042           *lp-=((uLong)FASTBASE*carry);      /* [inline] */
5043           } /* carry resolution */
5044         } /* rip loop */
5045
5046       /* The multiplication is complete; time to convert back into */
5047       /* units.  This can be done in-place in the accumulator and in */
5048       /* 32-bit operations, because carries were resolved after the */
5049       /* final add.  This needs N-1 divides and multiplies for */
5050       /* each item in the accumulator (which will become up to N */
5051       /* units, where 2<=N<=9). */
5052       for (lp=zacc, up=acc; lp<zacc+iacc; lp++) {
5053         uInt item=(uInt)*lp;                 /* decapitate to uInt */
5054         for (p=0; p<FASTDIGS-DECDPUN; p+=DECDPUN, up++) {
5055           uInt part=item/(DECDPUNMAX+1);
5056           *up=(Unit)(item-(part*(DECDPUNMAX+1)));
5057           item=part;
5058           } /* p */
5059         *up=(Unit)item; up++;                /* [final needs no division] */
5060         } /* lp */
5061       accunits=up-acc;                       /* count of units */
5062       }
5063      else { /* here to use units directly, without chunking ['old code'] */
5064     #endif
5065
5066       /* if accumulator will be too long for local storage, then allocate */
5067       acc=accbuff;                 /* -> assume buffer for accumulator */
5068       needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit);
5069       if (needbytes>(Int)sizeof(accbuff)) {
5070         allocacc=(Unit *)malloc(needbytes);
5071         if (allocacc==NULL) {*status|=DEC_Insufficient_storage; break;}
5072         acc=(Unit *)allocacc;                /* use the allocated space */
5073         }
5074
5075       /* Now the main long multiplication loop */
5076       /* Unlike the equivalent in the IBM Java implementation, there */
5077       /* is no advantage in calculating from msu to lsu.  So, do it */
5078       /* by the book, as it were. */
5079       /* Each iteration calculates ACC=ACC+MULTAND*MULT */
5080       accunits=1;                  /* accumulator starts at '0' */
5081       *acc=0;                      /* .. (lsu=0) */
5082       shift=0;                     /* no multiplicand shift at first */
5083       madlength=D2U(lhs->digits);  /* this won't change */
5084       mermsup=rhs->lsu+D2U(rhs->digits); /* -> msu+1 of multiplier */
5085
5086       for (mer=rhs->lsu; mer<mermsup; mer++) {
5087         /* Here, *mer is the next Unit in the multiplier to use */
5088         /* If non-zero [optimization] add it... */
5089         if (*mer!=0) accunits=decUnitAddSub(&acc[shift], accunits-shift,
5090                                             lhs->lsu, madlength, 0,
5091                                             &acc[shift], *mer)
5092                                             + shift;
5093          else { /* extend acc with a 0; it will be used shortly */
5094           *(acc+accunits)=0;       /* [this avoids length of <=0 later] */
5095           accunits++;
5096           }
5097         /* multiply multiplicand by 10**DECDPUN for next Unit to left */
5098         shift++;                   /* add this for 'logical length' */
5099         } /* n */
5100     #if FASTMUL
5101       } /* unchunked units */
5102     #endif
5103     /* common end-path */
5104     #if DECTRACE
5105       decDumpAr('*', acc, accunits);         /* Show exact result */
5106     #endif
5107
5108     /* acc now contains the exact result of the multiplication, */
5109     /* possibly with a leading zero unit; build the decNumber from */
5110     /* it, noting if any residue */
5111     res->bits=bits;                          /* set sign */
5112     res->digits=decGetDigits(acc, accunits); /* count digits exactly */
5113
5114     /* There can be a 31-bit wrap in calculating the exponent. */
5115     /* This can only happen if both input exponents are negative and */
5116     /* both their magnitudes are large.  If there was a wrap, set a */
5117     /* safe very negative exponent, from which decFinalize() will */
5118     /* raise a hard underflow shortly. */
5119     exponent=lhs->exponent+rhs->exponent;    /* calculate exponent */
5120     if (lhs->exponent<0 && rhs->exponent<0 && exponent>0)
5121       exponent=-2*DECNUMMAXE;                /* force underflow */
5122     res->exponent=exponent;                  /* OK to overwrite now */
5123
5124
5125     /* Set the coefficient.  If any rounding, residue records */
5126     decSetCoeff(res, set, acc, res->digits, &residue, status);
5127     decFinish(res, set, &residue, status);   /* final cleanup */
5128     } while(0);                         /* end protected */
5129
5130   free(allocacc);       /* drop any storage used */
5131   #if DECSUBSET
5132   free(allocrhs);       /* .. */
5133   free(alloclhs);       /* .. */
5134   #endif
5135   #if FASTMUL
5136   free(allocrhi);       /* .. */
5137   free(alloclhi);       /* .. */
5138   #endif
5139   return res;
5140   } /* decMultiplyOp */
5141
5142 /* ------------------------------------------------------------------ */
5143 /* decExpOp -- effect exponentiation                                  */
5144 /*                                                                    */
5145 /*   This computes C = exp(A)                                         */
5146 /*                                                                    */
5147 /*   res is C, the result.  C may be A                                */
5148 /*   rhs is A                                                         */
5149 /*   set is the context; note that rounding mode has no effect        */
5150 /*                                                                    */
5151 /* C must have space for set->digits digits. status is updated but    */
5152 /* not set.                                                           */
5153 /*                                                                    */
5154 /* Restrictions:                                                      */
5155 /*                                                                    */
5156 /*   digits, emax, and -emin in the context must be less than         */
5157 /*   2*DEC_MAX_MATH (1999998), and the rhs must be within these       */
5158 /*   bounds or a zero.  This is an internal routine, so these         */
5159 /*   restrictions are contractual and not enforced.                   */
5160 /*                                                                    */
5161 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will      */
5162 /* almost always be correctly rounded, but may be up to 1 ulp in      */
5163 /* error in rare cases.                                               */
5164 /*                                                                    */
5165 /* Finite results will always be full precision and Inexact, except   */
5166 /* when A is a zero or -Infinity (giving 1 or 0 respectively).        */
5167 /* ------------------------------------------------------------------ */
5168 /* This approach used here is similar to the algorithm described in   */
5169 /*                                                                    */
5170 /*   Variable Precision Exponential Function, T. E. Hull and          */
5171 /*   A. Abrham, ACM Transactions on Mathematical Software, Vol 12 #2, */
5172 /*   pp79-91, ACM, June 1986.                                         */
5173 /*                                                                    */
5174 /* with the main difference being that the iterations in the series   */
5175 /* evaluation are terminated dynamically (which does not require the  */
5176 /* extra variable-precision variables which are expensive in this     */
5177 /* context).                                                          */
5178 /*                                                                    */
5179 /* The error analysis in Hull & Abrham's paper applies except for the */
5180 /* round-off error accumulation during the series evaluation.  This   */
5181 /* code does not precalculate the number of iterations and so cannot  */
5182 /* use Horner's scheme.  Instead, the accumulation is done at double- */
5183 /* precision, which ensures that the additions of the terms are exact */
5184 /* and do not accumulate round-off (and any round-off errors in the   */
5185 /* terms themselves move 'to the right' faster than they can          */
5186 /* accumulate).  This code also extends the calculation by allowing,  */
5187 /* in the spirit of other decNumber operators, the input to be more   */
5188 /* precise than the result (the precision used is based on the more   */
5189 /* precise of the input or requested result).                         */
5190 /*                                                                    */
5191 /* Implementation notes:                                              */
5192 /*                                                                    */
5193 /* 1. This is separated out as decExpOp so it can be called from      */
5194 /*    other Mathematical functions (notably Ln) with a wider range    */
5195 /*    than normal.  In particular, it can handle the slightly wider   */
5196 /*    (double) range needed by Ln (which has to be able to calculate  */
5197 /*    exp(-x) where x can be the tiniest number (Ntiny).              */
5198 /*                                                                    */
5199 /* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop         */
5200 /*    iterations by appoximately a third with additional (although    */
5201 /*    diminishing) returns as the range is reduced to even smaller    */
5202 /*    fractions.  However, h (the power of 10 used to correct the     */
5203 /*    result at the end, see below) must be kept <=8 as otherwise     */
5204 /*    the final result cannot be computed.  Hence the leverage is a   */
5205 /*    sliding value (8-h), where potentially the range is reduced     */
5206 /*    more for smaller values.                                        */
5207 /*                                                                    */
5208 /*    The leverage that can be applied in this way is severely        */
5209 /*    limited by the cost of the raise-to-the power at the end,       */
5210 /*    which dominates when the number of iterations is small (less    */
5211 /*    than ten) or when rhs is short.  As an example, the adjustment  */
5212 /*    x**10,000,000 needs 31 multiplications, all but one full-width. */
5213 /*                                                                    */
5214 /* 3. The restrictions (especially precision) could be raised with    */
5215 /*    care, but the full decNumber range seems very hard within the   */
5216 /*    32-bit limits.                                                  */
5217 /*                                                                    */
5218 /* 4. The working precisions for the static buffers are twice the     */
5219 /*    obvious size to allow for calls from decNumberPower.            */
5220 /* ------------------------------------------------------------------ */
5221 decNumber * decExpOp(decNumber *res, const decNumber *rhs,
5222                          decContext *set, uInt *status) {
5223   uInt ignore=0;                   /* working status */
5224   Int h;                           /* adjusted exponent for 0.xxxx */
5225   Int p;                           /* working precision */
5226   Int residue;                     /* rounding residue */
5227   uInt needbytes;                  /* for space calculations */
5228   const decNumber *x=rhs;          /* (may point to safe copy later) */
5229   decContext aset, tset, dset;     /* working contexts */
5230   Int comp;                        /* work */
5231
5232   /* the argument is often copied to normalize it, so (unusually) it */
5233   /* is treated like other buffers, using DECBUFFER, +1 in case */
5234   /* DECBUFFER is 0 */
5235   decNumber bufr[D2N(DECBUFFER*2+1)];
5236   decNumber *allocrhs=NULL;        /* non-NULL if rhs buffer allocated */
5237
5238   /* the working precision will be no more than set->digits+8+1 */
5239   /* so for on-stack buffers DECBUFFER+9 is used, +1 in case DECBUFFER */
5240   /* is 0 (and twice that for the accumulator) */
5241
5242   /* buffer for t, term (working precision plus) */
5243   decNumber buft[D2N(DECBUFFER*2+9+1)];
5244   decNumber *allocbuft=NULL;       /* -> allocated buft, iff allocated */
5245   decNumber *t=buft;               /* term */
5246   /* buffer for a, accumulator (working precision * 2), at least 9 */
5247   decNumber bufa[D2N(DECBUFFER*4+18+1)];
5248   decNumber *allocbufa=NULL;       /* -> allocated bufa, iff allocated */
5249   decNumber *a=bufa;               /* accumulator */
5250   /* decNumber for the divisor term; this needs at most 9 digits */
5251   /* and so can be fixed size [16 so can use standard context] */
5252   decNumber bufd[D2N(16)];
5253   decNumber *d=bufd;               /* divisor */
5254   decNumber numone;                /* constant 1 */
5255
5256   #if DECCHECK
5257   Int iterations=0;                /* for later sanity check */
5258   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5259   #endif
5260
5261   do {                                  /* protect allocated storage */
5262     if (SPECIALARG) {                   /* handle infinities and NaNs */
5263       if (decNumberIsInfinite(rhs)) {   /* an infinity */
5264         if (decNumberIsNegative(rhs))   /* -Infinity -> +0 */
5265           decNumberZero(res);
5266          else decNumberCopy(res, rhs);  /* +Infinity -> self */
5267         }
5268        else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5269       break;}
5270
5271     if (ISZERO(rhs)) {                  /* zeros -> exact 1 */
5272       decNumberZero(res);               /* make clean 1 */
5273       *res->lsu=1;                      /* .. */
5274       break;}                           /* [no status to set] */
5275
5276     /* e**x when 0 < x < 0.66 is < 1+3x/2, hence can fast-path */
5277     /* positive and negative tiny cases which will result in inexact */
5278     /* 1.  This also allows the later add-accumulate to always be */
5279     /* exact (because its length will never be more than twice the */
5280     /* working precision). */
5281     /* The comparator (tiny) needs just one digit, so use the */
5282     /* decNumber d for it (reused as the divisor, etc., below); its */
5283     /* exponent is such that if x is positive it will have */
5284     /* set->digits-1 zeros between the decimal point and the digit, */
5285     /* which is 4, and if x is negative one more zero there as the */
5286     /* more precise result will be of the form 0.9999999 rather than */
5287     /* 1.0000001.  Hence, tiny will be 0.0000004  if digits=7 and x>0 */
5288     /* or 0.00000004 if digits=7 and x<0.  If RHS not larger than */
5289     /* this then the result will be 1.000000 */
5290     decNumberZero(d);                   /* clean */
5291     *d->lsu=4;                          /* set 4 .. */
5292     d->exponent=-set->digits;           /* * 10**(-d) */
5293     if (decNumberIsNegative(rhs)) d->exponent--;  /* negative case */
5294     comp=decCompare(d, rhs, 1);         /* signless compare */
5295     if (comp==BADINT) {
5296       *status|=DEC_Insufficient_storage;
5297       break;}
5298     if (comp>=0) {                      /* rhs < d */
5299       Int shift=set->digits-1;
5300       decNumberZero(res);               /* set 1 */
5301       *res->lsu=1;                      /* .. */
5302       res->digits=decShiftToMost(res->lsu, 1, shift);
5303       res->exponent=-shift;                  /* make 1.0000... */
5304       *status|=DEC_Inexact | DEC_Rounded;    /* .. inexactly */
5305       break;} /* tiny */
5306
5307     /* set up the context to be used for calculating a, as this is */
5308     /* used on both paths below */
5309     decContextDefault(&aset, DEC_INIT_DECIMAL64);
5310     /* accumulator bounds are as requested (could underflow) */
5311     aset.emax=set->emax;                /* usual bounds */
5312     aset.emin=set->emin;                /* .. */
5313     aset.clamp=0;                       /* and no concrete format */
5314
5315     /* calculate the adjusted (Hull & Abrham) exponent (where the */
5316     /* decimal point is just to the left of the coefficient msd) */
5317     h=rhs->exponent+rhs->digits;
5318     /* if h>8 then 10**h cannot be calculated safely; however, when */
5319     /* h=8 then exp(|rhs|) will be at least exp(1E+7) which is at */
5320     /* least 6.59E+4342944, so (due to the restriction on Emax/Emin) */
5321     /* overflow (or underflow to 0) is guaranteed -- so this case can */
5322     /* be handled by simply forcing the appropriate excess */
5323     if (h>8) {                          /* overflow/underflow */
5324       /* set up here so Power call below will over or underflow to */
5325       /* zero; set accumulator to either 2 or 0.02 */
5326       /* [stack buffer for a is always big enough for this] */
5327       decNumberZero(a);
5328       *a->lsu=2;                        /* not 1 but < exp(1) */
5329       if (decNumberIsNegative(rhs)) a->exponent=-2; /* make 0.02 */
5330       h=8;                              /* clamp so 10**h computable */
5331       p=9;                              /* set a working precision */
5332       }
5333      else {                             /* h<=8 */
5334       Int maxlever=(rhs->digits>8?1:0);
5335       /* [could/should increase this for precisions >40 or so, too] */
5336
5337       /* if h is 8, cannot normalize to a lower upper limit because */
5338       /* the final result will not be computable (see notes above), */
5339       /* but leverage can be applied whenever h is less than 8. */
5340       /* Apply as much as possible, up to a MAXLEVER digits, which */
5341       /* sets the tradeoff against the cost of the later a**(10**h). */
5342       /* As h is increased, the working precision below also */
5343       /* increases to compensate for the "constant digits at the */
5344       /* front" effect. */
5345       Int lever=MINI(8-h, maxlever);    /* leverage attainable */
5346       Int use=-rhs->digits-lever;       /* exponent to use for RHS */
5347       h+=lever;                         /* apply leverage selected */
5348       if (h<0) {                        /* clamp */
5349         use+=h;                         /* [may end up subnormal] */
5350         h=0;
5351         }
5352       /* Take a copy of RHS if it needs normalization (true whenever x>=1) */
5353       if (rhs->exponent!=use) {
5354         decNumber *newrhs=bufr;         /* assume will fit on stack */
5355         needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
5356         if (needbytes>sizeof(bufr)) {   /* need malloc space */
5357           allocrhs=(decNumber *)malloc(needbytes);
5358           if (allocrhs==NULL) {         /* hopeless -- abandon */
5359             *status|=DEC_Insufficient_storage;
5360             break;}
5361           newrhs=allocrhs;              /* use the allocated space */
5362           }
5363         decNumberCopy(newrhs, rhs);     /* copy to safe space */
5364         newrhs->exponent=use;           /* normalize; now <1 */
5365         x=newrhs;                       /* ready for use */
5366         /* decNumberShow(x); */
5367         }
5368
5369       /* Now use the usual power series to evaluate exp(x).  The */
5370       /* series starts as 1 + x + x^2/2 ... so prime ready for the */
5371       /* third term by setting the term variable t=x, the accumulator */
5372       /* a=1, and the divisor d=2. */
5373
5374       /* First determine the working precision.  From Hull & Abrham */
5375       /* this is set->digits+h+2.  However, if x is 'over-precise' we */
5376       /* need to allow for all its digits to potentially participate */
5377       /* (consider an x where all the excess digits are 9s) so in */
5378       /* this case use x->digits+h+2 */
5379       p=MAXI(x->digits, set->digits)+h+2;    /* [h<=8] */
5380
5381       /* a and t are variable precision, and depend on p, so space */
5382       /* must be allocated for them if necessary */
5383
5384       /* the accumulator needs to be able to hold 2p digits so that */
5385       /* the additions on the second and subsequent iterations are */
5386       /* sufficiently exact. */
5387       needbytes=sizeof(decNumber)+(D2U(p*2)-1)*sizeof(Unit);
5388       if (needbytes>sizeof(bufa)) {     /* need malloc space */
5389         allocbufa=(decNumber *)malloc(needbytes);
5390         if (allocbufa==NULL) {          /* hopeless -- abandon */
5391           *status|=DEC_Insufficient_storage;
5392           break;}
5393         a=allocbufa;                    /* use the allocated space */
5394         }
5395       /* the term needs to be able to hold p digits (which is */
5396       /* guaranteed to be larger than x->digits, so the initial copy */
5397       /* is safe); it may also be used for the raise-to-power */
5398       /* calculation below, which needs an extra two digits */
5399       needbytes=sizeof(decNumber)+(D2U(p+2)-1)*sizeof(Unit);
5400       if (needbytes>sizeof(buft)) {     /* need malloc space */
5401         allocbuft=(decNumber *)malloc(needbytes);
5402         if (allocbuft==NULL) {          /* hopeless -- abandon */
5403           *status|=DEC_Insufficient_storage;
5404           break;}
5405         t=allocbuft;                    /* use the allocated space */
5406         }
5407
5408       decNumberCopy(t, x);              /* term=x */
5409       decNumberZero(a); *a->lsu=1;      /* accumulator=1 */
5410       decNumberZero(d); *d->lsu=2;      /* divisor=2 */
5411       decNumberZero(&numone); *numone.lsu=1; /* constant 1 for increment */
5412
5413       /* set up the contexts for calculating a, t, and d */
5414       decContextDefault(&tset, DEC_INIT_DECIMAL64);
5415       dset=tset;
5416       /* accumulator bounds are set above, set precision now */
5417       aset.digits=p*2;                  /* double */
5418       /* term bounds avoid any underflow or overflow */
5419       tset.digits=p;
5420       tset.emin=DEC_MIN_EMIN;           /* [emax is plenty] */
5421       /* [dset.digits=16, etc., are sufficient] */
5422
5423       /* finally ready to roll */
5424       for (;;) {
5425         #if DECCHECK
5426         iterations++;
5427         #endif
5428         /* only the status from the accumulation is interesting */
5429         /* [but it should remain unchanged after first add] */
5430         decAddOp(a, a, t, &aset, 0, status);           /* a=a+t */
5431         decMultiplyOp(t, t, x, &tset, &ignore);        /* t=t*x */
5432         decDivideOp(t, t, d, &tset, DIVIDE, &ignore);  /* t=t/d */
5433         /* the iteration ends when the term cannot affect the result, */
5434         /* if rounded to p digits, which is when its value is smaller */
5435         /* than the accumulator by p+1 digits.  There must also be */
5436         /* full precision in a. */
5437         if (((a->digits+a->exponent)>=(t->digits+t->exponent+p+1))
5438             && (a->digits>=p)) break;
5439         decAddOp(d, d, &numone, &dset, 0, &ignore);    /* d=d+1 */
5440         } /* iterate */
5441
5442       #if DECCHECK
5443       /* just a sanity check; comment out test to show always */
5444       if (iterations>p+3)
5445         printf("Exp iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5446                (LI)iterations, (LI)*status, (LI)p, (LI)x->digits);
5447       #endif
5448       } /* h<=8 */
5449
5450     /* apply postconditioning: a=a**(10**h) -- this is calculated */
5451     /* at a slightly higher precision than Hull & Abrham suggest */
5452     if (h>0) {
5453       Int seenbit=0;               /* set once a 1-bit is seen */
5454       Int i;                       /* counter */
5455       Int n=powers[h];             /* always positive */
5456       aset.digits=p+2;             /* sufficient precision */
5457       /* avoid the overhead and many extra digits of decNumberPower */
5458       /* as all that is needed is the short 'multipliers' loop; here */
5459       /* accumulate the answer into t */
5460       decNumberZero(t); *t->lsu=1; /* acc=1 */
5461       for (i=1;;i++){              /* for each bit [top bit ignored] */
5462         /* abandon if have had overflow or terminal underflow */
5463         if (*status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
5464           if (*status&DEC_Overflow || ISZERO(t)) break;}
5465         n=n<<1;                    /* move next bit to testable position */
5466         if (n<0) {                 /* top bit is set */
5467           seenbit=1;               /* OK, have a significant bit */
5468           decMultiplyOp(t, t, a, &aset, status); /* acc=acc*x */
5469           }
5470         if (i==31) break;          /* that was the last bit */
5471         if (!seenbit) continue;    /* no need to square 1 */
5472         decMultiplyOp(t, t, t, &aset, status); /* acc=acc*acc [square] */
5473         } /*i*/ /* 32 bits */
5474       /* decNumberShow(t); */
5475       a=t;                         /* and carry on using t instead of a */
5476       }
5477
5478     /* Copy and round the result to res */
5479     residue=1;                          /* indicate dirt to right .. */
5480     if (ISZERO(a)) residue=0;           /* .. unless underflowed to 0 */
5481     aset.digits=set->digits;            /* [use default rounding] */
5482     decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5483     decFinish(res, set, &residue, status);       /* cleanup/set flags */
5484     } while(0);                         /* end protected */
5485
5486   free(allocrhs);       /* drop any storage used */
5487   free(allocbufa); /* .. */
5488   free(allocbuft); /* .. */
5489   /* [status is handled by caller] */
5490   return res;
5491   } /* decExpOp */
5492
5493 /* ------------------------------------------------------------------ */
5494 /* Initial-estimate natural logarithm table                           */
5495 /*                                                                    */
5496 /*   LNnn -- 90-entry 16-bit table for values from .10 through .99.   */
5497 /*           The result is a 4-digit encode of the coefficient (c=the */
5498 /*           top 14 bits encoding 0-9999) and a 2-digit encode of the */
5499 /*           exponent (e=the bottom 2 bits encoding 0-3)              */
5500 /*                                                                    */
5501 /*           The resulting value is given by:                         */
5502 /*                                                                    */
5503 /*             v = -c * 10**(-e-3)                                    */
5504 /*                                                                    */
5505 /*           where e and c are extracted from entry k = LNnn[x-10]    */
5506 /*           where x is truncated (NB) into the range 10 through 99,  */
5507 /*           and then c = k>>2 and e = k&3.                           */
5508 /* ------------------------------------------------------------------ */
5509 const uShort LNnn[90]={9016,  8652,  8316,  8008,  7724,  7456,  7208,
5510   6972,  6748,  6540,  6340,  6148,  5968,  5792,  5628,  5464,  5312,
5511   5164,  5020,  4884,  4748,  4620,  4496,  4376,  4256,  4144,  4032,
5512  39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629,
5513  29777, 28945, 28129, 27329, 26545, 25777, 25021, 24281, 23553, 22837,
5514  22137, 21445, 20769, 20101, 19445, 18801, 18165, 17541, 16925, 16321,
5515  15721, 15133, 14553, 13985, 13421, 12865, 12317, 11777, 11241, 10717,
5516  10197,  9685,  9177,  8677,  8185,  7697,  7213,  6737,  6269,  5801,
5517   5341,  4889,  4437, 39930, 35534, 31186, 26886, 22630, 18418, 14254,
5518  10130,  6046, 20055};
5519
5520 /* ------------------------------------------------------------------ */
5521 /* decLnOp -- effect natural logarithm                                */
5522 /*                                                                    */
5523 /*   This computes C = ln(A)                                          */
5524 /*                                                                    */
5525 /*   res is C, the result.  C may be A                                */
5526 /*   rhs is A                                                         */
5527 /*   set is the context; note that rounding mode has no effect        */
5528 /*                                                                    */
5529 /* C must have space for set->digits digits.                          */
5530 /*                                                                    */
5531 /* Notable cases:                                                     */
5532 /*   A<0 -> Invalid                                                   */
5533 /*   A=0 -> -Infinity (Exact)                                         */
5534 /*   A=+Infinity -> +Infinity (Exact)                                 */
5535 /*   A=1 exactly -> 0 (Exact)                                         */
5536 /*                                                                    */
5537 /* Restrictions (as for Exp):                                         */
5538 /*                                                                    */
5539 /*   digits, emax, and -emin in the context must be less than         */
5540 /*   DEC_MAX_MATH+11 (1000010), and the rhs must be within these      */
5541 /*   bounds or a zero.  This is an internal routine, so these         */
5542 /*   restrictions are contractual and not enforced.                   */
5543 /*                                                                    */
5544 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will      */
5545 /* almost always be correctly rounded, but may be up to 1 ulp in      */
5546 /* error in rare cases.                                               */
5547 /* ------------------------------------------------------------------ */
5548 /* The result is calculated using Newton's method, with each          */
5549 /* iteration calculating a' = a + x * exp(-a) - 1.  See, for example, */
5550 /* Epperson 1989.                                                     */
5551 /*                                                                    */
5552 /* The iteration ends when the adjustment x*exp(-a)-1 is tiny enough. */
5553 /* This has to be calculated at the sum of the precision of x and the */
5554 /* working precision.                                                 */
5555 /*                                                                    */
5556 /* Implementation notes:                                              */
5557 /*                                                                    */
5558 /* 1. This is separated out as decLnOp so it can be called from       */
5559 /*    other Mathematical functions (e.g., Log 10) with a wider range  */
5560 /*    than normal.  In particular, it can handle the slightly wider   */
5561 /*    (+9+2) range needed by a power function.                        */
5562 /*                                                                    */
5563 /* 2. The speed of this function is about 10x slower than exp, as     */
5564 /*    it typically needs 4-6 iterations for short numbers, and the    */
5565 /*    extra precision needed adds a squaring effect, twice.           */
5566 /*                                                                    */
5567 /* 3. Fastpaths are included for ln(10) and ln(2), up to length 40,   */
5568 /*    as these are common requests.  ln(10) is used by log10(x).      */
5569 /*                                                                    */
5570 /* 4. An iteration might be saved by widening the LNnn table, and     */
5571 /*    would certainly save at least one if it were made ten times     */
5572 /*    bigger, too (for truncated fractions 0.100 through 0.999).      */
5573 /*    However, for most practical evaluations, at least four or five  */
5574 /*    iterations will be neede -- so this would only speed up by      */
5575 /*    20-25% and that probably does not justify increasing the table  */
5576 /*    size.                                                           */
5577 /*                                                                    */
5578 /* 5. The static buffers are larger than might be expected to allow   */
5579 /*    for calls from decNumberPower.                                  */
5580 /* ------------------------------------------------------------------ */
5581 decNumber * decLnOp(decNumber *res, const decNumber *rhs,
5582                     decContext *set, uInt *status) {
5583   uInt ignore=0;                   /* working status accumulator */
5584   uInt needbytes;                  /* for space calculations */
5585   Int residue;                     /* rounding residue */
5586   Int r;                           /* rhs=f*10**r [see below] */
5587   Int p;                           /* working precision */
5588   Int pp;                          /* precision for iteration */
5589   Int t;                           /* work */
5590
5591   /* buffers for a (accumulator, typically precision+2) and b */
5592   /* (adjustment calculator, same size) */
5593   decNumber bufa[D2N(DECBUFFER+12)];
5594   decNumber *allocbufa=NULL;       /* -> allocated bufa, iff allocated */
5595   decNumber *a=bufa;               /* accumulator/work */
5596   decNumber bufb[D2N(DECBUFFER*2+2)];
5597   decNumber *allocbufb=NULL;       /* -> allocated bufa, iff allocated */
5598   decNumber *b=bufb;               /* adjustment/work */
5599
5600   decNumber  numone;               /* constant 1 */
5601   decNumber  cmp;                  /* work */
5602   decContext aset, bset;           /* working contexts */
5603
5604   #if DECCHECK
5605   Int iterations=0;                /* for later sanity check */
5606   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5607   #endif
5608
5609   do {                                  /* protect allocated storage */
5610     if (SPECIALARG) {                   /* handle infinities and NaNs */
5611       if (decNumberIsInfinite(rhs)) {   /* an infinity */
5612         if (decNumberIsNegative(rhs))   /* -Infinity -> error */
5613           *status|=DEC_Invalid_operation;
5614          else decNumberCopy(res, rhs);  /* +Infinity -> self */
5615         }
5616        else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5617       break;}
5618
5619     if (ISZERO(rhs)) {                  /* +/- zeros -> -Infinity */
5620       decNumberZero(res);               /* make clean */
5621       res->bits=DECINF|DECNEG;          /* set - infinity */
5622       break;}                           /* [no status to set] */
5623
5624     /* Non-zero negatives are bad... */
5625     if (decNumberIsNegative(rhs)) {     /* -x -> error */
5626       *status|=DEC_Invalid_operation;
5627       break;}
5628
5629     /* Here, rhs is positive, finite, and in range */
5630
5631     /* lookaside fastpath code for ln(2) and ln(10) at common lengths */
5632     if (rhs->exponent==0 && set->digits<=40) {
5633       #if DECDPUN==1
5634       if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { /* ln(10) */
5635       #else
5636       if (rhs->lsu[0]==10 && rhs->digits==2) {                  /* ln(10) */
5637       #endif
5638         aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5639         #define LN10 "2.302585092994045684017991454684364207601"
5640         decNumberFromString(res, LN10, &aset);
5641         *status|=(DEC_Inexact | DEC_Rounded); /* is inexact */
5642         break;}
5643       if (rhs->lsu[0]==2 && rhs->digits==1) { /* ln(2) */
5644         aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5645         #define LN2 "0.6931471805599453094172321214581765680755"
5646         decNumberFromString(res, LN2, &aset);
5647         *status|=(DEC_Inexact | DEC_Rounded);
5648         break;}
5649       } /* integer and short */
5650
5651     /* Determine the working precision.  This is normally the */
5652     /* requested precision + 2, with a minimum of 9.  However, if */
5653     /* the rhs is 'over-precise' then allow for all its digits to */
5654     /* potentially participate (consider an rhs where all the excess */
5655     /* digits are 9s) so in this case use rhs->digits+2. */
5656     p=MAXI(rhs->digits, MAXI(set->digits, 7))+2;
5657
5658     /* Allocate space for the accumulator and the high-precision */
5659     /* adjustment calculator, if necessary.  The accumulator must */
5660     /* be able to hold p digits, and the adjustment up to */
5661     /* rhs->digits+p digits.  They are also made big enough for 16 */
5662     /* digits so that they can be used for calculating the initial */
5663     /* estimate. */
5664     needbytes=sizeof(decNumber)+(D2U(MAXI(p,16))-1)*sizeof(Unit);
5665     if (needbytes>sizeof(bufa)) {     /* need malloc space */
5666       allocbufa=(decNumber *)malloc(needbytes);
5667       if (allocbufa==NULL) {          /* hopeless -- abandon */
5668         *status|=DEC_Insufficient_storage;
5669         break;}
5670       a=allocbufa;                    /* use the allocated space */
5671       }
5672     pp=p+rhs->digits;
5673     needbytes=sizeof(decNumber)+(D2U(MAXI(pp,16))-1)*sizeof(Unit);
5674     if (needbytes>sizeof(bufb)) {     /* need malloc space */
5675       allocbufb=(decNumber *)malloc(needbytes);
5676       if (allocbufb==NULL) {          /* hopeless -- abandon */
5677         *status|=DEC_Insufficient_storage;
5678         break;}
5679       b=allocbufb;                    /* use the allocated space */
5680       }
5681
5682     /* Prepare an initial estimate in acc. Calculate this by */
5683     /* considering the coefficient of x to be a normalized fraction, */
5684     /* f, with the decimal point at far left and multiplied by */
5685     /* 10**r.  Then, rhs=f*10**r and 0.1<=f<1, and */
5686     /*   ln(x) = ln(f) + ln(10)*r */
5687     /* Get the initial estimate for ln(f) from a small lookup */
5688     /* table (see above) indexed by the first two digits of f, */
5689     /* truncated. */
5690
5691     decContextDefault(&aset, DEC_INIT_DECIMAL64); /* 16-digit extended */
5692     r=rhs->exponent+rhs->digits;        /* 'normalised' exponent */
5693     decNumberFromInt32(a, r);           /* a=r */
5694     decNumberFromInt32(b, 2302585);     /* b=ln(10) (2.302585) */
5695     b->exponent=-6;                     /*  .. */
5696     decMultiplyOp(a, a, b, &aset, &ignore);  /* a=a*b */
5697     /* now get top two digits of rhs into b by simple truncate and */
5698     /* force to integer */
5699     residue=0;                          /* (no residue) */
5700     aset.digits=2; aset.round=DEC_ROUND_DOWN;
5701     decCopyFit(b, rhs, &aset, &residue, &ignore); /* copy & shorten */
5702     b->exponent=0;                      /* make integer */
5703     t=decGetInt(b);                     /* [cannot fail] */
5704     if (t<10) t=X10(t);                 /* adjust single-digit b */
5705     t=LNnn[t-10];                       /* look up ln(b) */
5706     decNumberFromInt32(b, t>>2);        /* b=ln(b) coefficient */
5707     b->exponent=-(t&3)-3;               /* set exponent */
5708     b->bits=DECNEG;                     /* ln(0.10)->ln(0.99) always -ve */
5709     aset.digits=16; aset.round=DEC_ROUND_HALF_EVEN; /* restore */
5710     decAddOp(a, a, b, &aset, 0, &ignore); /* acc=a+b */
5711     /* the initial estimate is now in a, with up to 4 digits correct. */
5712     /* When rhs is at or near Nmax the estimate will be low, so we */
5713     /* will approach it from below, avoiding overflow when calling exp. */
5714
5715     decNumberZero(&numone); *numone.lsu=1;   /* constant 1 for adjustment */
5716
5717     /* accumulator bounds are as requested (could underflow, but */
5718     /* cannot overflow) */
5719     aset.emax=set->emax;
5720     aset.emin=set->emin;
5721     aset.clamp=0;                       /* no concrete format */
5722     /* set up a context to be used for the multiply and subtract */
5723     bset=aset;
5724     bset.emax=DEC_MAX_MATH*2;           /* use double bounds for the */
5725     bset.emin=-DEC_MAX_MATH*2;          /* adjustment calculation */
5726                                         /* [see decExpOp call below] */
5727     /* for each iteration double the number of digits to calculate, */
5728     /* up to a maximum of p */
5729     pp=9;                               /* initial precision */
5730     /* [initially 9 as then the sequence starts 7+2, 16+2, and */
5731     /* 34+2, which is ideal for standard-sized numbers] */
5732     aset.digits=pp;                     /* working context */
5733     bset.digits=pp+rhs->digits;         /* wider context */
5734     for (;;) {                          /* iterate */
5735       #if DECCHECK
5736       iterations++;
5737       if (iterations>24) break;         /* consider 9 * 2**24 */
5738       #endif
5739       /* calculate the adjustment (exp(-a)*x-1) into b.  This is a */
5740       /* catastrophic subtraction but it really is the difference */
5741       /* from 1 that is of interest. */
5742       /* Use the internal entry point to Exp as it allows the double */
5743       /* range for calculating exp(-a) when a is the tiniest subnormal. */
5744       a->bits^=DECNEG;                  /* make -a */
5745       decExpOp(b, a, &bset, &ignore);   /* b=exp(-a) */
5746       a->bits^=DECNEG;                  /* restore sign of a */
5747       /* now multiply by rhs and subtract 1, at the wider precision */
5748       decMultiplyOp(b, b, rhs, &bset, &ignore);        /* b=b*rhs */
5749       decAddOp(b, b, &numone, &bset, DECNEG, &ignore); /* b=b-1 */
5750
5751       /* the iteration ends when the adjustment cannot affect the */
5752       /* result by >=0.5 ulp (at the requested digits), which */
5753       /* is when its value is smaller than the accumulator by */
5754       /* set->digits+1 digits (or it is zero) -- this is a looser */
5755       /* requirement than for Exp because all that happens to the */
5756       /* accumulator after this is the final rounding (but note that */
5757       /* there must also be full precision in a, or a=0). */
5758
5759       if (decNumberIsZero(b) ||
5760           (a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) {
5761         if (a->digits==p) break;
5762         if (decNumberIsZero(a)) {
5763           decCompareOp(&cmp, rhs, &numone, &aset, COMPARE, &ignore); /* rhs=1 ? */
5764           if (cmp.lsu[0]==0) a->exponent=0;            /* yes, exact 0 */
5765            else *status|=(DEC_Inexact | DEC_Rounded);  /* no, inexact */
5766           break;
5767           }
5768         /* force padding if adjustment has gone to 0 before full length */
5769         if (decNumberIsZero(b)) b->exponent=a->exponent-p;
5770         }
5771
5772       /* not done yet ... */
5773       decAddOp(a, a, b, &aset, 0, &ignore);  /* a=a+b for next estimate */
5774       if (pp==p) continue;                   /* precision is at maximum */
5775       /* lengthen the next calculation */
5776       pp=pp*2;                               /* double precision */
5777       if (pp>p) pp=p;                        /* clamp to maximum */
5778       aset.digits=pp;                        /* working context */
5779       bset.digits=pp+rhs->digits;            /* wider context */
5780       } /* Newton's iteration */
5781
5782     #if DECCHECK
5783     /* just a sanity check; remove the test to show always */
5784     if (iterations>24)
5785       printf("Ln iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5786             (LI)iterations, (LI)*status, (LI)p, (LI)rhs->digits);
5787     #endif
5788
5789     /* Copy and round the result to res */
5790     residue=1;                          /* indicate dirt to right */
5791     if (ISZERO(a)) residue=0;           /* .. unless underflowed to 0 */
5792     aset.digits=set->digits;            /* [use default rounding] */
5793     decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5794     decFinish(res, set, &residue, status);       /* cleanup/set flags */
5795     } while(0);                         /* end protected */
5796
5797   free(allocbufa); /* drop any storage used */
5798   free(allocbufb); /* .. */
5799   /* [status is handled by caller] */
5800   return res;
5801   } /* decLnOp */
5802
5803 /* ------------------------------------------------------------------ */
5804 /* decQuantizeOp  -- force exponent to requested value                */
5805 /*                                                                    */
5806 /*   This computes C = op(A, B), where op adjusts the coefficient     */
5807 /*   of C (by rounding or shifting) such that the exponent (-scale)   */
5808 /*   of C has the value B or matches the exponent of B.               */
5809 /*   The numerical value of C will equal A, except for the effects of */
5810 /*   any rounding that occurred.                                      */
5811 /*                                                                    */
5812 /*   res is C, the result.  C may be A or B                           */
5813 /*   lhs is A, the number to adjust                                   */
5814 /*   rhs is B, the requested exponent                                 */
5815 /*   set is the context                                               */
5816 /*   quant is 1 for quantize or 0 for rescale                         */
5817 /*   status is the status accumulator (this can be called without     */
5818 /*          risk of control loss)                                     */
5819 /*                                                                    */
5820 /* C must have space for set->digits digits.                          */
5821 /*                                                                    */
5822 /* Unless there is an error or the result is infinite, the exponent   */
5823 /* after the operation is guaranteed to be that requested.            */
5824 /* ------------------------------------------------------------------ */
5825 static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs,
5826                                  const decNumber *rhs, decContext *set,
5827                                  Flag quant, uInt *status) {
5828   #if DECSUBSET
5829   decNumber *alloclhs=NULL;        /* non-NULL if rounded lhs allocated */
5830   decNumber *allocrhs=NULL;        /* .., rhs */
5831   #endif
5832   const decNumber *inrhs=rhs;      /* save original rhs */
5833   Int   reqdigits=set->digits;     /* requested DIGITS */
5834   Int   reqexp;                    /* requested exponent [-scale] */
5835   Int   residue=0;                 /* rounding residue */
5836   Int   etiny=set->emin-(reqdigits-1);
5837
5838   #if DECCHECK
5839   if (decCheckOperands(res, lhs, rhs, set)) return res;
5840   #endif
5841
5842   do {                             /* protect allocated storage */
5843     #if DECSUBSET
5844     if (!set->extended) {
5845       /* reduce operands and set lostDigits status, as needed */
5846       if (lhs->digits>reqdigits) {
5847         alloclhs=decRoundOperand(lhs, set, status);
5848         if (alloclhs==NULL) break;
5849         lhs=alloclhs;
5850         }
5851       if (rhs->digits>reqdigits) { /* [this only checks lostDigits] */
5852         allocrhs=decRoundOperand(rhs, set, status);
5853         if (allocrhs==NULL) break;
5854         rhs=allocrhs;
5855         }
5856       }
5857     #endif
5858     /* [following code does not require input rounding] */
5859
5860     /* Handle special values */
5861     if (SPECIALARGS) {
5862       /* NaNs get usual processing */
5863       if (SPECIALARGS & (DECSNAN | DECNAN))
5864         decNaNs(res, lhs, rhs, set, status);
5865       /* one infinity but not both is bad */
5866       else if ((lhs->bits ^ rhs->bits) & DECINF)
5867         *status|=DEC_Invalid_operation;
5868       /* both infinity: return lhs */
5869       else decNumberCopy(res, lhs);          /* [nop if in place] */
5870       break;
5871       }
5872
5873     /* set requested exponent */
5874     if (quant) reqexp=inrhs->exponent;  /* quantize -- match exponents */
5875      else {                             /* rescale -- use value of rhs */
5876       /* Original rhs must be an integer that fits and is in range, */
5877       /* which could be from -1999999997 to +999999999, thanks to */
5878       /* subnormals */
5879       reqexp=decGetInt(inrhs);               /* [cannot fail] */
5880       }
5881
5882     #if DECSUBSET
5883     if (!set->extended) etiny=set->emin;     /* no subnormals */
5884     #endif
5885
5886     if (reqexp==BADINT                       /* bad (rescale only) or .. */
5887      || reqexp==BIGODD || reqexp==BIGEVEN    /* very big (ditto) or .. */
5888      || (reqexp<etiny)                       /* < lowest */
5889      || (reqexp>set->emax)) {                /* > emax */
5890       *status|=DEC_Invalid_operation;
5891       break;}
5892
5893     /* the RHS has been processed, so it can be overwritten now if necessary */
5894     if (ISZERO(lhs)) {                       /* zero coefficient unchanged */
5895       decNumberCopy(res, lhs);               /* [nop if in place] */
5896       res->exponent=reqexp;                  /* .. just set exponent */
5897       #if DECSUBSET
5898       if (!set->extended) res->bits=0;       /* subset specification; no -0 */
5899       #endif
5900       }
5901      else {                                  /* non-zero lhs */
5902       Int adjust=reqexp-lhs->exponent;       /* digit adjustment needed */
5903       /* if adjusted coefficient will definitely not fit, give up now */
5904       if ((lhs->digits-adjust)>reqdigits) {
5905         *status|=DEC_Invalid_operation;
5906         break;
5907         }
5908
5909       if (adjust>0) {                        /* increasing exponent */
5910         /* this will decrease the length of the coefficient by adjust */
5911         /* digits, and must round as it does so */
5912         decContext workset;                  /* work */
5913         workset=*set;                        /* clone rounding, etc. */
5914         workset.digits=lhs->digits-adjust;   /* set requested length */
5915         /* [note that the latter can be <1, here] */
5916         decCopyFit(res, lhs, &workset, &residue, status); /* fit to result */
5917         decApplyRound(res, &workset, residue, status);    /* .. and round */
5918         residue=0;                                        /* [used] */
5919         /* If just rounded a 999s case, exponent will be off by one; */
5920         /* adjust back (after checking space), if so. */
5921         if (res->exponent>reqexp) {
5922           /* re-check needed, e.g., for quantize(0.9999, 0.001) under */
5923           /* set->digits==3 */
5924           if (res->digits==reqdigits) {      /* cannot shift by 1 */
5925             *status&=~(DEC_Inexact | DEC_Rounded); /* [clean these] */
5926             *status|=DEC_Invalid_operation;
5927             break;
5928             }
5929           res->digits=decShiftToMost(res->lsu, res->digits, 1); /* shift */
5930           res->exponent--;                   /* (re)adjust the exponent. */
5931           }
5932         #if DECSUBSET
5933         if (ISZERO(res) && !set->extended) res->bits=0; /* subset; no -0 */
5934         #endif
5935         } /* increase */
5936        else /* adjust<=0 */ {                /* decreasing or = exponent */
5937         /* this will increase the length of the coefficient by -adjust */
5938         /* digits, by adding zero or more trailing zeros; this is */
5939         /* already checked for fit, above */
5940         decNumberCopy(res, lhs);             /* [it will fit] */
5941         /* if padding needed (adjust<0), add it now... */
5942         if (adjust<0) {
5943           res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
5944           res->exponent+=adjust;             /* adjust the exponent */
5945           }
5946         } /* decrease */
5947       } /* non-zero */
5948
5949     /* Check for overflow [do not use Finalize in this case, as an */
5950     /* overflow here is a "don't fit" situation] */
5951     if (res->exponent>set->emax-res->digits+1) {  /* too big */
5952       *status|=DEC_Invalid_operation;
5953       break;
5954       }
5955      else {
5956       decFinalize(res, set, &residue, status);    /* set subnormal flags */
5957       *status&=~DEC_Underflow;          /* suppress Underflow [as per 754] */
5958       }
5959     } while(0);                         /* end protected */
5960
5961   #if DECSUBSET
5962   free(allocrhs);       /* drop any storage used */
5963   free(alloclhs);       /* .. */
5964   #endif
5965   return res;
5966   } /* decQuantizeOp */
5967
5968 /* ------------------------------------------------------------------ */
5969 /* decCompareOp -- compare, min, or max two Numbers                   */
5970 /*                                                                    */
5971 /*   This computes C = A ? B and carries out one of four operations:  */
5972 /*     COMPARE    -- returns the signum (as a number) giving the      */
5973 /*                   result of a comparison unless one or both        */
5974 /*                   operands is a NaN (in which case a NaN results)  */
5975 /*     COMPSIG    -- as COMPARE except that a quiet NaN raises        */
5976 /*                   Invalid operation.                               */
5977 /*     COMPMAX    -- returns the larger of the operands, using the    */
5978 /*                   754 maxnum operation                             */
5979 /*     COMPMAXMAG -- ditto, comparing absolute values                 */
5980 /*     COMPMIN    -- the 754 minnum operation                         */
5981 /*     COMPMINMAG -- ditto, comparing absolute values                 */
5982 /*     COMTOTAL   -- returns the signum (as a number) giving the      */
5983 /*                   result of a comparison using 754 total ordering  */
5984 /*                                                                    */
5985 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
5986 /*   lhs is A                                                         */
5987 /*   rhs is B                                                         */
5988 /*   set is the context                                               */
5989 /*   op  is the operation flag                                        */
5990 /*   status is the usual accumulator                                  */
5991 /*                                                                    */
5992 /* C must have space for one digit for COMPARE or set->digits for     */
5993 /* COMPMAX, COMPMIN, COMPMAXMAG, or COMPMINMAG.                       */
5994 /* ------------------------------------------------------------------ */
5995 /* The emphasis here is on speed for common cases, and avoiding       */
5996 /* coefficient comparison if possible.                                */
5997 /* ------------------------------------------------------------------ */
5998 decNumber * decCompareOp(decNumber *res, const decNumber *lhs,
5999                          const decNumber *rhs, decContext *set,
6000                          Flag op, uInt *status) {
6001   #if DECSUBSET
6002   decNumber *alloclhs=NULL;        /* non-NULL if rounded lhs allocated */
6003   decNumber *allocrhs=NULL;        /* .., rhs */
6004   #endif
6005   Int   result=0;                  /* default result value */
6006   uByte merged;                    /* work */
6007
6008   #if DECCHECK
6009   if (decCheckOperands(res, lhs, rhs, set)) return res;
6010   #endif
6011
6012   do {                             /* protect allocated storage */
6013     #if DECSUBSET
6014     if (!set->extended) {
6015       /* reduce operands and set lostDigits status, as needed */
6016       if (lhs->digits>set->digits) {
6017         alloclhs=decRoundOperand(lhs, set, status);
6018         if (alloclhs==NULL) {result=BADINT; break;}
6019         lhs=alloclhs;
6020         }
6021       if (rhs->digits>set->digits) {
6022         allocrhs=decRoundOperand(rhs, set, status);
6023         if (allocrhs==NULL) {result=BADINT; break;}
6024         rhs=allocrhs;
6025         }
6026       }
6027     #endif
6028     /* [following code does not require input rounding] */
6029
6030     /* If total ordering then handle differing signs 'up front' */
6031     if (op==COMPTOTAL) {                /* total ordering */
6032       if (decNumberIsNegative(lhs) & !decNumberIsNegative(rhs)) {
6033         result=-1;
6034         break;
6035         }
6036       if (!decNumberIsNegative(lhs) & decNumberIsNegative(rhs)) {
6037         result=+1;
6038         break;
6039         }
6040       }
6041
6042     /* handle NaNs specially; let infinities drop through */
6043     /* This assumes sNaN (even just one) leads to NaN. */
6044     merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN);
6045     if (merged) {                       /* a NaN bit set */
6046       if (op==COMPARE);                 /* result will be NaN */
6047        else if (op==COMPSIG)            /* treat qNaN as sNaN */
6048         *status|=DEC_Invalid_operation | DEC_sNaN;
6049        else if (op==COMPTOTAL) {        /* total ordering, always finite */
6050         /* signs are known to be the same; compute the ordering here */
6051         /* as if the signs are both positive, then invert for negatives */
6052         if (!decNumberIsNaN(lhs)) result=-1;
6053          else if (!decNumberIsNaN(rhs)) result=+1;
6054          /* here if both NaNs */
6055          else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1;
6056          else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1;
6057          else { /* both NaN or both sNaN */
6058           /* now it just depends on the payload */
6059           result=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6060                                 rhs->lsu, D2U(rhs->digits), 0);
6061           /* [Error not possible, as these are 'aligned'] */
6062           } /* both same NaNs */
6063         if (decNumberIsNegative(lhs)) result=-result;
6064         break;
6065         } /* total order */
6066
6067        else if (merged & DECSNAN);           /* sNaN -> qNaN */
6068        else { /* here if MIN or MAX and one or two quiet NaNs */
6069         /* min or max -- 754 rules ignore single NaN */
6070         if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) {
6071           /* just one NaN; force choice to be the non-NaN operand */
6072           op=COMPMAX;
6073           if (lhs->bits & DECNAN) result=-1; /* pick rhs */
6074                              else result=+1; /* pick lhs */
6075           break;
6076           }
6077         } /* max or min */
6078       op=COMPNAN;                            /* use special path */
6079       decNaNs(res, lhs, rhs, set, status);   /* propagate NaN */
6080       break;
6081       }
6082     /* have numbers */
6083     if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1);
6084      else result=decCompare(lhs, rhs, 0);    /* sign matters */
6085     } while(0);                              /* end protected */
6086
6087   if (result==BADINT) *status|=DEC_Insufficient_storage; /* rare */
6088    else {
6089     if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { /* returning signum */
6090       if (op==COMPTOTAL && result==0) {
6091         /* operands are numerically equal or same NaN (and same sign, */
6092         /* tested first); if identical, leave result 0 */
6093         if (lhs->exponent!=rhs->exponent) {
6094           if (lhs->exponent<rhs->exponent) result=-1;
6095            else result=+1;
6096           if (decNumberIsNegative(lhs)) result=-result;
6097           } /* lexp!=rexp */
6098         } /* total-order by exponent */
6099       decNumberZero(res);               /* [always a valid result] */
6100       if (result!=0) {                  /* must be -1 or +1 */
6101         *res->lsu=1;
6102         if (result<0) res->bits=DECNEG;
6103         }
6104       }
6105      else if (op==COMPNAN);             /* special, drop through */
6106      else {                             /* MAX or MIN, non-NaN result */
6107       Int residue=0;                    /* rounding accumulator */
6108       /* choose the operand for the result */
6109       const decNumber *choice;
6110       if (result==0) { /* operands are numerically equal */
6111         /* choose according to sign then exponent (see 754) */
6112         uByte slhs=(lhs->bits & DECNEG);
6113         uByte srhs=(rhs->bits & DECNEG);
6114         #if DECSUBSET
6115         if (!set->extended) {           /* subset: force left-hand */
6116           op=COMPMAX;
6117           result=+1;
6118           }
6119         else
6120         #endif
6121         if (slhs!=srhs) {          /* signs differ */
6122           if (slhs) result=-1;     /* rhs is max */
6123                else result=+1;     /* lhs is max */
6124           }
6125          else if (slhs && srhs) {  /* both negative */
6126           if (lhs->exponent<rhs->exponent) result=+1;
6127                                       else result=-1;
6128           /* [if equal, use lhs, technically identical] */
6129           }
6130          else {                    /* both positive */
6131           if (lhs->exponent>rhs->exponent) result=+1;
6132                                       else result=-1;
6133           /* [ditto] */
6134           }
6135         } /* numerically equal */
6136       /* here result will be non-0; reverse if looking for MIN */
6137       if (op==COMPMIN || op==COMPMINMAG) result=-result;
6138       choice=(result>0 ? lhs : rhs);    /* choose */
6139       /* copy chosen to result, rounding if need be */
6140       decCopyFit(res, choice, set, &residue, status);
6141       decFinish(res, set, &residue, status);
6142       }
6143     }
6144   #if DECSUBSET
6145   free(allocrhs);       /* free any storage used */
6146   free(alloclhs);       /* .. */
6147   #endif
6148   return res;
6149   } /* decCompareOp */
6150
6151 /* ------------------------------------------------------------------ */
6152 /* decCompare -- compare two decNumbers by numerical value            */
6153 /*                                                                    */
6154 /*  This routine compares A ? B without altering them.                */
6155 /*                                                                    */
6156 /*  Arg1 is A, a decNumber which is not a NaN                         */
6157 /*  Arg2 is B, a decNumber which is not a NaN                         */
6158 /*  Arg3 is 1 for a sign-independent compare, 0 otherwise             */
6159 /*                                                                    */
6160 /*  returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure   */
6161 /*  (the only possible failure is an allocation error)                */
6162 /* ------------------------------------------------------------------ */
6163 static Int decCompare(const decNumber *lhs, const decNumber *rhs,
6164                       Flag abs) {
6165   Int   result;                    /* result value */
6166   Int   sigr;                      /* rhs signum */
6167   Int   compare;                   /* work */
6168
6169   result=1;                                  /* assume signum(lhs) */
6170   if (ISZERO(lhs)) result=0;
6171   if (abs) {
6172     if (ISZERO(rhs)) return result;          /* LHS wins or both 0 */
6173     /* RHS is non-zero */
6174     if (result==0) return -1;                /* LHS is 0; RHS wins */
6175     /* [here, both non-zero, result=1] */
6176     }
6177    else {                                    /* signs matter */
6178     if (result && decNumberIsNegative(lhs)) result=-1;
6179     sigr=1;                                  /* compute signum(rhs) */
6180     if (ISZERO(rhs)) sigr=0;
6181      else if (decNumberIsNegative(rhs)) sigr=-1;
6182     if (result > sigr) return +1;            /* L > R, return 1 */
6183     if (result < sigr) return -1;            /* L < R, return -1 */
6184     if (result==0) return 0;                   /* both 0 */
6185     }
6186
6187   /* signums are the same; both are non-zero */
6188   if ((lhs->bits | rhs->bits) & DECINF) {    /* one or more infinities */
6189     if (decNumberIsInfinite(rhs)) {
6190       if (decNumberIsInfinite(lhs)) result=0;/* both infinite */
6191        else result=-result;                  /* only rhs infinite */
6192       }
6193     return result;
6194     }
6195   /* must compare the coefficients, allowing for exponents */
6196   if (lhs->exponent>rhs->exponent) {         /* LHS exponent larger */
6197     /* swap sides, and sign */
6198     const decNumber *temp=lhs;
6199     lhs=rhs;
6200     rhs=temp;
6201     result=-result;
6202     }
6203   compare=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6204                          rhs->lsu, D2U(rhs->digits),
6205                          rhs->exponent-lhs->exponent);
6206   if (compare!=BADINT) compare*=result;      /* comparison succeeded */
6207   return compare;
6208   } /* decCompare */
6209
6210 /* ------------------------------------------------------------------ */
6211 /* decUnitCompare -- compare two >=0 integers in Unit arrays          */
6212 /*                                                                    */
6213 /*  This routine compares A ? B*10**E where A and B are unit arrays   */
6214 /*  A is a plain integer                                              */
6215 /*  B has an exponent of E (which must be non-negative)               */
6216 /*                                                                    */
6217 /*  Arg1 is A first Unit (lsu)                                        */
6218 /*  Arg2 is A length in Units                                         */
6219 /*  Arg3 is B first Unit (lsu)                                        */
6220 /*  Arg4 is B length in Units                                         */
6221 /*  Arg5 is E (0 if the units are aligned)                            */
6222 /*                                                                    */
6223 /*  returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure   */
6224 /*  (the only possible failure is an allocation error, which can      */
6225 /*  only occur if E!=0)                                               */
6226 /* ------------------------------------------------------------------ */
6227 static Int decUnitCompare(const Unit *a, Int alength,
6228                           const Unit *b, Int blength, Int exp) {
6229   Unit  *acc;                      /* accumulator for result */
6230   Unit  accbuff[SD2U(DECBUFFER*2+1)]; /* local buffer */
6231   Unit  *allocacc=NULL;            /* -> allocated acc buffer, iff allocated */
6232   Int   accunits, need;            /* units in use or needed for acc */
6233   const Unit *l, *r, *u;           /* work */
6234   Int   expunits, exprem, result;  /* .. */
6235
6236   if (exp==0) {                    /* aligned; fastpath */
6237     if (alength>blength) return 1;
6238     if (alength<blength) return -1;
6239     /* same number of units in both -- need unit-by-unit compare */
6240     l=a+alength-1;
6241     r=b+alength-1;
6242     for (;l>=a; l--, r--) {
6243       if (*l>*r) return 1;
6244       if (*l<*r) return -1;
6245       }
6246     return 0;                      /* all units match */
6247     } /* aligned */
6248
6249   /* Unaligned.  If one is >1 unit longer than the other, padded */
6250   /* approximately, then can return easily */
6251   if (alength>blength+(Int)D2U(exp)) return 1;
6252   if (alength+1<blength+(Int)D2U(exp)) return -1;
6253
6254   /* Need to do a real subtract.  For this, a result buffer is needed */
6255   /* even though only the sign is of interest.  Its length needs */
6256   /* to be the larger of alength and padded blength, +2 */
6257   need=blength+D2U(exp);                /* maximum real length of B */
6258   if (need<alength) need=alength;
6259   need+=2;
6260   acc=accbuff;                          /* assume use local buffer */
6261   if (need*sizeof(Unit)>sizeof(accbuff)) {
6262     allocacc=(Unit *)malloc(need*sizeof(Unit));
6263     if (allocacc==NULL) return BADINT;  /* hopeless -- abandon */
6264     acc=allocacc;
6265     }
6266   /* Calculate units and remainder from exponent. */
6267   expunits=exp/DECDPUN;
6268   exprem=exp%DECDPUN;
6269   /* subtract [A+B*(-m)] */
6270   accunits=decUnitAddSub(a, alength, b, blength, expunits, acc,
6271                          -(Int)powers[exprem]);
6272   /* [UnitAddSub result may have leading zeros, even on zero] */
6273   if (accunits<0) result=-1;            /* negative result */
6274    else {                               /* non-negative result */
6275     /* check units of the result before freeing any storage */
6276     for (u=acc; u<acc+accunits-1 && *u==0;) u++;
6277     result=(*u==0 ? 0 : +1);
6278     }
6279   /* clean up and return the result */
6280   free(allocacc);       /* drop any storage used */
6281   return result;
6282   } /* decUnitCompare */
6283
6284 /* ------------------------------------------------------------------ */
6285 /* decUnitAddSub -- add or subtract two >=0 integers in Unit arrays   */
6286 /*                                                                    */
6287 /*  This routine performs the calculation:                            */
6288 /*                                                                    */
6289 /*  C=A+(B*M)                                                         */
6290 /*                                                                    */
6291 /*  Where M is in the range -DECDPUNMAX through +DECDPUNMAX.          */
6292 /*                                                                    */
6293 /*  A may be shorter or longer than B.                                */
6294 /*                                                                    */
6295 /*  Leading zeros are not removed after a calculation.  The result is */
6296 /*  either the same length as the longer of A and B (adding any       */
6297 /*  shift), or one Unit longer than that (if a Unit carry occurred).  */
6298 /*                                                                    */
6299 /*  A and B content are not altered unless C is also A or B.          */
6300 /*  C may be the same array as A or B, but only if no zero padding is */
6301 /*  requested (that is, C may be B only if bshift==0).                */
6302 /*  C is filled from the lsu; only those units necessary to complete  */
6303 /*  the calculation are referenced.                                   */
6304 /*                                                                    */
6305 /*  Arg1 is A first Unit (lsu)                                        */
6306 /*  Arg2 is A length in Units                                         */
6307 /*  Arg3 is B first Unit (lsu)                                        */
6308 /*  Arg4 is B length in Units                                         */
6309 /*  Arg5 is B shift in Units  (>=0; pads with 0 units if positive)    */
6310 /*  Arg6 is C first Unit (lsu)                                        */
6311 /*  Arg7 is M, the multiplier                                         */
6312 /*                                                                    */
6313 /*  returns the count of Units written to C, which will be non-zero   */
6314 /*  and negated if the result is negative.  That is, the sign of the  */
6315 /*  returned Int is the sign of the result (positive for zero) and    */
6316 /*  the absolute value of the Int is the count of Units.              */
6317 /*                                                                    */
6318 /*  It is the caller's responsibility to make sure that C size is     */
6319 /*  safe, allowing space if necessary for a one-Unit carry.           */
6320 /*                                                                    */
6321 /*  This routine is severely performance-critical; *any* change here  */
6322 /*  must be measured (timed) to assure no performance degradation.    */
6323 /*  In particular, trickery here tends to be counter-productive, as   */
6324 /*  increased complexity of code hurts register optimizations on      */
6325 /*  register-poor architectures.  Avoiding divisions is nearly        */
6326 /*  always a Good Idea, however.                                      */
6327 /*                                                                    */
6328 /* Special thanks to Rick McGuire (IBM Cambridge, MA) and Dave Clark  */
6329 /* (IBM Warwick, UK) for some of the ideas used in this routine.      */
6330 /* ------------------------------------------------------------------ */
6331 static Int decUnitAddSub(const Unit *a, Int alength,
6332                          const Unit *b, Int blength, Int bshift,
6333                          Unit *c, Int m) {
6334   const Unit *alsu=a;              /* A lsu [need to remember it] */
6335   Unit *clsu=c;                    /* C ditto */
6336   Unit *minC;                      /* low water mark for C */
6337   Unit *maxC;                      /* high water mark for C */
6338   eInt carry=0;                    /* carry integer (could be Long) */
6339   Int  add;                        /* work */
6340   #if DECDPUN<=4                   /* myriadal, millenary, etc. */
6341   Int  est;                        /* estimated quotient */
6342   #endif
6343
6344   #if DECTRACE
6345   if (alength<1 || blength<1)
6346     printf("decUnitAddSub: alen blen m %ld %ld [%ld]\n", alength, blength, m);
6347   #endif
6348
6349   maxC=c+alength;                  /* A is usually the longer */
6350   minC=c+blength;                  /* .. and B the shorter */
6351   if (bshift!=0) {                 /* B is shifted; low As copy across */
6352     minC+=bshift;
6353     /* if in place [common], skip copy unless there's a gap [rare] */
6354     if (a==c && bshift<=alength) {
6355       c+=bshift;
6356       a+=bshift;
6357       }
6358      else for (; c<clsu+bshift; a++, c++) {  /* copy needed */
6359       if (a<alsu+alength) *c=*a;
6360        else *c=0;
6361       }
6362     }
6363   if (minC>maxC) { /* swap */
6364     Unit *hold=minC;
6365     minC=maxC;
6366     maxC=hold;
6367     }
6368
6369   /* For speed, do the addition as two loops; the first where both A */
6370   /* and B contribute, and the second (if necessary) where only one or */
6371   /* other of the numbers contribute. */
6372   /* Carry handling is the same (i.e., duplicated) in each case. */
6373   for (; c<minC; c++) {
6374     carry+=*a;
6375     a++;
6376     carry+=((eInt)*b)*m;                /* [special-casing m=1/-1 */
6377     b++;                                /* here is not a win] */
6378     /* here carry is new Unit of digits; it could be +ve or -ve */
6379     if ((ueInt)carry<=DECDPUNMAX) {     /* fastpath 0-DECDPUNMAX */
6380       *c=(Unit)carry;
6381       carry=0;
6382       continue;
6383       }
6384     #if DECDPUN==4                           /* use divide-by-multiply */
6385       if (carry>=0) {
6386         est=(((ueInt)carry>>11)*53687)>>18;
6387         *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6388         carry=est;                           /* likely quotient [89%] */
6389         if (*c<DECDPUNMAX+1) continue;       /* estimate was correct */
6390         carry++;
6391         *c-=DECDPUNMAX+1;
6392         continue;
6393         }
6394       /* negative case */
6395       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6396       est=(((ueInt)carry>>11)*53687)>>18;
6397       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6398       carry=est-(DECDPUNMAX+1);              /* correctly negative */
6399       if (*c<DECDPUNMAX+1) continue;         /* was OK */
6400       carry++;
6401       *c-=DECDPUNMAX+1;
6402     #elif DECDPUN==3
6403       if (carry>=0) {
6404         est=(((ueInt)carry>>3)*16777)>>21;
6405         *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6406         carry=est;                           /* likely quotient [99%] */
6407         if (*c<DECDPUNMAX+1) continue;       /* estimate was correct */
6408         carry++;
6409         *c-=DECDPUNMAX+1;
6410         continue;
6411         }
6412       /* negative case */
6413       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6414       est=(((ueInt)carry>>3)*16777)>>21;
6415       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6416       carry=est-(DECDPUNMAX+1);              /* correctly negative */
6417       if (*c<DECDPUNMAX+1) continue;         /* was OK */
6418       carry++;
6419       *c-=DECDPUNMAX+1;
6420     #elif DECDPUN<=2
6421       /* Can use QUOT10 as carry <= 4 digits */
6422       if (carry>=0) {
6423         est=QUOT10(carry, DECDPUN);
6424         *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6425         carry=est;                           /* quotient */
6426         continue;
6427         }
6428       /* negative case */
6429       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6430       est=QUOT10(carry, DECDPUN);
6431       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6432       carry=est-(DECDPUNMAX+1);              /* correctly negative */
6433     #else
6434       /* remainder operator is undefined if negative, so must test */
6435       if ((ueInt)carry<(DECDPUNMAX+1)*2) {   /* fastpath carry +1 */
6436         *c=(Unit)(carry-(DECDPUNMAX+1));     /* [helps additions] */
6437         carry=1;
6438         continue;
6439         }
6440       if (carry>=0) {
6441         *c=(Unit)(carry%(DECDPUNMAX+1));
6442         carry=carry/(DECDPUNMAX+1);
6443         continue;
6444         }
6445       /* negative case */
6446       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6447       *c=(Unit)(carry%(DECDPUNMAX+1));
6448       carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6449     #endif
6450     } /* c */
6451
6452   /* now may have one or other to complete */
6453   /* [pretest to avoid loop setup/shutdown] */
6454   if (c<maxC) for (; c<maxC; c++) {
6455     if (a<alsu+alength) {               /* still in A */
6456       carry+=*a;
6457       a++;
6458       }
6459      else {                             /* inside B */
6460       carry+=((eInt)*b)*m;
6461       b++;
6462       }
6463     /* here carry is new Unit of digits; it could be +ve or -ve and */
6464     /* magnitude up to DECDPUNMAX squared */
6465     if ((ueInt)carry<=DECDPUNMAX) {     /* fastpath 0-DECDPUNMAX */
6466       *c=(Unit)carry;
6467       carry=0;
6468       continue;
6469       }
6470     /* result for this unit is negative or >DECDPUNMAX */
6471     #if DECDPUN==4                           /* use divide-by-multiply */
6472       if (carry>=0) {
6473         est=(((ueInt)carry>>11)*53687)>>18;
6474         *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6475         carry=est;                           /* likely quotient [79.7%] */
6476         if (*c<DECDPUNMAX+1) continue;       /* estimate was correct */
6477         carry++;
6478         *c-=DECDPUNMAX+1;
6479         continue;
6480         }
6481       /* negative case */
6482       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6483       est=(((ueInt)carry>>11)*53687)>>18;
6484       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6485       carry=est-(DECDPUNMAX+1);              /* correctly negative */
6486       if (*c<DECDPUNMAX+1) continue;         /* was OK */
6487       carry++;
6488       *c-=DECDPUNMAX+1;
6489     #elif DECDPUN==3
6490       if (carry>=0) {
6491         est=(((ueInt)carry>>3)*16777)>>21;
6492         *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6493         carry=est;                           /* likely quotient [99%] */
6494         if (*c<DECDPUNMAX+1) continue;       /* estimate was correct */
6495         carry++;
6496         *c-=DECDPUNMAX+1;
6497         continue;
6498         }
6499       /* negative case */
6500       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6501       est=(((ueInt)carry>>3)*16777)>>21;
6502       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6503       carry=est-(DECDPUNMAX+1);              /* correctly negative */
6504       if (*c<DECDPUNMAX+1) continue;         /* was OK */
6505       carry++;
6506       *c-=DECDPUNMAX+1;
6507     #elif DECDPUN<=2
6508       if (carry>=0) {
6509         est=QUOT10(carry, DECDPUN);
6510         *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6511         carry=est;                           /* quotient */
6512         continue;
6513         }
6514       /* negative case */
6515       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6516       est=QUOT10(carry, DECDPUN);
6517       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6518       carry=est-(DECDPUNMAX+1);              /* correctly negative */
6519     #else
6520       if ((ueInt)carry<(DECDPUNMAX+1)*2){    /* fastpath carry 1 */
6521         *c=(Unit)(carry-(DECDPUNMAX+1));
6522         carry=1;
6523         continue;
6524         }
6525       /* remainder operator is undefined if negative, so must test */
6526       if (carry>=0) {
6527         *c=(Unit)(carry%(DECDPUNMAX+1));
6528         carry=carry/(DECDPUNMAX+1);
6529         continue;
6530         }
6531       /* negative case */
6532       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6533       *c=(Unit)(carry%(DECDPUNMAX+1));
6534       carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6535     #endif
6536     } /* c */
6537
6538   /* OK, all A and B processed; might still have carry or borrow */
6539   /* return number of Units in the result, negated if a borrow */
6540   if (carry==0) return c-clsu;     /* no carry, so no more to do */
6541   if (carry>0) {                   /* positive carry */
6542     *c=(Unit)carry;                /* place as new unit */
6543     c++;                           /* .. */
6544     return c-clsu;
6545     }
6546   /* -ve carry: it's a borrow; complement needed */
6547   add=1;                           /* temporary carry... */
6548   for (c=clsu; c<maxC; c++) {
6549     add=DECDPUNMAX+add-*c;
6550     if (add<=DECDPUNMAX) {
6551       *c=(Unit)add;
6552       add=0;
6553       }
6554      else {
6555       *c=0;
6556       add=1;
6557       }
6558     }
6559   /* add an extra unit iff it would be non-zero */
6560   #if DECTRACE
6561     printf("UAS borrow: add %ld, carry %ld\n", add, carry);
6562   #endif
6563   if ((add-carry-1)!=0) {
6564     *c=(Unit)(add-carry-1);
6565     c++;                      /* interesting, include it */
6566     }
6567   return clsu-c;              /* -ve result indicates borrowed */
6568   } /* decUnitAddSub */
6569
6570 /* ------------------------------------------------------------------ */
6571 /* decTrim -- trim trailing zeros or normalize                        */
6572 /*                                                                    */
6573 /*   dn is the number to trim or normalize                            */
6574 /*   set is the context to use to check for clamp                     */
6575 /*   all is 1 to remove all trailing zeros, 0 for just fraction ones  */
6576 /*   noclamp is 1 to unconditional (unclamped) trim                   */
6577 /*   dropped returns the number of discarded trailing zeros           */
6578 /*   returns dn                                                       */
6579 /*                                                                    */
6580 /* If clamp is set in the context then the number of zeros trimmed    */
6581 /* may be limited if the exponent is high.                            */
6582 /* All fields are updated as required.  This is a utility operation,  */
6583 /* so special values are unchanged and no error is possible.          */
6584 /* ------------------------------------------------------------------ */
6585 static decNumber * decTrim(decNumber *dn, decContext *set, Flag all,
6586                            Flag noclamp, Int *dropped) {
6587   Int   d, exp;                    /* work */
6588   uInt  cut;                       /* .. */
6589   Unit  *up;                       /* -> current Unit */
6590
6591   #if DECCHECK
6592   if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
6593   #endif
6594
6595   *dropped=0;                           /* assume no zeros dropped */
6596   if ((dn->bits & DECSPECIAL)           /* fast exit if special .. */
6597     || (*dn->lsu & 0x01)) return dn;    /* .. or odd */
6598   if (ISZERO(dn)) {                     /* .. or 0 */
6599     dn->exponent=0;                     /* (sign is preserved) */
6600     return dn;
6601     }
6602
6603   /* have a finite number which is even */
6604   exp=dn->exponent;
6605   cut=1;                           /* digit (1-DECDPUN) in Unit */
6606   up=dn->lsu;                      /* -> current Unit */
6607   for (d=0; d<dn->digits-1; d++) { /* [don't strip the final digit] */
6608     /* slice by powers */
6609     #if DECDPUN<=4
6610       uInt quot=QUOT10(*up, cut);
6611       if ((*up-quot*powers[cut])!=0) break;  /* found non-0 digit */
6612     #else
6613       if (*up%powers[cut]!=0) break;         /* found non-0 digit */
6614     #endif
6615     /* have a trailing 0 */
6616     if (!all) {                    /* trimming */
6617       /* [if exp>0 then all trailing 0s are significant for trim] */
6618       if (exp<=0) {                /* if digit might be significant */
6619         if (exp==0) break;         /* then quit */
6620         exp++;                     /* next digit might be significant */
6621         }
6622       }
6623     cut++;                         /* next power */
6624     if (cut>DECDPUN) {             /* need new Unit */
6625       up++;
6626       cut=1;
6627       }
6628     } /* d */
6629   if (d==0) return dn;             /* none to drop */
6630
6631   /* may need to limit drop if clamping */
6632   if (set->clamp && !noclamp) {
6633     Int maxd=set->emax-set->digits+1-dn->exponent;
6634     if (maxd<=0) return dn;        /* nothing possible */
6635     if (d>maxd) d=maxd;
6636     }
6637
6638   /* effect the drop */
6639   decShiftToLeast(dn->lsu, D2U(dn->digits), d);
6640   dn->exponent+=d;                 /* maintain numerical value */
6641   dn->digits-=d;                   /* new length */
6642   *dropped=d;                      /* report the count */
6643   return dn;
6644   } /* decTrim */
6645
6646 /* ------------------------------------------------------------------ */
6647 /* decReverse -- reverse a Unit array in place                        */
6648 /*                                                                    */
6649 /*   ulo    is the start of the array                                 */
6650 /*   uhi    is the end of the array (highest Unit to include)         */
6651 /*                                                                    */
6652 /* The units ulo through uhi are reversed in place (if the number     */
6653 /* of units is odd, the middle one is untouched).  Note that the      */
6654 /* digit(s) in each unit are unaffected.                              */
6655 /* ------------------------------------------------------------------ */
6656 static void decReverse(Unit *ulo, Unit *uhi) {
6657   Unit temp;
6658   for (; ulo<uhi; ulo++, uhi--) {
6659     temp=*ulo;
6660     *ulo=*uhi;
6661     *uhi=temp;
6662     }
6663   return;
6664   } /* decReverse */
6665
6666 /* ------------------------------------------------------------------ */
6667 /* decShiftToMost -- shift digits in array towards most significant   */
6668 /*                                                                    */
6669 /*   uar    is the array                                              */
6670 /*   digits is the count of digits in use in the array                */
6671 /*   shift  is the number of zeros to pad with (least significant);   */
6672 /*     it must be zero or positive                                    */
6673 /*                                                                    */
6674 /*   returns the new length of the integer in the array, in digits    */
6675 /*                                                                    */
6676 /* No overflow is permitted (that is, the uar array must be known to  */
6677 /* be large enough to hold the result, after shifting).               */
6678 /* ------------------------------------------------------------------ */
6679 static Int decShiftToMost(Unit *uar, Int digits, Int shift) {
6680   Unit  *target, *source, *first;  /* work */
6681   Int   cut;                       /* odd 0's to add */
6682   uInt  next;                      /* work */
6683
6684   if (shift==0) return digits;     /* [fastpath] nothing to do */
6685   if ((digits+shift)<=DECDPUN) {   /* [fastpath] single-unit case */
6686     *uar=(Unit)(*uar*powers[shift]);
6687     return digits+shift;
6688     }
6689
6690   next=0;                          /* all paths */
6691   source=uar+D2U(digits)-1;        /* where msu comes from */
6692   target=source+D2U(shift);        /* where upper part of first cut goes */
6693   cut=DECDPUN-MSUDIGITS(shift);    /* where to slice */
6694   if (cut==0) {                    /* unit-boundary case */
6695     for (; source>=uar; source--, target--) *target=*source;
6696     }
6697    else {
6698     first=uar+D2U(digits+shift)-1; /* where msu of source will end up */
6699     for (; source>=uar; source--, target--) {
6700       /* split the source Unit and accumulate remainder for next */
6701       #if DECDPUN<=4
6702         uInt quot=QUOT10(*source, cut);
6703         uInt rem=*source-quot*powers[cut];
6704         next+=quot;
6705       #else
6706         uInt rem=*source%powers[cut];
6707         next+=*source/powers[cut];
6708       #endif
6709       if (target<=first) *target=(Unit)next;   /* write to target iff valid */
6710       next=rem*powers[DECDPUN-cut];            /* save remainder for next Unit */
6711       }
6712     } /* shift-move */
6713
6714   /* propagate any partial unit to one below and clear the rest */
6715   for (; target>=uar; target--) {
6716     *target=(Unit)next;
6717     next=0;
6718     }
6719   return digits+shift;
6720   } /* decShiftToMost */
6721
6722 /* ------------------------------------------------------------------ */
6723 /* decShiftToLeast -- shift digits in array towards least significant */
6724 /*                                                                    */
6725 /*   uar   is the array                                               */
6726 /*   units is length of the array, in units                           */
6727 /*   shift is the number of digits to remove from the lsu end; it     */
6728 /*     must be zero or positive and <= than units*DECDPUN.            */
6729 /*                                                                    */
6730 /*   returns the new length of the integer in the array, in units     */
6731 /*                                                                    */
6732 /* Removed digits are discarded (lost).  Units not required to hold   */
6733 /* the final result are unchanged.                                    */
6734 /* ------------------------------------------------------------------ */
6735 static Int decShiftToLeast(Unit *uar, Int units, Int shift) {
6736   Unit  *target, *up;              /* work */
6737   Int   cut, count;                /* work */
6738   Int   quot, rem;                 /* for division */
6739
6740   if (shift==0) return units;      /* [fastpath] nothing to do */
6741   if (shift==units*DECDPUN) {      /* [fastpath] little to do */
6742     *uar=0;                        /* all digits cleared gives zero */
6743     return 1;                      /* leaves just the one */
6744     }
6745
6746   target=uar;                      /* both paths */
6747   cut=MSUDIGITS(shift);
6748   if (cut==DECDPUN) {              /* unit-boundary case; easy */
6749     up=uar+D2U(shift);
6750     for (; up<uar+units; target++, up++) *target=*up;
6751     return target-uar;
6752     }
6753
6754   /* messier */
6755   up=uar+D2U(shift-cut);           /* source; correct to whole Units */
6756   count=units*DECDPUN-shift;       /* the maximum new length */
6757   #if DECDPUN<=4
6758     quot=QUOT10(*up, cut);
6759   #else
6760     quot=*up/powers[cut];
6761   #endif
6762   for (; ; target++) {
6763     *target=(Unit)quot;
6764     count-=(DECDPUN-cut);
6765     if (count<=0) break;
6766     up++;
6767     quot=*up;
6768     #if DECDPUN<=4
6769       quot=QUOT10(quot, cut);
6770       rem=*up-quot*powers[cut];
6771     #else
6772       rem=quot%powers[cut];
6773       quot=quot/powers[cut];
6774     #endif
6775     *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
6776     count-=cut;
6777     if (count<=0) break;
6778     }
6779   return target-uar+1;
6780   } /* decShiftToLeast */
6781
6782 #if DECSUBSET
6783 /* ------------------------------------------------------------------ */
6784 /* decRoundOperand -- round an operand  [used for subset only]        */
6785 /*                                                                    */
6786 /*   dn is the number to round (dn->digits is > set->digits)          */
6787 /*   set is the relevant context                                      */
6788 /*   status is the status accumulator                                 */
6789 /*                                                                    */
6790 /*   returns an allocated decNumber with the rounded result.          */
6791 /*                                                                    */
6792 /* lostDigits and other status may be set by this.                    */
6793 /*                                                                    */
6794 /* Since the input is an operand, it must not be modified.            */
6795 /* Instead, return an allocated decNumber, rounded as required.       */
6796 /* It is the caller's responsibility to free the allocated storage.   */
6797 /*                                                                    */
6798 /* If no storage is available then the result cannot be used, so NULL */
6799 /* is returned.                                                       */
6800 /* ------------------------------------------------------------------ */
6801 static decNumber *decRoundOperand(const decNumber *dn, decContext *set,
6802                                   uInt *status) {
6803   decNumber *res;                       /* result structure */
6804   uInt newstatus=0;                     /* status from round */
6805   Int  residue=0;                       /* rounding accumulator */
6806
6807   /* Allocate storage for the returned decNumber, big enough for the */
6808   /* length specified by the context */
6809   res=(decNumber *)malloc(sizeof(decNumber)
6810                           +(D2U(set->digits)-1)*sizeof(Unit));
6811   if (res==NULL) {
6812     *status|=DEC_Insufficient_storage;
6813     return NULL;
6814     }
6815   decCopyFit(res, dn, set, &residue, &newstatus);
6816   decApplyRound(res, set, residue, &newstatus);
6817
6818   /* If that set Inexact then "lost digits" is raised... */
6819   if (newstatus & DEC_Inexact) newstatus|=DEC_Lost_digits;
6820   *status|=newstatus;
6821   return res;
6822   } /* decRoundOperand */
6823 #endif
6824
6825 /* ------------------------------------------------------------------ */
6826 /* decCopyFit -- copy a number, truncating the coefficient if needed  */
6827 /*                                                                    */
6828 /*   dest is the target decNumber                                     */
6829 /*   src  is the source decNumber                                     */
6830 /*   set is the context [used for length (digits) and rounding mode]  */
6831 /*   residue is the residue accumulator                               */
6832 /*   status contains the current status to be updated                 */
6833 /*                                                                    */
6834 /* (dest==src is allowed and will be a no-op if fits)                 */
6835 /* All fields are updated as required.                                */
6836 /* ------------------------------------------------------------------ */
6837 static void decCopyFit(decNumber *dest, const decNumber *src,
6838                        decContext *set, Int *residue, uInt *status) {
6839   dest->bits=src->bits;
6840   dest->exponent=src->exponent;
6841   decSetCoeff(dest, set, src->lsu, src->digits, residue, status);
6842   } /* decCopyFit */
6843
6844 /* ------------------------------------------------------------------ */
6845 /* decSetCoeff -- set the coefficient of a number                     */
6846 /*                                                                    */
6847 /*   dn    is the number whose coefficient array is to be set.        */
6848 /*         It must have space for set->digits digits                  */
6849 /*   set   is the context [for size]                                  */
6850 /*   lsu   -> lsu of the source coefficient [may be dn->lsu]          */
6851 /*   len   is digits in the source coefficient [may be dn->digits]    */
6852 /*   residue is the residue accumulator.  This has values as in       */
6853 /*         decApplyRound, and will be unchanged unless the            */
6854 /*         target size is less than len.  In this case, the           */
6855 /*         coefficient is truncated and the residue is updated to     */
6856 /*         reflect the previous residue and the dropped digits.       */
6857 /*   status is the status accumulator, as usual                       */
6858 /*                                                                    */
6859 /* The coefficient may already be in the number, or it can be an      */
6860 /* external intermediate array.  If it is in the number, lsu must ==  */
6861 /* dn->lsu and len must == dn->digits.                                */
6862 /*                                                                    */
6863 /* Note that the coefficient length (len) may be < set->digits, and   */
6864 /* in this case this merely copies the coefficient (or is a no-op     */
6865 /* if dn->lsu==lsu).                                                  */
6866 /*                                                                    */
6867 /* Note also that (only internally, from decQuantizeOp and            */
6868 /* decSetSubnormal) the value of set->digits may be less than one,    */
6869 /* indicating a round to left.  This routine handles that case        */
6870 /* correctly; caller ensures space.                                   */
6871 /*                                                                    */
6872 /* dn->digits, dn->lsu (and as required), and dn->exponent are        */
6873 /* updated as necessary.   dn->bits (sign) is unchanged.              */
6874 /*                                                                    */
6875 /* DEC_Rounded status is set if any digits are discarded.             */
6876 /* DEC_Inexact status is set if any non-zero digits are discarded, or */
6877 /*                       incoming residue was non-0 (implies rounded) */
6878 /* ------------------------------------------------------------------ */
6879 /* mapping array: maps 0-9 to canonical residues, so that a residue */
6880 /* can be adjusted in the range [-1, +1] and achieve correct rounding */
6881 /*                             0  1  2  3  4  5  6  7  8  9 */
6882 static const uByte resmap[10]={0, 3, 3, 3, 3, 5, 7, 7, 7, 7};
6883 static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu,
6884                         Int len, Int *residue, uInt *status) {
6885   Int   discard;              /* number of digits to discard */
6886   uInt  cut;                  /* cut point in Unit */
6887   const Unit *up;             /* work */
6888   Unit  *target;              /* .. */
6889   Int   count;                /* .. */
6890   #if DECDPUN<=4
6891   uInt  temp;                 /* .. */
6892   #endif
6893
6894   discard=len-set->digits;    /* digits to discard */
6895   if (discard<=0) {           /* no digits are being discarded */
6896     if (dn->lsu!=lsu) {       /* copy needed */
6897       /* copy the coefficient array to the result number; no shift needed */
6898       count=len;              /* avoids D2U */
6899       up=lsu;
6900       for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
6901         *target=*up;
6902       dn->digits=len;         /* set the new length */
6903       }
6904     /* dn->exponent and residue are unchanged, record any inexactitude */
6905     if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded);
6906     return;
6907     }
6908
6909   /* some digits must be discarded ... */
6910   dn->exponent+=discard;      /* maintain numerical value */
6911   *status|=DEC_Rounded;       /* accumulate Rounded status */
6912   if (*residue>1) *residue=1; /* previous residue now to right, so reduce */
6913
6914   if (discard>len) {          /* everything, +1, is being discarded */
6915     /* guard digit is 0 */
6916     /* residue is all the number [NB could be all 0s] */
6917     if (*residue<=0) {        /* not already positive */
6918       count=len;              /* avoids D2U */
6919       for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { /* found non-0 */
6920         *residue=1;
6921         break;                /* no need to check any others */
6922         }
6923       }
6924     if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
6925     *dn->lsu=0;               /* coefficient will now be 0 */
6926     dn->digits=1;             /* .. */
6927     return;
6928     } /* total discard */
6929
6930   /* partial discard [most common case] */
6931   /* here, at least the first (most significant) discarded digit exists */
6932
6933   /* spin up the number, noting residue during the spin, until get to */
6934   /* the Unit with the first discarded digit.  When reach it, extract */
6935   /* it and remember its position */
6936   count=0;
6937   for (up=lsu;; up++) {
6938     count+=DECDPUN;
6939     if (count>=discard) break; /* full ones all checked */
6940     if (*up!=0) *residue=1;
6941     } /* up */
6942
6943   /* here up -> Unit with first discarded digit */
6944   cut=discard-(count-DECDPUN)-1;
6945   if (cut==DECDPUN-1) {       /* unit-boundary case (fast) */
6946     Unit half=(Unit)powers[DECDPUN]>>1;
6947     /* set residue directly */
6948     if (*up>=half) {
6949       if (*up>half) *residue=7;
6950       else *residue+=5;       /* add sticky bit */
6951       }
6952      else { /* <half */
6953       if (*up!=0) *residue=3; /* [else is 0, leave as sticky bit] */
6954       }
6955     if (set->digits<=0) {     /* special for Quantize/Subnormal :-( */
6956       *dn->lsu=0;             /* .. result is 0 */
6957       dn->digits=1;           /* .. */
6958       }
6959      else {                   /* shift to least */
6960       count=set->digits;      /* now digits to end up with */
6961       dn->digits=count;       /* set the new length */
6962       up++;                   /* move to next */
6963       /* on unit boundary, so shift-down copy loop is simple */
6964       for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
6965         *target=*up;
6966       }
6967     } /* unit-boundary case */
6968
6969    else { /* discard digit is in low digit(s), and not top digit */
6970     uInt  discard1;                /* first discarded digit */
6971     uInt  quot, rem;               /* for divisions */
6972     if (cut==0) quot=*up;          /* is at bottom of unit */
6973      else /* cut>0 */ {            /* it's not at bottom of unit */
6974       #if DECDPUN<=4
6975         quot=QUOT10(*up, cut);
6976         rem=*up-quot*powers[cut];
6977       #else
6978         rem=*up%powers[cut];
6979         quot=*up/powers[cut];
6980       #endif
6981       if (rem!=0) *residue=1;
6982       }
6983     /* discard digit is now at bottom of quot */
6984     #if DECDPUN<=4
6985       temp=(quot*6554)>>16;        /* fast /10 */
6986       /* Vowels algorithm here not a win (9 instructions) */
6987       discard1=quot-X10(temp);
6988       quot=temp;
6989     #else
6990       discard1=quot%10;
6991       quot=quot/10;
6992     #endif
6993     /* here, discard1 is the guard digit, and residue is everything */
6994     /* else [use mapping array to accumulate residue safely] */
6995     *residue+=resmap[discard1];
6996     cut++;                         /* update cut */
6997     /* here: up -> Unit of the array with bottom digit */
6998     /*       cut is the division point for each Unit */
6999     /*       quot holds the uncut high-order digits for the current unit */
7000     if (set->digits<=0) {          /* special for Quantize/Subnormal :-( */
7001       *dn->lsu=0;                  /* .. result is 0 */
7002       dn->digits=1;                /* .. */
7003       }
7004      else {                        /* shift to least needed */
7005       count=set->digits;           /* now digits to end up with */
7006       dn->digits=count;            /* set the new length */
7007       /* shift-copy the coefficient array to the result number */
7008       for (target=dn->lsu; ; target++) {
7009         *target=(Unit)quot;
7010         count-=(DECDPUN-cut);
7011         if (count<=0) break;
7012         up++;
7013         quot=*up;
7014         #if DECDPUN<=4
7015           quot=QUOT10(quot, cut);
7016           rem=*up-quot*powers[cut];
7017         #else
7018           rem=quot%powers[cut];
7019           quot=quot/powers[cut];
7020         #endif
7021         *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
7022         count-=cut;
7023         if (count<=0) break;
7024         } /* shift-copy loop */
7025       } /* shift to least */
7026     } /* not unit boundary */
7027
7028   if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
7029   return;
7030   } /* decSetCoeff */
7031
7032 /* ------------------------------------------------------------------ */
7033 /* decApplyRound -- apply pending rounding to a number                */
7034 /*                                                                    */
7035 /*   dn    is the number, with space for set->digits digits           */
7036 /*   set   is the context [for size and rounding mode]                */
7037 /*   residue indicates pending rounding, being any accumulated        */
7038 /*         guard and sticky information.  It may be:                  */
7039 /*         6-9: rounding digit is >5                                  */
7040 /*         5:   rounding digit is exactly half-way                    */
7041 /*         1-4: rounding digit is <5 and >0                           */
7042 /*         0:   the coefficient is exact                              */
7043 /*        -1:   as 1, but the hidden digits are subtractive, that     */
7044 /*              is, of the opposite sign to dn.  In this case the     */
7045 /*              coefficient must be non-0.  This case occurs when     */
7046 /*              subtracting a small number (which can be reduced to   */
7047 /*              a sticky bit); see decAddOp.                          */
7048 /*   status is the status accumulator, as usual                       */
7049 /*                                                                    */
7050 /* This routine applies rounding while keeping the length of the      */
7051 /* coefficient constant.  The exponent and status are unchanged       */
7052 /* except if:                                                         */
7053 /*                                                                    */
7054 /*   -- the coefficient was increased and is all nines (in which      */
7055 /*      case Overflow could occur, and is handled directly here so    */
7056 /*      the caller does not need to re-test for overflow)             */
7057 /*                                                                    */
7058 /*   -- the coefficient was decreased and becomes all nines (in which */
7059 /*      case Underflow could occur, and is also handled directly).    */
7060 /*                                                                    */
7061 /* All fields in dn are updated as required.                          */
7062 /*                                                                    */
7063 /* ------------------------------------------------------------------ */
7064 static void decApplyRound(decNumber *dn, decContext *set, Int residue,
7065                           uInt *status) {
7066   Int  bump;                  /* 1 if coefficient needs to be incremented */
7067                               /* -1 if coefficient needs to be decremented */
7068
7069   if (residue==0) return;     /* nothing to apply */
7070
7071   bump=0;                     /* assume a smooth ride */
7072
7073   /* now decide whether, and how, to round, depending on mode */
7074   switch (set->round) {
7075     case DEC_ROUND_05UP: {    /* round zero or five up (for reround) */
7076       /* This is the same as DEC_ROUND_DOWN unless there is a */
7077       /* positive residue and the lsd of dn is 0 or 5, in which case */
7078       /* it is bumped; when residue is <0, the number is therefore */
7079       /* bumped down unless the final digit was 1 or 6 (in which */
7080       /* case it is bumped down and then up -- a no-op) */
7081       Int lsd5=*dn->lsu%5;     /* get lsd and quintate */
7082       if (residue<0 && lsd5!=1) bump=-1;
7083        else if (residue>0 && lsd5==0) bump=1;
7084       /* [bump==1 could be applied directly; use common path for clarity] */
7085       break;} /* r-05 */
7086
7087     case DEC_ROUND_DOWN: {
7088       /* no change, except if negative residue */
7089       if (residue<0) bump=-1;
7090       break;} /* r-d */
7091
7092     case DEC_ROUND_HALF_DOWN: {
7093       if (residue>5) bump=1;
7094       break;} /* r-h-d */
7095
7096     case DEC_ROUND_HALF_EVEN: {
7097       if (residue>5) bump=1;            /* >0.5 goes up */
7098        else if (residue==5) {           /* exactly 0.5000... */
7099         /* 0.5 goes up iff [new] lsd is odd */
7100         if (*dn->lsu & 0x01) bump=1;
7101         }
7102       break;} /* r-h-e */
7103
7104     case DEC_ROUND_HALF_UP: {
7105       if (residue>=5) bump=1;
7106       break;} /* r-h-u */
7107
7108     case DEC_ROUND_UP: {
7109       if (residue>0) bump=1;
7110       break;} /* r-u */
7111
7112     case DEC_ROUND_CEILING: {
7113       /* same as _UP for positive numbers, and as _DOWN for negatives */
7114       /* [negative residue cannot occur on 0] */
7115       if (decNumberIsNegative(dn)) {
7116         if (residue<0) bump=-1;
7117         }
7118        else {
7119         if (residue>0) bump=1;
7120         }
7121       break;} /* r-c */
7122
7123     case DEC_ROUND_FLOOR: {
7124       /* same as _UP for negative numbers, and as _DOWN for positive */
7125       /* [negative residue cannot occur on 0] */
7126       if (!decNumberIsNegative(dn)) {
7127         if (residue<0) bump=-1;
7128         }
7129        else {
7130         if (residue>0) bump=1;
7131         }
7132       break;} /* r-f */
7133
7134     default: {      /* e.g., DEC_ROUND_MAX */
7135       *status|=DEC_Invalid_context;
7136       #if DECTRACE || (DECCHECK && DECVERB)
7137       printf("Unknown rounding mode: %d\n", set->round);
7138       #endif
7139       break;}
7140     } /* switch */
7141
7142   /* now bump the number, up or down, if need be */
7143   if (bump==0) return;                       /* no action required */
7144
7145   /* Simply use decUnitAddSub unless bumping up and the number is */
7146   /* all nines.  In this special case set to 100... explicitly */
7147   /* and adjust the exponent by one (as otherwise could overflow */
7148   /* the array) */
7149   /* Similarly handle all-nines result if bumping down. */
7150   if (bump>0) {
7151     Unit *up;                                /* work */
7152     uInt count=dn->digits;                   /* digits to be checked */
7153     for (up=dn->lsu; ; up++) {
7154       if (count<=DECDPUN) {
7155         /* this is the last Unit (the msu) */
7156         if (*up!=powers[count]-1) break;     /* not still 9s */
7157         /* here if it, too, is all nines */
7158         *up=(Unit)powers[count-1];           /* here 999 -> 100 etc. */
7159         for (up=up-1; up>=dn->lsu; up--) *up=0; /* others all to 0 */
7160         dn->exponent++;                      /* and bump exponent */
7161         /* [which, very rarely, could cause Overflow...] */
7162         if ((dn->exponent+dn->digits)>set->emax+1) {
7163           decSetOverflow(dn, set, status);
7164           }
7165         return;                              /* done */
7166         }
7167       /* a full unit to check, with more to come */
7168       if (*up!=DECDPUNMAX) break;            /* not still 9s */
7169       count-=DECDPUN;
7170       } /* up */
7171     } /* bump>0 */
7172    else {                                    /* -1 */
7173     /* here checking for a pre-bump of 1000... (leading 1, all */
7174     /* other digits zero) */
7175     Unit *up, *sup;                          /* work */
7176     uInt count=dn->digits;                   /* digits to be checked */
7177     for (up=dn->lsu; ; up++) {
7178       if (count<=DECDPUN) {
7179         /* this is the last Unit (the msu) */
7180         if (*up!=powers[count-1]) break;     /* not 100.. */
7181         /* here if have the 1000... case */
7182         sup=up;                              /* save msu pointer */
7183         *up=(Unit)powers[count]-1;           /* here 100 in msu -> 999 */
7184         /* others all to all-nines, too */
7185         for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1;
7186         dn->exponent--;                      /* and bump exponent */
7187
7188         /* iff the number was at the subnormal boundary (exponent=etiny) */
7189         /* then the exponent is now out of range, so it will in fact get */
7190         /* clamped to etiny and the final 9 dropped. */
7191         /* printf(">> emin=%d exp=%d sdig=%d\n", set->emin, */
7192         /*        dn->exponent, set->digits); */
7193         if (dn->exponent+1==set->emin-set->digits+1) {
7194           if (count==1 && dn->digits==1) *sup=0;  /* here 9 -> 0[.9] */
7195            else {
7196             *sup=(Unit)powers[count-1]-1;    /* here 999.. in msu -> 99.. */
7197             dn->digits--;
7198             }
7199           dn->exponent++;
7200           *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7201           }
7202         return;                              /* done */
7203         }
7204
7205       /* a full unit to check, with more to come */
7206       if (*up!=0) break;                     /* not still 0s */
7207       count-=DECDPUN;
7208       } /* up */
7209
7210     } /* bump<0 */
7211
7212   /* Actual bump needed.  Do it. */
7213   decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump);
7214   } /* decApplyRound */
7215
7216 #if DECSUBSET
7217 /* ------------------------------------------------------------------ */
7218 /* decFinish -- finish processing a number                            */
7219 /*                                                                    */
7220 /*   dn is the number                                                 */
7221 /*   set is the context                                               */
7222 /*   residue is the rounding accumulator (as in decApplyRound)        */
7223 /*   status is the accumulator                                        */
7224 /*                                                                    */
7225 /* This finishes off the current number by:                           */
7226 /*    1. If not extended:                                             */
7227 /*       a. Converting a zero result to clean '0'                     */
7228 /*       b. Reducing positive exponents to 0, if would fit in digits  */
7229 /*    2. Checking for overflow and subnormals (always)                */
7230 /* Note this is just Finalize when no subset arithmetic.              */
7231 /* All fields are updated as required.                                */
7232 /* ------------------------------------------------------------------ */
7233 static void decFinish(decNumber *dn, decContext *set, Int *residue,
7234                       uInt *status) {
7235   if (!set->extended) {
7236     if ISZERO(dn) {                /* value is zero */
7237       dn->exponent=0;              /* clean exponent .. */
7238       dn->bits=0;                  /* .. and sign */
7239       return;                      /* no error possible */
7240       }
7241     if (dn->exponent>=0) {         /* non-negative exponent */
7242       /* >0; reduce to integer if possible */
7243       if (set->digits >= (dn->exponent+dn->digits)) {
7244         dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent);
7245         dn->exponent=0;
7246         }
7247       }
7248     } /* !extended */
7249
7250   decFinalize(dn, set, residue, status);
7251   } /* decFinish */
7252 #endif
7253
7254 /* ------------------------------------------------------------------ */
7255 /* decFinalize -- final check, clamp, and round of a number           */
7256 /*                                                                    */
7257 /*   dn is the number                                                 */
7258 /*   set is the context                                               */
7259 /*   residue is the rounding accumulator (as in decApplyRound)        */
7260 /*   status is the status accumulator                                 */
7261 /*                                                                    */
7262 /* This finishes off the current number by checking for subnormal     */
7263 /* results, applying any pending rounding, checking for overflow,     */
7264 /* and applying any clamping.                                         */
7265 /* Underflow and overflow conditions are raised as appropriate.       */
7266 /* All fields are updated as required.                                */
7267 /* ------------------------------------------------------------------ */
7268 static void decFinalize(decNumber *dn, decContext *set, Int *residue,
7269                         uInt *status) {
7270   Int shift;                            /* shift needed if clamping */
7271   Int tinyexp=set->emin-dn->digits+1;   /* precalculate subnormal boundary */
7272
7273   /* Must be careful, here, when checking the exponent as the */
7274   /* adjusted exponent could overflow 31 bits [because it may already */
7275   /* be up to twice the expected]. */
7276
7277   /* First test for subnormal.  This must be done before any final */
7278   /* round as the result could be rounded to Nmin or 0. */
7279   if (dn->exponent<=tinyexp) {          /* prefilter */
7280     Int comp;
7281     decNumber nmin;
7282     /* A very nasty case here is dn == Nmin and residue<0 */
7283     if (dn->exponent<tinyexp) {
7284       /* Go handle subnormals; this will apply round if needed. */
7285       decSetSubnormal(dn, set, residue, status);
7286       return;
7287       }
7288     /* Equals case: only subnormal if dn=Nmin and negative residue */
7289     decNumberZero(&nmin);
7290     nmin.lsu[0]=1;
7291     nmin.exponent=set->emin;
7292     comp=decCompare(dn, &nmin, 1);                /* (signless compare) */
7293     if (comp==BADINT) {                           /* oops */
7294       *status|=DEC_Insufficient_storage;          /* abandon... */
7295       return;
7296       }
7297     if (*residue<0 && comp==0) {                  /* neg residue and dn==Nmin */
7298       decApplyRound(dn, set, *residue, status);   /* might force down */
7299       decSetSubnormal(dn, set, residue, status);
7300       return;
7301       }
7302     }
7303
7304   /* now apply any pending round (this could raise overflow). */
7305   if (*residue!=0) decApplyRound(dn, set, *residue, status);
7306
7307   /* Check for overflow [redundant in the 'rare' case] or clamp */
7308   if (dn->exponent<=set->emax-set->digits+1) return;   /* neither needed */
7309
7310
7311   /* here when might have an overflow or clamp to do */
7312   if (dn->exponent>set->emax-dn->digits+1) {           /* too big */
7313     decSetOverflow(dn, set, status);
7314     return;
7315     }
7316   /* here when the result is normal but in clamp range */
7317   if (!set->clamp) return;
7318
7319   /* here when need to apply the IEEE exponent clamp (fold-down) */
7320   shift=dn->exponent-(set->emax-set->digits+1);
7321
7322   /* shift coefficient (if non-zero) */
7323   if (!ISZERO(dn)) {
7324     dn->digits=decShiftToMost(dn->lsu, dn->digits, shift);
7325     }
7326   dn->exponent-=shift;   /* adjust the exponent to match */
7327   *status|=DEC_Clamped;  /* and record the dirty deed */
7328   return;
7329   } /* decFinalize */
7330
7331 /* ------------------------------------------------------------------ */
7332 /* decSetOverflow -- set number to proper overflow value              */
7333 /*                                                                    */
7334 /*   dn is the number (used for sign [only] and result)               */
7335 /*   set is the context [used for the rounding mode, etc.]            */
7336 /*   status contains the current status to be updated                 */
7337 /*                                                                    */
7338 /* This sets the sign of a number and sets its value to either        */
7339 /* Infinity or the maximum finite value, depending on the sign of     */
7340 /* dn and the rounding mode, following IEEE 754 rules.                */
7341 /* ------------------------------------------------------------------ */
7342 static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) {
7343   Flag needmax=0;                  /* result is maximum finite value */
7344   uByte sign=dn->bits&DECNEG;      /* clean and save sign bit */
7345
7346   if (ISZERO(dn)) {                /* zero does not overflow magnitude */
7347     Int emax=set->emax;                      /* limit value */
7348     if (set->clamp) emax-=set->digits-1;     /* lower if clamping */
7349     if (dn->exponent>emax) {                 /* clamp required */
7350       dn->exponent=emax;
7351       *status|=DEC_Clamped;
7352       }
7353     return;
7354     }
7355
7356   decNumberZero(dn);
7357   switch (set->round) {
7358     case DEC_ROUND_DOWN: {
7359       needmax=1;                   /* never Infinity */
7360       break;} /* r-d */
7361     case DEC_ROUND_05UP: {
7362       needmax=1;                   /* never Infinity */
7363       break;} /* r-05 */
7364     case DEC_ROUND_CEILING: {
7365       if (sign) needmax=1;         /* Infinity if non-negative */
7366       break;} /* r-c */
7367     case DEC_ROUND_FLOOR: {
7368       if (!sign) needmax=1;        /* Infinity if negative */
7369       break;} /* r-f */
7370     default: break;                /* Infinity in all other cases */
7371     }
7372   if (needmax) {
7373     decSetMaxValue(dn, set);
7374     dn->bits=sign;                 /* set sign */
7375     }
7376    else dn->bits=sign|DECINF;      /* Value is +/-Infinity */
7377   *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded;
7378   } /* decSetOverflow */
7379
7380 /* ------------------------------------------------------------------ */
7381 /* decSetMaxValue -- set number to +Nmax (maximum normal value)       */
7382 /*                                                                    */
7383 /*   dn is the number to set                                          */
7384 /*   set is the context [used for digits and emax]                    */
7385 /*                                                                    */
7386 /* This sets the number to the maximum positive value.                */
7387 /* ------------------------------------------------------------------ */
7388 static void decSetMaxValue(decNumber *dn, decContext *set) {
7389   Unit *up;                        /* work */
7390   Int count=set->digits;           /* nines to add */
7391   dn->digits=count;
7392   /* fill in all nines to set maximum value */
7393   for (up=dn->lsu; ; up++) {
7394     if (count>DECDPUN) *up=DECDPUNMAX;  /* unit full o'nines */
7395      else {                             /* this is the msu */
7396       *up=(Unit)(powers[count]-1);
7397       break;
7398       }
7399     count-=DECDPUN;                /* filled those digits */
7400     } /* up */
7401   dn->bits=0;                      /* + sign */
7402   dn->exponent=set->emax-set->digits+1;
7403   } /* decSetMaxValue */
7404
7405 /* ------------------------------------------------------------------ */
7406 /* decSetSubnormal -- process value whose exponent is <Emin           */
7407 /*                                                                    */
7408 /*   dn is the number (used as input as well as output; it may have   */
7409 /*         an allowed subnormal value, which may need to be rounded)  */
7410 /*   set is the context [used for the rounding mode]                  */
7411 /*   residue is any pending residue                                   */
7412 /*   status contains the current status to be updated                 */
7413 /*                                                                    */
7414 /* If subset mode, set result to zero and set Underflow flags.        */
7415 /*                                                                    */
7416 /* Value may be zero with a low exponent; this does not set Subnormal */
7417 /* but the exponent will be clamped to Etiny.                         */
7418 /*                                                                    */
7419 /* Otherwise ensure exponent is not out of range, and round as        */
7420 /* necessary.  Underflow is set if the result is Inexact.             */
7421 /* ------------------------------------------------------------------ */
7422 static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue,
7423                             uInt *status) {
7424   decContext workset;         /* work */
7425   Int        etiny, adjust;   /* .. */
7426
7427   #if DECSUBSET
7428   /* simple set to zero and 'hard underflow' for subset */
7429   if (!set->extended) {
7430     decNumberZero(dn);
7431     /* always full overflow */
7432     *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7433     return;
7434     }
7435   #endif
7436
7437   /* Full arithmetic -- allow subnormals, rounded to minimum exponent */
7438   /* (Etiny) if needed */
7439   etiny=set->emin-(set->digits-1);      /* smallest allowed exponent */
7440
7441   if ISZERO(dn) {                       /* value is zero */
7442     /* residue can never be non-zero here */
7443     #if DECCHECK
7444       if (*residue!=0) {
7445         printf("++ Subnormal 0 residue %ld\n", (LI)*residue);
7446         *status|=DEC_Invalid_operation;
7447         }
7448     #endif
7449     if (dn->exponent<etiny) {           /* clamp required */
7450       dn->exponent=etiny;
7451       *status|=DEC_Clamped;
7452       }
7453     return;
7454     }
7455
7456   *status|=DEC_Subnormal;               /* have a non-zero subnormal */
7457   adjust=etiny-dn->exponent;            /* calculate digits to remove */
7458   if (adjust<=0) {                      /* not out of range; unrounded */
7459     /* residue can never be non-zero here, except in the Nmin-residue */
7460     /* case (which is a subnormal result), so can take fast-path here */
7461     /* it may already be inexact (from setting the coefficient) */
7462     if (*status&DEC_Inexact) *status|=DEC_Underflow;
7463     return;
7464     }
7465
7466   /* adjust>0, so need to rescale the result so exponent becomes Etiny */
7467   /* [this code is similar to that in rescale] */
7468   workset=*set;                         /* clone rounding, etc. */
7469   workset.digits=dn->digits-adjust;     /* set requested length */
7470   workset.emin-=adjust;                 /* and adjust emin to match */
7471   /* [note that the latter can be <1, here, similar to Rescale case] */
7472   decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status);
7473   decApplyRound(dn, &workset, *residue, status);
7474
7475   /* Use 754 default rule: Underflow is set iff Inexact */
7476   /* [independent of whether trapped] */
7477   if (*status&DEC_Inexact) *status|=DEC_Underflow;
7478
7479   /* if rounded up a 999s case, exponent will be off by one; adjust */
7480   /* back if so [it will fit, because it was shortened earlier] */
7481   if (dn->exponent>etiny) {
7482     dn->digits=decShiftToMost(dn->lsu, dn->digits, 1);
7483     dn->exponent--;                     /* (re)adjust the exponent. */
7484     }
7485
7486   /* if rounded to zero, it is by definition clamped... */
7487   if (ISZERO(dn)) *status|=DEC_Clamped;
7488   } /* decSetSubnormal */
7489
7490 /* ------------------------------------------------------------------ */
7491 /* decCheckMath - check entry conditions for a math function          */
7492 /*                                                                    */
7493 /*   This checks the context and the operand                          */
7494 /*                                                                    */
7495 /*   rhs is the operand to check                                      */
7496 /*   set is the context to check                                      */
7497 /*   status is unchanged if both are good                             */
7498 /*                                                                    */
7499 /* returns non-zero if status is changed, 0 otherwise                 */
7500 /*                                                                    */
7501 /* Restrictions enforced:                                             */
7502 /*                                                                    */
7503 /*   digits, emax, and -emin in the context must be less than         */
7504 /*   DEC_MAX_MATH (999999), and A must be within these bounds if      */
7505 /*   non-zero.  Invalid_operation is set in the status if a           */
7506 /*   restriction is violated.                                         */
7507 /* ------------------------------------------------------------------ */
7508 static uInt decCheckMath(const decNumber *rhs, decContext *set,
7509                          uInt *status) {
7510   uInt save=*status;                         /* record */
7511   if (set->digits>DEC_MAX_MATH
7512    || set->emax>DEC_MAX_MATH
7513    || -set->emin>DEC_MAX_MATH) *status|=DEC_Invalid_context;
7514    else if ((rhs->digits>DEC_MAX_MATH
7515      || rhs->exponent+rhs->digits>DEC_MAX_MATH+1
7516      || rhs->exponent+rhs->digits<2*(1-DEC_MAX_MATH))
7517      && !ISZERO(rhs)) *status|=DEC_Invalid_operation;
7518   return (*status!=save);
7519   } /* decCheckMath */
7520
7521 /* ------------------------------------------------------------------ */
7522 /* decGetInt -- get integer from a number                             */
7523 /*                                                                    */
7524 /*   dn is the number [which will not be altered]                     */
7525 /*                                                                    */
7526 /*   returns one of:                                                  */
7527 /*     BADINT if there is a non-zero fraction                         */
7528 /*     the converted integer                                          */
7529 /*     BIGEVEN if the integer is even and magnitude > 2*10**9         */
7530 /*     BIGODD  if the integer is odd  and magnitude > 2*10**9         */
7531 /*                                                                    */
7532 /* This checks and gets a whole number from the input decNumber.      */
7533 /* The sign can be determined from dn by the caller when BIGEVEN or   */
7534 /* BIGODD is returned.                                                */
7535 /* ------------------------------------------------------------------ */
7536 static Int decGetInt(const decNumber *dn) {
7537   Int  theInt;                          /* result accumulator */
7538   const Unit *up;                       /* work */
7539   Int  got;                             /* digits (real or not) processed */
7540   Int  ilength=dn->digits+dn->exponent; /* integral length */
7541   Flag neg=decNumberIsNegative(dn);     /* 1 if -ve */
7542
7543   /* The number must be an integer that fits in 10 digits */
7544   /* Assert, here, that 10 is enough for any rescale Etiny */
7545   #if DEC_MAX_EMAX > 999999999
7546     #error GetInt may need updating [for Emax]
7547   #endif
7548   #if DEC_MIN_EMIN < -999999999
7549     #error GetInt may need updating [for Emin]
7550   #endif
7551   if (ISZERO(dn)) return 0;             /* zeros are OK, with any exponent */
7552
7553   up=dn->lsu;                           /* ready for lsu */
7554   theInt=0;                             /* ready to accumulate */
7555   if (dn->exponent>=0) {                /* relatively easy */
7556     /* no fractional part [usual]; allow for positive exponent */
7557     got=dn->exponent;
7558     }
7559    else { /* -ve exponent; some fractional part to check and discard */
7560     Int count=-dn->exponent;            /* digits to discard */
7561     /* spin up whole units until reach the Unit with the unit digit */
7562     for (; count>=DECDPUN; up++) {
7563       if (*up!=0) return BADINT;        /* non-zero Unit to discard */
7564       count-=DECDPUN;
7565       }
7566     if (count==0) got=0;                /* [a multiple of DECDPUN] */
7567      else {                             /* [not multiple of DECDPUN] */
7568       Int rem;                          /* work */
7569       /* slice off fraction digits and check for non-zero */
7570       #if DECDPUN<=4
7571         theInt=QUOT10(*up, count);
7572         rem=*up-theInt*powers[count];
7573       #else
7574         rem=*up%powers[count];          /* slice off discards */
7575         theInt=*up/powers[count];
7576       #endif
7577       if (rem!=0) return BADINT;        /* non-zero fraction */
7578       /* it looks good */
7579       got=DECDPUN-count;                /* number of digits so far */
7580       up++;                             /* ready for next */
7581       }
7582     }
7583   /* now it's known there's no fractional part */
7584
7585   /* tricky code now, to accumulate up to 9.3 digits */
7586   if (got==0) {theInt=*up; got+=DECDPUN; up++;} /* ensure lsu is there */
7587
7588   if (ilength<11) {
7589     Int save=theInt;
7590     /* collect any remaining unit(s) */
7591     for (; got<ilength; up++) {
7592       theInt+=*up*powers[got];
7593       got+=DECDPUN;
7594       }
7595     if (ilength==10) {                  /* need to check for wrap */
7596       if (theInt/(Int)powers[got-DECDPUN]!=(Int)*(up-1)) ilength=11;
7597          /* [that test also disallows the BADINT result case] */
7598        else if (neg && theInt>1999999997) ilength=11;
7599        else if (!neg && theInt>999999999) ilength=11;
7600       if (ilength==11) theInt=save;     /* restore correct low bit */
7601       }
7602     }
7603
7604   if (ilength>10) {                     /* too big */
7605     if (theInt&1) return BIGODD;        /* bottom bit 1 */
7606     return BIGEVEN;                     /* bottom bit 0 */
7607     }
7608
7609   if (neg) theInt=-theInt;              /* apply sign */
7610   return theInt;
7611   } /* decGetInt */
7612
7613 /* ------------------------------------------------------------------ */
7614 /* decDecap -- decapitate the coefficient of a number                 */
7615 /*                                                                    */
7616 /*   dn   is the number to be decapitated                             */
7617 /*   drop is the number of digits to be removed from the left of dn;  */
7618 /*     this must be <= dn->digits (if equal, the coefficient is       */
7619 /*     set to 0)                                                      */
7620 /*                                                                    */
7621 /* Returns dn; dn->digits will be <= the initial digits less drop     */
7622 /* (after removing drop digits there may be leading zero digits       */
7623 /* which will also be removed).  Only dn->lsu and dn->digits change.  */
7624 /* ------------------------------------------------------------------ */
7625 static decNumber *decDecap(decNumber *dn, Int drop) {
7626   Unit *msu;                            /* -> target cut point */
7627   Int cut;                              /* work */
7628   if (drop>=dn->digits) {               /* losing the whole thing */
7629     #if DECCHECK
7630     if (drop>dn->digits)
7631       printf("decDecap called with drop>digits [%ld>%ld]\n",
7632              (LI)drop, (LI)dn->digits);
7633     #endif
7634     dn->lsu[0]=0;
7635     dn->digits=1;
7636     return dn;
7637     }
7638   msu=dn->lsu+D2U(dn->digits-drop)-1;   /* -> likely msu */
7639   cut=MSUDIGITS(dn->digits-drop);       /* digits to be in use in msu */
7640   if (cut!=DECDPUN) *msu%=powers[cut];  /* clear left digits */
7641   /* that may have left leading zero digits, so do a proper count... */
7642   dn->digits=decGetDigits(dn->lsu, msu-dn->lsu+1);
7643   return dn;
7644   } /* decDecap */
7645
7646 /* ------------------------------------------------------------------ */
7647 /* decBiStr -- compare string with pairwise options                   */
7648 /*                                                                    */
7649 /*   targ is the string to compare                                    */
7650 /*   str1 is one of the strings to compare against (length may be 0)  */
7651 /*   str2 is the other; it must be the same length as str1            */
7652 /*                                                                    */
7653 /*   returns 1 if strings compare equal, (that is, it is the same     */
7654 /*   length as str1 and str2, and each character of targ is in either */
7655 /*   str1 or str2 in the corresponding position), or 0 otherwise      */
7656 /*                                                                    */
7657 /* This is used for generic caseless compare, including the awkward   */
7658 /* case of the Turkish dotted and dotless Is.  Use as (for example):  */
7659 /*   if (decBiStr(test, "mike", "MIKE")) ...                          */
7660 /* ------------------------------------------------------------------ */
7661 static Flag decBiStr(const char *targ, const char *str1, const char *str2) {
7662   for (;;targ++, str1++, str2++) {
7663     if (*targ!=*str1 && *targ!=*str2) return 0;
7664     /* *targ has a match in one (or both, if terminator) */
7665     if (*targ=='\0') break;
7666     } /* forever */
7667   return 1;
7668   } /* decBiStr */
7669
7670 /* ------------------------------------------------------------------ */
7671 /* decNaNs -- handle NaN operand or operands                          */
7672 /*                                                                    */
7673 /*   res     is the result number                                     */
7674 /*   lhs     is the first operand                                     */
7675 /*   rhs     is the second operand, or NULL if none                   */
7676 /*   context is used to limit payload length                          */
7677 /*   status  contains the current status                              */
7678 /*   returns res in case convenient                                   */
7679 /*                                                                    */
7680 /* Called when one or both operands is a NaN, and propagates the      */
7681 /* appropriate result to res.  When an sNaN is found, it is changed   */
7682 /* to a qNaN and Invalid operation is set.                            */
7683 /* ------------------------------------------------------------------ */
7684 static decNumber * decNaNs(decNumber *res, const decNumber *lhs,
7685                            const decNumber *rhs, decContext *set,
7686                            uInt *status) {
7687   /* This decision tree ends up with LHS being the source pointer, */
7688   /* and status updated if need be */
7689   if (lhs->bits & DECSNAN)
7690     *status|=DEC_Invalid_operation | DEC_sNaN;
7691    else if (rhs==NULL);
7692    else if (rhs->bits & DECSNAN) {
7693     lhs=rhs;
7694     *status|=DEC_Invalid_operation | DEC_sNaN;
7695     }
7696    else if (lhs->bits & DECNAN);
7697    else lhs=rhs;
7698
7699   /* propagate the payload */
7700   if (lhs->digits<=set->digits) decNumberCopy(res, lhs); /* easy */
7701    else { /* too long */
7702     const Unit *ul;
7703     Unit *ur, *uresp1;
7704     /* copy safe number of units, then decapitate */
7705     res->bits=lhs->bits;                /* need sign etc. */
7706     uresp1=res->lsu+D2U(set->digits);
7707     for (ur=res->lsu, ul=lhs->lsu; ur<uresp1; ur++, ul++) *ur=*ul;
7708     res->digits=D2U(set->digits)*DECDPUN;
7709     /* maybe still too long */
7710     if (res->digits>set->digits) decDecap(res, res->digits-set->digits);
7711     }
7712
7713   res->bits&=~DECSNAN;        /* convert any sNaN to NaN, while */
7714   res->bits|=DECNAN;          /* .. preserving sign */
7715   res->exponent=0;            /* clean exponent */
7716                               /* [coefficient was copied/decapitated] */
7717   return res;
7718   } /* decNaNs */
7719
7720 /* ------------------------------------------------------------------ */
7721 /* decStatus -- apply non-zero status                                 */
7722 /*                                                                    */
7723 /*   dn     is the number to set if error                             */
7724 /*   status contains the current status (not yet in context)          */
7725 /*   set    is the context                                            */
7726 /*                                                                    */
7727 /* If the status is an error status, the number is set to a NaN,      */
7728 /* unless the error was an overflow, divide-by-zero, or underflow,    */
7729 /* in which case the number will have already been set.               */
7730 /*                                                                    */
7731 /* The context status is then updated with the new status.  Note that */
7732 /* this may raise a signal, so control may never return from this     */
7733 /* routine (hence resources must be recovered before it is called).   */
7734 /* ------------------------------------------------------------------ */
7735 static void decStatus(decNumber *dn, uInt status, decContext *set) {
7736   if (status & DEC_NaNs) {              /* error status -> NaN */
7737     /* if cause was an sNaN, clear and propagate [NaN is already set up] */
7738     if (status & DEC_sNaN) status&=~DEC_sNaN;
7739      else {
7740       decNumberZero(dn);                /* other error: clean throughout */
7741       dn->bits=DECNAN;                  /* and make a quiet NaN */
7742       }
7743     }
7744   decContextSetStatus(set, status);     /* [may not return] */
7745   return;
7746   } /* decStatus */
7747
7748 /* ------------------------------------------------------------------ */
7749 /* decGetDigits -- count digits in a Units array                      */
7750 /*                                                                    */
7751 /*   uar is the Unit array holding the number (this is often an       */
7752 /*          accumulator of some sort)                                 */
7753 /*   len is the length of the array in units [>=1]                    */
7754 /*                                                                    */
7755 /*   returns the number of (significant) digits in the array          */
7756 /*                                                                    */
7757 /* All leading zeros are excluded, except the last if the array has   */
7758 /* only zero Units.                                                   */
7759 /* ------------------------------------------------------------------ */
7760 /* This may be called twice during some operations. */
7761 static Int decGetDigits(Unit *uar, Int len) {
7762   Unit *up=uar+(len-1);            /* -> msu */
7763   Int  digits=(len-1)*DECDPUN+1;   /* possible digits excluding msu */
7764   #if DECDPUN>4
7765   uInt const *pow;                 /* work */
7766   #endif
7767                                    /* (at least 1 in final msu) */
7768   #if DECCHECK
7769   if (len<1) printf("decGetDigits called with len<1 [%ld]\n", (LI)len);
7770   #endif
7771
7772   for (; up>=uar; up--) {
7773     if (*up==0) {                  /* unit is all 0s */
7774       if (digits==1) break;        /* a zero has one digit */
7775       digits-=DECDPUN;             /* adjust for 0 unit */
7776       continue;}
7777     /* found the first (most significant) non-zero Unit */
7778     #if DECDPUN>1                  /* not done yet */
7779     if (*up<10) break;             /* is 1-9 */
7780     digits++;
7781     #if DECDPUN>2                  /* not done yet */
7782     if (*up<100) break;            /* is 10-99 */
7783     digits++;
7784     #if DECDPUN>3                  /* not done yet */
7785     if (*up<1000) break;           /* is 100-999 */
7786     digits++;
7787     #if DECDPUN>4                  /* count the rest ... */
7788     for (pow=&powers[4]; *up>=*pow; pow++) digits++;
7789     #endif
7790     #endif
7791     #endif
7792     #endif
7793     break;
7794     } /* up */
7795   return digits;
7796   } /* decGetDigits */
7797
7798 #if DECTRACE | DECCHECK
7799 /* ------------------------------------------------------------------ */
7800 /* decNumberShow -- display a number [debug aid]                      */
7801 /*   dn is the number to show                                         */
7802 /*                                                                    */
7803 /* Shows: sign, exponent, coefficient (msu first), digits             */
7804 /*    or: sign, special-value                                         */
7805 /* ------------------------------------------------------------------ */
7806 /* this is public so other modules can use it */
7807 void decNumberShow(const decNumber *dn) {
7808   const Unit *up;                  /* work */
7809   uInt u, d;                       /* .. */
7810   Int cut;                         /* .. */
7811   char isign='+';                  /* main sign */
7812   if (dn==NULL) {
7813     printf("NULL\n");
7814     return;}
7815   if (decNumberIsNegative(dn)) isign='-';
7816   printf(" >> %c ", isign);
7817   if (dn->bits&DECSPECIAL) {       /* Is a special value */
7818     if (decNumberIsInfinite(dn)) printf("Infinity");
7819      else {                                  /* a NaN */
7820       if (dn->bits&DECSNAN) printf("sNaN");  /* signalling NaN */
7821        else printf("NaN");
7822       }
7823     /* if coefficient and exponent are 0, no more to do */
7824     if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) {
7825       printf("\n");
7826       return;}
7827     /* drop through to report other information */
7828     printf(" ");
7829     }
7830
7831   /* now carefully display the coefficient */
7832   up=dn->lsu+D2U(dn->digits)-1;         /* msu */
7833   printf("%ld", (LI)*up);
7834   for (up=up-1; up>=dn->lsu; up--) {
7835     u=*up;
7836     printf(":");
7837     for (cut=DECDPUN-1; cut>=0; cut--) {
7838       d=u/powers[cut];
7839       u-=d*powers[cut];
7840       printf("%ld", (LI)d);
7841       } /* cut */
7842     } /* up */
7843   if (dn->exponent!=0) {
7844     char esign='+';
7845     if (dn->exponent<0) esign='-';
7846     printf(" E%c%ld", esign, (LI)abs(dn->exponent));
7847     }
7848   printf(" [%ld]\n", (LI)dn->digits);
7849   } /* decNumberShow */
7850 #endif
7851
7852 #if DECTRACE || DECCHECK
7853 /* ------------------------------------------------------------------ */
7854 /* decDumpAr -- display a unit array [debug/check aid]                */
7855 /*   name is a single-character tag name                              */
7856 /*   ar   is the array to display                                     */
7857 /*   len  is the length of the array in Units                         */
7858 /* ------------------------------------------------------------------ */
7859 static void decDumpAr(char name, const Unit *ar, Int len) {
7860   Int i;
7861   const char *spec;
7862   #if DECDPUN==9
7863     spec="%09d ";
7864   #elif DECDPUN==8
7865     spec="%08d ";
7866   #elif DECDPUN==7
7867     spec="%07d ";
7868   #elif DECDPUN==6
7869     spec="%06d ";
7870   #elif DECDPUN==5
7871     spec="%05d ";
7872   #elif DECDPUN==4
7873     spec="%04d ";
7874   #elif DECDPUN==3
7875     spec="%03d ";
7876   #elif DECDPUN==2
7877     spec="%02d ";
7878   #else
7879     spec="%d ";
7880   #endif
7881   printf("  :%c: ", name);
7882   for (i=len-1; i>=0; i--) {
7883     if (i==len-1) printf("%ld ", (LI)ar[i]);
7884      else printf(spec, ar[i]);
7885     }
7886   printf("\n");
7887   return;}
7888 #endif
7889
7890 #if DECCHECK
7891 /* ------------------------------------------------------------------ */
7892 /* decCheckOperands -- check operand(s) to a routine                  */
7893 /*   res is the result structure (not checked; it will be set to      */
7894 /*          quiet NaN if error found (and it is not NULL))            */
7895 /*   lhs is the first operand (may be DECUNRESU)                      */
7896 /*   rhs is the second (may be DECUNUSED)                             */
7897 /*   set is the context (may be DECUNCONT)                            */
7898 /*   returns 0 if both operands, and the context are clean, or 1      */
7899 /*     otherwise (in which case the context will show an error,       */
7900 /*     unless NULL).  Note that res is not cleaned; caller should     */
7901 /*     handle this so res=NULL case is safe.                          */
7902 /* The caller is expected to abandon immediately if 1 is returned.    */
7903 /* ------------------------------------------------------------------ */
7904 static Flag decCheckOperands(decNumber *res, const decNumber *lhs,
7905                              const decNumber *rhs, decContext *set) {
7906   Flag bad=0;
7907   if (set==NULL) {                 /* oops; hopeless */
7908     #if DECTRACE || DECVERB
7909     printf("Reference to context is NULL.\n");
7910     #endif
7911     bad=1;
7912     return 1;}
7913    else if (set!=DECUNCONT
7914      && (set->digits<1 || set->round>=DEC_ROUND_MAX)) {
7915     bad=1;
7916     #if DECTRACE || DECVERB
7917     printf("Bad context [digits=%ld round=%ld].\n",
7918            (LI)set->digits, (LI)set->round);
7919     #endif
7920     }
7921    else {
7922     if (res==NULL) {
7923       bad=1;
7924       #if DECTRACE
7925       /* this one not DECVERB as standard tests include NULL */
7926       printf("Reference to result is NULL.\n");
7927       #endif
7928       }
7929     if (!bad && lhs!=DECUNUSED) bad=(decCheckNumber(lhs));
7930     if (!bad && rhs!=DECUNUSED) bad=(decCheckNumber(rhs));
7931     }
7932   if (bad) {
7933     if (set!=DECUNCONT) decContextSetStatus(set, DEC_Invalid_operation);
7934     if (res!=DECUNRESU && res!=NULL) {
7935       decNumberZero(res);
7936       res->bits=DECNAN;       /* qNaN */
7937       }
7938     }
7939   return bad;
7940   } /* decCheckOperands */
7941
7942 /* ------------------------------------------------------------------ */
7943 /* decCheckNumber -- check a number                                   */
7944 /*   dn is the number to check                                        */
7945 /*   returns 0 if the number is clean, or 1 otherwise                 */
7946 /*                                                                    */
7947 /* The number is considered valid if it could be a result from some   */
7948 /* operation in some valid context.                                   */
7949 /* ------------------------------------------------------------------ */
7950 static Flag decCheckNumber(const decNumber *dn) {
7951   const Unit *up;             /* work */
7952   uInt maxuint;               /* .. */
7953   Int ae, d, digits;          /* .. */
7954   Int emin, emax;             /* .. */
7955
7956   if (dn==NULL) {             /* hopeless */
7957     #if DECTRACE
7958     /* this one not DECVERB as standard tests include NULL */
7959     printf("Reference to decNumber is NULL.\n");
7960     #endif
7961     return 1;}
7962
7963   /* check special values */
7964   if (dn->bits & DECSPECIAL) {
7965     if (dn->exponent!=0) {
7966       #if DECTRACE || DECVERB
7967       printf("Exponent %ld (not 0) for a special value [%02x].\n",
7968              (LI)dn->exponent, dn->bits);
7969       #endif
7970       return 1;}
7971
7972     /* 2003.09.08: NaNs may now have coefficients, so next tests Inf only */
7973     if (decNumberIsInfinite(dn)) {
7974       if (dn->digits!=1) {
7975         #if DECTRACE || DECVERB
7976         printf("Digits %ld (not 1) for an infinity.\n", (LI)dn->digits);
7977         #endif
7978         return 1;}
7979       if (*dn->lsu!=0) {
7980         #if DECTRACE || DECVERB
7981         printf("LSU %ld (not 0) for an infinity.\n", (LI)*dn->lsu);
7982         #endif
7983         decDumpAr('I', dn->lsu, D2U(dn->digits));
7984         return 1;}
7985       } /* Inf */
7986     /* 2002.12.26: negative NaNs can now appear through proposed IEEE */
7987     /*             concrete formats (decimal64, etc.). */
7988     return 0;
7989     }
7990
7991   /* check the coefficient */
7992   if (dn->digits<1 || dn->digits>DECNUMMAXP) {
7993     #if DECTRACE || DECVERB
7994     printf("Digits %ld in number.\n", (LI)dn->digits);
7995     #endif
7996     return 1;}
7997
7998   d=dn->digits;
7999
8000   for (up=dn->lsu; d>0; up++) {
8001     if (d>DECDPUN) maxuint=DECDPUNMAX;
8002      else {                   /* reached the msu */
8003       maxuint=powers[d]-1;
8004       if (dn->digits>1 && *up<powers[d-1]) {
8005         #if DECTRACE || DECVERB
8006         printf("Leading 0 in number.\n");
8007         decNumberShow(dn);
8008         #endif
8009         return 1;}
8010       }
8011     if (*up>maxuint) {
8012       #if DECTRACE || DECVERB
8013       printf("Bad Unit [%08lx] in %ld-digit number at offset %ld [maxuint %ld].\n",
8014               (LI)*up, (LI)dn->digits, (LI)(up-dn->lsu), (LI)maxuint);
8015       #endif
8016       return 1;}
8017     d-=DECDPUN;
8018     }
8019
8020   /* check the exponent.  Note that input operands can have exponents */
8021   /* which are out of the set->emin/set->emax and set->digits range */
8022   /* (just as they can have more digits than set->digits). */
8023   ae=dn->exponent+dn->digits-1;    /* adjusted exponent */
8024   emax=DECNUMMAXE;
8025   emin=DECNUMMINE;
8026   digits=DECNUMMAXP;
8027   if (ae<emin-(digits-1)) {
8028     #if DECTRACE || DECVERB
8029     printf("Adjusted exponent underflow [%ld].\n", (LI)ae);
8030     decNumberShow(dn);
8031     #endif
8032     return 1;}
8033   if (ae>+emax) {
8034     #if DECTRACE || DECVERB
8035     printf("Adjusted exponent overflow [%ld].\n", (LI)ae);
8036     decNumberShow(dn);
8037     #endif
8038     return 1;}
8039
8040   return 0;              /* it's OK */
8041   } /* decCheckNumber */
8042
8043 /* ------------------------------------------------------------------ */
8044 /* decCheckInexact -- check a normal finite inexact result has digits */
8045 /*   dn is the number to check                                        */
8046 /*   set is the context (for status and precision)                    */
8047 /*   sets Invalid operation, etc., if some digits are missing         */
8048 /* [this check is not made for DECSUBSET compilation or when          */
8049 /* subnormal is not set]                                              */
8050 /* ------------------------------------------------------------------ */
8051 static void decCheckInexact(const decNumber *dn, decContext *set) {
8052   #if !DECSUBSET && DECEXTFLAG
8053     if ((set->status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact
8054      && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) {
8055       #if DECTRACE || DECVERB
8056       printf("Insufficient digits [%ld] on normal Inexact result.\n",
8057              (LI)dn->digits);
8058       decNumberShow(dn);
8059       #endif
8060       decContextSetStatus(set, DEC_Invalid_operation);
8061       }
8062   #else
8063     /* next is a noop for quiet compiler */
8064     if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation;
8065   #endif
8066   return;
8067   } /* decCheckInexact */
8068 #endif
8069
8070 #if DECALLOC
8071 #undef malloc
8072 #undef free
8073 /* ------------------------------------------------------------------ */
8074 /* decMalloc -- accountable allocation routine                        */
8075 /*   n is the number of bytes to allocate                             */
8076 /*                                                                    */
8077 /* Semantics is the same as the stdlib malloc routine, but bytes      */
8078 /* allocated are accounted for globally, and corruption fences are    */
8079 /* added before and after the 'actual' storage.                       */
8080 /* ------------------------------------------------------------------ */
8081 /* This routine allocates storage with an extra twelve bytes; 8 are   */
8082 /* at the start and hold:                                             */
8083 /*   0-3 the original length requested                                */
8084 /*   4-7 buffer corruption detection fence (DECFENCE, x4)             */
8085 /* The 4 bytes at the end also hold a corruption fence (DECFENCE, x4) */
8086 /* ------------------------------------------------------------------ */
8087 static void *decMalloc(size_t n) {
8088   uInt  size=n+12;                 /* true size */
8089   void  *alloc;                    /* -> allocated storage */
8090   uByte *b, *b0;                   /* work */
8091   uInt  uiwork;                    /* for macros */
8092
8093   alloc=malloc(size);              /* -> allocated storage */
8094   if (alloc==NULL) return NULL;    /* out of strorage */
8095   b0=(uByte *)alloc;               /* as bytes */
8096   decAllocBytes+=n;                /* account for storage */
8097   UBFROMUI(alloc, n);              /* save n */
8098   /* printf(" alloc ++ dAB: %ld (%ld)\n", (LI)decAllocBytes, (LI)n); */
8099   for (b=b0+4; b<b0+8; b++) *b=DECFENCE;
8100   for (b=b0+n+8; b<b0+n+12; b++) *b=DECFENCE;
8101   return b0+8;                     /* -> play area */
8102   } /* decMalloc */
8103
8104 /* ------------------------------------------------------------------ */
8105 /* decFree -- accountable free routine                                */
8106 /*   alloc is the storage to free                                     */
8107 /*                                                                    */
8108 /* Semantics is the same as the stdlib malloc routine, except that    */
8109 /* the global storage accounting is updated and the fences are        */
8110 /* checked to ensure that no routine has written 'out of bounds'.     */
8111 /* ------------------------------------------------------------------ */
8112 /* This routine first checks that the fences have not been corrupted. */
8113 /* It then frees the storage using the 'truw' storage address (that   */
8114 /* is, offset by 8).                                                  */
8115 /* ------------------------------------------------------------------ */
8116 static void decFree(void *alloc) {
8117   uInt  n;                         /* original length */
8118   uByte *b, *b0;                   /* work */
8119   uInt  uiwork;                    /* for macros */
8120
8121   if (alloc==NULL) return;         /* allowed; it's a nop */
8122   b0=(uByte *)alloc;               /* as bytes */
8123   b0-=8;                           /* -> true start of storage */
8124   n=UBTOUI(b0);                    /* lift length */
8125   for (b=b0+4; b<b0+8; b++) if (*b!=DECFENCE)
8126     printf("=== Corrupt byte [%02x] at offset %d from %ld ===\n", *b,
8127            b-b0-8, (LI)b0);
8128   for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE)
8129     printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b,
8130            b-b0-8, (LI)b0, (LI)n);
8131   free(b0);                        /* drop the storage */
8132   decAllocBytes-=n;                /* account for storage */
8133   /* printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n); */
8134   } /* decFree */
8135 #define malloc(a) decMalloc(a)
8136 #define free(a) decFree(a)
8137 #endif