Lines Matching full:dn
331 /* dn is the decNumber to receive the integer */
333 /* returns dn */
337 decNumber * decNumberFromInt32(decNumber *dn, Int in) { in decNumberFromInt32() argument
345 decNumberFromUInt32(dn, unsig); in decNumberFromInt32()
346 if (in<0) dn->bits=DECNEG; /* sign needed */ in decNumberFromInt32()
347 return dn; in decNumberFromInt32()
350 decNumber * decNumberFromUInt32(decNumber *dn, uInt uin) { in decNumberFromUInt32() argument
352 decNumberZero(dn); /* clean */ in decNumberFromUInt32()
353 if (uin==0) return dn; /* [or decGetDigits bad call] */ in decNumberFromUInt32()
354 for (up=dn->lsu; uin>0; up++) { in decNumberFromUInt32()
358 dn->digits=decGetDigits(dn->lsu, up-dn->lsu); in decNumberFromUInt32()
359 return dn; in decNumberFromUInt32()
365 /* dn is the decNumber to convert */
372 Int decNumberToInt32(const decNumber *dn, decContext *set) { in decNumberToInt32() argument
374 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; in decNumberToInt32()
378 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; /* bad */ in decNumberToInt32()
383 up=dn->lsu; /* -> lsu */ in decNumberToInt32()
391 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1]; in decNumberToInt32()
395 if (dn->bits&DECNEG && hi==214748364 && lo==8) return 0x80000000; in decNumberToInt32()
400 if (dn->bits&DECNEG) return -i; in decNumberToInt32()
408 uInt decNumberToUInt32(const decNumber *dn, decContext *set) { in decNumberToUInt32() argument
410 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; in decNumberToUInt32()
413 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0 in decNumberToUInt32()
414 || (dn->bits&DECNEG && !ISZERO(dn))); /* bad */ in decNumberToUInt32()
419 up=dn->lsu; /* -> lsu */ in decNumberToUInt32()
427 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1]; in decNumberToUInt32()
437 decNumber *decNumberFromInt64(decNumber *dn, int64_t in) in decNumberFromInt64() argument
444 decNumberFromUInt64(dn, unsig); in decNumberFromInt64()
446 dn->bits = DECNEG; /* sign needed */ in decNumberFromInt64()
448 return dn; in decNumberFromInt64()
451 decNumber *decNumberFromUInt64(decNumber *dn, uint64_t uin) in decNumberFromUInt64() argument
454 decNumberZero(dn); /* clean */ in decNumberFromUInt64()
456 return dn; /* [or decGetDigits bad call] */ in decNumberFromUInt64()
458 for (up = dn->lsu; uin > 0; up++) { in decNumberFromUInt64()
462 dn->digits = decGetDigits(dn->lsu, up-dn->lsu); in decNumberFromUInt64()
463 return dn; in decNumberFromUInt64()
466 decNumber *decNumberFromInt128(decNumber *dn, uint64_t lo, int64_t hi) in decNumberFromInt128() argument
478 decNumberFromUInt128(dn, lo, unsig_hi); in decNumberFromInt128()
480 dn->bits = DECNEG; /* sign needed */ in decNumberFromInt128()
482 return dn; in decNumberFromInt128()
485 decNumber *decNumberFromUInt128(decNumber *dn, uint64_t lo, uint64_t hi) in decNumberFromUInt128() argument
489 decNumberZero(dn); /* clean */ in decNumberFromUInt128()
491 return dn; /* [or decGetDigits bad call] */ in decNumberFromUInt128()
493 for (up = dn->lsu; hi > 0 || lo > 0; up++) { in decNumberFromUInt128()
497 dn->digits = decGetDigits(dn->lsu, up - dn->lsu); in decNumberFromUInt128()
498 return dn; in decNumberFromUInt128()
504 /* dn is the decNumber to convert. dn is assumed to have been */
513 int64_t decNumberIntegralToInt64(const decNumber *dn, decContext *set) in decNumberIntegralToInt64() argument
515 if (decNumberIsSpecial(dn) || (dn->exponent < 0) || in decNumberIntegralToInt64()
516 (dn->digits + dn->exponent > 19)) { in decNumberIntegralToInt64()
522 up = dn->lsu; /* -> lsu */ in decNumberIntegralToInt64()
524 for (d = 1; d <= dn->digits; up++, d += DECDPUN) { in decNumberIntegralToInt64()
533 hi *= (uint64_t)powers[dn->exponent]; in decNumberIntegralToInt64()
537 return (decNumberIsNegative(dn)) ? -((int64_t)hi) : (int64_t)hi; in decNumberIntegralToInt64()
548 /* dn is the decNumber to convert. dn is assumed to have been */
557 void decNumberIntegralToInt128(const decNumber *dn, decContext *set, in decNumberIntegralToInt128() argument
564 if (decNumberIsSpecial(dn) || (dn->exponent < 0) || in decNumberIntegralToInt128()
565 (dn->digits + dn->exponent > 39)) { in decNumberIntegralToInt128()
569 up = dn->lsu; /* -> lsu */ in decNumberIntegralToInt128()
571 for (d = (dn->digits - 1) / DECDPUN; d >= 0; d--) { in decNumberIntegralToInt128()
584 if (mulUInt128ByPowOf10(&lo, &hi, dn->exponent)) { in decNumberIntegralToInt128()
589 if (decNumberIsNegative(dn)) { in decNumberIntegralToInt128()
612 /* decNumberToString(dn, string); */
613 /* decNumberToEngString(dn, string); */
615 /* dn is the decNumber to convert */
618 /* string must be at least dn->digits+14 characters long */
622 char * decNumberToString(const decNumber *dn, char *string){ in decNumberToString() argument
623 decToString(dn, string, 0); in decNumberToString()
627 char * decNumberToEngString(const decNumber *dn, char *string){ in decNumberToEngString() argument
628 decToString(dn, string, 1); in decNumberToEngString()
636 /* dn -- the number structure to fill */
652 decNumber * decNumberFromString(decNumber *dn, const char chars[], in decNumberFromString() argument
674 return decNumberZero(dn); in decNumberFromString()
710 decNumberZero(dn); /* be optimistic */ in decNumberFromString()
713 dn->bits=bits | DECINF; in decNumberFromString()
719 dn->bits=bits | DECNAN; /* assume simple NaN */ in decNumberFromString()
722 dn->bits=bits | DECSNAN; in decNumberFromString()
751 bits=dn->bits; /* for copy-back */ in decNumberFromString()
801 decNumberZero(dn); /* clean result */ in decNumberFromString()
814 if (d<=set->digits) res=dn->lsu; /* fits into supplied decNumber */ in decNumberFromString()
855 dn->bits=bits; in decNumberFromString()
856 dn->exponent=exponent; in decNumberFromString()
857 dn->digits=d; in decNumberFromString()
862 decSetCoeff(dn, set, res, d, &residue, &status); in decNumberFromString()
864 decFinalize(dn, set, &residue, &status); in decNumberFromString()
868 if ((dn->exponent-1<set->emin-dn->digits) in decNumberFromString()
869 || (dn->exponent-1>set->emax-set->digits)) { in decNumberFromString()
871 decFinalize(dn, set, &residue, &status); in decNumberFromString()
874 /* decNumberShow(dn); */ in decNumberFromString()
878 if (status!=0) decStatus(dn, status, set); in decNumberFromString()
879 return dn; in decNumberFromString()
3327 decNumber dn; in decNumberToIntegralExact() local
3347 decNumberZero(&dn); /* make a number with exponent 0 */ in decNumberToIntegralExact()
3348 decNumberQuantize(res, rhs, &dn, &workset); in decNumberToIntegralExact()
3442 /* dn -- the decNumber to test */
3446 enum decClass decNumberClass(const decNumber *dn, decContext *set) { in decNumberClass() argument
3447 if (decNumberIsSpecial(dn)) { in decNumberClass()
3448 if (decNumberIsQNaN(dn)) return DEC_CLASS_QNAN; in decNumberClass()
3449 if (decNumberIsSNaN(dn)) return DEC_CLASS_SNAN; in decNumberClass()
3451 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_INF; in decNumberClass()
3455 if (decNumberIsNormal(dn, set)) { /* most common */ in decNumberClass()
3456 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_NORMAL; in decNumberClass()
3460 if (decNumberIsZero(dn)) { /* most common */ in decNumberClass()
3461 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_ZERO; in decNumberClass()
3464 if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_SUBNORMAL; in decNumberClass()
3596 /* dn is the source decNumber */
3597 /* bcd is the uInt array that will receive dn->digits BCD bytes, */
3601 /* bcd must have at least dn->digits bytes. No error is possible; if */
3602 /* dn is a NaN or Infinite, digits must be 1 and the coefficient 0. */
3604 uByte * decNumberGetBCD(const decNumber *dn, uint8_t *bcd) { in decNumberGetBCD() argument
3605 uByte *ub=bcd+dn->digits-1; /* -> lsd */ in decNumberGetBCD()
3606 const Unit *up=dn->lsu; /* Unit pointer, -> lsu */ in decNumberGetBCD()
3628 /* dn is the target decNumber */
3632 /* returns dn */
3634 /* dn must have space for at least n digits. No error is possible; */
3635 /* if dn is a NaN, or Infinite, or is to become a zero, n must be 1 */
3638 decNumber * decNumberSetBCD(decNumber *dn, const uByte *bcd, uInt n) { in decNumberSetBCD() argument
3639 Unit *up = dn->lsu + D2U(n) - 1; /* -> msu [target pointer] */ in decNumberSetBCD()
3647 for (;up>=dn->lsu; up--) { /* each Unit from msu */ in decNumberSetBCD()
3653 dn->digits=n; /* set digit count */ in decNumberSetBCD()
3654 return dn; in decNumberSetBCD()
3659 /* dn is the decNumber to test */
3661 /* returns 1 if |dn| is finite and >=Nmin, 0 otherwise */
3663 Int decNumberIsNormal(const decNumber *dn, decContext *set) { in decNumberIsNormal() argument
3666 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; in decNumberIsNormal()
3669 if (decNumberIsSpecial(dn)) return 0; /* not finite */ in decNumberIsNormal()
3670 if (decNumberIsZero(dn)) return 0; /* not non-zero */ in decNumberIsNormal()
3672 ae=dn->exponent+dn->digits-1; /* adjusted exponent */ in decNumberIsNormal()
3679 /* dn is the decNumber to test */
3681 /* returns 1 if |dn| is finite, non-zero, and <Nmin, 0 otherwise */
3683 Int decNumberIsSubnormal(const decNumber *dn, decContext *set) { in decNumberIsSubnormal() argument
3686 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; in decNumberIsSubnormal()
3689 if (decNumberIsSpecial(dn)) return 0; /* not finite */ in decNumberIsSubnormal()
3690 if (decNumberIsZero(dn)) return 0; /* not non-zero */ in decNumberIsSubnormal()
3692 ae=dn->exponent+dn->digits-1; /* adjusted exponent */ in decNumberIsSubnormal()
3700 /* dn is the number to trim */
3701 /* returns dn */
3706 decNumber * decNumberTrim(decNumber *dn) { in decNumberTrim() argument
3710 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, DECUNCONT)) return dn; in decNumberTrim()
3713 return decTrim(dn, &set, 0, &dropped); in decNumberTrim()
3728 /* dn is the number to set, with space for one digit */
3729 /* returns dn */
3734 decNumber * decNumberZero(decNumber *dn) { in decNumberZero() argument
3737 if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn; in decNumberZero()
3740 dn->bits=0; in decNumberZero()
3741 dn->exponent=0; in decNumberZero()
3742 dn->digits=1; in decNumberZero()
3743 dn->lsu[0]=0; in decNumberZero()
3744 return dn; in decNumberZero()
3754 /* dn is the number to lay out */
3758 /* string must be at least dn->digits+14 characters long */
3767 static void decToString(const decNumber *dn, char *string, Flag eng) { in decToString() argument
3768 Int exp=dn->exponent; /* local copy */ in decToString()
3773 const Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [input pointer] */ in decToString()
3777 if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) { in decToString()
3782 if (decNumberIsNegative(dn)) { /* Negatives get a minus */ in decToString()
3786 if (dn->bits&DECSPECIAL) { /* Is a special value */ in decToString()
3787 if (decNumberIsInfinite(dn)) { in decToString()
3792 if (dn->bits&DECSNAN) { /* signalling NaN */ in decToString()
3800 if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return; in decToString()
3805 cut=MSUDIGITS(dn->digits); /* [faster than remainder] */ in decToString()
3809 for (;up>=dn->lsu; up--) { /* each Unit from msu */ in decToString()
3818 pre=dn->digits+exp; /* digits before '.' */ in decToString()
3821 e=exp+dn->digits-1; /* calculate E value */ in decToString()
3838 if (!ISZERO(dn)) pre+=adj; in decToString()
3854 if (up==dn->lsu) break; /* out of input digits (pre>digits) */ in decToString()
3861 if (n<dn->digits) { /* more to come, after '.' */ in decToString()
3865 if (up==dn->lsu) break; /* out of input digits */ in decToString()
3881 if (up==dn->lsu) break; /* out of input digits */ in decToString()
6726 /* dn is the number to trim or normalize */
6730 /* returns dn */
6737 static decNumber * decTrim(decNumber *dn, decContext *set, Flag all, argument
6744 if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
6748 if ((dn->bits & DECSPECIAL) /* fast exit if special .. */
6749 || (*dn->lsu & 0x01)) return dn; /* .. or odd */
6750 if (ISZERO(dn)) { /* .. or 0 */
6751 dn->exponent=0; /* (sign is preserved) */
6752 return dn;
6756 exp=dn->exponent;
6758 up=dn->lsu; /* -> current Unit */
6759 for (d=0; d<dn->digits-1; d++) { /* [don't strip the final digit] */
6781 if (d==0) return dn; /* none to drop */
6785 Int maxd=set->emax-set->digits+1-dn->exponent;
6786 if (maxd<=0) return dn; /* nothing possible */
6791 decShiftToLeast(dn->lsu, D2U(dn->digits), d);
6792 dn->exponent+=d; /* maintain numerical value */
6793 dn->digits-=d; /* new length */
6795 return dn;
6938 /* dn is the number to round (dn->digits is > set->digits) */
6953 static decNumber *decRoundOperand(const decNumber *dn, decContext *set, argument
6967 decCopyFit(res, dn, set, &residue, &newstatus);
6999 /* dn is the number whose coefficient array is to be set. */
7002 /* lsu -> lsu of the source coefficient [may be dn->lsu] */
7003 /* len is digits in the source coefficient [may be dn->digits] */
7013 /* dn->lsu and len must == dn->digits. */
7017 /* if dn->lsu==lsu). */
7024 /* dn->digits, dn->lsu (and as required), and dn->exponent are */
7025 /* updated as necessary. dn->bits (sign) is unchanged. */
7035 static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu, argument
7048 if (dn->lsu!=lsu) { /* copy needed */
7052 for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
7054 dn->digits=len; /* set the new length */
7056 /* dn->exponent and residue are unchanged, record any inexactitude */
7062 dn->exponent+=discard; /* maintain numerical value */
7077 *dn->lsu=0; /* coefficient will now be 0 */
7078 dn->digits=1; /* .. */
7108 *dn->lsu=0; /* .. result is 0 */
7109 dn->digits=1; /* .. */
7113 dn->digits=count; /* set the new length */
7116 for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
7153 *dn->lsu=0; /* .. result is 0 */
7154 dn->digits=1; /* .. */
7158 dn->digits=count; /* set the new length */
7160 for (target=dn->lsu; ; target++) {
7187 /* dn is the number, with space for set->digits digits */
7196 /* is, of the opposite sign to dn. In this case the */
7213 /* All fields in dn are updated as required. */
7216 static void decApplyRound(decNumber *dn, decContext *set, Int residue, argument
7229 /* positive residue and the lsd of dn is 0 or 5, in which case */
7233 Int lsd5=*dn->lsu%5; /* get lsd and quintate */
7252 if (*dn->lsu & 0x01) bump=1;
7267 if (decNumberIsNegative(dn)) {
7278 if (!decNumberIsNegative(dn)) {
7304 uInt count=dn->digits; /* digits to be checked */
7305 for (up=dn->lsu; ; up++) {
7311 for (up=up-1; up>=dn->lsu; up--) *up=0; /* others all to 0 */
7312 dn->exponent++; /* and bump exponent */
7314 if ((dn->exponent+dn->digits)>set->emax+1) {
7315 decSetOverflow(dn, set, status);
7328 uInt count=dn->digits; /* digits to be checked */
7329 for (up=dn->lsu; ; up++) {
7337 for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1;
7338 dn->exponent--; /* and bump exponent */
7344 /* dn->exponent, set->digits); */
7345 if (dn->exponent+1==set->emin-set->digits+1) {
7346 if (count==1 && dn->digits==1) *sup=0; /* here 9 -> 0[.9] */
7349 dn->digits--;
7351 dn->exponent++;
7365 decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump);
7372 /* dn is the number */
7385 static void decFinish(decNumber *dn, decContext *set, Int *residue, argument
7388 if ISZERO(dn) { /* value is zero */
7389 dn->exponent=0; /* clean exponent .. */
7390 dn->bits=0; /* .. and sign */
7393 if (dn->exponent>=0) { /* non-negative exponent */
7395 if (set->digits >= (dn->exponent+dn->digits)) {
7396 dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent);
7397 dn->exponent=0;
7402 decFinalize(dn, set, residue, status);
7409 /* dn is the number */
7420 static void decFinalize(decNumber *dn, decContext *set, Int *residue, argument
7423 Int tinyexp=set->emin-dn->digits+1; /* precalculate subnormal boundary */
7431 if (dn->exponent<=tinyexp) { /* prefilter */
7434 /* A very nasty case here is dn == Nmin and residue<0 */
7435 if (dn->exponent<tinyexp) {
7437 decSetSubnormal(dn, set, residue, status);
7440 /* Equals case: only subnormal if dn=Nmin and negative residue */
7444 comp=decCompare(dn, &nmin, 1); /* (signless compare) */
7449 if (*residue<0 && comp==0) { /* neg residue and dn==Nmin */
7450 decApplyRound(dn, set, *residue, status); /* might force down */
7451 decSetSubnormal(dn, set, residue, status);
7457 if (*residue!=0) decApplyRound(dn, set, *residue, status);
7460 if (dn->exponent<=set->emax-set->digits+1) return; /* neither needed */
7464 if (dn->exponent>set->emax-dn->digits+1) { /* too big */
7465 decSetOverflow(dn, set, status);
7472 shift=dn->exponent-(set->emax-set->digits+1);
7475 if (!ISZERO(dn)) {
7476 dn->digits=decShiftToMost(dn->lsu, dn->digits, shift);
7478 dn->exponent-=shift; /* adjust the exponent to match */
7486 /* dn is the number (used for sign [only] and result) */
7492 /* dn and the rounding mode, following IEEE 854 rules. */
7494 static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) { argument
7496 uByte sign=dn->bits&DECNEG; /* clean and save sign bit */
7498 if (ISZERO(dn)) { /* zero does not overflow magnitude */
7501 if (dn->exponent>emax) { /* clamp required */
7502 dn->exponent=emax;
7508 decNumberZero(dn);
7525 decSetMaxValue(dn, set);
7526 dn->bits=sign; /* set sign */
7528 else dn->bits=sign|DECINF; /* Value is +/-Infinity */
7535 /* dn is the number to set */
7540 static void decSetMaxValue(decNumber *dn, decContext *set) { argument
7543 dn->digits=count;
7545 for (up=dn->lsu; ; up++) {
7553 dn->bits=0; /* + sign */
7554 dn->exponent=set->emax-set->digits+1;
7560 /* dn is the number (used as input as well as output; it may have */
7574 static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue, argument
7582 decNumberZero(dn);
7593 if ISZERO(dn) { /* value is zero */
7601 if (dn->exponent<etiny) { /* clamp required */
7602 dn->exponent=etiny;
7609 adjust=etiny-dn->exponent; /* calculate digits to remove */
7621 workset.digits=dn->digits-adjust; /* set requested length */
7624 decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status);
7625 decApplyRound(dn, &workset, *residue, status);
7633 if (dn->exponent>etiny) {
7634 dn->digits=decShiftToMost(dn->lsu, dn->digits, 1);
7635 dn->exponent--; /* (re)adjust the exponent. */
7639 if (ISZERO(dn)) *status|=DEC_Clamped;
7676 /* dn is the number [which will not be altered] */
7685 /* The sign can be determined from dn by the caller when BIGEVEN or */
7688 static Int decGetInt(const decNumber *dn) { argument
7692 Int ilength=dn->digits+dn->exponent; /* integral length */
7693 Flag neg=decNumberIsNegative(dn); /* 1 if -ve */
7703 if (ISZERO(dn)) return 0; /* zeros are OK, with any exponent */
7705 up=dn->lsu; /* ready for lsu */
7707 if (dn->exponent>=0) { /* relatively easy */
7709 got=dn->exponent;
7712 Int count=-dn->exponent; /* digits to discard */
7768 /* dn is the number to be decapitated */
7769 /* drop is the number of digits to be removed from the left of dn; */
7770 /* this must be <= dn->digits (if equal, the coefficient is */
7773 /* Returns dn; dn->digits will be <= the initial digits less drop */
7775 /* which will also be removed). Only dn->lsu and dn->digits change. */
7777 static decNumber *decDecap(decNumber *dn, Int drop) { argument
7780 if (drop>=dn->digits) { /* losing the whole thing */
7782 if (drop>dn->digits)
7784 (LI)drop, (LI)dn->digits);
7786 dn->lsu[0]=0;
7787 dn->digits=1;
7788 return dn;
7790 msu=dn->lsu+D2U(dn->digits-drop)-1; /* -> likely msu */
7791 cut=MSUDIGITS(dn->digits-drop); /* digits to be in use in msu */
7794 dn->digits=decGetDigits(dn->lsu, msu-dn->lsu+1);
7795 return dn;
7875 /* dn is the number to set if error */
7887 static void decStatus(decNumber *dn, uInt status, decContext *set) { argument
7892 decNumberZero(dn); /* other error: clean throughout */
7893 dn->bits=DECNAN; /* and make a quiet NaN */
7985 /* dn is the number to show */
7991 void decNumberShow(const decNumber *dn) { argument
7996 if (dn==NULL) {
7999 if (decNumberIsNegative(dn)) isign='-';
8001 if (dn->bits&DECSPECIAL) { /* Is a special value */
8002 if (decNumberIsInfinite(dn)) printf("Infinity");
8004 if (dn->bits&DECSNAN) printf("sNaN"); /* signalling NaN */
8008 if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) {
8016 up=dn->lsu+D2U(dn->digits)-1; /* msu */
8018 for (up=up-1; up>=dn->lsu; up--) {
8027 if (dn->exponent!=0) {
8029 if (dn->exponent<0) esign='-';
8030 printf(" E%c%ld", esign, (LI)abs(dn->exponent));
8032 printf(" [%ld]\n", (LI)dn->digits);
8128 /* dn is the number to check */
8134 static Flag decCheckNumber(const decNumber *dn) { argument
8140 if (dn==NULL) { /* hopeless */
8148 if (dn->bits & DECSPECIAL) {
8149 if (dn->exponent!=0) {
8152 (LI)dn->exponent, dn->bits);
8157 if (decNumberIsInfinite(dn)) {
8158 if (dn->digits!=1) {
8160 printf("Digits %ld (not 1) for an infinity.\n", (LI)dn->digits);
8163 if (*dn->lsu!=0) {
8165 printf("LSU %ld (not 0) for an infinity.\n", (LI)*dn->lsu);
8167 decDumpAr('I', dn->lsu, D2U(dn->digits));
8176 if (dn->digits<1 || dn->digits>DECNUMMAXP) {
8178 printf("Digits %ld in number.\n", (LI)dn->digits);
8182 d=dn->digits;
8184 for (up=dn->lsu; d>0; up++) {
8188 if (dn->digits>1 && *up<powers[d-1]) {
8191 decNumberShow(dn);
8198 (LI)*up, (LI)dn->digits, (LI)(up-dn->lsu), (LI)maxuint);
8207 ae=dn->exponent+dn->digits-1; /* adjusted exponent */
8214 decNumberShow(dn);
8220 decNumberShow(dn);
8229 /* dn is the number to check */
8235 static void decCheckInexact(const decNumber *dn, decContext *set) { argument
8238 && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) {
8241 (LI)dn->digits);
8242 decNumberShow(dn);
8248 if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation;