rusanta-core 0.1.0

Core infrastructure crate for the Rusanta scientific computing ecosystem. Provides shared traits, errors, utilities, and backend abstractions.
Documentation
use crate::error::{Result, RusantaError};
use crate::traits::dataset::Dataset;
use crate::traits::numeric::{Accumulate, Float, Numeric};

/// Computes the sum of a dataset.
pub fn sum<T, D>(data: &D) -> Result<<T as Accumulate>::Output>
where
T: Numeric + Accumulate,
D: Dataset<T>,
{
    if data.is_empty() {
        return Err(RusantaError::EmptyData {
            context: "sum",
        });
    }

    let mut acc = data.get(0)?.to_acc();
    for i in 1..data.len() {
        acc += data.get(i)?.to_acc();
    }
    Ok(acc)
}

/// Computes the mean of a dataset.
pub fn mean<T, D>(data: &D) -> Result<<T as Accumulate>::Output>
where
T: Numeric + Accumulate,
<T as Accumulate>::Output: Float,
D: Dataset<T>,
{
    let n = data.len();
    if n == 0 {
        return Err(RusantaError::EmptyData {
            context: "mean",
        });
    }

    let total = sum::<T, D>(data)?;
    let mut count = <T as Accumulate>::Output::zero();
    for _ in 0..n {
        count += <T as Accumulate>::Output::one();
    }

    Ok(total / count)
}

/// Computes the variance of a dataset.
pub fn variance<T, D>(data: &D) -> Result<<T as Accumulate>::Output>
where
T: Numeric + Accumulate,
<T as Accumulate>::Output: Float,
D: Dataset<T>,
{
    let n = data.len();
    if n < 2 {
        return Err(RusantaError::InvalidValue {
            message: "variance requires at least two elements".into(),
        });
    }

    let mean_val = mean::<T, D>(data)?;

    let mut acc = <<T as Accumulate>::Output as Float>::zero();
    for i in 0..n {
        let x = data.get(i)?.to_acc();
        let diff = x - mean_val;
        acc += diff * diff;
    }

    let mut count_minus_one = <<T as Accumulate>::Output as Float>::zero();
    for _ in 0..(n - 1) {
        count_minus_one += <<T as Accumulate>::Output as Float>::one();
    }

    Ok(acc / count_minus_one)
}

/// Computes the minimum value.
pub fn min<T, D>(data: &D) -> Result<T>
where
T: Numeric,
D: Dataset<T>,
{
    if data.is_empty() {
        return Err(RusantaError::EmptyData {
            context: "min",
        });
    }

    let mut m = data.get(0)?;
    for i in 1..data.len() {
        let v = data.get(i)?;
        if v < m {
            m = v;
        }
    }
    Ok(m)
}

/// Computes the maximum value.
pub fn max<T, D>(data: &D) -> Result<T>
where
T: Numeric,
D: Dataset<T>,
{
    if data.is_empty() {
        return Err(RusantaError::EmptyData {
            context: "max",
        });
    }

    let mut m = data.get(0)?;
    for i in 1..data.len() {
        let v = data.get(i)?;
        if v > m {
            m = v;
        }
    }
    Ok(m)
}