RRI

13 rri_fn "RRI" (3, 3) [V "nper", V "pv", V "fv"] |s, a, sv| {
    tv_out(s, tv::rri(num(s, a, 0)?, num(s, a, 1)?, num(s, a, 2)?))
}

#[inline]
fn financial_daz(value: f64) -> f64 {
    if value.abs() < f64::MIN_POSITIVE {
        0.0_f64.copysign(value)
    } else {
        value
    }
}

pub fn rri(periods: f64, present_value: f64, future_value: f64) -> Result<f64, FinancialError> {
    validate_finite(&[periods, present_value, future_value])?;
    // W109's live edge-domain batteries pin the guard order as tightly as the
    // positive-domain power graph. Positive subnormal periods are rejected
    // before the equality shortcut, while MIN_POSITIVE is admitted.
    if periods < f64::MIN_POSITIVE {
        return Err(FinancialError::Num);
    }

    // This legacy financial body observes DAZ-normalized value inputs.
    // Equality precedes the sign guards, so equal zeros/subnormals (and even
    // equal negative normal values) publish +0.
    let present_value = financial_daz(present_value);
    let future_value = financial_daz(future_value);
    if present_value == future_value {
        return Ok(0.0);
    }
    // A present value of 0 and values of opposite signs are #NUM!; two negative values have a
    // positive ratio and are computed like positive ones (dc-ifc, Excel 16.0.20430 on 2026-10-27:
    // RRI(1,-1,-3) is 2, RRI(2,-4,-9) 0.5, RRI(2,-5,0) and RRI(2,5,0) -1, RRI(2,0,5),
    // RRI(2,-5,5) and RRI(2,5,-5) #NUM!).
    let opposite = (present_value < 0.0) != (future_value < 0.0) && future_value != 0.0;
    if present_value == 0.0 || opposite {
        return Err(FinancialError::Num);
    }

    // W109 G6-13 / BUG-FUNC-044: RRI is a legacy x87 spill body. Its wrapper
    // division, reciprocal, and final subtraction are each RN53(RN64(op)); the
    // power itself is the raw x87 chain
    // `exp(RN53(RN64((1/n) * ln(base))))`. Native `powf` misses the near-one
    // cancellation ladder by 2^27 output ULP, and `ln(base)/n` misses 97 of the
    // fresh 4,900 rows. This is NOT the worksheet POWER wrapper: RRI(2,1,2)
    // takes the raw chain and bypasses POWER's exponent-0.5 sqrt shortcut.
    // The published quotient is DAZ-normalized too. Its zero lane is exactly
    // -1 and must bypass the raw LN/EXP helper, whose contract requires a
    // finite positive base.
    let base = financial_daz(excel_x87_div(future_value, present_value));
    if base == 0.0 {
        return Ok(-1.0);
    }
    if !base.is_finite() {
        return Err(FinancialError::Num);
    }
    let reciprocal = excel_x87_recip(periods);
    if !reciprocal.is_finite() {
        return Err(FinancialError::Num);
    }

    // periods==1 is an exact identity route, not merely an exponent that
    // happens to equal one. Adjacent binary64 period values take the raw chain.
    let powered = if periods == 1.0 {
        base
    } else {
        excel_pow_chain(base, reciprocal)
    };
    let result = excel_x87_sub(powered, 1.0);
    if result.is_finite() {
        Ok(result)
    } else {
        Err(FinancialError::Num)
    }
}