Lines Matching refs:set
373 Int decNumberToInt32(const decNumber *dn, decContext *set) { in decNumberToInt32() argument
375 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; in decNumberToInt32()
405 decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */ in decNumberToInt32()
409 uInt decNumberToUInt32(const decNumber *dn, decContext *set) { in decNumberToUInt32() argument
411 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; in decNumberToUInt32()
434 decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */ in decNumberToUInt32()
514 int64_t decNumberIntegralToInt64(const decNumber *dn, decContext *set) in decNumberIntegralToInt64() argument
542 decContextSetStatus(set, DEC_Invalid_operation); in decNumberIntegralToInt64()
558 void decNumberIntegralToInt128(const decNumber *dn, decContext *set, in decNumberIntegralToInt128() argument
606 decContextSetStatus(set, DEC_Invalid_operation); in decNumberIntegralToInt128()
654 decContext *set) { in decNumberFromString() argument
674 if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set)) in decNumberFromString()
707 if (!set->extended) break; /* hopeless */ in decNumberFromString()
744 if (d>set->digits-1) { in decNumberFromString()
747 if (set->clamp) break; in decNumberFromString()
748 if (d>set->digits) break; in decNumberFromString()
801 if (*cfirst=='0' && !set->extended) { in decNumberFromString()
815 if (d<=set->digits) res=dn->lsu; /* fits into supplied decNumber */ in decNumberFromString()
861 if (d>set->digits) { in decNumberFromString()
863 decSetCoeff(dn, set, res, d, &residue, &status); in decNumberFromString()
865 decFinalize(dn, set, &residue, &status); in decNumberFromString()
869 if ((dn->exponent-1<set->emin-dn->digits) in decNumberFromString()
870 || (dn->exponent-1>set->emax-set->digits)) { in decNumberFromString()
872 decFinalize(dn, set, &residue, &status); in decNumberFromString()
879 if (status!=0) decStatus(dn, status, set); in decNumberFromString()
903 decContext *set) { in decNumberAbs() argument
908 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberAbs()
913 decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status); in decNumberAbs()
914 if (status!=0) decStatus(res, status, set); in decNumberAbs()
916 decCheckInexact(res, set); in decNumberAbs()
935 const decNumber *rhs, decContext *set) { in decNumberAdd() argument
937 decAddOp(res, lhs, rhs, set, 0, &status); in decNumberAdd()
938 if (status!=0) decStatus(res, status, set); in decNumberAdd()
940 decCheckInexact(res, set); in decNumberAdd()
961 const decNumber *rhs, decContext *set) { in decNumberAnd() argument
967 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberAnd()
972 decStatus(res, DEC_Invalid_operation, set); in decNumberAnd()
982 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ in decNumberAnd()
983 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ in decNumberAnd()
1002 decStatus(res, DEC_Invalid_operation, set); in decNumberAnd()
1029 const decNumber *rhs, decContext *set) { in decNumberCompare() argument
1031 decCompareOp(res, lhs, rhs, set, COMPARE, &status); in decNumberCompare()
1032 if (status!=0) decStatus(res, status, set); in decNumberCompare()
1049 const decNumber *rhs, decContext *set) { in decNumberCompareSignal() argument
1051 decCompareOp(res, lhs, rhs, set, COMPSIG, &status); in decNumberCompareSignal()
1052 if (status!=0) decStatus(res, status, set); in decNumberCompareSignal()
1070 const decNumber *rhs, decContext *set) { in decNumberCompareTotal() argument
1072 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status); in decNumberCompareTotal()
1073 if (status!=0) decStatus(res, status, set); in decNumberCompareTotal()
1091 const decNumber *rhs, decContext *set) { in decNumberCompareTotalMag() argument
1101 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberCompareTotalMag()
1134 decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status); in decNumberCompareTotalMag()
1139 if (status!=0) decStatus(res, status, set); in decNumberCompareTotalMag()
1156 const decNumber *rhs, decContext *set) { in decNumberDivide() argument
1158 decDivideOp(res, lhs, rhs, set, DIVIDE, &status); in decNumberDivide()
1159 if (status!=0) decStatus(res, status, set); in decNumberDivide()
1161 decCheckInexact(res, set); in decNumberDivide()
1179 const decNumber *rhs, decContext *set) { in decNumberDivideInteger() argument
1181 decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status); in decNumberDivideInteger()
1182 if (status!=0) decStatus(res, status, set); in decNumberDivideInteger()
1212 decContext *set) { in decNumberExp() argument
1219 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberExp()
1226 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */ in decNumberExp()
1228 if (!set->extended) { in decNumberExp()
1230 if (rhs->digits>set->digits) { in decNumberExp()
1231 allocrhs=decRoundOperand(rhs, set, &status); in decNumberExp()
1237 decExpOp(res, rhs, set, &status); in decNumberExp()
1244 if (status!=0) decStatus(res, status, set); in decNumberExp()
1246 decCheckInexact(res, set); in decNumberExp()
1269 decContext *set) { in decNumberFMA() argument
1279 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberFMA()
1280 if (decCheckOperands(res, fhs, DECUNUSED, set)) return res; in decNumberFMA()
1285 if (!set->extended) { /* [undefined if subset] */ in decNumberFMA()
1290 if ((!decNumberIsSpecial(lhs) && decCheckMath(lhs, set, &status)) in decNumberFMA()
1291 || (!decNumberIsSpecial(rhs) && decCheckMath(rhs, set, &status)) in decNumberFMA()
1292 || (!decNumberIsSpecial(fhs) && decCheckMath(fhs, set, &status))) break; in decNumberFMA()
1294 dcmul=*set; in decNumberFMA()
1333 decAddOp(res, acc, fhs, set, 0, &status); in decNumberFMA()
1337 if (status!=0) decStatus(res, status, set); in decNumberFMA()
1339 decCheckInexact(res, set); in decNumberFMA()
1359 decContext *set) { in decNumberInvert() argument
1364 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberInvert()
1368 decStatus(res, DEC_Invalid_operation, set); in decNumberInvert()
1375 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ in decNumberInvert()
1376 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ in decNumberInvert()
1390 decStatus(res, DEC_Invalid_operation, set); in decNumberInvert()
1432 decContext *set) { in decNumberLn() argument
1439 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberLn()
1444 if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */ in decNumberLn()
1446 if (!set->extended) { in decNumberLn()
1448 if (rhs->digits>set->digits) { in decNumberLn()
1449 allocrhs=decRoundOperand(rhs, set, &status); in decNumberLn()
1459 decLnOp(res, rhs, set, &status); in decNumberLn()
1466 if (status!=0) decStatus(res, status, set); in decNumberLn()
1468 decCheckInexact(res, set); in decNumberLn()
1498 decContext *set) { in decNumberLogB() argument
1502 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberLogB()
1506 if (decNumberIsNaN(rhs)) decNaNs(res, rhs, NULL, set, &status); in decNumberLogB()
1518 if (status!=0) decStatus(res, status, set); in decNumberLogB()
1554 decContext *set) { in decNumberLog10() argument
1577 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberLog10()
1582 if (!decCheckMath(rhs, set, &status)) do { /* protect malloc */ in decNumberLog10()
1584 if (!set->extended) { in decNumberLog10()
1586 if (rhs->digits>set->digits) { in decNumberLog10()
1587 allocrhs=decRoundOperand(rhs, set, &status); in decNumberLog10()
1616 decCopyFit(res, w, set, &residue, &status); /* copy & round */ in decNumberLog10()
1617 decFinish(res, set, &residue, &status); /* cleanup/set flags */ in decNumberLog10()
1629 p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3; in decNumberLog10()
1652 p=set->digits+3; in decNumberLog10()
1672 aset.digits=set->digits; /* for final divide */ in decNumberLog10()
1682 if (status!=0) decStatus(res, status, set); in decNumberLog10()
1684 decCheckInexact(res, set); in decNumberLog10()
1702 const decNumber *rhs, decContext *set) { in decNumberMax() argument
1704 decCompareOp(res, lhs, rhs, set, COMPMAX, &status); in decNumberMax()
1705 if (status!=0) decStatus(res, status, set); in decNumberMax()
1707 decCheckInexact(res, set); in decNumberMax()
1725 const decNumber *rhs, decContext *set) { in decNumberMaxMag() argument
1727 decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status); in decNumberMaxMag()
1728 if (status!=0) decStatus(res, status, set); in decNumberMaxMag()
1730 decCheckInexact(res, set); in decNumberMaxMag()
1748 const decNumber *rhs, decContext *set) { in decNumberMin() argument
1750 decCompareOp(res, lhs, rhs, set, COMPMIN, &status); in decNumberMin()
1751 if (status!=0) decStatus(res, status, set); in decNumberMin()
1753 decCheckInexact(res, set); in decNumberMin()
1771 const decNumber *rhs, decContext *set) { in decNumberMinMag() argument
1773 decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status); in decNumberMinMag()
1774 if (status!=0) decStatus(res, status, set); in decNumberMinMag()
1776 decCheckInexact(res, set); in decNumberMinMag()
1796 decContext *set) { in decNumberMinus() argument
1801 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberMinus()
1806 decAddOp(res, &dzero, rhs, set, DECNEG, &status); in decNumberMinus()
1807 if (status!=0) decStatus(res, status, set); in decNumberMinus()
1809 decCheckInexact(res, set); in decNumberMinus()
1826 decContext *set) { in decNumberNextMinus() argument
1828 decContext workset=*set; /* work */ in decNumberNextMinus()
1831 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberNextMinus()
1836 decSetMaxValue(res, set); /* is +ve */ in decNumberNextMinus()
1846 if (status!=0) decStatus(res, status, set); in decNumberNextMinus()
1862 decContext *set) { in decNumberNextPlus() argument
1864 decContext workset=*set; /* work */ in decNumberNextPlus()
1867 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberNextPlus()
1872 decSetMaxValue(res, set); in decNumberNextPlus()
1883 if (status!=0) decStatus(res, status, set); in decNumberNextPlus()
1901 const decNumber *rhs, decContext *set) { in decNumberNextToward() argument
1903 decContext workset=*set; /* work */ in decNumberNextToward()
1907 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberNextToward()
1911 decNaNs(res, lhs, rhs, set, &status); in decNumberNextToward()
1923 decSetMaxValue(res, set); in decNumberNextToward()
1933 decSetMaxValue(res, set); in decNumberNextToward()
1945 if (decNumberIsNormal(res, set)) status=0; in decNumberNextToward()
1949 if (status!=0) decStatus(res, status, set); in decNumberNextToward()
1969 const decNumber *rhs, decContext *set) { in decNumberOr() argument
1975 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberOr()
1980 decStatus(res, DEC_Invalid_operation, set); in decNumberOr()
1989 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ in decNumberOr()
1990 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ in decNumberOr()
2008 decStatus(res, DEC_Invalid_operation, set); in decNumberOr()
2039 decContext *set) { in decNumberPlus() argument
2043 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberPlus()
2048 decAddOp(res, &dzero, rhs, set, 0, &status); in decNumberPlus()
2049 if (status!=0) decStatus(res, status, set); in decNumberPlus()
2051 decCheckInexact(res, set); in decNumberPlus()
2069 const decNumber *rhs, decContext *set) { in decNumberMultiply() argument
2071 decMultiplyOp(res, lhs, rhs, set, &status); in decNumberMultiply()
2072 if (status!=0) decStatus(res, status, set); in decNumberMultiply()
2074 decCheckInexact(res, set); in decNumberMultiply()
2106 const decNumber *rhs, decContext *set) { in decNumberPower() argument
2113 Int reqdigits=set->digits; /* requested DIGITS */ in decNumberPower()
2136 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberPower()
2141 if (!set->extended) { /* reduce operands and set status, as needed */ in decNumberPower()
2143 alloclhs=decRoundOperand(lhs, set, &status); in decNumberPower()
2148 allocrhs=decRoundOperand(rhs, set, &status); in decNumberPower()
2159 decNaNs(res, lhs, rhs, set, &status); in decNumberPower()
2169 decNumberCompare(dac, lhs, &dnOne, set); /* lhs ? 1 */ in decNumberPower()
2176 Int shift=set->digits-1; in decNumberPower()
2222 if (!set->extended) { /* [unless subset] */ in decNumberPower()
2233 if (!set->extended) { /* [bad if subset] */ in decNumberPower()
2253 if (decCheckMath(lhs, set, &status) in decNumberPower()
2254 || decCheckMath(rhs, set, &status)) break; /* variable status */ in decNumberPower()
2271 aset.digits=MAXI(lhs->digits, set->digits)+6+4; in decNumberPower()
2283 aset=*set; /* clone the context */ in decNumberPower()
2288 if (!set->extended) aset.digits--; /* use classic precision */ in decNumberPower()
2317 Int shift=set->digits-1; in decNumberPower()
2340 if (set->extended) { /* need to calculate 1/lhs */ in decNumberPower()
2385 if (!set->extended && decNumberIsNegative(rhs)) { in decNumberPower()
2397 decFinalize(dac, set, &residue, &status); in decNumberPower()
2403 if (!set->extended && /* subset math */ in decNumberPower()
2412 decCopyFit(res, dac, set, &residue, &status); in decNumberPower()
2413 decFinish(res, set, &residue, &status); /* final cleanup */ in decNumberPower()
2415 if (!set->extended) decTrim(res, set, 0, &dropped); /* trailing zeros */ in decNumberPower()
2425 if (status!=0) decStatus(res, status, set); in decNumberPower()
2427 decCheckInexact(res, set); in decNumberPower()
2451 const decNumber *rhs, decContext *set) { in decNumberQuantize() argument
2453 decQuantizeOp(res, lhs, rhs, set, 1, &status); in decNumberQuantize()
2454 if (status!=0) decStatus(res, status, set); in decNumberQuantize()
2471 decContext *set) { in decNumberNormalize() argument
2472 return decNumberReduce(res, rhs, set); in decNumberNormalize()
2476 decContext *set) { in decNumberReduce() argument
2485 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberReduce()
2490 if (!set->extended) { in decNumberReduce()
2492 if (rhs->digits>set->digits) { in decNumberReduce()
2493 allocrhs=decRoundOperand(rhs, set, &status); in decNumberReduce()
2503 decNaNs(res, rhs, NULL, set, &status); in decNumberReduce()
2508 decCopyFit(res, rhs, set, &residue, &status); /* copy & round */ in decNumberReduce()
2509 decFinish(res, set, &residue, &status); /* cleanup/set flags */ in decNumberReduce()
2510 decTrim(res, set, 1, &dropped); /* normalize in place */ in decNumberReduce()
2516 if (status!=0) decStatus(res, status, set);/* then report status */ in decNumberReduce()
2539 const decNumber *rhs, decContext *set) { in decNumberRescale() argument
2541 decQuantizeOp(res, lhs, rhs, set, 0, &status); in decNumberRescale()
2542 if (status!=0) decStatus(res, status, set); in decNumberRescale()
2559 const decNumber *rhs, decContext *set) { in decNumberRemainder() argument
2561 decDivideOp(res, lhs, rhs, set, REMAINDER, &status); in decNumberRemainder()
2562 if (status!=0) decStatus(res, status, set); in decNumberRemainder()
2564 decCheckInexact(res, set); in decNumberRemainder()
2582 const decNumber *rhs, decContext *set) { in decNumberRemainderNear() argument
2584 decDivideOp(res, lhs, rhs, set, REMNEAR, &status); in decNumberRemainderNear()
2585 if (status!=0) decStatus(res, status, set); in decNumberRemainderNear()
2587 decCheckInexact(res, set); in decNumberRemainderNear()
2618 const decNumber *rhs, decContext *set) { in decNumberRotate() argument
2623 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberRotate()
2628 decNaNs(res, lhs, rhs, set, &status); in decNumberRotate()
2636 || abs(rotate)>set->digits) /* .. or out of range */ in decNumberRotate()
2641 if (rotate<0) rotate=set->digits+rotate; in decNumberRotate()
2642 if (rotate!=0 && rotate!=set->digits /* zero or full rotation */ in decNumberRotate()
2648 Unit *msumax=res->lsu+D2U(set->digits)-1; /* rotation msu */ in decNumberRotate()
2650 res->digits=set->digits; /* now full-length */ in decNumberRotate()
2684 rotate=set->digits-rotate; /* make it right-rotate */ in decNumberRotate()
2725 if (status!=0) decStatus(res, status, set); in decNumberRotate()
2774 const decNumber *rhs, decContext *set) { in decNumberScaleB() argument
2780 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberScaleB()
2785 decNaNs(res, lhs, rhs, set, &status); in decNumberScaleB()
2794 || abs(reqexp)>(2*(set->digits+set->emax))) /* .. or out of range */ in decNumberScaleB()
2801 decFinalize(res, set, &residue, &status); /* .. and check */ in decNumberScaleB()
2805 if (status!=0) decStatus(res, status, set); in decNumberScaleB()
2831 const decNumber *rhs, decContext *set) { in decNumberShift() argument
2836 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberShift()
2841 decNaNs(res, lhs, rhs, set, &status); in decNumberShift()
2849 || abs(shift)>set->digits) /* .. or out of range */ in decNumberShift()
2855 if (shift==set->digits) { /* removing all */ in decNumberShift()
2861 if (res->digits+shift>set->digits) { in decNumberShift()
2862 decDecap(res, res->digits+shift-set->digits); in decNumberShift()
2883 if (status!=0) decStatus(res, status, set); in decNumberShift()
2960 decContext *set) { in decNumberSquareRoot() argument
2993 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberSquareRoot()
2998 if (!set->extended) { in decNumberSquareRoot()
3000 if (rhs->digits>set->digits) { in decNumberSquareRoot()
3001 allocrhs=decRoundOperand(rhs, set, &status); in decNumberSquareRoot()
3017 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */ in decNumberSquareRoot()
3031 decFinish(res, set, &residue, &status); in decNumberSquareRoot()
3048 workp=MAXI(set->digits+1, rhs->digits); /* actual rounding precision */ in decNumberSquareRoot()
3145 approxset=*set; /* get emin, emax, etc. */ in decNumberSquareRoot()
3213 decTrim(b, set, 1, &dropped); /* [drops trailing zeros] */ in decNumberSquareRoot()
3219 if (b->digits*2-1 > workp && !set->clamp) { /* cannot fit */ in decNumberSquareRoot()
3257 if (ae>=set->emin*2) status&=~(DEC_Subnormal|DEC_Underflow); in decNumberSquareRoot()
3259 if (ae>=set->emin*2) status&=~DEC_Underflow; in decNumberSquareRoot()
3274 if (status!=0) decStatus(res, status, set);/* then report status */ in decNumberSquareRoot()
3276 decCheckInexact(res, set); in decNumberSquareRoot()
3294 const decNumber *rhs, decContext *set) { in decNumberSubtract() argument
3297 decAddOp(res, lhs, rhs, set, DECNEG, &status); in decNumberSubtract()
3298 if (status!=0) decStatus(res, status, set); in decNumberSubtract()
3300 decCheckInexact(res, set); in decNumberSubtract()
3327 decContext *set) { in decNumberToIntegralExact() argument
3333 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decNumberToIntegralExact()
3339 else decNaNs(res, rhs, NULL, set, &status); /* a NaN */ in decNumberToIntegralExact()
3345 workset=*set; /* clone rounding, etc. */ in decNumberToIntegralExact()
3352 if (status!=0) decStatus(res, status, set); in decNumberToIntegralExact()
3357 decContext *set) { in decNumberToIntegralValue() argument
3358 decContext workset=*set; /* working context */ in decNumberToIntegralValue()
3363 set->status|=workset.status&DEC_Invalid_operation; in decNumberToIntegralValue()
3383 const decNumber *rhs, decContext *set) { in decNumberXor() argument
3389 if (decCheckOperands(res, lhs, rhs, set)) return res; in decNumberXor()
3394 decStatus(res, DEC_Invalid_operation, set); in decNumberXor()
3403 msuc=uc+D2U(set->digits)-1; /* -> msu of result */ in decNumberXor()
3404 msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */ in decNumberXor()
3422 decStatus(res, DEC_Invalid_operation, set); in decNumberXor()
3447 enum decClass decNumberClass(const decNumber *dn, decContext *set) { in decNumberClass() argument
3456 if (decNumberIsNormal(dn, set)) { /* most common */ in decNumberClass()
3664 Int decNumberIsNormal(const decNumber *dn, decContext *set) { in decNumberIsNormal() argument
3667 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; in decNumberIsNormal()
3674 if (ae<set->emin) return 0; /* is subnormal */ in decNumberIsNormal()
3684 Int decNumberIsSubnormal(const decNumber *dn, decContext *set) { in decNumberIsSubnormal() argument
3687 if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0; in decNumberIsSubnormal()
3694 if (ae<set->emin) return 1; /* is subnormal */ in decNumberIsSubnormal()
3709 decContext set; /* .. */ in decNumberTrim() local
3713 decContextDefault(&set, DEC_INIT_BASE); /* clamp=0 */ in decNumberTrim()
3714 return decTrim(dn, &set, 0, &dropped); in decNumberTrim()
3951 const decNumber *rhs, decContext *set, in decAddOp() argument
3968 Int reqdigits=set->digits; /* local copy; requested DIGITS */ in decAddOp()
3972 if (decCheckOperands(res, lhs, rhs, set)) return res; in decAddOp()
3977 if (!set->extended) { in decAddOp()
3980 alloclhs=decRoundOperand(lhs, set, status); in decAddOp()
3985 allocrhs=decRoundOperand(rhs, set, status); in decAddOp()
3999 decNaNs(res, lhs, rhs, set, status); in decAddOp()
4023 decCopyFit(res, rhs, set, &residue, status); /* copy (as needed) */ in decAddOp()
4026 if (set->extended) { /* exponents on zeros count */ in decAddOp()
4034 if (set->round!=DEC_ROUND_FLOOR) res->bits=0; in decAddOp()
4040 if ((res->digits-adjust)>set->digits) { in decAddOp()
4041 adjust=res->digits-set->digits; /* to fit exactly */ in decAddOp()
4051 decFinish(res, set, &residue, status); /* clean and finalize */ in decAddOp()
4059 decCopyFit(res, lhs, set, &residue, status); /* copy (as needed) */ in decAddOp()
4061 if (set->extended) { /* exponents on zeros count */ in decAddOp()
4067 if ((res->digits-adjust)>set->digits) { in decAddOp()
4068 adjust=res->digits-set->digits; /* to fit exactly */ in decAddOp()
4077 decFinish(res, set, &residue, status); /* clean and finalize */ in decAddOp()
4091 && rhs->exponent>=set->emin /* [some normals drop through] */ in decAddOp()
4092 && rhs->exponent<=set->emax-set->digits+1 /* [could clamp] */ in decAddOp()
4155 decCopyFit(res, rhs, set, &residue, status); in decAddOp()
4163 decFinish(res, set, &residue, status); /* done */ in decAddOp()
4227 if (set->extended) { /* round from first significant digit */ in decAddOp()
4233 decSetCoeff(res, set, acc, res->digits, &residue, status); in decAddOp()
4255 decSetCoeff(res, set, acc, res->digits, &residue, status); in decAddOp()
4259 decApplyRound(res, set, residue, status); in decAddOp()
4270 decFinish(res, set, &residue, status); in decAddOp()
4278 && set->extended in decAddOp()
4281 if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG; /* sign - */ in decAddOp()
4366 decContext *set, Flag op, uInt *status) { in decDivideOp() argument
4396 Int reqdigits=set->digits; /* requested DIGITS */ in decDivideOp()
4409 if (decCheckOperands(res, lhs, rhs, set)) return res; in decDivideOp()
4414 if (!set->extended) { in decDivideOp()
4417 alloclhs=decRoundOperand(lhs, set, status); in decDivideOp()
4422 allocrhs=decRoundOperand(rhs, set, status); in decDivideOp()
4435 decNaNs(res, lhs, rhs, set, status); in decDivideOp()
4454 decCopyFit(res, lhs, set, &residue, status); in decDivideOp()
4462 res->exponent=set->emin-set->digits+1; in decDivideOp()
4466 decFinish(res, set, &residue, status); in decDivideOp()
4490 if (!set->extended) decNumberZero(res); in decDivideOp()
4499 decFinalize(res, set, &residue, status); /* check exponent */ in decDivideOp()
4528 if (set->extended) in decDivideOp()
4539 decCopyFit(res, lhs, set, &residue, status); in decDivideOp()
4540 decFinish(res, set, &residue, status); in decDivideOp()
4819 if (set->extended) in decDivideOp()
4823 decFinish(res, set, &residue, status); /* might clamp */ in decDivideOp()
4928 decSetCoeff(res, set, accnext, accdigits, &residue, status); in decDivideOp()
4930 decFinish(res, set, &residue, status); /* final cleanup */ in decDivideOp()
4934 if (!set->extended && (op==DIVIDE)) decTrim(res, set, 0, &dropped); in decDivideOp()
4985 const decNumber *rhs, decContext *set, in decMultiplyOp() argument
5046 if (decCheckOperands(res, lhs, rhs, set)) return res; in decMultiplyOp()
5055 decNaNs(res, lhs, rhs, set, status); in decMultiplyOp()
5078 if (!set->extended) { in decMultiplyOp()
5080 if (lhs->digits>set->digits) { in decMultiplyOp()
5081 alloclhs=decRoundOperand(lhs, set, status); in decMultiplyOp()
5085 if (rhs->digits>set->digits) { in decMultiplyOp()
5086 allocrhs=decRoundOperand(rhs, set, status); in decMultiplyOp()
5279 decSetCoeff(res, set, acc, res->digits, &residue, status); in decMultiplyOp()
5280 decFinish(res, set, &residue, status); /* final cleanup */ in decMultiplyOp()
5375 decContext *set, uInt *status) { in decExpOp() argument
5411 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; in decExpOp()
5421 else decNaNs(res, rhs, NULL, set, status); /* a NaN */ in decExpOp()
5445 d->exponent=-set->digits; /* * 10**(-d) */ in decExpOp()
5452 Int shift=set->digits-1; in decExpOp()
5464 aset.emax=set->emax; /* usual bounds */ in decExpOp()
5465 aset.emin=set->emin; /* .. */ in decExpOp()
5532 p=MAXI(x->digits, set->digits)+h+2; /* [h<=8] */ in decExpOp()
5634 aset.digits=set->digits; /* [use default rounding] */ in decExpOp()
5636 decFinish(res, set, &residue, status); /* cleanup/set flags */ in decExpOp()
5736 decContext *set, uInt *status) { argument
5760 if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5770 else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5786 if (rhs->exponent==0 && set->digits<=40) {
5792 aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5798 aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5810 p=MAXI(rhs->digits, MAXI(set->digits, 7))+2;
5873 aset.emax=set->emax;
5874 aset.emin=set->emin;
5914 (a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) {
5946 aset.digits=set->digits; /* [use default rounding] */
5948 decFinish(res, set, &residue, status); /* cleanup/set flags */
5980 const decNumber *rhs, decContext *set, argument
5987 Int reqdigits=set->digits; /* requested DIGITS */
5990 Int etiny=set->emin-(reqdigits-1);
5993 if (decCheckOperands(res, lhs, rhs, set)) return res;
5998 if (!set->extended) {
6001 alloclhs=decRoundOperand(lhs, set, status);
6006 allocrhs=decRoundOperand(rhs, set, status);
6018 decNaNs(res, lhs, rhs, set, status);
6037 if (!set->extended) etiny=set->emin; /* no subnormals */
6043 || (reqexp>set->emax)) { /* > emax */
6052 if (!set->extended) res->bits=0; /* subset specification; no -0 */
6067 workset=*set; /* clone rounding, etc. */
6087 if (ISZERO(res) && !set->extended) res->bits=0; /* subset; no -0 */
6105 if (res->exponent>set->emax-res->digits+1) { /* too big */
6110 decFinalize(res, set, &residue, status); /* set subnormal flags */
6153 const decNumber *rhs, decContext *set, argument
6163 if (decCheckOperands(res, lhs, rhs, set)) return res;
6168 if (!set->extended) {
6170 if (lhs->digits>set->digits) {
6171 alloclhs=decRoundOperand(lhs, set, status);
6175 if (rhs->digits>set->digits) {
6176 allocrhs=decRoundOperand(rhs, set, status);
6233 decNaNs(res, lhs, rhs, set, status); /* propagate NaN */
6269 if (!set->extended) { /* subset: force left-hand */
6294 decCopyFit(res, choice, set, &residue, status);
6295 decFinish(res, set, &residue, status);
6738 static decNumber * decTrim(decNumber *dn, decContext *set, Flag all, argument
6785 if (set->clamp) {
6786 Int maxd=set->emax-set->digits+1-dn->exponent;
6954 static decNumber *decRoundOperand(const decNumber *dn, decContext *set, argument
6963 +(D2U(set->digits)-1)*sizeof(Unit));
6968 decCopyFit(res, dn, set, &residue, &newstatus);
6969 decApplyRound(res, set, residue, &newstatus);
6991 decContext *set, Int *residue, uInt *status) { argument
6994 decSetCoeff(dest, set, src->lsu, src->digits, residue, status);
7036 static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu, argument
7047 discard=len-set->digits; /* digits to discard */
7108 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */
7113 count=set->digits; /* now digits to end up with */
7153 if (set->digits<=0) { /* special for Quantize/Subnormal :-( */
7158 count=set->digits; /* now digits to end up with */
7217 static void decApplyRound(decNumber *dn, decContext *set, Int residue, argument
7227 switch (set->round) {
7290 printf("Unknown rounding mode: %d\n", set->round);
7315 if ((dn->exponent+dn->digits)>set->emax+1) {
7316 decSetOverflow(dn, set, status);
7346 if (dn->exponent+1==set->emin-set->digits+1) {
7386 static void decFinish(decNumber *dn, decContext *set, Int *residue, argument
7388 if (!set->extended) {
7396 if (set->digits >= (dn->exponent+dn->digits)) {
7403 decFinalize(dn, set, residue, status);
7421 static void decFinalize(decNumber *dn, decContext *set, Int *residue, argument
7424 Int tinyexp=set->emin-dn->digits+1; /* precalculate subnormal boundary */
7438 decSetSubnormal(dn, set, residue, status);
7444 nmin.exponent=set->emin;
7451 decApplyRound(dn, set, *residue, status); /* might force down */
7452 decSetSubnormal(dn, set, residue, status);
7458 if (*residue!=0) decApplyRound(dn, set, *residue, status);
7461 if (dn->exponent<=set->emax-set->digits+1) return; /* neither needed */
7465 if (dn->exponent>set->emax-dn->digits+1) { /* too big */
7466 decSetOverflow(dn, set, status);
7470 if (!set->clamp) return;
7473 shift=dn->exponent-(set->emax-set->digits+1);
7495 static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) { argument
7500 Int emax=set->emax; /* limit value */
7501 if (set->clamp) emax-=set->digits-1; /* lower if clamping */
7510 switch (set->round) {
7526 decSetMaxValue(dn, set);
7541 static void decSetMaxValue(decNumber *dn, decContext *set) { argument
7543 Int count=set->digits; /* nines to add */
7555 dn->exponent=set->emax-set->digits+1;
7575 static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue, argument
7582 if (!set->extended) {
7592 etiny=set->emin-(set->digits-1); /* smallest allowed exponent */
7621 workset=*set; /* clone rounding, etc. */
7661 static uInt decCheckMath(const decNumber *rhs, decContext *set, argument
7664 if (set->digits>DEC_MAX_MATH
7665 || set->emax>DEC_MAX_MATH
7666 || -set->emin>DEC_MAX_MATH) *status|=DEC_Invalid_context;
7838 const decNumber *rhs, decContext *set, argument
7853 if (lhs->digits<=set->digits) decNumberCopy(res, lhs); /* easy */
7859 uresp1=res->lsu+D2U(set->digits);
7861 res->digits=D2U(set->digits)*DECDPUN;
7863 if (res->digits>set->digits) decDecap(res, res->digits-set->digits);
7888 static void decStatus(decNumber *dn, uInt status, decContext *set) { argument
7897 decContextSetStatus(set, status); /* [may not return] */
8090 const decNumber *rhs, decContext *set) { argument
8092 if (set==NULL) { /* oops; hopeless */
8098 else if (set!=DECUNCONT
8099 && (set->digits<1 || set->round>=DEC_ROUND_MAX)) {
8103 (LI)set->digits, (LI)set->round);
8118 if (set!=DECUNCONT) decContextSetStatus(set, DEC_Invalid_operation);
8236 static void decCheckInexact(const decNumber *dn, decContext *set) { argument
8238 if ((set->status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact
8239 && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) {
8245 decContextSetStatus(set, DEC_Invalid_operation);
8249 if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation;