Function addSat [src]

r = a + b with 2s-complement saturating semantics. r, a and b may be aliases. Assets the result fits in r. Upper bound on the number of limbs needed by r is calcTwosCompLimbCount(bit_count).

Prototype

pub fn addSat(r: *Mutable, a: Const, b: Const, signedness: Signedness, bit_count: usize) void

Parameters

r: *Mutablea: Constb: Constsignedness: Signednessbit_count: usize

Source

  pub fn addSat(r: *Mutable, a: Const, b: Const, signedness: Signedness, bit_count: usize) void {
    const req_limbs = calcTwosCompLimbCount(bit_count);

    // Slice of the upper bits if they exist, these will be ignored and allows us to use addCarry to determine
    // if an overflow occurred.
    const x = Const{
        .positive = a.positive,
        .limbs = a.limbs[0..@min(req_limbs, a.limbs.len)],
    };

    const y = Const{
        .positive = b.positive,
        .limbs = b.limbs[0..@min(req_limbs, b.limbs.len)],
    };

    if (r.addCarry(x, y)) {
        // There are two possibilities here:
        // - We overflowed req_limbs, in which case we need to saturate.
        // - a and b had less elements than req_limbs, and those were overflowed.
        //   Note: In this case, might _also_ need to saturate.
        const msl = @max(a.limbs.len, b.limbs.len);
        if (msl < req_limbs) {
            r.limbs[msl] = 1;
            r.len = req_limbs;
            // Note: Saturation may still be required if msl == req_limbs - 1
        } else {
            // Overflowed req_limbs, definitely saturate.
            r.setTwosCompIntLimit(if (r.positive) .max else .min, signedness, bit_count);
        }
    }

    // Saturate if the result didn't fit.
    r.saturate(r.toConst(), signedness, bit_count);
}  