1 /* Decimal number arithmetic module for the decNumber C Library. 2 Copyright (C) 2005, 2007 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 2, or (at your option) any later 10 version. 11 12 In addition to the permissions in the GNU General Public License, 13 the Free Software Foundation gives you unlimited permission to link 14 the compiled version of this file into combinations with other 15 programs, and to distribute those combinations without any 16 restriction coming from the use of this file. (The General Public 17 License restrictions do apply in other respects; for example, they 18 cover modification of the file, and distribution when not linked 19 into a combine executable.) 20 21 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 22 WARRANTY; without even the implied warranty of MERCHANTABILITY or 23 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 24 for more details. 25 26 You should have received a copy of the GNU General Public License 27 along with GCC; see the file COPYING. If not, write to the Free 28 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 29 02110-1301, USA. */ 30 31 /* ------------------------------------------------------------------ */ 32 /* Decimal Number arithmetic module */ 33 /* ------------------------------------------------------------------ */ 34 /* This module comprises the routines for General Decimal Arithmetic */ 35 /* as defined in the specification which may be found on the */ 36 /* http://www2.hursley.ibm.com/decimal web pages. It implements both */ 37 /* the full ('extended') arithmetic and the simpler ('subset') */ 38 /* arithmetic. */ 39 /* */ 40 /* Usage notes: */ 41 /* */ 42 /* 1. This code is ANSI C89 except: */ 43 /* */ 44 /* If DECDPUN>4 or DECUSE64=1, the C99 64-bit int64_t and */ 45 /* uint64_t types may be used. To avoid these, set DECUSE64=0 */ 46 /* and DECDPUN<=4 (see documentation). */ 47 /* */ 48 /* 2. The decNumber format which this library uses is optimized for */ 49 /* efficient processing of relatively short numbers; in particular */ 50 /* it allows the use of fixed sized structures and minimizes copy */ 51 /* and move operations. It does, however, support arbitrary */ 52 /* precision (up to 999,999,999 digits) and arbitrary exponent */ 53 /* range (Emax in the range 0 through 999,999,999 and Emin in the */ 54 /* range -999,999,999 through 0). Mathematical functions (for */ 55 /* example decNumberExp) as identified below are restricted more */ 56 /* tightly: digits, emax, and -emin in the context must be <= */ 57 /* DEC_MAX_MATH (999999), and their operand(s) must be within */ 58 /* these bounds. */ 59 /* */ 60 /* 3. Logical functions are further restricted; their operands must */ 61 /* be finite, positive, have an exponent of zero, and all digits */ 62 /* must be either 0 or 1. The result will only contain digits */ 63 /* which are 0 or 1 (and will have exponent=0 and a sign of 0). */ 64 /* */ 65 /* 4. Operands to operator functions are never modified unless they */ 66 /* are also specified to be the result number (which is always */ 67 /* permitted). Other than that case, operands must not overlap. */ 68 /* */ 69 /* 5. Error handling: the type of the error is ORed into the status */ 70 /* flags in the current context (decContext structure). The */ 71 /* SIGFPE signal is then raised if the corresponding trap-enabler */ 72 /* flag in the decContext is set (is 1). */ 73 /* */ 74 /* It is the responsibility of the caller to clear the status */ 75 /* flags as required. */ 76 /* */ 77 /* The result of any routine which returns a number will always */ 78 /* be a valid number (which may be a special value, such as an */ 79 /* Infinity or NaN). */ 80 /* */ 81 /* 6. The decNumber format is not an exchangeable concrete */ 82 /* representation as it comprises fields which may be machine- */ 83 /* dependent (packed or unpacked, or special length, for example). */ 84 /* Canonical conversions to and from strings are provided; other */ 85 /* conversions are available in separate modules. */ 86 /* */ 87 /* 7. Normally, input operands are assumed to be valid. Set DECCHECK */ 88 /* to 1 for extended operand checking (including NULL operands). */ 89 /* Results are undefined if a badly-formed structure (or a NULL */ 90 /* pointer to a structure) is provided, though with DECCHECK */ 91 /* enabled the operator routines are protected against exceptions. */ 92 /* (Except if the result pointer is NULL, which is unrecoverable.) */ 93 /* */ 94 /* However, the routines will never cause exceptions if they are */ 95 /* given well-formed operands, even if the value of the operands */ 96 /* is inappropriate for the operation and DECCHECK is not set. */ 97 /* (Except for SIGFPE, as and where documented.) */ 98 /* */ 99 /* 8. Subset arithmetic is available only if DECSUBSET is set to 1. */ 100 /* ------------------------------------------------------------------ */ 101 /* Implementation notes for maintenance of this module: */ 102 /* */ 103 /* 1. Storage leak protection: Routines which use malloc are not */ 104 /* permitted to use return for fastpath or error exits (i.e., */ 105 /* they follow strict structured programming conventions). */ 106 /* Instead they have a do{}while(0); construct surrounding the */ 107 /* code which is protected -- break may be used to exit this. */ 108 /* Other routines can safely use the return statement inline. */ 109 /* */ 110 /* Storage leak accounting can be enabled using DECALLOC. */ 111 /* */ 112 /* 2. All loops use the for(;;) construct. Any do construct does */ 113 /* not loop; it is for allocation protection as just described. */ 114 /* */ 115 /* 3. Setting status in the context must always be the very last */ 116 /* action in a routine, as non-0 status may raise a trap and hence */ 117 /* the call to set status may not return (if the handler uses long */ 118 /* jump). Therefore all cleanup must be done first. In general, */ 119 /* to achieve this status is accumulated and is only applied just */ 120 /* before return by calling decContextSetStatus (via decStatus). */ 121 /* */ 122 /* Routines which allocate storage cannot, in general, use the */ 123 /* 'top level' routines which could cause a non-returning */ 124 /* transfer of control. The decXxxxOp routines are safe (do not */ 125 /* call decStatus even if traps are set in the context) and should */ 126 /* be used instead (they are also a little faster). */ 127 /* */ 128 /* 4. Exponent checking is minimized by allowing the exponent to */ 129 /* grow outside its limits during calculations, provided that */ 130 /* the decFinalize function is called later. Multiplication and */ 131 /* division, and intermediate calculations in exponentiation, */ 132 /* require more careful checks because of the risk of 31-bit */ 133 /* overflow (the most negative valid exponent is -1999999997, for */ 134 /* a 999999999-digit number with adjusted exponent of -999999999). */ 135 /* */ 136 /* 5. Rounding is deferred until finalization of results, with any */ 137 /* 'off to the right' data being represented as a single digit */ 138 /* residue (in the range -1 through 9). This avoids any double- */ 139 /* rounding when more than one shortening takes place (for */ 140 /* example, when a result is subnormal). */ 141 /* */ 142 /* 6. The digits count is allowed to rise to a multiple of DECDPUN */ 143 /* during many operations, so whole Units are handled and exact */ 144 /* accounting of digits is not needed. The correct digits value */ 145 /* is found by decGetDigits, which accounts for leading zeros. */ 146 /* This must be called before any rounding if the number of digits */ 147 /* is not known exactly. */ 148 /* */ 149 /* 7. The multiply-by-reciprocal 'trick' is used for partitioning */ 150 /* numbers up to four digits, using appropriate constants. This */ 151 /* is not useful for longer numbers because overflow of 32 bits */ 152 /* would lead to 4 multiplies, which is almost as expensive as */ 153 /* a divide (unless a floating-point or 64-bit multiply is */ 154 /* assumed to be available). */ 155 /* */ 156 /* 8. Unusual abbreviations that may be used in the commentary: */ 157 /* lhs -- left hand side (operand, of an operation) */ 158 /* lsd -- least significant digit (of coefficient) */ 159 /* lsu -- least significant Unit (of coefficient) */ 160 /* msd -- most significant digit (of coefficient) */ 161 /* msi -- most significant item (in an array) */ 162 /* msu -- most significant Unit (of coefficient) */ 163 /* rhs -- right hand side (operand, of an operation) */ 164 /* +ve -- positive */ 165 /* -ve -- negative */ 166 /* ** -- raise to the power */ 167 /* ------------------------------------------------------------------ */ 168 169 #include "qemu/osdep.h" 170 #include "qemu/host-utils.h" 171 #include "libdecnumber/dconfig.h" 172 #include "libdecnumber/decNumber.h" 173 #include "libdecnumber/decNumberLocal.h" 174 175 /* Constants */ 176 /* Public lookup table used by the D2U macro */ 177 const uByte d2utable[DECMAXD2U+1]=D2UTABLE; 178 179 #define DECVERB 1 /* set to 1 for verbose DECCHECK */ 180 #define powers DECPOWERS /* old internal name */ 181 182 /* Local constants */ 183 #define DIVIDE 0x80 /* Divide operators */ 184 #define REMAINDER 0x40 /* .. */ 185 #define DIVIDEINT 0x20 /* .. */ 186 #define REMNEAR 0x10 /* .. */ 187 #define COMPARE 0x01 /* Compare operators */ 188 #define COMPMAX 0x02 /* .. */ 189 #define COMPMIN 0x03 /* .. */ 190 #define COMPTOTAL 0x04 /* .. */ 191 #define COMPNAN 0x05 /* .. [NaN processing] */ 192 #define COMPSIG 0x06 /* .. [signaling COMPARE] */ 193 #define COMPMAXMAG 0x07 /* .. */ 194 #define COMPMINMAG 0x08 /* .. */ 195 196 #define DEC_sNaN 0x40000000 /* local status: sNaN signal */ 197 #define BADINT (Int)0x80000000 /* most-negative Int; error indicator */ 198 /* Next two indicate an integer >= 10**6, and its parity (bottom bit) */ 199 #define BIGEVEN (Int)0x80000002 200 #define BIGODD (Int)0x80000003 201 202 static Unit uarrone[1]={1}; /* Unit array of 1, used for incrementing */ 203 204 /* Granularity-dependent code */ 205 #if DECDPUN<=4 206 #define eInt Int /* extended integer */ 207 #define ueInt uInt /* unsigned extended integer */ 208 /* Constant multipliers for divide-by-power-of five using reciprocal */ 209 /* multiply, after removing powers of 2 by shifting, and final shift */ 210 /* of 17 [we only need up to **4] */ 211 static const uInt multies[]={131073, 26215, 5243, 1049, 210}; 212 /* QUOT10 -- macro to return the quotient of unit u divided by 10**n */ 213 #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) 214 #else 215 /* For DECDPUN>4 non-ANSI-89 64-bit types are needed. */ 216 #if !DECUSE64 217 #error decNumber.c: DECUSE64 must be 1 when DECDPUN>4 218 #endif 219 #define eInt Long /* extended integer */ 220 #define ueInt uLong /* unsigned extended integer */ 221 #endif 222 223 /* Local routines */ 224 static decNumber * decAddOp(decNumber *, const decNumber *, const decNumber *, 225 decContext *, uByte, uInt *); 226 static Flag decBiStr(const char *, const char *, const char *); 227 static uInt decCheckMath(const decNumber *, decContext *, uInt *); 228 static void decApplyRound(decNumber *, decContext *, Int, uInt *); 229 static Int decCompare(const decNumber *lhs, const decNumber *rhs, Flag); 230 static decNumber * decCompareOp(decNumber *, const decNumber *, 231 const decNumber *, decContext *, 232 Flag, uInt *); 233 static void decCopyFit(decNumber *, const decNumber *, decContext *, 234 Int *, uInt *); 235 static decNumber * decDecap(decNumber *, Int); 236 static decNumber * decDivideOp(decNumber *, const decNumber *, 237 const decNumber *, decContext *, Flag, uInt *); 238 static decNumber * decExpOp(decNumber *, const decNumber *, 239 decContext *, uInt *); 240 static void decFinalize(decNumber *, decContext *, Int *, uInt *); 241 static Int decGetDigits(Unit *, Int); 242 static Int decGetInt(const decNumber *); 243 static decNumber * decLnOp(decNumber *, const decNumber *, 244 decContext *, uInt *); 245 static decNumber * decMultiplyOp(decNumber *, const decNumber *, 246 const decNumber *, decContext *, 247 uInt *); 248 static decNumber * decNaNs(decNumber *, const decNumber *, 249 const decNumber *, decContext *, uInt *); 250 static decNumber * decQuantizeOp(decNumber *, const decNumber *, 251 const decNumber *, decContext *, Flag, 252 uInt *); 253 static void decReverse(Unit *, Unit *); 254 static void decSetCoeff(decNumber *, decContext *, const Unit *, 255 Int, Int *, uInt *); 256 static void decSetMaxValue(decNumber *, decContext *); 257 static void decSetOverflow(decNumber *, decContext *, uInt *); 258 static void decSetSubnormal(decNumber *, decContext *, Int *, uInt *); 259 static Int decShiftToLeast(Unit *, Int, Int); 260 static Int decShiftToMost(Unit *, Int, Int); 261 static void decStatus(decNumber *, uInt, decContext *); 262 static void decToString(const decNumber *, char[], Flag); 263 static decNumber * decTrim(decNumber *, decContext *, Flag, Int *); 264 static Int decUnitAddSub(const Unit *, Int, const Unit *, Int, Int, 265 Unit *, Int); 266 static Int decUnitCompare(const Unit *, Int, const Unit *, Int, Int); 267 static bool mulUInt128ByPowOf10(uLong *, uLong *, uInt); 268 269 #if !DECSUBSET 270 /* decFinish == decFinalize when no subset arithmetic needed */ 271 #define decFinish(a,b,c,d) decFinalize(a,b,c,d) 272 #else 273 static void decFinish(decNumber *, decContext *, Int *, uInt *); 274 static decNumber * decRoundOperand(const decNumber *, decContext *, uInt *); 275 #endif 276 277 /* Local macros */ 278 /* masked special-values bits */ 279 #define SPECIALARG (rhs->bits & DECSPECIAL) 280 #define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL) 281 282 /* Diagnostic macros, etc. */ 283 #if DECALLOC 284 /* Handle malloc/free accounting. If enabled, our accountable routines */ 285 /* are used; otherwise the code just goes straight to the system malloc */ 286 /* and free routines. */ 287 #define malloc(a) decMalloc(a) 288 #define free(a) decFree(a) 289 #define DECFENCE 0x5a /* corruption detector */ 290 /* 'Our' malloc and free: */ 291 static void *decMalloc(size_t); 292 static void decFree(void *); 293 uInt decAllocBytes=0; /* count of bytes allocated */ 294 /* Note that DECALLOC code only checks for storage buffer overflow. */ 295 /* To check for memory leaks, the decAllocBytes variable must be */ 296 /* checked to be 0 at appropriate times (e.g., after the test */ 297 /* harness completes a set of tests). This checking may be unreliable */ 298 /* if the testing is done in a multi-thread environment. */ 299 #endif 300 301 #if DECCHECK 302 /* Optional checking routines. Enabling these means that decNumber */ 303 /* and decContext operands to operator routines are checked for */ 304 /* correctness. This roughly doubles the execution time of the */ 305 /* fastest routines (and adds 600+ bytes), so should not normally be */ 306 /* used in 'production'. */ 307 /* decCheckInexact is used to check that inexact results have a full */ 308 /* complement of digits (where appropriate -- this is not the case */ 309 /* for Quantize, for example) */ 310 #define DECUNRESU ((decNumber *)(void *)0xffffffff) 311 #define DECUNUSED ((const decNumber *)(void *)0xffffffff) 312 #define DECUNCONT ((decContext *)(void *)(0xffffffff)) 313 static Flag decCheckOperands(decNumber *, const decNumber *, 314 const decNumber *, decContext *); 315 static Flag decCheckNumber(const decNumber *); 316 static void decCheckInexact(const decNumber *, decContext *); 317 #endif 318 319 #if DECTRACE || DECCHECK 320 /* Optional trace/debugging routines (may or may not be used) */ 321 void decNumberShow(const decNumber *); /* displays the components of a number */ 322 static void decDumpAr(char, const Unit *, Int); 323 #endif 324 325 /* ================================================================== */ 326 /* Conversions */ 327 /* ================================================================== */ 328 329 /* ------------------------------------------------------------------ */ 330 /* from-int32 -- conversion from Int or uInt */ 331 /* */ 332 /* dn is the decNumber to receive the integer */ 333 /* in or uin is the integer to be converted */ 334 /* returns dn */ 335 /* */ 336 /* No error is possible. */ 337 /* ------------------------------------------------------------------ */ 338 decNumber * decNumberFromInt32(decNumber *dn, Int in) { 339 uInt unsig; 340 if (in>=0) unsig=in; 341 else { /* negative (possibly BADINT) */ 342 if (in==BADINT) unsig=(uInt)1073741824*2; /* special case */ 343 else unsig=-in; /* invert */ 344 } 345 /* in is now positive */ 346 decNumberFromUInt32(dn, unsig); 347 if (in<0) dn->bits=DECNEG; /* sign needed */ 348 return dn; 349 } /* decNumberFromInt32 */ 350 351 decNumber * decNumberFromUInt32(decNumber *dn, uInt uin) { 352 Unit *up; /* work pointer */ 353 decNumberZero(dn); /* clean */ 354 if (uin==0) return dn; /* [or decGetDigits bad call] */ 355 for (up=dn->lsu; uin>0; up++) { 356 *up=(Unit)(uin%(DECDPUNMAX+1)); 357 uin=uin/(DECDPUNMAX+1); 358 } 359 dn->digits=decGetDigits(dn->lsu, up-dn->lsu); 360 return dn; 361 } /* decNumberFromUInt32 */ 362 363 /* ------------------------------------------------------------------ */ 364 /* to-int32 -- conversion to Int or uInt */ 365 /* */ 366 /* dn is the decNumber to convert */ 367 /* set is the context for reporting errors */ 368 /* returns the converted decNumber, or 0 if Invalid is set */ 369 /* */ 370 /* Invalid is set if the decNumber does not have exponent==0 or if */ 371 /* it is a NaN, Infinite, or out-of-range. */ 372 /* ------------------------------------------------------------------ */ 373 Int decNumberToInt32(const decNumber *dn, decContext *set) { 374 #if DECCHECK 375 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; 376 #endif 377 378 /* special or too many digits, or bad exponent */ 379 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; /* bad */ 380 else { /* is a finite integer with 10 or fewer digits */ 381 Int d; /* work */ 382 const Unit *up; /* .. */ 383 uInt hi=0, lo; /* .. */ 384 up=dn->lsu; /* -> lsu */ 385 lo=*up; /* get 1 to 9 digits */ 386 #if DECDPUN>1 /* split to higher */ 387 hi=lo/10; 388 lo=lo%10; 389 #endif 390 up++; 391 /* collect remaining Units, if any, into hi */ 392 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1]; 393 /* now low has the lsd, hi the remainder */ 394 if (hi>214748364 || (hi==214748364 && lo>7)) { /* out of range? */ 395 /* most-negative is a reprieve */ 396 if (dn->bits&DECNEG && hi==214748364 && lo==8) return 0x80000000; 397 /* bad -- drop through */ 398 } 399 else { /* in-range always */ 400 Int i=X10(hi)+lo; 401 if (dn->bits&DECNEG) return -i; 402 return i; 403 } 404 } /* integer */ 405 decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */ 406 return 0; 407 } /* decNumberToInt32 */ 408 409 uInt decNumberToUInt32(const decNumber *dn, decContext *set) { 410 #if DECCHECK 411 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; 412 #endif 413 /* special or too many digits, or bad exponent, or negative (<0) */ 414 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0 415 || (dn->bits&DECNEG && !ISZERO(dn))); /* bad */ 416 else { /* is a finite integer with 10 or fewer digits */ 417 Int d; /* work */ 418 const Unit *up; /* .. */ 419 uInt hi=0, lo; /* .. */ 420 up=dn->lsu; /* -> lsu */ 421 lo=*up; /* get 1 to 9 digits */ 422 #if DECDPUN>1 /* split to higher */ 423 hi=lo/10; 424 lo=lo%10; 425 #endif 426 up++; 427 /* collect remaining Units, if any, into hi */ 428 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1]; 429 430 /* now low has the lsd, hi the remainder */ 431 if (hi>429496729 || (hi==429496729 && lo>5)) ; /* no reprieve possible */ 432 else return X10(hi)+lo; 433 } /* integer */ 434 decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */ 435 return 0; 436 } /* decNumberToUInt32 */ 437 438 decNumber *decNumberFromInt64(decNumber *dn, int64_t in) 439 { 440 uint64_t unsig = in; 441 if (in < 0) { 442 unsig = -unsig; 443 } 444 445 decNumberFromUInt64(dn, unsig); 446 if (in < 0) { 447 dn->bits = DECNEG; /* sign needed */ 448 } 449 return dn; 450 } /* decNumberFromInt64 */ 451 452 decNumber *decNumberFromUInt64(decNumber *dn, uint64_t uin) 453 { 454 Unit *up; /* work pointer */ 455 decNumberZero(dn); /* clean */ 456 if (uin == 0) { 457 return dn; /* [or decGetDigits bad call] */ 458 } 459 for (up = dn->lsu; uin > 0; up++) { 460 *up = (Unit)(uin % (DECDPUNMAX + 1)); 461 uin = uin / (DECDPUNMAX + 1); 462 } 463 dn->digits = decGetDigits(dn->lsu, up-dn->lsu); 464 return dn; 465 } /* decNumberFromUInt64 */ 466 467 decNumber *decNumberFromInt128(decNumber *dn, uint64_t lo, int64_t hi) 468 { 469 uint64_t unsig_hi = hi; 470 if (hi < 0) { 471 if (lo == 0) { 472 unsig_hi = -unsig_hi; 473 } else { 474 unsig_hi = ~unsig_hi; 475 lo = -lo; 476 } 477 } 478 479 decNumberFromUInt128(dn, lo, unsig_hi); 480 if (hi < 0) { 481 dn->bits = DECNEG; /* sign needed */ 482 } 483 return dn; 484 } /* decNumberFromInt128 */ 485 486 decNumber *decNumberFromUInt128(decNumber *dn, uint64_t lo, uint64_t hi) 487 { 488 uint64_t rem; 489 Unit *up; /* work pointer */ 490 decNumberZero(dn); /* clean */ 491 if (lo == 0 && hi == 0) { 492 return dn; /* [or decGetDigits bad call] */ 493 } 494 for (up = dn->lsu; hi > 0 || lo > 0; up++) { 495 rem = divu128(&lo, &hi, DECDPUNMAX + 1); 496 *up = (Unit)rem; 497 } 498 dn->digits = decGetDigits(dn->lsu, up - dn->lsu); 499 return dn; 500 } /* decNumberFromUInt128 */ 501 502 /* ------------------------------------------------------------------ */ 503 /* to-int64 -- conversion to int64 */ 504 /* */ 505 /* dn is the decNumber to convert. dn is assumed to have been */ 506 /* rounded to a floating point integer value. */ 507 /* set is the context for reporting errors */ 508 /* returns the converted decNumber, or 0 if Invalid is set */ 509 /* */ 510 /* Invalid is set if the decNumber is a NaN, Infinite or is out of */ 511 /* range for a signed 64 bit integer. */ 512 /* ------------------------------------------------------------------ */ 513 514 int64_t decNumberIntegralToInt64(const decNumber *dn, decContext *set) 515 { 516 if (decNumberIsSpecial(dn) || (dn->exponent < 0) || 517 (dn->digits + dn->exponent > 19)) { 518 goto Invalid; 519 } else { 520 int64_t d; /* work */ 521 const Unit *up; /* .. */ 522 uint64_t hi = 0; 523 up = dn->lsu; /* -> lsu */ 524 525 for (d = 1; d <= dn->digits; up++, d += DECDPUN) { 526 uint64_t prev = hi; 527 hi += *up * powers[d-1]; 528 if ((hi < prev) || (hi > INT64_MAX)) { 529 goto Invalid; 530 } 531 } 532 533 uint64_t prev = hi; 534 hi *= (uint64_t)powers[dn->exponent]; 535 if ((hi < prev) || (hi > INT64_MAX)) { 536 goto Invalid; 537 } 538 return (decNumberIsNegative(dn)) ? -((int64_t)hi) : (int64_t)hi; 539 } 540 541 Invalid: 542 decContextSetStatus(set, DEC_Invalid_operation); 543 return 0; 544 } /* decNumberIntegralToInt64 */ 545 546 /* ------------------------------------------------------------------ */ 547 /* decNumberIntegralToInt128 -- conversion to int128 */ 548 /* */ 549 /* dn is the decNumber to convert. dn is assumed to have been */ 550 /* rounded to a floating point integer value. */ 551 /* set is the context for reporting errors */ 552 /* returns the converted decNumber via plow and phigh */ 553 /* */ 554 /* Invalid is set if the decNumber is a NaN, Infinite or is out of */ 555 /* range for a signed 128 bit integer. */ 556 /* ------------------------------------------------------------------ */ 557 558 void decNumberIntegralToInt128(const decNumber *dn, decContext *set, 559 uint64_t *plow, uint64_t *phigh) 560 { 561 int d; /* work */ 562 const Unit *up; /* .. */ 563 uint64_t lo = 0, hi = 0; 564 565 if (decNumberIsSpecial(dn) || (dn->exponent < 0) || 566 (dn->digits + dn->exponent > 39)) { 567 goto Invalid; 568 } 569 570 up = dn->lsu; /* -> lsu */ 571 572 for (d = (dn->digits - 1) / DECDPUN; d >= 0; d--) { 573 if (mulu128(&lo, &hi, DECDPUNMAX + 1)) { 574 /* overflow */ 575 goto Invalid; 576 } 577 if (uadd64_overflow(lo, up[d], &lo)) { 578 if (uadd64_overflow(hi, 1, &hi)) { 579 /* overflow */ 580 goto Invalid; 581 } 582 } 583 } 584 585 if (mulUInt128ByPowOf10(&lo, &hi, dn->exponent)) { 586 /* overflow */ 587 goto Invalid; 588 } 589 590 if (decNumberIsNegative(dn)) { 591 if (lo == 0) { 592 *phigh = -hi; 593 *plow = 0; 594 } else { 595 *phigh = ~hi; 596 *plow = -lo; 597 } 598 } else { 599 *plow = lo; 600 *phigh = hi; 601 } 602 603 return; 604 605 Invalid: 606 decContextSetStatus(set, DEC_Invalid_operation); 607 } /* decNumberIntegralToInt128 */ 608 609 /* ------------------------------------------------------------------ */ 610 /* to-scientific-string -- conversion to numeric string */ 611 /* to-engineering-string -- conversion to numeric string */ 612 /* */ 613 /* decNumberToString(dn, string); */ 614 /* decNumberToEngString(dn, string); */ 615 /* */ 616 /* dn is the decNumber to convert */ 617 /* string is the string where the result will be laid out */ 618 /* */ 619 /* string must be at least dn->digits+14 characters long */ 620 /* */ 621 /* No error is possible, and no status can be set. */ 622 /* ------------------------------------------------------------------ */ 623 char * decNumberToString(const decNumber *dn, char *string){ 624 decToString(dn, string, 0); 625 return string; 626 } /* DecNumberToString */ 627 628 char * decNumberToEngString(const decNumber *dn, char *string){ 629 decToString(dn, string, 1); 630 return string; 631 } /* DecNumberToEngString */ 632 633 /* ------------------------------------------------------------------ */ 634 /* to-number -- conversion from numeric string */ 635 /* */ 636 /* decNumberFromString -- convert string to decNumber */ 637 /* dn -- the number structure to fill */ 638 /* chars[] -- the string to convert ('\0' terminated) */ 639 /* set -- the context used for processing any error, */ 640 /* determining the maximum precision available */ 641 /* (set.digits), determining the maximum and minimum */ 642 /* exponent (set.emax and set.emin), determining if */ 643 /* extended values are allowed, and checking the */ 644 /* rounding mode if overflow occurs or rounding is */ 645 /* needed. */ 646 /* */ 647 /* The length of the coefficient and the size of the exponent are */ 648 /* checked by this routine, so the correct error (Underflow or */ 649 /* Overflow) can be reported or rounding applied, as necessary. */ 650 /* */ 651 /* If bad syntax is detected, the result will be a quiet NaN. */ 652 /* ------------------------------------------------------------------ */ 653 decNumber * decNumberFromString(decNumber *dn, const char chars[], 654 decContext *set) { 655 Int exponent=0; /* working exponent [assume 0] */ 656 uByte bits=0; /* working flags [assume +ve] */ 657 Unit *res; /* where result will be built */ 658 Unit resbuff[SD2U(DECBUFFER+9)];/* local buffer in case need temporary */ 659 /* [+9 allows for ln() constants] */ 660 Unit *allocres=NULL; /* -> allocated result, iff allocated */ 661 Int d=0; /* count of digits found in decimal part */ 662 const char *dotchar=NULL; /* where dot was found */ 663 const char *cfirst=chars; /* -> first character of decimal part */ 664 const char *last=NULL; /* -> last digit of decimal part */ 665 const char *c; /* work */ 666 Unit *up; /* .. */ 667 #if DECDPUN>1 668 Int cut, out; /* .. */ 669 #endif 670 Int residue; /* rounding residue */ 671 uInt status=0; /* error code */ 672 673 #if DECCHECK 674 if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set)) 675 return decNumberZero(dn); 676 #endif 677 678 do { /* status & malloc protection */ 679 for (c=chars;; c++) { /* -> input character */ 680 if (*c>='0' && *c<='9') { /* test for Arabic digit */ 681 last=c; 682 d++; /* count of real digits */ 683 continue; /* still in decimal part */ 684 } 685 if (*c=='.' && dotchar==NULL) { /* first '.' */ 686 dotchar=c; /* record offset into decimal part */ 687 if (c==cfirst) cfirst++; /* first digit must follow */ 688 continue;} 689 if (c==chars) { /* first in string... */ 690 if (*c=='-') { /* valid - sign */ 691 cfirst++; 692 bits=DECNEG; 693 continue;} 694 if (*c=='+') { /* valid + sign */ 695 cfirst++; 696 continue;} 697 } 698 /* *c is not a digit, or a valid +, -, or '.' */ 699 break; 700 } /* c */ 701 702 if (last==NULL) { /* no digits yet */ 703 status=DEC_Conversion_syntax;/* assume the worst */ 704 if (*c=='\0') break; /* and no more to come... */ 705 #if DECSUBSET 706 /* if subset then infinities and NaNs are not allowed */ 707 if (!set->extended) break; /* hopeless */ 708 #endif 709 /* Infinities and NaNs are possible, here */ 710 if (dotchar!=NULL) break; /* .. unless had a dot */ 711 decNumberZero(dn); /* be optimistic */ 712 if (decBiStr(c, "infinity", "INFINITY") 713 || decBiStr(c, "inf", "INF")) { 714 dn->bits=bits | DECINF; 715 status=0; /* is OK */ 716 break; /* all done */ 717 } 718 /* a NaN expected */ 719 /* 2003.09.10 NaNs are now permitted to have a sign */ 720 dn->bits=bits | DECNAN; /* assume simple NaN */ 721 if (*c=='s' || *c=='S') { /* looks like an sNaN */ 722 c++; 723 dn->bits=bits | DECSNAN; 724 } 725 if (*c!='n' && *c!='N') break; /* check caseless "NaN" */ 726 c++; 727 if (*c!='a' && *c!='A') break; /* .. */ 728 c++; 729 if (*c!='n' && *c!='N') break; /* .. */ 730 c++; 731 /* now either nothing, or nnnn payload, expected */ 732 /* -> start of integer and skip leading 0s [including plain 0] */ 733 for (cfirst=c; *cfirst=='0';) cfirst++; 734 if (*cfirst=='\0') { /* "NaN" or "sNaN", maybe with all 0s */ 735 status=0; /* it's good */ 736 break; /* .. */ 737 } 738 /* something other than 0s; setup last and d as usual [no dots] */ 739 for (c=cfirst;; c++, d++) { 740 if (*c<'0' || *c>'9') break; /* test for Arabic digit */ 741 last=c; 742 } 743 if (*c!='\0') break; /* not all digits */ 744 if (d>set->digits-1) { 745 /* [NB: payload in a decNumber can be full length unless */ 746 /* clamped, in which case can only be digits-1] */ 747 if (set->clamp) break; 748 if (d>set->digits) break; 749 } /* too many digits? */ 750 /* good; drop through to convert the integer to coefficient */ 751 status=0; /* syntax is OK */ 752 bits=dn->bits; /* for copy-back */ 753 } /* last==NULL */ 754 755 else if (*c!='\0') { /* more to process... */ 756 /* had some digits; exponent is only valid sequence now */ 757 Flag nege; /* 1=negative exponent */ 758 const char *firstexp; /* -> first significant exponent digit */ 759 status=DEC_Conversion_syntax;/* assume the worst */ 760 if (*c!='e' && *c!='E') break; 761 /* Found 'e' or 'E' -- now process explicit exponent */ 762 /* 1998.07.11: sign no longer required */ 763 nege=0; 764 c++; /* to (possible) sign */ 765 if (*c=='-') {nege=1; c++;} 766 else if (*c=='+') c++; 767 if (*c=='\0') break; 768 769 for (; *c=='0' && *(c+1)!='\0';) c++; /* strip insignificant zeros */ 770 firstexp=c; /* save exponent digit place */ 771 for (; ;c++) { 772 if (*c<'0' || *c>'9') break; /* not a digit */ 773 exponent=X10(exponent)+(Int)*c-(Int)'0'; 774 } /* c */ 775 /* if not now on a '\0', *c must not be a digit */ 776 if (*c!='\0') break; 777 778 /* (this next test must be after the syntax checks) */ 779 /* if it was too long the exponent may have wrapped, so check */ 780 /* carefully and set it to a certain overflow if wrap possible */ 781 if (c>=firstexp+9+1) { 782 if (c>firstexp+9+1 || *firstexp>'1') exponent=DECNUMMAXE*2; 783 /* [up to 1999999999 is OK, for example 1E-1000000998] */ 784 } 785 if (nege) exponent=-exponent; /* was negative */ 786 status=0; /* is OK */ 787 } /* stuff after digits */ 788 789 /* Here when whole string has been inspected; syntax is good */ 790 /* cfirst->first digit (never dot), last->last digit (ditto) */ 791 792 /* strip leading zeros/dot [leave final 0 if all 0's] */ 793 if (*cfirst=='0') { /* [cfirst has stepped over .] */ 794 for (c=cfirst; c<last; c++, cfirst++) { 795 if (*c=='.') continue; /* ignore dots */ 796 if (*c!='0') break; /* non-zero found */ 797 d--; /* 0 stripped */ 798 } /* c */ 799 #if DECSUBSET 800 /* make a rapid exit for easy zeros if !extended */ 801 if (*cfirst=='0' && !set->extended) { 802 decNumberZero(dn); /* clean result */ 803 break; /* [could be return] */ 804 } 805 #endif 806 } /* at least one leading 0 */ 807 808 /* Handle decimal point... */ 809 if (dotchar!=NULL && dotchar<last) /* non-trailing '.' found? */ 810 exponent-=(last-dotchar); /* adjust exponent */ 811 /* [we can now ignore the .] */ 812 813 /* OK, the digits string is good. Assemble in the decNumber, or in */ 814 /* a temporary units array if rounding is needed */ 815 if (d<=set->digits) res=dn->lsu; /* fits into supplied decNumber */ 816 else { /* rounding needed */ 817 Int needbytes=D2U(d)*sizeof(Unit);/* bytes needed */ 818 res=resbuff; /* assume use local buffer */ 819 if (needbytes>(Int)sizeof(resbuff)) { /* too big for local */ 820 allocres=(Unit *)malloc(needbytes); 821 if (allocres==NULL) {status|=DEC_Insufficient_storage; break;} 822 res=allocres; 823 } 824 } 825 /* res now -> number lsu, buffer, or allocated storage for Unit array */ 826 827 /* Place the coefficient into the selected Unit array */ 828 /* [this is often 70% of the cost of this function when DECDPUN>1] */ 829 #if DECDPUN>1 830 out=0; /* accumulator */ 831 up=res+D2U(d)-1; /* -> msu */ 832 cut=d-(up-res)*DECDPUN; /* digits in top unit */ 833 for (c=cfirst;; c++) { /* along the digits */ 834 if (*c=='.') continue; /* ignore '.' [don't decrement cut] */ 835 out=X10(out)+(Int)*c-(Int)'0'; 836 if (c==last) break; /* done [never get to trailing '.'] */ 837 cut--; 838 if (cut>0) continue; /* more for this unit */ 839 *up=(Unit)out; /* write unit */ 840 up--; /* prepare for unit below.. */ 841 cut=DECDPUN; /* .. */ 842 out=0; /* .. */ 843 } /* c */ 844 *up=(Unit)out; /* write lsu */ 845 846 #else 847 /* DECDPUN==1 */ 848 up=res; /* -> lsu */ 849 for (c=last; c>=cfirst; c--) { /* over each character, from least */ 850 if (*c=='.') continue; /* ignore . [don't step up] */ 851 *up=(Unit)((Int)*c-(Int)'0'); 852 up++; 853 } /* c */ 854 #endif 855 856 dn->bits=bits; 857 dn->exponent=exponent; 858 dn->digits=d; 859 860 /* if not in number (too long) shorten into the number */ 861 if (d>set->digits) { 862 residue=0; 863 decSetCoeff(dn, set, res, d, &residue, &status); 864 /* always check for overflow or subnormal and round as needed */ 865 decFinalize(dn, set, &residue, &status); 866 } 867 else { /* no rounding, but may still have overflow or subnormal */ 868 /* [these tests are just for performance; finalize repeats them] */ 869 if ((dn->exponent-1<set->emin-dn->digits) 870 || (dn->exponent-1>set->emax-set->digits)) { 871 residue=0; 872 decFinalize(dn, set, &residue, &status); 873 } 874 } 875 /* decNumberShow(dn); */ 876 } while(0); /* [for break] */ 877 878 if (allocres!=NULL) free(allocres); /* drop any storage used */ 879 if (status!=0) decStatus(dn, status, set); 880 return dn; 881 } /* decNumberFromString */ 882 883 /* ================================================================== */ 884 /* Operators */ 885 /* ================================================================== */ 886 887 /* ------------------------------------------------------------------ */ 888 /* decNumberAbs -- absolute value operator */ 889 /* */ 890 /* This computes C = abs(A) */ 891 /* */ 892 /* res is C, the result. C may be A */ 893 /* rhs is A */ 894 /* set is the context */ 895 /* */ 896 /* See also decNumberCopyAbs for a quiet bitwise version of this. */ 897 /* C must have space for set->digits digits. */ 898 /* ------------------------------------------------------------------ */ 899 /* This has the same effect as decNumberPlus unless A is negative, */ 900 /* in which case it has the same effect as decNumberMinus. */ 901 /* ------------------------------------------------------------------ */ 902 decNumber * decNumberAbs(decNumber *res, const decNumber *rhs, 903 decContext *set) { 904 decNumber dzero; /* for 0 */ 905 uInt status=0; /* accumulator */ 906 907 #if DECCHECK 908 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 909 #endif 910 911 decNumberZero(&dzero); /* set 0 */ 912 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */ 913 decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status); 914 if (status!=0) decStatus(res, status, set); 915 #if DECCHECK 916 decCheckInexact(res, set); 917 #endif 918 return res; 919 } /* decNumberAbs */ 920 921 /* ------------------------------------------------------------------ */ 922 /* decNumberAdd -- add two Numbers */ 923 /* */ 924 /* This computes C = A + B */ 925 /* */ 926 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */ 927 /* lhs is A */ 928 /* rhs is B */ 929 /* set is the context */ 930 /* */ 931 /* C must have space for set->digits digits. */ 932 /* ------------------------------------------------------------------ */ 933 /* This just calls the routine shared with Subtract */ 934 decNumber * decNumberAdd(decNumber *res, const decNumber *lhs, 935 const decNumber *rhs, decContext *set) { 936 uInt status=0; /* accumulator */ 937 decAddOp(res, lhs, rhs, set, 0, &status); 938 if (status!=0) decStatus(res, status, set); 939 #if DECCHECK 940 decCheckInexact(res, set); 941 #endif 942 return res; 943 } /* decNumberAdd */ 944 945 /* ------------------------------------------------------------------ */ 946 /* decNumberAnd -- AND two Numbers, digitwise */ 947 /* */ 948 /* This computes C = A & B */ 949 /* */ 950 /* res is C, the result. C may be A and/or B (e.g., X=X&X) */ 951 /* lhs is A */ 952 /* rhs is B */ 953 /* set is the context (used for result length and error report) */ 954 /* */ 955 /* C must have space for set->digits digits. */ 956 /* */ 957 /* Logical function restrictions apply (see above); a NaN is */ 958 /* returned with Invalid_operation if a restriction is violated. */ 959 /* ------------------------------------------------------------------ */ 960 decNumber * decNumberAnd(decNumber *res, const decNumber *lhs, 961 const decNumber *rhs, decContext *set) { 962 const Unit *ua, *ub; /* -> operands */ 963 const Unit *msua, *msub; /* -> operand msus */ 964 Unit *uc, *msuc; /* -> result and its msu */ 965 Int msudigs; /* digits in res msu */ 966 #if DECCHECK 967 if (decCheckOperands(res, lhs, rhs, set)) return res; 968 #endif 969 970 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs) 971 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { 972 decStatus(res, DEC_Invalid_operation, set); 973 return res; 974 } 975 976 /* operands are valid */ 977 ua=lhs->lsu; /* bottom-up */ 978 ub=rhs->lsu; /* .. */ 979 uc=res->lsu; /* .. */ 980 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */ 981 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ 982 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ 983 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ 984 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */ 985 Unit a, b; /* extract units */ 986 if (ua>msua) a=0; 987 else a=*ua; 988 if (ub>msub) b=0; 989 else b=*ub; 990 *uc=0; /* can now write back */ 991 if (a|b) { /* maybe 1 bits to examine */ 992 Int i, j; 993 *uc=0; /* can now write back */ 994 /* This loop could be unrolled and/or use BIN2BCD tables */ 995 for (i=0; i<DECDPUN; i++) { 996 if (a&b&1) *uc=*uc+(Unit)powers[i]; /* effect AND */ 997 j=a%10; 998 a=a/10; 999 j|=b%10; 1000 b=b/10; 1001 if (j>1) { 1002 decStatus(res, DEC_Invalid_operation, set); 1003 return res; 1004 } 1005 if (uc==msuc && i==msudigs-1) break; /* just did final digit */ 1006 } /* each digit */ 1007 } /* both OK */ 1008 } /* each unit */ 1009 /* [here uc-1 is the msu of the result] */ 1010 res->digits=decGetDigits(res->lsu, uc-res->lsu); 1011 res->exponent=0; /* integer */ 1012 res->bits=0; /* sign=0 */ 1013 return res; /* [no status to set] */ 1014 } /* decNumberAnd */ 1015 1016 /* ------------------------------------------------------------------ */ 1017 /* decNumberCompare -- compare two Numbers */ 1018 /* */ 1019 /* This computes C = A ? B */ 1020 /* */ 1021 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1022 /* lhs is A */ 1023 /* rhs is B */ 1024 /* set is the context */ 1025 /* */ 1026 /* C must have space for one digit (or NaN). */ 1027 /* ------------------------------------------------------------------ */ 1028 decNumber * decNumberCompare(decNumber *res, const decNumber *lhs, 1029 const decNumber *rhs, decContext *set) { 1030 uInt status=0; /* accumulator */ 1031 decCompareOp(res, lhs, rhs, set, COMPARE, &status); 1032 if (status!=0) decStatus(res, status, set); 1033 return res; 1034 } /* decNumberCompare */ 1035 1036 /* ------------------------------------------------------------------ */ 1037 /* decNumberCompareSignal -- compare, signalling on all NaNs */ 1038 /* */ 1039 /* This computes C = A ? B */ 1040 /* */ 1041 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1042 /* lhs is A */ 1043 /* rhs is B */ 1044 /* set is the context */ 1045 /* */ 1046 /* C must have space for one digit (or NaN). */ 1047 /* ------------------------------------------------------------------ */ 1048 decNumber * decNumberCompareSignal(decNumber *res, const decNumber *lhs, 1049 const decNumber *rhs, decContext *set) { 1050 uInt status=0; /* accumulator */ 1051 decCompareOp(res, lhs, rhs, set, COMPSIG, &status); 1052 if (status!=0) decStatus(res, status, set); 1053 return res; 1054 } /* decNumberCompareSignal */ 1055 1056 /* ------------------------------------------------------------------ */ 1057 /* decNumberCompareTotal -- compare two Numbers, using total ordering */ 1058 /* */ 1059 /* This computes C = A ? B, under total ordering */ 1060 /* */ 1061 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1062 /* lhs is A */ 1063 /* rhs is B */ 1064 /* set is the context */ 1065 /* */ 1066 /* C must have space for one digit; the result will always be one of */ 1067 /* -1, 0, or 1. */ 1068 /* ------------------------------------------------------------------ */ 1069 decNumber * decNumberCompareTotal(decNumber *res, const decNumber *lhs, 1070 const decNumber *rhs, decContext *set) { 1071 uInt status=0; /* accumulator */ 1072 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status); 1073 if (status!=0) decStatus(res, status, set); 1074 return res; 1075 } /* decNumberCompareTotal */ 1076 1077 /* ------------------------------------------------------------------ */ 1078 /* decNumberCompareTotalMag -- compare, total ordering of magnitudes */ 1079 /* */ 1080 /* This computes C = |A| ? |B|, under total ordering */ 1081 /* */ 1082 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1083 /* lhs is A */ 1084 /* rhs is B */ 1085 /* set is the context */ 1086 /* */ 1087 /* C must have space for one digit; the result will always be one of */ 1088 /* -1, 0, or 1. */ 1089 /* ------------------------------------------------------------------ */ 1090 decNumber * decNumberCompareTotalMag(decNumber *res, const decNumber *lhs, 1091 const decNumber *rhs, decContext *set) { 1092 uInt status=0; /* accumulator */ 1093 uInt needbytes; /* for space calculations */ 1094 decNumber bufa[D2N(DECBUFFER+1)];/* +1 in case DECBUFFER=0 */ 1095 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 1096 decNumber bufb[D2N(DECBUFFER+1)]; 1097 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */ 1098 decNumber *a, *b; /* temporary pointers */ 1099 1100 #if DECCHECK 1101 if (decCheckOperands(res, lhs, rhs, set)) return res; 1102 #endif 1103 1104 do { /* protect allocated storage */ 1105 /* if either is negative, take a copy and absolute */ 1106 if (decNumberIsNegative(lhs)) { /* lhs<0 */ 1107 a=bufa; 1108 needbytes=sizeof(decNumber)+(D2U(lhs->digits)-1)*sizeof(Unit); 1109 if (needbytes>sizeof(bufa)) { /* need malloc space */ 1110 allocbufa=(decNumber *)malloc(needbytes); 1111 if (allocbufa==NULL) { /* hopeless -- abandon */ 1112 status|=DEC_Insufficient_storage; 1113 break;} 1114 a=allocbufa; /* use the allocated space */ 1115 } 1116 decNumberCopy(a, lhs); /* copy content */ 1117 a->bits&=~DECNEG; /* .. and clear the sign */ 1118 lhs=a; /* use copy from here on */ 1119 } 1120 if (decNumberIsNegative(rhs)) { /* rhs<0 */ 1121 b=bufb; 1122 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); 1123 if (needbytes>sizeof(bufb)) { /* need malloc space */ 1124 allocbufb=(decNumber *)malloc(needbytes); 1125 if (allocbufb==NULL) { /* hopeless -- abandon */ 1126 status|=DEC_Insufficient_storage; 1127 break;} 1128 b=allocbufb; /* use the allocated space */ 1129 } 1130 decNumberCopy(b, rhs); /* copy content */ 1131 b->bits&=~DECNEG; /* .. and clear the sign */ 1132 rhs=b; /* use copy from here on */ 1133 } 1134 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status); 1135 } while(0); /* end protected */ 1136 1137 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */ 1138 if (allocbufb!=NULL) free(allocbufb); /* .. */ 1139 if (status!=0) decStatus(res, status, set); 1140 return res; 1141 } /* decNumberCompareTotalMag */ 1142 1143 /* ------------------------------------------------------------------ */ 1144 /* decNumberDivide -- divide one number by another */ 1145 /* */ 1146 /* This computes C = A / B */ 1147 /* */ 1148 /* res is C, the result. C may be A and/or B (e.g., X=X/X) */ 1149 /* lhs is A */ 1150 /* rhs is B */ 1151 /* set is the context */ 1152 /* */ 1153 /* C must have space for set->digits digits. */ 1154 /* ------------------------------------------------------------------ */ 1155 decNumber * decNumberDivide(decNumber *res, const decNumber *lhs, 1156 const decNumber *rhs, decContext *set) { 1157 uInt status=0; /* accumulator */ 1158 decDivideOp(res, lhs, rhs, set, DIVIDE, &status); 1159 if (status!=0) decStatus(res, status, set); 1160 #if DECCHECK 1161 decCheckInexact(res, set); 1162 #endif 1163 return res; 1164 } /* decNumberDivide */ 1165 1166 /* ------------------------------------------------------------------ */ 1167 /* decNumberDivideInteger -- divide and return integer quotient */ 1168 /* */ 1169 /* This computes C = A # B, where # is the integer divide operator */ 1170 /* */ 1171 /* res is C, the result. C may be A and/or B (e.g., X=X#X) */ 1172 /* lhs is A */ 1173 /* rhs is B */ 1174 /* set is the context */ 1175 /* */ 1176 /* C must have space for set->digits digits. */ 1177 /* ------------------------------------------------------------------ */ 1178 decNumber * decNumberDivideInteger(decNumber *res, const decNumber *lhs, 1179 const decNumber *rhs, decContext *set) { 1180 uInt status=0; /* accumulator */ 1181 decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status); 1182 if (status!=0) decStatus(res, status, set); 1183 return res; 1184 } /* decNumberDivideInteger */ 1185 1186 /* ------------------------------------------------------------------ */ 1187 /* decNumberExp -- exponentiation */ 1188 /* */ 1189 /* This computes C = exp(A) */ 1190 /* */ 1191 /* res is C, the result. C may be A */ 1192 /* rhs is A */ 1193 /* set is the context; note that rounding mode has no effect */ 1194 /* */ 1195 /* C must have space for set->digits digits. */ 1196 /* */ 1197 /* Mathematical function restrictions apply (see above); a NaN is */ 1198 /* returned with Invalid_operation if a restriction is violated. */ 1199 /* */ 1200 /* Finite results will always be full precision and Inexact, except */ 1201 /* when A is a zero or -Infinity (giving 1 or 0 respectively). */ 1202 /* */ 1203 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */ 1204 /* almost always be correctly rounded, but may be up to 1 ulp in */ 1205 /* error in rare cases. */ 1206 /* ------------------------------------------------------------------ */ 1207 /* This is a wrapper for decExpOp which can handle the slightly wider */ 1208 /* (double) range needed by Ln (which has to be able to calculate */ 1209 /* exp(-a) where a can be the tiniest number (Ntiny). */ 1210 /* ------------------------------------------------------------------ */ 1211 decNumber * decNumberExp(decNumber *res, const decNumber *rhs, 1212 decContext *set) { 1213 uInt status=0; /* accumulator */ 1214 #if DECSUBSET 1215 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 1216 #endif 1217 1218 #if DECCHECK 1219 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1220 #endif 1221 1222 /* Check restrictions; these restrictions ensure that if h=8 (see */ 1223 /* decExpOp) then the result will either overflow or underflow to 0. */ 1224 /* Other math functions restrict the input range, too, for inverses. */ 1225 /* If not violated then carry out the operation. */ 1226 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */ 1227 #if DECSUBSET 1228 if (!set->extended) { 1229 /* reduce operand and set lostDigits status, as needed */ 1230 if (rhs->digits>set->digits) { 1231 allocrhs=decRoundOperand(rhs, set, &status); 1232 if (allocrhs==NULL) break; 1233 rhs=allocrhs; 1234 } 1235 } 1236 #endif 1237 decExpOp(res, rhs, set, &status); 1238 } while(0); /* end protected */ 1239 1240 #if DECSUBSET 1241 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */ 1242 #endif 1243 /* apply significant status */ 1244 if (status!=0) decStatus(res, status, set); 1245 #if DECCHECK 1246 decCheckInexact(res, set); 1247 #endif 1248 return res; 1249 } /* decNumberExp */ 1250 1251 /* ------------------------------------------------------------------ */ 1252 /* decNumberFMA -- fused multiply add */ 1253 /* */ 1254 /* This computes D = (A * B) + C with only one rounding */ 1255 /* */ 1256 /* res is D, the result. D may be A or B or C (e.g., X=FMA(X,X,X)) */ 1257 /* lhs is A */ 1258 /* rhs is B */ 1259 /* fhs is C [far hand side] */ 1260 /* set is the context */ 1261 /* */ 1262 /* Mathematical function restrictions apply (see above); a NaN is */ 1263 /* returned with Invalid_operation if a restriction is violated. */ 1264 /* */ 1265 /* C must have space for set->digits digits. */ 1266 /* ------------------------------------------------------------------ */ 1267 decNumber * decNumberFMA(decNumber *res, const decNumber *lhs, 1268 const decNumber *rhs, const decNumber *fhs, 1269 decContext *set) { 1270 uInt status=0; /* accumulator */ 1271 decContext dcmul; /* context for the multiplication */ 1272 uInt needbytes; /* for space calculations */ 1273 decNumber bufa[D2N(DECBUFFER*2+1)]; 1274 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 1275 decNumber *acc; /* accumulator pointer */ 1276 decNumber dzero; /* work */ 1277 1278 #if DECCHECK 1279 if (decCheckOperands(res, lhs, rhs, set)) return res; 1280 if (decCheckOperands(res, fhs, DECUNUSED, set)) return res; 1281 #endif 1282 1283 do { /* protect allocated storage */ 1284 #if DECSUBSET 1285 if (!set->extended) { /* [undefined if subset] */ 1286 status|=DEC_Invalid_operation; 1287 break;} 1288 #endif 1289 /* Check math restrictions [these ensure no overflow or underflow] */ 1290 if ((!decNumberIsSpecial(lhs) && decCheckMath(lhs, set, &status)) 1291 || (!decNumberIsSpecial(rhs) && decCheckMath(rhs, set, &status)) 1292 || (!decNumberIsSpecial(fhs) && decCheckMath(fhs, set, &status))) break; 1293 /* set up context for multiply */ 1294 dcmul=*set; 1295 dcmul.digits=lhs->digits+rhs->digits; /* just enough */ 1296 /* [The above may be an over-estimate for subset arithmetic, but that's OK] */ 1297 dcmul.emax=DEC_MAX_EMAX; /* effectively unbounded .. */ 1298 dcmul.emin=DEC_MIN_EMIN; /* [thanks to Math restrictions] */ 1299 /* set up decNumber space to receive the result of the multiply */ 1300 acc=bufa; /* may fit */ 1301 needbytes=sizeof(decNumber)+(D2U(dcmul.digits)-1)*sizeof(Unit); 1302 if (needbytes>sizeof(bufa)) { /* need malloc space */ 1303 allocbufa=(decNumber *)malloc(needbytes); 1304 if (allocbufa==NULL) { /* hopeless -- abandon */ 1305 status|=DEC_Insufficient_storage; 1306 break;} 1307 acc=allocbufa; /* use the allocated space */ 1308 } 1309 /* multiply with extended range and necessary precision */ 1310 /*printf("emin=%ld\n", dcmul.emin); */ 1311 decMultiplyOp(acc, lhs, rhs, &dcmul, &status); 1312 /* Only Invalid operation (from sNaN or Inf * 0) is possible in */ 1313 /* status; if either is seen than ignore fhs (in case it is */ 1314 /* another sNaN) and set acc to NaN unless we had an sNaN */ 1315 /* [decMultiplyOp leaves that to caller] */ 1316 /* Note sNaN has to go through addOp to shorten payload if */ 1317 /* necessary */ 1318 if ((status&DEC_Invalid_operation)!=0) { 1319 if (!(status&DEC_sNaN)) { /* but be true invalid */ 1320 decNumberZero(res); /* acc not yet set */ 1321 res->bits=DECNAN; 1322 break; 1323 } 1324 decNumberZero(&dzero); /* make 0 (any non-NaN would do) */ 1325 fhs=&dzero; /* use that */ 1326 } 1327 #if DECCHECK 1328 else { /* multiply was OK */ 1329 if (status!=0) printf("Status=%08lx after FMA multiply\n", status); 1330 } 1331 #endif 1332 /* add the third operand and result -> res, and all is done */ 1333 decAddOp(res, acc, fhs, set, 0, &status); 1334 } while(0); /* end protected */ 1335 1336 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */ 1337 if (status!=0) decStatus(res, status, set); 1338 #if DECCHECK 1339 decCheckInexact(res, set); 1340 #endif 1341 return res; 1342 } /* decNumberFMA */ 1343 1344 /* ------------------------------------------------------------------ */ 1345 /* decNumberInvert -- invert a Number, digitwise */ 1346 /* */ 1347 /* This computes C = ~A */ 1348 /* */ 1349 /* res is C, the result. C may be A (e.g., X=~X) */ 1350 /* rhs is A */ 1351 /* set is the context (used for result length and error report) */ 1352 /* */ 1353 /* C must have space for set->digits digits. */ 1354 /* */ 1355 /* Logical function restrictions apply (see above); a NaN is */ 1356 /* returned with Invalid_operation if a restriction is violated. */ 1357 /* ------------------------------------------------------------------ */ 1358 decNumber * decNumberInvert(decNumber *res, const decNumber *rhs, 1359 decContext *set) { 1360 const Unit *ua, *msua; /* -> operand and its msu */ 1361 Unit *uc, *msuc; /* -> result and its msu */ 1362 Int msudigs; /* digits in res msu */ 1363 #if DECCHECK 1364 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1365 #endif 1366 1367 if (rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { 1368 decStatus(res, DEC_Invalid_operation, set); 1369 return res; 1370 } 1371 /* operand is valid */ 1372 ua=rhs->lsu; /* bottom-up */ 1373 uc=res->lsu; /* .. */ 1374 msua=ua+D2U(rhs->digits)-1; /* -> msu of rhs */ 1375 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ 1376 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ 1377 for (; uc<=msuc; ua++, uc++) { /* Unit loop */ 1378 Unit a; /* extract unit */ 1379 Int i, j; /* work */ 1380 if (ua>msua) a=0; 1381 else a=*ua; 1382 *uc=0; /* can now write back */ 1383 /* always need to examine all bits in rhs */ 1384 /* This loop could be unrolled and/or use BIN2BCD tables */ 1385 for (i=0; i<DECDPUN; i++) { 1386 if ((~a)&1) *uc=*uc+(Unit)powers[i]; /* effect INVERT */ 1387 j=a%10; 1388 a=a/10; 1389 if (j>1) { 1390 decStatus(res, DEC_Invalid_operation, set); 1391 return res; 1392 } 1393 if (uc==msuc && i==msudigs-1) break; /* just did final digit */ 1394 } /* each digit */ 1395 } /* each unit */ 1396 /* [here uc-1 is the msu of the result] */ 1397 res->digits=decGetDigits(res->lsu, uc-res->lsu); 1398 res->exponent=0; /* integer */ 1399 res->bits=0; /* sign=0 */ 1400 return res; /* [no status to set] */ 1401 } /* decNumberInvert */ 1402 1403 /* ------------------------------------------------------------------ */ 1404 /* decNumberLn -- natural logarithm */ 1405 /* */ 1406 /* This computes C = ln(A) */ 1407 /* */ 1408 /* res is C, the result. C may be A */ 1409 /* rhs is A */ 1410 /* set is the context; note that rounding mode has no effect */ 1411 /* */ 1412 /* C must have space for set->digits digits. */ 1413 /* */ 1414 /* Notable cases: */ 1415 /* A<0 -> Invalid */ 1416 /* A=0 -> -Infinity (Exact) */ 1417 /* A=+Infinity -> +Infinity (Exact) */ 1418 /* A=1 exactly -> 0 (Exact) */ 1419 /* */ 1420 /* Mathematical function restrictions apply (see above); a NaN is */ 1421 /* returned with Invalid_operation if a restriction is violated. */ 1422 /* */ 1423 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */ 1424 /* almost always be correctly rounded, but may be up to 1 ulp in */ 1425 /* error in rare cases. */ 1426 /* ------------------------------------------------------------------ */ 1427 /* This is a wrapper for decLnOp which can handle the slightly wider */ 1428 /* (+11) range needed by Ln, Log10, etc. (which may have to be able */ 1429 /* to calculate at p+e+2). */ 1430 /* ------------------------------------------------------------------ */ 1431 decNumber * decNumberLn(decNumber *res, const decNumber *rhs, 1432 decContext *set) { 1433 uInt status=0; /* accumulator */ 1434 #if DECSUBSET 1435 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 1436 #endif 1437 1438 #if DECCHECK 1439 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1440 #endif 1441 1442 /* Check restrictions; this is a math function; if not violated */ 1443 /* then carry out the operation. */ 1444 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */ 1445 #if DECSUBSET 1446 if (!set->extended) { 1447 /* reduce operand and set lostDigits status, as needed */ 1448 if (rhs->digits>set->digits) { 1449 allocrhs=decRoundOperand(rhs, set, &status); 1450 if (allocrhs==NULL) break; 1451 rhs=allocrhs; 1452 } 1453 /* special check in subset for rhs=0 */ 1454 if (ISZERO(rhs)) { /* +/- zeros -> error */ 1455 status|=DEC_Invalid_operation; 1456 break;} 1457 } /* extended=0 */ 1458 #endif 1459 decLnOp(res, rhs, set, &status); 1460 } while(0); /* end protected */ 1461 1462 #if DECSUBSET 1463 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */ 1464 #endif 1465 /* apply significant status */ 1466 if (status!=0) decStatus(res, status, set); 1467 #if DECCHECK 1468 decCheckInexact(res, set); 1469 #endif 1470 return res; 1471 } /* decNumberLn */ 1472 1473 /* ------------------------------------------------------------------ */ 1474 /* decNumberLogB - get adjusted exponent, by 754r rules */ 1475 /* */ 1476 /* This computes C = adjustedexponent(A) */ 1477 /* */ 1478 /* res is C, the result. C may be A */ 1479 /* rhs is A */ 1480 /* set is the context, used only for digits and status */ 1481 /* */ 1482 /* C must have space for 10 digits (A might have 10**9 digits and */ 1483 /* an exponent of +999999999, or one digit and an exponent of */ 1484 /* -1999999999). */ 1485 /* */ 1486 /* This returns the adjusted exponent of A after (in theory) padding */ 1487 /* with zeros on the right to set->digits digits while keeping the */ 1488 /* same value. The exponent is not limited by emin/emax. */ 1489 /* */ 1490 /* Notable cases: */ 1491 /* A<0 -> Use |A| */ 1492 /* A=0 -> -Infinity (Division by zero) */ 1493 /* A=Infinite -> +Infinity (Exact) */ 1494 /* A=1 exactly -> 0 (Exact) */ 1495 /* NaNs are propagated as usual */ 1496 /* ------------------------------------------------------------------ */ 1497 decNumber * decNumberLogB(decNumber *res, const decNumber *rhs, 1498 decContext *set) { 1499 uInt status=0; /* accumulator */ 1500 1501 #if DECCHECK 1502 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1503 #endif 1504 1505 /* NaNs as usual; Infinities return +Infinity; 0->oops */ 1506 if (decNumberIsNaN(rhs)) decNaNs(res, rhs, NULL, set, &status); 1507 else if (decNumberIsInfinite(rhs)) decNumberCopyAbs(res, rhs); 1508 else if (decNumberIsZero(rhs)) { 1509 decNumberZero(res); /* prepare for Infinity */ 1510 res->bits=DECNEG|DECINF; /* -Infinity */ 1511 status|=DEC_Division_by_zero; /* as per 754r */ 1512 } 1513 else { /* finite non-zero */ 1514 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */ 1515 decNumberFromInt32(res, ae); /* lay it out */ 1516 } 1517 1518 if (status!=0) decStatus(res, status, set); 1519 return res; 1520 } /* decNumberLogB */ 1521 1522 /* ------------------------------------------------------------------ */ 1523 /* decNumberLog10 -- logarithm in base 10 */ 1524 /* */ 1525 /* This computes C = log10(A) */ 1526 /* */ 1527 /* res is C, the result. C may be A */ 1528 /* rhs is A */ 1529 /* set is the context; note that rounding mode has no effect */ 1530 /* */ 1531 /* C must have space for set->digits digits. */ 1532 /* */ 1533 /* Notable cases: */ 1534 /* A<0 -> Invalid */ 1535 /* A=0 -> -Infinity (Exact) */ 1536 /* A=+Infinity -> +Infinity (Exact) */ 1537 /* A=10**n (if n is an integer) -> n (Exact) */ 1538 /* */ 1539 /* Mathematical function restrictions apply (see above); a NaN is */ 1540 /* returned with Invalid_operation if a restriction is violated. */ 1541 /* */ 1542 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */ 1543 /* almost always be correctly rounded, but may be up to 1 ulp in */ 1544 /* error in rare cases. */ 1545 /* ------------------------------------------------------------------ */ 1546 /* This calculates ln(A)/ln(10) using appropriate precision. For */ 1547 /* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the */ 1548 /* requested digits and t is the number of digits in the exponent */ 1549 /* (maximum 6). For ln(10) it is p + 3; this is often handled by the */ 1550 /* fastpath in decLnOp. The final division is done to the requested */ 1551 /* precision. */ 1552 /* ------------------------------------------------------------------ */ 1553 decNumber * decNumberLog10(decNumber *res, const decNumber *rhs, 1554 decContext *set) { 1555 uInt status=0, ignore=0; /* status accumulators */ 1556 uInt needbytes; /* for space calculations */ 1557 Int p; /* working precision */ 1558 Int t; /* digits in exponent of A */ 1559 1560 /* buffers for a and b working decimals */ 1561 /* (adjustment calculator, same size) */ 1562 decNumber bufa[D2N(DECBUFFER+2)]; 1563 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 1564 decNumber *a=bufa; /* temporary a */ 1565 decNumber bufb[D2N(DECBUFFER+2)]; 1566 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */ 1567 decNumber *b=bufb; /* temporary b */ 1568 decNumber bufw[D2N(10)]; /* working 2-10 digit number */ 1569 decNumber *w=bufw; /* .. */ 1570 #if DECSUBSET 1571 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 1572 #endif 1573 1574 decContext aset; /* working context */ 1575 1576 #if DECCHECK 1577 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1578 #endif 1579 1580 /* Check restrictions; this is a math function; if not violated */ 1581 /* then carry out the operation. */ 1582 if (!decCheckMath(rhs, set, &status)) do { /* protect malloc */ 1583 #if DECSUBSET 1584 if (!set->extended) { 1585 /* reduce operand and set lostDigits status, as needed */ 1586 if (rhs->digits>set->digits) { 1587 allocrhs=decRoundOperand(rhs, set, &status); 1588 if (allocrhs==NULL) break; 1589 rhs=allocrhs; 1590 } 1591 /* special check in subset for rhs=0 */ 1592 if (ISZERO(rhs)) { /* +/- zeros -> error */ 1593 status|=DEC_Invalid_operation; 1594 break;} 1595 } /* extended=0 */ 1596 #endif 1597 1598 decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */ 1599 1600 /* handle exact powers of 10; only check if +ve finite */ 1601 if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) { 1602 Int residue=0; /* (no residue) */ 1603 uInt copystat=0; /* clean status */ 1604 1605 /* round to a single digit... */ 1606 aset.digits=1; 1607 decCopyFit(w, rhs, &aset, &residue, ©stat); /* copy & shorten */ 1608 /* if exact and the digit is 1, rhs is a power of 10 */ 1609 if (!(copystat&DEC_Inexact) && w->lsu[0]==1) { 1610 /* the exponent, conveniently, is the power of 10; making */ 1611 /* this the result needs a little care as it might not fit, */ 1612 /* so first convert it into the working number, and then move */ 1613 /* to res */ 1614 decNumberFromInt32(w, w->exponent); 1615 residue=0; 1616 decCopyFit(res, w, set, &residue, &status); /* copy & round */ 1617 decFinish(res, set, &residue, &status); /* cleanup/set flags */ 1618 break; 1619 } /* not a power of 10 */ 1620 } /* not a candidate for exact */ 1621 1622 /* simplify the information-content calculation to use 'total */ 1623 /* number of digits in a, including exponent' as compared to the */ 1624 /* requested digits, as increasing this will only rarely cost an */ 1625 /* iteration in ln(a) anyway */ 1626 t=6; /* it can never be >6 */ 1627 1628 /* allocate space when needed... */ 1629 p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3; 1630 needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit); 1631 if (needbytes>sizeof(bufa)) { /* need malloc space */ 1632 allocbufa=(decNumber *)malloc(needbytes); 1633 if (allocbufa==NULL) { /* hopeless -- abandon */ 1634 status|=DEC_Insufficient_storage; 1635 break;} 1636 a=allocbufa; /* use the allocated space */ 1637 } 1638 aset.digits=p; /* as calculated */ 1639 aset.emax=DEC_MAX_MATH; /* usual bounds */ 1640 aset.emin=-DEC_MAX_MATH; /* .. */ 1641 aset.clamp=0; /* and no concrete format */ 1642 decLnOp(a, rhs, &aset, &status); /* a=ln(rhs) */ 1643 1644 /* skip the division if the result so far is infinite, NaN, or */ 1645 /* zero, or there was an error; note NaN from sNaN needs copy */ 1646 if (status&DEC_NaNs && !(status&DEC_sNaN)) break; 1647 if (a->bits&DECSPECIAL || ISZERO(a)) { 1648 decNumberCopy(res, a); /* [will fit] */ 1649 break;} 1650 1651 /* for ln(10) an extra 3 digits of precision are needed */ 1652 p=set->digits+3; 1653 needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit); 1654 if (needbytes>sizeof(bufb)) { /* need malloc space */ 1655 allocbufb=(decNumber *)malloc(needbytes); 1656 if (allocbufb==NULL) { /* hopeless -- abandon */ 1657 status|=DEC_Insufficient_storage; 1658 break;} 1659 b=allocbufb; /* use the allocated space */ 1660 } 1661 decNumberZero(w); /* set up 10... */ 1662 #if DECDPUN==1 1663 w->lsu[1]=1; w->lsu[0]=0; /* .. */ 1664 #else 1665 w->lsu[0]=10; /* .. */ 1666 #endif 1667 w->digits=2; /* .. */ 1668 1669 aset.digits=p; 1670 decLnOp(b, w, &aset, &ignore); /* b=ln(10) */ 1671 1672 aset.digits=set->digits; /* for final divide */ 1673 decDivideOp(res, a, b, &aset, DIVIDE, &status); /* into result */ 1674 } while(0); /* [for break] */ 1675 1676 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */ 1677 if (allocbufb!=NULL) free(allocbufb); /* .. */ 1678 #if DECSUBSET 1679 if (allocrhs !=NULL) free(allocrhs); /* .. */ 1680 #endif 1681 /* apply significant status */ 1682 if (status!=0) decStatus(res, status, set); 1683 #if DECCHECK 1684 decCheckInexact(res, set); 1685 #endif 1686 return res; 1687 } /* decNumberLog10 */ 1688 1689 /* ------------------------------------------------------------------ */ 1690 /* decNumberMax -- compare two Numbers and return the maximum */ 1691 /* */ 1692 /* This computes C = A ? B, returning the maximum by 754R rules */ 1693 /* */ 1694 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1695 /* lhs is A */ 1696 /* rhs is B */ 1697 /* set is the context */ 1698 /* */ 1699 /* C must have space for set->digits digits. */ 1700 /* ------------------------------------------------------------------ */ 1701 decNumber * decNumberMax(decNumber *res, const decNumber *lhs, 1702 const decNumber *rhs, decContext *set) { 1703 uInt status=0; /* accumulator */ 1704 decCompareOp(res, lhs, rhs, set, COMPMAX, &status); 1705 if (status!=0) decStatus(res, status, set); 1706 #if DECCHECK 1707 decCheckInexact(res, set); 1708 #endif 1709 return res; 1710 } /* decNumberMax */ 1711 1712 /* ------------------------------------------------------------------ */ 1713 /* decNumberMaxMag -- compare and return the maximum by magnitude */ 1714 /* */ 1715 /* This computes C = A ? B, returning the maximum by 754R rules */ 1716 /* */ 1717 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1718 /* lhs is A */ 1719 /* rhs is B */ 1720 /* set is the context */ 1721 /* */ 1722 /* C must have space for set->digits digits. */ 1723 /* ------------------------------------------------------------------ */ 1724 decNumber * decNumberMaxMag(decNumber *res, const decNumber *lhs, 1725 const decNumber *rhs, decContext *set) { 1726 uInt status=0; /* accumulator */ 1727 decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status); 1728 if (status!=0) decStatus(res, status, set); 1729 #if DECCHECK 1730 decCheckInexact(res, set); 1731 #endif 1732 return res; 1733 } /* decNumberMaxMag */ 1734 1735 /* ------------------------------------------------------------------ */ 1736 /* decNumberMin -- compare two Numbers and return the minimum */ 1737 /* */ 1738 /* This computes C = A ? B, returning the minimum by 754R rules */ 1739 /* */ 1740 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1741 /* lhs is A */ 1742 /* rhs is B */ 1743 /* set is the context */ 1744 /* */ 1745 /* C must have space for set->digits digits. */ 1746 /* ------------------------------------------------------------------ */ 1747 decNumber * decNumberMin(decNumber *res, const decNumber *lhs, 1748 const decNumber *rhs, decContext *set) { 1749 uInt status=0; /* accumulator */ 1750 decCompareOp(res, lhs, rhs, set, COMPMIN, &status); 1751 if (status!=0) decStatus(res, status, set); 1752 #if DECCHECK 1753 decCheckInexact(res, set); 1754 #endif 1755 return res; 1756 } /* decNumberMin */ 1757 1758 /* ------------------------------------------------------------------ */ 1759 /* decNumberMinMag -- compare and return the minimum by magnitude */ 1760 /* */ 1761 /* This computes C = A ? B, returning the minimum by 754R rules */ 1762 /* */ 1763 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1764 /* lhs is A */ 1765 /* rhs is B */ 1766 /* set is the context */ 1767 /* */ 1768 /* C must have space for set->digits digits. */ 1769 /* ------------------------------------------------------------------ */ 1770 decNumber * decNumberMinMag(decNumber *res, const decNumber *lhs, 1771 const decNumber *rhs, decContext *set) { 1772 uInt status=0; /* accumulator */ 1773 decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status); 1774 if (status!=0) decStatus(res, status, set); 1775 #if DECCHECK 1776 decCheckInexact(res, set); 1777 #endif 1778 return res; 1779 } /* decNumberMinMag */ 1780 1781 /* ------------------------------------------------------------------ */ 1782 /* decNumberMinus -- prefix minus operator */ 1783 /* */ 1784 /* This computes C = 0 - A */ 1785 /* */ 1786 /* res is C, the result. C may be A */ 1787 /* rhs is A */ 1788 /* set is the context */ 1789 /* */ 1790 /* See also decNumberCopyNegate for a quiet bitwise version of this. */ 1791 /* C must have space for set->digits digits. */ 1792 /* ------------------------------------------------------------------ */ 1793 /* Simply use AddOp for the subtract, which will do the necessary. */ 1794 /* ------------------------------------------------------------------ */ 1795 decNumber * decNumberMinus(decNumber *res, const decNumber *rhs, 1796 decContext *set) { 1797 decNumber dzero; 1798 uInt status=0; /* accumulator */ 1799 1800 #if DECCHECK 1801 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1802 #endif 1803 1804 decNumberZero(&dzero); /* make 0 */ 1805 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */ 1806 decAddOp(res, &dzero, rhs, set, DECNEG, &status); 1807 if (status!=0) decStatus(res, status, set); 1808 #if DECCHECK 1809 decCheckInexact(res, set); 1810 #endif 1811 return res; 1812 } /* decNumberMinus */ 1813 1814 /* ------------------------------------------------------------------ */ 1815 /* decNumberNextMinus -- next towards -Infinity */ 1816 /* */ 1817 /* This computes C = A - infinitesimal, rounded towards -Infinity */ 1818 /* */ 1819 /* res is C, the result. C may be A */ 1820 /* rhs is A */ 1821 /* set is the context */ 1822 /* */ 1823 /* This is a generalization of 754r NextDown. */ 1824 /* ------------------------------------------------------------------ */ 1825 decNumber * decNumberNextMinus(decNumber *res, const decNumber *rhs, 1826 decContext *set) { 1827 decNumber dtiny; /* constant */ 1828 decContext workset=*set; /* work */ 1829 uInt status=0; /* accumulator */ 1830 #if DECCHECK 1831 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1832 #endif 1833 1834 /* +Infinity is the special case */ 1835 if ((rhs->bits&(DECINF|DECNEG))==DECINF) { 1836 decSetMaxValue(res, set); /* is +ve */ 1837 /* there is no status to set */ 1838 return res; 1839 } 1840 decNumberZero(&dtiny); /* start with 0 */ 1841 dtiny.lsu[0]=1; /* make number that is .. */ 1842 dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */ 1843 workset.round=DEC_ROUND_FLOOR; 1844 decAddOp(res, rhs, &dtiny, &workset, DECNEG, &status); 1845 status&=DEC_Invalid_operation|DEC_sNaN; /* only sNaN Invalid please */ 1846 if (status!=0) decStatus(res, status, set); 1847 return res; 1848 } /* decNumberNextMinus */ 1849 1850 /* ------------------------------------------------------------------ */ 1851 /* decNumberNextPlus -- next towards +Infinity */ 1852 /* */ 1853 /* This computes C = A + infinitesimal, rounded towards +Infinity */ 1854 /* */ 1855 /* res is C, the result. C may be A */ 1856 /* rhs is A */ 1857 /* set is the context */ 1858 /* */ 1859 /* This is a generalization of 754r NextUp. */ 1860 /* ------------------------------------------------------------------ */ 1861 decNumber * decNumberNextPlus(decNumber *res, const decNumber *rhs, 1862 decContext *set) { 1863 decNumber dtiny; /* constant */ 1864 decContext workset=*set; /* work */ 1865 uInt status=0; /* accumulator */ 1866 #if DECCHECK 1867 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1868 #endif 1869 1870 /* -Infinity is the special case */ 1871 if ((rhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) { 1872 decSetMaxValue(res, set); 1873 res->bits=DECNEG; /* negative */ 1874 /* there is no status to set */ 1875 return res; 1876 } 1877 decNumberZero(&dtiny); /* start with 0 */ 1878 dtiny.lsu[0]=1; /* make number that is .. */ 1879 dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */ 1880 workset.round=DEC_ROUND_CEILING; 1881 decAddOp(res, rhs, &dtiny, &workset, 0, &status); 1882 status&=DEC_Invalid_operation|DEC_sNaN; /* only sNaN Invalid please */ 1883 if (status!=0) decStatus(res, status, set); 1884 return res; 1885 } /* decNumberNextPlus */ 1886 1887 /* ------------------------------------------------------------------ */ 1888 /* decNumberNextToward -- next towards rhs */ 1889 /* */ 1890 /* This computes C = A +/- infinitesimal, rounded towards */ 1891 /* +/-Infinity in the direction of B, as per 754r nextafter rules */ 1892 /* */ 1893 /* res is C, the result. C may be A or B. */ 1894 /* lhs is A */ 1895 /* rhs is B */ 1896 /* set is the context */ 1897 /* */ 1898 /* This is a generalization of 754r NextAfter. */ 1899 /* ------------------------------------------------------------------ */ 1900 decNumber * decNumberNextToward(decNumber *res, const decNumber *lhs, 1901 const decNumber *rhs, decContext *set) { 1902 decNumber dtiny; /* constant */ 1903 decContext workset=*set; /* work */ 1904 Int result; /* .. */ 1905 uInt status=0; /* accumulator */ 1906 #if DECCHECK 1907 if (decCheckOperands(res, lhs, rhs, set)) return res; 1908 #endif 1909 1910 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { 1911 decNaNs(res, lhs, rhs, set, &status); 1912 } 1913 else { /* Is numeric, so no chance of sNaN Invalid, etc. */ 1914 result=decCompare(lhs, rhs, 0); /* sign matters */ 1915 if (result==BADINT) status|=DEC_Insufficient_storage; /* rare */ 1916 else { /* valid compare */ 1917 if (result==0) decNumberCopySign(res, lhs, rhs); /* easy */ 1918 else { /* differ: need NextPlus or NextMinus */ 1919 uByte sub; /* add or subtract */ 1920 if (result<0) { /* lhs<rhs, do nextplus */ 1921 /* -Infinity is the special case */ 1922 if ((lhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) { 1923 decSetMaxValue(res, set); 1924 res->bits=DECNEG; /* negative */ 1925 return res; /* there is no status to set */ 1926 } 1927 workset.round=DEC_ROUND_CEILING; 1928 sub=0; /* add, please */ 1929 } /* plus */ 1930 else { /* lhs>rhs, do nextminus */ 1931 /* +Infinity is the special case */ 1932 if ((lhs->bits&(DECINF|DECNEG))==DECINF) { 1933 decSetMaxValue(res, set); 1934 return res; /* there is no status to set */ 1935 } 1936 workset.round=DEC_ROUND_FLOOR; 1937 sub=DECNEG; /* subtract, please */ 1938 } /* minus */ 1939 decNumberZero(&dtiny); /* start with 0 */ 1940 dtiny.lsu[0]=1; /* make number that is .. */ 1941 dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */ 1942 decAddOp(res, lhs, &dtiny, &workset, sub, &status); /* + or - */ 1943 /* turn off exceptions if the result is a normal number */ 1944 /* (including Nmin), otherwise let all status through */ 1945 if (decNumberIsNormal(res, set)) status=0; 1946 } /* unequal */ 1947 } /* compare OK */ 1948 } /* numeric */ 1949 if (status!=0) decStatus(res, status, set); 1950 return res; 1951 } /* decNumberNextToward */ 1952 1953 /* ------------------------------------------------------------------ */ 1954 /* decNumberOr -- OR two Numbers, digitwise */ 1955 /* */ 1956 /* This computes C = A | B */ 1957 /* */ 1958 /* res is C, the result. C may be A and/or B (e.g., X=X|X) */ 1959 /* lhs is A */ 1960 /* rhs is B */ 1961 /* set is the context (used for result length and error report) */ 1962 /* */ 1963 /* C must have space for set->digits digits. */ 1964 /* */ 1965 /* Logical function restrictions apply (see above); a NaN is */ 1966 /* returned with Invalid_operation if a restriction is violated. */ 1967 /* ------------------------------------------------------------------ */ 1968 decNumber * decNumberOr(decNumber *res, const decNumber *lhs, 1969 const decNumber *rhs, decContext *set) { 1970 const Unit *ua, *ub; /* -> operands */ 1971 const Unit *msua, *msub; /* -> operand msus */ 1972 Unit *uc, *msuc; /* -> result and its msu */ 1973 Int msudigs; /* digits in res msu */ 1974 #if DECCHECK 1975 if (decCheckOperands(res, lhs, rhs, set)) return res; 1976 #endif 1977 1978 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs) 1979 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { 1980 decStatus(res, DEC_Invalid_operation, set); 1981 return res; 1982 } 1983 /* operands are valid */ 1984 ua=lhs->lsu; /* bottom-up */ 1985 ub=rhs->lsu; /* .. */ 1986 uc=res->lsu; /* .. */ 1987 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */ 1988 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ 1989 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ 1990 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ 1991 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */ 1992 Unit a, b; /* extract units */ 1993 if (ua>msua) a=0; 1994 else a=*ua; 1995 if (ub>msub) b=0; 1996 else b=*ub; 1997 *uc=0; /* can now write back */ 1998 if (a|b) { /* maybe 1 bits to examine */ 1999 Int i, j; 2000 /* This loop could be unrolled and/or use BIN2BCD tables */ 2001 for (i=0; i<DECDPUN; i++) { 2002 if ((a|b)&1) *uc=*uc+(Unit)powers[i]; /* effect OR */ 2003 j=a%10; 2004 a=a/10; 2005 j|=b%10; 2006 b=b/10; 2007 if (j>1) { 2008 decStatus(res, DEC_Invalid_operation, set); 2009 return res; 2010 } 2011 if (uc==msuc && i==msudigs-1) break; /* just did final digit */ 2012 } /* each digit */ 2013 } /* non-zero */ 2014 } /* each unit */ 2015 /* [here uc-1 is the msu of the result] */ 2016 res->digits=decGetDigits(res->lsu, uc-res->lsu); 2017 res->exponent=0; /* integer */ 2018 res->bits=0; /* sign=0 */ 2019 return res; /* [no status to set] */ 2020 } /* decNumberOr */ 2021 2022 /* ------------------------------------------------------------------ */ 2023 /* decNumberPlus -- prefix plus operator */ 2024 /* */ 2025 /* This computes C = 0 + A */ 2026 /* */ 2027 /* res is C, the result. C may be A */ 2028 /* rhs is A */ 2029 /* set is the context */ 2030 /* */ 2031 /* See also decNumberCopy for a quiet bitwise version of this. */ 2032 /* C must have space for set->digits digits. */ 2033 /* ------------------------------------------------------------------ */ 2034 /* This simply uses AddOp; Add will take fast path after preparing A. */ 2035 /* Performance is a concern here, as this routine is often used to */ 2036 /* check operands and apply rounding and overflow/underflow testing. */ 2037 /* ------------------------------------------------------------------ */ 2038 decNumber * decNumberPlus(decNumber *res, const decNumber *rhs, 2039 decContext *set) { 2040 decNumber dzero; 2041 uInt status=0; /* accumulator */ 2042 #if DECCHECK 2043 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 2044 #endif 2045 2046 decNumberZero(&dzero); /* make 0 */ 2047 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */ 2048 decAddOp(res, &dzero, rhs, set, 0, &status); 2049 if (status!=0) decStatus(res, status, set); 2050 #if DECCHECK 2051 decCheckInexact(res, set); 2052 #endif 2053 return res; 2054 } /* decNumberPlus */ 2055 2056 /* ------------------------------------------------------------------ */ 2057 /* decNumberMultiply -- multiply two Numbers */ 2058 /* */ 2059 /* This computes C = A x B */ 2060 /* */ 2061 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */ 2062 /* lhs is A */ 2063 /* rhs is B */ 2064 /* set is the context */ 2065 /* */ 2066 /* C must have space for set->digits digits. */ 2067 /* ------------------------------------------------------------------ */ 2068 decNumber * decNumberMultiply(decNumber *res, const decNumber *lhs, 2069 const decNumber *rhs, decContext *set) { 2070 uInt status=0; /* accumulator */ 2071 decMultiplyOp(res, lhs, rhs, set, &status); 2072 if (status!=0) decStatus(res, status, set); 2073 #if DECCHECK 2074 decCheckInexact(res, set); 2075 #endif 2076 return res; 2077 } /* decNumberMultiply */ 2078 2079 /* ------------------------------------------------------------------ */ 2080 /* decNumberPower -- raise a number to a power */ 2081 /* */ 2082 /* This computes C = A ** B */ 2083 /* */ 2084 /* res is C, the result. C may be A and/or B (e.g., X=X**X) */ 2085 /* lhs is A */ 2086 /* rhs is B */ 2087 /* set is the context */ 2088 /* */ 2089 /* C must have space for set->digits digits. */ 2090 /* */ 2091 /* Mathematical function restrictions apply (see above); a NaN is */ 2092 /* returned with Invalid_operation if a restriction is violated. */ 2093 /* */ 2094 /* However, if 1999999997<=B<=999999999 and B is an integer then the */ 2095 /* restrictions on A and the context are relaxed to the usual bounds, */ 2096 /* for compatibility with the earlier (integer power only) version */ 2097 /* of this function. */ 2098 /* */ 2099 /* When B is an integer, the result may be exact, even if rounded. */ 2100 /* */ 2101 /* The final result is rounded according to the context; it will */ 2102 /* almost always be correctly rounded, but may be up to 1 ulp in */ 2103 /* error in rare cases. */ 2104 /* ------------------------------------------------------------------ */ 2105 decNumber * decNumberPower(decNumber *res, const decNumber *lhs, 2106 const decNumber *rhs, decContext *set) { 2107 #if DECSUBSET 2108 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 2109 decNumber *allocrhs=NULL; /* .., rhs */ 2110 #endif 2111 decNumber *allocdac=NULL; /* -> allocated acc buffer, iff used */ 2112 decNumber *allocinv=NULL; /* -> allocated 1/x buffer, iff used */ 2113 Int reqdigits=set->digits; /* requested DIGITS */ 2114 Int n; /* rhs in binary */ 2115 Flag rhsint=0; /* 1 if rhs is an integer */ 2116 Flag useint=0; /* 1 if can use integer calculation */ 2117 Flag isoddint=0; /* 1 if rhs is an integer and odd */ 2118 Int i; /* work */ 2119 #if DECSUBSET 2120 Int dropped; /* .. */ 2121 #endif 2122 uInt needbytes; /* buffer size needed */ 2123 Flag seenbit; /* seen a bit while powering */ 2124 Int residue=0; /* rounding residue */ 2125 uInt status=0; /* accumulators */ 2126 uByte bits=0; /* result sign if errors */ 2127 decContext aset; /* working context */ 2128 decNumber dnOne; /* work value 1... */ 2129 /* local accumulator buffer [a decNumber, with digits+elength+1 digits] */ 2130 decNumber dacbuff[D2N(DECBUFFER+9)]; 2131 decNumber *dac=dacbuff; /* -> result accumulator */ 2132 /* same again for possible 1/lhs calculation */ 2133 decNumber invbuff[D2N(DECBUFFER+9)]; 2134 2135 #if DECCHECK 2136 if (decCheckOperands(res, lhs, rhs, set)) return res; 2137 #endif 2138 2139 do { /* protect allocated storage */ 2140 #if DECSUBSET 2141 if (!set->extended) { /* reduce operands and set status, as needed */ 2142 if (lhs->digits>reqdigits) { 2143 alloclhs=decRoundOperand(lhs, set, &status); 2144 if (alloclhs==NULL) break; 2145 lhs=alloclhs; 2146 } 2147 if (rhs->digits>reqdigits) { 2148 allocrhs=decRoundOperand(rhs, set, &status); 2149 if (allocrhs==NULL) break; 2150 rhs=allocrhs; 2151 } 2152 } 2153 #endif 2154 /* [following code does not require input rounding] */ 2155 2156 /* handle NaNs and rhs Infinity (lhs infinity is harder) */ 2157 if (SPECIALARGS) { 2158 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { /* NaNs */ 2159 decNaNs(res, lhs, rhs, set, &status); 2160 break;} 2161 if (decNumberIsInfinite(rhs)) { /* rhs Infinity */ 2162 Flag rhsneg=rhs->bits&DECNEG; /* save rhs sign */ 2163 if (decNumberIsNegative(lhs) /* lhs<0 */ 2164 && !decNumberIsZero(lhs)) /* .. */ 2165 status|=DEC_Invalid_operation; 2166 else { /* lhs >=0 */ 2167 decNumberZero(&dnOne); /* set up 1 */ 2168 dnOne.lsu[0]=1; 2169 decNumberCompare(dac, lhs, &dnOne, set); /* lhs ? 1 */ 2170 decNumberZero(res); /* prepare for 0/1/Infinity */ 2171 if (decNumberIsNegative(dac)) { /* lhs<1 */ 2172 if (rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */ 2173 } 2174 else if (dac->lsu[0]==0) { /* lhs=1 */ 2175 /* 1**Infinity is inexact, so return fully-padded 1.0000 */ 2176 Int shift=set->digits-1; 2177 *res->lsu=1; /* was 0, make int 1 */ 2178 res->digits=decShiftToMost(res->lsu, 1, shift); 2179 res->exponent=-shift; /* make 1.0000... */ 2180 status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */ 2181 } 2182 else { /* lhs>1 */ 2183 if (!rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */ 2184 } 2185 } /* lhs>=0 */ 2186 break;} 2187 /* [lhs infinity drops through] */ 2188 } /* specials */ 2189 2190 /* Original rhs may be an integer that fits and is in range */ 2191 n=decGetInt(rhs); 2192 if (n!=BADINT) { /* it is an integer */ 2193 rhsint=1; /* record the fact for 1**n */ 2194 isoddint=(Flag)n&1; /* [works even if big] */ 2195 if (n!=BIGEVEN && n!=BIGODD) /* can use integer path? */ 2196 useint=1; /* looks good */ 2197 } 2198 2199 if (decNumberIsNegative(lhs) /* -x .. */ 2200 && isoddint) bits=DECNEG; /* .. to an odd power */ 2201 2202 /* handle LHS infinity */ 2203 if (decNumberIsInfinite(lhs)) { /* [NaNs already handled] */ 2204 uByte rbits=rhs->bits; /* save */ 2205 decNumberZero(res); /* prepare */ 2206 if (n==0) *res->lsu=1; /* [-]Inf**0 => 1 */ 2207 else { 2208 /* -Inf**nonint -> error */ 2209 if (!rhsint && decNumberIsNegative(lhs)) { 2210 status|=DEC_Invalid_operation; /* -Inf**nonint is error */ 2211 break;} 2212 if (!(rbits & DECNEG)) bits|=DECINF; /* was not a **-n */ 2213 /* [otherwise will be 0 or -0] */ 2214 res->bits=bits; 2215 } 2216 break;} 2217 2218 /* similarly handle LHS zero */ 2219 if (decNumberIsZero(lhs)) { 2220 if (n==0) { /* 0**0 => Error */ 2221 #if DECSUBSET 2222 if (!set->extended) { /* [unless subset] */ 2223 decNumberZero(res); 2224 *res->lsu=1; /* return 1 */ 2225 break;} 2226 #endif 2227 status|=DEC_Invalid_operation; 2228 } 2229 else { /* 0**x */ 2230 uByte rbits=rhs->bits; /* save */ 2231 if (rbits & DECNEG) { /* was a 0**(-n) */ 2232 #if DECSUBSET 2233 if (!set->extended) { /* [bad if subset] */ 2234 status|=DEC_Invalid_operation; 2235 break;} 2236 #endif 2237 bits|=DECINF; 2238 } 2239 decNumberZero(res); /* prepare */ 2240 /* [otherwise will be 0 or -0] */ 2241 res->bits=bits; 2242 } 2243 break;} 2244 2245 /* here both lhs and rhs are finite; rhs==0 is handled in the */ 2246 /* integer path. Next handle the non-integer cases */ 2247 if (!useint) { /* non-integral rhs */ 2248 /* any -ve lhs is bad, as is either operand or context out of */ 2249 /* bounds */ 2250 if (decNumberIsNegative(lhs)) { 2251 status|=DEC_Invalid_operation; 2252 break;} 2253 if (decCheckMath(lhs, set, &status) 2254 || decCheckMath(rhs, set, &status)) break; /* variable status */ 2255 2256 decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */ 2257 aset.emax=DEC_MAX_MATH; /* usual bounds */ 2258 aset.emin=-DEC_MAX_MATH; /* .. */ 2259 aset.clamp=0; /* and no concrete format */ 2260 2261 /* calculate the result using exp(ln(lhs)*rhs), which can */ 2262 /* all be done into the accumulator, dac. The precision needed */ 2263 /* is enough to contain the full information in the lhs (which */ 2264 /* is the total digits, including exponent), or the requested */ 2265 /* precision, if larger, + 4; 6 is used for the exponent */ 2266 /* maximum length, and this is also used when it is shorter */ 2267 /* than the requested digits as it greatly reduces the >0.5 ulp */ 2268 /* cases at little cost (because Ln doubles digits each */ 2269 /* iteration so a few extra digits rarely causes an extra */ 2270 /* iteration) */ 2271 aset.digits=MAXI(lhs->digits, set->digits)+6+4; 2272 } /* non-integer rhs */ 2273 2274 else { /* rhs is in-range integer */ 2275 if (n==0) { /* x**0 = 1 */ 2276 /* (0**0 was handled above) */ 2277 decNumberZero(res); /* result=1 */ 2278 *res->lsu=1; /* .. */ 2279 break;} 2280 /* rhs is a non-zero integer */ 2281 if (n<0) n=-n; /* use abs(n) */ 2282 2283 aset=*set; /* clone the context */ 2284 aset.round=DEC_ROUND_HALF_EVEN; /* internally use balanced */ 2285 /* calculate the working DIGITS */ 2286 aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2; 2287 #if DECSUBSET 2288 if (!set->extended) aset.digits--; /* use classic precision */ 2289 #endif 2290 /* it's an error if this is more than can be handled */ 2291 if (aset.digits>DECNUMMAXP) {status|=DEC_Invalid_operation; break;} 2292 } /* integer path */ 2293 2294 /* aset.digits is the count of digits for the accumulator needed */ 2295 /* if accumulator is too long for local storage, then allocate */ 2296 needbytes=sizeof(decNumber)+(D2U(aset.digits)-1)*sizeof(Unit); 2297 /* [needbytes also used below if 1/lhs needed] */ 2298 if (needbytes>sizeof(dacbuff)) { 2299 allocdac=(decNumber *)malloc(needbytes); 2300 if (allocdac==NULL) { /* hopeless -- abandon */ 2301 status|=DEC_Insufficient_storage; 2302 break;} 2303 dac=allocdac; /* use the allocated space */ 2304 } 2305 /* here, aset is set up and accumulator is ready for use */ 2306 2307 if (!useint) { /* non-integral rhs */ 2308 /* x ** y; special-case x=1 here as it will otherwise always */ 2309 /* reduce to integer 1; decLnOp has a fastpath which detects */ 2310 /* the case of x=1 */ 2311 decLnOp(dac, lhs, &aset, &status); /* dac=ln(lhs) */ 2312 /* [no error possible, as lhs 0 already handled] */ 2313 if (ISZERO(dac)) { /* x==1, 1.0, etc. */ 2314 /* need to return fully-padded 1.0000 etc., but rhsint->1 */ 2315 *dac->lsu=1; /* was 0, make int 1 */ 2316 if (!rhsint) { /* add padding */ 2317 Int shift=set->digits-1; 2318 dac->digits=decShiftToMost(dac->lsu, 1, shift); 2319 dac->exponent=-shift; /* make 1.0000... */ 2320 status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */ 2321 } 2322 } 2323 else { 2324 decMultiplyOp(dac, dac, rhs, &aset, &status); /* dac=dac*rhs */ 2325 decExpOp(dac, dac, &aset, &status); /* dac=exp(dac) */ 2326 } 2327 /* and drop through for final rounding */ 2328 } /* non-integer rhs */ 2329 2330 else { /* carry on with integer */ 2331 decNumberZero(dac); /* acc=1 */ 2332 *dac->lsu=1; /* .. */ 2333 2334 /* if a negative power the constant 1 is needed, and if not subset */ 2335 /* invert the lhs now rather than inverting the result later */ 2336 if (decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */ 2337 decNumber *inv=invbuff; /* assume use fixed buffer */ 2338 decNumberCopy(&dnOne, dac); /* dnOne=1; [needed now or later] */ 2339 #if DECSUBSET 2340 if (set->extended) { /* need to calculate 1/lhs */ 2341 #endif 2342 /* divide lhs into 1, putting result in dac [dac=1/dac] */ 2343 decDivideOp(dac, &dnOne, lhs, &aset, DIVIDE, &status); 2344 /* now locate or allocate space for the inverted lhs */ 2345 if (needbytes>sizeof(invbuff)) { 2346 allocinv=(decNumber *)malloc(needbytes); 2347 if (allocinv==NULL) { /* hopeless -- abandon */ 2348 status|=DEC_Insufficient_storage; 2349 break;} 2350 inv=allocinv; /* use the allocated space */ 2351 } 2352 /* [inv now points to big-enough buffer or allocated storage] */ 2353 decNumberCopy(inv, dac); /* copy the 1/lhs */ 2354 decNumberCopy(dac, &dnOne); /* restore acc=1 */ 2355 lhs=inv; /* .. and go forward with new lhs */ 2356 #if DECSUBSET 2357 } 2358 #endif 2359 } 2360 2361 /* Raise-to-the-power loop... */ 2362 seenbit=0; /* set once a 1-bit is encountered */ 2363 for (i=1;;i++){ /* for each bit [top bit ignored] */ 2364 /* abandon if had overflow or terminal underflow */ 2365 if (status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */ 2366 if (status&DEC_Overflow || ISZERO(dac)) break; 2367 } 2368 /* [the following two lines revealed an optimizer bug in a C++ */ 2369 /* compiler, with symptom: 5**3 -> 25, when n=n+n was used] */ 2370 n=n<<1; /* move next bit to testable position */ 2371 if (n<0) { /* top bit is set */ 2372 seenbit=1; /* OK, significant bit seen */ 2373 decMultiplyOp(dac, dac, lhs, &aset, &status); /* dac=dac*x */ 2374 } 2375 if (i==31) break; /* that was the last bit */ 2376 if (!seenbit) continue; /* no need to square 1 */ 2377 decMultiplyOp(dac, dac, dac, &aset, &status); /* dac=dac*dac [square] */ 2378 } /*i*/ /* 32 bits */ 2379 2380 /* complete internal overflow or underflow processing */ 2381 if (status & (DEC_Overflow|DEC_Underflow)) { 2382 #if DECSUBSET 2383 /* If subset, and power was negative, reverse the kind of -erflow */ 2384 /* [1/x not yet done] */ 2385 if (!set->extended && decNumberIsNegative(rhs)) { 2386 if (status & DEC_Overflow) 2387 status^=DEC_Overflow | DEC_Underflow | DEC_Subnormal; 2388 else { /* trickier -- Underflow may or may not be set */ 2389 status&=~(DEC_Underflow | DEC_Subnormal); /* [one or both] */ 2390 status|=DEC_Overflow; 2391 } 2392 } 2393 #endif 2394 dac->bits=(dac->bits & ~DECNEG) | bits; /* force correct sign */ 2395 /* round subnormals [to set.digits rather than aset.digits] */ 2396 /* or set overflow result similarly as required */ 2397 decFinalize(dac, set, &residue, &status); 2398 decNumberCopy(res, dac); /* copy to result (is now OK length) */ 2399 break; 2400 } 2401 2402 #if DECSUBSET 2403 if (!set->extended && /* subset math */ 2404 decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */ 2405 /* so divide result into 1 [dac=1/dac] */ 2406 decDivideOp(dac, &dnOne, dac, &aset, DIVIDE, &status); 2407 } 2408 #endif 2409 } /* rhs integer path */ 2410 2411 /* reduce result to the requested length and copy to result */ 2412 decCopyFit(res, dac, set, &residue, &status); 2413 decFinish(res, set, &residue, &status); /* final cleanup */ 2414 #if DECSUBSET 2415 if (!set->extended) decTrim(res, set, 0, &dropped); /* trailing zeros */ 2416 #endif 2417 } while(0); /* end protected */ 2418 2419 if (allocdac!=NULL) free(allocdac); /* drop any storage used */ 2420 if (allocinv!=NULL) free(allocinv); /* .. */ 2421 #if DECSUBSET 2422 if (alloclhs!=NULL) free(alloclhs); /* .. */ 2423 if (allocrhs!=NULL) free(allocrhs); /* .. */ 2424 #endif 2425 if (status!=0) decStatus(res, status, set); 2426 #if DECCHECK 2427 decCheckInexact(res, set); 2428 #endif 2429 return res; 2430 } /* decNumberPower */ 2431 2432 /* ------------------------------------------------------------------ */ 2433 /* decNumberQuantize -- force exponent to requested value */ 2434 /* */ 2435 /* This computes C = op(A, B), where op adjusts the coefficient */ 2436 /* of C (by rounding or shifting) such that the exponent (-scale) */ 2437 /* of C has exponent of B. The numerical value of C will equal A, */ 2438 /* except for the effects of any rounding that occurred. */ 2439 /* */ 2440 /* res is C, the result. C may be A or B */ 2441 /* lhs is A, the number to adjust */ 2442 /* rhs is B, the number with exponent to match */ 2443 /* set is the context */ 2444 /* */ 2445 /* C must have space for set->digits digits. */ 2446 /* */ 2447 /* Unless there is an error or the result is infinite, the exponent */ 2448 /* after the operation is guaranteed to be equal to that of B. */ 2449 /* ------------------------------------------------------------------ */ 2450 decNumber * decNumberQuantize(decNumber *res, const decNumber *lhs, 2451 const decNumber *rhs, decContext *set) { 2452 uInt status=0; /* accumulator */ 2453 decQuantizeOp(res, lhs, rhs, set, 1, &status); 2454 if (status!=0) decStatus(res, status, set); 2455 return res; 2456 } /* decNumberQuantize */ 2457 2458 /* ------------------------------------------------------------------ */ 2459 /* decNumberReduce -- remove trailing zeros */ 2460 /* */ 2461 /* This computes C = 0 + A, and normalizes the result */ 2462 /* */ 2463 /* res is C, the result. C may be A */ 2464 /* rhs is A */ 2465 /* set is the context */ 2466 /* */ 2467 /* C must have space for set->digits digits. */ 2468 /* ------------------------------------------------------------------ */ 2469 /* Previously known as Normalize */ 2470 decNumber * decNumberNormalize(decNumber *res, const decNumber *rhs, 2471 decContext *set) { 2472 return decNumberReduce(res, rhs, set); 2473 } /* decNumberNormalize */ 2474 2475 decNumber * decNumberReduce(decNumber *res, const decNumber *rhs, 2476 decContext *set) { 2477 #if DECSUBSET 2478 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 2479 #endif 2480 uInt status=0; /* as usual */ 2481 Int residue=0; /* as usual */ 2482 Int dropped; /* work */ 2483 2484 #if DECCHECK 2485 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 2486 #endif 2487 2488 do { /* protect allocated storage */ 2489 #if DECSUBSET 2490 if (!set->extended) { 2491 /* reduce operand and set lostDigits status, as needed */ 2492 if (rhs->digits>set->digits) { 2493 allocrhs=decRoundOperand(rhs, set, &status); 2494 if (allocrhs==NULL) break; 2495 rhs=allocrhs; 2496 } 2497 } 2498 #endif 2499 /* [following code does not require input rounding] */ 2500 2501 /* Infinities copy through; NaNs need usual treatment */ 2502 if (decNumberIsNaN(rhs)) { 2503 decNaNs(res, rhs, NULL, set, &status); 2504 break; 2505 } 2506 2507 /* reduce result to the requested length and copy to result */ 2508 decCopyFit(res, rhs, set, &residue, &status); /* copy & round */ 2509 decFinish(res, set, &residue, &status); /* cleanup/set flags */ 2510 decTrim(res, set, 1, &dropped); /* normalize in place */ 2511 } while(0); /* end protected */ 2512 2513 #if DECSUBSET 2514 if (allocrhs !=NULL) free(allocrhs); /* .. */ 2515 #endif 2516 if (status!=0) decStatus(res, status, set);/* then report status */ 2517 return res; 2518 } /* decNumberReduce */ 2519 2520 /* ------------------------------------------------------------------ */ 2521 /* decNumberRescale -- force exponent to requested value */ 2522 /* */ 2523 /* This computes C = op(A, B), where op adjusts the coefficient */ 2524 /* of C (by rounding or shifting) such that the exponent (-scale) */ 2525 /* of C has the value B. The numerical value of C will equal A, */ 2526 /* except for the effects of any rounding that occurred. */ 2527 /* */ 2528 /* res is C, the result. C may be A or B */ 2529 /* lhs is A, the number to adjust */ 2530 /* rhs is B, the requested exponent */ 2531 /* set is the context */ 2532 /* */ 2533 /* C must have space for set->digits digits. */ 2534 /* */ 2535 /* Unless there is an error or the result is infinite, the exponent */ 2536 /* after the operation is guaranteed to be equal to B. */ 2537 /* ------------------------------------------------------------------ */ 2538 decNumber * decNumberRescale(decNumber *res, const decNumber *lhs, 2539 const decNumber *rhs, decContext *set) { 2540 uInt status=0; /* accumulator */ 2541 decQuantizeOp(res, lhs, rhs, set, 0, &status); 2542 if (status!=0) decStatus(res, status, set); 2543 return res; 2544 } /* decNumberRescale */ 2545 2546 /* ------------------------------------------------------------------ */ 2547 /* decNumberRemainder -- divide and return remainder */ 2548 /* */ 2549 /* This computes C = A % B */ 2550 /* */ 2551 /* res is C, the result. C may be A and/or B (e.g., X=X%X) */ 2552 /* lhs is A */ 2553 /* rhs is B */ 2554 /* set is the context */ 2555 /* */ 2556 /* C must have space for set->digits digits. */ 2557 /* ------------------------------------------------------------------ */ 2558 decNumber * decNumberRemainder(decNumber *res, const decNumber *lhs, 2559 const decNumber *rhs, decContext *set) { 2560 uInt status=0; /* accumulator */ 2561 decDivideOp(res, lhs, rhs, set, REMAINDER, &status); 2562 if (status!=0) decStatus(res, status, set); 2563 #if DECCHECK 2564 decCheckInexact(res, set); 2565 #endif 2566 return res; 2567 } /* decNumberRemainder */ 2568 2569 /* ------------------------------------------------------------------ */ 2570 /* decNumberRemainderNear -- divide and return remainder from nearest */ 2571 /* */ 2572 /* This computes C = A % B, where % is the IEEE remainder operator */ 2573 /* */ 2574 /* res is C, the result. C may be A and/or B (e.g., X=X%X) */ 2575 /* lhs is A */ 2576 /* rhs is B */ 2577 /* set is the context */ 2578 /* */ 2579 /* C must have space for set->digits digits. */ 2580 /* ------------------------------------------------------------------ */ 2581 decNumber * decNumberRemainderNear(decNumber *res, const decNumber *lhs, 2582 const decNumber *rhs, decContext *set) { 2583 uInt status=0; /* accumulator */ 2584 decDivideOp(res, lhs, rhs, set, REMNEAR, &status); 2585 if (status!=0) decStatus(res, status, set); 2586 #if DECCHECK 2587 decCheckInexact(res, set); 2588 #endif 2589 return res; 2590 } /* decNumberRemainderNear */ 2591 2592 /* ------------------------------------------------------------------ */ 2593 /* decNumberRotate -- rotate the coefficient of a Number left/right */ 2594 /* */ 2595 /* This computes C = A rot B (in base ten and rotating set->digits */ 2596 /* digits). */ 2597 /* */ 2598 /* res is C, the result. C may be A and/or B (e.g., X=XrotX) */ 2599 /* lhs is A */ 2600 /* rhs is B, the number of digits to rotate (-ve to right) */ 2601 /* set is the context */ 2602 /* */ 2603 /* The digits of the coefficient of A are rotated to the left (if B */ 2604 /* is positive) or to the right (if B is negative) without adjusting */ 2605 /* the exponent or the sign of A. If lhs->digits is less than */ 2606 /* set->digits the coefficient is padded with zeros on the left */ 2607 /* before the rotate. Any leading zeros in the result are removed */ 2608 /* as usual. */ 2609 /* */ 2610 /* B must be an integer (q=0) and in the range -set->digits through */ 2611 /* +set->digits. */ 2612 /* C must have space for set->digits digits. */ 2613 /* NaNs are propagated as usual. Infinities are unaffected (but */ 2614 /* B must be valid). No status is set unless B is invalid or an */ 2615 /* operand is an sNaN. */ 2616 /* ------------------------------------------------------------------ */ 2617 decNumber * decNumberRotate(decNumber *res, const decNumber *lhs, 2618 const decNumber *rhs, decContext *set) { 2619 uInt status=0; /* accumulator */ 2620 Int rotate; /* rhs as an Int */ 2621 2622 #if DECCHECK 2623 if (decCheckOperands(res, lhs, rhs, set)) return res; 2624 #endif 2625 2626 /* NaNs propagate as normal */ 2627 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) 2628 decNaNs(res, lhs, rhs, set, &status); 2629 /* rhs must be an integer */ 2630 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0) 2631 status=DEC_Invalid_operation; 2632 else { /* both numeric, rhs is an integer */ 2633 rotate=decGetInt(rhs); /* [cannot fail] */ 2634 if (rotate==BADINT /* something bad .. */ 2635 || rotate==BIGODD || rotate==BIGEVEN /* .. very big .. */ 2636 || abs(rotate)>set->digits) /* .. or out of range */ 2637 status=DEC_Invalid_operation; 2638 else { /* rhs is OK */ 2639 decNumberCopy(res, lhs); 2640 /* convert -ve rotate to equivalent positive rotation */ 2641 if (rotate<0) rotate=set->digits+rotate; 2642 if (rotate!=0 && rotate!=set->digits /* zero or full rotation */ 2643 && !decNumberIsInfinite(res)) { /* lhs was infinite */ 2644 /* left-rotate to do; 0 < rotate < set->digits */ 2645 uInt units, shift; /* work */ 2646 uInt msudigits; /* digits in result msu */ 2647 Unit *msu=res->lsu+D2U(res->digits)-1; /* current msu */ 2648 Unit *msumax=res->lsu+D2U(set->digits)-1; /* rotation msu */ 2649 for (msu++; msu<=msumax; msu++) *msu=0; /* ensure high units=0 */ 2650 res->digits=set->digits; /* now full-length */ 2651 msudigits=MSUDIGITS(res->digits); /* actual digits in msu */ 2652 2653 /* rotation here is done in-place, in three steps */ 2654 /* 1. shift all to least up to one unit to unit-align final */ 2655 /* lsd [any digits shifted out are rotated to the left, */ 2656 /* abutted to the original msd (which may require split)] */ 2657 /* */ 2658 /* [if there are no whole units left to rotate, the */ 2659 /* rotation is now complete] */ 2660 /* */ 2661 /* 2. shift to least, from below the split point only, so that */ 2662 /* the final msd is in the right place in its Unit [any */ 2663 /* digits shifted out will fit exactly in the current msu, */ 2664 /* left aligned, no split required] */ 2665 /* */ 2666 /* 3. rotate all the units by reversing left part, right */ 2667 /* part, and then whole */ 2668 /* */ 2669 /* example: rotate right 8 digits (2 units + 2), DECDPUN=3. */ 2670 /* */ 2671 /* start: 00a bcd efg hij klm npq */ 2672 /* */ 2673 /* 1a 000 0ab cde fgh|ijk lmn [pq saved] */ 2674 /* 1b 00p qab cde fgh|ijk lmn */ 2675 /* */ 2676 /* 2a 00p qab cde fgh|00i jkl [mn saved] */ 2677 /* 2b mnp qab cde fgh|00i jkl */ 2678 /* */ 2679 /* 3a fgh cde qab mnp|00i jkl */ 2680 /* 3b fgh cde qab mnp|jkl 00i */ 2681 /* 3c 00i jkl mnp qab cde fgh */ 2682 2683 /* Step 1: amount to shift is the partial right-rotate count */ 2684 rotate=set->digits-rotate; /* make it right-rotate */ 2685 units=rotate/DECDPUN; /* whole units to rotate */ 2686 shift=rotate%DECDPUN; /* left-over digits count */ 2687 if (shift>0) { /* not an exact number of units */ 2688 uInt save=res->lsu[0]%powers[shift]; /* save low digit(s) */ 2689 decShiftToLeast(res->lsu, D2U(res->digits), shift); 2690 if (shift>msudigits) { /* msumax-1 needs >0 digits */ 2691 uInt rem=save%powers[shift-msudigits];/* split save */ 2692 *msumax=(Unit)(save/powers[shift-msudigits]); /* and insert */ 2693 *(msumax-1)=*(msumax-1) 2694 +(Unit)(rem*powers[DECDPUN-(shift-msudigits)]); /* .. */ 2695 } 2696 else { /* all fits in msumax */ 2697 *msumax=*msumax+(Unit)(save*powers[msudigits-shift]); /* [maybe *1] */ 2698 } 2699 } /* digits shift needed */ 2700 2701 /* If whole units to rotate... */ 2702 if (units>0) { /* some to do */ 2703 /* Step 2: the units to touch are the whole ones in rotate, */ 2704 /* if any, and the shift is DECDPUN-msudigits (which may be */ 2705 /* 0, again) */ 2706 shift=DECDPUN-msudigits; 2707 if (shift>0) { /* not an exact number of units */ 2708 uInt save=res->lsu[0]%powers[shift]; /* save low digit(s) */ 2709 decShiftToLeast(res->lsu, units, shift); 2710 *msumax=*msumax+(Unit)(save*powers[msudigits]); 2711 } /* partial shift needed */ 2712 2713 /* Step 3: rotate the units array using triple reverse */ 2714 /* (reversing is easy and fast) */ 2715 decReverse(res->lsu+units, msumax); /* left part */ 2716 decReverse(res->lsu, res->lsu+units-1); /* right part */ 2717 decReverse(res->lsu, msumax); /* whole */ 2718 } /* whole units to rotate */ 2719 /* the rotation may have left an undetermined number of zeros */ 2720 /* on the left, so true length needs to be calculated */ 2721 res->digits=decGetDigits(res->lsu, msumax-res->lsu+1); 2722 } /* rotate needed */ 2723 } /* rhs OK */ 2724 } /* numerics */ 2725 if (status!=0) decStatus(res, status, set); 2726 return res; 2727 } /* decNumberRotate */ 2728 2729 /* ------------------------------------------------------------------ */ 2730 /* decNumberSameQuantum -- test for equal exponents */ 2731 /* */ 2732 /* res is the result number, which will contain either 0 or 1 */ 2733 /* lhs is a number to test */ 2734 /* rhs is the second (usually a pattern) */ 2735 /* */ 2736 /* No errors are possible and no context is needed. */ 2737 /* ------------------------------------------------------------------ */ 2738 decNumber * decNumberSameQuantum(decNumber *res, const decNumber *lhs, 2739 const decNumber *rhs) { 2740 Unit ret=0; /* return value */ 2741 2742 #if DECCHECK 2743 if (decCheckOperands(res, lhs, rhs, DECUNCONT)) return res; 2744 #endif 2745 2746 if (SPECIALARGS) { 2747 if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1; 2748 else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1; 2749 /* [anything else with a special gives 0] */ 2750 } 2751 else if (lhs->exponent==rhs->exponent) ret=1; 2752 2753 decNumberZero(res); /* OK to overwrite an operand now */ 2754 *res->lsu=ret; 2755 return res; 2756 } /* decNumberSameQuantum */ 2757 2758 /* ------------------------------------------------------------------ */ 2759 /* decNumberScaleB -- multiply by a power of 10 */ 2760 /* */ 2761 /* This computes C = A x 10**B where B is an integer (q=0) with */ 2762 /* maximum magnitude 2*(emax+digits) */ 2763 /* */ 2764 /* res is C, the result. C may be A or B */ 2765 /* lhs is A, the number to adjust */ 2766 /* rhs is B, the requested power of ten to use */ 2767 /* set is the context */ 2768 /* */ 2769 /* C must have space for set->digits digits. */ 2770 /* */ 2771 /* The result may underflow or overflow. */ 2772 /* ------------------------------------------------------------------ */ 2773 decNumber * decNumberScaleB(decNumber *res, const decNumber *lhs, 2774 const decNumber *rhs, decContext *set) { 2775 Int reqexp; /* requested exponent change [B] */ 2776 uInt status=0; /* accumulator */ 2777 Int residue; /* work */ 2778 2779 #if DECCHECK 2780 if (decCheckOperands(res, lhs, rhs, set)) return res; 2781 #endif 2782 2783 /* Handle special values except lhs infinite */ 2784 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) 2785 decNaNs(res, lhs, rhs, set, &status); 2786 /* rhs must be an integer */ 2787 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0) 2788 status=DEC_Invalid_operation; 2789 else { 2790 /* lhs is a number; rhs is a finite with q==0 */ 2791 reqexp=decGetInt(rhs); /* [cannot fail] */ 2792 if (reqexp==BADINT /* something bad .. */ 2793 || reqexp==BIGODD || reqexp==BIGEVEN /* .. very big .. */ 2794 || abs(reqexp)>(2*(set->digits+set->emax))) /* .. or out of range */ 2795 status=DEC_Invalid_operation; 2796 else { /* rhs is OK */ 2797 decNumberCopy(res, lhs); /* all done if infinite lhs */ 2798 if (!decNumberIsInfinite(res)) { /* prepare to scale */ 2799 res->exponent+=reqexp; /* adjust the exponent */ 2800 residue=0; 2801 decFinalize(res, set, &residue, &status); /* .. and check */ 2802 } /* finite LHS */ 2803 } /* rhs OK */ 2804 } /* rhs finite */ 2805 if (status!=0) decStatus(res, status, set); 2806 return res; 2807 } /* decNumberScaleB */ 2808 2809 /* ------------------------------------------------------------------ */ 2810 /* decNumberShift -- shift the coefficient of a Number left or right */ 2811 /* */ 2812 /* This computes C = A << B or C = A >> -B (in base ten). */ 2813 /* */ 2814 /* res is C, the result. C may be A and/or B (e.g., X=X<<X) */ 2815 /* lhs is A */ 2816 /* rhs is B, the number of digits to shift (-ve to right) */ 2817 /* set is the context */ 2818 /* */ 2819 /* The digits of the coefficient of A are shifted to the left (if B */ 2820 /* is positive) or to the right (if B is negative) without adjusting */ 2821 /* the exponent or the sign of A. */ 2822 /* */ 2823 /* B must be an integer (q=0) and in the range -set->digits through */ 2824 /* +set->digits. */ 2825 /* C must have space for set->digits digits. */ 2826 /* NaNs are propagated as usual. Infinities are unaffected (but */ 2827 /* B must be valid). No status is set unless B is invalid or an */ 2828 /* operand is an sNaN. */ 2829 /* ------------------------------------------------------------------ */ 2830 decNumber * decNumberShift(decNumber *res, const decNumber *lhs, 2831 const decNumber *rhs, decContext *set) { 2832 uInt status=0; /* accumulator */ 2833 Int shift; /* rhs as an Int */ 2834 2835 #if DECCHECK 2836 if (decCheckOperands(res, lhs, rhs, set)) return res; 2837 #endif 2838 2839 /* NaNs propagate as normal */ 2840 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) 2841 decNaNs(res, lhs, rhs, set, &status); 2842 /* rhs must be an integer */ 2843 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0) 2844 status=DEC_Invalid_operation; 2845 else { /* both numeric, rhs is an integer */ 2846 shift=decGetInt(rhs); /* [cannot fail] */ 2847 if (shift==BADINT /* something bad .. */ 2848 || shift==BIGODD || shift==BIGEVEN /* .. very big .. */ 2849 || abs(shift)>set->digits) /* .. or out of range */ 2850 status=DEC_Invalid_operation; 2851 else { /* rhs is OK */ 2852 decNumberCopy(res, lhs); 2853 if (shift!=0 && !decNumberIsInfinite(res)) { /* something to do */ 2854 if (shift>0) { /* to left */ 2855 if (shift==set->digits) { /* removing all */ 2856 *res->lsu=0; /* so place 0 */ 2857 res->digits=1; /* .. */ 2858 } 2859 else { /* */ 2860 /* first remove leading digits if necessary */ 2861 if (res->digits+shift>set->digits) { 2862 decDecap(res, res->digits+shift-set->digits); 2863 /* that updated res->digits; may have gone to 1 (for a */ 2864 /* single digit or for zero */ 2865 } 2866 if (res->digits>1 || *res->lsu) /* if non-zero.. */ 2867 res->digits=decShiftToMost(res->lsu, res->digits, shift); 2868 } /* partial left */ 2869 } /* left */ 2870 else { /* to right */ 2871 if (-shift>=res->digits) { /* discarding all */ 2872 *res->lsu=0; /* so place 0 */ 2873 res->digits=1; /* .. */ 2874 } 2875 else { 2876 decShiftToLeast(res->lsu, D2U(res->digits), -shift); 2877 res->digits-=(-shift); 2878 } 2879 } /* to right */ 2880 } /* non-0 non-Inf shift */ 2881 } /* rhs OK */ 2882 } /* numerics */ 2883 if (status!=0) decStatus(res, status, set); 2884 return res; 2885 } /* decNumberShift */ 2886 2887 /* ------------------------------------------------------------------ */ 2888 /* decNumberSquareRoot -- square root operator */ 2889 /* */ 2890 /* This computes C = squareroot(A) */ 2891 /* */ 2892 /* res is C, the result. C may be A */ 2893 /* rhs is A */ 2894 /* set is the context; note that rounding mode has no effect */ 2895 /* */ 2896 /* C must have space for set->digits digits. */ 2897 /* ------------------------------------------------------------------ */ 2898 /* This uses the following varying-precision algorithm in: */ 2899 /* */ 2900 /* Properly Rounded Variable Precision Square Root, T. E. Hull and */ 2901 /* A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, */ 2902 /* pp229-237, ACM, September 1985. */ 2903 /* */ 2904 /* The square-root is calculated using Newton's method, after which */ 2905 /* a check is made to ensure the result is correctly rounded. */ 2906 /* */ 2907 /* % [Reformatted original Numerical Turing source code follows.] */ 2908 /* function sqrt(x : real) : real */ 2909 /* % sqrt(x) returns the properly rounded approximation to the square */ 2910 /* % root of x, in the precision of the calling environment, or it */ 2911 /* % fails if x < 0. */ 2912 /* % t e hull and a abrham, august, 1984 */ 2913 /* if x <= 0 then */ 2914 /* if x < 0 then */ 2915 /* assert false */ 2916 /* else */ 2917 /* result 0 */ 2918 /* end if */ 2919 /* end if */ 2920 /* var f := setexp(x, 0) % fraction part of x [0.1 <= x < 1] */ 2921 /* var e := getexp(x) % exponent part of x */ 2922 /* var approx : real */ 2923 /* if e mod 2 = 0 then */ 2924 /* approx := .259 + .819 * f % approx to root of f */ 2925 /* else */ 2926 /* f := f/l0 % adjustments */ 2927 /* e := e + 1 % for odd */ 2928 /* approx := .0819 + 2.59 * f % exponent */ 2929 /* end if */ 2930 /* */ 2931 /* var p:= 3 */ 2932 /* const maxp := currentprecision + 2 */ 2933 /* loop */ 2934 /* p := min(2*p - 2, maxp) % p = 4,6,10, . . . , maxp */ 2935 /* precision p */ 2936 /* approx := .5 * (approx + f/approx) */ 2937 /* exit when p = maxp */ 2938 /* end loop */ 2939 /* */ 2940 /* % approx is now within 1 ulp of the properly rounded square root */ 2941 /* % of f; to ensure proper rounding, compare squares of (approx - */ 2942 /* % l/2 ulp) and (approx + l/2 ulp) with f. */ 2943 /* p := currentprecision */ 2944 /* begin */ 2945 /* precision p + 2 */ 2946 /* const approxsubhalf := approx - setexp(.5, -p) */ 2947 /* if mulru(approxsubhalf, approxsubhalf) > f then */ 2948 /* approx := approx - setexp(.l, -p + 1) */ 2949 /* else */ 2950 /* const approxaddhalf := approx + setexp(.5, -p) */ 2951 /* if mulrd(approxaddhalf, approxaddhalf) < f then */ 2952 /* approx := approx + setexp(.l, -p + 1) */ 2953 /* end if */ 2954 /* end if */ 2955 /* end */ 2956 /* result setexp(approx, e div 2) % fix exponent */ 2957 /* end sqrt */ 2958 /* ------------------------------------------------------------------ */ 2959 decNumber * decNumberSquareRoot(decNumber *res, const decNumber *rhs, 2960 decContext *set) { 2961 decContext workset, approxset; /* work contexts */ 2962 decNumber dzero; /* used for constant zero */ 2963 Int maxp; /* largest working precision */ 2964 Int workp; /* working precision */ 2965 Int residue=0; /* rounding residue */ 2966 uInt status=0, ignore=0; /* status accumulators */ 2967 uInt rstatus; /* .. */ 2968 Int exp; /* working exponent */ 2969 Int ideal; /* ideal (preferred) exponent */ 2970 Int needbytes; /* work */ 2971 Int dropped; /* .. */ 2972 2973 #if DECSUBSET 2974 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 2975 #endif 2976 /* buffer for f [needs +1 in case DECBUFFER 0] */ 2977 decNumber buff[D2N(DECBUFFER+1)]; 2978 /* buffer for a [needs +2 to match likely maxp] */ 2979 decNumber bufa[D2N(DECBUFFER+2)]; 2980 /* buffer for temporary, b [must be same size as a] */ 2981 decNumber bufb[D2N(DECBUFFER+2)]; 2982 decNumber *allocbuff=NULL; /* -> allocated buff, iff allocated */ 2983 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 2984 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */ 2985 decNumber *f=buff; /* reduced fraction */ 2986 decNumber *a=bufa; /* approximation to result */ 2987 decNumber *b=bufb; /* intermediate result */ 2988 /* buffer for temporary variable, up to 3 digits */ 2989 decNumber buft[D2N(3)]; 2990 decNumber *t=buft; /* up-to-3-digit constant or work */ 2991 2992 #if DECCHECK 2993 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 2994 #endif 2995 2996 do { /* protect allocated storage */ 2997 #if DECSUBSET 2998 if (!set->extended) { 2999 /* reduce operand and set lostDigits status, as needed */ 3000 if (rhs->digits>set->digits) { 3001 allocrhs=decRoundOperand(rhs, set, &status); 3002 if (allocrhs==NULL) break; 3003 /* [Note: 'f' allocation below could reuse this buffer if */ 3004 /* used, but as this is rare they are kept separate for clarity.] */ 3005 rhs=allocrhs; 3006 } 3007 } 3008 #endif 3009 /* [following code does not require input rounding] */ 3010 3011 /* handle infinities and NaNs */ 3012 if (SPECIALARG) { 3013 if (decNumberIsInfinite(rhs)) { /* an infinity */ 3014 if (decNumberIsNegative(rhs)) status|=DEC_Invalid_operation; 3015 else decNumberCopy(res, rhs); /* +Infinity */ 3016 } 3017 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */ 3018 break; 3019 } 3020 3021 /* calculate the ideal (preferred) exponent [floor(exp/2)] */ 3022 /* [We would like to write: ideal=rhs->exponent>>1, but this */ 3023 /* generates a compiler warning. Generated code is the same.] */ 3024 ideal=(rhs->exponent&~1)/2; /* target */ 3025 3026 /* handle zeros */ 3027 if (ISZERO(rhs)) { 3028 decNumberCopy(res, rhs); /* could be 0 or -0 */ 3029 res->exponent=ideal; /* use the ideal [safe] */ 3030 /* use decFinish to clamp any out-of-range exponent, etc. */ 3031 decFinish(res, set, &residue, &status); 3032 break; 3033 } 3034 3035 /* any other -x is an oops */ 3036 if (decNumberIsNegative(rhs)) { 3037 status|=DEC_Invalid_operation; 3038 break; 3039 } 3040 3041 /* space is needed for three working variables */ 3042 /* f -- the same precision as the RHS, reduced to 0.01->0.99... */ 3043 /* a -- Hull's approximation -- precision, when assigned, is */ 3044 /* currentprecision+1 or the input argument precision, */ 3045 /* whichever is larger (+2 for use as temporary) */ 3046 /* b -- intermediate temporary result (same size as a) */ 3047 /* if any is too long for local storage, then allocate */ 3048 workp=MAXI(set->digits+1, rhs->digits); /* actual rounding precision */ 3049 maxp=workp+2; /* largest working precision */ 3050 3051 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); 3052 if (needbytes>(Int)sizeof(buff)) { 3053 allocbuff=(decNumber *)malloc(needbytes); 3054 if (allocbuff==NULL) { /* hopeless -- abandon */ 3055 status|=DEC_Insufficient_storage; 3056 break;} 3057 f=allocbuff; /* use the allocated space */ 3058 } 3059 /* a and b both need to be able to hold a maxp-length number */ 3060 needbytes=sizeof(decNumber)+(D2U(maxp)-1)*sizeof(Unit); 3061 if (needbytes>(Int)sizeof(bufa)) { /* [same applies to b] */ 3062 allocbufa=(decNumber *)malloc(needbytes); 3063 allocbufb=(decNumber *)malloc(needbytes); 3064 if (allocbufa==NULL || allocbufb==NULL) { /* hopeless */ 3065 status|=DEC_Insufficient_storage; 3066 break;} 3067 a=allocbufa; /* use the allocated spaces */ 3068 b=allocbufb; /* .. */ 3069 } 3070 3071 /* copy rhs -> f, save exponent, and reduce so 0.1 <= f < 1 */ 3072 decNumberCopy(f, rhs); 3073 exp=f->exponent+f->digits; /* adjusted to Hull rules */ 3074 f->exponent=-(f->digits); /* to range */ 3075 3076 /* set up working context */ 3077 decContextDefault(&workset, DEC_INIT_DECIMAL64); 3078 3079 /* [Until further notice, no error is possible and status bits */ 3080 /* (Rounded, etc.) should be ignored, not accumulated.] */ 3081 3082 /* Calculate initial approximation, and allow for odd exponent */ 3083 workset.digits=workp; /* p for initial calculation */ 3084 t->bits=0; t->digits=3; 3085 a->bits=0; a->digits=3; 3086 if ((exp & 1)==0) { /* even exponent */ 3087 /* Set t=0.259, a=0.819 */ 3088 t->exponent=-3; 3089 a->exponent=-3; 3090 #if DECDPUN>=3 3091 t->lsu[0]=259; 3092 a->lsu[0]=819; 3093 #elif DECDPUN==2 3094 t->lsu[0]=59; t->lsu[1]=2; 3095 a->lsu[0]=19; a->lsu[1]=8; 3096 #else 3097 t->lsu[0]=9; t->lsu[1]=5; t->lsu[2]=2; 3098 a->lsu[0]=9; a->lsu[1]=1; a->lsu[2]=8; 3099 #endif 3100 } 3101 else { /* odd exponent */ 3102 /* Set t=0.0819, a=2.59 */ 3103 f->exponent--; /* f=f/10 */ 3104 exp++; /* e=e+1 */ 3105 t->exponent=-4; 3106 a->exponent=-2; 3107 #if DECDPUN>=3 3108 t->lsu[0]=819; 3109 a->lsu[0]=259; 3110 #elif DECDPUN==2 3111 t->lsu[0]=19; t->lsu[1]=8; 3112 a->lsu[0]=59; a->lsu[1]=2; 3113 #else 3114 t->lsu[0]=9; t->lsu[1]=1; t->lsu[2]=8; 3115 a->lsu[0]=9; a->lsu[1]=5; a->lsu[2]=2; 3116 #endif 3117 } 3118 decMultiplyOp(a, a, f, &workset, &ignore); /* a=a*f */ 3119 decAddOp(a, a, t, &workset, 0, &ignore); /* ..+t */ 3120 /* [a is now the initial approximation for sqrt(f), calculated with */ 3121 /* currentprecision, which is also a's precision.] */ 3122 3123 /* the main calculation loop */ 3124 decNumberZero(&dzero); /* make 0 */ 3125 decNumberZero(t); /* set t = 0.5 */ 3126 t->lsu[0]=5; /* .. */ 3127 t->exponent=-1; /* .. */ 3128 workset.digits=3; /* initial p */ 3129 for (;;) { 3130 /* set p to min(2*p - 2, maxp) [hence 3; or: 4, 6, 10, ... , maxp] */ 3131 workset.digits=workset.digits*2-2; 3132 if (workset.digits>maxp) workset.digits=maxp; 3133 /* a = 0.5 * (a + f/a) */ 3134 /* [calculated at p then rounded to currentprecision] */ 3135 decDivideOp(b, f, a, &workset, DIVIDE, &ignore); /* b=f/a */ 3136 decAddOp(b, b, a, &workset, 0, &ignore); /* b=b+a */ 3137 decMultiplyOp(a, b, t, &workset, &ignore); /* a=b*0.5 */ 3138 if (a->digits==maxp) break; /* have required digits */ 3139 } /* loop */ 3140 3141 /* Here, 0.1 <= a < 1 [Hull], and a has maxp digits */ 3142 /* now reduce to length, etc.; this needs to be done with a */ 3143 /* having the correct exponent so as to handle subnormals */ 3144 /* correctly */ 3145 approxset=*set; /* get emin, emax, etc. */ 3146 approxset.round=DEC_ROUND_HALF_EVEN; 3147 a->exponent+=exp/2; /* set correct exponent */ 3148 3149 rstatus=0; /* clear status */ 3150 residue=0; /* .. and accumulator */ 3151 decCopyFit(a, a, &approxset, &residue, &rstatus); /* reduce (if needed) */ 3152 decFinish(a, &approxset, &residue, &rstatus); /* clean and finalize */ 3153 3154 /* Overflow was possible if the input exponent was out-of-range, */ 3155 /* in which case quit */ 3156 if (rstatus&DEC_Overflow) { 3157 status=rstatus; /* use the status as-is */ 3158 decNumberCopy(res, a); /* copy to result */ 3159 break; 3160 } 3161 3162 /* Preserve status except Inexact/Rounded */ 3163 status|=(rstatus & ~(DEC_Rounded|DEC_Inexact)); 3164 3165 /* Carry out the Hull correction */ 3166 a->exponent-=exp/2; /* back to 0.1->1 */ 3167 3168 /* a is now at final precision and within 1 ulp of the properly */ 3169 /* rounded square root of f; to ensure proper rounding, compare */ 3170 /* squares of (a - l/2 ulp) and (a + l/2 ulp) with f. */ 3171 /* Here workset.digits=maxp and t=0.5, and a->digits determines */ 3172 /* the ulp */ 3173 workset.digits--; /* maxp-1 is OK now */ 3174 t->exponent=-a->digits-1; /* make 0.5 ulp */ 3175 decAddOp(b, a, t, &workset, DECNEG, &ignore); /* b = a - 0.5 ulp */ 3176 workset.round=DEC_ROUND_UP; 3177 decMultiplyOp(b, b, b, &workset, &ignore); /* b = mulru(b, b) */ 3178 decCompareOp(b, f, b, &workset, COMPARE, &ignore); /* b ? f, reversed */ 3179 if (decNumberIsNegative(b)) { /* f < b [i.e., b > f] */ 3180 /* this is the more common adjustment, though both are rare */ 3181 t->exponent++; /* make 1.0 ulp */ 3182 t->lsu[0]=1; /* .. */ 3183 decAddOp(a, a, t, &workset, DECNEG, &ignore); /* a = a - 1 ulp */ 3184 /* assign to approx [round to length] */ 3185 approxset.emin-=exp/2; /* adjust to match a */ 3186 approxset.emax-=exp/2; 3187 decAddOp(a, &dzero, a, &approxset, 0, &ignore); 3188 } 3189 else { 3190 decAddOp(b, a, t, &workset, 0, &ignore); /* b = a + 0.5 ulp */ 3191 workset.round=DEC_ROUND_DOWN; 3192 decMultiplyOp(b, b, b, &workset, &ignore); /* b = mulrd(b, b) */ 3193 decCompareOp(b, b, f, &workset, COMPARE, &ignore); /* b ? f */ 3194 if (decNumberIsNegative(b)) { /* b < f */ 3195 t->exponent++; /* make 1.0 ulp */ 3196 t->lsu[0]=1; /* .. */ 3197 decAddOp(a, a, t, &workset, 0, &ignore); /* a = a + 1 ulp */ 3198 /* assign to approx [round to length] */ 3199 approxset.emin-=exp/2; /* adjust to match a */ 3200 approxset.emax-=exp/2; 3201 decAddOp(a, &dzero, a, &approxset, 0, &ignore); 3202 } 3203 } 3204 /* [no errors are possible in the above, and rounding/inexact during */ 3205 /* estimation are irrelevant, so status was not accumulated] */ 3206 3207 /* Here, 0.1 <= a < 1 (still), so adjust back */ 3208 a->exponent+=exp/2; /* set correct exponent */ 3209 3210 /* count droppable zeros [after any subnormal rounding] by */ 3211 /* trimming a copy */ 3212 decNumberCopy(b, a); 3213 decTrim(b, set, 1, &dropped); /* [drops trailing zeros] */ 3214 3215 /* Set Inexact and Rounded. The answer can only be exact if */ 3216 /* it is short enough so that squaring it could fit in workp digits, */ 3217 /* and it cannot have trailing zeros due to clamping, so these are */ 3218 /* the only (relatively rare) conditions a careful check is needed */ 3219 if (b->digits*2-1 > workp && !set->clamp) { /* cannot fit */ 3220 status|=DEC_Inexact|DEC_Rounded; 3221 } 3222 else { /* could be exact/unrounded */ 3223 uInt mstatus=0; /* local status */ 3224 decMultiplyOp(b, b, b, &workset, &mstatus); /* try the multiply */ 3225 if (mstatus&DEC_Overflow) { /* result just won't fit */ 3226 status|=DEC_Inexact|DEC_Rounded; 3227 } 3228 else { /* plausible */ 3229 decCompareOp(t, b, rhs, &workset, COMPARE, &mstatus); /* b ? rhs */ 3230 if (!ISZERO(t)) status|=DEC_Inexact|DEC_Rounded; /* not equal */ 3231 else { /* is Exact */ 3232 /* here, dropped is the count of trailing zeros in 'a' */ 3233 /* use closest exponent to ideal... */ 3234 Int todrop=ideal-a->exponent; /* most that can be dropped */ 3235 if (todrop<0) status|=DEC_Rounded; /* ideally would add 0s */ 3236 else { /* unrounded */ 3237 if (dropped<todrop) { /* clamp to those available */ 3238 todrop=dropped; 3239 status|=DEC_Clamped; 3240 } 3241 if (todrop>0) { /* have some to drop */ 3242 decShiftToLeast(a->lsu, D2U(a->digits), todrop); 3243 a->exponent+=todrop; /* maintain numerical value */ 3244 a->digits-=todrop; /* new length */ 3245 } 3246 } 3247 } 3248 } 3249 } 3250 3251 /* double-check Underflow, as perhaps the result could not have */ 3252 /* been subnormal (initial argument too big), or it is now Exact */ 3253 if (status&DEC_Underflow) { 3254 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */ 3255 /* check if truly subnormal */ 3256 #if DECEXTFLAG /* DEC_Subnormal too */ 3257 if (ae>=set->emin*2) status&=~(DEC_Subnormal|DEC_Underflow); 3258 #else 3259 if (ae>=set->emin*2) status&=~DEC_Underflow; 3260 #endif 3261 /* check if truly inexact */ 3262 if (!(status&DEC_Inexact)) status&=~DEC_Underflow; 3263 } 3264 3265 decNumberCopy(res, a); /* a is now the result */ 3266 } while(0); /* end protected */ 3267 3268 if (allocbuff!=NULL) free(allocbuff); /* drop any storage used */ 3269 if (allocbufa!=NULL) free(allocbufa); /* .. */ 3270 if (allocbufb!=NULL) free(allocbufb); /* .. */ 3271 #if DECSUBSET 3272 if (allocrhs !=NULL) free(allocrhs); /* .. */ 3273 #endif 3274 if (status!=0) decStatus(res, status, set);/* then report status */ 3275 #if DECCHECK 3276 decCheckInexact(res, set); 3277 #endif 3278 return res; 3279 } /* decNumberSquareRoot */ 3280 3281 /* ------------------------------------------------------------------ */ 3282 /* decNumberSubtract -- subtract two Numbers */ 3283 /* */ 3284 /* This computes C = A - B */ 3285 /* */ 3286 /* res is C, the result. C may be A and/or B (e.g., X=X-X) */ 3287 /* lhs is A */ 3288 /* rhs is B */ 3289 /* set is the context */ 3290 /* */ 3291 /* C must have space for set->digits digits. */ 3292 /* ------------------------------------------------------------------ */ 3293 decNumber * decNumberSubtract(decNumber *res, const decNumber *lhs, 3294 const decNumber *rhs, decContext *set) { 3295 uInt status=0; /* accumulator */ 3296 3297 decAddOp(res, lhs, rhs, set, DECNEG, &status); 3298 if (status!=0) decStatus(res, status, set); 3299 #if DECCHECK 3300 decCheckInexact(res, set); 3301 #endif 3302 return res; 3303 } /* decNumberSubtract */ 3304 3305 /* ------------------------------------------------------------------ */ 3306 /* decNumberToIntegralExact -- round-to-integral-value with InExact */ 3307 /* decNumberToIntegralValue -- round-to-integral-value */ 3308 /* */ 3309 /* res is the result */ 3310 /* rhs is input number */ 3311 /* set is the context */ 3312 /* */ 3313 /* res must have space for any value of rhs. */ 3314 /* */ 3315 /* This implements the IEEE special operators and therefore treats */ 3316 /* special values as valid. For finite numbers it returns */ 3317 /* rescale(rhs, 0) if rhs->exponent is <0. */ 3318 /* Otherwise the result is rhs (so no error is possible, except for */ 3319 /* sNaN). */ 3320 /* */ 3321 /* The context is used for rounding mode and status after sNaN, but */ 3322 /* the digits setting is ignored. The Exact version will signal */ 3323 /* Inexact if the result differs numerically from rhs; the other */ 3324 /* never signals Inexact. */ 3325 /* ------------------------------------------------------------------ */ 3326 decNumber * decNumberToIntegralExact(decNumber *res, const decNumber *rhs, 3327 decContext *set) { 3328 decNumber dn; 3329 decContext workset; /* working context */ 3330 uInt status=0; /* accumulator */ 3331 3332 #if DECCHECK 3333 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 3334 #endif 3335 3336 /* handle infinities and NaNs */ 3337 if (SPECIALARG) { 3338 if (decNumberIsInfinite(rhs)) decNumberCopy(res, rhs); /* an Infinity */ 3339 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */ 3340 } 3341 else { /* finite */ 3342 /* have a finite number; no error possible (res must be big enough) */ 3343 if (rhs->exponent>=0) return decNumberCopy(res, rhs); 3344 /* that was easy, but if negative exponent there is work to do... */ 3345 workset=*set; /* clone rounding, etc. */ 3346 workset.digits=rhs->digits; /* no length rounding */ 3347 workset.traps=0; /* no traps */ 3348 decNumberZero(&dn); /* make a number with exponent 0 */ 3349 decNumberQuantize(res, rhs, &dn, &workset); 3350 status|=workset.status; 3351 } 3352 if (status!=0) decStatus(res, status, set); 3353 return res; 3354 } /* decNumberToIntegralExact */ 3355 3356 decNumber * decNumberToIntegralValue(decNumber *res, const decNumber *rhs, 3357 decContext *set) { 3358 decContext workset=*set; /* working context */ 3359 workset.traps=0; /* no traps */ 3360 decNumberToIntegralExact(res, rhs, &workset); 3361 /* this never affects set, except for sNaNs; NaN will have been set */ 3362 /* or propagated already, so no need to call decStatus */ 3363 set->status|=workset.status&DEC_Invalid_operation; 3364 return res; 3365 } /* decNumberToIntegralValue */ 3366 3367 /* ------------------------------------------------------------------ */ 3368 /* decNumberXor -- XOR two Numbers, digitwise */ 3369 /* */ 3370 /* This computes C = A ^ B */ 3371 /* */ 3372 /* res is C, the result. C may be A and/or B (e.g., X=X^X) */ 3373 /* lhs is A */ 3374 /* rhs is B */ 3375 /* set is the context (used for result length and error report) */ 3376 /* */ 3377 /* C must have space for set->digits digits. */ 3378 /* */ 3379 /* Logical function restrictions apply (see above); a NaN is */ 3380 /* returned with Invalid_operation if a restriction is violated. */ 3381 /* ------------------------------------------------------------------ */ 3382 decNumber * decNumberXor(decNumber *res, const decNumber *lhs, 3383 const decNumber *rhs, decContext *set) { 3384 const Unit *ua, *ub; /* -> operands */ 3385 const Unit *msua, *msub; /* -> operand msus */ 3386 Unit *uc, *msuc; /* -> result and its msu */ 3387 Int msudigs; /* digits in res msu */ 3388 #if DECCHECK 3389 if (decCheckOperands(res, lhs, rhs, set)) return res; 3390 #endif 3391 3392 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs) 3393 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { 3394 decStatus(res, DEC_Invalid_operation, set); 3395 return res; 3396 } 3397 /* operands are valid */ 3398 ua=lhs->lsu; /* bottom-up */ 3399 ub=rhs->lsu; /* .. */ 3400 uc=res->lsu; /* .. */ 3401 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */ 3402 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ 3403 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ 3404 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ 3405 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */ 3406 Unit a, b; /* extract units */ 3407 if (ua>msua) a=0; 3408 else a=*ua; 3409 if (ub>msub) b=0; 3410 else b=*ub; 3411 *uc=0; /* can now write back */ 3412 if (a|b) { /* maybe 1 bits to examine */ 3413 Int i, j; 3414 /* This loop could be unrolled and/or use BIN2BCD tables */ 3415 for (i=0; i<DECDPUN; i++) { 3416 if ((a^b)&1) *uc=*uc+(Unit)powers[i]; /* effect XOR */ 3417 j=a%10; 3418 a=a/10; 3419 j|=b%10; 3420 b=b/10; 3421 if (j>1) { 3422 decStatus(res, DEC_Invalid_operation, set); 3423 return res; 3424 } 3425 if (uc==msuc && i==msudigs-1) break; /* just did final digit */ 3426 } /* each digit */ 3427 } /* non-zero */ 3428 } /* each unit */ 3429 /* [here uc-1 is the msu of the result] */ 3430 res->digits=decGetDigits(res->lsu, uc-res->lsu); 3431 res->exponent=0; /* integer */ 3432 res->bits=0; /* sign=0 */ 3433 return res; /* [no status to set] */ 3434 } /* decNumberXor */ 3435 3436 3437 /* ================================================================== */ 3438 /* Utility routines */ 3439 /* ================================================================== */ 3440 3441 /* ------------------------------------------------------------------ */ 3442 /* decNumberClass -- return the decClass of a decNumber */ 3443 /* dn -- the decNumber to test */ 3444 /* set -- the context to use for Emin */ 3445 /* returns the decClass enum */ 3446 /* ------------------------------------------------------------------ */ 3447 enum decClass decNumberClass(const decNumber *dn, decContext *set) { 3448 if (decNumberIsSpecial(dn)) { 3449 if (decNumberIsQNaN(dn)) return DEC_CLASS_QNAN; 3450 if (decNumberIsSNaN(dn)) return DEC_CLASS_SNAN; 3451 /* must be an infinity */ 3452 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_INF; 3453 return DEC_CLASS_POS_INF; 3454 } 3455 /* is finite */ 3456 if (decNumberIsNormal(dn, set)) { /* most common */ 3457 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_NORMAL; 3458 return DEC_CLASS_POS_NORMAL; 3459 } 3460 /* is subnormal or zero */ 3461 if (decNumberIsZero(dn)) { /* most common */ 3462 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_ZERO; 3463 return DEC_CLASS_POS_ZERO; 3464 } 3465 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_SUBNORMAL; 3466 return DEC_CLASS_POS_SUBNORMAL; 3467 } /* decNumberClass */ 3468 3469 /* ------------------------------------------------------------------ */ 3470 /* decNumberClassToString -- convert decClass to a string */ 3471 /* */ 3472 /* eclass is a valid decClass */ 3473 /* returns a constant string describing the class (max 13+1 chars) */ 3474 /* ------------------------------------------------------------------ */ 3475 const char *decNumberClassToString(enum decClass eclass) { 3476 if (eclass==DEC_CLASS_POS_NORMAL) return DEC_ClassString_PN; 3477 if (eclass==DEC_CLASS_NEG_NORMAL) return DEC_ClassString_NN; 3478 if (eclass==DEC_CLASS_POS_ZERO) return DEC_ClassString_PZ; 3479 if (eclass==DEC_CLASS_NEG_ZERO) return DEC_ClassString_NZ; 3480 if (eclass==DEC_CLASS_POS_SUBNORMAL) return DEC_ClassString_PS; 3481 if (eclass==DEC_CLASS_NEG_SUBNORMAL) return DEC_ClassString_NS; 3482 if (eclass==DEC_CLASS_POS_INF) return DEC_ClassString_PI; 3483 if (eclass==DEC_CLASS_NEG_INF) return DEC_ClassString_NI; 3484 if (eclass==DEC_CLASS_QNAN) return DEC_ClassString_QN; 3485 if (eclass==DEC_CLASS_SNAN) return DEC_ClassString_SN; 3486 return DEC_ClassString_UN; /* Unknown */ 3487 } /* decNumberClassToString */ 3488 3489 /* ------------------------------------------------------------------ */ 3490 /* decNumberCopy -- copy a number */ 3491 /* */ 3492 /* dest is the target decNumber */ 3493 /* src is the source decNumber */ 3494 /* returns dest */ 3495 /* */ 3496 /* (dest==src is allowed and is a no-op) */ 3497 /* All fields are updated as required. This is a utility operation, */ 3498 /* so special values are unchanged and no error is possible. */ 3499 /* ------------------------------------------------------------------ */ 3500 decNumber * decNumberCopy(decNumber *dest, const decNumber *src) { 3501 3502 #if DECCHECK 3503 if (src==NULL) return decNumberZero(dest); 3504 #endif 3505 3506 if (dest==src) return dest; /* no copy required */ 3507 3508 /* Use explicit assignments here as structure assignment could copy */ 3509 /* more than just the lsu (for small DECDPUN). This would not affect */ 3510 /* the value of the results, but could disturb test harness spill */ 3511 /* checking. */ 3512 dest->bits=src->bits; 3513 dest->exponent=src->exponent; 3514 dest->digits=src->digits; 3515 dest->lsu[0]=src->lsu[0]; 3516 if (src->digits>DECDPUN) { /* more Units to come */ 3517 const Unit *smsup, *s; /* work */ 3518 Unit *d; /* .. */ 3519 /* memcpy for the remaining Units would be safe as they cannot */ 3520 /* overlap. However, this explicit loop is faster in short cases. */ 3521 d=dest->lsu+1; /* -> first destination */ 3522 smsup=src->lsu+D2U(src->digits); /* -> source msu+1 */ 3523 for (s=src->lsu+1; s<smsup; s++, d++) *d=*s; 3524 } 3525 return dest; 3526 } /* decNumberCopy */ 3527 3528 /* ------------------------------------------------------------------ */ 3529 /* decNumberCopyAbs -- quiet absolute value operator */ 3530 /* */ 3531 /* This sets C = abs(A) */ 3532 /* */ 3533 /* res is C, the result. C may be A */ 3534 /* rhs is A */ 3535 /* */ 3536 /* C must have space for set->digits digits. */ 3537 /* No exception or error can occur; this is a quiet bitwise operation.*/ 3538 /* See also decNumberAbs for a checking version of this. */ 3539 /* ------------------------------------------------------------------ */ 3540 decNumber * decNumberCopyAbs(decNumber *res, const decNumber *rhs) { 3541 #if DECCHECK 3542 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res; 3543 #endif 3544 decNumberCopy(res, rhs); 3545 res->bits&=~DECNEG; /* turn off sign */ 3546 return res; 3547 } /* decNumberCopyAbs */ 3548 3549 /* ------------------------------------------------------------------ */ 3550 /* decNumberCopyNegate -- quiet negate value operator */ 3551 /* */ 3552 /* This sets C = negate(A) */ 3553 /* */ 3554 /* res is C, the result. C may be A */ 3555 /* rhs is A */ 3556 /* */ 3557 /* C must have space for set->digits digits. */ 3558 /* No exception or error can occur; this is a quiet bitwise operation.*/ 3559 /* See also decNumberMinus for a checking version of this. */ 3560 /* ------------------------------------------------------------------ */ 3561 decNumber * decNumberCopyNegate(decNumber *res, const decNumber *rhs) { 3562 #if DECCHECK 3563 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res; 3564 #endif 3565 decNumberCopy(res, rhs); 3566 res->bits^=DECNEG; /* invert the sign */ 3567 return res; 3568 } /* decNumberCopyNegate */ 3569 3570 /* ------------------------------------------------------------------ */ 3571 /* decNumberCopySign -- quiet copy and set sign operator */ 3572 /* */ 3573 /* This sets C = A with the sign of B */ 3574 /* */ 3575 /* res is C, the result. C may be A */ 3576 /* lhs is A */ 3577 /* rhs is B */ 3578 /* */ 3579 /* C must have space for set->digits digits. */ 3580 /* No exception or error can occur; this is a quiet bitwise operation.*/ 3581 /* ------------------------------------------------------------------ */ 3582 decNumber * decNumberCopySign(decNumber *res, const decNumber *lhs, 3583 const decNumber *rhs) { 3584 uByte sign; /* rhs sign */ 3585 #if DECCHECK 3586 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res; 3587 #endif 3588 sign=rhs->bits & DECNEG; /* save sign bit */ 3589 decNumberCopy(res, lhs); 3590 res->bits&=~DECNEG; /* clear the sign */ 3591 res->bits|=sign; /* set from rhs */ 3592 return res; 3593 } /* decNumberCopySign */ 3594 3595 /* ------------------------------------------------------------------ */ 3596 /* decNumberGetBCD -- get the coefficient in BCD8 */ 3597 /* dn is the source decNumber */ 3598 /* bcd is the uInt array that will receive dn->digits BCD bytes, */ 3599 /* most-significant at offset 0 */ 3600 /* returns bcd */ 3601 /* */ 3602 /* bcd must have at least dn->digits bytes. No error is possible; if */ 3603 /* dn is a NaN or Infinite, digits must be 1 and the coefficient 0. */ 3604 /* ------------------------------------------------------------------ */ 3605 uByte * decNumberGetBCD(const decNumber *dn, uint8_t *bcd) { 3606 uByte *ub=bcd+dn->digits-1; /* -> lsd */ 3607 const Unit *up=dn->lsu; /* Unit pointer, -> lsu */ 3608 3609 #if DECDPUN==1 /* trivial simple copy */ 3610 for (; ub>=bcd; ub--, up++) *ub=*up; 3611 #else /* chopping needed */ 3612 uInt u=*up; /* work */ 3613 uInt cut=DECDPUN; /* downcounter through unit */ 3614 for (; ub>=bcd; ub--) { 3615 *ub=(uByte)(u%10); /* [*6554 trick inhibits, here] */ 3616 u=u/10; 3617 cut--; 3618 if (cut>0) continue; /* more in this unit */ 3619 up++; 3620 u=*up; 3621 cut=DECDPUN; 3622 } 3623 #endif 3624 return bcd; 3625 } /* decNumberGetBCD */ 3626 3627 /* ------------------------------------------------------------------ */ 3628 /* decNumberSetBCD -- set (replace) the coefficient from BCD8 */ 3629 /* dn is the target decNumber */ 3630 /* bcd is the uInt array that will source n BCD bytes, most- */ 3631 /* significant at offset 0 */ 3632 /* n is the number of digits in the source BCD array (bcd) */ 3633 /* returns dn */ 3634 /* */ 3635 /* dn must have space for at least n digits. No error is possible; */ 3636 /* if dn is a NaN, or Infinite, or is to become a zero, n must be 1 */ 3637 /* and bcd[0] zero. */ 3638 /* ------------------------------------------------------------------ */ 3639 decNumber * decNumberSetBCD(decNumber *dn, const uByte *bcd, uInt n) { 3640 Unit *up = dn->lsu + D2U(n) - 1; /* -> msu [target pointer] */ 3641 const uByte *ub=bcd; /* -> source msd */ 3642 3643 #if DECDPUN==1 /* trivial simple copy */ 3644 for (; ub<bcd+n; ub++, up--) *up=*ub; 3645 #else /* some assembly needed */ 3646 /* calculate how many digits in msu, and hence first cut */ 3647 Int cut=MSUDIGITS(n); /* [faster than remainder] */ 3648 for (;up>=dn->lsu; up--) { /* each Unit from msu */ 3649 *up=0; /* will take <=DECDPUN digits */ 3650 for (; cut>0; ub++, cut--) *up=X10(*up)+*ub; 3651 cut=DECDPUN; /* next Unit has all digits */ 3652 } 3653 #endif 3654 dn->digits=n; /* set digit count */ 3655 return dn; 3656 } /* decNumberSetBCD */ 3657 3658 /* ------------------------------------------------------------------ */ 3659 /* decNumberIsNormal -- test normality of a decNumber */ 3660 /* dn is the decNumber to test */ 3661 /* set is the context to use for Emin */ 3662 /* returns 1 if |dn| is finite and >=Nmin, 0 otherwise */ 3663 /* ------------------------------------------------------------------ */ 3664 Int decNumberIsNormal(const decNumber *dn, decContext *set) { 3665 Int ae; /* adjusted exponent */ 3666 #if DECCHECK 3667 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; 3668 #endif 3669 3670 if (decNumberIsSpecial(dn)) return 0; /* not finite */ 3671 if (decNumberIsZero(dn)) return 0; /* not non-zero */ 3672 3673 ae=dn->exponent+dn->digits-1; /* adjusted exponent */ 3674 if (ae<set->emin) return 0; /* is subnormal */ 3675 return 1; 3676 } /* decNumberIsNormal */ 3677 3678 /* ------------------------------------------------------------------ */ 3679 /* decNumberIsSubnormal -- test subnormality of a decNumber */ 3680 /* dn is the decNumber to test */ 3681 /* set is the context to use for Emin */ 3682 /* returns 1 if |dn| is finite, non-zero, and <Nmin, 0 otherwise */ 3683 /* ------------------------------------------------------------------ */ 3684 Int decNumberIsSubnormal(const decNumber *dn, decContext *set) { 3685 Int ae; /* adjusted exponent */ 3686 #if DECCHECK 3687 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; 3688 #endif 3689 3690 if (decNumberIsSpecial(dn)) return 0; /* not finite */ 3691 if (decNumberIsZero(dn)) return 0; /* not non-zero */ 3692 3693 ae=dn->exponent+dn->digits-1; /* adjusted exponent */ 3694 if (ae<set->emin) return 1; /* is subnormal */ 3695 return 0; 3696 } /* decNumberIsSubnormal */ 3697 3698 /* ------------------------------------------------------------------ */ 3699 /* decNumberTrim -- remove insignificant zeros */ 3700 /* */ 3701 /* dn is the number to trim */ 3702 /* returns dn */ 3703 /* */ 3704 /* All fields are updated as required. This is a utility operation, */ 3705 /* so special values are unchanged and no error is possible. */ 3706 /* ------------------------------------------------------------------ */ 3707 decNumber * decNumberTrim(decNumber *dn) { 3708 Int dropped; /* work */ 3709 decContext set; /* .. */ 3710 #if DECCHECK 3711 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, DECUNCONT)) return dn; 3712 #endif 3713 decContextDefault(&set, DEC_INIT_BASE); /* clamp=0 */ 3714 return decTrim(dn, &set, 0, &dropped); 3715 } /* decNumberTrim */ 3716 3717 /* ------------------------------------------------------------------ */ 3718 /* decNumberVersion -- return the name and version of this module */ 3719 /* */ 3720 /* No error is possible. */ 3721 /* ------------------------------------------------------------------ */ 3722 const char * decNumberVersion(void) { 3723 return DECVERSION; 3724 } /* decNumberVersion */ 3725 3726 /* ------------------------------------------------------------------ */ 3727 /* decNumberZero -- set a number to 0 */ 3728 /* */ 3729 /* dn is the number to set, with space for one digit */ 3730 /* returns dn */ 3731 /* */ 3732 /* No error is possible. */ 3733 /* ------------------------------------------------------------------ */ 3734 /* Memset is not used as it is much slower in some environments. */ 3735 decNumber * decNumberZero(decNumber *dn) { 3736 3737 #if DECCHECK 3738 if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn; 3739 #endif 3740 3741 dn->bits=0; 3742 dn->exponent=0; 3743 dn->digits=1; 3744 dn->lsu[0]=0; 3745 return dn; 3746 } /* decNumberZero */ 3747 3748 /* ================================================================== */ 3749 /* Local routines */ 3750 /* ================================================================== */ 3751 3752 /* ------------------------------------------------------------------ */ 3753 /* decToString -- lay out a number into a string */ 3754 /* */ 3755 /* dn is the number to lay out */ 3756 /* string is where to lay out the number */ 3757 /* eng is 1 if Engineering, 0 if Scientific */ 3758 /* */ 3759 /* string must be at least dn->digits+14 characters long */ 3760 /* No error is possible. */ 3761 /* */ 3762 /* Note that this routine can generate a -0 or 0.000. These are */ 3763 /* never generated in subset to-number or arithmetic, but can occur */ 3764 /* in non-subset arithmetic (e.g., -1*0 or 1.234-1.234). */ 3765 /* ------------------------------------------------------------------ */ 3766 /* If DECCHECK is enabled the string "?" is returned if a number is */ 3767 /* invalid. */ 3768 static void decToString(const decNumber *dn, char *string, Flag eng) { 3769 Int exp=dn->exponent; /* local copy */ 3770 Int e; /* E-part value */ 3771 Int pre; /* digits before the '.' */ 3772 Int cut; /* for counting digits in a Unit */ 3773 char *c=string; /* work [output pointer] */ 3774 const Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [input pointer] */ 3775 uInt u, pow; /* work */ 3776 3777 #if DECCHECK 3778 if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) { 3779 strcpy(string, "?"); 3780 return;} 3781 #endif 3782 3783 if (decNumberIsNegative(dn)) { /* Negatives get a minus */ 3784 *c='-'; 3785 c++; 3786 } 3787 if (dn->bits&DECSPECIAL) { /* Is a special value */ 3788 if (decNumberIsInfinite(dn)) { 3789 strcpy(c, "Inf"); 3790 strcpy(c+3, "inity"); 3791 return;} 3792 /* a NaN */ 3793 if (dn->bits&DECSNAN) { /* signalling NaN */ 3794 *c='s'; 3795 c++; 3796 } 3797 strcpy(c, "NaN"); 3798 c+=3; /* step past */ 3799 /* if not a clean non-zero coefficient, that's all there is in a */ 3800 /* NaN string */ 3801 if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return; 3802 /* [drop through to add integer] */ 3803 } 3804 3805 /* calculate how many digits in msu, and hence first cut */ 3806 cut=MSUDIGITS(dn->digits); /* [faster than remainder] */ 3807 cut--; /* power of ten for digit */ 3808 3809 if (exp==0) { /* simple integer [common fastpath] */ 3810 for (;up>=dn->lsu; up--) { /* each Unit from msu */ 3811 u=*up; /* contains DECDPUN digits to lay out */ 3812 for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow); 3813 cut=DECDPUN-1; /* next Unit has all digits */ 3814 } 3815 *c='\0'; /* terminate the string */ 3816 return;} 3817 3818 /* non-0 exponent -- assume plain form */ 3819 pre=dn->digits+exp; /* digits before '.' */ 3820 e=0; /* no E */ 3821 if ((exp>0) || (pre<-5)) { /* need exponential form */ 3822 e=exp+dn->digits-1; /* calculate E value */ 3823 pre=1; /* assume one digit before '.' */ 3824 if (eng && (e!=0)) { /* engineering: may need to adjust */ 3825 Int adj; /* adjustment */ 3826 /* The C remainder operator is undefined for negative numbers, so */ 3827 /* a positive remainder calculation must be used here */ 3828 if (e<0) { 3829 adj=(-e)%3; 3830 if (adj!=0) adj=3-adj; 3831 } 3832 else { /* e>0 */ 3833 adj=e%3; 3834 } 3835 e=e-adj; 3836 /* if dealing with zero still produce an exponent which is a */ 3837 /* multiple of three, as expected, but there will only be the */ 3838 /* one zero before the E, still. Otherwise note the padding. */ 3839 if (!ISZERO(dn)) pre+=adj; 3840 else { /* is zero */ 3841 if (adj!=0) { /* 0.00Esnn needed */ 3842 e=e+3; 3843 pre=-(2-adj); 3844 } 3845 } /* zero */ 3846 } /* eng */ 3847 } /* need exponent */ 3848 3849 /* lay out the digits of the coefficient, adding 0s and . as needed */ 3850 u=*up; 3851 if (pre>0) { /* xxx.xxx or xx00 (engineering) form */ 3852 Int n=pre; 3853 for (; pre>0; pre--, c++, cut--) { 3854 if (cut<0) { /* need new Unit */ 3855 if (up==dn->lsu) break; /* out of input digits (pre>digits) */ 3856 up--; 3857 cut=DECDPUN-1; 3858 u=*up; 3859 } 3860 TODIGIT(u, cut, c, pow); 3861 } 3862 if (n<dn->digits) { /* more to come, after '.' */ 3863 *c='.'; c++; 3864 for (;; c++, cut--) { 3865 if (cut<0) { /* need new Unit */ 3866 if (up==dn->lsu) break; /* out of input digits */ 3867 up--; 3868 cut=DECDPUN-1; 3869 u=*up; 3870 } 3871 TODIGIT(u, cut, c, pow); 3872 } 3873 } 3874 else for (; pre>0; pre--, c++) *c='0'; /* 0 padding (for engineering) needed */ 3875 } 3876 else { /* 0.xxx or 0.000xxx form */ 3877 *c='0'; c++; 3878 *c='.'; c++; 3879 for (; pre<0; pre++, c++) *c='0'; /* add any 0's after '.' */ 3880 for (; ; c++, cut--) { 3881 if (cut<0) { /* need new Unit */ 3882 if (up==dn->lsu) break; /* out of input digits */ 3883 up--; 3884 cut=DECDPUN-1; 3885 u=*up; 3886 } 3887 TODIGIT(u, cut, c, pow); 3888 } 3889 } 3890 3891 /* Finally add the E-part, if needed. It will never be 0, has a 3892 base maximum and minimum of +999999999 through -999999999, but 3893 could range down to -1999999998 for anormal numbers */ 3894 if (e!=0) { 3895 Flag had=0; /* 1=had non-zero */ 3896 *c='E'; c++; 3897 *c='+'; c++; /* assume positive */ 3898 u=e; /* .. */ 3899 if (e<0) { 3900 *(c-1)='-'; /* oops, need - */ 3901 u=-e; /* uInt, please */ 3902 } 3903 /* lay out the exponent [_itoa or equivalent is not ANSI C] */ 3904 for (cut=9; cut>=0; cut--) { 3905 TODIGIT(u, cut, c, pow); 3906 if (*c=='0' && !had) continue; /* skip leading zeros */ 3907 had=1; /* had non-0 */ 3908 c++; /* step for next */ 3909 } /* cut */ 3910 } 3911 *c='\0'; /* terminate the string (all paths) */ 3912 return; 3913 } /* decToString */ 3914 3915 /* ------------------------------------------------------------------ */ 3916 /* decAddOp -- add/subtract operation */ 3917 /* */ 3918 /* This computes C = A + B */ 3919 /* */ 3920 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */ 3921 /* lhs is A */ 3922 /* rhs is B */ 3923 /* set is the context */ 3924 /* negate is DECNEG if rhs should be negated, or 0 otherwise */ 3925 /* status accumulates status for the caller */ 3926 /* */ 3927 /* C must have space for set->digits digits. */ 3928 /* Inexact in status must be 0 for correct Exact zero sign in result */ 3929 /* ------------------------------------------------------------------ */ 3930 /* If possible, the coefficient is calculated directly into C. */ 3931 /* However, if: */ 3932 /* -- a digits+1 calculation is needed because the numbers are */ 3933 /* unaligned and span more than set->digits digits */ 3934 /* -- a carry to digits+1 digits looks possible */ 3935 /* -- C is the same as A or B, and the result would destructively */ 3936 /* overlap the A or B coefficient */ 3937 /* then the result must be calculated into a temporary buffer. In */ 3938 /* this case a local (stack) buffer is used if possible, and only if */ 3939 /* too long for that does malloc become the final resort. */ 3940 /* */ 3941 /* Misalignment is handled as follows: */ 3942 /* Apad: (AExp>BExp) Swap operands and proceed as for BExp>AExp. */ 3943 /* BPad: Apply the padding by a combination of shifting (whole */ 3944 /* units) and multiplication (part units). */ 3945 /* */ 3946 /* Addition, especially x=x+1, is speed-critical. */ 3947 /* The static buffer is larger than might be expected to allow for */ 3948 /* calls from higher-level functions (notably exp). */ 3949 /* ------------------------------------------------------------------ */ 3950 static decNumber * decAddOp(decNumber *res, const decNumber *lhs, 3951 const decNumber *rhs, decContext *set, 3952 uByte negate, uInt *status) { 3953 #if DECSUBSET 3954 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 3955 decNumber *allocrhs=NULL; /* .., rhs */ 3956 #endif 3957 Int rhsshift; /* working shift (in Units) */ 3958 Int maxdigits; /* longest logical length */ 3959 Int mult; /* multiplier */ 3960 Int residue; /* rounding accumulator */ 3961 uByte bits; /* result bits */ 3962 Flag diffsign; /* non-0 if arguments have different sign */ 3963 Unit *acc; /* accumulator for result */ 3964 Unit accbuff[SD2U(DECBUFFER*2+20)]; /* local buffer [*2+20 reduces many */ 3965 /* allocations when called from */ 3966 /* other operations, notable exp] */ 3967 Unit *allocacc=NULL; /* -> allocated acc buffer, iff allocated */ 3968 Int reqdigits=set->digits; /* local copy; requested DIGITS */ 3969 Int padding; /* work */ 3970 3971 #if DECCHECK 3972 if (decCheckOperands(res, lhs, rhs, set)) return res; 3973 #endif 3974 3975 do { /* protect allocated storage */ 3976 #if DECSUBSET 3977 if (!set->extended) { 3978 /* reduce operands and set lostDigits status, as needed */ 3979 if (lhs->digits>reqdigits) { 3980 alloclhs=decRoundOperand(lhs, set, status); 3981 if (alloclhs==NULL) break; 3982 lhs=alloclhs; 3983 } 3984 if (rhs->digits>reqdigits) { 3985 allocrhs=decRoundOperand(rhs, set, status); 3986 if (allocrhs==NULL) break; 3987 rhs=allocrhs; 3988 } 3989 } 3990 #endif 3991 /* [following code does not require input rounding] */ 3992 3993 /* note whether signs differ [used all paths] */ 3994 diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG); 3995 3996 /* handle infinities and NaNs */ 3997 if (SPECIALARGS) { /* a special bit set */ 3998 if (SPECIALARGS & (DECSNAN | DECNAN)) /* a NaN */ 3999 decNaNs(res, lhs, rhs, set, status); 4000 else { /* one or two infinities */ 4001 if (decNumberIsInfinite(lhs)) { /* LHS is infinity */ 4002 /* two infinities with different signs is invalid */ 4003 if (decNumberIsInfinite(rhs) && diffsign) { 4004 *status|=DEC_Invalid_operation; 4005 break; 4006 } 4007 bits=lhs->bits & DECNEG; /* get sign from LHS */ 4008 } 4009 else bits=(rhs->bits^negate) & DECNEG;/* RHS must be Infinity */ 4010 bits|=DECINF; 4011 decNumberZero(res); 4012 res->bits=bits; /* set +/- infinity */ 4013 } /* an infinity */ 4014 break; 4015 } 4016 4017 /* Quick exit for add 0s; return the non-0, modified as need be */ 4018 if (ISZERO(lhs)) { 4019 Int adjust; /* work */ 4020 Int lexp=lhs->exponent; /* save in case LHS==RES */ 4021 bits=lhs->bits; /* .. */ 4022 residue=0; /* clear accumulator */ 4023 decCopyFit(res, rhs, set, &residue, status); /* copy (as needed) */ 4024 res->bits^=negate; /* flip if rhs was negated */ 4025 #if DECSUBSET 4026 if (set->extended) { /* exponents on zeros count */ 4027 #endif 4028 /* exponent will be the lower of the two */ 4029 adjust=lexp-res->exponent; /* adjustment needed [if -ve] */ 4030 if (ISZERO(res)) { /* both 0: special IEEE 854 rules */ 4031 if (adjust<0) res->exponent=lexp; /* set exponent */ 4032 /* 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0 */ 4033 if (diffsign) { 4034 if (set->round!=DEC_ROUND_FLOOR) res->bits=0; 4035 else res->bits=DECNEG; /* preserve 0 sign */ 4036 } 4037 } 4038 else { /* non-0 res */ 4039 if (adjust<0) { /* 0-padding needed */ 4040 if ((res->digits-adjust)>set->digits) { 4041 adjust=res->digits-set->digits; /* to fit exactly */ 4042 *status|=DEC_Rounded; /* [but exact] */ 4043 } 4044 res->digits=decShiftToMost(res->lsu, res->digits, -adjust); 4045 res->exponent+=adjust; /* set the exponent. */ 4046 } 4047 } /* non-0 res */ 4048 #if DECSUBSET 4049 } /* extended */ 4050 #endif 4051 decFinish(res, set, &residue, status); /* clean and finalize */ 4052 break;} 4053 4054 if (ISZERO(rhs)) { /* [lhs is non-zero] */ 4055 Int adjust; /* work */ 4056 Int rexp=rhs->exponent; /* save in case RHS==RES */ 4057 bits=rhs->bits; /* be clean */ 4058 residue=0; /* clear accumulator */ 4059 decCopyFit(res, lhs, set, &residue, status); /* copy (as needed) */ 4060 #if DECSUBSET 4061 if (set->extended) { /* exponents on zeros count */ 4062 #endif 4063 /* exponent will be the lower of the two */ 4064 /* [0-0 case handled above] */ 4065 adjust=rexp-res->exponent; /* adjustment needed [if -ve] */ 4066 if (adjust<0) { /* 0-padding needed */ 4067 if ((res->digits-adjust)>set->digits) { 4068 adjust=res->digits-set->digits; /* to fit exactly */ 4069 *status|=DEC_Rounded; /* [but exact] */ 4070 } 4071 res->digits=decShiftToMost(res->lsu, res->digits, -adjust); 4072 res->exponent+=adjust; /* set the exponent. */ 4073 } 4074 #if DECSUBSET 4075 } /* extended */ 4076 #endif 4077 decFinish(res, set, &residue, status); /* clean and finalize */ 4078 break;} 4079 4080 /* [NB: both fastpath and mainpath code below assume these cases */ 4081 /* (notably 0-0) have already been handled] */ 4082 4083 /* calculate the padding needed to align the operands */ 4084 padding=rhs->exponent-lhs->exponent; 4085 4086 /* Fastpath cases where the numbers are aligned and normal, the RHS */ 4087 /* is all in one unit, no operand rounding is needed, and no carry, */ 4088 /* lengthening, or borrow is needed */ 4089 if (padding==0 4090 && rhs->digits<=DECDPUN 4091 && rhs->exponent>=set->emin /* [some normals drop through] */ 4092 && rhs->exponent<=set->emax-set->digits+1 /* [could clamp] */ 4093 && rhs->digits<=reqdigits 4094 && lhs->digits<=reqdigits) { 4095 Int partial=*lhs->lsu; 4096 if (!diffsign) { /* adding */ 4097 partial+=*rhs->lsu; 4098 if ((partial<=DECDPUNMAX) /* result fits in unit */ 4099 && (lhs->digits>=DECDPUN || /* .. and no digits-count change */ 4100 partial<(Int)powers[lhs->digits])) { /* .. */ 4101 if (res!=lhs) decNumberCopy(res, lhs); /* not in place */ 4102 *res->lsu=(Unit)partial; /* [copy could have overwritten RHS] */ 4103 break; 4104 } 4105 /* else drop out for careful add */ 4106 } 4107 else { /* signs differ */ 4108 partial-=*rhs->lsu; 4109 if (partial>0) { /* no borrow needed, and non-0 result */ 4110 if (res!=lhs) decNumberCopy(res, lhs); /* not in place */ 4111 *res->lsu=(Unit)partial; 4112 /* this could have reduced digits [but result>0] */ 4113 res->digits=decGetDigits(res->lsu, D2U(res->digits)); 4114 break; 4115 } 4116 /* else drop out for careful subtract */ 4117 } 4118 } 4119 4120 /* Now align (pad) the lhs or rhs so they can be added or */ 4121 /* subtracted, as necessary. If one number is much larger than */ 4122 /* the other (that is, if in plain form there is a least one */ 4123 /* digit between the lowest digit of one and the highest of the */ 4124 /* other) padding with up to DIGITS-1 trailing zeros may be */ 4125 /* needed; then apply rounding (as exotic rounding modes may be */ 4126 /* affected by the residue). */ 4127 rhsshift=0; /* rhs shift to left (padding) in Units */ 4128 bits=lhs->bits; /* assume sign is that of LHS */ 4129 mult=1; /* likely multiplier */ 4130 4131 /* [if padding==0 the operands are aligned; no padding is needed] */ 4132 if (padding!=0) { 4133 /* some padding needed; always pad the RHS, as any required */ 4134 /* padding can then be effected by a simple combination of */ 4135 /* shifts and a multiply */ 4136 Flag swapped=0; 4137 if (padding<0) { /* LHS needs the padding */ 4138 const decNumber *t; 4139 padding=-padding; /* will be +ve */ 4140 bits=(uByte)(rhs->bits^negate); /* assumed sign is now that of RHS */ 4141 t=lhs; lhs=rhs; rhs=t; 4142 swapped=1; 4143 } 4144 4145 /* If, after pad, rhs would be longer than lhs by digits+1 or */ 4146 /* more then lhs cannot affect the answer, except as a residue, */ 4147 /* so only need to pad up to a length of DIGITS+1. */ 4148 if (rhs->digits+padding > lhs->digits+reqdigits+1) { 4149 /* The RHS is sufficient */ 4150 /* for residue use the relative sign indication... */ 4151 Int shift=reqdigits-rhs->digits; /* left shift needed */ 4152 residue=1; /* residue for rounding */ 4153 if (diffsign) residue=-residue; /* signs differ */ 4154 /* copy, shortening if necessary */ 4155 decCopyFit(res, rhs, set, &residue, status); 4156 /* if it was already shorter, then need to pad with zeros */ 4157 if (shift>0) { 4158 res->digits=decShiftToMost(res->lsu, res->digits, shift); 4159 res->exponent-=shift; /* adjust the exponent. */ 4160 } 4161 /* flip the result sign if unswapped and rhs was negated */ 4162 if (!swapped) res->bits^=negate; 4163 decFinish(res, set, &residue, status); /* done */ 4164 break;} 4165 4166 /* LHS digits may affect result */ 4167 rhsshift=D2U(padding+1)-1; /* this much by Unit shift .. */ 4168 mult=powers[padding-(rhsshift*DECDPUN)]; /* .. this by multiplication */ 4169 } /* padding needed */ 4170 4171 if (diffsign) mult=-mult; /* signs differ */ 4172 4173 /* determine the longer operand */ 4174 maxdigits=rhs->digits+padding; /* virtual length of RHS */ 4175 if (lhs->digits>maxdigits) maxdigits=lhs->digits; 4176 4177 /* Decide on the result buffer to use; if possible place directly */ 4178 /* into result. */ 4179 acc=res->lsu; /* assume add direct to result */ 4180 /* If destructive overlap, or the number is too long, or a carry or */ 4181 /* borrow to DIGITS+1 might be possible, a buffer must be used. */ 4182 /* [Might be worth more sophisticated tests when maxdigits==reqdigits] */ 4183 if ((maxdigits>=reqdigits) /* is, or could be, too large */ 4184 || (res==rhs && rhsshift>0)) { /* destructive overlap */ 4185 /* buffer needed, choose it; units for maxdigits digits will be */ 4186 /* needed, +1 Unit for carry or borrow */ 4187 Int need=D2U(maxdigits)+1; 4188 acc=accbuff; /* assume use local buffer */ 4189 if (need*sizeof(Unit)>sizeof(accbuff)) { 4190 /* printf("malloc add %ld %ld\n", need, sizeof(accbuff)); */ 4191 allocacc=(Unit *)malloc(need*sizeof(Unit)); 4192 if (allocacc==NULL) { /* hopeless -- abandon */ 4193 *status|=DEC_Insufficient_storage; 4194 break;} 4195 acc=allocacc; 4196 } 4197 } 4198 4199 res->bits=(uByte)(bits&DECNEG); /* it's now safe to overwrite.. */ 4200 res->exponent=lhs->exponent; /* .. operands (even if aliased) */ 4201 4202 #if DECTRACE 4203 decDumpAr('A', lhs->lsu, D2U(lhs->digits)); 4204 decDumpAr('B', rhs->lsu, D2U(rhs->digits)); 4205 printf(" :h: %ld %ld\n", rhsshift, mult); 4206 #endif 4207 4208 /* add [A+B*m] or subtract [A+B*(-m)] */ 4209 res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits), 4210 rhs->lsu, D2U(rhs->digits), 4211 rhsshift, acc, mult) 4212 *DECDPUN; /* [units -> digits] */ 4213 if (res->digits<0) { /* borrowed... */ 4214 res->digits=-res->digits; 4215 res->bits^=DECNEG; /* flip the sign */ 4216 } 4217 #if DECTRACE 4218 decDumpAr('+', acc, D2U(res->digits)); 4219 #endif 4220 4221 /* If a buffer was used the result must be copied back, possibly */ 4222 /* shortening. (If no buffer was used then the result must have */ 4223 /* fit, so can't need rounding and residue must be 0.) */ 4224 residue=0; /* clear accumulator */ 4225 if (acc!=res->lsu) { 4226 #if DECSUBSET 4227 if (set->extended) { /* round from first significant digit */ 4228 #endif 4229 /* remove leading zeros that were added due to rounding up to */ 4230 /* integral Units -- before the test for rounding. */ 4231 if (res->digits>reqdigits) 4232 res->digits=decGetDigits(acc, D2U(res->digits)); 4233 decSetCoeff(res, set, acc, res->digits, &residue, status); 4234 #if DECSUBSET 4235 } 4236 else { /* subset arithmetic rounds from original significant digit */ 4237 /* May have an underestimate. This only occurs when both */ 4238 /* numbers fit in DECDPUN digits and are padding with a */ 4239 /* negative multiple (-10, -100...) and the top digit(s) become */ 4240 /* 0. (This only matters when using X3.274 rules where the */ 4241 /* leading zero could be included in the rounding.) */ 4242 if (res->digits<maxdigits) { 4243 *(acc+D2U(res->digits))=0; /* ensure leading 0 is there */ 4244 res->digits=maxdigits; 4245 } 4246 else { 4247 /* remove leading zeros that added due to rounding up to */ 4248 /* integral Units (but only those in excess of the original */ 4249 /* maxdigits length, unless extended) before test for rounding. */ 4250 if (res->digits>reqdigits) { 4251 res->digits=decGetDigits(acc, D2U(res->digits)); 4252 if (res->digits<maxdigits) res->digits=maxdigits; 4253 } 4254 } 4255 decSetCoeff(res, set, acc, res->digits, &residue, status); 4256 /* Now apply rounding if needed before removing leading zeros. */ 4257 /* This is safe because subnormals are not a possibility */ 4258 if (residue!=0) { 4259 decApplyRound(res, set, residue, status); 4260 residue=0; /* did what needed to be done */ 4261 } 4262 } /* subset */ 4263 #endif 4264 } /* used buffer */ 4265 4266 /* strip leading zeros [these were left on in case of subset subtract] */ 4267 res->digits=decGetDigits(res->lsu, D2U(res->digits)); 4268 4269 /* apply checks and rounding */ 4270 decFinish(res, set, &residue, status); 4271 4272 /* "When the sum of two operands with opposite signs is exactly */ 4273 /* zero, the sign of that sum shall be '+' in all rounding modes */ 4274 /* except round toward -Infinity, in which mode that sign shall be */ 4275 /* '-'." [Subset zeros also never have '-', set by decFinish.] */ 4276 if (ISZERO(res) && diffsign 4277 #if DECSUBSET 4278 && set->extended 4279 #endif 4280 && (*status&DEC_Inexact)==0) { 4281 if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG; /* sign - */ 4282 else res->bits&=~DECNEG; /* sign + */ 4283 } 4284 } while(0); /* end protected */ 4285 4286 if (allocacc!=NULL) free(allocacc); /* drop any storage used */ 4287 #if DECSUBSET 4288 if (allocrhs!=NULL) free(allocrhs); /* .. */ 4289 if (alloclhs!=NULL) free(alloclhs); /* .. */ 4290 #endif 4291 return res; 4292 } /* decAddOp */ 4293 4294 /* ------------------------------------------------------------------ */ 4295 /* decDivideOp -- division operation */ 4296 /* */ 4297 /* This routine performs the calculations for all four division */ 4298 /* operators (divide, divideInteger, remainder, remainderNear). */ 4299 /* */ 4300 /* C=A op B */ 4301 /* */ 4302 /* res is C, the result. C may be A and/or B (e.g., X=X/X) */ 4303 /* lhs is A */ 4304 /* rhs is B */ 4305 /* set is the context */ 4306 /* op is DIVIDE, DIVIDEINT, REMAINDER, or REMNEAR respectively. */ 4307 /* status is the usual accumulator */ 4308 /* */ 4309 /* C must have space for set->digits digits. */ 4310 /* */ 4311 /* ------------------------------------------------------------------ */ 4312 /* The underlying algorithm of this routine is the same as in the */ 4313 /* 1981 S/370 implementation, that is, non-restoring long division */ 4314 /* with bi-unit (rather than bi-digit) estimation for each unit */ 4315 /* multiplier. In this pseudocode overview, complications for the */ 4316 /* Remainder operators and division residues for exact rounding are */ 4317 /* omitted for clarity. */ 4318 /* */ 4319 /* Prepare operands and handle special values */ 4320 /* Test for x/0 and then 0/x */ 4321 /* Exp =Exp1 - Exp2 */ 4322 /* Exp =Exp +len(var1) -len(var2) */ 4323 /* Sign=Sign1 * Sign2 */ 4324 /* Pad accumulator (Var1) to double-length with 0's (pad1) */ 4325 /* Pad Var2 to same length as Var1 */ 4326 /* msu2pair/plus=1st 2 or 1 units of var2, +1 to allow for round */ 4327 /* have=0 */ 4328 /* Do until (have=digits+1 OR residue=0) */ 4329 /* if exp<0 then if integer divide/residue then leave */ 4330 /* this_unit=0 */ 4331 /* Do forever */ 4332 /* compare numbers */ 4333 /* if <0 then leave inner_loop */ 4334 /* if =0 then (* quick exit without subtract *) do */ 4335 /* this_unit=this_unit+1; output this_unit */ 4336 /* leave outer_loop; end */ 4337 /* Compare lengths of numbers (mantissae): */ 4338 /* If same then tops2=msu2pair -- {units 1&2 of var2} */ 4339 /* else tops2=msu2plus -- {0, unit 1 of var2} */ 4340 /* tops1=first_unit_of_Var1*10**DECDPUN +second_unit_of_var1 */ 4341 /* mult=tops1/tops2 -- Good and safe guess at divisor */ 4342 /* if mult=0 then mult=1 */ 4343 /* this_unit=this_unit+mult */ 4344 /* subtract */ 4345 /* end inner_loop */ 4346 /* if have\=0 | this_unit\=0 then do */ 4347 /* output this_unit */ 4348 /* have=have+1; end */ 4349 /* var2=var2/10 */ 4350 /* exp=exp-1 */ 4351 /* end outer_loop */ 4352 /* exp=exp+1 -- set the proper exponent */ 4353 /* if have=0 then generate answer=0 */ 4354 /* Return (Result is defined by Var1) */ 4355 /* */ 4356 /* ------------------------------------------------------------------ */ 4357 /* Two working buffers are needed during the division; one (digits+ */ 4358 /* 1) to accumulate the result, and the other (up to 2*digits+1) for */ 4359 /* long subtractions. These are acc and var1 respectively. */ 4360 /* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/ 4361 /* The static buffers may be larger than might be expected to allow */ 4362 /* for calls from higher-level functions (notably exp). */ 4363 /* ------------------------------------------------------------------ */ 4364 static decNumber * decDivideOp(decNumber *res, 4365 const decNumber *lhs, const decNumber *rhs, 4366 decContext *set, Flag op, uInt *status) { 4367 #if DECSUBSET 4368 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 4369 decNumber *allocrhs=NULL; /* .., rhs */ 4370 #endif 4371 Unit accbuff[SD2U(DECBUFFER+DECDPUN+10)]; /* local buffer */ 4372 Unit *acc=accbuff; /* -> accumulator array for result */ 4373 Unit *allocacc=NULL; /* -> allocated buffer, iff allocated */ 4374 Unit *accnext; /* -> where next digit will go */ 4375 Int acclength; /* length of acc needed [Units] */ 4376 Int accunits; /* count of units accumulated */ 4377 Int accdigits; /* count of digits accumulated */ 4378 4379 Unit varbuff[SD2U(DECBUFFER*2+DECDPUN)*sizeof(Unit)]; /* buffer for var1 */ 4380 Unit *var1=varbuff; /* -> var1 array for long subtraction */ 4381 Unit *varalloc=NULL; /* -> allocated buffer, iff used */ 4382 Unit *msu1; /* -> msu of var1 */ 4383 4384 const Unit *var2; /* -> var2 array */ 4385 const Unit *msu2; /* -> msu of var2 */ 4386 Int msu2plus; /* msu2 plus one [does not vary] */ 4387 eInt msu2pair; /* msu2 pair plus one [does not vary] */ 4388 4389 Int var1units, var2units; /* actual lengths */ 4390 Int var2ulen; /* logical length (units) */ 4391 Int var1initpad=0; /* var1 initial padding (digits) */ 4392 Int maxdigits; /* longest LHS or required acc length */ 4393 Int mult; /* multiplier for subtraction */ 4394 Unit thisunit; /* current unit being accumulated */ 4395 Int residue; /* for rounding */ 4396 Int reqdigits=set->digits; /* requested DIGITS */ 4397 Int exponent; /* working exponent */ 4398 Int maxexponent=0; /* DIVIDE maximum exponent if unrounded */ 4399 uByte bits; /* working sign */ 4400 Unit *target; /* work */ 4401 const Unit *source; /* .. */ 4402 uLong const *pow; /* .. */ 4403 Int shift, cut; /* .. */ 4404 #if DECSUBSET 4405 Int dropped; /* work */ 4406 #endif 4407 4408 #if DECCHECK 4409 if (decCheckOperands(res, lhs, rhs, set)) return res; 4410 #endif 4411 4412 do { /* protect allocated storage */ 4413 #if DECSUBSET 4414 if (!set->extended) { 4415 /* reduce operands and set lostDigits status, as needed */ 4416 if (lhs->digits>reqdigits) { 4417 alloclhs=decRoundOperand(lhs, set, status); 4418 if (alloclhs==NULL) break; 4419 lhs=alloclhs; 4420 } 4421 if (rhs->digits>reqdigits) { 4422 allocrhs=decRoundOperand(rhs, set, status); 4423 if (allocrhs==NULL) break; 4424 rhs=allocrhs; 4425 } 4426 } 4427 #endif 4428 /* [following code does not require input rounding] */ 4429 4430 bits=(lhs->bits^rhs->bits)&DECNEG; /* assumed sign for divisions */ 4431 4432 /* handle infinities and NaNs */ 4433 if (SPECIALARGS) { /* a special bit set */ 4434 if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */ 4435 decNaNs(res, lhs, rhs, set, status); 4436 break; 4437 } 4438 /* one or two infinities */ 4439 if (decNumberIsInfinite(lhs)) { /* LHS (dividend) is infinite */ 4440 if (decNumberIsInfinite(rhs) || /* two infinities are invalid .. */ 4441 op & (REMAINDER | REMNEAR)) { /* as is remainder of infinity */ 4442 *status|=DEC_Invalid_operation; 4443 break; 4444 } 4445 /* [Note that infinity/0 raises no exceptions] */ 4446 decNumberZero(res); 4447 res->bits=bits|DECINF; /* set +/- infinity */ 4448 break; 4449 } 4450 else { /* RHS (divisor) is infinite */ 4451 residue=0; 4452 if (op&(REMAINDER|REMNEAR)) { 4453 /* result is [finished clone of] lhs */ 4454 decCopyFit(res, lhs, set, &residue, status); 4455 } 4456 else { /* a division */ 4457 decNumberZero(res); 4458 res->bits=bits; /* set +/- zero */ 4459 /* for DIVIDEINT the exponent is always 0. For DIVIDE, result */ 4460 /* is a 0 with infinitely negative exponent, clamped to minimum */ 4461 if (op&DIVIDE) { 4462 res->exponent=set->emin-set->digits+1; 4463 *status|=DEC_Clamped; 4464 } 4465 } 4466 decFinish(res, set, &residue, status); 4467 break; 4468 } 4469 } 4470 4471 /* handle 0 rhs (x/0) */ 4472 if (ISZERO(rhs)) { /* x/0 is always exceptional */ 4473 if (ISZERO(lhs)) { 4474 decNumberZero(res); /* [after lhs test] */ 4475 *status|=DEC_Division_undefined;/* 0/0 will become NaN */ 4476 } 4477 else { 4478 decNumberZero(res); 4479 if (op&(REMAINDER|REMNEAR)) *status|=DEC_Invalid_operation; 4480 else { 4481 *status|=DEC_Division_by_zero; /* x/0 */ 4482 res->bits=bits|DECINF; /* .. is +/- Infinity */ 4483 } 4484 } 4485 break;} 4486 4487 /* handle 0 lhs (0/x) */ 4488 if (ISZERO(lhs)) { /* 0/x [x!=0] */ 4489 #if DECSUBSET 4490 if (!set->extended) decNumberZero(res); 4491 else { 4492 #endif 4493 if (op&DIVIDE) { 4494 residue=0; 4495 exponent=lhs->exponent-rhs->exponent; /* ideal exponent */ 4496 decNumberCopy(res, lhs); /* [zeros always fit] */ 4497 res->bits=bits; /* sign as computed */ 4498 res->exponent=exponent; /* exponent, too */ 4499 decFinalize(res, set, &residue, status); /* check exponent */ 4500 } 4501 else if (op&DIVIDEINT) { 4502 decNumberZero(res); /* integer 0 */ 4503 res->bits=bits; /* sign as computed */ 4504 } 4505 else { /* a remainder */ 4506 exponent=rhs->exponent; /* [save in case overwrite] */ 4507 decNumberCopy(res, lhs); /* [zeros always fit] */ 4508 if (exponent<res->exponent) res->exponent=exponent; /* use lower */ 4509 } 4510 #if DECSUBSET 4511 } 4512 #endif 4513 break;} 4514 4515 /* Precalculate exponent. This starts off adjusted (and hence fits */ 4516 /* in 31 bits) and becomes the usual unadjusted exponent as the */ 4517 /* division proceeds. The order of evaluation is important, here, */ 4518 /* to avoid wrap. */ 4519 exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits); 4520 4521 /* If the working exponent is -ve, then some quick exits are */ 4522 /* possible because the quotient is known to be <1 */ 4523 /* [for REMNEAR, it needs to be < -1, as -0.5 could need work] */ 4524 if (exponent<0 && !(op==DIVIDE)) { 4525 if (op&DIVIDEINT) { 4526 decNumberZero(res); /* integer part is 0 */ 4527 #if DECSUBSET 4528 if (set->extended) 4529 #endif 4530 res->bits=bits; /* set +/- zero */ 4531 break;} 4532 /* fastpath remainders so long as the lhs has the smaller */ 4533 /* (or equal) exponent */ 4534 if (lhs->exponent<=rhs->exponent) { 4535 if (op&REMAINDER || exponent<-1) { 4536 /* It is REMAINDER or safe REMNEAR; result is [finished */ 4537 /* clone of] lhs (r = x - 0*y) */ 4538 residue=0; 4539 decCopyFit(res, lhs, set, &residue, status); 4540 decFinish(res, set, &residue, status); 4541 break; 4542 } 4543 /* [unsafe REMNEAR drops through] */ 4544 } 4545 } /* fastpaths */ 4546 4547 /* Long (slow) division is needed; roll up the sleeves... */ 4548 4549 /* The accumulator will hold the quotient of the division. */ 4550 /* If it needs to be too long for stack storage, then allocate. */ 4551 acclength=D2U(reqdigits+DECDPUN); /* in Units */ 4552 if (acclength*sizeof(Unit)>sizeof(accbuff)) { 4553 /* printf("malloc dvacc %ld units\n", acclength); */ 4554 allocacc=(Unit *)malloc(acclength*sizeof(Unit)); 4555 if (allocacc==NULL) { /* hopeless -- abandon */ 4556 *status|=DEC_Insufficient_storage; 4557 break;} 4558 acc=allocacc; /* use the allocated space */ 4559 } 4560 4561 /* var1 is the padded LHS ready for subtractions. */ 4562 /* If it needs to be too long for stack storage, then allocate. */ 4563 /* The maximum units needed for var1 (long subtraction) is: */ 4564 /* Enough for */ 4565 /* (rhs->digits+reqdigits-1) -- to allow full slide to right */ 4566 /* or (lhs->digits) -- to allow for long lhs */ 4567 /* whichever is larger */ 4568 /* +1 -- for rounding of slide to right */ 4569 /* +1 -- for leading 0s */ 4570 /* +1 -- for pre-adjust if a remainder or DIVIDEINT */ 4571 /* [Note: unused units do not participate in decUnitAddSub data] */ 4572 maxdigits=rhs->digits+reqdigits-1; 4573 if (lhs->digits>maxdigits) maxdigits=lhs->digits; 4574 var1units=D2U(maxdigits)+2; 4575 /* allocate a guard unit above msu1 for REMAINDERNEAR */ 4576 if (!(op&DIVIDE)) var1units++; 4577 if ((var1units+1)*sizeof(Unit)>sizeof(varbuff)) { 4578 /* printf("malloc dvvar %ld units\n", var1units+1); */ 4579 varalloc=(Unit *)malloc((var1units+1)*sizeof(Unit)); 4580 if (varalloc==NULL) { /* hopeless -- abandon */ 4581 *status|=DEC_Insufficient_storage; 4582 break;} 4583 var1=varalloc; /* use the allocated space */ 4584 } 4585 4586 /* Extend the lhs and rhs to full long subtraction length. The lhs */ 4587 /* is truly extended into the var1 buffer, with 0 padding, so a */ 4588 /* subtract in place is always possible. The rhs (var2) has */ 4589 /* virtual padding (implemented by decUnitAddSub). */ 4590 /* One guard unit was allocated above msu1 for rem=rem+rem in */ 4591 /* REMAINDERNEAR. */ 4592 msu1=var1+var1units-1; /* msu of var1 */ 4593 source=lhs->lsu+D2U(lhs->digits)-1; /* msu of input array */ 4594 for (target=msu1; source>=lhs->lsu; source--, target--) *target=*source; 4595 for (; target>=var1; target--) *target=0; 4596 4597 /* rhs (var2) is left-aligned with var1 at the start */ 4598 var2ulen=var1units; /* rhs logical length (units) */ 4599 var2units=D2U(rhs->digits); /* rhs actual length (units) */ 4600 var2=rhs->lsu; /* -> rhs array */ 4601 msu2=var2+var2units-1; /* -> msu of var2 [never changes] */ 4602 /* now set up the variables which will be used for estimating the */ 4603 /* multiplication factor. If these variables are not exact, add */ 4604 /* 1 to make sure that the multiplier is never overestimated. */ 4605 msu2plus=*msu2; /* it's value .. */ 4606 if (var2units>1) msu2plus++; /* .. +1 if any more */ 4607 msu2pair=(eInt)*msu2*(DECDPUNMAX+1);/* top two pair .. */ 4608 if (var2units>1) { /* .. [else treat 2nd as 0] */ 4609 msu2pair+=*(msu2-1); /* .. */ 4610 if (var2units>2) msu2pair++; /* .. +1 if any more */ 4611 } 4612 4613 /* The calculation is working in units, which may have leading zeros, */ 4614 /* but the exponent was calculated on the assumption that they are */ 4615 /* both left-aligned. Adjust the exponent to compensate: add the */ 4616 /* number of leading zeros in var1 msu and subtract those in var2 msu. */ 4617 /* [This is actually done by counting the digits and negating, as */ 4618 /* lead1=DECDPUN-digits1, and similarly for lead2.] */ 4619 for (pow=&powers[1]; *msu1>=*pow; pow++) exponent--; 4620 for (pow=&powers[1]; *msu2>=*pow; pow++) exponent++; 4621 4622 /* Now, if doing an integer divide or remainder, ensure that */ 4623 /* the result will be Unit-aligned. To do this, shift the var1 */ 4624 /* accumulator towards least if need be. (It's much easier to */ 4625 /* do this now than to reassemble the residue afterwards, if */ 4626 /* doing a remainder.) Also ensure the exponent is not negative. */ 4627 if (!(op&DIVIDE)) { 4628 Unit *u; /* work */ 4629 /* save the initial 'false' padding of var1, in digits */ 4630 var1initpad=(var1units-D2U(lhs->digits))*DECDPUN; 4631 /* Determine the shift to do. */ 4632 if (exponent<0) cut=-exponent; 4633 else cut=DECDPUN-exponent%DECDPUN; 4634 decShiftToLeast(var1, var1units, cut); 4635 exponent+=cut; /* maintain numerical value */ 4636 var1initpad-=cut; /* .. and reduce padding */ 4637 /* clean any most-significant units which were just emptied */ 4638 for (u=msu1; cut>=DECDPUN; cut-=DECDPUN, u--) *u=0; 4639 } /* align */ 4640 else { /* is DIVIDE */ 4641 maxexponent=lhs->exponent-rhs->exponent; /* save */ 4642 /* optimization: if the first iteration will just produce 0, */ 4643 /* preadjust to skip it [valid for DIVIDE only] */ 4644 if (*msu1<*msu2) { 4645 var2ulen--; /* shift down */ 4646 exponent-=DECDPUN; /* update the exponent */ 4647 } 4648 } 4649 4650 /* ---- start the long-division loops ------------------------------ */ 4651 accunits=0; /* no units accumulated yet */ 4652 accdigits=0; /* .. or digits */ 4653 accnext=acc+acclength-1; /* -> msu of acc [NB: allows digits+1] */ 4654 for (;;) { /* outer forever loop */ 4655 thisunit=0; /* current unit assumed 0 */ 4656 /* find the next unit */ 4657 for (;;) { /* inner forever loop */ 4658 /* strip leading zero units [from either pre-adjust or from */ 4659 /* subtract last time around]. Leave at least one unit. */ 4660 for (; *msu1==0 && msu1>var1; msu1--) var1units--; 4661 4662 if (var1units<var2ulen) break; /* var1 too low for subtract */ 4663 if (var1units==var2ulen) { /* unit-by-unit compare needed */ 4664 /* compare the two numbers, from msu */ 4665 const Unit *pv1, *pv2; 4666 Unit v2; /* units to compare */ 4667 pv2=msu2; /* -> msu */ 4668 for (pv1=msu1; ; pv1--, pv2--) { 4669 /* v1=*pv1 -- always OK */ 4670 v2=0; /* assume in padding */ 4671 if (pv2>=var2) v2=*pv2; /* in range */ 4672 if (*pv1!=v2) break; /* no longer the same */ 4673 if (pv1==var1) break; /* done; leave pv1 as is */ 4674 } 4675 /* here when all inspected or a difference seen */ 4676 if (*pv1<v2) break; /* var1 too low to subtract */ 4677 if (*pv1==v2) { /* var1 == var2 */ 4678 /* reach here if var1 and var2 are identical; subtraction */ 4679 /* would increase digit by one, and the residue will be 0 so */ 4680 /* the calculation is done; leave the loop with residue=0. */ 4681 thisunit++; /* as though subtracted */ 4682 *var1=0; /* set var1 to 0 */ 4683 var1units=1; /* .. */ 4684 break; /* from inner */ 4685 } /* var1 == var2 */ 4686 /* *pv1>v2. Prepare for real subtraction; the lengths are equal */ 4687 /* Estimate the multiplier (there's always a msu1-1)... */ 4688 /* Bring in two units of var2 to provide a good estimate. */ 4689 mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2pair); 4690 } /* lengths the same */ 4691 else { /* var1units > var2ulen, so subtraction is safe */ 4692 /* The var2 msu is one unit towards the lsu of the var1 msu, */ 4693 /* so only one unit for var2 can be used. */ 4694 mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2plus); 4695 } 4696 if (mult==0) mult=1; /* must always be at least 1 */ 4697 /* subtraction needed; var1 is > var2 */ 4698 thisunit=(Unit)(thisunit+mult); /* accumulate */ 4699 /* subtract var1-var2, into var1; only the overlap needs */ 4700 /* processing, as this is an in-place calculation */ 4701 shift=var2ulen-var2units; 4702 #if DECTRACE 4703 decDumpAr('1', &var1[shift], var1units-shift); 4704 decDumpAr('2', var2, var2units); 4705 printf("m=%ld\n", -mult); 4706 #endif 4707 decUnitAddSub(&var1[shift], var1units-shift, 4708 var2, var2units, 0, 4709 &var1[shift], -mult); 4710 #if DECTRACE 4711 decDumpAr('#', &var1[shift], var1units-shift); 4712 #endif 4713 /* var1 now probably has leading zeros; these are removed at the */ 4714 /* top of the inner loop. */ 4715 } /* inner loop */ 4716 4717 /* The next unit has been calculated in full; unless it's a */ 4718 /* leading zero, add to acc */ 4719 if (accunits!=0 || thisunit!=0) { /* is first or non-zero */ 4720 *accnext=thisunit; /* store in accumulator */ 4721 /* account exactly for the new digits */ 4722 if (accunits==0) { 4723 accdigits++; /* at least one */ 4724 for (pow=&powers[1]; thisunit>=*pow; pow++) accdigits++; 4725 } 4726 else accdigits+=DECDPUN; 4727 accunits++; /* update count */ 4728 accnext--; /* ready for next */ 4729 if (accdigits>reqdigits) break; /* have enough digits */ 4730 } 4731 4732 /* if the residue is zero, the operation is done (unless divide */ 4733 /* or divideInteger and still not enough digits yet) */ 4734 if (*var1==0 && var1units==1) { /* residue is 0 */ 4735 if (op&(REMAINDER|REMNEAR)) break; 4736 if ((op&DIVIDE) && (exponent<=maxexponent)) break; 4737 /* [drop through if divideInteger] */ 4738 } 4739 /* also done enough if calculating remainder or integer */ 4740 /* divide and just did the last ('units') unit */ 4741 if (exponent==0 && !(op&DIVIDE)) break; 4742 4743 /* to get here, var1 is less than var2, so divide var2 by the per- */ 4744 /* Unit power of ten and go for the next digit */ 4745 var2ulen--; /* shift down */ 4746 exponent-=DECDPUN; /* update the exponent */ 4747 } /* outer loop */ 4748 4749 /* ---- division is complete --------------------------------------- */ 4750 /* here: acc has at least reqdigits+1 of good results (or fewer */ 4751 /* if early stop), starting at accnext+1 (its lsu) */ 4752 /* var1 has any residue at the stopping point */ 4753 /* accunits is the number of digits collected in acc */ 4754 if (accunits==0) { /* acc is 0 */ 4755 accunits=1; /* show have a unit .. */ 4756 accdigits=1; /* .. */ 4757 *accnext=0; /* .. whose value is 0 */ 4758 } 4759 else accnext++; /* back to last placed */ 4760 /* accnext now -> lowest unit of result */ 4761 4762 residue=0; /* assume no residue */ 4763 if (op&DIVIDE) { 4764 /* record the presence of any residue, for rounding */ 4765 if (*var1!=0 || var1units>1) residue=1; 4766 else { /* no residue */ 4767 /* Had an exact division; clean up spurious trailing 0s. */ 4768 /* There will be at most DECDPUN-1, from the final multiply, */ 4769 /* and then only if the result is non-0 (and even) and the */ 4770 /* exponent is 'loose'. */ 4771 #if DECDPUN>1 4772 Unit lsu=*accnext; 4773 if (!(lsu&0x01) && (lsu!=0)) { 4774 /* count the trailing zeros */ 4775 Int drop=0; 4776 for (;; drop++) { /* [will terminate because lsu!=0] */ 4777 if (exponent>=maxexponent) break; /* don't chop real 0s */ 4778 #if DECDPUN<=4 4779 if ((lsu-QUOT10(lsu, drop+1) 4780 *powers[drop+1])!=0) break; /* found non-0 digit */ 4781 #else 4782 if (lsu%powers[drop+1]!=0) break; /* found non-0 digit */ 4783 #endif 4784 exponent++; 4785 } 4786 if (drop>0) { 4787 accunits=decShiftToLeast(accnext, accunits, drop); 4788 accdigits=decGetDigits(accnext, accunits); 4789 accunits=D2U(accdigits); 4790 /* [exponent was adjusted in the loop] */ 4791 } 4792 } /* neither odd nor 0 */ 4793 #endif 4794 } /* exact divide */ 4795 } /* divide */ 4796 else /* op!=DIVIDE */ { 4797 /* check for coefficient overflow */ 4798 if (accdigits+exponent>reqdigits) { 4799 *status|=DEC_Division_impossible; 4800 break; 4801 } 4802 if (op & (REMAINDER|REMNEAR)) { 4803 /* [Here, the exponent will be 0, because var1 was adjusted */ 4804 /* appropriately.] */ 4805 Int postshift; /* work */ 4806 Flag wasodd=0; /* integer was odd */ 4807 Unit *quotlsu; /* for save */ 4808 Int quotdigits; /* .. */ 4809 4810 bits=lhs->bits; /* remainder sign is always as lhs */ 4811 4812 /* Fastpath when residue is truly 0 is worthwhile [and */ 4813 /* simplifies the code below] */ 4814 if (*var1==0 && var1units==1) { /* residue is 0 */ 4815 Int exp=lhs->exponent; /* save min(exponents) */ 4816 if (rhs->exponent<exp) exp=rhs->exponent; 4817 decNumberZero(res); /* 0 coefficient */ 4818 #if DECSUBSET 4819 if (set->extended) 4820 #endif 4821 res->exponent=exp; /* .. with proper exponent */ 4822 res->bits=(uByte)(bits&DECNEG); /* [cleaned] */ 4823 decFinish(res, set, &residue, status); /* might clamp */ 4824 break; 4825 } 4826 /* note if the quotient was odd */ 4827 if (*accnext & 0x01) wasodd=1; /* acc is odd */ 4828 quotlsu=accnext; /* save in case need to reinspect */ 4829 quotdigits=accdigits; /* .. */ 4830 4831 /* treat the residue, in var1, as the value to return, via acc */ 4832 /* calculate the unused zero digits. This is the smaller of: */ 4833 /* var1 initial padding (saved above) */ 4834 /* var2 residual padding, which happens to be given by: */ 4835 postshift=var1initpad+exponent-lhs->exponent+rhs->exponent; 4836 /* [the 'exponent' term accounts for the shifts during divide] */ 4837 if (var1initpad<postshift) postshift=var1initpad; 4838 4839 /* shift var1 the requested amount, and adjust its digits */ 4840 var1units=decShiftToLeast(var1, var1units, postshift); 4841 accnext=var1; 4842 accdigits=decGetDigits(var1, var1units); 4843 accunits=D2U(accdigits); 4844 4845 exponent=lhs->exponent; /* exponent is smaller of lhs & rhs */ 4846 if (rhs->exponent<exponent) exponent=rhs->exponent; 4847 4848 /* Now correct the result if doing remainderNear; if it */ 4849 /* (looking just at coefficients) is > rhs/2, or == rhs/2 and */ 4850 /* the integer was odd then the result should be rem-rhs. */ 4851 if (op&REMNEAR) { 4852 Int compare, tarunits; /* work */ 4853 Unit *up; /* .. */ 4854 /* calculate remainder*2 into the var1 buffer (which has */ 4855 /* 'headroom' of an extra unit and hence enough space) */ 4856 /* [a dedicated 'double' loop would be faster, here] */ 4857 tarunits=decUnitAddSub(accnext, accunits, accnext, accunits, 4858 0, accnext, 1); 4859 /* decDumpAr('r', accnext, tarunits); */ 4860 4861 /* Here, accnext (var1) holds tarunits Units with twice the */ 4862 /* remainder's coefficient, which must now be compared to the */ 4863 /* RHS. The remainder's exponent may be smaller than the RHS's. */ 4864 compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits), 4865 rhs->exponent-exponent); 4866 if (compare==BADINT) { /* deep trouble */ 4867 *status|=DEC_Insufficient_storage; 4868 break;} 4869 4870 /* now restore the remainder by dividing by two; the lsu */ 4871 /* is known to be even. */ 4872 for (up=accnext; up<accnext+tarunits; up++) { 4873 Int half; /* half to add to lower unit */ 4874 half=*up & 0x01; 4875 *up/=2; /* [shift] */ 4876 if (!half) continue; 4877 *(up-1)+=DIV_ROUND_UP(DECDPUNMAX, 2); 4878 } 4879 /* [accunits still describes the original remainder length] */ 4880 4881 if (compare>0 || (compare==0 && wasodd)) { /* adjustment needed */ 4882 Int exp, expunits, exprem; /* work */ 4883 /* This is effectively causing round-up of the quotient, */ 4884 /* so if it was the rare case where it was full and all */ 4885 /* nines, it would overflow and hence division-impossible */ 4886 /* should be raised */ 4887 Flag allnines=0; /* 1 if quotient all nines */ 4888 if (quotdigits==reqdigits) { /* could be borderline */ 4889 for (up=quotlsu; ; up++) { 4890 if (quotdigits>DECDPUN) { 4891 if (*up!=DECDPUNMAX) break;/* non-nines */ 4892 } 4893 else { /* this is the last Unit */ 4894 if (*up==powers[quotdigits]-1) allnines=1; 4895 break; 4896 } 4897 quotdigits-=DECDPUN; /* checked those digits */ 4898 } /* up */ 4899 } /* borderline check */ 4900 if (allnines) { 4901 *status|=DEC_Division_impossible; 4902 break;} 4903 4904 /* rem-rhs is needed; the sign will invert. Again, var1 */ 4905 /* can safely be used for the working Units array. */ 4906 exp=rhs->exponent-exponent; /* RHS padding needed */ 4907 /* Calculate units and remainder from exponent. */ 4908 expunits=exp/DECDPUN; 4909 exprem=exp%DECDPUN; 4910 /* subtract [A+B*(-m)]; the result will always be negative */ 4911 accunits=-decUnitAddSub(accnext, accunits, 4912 rhs->lsu, D2U(rhs->digits), 4913 expunits, accnext, -(Int)powers[exprem]); 4914 accdigits=decGetDigits(accnext, accunits); /* count digits exactly */ 4915 accunits=D2U(accdigits); /* and recalculate the units for copy */ 4916 /* [exponent is as for original remainder] */ 4917 bits^=DECNEG; /* flip the sign */ 4918 } 4919 } /* REMNEAR */ 4920 } /* REMAINDER or REMNEAR */ 4921 } /* not DIVIDE */ 4922 4923 /* Set exponent and bits */ 4924 res->exponent=exponent; 4925 res->bits=(uByte)(bits&DECNEG); /* [cleaned] */ 4926 4927 /* Now the coefficient. */ 4928 decSetCoeff(res, set, accnext, accdigits, &residue, status); 4929 4930 decFinish(res, set, &residue, status); /* final cleanup */ 4931 4932 #if DECSUBSET 4933 /* If a divide then strip trailing zeros if subset [after round] */ 4934 if (!set->extended && (op==DIVIDE)) decTrim(res, set, 0, &dropped); 4935 #endif 4936 } while(0); /* end protected */ 4937 4938 if (varalloc!=NULL) free(varalloc); /* drop any storage used */ 4939 if (allocacc!=NULL) free(allocacc); /* .. */ 4940 #if DECSUBSET 4941 if (allocrhs!=NULL) free(allocrhs); /* .. */ 4942 if (alloclhs!=NULL) free(alloclhs); /* .. */ 4943 #endif 4944 return res; 4945 } /* decDivideOp */ 4946 4947 /* ------------------------------------------------------------------ */ 4948 /* decMultiplyOp -- multiplication operation */ 4949 /* */ 4950 /* This routine performs the multiplication C=A x B. */ 4951 /* */ 4952 /* res is C, the result. C may be A and/or B (e.g., X=X*X) */ 4953 /* lhs is A */ 4954 /* rhs is B */ 4955 /* set is the context */ 4956 /* status is the usual accumulator */ 4957 /* */ 4958 /* C must have space for set->digits digits. */ 4959 /* */ 4960 /* ------------------------------------------------------------------ */ 4961 /* 'Classic' multiplication is used rather than Karatsuba, as the */ 4962 /* latter would give only a minor improvement for the short numbers */ 4963 /* expected to be handled most (and uses much more memory). */ 4964 /* */ 4965 /* There are two major paths here: the general-purpose ('old code') */ 4966 /* path which handles all DECDPUN values, and a fastpath version */ 4967 /* which is used if 64-bit ints are available, DECDPUN<=4, and more */ 4968 /* than two calls to decUnitAddSub would be made. */ 4969 /* */ 4970 /* The fastpath version lumps units together into 8-digit or 9-digit */ 4971 /* chunks, and also uses a lazy carry strategy to minimise expensive */ 4972 /* 64-bit divisions. The chunks are then broken apart again into */ 4973 /* units for continuing processing. Despite this overhead, the */ 4974 /* fastpath can speed up some 16-digit operations by 10x (and much */ 4975 /* more for higher-precision calculations). */ 4976 /* */ 4977 /* A buffer always has to be used for the accumulator; in the */ 4978 /* fastpath, buffers are also always needed for the chunked copies of */ 4979 /* of the operand coefficients. */ 4980 /* Static buffers are larger than needed just for multiply, to allow */ 4981 /* for calls from other operations (notably exp). */ 4982 /* ------------------------------------------------------------------ */ 4983 #define FASTMUL (DECUSE64 && DECDPUN<5) 4984 static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs, 4985 const decNumber *rhs, decContext *set, 4986 uInt *status) { 4987 Int accunits; /* Units of accumulator in use */ 4988 Int exponent; /* work */ 4989 Int residue=0; /* rounding residue */ 4990 uByte bits; /* result sign */ 4991 Unit *acc; /* -> accumulator Unit array */ 4992 Int needbytes; /* size calculator */ 4993 void *allocacc=NULL; /* -> allocated accumulator, iff allocated */ 4994 Unit accbuff[SD2U(DECBUFFER*4+1)]; /* buffer (+1 for DECBUFFER==0, */ 4995 /* *4 for calls from other operations) */ 4996 const Unit *mer, *mermsup; /* work */ 4997 Int madlength; /* Units in multiplicand */ 4998 Int shift; /* Units to shift multiplicand by */ 4999 5000 #if FASTMUL 5001 /* if DECDPUN is 1 or 3 work in base 10**9, otherwise */ 5002 /* (DECDPUN is 2 or 4) then work in base 10**8 */ 5003 #if DECDPUN & 1 /* odd */ 5004 #define FASTBASE 1000000000 /* base */ 5005 #define FASTDIGS 9 /* digits in base */ 5006 #define FASTLAZY 18 /* carry resolution point [1->18] */ 5007 #else 5008 #define FASTBASE 100000000 5009 #define FASTDIGS 8 5010 #define FASTLAZY 1844 /* carry resolution point [1->1844] */ 5011 #endif 5012 /* three buffers are used, two for chunked copies of the operands */ 5013 /* (base 10**8 or base 10**9) and one base 2**64 accumulator with */ 5014 /* lazy carry evaluation */ 5015 uInt zlhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */ 5016 uInt *zlhi=zlhibuff; /* -> lhs array */ 5017 uInt *alloclhi=NULL; /* -> allocated buffer, iff allocated */ 5018 uInt zrhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */ 5019 uInt *zrhi=zrhibuff; /* -> rhs array */ 5020 uInt *allocrhi=NULL; /* -> allocated buffer, iff allocated */ 5021 uLong zaccbuff[(DECBUFFER*2+1)/4+2]; /* buffer (+1 for DECBUFFER==0) */ 5022 /* [allocacc is shared for both paths, as only one will run] */ 5023 uLong *zacc=zaccbuff; /* -> accumulator array for exact result */ 5024 #if DECDPUN==1 5025 Int zoff; /* accumulator offset */ 5026 #endif 5027 uInt *lip, *rip; /* item pointers */ 5028 uInt *lmsi, *rmsi; /* most significant items */ 5029 Int ilhs, irhs, iacc; /* item counts in the arrays */ 5030 Int lazy; /* lazy carry counter */ 5031 uLong lcarry; /* uLong carry */ 5032 uInt carry; /* carry (NB not uLong) */ 5033 Int count; /* work */ 5034 const Unit *cup; /* .. */ 5035 Unit *up; /* .. */ 5036 uLong *lp; /* .. */ 5037 Int p; /* .. */ 5038 #endif 5039 5040 #if DECSUBSET 5041 decNumber *alloclhs=NULL; /* -> allocated buffer, iff allocated */ 5042 decNumber *allocrhs=NULL; /* -> allocated buffer, iff allocated */ 5043 #endif 5044 5045 #if DECCHECK 5046 if (decCheckOperands(res, lhs, rhs, set)) return res; 5047 #endif 5048 5049 /* precalculate result sign */ 5050 bits=(uByte)((lhs->bits^rhs->bits)&DECNEG); 5051 5052 /* handle infinities and NaNs */ 5053 if (SPECIALARGS) { /* a special bit set */ 5054 if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */ 5055 decNaNs(res, lhs, rhs, set, status); 5056 return res;} 5057 /* one or two infinities; Infinity * 0 is invalid */ 5058 if (((lhs->bits & DECINF)==0 && ISZERO(lhs)) 5059 ||((rhs->bits & DECINF)==0 && ISZERO(rhs))) { 5060 *status|=DEC_Invalid_operation; 5061 return res;} 5062 decNumberZero(res); 5063 res->bits=bits|DECINF; /* infinity */ 5064 return res;} 5065 5066 /* For best speed, as in DMSRCN [the original Rexx numerics */ 5067 /* module], use the shorter number as the multiplier (rhs) and */ 5068 /* the longer as the multiplicand (lhs) to minimise the number of */ 5069 /* adds (partial products) */ 5070 if (lhs->digits<rhs->digits) { /* swap... */ 5071 const decNumber *hold=lhs; 5072 lhs=rhs; 5073 rhs=hold; 5074 } 5075 5076 do { /* protect allocated storage */ 5077 #if DECSUBSET 5078 if (!set->extended) { 5079 /* reduce operands and set lostDigits status, as needed */ 5080 if (lhs->digits>set->digits) { 5081 alloclhs=decRoundOperand(lhs, set, status); 5082 if (alloclhs==NULL) break; 5083 lhs=alloclhs; 5084 } 5085 if (rhs->digits>set->digits) { 5086 allocrhs=decRoundOperand(rhs, set, status); 5087 if (allocrhs==NULL) break; 5088 rhs=allocrhs; 5089 } 5090 } 5091 #endif 5092 /* [following code does not require input rounding] */ 5093 5094 #if FASTMUL /* fastpath can be used */ 5095 /* use the fast path if there are enough digits in the shorter */ 5096 /* operand to make the setup and takedown worthwhile */ 5097 #define NEEDTWO (DECDPUN*2) /* within two decUnitAddSub calls */ 5098 if (rhs->digits>NEEDTWO) { /* use fastpath... */ 5099 /* calculate the number of elements in each array */ 5100 ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; /* [ceiling] */ 5101 irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; /* .. */ 5102 iacc=ilhs+irhs; 5103 5104 /* allocate buffers if required, as usual */ 5105 needbytes=ilhs*sizeof(uInt); 5106 if (needbytes>(Int)sizeof(zlhibuff)) { 5107 alloclhi=(uInt *)malloc(needbytes); 5108 zlhi=alloclhi;} 5109 needbytes=irhs*sizeof(uInt); 5110 if (needbytes>(Int)sizeof(zrhibuff)) { 5111 allocrhi=(uInt *)malloc(needbytes); 5112 zrhi=allocrhi;} 5113 5114 /* Allocating the accumulator space needs a special case when */ 5115 /* DECDPUN=1 because when converting the accumulator to Units */ 5116 /* after the multiplication each 8-byte item becomes 9 1-byte */ 5117 /* units. Therefore iacc extra bytes are needed at the front */ 5118 /* (rounded up to a multiple of 8 bytes), and the uLong */ 5119 /* accumulator starts offset the appropriate number of units */ 5120 /* to the right to avoid overwrite during the unchunking. */ 5121 needbytes=iacc*sizeof(uLong); 5122 #if DECDPUN==1 5123 zoff=(iacc+7)/8; /* items to offset by */ 5124 needbytes+=zoff*8; 5125 #endif 5126 if (needbytes>(Int)sizeof(zaccbuff)) { 5127 allocacc=(uLong *)malloc(needbytes); 5128 zacc=(uLong *)allocacc;} 5129 if (zlhi==NULL||zrhi==NULL||zacc==NULL) { 5130 *status|=DEC_Insufficient_storage; 5131 break;} 5132 5133 acc=(Unit *)zacc; /* -> target Unit array */ 5134 #if DECDPUN==1 5135 zacc+=zoff; /* start uLong accumulator to right */ 5136 #endif 5137 5138 /* assemble the chunked copies of the left and right sides */ 5139 for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++) 5140 for (p=0, *lip=0; p<FASTDIGS && count>0; 5141 p+=DECDPUN, cup++, count-=DECDPUN) 5142 *lip+=*cup*powers[p]; 5143 lmsi=lip-1; /* save -> msi */ 5144 for (count=rhs->digits, cup=rhs->lsu, rip=zrhi; count>0; rip++) 5145 for (p=0, *rip=0; p<FASTDIGS && count>0; 5146 p+=DECDPUN, cup++, count-=DECDPUN) 5147 *rip+=*cup*powers[p]; 5148 rmsi=rip-1; /* save -> msi */ 5149 5150 /* zero the accumulator */ 5151 for (lp=zacc; lp<zacc+iacc; lp++) *lp=0; 5152 5153 /* Start the multiplication */ 5154 /* Resolving carries can dominate the cost of accumulating the */ 5155 /* partial products, so this is only done when necessary. */ 5156 /* Each uLong item in the accumulator can hold values up to */ 5157 /* 2**64-1, and each partial product can be as large as */ 5158 /* (10**FASTDIGS-1)**2. When FASTDIGS=9, this can be added to */ 5159 /* itself 18.4 times in a uLong without overflowing, so during */ 5160 /* the main calculation resolution is carried out every 18th */ 5161 /* add -- every 162 digits. Similarly, when FASTDIGS=8, the */ 5162 /* partial products can be added to themselves 1844.6 times in */ 5163 /* a uLong without overflowing, so intermediate carry */ 5164 /* resolution occurs only every 14752 digits. Hence for common */ 5165 /* short numbers usually only the one final carry resolution */ 5166 /* occurs. */ 5167 /* (The count is set via FASTLAZY to simplify experiments to */ 5168 /* measure the value of this approach: a 35% improvement on a */ 5169 /* [34x34] multiply.) */ 5170 lazy=FASTLAZY; /* carry delay count */ 5171 for (rip=zrhi; rip<=rmsi; rip++) { /* over each item in rhs */ 5172 lp=zacc+(rip-zrhi); /* where to add the lhs */ 5173 for (lip=zlhi; lip<=lmsi; lip++, lp++) { /* over each item in lhs */ 5174 *lp+=(uLong)(*lip)*(*rip); /* [this should in-line] */ 5175 } /* lip loop */ 5176 lazy--; 5177 if (lazy>0 && rip!=rmsi) continue; 5178 lazy=FASTLAZY; /* reset delay count */ 5179 /* spin up the accumulator resolving overflows */ 5180 for (lp=zacc; lp<zacc+iacc; lp++) { 5181 if (*lp<FASTBASE) continue; /* it fits */ 5182 lcarry=*lp/FASTBASE; /* top part [slow divide] */ 5183 /* lcarry can exceed 2**32-1, so check again; this check */ 5184 /* and occasional extra divide (slow) is well worth it, as */ 5185 /* it allows FASTLAZY to be increased to 18 rather than 4 */ 5186 /* in the FASTDIGS=9 case */ 5187 if (lcarry<FASTBASE) carry=(uInt)lcarry; /* [usual] */ 5188 else { /* two-place carry [fairly rare] */ 5189 uInt carry2=(uInt)(lcarry/FASTBASE); /* top top part */ 5190 *(lp+2)+=carry2; /* add to item+2 */ 5191 *lp-=((uLong)FASTBASE*FASTBASE*carry2); /* [slow] */ 5192 carry=(uInt)(lcarry-((uLong)FASTBASE*carry2)); /* [inline] */ 5193 } 5194 *(lp+1)+=carry; /* add to item above [inline] */ 5195 *lp-=((uLong)FASTBASE*carry); /* [inline] */ 5196 } /* carry resolution */ 5197 } /* rip loop */ 5198 5199 /* The multiplication is complete; time to convert back into */ 5200 /* units. This can be done in-place in the accumulator and in */ 5201 /* 32-bit operations, because carries were resolved after the */ 5202 /* final add. This needs N-1 divides and multiplies for */ 5203 /* each item in the accumulator (which will become up to N */ 5204 /* units, where 2<=N<=9). */ 5205 for (lp=zacc, up=acc; lp<zacc+iacc; lp++) { 5206 uInt item=(uInt)*lp; /* decapitate to uInt */ 5207 for (p=0; p<FASTDIGS-DECDPUN; p+=DECDPUN, up++) { 5208 uInt part=item/(DECDPUNMAX+1); 5209 *up=(Unit)(item-(part*(DECDPUNMAX+1))); 5210 item=part; 5211 } /* p */ 5212 *up=(Unit)item; up++; /* [final needs no division] */ 5213 } /* lp */ 5214 accunits=up-acc; /* count of units */ 5215 } 5216 else { /* here to use units directly, without chunking ['old code'] */ 5217 #endif 5218 5219 /* if accumulator will be too long for local storage, then allocate */ 5220 acc=accbuff; /* -> assume buffer for accumulator */ 5221 needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit); 5222 if (needbytes>(Int)sizeof(accbuff)) { 5223 allocacc=(Unit *)malloc(needbytes); 5224 if (allocacc==NULL) {*status|=DEC_Insufficient_storage; break;} 5225 acc=(Unit *)allocacc; /* use the allocated space */ 5226 } 5227 5228 /* Now the main long multiplication loop */ 5229 /* Unlike the equivalent in the IBM Java implementation, there */ 5230 /* is no advantage in calculating from msu to lsu. So, do it */ 5231 /* by the book, as it were. */ 5232 /* Each iteration calculates ACC=ACC+MULTAND*MULT */ 5233 accunits=1; /* accumulator starts at '0' */ 5234 *acc=0; /* .. (lsu=0) */ 5235 shift=0; /* no multiplicand shift at first */ 5236 madlength=D2U(lhs->digits); /* this won't change */ 5237 mermsup=rhs->lsu+D2U(rhs->digits); /* -> msu+1 of multiplier */ 5238 5239 for (mer=rhs->lsu; mer<mermsup; mer++) { 5240 /* Here, *mer is the next Unit in the multiplier to use */ 5241 /* If non-zero [optimization] add it... */ 5242 if (*mer!=0) accunits=decUnitAddSub(&acc[shift], accunits-shift, 5243 lhs->lsu, madlength, 0, 5244 &acc[shift], *mer) 5245 + shift; 5246 else { /* extend acc with a 0; it will be used shortly */ 5247 *(acc+accunits)=0; /* [this avoids length of <=0 later] */ 5248 accunits++; 5249 } 5250 /* multiply multiplicand by 10**DECDPUN for next Unit to left */ 5251 shift++; /* add this for 'logical length' */ 5252 } /* n */ 5253 #if FASTMUL 5254 } /* unchunked units */ 5255 #endif 5256 /* common end-path */ 5257 #if DECTRACE 5258 decDumpAr('*', acc, accunits); /* Show exact result */ 5259 #endif 5260 5261 /* acc now contains the exact result of the multiplication, */ 5262 /* possibly with a leading zero unit; build the decNumber from */ 5263 /* it, noting if any residue */ 5264 res->bits=bits; /* set sign */ 5265 res->digits=decGetDigits(acc, accunits); /* count digits exactly */ 5266 5267 /* There can be a 31-bit wrap in calculating the exponent. */ 5268 /* This can only happen if both input exponents are negative and */ 5269 /* both their magnitudes are large. If there was a wrap, set a */ 5270 /* safe very negative exponent, from which decFinalize() will */ 5271 /* raise a hard underflow shortly. */ 5272 exponent=lhs->exponent+rhs->exponent; /* calculate exponent */ 5273 if (lhs->exponent<0 && rhs->exponent<0 && exponent>0) 5274 exponent=-2*DECNUMMAXE; /* force underflow */ 5275 res->exponent=exponent; /* OK to overwrite now */ 5276 5277 5278 /* Set the coefficient. If any rounding, residue records */ 5279 decSetCoeff(res, set, acc, res->digits, &residue, status); 5280 decFinish(res, set, &residue, status); /* final cleanup */ 5281 } while(0); /* end protected */ 5282 5283 if (allocacc!=NULL) free(allocacc); /* drop any storage used */ 5284 #if DECSUBSET 5285 if (allocrhs!=NULL) free(allocrhs); /* .. */ 5286 if (alloclhs!=NULL) free(alloclhs); /* .. */ 5287 #endif 5288 #if FASTMUL 5289 if (allocrhi!=NULL) free(allocrhi); /* .. */ 5290 if (alloclhi!=NULL) free(alloclhi); /* .. */ 5291 #endif 5292 return res; 5293 } /* decMultiplyOp */ 5294 5295 /* ------------------------------------------------------------------ */ 5296 /* decExpOp -- effect exponentiation */ 5297 /* */ 5298 /* This computes C = exp(A) */ 5299 /* */ 5300 /* res is C, the result. C may be A */ 5301 /* rhs is A */ 5302 /* set is the context; note that rounding mode has no effect */ 5303 /* */ 5304 /* C must have space for set->digits digits. status is updated but */ 5305 /* not set. */ 5306 /* */ 5307 /* Restrictions: */ 5308 /* */ 5309 /* digits, emax, and -emin in the context must be less than */ 5310 /* 2*DEC_MAX_MATH (1999998), and the rhs must be within these */ 5311 /* bounds or a zero. This is an internal routine, so these */ 5312 /* restrictions are contractual and not enforced. */ 5313 /* */ 5314 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */ 5315 /* almost always be correctly rounded, but may be up to 1 ulp in */ 5316 /* error in rare cases. */ 5317 /* */ 5318 /* Finite results will always be full precision and Inexact, except */ 5319 /* when A is a zero or -Infinity (giving 1 or 0 respectively). */ 5320 /* ------------------------------------------------------------------ */ 5321 /* This approach used here is similar to the algorithm described in */ 5322 /* */ 5323 /* Variable Precision Exponential Function, T. E. Hull and */ 5324 /* A. Abrham, ACM Transactions on Mathematical Software, Vol 12 #2, */ 5325 /* pp79-91, ACM, June 1986. */ 5326 /* */ 5327 /* with the main difference being that the iterations in the series */ 5328 /* evaluation are terminated dynamically (which does not require the */ 5329 /* extra variable-precision variables which are expensive in this */ 5330 /* context). */ 5331 /* */ 5332 /* The error analysis in Hull & Abrham's paper applies except for the */ 5333 /* round-off error accumulation during the series evaluation. This */ 5334 /* code does not precalculate the number of iterations and so cannot */ 5335 /* use Horner's scheme. Instead, the accumulation is done at double- */ 5336 /* precision, which ensures that the additions of the terms are exact */ 5337 /* and do not accumulate round-off (and any round-off errors in the */ 5338 /* terms themselves move 'to the right' faster than they can */ 5339 /* accumulate). This code also extends the calculation by allowing, */ 5340 /* in the spirit of other decNumber operators, the input to be more */ 5341 /* precise than the result (the precision used is based on the more */ 5342 /* precise of the input or requested result). */ 5343 /* */ 5344 /* Implementation notes: */ 5345 /* */ 5346 /* 1. This is separated out as decExpOp so it can be called from */ 5347 /* other Mathematical functions (notably Ln) with a wider range */ 5348 /* than normal. In particular, it can handle the slightly wider */ 5349 /* (double) range needed by Ln (which has to be able to calculate */ 5350 /* exp(-x) where x can be the tiniest number (Ntiny). */ 5351 /* */ 5352 /* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop */ 5353 /* iterations by approximately a third with additional (although */ 5354 /* diminishing) returns as the range is reduced to even smaller */ 5355 /* fractions. However, h (the power of 10 used to correct the */ 5356 /* result at the end, see below) must be kept <=8 as otherwise */ 5357 /* the final result cannot be computed. Hence the leverage is a */ 5358 /* sliding value (8-h), where potentially the range is reduced */ 5359 /* more for smaller values. */ 5360 /* */ 5361 /* The leverage that can be applied in this way is severely */ 5362 /* limited by the cost of the raise-to-the power at the end, */ 5363 /* which dominates when the number of iterations is small (less */ 5364 /* than ten) or when rhs is short. As an example, the adjustment */ 5365 /* x**10,000,000 needs 31 multiplications, all but one full-width. */ 5366 /* */ 5367 /* 3. The restrictions (especially precision) could be raised with */ 5368 /* care, but the full decNumber range seems very hard within the */ 5369 /* 32-bit limits. */ 5370 /* */ 5371 /* 4. The working precisions for the static buffers are twice the */ 5372 /* obvious size to allow for calls from decNumberPower. */ 5373 /* ------------------------------------------------------------------ */ 5374 static decNumber *decExpOp(decNumber *res, const decNumber *rhs, 5375 decContext *set, uInt *status) { 5376 uInt ignore=0; /* working status */ 5377 Int h; /* adjusted exponent for 0.xxxx */ 5378 Int p; /* working precision */ 5379 Int residue; /* rounding residue */ 5380 uInt needbytes; /* for space calculations */ 5381 const decNumber *x=rhs; /* (may point to safe copy later) */ 5382 decContext aset, tset, dset; /* working contexts */ 5383 Int comp; /* work */ 5384 5385 /* the argument is often copied to normalize it, so (unusually) it */ 5386 /* is treated like other buffers, using DECBUFFER, +1 in case */ 5387 /* DECBUFFER is 0 */ 5388 decNumber bufr[D2N(DECBUFFER*2+1)]; 5389 decNumber *allocrhs=NULL; /* non-NULL if rhs buffer allocated */ 5390 5391 /* the working precision will be no more than set->digits+8+1 */ 5392 /* so for on-stack buffers DECBUFFER+9 is used, +1 in case DECBUFFER */ 5393 /* is 0 (and twice that for the accumulator) */ 5394 5395 /* buffer for t, term (working precision plus) */ 5396 decNumber buft[D2N(DECBUFFER*2+9+1)]; 5397 decNumber *allocbuft=NULL; /* -> allocated buft, iff allocated */ 5398 decNumber *t=buft; /* term */ 5399 /* buffer for a, accumulator (working precision * 2), at least 9 */ 5400 decNumber bufa[D2N(DECBUFFER*4+18+1)]; 5401 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 5402 decNumber *a=bufa; /* accumulator */ 5403 /* decNumber for the divisor term; this needs at most 9 digits */ 5404 /* and so can be fixed size [16 so can use standard context] */ 5405 decNumber bufd[D2N(16)]; 5406 decNumber *d=bufd; /* divisor */ 5407 decNumber numone; /* constant 1 */ 5408 5409 #if DECCHECK 5410 Int iterations=0; /* for later sanity check */ 5411 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 5412 #endif 5413 5414 do { /* protect allocated storage */ 5415 if (SPECIALARG) { /* handle infinities and NaNs */ 5416 if (decNumberIsInfinite(rhs)) { /* an infinity */ 5417 if (decNumberIsNegative(rhs)) /* -Infinity -> +0 */ 5418 decNumberZero(res); 5419 else decNumberCopy(res, rhs); /* +Infinity -> self */ 5420 } 5421 else decNaNs(res, rhs, NULL, set, status); /* a NaN */ 5422 break;} 5423 5424 if (ISZERO(rhs)) { /* zeros -> exact 1 */ 5425 decNumberZero(res); /* make clean 1 */ 5426 *res->lsu=1; /* .. */ 5427 break;} /* [no status to set] */ 5428 5429 /* e**x when 0 < x < 0.66 is < 1+3x/2, hence can fast-path */ 5430 /* positive and negative tiny cases which will result in inexact */ 5431 /* 1. This also allows the later add-accumulate to always be */ 5432 /* exact (because its length will never be more than twice the */ 5433 /* working precision). */ 5434 /* The comparator (tiny) needs just one digit, so use the */ 5435 /* decNumber d for it (reused as the divisor, etc., below); its */ 5436 /* exponent is such that if x is positive it will have */ 5437 /* set->digits-1 zeros between the decimal point and the digit, */ 5438 /* which is 4, and if x is negative one more zero there as the */ 5439 /* more precise result will be of the form 0.9999999 rather than */ 5440 /* 1.0000001. Hence, tiny will be 0.0000004 if digits=7 and x>0 */ 5441 /* or 0.00000004 if digits=7 and x<0. If RHS not larger than */ 5442 /* this then the result will be 1.000000 */ 5443 decNumberZero(d); /* clean */ 5444 *d->lsu=4; /* set 4 .. */ 5445 d->exponent=-set->digits; /* * 10**(-d) */ 5446 if (decNumberIsNegative(rhs)) d->exponent--; /* negative case */ 5447 comp=decCompare(d, rhs, 1); /* signless compare */ 5448 if (comp==BADINT) { 5449 *status|=DEC_Insufficient_storage; 5450 break;} 5451 if (comp>=0) { /* rhs < d */ 5452 Int shift=set->digits-1; 5453 decNumberZero(res); /* set 1 */ 5454 *res->lsu=1; /* .. */ 5455 res->digits=decShiftToMost(res->lsu, 1, shift); 5456 res->exponent=-shift; /* make 1.0000... */ 5457 *status|=DEC_Inexact | DEC_Rounded; /* .. inexactly */ 5458 break;} /* tiny */ 5459 5460 /* set up the context to be used for calculating a, as this is */ 5461 /* used on both paths below */ 5462 decContextDefault(&aset, DEC_INIT_DECIMAL64); 5463 /* accumulator bounds are as requested (could underflow) */ 5464 aset.emax=set->emax; /* usual bounds */ 5465 aset.emin=set->emin; /* .. */ 5466 aset.clamp=0; /* and no concrete format */ 5467 5468 /* calculate the adjusted (Hull & Abrham) exponent (where the */ 5469 /* decimal point is just to the left of the coefficient msd) */ 5470 h=rhs->exponent+rhs->digits; 5471 /* if h>8 then 10**h cannot be calculated safely; however, when */ 5472 /* h=8 then exp(|rhs|) will be at least exp(1E+7) which is at */ 5473 /* least 6.59E+4342944, so (due to the restriction on Emax/Emin) */ 5474 /* overflow (or underflow to 0) is guaranteed -- so this case can */ 5475 /* be handled by simply forcing the appropriate excess */ 5476 if (h>8) { /* overflow/underflow */ 5477 /* set up here so Power call below will over or underflow to */ 5478 /* zero; set accumulator to either 2 or 0.02 */ 5479 /* [stack buffer for a is always big enough for this] */ 5480 decNumberZero(a); 5481 *a->lsu=2; /* not 1 but < exp(1) */ 5482 if (decNumberIsNegative(rhs)) a->exponent=-2; /* make 0.02 */ 5483 h=8; /* clamp so 10**h computable */ 5484 p=9; /* set a working precision */ 5485 } 5486 else { /* h<=8 */ 5487 Int maxlever=(rhs->digits>8?1:0); 5488 /* [could/should increase this for precisions >40 or so, too] */ 5489 5490 /* if h is 8, cannot normalize to a lower upper limit because */ 5491 /* the final result will not be computable (see notes above), */ 5492 /* but leverage can be applied whenever h is less than 8. */ 5493 /* Apply as much as possible, up to a MAXLEVER digits, which */ 5494 /* sets the tradeoff against the cost of the later a**(10**h). */ 5495 /* As h is increased, the working precision below also */ 5496 /* increases to compensate for the "constant digits at the */ 5497 /* front" effect. */ 5498 Int lever=MINI(8-h, maxlever); /* leverage attainable */ 5499 Int use=-rhs->digits-lever; /* exponent to use for RHS */ 5500 h+=lever; /* apply leverage selected */ 5501 if (h<0) { /* clamp */ 5502 use+=h; /* [may end up subnormal] */ 5503 h=0; 5504 } 5505 /* Take a copy of RHS if it needs normalization (true whenever x>=1) */ 5506 if (rhs->exponent!=use) { 5507 decNumber *newrhs=bufr; /* assume will fit on stack */ 5508 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); 5509 if (needbytes>sizeof(bufr)) { /* need malloc space */ 5510 allocrhs=(decNumber *)malloc(needbytes); 5511 if (allocrhs==NULL) { /* hopeless -- abandon */ 5512 *status|=DEC_Insufficient_storage; 5513 break;} 5514 newrhs=allocrhs; /* use the allocated space */ 5515 } 5516 decNumberCopy(newrhs, rhs); /* copy to safe space */ 5517 newrhs->exponent=use; /* normalize; now <1 */ 5518 x=newrhs; /* ready for use */ 5519 /* decNumberShow(x); */ 5520 } 5521 5522 /* Now use the usual power series to evaluate exp(x). The */ 5523 /* series starts as 1 + x + x^2/2 ... so prime ready for the */ 5524 /* third term by setting the term variable t=x, the accumulator */ 5525 /* a=1, and the divisor d=2. */ 5526 5527 /* First determine the working precision. From Hull & Abrham */ 5528 /* this is set->digits+h+2. However, if x is 'over-precise' we */ 5529 /* need to allow for all its digits to potentially participate */ 5530 /* (consider an x where all the excess digits are 9s) so in */ 5531 /* this case use x->digits+h+2 */ 5532 p=MAXI(x->digits, set->digits)+h+2; /* [h<=8] */ 5533 5534 /* a and t are variable precision, and depend on p, so space */ 5535 /* must be allocated for them if necessary */ 5536 5537 /* the accumulator needs to be able to hold 2p digits so that */ 5538 /* the additions on the second and subsequent iterations are */ 5539 /* sufficiently exact. */ 5540 needbytes=sizeof(decNumber)+(D2U(p*2)-1)*sizeof(Unit); 5541 if (needbytes>sizeof(bufa)) { /* need malloc space */ 5542 allocbufa=(decNumber *)malloc(needbytes); 5543 if (allocbufa==NULL) { /* hopeless -- abandon */ 5544 *status|=DEC_Insufficient_storage; 5545 break;} 5546 a=allocbufa; /* use the allocated space */ 5547 } 5548 /* the term needs to be able to hold p digits (which is */ 5549 /* guaranteed to be larger than x->digits, so the initial copy */ 5550 /* is safe); it may also be used for the raise-to-power */ 5551 /* calculation below, which needs an extra two digits */ 5552 needbytes=sizeof(decNumber)+(D2U(p+2)-1)*sizeof(Unit); 5553 if (needbytes>sizeof(buft)) { /* need malloc space */ 5554 allocbuft=(decNumber *)malloc(needbytes); 5555 if (allocbuft==NULL) { /* hopeless -- abandon */ 5556 *status|=DEC_Insufficient_storage; 5557 break;} 5558 t=allocbuft; /* use the allocated space */ 5559 } 5560 5561 decNumberCopy(t, x); /* term=x */ 5562 decNumberZero(a); *a->lsu=1; /* accumulator=1 */ 5563 decNumberZero(d); *d->lsu=2; /* divisor=2 */ 5564 decNumberZero(&numone); *numone.lsu=1; /* constant 1 for increment */ 5565 5566 /* set up the contexts for calculating a, t, and d */ 5567 decContextDefault(&tset, DEC_INIT_DECIMAL64); 5568 dset=tset; 5569 /* accumulator bounds are set above, set precision now */ 5570 aset.digits=p*2; /* double */ 5571 /* term bounds avoid any underflow or overflow */ 5572 tset.digits=p; 5573 tset.emin=DEC_MIN_EMIN; /* [emax is plenty] */ 5574 /* [dset.digits=16, etc., are sufficient] */ 5575 5576 /* finally ready to roll */ 5577 for (;;) { 5578 #if DECCHECK 5579 iterations++; 5580 #endif 5581 /* only the status from the accumulation is interesting */ 5582 /* [but it should remain unchanged after first add] */ 5583 decAddOp(a, a, t, &aset, 0, status); /* a=a+t */ 5584 decMultiplyOp(t, t, x, &tset, &ignore); /* t=t*x */ 5585 decDivideOp(t, t, d, &tset, DIVIDE, &ignore); /* t=t/d */ 5586 /* the iteration ends when the term cannot affect the result, */ 5587 /* if rounded to p digits, which is when its value is smaller */ 5588 /* than the accumulator by p+1 digits. There must also be */ 5589 /* full precision in a. */ 5590 if (((a->digits+a->exponent)>=(t->digits+t->exponent+p+1)) 5591 && (a->digits>=p)) break; 5592 decAddOp(d, d, &numone, &dset, 0, &ignore); /* d=d+1 */ 5593 } /* iterate */ 5594 5595 #if DECCHECK 5596 /* just a sanity check; comment out test to show always */ 5597 if (iterations>p+3) 5598 printf("Exp iterations=%ld, status=%08lx, p=%ld, d=%ld\n", 5599 iterations, *status, p, x->digits); 5600 #endif 5601 } /* h<=8 */ 5602 5603 /* apply postconditioning: a=a**(10**h) -- this is calculated */ 5604 /* at a slightly higher precision than Hull & Abrham suggest */ 5605 if (h>0) { 5606 Int seenbit=0; /* set once a 1-bit is seen */ 5607 Int i; /* counter */ 5608 Int n=powers[h]; /* always positive */ 5609 aset.digits=p+2; /* sufficient precision */ 5610 /* avoid the overhead and many extra digits of decNumberPower */ 5611 /* as all that is needed is the short 'multipliers' loop; here */ 5612 /* accumulate the answer into t */ 5613 decNumberZero(t); *t->lsu=1; /* acc=1 */ 5614 for (i=1;;i++){ /* for each bit [top bit ignored] */ 5615 /* abandon if have had overflow or terminal underflow */ 5616 if (*status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */ 5617 if (*status&DEC_Overflow || ISZERO(t)) break;} 5618 n=n<<1; /* move next bit to testable position */ 5619 if (n<0) { /* top bit is set */ 5620 seenbit=1; /* OK, have a significant bit */ 5621 decMultiplyOp(t, t, a, &aset, status); /* acc=acc*x */ 5622 } 5623 if (i==31) break; /* that was the last bit */ 5624 if (!seenbit) continue; /* no need to square 1 */ 5625 decMultiplyOp(t, t, t, &aset, status); /* acc=acc*acc [square] */ 5626 } /*i*/ /* 32 bits */ 5627 /* decNumberShow(t); */ 5628 a=t; /* and carry on using t instead of a */ 5629 } 5630 5631 /* Copy and round the result to res */ 5632 residue=1; /* indicate dirt to right .. */ 5633 if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */ 5634 aset.digits=set->digits; /* [use default rounding] */ 5635 decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */ 5636 decFinish(res, set, &residue, status); /* cleanup/set flags */ 5637 } while(0); /* end protected */ 5638 5639 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */ 5640 if (allocbufa!=NULL) free(allocbufa); /* .. */ 5641 if (allocbuft!=NULL) free(allocbuft); /* .. */ 5642 /* [status is handled by caller] */ 5643 return res; 5644 } /* decExpOp */ 5645 5646 /* ------------------------------------------------------------------ */ 5647 /* Initial-estimate natural logarithm table */ 5648 /* */ 5649 /* LNnn -- 90-entry 16-bit table for values from .10 through .99. */ 5650 /* The result is a 4-digit encode of the coefficient (c=the */ 5651 /* top 14 bits encoding 0-9999) and a 2-digit encode of the */ 5652 /* exponent (e=the bottom 2 bits encoding 0-3) */ 5653 /* */ 5654 /* The resulting value is given by: */ 5655 /* */ 5656 /* v = -c * 10**(-e-3) */ 5657 /* */ 5658 /* where e and c are extracted from entry k = LNnn[x-10] */ 5659 /* where x is truncated (NB) into the range 10 through 99, */ 5660 /* and then c = k>>2 and e = k&3. */ 5661 /* ------------------------------------------------------------------ */ 5662 static const uShort LNnn[90] = { 5663 9016, 8652, 8316, 8008, 7724, 7456, 7208, 5664 6972, 6748, 6540, 6340, 6148, 5968, 5792, 5628, 5464, 5312, 5665 5164, 5020, 4884, 4748, 4620, 4496, 4376, 4256, 4144, 4032, 5666 39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629, 5667 29777, 28945, 28129, 27329, 26545, 25777, 25021, 24281, 23553, 22837, 5668 22137, 21445, 20769, 20101, 19445, 18801, 18165, 17541, 16925, 16321, 5669 15721, 15133, 14553, 13985, 13421, 12865, 12317, 11777, 11241, 10717, 5670 10197, 9685, 9177, 8677, 8185, 7697, 7213, 6737, 6269, 5801, 5671 5341, 4889, 4437, 39930, 35534, 31186, 26886, 22630, 18418, 14254, 5672 10130, 6046, 20055}; 5673 5674 /* ------------------------------------------------------------------ */ 5675 /* decLnOp -- effect natural logarithm */ 5676 /* */ 5677 /* This computes C = ln(A) */ 5678 /* */ 5679 /* res is C, the result. C may be A */ 5680 /* rhs is A */ 5681 /* set is the context; note that rounding mode has no effect */ 5682 /* */ 5683 /* C must have space for set->digits digits. */ 5684 /* */ 5685 /* Notable cases: */ 5686 /* A<0 -> Invalid */ 5687 /* A=0 -> -Infinity (Exact) */ 5688 /* A=+Infinity -> +Infinity (Exact) */ 5689 /* A=1 exactly -> 0 (Exact) */ 5690 /* */ 5691 /* Restrictions (as for Exp): */ 5692 /* */ 5693 /* digits, emax, and -emin in the context must be less than */ 5694 /* DEC_MAX_MATH+11 (1000010), and the rhs must be within these */ 5695 /* bounds or a zero. This is an internal routine, so these */ 5696 /* restrictions are contractual and not enforced. */ 5697 /* */ 5698 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */ 5699 /* almost always be correctly rounded, but may be up to 1 ulp in */ 5700 /* error in rare cases. */ 5701 /* ------------------------------------------------------------------ */ 5702 /* The result is calculated using Newton's method, with each */ 5703 /* iteration calculating a' = a + x * exp(-a) - 1. See, for example, */ 5704 /* Epperson 1989. */ 5705 /* */ 5706 /* The iteration ends when the adjustment x*exp(-a)-1 is tiny enough. */ 5707 /* This has to be calculated at the sum of the precision of x and the */ 5708 /* working precision. */ 5709 /* */ 5710 /* Implementation notes: */ 5711 /* */ 5712 /* 1. This is separated out as decLnOp so it can be called from */ 5713 /* other Mathematical functions (e.g., Log 10) with a wider range */ 5714 /* than normal. In particular, it can handle the slightly wider */ 5715 /* (+9+2) range needed by a power function. */ 5716 /* */ 5717 /* 2. The speed of this function is about 10x slower than exp, as */ 5718 /* it typically needs 4-6 iterations for short numbers, and the */ 5719 /* extra precision needed adds a squaring effect, twice. */ 5720 /* */ 5721 /* 3. Fastpaths are included for ln(10) and ln(2), up to length 40, */ 5722 /* as these are common requests. ln(10) is used by log10(x). */ 5723 /* */ 5724 /* 4. An iteration might be saved by widening the LNnn table, and */ 5725 /* would certainly save at least one if it were made ten times */ 5726 /* bigger, too (for truncated fractions 0.100 through 0.999). */ 5727 /* However, for most practical evaluations, at least four or five */ 5728 /* iterations will be needed -- so this would only speed up by */ 5729 /* 20-25% and that probably does not justify increasing the table */ 5730 /* size. */ 5731 /* */ 5732 /* 5. The static buffers are larger than might be expected to allow */ 5733 /* for calls from decNumberPower. */ 5734 /* ------------------------------------------------------------------ */ 5735 static decNumber *decLnOp(decNumber *res, const decNumber *rhs, 5736 decContext *set, uInt *status) { 5737 uInt ignore=0; /* working status accumulator */ 5738 uInt needbytes; /* for space calculations */ 5739 Int residue; /* rounding residue */ 5740 Int r; /* rhs=f*10**r [see below] */ 5741 Int p; /* working precision */ 5742 Int pp; /* precision for iteration */ 5743 Int t; /* work */ 5744 5745 /* buffers for a (accumulator, typically precision+2) and b */ 5746 /* (adjustment calculator, same size) */ 5747 decNumber bufa[D2N(DECBUFFER+12)]; 5748 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 5749 decNumber *a=bufa; /* accumulator/work */ 5750 decNumber bufb[D2N(DECBUFFER*2+2)]; 5751 decNumber *allocbufb=NULL; /* -> allocated bufa, iff allocated */ 5752 decNumber *b=bufb; /* adjustment/work */ 5753 5754 decNumber numone; /* constant 1 */ 5755 decNumber cmp; /* work */ 5756 decContext aset, bset; /* working contexts */ 5757 5758 #if DECCHECK 5759 Int iterations=0; /* for later sanity check */ 5760 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 5761 #endif 5762 5763 do { /* protect allocated storage */ 5764 if (SPECIALARG) { /* handle infinities and NaNs */ 5765 if (decNumberIsInfinite(rhs)) { /* an infinity */ 5766 if (decNumberIsNegative(rhs)) /* -Infinity -> error */ 5767 *status|=DEC_Invalid_operation; 5768 else decNumberCopy(res, rhs); /* +Infinity -> self */ 5769 } 5770 else decNaNs(res, rhs, NULL, set, status); /* a NaN */ 5771 break;} 5772 5773 if (ISZERO(rhs)) { /* +/- zeros -> -Infinity */ 5774 decNumberZero(res); /* make clean */ 5775 res->bits=DECINF|DECNEG; /* set - infinity */ 5776 break;} /* [no status to set] */ 5777 5778 /* Non-zero negatives are bad... */ 5779 if (decNumberIsNegative(rhs)) { /* -x -> error */ 5780 *status|=DEC_Invalid_operation; 5781 break;} 5782 5783 /* Here, rhs is positive, finite, and in range */ 5784 5785 /* lookaside fastpath code for ln(2) and ln(10) at common lengths */ 5786 if (rhs->exponent==0 && set->digits<=40) { 5787 #if DECDPUN==1 5788 if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { /* ln(10) */ 5789 #else 5790 if (rhs->lsu[0]==10 && rhs->digits==2) { /* ln(10) */ 5791 #endif 5792 aset=*set; aset.round=DEC_ROUND_HALF_EVEN; 5793 #define LN10 "2.302585092994045684017991454684364207601" 5794 decNumberFromString(res, LN10, &aset); 5795 *status|=(DEC_Inexact | DEC_Rounded); /* is inexact */ 5796 break;} 5797 if (rhs->lsu[0]==2 && rhs->digits==1) { /* ln(2) */ 5798 aset=*set; aset.round=DEC_ROUND_HALF_EVEN; 5799 #define LN2 "0.6931471805599453094172321214581765680755" 5800 decNumberFromString(res, LN2, &aset); 5801 *status|=(DEC_Inexact | DEC_Rounded); 5802 break;} 5803 } /* integer and short */ 5804 5805 /* Determine the working precision. This is normally the */ 5806 /* requested precision + 2, with a minimum of 9. However, if */ 5807 /* the rhs is 'over-precise' then allow for all its digits to */ 5808 /* potentially participate (consider an rhs where all the excess */ 5809 /* digits are 9s) so in this case use rhs->digits+2. */ 5810 p=MAXI(rhs->digits, MAXI(set->digits, 7))+2; 5811 5812 /* Allocate space for the accumulator and the high-precision */ 5813 /* adjustment calculator, if necessary. The accumulator must */ 5814 /* be able to hold p digits, and the adjustment up to */ 5815 /* rhs->digits+p digits. They are also made big enough for 16 */ 5816 /* digits so that they can be used for calculating the initial */ 5817 /* estimate. */ 5818 needbytes=sizeof(decNumber)+(D2U(MAXI(p,16))-1)*sizeof(Unit); 5819 if (needbytes>sizeof(bufa)) { /* need malloc space */ 5820 allocbufa=(decNumber *)malloc(needbytes); 5821 if (allocbufa==NULL) { /* hopeless -- abandon */ 5822 *status|=DEC_Insufficient_storage; 5823 break;} 5824 a=allocbufa; /* use the allocated space */ 5825 } 5826 pp=p+rhs->digits; 5827 needbytes=sizeof(decNumber)+(D2U(MAXI(pp,16))-1)*sizeof(Unit); 5828 if (needbytes>sizeof(bufb)) { /* need malloc space */ 5829 allocbufb=(decNumber *)malloc(needbytes); 5830 if (allocbufb==NULL) { /* hopeless -- abandon */ 5831 *status|=DEC_Insufficient_storage; 5832 break;} 5833 b=allocbufb; /* use the allocated space */ 5834 } 5835 5836 /* Prepare an initial estimate in acc. Calculate this by */ 5837 /* considering the coefficient of x to be a normalized fraction, */ 5838 /* f, with the decimal point at far left and multiplied by */ 5839 /* 10**r. Then, rhs=f*10**r and 0.1<=f<1, and */ 5840 /* ln(x) = ln(f) + ln(10)*r */ 5841 /* Get the initial estimate for ln(f) from a small lookup */ 5842 /* table (see above) indexed by the first two digits of f, */ 5843 /* truncated. */ 5844 5845 decContextDefault(&aset, DEC_INIT_DECIMAL64); /* 16-digit extended */ 5846 r=rhs->exponent+rhs->digits; /* 'normalised' exponent */ 5847 decNumberFromInt32(a, r); /* a=r */ 5848 decNumberFromInt32(b, 2302585); /* b=ln(10) (2.302585) */ 5849 b->exponent=-6; /* .. */ 5850 decMultiplyOp(a, a, b, &aset, &ignore); /* a=a*b */ 5851 /* now get top two digits of rhs into b by simple truncate and */ 5852 /* force to integer */ 5853 residue=0; /* (no residue) */ 5854 aset.digits=2; aset.round=DEC_ROUND_DOWN; 5855 decCopyFit(b, rhs, &aset, &residue, &ignore); /* copy & shorten */ 5856 b->exponent=0; /* make integer */ 5857 t=decGetInt(b); /* [cannot fail] */ 5858 if (t<10) t=X10(t); /* adjust single-digit b */ 5859 t=LNnn[t-10]; /* look up ln(b) */ 5860 decNumberFromInt32(b, t>>2); /* b=ln(b) coefficient */ 5861 b->exponent=-(t&3)-3; /* set exponent */ 5862 b->bits=DECNEG; /* ln(0.10)->ln(0.99) always -ve */ 5863 aset.digits=16; aset.round=DEC_ROUND_HALF_EVEN; /* restore */ 5864 decAddOp(a, a, b, &aset, 0, &ignore); /* acc=a+b */ 5865 /* the initial estimate is now in a, with up to 4 digits correct. */ 5866 /* When rhs is at or near Nmax the estimate will be low, so we */ 5867 /* will approach it from below, avoiding overflow when calling exp. */ 5868 5869 decNumberZero(&numone); *numone.lsu=1; /* constant 1 for adjustment */ 5870 5871 /* accumulator bounds are as requested (could underflow, but */ 5872 /* cannot overflow) */ 5873 aset.emax=set->emax; 5874 aset.emin=set->emin; 5875 aset.clamp=0; /* no concrete format */ 5876 /* set up a context to be used for the multiply and subtract */ 5877 bset=aset; 5878 bset.emax=DEC_MAX_MATH*2; /* use double bounds for the */ 5879 bset.emin=-DEC_MAX_MATH*2; /* adjustment calculation */ 5880 /* [see decExpOp call below] */ 5881 /* for each iteration double the number of digits to calculate, */ 5882 /* up to a maximum of p */ 5883 pp=9; /* initial precision */ 5884 /* [initially 9 as then the sequence starts 7+2, 16+2, and */ 5885 /* 34+2, which is ideal for standard-sized numbers] */ 5886 aset.digits=pp; /* working context */ 5887 bset.digits=pp+rhs->digits; /* wider context */ 5888 for (;;) { /* iterate */ 5889 #if DECCHECK 5890 iterations++; 5891 if (iterations>24) break; /* consider 9 * 2**24 */ 5892 #endif 5893 /* calculate the adjustment (exp(-a)*x-1) into b. This is a */ 5894 /* catastrophic subtraction but it really is the difference */ 5895 /* from 1 that is of interest. */ 5896 /* Use the internal entry point to Exp as it allows the double */ 5897 /* range for calculating exp(-a) when a is the tiniest subnormal. */ 5898 a->bits^=DECNEG; /* make -a */ 5899 decExpOp(b, a, &bset, &ignore); /* b=exp(-a) */ 5900 a->bits^=DECNEG; /* restore sign of a */ 5901 /* now multiply by rhs and subtract 1, at the wider precision */ 5902 decMultiplyOp(b, b, rhs, &bset, &ignore); /* b=b*rhs */ 5903 decAddOp(b, b, &numone, &bset, DECNEG, &ignore); /* b=b-1 */ 5904 5905 /* the iteration ends when the adjustment cannot affect the */ 5906 /* result by >=0.5 ulp (at the requested digits), which */ 5907 /* is when its value is smaller than the accumulator by */ 5908 /* set->digits+1 digits (or it is zero) -- this is a looser */ 5909 /* requirement than for Exp because all that happens to the */ 5910 /* accumulator after this is the final rounding (but note that */ 5911 /* there must also be full precision in a, or a=0). */ 5912 5913 if (decNumberIsZero(b) || 5914 (a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) { 5915 if (a->digits==p) break; 5916 if (decNumberIsZero(a)) { 5917 decCompareOp(&cmp, rhs, &numone, &aset, COMPARE, &ignore); /* rhs=1 ? */ 5918 if (cmp.lsu[0]==0) a->exponent=0; /* yes, exact 0 */ 5919 else *status|=(DEC_Inexact | DEC_Rounded); /* no, inexact */ 5920 break; 5921 } 5922 /* force padding if adjustment has gone to 0 before full length */ 5923 if (decNumberIsZero(b)) b->exponent=a->exponent-p; 5924 } 5925 5926 /* not done yet ... */ 5927 decAddOp(a, a, b, &aset, 0, &ignore); /* a=a+b for next estimate */ 5928 if (pp==p) continue; /* precision is at maximum */ 5929 /* lengthen the next calculation */ 5930 pp=pp*2; /* double precision */ 5931 if (pp>p) pp=p; /* clamp to maximum */ 5932 aset.digits=pp; /* working context */ 5933 bset.digits=pp+rhs->digits; /* wider context */ 5934 } /* Newton's iteration */ 5935 5936 #if DECCHECK 5937 /* just a sanity check; remove the test to show always */ 5938 if (iterations>24) 5939 printf("Ln iterations=%ld, status=%08lx, p=%ld, d=%ld\n", 5940 iterations, *status, p, rhs->digits); 5941 #endif 5942 5943 /* Copy and round the result to res */ 5944 residue=1; /* indicate dirt to right */ 5945 if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */ 5946 aset.digits=set->digits; /* [use default rounding] */ 5947 decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */ 5948 decFinish(res, set, &residue, status); /* cleanup/set flags */ 5949 } while(0); /* end protected */ 5950 5951 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */ 5952 if (allocbufb!=NULL) free(allocbufb); /* .. */ 5953 /* [status is handled by caller] */ 5954 return res; 5955 } /* decLnOp */ 5956 5957 /* ------------------------------------------------------------------ */ 5958 /* decQuantizeOp -- force exponent to requested value */ 5959 /* */ 5960 /* This computes C = op(A, B), where op adjusts the coefficient */ 5961 /* of C (by rounding or shifting) such that the exponent (-scale) */ 5962 /* of C has the value B or matches the exponent of B. */ 5963 /* The numerical value of C will equal A, except for the effects of */ 5964 /* any rounding that occurred. */ 5965 /* */ 5966 /* res is C, the result. C may be A or B */ 5967 /* lhs is A, the number to adjust */ 5968 /* rhs is B, the requested exponent */ 5969 /* set is the context */ 5970 /* quant is 1 for quantize or 0 for rescale */ 5971 /* status is the status accumulator (this can be called without */ 5972 /* risk of control loss) */ 5973 /* */ 5974 /* C must have space for set->digits digits. */ 5975 /* */ 5976 /* Unless there is an error or the result is infinite, the exponent */ 5977 /* after the operation is guaranteed to be that requested. */ 5978 /* ------------------------------------------------------------------ */ 5979 static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs, 5980 const decNumber *rhs, decContext *set, 5981 Flag quant, uInt *status) { 5982 #if DECSUBSET 5983 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 5984 decNumber *allocrhs=NULL; /* .., rhs */ 5985 #endif 5986 const decNumber *inrhs=rhs; /* save original rhs */ 5987 Int reqdigits=set->digits; /* requested DIGITS */ 5988 Int reqexp; /* requested exponent [-scale] */ 5989 Int residue=0; /* rounding residue */ 5990 Int etiny=set->emin-(reqdigits-1); 5991 5992 #if DECCHECK 5993 if (decCheckOperands(res, lhs, rhs, set)) return res; 5994 #endif 5995 5996 do { /* protect allocated storage */ 5997 #if DECSUBSET 5998 if (!set->extended) { 5999 /* reduce operands and set lostDigits status, as needed */ 6000 if (lhs->digits>reqdigits) { 6001 alloclhs=decRoundOperand(lhs, set, status); 6002 if (alloclhs==NULL) break; 6003 lhs=alloclhs; 6004 } 6005 if (rhs->digits>reqdigits) { /* [this only checks lostDigits] */ 6006 allocrhs=decRoundOperand(rhs, set, status); 6007 if (allocrhs==NULL) break; 6008 rhs=allocrhs; 6009 } 6010 } 6011 #endif 6012 /* [following code does not require input rounding] */ 6013 6014 /* Handle special values */ 6015 if (SPECIALARGS) { 6016 /* NaNs get usual processing */ 6017 if (SPECIALARGS & (DECSNAN | DECNAN)) 6018 decNaNs(res, lhs, rhs, set, status); 6019 /* one infinity but not both is bad */ 6020 else if ((lhs->bits ^ rhs->bits) & DECINF) 6021 *status|=DEC_Invalid_operation; 6022 /* both infinity: return lhs */ 6023 else decNumberCopy(res, lhs); /* [nop if in place] */ 6024 break; 6025 } 6026 6027 /* set requested exponent */ 6028 if (quant) reqexp=inrhs->exponent; /* quantize -- match exponents */ 6029 else { /* rescale -- use value of rhs */ 6030 /* Original rhs must be an integer that fits and is in range, */ 6031 /* which could be from -1999999997 to +999999999, thanks to */ 6032 /* subnormals */ 6033 reqexp=decGetInt(inrhs); /* [cannot fail] */ 6034 } 6035 6036 #if DECSUBSET 6037 if (!set->extended) etiny=set->emin; /* no subnormals */ 6038 #endif 6039 6040 if (reqexp==BADINT /* bad (rescale only) or .. */ 6041 || reqexp==BIGODD || reqexp==BIGEVEN /* very big (ditto) or .. */ 6042 || (reqexp<etiny) /* < lowest */ 6043 || (reqexp>set->emax)) { /* > emax */ 6044 *status|=DEC_Invalid_operation; 6045 break;} 6046 6047 /* the RHS has been processed, so it can be overwritten now if necessary */ 6048 if (ISZERO(lhs)) { /* zero coefficient unchanged */ 6049 decNumberCopy(res, lhs); /* [nop if in place] */ 6050 res->exponent=reqexp; /* .. just set exponent */ 6051 #if DECSUBSET 6052 if (!set->extended) res->bits=0; /* subset specification; no -0 */ 6053 #endif 6054 } 6055 else { /* non-zero lhs */ 6056 Int adjust=reqexp-lhs->exponent; /* digit adjustment needed */ 6057 /* if adjusted coefficient will definitely not fit, give up now */ 6058 if ((lhs->digits-adjust)>reqdigits) { 6059 *status|=DEC_Invalid_operation; 6060 break; 6061 } 6062 6063 if (adjust>0) { /* increasing exponent */ 6064 /* this will decrease the length of the coefficient by adjust */ 6065 /* digits, and must round as it does so */ 6066 decContext workset; /* work */ 6067 workset=*set; /* clone rounding, etc. */ 6068 workset.digits=lhs->digits-adjust; /* set requested length */ 6069 /* [note that the latter can be <1, here] */ 6070 decCopyFit(res, lhs, &workset, &residue, status); /* fit to result */ 6071 decApplyRound(res, &workset, residue, status); /* .. and round */ 6072 residue=0; /* [used] */ 6073 /* If just rounded a 999s case, exponent will be off by one; */ 6074 /* adjust back (after checking space), if so. */ 6075 if (res->exponent>reqexp) { 6076 /* re-check needed, e.g., for quantize(0.9999, 0.001) under */ 6077 /* set->digits==3 */ 6078 if (res->digits==reqdigits) { /* cannot shift by 1 */ 6079 *status&=~(DEC_Inexact | DEC_Rounded); /* [clean these] */ 6080 *status|=DEC_Invalid_operation; 6081 break; 6082 } 6083 res->digits=decShiftToMost(res->lsu, res->digits, 1); /* shift */ 6084 res->exponent--; /* (re)adjust the exponent. */ 6085 } 6086 #if DECSUBSET 6087 if (ISZERO(res) && !set->extended) res->bits=0; /* subset; no -0 */ 6088 #endif 6089 } /* increase */ 6090 else /* adjust<=0 */ { /* decreasing or = exponent */ 6091 /* this will increase the length of the coefficient by -adjust */ 6092 /* digits, by adding zero or more trailing zeros; this is */ 6093 /* already checked for fit, above */ 6094 decNumberCopy(res, lhs); /* [it will fit] */ 6095 /* if padding needed (adjust<0), add it now... */ 6096 if (adjust<0) { 6097 res->digits=decShiftToMost(res->lsu, res->digits, -adjust); 6098 res->exponent+=adjust; /* adjust the exponent */ 6099 } 6100 } /* decrease */ 6101 } /* non-zero */ 6102 6103 /* Check for overflow [do not use Finalize in this case, as an */ 6104 /* overflow here is a "don't fit" situation] */ 6105 if (res->exponent>set->emax-res->digits+1) { /* too big */ 6106 *status|=DEC_Invalid_operation; 6107 break; 6108 } 6109 else { 6110 decFinalize(res, set, &residue, status); /* set subnormal flags */ 6111 *status&=~DEC_Underflow; /* suppress Underflow [754r] */ 6112 } 6113 } while(0); /* end protected */ 6114 6115 #if DECSUBSET 6116 if (allocrhs!=NULL) free(allocrhs); /* drop any storage used */ 6117 if (alloclhs!=NULL) free(alloclhs); /* .. */ 6118 #endif 6119 return res; 6120 } /* decQuantizeOp */ 6121 6122 /* ------------------------------------------------------------------ */ 6123 /* decCompareOp -- compare, min, or max two Numbers */ 6124 /* */ 6125 /* This computes C = A ? B and carries out one of four operations: */ 6126 /* COMPARE -- returns the signum (as a number) giving the */ 6127 /* result of a comparison unless one or both */ 6128 /* operands is a NaN (in which case a NaN results) */ 6129 /* COMPSIG -- as COMPARE except that a quiet NaN raises */ 6130 /* Invalid operation. */ 6131 /* COMPMAX -- returns the larger of the operands, using the */ 6132 /* 754r maxnum operation */ 6133 /* COMPMAXMAG -- ditto, comparing absolute values */ 6134 /* COMPMIN -- the 754r minnum operation */ 6135 /* COMPMINMAG -- ditto, comparing absolute values */ 6136 /* COMTOTAL -- returns the signum (as a number) giving the */ 6137 /* result of a comparison using 754r total ordering */ 6138 /* */ 6139 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 6140 /* lhs is A */ 6141 /* rhs is B */ 6142 /* set is the context */ 6143 /* op is the operation flag */ 6144 /* status is the usual accumulator */ 6145 /* */ 6146 /* C must have space for one digit for COMPARE or set->digits for */ 6147 /* COMPMAX, COMPMIN, COMPMAXMAG, or COMPMINMAG. */ 6148 /* ------------------------------------------------------------------ */ 6149 /* The emphasis here is on speed for common cases, and avoiding */ 6150 /* coefficient comparison if possible. */ 6151 /* ------------------------------------------------------------------ */ 6152 static decNumber *decCompareOp(decNumber *res, const decNumber *lhs, 6153 const decNumber *rhs, decContext *set, 6154 Flag op, uInt *status) { 6155 #if DECSUBSET 6156 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 6157 decNumber *allocrhs=NULL; /* .., rhs */ 6158 #endif 6159 Int result=0; /* default result value */ 6160 uByte merged; /* work */ 6161 6162 #if DECCHECK 6163 if (decCheckOperands(res, lhs, rhs, set)) return res; 6164 #endif 6165 6166 do { /* protect allocated storage */ 6167 #if DECSUBSET 6168 if (!set->extended) { 6169 /* reduce operands and set lostDigits status, as needed */ 6170 if (lhs->digits>set->digits) { 6171 alloclhs=decRoundOperand(lhs, set, status); 6172 if (alloclhs==NULL) {result=BADINT; break;} 6173 lhs=alloclhs; 6174 } 6175 if (rhs->digits>set->digits) { 6176 allocrhs=decRoundOperand(rhs, set, status); 6177 if (allocrhs==NULL) {result=BADINT; break;} 6178 rhs=allocrhs; 6179 } 6180 } 6181 #endif 6182 /* [following code does not require input rounding] */ 6183 6184 /* If total ordering then handle differing signs 'up front' */ 6185 if (op==COMPTOTAL) { /* total ordering */ 6186 if (decNumberIsNegative(lhs) && !decNumberIsNegative(rhs)) { 6187 result=-1; 6188 break; 6189 } 6190 if (!decNumberIsNegative(lhs) && decNumberIsNegative(rhs)) { 6191 result=+1; 6192 break; 6193 } 6194 } 6195 6196 /* handle NaNs specially; let infinities drop through */ 6197 /* This assumes sNaN (even just one) leads to NaN. */ 6198 merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN); 6199 if (merged) { /* a NaN bit set */ 6200 if (op==COMPARE); /* result will be NaN */ 6201 else if (op==COMPSIG) /* treat qNaN as sNaN */ 6202 *status|=DEC_Invalid_operation | DEC_sNaN; 6203 else if (op==COMPTOTAL) { /* total ordering, always finite */ 6204 /* signs are known to be the same; compute the ordering here */ 6205 /* as if the signs are both positive, then invert for negatives */ 6206 if (!decNumberIsNaN(lhs)) result=-1; 6207 else if (!decNumberIsNaN(rhs)) result=+1; 6208 /* here if both NaNs */ 6209 else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1; 6210 else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1; 6211 else { /* both NaN or both sNaN */ 6212 /* now it just depends on the payload */ 6213 result=decUnitCompare(lhs->lsu, D2U(lhs->digits), 6214 rhs->lsu, D2U(rhs->digits), 0); 6215 /* [Error not possible, as these are 'aligned'] */ 6216 } /* both same NaNs */ 6217 if (decNumberIsNegative(lhs)) result=-result; 6218 break; 6219 } /* total order */ 6220 6221 else if (merged & DECSNAN); /* sNaN -> qNaN */ 6222 else { /* here if MIN or MAX and one or two quiet NaNs */ 6223 /* min or max -- 754r rules ignore single NaN */ 6224 if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) { 6225 /* just one NaN; force choice to be the non-NaN operand */ 6226 op=COMPMAX; 6227 if (lhs->bits & DECNAN) result=-1; /* pick rhs */ 6228 else result=+1; /* pick lhs */ 6229 break; 6230 } 6231 } /* max or min */ 6232 op=COMPNAN; /* use special path */ 6233 decNaNs(res, lhs, rhs, set, status); /* propagate NaN */ 6234 break; 6235 } 6236 /* have numbers */ 6237 if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1); 6238 else result=decCompare(lhs, rhs, 0); /* sign matters */ 6239 } while(0); /* end protected */ 6240 6241 if (result==BADINT) *status|=DEC_Insufficient_storage; /* rare */ 6242 else { 6243 if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { /* returning signum */ 6244 if (op==COMPTOTAL && result==0) { 6245 /* operands are numerically equal or same NaN (and same sign, */ 6246 /* tested first); if identical, leave result 0 */ 6247 if (lhs->exponent!=rhs->exponent) { 6248 if (lhs->exponent<rhs->exponent) result=-1; 6249 else result=+1; 6250 if (decNumberIsNegative(lhs)) result=-result; 6251 } /* lexp!=rexp */ 6252 } /* total-order by exponent */ 6253 decNumberZero(res); /* [always a valid result] */ 6254 if (result!=0) { /* must be -1 or +1 */ 6255 *res->lsu=1; 6256 if (result<0) res->bits=DECNEG; 6257 } 6258 } 6259 else if (op==COMPNAN); /* special, drop through */ 6260 else { /* MAX or MIN, non-NaN result */ 6261 Int residue=0; /* rounding accumulator */ 6262 /* choose the operand for the result */ 6263 const decNumber *choice; 6264 if (result==0) { /* operands are numerically equal */ 6265 /* choose according to sign then exponent (see 754r) */ 6266 uByte slhs=(lhs->bits & DECNEG); 6267 uByte srhs=(rhs->bits & DECNEG); 6268 #if DECSUBSET 6269 if (!set->extended) { /* subset: force left-hand */ 6270 op=COMPMAX; 6271 result=+1; 6272 } 6273 else 6274 #endif 6275 if (slhs!=srhs) { /* signs differ */ 6276 if (slhs) result=-1; /* rhs is max */ 6277 else result=+1; /* lhs is max */ 6278 } 6279 else if (slhs && srhs) { /* both negative */ 6280 if (lhs->exponent<rhs->exponent) result=+1; 6281 else result=-1; 6282 /* [if equal, use lhs, technically identical] */ 6283 } 6284 else { /* both positive */ 6285 if (lhs->exponent>rhs->exponent) result=+1; 6286 else result=-1; 6287 /* [ditto] */ 6288 } 6289 } /* numerically equal */ 6290 /* here result will be non-0; reverse if looking for MIN */ 6291 if (op==COMPMIN || op==COMPMINMAG) result=-result; 6292 choice=(result>0 ? lhs : rhs); /* choose */ 6293 /* copy chosen to result, rounding if need be */ 6294 decCopyFit(res, choice, set, &residue, status); 6295 decFinish(res, set, &residue, status); 6296 } 6297 } 6298 #if DECSUBSET 6299 if (allocrhs!=NULL) free(allocrhs); /* free any storage used */ 6300 if (alloclhs!=NULL) free(alloclhs); /* .. */ 6301 #endif 6302 return res; 6303 } /* decCompareOp */ 6304 6305 /* ------------------------------------------------------------------ */ 6306 /* decCompare -- compare two decNumbers by numerical value */ 6307 /* */ 6308 /* This routine compares A ? B without altering them. */ 6309 /* */ 6310 /* Arg1 is A, a decNumber which is not a NaN */ 6311 /* Arg2 is B, a decNumber which is not a NaN */ 6312 /* Arg3 is 1 for a sign-independent compare, 0 otherwise */ 6313 /* */ 6314 /* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */ 6315 /* (the only possible failure is an allocation error) */ 6316 /* ------------------------------------------------------------------ */ 6317 static Int decCompare(const decNumber *lhs, const decNumber *rhs, 6318 Flag abs) { 6319 Int result; /* result value */ 6320 Int sigr; /* rhs signum */ 6321 Int compare; /* work */ 6322 6323 result=1; /* assume signum(lhs) */ 6324 if (ISZERO(lhs)) result=0; 6325 if (abs) { 6326 if (ISZERO(rhs)) return result; /* LHS wins or both 0 */ 6327 /* RHS is non-zero */ 6328 if (result==0) return -1; /* LHS is 0; RHS wins */ 6329 /* [here, both non-zero, result=1] */ 6330 } 6331 else { /* signs matter */ 6332 if (result && decNumberIsNegative(lhs)) result=-1; 6333 sigr=1; /* compute signum(rhs) */ 6334 if (ISZERO(rhs)) sigr=0; 6335 else if (decNumberIsNegative(rhs)) sigr=-1; 6336 if (result > sigr) return +1; /* L > R, return 1 */ 6337 if (result < sigr) return -1; /* L < R, return -1 */ 6338 if (result==0) return 0; /* both 0 */ 6339 } 6340 6341 /* signums are the same; both are non-zero */ 6342 if ((lhs->bits | rhs->bits) & DECINF) { /* one or more infinities */ 6343 if (decNumberIsInfinite(rhs)) { 6344 if (decNumberIsInfinite(lhs)) result=0;/* both infinite */ 6345 else result=-result; /* only rhs infinite */ 6346 } 6347 return result; 6348 } 6349 /* must compare the coefficients, allowing for exponents */ 6350 if (lhs->exponent>rhs->exponent) { /* LHS exponent larger */ 6351 /* swap sides, and sign */ 6352 const decNumber *temp=lhs; 6353 lhs=rhs; 6354 rhs=temp; 6355 result=-result; 6356 } 6357 compare=decUnitCompare(lhs->lsu, D2U(lhs->digits), 6358 rhs->lsu, D2U(rhs->digits), 6359 rhs->exponent-lhs->exponent); 6360 if (compare!=BADINT) compare*=result; /* comparison succeeded */ 6361 return compare; 6362 } /* decCompare */ 6363 6364 /* ------------------------------------------------------------------ */ 6365 /* decUnitCompare -- compare two >=0 integers in Unit arrays */ 6366 /* */ 6367 /* This routine compares A ? B*10**E where A and B are unit arrays */ 6368 /* A is a plain integer */ 6369 /* B has an exponent of E (which must be non-negative) */ 6370 /* */ 6371 /* Arg1 is A first Unit (lsu) */ 6372 /* Arg2 is A length in Units */ 6373 /* Arg3 is B first Unit (lsu) */ 6374 /* Arg4 is B length in Units */ 6375 /* Arg5 is E (0 if the units are aligned) */ 6376 /* */ 6377 /* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */ 6378 /* (the only possible failure is an allocation error, which can */ 6379 /* only occur if E!=0) */ 6380 /* ------------------------------------------------------------------ */ 6381 static Int decUnitCompare(const Unit *a, Int alength, 6382 const Unit *b, Int blength, Int exp) { 6383 Unit *acc; /* accumulator for result */ 6384 Unit accbuff[SD2U(DECBUFFER*2+1)]; /* local buffer */ 6385 Unit *allocacc=NULL; /* -> allocated acc buffer, iff allocated */ 6386 Int accunits, need; /* units in use or needed for acc */ 6387 const Unit *l, *r, *u; /* work */ 6388 Int expunits, exprem, result; /* .. */ 6389 6390 if (exp==0) { /* aligned; fastpath */ 6391 if (alength>blength) return 1; 6392 if (alength<blength) return -1; 6393 /* same number of units in both -- need unit-by-unit compare */ 6394 l=a+alength-1; 6395 r=b+alength-1; 6396 for (;l>=a; l--, r--) { 6397 if (*l>*r) return 1; 6398 if (*l<*r) return -1; 6399 } 6400 return 0; /* all units match */ 6401 } /* aligned */ 6402 6403 /* Unaligned. If one is >1 unit longer than the other, padded */ 6404 /* approximately, then can return easily */ 6405 if (alength>blength+(Int)D2U(exp)) return 1; 6406 if (alength+1<blength+(Int)D2U(exp)) return -1; 6407 6408 /* Need to do a real subtract. For this, a result buffer is needed */ 6409 /* even though only the sign is of interest. Its length needs */ 6410 /* to be the larger of alength and padded blength, +2 */ 6411 need=blength+D2U(exp); /* maximum real length of B */ 6412 if (need<alength) need=alength; 6413 need+=2; 6414 acc=accbuff; /* assume use local buffer */ 6415 if (need*sizeof(Unit)>sizeof(accbuff)) { 6416 allocacc=(Unit *)malloc(need*sizeof(Unit)); 6417 if (allocacc==NULL) return BADINT; /* hopeless -- abandon */ 6418 acc=allocacc; 6419 } 6420 /* Calculate units and remainder from exponent. */ 6421 expunits=exp/DECDPUN; 6422 exprem=exp%DECDPUN; 6423 /* subtract [A+B*(-m)] */ 6424 accunits=decUnitAddSub(a, alength, b, blength, expunits, acc, 6425 -(Int)powers[exprem]); 6426 /* [UnitAddSub result may have leading zeros, even on zero] */ 6427 if (accunits<0) result=-1; /* negative result */ 6428 else { /* non-negative result */ 6429 /* check units of the result before freeing any storage */ 6430 for (u=acc; u<acc+accunits-1 && *u==0;) u++; 6431 result=(*u==0 ? 0 : +1); 6432 } 6433 /* clean up and return the result */ 6434 if (allocacc!=NULL) free(allocacc); /* drop any storage used */ 6435 return result; 6436 } /* decUnitCompare */ 6437 6438 /* ------------------------------------------------------------------ */ 6439 /* decUnitAddSub -- add or subtract two >=0 integers in Unit arrays */ 6440 /* */ 6441 /* This routine performs the calculation: */ 6442 /* */ 6443 /* C=A+(B*M) */ 6444 /* */ 6445 /* Where M is in the range -DECDPUNMAX through +DECDPUNMAX. */ 6446 /* */ 6447 /* A may be shorter or longer than B. */ 6448 /* */ 6449 /* Leading zeros are not removed after a calculation. The result is */ 6450 /* either the same length as the longer of A and B (adding any */ 6451 /* shift), or one Unit longer than that (if a Unit carry occurred). */ 6452 /* */ 6453 /* A and B content are not altered unless C is also A or B. */ 6454 /* C may be the same array as A or B, but only if no zero padding is */ 6455 /* requested (that is, C may be B only if bshift==0). */ 6456 /* C is filled from the lsu; only those units necessary to complete */ 6457 /* the calculation are referenced. */ 6458 /* */ 6459 /* Arg1 is A first Unit (lsu) */ 6460 /* Arg2 is A length in Units */ 6461 /* Arg3 is B first Unit (lsu) */ 6462 /* Arg4 is B length in Units */ 6463 /* Arg5 is B shift in Units (>=0; pads with 0 units if positive) */ 6464 /* Arg6 is C first Unit (lsu) */ 6465 /* Arg7 is M, the multiplier */ 6466 /* */ 6467 /* returns the count of Units written to C, which will be non-zero */ 6468 /* and negated if the result is negative. That is, the sign of the */ 6469 /* returned Int is the sign of the result (positive for zero) and */ 6470 /* the absolute value of the Int is the count of Units. */ 6471 /* */ 6472 /* It is the caller's responsibility to make sure that C size is */ 6473 /* safe, allowing space if necessary for a one-Unit carry. */ 6474 /* */ 6475 /* This routine is severely performance-critical; *any* change here */ 6476 /* must be measured (timed) to assure no performance degradation. */ 6477 /* In particular, trickery here tends to be counter-productive, as */ 6478 /* increased complexity of code hurts register optimizations on */ 6479 /* register-poor architectures. Avoiding divisions is nearly */ 6480 /* always a Good Idea, however. */ 6481 /* */ 6482 /* Special thanks to Rick McGuire (IBM Cambridge, MA) and Dave Clark */ 6483 /* (IBM Warwick, UK) for some of the ideas used in this routine. */ 6484 /* ------------------------------------------------------------------ */ 6485 static Int decUnitAddSub(const Unit *a, Int alength, 6486 const Unit *b, Int blength, Int bshift, 6487 Unit *c, Int m) { 6488 const Unit *alsu=a; /* A lsu [need to remember it] */ 6489 Unit *clsu=c; /* C ditto */ 6490 Unit *minC; /* low water mark for C */ 6491 Unit *maxC; /* high water mark for C */ 6492 eInt carry=0; /* carry integer (could be Long) */ 6493 Int add; /* work */ 6494 #if DECDPUN<=4 /* myriadal, millenary, etc. */ 6495 Int est; /* estimated quotient */ 6496 #endif 6497 6498 #if DECTRACE 6499 if (alength<1 || blength<1) 6500 printf("decUnitAddSub: alen blen m %ld %ld [%ld]\n", alength, blength, m); 6501 #endif 6502 6503 maxC=c+alength; /* A is usually the longer */ 6504 minC=c+blength; /* .. and B the shorter */ 6505 if (bshift!=0) { /* B is shifted; low As copy across */ 6506 minC+=bshift; 6507 /* if in place [common], skip copy unless there's a gap [rare] */ 6508 if (a==c && bshift<=alength) { 6509 c+=bshift; 6510 a+=bshift; 6511 } 6512 else for (; c<clsu+bshift; a++, c++) { /* copy needed */ 6513 if (a<alsu+alength) *c=*a; 6514 else *c=0; 6515 } 6516 } 6517 if (minC>maxC) { /* swap */ 6518 Unit *hold=minC; 6519 minC=maxC; 6520 maxC=hold; 6521 } 6522 6523 /* For speed, do the addition as two loops; the first where both A */ 6524 /* and B contribute, and the second (if necessary) where only one or */ 6525 /* other of the numbers contribute. */ 6526 /* Carry handling is the same (i.e., duplicated) in each case. */ 6527 for (; c<minC; c++) { 6528 carry+=*a; 6529 a++; 6530 carry+=((eInt)*b)*m; /* [special-casing m=1/-1 */ 6531 b++; /* here is not a win] */ 6532 /* here carry is new Unit of digits; it could be +ve or -ve */ 6533 if ((ueInt)carry<=DECDPUNMAX) { /* fastpath 0-DECDPUNMAX */ 6534 *c=(Unit)carry; 6535 carry=0; 6536 continue; 6537 } 6538 #if DECDPUN==4 /* use divide-by-multiply */ 6539 if (carry>=0) { 6540 est=(((ueInt)carry>>11)*53687)>>18; 6541 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6542 carry=est; /* likely quotient [89%] */ 6543 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */ 6544 carry++; 6545 *c-=DECDPUNMAX+1; 6546 continue; 6547 } 6548 /* negative case */ 6549 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6550 est=(((ueInt)carry>>11)*53687)>>18; 6551 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6552 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6553 if (*c<DECDPUNMAX+1) continue; /* was OK */ 6554 carry++; 6555 *c-=DECDPUNMAX+1; 6556 #elif DECDPUN==3 6557 if (carry>=0) { 6558 est=(((ueInt)carry>>3)*16777)>>21; 6559 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6560 carry=est; /* likely quotient [99%] */ 6561 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */ 6562 carry++; 6563 *c-=DECDPUNMAX+1; 6564 continue; 6565 } 6566 /* negative case */ 6567 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6568 est=(((ueInt)carry>>3)*16777)>>21; 6569 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6570 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6571 if (*c<DECDPUNMAX+1) continue; /* was OK */ 6572 carry++; 6573 *c-=DECDPUNMAX+1; 6574 #elif DECDPUN<=2 6575 /* Can use QUOT10 as carry <= 4 digits */ 6576 if (carry>=0) { 6577 est=QUOT10(carry, DECDPUN); 6578 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6579 carry=est; /* quotient */ 6580 continue; 6581 } 6582 /* negative case */ 6583 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6584 est=QUOT10(carry, DECDPUN); 6585 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6586 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6587 #else 6588 /* remainder operator is undefined if negative, so must test */ 6589 if ((ueInt)carry<(DECDPUNMAX+1)*2) { /* fastpath carry +1 */ 6590 *c=(Unit)(carry-(DECDPUNMAX+1)); /* [helps additions] */ 6591 carry=1; 6592 continue; 6593 } 6594 if (carry>=0) { 6595 *c=(Unit)(carry%(DECDPUNMAX+1)); 6596 carry=carry/(DECDPUNMAX+1); 6597 continue; 6598 } 6599 /* negative case */ 6600 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6601 *c=(Unit)(carry%(DECDPUNMAX+1)); 6602 carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1); 6603 #endif 6604 } /* c */ 6605 6606 /* now may have one or other to complete */ 6607 /* [pretest to avoid loop setup/shutdown] */ 6608 if (c<maxC) for (; c<maxC; c++) { 6609 if (a<alsu+alength) { /* still in A */ 6610 carry+=*a; 6611 a++; 6612 } 6613 else { /* inside B */ 6614 carry+=((eInt)*b)*m; 6615 b++; 6616 } 6617 /* here carry is new Unit of digits; it could be +ve or -ve and */ 6618 /* magnitude up to DECDPUNMAX squared */ 6619 if ((ueInt)carry<=DECDPUNMAX) { /* fastpath 0-DECDPUNMAX */ 6620 *c=(Unit)carry; 6621 carry=0; 6622 continue; 6623 } 6624 /* result for this unit is negative or >DECDPUNMAX */ 6625 #if DECDPUN==4 /* use divide-by-multiply */ 6626 if (carry>=0) { 6627 est=(((ueInt)carry>>11)*53687)>>18; 6628 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6629 carry=est; /* likely quotient [79.7%] */ 6630 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */ 6631 carry++; 6632 *c-=DECDPUNMAX+1; 6633 continue; 6634 } 6635 /* negative case */ 6636 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6637 est=(((ueInt)carry>>11)*53687)>>18; 6638 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6639 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6640 if (*c<DECDPUNMAX+1) continue; /* was OK */ 6641 carry++; 6642 *c-=DECDPUNMAX+1; 6643 #elif DECDPUN==3 6644 if (carry>=0) { 6645 est=(((ueInt)carry>>3)*16777)>>21; 6646 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6647 carry=est; /* likely quotient [99%] */ 6648 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */ 6649 carry++; 6650 *c-=DECDPUNMAX+1; 6651 continue; 6652 } 6653 /* negative case */ 6654 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6655 est=(((ueInt)carry>>3)*16777)>>21; 6656 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6657 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6658 if (*c<DECDPUNMAX+1) continue; /* was OK */ 6659 carry++; 6660 *c-=DECDPUNMAX+1; 6661 #elif DECDPUN<=2 6662 if (carry>=0) { 6663 est=QUOT10(carry, DECDPUN); 6664 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6665 carry=est; /* quotient */ 6666 continue; 6667 } 6668 /* negative case */ 6669 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6670 est=QUOT10(carry, DECDPUN); 6671 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6672 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6673 #else 6674 if ((ueInt)carry<(DECDPUNMAX+1)*2){ /* fastpath carry 1 */ 6675 *c=(Unit)(carry-(DECDPUNMAX+1)); 6676 carry=1; 6677 continue; 6678 } 6679 /* remainder operator is undefined if negative, so must test */ 6680 if (carry>=0) { 6681 *c=(Unit)(carry%(DECDPUNMAX+1)); 6682 carry=carry/(DECDPUNMAX+1); 6683 continue; 6684 } 6685 /* negative case */ 6686 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6687 *c=(Unit)(carry%(DECDPUNMAX+1)); 6688 carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1); 6689 #endif 6690 } /* c */ 6691 6692 /* OK, all A and B processed; might still have carry or borrow */ 6693 /* return number of Units in the result, negated if a borrow */ 6694 if (carry==0) return c-clsu; /* no carry, so no more to do */ 6695 if (carry>0) { /* positive carry */ 6696 *c=(Unit)carry; /* place as new unit */ 6697 c++; /* .. */ 6698 return c-clsu; 6699 } 6700 /* -ve carry: it's a borrow; complement needed */ 6701 add=1; /* temporary carry... */ 6702 for (c=clsu; c<maxC; c++) { 6703 add=DECDPUNMAX+add-*c; 6704 if (add<=DECDPUNMAX) { 6705 *c=(Unit)add; 6706 add=0; 6707 } 6708 else { 6709 *c=0; 6710 add=1; 6711 } 6712 } 6713 /* add an extra unit iff it would be non-zero */ 6714 #if DECTRACE 6715 printf("UAS borrow: add %ld, carry %ld\n", add, carry); 6716 #endif 6717 if ((add-carry-1)!=0) { 6718 *c=(Unit)(add-carry-1); 6719 c++; /* interesting, include it */ 6720 } 6721 return clsu-c; /* -ve result indicates borrowed */ 6722 } /* decUnitAddSub */ 6723 6724 /* ------------------------------------------------------------------ */ 6725 /* decTrim -- trim trailing zeros or normalize */ 6726 /* */ 6727 /* dn is the number to trim or normalize */ 6728 /* set is the context to use to check for clamp */ 6729 /* all is 1 to remove all trailing zeros, 0 for just fraction ones */ 6730 /* dropped returns the number of discarded trailing zeros */ 6731 /* returns dn */ 6732 /* */ 6733 /* If clamp is set in the context then the number of zeros trimmed */ 6734 /* may be limited if the exponent is high. */ 6735 /* All fields are updated as required. This is a utility operation, */ 6736 /* so special values are unchanged and no error is possible. */ 6737 /* ------------------------------------------------------------------ */ 6738 static decNumber * decTrim(decNumber *dn, decContext *set, Flag all, 6739 Int *dropped) { 6740 Int d, exp; /* work */ 6741 uInt cut; /* .. */ 6742 Unit *up; /* -> current Unit */ 6743 6744 #if DECCHECK 6745 if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn; 6746 #endif 6747 6748 *dropped=0; /* assume no zeros dropped */ 6749 if ((dn->bits & DECSPECIAL) /* fast exit if special .. */ 6750 || (*dn->lsu & 0x01)) return dn; /* .. or odd */ 6751 if (ISZERO(dn)) { /* .. or 0 */ 6752 dn->exponent=0; /* (sign is preserved) */ 6753 return dn; 6754 } 6755 6756 /* have a finite number which is even */ 6757 exp=dn->exponent; 6758 cut=1; /* digit (1-DECDPUN) in Unit */ 6759 up=dn->lsu; /* -> current Unit */ 6760 for (d=0; d<dn->digits-1; d++) { /* [don't strip the final digit] */ 6761 /* slice by powers */ 6762 #if DECDPUN<=4 6763 uInt quot=QUOT10(*up, cut); 6764 if ((*up-quot*powers[cut])!=0) break; /* found non-0 digit */ 6765 #else 6766 if (*up%powers[cut]!=0) break; /* found non-0 digit */ 6767 #endif 6768 /* have a trailing 0 */ 6769 if (!all) { /* trimming */ 6770 /* [if exp>0 then all trailing 0s are significant for trim] */ 6771 if (exp<=0) { /* if digit might be significant */ 6772 if (exp==0) break; /* then quit */ 6773 exp++; /* next digit might be significant */ 6774 } 6775 } 6776 cut++; /* next power */ 6777 if (cut>DECDPUN) { /* need new Unit */ 6778 up++; 6779 cut=1; 6780 } 6781 } /* d */ 6782 if (d==0) return dn; /* none to drop */ 6783 6784 /* may need to limit drop if clamping */ 6785 if (set->clamp) { 6786 Int maxd=set->emax-set->digits+1-dn->exponent; 6787 if (maxd<=0) return dn; /* nothing possible */ 6788 if (d>maxd) d=maxd; 6789 } 6790 6791 /* effect the drop */ 6792 decShiftToLeast(dn->lsu, D2U(dn->digits), d); 6793 dn->exponent+=d; /* maintain numerical value */ 6794 dn->digits-=d; /* new length */ 6795 *dropped=d; /* report the count */ 6796 return dn; 6797 } /* decTrim */ 6798 6799 /* ------------------------------------------------------------------ */ 6800 /* decReverse -- reverse a Unit array in place */ 6801 /* */ 6802 /* ulo is the start of the array */ 6803 /* uhi is the end of the array (highest Unit to include) */ 6804 /* */ 6805 /* The units ulo through uhi are reversed in place (if the number */ 6806 /* of units is odd, the middle one is untouched). Note that the */ 6807 /* digit(s) in each unit are unaffected. */ 6808 /* ------------------------------------------------------------------ */ 6809 static void decReverse(Unit *ulo, Unit *uhi) { 6810 Unit temp; 6811 for (; ulo<uhi; ulo++, uhi--) { 6812 temp=*ulo; 6813 *ulo=*uhi; 6814 *uhi=temp; 6815 } 6816 return; 6817 } /* decReverse */ 6818 6819 /* ------------------------------------------------------------------ */ 6820 /* decShiftToMost -- shift digits in array towards most significant */ 6821 /* */ 6822 /* uar is the array */ 6823 /* digits is the count of digits in use in the array */ 6824 /* shift is the number of zeros to pad with (least significant); */ 6825 /* it must be zero or positive */ 6826 /* */ 6827 /* returns the new length of the integer in the array, in digits */ 6828 /* */ 6829 /* No overflow is permitted (that is, the uar array must be known to */ 6830 /* be large enough to hold the result, after shifting). */ 6831 /* ------------------------------------------------------------------ */ 6832 static Int decShiftToMost(Unit *uar, Int digits, Int shift) { 6833 Unit *target, *source, *first; /* work */ 6834 Int cut; /* odd 0's to add */ 6835 uInt next; /* work */ 6836 6837 if (shift==0) return digits; /* [fastpath] nothing to do */ 6838 if ((digits+shift)<=DECDPUN) { /* [fastpath] single-unit case */ 6839 *uar=(Unit)(*uar*powers[shift]); 6840 return digits+shift; 6841 } 6842 6843 next=0; /* all paths */ 6844 source=uar+D2U(digits)-1; /* where msu comes from */ 6845 target=source+D2U(shift); /* where upper part of first cut goes */ 6846 cut=DECDPUN-MSUDIGITS(shift); /* where to slice */ 6847 if (cut==0) { /* unit-boundary case */ 6848 for (; source>=uar; source--, target--) *target=*source; 6849 } 6850 else { 6851 first=uar+D2U(digits+shift)-1; /* where msu of source will end up */ 6852 for (; source>=uar; source--, target--) { 6853 /* split the source Unit and accumulate remainder for next */ 6854 #if DECDPUN<=4 6855 uInt quot=QUOT10(*source, cut); 6856 uInt rem=*source-quot*powers[cut]; 6857 next+=quot; 6858 #else 6859 uInt rem=*source%powers[cut]; 6860 next+=*source/powers[cut]; 6861 #endif 6862 if (target<=first) *target=(Unit)next; /* write to target iff valid */ 6863 next=rem*powers[DECDPUN-cut]; /* save remainder for next Unit */ 6864 } 6865 } /* shift-move */ 6866 6867 /* propagate any partial unit to one below and clear the rest */ 6868 for (; target>=uar; target--) { 6869 *target=(Unit)next; 6870 next=0; 6871 } 6872 return digits+shift; 6873 } /* decShiftToMost */ 6874 6875 /* ------------------------------------------------------------------ */ 6876 /* decShiftToLeast -- shift digits in array towards least significant */ 6877 /* */ 6878 /* uar is the array */ 6879 /* units is length of the array, in units */ 6880 /* shift is the number of digits to remove from the lsu end; it */ 6881 /* must be zero or positive and <= than units*DECDPUN. */ 6882 /* */ 6883 /* returns the new length of the integer in the array, in units */ 6884 /* */ 6885 /* Removed digits are discarded (lost). Units not required to hold */ 6886 /* the final result are unchanged. */ 6887 /* ------------------------------------------------------------------ */ 6888 static Int decShiftToLeast(Unit *uar, Int units, Int shift) { 6889 Unit *target, *up; /* work */ 6890 Int cut, count; /* work */ 6891 Int quot, rem; /* for division */ 6892 6893 if (shift==0) return units; /* [fastpath] nothing to do */ 6894 if (shift==units*DECDPUN) { /* [fastpath] little to do */ 6895 *uar=0; /* all digits cleared gives zero */ 6896 return 1; /* leaves just the one */ 6897 } 6898 6899 target=uar; /* both paths */ 6900 cut=MSUDIGITS(shift); 6901 if (cut==DECDPUN) { /* unit-boundary case; easy */ 6902 up=uar+D2U(shift); 6903 for (; up<uar+units; target++, up++) *target=*up; 6904 return target-uar; 6905 } 6906 6907 /* messier */ 6908 up=uar+D2U(shift-cut); /* source; correct to whole Units */ 6909 count=units*DECDPUN-shift; /* the maximum new length */ 6910 #if DECDPUN<=4 6911 quot=QUOT10(*up, cut); 6912 #else 6913 quot=*up/powers[cut]; 6914 #endif 6915 for (; ; target++) { 6916 *target=(Unit)quot; 6917 count-=(DECDPUN-cut); 6918 if (count<=0) break; 6919 up++; 6920 quot=*up; 6921 #if DECDPUN<=4 6922 quot=QUOT10(quot, cut); 6923 rem=*up-quot*powers[cut]; 6924 #else 6925 rem=quot%powers[cut]; 6926 quot=quot/powers[cut]; 6927 #endif 6928 *target=(Unit)(*target+rem*powers[DECDPUN-cut]); 6929 count-=cut; 6930 if (count<=0) break; 6931 } 6932 return target-uar+1; 6933 } /* decShiftToLeast */ 6934 6935 #if DECSUBSET 6936 /* ------------------------------------------------------------------ */ 6937 /* decRoundOperand -- round an operand [used for subset only] */ 6938 /* */ 6939 /* dn is the number to round (dn->digits is > set->digits) */ 6940 /* set is the relevant context */ 6941 /* status is the status accumulator */ 6942 /* */ 6943 /* returns an allocated decNumber with the rounded result. */ 6944 /* */ 6945 /* lostDigits and other status may be set by this. */ 6946 /* */ 6947 /* Since the input is an operand, it must not be modified. */ 6948 /* Instead, return an allocated decNumber, rounded as required. */ 6949 /* It is the caller's responsibility to free the allocated storage. */ 6950 /* */ 6951 /* If no storage is available then the result cannot be used, so NULL */ 6952 /* is returned. */ 6953 /* ------------------------------------------------------------------ */ 6954 static decNumber *decRoundOperand(const decNumber *dn, decContext *set, 6955 uInt *status) { 6956 decNumber *res; /* result structure */ 6957 uInt newstatus=0; /* status from round */ 6958 Int residue=0; /* rounding accumulator */ 6959 6960 /* Allocate storage for the returned decNumber, big enough for the */ 6961 /* length specified by the context */ 6962 res=(decNumber *)malloc(sizeof(decNumber) 6963 +(D2U(set->digits)-1)*sizeof(Unit)); 6964 if (res==NULL) { 6965 *status|=DEC_Insufficient_storage; 6966 return NULL; 6967 } 6968 decCopyFit(res, dn, set, &residue, &newstatus); 6969 decApplyRound(res, set, residue, &newstatus); 6970 6971 /* If that set Inexact then "lost digits" is raised... */ 6972 if (newstatus & DEC_Inexact) newstatus|=DEC_Lost_digits; 6973 *status|=newstatus; 6974 return res; 6975 } /* decRoundOperand */ 6976 #endif 6977 6978 /* ------------------------------------------------------------------ */ 6979 /* decCopyFit -- copy a number, truncating the coefficient if needed */ 6980 /* */ 6981 /* dest is the target decNumber */ 6982 /* src is the source decNumber */ 6983 /* set is the context [used for length (digits) and rounding mode] */ 6984 /* residue is the residue accumulator */ 6985 /* status contains the current status to be updated */ 6986 /* */ 6987 /* (dest==src is allowed and will be a no-op if fits) */ 6988 /* All fields are updated as required. */ 6989 /* ------------------------------------------------------------------ */ 6990 static void decCopyFit(decNumber *dest, const decNumber *src, 6991 decContext *set, Int *residue, uInt *status) { 6992 dest->bits=src->bits; 6993 dest->exponent=src->exponent; 6994 decSetCoeff(dest, set, src->lsu, src->digits, residue, status); 6995 } /* decCopyFit */ 6996 6997 /* ------------------------------------------------------------------ */ 6998 /* decSetCoeff -- set the coefficient of a number */ 6999 /* */ 7000 /* dn is the number whose coefficient array is to be set. */ 7001 /* It must have space for set->digits digits */ 7002 /* set is the context [for size] */ 7003 /* lsu -> lsu of the source coefficient [may be dn->lsu] */ 7004 /* len is digits in the source coefficient [may be dn->digits] */ 7005 /* residue is the residue accumulator. This has values as in */ 7006 /* decApplyRound, and will be unchanged unless the */ 7007 /* target size is less than len. In this case, the */ 7008 /* coefficient is truncated and the residue is updated to */ 7009 /* reflect the previous residue and the dropped digits. */ 7010 /* status is the status accumulator, as usual */ 7011 /* */ 7012 /* The coefficient may already be in the number, or it can be an */ 7013 /* external intermediate array. If it is in the number, lsu must == */ 7014 /* dn->lsu and len must == dn->digits. */ 7015 /* */ 7016 /* Note that the coefficient length (len) may be < set->digits, and */ 7017 /* in this case this merely copies the coefficient (or is a no-op */ 7018 /* if dn->lsu==lsu). */ 7019 /* */ 7020 /* Note also that (only internally, from decQuantizeOp and */ 7021 /* decSetSubnormal) the value of set->digits may be less than one, */ 7022 /* indicating a round to left. This routine handles that case */ 7023 /* correctly; caller ensures space. */ 7024 /* */ 7025 /* dn->digits, dn->lsu (and as required), and dn->exponent are */ 7026 /* updated as necessary. dn->bits (sign) is unchanged. */ 7027 /* */ 7028 /* DEC_Rounded status is set if any digits are discarded. */ 7029 /* DEC_Inexact status is set if any non-zero digits are discarded, or */ 7030 /* incoming residue was non-0 (implies rounded) */ 7031 /* ------------------------------------------------------------------ */ 7032 /* mapping array: maps 0-9 to canonical residues, so that a residue */ 7033 /* can be adjusted in the range [-1, +1] and achieve correct rounding */ 7034 /* 0 1 2 3 4 5 6 7 8 9 */ 7035 static const uByte resmap[10]={0, 3, 3, 3, 3, 5, 7, 7, 7, 7}; 7036 static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu, 7037 Int len, Int *residue, uInt *status) { 7038 Int discard; /* number of digits to discard */ 7039 uInt cut; /* cut point in Unit */ 7040 const Unit *up; /* work */ 7041 Unit *target; /* .. */ 7042 Int count; /* .. */ 7043 #if DECDPUN<=4 7044 uInt temp; /* .. */ 7045 #endif 7046 7047 discard=len-set->digits; /* digits to discard */ 7048 if (discard<=0) { /* no digits are being discarded */ 7049 if (dn->lsu!=lsu) { /* copy needed */ 7050 /* copy the coefficient array to the result number; no shift needed */ 7051 count=len; /* avoids D2U */ 7052 up=lsu; 7053 for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN) 7054 *target=*up; 7055 dn->digits=len; /* set the new length */ 7056 } 7057 /* dn->exponent and residue are unchanged, record any inexactitude */ 7058 if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded); 7059 return; 7060 } 7061 7062 /* some digits must be discarded ... */ 7063 dn->exponent+=discard; /* maintain numerical value */ 7064 *status|=DEC_Rounded; /* accumulate Rounded status */ 7065 if (*residue>1) *residue=1; /* previous residue now to right, so reduce */ 7066 7067 if (discard>len) { /* everything, +1, is being discarded */ 7068 /* guard digit is 0 */ 7069 /* residue is all the number [NB could be all 0s] */ 7070 if (*residue<=0) { /* not already positive */ 7071 count=len; /* avoids D2U */ 7072 for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { /* found non-0 */ 7073 *residue=1; 7074 break; /* no need to check any others */ 7075 } 7076 } 7077 if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */ 7078 *dn->lsu=0; /* coefficient will now be 0 */ 7079 dn->digits=1; /* .. */ 7080 return; 7081 } /* total discard */ 7082 7083 /* partial discard [most common case] */ 7084 /* here, at least the first (most significant) discarded digit exists */ 7085 7086 /* spin up the number, noting residue during the spin, until get to */ 7087 /* the Unit with the first discarded digit. When reach it, extract */ 7088 /* it and remember its position */ 7089 count=0; 7090 for (up=lsu;; up++) { 7091 count+=DECDPUN; 7092 if (count>=discard) break; /* full ones all checked */ 7093 if (*up!=0) *residue=1; 7094 } /* up */ 7095 7096 /* here up -> Unit with first discarded digit */ 7097 cut=discard-(count-DECDPUN)-1; 7098 if (cut==DECDPUN-1) { /* unit-boundary case (fast) */ 7099 Unit half=(Unit)powers[DECDPUN]>>1; 7100 /* set residue directly */ 7101 if (*up>=half) { 7102 if (*up>half) *residue=7; 7103 else *residue+=5; /* add sticky bit */ 7104 } 7105 else { /* <half */ 7106 if (*up!=0) *residue=3; /* [else is 0, leave as sticky bit] */ 7107 } 7108 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */ 7109 *dn->lsu=0; /* .. result is 0 */ 7110 dn->digits=1; /* .. */ 7111 } 7112 else { /* shift to least */ 7113 count=set->digits; /* now digits to end up with */ 7114 dn->digits=count; /* set the new length */ 7115 up++; /* move to next */ 7116 /* on unit boundary, so shift-down copy loop is simple */ 7117 for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN) 7118 *target=*up; 7119 } 7120 } /* unit-boundary case */ 7121 7122 else { /* discard digit is in low digit(s), and not top digit */ 7123 uInt discard1; /* first discarded digit */ 7124 uInt quot, rem; /* for divisions */ 7125 if (cut==0) quot=*up; /* is at bottom of unit */ 7126 else /* cut>0 */ { /* it's not at bottom of unit */ 7127 #if DECDPUN<=4 7128 quot=QUOT10(*up, cut); 7129 rem=*up-quot*powers[cut]; 7130 #else 7131 rem=*up%powers[cut]; 7132 quot=*up/powers[cut]; 7133 #endif 7134 if (rem!=0) *residue=1; 7135 } 7136 /* discard digit is now at bottom of quot */ 7137 #if DECDPUN<=4 7138 temp=(quot*6554)>>16; /* fast /10 */ 7139 /* Vowels algorithm here not a win (9 instructions) */ 7140 discard1=quot-X10(temp); 7141 quot=temp; 7142 #else 7143 discard1=quot%10; 7144 quot=quot/10; 7145 #endif 7146 /* here, discard1 is the guard digit, and residue is everything */ 7147 /* else [use mapping array to accumulate residue safely] */ 7148 *residue+=resmap[discard1]; 7149 cut++; /* update cut */ 7150 /* here: up -> Unit of the array with bottom digit */ 7151 /* cut is the division point for each Unit */ 7152 /* quot holds the uncut high-order digits for the current unit */ 7153 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */ 7154 *dn->lsu=0; /* .. result is 0 */ 7155 dn->digits=1; /* .. */ 7156 } 7157 else { /* shift to least needed */ 7158 count=set->digits; /* now digits to end up with */ 7159 dn->digits=count; /* set the new length */ 7160 /* shift-copy the coefficient array to the result number */ 7161 for (target=dn->lsu; ; target++) { 7162 *target=(Unit)quot; 7163 count-=(DECDPUN-cut); 7164 if (count<=0) break; 7165 up++; 7166 quot=*up; 7167 #if DECDPUN<=4 7168 quot=QUOT10(quot, cut); 7169 rem=*up-quot*powers[cut]; 7170 #else 7171 rem=quot%powers[cut]; 7172 quot=quot/powers[cut]; 7173 #endif 7174 *target=(Unit)(*target+rem*powers[DECDPUN-cut]); 7175 count-=cut; 7176 if (count<=0) break; 7177 } /* shift-copy loop */ 7178 } /* shift to least */ 7179 } /* not unit boundary */ 7180 7181 if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */ 7182 return; 7183 } /* decSetCoeff */ 7184 7185 /* ------------------------------------------------------------------ */ 7186 /* decApplyRound -- apply pending rounding to a number */ 7187 /* */ 7188 /* dn is the number, with space for set->digits digits */ 7189 /* set is the context [for size and rounding mode] */ 7190 /* residue indicates pending rounding, being any accumulated */ 7191 /* guard and sticky information. It may be: */ 7192 /* 6-9: rounding digit is >5 */ 7193 /* 5: rounding digit is exactly half-way */ 7194 /* 1-4: rounding digit is <5 and >0 */ 7195 /* 0: the coefficient is exact */ 7196 /* -1: as 1, but the hidden digits are subtractive, that */ 7197 /* is, of the opposite sign to dn. In this case the */ 7198 /* coefficient must be non-0. This case occurs when */ 7199 /* subtracting a small number (which can be reduced to */ 7200 /* a sticky bit); see decAddOp. */ 7201 /* status is the status accumulator, as usual */ 7202 /* */ 7203 /* This routine applies rounding while keeping the length of the */ 7204 /* coefficient constant. The exponent and status are unchanged */ 7205 /* except if: */ 7206 /* */ 7207 /* -- the coefficient was increased and is all nines (in which */ 7208 /* case Overflow could occur, and is handled directly here so */ 7209 /* the caller does not need to re-test for overflow) */ 7210 /* */ 7211 /* -- the coefficient was decreased and becomes all nines (in which */ 7212 /* case Underflow could occur, and is also handled directly). */ 7213 /* */ 7214 /* All fields in dn are updated as required. */ 7215 /* */ 7216 /* ------------------------------------------------------------------ */ 7217 static void decApplyRound(decNumber *dn, decContext *set, Int residue, 7218 uInt *status) { 7219 Int bump; /* 1 if coefficient needs to be incremented */ 7220 /* -1 if coefficient needs to be decremented */ 7221 7222 if (residue==0) return; /* nothing to apply */ 7223 7224 bump=0; /* assume a smooth ride */ 7225 7226 /* now decide whether, and how, to round, depending on mode */ 7227 switch (set->round) { 7228 case DEC_ROUND_05UP: { /* round zero or five up (for reround) */ 7229 /* This is the same as DEC_ROUND_DOWN unless there is a */ 7230 /* positive residue and the lsd of dn is 0 or 5, in which case */ 7231 /* it is bumped; when residue is <0, the number is therefore */ 7232 /* bumped down unless the final digit was 1 or 6 (in which */ 7233 /* case it is bumped down and then up -- a no-op) */ 7234 Int lsd5=*dn->lsu%5; /* get lsd and quintate */ 7235 if (residue<0 && lsd5!=1) bump=-1; 7236 else if (residue>0 && lsd5==0) bump=1; 7237 /* [bump==1 could be applied directly; use common path for clarity] */ 7238 break;} /* r-05 */ 7239 7240 case DEC_ROUND_DOWN: { 7241 /* no change, except if negative residue */ 7242 if (residue<0) bump=-1; 7243 break;} /* r-d */ 7244 7245 case DEC_ROUND_HALF_DOWN: { 7246 if (residue>5) bump=1; 7247 break;} /* r-h-d */ 7248 7249 case DEC_ROUND_HALF_EVEN: { 7250 if (residue>5) bump=1; /* >0.5 goes up */ 7251 else if (residue==5) { /* exactly 0.5000... */ 7252 /* 0.5 goes up iff [new] lsd is odd */ 7253 if (*dn->lsu & 0x01) bump=1; 7254 } 7255 break;} /* r-h-e */ 7256 7257 case DEC_ROUND_HALF_UP: { 7258 if (residue>=5) bump=1; 7259 break;} /* r-h-u */ 7260 7261 case DEC_ROUND_UP: { 7262 if (residue>0) bump=1; 7263 break;} /* r-u */ 7264 7265 case DEC_ROUND_CEILING: { 7266 /* same as _UP for positive numbers, and as _DOWN for negatives */ 7267 /* [negative residue cannot occur on 0] */ 7268 if (decNumberIsNegative(dn)) { 7269 if (residue<0) bump=-1; 7270 } 7271 else { 7272 if (residue>0) bump=1; 7273 } 7274 break;} /* r-c */ 7275 7276 case DEC_ROUND_FLOOR: { 7277 /* same as _UP for negative numbers, and as _DOWN for positive */ 7278 /* [negative residue cannot occur on 0] */ 7279 if (!decNumberIsNegative(dn)) { 7280 if (residue<0) bump=-1; 7281 } 7282 else { 7283 if (residue>0) bump=1; 7284 } 7285 break;} /* r-f */ 7286 7287 default: { /* e.g., DEC_ROUND_MAX */ 7288 *status|=DEC_Invalid_context; 7289 #if DECTRACE || (DECCHECK && DECVERB) 7290 printf("Unknown rounding mode: %d\n", set->round); 7291 #endif 7292 break;} 7293 } /* switch */ 7294 7295 /* now bump the number, up or down, if need be */ 7296 if (bump==0) return; /* no action required */ 7297 7298 /* Simply use decUnitAddSub unless bumping up and the number is */ 7299 /* all nines. In this special case set to 100... explicitly */ 7300 /* and adjust the exponent by one (as otherwise could overflow */ 7301 /* the array) */ 7302 /* Similarly handle all-nines result if bumping down. */ 7303 if (bump>0) { 7304 Unit *up; /* work */ 7305 uInt count=dn->digits; /* digits to be checked */ 7306 for (up=dn->lsu; ; up++) { 7307 if (count<=DECDPUN) { 7308 /* this is the last Unit (the msu) */ 7309 if (*up!=powers[count]-1) break; /* not still 9s */ 7310 /* here if it, too, is all nines */ 7311 *up=(Unit)powers[count-1]; /* here 999 -> 100 etc. */ 7312 for (up=up-1; up>=dn->lsu; up--) *up=0; /* others all to 0 */ 7313 dn->exponent++; /* and bump exponent */ 7314 /* [which, very rarely, could cause Overflow...] */ 7315 if ((dn->exponent+dn->digits)>set->emax+1) { 7316 decSetOverflow(dn, set, status); 7317 } 7318 return; /* done */ 7319 } 7320 /* a full unit to check, with more to come */ 7321 if (*up!=DECDPUNMAX) break; /* not still 9s */ 7322 count-=DECDPUN; 7323 } /* up */ 7324 } /* bump>0 */ 7325 else { /* -1 */ 7326 /* here checking for a pre-bump of 1000... (leading 1, all */ 7327 /* other digits zero) */ 7328 Unit *up, *sup; /* work */ 7329 uInt count=dn->digits; /* digits to be checked */ 7330 for (up=dn->lsu; ; up++) { 7331 if (count<=DECDPUN) { 7332 /* this is the last Unit (the msu) */ 7333 if (*up!=powers[count-1]) break; /* not 100.. */ 7334 /* here if have the 1000... case */ 7335 sup=up; /* save msu pointer */ 7336 *up=(Unit)powers[count]-1; /* here 100 in msu -> 999 */ 7337 /* others all to all-nines, too */ 7338 for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1; 7339 dn->exponent--; /* and bump exponent */ 7340 7341 /* iff the number was at the subnormal boundary (exponent=etiny) */ 7342 /* then the exponent is now out of range, so it will in fact get */ 7343 /* clamped to etiny and the final 9 dropped. */ 7344 /* printf(">> emin=%d exp=%d sdig=%d\n", set->emin, */ 7345 /* dn->exponent, set->digits); */ 7346 if (dn->exponent+1==set->emin-set->digits+1) { 7347 if (count==1 && dn->digits==1) *sup=0; /* here 9 -> 0[.9] */ 7348 else { 7349 *sup=(Unit)powers[count-1]-1; /* here 999.. in msu -> 99.. */ 7350 dn->digits--; 7351 } 7352 dn->exponent++; 7353 *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded; 7354 } 7355 return; /* done */ 7356 } 7357 7358 /* a full unit to check, with more to come */ 7359 if (*up!=0) break; /* not still 0s */ 7360 count-=DECDPUN; 7361 } /* up */ 7362 7363 } /* bump<0 */ 7364 7365 /* Actual bump needed. Do it. */ 7366 decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump); 7367 } /* decApplyRound */ 7368 7369 #if DECSUBSET 7370 /* ------------------------------------------------------------------ */ 7371 /* decFinish -- finish processing a number */ 7372 /* */ 7373 /* dn is the number */ 7374 /* set is the context */ 7375 /* residue is the rounding accumulator (as in decApplyRound) */ 7376 /* status is the accumulator */ 7377 /* */ 7378 /* This finishes off the current number by: */ 7379 /* 1. If not extended: */ 7380 /* a. Converting a zero result to clean '0' */ 7381 /* b. Reducing positive exponents to 0, if would fit in digits */ 7382 /* 2. Checking for overflow and subnormals (always) */ 7383 /* Note this is just Finalize when no subset arithmetic. */ 7384 /* All fields are updated as required. */ 7385 /* ------------------------------------------------------------------ */ 7386 static void decFinish(decNumber *dn, decContext *set, Int *residue, 7387 uInt *status) { 7388 if (!set->extended) { 7389 if ISZERO(dn) { /* value is zero */ 7390 dn->exponent=0; /* clean exponent .. */ 7391 dn->bits=0; /* .. and sign */ 7392 return; /* no error possible */ 7393 } 7394 if (dn->exponent>=0) { /* non-negative exponent */ 7395 /* >0; reduce to integer if possible */ 7396 if (set->digits >= (dn->exponent+dn->digits)) { 7397 dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent); 7398 dn->exponent=0; 7399 } 7400 } 7401 } /* !extended */ 7402 7403 decFinalize(dn, set, residue, status); 7404 } /* decFinish */ 7405 #endif 7406 7407 /* ------------------------------------------------------------------ */ 7408 /* decFinalize -- final check, clamp, and round of a number */ 7409 /* */ 7410 /* dn is the number */ 7411 /* set is the context */ 7412 /* residue is the rounding accumulator (as in decApplyRound) */ 7413 /* status is the status accumulator */ 7414 /* */ 7415 /* This finishes off the current number by checking for subnormal */ 7416 /* results, applying any pending rounding, checking for overflow, */ 7417 /* and applying any clamping. */ 7418 /* Underflow and overflow conditions are raised as appropriate. */ 7419 /* All fields are updated as required. */ 7420 /* ------------------------------------------------------------------ */ 7421 static void decFinalize(decNumber *dn, decContext *set, Int *residue, 7422 uInt *status) { 7423 Int shift; /* shift needed if clamping */ 7424 Int tinyexp=set->emin-dn->digits+1; /* precalculate subnormal boundary */ 7425 7426 /* Must be careful, here, when checking the exponent as the */ 7427 /* adjusted exponent could overflow 31 bits [because it may already */ 7428 /* be up to twice the expected]. */ 7429 7430 /* First test for subnormal. This must be done before any final */ 7431 /* round as the result could be rounded to Nmin or 0. */ 7432 if (dn->exponent<=tinyexp) { /* prefilter */ 7433 Int comp; 7434 decNumber nmin; 7435 /* A very nasty case here is dn == Nmin and residue<0 */ 7436 if (dn->exponent<tinyexp) { 7437 /* Go handle subnormals; this will apply round if needed. */ 7438 decSetSubnormal(dn, set, residue, status); 7439 return; 7440 } 7441 /* Equals case: only subnormal if dn=Nmin and negative residue */ 7442 decNumberZero(&nmin); 7443 nmin.lsu[0]=1; 7444 nmin.exponent=set->emin; 7445 comp=decCompare(dn, &nmin, 1); /* (signless compare) */ 7446 if (comp==BADINT) { /* oops */ 7447 *status|=DEC_Insufficient_storage; /* abandon... */ 7448 return; 7449 } 7450 if (*residue<0 && comp==0) { /* neg residue and dn==Nmin */ 7451 decApplyRound(dn, set, *residue, status); /* might force down */ 7452 decSetSubnormal(dn, set, residue, status); 7453 return; 7454 } 7455 } 7456 7457 /* now apply any pending round (this could raise overflow). */ 7458 if (*residue!=0) decApplyRound(dn, set, *residue, status); 7459 7460 /* Check for overflow [redundant in the 'rare' case] or clamp */ 7461 if (dn->exponent<=set->emax-set->digits+1) return; /* neither needed */ 7462 7463 7464 /* here when might have an overflow or clamp to do */ 7465 if (dn->exponent>set->emax-dn->digits+1) { /* too big */ 7466 decSetOverflow(dn, set, status); 7467 return; 7468 } 7469 /* here when the result is normal but in clamp range */ 7470 if (!set->clamp) return; 7471 7472 /* here when need to apply the IEEE exponent clamp (fold-down) */ 7473 shift=dn->exponent-(set->emax-set->digits+1); 7474 7475 /* shift coefficient (if non-zero) */ 7476 if (!ISZERO(dn)) { 7477 dn->digits=decShiftToMost(dn->lsu, dn->digits, shift); 7478 } 7479 dn->exponent-=shift; /* adjust the exponent to match */ 7480 *status|=DEC_Clamped; /* and record the dirty deed */ 7481 return; 7482 } /* decFinalize */ 7483 7484 /* ------------------------------------------------------------------ */ 7485 /* decSetOverflow -- set number to proper overflow value */ 7486 /* */ 7487 /* dn is the number (used for sign [only] and result) */ 7488 /* set is the context [used for the rounding mode, etc.] */ 7489 /* status contains the current status to be updated */ 7490 /* */ 7491 /* This sets the sign of a number and sets its value to either */ 7492 /* Infinity or the maximum finite value, depending on the sign of */ 7493 /* dn and the rounding mode, following IEEE 854 rules. */ 7494 /* ------------------------------------------------------------------ */ 7495 static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) { 7496 Flag needmax=0; /* result is maximum finite value */ 7497 uByte sign=dn->bits&DECNEG; /* clean and save sign bit */ 7498 7499 if (ISZERO(dn)) { /* zero does not overflow magnitude */ 7500 Int emax=set->emax; /* limit value */ 7501 if (set->clamp) emax-=set->digits-1; /* lower if clamping */ 7502 if (dn->exponent>emax) { /* clamp required */ 7503 dn->exponent=emax; 7504 *status|=DEC_Clamped; 7505 } 7506 return; 7507 } 7508 7509 decNumberZero(dn); 7510 switch (set->round) { 7511 case DEC_ROUND_DOWN: { 7512 needmax=1; /* never Infinity */ 7513 break;} /* r-d */ 7514 case DEC_ROUND_05UP: { 7515 needmax=1; /* never Infinity */ 7516 break;} /* r-05 */ 7517 case DEC_ROUND_CEILING: { 7518 if (sign) needmax=1; /* Infinity if non-negative */ 7519 break;} /* r-c */ 7520 case DEC_ROUND_FLOOR: { 7521 if (!sign) needmax=1; /* Infinity if negative */ 7522 break;} /* r-f */ 7523 default: break; /* Infinity in all other cases */ 7524 } 7525 if (needmax) { 7526 decSetMaxValue(dn, set); 7527 dn->bits=sign; /* set sign */ 7528 } 7529 else dn->bits=sign|DECINF; /* Value is +/-Infinity */ 7530 *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded; 7531 } /* decSetOverflow */ 7532 7533 /* ------------------------------------------------------------------ */ 7534 /* decSetMaxValue -- set number to +Nmax (maximum normal value) */ 7535 /* */ 7536 /* dn is the number to set */ 7537 /* set is the context [used for digits and emax] */ 7538 /* */ 7539 /* This sets the number to the maximum positive value. */ 7540 /* ------------------------------------------------------------------ */ 7541 static void decSetMaxValue(decNumber *dn, decContext *set) { 7542 Unit *up; /* work */ 7543 Int count=set->digits; /* nines to add */ 7544 dn->digits=count; 7545 /* fill in all nines to set maximum value */ 7546 for (up=dn->lsu; ; up++) { 7547 if (count>DECDPUN) *up=DECDPUNMAX; /* unit full o'nines */ 7548 else { /* this is the msu */ 7549 *up=(Unit)(powers[count]-1); 7550 break; 7551 } 7552 count-=DECDPUN; /* filled those digits */ 7553 } /* up */ 7554 dn->bits=0; /* + sign */ 7555 dn->exponent=set->emax-set->digits+1; 7556 } /* decSetMaxValue */ 7557 7558 /* ------------------------------------------------------------------ */ 7559 /* decSetSubnormal -- process value whose exponent is <Emin */ 7560 /* */ 7561 /* dn is the number (used as input as well as output; it may have */ 7562 /* an allowed subnormal value, which may need to be rounded) */ 7563 /* set is the context [used for the rounding mode] */ 7564 /* residue is any pending residue */ 7565 /* status contains the current status to be updated */ 7566 /* */ 7567 /* If subset mode, set result to zero and set Underflow flags. */ 7568 /* */ 7569 /* Value may be zero with a low exponent; this does not set Subnormal */ 7570 /* but the exponent will be clamped to Etiny. */ 7571 /* */ 7572 /* Otherwise ensure exponent is not out of range, and round as */ 7573 /* necessary. Underflow is set if the result is Inexact. */ 7574 /* ------------------------------------------------------------------ */ 7575 static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue, 7576 uInt *status) { 7577 decContext workset; /* work */ 7578 Int etiny, adjust; /* .. */ 7579 7580 #if DECSUBSET 7581 /* simple set to zero and 'hard underflow' for subset */ 7582 if (!set->extended) { 7583 decNumberZero(dn); 7584 /* always full overflow */ 7585 *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded; 7586 return; 7587 } 7588 #endif 7589 7590 /* Full arithmetic -- allow subnormals, rounded to minimum exponent */ 7591 /* (Etiny) if needed */ 7592 etiny=set->emin-(set->digits-1); /* smallest allowed exponent */ 7593 7594 if ISZERO(dn) { /* value is zero */ 7595 /* residue can never be non-zero here */ 7596 #if DECCHECK 7597 if (*residue!=0) { 7598 printf("++ Subnormal 0 residue %ld\n", (LI)*residue); 7599 *status|=DEC_Invalid_operation; 7600 } 7601 #endif 7602 if (dn->exponent<etiny) { /* clamp required */ 7603 dn->exponent=etiny; 7604 *status|=DEC_Clamped; 7605 } 7606 return; 7607 } 7608 7609 *status|=DEC_Subnormal; /* have a non-zero subnormal */ 7610 adjust=etiny-dn->exponent; /* calculate digits to remove */ 7611 if (adjust<=0) { /* not out of range; unrounded */ 7612 /* residue can never be non-zero here, except in the Nmin-residue */ 7613 /* case (which is a subnormal result), so can take fast-path here */ 7614 /* it may already be inexact (from setting the coefficient) */ 7615 if (*status&DEC_Inexact) *status|=DEC_Underflow; 7616 return; 7617 } 7618 7619 /* adjust>0, so need to rescale the result so exponent becomes Etiny */ 7620 /* [this code is similar to that in rescale] */ 7621 workset=*set; /* clone rounding, etc. */ 7622 workset.digits=dn->digits-adjust; /* set requested length */ 7623 workset.emin-=adjust; /* and adjust emin to match */ 7624 /* [note that the latter can be <1, here, similar to Rescale case] */ 7625 decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status); 7626 decApplyRound(dn, &workset, *residue, status); 7627 7628 /* Use 754R/854 default rule: Underflow is set iff Inexact */ 7629 /* [independent of whether trapped] */ 7630 if (*status&DEC_Inexact) *status|=DEC_Underflow; 7631 7632 /* if rounded up a 999s case, exponent will be off by one; adjust */ 7633 /* back if so [it will fit, because it was shortened earlier] */ 7634 if (dn->exponent>etiny) { 7635 dn->digits=decShiftToMost(dn->lsu, dn->digits, 1); 7636 dn->exponent--; /* (re)adjust the exponent. */ 7637 } 7638 7639 /* if rounded to zero, it is by definition clamped... */ 7640 if (ISZERO(dn)) *status|=DEC_Clamped; 7641 } /* decSetSubnormal */ 7642 7643 /* ------------------------------------------------------------------ */ 7644 /* decCheckMath - check entry conditions for a math function */ 7645 /* */ 7646 /* This checks the context and the operand */ 7647 /* */ 7648 /* rhs is the operand to check */ 7649 /* set is the context to check */ 7650 /* status is unchanged if both are good */ 7651 /* */ 7652 /* returns non-zero if status is changed, 0 otherwise */ 7653 /* */ 7654 /* Restrictions enforced: */ 7655 /* */ 7656 /* digits, emax, and -emin in the context must be less than */ 7657 /* DEC_MAX_MATH (999999), and A must be within these bounds if */ 7658 /* non-zero. Invalid_operation is set in the status if a */ 7659 /* restriction is violated. */ 7660 /* ------------------------------------------------------------------ */ 7661 static uInt decCheckMath(const decNumber *rhs, decContext *set, 7662 uInt *status) { 7663 uInt save=*status; /* record */ 7664 if (set->digits>DEC_MAX_MATH 7665 || set->emax>DEC_MAX_MATH 7666 || -set->emin>DEC_MAX_MATH) *status|=DEC_Invalid_context; 7667 else if ((rhs->digits>DEC_MAX_MATH 7668 || rhs->exponent+rhs->digits>DEC_MAX_MATH+1 7669 || rhs->exponent+rhs->digits<2*(1-DEC_MAX_MATH)) 7670 && !ISZERO(rhs)) *status|=DEC_Invalid_operation; 7671 return (*status!=save); 7672 } /* decCheckMath */ 7673 7674 /* ------------------------------------------------------------------ */ 7675 /* decGetInt -- get integer from a number */ 7676 /* */ 7677 /* dn is the number [which will not be altered] */ 7678 /* */ 7679 /* returns one of: */ 7680 /* BADINT if there is a non-zero fraction */ 7681 /* the converted integer */ 7682 /* BIGEVEN if the integer is even and magnitude > 2*10**9 */ 7683 /* BIGODD if the integer is odd and magnitude > 2*10**9 */ 7684 /* */ 7685 /* This checks and gets a whole number from the input decNumber. */ 7686 /* The sign can be determined from dn by the caller when BIGEVEN or */ 7687 /* BIGODD is returned. */ 7688 /* ------------------------------------------------------------------ */ 7689 static Int decGetInt(const decNumber *dn) { 7690 Int theInt; /* result accumulator */ 7691 const Unit *up; /* work */ 7692 Int got; /* digits (real or not) processed */ 7693 Int ilength=dn->digits+dn->exponent; /* integral length */ 7694 Flag neg=decNumberIsNegative(dn); /* 1 if -ve */ 7695 7696 /* The number must be an integer that fits in 10 digits */ 7697 /* Assert, here, that 10 is enough for any rescale Etiny */ 7698 #if DEC_MAX_EMAX > 999999999 7699 #error GetInt may need updating [for Emax] 7700 #endif 7701 #if DEC_MIN_EMIN < -999999999 7702 #error GetInt may need updating [for Emin] 7703 #endif 7704 if (ISZERO(dn)) return 0; /* zeros are OK, with any exponent */ 7705 7706 up=dn->lsu; /* ready for lsu */ 7707 theInt=0; /* ready to accumulate */ 7708 if (dn->exponent>=0) { /* relatively easy */ 7709 /* no fractional part [usual]; allow for positive exponent */ 7710 got=dn->exponent; 7711 } 7712 else { /* -ve exponent; some fractional part to check and discard */ 7713 Int count=-dn->exponent; /* digits to discard */ 7714 /* spin up whole units until reach the Unit with the unit digit */ 7715 for (; count>=DECDPUN; up++) { 7716 if (*up!=0) return BADINT; /* non-zero Unit to discard */ 7717 count-=DECDPUN; 7718 } 7719 if (count==0) got=0; /* [a multiple of DECDPUN] */ 7720 else { /* [not multiple of DECDPUN] */ 7721 Int rem; /* work */ 7722 /* slice off fraction digits and check for non-zero */ 7723 #if DECDPUN<=4 7724 theInt=QUOT10(*up, count); 7725 rem=*up-theInt*powers[count]; 7726 #else 7727 rem=*up%powers[count]; /* slice off discards */ 7728 theInt=*up/powers[count]; 7729 #endif 7730 if (rem!=0) return BADINT; /* non-zero fraction */ 7731 /* it looks good */ 7732 got=DECDPUN-count; /* number of digits so far */ 7733 up++; /* ready for next */ 7734 } 7735 } 7736 /* now it's known there's no fractional part */ 7737 7738 /* tricky code now, to accumulate up to 9.3 digits */ 7739 if (got==0) {theInt=*up; got+=DECDPUN; up++;} /* ensure lsu is there */ 7740 7741 if (ilength<11) { 7742 Int save=theInt; 7743 /* collect any remaining unit(s) */ 7744 for (; got<ilength; up++) { 7745 theInt+=*up*powers[got]; 7746 got+=DECDPUN; 7747 } 7748 if (ilength==10) { /* need to check for wrap */ 7749 if (theInt/(Int)powers[got-DECDPUN]!=(Int)*(up-1)) ilength=11; 7750 /* [that test also disallows the BADINT result case] */ 7751 else if (neg && theInt>1999999997) ilength=11; 7752 else if (!neg && theInt>999999999) ilength=11; 7753 if (ilength==11) theInt=save; /* restore correct low bit */ 7754 } 7755 } 7756 7757 if (ilength>10) { /* too big */ 7758 if (theInt&1) return BIGODD; /* bottom bit 1 */ 7759 return BIGEVEN; /* bottom bit 0 */ 7760 } 7761 7762 if (neg) theInt=-theInt; /* apply sign */ 7763 return theInt; 7764 } /* decGetInt */ 7765 7766 /* ------------------------------------------------------------------ */ 7767 /* decDecap -- decapitate the coefficient of a number */ 7768 /* */ 7769 /* dn is the number to be decapitated */ 7770 /* drop is the number of digits to be removed from the left of dn; */ 7771 /* this must be <= dn->digits (if equal, the coefficient is */ 7772 /* set to 0) */ 7773 /* */ 7774 /* Returns dn; dn->digits will be <= the initial digits less drop */ 7775 /* (after removing drop digits there may be leading zero digits */ 7776 /* which will also be removed). Only dn->lsu and dn->digits change. */ 7777 /* ------------------------------------------------------------------ */ 7778 static decNumber *decDecap(decNumber *dn, Int drop) { 7779 Unit *msu; /* -> target cut point */ 7780 Int cut; /* work */ 7781 if (drop>=dn->digits) { /* losing the whole thing */ 7782 #if DECCHECK 7783 if (drop>dn->digits) 7784 printf("decDecap called with drop>digits [%ld>%ld]\n", 7785 (LI)drop, (LI)dn->digits); 7786 #endif 7787 dn->lsu[0]=0; 7788 dn->digits=1; 7789 return dn; 7790 } 7791 msu=dn->lsu+D2U(dn->digits-drop)-1; /* -> likely msu */ 7792 cut=MSUDIGITS(dn->digits-drop); /* digits to be in use in msu */ 7793 if (cut!=DECDPUN) *msu%=powers[cut]; /* clear left digits */ 7794 /* that may have left leading zero digits, so do a proper count... */ 7795 dn->digits=decGetDigits(dn->lsu, msu-dn->lsu+1); 7796 return dn; 7797 } /* decDecap */ 7798 7799 /* ------------------------------------------------------------------ */ 7800 /* decBiStr -- compare string with pairwise options */ 7801 /* */ 7802 /* targ is the string to compare */ 7803 /* str1 is one of the strings to compare against (length may be 0) */ 7804 /* str2 is the other; it must be the same length as str1 */ 7805 /* */ 7806 /* returns 1 if strings compare equal, (that is, it is the same */ 7807 /* length as str1 and str2, and each character of targ is in either */ 7808 /* str1 or str2 in the corresponding position), or 0 otherwise */ 7809 /* */ 7810 /* This is used for generic caseless compare, including the awkward */ 7811 /* case of the Turkish dotted and dotless Is. Use as (for example): */ 7812 /* if (decBiStr(test, "mike", "MIKE")) ... */ 7813 /* ------------------------------------------------------------------ */ 7814 static Flag decBiStr(const char *targ, const char *str1, const char *str2) { 7815 for (;;targ++, str1++, str2++) { 7816 if (*targ!=*str1 && *targ!=*str2) return 0; 7817 /* *targ has a match in one (or both, if terminator) */ 7818 if (*targ=='\0') break; 7819 } /* forever */ 7820 return 1; 7821 } /* decBiStr */ 7822 7823 /* ------------------------------------------------------------------ */ 7824 /* decNaNs -- handle NaN operand or operands */ 7825 /* */ 7826 /* res is the result number */ 7827 /* lhs is the first operand */ 7828 /* rhs is the second operand, or NULL if none */ 7829 /* context is used to limit payload length */ 7830 /* status contains the current status */ 7831 /* returns res in case convenient */ 7832 /* */ 7833 /* Called when one or both operands is a NaN, and propagates the */ 7834 /* appropriate result to res. When an sNaN is found, it is changed */ 7835 /* to a qNaN and Invalid operation is set. */ 7836 /* ------------------------------------------------------------------ */ 7837 static decNumber * decNaNs(decNumber *res, const decNumber *lhs, 7838 const decNumber *rhs, decContext *set, 7839 uInt *status) { 7840 /* This decision tree ends up with LHS being the source pointer, */ 7841 /* and status updated if need be */ 7842 if (lhs->bits & DECSNAN) 7843 *status|=DEC_Invalid_operation | DEC_sNaN; 7844 else if (rhs==NULL); 7845 else if (rhs->bits & DECSNAN) { 7846 lhs=rhs; 7847 *status|=DEC_Invalid_operation | DEC_sNaN; 7848 } 7849 else if (lhs->bits & DECNAN); 7850 else lhs=rhs; 7851 7852 /* propagate the payload */ 7853 if (lhs->digits<=set->digits) decNumberCopy(res, lhs); /* easy */ 7854 else { /* too long */ 7855 const Unit *ul; 7856 Unit *ur, *uresp1; 7857 /* copy safe number of units, then decapitate */ 7858 res->bits=lhs->bits; /* need sign etc. */ 7859 uresp1=res->lsu+D2U(set->digits); 7860 for (ur=res->lsu, ul=lhs->lsu; ur<uresp1; ur++, ul++) *ur=*ul; 7861 res->digits=D2U(set->digits)*DECDPUN; 7862 /* maybe still too long */ 7863 if (res->digits>set->digits) decDecap(res, res->digits-set->digits); 7864 } 7865 7866 res->bits&=~DECSNAN; /* convert any sNaN to NaN, while */ 7867 res->bits|=DECNAN; /* .. preserving sign */ 7868 res->exponent=0; /* clean exponent */ 7869 /* [coefficient was copied/decapitated] */ 7870 return res; 7871 } /* decNaNs */ 7872 7873 /* ------------------------------------------------------------------ */ 7874 /* decStatus -- apply non-zero status */ 7875 /* */ 7876 /* dn is the number to set if error */ 7877 /* status contains the current status (not yet in context) */ 7878 /* set is the context */ 7879 /* */ 7880 /* If the status is an error status, the number is set to a NaN, */ 7881 /* unless the error was an overflow, divide-by-zero, or underflow, */ 7882 /* in which case the number will have already been set. */ 7883 /* */ 7884 /* The context status is then updated with the new status. Note that */ 7885 /* this may raise a signal, so control may never return from this */ 7886 /* routine (hence resources must be recovered before it is called). */ 7887 /* ------------------------------------------------------------------ */ 7888 static void decStatus(decNumber *dn, uInt status, decContext *set) { 7889 if (status & DEC_NaNs) { /* error status -> NaN */ 7890 /* if cause was an sNaN, clear and propagate [NaN is already set up] */ 7891 if (status & DEC_sNaN) status&=~DEC_sNaN; 7892 else { 7893 decNumberZero(dn); /* other error: clean throughout */ 7894 dn->bits=DECNAN; /* and make a quiet NaN */ 7895 } 7896 } 7897 decContextSetStatus(set, status); /* [may not return] */ 7898 return; 7899 } /* decStatus */ 7900 7901 /* ------------------------------------------------------------------ */ 7902 /* decGetDigits -- count digits in a Units array */ 7903 /* */ 7904 /* uar is the Unit array holding the number (this is often an */ 7905 /* accumulator of some sort) */ 7906 /* len is the length of the array in units [>=1] */ 7907 /* */ 7908 /* returns the number of (significant) digits in the array */ 7909 /* */ 7910 /* All leading zeros are excluded, except the last if the array has */ 7911 /* only zero Units. */ 7912 /* ------------------------------------------------------------------ */ 7913 /* This may be called twice during some operations. */ 7914 static Int decGetDigits(Unit *uar, Int len) { 7915 Unit *up=uar+(len-1); /* -> msu */ 7916 Int digits=(len-1)*DECDPUN+1; /* possible digits excluding msu */ 7917 #if DECDPUN>4 7918 uInt const *pow; /* work */ 7919 #endif 7920 /* (at least 1 in final msu) */ 7921 #if DECCHECK 7922 if (len<1) printf("decGetDigits called with len<1 [%ld]\n", (LI)len); 7923 #endif 7924 7925 for (; up>=uar; up--) { 7926 if (*up==0) { /* unit is all 0s */ 7927 if (digits==1) break; /* a zero has one digit */ 7928 digits-=DECDPUN; /* adjust for 0 unit */ 7929 continue;} 7930 /* found the first (most significant) non-zero Unit */ 7931 #if DECDPUN>1 /* not done yet */ 7932 if (*up<10) break; /* is 1-9 */ 7933 digits++; 7934 #if DECDPUN>2 /* not done yet */ 7935 if (*up<100) break; /* is 10-99 */ 7936 digits++; 7937 #if DECDPUN>3 /* not done yet */ 7938 if (*up<1000) break; /* is 100-999 */ 7939 digits++; 7940 #if DECDPUN>4 /* count the rest ... */ 7941 for (pow=&powers[4]; *up>=*pow; pow++) digits++; 7942 #endif 7943 #endif 7944 #endif 7945 #endif 7946 break; 7947 } /* up */ 7948 return digits; 7949 } /* decGetDigits */ 7950 7951 /* ------------------------------------------------------------------ */ 7952 /* mulUInt128ByPowOf10 -- multiply a 128-bit unsigned integer by a */ 7953 /* power of 10. */ 7954 /* */ 7955 /* The 128-bit factor composed of plow and phigh is multiplied */ 7956 /* by 10^exp. */ 7957 /* */ 7958 /* plow pointer to the low 64 bits of the first factor */ 7959 /* phigh pointer to the high 64 bits of the first factor */ 7960 /* exp the exponent of the power of 10 of the second factor */ 7961 /* */ 7962 /* If the result fits in 128 bits, returns false and the */ 7963 /* multiplication result through plow and phigh. */ 7964 /* Otherwise, returns true. */ 7965 /* ------------------------------------------------------------------ */ 7966 static bool mulUInt128ByPowOf10(uLong *plow, uLong *phigh, uInt pow10) 7967 { 7968 while (pow10 >= ARRAY_SIZE(powers)) { 7969 if (mulu128(plow, phigh, powers[ARRAY_SIZE(powers) - 1])) { 7970 /* Overflow */ 7971 return true; 7972 } 7973 pow10 -= ARRAY_SIZE(powers) - 1; 7974 } 7975 7976 if (pow10 > 0) { 7977 return mulu128(plow, phigh, powers[pow10]); 7978 } else { 7979 return false; 7980 } 7981 } 7982 7983 #if DECTRACE | DECCHECK 7984 /* ------------------------------------------------------------------ */ 7985 /* decNumberShow -- display a number [debug aid] */ 7986 /* dn is the number to show */ 7987 /* */ 7988 /* Shows: sign, exponent, coefficient (msu first), digits */ 7989 /* or: sign, special-value */ 7990 /* ------------------------------------------------------------------ */ 7991 /* this is public so other modules can use it */ 7992 void decNumberShow(const decNumber *dn) { 7993 const Unit *up; /* work */ 7994 uInt u, d; /* .. */ 7995 Int cut; /* .. */ 7996 char isign='+'; /* main sign */ 7997 if (dn==NULL) { 7998 printf("NULL\n"); 7999 return;} 8000 if (decNumberIsNegative(dn)) isign='-'; 8001 printf(" >> %c ", isign); 8002 if (dn->bits&DECSPECIAL) { /* Is a special value */ 8003 if (decNumberIsInfinite(dn)) printf("Infinity"); 8004 else { /* a NaN */ 8005 if (dn->bits&DECSNAN) printf("sNaN"); /* signalling NaN */ 8006 else printf("NaN"); 8007 } 8008 /* if coefficient and exponent are 0, no more to do */ 8009 if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) { 8010 printf("\n"); 8011 return;} 8012 /* drop through to report other information */ 8013 printf(" "); 8014 } 8015 8016 /* now carefully display the coefficient */ 8017 up=dn->lsu+D2U(dn->digits)-1; /* msu */ 8018 printf("%ld", (LI)*up); 8019 for (up=up-1; up>=dn->lsu; up--) { 8020 u=*up; 8021 printf(":"); 8022 for (cut=DECDPUN-1; cut>=0; cut--) { 8023 d=u/powers[cut]; 8024 u-=d*powers[cut]; 8025 printf("%ld", (LI)d); 8026 } /* cut */ 8027 } /* up */ 8028 if (dn->exponent!=0) { 8029 char esign='+'; 8030 if (dn->exponent<0) esign='-'; 8031 printf(" E%c%ld", esign, (LI)abs(dn->exponent)); 8032 } 8033 printf(" [%ld]\n", (LI)dn->digits); 8034 } /* decNumberShow */ 8035 #endif 8036 8037 #if DECTRACE || DECCHECK 8038 /* ------------------------------------------------------------------ */ 8039 /* decDumpAr -- display a unit array [debug/check aid] */ 8040 /* name is a single-character tag name */ 8041 /* ar is the array to display */ 8042 /* len is the length of the array in Units */ 8043 /* ------------------------------------------------------------------ */ 8044 static void decDumpAr(char name, const Unit *ar, Int len) { 8045 Int i; 8046 const char *spec; 8047 #if DECDPUN==9 8048 spec="%09d "; 8049 #elif DECDPUN==8 8050 spec="%08d "; 8051 #elif DECDPUN==7 8052 spec="%07d "; 8053 #elif DECDPUN==6 8054 spec="%06d "; 8055 #elif DECDPUN==5 8056 spec="%05d "; 8057 #elif DECDPUN==4 8058 spec="%04d "; 8059 #elif DECDPUN==3 8060 spec="%03d "; 8061 #elif DECDPUN==2 8062 spec="%02d "; 8063 #else 8064 spec="%d "; 8065 #endif 8066 printf(" :%c: ", name); 8067 for (i=len-1; i>=0; i--) { 8068 if (i==len-1) printf("%ld ", (LI)ar[i]); 8069 else printf(spec, ar[i]); 8070 } 8071 printf("\n"); 8072 return;} 8073 #endif 8074 8075 #if DECCHECK 8076 /* ------------------------------------------------------------------ */ 8077 /* decCheckOperands -- check operand(s) to a routine */ 8078 /* res is the result structure (not checked; it will be set to */ 8079 /* quiet NaN if error found (and it is not NULL)) */ 8080 /* lhs is the first operand (may be DECUNRESU) */ 8081 /* rhs is the second (may be DECUNUSED) */ 8082 /* set is the context (may be DECUNCONT) */ 8083 /* returns 0 if both operands, and the context are clean, or 1 */ 8084 /* otherwise (in which case the context will show an error, */ 8085 /* unless NULL). Note that res is not cleaned; caller should */ 8086 /* handle this so res=NULL case is safe. */ 8087 /* The caller is expected to abandon immediately if 1 is returned. */ 8088 /* ------------------------------------------------------------------ */ 8089 static Flag decCheckOperands(decNumber *res, const decNumber *lhs, 8090 const decNumber *rhs, decContext *set) { 8091 Flag bad=0; 8092 if (set==NULL) { /* oops; hopeless */ 8093 #if DECTRACE || DECVERB 8094 printf("Reference to context is NULL.\n"); 8095 #endif 8096 bad=1; 8097 return 1;} 8098 else if (set!=DECUNCONT 8099 && (set->digits<1 || set->round>=DEC_ROUND_MAX)) { 8100 bad=1; 8101 #if DECTRACE || DECVERB 8102 printf("Bad context [digits=%ld round=%ld].\n", 8103 (LI)set->digits, (LI)set->round); 8104 #endif 8105 } 8106 else { 8107 if (res==NULL) { 8108 bad=1; 8109 #if DECTRACE 8110 /* this one not DECVERB as standard tests include NULL */ 8111 printf("Reference to result is NULL.\n"); 8112 #endif 8113 } 8114 if (!bad && lhs!=DECUNUSED) bad=(decCheckNumber(lhs)); 8115 if (!bad && rhs!=DECUNUSED) bad=(decCheckNumber(rhs)); 8116 } 8117 if (bad) { 8118 if (set!=DECUNCONT) decContextSetStatus(set, DEC_Invalid_operation); 8119 if (res!=DECUNRESU && res!=NULL) { 8120 decNumberZero(res); 8121 res->bits=DECNAN; /* qNaN */ 8122 } 8123 } 8124 return bad; 8125 } /* decCheckOperands */ 8126 8127 /* ------------------------------------------------------------------ */ 8128 /* decCheckNumber -- check a number */ 8129 /* dn is the number to check */ 8130 /* returns 0 if the number is clean, or 1 otherwise */ 8131 /* */ 8132 /* The number is considered valid if it could be a result from some */ 8133 /* operation in some valid context. */ 8134 /* ------------------------------------------------------------------ */ 8135 static Flag decCheckNumber(const decNumber *dn) { 8136 const Unit *up; /* work */ 8137 uInt maxuint; /* .. */ 8138 Int ae, d, digits; /* .. */ 8139 Int emin, emax; /* .. */ 8140 8141 if (dn==NULL) { /* hopeless */ 8142 #if DECTRACE 8143 /* this one not DECVERB as standard tests include NULL */ 8144 printf("Reference to decNumber is NULL.\n"); 8145 #endif 8146 return 1;} 8147 8148 /* check special values */ 8149 if (dn->bits & DECSPECIAL) { 8150 if (dn->exponent!=0) { 8151 #if DECTRACE || DECVERB 8152 printf("Exponent %ld (not 0) for a special value [%02x].\n", 8153 (LI)dn->exponent, dn->bits); 8154 #endif 8155 return 1;} 8156 8157 /* 2003.09.08: NaNs may now have coefficients, so next tests Inf only */ 8158 if (decNumberIsInfinite(dn)) { 8159 if (dn->digits!=1) { 8160 #if DECTRACE || DECVERB 8161 printf("Digits %ld (not 1) for an infinity.\n", (LI)dn->digits); 8162 #endif 8163 return 1;} 8164 if (*dn->lsu!=0) { 8165 #if DECTRACE || DECVERB 8166 printf("LSU %ld (not 0) for an infinity.\n", (LI)*dn->lsu); 8167 #endif 8168 decDumpAr('I', dn->lsu, D2U(dn->digits)); 8169 return 1;} 8170 } /* Inf */ 8171 /* 2002.12.26: negative NaNs can now appear through proposed IEEE */ 8172 /* concrete formats (decimal64, etc.). */ 8173 return 0; 8174 } 8175 8176 /* check the coefficient */ 8177 if (dn->digits<1 || dn->digits>DECNUMMAXP) { 8178 #if DECTRACE || DECVERB 8179 printf("Digits %ld in number.\n", (LI)dn->digits); 8180 #endif 8181 return 1;} 8182 8183 d=dn->digits; 8184 8185 for (up=dn->lsu; d>0; up++) { 8186 if (d>DECDPUN) maxuint=DECDPUNMAX; 8187 else { /* reached the msu */ 8188 maxuint=powers[d]-1; 8189 if (dn->digits>1 && *up<powers[d-1]) { 8190 #if DECTRACE || DECVERB 8191 printf("Leading 0 in number.\n"); 8192 decNumberShow(dn); 8193 #endif 8194 return 1;} 8195 } 8196 if (*up>maxuint) { 8197 #if DECTRACE || DECVERB 8198 printf("Bad Unit [%08lx] in %ld-digit number at offset %ld [maxuint %ld].\n", 8199 (LI)*up, (LI)dn->digits, (LI)(up-dn->lsu), (LI)maxuint); 8200 #endif 8201 return 1;} 8202 d-=DECDPUN; 8203 } 8204 8205 /* check the exponent. Note that input operands can have exponents */ 8206 /* which are out of the set->emin/set->emax and set->digits range */ 8207 /* (just as they can have more digits than set->digits). */ 8208 ae=dn->exponent+dn->digits-1; /* adjusted exponent */ 8209 emax=DECNUMMAXE; 8210 emin=DECNUMMINE; 8211 digits=DECNUMMAXP; 8212 if (ae<emin-(digits-1)) { 8213 #if DECTRACE || DECVERB 8214 printf("Adjusted exponent underflow [%ld].\n", (LI)ae); 8215 decNumberShow(dn); 8216 #endif 8217 return 1;} 8218 if (ae>+emax) { 8219 #if DECTRACE || DECVERB 8220 printf("Adjusted exponent overflow [%ld].\n", (LI)ae); 8221 decNumberShow(dn); 8222 #endif 8223 return 1;} 8224 8225 return 0; /* it's OK */ 8226 } /* decCheckNumber */ 8227 8228 /* ------------------------------------------------------------------ */ 8229 /* decCheckInexact -- check a normal finite inexact result has digits */ 8230 /* dn is the number to check */ 8231 /* set is the context (for status and precision) */ 8232 /* sets Invalid operation, etc., if some digits are missing */ 8233 /* [this check is not made for DECSUBSET compilation or when */ 8234 /* subnormal is not set] */ 8235 /* ------------------------------------------------------------------ */ 8236 static void decCheckInexact(const decNumber *dn, decContext *set) { 8237 #if !DECSUBSET && DECEXTFLAG 8238 if ((set->status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact 8239 && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) { 8240 #if DECTRACE || DECVERB 8241 printf("Insufficient digits [%ld] on normal Inexact result.\n", 8242 (LI)dn->digits); 8243 decNumberShow(dn); 8244 #endif 8245 decContextSetStatus(set, DEC_Invalid_operation); 8246 } 8247 #else 8248 /* next is a noop for quiet compiler */ 8249 if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation; 8250 #endif 8251 return; 8252 } /* decCheckInexact */ 8253 #endif 8254 8255 #if DECALLOC 8256 #undef malloc 8257 #undef free 8258 /* ------------------------------------------------------------------ */ 8259 /* decMalloc -- accountable allocation routine */ 8260 /* n is the number of bytes to allocate */ 8261 /* */ 8262 /* Semantics is the same as the stdlib malloc routine, but bytes */ 8263 /* allocated are accounted for globally, and corruption fences are */ 8264 /* added before and after the 'actual' storage. */ 8265 /* ------------------------------------------------------------------ */ 8266 /* This routine allocates storage with an extra twelve bytes; 8 are */ 8267 /* at the start and hold: */ 8268 /* 0-3 the original length requested */ 8269 /* 4-7 buffer corruption detection fence (DECFENCE, x4) */ 8270 /* The 4 bytes at the end also hold a corruption fence (DECFENCE, x4) */ 8271 /* ------------------------------------------------------------------ */ 8272 static void *decMalloc(size_t n) { 8273 uInt size=n+12; /* true size */ 8274 void *alloc; /* -> allocated storage */ 8275 uInt *j; /* work */ 8276 uByte *b, *b0; /* .. */ 8277 8278 alloc=malloc(size); /* -> allocated storage */ 8279 if (alloc==NULL) return NULL; /* out of strorage */ 8280 b0=(uByte *)alloc; /* as bytes */ 8281 decAllocBytes+=n; /* account for storage */ 8282 j=(uInt *)alloc; /* -> first four bytes */ 8283 *j=n; /* save n */ 8284 /* printf(" alloc ++ dAB: %ld (%d)\n", decAllocBytes, n); */ 8285 for (b=b0+4; b<b0+8; b++) *b=DECFENCE; 8286 for (b=b0+n+8; b<b0+n+12; b++) *b=DECFENCE; 8287 return b0+8; /* -> play area */ 8288 } /* decMalloc */ 8289 8290 /* ------------------------------------------------------------------ */ 8291 /* decFree -- accountable free routine */ 8292 /* alloc is the storage to free */ 8293 /* */ 8294 /* Semantics is the same as the stdlib malloc routine, except that */ 8295 /* the global storage accounting is updated and the fences are */ 8296 /* checked to ensure that no routine has written 'out of bounds'. */ 8297 /* ------------------------------------------------------------------ */ 8298 /* This routine first checks that the fences have not been corrupted. */ 8299 /* It then frees the storage using the 'truw' storage address (that */ 8300 /* is, offset by 8). */ 8301 /* ------------------------------------------------------------------ */ 8302 static void decFree(void *alloc) { 8303 uInt *j, n; /* pointer, original length */ 8304 uByte *b, *b0; /* work */ 8305 8306 if (alloc==NULL) return; /* allowed; it's a nop */ 8307 b0=(uByte *)alloc; /* as bytes */ 8308 b0-=8; /* -> true start of storage */ 8309 j=(uInt *)b0; /* -> first four bytes */ 8310 n=*j; /* lift */ 8311 for (b=b0+4; b<b0+8; b++) if (*b!=DECFENCE) 8312 printf("=== Corrupt byte [%02x] at offset %d from %ld ===\n", *b, 8313 b-b0-8, (Int)b0); 8314 for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE) 8315 printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b, 8316 b-b0-8, (Int)b0, n); 8317 free(b0); /* drop the storage */ 8318 decAllocBytes-=n; /* account for storage */ 8319 /* printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n); */ 8320 } /* decFree */ 8321 #define malloc(a) decMalloc(a) 8322 #define free(a) decFree(a) 8323 #endif 8324