use crate::Vec1;
impl Vec1<f64> {
#[inline]
pub fn min_max_normalize(&self) -> Vec1<f64> {
if self.is_empty() {
return Vec1::new();
}
let mut min_v = self[1];
let mut max_v = self[1];
for i in 2..=self.len() {
if self[i] < min_v {
min_v = self[i];
}
if self[i] > max_v {
max_v = self[i];
}
}
let range = max_v - min_v;
let mut out = Vec1::with_capacity(self.len());
if range == 0.0 {
for _ in 1..=self.len() {
out.push(0.5);
}
return out;
}
for i in 1..=self.len() {
out.push((self[i] - min_v) / range);
}
out
}
#[inline]
pub fn z_score_normalize(&self) -> Vec1<f64> {
if self.len() < 2 {
let mut out = Vec1::with_capacity(self.len());
for _ in 1..=self.len() {
out.push(0.0);
}
return out;
}
let mean = self.mean();
let sd = self.std_dev();
let mut out = Vec1::with_capacity(self.len());
if sd == 0.0 {
for _ in 1..=self.len() {
out.push(0.0);
}
return out;
}
for i in 1..=self.len() {
out.push((self[i] - mean) / sd);
}
out
}
#[inline]
pub fn l2_normalize(&self) -> Vec1<f64> {
let norm: f64 = libm::sqrt(self.iter().map(|&x| x * x).sum::<f64>());
let mut out = Vec1::with_capacity(self.len());
if norm == 0.0 {
for _ in 1..=self.len() {
out.push(0.0);
}
return out;
}
for i in 1..=self.len() {
out.push(self[i] / norm);
}
out
}
}
#[cfg(test)]
mod tests {
use crate::vec1;
#[test]
fn min_max_basic() {
let v = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
assert_eq!(v.min_max_normalize().as_slice(), &[0.0, 0.25, 0.5, 0.75, 1.0]);
}
#[test]
fn min_max_constant() {
let v = vec1![3.0, 3.0, 3.0];
assert_eq!(v.min_max_normalize().as_slice(), &[0.5, 0.5, 0.5]);
}
#[test]
fn z_score_basic() {
let v = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
let z = v.z_score_normalize();
assert!((z[1] - (-core::f64::consts::SQRT_2)).abs() < 1e-6);
assert!((z[5] - core::f64::consts::SQRT_2).abs() < 1e-6);
}
#[test]
fn l2_normalize_basic() {
let v = vec1![3.0, 4.0];
let n = v.l2_normalize();
assert!((n[1] - 0.6).abs() < 1e-10);
assert!((n[2] - 0.8).abs() < 1e-10);
}
}