use ndarray::{Array, Axis, Ix1, Ix2, ScalarOperand};
use ndarray_parallel::prelude::*;
use ndarray_rand::RandomExt;
use num_traits::{Float, FromPrimitive, NumAssign, ToPrimitive};
use rand::distributions::{Bernoulli, StandardNormal};
use crate::util::stats_util::{mean, standard_deviation};
pub fn generate_plus_minus_one_bernoulli_matrix(num_rows: usize, num_cols: usize) -> Array<f32, Ix2> {
Array::random((num_rows, num_cols), Bernoulli::new(0.5)).mapv(|e| (e as i32 * 2 - 1) as f32)
}
pub fn generate_standard_normal_matrix(num_rows: usize, num_cols: usize) -> Array<f32, Ix2> {
Array::random((num_rows, num_cols), StandardNormal).mapv(|e| e as f32)
}
pub fn normalize_matrix_row_wise_inplace<A>(mut matrix: Array<A, Ix2>, ddof: usize) -> Array<A, Ix2>
where A: ToPrimitive + FromPrimitive + NumAssign + Float + ScalarOperand {
let (_num_rows, num_cols) = matrix.dim();
let ones = Array::from_shape_vec((num_cols, 1), vec![A::one(); num_cols]).unwrap();
let mean_vec = matrix.dot(&ones) / A::from(num_cols).unwrap();
matrix -= &mean_vec;
let denominator = A::from(num_cols - ddof).unwrap();
for mut row in matrix.genrows_mut() {
let std = (A::from((&row * &row).sum()).unwrap() / denominator).sqrt();
if std > A::zero() {
row /= std;
}
};
matrix
}
pub fn normalize_matrix_columns_inplace<A>(matrix: &mut Array<A, Ix2>, ddof: usize)
where A: ToPrimitive + FromPrimitive + NumAssign + Float + ScalarOperand + Send + Sync {
let (num_rows, _num_cols) = matrix.dim();
let num_rows_denom = A::from(num_rows).unwrap();
let denominator = A::from(num_rows - ddof).unwrap();
let zero = A::zero();
matrix.axis_iter_mut(Axis(1))
.into_par_iter()
.for_each(|mut col| {
col -= col.sum() / num_rows_denom;
let std = ((&col * &col).sum() / denominator).sqrt();
if std > zero {
col /= std;
}
});
}
pub fn normalize_vector_inplace<A>(vec: &mut Array<A, Ix1>, ddof: usize)
where A: ToPrimitive + FromPrimitive + NumAssign + Float + ScalarOperand + Send + Sync {
*vec -= A::from(mean(vec.iter())).unwrap();
*vec /= A::from(standard_deviation(vec.iter(), ddof)).unwrap();
}
pub fn mean_center_vector<A>(vector: &mut Array<A, Ix1>)
where A: ToPrimitive + FromPrimitive + NumAssign + Float + ScalarOperand {
*vector -= A::from(mean(vector.iter())).unwrap();
}
pub fn row_mean_vec<A, T>(matrix: &Array<A, Ix2>) -> Array<T, Ix1>
where A: Copy + ToPrimitive + NumAssign, T: Float + FromPrimitive {
let mut mean_vec = Vec::new();
for row in matrix.genrows() {
mean_vec.push(T::from(mean(row.iter())).unwrap());
}
Array::from_vec(mean_vec)
}
pub fn row_std_vec<A, T>(matrix: &Array<A, Ix2>, ddof: usize) -> Array<T, Ix1>
where A: Copy + ToPrimitive + NumAssign, T: Float + FromPrimitive {
let mut std_vec = Vec::new();
for row in matrix.genrows() {
std_vec.push(T::from(standard_deviation(row.iter(), ddof)).unwrap());
}
Array::from_vec(std_vec)
}
pub fn get_correlation<A>(arr1: &Array<A, Ix1>, arr2: &Array<A, Ix1>) -> f64
where A: Copy + ToPrimitive + FromPrimitive + NumAssign + ScalarOperand {
let mut a = arr1.clone() - A::from_f64(mean(arr1.iter())).unwrap();
a /= A::from_f64(standard_deviation(arr1.iter(), 0)).unwrap();
let mut b = arr2.clone() - A::from_f64(mean(arr2.iter())).unwrap();
b /= A::from_f64(standard_deviation(arr2.iter(), 0)).unwrap();
a.dot(&b).to_f64().unwrap() / arr1.dim() as f64
}
#[cfg(test)]
mod tests {
use ndarray::Array;
use ndarray_rand::RandomExt;
use rand::distributions::Uniform;
use crate::util::stats_util::{mean, standard_deviation};
use super::{get_correlation, mean_center_vector, normalize_matrix_columns_inplace,
normalize_matrix_row_wise_inplace, normalize_vector_inplace};
#[test]
fn test_normalize_matrix_row_wise() {
let ddof = 1;
let (num_rows, num_cols) = (50, 100);
let mut matrix = Array::random((num_rows, num_cols), Uniform::new(-10f32, 50f32));
matrix = normalize_matrix_row_wise_inplace(matrix, ddof);
for row in matrix.genrows() {
assert!(mean(row.iter()).abs() < 1e-6);
assert!((standard_deviation(row.iter(), ddof) - 1.).abs() < 1e-6);
}
}
#[test]
fn test_normalize_matrix_columns() {
let ddof = 1;
let (num_rows, num_cols) = (50, 100);
let mut matrix = Array::random((num_rows, num_cols), Uniform::new(-10f32, 50f32));
normalize_matrix_columns_inplace(&mut matrix, ddof);
for col in matrix.gencolumns() {
assert!(mean(col.iter()).abs() < 1e-6);
assert!((standard_deviation(col.iter(), ddof) - 1.).abs() < 1e-6);
}
}
#[test]
fn test_normalize_vector_inplace() {
let num_elements = 1000;
let ddof = 0;
let mut vec = Array::random(num_elements, Uniform::new(-10f32, 50f32));
assert!(mean(vec.iter()).abs() > 1e-3, "the randomly generated vector should have a large non-zero mean");
assert!((standard_deviation(vec.iter(), ddof) - 1.).abs() > 2., "the randomly generated vector should have a large std");
normalize_vector_inplace(&mut vec, ddof);
assert!(mean(vec.iter()).abs() < 1e-6);
assert!((standard_deviation(vec.iter(), ddof) - 1.).abs() < 1e-6);
}
#[test]
fn test_mean_center_vector() {
let size = 100;
let mut vec = Array::random(size, Uniform::new(-10f32, 50f32));
assert!(mean(vec.iter()).abs() > 1e-3, "the randomly generated vector should have a large non-zero mean");
mean_center_vector(&mut vec);
assert!(mean(vec.iter()).abs() < 1e-6);
}
#[test]
fn test_get_correlation() {
let size = 500;
let v1 = Array::random(size, Uniform::new(-10f32, 50f32));
let v1_clone = v1.clone();
assert!((get_correlation(&v1, &v1_clone) - 1.).abs() < 1e-6);
}
}