Function _get_mean_bins

src/shared/processing/mod.rs:304–351

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

}

pub fn _get_mean_bins(
    log_means: &[f64],
    n_bins: usize,
) -> anyhow::Result<(Vec<usize>, Vec<usize>)> {
    // Use quantile-based binning instead of equal-width binning
    // This ensures each bin has roughly the same number of genes

    let mut sorted_means: Vec<(usize, f64)> = log_means
        .iter()
        .enumerate()
        .map(|(i, &mean)| (i, mean))
        .collect();

    // Sort by log_means values
    sorted_means.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));

    let n_genes = log_means.len();
    let genes_per_bin = n_genes / n_bins;
    let remainder = n_genes % n_bins;

    let mut bin_indices = vec![0; log_means.len()];
    let mut mean_bins = vec![0; n_bins];

    let mut current_gene_idx = 0;

    (0..n_bins).for_each(|bin_idx| {
        // Calculate how many genes should be in this bin
        // First 'remainder' bins get one extra gene
        let genes_in_this_bin = if bin_idx < remainder {
            genes_per_bin + 1
        } else {
            genes_per_bin
        };

        // Assign genes to this bin
        for _ in 0..genes_in_this_bin {
            if current_gene_idx < sorted_means.len() {
                let original_idx = sorted_means[current_gene_idx].0;
                bin_indices[original_idx] = bin_idx;
                current_gene_idx += 1;
            }
        }

        mean_bins[bin_idx] = genes_in_this_bin;
    });

    Ok((mean_bins, bin_indices))
}

pub fn _calculate_dispersion_stats(
    log_dispersions: &[f64],