Function standardize_log_form_vec

src/shared/processing/mod.rs:89–135

(vec: &[f64])

}

pub fn standardize_log_form_vec(vec: &[f64]) -> Vec<f64> {
    // Filter out non-finite values for statistics calculation
    let finite_values: Vec<f64> = vec.iter().filter(|x| x.is_finite()).copied().collect();

    let n = finite_values.len() as f64;
    if n <= 1.0 {
        // If we have too few finite values, return zeros
        println!(
            "DEBUG: Too few finite values ({}) for standardization, returning zeros",
            n
        );
        return vec![0.0; vec.len()];
    }

    let mu: f64 = finite_values.iter().sum::<f64>() / n;
    let sigma = (finite_values.iter().map(|x| (x - mu).powi(2)).sum::<f64>() / (n - 1.0)).sqrt();

    // Debug the standardization process
    let finite_count = vec.iter().filter(|x| x.is_finite()).count();
    let nan_count = vec.iter().filter(|x| x.is_nan()).count();
    let inf_count = vec.iter().filter(|x| x.is_infinite()).count();
    println!(
        "DEBUG Standardization: n={}, mu={:.6}, sigma={:.6}, finite={}, nan={}, inf={}",
        vec.len(),
        mu,
        sigma,
        finite_count,
        nan_count,
        inf_count
    );

    if !sigma.is_finite() || sigma == 0.0 {
        println!("DEBUG: Sigma is problematic, returning zeros");
        return vec![0.0; vec.len()];
    }

    // Standardize all values, but only finite ones get proper standardization
    vec.iter()
        .map(|&x| {
            if x.is_finite() {
                standardize_log(x, mu, sigma)
            } else {
                0.0 // Non-finite values get zero standardized score
            }
        })
        .collect()
}

#[allow(dead_code)]
fn normalize_per_bin(