ODDFYIELD

24 oddfyield_fn "ODDFYIELD" (8, 9) [V "settlement", V "maturity", V "issue", V "first_coupon", V "rate", V "pr", V "redemption", V "frequency", V "basis"] |s, a, sv| {
    let dates = [yield_date(s, a, 0, sv)?, yield_date(s, a, 1, sv)?, yield_date(s, a, 2, sv)?, yield_date(s, a, 3, sv)?];
    let (rate, price, redemption, frequency) = (required_num(s, a, 4)?, required_num(s, a, 5)?, required_num(s, a, 6)?, required_num(s, a, 7)?);
    // ODDFYIELD keeps frequency before basis, unlike YIELD.
    let basis = if a.len() > 8 { Some(num_without_logical(s, a, 8)?) } else { None };
    odd_out(s, odd::oddfyield_kernel(dates[0], dates[1], dates[2], dates[3], rate, price, redemption, frequency, basis))
}

fn solve_yield_bisection(
    target_price: f64,
    price_at_yield: impl Fn(f64) -> Result<f64, OddBondEvalError>,
) -> Result<f64, OddBondEvalError> {
    if target_price <= 0.0 || !target_price.is_finite() {
        return Err(OddBondEvalError::Domain(WorksheetErrorCode::Num));
    }
    let low = 0.0;
    let price_low = price_at_yield(low)?;
    if target_price > price_low {
        return Err(OddBondEvalError::Domain(WorksheetErrorCode::Num));
    }
    let mut hi = 0.1;
    let mut price_hi = price_at_yield(hi)?;
    for _ in 0..32 {
        if price_hi <= target_price {
            break;
        }
        hi *= 2.0;
        price_hi = price_at_yield(hi)?;
    }
    if price_hi > target_price {
        return Err(OddBondEvalError::Domain(WorksheetErrorCode::Num));
    }

    // Bisection to adjacent binary64 bounds (full convergence, dc-ifc: Excel's ODDFYIELD
    // converges past the former 1e-12 price tolerance), then the bound with the smaller residual.
    let mut lo = low;
    let mut hi_mut = hi;
    for _ in 0..2200 {
        let mid = (lo + hi_mut) / 2.0;
        if mid <= lo || mid >= hi_mut {
            break;
        }
        let price_mid = price_at_yield(mid)?;
        if price_mid == target_price {
            return Ok(mid);
        }
        if price_mid > target_price {
            lo = mid;
        } else {
            hi_mut = mid;
        }
    }
    let residual = |y: f64| price_at_yield(y).map(|p| (p - target_price).abs());
    Ok(match (residual(lo), residual(hi_mut)) {
        (Ok(a), Ok(b)) if a < b => lo,
        (Ok(_), Err(_)) => lo,
        _ => hi_mut,
    })
}

pub fn oddfyield_kernel(
    settlement: f64,
    maturity: f64,
    issue: f64,
    first_coupon: f64,
    rate: f64,
    pr: f64,
    redemption: f64,
    frequency: f64,
    basis: Option<f64>,
) -> Result<f64, OddBondEvalError> {
    solve_yield_bisection(pr, |y| {
        oddfprice_kernel(
            settlement,
            maturity,
            issue,
            first_coupon,
            rate,
            y,
            redemption,
            frequency,
            basis,
        )
    })
}