catalogue/distributions

/// The first `count` arguments as numbers.
fn nums<const N: usize>(site: &Site<'_>, a: &[CalcValue]) -> Step<[f64; N]> {
    let mut found = [0.0; N];
    for (index, slot) in found.iter_mut().enumerate() {
        *slot = num(site, a, index)?;
    }
    Ok(found)
}

/// Argument `index`'s numbers by the aggregate rule.
fn sample(site: &Site<'_>, a: &[CalcValue], index: usize, sv: &mut EvalServices<'_>) -> Step<Vec<f64>> {
    numbers(site, a, index, index + 1, sv, Held::Numbers)
}

/// The tests' tails or type argument: a number, truncated.
fn whole(site: &Site<'_>, a: &[CalcValue], index: usize) -> Step<i32> {
    let n = num(site, a, index)?;
    if !n.is_finite() {
        return fail(WorksheetErrorCode::Num);
    }
    Ok(n.trunc() as i32)
}

fn chisq_test_of(site: &Site<'_>, a: &[CalcValue], sv: &mut EvalServices<'_>) -> Step<CalcValue> {
    // An argument that is an error value is the result before the shapes are compared (Excel
    // 16.0.20430, 2026-10-25, dc-6au: `=CHISQ.TEST(#REF!,1)`, `=CHISQ.TEST(1,#REF!)` and
    // `=CHISQ.TEST(A1:A2,#REF!)` are #REF!, `=CHISQ.TEST(#DIV/0!,A1:A2)` #DIV/0!).
    for argument in &a[..2] {
        if let CoreRef::Error(code) = argument.core_ref() {
            return fail(code);
        }
    }
    let actual = grid(site, a, 0, sv)?;
    let expected = grid(site, a, 1, sv)?;
    if (actual.rows, actual.cols) != (expected.rows, expected.cols) {
        return fail(WorksheetErrorCode::NA);
    }
    let df = if actual.rows > 1 && actual.cols > 1 {
        (actual.rows - 1) * (actual.cols - 1)
    } else if actual.rows == 1 {
        actual.cols - 1
    } else {
        actual.rows - 1
    };
    if df == 0 {
        return fail(WorksheetErrorCode::NA);
    }
    let mut statistic = 0.0;
    for (x, e) in actual.cells.iter().zip(&expected.cells) {
        let (x, e) = match (x.core_ref(), e.core_ref()) {
            (CoreRef::Error(code), _) | (_, CoreRef::Error(code)) => return fail(code),
            (CoreRef::Number(x), CoreRef::Number(e)) => (x, e),
            _ => return fail(WorksheetErrorCode::Value),
        };
        if e <= 0.0 {
            return fail(WorksheetErrorCode::Num);
        }
        let delta = x - e;
        statistic += delta * delta / e;
    }
    out(site, cft::chisq_dist_rt_kernel(statistic, df as f64))
}

fn t_test_of(site: &Site<'_>, a: &[CalcValue], sv: &mut EvalServices<'_>) -> Step<CalcValue> {
    let tails = whole(site, a, 2)?;
    let kind = whole(site, a, 3)?;
    let result = match kind {
        1 => {
            let pairs = super::kit::pairs(site, a, 0, 1, super::kit::PairScalars::Coerce, sv)?;
            st::t_test_paired_kernel(&pairs, tails)
        }
        2 | 3 => {
            let x = sample(site, a, 0, sv)?;
            let y = sample(site, a, 1, sv)?;
            if kind == 2 {
                st::t_test_equal_variance_kernel(&x, &y, tails)
            } else {
                st::t_test_unequal_variance_kernel(&x, &y, tails)
            }
        }
        _ => Err(WorksheetErrorCode::Num),
    };
    out(site, result)
}

fn z_test_of(site: &Site<'_>, a: &[CalcValue], sv: &mut EvalServices<'_>) -> Step<CalcValue> {
    let values = sample(site, a, 0, sv)?;
    let x = num(site, a, 1)?;
    let sigma = if given(a, 2) { Some(num(site, a, 2)?) } else { None };
    out(site, ct::z_test_kernel(&values, x, sigma))
}