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 "libdecnumber/dconfig.h" 171 #include "libdecnumber/decNumber.h" 172 #include "libdecnumber/decNumberLocal.h" 173 174 /* Constants */ 175 /* Public lookup table used by the D2U macro */ 176 const uByte d2utable[DECMAXD2U+1]=D2UTABLE; 177 178 #define DECVERB 1 /* set to 1 for verbose DECCHECK */ 179 #define powers DECPOWERS /* old internal name */ 180 181 /* Local constants */ 182 #define DIVIDE 0x80 /* Divide operators */ 183 #define REMAINDER 0x40 /* .. */ 184 #define DIVIDEINT 0x20 /* .. */ 185 #define REMNEAR 0x10 /* .. */ 186 #define COMPARE 0x01 /* Compare operators */ 187 #define COMPMAX 0x02 /* .. */ 188 #define COMPMIN 0x03 /* .. */ 189 #define COMPTOTAL 0x04 /* .. */ 190 #define COMPNAN 0x05 /* .. [NaN processing] */ 191 #define COMPSIG 0x06 /* .. [signaling COMPARE] */ 192 #define COMPMAXMAG 0x07 /* .. */ 193 #define COMPMINMAG 0x08 /* .. */ 194 195 #define DEC_sNaN 0x40000000 /* local status: sNaN signal */ 196 #define BADINT (Int)0x80000000 /* most-negative Int; error indicator */ 197 /* Next two indicate an integer >= 10**6, and its parity (bottom bit) */ 198 #define BIGEVEN (Int)0x80000002 199 #define BIGODD (Int)0x80000003 200 201 static Unit uarrone[1]={1}; /* Unit array of 1, used for incrementing */ 202 203 /* Granularity-dependent code */ 204 #if DECDPUN<=4 205 #define eInt Int /* extended integer */ 206 #define ueInt uInt /* unsigned extended integer */ 207 /* Constant multipliers for divide-by-power-of five using reciprocal */ 208 /* multiply, after removing powers of 2 by shifting, and final shift */ 209 /* of 17 [we only need up to **4] */ 210 static const uInt multies[]={131073, 26215, 5243, 1049, 210}; 211 /* QUOT10 -- macro to return the quotient of unit u divided by 10**n */ 212 #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) 213 #else 214 /* For DECDPUN>4 non-ANSI-89 64-bit types are needed. */ 215 #if !DECUSE64 216 #error decNumber.c: DECUSE64 must be 1 when DECDPUN>4 217 #endif 218 #define eInt Long /* extended integer */ 219 #define ueInt uLong /* unsigned extended integer */ 220 #endif 221 222 /* Local routines */ 223 static decNumber * decAddOp(decNumber *, const decNumber *, const decNumber *, 224 decContext *, uByte, uInt *); 225 static Flag decBiStr(const char *, const char *, const char *); 226 static uInt decCheckMath(const decNumber *, decContext *, uInt *); 227 static void decApplyRound(decNumber *, decContext *, Int, uInt *); 228 static Int decCompare(const decNumber *lhs, const decNumber *rhs, Flag); 229 static decNumber * decCompareOp(decNumber *, const decNumber *, 230 const decNumber *, decContext *, 231 Flag, uInt *); 232 static void decCopyFit(decNumber *, const decNumber *, decContext *, 233 Int *, uInt *); 234 static decNumber * decDecap(decNumber *, Int); 235 static decNumber * decDivideOp(decNumber *, const decNumber *, 236 const decNumber *, decContext *, Flag, uInt *); 237 static decNumber * decExpOp(decNumber *, const decNumber *, 238 decContext *, uInt *); 239 static void decFinalize(decNumber *, decContext *, Int *, uInt *); 240 static Int decGetDigits(Unit *, Int); 241 static Int decGetInt(const decNumber *); 242 static decNumber * decLnOp(decNumber *, const decNumber *, 243 decContext *, uInt *); 244 static decNumber * decMultiplyOp(decNumber *, const decNumber *, 245 const decNumber *, decContext *, 246 uInt *); 247 static decNumber * decNaNs(decNumber *, const decNumber *, 248 const decNumber *, decContext *, uInt *); 249 static decNumber * decQuantizeOp(decNumber *, const decNumber *, 250 const decNumber *, decContext *, Flag, 251 uInt *); 252 static void decReverse(Unit *, Unit *); 253 static void decSetCoeff(decNumber *, decContext *, const Unit *, 254 Int, Int *, uInt *); 255 static void decSetMaxValue(decNumber *, decContext *); 256 static void decSetOverflow(decNumber *, decContext *, uInt *); 257 static void decSetSubnormal(decNumber *, decContext *, Int *, uInt *); 258 static Int decShiftToLeast(Unit *, Int, Int); 259 static Int decShiftToMost(Unit *, Int, Int); 260 static void decStatus(decNumber *, uInt, decContext *); 261 static void decToString(const decNumber *, char[], Flag); 262 static decNumber * decTrim(decNumber *, decContext *, Flag, Int *); 263 static Int decUnitAddSub(const Unit *, Int, const Unit *, Int, Int, 264 Unit *, Int); 265 static Int decUnitCompare(const Unit *, Int, const Unit *, Int, Int); 266 267 #if !DECSUBSET 268 /* decFinish == decFinalize when no subset arithmetic needed */ 269 #define decFinish(a,b,c,d) decFinalize(a,b,c,d) 270 #else 271 static void decFinish(decNumber *, decContext *, Int *, uInt *); 272 static decNumber * decRoundOperand(const decNumber *, decContext *, uInt *); 273 #endif 274 275 /* Local macros */ 276 /* masked special-values bits */ 277 #define SPECIALARG (rhs->bits & DECSPECIAL) 278 #define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL) 279 280 /* Diagnostic macros, etc. */ 281 #if DECALLOC 282 /* Handle malloc/free accounting. If enabled, our accountable routines */ 283 /* are used; otherwise the code just goes straight to the system malloc */ 284 /* and free routines. */ 285 #define malloc(a) decMalloc(a) 286 #define free(a) decFree(a) 287 #define DECFENCE 0x5a /* corruption detector */ 288 /* 'Our' malloc and free: */ 289 static void *decMalloc(size_t); 290 static void decFree(void *); 291 uInt decAllocBytes=0; /* count of bytes allocated */ 292 /* Note that DECALLOC code only checks for storage buffer overflow. */ 293 /* To check for memory leaks, the decAllocBytes variable must be */ 294 /* checked to be 0 at appropriate times (e.g., after the test */ 295 /* harness completes a set of tests). This checking may be unreliable */ 296 /* if the testing is done in a multi-thread environment. */ 297 #endif 298 299 #if DECCHECK 300 /* Optional checking routines. Enabling these means that decNumber */ 301 /* and decContext operands to operator routines are checked for */ 302 /* correctness. This roughly doubles the execution time of the */ 303 /* fastest routines (and adds 600+ bytes), so should not normally be */ 304 /* used in 'production'. */ 305 /* decCheckInexact is used to check that inexact results have a full */ 306 /* complement of digits (where appropriate -- this is not the case */ 307 /* for Quantize, for example) */ 308 #define DECUNRESU ((decNumber *)(void *)0xffffffff) 309 #define DECUNUSED ((const decNumber *)(void *)0xffffffff) 310 #define DECUNCONT ((decContext *)(void *)(0xffffffff)) 311 static Flag decCheckOperands(decNumber *, const decNumber *, 312 const decNumber *, decContext *); 313 static Flag decCheckNumber(const decNumber *); 314 static void decCheckInexact(const decNumber *, decContext *); 315 #endif 316 317 #if DECTRACE || DECCHECK 318 /* Optional trace/debugging routines (may or may not be used) */ 319 void decNumberShow(const decNumber *); /* displays the components of a number */ 320 static void decDumpAr(char, const Unit *, Int); 321 #endif 322 323 /* ================================================================== */ 324 /* Conversions */ 325 /* ================================================================== */ 326 327 /* ------------------------------------------------------------------ */ 328 /* from-int32 -- conversion from Int or uInt */ 329 /* */ 330 /* dn is the decNumber to receive the integer */ 331 /* in or uin is the integer to be converted */ 332 /* returns dn */ 333 /* */ 334 /* No error is possible. */ 335 /* ------------------------------------------------------------------ */ 336 decNumber * decNumberFromInt32(decNumber *dn, Int in) { 337 uInt unsig; 338 if (in>=0) unsig=in; 339 else { /* negative (possibly BADINT) */ 340 if (in==BADINT) unsig=(uInt)1073741824*2; /* special case */ 341 else unsig=-in; /* invert */ 342 } 343 /* in is now positive */ 344 decNumberFromUInt32(dn, unsig); 345 if (in<0) dn->bits=DECNEG; /* sign needed */ 346 return dn; 347 } /* decNumberFromInt32 */ 348 349 decNumber * decNumberFromUInt32(decNumber *dn, uInt uin) { 350 Unit *up; /* work pointer */ 351 decNumberZero(dn); /* clean */ 352 if (uin==0) return dn; /* [or decGetDigits bad call] */ 353 for (up=dn->lsu; uin>0; up++) { 354 *up=(Unit)(uin%(DECDPUNMAX+1)); 355 uin=uin/(DECDPUNMAX+1); 356 } 357 dn->digits=decGetDigits(dn->lsu, up-dn->lsu); 358 return dn; 359 } /* decNumberFromUInt32 */ 360 361 /* ------------------------------------------------------------------ */ 362 /* to-int32 -- conversion to Int or uInt */ 363 /* */ 364 /* dn is the decNumber to convert */ 365 /* set is the context for reporting errors */ 366 /* returns the converted decNumber, or 0 if Invalid is set */ 367 /* */ 368 /* Invalid is set if the decNumber does not have exponent==0 or if */ 369 /* it is a NaN, Infinite, or out-of-range. */ 370 /* ------------------------------------------------------------------ */ 371 Int decNumberToInt32(const decNumber *dn, decContext *set) { 372 #if DECCHECK 373 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; 374 #endif 375 376 /* special or too many digits, or bad exponent */ 377 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; /* bad */ 378 else { /* is a finite integer with 10 or fewer digits */ 379 Int d; /* work */ 380 const Unit *up; /* .. */ 381 uInt hi=0, lo; /* .. */ 382 up=dn->lsu; /* -> lsu */ 383 lo=*up; /* get 1 to 9 digits */ 384 #if DECDPUN>1 /* split to higher */ 385 hi=lo/10; 386 lo=lo%10; 387 #endif 388 up++; 389 /* collect remaining Units, if any, into hi */ 390 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1]; 391 /* now low has the lsd, hi the remainder */ 392 if (hi>214748364 || (hi==214748364 && lo>7)) { /* out of range? */ 393 /* most-negative is a reprieve */ 394 if (dn->bits&DECNEG && hi==214748364 && lo==8) return 0x80000000; 395 /* bad -- drop through */ 396 } 397 else { /* in-range always */ 398 Int i=X10(hi)+lo; 399 if (dn->bits&DECNEG) return -i; 400 return i; 401 } 402 } /* integer */ 403 decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */ 404 return 0; 405 } /* decNumberToInt32 */ 406 407 uInt decNumberToUInt32(const decNumber *dn, decContext *set) { 408 #if DECCHECK 409 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; 410 #endif 411 /* special or too many digits, or bad exponent, or negative (<0) */ 412 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0 413 || (dn->bits&DECNEG && !ISZERO(dn))); /* bad */ 414 else { /* is a finite integer with 10 or fewer digits */ 415 Int d; /* work */ 416 const Unit *up; /* .. */ 417 uInt hi=0, lo; /* .. */ 418 up=dn->lsu; /* -> lsu */ 419 lo=*up; /* get 1 to 9 digits */ 420 #if DECDPUN>1 /* split to higher */ 421 hi=lo/10; 422 lo=lo%10; 423 #endif 424 up++; 425 /* collect remaining Units, if any, into hi */ 426 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1]; 427 428 /* now low has the lsd, hi the remainder */ 429 if (hi>429496729 || (hi==429496729 && lo>5)) ; /* no reprieve possible */ 430 else return X10(hi)+lo; 431 } /* integer */ 432 decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */ 433 return 0; 434 } /* decNumberToUInt32 */ 435 436 decNumber *decNumberFromInt64(decNumber *dn, int64_t in) 437 { 438 uint64_t unsig = in; 439 if (in < 0) { 440 unsig = -unsig; 441 } 442 443 decNumberFromUInt64(dn, unsig); 444 if (in < 0) { 445 dn->bits = DECNEG; /* sign needed */ 446 } 447 return dn; 448 } /* decNumberFromInt64 */ 449 450 decNumber *decNumberFromUInt64(decNumber *dn, uint64_t uin) 451 { 452 Unit *up; /* work pointer */ 453 decNumberZero(dn); /* clean */ 454 if (uin == 0) { 455 return dn; /* [or decGetDigits bad call] */ 456 } 457 for (up = dn->lsu; uin > 0; up++) { 458 *up = (Unit)(uin % (DECDPUNMAX + 1)); 459 uin = uin / (DECDPUNMAX + 1); 460 } 461 dn->digits = decGetDigits(dn->lsu, up-dn->lsu); 462 return dn; 463 } /* decNumberFromUInt64 */ 464 465 /* ------------------------------------------------------------------ */ 466 /* to-int64 -- conversion to int64 */ 467 /* */ 468 /* dn is the decNumber to convert. dn is assumed to have been */ 469 /* rounded to a floating point integer value. */ 470 /* set is the context for reporting errors */ 471 /* returns the converted decNumber, or 0 if Invalid is set */ 472 /* */ 473 /* Invalid is set if the decNumber is a NaN, Infinite or is out of */ 474 /* range for a signed 64 bit integer. */ 475 /* ------------------------------------------------------------------ */ 476 477 int64_t decNumberIntegralToInt64(const decNumber *dn, decContext *set) 478 { 479 if (decNumberIsSpecial(dn) || (dn->exponent < 0) || 480 (dn->digits + dn->exponent > 19)) { 481 goto Invalid; 482 } else { 483 int64_t d; /* work */ 484 const Unit *up; /* .. */ 485 uint64_t hi = 0; 486 up = dn->lsu; /* -> lsu */ 487 488 for (d = 1; d <= dn->digits; up++, d += DECDPUN) { 489 uint64_t prev = hi; 490 hi += *up * powers[d-1]; 491 if ((hi < prev) || (hi > INT64_MAX)) { 492 goto Invalid; 493 } 494 } 495 496 uint64_t prev = hi; 497 hi *= (uint64_t)powers[dn->exponent]; 498 if ((hi < prev) || (hi > INT64_MAX)) { 499 goto Invalid; 500 } 501 return (decNumberIsNegative(dn)) ? -((int64_t)hi) : (int64_t)hi; 502 } 503 504 Invalid: 505 decContextSetStatus(set, DEC_Invalid_operation); 506 return 0; 507 } /* decNumberIntegralToInt64 */ 508 509 510 /* ------------------------------------------------------------------ */ 511 /* to-scientific-string -- conversion to numeric string */ 512 /* to-engineering-string -- conversion to numeric string */ 513 /* */ 514 /* decNumberToString(dn, string); */ 515 /* decNumberToEngString(dn, string); */ 516 /* */ 517 /* dn is the decNumber to convert */ 518 /* string is the string where the result will be laid out */ 519 /* */ 520 /* string must be at least dn->digits+14 characters long */ 521 /* */ 522 /* No error is possible, and no status can be set. */ 523 /* ------------------------------------------------------------------ */ 524 char * decNumberToString(const decNumber *dn, char *string){ 525 decToString(dn, string, 0); 526 return string; 527 } /* DecNumberToString */ 528 529 char * decNumberToEngString(const decNumber *dn, char *string){ 530 decToString(dn, string, 1); 531 return string; 532 } /* DecNumberToEngString */ 533 534 /* ------------------------------------------------------------------ */ 535 /* to-number -- conversion from numeric string */ 536 /* */ 537 /* decNumberFromString -- convert string to decNumber */ 538 /* dn -- the number structure to fill */ 539 /* chars[] -- the string to convert ('\0' terminated) */ 540 /* set -- the context used for processing any error, */ 541 /* determining the maximum precision available */ 542 /* (set.digits), determining the maximum and minimum */ 543 /* exponent (set.emax and set.emin), determining if */ 544 /* extended values are allowed, and checking the */ 545 /* rounding mode if overflow occurs or rounding is */ 546 /* needed. */ 547 /* */ 548 /* The length of the coefficient and the size of the exponent are */ 549 /* checked by this routine, so the correct error (Underflow or */ 550 /* Overflow) can be reported or rounding applied, as necessary. */ 551 /* */ 552 /* If bad syntax is detected, the result will be a quiet NaN. */ 553 /* ------------------------------------------------------------------ */ 554 decNumber * decNumberFromString(decNumber *dn, const char chars[], 555 decContext *set) { 556 Int exponent=0; /* working exponent [assume 0] */ 557 uByte bits=0; /* working flags [assume +ve] */ 558 Unit *res; /* where result will be built */ 559 Unit resbuff[SD2U(DECBUFFER+9)];/* local buffer in case need temporary */ 560 /* [+9 allows for ln() constants] */ 561 Unit *allocres=NULL; /* -> allocated result, iff allocated */ 562 Int d=0; /* count of digits found in decimal part */ 563 const char *dotchar=NULL; /* where dot was found */ 564 const char *cfirst=chars; /* -> first character of decimal part */ 565 const char *last=NULL; /* -> last digit of decimal part */ 566 const char *c; /* work */ 567 Unit *up; /* .. */ 568 #if DECDPUN>1 569 Int cut, out; /* .. */ 570 #endif 571 Int residue; /* rounding residue */ 572 uInt status=0; /* error code */ 573 574 #if DECCHECK 575 if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set)) 576 return decNumberZero(dn); 577 #endif 578 579 do { /* status & malloc protection */ 580 for (c=chars;; c++) { /* -> input character */ 581 if (*c>='0' && *c<='9') { /* test for Arabic digit */ 582 last=c; 583 d++; /* count of real digits */ 584 continue; /* still in decimal part */ 585 } 586 if (*c=='.' && dotchar==NULL) { /* first '.' */ 587 dotchar=c; /* record offset into decimal part */ 588 if (c==cfirst) cfirst++; /* first digit must follow */ 589 continue;} 590 if (c==chars) { /* first in string... */ 591 if (*c=='-') { /* valid - sign */ 592 cfirst++; 593 bits=DECNEG; 594 continue;} 595 if (*c=='+') { /* valid + sign */ 596 cfirst++; 597 continue;} 598 } 599 /* *c is not a digit, or a valid +, -, or '.' */ 600 break; 601 } /* c */ 602 603 if (last==NULL) { /* no digits yet */ 604 status=DEC_Conversion_syntax;/* assume the worst */ 605 if (*c=='\0') break; /* and no more to come... */ 606 #if DECSUBSET 607 /* if subset then infinities and NaNs are not allowed */ 608 if (!set->extended) break; /* hopeless */ 609 #endif 610 /* Infinities and NaNs are possible, here */ 611 if (dotchar!=NULL) break; /* .. unless had a dot */ 612 decNumberZero(dn); /* be optimistic */ 613 if (decBiStr(c, "infinity", "INFINITY") 614 || decBiStr(c, "inf", "INF")) { 615 dn->bits=bits | DECINF; 616 status=0; /* is OK */ 617 break; /* all done */ 618 } 619 /* a NaN expected */ 620 /* 2003.09.10 NaNs are now permitted to have a sign */ 621 dn->bits=bits | DECNAN; /* assume simple NaN */ 622 if (*c=='s' || *c=='S') { /* looks like an sNaN */ 623 c++; 624 dn->bits=bits | DECSNAN; 625 } 626 if (*c!='n' && *c!='N') break; /* check caseless "NaN" */ 627 c++; 628 if (*c!='a' && *c!='A') break; /* .. */ 629 c++; 630 if (*c!='n' && *c!='N') break; /* .. */ 631 c++; 632 /* now either nothing, or nnnn payload, expected */ 633 /* -> start of integer and skip leading 0s [including plain 0] */ 634 for (cfirst=c; *cfirst=='0';) cfirst++; 635 if (*cfirst=='\0') { /* "NaN" or "sNaN", maybe with all 0s */ 636 status=0; /* it's good */ 637 break; /* .. */ 638 } 639 /* something other than 0s; setup last and d as usual [no dots] */ 640 for (c=cfirst;; c++, d++) { 641 if (*c<'0' || *c>'9') break; /* test for Arabic digit */ 642 last=c; 643 } 644 if (*c!='\0') break; /* not all digits */ 645 if (d>set->digits-1) { 646 /* [NB: payload in a decNumber can be full length unless */ 647 /* clamped, in which case can only be digits-1] */ 648 if (set->clamp) break; 649 if (d>set->digits) break; 650 } /* too many digits? */ 651 /* good; drop through to convert the integer to coefficient */ 652 status=0; /* syntax is OK */ 653 bits=dn->bits; /* for copy-back */ 654 } /* last==NULL */ 655 656 else if (*c!='\0') { /* more to process... */ 657 /* had some digits; exponent is only valid sequence now */ 658 Flag nege; /* 1=negative exponent */ 659 const char *firstexp; /* -> first significant exponent digit */ 660 status=DEC_Conversion_syntax;/* assume the worst */ 661 if (*c!='e' && *c!='E') break; 662 /* Found 'e' or 'E' -- now process explicit exponent */ 663 /* 1998.07.11: sign no longer required */ 664 nege=0; 665 c++; /* to (possible) sign */ 666 if (*c=='-') {nege=1; c++;} 667 else if (*c=='+') c++; 668 if (*c=='\0') break; 669 670 for (; *c=='0' && *(c+1)!='\0';) c++; /* strip insignificant zeros */ 671 firstexp=c; /* save exponent digit place */ 672 for (; ;c++) { 673 if (*c<'0' || *c>'9') break; /* not a digit */ 674 exponent=X10(exponent)+(Int)*c-(Int)'0'; 675 } /* c */ 676 /* if not now on a '\0', *c must not be a digit */ 677 if (*c!='\0') break; 678 679 /* (this next test must be after the syntax checks) */ 680 /* if it was too long the exponent may have wrapped, so check */ 681 /* carefully and set it to a certain overflow if wrap possible */ 682 if (c>=firstexp+9+1) { 683 if (c>firstexp+9+1 || *firstexp>'1') exponent=DECNUMMAXE*2; 684 /* [up to 1999999999 is OK, for example 1E-1000000998] */ 685 } 686 if (nege) exponent=-exponent; /* was negative */ 687 status=0; /* is OK */ 688 } /* stuff after digits */ 689 690 /* Here when whole string has been inspected; syntax is good */ 691 /* cfirst->first digit (never dot), last->last digit (ditto) */ 692 693 /* strip leading zeros/dot [leave final 0 if all 0's] */ 694 if (*cfirst=='0') { /* [cfirst has stepped over .] */ 695 for (c=cfirst; c<last; c++, cfirst++) { 696 if (*c=='.') continue; /* ignore dots */ 697 if (*c!='0') break; /* non-zero found */ 698 d--; /* 0 stripped */ 699 } /* c */ 700 #if DECSUBSET 701 /* make a rapid exit for easy zeros if !extended */ 702 if (*cfirst=='0' && !set->extended) { 703 decNumberZero(dn); /* clean result */ 704 break; /* [could be return] */ 705 } 706 #endif 707 } /* at least one leading 0 */ 708 709 /* Handle decimal point... */ 710 if (dotchar!=NULL && dotchar<last) /* non-trailing '.' found? */ 711 exponent-=(last-dotchar); /* adjust exponent */ 712 /* [we can now ignore the .] */ 713 714 /* OK, the digits string is good. Assemble in the decNumber, or in */ 715 /* a temporary units array if rounding is needed */ 716 if (d<=set->digits) res=dn->lsu; /* fits into supplied decNumber */ 717 else { /* rounding needed */ 718 Int needbytes=D2U(d)*sizeof(Unit);/* bytes needed */ 719 res=resbuff; /* assume use local buffer */ 720 if (needbytes>(Int)sizeof(resbuff)) { /* too big for local */ 721 allocres=(Unit *)malloc(needbytes); 722 if (allocres==NULL) {status|=DEC_Insufficient_storage; break;} 723 res=allocres; 724 } 725 } 726 /* res now -> number lsu, buffer, or allocated storage for Unit array */ 727 728 /* Place the coefficient into the selected Unit array */ 729 /* [this is often 70% of the cost of this function when DECDPUN>1] */ 730 #if DECDPUN>1 731 out=0; /* accumulator */ 732 up=res+D2U(d)-1; /* -> msu */ 733 cut=d-(up-res)*DECDPUN; /* digits in top unit */ 734 for (c=cfirst;; c++) { /* along the digits */ 735 if (*c=='.') continue; /* ignore '.' [don't decrement cut] */ 736 out=X10(out)+(Int)*c-(Int)'0'; 737 if (c==last) break; /* done [never get to trailing '.'] */ 738 cut--; 739 if (cut>0) continue; /* more for this unit */ 740 *up=(Unit)out; /* write unit */ 741 up--; /* prepare for unit below.. */ 742 cut=DECDPUN; /* .. */ 743 out=0; /* .. */ 744 } /* c */ 745 *up=(Unit)out; /* write lsu */ 746 747 #else 748 /* DECDPUN==1 */ 749 up=res; /* -> lsu */ 750 for (c=last; c>=cfirst; c--) { /* over each character, from least */ 751 if (*c=='.') continue; /* ignore . [don't step up] */ 752 *up=(Unit)((Int)*c-(Int)'0'); 753 up++; 754 } /* c */ 755 #endif 756 757 dn->bits=bits; 758 dn->exponent=exponent; 759 dn->digits=d; 760 761 /* if not in number (too long) shorten into the number */ 762 if (d>set->digits) { 763 residue=0; 764 decSetCoeff(dn, set, res, d, &residue, &status); 765 /* always check for overflow or subnormal and round as needed */ 766 decFinalize(dn, set, &residue, &status); 767 } 768 else { /* no rounding, but may still have overflow or subnormal */ 769 /* [these tests are just for performance; finalize repeats them] */ 770 if ((dn->exponent-1<set->emin-dn->digits) 771 || (dn->exponent-1>set->emax-set->digits)) { 772 residue=0; 773 decFinalize(dn, set, &residue, &status); 774 } 775 } 776 /* decNumberShow(dn); */ 777 } while(0); /* [for break] */ 778 779 if (allocres!=NULL) free(allocres); /* drop any storage used */ 780 if (status!=0) decStatus(dn, status, set); 781 return dn; 782 } /* decNumberFromString */ 783 784 /* ================================================================== */ 785 /* Operators */ 786 /* ================================================================== */ 787 788 /* ------------------------------------------------------------------ */ 789 /* decNumberAbs -- absolute value operator */ 790 /* */ 791 /* This computes C = abs(A) */ 792 /* */ 793 /* res is C, the result. C may be A */ 794 /* rhs is A */ 795 /* set is the context */ 796 /* */ 797 /* See also decNumberCopyAbs for a quiet bitwise version of this. */ 798 /* C must have space for set->digits digits. */ 799 /* ------------------------------------------------------------------ */ 800 /* This has the same effect as decNumberPlus unless A is negative, */ 801 /* in which case it has the same effect as decNumberMinus. */ 802 /* ------------------------------------------------------------------ */ 803 decNumber * decNumberAbs(decNumber *res, const decNumber *rhs, 804 decContext *set) { 805 decNumber dzero; /* for 0 */ 806 uInt status=0; /* accumulator */ 807 808 #if DECCHECK 809 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 810 #endif 811 812 decNumberZero(&dzero); /* set 0 */ 813 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */ 814 decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status); 815 if (status!=0) decStatus(res, status, set); 816 #if DECCHECK 817 decCheckInexact(res, set); 818 #endif 819 return res; 820 } /* decNumberAbs */ 821 822 /* ------------------------------------------------------------------ */ 823 /* decNumberAdd -- add two Numbers */ 824 /* */ 825 /* This computes C = A + B */ 826 /* */ 827 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */ 828 /* lhs is A */ 829 /* rhs is B */ 830 /* set is the context */ 831 /* */ 832 /* C must have space for set->digits digits. */ 833 /* ------------------------------------------------------------------ */ 834 /* This just calls the routine shared with Subtract */ 835 decNumber * decNumberAdd(decNumber *res, const decNumber *lhs, 836 const decNumber *rhs, decContext *set) { 837 uInt status=0; /* accumulator */ 838 decAddOp(res, lhs, rhs, set, 0, &status); 839 if (status!=0) decStatus(res, status, set); 840 #if DECCHECK 841 decCheckInexact(res, set); 842 #endif 843 return res; 844 } /* decNumberAdd */ 845 846 /* ------------------------------------------------------------------ */ 847 /* decNumberAnd -- AND two Numbers, digitwise */ 848 /* */ 849 /* This computes C = A & B */ 850 /* */ 851 /* res is C, the result. C may be A and/or B (e.g., X=X&X) */ 852 /* lhs is A */ 853 /* rhs is B */ 854 /* set is the context (used for result length and error report) */ 855 /* */ 856 /* C must have space for set->digits digits. */ 857 /* */ 858 /* Logical function restrictions apply (see above); a NaN is */ 859 /* returned with Invalid_operation if a restriction is violated. */ 860 /* ------------------------------------------------------------------ */ 861 decNumber * decNumberAnd(decNumber *res, const decNumber *lhs, 862 const decNumber *rhs, decContext *set) { 863 const Unit *ua, *ub; /* -> operands */ 864 const Unit *msua, *msub; /* -> operand msus */ 865 Unit *uc, *msuc; /* -> result and its msu */ 866 Int msudigs; /* digits in res msu */ 867 #if DECCHECK 868 if (decCheckOperands(res, lhs, rhs, set)) return res; 869 #endif 870 871 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs) 872 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { 873 decStatus(res, DEC_Invalid_operation, set); 874 return res; 875 } 876 877 /* operands are valid */ 878 ua=lhs->lsu; /* bottom-up */ 879 ub=rhs->lsu; /* .. */ 880 uc=res->lsu; /* .. */ 881 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */ 882 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ 883 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ 884 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ 885 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */ 886 Unit a, b; /* extract units */ 887 if (ua>msua) a=0; 888 else a=*ua; 889 if (ub>msub) b=0; 890 else b=*ub; 891 *uc=0; /* can now write back */ 892 if (a|b) { /* maybe 1 bits to examine */ 893 Int i, j; 894 *uc=0; /* can now write back */ 895 /* This loop could be unrolled and/or use BIN2BCD tables */ 896 for (i=0; i<DECDPUN; i++) { 897 if (a&b&1) *uc=*uc+(Unit)powers[i]; /* effect AND */ 898 j=a%10; 899 a=a/10; 900 j|=b%10; 901 b=b/10; 902 if (j>1) { 903 decStatus(res, DEC_Invalid_operation, set); 904 return res; 905 } 906 if (uc==msuc && i==msudigs-1) break; /* just did final digit */ 907 } /* each digit */ 908 } /* both OK */ 909 } /* each unit */ 910 /* [here uc-1 is the msu of the result] */ 911 res->digits=decGetDigits(res->lsu, uc-res->lsu); 912 res->exponent=0; /* integer */ 913 res->bits=0; /* sign=0 */ 914 return res; /* [no status to set] */ 915 } /* decNumberAnd */ 916 917 /* ------------------------------------------------------------------ */ 918 /* decNumberCompare -- compare two Numbers */ 919 /* */ 920 /* This computes C = A ? B */ 921 /* */ 922 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 923 /* lhs is A */ 924 /* rhs is B */ 925 /* set is the context */ 926 /* */ 927 /* C must have space for one digit (or NaN). */ 928 /* ------------------------------------------------------------------ */ 929 decNumber * decNumberCompare(decNumber *res, const decNumber *lhs, 930 const decNumber *rhs, decContext *set) { 931 uInt status=0; /* accumulator */ 932 decCompareOp(res, lhs, rhs, set, COMPARE, &status); 933 if (status!=0) decStatus(res, status, set); 934 return res; 935 } /* decNumberCompare */ 936 937 /* ------------------------------------------------------------------ */ 938 /* decNumberCompareSignal -- compare, signalling on all NaNs */ 939 /* */ 940 /* This computes C = A ? B */ 941 /* */ 942 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 943 /* lhs is A */ 944 /* rhs is B */ 945 /* set is the context */ 946 /* */ 947 /* C must have space for one digit (or NaN). */ 948 /* ------------------------------------------------------------------ */ 949 decNumber * decNumberCompareSignal(decNumber *res, const decNumber *lhs, 950 const decNumber *rhs, decContext *set) { 951 uInt status=0; /* accumulator */ 952 decCompareOp(res, lhs, rhs, set, COMPSIG, &status); 953 if (status!=0) decStatus(res, status, set); 954 return res; 955 } /* decNumberCompareSignal */ 956 957 /* ------------------------------------------------------------------ */ 958 /* decNumberCompareTotal -- compare two Numbers, using total ordering */ 959 /* */ 960 /* This computes C = A ? B, under total ordering */ 961 /* */ 962 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 963 /* lhs is A */ 964 /* rhs is B */ 965 /* set is the context */ 966 /* */ 967 /* C must have space for one digit; the result will always be one of */ 968 /* -1, 0, or 1. */ 969 /* ------------------------------------------------------------------ */ 970 decNumber * decNumberCompareTotal(decNumber *res, const decNumber *lhs, 971 const decNumber *rhs, decContext *set) { 972 uInt status=0; /* accumulator */ 973 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status); 974 if (status!=0) decStatus(res, status, set); 975 return res; 976 } /* decNumberCompareTotal */ 977 978 /* ------------------------------------------------------------------ */ 979 /* decNumberCompareTotalMag -- compare, total ordering of magnitudes */ 980 /* */ 981 /* This computes C = |A| ? |B|, under total ordering */ 982 /* */ 983 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 984 /* lhs is A */ 985 /* rhs is B */ 986 /* set is the context */ 987 /* */ 988 /* C must have space for one digit; the result will always be one of */ 989 /* -1, 0, or 1. */ 990 /* ------------------------------------------------------------------ */ 991 decNumber * decNumberCompareTotalMag(decNumber *res, const decNumber *lhs, 992 const decNumber *rhs, decContext *set) { 993 uInt status=0; /* accumulator */ 994 uInt needbytes; /* for space calculations */ 995 decNumber bufa[D2N(DECBUFFER+1)];/* +1 in case DECBUFFER=0 */ 996 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 997 decNumber bufb[D2N(DECBUFFER+1)]; 998 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */ 999 decNumber *a, *b; /* temporary pointers */ 1000 1001 #if DECCHECK 1002 if (decCheckOperands(res, lhs, rhs, set)) return res; 1003 #endif 1004 1005 do { /* protect allocated storage */ 1006 /* if either is negative, take a copy and absolute */ 1007 if (decNumberIsNegative(lhs)) { /* lhs<0 */ 1008 a=bufa; 1009 needbytes=sizeof(decNumber)+(D2U(lhs->digits)-1)*sizeof(Unit); 1010 if (needbytes>sizeof(bufa)) { /* need malloc space */ 1011 allocbufa=(decNumber *)malloc(needbytes); 1012 if (allocbufa==NULL) { /* hopeless -- abandon */ 1013 status|=DEC_Insufficient_storage; 1014 break;} 1015 a=allocbufa; /* use the allocated space */ 1016 } 1017 decNumberCopy(a, lhs); /* copy content */ 1018 a->bits&=~DECNEG; /* .. and clear the sign */ 1019 lhs=a; /* use copy from here on */ 1020 } 1021 if (decNumberIsNegative(rhs)) { /* rhs<0 */ 1022 b=bufb; 1023 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); 1024 if (needbytes>sizeof(bufb)) { /* need malloc space */ 1025 allocbufb=(decNumber *)malloc(needbytes); 1026 if (allocbufb==NULL) { /* hopeless -- abandon */ 1027 status|=DEC_Insufficient_storage; 1028 break;} 1029 b=allocbufb; /* use the allocated space */ 1030 } 1031 decNumberCopy(b, rhs); /* copy content */ 1032 b->bits&=~DECNEG; /* .. and clear the sign */ 1033 rhs=b; /* use copy from here on */ 1034 } 1035 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status); 1036 } while(0); /* end protected */ 1037 1038 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */ 1039 if (allocbufb!=NULL) free(allocbufb); /* .. */ 1040 if (status!=0) decStatus(res, status, set); 1041 return res; 1042 } /* decNumberCompareTotalMag */ 1043 1044 /* ------------------------------------------------------------------ */ 1045 /* decNumberDivide -- divide one number by another */ 1046 /* */ 1047 /* This computes C = A / B */ 1048 /* */ 1049 /* res is C, the result. C may be A and/or B (e.g., X=X/X) */ 1050 /* lhs is A */ 1051 /* rhs is B */ 1052 /* set is the context */ 1053 /* */ 1054 /* C must have space for set->digits digits. */ 1055 /* ------------------------------------------------------------------ */ 1056 decNumber * decNumberDivide(decNumber *res, const decNumber *lhs, 1057 const decNumber *rhs, decContext *set) { 1058 uInt status=0; /* accumulator */ 1059 decDivideOp(res, lhs, rhs, set, DIVIDE, &status); 1060 if (status!=0) decStatus(res, status, set); 1061 #if DECCHECK 1062 decCheckInexact(res, set); 1063 #endif 1064 return res; 1065 } /* decNumberDivide */ 1066 1067 /* ------------------------------------------------------------------ */ 1068 /* decNumberDivideInteger -- divide and return integer quotient */ 1069 /* */ 1070 /* This computes C = A # B, where # is the integer divide operator */ 1071 /* */ 1072 /* res is C, the result. C may be A and/or B (e.g., X=X#X) */ 1073 /* lhs is A */ 1074 /* rhs is B */ 1075 /* set is the context */ 1076 /* */ 1077 /* C must have space for set->digits digits. */ 1078 /* ------------------------------------------------------------------ */ 1079 decNumber * decNumberDivideInteger(decNumber *res, const decNumber *lhs, 1080 const decNumber *rhs, decContext *set) { 1081 uInt status=0; /* accumulator */ 1082 decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status); 1083 if (status!=0) decStatus(res, status, set); 1084 return res; 1085 } /* decNumberDivideInteger */ 1086 1087 /* ------------------------------------------------------------------ */ 1088 /* decNumberExp -- exponentiation */ 1089 /* */ 1090 /* This computes C = exp(A) */ 1091 /* */ 1092 /* res is C, the result. C may be A */ 1093 /* rhs is A */ 1094 /* set is the context; note that rounding mode has no effect */ 1095 /* */ 1096 /* C must have space for set->digits digits. */ 1097 /* */ 1098 /* Mathematical function restrictions apply (see above); a NaN is */ 1099 /* returned with Invalid_operation if a restriction is violated. */ 1100 /* */ 1101 /* Finite results will always be full precision and Inexact, except */ 1102 /* when A is a zero or -Infinity (giving 1 or 0 respectively). */ 1103 /* */ 1104 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */ 1105 /* almost always be correctly rounded, but may be up to 1 ulp in */ 1106 /* error in rare cases. */ 1107 /* ------------------------------------------------------------------ */ 1108 /* This is a wrapper for decExpOp which can handle the slightly wider */ 1109 /* (double) range needed by Ln (which has to be able to calculate */ 1110 /* exp(-a) where a can be the tiniest number (Ntiny). */ 1111 /* ------------------------------------------------------------------ */ 1112 decNumber * decNumberExp(decNumber *res, const decNumber *rhs, 1113 decContext *set) { 1114 uInt status=0; /* accumulator */ 1115 #if DECSUBSET 1116 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 1117 #endif 1118 1119 #if DECCHECK 1120 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1121 #endif 1122 1123 /* Check restrictions; these restrictions ensure that if h=8 (see */ 1124 /* decExpOp) then the result will either overflow or underflow to 0. */ 1125 /* Other math functions restrict the input range, too, for inverses. */ 1126 /* If not violated then carry out the operation. */ 1127 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */ 1128 #if DECSUBSET 1129 if (!set->extended) { 1130 /* reduce operand and set lostDigits status, as needed */ 1131 if (rhs->digits>set->digits) { 1132 allocrhs=decRoundOperand(rhs, set, &status); 1133 if (allocrhs==NULL) break; 1134 rhs=allocrhs; 1135 } 1136 } 1137 #endif 1138 decExpOp(res, rhs, set, &status); 1139 } while(0); /* end protected */ 1140 1141 #if DECSUBSET 1142 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */ 1143 #endif 1144 /* apply significant status */ 1145 if (status!=0) decStatus(res, status, set); 1146 #if DECCHECK 1147 decCheckInexact(res, set); 1148 #endif 1149 return res; 1150 } /* decNumberExp */ 1151 1152 /* ------------------------------------------------------------------ */ 1153 /* decNumberFMA -- fused multiply add */ 1154 /* */ 1155 /* This computes D = (A * B) + C with only one rounding */ 1156 /* */ 1157 /* res is D, the result. D may be A or B or C (e.g., X=FMA(X,X,X)) */ 1158 /* lhs is A */ 1159 /* rhs is B */ 1160 /* fhs is C [far hand side] */ 1161 /* set is the context */ 1162 /* */ 1163 /* Mathematical function restrictions apply (see above); a NaN is */ 1164 /* returned with Invalid_operation if a restriction is violated. */ 1165 /* */ 1166 /* C must have space for set->digits digits. */ 1167 /* ------------------------------------------------------------------ */ 1168 decNumber * decNumberFMA(decNumber *res, const decNumber *lhs, 1169 const decNumber *rhs, const decNumber *fhs, 1170 decContext *set) { 1171 uInt status=0; /* accumulator */ 1172 decContext dcmul; /* context for the multiplication */ 1173 uInt needbytes; /* for space calculations */ 1174 decNumber bufa[D2N(DECBUFFER*2+1)]; 1175 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 1176 decNumber *acc; /* accumulator pointer */ 1177 decNumber dzero; /* work */ 1178 1179 #if DECCHECK 1180 if (decCheckOperands(res, lhs, rhs, set)) return res; 1181 if (decCheckOperands(res, fhs, DECUNUSED, set)) return res; 1182 #endif 1183 1184 do { /* protect allocated storage */ 1185 #if DECSUBSET 1186 if (!set->extended) { /* [undefined if subset] */ 1187 status|=DEC_Invalid_operation; 1188 break;} 1189 #endif 1190 /* Check math restrictions [these ensure no overflow or underflow] */ 1191 if ((!decNumberIsSpecial(lhs) && decCheckMath(lhs, set, &status)) 1192 || (!decNumberIsSpecial(rhs) && decCheckMath(rhs, set, &status)) 1193 || (!decNumberIsSpecial(fhs) && decCheckMath(fhs, set, &status))) break; 1194 /* set up context for multiply */ 1195 dcmul=*set; 1196 dcmul.digits=lhs->digits+rhs->digits; /* just enough */ 1197 /* [The above may be an over-estimate for subset arithmetic, but that's OK] */ 1198 dcmul.emax=DEC_MAX_EMAX; /* effectively unbounded .. */ 1199 dcmul.emin=DEC_MIN_EMIN; /* [thanks to Math restrictions] */ 1200 /* set up decNumber space to receive the result of the multiply */ 1201 acc=bufa; /* may fit */ 1202 needbytes=sizeof(decNumber)+(D2U(dcmul.digits)-1)*sizeof(Unit); 1203 if (needbytes>sizeof(bufa)) { /* need malloc space */ 1204 allocbufa=(decNumber *)malloc(needbytes); 1205 if (allocbufa==NULL) { /* hopeless -- abandon */ 1206 status|=DEC_Insufficient_storage; 1207 break;} 1208 acc=allocbufa; /* use the allocated space */ 1209 } 1210 /* multiply with extended range and necessary precision */ 1211 /*printf("emin=%ld\n", dcmul.emin); */ 1212 decMultiplyOp(acc, lhs, rhs, &dcmul, &status); 1213 /* Only Invalid operation (from sNaN or Inf * 0) is possible in */ 1214 /* status; if either is seen than ignore fhs (in case it is */ 1215 /* another sNaN) and set acc to NaN unless we had an sNaN */ 1216 /* [decMultiplyOp leaves that to caller] */ 1217 /* Note sNaN has to go through addOp to shorten payload if */ 1218 /* necessary */ 1219 if ((status&DEC_Invalid_operation)!=0) { 1220 if (!(status&DEC_sNaN)) { /* but be true invalid */ 1221 decNumberZero(res); /* acc not yet set */ 1222 res->bits=DECNAN; 1223 break; 1224 } 1225 decNumberZero(&dzero); /* make 0 (any non-NaN would do) */ 1226 fhs=&dzero; /* use that */ 1227 } 1228 #if DECCHECK 1229 else { /* multiply was OK */ 1230 if (status!=0) printf("Status=%08lx after FMA multiply\n", status); 1231 } 1232 #endif 1233 /* add the third operand and result -> res, and all is done */ 1234 decAddOp(res, acc, fhs, set, 0, &status); 1235 } while(0); /* end protected */ 1236 1237 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */ 1238 if (status!=0) decStatus(res, status, set); 1239 #if DECCHECK 1240 decCheckInexact(res, set); 1241 #endif 1242 return res; 1243 } /* decNumberFMA */ 1244 1245 /* ------------------------------------------------------------------ */ 1246 /* decNumberInvert -- invert a Number, digitwise */ 1247 /* */ 1248 /* This computes C = ~A */ 1249 /* */ 1250 /* res is C, the result. C may be A (e.g., X=~X) */ 1251 /* rhs is A */ 1252 /* set is the context (used for result length and error report) */ 1253 /* */ 1254 /* C must have space for set->digits digits. */ 1255 /* */ 1256 /* Logical function restrictions apply (see above); a NaN is */ 1257 /* returned with Invalid_operation if a restriction is violated. */ 1258 /* ------------------------------------------------------------------ */ 1259 decNumber * decNumberInvert(decNumber *res, const decNumber *rhs, 1260 decContext *set) { 1261 const Unit *ua, *msua; /* -> operand and its msu */ 1262 Unit *uc, *msuc; /* -> result and its msu */ 1263 Int msudigs; /* digits in res msu */ 1264 #if DECCHECK 1265 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1266 #endif 1267 1268 if (rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { 1269 decStatus(res, DEC_Invalid_operation, set); 1270 return res; 1271 } 1272 /* operand is valid */ 1273 ua=rhs->lsu; /* bottom-up */ 1274 uc=res->lsu; /* .. */ 1275 msua=ua+D2U(rhs->digits)-1; /* -> msu of rhs */ 1276 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ 1277 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ 1278 for (; uc<=msuc; ua++, uc++) { /* Unit loop */ 1279 Unit a; /* extract unit */ 1280 Int i, j; /* work */ 1281 if (ua>msua) a=0; 1282 else a=*ua; 1283 *uc=0; /* can now write back */ 1284 /* always need to examine all bits in rhs */ 1285 /* This loop could be unrolled and/or use BIN2BCD tables */ 1286 for (i=0; i<DECDPUN; i++) { 1287 if ((~a)&1) *uc=*uc+(Unit)powers[i]; /* effect INVERT */ 1288 j=a%10; 1289 a=a/10; 1290 if (j>1) { 1291 decStatus(res, DEC_Invalid_operation, set); 1292 return res; 1293 } 1294 if (uc==msuc && i==msudigs-1) break; /* just did final digit */ 1295 } /* each digit */ 1296 } /* each unit */ 1297 /* [here uc-1 is the msu of the result] */ 1298 res->digits=decGetDigits(res->lsu, uc-res->lsu); 1299 res->exponent=0; /* integer */ 1300 res->bits=0; /* sign=0 */ 1301 return res; /* [no status to set] */ 1302 } /* decNumberInvert */ 1303 1304 /* ------------------------------------------------------------------ */ 1305 /* decNumberLn -- natural logarithm */ 1306 /* */ 1307 /* This computes C = ln(A) */ 1308 /* */ 1309 /* res is C, the result. C may be A */ 1310 /* rhs is A */ 1311 /* set is the context; note that rounding mode has no effect */ 1312 /* */ 1313 /* C must have space for set->digits digits. */ 1314 /* */ 1315 /* Notable cases: */ 1316 /* A<0 -> Invalid */ 1317 /* A=0 -> -Infinity (Exact) */ 1318 /* A=+Infinity -> +Infinity (Exact) */ 1319 /* A=1 exactly -> 0 (Exact) */ 1320 /* */ 1321 /* Mathematical function restrictions apply (see above); a NaN is */ 1322 /* returned with Invalid_operation if a restriction is violated. */ 1323 /* */ 1324 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */ 1325 /* almost always be correctly rounded, but may be up to 1 ulp in */ 1326 /* error in rare cases. */ 1327 /* ------------------------------------------------------------------ */ 1328 /* This is a wrapper for decLnOp which can handle the slightly wider */ 1329 /* (+11) range needed by Ln, Log10, etc. (which may have to be able */ 1330 /* to calculate at p+e+2). */ 1331 /* ------------------------------------------------------------------ */ 1332 decNumber * decNumberLn(decNumber *res, const decNumber *rhs, 1333 decContext *set) { 1334 uInt status=0; /* accumulator */ 1335 #if DECSUBSET 1336 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 1337 #endif 1338 1339 #if DECCHECK 1340 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1341 #endif 1342 1343 /* Check restrictions; this is a math function; if not violated */ 1344 /* then carry out the operation. */ 1345 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */ 1346 #if DECSUBSET 1347 if (!set->extended) { 1348 /* reduce operand and set lostDigits status, as needed */ 1349 if (rhs->digits>set->digits) { 1350 allocrhs=decRoundOperand(rhs, set, &status); 1351 if (allocrhs==NULL) break; 1352 rhs=allocrhs; 1353 } 1354 /* special check in subset for rhs=0 */ 1355 if (ISZERO(rhs)) { /* +/- zeros -> error */ 1356 status|=DEC_Invalid_operation; 1357 break;} 1358 } /* extended=0 */ 1359 #endif 1360 decLnOp(res, rhs, set, &status); 1361 } while(0); /* end protected */ 1362 1363 #if DECSUBSET 1364 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */ 1365 #endif 1366 /* apply significant status */ 1367 if (status!=0) decStatus(res, status, set); 1368 #if DECCHECK 1369 decCheckInexact(res, set); 1370 #endif 1371 return res; 1372 } /* decNumberLn */ 1373 1374 /* ------------------------------------------------------------------ */ 1375 /* decNumberLogB - get adjusted exponent, by 754r rules */ 1376 /* */ 1377 /* This computes C = adjustedexponent(A) */ 1378 /* */ 1379 /* res is C, the result. C may be A */ 1380 /* rhs is A */ 1381 /* set is the context, used only for digits and status */ 1382 /* */ 1383 /* C must have space for 10 digits (A might have 10**9 digits and */ 1384 /* an exponent of +999999999, or one digit and an exponent of */ 1385 /* -1999999999). */ 1386 /* */ 1387 /* This returns the adjusted exponent of A after (in theory) padding */ 1388 /* with zeros on the right to set->digits digits while keeping the */ 1389 /* same value. The exponent is not limited by emin/emax. */ 1390 /* */ 1391 /* Notable cases: */ 1392 /* A<0 -> Use |A| */ 1393 /* A=0 -> -Infinity (Division by zero) */ 1394 /* A=Infinite -> +Infinity (Exact) */ 1395 /* A=1 exactly -> 0 (Exact) */ 1396 /* NaNs are propagated as usual */ 1397 /* ------------------------------------------------------------------ */ 1398 decNumber * decNumberLogB(decNumber *res, const decNumber *rhs, 1399 decContext *set) { 1400 uInt status=0; /* accumulator */ 1401 1402 #if DECCHECK 1403 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1404 #endif 1405 1406 /* NaNs as usual; Infinities return +Infinity; 0->oops */ 1407 if (decNumberIsNaN(rhs)) decNaNs(res, rhs, NULL, set, &status); 1408 else if (decNumberIsInfinite(rhs)) decNumberCopyAbs(res, rhs); 1409 else if (decNumberIsZero(rhs)) { 1410 decNumberZero(res); /* prepare for Infinity */ 1411 res->bits=DECNEG|DECINF; /* -Infinity */ 1412 status|=DEC_Division_by_zero; /* as per 754r */ 1413 } 1414 else { /* finite non-zero */ 1415 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */ 1416 decNumberFromInt32(res, ae); /* lay it out */ 1417 } 1418 1419 if (status!=0) decStatus(res, status, set); 1420 return res; 1421 } /* decNumberLogB */ 1422 1423 /* ------------------------------------------------------------------ */ 1424 /* decNumberLog10 -- logarithm in base 10 */ 1425 /* */ 1426 /* This computes C = log10(A) */ 1427 /* */ 1428 /* res is C, the result. C may be A */ 1429 /* rhs is A */ 1430 /* set is the context; note that rounding mode has no effect */ 1431 /* */ 1432 /* C must have space for set->digits digits. */ 1433 /* */ 1434 /* Notable cases: */ 1435 /* A<0 -> Invalid */ 1436 /* A=0 -> -Infinity (Exact) */ 1437 /* A=+Infinity -> +Infinity (Exact) */ 1438 /* A=10**n (if n is an integer) -> n (Exact) */ 1439 /* */ 1440 /* Mathematical function restrictions apply (see above); a NaN is */ 1441 /* returned with Invalid_operation if a restriction is violated. */ 1442 /* */ 1443 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */ 1444 /* almost always be correctly rounded, but may be up to 1 ulp in */ 1445 /* error in rare cases. */ 1446 /* ------------------------------------------------------------------ */ 1447 /* This calculates ln(A)/ln(10) using appropriate precision. For */ 1448 /* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the */ 1449 /* requested digits and t is the number of digits in the exponent */ 1450 /* (maximum 6). For ln(10) it is p + 3; this is often handled by the */ 1451 /* fastpath in decLnOp. The final division is done to the requested */ 1452 /* precision. */ 1453 /* ------------------------------------------------------------------ */ 1454 decNumber * decNumberLog10(decNumber *res, const decNumber *rhs, 1455 decContext *set) { 1456 uInt status=0, ignore=0; /* status accumulators */ 1457 uInt needbytes; /* for space calculations */ 1458 Int p; /* working precision */ 1459 Int t; /* digits in exponent of A */ 1460 1461 /* buffers for a and b working decimals */ 1462 /* (adjustment calculator, same size) */ 1463 decNumber bufa[D2N(DECBUFFER+2)]; 1464 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 1465 decNumber *a=bufa; /* temporary a */ 1466 decNumber bufb[D2N(DECBUFFER+2)]; 1467 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */ 1468 decNumber *b=bufb; /* temporary b */ 1469 decNumber bufw[D2N(10)]; /* working 2-10 digit number */ 1470 decNumber *w=bufw; /* .. */ 1471 #if DECSUBSET 1472 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 1473 #endif 1474 1475 decContext aset; /* working context */ 1476 1477 #if DECCHECK 1478 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1479 #endif 1480 1481 /* Check restrictions; this is a math function; if not violated */ 1482 /* then carry out the operation. */ 1483 if (!decCheckMath(rhs, set, &status)) do { /* protect malloc */ 1484 #if DECSUBSET 1485 if (!set->extended) { 1486 /* reduce operand and set lostDigits status, as needed */ 1487 if (rhs->digits>set->digits) { 1488 allocrhs=decRoundOperand(rhs, set, &status); 1489 if (allocrhs==NULL) break; 1490 rhs=allocrhs; 1491 } 1492 /* special check in subset for rhs=0 */ 1493 if (ISZERO(rhs)) { /* +/- zeros -> error */ 1494 status|=DEC_Invalid_operation; 1495 break;} 1496 } /* extended=0 */ 1497 #endif 1498 1499 decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */ 1500 1501 /* handle exact powers of 10; only check if +ve finite */ 1502 if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) { 1503 Int residue=0; /* (no residue) */ 1504 uInt copystat=0; /* clean status */ 1505 1506 /* round to a single digit... */ 1507 aset.digits=1; 1508 decCopyFit(w, rhs, &aset, &residue, ©stat); /* copy & shorten */ 1509 /* if exact and the digit is 1, rhs is a power of 10 */ 1510 if (!(copystat&DEC_Inexact) && w->lsu[0]==1) { 1511 /* the exponent, conveniently, is the power of 10; making */ 1512 /* this the result needs a little care as it might not fit, */ 1513 /* so first convert it into the working number, and then move */ 1514 /* to res */ 1515 decNumberFromInt32(w, w->exponent); 1516 residue=0; 1517 decCopyFit(res, w, set, &residue, &status); /* copy & round */ 1518 decFinish(res, set, &residue, &status); /* cleanup/set flags */ 1519 break; 1520 } /* not a power of 10 */ 1521 } /* not a candidate for exact */ 1522 1523 /* simplify the information-content calculation to use 'total */ 1524 /* number of digits in a, including exponent' as compared to the */ 1525 /* requested digits, as increasing this will only rarely cost an */ 1526 /* iteration in ln(a) anyway */ 1527 t=6; /* it can never be >6 */ 1528 1529 /* allocate space when needed... */ 1530 p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3; 1531 needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit); 1532 if (needbytes>sizeof(bufa)) { /* need malloc space */ 1533 allocbufa=(decNumber *)malloc(needbytes); 1534 if (allocbufa==NULL) { /* hopeless -- abandon */ 1535 status|=DEC_Insufficient_storage; 1536 break;} 1537 a=allocbufa; /* use the allocated space */ 1538 } 1539 aset.digits=p; /* as calculated */ 1540 aset.emax=DEC_MAX_MATH; /* usual bounds */ 1541 aset.emin=-DEC_MAX_MATH; /* .. */ 1542 aset.clamp=0; /* and no concrete format */ 1543 decLnOp(a, rhs, &aset, &status); /* a=ln(rhs) */ 1544 1545 /* skip the division if the result so far is infinite, NaN, or */ 1546 /* zero, or there was an error; note NaN from sNaN needs copy */ 1547 if (status&DEC_NaNs && !(status&DEC_sNaN)) break; 1548 if (a->bits&DECSPECIAL || ISZERO(a)) { 1549 decNumberCopy(res, a); /* [will fit] */ 1550 break;} 1551 1552 /* for ln(10) an extra 3 digits of precision are needed */ 1553 p=set->digits+3; 1554 needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit); 1555 if (needbytes>sizeof(bufb)) { /* need malloc space */ 1556 allocbufb=(decNumber *)malloc(needbytes); 1557 if (allocbufb==NULL) { /* hopeless -- abandon */ 1558 status|=DEC_Insufficient_storage; 1559 break;} 1560 b=allocbufb; /* use the allocated space */ 1561 } 1562 decNumberZero(w); /* set up 10... */ 1563 #if DECDPUN==1 1564 w->lsu[1]=1; w->lsu[0]=0; /* .. */ 1565 #else 1566 w->lsu[0]=10; /* .. */ 1567 #endif 1568 w->digits=2; /* .. */ 1569 1570 aset.digits=p; 1571 decLnOp(b, w, &aset, &ignore); /* b=ln(10) */ 1572 1573 aset.digits=set->digits; /* for final divide */ 1574 decDivideOp(res, a, b, &aset, DIVIDE, &status); /* into result */ 1575 } while(0); /* [for break] */ 1576 1577 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */ 1578 if (allocbufb!=NULL) free(allocbufb); /* .. */ 1579 #if DECSUBSET 1580 if (allocrhs !=NULL) free(allocrhs); /* .. */ 1581 #endif 1582 /* apply significant status */ 1583 if (status!=0) decStatus(res, status, set); 1584 #if DECCHECK 1585 decCheckInexact(res, set); 1586 #endif 1587 return res; 1588 } /* decNumberLog10 */ 1589 1590 /* ------------------------------------------------------------------ */ 1591 /* decNumberMax -- compare two Numbers and return the maximum */ 1592 /* */ 1593 /* This computes C = A ? B, returning the maximum by 754R rules */ 1594 /* */ 1595 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1596 /* lhs is A */ 1597 /* rhs is B */ 1598 /* set is the context */ 1599 /* */ 1600 /* C must have space for set->digits digits. */ 1601 /* ------------------------------------------------------------------ */ 1602 decNumber * decNumberMax(decNumber *res, const decNumber *lhs, 1603 const decNumber *rhs, decContext *set) { 1604 uInt status=0; /* accumulator */ 1605 decCompareOp(res, lhs, rhs, set, COMPMAX, &status); 1606 if (status!=0) decStatus(res, status, set); 1607 #if DECCHECK 1608 decCheckInexact(res, set); 1609 #endif 1610 return res; 1611 } /* decNumberMax */ 1612 1613 /* ------------------------------------------------------------------ */ 1614 /* decNumberMaxMag -- compare and return the maximum by magnitude */ 1615 /* */ 1616 /* This computes C = A ? B, returning the maximum by 754R rules */ 1617 /* */ 1618 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1619 /* lhs is A */ 1620 /* rhs is B */ 1621 /* set is the context */ 1622 /* */ 1623 /* C must have space for set->digits digits. */ 1624 /* ------------------------------------------------------------------ */ 1625 decNumber * decNumberMaxMag(decNumber *res, const decNumber *lhs, 1626 const decNumber *rhs, decContext *set) { 1627 uInt status=0; /* accumulator */ 1628 decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status); 1629 if (status!=0) decStatus(res, status, set); 1630 #if DECCHECK 1631 decCheckInexact(res, set); 1632 #endif 1633 return res; 1634 } /* decNumberMaxMag */ 1635 1636 /* ------------------------------------------------------------------ */ 1637 /* decNumberMin -- compare two Numbers and return the minimum */ 1638 /* */ 1639 /* This computes C = A ? B, returning the minimum by 754R rules */ 1640 /* */ 1641 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1642 /* lhs is A */ 1643 /* rhs is B */ 1644 /* set is the context */ 1645 /* */ 1646 /* C must have space for set->digits digits. */ 1647 /* ------------------------------------------------------------------ */ 1648 decNumber * decNumberMin(decNumber *res, const decNumber *lhs, 1649 const decNumber *rhs, decContext *set) { 1650 uInt status=0; /* accumulator */ 1651 decCompareOp(res, lhs, rhs, set, COMPMIN, &status); 1652 if (status!=0) decStatus(res, status, set); 1653 #if DECCHECK 1654 decCheckInexact(res, set); 1655 #endif 1656 return res; 1657 } /* decNumberMin */ 1658 1659 /* ------------------------------------------------------------------ */ 1660 /* decNumberMinMag -- compare and return the minimum by magnitude */ 1661 /* */ 1662 /* This computes C = A ? B, returning the minimum by 754R rules */ 1663 /* */ 1664 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1665 /* lhs is A */ 1666 /* rhs is B */ 1667 /* set is the context */ 1668 /* */ 1669 /* C must have space for set->digits digits. */ 1670 /* ------------------------------------------------------------------ */ 1671 decNumber * decNumberMinMag(decNumber *res, const decNumber *lhs, 1672 const decNumber *rhs, decContext *set) { 1673 uInt status=0; /* accumulator */ 1674 decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status); 1675 if (status!=0) decStatus(res, status, set); 1676 #if DECCHECK 1677 decCheckInexact(res, set); 1678 #endif 1679 return res; 1680 } /* decNumberMinMag */ 1681 1682 /* ------------------------------------------------------------------ */ 1683 /* decNumberMinus -- prefix minus operator */ 1684 /* */ 1685 /* This computes C = 0 - A */ 1686 /* */ 1687 /* res is C, the result. C may be A */ 1688 /* rhs is A */ 1689 /* set is the context */ 1690 /* */ 1691 /* See also decNumberCopyNegate for a quiet bitwise version of this. */ 1692 /* C must have space for set->digits digits. */ 1693 /* ------------------------------------------------------------------ */ 1694 /* Simply use AddOp for the subtract, which will do the necessary. */ 1695 /* ------------------------------------------------------------------ */ 1696 decNumber * decNumberMinus(decNumber *res, const decNumber *rhs, 1697 decContext *set) { 1698 decNumber dzero; 1699 uInt status=0; /* accumulator */ 1700 1701 #if DECCHECK 1702 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1703 #endif 1704 1705 decNumberZero(&dzero); /* make 0 */ 1706 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */ 1707 decAddOp(res, &dzero, rhs, set, DECNEG, &status); 1708 if (status!=0) decStatus(res, status, set); 1709 #if DECCHECK 1710 decCheckInexact(res, set); 1711 #endif 1712 return res; 1713 } /* decNumberMinus */ 1714 1715 /* ------------------------------------------------------------------ */ 1716 /* decNumberNextMinus -- next towards -Infinity */ 1717 /* */ 1718 /* This computes C = A - infinitesimal, rounded towards -Infinity */ 1719 /* */ 1720 /* res is C, the result. C may be A */ 1721 /* rhs is A */ 1722 /* set is the context */ 1723 /* */ 1724 /* This is a generalization of 754r NextDown. */ 1725 /* ------------------------------------------------------------------ */ 1726 decNumber * decNumberNextMinus(decNumber *res, const decNumber *rhs, 1727 decContext *set) { 1728 decNumber dtiny; /* constant */ 1729 decContext workset=*set; /* work */ 1730 uInt status=0; /* accumulator */ 1731 #if DECCHECK 1732 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1733 #endif 1734 1735 /* +Infinity is the special case */ 1736 if ((rhs->bits&(DECINF|DECNEG))==DECINF) { 1737 decSetMaxValue(res, set); /* is +ve */ 1738 /* there is no status to set */ 1739 return res; 1740 } 1741 decNumberZero(&dtiny); /* start with 0 */ 1742 dtiny.lsu[0]=1; /* make number that is .. */ 1743 dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */ 1744 workset.round=DEC_ROUND_FLOOR; 1745 decAddOp(res, rhs, &dtiny, &workset, DECNEG, &status); 1746 status&=DEC_Invalid_operation|DEC_sNaN; /* only sNaN Invalid please */ 1747 if (status!=0) decStatus(res, status, set); 1748 return res; 1749 } /* decNumberNextMinus */ 1750 1751 /* ------------------------------------------------------------------ */ 1752 /* decNumberNextPlus -- next towards +Infinity */ 1753 /* */ 1754 /* This computes C = A + infinitesimal, rounded towards +Infinity */ 1755 /* */ 1756 /* res is C, the result. C may be A */ 1757 /* rhs is A */ 1758 /* set is the context */ 1759 /* */ 1760 /* This is a generalization of 754r NextUp. */ 1761 /* ------------------------------------------------------------------ */ 1762 decNumber * decNumberNextPlus(decNumber *res, const decNumber *rhs, 1763 decContext *set) { 1764 decNumber dtiny; /* constant */ 1765 decContext workset=*set; /* work */ 1766 uInt status=0; /* accumulator */ 1767 #if DECCHECK 1768 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1769 #endif 1770 1771 /* -Infinity is the special case */ 1772 if ((rhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) { 1773 decSetMaxValue(res, set); 1774 res->bits=DECNEG; /* negative */ 1775 /* there is no status to set */ 1776 return res; 1777 } 1778 decNumberZero(&dtiny); /* start with 0 */ 1779 dtiny.lsu[0]=1; /* make number that is .. */ 1780 dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */ 1781 workset.round=DEC_ROUND_CEILING; 1782 decAddOp(res, rhs, &dtiny, &workset, 0, &status); 1783 status&=DEC_Invalid_operation|DEC_sNaN; /* only sNaN Invalid please */ 1784 if (status!=0) decStatus(res, status, set); 1785 return res; 1786 } /* decNumberNextPlus */ 1787 1788 /* ------------------------------------------------------------------ */ 1789 /* decNumberNextToward -- next towards rhs */ 1790 /* */ 1791 /* This computes C = A +/- infinitesimal, rounded towards */ 1792 /* +/-Infinity in the direction of B, as per 754r nextafter rules */ 1793 /* */ 1794 /* res is C, the result. C may be A or B. */ 1795 /* lhs is A */ 1796 /* rhs is B */ 1797 /* set is the context */ 1798 /* */ 1799 /* This is a generalization of 754r NextAfter. */ 1800 /* ------------------------------------------------------------------ */ 1801 decNumber * decNumberNextToward(decNumber *res, const decNumber *lhs, 1802 const decNumber *rhs, decContext *set) { 1803 decNumber dtiny; /* constant */ 1804 decContext workset=*set; /* work */ 1805 Int result; /* .. */ 1806 uInt status=0; /* accumulator */ 1807 #if DECCHECK 1808 if (decCheckOperands(res, lhs, rhs, set)) return res; 1809 #endif 1810 1811 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { 1812 decNaNs(res, lhs, rhs, set, &status); 1813 } 1814 else { /* Is numeric, so no chance of sNaN Invalid, etc. */ 1815 result=decCompare(lhs, rhs, 0); /* sign matters */ 1816 if (result==BADINT) status|=DEC_Insufficient_storage; /* rare */ 1817 else { /* valid compare */ 1818 if (result==0) decNumberCopySign(res, lhs, rhs); /* easy */ 1819 else { /* differ: need NextPlus or NextMinus */ 1820 uByte sub; /* add or subtract */ 1821 if (result<0) { /* lhs<rhs, do nextplus */ 1822 /* -Infinity is the special case */ 1823 if ((lhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) { 1824 decSetMaxValue(res, set); 1825 res->bits=DECNEG; /* negative */ 1826 return res; /* there is no status to set */ 1827 } 1828 workset.round=DEC_ROUND_CEILING; 1829 sub=0; /* add, please */ 1830 } /* plus */ 1831 else { /* lhs>rhs, do nextminus */ 1832 /* +Infinity is the special case */ 1833 if ((lhs->bits&(DECINF|DECNEG))==DECINF) { 1834 decSetMaxValue(res, set); 1835 return res; /* there is no status to set */ 1836 } 1837 workset.round=DEC_ROUND_FLOOR; 1838 sub=DECNEG; /* subtract, please */ 1839 } /* minus */ 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 decAddOp(res, lhs, &dtiny, &workset, sub, &status); /* + or - */ 1844 /* turn off exceptions if the result is a normal number */ 1845 /* (including Nmin), otherwise let all status through */ 1846 if (decNumberIsNormal(res, set)) status=0; 1847 } /* unequal */ 1848 } /* compare OK */ 1849 } /* numeric */ 1850 if (status!=0) decStatus(res, status, set); 1851 return res; 1852 } /* decNumberNextToward */ 1853 1854 /* ------------------------------------------------------------------ */ 1855 /* decNumberOr -- OR two Numbers, digitwise */ 1856 /* */ 1857 /* This computes C = A | B */ 1858 /* */ 1859 /* res is C, the result. C may be A and/or B (e.g., X=X|X) */ 1860 /* lhs is A */ 1861 /* rhs is B */ 1862 /* set is the context (used for result length and error report) */ 1863 /* */ 1864 /* C must have space for set->digits digits. */ 1865 /* */ 1866 /* Logical function restrictions apply (see above); a NaN is */ 1867 /* returned with Invalid_operation if a restriction is violated. */ 1868 /* ------------------------------------------------------------------ */ 1869 decNumber * decNumberOr(decNumber *res, const decNumber *lhs, 1870 const decNumber *rhs, decContext *set) { 1871 const Unit *ua, *ub; /* -> operands */ 1872 const Unit *msua, *msub; /* -> operand msus */ 1873 Unit *uc, *msuc; /* -> result and its msu */ 1874 Int msudigs; /* digits in res msu */ 1875 #if DECCHECK 1876 if (decCheckOperands(res, lhs, rhs, set)) return res; 1877 #endif 1878 1879 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs) 1880 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { 1881 decStatus(res, DEC_Invalid_operation, set); 1882 return res; 1883 } 1884 /* operands are valid */ 1885 ua=lhs->lsu; /* bottom-up */ 1886 ub=rhs->lsu; /* .. */ 1887 uc=res->lsu; /* .. */ 1888 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */ 1889 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ 1890 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ 1891 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ 1892 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */ 1893 Unit a, b; /* extract units */ 1894 if (ua>msua) a=0; 1895 else a=*ua; 1896 if (ub>msub) b=0; 1897 else b=*ub; 1898 *uc=0; /* can now write back */ 1899 if (a|b) { /* maybe 1 bits to examine */ 1900 Int i, j; 1901 /* This loop could be unrolled and/or use BIN2BCD tables */ 1902 for (i=0; i<DECDPUN; i++) { 1903 if ((a|b)&1) *uc=*uc+(Unit)powers[i]; /* effect OR */ 1904 j=a%10; 1905 a=a/10; 1906 j|=b%10; 1907 b=b/10; 1908 if (j>1) { 1909 decStatus(res, DEC_Invalid_operation, set); 1910 return res; 1911 } 1912 if (uc==msuc && i==msudigs-1) break; /* just did final digit */ 1913 } /* each digit */ 1914 } /* non-zero */ 1915 } /* each unit */ 1916 /* [here uc-1 is the msu of the result] */ 1917 res->digits=decGetDigits(res->lsu, uc-res->lsu); 1918 res->exponent=0; /* integer */ 1919 res->bits=0; /* sign=0 */ 1920 return res; /* [no status to set] */ 1921 } /* decNumberOr */ 1922 1923 /* ------------------------------------------------------------------ */ 1924 /* decNumberPlus -- prefix plus operator */ 1925 /* */ 1926 /* This computes C = 0 + A */ 1927 /* */ 1928 /* res is C, the result. C may be A */ 1929 /* rhs is A */ 1930 /* set is the context */ 1931 /* */ 1932 /* See also decNumberCopy for a quiet bitwise version of this. */ 1933 /* C must have space for set->digits digits. */ 1934 /* ------------------------------------------------------------------ */ 1935 /* This simply uses AddOp; Add will take fast path after preparing A. */ 1936 /* Performance is a concern here, as this routine is often used to */ 1937 /* check operands and apply rounding and overflow/underflow testing. */ 1938 /* ------------------------------------------------------------------ */ 1939 decNumber * decNumberPlus(decNumber *res, const decNumber *rhs, 1940 decContext *set) { 1941 decNumber dzero; 1942 uInt status=0; /* accumulator */ 1943 #if DECCHECK 1944 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1945 #endif 1946 1947 decNumberZero(&dzero); /* make 0 */ 1948 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */ 1949 decAddOp(res, &dzero, rhs, set, 0, &status); 1950 if (status!=0) decStatus(res, status, set); 1951 #if DECCHECK 1952 decCheckInexact(res, set); 1953 #endif 1954 return res; 1955 } /* decNumberPlus */ 1956 1957 /* ------------------------------------------------------------------ */ 1958 /* decNumberMultiply -- multiply two Numbers */ 1959 /* */ 1960 /* This computes C = A x B */ 1961 /* */ 1962 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */ 1963 /* lhs is A */ 1964 /* rhs is B */ 1965 /* set is the context */ 1966 /* */ 1967 /* C must have space for set->digits digits. */ 1968 /* ------------------------------------------------------------------ */ 1969 decNumber * decNumberMultiply(decNumber *res, const decNumber *lhs, 1970 const decNumber *rhs, decContext *set) { 1971 uInt status=0; /* accumulator */ 1972 decMultiplyOp(res, lhs, rhs, set, &status); 1973 if (status!=0) decStatus(res, status, set); 1974 #if DECCHECK 1975 decCheckInexact(res, set); 1976 #endif 1977 return res; 1978 } /* decNumberMultiply */ 1979 1980 /* ------------------------------------------------------------------ */ 1981 /* decNumberPower -- raise a number to a power */ 1982 /* */ 1983 /* This computes C = A ** B */ 1984 /* */ 1985 /* res is C, the result. C may be A and/or B (e.g., X=X**X) */ 1986 /* lhs is A */ 1987 /* rhs is B */ 1988 /* set is the context */ 1989 /* */ 1990 /* C must have space for set->digits digits. */ 1991 /* */ 1992 /* Mathematical function restrictions apply (see above); a NaN is */ 1993 /* returned with Invalid_operation if a restriction is violated. */ 1994 /* */ 1995 /* However, if 1999999997<=B<=999999999 and B is an integer then the */ 1996 /* restrictions on A and the context are relaxed to the usual bounds, */ 1997 /* for compatibility with the earlier (integer power only) version */ 1998 /* of this function. */ 1999 /* */ 2000 /* When B is an integer, the result may be exact, even if rounded. */ 2001 /* */ 2002 /* The final result is rounded according to the context; it will */ 2003 /* almost always be correctly rounded, but may be up to 1 ulp in */ 2004 /* error in rare cases. */ 2005 /* ------------------------------------------------------------------ */ 2006 decNumber * decNumberPower(decNumber *res, const decNumber *lhs, 2007 const decNumber *rhs, decContext *set) { 2008 #if DECSUBSET 2009 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 2010 decNumber *allocrhs=NULL; /* .., rhs */ 2011 #endif 2012 decNumber *allocdac=NULL; /* -> allocated acc buffer, iff used */ 2013 decNumber *allocinv=NULL; /* -> allocated 1/x buffer, iff used */ 2014 Int reqdigits=set->digits; /* requested DIGITS */ 2015 Int n; /* rhs in binary */ 2016 Flag rhsint=0; /* 1 if rhs is an integer */ 2017 Flag useint=0; /* 1 if can use integer calculation */ 2018 Flag isoddint=0; /* 1 if rhs is an integer and odd */ 2019 Int i; /* work */ 2020 #if DECSUBSET 2021 Int dropped; /* .. */ 2022 #endif 2023 uInt needbytes; /* buffer size needed */ 2024 Flag seenbit; /* seen a bit while powering */ 2025 Int residue=0; /* rounding residue */ 2026 uInt status=0; /* accumulators */ 2027 uByte bits=0; /* result sign if errors */ 2028 decContext aset; /* working context */ 2029 decNumber dnOne; /* work value 1... */ 2030 /* local accumulator buffer [a decNumber, with digits+elength+1 digits] */ 2031 decNumber dacbuff[D2N(DECBUFFER+9)]; 2032 decNumber *dac=dacbuff; /* -> result accumulator */ 2033 /* same again for possible 1/lhs calculation */ 2034 decNumber invbuff[D2N(DECBUFFER+9)]; 2035 2036 #if DECCHECK 2037 if (decCheckOperands(res, lhs, rhs, set)) return res; 2038 #endif 2039 2040 do { /* protect allocated storage */ 2041 #if DECSUBSET 2042 if (!set->extended) { /* reduce operands and set status, as needed */ 2043 if (lhs->digits>reqdigits) { 2044 alloclhs=decRoundOperand(lhs, set, &status); 2045 if (alloclhs==NULL) break; 2046 lhs=alloclhs; 2047 } 2048 if (rhs->digits>reqdigits) { 2049 allocrhs=decRoundOperand(rhs, set, &status); 2050 if (allocrhs==NULL) break; 2051 rhs=allocrhs; 2052 } 2053 } 2054 #endif 2055 /* [following code does not require input rounding] */ 2056 2057 /* handle NaNs and rhs Infinity (lhs infinity is harder) */ 2058 if (SPECIALARGS) { 2059 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { /* NaNs */ 2060 decNaNs(res, lhs, rhs, set, &status); 2061 break;} 2062 if (decNumberIsInfinite(rhs)) { /* rhs Infinity */ 2063 Flag rhsneg=rhs->bits&DECNEG; /* save rhs sign */ 2064 if (decNumberIsNegative(lhs) /* lhs<0 */ 2065 && !decNumberIsZero(lhs)) /* .. */ 2066 status|=DEC_Invalid_operation; 2067 else { /* lhs >=0 */ 2068 decNumberZero(&dnOne); /* set up 1 */ 2069 dnOne.lsu[0]=1; 2070 decNumberCompare(dac, lhs, &dnOne, set); /* lhs ? 1 */ 2071 decNumberZero(res); /* prepare for 0/1/Infinity */ 2072 if (decNumberIsNegative(dac)) { /* lhs<1 */ 2073 if (rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */ 2074 } 2075 else if (dac->lsu[0]==0) { /* lhs=1 */ 2076 /* 1**Infinity is inexact, so return fully-padded 1.0000 */ 2077 Int shift=set->digits-1; 2078 *res->lsu=1; /* was 0, make int 1 */ 2079 res->digits=decShiftToMost(res->lsu, 1, shift); 2080 res->exponent=-shift; /* make 1.0000... */ 2081 status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */ 2082 } 2083 else { /* lhs>1 */ 2084 if (!rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */ 2085 } 2086 } /* lhs>=0 */ 2087 break;} 2088 /* [lhs infinity drops through] */ 2089 } /* specials */ 2090 2091 /* Original rhs may be an integer that fits and is in range */ 2092 n=decGetInt(rhs); 2093 if (n!=BADINT) { /* it is an integer */ 2094 rhsint=1; /* record the fact for 1**n */ 2095 isoddint=(Flag)n&1; /* [works even if big] */ 2096 if (n!=BIGEVEN && n!=BIGODD) /* can use integer path? */ 2097 useint=1; /* looks good */ 2098 } 2099 2100 if (decNumberIsNegative(lhs) /* -x .. */ 2101 && isoddint) bits=DECNEG; /* .. to an odd power */ 2102 2103 /* handle LHS infinity */ 2104 if (decNumberIsInfinite(lhs)) { /* [NaNs already handled] */ 2105 uByte rbits=rhs->bits; /* save */ 2106 decNumberZero(res); /* prepare */ 2107 if (n==0) *res->lsu=1; /* [-]Inf**0 => 1 */ 2108 else { 2109 /* -Inf**nonint -> error */ 2110 if (!rhsint && decNumberIsNegative(lhs)) { 2111 status|=DEC_Invalid_operation; /* -Inf**nonint is error */ 2112 break;} 2113 if (!(rbits & DECNEG)) bits|=DECINF; /* was not a **-n */ 2114 /* [otherwise will be 0 or -0] */ 2115 res->bits=bits; 2116 } 2117 break;} 2118 2119 /* similarly handle LHS zero */ 2120 if (decNumberIsZero(lhs)) { 2121 if (n==0) { /* 0**0 => Error */ 2122 #if DECSUBSET 2123 if (!set->extended) { /* [unless subset] */ 2124 decNumberZero(res); 2125 *res->lsu=1; /* return 1 */ 2126 break;} 2127 #endif 2128 status|=DEC_Invalid_operation; 2129 } 2130 else { /* 0**x */ 2131 uByte rbits=rhs->bits; /* save */ 2132 if (rbits & DECNEG) { /* was a 0**(-n) */ 2133 #if DECSUBSET 2134 if (!set->extended) { /* [bad if subset] */ 2135 status|=DEC_Invalid_operation; 2136 break;} 2137 #endif 2138 bits|=DECINF; 2139 } 2140 decNumberZero(res); /* prepare */ 2141 /* [otherwise will be 0 or -0] */ 2142 res->bits=bits; 2143 } 2144 break;} 2145 2146 /* here both lhs and rhs are finite; rhs==0 is handled in the */ 2147 /* integer path. Next handle the non-integer cases */ 2148 if (!useint) { /* non-integral rhs */ 2149 /* any -ve lhs is bad, as is either operand or context out of */ 2150 /* bounds */ 2151 if (decNumberIsNegative(lhs)) { 2152 status|=DEC_Invalid_operation; 2153 break;} 2154 if (decCheckMath(lhs, set, &status) 2155 || decCheckMath(rhs, set, &status)) break; /* variable status */ 2156 2157 decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */ 2158 aset.emax=DEC_MAX_MATH; /* usual bounds */ 2159 aset.emin=-DEC_MAX_MATH; /* .. */ 2160 aset.clamp=0; /* and no concrete format */ 2161 2162 /* calculate the result using exp(ln(lhs)*rhs), which can */ 2163 /* all be done into the accumulator, dac. The precision needed */ 2164 /* is enough to contain the full information in the lhs (which */ 2165 /* is the total digits, including exponent), or the requested */ 2166 /* precision, if larger, + 4; 6 is used for the exponent */ 2167 /* maximum length, and this is also used when it is shorter */ 2168 /* than the requested digits as it greatly reduces the >0.5 ulp */ 2169 /* cases at little cost (because Ln doubles digits each */ 2170 /* iteration so a few extra digits rarely causes an extra */ 2171 /* iteration) */ 2172 aset.digits=MAXI(lhs->digits, set->digits)+6+4; 2173 } /* non-integer rhs */ 2174 2175 else { /* rhs is in-range integer */ 2176 if (n==0) { /* x**0 = 1 */ 2177 /* (0**0 was handled above) */ 2178 decNumberZero(res); /* result=1 */ 2179 *res->lsu=1; /* .. */ 2180 break;} 2181 /* rhs is a non-zero integer */ 2182 if (n<0) n=-n; /* use abs(n) */ 2183 2184 aset=*set; /* clone the context */ 2185 aset.round=DEC_ROUND_HALF_EVEN; /* internally use balanced */ 2186 /* calculate the working DIGITS */ 2187 aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2; 2188 #if DECSUBSET 2189 if (!set->extended) aset.digits--; /* use classic precision */ 2190 #endif 2191 /* it's an error if this is more than can be handled */ 2192 if (aset.digits>DECNUMMAXP) {status|=DEC_Invalid_operation; break;} 2193 } /* integer path */ 2194 2195 /* aset.digits is the count of digits for the accumulator needed */ 2196 /* if accumulator is too long for local storage, then allocate */ 2197 needbytes=sizeof(decNumber)+(D2U(aset.digits)-1)*sizeof(Unit); 2198 /* [needbytes also used below if 1/lhs needed] */ 2199 if (needbytes>sizeof(dacbuff)) { 2200 allocdac=(decNumber *)malloc(needbytes); 2201 if (allocdac==NULL) { /* hopeless -- abandon */ 2202 status|=DEC_Insufficient_storage; 2203 break;} 2204 dac=allocdac; /* use the allocated space */ 2205 } 2206 /* here, aset is set up and accumulator is ready for use */ 2207 2208 if (!useint) { /* non-integral rhs */ 2209 /* x ** y; special-case x=1 here as it will otherwise always */ 2210 /* reduce to integer 1; decLnOp has a fastpath which detects */ 2211 /* the case of x=1 */ 2212 decLnOp(dac, lhs, &aset, &status); /* dac=ln(lhs) */ 2213 /* [no error possible, as lhs 0 already handled] */ 2214 if (ISZERO(dac)) { /* x==1, 1.0, etc. */ 2215 /* need to return fully-padded 1.0000 etc., but rhsint->1 */ 2216 *dac->lsu=1; /* was 0, make int 1 */ 2217 if (!rhsint) { /* add padding */ 2218 Int shift=set->digits-1; 2219 dac->digits=decShiftToMost(dac->lsu, 1, shift); 2220 dac->exponent=-shift; /* make 1.0000... */ 2221 status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */ 2222 } 2223 } 2224 else { 2225 decMultiplyOp(dac, dac, rhs, &aset, &status); /* dac=dac*rhs */ 2226 decExpOp(dac, dac, &aset, &status); /* dac=exp(dac) */ 2227 } 2228 /* and drop through for final rounding */ 2229 } /* non-integer rhs */ 2230 2231 else { /* carry on with integer */ 2232 decNumberZero(dac); /* acc=1 */ 2233 *dac->lsu=1; /* .. */ 2234 2235 /* if a negative power the constant 1 is needed, and if not subset */ 2236 /* invert the lhs now rather than inverting the result later */ 2237 if (decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */ 2238 decNumber *inv=invbuff; /* assume use fixed buffer */ 2239 decNumberCopy(&dnOne, dac); /* dnOne=1; [needed now or later] */ 2240 #if DECSUBSET 2241 if (set->extended) { /* need to calculate 1/lhs */ 2242 #endif 2243 /* divide lhs into 1, putting result in dac [dac=1/dac] */ 2244 decDivideOp(dac, &dnOne, lhs, &aset, DIVIDE, &status); 2245 /* now locate or allocate space for the inverted lhs */ 2246 if (needbytes>sizeof(invbuff)) { 2247 allocinv=(decNumber *)malloc(needbytes); 2248 if (allocinv==NULL) { /* hopeless -- abandon */ 2249 status|=DEC_Insufficient_storage; 2250 break;} 2251 inv=allocinv; /* use the allocated space */ 2252 } 2253 /* [inv now points to big-enough buffer or allocated storage] */ 2254 decNumberCopy(inv, dac); /* copy the 1/lhs */ 2255 decNumberCopy(dac, &dnOne); /* restore acc=1 */ 2256 lhs=inv; /* .. and go forward with new lhs */ 2257 #if DECSUBSET 2258 } 2259 #endif 2260 } 2261 2262 /* Raise-to-the-power loop... */ 2263 seenbit=0; /* set once a 1-bit is encountered */ 2264 for (i=1;;i++){ /* for each bit [top bit ignored] */ 2265 /* abandon if had overflow or terminal underflow */ 2266 if (status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */ 2267 if (status&DEC_Overflow || ISZERO(dac)) break; 2268 } 2269 /* [the following two lines revealed an optimizer bug in a C++ */ 2270 /* compiler, with symptom: 5**3 -> 25, when n=n+n was used] */ 2271 n=n<<1; /* move next bit to testable position */ 2272 if (n<0) { /* top bit is set */ 2273 seenbit=1; /* OK, significant bit seen */ 2274 decMultiplyOp(dac, dac, lhs, &aset, &status); /* dac=dac*x */ 2275 } 2276 if (i==31) break; /* that was the last bit */ 2277 if (!seenbit) continue; /* no need to square 1 */ 2278 decMultiplyOp(dac, dac, dac, &aset, &status); /* dac=dac*dac [square] */ 2279 } /*i*/ /* 32 bits */ 2280 2281 /* complete internal overflow or underflow processing */ 2282 if (status & (DEC_Overflow|DEC_Underflow)) { 2283 #if DECSUBSET 2284 /* If subset, and power was negative, reverse the kind of -erflow */ 2285 /* [1/x not yet done] */ 2286 if (!set->extended && decNumberIsNegative(rhs)) { 2287 if (status & DEC_Overflow) 2288 status^=DEC_Overflow | DEC_Underflow | DEC_Subnormal; 2289 else { /* trickier -- Underflow may or may not be set */ 2290 status&=~(DEC_Underflow | DEC_Subnormal); /* [one or both] */ 2291 status|=DEC_Overflow; 2292 } 2293 } 2294 #endif 2295 dac->bits=(dac->bits & ~DECNEG) | bits; /* force correct sign */ 2296 /* round subnormals [to set.digits rather than aset.digits] */ 2297 /* or set overflow result similarly as required */ 2298 decFinalize(dac, set, &residue, &status); 2299 decNumberCopy(res, dac); /* copy to result (is now OK length) */ 2300 break; 2301 } 2302 2303 #if DECSUBSET 2304 if (!set->extended && /* subset math */ 2305 decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */ 2306 /* so divide result into 1 [dac=1/dac] */ 2307 decDivideOp(dac, &dnOne, dac, &aset, DIVIDE, &status); 2308 } 2309 #endif 2310 } /* rhs integer path */ 2311 2312 /* reduce result to the requested length and copy to result */ 2313 decCopyFit(res, dac, set, &residue, &status); 2314 decFinish(res, set, &residue, &status); /* final cleanup */ 2315 #if DECSUBSET 2316 if (!set->extended) decTrim(res, set, 0, &dropped); /* trailing zeros */ 2317 #endif 2318 } while(0); /* end protected */ 2319 2320 if (allocdac!=NULL) free(allocdac); /* drop any storage used */ 2321 if (allocinv!=NULL) free(allocinv); /* .. */ 2322 #if DECSUBSET 2323 if (alloclhs!=NULL) free(alloclhs); /* .. */ 2324 if (allocrhs!=NULL) free(allocrhs); /* .. */ 2325 #endif 2326 if (status!=0) decStatus(res, status, set); 2327 #if DECCHECK 2328 decCheckInexact(res, set); 2329 #endif 2330 return res; 2331 } /* decNumberPower */ 2332 2333 /* ------------------------------------------------------------------ */ 2334 /* decNumberQuantize -- force exponent to requested value */ 2335 /* */ 2336 /* This computes C = op(A, B), where op adjusts the coefficient */ 2337 /* of C (by rounding or shifting) such that the exponent (-scale) */ 2338 /* of C has exponent of B. The numerical value of C will equal A, */ 2339 /* except for the effects of any rounding that occurred. */ 2340 /* */ 2341 /* res is C, the result. C may be A or B */ 2342 /* lhs is A, the number to adjust */ 2343 /* rhs is B, the number with exponent to match */ 2344 /* set is the context */ 2345 /* */ 2346 /* C must have space for set->digits digits. */ 2347 /* */ 2348 /* Unless there is an error or the result is infinite, the exponent */ 2349 /* after the operation is guaranteed to be equal to that of B. */ 2350 /* ------------------------------------------------------------------ */ 2351 decNumber * decNumberQuantize(decNumber *res, const decNumber *lhs, 2352 const decNumber *rhs, decContext *set) { 2353 uInt status=0; /* accumulator */ 2354 decQuantizeOp(res, lhs, rhs, set, 1, &status); 2355 if (status!=0) decStatus(res, status, set); 2356 return res; 2357 } /* decNumberQuantize */ 2358 2359 /* ------------------------------------------------------------------ */ 2360 /* decNumberReduce -- remove trailing zeros */ 2361 /* */ 2362 /* This computes C = 0 + A, and normalizes the result */ 2363 /* */ 2364 /* res is C, the result. C may be A */ 2365 /* rhs is A */ 2366 /* set is the context */ 2367 /* */ 2368 /* C must have space for set->digits digits. */ 2369 /* ------------------------------------------------------------------ */ 2370 /* Previously known as Normalize */ 2371 decNumber * decNumberNormalize(decNumber *res, const decNumber *rhs, 2372 decContext *set) { 2373 return decNumberReduce(res, rhs, set); 2374 } /* decNumberNormalize */ 2375 2376 decNumber * decNumberReduce(decNumber *res, const decNumber *rhs, 2377 decContext *set) { 2378 #if DECSUBSET 2379 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 2380 #endif 2381 uInt status=0; /* as usual */ 2382 Int residue=0; /* as usual */ 2383 Int dropped; /* work */ 2384 2385 #if DECCHECK 2386 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 2387 #endif 2388 2389 do { /* protect allocated storage */ 2390 #if DECSUBSET 2391 if (!set->extended) { 2392 /* reduce operand and set lostDigits status, as needed */ 2393 if (rhs->digits>set->digits) { 2394 allocrhs=decRoundOperand(rhs, set, &status); 2395 if (allocrhs==NULL) break; 2396 rhs=allocrhs; 2397 } 2398 } 2399 #endif 2400 /* [following code does not require input rounding] */ 2401 2402 /* Infinities copy through; NaNs need usual treatment */ 2403 if (decNumberIsNaN(rhs)) { 2404 decNaNs(res, rhs, NULL, set, &status); 2405 break; 2406 } 2407 2408 /* reduce result to the requested length and copy to result */ 2409 decCopyFit(res, rhs, set, &residue, &status); /* copy & round */ 2410 decFinish(res, set, &residue, &status); /* cleanup/set flags */ 2411 decTrim(res, set, 1, &dropped); /* normalize in place */ 2412 } while(0); /* end protected */ 2413 2414 #if DECSUBSET 2415 if (allocrhs !=NULL) free(allocrhs); /* .. */ 2416 #endif 2417 if (status!=0) decStatus(res, status, set);/* then report status */ 2418 return res; 2419 } /* decNumberReduce */ 2420 2421 /* ------------------------------------------------------------------ */ 2422 /* decNumberRescale -- force exponent to requested value */ 2423 /* */ 2424 /* This computes C = op(A, B), where op adjusts the coefficient */ 2425 /* of C (by rounding or shifting) such that the exponent (-scale) */ 2426 /* of C has the value B. The numerical value of C will equal A, */ 2427 /* except for the effects of any rounding that occurred. */ 2428 /* */ 2429 /* res is C, the result. C may be A or B */ 2430 /* lhs is A, the number to adjust */ 2431 /* rhs is B, the requested exponent */ 2432 /* set is the context */ 2433 /* */ 2434 /* C must have space for set->digits digits. */ 2435 /* */ 2436 /* Unless there is an error or the result is infinite, the exponent */ 2437 /* after the operation is guaranteed to be equal to B. */ 2438 /* ------------------------------------------------------------------ */ 2439 decNumber * decNumberRescale(decNumber *res, const decNumber *lhs, 2440 const decNumber *rhs, decContext *set) { 2441 uInt status=0; /* accumulator */ 2442 decQuantizeOp(res, lhs, rhs, set, 0, &status); 2443 if (status!=0) decStatus(res, status, set); 2444 return res; 2445 } /* decNumberRescale */ 2446 2447 /* ------------------------------------------------------------------ */ 2448 /* decNumberRemainder -- divide and return remainder */ 2449 /* */ 2450 /* This computes C = A % B */ 2451 /* */ 2452 /* res is C, the result. C may be A and/or B (e.g., X=X%X) */ 2453 /* lhs is A */ 2454 /* rhs is B */ 2455 /* set is the context */ 2456 /* */ 2457 /* C must have space for set->digits digits. */ 2458 /* ------------------------------------------------------------------ */ 2459 decNumber * decNumberRemainder(decNumber *res, const decNumber *lhs, 2460 const decNumber *rhs, decContext *set) { 2461 uInt status=0; /* accumulator */ 2462 decDivideOp(res, lhs, rhs, set, REMAINDER, &status); 2463 if (status!=0) decStatus(res, status, set); 2464 #if DECCHECK 2465 decCheckInexact(res, set); 2466 #endif 2467 return res; 2468 } /* decNumberRemainder */ 2469 2470 /* ------------------------------------------------------------------ */ 2471 /* decNumberRemainderNear -- divide and return remainder from nearest */ 2472 /* */ 2473 /* This computes C = A % B, where % is the IEEE remainder operator */ 2474 /* */ 2475 /* res is C, the result. C may be A and/or B (e.g., X=X%X) */ 2476 /* lhs is A */ 2477 /* rhs is B */ 2478 /* set is the context */ 2479 /* */ 2480 /* C must have space for set->digits digits. */ 2481 /* ------------------------------------------------------------------ */ 2482 decNumber * decNumberRemainderNear(decNumber *res, const decNumber *lhs, 2483 const decNumber *rhs, decContext *set) { 2484 uInt status=0; /* accumulator */ 2485 decDivideOp(res, lhs, rhs, set, REMNEAR, &status); 2486 if (status!=0) decStatus(res, status, set); 2487 #if DECCHECK 2488 decCheckInexact(res, set); 2489 #endif 2490 return res; 2491 } /* decNumberRemainderNear */ 2492 2493 /* ------------------------------------------------------------------ */ 2494 /* decNumberRotate -- rotate the coefficient of a Number left/right */ 2495 /* */ 2496 /* This computes C = A rot B (in base ten and rotating set->digits */ 2497 /* digits). */ 2498 /* */ 2499 /* res is C, the result. C may be A and/or B (e.g., X=XrotX) */ 2500 /* lhs is A */ 2501 /* rhs is B, the number of digits to rotate (-ve to right) */ 2502 /* set is the context */ 2503 /* */ 2504 /* The digits of the coefficient of A are rotated to the left (if B */ 2505 /* is positive) or to the right (if B is negative) without adjusting */ 2506 /* the exponent or the sign of A. If lhs->digits is less than */ 2507 /* set->digits the coefficient is padded with zeros on the left */ 2508 /* before the rotate. Any leading zeros in the result are removed */ 2509 /* as usual. */ 2510 /* */ 2511 /* B must be an integer (q=0) and in the range -set->digits through */ 2512 /* +set->digits. */ 2513 /* C must have space for set->digits digits. */ 2514 /* NaNs are propagated as usual. Infinities are unaffected (but */ 2515 /* B must be valid). No status is set unless B is invalid or an */ 2516 /* operand is an sNaN. */ 2517 /* ------------------------------------------------------------------ */ 2518 decNumber * decNumberRotate(decNumber *res, const decNumber *lhs, 2519 const decNumber *rhs, decContext *set) { 2520 uInt status=0; /* accumulator */ 2521 Int rotate; /* rhs as an Int */ 2522 2523 #if DECCHECK 2524 if (decCheckOperands(res, lhs, rhs, set)) return res; 2525 #endif 2526 2527 /* NaNs propagate as normal */ 2528 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) 2529 decNaNs(res, lhs, rhs, set, &status); 2530 /* rhs must be an integer */ 2531 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0) 2532 status=DEC_Invalid_operation; 2533 else { /* both numeric, rhs is an integer */ 2534 rotate=decGetInt(rhs); /* [cannot fail] */ 2535 if (rotate==BADINT /* something bad .. */ 2536 || rotate==BIGODD || rotate==BIGEVEN /* .. very big .. */ 2537 || abs(rotate)>set->digits) /* .. or out of range */ 2538 status=DEC_Invalid_operation; 2539 else { /* rhs is OK */ 2540 decNumberCopy(res, lhs); 2541 /* convert -ve rotate to equivalent positive rotation */ 2542 if (rotate<0) rotate=set->digits+rotate; 2543 if (rotate!=0 && rotate!=set->digits /* zero or full rotation */ 2544 && !decNumberIsInfinite(res)) { /* lhs was infinite */ 2545 /* left-rotate to do; 0 < rotate < set->digits */ 2546 uInt units, shift; /* work */ 2547 uInt msudigits; /* digits in result msu */ 2548 Unit *msu=res->lsu+D2U(res->digits)-1; /* current msu */ 2549 Unit *msumax=res->lsu+D2U(set->digits)-1; /* rotation msu */ 2550 for (msu++; msu<=msumax; msu++) *msu=0; /* ensure high units=0 */ 2551 res->digits=set->digits; /* now full-length */ 2552 msudigits=MSUDIGITS(res->digits); /* actual digits in msu */ 2553 2554 /* rotation here is done in-place, in three steps */ 2555 /* 1. shift all to least up to one unit to unit-align final */ 2556 /* lsd [any digits shifted out are rotated to the left, */ 2557 /* abutted to the original msd (which may require split)] */ 2558 /* */ 2559 /* [if there are no whole units left to rotate, the */ 2560 /* rotation is now complete] */ 2561 /* */ 2562 /* 2. shift to least, from below the split point only, so that */ 2563 /* the final msd is in the right place in its Unit [any */ 2564 /* digits shifted out will fit exactly in the current msu, */ 2565 /* left aligned, no split required] */ 2566 /* */ 2567 /* 3. rotate all the units by reversing left part, right */ 2568 /* part, and then whole */ 2569 /* */ 2570 /* example: rotate right 8 digits (2 units + 2), DECDPUN=3. */ 2571 /* */ 2572 /* start: 00a bcd efg hij klm npq */ 2573 /* */ 2574 /* 1a 000 0ab cde fgh|ijk lmn [pq saved] */ 2575 /* 1b 00p qab cde fgh|ijk lmn */ 2576 /* */ 2577 /* 2a 00p qab cde fgh|00i jkl [mn saved] */ 2578 /* 2b mnp qab cde fgh|00i jkl */ 2579 /* */ 2580 /* 3a fgh cde qab mnp|00i jkl */ 2581 /* 3b fgh cde qab mnp|jkl 00i */ 2582 /* 3c 00i jkl mnp qab cde fgh */ 2583 2584 /* Step 1: amount to shift is the partial right-rotate count */ 2585 rotate=set->digits-rotate; /* make it right-rotate */ 2586 units=rotate/DECDPUN; /* whole units to rotate */ 2587 shift=rotate%DECDPUN; /* left-over digits count */ 2588 if (shift>0) { /* not an exact number of units */ 2589 uInt save=res->lsu[0]%powers[shift]; /* save low digit(s) */ 2590 decShiftToLeast(res->lsu, D2U(res->digits), shift); 2591 if (shift>msudigits) { /* msumax-1 needs >0 digits */ 2592 uInt rem=save%powers[shift-msudigits];/* split save */ 2593 *msumax=(Unit)(save/powers[shift-msudigits]); /* and insert */ 2594 *(msumax-1)=*(msumax-1) 2595 +(Unit)(rem*powers[DECDPUN-(shift-msudigits)]); /* .. */ 2596 } 2597 else { /* all fits in msumax */ 2598 *msumax=*msumax+(Unit)(save*powers[msudigits-shift]); /* [maybe *1] */ 2599 } 2600 } /* digits shift needed */ 2601 2602 /* If whole units to rotate... */ 2603 if (units>0) { /* some to do */ 2604 /* Step 2: the units to touch are the whole ones in rotate, */ 2605 /* if any, and the shift is DECDPUN-msudigits (which may be */ 2606 /* 0, again) */ 2607 shift=DECDPUN-msudigits; 2608 if (shift>0) { /* not an exact number of units */ 2609 uInt save=res->lsu[0]%powers[shift]; /* save low digit(s) */ 2610 decShiftToLeast(res->lsu, units, shift); 2611 *msumax=*msumax+(Unit)(save*powers[msudigits]); 2612 } /* partial shift needed */ 2613 2614 /* Step 3: rotate the units array using triple reverse */ 2615 /* (reversing is easy and fast) */ 2616 decReverse(res->lsu+units, msumax); /* left part */ 2617 decReverse(res->lsu, res->lsu+units-1); /* right part */ 2618 decReverse(res->lsu, msumax); /* whole */ 2619 } /* whole units to rotate */ 2620 /* the rotation may have left an undetermined number of zeros */ 2621 /* on the left, so true length needs to be calculated */ 2622 res->digits=decGetDigits(res->lsu, msumax-res->lsu+1); 2623 } /* rotate needed */ 2624 } /* rhs OK */ 2625 } /* numerics */ 2626 if (status!=0) decStatus(res, status, set); 2627 return res; 2628 } /* decNumberRotate */ 2629 2630 /* ------------------------------------------------------------------ */ 2631 /* decNumberSameQuantum -- test for equal exponents */ 2632 /* */ 2633 /* res is the result number, which will contain either 0 or 1 */ 2634 /* lhs is a number to test */ 2635 /* rhs is the second (usually a pattern) */ 2636 /* */ 2637 /* No errors are possible and no context is needed. */ 2638 /* ------------------------------------------------------------------ */ 2639 decNumber * decNumberSameQuantum(decNumber *res, const decNumber *lhs, 2640 const decNumber *rhs) { 2641 Unit ret=0; /* return value */ 2642 2643 #if DECCHECK 2644 if (decCheckOperands(res, lhs, rhs, DECUNCONT)) return res; 2645 #endif 2646 2647 if (SPECIALARGS) { 2648 if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1; 2649 else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1; 2650 /* [anything else with a special gives 0] */ 2651 } 2652 else if (lhs->exponent==rhs->exponent) ret=1; 2653 2654 decNumberZero(res); /* OK to overwrite an operand now */ 2655 *res->lsu=ret; 2656 return res; 2657 } /* decNumberSameQuantum */ 2658 2659 /* ------------------------------------------------------------------ */ 2660 /* decNumberScaleB -- multiply by a power of 10 */ 2661 /* */ 2662 /* This computes C = A x 10**B where B is an integer (q=0) with */ 2663 /* maximum magnitude 2*(emax+digits) */ 2664 /* */ 2665 /* res is C, the result. C may be A or B */ 2666 /* lhs is A, the number to adjust */ 2667 /* rhs is B, the requested power of ten to use */ 2668 /* set is the context */ 2669 /* */ 2670 /* C must have space for set->digits digits. */ 2671 /* */ 2672 /* The result may underflow or overflow. */ 2673 /* ------------------------------------------------------------------ */ 2674 decNumber * decNumberScaleB(decNumber *res, const decNumber *lhs, 2675 const decNumber *rhs, decContext *set) { 2676 Int reqexp; /* requested exponent change [B] */ 2677 uInt status=0; /* accumulator */ 2678 Int residue; /* work */ 2679 2680 #if DECCHECK 2681 if (decCheckOperands(res, lhs, rhs, set)) return res; 2682 #endif 2683 2684 /* Handle special values except lhs infinite */ 2685 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) 2686 decNaNs(res, lhs, rhs, set, &status); 2687 /* rhs must be an integer */ 2688 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0) 2689 status=DEC_Invalid_operation; 2690 else { 2691 /* lhs is a number; rhs is a finite with q==0 */ 2692 reqexp=decGetInt(rhs); /* [cannot fail] */ 2693 if (reqexp==BADINT /* something bad .. */ 2694 || reqexp==BIGODD || reqexp==BIGEVEN /* .. very big .. */ 2695 || abs(reqexp)>(2*(set->digits+set->emax))) /* .. or out of range */ 2696 status=DEC_Invalid_operation; 2697 else { /* rhs is OK */ 2698 decNumberCopy(res, lhs); /* all done if infinite lhs */ 2699 if (!decNumberIsInfinite(res)) { /* prepare to scale */ 2700 res->exponent+=reqexp; /* adjust the exponent */ 2701 residue=0; 2702 decFinalize(res, set, &residue, &status); /* .. and check */ 2703 } /* finite LHS */ 2704 } /* rhs OK */ 2705 } /* rhs finite */ 2706 if (status!=0) decStatus(res, status, set); 2707 return res; 2708 } /* decNumberScaleB */ 2709 2710 /* ------------------------------------------------------------------ */ 2711 /* decNumberShift -- shift the coefficient of a Number left or right */ 2712 /* */ 2713 /* This computes C = A << B or C = A >> -B (in base ten). */ 2714 /* */ 2715 /* res is C, the result. C may be A and/or B (e.g., X=X<<X) */ 2716 /* lhs is A */ 2717 /* rhs is B, the number of digits to shift (-ve to right) */ 2718 /* set is the context */ 2719 /* */ 2720 /* The digits of the coefficient of A are shifted to the left (if B */ 2721 /* is positive) or to the right (if B is negative) without adjusting */ 2722 /* the exponent or the sign of A. */ 2723 /* */ 2724 /* B must be an integer (q=0) and in the range -set->digits through */ 2725 /* +set->digits. */ 2726 /* C must have space for set->digits digits. */ 2727 /* NaNs are propagated as usual. Infinities are unaffected (but */ 2728 /* B must be valid). No status is set unless B is invalid or an */ 2729 /* operand is an sNaN. */ 2730 /* ------------------------------------------------------------------ */ 2731 decNumber * decNumberShift(decNumber *res, const decNumber *lhs, 2732 const decNumber *rhs, decContext *set) { 2733 uInt status=0; /* accumulator */ 2734 Int shift; /* rhs as an Int */ 2735 2736 #if DECCHECK 2737 if (decCheckOperands(res, lhs, rhs, set)) return res; 2738 #endif 2739 2740 /* NaNs propagate as normal */ 2741 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) 2742 decNaNs(res, lhs, rhs, set, &status); 2743 /* rhs must be an integer */ 2744 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0) 2745 status=DEC_Invalid_operation; 2746 else { /* both numeric, rhs is an integer */ 2747 shift=decGetInt(rhs); /* [cannot fail] */ 2748 if (shift==BADINT /* something bad .. */ 2749 || shift==BIGODD || shift==BIGEVEN /* .. very big .. */ 2750 || abs(shift)>set->digits) /* .. or out of range */ 2751 status=DEC_Invalid_operation; 2752 else { /* rhs is OK */ 2753 decNumberCopy(res, lhs); 2754 if (shift!=0 && !decNumberIsInfinite(res)) { /* something to do */ 2755 if (shift>0) { /* to left */ 2756 if (shift==set->digits) { /* removing all */ 2757 *res->lsu=0; /* so place 0 */ 2758 res->digits=1; /* .. */ 2759 } 2760 else { /* */ 2761 /* first remove leading digits if necessary */ 2762 if (res->digits+shift>set->digits) { 2763 decDecap(res, res->digits+shift-set->digits); 2764 /* that updated res->digits; may have gone to 1 (for a */ 2765 /* single digit or for zero */ 2766 } 2767 if (res->digits>1 || *res->lsu) /* if non-zero.. */ 2768 res->digits=decShiftToMost(res->lsu, res->digits, shift); 2769 } /* partial left */ 2770 } /* left */ 2771 else { /* to right */ 2772 if (-shift>=res->digits) { /* discarding all */ 2773 *res->lsu=0; /* so place 0 */ 2774 res->digits=1; /* .. */ 2775 } 2776 else { 2777 decShiftToLeast(res->lsu, D2U(res->digits), -shift); 2778 res->digits-=(-shift); 2779 } 2780 } /* to right */ 2781 } /* non-0 non-Inf shift */ 2782 } /* rhs OK */ 2783 } /* numerics */ 2784 if (status!=0) decStatus(res, status, set); 2785 return res; 2786 } /* decNumberShift */ 2787 2788 /* ------------------------------------------------------------------ */ 2789 /* decNumberSquareRoot -- square root operator */ 2790 /* */ 2791 /* This computes C = squareroot(A) */ 2792 /* */ 2793 /* res is C, the result. C may be A */ 2794 /* rhs is A */ 2795 /* set is the context; note that rounding mode has no effect */ 2796 /* */ 2797 /* C must have space for set->digits digits. */ 2798 /* ------------------------------------------------------------------ */ 2799 /* This uses the following varying-precision algorithm in: */ 2800 /* */ 2801 /* Properly Rounded Variable Precision Square Root, T. E. Hull and */ 2802 /* A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, */ 2803 /* pp229-237, ACM, September 1985. */ 2804 /* */ 2805 /* The square-root is calculated using Newton's method, after which */ 2806 /* a check is made to ensure the result is correctly rounded. */ 2807 /* */ 2808 /* % [Reformatted original Numerical Turing source code follows.] */ 2809 /* function sqrt(x : real) : real */ 2810 /* % sqrt(x) returns the properly rounded approximation to the square */ 2811 /* % root of x, in the precision of the calling environment, or it */ 2812 /* % fails if x < 0. */ 2813 /* % t e hull and a abrham, august, 1984 */ 2814 /* if x <= 0 then */ 2815 /* if x < 0 then */ 2816 /* assert false */ 2817 /* else */ 2818 /* result 0 */ 2819 /* end if */ 2820 /* end if */ 2821 /* var f := setexp(x, 0) % fraction part of x [0.1 <= x < 1] */ 2822 /* var e := getexp(x) % exponent part of x */ 2823 /* var approx : real */ 2824 /* if e mod 2 = 0 then */ 2825 /* approx := .259 + .819 * f % approx to root of f */ 2826 /* else */ 2827 /* f := f/l0 % adjustments */ 2828 /* e := e + 1 % for odd */ 2829 /* approx := .0819 + 2.59 * f % exponent */ 2830 /* end if */ 2831 /* */ 2832 /* var p:= 3 */ 2833 /* const maxp := currentprecision + 2 */ 2834 /* loop */ 2835 /* p := min(2*p - 2, maxp) % p = 4,6,10, . . . , maxp */ 2836 /* precision p */ 2837 /* approx := .5 * (approx + f/approx) */ 2838 /* exit when p = maxp */ 2839 /* end loop */ 2840 /* */ 2841 /* % approx is now within 1 ulp of the properly rounded square root */ 2842 /* % of f; to ensure proper rounding, compare squares of (approx - */ 2843 /* % l/2 ulp) and (approx + l/2 ulp) with f. */ 2844 /* p := currentprecision */ 2845 /* begin */ 2846 /* precision p + 2 */ 2847 /* const approxsubhalf := approx - setexp(.5, -p) */ 2848 /* if mulru(approxsubhalf, approxsubhalf) > f then */ 2849 /* approx := approx - setexp(.l, -p + 1) */ 2850 /* else */ 2851 /* const approxaddhalf := approx + setexp(.5, -p) */ 2852 /* if mulrd(approxaddhalf, approxaddhalf) < f then */ 2853 /* approx := approx + setexp(.l, -p + 1) */ 2854 /* end if */ 2855 /* end if */ 2856 /* end */ 2857 /* result setexp(approx, e div 2) % fix exponent */ 2858 /* end sqrt */ 2859 /* ------------------------------------------------------------------ */ 2860 decNumber * decNumberSquareRoot(decNumber *res, const decNumber *rhs, 2861 decContext *set) { 2862 decContext workset, approxset; /* work contexts */ 2863 decNumber dzero; /* used for constant zero */ 2864 Int maxp; /* largest working precision */ 2865 Int workp; /* working precision */ 2866 Int residue=0; /* rounding residue */ 2867 uInt status=0, ignore=0; /* status accumulators */ 2868 uInt rstatus; /* .. */ 2869 Int exp; /* working exponent */ 2870 Int ideal; /* ideal (preferred) exponent */ 2871 Int needbytes; /* work */ 2872 Int dropped; /* .. */ 2873 2874 #if DECSUBSET 2875 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 2876 #endif 2877 /* buffer for f [needs +1 in case DECBUFFER 0] */ 2878 decNumber buff[D2N(DECBUFFER+1)]; 2879 /* buffer for a [needs +2 to match likely maxp] */ 2880 decNumber bufa[D2N(DECBUFFER+2)]; 2881 /* buffer for temporary, b [must be same size as a] */ 2882 decNumber bufb[D2N(DECBUFFER+2)]; 2883 decNumber *allocbuff=NULL; /* -> allocated buff, iff allocated */ 2884 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 2885 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */ 2886 decNumber *f=buff; /* reduced fraction */ 2887 decNumber *a=bufa; /* approximation to result */ 2888 decNumber *b=bufb; /* intermediate result */ 2889 /* buffer for temporary variable, up to 3 digits */ 2890 decNumber buft[D2N(3)]; 2891 decNumber *t=buft; /* up-to-3-digit constant or work */ 2892 2893 #if DECCHECK 2894 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 2895 #endif 2896 2897 do { /* protect allocated storage */ 2898 #if DECSUBSET 2899 if (!set->extended) { 2900 /* reduce operand and set lostDigits status, as needed */ 2901 if (rhs->digits>set->digits) { 2902 allocrhs=decRoundOperand(rhs, set, &status); 2903 if (allocrhs==NULL) break; 2904 /* [Note: 'f' allocation below could reuse this buffer if */ 2905 /* used, but as this is rare they are kept separate for clarity.] */ 2906 rhs=allocrhs; 2907 } 2908 } 2909 #endif 2910 /* [following code does not require input rounding] */ 2911 2912 /* handle infinities and NaNs */ 2913 if (SPECIALARG) { 2914 if (decNumberIsInfinite(rhs)) { /* an infinity */ 2915 if (decNumberIsNegative(rhs)) status|=DEC_Invalid_operation; 2916 else decNumberCopy(res, rhs); /* +Infinity */ 2917 } 2918 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */ 2919 break; 2920 } 2921 2922 /* calculate the ideal (preferred) exponent [floor(exp/2)] */ 2923 /* [We would like to write: ideal=rhs->exponent>>1, but this */ 2924 /* generates a compiler warning. Generated code is the same.] */ 2925 ideal=(rhs->exponent&~1)/2; /* target */ 2926 2927 /* handle zeros */ 2928 if (ISZERO(rhs)) { 2929 decNumberCopy(res, rhs); /* could be 0 or -0 */ 2930 res->exponent=ideal; /* use the ideal [safe] */ 2931 /* use decFinish to clamp any out-of-range exponent, etc. */ 2932 decFinish(res, set, &residue, &status); 2933 break; 2934 } 2935 2936 /* any other -x is an oops */ 2937 if (decNumberIsNegative(rhs)) { 2938 status|=DEC_Invalid_operation; 2939 break; 2940 } 2941 2942 /* space is needed for three working variables */ 2943 /* f -- the same precision as the RHS, reduced to 0.01->0.99... */ 2944 /* a -- Hull's approximation -- precision, when assigned, is */ 2945 /* currentprecision+1 or the input argument precision, */ 2946 /* whichever is larger (+2 for use as temporary) */ 2947 /* b -- intermediate temporary result (same size as a) */ 2948 /* if any is too long for local storage, then allocate */ 2949 workp=MAXI(set->digits+1, rhs->digits); /* actual rounding precision */ 2950 maxp=workp+2; /* largest working precision */ 2951 2952 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); 2953 if (needbytes>(Int)sizeof(buff)) { 2954 allocbuff=(decNumber *)malloc(needbytes); 2955 if (allocbuff==NULL) { /* hopeless -- abandon */ 2956 status|=DEC_Insufficient_storage; 2957 break;} 2958 f=allocbuff; /* use the allocated space */ 2959 } 2960 /* a and b both need to be able to hold a maxp-length number */ 2961 needbytes=sizeof(decNumber)+(D2U(maxp)-1)*sizeof(Unit); 2962 if (needbytes>(Int)sizeof(bufa)) { /* [same applies to b] */ 2963 allocbufa=(decNumber *)malloc(needbytes); 2964 allocbufb=(decNumber *)malloc(needbytes); 2965 if (allocbufa==NULL || allocbufb==NULL) { /* hopeless */ 2966 status|=DEC_Insufficient_storage; 2967 break;} 2968 a=allocbufa; /* use the allocated spaces */ 2969 b=allocbufb; /* .. */ 2970 } 2971 2972 /* copy rhs -> f, save exponent, and reduce so 0.1 <= f < 1 */ 2973 decNumberCopy(f, rhs); 2974 exp=f->exponent+f->digits; /* adjusted to Hull rules */ 2975 f->exponent=-(f->digits); /* to range */ 2976 2977 /* set up working context */ 2978 decContextDefault(&workset, DEC_INIT_DECIMAL64); 2979 2980 /* [Until further notice, no error is possible and status bits */ 2981 /* (Rounded, etc.) should be ignored, not accumulated.] */ 2982 2983 /* Calculate initial approximation, and allow for odd exponent */ 2984 workset.digits=workp; /* p for initial calculation */ 2985 t->bits=0; t->digits=3; 2986 a->bits=0; a->digits=3; 2987 if ((exp & 1)==0) { /* even exponent */ 2988 /* Set t=0.259, a=0.819 */ 2989 t->exponent=-3; 2990 a->exponent=-3; 2991 #if DECDPUN>=3 2992 t->lsu[0]=259; 2993 a->lsu[0]=819; 2994 #elif DECDPUN==2 2995 t->lsu[0]=59; t->lsu[1]=2; 2996 a->lsu[0]=19; a->lsu[1]=8; 2997 #else 2998 t->lsu[0]=9; t->lsu[1]=5; t->lsu[2]=2; 2999 a->lsu[0]=9; a->lsu[1]=1; a->lsu[2]=8; 3000 #endif 3001 } 3002 else { /* odd exponent */ 3003 /* Set t=0.0819, a=2.59 */ 3004 f->exponent--; /* f=f/10 */ 3005 exp++; /* e=e+1 */ 3006 t->exponent=-4; 3007 a->exponent=-2; 3008 #if DECDPUN>=3 3009 t->lsu[0]=819; 3010 a->lsu[0]=259; 3011 #elif DECDPUN==2 3012 t->lsu[0]=19; t->lsu[1]=8; 3013 a->lsu[0]=59; a->lsu[1]=2; 3014 #else 3015 t->lsu[0]=9; t->lsu[1]=1; t->lsu[2]=8; 3016 a->lsu[0]=9; a->lsu[1]=5; a->lsu[2]=2; 3017 #endif 3018 } 3019 decMultiplyOp(a, a, f, &workset, &ignore); /* a=a*f */ 3020 decAddOp(a, a, t, &workset, 0, &ignore); /* ..+t */ 3021 /* [a is now the initial approximation for sqrt(f), calculated with */ 3022 /* currentprecision, which is also a's precision.] */ 3023 3024 /* the main calculation loop */ 3025 decNumberZero(&dzero); /* make 0 */ 3026 decNumberZero(t); /* set t = 0.5 */ 3027 t->lsu[0]=5; /* .. */ 3028 t->exponent=-1; /* .. */ 3029 workset.digits=3; /* initial p */ 3030 for (;;) { 3031 /* set p to min(2*p - 2, maxp) [hence 3; or: 4, 6, 10, ... , maxp] */ 3032 workset.digits=workset.digits*2-2; 3033 if (workset.digits>maxp) workset.digits=maxp; 3034 /* a = 0.5 * (a + f/a) */ 3035 /* [calculated at p then rounded to currentprecision] */ 3036 decDivideOp(b, f, a, &workset, DIVIDE, &ignore); /* b=f/a */ 3037 decAddOp(b, b, a, &workset, 0, &ignore); /* b=b+a */ 3038 decMultiplyOp(a, b, t, &workset, &ignore); /* a=b*0.5 */ 3039 if (a->digits==maxp) break; /* have required digits */ 3040 } /* loop */ 3041 3042 /* Here, 0.1 <= a < 1 [Hull], and a has maxp digits */ 3043 /* now reduce to length, etc.; this needs to be done with a */ 3044 /* having the correct exponent so as to handle subnormals */ 3045 /* correctly */ 3046 approxset=*set; /* get emin, emax, etc. */ 3047 approxset.round=DEC_ROUND_HALF_EVEN; 3048 a->exponent+=exp/2; /* set correct exponent */ 3049 3050 rstatus=0; /* clear status */ 3051 residue=0; /* .. and accumulator */ 3052 decCopyFit(a, a, &approxset, &residue, &rstatus); /* reduce (if needed) */ 3053 decFinish(a, &approxset, &residue, &rstatus); /* clean and finalize */ 3054 3055 /* Overflow was possible if the input exponent was out-of-range, */ 3056 /* in which case quit */ 3057 if (rstatus&DEC_Overflow) { 3058 status=rstatus; /* use the status as-is */ 3059 decNumberCopy(res, a); /* copy to result */ 3060 break; 3061 } 3062 3063 /* Preserve status except Inexact/Rounded */ 3064 status|=(rstatus & ~(DEC_Rounded|DEC_Inexact)); 3065 3066 /* Carry out the Hull correction */ 3067 a->exponent-=exp/2; /* back to 0.1->1 */ 3068 3069 /* a is now at final precision and within 1 ulp of the properly */ 3070 /* rounded square root of f; to ensure proper rounding, compare */ 3071 /* squares of (a - l/2 ulp) and (a + l/2 ulp) with f. */ 3072 /* Here workset.digits=maxp and t=0.5, and a->digits determines */ 3073 /* the ulp */ 3074 workset.digits--; /* maxp-1 is OK now */ 3075 t->exponent=-a->digits-1; /* make 0.5 ulp */ 3076 decAddOp(b, a, t, &workset, DECNEG, &ignore); /* b = a - 0.5 ulp */ 3077 workset.round=DEC_ROUND_UP; 3078 decMultiplyOp(b, b, b, &workset, &ignore); /* b = mulru(b, b) */ 3079 decCompareOp(b, f, b, &workset, COMPARE, &ignore); /* b ? f, reversed */ 3080 if (decNumberIsNegative(b)) { /* f < b [i.e., b > f] */ 3081 /* this is the more common adjustment, though both are rare */ 3082 t->exponent++; /* make 1.0 ulp */ 3083 t->lsu[0]=1; /* .. */ 3084 decAddOp(a, a, t, &workset, DECNEG, &ignore); /* a = a - 1 ulp */ 3085 /* assign to approx [round to length] */ 3086 approxset.emin-=exp/2; /* adjust to match a */ 3087 approxset.emax-=exp/2; 3088 decAddOp(a, &dzero, a, &approxset, 0, &ignore); 3089 } 3090 else { 3091 decAddOp(b, a, t, &workset, 0, &ignore); /* b = a + 0.5 ulp */ 3092 workset.round=DEC_ROUND_DOWN; 3093 decMultiplyOp(b, b, b, &workset, &ignore); /* b = mulrd(b, b) */ 3094 decCompareOp(b, b, f, &workset, COMPARE, &ignore); /* b ? f */ 3095 if (decNumberIsNegative(b)) { /* b < f */ 3096 t->exponent++; /* make 1.0 ulp */ 3097 t->lsu[0]=1; /* .. */ 3098 decAddOp(a, a, t, &workset, 0, &ignore); /* a = a + 1 ulp */ 3099 /* assign to approx [round to length] */ 3100 approxset.emin-=exp/2; /* adjust to match a */ 3101 approxset.emax-=exp/2; 3102 decAddOp(a, &dzero, a, &approxset, 0, &ignore); 3103 } 3104 } 3105 /* [no errors are possible in the above, and rounding/inexact during */ 3106 /* estimation are irrelevant, so status was not accumulated] */ 3107 3108 /* Here, 0.1 <= a < 1 (still), so adjust back */ 3109 a->exponent+=exp/2; /* set correct exponent */ 3110 3111 /* count droppable zeros [after any subnormal rounding] by */ 3112 /* trimming a copy */ 3113 decNumberCopy(b, a); 3114 decTrim(b, set, 1, &dropped); /* [drops trailing zeros] */ 3115 3116 /* Set Inexact and Rounded. The answer can only be exact if */ 3117 /* it is short enough so that squaring it could fit in workp digits, */ 3118 /* and it cannot have trailing zeros due to clamping, so these are */ 3119 /* the only (relatively rare) conditions a careful check is needed */ 3120 if (b->digits*2-1 > workp && !set->clamp) { /* cannot fit */ 3121 status|=DEC_Inexact|DEC_Rounded; 3122 } 3123 else { /* could be exact/unrounded */ 3124 uInt mstatus=0; /* local status */ 3125 decMultiplyOp(b, b, b, &workset, &mstatus); /* try the multiply */ 3126 if (mstatus&DEC_Overflow) { /* result just won't fit */ 3127 status|=DEC_Inexact|DEC_Rounded; 3128 } 3129 else { /* plausible */ 3130 decCompareOp(t, b, rhs, &workset, COMPARE, &mstatus); /* b ? rhs */ 3131 if (!ISZERO(t)) status|=DEC_Inexact|DEC_Rounded; /* not equal */ 3132 else { /* is Exact */ 3133 /* here, dropped is the count of trailing zeros in 'a' */ 3134 /* use closest exponent to ideal... */ 3135 Int todrop=ideal-a->exponent; /* most that can be dropped */ 3136 if (todrop<0) status|=DEC_Rounded; /* ideally would add 0s */ 3137 else { /* unrounded */ 3138 if (dropped<todrop) { /* clamp to those available */ 3139 todrop=dropped; 3140 status|=DEC_Clamped; 3141 } 3142 if (todrop>0) { /* have some to drop */ 3143 decShiftToLeast(a->lsu, D2U(a->digits), todrop); 3144 a->exponent+=todrop; /* maintain numerical value */ 3145 a->digits-=todrop; /* new length */ 3146 } 3147 } 3148 } 3149 } 3150 } 3151 3152 /* double-check Underflow, as perhaps the result could not have */ 3153 /* been subnormal (initial argument too big), or it is now Exact */ 3154 if (status&DEC_Underflow) { 3155 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */ 3156 /* check if truly subnormal */ 3157 #if DECEXTFLAG /* DEC_Subnormal too */ 3158 if (ae>=set->emin*2) status&=~(DEC_Subnormal|DEC_Underflow); 3159 #else 3160 if (ae>=set->emin*2) status&=~DEC_Underflow; 3161 #endif 3162 /* check if truly inexact */ 3163 if (!(status&DEC_Inexact)) status&=~DEC_Underflow; 3164 } 3165 3166 decNumberCopy(res, a); /* a is now the result */ 3167 } while(0); /* end protected */ 3168 3169 if (allocbuff!=NULL) free(allocbuff); /* drop any storage used */ 3170 if (allocbufa!=NULL) free(allocbufa); /* .. */ 3171 if (allocbufb!=NULL) free(allocbufb); /* .. */ 3172 #if DECSUBSET 3173 if (allocrhs !=NULL) free(allocrhs); /* .. */ 3174 #endif 3175 if (status!=0) decStatus(res, status, set);/* then report status */ 3176 #if DECCHECK 3177 decCheckInexact(res, set); 3178 #endif 3179 return res; 3180 } /* decNumberSquareRoot */ 3181 3182 /* ------------------------------------------------------------------ */ 3183 /* decNumberSubtract -- subtract two Numbers */ 3184 /* */ 3185 /* This computes C = A - B */ 3186 /* */ 3187 /* res is C, the result. C may be A and/or B (e.g., X=X-X) */ 3188 /* lhs is A */ 3189 /* rhs is B */ 3190 /* set is the context */ 3191 /* */ 3192 /* C must have space for set->digits digits. */ 3193 /* ------------------------------------------------------------------ */ 3194 decNumber * decNumberSubtract(decNumber *res, const decNumber *lhs, 3195 const decNumber *rhs, decContext *set) { 3196 uInt status=0; /* accumulator */ 3197 3198 decAddOp(res, lhs, rhs, set, DECNEG, &status); 3199 if (status!=0) decStatus(res, status, set); 3200 #if DECCHECK 3201 decCheckInexact(res, set); 3202 #endif 3203 return res; 3204 } /* decNumberSubtract */ 3205 3206 /* ------------------------------------------------------------------ */ 3207 /* decNumberToIntegralExact -- round-to-integral-value with InExact */ 3208 /* decNumberToIntegralValue -- round-to-integral-value */ 3209 /* */ 3210 /* res is the result */ 3211 /* rhs is input number */ 3212 /* set is the context */ 3213 /* */ 3214 /* res must have space for any value of rhs. */ 3215 /* */ 3216 /* This implements the IEEE special operators and therefore treats */ 3217 /* special values as valid. For finite numbers it returns */ 3218 /* rescale(rhs, 0) if rhs->exponent is <0. */ 3219 /* Otherwise the result is rhs (so no error is possible, except for */ 3220 /* sNaN). */ 3221 /* */ 3222 /* The context is used for rounding mode and status after sNaN, but */ 3223 /* the digits setting is ignored. The Exact version will signal */ 3224 /* Inexact if the result differs numerically from rhs; the other */ 3225 /* never signals Inexact. */ 3226 /* ------------------------------------------------------------------ */ 3227 decNumber * decNumberToIntegralExact(decNumber *res, const decNumber *rhs, 3228 decContext *set) { 3229 decNumber dn; 3230 decContext workset; /* working context */ 3231 uInt status=0; /* accumulator */ 3232 3233 #if DECCHECK 3234 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 3235 #endif 3236 3237 /* handle infinities and NaNs */ 3238 if (SPECIALARG) { 3239 if (decNumberIsInfinite(rhs)) decNumberCopy(res, rhs); /* an Infinity */ 3240 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */ 3241 } 3242 else { /* finite */ 3243 /* have a finite number; no error possible (res must be big enough) */ 3244 if (rhs->exponent>=0) return decNumberCopy(res, rhs); 3245 /* that was easy, but if negative exponent there is work to do... */ 3246 workset=*set; /* clone rounding, etc. */ 3247 workset.digits=rhs->digits; /* no length rounding */ 3248 workset.traps=0; /* no traps */ 3249 decNumberZero(&dn); /* make a number with exponent 0 */ 3250 decNumberQuantize(res, rhs, &dn, &workset); 3251 status|=workset.status; 3252 } 3253 if (status!=0) decStatus(res, status, set); 3254 return res; 3255 } /* decNumberToIntegralExact */ 3256 3257 decNumber * decNumberToIntegralValue(decNumber *res, const decNumber *rhs, 3258 decContext *set) { 3259 decContext workset=*set; /* working context */ 3260 workset.traps=0; /* no traps */ 3261 decNumberToIntegralExact(res, rhs, &workset); 3262 /* this never affects set, except for sNaNs; NaN will have been set */ 3263 /* or propagated already, so no need to call decStatus */ 3264 set->status|=workset.status&DEC_Invalid_operation; 3265 return res; 3266 } /* decNumberToIntegralValue */ 3267 3268 /* ------------------------------------------------------------------ */ 3269 /* decNumberXor -- XOR two Numbers, digitwise */ 3270 /* */ 3271 /* This computes C = A ^ B */ 3272 /* */ 3273 /* res is C, the result. C may be A and/or B (e.g., X=X^X) */ 3274 /* lhs is A */ 3275 /* rhs is B */ 3276 /* set is the context (used for result length and error report) */ 3277 /* */ 3278 /* C must have space for set->digits digits. */ 3279 /* */ 3280 /* Logical function restrictions apply (see above); a NaN is */ 3281 /* returned with Invalid_operation if a restriction is violated. */ 3282 /* ------------------------------------------------------------------ */ 3283 decNumber * decNumberXor(decNumber *res, const decNumber *lhs, 3284 const decNumber *rhs, decContext *set) { 3285 const Unit *ua, *ub; /* -> operands */ 3286 const Unit *msua, *msub; /* -> operand msus */ 3287 Unit *uc, *msuc; /* -> result and its msu */ 3288 Int msudigs; /* digits in res msu */ 3289 #if DECCHECK 3290 if (decCheckOperands(res, lhs, rhs, set)) return res; 3291 #endif 3292 3293 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs) 3294 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { 3295 decStatus(res, DEC_Invalid_operation, set); 3296 return res; 3297 } 3298 /* operands are valid */ 3299 ua=lhs->lsu; /* bottom-up */ 3300 ub=rhs->lsu; /* .. */ 3301 uc=res->lsu; /* .. */ 3302 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */ 3303 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ 3304 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ 3305 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ 3306 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */ 3307 Unit a, b; /* extract units */ 3308 if (ua>msua) a=0; 3309 else a=*ua; 3310 if (ub>msub) b=0; 3311 else b=*ub; 3312 *uc=0; /* can now write back */ 3313 if (a|b) { /* maybe 1 bits to examine */ 3314 Int i, j; 3315 /* This loop could be unrolled and/or use BIN2BCD tables */ 3316 for (i=0; i<DECDPUN; i++) { 3317 if ((a^b)&1) *uc=*uc+(Unit)powers[i]; /* effect XOR */ 3318 j=a%10; 3319 a=a/10; 3320 j|=b%10; 3321 b=b/10; 3322 if (j>1) { 3323 decStatus(res, DEC_Invalid_operation, set); 3324 return res; 3325 } 3326 if (uc==msuc && i==msudigs-1) break; /* just did final digit */ 3327 } /* each digit */ 3328 } /* non-zero */ 3329 } /* each unit */ 3330 /* [here uc-1 is the msu of the result] */ 3331 res->digits=decGetDigits(res->lsu, uc-res->lsu); 3332 res->exponent=0; /* integer */ 3333 res->bits=0; /* sign=0 */ 3334 return res; /* [no status to set] */ 3335 } /* decNumberXor */ 3336 3337 3338 /* ================================================================== */ 3339 /* Utility routines */ 3340 /* ================================================================== */ 3341 3342 /* ------------------------------------------------------------------ */ 3343 /* decNumberClass -- return the decClass of a decNumber */ 3344 /* dn -- the decNumber to test */ 3345 /* set -- the context to use for Emin */ 3346 /* returns the decClass enum */ 3347 /* ------------------------------------------------------------------ */ 3348 enum decClass decNumberClass(const decNumber *dn, decContext *set) { 3349 if (decNumberIsSpecial(dn)) { 3350 if (decNumberIsQNaN(dn)) return DEC_CLASS_QNAN; 3351 if (decNumberIsSNaN(dn)) return DEC_CLASS_SNAN; 3352 /* must be an infinity */ 3353 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_INF; 3354 return DEC_CLASS_POS_INF; 3355 } 3356 /* is finite */ 3357 if (decNumberIsNormal(dn, set)) { /* most common */ 3358 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_NORMAL; 3359 return DEC_CLASS_POS_NORMAL; 3360 } 3361 /* is subnormal or zero */ 3362 if (decNumberIsZero(dn)) { /* most common */ 3363 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_ZERO; 3364 return DEC_CLASS_POS_ZERO; 3365 } 3366 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_SUBNORMAL; 3367 return DEC_CLASS_POS_SUBNORMAL; 3368 } /* decNumberClass */ 3369 3370 /* ------------------------------------------------------------------ */ 3371 /* decNumberClassToString -- convert decClass to a string */ 3372 /* */ 3373 /* eclass is a valid decClass */ 3374 /* returns a constant string describing the class (max 13+1 chars) */ 3375 /* ------------------------------------------------------------------ */ 3376 const char *decNumberClassToString(enum decClass eclass) { 3377 if (eclass==DEC_CLASS_POS_NORMAL) return DEC_ClassString_PN; 3378 if (eclass==DEC_CLASS_NEG_NORMAL) return DEC_ClassString_NN; 3379 if (eclass==DEC_CLASS_POS_ZERO) return DEC_ClassString_PZ; 3380 if (eclass==DEC_CLASS_NEG_ZERO) return DEC_ClassString_NZ; 3381 if (eclass==DEC_CLASS_POS_SUBNORMAL) return DEC_ClassString_PS; 3382 if (eclass==DEC_CLASS_NEG_SUBNORMAL) return DEC_ClassString_NS; 3383 if (eclass==DEC_CLASS_POS_INF) return DEC_ClassString_PI; 3384 if (eclass==DEC_CLASS_NEG_INF) return DEC_ClassString_NI; 3385 if (eclass==DEC_CLASS_QNAN) return DEC_ClassString_QN; 3386 if (eclass==DEC_CLASS_SNAN) return DEC_ClassString_SN; 3387 return DEC_ClassString_UN; /* Unknown */ 3388 } /* decNumberClassToString */ 3389 3390 /* ------------------------------------------------------------------ */ 3391 /* decNumberCopy -- copy a number */ 3392 /* */ 3393 /* dest is the target decNumber */ 3394 /* src is the source decNumber */ 3395 /* returns dest */ 3396 /* */ 3397 /* (dest==src is allowed and is a no-op) */ 3398 /* All fields are updated as required. This is a utility operation, */ 3399 /* so special values are unchanged and no error is possible. */ 3400 /* ------------------------------------------------------------------ */ 3401 decNumber * decNumberCopy(decNumber *dest, const decNumber *src) { 3402 3403 #if DECCHECK 3404 if (src==NULL) return decNumberZero(dest); 3405 #endif 3406 3407 if (dest==src) return dest; /* no copy required */ 3408 3409 /* Use explicit assignments here as structure assignment could copy */ 3410 /* more than just the lsu (for small DECDPUN). This would not affect */ 3411 /* the value of the results, but could disturb test harness spill */ 3412 /* checking. */ 3413 dest->bits=src->bits; 3414 dest->exponent=src->exponent; 3415 dest->digits=src->digits; 3416 dest->lsu[0]=src->lsu[0]; 3417 if (src->digits>DECDPUN) { /* more Units to come */ 3418 const Unit *smsup, *s; /* work */ 3419 Unit *d; /* .. */ 3420 /* memcpy for the remaining Units would be safe as they cannot */ 3421 /* overlap. However, this explicit loop is faster in short cases. */ 3422 d=dest->lsu+1; /* -> first destination */ 3423 smsup=src->lsu+D2U(src->digits); /* -> source msu+1 */ 3424 for (s=src->lsu+1; s<smsup; s++, d++) *d=*s; 3425 } 3426 return dest; 3427 } /* decNumberCopy */ 3428 3429 /* ------------------------------------------------------------------ */ 3430 /* decNumberCopyAbs -- quiet absolute value operator */ 3431 /* */ 3432 /* This sets C = abs(A) */ 3433 /* */ 3434 /* res is C, the result. C may be A */ 3435 /* rhs is A */ 3436 /* */ 3437 /* C must have space for set->digits digits. */ 3438 /* No exception or error can occur; this is a quiet bitwise operation.*/ 3439 /* See also decNumberAbs for a checking version of this. */ 3440 /* ------------------------------------------------------------------ */ 3441 decNumber * decNumberCopyAbs(decNumber *res, const decNumber *rhs) { 3442 #if DECCHECK 3443 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res; 3444 #endif 3445 decNumberCopy(res, rhs); 3446 res->bits&=~DECNEG; /* turn off sign */ 3447 return res; 3448 } /* decNumberCopyAbs */ 3449 3450 /* ------------------------------------------------------------------ */ 3451 /* decNumberCopyNegate -- quiet negate value operator */ 3452 /* */ 3453 /* This sets C = negate(A) */ 3454 /* */ 3455 /* res is C, the result. C may be A */ 3456 /* rhs is A */ 3457 /* */ 3458 /* C must have space for set->digits digits. */ 3459 /* No exception or error can occur; this is a quiet bitwise operation.*/ 3460 /* See also decNumberMinus for a checking version of this. */ 3461 /* ------------------------------------------------------------------ */ 3462 decNumber * decNumberCopyNegate(decNumber *res, const decNumber *rhs) { 3463 #if DECCHECK 3464 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res; 3465 #endif 3466 decNumberCopy(res, rhs); 3467 res->bits^=DECNEG; /* invert the sign */ 3468 return res; 3469 } /* decNumberCopyNegate */ 3470 3471 /* ------------------------------------------------------------------ */ 3472 /* decNumberCopySign -- quiet copy and set sign operator */ 3473 /* */ 3474 /* This sets C = A with the sign of B */ 3475 /* */ 3476 /* res is C, the result. C may be A */ 3477 /* lhs is A */ 3478 /* rhs is B */ 3479 /* */ 3480 /* C must have space for set->digits digits. */ 3481 /* No exception or error can occur; this is a quiet bitwise operation.*/ 3482 /* ------------------------------------------------------------------ */ 3483 decNumber * decNumberCopySign(decNumber *res, const decNumber *lhs, 3484 const decNumber *rhs) { 3485 uByte sign; /* rhs sign */ 3486 #if DECCHECK 3487 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res; 3488 #endif 3489 sign=rhs->bits & DECNEG; /* save sign bit */ 3490 decNumberCopy(res, lhs); 3491 res->bits&=~DECNEG; /* clear the sign */ 3492 res->bits|=sign; /* set from rhs */ 3493 return res; 3494 } /* decNumberCopySign */ 3495 3496 /* ------------------------------------------------------------------ */ 3497 /* decNumberGetBCD -- get the coefficient in BCD8 */ 3498 /* dn is the source decNumber */ 3499 /* bcd is the uInt array that will receive dn->digits BCD bytes, */ 3500 /* most-significant at offset 0 */ 3501 /* returns bcd */ 3502 /* */ 3503 /* bcd must have at least dn->digits bytes. No error is possible; if */ 3504 /* dn is a NaN or Infinite, digits must be 1 and the coefficient 0. */ 3505 /* ------------------------------------------------------------------ */ 3506 uByte * decNumberGetBCD(const decNumber *dn, uint8_t *bcd) { 3507 uByte *ub=bcd+dn->digits-1; /* -> lsd */ 3508 const Unit *up=dn->lsu; /* Unit pointer, -> lsu */ 3509 3510 #if DECDPUN==1 /* trivial simple copy */ 3511 for (; ub>=bcd; ub--, up++) *ub=*up; 3512 #else /* chopping needed */ 3513 uInt u=*up; /* work */ 3514 uInt cut=DECDPUN; /* downcounter through unit */ 3515 for (; ub>=bcd; ub--) { 3516 *ub=(uByte)(u%10); /* [*6554 trick inhibits, here] */ 3517 u=u/10; 3518 cut--; 3519 if (cut>0) continue; /* more in this unit */ 3520 up++; 3521 u=*up; 3522 cut=DECDPUN; 3523 } 3524 #endif 3525 return bcd; 3526 } /* decNumberGetBCD */ 3527 3528 /* ------------------------------------------------------------------ */ 3529 /* decNumberSetBCD -- set (replace) the coefficient from BCD8 */ 3530 /* dn is the target decNumber */ 3531 /* bcd is the uInt array that will source n BCD bytes, most- */ 3532 /* significant at offset 0 */ 3533 /* n is the number of digits in the source BCD array (bcd) */ 3534 /* returns dn */ 3535 /* */ 3536 /* dn must have space for at least n digits. No error is possible; */ 3537 /* if dn is a NaN, or Infinite, or is to become a zero, n must be 1 */ 3538 /* and bcd[0] zero. */ 3539 /* ------------------------------------------------------------------ */ 3540 decNumber * decNumberSetBCD(decNumber *dn, const uByte *bcd, uInt n) { 3541 Unit *up = dn->lsu + D2U(n) - 1; /* -> msu [target pointer] */ 3542 const uByte *ub=bcd; /* -> source msd */ 3543 3544 #if DECDPUN==1 /* trivial simple copy */ 3545 for (; ub<bcd+n; ub++, up--) *up=*ub; 3546 #else /* some assembly needed */ 3547 /* calculate how many digits in msu, and hence first cut */ 3548 Int cut=MSUDIGITS(n); /* [faster than remainder] */ 3549 for (;up>=dn->lsu; up--) { /* each Unit from msu */ 3550 *up=0; /* will take <=DECDPUN digits */ 3551 for (; cut>0; ub++, cut--) *up=X10(*up)+*ub; 3552 cut=DECDPUN; /* next Unit has all digits */ 3553 } 3554 #endif 3555 dn->digits=n; /* set digit count */ 3556 return dn; 3557 } /* decNumberSetBCD */ 3558 3559 /* ------------------------------------------------------------------ */ 3560 /* decNumberIsNormal -- test normality of a decNumber */ 3561 /* dn is the decNumber to test */ 3562 /* set is the context to use for Emin */ 3563 /* returns 1 if |dn| is finite and >=Nmin, 0 otherwise */ 3564 /* ------------------------------------------------------------------ */ 3565 Int decNumberIsNormal(const decNumber *dn, decContext *set) { 3566 Int ae; /* adjusted exponent */ 3567 #if DECCHECK 3568 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; 3569 #endif 3570 3571 if (decNumberIsSpecial(dn)) return 0; /* not finite */ 3572 if (decNumberIsZero(dn)) return 0; /* not non-zero */ 3573 3574 ae=dn->exponent+dn->digits-1; /* adjusted exponent */ 3575 if (ae<set->emin) return 0; /* is subnormal */ 3576 return 1; 3577 } /* decNumberIsNormal */ 3578 3579 /* ------------------------------------------------------------------ */ 3580 /* decNumberIsSubnormal -- test subnormality of a decNumber */ 3581 /* dn is the decNumber to test */ 3582 /* set is the context to use for Emin */ 3583 /* returns 1 if |dn| is finite, non-zero, and <Nmin, 0 otherwise */ 3584 /* ------------------------------------------------------------------ */ 3585 Int decNumberIsSubnormal(const decNumber *dn, decContext *set) { 3586 Int ae; /* adjusted exponent */ 3587 #if DECCHECK 3588 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; 3589 #endif 3590 3591 if (decNumberIsSpecial(dn)) return 0; /* not finite */ 3592 if (decNumberIsZero(dn)) return 0; /* not non-zero */ 3593 3594 ae=dn->exponent+dn->digits-1; /* adjusted exponent */ 3595 if (ae<set->emin) return 1; /* is subnormal */ 3596 return 0; 3597 } /* decNumberIsSubnormal */ 3598 3599 /* ------------------------------------------------------------------ */ 3600 /* decNumberTrim -- remove insignificant zeros */ 3601 /* */ 3602 /* dn is the number to trim */ 3603 /* returns dn */ 3604 /* */ 3605 /* All fields are updated as required. This is a utility operation, */ 3606 /* so special values are unchanged and no error is possible. */ 3607 /* ------------------------------------------------------------------ */ 3608 decNumber * decNumberTrim(decNumber *dn) { 3609 Int dropped; /* work */ 3610 decContext set; /* .. */ 3611 #if DECCHECK 3612 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, DECUNCONT)) return dn; 3613 #endif 3614 decContextDefault(&set, DEC_INIT_BASE); /* clamp=0 */ 3615 return decTrim(dn, &set, 0, &dropped); 3616 } /* decNumberTrim */ 3617 3618 /* ------------------------------------------------------------------ */ 3619 /* decNumberVersion -- return the name and version of this module */ 3620 /* */ 3621 /* No error is possible. */ 3622 /* ------------------------------------------------------------------ */ 3623 const char * decNumberVersion(void) { 3624 return DECVERSION; 3625 } /* decNumberVersion */ 3626 3627 /* ------------------------------------------------------------------ */ 3628 /* decNumberZero -- set a number to 0 */ 3629 /* */ 3630 /* dn is the number to set, with space for one digit */ 3631 /* returns dn */ 3632 /* */ 3633 /* No error is possible. */ 3634 /* ------------------------------------------------------------------ */ 3635 /* Memset is not used as it is much slower in some environments. */ 3636 decNumber * decNumberZero(decNumber *dn) { 3637 3638 #if DECCHECK 3639 if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn; 3640 #endif 3641 3642 dn->bits=0; 3643 dn->exponent=0; 3644 dn->digits=1; 3645 dn->lsu[0]=0; 3646 return dn; 3647 } /* decNumberZero */ 3648 3649 /* ================================================================== */ 3650 /* Local routines */ 3651 /* ================================================================== */ 3652 3653 /* ------------------------------------------------------------------ */ 3654 /* decToString -- lay out a number into a string */ 3655 /* */ 3656 /* dn is the number to lay out */ 3657 /* string is where to lay out the number */ 3658 /* eng is 1 if Engineering, 0 if Scientific */ 3659 /* */ 3660 /* string must be at least dn->digits+14 characters long */ 3661 /* No error is possible. */ 3662 /* */ 3663 /* Note that this routine can generate a -0 or 0.000. These are */ 3664 /* never generated in subset to-number or arithmetic, but can occur */ 3665 /* in non-subset arithmetic (e.g., -1*0 or 1.234-1.234). */ 3666 /* ------------------------------------------------------------------ */ 3667 /* If DECCHECK is enabled the string "?" is returned if a number is */ 3668 /* invalid. */ 3669 static void decToString(const decNumber *dn, char *string, Flag eng) { 3670 Int exp=dn->exponent; /* local copy */ 3671 Int e; /* E-part value */ 3672 Int pre; /* digits before the '.' */ 3673 Int cut; /* for counting digits in a Unit */ 3674 char *c=string; /* work [output pointer] */ 3675 const Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [input pointer] */ 3676 uInt u, pow; /* work */ 3677 3678 #if DECCHECK 3679 if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) { 3680 strcpy(string, "?"); 3681 return;} 3682 #endif 3683 3684 if (decNumberIsNegative(dn)) { /* Negatives get a minus */ 3685 *c='-'; 3686 c++; 3687 } 3688 if (dn->bits&DECSPECIAL) { /* Is a special value */ 3689 if (decNumberIsInfinite(dn)) { 3690 strcpy(c, "Inf"); 3691 strcpy(c+3, "inity"); 3692 return;} 3693 /* a NaN */ 3694 if (dn->bits&DECSNAN) { /* signalling NaN */ 3695 *c='s'; 3696 c++; 3697 } 3698 strcpy(c, "NaN"); 3699 c+=3; /* step past */ 3700 /* if not a clean non-zero coefficient, that's all there is in a */ 3701 /* NaN string */ 3702 if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return; 3703 /* [drop through to add integer] */ 3704 } 3705 3706 /* calculate how many digits in msu, and hence first cut */ 3707 cut=MSUDIGITS(dn->digits); /* [faster than remainder] */ 3708 cut--; /* power of ten for digit */ 3709 3710 if (exp==0) { /* simple integer [common fastpath] */ 3711 for (;up>=dn->lsu; up--) { /* each Unit from msu */ 3712 u=*up; /* contains DECDPUN digits to lay out */ 3713 for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow); 3714 cut=DECDPUN-1; /* next Unit has all digits */ 3715 } 3716 *c='\0'; /* terminate the string */ 3717 return;} 3718 3719 /* non-0 exponent -- assume plain form */ 3720 pre=dn->digits+exp; /* digits before '.' */ 3721 e=0; /* no E */ 3722 if ((exp>0) || (pre<-5)) { /* need exponential form */ 3723 e=exp+dn->digits-1; /* calculate E value */ 3724 pre=1; /* assume one digit before '.' */ 3725 if (eng && (e!=0)) { /* engineering: may need to adjust */ 3726 Int adj; /* adjustment */ 3727 /* The C remainder operator is undefined for negative numbers, so */ 3728 /* a positive remainder calculation must be used here */ 3729 if (e<0) { 3730 adj=(-e)%3; 3731 if (adj!=0) adj=3-adj; 3732 } 3733 else { /* e>0 */ 3734 adj=e%3; 3735 } 3736 e=e-adj; 3737 /* if dealing with zero still produce an exponent which is a */ 3738 /* multiple of three, as expected, but there will only be the */ 3739 /* one zero before the E, still. Otherwise note the padding. */ 3740 if (!ISZERO(dn)) pre+=adj; 3741 else { /* is zero */ 3742 if (adj!=0) { /* 0.00Esnn needed */ 3743 e=e+3; 3744 pre=-(2-adj); 3745 } 3746 } /* zero */ 3747 } /* eng */ 3748 } /* need exponent */ 3749 3750 /* lay out the digits of the coefficient, adding 0s and . as needed */ 3751 u=*up; 3752 if (pre>0) { /* xxx.xxx or xx00 (engineering) form */ 3753 Int n=pre; 3754 for (; pre>0; pre--, c++, cut--) { 3755 if (cut<0) { /* need new Unit */ 3756 if (up==dn->lsu) break; /* out of input digits (pre>digits) */ 3757 up--; 3758 cut=DECDPUN-1; 3759 u=*up; 3760 } 3761 TODIGIT(u, cut, c, pow); 3762 } 3763 if (n<dn->digits) { /* more to come, after '.' */ 3764 *c='.'; c++; 3765 for (;; c++, cut--) { 3766 if (cut<0) { /* need new Unit */ 3767 if (up==dn->lsu) break; /* out of input digits */ 3768 up--; 3769 cut=DECDPUN-1; 3770 u=*up; 3771 } 3772 TODIGIT(u, cut, c, pow); 3773 } 3774 } 3775 else for (; pre>0; pre--, c++) *c='0'; /* 0 padding (for engineering) needed */ 3776 } 3777 else { /* 0.xxx or 0.000xxx form */ 3778 *c='0'; c++; 3779 *c='.'; c++; 3780 for (; pre<0; pre++, c++) *c='0'; /* add any 0's after '.' */ 3781 for (; ; c++, cut--) { 3782 if (cut<0) { /* need new Unit */ 3783 if (up==dn->lsu) break; /* out of input digits */ 3784 up--; 3785 cut=DECDPUN-1; 3786 u=*up; 3787 } 3788 TODIGIT(u, cut, c, pow); 3789 } 3790 } 3791 3792 /* Finally add the E-part, if needed. It will never be 0, has a 3793 base maximum and minimum of +999999999 through -999999999, but 3794 could range down to -1999999998 for anormal numbers */ 3795 if (e!=0) { 3796 Flag had=0; /* 1=had non-zero */ 3797 *c='E'; c++; 3798 *c='+'; c++; /* assume positive */ 3799 u=e; /* .. */ 3800 if (e<0) { 3801 *(c-1)='-'; /* oops, need - */ 3802 u=-e; /* uInt, please */ 3803 } 3804 /* lay out the exponent [_itoa or equivalent is not ANSI C] */ 3805 for (cut=9; cut>=0; cut--) { 3806 TODIGIT(u, cut, c, pow); 3807 if (*c=='0' && !had) continue; /* skip leading zeros */ 3808 had=1; /* had non-0 */ 3809 c++; /* step for next */ 3810 } /* cut */ 3811 } 3812 *c='\0'; /* terminate the string (all paths) */ 3813 return; 3814 } /* decToString */ 3815 3816 /* ------------------------------------------------------------------ */ 3817 /* decAddOp -- add/subtract operation */ 3818 /* */ 3819 /* This computes C = A + B */ 3820 /* */ 3821 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */ 3822 /* lhs is A */ 3823 /* rhs is B */ 3824 /* set is the context */ 3825 /* negate is DECNEG if rhs should be negated, or 0 otherwise */ 3826 /* status accumulates status for the caller */ 3827 /* */ 3828 /* C must have space for set->digits digits. */ 3829 /* Inexact in status must be 0 for correct Exact zero sign in result */ 3830 /* ------------------------------------------------------------------ */ 3831 /* If possible, the coefficient is calculated directly into C. */ 3832 /* However, if: */ 3833 /* -- a digits+1 calculation is needed because the numbers are */ 3834 /* unaligned and span more than set->digits digits */ 3835 /* -- a carry to digits+1 digits looks possible */ 3836 /* -- C is the same as A or B, and the result would destructively */ 3837 /* overlap the A or B coefficient */ 3838 /* then the result must be calculated into a temporary buffer. In */ 3839 /* this case a local (stack) buffer is used if possible, and only if */ 3840 /* too long for that does malloc become the final resort. */ 3841 /* */ 3842 /* Misalignment is handled as follows: */ 3843 /* Apad: (AExp>BExp) Swap operands and proceed as for BExp>AExp. */ 3844 /* BPad: Apply the padding by a combination of shifting (whole */ 3845 /* units) and multiplication (part units). */ 3846 /* */ 3847 /* Addition, especially x=x+1, is speed-critical. */ 3848 /* The static buffer is larger than might be expected to allow for */ 3849 /* calls from higher-level functions (notably exp). */ 3850 /* ------------------------------------------------------------------ */ 3851 static decNumber * decAddOp(decNumber *res, const decNumber *lhs, 3852 const decNumber *rhs, decContext *set, 3853 uByte negate, uInt *status) { 3854 #if DECSUBSET 3855 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 3856 decNumber *allocrhs=NULL; /* .., rhs */ 3857 #endif 3858 Int rhsshift; /* working shift (in Units) */ 3859 Int maxdigits; /* longest logical length */ 3860 Int mult; /* multiplier */ 3861 Int residue; /* rounding accumulator */ 3862 uByte bits; /* result bits */ 3863 Flag diffsign; /* non-0 if arguments have different sign */ 3864 Unit *acc; /* accumulator for result */ 3865 Unit accbuff[SD2U(DECBUFFER*2+20)]; /* local buffer [*2+20 reduces many */ 3866 /* allocations when called from */ 3867 /* other operations, notable exp] */ 3868 Unit *allocacc=NULL; /* -> allocated acc buffer, iff allocated */ 3869 Int reqdigits=set->digits; /* local copy; requested DIGITS */ 3870 Int padding; /* work */ 3871 3872 #if DECCHECK 3873 if (decCheckOperands(res, lhs, rhs, set)) return res; 3874 #endif 3875 3876 do { /* protect allocated storage */ 3877 #if DECSUBSET 3878 if (!set->extended) { 3879 /* reduce operands and set lostDigits status, as needed */ 3880 if (lhs->digits>reqdigits) { 3881 alloclhs=decRoundOperand(lhs, set, status); 3882 if (alloclhs==NULL) break; 3883 lhs=alloclhs; 3884 } 3885 if (rhs->digits>reqdigits) { 3886 allocrhs=decRoundOperand(rhs, set, status); 3887 if (allocrhs==NULL) break; 3888 rhs=allocrhs; 3889 } 3890 } 3891 #endif 3892 /* [following code does not require input rounding] */ 3893 3894 /* note whether signs differ [used all paths] */ 3895 diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG); 3896 3897 /* handle infinities and NaNs */ 3898 if (SPECIALARGS) { /* a special bit set */ 3899 if (SPECIALARGS & (DECSNAN | DECNAN)) /* a NaN */ 3900 decNaNs(res, lhs, rhs, set, status); 3901 else { /* one or two infinities */ 3902 if (decNumberIsInfinite(lhs)) { /* LHS is infinity */ 3903 /* two infinities with different signs is invalid */ 3904 if (decNumberIsInfinite(rhs) && diffsign) { 3905 *status|=DEC_Invalid_operation; 3906 break; 3907 } 3908 bits=lhs->bits & DECNEG; /* get sign from LHS */ 3909 } 3910 else bits=(rhs->bits^negate) & DECNEG;/* RHS must be Infinity */ 3911 bits|=DECINF; 3912 decNumberZero(res); 3913 res->bits=bits; /* set +/- infinity */ 3914 } /* an infinity */ 3915 break; 3916 } 3917 3918 /* Quick exit for add 0s; return the non-0, modified as need be */ 3919 if (ISZERO(lhs)) { 3920 Int adjust; /* work */ 3921 Int lexp=lhs->exponent; /* save in case LHS==RES */ 3922 bits=lhs->bits; /* .. */ 3923 residue=0; /* clear accumulator */ 3924 decCopyFit(res, rhs, set, &residue, status); /* copy (as needed) */ 3925 res->bits^=negate; /* flip if rhs was negated */ 3926 #if DECSUBSET 3927 if (set->extended) { /* exponents on zeros count */ 3928 #endif 3929 /* exponent will be the lower of the two */ 3930 adjust=lexp-res->exponent; /* adjustment needed [if -ve] */ 3931 if (ISZERO(res)) { /* both 0: special IEEE 854 rules */ 3932 if (adjust<0) res->exponent=lexp; /* set exponent */ 3933 /* 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0 */ 3934 if (diffsign) { 3935 if (set->round!=DEC_ROUND_FLOOR) res->bits=0; 3936 else res->bits=DECNEG; /* preserve 0 sign */ 3937 } 3938 } 3939 else { /* non-0 res */ 3940 if (adjust<0) { /* 0-padding needed */ 3941 if ((res->digits-adjust)>set->digits) { 3942 adjust=res->digits-set->digits; /* to fit exactly */ 3943 *status|=DEC_Rounded; /* [but exact] */ 3944 } 3945 res->digits=decShiftToMost(res->lsu, res->digits, -adjust); 3946 res->exponent+=adjust; /* set the exponent. */ 3947 } 3948 } /* non-0 res */ 3949 #if DECSUBSET 3950 } /* extended */ 3951 #endif 3952 decFinish(res, set, &residue, status); /* clean and finalize */ 3953 break;} 3954 3955 if (ISZERO(rhs)) { /* [lhs is non-zero] */ 3956 Int adjust; /* work */ 3957 Int rexp=rhs->exponent; /* save in case RHS==RES */ 3958 bits=rhs->bits; /* be clean */ 3959 residue=0; /* clear accumulator */ 3960 decCopyFit(res, lhs, set, &residue, status); /* copy (as needed) */ 3961 #if DECSUBSET 3962 if (set->extended) { /* exponents on zeros count */ 3963 #endif 3964 /* exponent will be the lower of the two */ 3965 /* [0-0 case handled above] */ 3966 adjust=rexp-res->exponent; /* adjustment needed [if -ve] */ 3967 if (adjust<0) { /* 0-padding needed */ 3968 if ((res->digits-adjust)>set->digits) { 3969 adjust=res->digits-set->digits; /* to fit exactly */ 3970 *status|=DEC_Rounded; /* [but exact] */ 3971 } 3972 res->digits=decShiftToMost(res->lsu, res->digits, -adjust); 3973 res->exponent+=adjust; /* set the exponent. */ 3974 } 3975 #if DECSUBSET 3976 } /* extended */ 3977 #endif 3978 decFinish(res, set, &residue, status); /* clean and finalize */ 3979 break;} 3980 3981 /* [NB: both fastpath and mainpath code below assume these cases */ 3982 /* (notably 0-0) have already been handled] */ 3983 3984 /* calculate the padding needed to align the operands */ 3985 padding=rhs->exponent-lhs->exponent; 3986 3987 /* Fastpath cases where the numbers are aligned and normal, the RHS */ 3988 /* is all in one unit, no operand rounding is needed, and no carry, */ 3989 /* lengthening, or borrow is needed */ 3990 if (padding==0 3991 && rhs->digits<=DECDPUN 3992 && rhs->exponent>=set->emin /* [some normals drop through] */ 3993 && rhs->exponent<=set->emax-set->digits+1 /* [could clamp] */ 3994 && rhs->digits<=reqdigits 3995 && lhs->digits<=reqdigits) { 3996 Int partial=*lhs->lsu; 3997 if (!diffsign) { /* adding */ 3998 partial+=*rhs->lsu; 3999 if ((partial<=DECDPUNMAX) /* result fits in unit */ 4000 && (lhs->digits>=DECDPUN || /* .. and no digits-count change */ 4001 partial<(Int)powers[lhs->digits])) { /* .. */ 4002 if (res!=lhs) decNumberCopy(res, lhs); /* not in place */ 4003 *res->lsu=(Unit)partial; /* [copy could have overwritten RHS] */ 4004 break; 4005 } 4006 /* else drop out for careful add */ 4007 } 4008 else { /* signs differ */ 4009 partial-=*rhs->lsu; 4010 if (partial>0) { /* no borrow needed, and non-0 result */ 4011 if (res!=lhs) decNumberCopy(res, lhs); /* not in place */ 4012 *res->lsu=(Unit)partial; 4013 /* this could have reduced digits [but result>0] */ 4014 res->digits=decGetDigits(res->lsu, D2U(res->digits)); 4015 break; 4016 } 4017 /* else drop out for careful subtract */ 4018 } 4019 } 4020 4021 /* Now align (pad) the lhs or rhs so they can be added or */ 4022 /* subtracted, as necessary. If one number is much larger than */ 4023 /* the other (that is, if in plain form there is a least one */ 4024 /* digit between the lowest digit of one and the highest of the */ 4025 /* other) padding with up to DIGITS-1 trailing zeros may be */ 4026 /* needed; then apply rounding (as exotic rounding modes may be */ 4027 /* affected by the residue). */ 4028 rhsshift=0; /* rhs shift to left (padding) in Units */ 4029 bits=lhs->bits; /* assume sign is that of LHS */ 4030 mult=1; /* likely multiplier */ 4031 4032 /* [if padding==0 the operands are aligned; no padding is needed] */ 4033 if (padding!=0) { 4034 /* some padding needed; always pad the RHS, as any required */ 4035 /* padding can then be effected by a simple combination of */ 4036 /* shifts and a multiply */ 4037 Flag swapped=0; 4038 if (padding<0) { /* LHS needs the padding */ 4039 const decNumber *t; 4040 padding=-padding; /* will be +ve */ 4041 bits=(uByte)(rhs->bits^negate); /* assumed sign is now that of RHS */ 4042 t=lhs; lhs=rhs; rhs=t; 4043 swapped=1; 4044 } 4045 4046 /* If, after pad, rhs would be longer than lhs by digits+1 or */ 4047 /* more then lhs cannot affect the answer, except as a residue, */ 4048 /* so only need to pad up to a length of DIGITS+1. */ 4049 if (rhs->digits+padding > lhs->digits+reqdigits+1) { 4050 /* The RHS is sufficient */ 4051 /* for residue use the relative sign indication... */ 4052 Int shift=reqdigits-rhs->digits; /* left shift needed */ 4053 residue=1; /* residue for rounding */ 4054 if (diffsign) residue=-residue; /* signs differ */ 4055 /* copy, shortening if necessary */ 4056 decCopyFit(res, rhs, set, &residue, status); 4057 /* if it was already shorter, then need to pad with zeros */ 4058 if (shift>0) { 4059 res->digits=decShiftToMost(res->lsu, res->digits, shift); 4060 res->exponent-=shift; /* adjust the exponent. */ 4061 } 4062 /* flip the result sign if unswapped and rhs was negated */ 4063 if (!swapped) res->bits^=negate; 4064 decFinish(res, set, &residue, status); /* done */ 4065 break;} 4066 4067 /* LHS digits may affect result */ 4068 rhsshift=D2U(padding+1)-1; /* this much by Unit shift .. */ 4069 mult=powers[padding-(rhsshift*DECDPUN)]; /* .. this by multiplication */ 4070 } /* padding needed */ 4071 4072 if (diffsign) mult=-mult; /* signs differ */ 4073 4074 /* determine the longer operand */ 4075 maxdigits=rhs->digits+padding; /* virtual length of RHS */ 4076 if (lhs->digits>maxdigits) maxdigits=lhs->digits; 4077 4078 /* Decide on the result buffer to use; if possible place directly */ 4079 /* into result. */ 4080 acc=res->lsu; /* assume add direct to result */ 4081 /* If destructive overlap, or the number is too long, or a carry or */ 4082 /* borrow to DIGITS+1 might be possible, a buffer must be used. */ 4083 /* [Might be worth more sophisticated tests when maxdigits==reqdigits] */ 4084 if ((maxdigits>=reqdigits) /* is, or could be, too large */ 4085 || (res==rhs && rhsshift>0)) { /* destructive overlap */ 4086 /* buffer needed, choose it; units for maxdigits digits will be */ 4087 /* needed, +1 Unit for carry or borrow */ 4088 Int need=D2U(maxdigits)+1; 4089 acc=accbuff; /* assume use local buffer */ 4090 if (need*sizeof(Unit)>sizeof(accbuff)) { 4091 /* printf("malloc add %ld %ld\n", need, sizeof(accbuff)); */ 4092 allocacc=(Unit *)malloc(need*sizeof(Unit)); 4093 if (allocacc==NULL) { /* hopeless -- abandon */ 4094 *status|=DEC_Insufficient_storage; 4095 break;} 4096 acc=allocacc; 4097 } 4098 } 4099 4100 res->bits=(uByte)(bits&DECNEG); /* it's now safe to overwrite.. */ 4101 res->exponent=lhs->exponent; /* .. operands (even if aliased) */ 4102 4103 #if DECTRACE 4104 decDumpAr('A', lhs->lsu, D2U(lhs->digits)); 4105 decDumpAr('B', rhs->lsu, D2U(rhs->digits)); 4106 printf(" :h: %ld %ld\n", rhsshift, mult); 4107 #endif 4108 4109 /* add [A+B*m] or subtract [A+B*(-m)] */ 4110 res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits), 4111 rhs->lsu, D2U(rhs->digits), 4112 rhsshift, acc, mult) 4113 *DECDPUN; /* [units -> digits] */ 4114 if (res->digits<0) { /* borrowed... */ 4115 res->digits=-res->digits; 4116 res->bits^=DECNEG; /* flip the sign */ 4117 } 4118 #if DECTRACE 4119 decDumpAr('+', acc, D2U(res->digits)); 4120 #endif 4121 4122 /* If a buffer was used the result must be copied back, possibly */ 4123 /* shortening. (If no buffer was used then the result must have */ 4124 /* fit, so can't need rounding and residue must be 0.) */ 4125 residue=0; /* clear accumulator */ 4126 if (acc!=res->lsu) { 4127 #if DECSUBSET 4128 if (set->extended) { /* round from first significant digit */ 4129 #endif 4130 /* remove leading zeros that were added due to rounding up to */ 4131 /* integral Units -- before the test for rounding. */ 4132 if (res->digits>reqdigits) 4133 res->digits=decGetDigits(acc, D2U(res->digits)); 4134 decSetCoeff(res, set, acc, res->digits, &residue, status); 4135 #if DECSUBSET 4136 } 4137 else { /* subset arithmetic rounds from original significant digit */ 4138 /* May have an underestimate. This only occurs when both */ 4139 /* numbers fit in DECDPUN digits and are padding with a */ 4140 /* negative multiple (-10, -100...) and the top digit(s) become */ 4141 /* 0. (This only matters when using X3.274 rules where the */ 4142 /* leading zero could be included in the rounding.) */ 4143 if (res->digits<maxdigits) { 4144 *(acc+D2U(res->digits))=0; /* ensure leading 0 is there */ 4145 res->digits=maxdigits; 4146 } 4147 else { 4148 /* remove leading zeros that added due to rounding up to */ 4149 /* integral Units (but only those in excess of the original */ 4150 /* maxdigits length, unless extended) before test for rounding. */ 4151 if (res->digits>reqdigits) { 4152 res->digits=decGetDigits(acc, D2U(res->digits)); 4153 if (res->digits<maxdigits) res->digits=maxdigits; 4154 } 4155 } 4156 decSetCoeff(res, set, acc, res->digits, &residue, status); 4157 /* Now apply rounding if needed before removing leading zeros. */ 4158 /* This is safe because subnormals are not a possibility */ 4159 if (residue!=0) { 4160 decApplyRound(res, set, residue, status); 4161 residue=0; /* did what needed to be done */ 4162 } 4163 } /* subset */ 4164 #endif 4165 } /* used buffer */ 4166 4167 /* strip leading zeros [these were left on in case of subset subtract] */ 4168 res->digits=decGetDigits(res->lsu, D2U(res->digits)); 4169 4170 /* apply checks and rounding */ 4171 decFinish(res, set, &residue, status); 4172 4173 /* "When the sum of two operands with opposite signs is exactly */ 4174 /* zero, the sign of that sum shall be '+' in all rounding modes */ 4175 /* except round toward -Infinity, in which mode that sign shall be */ 4176 /* '-'." [Subset zeros also never have '-', set by decFinish.] */ 4177 if (ISZERO(res) && diffsign 4178 #if DECSUBSET 4179 && set->extended 4180 #endif 4181 && (*status&DEC_Inexact)==0) { 4182 if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG; /* sign - */ 4183 else res->bits&=~DECNEG; /* sign + */ 4184 } 4185 } while(0); /* end protected */ 4186 4187 if (allocacc!=NULL) free(allocacc); /* drop any storage used */ 4188 #if DECSUBSET 4189 if (allocrhs!=NULL) free(allocrhs); /* .. */ 4190 if (alloclhs!=NULL) free(alloclhs); /* .. */ 4191 #endif 4192 return res; 4193 } /* decAddOp */ 4194 4195 /* ------------------------------------------------------------------ */ 4196 /* decDivideOp -- division operation */ 4197 /* */ 4198 /* This routine performs the calculations for all four division */ 4199 /* operators (divide, divideInteger, remainder, remainderNear). */ 4200 /* */ 4201 /* C=A op B */ 4202 /* */ 4203 /* res is C, the result. C may be A and/or B (e.g., X=X/X) */ 4204 /* lhs is A */ 4205 /* rhs is B */ 4206 /* set is the context */ 4207 /* op is DIVIDE, DIVIDEINT, REMAINDER, or REMNEAR respectively. */ 4208 /* status is the usual accumulator */ 4209 /* */ 4210 /* C must have space for set->digits digits. */ 4211 /* */ 4212 /* ------------------------------------------------------------------ */ 4213 /* The underlying algorithm of this routine is the same as in the */ 4214 /* 1981 S/370 implementation, that is, non-restoring long division */ 4215 /* with bi-unit (rather than bi-digit) estimation for each unit */ 4216 /* multiplier. In this pseudocode overview, complications for the */ 4217 /* Remainder operators and division residues for exact rounding are */ 4218 /* omitted for clarity. */ 4219 /* */ 4220 /* Prepare operands and handle special values */ 4221 /* Test for x/0 and then 0/x */ 4222 /* Exp =Exp1 - Exp2 */ 4223 /* Exp =Exp +len(var1) -len(var2) */ 4224 /* Sign=Sign1 * Sign2 */ 4225 /* Pad accumulator (Var1) to double-length with 0's (pad1) */ 4226 /* Pad Var2 to same length as Var1 */ 4227 /* msu2pair/plus=1st 2 or 1 units of var2, +1 to allow for round */ 4228 /* have=0 */ 4229 /* Do until (have=digits+1 OR residue=0) */ 4230 /* if exp<0 then if integer divide/residue then leave */ 4231 /* this_unit=0 */ 4232 /* Do forever */ 4233 /* compare numbers */ 4234 /* if <0 then leave inner_loop */ 4235 /* if =0 then (* quick exit without subtract *) do */ 4236 /* this_unit=this_unit+1; output this_unit */ 4237 /* leave outer_loop; end */ 4238 /* Compare lengths of numbers (mantissae): */ 4239 /* If same then tops2=msu2pair -- {units 1&2 of var2} */ 4240 /* else tops2=msu2plus -- {0, unit 1 of var2} */ 4241 /* tops1=first_unit_of_Var1*10**DECDPUN +second_unit_of_var1 */ 4242 /* mult=tops1/tops2 -- Good and safe guess at divisor */ 4243 /* if mult=0 then mult=1 */ 4244 /* this_unit=this_unit+mult */ 4245 /* subtract */ 4246 /* end inner_loop */ 4247 /* if have\=0 | this_unit\=0 then do */ 4248 /* output this_unit */ 4249 /* have=have+1; end */ 4250 /* var2=var2/10 */ 4251 /* exp=exp-1 */ 4252 /* end outer_loop */ 4253 /* exp=exp+1 -- set the proper exponent */ 4254 /* if have=0 then generate answer=0 */ 4255 /* Return (Result is defined by Var1) */ 4256 /* */ 4257 /* ------------------------------------------------------------------ */ 4258 /* Two working buffers are needed during the division; one (digits+ */ 4259 /* 1) to accumulate the result, and the other (up to 2*digits+1) for */ 4260 /* long subtractions. These are acc and var1 respectively. */ 4261 /* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/ 4262 /* The static buffers may be larger than might be expected to allow */ 4263 /* for calls from higher-level functions (notably exp). */ 4264 /* ------------------------------------------------------------------ */ 4265 static decNumber * decDivideOp(decNumber *res, 4266 const decNumber *lhs, const decNumber *rhs, 4267 decContext *set, Flag op, uInt *status) { 4268 #if DECSUBSET 4269 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 4270 decNumber *allocrhs=NULL; /* .., rhs */ 4271 #endif 4272 Unit accbuff[SD2U(DECBUFFER+DECDPUN+10)]; /* local buffer */ 4273 Unit *acc=accbuff; /* -> accumulator array for result */ 4274 Unit *allocacc=NULL; /* -> allocated buffer, iff allocated */ 4275 Unit *accnext; /* -> where next digit will go */ 4276 Int acclength; /* length of acc needed [Units] */ 4277 Int accunits; /* count of units accumulated */ 4278 Int accdigits; /* count of digits accumulated */ 4279 4280 Unit varbuff[SD2U(DECBUFFER*2+DECDPUN)*sizeof(Unit)]; /* buffer for var1 */ 4281 Unit *var1=varbuff; /* -> var1 array for long subtraction */ 4282 Unit *varalloc=NULL; /* -> allocated buffer, iff used */ 4283 Unit *msu1; /* -> msu of var1 */ 4284 4285 const Unit *var2; /* -> var2 array */ 4286 const Unit *msu2; /* -> msu of var2 */ 4287 Int msu2plus; /* msu2 plus one [does not vary] */ 4288 eInt msu2pair; /* msu2 pair plus one [does not vary] */ 4289 4290 Int var1units, var2units; /* actual lengths */ 4291 Int var2ulen; /* logical length (units) */ 4292 Int var1initpad=0; /* var1 initial padding (digits) */ 4293 Int maxdigits; /* longest LHS or required acc length */ 4294 Int mult; /* multiplier for subtraction */ 4295 Unit thisunit; /* current unit being accumulated */ 4296 Int residue; /* for rounding */ 4297 Int reqdigits=set->digits; /* requested DIGITS */ 4298 Int exponent; /* working exponent */ 4299 Int maxexponent=0; /* DIVIDE maximum exponent if unrounded */ 4300 uByte bits; /* working sign */ 4301 Unit *target; /* work */ 4302 const Unit *source; /* .. */ 4303 uLong const *pow; /* .. */ 4304 Int shift, cut; /* .. */ 4305 #if DECSUBSET 4306 Int dropped; /* work */ 4307 #endif 4308 4309 #if DECCHECK 4310 if (decCheckOperands(res, lhs, rhs, set)) return res; 4311 #endif 4312 4313 do { /* protect allocated storage */ 4314 #if DECSUBSET 4315 if (!set->extended) { 4316 /* reduce operands and set lostDigits status, as needed */ 4317 if (lhs->digits>reqdigits) { 4318 alloclhs=decRoundOperand(lhs, set, status); 4319 if (alloclhs==NULL) break; 4320 lhs=alloclhs; 4321 } 4322 if (rhs->digits>reqdigits) { 4323 allocrhs=decRoundOperand(rhs, set, status); 4324 if (allocrhs==NULL) break; 4325 rhs=allocrhs; 4326 } 4327 } 4328 #endif 4329 /* [following code does not require input rounding] */ 4330 4331 bits=(lhs->bits^rhs->bits)&DECNEG; /* assumed sign for divisions */ 4332 4333 /* handle infinities and NaNs */ 4334 if (SPECIALARGS) { /* a special bit set */ 4335 if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */ 4336 decNaNs(res, lhs, rhs, set, status); 4337 break; 4338 } 4339 /* one or two infinities */ 4340 if (decNumberIsInfinite(lhs)) { /* LHS (dividend) is infinite */ 4341 if (decNumberIsInfinite(rhs) || /* two infinities are invalid .. */ 4342 op & (REMAINDER | REMNEAR)) { /* as is remainder of infinity */ 4343 *status|=DEC_Invalid_operation; 4344 break; 4345 } 4346 /* [Note that infinity/0 raises no exceptions] */ 4347 decNumberZero(res); 4348 res->bits=bits|DECINF; /* set +/- infinity */ 4349 break; 4350 } 4351 else { /* RHS (divisor) is infinite */ 4352 residue=0; 4353 if (op&(REMAINDER|REMNEAR)) { 4354 /* result is [finished clone of] lhs */ 4355 decCopyFit(res, lhs, set, &residue, status); 4356 } 4357 else { /* a division */ 4358 decNumberZero(res); 4359 res->bits=bits; /* set +/- zero */ 4360 /* for DIVIDEINT the exponent is always 0. For DIVIDE, result */ 4361 /* is a 0 with infinitely negative exponent, clamped to minimum */ 4362 if (op&DIVIDE) { 4363 res->exponent=set->emin-set->digits+1; 4364 *status|=DEC_Clamped; 4365 } 4366 } 4367 decFinish(res, set, &residue, status); 4368 break; 4369 } 4370 } 4371 4372 /* handle 0 rhs (x/0) */ 4373 if (ISZERO(rhs)) { /* x/0 is always exceptional */ 4374 if (ISZERO(lhs)) { 4375 decNumberZero(res); /* [after lhs test] */ 4376 *status|=DEC_Division_undefined;/* 0/0 will become NaN */ 4377 } 4378 else { 4379 decNumberZero(res); 4380 if (op&(REMAINDER|REMNEAR)) *status|=DEC_Invalid_operation; 4381 else { 4382 *status|=DEC_Division_by_zero; /* x/0 */ 4383 res->bits=bits|DECINF; /* .. is +/- Infinity */ 4384 } 4385 } 4386 break;} 4387 4388 /* handle 0 lhs (0/x) */ 4389 if (ISZERO(lhs)) { /* 0/x [x!=0] */ 4390 #if DECSUBSET 4391 if (!set->extended) decNumberZero(res); 4392 else { 4393 #endif 4394 if (op&DIVIDE) { 4395 residue=0; 4396 exponent=lhs->exponent-rhs->exponent; /* ideal exponent */ 4397 decNumberCopy(res, lhs); /* [zeros always fit] */ 4398 res->bits=bits; /* sign as computed */ 4399 res->exponent=exponent; /* exponent, too */ 4400 decFinalize(res, set, &residue, status); /* check exponent */ 4401 } 4402 else if (op&DIVIDEINT) { 4403 decNumberZero(res); /* integer 0 */ 4404 res->bits=bits; /* sign as computed */ 4405 } 4406 else { /* a remainder */ 4407 exponent=rhs->exponent; /* [save in case overwrite] */ 4408 decNumberCopy(res, lhs); /* [zeros always fit] */ 4409 if (exponent<res->exponent) res->exponent=exponent; /* use lower */ 4410 } 4411 #if DECSUBSET 4412 } 4413 #endif 4414 break;} 4415 4416 /* Precalculate exponent. This starts off adjusted (and hence fits */ 4417 /* in 31 bits) and becomes the usual unadjusted exponent as the */ 4418 /* division proceeds. The order of evaluation is important, here, */ 4419 /* to avoid wrap. */ 4420 exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits); 4421 4422 /* If the working exponent is -ve, then some quick exits are */ 4423 /* possible because the quotient is known to be <1 */ 4424 /* [for REMNEAR, it needs to be < -1, as -0.5 could need work] */ 4425 if (exponent<0 && !(op==DIVIDE)) { 4426 if (op&DIVIDEINT) { 4427 decNumberZero(res); /* integer part is 0 */ 4428 #if DECSUBSET 4429 if (set->extended) 4430 #endif 4431 res->bits=bits; /* set +/- zero */ 4432 break;} 4433 /* fastpath remainders so long as the lhs has the smaller */ 4434 /* (or equal) exponent */ 4435 if (lhs->exponent<=rhs->exponent) { 4436 if (op&REMAINDER || exponent<-1) { 4437 /* It is REMAINDER or safe REMNEAR; result is [finished */ 4438 /* clone of] lhs (r = x - 0*y) */ 4439 residue=0; 4440 decCopyFit(res, lhs, set, &residue, status); 4441 decFinish(res, set, &residue, status); 4442 break; 4443 } 4444 /* [unsafe REMNEAR drops through] */ 4445 } 4446 } /* fastpaths */ 4447 4448 /* Long (slow) division is needed; roll up the sleeves... */ 4449 4450 /* The accumulator will hold the quotient of the division. */ 4451 /* If it needs to be too long for stack storage, then allocate. */ 4452 acclength=D2U(reqdigits+DECDPUN); /* in Units */ 4453 if (acclength*sizeof(Unit)>sizeof(accbuff)) { 4454 /* printf("malloc dvacc %ld units\n", acclength); */ 4455 allocacc=(Unit *)malloc(acclength*sizeof(Unit)); 4456 if (allocacc==NULL) { /* hopeless -- abandon */ 4457 *status|=DEC_Insufficient_storage; 4458 break;} 4459 acc=allocacc; /* use the allocated space */ 4460 } 4461 4462 /* var1 is the padded LHS ready for subtractions. */ 4463 /* If it needs to be too long for stack storage, then allocate. */ 4464 /* The maximum units needed for var1 (long subtraction) is: */ 4465 /* Enough for */ 4466 /* (rhs->digits+reqdigits-1) -- to allow full slide to right */ 4467 /* or (lhs->digits) -- to allow for long lhs */ 4468 /* whichever is larger */ 4469 /* +1 -- for rounding of slide to right */ 4470 /* +1 -- for leading 0s */ 4471 /* +1 -- for pre-adjust if a remainder or DIVIDEINT */ 4472 /* [Note: unused units do not participate in decUnitAddSub data] */ 4473 maxdigits=rhs->digits+reqdigits-1; 4474 if (lhs->digits>maxdigits) maxdigits=lhs->digits; 4475 var1units=D2U(maxdigits)+2; 4476 /* allocate a guard unit above msu1 for REMAINDERNEAR */ 4477 if (!(op&DIVIDE)) var1units++; 4478 if ((var1units+1)*sizeof(Unit)>sizeof(varbuff)) { 4479 /* printf("malloc dvvar %ld units\n", var1units+1); */ 4480 varalloc=(Unit *)malloc((var1units+1)*sizeof(Unit)); 4481 if (varalloc==NULL) { /* hopeless -- abandon */ 4482 *status|=DEC_Insufficient_storage; 4483 break;} 4484 var1=varalloc; /* use the allocated space */ 4485 } 4486 4487 /* Extend the lhs and rhs to full long subtraction length. The lhs */ 4488 /* is truly extended into the var1 buffer, with 0 padding, so a */ 4489 /* subtract in place is always possible. The rhs (var2) has */ 4490 /* virtual padding (implemented by decUnitAddSub). */ 4491 /* One guard unit was allocated above msu1 for rem=rem+rem in */ 4492 /* REMAINDERNEAR. */ 4493 msu1=var1+var1units-1; /* msu of var1 */ 4494 source=lhs->lsu+D2U(lhs->digits)-1; /* msu of input array */ 4495 for (target=msu1; source>=lhs->lsu; source--, target--) *target=*source; 4496 for (; target>=var1; target--) *target=0; 4497 4498 /* rhs (var2) is left-aligned with var1 at the start */ 4499 var2ulen=var1units; /* rhs logical length (units) */ 4500 var2units=D2U(rhs->digits); /* rhs actual length (units) */ 4501 var2=rhs->lsu; /* -> rhs array */ 4502 msu2=var2+var2units-1; /* -> msu of var2 [never changes] */ 4503 /* now set up the variables which will be used for estimating the */ 4504 /* multiplication factor. If these variables are not exact, add */ 4505 /* 1 to make sure that the multiplier is never overestimated. */ 4506 msu2plus=*msu2; /* it's value .. */ 4507 if (var2units>1) msu2plus++; /* .. +1 if any more */ 4508 msu2pair=(eInt)*msu2*(DECDPUNMAX+1);/* top two pair .. */ 4509 if (var2units>1) { /* .. [else treat 2nd as 0] */ 4510 msu2pair+=*(msu2-1); /* .. */ 4511 if (var2units>2) msu2pair++; /* .. +1 if any more */ 4512 } 4513 4514 /* The calculation is working in units, which may have leading zeros, */ 4515 /* but the exponent was calculated on the assumption that they are */ 4516 /* both left-aligned. Adjust the exponent to compensate: add the */ 4517 /* number of leading zeros in var1 msu and subtract those in var2 msu. */ 4518 /* [This is actually done by counting the digits and negating, as */ 4519 /* lead1=DECDPUN-digits1, and similarly for lead2.] */ 4520 for (pow=&powers[1]; *msu1>=*pow; pow++) exponent--; 4521 for (pow=&powers[1]; *msu2>=*pow; pow++) exponent++; 4522 4523 /* Now, if doing an integer divide or remainder, ensure that */ 4524 /* the result will be Unit-aligned. To do this, shift the var1 */ 4525 /* accumulator towards least if need be. (It's much easier to */ 4526 /* do this now than to reassemble the residue afterwards, if */ 4527 /* doing a remainder.) Also ensure the exponent is not negative. */ 4528 if (!(op&DIVIDE)) { 4529 Unit *u; /* work */ 4530 /* save the initial 'false' padding of var1, in digits */ 4531 var1initpad=(var1units-D2U(lhs->digits))*DECDPUN; 4532 /* Determine the shift to do. */ 4533 if (exponent<0) cut=-exponent; 4534 else cut=DECDPUN-exponent%DECDPUN; 4535 decShiftToLeast(var1, var1units, cut); 4536 exponent+=cut; /* maintain numerical value */ 4537 var1initpad-=cut; /* .. and reduce padding */ 4538 /* clean any most-significant units which were just emptied */ 4539 for (u=msu1; cut>=DECDPUN; cut-=DECDPUN, u--) *u=0; 4540 } /* align */ 4541 else { /* is DIVIDE */ 4542 maxexponent=lhs->exponent-rhs->exponent; /* save */ 4543 /* optimization: if the first iteration will just produce 0, */ 4544 /* preadjust to skip it [valid for DIVIDE only] */ 4545 if (*msu1<*msu2) { 4546 var2ulen--; /* shift down */ 4547 exponent-=DECDPUN; /* update the exponent */ 4548 } 4549 } 4550 4551 /* ---- start the long-division loops ------------------------------ */ 4552 accunits=0; /* no units accumulated yet */ 4553 accdigits=0; /* .. or digits */ 4554 accnext=acc+acclength-1; /* -> msu of acc [NB: allows digits+1] */ 4555 for (;;) { /* outer forever loop */ 4556 thisunit=0; /* current unit assumed 0 */ 4557 /* find the next unit */ 4558 for (;;) { /* inner forever loop */ 4559 /* strip leading zero units [from either pre-adjust or from */ 4560 /* subtract last time around]. Leave at least one unit. */ 4561 for (; *msu1==0 && msu1>var1; msu1--) var1units--; 4562 4563 if (var1units<var2ulen) break; /* var1 too low for subtract */ 4564 if (var1units==var2ulen) { /* unit-by-unit compare needed */ 4565 /* compare the two numbers, from msu */ 4566 const Unit *pv1, *pv2; 4567 Unit v2; /* units to compare */ 4568 pv2=msu2; /* -> msu */ 4569 for (pv1=msu1; ; pv1--, pv2--) { 4570 /* v1=*pv1 -- always OK */ 4571 v2=0; /* assume in padding */ 4572 if (pv2>=var2) v2=*pv2; /* in range */ 4573 if (*pv1!=v2) break; /* no longer the same */ 4574 if (pv1==var1) break; /* done; leave pv1 as is */ 4575 } 4576 /* here when all inspected or a difference seen */ 4577 if (*pv1<v2) break; /* var1 too low to subtract */ 4578 if (*pv1==v2) { /* var1 == var2 */ 4579 /* reach here if var1 and var2 are identical; subtraction */ 4580 /* would increase digit by one, and the residue will be 0 so */ 4581 /* the calculation is done; leave the loop with residue=0. */ 4582 thisunit++; /* as though subtracted */ 4583 *var1=0; /* set var1 to 0 */ 4584 var1units=1; /* .. */ 4585 break; /* from inner */ 4586 } /* var1 == var2 */ 4587 /* *pv1>v2. Prepare for real subtraction; the lengths are equal */ 4588 /* Estimate the multiplier (there's always a msu1-1)... */ 4589 /* Bring in two units of var2 to provide a good estimate. */ 4590 mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2pair); 4591 } /* lengths the same */ 4592 else { /* var1units > var2ulen, so subtraction is safe */ 4593 /* The var2 msu is one unit towards the lsu of the var1 msu, */ 4594 /* so only one unit for var2 can be used. */ 4595 mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2plus); 4596 } 4597 if (mult==0) mult=1; /* must always be at least 1 */ 4598 /* subtraction needed; var1 is > var2 */ 4599 thisunit=(Unit)(thisunit+mult); /* accumulate */ 4600 /* subtract var1-var2, into var1; only the overlap needs */ 4601 /* processing, as this is an in-place calculation */ 4602 shift=var2ulen-var2units; 4603 #if DECTRACE 4604 decDumpAr('1', &var1[shift], var1units-shift); 4605 decDumpAr('2', var2, var2units); 4606 printf("m=%ld\n", -mult); 4607 #endif 4608 decUnitAddSub(&var1[shift], var1units-shift, 4609 var2, var2units, 0, 4610 &var1[shift], -mult); 4611 #if DECTRACE 4612 decDumpAr('#', &var1[shift], var1units-shift); 4613 #endif 4614 /* var1 now probably has leading zeros; these are removed at the */ 4615 /* top of the inner loop. */ 4616 } /* inner loop */ 4617 4618 /* The next unit has been calculated in full; unless it's a */ 4619 /* leading zero, add to acc */ 4620 if (accunits!=0 || thisunit!=0) { /* is first or non-zero */ 4621 *accnext=thisunit; /* store in accumulator */ 4622 /* account exactly for the new digits */ 4623 if (accunits==0) { 4624 accdigits++; /* at least one */ 4625 for (pow=&powers[1]; thisunit>=*pow; pow++) accdigits++; 4626 } 4627 else accdigits+=DECDPUN; 4628 accunits++; /* update count */ 4629 accnext--; /* ready for next */ 4630 if (accdigits>reqdigits) break; /* have enough digits */ 4631 } 4632 4633 /* if the residue is zero, the operation is done (unless divide */ 4634 /* or divideInteger and still not enough digits yet) */ 4635 if (*var1==0 && var1units==1) { /* residue is 0 */ 4636 if (op&(REMAINDER|REMNEAR)) break; 4637 if ((op&DIVIDE) && (exponent<=maxexponent)) break; 4638 /* [drop through if divideInteger] */ 4639 } 4640 /* also done enough if calculating remainder or integer */ 4641 /* divide and just did the last ('units') unit */ 4642 if (exponent==0 && !(op&DIVIDE)) break; 4643 4644 /* to get here, var1 is less than var2, so divide var2 by the per- */ 4645 /* Unit power of ten and go for the next digit */ 4646 var2ulen--; /* shift down */ 4647 exponent-=DECDPUN; /* update the exponent */ 4648 } /* outer loop */ 4649 4650 /* ---- division is complete --------------------------------------- */ 4651 /* here: acc has at least reqdigits+1 of good results (or fewer */ 4652 /* if early stop), starting at accnext+1 (its lsu) */ 4653 /* var1 has any residue at the stopping point */ 4654 /* accunits is the number of digits collected in acc */ 4655 if (accunits==0) { /* acc is 0 */ 4656 accunits=1; /* show have a unit .. */ 4657 accdigits=1; /* .. */ 4658 *accnext=0; /* .. whose value is 0 */ 4659 } 4660 else accnext++; /* back to last placed */ 4661 /* accnext now -> lowest unit of result */ 4662 4663 residue=0; /* assume no residue */ 4664 if (op&DIVIDE) { 4665 /* record the presence of any residue, for rounding */ 4666 if (*var1!=0 || var1units>1) residue=1; 4667 else { /* no residue */ 4668 /* Had an exact division; clean up spurious trailing 0s. */ 4669 /* There will be at most DECDPUN-1, from the final multiply, */ 4670 /* and then only if the result is non-0 (and even) and the */ 4671 /* exponent is 'loose'. */ 4672 #if DECDPUN>1 4673 Unit lsu=*accnext; 4674 if (!(lsu&0x01) && (lsu!=0)) { 4675 /* count the trailing zeros */ 4676 Int drop=0; 4677 for (;; drop++) { /* [will terminate because lsu!=0] */ 4678 if (exponent>=maxexponent) break; /* don't chop real 0s */ 4679 #if DECDPUN<=4 4680 if ((lsu-QUOT10(lsu, drop+1) 4681 *powers[drop+1])!=0) break; /* found non-0 digit */ 4682 #else 4683 if (lsu%powers[drop+1]!=0) break; /* found non-0 digit */ 4684 #endif 4685 exponent++; 4686 } 4687 if (drop>0) { 4688 accunits=decShiftToLeast(accnext, accunits, drop); 4689 accdigits=decGetDigits(accnext, accunits); 4690 accunits=D2U(accdigits); 4691 /* [exponent was adjusted in the loop] */ 4692 } 4693 } /* neither odd nor 0 */ 4694 #endif 4695 } /* exact divide */ 4696 } /* divide */ 4697 else /* op!=DIVIDE */ { 4698 /* check for coefficient overflow */ 4699 if (accdigits+exponent>reqdigits) { 4700 *status|=DEC_Division_impossible; 4701 break; 4702 } 4703 if (op & (REMAINDER|REMNEAR)) { 4704 /* [Here, the exponent will be 0, because var1 was adjusted */ 4705 /* appropriately.] */ 4706 Int postshift; /* work */ 4707 Flag wasodd=0; /* integer was odd */ 4708 Unit *quotlsu; /* for save */ 4709 Int quotdigits; /* .. */ 4710 4711 bits=lhs->bits; /* remainder sign is always as lhs */ 4712 4713 /* Fastpath when residue is truly 0 is worthwhile [and */ 4714 /* simplifies the code below] */ 4715 if (*var1==0 && var1units==1) { /* residue is 0 */ 4716 Int exp=lhs->exponent; /* save min(exponents) */ 4717 if (rhs->exponent<exp) exp=rhs->exponent; 4718 decNumberZero(res); /* 0 coefficient */ 4719 #if DECSUBSET 4720 if (set->extended) 4721 #endif 4722 res->exponent=exp; /* .. with proper exponent */ 4723 res->bits=(uByte)(bits&DECNEG); /* [cleaned] */ 4724 decFinish(res, set, &residue, status); /* might clamp */ 4725 break; 4726 } 4727 /* note if the quotient was odd */ 4728 if (*accnext & 0x01) wasodd=1; /* acc is odd */ 4729 quotlsu=accnext; /* save in case need to reinspect */ 4730 quotdigits=accdigits; /* .. */ 4731 4732 /* treat the residue, in var1, as the value to return, via acc */ 4733 /* calculate the unused zero digits. This is the smaller of: */ 4734 /* var1 initial padding (saved above) */ 4735 /* var2 residual padding, which happens to be given by: */ 4736 postshift=var1initpad+exponent-lhs->exponent+rhs->exponent; 4737 /* [the 'exponent' term accounts for the shifts during divide] */ 4738 if (var1initpad<postshift) postshift=var1initpad; 4739 4740 /* shift var1 the requested amount, and adjust its digits */ 4741 var1units=decShiftToLeast(var1, var1units, postshift); 4742 accnext=var1; 4743 accdigits=decGetDigits(var1, var1units); 4744 accunits=D2U(accdigits); 4745 4746 exponent=lhs->exponent; /* exponent is smaller of lhs & rhs */ 4747 if (rhs->exponent<exponent) exponent=rhs->exponent; 4748 4749 /* Now correct the result if doing remainderNear; if it */ 4750 /* (looking just at coefficients) is > rhs/2, or == rhs/2 and */ 4751 /* the integer was odd then the result should be rem-rhs. */ 4752 if (op&REMNEAR) { 4753 Int compare, tarunits; /* work */ 4754 Unit *up; /* .. */ 4755 /* calculate remainder*2 into the var1 buffer (which has */ 4756 /* 'headroom' of an extra unit and hence enough space) */ 4757 /* [a dedicated 'double' loop would be faster, here] */ 4758 tarunits=decUnitAddSub(accnext, accunits, accnext, accunits, 4759 0, accnext, 1); 4760 /* decDumpAr('r', accnext, tarunits); */ 4761 4762 /* Here, accnext (var1) holds tarunits Units with twice the */ 4763 /* remainder's coefficient, which must now be compared to the */ 4764 /* RHS. The remainder's exponent may be smaller than the RHS's. */ 4765 compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits), 4766 rhs->exponent-exponent); 4767 if (compare==BADINT) { /* deep trouble */ 4768 *status|=DEC_Insufficient_storage; 4769 break;} 4770 4771 /* now restore the remainder by dividing by two; the lsu */ 4772 /* is known to be even. */ 4773 for (up=accnext; up<accnext+tarunits; up++) { 4774 Int half; /* half to add to lower unit */ 4775 half=*up & 0x01; 4776 *up/=2; /* [shift] */ 4777 if (!half) continue; 4778 *(up-1)+=DIV_ROUND_UP(DECDPUNMAX, 2); 4779 } 4780 /* [accunits still describes the original remainder length] */ 4781 4782 if (compare>0 || (compare==0 && wasodd)) { /* adjustment needed */ 4783 Int exp, expunits, exprem; /* work */ 4784 /* This is effectively causing round-up of the quotient, */ 4785 /* so if it was the rare case where it was full and all */ 4786 /* nines, it would overflow and hence division-impossible */ 4787 /* should be raised */ 4788 Flag allnines=0; /* 1 if quotient all nines */ 4789 if (quotdigits==reqdigits) { /* could be borderline */ 4790 for (up=quotlsu; ; up++) { 4791 if (quotdigits>DECDPUN) { 4792 if (*up!=DECDPUNMAX) break;/* non-nines */ 4793 } 4794 else { /* this is the last Unit */ 4795 if (*up==powers[quotdigits]-1) allnines=1; 4796 break; 4797 } 4798 quotdigits-=DECDPUN; /* checked those digits */ 4799 } /* up */ 4800 } /* borderline check */ 4801 if (allnines) { 4802 *status|=DEC_Division_impossible; 4803 break;} 4804 4805 /* rem-rhs is needed; the sign will invert. Again, var1 */ 4806 /* can safely be used for the working Units array. */ 4807 exp=rhs->exponent-exponent; /* RHS padding needed */ 4808 /* Calculate units and remainder from exponent. */ 4809 expunits=exp/DECDPUN; 4810 exprem=exp%DECDPUN; 4811 /* subtract [A+B*(-m)]; the result will always be negative */ 4812 accunits=-decUnitAddSub(accnext, accunits, 4813 rhs->lsu, D2U(rhs->digits), 4814 expunits, accnext, -(Int)powers[exprem]); 4815 accdigits=decGetDigits(accnext, accunits); /* count digits exactly */ 4816 accunits=D2U(accdigits); /* and recalculate the units for copy */ 4817 /* [exponent is as for original remainder] */ 4818 bits^=DECNEG; /* flip the sign */ 4819 } 4820 } /* REMNEAR */ 4821 } /* REMAINDER or REMNEAR */ 4822 } /* not DIVIDE */ 4823 4824 /* Set exponent and bits */ 4825 res->exponent=exponent; 4826 res->bits=(uByte)(bits&DECNEG); /* [cleaned] */ 4827 4828 /* Now the coefficient. */ 4829 decSetCoeff(res, set, accnext, accdigits, &residue, status); 4830 4831 decFinish(res, set, &residue, status); /* final cleanup */ 4832 4833 #if DECSUBSET 4834 /* If a divide then strip trailing zeros if subset [after round] */ 4835 if (!set->extended && (op==DIVIDE)) decTrim(res, set, 0, &dropped); 4836 #endif 4837 } while(0); /* end protected */ 4838 4839 if (varalloc!=NULL) free(varalloc); /* drop any storage used */ 4840 if (allocacc!=NULL) free(allocacc); /* .. */ 4841 #if DECSUBSET 4842 if (allocrhs!=NULL) free(allocrhs); /* .. */ 4843 if (alloclhs!=NULL) free(alloclhs); /* .. */ 4844 #endif 4845 return res; 4846 } /* decDivideOp */ 4847 4848 /* ------------------------------------------------------------------ */ 4849 /* decMultiplyOp -- multiplication operation */ 4850 /* */ 4851 /* This routine performs the multiplication C=A x B. */ 4852 /* */ 4853 /* res is C, the result. C may be A and/or B (e.g., X=X*X) */ 4854 /* lhs is A */ 4855 /* rhs is B */ 4856 /* set is the context */ 4857 /* status is the usual accumulator */ 4858 /* */ 4859 /* C must have space for set->digits digits. */ 4860 /* */ 4861 /* ------------------------------------------------------------------ */ 4862 /* 'Classic' multiplication is used rather than Karatsuba, as the */ 4863 /* latter would give only a minor improvement for the short numbers */ 4864 /* expected to be handled most (and uses much more memory). */ 4865 /* */ 4866 /* There are two major paths here: the general-purpose ('old code') */ 4867 /* path which handles all DECDPUN values, and a fastpath version */ 4868 /* which is used if 64-bit ints are available, DECDPUN<=4, and more */ 4869 /* than two calls to decUnitAddSub would be made. */ 4870 /* */ 4871 /* The fastpath version lumps units together into 8-digit or 9-digit */ 4872 /* chunks, and also uses a lazy carry strategy to minimise expensive */ 4873 /* 64-bit divisions. The chunks are then broken apart again into */ 4874 /* units for continuing processing. Despite this overhead, the */ 4875 /* fastpath can speed up some 16-digit operations by 10x (and much */ 4876 /* more for higher-precision calculations). */ 4877 /* */ 4878 /* A buffer always has to be used for the accumulator; in the */ 4879 /* fastpath, buffers are also always needed for the chunked copies of */ 4880 /* of the operand coefficients. */ 4881 /* Static buffers are larger than needed just for multiply, to allow */ 4882 /* for calls from other operations (notably exp). */ 4883 /* ------------------------------------------------------------------ */ 4884 #define FASTMUL (DECUSE64 && DECDPUN<5) 4885 static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs, 4886 const decNumber *rhs, decContext *set, 4887 uInt *status) { 4888 Int accunits; /* Units of accumulator in use */ 4889 Int exponent; /* work */ 4890 Int residue=0; /* rounding residue */ 4891 uByte bits; /* result sign */ 4892 Unit *acc; /* -> accumulator Unit array */ 4893 Int needbytes; /* size calculator */ 4894 void *allocacc=NULL; /* -> allocated accumulator, iff allocated */ 4895 Unit accbuff[SD2U(DECBUFFER*4+1)]; /* buffer (+1 for DECBUFFER==0, */ 4896 /* *4 for calls from other operations) */ 4897 const Unit *mer, *mermsup; /* work */ 4898 Int madlength; /* Units in multiplicand */ 4899 Int shift; /* Units to shift multiplicand by */ 4900 4901 #if FASTMUL 4902 /* if DECDPUN is 1 or 3 work in base 10**9, otherwise */ 4903 /* (DECDPUN is 2 or 4) then work in base 10**8 */ 4904 #if DECDPUN & 1 /* odd */ 4905 #define FASTBASE 1000000000 /* base */ 4906 #define FASTDIGS 9 /* digits in base */ 4907 #define FASTLAZY 18 /* carry resolution point [1->18] */ 4908 #else 4909 #define FASTBASE 100000000 4910 #define FASTDIGS 8 4911 #define FASTLAZY 1844 /* carry resolution point [1->1844] */ 4912 #endif 4913 /* three buffers are used, two for chunked copies of the operands */ 4914 /* (base 10**8 or base 10**9) and one base 2**64 accumulator with */ 4915 /* lazy carry evaluation */ 4916 uInt zlhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */ 4917 uInt *zlhi=zlhibuff; /* -> lhs array */ 4918 uInt *alloclhi=NULL; /* -> allocated buffer, iff allocated */ 4919 uInt zrhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */ 4920 uInt *zrhi=zrhibuff; /* -> rhs array */ 4921 uInt *allocrhi=NULL; /* -> allocated buffer, iff allocated */ 4922 uLong zaccbuff[(DECBUFFER*2+1)/4+2]; /* buffer (+1 for DECBUFFER==0) */ 4923 /* [allocacc is shared for both paths, as only one will run] */ 4924 uLong *zacc=zaccbuff; /* -> accumulator array for exact result */ 4925 #if DECDPUN==1 4926 Int zoff; /* accumulator offset */ 4927 #endif 4928 uInt *lip, *rip; /* item pointers */ 4929 uInt *lmsi, *rmsi; /* most significant items */ 4930 Int ilhs, irhs, iacc; /* item counts in the arrays */ 4931 Int lazy; /* lazy carry counter */ 4932 uLong lcarry; /* uLong carry */ 4933 uInt carry; /* carry (NB not uLong) */ 4934 Int count; /* work */ 4935 const Unit *cup; /* .. */ 4936 Unit *up; /* .. */ 4937 uLong *lp; /* .. */ 4938 Int p; /* .. */ 4939 #endif 4940 4941 #if DECSUBSET 4942 decNumber *alloclhs=NULL; /* -> allocated buffer, iff allocated */ 4943 decNumber *allocrhs=NULL; /* -> allocated buffer, iff allocated */ 4944 #endif 4945 4946 #if DECCHECK 4947 if (decCheckOperands(res, lhs, rhs, set)) return res; 4948 #endif 4949 4950 /* precalculate result sign */ 4951 bits=(uByte)((lhs->bits^rhs->bits)&DECNEG); 4952 4953 /* handle infinities and NaNs */ 4954 if (SPECIALARGS) { /* a special bit set */ 4955 if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */ 4956 decNaNs(res, lhs, rhs, set, status); 4957 return res;} 4958 /* one or two infinities; Infinity * 0 is invalid */ 4959 if (((lhs->bits & DECINF)==0 && ISZERO(lhs)) 4960 ||((rhs->bits & DECINF)==0 && ISZERO(rhs))) { 4961 *status|=DEC_Invalid_operation; 4962 return res;} 4963 decNumberZero(res); 4964 res->bits=bits|DECINF; /* infinity */ 4965 return res;} 4966 4967 /* For best speed, as in DMSRCN [the original Rexx numerics */ 4968 /* module], use the shorter number as the multiplier (rhs) and */ 4969 /* the longer as the multiplicand (lhs) to minimise the number of */ 4970 /* adds (partial products) */ 4971 if (lhs->digits<rhs->digits) { /* swap... */ 4972 const decNumber *hold=lhs; 4973 lhs=rhs; 4974 rhs=hold; 4975 } 4976 4977 do { /* protect allocated storage */ 4978 #if DECSUBSET 4979 if (!set->extended) { 4980 /* reduce operands and set lostDigits status, as needed */ 4981 if (lhs->digits>set->digits) { 4982 alloclhs=decRoundOperand(lhs, set, status); 4983 if (alloclhs==NULL) break; 4984 lhs=alloclhs; 4985 } 4986 if (rhs->digits>set->digits) { 4987 allocrhs=decRoundOperand(rhs, set, status); 4988 if (allocrhs==NULL) break; 4989 rhs=allocrhs; 4990 } 4991 } 4992 #endif 4993 /* [following code does not require input rounding] */ 4994 4995 #if FASTMUL /* fastpath can be used */ 4996 /* use the fast path if there are enough digits in the shorter */ 4997 /* operand to make the setup and takedown worthwhile */ 4998 #define NEEDTWO (DECDPUN*2) /* within two decUnitAddSub calls */ 4999 if (rhs->digits>NEEDTWO) { /* use fastpath... */ 5000 /* calculate the number of elements in each array */ 5001 ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; /* [ceiling] */ 5002 irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; /* .. */ 5003 iacc=ilhs+irhs; 5004 5005 /* allocate buffers if required, as usual */ 5006 needbytes=ilhs*sizeof(uInt); 5007 if (needbytes>(Int)sizeof(zlhibuff)) { 5008 alloclhi=(uInt *)malloc(needbytes); 5009 zlhi=alloclhi;} 5010 needbytes=irhs*sizeof(uInt); 5011 if (needbytes>(Int)sizeof(zrhibuff)) { 5012 allocrhi=(uInt *)malloc(needbytes); 5013 zrhi=allocrhi;} 5014 5015 /* Allocating the accumulator space needs a special case when */ 5016 /* DECDPUN=1 because when converting the accumulator to Units */ 5017 /* after the multiplication each 8-byte item becomes 9 1-byte */ 5018 /* units. Therefore iacc extra bytes are needed at the front */ 5019 /* (rounded up to a multiple of 8 bytes), and the uLong */ 5020 /* accumulator starts offset the appropriate number of units */ 5021 /* to the right to avoid overwrite during the unchunking. */ 5022 needbytes=iacc*sizeof(uLong); 5023 #if DECDPUN==1 5024 zoff=(iacc+7)/8; /* items to offset by */ 5025 needbytes+=zoff*8; 5026 #endif 5027 if (needbytes>(Int)sizeof(zaccbuff)) { 5028 allocacc=(uLong *)malloc(needbytes); 5029 zacc=(uLong *)allocacc;} 5030 if (zlhi==NULL||zrhi==NULL||zacc==NULL) { 5031 *status|=DEC_Insufficient_storage; 5032 break;} 5033 5034 acc=(Unit *)zacc; /* -> target Unit array */ 5035 #if DECDPUN==1 5036 zacc+=zoff; /* start uLong accumulator to right */ 5037 #endif 5038 5039 /* assemble the chunked copies of the left and right sides */ 5040 for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++) 5041 for (p=0, *lip=0; p<FASTDIGS && count>0; 5042 p+=DECDPUN, cup++, count-=DECDPUN) 5043 *lip+=*cup*powers[p]; 5044 lmsi=lip-1; /* save -> msi */ 5045 for (count=rhs->digits, cup=rhs->lsu, rip=zrhi; count>0; rip++) 5046 for (p=0, *rip=0; p<FASTDIGS && count>0; 5047 p+=DECDPUN, cup++, count-=DECDPUN) 5048 *rip+=*cup*powers[p]; 5049 rmsi=rip-1; /* save -> msi */ 5050 5051 /* zero the accumulator */ 5052 for (lp=zacc; lp<zacc+iacc; lp++) *lp=0; 5053 5054 /* Start the multiplication */ 5055 /* Resolving carries can dominate the cost of accumulating the */ 5056 /* partial products, so this is only done when necessary. */ 5057 /* Each uLong item in the accumulator can hold values up to */ 5058 /* 2**64-1, and each partial product can be as large as */ 5059 /* (10**FASTDIGS-1)**2. When FASTDIGS=9, this can be added to */ 5060 /* itself 18.4 times in a uLong without overflowing, so during */ 5061 /* the main calculation resolution is carried out every 18th */ 5062 /* add -- every 162 digits. Similarly, when FASTDIGS=8, the */ 5063 /* partial products can be added to themselves 1844.6 times in */ 5064 /* a uLong without overflowing, so intermediate carry */ 5065 /* resolution occurs only every 14752 digits. Hence for common */ 5066 /* short numbers usually only the one final carry resolution */ 5067 /* occurs. */ 5068 /* (The count is set via FASTLAZY to simplify experiments to */ 5069 /* measure the value of this approach: a 35% improvement on a */ 5070 /* [34x34] multiply.) */ 5071 lazy=FASTLAZY; /* carry delay count */ 5072 for (rip=zrhi; rip<=rmsi; rip++) { /* over each item in rhs */ 5073 lp=zacc+(rip-zrhi); /* where to add the lhs */ 5074 for (lip=zlhi; lip<=lmsi; lip++, lp++) { /* over each item in lhs */ 5075 *lp+=(uLong)(*lip)*(*rip); /* [this should in-line] */ 5076 } /* lip loop */ 5077 lazy--; 5078 if (lazy>0 && rip!=rmsi) continue; 5079 lazy=FASTLAZY; /* reset delay count */ 5080 /* spin up the accumulator resolving overflows */ 5081 for (lp=zacc; lp<zacc+iacc; lp++) { 5082 if (*lp<FASTBASE) continue; /* it fits */ 5083 lcarry=*lp/FASTBASE; /* top part [slow divide] */ 5084 /* lcarry can exceed 2**32-1, so check again; this check */ 5085 /* and occasional extra divide (slow) is well worth it, as */ 5086 /* it allows FASTLAZY to be increased to 18 rather than 4 */ 5087 /* in the FASTDIGS=9 case */ 5088 if (lcarry<FASTBASE) carry=(uInt)lcarry; /* [usual] */ 5089 else { /* two-place carry [fairly rare] */ 5090 uInt carry2=(uInt)(lcarry/FASTBASE); /* top top part */ 5091 *(lp+2)+=carry2; /* add to item+2 */ 5092 *lp-=((uLong)FASTBASE*FASTBASE*carry2); /* [slow] */ 5093 carry=(uInt)(lcarry-((uLong)FASTBASE*carry2)); /* [inline] */ 5094 } 5095 *(lp+1)+=carry; /* add to item above [inline] */ 5096 *lp-=((uLong)FASTBASE*carry); /* [inline] */ 5097 } /* carry resolution */ 5098 } /* rip loop */ 5099 5100 /* The multiplication is complete; time to convert back into */ 5101 /* units. This can be done in-place in the accumulator and in */ 5102 /* 32-bit operations, because carries were resolved after the */ 5103 /* final add. This needs N-1 divides and multiplies for */ 5104 /* each item in the accumulator (which will become up to N */ 5105 /* units, where 2<=N<=9). */ 5106 for (lp=zacc, up=acc; lp<zacc+iacc; lp++) { 5107 uInt item=(uInt)*lp; /* decapitate to uInt */ 5108 for (p=0; p<FASTDIGS-DECDPUN; p+=DECDPUN, up++) { 5109 uInt part=item/(DECDPUNMAX+1); 5110 *up=(Unit)(item-(part*(DECDPUNMAX+1))); 5111 item=part; 5112 } /* p */ 5113 *up=(Unit)item; up++; /* [final needs no division] */ 5114 } /* lp */ 5115 accunits=up-acc; /* count of units */ 5116 } 5117 else { /* here to use units directly, without chunking ['old code'] */ 5118 #endif 5119 5120 /* if accumulator will be too long for local storage, then allocate */ 5121 acc=accbuff; /* -> assume buffer for accumulator */ 5122 needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit); 5123 if (needbytes>(Int)sizeof(accbuff)) { 5124 allocacc=(Unit *)malloc(needbytes); 5125 if (allocacc==NULL) {*status|=DEC_Insufficient_storage; break;} 5126 acc=(Unit *)allocacc; /* use the allocated space */ 5127 } 5128 5129 /* Now the main long multiplication loop */ 5130 /* Unlike the equivalent in the IBM Java implementation, there */ 5131 /* is no advantage in calculating from msu to lsu. So, do it */ 5132 /* by the book, as it were. */ 5133 /* Each iteration calculates ACC=ACC+MULTAND*MULT */ 5134 accunits=1; /* accumulator starts at '0' */ 5135 *acc=0; /* .. (lsu=0) */ 5136 shift=0; /* no multiplicand shift at first */ 5137 madlength=D2U(lhs->digits); /* this won't change */ 5138 mermsup=rhs->lsu+D2U(rhs->digits); /* -> msu+1 of multiplier */ 5139 5140 for (mer=rhs->lsu; mer<mermsup; mer++) { 5141 /* Here, *mer is the next Unit in the multiplier to use */ 5142 /* If non-zero [optimization] add it... */ 5143 if (*mer!=0) accunits=decUnitAddSub(&acc[shift], accunits-shift, 5144 lhs->lsu, madlength, 0, 5145 &acc[shift], *mer) 5146 + shift; 5147 else { /* extend acc with a 0; it will be used shortly */ 5148 *(acc+accunits)=0; /* [this avoids length of <=0 later] */ 5149 accunits++; 5150 } 5151 /* multiply multiplicand by 10**DECDPUN for next Unit to left */ 5152 shift++; /* add this for 'logical length' */ 5153 } /* n */ 5154 #if FASTMUL 5155 } /* unchunked units */ 5156 #endif 5157 /* common end-path */ 5158 #if DECTRACE 5159 decDumpAr('*', acc, accunits); /* Show exact result */ 5160 #endif 5161 5162 /* acc now contains the exact result of the multiplication, */ 5163 /* possibly with a leading zero unit; build the decNumber from */ 5164 /* it, noting if any residue */ 5165 res->bits=bits; /* set sign */ 5166 res->digits=decGetDigits(acc, accunits); /* count digits exactly */ 5167 5168 /* There can be a 31-bit wrap in calculating the exponent. */ 5169 /* This can only happen if both input exponents are negative and */ 5170 /* both their magnitudes are large. If there was a wrap, set a */ 5171 /* safe very negative exponent, from which decFinalize() will */ 5172 /* raise a hard underflow shortly. */ 5173 exponent=lhs->exponent+rhs->exponent; /* calculate exponent */ 5174 if (lhs->exponent<0 && rhs->exponent<0 && exponent>0) 5175 exponent=-2*DECNUMMAXE; /* force underflow */ 5176 res->exponent=exponent; /* OK to overwrite now */ 5177 5178 5179 /* Set the coefficient. If any rounding, residue records */ 5180 decSetCoeff(res, set, acc, res->digits, &residue, status); 5181 decFinish(res, set, &residue, status); /* final cleanup */ 5182 } while(0); /* end protected */ 5183 5184 if (allocacc!=NULL) free(allocacc); /* drop any storage used */ 5185 #if DECSUBSET 5186 if (allocrhs!=NULL) free(allocrhs); /* .. */ 5187 if (alloclhs!=NULL) free(alloclhs); /* .. */ 5188 #endif 5189 #if FASTMUL 5190 if (allocrhi!=NULL) free(allocrhi); /* .. */ 5191 if (alloclhi!=NULL) free(alloclhi); /* .. */ 5192 #endif 5193 return res; 5194 } /* decMultiplyOp */ 5195 5196 /* ------------------------------------------------------------------ */ 5197 /* decExpOp -- effect exponentiation */ 5198 /* */ 5199 /* This computes C = exp(A) */ 5200 /* */ 5201 /* res is C, the result. C may be A */ 5202 /* rhs is A */ 5203 /* set is the context; note that rounding mode has no effect */ 5204 /* */ 5205 /* C must have space for set->digits digits. status is updated but */ 5206 /* not set. */ 5207 /* */ 5208 /* Restrictions: */ 5209 /* */ 5210 /* digits, emax, and -emin in the context must be less than */ 5211 /* 2*DEC_MAX_MATH (1999998), and the rhs must be within these */ 5212 /* bounds or a zero. This is an internal routine, so these */ 5213 /* restrictions are contractual and not enforced. */ 5214 /* */ 5215 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */ 5216 /* almost always be correctly rounded, but may be up to 1 ulp in */ 5217 /* error in rare cases. */ 5218 /* */ 5219 /* Finite results will always be full precision and Inexact, except */ 5220 /* when A is a zero or -Infinity (giving 1 or 0 respectively). */ 5221 /* ------------------------------------------------------------------ */ 5222 /* This approach used here is similar to the algorithm described in */ 5223 /* */ 5224 /* Variable Precision Exponential Function, T. E. Hull and */ 5225 /* A. Abrham, ACM Transactions on Mathematical Software, Vol 12 #2, */ 5226 /* pp79-91, ACM, June 1986. */ 5227 /* */ 5228 /* with the main difference being that the iterations in the series */ 5229 /* evaluation are terminated dynamically (which does not require the */ 5230 /* extra variable-precision variables which are expensive in this */ 5231 /* context). */ 5232 /* */ 5233 /* The error analysis in Hull & Abrham's paper applies except for the */ 5234 /* round-off error accumulation during the series evaluation. This */ 5235 /* code does not precalculate the number of iterations and so cannot */ 5236 /* use Horner's scheme. Instead, the accumulation is done at double- */ 5237 /* precision, which ensures that the additions of the terms are exact */ 5238 /* and do not accumulate round-off (and any round-off errors in the */ 5239 /* terms themselves move 'to the right' faster than they can */ 5240 /* accumulate). This code also extends the calculation by allowing, */ 5241 /* in the spirit of other decNumber operators, the input to be more */ 5242 /* precise than the result (the precision used is based on the more */ 5243 /* precise of the input or requested result). */ 5244 /* */ 5245 /* Implementation notes: */ 5246 /* */ 5247 /* 1. This is separated out as decExpOp so it can be called from */ 5248 /* other Mathematical functions (notably Ln) with a wider range */ 5249 /* than normal. In particular, it can handle the slightly wider */ 5250 /* (double) range needed by Ln (which has to be able to calculate */ 5251 /* exp(-x) where x can be the tiniest number (Ntiny). */ 5252 /* */ 5253 /* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop */ 5254 /* iterations by approximately a third with additional (although */ 5255 /* diminishing) returns as the range is reduced to even smaller */ 5256 /* fractions. However, h (the power of 10 used to correct the */ 5257 /* result at the end, see below) must be kept <=8 as otherwise */ 5258 /* the final result cannot be computed. Hence the leverage is a */ 5259 /* sliding value (8-h), where potentially the range is reduced */ 5260 /* more for smaller values. */ 5261 /* */ 5262 /* The leverage that can be applied in this way is severely */ 5263 /* limited by the cost of the raise-to-the power at the end, */ 5264 /* which dominates when the number of iterations is small (less */ 5265 /* than ten) or when rhs is short. As an example, the adjustment */ 5266 /* x**10,000,000 needs 31 multiplications, all but one full-width. */ 5267 /* */ 5268 /* 3. The restrictions (especially precision) could be raised with */ 5269 /* care, but the full decNumber range seems very hard within the */ 5270 /* 32-bit limits. */ 5271 /* */ 5272 /* 4. The working precisions for the static buffers are twice the */ 5273 /* obvious size to allow for calls from decNumberPower. */ 5274 /* ------------------------------------------------------------------ */ 5275 static decNumber *decExpOp(decNumber *res, const decNumber *rhs, 5276 decContext *set, uInt *status) { 5277 uInt ignore=0; /* working status */ 5278 Int h; /* adjusted exponent for 0.xxxx */ 5279 Int p; /* working precision */ 5280 Int residue; /* rounding residue */ 5281 uInt needbytes; /* for space calculations */ 5282 const decNumber *x=rhs; /* (may point to safe copy later) */ 5283 decContext aset, tset, dset; /* working contexts */ 5284 Int comp; /* work */ 5285 5286 /* the argument is often copied to normalize it, so (unusually) it */ 5287 /* is treated like other buffers, using DECBUFFER, +1 in case */ 5288 /* DECBUFFER is 0 */ 5289 decNumber bufr[D2N(DECBUFFER*2+1)]; 5290 decNumber *allocrhs=NULL; /* non-NULL if rhs buffer allocated */ 5291 5292 /* the working precision will be no more than set->digits+8+1 */ 5293 /* so for on-stack buffers DECBUFFER+9 is used, +1 in case DECBUFFER */ 5294 /* is 0 (and twice that for the accumulator) */ 5295 5296 /* buffer for t, term (working precision plus) */ 5297 decNumber buft[D2N(DECBUFFER*2+9+1)]; 5298 decNumber *allocbuft=NULL; /* -> allocated buft, iff allocated */ 5299 decNumber *t=buft; /* term */ 5300 /* buffer for a, accumulator (working precision * 2), at least 9 */ 5301 decNumber bufa[D2N(DECBUFFER*4+18+1)]; 5302 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 5303 decNumber *a=bufa; /* accumulator */ 5304 /* decNumber for the divisor term; this needs at most 9 digits */ 5305 /* and so can be fixed size [16 so can use standard context] */ 5306 decNumber bufd[D2N(16)]; 5307 decNumber *d=bufd; /* divisor */ 5308 decNumber numone; /* constant 1 */ 5309 5310 #if DECCHECK 5311 Int iterations=0; /* for later sanity check */ 5312 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 5313 #endif 5314 5315 do { /* protect allocated storage */ 5316 if (SPECIALARG) { /* handle infinities and NaNs */ 5317 if (decNumberIsInfinite(rhs)) { /* an infinity */ 5318 if (decNumberIsNegative(rhs)) /* -Infinity -> +0 */ 5319 decNumberZero(res); 5320 else decNumberCopy(res, rhs); /* +Infinity -> self */ 5321 } 5322 else decNaNs(res, rhs, NULL, set, status); /* a NaN */ 5323 break;} 5324 5325 if (ISZERO(rhs)) { /* zeros -> exact 1 */ 5326 decNumberZero(res); /* make clean 1 */ 5327 *res->lsu=1; /* .. */ 5328 break;} /* [no status to set] */ 5329 5330 /* e**x when 0 < x < 0.66 is < 1+3x/2, hence can fast-path */ 5331 /* positive and negative tiny cases which will result in inexact */ 5332 /* 1. This also allows the later add-accumulate to always be */ 5333 /* exact (because its length will never be more than twice the */ 5334 /* working precision). */ 5335 /* The comparator (tiny) needs just one digit, so use the */ 5336 /* decNumber d for it (reused as the divisor, etc., below); its */ 5337 /* exponent is such that if x is positive it will have */ 5338 /* set->digits-1 zeros between the decimal point and the digit, */ 5339 /* which is 4, and if x is negative one more zero there as the */ 5340 /* more precise result will be of the form 0.9999999 rather than */ 5341 /* 1.0000001. Hence, tiny will be 0.0000004 if digits=7 and x>0 */ 5342 /* or 0.00000004 if digits=7 and x<0. If RHS not larger than */ 5343 /* this then the result will be 1.000000 */ 5344 decNumberZero(d); /* clean */ 5345 *d->lsu=4; /* set 4 .. */ 5346 d->exponent=-set->digits; /* * 10**(-d) */ 5347 if (decNumberIsNegative(rhs)) d->exponent--; /* negative case */ 5348 comp=decCompare(d, rhs, 1); /* signless compare */ 5349 if (comp==BADINT) { 5350 *status|=DEC_Insufficient_storage; 5351 break;} 5352 if (comp>=0) { /* rhs < d */ 5353 Int shift=set->digits-1; 5354 decNumberZero(res); /* set 1 */ 5355 *res->lsu=1; /* .. */ 5356 res->digits=decShiftToMost(res->lsu, 1, shift); 5357 res->exponent=-shift; /* make 1.0000... */ 5358 *status|=DEC_Inexact | DEC_Rounded; /* .. inexactly */ 5359 break;} /* tiny */ 5360 5361 /* set up the context to be used for calculating a, as this is */ 5362 /* used on both paths below */ 5363 decContextDefault(&aset, DEC_INIT_DECIMAL64); 5364 /* accumulator bounds are as requested (could underflow) */ 5365 aset.emax=set->emax; /* usual bounds */ 5366 aset.emin=set->emin; /* .. */ 5367 aset.clamp=0; /* and no concrete format */ 5368 5369 /* calculate the adjusted (Hull & Abrham) exponent (where the */ 5370 /* decimal point is just to the left of the coefficient msd) */ 5371 h=rhs->exponent+rhs->digits; 5372 /* if h>8 then 10**h cannot be calculated safely; however, when */ 5373 /* h=8 then exp(|rhs|) will be at least exp(1E+7) which is at */ 5374 /* least 6.59E+4342944, so (due to the restriction on Emax/Emin) */ 5375 /* overflow (or underflow to 0) is guaranteed -- so this case can */ 5376 /* be handled by simply forcing the appropriate excess */ 5377 if (h>8) { /* overflow/underflow */ 5378 /* set up here so Power call below will over or underflow to */ 5379 /* zero; set accumulator to either 2 or 0.02 */ 5380 /* [stack buffer for a is always big enough for this] */ 5381 decNumberZero(a); 5382 *a->lsu=2; /* not 1 but < exp(1) */ 5383 if (decNumberIsNegative(rhs)) a->exponent=-2; /* make 0.02 */ 5384 h=8; /* clamp so 10**h computable */ 5385 p=9; /* set a working precision */ 5386 } 5387 else { /* h<=8 */ 5388 Int maxlever=(rhs->digits>8?1:0); 5389 /* [could/should increase this for precisions >40 or so, too] */ 5390 5391 /* if h is 8, cannot normalize to a lower upper limit because */ 5392 /* the final result will not be computable (see notes above), */ 5393 /* but leverage can be applied whenever h is less than 8. */ 5394 /* Apply as much as possible, up to a MAXLEVER digits, which */ 5395 /* sets the tradeoff against the cost of the later a**(10**h). */ 5396 /* As h is increased, the working precision below also */ 5397 /* increases to compensate for the "constant digits at the */ 5398 /* front" effect. */ 5399 Int lever=MINI(8-h, maxlever); /* leverage attainable */ 5400 Int use=-rhs->digits-lever; /* exponent to use for RHS */ 5401 h+=lever; /* apply leverage selected */ 5402 if (h<0) { /* clamp */ 5403 use+=h; /* [may end up subnormal] */ 5404 h=0; 5405 } 5406 /* Take a copy of RHS if it needs normalization (true whenever x>=1) */ 5407 if (rhs->exponent!=use) { 5408 decNumber *newrhs=bufr; /* assume will fit on stack */ 5409 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); 5410 if (needbytes>sizeof(bufr)) { /* need malloc space */ 5411 allocrhs=(decNumber *)malloc(needbytes); 5412 if (allocrhs==NULL) { /* hopeless -- abandon */ 5413 *status|=DEC_Insufficient_storage; 5414 break;} 5415 newrhs=allocrhs; /* use the allocated space */ 5416 } 5417 decNumberCopy(newrhs, rhs); /* copy to safe space */ 5418 newrhs->exponent=use; /* normalize; now <1 */ 5419 x=newrhs; /* ready for use */ 5420 /* decNumberShow(x); */ 5421 } 5422 5423 /* Now use the usual power series to evaluate exp(x). The */ 5424 /* series starts as 1 + x + x^2/2 ... so prime ready for the */ 5425 /* third term by setting the term variable t=x, the accumulator */ 5426 /* a=1, and the divisor d=2. */ 5427 5428 /* First determine the working precision. From Hull & Abrham */ 5429 /* this is set->digits+h+2. However, if x is 'over-precise' we */ 5430 /* need to allow for all its digits to potentially participate */ 5431 /* (consider an x where all the excess digits are 9s) so in */ 5432 /* this case use x->digits+h+2 */ 5433 p=MAXI(x->digits, set->digits)+h+2; /* [h<=8] */ 5434 5435 /* a and t are variable precision, and depend on p, so space */ 5436 /* must be allocated for them if necessary */ 5437 5438 /* the accumulator needs to be able to hold 2p digits so that */ 5439 /* the additions on the second and subsequent iterations are */ 5440 /* sufficiently exact. */ 5441 needbytes=sizeof(decNumber)+(D2U(p*2)-1)*sizeof(Unit); 5442 if (needbytes>sizeof(bufa)) { /* need malloc space */ 5443 allocbufa=(decNumber *)malloc(needbytes); 5444 if (allocbufa==NULL) { /* hopeless -- abandon */ 5445 *status|=DEC_Insufficient_storage; 5446 break;} 5447 a=allocbufa; /* use the allocated space */ 5448 } 5449 /* the term needs to be able to hold p digits (which is */ 5450 /* guaranteed to be larger than x->digits, so the initial copy */ 5451 /* is safe); it may also be used for the raise-to-power */ 5452 /* calculation below, which needs an extra two digits */ 5453 needbytes=sizeof(decNumber)+(D2U(p+2)-1)*sizeof(Unit); 5454 if (needbytes>sizeof(buft)) { /* need malloc space */ 5455 allocbuft=(decNumber *)malloc(needbytes); 5456 if (allocbuft==NULL) { /* hopeless -- abandon */ 5457 *status|=DEC_Insufficient_storage; 5458 break;} 5459 t=allocbuft; /* use the allocated space */ 5460 } 5461 5462 decNumberCopy(t, x); /* term=x */ 5463 decNumberZero(a); *a->lsu=1; /* accumulator=1 */ 5464 decNumberZero(d); *d->lsu=2; /* divisor=2 */ 5465 decNumberZero(&numone); *numone.lsu=1; /* constant 1 for increment */ 5466 5467 /* set up the contexts for calculating a, t, and d */ 5468 decContextDefault(&tset, DEC_INIT_DECIMAL64); 5469 dset=tset; 5470 /* accumulator bounds are set above, set precision now */ 5471 aset.digits=p*2; /* double */ 5472 /* term bounds avoid any underflow or overflow */ 5473 tset.digits=p; 5474 tset.emin=DEC_MIN_EMIN; /* [emax is plenty] */ 5475 /* [dset.digits=16, etc., are sufficient] */ 5476 5477 /* finally ready to roll */ 5478 for (;;) { 5479 #if DECCHECK 5480 iterations++; 5481 #endif 5482 /* only the status from the accumulation is interesting */ 5483 /* [but it should remain unchanged after first add] */ 5484 decAddOp(a, a, t, &aset, 0, status); /* a=a+t */ 5485 decMultiplyOp(t, t, x, &tset, &ignore); /* t=t*x */ 5486 decDivideOp(t, t, d, &tset, DIVIDE, &ignore); /* t=t/d */ 5487 /* the iteration ends when the term cannot affect the result, */ 5488 /* if rounded to p digits, which is when its value is smaller */ 5489 /* than the accumulator by p+1 digits. There must also be */ 5490 /* full precision in a. */ 5491 if (((a->digits+a->exponent)>=(t->digits+t->exponent+p+1)) 5492 && (a->digits>=p)) break; 5493 decAddOp(d, d, &numone, &dset, 0, &ignore); /* d=d+1 */ 5494 } /* iterate */ 5495 5496 #if DECCHECK 5497 /* just a sanity check; comment out test to show always */ 5498 if (iterations>p+3) 5499 printf("Exp iterations=%ld, status=%08lx, p=%ld, d=%ld\n", 5500 iterations, *status, p, x->digits); 5501 #endif 5502 } /* h<=8 */ 5503 5504 /* apply postconditioning: a=a**(10**h) -- this is calculated */ 5505 /* at a slightly higher precision than Hull & Abrham suggest */ 5506 if (h>0) { 5507 Int seenbit=0; /* set once a 1-bit is seen */ 5508 Int i; /* counter */ 5509 Int n=powers[h]; /* always positive */ 5510 aset.digits=p+2; /* sufficient precision */ 5511 /* avoid the overhead and many extra digits of decNumberPower */ 5512 /* as all that is needed is the short 'multipliers' loop; here */ 5513 /* accumulate the answer into t */ 5514 decNumberZero(t); *t->lsu=1; /* acc=1 */ 5515 for (i=1;;i++){ /* for each bit [top bit ignored] */ 5516 /* abandon if have had overflow or terminal underflow */ 5517 if (*status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */ 5518 if (*status&DEC_Overflow || ISZERO(t)) break;} 5519 n=n<<1; /* move next bit to testable position */ 5520 if (n<0) { /* top bit is set */ 5521 seenbit=1; /* OK, have a significant bit */ 5522 decMultiplyOp(t, t, a, &aset, status); /* acc=acc*x */ 5523 } 5524 if (i==31) break; /* that was the last bit */ 5525 if (!seenbit) continue; /* no need to square 1 */ 5526 decMultiplyOp(t, t, t, &aset, status); /* acc=acc*acc [square] */ 5527 } /*i*/ /* 32 bits */ 5528 /* decNumberShow(t); */ 5529 a=t; /* and carry on using t instead of a */ 5530 } 5531 5532 /* Copy and round the result to res */ 5533 residue=1; /* indicate dirt to right .. */ 5534 if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */ 5535 aset.digits=set->digits; /* [use default rounding] */ 5536 decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */ 5537 decFinish(res, set, &residue, status); /* cleanup/set flags */ 5538 } while(0); /* end protected */ 5539 5540 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */ 5541 if (allocbufa!=NULL) free(allocbufa); /* .. */ 5542 if (allocbuft!=NULL) free(allocbuft); /* .. */ 5543 /* [status is handled by caller] */ 5544 return res; 5545 } /* decExpOp */ 5546 5547 /* ------------------------------------------------------------------ */ 5548 /* Initial-estimate natural logarithm table */ 5549 /* */ 5550 /* LNnn -- 90-entry 16-bit table for values from .10 through .99. */ 5551 /* The result is a 4-digit encode of the coefficient (c=the */ 5552 /* top 14 bits encoding 0-9999) and a 2-digit encode of the */ 5553 /* exponent (e=the bottom 2 bits encoding 0-3) */ 5554 /* */ 5555 /* The resulting value is given by: */ 5556 /* */ 5557 /* v = -c * 10**(-e-3) */ 5558 /* */ 5559 /* where e and c are extracted from entry k = LNnn[x-10] */ 5560 /* where x is truncated (NB) into the range 10 through 99, */ 5561 /* and then c = k>>2 and e = k&3. */ 5562 /* ------------------------------------------------------------------ */ 5563 static const uShort LNnn[90] = { 5564 9016, 8652, 8316, 8008, 7724, 7456, 7208, 5565 6972, 6748, 6540, 6340, 6148, 5968, 5792, 5628, 5464, 5312, 5566 5164, 5020, 4884, 4748, 4620, 4496, 4376, 4256, 4144, 4032, 5567 39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629, 5568 29777, 28945, 28129, 27329, 26545, 25777, 25021, 24281, 23553, 22837, 5569 22137, 21445, 20769, 20101, 19445, 18801, 18165, 17541, 16925, 16321, 5570 15721, 15133, 14553, 13985, 13421, 12865, 12317, 11777, 11241, 10717, 5571 10197, 9685, 9177, 8677, 8185, 7697, 7213, 6737, 6269, 5801, 5572 5341, 4889, 4437, 39930, 35534, 31186, 26886, 22630, 18418, 14254, 5573 10130, 6046, 20055}; 5574 5575 /* ------------------------------------------------------------------ */ 5576 /* decLnOp -- effect natural logarithm */ 5577 /* */ 5578 /* This computes C = ln(A) */ 5579 /* */ 5580 /* res is C, the result. C may be A */ 5581 /* rhs is A */ 5582 /* set is the context; note that rounding mode has no effect */ 5583 /* */ 5584 /* C must have space for set->digits digits. */ 5585 /* */ 5586 /* Notable cases: */ 5587 /* A<0 -> Invalid */ 5588 /* A=0 -> -Infinity (Exact) */ 5589 /* A=+Infinity -> +Infinity (Exact) */ 5590 /* A=1 exactly -> 0 (Exact) */ 5591 /* */ 5592 /* Restrictions (as for Exp): */ 5593 /* */ 5594 /* digits, emax, and -emin in the context must be less than */ 5595 /* DEC_MAX_MATH+11 (1000010), and the rhs must be within these */ 5596 /* bounds or a zero. This is an internal routine, so these */ 5597 /* restrictions are contractual and not enforced. */ 5598 /* */ 5599 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */ 5600 /* almost always be correctly rounded, but may be up to 1 ulp in */ 5601 /* error in rare cases. */ 5602 /* ------------------------------------------------------------------ */ 5603 /* The result is calculated using Newton's method, with each */ 5604 /* iteration calculating a' = a + x * exp(-a) - 1. See, for example, */ 5605 /* Epperson 1989. */ 5606 /* */ 5607 /* The iteration ends when the adjustment x*exp(-a)-1 is tiny enough. */ 5608 /* This has to be calculated at the sum of the precision of x and the */ 5609 /* working precision. */ 5610 /* */ 5611 /* Implementation notes: */ 5612 /* */ 5613 /* 1. This is separated out as decLnOp so it can be called from */ 5614 /* other Mathematical functions (e.g., Log 10) with a wider range */ 5615 /* than normal. In particular, it can handle the slightly wider */ 5616 /* (+9+2) range needed by a power function. */ 5617 /* */ 5618 /* 2. The speed of this function is about 10x slower than exp, as */ 5619 /* it typically needs 4-6 iterations for short numbers, and the */ 5620 /* extra precision needed adds a squaring effect, twice. */ 5621 /* */ 5622 /* 3. Fastpaths are included for ln(10) and ln(2), up to length 40, */ 5623 /* as these are common requests. ln(10) is used by log10(x). */ 5624 /* */ 5625 /* 4. An iteration might be saved by widening the LNnn table, and */ 5626 /* would certainly save at least one if it were made ten times */ 5627 /* bigger, too (for truncated fractions 0.100 through 0.999). */ 5628 /* However, for most practical evaluations, at least four or five */ 5629 /* iterations will be needed -- so this would only speed up by */ 5630 /* 20-25% and that probably does not justify increasing the table */ 5631 /* size. */ 5632 /* */ 5633 /* 5. The static buffers are larger than might be expected to allow */ 5634 /* for calls from decNumberPower. */ 5635 /* ------------------------------------------------------------------ */ 5636 static decNumber *decLnOp(decNumber *res, const decNumber *rhs, 5637 decContext *set, uInt *status) { 5638 uInt ignore=0; /* working status accumulator */ 5639 uInt needbytes; /* for space calculations */ 5640 Int residue; /* rounding residue */ 5641 Int r; /* rhs=f*10**r [see below] */ 5642 Int p; /* working precision */ 5643 Int pp; /* precision for iteration */ 5644 Int t; /* work */ 5645 5646 /* buffers for a (accumulator, typically precision+2) and b */ 5647 /* (adjustment calculator, same size) */ 5648 decNumber bufa[D2N(DECBUFFER+12)]; 5649 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 5650 decNumber *a=bufa; /* accumulator/work */ 5651 decNumber bufb[D2N(DECBUFFER*2+2)]; 5652 decNumber *allocbufb=NULL; /* -> allocated bufa, iff allocated */ 5653 decNumber *b=bufb; /* adjustment/work */ 5654 5655 decNumber numone; /* constant 1 */ 5656 decNumber cmp; /* work */ 5657 decContext aset, bset; /* working contexts */ 5658 5659 #if DECCHECK 5660 Int iterations=0; /* for later sanity check */ 5661 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 5662 #endif 5663 5664 do { /* protect allocated storage */ 5665 if (SPECIALARG) { /* handle infinities and NaNs */ 5666 if (decNumberIsInfinite(rhs)) { /* an infinity */ 5667 if (decNumberIsNegative(rhs)) /* -Infinity -> error */ 5668 *status|=DEC_Invalid_operation; 5669 else decNumberCopy(res, rhs); /* +Infinity -> self */ 5670 } 5671 else decNaNs(res, rhs, NULL, set, status); /* a NaN */ 5672 break;} 5673 5674 if (ISZERO(rhs)) { /* +/- zeros -> -Infinity */ 5675 decNumberZero(res); /* make clean */ 5676 res->bits=DECINF|DECNEG; /* set - infinity */ 5677 break;} /* [no status to set] */ 5678 5679 /* Non-zero negatives are bad... */ 5680 if (decNumberIsNegative(rhs)) { /* -x -> error */ 5681 *status|=DEC_Invalid_operation; 5682 break;} 5683 5684 /* Here, rhs is positive, finite, and in range */ 5685 5686 /* lookaside fastpath code for ln(2) and ln(10) at common lengths */ 5687 if (rhs->exponent==0 && set->digits<=40) { 5688 #if DECDPUN==1 5689 if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { /* ln(10) */ 5690 #else 5691 if (rhs->lsu[0]==10 && rhs->digits==2) { /* ln(10) */ 5692 #endif 5693 aset=*set; aset.round=DEC_ROUND_HALF_EVEN; 5694 #define LN10 "2.302585092994045684017991454684364207601" 5695 decNumberFromString(res, LN10, &aset); 5696 *status|=(DEC_Inexact | DEC_Rounded); /* is inexact */ 5697 break;} 5698 if (rhs->lsu[0]==2 && rhs->digits==1) { /* ln(2) */ 5699 aset=*set; aset.round=DEC_ROUND_HALF_EVEN; 5700 #define LN2 "0.6931471805599453094172321214581765680755" 5701 decNumberFromString(res, LN2, &aset); 5702 *status|=(DEC_Inexact | DEC_Rounded); 5703 break;} 5704 } /* integer and short */ 5705 5706 /* Determine the working precision. This is normally the */ 5707 /* requested precision + 2, with a minimum of 9. However, if */ 5708 /* the rhs is 'over-precise' then allow for all its digits to */ 5709 /* potentially participate (consider an rhs where all the excess */ 5710 /* digits are 9s) so in this case use rhs->digits+2. */ 5711 p=MAXI(rhs->digits, MAXI(set->digits, 7))+2; 5712 5713 /* Allocate space for the accumulator and the high-precision */ 5714 /* adjustment calculator, if necessary. The accumulator must */ 5715 /* be able to hold p digits, and the adjustment up to */ 5716 /* rhs->digits+p digits. They are also made big enough for 16 */ 5717 /* digits so that they can be used for calculating the initial */ 5718 /* estimate. */ 5719 needbytes=sizeof(decNumber)+(D2U(MAXI(p,16))-1)*sizeof(Unit); 5720 if (needbytes>sizeof(bufa)) { /* need malloc space */ 5721 allocbufa=(decNumber *)malloc(needbytes); 5722 if (allocbufa==NULL) { /* hopeless -- abandon */ 5723 *status|=DEC_Insufficient_storage; 5724 break;} 5725 a=allocbufa; /* use the allocated space */ 5726 } 5727 pp=p+rhs->digits; 5728 needbytes=sizeof(decNumber)+(D2U(MAXI(pp,16))-1)*sizeof(Unit); 5729 if (needbytes>sizeof(bufb)) { /* need malloc space */ 5730 allocbufb=(decNumber *)malloc(needbytes); 5731 if (allocbufb==NULL) { /* hopeless -- abandon */ 5732 *status|=DEC_Insufficient_storage; 5733 break;} 5734 b=allocbufb; /* use the allocated space */ 5735 } 5736 5737 /* Prepare an initial estimate in acc. Calculate this by */ 5738 /* considering the coefficient of x to be a normalized fraction, */ 5739 /* f, with the decimal point at far left and multiplied by */ 5740 /* 10**r. Then, rhs=f*10**r and 0.1<=f<1, and */ 5741 /* ln(x) = ln(f) + ln(10)*r */ 5742 /* Get the initial estimate for ln(f) from a small lookup */ 5743 /* table (see above) indexed by the first two digits of f, */ 5744 /* truncated. */ 5745 5746 decContextDefault(&aset, DEC_INIT_DECIMAL64); /* 16-digit extended */ 5747 r=rhs->exponent+rhs->digits; /* 'normalised' exponent */ 5748 decNumberFromInt32(a, r); /* a=r */ 5749 decNumberFromInt32(b, 2302585); /* b=ln(10) (2.302585) */ 5750 b->exponent=-6; /* .. */ 5751 decMultiplyOp(a, a, b, &aset, &ignore); /* a=a*b */ 5752 /* now get top two digits of rhs into b by simple truncate and */ 5753 /* force to integer */ 5754 residue=0; /* (no residue) */ 5755 aset.digits=2; aset.round=DEC_ROUND_DOWN; 5756 decCopyFit(b, rhs, &aset, &residue, &ignore); /* copy & shorten */ 5757 b->exponent=0; /* make integer */ 5758 t=decGetInt(b); /* [cannot fail] */ 5759 if (t<10) t=X10(t); /* adjust single-digit b */ 5760 t=LNnn[t-10]; /* look up ln(b) */ 5761 decNumberFromInt32(b, t>>2); /* b=ln(b) coefficient */ 5762 b->exponent=-(t&3)-3; /* set exponent */ 5763 b->bits=DECNEG; /* ln(0.10)->ln(0.99) always -ve */ 5764 aset.digits=16; aset.round=DEC_ROUND_HALF_EVEN; /* restore */ 5765 decAddOp(a, a, b, &aset, 0, &ignore); /* acc=a+b */ 5766 /* the initial estimate is now in a, with up to 4 digits correct. */ 5767 /* When rhs is at or near Nmax the estimate will be low, so we */ 5768 /* will approach it from below, avoiding overflow when calling exp. */ 5769 5770 decNumberZero(&numone); *numone.lsu=1; /* constant 1 for adjustment */ 5771 5772 /* accumulator bounds are as requested (could underflow, but */ 5773 /* cannot overflow) */ 5774 aset.emax=set->emax; 5775 aset.emin=set->emin; 5776 aset.clamp=0; /* no concrete format */ 5777 /* set up a context to be used for the multiply and subtract */ 5778 bset=aset; 5779 bset.emax=DEC_MAX_MATH*2; /* use double bounds for the */ 5780 bset.emin=-DEC_MAX_MATH*2; /* adjustment calculation */ 5781 /* [see decExpOp call below] */ 5782 /* for each iteration double the number of digits to calculate, */ 5783 /* up to a maximum of p */ 5784 pp=9; /* initial precision */ 5785 /* [initially 9 as then the sequence starts 7+2, 16+2, and */ 5786 /* 34+2, which is ideal for standard-sized numbers] */ 5787 aset.digits=pp; /* working context */ 5788 bset.digits=pp+rhs->digits; /* wider context */ 5789 for (;;) { /* iterate */ 5790 #if DECCHECK 5791 iterations++; 5792 if (iterations>24) break; /* consider 9 * 2**24 */ 5793 #endif 5794 /* calculate the adjustment (exp(-a)*x-1) into b. This is a */ 5795 /* catastrophic subtraction but it really is the difference */ 5796 /* from 1 that is of interest. */ 5797 /* Use the internal entry point to Exp as it allows the double */ 5798 /* range for calculating exp(-a) when a is the tiniest subnormal. */ 5799 a->bits^=DECNEG; /* make -a */ 5800 decExpOp(b, a, &bset, &ignore); /* b=exp(-a) */ 5801 a->bits^=DECNEG; /* restore sign of a */ 5802 /* now multiply by rhs and subtract 1, at the wider precision */ 5803 decMultiplyOp(b, b, rhs, &bset, &ignore); /* b=b*rhs */ 5804 decAddOp(b, b, &numone, &bset, DECNEG, &ignore); /* b=b-1 */ 5805 5806 /* the iteration ends when the adjustment cannot affect the */ 5807 /* result by >=0.5 ulp (at the requested digits), which */ 5808 /* is when its value is smaller than the accumulator by */ 5809 /* set->digits+1 digits (or it is zero) -- this is a looser */ 5810 /* requirement than for Exp because all that happens to the */ 5811 /* accumulator after this is the final rounding (but note that */ 5812 /* there must also be full precision in a, or a=0). */ 5813 5814 if (decNumberIsZero(b) || 5815 (a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) { 5816 if (a->digits==p) break; 5817 if (decNumberIsZero(a)) { 5818 decCompareOp(&cmp, rhs, &numone, &aset, COMPARE, &ignore); /* rhs=1 ? */ 5819 if (cmp.lsu[0]==0) a->exponent=0; /* yes, exact 0 */ 5820 else *status|=(DEC_Inexact | DEC_Rounded); /* no, inexact */ 5821 break; 5822 } 5823 /* force padding if adjustment has gone to 0 before full length */ 5824 if (decNumberIsZero(b)) b->exponent=a->exponent-p; 5825 } 5826 5827 /* not done yet ... */ 5828 decAddOp(a, a, b, &aset, 0, &ignore); /* a=a+b for next estimate */ 5829 if (pp==p) continue; /* precision is at maximum */ 5830 /* lengthen the next calculation */ 5831 pp=pp*2; /* double precision */ 5832 if (pp>p) pp=p; /* clamp to maximum */ 5833 aset.digits=pp; /* working context */ 5834 bset.digits=pp+rhs->digits; /* wider context */ 5835 } /* Newton's iteration */ 5836 5837 #if DECCHECK 5838 /* just a sanity check; remove the test to show always */ 5839 if (iterations>24) 5840 printf("Ln iterations=%ld, status=%08lx, p=%ld, d=%ld\n", 5841 iterations, *status, p, rhs->digits); 5842 #endif 5843 5844 /* Copy and round the result to res */ 5845 residue=1; /* indicate dirt to right */ 5846 if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */ 5847 aset.digits=set->digits; /* [use default rounding] */ 5848 decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */ 5849 decFinish(res, set, &residue, status); /* cleanup/set flags */ 5850 } while(0); /* end protected */ 5851 5852 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */ 5853 if (allocbufb!=NULL) free(allocbufb); /* .. */ 5854 /* [status is handled by caller] */ 5855 return res; 5856 } /* decLnOp */ 5857 5858 /* ------------------------------------------------------------------ */ 5859 /* decQuantizeOp -- force exponent to requested value */ 5860 /* */ 5861 /* This computes C = op(A, B), where op adjusts the coefficient */ 5862 /* of C (by rounding or shifting) such that the exponent (-scale) */ 5863 /* of C has the value B or matches the exponent of B. */ 5864 /* The numerical value of C will equal A, except for the effects of */ 5865 /* any rounding that occurred. */ 5866 /* */ 5867 /* res is C, the result. C may be A or B */ 5868 /* lhs is A, the number to adjust */ 5869 /* rhs is B, the requested exponent */ 5870 /* set is the context */ 5871 /* quant is 1 for quantize or 0 for rescale */ 5872 /* status is the status accumulator (this can be called without */ 5873 /* risk of control loss) */ 5874 /* */ 5875 /* C must have space for set->digits digits. */ 5876 /* */ 5877 /* Unless there is an error or the result is infinite, the exponent */ 5878 /* after the operation is guaranteed to be that requested. */ 5879 /* ------------------------------------------------------------------ */ 5880 static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs, 5881 const decNumber *rhs, decContext *set, 5882 Flag quant, uInt *status) { 5883 #if DECSUBSET 5884 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 5885 decNumber *allocrhs=NULL; /* .., rhs */ 5886 #endif 5887 const decNumber *inrhs=rhs; /* save original rhs */ 5888 Int reqdigits=set->digits; /* requested DIGITS */ 5889 Int reqexp; /* requested exponent [-scale] */ 5890 Int residue=0; /* rounding residue */ 5891 Int etiny=set->emin-(reqdigits-1); 5892 5893 #if DECCHECK 5894 if (decCheckOperands(res, lhs, rhs, set)) return res; 5895 #endif 5896 5897 do { /* protect allocated storage */ 5898 #if DECSUBSET 5899 if (!set->extended) { 5900 /* reduce operands and set lostDigits status, as needed */ 5901 if (lhs->digits>reqdigits) { 5902 alloclhs=decRoundOperand(lhs, set, status); 5903 if (alloclhs==NULL) break; 5904 lhs=alloclhs; 5905 } 5906 if (rhs->digits>reqdigits) { /* [this only checks lostDigits] */ 5907 allocrhs=decRoundOperand(rhs, set, status); 5908 if (allocrhs==NULL) break; 5909 rhs=allocrhs; 5910 } 5911 } 5912 #endif 5913 /* [following code does not require input rounding] */ 5914 5915 /* Handle special values */ 5916 if (SPECIALARGS) { 5917 /* NaNs get usual processing */ 5918 if (SPECIALARGS & (DECSNAN | DECNAN)) 5919 decNaNs(res, lhs, rhs, set, status); 5920 /* one infinity but not both is bad */ 5921 else if ((lhs->bits ^ rhs->bits) & DECINF) 5922 *status|=DEC_Invalid_operation; 5923 /* both infinity: return lhs */ 5924 else decNumberCopy(res, lhs); /* [nop if in place] */ 5925 break; 5926 } 5927 5928 /* set requested exponent */ 5929 if (quant) reqexp=inrhs->exponent; /* quantize -- match exponents */ 5930 else { /* rescale -- use value of rhs */ 5931 /* Original rhs must be an integer that fits and is in range, */ 5932 /* which could be from -1999999997 to +999999999, thanks to */ 5933 /* subnormals */ 5934 reqexp=decGetInt(inrhs); /* [cannot fail] */ 5935 } 5936 5937 #if DECSUBSET 5938 if (!set->extended) etiny=set->emin; /* no subnormals */ 5939 #endif 5940 5941 if (reqexp==BADINT /* bad (rescale only) or .. */ 5942 || reqexp==BIGODD || reqexp==BIGEVEN /* very big (ditto) or .. */ 5943 || (reqexp<etiny) /* < lowest */ 5944 || (reqexp>set->emax)) { /* > emax */ 5945 *status|=DEC_Invalid_operation; 5946 break;} 5947 5948 /* the RHS has been processed, so it can be overwritten now if necessary */ 5949 if (ISZERO(lhs)) { /* zero coefficient unchanged */ 5950 decNumberCopy(res, lhs); /* [nop if in place] */ 5951 res->exponent=reqexp; /* .. just set exponent */ 5952 #if DECSUBSET 5953 if (!set->extended) res->bits=0; /* subset specification; no -0 */ 5954 #endif 5955 } 5956 else { /* non-zero lhs */ 5957 Int adjust=reqexp-lhs->exponent; /* digit adjustment needed */ 5958 /* if adjusted coefficient will definitely not fit, give up now */ 5959 if ((lhs->digits-adjust)>reqdigits) { 5960 *status|=DEC_Invalid_operation; 5961 break; 5962 } 5963 5964 if (adjust>0) { /* increasing exponent */ 5965 /* this will decrease the length of the coefficient by adjust */ 5966 /* digits, and must round as it does so */ 5967 decContext workset; /* work */ 5968 workset=*set; /* clone rounding, etc. */ 5969 workset.digits=lhs->digits-adjust; /* set requested length */ 5970 /* [note that the latter can be <1, here] */ 5971 decCopyFit(res, lhs, &workset, &residue, status); /* fit to result */ 5972 decApplyRound(res, &workset, residue, status); /* .. and round */ 5973 residue=0; /* [used] */ 5974 /* If just rounded a 999s case, exponent will be off by one; */ 5975 /* adjust back (after checking space), if so. */ 5976 if (res->exponent>reqexp) { 5977 /* re-check needed, e.g., for quantize(0.9999, 0.001) under */ 5978 /* set->digits==3 */ 5979 if (res->digits==reqdigits) { /* cannot shift by 1 */ 5980 *status&=~(DEC_Inexact | DEC_Rounded); /* [clean these] */ 5981 *status|=DEC_Invalid_operation; 5982 break; 5983 } 5984 res->digits=decShiftToMost(res->lsu, res->digits, 1); /* shift */ 5985 res->exponent--; /* (re)adjust the exponent. */ 5986 } 5987 #if DECSUBSET 5988 if (ISZERO(res) && !set->extended) res->bits=0; /* subset; no -0 */ 5989 #endif 5990 } /* increase */ 5991 else /* adjust<=0 */ { /* decreasing or = exponent */ 5992 /* this will increase the length of the coefficient by -adjust */ 5993 /* digits, by adding zero or more trailing zeros; this is */ 5994 /* already checked for fit, above */ 5995 decNumberCopy(res, lhs); /* [it will fit] */ 5996 /* if padding needed (adjust<0), add it now... */ 5997 if (adjust<0) { 5998 res->digits=decShiftToMost(res->lsu, res->digits, -adjust); 5999 res->exponent+=adjust; /* adjust the exponent */ 6000 } 6001 } /* decrease */ 6002 } /* non-zero */ 6003 6004 /* Check for overflow [do not use Finalize in this case, as an */ 6005 /* overflow here is a "don't fit" situation] */ 6006 if (res->exponent>set->emax-res->digits+1) { /* too big */ 6007 *status|=DEC_Invalid_operation; 6008 break; 6009 } 6010 else { 6011 decFinalize(res, set, &residue, status); /* set subnormal flags */ 6012 *status&=~DEC_Underflow; /* suppress Underflow [754r] */ 6013 } 6014 } while(0); /* end protected */ 6015 6016 #if DECSUBSET 6017 if (allocrhs!=NULL) free(allocrhs); /* drop any storage used */ 6018 if (alloclhs!=NULL) free(alloclhs); /* .. */ 6019 #endif 6020 return res; 6021 } /* decQuantizeOp */ 6022 6023 /* ------------------------------------------------------------------ */ 6024 /* decCompareOp -- compare, min, or max two Numbers */ 6025 /* */ 6026 /* This computes C = A ? B and carries out one of four operations: */ 6027 /* COMPARE -- returns the signum (as a number) giving the */ 6028 /* result of a comparison unless one or both */ 6029 /* operands is a NaN (in which case a NaN results) */ 6030 /* COMPSIG -- as COMPARE except that a quiet NaN raises */ 6031 /* Invalid operation. */ 6032 /* COMPMAX -- returns the larger of the operands, using the */ 6033 /* 754r maxnum operation */ 6034 /* COMPMAXMAG -- ditto, comparing absolute values */ 6035 /* COMPMIN -- the 754r minnum operation */ 6036 /* COMPMINMAG -- ditto, comparing absolute values */ 6037 /* COMTOTAL -- returns the signum (as a number) giving the */ 6038 /* result of a comparison using 754r total ordering */ 6039 /* */ 6040 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 6041 /* lhs is A */ 6042 /* rhs is B */ 6043 /* set is the context */ 6044 /* op is the operation flag */ 6045 /* status is the usual accumulator */ 6046 /* */ 6047 /* C must have space for one digit for COMPARE or set->digits for */ 6048 /* COMPMAX, COMPMIN, COMPMAXMAG, or COMPMINMAG. */ 6049 /* ------------------------------------------------------------------ */ 6050 /* The emphasis here is on speed for common cases, and avoiding */ 6051 /* coefficient comparison if possible. */ 6052 /* ------------------------------------------------------------------ */ 6053 static decNumber *decCompareOp(decNumber *res, const decNumber *lhs, 6054 const decNumber *rhs, decContext *set, 6055 Flag op, uInt *status) { 6056 #if DECSUBSET 6057 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 6058 decNumber *allocrhs=NULL; /* .., rhs */ 6059 #endif 6060 Int result=0; /* default result value */ 6061 uByte merged; /* work */ 6062 6063 #if DECCHECK 6064 if (decCheckOperands(res, lhs, rhs, set)) return res; 6065 #endif 6066 6067 do { /* protect allocated storage */ 6068 #if DECSUBSET 6069 if (!set->extended) { 6070 /* reduce operands and set lostDigits status, as needed */ 6071 if (lhs->digits>set->digits) { 6072 alloclhs=decRoundOperand(lhs, set, status); 6073 if (alloclhs==NULL) {result=BADINT; break;} 6074 lhs=alloclhs; 6075 } 6076 if (rhs->digits>set->digits) { 6077 allocrhs=decRoundOperand(rhs, set, status); 6078 if (allocrhs==NULL) {result=BADINT; break;} 6079 rhs=allocrhs; 6080 } 6081 } 6082 #endif 6083 /* [following code does not require input rounding] */ 6084 6085 /* If total ordering then handle differing signs 'up front' */ 6086 if (op==COMPTOTAL) { /* total ordering */ 6087 if (decNumberIsNegative(lhs) && !decNumberIsNegative(rhs)) { 6088 result=-1; 6089 break; 6090 } 6091 if (!decNumberIsNegative(lhs) && decNumberIsNegative(rhs)) { 6092 result=+1; 6093 break; 6094 } 6095 } 6096 6097 /* handle NaNs specially; let infinities drop through */ 6098 /* This assumes sNaN (even just one) leads to NaN. */ 6099 merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN); 6100 if (merged) { /* a NaN bit set */ 6101 if (op==COMPARE); /* result will be NaN */ 6102 else if (op==COMPSIG) /* treat qNaN as sNaN */ 6103 *status|=DEC_Invalid_operation | DEC_sNaN; 6104 else if (op==COMPTOTAL) { /* total ordering, always finite */ 6105 /* signs are known to be the same; compute the ordering here */ 6106 /* as if the signs are both positive, then invert for negatives */ 6107 if (!decNumberIsNaN(lhs)) result=-1; 6108 else if (!decNumberIsNaN(rhs)) result=+1; 6109 /* here if both NaNs */ 6110 else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1; 6111 else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1; 6112 else { /* both NaN or both sNaN */ 6113 /* now it just depends on the payload */ 6114 result=decUnitCompare(lhs->lsu, D2U(lhs->digits), 6115 rhs->lsu, D2U(rhs->digits), 0); 6116 /* [Error not possible, as these are 'aligned'] */ 6117 } /* both same NaNs */ 6118 if (decNumberIsNegative(lhs)) result=-result; 6119 break; 6120 } /* total order */ 6121 6122 else if (merged & DECSNAN); /* sNaN -> qNaN */ 6123 else { /* here if MIN or MAX and one or two quiet NaNs */ 6124 /* min or max -- 754r rules ignore single NaN */ 6125 if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) { 6126 /* just one NaN; force choice to be the non-NaN operand */ 6127 op=COMPMAX; 6128 if (lhs->bits & DECNAN) result=-1; /* pick rhs */ 6129 else result=+1; /* pick lhs */ 6130 break; 6131 } 6132 } /* max or min */ 6133 op=COMPNAN; /* use special path */ 6134 decNaNs(res, lhs, rhs, set, status); /* propagate NaN */ 6135 break; 6136 } 6137 /* have numbers */ 6138 if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1); 6139 else result=decCompare(lhs, rhs, 0); /* sign matters */ 6140 } while(0); /* end protected */ 6141 6142 if (result==BADINT) *status|=DEC_Insufficient_storage; /* rare */ 6143 else { 6144 if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { /* returning signum */ 6145 if (op==COMPTOTAL && result==0) { 6146 /* operands are numerically equal or same NaN (and same sign, */ 6147 /* tested first); if identical, leave result 0 */ 6148 if (lhs->exponent!=rhs->exponent) { 6149 if (lhs->exponent<rhs->exponent) result=-1; 6150 else result=+1; 6151 if (decNumberIsNegative(lhs)) result=-result; 6152 } /* lexp!=rexp */ 6153 } /* total-order by exponent */ 6154 decNumberZero(res); /* [always a valid result] */ 6155 if (result!=0) { /* must be -1 or +1 */ 6156 *res->lsu=1; 6157 if (result<0) res->bits=DECNEG; 6158 } 6159 } 6160 else if (op==COMPNAN); /* special, drop through */ 6161 else { /* MAX or MIN, non-NaN result */ 6162 Int residue=0; /* rounding accumulator */ 6163 /* choose the operand for the result */ 6164 const decNumber *choice; 6165 if (result==0) { /* operands are numerically equal */ 6166 /* choose according to sign then exponent (see 754r) */ 6167 uByte slhs=(lhs->bits & DECNEG); 6168 uByte srhs=(rhs->bits & DECNEG); 6169 #if DECSUBSET 6170 if (!set->extended) { /* subset: force left-hand */ 6171 op=COMPMAX; 6172 result=+1; 6173 } 6174 else 6175 #endif 6176 if (slhs!=srhs) { /* signs differ */ 6177 if (slhs) result=-1; /* rhs is max */ 6178 else result=+1; /* lhs is max */ 6179 } 6180 else if (slhs && srhs) { /* both negative */ 6181 if (lhs->exponent<rhs->exponent) result=+1; 6182 else result=-1; 6183 /* [if equal, use lhs, technically identical] */ 6184 } 6185 else { /* both positive */ 6186 if (lhs->exponent>rhs->exponent) result=+1; 6187 else result=-1; 6188 /* [ditto] */ 6189 } 6190 } /* numerically equal */ 6191 /* here result will be non-0; reverse if looking for MIN */ 6192 if (op==COMPMIN || op==COMPMINMAG) result=-result; 6193 choice=(result>0 ? lhs : rhs); /* choose */ 6194 /* copy chosen to result, rounding if need be */ 6195 decCopyFit(res, choice, set, &residue, status); 6196 decFinish(res, set, &residue, status); 6197 } 6198 } 6199 #if DECSUBSET 6200 if (allocrhs!=NULL) free(allocrhs); /* free any storage used */ 6201 if (alloclhs!=NULL) free(alloclhs); /* .. */ 6202 #endif 6203 return res; 6204 } /* decCompareOp */ 6205 6206 /* ------------------------------------------------------------------ */ 6207 /* decCompare -- compare two decNumbers by numerical value */ 6208 /* */ 6209 /* This routine compares A ? B without altering them. */ 6210 /* */ 6211 /* Arg1 is A, a decNumber which is not a NaN */ 6212 /* Arg2 is B, a decNumber which is not a NaN */ 6213 /* Arg3 is 1 for a sign-independent compare, 0 otherwise */ 6214 /* */ 6215 /* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */ 6216 /* (the only possible failure is an allocation error) */ 6217 /* ------------------------------------------------------------------ */ 6218 static Int decCompare(const decNumber *lhs, const decNumber *rhs, 6219 Flag abs) { 6220 Int result; /* result value */ 6221 Int sigr; /* rhs signum */ 6222 Int compare; /* work */ 6223 6224 result=1; /* assume signum(lhs) */ 6225 if (ISZERO(lhs)) result=0; 6226 if (abs) { 6227 if (ISZERO(rhs)) return result; /* LHS wins or both 0 */ 6228 /* RHS is non-zero */ 6229 if (result==0) return -1; /* LHS is 0; RHS wins */ 6230 /* [here, both non-zero, result=1] */ 6231 } 6232 else { /* signs matter */ 6233 if (result && decNumberIsNegative(lhs)) result=-1; 6234 sigr=1; /* compute signum(rhs) */ 6235 if (ISZERO(rhs)) sigr=0; 6236 else if (decNumberIsNegative(rhs)) sigr=-1; 6237 if (result > sigr) return +1; /* L > R, return 1 */ 6238 if (result < sigr) return -1; /* L < R, return -1 */ 6239 if (result==0) return 0; /* both 0 */ 6240 } 6241 6242 /* signums are the same; both are non-zero */ 6243 if ((lhs->bits | rhs->bits) & DECINF) { /* one or more infinities */ 6244 if (decNumberIsInfinite(rhs)) { 6245 if (decNumberIsInfinite(lhs)) result=0;/* both infinite */ 6246 else result=-result; /* only rhs infinite */ 6247 } 6248 return result; 6249 } 6250 /* must compare the coefficients, allowing for exponents */ 6251 if (lhs->exponent>rhs->exponent) { /* LHS exponent larger */ 6252 /* swap sides, and sign */ 6253 const decNumber *temp=lhs; 6254 lhs=rhs; 6255 rhs=temp; 6256 result=-result; 6257 } 6258 compare=decUnitCompare(lhs->lsu, D2U(lhs->digits), 6259 rhs->lsu, D2U(rhs->digits), 6260 rhs->exponent-lhs->exponent); 6261 if (compare!=BADINT) compare*=result; /* comparison succeeded */ 6262 return compare; 6263 } /* decCompare */ 6264 6265 /* ------------------------------------------------------------------ */ 6266 /* decUnitCompare -- compare two >=0 integers in Unit arrays */ 6267 /* */ 6268 /* This routine compares A ? B*10**E where A and B are unit arrays */ 6269 /* A is a plain integer */ 6270 /* B has an exponent of E (which must be non-negative) */ 6271 /* */ 6272 /* Arg1 is A first Unit (lsu) */ 6273 /* Arg2 is A length in Units */ 6274 /* Arg3 is B first Unit (lsu) */ 6275 /* Arg4 is B length in Units */ 6276 /* Arg5 is E (0 if the units are aligned) */ 6277 /* */ 6278 /* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */ 6279 /* (the only possible failure is an allocation error, which can */ 6280 /* only occur if E!=0) */ 6281 /* ------------------------------------------------------------------ */ 6282 static Int decUnitCompare(const Unit *a, Int alength, 6283 const Unit *b, Int blength, Int exp) { 6284 Unit *acc; /* accumulator for result */ 6285 Unit accbuff[SD2U(DECBUFFER*2+1)]; /* local buffer */ 6286 Unit *allocacc=NULL; /* -> allocated acc buffer, iff allocated */ 6287 Int accunits, need; /* units in use or needed for acc */ 6288 const Unit *l, *r, *u; /* work */ 6289 Int expunits, exprem, result; /* .. */ 6290 6291 if (exp==0) { /* aligned; fastpath */ 6292 if (alength>blength) return 1; 6293 if (alength<blength) return -1; 6294 /* same number of units in both -- need unit-by-unit compare */ 6295 l=a+alength-1; 6296 r=b+alength-1; 6297 for (;l>=a; l--, r--) { 6298 if (*l>*r) return 1; 6299 if (*l<*r) return -1; 6300 } 6301 return 0; /* all units match */ 6302 } /* aligned */ 6303 6304 /* Unaligned. If one is >1 unit longer than the other, padded */ 6305 /* approximately, then can return easily */ 6306 if (alength>blength+(Int)D2U(exp)) return 1; 6307 if (alength+1<blength+(Int)D2U(exp)) return -1; 6308 6309 /* Need to do a real subtract. For this, a result buffer is needed */ 6310 /* even though only the sign is of interest. Its length needs */ 6311 /* to be the larger of alength and padded blength, +2 */ 6312 need=blength+D2U(exp); /* maximum real length of B */ 6313 if (need<alength) need=alength; 6314 need+=2; 6315 acc=accbuff; /* assume use local buffer */ 6316 if (need*sizeof(Unit)>sizeof(accbuff)) { 6317 allocacc=(Unit *)malloc(need*sizeof(Unit)); 6318 if (allocacc==NULL) return BADINT; /* hopeless -- abandon */ 6319 acc=allocacc; 6320 } 6321 /* Calculate units and remainder from exponent. */ 6322 expunits=exp/DECDPUN; 6323 exprem=exp%DECDPUN; 6324 /* subtract [A+B*(-m)] */ 6325 accunits=decUnitAddSub(a, alength, b, blength, expunits, acc, 6326 -(Int)powers[exprem]); 6327 /* [UnitAddSub result may have leading zeros, even on zero] */ 6328 if (accunits<0) result=-1; /* negative result */ 6329 else { /* non-negative result */ 6330 /* check units of the result before freeing any storage */ 6331 for (u=acc; u<acc+accunits-1 && *u==0;) u++; 6332 result=(*u==0 ? 0 : +1); 6333 } 6334 /* clean up and return the result */ 6335 if (allocacc!=NULL) free(allocacc); /* drop any storage used */ 6336 return result; 6337 } /* decUnitCompare */ 6338 6339 /* ------------------------------------------------------------------ */ 6340 /* decUnitAddSub -- add or subtract two >=0 integers in Unit arrays */ 6341 /* */ 6342 /* This routine performs the calculation: */ 6343 /* */ 6344 /* C=A+(B*M) */ 6345 /* */ 6346 /* Where M is in the range -DECDPUNMAX through +DECDPUNMAX. */ 6347 /* */ 6348 /* A may be shorter or longer than B. */ 6349 /* */ 6350 /* Leading zeros are not removed after a calculation. The result is */ 6351 /* either the same length as the longer of A and B (adding any */ 6352 /* shift), or one Unit longer than that (if a Unit carry occurred). */ 6353 /* */ 6354 /* A and B content are not altered unless C is also A or B. */ 6355 /* C may be the same array as A or B, but only if no zero padding is */ 6356 /* requested (that is, C may be B only if bshift==0). */ 6357 /* C is filled from the lsu; only those units necessary to complete */ 6358 /* the calculation are referenced. */ 6359 /* */ 6360 /* Arg1 is A first Unit (lsu) */ 6361 /* Arg2 is A length in Units */ 6362 /* Arg3 is B first Unit (lsu) */ 6363 /* Arg4 is B length in Units */ 6364 /* Arg5 is B shift in Units (>=0; pads with 0 units if positive) */ 6365 /* Arg6 is C first Unit (lsu) */ 6366 /* Arg7 is M, the multiplier */ 6367 /* */ 6368 /* returns the count of Units written to C, which will be non-zero */ 6369 /* and negated if the result is negative. That is, the sign of the */ 6370 /* returned Int is the sign of the result (positive for zero) and */ 6371 /* the absolute value of the Int is the count of Units. */ 6372 /* */ 6373 /* It is the caller's responsibility to make sure that C size is */ 6374 /* safe, allowing space if necessary for a one-Unit carry. */ 6375 /* */ 6376 /* This routine is severely performance-critical; *any* change here */ 6377 /* must be measured (timed) to assure no performance degradation. */ 6378 /* In particular, trickery here tends to be counter-productive, as */ 6379 /* increased complexity of code hurts register optimizations on */ 6380 /* register-poor architectures. Avoiding divisions is nearly */ 6381 /* always a Good Idea, however. */ 6382 /* */ 6383 /* Special thanks to Rick McGuire (IBM Cambridge, MA) and Dave Clark */ 6384 /* (IBM Warwick, UK) for some of the ideas used in this routine. */ 6385 /* ------------------------------------------------------------------ */ 6386 static Int decUnitAddSub(const Unit *a, Int alength, 6387 const Unit *b, Int blength, Int bshift, 6388 Unit *c, Int m) { 6389 const Unit *alsu=a; /* A lsu [need to remember it] */ 6390 Unit *clsu=c; /* C ditto */ 6391 Unit *minC; /* low water mark for C */ 6392 Unit *maxC; /* high water mark for C */ 6393 eInt carry=0; /* carry integer (could be Long) */ 6394 Int add; /* work */ 6395 #if DECDPUN<=4 /* myriadal, millenary, etc. */ 6396 Int est; /* estimated quotient */ 6397 #endif 6398 6399 #if DECTRACE 6400 if (alength<1 || blength<1) 6401 printf("decUnitAddSub: alen blen m %ld %ld [%ld]\n", alength, blength, m); 6402 #endif 6403 6404 maxC=c+alength; /* A is usually the longer */ 6405 minC=c+blength; /* .. and B the shorter */ 6406 if (bshift!=0) { /* B is shifted; low As copy across */ 6407 minC+=bshift; 6408 /* if in place [common], skip copy unless there's a gap [rare] */ 6409 if (a==c && bshift<=alength) { 6410 c+=bshift; 6411 a+=bshift; 6412 } 6413 else for (; c<clsu+bshift; a++, c++) { /* copy needed */ 6414 if (a<alsu+alength) *c=*a; 6415 else *c=0; 6416 } 6417 } 6418 if (minC>maxC) { /* swap */ 6419 Unit *hold=minC; 6420 minC=maxC; 6421 maxC=hold; 6422 } 6423 6424 /* For speed, do the addition as two loops; the first where both A */ 6425 /* and B contribute, and the second (if necessary) where only one or */ 6426 /* other of the numbers contribute. */ 6427 /* Carry handling is the same (i.e., duplicated) in each case. */ 6428 for (; c<minC; c++) { 6429 carry+=*a; 6430 a++; 6431 carry+=((eInt)*b)*m; /* [special-casing m=1/-1 */ 6432 b++; /* here is not a win] */ 6433 /* here carry is new Unit of digits; it could be +ve or -ve */ 6434 if ((ueInt)carry<=DECDPUNMAX) { /* fastpath 0-DECDPUNMAX */ 6435 *c=(Unit)carry; 6436 carry=0; 6437 continue; 6438 } 6439 #if DECDPUN==4 /* use divide-by-multiply */ 6440 if (carry>=0) { 6441 est=(((ueInt)carry>>11)*53687)>>18; 6442 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6443 carry=est; /* likely quotient [89%] */ 6444 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */ 6445 carry++; 6446 *c-=DECDPUNMAX+1; 6447 continue; 6448 } 6449 /* negative case */ 6450 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6451 est=(((ueInt)carry>>11)*53687)>>18; 6452 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6453 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6454 if (*c<DECDPUNMAX+1) continue; /* was OK */ 6455 carry++; 6456 *c-=DECDPUNMAX+1; 6457 #elif DECDPUN==3 6458 if (carry>=0) { 6459 est=(((ueInt)carry>>3)*16777)>>21; 6460 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6461 carry=est; /* likely quotient [99%] */ 6462 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */ 6463 carry++; 6464 *c-=DECDPUNMAX+1; 6465 continue; 6466 } 6467 /* negative case */ 6468 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6469 est=(((ueInt)carry>>3)*16777)>>21; 6470 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6471 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6472 if (*c<DECDPUNMAX+1) continue; /* was OK */ 6473 carry++; 6474 *c-=DECDPUNMAX+1; 6475 #elif DECDPUN<=2 6476 /* Can use QUOT10 as carry <= 4 digits */ 6477 if (carry>=0) { 6478 est=QUOT10(carry, DECDPUN); 6479 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6480 carry=est; /* quotient */ 6481 continue; 6482 } 6483 /* negative case */ 6484 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6485 est=QUOT10(carry, DECDPUN); 6486 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6487 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6488 #else 6489 /* remainder operator is undefined if negative, so must test */ 6490 if ((ueInt)carry<(DECDPUNMAX+1)*2) { /* fastpath carry +1 */ 6491 *c=(Unit)(carry-(DECDPUNMAX+1)); /* [helps additions] */ 6492 carry=1; 6493 continue; 6494 } 6495 if (carry>=0) { 6496 *c=(Unit)(carry%(DECDPUNMAX+1)); 6497 carry=carry/(DECDPUNMAX+1); 6498 continue; 6499 } 6500 /* negative case */ 6501 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6502 *c=(Unit)(carry%(DECDPUNMAX+1)); 6503 carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1); 6504 #endif 6505 } /* c */ 6506 6507 /* now may have one or other to complete */ 6508 /* [pretest to avoid loop setup/shutdown] */ 6509 if (c<maxC) for (; c<maxC; c++) { 6510 if (a<alsu+alength) { /* still in A */ 6511 carry+=*a; 6512 a++; 6513 } 6514 else { /* inside B */ 6515 carry+=((eInt)*b)*m; 6516 b++; 6517 } 6518 /* here carry is new Unit of digits; it could be +ve or -ve and */ 6519 /* magnitude up to DECDPUNMAX squared */ 6520 if ((ueInt)carry<=DECDPUNMAX) { /* fastpath 0-DECDPUNMAX */ 6521 *c=(Unit)carry; 6522 carry=0; 6523 continue; 6524 } 6525 /* result for this unit is negative or >DECDPUNMAX */ 6526 #if DECDPUN==4 /* use divide-by-multiply */ 6527 if (carry>=0) { 6528 est=(((ueInt)carry>>11)*53687)>>18; 6529 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6530 carry=est; /* likely quotient [79.7%] */ 6531 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */ 6532 carry++; 6533 *c-=DECDPUNMAX+1; 6534 continue; 6535 } 6536 /* negative case */ 6537 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6538 est=(((ueInt)carry>>11)*53687)>>18; 6539 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6540 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6541 if (*c<DECDPUNMAX+1) continue; /* was OK */ 6542 carry++; 6543 *c-=DECDPUNMAX+1; 6544 #elif DECDPUN==3 6545 if (carry>=0) { 6546 est=(((ueInt)carry>>3)*16777)>>21; 6547 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6548 carry=est; /* likely quotient [99%] */ 6549 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */ 6550 carry++; 6551 *c-=DECDPUNMAX+1; 6552 continue; 6553 } 6554 /* negative case */ 6555 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6556 est=(((ueInt)carry>>3)*16777)>>21; 6557 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6558 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6559 if (*c<DECDPUNMAX+1) continue; /* was OK */ 6560 carry++; 6561 *c-=DECDPUNMAX+1; 6562 #elif DECDPUN<=2 6563 if (carry>=0) { 6564 est=QUOT10(carry, DECDPUN); 6565 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6566 carry=est; /* quotient */ 6567 continue; 6568 } 6569 /* negative case */ 6570 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6571 est=QUOT10(carry, DECDPUN); 6572 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6573 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6574 #else 6575 if ((ueInt)carry<(DECDPUNMAX+1)*2){ /* fastpath carry 1 */ 6576 *c=(Unit)(carry-(DECDPUNMAX+1)); 6577 carry=1; 6578 continue; 6579 } 6580 /* remainder operator is undefined if negative, so must test */ 6581 if (carry>=0) { 6582 *c=(Unit)(carry%(DECDPUNMAX+1)); 6583 carry=carry/(DECDPUNMAX+1); 6584 continue; 6585 } 6586 /* negative case */ 6587 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6588 *c=(Unit)(carry%(DECDPUNMAX+1)); 6589 carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1); 6590 #endif 6591 } /* c */ 6592 6593 /* OK, all A and B processed; might still have carry or borrow */ 6594 /* return number of Units in the result, negated if a borrow */ 6595 if (carry==0) return c-clsu; /* no carry, so no more to do */ 6596 if (carry>0) { /* positive carry */ 6597 *c=(Unit)carry; /* place as new unit */ 6598 c++; /* .. */ 6599 return c-clsu; 6600 } 6601 /* -ve carry: it's a borrow; complement needed */ 6602 add=1; /* temporary carry... */ 6603 for (c=clsu; c<maxC; c++) { 6604 add=DECDPUNMAX+add-*c; 6605 if (add<=DECDPUNMAX) { 6606 *c=(Unit)add; 6607 add=0; 6608 } 6609 else { 6610 *c=0; 6611 add=1; 6612 } 6613 } 6614 /* add an extra unit iff it would be non-zero */ 6615 #if DECTRACE 6616 printf("UAS borrow: add %ld, carry %ld\n", add, carry); 6617 #endif 6618 if ((add-carry-1)!=0) { 6619 *c=(Unit)(add-carry-1); 6620 c++; /* interesting, include it */ 6621 } 6622 return clsu-c; /* -ve result indicates borrowed */ 6623 } /* decUnitAddSub */ 6624 6625 /* ------------------------------------------------------------------ */ 6626 /* decTrim -- trim trailing zeros or normalize */ 6627 /* */ 6628 /* dn is the number to trim or normalize */ 6629 /* set is the context to use to check for clamp */ 6630 /* all is 1 to remove all trailing zeros, 0 for just fraction ones */ 6631 /* dropped returns the number of discarded trailing zeros */ 6632 /* returns dn */ 6633 /* */ 6634 /* If clamp is set in the context then the number of zeros trimmed */ 6635 /* may be limited if the exponent is high. */ 6636 /* All fields are updated as required. This is a utility operation, */ 6637 /* so special values are unchanged and no error is possible. */ 6638 /* ------------------------------------------------------------------ */ 6639 static decNumber * decTrim(decNumber *dn, decContext *set, Flag all, 6640 Int *dropped) { 6641 Int d, exp; /* work */ 6642 uInt cut; /* .. */ 6643 Unit *up; /* -> current Unit */ 6644 6645 #if DECCHECK 6646 if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn; 6647 #endif 6648 6649 *dropped=0; /* assume no zeros dropped */ 6650 if ((dn->bits & DECSPECIAL) /* fast exit if special .. */ 6651 || (*dn->lsu & 0x01)) return dn; /* .. or odd */ 6652 if (ISZERO(dn)) { /* .. or 0 */ 6653 dn->exponent=0; /* (sign is preserved) */ 6654 return dn; 6655 } 6656 6657 /* have a finite number which is even */ 6658 exp=dn->exponent; 6659 cut=1; /* digit (1-DECDPUN) in Unit */ 6660 up=dn->lsu; /* -> current Unit */ 6661 for (d=0; d<dn->digits-1; d++) { /* [don't strip the final digit] */ 6662 /* slice by powers */ 6663 #if DECDPUN<=4 6664 uInt quot=QUOT10(*up, cut); 6665 if ((*up-quot*powers[cut])!=0) break; /* found non-0 digit */ 6666 #else 6667 if (*up%powers[cut]!=0) break; /* found non-0 digit */ 6668 #endif 6669 /* have a trailing 0 */ 6670 if (!all) { /* trimming */ 6671 /* [if exp>0 then all trailing 0s are significant for trim] */ 6672 if (exp<=0) { /* if digit might be significant */ 6673 if (exp==0) break; /* then quit */ 6674 exp++; /* next digit might be significant */ 6675 } 6676 } 6677 cut++; /* next power */ 6678 if (cut>DECDPUN) { /* need new Unit */ 6679 up++; 6680 cut=1; 6681 } 6682 } /* d */ 6683 if (d==0) return dn; /* none to drop */ 6684 6685 /* may need to limit drop if clamping */ 6686 if (set->clamp) { 6687 Int maxd=set->emax-set->digits+1-dn->exponent; 6688 if (maxd<=0) return dn; /* nothing possible */ 6689 if (d>maxd) d=maxd; 6690 } 6691 6692 /* effect the drop */ 6693 decShiftToLeast(dn->lsu, D2U(dn->digits), d); 6694 dn->exponent+=d; /* maintain numerical value */ 6695 dn->digits-=d; /* new length */ 6696 *dropped=d; /* report the count */ 6697 return dn; 6698 } /* decTrim */ 6699 6700 /* ------------------------------------------------------------------ */ 6701 /* decReverse -- reverse a Unit array in place */ 6702 /* */ 6703 /* ulo is the start of the array */ 6704 /* uhi is the end of the array (highest Unit to include) */ 6705 /* */ 6706 /* The units ulo through uhi are reversed in place (if the number */ 6707 /* of units is odd, the middle one is untouched). Note that the */ 6708 /* digit(s) in each unit are unaffected. */ 6709 /* ------------------------------------------------------------------ */ 6710 static void decReverse(Unit *ulo, Unit *uhi) { 6711 Unit temp; 6712 for (; ulo<uhi; ulo++, uhi--) { 6713 temp=*ulo; 6714 *ulo=*uhi; 6715 *uhi=temp; 6716 } 6717 return; 6718 } /* decReverse */ 6719 6720 /* ------------------------------------------------------------------ */ 6721 /* decShiftToMost -- shift digits in array towards most significant */ 6722 /* */ 6723 /* uar is the array */ 6724 /* digits is the count of digits in use in the array */ 6725 /* shift is the number of zeros to pad with (least significant); */ 6726 /* it must be zero or positive */ 6727 /* */ 6728 /* returns the new length of the integer in the array, in digits */ 6729 /* */ 6730 /* No overflow is permitted (that is, the uar array must be known to */ 6731 /* be large enough to hold the result, after shifting). */ 6732 /* ------------------------------------------------------------------ */ 6733 static Int decShiftToMost(Unit *uar, Int digits, Int shift) { 6734 Unit *target, *source, *first; /* work */ 6735 Int cut; /* odd 0's to add */ 6736 uInt next; /* work */ 6737 6738 if (shift==0) return digits; /* [fastpath] nothing to do */ 6739 if ((digits+shift)<=DECDPUN) { /* [fastpath] single-unit case */ 6740 *uar=(Unit)(*uar*powers[shift]); 6741 return digits+shift; 6742 } 6743 6744 next=0; /* all paths */ 6745 source=uar+D2U(digits)-1; /* where msu comes from */ 6746 target=source+D2U(shift); /* where upper part of first cut goes */ 6747 cut=DECDPUN-MSUDIGITS(shift); /* where to slice */ 6748 if (cut==0) { /* unit-boundary case */ 6749 for (; source>=uar; source--, target--) *target=*source; 6750 } 6751 else { 6752 first=uar+D2U(digits+shift)-1; /* where msu of source will end up */ 6753 for (; source>=uar; source--, target--) { 6754 /* split the source Unit and accumulate remainder for next */ 6755 #if DECDPUN<=4 6756 uInt quot=QUOT10(*source, cut); 6757 uInt rem=*source-quot*powers[cut]; 6758 next+=quot; 6759 #else 6760 uInt rem=*source%powers[cut]; 6761 next+=*source/powers[cut]; 6762 #endif 6763 if (target<=first) *target=(Unit)next; /* write to target iff valid */ 6764 next=rem*powers[DECDPUN-cut]; /* save remainder for next Unit */ 6765 } 6766 } /* shift-move */ 6767 6768 /* propagate any partial unit to one below and clear the rest */ 6769 for (; target>=uar; target--) { 6770 *target=(Unit)next; 6771 next=0; 6772 } 6773 return digits+shift; 6774 } /* decShiftToMost */ 6775 6776 /* ------------------------------------------------------------------ */ 6777 /* decShiftToLeast -- shift digits in array towards least significant */ 6778 /* */ 6779 /* uar is the array */ 6780 /* units is length of the array, in units */ 6781 /* shift is the number of digits to remove from the lsu end; it */ 6782 /* must be zero or positive and <= than units*DECDPUN. */ 6783 /* */ 6784 /* returns the new length of the integer in the array, in units */ 6785 /* */ 6786 /* Removed digits are discarded (lost). Units not required to hold */ 6787 /* the final result are unchanged. */ 6788 /* ------------------------------------------------------------------ */ 6789 static Int decShiftToLeast(Unit *uar, Int units, Int shift) { 6790 Unit *target, *up; /* work */ 6791 Int cut, count; /* work */ 6792 Int quot, rem; /* for division */ 6793 6794 if (shift==0) return units; /* [fastpath] nothing to do */ 6795 if (shift==units*DECDPUN) { /* [fastpath] little to do */ 6796 *uar=0; /* all digits cleared gives zero */ 6797 return 1; /* leaves just the one */ 6798 } 6799 6800 target=uar; /* both paths */ 6801 cut=MSUDIGITS(shift); 6802 if (cut==DECDPUN) { /* unit-boundary case; easy */ 6803 up=uar+D2U(shift); 6804 for (; up<uar+units; target++, up++) *target=*up; 6805 return target-uar; 6806 } 6807 6808 /* messier */ 6809 up=uar+D2U(shift-cut); /* source; correct to whole Units */ 6810 count=units*DECDPUN-shift; /* the maximum new length */ 6811 #if DECDPUN<=4 6812 quot=QUOT10(*up, cut); 6813 #else 6814 quot=*up/powers[cut]; 6815 #endif 6816 for (; ; target++) { 6817 *target=(Unit)quot; 6818 count-=(DECDPUN-cut); 6819 if (count<=0) break; 6820 up++; 6821 quot=*up; 6822 #if DECDPUN<=4 6823 quot=QUOT10(quot, cut); 6824 rem=*up-quot*powers[cut]; 6825 #else 6826 rem=quot%powers[cut]; 6827 quot=quot/powers[cut]; 6828 #endif 6829 *target=(Unit)(*target+rem*powers[DECDPUN-cut]); 6830 count-=cut; 6831 if (count<=0) break; 6832 } 6833 return target-uar+1; 6834 } /* decShiftToLeast */ 6835 6836 #if DECSUBSET 6837 /* ------------------------------------------------------------------ */ 6838 /* decRoundOperand -- round an operand [used for subset only] */ 6839 /* */ 6840 /* dn is the number to round (dn->digits is > set->digits) */ 6841 /* set is the relevant context */ 6842 /* status is the status accumulator */ 6843 /* */ 6844 /* returns an allocated decNumber with the rounded result. */ 6845 /* */ 6846 /* lostDigits and other status may be set by this. */ 6847 /* */ 6848 /* Since the input is an operand, it must not be modified. */ 6849 /* Instead, return an allocated decNumber, rounded as required. */ 6850 /* It is the caller's responsibility to free the allocated storage. */ 6851 /* */ 6852 /* If no storage is available then the result cannot be used, so NULL */ 6853 /* is returned. */ 6854 /* ------------------------------------------------------------------ */ 6855 static decNumber *decRoundOperand(const decNumber *dn, decContext *set, 6856 uInt *status) { 6857 decNumber *res; /* result structure */ 6858 uInt newstatus=0; /* status from round */ 6859 Int residue=0; /* rounding accumulator */ 6860 6861 /* Allocate storage for the returned decNumber, big enough for the */ 6862 /* length specified by the context */ 6863 res=(decNumber *)malloc(sizeof(decNumber) 6864 +(D2U(set->digits)-1)*sizeof(Unit)); 6865 if (res==NULL) { 6866 *status|=DEC_Insufficient_storage; 6867 return NULL; 6868 } 6869 decCopyFit(res, dn, set, &residue, &newstatus); 6870 decApplyRound(res, set, residue, &newstatus); 6871 6872 /* If that set Inexact then "lost digits" is raised... */ 6873 if (newstatus & DEC_Inexact) newstatus|=DEC_Lost_digits; 6874 *status|=newstatus; 6875 return res; 6876 } /* decRoundOperand */ 6877 #endif 6878 6879 /* ------------------------------------------------------------------ */ 6880 /* decCopyFit -- copy a number, truncating the coefficient if needed */ 6881 /* */ 6882 /* dest is the target decNumber */ 6883 /* src is the source decNumber */ 6884 /* set is the context [used for length (digits) and rounding mode] */ 6885 /* residue is the residue accumulator */ 6886 /* status contains the current status to be updated */ 6887 /* */ 6888 /* (dest==src is allowed and will be a no-op if fits) */ 6889 /* All fields are updated as required. */ 6890 /* ------------------------------------------------------------------ */ 6891 static void decCopyFit(decNumber *dest, const decNumber *src, 6892 decContext *set, Int *residue, uInt *status) { 6893 dest->bits=src->bits; 6894 dest->exponent=src->exponent; 6895 decSetCoeff(dest, set, src->lsu, src->digits, residue, status); 6896 } /* decCopyFit */ 6897 6898 /* ------------------------------------------------------------------ */ 6899 /* decSetCoeff -- set the coefficient of a number */ 6900 /* */ 6901 /* dn is the number whose coefficient array is to be set. */ 6902 /* It must have space for set->digits digits */ 6903 /* set is the context [for size] */ 6904 /* lsu -> lsu of the source coefficient [may be dn->lsu] */ 6905 /* len is digits in the source coefficient [may be dn->digits] */ 6906 /* residue is the residue accumulator. This has values as in */ 6907 /* decApplyRound, and will be unchanged unless the */ 6908 /* target size is less than len. In this case, the */ 6909 /* coefficient is truncated and the residue is updated to */ 6910 /* reflect the previous residue and the dropped digits. */ 6911 /* status is the status accumulator, as usual */ 6912 /* */ 6913 /* The coefficient may already be in the number, or it can be an */ 6914 /* external intermediate array. If it is in the number, lsu must == */ 6915 /* dn->lsu and len must == dn->digits. */ 6916 /* */ 6917 /* Note that the coefficient length (len) may be < set->digits, and */ 6918 /* in this case this merely copies the coefficient (or is a no-op */ 6919 /* if dn->lsu==lsu). */ 6920 /* */ 6921 /* Note also that (only internally, from decQuantizeOp and */ 6922 /* decSetSubnormal) the value of set->digits may be less than one, */ 6923 /* indicating a round to left. This routine handles that case */ 6924 /* correctly; caller ensures space. */ 6925 /* */ 6926 /* dn->digits, dn->lsu (and as required), and dn->exponent are */ 6927 /* updated as necessary. dn->bits (sign) is unchanged. */ 6928 /* */ 6929 /* DEC_Rounded status is set if any digits are discarded. */ 6930 /* DEC_Inexact status is set if any non-zero digits are discarded, or */ 6931 /* incoming residue was non-0 (implies rounded) */ 6932 /* ------------------------------------------------------------------ */ 6933 /* mapping array: maps 0-9 to canonical residues, so that a residue */ 6934 /* can be adjusted in the range [-1, +1] and achieve correct rounding */ 6935 /* 0 1 2 3 4 5 6 7 8 9 */ 6936 static const uByte resmap[10]={0, 3, 3, 3, 3, 5, 7, 7, 7, 7}; 6937 static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu, 6938 Int len, Int *residue, uInt *status) { 6939 Int discard; /* number of digits to discard */ 6940 uInt cut; /* cut point in Unit */ 6941 const Unit *up; /* work */ 6942 Unit *target; /* .. */ 6943 Int count; /* .. */ 6944 #if DECDPUN<=4 6945 uInt temp; /* .. */ 6946 #endif 6947 6948 discard=len-set->digits; /* digits to discard */ 6949 if (discard<=0) { /* no digits are being discarded */ 6950 if (dn->lsu!=lsu) { /* copy needed */ 6951 /* copy the coefficient array to the result number; no shift needed */ 6952 count=len; /* avoids D2U */ 6953 up=lsu; 6954 for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN) 6955 *target=*up; 6956 dn->digits=len; /* set the new length */ 6957 } 6958 /* dn->exponent and residue are unchanged, record any inexactitude */ 6959 if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded); 6960 return; 6961 } 6962 6963 /* some digits must be discarded ... */ 6964 dn->exponent+=discard; /* maintain numerical value */ 6965 *status|=DEC_Rounded; /* accumulate Rounded status */ 6966 if (*residue>1) *residue=1; /* previous residue now to right, so reduce */ 6967 6968 if (discard>len) { /* everything, +1, is being discarded */ 6969 /* guard digit is 0 */ 6970 /* residue is all the number [NB could be all 0s] */ 6971 if (*residue<=0) { /* not already positive */ 6972 count=len; /* avoids D2U */ 6973 for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { /* found non-0 */ 6974 *residue=1; 6975 break; /* no need to check any others */ 6976 } 6977 } 6978 if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */ 6979 *dn->lsu=0; /* coefficient will now be 0 */ 6980 dn->digits=1; /* .. */ 6981 return; 6982 } /* total discard */ 6983 6984 /* partial discard [most common case] */ 6985 /* here, at least the first (most significant) discarded digit exists */ 6986 6987 /* spin up the number, noting residue during the spin, until get to */ 6988 /* the Unit with the first discarded digit. When reach it, extract */ 6989 /* it and remember its position */ 6990 count=0; 6991 for (up=lsu;; up++) { 6992 count+=DECDPUN; 6993 if (count>=discard) break; /* full ones all checked */ 6994 if (*up!=0) *residue=1; 6995 } /* up */ 6996 6997 /* here up -> Unit with first discarded digit */ 6998 cut=discard-(count-DECDPUN)-1; 6999 if (cut==DECDPUN-1) { /* unit-boundary case (fast) */ 7000 Unit half=(Unit)powers[DECDPUN]>>1; 7001 /* set residue directly */ 7002 if (*up>=half) { 7003 if (*up>half) *residue=7; 7004 else *residue+=5; /* add sticky bit */ 7005 } 7006 else { /* <half */ 7007 if (*up!=0) *residue=3; /* [else is 0, leave as sticky bit] */ 7008 } 7009 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */ 7010 *dn->lsu=0; /* .. result is 0 */ 7011 dn->digits=1; /* .. */ 7012 } 7013 else { /* shift to least */ 7014 count=set->digits; /* now digits to end up with */ 7015 dn->digits=count; /* set the new length */ 7016 up++; /* move to next */ 7017 /* on unit boundary, so shift-down copy loop is simple */ 7018 for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN) 7019 *target=*up; 7020 } 7021 } /* unit-boundary case */ 7022 7023 else { /* discard digit is in low digit(s), and not top digit */ 7024 uInt discard1; /* first discarded digit */ 7025 uInt quot, rem; /* for divisions */ 7026 if (cut==0) quot=*up; /* is at bottom of unit */ 7027 else /* cut>0 */ { /* it's not at bottom of unit */ 7028 #if DECDPUN<=4 7029 quot=QUOT10(*up, cut); 7030 rem=*up-quot*powers[cut]; 7031 #else 7032 rem=*up%powers[cut]; 7033 quot=*up/powers[cut]; 7034 #endif 7035 if (rem!=0) *residue=1; 7036 } 7037 /* discard digit is now at bottom of quot */ 7038 #if DECDPUN<=4 7039 temp=(quot*6554)>>16; /* fast /10 */ 7040 /* Vowels algorithm here not a win (9 instructions) */ 7041 discard1=quot-X10(temp); 7042 quot=temp; 7043 #else 7044 discard1=quot%10; 7045 quot=quot/10; 7046 #endif 7047 /* here, discard1 is the guard digit, and residue is everything */ 7048 /* else [use mapping array to accumulate residue safely] */ 7049 *residue+=resmap[discard1]; 7050 cut++; /* update cut */ 7051 /* here: up -> Unit of the array with bottom digit */ 7052 /* cut is the division point for each Unit */ 7053 /* quot holds the uncut high-order digits for the current unit */ 7054 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */ 7055 *dn->lsu=0; /* .. result is 0 */ 7056 dn->digits=1; /* .. */ 7057 } 7058 else { /* shift to least needed */ 7059 count=set->digits; /* now digits to end up with */ 7060 dn->digits=count; /* set the new length */ 7061 /* shift-copy the coefficient array to the result number */ 7062 for (target=dn->lsu; ; target++) { 7063 *target=(Unit)quot; 7064 count-=(DECDPUN-cut); 7065 if (count<=0) break; 7066 up++; 7067 quot=*up; 7068 #if DECDPUN<=4 7069 quot=QUOT10(quot, cut); 7070 rem=*up-quot*powers[cut]; 7071 #else 7072 rem=quot%powers[cut]; 7073 quot=quot/powers[cut]; 7074 #endif 7075 *target=(Unit)(*target+rem*powers[DECDPUN-cut]); 7076 count-=cut; 7077 if (count<=0) break; 7078 } /* shift-copy loop */ 7079 } /* shift to least */ 7080 } /* not unit boundary */ 7081 7082 if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */ 7083 return; 7084 } /* decSetCoeff */ 7085 7086 /* ------------------------------------------------------------------ */ 7087 /* decApplyRound -- apply pending rounding to a number */ 7088 /* */ 7089 /* dn is the number, with space for set->digits digits */ 7090 /* set is the context [for size and rounding mode] */ 7091 /* residue indicates pending rounding, being any accumulated */ 7092 /* guard and sticky information. It may be: */ 7093 /* 6-9: rounding digit is >5 */ 7094 /* 5: rounding digit is exactly half-way */ 7095 /* 1-4: rounding digit is <5 and >0 */ 7096 /* 0: the coefficient is exact */ 7097 /* -1: as 1, but the hidden digits are subtractive, that */ 7098 /* is, of the opposite sign to dn. In this case the */ 7099 /* coefficient must be non-0. This case occurs when */ 7100 /* subtracting a small number (which can be reduced to */ 7101 /* a sticky bit); see decAddOp. */ 7102 /* status is the status accumulator, as usual */ 7103 /* */ 7104 /* This routine applies rounding while keeping the length of the */ 7105 /* coefficient constant. The exponent and status are unchanged */ 7106 /* except if: */ 7107 /* */ 7108 /* -- the coefficient was increased and is all nines (in which */ 7109 /* case Overflow could occur, and is handled directly here so */ 7110 /* the caller does not need to re-test for overflow) */ 7111 /* */ 7112 /* -- the coefficient was decreased and becomes all nines (in which */ 7113 /* case Underflow could occur, and is also handled directly). */ 7114 /* */ 7115 /* All fields in dn are updated as required. */ 7116 /* */ 7117 /* ------------------------------------------------------------------ */ 7118 static void decApplyRound(decNumber *dn, decContext *set, Int residue, 7119 uInt *status) { 7120 Int bump; /* 1 if coefficient needs to be incremented */ 7121 /* -1 if coefficient needs to be decremented */ 7122 7123 if (residue==0) return; /* nothing to apply */ 7124 7125 bump=0; /* assume a smooth ride */ 7126 7127 /* now decide whether, and how, to round, depending on mode */ 7128 switch (set->round) { 7129 case DEC_ROUND_05UP: { /* round zero or five up (for reround) */ 7130 /* This is the same as DEC_ROUND_DOWN unless there is a */ 7131 /* positive residue and the lsd of dn is 0 or 5, in which case */ 7132 /* it is bumped; when residue is <0, the number is therefore */ 7133 /* bumped down unless the final digit was 1 or 6 (in which */ 7134 /* case it is bumped down and then up -- a no-op) */ 7135 Int lsd5=*dn->lsu%5; /* get lsd and quintate */ 7136 if (residue<0 && lsd5!=1) bump=-1; 7137 else if (residue>0 && lsd5==0) bump=1; 7138 /* [bump==1 could be applied directly; use common path for clarity] */ 7139 break;} /* r-05 */ 7140 7141 case DEC_ROUND_DOWN: { 7142 /* no change, except if negative residue */ 7143 if (residue<0) bump=-1; 7144 break;} /* r-d */ 7145 7146 case DEC_ROUND_HALF_DOWN: { 7147 if (residue>5) bump=1; 7148 break;} /* r-h-d */ 7149 7150 case DEC_ROUND_HALF_EVEN: { 7151 if (residue>5) bump=1; /* >0.5 goes up */ 7152 else if (residue==5) { /* exactly 0.5000... */ 7153 /* 0.5 goes up iff [new] lsd is odd */ 7154 if (*dn->lsu & 0x01) bump=1; 7155 } 7156 break;} /* r-h-e */ 7157 7158 case DEC_ROUND_HALF_UP: { 7159 if (residue>=5) bump=1; 7160 break;} /* r-h-u */ 7161 7162 case DEC_ROUND_UP: { 7163 if (residue>0) bump=1; 7164 break;} /* r-u */ 7165 7166 case DEC_ROUND_CEILING: { 7167 /* same as _UP for positive numbers, and as _DOWN for negatives */ 7168 /* [negative residue cannot occur on 0] */ 7169 if (decNumberIsNegative(dn)) { 7170 if (residue<0) bump=-1; 7171 } 7172 else { 7173 if (residue>0) bump=1; 7174 } 7175 break;} /* r-c */ 7176 7177 case DEC_ROUND_FLOOR: { 7178 /* same as _UP for negative numbers, and as _DOWN for positive */ 7179 /* [negative residue cannot occur on 0] */ 7180 if (!decNumberIsNegative(dn)) { 7181 if (residue<0) bump=-1; 7182 } 7183 else { 7184 if (residue>0) bump=1; 7185 } 7186 break;} /* r-f */ 7187 7188 default: { /* e.g., DEC_ROUND_MAX */ 7189 *status|=DEC_Invalid_context; 7190 #if DECTRACE || (DECCHECK && DECVERB) 7191 printf("Unknown rounding mode: %d\n", set->round); 7192 #endif 7193 break;} 7194 } /* switch */ 7195 7196 /* now bump the number, up or down, if need be */ 7197 if (bump==0) return; /* no action required */ 7198 7199 /* Simply use decUnitAddSub unless bumping up and the number is */ 7200 /* all nines. In this special case set to 100... explicitly */ 7201 /* and adjust the exponent by one (as otherwise could overflow */ 7202 /* the array) */ 7203 /* Similarly handle all-nines result if bumping down. */ 7204 if (bump>0) { 7205 Unit *up; /* work */ 7206 uInt count=dn->digits; /* digits to be checked */ 7207 for (up=dn->lsu; ; up++) { 7208 if (count<=DECDPUN) { 7209 /* this is the last Unit (the msu) */ 7210 if (*up!=powers[count]-1) break; /* not still 9s */ 7211 /* here if it, too, is all nines */ 7212 *up=(Unit)powers[count-1]; /* here 999 -> 100 etc. */ 7213 for (up=up-1; up>=dn->lsu; up--) *up=0; /* others all to 0 */ 7214 dn->exponent++; /* and bump exponent */ 7215 /* [which, very rarely, could cause Overflow...] */ 7216 if ((dn->exponent+dn->digits)>set->emax+1) { 7217 decSetOverflow(dn, set, status); 7218 } 7219 return; /* done */ 7220 } 7221 /* a full unit to check, with more to come */ 7222 if (*up!=DECDPUNMAX) break; /* not still 9s */ 7223 count-=DECDPUN; 7224 } /* up */ 7225 } /* bump>0 */ 7226 else { /* -1 */ 7227 /* here checking for a pre-bump of 1000... (leading 1, all */ 7228 /* other digits zero) */ 7229 Unit *up, *sup; /* work */ 7230 uInt count=dn->digits; /* digits to be checked */ 7231 for (up=dn->lsu; ; up++) { 7232 if (count<=DECDPUN) { 7233 /* this is the last Unit (the msu) */ 7234 if (*up!=powers[count-1]) break; /* not 100.. */ 7235 /* here if have the 1000... case */ 7236 sup=up; /* save msu pointer */ 7237 *up=(Unit)powers[count]-1; /* here 100 in msu -> 999 */ 7238 /* others all to all-nines, too */ 7239 for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1; 7240 dn->exponent--; /* and bump exponent */ 7241 7242 /* iff the number was at the subnormal boundary (exponent=etiny) */ 7243 /* then the exponent is now out of range, so it will in fact get */ 7244 /* clamped to etiny and the final 9 dropped. */ 7245 /* printf(">> emin=%d exp=%d sdig=%d\n", set->emin, */ 7246 /* dn->exponent, set->digits); */ 7247 if (dn->exponent+1==set->emin-set->digits+1) { 7248 if (count==1 && dn->digits==1) *sup=0; /* here 9 -> 0[.9] */ 7249 else { 7250 *sup=(Unit)powers[count-1]-1; /* here 999.. in msu -> 99.. */ 7251 dn->digits--; 7252 } 7253 dn->exponent++; 7254 *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded; 7255 } 7256 return; /* done */ 7257 } 7258 7259 /* a full unit to check, with more to come */ 7260 if (*up!=0) break; /* not still 0s */ 7261 count-=DECDPUN; 7262 } /* up */ 7263 7264 } /* bump<0 */ 7265 7266 /* Actual bump needed. Do it. */ 7267 decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump); 7268 } /* decApplyRound */ 7269 7270 #if DECSUBSET 7271 /* ------------------------------------------------------------------ */ 7272 /* decFinish -- finish processing a number */ 7273 /* */ 7274 /* dn is the number */ 7275 /* set is the context */ 7276 /* residue is the rounding accumulator (as in decApplyRound) */ 7277 /* status is the accumulator */ 7278 /* */ 7279 /* This finishes off the current number by: */ 7280 /* 1. If not extended: */ 7281 /* a. Converting a zero result to clean '0' */ 7282 /* b. Reducing positive exponents to 0, if would fit in digits */ 7283 /* 2. Checking for overflow and subnormals (always) */ 7284 /* Note this is just Finalize when no subset arithmetic. */ 7285 /* All fields are updated as required. */ 7286 /* ------------------------------------------------------------------ */ 7287 static void decFinish(decNumber *dn, decContext *set, Int *residue, 7288 uInt *status) { 7289 if (!set->extended) { 7290 if ISZERO(dn) { /* value is zero */ 7291 dn->exponent=0; /* clean exponent .. */ 7292 dn->bits=0; /* .. and sign */ 7293 return; /* no error possible */ 7294 } 7295 if (dn->exponent>=0) { /* non-negative exponent */ 7296 /* >0; reduce to integer if possible */ 7297 if (set->digits >= (dn->exponent+dn->digits)) { 7298 dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent); 7299 dn->exponent=0; 7300 } 7301 } 7302 } /* !extended */ 7303 7304 decFinalize(dn, set, residue, status); 7305 } /* decFinish */ 7306 #endif 7307 7308 /* ------------------------------------------------------------------ */ 7309 /* decFinalize -- final check, clamp, and round of a number */ 7310 /* */ 7311 /* dn is the number */ 7312 /* set is the context */ 7313 /* residue is the rounding accumulator (as in decApplyRound) */ 7314 /* status is the status accumulator */ 7315 /* */ 7316 /* This finishes off the current number by checking for subnormal */ 7317 /* results, applying any pending rounding, checking for overflow, */ 7318 /* and applying any clamping. */ 7319 /* Underflow and overflow conditions are raised as appropriate. */ 7320 /* All fields are updated as required. */ 7321 /* ------------------------------------------------------------------ */ 7322 static void decFinalize(decNumber *dn, decContext *set, Int *residue, 7323 uInt *status) { 7324 Int shift; /* shift needed if clamping */ 7325 Int tinyexp=set->emin-dn->digits+1; /* precalculate subnormal boundary */ 7326 7327 /* Must be careful, here, when checking the exponent as the */ 7328 /* adjusted exponent could overflow 31 bits [because it may already */ 7329 /* be up to twice the expected]. */ 7330 7331 /* First test for subnormal. This must be done before any final */ 7332 /* round as the result could be rounded to Nmin or 0. */ 7333 if (dn->exponent<=tinyexp) { /* prefilter */ 7334 Int comp; 7335 decNumber nmin; 7336 /* A very nasty case here is dn == Nmin and residue<0 */ 7337 if (dn->exponent<tinyexp) { 7338 /* Go handle subnormals; this will apply round if needed. */ 7339 decSetSubnormal(dn, set, residue, status); 7340 return; 7341 } 7342 /* Equals case: only subnormal if dn=Nmin and negative residue */ 7343 decNumberZero(&nmin); 7344 nmin.lsu[0]=1; 7345 nmin.exponent=set->emin; 7346 comp=decCompare(dn, &nmin, 1); /* (signless compare) */ 7347 if (comp==BADINT) { /* oops */ 7348 *status|=DEC_Insufficient_storage; /* abandon... */ 7349 return; 7350 } 7351 if (*residue<0 && comp==0) { /* neg residue and dn==Nmin */ 7352 decApplyRound(dn, set, *residue, status); /* might force down */ 7353 decSetSubnormal(dn, set, residue, status); 7354 return; 7355 } 7356 } 7357 7358 /* now apply any pending round (this could raise overflow). */ 7359 if (*residue!=0) decApplyRound(dn, set, *residue, status); 7360 7361 /* Check for overflow [redundant in the 'rare' case] or clamp */ 7362 if (dn->exponent<=set->emax-set->digits+1) return; /* neither needed */ 7363 7364 7365 /* here when might have an overflow or clamp to do */ 7366 if (dn->exponent>set->emax-dn->digits+1) { /* too big */ 7367 decSetOverflow(dn, set, status); 7368 return; 7369 } 7370 /* here when the result is normal but in clamp range */ 7371 if (!set->clamp) return; 7372 7373 /* here when need to apply the IEEE exponent clamp (fold-down) */ 7374 shift=dn->exponent-(set->emax-set->digits+1); 7375 7376 /* shift coefficient (if non-zero) */ 7377 if (!ISZERO(dn)) { 7378 dn->digits=decShiftToMost(dn->lsu, dn->digits, shift); 7379 } 7380 dn->exponent-=shift; /* adjust the exponent to match */ 7381 *status|=DEC_Clamped; /* and record the dirty deed */ 7382 return; 7383 } /* decFinalize */ 7384 7385 /* ------------------------------------------------------------------ */ 7386 /* decSetOverflow -- set number to proper overflow value */ 7387 /* */ 7388 /* dn is the number (used for sign [only] and result) */ 7389 /* set is the context [used for the rounding mode, etc.] */ 7390 /* status contains the current status to be updated */ 7391 /* */ 7392 /* This sets the sign of a number and sets its value to either */ 7393 /* Infinity or the maximum finite value, depending on the sign of */ 7394 /* dn and the rounding mode, following IEEE 854 rules. */ 7395 /* ------------------------------------------------------------------ */ 7396 static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) { 7397 Flag needmax=0; /* result is maximum finite value */ 7398 uByte sign=dn->bits&DECNEG; /* clean and save sign bit */ 7399 7400 if (ISZERO(dn)) { /* zero does not overflow magnitude */ 7401 Int emax=set->emax; /* limit value */ 7402 if (set->clamp) emax-=set->digits-1; /* lower if clamping */ 7403 if (dn->exponent>emax) { /* clamp required */ 7404 dn->exponent=emax; 7405 *status|=DEC_Clamped; 7406 } 7407 return; 7408 } 7409 7410 decNumberZero(dn); 7411 switch (set->round) { 7412 case DEC_ROUND_DOWN: { 7413 needmax=1; /* never Infinity */ 7414 break;} /* r-d */ 7415 case DEC_ROUND_05UP: { 7416 needmax=1; /* never Infinity */ 7417 break;} /* r-05 */ 7418 case DEC_ROUND_CEILING: { 7419 if (sign) needmax=1; /* Infinity if non-negative */ 7420 break;} /* r-c */ 7421 case DEC_ROUND_FLOOR: { 7422 if (!sign) needmax=1; /* Infinity if negative */ 7423 break;} /* r-f */ 7424 default: break; /* Infinity in all other cases */ 7425 } 7426 if (needmax) { 7427 decSetMaxValue(dn, set); 7428 dn->bits=sign; /* set sign */ 7429 } 7430 else dn->bits=sign|DECINF; /* Value is +/-Infinity */ 7431 *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded; 7432 } /* decSetOverflow */ 7433 7434 /* ------------------------------------------------------------------ */ 7435 /* decSetMaxValue -- set number to +Nmax (maximum normal value) */ 7436 /* */ 7437 /* dn is the number to set */ 7438 /* set is the context [used for digits and emax] */ 7439 /* */ 7440 /* This sets the number to the maximum positive value. */ 7441 /* ------------------------------------------------------------------ */ 7442 static void decSetMaxValue(decNumber *dn, decContext *set) { 7443 Unit *up; /* work */ 7444 Int count=set->digits; /* nines to add */ 7445 dn->digits=count; 7446 /* fill in all nines to set maximum value */ 7447 for (up=dn->lsu; ; up++) { 7448 if (count>DECDPUN) *up=DECDPUNMAX; /* unit full o'nines */ 7449 else { /* this is the msu */ 7450 *up=(Unit)(powers[count]-1); 7451 break; 7452 } 7453 count-=DECDPUN; /* filled those digits */ 7454 } /* up */ 7455 dn->bits=0; /* + sign */ 7456 dn->exponent=set->emax-set->digits+1; 7457 } /* decSetMaxValue */ 7458 7459 /* ------------------------------------------------------------------ */ 7460 /* decSetSubnormal -- process value whose exponent is <Emin */ 7461 /* */ 7462 /* dn is the number (used as input as well as output; it may have */ 7463 /* an allowed subnormal value, which may need to be rounded) */ 7464 /* set is the context [used for the rounding mode] */ 7465 /* residue is any pending residue */ 7466 /* status contains the current status to be updated */ 7467 /* */ 7468 /* If subset mode, set result to zero and set Underflow flags. */ 7469 /* */ 7470 /* Value may be zero with a low exponent; this does not set Subnormal */ 7471 /* but the exponent will be clamped to Etiny. */ 7472 /* */ 7473 /* Otherwise ensure exponent is not out of range, and round as */ 7474 /* necessary. Underflow is set if the result is Inexact. */ 7475 /* ------------------------------------------------------------------ */ 7476 static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue, 7477 uInt *status) { 7478 decContext workset; /* work */ 7479 Int etiny, adjust; /* .. */ 7480 7481 #if DECSUBSET 7482 /* simple set to zero and 'hard underflow' for subset */ 7483 if (!set->extended) { 7484 decNumberZero(dn); 7485 /* always full overflow */ 7486 *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded; 7487 return; 7488 } 7489 #endif 7490 7491 /* Full arithmetic -- allow subnormals, rounded to minimum exponent */ 7492 /* (Etiny) if needed */ 7493 etiny=set->emin-(set->digits-1); /* smallest allowed exponent */ 7494 7495 if ISZERO(dn) { /* value is zero */ 7496 /* residue can never be non-zero here */ 7497 #if DECCHECK 7498 if (*residue!=0) { 7499 printf("++ Subnormal 0 residue %ld\n", (LI)*residue); 7500 *status|=DEC_Invalid_operation; 7501 } 7502 #endif 7503 if (dn->exponent<etiny) { /* clamp required */ 7504 dn->exponent=etiny; 7505 *status|=DEC_Clamped; 7506 } 7507 return; 7508 } 7509 7510 *status|=DEC_Subnormal; /* have a non-zero subnormal */ 7511 adjust=etiny-dn->exponent; /* calculate digits to remove */ 7512 if (adjust<=0) { /* not out of range; unrounded */ 7513 /* residue can never be non-zero here, except in the Nmin-residue */ 7514 /* case (which is a subnormal result), so can take fast-path here */ 7515 /* it may already be inexact (from setting the coefficient) */ 7516 if (*status&DEC_Inexact) *status|=DEC_Underflow; 7517 return; 7518 } 7519 7520 /* adjust>0, so need to rescale the result so exponent becomes Etiny */ 7521 /* [this code is similar to that in rescale] */ 7522 workset=*set; /* clone rounding, etc. */ 7523 workset.digits=dn->digits-adjust; /* set requested length */ 7524 workset.emin-=adjust; /* and adjust emin to match */ 7525 /* [note that the latter can be <1, here, similar to Rescale case] */ 7526 decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status); 7527 decApplyRound(dn, &workset, *residue, status); 7528 7529 /* Use 754R/854 default rule: Underflow is set iff Inexact */ 7530 /* [independent of whether trapped] */ 7531 if (*status&DEC_Inexact) *status|=DEC_Underflow; 7532 7533 /* if rounded up a 999s case, exponent will be off by one; adjust */ 7534 /* back if so [it will fit, because it was shortened earlier] */ 7535 if (dn->exponent>etiny) { 7536 dn->digits=decShiftToMost(dn->lsu, dn->digits, 1); 7537 dn->exponent--; /* (re)adjust the exponent. */ 7538 } 7539 7540 /* if rounded to zero, it is by definition clamped... */ 7541 if (ISZERO(dn)) *status|=DEC_Clamped; 7542 } /* decSetSubnormal */ 7543 7544 /* ------------------------------------------------------------------ */ 7545 /* decCheckMath - check entry conditions for a math function */ 7546 /* */ 7547 /* This checks the context and the operand */ 7548 /* */ 7549 /* rhs is the operand to check */ 7550 /* set is the context to check */ 7551 /* status is unchanged if both are good */ 7552 /* */ 7553 /* returns non-zero if status is changed, 0 otherwise */ 7554 /* */ 7555 /* Restrictions enforced: */ 7556 /* */ 7557 /* digits, emax, and -emin in the context must be less than */ 7558 /* DEC_MAX_MATH (999999), and A must be within these bounds if */ 7559 /* non-zero. Invalid_operation is set in the status if a */ 7560 /* restriction is violated. */ 7561 /* ------------------------------------------------------------------ */ 7562 static uInt decCheckMath(const decNumber *rhs, decContext *set, 7563 uInt *status) { 7564 uInt save=*status; /* record */ 7565 if (set->digits>DEC_MAX_MATH 7566 || set->emax>DEC_MAX_MATH 7567 || -set->emin>DEC_MAX_MATH) *status|=DEC_Invalid_context; 7568 else if ((rhs->digits>DEC_MAX_MATH 7569 || rhs->exponent+rhs->digits>DEC_MAX_MATH+1 7570 || rhs->exponent+rhs->digits<2*(1-DEC_MAX_MATH)) 7571 && !ISZERO(rhs)) *status|=DEC_Invalid_operation; 7572 return (*status!=save); 7573 } /* decCheckMath */ 7574 7575 /* ------------------------------------------------------------------ */ 7576 /* decGetInt -- get integer from a number */ 7577 /* */ 7578 /* dn is the number [which will not be altered] */ 7579 /* */ 7580 /* returns one of: */ 7581 /* BADINT if there is a non-zero fraction */ 7582 /* the converted integer */ 7583 /* BIGEVEN if the integer is even and magnitude > 2*10**9 */ 7584 /* BIGODD if the integer is odd and magnitude > 2*10**9 */ 7585 /* */ 7586 /* This checks and gets a whole number from the input decNumber. */ 7587 /* The sign can be determined from dn by the caller when BIGEVEN or */ 7588 /* BIGODD is returned. */ 7589 /* ------------------------------------------------------------------ */ 7590 static Int decGetInt(const decNumber *dn) { 7591 Int theInt; /* result accumulator */ 7592 const Unit *up; /* work */ 7593 Int got; /* digits (real or not) processed */ 7594 Int ilength=dn->digits+dn->exponent; /* integral length */ 7595 Flag neg=decNumberIsNegative(dn); /* 1 if -ve */ 7596 7597 /* The number must be an integer that fits in 10 digits */ 7598 /* Assert, here, that 10 is enough for any rescale Etiny */ 7599 #if DEC_MAX_EMAX > 999999999 7600 #error GetInt may need updating [for Emax] 7601 #endif 7602 #if DEC_MIN_EMIN < -999999999 7603 #error GetInt may need updating [for Emin] 7604 #endif 7605 if (ISZERO(dn)) return 0; /* zeros are OK, with any exponent */ 7606 7607 up=dn->lsu; /* ready for lsu */ 7608 theInt=0; /* ready to accumulate */ 7609 if (dn->exponent>=0) { /* relatively easy */ 7610 /* no fractional part [usual]; allow for positive exponent */ 7611 got=dn->exponent; 7612 } 7613 else { /* -ve exponent; some fractional part to check and discard */ 7614 Int count=-dn->exponent; /* digits to discard */ 7615 /* spin up whole units until reach the Unit with the unit digit */ 7616 for (; count>=DECDPUN; up++) { 7617 if (*up!=0) return BADINT; /* non-zero Unit to discard */ 7618 count-=DECDPUN; 7619 } 7620 if (count==0) got=0; /* [a multiple of DECDPUN] */ 7621 else { /* [not multiple of DECDPUN] */ 7622 Int rem; /* work */ 7623 /* slice off fraction digits and check for non-zero */ 7624 #if DECDPUN<=4 7625 theInt=QUOT10(*up, count); 7626 rem=*up-theInt*powers[count]; 7627 #else 7628 rem=*up%powers[count]; /* slice off discards */ 7629 theInt=*up/powers[count]; 7630 #endif 7631 if (rem!=0) return BADINT; /* non-zero fraction */ 7632 /* it looks good */ 7633 got=DECDPUN-count; /* number of digits so far */ 7634 up++; /* ready for next */ 7635 } 7636 } 7637 /* now it's known there's no fractional part */ 7638 7639 /* tricky code now, to accumulate up to 9.3 digits */ 7640 if (got==0) {theInt=*up; got+=DECDPUN; up++;} /* ensure lsu is there */ 7641 7642 if (ilength<11) { 7643 Int save=theInt; 7644 /* collect any remaining unit(s) */ 7645 for (; got<ilength; up++) { 7646 theInt+=*up*powers[got]; 7647 got+=DECDPUN; 7648 } 7649 if (ilength==10) { /* need to check for wrap */ 7650 if (theInt/(Int)powers[got-DECDPUN]!=(Int)*(up-1)) ilength=11; 7651 /* [that test also disallows the BADINT result case] */ 7652 else if (neg && theInt>1999999997) ilength=11; 7653 else if (!neg && theInt>999999999) ilength=11; 7654 if (ilength==11) theInt=save; /* restore correct low bit */ 7655 } 7656 } 7657 7658 if (ilength>10) { /* too big */ 7659 if (theInt&1) return BIGODD; /* bottom bit 1 */ 7660 return BIGEVEN; /* bottom bit 0 */ 7661 } 7662 7663 if (neg) theInt=-theInt; /* apply sign */ 7664 return theInt; 7665 } /* decGetInt */ 7666 7667 /* ------------------------------------------------------------------ */ 7668 /* decDecap -- decapitate the coefficient of a number */ 7669 /* */ 7670 /* dn is the number to be decapitated */ 7671 /* drop is the number of digits to be removed from the left of dn; */ 7672 /* this must be <= dn->digits (if equal, the coefficient is */ 7673 /* set to 0) */ 7674 /* */ 7675 /* Returns dn; dn->digits will be <= the initial digits less drop */ 7676 /* (after removing drop digits there may be leading zero digits */ 7677 /* which will also be removed). Only dn->lsu and dn->digits change. */ 7678 /* ------------------------------------------------------------------ */ 7679 static decNumber *decDecap(decNumber *dn, Int drop) { 7680 Unit *msu; /* -> target cut point */ 7681 Int cut; /* work */ 7682 if (drop>=dn->digits) { /* losing the whole thing */ 7683 #if DECCHECK 7684 if (drop>dn->digits) 7685 printf("decDecap called with drop>digits [%ld>%ld]\n", 7686 (LI)drop, (LI)dn->digits); 7687 #endif 7688 dn->lsu[0]=0; 7689 dn->digits=1; 7690 return dn; 7691 } 7692 msu=dn->lsu+D2U(dn->digits-drop)-1; /* -> likely msu */ 7693 cut=MSUDIGITS(dn->digits-drop); /* digits to be in use in msu */ 7694 if (cut!=DECDPUN) *msu%=powers[cut]; /* clear left digits */ 7695 /* that may have left leading zero digits, so do a proper count... */ 7696 dn->digits=decGetDigits(dn->lsu, msu-dn->lsu+1); 7697 return dn; 7698 } /* decDecap */ 7699 7700 /* ------------------------------------------------------------------ */ 7701 /* decBiStr -- compare string with pairwise options */ 7702 /* */ 7703 /* targ is the string to compare */ 7704 /* str1 is one of the strings to compare against (length may be 0) */ 7705 /* str2 is the other; it must be the same length as str1 */ 7706 /* */ 7707 /* returns 1 if strings compare equal, (that is, it is the same */ 7708 /* length as str1 and str2, and each character of targ is in either */ 7709 /* str1 or str2 in the corresponding position), or 0 otherwise */ 7710 /* */ 7711 /* This is used for generic caseless compare, including the awkward */ 7712 /* case of the Turkish dotted and dotless Is. Use as (for example): */ 7713 /* if (decBiStr(test, "mike", "MIKE")) ... */ 7714 /* ------------------------------------------------------------------ */ 7715 static Flag decBiStr(const char *targ, const char *str1, const char *str2) { 7716 for (;;targ++, str1++, str2++) { 7717 if (*targ!=*str1 && *targ!=*str2) return 0; 7718 /* *targ has a match in one (or both, if terminator) */ 7719 if (*targ=='\0') break; 7720 } /* forever */ 7721 return 1; 7722 } /* decBiStr */ 7723 7724 /* ------------------------------------------------------------------ */ 7725 /* decNaNs -- handle NaN operand or operands */ 7726 /* */ 7727 /* res is the result number */ 7728 /* lhs is the first operand */ 7729 /* rhs is the second operand, or NULL if none */ 7730 /* context is used to limit payload length */ 7731 /* status contains the current status */ 7732 /* returns res in case convenient */ 7733 /* */ 7734 /* Called when one or both operands is a NaN, and propagates the */ 7735 /* appropriate result to res. When an sNaN is found, it is changed */ 7736 /* to a qNaN and Invalid operation is set. */ 7737 /* ------------------------------------------------------------------ */ 7738 static decNumber * decNaNs(decNumber *res, const decNumber *lhs, 7739 const decNumber *rhs, decContext *set, 7740 uInt *status) { 7741 /* This decision tree ends up with LHS being the source pointer, */ 7742 /* and status updated if need be */ 7743 if (lhs->bits & DECSNAN) 7744 *status|=DEC_Invalid_operation | DEC_sNaN; 7745 else if (rhs==NULL); 7746 else if (rhs->bits & DECSNAN) { 7747 lhs=rhs; 7748 *status|=DEC_Invalid_operation | DEC_sNaN; 7749 } 7750 else if (lhs->bits & DECNAN); 7751 else lhs=rhs; 7752 7753 /* propagate the payload */ 7754 if (lhs->digits<=set->digits) decNumberCopy(res, lhs); /* easy */ 7755 else { /* too long */ 7756 const Unit *ul; 7757 Unit *ur, *uresp1; 7758 /* copy safe number of units, then decapitate */ 7759 res->bits=lhs->bits; /* need sign etc. */ 7760 uresp1=res->lsu+D2U(set->digits); 7761 for (ur=res->lsu, ul=lhs->lsu; ur<uresp1; ur++, ul++) *ur=*ul; 7762 res->digits=D2U(set->digits)*DECDPUN; 7763 /* maybe still too long */ 7764 if (res->digits>set->digits) decDecap(res, res->digits-set->digits); 7765 } 7766 7767 res->bits&=~DECSNAN; /* convert any sNaN to NaN, while */ 7768 res->bits|=DECNAN; /* .. preserving sign */ 7769 res->exponent=0; /* clean exponent */ 7770 /* [coefficient was copied/decapitated] */ 7771 return res; 7772 } /* decNaNs */ 7773 7774 /* ------------------------------------------------------------------ */ 7775 /* decStatus -- apply non-zero status */ 7776 /* */ 7777 /* dn is the number to set if error */ 7778 /* status contains the current status (not yet in context) */ 7779 /* set is the context */ 7780 /* */ 7781 /* If the status is an error status, the number is set to a NaN, */ 7782 /* unless the error was an overflow, divide-by-zero, or underflow, */ 7783 /* in which case the number will have already been set. */ 7784 /* */ 7785 /* The context status is then updated with the new status. Note that */ 7786 /* this may raise a signal, so control may never return from this */ 7787 /* routine (hence resources must be recovered before it is called). */ 7788 /* ------------------------------------------------------------------ */ 7789 static void decStatus(decNumber *dn, uInt status, decContext *set) { 7790 if (status & DEC_NaNs) { /* error status -> NaN */ 7791 /* if cause was an sNaN, clear and propagate [NaN is already set up] */ 7792 if (status & DEC_sNaN) status&=~DEC_sNaN; 7793 else { 7794 decNumberZero(dn); /* other error: clean throughout */ 7795 dn->bits=DECNAN; /* and make a quiet NaN */ 7796 } 7797 } 7798 decContextSetStatus(set, status); /* [may not return] */ 7799 return; 7800 } /* decStatus */ 7801 7802 /* ------------------------------------------------------------------ */ 7803 /* decGetDigits -- count digits in a Units array */ 7804 /* */ 7805 /* uar is the Unit array holding the number (this is often an */ 7806 /* accumulator of some sort) */ 7807 /* len is the length of the array in units [>=1] */ 7808 /* */ 7809 /* returns the number of (significant) digits in the array */ 7810 /* */ 7811 /* All leading zeros are excluded, except the last if the array has */ 7812 /* only zero Units. */ 7813 /* ------------------------------------------------------------------ */ 7814 /* This may be called twice during some operations. */ 7815 static Int decGetDigits(Unit *uar, Int len) { 7816 Unit *up=uar+(len-1); /* -> msu */ 7817 Int digits=(len-1)*DECDPUN+1; /* possible digits excluding msu */ 7818 #if DECDPUN>4 7819 uInt const *pow; /* work */ 7820 #endif 7821 /* (at least 1 in final msu) */ 7822 #if DECCHECK 7823 if (len<1) printf("decGetDigits called with len<1 [%ld]\n", (LI)len); 7824 #endif 7825 7826 for (; up>=uar; up--) { 7827 if (*up==0) { /* unit is all 0s */ 7828 if (digits==1) break; /* a zero has one digit */ 7829 digits-=DECDPUN; /* adjust for 0 unit */ 7830 continue;} 7831 /* found the first (most significant) non-zero Unit */ 7832 #if DECDPUN>1 /* not done yet */ 7833 if (*up<10) break; /* is 1-9 */ 7834 digits++; 7835 #if DECDPUN>2 /* not done yet */ 7836 if (*up<100) break; /* is 10-99 */ 7837 digits++; 7838 #if DECDPUN>3 /* not done yet */ 7839 if (*up<1000) break; /* is 100-999 */ 7840 digits++; 7841 #if DECDPUN>4 /* count the rest ... */ 7842 for (pow=&powers[4]; *up>=*pow; pow++) digits++; 7843 #endif 7844 #endif 7845 #endif 7846 #endif 7847 break; 7848 } /* up */ 7849 return digits; 7850 } /* decGetDigits */ 7851 7852 #if DECTRACE | DECCHECK 7853 /* ------------------------------------------------------------------ */ 7854 /* decNumberShow -- display a number [debug aid] */ 7855 /* dn is the number to show */ 7856 /* */ 7857 /* Shows: sign, exponent, coefficient (msu first), digits */ 7858 /* or: sign, special-value */ 7859 /* ------------------------------------------------------------------ */ 7860 /* this is public so other modules can use it */ 7861 void decNumberShow(const decNumber *dn) { 7862 const Unit *up; /* work */ 7863 uInt u, d; /* .. */ 7864 Int cut; /* .. */ 7865 char isign='+'; /* main sign */ 7866 if (dn==NULL) { 7867 printf("NULL\n"); 7868 return;} 7869 if (decNumberIsNegative(dn)) isign='-'; 7870 printf(" >> %c ", isign); 7871 if (dn->bits&DECSPECIAL) { /* Is a special value */ 7872 if (decNumberIsInfinite(dn)) printf("Infinity"); 7873 else { /* a NaN */ 7874 if (dn->bits&DECSNAN) printf("sNaN"); /* signalling NaN */ 7875 else printf("NaN"); 7876 } 7877 /* if coefficient and exponent are 0, no more to do */ 7878 if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) { 7879 printf("\n"); 7880 return;} 7881 /* drop through to report other information */ 7882 printf(" "); 7883 } 7884 7885 /* now carefully display the coefficient */ 7886 up=dn->lsu+D2U(dn->digits)-1; /* msu */ 7887 printf("%ld", (LI)*up); 7888 for (up=up-1; up>=dn->lsu; up--) { 7889 u=*up; 7890 printf(":"); 7891 for (cut=DECDPUN-1; cut>=0; cut--) { 7892 d=u/powers[cut]; 7893 u-=d*powers[cut]; 7894 printf("%ld", (LI)d); 7895 } /* cut */ 7896 } /* up */ 7897 if (dn->exponent!=0) { 7898 char esign='+'; 7899 if (dn->exponent<0) esign='-'; 7900 printf(" E%c%ld", esign, (LI)abs(dn->exponent)); 7901 } 7902 printf(" [%ld]\n", (LI)dn->digits); 7903 } /* decNumberShow */ 7904 #endif 7905 7906 #if DECTRACE || DECCHECK 7907 /* ------------------------------------------------------------------ */ 7908 /* decDumpAr -- display a unit array [debug/check aid] */ 7909 /* name is a single-character tag name */ 7910 /* ar is the array to display */ 7911 /* len is the length of the array in Units */ 7912 /* ------------------------------------------------------------------ */ 7913 static void decDumpAr(char name, const Unit *ar, Int len) { 7914 Int i; 7915 const char *spec; 7916 #if DECDPUN==9 7917 spec="%09d "; 7918 #elif DECDPUN==8 7919 spec="%08d "; 7920 #elif DECDPUN==7 7921 spec="%07d "; 7922 #elif DECDPUN==6 7923 spec="%06d "; 7924 #elif DECDPUN==5 7925 spec="%05d "; 7926 #elif DECDPUN==4 7927 spec="%04d "; 7928 #elif DECDPUN==3 7929 spec="%03d "; 7930 #elif DECDPUN==2 7931 spec="%02d "; 7932 #else 7933 spec="%d "; 7934 #endif 7935 printf(" :%c: ", name); 7936 for (i=len-1; i>=0; i--) { 7937 if (i==len-1) printf("%ld ", (LI)ar[i]); 7938 else printf(spec, ar[i]); 7939 } 7940 printf("\n"); 7941 return;} 7942 #endif 7943 7944 #if DECCHECK 7945 /* ------------------------------------------------------------------ */ 7946 /* decCheckOperands -- check operand(s) to a routine */ 7947 /* res is the result structure (not checked; it will be set to */ 7948 /* quiet NaN if error found (and it is not NULL)) */ 7949 /* lhs is the first operand (may be DECUNRESU) */ 7950 /* rhs is the second (may be DECUNUSED) */ 7951 /* set is the context (may be DECUNCONT) */ 7952 /* returns 0 if both operands, and the context are clean, or 1 */ 7953 /* otherwise (in which case the context will show an error, */ 7954 /* unless NULL). Note that res is not cleaned; caller should */ 7955 /* handle this so res=NULL case is safe. */ 7956 /* The caller is expected to abandon immediately if 1 is returned. */ 7957 /* ------------------------------------------------------------------ */ 7958 static Flag decCheckOperands(decNumber *res, const decNumber *lhs, 7959 const decNumber *rhs, decContext *set) { 7960 Flag bad=0; 7961 if (set==NULL) { /* oops; hopeless */ 7962 #if DECTRACE || DECVERB 7963 printf("Reference to context is NULL.\n"); 7964 #endif 7965 bad=1; 7966 return 1;} 7967 else if (set!=DECUNCONT 7968 && (set->digits<1 || set->round>=DEC_ROUND_MAX)) { 7969 bad=1; 7970 #if DECTRACE || DECVERB 7971 printf("Bad context [digits=%ld round=%ld].\n", 7972 (LI)set->digits, (LI)set->round); 7973 #endif 7974 } 7975 else { 7976 if (res==NULL) { 7977 bad=1; 7978 #if DECTRACE 7979 /* this one not DECVERB as standard tests include NULL */ 7980 printf("Reference to result is NULL.\n"); 7981 #endif 7982 } 7983 if (!bad && lhs!=DECUNUSED) bad=(decCheckNumber(lhs)); 7984 if (!bad && rhs!=DECUNUSED) bad=(decCheckNumber(rhs)); 7985 } 7986 if (bad) { 7987 if (set!=DECUNCONT) decContextSetStatus(set, DEC_Invalid_operation); 7988 if (res!=DECUNRESU && res!=NULL) { 7989 decNumberZero(res); 7990 res->bits=DECNAN; /* qNaN */ 7991 } 7992 } 7993 return bad; 7994 } /* decCheckOperands */ 7995 7996 /* ------------------------------------------------------------------ */ 7997 /* decCheckNumber -- check a number */ 7998 /* dn is the number to check */ 7999 /* returns 0 if the number is clean, or 1 otherwise */ 8000 /* */ 8001 /* The number is considered valid if it could be a result from some */ 8002 /* operation in some valid context. */ 8003 /* ------------------------------------------------------------------ */ 8004 static Flag decCheckNumber(const decNumber *dn) { 8005 const Unit *up; /* work */ 8006 uInt maxuint; /* .. */ 8007 Int ae, d, digits; /* .. */ 8008 Int emin, emax; /* .. */ 8009 8010 if (dn==NULL) { /* hopeless */ 8011 #if DECTRACE 8012 /* this one not DECVERB as standard tests include NULL */ 8013 printf("Reference to decNumber is NULL.\n"); 8014 #endif 8015 return 1;} 8016 8017 /* check special values */ 8018 if (dn->bits & DECSPECIAL) { 8019 if (dn->exponent!=0) { 8020 #if DECTRACE || DECVERB 8021 printf("Exponent %ld (not 0) for a special value [%02x].\n", 8022 (LI)dn->exponent, dn->bits); 8023 #endif 8024 return 1;} 8025 8026 /* 2003.09.08: NaNs may now have coefficients, so next tests Inf only */ 8027 if (decNumberIsInfinite(dn)) { 8028 if (dn->digits!=1) { 8029 #if DECTRACE || DECVERB 8030 printf("Digits %ld (not 1) for an infinity.\n", (LI)dn->digits); 8031 #endif 8032 return 1;} 8033 if (*dn->lsu!=0) { 8034 #if DECTRACE || DECVERB 8035 printf("LSU %ld (not 0) for an infinity.\n", (LI)*dn->lsu); 8036 #endif 8037 decDumpAr('I', dn->lsu, D2U(dn->digits)); 8038 return 1;} 8039 } /* Inf */ 8040 /* 2002.12.26: negative NaNs can now appear through proposed IEEE */ 8041 /* concrete formats (decimal64, etc.). */ 8042 return 0; 8043 } 8044 8045 /* check the coefficient */ 8046 if (dn->digits<1 || dn->digits>DECNUMMAXP) { 8047 #if DECTRACE || DECVERB 8048 printf("Digits %ld in number.\n", (LI)dn->digits); 8049 #endif 8050 return 1;} 8051 8052 d=dn->digits; 8053 8054 for (up=dn->lsu; d>0; up++) { 8055 if (d>DECDPUN) maxuint=DECDPUNMAX; 8056 else { /* reached the msu */ 8057 maxuint=powers[d]-1; 8058 if (dn->digits>1 && *up<powers[d-1]) { 8059 #if DECTRACE || DECVERB 8060 printf("Leading 0 in number.\n"); 8061 decNumberShow(dn); 8062 #endif 8063 return 1;} 8064 } 8065 if (*up>maxuint) { 8066 #if DECTRACE || DECVERB 8067 printf("Bad Unit [%08lx] in %ld-digit number at offset %ld [maxuint %ld].\n", 8068 (LI)*up, (LI)dn->digits, (LI)(up-dn->lsu), (LI)maxuint); 8069 #endif 8070 return 1;} 8071 d-=DECDPUN; 8072 } 8073 8074 /* check the exponent. Note that input operands can have exponents */ 8075 /* which are out of the set->emin/set->emax and set->digits range */ 8076 /* (just as they can have more digits than set->digits). */ 8077 ae=dn->exponent+dn->digits-1; /* adjusted exponent */ 8078 emax=DECNUMMAXE; 8079 emin=DECNUMMINE; 8080 digits=DECNUMMAXP; 8081 if (ae<emin-(digits-1)) { 8082 #if DECTRACE || DECVERB 8083 printf("Adjusted exponent underflow [%ld].\n", (LI)ae); 8084 decNumberShow(dn); 8085 #endif 8086 return 1;} 8087 if (ae>+emax) { 8088 #if DECTRACE || DECVERB 8089 printf("Adjusted exponent overflow [%ld].\n", (LI)ae); 8090 decNumberShow(dn); 8091 #endif 8092 return 1;} 8093 8094 return 0; /* it's OK */ 8095 } /* decCheckNumber */ 8096 8097 /* ------------------------------------------------------------------ */ 8098 /* decCheckInexact -- check a normal finite inexact result has digits */ 8099 /* dn is the number to check */ 8100 /* set is the context (for status and precision) */ 8101 /* sets Invalid operation, etc., if some digits are missing */ 8102 /* [this check is not made for DECSUBSET compilation or when */ 8103 /* subnormal is not set] */ 8104 /* ------------------------------------------------------------------ */ 8105 static void decCheckInexact(const decNumber *dn, decContext *set) { 8106 #if !DECSUBSET && DECEXTFLAG 8107 if ((set->status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact 8108 && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) { 8109 #if DECTRACE || DECVERB 8110 printf("Insufficient digits [%ld] on normal Inexact result.\n", 8111 (LI)dn->digits); 8112 decNumberShow(dn); 8113 #endif 8114 decContextSetStatus(set, DEC_Invalid_operation); 8115 } 8116 #else 8117 /* next is a noop for quiet compiler */ 8118 if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation; 8119 #endif 8120 return; 8121 } /* decCheckInexact */ 8122 #endif 8123 8124 #if DECALLOC 8125 #undef malloc 8126 #undef free 8127 /* ------------------------------------------------------------------ */ 8128 /* decMalloc -- accountable allocation routine */ 8129 /* n is the number of bytes to allocate */ 8130 /* */ 8131 /* Semantics is the same as the stdlib malloc routine, but bytes */ 8132 /* allocated are accounted for globally, and corruption fences are */ 8133 /* added before and after the 'actual' storage. */ 8134 /* ------------------------------------------------------------------ */ 8135 /* This routine allocates storage with an extra twelve bytes; 8 are */ 8136 /* at the start and hold: */ 8137 /* 0-3 the original length requested */ 8138 /* 4-7 buffer corruption detection fence (DECFENCE, x4) */ 8139 /* The 4 bytes at the end also hold a corruption fence (DECFENCE, x4) */ 8140 /* ------------------------------------------------------------------ */ 8141 static void *decMalloc(size_t n) { 8142 uInt size=n+12; /* true size */ 8143 void *alloc; /* -> allocated storage */ 8144 uInt *j; /* work */ 8145 uByte *b, *b0; /* .. */ 8146 8147 alloc=malloc(size); /* -> allocated storage */ 8148 if (alloc==NULL) return NULL; /* out of strorage */ 8149 b0=(uByte *)alloc; /* as bytes */ 8150 decAllocBytes+=n; /* account for storage */ 8151 j=(uInt *)alloc; /* -> first four bytes */ 8152 *j=n; /* save n */ 8153 /* printf(" alloc ++ dAB: %ld (%d)\n", decAllocBytes, n); */ 8154 for (b=b0+4; b<b0+8; b++) *b=DECFENCE; 8155 for (b=b0+n+8; b<b0+n+12; b++) *b=DECFENCE; 8156 return b0+8; /* -> play area */ 8157 } /* decMalloc */ 8158 8159 /* ------------------------------------------------------------------ */ 8160 /* decFree -- accountable free routine */ 8161 /* alloc is the storage to free */ 8162 /* */ 8163 /* Semantics is the same as the stdlib malloc routine, except that */ 8164 /* the global storage accounting is updated and the fences are */ 8165 /* checked to ensure that no routine has written 'out of bounds'. */ 8166 /* ------------------------------------------------------------------ */ 8167 /* This routine first checks that the fences have not been corrupted. */ 8168 /* It then frees the storage using the 'truw' storage address (that */ 8169 /* is, offset by 8). */ 8170 /* ------------------------------------------------------------------ */ 8171 static void decFree(void *alloc) { 8172 uInt *j, n; /* pointer, original length */ 8173 uByte *b, *b0; /* work */ 8174 8175 if (alloc==NULL) return; /* allowed; it's a nop */ 8176 b0=(uByte *)alloc; /* as bytes */ 8177 b0-=8; /* -> true start of storage */ 8178 j=(uInt *)b0; /* -> first four bytes */ 8179 n=*j; /* lift */ 8180 for (b=b0+4; b<b0+8; b++) if (*b!=DECFENCE) 8181 printf("=== Corrupt byte [%02x] at offset %d from %ld ===\n", *b, 8182 b-b0-8, (Int)b0); 8183 for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE) 8184 printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b, 8185 b-b0-8, (Int)b0, n); 8186 free(b0); /* drop the storage */ 8187 decAllocBytes-=n; /* account for storage */ 8188 /* printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n); */ 8189 } /* decFree */ 8190 #define malloc(a) decMalloc(a) 8191 #define free(a) decFree(a) 8192 #endif 8193