YIELD

2 yield_fn "YIELD" (6, 7) [V "settlement", V "maturity", V "rate", V "pr", V "redemption", V "frequency", V "basis"] |s, a, sv| {
    let settlement = yield_date(s, a, 0, sv)?;
    let maturity = yield_date(s, a, 1, sv)?;
    let (rate, price, redemption) = (required_num(s, a, 2)?, required_num(s, a, 3)?, required_num(s, a, 4)?);
    // Fn8 adjacent-error controls read basis before frequency in YIELD.
    let basis = if given(a, 6) { num_without_logical(s, a, 6)? } else { 0.0 };
    let frequency = required_num(s, a, 5)?;
    bond_out(s, bond::yield_kernel(settlement, maturity, rate, price, redemption, frequency, Some(basis)))
}

fn pcomp(
    rate: f64,
    yld: f64,
    red: f64,
    c: Ctx,
    p: Period,
) -> Result<(f64, f64, f64, f64, f64), BondCoreEvalError> {
    // `binexp = false` keeps the legacy `powf` discount path. Callers that need Excel's
    // C-runtime integer-`pow` staging (PRICE) pass `true`; YIELD's solver and DURATION keep
    // `false` until their own identifications land (the forward fix is coupled to the YIELD
    // schedule — see the workset notes).
    pcomp_disc(rate, yld, red, c, p, false)
}

fn solve(
    target: f64,
    f: i64,
    fun: impl Fn(f64) -> Result<f64, BondCoreEvalError>,
) -> Result<f64, BondCoreEvalError> {
    let low = -(f as f64) + 1e-10;
    // Price → +∞ as yield → -frequency, but the price kernel can overflow/reject
    // that near-degenerate endpoint. Treat an un-evaluable low-yield endpoint as
    // an effectively infinite price so the "is the target achievable" guard does
    // not spuriously fail a well-posed bond (BUG-FUNC-031). The bisection below
    // moves off `low` on its first step, so it never re-probes the endpoint.
    let lowp = fun(low).unwrap_or(f64::INFINITY);
    if target > lowp {
        return Err(derr(WorksheetErrorCode::Num));
    }
    let mut hi = 1.0;
    let mut hip = fun(hi)?;
    let mut g = 0;
    while hip > target && g < 80 {
        hi *= 2.0;
        hip = fun(hi)?;
        g += 1;
    }
    if hip > target {
        return Err(derr(WorksheetErrorCode::Num));
    }
    // Bisection to adjacent binary64 bounds (full convergence, dc-ifc: Excel's YIELD converges
    // past the former 1e-15 price tolerance), then the bound with the smaller residual.
    let mut lo = low;
    let mut hh = hi;
    for _ in 0..2200 {
        let mid = (lo + hh) / 2.0;
        if mid <= lo || mid >= hh {
            break;
        }
        let mp = fun(mid)?;
        if mp == target {
            return Ok(mid);
        }
        if mp > target { lo = mid } else { hh = mid }
    }
    let (lo_res, hi_res) = (fun(lo).map(|v| (v - target).abs()), fun(hh).map(|v| (v - target).abs()));
    Ok(match (lo_res, hi_res) {
        (Ok(a), Ok(b)) if a < b => lo,
        (Ok(_), Err(_)) => lo,
        _ => hh,
    })
}

pub fn yield_kernel(
    settlement: f64,
    maturity: f64,
    rate_: f64,
    price: f64,
    red: f64,
    frequency: f64,
    basis_: Option<f64>,
) -> Result<f64, BondCoreEvalError> {
    let c = ctx(settlement, maturity, frequency, basis_)?;
    let p = period(c)?;
    let rate_ = rate(rate_)?;
    let price = pos(price)?;
    let red = pos(red)?;
    // On a coupon date, a multi-period bond priced and redeemed at its 100 face value
    // has yield equal to its coupon rate. At y=rate, the geometric coupon
    // sum 100*c*sum((1+c)^-k) plus redemption 100*(1+c)^-n is 100.
    // Return that exact algebraic root before the iterative price inversion.
    // Preserve the existing coupon-overflow route. The build 20228 bank has
    // both short and long par observations; wider Excel coverage stays open.
    if p.n > 1 && c.settlement == p.prev && price == 100.0 && red == 100.0
        && (100.0 * rate_ / c.frequency as f64).is_finite()
    {
        return Ok(rate_);
    }
    if p.n == 1 {
        let coup = 100.0 * rate_ / c.frequency as f64;
        let e = dc(p.prev, p.next, c.basis, c.frequency)?;
        let a = dd(p.prev, c.settlement, c.basis)?;
        let dsc = dd(c.settlement, p.next, c.basis)?;
        return Ok((((red + coup) / (price + coup * a / e)) - 1.0) * c.frequency as f64 * e / dsc);
    }
    // Solve over candidate yields with `pcomp` directly. `price_kernel` rejects
    // `yld < 0` via `rate(yld)`, but the root-finder must probe negative candidate
    // yields (its bracket runs down to `-frequency`); `pcomp`'s own guards
    // (`yld <= -frequency`, `base <= 0`) keep the domain correct (BUG-FUNC-031).
    solve(price, c.frequency, |cand| {
        Ok(pcomp(rate_, cand, red, c, p)?.0)
    })
}