Function normalize_per_bin

src/shared/processing/mod.rs:138–200

(
    log_means: &[f64],
    log_dispersions: &[f64],
    n_bins: usize,
)

#[allow(dead_code)]
fn normalize_per_bin(
    log_means: &[f64],
    log_dispersions: &[f64],
    n_bins: usize,
) -> anyhow::Result<Vec<f64>> {
    let min_mean = log_means.iter().fold(f64::INFINITY, |a, &b| a.min(b));
    let max_mean = log_means.iter().fold(f64::NEG_INFINITY, |a, &b| a.max(b));
    let bin_width = (max_mean - min_mean) / n_bins as f64;

    let mut norm_dispersions = vec![0.0; log_means.len()];
    let mut bin_counts = vec![0; n_bins];
    let mut bin_disp_means = vec![0.0; n_bins];
    let mut bin_disp_stds = vec![0.0; n_bins];

    for i in 0..log_means.len() {
        let bin_idx = if log_means[i] == max_mean {
            n_bins - 1
        } else {
            ((log_means[i] - min_mean) / bin_width) as usize
        };

        bin_counts[bin_idx] += 1;
        bin_disp_means[bin_idx] += log_dispersions[i];
    }

    for i in 0..n_bins {
        if bin_counts[i] > 0 {
            bin_disp_means[i] /= bin_counts[i] as f64;
        }
    }

    for i in 0..log_means.len() {
        let bin_idx = if log_means[i] == max_mean {
            n_bins - 1
        } else {
            ((log_means[i] - min_mean) / bin_width) as usize
        };
        if bin_counts[bin_idx] > 1 {
            bin_disp_stds[bin_idx] += (log_dispersions[i] - bin_disp_means[bin_idx]).powi(2);
        }
    }

    for i in 0..n_bins {
        if bin_counts[i] > 1 {
            bin_disp_stds[i] = (bin_disp_stds[i] / (bin_counts[i] - 1) as f64).sqrt();
        }
    }

    for i in 0..log_means.len() {
        let bin_idx = if log_means[i] == max_mean {
            n_bins - 1
        } else {
            ((log_means[i] - min_mean) / bin_width) as usize
        };

        if bin_disp_stds[bin_idx] > 0.0 {
            norm_dispersions[i] =
                (log_dispersions[i] - bin_disp_means[bin_idx]) / bin_disp_stds[bin_idx];