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 <stdlib.h> /* for malloc, free, etc. */ 170 #include <stdio.h> /* for printf [if needed] */ 171 #include <string.h> /* for strcpy */ 172 #include <ctype.h> /* for lower */ 173 #include "libdecnumber/dconfig.h" 174 #include "libdecnumber/decNumber.h" 175 #include "libdecnumber/decNumberLocal.h" 176 177 /* Constants */ 178 /* Public lookup table used by the D2U macro */ 179 const uByte d2utable[DECMAXD2U+1]=D2UTABLE; 180 181 #define DECVERB 1 /* set to 1 for verbose DECCHECK */ 182 #define powers DECPOWERS /* old internal name */ 183 184 /* Local constants */ 185 #define DIVIDE 0x80 /* Divide operators */ 186 #define REMAINDER 0x40 /* .. */ 187 #define DIVIDEINT 0x20 /* .. */ 188 #define REMNEAR 0x10 /* .. */ 189 #define COMPARE 0x01 /* Compare operators */ 190 #define COMPMAX 0x02 /* .. */ 191 #define COMPMIN 0x03 /* .. */ 192 #define COMPTOTAL 0x04 /* .. */ 193 #define COMPNAN 0x05 /* .. [NaN processing] */ 194 #define COMPSIG 0x06 /* .. [signaling COMPARE] */ 195 #define COMPMAXMAG 0x07 /* .. */ 196 #define COMPMINMAG 0x08 /* .. */ 197 198 #define DEC_sNaN 0x40000000 /* local status: sNaN signal */ 199 #define BADINT (Int)0x80000000 /* most-negative Int; error indicator */ 200 /* Next two indicate an integer >= 10**6, and its parity (bottom bit) */ 201 #define BIGEVEN (Int)0x80000002 202 #define BIGODD (Int)0x80000003 203 204 static Unit uarrone[1]={1}; /* Unit array of 1, used for incrementing */ 205 206 /* Granularity-dependent code */ 207 #if DECDPUN<=4 208 #define eInt Int /* extended integer */ 209 #define ueInt uInt /* unsigned extended integer */ 210 /* Constant multipliers for divide-by-power-of five using reciprocal */ 211 /* multiply, after removing powers of 2 by shifting, and final shift */ 212 /* of 17 [we only need up to **4] */ 213 static const uInt multies[]={131073, 26215, 5243, 1049, 210}; 214 /* QUOT10 -- macro to return the quotient of unit u divided by 10**n */ 215 #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) 216 #else 217 /* For DECDPUN>4 non-ANSI-89 64-bit types are needed. */ 218 #if !DECUSE64 219 #error decNumber.c: DECUSE64 must be 1 when DECDPUN>4 220 #endif 221 #define eInt Long /* extended integer */ 222 #define ueInt uLong /* unsigned extended integer */ 223 #endif 224 225 /* Local routines */ 226 static decNumber * decAddOp(decNumber *, const decNumber *, const decNumber *, 227 decContext *, uByte, uInt *); 228 static Flag decBiStr(const char *, const char *, const char *); 229 static uInt decCheckMath(const decNumber *, decContext *, uInt *); 230 static void decApplyRound(decNumber *, decContext *, Int, uInt *); 231 static Int decCompare(const decNumber *lhs, const decNumber *rhs, Flag); 232 static decNumber * decCompareOp(decNumber *, const decNumber *, 233 const decNumber *, decContext *, 234 Flag, uInt *); 235 static void decCopyFit(decNumber *, const decNumber *, decContext *, 236 Int *, uInt *); 237 static decNumber * decDecap(decNumber *, Int); 238 static decNumber * decDivideOp(decNumber *, const decNumber *, 239 const decNumber *, decContext *, Flag, uInt *); 240 static decNumber * decExpOp(decNumber *, const decNumber *, 241 decContext *, uInt *); 242 static void decFinalize(decNumber *, decContext *, Int *, uInt *); 243 static Int decGetDigits(Unit *, Int); 244 static Int decGetInt(const decNumber *); 245 static decNumber * decLnOp(decNumber *, const decNumber *, 246 decContext *, uInt *); 247 static decNumber * decMultiplyOp(decNumber *, const decNumber *, 248 const decNumber *, decContext *, 249 uInt *); 250 static decNumber * decNaNs(decNumber *, const decNumber *, 251 const decNumber *, decContext *, uInt *); 252 static decNumber * decQuantizeOp(decNumber *, const decNumber *, 253 const decNumber *, decContext *, Flag, 254 uInt *); 255 static void decReverse(Unit *, Unit *); 256 static void decSetCoeff(decNumber *, decContext *, const Unit *, 257 Int, Int *, uInt *); 258 static void decSetMaxValue(decNumber *, decContext *); 259 static void decSetOverflow(decNumber *, decContext *, uInt *); 260 static void decSetSubnormal(decNumber *, decContext *, Int *, uInt *); 261 static Int decShiftToLeast(Unit *, Int, Int); 262 static Int decShiftToMost(Unit *, Int, Int); 263 static void decStatus(decNumber *, uInt, decContext *); 264 static void decToString(const decNumber *, char[], Flag); 265 static decNumber * decTrim(decNumber *, decContext *, Flag, Int *); 266 static Int decUnitAddSub(const Unit *, Int, const Unit *, Int, Int, 267 Unit *, Int); 268 static Int decUnitCompare(const Unit *, Int, const Unit *, Int, Int); 269 270 #if !DECSUBSET 271 /* decFinish == decFinalize when no subset arithmetic needed */ 272 #define decFinish(a,b,c,d) decFinalize(a,b,c,d) 273 #else 274 static void decFinish(decNumber *, decContext *, Int *, uInt *); 275 static decNumber * decRoundOperand(const decNumber *, decContext *, uInt *); 276 #endif 277 278 /* Local macros */ 279 /* masked special-values bits */ 280 #define SPECIALARG (rhs->bits & DECSPECIAL) 281 #define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL) 282 283 /* Diagnostic macros, etc. */ 284 #if DECALLOC 285 /* Handle malloc/free accounting. If enabled, our accountable routines */ 286 /* are used; otherwise the code just goes straight to the system malloc */ 287 /* and free routines. */ 288 #define malloc(a) decMalloc(a) 289 #define free(a) decFree(a) 290 #define DECFENCE 0x5a /* corruption detector */ 291 /* 'Our' malloc and free: */ 292 static void *decMalloc(size_t); 293 static void decFree(void *); 294 uInt decAllocBytes=0; /* count of bytes allocated */ 295 /* Note that DECALLOC code only checks for storage buffer overflow. */ 296 /* To check for memory leaks, the decAllocBytes variable must be */ 297 /* checked to be 0 at appropriate times (e.g., after the test */ 298 /* harness completes a set of tests). This checking may be unreliable */ 299 /* if the testing is done in a multi-thread environment. */ 300 #endif 301 302 #if DECCHECK 303 /* Optional checking routines. Enabling these means that decNumber */ 304 /* and decContext operands to operator routines are checked for */ 305 /* correctness. This roughly doubles the execution time of the */ 306 /* fastest routines (and adds 600+ bytes), so should not normally be */ 307 /* used in 'production'. */ 308 /* decCheckInexact is used to check that inexact results have a full */ 309 /* complement of digits (where appropriate -- this is not the case */ 310 /* for Quantize, for example) */ 311 #define DECUNRESU ((decNumber *)(void *)0xffffffff) 312 #define DECUNUSED ((const decNumber *)(void *)0xffffffff) 313 #define DECUNCONT ((decContext *)(void *)(0xffffffff)) 314 static Flag decCheckOperands(decNumber *, const decNumber *, 315 const decNumber *, decContext *); 316 static Flag decCheckNumber(const decNumber *); 317 static void decCheckInexact(const decNumber *, decContext *); 318 #endif 319 320 #if DECTRACE || DECCHECK 321 /* Optional trace/debugging routines (may or may not be used) */ 322 void decNumberShow(const decNumber *); /* displays the components of a number */ 323 static void decDumpAr(char, const Unit *, Int); 324 #endif 325 326 /* ================================================================== */ 327 /* Conversions */ 328 /* ================================================================== */ 329 330 /* ------------------------------------------------------------------ */ 331 /* from-int32 -- conversion from Int or uInt */ 332 /* */ 333 /* dn is the decNumber to receive the integer */ 334 /* in or uin is the integer to be converted */ 335 /* returns dn */ 336 /* */ 337 /* No error is possible. */ 338 /* ------------------------------------------------------------------ */ 339 decNumber * decNumberFromInt32(decNumber *dn, Int in) { 340 uInt unsig; 341 if (in>=0) unsig=in; 342 else { /* negative (possibly BADINT) */ 343 if (in==BADINT) unsig=(uInt)1073741824*2; /* special case */ 344 else unsig=-in; /* invert */ 345 } 346 /* in is now positive */ 347 decNumberFromUInt32(dn, unsig); 348 if (in<0) dn->bits=DECNEG; /* sign needed */ 349 return dn; 350 } /* decNumberFromInt32 */ 351 352 decNumber * decNumberFromUInt32(decNumber *dn, uInt uin) { 353 Unit *up; /* work pointer */ 354 decNumberZero(dn); /* clean */ 355 if (uin==0) return dn; /* [or decGetDigits bad call] */ 356 for (up=dn->lsu; uin>0; up++) { 357 *up=(Unit)(uin%(DECDPUNMAX+1)); 358 uin=uin/(DECDPUNMAX+1); 359 } 360 dn->digits=decGetDigits(dn->lsu, up-dn->lsu); 361 return dn; 362 } /* decNumberFromUInt32 */ 363 364 /* ------------------------------------------------------------------ */ 365 /* to-int32 -- conversion to Int or uInt */ 366 /* */ 367 /* dn is the decNumber to convert */ 368 /* set is the context for reporting errors */ 369 /* returns the converted decNumber, or 0 if Invalid is set */ 370 /* */ 371 /* Invalid is set if the decNumber does not have exponent==0 or if */ 372 /* it is a NaN, Infinite, or out-of-range. */ 373 /* ------------------------------------------------------------------ */ 374 Int decNumberToInt32(const decNumber *dn, decContext *set) { 375 #if DECCHECK 376 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; 377 #endif 378 379 /* special or too many digits, or bad exponent */ 380 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; /* bad */ 381 else { /* is a finite integer with 10 or fewer digits */ 382 Int d; /* work */ 383 const Unit *up; /* .. */ 384 uInt hi=0, lo; /* .. */ 385 up=dn->lsu; /* -> lsu */ 386 lo=*up; /* get 1 to 9 digits */ 387 #if DECDPUN>1 /* split to higher */ 388 hi=lo/10; 389 lo=lo%10; 390 #endif 391 up++; 392 /* collect remaining Units, if any, into hi */ 393 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1]; 394 /* now low has the lsd, hi the remainder */ 395 if (hi>214748364 || (hi==214748364 && lo>7)) { /* out of range? */ 396 /* most-negative is a reprieve */ 397 if (dn->bits&DECNEG && hi==214748364 && lo==8) return 0x80000000; 398 /* bad -- drop through */ 399 } 400 else { /* in-range always */ 401 Int i=X10(hi)+lo; 402 if (dn->bits&DECNEG) return -i; 403 return i; 404 } 405 } /* integer */ 406 decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */ 407 return 0; 408 } /* decNumberToInt32 */ 409 410 uInt decNumberToUInt32(const decNumber *dn, decContext *set) { 411 #if DECCHECK 412 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; 413 #endif 414 /* special or too many digits, or bad exponent, or negative (<0) */ 415 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0 416 || (dn->bits&DECNEG && !ISZERO(dn))); /* bad */ 417 else { /* is a finite integer with 10 or fewer digits */ 418 Int d; /* work */ 419 const Unit *up; /* .. */ 420 uInt hi=0, lo; /* .. */ 421 up=dn->lsu; /* -> lsu */ 422 lo=*up; /* get 1 to 9 digits */ 423 #if DECDPUN>1 /* split to higher */ 424 hi=lo/10; 425 lo=lo%10; 426 #endif 427 up++; 428 /* collect remaining Units, if any, into hi */ 429 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1]; 430 431 /* now low has the lsd, hi the remainder */ 432 if (hi>429496729 || (hi==429496729 && lo>5)) ; /* no reprieve possible */ 433 else return X10(hi)+lo; 434 } /* integer */ 435 decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */ 436 return 0; 437 } /* decNumberToUInt32 */ 438 439 decNumber *decNumberFromInt64(decNumber *dn, int64_t in) 440 { 441 uint64_t unsig = in; 442 if (in < 0) { 443 unsig = -unsig; 444 } 445 446 decNumberFromUInt64(dn, unsig); 447 if (in < 0) { 448 dn->bits = DECNEG; /* sign needed */ 449 } 450 return dn; 451 } /* decNumberFromInt64 */ 452 453 decNumber *decNumberFromUInt64(decNumber *dn, uint64_t uin) 454 { 455 Unit *up; /* work pointer */ 456 decNumberZero(dn); /* clean */ 457 if (uin == 0) { 458 return dn; /* [or decGetDigits bad call] */ 459 } 460 for (up = dn->lsu; uin > 0; up++) { 461 *up = (Unit)(uin % (DECDPUNMAX + 1)); 462 uin = uin / (DECDPUNMAX + 1); 463 } 464 dn->digits = decGetDigits(dn->lsu, up-dn->lsu); 465 return dn; 466 } /* decNumberFromUInt64 */ 467 468 /* ------------------------------------------------------------------ */ 469 /* to-int64 -- conversion to int64 */ 470 /* */ 471 /* dn is the decNumber to convert. dn is assumed to have been */ 472 /* rounded to a floating point integer value. */ 473 /* set is the context for reporting errors */ 474 /* returns the converted decNumber, or 0 if Invalid is set */ 475 /* */ 476 /* Invalid is set if the decNumber is a NaN, Infinite or is out of */ 477 /* range for a signed 64 bit integer. */ 478 /* ------------------------------------------------------------------ */ 479 480 int64_t decNumberIntegralToInt64(const decNumber *dn, decContext *set) 481 { 482 if (decNumberIsSpecial(dn) || (dn->exponent < 0) || 483 (dn->digits + dn->exponent > 19)) { 484 goto Invalid; 485 } else { 486 int64_t d; /* work */ 487 const Unit *up; /* .. */ 488 uint64_t hi = 0; 489 up = dn->lsu; /* -> lsu */ 490 491 for (d = 1; d <= dn->digits; up++, d += DECDPUN) { 492 uint64_t prev = hi; 493 hi += *up * powers[d-1]; 494 if ((hi < prev) || (hi > INT64_MAX)) { 495 goto Invalid; 496 } 497 } 498 499 uint64_t prev = hi; 500 hi *= (uint64_t)powers[dn->exponent]; 501 if ((hi < prev) || (hi > INT64_MAX)) { 502 goto Invalid; 503 } 504 return (decNumberIsNegative(dn)) ? -((int64_t)hi) : (int64_t)hi; 505 } 506 507 Invalid: 508 decContextSetStatus(set, DEC_Invalid_operation); 509 return 0; 510 } /* decNumberIntegralToInt64 */ 511 512 513 /* ------------------------------------------------------------------ */ 514 /* to-scientific-string -- conversion to numeric string */ 515 /* to-engineering-string -- conversion to numeric string */ 516 /* */ 517 /* decNumberToString(dn, string); */ 518 /* decNumberToEngString(dn, string); */ 519 /* */ 520 /* dn is the decNumber to convert */ 521 /* string is the string where the result will be laid out */ 522 /* */ 523 /* string must be at least dn->digits+14 characters long */ 524 /* */ 525 /* No error is possible, and no status can be set. */ 526 /* ------------------------------------------------------------------ */ 527 char * decNumberToString(const decNumber *dn, char *string){ 528 decToString(dn, string, 0); 529 return string; 530 } /* DecNumberToString */ 531 532 char * decNumberToEngString(const decNumber *dn, char *string){ 533 decToString(dn, string, 1); 534 return string; 535 } /* DecNumberToEngString */ 536 537 /* ------------------------------------------------------------------ */ 538 /* to-number -- conversion from numeric string */ 539 /* */ 540 /* decNumberFromString -- convert string to decNumber */ 541 /* dn -- the number structure to fill */ 542 /* chars[] -- the string to convert ('\0' terminated) */ 543 /* set -- the context used for processing any error, */ 544 /* determining the maximum precision available */ 545 /* (set.digits), determining the maximum and minimum */ 546 /* exponent (set.emax and set.emin), determining if */ 547 /* extended values are allowed, and checking the */ 548 /* rounding mode if overflow occurs or rounding is */ 549 /* needed. */ 550 /* */ 551 /* The length of the coefficient and the size of the exponent are */ 552 /* checked by this routine, so the correct error (Underflow or */ 553 /* Overflow) can be reported or rounding applied, as necessary. */ 554 /* */ 555 /* If bad syntax is detected, the result will be a quiet NaN. */ 556 /* ------------------------------------------------------------------ */ 557 decNumber * decNumberFromString(decNumber *dn, const char chars[], 558 decContext *set) { 559 Int exponent=0; /* working exponent [assume 0] */ 560 uByte bits=0; /* working flags [assume +ve] */ 561 Unit *res; /* where result will be built */ 562 Unit resbuff[SD2U(DECBUFFER+9)];/* local buffer in case need temporary */ 563 /* [+9 allows for ln() constants] */ 564 Unit *allocres=NULL; /* -> allocated result, iff allocated */ 565 Int d=0; /* count of digits found in decimal part */ 566 const char *dotchar=NULL; /* where dot was found */ 567 const char *cfirst=chars; /* -> first character of decimal part */ 568 const char *last=NULL; /* -> last digit of decimal part */ 569 const char *c; /* work */ 570 Unit *up; /* .. */ 571 #if DECDPUN>1 572 Int cut, out; /* .. */ 573 #endif 574 Int residue; /* rounding residue */ 575 uInt status=0; /* error code */ 576 577 #if DECCHECK 578 if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set)) 579 return decNumberZero(dn); 580 #endif 581 582 do { /* status & malloc protection */ 583 for (c=chars;; c++) { /* -> input character */ 584 if (*c>='0' && *c<='9') { /* test for Arabic digit */ 585 last=c; 586 d++; /* count of real digits */ 587 continue; /* still in decimal part */ 588 } 589 if (*c=='.' && dotchar==NULL) { /* first '.' */ 590 dotchar=c; /* record offset into decimal part */ 591 if (c==cfirst) cfirst++; /* first digit must follow */ 592 continue;} 593 if (c==chars) { /* first in string... */ 594 if (*c=='-') { /* valid - sign */ 595 cfirst++; 596 bits=DECNEG; 597 continue;} 598 if (*c=='+') { /* valid + sign */ 599 cfirst++; 600 continue;} 601 } 602 /* *c is not a digit, or a valid +, -, or '.' */ 603 break; 604 } /* c */ 605 606 if (last==NULL) { /* no digits yet */ 607 status=DEC_Conversion_syntax;/* assume the worst */ 608 if (*c=='\0') break; /* and no more to come... */ 609 #if DECSUBSET 610 /* if subset then infinities and NaNs are not allowed */ 611 if (!set->extended) break; /* hopeless */ 612 #endif 613 /* Infinities and NaNs are possible, here */ 614 if (dotchar!=NULL) break; /* .. unless had a dot */ 615 decNumberZero(dn); /* be optimistic */ 616 if (decBiStr(c, "infinity", "INFINITY") 617 || decBiStr(c, "inf", "INF")) { 618 dn->bits=bits | DECINF; 619 status=0; /* is OK */ 620 break; /* all done */ 621 } 622 /* a NaN expected */ 623 /* 2003.09.10 NaNs are now permitted to have a sign */ 624 dn->bits=bits | DECNAN; /* assume simple NaN */ 625 if (*c=='s' || *c=='S') { /* looks like an sNaN */ 626 c++; 627 dn->bits=bits | DECSNAN; 628 } 629 if (*c!='n' && *c!='N') break; /* check caseless "NaN" */ 630 c++; 631 if (*c!='a' && *c!='A') break; /* .. */ 632 c++; 633 if (*c!='n' && *c!='N') break; /* .. */ 634 c++; 635 /* now either nothing, or nnnn payload, expected */ 636 /* -> start of integer and skip leading 0s [including plain 0] */ 637 for (cfirst=c; *cfirst=='0';) cfirst++; 638 if (*cfirst=='\0') { /* "NaN" or "sNaN", maybe with all 0s */ 639 status=0; /* it's good */ 640 break; /* .. */ 641 } 642 /* something other than 0s; setup last and d as usual [no dots] */ 643 for (c=cfirst;; c++, d++) { 644 if (*c<'0' || *c>'9') break; /* test for Arabic digit */ 645 last=c; 646 } 647 if (*c!='\0') break; /* not all digits */ 648 if (d>set->digits-1) { 649 /* [NB: payload in a decNumber can be full length unless */ 650 /* clamped, in which case can only be digits-1] */ 651 if (set->clamp) break; 652 if (d>set->digits) break; 653 } /* too many digits? */ 654 /* good; drop through to convert the integer to coefficient */ 655 status=0; /* syntax is OK */ 656 bits=dn->bits; /* for copy-back */ 657 } /* last==NULL */ 658 659 else if (*c!='\0') { /* more to process... */ 660 /* had some digits; exponent is only valid sequence now */ 661 Flag nege; /* 1=negative exponent */ 662 const char *firstexp; /* -> first significant exponent digit */ 663 status=DEC_Conversion_syntax;/* assume the worst */ 664 if (*c!='e' && *c!='E') break; 665 /* Found 'e' or 'E' -- now process explicit exponent */ 666 /* 1998.07.11: sign no longer required */ 667 nege=0; 668 c++; /* to (possible) sign */ 669 if (*c=='-') {nege=1; c++;} 670 else if (*c=='+') c++; 671 if (*c=='\0') break; 672 673 for (; *c=='0' && *(c+1)!='\0';) c++; /* strip insignificant zeros */ 674 firstexp=c; /* save exponent digit place */ 675 for (; ;c++) { 676 if (*c<'0' || *c>'9') break; /* not a digit */ 677 exponent=X10(exponent)+(Int)*c-(Int)'0'; 678 } /* c */ 679 /* if not now on a '\0', *c must not be a digit */ 680 if (*c!='\0') break; 681 682 /* (this next test must be after the syntax checks) */ 683 /* if it was too long the exponent may have wrapped, so check */ 684 /* carefully and set it to a certain overflow if wrap possible */ 685 if (c>=firstexp+9+1) { 686 if (c>firstexp+9+1 || *firstexp>'1') exponent=DECNUMMAXE*2; 687 /* [up to 1999999999 is OK, for example 1E-1000000998] */ 688 } 689 if (nege) exponent=-exponent; /* was negative */ 690 status=0; /* is OK */ 691 } /* stuff after digits */ 692 693 /* Here when whole string has been inspected; syntax is good */ 694 /* cfirst->first digit (never dot), last->last digit (ditto) */ 695 696 /* strip leading zeros/dot [leave final 0 if all 0's] */ 697 if (*cfirst=='0') { /* [cfirst has stepped over .] */ 698 for (c=cfirst; c<last; c++, cfirst++) { 699 if (*c=='.') continue; /* ignore dots */ 700 if (*c!='0') break; /* non-zero found */ 701 d--; /* 0 stripped */ 702 } /* c */ 703 #if DECSUBSET 704 /* make a rapid exit for easy zeros if !extended */ 705 if (*cfirst=='0' && !set->extended) { 706 decNumberZero(dn); /* clean result */ 707 break; /* [could be return] */ 708 } 709 #endif 710 } /* at least one leading 0 */ 711 712 /* Handle decimal point... */ 713 if (dotchar!=NULL && dotchar<last) /* non-trailing '.' found? */ 714 exponent-=(last-dotchar); /* adjust exponent */ 715 /* [we can now ignore the .] */ 716 717 /* OK, the digits string is good. Assemble in the decNumber, or in */ 718 /* a temporary units array if rounding is needed */ 719 if (d<=set->digits) res=dn->lsu; /* fits into supplied decNumber */ 720 else { /* rounding needed */ 721 Int needbytes=D2U(d)*sizeof(Unit);/* bytes needed */ 722 res=resbuff; /* assume use local buffer */ 723 if (needbytes>(Int)sizeof(resbuff)) { /* too big for local */ 724 allocres=(Unit *)malloc(needbytes); 725 if (allocres==NULL) {status|=DEC_Insufficient_storage; break;} 726 res=allocres; 727 } 728 } 729 /* res now -> number lsu, buffer, or allocated storage for Unit array */ 730 731 /* Place the coefficient into the selected Unit array */ 732 /* [this is often 70% of the cost of this function when DECDPUN>1] */ 733 #if DECDPUN>1 734 out=0; /* accumulator */ 735 up=res+D2U(d)-1; /* -> msu */ 736 cut=d-(up-res)*DECDPUN; /* digits in top unit */ 737 for (c=cfirst;; c++) { /* along the digits */ 738 if (*c=='.') continue; /* ignore '.' [don't decrement cut] */ 739 out=X10(out)+(Int)*c-(Int)'0'; 740 if (c==last) break; /* done [never get to trailing '.'] */ 741 cut--; 742 if (cut>0) continue; /* more for this unit */ 743 *up=(Unit)out; /* write unit */ 744 up--; /* prepare for unit below.. */ 745 cut=DECDPUN; /* .. */ 746 out=0; /* .. */ 747 } /* c */ 748 *up=(Unit)out; /* write lsu */ 749 750 #else 751 /* DECDPUN==1 */ 752 up=res; /* -> lsu */ 753 for (c=last; c>=cfirst; c--) { /* over each character, from least */ 754 if (*c=='.') continue; /* ignore . [don't step up] */ 755 *up=(Unit)((Int)*c-(Int)'0'); 756 up++; 757 } /* c */ 758 #endif 759 760 dn->bits=bits; 761 dn->exponent=exponent; 762 dn->digits=d; 763 764 /* if not in number (too long) shorten into the number */ 765 if (d>set->digits) { 766 residue=0; 767 decSetCoeff(dn, set, res, d, &residue, &status); 768 /* always check for overflow or subnormal and round as needed */ 769 decFinalize(dn, set, &residue, &status); 770 } 771 else { /* no rounding, but may still have overflow or subnormal */ 772 /* [these tests are just for performance; finalize repeats them] */ 773 if ((dn->exponent-1<set->emin-dn->digits) 774 || (dn->exponent-1>set->emax-set->digits)) { 775 residue=0; 776 decFinalize(dn, set, &residue, &status); 777 } 778 } 779 /* decNumberShow(dn); */ 780 } while(0); /* [for break] */ 781 782 if (allocres!=NULL) free(allocres); /* drop any storage used */ 783 if (status!=0) decStatus(dn, status, set); 784 return dn; 785 } /* decNumberFromString */ 786 787 /* ================================================================== */ 788 /* Operators */ 789 /* ================================================================== */ 790 791 /* ------------------------------------------------------------------ */ 792 /* decNumberAbs -- absolute value operator */ 793 /* */ 794 /* This computes C = abs(A) */ 795 /* */ 796 /* res is C, the result. C may be A */ 797 /* rhs is A */ 798 /* set is the context */ 799 /* */ 800 /* See also decNumberCopyAbs for a quiet bitwise version of this. */ 801 /* C must have space for set->digits digits. */ 802 /* ------------------------------------------------------------------ */ 803 /* This has the same effect as decNumberPlus unless A is negative, */ 804 /* in which case it has the same effect as decNumberMinus. */ 805 /* ------------------------------------------------------------------ */ 806 decNumber * decNumberAbs(decNumber *res, const decNumber *rhs, 807 decContext *set) { 808 decNumber dzero; /* for 0 */ 809 uInt status=0; /* accumulator */ 810 811 #if DECCHECK 812 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 813 #endif 814 815 decNumberZero(&dzero); /* set 0 */ 816 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */ 817 decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status); 818 if (status!=0) decStatus(res, status, set); 819 #if DECCHECK 820 decCheckInexact(res, set); 821 #endif 822 return res; 823 } /* decNumberAbs */ 824 825 /* ------------------------------------------------------------------ */ 826 /* decNumberAdd -- add two Numbers */ 827 /* */ 828 /* This computes C = A + B */ 829 /* */ 830 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */ 831 /* lhs is A */ 832 /* rhs is B */ 833 /* set is the context */ 834 /* */ 835 /* C must have space for set->digits digits. */ 836 /* ------------------------------------------------------------------ */ 837 /* This just calls the routine shared with Subtract */ 838 decNumber * decNumberAdd(decNumber *res, const decNumber *lhs, 839 const decNumber *rhs, decContext *set) { 840 uInt status=0; /* accumulator */ 841 decAddOp(res, lhs, rhs, set, 0, &status); 842 if (status!=0) decStatus(res, status, set); 843 #if DECCHECK 844 decCheckInexact(res, set); 845 #endif 846 return res; 847 } /* decNumberAdd */ 848 849 /* ------------------------------------------------------------------ */ 850 /* decNumberAnd -- AND two Numbers, digitwise */ 851 /* */ 852 /* This computes C = A & B */ 853 /* */ 854 /* res is C, the result. C may be A and/or B (e.g., X=X&X) */ 855 /* lhs is A */ 856 /* rhs is B */ 857 /* set is the context (used for result length and error report) */ 858 /* */ 859 /* C must have space for set->digits digits. */ 860 /* */ 861 /* Logical function restrictions apply (see above); a NaN is */ 862 /* returned with Invalid_operation if a restriction is violated. */ 863 /* ------------------------------------------------------------------ */ 864 decNumber * decNumberAnd(decNumber *res, const decNumber *lhs, 865 const decNumber *rhs, decContext *set) { 866 const Unit *ua, *ub; /* -> operands */ 867 const Unit *msua, *msub; /* -> operand msus */ 868 Unit *uc, *msuc; /* -> result and its msu */ 869 Int msudigs; /* digits in res msu */ 870 #if DECCHECK 871 if (decCheckOperands(res, lhs, rhs, set)) return res; 872 #endif 873 874 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs) 875 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { 876 decStatus(res, DEC_Invalid_operation, set); 877 return res; 878 } 879 880 /* operands are valid */ 881 ua=lhs->lsu; /* bottom-up */ 882 ub=rhs->lsu; /* .. */ 883 uc=res->lsu; /* .. */ 884 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */ 885 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ 886 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ 887 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ 888 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */ 889 Unit a, b; /* extract units */ 890 if (ua>msua) a=0; 891 else a=*ua; 892 if (ub>msub) b=0; 893 else b=*ub; 894 *uc=0; /* can now write back */ 895 if (a|b) { /* maybe 1 bits to examine */ 896 Int i, j; 897 *uc=0; /* can now write back */ 898 /* This loop could be unrolled and/or use BIN2BCD tables */ 899 for (i=0; i<DECDPUN; i++) { 900 if (a&b&1) *uc=*uc+(Unit)powers[i]; /* effect AND */ 901 j=a%10; 902 a=a/10; 903 j|=b%10; 904 b=b/10; 905 if (j>1) { 906 decStatus(res, DEC_Invalid_operation, set); 907 return res; 908 } 909 if (uc==msuc && i==msudigs-1) break; /* just did final digit */ 910 } /* each digit */ 911 } /* both OK */ 912 } /* each unit */ 913 /* [here uc-1 is the msu of the result] */ 914 res->digits=decGetDigits(res->lsu, uc-res->lsu); 915 res->exponent=0; /* integer */ 916 res->bits=0; /* sign=0 */ 917 return res; /* [no status to set] */ 918 } /* decNumberAnd */ 919 920 /* ------------------------------------------------------------------ */ 921 /* decNumberCompare -- compare two Numbers */ 922 /* */ 923 /* This computes C = A ? B */ 924 /* */ 925 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 926 /* lhs is A */ 927 /* rhs is B */ 928 /* set is the context */ 929 /* */ 930 /* C must have space for one digit (or NaN). */ 931 /* ------------------------------------------------------------------ */ 932 decNumber * decNumberCompare(decNumber *res, const decNumber *lhs, 933 const decNumber *rhs, decContext *set) { 934 uInt status=0; /* accumulator */ 935 decCompareOp(res, lhs, rhs, set, COMPARE, &status); 936 if (status!=0) decStatus(res, status, set); 937 return res; 938 } /* decNumberCompare */ 939 940 /* ------------------------------------------------------------------ */ 941 /* decNumberCompareSignal -- compare, signalling on all NaNs */ 942 /* */ 943 /* This computes C = A ? B */ 944 /* */ 945 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 946 /* lhs is A */ 947 /* rhs is B */ 948 /* set is the context */ 949 /* */ 950 /* C must have space for one digit (or NaN). */ 951 /* ------------------------------------------------------------------ */ 952 decNumber * decNumberCompareSignal(decNumber *res, const decNumber *lhs, 953 const decNumber *rhs, decContext *set) { 954 uInt status=0; /* accumulator */ 955 decCompareOp(res, lhs, rhs, set, COMPSIG, &status); 956 if (status!=0) decStatus(res, status, set); 957 return res; 958 } /* decNumberCompareSignal */ 959 960 /* ------------------------------------------------------------------ */ 961 /* decNumberCompareTotal -- compare two Numbers, using total ordering */ 962 /* */ 963 /* This computes C = A ? B, under total ordering */ 964 /* */ 965 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 966 /* lhs is A */ 967 /* rhs is B */ 968 /* set is the context */ 969 /* */ 970 /* C must have space for one digit; the result will always be one of */ 971 /* -1, 0, or 1. */ 972 /* ------------------------------------------------------------------ */ 973 decNumber * decNumberCompareTotal(decNumber *res, const decNumber *lhs, 974 const decNumber *rhs, decContext *set) { 975 uInt status=0; /* accumulator */ 976 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status); 977 if (status!=0) decStatus(res, status, set); 978 return res; 979 } /* decNumberCompareTotal */ 980 981 /* ------------------------------------------------------------------ */ 982 /* decNumberCompareTotalMag -- compare, total ordering of magnitudes */ 983 /* */ 984 /* This computes C = |A| ? |B|, under total ordering */ 985 /* */ 986 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 987 /* lhs is A */ 988 /* rhs is B */ 989 /* set is the context */ 990 /* */ 991 /* C must have space for one digit; the result will always be one of */ 992 /* -1, 0, or 1. */ 993 /* ------------------------------------------------------------------ */ 994 decNumber * decNumberCompareTotalMag(decNumber *res, const decNumber *lhs, 995 const decNumber *rhs, decContext *set) { 996 uInt status=0; /* accumulator */ 997 uInt needbytes; /* for space calculations */ 998 decNumber bufa[D2N(DECBUFFER+1)];/* +1 in case DECBUFFER=0 */ 999 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 1000 decNumber bufb[D2N(DECBUFFER+1)]; 1001 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */ 1002 decNumber *a, *b; /* temporary pointers */ 1003 1004 #if DECCHECK 1005 if (decCheckOperands(res, lhs, rhs, set)) return res; 1006 #endif 1007 1008 do { /* protect allocated storage */ 1009 /* if either is negative, take a copy and absolute */ 1010 if (decNumberIsNegative(lhs)) { /* lhs<0 */ 1011 a=bufa; 1012 needbytes=sizeof(decNumber)+(D2U(lhs->digits)-1)*sizeof(Unit); 1013 if (needbytes>sizeof(bufa)) { /* need malloc space */ 1014 allocbufa=(decNumber *)malloc(needbytes); 1015 if (allocbufa==NULL) { /* hopeless -- abandon */ 1016 status|=DEC_Insufficient_storage; 1017 break;} 1018 a=allocbufa; /* use the allocated space */ 1019 } 1020 decNumberCopy(a, lhs); /* copy content */ 1021 a->bits&=~DECNEG; /* .. and clear the sign */ 1022 lhs=a; /* use copy from here on */ 1023 } 1024 if (decNumberIsNegative(rhs)) { /* rhs<0 */ 1025 b=bufb; 1026 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); 1027 if (needbytes>sizeof(bufb)) { /* need malloc space */ 1028 allocbufb=(decNumber *)malloc(needbytes); 1029 if (allocbufb==NULL) { /* hopeless -- abandon */ 1030 status|=DEC_Insufficient_storage; 1031 break;} 1032 b=allocbufb; /* use the allocated space */ 1033 } 1034 decNumberCopy(b, rhs); /* copy content */ 1035 b->bits&=~DECNEG; /* .. and clear the sign */ 1036 rhs=b; /* use copy from here on */ 1037 } 1038 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status); 1039 } while(0); /* end protected */ 1040 1041 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */ 1042 if (allocbufb!=NULL) free(allocbufb); /* .. */ 1043 if (status!=0) decStatus(res, status, set); 1044 return res; 1045 } /* decNumberCompareTotalMag */ 1046 1047 /* ------------------------------------------------------------------ */ 1048 /* decNumberDivide -- divide one number by another */ 1049 /* */ 1050 /* This computes C = A / B */ 1051 /* */ 1052 /* res is C, the result. C may be A and/or B (e.g., X=X/X) */ 1053 /* lhs is A */ 1054 /* rhs is B */ 1055 /* set is the context */ 1056 /* */ 1057 /* C must have space for set->digits digits. */ 1058 /* ------------------------------------------------------------------ */ 1059 decNumber * decNumberDivide(decNumber *res, const decNumber *lhs, 1060 const decNumber *rhs, decContext *set) { 1061 uInt status=0; /* accumulator */ 1062 decDivideOp(res, lhs, rhs, set, DIVIDE, &status); 1063 if (status!=0) decStatus(res, status, set); 1064 #if DECCHECK 1065 decCheckInexact(res, set); 1066 #endif 1067 return res; 1068 } /* decNumberDivide */ 1069 1070 /* ------------------------------------------------------------------ */ 1071 /* decNumberDivideInteger -- divide and return integer quotient */ 1072 /* */ 1073 /* This computes C = A # B, where # is the integer divide operator */ 1074 /* */ 1075 /* res is C, the result. C may be A and/or B (e.g., X=X#X) */ 1076 /* lhs is A */ 1077 /* rhs is B */ 1078 /* set is the context */ 1079 /* */ 1080 /* C must have space for set->digits digits. */ 1081 /* ------------------------------------------------------------------ */ 1082 decNumber * decNumberDivideInteger(decNumber *res, const decNumber *lhs, 1083 const decNumber *rhs, decContext *set) { 1084 uInt status=0; /* accumulator */ 1085 decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status); 1086 if (status!=0) decStatus(res, status, set); 1087 return res; 1088 } /* decNumberDivideInteger */ 1089 1090 /* ------------------------------------------------------------------ */ 1091 /* decNumberExp -- exponentiation */ 1092 /* */ 1093 /* This computes C = exp(A) */ 1094 /* */ 1095 /* res is C, the result. C may be A */ 1096 /* rhs is A */ 1097 /* set is the context; note that rounding mode has no effect */ 1098 /* */ 1099 /* C must have space for set->digits digits. */ 1100 /* */ 1101 /* Mathematical function restrictions apply (see above); a NaN is */ 1102 /* returned with Invalid_operation if a restriction is violated. */ 1103 /* */ 1104 /* Finite results will always be full precision and Inexact, except */ 1105 /* when A is a zero or -Infinity (giving 1 or 0 respectively). */ 1106 /* */ 1107 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */ 1108 /* almost always be correctly rounded, but may be up to 1 ulp in */ 1109 /* error in rare cases. */ 1110 /* ------------------------------------------------------------------ */ 1111 /* This is a wrapper for decExpOp which can handle the slightly wider */ 1112 /* (double) range needed by Ln (which has to be able to calculate */ 1113 /* exp(-a) where a can be the tiniest number (Ntiny). */ 1114 /* ------------------------------------------------------------------ */ 1115 decNumber * decNumberExp(decNumber *res, const decNumber *rhs, 1116 decContext *set) { 1117 uInt status=0; /* accumulator */ 1118 #if DECSUBSET 1119 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 1120 #endif 1121 1122 #if DECCHECK 1123 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1124 #endif 1125 1126 /* Check restrictions; these restrictions ensure that if h=8 (see */ 1127 /* decExpOp) then the result will either overflow or underflow to 0. */ 1128 /* Other math functions restrict the input range, too, for inverses. */ 1129 /* If not violated then carry out the operation. */ 1130 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */ 1131 #if DECSUBSET 1132 if (!set->extended) { 1133 /* reduce operand and set lostDigits status, as needed */ 1134 if (rhs->digits>set->digits) { 1135 allocrhs=decRoundOperand(rhs, set, &status); 1136 if (allocrhs==NULL) break; 1137 rhs=allocrhs; 1138 } 1139 } 1140 #endif 1141 decExpOp(res, rhs, set, &status); 1142 } while(0); /* end protected */ 1143 1144 #if DECSUBSET 1145 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */ 1146 #endif 1147 /* apply significant status */ 1148 if (status!=0) decStatus(res, status, set); 1149 #if DECCHECK 1150 decCheckInexact(res, set); 1151 #endif 1152 return res; 1153 } /* decNumberExp */ 1154 1155 /* ------------------------------------------------------------------ */ 1156 /* decNumberFMA -- fused multiply add */ 1157 /* */ 1158 /* This computes D = (A * B) + C with only one rounding */ 1159 /* */ 1160 /* res is D, the result. D may be A or B or C (e.g., X=FMA(X,X,X)) */ 1161 /* lhs is A */ 1162 /* rhs is B */ 1163 /* fhs is C [far hand side] */ 1164 /* set is the context */ 1165 /* */ 1166 /* Mathematical function restrictions apply (see above); a NaN is */ 1167 /* returned with Invalid_operation if a restriction is violated. */ 1168 /* */ 1169 /* C must have space for set->digits digits. */ 1170 /* ------------------------------------------------------------------ */ 1171 decNumber * decNumberFMA(decNumber *res, const decNumber *lhs, 1172 const decNumber *rhs, const decNumber *fhs, 1173 decContext *set) { 1174 uInt status=0; /* accumulator */ 1175 decContext dcmul; /* context for the multiplication */ 1176 uInt needbytes; /* for space calculations */ 1177 decNumber bufa[D2N(DECBUFFER*2+1)]; 1178 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 1179 decNumber *acc; /* accumulator pointer */ 1180 decNumber dzero; /* work */ 1181 1182 #if DECCHECK 1183 if (decCheckOperands(res, lhs, rhs, set)) return res; 1184 if (decCheckOperands(res, fhs, DECUNUSED, set)) return res; 1185 #endif 1186 1187 do { /* protect allocated storage */ 1188 #if DECSUBSET 1189 if (!set->extended) { /* [undefined if subset] */ 1190 status|=DEC_Invalid_operation; 1191 break;} 1192 #endif 1193 /* Check math restrictions [these ensure no overflow or underflow] */ 1194 if ((!decNumberIsSpecial(lhs) && decCheckMath(lhs, set, &status)) 1195 || (!decNumberIsSpecial(rhs) && decCheckMath(rhs, set, &status)) 1196 || (!decNumberIsSpecial(fhs) && decCheckMath(fhs, set, &status))) break; 1197 /* set up context for multiply */ 1198 dcmul=*set; 1199 dcmul.digits=lhs->digits+rhs->digits; /* just enough */ 1200 /* [The above may be an over-estimate for subset arithmetic, but that's OK] */ 1201 dcmul.emax=DEC_MAX_EMAX; /* effectively unbounded .. */ 1202 dcmul.emin=DEC_MIN_EMIN; /* [thanks to Math restrictions] */ 1203 /* set up decNumber space to receive the result of the multiply */ 1204 acc=bufa; /* may fit */ 1205 needbytes=sizeof(decNumber)+(D2U(dcmul.digits)-1)*sizeof(Unit); 1206 if (needbytes>sizeof(bufa)) { /* need malloc space */ 1207 allocbufa=(decNumber *)malloc(needbytes); 1208 if (allocbufa==NULL) { /* hopeless -- abandon */ 1209 status|=DEC_Insufficient_storage; 1210 break;} 1211 acc=allocbufa; /* use the allocated space */ 1212 } 1213 /* multiply with extended range and necessary precision */ 1214 /*printf("emin=%ld\n", dcmul.emin); */ 1215 decMultiplyOp(acc, lhs, rhs, &dcmul, &status); 1216 /* Only Invalid operation (from sNaN or Inf * 0) is possible in */ 1217 /* status; if either is seen than ignore fhs (in case it is */ 1218 /* another sNaN) and set acc to NaN unless we had an sNaN */ 1219 /* [decMultiplyOp leaves that to caller] */ 1220 /* Note sNaN has to go through addOp to shorten payload if */ 1221 /* necessary */ 1222 if ((status&DEC_Invalid_operation)!=0) { 1223 if (!(status&DEC_sNaN)) { /* but be true invalid */ 1224 decNumberZero(res); /* acc not yet set */ 1225 res->bits=DECNAN; 1226 break; 1227 } 1228 decNumberZero(&dzero); /* make 0 (any non-NaN would do) */ 1229 fhs=&dzero; /* use that */ 1230 } 1231 #if DECCHECK 1232 else { /* multiply was OK */ 1233 if (status!=0) printf("Status=%08lx after FMA multiply\n", status); 1234 } 1235 #endif 1236 /* add the third operand and result -> res, and all is done */ 1237 decAddOp(res, acc, fhs, set, 0, &status); 1238 } while(0); /* end protected */ 1239 1240 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */ 1241 if (status!=0) decStatus(res, status, set); 1242 #if DECCHECK 1243 decCheckInexact(res, set); 1244 #endif 1245 return res; 1246 } /* decNumberFMA */ 1247 1248 /* ------------------------------------------------------------------ */ 1249 /* decNumberInvert -- invert a Number, digitwise */ 1250 /* */ 1251 /* This computes C = ~A */ 1252 /* */ 1253 /* res is C, the result. C may be A (e.g., X=~X) */ 1254 /* rhs is A */ 1255 /* set is the context (used for result length and error report) */ 1256 /* */ 1257 /* C must have space for set->digits digits. */ 1258 /* */ 1259 /* Logical function restrictions apply (see above); a NaN is */ 1260 /* returned with Invalid_operation if a restriction is violated. */ 1261 /* ------------------------------------------------------------------ */ 1262 decNumber * decNumberInvert(decNumber *res, const decNumber *rhs, 1263 decContext *set) { 1264 const Unit *ua, *msua; /* -> operand and its msu */ 1265 Unit *uc, *msuc; /* -> result and its msu */ 1266 Int msudigs; /* digits in res msu */ 1267 #if DECCHECK 1268 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1269 #endif 1270 1271 if (rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { 1272 decStatus(res, DEC_Invalid_operation, set); 1273 return res; 1274 } 1275 /* operand is valid */ 1276 ua=rhs->lsu; /* bottom-up */ 1277 uc=res->lsu; /* .. */ 1278 msua=ua+D2U(rhs->digits)-1; /* -> msu of rhs */ 1279 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ 1280 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ 1281 for (; uc<=msuc; ua++, uc++) { /* Unit loop */ 1282 Unit a; /* extract unit */ 1283 Int i, j; /* work */ 1284 if (ua>msua) a=0; 1285 else a=*ua; 1286 *uc=0; /* can now write back */ 1287 /* always need to examine all bits in rhs */ 1288 /* This loop could be unrolled and/or use BIN2BCD tables */ 1289 for (i=0; i<DECDPUN; i++) { 1290 if ((~a)&1) *uc=*uc+(Unit)powers[i]; /* effect INVERT */ 1291 j=a%10; 1292 a=a/10; 1293 if (j>1) { 1294 decStatus(res, DEC_Invalid_operation, set); 1295 return res; 1296 } 1297 if (uc==msuc && i==msudigs-1) break; /* just did final digit */ 1298 } /* each digit */ 1299 } /* each unit */ 1300 /* [here uc-1 is the msu of the result] */ 1301 res->digits=decGetDigits(res->lsu, uc-res->lsu); 1302 res->exponent=0; /* integer */ 1303 res->bits=0; /* sign=0 */ 1304 return res; /* [no status to set] */ 1305 } /* decNumberInvert */ 1306 1307 /* ------------------------------------------------------------------ */ 1308 /* decNumberLn -- natural logarithm */ 1309 /* */ 1310 /* This computes C = ln(A) */ 1311 /* */ 1312 /* res is C, the result. C may be A */ 1313 /* rhs is A */ 1314 /* set is the context; note that rounding mode has no effect */ 1315 /* */ 1316 /* C must have space for set->digits digits. */ 1317 /* */ 1318 /* Notable cases: */ 1319 /* A<0 -> Invalid */ 1320 /* A=0 -> -Infinity (Exact) */ 1321 /* A=+Infinity -> +Infinity (Exact) */ 1322 /* A=1 exactly -> 0 (Exact) */ 1323 /* */ 1324 /* Mathematical function restrictions apply (see above); a NaN is */ 1325 /* returned with Invalid_operation if a restriction is violated. */ 1326 /* */ 1327 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */ 1328 /* almost always be correctly rounded, but may be up to 1 ulp in */ 1329 /* error in rare cases. */ 1330 /* ------------------------------------------------------------------ */ 1331 /* This is a wrapper for decLnOp which can handle the slightly wider */ 1332 /* (+11) range needed by Ln, Log10, etc. (which may have to be able */ 1333 /* to calculate at p+e+2). */ 1334 /* ------------------------------------------------------------------ */ 1335 decNumber * decNumberLn(decNumber *res, const decNumber *rhs, 1336 decContext *set) { 1337 uInt status=0; /* accumulator */ 1338 #if DECSUBSET 1339 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 1340 #endif 1341 1342 #if DECCHECK 1343 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1344 #endif 1345 1346 /* Check restrictions; this is a math function; if not violated */ 1347 /* then carry out the operation. */ 1348 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */ 1349 #if DECSUBSET 1350 if (!set->extended) { 1351 /* reduce operand and set lostDigits status, as needed */ 1352 if (rhs->digits>set->digits) { 1353 allocrhs=decRoundOperand(rhs, set, &status); 1354 if (allocrhs==NULL) break; 1355 rhs=allocrhs; 1356 } 1357 /* special check in subset for rhs=0 */ 1358 if (ISZERO(rhs)) { /* +/- zeros -> error */ 1359 status|=DEC_Invalid_operation; 1360 break;} 1361 } /* extended=0 */ 1362 #endif 1363 decLnOp(res, rhs, set, &status); 1364 } while(0); /* end protected */ 1365 1366 #if DECSUBSET 1367 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */ 1368 #endif 1369 /* apply significant status */ 1370 if (status!=0) decStatus(res, status, set); 1371 #if DECCHECK 1372 decCheckInexact(res, set); 1373 #endif 1374 return res; 1375 } /* decNumberLn */ 1376 1377 /* ------------------------------------------------------------------ */ 1378 /* decNumberLogB - get adjusted exponent, by 754r rules */ 1379 /* */ 1380 /* This computes C = adjustedexponent(A) */ 1381 /* */ 1382 /* res is C, the result. C may be A */ 1383 /* rhs is A */ 1384 /* set is the context, used only for digits and status */ 1385 /* */ 1386 /* C must have space for 10 digits (A might have 10**9 digits and */ 1387 /* an exponent of +999999999, or one digit and an exponent of */ 1388 /* -1999999999). */ 1389 /* */ 1390 /* This returns the adjusted exponent of A after (in theory) padding */ 1391 /* with zeros on the right to set->digits digits while keeping the */ 1392 /* same value. The exponent is not limited by emin/emax. */ 1393 /* */ 1394 /* Notable cases: */ 1395 /* A<0 -> Use |A| */ 1396 /* A=0 -> -Infinity (Division by zero) */ 1397 /* A=Infinite -> +Infinity (Exact) */ 1398 /* A=1 exactly -> 0 (Exact) */ 1399 /* NaNs are propagated as usual */ 1400 /* ------------------------------------------------------------------ */ 1401 decNumber * decNumberLogB(decNumber *res, const decNumber *rhs, 1402 decContext *set) { 1403 uInt status=0; /* accumulator */ 1404 1405 #if DECCHECK 1406 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1407 #endif 1408 1409 /* NaNs as usual; Infinities return +Infinity; 0->oops */ 1410 if (decNumberIsNaN(rhs)) decNaNs(res, rhs, NULL, set, &status); 1411 else if (decNumberIsInfinite(rhs)) decNumberCopyAbs(res, rhs); 1412 else if (decNumberIsZero(rhs)) { 1413 decNumberZero(res); /* prepare for Infinity */ 1414 res->bits=DECNEG|DECINF; /* -Infinity */ 1415 status|=DEC_Division_by_zero; /* as per 754r */ 1416 } 1417 else { /* finite non-zero */ 1418 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */ 1419 decNumberFromInt32(res, ae); /* lay it out */ 1420 } 1421 1422 if (status!=0) decStatus(res, status, set); 1423 return res; 1424 } /* decNumberLogB */ 1425 1426 /* ------------------------------------------------------------------ */ 1427 /* decNumberLog10 -- logarithm in base 10 */ 1428 /* */ 1429 /* This computes C = log10(A) */ 1430 /* */ 1431 /* res is C, the result. C may be A */ 1432 /* rhs is A */ 1433 /* set is the context; note that rounding mode has no effect */ 1434 /* */ 1435 /* C must have space for set->digits digits. */ 1436 /* */ 1437 /* Notable cases: */ 1438 /* A<0 -> Invalid */ 1439 /* A=0 -> -Infinity (Exact) */ 1440 /* A=+Infinity -> +Infinity (Exact) */ 1441 /* A=10**n (if n is an integer) -> n (Exact) */ 1442 /* */ 1443 /* Mathematical function restrictions apply (see above); a NaN is */ 1444 /* returned with Invalid_operation if a restriction is violated. */ 1445 /* */ 1446 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */ 1447 /* almost always be correctly rounded, but may be up to 1 ulp in */ 1448 /* error in rare cases. */ 1449 /* ------------------------------------------------------------------ */ 1450 /* This calculates ln(A)/ln(10) using appropriate precision. For */ 1451 /* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the */ 1452 /* requested digits and t is the number of digits in the exponent */ 1453 /* (maximum 6). For ln(10) it is p + 3; this is often handled by the */ 1454 /* fastpath in decLnOp. The final division is done to the requested */ 1455 /* precision. */ 1456 /* ------------------------------------------------------------------ */ 1457 decNumber * decNumberLog10(decNumber *res, const decNumber *rhs, 1458 decContext *set) { 1459 uInt status=0, ignore=0; /* status accumulators */ 1460 uInt needbytes; /* for space calculations */ 1461 Int p; /* working precision */ 1462 Int t; /* digits in exponent of A */ 1463 1464 /* buffers for a and b working decimals */ 1465 /* (adjustment calculator, same size) */ 1466 decNumber bufa[D2N(DECBUFFER+2)]; 1467 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 1468 decNumber *a=bufa; /* temporary a */ 1469 decNumber bufb[D2N(DECBUFFER+2)]; 1470 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */ 1471 decNumber *b=bufb; /* temporary b */ 1472 decNumber bufw[D2N(10)]; /* working 2-10 digit number */ 1473 decNumber *w=bufw; /* .. */ 1474 #if DECSUBSET 1475 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 1476 #endif 1477 1478 decContext aset; /* working context */ 1479 1480 #if DECCHECK 1481 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1482 #endif 1483 1484 /* Check restrictions; this is a math function; if not violated */ 1485 /* then carry out the operation. */ 1486 if (!decCheckMath(rhs, set, &status)) do { /* protect malloc */ 1487 #if DECSUBSET 1488 if (!set->extended) { 1489 /* reduce operand and set lostDigits status, as needed */ 1490 if (rhs->digits>set->digits) { 1491 allocrhs=decRoundOperand(rhs, set, &status); 1492 if (allocrhs==NULL) break; 1493 rhs=allocrhs; 1494 } 1495 /* special check in subset for rhs=0 */ 1496 if (ISZERO(rhs)) { /* +/- zeros -> error */ 1497 status|=DEC_Invalid_operation; 1498 break;} 1499 } /* extended=0 */ 1500 #endif 1501 1502 decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */ 1503 1504 /* handle exact powers of 10; only check if +ve finite */ 1505 if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) { 1506 Int residue=0; /* (no residue) */ 1507 uInt copystat=0; /* clean status */ 1508 1509 /* round to a single digit... */ 1510 aset.digits=1; 1511 decCopyFit(w, rhs, &aset, &residue, ©stat); /* copy & shorten */ 1512 /* if exact and the digit is 1, rhs is a power of 10 */ 1513 if (!(copystat&DEC_Inexact) && w->lsu[0]==1) { 1514 /* the exponent, conveniently, is the power of 10; making */ 1515 /* this the result needs a little care as it might not fit, */ 1516 /* so first convert it into the working number, and then move */ 1517 /* to res */ 1518 decNumberFromInt32(w, w->exponent); 1519 residue=0; 1520 decCopyFit(res, w, set, &residue, &status); /* copy & round */ 1521 decFinish(res, set, &residue, &status); /* cleanup/set flags */ 1522 break; 1523 } /* not a power of 10 */ 1524 } /* not a candidate for exact */ 1525 1526 /* simplify the information-content calculation to use 'total */ 1527 /* number of digits in a, including exponent' as compared to the */ 1528 /* requested digits, as increasing this will only rarely cost an */ 1529 /* iteration in ln(a) anyway */ 1530 t=6; /* it can never be >6 */ 1531 1532 /* allocate space when needed... */ 1533 p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3; 1534 needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit); 1535 if (needbytes>sizeof(bufa)) { /* need malloc space */ 1536 allocbufa=(decNumber *)malloc(needbytes); 1537 if (allocbufa==NULL) { /* hopeless -- abandon */ 1538 status|=DEC_Insufficient_storage; 1539 break;} 1540 a=allocbufa; /* use the allocated space */ 1541 } 1542 aset.digits=p; /* as calculated */ 1543 aset.emax=DEC_MAX_MATH; /* usual bounds */ 1544 aset.emin=-DEC_MAX_MATH; /* .. */ 1545 aset.clamp=0; /* and no concrete format */ 1546 decLnOp(a, rhs, &aset, &status); /* a=ln(rhs) */ 1547 1548 /* skip the division if the result so far is infinite, NaN, or */ 1549 /* zero, or there was an error; note NaN from sNaN needs copy */ 1550 if (status&DEC_NaNs && !(status&DEC_sNaN)) break; 1551 if (a->bits&DECSPECIAL || ISZERO(a)) { 1552 decNumberCopy(res, a); /* [will fit] */ 1553 break;} 1554 1555 /* for ln(10) an extra 3 digits of precision are needed */ 1556 p=set->digits+3; 1557 needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit); 1558 if (needbytes>sizeof(bufb)) { /* need malloc space */ 1559 allocbufb=(decNumber *)malloc(needbytes); 1560 if (allocbufb==NULL) { /* hopeless -- abandon */ 1561 status|=DEC_Insufficient_storage; 1562 break;} 1563 b=allocbufb; /* use the allocated space */ 1564 } 1565 decNumberZero(w); /* set up 10... */ 1566 #if DECDPUN==1 1567 w->lsu[1]=1; w->lsu[0]=0; /* .. */ 1568 #else 1569 w->lsu[0]=10; /* .. */ 1570 #endif 1571 w->digits=2; /* .. */ 1572 1573 aset.digits=p; 1574 decLnOp(b, w, &aset, &ignore); /* b=ln(10) */ 1575 1576 aset.digits=set->digits; /* for final divide */ 1577 decDivideOp(res, a, b, &aset, DIVIDE, &status); /* into result */ 1578 } while(0); /* [for break] */ 1579 1580 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */ 1581 if (allocbufb!=NULL) free(allocbufb); /* .. */ 1582 #if DECSUBSET 1583 if (allocrhs !=NULL) free(allocrhs); /* .. */ 1584 #endif 1585 /* apply significant status */ 1586 if (status!=0) decStatus(res, status, set); 1587 #if DECCHECK 1588 decCheckInexact(res, set); 1589 #endif 1590 return res; 1591 } /* decNumberLog10 */ 1592 1593 /* ------------------------------------------------------------------ */ 1594 /* decNumberMax -- compare two Numbers and return the maximum */ 1595 /* */ 1596 /* This computes C = A ? B, returning the maximum by 754R rules */ 1597 /* */ 1598 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1599 /* lhs is A */ 1600 /* rhs is B */ 1601 /* set is the context */ 1602 /* */ 1603 /* C must have space for set->digits digits. */ 1604 /* ------------------------------------------------------------------ */ 1605 decNumber * decNumberMax(decNumber *res, const decNumber *lhs, 1606 const decNumber *rhs, decContext *set) { 1607 uInt status=0; /* accumulator */ 1608 decCompareOp(res, lhs, rhs, set, COMPMAX, &status); 1609 if (status!=0) decStatus(res, status, set); 1610 #if DECCHECK 1611 decCheckInexact(res, set); 1612 #endif 1613 return res; 1614 } /* decNumberMax */ 1615 1616 /* ------------------------------------------------------------------ */ 1617 /* decNumberMaxMag -- compare and return the maximum by magnitude */ 1618 /* */ 1619 /* This computes C = A ? B, returning the maximum by 754R rules */ 1620 /* */ 1621 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1622 /* lhs is A */ 1623 /* rhs is B */ 1624 /* set is the context */ 1625 /* */ 1626 /* C must have space for set->digits digits. */ 1627 /* ------------------------------------------------------------------ */ 1628 decNumber * decNumberMaxMag(decNumber *res, const decNumber *lhs, 1629 const decNumber *rhs, decContext *set) { 1630 uInt status=0; /* accumulator */ 1631 decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status); 1632 if (status!=0) decStatus(res, status, set); 1633 #if DECCHECK 1634 decCheckInexact(res, set); 1635 #endif 1636 return res; 1637 } /* decNumberMaxMag */ 1638 1639 /* ------------------------------------------------------------------ */ 1640 /* decNumberMin -- compare two Numbers and return the minimum */ 1641 /* */ 1642 /* This computes C = A ? B, returning the minimum by 754R rules */ 1643 /* */ 1644 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1645 /* lhs is A */ 1646 /* rhs is B */ 1647 /* set is the context */ 1648 /* */ 1649 /* C must have space for set->digits digits. */ 1650 /* ------------------------------------------------------------------ */ 1651 decNumber * decNumberMin(decNumber *res, const decNumber *lhs, 1652 const decNumber *rhs, decContext *set) { 1653 uInt status=0; /* accumulator */ 1654 decCompareOp(res, lhs, rhs, set, COMPMIN, &status); 1655 if (status!=0) decStatus(res, status, set); 1656 #if DECCHECK 1657 decCheckInexact(res, set); 1658 #endif 1659 return res; 1660 } /* decNumberMin */ 1661 1662 /* ------------------------------------------------------------------ */ 1663 /* decNumberMinMag -- compare and return the minimum by magnitude */ 1664 /* */ 1665 /* This computes C = A ? B, returning the minimum by 754R rules */ 1666 /* */ 1667 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 1668 /* lhs is A */ 1669 /* rhs is B */ 1670 /* set is the context */ 1671 /* */ 1672 /* C must have space for set->digits digits. */ 1673 /* ------------------------------------------------------------------ */ 1674 decNumber * decNumberMinMag(decNumber *res, const decNumber *lhs, 1675 const decNumber *rhs, decContext *set) { 1676 uInt status=0; /* accumulator */ 1677 decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status); 1678 if (status!=0) decStatus(res, status, set); 1679 #if DECCHECK 1680 decCheckInexact(res, set); 1681 #endif 1682 return res; 1683 } /* decNumberMinMag */ 1684 1685 /* ------------------------------------------------------------------ */ 1686 /* decNumberMinus -- prefix minus operator */ 1687 /* */ 1688 /* This computes C = 0 - A */ 1689 /* */ 1690 /* res is C, the result. C may be A */ 1691 /* rhs is A */ 1692 /* set is the context */ 1693 /* */ 1694 /* See also decNumberCopyNegate for a quiet bitwise version of this. */ 1695 /* C must have space for set->digits digits. */ 1696 /* ------------------------------------------------------------------ */ 1697 /* Simply use AddOp for the subtract, which will do the necessary. */ 1698 /* ------------------------------------------------------------------ */ 1699 decNumber * decNumberMinus(decNumber *res, const decNumber *rhs, 1700 decContext *set) { 1701 decNumber dzero; 1702 uInt status=0; /* accumulator */ 1703 1704 #if DECCHECK 1705 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1706 #endif 1707 1708 decNumberZero(&dzero); /* make 0 */ 1709 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */ 1710 decAddOp(res, &dzero, rhs, set, DECNEG, &status); 1711 if (status!=0) decStatus(res, status, set); 1712 #if DECCHECK 1713 decCheckInexact(res, set); 1714 #endif 1715 return res; 1716 } /* decNumberMinus */ 1717 1718 /* ------------------------------------------------------------------ */ 1719 /* decNumberNextMinus -- next towards -Infinity */ 1720 /* */ 1721 /* This computes C = A - infinitesimal, rounded towards -Infinity */ 1722 /* */ 1723 /* res is C, the result. C may be A */ 1724 /* rhs is A */ 1725 /* set is the context */ 1726 /* */ 1727 /* This is a generalization of 754r NextDown. */ 1728 /* ------------------------------------------------------------------ */ 1729 decNumber * decNumberNextMinus(decNumber *res, const decNumber *rhs, 1730 decContext *set) { 1731 decNumber dtiny; /* constant */ 1732 decContext workset=*set; /* work */ 1733 uInt status=0; /* accumulator */ 1734 #if DECCHECK 1735 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1736 #endif 1737 1738 /* +Infinity is the special case */ 1739 if ((rhs->bits&(DECINF|DECNEG))==DECINF) { 1740 decSetMaxValue(res, set); /* is +ve */ 1741 /* there is no status to set */ 1742 return res; 1743 } 1744 decNumberZero(&dtiny); /* start with 0 */ 1745 dtiny.lsu[0]=1; /* make number that is .. */ 1746 dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */ 1747 workset.round=DEC_ROUND_FLOOR; 1748 decAddOp(res, rhs, &dtiny, &workset, DECNEG, &status); 1749 status&=DEC_Invalid_operation|DEC_sNaN; /* only sNaN Invalid please */ 1750 if (status!=0) decStatus(res, status, set); 1751 return res; 1752 } /* decNumberNextMinus */ 1753 1754 /* ------------------------------------------------------------------ */ 1755 /* decNumberNextPlus -- next towards +Infinity */ 1756 /* */ 1757 /* This computes C = A + infinitesimal, rounded towards +Infinity */ 1758 /* */ 1759 /* res is C, the result. C may be A */ 1760 /* rhs is A */ 1761 /* set is the context */ 1762 /* */ 1763 /* This is a generalization of 754r NextUp. */ 1764 /* ------------------------------------------------------------------ */ 1765 decNumber * decNumberNextPlus(decNumber *res, const decNumber *rhs, 1766 decContext *set) { 1767 decNumber dtiny; /* constant */ 1768 decContext workset=*set; /* work */ 1769 uInt status=0; /* accumulator */ 1770 #if DECCHECK 1771 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1772 #endif 1773 1774 /* -Infinity is the special case */ 1775 if ((rhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) { 1776 decSetMaxValue(res, set); 1777 res->bits=DECNEG; /* negative */ 1778 /* there is no status to set */ 1779 return res; 1780 } 1781 decNumberZero(&dtiny); /* start with 0 */ 1782 dtiny.lsu[0]=1; /* make number that is .. */ 1783 dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */ 1784 workset.round=DEC_ROUND_CEILING; 1785 decAddOp(res, rhs, &dtiny, &workset, 0, &status); 1786 status&=DEC_Invalid_operation|DEC_sNaN; /* only sNaN Invalid please */ 1787 if (status!=0) decStatus(res, status, set); 1788 return res; 1789 } /* decNumberNextPlus */ 1790 1791 /* ------------------------------------------------------------------ */ 1792 /* decNumberNextToward -- next towards rhs */ 1793 /* */ 1794 /* This computes C = A +/- infinitesimal, rounded towards */ 1795 /* +/-Infinity in the direction of B, as per 754r nextafter rules */ 1796 /* */ 1797 /* res is C, the result. C may be A or B. */ 1798 /* lhs is A */ 1799 /* rhs is B */ 1800 /* set is the context */ 1801 /* */ 1802 /* This is a generalization of 754r NextAfter. */ 1803 /* ------------------------------------------------------------------ */ 1804 decNumber * decNumberNextToward(decNumber *res, const decNumber *lhs, 1805 const decNumber *rhs, decContext *set) { 1806 decNumber dtiny; /* constant */ 1807 decContext workset=*set; /* work */ 1808 Int result; /* .. */ 1809 uInt status=0; /* accumulator */ 1810 #if DECCHECK 1811 if (decCheckOperands(res, lhs, rhs, set)) return res; 1812 #endif 1813 1814 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { 1815 decNaNs(res, lhs, rhs, set, &status); 1816 } 1817 else { /* Is numeric, so no chance of sNaN Invalid, etc. */ 1818 result=decCompare(lhs, rhs, 0); /* sign matters */ 1819 if (result==BADINT) status|=DEC_Insufficient_storage; /* rare */ 1820 else { /* valid compare */ 1821 if (result==0) decNumberCopySign(res, lhs, rhs); /* easy */ 1822 else { /* differ: need NextPlus or NextMinus */ 1823 uByte sub; /* add or subtract */ 1824 if (result<0) { /* lhs<rhs, do nextplus */ 1825 /* -Infinity is the special case */ 1826 if ((lhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) { 1827 decSetMaxValue(res, set); 1828 res->bits=DECNEG; /* negative */ 1829 return res; /* there is no status to set */ 1830 } 1831 workset.round=DEC_ROUND_CEILING; 1832 sub=0; /* add, please */ 1833 } /* plus */ 1834 else { /* lhs>rhs, do nextminus */ 1835 /* +Infinity is the special case */ 1836 if ((lhs->bits&(DECINF|DECNEG))==DECINF) { 1837 decSetMaxValue(res, set); 1838 return res; /* there is no status to set */ 1839 } 1840 workset.round=DEC_ROUND_FLOOR; 1841 sub=DECNEG; /* subtract, please */ 1842 } /* minus */ 1843 decNumberZero(&dtiny); /* start with 0 */ 1844 dtiny.lsu[0]=1; /* make number that is .. */ 1845 dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */ 1846 decAddOp(res, lhs, &dtiny, &workset, sub, &status); /* + or - */ 1847 /* turn off exceptions if the result is a normal number */ 1848 /* (including Nmin), otherwise let all status through */ 1849 if (decNumberIsNormal(res, set)) status=0; 1850 } /* unequal */ 1851 } /* compare OK */ 1852 } /* numeric */ 1853 if (status!=0) decStatus(res, status, set); 1854 return res; 1855 } /* decNumberNextToward */ 1856 1857 /* ------------------------------------------------------------------ */ 1858 /* decNumberOr -- OR two Numbers, digitwise */ 1859 /* */ 1860 /* This computes C = A | B */ 1861 /* */ 1862 /* res is C, the result. C may be A and/or B (e.g., X=X|X) */ 1863 /* lhs is A */ 1864 /* rhs is B */ 1865 /* set is the context (used for result length and error report) */ 1866 /* */ 1867 /* C must have space for set->digits digits. */ 1868 /* */ 1869 /* Logical function restrictions apply (see above); a NaN is */ 1870 /* returned with Invalid_operation if a restriction is violated. */ 1871 /* ------------------------------------------------------------------ */ 1872 decNumber * decNumberOr(decNumber *res, const decNumber *lhs, 1873 const decNumber *rhs, decContext *set) { 1874 const Unit *ua, *ub; /* -> operands */ 1875 const Unit *msua, *msub; /* -> operand msus */ 1876 Unit *uc, *msuc; /* -> result and its msu */ 1877 Int msudigs; /* digits in res msu */ 1878 #if DECCHECK 1879 if (decCheckOperands(res, lhs, rhs, set)) return res; 1880 #endif 1881 1882 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs) 1883 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { 1884 decStatus(res, DEC_Invalid_operation, set); 1885 return res; 1886 } 1887 /* operands are valid */ 1888 ua=lhs->lsu; /* bottom-up */ 1889 ub=rhs->lsu; /* .. */ 1890 uc=res->lsu; /* .. */ 1891 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */ 1892 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ 1893 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ 1894 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ 1895 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */ 1896 Unit a, b; /* extract units */ 1897 if (ua>msua) a=0; 1898 else a=*ua; 1899 if (ub>msub) b=0; 1900 else b=*ub; 1901 *uc=0; /* can now write back */ 1902 if (a|b) { /* maybe 1 bits to examine */ 1903 Int i, j; 1904 /* This loop could be unrolled and/or use BIN2BCD tables */ 1905 for (i=0; i<DECDPUN; i++) { 1906 if ((a|b)&1) *uc=*uc+(Unit)powers[i]; /* effect OR */ 1907 j=a%10; 1908 a=a/10; 1909 j|=b%10; 1910 b=b/10; 1911 if (j>1) { 1912 decStatus(res, DEC_Invalid_operation, set); 1913 return res; 1914 } 1915 if (uc==msuc && i==msudigs-1) break; /* just did final digit */ 1916 } /* each digit */ 1917 } /* non-zero */ 1918 } /* each unit */ 1919 /* [here uc-1 is the msu of the result] */ 1920 res->digits=decGetDigits(res->lsu, uc-res->lsu); 1921 res->exponent=0; /* integer */ 1922 res->bits=0; /* sign=0 */ 1923 return res; /* [no status to set] */ 1924 } /* decNumberOr */ 1925 1926 /* ------------------------------------------------------------------ */ 1927 /* decNumberPlus -- prefix plus operator */ 1928 /* */ 1929 /* This computes C = 0 + A */ 1930 /* */ 1931 /* res is C, the result. C may be A */ 1932 /* rhs is A */ 1933 /* set is the context */ 1934 /* */ 1935 /* See also decNumberCopy for a quiet bitwise version of this. */ 1936 /* C must have space for set->digits digits. */ 1937 /* ------------------------------------------------------------------ */ 1938 /* This simply uses AddOp; Add will take fast path after preparing A. */ 1939 /* Performance is a concern here, as this routine is often used to */ 1940 /* check operands and apply rounding and overflow/underflow testing. */ 1941 /* ------------------------------------------------------------------ */ 1942 decNumber * decNumberPlus(decNumber *res, const decNumber *rhs, 1943 decContext *set) { 1944 decNumber dzero; 1945 uInt status=0; /* accumulator */ 1946 #if DECCHECK 1947 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1948 #endif 1949 1950 decNumberZero(&dzero); /* make 0 */ 1951 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */ 1952 decAddOp(res, &dzero, rhs, set, 0, &status); 1953 if (status!=0) decStatus(res, status, set); 1954 #if DECCHECK 1955 decCheckInexact(res, set); 1956 #endif 1957 return res; 1958 } /* decNumberPlus */ 1959 1960 /* ------------------------------------------------------------------ */ 1961 /* decNumberMultiply -- multiply two Numbers */ 1962 /* */ 1963 /* This computes C = A x B */ 1964 /* */ 1965 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */ 1966 /* lhs is A */ 1967 /* rhs is B */ 1968 /* set is the context */ 1969 /* */ 1970 /* C must have space for set->digits digits. */ 1971 /* ------------------------------------------------------------------ */ 1972 decNumber * decNumberMultiply(decNumber *res, const decNumber *lhs, 1973 const decNumber *rhs, decContext *set) { 1974 uInt status=0; /* accumulator */ 1975 decMultiplyOp(res, lhs, rhs, set, &status); 1976 if (status!=0) decStatus(res, status, set); 1977 #if DECCHECK 1978 decCheckInexact(res, set); 1979 #endif 1980 return res; 1981 } /* decNumberMultiply */ 1982 1983 /* ------------------------------------------------------------------ */ 1984 /* decNumberPower -- raise a number to a power */ 1985 /* */ 1986 /* This computes C = A ** B */ 1987 /* */ 1988 /* res is C, the result. C may be A and/or B (e.g., X=X**X) */ 1989 /* lhs is A */ 1990 /* rhs is B */ 1991 /* set is the context */ 1992 /* */ 1993 /* C must have space for set->digits digits. */ 1994 /* */ 1995 /* Mathematical function restrictions apply (see above); a NaN is */ 1996 /* returned with Invalid_operation if a restriction is violated. */ 1997 /* */ 1998 /* However, if 1999999997<=B<=999999999 and B is an integer then the */ 1999 /* restrictions on A and the context are relaxed to the usual bounds, */ 2000 /* for compatibility with the earlier (integer power only) version */ 2001 /* of this function. */ 2002 /* */ 2003 /* When B is an integer, the result may be exact, even if rounded. */ 2004 /* */ 2005 /* The final result is rounded according to the context; it will */ 2006 /* almost always be correctly rounded, but may be up to 1 ulp in */ 2007 /* error in rare cases. */ 2008 /* ------------------------------------------------------------------ */ 2009 decNumber * decNumberPower(decNumber *res, const decNumber *lhs, 2010 const decNumber *rhs, decContext *set) { 2011 #if DECSUBSET 2012 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 2013 decNumber *allocrhs=NULL; /* .., rhs */ 2014 #endif 2015 decNumber *allocdac=NULL; /* -> allocated acc buffer, iff used */ 2016 decNumber *allocinv=NULL; /* -> allocated 1/x buffer, iff used */ 2017 Int reqdigits=set->digits; /* requested DIGITS */ 2018 Int n; /* rhs in binary */ 2019 Flag rhsint=0; /* 1 if rhs is an integer */ 2020 Flag useint=0; /* 1 if can use integer calculation */ 2021 Flag isoddint=0; /* 1 if rhs is an integer and odd */ 2022 Int i; /* work */ 2023 #if DECSUBSET 2024 Int dropped; /* .. */ 2025 #endif 2026 uInt needbytes; /* buffer size needed */ 2027 Flag seenbit; /* seen a bit while powering */ 2028 Int residue=0; /* rounding residue */ 2029 uInt status=0; /* accumulators */ 2030 uByte bits=0; /* result sign if errors */ 2031 decContext aset; /* working context */ 2032 decNumber dnOne; /* work value 1... */ 2033 /* local accumulator buffer [a decNumber, with digits+elength+1 digits] */ 2034 decNumber dacbuff[D2N(DECBUFFER+9)]; 2035 decNumber *dac=dacbuff; /* -> result accumulator */ 2036 /* same again for possible 1/lhs calculation */ 2037 decNumber invbuff[D2N(DECBUFFER+9)]; 2038 2039 #if DECCHECK 2040 if (decCheckOperands(res, lhs, rhs, set)) return res; 2041 #endif 2042 2043 do { /* protect allocated storage */ 2044 #if DECSUBSET 2045 if (!set->extended) { /* reduce operands and set status, as needed */ 2046 if (lhs->digits>reqdigits) { 2047 alloclhs=decRoundOperand(lhs, set, &status); 2048 if (alloclhs==NULL) break; 2049 lhs=alloclhs; 2050 } 2051 if (rhs->digits>reqdigits) { 2052 allocrhs=decRoundOperand(rhs, set, &status); 2053 if (allocrhs==NULL) break; 2054 rhs=allocrhs; 2055 } 2056 } 2057 #endif 2058 /* [following code does not require input rounding] */ 2059 2060 /* handle NaNs and rhs Infinity (lhs infinity is harder) */ 2061 if (SPECIALARGS) { 2062 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { /* NaNs */ 2063 decNaNs(res, lhs, rhs, set, &status); 2064 break;} 2065 if (decNumberIsInfinite(rhs)) { /* rhs Infinity */ 2066 Flag rhsneg=rhs->bits&DECNEG; /* save rhs sign */ 2067 if (decNumberIsNegative(lhs) /* lhs<0 */ 2068 && !decNumberIsZero(lhs)) /* .. */ 2069 status|=DEC_Invalid_operation; 2070 else { /* lhs >=0 */ 2071 decNumberZero(&dnOne); /* set up 1 */ 2072 dnOne.lsu[0]=1; 2073 decNumberCompare(dac, lhs, &dnOne, set); /* lhs ? 1 */ 2074 decNumberZero(res); /* prepare for 0/1/Infinity */ 2075 if (decNumberIsNegative(dac)) { /* lhs<1 */ 2076 if (rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */ 2077 } 2078 else if (dac->lsu[0]==0) { /* lhs=1 */ 2079 /* 1**Infinity is inexact, so return fully-padded 1.0000 */ 2080 Int shift=set->digits-1; 2081 *res->lsu=1; /* was 0, make int 1 */ 2082 res->digits=decShiftToMost(res->lsu, 1, shift); 2083 res->exponent=-shift; /* make 1.0000... */ 2084 status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */ 2085 } 2086 else { /* lhs>1 */ 2087 if (!rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */ 2088 } 2089 } /* lhs>=0 */ 2090 break;} 2091 /* [lhs infinity drops through] */ 2092 } /* specials */ 2093 2094 /* Original rhs may be an integer that fits and is in range */ 2095 n=decGetInt(rhs); 2096 if (n!=BADINT) { /* it is an integer */ 2097 rhsint=1; /* record the fact for 1**n */ 2098 isoddint=(Flag)n&1; /* [works even if big] */ 2099 if (n!=BIGEVEN && n!=BIGODD) /* can use integer path? */ 2100 useint=1; /* looks good */ 2101 } 2102 2103 if (decNumberIsNegative(lhs) /* -x .. */ 2104 && isoddint) bits=DECNEG; /* .. to an odd power */ 2105 2106 /* handle LHS infinity */ 2107 if (decNumberIsInfinite(lhs)) { /* [NaNs already handled] */ 2108 uByte rbits=rhs->bits; /* save */ 2109 decNumberZero(res); /* prepare */ 2110 if (n==0) *res->lsu=1; /* [-]Inf**0 => 1 */ 2111 else { 2112 /* -Inf**nonint -> error */ 2113 if (!rhsint && decNumberIsNegative(lhs)) { 2114 status|=DEC_Invalid_operation; /* -Inf**nonint is error */ 2115 break;} 2116 if (!(rbits & DECNEG)) bits|=DECINF; /* was not a **-n */ 2117 /* [otherwise will be 0 or -0] */ 2118 res->bits=bits; 2119 } 2120 break;} 2121 2122 /* similarly handle LHS zero */ 2123 if (decNumberIsZero(lhs)) { 2124 if (n==0) { /* 0**0 => Error */ 2125 #if DECSUBSET 2126 if (!set->extended) { /* [unless subset] */ 2127 decNumberZero(res); 2128 *res->lsu=1; /* return 1 */ 2129 break;} 2130 #endif 2131 status|=DEC_Invalid_operation; 2132 } 2133 else { /* 0**x */ 2134 uByte rbits=rhs->bits; /* save */ 2135 if (rbits & DECNEG) { /* was a 0**(-n) */ 2136 #if DECSUBSET 2137 if (!set->extended) { /* [bad if subset] */ 2138 status|=DEC_Invalid_operation; 2139 break;} 2140 #endif 2141 bits|=DECINF; 2142 } 2143 decNumberZero(res); /* prepare */ 2144 /* [otherwise will be 0 or -0] */ 2145 res->bits=bits; 2146 } 2147 break;} 2148 2149 /* here both lhs and rhs are finite; rhs==0 is handled in the */ 2150 /* integer path. Next handle the non-integer cases */ 2151 if (!useint) { /* non-integral rhs */ 2152 /* any -ve lhs is bad, as is either operand or context out of */ 2153 /* bounds */ 2154 if (decNumberIsNegative(lhs)) { 2155 status|=DEC_Invalid_operation; 2156 break;} 2157 if (decCheckMath(lhs, set, &status) 2158 || decCheckMath(rhs, set, &status)) break; /* variable status */ 2159 2160 decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */ 2161 aset.emax=DEC_MAX_MATH; /* usual bounds */ 2162 aset.emin=-DEC_MAX_MATH; /* .. */ 2163 aset.clamp=0; /* and no concrete format */ 2164 2165 /* calculate the result using exp(ln(lhs)*rhs), which can */ 2166 /* all be done into the accumulator, dac. The precision needed */ 2167 /* is enough to contain the full information in the lhs (which */ 2168 /* is the total digits, including exponent), or the requested */ 2169 /* precision, if larger, + 4; 6 is used for the exponent */ 2170 /* maximum length, and this is also used when it is shorter */ 2171 /* than the requested digits as it greatly reduces the >0.5 ulp */ 2172 /* cases at little cost (because Ln doubles digits each */ 2173 /* iteration so a few extra digits rarely causes an extra */ 2174 /* iteration) */ 2175 aset.digits=MAXI(lhs->digits, set->digits)+6+4; 2176 } /* non-integer rhs */ 2177 2178 else { /* rhs is in-range integer */ 2179 if (n==0) { /* x**0 = 1 */ 2180 /* (0**0 was handled above) */ 2181 decNumberZero(res); /* result=1 */ 2182 *res->lsu=1; /* .. */ 2183 break;} 2184 /* rhs is a non-zero integer */ 2185 if (n<0) n=-n; /* use abs(n) */ 2186 2187 aset=*set; /* clone the context */ 2188 aset.round=DEC_ROUND_HALF_EVEN; /* internally use balanced */ 2189 /* calculate the working DIGITS */ 2190 aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2; 2191 #if DECSUBSET 2192 if (!set->extended) aset.digits--; /* use classic precision */ 2193 #endif 2194 /* it's an error if this is more than can be handled */ 2195 if (aset.digits>DECNUMMAXP) {status|=DEC_Invalid_operation; break;} 2196 } /* integer path */ 2197 2198 /* aset.digits is the count of digits for the accumulator needed */ 2199 /* if accumulator is too long for local storage, then allocate */ 2200 needbytes=sizeof(decNumber)+(D2U(aset.digits)-1)*sizeof(Unit); 2201 /* [needbytes also used below if 1/lhs needed] */ 2202 if (needbytes>sizeof(dacbuff)) { 2203 allocdac=(decNumber *)malloc(needbytes); 2204 if (allocdac==NULL) { /* hopeless -- abandon */ 2205 status|=DEC_Insufficient_storage; 2206 break;} 2207 dac=allocdac; /* use the allocated space */ 2208 } 2209 /* here, aset is set up and accumulator is ready for use */ 2210 2211 if (!useint) { /* non-integral rhs */ 2212 /* x ** y; special-case x=1 here as it will otherwise always */ 2213 /* reduce to integer 1; decLnOp has a fastpath which detects */ 2214 /* the case of x=1 */ 2215 decLnOp(dac, lhs, &aset, &status); /* dac=ln(lhs) */ 2216 /* [no error possible, as lhs 0 already handled] */ 2217 if (ISZERO(dac)) { /* x==1, 1.0, etc. */ 2218 /* need to return fully-padded 1.0000 etc., but rhsint->1 */ 2219 *dac->lsu=1; /* was 0, make int 1 */ 2220 if (!rhsint) { /* add padding */ 2221 Int shift=set->digits-1; 2222 dac->digits=decShiftToMost(dac->lsu, 1, shift); 2223 dac->exponent=-shift; /* make 1.0000... */ 2224 status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */ 2225 } 2226 } 2227 else { 2228 decMultiplyOp(dac, dac, rhs, &aset, &status); /* dac=dac*rhs */ 2229 decExpOp(dac, dac, &aset, &status); /* dac=exp(dac) */ 2230 } 2231 /* and drop through for final rounding */ 2232 } /* non-integer rhs */ 2233 2234 else { /* carry on with integer */ 2235 decNumberZero(dac); /* acc=1 */ 2236 *dac->lsu=1; /* .. */ 2237 2238 /* if a negative power the constant 1 is needed, and if not subset */ 2239 /* invert the lhs now rather than inverting the result later */ 2240 if (decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */ 2241 decNumber *inv=invbuff; /* asssume use fixed buffer */ 2242 decNumberCopy(&dnOne, dac); /* dnOne=1; [needed now or later] */ 2243 #if DECSUBSET 2244 if (set->extended) { /* need to calculate 1/lhs */ 2245 #endif 2246 /* divide lhs into 1, putting result in dac [dac=1/dac] */ 2247 decDivideOp(dac, &dnOne, lhs, &aset, DIVIDE, &status); 2248 /* now locate or allocate space for the inverted lhs */ 2249 if (needbytes>sizeof(invbuff)) { 2250 allocinv=(decNumber *)malloc(needbytes); 2251 if (allocinv==NULL) { /* hopeless -- abandon */ 2252 status|=DEC_Insufficient_storage; 2253 break;} 2254 inv=allocinv; /* use the allocated space */ 2255 } 2256 /* [inv now points to big-enough buffer or allocated storage] */ 2257 decNumberCopy(inv, dac); /* copy the 1/lhs */ 2258 decNumberCopy(dac, &dnOne); /* restore acc=1 */ 2259 lhs=inv; /* .. and go forward with new lhs */ 2260 #if DECSUBSET 2261 } 2262 #endif 2263 } 2264 2265 /* Raise-to-the-power loop... */ 2266 seenbit=0; /* set once a 1-bit is encountered */ 2267 for (i=1;;i++){ /* for each bit [top bit ignored] */ 2268 /* abandon if had overflow or terminal underflow */ 2269 if (status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */ 2270 if (status&DEC_Overflow || ISZERO(dac)) break; 2271 } 2272 /* [the following two lines revealed an optimizer bug in a C++ */ 2273 /* compiler, with symptom: 5**3 -> 25, when n=n+n was used] */ 2274 n=n<<1; /* move next bit to testable position */ 2275 if (n<0) { /* top bit is set */ 2276 seenbit=1; /* OK, significant bit seen */ 2277 decMultiplyOp(dac, dac, lhs, &aset, &status); /* dac=dac*x */ 2278 } 2279 if (i==31) break; /* that was the last bit */ 2280 if (!seenbit) continue; /* no need to square 1 */ 2281 decMultiplyOp(dac, dac, dac, &aset, &status); /* dac=dac*dac [square] */ 2282 } /*i*/ /* 32 bits */ 2283 2284 /* complete internal overflow or underflow processing */ 2285 if (status & (DEC_Overflow|DEC_Underflow)) { 2286 #if DECSUBSET 2287 /* If subset, and power was negative, reverse the kind of -erflow */ 2288 /* [1/x not yet done] */ 2289 if (!set->extended && decNumberIsNegative(rhs)) { 2290 if (status & DEC_Overflow) 2291 status^=DEC_Overflow | DEC_Underflow | DEC_Subnormal; 2292 else { /* trickier -- Underflow may or may not be set */ 2293 status&=~(DEC_Underflow | DEC_Subnormal); /* [one or both] */ 2294 status|=DEC_Overflow; 2295 } 2296 } 2297 #endif 2298 dac->bits=(dac->bits & ~DECNEG) | bits; /* force correct sign */ 2299 /* round subnormals [to set.digits rather than aset.digits] */ 2300 /* or set overflow result similarly as required */ 2301 decFinalize(dac, set, &residue, &status); 2302 decNumberCopy(res, dac); /* copy to result (is now OK length) */ 2303 break; 2304 } 2305 2306 #if DECSUBSET 2307 if (!set->extended && /* subset math */ 2308 decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */ 2309 /* so divide result into 1 [dac=1/dac] */ 2310 decDivideOp(dac, &dnOne, dac, &aset, DIVIDE, &status); 2311 } 2312 #endif 2313 } /* rhs integer path */ 2314 2315 /* reduce result to the requested length and copy to result */ 2316 decCopyFit(res, dac, set, &residue, &status); 2317 decFinish(res, set, &residue, &status); /* final cleanup */ 2318 #if DECSUBSET 2319 if (!set->extended) decTrim(res, set, 0, &dropped); /* trailing zeros */ 2320 #endif 2321 } while(0); /* end protected */ 2322 2323 if (allocdac!=NULL) free(allocdac); /* drop any storage used */ 2324 if (allocinv!=NULL) free(allocinv); /* .. */ 2325 #if DECSUBSET 2326 if (alloclhs!=NULL) free(alloclhs); /* .. */ 2327 if (allocrhs!=NULL) free(allocrhs); /* .. */ 2328 #endif 2329 if (status!=0) decStatus(res, status, set); 2330 #if DECCHECK 2331 decCheckInexact(res, set); 2332 #endif 2333 return res; 2334 } /* decNumberPower */ 2335 2336 /* ------------------------------------------------------------------ */ 2337 /* decNumberQuantize -- force exponent to requested value */ 2338 /* */ 2339 /* This computes C = op(A, B), where op adjusts the coefficient */ 2340 /* of C (by rounding or shifting) such that the exponent (-scale) */ 2341 /* of C has exponent of B. The numerical value of C will equal A, */ 2342 /* except for the effects of any rounding that occurred. */ 2343 /* */ 2344 /* res is C, the result. C may be A or B */ 2345 /* lhs is A, the number to adjust */ 2346 /* rhs is B, the number with exponent to match */ 2347 /* set is the context */ 2348 /* */ 2349 /* C must have space for set->digits digits. */ 2350 /* */ 2351 /* Unless there is an error or the result is infinite, the exponent */ 2352 /* after the operation is guaranteed to be equal to that of B. */ 2353 /* ------------------------------------------------------------------ */ 2354 decNumber * decNumberQuantize(decNumber *res, const decNumber *lhs, 2355 const decNumber *rhs, decContext *set) { 2356 uInt status=0; /* accumulator */ 2357 decQuantizeOp(res, lhs, rhs, set, 1, &status); 2358 if (status!=0) decStatus(res, status, set); 2359 return res; 2360 } /* decNumberQuantize */ 2361 2362 /* ------------------------------------------------------------------ */ 2363 /* decNumberReduce -- remove trailing zeros */ 2364 /* */ 2365 /* This computes C = 0 + A, and normalizes the result */ 2366 /* */ 2367 /* res is C, the result. C may be A */ 2368 /* rhs is A */ 2369 /* set is the context */ 2370 /* */ 2371 /* C must have space for set->digits digits. */ 2372 /* ------------------------------------------------------------------ */ 2373 /* Previously known as Normalize */ 2374 decNumber * decNumberNormalize(decNumber *res, const decNumber *rhs, 2375 decContext *set) { 2376 return decNumberReduce(res, rhs, set); 2377 } /* decNumberNormalize */ 2378 2379 decNumber * decNumberReduce(decNumber *res, const decNumber *rhs, 2380 decContext *set) { 2381 #if DECSUBSET 2382 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 2383 #endif 2384 uInt status=0; /* as usual */ 2385 Int residue=0; /* as usual */ 2386 Int dropped; /* work */ 2387 2388 #if DECCHECK 2389 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 2390 #endif 2391 2392 do { /* protect allocated storage */ 2393 #if DECSUBSET 2394 if (!set->extended) { 2395 /* reduce operand and set lostDigits status, as needed */ 2396 if (rhs->digits>set->digits) { 2397 allocrhs=decRoundOperand(rhs, set, &status); 2398 if (allocrhs==NULL) break; 2399 rhs=allocrhs; 2400 } 2401 } 2402 #endif 2403 /* [following code does not require input rounding] */ 2404 2405 /* Infinities copy through; NaNs need usual treatment */ 2406 if (decNumberIsNaN(rhs)) { 2407 decNaNs(res, rhs, NULL, set, &status); 2408 break; 2409 } 2410 2411 /* reduce result to the requested length and copy to result */ 2412 decCopyFit(res, rhs, set, &residue, &status); /* copy & round */ 2413 decFinish(res, set, &residue, &status); /* cleanup/set flags */ 2414 decTrim(res, set, 1, &dropped); /* normalize in place */ 2415 } while(0); /* end protected */ 2416 2417 #if DECSUBSET 2418 if (allocrhs !=NULL) free(allocrhs); /* .. */ 2419 #endif 2420 if (status!=0) decStatus(res, status, set);/* then report status */ 2421 return res; 2422 } /* decNumberReduce */ 2423 2424 /* ------------------------------------------------------------------ */ 2425 /* decNumberRescale -- force exponent to requested value */ 2426 /* */ 2427 /* This computes C = op(A, B), where op adjusts the coefficient */ 2428 /* of C (by rounding or shifting) such that the exponent (-scale) */ 2429 /* of C has the value B. The numerical value of C will equal A, */ 2430 /* except for the effects of any rounding that occurred. */ 2431 /* */ 2432 /* res is C, the result. C may be A or B */ 2433 /* lhs is A, the number to adjust */ 2434 /* rhs is B, the requested exponent */ 2435 /* set is the context */ 2436 /* */ 2437 /* C must have space for set->digits digits. */ 2438 /* */ 2439 /* Unless there is an error or the result is infinite, the exponent */ 2440 /* after the operation is guaranteed to be equal to B. */ 2441 /* ------------------------------------------------------------------ */ 2442 decNumber * decNumberRescale(decNumber *res, const decNumber *lhs, 2443 const decNumber *rhs, decContext *set) { 2444 uInt status=0; /* accumulator */ 2445 decQuantizeOp(res, lhs, rhs, set, 0, &status); 2446 if (status!=0) decStatus(res, status, set); 2447 return res; 2448 } /* decNumberRescale */ 2449 2450 /* ------------------------------------------------------------------ */ 2451 /* decNumberRemainder -- divide and return remainder */ 2452 /* */ 2453 /* This computes C = A % B */ 2454 /* */ 2455 /* res is C, the result. C may be A and/or B (e.g., X=X%X) */ 2456 /* lhs is A */ 2457 /* rhs is B */ 2458 /* set is the context */ 2459 /* */ 2460 /* C must have space for set->digits digits. */ 2461 /* ------------------------------------------------------------------ */ 2462 decNumber * decNumberRemainder(decNumber *res, const decNumber *lhs, 2463 const decNumber *rhs, decContext *set) { 2464 uInt status=0; /* accumulator */ 2465 decDivideOp(res, lhs, rhs, set, REMAINDER, &status); 2466 if (status!=0) decStatus(res, status, set); 2467 #if DECCHECK 2468 decCheckInexact(res, set); 2469 #endif 2470 return res; 2471 } /* decNumberRemainder */ 2472 2473 /* ------------------------------------------------------------------ */ 2474 /* decNumberRemainderNear -- divide and return remainder from nearest */ 2475 /* */ 2476 /* This computes C = A % B, where % is the IEEE remainder operator */ 2477 /* */ 2478 /* res is C, the result. C may be A and/or B (e.g., X=X%X) */ 2479 /* lhs is A */ 2480 /* rhs is B */ 2481 /* set is the context */ 2482 /* */ 2483 /* C must have space for set->digits digits. */ 2484 /* ------------------------------------------------------------------ */ 2485 decNumber * decNumberRemainderNear(decNumber *res, const decNumber *lhs, 2486 const decNumber *rhs, decContext *set) { 2487 uInt status=0; /* accumulator */ 2488 decDivideOp(res, lhs, rhs, set, REMNEAR, &status); 2489 if (status!=0) decStatus(res, status, set); 2490 #if DECCHECK 2491 decCheckInexact(res, set); 2492 #endif 2493 return res; 2494 } /* decNumberRemainderNear */ 2495 2496 /* ------------------------------------------------------------------ */ 2497 /* decNumberRotate -- rotate the coefficient of a Number left/right */ 2498 /* */ 2499 /* This computes C = A rot B (in base ten and rotating set->digits */ 2500 /* digits). */ 2501 /* */ 2502 /* res is C, the result. C may be A and/or B (e.g., X=XrotX) */ 2503 /* lhs is A */ 2504 /* rhs is B, the number of digits to rotate (-ve to right) */ 2505 /* set is the context */ 2506 /* */ 2507 /* The digits of the coefficient of A are rotated to the left (if B */ 2508 /* is positive) or to the right (if B is negative) without adjusting */ 2509 /* the exponent or the sign of A. If lhs->digits is less than */ 2510 /* set->digits the coefficient is padded with zeros on the left */ 2511 /* before the rotate. Any leading zeros in the result are removed */ 2512 /* as usual. */ 2513 /* */ 2514 /* B must be an integer (q=0) and in the range -set->digits through */ 2515 /* +set->digits. */ 2516 /* C must have space for set->digits digits. */ 2517 /* NaNs are propagated as usual. Infinities are unaffected (but */ 2518 /* B must be valid). No status is set unless B is invalid or an */ 2519 /* operand is an sNaN. */ 2520 /* ------------------------------------------------------------------ */ 2521 decNumber * decNumberRotate(decNumber *res, const decNumber *lhs, 2522 const decNumber *rhs, decContext *set) { 2523 uInt status=0; /* accumulator */ 2524 Int rotate; /* rhs as an Int */ 2525 2526 #if DECCHECK 2527 if (decCheckOperands(res, lhs, rhs, set)) return res; 2528 #endif 2529 2530 /* NaNs propagate as normal */ 2531 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) 2532 decNaNs(res, lhs, rhs, set, &status); 2533 /* rhs must be an integer */ 2534 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0) 2535 status=DEC_Invalid_operation; 2536 else { /* both numeric, rhs is an integer */ 2537 rotate=decGetInt(rhs); /* [cannot fail] */ 2538 if (rotate==BADINT /* something bad .. */ 2539 || rotate==BIGODD || rotate==BIGEVEN /* .. very big .. */ 2540 || abs(rotate)>set->digits) /* .. or out of range */ 2541 status=DEC_Invalid_operation; 2542 else { /* rhs is OK */ 2543 decNumberCopy(res, lhs); 2544 /* convert -ve rotate to equivalent positive rotation */ 2545 if (rotate<0) rotate=set->digits+rotate; 2546 if (rotate!=0 && rotate!=set->digits /* zero or full rotation */ 2547 && !decNumberIsInfinite(res)) { /* lhs was infinite */ 2548 /* left-rotate to do; 0 < rotate < set->digits */ 2549 uInt units, shift; /* work */ 2550 uInt msudigits; /* digits in result msu */ 2551 Unit *msu=res->lsu+D2U(res->digits)-1; /* current msu */ 2552 Unit *msumax=res->lsu+D2U(set->digits)-1; /* rotation msu */ 2553 for (msu++; msu<=msumax; msu++) *msu=0; /* ensure high units=0 */ 2554 res->digits=set->digits; /* now full-length */ 2555 msudigits=MSUDIGITS(res->digits); /* actual digits in msu */ 2556 2557 /* rotation here is done in-place, in three steps */ 2558 /* 1. shift all to least up to one unit to unit-align final */ 2559 /* lsd [any digits shifted out are rotated to the left, */ 2560 /* abutted to the original msd (which may require split)] */ 2561 /* */ 2562 /* [if there are no whole units left to rotate, the */ 2563 /* rotation is now complete] */ 2564 /* */ 2565 /* 2. shift to least, from below the split point only, so that */ 2566 /* the final msd is in the right place in its Unit [any */ 2567 /* digits shifted out will fit exactly in the current msu, */ 2568 /* left aligned, no split required] */ 2569 /* */ 2570 /* 3. rotate all the units by reversing left part, right */ 2571 /* part, and then whole */ 2572 /* */ 2573 /* example: rotate right 8 digits (2 units + 2), DECDPUN=3. */ 2574 /* */ 2575 /* start: 00a bcd efg hij klm npq */ 2576 /* */ 2577 /* 1a 000 0ab cde fgh|ijk lmn [pq saved] */ 2578 /* 1b 00p qab cde fgh|ijk lmn */ 2579 /* */ 2580 /* 2a 00p qab cde fgh|00i jkl [mn saved] */ 2581 /* 2b mnp qab cde fgh|00i jkl */ 2582 /* */ 2583 /* 3a fgh cde qab mnp|00i jkl */ 2584 /* 3b fgh cde qab mnp|jkl 00i */ 2585 /* 3c 00i jkl mnp qab cde fgh */ 2586 2587 /* Step 1: amount to shift is the partial right-rotate count */ 2588 rotate=set->digits-rotate; /* make it right-rotate */ 2589 units=rotate/DECDPUN; /* whole units to rotate */ 2590 shift=rotate%DECDPUN; /* left-over digits count */ 2591 if (shift>0) { /* not an exact number of units */ 2592 uInt save=res->lsu[0]%powers[shift]; /* save low digit(s) */ 2593 decShiftToLeast(res->lsu, D2U(res->digits), shift); 2594 if (shift>msudigits) { /* msumax-1 needs >0 digits */ 2595 uInt rem=save%powers[shift-msudigits];/* split save */ 2596 *msumax=(Unit)(save/powers[shift-msudigits]); /* and insert */ 2597 *(msumax-1)=*(msumax-1) 2598 +(Unit)(rem*powers[DECDPUN-(shift-msudigits)]); /* .. */ 2599 } 2600 else { /* all fits in msumax */ 2601 *msumax=*msumax+(Unit)(save*powers[msudigits-shift]); /* [maybe *1] */ 2602 } 2603 } /* digits shift needed */ 2604 2605 /* If whole units to rotate... */ 2606 if (units>0) { /* some to do */ 2607 /* Step 2: the units to touch are the whole ones in rotate, */ 2608 /* if any, and the shift is DECDPUN-msudigits (which may be */ 2609 /* 0, again) */ 2610 shift=DECDPUN-msudigits; 2611 if (shift>0) { /* not an exact number of units */ 2612 uInt save=res->lsu[0]%powers[shift]; /* save low digit(s) */ 2613 decShiftToLeast(res->lsu, units, shift); 2614 *msumax=*msumax+(Unit)(save*powers[msudigits]); 2615 } /* partial shift needed */ 2616 2617 /* Step 3: rotate the units array using triple reverse */ 2618 /* (reversing is easy and fast) */ 2619 decReverse(res->lsu+units, msumax); /* left part */ 2620 decReverse(res->lsu, res->lsu+units-1); /* right part */ 2621 decReverse(res->lsu, msumax); /* whole */ 2622 } /* whole units to rotate */ 2623 /* the rotation may have left an undetermined number of zeros */ 2624 /* on the left, so true length needs to be calculated */ 2625 res->digits=decGetDigits(res->lsu, msumax-res->lsu+1); 2626 } /* rotate needed */ 2627 } /* rhs OK */ 2628 } /* numerics */ 2629 if (status!=0) decStatus(res, status, set); 2630 return res; 2631 } /* decNumberRotate */ 2632 2633 /* ------------------------------------------------------------------ */ 2634 /* decNumberSameQuantum -- test for equal exponents */ 2635 /* */ 2636 /* res is the result number, which will contain either 0 or 1 */ 2637 /* lhs is a number to test */ 2638 /* rhs is the second (usually a pattern) */ 2639 /* */ 2640 /* No errors are possible and no context is needed. */ 2641 /* ------------------------------------------------------------------ */ 2642 decNumber * decNumberSameQuantum(decNumber *res, const decNumber *lhs, 2643 const decNumber *rhs) { 2644 Unit ret=0; /* return value */ 2645 2646 #if DECCHECK 2647 if (decCheckOperands(res, lhs, rhs, DECUNCONT)) return res; 2648 #endif 2649 2650 if (SPECIALARGS) { 2651 if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1; 2652 else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1; 2653 /* [anything else with a special gives 0] */ 2654 } 2655 else if (lhs->exponent==rhs->exponent) ret=1; 2656 2657 decNumberZero(res); /* OK to overwrite an operand now */ 2658 *res->lsu=ret; 2659 return res; 2660 } /* decNumberSameQuantum */ 2661 2662 /* ------------------------------------------------------------------ */ 2663 /* decNumberScaleB -- multiply by a power of 10 */ 2664 /* */ 2665 /* This computes C = A x 10**B where B is an integer (q=0) with */ 2666 /* maximum magnitude 2*(emax+digits) */ 2667 /* */ 2668 /* res is C, the result. C may be A or B */ 2669 /* lhs is A, the number to adjust */ 2670 /* rhs is B, the requested power of ten to use */ 2671 /* set is the context */ 2672 /* */ 2673 /* C must have space for set->digits digits. */ 2674 /* */ 2675 /* The result may underflow or overflow. */ 2676 /* ------------------------------------------------------------------ */ 2677 decNumber * decNumberScaleB(decNumber *res, const decNumber *lhs, 2678 const decNumber *rhs, decContext *set) { 2679 Int reqexp; /* requested exponent change [B] */ 2680 uInt status=0; /* accumulator */ 2681 Int residue; /* work */ 2682 2683 #if DECCHECK 2684 if (decCheckOperands(res, lhs, rhs, set)) return res; 2685 #endif 2686 2687 /* Handle special values except lhs infinite */ 2688 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) 2689 decNaNs(res, lhs, rhs, set, &status); 2690 /* rhs must be an integer */ 2691 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0) 2692 status=DEC_Invalid_operation; 2693 else { 2694 /* lhs is a number; rhs is a finite with q==0 */ 2695 reqexp=decGetInt(rhs); /* [cannot fail] */ 2696 if (reqexp==BADINT /* something bad .. */ 2697 || reqexp==BIGODD || reqexp==BIGEVEN /* .. very big .. */ 2698 || abs(reqexp)>(2*(set->digits+set->emax))) /* .. or out of range */ 2699 status=DEC_Invalid_operation; 2700 else { /* rhs is OK */ 2701 decNumberCopy(res, lhs); /* all done if infinite lhs */ 2702 if (!decNumberIsInfinite(res)) { /* prepare to scale */ 2703 res->exponent+=reqexp; /* adjust the exponent */ 2704 residue=0; 2705 decFinalize(res, set, &residue, &status); /* .. and check */ 2706 } /* finite LHS */ 2707 } /* rhs OK */ 2708 } /* rhs finite */ 2709 if (status!=0) decStatus(res, status, set); 2710 return res; 2711 } /* decNumberScaleB */ 2712 2713 /* ------------------------------------------------------------------ */ 2714 /* decNumberShift -- shift the coefficient of a Number left or right */ 2715 /* */ 2716 /* This computes C = A << B or C = A >> -B (in base ten). */ 2717 /* */ 2718 /* res is C, the result. C may be A and/or B (e.g., X=X<<X) */ 2719 /* lhs is A */ 2720 /* rhs is B, the number of digits to shift (-ve to right) */ 2721 /* set is the context */ 2722 /* */ 2723 /* The digits of the coefficient of A are shifted to the left (if B */ 2724 /* is positive) or to the right (if B is negative) without adjusting */ 2725 /* the exponent or the sign of A. */ 2726 /* */ 2727 /* B must be an integer (q=0) and in the range -set->digits through */ 2728 /* +set->digits. */ 2729 /* C must have space for set->digits digits. */ 2730 /* NaNs are propagated as usual. Infinities are unaffected (but */ 2731 /* B must be valid). No status is set unless B is invalid or an */ 2732 /* operand is an sNaN. */ 2733 /* ------------------------------------------------------------------ */ 2734 decNumber * decNumberShift(decNumber *res, const decNumber *lhs, 2735 const decNumber *rhs, decContext *set) { 2736 uInt status=0; /* accumulator */ 2737 Int shift; /* rhs as an Int */ 2738 2739 #if DECCHECK 2740 if (decCheckOperands(res, lhs, rhs, set)) return res; 2741 #endif 2742 2743 /* NaNs propagate as normal */ 2744 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) 2745 decNaNs(res, lhs, rhs, set, &status); 2746 /* rhs must be an integer */ 2747 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0) 2748 status=DEC_Invalid_operation; 2749 else { /* both numeric, rhs is an integer */ 2750 shift=decGetInt(rhs); /* [cannot fail] */ 2751 if (shift==BADINT /* something bad .. */ 2752 || shift==BIGODD || shift==BIGEVEN /* .. very big .. */ 2753 || abs(shift)>set->digits) /* .. or out of range */ 2754 status=DEC_Invalid_operation; 2755 else { /* rhs is OK */ 2756 decNumberCopy(res, lhs); 2757 if (shift!=0 && !decNumberIsInfinite(res)) { /* something to do */ 2758 if (shift>0) { /* to left */ 2759 if (shift==set->digits) { /* removing all */ 2760 *res->lsu=0; /* so place 0 */ 2761 res->digits=1; /* .. */ 2762 } 2763 else { /* */ 2764 /* first remove leading digits if necessary */ 2765 if (res->digits+shift>set->digits) { 2766 decDecap(res, res->digits+shift-set->digits); 2767 /* that updated res->digits; may have gone to 1 (for a */ 2768 /* single digit or for zero */ 2769 } 2770 if (res->digits>1 || *res->lsu) /* if non-zero.. */ 2771 res->digits=decShiftToMost(res->lsu, res->digits, shift); 2772 } /* partial left */ 2773 } /* left */ 2774 else { /* to right */ 2775 if (-shift>=res->digits) { /* discarding all */ 2776 *res->lsu=0; /* so place 0 */ 2777 res->digits=1; /* .. */ 2778 } 2779 else { 2780 decShiftToLeast(res->lsu, D2U(res->digits), -shift); 2781 res->digits-=(-shift); 2782 } 2783 } /* to right */ 2784 } /* non-0 non-Inf shift */ 2785 } /* rhs OK */ 2786 } /* numerics */ 2787 if (status!=0) decStatus(res, status, set); 2788 return res; 2789 } /* decNumberShift */ 2790 2791 /* ------------------------------------------------------------------ */ 2792 /* decNumberSquareRoot -- square root operator */ 2793 /* */ 2794 /* This computes C = squareroot(A) */ 2795 /* */ 2796 /* res is C, the result. C may be A */ 2797 /* rhs is A */ 2798 /* set is the context; note that rounding mode has no effect */ 2799 /* */ 2800 /* C must have space for set->digits digits. */ 2801 /* ------------------------------------------------------------------ */ 2802 /* This uses the following varying-precision algorithm in: */ 2803 /* */ 2804 /* Properly Rounded Variable Precision Square Root, T. E. Hull and */ 2805 /* A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, */ 2806 /* pp229-237, ACM, September 1985. */ 2807 /* */ 2808 /* The square-root is calculated using Newton's method, after which */ 2809 /* a check is made to ensure the result is correctly rounded. */ 2810 /* */ 2811 /* % [Reformatted original Numerical Turing source code follows.] */ 2812 /* function sqrt(x : real) : real */ 2813 /* % sqrt(x) returns the properly rounded approximation to the square */ 2814 /* % root of x, in the precision of the calling environment, or it */ 2815 /* % fails if x < 0. */ 2816 /* % t e hull and a abrham, august, 1984 */ 2817 /* if x <= 0 then */ 2818 /* if x < 0 then */ 2819 /* assert false */ 2820 /* else */ 2821 /* result 0 */ 2822 /* end if */ 2823 /* end if */ 2824 /* var f := setexp(x, 0) % fraction part of x [0.1 <= x < 1] */ 2825 /* var e := getexp(x) % exponent part of x */ 2826 /* var approx : real */ 2827 /* if e mod 2 = 0 then */ 2828 /* approx := .259 + .819 * f % approx to root of f */ 2829 /* else */ 2830 /* f := f/l0 % adjustments */ 2831 /* e := e + 1 % for odd */ 2832 /* approx := .0819 + 2.59 * f % exponent */ 2833 /* end if */ 2834 /* */ 2835 /* var p:= 3 */ 2836 /* const maxp := currentprecision + 2 */ 2837 /* loop */ 2838 /* p := min(2*p - 2, maxp) % p = 4,6,10, . . . , maxp */ 2839 /* precision p */ 2840 /* approx := .5 * (approx + f/approx) */ 2841 /* exit when p = maxp */ 2842 /* end loop */ 2843 /* */ 2844 /* % approx is now within 1 ulp of the properly rounded square root */ 2845 /* % of f; to ensure proper rounding, compare squares of (approx - */ 2846 /* % l/2 ulp) and (approx + l/2 ulp) with f. */ 2847 /* p := currentprecision */ 2848 /* begin */ 2849 /* precision p + 2 */ 2850 /* const approxsubhalf := approx - setexp(.5, -p) */ 2851 /* if mulru(approxsubhalf, approxsubhalf) > f then */ 2852 /* approx := approx - setexp(.l, -p + 1) */ 2853 /* else */ 2854 /* const approxaddhalf := approx + setexp(.5, -p) */ 2855 /* if mulrd(approxaddhalf, approxaddhalf) < f then */ 2856 /* approx := approx + setexp(.l, -p + 1) */ 2857 /* end if */ 2858 /* end if */ 2859 /* end */ 2860 /* result setexp(approx, e div 2) % fix exponent */ 2861 /* end sqrt */ 2862 /* ------------------------------------------------------------------ */ 2863 decNumber * decNumberSquareRoot(decNumber *res, const decNumber *rhs, 2864 decContext *set) { 2865 decContext workset, approxset; /* work contexts */ 2866 decNumber dzero; /* used for constant zero */ 2867 Int maxp; /* largest working precision */ 2868 Int workp; /* working precision */ 2869 Int residue=0; /* rounding residue */ 2870 uInt status=0, ignore=0; /* status accumulators */ 2871 uInt rstatus; /* .. */ 2872 Int exp; /* working exponent */ 2873 Int ideal; /* ideal (preferred) exponent */ 2874 Int needbytes; /* work */ 2875 Int dropped; /* .. */ 2876 2877 #if DECSUBSET 2878 decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */ 2879 #endif 2880 /* buffer for f [needs +1 in case DECBUFFER 0] */ 2881 decNumber buff[D2N(DECBUFFER+1)]; 2882 /* buffer for a [needs +2 to match likely maxp] */ 2883 decNumber bufa[D2N(DECBUFFER+2)]; 2884 /* buffer for temporary, b [must be same size as a] */ 2885 decNumber bufb[D2N(DECBUFFER+2)]; 2886 decNumber *allocbuff=NULL; /* -> allocated buff, iff allocated */ 2887 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 2888 decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */ 2889 decNumber *f=buff; /* reduced fraction */ 2890 decNumber *a=bufa; /* approximation to result */ 2891 decNumber *b=bufb; /* intermediate result */ 2892 /* buffer for temporary variable, up to 3 digits */ 2893 decNumber buft[D2N(3)]; 2894 decNumber *t=buft; /* up-to-3-digit constant or work */ 2895 2896 #if DECCHECK 2897 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 2898 #endif 2899 2900 do { /* protect allocated storage */ 2901 #if DECSUBSET 2902 if (!set->extended) { 2903 /* reduce operand and set lostDigits status, as needed */ 2904 if (rhs->digits>set->digits) { 2905 allocrhs=decRoundOperand(rhs, set, &status); 2906 if (allocrhs==NULL) break; 2907 /* [Note: 'f' allocation below could reuse this buffer if */ 2908 /* used, but as this is rare they are kept separate for clarity.] */ 2909 rhs=allocrhs; 2910 } 2911 } 2912 #endif 2913 /* [following code does not require input rounding] */ 2914 2915 /* handle infinities and NaNs */ 2916 if (SPECIALARG) { 2917 if (decNumberIsInfinite(rhs)) { /* an infinity */ 2918 if (decNumberIsNegative(rhs)) status|=DEC_Invalid_operation; 2919 else decNumberCopy(res, rhs); /* +Infinity */ 2920 } 2921 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */ 2922 break; 2923 } 2924 2925 /* calculate the ideal (preferred) exponent [floor(exp/2)] */ 2926 /* [We would like to write: ideal=rhs->exponent>>1, but this */ 2927 /* generates a compiler warning. Generated code is the same.] */ 2928 ideal=(rhs->exponent&~1)/2; /* target */ 2929 2930 /* handle zeros */ 2931 if (ISZERO(rhs)) { 2932 decNumberCopy(res, rhs); /* could be 0 or -0 */ 2933 res->exponent=ideal; /* use the ideal [safe] */ 2934 /* use decFinish to clamp any out-of-range exponent, etc. */ 2935 decFinish(res, set, &residue, &status); 2936 break; 2937 } 2938 2939 /* any other -x is an oops */ 2940 if (decNumberIsNegative(rhs)) { 2941 status|=DEC_Invalid_operation; 2942 break; 2943 } 2944 2945 /* space is needed for three working variables */ 2946 /* f -- the same precision as the RHS, reduced to 0.01->0.99... */ 2947 /* a -- Hull's approximation -- precision, when assigned, is */ 2948 /* currentprecision+1 or the input argument precision, */ 2949 /* whichever is larger (+2 for use as temporary) */ 2950 /* b -- intermediate temporary result (same size as a) */ 2951 /* if any is too long for local storage, then allocate */ 2952 workp=MAXI(set->digits+1, rhs->digits); /* actual rounding precision */ 2953 maxp=workp+2; /* largest working precision */ 2954 2955 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); 2956 if (needbytes>(Int)sizeof(buff)) { 2957 allocbuff=(decNumber *)malloc(needbytes); 2958 if (allocbuff==NULL) { /* hopeless -- abandon */ 2959 status|=DEC_Insufficient_storage; 2960 break;} 2961 f=allocbuff; /* use the allocated space */ 2962 } 2963 /* a and b both need to be able to hold a maxp-length number */ 2964 needbytes=sizeof(decNumber)+(D2U(maxp)-1)*sizeof(Unit); 2965 if (needbytes>(Int)sizeof(bufa)) { /* [same applies to b] */ 2966 allocbufa=(decNumber *)malloc(needbytes); 2967 allocbufb=(decNumber *)malloc(needbytes); 2968 if (allocbufa==NULL || allocbufb==NULL) { /* hopeless */ 2969 status|=DEC_Insufficient_storage; 2970 break;} 2971 a=allocbufa; /* use the allocated spaces */ 2972 b=allocbufb; /* .. */ 2973 } 2974 2975 /* copy rhs -> f, save exponent, and reduce so 0.1 <= f < 1 */ 2976 decNumberCopy(f, rhs); 2977 exp=f->exponent+f->digits; /* adjusted to Hull rules */ 2978 f->exponent=-(f->digits); /* to range */ 2979 2980 /* set up working context */ 2981 decContextDefault(&workset, DEC_INIT_DECIMAL64); 2982 2983 /* [Until further notice, no error is possible and status bits */ 2984 /* (Rounded, etc.) should be ignored, not accumulated.] */ 2985 2986 /* Calculate initial approximation, and allow for odd exponent */ 2987 workset.digits=workp; /* p for initial calculation */ 2988 t->bits=0; t->digits=3; 2989 a->bits=0; a->digits=3; 2990 if ((exp & 1)==0) { /* even exponent */ 2991 /* Set t=0.259, a=0.819 */ 2992 t->exponent=-3; 2993 a->exponent=-3; 2994 #if DECDPUN>=3 2995 t->lsu[0]=259; 2996 a->lsu[0]=819; 2997 #elif DECDPUN==2 2998 t->lsu[0]=59; t->lsu[1]=2; 2999 a->lsu[0]=19; a->lsu[1]=8; 3000 #else 3001 t->lsu[0]=9; t->lsu[1]=5; t->lsu[2]=2; 3002 a->lsu[0]=9; a->lsu[1]=1; a->lsu[2]=8; 3003 #endif 3004 } 3005 else { /* odd exponent */ 3006 /* Set t=0.0819, a=2.59 */ 3007 f->exponent--; /* f=f/10 */ 3008 exp++; /* e=e+1 */ 3009 t->exponent=-4; 3010 a->exponent=-2; 3011 #if DECDPUN>=3 3012 t->lsu[0]=819; 3013 a->lsu[0]=259; 3014 #elif DECDPUN==2 3015 t->lsu[0]=19; t->lsu[1]=8; 3016 a->lsu[0]=59; a->lsu[1]=2; 3017 #else 3018 t->lsu[0]=9; t->lsu[1]=1; t->lsu[2]=8; 3019 a->lsu[0]=9; a->lsu[1]=5; a->lsu[2]=2; 3020 #endif 3021 } 3022 decMultiplyOp(a, a, f, &workset, &ignore); /* a=a*f */ 3023 decAddOp(a, a, t, &workset, 0, &ignore); /* ..+t */ 3024 /* [a is now the initial approximation for sqrt(f), calculated with */ 3025 /* currentprecision, which is also a's precision.] */ 3026 3027 /* the main calculation loop */ 3028 decNumberZero(&dzero); /* make 0 */ 3029 decNumberZero(t); /* set t = 0.5 */ 3030 t->lsu[0]=5; /* .. */ 3031 t->exponent=-1; /* .. */ 3032 workset.digits=3; /* initial p */ 3033 for (;;) { 3034 /* set p to min(2*p - 2, maxp) [hence 3; or: 4, 6, 10, ... , maxp] */ 3035 workset.digits=workset.digits*2-2; 3036 if (workset.digits>maxp) workset.digits=maxp; 3037 /* a = 0.5 * (a + f/a) */ 3038 /* [calculated at p then rounded to currentprecision] */ 3039 decDivideOp(b, f, a, &workset, DIVIDE, &ignore); /* b=f/a */ 3040 decAddOp(b, b, a, &workset, 0, &ignore); /* b=b+a */ 3041 decMultiplyOp(a, b, t, &workset, &ignore); /* a=b*0.5 */ 3042 if (a->digits==maxp) break; /* have required digits */ 3043 } /* loop */ 3044 3045 /* Here, 0.1 <= a < 1 [Hull], and a has maxp digits */ 3046 /* now reduce to length, etc.; this needs to be done with a */ 3047 /* having the correct exponent so as to handle subnormals */ 3048 /* correctly */ 3049 approxset=*set; /* get emin, emax, etc. */ 3050 approxset.round=DEC_ROUND_HALF_EVEN; 3051 a->exponent+=exp/2; /* set correct exponent */ 3052 3053 rstatus=0; /* clear status */ 3054 residue=0; /* .. and accumulator */ 3055 decCopyFit(a, a, &approxset, &residue, &rstatus); /* reduce (if needed) */ 3056 decFinish(a, &approxset, &residue, &rstatus); /* clean and finalize */ 3057 3058 /* Overflow was possible if the input exponent was out-of-range, */ 3059 /* in which case quit */ 3060 if (rstatus&DEC_Overflow) { 3061 status=rstatus; /* use the status as-is */ 3062 decNumberCopy(res, a); /* copy to result */ 3063 break; 3064 } 3065 3066 /* Preserve status except Inexact/Rounded */ 3067 status|=(rstatus & ~(DEC_Rounded|DEC_Inexact)); 3068 3069 /* Carry out the Hull correction */ 3070 a->exponent-=exp/2; /* back to 0.1->1 */ 3071 3072 /* a is now at final precision and within 1 ulp of the properly */ 3073 /* rounded square root of f; to ensure proper rounding, compare */ 3074 /* squares of (a - l/2 ulp) and (a + l/2 ulp) with f. */ 3075 /* Here workset.digits=maxp and t=0.5, and a->digits determines */ 3076 /* the ulp */ 3077 workset.digits--; /* maxp-1 is OK now */ 3078 t->exponent=-a->digits-1; /* make 0.5 ulp */ 3079 decAddOp(b, a, t, &workset, DECNEG, &ignore); /* b = a - 0.5 ulp */ 3080 workset.round=DEC_ROUND_UP; 3081 decMultiplyOp(b, b, b, &workset, &ignore); /* b = mulru(b, b) */ 3082 decCompareOp(b, f, b, &workset, COMPARE, &ignore); /* b ? f, reversed */ 3083 if (decNumberIsNegative(b)) { /* f < b [i.e., b > f] */ 3084 /* this is the more common adjustment, though both are rare */ 3085 t->exponent++; /* make 1.0 ulp */ 3086 t->lsu[0]=1; /* .. */ 3087 decAddOp(a, a, t, &workset, DECNEG, &ignore); /* a = a - 1 ulp */ 3088 /* assign to approx [round to length] */ 3089 approxset.emin-=exp/2; /* adjust to match a */ 3090 approxset.emax-=exp/2; 3091 decAddOp(a, &dzero, a, &approxset, 0, &ignore); 3092 } 3093 else { 3094 decAddOp(b, a, t, &workset, 0, &ignore); /* b = a + 0.5 ulp */ 3095 workset.round=DEC_ROUND_DOWN; 3096 decMultiplyOp(b, b, b, &workset, &ignore); /* b = mulrd(b, b) */ 3097 decCompareOp(b, b, f, &workset, COMPARE, &ignore); /* b ? f */ 3098 if (decNumberIsNegative(b)) { /* b < f */ 3099 t->exponent++; /* make 1.0 ulp */ 3100 t->lsu[0]=1; /* .. */ 3101 decAddOp(a, a, t, &workset, 0, &ignore); /* a = a + 1 ulp */ 3102 /* assign to approx [round to length] */ 3103 approxset.emin-=exp/2; /* adjust to match a */ 3104 approxset.emax-=exp/2; 3105 decAddOp(a, &dzero, a, &approxset, 0, &ignore); 3106 } 3107 } 3108 /* [no errors are possible in the above, and rounding/inexact during */ 3109 /* estimation are irrelevant, so status was not accumulated] */ 3110 3111 /* Here, 0.1 <= a < 1 (still), so adjust back */ 3112 a->exponent+=exp/2; /* set correct exponent */ 3113 3114 /* count droppable zeros [after any subnormal rounding] by */ 3115 /* trimming a copy */ 3116 decNumberCopy(b, a); 3117 decTrim(b, set, 1, &dropped); /* [drops trailing zeros] */ 3118 3119 /* Set Inexact and Rounded. The answer can only be exact if */ 3120 /* it is short enough so that squaring it could fit in workp digits, */ 3121 /* and it cannot have trailing zeros due to clamping, so these are */ 3122 /* the only (relatively rare) conditions a careful check is needed */ 3123 if (b->digits*2-1 > workp && !set->clamp) { /* cannot fit */ 3124 status|=DEC_Inexact|DEC_Rounded; 3125 } 3126 else { /* could be exact/unrounded */ 3127 uInt mstatus=0; /* local status */ 3128 decMultiplyOp(b, b, b, &workset, &mstatus); /* try the multiply */ 3129 if (mstatus&DEC_Overflow) { /* result just won't fit */ 3130 status|=DEC_Inexact|DEC_Rounded; 3131 } 3132 else { /* plausible */ 3133 decCompareOp(t, b, rhs, &workset, COMPARE, &mstatus); /* b ? rhs */ 3134 if (!ISZERO(t)) status|=DEC_Inexact|DEC_Rounded; /* not equal */ 3135 else { /* is Exact */ 3136 /* here, dropped is the count of trailing zeros in 'a' */ 3137 /* use closest exponent to ideal... */ 3138 Int todrop=ideal-a->exponent; /* most that can be dropped */ 3139 if (todrop<0) status|=DEC_Rounded; /* ideally would add 0s */ 3140 else { /* unrounded */ 3141 if (dropped<todrop) { /* clamp to those available */ 3142 todrop=dropped; 3143 status|=DEC_Clamped; 3144 } 3145 if (todrop>0) { /* have some to drop */ 3146 decShiftToLeast(a->lsu, D2U(a->digits), todrop); 3147 a->exponent+=todrop; /* maintain numerical value */ 3148 a->digits-=todrop; /* new length */ 3149 } 3150 } 3151 } 3152 } 3153 } 3154 3155 /* double-check Underflow, as perhaps the result could not have */ 3156 /* been subnormal (initial argument too big), or it is now Exact */ 3157 if (status&DEC_Underflow) { 3158 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */ 3159 /* check if truly subnormal */ 3160 #if DECEXTFLAG /* DEC_Subnormal too */ 3161 if (ae>=set->emin*2) status&=~(DEC_Subnormal|DEC_Underflow); 3162 #else 3163 if (ae>=set->emin*2) status&=~DEC_Underflow; 3164 #endif 3165 /* check if truly inexact */ 3166 if (!(status&DEC_Inexact)) status&=~DEC_Underflow; 3167 } 3168 3169 decNumberCopy(res, a); /* a is now the result */ 3170 } while(0); /* end protected */ 3171 3172 if (allocbuff!=NULL) free(allocbuff); /* drop any storage used */ 3173 if (allocbufa!=NULL) free(allocbufa); /* .. */ 3174 if (allocbufb!=NULL) free(allocbufb); /* .. */ 3175 #if DECSUBSET 3176 if (allocrhs !=NULL) free(allocrhs); /* .. */ 3177 #endif 3178 if (status!=0) decStatus(res, status, set);/* then report status */ 3179 #if DECCHECK 3180 decCheckInexact(res, set); 3181 #endif 3182 return res; 3183 } /* decNumberSquareRoot */ 3184 3185 /* ------------------------------------------------------------------ */ 3186 /* decNumberSubtract -- subtract two Numbers */ 3187 /* */ 3188 /* This computes C = A - B */ 3189 /* */ 3190 /* res is C, the result. C may be A and/or B (e.g., X=X-X) */ 3191 /* lhs is A */ 3192 /* rhs is B */ 3193 /* set is the context */ 3194 /* */ 3195 /* C must have space for set->digits digits. */ 3196 /* ------------------------------------------------------------------ */ 3197 decNumber * decNumberSubtract(decNumber *res, const decNumber *lhs, 3198 const decNumber *rhs, decContext *set) { 3199 uInt status=0; /* accumulator */ 3200 3201 decAddOp(res, lhs, rhs, set, DECNEG, &status); 3202 if (status!=0) decStatus(res, status, set); 3203 #if DECCHECK 3204 decCheckInexact(res, set); 3205 #endif 3206 return res; 3207 } /* decNumberSubtract */ 3208 3209 /* ------------------------------------------------------------------ */ 3210 /* decNumberToIntegralExact -- round-to-integral-value with InExact */ 3211 /* decNumberToIntegralValue -- round-to-integral-value */ 3212 /* */ 3213 /* res is the result */ 3214 /* rhs is input number */ 3215 /* set is the context */ 3216 /* */ 3217 /* res must have space for any value of rhs. */ 3218 /* */ 3219 /* This implements the IEEE special operators and therefore treats */ 3220 /* special values as valid. For finite numbers it returns */ 3221 /* rescale(rhs, 0) if rhs->exponent is <0. */ 3222 /* Otherwise the result is rhs (so no error is possible, except for */ 3223 /* sNaN). */ 3224 /* */ 3225 /* The context is used for rounding mode and status after sNaN, but */ 3226 /* the digits setting is ignored. The Exact version will signal */ 3227 /* Inexact if the result differs numerically from rhs; the other */ 3228 /* never signals Inexact. */ 3229 /* ------------------------------------------------------------------ */ 3230 decNumber * decNumberToIntegralExact(decNumber *res, const decNumber *rhs, 3231 decContext *set) { 3232 decNumber dn; 3233 decContext workset; /* working context */ 3234 uInt status=0; /* accumulator */ 3235 3236 #if DECCHECK 3237 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 3238 #endif 3239 3240 /* handle infinities and NaNs */ 3241 if (SPECIALARG) { 3242 if (decNumberIsInfinite(rhs)) decNumberCopy(res, rhs); /* an Infinity */ 3243 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */ 3244 } 3245 else { /* finite */ 3246 /* have a finite number; no error possible (res must be big enough) */ 3247 if (rhs->exponent>=0) return decNumberCopy(res, rhs); 3248 /* that was easy, but if negative exponent there is work to do... */ 3249 workset=*set; /* clone rounding, etc. */ 3250 workset.digits=rhs->digits; /* no length rounding */ 3251 workset.traps=0; /* no traps */ 3252 decNumberZero(&dn); /* make a number with exponent 0 */ 3253 decNumberQuantize(res, rhs, &dn, &workset); 3254 status|=workset.status; 3255 } 3256 if (status!=0) decStatus(res, status, set); 3257 return res; 3258 } /* decNumberToIntegralExact */ 3259 3260 decNumber * decNumberToIntegralValue(decNumber *res, const decNumber *rhs, 3261 decContext *set) { 3262 decContext workset=*set; /* working context */ 3263 workset.traps=0; /* no traps */ 3264 decNumberToIntegralExact(res, rhs, &workset); 3265 /* this never affects set, except for sNaNs; NaN will have been set */ 3266 /* or propagated already, so no need to call decStatus */ 3267 set->status|=workset.status&DEC_Invalid_operation; 3268 return res; 3269 } /* decNumberToIntegralValue */ 3270 3271 /* ------------------------------------------------------------------ */ 3272 /* decNumberXor -- XOR two Numbers, digitwise */ 3273 /* */ 3274 /* This computes C = A ^ B */ 3275 /* */ 3276 /* res is C, the result. C may be A and/or B (e.g., X=X^X) */ 3277 /* lhs is A */ 3278 /* rhs is B */ 3279 /* set is the context (used for result length and error report) */ 3280 /* */ 3281 /* C must have space for set->digits digits. */ 3282 /* */ 3283 /* Logical function restrictions apply (see above); a NaN is */ 3284 /* returned with Invalid_operation if a restriction is violated. */ 3285 /* ------------------------------------------------------------------ */ 3286 decNumber * decNumberXor(decNumber *res, const decNumber *lhs, 3287 const decNumber *rhs, decContext *set) { 3288 const Unit *ua, *ub; /* -> operands */ 3289 const Unit *msua, *msub; /* -> operand msus */ 3290 Unit *uc, *msuc; /* -> result and its msu */ 3291 Int msudigs; /* digits in res msu */ 3292 #if DECCHECK 3293 if (decCheckOperands(res, lhs, rhs, set)) return res; 3294 #endif 3295 3296 if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs) 3297 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { 3298 decStatus(res, DEC_Invalid_operation, set); 3299 return res; 3300 } 3301 /* operands are valid */ 3302 ua=lhs->lsu; /* bottom-up */ 3303 ub=rhs->lsu; /* .. */ 3304 uc=res->lsu; /* .. */ 3305 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */ 3306 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ 3307 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ 3308 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ 3309 for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */ 3310 Unit a, b; /* extract units */ 3311 if (ua>msua) a=0; 3312 else a=*ua; 3313 if (ub>msub) b=0; 3314 else b=*ub; 3315 *uc=0; /* can now write back */ 3316 if (a|b) { /* maybe 1 bits to examine */ 3317 Int i, j; 3318 /* This loop could be unrolled and/or use BIN2BCD tables */ 3319 for (i=0; i<DECDPUN; i++) { 3320 if ((a^b)&1) *uc=*uc+(Unit)powers[i]; /* effect XOR */ 3321 j=a%10; 3322 a=a/10; 3323 j|=b%10; 3324 b=b/10; 3325 if (j>1) { 3326 decStatus(res, DEC_Invalid_operation, set); 3327 return res; 3328 } 3329 if (uc==msuc && i==msudigs-1) break; /* just did final digit */ 3330 } /* each digit */ 3331 } /* non-zero */ 3332 } /* each unit */ 3333 /* [here uc-1 is the msu of the result] */ 3334 res->digits=decGetDigits(res->lsu, uc-res->lsu); 3335 res->exponent=0; /* integer */ 3336 res->bits=0; /* sign=0 */ 3337 return res; /* [no status to set] */ 3338 } /* decNumberXor */ 3339 3340 3341 /* ================================================================== */ 3342 /* Utility routines */ 3343 /* ================================================================== */ 3344 3345 /* ------------------------------------------------------------------ */ 3346 /* decNumberClass -- return the decClass of a decNumber */ 3347 /* dn -- the decNumber to test */ 3348 /* set -- the context to use for Emin */ 3349 /* returns the decClass enum */ 3350 /* ------------------------------------------------------------------ */ 3351 enum decClass decNumberClass(const decNumber *dn, decContext *set) { 3352 if (decNumberIsSpecial(dn)) { 3353 if (decNumberIsQNaN(dn)) return DEC_CLASS_QNAN; 3354 if (decNumberIsSNaN(dn)) return DEC_CLASS_SNAN; 3355 /* must be an infinity */ 3356 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_INF; 3357 return DEC_CLASS_POS_INF; 3358 } 3359 /* is finite */ 3360 if (decNumberIsNormal(dn, set)) { /* most common */ 3361 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_NORMAL; 3362 return DEC_CLASS_POS_NORMAL; 3363 } 3364 /* is subnormal or zero */ 3365 if (decNumberIsZero(dn)) { /* most common */ 3366 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_ZERO; 3367 return DEC_CLASS_POS_ZERO; 3368 } 3369 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_SUBNORMAL; 3370 return DEC_CLASS_POS_SUBNORMAL; 3371 } /* decNumberClass */ 3372 3373 /* ------------------------------------------------------------------ */ 3374 /* decNumberClassToString -- convert decClass to a string */ 3375 /* */ 3376 /* eclass is a valid decClass */ 3377 /* returns a constant string describing the class (max 13+1 chars) */ 3378 /* ------------------------------------------------------------------ */ 3379 const char *decNumberClassToString(enum decClass eclass) { 3380 if (eclass==DEC_CLASS_POS_NORMAL) return DEC_ClassString_PN; 3381 if (eclass==DEC_CLASS_NEG_NORMAL) return DEC_ClassString_NN; 3382 if (eclass==DEC_CLASS_POS_ZERO) return DEC_ClassString_PZ; 3383 if (eclass==DEC_CLASS_NEG_ZERO) return DEC_ClassString_NZ; 3384 if (eclass==DEC_CLASS_POS_SUBNORMAL) return DEC_ClassString_PS; 3385 if (eclass==DEC_CLASS_NEG_SUBNORMAL) return DEC_ClassString_NS; 3386 if (eclass==DEC_CLASS_POS_INF) return DEC_ClassString_PI; 3387 if (eclass==DEC_CLASS_NEG_INF) return DEC_ClassString_NI; 3388 if (eclass==DEC_CLASS_QNAN) return DEC_ClassString_QN; 3389 if (eclass==DEC_CLASS_SNAN) return DEC_ClassString_SN; 3390 return DEC_ClassString_UN; /* Unknown */ 3391 } /* decNumberClassToString */ 3392 3393 /* ------------------------------------------------------------------ */ 3394 /* decNumberCopy -- copy a number */ 3395 /* */ 3396 /* dest is the target decNumber */ 3397 /* src is the source decNumber */ 3398 /* returns dest */ 3399 /* */ 3400 /* (dest==src is allowed and is a no-op) */ 3401 /* All fields are updated as required. This is a utility operation, */ 3402 /* so special values are unchanged and no error is possible. */ 3403 /* ------------------------------------------------------------------ */ 3404 decNumber * decNumberCopy(decNumber *dest, const decNumber *src) { 3405 3406 #if DECCHECK 3407 if (src==NULL) return decNumberZero(dest); 3408 #endif 3409 3410 if (dest==src) return dest; /* no copy required */ 3411 3412 /* Use explicit assignments here as structure assignment could copy */ 3413 /* more than just the lsu (for small DECDPUN). This would not affect */ 3414 /* the value of the results, but could disturb test harness spill */ 3415 /* checking. */ 3416 dest->bits=src->bits; 3417 dest->exponent=src->exponent; 3418 dest->digits=src->digits; 3419 dest->lsu[0]=src->lsu[0]; 3420 if (src->digits>DECDPUN) { /* more Units to come */ 3421 const Unit *smsup, *s; /* work */ 3422 Unit *d; /* .. */ 3423 /* memcpy for the remaining Units would be safe as they cannot */ 3424 /* overlap. However, this explicit loop is faster in short cases. */ 3425 d=dest->lsu+1; /* -> first destination */ 3426 smsup=src->lsu+D2U(src->digits); /* -> source msu+1 */ 3427 for (s=src->lsu+1; s<smsup; s++, d++) *d=*s; 3428 } 3429 return dest; 3430 } /* decNumberCopy */ 3431 3432 /* ------------------------------------------------------------------ */ 3433 /* decNumberCopyAbs -- quiet absolute value operator */ 3434 /* */ 3435 /* This sets C = abs(A) */ 3436 /* */ 3437 /* res is C, the result. C may be A */ 3438 /* rhs is A */ 3439 /* */ 3440 /* C must have space for set->digits digits. */ 3441 /* No exception or error can occur; this is a quiet bitwise operation.*/ 3442 /* See also decNumberAbs for a checking version of this. */ 3443 /* ------------------------------------------------------------------ */ 3444 decNumber * decNumberCopyAbs(decNumber *res, const decNumber *rhs) { 3445 #if DECCHECK 3446 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res; 3447 #endif 3448 decNumberCopy(res, rhs); 3449 res->bits&=~DECNEG; /* turn off sign */ 3450 return res; 3451 } /* decNumberCopyAbs */ 3452 3453 /* ------------------------------------------------------------------ */ 3454 /* decNumberCopyNegate -- quiet negate value operator */ 3455 /* */ 3456 /* This sets C = negate(A) */ 3457 /* */ 3458 /* res is C, the result. C may be A */ 3459 /* rhs is A */ 3460 /* */ 3461 /* C must have space for set->digits digits. */ 3462 /* No exception or error can occur; this is a quiet bitwise operation.*/ 3463 /* See also decNumberMinus for a checking version of this. */ 3464 /* ------------------------------------------------------------------ */ 3465 decNumber * decNumberCopyNegate(decNumber *res, const decNumber *rhs) { 3466 #if DECCHECK 3467 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res; 3468 #endif 3469 decNumberCopy(res, rhs); 3470 res->bits^=DECNEG; /* invert the sign */ 3471 return res; 3472 } /* decNumberCopyNegate */ 3473 3474 /* ------------------------------------------------------------------ */ 3475 /* decNumberCopySign -- quiet copy and set sign operator */ 3476 /* */ 3477 /* This sets C = A with the sign of B */ 3478 /* */ 3479 /* res is C, the result. C may be A */ 3480 /* lhs is A */ 3481 /* rhs is B */ 3482 /* */ 3483 /* C must have space for set->digits digits. */ 3484 /* No exception or error can occur; this is a quiet bitwise operation.*/ 3485 /* ------------------------------------------------------------------ */ 3486 decNumber * decNumberCopySign(decNumber *res, const decNumber *lhs, 3487 const decNumber *rhs) { 3488 uByte sign; /* rhs sign */ 3489 #if DECCHECK 3490 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res; 3491 #endif 3492 sign=rhs->bits & DECNEG; /* save sign bit */ 3493 decNumberCopy(res, lhs); 3494 res->bits&=~DECNEG; /* clear the sign */ 3495 res->bits|=sign; /* set from rhs */ 3496 return res; 3497 } /* decNumberCopySign */ 3498 3499 /* ------------------------------------------------------------------ */ 3500 /* decNumberGetBCD -- get the coefficient in BCD8 */ 3501 /* dn is the source decNumber */ 3502 /* bcd is the uInt array that will receive dn->digits BCD bytes, */ 3503 /* most-significant at offset 0 */ 3504 /* returns bcd */ 3505 /* */ 3506 /* bcd must have at least dn->digits bytes. No error is possible; if */ 3507 /* dn is a NaN or Infinite, digits must be 1 and the coefficient 0. */ 3508 /* ------------------------------------------------------------------ */ 3509 uByte * decNumberGetBCD(const decNumber *dn, uint8_t *bcd) { 3510 uByte *ub=bcd+dn->digits-1; /* -> lsd */ 3511 const Unit *up=dn->lsu; /* Unit pointer, -> lsu */ 3512 3513 #if DECDPUN==1 /* trivial simple copy */ 3514 for (; ub>=bcd; ub--, up++) *ub=*up; 3515 #else /* chopping needed */ 3516 uInt u=*up; /* work */ 3517 uInt cut=DECDPUN; /* downcounter through unit */ 3518 for (; ub>=bcd; ub--) { 3519 *ub=(uByte)(u%10); /* [*6554 trick inhibits, here] */ 3520 u=u/10; 3521 cut--; 3522 if (cut>0) continue; /* more in this unit */ 3523 up++; 3524 u=*up; 3525 cut=DECDPUN; 3526 } 3527 #endif 3528 return bcd; 3529 } /* decNumberGetBCD */ 3530 3531 /* ------------------------------------------------------------------ */ 3532 /* decNumberSetBCD -- set (replace) the coefficient from BCD8 */ 3533 /* dn is the target decNumber */ 3534 /* bcd is the uInt array that will source n BCD bytes, most- */ 3535 /* significant at offset 0 */ 3536 /* n is the number of digits in the source BCD array (bcd) */ 3537 /* returns dn */ 3538 /* */ 3539 /* dn must have space for at least n digits. No error is possible; */ 3540 /* if dn is a NaN, or Infinite, or is to become a zero, n must be 1 */ 3541 /* and bcd[0] zero. */ 3542 /* ------------------------------------------------------------------ */ 3543 decNumber * decNumberSetBCD(decNumber *dn, const uByte *bcd, uInt n) { 3544 Unit *up = dn->lsu + D2U(n) - 1; /* -> msu [target pointer] */ 3545 const uByte *ub=bcd; /* -> source msd */ 3546 3547 #if DECDPUN==1 /* trivial simple copy */ 3548 for (; ub<bcd+n; ub++, up--) *up=*ub; 3549 #else /* some assembly needed */ 3550 /* calculate how many digits in msu, and hence first cut */ 3551 Int cut=MSUDIGITS(n); /* [faster than remainder] */ 3552 for (;up>=dn->lsu; up--) { /* each Unit from msu */ 3553 *up=0; /* will take <=DECDPUN digits */ 3554 for (; cut>0; ub++, cut--) *up=X10(*up)+*ub; 3555 cut=DECDPUN; /* next Unit has all digits */ 3556 } 3557 #endif 3558 dn->digits=n; /* set digit count */ 3559 return dn; 3560 } /* decNumberSetBCD */ 3561 3562 /* ------------------------------------------------------------------ */ 3563 /* decNumberIsNormal -- test normality of a decNumber */ 3564 /* dn is the decNumber to test */ 3565 /* set is the context to use for Emin */ 3566 /* returns 1 if |dn| is finite and >=Nmin, 0 otherwise */ 3567 /* ------------------------------------------------------------------ */ 3568 Int decNumberIsNormal(const decNumber *dn, decContext *set) { 3569 Int ae; /* adjusted exponent */ 3570 #if DECCHECK 3571 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; 3572 #endif 3573 3574 if (decNumberIsSpecial(dn)) return 0; /* not finite */ 3575 if (decNumberIsZero(dn)) return 0; /* not non-zero */ 3576 3577 ae=dn->exponent+dn->digits-1; /* adjusted exponent */ 3578 if (ae<set->emin) return 0; /* is subnormal */ 3579 return 1; 3580 } /* decNumberIsNormal */ 3581 3582 /* ------------------------------------------------------------------ */ 3583 /* decNumberIsSubnormal -- test subnormality of a decNumber */ 3584 /* dn is the decNumber to test */ 3585 /* set is the context to use for Emin */ 3586 /* returns 1 if |dn| is finite, non-zero, and <Nmin, 0 otherwise */ 3587 /* ------------------------------------------------------------------ */ 3588 Int decNumberIsSubnormal(const decNumber *dn, decContext *set) { 3589 Int ae; /* adjusted exponent */ 3590 #if DECCHECK 3591 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; 3592 #endif 3593 3594 if (decNumberIsSpecial(dn)) return 0; /* not finite */ 3595 if (decNumberIsZero(dn)) return 0; /* not non-zero */ 3596 3597 ae=dn->exponent+dn->digits-1; /* adjusted exponent */ 3598 if (ae<set->emin) return 1; /* is subnormal */ 3599 return 0; 3600 } /* decNumberIsSubnormal */ 3601 3602 /* ------------------------------------------------------------------ */ 3603 /* decNumberTrim -- remove insignificant zeros */ 3604 /* */ 3605 /* dn is the number to trim */ 3606 /* returns dn */ 3607 /* */ 3608 /* All fields are updated as required. This is a utility operation, */ 3609 /* so special values are unchanged and no error is possible. */ 3610 /* ------------------------------------------------------------------ */ 3611 decNumber * decNumberTrim(decNumber *dn) { 3612 Int dropped; /* work */ 3613 decContext set; /* .. */ 3614 #if DECCHECK 3615 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, DECUNCONT)) return dn; 3616 #endif 3617 decContextDefault(&set, DEC_INIT_BASE); /* clamp=0 */ 3618 return decTrim(dn, &set, 0, &dropped); 3619 } /* decNumberTrim */ 3620 3621 /* ------------------------------------------------------------------ */ 3622 /* decNumberVersion -- return the name and version of this module */ 3623 /* */ 3624 /* No error is possible. */ 3625 /* ------------------------------------------------------------------ */ 3626 const char * decNumberVersion(void) { 3627 return DECVERSION; 3628 } /* decNumberVersion */ 3629 3630 /* ------------------------------------------------------------------ */ 3631 /* decNumberZero -- set a number to 0 */ 3632 /* */ 3633 /* dn is the number to set, with space for one digit */ 3634 /* returns dn */ 3635 /* */ 3636 /* No error is possible. */ 3637 /* ------------------------------------------------------------------ */ 3638 /* Memset is not used as it is much slower in some environments. */ 3639 decNumber * decNumberZero(decNumber *dn) { 3640 3641 #if DECCHECK 3642 if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn; 3643 #endif 3644 3645 dn->bits=0; 3646 dn->exponent=0; 3647 dn->digits=1; 3648 dn->lsu[0]=0; 3649 return dn; 3650 } /* decNumberZero */ 3651 3652 /* ================================================================== */ 3653 /* Local routines */ 3654 /* ================================================================== */ 3655 3656 /* ------------------------------------------------------------------ */ 3657 /* decToString -- lay out a number into a string */ 3658 /* */ 3659 /* dn is the number to lay out */ 3660 /* string is where to lay out the number */ 3661 /* eng is 1 if Engineering, 0 if Scientific */ 3662 /* */ 3663 /* string must be at least dn->digits+14 characters long */ 3664 /* No error is possible. */ 3665 /* */ 3666 /* Note that this routine can generate a -0 or 0.000. These are */ 3667 /* never generated in subset to-number or arithmetic, but can occur */ 3668 /* in non-subset arithmetic (e.g., -1*0 or 1.234-1.234). */ 3669 /* ------------------------------------------------------------------ */ 3670 /* If DECCHECK is enabled the string "?" is returned if a number is */ 3671 /* invalid. */ 3672 static void decToString(const decNumber *dn, char *string, Flag eng) { 3673 Int exp=dn->exponent; /* local copy */ 3674 Int e; /* E-part value */ 3675 Int pre; /* digits before the '.' */ 3676 Int cut; /* for counting digits in a Unit */ 3677 char *c=string; /* work [output pointer] */ 3678 const Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [input pointer] */ 3679 uInt u, pow; /* work */ 3680 3681 #if DECCHECK 3682 if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) { 3683 strcpy(string, "?"); 3684 return;} 3685 #endif 3686 3687 if (decNumberIsNegative(dn)) { /* Negatives get a minus */ 3688 *c='-'; 3689 c++; 3690 } 3691 if (dn->bits&DECSPECIAL) { /* Is a special value */ 3692 if (decNumberIsInfinite(dn)) { 3693 strcpy(c, "Inf"); 3694 strcpy(c+3, "inity"); 3695 return;} 3696 /* a NaN */ 3697 if (dn->bits&DECSNAN) { /* signalling NaN */ 3698 *c='s'; 3699 c++; 3700 } 3701 strcpy(c, "NaN"); 3702 c+=3; /* step past */ 3703 /* if not a clean non-zero coefficient, that's all there is in a */ 3704 /* NaN string */ 3705 if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return; 3706 /* [drop through to add integer] */ 3707 } 3708 3709 /* calculate how many digits in msu, and hence first cut */ 3710 cut=MSUDIGITS(dn->digits); /* [faster than remainder] */ 3711 cut--; /* power of ten for digit */ 3712 3713 if (exp==0) { /* simple integer [common fastpath] */ 3714 for (;up>=dn->lsu; up--) { /* each Unit from msu */ 3715 u=*up; /* contains DECDPUN digits to lay out */ 3716 for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow); 3717 cut=DECDPUN-1; /* next Unit has all digits */ 3718 } 3719 *c='\0'; /* terminate the string */ 3720 return;} 3721 3722 /* non-0 exponent -- assume plain form */ 3723 pre=dn->digits+exp; /* digits before '.' */ 3724 e=0; /* no E */ 3725 if ((exp>0) || (pre<-5)) { /* need exponential form */ 3726 e=exp+dn->digits-1; /* calculate E value */ 3727 pre=1; /* assume one digit before '.' */ 3728 if (eng && (e!=0)) { /* engineering: may need to adjust */ 3729 Int adj; /* adjustment */ 3730 /* The C remainder operator is undefined for negative numbers, so */ 3731 /* a positive remainder calculation must be used here */ 3732 if (e<0) { 3733 adj=(-e)%3; 3734 if (adj!=0) adj=3-adj; 3735 } 3736 else { /* e>0 */ 3737 adj=e%3; 3738 } 3739 e=e-adj; 3740 /* if dealing with zero still produce an exponent which is a */ 3741 /* multiple of three, as expected, but there will only be the */ 3742 /* one zero before the E, still. Otherwise note the padding. */ 3743 if (!ISZERO(dn)) pre+=adj; 3744 else { /* is zero */ 3745 if (adj!=0) { /* 0.00Esnn needed */ 3746 e=e+3; 3747 pre=-(2-adj); 3748 } 3749 } /* zero */ 3750 } /* eng */ 3751 } /* need exponent */ 3752 3753 /* lay out the digits of the coefficient, adding 0s and . as needed */ 3754 u=*up; 3755 if (pre>0) { /* xxx.xxx or xx00 (engineering) form */ 3756 Int n=pre; 3757 for (; pre>0; pre--, c++, cut--) { 3758 if (cut<0) { /* need new Unit */ 3759 if (up==dn->lsu) break; /* out of input digits (pre>digits) */ 3760 up--; 3761 cut=DECDPUN-1; 3762 u=*up; 3763 } 3764 TODIGIT(u, cut, c, pow); 3765 } 3766 if (n<dn->digits) { /* more to come, after '.' */ 3767 *c='.'; c++; 3768 for (;; c++, cut--) { 3769 if (cut<0) { /* need new Unit */ 3770 if (up==dn->lsu) break; /* out of input digits */ 3771 up--; 3772 cut=DECDPUN-1; 3773 u=*up; 3774 } 3775 TODIGIT(u, cut, c, pow); 3776 } 3777 } 3778 else for (; pre>0; pre--, c++) *c='0'; /* 0 padding (for engineering) needed */ 3779 } 3780 else { /* 0.xxx or 0.000xxx form */ 3781 *c='0'; c++; 3782 *c='.'; c++; 3783 for (; pre<0; pre++, c++) *c='0'; /* add any 0's after '.' */ 3784 for (; ; c++, cut--) { 3785 if (cut<0) { /* need new Unit */ 3786 if (up==dn->lsu) break; /* out of input digits */ 3787 up--; 3788 cut=DECDPUN-1; 3789 u=*up; 3790 } 3791 TODIGIT(u, cut, c, pow); 3792 } 3793 } 3794 3795 /* Finally add the E-part, if needed. It will never be 0, has a 3796 base maximum and minimum of +999999999 through -999999999, but 3797 could range down to -1999999998 for anormal numbers */ 3798 if (e!=0) { 3799 Flag had=0; /* 1=had non-zero */ 3800 *c='E'; c++; 3801 *c='+'; c++; /* assume positive */ 3802 u=e; /* .. */ 3803 if (e<0) { 3804 *(c-1)='-'; /* oops, need - */ 3805 u=-e; /* uInt, please */ 3806 } 3807 /* lay out the exponent [_itoa or equivalent is not ANSI C] */ 3808 for (cut=9; cut>=0; cut--) { 3809 TODIGIT(u, cut, c, pow); 3810 if (*c=='0' && !had) continue; /* skip leading zeros */ 3811 had=1; /* had non-0 */ 3812 c++; /* step for next */ 3813 } /* cut */ 3814 } 3815 *c='\0'; /* terminate the string (all paths) */ 3816 return; 3817 } /* decToString */ 3818 3819 /* ------------------------------------------------------------------ */ 3820 /* decAddOp -- add/subtract operation */ 3821 /* */ 3822 /* This computes C = A + B */ 3823 /* */ 3824 /* res is C, the result. C may be A and/or B (e.g., X=X+X) */ 3825 /* lhs is A */ 3826 /* rhs is B */ 3827 /* set is the context */ 3828 /* negate is DECNEG if rhs should be negated, or 0 otherwise */ 3829 /* status accumulates status for the caller */ 3830 /* */ 3831 /* C must have space for set->digits digits. */ 3832 /* Inexact in status must be 0 for correct Exact zero sign in result */ 3833 /* ------------------------------------------------------------------ */ 3834 /* If possible, the coefficient is calculated directly into C. */ 3835 /* However, if: */ 3836 /* -- a digits+1 calculation is needed because the numbers are */ 3837 /* unaligned and span more than set->digits digits */ 3838 /* -- a carry to digits+1 digits looks possible */ 3839 /* -- C is the same as A or B, and the result would destructively */ 3840 /* overlap the A or B coefficient */ 3841 /* then the result must be calculated into a temporary buffer. In */ 3842 /* this case a local (stack) buffer is used if possible, and only if */ 3843 /* too long for that does malloc become the final resort. */ 3844 /* */ 3845 /* Misalignment is handled as follows: */ 3846 /* Apad: (AExp>BExp) Swap operands and proceed as for BExp>AExp. */ 3847 /* BPad: Apply the padding by a combination of shifting (whole */ 3848 /* units) and multiplication (part units). */ 3849 /* */ 3850 /* Addition, especially x=x+1, is speed-critical. */ 3851 /* The static buffer is larger than might be expected to allow for */ 3852 /* calls from higher-level funtions (notable exp). */ 3853 /* ------------------------------------------------------------------ */ 3854 static decNumber * decAddOp(decNumber *res, const decNumber *lhs, 3855 const decNumber *rhs, decContext *set, 3856 uByte negate, uInt *status) { 3857 #if DECSUBSET 3858 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 3859 decNumber *allocrhs=NULL; /* .., rhs */ 3860 #endif 3861 Int rhsshift; /* working shift (in Units) */ 3862 Int maxdigits; /* longest logical length */ 3863 Int mult; /* multiplier */ 3864 Int residue; /* rounding accumulator */ 3865 uByte bits; /* result bits */ 3866 Flag diffsign; /* non-0 if arguments have different sign */ 3867 Unit *acc; /* accumulator for result */ 3868 Unit accbuff[SD2U(DECBUFFER*2+20)]; /* local buffer [*2+20 reduces many */ 3869 /* allocations when called from */ 3870 /* other operations, notable exp] */ 3871 Unit *allocacc=NULL; /* -> allocated acc buffer, iff allocated */ 3872 Int reqdigits=set->digits; /* local copy; requested DIGITS */ 3873 Int padding; /* work */ 3874 3875 #if DECCHECK 3876 if (decCheckOperands(res, lhs, rhs, set)) return res; 3877 #endif 3878 3879 do { /* protect allocated storage */ 3880 #if DECSUBSET 3881 if (!set->extended) { 3882 /* reduce operands and set lostDigits status, as needed */ 3883 if (lhs->digits>reqdigits) { 3884 alloclhs=decRoundOperand(lhs, set, status); 3885 if (alloclhs==NULL) break; 3886 lhs=alloclhs; 3887 } 3888 if (rhs->digits>reqdigits) { 3889 allocrhs=decRoundOperand(rhs, set, status); 3890 if (allocrhs==NULL) break; 3891 rhs=allocrhs; 3892 } 3893 } 3894 #endif 3895 /* [following code does not require input rounding] */ 3896 3897 /* note whether signs differ [used all paths] */ 3898 diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG); 3899 3900 /* handle infinities and NaNs */ 3901 if (SPECIALARGS) { /* a special bit set */ 3902 if (SPECIALARGS & (DECSNAN | DECNAN)) /* a NaN */ 3903 decNaNs(res, lhs, rhs, set, status); 3904 else { /* one or two infinities */ 3905 if (decNumberIsInfinite(lhs)) { /* LHS is infinity */ 3906 /* two infinities with different signs is invalid */ 3907 if (decNumberIsInfinite(rhs) && diffsign) { 3908 *status|=DEC_Invalid_operation; 3909 break; 3910 } 3911 bits=lhs->bits & DECNEG; /* get sign from LHS */ 3912 } 3913 else bits=(rhs->bits^negate) & DECNEG;/* RHS must be Infinity */ 3914 bits|=DECINF; 3915 decNumberZero(res); 3916 res->bits=bits; /* set +/- infinity */ 3917 } /* an infinity */ 3918 break; 3919 } 3920 3921 /* Quick exit for add 0s; return the non-0, modified as need be */ 3922 if (ISZERO(lhs)) { 3923 Int adjust; /* work */ 3924 Int lexp=lhs->exponent; /* save in case LHS==RES */ 3925 bits=lhs->bits; /* .. */ 3926 residue=0; /* clear accumulator */ 3927 decCopyFit(res, rhs, set, &residue, status); /* copy (as needed) */ 3928 res->bits^=negate; /* flip if rhs was negated */ 3929 #if DECSUBSET 3930 if (set->extended) { /* exponents on zeros count */ 3931 #endif 3932 /* exponent will be the lower of the two */ 3933 adjust=lexp-res->exponent; /* adjustment needed [if -ve] */ 3934 if (ISZERO(res)) { /* both 0: special IEEE 854 rules */ 3935 if (adjust<0) res->exponent=lexp; /* set exponent */ 3936 /* 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0 */ 3937 if (diffsign) { 3938 if (set->round!=DEC_ROUND_FLOOR) res->bits=0; 3939 else res->bits=DECNEG; /* preserve 0 sign */ 3940 } 3941 } 3942 else { /* non-0 res */ 3943 if (adjust<0) { /* 0-padding needed */ 3944 if ((res->digits-adjust)>set->digits) { 3945 adjust=res->digits-set->digits; /* to fit exactly */ 3946 *status|=DEC_Rounded; /* [but exact] */ 3947 } 3948 res->digits=decShiftToMost(res->lsu, res->digits, -adjust); 3949 res->exponent+=adjust; /* set the exponent. */ 3950 } 3951 } /* non-0 res */ 3952 #if DECSUBSET 3953 } /* extended */ 3954 #endif 3955 decFinish(res, set, &residue, status); /* clean and finalize */ 3956 break;} 3957 3958 if (ISZERO(rhs)) { /* [lhs is non-zero] */ 3959 Int adjust; /* work */ 3960 Int rexp=rhs->exponent; /* save in case RHS==RES */ 3961 bits=rhs->bits; /* be clean */ 3962 residue=0; /* clear accumulator */ 3963 decCopyFit(res, lhs, set, &residue, status); /* copy (as needed) */ 3964 #if DECSUBSET 3965 if (set->extended) { /* exponents on zeros count */ 3966 #endif 3967 /* exponent will be the lower of the two */ 3968 /* [0-0 case handled above] */ 3969 adjust=rexp-res->exponent; /* adjustment needed [if -ve] */ 3970 if (adjust<0) { /* 0-padding needed */ 3971 if ((res->digits-adjust)>set->digits) { 3972 adjust=res->digits-set->digits; /* to fit exactly */ 3973 *status|=DEC_Rounded; /* [but exact] */ 3974 } 3975 res->digits=decShiftToMost(res->lsu, res->digits, -adjust); 3976 res->exponent+=adjust; /* set the exponent. */ 3977 } 3978 #if DECSUBSET 3979 } /* extended */ 3980 #endif 3981 decFinish(res, set, &residue, status); /* clean and finalize */ 3982 break;} 3983 3984 /* [NB: both fastpath and mainpath code below assume these cases */ 3985 /* (notably 0-0) have already been handled] */ 3986 3987 /* calculate the padding needed to align the operands */ 3988 padding=rhs->exponent-lhs->exponent; 3989 3990 /* Fastpath cases where the numbers are aligned and normal, the RHS */ 3991 /* is all in one unit, no operand rounding is needed, and no carry, */ 3992 /* lengthening, or borrow is needed */ 3993 if (padding==0 3994 && rhs->digits<=DECDPUN 3995 && rhs->exponent>=set->emin /* [some normals drop through] */ 3996 && rhs->exponent<=set->emax-set->digits+1 /* [could clamp] */ 3997 && rhs->digits<=reqdigits 3998 && lhs->digits<=reqdigits) { 3999 Int partial=*lhs->lsu; 4000 if (!diffsign) { /* adding */ 4001 partial+=*rhs->lsu; 4002 if ((partial<=DECDPUNMAX) /* result fits in unit */ 4003 && (lhs->digits>=DECDPUN || /* .. and no digits-count change */ 4004 partial<(Int)powers[lhs->digits])) { /* .. */ 4005 if (res!=lhs) decNumberCopy(res, lhs); /* not in place */ 4006 *res->lsu=(Unit)partial; /* [copy could have overwritten RHS] */ 4007 break; 4008 } 4009 /* else drop out for careful add */ 4010 } 4011 else { /* signs differ */ 4012 partial-=*rhs->lsu; 4013 if (partial>0) { /* no borrow needed, and non-0 result */ 4014 if (res!=lhs) decNumberCopy(res, lhs); /* not in place */ 4015 *res->lsu=(Unit)partial; 4016 /* this could have reduced digits [but result>0] */ 4017 res->digits=decGetDigits(res->lsu, D2U(res->digits)); 4018 break; 4019 } 4020 /* else drop out for careful subtract */ 4021 } 4022 } 4023 4024 /* Now align (pad) the lhs or rhs so they can be added or */ 4025 /* subtracted, as necessary. If one number is much larger than */ 4026 /* the other (that is, if in plain form there is a least one */ 4027 /* digit between the lowest digit of one and the highest of the */ 4028 /* other) padding with up to DIGITS-1 trailing zeros may be */ 4029 /* needed; then apply rounding (as exotic rounding modes may be */ 4030 /* affected by the residue). */ 4031 rhsshift=0; /* rhs shift to left (padding) in Units */ 4032 bits=lhs->bits; /* assume sign is that of LHS */ 4033 mult=1; /* likely multiplier */ 4034 4035 /* [if padding==0 the operands are aligned; no padding is needed] */ 4036 if (padding!=0) { 4037 /* some padding needed; always pad the RHS, as any required */ 4038 /* padding can then be effected by a simple combination of */ 4039 /* shifts and a multiply */ 4040 Flag swapped=0; 4041 if (padding<0) { /* LHS needs the padding */ 4042 const decNumber *t; 4043 padding=-padding; /* will be +ve */ 4044 bits=(uByte)(rhs->bits^negate); /* assumed sign is now that of RHS */ 4045 t=lhs; lhs=rhs; rhs=t; 4046 swapped=1; 4047 } 4048 4049 /* If, after pad, rhs would be longer than lhs by digits+1 or */ 4050 /* more then lhs cannot affect the answer, except as a residue, */ 4051 /* so only need to pad up to a length of DIGITS+1. */ 4052 if (rhs->digits+padding > lhs->digits+reqdigits+1) { 4053 /* The RHS is sufficient */ 4054 /* for residue use the relative sign indication... */ 4055 Int shift=reqdigits-rhs->digits; /* left shift needed */ 4056 residue=1; /* residue for rounding */ 4057 if (diffsign) residue=-residue; /* signs differ */ 4058 /* copy, shortening if necessary */ 4059 decCopyFit(res, rhs, set, &residue, status); 4060 /* if it was already shorter, then need to pad with zeros */ 4061 if (shift>0) { 4062 res->digits=decShiftToMost(res->lsu, res->digits, shift); 4063 res->exponent-=shift; /* adjust the exponent. */ 4064 } 4065 /* flip the result sign if unswapped and rhs was negated */ 4066 if (!swapped) res->bits^=negate; 4067 decFinish(res, set, &residue, status); /* done */ 4068 break;} 4069 4070 /* LHS digits may affect result */ 4071 rhsshift=D2U(padding+1)-1; /* this much by Unit shift .. */ 4072 mult=powers[padding-(rhsshift*DECDPUN)]; /* .. this by multiplication */ 4073 } /* padding needed */ 4074 4075 if (diffsign) mult=-mult; /* signs differ */ 4076 4077 /* determine the longer operand */ 4078 maxdigits=rhs->digits+padding; /* virtual length of RHS */ 4079 if (lhs->digits>maxdigits) maxdigits=lhs->digits; 4080 4081 /* Decide on the result buffer to use; if possible place directly */ 4082 /* into result. */ 4083 acc=res->lsu; /* assume add direct to result */ 4084 /* If destructive overlap, or the number is too long, or a carry or */ 4085 /* borrow to DIGITS+1 might be possible, a buffer must be used. */ 4086 /* [Might be worth more sophisticated tests when maxdigits==reqdigits] */ 4087 if ((maxdigits>=reqdigits) /* is, or could be, too large */ 4088 || (res==rhs && rhsshift>0)) { /* destructive overlap */ 4089 /* buffer needed, choose it; units for maxdigits digits will be */ 4090 /* needed, +1 Unit for carry or borrow */ 4091 Int need=D2U(maxdigits)+1; 4092 acc=accbuff; /* assume use local buffer */ 4093 if (need*sizeof(Unit)>sizeof(accbuff)) { 4094 /* printf("malloc add %ld %ld\n", need, sizeof(accbuff)); */ 4095 allocacc=(Unit *)malloc(need*sizeof(Unit)); 4096 if (allocacc==NULL) { /* hopeless -- abandon */ 4097 *status|=DEC_Insufficient_storage; 4098 break;} 4099 acc=allocacc; 4100 } 4101 } 4102 4103 res->bits=(uByte)(bits&DECNEG); /* it's now safe to overwrite.. */ 4104 res->exponent=lhs->exponent; /* .. operands (even if aliased) */ 4105 4106 #if DECTRACE 4107 decDumpAr('A', lhs->lsu, D2U(lhs->digits)); 4108 decDumpAr('B', rhs->lsu, D2U(rhs->digits)); 4109 printf(" :h: %ld %ld\n", rhsshift, mult); 4110 #endif 4111 4112 /* add [A+B*m] or subtract [A+B*(-m)] */ 4113 res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits), 4114 rhs->lsu, D2U(rhs->digits), 4115 rhsshift, acc, mult) 4116 *DECDPUN; /* [units -> digits] */ 4117 if (res->digits<0) { /* borrowed... */ 4118 res->digits=-res->digits; 4119 res->bits^=DECNEG; /* flip the sign */ 4120 } 4121 #if DECTRACE 4122 decDumpAr('+', acc, D2U(res->digits)); 4123 #endif 4124 4125 /* If a buffer was used the result must be copied back, possibly */ 4126 /* shortening. (If no buffer was used then the result must have */ 4127 /* fit, so can't need rounding and residue must be 0.) */ 4128 residue=0; /* clear accumulator */ 4129 if (acc!=res->lsu) { 4130 #if DECSUBSET 4131 if (set->extended) { /* round from first significant digit */ 4132 #endif 4133 /* remove leading zeros that were added due to rounding up to */ 4134 /* integral Units -- before the test for rounding. */ 4135 if (res->digits>reqdigits) 4136 res->digits=decGetDigits(acc, D2U(res->digits)); 4137 decSetCoeff(res, set, acc, res->digits, &residue, status); 4138 #if DECSUBSET 4139 } 4140 else { /* subset arithmetic rounds from original significant digit */ 4141 /* May have an underestimate. This only occurs when both */ 4142 /* numbers fit in DECDPUN digits and are padding with a */ 4143 /* negative multiple (-10, -100...) and the top digit(s) become */ 4144 /* 0. (This only matters when using X3.274 rules where the */ 4145 /* leading zero could be included in the rounding.) */ 4146 if (res->digits<maxdigits) { 4147 *(acc+D2U(res->digits))=0; /* ensure leading 0 is there */ 4148 res->digits=maxdigits; 4149 } 4150 else { 4151 /* remove leading zeros that added due to rounding up to */ 4152 /* integral Units (but only those in excess of the original */ 4153 /* maxdigits length, unless extended) before test for rounding. */ 4154 if (res->digits>reqdigits) { 4155 res->digits=decGetDigits(acc, D2U(res->digits)); 4156 if (res->digits<maxdigits) res->digits=maxdigits; 4157 } 4158 } 4159 decSetCoeff(res, set, acc, res->digits, &residue, status); 4160 /* Now apply rounding if needed before removing leading zeros. */ 4161 /* This is safe because subnormals are not a possibility */ 4162 if (residue!=0) { 4163 decApplyRound(res, set, residue, status); 4164 residue=0; /* did what needed to be done */ 4165 } 4166 } /* subset */ 4167 #endif 4168 } /* used buffer */ 4169 4170 /* strip leading zeros [these were left on in case of subset subtract] */ 4171 res->digits=decGetDigits(res->lsu, D2U(res->digits)); 4172 4173 /* apply checks and rounding */ 4174 decFinish(res, set, &residue, status); 4175 4176 /* "When the sum of two operands with opposite signs is exactly */ 4177 /* zero, the sign of that sum shall be '+' in all rounding modes */ 4178 /* except round toward -Infinity, in which mode that sign shall be */ 4179 /* '-'." [Subset zeros also never have '-', set by decFinish.] */ 4180 if (ISZERO(res) && diffsign 4181 #if DECSUBSET 4182 && set->extended 4183 #endif 4184 && (*status&DEC_Inexact)==0) { 4185 if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG; /* sign - */ 4186 else res->bits&=~DECNEG; /* sign + */ 4187 } 4188 } while(0); /* end protected */ 4189 4190 if (allocacc!=NULL) free(allocacc); /* drop any storage used */ 4191 #if DECSUBSET 4192 if (allocrhs!=NULL) free(allocrhs); /* .. */ 4193 if (alloclhs!=NULL) free(alloclhs); /* .. */ 4194 #endif 4195 return res; 4196 } /* decAddOp */ 4197 4198 /* ------------------------------------------------------------------ */ 4199 /* decDivideOp -- division operation */ 4200 /* */ 4201 /* This routine performs the calculations for all four division */ 4202 /* operators (divide, divideInteger, remainder, remainderNear). */ 4203 /* */ 4204 /* C=A op B */ 4205 /* */ 4206 /* res is C, the result. C may be A and/or B (e.g., X=X/X) */ 4207 /* lhs is A */ 4208 /* rhs is B */ 4209 /* set is the context */ 4210 /* op is DIVIDE, DIVIDEINT, REMAINDER, or REMNEAR respectively. */ 4211 /* status is the usual accumulator */ 4212 /* */ 4213 /* C must have space for set->digits digits. */ 4214 /* */ 4215 /* ------------------------------------------------------------------ */ 4216 /* The underlying algorithm of this routine is the same as in the */ 4217 /* 1981 S/370 implementation, that is, non-restoring long division */ 4218 /* with bi-unit (rather than bi-digit) estimation for each unit */ 4219 /* multiplier. In this pseudocode overview, complications for the */ 4220 /* Remainder operators and division residues for exact rounding are */ 4221 /* omitted for clarity. */ 4222 /* */ 4223 /* Prepare operands and handle special values */ 4224 /* Test for x/0 and then 0/x */ 4225 /* Exp =Exp1 - Exp2 */ 4226 /* Exp =Exp +len(var1) -len(var2) */ 4227 /* Sign=Sign1 * Sign2 */ 4228 /* Pad accumulator (Var1) to double-length with 0's (pad1) */ 4229 /* Pad Var2 to same length as Var1 */ 4230 /* msu2pair/plus=1st 2 or 1 units of var2, +1 to allow for round */ 4231 /* have=0 */ 4232 /* Do until (have=digits+1 OR residue=0) */ 4233 /* if exp<0 then if integer divide/residue then leave */ 4234 /* this_unit=0 */ 4235 /* Do forever */ 4236 /* compare numbers */ 4237 /* if <0 then leave inner_loop */ 4238 /* if =0 then (* quick exit without subtract *) do */ 4239 /* this_unit=this_unit+1; output this_unit */ 4240 /* leave outer_loop; end */ 4241 /* Compare lengths of numbers (mantissae): */ 4242 /* If same then tops2=msu2pair -- {units 1&2 of var2} */ 4243 /* else tops2=msu2plus -- {0, unit 1 of var2} */ 4244 /* tops1=first_unit_of_Var1*10**DECDPUN +second_unit_of_var1 */ 4245 /* mult=tops1/tops2 -- Good and safe guess at divisor */ 4246 /* if mult=0 then mult=1 */ 4247 /* this_unit=this_unit+mult */ 4248 /* subtract */ 4249 /* end inner_loop */ 4250 /* if have\=0 | this_unit\=0 then do */ 4251 /* output this_unit */ 4252 /* have=have+1; end */ 4253 /* var2=var2/10 */ 4254 /* exp=exp-1 */ 4255 /* end outer_loop */ 4256 /* exp=exp+1 -- set the proper exponent */ 4257 /* if have=0 then generate answer=0 */ 4258 /* Return (Result is defined by Var1) */ 4259 /* */ 4260 /* ------------------------------------------------------------------ */ 4261 /* Two working buffers are needed during the division; one (digits+ */ 4262 /* 1) to accumulate the result, and the other (up to 2*digits+1) for */ 4263 /* long subtractions. These are acc and var1 respectively. */ 4264 /* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/ 4265 /* The static buffers may be larger than might be expected to allow */ 4266 /* for calls from higher-level funtions (notable exp). */ 4267 /* ------------------------------------------------------------------ */ 4268 static decNumber * decDivideOp(decNumber *res, 4269 const decNumber *lhs, const decNumber *rhs, 4270 decContext *set, Flag op, uInt *status) { 4271 #if DECSUBSET 4272 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 4273 decNumber *allocrhs=NULL; /* .., rhs */ 4274 #endif 4275 Unit accbuff[SD2U(DECBUFFER+DECDPUN+10)]; /* local buffer */ 4276 Unit *acc=accbuff; /* -> accumulator array for result */ 4277 Unit *allocacc=NULL; /* -> allocated buffer, iff allocated */ 4278 Unit *accnext; /* -> where next digit will go */ 4279 Int acclength; /* length of acc needed [Units] */ 4280 Int accunits; /* count of units accumulated */ 4281 Int accdigits; /* count of digits accumulated */ 4282 4283 Unit varbuff[SD2U(DECBUFFER*2+DECDPUN)*sizeof(Unit)]; /* buffer for var1 */ 4284 Unit *var1=varbuff; /* -> var1 array for long subtraction */ 4285 Unit *varalloc=NULL; /* -> allocated buffer, iff used */ 4286 Unit *msu1; /* -> msu of var1 */ 4287 4288 const Unit *var2; /* -> var2 array */ 4289 const Unit *msu2; /* -> msu of var2 */ 4290 Int msu2plus; /* msu2 plus one [does not vary] */ 4291 eInt msu2pair; /* msu2 pair plus one [does not vary] */ 4292 4293 Int var1units, var2units; /* actual lengths */ 4294 Int var2ulen; /* logical length (units) */ 4295 Int var1initpad=0; /* var1 initial padding (digits) */ 4296 Int maxdigits; /* longest LHS or required acc length */ 4297 Int mult; /* multiplier for subtraction */ 4298 Unit thisunit; /* current unit being accumulated */ 4299 Int residue; /* for rounding */ 4300 Int reqdigits=set->digits; /* requested DIGITS */ 4301 Int exponent; /* working exponent */ 4302 Int maxexponent=0; /* DIVIDE maximum exponent if unrounded */ 4303 uByte bits; /* working sign */ 4304 Unit *target; /* work */ 4305 const Unit *source; /* .. */ 4306 uLong const *pow; /* .. */ 4307 Int shift, cut; /* .. */ 4308 #if DECSUBSET 4309 Int dropped; /* work */ 4310 #endif 4311 4312 #if DECCHECK 4313 if (decCheckOperands(res, lhs, rhs, set)) return res; 4314 #endif 4315 4316 do { /* protect allocated storage */ 4317 #if DECSUBSET 4318 if (!set->extended) { 4319 /* reduce operands and set lostDigits status, as needed */ 4320 if (lhs->digits>reqdigits) { 4321 alloclhs=decRoundOperand(lhs, set, status); 4322 if (alloclhs==NULL) break; 4323 lhs=alloclhs; 4324 } 4325 if (rhs->digits>reqdigits) { 4326 allocrhs=decRoundOperand(rhs, set, status); 4327 if (allocrhs==NULL) break; 4328 rhs=allocrhs; 4329 } 4330 } 4331 #endif 4332 /* [following code does not require input rounding] */ 4333 4334 bits=(lhs->bits^rhs->bits)&DECNEG; /* assumed sign for divisions */ 4335 4336 /* handle infinities and NaNs */ 4337 if (SPECIALARGS) { /* a special bit set */ 4338 if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */ 4339 decNaNs(res, lhs, rhs, set, status); 4340 break; 4341 } 4342 /* one or two infinities */ 4343 if (decNumberIsInfinite(lhs)) { /* LHS (dividend) is infinite */ 4344 if (decNumberIsInfinite(rhs) || /* two infinities are invalid .. */ 4345 op & (REMAINDER | REMNEAR)) { /* as is remainder of infinity */ 4346 *status|=DEC_Invalid_operation; 4347 break; 4348 } 4349 /* [Note that infinity/0 raises no exceptions] */ 4350 decNumberZero(res); 4351 res->bits=bits|DECINF; /* set +/- infinity */ 4352 break; 4353 } 4354 else { /* RHS (divisor) is infinite */ 4355 residue=0; 4356 if (op&(REMAINDER|REMNEAR)) { 4357 /* result is [finished clone of] lhs */ 4358 decCopyFit(res, lhs, set, &residue, status); 4359 } 4360 else { /* a division */ 4361 decNumberZero(res); 4362 res->bits=bits; /* set +/- zero */ 4363 /* for DIVIDEINT the exponent is always 0. For DIVIDE, result */ 4364 /* is a 0 with infinitely negative exponent, clamped to minimum */ 4365 if (op&DIVIDE) { 4366 res->exponent=set->emin-set->digits+1; 4367 *status|=DEC_Clamped; 4368 } 4369 } 4370 decFinish(res, set, &residue, status); 4371 break; 4372 } 4373 } 4374 4375 /* handle 0 rhs (x/0) */ 4376 if (ISZERO(rhs)) { /* x/0 is always exceptional */ 4377 if (ISZERO(lhs)) { 4378 decNumberZero(res); /* [after lhs test] */ 4379 *status|=DEC_Division_undefined;/* 0/0 will become NaN */ 4380 } 4381 else { 4382 decNumberZero(res); 4383 if (op&(REMAINDER|REMNEAR)) *status|=DEC_Invalid_operation; 4384 else { 4385 *status|=DEC_Division_by_zero; /* x/0 */ 4386 res->bits=bits|DECINF; /* .. is +/- Infinity */ 4387 } 4388 } 4389 break;} 4390 4391 /* handle 0 lhs (0/x) */ 4392 if (ISZERO(lhs)) { /* 0/x [x!=0] */ 4393 #if DECSUBSET 4394 if (!set->extended) decNumberZero(res); 4395 else { 4396 #endif 4397 if (op&DIVIDE) { 4398 residue=0; 4399 exponent=lhs->exponent-rhs->exponent; /* ideal exponent */ 4400 decNumberCopy(res, lhs); /* [zeros always fit] */ 4401 res->bits=bits; /* sign as computed */ 4402 res->exponent=exponent; /* exponent, too */ 4403 decFinalize(res, set, &residue, status); /* check exponent */ 4404 } 4405 else if (op&DIVIDEINT) { 4406 decNumberZero(res); /* integer 0 */ 4407 res->bits=bits; /* sign as computed */ 4408 } 4409 else { /* a remainder */ 4410 exponent=rhs->exponent; /* [save in case overwrite] */ 4411 decNumberCopy(res, lhs); /* [zeros always fit] */ 4412 if (exponent<res->exponent) res->exponent=exponent; /* use lower */ 4413 } 4414 #if DECSUBSET 4415 } 4416 #endif 4417 break;} 4418 4419 /* Precalculate exponent. This starts off adjusted (and hence fits */ 4420 /* in 31 bits) and becomes the usual unadjusted exponent as the */ 4421 /* division proceeds. The order of evaluation is important, here, */ 4422 /* to avoid wrap. */ 4423 exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits); 4424 4425 /* If the working exponent is -ve, then some quick exits are */ 4426 /* possible because the quotient is known to be <1 */ 4427 /* [for REMNEAR, it needs to be < -1, as -0.5 could need work] */ 4428 if (exponent<0 && !(op==DIVIDE)) { 4429 if (op&DIVIDEINT) { 4430 decNumberZero(res); /* integer part is 0 */ 4431 #if DECSUBSET 4432 if (set->extended) 4433 #endif 4434 res->bits=bits; /* set +/- zero */ 4435 break;} 4436 /* fastpath remainders so long as the lhs has the smaller */ 4437 /* (or equal) exponent */ 4438 if (lhs->exponent<=rhs->exponent) { 4439 if (op&REMAINDER || exponent<-1) { 4440 /* It is REMAINDER or safe REMNEAR; result is [finished */ 4441 /* clone of] lhs (r = x - 0*y) */ 4442 residue=0; 4443 decCopyFit(res, lhs, set, &residue, status); 4444 decFinish(res, set, &residue, status); 4445 break; 4446 } 4447 /* [unsafe REMNEAR drops through] */ 4448 } 4449 } /* fastpaths */ 4450 4451 /* Long (slow) division is needed; roll up the sleeves... */ 4452 4453 /* The accumulator will hold the quotient of the division. */ 4454 /* If it needs to be too long for stack storage, then allocate. */ 4455 acclength=D2U(reqdigits+DECDPUN); /* in Units */ 4456 if (acclength*sizeof(Unit)>sizeof(accbuff)) { 4457 /* printf("malloc dvacc %ld units\n", acclength); */ 4458 allocacc=(Unit *)malloc(acclength*sizeof(Unit)); 4459 if (allocacc==NULL) { /* hopeless -- abandon */ 4460 *status|=DEC_Insufficient_storage; 4461 break;} 4462 acc=allocacc; /* use the allocated space */ 4463 } 4464 4465 /* var1 is the padded LHS ready for subtractions. */ 4466 /* If it needs to be too long for stack storage, then allocate. */ 4467 /* The maximum units needed for var1 (long subtraction) is: */ 4468 /* Enough for */ 4469 /* (rhs->digits+reqdigits-1) -- to allow full slide to right */ 4470 /* or (lhs->digits) -- to allow for long lhs */ 4471 /* whichever is larger */ 4472 /* +1 -- for rounding of slide to right */ 4473 /* +1 -- for leading 0s */ 4474 /* +1 -- for pre-adjust if a remainder or DIVIDEINT */ 4475 /* [Note: unused units do not participate in decUnitAddSub data] */ 4476 maxdigits=rhs->digits+reqdigits-1; 4477 if (lhs->digits>maxdigits) maxdigits=lhs->digits; 4478 var1units=D2U(maxdigits)+2; 4479 /* allocate a guard unit above msu1 for REMAINDERNEAR */ 4480 if (!(op&DIVIDE)) var1units++; 4481 if ((var1units+1)*sizeof(Unit)>sizeof(varbuff)) { 4482 /* printf("malloc dvvar %ld units\n", var1units+1); */ 4483 varalloc=(Unit *)malloc((var1units+1)*sizeof(Unit)); 4484 if (varalloc==NULL) { /* hopeless -- abandon */ 4485 *status|=DEC_Insufficient_storage; 4486 break;} 4487 var1=varalloc; /* use the allocated space */ 4488 } 4489 4490 /* Extend the lhs and rhs to full long subtraction length. The lhs */ 4491 /* is truly extended into the var1 buffer, with 0 padding, so a */ 4492 /* subtract in place is always possible. The rhs (var2) has */ 4493 /* virtual padding (implemented by decUnitAddSub). */ 4494 /* One guard unit was allocated above msu1 for rem=rem+rem in */ 4495 /* REMAINDERNEAR. */ 4496 msu1=var1+var1units-1; /* msu of var1 */ 4497 source=lhs->lsu+D2U(lhs->digits)-1; /* msu of input array */ 4498 for (target=msu1; source>=lhs->lsu; source--, target--) *target=*source; 4499 for (; target>=var1; target--) *target=0; 4500 4501 /* rhs (var2) is left-aligned with var1 at the start */ 4502 var2ulen=var1units; /* rhs logical length (units) */ 4503 var2units=D2U(rhs->digits); /* rhs actual length (units) */ 4504 var2=rhs->lsu; /* -> rhs array */ 4505 msu2=var2+var2units-1; /* -> msu of var2 [never changes] */ 4506 /* now set up the variables which will be used for estimating the */ 4507 /* multiplication factor. If these variables are not exact, add */ 4508 /* 1 to make sure that the multiplier is never overestimated. */ 4509 msu2plus=*msu2; /* it's value .. */ 4510 if (var2units>1) msu2plus++; /* .. +1 if any more */ 4511 msu2pair=(eInt)*msu2*(DECDPUNMAX+1);/* top two pair .. */ 4512 if (var2units>1) { /* .. [else treat 2nd as 0] */ 4513 msu2pair+=*(msu2-1); /* .. */ 4514 if (var2units>2) msu2pair++; /* .. +1 if any more */ 4515 } 4516 4517 /* The calculation is working in units, which may have leading zeros, */ 4518 /* but the exponent was calculated on the assumption that they are */ 4519 /* both left-aligned. Adjust the exponent to compensate: add the */ 4520 /* number of leading zeros in var1 msu and subtract those in var2 msu. */ 4521 /* [This is actually done by counting the digits and negating, as */ 4522 /* lead1=DECDPUN-digits1, and similarly for lead2.] */ 4523 for (pow=&powers[1]; *msu1>=*pow; pow++) exponent--; 4524 for (pow=&powers[1]; *msu2>=*pow; pow++) exponent++; 4525 4526 /* Now, if doing an integer divide or remainder, ensure that */ 4527 /* the result will be Unit-aligned. To do this, shift the var1 */ 4528 /* accumulator towards least if need be. (It's much easier to */ 4529 /* do this now than to reassemble the residue afterwards, if */ 4530 /* doing a remainder.) Also ensure the exponent is not negative. */ 4531 if (!(op&DIVIDE)) { 4532 Unit *u; /* work */ 4533 /* save the initial 'false' padding of var1, in digits */ 4534 var1initpad=(var1units-D2U(lhs->digits))*DECDPUN; 4535 /* Determine the shift to do. */ 4536 if (exponent<0) cut=-exponent; 4537 else cut=DECDPUN-exponent%DECDPUN; 4538 decShiftToLeast(var1, var1units, cut); 4539 exponent+=cut; /* maintain numerical value */ 4540 var1initpad-=cut; /* .. and reduce padding */ 4541 /* clean any most-significant units which were just emptied */ 4542 for (u=msu1; cut>=DECDPUN; cut-=DECDPUN, u--) *u=0; 4543 } /* align */ 4544 else { /* is DIVIDE */ 4545 maxexponent=lhs->exponent-rhs->exponent; /* save */ 4546 /* optimization: if the first iteration will just produce 0, */ 4547 /* preadjust to skip it [valid for DIVIDE only] */ 4548 if (*msu1<*msu2) { 4549 var2ulen--; /* shift down */ 4550 exponent-=DECDPUN; /* update the exponent */ 4551 } 4552 } 4553 4554 /* ---- start the long-division loops ------------------------------ */ 4555 accunits=0; /* no units accumulated yet */ 4556 accdigits=0; /* .. or digits */ 4557 accnext=acc+acclength-1; /* -> msu of acc [NB: allows digits+1] */ 4558 for (;;) { /* outer forever loop */ 4559 thisunit=0; /* current unit assumed 0 */ 4560 /* find the next unit */ 4561 for (;;) { /* inner forever loop */ 4562 /* strip leading zero units [from either pre-adjust or from */ 4563 /* subtract last time around]. Leave at least one unit. */ 4564 for (; *msu1==0 && msu1>var1; msu1--) var1units--; 4565 4566 if (var1units<var2ulen) break; /* var1 too low for subtract */ 4567 if (var1units==var2ulen) { /* unit-by-unit compare needed */ 4568 /* compare the two numbers, from msu */ 4569 const Unit *pv1, *pv2; 4570 Unit v2; /* units to compare */ 4571 pv2=msu2; /* -> msu */ 4572 for (pv1=msu1; ; pv1--, pv2--) { 4573 /* v1=*pv1 -- always OK */ 4574 v2=0; /* assume in padding */ 4575 if (pv2>=var2) v2=*pv2; /* in range */ 4576 if (*pv1!=v2) break; /* no longer the same */ 4577 if (pv1==var1) break; /* done; leave pv1 as is */ 4578 } 4579 /* here when all inspected or a difference seen */ 4580 if (*pv1<v2) break; /* var1 too low to subtract */ 4581 if (*pv1==v2) { /* var1 == var2 */ 4582 /* reach here if var1 and var2 are identical; subtraction */ 4583 /* would increase digit by one, and the residue will be 0 so */ 4584 /* the calculation is done; leave the loop with residue=0. */ 4585 thisunit++; /* as though subtracted */ 4586 *var1=0; /* set var1 to 0 */ 4587 var1units=1; /* .. */ 4588 break; /* from inner */ 4589 } /* var1 == var2 */ 4590 /* *pv1>v2. Prepare for real subtraction; the lengths are equal */ 4591 /* Estimate the multiplier (there's always a msu1-1)... */ 4592 /* Bring in two units of var2 to provide a good estimate. */ 4593 mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2pair); 4594 } /* lengths the same */ 4595 else { /* var1units > var2ulen, so subtraction is safe */ 4596 /* The var2 msu is one unit towards the lsu of the var1 msu, */ 4597 /* so only one unit for var2 can be used. */ 4598 mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2plus); 4599 } 4600 if (mult==0) mult=1; /* must always be at least 1 */ 4601 /* subtraction needed; var1 is > var2 */ 4602 thisunit=(Unit)(thisunit+mult); /* accumulate */ 4603 /* subtract var1-var2, into var1; only the overlap needs */ 4604 /* processing, as this is an in-place calculation */ 4605 shift=var2ulen-var2units; 4606 #if DECTRACE 4607 decDumpAr('1', &var1[shift], var1units-shift); 4608 decDumpAr('2', var2, var2units); 4609 printf("m=%ld\n", -mult); 4610 #endif 4611 decUnitAddSub(&var1[shift], var1units-shift, 4612 var2, var2units, 0, 4613 &var1[shift], -mult); 4614 #if DECTRACE 4615 decDumpAr('#', &var1[shift], var1units-shift); 4616 #endif 4617 /* var1 now probably has leading zeros; these are removed at the */ 4618 /* top of the inner loop. */ 4619 } /* inner loop */ 4620 4621 /* The next unit has been calculated in full; unless it's a */ 4622 /* leading zero, add to acc */ 4623 if (accunits!=0 || thisunit!=0) { /* is first or non-zero */ 4624 *accnext=thisunit; /* store in accumulator */ 4625 /* account exactly for the new digits */ 4626 if (accunits==0) { 4627 accdigits++; /* at least one */ 4628 for (pow=&powers[1]; thisunit>=*pow; pow++) accdigits++; 4629 } 4630 else accdigits+=DECDPUN; 4631 accunits++; /* update count */ 4632 accnext--; /* ready for next */ 4633 if (accdigits>reqdigits) break; /* have enough digits */ 4634 } 4635 4636 /* if the residue is zero, the operation is done (unless divide */ 4637 /* or divideInteger and still not enough digits yet) */ 4638 if (*var1==0 && var1units==1) { /* residue is 0 */ 4639 if (op&(REMAINDER|REMNEAR)) break; 4640 if ((op&DIVIDE) && (exponent<=maxexponent)) break; 4641 /* [drop through if divideInteger] */ 4642 } 4643 /* also done enough if calculating remainder or integer */ 4644 /* divide and just did the last ('units') unit */ 4645 if (exponent==0 && !(op&DIVIDE)) break; 4646 4647 /* to get here, var1 is less than var2, so divide var2 by the per- */ 4648 /* Unit power of ten and go for the next digit */ 4649 var2ulen--; /* shift down */ 4650 exponent-=DECDPUN; /* update the exponent */ 4651 } /* outer loop */ 4652 4653 /* ---- division is complete --------------------------------------- */ 4654 /* here: acc has at least reqdigits+1 of good results (or fewer */ 4655 /* if early stop), starting at accnext+1 (its lsu) */ 4656 /* var1 has any residue at the stopping point */ 4657 /* accunits is the number of digits collected in acc */ 4658 if (accunits==0) { /* acc is 0 */ 4659 accunits=1; /* show have a unit .. */ 4660 accdigits=1; /* .. */ 4661 *accnext=0; /* .. whose value is 0 */ 4662 } 4663 else accnext++; /* back to last placed */ 4664 /* accnext now -> lowest unit of result */ 4665 4666 residue=0; /* assume no residue */ 4667 if (op&DIVIDE) { 4668 /* record the presence of any residue, for rounding */ 4669 if (*var1!=0 || var1units>1) residue=1; 4670 else { /* no residue */ 4671 /* Had an exact division; clean up spurious trailing 0s. */ 4672 /* There will be at most DECDPUN-1, from the final multiply, */ 4673 /* and then only if the result is non-0 (and even) and the */ 4674 /* exponent is 'loose'. */ 4675 #if DECDPUN>1 4676 Unit lsu=*accnext; 4677 if (!(lsu&0x01) && (lsu!=0)) { 4678 /* count the trailing zeros */ 4679 Int drop=0; 4680 for (;; drop++) { /* [will terminate because lsu!=0] */ 4681 if (exponent>=maxexponent) break; /* don't chop real 0s */ 4682 #if DECDPUN<=4 4683 if ((lsu-QUOT10(lsu, drop+1) 4684 *powers[drop+1])!=0) break; /* found non-0 digit */ 4685 #else 4686 if (lsu%powers[drop+1]!=0) break; /* found non-0 digit */ 4687 #endif 4688 exponent++; 4689 } 4690 if (drop>0) { 4691 accunits=decShiftToLeast(accnext, accunits, drop); 4692 accdigits=decGetDigits(accnext, accunits); 4693 accunits=D2U(accdigits); 4694 /* [exponent was adjusted in the loop] */ 4695 } 4696 } /* neither odd nor 0 */ 4697 #endif 4698 } /* exact divide */ 4699 } /* divide */ 4700 else /* op!=DIVIDE */ { 4701 /* check for coefficient overflow */ 4702 if (accdigits+exponent>reqdigits) { 4703 *status|=DEC_Division_impossible; 4704 break; 4705 } 4706 if (op & (REMAINDER|REMNEAR)) { 4707 /* [Here, the exponent will be 0, because var1 was adjusted */ 4708 /* appropriately.] */ 4709 Int postshift; /* work */ 4710 Flag wasodd=0; /* integer was odd */ 4711 Unit *quotlsu; /* for save */ 4712 Int quotdigits; /* .. */ 4713 4714 bits=lhs->bits; /* remainder sign is always as lhs */ 4715 4716 /* Fastpath when residue is truly 0 is worthwhile [and */ 4717 /* simplifies the code below] */ 4718 if (*var1==0 && var1units==1) { /* residue is 0 */ 4719 Int exp=lhs->exponent; /* save min(exponents) */ 4720 if (rhs->exponent<exp) exp=rhs->exponent; 4721 decNumberZero(res); /* 0 coefficient */ 4722 #if DECSUBSET 4723 if (set->extended) 4724 #endif 4725 res->exponent=exp; /* .. with proper exponent */ 4726 res->bits=(uByte)(bits&DECNEG); /* [cleaned] */ 4727 decFinish(res, set, &residue, status); /* might clamp */ 4728 break; 4729 } 4730 /* note if the quotient was odd */ 4731 if (*accnext & 0x01) wasodd=1; /* acc is odd */ 4732 quotlsu=accnext; /* save in case need to reinspect */ 4733 quotdigits=accdigits; /* .. */ 4734 4735 /* treat the residue, in var1, as the value to return, via acc */ 4736 /* calculate the unused zero digits. This is the smaller of: */ 4737 /* var1 initial padding (saved above) */ 4738 /* var2 residual padding, which happens to be given by: */ 4739 postshift=var1initpad+exponent-lhs->exponent+rhs->exponent; 4740 /* [the 'exponent' term accounts for the shifts during divide] */ 4741 if (var1initpad<postshift) postshift=var1initpad; 4742 4743 /* shift var1 the requested amount, and adjust its digits */ 4744 var1units=decShiftToLeast(var1, var1units, postshift); 4745 accnext=var1; 4746 accdigits=decGetDigits(var1, var1units); 4747 accunits=D2U(accdigits); 4748 4749 exponent=lhs->exponent; /* exponent is smaller of lhs & rhs */ 4750 if (rhs->exponent<exponent) exponent=rhs->exponent; 4751 4752 /* Now correct the result if doing remainderNear; if it */ 4753 /* (looking just at coefficients) is > rhs/2, or == rhs/2 and */ 4754 /* the integer was odd then the result should be rem-rhs. */ 4755 if (op&REMNEAR) { 4756 Int compare, tarunits; /* work */ 4757 Unit *up; /* .. */ 4758 /* calculate remainder*2 into the var1 buffer (which has */ 4759 /* 'headroom' of an extra unit and hence enough space) */ 4760 /* [a dedicated 'double' loop would be faster, here] */ 4761 tarunits=decUnitAddSub(accnext, accunits, accnext, accunits, 4762 0, accnext, 1); 4763 /* decDumpAr('r', accnext, tarunits); */ 4764 4765 /* Here, accnext (var1) holds tarunits Units with twice the */ 4766 /* remainder's coefficient, which must now be compared to the */ 4767 /* RHS. The remainder's exponent may be smaller than the RHS's. */ 4768 compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits), 4769 rhs->exponent-exponent); 4770 if (compare==BADINT) { /* deep trouble */ 4771 *status|=DEC_Insufficient_storage; 4772 break;} 4773 4774 /* now restore the remainder by dividing by two; the lsu */ 4775 /* is known to be even. */ 4776 for (up=accnext; up<accnext+tarunits; up++) { 4777 Int half; /* half to add to lower unit */ 4778 half=*up & 0x01; 4779 *up/=2; /* [shift] */ 4780 if (!half) continue; 4781 *(up-1)+=(DECDPUNMAX+1)/2; 4782 } 4783 /* [accunits still describes the original remainder length] */ 4784 4785 if (compare>0 || (compare==0 && wasodd)) { /* adjustment needed */ 4786 Int exp, expunits, exprem; /* work */ 4787 /* This is effectively causing round-up of the quotient, */ 4788 /* so if it was the rare case where it was full and all */ 4789 /* nines, it would overflow and hence division-impossible */ 4790 /* should be raised */ 4791 Flag allnines=0; /* 1 if quotient all nines */ 4792 if (quotdigits==reqdigits) { /* could be borderline */ 4793 for (up=quotlsu; ; up++) { 4794 if (quotdigits>DECDPUN) { 4795 if (*up!=DECDPUNMAX) break;/* non-nines */ 4796 } 4797 else { /* this is the last Unit */ 4798 if (*up==powers[quotdigits]-1) allnines=1; 4799 break; 4800 } 4801 quotdigits-=DECDPUN; /* checked those digits */ 4802 } /* up */ 4803 } /* borderline check */ 4804 if (allnines) { 4805 *status|=DEC_Division_impossible; 4806 break;} 4807 4808 /* rem-rhs is needed; the sign will invert. Again, var1 */ 4809 /* can safely be used for the working Units array. */ 4810 exp=rhs->exponent-exponent; /* RHS padding needed */ 4811 /* Calculate units and remainder from exponent. */ 4812 expunits=exp/DECDPUN; 4813 exprem=exp%DECDPUN; 4814 /* subtract [A+B*(-m)]; the result will always be negative */ 4815 accunits=-decUnitAddSub(accnext, accunits, 4816 rhs->lsu, D2U(rhs->digits), 4817 expunits, accnext, -(Int)powers[exprem]); 4818 accdigits=decGetDigits(accnext, accunits); /* count digits exactly */ 4819 accunits=D2U(accdigits); /* and recalculate the units for copy */ 4820 /* [exponent is as for original remainder] */ 4821 bits^=DECNEG; /* flip the sign */ 4822 } 4823 } /* REMNEAR */ 4824 } /* REMAINDER or REMNEAR */ 4825 } /* not DIVIDE */ 4826 4827 /* Set exponent and bits */ 4828 res->exponent=exponent; 4829 res->bits=(uByte)(bits&DECNEG); /* [cleaned] */ 4830 4831 /* Now the coefficient. */ 4832 decSetCoeff(res, set, accnext, accdigits, &residue, status); 4833 4834 decFinish(res, set, &residue, status); /* final cleanup */ 4835 4836 #if DECSUBSET 4837 /* If a divide then strip trailing zeros if subset [after round] */ 4838 if (!set->extended && (op==DIVIDE)) decTrim(res, set, 0, &dropped); 4839 #endif 4840 } while(0); /* end protected */ 4841 4842 if (varalloc!=NULL) free(varalloc); /* drop any storage used */ 4843 if (allocacc!=NULL) free(allocacc); /* .. */ 4844 #if DECSUBSET 4845 if (allocrhs!=NULL) free(allocrhs); /* .. */ 4846 if (alloclhs!=NULL) free(alloclhs); /* .. */ 4847 #endif 4848 return res; 4849 } /* decDivideOp */ 4850 4851 /* ------------------------------------------------------------------ */ 4852 /* decMultiplyOp -- multiplication operation */ 4853 /* */ 4854 /* This routine performs the multiplication C=A x B. */ 4855 /* */ 4856 /* res is C, the result. C may be A and/or B (e.g., X=X*X) */ 4857 /* lhs is A */ 4858 /* rhs is B */ 4859 /* set is the context */ 4860 /* status is the usual accumulator */ 4861 /* */ 4862 /* C must have space for set->digits digits. */ 4863 /* */ 4864 /* ------------------------------------------------------------------ */ 4865 /* 'Classic' multiplication is used rather than Karatsuba, as the */ 4866 /* latter would give only a minor improvement for the short numbers */ 4867 /* expected to be handled most (and uses much more memory). */ 4868 /* */ 4869 /* There are two major paths here: the general-purpose ('old code') */ 4870 /* path which handles all DECDPUN values, and a fastpath version */ 4871 /* which is used if 64-bit ints are available, DECDPUN<=4, and more */ 4872 /* than two calls to decUnitAddSub would be made. */ 4873 /* */ 4874 /* The fastpath version lumps units together into 8-digit or 9-digit */ 4875 /* chunks, and also uses a lazy carry strategy to minimise expensive */ 4876 /* 64-bit divisions. The chunks are then broken apart again into */ 4877 /* units for continuing processing. Despite this overhead, the */ 4878 /* fastpath can speed up some 16-digit operations by 10x (and much */ 4879 /* more for higher-precision calculations). */ 4880 /* */ 4881 /* A buffer always has to be used for the accumulator; in the */ 4882 /* fastpath, buffers are also always needed for the chunked copies of */ 4883 /* of the operand coefficients. */ 4884 /* Static buffers are larger than needed just for multiply, to allow */ 4885 /* for calls from other operations (notably exp). */ 4886 /* ------------------------------------------------------------------ */ 4887 #define FASTMUL (DECUSE64 && DECDPUN<5) 4888 static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs, 4889 const decNumber *rhs, decContext *set, 4890 uInt *status) { 4891 Int accunits; /* Units of accumulator in use */ 4892 Int exponent; /* work */ 4893 Int residue=0; /* rounding residue */ 4894 uByte bits; /* result sign */ 4895 Unit *acc; /* -> accumulator Unit array */ 4896 Int needbytes; /* size calculator */ 4897 void *allocacc=NULL; /* -> allocated accumulator, iff allocated */ 4898 Unit accbuff[SD2U(DECBUFFER*4+1)]; /* buffer (+1 for DECBUFFER==0, */ 4899 /* *4 for calls from other operations) */ 4900 const Unit *mer, *mermsup; /* work */ 4901 Int madlength; /* Units in multiplicand */ 4902 Int shift; /* Units to shift multiplicand by */ 4903 4904 #if FASTMUL 4905 /* if DECDPUN is 1 or 3 work in base 10**9, otherwise */ 4906 /* (DECDPUN is 2 or 4) then work in base 10**8 */ 4907 #if DECDPUN & 1 /* odd */ 4908 #define FASTBASE 1000000000 /* base */ 4909 #define FASTDIGS 9 /* digits in base */ 4910 #define FASTLAZY 18 /* carry resolution point [1->18] */ 4911 #else 4912 #define FASTBASE 100000000 4913 #define FASTDIGS 8 4914 #define FASTLAZY 1844 /* carry resolution point [1->1844] */ 4915 #endif 4916 /* three buffers are used, two for chunked copies of the operands */ 4917 /* (base 10**8 or base 10**9) and one base 2**64 accumulator with */ 4918 /* lazy carry evaluation */ 4919 uInt zlhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */ 4920 uInt *zlhi=zlhibuff; /* -> lhs array */ 4921 uInt *alloclhi=NULL; /* -> allocated buffer, iff allocated */ 4922 uInt zrhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */ 4923 uInt *zrhi=zrhibuff; /* -> rhs array */ 4924 uInt *allocrhi=NULL; /* -> allocated buffer, iff allocated */ 4925 uLong zaccbuff[(DECBUFFER*2+1)/4+2]; /* buffer (+1 for DECBUFFER==0) */ 4926 /* [allocacc is shared for both paths, as only one will run] */ 4927 uLong *zacc=zaccbuff; /* -> accumulator array for exact result */ 4928 #if DECDPUN==1 4929 Int zoff; /* accumulator offset */ 4930 #endif 4931 uInt *lip, *rip; /* item pointers */ 4932 uInt *lmsi, *rmsi; /* most significant items */ 4933 Int ilhs, irhs, iacc; /* item counts in the arrays */ 4934 Int lazy; /* lazy carry counter */ 4935 uLong lcarry; /* uLong carry */ 4936 uInt carry; /* carry (NB not uLong) */ 4937 Int count; /* work */ 4938 const Unit *cup; /* .. */ 4939 Unit *up; /* .. */ 4940 uLong *lp; /* .. */ 4941 Int p; /* .. */ 4942 #endif 4943 4944 #if DECSUBSET 4945 decNumber *alloclhs=NULL; /* -> allocated buffer, iff allocated */ 4946 decNumber *allocrhs=NULL; /* -> allocated buffer, iff allocated */ 4947 #endif 4948 4949 #if DECCHECK 4950 if (decCheckOperands(res, lhs, rhs, set)) return res; 4951 #endif 4952 4953 /* precalculate result sign */ 4954 bits=(uByte)((lhs->bits^rhs->bits)&DECNEG); 4955 4956 /* handle infinities and NaNs */ 4957 if (SPECIALARGS) { /* a special bit set */ 4958 if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */ 4959 decNaNs(res, lhs, rhs, set, status); 4960 return res;} 4961 /* one or two infinities; Infinity * 0 is invalid */ 4962 if (((lhs->bits & DECINF)==0 && ISZERO(lhs)) 4963 ||((rhs->bits & DECINF)==0 && ISZERO(rhs))) { 4964 *status|=DEC_Invalid_operation; 4965 return res;} 4966 decNumberZero(res); 4967 res->bits=bits|DECINF; /* infinity */ 4968 return res;} 4969 4970 /* For best speed, as in DMSRCN [the original Rexx numerics */ 4971 /* module], use the shorter number as the multiplier (rhs) and */ 4972 /* the longer as the multiplicand (lhs) to minimise the number of */ 4973 /* adds (partial products) */ 4974 if (lhs->digits<rhs->digits) { /* swap... */ 4975 const decNumber *hold=lhs; 4976 lhs=rhs; 4977 rhs=hold; 4978 } 4979 4980 do { /* protect allocated storage */ 4981 #if DECSUBSET 4982 if (!set->extended) { 4983 /* reduce operands and set lostDigits status, as needed */ 4984 if (lhs->digits>set->digits) { 4985 alloclhs=decRoundOperand(lhs, set, status); 4986 if (alloclhs==NULL) break; 4987 lhs=alloclhs; 4988 } 4989 if (rhs->digits>set->digits) { 4990 allocrhs=decRoundOperand(rhs, set, status); 4991 if (allocrhs==NULL) break; 4992 rhs=allocrhs; 4993 } 4994 } 4995 #endif 4996 /* [following code does not require input rounding] */ 4997 4998 #if FASTMUL /* fastpath can be used */ 4999 /* use the fast path if there are enough digits in the shorter */ 5000 /* operand to make the setup and takedown worthwhile */ 5001 #define NEEDTWO (DECDPUN*2) /* within two decUnitAddSub calls */ 5002 if (rhs->digits>NEEDTWO) { /* use fastpath... */ 5003 /* calculate the number of elements in each array */ 5004 ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; /* [ceiling] */ 5005 irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; /* .. */ 5006 iacc=ilhs+irhs; 5007 5008 /* allocate buffers if required, as usual */ 5009 needbytes=ilhs*sizeof(uInt); 5010 if (needbytes>(Int)sizeof(zlhibuff)) { 5011 alloclhi=(uInt *)malloc(needbytes); 5012 zlhi=alloclhi;} 5013 needbytes=irhs*sizeof(uInt); 5014 if (needbytes>(Int)sizeof(zrhibuff)) { 5015 allocrhi=(uInt *)malloc(needbytes); 5016 zrhi=allocrhi;} 5017 5018 /* Allocating the accumulator space needs a special case when */ 5019 /* DECDPUN=1 because when converting the accumulator to Units */ 5020 /* after the multiplication each 8-byte item becomes 9 1-byte */ 5021 /* units. Therefore iacc extra bytes are needed at the front */ 5022 /* (rounded up to a multiple of 8 bytes), and the uLong */ 5023 /* accumulator starts offset the appropriate number of units */ 5024 /* to the right to avoid overwrite during the unchunking. */ 5025 needbytes=iacc*sizeof(uLong); 5026 #if DECDPUN==1 5027 zoff=(iacc+7)/8; /* items to offset by */ 5028 needbytes+=zoff*8; 5029 #endif 5030 if (needbytes>(Int)sizeof(zaccbuff)) { 5031 allocacc=(uLong *)malloc(needbytes); 5032 zacc=(uLong *)allocacc;} 5033 if (zlhi==NULL||zrhi==NULL||zacc==NULL) { 5034 *status|=DEC_Insufficient_storage; 5035 break;} 5036 5037 acc=(Unit *)zacc; /* -> target Unit array */ 5038 #if DECDPUN==1 5039 zacc+=zoff; /* start uLong accumulator to right */ 5040 #endif 5041 5042 /* assemble the chunked copies of the left and right sides */ 5043 for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++) 5044 for (p=0, *lip=0; p<FASTDIGS && count>0; 5045 p+=DECDPUN, cup++, count-=DECDPUN) 5046 *lip+=*cup*powers[p]; 5047 lmsi=lip-1; /* save -> msi */ 5048 for (count=rhs->digits, cup=rhs->lsu, rip=zrhi; count>0; rip++) 5049 for (p=0, *rip=0; p<FASTDIGS && count>0; 5050 p+=DECDPUN, cup++, count-=DECDPUN) 5051 *rip+=*cup*powers[p]; 5052 rmsi=rip-1; /* save -> msi */ 5053 5054 /* zero the accumulator */ 5055 for (lp=zacc; lp<zacc+iacc; lp++) *lp=0; 5056 5057 /* Start the multiplication */ 5058 /* Resolving carries can dominate the cost of accumulating the */ 5059 /* partial products, so this is only done when necessary. */ 5060 /* Each uLong item in the accumulator can hold values up to */ 5061 /* 2**64-1, and each partial product can be as large as */ 5062 /* (10**FASTDIGS-1)**2. When FASTDIGS=9, this can be added to */ 5063 /* itself 18.4 times in a uLong without overflowing, so during */ 5064 /* the main calculation resolution is carried out every 18th */ 5065 /* add -- every 162 digits. Similarly, when FASTDIGS=8, the */ 5066 /* partial products can be added to themselves 1844.6 times in */ 5067 /* a uLong without overflowing, so intermediate carry */ 5068 /* resolution occurs only every 14752 digits. Hence for common */ 5069 /* short numbers usually only the one final carry resolution */ 5070 /* occurs. */ 5071 /* (The count is set via FASTLAZY to simplify experiments to */ 5072 /* measure the value of this approach: a 35% improvement on a */ 5073 /* [34x34] multiply.) */ 5074 lazy=FASTLAZY; /* carry delay count */ 5075 for (rip=zrhi; rip<=rmsi; rip++) { /* over each item in rhs */ 5076 lp=zacc+(rip-zrhi); /* where to add the lhs */ 5077 for (lip=zlhi; lip<=lmsi; lip++, lp++) { /* over each item in lhs */ 5078 *lp+=(uLong)(*lip)*(*rip); /* [this should in-line] */ 5079 } /* lip loop */ 5080 lazy--; 5081 if (lazy>0 && rip!=rmsi) continue; 5082 lazy=FASTLAZY; /* reset delay count */ 5083 /* spin up the accumulator resolving overflows */ 5084 for (lp=zacc; lp<zacc+iacc; lp++) { 5085 if (*lp<FASTBASE) continue; /* it fits */ 5086 lcarry=*lp/FASTBASE; /* top part [slow divide] */ 5087 /* lcarry can exceed 2**32-1, so check again; this check */ 5088 /* and occasional extra divide (slow) is well worth it, as */ 5089 /* it allows FASTLAZY to be increased to 18 rather than 4 */ 5090 /* in the FASTDIGS=9 case */ 5091 if (lcarry<FASTBASE) carry=(uInt)lcarry; /* [usual] */ 5092 else { /* two-place carry [fairly rare] */ 5093 uInt carry2=(uInt)(lcarry/FASTBASE); /* top top part */ 5094 *(lp+2)+=carry2; /* add to item+2 */ 5095 *lp-=((uLong)FASTBASE*FASTBASE*carry2); /* [slow] */ 5096 carry=(uInt)(lcarry-((uLong)FASTBASE*carry2)); /* [inline] */ 5097 } 5098 *(lp+1)+=carry; /* add to item above [inline] */ 5099 *lp-=((uLong)FASTBASE*carry); /* [inline] */ 5100 } /* carry resolution */ 5101 } /* rip loop */ 5102 5103 /* The multiplication is complete; time to convert back into */ 5104 /* units. This can be done in-place in the accumulator and in */ 5105 /* 32-bit operations, because carries were resolved after the */ 5106 /* final add. This needs N-1 divides and multiplies for */ 5107 /* each item in the accumulator (which will become up to N */ 5108 /* units, where 2<=N<=9). */ 5109 for (lp=zacc, up=acc; lp<zacc+iacc; lp++) { 5110 uInt item=(uInt)*lp; /* decapitate to uInt */ 5111 for (p=0; p<FASTDIGS-DECDPUN; p+=DECDPUN, up++) { 5112 uInt part=item/(DECDPUNMAX+1); 5113 *up=(Unit)(item-(part*(DECDPUNMAX+1))); 5114 item=part; 5115 } /* p */ 5116 *up=(Unit)item; up++; /* [final needs no division] */ 5117 } /* lp */ 5118 accunits=up-acc; /* count of units */ 5119 } 5120 else { /* here to use units directly, without chunking ['old code'] */ 5121 #endif 5122 5123 /* if accumulator will be too long for local storage, then allocate */ 5124 acc=accbuff; /* -> assume buffer for accumulator */ 5125 needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit); 5126 if (needbytes>(Int)sizeof(accbuff)) { 5127 allocacc=(Unit *)malloc(needbytes); 5128 if (allocacc==NULL) {*status|=DEC_Insufficient_storage; break;} 5129 acc=(Unit *)allocacc; /* use the allocated space */ 5130 } 5131 5132 /* Now the main long multiplication loop */ 5133 /* Unlike the equivalent in the IBM Java implementation, there */ 5134 /* is no advantage in calculating from msu to lsu. So, do it */ 5135 /* by the book, as it were. */ 5136 /* Each iteration calculates ACC=ACC+MULTAND*MULT */ 5137 accunits=1; /* accumulator starts at '0' */ 5138 *acc=0; /* .. (lsu=0) */ 5139 shift=0; /* no multiplicand shift at first */ 5140 madlength=D2U(lhs->digits); /* this won't change */ 5141 mermsup=rhs->lsu+D2U(rhs->digits); /* -> msu+1 of multiplier */ 5142 5143 for (mer=rhs->lsu; mer<mermsup; mer++) { 5144 /* Here, *mer is the next Unit in the multiplier to use */ 5145 /* If non-zero [optimization] add it... */ 5146 if (*mer!=0) accunits=decUnitAddSub(&acc[shift], accunits-shift, 5147 lhs->lsu, madlength, 0, 5148 &acc[shift], *mer) 5149 + shift; 5150 else { /* extend acc with a 0; it will be used shortly */ 5151 *(acc+accunits)=0; /* [this avoids length of <=0 later] */ 5152 accunits++; 5153 } 5154 /* multiply multiplicand by 10**DECDPUN for next Unit to left */ 5155 shift++; /* add this for 'logical length' */ 5156 } /* n */ 5157 #if FASTMUL 5158 } /* unchunked units */ 5159 #endif 5160 /* common end-path */ 5161 #if DECTRACE 5162 decDumpAr('*', acc, accunits); /* Show exact result */ 5163 #endif 5164 5165 /* acc now contains the exact result of the multiplication, */ 5166 /* possibly with a leading zero unit; build the decNumber from */ 5167 /* it, noting if any residue */ 5168 res->bits=bits; /* set sign */ 5169 res->digits=decGetDigits(acc, accunits); /* count digits exactly */ 5170 5171 /* There can be a 31-bit wrap in calculating the exponent. */ 5172 /* This can only happen if both input exponents are negative and */ 5173 /* both their magnitudes are large. If there was a wrap, set a */ 5174 /* safe very negative exponent, from which decFinalize() will */ 5175 /* raise a hard underflow shortly. */ 5176 exponent=lhs->exponent+rhs->exponent; /* calculate exponent */ 5177 if (lhs->exponent<0 && rhs->exponent<0 && exponent>0) 5178 exponent=-2*DECNUMMAXE; /* force underflow */ 5179 res->exponent=exponent; /* OK to overwrite now */ 5180 5181 5182 /* Set the coefficient. If any rounding, residue records */ 5183 decSetCoeff(res, set, acc, res->digits, &residue, status); 5184 decFinish(res, set, &residue, status); /* final cleanup */ 5185 } while(0); /* end protected */ 5186 5187 if (allocacc!=NULL) free(allocacc); /* drop any storage used */ 5188 #if DECSUBSET 5189 if (allocrhs!=NULL) free(allocrhs); /* .. */ 5190 if (alloclhs!=NULL) free(alloclhs); /* .. */ 5191 #endif 5192 #if FASTMUL 5193 if (allocrhi!=NULL) free(allocrhi); /* .. */ 5194 if (alloclhi!=NULL) free(alloclhi); /* .. */ 5195 #endif 5196 return res; 5197 } /* decMultiplyOp */ 5198 5199 /* ------------------------------------------------------------------ */ 5200 /* decExpOp -- effect exponentiation */ 5201 /* */ 5202 /* This computes C = exp(A) */ 5203 /* */ 5204 /* res is C, the result. C may be A */ 5205 /* rhs is A */ 5206 /* set is the context; note that rounding mode has no effect */ 5207 /* */ 5208 /* C must have space for set->digits digits. status is updated but */ 5209 /* not set. */ 5210 /* */ 5211 /* Restrictions: */ 5212 /* */ 5213 /* digits, emax, and -emin in the context must be less than */ 5214 /* 2*DEC_MAX_MATH (1999998), and the rhs must be within these */ 5215 /* bounds or a zero. This is an internal routine, so these */ 5216 /* restrictions are contractual and not enforced. */ 5217 /* */ 5218 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */ 5219 /* almost always be correctly rounded, but may be up to 1 ulp in */ 5220 /* error in rare cases. */ 5221 /* */ 5222 /* Finite results will always be full precision and Inexact, except */ 5223 /* when A is a zero or -Infinity (giving 1 or 0 respectively). */ 5224 /* ------------------------------------------------------------------ */ 5225 /* This approach used here is similar to the algorithm described in */ 5226 /* */ 5227 /* Variable Precision Exponential Function, T. E. Hull and */ 5228 /* A. Abrham, ACM Transactions on Mathematical Software, Vol 12 #2, */ 5229 /* pp79-91, ACM, June 1986. */ 5230 /* */ 5231 /* with the main difference being that the iterations in the series */ 5232 /* evaluation are terminated dynamically (which does not require the */ 5233 /* extra variable-precision variables which are expensive in this */ 5234 /* context). */ 5235 /* */ 5236 /* The error analysis in Hull & Abrham's paper applies except for the */ 5237 /* round-off error accumulation during the series evaluation. This */ 5238 /* code does not precalculate the number of iterations and so cannot */ 5239 /* use Horner's scheme. Instead, the accumulation is done at double- */ 5240 /* precision, which ensures that the additions of the terms are exact */ 5241 /* and do not accumulate round-off (and any round-off errors in the */ 5242 /* terms themselves move 'to the right' faster than they can */ 5243 /* accumulate). This code also extends the calculation by allowing, */ 5244 /* in the spirit of other decNumber operators, the input to be more */ 5245 /* precise than the result (the precision used is based on the more */ 5246 /* precise of the input or requested result). */ 5247 /* */ 5248 /* Implementation notes: */ 5249 /* */ 5250 /* 1. This is separated out as decExpOp so it can be called from */ 5251 /* other Mathematical functions (notably Ln) with a wider range */ 5252 /* than normal. In particular, it can handle the slightly wider */ 5253 /* (double) range needed by Ln (which has to be able to calculate */ 5254 /* exp(-x) where x can be the tiniest number (Ntiny). */ 5255 /* */ 5256 /* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop */ 5257 /* iterations by appoximately a third with additional (although */ 5258 /* diminishing) returns as the range is reduced to even smaller */ 5259 /* fractions. However, h (the power of 10 used to correct the */ 5260 /* result at the end, see below) must be kept <=8 as otherwise */ 5261 /* the final result cannot be computed. Hence the leverage is a */ 5262 /* sliding value (8-h), where potentially the range is reduced */ 5263 /* more for smaller values. */ 5264 /* */ 5265 /* The leverage that can be applied in this way is severely */ 5266 /* limited by the cost of the raise-to-the power at the end, */ 5267 /* which dominates when the number of iterations is small (less */ 5268 /* than ten) or when rhs is short. As an example, the adjustment */ 5269 /* x**10,000,000 needs 31 multiplications, all but one full-width. */ 5270 /* */ 5271 /* 3. The restrictions (especially precision) could be raised with */ 5272 /* care, but the full decNumber range seems very hard within the */ 5273 /* 32-bit limits. */ 5274 /* */ 5275 /* 4. The working precisions for the static buffers are twice the */ 5276 /* obvious size to allow for calls from decNumberPower. */ 5277 /* ------------------------------------------------------------------ */ 5278 static decNumber *decExpOp(decNumber *res, const decNumber *rhs, 5279 decContext *set, uInt *status) { 5280 uInt ignore=0; /* working status */ 5281 Int h; /* adjusted exponent for 0.xxxx */ 5282 Int p; /* working precision */ 5283 Int residue; /* rounding residue */ 5284 uInt needbytes; /* for space calculations */ 5285 const decNumber *x=rhs; /* (may point to safe copy later) */ 5286 decContext aset, tset, dset; /* working contexts */ 5287 Int comp; /* work */ 5288 5289 /* the argument is often copied to normalize it, so (unusually) it */ 5290 /* is treated like other buffers, using DECBUFFER, +1 in case */ 5291 /* DECBUFFER is 0 */ 5292 decNumber bufr[D2N(DECBUFFER*2+1)]; 5293 decNumber *allocrhs=NULL; /* non-NULL if rhs buffer allocated */ 5294 5295 /* the working precision will be no more than set->digits+8+1 */ 5296 /* so for on-stack buffers DECBUFFER+9 is used, +1 in case DECBUFFER */ 5297 /* is 0 (and twice that for the accumulator) */ 5298 5299 /* buffer for t, term (working precision plus) */ 5300 decNumber buft[D2N(DECBUFFER*2+9+1)]; 5301 decNumber *allocbuft=NULL; /* -> allocated buft, iff allocated */ 5302 decNumber *t=buft; /* term */ 5303 /* buffer for a, accumulator (working precision * 2), at least 9 */ 5304 decNumber bufa[D2N(DECBUFFER*4+18+1)]; 5305 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 5306 decNumber *a=bufa; /* accumulator */ 5307 /* decNumber for the divisor term; this needs at most 9 digits */ 5308 /* and so can be fixed size [16 so can use standard context] */ 5309 decNumber bufd[D2N(16)]; 5310 decNumber *d=bufd; /* divisor */ 5311 decNumber numone; /* constant 1 */ 5312 5313 #if DECCHECK 5314 Int iterations=0; /* for later sanity check */ 5315 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 5316 #endif 5317 5318 do { /* protect allocated storage */ 5319 if (SPECIALARG) { /* handle infinities and NaNs */ 5320 if (decNumberIsInfinite(rhs)) { /* an infinity */ 5321 if (decNumberIsNegative(rhs)) /* -Infinity -> +0 */ 5322 decNumberZero(res); 5323 else decNumberCopy(res, rhs); /* +Infinity -> self */ 5324 } 5325 else decNaNs(res, rhs, NULL, set, status); /* a NaN */ 5326 break;} 5327 5328 if (ISZERO(rhs)) { /* zeros -> exact 1 */ 5329 decNumberZero(res); /* make clean 1 */ 5330 *res->lsu=1; /* .. */ 5331 break;} /* [no status to set] */ 5332 5333 /* e**x when 0 < x < 0.66 is < 1+3x/2, hence can fast-path */ 5334 /* positive and negative tiny cases which will result in inexact */ 5335 /* 1. This also allows the later add-accumulate to always be */ 5336 /* exact (because its length will never be more than twice the */ 5337 /* working precision). */ 5338 /* The comparator (tiny) needs just one digit, so use the */ 5339 /* decNumber d for it (reused as the divisor, etc., below); its */ 5340 /* exponent is such that if x is positive it will have */ 5341 /* set->digits-1 zeros between the decimal point and the digit, */ 5342 /* which is 4, and if x is negative one more zero there as the */ 5343 /* more precise result will be of the form 0.9999999 rather than */ 5344 /* 1.0000001. Hence, tiny will be 0.0000004 if digits=7 and x>0 */ 5345 /* or 0.00000004 if digits=7 and x<0. If RHS not larger than */ 5346 /* this then the result will be 1.000000 */ 5347 decNumberZero(d); /* clean */ 5348 *d->lsu=4; /* set 4 .. */ 5349 d->exponent=-set->digits; /* * 10**(-d) */ 5350 if (decNumberIsNegative(rhs)) d->exponent--; /* negative case */ 5351 comp=decCompare(d, rhs, 1); /* signless compare */ 5352 if (comp==BADINT) { 5353 *status|=DEC_Insufficient_storage; 5354 break;} 5355 if (comp>=0) { /* rhs < d */ 5356 Int shift=set->digits-1; 5357 decNumberZero(res); /* set 1 */ 5358 *res->lsu=1; /* .. */ 5359 res->digits=decShiftToMost(res->lsu, 1, shift); 5360 res->exponent=-shift; /* make 1.0000... */ 5361 *status|=DEC_Inexact | DEC_Rounded; /* .. inexactly */ 5362 break;} /* tiny */ 5363 5364 /* set up the context to be used for calculating a, as this is */ 5365 /* used on both paths below */ 5366 decContextDefault(&aset, DEC_INIT_DECIMAL64); 5367 /* accumulator bounds are as requested (could underflow) */ 5368 aset.emax=set->emax; /* usual bounds */ 5369 aset.emin=set->emin; /* .. */ 5370 aset.clamp=0; /* and no concrete format */ 5371 5372 /* calculate the adjusted (Hull & Abrham) exponent (where the */ 5373 /* decimal point is just to the left of the coefficient msd) */ 5374 h=rhs->exponent+rhs->digits; 5375 /* if h>8 then 10**h cannot be calculated safely; however, when */ 5376 /* h=8 then exp(|rhs|) will be at least exp(1E+7) which is at */ 5377 /* least 6.59E+4342944, so (due to the restriction on Emax/Emin) */ 5378 /* overflow (or underflow to 0) is guaranteed -- so this case can */ 5379 /* be handled by simply forcing the appropriate excess */ 5380 if (h>8) { /* overflow/underflow */ 5381 /* set up here so Power call below will over or underflow to */ 5382 /* zero; set accumulator to either 2 or 0.02 */ 5383 /* [stack buffer for a is always big enough for this] */ 5384 decNumberZero(a); 5385 *a->lsu=2; /* not 1 but < exp(1) */ 5386 if (decNumberIsNegative(rhs)) a->exponent=-2; /* make 0.02 */ 5387 h=8; /* clamp so 10**h computable */ 5388 p=9; /* set a working precision */ 5389 } 5390 else { /* h<=8 */ 5391 Int maxlever=(rhs->digits>8?1:0); 5392 /* [could/should increase this for precisions >40 or so, too] */ 5393 5394 /* if h is 8, cannot normalize to a lower upper limit because */ 5395 /* the final result will not be computable (see notes above), */ 5396 /* but leverage can be applied whenever h is less than 8. */ 5397 /* Apply as much as possible, up to a MAXLEVER digits, which */ 5398 /* sets the tradeoff against the cost of the later a**(10**h). */ 5399 /* As h is increased, the working precision below also */ 5400 /* increases to compensate for the "constant digits at the */ 5401 /* front" effect. */ 5402 Int lever=MINI(8-h, maxlever); /* leverage attainable */ 5403 Int use=-rhs->digits-lever; /* exponent to use for RHS */ 5404 h+=lever; /* apply leverage selected */ 5405 if (h<0) { /* clamp */ 5406 use+=h; /* [may end up subnormal] */ 5407 h=0; 5408 } 5409 /* Take a copy of RHS if it needs normalization (true whenever x>=1) */ 5410 if (rhs->exponent!=use) { 5411 decNumber *newrhs=bufr; /* assume will fit on stack */ 5412 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); 5413 if (needbytes>sizeof(bufr)) { /* need malloc space */ 5414 allocrhs=(decNumber *)malloc(needbytes); 5415 if (allocrhs==NULL) { /* hopeless -- abandon */ 5416 *status|=DEC_Insufficient_storage; 5417 break;} 5418 newrhs=allocrhs; /* use the allocated space */ 5419 } 5420 decNumberCopy(newrhs, rhs); /* copy to safe space */ 5421 newrhs->exponent=use; /* normalize; now <1 */ 5422 x=newrhs; /* ready for use */ 5423 /* decNumberShow(x); */ 5424 } 5425 5426 /* Now use the usual power series to evaluate exp(x). The */ 5427 /* series starts as 1 + x + x^2/2 ... so prime ready for the */ 5428 /* third term by setting the term variable t=x, the accumulator */ 5429 /* a=1, and the divisor d=2. */ 5430 5431 /* First determine the working precision. From Hull & Abrham */ 5432 /* this is set->digits+h+2. However, if x is 'over-precise' we */ 5433 /* need to allow for all its digits to potentially participate */ 5434 /* (consider an x where all the excess digits are 9s) so in */ 5435 /* this case use x->digits+h+2 */ 5436 p=MAXI(x->digits, set->digits)+h+2; /* [h<=8] */ 5437 5438 /* a and t are variable precision, and depend on p, so space */ 5439 /* must be allocated for them if necessary */ 5440 5441 /* the accumulator needs to be able to hold 2p digits so that */ 5442 /* the additions on the second and subsequent iterations are */ 5443 /* sufficiently exact. */ 5444 needbytes=sizeof(decNumber)+(D2U(p*2)-1)*sizeof(Unit); 5445 if (needbytes>sizeof(bufa)) { /* need malloc space */ 5446 allocbufa=(decNumber *)malloc(needbytes); 5447 if (allocbufa==NULL) { /* hopeless -- abandon */ 5448 *status|=DEC_Insufficient_storage; 5449 break;} 5450 a=allocbufa; /* use the allocated space */ 5451 } 5452 /* the term needs to be able to hold p digits (which is */ 5453 /* guaranteed to be larger than x->digits, so the initial copy */ 5454 /* is safe); it may also be used for the raise-to-power */ 5455 /* calculation below, which needs an extra two digits */ 5456 needbytes=sizeof(decNumber)+(D2U(p+2)-1)*sizeof(Unit); 5457 if (needbytes>sizeof(buft)) { /* need malloc space */ 5458 allocbuft=(decNumber *)malloc(needbytes); 5459 if (allocbuft==NULL) { /* hopeless -- abandon */ 5460 *status|=DEC_Insufficient_storage; 5461 break;} 5462 t=allocbuft; /* use the allocated space */ 5463 } 5464 5465 decNumberCopy(t, x); /* term=x */ 5466 decNumberZero(a); *a->lsu=1; /* accumulator=1 */ 5467 decNumberZero(d); *d->lsu=2; /* divisor=2 */ 5468 decNumberZero(&numone); *numone.lsu=1; /* constant 1 for increment */ 5469 5470 /* set up the contexts for calculating a, t, and d */ 5471 decContextDefault(&tset, DEC_INIT_DECIMAL64); 5472 dset=tset; 5473 /* accumulator bounds are set above, set precision now */ 5474 aset.digits=p*2; /* double */ 5475 /* term bounds avoid any underflow or overflow */ 5476 tset.digits=p; 5477 tset.emin=DEC_MIN_EMIN; /* [emax is plenty] */ 5478 /* [dset.digits=16, etc., are sufficient] */ 5479 5480 /* finally ready to roll */ 5481 for (;;) { 5482 #if DECCHECK 5483 iterations++; 5484 #endif 5485 /* only the status from the accumulation is interesting */ 5486 /* [but it should remain unchanged after first add] */ 5487 decAddOp(a, a, t, &aset, 0, status); /* a=a+t */ 5488 decMultiplyOp(t, t, x, &tset, &ignore); /* t=t*x */ 5489 decDivideOp(t, t, d, &tset, DIVIDE, &ignore); /* t=t/d */ 5490 /* the iteration ends when the term cannot affect the result, */ 5491 /* if rounded to p digits, which is when its value is smaller */ 5492 /* than the accumulator by p+1 digits. There must also be */ 5493 /* full precision in a. */ 5494 if (((a->digits+a->exponent)>=(t->digits+t->exponent+p+1)) 5495 && (a->digits>=p)) break; 5496 decAddOp(d, d, &numone, &dset, 0, &ignore); /* d=d+1 */ 5497 } /* iterate */ 5498 5499 #if DECCHECK 5500 /* just a sanity check; comment out test to show always */ 5501 if (iterations>p+3) 5502 printf("Exp iterations=%ld, status=%08lx, p=%ld, d=%ld\n", 5503 iterations, *status, p, x->digits); 5504 #endif 5505 } /* h<=8 */ 5506 5507 /* apply postconditioning: a=a**(10**h) -- this is calculated */ 5508 /* at a slightly higher precision than Hull & Abrham suggest */ 5509 if (h>0) { 5510 Int seenbit=0; /* set once a 1-bit is seen */ 5511 Int i; /* counter */ 5512 Int n=powers[h]; /* always positive */ 5513 aset.digits=p+2; /* sufficient precision */ 5514 /* avoid the overhead and many extra digits of decNumberPower */ 5515 /* as all that is needed is the short 'multipliers' loop; here */ 5516 /* accumulate the answer into t */ 5517 decNumberZero(t); *t->lsu=1; /* acc=1 */ 5518 for (i=1;;i++){ /* for each bit [top bit ignored] */ 5519 /* abandon if have had overflow or terminal underflow */ 5520 if (*status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */ 5521 if (*status&DEC_Overflow || ISZERO(t)) break;} 5522 n=n<<1; /* move next bit to testable position */ 5523 if (n<0) { /* top bit is set */ 5524 seenbit=1; /* OK, have a significant bit */ 5525 decMultiplyOp(t, t, a, &aset, status); /* acc=acc*x */ 5526 } 5527 if (i==31) break; /* that was the last bit */ 5528 if (!seenbit) continue; /* no need to square 1 */ 5529 decMultiplyOp(t, t, t, &aset, status); /* acc=acc*acc [square] */ 5530 } /*i*/ /* 32 bits */ 5531 /* decNumberShow(t); */ 5532 a=t; /* and carry on using t instead of a */ 5533 } 5534 5535 /* Copy and round the result to res */ 5536 residue=1; /* indicate dirt to right .. */ 5537 if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */ 5538 aset.digits=set->digits; /* [use default rounding] */ 5539 decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */ 5540 decFinish(res, set, &residue, status); /* cleanup/set flags */ 5541 } while(0); /* end protected */ 5542 5543 if (allocrhs !=NULL) free(allocrhs); /* drop any storage used */ 5544 if (allocbufa!=NULL) free(allocbufa); /* .. */ 5545 if (allocbuft!=NULL) free(allocbuft); /* .. */ 5546 /* [status is handled by caller] */ 5547 return res; 5548 } /* decExpOp */ 5549 5550 /* ------------------------------------------------------------------ */ 5551 /* Initial-estimate natural logarithm table */ 5552 /* */ 5553 /* LNnn -- 90-entry 16-bit table for values from .10 through .99. */ 5554 /* The result is a 4-digit encode of the coefficient (c=the */ 5555 /* top 14 bits encoding 0-9999) and a 2-digit encode of the */ 5556 /* exponent (e=the bottom 2 bits encoding 0-3) */ 5557 /* */ 5558 /* The resulting value is given by: */ 5559 /* */ 5560 /* v = -c * 10**(-e-3) */ 5561 /* */ 5562 /* where e and c are extracted from entry k = LNnn[x-10] */ 5563 /* where x is truncated (NB) into the range 10 through 99, */ 5564 /* and then c = k>>2 and e = k&3. */ 5565 /* ------------------------------------------------------------------ */ 5566 static const uShort LNnn[90] = { 5567 9016, 8652, 8316, 8008, 7724, 7456, 7208, 5568 6972, 6748, 6540, 6340, 6148, 5968, 5792, 5628, 5464, 5312, 5569 5164, 5020, 4884, 4748, 4620, 4496, 4376, 4256, 4144, 4032, 5570 39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629, 5571 29777, 28945, 28129, 27329, 26545, 25777, 25021, 24281, 23553, 22837, 5572 22137, 21445, 20769, 20101, 19445, 18801, 18165, 17541, 16925, 16321, 5573 15721, 15133, 14553, 13985, 13421, 12865, 12317, 11777, 11241, 10717, 5574 10197, 9685, 9177, 8677, 8185, 7697, 7213, 6737, 6269, 5801, 5575 5341, 4889, 4437, 39930, 35534, 31186, 26886, 22630, 18418, 14254, 5576 10130, 6046, 20055}; 5577 5578 /* ------------------------------------------------------------------ */ 5579 /* decLnOp -- effect natural logarithm */ 5580 /* */ 5581 /* This computes C = ln(A) */ 5582 /* */ 5583 /* res is C, the result. C may be A */ 5584 /* rhs is A */ 5585 /* set is the context; note that rounding mode has no effect */ 5586 /* */ 5587 /* C must have space for set->digits digits. */ 5588 /* */ 5589 /* Notable cases: */ 5590 /* A<0 -> Invalid */ 5591 /* A=0 -> -Infinity (Exact) */ 5592 /* A=+Infinity -> +Infinity (Exact) */ 5593 /* A=1 exactly -> 0 (Exact) */ 5594 /* */ 5595 /* Restrictions (as for Exp): */ 5596 /* */ 5597 /* digits, emax, and -emin in the context must be less than */ 5598 /* DEC_MAX_MATH+11 (1000010), and the rhs must be within these */ 5599 /* bounds or a zero. This is an internal routine, so these */ 5600 /* restrictions are contractual and not enforced. */ 5601 /* */ 5602 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */ 5603 /* almost always be correctly rounded, but may be up to 1 ulp in */ 5604 /* error in rare cases. */ 5605 /* ------------------------------------------------------------------ */ 5606 /* The result is calculated using Newton's method, with each */ 5607 /* iteration calculating a' = a + x * exp(-a) - 1. See, for example, */ 5608 /* Epperson 1989. */ 5609 /* */ 5610 /* The iteration ends when the adjustment x*exp(-a)-1 is tiny enough. */ 5611 /* This has to be calculated at the sum of the precision of x and the */ 5612 /* working precision. */ 5613 /* */ 5614 /* Implementation notes: */ 5615 /* */ 5616 /* 1. This is separated out as decLnOp so it can be called from */ 5617 /* other Mathematical functions (e.g., Log 10) with a wider range */ 5618 /* than normal. In particular, it can handle the slightly wider */ 5619 /* (+9+2) range needed by a power function. */ 5620 /* */ 5621 /* 2. The speed of this function is about 10x slower than exp, as */ 5622 /* it typically needs 4-6 iterations for short numbers, and the */ 5623 /* extra precision needed adds a squaring effect, twice. */ 5624 /* */ 5625 /* 3. Fastpaths are included for ln(10) and ln(2), up to length 40, */ 5626 /* as these are common requests. ln(10) is used by log10(x). */ 5627 /* */ 5628 /* 4. An iteration might be saved by widening the LNnn table, and */ 5629 /* would certainly save at least one if it were made ten times */ 5630 /* bigger, too (for truncated fractions 0.100 through 0.999). */ 5631 /* However, for most practical evaluations, at least four or five */ 5632 /* iterations will be neede -- so this would only speed up by */ 5633 /* 20-25% and that probably does not justify increasing the table */ 5634 /* size. */ 5635 /* */ 5636 /* 5. The static buffers are larger than might be expected to allow */ 5637 /* for calls from decNumberPower. */ 5638 /* ------------------------------------------------------------------ */ 5639 static decNumber *decLnOp(decNumber *res, const decNumber *rhs, 5640 decContext *set, uInt *status) { 5641 uInt ignore=0; /* working status accumulator */ 5642 uInt needbytes; /* for space calculations */ 5643 Int residue; /* rounding residue */ 5644 Int r; /* rhs=f*10**r [see below] */ 5645 Int p; /* working precision */ 5646 Int pp; /* precision for iteration */ 5647 Int t; /* work */ 5648 5649 /* buffers for a (accumulator, typically precision+2) and b */ 5650 /* (adjustment calculator, same size) */ 5651 decNumber bufa[D2N(DECBUFFER+12)]; 5652 decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */ 5653 decNumber *a=bufa; /* accumulator/work */ 5654 decNumber bufb[D2N(DECBUFFER*2+2)]; 5655 decNumber *allocbufb=NULL; /* -> allocated bufa, iff allocated */ 5656 decNumber *b=bufb; /* adjustment/work */ 5657 5658 decNumber numone; /* constant 1 */ 5659 decNumber cmp; /* work */ 5660 decContext aset, bset; /* working contexts */ 5661 5662 #if DECCHECK 5663 Int iterations=0; /* for later sanity check */ 5664 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 5665 #endif 5666 5667 do { /* protect allocated storage */ 5668 if (SPECIALARG) { /* handle infinities and NaNs */ 5669 if (decNumberIsInfinite(rhs)) { /* an infinity */ 5670 if (decNumberIsNegative(rhs)) /* -Infinity -> error */ 5671 *status|=DEC_Invalid_operation; 5672 else decNumberCopy(res, rhs); /* +Infinity -> self */ 5673 } 5674 else decNaNs(res, rhs, NULL, set, status); /* a NaN */ 5675 break;} 5676 5677 if (ISZERO(rhs)) { /* +/- zeros -> -Infinity */ 5678 decNumberZero(res); /* make clean */ 5679 res->bits=DECINF|DECNEG; /* set - infinity */ 5680 break;} /* [no status to set] */ 5681 5682 /* Non-zero negatives are bad... */ 5683 if (decNumberIsNegative(rhs)) { /* -x -> error */ 5684 *status|=DEC_Invalid_operation; 5685 break;} 5686 5687 /* Here, rhs is positive, finite, and in range */ 5688 5689 /* lookaside fastpath code for ln(2) and ln(10) at common lengths */ 5690 if (rhs->exponent==0 && set->digits<=40) { 5691 #if DECDPUN==1 5692 if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { /* ln(10) */ 5693 #else 5694 if (rhs->lsu[0]==10 && rhs->digits==2) { /* ln(10) */ 5695 #endif 5696 aset=*set; aset.round=DEC_ROUND_HALF_EVEN; 5697 #define LN10 "2.302585092994045684017991454684364207601" 5698 decNumberFromString(res, LN10, &aset); 5699 *status|=(DEC_Inexact | DEC_Rounded); /* is inexact */ 5700 break;} 5701 if (rhs->lsu[0]==2 && rhs->digits==1) { /* ln(2) */ 5702 aset=*set; aset.round=DEC_ROUND_HALF_EVEN; 5703 #define LN2 "0.6931471805599453094172321214581765680755" 5704 decNumberFromString(res, LN2, &aset); 5705 *status|=(DEC_Inexact | DEC_Rounded); 5706 break;} 5707 } /* integer and short */ 5708 5709 /* Determine the working precision. This is normally the */ 5710 /* requested precision + 2, with a minimum of 9. However, if */ 5711 /* the rhs is 'over-precise' then allow for all its digits to */ 5712 /* potentially participate (consider an rhs where all the excess */ 5713 /* digits are 9s) so in this case use rhs->digits+2. */ 5714 p=MAXI(rhs->digits, MAXI(set->digits, 7))+2; 5715 5716 /* Allocate space for the accumulator and the high-precision */ 5717 /* adjustment calculator, if necessary. The accumulator must */ 5718 /* be able to hold p digits, and the adjustment up to */ 5719 /* rhs->digits+p digits. They are also made big enough for 16 */ 5720 /* digits so that they can be used for calculating the initial */ 5721 /* estimate. */ 5722 needbytes=sizeof(decNumber)+(D2U(MAXI(p,16))-1)*sizeof(Unit); 5723 if (needbytes>sizeof(bufa)) { /* need malloc space */ 5724 allocbufa=(decNumber *)malloc(needbytes); 5725 if (allocbufa==NULL) { /* hopeless -- abandon */ 5726 *status|=DEC_Insufficient_storage; 5727 break;} 5728 a=allocbufa; /* use the allocated space */ 5729 } 5730 pp=p+rhs->digits; 5731 needbytes=sizeof(decNumber)+(D2U(MAXI(pp,16))-1)*sizeof(Unit); 5732 if (needbytes>sizeof(bufb)) { /* need malloc space */ 5733 allocbufb=(decNumber *)malloc(needbytes); 5734 if (allocbufb==NULL) { /* hopeless -- abandon */ 5735 *status|=DEC_Insufficient_storage; 5736 break;} 5737 b=allocbufb; /* use the allocated space */ 5738 } 5739 5740 /* Prepare an initial estimate in acc. Calculate this by */ 5741 /* considering the coefficient of x to be a normalized fraction, */ 5742 /* f, with the decimal point at far left and multiplied by */ 5743 /* 10**r. Then, rhs=f*10**r and 0.1<=f<1, and */ 5744 /* ln(x) = ln(f) + ln(10)*r */ 5745 /* Get the initial estimate for ln(f) from a small lookup */ 5746 /* table (see above) indexed by the first two digits of f, */ 5747 /* truncated. */ 5748 5749 decContextDefault(&aset, DEC_INIT_DECIMAL64); /* 16-digit extended */ 5750 r=rhs->exponent+rhs->digits; /* 'normalised' exponent */ 5751 decNumberFromInt32(a, r); /* a=r */ 5752 decNumberFromInt32(b, 2302585); /* b=ln(10) (2.302585) */ 5753 b->exponent=-6; /* .. */ 5754 decMultiplyOp(a, a, b, &aset, &ignore); /* a=a*b */ 5755 /* now get top two digits of rhs into b by simple truncate and */ 5756 /* force to integer */ 5757 residue=0; /* (no residue) */ 5758 aset.digits=2; aset.round=DEC_ROUND_DOWN; 5759 decCopyFit(b, rhs, &aset, &residue, &ignore); /* copy & shorten */ 5760 b->exponent=0; /* make integer */ 5761 t=decGetInt(b); /* [cannot fail] */ 5762 if (t<10) t=X10(t); /* adjust single-digit b */ 5763 t=LNnn[t-10]; /* look up ln(b) */ 5764 decNumberFromInt32(b, t>>2); /* b=ln(b) coefficient */ 5765 b->exponent=-(t&3)-3; /* set exponent */ 5766 b->bits=DECNEG; /* ln(0.10)->ln(0.99) always -ve */ 5767 aset.digits=16; aset.round=DEC_ROUND_HALF_EVEN; /* restore */ 5768 decAddOp(a, a, b, &aset, 0, &ignore); /* acc=a+b */ 5769 /* the initial estimate is now in a, with up to 4 digits correct. */ 5770 /* When rhs is at or near Nmax the estimate will be low, so we */ 5771 /* will approach it from below, avoiding overflow when calling exp. */ 5772 5773 decNumberZero(&numone); *numone.lsu=1; /* constant 1 for adjustment */ 5774 5775 /* accumulator bounds are as requested (could underflow, but */ 5776 /* cannot overflow) */ 5777 aset.emax=set->emax; 5778 aset.emin=set->emin; 5779 aset.clamp=0; /* no concrete format */ 5780 /* set up a context to be used for the multiply and subtract */ 5781 bset=aset; 5782 bset.emax=DEC_MAX_MATH*2; /* use double bounds for the */ 5783 bset.emin=-DEC_MAX_MATH*2; /* adjustment calculation */ 5784 /* [see decExpOp call below] */ 5785 /* for each iteration double the number of digits to calculate, */ 5786 /* up to a maximum of p */ 5787 pp=9; /* initial precision */ 5788 /* [initially 9 as then the sequence starts 7+2, 16+2, and */ 5789 /* 34+2, which is ideal for standard-sized numbers] */ 5790 aset.digits=pp; /* working context */ 5791 bset.digits=pp+rhs->digits; /* wider context */ 5792 for (;;) { /* iterate */ 5793 #if DECCHECK 5794 iterations++; 5795 if (iterations>24) break; /* consider 9 * 2**24 */ 5796 #endif 5797 /* calculate the adjustment (exp(-a)*x-1) into b. This is a */ 5798 /* catastrophic subtraction but it really is the difference */ 5799 /* from 1 that is of interest. */ 5800 /* Use the internal entry point to Exp as it allows the double */ 5801 /* range for calculating exp(-a) when a is the tiniest subnormal. */ 5802 a->bits^=DECNEG; /* make -a */ 5803 decExpOp(b, a, &bset, &ignore); /* b=exp(-a) */ 5804 a->bits^=DECNEG; /* restore sign of a */ 5805 /* now multiply by rhs and subtract 1, at the wider precision */ 5806 decMultiplyOp(b, b, rhs, &bset, &ignore); /* b=b*rhs */ 5807 decAddOp(b, b, &numone, &bset, DECNEG, &ignore); /* b=b-1 */ 5808 5809 /* the iteration ends when the adjustment cannot affect the */ 5810 /* result by >=0.5 ulp (at the requested digits), which */ 5811 /* is when its value is smaller than the accumulator by */ 5812 /* set->digits+1 digits (or it is zero) -- this is a looser */ 5813 /* requirement than for Exp because all that happens to the */ 5814 /* accumulator after this is the final rounding (but note that */ 5815 /* there must also be full precision in a, or a=0). */ 5816 5817 if (decNumberIsZero(b) || 5818 (a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) { 5819 if (a->digits==p) break; 5820 if (decNumberIsZero(a)) { 5821 decCompareOp(&cmp, rhs, &numone, &aset, COMPARE, &ignore); /* rhs=1 ? */ 5822 if (cmp.lsu[0]==0) a->exponent=0; /* yes, exact 0 */ 5823 else *status|=(DEC_Inexact | DEC_Rounded); /* no, inexact */ 5824 break; 5825 } 5826 /* force padding if adjustment has gone to 0 before full length */ 5827 if (decNumberIsZero(b)) b->exponent=a->exponent-p; 5828 } 5829 5830 /* not done yet ... */ 5831 decAddOp(a, a, b, &aset, 0, &ignore); /* a=a+b for next estimate */ 5832 if (pp==p) continue; /* precision is at maximum */ 5833 /* lengthen the next calculation */ 5834 pp=pp*2; /* double precision */ 5835 if (pp>p) pp=p; /* clamp to maximum */ 5836 aset.digits=pp; /* working context */ 5837 bset.digits=pp+rhs->digits; /* wider context */ 5838 } /* Newton's iteration */ 5839 5840 #if DECCHECK 5841 /* just a sanity check; remove the test to show always */ 5842 if (iterations>24) 5843 printf("Ln iterations=%ld, status=%08lx, p=%ld, d=%ld\n", 5844 iterations, *status, p, rhs->digits); 5845 #endif 5846 5847 /* Copy and round the result to res */ 5848 residue=1; /* indicate dirt to right */ 5849 if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */ 5850 aset.digits=set->digits; /* [use default rounding] */ 5851 decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */ 5852 decFinish(res, set, &residue, status); /* cleanup/set flags */ 5853 } while(0); /* end protected */ 5854 5855 if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */ 5856 if (allocbufb!=NULL) free(allocbufb); /* .. */ 5857 /* [status is handled by caller] */ 5858 return res; 5859 } /* decLnOp */ 5860 5861 /* ------------------------------------------------------------------ */ 5862 /* decQuantizeOp -- force exponent to requested value */ 5863 /* */ 5864 /* This computes C = op(A, B), where op adjusts the coefficient */ 5865 /* of C (by rounding or shifting) such that the exponent (-scale) */ 5866 /* of C has the value B or matches the exponent of B. */ 5867 /* The numerical value of C will equal A, except for the effects of */ 5868 /* any rounding that occurred. */ 5869 /* */ 5870 /* res is C, the result. C may be A or B */ 5871 /* lhs is A, the number to adjust */ 5872 /* rhs is B, the requested exponent */ 5873 /* set is the context */ 5874 /* quant is 1 for quantize or 0 for rescale */ 5875 /* status is the status accumulator (this can be called without */ 5876 /* risk of control loss) */ 5877 /* */ 5878 /* C must have space for set->digits digits. */ 5879 /* */ 5880 /* Unless there is an error or the result is infinite, the exponent */ 5881 /* after the operation is guaranteed to be that requested. */ 5882 /* ------------------------------------------------------------------ */ 5883 static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs, 5884 const decNumber *rhs, decContext *set, 5885 Flag quant, uInt *status) { 5886 #if DECSUBSET 5887 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 5888 decNumber *allocrhs=NULL; /* .., rhs */ 5889 #endif 5890 const decNumber *inrhs=rhs; /* save original rhs */ 5891 Int reqdigits=set->digits; /* requested DIGITS */ 5892 Int reqexp; /* requested exponent [-scale] */ 5893 Int residue=0; /* rounding residue */ 5894 Int etiny=set->emin-(reqdigits-1); 5895 5896 #if DECCHECK 5897 if (decCheckOperands(res, lhs, rhs, set)) return res; 5898 #endif 5899 5900 do { /* protect allocated storage */ 5901 #if DECSUBSET 5902 if (!set->extended) { 5903 /* reduce operands and set lostDigits status, as needed */ 5904 if (lhs->digits>reqdigits) { 5905 alloclhs=decRoundOperand(lhs, set, status); 5906 if (alloclhs==NULL) break; 5907 lhs=alloclhs; 5908 } 5909 if (rhs->digits>reqdigits) { /* [this only checks lostDigits] */ 5910 allocrhs=decRoundOperand(rhs, set, status); 5911 if (allocrhs==NULL) break; 5912 rhs=allocrhs; 5913 } 5914 } 5915 #endif 5916 /* [following code does not require input rounding] */ 5917 5918 /* Handle special values */ 5919 if (SPECIALARGS) { 5920 /* NaNs get usual processing */ 5921 if (SPECIALARGS & (DECSNAN | DECNAN)) 5922 decNaNs(res, lhs, rhs, set, status); 5923 /* one infinity but not both is bad */ 5924 else if ((lhs->bits ^ rhs->bits) & DECINF) 5925 *status|=DEC_Invalid_operation; 5926 /* both infinity: return lhs */ 5927 else decNumberCopy(res, lhs); /* [nop if in place] */ 5928 break; 5929 } 5930 5931 /* set requested exponent */ 5932 if (quant) reqexp=inrhs->exponent; /* quantize -- match exponents */ 5933 else { /* rescale -- use value of rhs */ 5934 /* Original rhs must be an integer that fits and is in range, */ 5935 /* which could be from -1999999997 to +999999999, thanks to */ 5936 /* subnormals */ 5937 reqexp=decGetInt(inrhs); /* [cannot fail] */ 5938 } 5939 5940 #if DECSUBSET 5941 if (!set->extended) etiny=set->emin; /* no subnormals */ 5942 #endif 5943 5944 if (reqexp==BADINT /* bad (rescale only) or .. */ 5945 || reqexp==BIGODD || reqexp==BIGEVEN /* very big (ditto) or .. */ 5946 || (reqexp<etiny) /* < lowest */ 5947 || (reqexp>set->emax)) { /* > emax */ 5948 *status|=DEC_Invalid_operation; 5949 break;} 5950 5951 /* the RHS has been processed, so it can be overwritten now if necessary */ 5952 if (ISZERO(lhs)) { /* zero coefficient unchanged */ 5953 decNumberCopy(res, lhs); /* [nop if in place] */ 5954 res->exponent=reqexp; /* .. just set exponent */ 5955 #if DECSUBSET 5956 if (!set->extended) res->bits=0; /* subset specification; no -0 */ 5957 #endif 5958 } 5959 else { /* non-zero lhs */ 5960 Int adjust=reqexp-lhs->exponent; /* digit adjustment needed */ 5961 /* if adjusted coefficient will definitely not fit, give up now */ 5962 if ((lhs->digits-adjust)>reqdigits) { 5963 *status|=DEC_Invalid_operation; 5964 break; 5965 } 5966 5967 if (adjust>0) { /* increasing exponent */ 5968 /* this will decrease the length of the coefficient by adjust */ 5969 /* digits, and must round as it does so */ 5970 decContext workset; /* work */ 5971 workset=*set; /* clone rounding, etc. */ 5972 workset.digits=lhs->digits-adjust; /* set requested length */ 5973 /* [note that the latter can be <1, here] */ 5974 decCopyFit(res, lhs, &workset, &residue, status); /* fit to result */ 5975 decApplyRound(res, &workset, residue, status); /* .. and round */ 5976 residue=0; /* [used] */ 5977 /* If just rounded a 999s case, exponent will be off by one; */ 5978 /* adjust back (after checking space), if so. */ 5979 if (res->exponent>reqexp) { 5980 /* re-check needed, e.g., for quantize(0.9999, 0.001) under */ 5981 /* set->digits==3 */ 5982 if (res->digits==reqdigits) { /* cannot shift by 1 */ 5983 *status&=~(DEC_Inexact | DEC_Rounded); /* [clean these] */ 5984 *status|=DEC_Invalid_operation; 5985 break; 5986 } 5987 res->digits=decShiftToMost(res->lsu, res->digits, 1); /* shift */ 5988 res->exponent--; /* (re)adjust the exponent. */ 5989 } 5990 #if DECSUBSET 5991 if (ISZERO(res) && !set->extended) res->bits=0; /* subset; no -0 */ 5992 #endif 5993 } /* increase */ 5994 else /* adjust<=0 */ { /* decreasing or = exponent */ 5995 /* this will increase the length of the coefficient by -adjust */ 5996 /* digits, by adding zero or more trailing zeros; this is */ 5997 /* already checked for fit, above */ 5998 decNumberCopy(res, lhs); /* [it will fit] */ 5999 /* if padding needed (adjust<0), add it now... */ 6000 if (adjust<0) { 6001 res->digits=decShiftToMost(res->lsu, res->digits, -adjust); 6002 res->exponent+=adjust; /* adjust the exponent */ 6003 } 6004 } /* decrease */ 6005 } /* non-zero */ 6006 6007 /* Check for overflow [do not use Finalize in this case, as an */ 6008 /* overflow here is a "don't fit" situation] */ 6009 if (res->exponent>set->emax-res->digits+1) { /* too big */ 6010 *status|=DEC_Invalid_operation; 6011 break; 6012 } 6013 else { 6014 decFinalize(res, set, &residue, status); /* set subnormal flags */ 6015 *status&=~DEC_Underflow; /* suppress Underflow [754r] */ 6016 } 6017 } while(0); /* end protected */ 6018 6019 #if DECSUBSET 6020 if (allocrhs!=NULL) free(allocrhs); /* drop any storage used */ 6021 if (alloclhs!=NULL) free(alloclhs); /* .. */ 6022 #endif 6023 return res; 6024 } /* decQuantizeOp */ 6025 6026 /* ------------------------------------------------------------------ */ 6027 /* decCompareOp -- compare, min, or max two Numbers */ 6028 /* */ 6029 /* This computes C = A ? B and carries out one of four operations: */ 6030 /* COMPARE -- returns the signum (as a number) giving the */ 6031 /* result of a comparison unless one or both */ 6032 /* operands is a NaN (in which case a NaN results) */ 6033 /* COMPSIG -- as COMPARE except that a quiet NaN raises */ 6034 /* Invalid operation. */ 6035 /* COMPMAX -- returns the larger of the operands, using the */ 6036 /* 754r maxnum operation */ 6037 /* COMPMAXMAG -- ditto, comparing absolute values */ 6038 /* COMPMIN -- the 754r minnum operation */ 6039 /* COMPMINMAG -- ditto, comparing absolute values */ 6040 /* COMTOTAL -- returns the signum (as a number) giving the */ 6041 /* result of a comparison using 754r total ordering */ 6042 /* */ 6043 /* res is C, the result. C may be A and/or B (e.g., X=X?X) */ 6044 /* lhs is A */ 6045 /* rhs is B */ 6046 /* set is the context */ 6047 /* op is the operation flag */ 6048 /* status is the usual accumulator */ 6049 /* */ 6050 /* C must have space for one digit for COMPARE or set->digits for */ 6051 /* COMPMAX, COMPMIN, COMPMAXMAG, or COMPMINMAG. */ 6052 /* ------------------------------------------------------------------ */ 6053 /* The emphasis here is on speed for common cases, and avoiding */ 6054 /* coefficient comparison if possible. */ 6055 /* ------------------------------------------------------------------ */ 6056 static decNumber *decCompareOp(decNumber *res, const decNumber *lhs, 6057 const decNumber *rhs, decContext *set, 6058 Flag op, uInt *status) { 6059 #if DECSUBSET 6060 decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */ 6061 decNumber *allocrhs=NULL; /* .., rhs */ 6062 #endif 6063 Int result=0; /* default result value */ 6064 uByte merged; /* work */ 6065 6066 #if DECCHECK 6067 if (decCheckOperands(res, lhs, rhs, set)) return res; 6068 #endif 6069 6070 do { /* protect allocated storage */ 6071 #if DECSUBSET 6072 if (!set->extended) { 6073 /* reduce operands and set lostDigits status, as needed */ 6074 if (lhs->digits>set->digits) { 6075 alloclhs=decRoundOperand(lhs, set, status); 6076 if (alloclhs==NULL) {result=BADINT; break;} 6077 lhs=alloclhs; 6078 } 6079 if (rhs->digits>set->digits) { 6080 allocrhs=decRoundOperand(rhs, set, status); 6081 if (allocrhs==NULL) {result=BADINT; break;} 6082 rhs=allocrhs; 6083 } 6084 } 6085 #endif 6086 /* [following code does not require input rounding] */ 6087 6088 /* If total ordering then handle differing signs 'up front' */ 6089 if (op==COMPTOTAL) { /* total ordering */ 6090 if (decNumberIsNegative(lhs) && !decNumberIsNegative(rhs)) { 6091 result=-1; 6092 break; 6093 } 6094 if (!decNumberIsNegative(lhs) && decNumberIsNegative(rhs)) { 6095 result=+1; 6096 break; 6097 } 6098 } 6099 6100 /* handle NaNs specially; let infinities drop through */ 6101 /* This assumes sNaN (even just one) leads to NaN. */ 6102 merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN); 6103 if (merged) { /* a NaN bit set */ 6104 if (op==COMPARE); /* result will be NaN */ 6105 else if (op==COMPSIG) /* treat qNaN as sNaN */ 6106 *status|=DEC_Invalid_operation | DEC_sNaN; 6107 else if (op==COMPTOTAL) { /* total ordering, always finite */ 6108 /* signs are known to be the same; compute the ordering here */ 6109 /* as if the signs are both positive, then invert for negatives */ 6110 if (!decNumberIsNaN(lhs)) result=-1; 6111 else if (!decNumberIsNaN(rhs)) result=+1; 6112 /* here if both NaNs */ 6113 else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1; 6114 else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1; 6115 else { /* both NaN or both sNaN */ 6116 /* now it just depends on the payload */ 6117 result=decUnitCompare(lhs->lsu, D2U(lhs->digits), 6118 rhs->lsu, D2U(rhs->digits), 0); 6119 /* [Error not possible, as these are 'aligned'] */ 6120 } /* both same NaNs */ 6121 if (decNumberIsNegative(lhs)) result=-result; 6122 break; 6123 } /* total order */ 6124 6125 else if (merged & DECSNAN); /* sNaN -> qNaN */ 6126 else { /* here if MIN or MAX and one or two quiet NaNs */ 6127 /* min or max -- 754r rules ignore single NaN */ 6128 if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) { 6129 /* just one NaN; force choice to be the non-NaN operand */ 6130 op=COMPMAX; 6131 if (lhs->bits & DECNAN) result=-1; /* pick rhs */ 6132 else result=+1; /* pick lhs */ 6133 break; 6134 } 6135 } /* max or min */ 6136 op=COMPNAN; /* use special path */ 6137 decNaNs(res, lhs, rhs, set, status); /* propagate NaN */ 6138 break; 6139 } 6140 /* have numbers */ 6141 if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1); 6142 else result=decCompare(lhs, rhs, 0); /* sign matters */ 6143 } while(0); /* end protected */ 6144 6145 if (result==BADINT) *status|=DEC_Insufficient_storage; /* rare */ 6146 else { 6147 if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { /* returning signum */ 6148 if (op==COMPTOTAL && result==0) { 6149 /* operands are numerically equal or same NaN (and same sign, */ 6150 /* tested first); if identical, leave result 0 */ 6151 if (lhs->exponent!=rhs->exponent) { 6152 if (lhs->exponent<rhs->exponent) result=-1; 6153 else result=+1; 6154 if (decNumberIsNegative(lhs)) result=-result; 6155 } /* lexp!=rexp */ 6156 } /* total-order by exponent */ 6157 decNumberZero(res); /* [always a valid result] */ 6158 if (result!=0) { /* must be -1 or +1 */ 6159 *res->lsu=1; 6160 if (result<0) res->bits=DECNEG; 6161 } 6162 } 6163 else if (op==COMPNAN); /* special, drop through */ 6164 else { /* MAX or MIN, non-NaN result */ 6165 Int residue=0; /* rounding accumulator */ 6166 /* choose the operand for the result */ 6167 const decNumber *choice; 6168 if (result==0) { /* operands are numerically equal */ 6169 /* choose according to sign then exponent (see 754r) */ 6170 uByte slhs=(lhs->bits & DECNEG); 6171 uByte srhs=(rhs->bits & DECNEG); 6172 #if DECSUBSET 6173 if (!set->extended) { /* subset: force left-hand */ 6174 op=COMPMAX; 6175 result=+1; 6176 } 6177 else 6178 #endif 6179 if (slhs!=srhs) { /* signs differ */ 6180 if (slhs) result=-1; /* rhs is max */ 6181 else result=+1; /* lhs is max */ 6182 } 6183 else if (slhs && srhs) { /* both negative */ 6184 if (lhs->exponent<rhs->exponent) result=+1; 6185 else result=-1; 6186 /* [if equal, use lhs, technically identical] */ 6187 } 6188 else { /* both positive */ 6189 if (lhs->exponent>rhs->exponent) result=+1; 6190 else result=-1; 6191 /* [ditto] */ 6192 } 6193 } /* numerically equal */ 6194 /* here result will be non-0; reverse if looking for MIN */ 6195 if (op==COMPMIN || op==COMPMINMAG) result=-result; 6196 choice=(result>0 ? lhs : rhs); /* choose */ 6197 /* copy chosen to result, rounding if need be */ 6198 decCopyFit(res, choice, set, &residue, status); 6199 decFinish(res, set, &residue, status); 6200 } 6201 } 6202 #if DECSUBSET 6203 if (allocrhs!=NULL) free(allocrhs); /* free any storage used */ 6204 if (alloclhs!=NULL) free(alloclhs); /* .. */ 6205 #endif 6206 return res; 6207 } /* decCompareOp */ 6208 6209 /* ------------------------------------------------------------------ */ 6210 /* decCompare -- compare two decNumbers by numerical value */ 6211 /* */ 6212 /* This routine compares A ? B without altering them. */ 6213 /* */ 6214 /* Arg1 is A, a decNumber which is not a NaN */ 6215 /* Arg2 is B, a decNumber which is not a NaN */ 6216 /* Arg3 is 1 for a sign-independent compare, 0 otherwise */ 6217 /* */ 6218 /* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */ 6219 /* (the only possible failure is an allocation error) */ 6220 /* ------------------------------------------------------------------ */ 6221 static Int decCompare(const decNumber *lhs, const decNumber *rhs, 6222 Flag abs) { 6223 Int result; /* result value */ 6224 Int sigr; /* rhs signum */ 6225 Int compare; /* work */ 6226 6227 result=1; /* assume signum(lhs) */ 6228 if (ISZERO(lhs)) result=0; 6229 if (abs) { 6230 if (ISZERO(rhs)) return result; /* LHS wins or both 0 */ 6231 /* RHS is non-zero */ 6232 if (result==0) return -1; /* LHS is 0; RHS wins */ 6233 /* [here, both non-zero, result=1] */ 6234 } 6235 else { /* signs matter */ 6236 if (result && decNumberIsNegative(lhs)) result=-1; 6237 sigr=1; /* compute signum(rhs) */ 6238 if (ISZERO(rhs)) sigr=0; 6239 else if (decNumberIsNegative(rhs)) sigr=-1; 6240 if (result > sigr) return +1; /* L > R, return 1 */ 6241 if (result < sigr) return -1; /* L < R, return -1 */ 6242 if (result==0) return 0; /* both 0 */ 6243 } 6244 6245 /* signums are the same; both are non-zero */ 6246 if ((lhs->bits | rhs->bits) & DECINF) { /* one or more infinities */ 6247 if (decNumberIsInfinite(rhs)) { 6248 if (decNumberIsInfinite(lhs)) result=0;/* both infinite */ 6249 else result=-result; /* only rhs infinite */ 6250 } 6251 return result; 6252 } 6253 /* must compare the coefficients, allowing for exponents */ 6254 if (lhs->exponent>rhs->exponent) { /* LHS exponent larger */ 6255 /* swap sides, and sign */ 6256 const decNumber *temp=lhs; 6257 lhs=rhs; 6258 rhs=temp; 6259 result=-result; 6260 } 6261 compare=decUnitCompare(lhs->lsu, D2U(lhs->digits), 6262 rhs->lsu, D2U(rhs->digits), 6263 rhs->exponent-lhs->exponent); 6264 if (compare!=BADINT) compare*=result; /* comparison succeeded */ 6265 return compare; 6266 } /* decCompare */ 6267 6268 /* ------------------------------------------------------------------ */ 6269 /* decUnitCompare -- compare two >=0 integers in Unit arrays */ 6270 /* */ 6271 /* This routine compares A ? B*10**E where A and B are unit arrays */ 6272 /* A is a plain integer */ 6273 /* B has an exponent of E (which must be non-negative) */ 6274 /* */ 6275 /* Arg1 is A first Unit (lsu) */ 6276 /* Arg2 is A length in Units */ 6277 /* Arg3 is B first Unit (lsu) */ 6278 /* Arg4 is B length in Units */ 6279 /* Arg5 is E (0 if the units are aligned) */ 6280 /* */ 6281 /* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */ 6282 /* (the only possible failure is an allocation error, which can */ 6283 /* only occur if E!=0) */ 6284 /* ------------------------------------------------------------------ */ 6285 static Int decUnitCompare(const Unit *a, Int alength, 6286 const Unit *b, Int blength, Int exp) { 6287 Unit *acc; /* accumulator for result */ 6288 Unit accbuff[SD2U(DECBUFFER*2+1)]; /* local buffer */ 6289 Unit *allocacc=NULL; /* -> allocated acc buffer, iff allocated */ 6290 Int accunits, need; /* units in use or needed for acc */ 6291 const Unit *l, *r, *u; /* work */ 6292 Int expunits, exprem, result; /* .. */ 6293 6294 if (exp==0) { /* aligned; fastpath */ 6295 if (alength>blength) return 1; 6296 if (alength<blength) return -1; 6297 /* same number of units in both -- need unit-by-unit compare */ 6298 l=a+alength-1; 6299 r=b+alength-1; 6300 for (;l>=a; l--, r--) { 6301 if (*l>*r) return 1; 6302 if (*l<*r) return -1; 6303 } 6304 return 0; /* all units match */ 6305 } /* aligned */ 6306 6307 /* Unaligned. If one is >1 unit longer than the other, padded */ 6308 /* approximately, then can return easily */ 6309 if (alength>blength+(Int)D2U(exp)) return 1; 6310 if (alength+1<blength+(Int)D2U(exp)) return -1; 6311 6312 /* Need to do a real subtract. For this, a result buffer is needed */ 6313 /* even though only the sign is of interest. Its length needs */ 6314 /* to be the larger of alength and padded blength, +2 */ 6315 need=blength+D2U(exp); /* maximum real length of B */ 6316 if (need<alength) need=alength; 6317 need+=2; 6318 acc=accbuff; /* assume use local buffer */ 6319 if (need*sizeof(Unit)>sizeof(accbuff)) { 6320 allocacc=(Unit *)malloc(need*sizeof(Unit)); 6321 if (allocacc==NULL) return BADINT; /* hopeless -- abandon */ 6322 acc=allocacc; 6323 } 6324 /* Calculate units and remainder from exponent. */ 6325 expunits=exp/DECDPUN; 6326 exprem=exp%DECDPUN; 6327 /* subtract [A+B*(-m)] */ 6328 accunits=decUnitAddSub(a, alength, b, blength, expunits, acc, 6329 -(Int)powers[exprem]); 6330 /* [UnitAddSub result may have leading zeros, even on zero] */ 6331 if (accunits<0) result=-1; /* negative result */ 6332 else { /* non-negative result */ 6333 /* check units of the result before freeing any storage */ 6334 for (u=acc; u<acc+accunits-1 && *u==0;) u++; 6335 result=(*u==0 ? 0 : +1); 6336 } 6337 /* clean up and return the result */ 6338 if (allocacc!=NULL) free(allocacc); /* drop any storage used */ 6339 return result; 6340 } /* decUnitCompare */ 6341 6342 /* ------------------------------------------------------------------ */ 6343 /* decUnitAddSub -- add or subtract two >=0 integers in Unit arrays */ 6344 /* */ 6345 /* This routine performs the calculation: */ 6346 /* */ 6347 /* C=A+(B*M) */ 6348 /* */ 6349 /* Where M is in the range -DECDPUNMAX through +DECDPUNMAX. */ 6350 /* */ 6351 /* A may be shorter or longer than B. */ 6352 /* */ 6353 /* Leading zeros are not removed after a calculation. The result is */ 6354 /* either the same length as the longer of A and B (adding any */ 6355 /* shift), or one Unit longer than that (if a Unit carry occurred). */ 6356 /* */ 6357 /* A and B content are not altered unless C is also A or B. */ 6358 /* C may be the same array as A or B, but only if no zero padding is */ 6359 /* requested (that is, C may be B only if bshift==0). */ 6360 /* C is filled from the lsu; only those units necessary to complete */ 6361 /* the calculation are referenced. */ 6362 /* */ 6363 /* Arg1 is A first Unit (lsu) */ 6364 /* Arg2 is A length in Units */ 6365 /* Arg3 is B first Unit (lsu) */ 6366 /* Arg4 is B length in Units */ 6367 /* Arg5 is B shift in Units (>=0; pads with 0 units if positive) */ 6368 /* Arg6 is C first Unit (lsu) */ 6369 /* Arg7 is M, the multiplier */ 6370 /* */ 6371 /* returns the count of Units written to C, which will be non-zero */ 6372 /* and negated if the result is negative. That is, the sign of the */ 6373 /* returned Int is the sign of the result (positive for zero) and */ 6374 /* the absolute value of the Int is the count of Units. */ 6375 /* */ 6376 /* It is the caller's responsibility to make sure that C size is */ 6377 /* safe, allowing space if necessary for a one-Unit carry. */ 6378 /* */ 6379 /* This routine is severely performance-critical; *any* change here */ 6380 /* must be measured (timed) to assure no performance degradation. */ 6381 /* In particular, trickery here tends to be counter-productive, as */ 6382 /* increased complexity of code hurts register optimizations on */ 6383 /* register-poor architectures. Avoiding divisions is nearly */ 6384 /* always a Good Idea, however. */ 6385 /* */ 6386 /* Special thanks to Rick McGuire (IBM Cambridge, MA) and Dave Clark */ 6387 /* (IBM Warwick, UK) for some of the ideas used in this routine. */ 6388 /* ------------------------------------------------------------------ */ 6389 static Int decUnitAddSub(const Unit *a, Int alength, 6390 const Unit *b, Int blength, Int bshift, 6391 Unit *c, Int m) { 6392 const Unit *alsu=a; /* A lsu [need to remember it] */ 6393 Unit *clsu=c; /* C ditto */ 6394 Unit *minC; /* low water mark for C */ 6395 Unit *maxC; /* high water mark for C */ 6396 eInt carry=0; /* carry integer (could be Long) */ 6397 Int add; /* work */ 6398 #if DECDPUN<=4 /* myriadal, millenary, etc. */ 6399 Int est; /* estimated quotient */ 6400 #endif 6401 6402 #if DECTRACE 6403 if (alength<1 || blength<1) 6404 printf("decUnitAddSub: alen blen m %ld %ld [%ld]\n", alength, blength, m); 6405 #endif 6406 6407 maxC=c+alength; /* A is usually the longer */ 6408 minC=c+blength; /* .. and B the shorter */ 6409 if (bshift!=0) { /* B is shifted; low As copy across */ 6410 minC+=bshift; 6411 /* if in place [common], skip copy unless there's a gap [rare] */ 6412 if (a==c && bshift<=alength) { 6413 c+=bshift; 6414 a+=bshift; 6415 } 6416 else for (; c<clsu+bshift; a++, c++) { /* copy needed */ 6417 if (a<alsu+alength) *c=*a; 6418 else *c=0; 6419 } 6420 } 6421 if (minC>maxC) { /* swap */ 6422 Unit *hold=minC; 6423 minC=maxC; 6424 maxC=hold; 6425 } 6426 6427 /* For speed, do the addition as two loops; the first where both A */ 6428 /* and B contribute, and the second (if necessary) where only one or */ 6429 /* other of the numbers contribute. */ 6430 /* Carry handling is the same (i.e., duplicated) in each case. */ 6431 for (; c<minC; c++) { 6432 carry+=*a; 6433 a++; 6434 carry+=((eInt)*b)*m; /* [special-casing m=1/-1 */ 6435 b++; /* here is not a win] */ 6436 /* here carry is new Unit of digits; it could be +ve or -ve */ 6437 if ((ueInt)carry<=DECDPUNMAX) { /* fastpath 0-DECDPUNMAX */ 6438 *c=(Unit)carry; 6439 carry=0; 6440 continue; 6441 } 6442 #if DECDPUN==4 /* use divide-by-multiply */ 6443 if (carry>=0) { 6444 est=(((ueInt)carry>>11)*53687)>>18; 6445 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6446 carry=est; /* likely quotient [89%] */ 6447 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */ 6448 carry++; 6449 *c-=DECDPUNMAX+1; 6450 continue; 6451 } 6452 /* negative case */ 6453 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6454 est=(((ueInt)carry>>11)*53687)>>18; 6455 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6456 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6457 if (*c<DECDPUNMAX+1) continue; /* was OK */ 6458 carry++; 6459 *c-=DECDPUNMAX+1; 6460 #elif DECDPUN==3 6461 if (carry>=0) { 6462 est=(((ueInt)carry>>3)*16777)>>21; 6463 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6464 carry=est; /* likely quotient [99%] */ 6465 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */ 6466 carry++; 6467 *c-=DECDPUNMAX+1; 6468 continue; 6469 } 6470 /* negative case */ 6471 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6472 est=(((ueInt)carry>>3)*16777)>>21; 6473 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6474 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6475 if (*c<DECDPUNMAX+1) continue; /* was OK */ 6476 carry++; 6477 *c-=DECDPUNMAX+1; 6478 #elif DECDPUN<=2 6479 /* Can use QUOT10 as carry <= 4 digits */ 6480 if (carry>=0) { 6481 est=QUOT10(carry, DECDPUN); 6482 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6483 carry=est; /* quotient */ 6484 continue; 6485 } 6486 /* negative case */ 6487 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6488 est=QUOT10(carry, DECDPUN); 6489 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6490 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6491 #else 6492 /* remainder operator is undefined if negative, so must test */ 6493 if ((ueInt)carry<(DECDPUNMAX+1)*2) { /* fastpath carry +1 */ 6494 *c=(Unit)(carry-(DECDPUNMAX+1)); /* [helps additions] */ 6495 carry=1; 6496 continue; 6497 } 6498 if (carry>=0) { 6499 *c=(Unit)(carry%(DECDPUNMAX+1)); 6500 carry=carry/(DECDPUNMAX+1); 6501 continue; 6502 } 6503 /* negative case */ 6504 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6505 *c=(Unit)(carry%(DECDPUNMAX+1)); 6506 carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1); 6507 #endif 6508 } /* c */ 6509 6510 /* now may have one or other to complete */ 6511 /* [pretest to avoid loop setup/shutdown] */ 6512 if (c<maxC) for (; c<maxC; c++) { 6513 if (a<alsu+alength) { /* still in A */ 6514 carry+=*a; 6515 a++; 6516 } 6517 else { /* inside B */ 6518 carry+=((eInt)*b)*m; 6519 b++; 6520 } 6521 /* here carry is new Unit of digits; it could be +ve or -ve and */ 6522 /* magnitude up to DECDPUNMAX squared */ 6523 if ((ueInt)carry<=DECDPUNMAX) { /* fastpath 0-DECDPUNMAX */ 6524 *c=(Unit)carry; 6525 carry=0; 6526 continue; 6527 } 6528 /* result for this unit is negative or >DECDPUNMAX */ 6529 #if DECDPUN==4 /* use divide-by-multiply */ 6530 if (carry>=0) { 6531 est=(((ueInt)carry>>11)*53687)>>18; 6532 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6533 carry=est; /* likely quotient [79.7%] */ 6534 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */ 6535 carry++; 6536 *c-=DECDPUNMAX+1; 6537 continue; 6538 } 6539 /* negative case */ 6540 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6541 est=(((ueInt)carry>>11)*53687)>>18; 6542 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6543 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6544 if (*c<DECDPUNMAX+1) continue; /* was OK */ 6545 carry++; 6546 *c-=DECDPUNMAX+1; 6547 #elif DECDPUN==3 6548 if (carry>=0) { 6549 est=(((ueInt)carry>>3)*16777)>>21; 6550 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6551 carry=est; /* likely quotient [99%] */ 6552 if (*c<DECDPUNMAX+1) continue; /* estimate was correct */ 6553 carry++; 6554 *c-=DECDPUNMAX+1; 6555 continue; 6556 } 6557 /* negative case */ 6558 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6559 est=(((ueInt)carry>>3)*16777)>>21; 6560 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6561 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6562 if (*c<DECDPUNMAX+1) continue; /* was OK */ 6563 carry++; 6564 *c-=DECDPUNMAX+1; 6565 #elif DECDPUN<=2 6566 if (carry>=0) { 6567 est=QUOT10(carry, DECDPUN); 6568 *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */ 6569 carry=est; /* quotient */ 6570 continue; 6571 } 6572 /* negative case */ 6573 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6574 est=QUOT10(carry, DECDPUN); 6575 *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6576 carry=est-(DECDPUNMAX+1); /* correctly negative */ 6577 #else 6578 if ((ueInt)carry<(DECDPUNMAX+1)*2){ /* fastpath carry 1 */ 6579 *c=(Unit)(carry-(DECDPUNMAX+1)); 6580 carry=1; 6581 continue; 6582 } 6583 /* remainder operator is undefined if negative, so must test */ 6584 if (carry>=0) { 6585 *c=(Unit)(carry%(DECDPUNMAX+1)); 6586 carry=carry/(DECDPUNMAX+1); 6587 continue; 6588 } 6589 /* negative case */ 6590 carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */ 6591 *c=(Unit)(carry%(DECDPUNMAX+1)); 6592 carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1); 6593 #endif 6594 } /* c */ 6595 6596 /* OK, all A and B processed; might still have carry or borrow */ 6597 /* return number of Units in the result, negated if a borrow */ 6598 if (carry==0) return c-clsu; /* no carry, so no more to do */ 6599 if (carry>0) { /* positive carry */ 6600 *c=(Unit)carry; /* place as new unit */ 6601 c++; /* .. */ 6602 return c-clsu; 6603 } 6604 /* -ve carry: it's a borrow; complement needed */ 6605 add=1; /* temporary carry... */ 6606 for (c=clsu; c<maxC; c++) { 6607 add=DECDPUNMAX+add-*c; 6608 if (add<=DECDPUNMAX) { 6609 *c=(Unit)add; 6610 add=0; 6611 } 6612 else { 6613 *c=0; 6614 add=1; 6615 } 6616 } 6617 /* add an extra unit iff it would be non-zero */ 6618 #if DECTRACE 6619 printf("UAS borrow: add %ld, carry %ld\n", add, carry); 6620 #endif 6621 if ((add-carry-1)!=0) { 6622 *c=(Unit)(add-carry-1); 6623 c++; /* interesting, include it */ 6624 } 6625 return clsu-c; /* -ve result indicates borrowed */ 6626 } /* decUnitAddSub */ 6627 6628 /* ------------------------------------------------------------------ */ 6629 /* decTrim -- trim trailing zeros or normalize */ 6630 /* */ 6631 /* dn is the number to trim or normalize */ 6632 /* set is the context to use to check for clamp */ 6633 /* all is 1 to remove all trailing zeros, 0 for just fraction ones */ 6634 /* dropped returns the number of discarded trailing zeros */ 6635 /* returns dn */ 6636 /* */ 6637 /* If clamp is set in the context then the number of zeros trimmed */ 6638 /* may be limited if the exponent is high. */ 6639 /* All fields are updated as required. This is a utility operation, */ 6640 /* so special values are unchanged and no error is possible. */ 6641 /* ------------------------------------------------------------------ */ 6642 static decNumber * decTrim(decNumber *dn, decContext *set, Flag all, 6643 Int *dropped) { 6644 Int d, exp; /* work */ 6645 uInt cut; /* .. */ 6646 Unit *up; /* -> current Unit */ 6647 6648 #if DECCHECK 6649 if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn; 6650 #endif 6651 6652 *dropped=0; /* assume no zeros dropped */ 6653 if ((dn->bits & DECSPECIAL) /* fast exit if special .. */ 6654 || (*dn->lsu & 0x01)) return dn; /* .. or odd */ 6655 if (ISZERO(dn)) { /* .. or 0 */ 6656 dn->exponent=0; /* (sign is preserved) */ 6657 return dn; 6658 } 6659 6660 /* have a finite number which is even */ 6661 exp=dn->exponent; 6662 cut=1; /* digit (1-DECDPUN) in Unit */ 6663 up=dn->lsu; /* -> current Unit */ 6664 for (d=0; d<dn->digits-1; d++) { /* [don't strip the final digit] */ 6665 /* slice by powers */ 6666 #if DECDPUN<=4 6667 uInt quot=QUOT10(*up, cut); 6668 if ((*up-quot*powers[cut])!=0) break; /* found non-0 digit */ 6669 #else 6670 if (*up%powers[cut]!=0) break; /* found non-0 digit */ 6671 #endif 6672 /* have a trailing 0 */ 6673 if (!all) { /* trimming */ 6674 /* [if exp>0 then all trailing 0s are significant for trim] */ 6675 if (exp<=0) { /* if digit might be significant */ 6676 if (exp==0) break; /* then quit */ 6677 exp++; /* next digit might be significant */ 6678 } 6679 } 6680 cut++; /* next power */ 6681 if (cut>DECDPUN) { /* need new Unit */ 6682 up++; 6683 cut=1; 6684 } 6685 } /* d */ 6686 if (d==0) return dn; /* none to drop */ 6687 6688 /* may need to limit drop if clamping */ 6689 if (set->clamp) { 6690 Int maxd=set->emax-set->digits+1-dn->exponent; 6691 if (maxd<=0) return dn; /* nothing possible */ 6692 if (d>maxd) d=maxd; 6693 } 6694 6695 /* effect the drop */ 6696 decShiftToLeast(dn->lsu, D2U(dn->digits), d); 6697 dn->exponent+=d; /* maintain numerical value */ 6698 dn->digits-=d; /* new length */ 6699 *dropped=d; /* report the count */ 6700 return dn; 6701 } /* decTrim */ 6702 6703 /* ------------------------------------------------------------------ */ 6704 /* decReverse -- reverse a Unit array in place */ 6705 /* */ 6706 /* ulo is the start of the array */ 6707 /* uhi is the end of the array (highest Unit to include) */ 6708 /* */ 6709 /* The units ulo through uhi are reversed in place (if the number */ 6710 /* of units is odd, the middle one is untouched). Note that the */ 6711 /* digit(s) in each unit are unaffected. */ 6712 /* ------------------------------------------------------------------ */ 6713 static void decReverse(Unit *ulo, Unit *uhi) { 6714 Unit temp; 6715 for (; ulo<uhi; ulo++, uhi--) { 6716 temp=*ulo; 6717 *ulo=*uhi; 6718 *uhi=temp; 6719 } 6720 return; 6721 } /* decReverse */ 6722 6723 /* ------------------------------------------------------------------ */ 6724 /* decShiftToMost -- shift digits in array towards most significant */ 6725 /* */ 6726 /* uar is the array */ 6727 /* digits is the count of digits in use in the array */ 6728 /* shift is the number of zeros to pad with (least significant); */ 6729 /* it must be zero or positive */ 6730 /* */ 6731 /* returns the new length of the integer in the array, in digits */ 6732 /* */ 6733 /* No overflow is permitted (that is, the uar array must be known to */ 6734 /* be large enough to hold the result, after shifting). */ 6735 /* ------------------------------------------------------------------ */ 6736 static Int decShiftToMost(Unit *uar, Int digits, Int shift) { 6737 Unit *target, *source, *first; /* work */ 6738 Int cut; /* odd 0's to add */ 6739 uInt next; /* work */ 6740 6741 if (shift==0) return digits; /* [fastpath] nothing to do */ 6742 if ((digits+shift)<=DECDPUN) { /* [fastpath] single-unit case */ 6743 *uar=(Unit)(*uar*powers[shift]); 6744 return digits+shift; 6745 } 6746 6747 next=0; /* all paths */ 6748 source=uar+D2U(digits)-1; /* where msu comes from */ 6749 target=source+D2U(shift); /* where upper part of first cut goes */ 6750 cut=DECDPUN-MSUDIGITS(shift); /* where to slice */ 6751 if (cut==0) { /* unit-boundary case */ 6752 for (; source>=uar; source--, target--) *target=*source; 6753 } 6754 else { 6755 first=uar+D2U(digits+shift)-1; /* where msu of source will end up */ 6756 for (; source>=uar; source--, target--) { 6757 /* split the source Unit and accumulate remainder for next */ 6758 #if DECDPUN<=4 6759 uInt quot=QUOT10(*source, cut); 6760 uInt rem=*source-quot*powers[cut]; 6761 next+=quot; 6762 #else 6763 uInt rem=*source%powers[cut]; 6764 next+=*source/powers[cut]; 6765 #endif 6766 if (target<=first) *target=(Unit)next; /* write to target iff valid */ 6767 next=rem*powers[DECDPUN-cut]; /* save remainder for next Unit */ 6768 } 6769 } /* shift-move */ 6770 6771 /* propagate any partial unit to one below and clear the rest */ 6772 for (; target>=uar; target--) { 6773 *target=(Unit)next; 6774 next=0; 6775 } 6776 return digits+shift; 6777 } /* decShiftToMost */ 6778 6779 /* ------------------------------------------------------------------ */ 6780 /* decShiftToLeast -- shift digits in array towards least significant */ 6781 /* */ 6782 /* uar is the array */ 6783 /* units is length of the array, in units */ 6784 /* shift is the number of digits to remove from the lsu end; it */ 6785 /* must be zero or positive and <= than units*DECDPUN. */ 6786 /* */ 6787 /* returns the new length of the integer in the array, in units */ 6788 /* */ 6789 /* Removed digits are discarded (lost). Units not required to hold */ 6790 /* the final result are unchanged. */ 6791 /* ------------------------------------------------------------------ */ 6792 static Int decShiftToLeast(Unit *uar, Int units, Int shift) { 6793 Unit *target, *up; /* work */ 6794 Int cut, count; /* work */ 6795 Int quot, rem; /* for division */ 6796 6797 if (shift==0) return units; /* [fastpath] nothing to do */ 6798 if (shift==units*DECDPUN) { /* [fastpath] little to do */ 6799 *uar=0; /* all digits cleared gives zero */ 6800 return 1; /* leaves just the one */ 6801 } 6802 6803 target=uar; /* both paths */ 6804 cut=MSUDIGITS(shift); 6805 if (cut==DECDPUN) { /* unit-boundary case; easy */ 6806 up=uar+D2U(shift); 6807 for (; up<uar+units; target++, up++) *target=*up; 6808 return target-uar; 6809 } 6810 6811 /* messier */ 6812 up=uar+D2U(shift-cut); /* source; correct to whole Units */ 6813 count=units*DECDPUN-shift; /* the maximum new length */ 6814 #if DECDPUN<=4 6815 quot=QUOT10(*up, cut); 6816 #else 6817 quot=*up/powers[cut]; 6818 #endif 6819 for (; ; target++) { 6820 *target=(Unit)quot; 6821 count-=(DECDPUN-cut); 6822 if (count<=0) break; 6823 up++; 6824 quot=*up; 6825 #if DECDPUN<=4 6826 quot=QUOT10(quot, cut); 6827 rem=*up-quot*powers[cut]; 6828 #else 6829 rem=quot%powers[cut]; 6830 quot=quot/powers[cut]; 6831 #endif 6832 *target=(Unit)(*target+rem*powers[DECDPUN-cut]); 6833 count-=cut; 6834 if (count<=0) break; 6835 } 6836 return target-uar+1; 6837 } /* decShiftToLeast */ 6838 6839 #if DECSUBSET 6840 /* ------------------------------------------------------------------ */ 6841 /* decRoundOperand -- round an operand [used for subset only] */ 6842 /* */ 6843 /* dn is the number to round (dn->digits is > set->digits) */ 6844 /* set is the relevant context */ 6845 /* status is the status accumulator */ 6846 /* */ 6847 /* returns an allocated decNumber with the rounded result. */ 6848 /* */ 6849 /* lostDigits and other status may be set by this. */ 6850 /* */ 6851 /* Since the input is an operand, it must not be modified. */ 6852 /* Instead, return an allocated decNumber, rounded as required. */ 6853 /* It is the caller's responsibility to free the allocated storage. */ 6854 /* */ 6855 /* If no storage is available then the result cannot be used, so NULL */ 6856 /* is returned. */ 6857 /* ------------------------------------------------------------------ */ 6858 static decNumber *decRoundOperand(const decNumber *dn, decContext *set, 6859 uInt *status) { 6860 decNumber *res; /* result structure */ 6861 uInt newstatus=0; /* status from round */ 6862 Int residue=0; /* rounding accumulator */ 6863 6864 /* Allocate storage for the returned decNumber, big enough for the */ 6865 /* length specified by the context */ 6866 res=(decNumber *)malloc(sizeof(decNumber) 6867 +(D2U(set->digits)-1)*sizeof(Unit)); 6868 if (res==NULL) { 6869 *status|=DEC_Insufficient_storage; 6870 return NULL; 6871 } 6872 decCopyFit(res, dn, set, &residue, &newstatus); 6873 decApplyRound(res, set, residue, &newstatus); 6874 6875 /* If that set Inexact then "lost digits" is raised... */ 6876 if (newstatus & DEC_Inexact) newstatus|=DEC_Lost_digits; 6877 *status|=newstatus; 6878 return res; 6879 } /* decRoundOperand */ 6880 #endif 6881 6882 /* ------------------------------------------------------------------ */ 6883 /* decCopyFit -- copy a number, truncating the coefficient if needed */ 6884 /* */ 6885 /* dest is the target decNumber */ 6886 /* src is the source decNumber */ 6887 /* set is the context [used for length (digits) and rounding mode] */ 6888 /* residue is the residue accumulator */ 6889 /* status contains the current status to be updated */ 6890 /* */ 6891 /* (dest==src is allowed and will be a no-op if fits) */ 6892 /* All fields are updated as required. */ 6893 /* ------------------------------------------------------------------ */ 6894 static void decCopyFit(decNumber *dest, const decNumber *src, 6895 decContext *set, Int *residue, uInt *status) { 6896 dest->bits=src->bits; 6897 dest->exponent=src->exponent; 6898 decSetCoeff(dest, set, src->lsu, src->digits, residue, status); 6899 } /* decCopyFit */ 6900 6901 /* ------------------------------------------------------------------ */ 6902 /* decSetCoeff -- set the coefficient of a number */ 6903 /* */ 6904 /* dn is the number whose coefficient array is to be set. */ 6905 /* It must have space for set->digits digits */ 6906 /* set is the context [for size] */ 6907 /* lsu -> lsu of the source coefficient [may be dn->lsu] */ 6908 /* len is digits in the source coefficient [may be dn->digits] */ 6909 /* residue is the residue accumulator. This has values as in */ 6910 /* decApplyRound, and will be unchanged unless the */ 6911 /* target size is less than len. In this case, the */ 6912 /* coefficient is truncated and the residue is updated to */ 6913 /* reflect the previous residue and the dropped digits. */ 6914 /* status is the status accumulator, as usual */ 6915 /* */ 6916 /* The coefficient may already be in the number, or it can be an */ 6917 /* external intermediate array. If it is in the number, lsu must == */ 6918 /* dn->lsu and len must == dn->digits. */ 6919 /* */ 6920 /* Note that the coefficient length (len) may be < set->digits, and */ 6921 /* in this case this merely copies the coefficient (or is a no-op */ 6922 /* if dn->lsu==lsu). */ 6923 /* */ 6924 /* Note also that (only internally, from decQuantizeOp and */ 6925 /* decSetSubnormal) the value of set->digits may be less than one, */ 6926 /* indicating a round to left. This routine handles that case */ 6927 /* correctly; caller ensures space. */ 6928 /* */ 6929 /* dn->digits, dn->lsu (and as required), and dn->exponent are */ 6930 /* updated as necessary. dn->bits (sign) is unchanged. */ 6931 /* */ 6932 /* DEC_Rounded status is set if any digits are discarded. */ 6933 /* DEC_Inexact status is set if any non-zero digits are discarded, or */ 6934 /* incoming residue was non-0 (implies rounded) */ 6935 /* ------------------------------------------------------------------ */ 6936 /* mapping array: maps 0-9 to canonical residues, so that a residue */ 6937 /* can be adjusted in the range [-1, +1] and achieve correct rounding */ 6938 /* 0 1 2 3 4 5 6 7 8 9 */ 6939 static const uByte resmap[10]={0, 3, 3, 3, 3, 5, 7, 7, 7, 7}; 6940 static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu, 6941 Int len, Int *residue, uInt *status) { 6942 Int discard; /* number of digits to discard */ 6943 uInt cut; /* cut point in Unit */ 6944 const Unit *up; /* work */ 6945 Unit *target; /* .. */ 6946 Int count; /* .. */ 6947 #if DECDPUN<=4 6948 uInt temp; /* .. */ 6949 #endif 6950 6951 discard=len-set->digits; /* digits to discard */ 6952 if (discard<=0) { /* no digits are being discarded */ 6953 if (dn->lsu!=lsu) { /* copy needed */ 6954 /* copy the coefficient array to the result number; no shift needed */ 6955 count=len; /* avoids D2U */ 6956 up=lsu; 6957 for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN) 6958 *target=*up; 6959 dn->digits=len; /* set the new length */ 6960 } 6961 /* dn->exponent and residue are unchanged, record any inexactitude */ 6962 if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded); 6963 return; 6964 } 6965 6966 /* some digits must be discarded ... */ 6967 dn->exponent+=discard; /* maintain numerical value */ 6968 *status|=DEC_Rounded; /* accumulate Rounded status */ 6969 if (*residue>1) *residue=1; /* previous residue now to right, so reduce */ 6970 6971 if (discard>len) { /* everything, +1, is being discarded */ 6972 /* guard digit is 0 */ 6973 /* residue is all the number [NB could be all 0s] */ 6974 if (*residue<=0) { /* not already positive */ 6975 count=len; /* avoids D2U */ 6976 for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { /* found non-0 */ 6977 *residue=1; 6978 break; /* no need to check any others */ 6979 } 6980 } 6981 if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */ 6982 *dn->lsu=0; /* coefficient will now be 0 */ 6983 dn->digits=1; /* .. */ 6984 return; 6985 } /* total discard */ 6986 6987 /* partial discard [most common case] */ 6988 /* here, at least the first (most significant) discarded digit exists */ 6989 6990 /* spin up the number, noting residue during the spin, until get to */ 6991 /* the Unit with the first discarded digit. When reach it, extract */ 6992 /* it and remember its position */ 6993 count=0; 6994 for (up=lsu;; up++) { 6995 count+=DECDPUN; 6996 if (count>=discard) break; /* full ones all checked */ 6997 if (*up!=0) *residue=1; 6998 } /* up */ 6999 7000 /* here up -> Unit with first discarded digit */ 7001 cut=discard-(count-DECDPUN)-1; 7002 if (cut==DECDPUN-1) { /* unit-boundary case (fast) */ 7003 Unit half=(Unit)powers[DECDPUN]>>1; 7004 /* set residue directly */ 7005 if (*up>=half) { 7006 if (*up>half) *residue=7; 7007 else *residue+=5; /* add sticky bit */ 7008 } 7009 else { /* <half */ 7010 if (*up!=0) *residue=3; /* [else is 0, leave as sticky bit] */ 7011 } 7012 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */ 7013 *dn->lsu=0; /* .. result is 0 */ 7014 dn->digits=1; /* .. */ 7015 } 7016 else { /* shift to least */ 7017 count=set->digits; /* now digits to end up with */ 7018 dn->digits=count; /* set the new length */ 7019 up++; /* move to next */ 7020 /* on unit boundary, so shift-down copy loop is simple */ 7021 for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN) 7022 *target=*up; 7023 } 7024 } /* unit-boundary case */ 7025 7026 else { /* discard digit is in low digit(s), and not top digit */ 7027 uInt discard1; /* first discarded digit */ 7028 uInt quot, rem; /* for divisions */ 7029 if (cut==0) quot=*up; /* is at bottom of unit */ 7030 else /* cut>0 */ { /* it's not at bottom of unit */ 7031 #if DECDPUN<=4 7032 quot=QUOT10(*up, cut); 7033 rem=*up-quot*powers[cut]; 7034 #else 7035 rem=*up%powers[cut]; 7036 quot=*up/powers[cut]; 7037 #endif 7038 if (rem!=0) *residue=1; 7039 } 7040 /* discard digit is now at bottom of quot */ 7041 #if DECDPUN<=4 7042 temp=(quot*6554)>>16; /* fast /10 */ 7043 /* Vowels algorithm here not a win (9 instructions) */ 7044 discard1=quot-X10(temp); 7045 quot=temp; 7046 #else 7047 discard1=quot%10; 7048 quot=quot/10; 7049 #endif 7050 /* here, discard1 is the guard digit, and residue is everything */ 7051 /* else [use mapping array to accumulate residue safely] */ 7052 *residue+=resmap[discard1]; 7053 cut++; /* update cut */ 7054 /* here: up -> Unit of the array with bottom digit */ 7055 /* cut is the division point for each Unit */ 7056 /* quot holds the uncut high-order digits for the current unit */ 7057 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */ 7058 *dn->lsu=0; /* .. result is 0 */ 7059 dn->digits=1; /* .. */ 7060 } 7061 else { /* shift to least needed */ 7062 count=set->digits; /* now digits to end up with */ 7063 dn->digits=count; /* set the new length */ 7064 /* shift-copy the coefficient array to the result number */ 7065 for (target=dn->lsu; ; target++) { 7066 *target=(Unit)quot; 7067 count-=(DECDPUN-cut); 7068 if (count<=0) break; 7069 up++; 7070 quot=*up; 7071 #if DECDPUN<=4 7072 quot=QUOT10(quot, cut); 7073 rem=*up-quot*powers[cut]; 7074 #else 7075 rem=quot%powers[cut]; 7076 quot=quot/powers[cut]; 7077 #endif 7078 *target=(Unit)(*target+rem*powers[DECDPUN-cut]); 7079 count-=cut; 7080 if (count<=0) break; 7081 } /* shift-copy loop */ 7082 } /* shift to least */ 7083 } /* not unit boundary */ 7084 7085 if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */ 7086 return; 7087 } /* decSetCoeff */ 7088 7089 /* ------------------------------------------------------------------ */ 7090 /* decApplyRound -- apply pending rounding to a number */ 7091 /* */ 7092 /* dn is the number, with space for set->digits digits */ 7093 /* set is the context [for size and rounding mode] */ 7094 /* residue indicates pending rounding, being any accumulated */ 7095 /* guard and sticky information. It may be: */ 7096 /* 6-9: rounding digit is >5 */ 7097 /* 5: rounding digit is exactly half-way */ 7098 /* 1-4: rounding digit is <5 and >0 */ 7099 /* 0: the coefficient is exact */ 7100 /* -1: as 1, but the hidden digits are subtractive, that */ 7101 /* is, of the opposite sign to dn. In this case the */ 7102 /* coefficient must be non-0. This case occurs when */ 7103 /* subtracting a small number (which can be reduced to */ 7104 /* a sticky bit); see decAddOp. */ 7105 /* status is the status accumulator, as usual */ 7106 /* */ 7107 /* This routine applies rounding while keeping the length of the */ 7108 /* coefficient constant. The exponent and status are unchanged */ 7109 /* except if: */ 7110 /* */ 7111 /* -- the coefficient was increased and is all nines (in which */ 7112 /* case Overflow could occur, and is handled directly here so */ 7113 /* the caller does not need to re-test for overflow) */ 7114 /* */ 7115 /* -- the coefficient was decreased and becomes all nines (in which */ 7116 /* case Underflow could occur, and is also handled directly). */ 7117 /* */ 7118 /* All fields in dn are updated as required. */ 7119 /* */ 7120 /* ------------------------------------------------------------------ */ 7121 static void decApplyRound(decNumber *dn, decContext *set, Int residue, 7122 uInt *status) { 7123 Int bump; /* 1 if coefficient needs to be incremented */ 7124 /* -1 if coefficient needs to be decremented */ 7125 7126 if (residue==0) return; /* nothing to apply */ 7127 7128 bump=0; /* assume a smooth ride */ 7129 7130 /* now decide whether, and how, to round, depending on mode */ 7131 switch (set->round) { 7132 case DEC_ROUND_05UP: { /* round zero or five up (for reround) */ 7133 /* This is the same as DEC_ROUND_DOWN unless there is a */ 7134 /* positive residue and the lsd of dn is 0 or 5, in which case */ 7135 /* it is bumped; when residue is <0, the number is therefore */ 7136 /* bumped down unless the final digit was 1 or 6 (in which */ 7137 /* case it is bumped down and then up -- a no-op) */ 7138 Int lsd5=*dn->lsu%5; /* get lsd and quintate */ 7139 if (residue<0 && lsd5!=1) bump=-1; 7140 else if (residue>0 && lsd5==0) bump=1; 7141 /* [bump==1 could be applied directly; use common path for clarity] */ 7142 break;} /* r-05 */ 7143 7144 case DEC_ROUND_DOWN: { 7145 /* no change, except if negative residue */ 7146 if (residue<0) bump=-1; 7147 break;} /* r-d */ 7148 7149 case DEC_ROUND_HALF_DOWN: { 7150 if (residue>5) bump=1; 7151 break;} /* r-h-d */ 7152 7153 case DEC_ROUND_HALF_EVEN: { 7154 if (residue>5) bump=1; /* >0.5 goes up */ 7155 else if (residue==5) { /* exactly 0.5000... */ 7156 /* 0.5 goes up iff [new] lsd is odd */ 7157 if (*dn->lsu & 0x01) bump=1; 7158 } 7159 break;} /* r-h-e */ 7160 7161 case DEC_ROUND_HALF_UP: { 7162 if (residue>=5) bump=1; 7163 break;} /* r-h-u */ 7164 7165 case DEC_ROUND_UP: { 7166 if (residue>0) bump=1; 7167 break;} /* r-u */ 7168 7169 case DEC_ROUND_CEILING: { 7170 /* same as _UP for positive numbers, and as _DOWN for negatives */ 7171 /* [negative residue cannot occur on 0] */ 7172 if (decNumberIsNegative(dn)) { 7173 if (residue<0) bump=-1; 7174 } 7175 else { 7176 if (residue>0) bump=1; 7177 } 7178 break;} /* r-c */ 7179 7180 case DEC_ROUND_FLOOR: { 7181 /* same as _UP for negative numbers, and as _DOWN for positive */ 7182 /* [negative residue cannot occur on 0] */ 7183 if (!decNumberIsNegative(dn)) { 7184 if (residue<0) bump=-1; 7185 } 7186 else { 7187 if (residue>0) bump=1; 7188 } 7189 break;} /* r-f */ 7190 7191 default: { /* e.g., DEC_ROUND_MAX */ 7192 *status|=DEC_Invalid_context; 7193 #if DECTRACE || (DECCHECK && DECVERB) 7194 printf("Unknown rounding mode: %d\n", set->round); 7195 #endif 7196 break;} 7197 } /* switch */ 7198 7199 /* now bump the number, up or down, if need be */ 7200 if (bump==0) return; /* no action required */ 7201 7202 /* Simply use decUnitAddSub unless bumping up and the number is */ 7203 /* all nines. In this special case set to 100... explicitly */ 7204 /* and adjust the exponent by one (as otherwise could overflow */ 7205 /* the array) */ 7206 /* Similarly handle all-nines result if bumping down. */ 7207 if (bump>0) { 7208 Unit *up; /* work */ 7209 uInt count=dn->digits; /* digits to be checked */ 7210 for (up=dn->lsu; ; up++) { 7211 if (count<=DECDPUN) { 7212 /* this is the last Unit (the msu) */ 7213 if (*up!=powers[count]-1) break; /* not still 9s */ 7214 /* here if it, too, is all nines */ 7215 *up=(Unit)powers[count-1]; /* here 999 -> 100 etc. */ 7216 for (up=up-1; up>=dn->lsu; up--) *up=0; /* others all to 0 */ 7217 dn->exponent++; /* and bump exponent */ 7218 /* [which, very rarely, could cause Overflow...] */ 7219 if ((dn->exponent+dn->digits)>set->emax+1) { 7220 decSetOverflow(dn, set, status); 7221 } 7222 return; /* done */ 7223 } 7224 /* a full unit to check, with more to come */ 7225 if (*up!=DECDPUNMAX) break; /* not still 9s */ 7226 count-=DECDPUN; 7227 } /* up */ 7228 } /* bump>0 */ 7229 else { /* -1 */ 7230 /* here checking for a pre-bump of 1000... (leading 1, all */ 7231 /* other digits zero) */ 7232 Unit *up, *sup; /* work */ 7233 uInt count=dn->digits; /* digits to be checked */ 7234 for (up=dn->lsu; ; up++) { 7235 if (count<=DECDPUN) { 7236 /* this is the last Unit (the msu) */ 7237 if (*up!=powers[count-1]) break; /* not 100.. */ 7238 /* here if have the 1000... case */ 7239 sup=up; /* save msu pointer */ 7240 *up=(Unit)powers[count]-1; /* here 100 in msu -> 999 */ 7241 /* others all to all-nines, too */ 7242 for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1; 7243 dn->exponent--; /* and bump exponent */ 7244 7245 /* iff the number was at the subnormal boundary (exponent=etiny) */ 7246 /* then the exponent is now out of range, so it will in fact get */ 7247 /* clamped to etiny and the final 9 dropped. */ 7248 /* printf(">> emin=%d exp=%d sdig=%d\n", set->emin, */ 7249 /* dn->exponent, set->digits); */ 7250 if (dn->exponent+1==set->emin-set->digits+1) { 7251 if (count==1 && dn->digits==1) *sup=0; /* here 9 -> 0[.9] */ 7252 else { 7253 *sup=(Unit)powers[count-1]-1; /* here 999.. in msu -> 99.. */ 7254 dn->digits--; 7255 } 7256 dn->exponent++; 7257 *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded; 7258 } 7259 return; /* done */ 7260 } 7261 7262 /* a full unit to check, with more to come */ 7263 if (*up!=0) break; /* not still 0s */ 7264 count-=DECDPUN; 7265 } /* up */ 7266 7267 } /* bump<0 */ 7268 7269 /* Actual bump needed. Do it. */ 7270 decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump); 7271 } /* decApplyRound */ 7272 7273 #if DECSUBSET 7274 /* ------------------------------------------------------------------ */ 7275 /* decFinish -- finish processing a number */ 7276 /* */ 7277 /* dn is the number */ 7278 /* set is the context */ 7279 /* residue is the rounding accumulator (as in decApplyRound) */ 7280 /* status is the accumulator */ 7281 /* */ 7282 /* This finishes off the current number by: */ 7283 /* 1. If not extended: */ 7284 /* a. Converting a zero result to clean '0' */ 7285 /* b. Reducing positive exponents to 0, if would fit in digits */ 7286 /* 2. Checking for overflow and subnormals (always) */ 7287 /* Note this is just Finalize when no subset arithmetic. */ 7288 /* All fields are updated as required. */ 7289 /* ------------------------------------------------------------------ */ 7290 static void decFinish(decNumber *dn, decContext *set, Int *residue, 7291 uInt *status) { 7292 if (!set->extended) { 7293 if ISZERO(dn) { /* value is zero */ 7294 dn->exponent=0; /* clean exponent .. */ 7295 dn->bits=0; /* .. and sign */ 7296 return; /* no error possible */ 7297 } 7298 if (dn->exponent>=0) { /* non-negative exponent */ 7299 /* >0; reduce to integer if possible */ 7300 if (set->digits >= (dn->exponent+dn->digits)) { 7301 dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent); 7302 dn->exponent=0; 7303 } 7304 } 7305 } /* !extended */ 7306 7307 decFinalize(dn, set, residue, status); 7308 } /* decFinish */ 7309 #endif 7310 7311 /* ------------------------------------------------------------------ */ 7312 /* decFinalize -- final check, clamp, and round of a number */ 7313 /* */ 7314 /* dn is the number */ 7315 /* set is the context */ 7316 /* residue is the rounding accumulator (as in decApplyRound) */ 7317 /* status is the status accumulator */ 7318 /* */ 7319 /* This finishes off the current number by checking for subnormal */ 7320 /* results, applying any pending rounding, checking for overflow, */ 7321 /* and applying any clamping. */ 7322 /* Underflow and overflow conditions are raised as appropriate. */ 7323 /* All fields are updated as required. */ 7324 /* ------------------------------------------------------------------ */ 7325 static void decFinalize(decNumber *dn, decContext *set, Int *residue, 7326 uInt *status) { 7327 Int shift; /* shift needed if clamping */ 7328 Int tinyexp=set->emin-dn->digits+1; /* precalculate subnormal boundary */ 7329 7330 /* Must be careful, here, when checking the exponent as the */ 7331 /* adjusted exponent could overflow 31 bits [because it may already */ 7332 /* be up to twice the expected]. */ 7333 7334 /* First test for subnormal. This must be done before any final */ 7335 /* round as the result could be rounded to Nmin or 0. */ 7336 if (dn->exponent<=tinyexp) { /* prefilter */ 7337 Int comp; 7338 decNumber nmin; 7339 /* A very nasty case here is dn == Nmin and residue<0 */ 7340 if (dn->exponent<tinyexp) { 7341 /* Go handle subnormals; this will apply round if needed. */ 7342 decSetSubnormal(dn, set, residue, status); 7343 return; 7344 } 7345 /* Equals case: only subnormal if dn=Nmin and negative residue */ 7346 decNumberZero(&nmin); 7347 nmin.lsu[0]=1; 7348 nmin.exponent=set->emin; 7349 comp=decCompare(dn, &nmin, 1); /* (signless compare) */ 7350 if (comp==BADINT) { /* oops */ 7351 *status|=DEC_Insufficient_storage; /* abandon... */ 7352 return; 7353 } 7354 if (*residue<0 && comp==0) { /* neg residue and dn==Nmin */ 7355 decApplyRound(dn, set, *residue, status); /* might force down */ 7356 decSetSubnormal(dn, set, residue, status); 7357 return; 7358 } 7359 } 7360 7361 /* now apply any pending round (this could raise overflow). */ 7362 if (*residue!=0) decApplyRound(dn, set, *residue, status); 7363 7364 /* Check for overflow [redundant in the 'rare' case] or clamp */ 7365 if (dn->exponent<=set->emax-set->digits+1) return; /* neither needed */ 7366 7367 7368 /* here when might have an overflow or clamp to do */ 7369 if (dn->exponent>set->emax-dn->digits+1) { /* too big */ 7370 decSetOverflow(dn, set, status); 7371 return; 7372 } 7373 /* here when the result is normal but in clamp range */ 7374 if (!set->clamp) return; 7375 7376 /* here when need to apply the IEEE exponent clamp (fold-down) */ 7377 shift=dn->exponent-(set->emax-set->digits+1); 7378 7379 /* shift coefficient (if non-zero) */ 7380 if (!ISZERO(dn)) { 7381 dn->digits=decShiftToMost(dn->lsu, dn->digits, shift); 7382 } 7383 dn->exponent-=shift; /* adjust the exponent to match */ 7384 *status|=DEC_Clamped; /* and record the dirty deed */ 7385 return; 7386 } /* decFinalize */ 7387 7388 /* ------------------------------------------------------------------ */ 7389 /* decSetOverflow -- set number to proper overflow value */ 7390 /* */ 7391 /* dn is the number (used for sign [only] and result) */ 7392 /* set is the context [used for the rounding mode, etc.] */ 7393 /* status contains the current status to be updated */ 7394 /* */ 7395 /* This sets the sign of a number and sets its value to either */ 7396 /* Infinity or the maximum finite value, depending on the sign of */ 7397 /* dn and the rounding mode, following IEEE 854 rules. */ 7398 /* ------------------------------------------------------------------ */ 7399 static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) { 7400 Flag needmax=0; /* result is maximum finite value */ 7401 uByte sign=dn->bits&DECNEG; /* clean and save sign bit */ 7402 7403 if (ISZERO(dn)) { /* zero does not overflow magnitude */ 7404 Int emax=set->emax; /* limit value */ 7405 if (set->clamp) emax-=set->digits-1; /* lower if clamping */ 7406 if (dn->exponent>emax) { /* clamp required */ 7407 dn->exponent=emax; 7408 *status|=DEC_Clamped; 7409 } 7410 return; 7411 } 7412 7413 decNumberZero(dn); 7414 switch (set->round) { 7415 case DEC_ROUND_DOWN: { 7416 needmax=1; /* never Infinity */ 7417 break;} /* r-d */ 7418 case DEC_ROUND_05UP: { 7419 needmax=1; /* never Infinity */ 7420 break;} /* r-05 */ 7421 case DEC_ROUND_CEILING: { 7422 if (sign) needmax=1; /* Infinity if non-negative */ 7423 break;} /* r-c */ 7424 case DEC_ROUND_FLOOR: { 7425 if (!sign) needmax=1; /* Infinity if negative */ 7426 break;} /* r-f */ 7427 default: break; /* Infinity in all other cases */ 7428 } 7429 if (needmax) { 7430 decSetMaxValue(dn, set); 7431 dn->bits=sign; /* set sign */ 7432 } 7433 else dn->bits=sign|DECINF; /* Value is +/-Infinity */ 7434 *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded; 7435 } /* decSetOverflow */ 7436 7437 /* ------------------------------------------------------------------ */ 7438 /* decSetMaxValue -- set number to +Nmax (maximum normal value) */ 7439 /* */ 7440 /* dn is the number to set */ 7441 /* set is the context [used for digits and emax] */ 7442 /* */ 7443 /* This sets the number to the maximum positive value. */ 7444 /* ------------------------------------------------------------------ */ 7445 static void decSetMaxValue(decNumber *dn, decContext *set) { 7446 Unit *up; /* work */ 7447 Int count=set->digits; /* nines to add */ 7448 dn->digits=count; 7449 /* fill in all nines to set maximum value */ 7450 for (up=dn->lsu; ; up++) { 7451 if (count>DECDPUN) *up=DECDPUNMAX; /* unit full o'nines */ 7452 else { /* this is the msu */ 7453 *up=(Unit)(powers[count]-1); 7454 break; 7455 } 7456 count-=DECDPUN; /* filled those digits */ 7457 } /* up */ 7458 dn->bits=0; /* + sign */ 7459 dn->exponent=set->emax-set->digits+1; 7460 } /* decSetMaxValue */ 7461 7462 /* ------------------------------------------------------------------ */ 7463 /* decSetSubnormal -- process value whose exponent is <Emin */ 7464 /* */ 7465 /* dn is the number (used as input as well as output; it may have */ 7466 /* an allowed subnormal value, which may need to be rounded) */ 7467 /* set is the context [used for the rounding mode] */ 7468 /* residue is any pending residue */ 7469 /* status contains the current status to be updated */ 7470 /* */ 7471 /* If subset mode, set result to zero and set Underflow flags. */ 7472 /* */ 7473 /* Value may be zero with a low exponent; this does not set Subnormal */ 7474 /* but the exponent will be clamped to Etiny. */ 7475 /* */ 7476 /* Otherwise ensure exponent is not out of range, and round as */ 7477 /* necessary. Underflow is set if the result is Inexact. */ 7478 /* ------------------------------------------------------------------ */ 7479 static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue, 7480 uInt *status) { 7481 decContext workset; /* work */ 7482 Int etiny, adjust; /* .. */ 7483 7484 #if DECSUBSET 7485 /* simple set to zero and 'hard underflow' for subset */ 7486 if (!set->extended) { 7487 decNumberZero(dn); 7488 /* always full overflow */ 7489 *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded; 7490 return; 7491 } 7492 #endif 7493 7494 /* Full arithmetic -- allow subnormals, rounded to minimum exponent */ 7495 /* (Etiny) if needed */ 7496 etiny=set->emin-(set->digits-1); /* smallest allowed exponent */ 7497 7498 if ISZERO(dn) { /* value is zero */ 7499 /* residue can never be non-zero here */ 7500 #if DECCHECK 7501 if (*residue!=0) { 7502 printf("++ Subnormal 0 residue %ld\n", (LI)*residue); 7503 *status|=DEC_Invalid_operation; 7504 } 7505 #endif 7506 if (dn->exponent<etiny) { /* clamp required */ 7507 dn->exponent=etiny; 7508 *status|=DEC_Clamped; 7509 } 7510 return; 7511 } 7512 7513 *status|=DEC_Subnormal; /* have a non-zero subnormal */ 7514 adjust=etiny-dn->exponent; /* calculate digits to remove */ 7515 if (adjust<=0) { /* not out of range; unrounded */ 7516 /* residue can never be non-zero here, except in the Nmin-residue */ 7517 /* case (which is a subnormal result), so can take fast-path here */ 7518 /* it may already be inexact (from setting the coefficient) */ 7519 if (*status&DEC_Inexact) *status|=DEC_Underflow; 7520 return; 7521 } 7522 7523 /* adjust>0, so need to rescale the result so exponent becomes Etiny */ 7524 /* [this code is similar to that in rescale] */ 7525 workset=*set; /* clone rounding, etc. */ 7526 workset.digits=dn->digits-adjust; /* set requested length */ 7527 workset.emin-=adjust; /* and adjust emin to match */ 7528 /* [note that the latter can be <1, here, similar to Rescale case] */ 7529 decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status); 7530 decApplyRound(dn, &workset, *residue, status); 7531 7532 /* Use 754R/854 default rule: Underflow is set iff Inexact */ 7533 /* [independent of whether trapped] */ 7534 if (*status&DEC_Inexact) *status|=DEC_Underflow; 7535 7536 /* if rounded up a 999s case, exponent will be off by one; adjust */ 7537 /* back if so [it will fit, because it was shortened earlier] */ 7538 if (dn->exponent>etiny) { 7539 dn->digits=decShiftToMost(dn->lsu, dn->digits, 1); 7540 dn->exponent--; /* (re)adjust the exponent. */ 7541 } 7542 7543 /* if rounded to zero, it is by definition clamped... */ 7544 if (ISZERO(dn)) *status|=DEC_Clamped; 7545 } /* decSetSubnormal */ 7546 7547 /* ------------------------------------------------------------------ */ 7548 /* decCheckMath - check entry conditions for a math function */ 7549 /* */ 7550 /* This checks the context and the operand */ 7551 /* */ 7552 /* rhs is the operand to check */ 7553 /* set is the context to check */ 7554 /* status is unchanged if both are good */ 7555 /* */ 7556 /* returns non-zero if status is changed, 0 otherwise */ 7557 /* */ 7558 /* Restrictions enforced: */ 7559 /* */ 7560 /* digits, emax, and -emin in the context must be less than */ 7561 /* DEC_MAX_MATH (999999), and A must be within these bounds if */ 7562 /* non-zero. Invalid_operation is set in the status if a */ 7563 /* restriction is violated. */ 7564 /* ------------------------------------------------------------------ */ 7565 static uInt decCheckMath(const decNumber *rhs, decContext *set, 7566 uInt *status) { 7567 uInt save=*status; /* record */ 7568 if (set->digits>DEC_MAX_MATH 7569 || set->emax>DEC_MAX_MATH 7570 || -set->emin>DEC_MAX_MATH) *status|=DEC_Invalid_context; 7571 else if ((rhs->digits>DEC_MAX_MATH 7572 || rhs->exponent+rhs->digits>DEC_MAX_MATH+1 7573 || rhs->exponent+rhs->digits<2*(1-DEC_MAX_MATH)) 7574 && !ISZERO(rhs)) *status|=DEC_Invalid_operation; 7575 return (*status!=save); 7576 } /* decCheckMath */ 7577 7578 /* ------------------------------------------------------------------ */ 7579 /* decGetInt -- get integer from a number */ 7580 /* */ 7581 /* dn is the number [which will not be altered] */ 7582 /* */ 7583 /* returns one of: */ 7584 /* BADINT if there is a non-zero fraction */ 7585 /* the converted integer */ 7586 /* BIGEVEN if the integer is even and magnitude > 2*10**9 */ 7587 /* BIGODD if the integer is odd and magnitude > 2*10**9 */ 7588 /* */ 7589 /* This checks and gets a whole number from the input decNumber. */ 7590 /* The sign can be determined from dn by the caller when BIGEVEN or */ 7591 /* BIGODD is returned. */ 7592 /* ------------------------------------------------------------------ */ 7593 static Int decGetInt(const decNumber *dn) { 7594 Int theInt; /* result accumulator */ 7595 const Unit *up; /* work */ 7596 Int got; /* digits (real or not) processed */ 7597 Int ilength=dn->digits+dn->exponent; /* integral length */ 7598 Flag neg=decNumberIsNegative(dn); /* 1 if -ve */ 7599 7600 /* The number must be an integer that fits in 10 digits */ 7601 /* Assert, here, that 10 is enough for any rescale Etiny */ 7602 #if DEC_MAX_EMAX > 999999999 7603 #error GetInt may need updating [for Emax] 7604 #endif 7605 #if DEC_MIN_EMIN < -999999999 7606 #error GetInt may need updating [for Emin] 7607 #endif 7608 if (ISZERO(dn)) return 0; /* zeros are OK, with any exponent */ 7609 7610 up=dn->lsu; /* ready for lsu */ 7611 theInt=0; /* ready to accumulate */ 7612 if (dn->exponent>=0) { /* relatively easy */ 7613 /* no fractional part [usual]; allow for positive exponent */ 7614 got=dn->exponent; 7615 } 7616 else { /* -ve exponent; some fractional part to check and discard */ 7617 Int count=-dn->exponent; /* digits to discard */ 7618 /* spin up whole units until reach the Unit with the unit digit */ 7619 for (; count>=DECDPUN; up++) { 7620 if (*up!=0) return BADINT; /* non-zero Unit to discard */ 7621 count-=DECDPUN; 7622 } 7623 if (count==0) got=0; /* [a multiple of DECDPUN] */ 7624 else { /* [not multiple of DECDPUN] */ 7625 Int rem; /* work */ 7626 /* slice off fraction digits and check for non-zero */ 7627 #if DECDPUN<=4 7628 theInt=QUOT10(*up, count); 7629 rem=*up-theInt*powers[count]; 7630 #else 7631 rem=*up%powers[count]; /* slice off discards */ 7632 theInt=*up/powers[count]; 7633 #endif 7634 if (rem!=0) return BADINT; /* non-zero fraction */ 7635 /* it looks good */ 7636 got=DECDPUN-count; /* number of digits so far */ 7637 up++; /* ready for next */ 7638 } 7639 } 7640 /* now it's known there's no fractional part */ 7641 7642 /* tricky code now, to accumulate up to 9.3 digits */ 7643 if (got==0) {theInt=*up; got+=DECDPUN; up++;} /* ensure lsu is there */ 7644 7645 if (ilength<11) { 7646 Int save=theInt; 7647 /* collect any remaining unit(s) */ 7648 for (; got<ilength; up++) { 7649 theInt+=*up*powers[got]; 7650 got+=DECDPUN; 7651 } 7652 if (ilength==10) { /* need to check for wrap */ 7653 if (theInt/(Int)powers[got-DECDPUN]!=(Int)*(up-1)) ilength=11; 7654 /* [that test also disallows the BADINT result case] */ 7655 else if (neg && theInt>1999999997) ilength=11; 7656 else if (!neg && theInt>999999999) ilength=11; 7657 if (ilength==11) theInt=save; /* restore correct low bit */ 7658 } 7659 } 7660 7661 if (ilength>10) { /* too big */ 7662 if (theInt&1) return BIGODD; /* bottom bit 1 */ 7663 return BIGEVEN; /* bottom bit 0 */ 7664 } 7665 7666 if (neg) theInt=-theInt; /* apply sign */ 7667 return theInt; 7668 } /* decGetInt */ 7669 7670 /* ------------------------------------------------------------------ */ 7671 /* decDecap -- decapitate the coefficient of a number */ 7672 /* */ 7673 /* dn is the number to be decapitated */ 7674 /* drop is the number of digits to be removed from the left of dn; */ 7675 /* this must be <= dn->digits (if equal, the coefficient is */ 7676 /* set to 0) */ 7677 /* */ 7678 /* Returns dn; dn->digits will be <= the initial digits less drop */ 7679 /* (after removing drop digits there may be leading zero digits */ 7680 /* which will also be removed). Only dn->lsu and dn->digits change. */ 7681 /* ------------------------------------------------------------------ */ 7682 static decNumber *decDecap(decNumber *dn, Int drop) { 7683 Unit *msu; /* -> target cut point */ 7684 Int cut; /* work */ 7685 if (drop>=dn->digits) { /* losing the whole thing */ 7686 #if DECCHECK 7687 if (drop>dn->digits) 7688 printf("decDecap called with drop>digits [%ld>%ld]\n", 7689 (LI)drop, (LI)dn->digits); 7690 #endif 7691 dn->lsu[0]=0; 7692 dn->digits=1; 7693 return dn; 7694 } 7695 msu=dn->lsu+D2U(dn->digits-drop)-1; /* -> likely msu */ 7696 cut=MSUDIGITS(dn->digits-drop); /* digits to be in use in msu */ 7697 if (cut!=DECDPUN) *msu%=powers[cut]; /* clear left digits */ 7698 /* that may have left leading zero digits, so do a proper count... */ 7699 dn->digits=decGetDigits(dn->lsu, msu-dn->lsu+1); 7700 return dn; 7701 } /* decDecap */ 7702 7703 /* ------------------------------------------------------------------ */ 7704 /* decBiStr -- compare string with pairwise options */ 7705 /* */ 7706 /* targ is the string to compare */ 7707 /* str1 is one of the strings to compare against (length may be 0) */ 7708 /* str2 is the other; it must be the same length as str1 */ 7709 /* */ 7710 /* returns 1 if strings compare equal, (that is, it is the same */ 7711 /* length as str1 and str2, and each character of targ is in either */ 7712 /* str1 or str2 in the corresponding position), or 0 otherwise */ 7713 /* */ 7714 /* This is used for generic caseless compare, including the awkward */ 7715 /* case of the Turkish dotted and dotless Is. Use as (for example): */ 7716 /* if (decBiStr(test, "mike", "MIKE")) ... */ 7717 /* ------------------------------------------------------------------ */ 7718 static Flag decBiStr(const char *targ, const char *str1, const char *str2) { 7719 for (;;targ++, str1++, str2++) { 7720 if (*targ!=*str1 && *targ!=*str2) return 0; 7721 /* *targ has a match in one (or both, if terminator) */ 7722 if (*targ=='\0') break; 7723 } /* forever */ 7724 return 1; 7725 } /* decBiStr */ 7726 7727 /* ------------------------------------------------------------------ */ 7728 /* decNaNs -- handle NaN operand or operands */ 7729 /* */ 7730 /* res is the result number */ 7731 /* lhs is the first operand */ 7732 /* rhs is the second operand, or NULL if none */ 7733 /* context is used to limit payload length */ 7734 /* status contains the current status */ 7735 /* returns res in case convenient */ 7736 /* */ 7737 /* Called when one or both operands is a NaN, and propagates the */ 7738 /* appropriate result to res. When an sNaN is found, it is changed */ 7739 /* to a qNaN and Invalid operation is set. */ 7740 /* ------------------------------------------------------------------ */ 7741 static decNumber * decNaNs(decNumber *res, const decNumber *lhs, 7742 const decNumber *rhs, decContext *set, 7743 uInt *status) { 7744 /* This decision tree ends up with LHS being the source pointer, */ 7745 /* and status updated if need be */ 7746 if (lhs->bits & DECSNAN) 7747 *status|=DEC_Invalid_operation | DEC_sNaN; 7748 else if (rhs==NULL); 7749 else if (rhs->bits & DECSNAN) { 7750 lhs=rhs; 7751 *status|=DEC_Invalid_operation | DEC_sNaN; 7752 } 7753 else if (lhs->bits & DECNAN); 7754 else lhs=rhs; 7755 7756 /* propagate the payload */ 7757 if (lhs->digits<=set->digits) decNumberCopy(res, lhs); /* easy */ 7758 else { /* too long */ 7759 const Unit *ul; 7760 Unit *ur, *uresp1; 7761 /* copy safe number of units, then decapitate */ 7762 res->bits=lhs->bits; /* need sign etc. */ 7763 uresp1=res->lsu+D2U(set->digits); 7764 for (ur=res->lsu, ul=lhs->lsu; ur<uresp1; ur++, ul++) *ur=*ul; 7765 res->digits=D2U(set->digits)*DECDPUN; 7766 /* maybe still too long */ 7767 if (res->digits>set->digits) decDecap(res, res->digits-set->digits); 7768 } 7769 7770 res->bits&=~DECSNAN; /* convert any sNaN to NaN, while */ 7771 res->bits|=DECNAN; /* .. preserving sign */ 7772 res->exponent=0; /* clean exponent */ 7773 /* [coefficient was copied/decapitated] */ 7774 return res; 7775 } /* decNaNs */ 7776 7777 /* ------------------------------------------------------------------ */ 7778 /* decStatus -- apply non-zero status */ 7779 /* */ 7780 /* dn is the number to set if error */ 7781 /* status contains the current status (not yet in context) */ 7782 /* set is the context */ 7783 /* */ 7784 /* If the status is an error status, the number is set to a NaN, */ 7785 /* unless the error was an overflow, divide-by-zero, or underflow, */ 7786 /* in which case the number will have already been set. */ 7787 /* */ 7788 /* The context status is then updated with the new status. Note that */ 7789 /* this may raise a signal, so control may never return from this */ 7790 /* routine (hence resources must be recovered before it is called). */ 7791 /* ------------------------------------------------------------------ */ 7792 static void decStatus(decNumber *dn, uInt status, decContext *set) { 7793 if (status & DEC_NaNs) { /* error status -> NaN */ 7794 /* if cause was an sNaN, clear and propagate [NaN is already set up] */ 7795 if (status & DEC_sNaN) status&=~DEC_sNaN; 7796 else { 7797 decNumberZero(dn); /* other error: clean throughout */ 7798 dn->bits=DECNAN; /* and make a quiet NaN */ 7799 } 7800 } 7801 decContextSetStatus(set, status); /* [may not return] */ 7802 return; 7803 } /* decStatus */ 7804 7805 /* ------------------------------------------------------------------ */ 7806 /* decGetDigits -- count digits in a Units array */ 7807 /* */ 7808 /* uar is the Unit array holding the number (this is often an */ 7809 /* accumulator of some sort) */ 7810 /* len is the length of the array in units [>=1] */ 7811 /* */ 7812 /* returns the number of (significant) digits in the array */ 7813 /* */ 7814 /* All leading zeros are excluded, except the last if the array has */ 7815 /* only zero Units. */ 7816 /* ------------------------------------------------------------------ */ 7817 /* This may be called twice during some operations. */ 7818 static Int decGetDigits(Unit *uar, Int len) { 7819 Unit *up=uar+(len-1); /* -> msu */ 7820 Int digits=(len-1)*DECDPUN+1; /* possible digits excluding msu */ 7821 #if DECDPUN>4 7822 uInt const *pow; /* work */ 7823 #endif 7824 /* (at least 1 in final msu) */ 7825 #if DECCHECK 7826 if (len<1) printf("decGetDigits called with len<1 [%ld]\n", (LI)len); 7827 #endif 7828 7829 for (; up>=uar; up--) { 7830 if (*up==0) { /* unit is all 0s */ 7831 if (digits==1) break; /* a zero has one digit */ 7832 digits-=DECDPUN; /* adjust for 0 unit */ 7833 continue;} 7834 /* found the first (most significant) non-zero Unit */ 7835 #if DECDPUN>1 /* not done yet */ 7836 if (*up<10) break; /* is 1-9 */ 7837 digits++; 7838 #if DECDPUN>2 /* not done yet */ 7839 if (*up<100) break; /* is 10-99 */ 7840 digits++; 7841 #if DECDPUN>3 /* not done yet */ 7842 if (*up<1000) break; /* is 100-999 */ 7843 digits++; 7844 #if DECDPUN>4 /* count the rest ... */ 7845 for (pow=&powers[4]; *up>=*pow; pow++) digits++; 7846 #endif 7847 #endif 7848 #endif 7849 #endif 7850 break; 7851 } /* up */ 7852 return digits; 7853 } /* decGetDigits */ 7854 7855 #if DECTRACE | DECCHECK 7856 /* ------------------------------------------------------------------ */ 7857 /* decNumberShow -- display a number [debug aid] */ 7858 /* dn is the number to show */ 7859 /* */ 7860 /* Shows: sign, exponent, coefficient (msu first), digits */ 7861 /* or: sign, special-value */ 7862 /* ------------------------------------------------------------------ */ 7863 /* this is public so other modules can use it */ 7864 void decNumberShow(const decNumber *dn) { 7865 const Unit *up; /* work */ 7866 uInt u, d; /* .. */ 7867 Int cut; /* .. */ 7868 char isign='+'; /* main sign */ 7869 if (dn==NULL) { 7870 printf("NULL\n"); 7871 return;} 7872 if (decNumberIsNegative(dn)) isign='-'; 7873 printf(" >> %c ", isign); 7874 if (dn->bits&DECSPECIAL) { /* Is a special value */ 7875 if (decNumberIsInfinite(dn)) printf("Infinity"); 7876 else { /* a NaN */ 7877 if (dn->bits&DECSNAN) printf("sNaN"); /* signalling NaN */ 7878 else printf("NaN"); 7879 } 7880 /* if coefficient and exponent are 0, no more to do */ 7881 if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) { 7882 printf("\n"); 7883 return;} 7884 /* drop through to report other information */ 7885 printf(" "); 7886 } 7887 7888 /* now carefully display the coefficient */ 7889 up=dn->lsu+D2U(dn->digits)-1; /* msu */ 7890 printf("%ld", (LI)*up); 7891 for (up=up-1; up>=dn->lsu; up--) { 7892 u=*up; 7893 printf(":"); 7894 for (cut=DECDPUN-1; cut>=0; cut--) { 7895 d=u/powers[cut]; 7896 u-=d*powers[cut]; 7897 printf("%ld", (LI)d); 7898 } /* cut */ 7899 } /* up */ 7900 if (dn->exponent!=0) { 7901 char esign='+'; 7902 if (dn->exponent<0) esign='-'; 7903 printf(" E%c%ld", esign, (LI)abs(dn->exponent)); 7904 } 7905 printf(" [%ld]\n", (LI)dn->digits); 7906 } /* decNumberShow */ 7907 #endif 7908 7909 #if DECTRACE || DECCHECK 7910 /* ------------------------------------------------------------------ */ 7911 /* decDumpAr -- display a unit array [debug/check aid] */ 7912 /* name is a single-character tag name */ 7913 /* ar is the array to display */ 7914 /* len is the length of the array in Units */ 7915 /* ------------------------------------------------------------------ */ 7916 static void decDumpAr(char name, const Unit *ar, Int len) { 7917 Int i; 7918 const char *spec; 7919 #if DECDPUN==9 7920 spec="%09d "; 7921 #elif DECDPUN==8 7922 spec="%08d "; 7923 #elif DECDPUN==7 7924 spec="%07d "; 7925 #elif DECDPUN==6 7926 spec="%06d "; 7927 #elif DECDPUN==5 7928 spec="%05d "; 7929 #elif DECDPUN==4 7930 spec="%04d "; 7931 #elif DECDPUN==3 7932 spec="%03d "; 7933 #elif DECDPUN==2 7934 spec="%02d "; 7935 #else 7936 spec="%d "; 7937 #endif 7938 printf(" :%c: ", name); 7939 for (i=len-1; i>=0; i--) { 7940 if (i==len-1) printf("%ld ", (LI)ar[i]); 7941 else printf(spec, ar[i]); 7942 } 7943 printf("\n"); 7944 return;} 7945 #endif 7946 7947 #if DECCHECK 7948 /* ------------------------------------------------------------------ */ 7949 /* decCheckOperands -- check operand(s) to a routine */ 7950 /* res is the result structure (not checked; it will be set to */ 7951 /* quiet NaN if error found (and it is not NULL)) */ 7952 /* lhs is the first operand (may be DECUNRESU) */ 7953 /* rhs is the second (may be DECUNUSED) */ 7954 /* set is the context (may be DECUNCONT) */ 7955 /* returns 0 if both operands, and the context are clean, or 1 */ 7956 /* otherwise (in which case the context will show an error, */ 7957 /* unless NULL). Note that res is not cleaned; caller should */ 7958 /* handle this so res=NULL case is safe. */ 7959 /* The caller is expected to abandon immediately if 1 is returned. */ 7960 /* ------------------------------------------------------------------ */ 7961 static Flag decCheckOperands(decNumber *res, const decNumber *lhs, 7962 const decNumber *rhs, decContext *set) { 7963 Flag bad=0; 7964 if (set==NULL) { /* oops; hopeless */ 7965 #if DECTRACE || DECVERB 7966 printf("Reference to context is NULL.\n"); 7967 #endif 7968 bad=1; 7969 return 1;} 7970 else if (set!=DECUNCONT 7971 && (set->digits<1 || set->round>=DEC_ROUND_MAX)) { 7972 bad=1; 7973 #if DECTRACE || DECVERB 7974 printf("Bad context [digits=%ld round=%ld].\n", 7975 (LI)set->digits, (LI)set->round); 7976 #endif 7977 } 7978 else { 7979 if (res==NULL) { 7980 bad=1; 7981 #if DECTRACE 7982 /* this one not DECVERB as standard tests include NULL */ 7983 printf("Reference to result is NULL.\n"); 7984 #endif 7985 } 7986 if (!bad && lhs!=DECUNUSED) bad=(decCheckNumber(lhs)); 7987 if (!bad && rhs!=DECUNUSED) bad=(decCheckNumber(rhs)); 7988 } 7989 if (bad) { 7990 if (set!=DECUNCONT) decContextSetStatus(set, DEC_Invalid_operation); 7991 if (res!=DECUNRESU && res!=NULL) { 7992 decNumberZero(res); 7993 res->bits=DECNAN; /* qNaN */ 7994 } 7995 } 7996 return bad; 7997 } /* decCheckOperands */ 7998 7999 /* ------------------------------------------------------------------ */ 8000 /* decCheckNumber -- check a number */ 8001 /* dn is the number to check */ 8002 /* returns 0 if the number is clean, or 1 otherwise */ 8003 /* */ 8004 /* The number is considered valid if it could be a result from some */ 8005 /* operation in some valid context. */ 8006 /* ------------------------------------------------------------------ */ 8007 static Flag decCheckNumber(const decNumber *dn) { 8008 const Unit *up; /* work */ 8009 uInt maxuint; /* .. */ 8010 Int ae, d, digits; /* .. */ 8011 Int emin, emax; /* .. */ 8012 8013 if (dn==NULL) { /* hopeless */ 8014 #if DECTRACE 8015 /* this one not DECVERB as standard tests include NULL */ 8016 printf("Reference to decNumber is NULL.\n"); 8017 #endif 8018 return 1;} 8019 8020 /* check special values */ 8021 if (dn->bits & DECSPECIAL) { 8022 if (dn->exponent!=0) { 8023 #if DECTRACE || DECVERB 8024 printf("Exponent %ld (not 0) for a special value [%02x].\n", 8025 (LI)dn->exponent, dn->bits); 8026 #endif 8027 return 1;} 8028 8029 /* 2003.09.08: NaNs may now have coefficients, so next tests Inf only */ 8030 if (decNumberIsInfinite(dn)) { 8031 if (dn->digits!=1) { 8032 #if DECTRACE || DECVERB 8033 printf("Digits %ld (not 1) for an infinity.\n", (LI)dn->digits); 8034 #endif 8035 return 1;} 8036 if (*dn->lsu!=0) { 8037 #if DECTRACE || DECVERB 8038 printf("LSU %ld (not 0) for an infinity.\n", (LI)*dn->lsu); 8039 #endif 8040 decDumpAr('I', dn->lsu, D2U(dn->digits)); 8041 return 1;} 8042 } /* Inf */ 8043 /* 2002.12.26: negative NaNs can now appear through proposed IEEE */ 8044 /* concrete formats (decimal64, etc.). */ 8045 return 0; 8046 } 8047 8048 /* check the coefficient */ 8049 if (dn->digits<1 || dn->digits>DECNUMMAXP) { 8050 #if DECTRACE || DECVERB 8051 printf("Digits %ld in number.\n", (LI)dn->digits); 8052 #endif 8053 return 1;} 8054 8055 d=dn->digits; 8056 8057 for (up=dn->lsu; d>0; up++) { 8058 if (d>DECDPUN) maxuint=DECDPUNMAX; 8059 else { /* reached the msu */ 8060 maxuint=powers[d]-1; 8061 if (dn->digits>1 && *up<powers[d-1]) { 8062 #if DECTRACE || DECVERB 8063 printf("Leading 0 in number.\n"); 8064 decNumberShow(dn); 8065 #endif 8066 return 1;} 8067 } 8068 if (*up>maxuint) { 8069 #if DECTRACE || DECVERB 8070 printf("Bad Unit [%08lx] in %ld-digit number at offset %ld [maxuint %ld].\n", 8071 (LI)*up, (LI)dn->digits, (LI)(up-dn->lsu), (LI)maxuint); 8072 #endif 8073 return 1;} 8074 d-=DECDPUN; 8075 } 8076 8077 /* check the exponent. Note that input operands can have exponents */ 8078 /* which are out of the set->emin/set->emax and set->digits range */ 8079 /* (just as they can have more digits than set->digits). */ 8080 ae=dn->exponent+dn->digits-1; /* adjusted exponent */ 8081 emax=DECNUMMAXE; 8082 emin=DECNUMMINE; 8083 digits=DECNUMMAXP; 8084 if (ae<emin-(digits-1)) { 8085 #if DECTRACE || DECVERB 8086 printf("Adjusted exponent underflow [%ld].\n", (LI)ae); 8087 decNumberShow(dn); 8088 #endif 8089 return 1;} 8090 if (ae>+emax) { 8091 #if DECTRACE || DECVERB 8092 printf("Adjusted exponent overflow [%ld].\n", (LI)ae); 8093 decNumberShow(dn); 8094 #endif 8095 return 1;} 8096 8097 return 0; /* it's OK */ 8098 } /* decCheckNumber */ 8099 8100 /* ------------------------------------------------------------------ */ 8101 /* decCheckInexact -- check a normal finite inexact result has digits */ 8102 /* dn is the number to check */ 8103 /* set is the context (for status and precision) */ 8104 /* sets Invalid operation, etc., if some digits are missing */ 8105 /* [this check is not made for DECSUBSET compilation or when */ 8106 /* subnormal is not set] */ 8107 /* ------------------------------------------------------------------ */ 8108 static void decCheckInexact(const decNumber *dn, decContext *set) { 8109 #if !DECSUBSET && DECEXTFLAG 8110 if ((set->status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact 8111 && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) { 8112 #if DECTRACE || DECVERB 8113 printf("Insufficient digits [%ld] on normal Inexact result.\n", 8114 (LI)dn->digits); 8115 decNumberShow(dn); 8116 #endif 8117 decContextSetStatus(set, DEC_Invalid_operation); 8118 } 8119 #else 8120 /* next is a noop for quiet compiler */ 8121 if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation; 8122 #endif 8123 return; 8124 } /* decCheckInexact */ 8125 #endif 8126 8127 #if DECALLOC 8128 #undef malloc 8129 #undef free 8130 /* ------------------------------------------------------------------ */ 8131 /* decMalloc -- accountable allocation routine */ 8132 /* n is the number of bytes to allocate */ 8133 /* */ 8134 /* Semantics is the same as the stdlib malloc routine, but bytes */ 8135 /* allocated are accounted for globally, and corruption fences are */ 8136 /* added before and after the 'actual' storage. */ 8137 /* ------------------------------------------------------------------ */ 8138 /* This routine allocates storage with an extra twelve bytes; 8 are */ 8139 /* at the start and hold: */ 8140 /* 0-3 the original length requested */ 8141 /* 4-7 buffer corruption detection fence (DECFENCE, x4) */ 8142 /* The 4 bytes at the end also hold a corruption fence (DECFENCE, x4) */ 8143 /* ------------------------------------------------------------------ */ 8144 static void *decMalloc(size_t n) { 8145 uInt size=n+12; /* true size */ 8146 void *alloc; /* -> allocated storage */ 8147 uInt *j; /* work */ 8148 uByte *b, *b0; /* .. */ 8149 8150 alloc=malloc(size); /* -> allocated storage */ 8151 if (alloc==NULL) return NULL; /* out of strorage */ 8152 b0=(uByte *)alloc; /* as bytes */ 8153 decAllocBytes+=n; /* account for storage */ 8154 j=(uInt *)alloc; /* -> first four bytes */ 8155 *j=n; /* save n */ 8156 /* printf(" alloc ++ dAB: %ld (%d)\n", decAllocBytes, n); */ 8157 for (b=b0+4; b<b0+8; b++) *b=DECFENCE; 8158 for (b=b0+n+8; b<b0+n+12; b++) *b=DECFENCE; 8159 return b0+8; /* -> play area */ 8160 } /* decMalloc */ 8161 8162 /* ------------------------------------------------------------------ */ 8163 /* decFree -- accountable free routine */ 8164 /* alloc is the storage to free */ 8165 /* */ 8166 /* Semantics is the same as the stdlib malloc routine, except that */ 8167 /* the global storage accounting is updated and the fences are */ 8168 /* checked to ensure that no routine has written 'out of bounds'. */ 8169 /* ------------------------------------------------------------------ */ 8170 /* This routine first checks that the fences have not been corrupted. */ 8171 /* It then frees the storage using the 'truw' storage address (that */ 8172 /* is, offset by 8). */ 8173 /* ------------------------------------------------------------------ */ 8174 static void decFree(void *alloc) { 8175 uInt *j, n; /* pointer, original length */ 8176 uByte *b, *b0; /* work */ 8177 8178 if (alloc==NULL) return; /* allowed; it's a nop */ 8179 b0=(uByte *)alloc; /* as bytes */ 8180 b0-=8; /* -> true start of storage */ 8181 j=(uInt *)b0; /* -> first four bytes */ 8182 n=*j; /* lift */ 8183 for (b=b0+4; b<b0+8; b++) if (*b!=DECFENCE) 8184 printf("=== Corrupt byte [%02x] at offset %d from %ld ===\n", *b, 8185 b-b0-8, (Int)b0); 8186 for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE) 8187 printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b, 8188 b-b0-8, (Int)b0, n); 8189 free(b0); /* drop the storage */ 8190 decAllocBytes-=n; /* account for storage */ 8191 /* printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n); */ 8192 } /* decFree */ 8193 #define malloc(a) decMalloc(a) 8194 #define free(a) decFree(a) 8195 #endif 8196