use crate::backend_ops::BackendOps;
use crate::binary;
use coeus_core::{Float, FloatElement};
use coeus_tensor::Tensor;
#[inline]
fn axis_count(shape: &[usize], axis: usize) -> usize {
shape[axis]
}
#[inline]
pub fn var<T: Float + FloatElement, B: BackendOps<T> + Default>(
a: &Tensor<T, B>,
unbiased: bool,
backend: &B,
) -> Result<T, B::Error> {
Ok(var_mean(a, unbiased, backend)?.0)
}
#[inline]
pub fn var_mean<T: Float + FloatElement, B: BackendOps<T> + Default>(
a: &Tensor<T, B>,
unbiased: bool,
backend: &B,
) -> Result<(T, T), B::Error> {
let n = a.numel();
assert!(n > 0, "var_mean: empty tensor has no variance");
let mu = super::mean(a, backend)?;
let flattened = if a.is_contiguous() && a.layout().offset() == 0 {
a.reshape([n])
} else {
a.to_contiguous_on(backend).reshape([n])
};
let mu_full = Tensor::full_on([n], mu, backend);
let dev = binary::sub(&flattened, &mu_full, backend);
let sq = binary::mul(&dev, &dev, backend);
let s = super::sum(&sq, backend)?;
let denom = if unbiased && n > 1 { n - 1 } else { n };
Ok((s / T::from_count(denom), mu))
}
#[inline]
pub fn var_axis<T: Float + FloatElement, B: BackendOps<T> + Default>(
a: &Tensor<T, B>,
axis: usize,
unbiased: bool,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
Ok(var_mean_axis(a, axis, unbiased, backend)?.0)
}
#[inline]
pub fn std_dev<T: Float + FloatElement, B: BackendOps<T> + Default>(
a: &Tensor<T, B>,
unbiased: bool,
backend: &B,
) -> Result<T, B::Error> {
Ok(std_mean(a, unbiased, backend)?.0)
}
#[inline]
pub fn std_mean<T: Float + FloatElement, B: BackendOps<T> + Default>(
a: &Tensor<T, B>,
unbiased: bool,
backend: &B,
) -> Result<(T, T), B::Error> {
let (v, mu) = var_mean(a, unbiased, backend)?;
Ok((<T as Float>::sqrt(v), mu))
}
#[inline]
pub fn std_dev_axis<T: Float + FloatElement, B: BackendOps<T> + Default>(
a: &Tensor<T, B>,
axis: usize,
unbiased: bool,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
Ok(std_mean_axis(a, axis, unbiased, backend)?.0)
}
#[inline]
#[expect(
clippy::type_complexity,
reason = "The paired tensor return preserves the established variance/mean API."
)]
pub fn var_mean_axis<T: Float + FloatElement, B: BackendOps<T> + Default>(
a: &Tensor<T, B>,
axis: usize,
unbiased: bool,
backend: &B,
) -> Result<(Tensor<T, B>, Tensor<T, B>), B::Error> {
assert!(axis < a.ndim(), "var_mean_axis: axis {axis} out of bounds");
let n = axis_count(a.shape(), axis);
assert!(n > 0, "var_mean_axis: axis {axis} has zero elements");
let mu = super::mean_axis(a, axis, backend)?;
let dev = binary::sub(a, &mu, backend);
let sq = binary::mul(&dev, &dev, backend);
let s = super::sum_axis(&sq, axis, backend)?;
let denom = if unbiased && n > 1 { n - 1 } else { n };
let denom_full = Tensor::full_on(s.shape_cloned(), T::from_count(denom), backend);
let v = binary::div(&s, &denom_full, backend);
Ok((v, mu))
}
#[inline]
#[expect(
clippy::type_complexity,
reason = "The paired tensor return preserves the established standard-deviation/mean API."
)]
pub fn std_mean_axis<T: Float + FloatElement, B: BackendOps<T> + Default>(
a: &Tensor<T, B>,
axis: usize,
unbiased: bool,
backend: &B,
) -> Result<(Tensor<T, B>, Tensor<T, B>), B::Error> {
let (v, mu) = var_mean_axis(a, axis, unbiased, backend)?;
let std = crate::unary::sqrt(&v, backend);
Ok((std, mu))
}