use crate::error::{BarracudaError, Result};
pub fn pearson_correlation(x: &[f64], y: &[f64]) -> Result<f64> {
if x.len() != y.len() {
return Err(BarracudaError::InvalidInput {
message: format!("Vectors must have same length: {} vs {}", x.len(), y.len()),
});
}
if x.len() < 2 {
return Err(BarracudaError::InvalidInput {
message: "Need at least 2 data points for correlation".to_string(),
});
}
let n = x.len() as f64;
let mean_x: f64 = x.iter().sum::<f64>() / n;
let mean_y: f64 = y.iter().sum::<f64>() / n;
let mut cov = 0.0;
let mut var_x = 0.0;
let mut var_y = 0.0;
for (&xi, &yi) in x.iter().zip(y) {
let dx = xi - mean_x;
let dy = yi - mean_y;
cov = dx.mul_add(dy, cov);
var_x = dx.mul_add(dx, var_x);
var_y = dy.mul_add(dy, var_y);
}
let denom = (var_x * var_y).sqrt();
if denom == 0.0 {
return Ok(f64::NAN);
}
Ok(cov / denom)
}
pub fn covariance(x: &[f64], y: &[f64]) -> Result<f64> {
if x.len() != y.len() {
return Err(BarracudaError::InvalidInput {
message: format!("Vectors must have same length: {} vs {}", x.len(), y.len()),
});
}
if x.len() < 2 {
return Err(BarracudaError::InvalidInput {
message: "Need at least 2 data points for covariance".to_string(),
});
}
let n = x.len() as f64;
let mean_x: f64 = x.iter().sum::<f64>() / n;
let mean_y: f64 = y.iter().sum::<f64>() / n;
let cov: f64 = x
.iter()
.zip(y.iter())
.map(|(&xi, &yi)| (xi - mean_x) * (yi - mean_y))
.sum();
Ok(cov / (n - 1.0))
}
pub fn variance(x: &[f64]) -> Result<f64> {
if x.len() < 2 {
return Err(BarracudaError::InvalidInput {
message: "Need at least 2 data points for variance".to_string(),
});
}
let n = x.len() as f64;
let mean: f64 = x.iter().sum::<f64>() / n;
let var: f64 = x.iter().map(|&xi| (xi - mean).powi(2)).sum();
Ok(var / (n - 1.0))
}
pub fn std_dev(x: &[f64]) -> Result<f64> {
Ok(variance(x)?.sqrt())
}
pub fn correlation_matrix(data: &[Vec<f64>]) -> Result<Vec<f64>> {
if data.is_empty() {
return Err(BarracudaError::InvalidInput {
message: "Data matrix is empty".to_string(),
});
}
let n = data.len();
if n < 2 {
return Err(BarracudaError::InvalidInput {
message: "Need at least 2 observations".to_string(),
});
}
let p = data[0].len();
if p == 0 {
return Err(BarracudaError::InvalidInput {
message: "Data has no variables".to_string(),
});
}
for (i, row) in data.iter().enumerate() {
if row.len() != p {
return Err(BarracudaError::InvalidInput {
message: format!("Row {} has {} elements, expected {}", i, row.len(), p),
});
}
}
let columns: Vec<Vec<f64>> = (0..p)
.map(|j| data.iter().map(|row| row[j]).collect())
.collect();
let mut corr = vec![0.0; p * p];
for i in 0..p {
corr[i * p + i] = 1.0; for j in (i + 1)..p {
let r = pearson_correlation(&columns[i], &columns[j])?;
corr[i * p + j] = r;
corr[j * p + i] = r; }
}
Ok(corr)
}
pub fn covariance_matrix(data: &[Vec<f64>]) -> Result<Vec<f64>> {
if data.is_empty() {
return Err(BarracudaError::InvalidInput {
message: "Data matrix is empty".to_string(),
});
}
let n = data.len();
if n < 2 {
return Err(BarracudaError::InvalidInput {
message: "Need at least 2 observations".to_string(),
});
}
let p = data[0].len();
if p == 0 {
return Err(BarracudaError::InvalidInput {
message: "Data has no variables".to_string(),
});
}
for (i, row) in data.iter().enumerate() {
if row.len() != p {
return Err(BarracudaError::InvalidInput {
message: format!("Row {} has {} elements, expected {}", i, row.len(), p),
});
}
}
let columns: Vec<Vec<f64>> = (0..p)
.map(|j| data.iter().map(|row| row[j]).collect())
.collect();
let mut cov_mat = vec![0.0; p * p];
for i in 0..p {
for j in i..p {
let c = covariance(&columns[i], &columns[j])?;
cov_mat[i * p + j] = c;
cov_mat[j * p + i] = c; }
}
Ok(cov_mat)
}
pub fn spearman_correlation(x: &[f64], y: &[f64]) -> Result<f64> {
if x.len() != y.len() {
return Err(BarracudaError::InvalidInput {
message: format!("Vectors must have same length: {} vs {}", x.len(), y.len()),
});
}
if x.len() < 2 {
return Err(BarracudaError::InvalidInput {
message: "Need at least 2 data points".to_string(),
});
}
let rank_x = compute_ranks(x);
let rank_y = compute_ranks(y);
pearson_correlation(&rank_x, &rank_y)
}
fn compute_ranks(x: &[f64]) -> Vec<f64> {
let n = x.len();
let mut indexed: Vec<(usize, f64)> = x.iter().copied().enumerate().collect();
indexed.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
let mut ranks = vec![0.0; n];
let mut i = 0;
while i < n {
let mut j = i;
while j < n - 1 && indexed[j].1 == indexed[j + 1].1 {
j += 1;
}
let avg_rank = (i + j) as f64 / 2.0 + 1.0;
for k in i..=j {
ranks[indexed[k].0] = avg_rank;
}
i = j + 1;
}
ranks
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_pearson_perfect_positive() {
let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let y = vec![2.0, 4.0, 6.0, 8.0, 10.0];
let r = pearson_correlation(&x, &y).unwrap();
assert!((r - 1.0).abs() < 1e-10);
}
#[test]
fn test_pearson_perfect_negative() {
let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let y = vec![10.0, 8.0, 6.0, 4.0, 2.0];
let r = pearson_correlation(&x, &y).unwrap();
assert!((r + 1.0).abs() < 1e-10);
}
#[test]
fn test_pearson_zero() {
let x = vec![1.0, -1.0, 1.0, -1.0];
let y = vec![1.0, 1.0, -1.0, -1.0];
let r = pearson_correlation(&x, &y).unwrap();
assert!(r.abs() < 1e-10);
}
#[test]
fn test_pearson_length_mismatch() {
let x = vec![1.0, 2.0, 3.0];
let y = vec![1.0, 2.0];
assert!(pearson_correlation(&x, &y).is_err());
}
#[test]
fn test_covariance_perfect() {
let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let y = vec![2.0, 4.0, 6.0, 8.0, 10.0]; let cov = covariance(&x, &y).unwrap();
assert!((cov - 5.0).abs() < 1e-10);
}
#[test]
fn test_variance() {
let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let v = variance(&x).unwrap();
assert!((v - 2.5).abs() < 1e-10);
}
#[test]
fn test_correlation_matrix() {
let data = vec![
vec![1.0, 2.0],
vec![2.0, 4.0],
vec![3.0, 6.0],
vec![4.0, 8.0],
vec![5.0, 10.0],
];
let corr = correlation_matrix(&data).unwrap();
assert_eq!(corr.len(), 4);
assert!((corr[0] - 1.0).abs() < 1e-10); assert!((corr[1] - 1.0).abs() < 1e-10); assert!((corr[2] - 1.0).abs() < 1e-10); assert!((corr[3] - 1.0).abs() < 1e-10); }
#[test]
fn test_covariance_matrix() {
let data = vec![
vec![1.0, 2.0],
vec![2.0, 4.0],
vec![3.0, 6.0],
vec![4.0, 8.0],
vec![5.0, 10.0],
];
let cov = covariance_matrix(&data).unwrap();
assert!((cov[0] - 2.5).abs() < 1e-10); assert!((cov[1] - 5.0).abs() < 1e-10); assert!((cov[2] - 5.0).abs() < 1e-10); assert!((cov[3] - 10.0).abs() < 1e-10); }
#[test]
fn test_spearman_monotonic() {
let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let y = vec![1.0, 4.0, 9.0, 16.0, 25.0]; let r = spearman_correlation(&x, &y).unwrap();
assert!((r - 1.0).abs() < 1e-10);
}
#[test]
fn test_spearman_with_ties() {
let x = vec![1.0, 2.0, 2.0, 4.0];
let y = vec![1.0, 3.0, 2.0, 4.0];
let r = spearman_correlation(&x, &y).unwrap();
assert!(r > 0.5);
}
#[test]
fn test_compute_ranks() {
let x = vec![3.0, 1.0, 2.0];
let ranks = compute_ranks(&x);
assert!((ranks[0] - 3.0).abs() < 1e-10); assert!((ranks[1] - 1.0).abs() < 1e-10); assert!((ranks[2] - 2.0).abs() < 1e-10); }
#[test]
fn test_compute_ranks_with_ties() {
let x = vec![1.0, 2.0, 2.0, 4.0];
let ranks = compute_ranks(&x);
assert!((ranks[0] - 1.0).abs() < 1e-10);
assert!((ranks[1] - 2.5).abs() < 1e-10); assert!((ranks[2] - 2.5).abs() < 1e-10);
assert!((ranks[3] - 4.0).abs() < 1e-10);
}
}