Lines Matching full:residue
146 /* residue (in the range -1 through 9). This avoids any double- */
527 Int residue; /* rounding residue */
719 residue=0;
720 decSetCoeff(dn, set, res, d, &residue, &status);
722 decFinalize(dn, set, &residue, &status);
728 residue=0;
729 decFinalize(dn, set, &residue, &status);
1463 Int residue=0; /* (no residue) */
1468 decCopyFit(w, rhs, &aset, &residue, ©stat); /* copy & shorten */
1476 residue=0;
1477 decCopyFit(res, w, set, &residue, &status); /* copy & round */
1478 decFinish(res, set, &residue, &status); /* cleanup/set flags */
1989 Int residue=0; /* rounding residue */
2262 decFinalize(dac, set, &residue, &status);
2277 decCopyFit(res, dac, set, &residue, &status);
2278 decFinish(res, set, &residue, &status); /* final cleanup */
2346 Int residue=0; /* as usual */
2373 decCopyFit(res, rhs, set, &residue, &status); /* copy & round */
2374 decFinish(res, set, &residue, &status); /* cleanup/set flags */
2643 Int residue; /* work */
2666 residue=0;
2667 decFinalize(res, set, &residue, &status); /* .. and check */
2835 Int residue=0; /* rounding residue */
2901 decFinish(res, set, &residue, &status);
3021 residue=0; /* .. and accumulator */
3022 decCopyFit(a, a, &approxset, &residue, &rstatus); /* reduce (if needed) */
3023 decFinish(a, &approxset, &residue, &rstatus); /* clean and finalize */
3842 Int residue; /* rounding accumulator */
3904 residue=0; /* clear accumulator */
3905 decCopyFit(res, rhs, set, &residue, status); /* copy (as needed) */
3933 decFinish(res, set, &residue, status); /* clean and finalize */
3940 residue=0; /* clear accumulator */
3941 decCopyFit(res, lhs, set, &residue, status); /* copy (as needed) */
3959 decFinish(res, set, &residue, status); /* clean and finalize */
4008 /* affected by the residue). */
4028 /* more then lhs cannot affect the answer, except as a residue, */
4032 /* for residue use the relative sign indication... */
4034 residue=1; /* residue for rounding */
4035 if (diffsign) residue=-residue; /* signs differ */
4037 decCopyFit(res, rhs, set, &residue, status);
4045 decFinish(res, set, &residue, status); /* done */
4107 /* fit, so can't need rounding and residue must be 0.) */
4108 residue=0; /* clear accumulator */
4117 decSetCoeff(res, set, acc, res->digits, &residue, status);
4139 decSetCoeff(res, set, acc, res->digits, &residue, status);
4142 if (residue!=0) {
4143 decApplyRound(res, set, residue, status);
4144 residue=0; /* did what needed to be done */
4154 decFinish(res, set, &residue, status);
4212 /* Do until (have=digits+1 OR residue=0) */
4213 /* if exp<0 then if integer divide/residue then leave */
4279 Int residue; /* for rounding */
4335 residue=0;
4338 decCopyFit(res, lhs, set, &residue, status);
4350 decFinish(res, set, &residue, status);
4378 residue=0;
4383 decFinalize(res, set, &residue, status); /* check exponent */
4422 residue=0;
4423 decCopyFit(res, lhs, set, &residue, status);
4424 decFinish(res, set, &residue, status);
4509 /* do this now than to reassemble the residue afterwards, if */
4563 /* would increase digit by one, and the residue will be 0 so */
4564 /* the calculation is done; leave the loop with residue=0. */
4616 /* if the residue is zero, the operation is done (unless divide */
4618 if (*var1==0 && var1units==1) { /* residue is 0 */
4636 /* var1 has any residue at the stopping point */
4646 residue=0; /* assume no residue */
4648 /* record the presence of any residue, for rounding */
4649 if (*var1!=0 || var1units>1) residue=1;
4650 else { /* no residue */
4696 /* Fastpath when residue is truly 0 is worthwhile [and */
4698 if (*var1==0 && var1units==1) { /* residue is 0 */
4707 decFinish(res, set, &residue, status); /* might clamp */
4715 /* treat the residue, in var1, as the value to return, via acc */
4812 decSetCoeff(res, set, accnext, accdigits, &residue, status);
4814 decFinish(res, set, &residue, status); /* final cleanup */
4873 Int residue=0; /* rounding residue */
5151 /* it, noting if any residue */
5166 /* Set the coefficient. If any rounding, residue records */
5167 decSetCoeff(res, set, acc, res->digits, &residue, status);
5168 decFinish(res, set, &residue, status); /* final cleanup */
5267 Int residue; /* rounding residue */
5520 residue=1; /* indicate dirt to right .. */
5521 if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */
5523 decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5524 decFinish(res, set, &residue, status); /* cleanup/set flags */
5630 Int residue; /* rounding residue */
5744 residue=0; /* (no residue) */
5746 decCopyFit(b, rhs, &aset, &residue, &ignore); /* copy & shorten */
5835 residue=1; /* indicate dirt to right */
5836 if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */
5838 decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5839 decFinish(res, set, &residue, status); /* cleanup/set flags */
5883 Int residue=0; /* rounding residue */
5964 decCopyFit(res, lhs, &workset, &residue, status); /* fit to result */
5965 decApplyRound(res, &workset, residue, status); /* .. and round */
5966 residue=0; /* [used] */
6004 decFinalize(res, set, &residue, status); /* set subnormal flags */
6155 Int residue=0; /* rounding accumulator */
6188 decCopyFit(res, choice, set, &residue, status);
6189 decFinish(res, set, &residue, status);
6853 Int residue=0; /* rounding accumulator */
6863 decCopyFit(res, dn, set, &residue, &newstatus);
6864 decApplyRound(res, set, residue, &newstatus);
6879 /* residue is the residue accumulator */
6886 decContext *set, Int *residue, uInt *status) {
6889 decSetCoeff(dest, set, src->lsu, src->digits, residue, status);
6900 /* residue is the residue accumulator. This has values as in */
6903 /* coefficient is truncated and the residue is updated to */
6904 /* reflect the previous residue and the dropped digits. */
6925 /* incoming residue was non-0 (implies rounded) */
6927 /* mapping array: maps 0-9 to canonical residues, so that a residue */
6932 Int len, Int *residue, uInt *status) {
6952 /* dn->exponent and residue are unchanged, record any inexactitude */
6953 if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded);
6960 if (*residue>1) *residue=1; /* previous residue now to right, so reduce */
6964 /* residue is all the number [NB could be all 0s] */
6965 if (*residue<=0) { /* not already positive */
6968 *residue=1;
6972 if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
6981 /* spin up the number, noting residue during the spin, until get to */
6988 if (*up!=0) *residue=1;
6995 /* set residue directly */
6997 if (*up>half) *residue=7;
6998 else *residue+=5; /* add sticky bit */
7001 if (*up!=0) *residue=3; /* [else is 0, leave as sticky bit] */
7030 if (rem!=0) *residue=1;
7042 /* here, discard1 is the guard digit, and residue is everything */
7043 /* else [use mapping array to accumulate residue safely] */
7044 *residue+=resmap[discard1];
7077 if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
7086 /* residue indicates pending rounding, being any accumulated */
7113 static void decApplyRound(decNumber *dn, decContext *set, Int residue,
7118 if (residue==0) return; /* nothing to apply */
7126 /* positive residue and the lsd of dn is 0 or 5, in which case */
7127 /* it is bumped; when residue is <0, the number is therefore */
7131 if (residue<0 && lsd5!=1) bump=-1;
7132 else if (residue>0 && lsd5==0) bump=1;
7137 /* no change, except if negative residue */
7138 if (residue<0) bump=-1;
7142 if (residue>5) bump=1;
7146 if (residue>5) bump=1; /* >0.5 goes up */
7147 else if (residue==5) { /* exactly 0.5000... */
7154 if (residue>=5) bump=1;
7158 if (residue>0) bump=1;
7163 /* [negative residue cannot occur on 0] */
7165 if (residue<0) bump=-1;
7168 if (residue>0) bump=1;
7174 /* [negative residue cannot occur on 0] */
7176 if (residue<0) bump=-1;
7179 if (residue>0) bump=1;
7271 /* residue is the rounding accumulator (as in decApplyRound) */
7282 static void decFinish(decNumber *dn, decContext *set, Int *residue,
7299 decFinalize(dn, set, residue, status);
7308 /* residue is the rounding accumulator (as in decApplyRound) */
7317 static void decFinalize(decNumber *dn, decContext *set, Int *residue,
7331 /* A very nasty case here is dn == Nmin and residue<0 */
7334 decSetSubnormal(dn, set, residue, status);
7337 /* Equals case: only subnormal if dn=Nmin and negative residue */
7346 if (*residue<0 && comp==0) { /* neg residue and dn==Nmin */
7347 decApplyRound(dn, set, *residue, status); /* might force down */
7348 decSetSubnormal(dn, set, residue, status);
7354 if (*residue!=0) decApplyRound(dn, set, *residue, status);
7460 /* residue is any pending residue */
7471 static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue,
7491 /* residue can never be non-zero here */
7493 if (*residue!=0) {
7494 printf("++ Subnormal 0 residue %ld\n", (LI)*residue);
7508 /* residue can never be non-zero here, except in the Nmin-residue */
7521 decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status);
7522 decApplyRound(dn, &workset, *residue, status);
