Lines Matching refs:digits
366 dn->digits=decGetDigits(dn->lsu, up-dn->lsu); in decNumberFromUInt32()
386 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; /* bad */ in decNumberToInt32()
399 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1]; in decNumberToInt32()
421 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0 in decNumberToUInt32()
435 for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1]; in decNumberToUInt32()
580 if (d>set->digits-1) { in decNumberFromString()
584 if (d>set->digits) break; in decNumberFromString()
651 if (d<=set->digits) res=dn->lsu; /* fits into supplied decNumber */ in decNumberFromString()
694 dn->digits=d; in decNumberFromString()
697 if (d>set->digits) { in decNumberFromString()
705 if ((dn->exponent-1<set->emin-dn->digits) in decNumberFromString()
706 || (dn->exponent-1>set->emax-set->digits)) { in decNumberFromString()
816 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */ in decNumberAnd()
817 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ in decNumberAnd()
818 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ in decNumberAnd()
819 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ in decNumberAnd()
846 res->digits=decGetDigits(res->lsu, uc-res->lsu); in decNumberAnd()
944 needbytes=sizeof(decNumber)+(D2U(lhs->digits)-1)*sizeof(Unit); in decNumberCompareTotalMag()
958 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); in decNumberCompareTotalMag()
1066 if (rhs->digits>set->digits) { in decNumberExp()
1131 dcmul.digits=lhs->digits+rhs->digits; /* just enough */ in decNumberFMA()
1137 needbytes=sizeof(decNumber)+(D2U(dcmul.digits)-1)*sizeof(Unit); in decNumberFMA()
1210 msua=ua+D2U(rhs->digits)-1; /* -> msu of rhs */ in decNumberInvert()
1211 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ in decNumberInvert()
1212 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ in decNumberInvert()
1233 res->digits=decGetDigits(res->lsu, uc-res->lsu); in decNumberInvert()
1284 if (rhs->digits>set->digits) { in decNumberLn()
1350 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */ in decNumberLogB()
1422 if (rhs->digits>set->digits) { in decNumberLog10()
1442 aset.digits=1; in decNumberLog10()
1465 p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3; in decNumberLog10()
1474 aset.digits=p; /* as calculated */ in decNumberLog10()
1488 p=set->digits+3; in decNumberLog10()
1503 w->digits=2; /* .. */ in decNumberLog10()
1505 aset.digits=p; in decNumberLog10()
1508 aset.digits=set->digits; /* for final divide */ in decNumberLog10()
1824 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */ in decNumberOr()
1825 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ in decNumberOr()
1826 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ in decNumberOr()
1827 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ in decNumberOr()
1853 res->digits=decGetDigits(res->lsu, uc-res->lsu); in decNumberOr()
1950 Int reqdigits=set->digits; /* requested DIGITS */ in decNumberPower()
1979 if (lhs->digits>reqdigits) { in decNumberPower()
1984 if (rhs->digits>reqdigits) { in decNumberPower()
2013 Int shift=set->digits-1; in decNumberPower()
2015 res->digits=decShiftToMost(res->lsu, 1, shift); in decNumberPower()
2108 aset.digits=MAXI(lhs->digits, set->digits)+6+4; in decNumberPower()
2123 aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2; in decNumberPower()
2125 if (!set->extended) aset.digits--; /* use classic precision */ in decNumberPower()
2128 if (aset.digits>DECNUMMAXP) {status|=DEC_Invalid_operation; break;} in decNumberPower()
2133 needbytes=sizeof(decNumber)+(D2U(aset.digits)-1)*sizeof(Unit); in decNumberPower()
2154 Int shift=set->digits-1; in decNumberPower()
2155 dac->digits=decShiftToMost(dac->lsu, 1, shift); in decNumberPower()
2329 if (rhs->digits>set->digits) { in decNumberReduce()
2474 || abs(rotate)>set->digits) /* .. or out of range */ in decNumberRotate()
2479 if (rotate<0) rotate=set->digits+rotate; in decNumberRotate()
2480 if (rotate!=0 && rotate!=set->digits /* zero or full rotation */ in decNumberRotate()
2485 Unit *msu=res->lsu+D2U(res->digits)-1; /* current msu */ in decNumberRotate()
2486 Unit *msumax=res->lsu+D2U(set->digits)-1; /* rotation msu */ in decNumberRotate()
2488 res->digits=set->digits; /* now full-length */ in decNumberRotate()
2489 msudigits=MSUDIGITS(res->digits); /* actual digits in msu */ in decNumberRotate()
2522 rotate=set->digits-rotate; /* make it right-rotate */ in decNumberRotate()
2527 decShiftToLeast(res->lsu, D2U(res->digits), shift); in decNumberRotate()
2559 res->digits=decGetDigits(res->lsu, msumax-res->lsu+1); in decNumberRotate()
2632 || abs(reqexp)>(2*(set->digits+set->emax))) /* .. or out of range */ in decNumberScaleB()
2687 || abs(shift)>set->digits) /* .. or out of range */ in decNumberShift()
2693 if (shift==set->digits) { /* removing all */ in decNumberShift()
2695 res->digits=1; /* .. */ in decNumberShift()
2699 if (res->digits+shift>set->digits) { in decNumberShift()
2700 decDecap(res, res->digits+shift-set->digits); in decNumberShift()
2704 if (res->digits>1 || *res->lsu) /* if non-zero.. */ in decNumberShift()
2705 res->digits=decShiftToMost(res->lsu, res->digits, shift); in decNumberShift()
2709 if (-shift>=res->digits) { /* discarding all */ in decNumberShift()
2711 res->digits=1; /* .. */ in decNumberShift()
2714 decShiftToLeast(res->lsu, D2U(res->digits), -shift); in decNumberShift()
2715 res->digits-=(-shift); in decNumberShift()
2838 if (rhs->digits>set->digits) { in decNumberSquareRoot()
2886 workp=MAXI(set->digits+1, rhs->digits); /* actual rounding precision */ in decNumberSquareRoot()
2890 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); in decNumberSquareRoot()
2912 exp=f->exponent+f->digits; /* adjusted to Hull rules */ in decNumberSquareRoot()
2913 f->exponent=-(f->digits); /* to range */ in decNumberSquareRoot()
2924 workset.digits=workp; /* p for initial calculation */ in decNumberSquareRoot()
2925 t->bits=0; t->digits=3; in decNumberSquareRoot()
2926 a->bits=0; a->digits=3; in decNumberSquareRoot()
2970 workset.digits=3; /* initial p */ in decNumberSquareRoot()
2971 for (; workset.digits<maxp;) { in decNumberSquareRoot()
2973 workset.digits=MINI(workset.digits*2-2, maxp); in decNumberSquareRoot()
3012 workset.digits--; /* maxp-1 is OK now */ in decNumberSquareRoot()
3013 t->exponent=-a->digits-1; /* make 0.5 ulp */ in decNumberSquareRoot()
3058 if (b->digits*2-1 > workp) { /* cannot fit */ in decNumberSquareRoot()
3077 Int maxexp=set->emax-set->digits+1; in decNumberSquareRoot()
3088 decShiftToLeast(a->lsu, D2U(a->digits), todrop); in decNumberSquareRoot()
3090 a->digits-=todrop; /* new length */ in decNumberSquareRoot()
3100 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */ in decNumberSquareRoot()
3192 workset.digits=rhs->digits; /* no length rounding */ in decNumberToIntegralExact()
3247 msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */ in decNumberXor()
3248 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ in decNumberXor()
3249 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ in decNumberXor()
3250 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ in decNumberXor()
3276 res->digits=decGetDigits(res->lsu, uc-res->lsu); in decNumberXor()
3360 dest->digits=src->digits; in decNumberCopy()
3362 if (src->digits>DECDPUN) { /* more Units to come */ in decNumberCopy()
3368 smsup=src->lsu+D2U(src->digits); /* -> source msu+1 */ in decNumberCopy()
3452 uByte *ub=bcd+dn->digits-1; /* -> lsd */ in decNumberGetBCD()
3486 Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [target pointer] */ in decNumberSetBCD()
3500 dn->digits=n; /* set digit count */ in decNumberSetBCD()
3519 ae=dn->exponent+dn->digits-1; /* adjusted exponent */ in decNumberIsNormal()
3539 ae=dn->exponent+dn->digits-1; /* adjusted exponent */ in decNumberIsSubnormal()
3590 dn->digits=1; in decNumberZero()
3621 const Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [input pointer] */ in decToString()
3648 if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return; in decToString()
3653 cut=MSUDIGITS(dn->digits); /* [faster than remainder] */ in decToString()
3666 pre=dn->digits+exp; /* digits before '.' */ in decToString()
3669 e=exp+dn->digits-1; /* calculate E value */ in decToString()
3709 if (n<dn->digits) { /* more to come, after '.' */ in decToString()
3815 Int reqdigits=set->digits; /* local copy; requested DIGITS */ in decAddOp()
3826 if (lhs->digits>reqdigits) { in decAddOp()
3831 if (rhs->digits>reqdigits) { in decAddOp()
3887 if ((res->digits-adjust)>set->digits) { in decAddOp()
3888 adjust=res->digits-set->digits; /* to fit exactly */ in decAddOp()
3891 res->digits=decShiftToMost(res->lsu, res->digits, -adjust); in decAddOp()
3914 if ((res->digits-adjust)>set->digits) { in decAddOp()
3915 adjust=res->digits-set->digits; /* to fit exactly */ in decAddOp()
3918 res->digits=decShiftToMost(res->lsu, res->digits, -adjust); in decAddOp()
3937 && rhs->digits<=DECDPUN in decAddOp()
3939 && rhs->exponent<=set->emax-set->digits+1 /* [could clamp] */ in decAddOp()
3940 && rhs->digits<=reqdigits in decAddOp()
3941 && lhs->digits<=reqdigits) { in decAddOp()
3946 && (lhs->digits>=DECDPUN || /* .. and no digits-count change */ in decAddOp()
3947 partial<(Int)powers[lhs->digits])) { /* .. */ in decAddOp()
3960 res->digits=decGetDigits(res->lsu, D2U(res->digits)); in decAddOp()
3995 if (rhs->digits+padding > lhs->digits+reqdigits+1) { in decAddOp()
3998 Int shift=reqdigits-rhs->digits; /* left shift needed */ in decAddOp()
4005 res->digits=decShiftToMost(res->lsu, res->digits, shift); in decAddOp()
4021 maxdigits=rhs->digits+padding; /* virtual length of RHS */ in decAddOp()
4022 if (lhs->digits>maxdigits) maxdigits=lhs->digits; in decAddOp()
4050 decDumpAr('A', lhs->lsu, D2U(lhs->digits)); in decAddOp()
4051 decDumpAr('B', rhs->lsu, D2U(rhs->digits)); in decAddOp()
4056 res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits), in decAddOp()
4057 rhs->lsu, D2U(rhs->digits), in decAddOp()
4060 if (res->digits<0) { /* borrowed... */ in decAddOp()
4061 res->digits=-res->digits; in decAddOp()
4065 decDumpAr('+', acc, D2U(res->digits)); in decAddOp()
4078 if (res->digits>reqdigits) in decAddOp()
4079 res->digits=decGetDigits(acc, D2U(res->digits)); in decAddOp()
4080 decSetCoeff(res, set, acc, res->digits, &residue, status); in decAddOp()
4089 if (res->digits<maxdigits) { in decAddOp()
4090 *(acc+D2U(res->digits))=0; /* ensure leading 0 is there */ in decAddOp()
4091 res->digits=maxdigits; in decAddOp()
4097 if (res->digits>reqdigits) { in decAddOp()
4098 res->digits=decGetDigits(acc, D2U(res->digits)); in decAddOp()
4099 if (res->digits<maxdigits) res->digits=maxdigits; in decAddOp()
4102 decSetCoeff(res, set, acc, res->digits, &residue, status); in decAddOp()
4114 res->digits=decGetDigits(res->lsu, D2U(res->digits)); in decAddOp()
4243 Int reqdigits=set->digits; /* requested DIGITS */ in decDivideOp()
4263 if (lhs->digits>reqdigits) { in decDivideOp()
4268 if (rhs->digits>reqdigits) { in decDivideOp()
4309 res->exponent=set->emin-set->digits+1; in decDivideOp()
4366 exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits); in decDivideOp()
4419 maxdigits=rhs->digits+reqdigits-1; in decDivideOp()
4420 if (lhs->digits>maxdigits) maxdigits=lhs->digits; in decDivideOp()
4440 source=lhs->lsu+D2U(lhs->digits)-1; /* msu of input array */ in decDivideOp()
4446 var2units=D2U(rhs->digits); /* rhs actual length (units) */ in decDivideOp()
4477 var1initpad=(var1units-D2U(lhs->digits))*DECDPUN; in decDivideOp()
4711 compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits), in decDivideOp()
4759 rhs->lsu, D2U(rhs->digits), in decDivideOp()
4917 if (lhs->digits<rhs->digits) { /* swap... */ in decMultiplyOp()
4927 if (lhs->digits>set->digits) { in decMultiplyOp()
4932 if (rhs->digits>set->digits) { in decMultiplyOp()
4945 if (rhs->digits>NEEDTWO) { /* use fastpath... */ in decMultiplyOp()
4947 ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; /* [ceiling] */ in decMultiplyOp()
4948 irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; /* .. */ in decMultiplyOp()
4986 for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++) in decMultiplyOp()
4991 for (count=rhs->digits, cup=rhs->lsu, rip=zrhi; count>0; rip++) in decMultiplyOp()
5068 needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit); in decMultiplyOp()
5083 madlength=D2U(lhs->digits); /* this won't change */ in decMultiplyOp()
5084 mermsup=rhs->lsu+D2U(rhs->digits); /* -> msu+1 of multiplier */ in decMultiplyOp()
5112 res->digits=decGetDigits(acc, accunits); /* count digits exactly */ in decMultiplyOp()
5126 decSetCoeff(res, set, acc, res->digits, &residue, status); in decMultiplyOp()
5292 d->exponent=-set->digits; /* * 10**(-d) */ in decExpOp()
5299 Int shift=set->digits-1; in decExpOp()
5302 res->digits=decShiftToMost(res->lsu, 1, shift); in decExpOp()
5317 h=rhs->exponent+rhs->digits; in decExpOp()
5334 Int maxlever=(rhs->digits>8?1:0); in decExpOp()
5346 Int use=-rhs->digits-lever; /* exponent to use for RHS */ in decExpOp()
5355 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); in decExpOp()
5379 p=MAXI(x->digits, set->digits)+h+2; /* [h<=8] */ in decExpOp()
5417 aset.digits=p*2; /* double */ in decExpOp()
5419 tset.digits=p; in decExpOp()
5437 if (((a->digits+a->exponent)>=(t->digits+t->exponent+p+1)) in decExpOp()
5438 && (a->digits>=p)) break; in decExpOp()
5446 (LI)iterations, (LI)*status, (LI)p, (LI)x->digits); in decExpOp()
5456 aset.digits=p+2; /* sufficient precision */ in decExpOp()
5481 aset.digits=set->digits; /* [use default rounding] */ in decExpOp()
5632 if (rhs->exponent==0 && set->digits<=40) {
5634 if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { /* ln(10) */
5636 if (rhs->lsu[0]==10 && rhs->digits==2) { /* ln(10) */
5643 if (rhs->lsu[0]==2 && rhs->digits==1) { /* ln(2) */
5656 p=MAXI(rhs->digits, MAXI(set->digits, 7))+2;
5672 pp=p+rhs->digits;
5692 r=rhs->exponent+rhs->digits; /* 'normalised' exponent */
5700 aset.digits=2; aset.round=DEC_ROUND_DOWN;
5709 aset.digits=16; aset.round=DEC_ROUND_HALF_EVEN; /* restore */
5732 aset.digits=pp; /* working context */
5733 bset.digits=pp+rhs->digits; /* wider context */
5760 (a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) {
5761 if (a->digits==p) break;
5778 aset.digits=pp; /* working context */
5779 bset.digits=pp+rhs->digits; /* wider context */
5786 (LI)iterations, (LI)*status, (LI)p, (LI)rhs->digits);
5792 aset.digits=set->digits; /* [use default rounding] */
5833 Int reqdigits=set->digits; /* requested DIGITS */
5846 if (lhs->digits>reqdigits) {
5851 if (rhs->digits>reqdigits) { /* [this only checks lostDigits] */
5904 if ((lhs->digits-adjust)>reqdigits) {
5914 workset.digits=lhs->digits-adjust; /* set requested length */
5924 if (res->digits==reqdigits) { /* cannot shift by 1 */
5929 res->digits=decShiftToMost(res->lsu, res->digits, 1); /* shift */
5943 res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
5951 if (res->exponent>set->emax-res->digits+1) { /* too big */
6016 if (lhs->digits>set->digits) {
6021 if (rhs->digits>set->digits) {
6059 result=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6060 rhs->lsu, D2U(rhs->digits), 0);
6203 compare=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6204 rhs->lsu, D2U(rhs->digits),
6607 for (d=0; d<dn->digits-1; d++) { /* [don't strip the final digit] */
6633 Int maxd=set->emax-set->digits+1-dn->exponent;
6639 decShiftToLeast(dn->lsu, D2U(dn->digits), d);
6641 dn->digits-=d; /* new length */
6679 static Int decShiftToMost(Unit *uar, Int digits, Int shift) { argument
6684 if (shift==0) return digits; /* [fastpath] nothing to do */
6685 if ((digits+shift)<=DECDPUN) { /* [fastpath] single-unit case */
6687 return digits+shift;
6691 source=uar+D2U(digits)-1; /* where msu comes from */
6698 first=uar+D2U(digits+shift)-1; /* where msu of source will end up */
6719 return digits+shift;
6810 +(D2U(set->digits)-1)*sizeof(Unit));
6841 decSetCoeff(dest, set, src->lsu, src->digits, residue, status);
6894 discard=len-set->digits; /* digits to discard */
6902 dn->digits=len; /* set the new length */
6926 dn->digits=1; /* .. */
6955 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */
6957 dn->digits=1; /* .. */
6960 count=set->digits; /* now digits to end up with */
6961 dn->digits=count; /* set the new length */
7000 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */
7002 dn->digits=1; /* .. */
7005 count=set->digits; /* now digits to end up with */
7006 dn->digits=count; /* set the new length */
7152 uInt count=dn->digits; /* digits to be checked */
7162 if ((dn->exponent+dn->digits)>set->emax+1) {
7176 uInt count=dn->digits; /* digits to be checked */
7193 if (dn->exponent+1==set->emin-set->digits+1) {
7194 if (count==1 && dn->digits==1) *sup=0; /* here 9 -> 0[.9] */
7197 dn->digits--;
7213 decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump);
7243 if (set->digits >= (dn->exponent+dn->digits)) {
7244 dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent);
7271 Int tinyexp=set->emin-dn->digits+1; /* precalculate subnormal boundary */
7308 if (dn->exponent<=set->emax-set->digits+1) return; /* neither needed */
7312 if (dn->exponent>set->emax-dn->digits+1) { /* too big */
7320 shift=dn->exponent-(set->emax-set->digits+1);
7324 dn->digits=decShiftToMost(dn->lsu, dn->digits, shift);
7348 if (set->clamp) emax-=set->digits-1; /* lower if clamping */
7390 Int count=set->digits; /* nines to add */
7391 dn->digits=count;
7402 dn->exponent=set->emax-set->digits+1;
7439 etiny=set->emin-(set->digits-1); /* smallest allowed exponent */
7469 workset.digits=dn->digits-adjust; /* set requested length */
7472 decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status);
7482 dn->digits=decShiftToMost(dn->lsu, dn->digits, 1);
7511 if (set->digits>DEC_MAX_MATH
7514 else if ((rhs->digits>DEC_MAX_MATH
7515 || rhs->exponent+rhs->digits>DEC_MAX_MATH+1
7516 || rhs->exponent+rhs->digits<2*(1-DEC_MAX_MATH))
7540 Int ilength=dn->digits+dn->exponent; /* integral length */
7628 if (drop>=dn->digits) { /* losing the whole thing */
7630 if (drop>dn->digits)
7632 (LI)drop, (LI)dn->digits);
7635 dn->digits=1;
7638 msu=dn->lsu+D2U(dn->digits-drop)-1; /* -> likely msu */
7639 cut=MSUDIGITS(dn->digits-drop); /* digits to be in use in msu */
7642 dn->digits=decGetDigits(dn->lsu, msu-dn->lsu+1);
7700 if (lhs->digits<=set->digits) decNumberCopy(res, lhs); /* easy */
7706 uresp1=res->lsu+D2U(set->digits);
7708 res->digits=D2U(set->digits)*DECDPUN;
7710 if (res->digits>set->digits) decDecap(res, res->digits-set->digits);
7763 Int digits=(len-1)*DECDPUN+1; /* possible digits excluding msu */ local
7774 if (digits==1) break; /* a zero has one digit */
7775 digits-=DECDPUN; /* adjust for 0 unit */
7780 digits++;
7783 digits++;
7786 digits++;
7788 for (pow=&powers[4]; *up>=*pow; pow++) digits++;
7795 return digits;
7824 if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) {
7832 up=dn->lsu+D2U(dn->digits)-1; /* msu */
7848 printf(" [%ld]\n", (LI)dn->digits);
7914 && (set->digits<1 || set->round>=DEC_ROUND_MAX)) {
7918 (LI)set->digits, (LI)set->round);
7953 Int ae, d, digits; /* .. */ local
7974 if (dn->digits!=1) {
7976 printf("Digits %ld (not 1) for an infinity.\n", (LI)dn->digits);
7983 decDumpAr('I', dn->lsu, D2U(dn->digits));
7992 if (dn->digits<1 || dn->digits>DECNUMMAXP) {
7994 printf("Digits %ld in number.\n", (LI)dn->digits);
7998 d=dn->digits;
8004 if (dn->digits>1 && *up<powers[d-1]) {
8014 (LI)*up, (LI)dn->digits, (LI)(up-dn->lsu), (LI)maxuint);
8023 ae=dn->exponent+dn->digits-1; /* adjusted exponent */
8026 digits=DECNUMMAXP;
8027 if (ae<emin-(digits-1)) {
8054 && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) {
8057 (LI)dn->digits);
8064 if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation;