Lines Matching refs:rhs
237 static Int decCompare(const decNumber *lhs, const decNumber *rhs, Flag);
286 #define SPECIALARG (rhs->bits & DECSPECIAL)
287 #define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL)
738 decNumber * decNumberAbs(decNumber *res, const decNumber *rhs, in decNumberAbs() argument
744 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberAbs()
748 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */ in decNumberAbs()
749 decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status); in decNumberAbs()
771 const decNumber *rhs, decContext *set) { in decNumberAdd() argument
773 decAddOp(res, lhs, rhs, set, 0, &status); in decNumberAdd()
797 const decNumber *rhs, decContext *set) { in decNumberAnd() argument
803 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberAnd()
807 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { in decNumberAnd()
814 ub=rhs->lsu; /* .. */ in decNumberAnd()
817 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ in decNumberAnd()
865 const decNumber *rhs, decContext *set) { in decNumberCompare() argument
867 decCompareOp(res, lhs, rhs, set, COMPARE, &status); in decNumberCompare()
885 const decNumber *rhs, decContext *set) { in decNumberCompareSignal() argument
887 decCompareOp(res, lhs, rhs, set, COMPSIG, &status); in decNumberCompareSignal()
906 const decNumber *rhs, decContext *set) { in decNumberCompareTotal() argument
908 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status); in decNumberCompareTotal()
927 const decNumber *rhs, decContext *set) { in decNumberCompareTotalMag() argument
937 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberCompareTotalMag()
956 if (decNumberIsNegative(rhs)) { /* rhs<0 */ in decNumberCompareTotalMag()
958 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); in decNumberCompareTotalMag()
966 decNumberCopy(b, rhs); /* copy content */ in decNumberCompareTotalMag()
968 rhs=b; /* use copy from here on */ in decNumberCompareTotalMag()
970 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status); in decNumberCompareTotalMag()
992 const decNumber *rhs, decContext *set) { in decNumberDivide() argument
994 decDivideOp(res, lhs, rhs, set, DIVIDE, &status); in decNumberDivide()
1015 const decNumber *rhs, decContext *set) { in decNumberDivideInteger() argument
1017 decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status); in decNumberDivideInteger()
1047 decNumber * decNumberExp(decNumber *res, const decNumber *rhs, in decNumberExp() argument
1055 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberExp()
1062 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */ in decNumberExp()
1066 if (rhs->digits>set->digits) { in decNumberExp()
1067 allocrhs=decRoundOperand(rhs, set, &status); in decNumberExp()
1069 rhs=allocrhs; in decNumberExp()
1073 decExpOp(res, rhs, set, &status); in decNumberExp()
1104 const decNumber *rhs, const decNumber *fhs, in decNumberFMA() argument
1115 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberFMA()
1127 || (!decNumberIsSpecial(rhs) && decCheckMath(rhs, set, &status)) in decNumberFMA()
1131 dcmul.digits=lhs->digits+rhs->digits; /* just enough */ in decNumberFMA()
1147 decMultiplyOp(acc, lhs, rhs, &dcmul, &status); in decNumberFMA()
1194 decNumber * decNumberInvert(decNumber *res, const decNumber *rhs, in decNumberInvert() argument
1200 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberInvert()
1203 if (rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { in decNumberInvert()
1208 ua=rhs->lsu; /* bottom-up */ in decNumberInvert()
1210 msua=ua+D2U(rhs->digits)-1; /* -> msu of rhs */ in decNumberInvert()
1267 decNumber * decNumberLn(decNumber *res, const decNumber *rhs, in decNumberLn() argument
1275 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberLn()
1280 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */ in decNumberLn()
1284 if (rhs->digits>set->digits) { in decNumberLn()
1285 allocrhs=decRoundOperand(rhs, set, &status); in decNumberLn()
1287 rhs=allocrhs; in decNumberLn()
1290 if (ISZERO(rhs)) { /* +/- zeros -> error */ in decNumberLn()
1295 decLnOp(res, rhs, set, &status); in decNumberLn()
1333 decNumber * decNumberLogB(decNumber *res, const decNumber *rhs, in decNumberLogB() argument
1338 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberLogB()
1342 if (decNumberIsNaN(rhs)) decNaNs(res, rhs, NULL, set, &status); in decNumberLogB()
1343 else if (decNumberIsInfinite(rhs)) decNumberCopyAbs(res, rhs); in decNumberLogB()
1344 else if (decNumberIsZero(rhs)) { in decNumberLogB()
1350 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */ in decNumberLogB()
1389 decNumber * decNumberLog10(decNumber *res, const decNumber *rhs, in decNumberLog10() argument
1413 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberLog10()
1418 if (!decCheckMath(rhs, set, &status)) do { /* protect malloc */ in decNumberLog10()
1422 if (rhs->digits>set->digits) { in decNumberLog10()
1423 allocrhs=decRoundOperand(rhs, set, &status); in decNumberLog10()
1425 rhs=allocrhs; in decNumberLog10()
1428 if (ISZERO(rhs)) { /* +/- zeros -> error */ in decNumberLog10()
1437 if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) { in decNumberLog10()
1443 decCopyFit(w, rhs, &aset, &residue, ©stat); /* copy & shorten */ in decNumberLog10()
1465 p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3; in decNumberLog10()
1478 decLnOp(a, rhs, &aset, &status); /* a=ln(rhs) */ in decNumberLog10()
1538 const decNumber *rhs, decContext *set) { in decNumberMax() argument
1540 decCompareOp(res, lhs, rhs, set, COMPMAX, &status); in decNumberMax()
1561 const decNumber *rhs, decContext *set) { in decNumberMaxMag() argument
1563 decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status); in decNumberMaxMag()
1584 const decNumber *rhs, decContext *set) { in decNumberMin() argument
1586 decCompareOp(res, lhs, rhs, set, COMPMIN, &status); in decNumberMin()
1607 const decNumber *rhs, decContext *set) { in decNumberMinMag() argument
1609 decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status); in decNumberMinMag()
1631 decNumber * decNumberMinus(decNumber *res, const decNumber *rhs, in decNumberMinus() argument
1637 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberMinus()
1641 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */ in decNumberMinus()
1642 decAddOp(res, &dzero, rhs, set, DECNEG, &status); in decNumberMinus()
1661 decNumber * decNumberNextMinus(decNumber *res, const decNumber *rhs, in decNumberNextMinus() argument
1667 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberNextMinus()
1671 if ((rhs->bits&(DECINF|DECNEG))==DECINF) { in decNumberNextMinus()
1680 decAddOp(res, rhs, &dtiny, &workset, DECNEG, &status); in decNumberNextMinus()
1697 decNumber * decNumberNextPlus(decNumber *res, const decNumber *rhs, in decNumberNextPlus() argument
1703 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberNextPlus()
1707 if ((rhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) { in decNumberNextPlus()
1717 decAddOp(res, rhs, &dtiny, &workset, 0, &status); in decNumberNextPlus()
1738 const decNumber *rhs, decContext *set) { in decNumberNextToward() argument
1744 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberNextToward()
1747 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { in decNumberNextToward()
1748 decNaNs(res, lhs, rhs, set, &status); in decNumberNextToward()
1751 result=decCompare(lhs, rhs, 0); /* sign matters */ in decNumberNextToward()
1754 if (result==0) decNumberCopySign(res, lhs, rhs); /* easy */ in decNumberNextToward()
1806 const decNumber *rhs, decContext *set) { in decNumberOr() argument
1812 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberOr()
1816 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { in decNumberOr()
1822 ub=rhs->lsu; /* .. */ in decNumberOr()
1825 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ in decNumberOr()
1875 decNumber * decNumberPlus(decNumber *res, const decNumber *rhs, in decNumberPlus() argument
1880 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberPlus()
1884 dzero.exponent=rhs->exponent; /* [no coefficient expansion] */ in decNumberPlus()
1885 decAddOp(res, &dzero, rhs, set, 0, &status); in decNumberPlus()
1906 const decNumber *rhs, decContext *set) { in decNumberMultiply() argument
1908 decMultiplyOp(res, lhs, rhs, set, &status); in decNumberMultiply()
1943 const decNumber *rhs, decContext *set) { in decNumberPower() argument
1973 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberPower()
1984 if (rhs->digits>reqdigits) { in decNumberPower()
1985 allocrhs=decRoundOperand(rhs, set, &status); in decNumberPower()
1987 rhs=allocrhs; in decNumberPower()
1995 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { /* NaNs */ in decNumberPower()
1996 decNaNs(res, lhs, rhs, set, &status); in decNumberPower()
1998 if (decNumberIsInfinite(rhs)) { /* rhs Infinity */ in decNumberPower()
1999 Flag rhsneg=rhs->bits&DECNEG; /* save rhs sign */ in decNumberPower()
2028 n=decGetInt(rhs); in decNumberPower()
2041 uByte rbits=rhs->bits; /* save */ in decNumberPower()
2067 uByte rbits=rhs->bits; /* save */ in decNumberPower()
2091 || decCheckMath(rhs, set, &status)) break; /* variable status */ in decNumberPower()
2123 aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2; in decNumberPower()
2161 decMultiplyOp(dac, dac, rhs, &aset, &status); /* dac=dac*rhs */ in decNumberPower()
2173 if (decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */ in decNumberPower()
2222 if (!set->extended && decNumberIsNegative(rhs)) { in decNumberPower()
2241 decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */ in decNumberPower()
2288 const decNumber *rhs, decContext *set) { in decNumberQuantize() argument
2290 decQuantizeOp(res, lhs, rhs, set, 1, &status); in decNumberQuantize()
2307 decNumber * decNumberNormalize(decNumber *res, const decNumber *rhs, in decNumberNormalize() argument
2309 return decNumberReduce(res, rhs, set); in decNumberNormalize()
2312 decNumber * decNumberReduce(decNumber *res, const decNumber *rhs, in decNumberReduce() argument
2322 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberReduce()
2329 if (rhs->digits>set->digits) { in decNumberReduce()
2330 allocrhs=decRoundOperand(rhs, set, &status); in decNumberReduce()
2332 rhs=allocrhs; in decNumberReduce()
2339 if (decNumberIsNaN(rhs)) { in decNumberReduce()
2340 decNaNs(res, rhs, NULL, set, &status); in decNumberReduce()
2345 decCopyFit(res, rhs, set, &residue, &status); /* copy & round */ in decNumberReduce()
2377 const decNumber *rhs, decContext *set) { in decNumberRescale() argument
2379 decQuantizeOp(res, lhs, rhs, set, 0, &status); in decNumberRescale()
2397 const decNumber *rhs, decContext *set) { in decNumberRemainder() argument
2399 decDivideOp(res, lhs, rhs, set, REMAINDER, &status); in decNumberRemainder()
2420 const decNumber *rhs, decContext *set) { in decNumberRemainderNear() argument
2422 decDivideOp(res, lhs, rhs, set, REMNEAR, &status); in decNumberRemainderNear()
2456 const decNumber *rhs, decContext *set) { in decNumberRotate() argument
2461 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberRotate()
2465 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) in decNumberRotate()
2466 decNaNs(res, lhs, rhs, set, &status); in decNumberRotate()
2468 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0) in decNumberRotate()
2471 rotate=decGetInt(rhs); /* [cannot fail] */ in decNumberRotate()
2577 const decNumber *rhs) { in decNumberSameQuantum() argument
2581 if (decCheckOperands(res, lhs, rhs, DECUNCONT)) return res; in decNumberSameQuantum()
2585 if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1; in decNumberSameQuantum()
2586 else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1; in decNumberSameQuantum()
2589 else if (lhs->exponent==rhs->exponent) ret=1; in decNumberSameQuantum()
2612 const decNumber *rhs, decContext *set) { in decNumberScaleB() argument
2618 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberScaleB()
2622 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) in decNumberScaleB()
2623 decNaNs(res, lhs, rhs, set, &status); in decNumberScaleB()
2625 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0) in decNumberScaleB()
2629 reqexp=decGetInt(rhs); /* [cannot fail] */ in decNumberScaleB()
2669 const decNumber *rhs, decContext *set) { in decNumberShift() argument
2674 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberShift()
2678 if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) in decNumberShift()
2679 decNaNs(res, lhs, rhs, set, &status); in decNumberShift()
2681 else if (decNumberIsInfinite(rhs) || rhs->exponent!=0) in decNumberShift()
2684 shift=decGetInt(rhs); /* [cannot fail] */ in decNumberShift()
2797 decNumber * decNumberSquareRoot(decNumber *res, const decNumber *rhs, in decNumberSquareRoot() argument
2831 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberSquareRoot()
2838 if (rhs->digits>set->digits) { in decNumberSquareRoot()
2839 allocrhs=decRoundOperand(rhs, set, &status); in decNumberSquareRoot()
2843 rhs=allocrhs; in decNumberSquareRoot()
2851 if (decNumberIsInfinite(rhs)) { /* an infinity */ in decNumberSquareRoot()
2852 if (decNumberIsNegative(rhs)) status|=DEC_Invalid_operation; in decNumberSquareRoot()
2853 else decNumberCopy(res, rhs); /* +Infinity */ in decNumberSquareRoot()
2855 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */ in decNumberSquareRoot()
2862 ideal=(rhs->exponent&~1)/2; /* target */ in decNumberSquareRoot()
2865 if (ISZERO(rhs)) { in decNumberSquareRoot()
2866 decNumberCopy(res, rhs); /* could be 0 or -0 */ in decNumberSquareRoot()
2874 if (decNumberIsNegative(rhs)) { 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()
2911 decNumberCopy(f, rhs); in decNumberSquareRoot()
3068 decCompareOp(t, b, rhs, &workset, COMPARE, &mstatus); /* b ? rhs */ in decNumberSquareRoot()
3100 Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */ in decNumberSquareRoot()
3140 const decNumber *rhs, decContext *set) { in decNumberSubtract() argument
3143 decAddOp(res, lhs, rhs, set, DECNEG, &status); in decNumberSubtract()
3172 decNumber * decNumberToIntegralExact(decNumber *res, const decNumber *rhs, in decNumberToIntegralExact() argument
3179 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberToIntegralExact()
3184 if (decNumberIsInfinite(rhs)) decNumberCopy(res, rhs); /* an Infinity */ in decNumberToIntegralExact()
3185 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */ in decNumberToIntegralExact()
3189 if (rhs->exponent>=0) return decNumberCopy(res, rhs); in decNumberToIntegralExact()
3192 workset.digits=rhs->digits; /* no length rounding */ in decNumberToIntegralExact()
3195 decNumberQuantize(res, rhs, &dn, &workset); in decNumberToIntegralExact()
3202 decNumber * decNumberToIntegralValue(decNumber *res, const decNumber *rhs, in decNumberToIntegralValue() argument
3206 decNumberToIntegralExact(res, rhs, &workset); in decNumberToIntegralValue()
3229 const decNumber *rhs, decContext *set) { in decNumberXor() argument
3235 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberXor()
3239 || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) { in decNumberXor()
3245 ub=rhs->lsu; /* .. */ in decNumberXor()
3248 msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */ in decNumberXor()
3386 decNumber * decNumberCopyAbs(decNumber *res, const decNumber *rhs) { in decNumberCopyAbs() argument
3388 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res; in decNumberCopyAbs()
3390 decNumberCopy(res, rhs); in decNumberCopyAbs()
3407 decNumber * decNumberCopyNegate(decNumber *res, const decNumber *rhs) { in decNumberCopyNegate() argument
3409 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res; in decNumberCopyNegate()
3411 decNumberCopy(res, rhs); in decNumberCopyNegate()
3429 const decNumber *rhs) { in decNumberCopySign() argument
3432 if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res; in decNumberCopySign()
3434 sign=rhs->bits & DECNEG; /* save sign bit */ in decNumberCopySign()
3798 const decNumber *rhs, decContext *set, in decAddOp() argument
3819 if (decCheckOperands(res, lhs, rhs, set)) return res; in decAddOp()
3831 if (rhs->digits>reqdigits) { in decAddOp()
3832 allocrhs=decRoundOperand(rhs, set, status); in decAddOp()
3834 rhs=allocrhs; in decAddOp()
3841 diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG); in decAddOp()
3846 decNaNs(res, lhs, rhs, set, status); in decAddOp()
3850 if (decNumberIsInfinite(rhs) && diffsign) { in decAddOp()
3856 else bits=(rhs->bits^negate) & DECNEG;/* RHS must be Infinity */ in decAddOp()
3870 decCopyFit(res, rhs, set, &residue, status); /* copy (as needed) */ in decAddOp()
3901 if (ISZERO(rhs)) { /* [lhs is non-zero] */ in decAddOp()
3903 Int rexp=rhs->exponent; /* save in case RHS==RES */ in decAddOp()
3904 bits=rhs->bits; /* be clean */ in decAddOp()
3931 padding=rhs->exponent-lhs->exponent; in decAddOp()
3937 && rhs->digits<=DECDPUN in decAddOp()
3938 && rhs->exponent>=set->emin /* [some normals drop through] */ in decAddOp()
3939 && rhs->exponent<=set->emax-set->digits+1 /* [could clamp] */ in decAddOp()
3940 && rhs->digits<=reqdigits in decAddOp()
3944 partial+=*rhs->lsu; in decAddOp()
3955 partial-=*rhs->lsu; in decAddOp()
3987 bits=(uByte)(rhs->bits^negate); /* assumed sign is now that of RHS */ in decAddOp()
3988 t=lhs; lhs=rhs; rhs=t; in decAddOp()
3995 if (rhs->digits+padding > lhs->digits+reqdigits+1) { in decAddOp()
3998 Int shift=reqdigits-rhs->digits; /* left shift needed */ in decAddOp()
4002 decCopyFit(res, rhs, set, &residue, status); in decAddOp()
4021 maxdigits=rhs->digits+padding; /* virtual length of RHS */ in decAddOp()
4031 || (res==rhs && rhsshift>0)) { /* destructive overlap */ in decAddOp()
4051 decDumpAr('B', rhs->lsu, D2U(rhs->digits)); in decAddOp()
4057 rhs->lsu, D2U(rhs->digits), in decAddOp()
4212 const decNumber *lhs, const decNumber *rhs, in decDivideOp() argument
4256 if (decCheckOperands(res, lhs, rhs, set)) return res; in decDivideOp()
4268 if (rhs->digits>reqdigits) { in decDivideOp()
4269 allocrhs=decRoundOperand(rhs, set, status); in decDivideOp()
4271 rhs=allocrhs; in decDivideOp()
4277 bits=(lhs->bits^rhs->bits)&DECNEG; /* assumed sign for divisions */ in decDivideOp()
4282 decNaNs(res, lhs, rhs, set, status); in decDivideOp()
4287 if (decNumberIsInfinite(rhs) || /* two infinities are invalid .. */ in decDivideOp()
4319 if (ISZERO(rhs)) { /* x/0 is always exceptional */ in decDivideOp()
4342 exponent=lhs->exponent-rhs->exponent; /* ideal exponent */ in decDivideOp()
4353 exponent=rhs->exponent; /* [save in case overwrite] */ in decDivideOp()
4366 exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits); in decDivideOp()
4381 if (lhs->exponent<=rhs->exponent) { in decDivideOp()
4419 maxdigits=rhs->digits+reqdigits-1; in decDivideOp()
4446 var2units=D2U(rhs->digits); /* rhs actual length (units) */ in decDivideOp()
4447 var2=rhs->lsu; /* -> rhs array */ in decDivideOp()
4488 maxexponent=lhs->exponent-rhs->exponent; /* save */ in decDivideOp()
4663 if (rhs->exponent<exp) exp=rhs->exponent; in decDivideOp()
4682 postshift=var1initpad+exponent-lhs->exponent+rhs->exponent; in decDivideOp()
4693 if (rhs->exponent<exponent) exponent=rhs->exponent; in decDivideOp()
4711 compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits), in decDivideOp()
4712 rhs->exponent-exponent); in decDivideOp()
4753 exp=rhs->exponent-exponent; /* RHS padding needed */ in decDivideOp()
4759 rhs->lsu, D2U(rhs->digits), in decDivideOp()
4832 const decNumber *rhs, decContext *set, in decMultiplyOp() argument
4893 if (decCheckOperands(res, lhs, rhs, set)) return res; in decMultiplyOp()
4897 bits=(uByte)((lhs->bits^rhs->bits)&DECNEG); in decMultiplyOp()
4902 decNaNs(res, lhs, rhs, set, status); in decMultiplyOp()
4906 ||((rhs->bits & DECINF)==0 && ISZERO(rhs))) { in decMultiplyOp()
4917 if (lhs->digits<rhs->digits) { /* swap... */ in decMultiplyOp()
4919 lhs=rhs; in decMultiplyOp()
4920 rhs=hold; in decMultiplyOp()
4932 if (rhs->digits>set->digits) { in decMultiplyOp()
4933 allocrhs=decRoundOperand(rhs, set, status); in decMultiplyOp()
4935 rhs=allocrhs; in decMultiplyOp()
4945 if (rhs->digits>NEEDTWO) { /* use fastpath... */ in decMultiplyOp()
4948 irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; /* .. */ 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()
5084 mermsup=rhs->lsu+D2U(rhs->digits); /* -> msu+1 of multiplier */ in decMultiplyOp()
5086 for (mer=rhs->lsu; mer<mermsup; mer++) { in decMultiplyOp()
5119 exponent=lhs->exponent+rhs->exponent; /* calculate exponent */ in decMultiplyOp()
5120 if (lhs->exponent<0 && rhs->exponent<0 && exponent>0) in decMultiplyOp()
5221 decNumber * decExpOp(decNumber *res, const decNumber *rhs, in decExpOp() argument
5228 const decNumber *x=rhs; /* (may point to safe copy later) */ in decExpOp()
5258 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decExpOp()
5263 if (decNumberIsInfinite(rhs)) { /* an infinity */ in decExpOp()
5264 if (decNumberIsNegative(rhs)) /* -Infinity -> +0 */ in decExpOp()
5266 else decNumberCopy(res, rhs); /* +Infinity -> self */ in decExpOp()
5268 else decNaNs(res, rhs, NULL, set, status); /* a NaN */ in decExpOp()
5271 if (ISZERO(rhs)) { /* zeros -> exact 1 */ in decExpOp()
5293 if (decNumberIsNegative(rhs)) d->exponent--; /* negative case */ in decExpOp()
5294 comp=decCompare(d, rhs, 1); /* signless compare */ in decExpOp()
5317 h=rhs->exponent+rhs->digits; in decExpOp()
5329 if (decNumberIsNegative(rhs)) a->exponent=-2; /* make 0.02 */ 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()
5353 if (rhs->exponent!=use) { in decExpOp()
5355 needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit); in decExpOp()
5363 decNumberCopy(newrhs, rhs); /* copy to safe space */ in decExpOp()
5581 decNumber * decLnOp(decNumber *res, const decNumber *rhs, argument
5606 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5611 if (decNumberIsInfinite(rhs)) { /* an infinity */
5612 if (decNumberIsNegative(rhs)) /* -Infinity -> error */
5614 else decNumberCopy(res, rhs); /* +Infinity -> self */
5616 else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5619 if (ISZERO(rhs)) { /* +/- zeros -> -Infinity */
5625 if (decNumberIsNegative(rhs)) { /* -x -> error */
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 */
5701 decCopyFit(b, rhs, &aset, &residue, &ignore); /* copy & shorten */
5733 bset.digits=pp+rhs->digits; /* wider context */
5748 decMultiplyOp(b, b, rhs, &bset, &ignore); /* b=b*rhs */
5763 decCompareOp(&cmp, rhs, &numone, &aset, COMPARE, &ignore); /* rhs=1 ? */
5779 bset.digits=pp+rhs->digits; /* wider context */
5786 (LI)iterations, (LI)*status, (LI)p, (LI)rhs->digits);
5826 const decNumber *rhs, decContext *set, argument
5832 const decNumber *inrhs=rhs; /* save original rhs */
5839 if (decCheckOperands(res, lhs, rhs, set)) return res;
5851 if (rhs->digits>reqdigits) { /* [this only checks lostDigits] */
5852 allocrhs=decRoundOperand(rhs, set, status);
5854 rhs=allocrhs;
5864 decNaNs(res, lhs, rhs, set, status);
5866 else if ((lhs->bits ^ rhs->bits) & DECINF)
5999 const decNumber *rhs, decContext *set, argument
6009 if (decCheckOperands(res, lhs, rhs, set)) return res;
6021 if (rhs->digits>set->digits) {
6022 allocrhs=decRoundOperand(rhs, set, status);
6024 rhs=allocrhs;
6032 if (decNumberIsNegative(lhs) && !decNumberIsNegative(rhs)) {
6036 if (!decNumberIsNegative(lhs) && decNumberIsNegative(rhs)) {
6044 merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN);
6053 else if (!decNumberIsNaN(rhs)) result=+1;
6055 else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1;
6056 else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1;
6060 rhs->lsu, D2U(rhs->digits), 0);
6070 if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) {
6079 decNaNs(res, lhs, rhs, set, status); /* propagate NaN */
6083 if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1);
6084 else result=decCompare(lhs, rhs, 0); /* sign matters */
6093 if (lhs->exponent!=rhs->exponent) {
6094 if (lhs->exponent<rhs->exponent) result=-1;
6113 uByte srhs=(rhs->bits & DECNEG);
6126 if (lhs->exponent<rhs->exponent) result=+1;
6131 if (lhs->exponent>rhs->exponent) result=+1;
6138 choice=(result>0 ? lhs : rhs); /* choose */
6163 static Int decCompare(const decNumber *lhs, const decNumber *rhs, argument
6172 if (ISZERO(rhs)) return result; /* LHS wins or both 0 */
6180 if (ISZERO(rhs)) sigr=0;
6181 else if (decNumberIsNegative(rhs)) sigr=-1;
6188 if ((lhs->bits | rhs->bits) & DECINF) { /* one or more infinities */
6189 if (decNumberIsInfinite(rhs)) {
6196 if (lhs->exponent>rhs->exponent) { /* LHS exponent larger */
6199 lhs=rhs;
6200 rhs=temp;
6204 rhs->lsu, D2U(rhs->digits),
6205 rhs->exponent-lhs->exponent);
7508 static uInt decCheckMath(const decNumber *rhs, decContext *set, argument
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))
7517 && !ISZERO(rhs)) *status|=DEC_Invalid_operation;
7685 const decNumber *rhs, decContext *set, argument
7691 else if (rhs==NULL);
7692 else if (rhs->bits & DECSNAN) {
7693 lhs=rhs;
7697 else lhs=rhs;
7905 const decNumber *rhs, decContext *set) { argument
7930 if (!bad && rhs!=DECUNUSED) bad=(decCheckNumber(rhs));