Method Round

round.go:62–111

Round sets d to rounded x.

(c *Context, d, x *Decimal, disableIfPrecisionZero bool)

// Round sets d to rounded x.
func (r Rounder) Round(c *Context, d, x *Decimal, disableIfPrecisionZero bool) Condition {
	d.Set(x)
	nd := x.NumDigits()
	xs := x.Sign()
	var res Condition

	if disableIfPrecisionZero && c.Precision == 0 {
		// Rounding has been disabled.
		return d.setExponent(c, nd, res, int64(d.Exponent))
	}

	// adj is the adjusted exponent: exponent + clength - 1
	if adj := int64(x.Exponent) + nd - 1; xs != 0 && adj < int64(c.MinExponent) {
		// Subnormal is defined before rounding.
		res |= Subnormal
		// setExponent here to prevent double-rounded subnormals.
		res |= d.setExponent(c, nd, res, int64(d.Exponent))
		return res
	}

	diff := nd - int64(c.Precision)
	if diff > 0 {
		if diff > MaxExponent {
			return SystemOverflow | Overflow
		}
		if diff < MinExponent {
			return SystemUnderflow | Underflow
		}
		res |= Rounded
		var y, m BigInt
		e := tableExp10(diff, &y)
		y.QuoRem(&d.Coeff, e, &m)
		if m.Sign() != 0 {
			res |= Inexact
			var discard Decimal
			discard.Coeff.Set(&m)
			discard.Exponent = int32(-diff)
			if r.ShouldAddOne(&y, x.Negative, discard.Cmp(decimalHalf)) {
				roundAddOne(&y, &diff)
			}
		}
		d.Coeff.Set(&y)
		// The coefficient changed, so recompute num digits in setExponent.
		nd = unknownNumDigits
	} else {
		diff = 0
	}
	res |= d.setExponent(c, nd, res, int64(d.Exponent), diff)
	return res
}

// roundAddOne adds 1 to abs(b).
func roundAddOne(b *BigInt, diff *int64) {