Function _normalize_by_batch

src/shared/processing/mod.rs:202–250

(
    log_means: &[f64],
    log_dispersions: &[f64],
    batch_col: &polars::prelude::Column,
    n_bins: usize,
)

}

pub fn _normalize_by_batch(
    log_means: &[f64],
    log_dispersions: &[f64],
    batch_col: &polars::prelude::Column,
    n_bins: usize,
) -> anyhow::Result<Vec<f64>> {
    let mut unique_batches = Vec::new();
    if let DataType::String = batch_col.dtype() {
        unique_batches = batch_col.str()?.iter().flatten().collect::<Vec<&str>>();
    }

    let mut norm_dispersions = vec![0.0; log_means.len()];
    for batch in unique_batches {
        let batch_mask: Vec<bool> = batch_col
            .str()?
            .into_iter()
            .map(|x| x == Some(batch))
            .collect();

        let batch_size = batch_mask.iter().filter(|&&x| x).count();

        if batch_size > 0 {
            let batch_norm = normalize_per_bin(
                &log_means
                    .iter()
                    .zip(batch_mask.iter())
                    .filter(|(_, &mask)| mask)
                    .map(|(&x, _)| x)
                    .collect::<Vec<_>>(),
                &log_dispersions
                    .iter()
                    .zip(batch_mask.iter())
                    .filter(|(_, &mask)| mask)
                    .map(|(&x, _)| x)
                    .collect::<Vec<_>>(),
                n_bins,
            )?;

            let mut j = 0;
            for i in 0..log_means.len() {
                if batch_mask[i] {
                    norm_dispersions[i] = batch_norm[j];
                    j += 1;
                }
            }
        }
    }
    Ok(norm_dispersions)
}

pub fn fit_svr(x: &[f64], y: &[f64]) -> anyhow::Result<(Vec<f64>, Vec<f64>)> {
    let n = x.len();