magnus167/rustframe
1
0
Fork 0
mirror of https://github.com/Magnus167/rustframe.git synced 2025-08-20 04:19:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

moved tests out of tests directory

Browse Source
This commit is contained in:
Palash Tyagi 2025-04-20 01:46:57 +01:00
parent b6ce1c9076
commit 1d81f7e72f
6 changed files with 509 additions and 523 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
src/frame/base.rs
View File

@ -701,4 +701,51 @@ mod tests {
assert_eq!(frame_not["P"].to_vec(), &[false, true]);
assert_eq!(frame_not["Q"].to_vec(), &[true, false]);
}
#[test]
fn test_swap_columns() {
let mut frame = create_test_frame_i32();
let initial_a_data = frame.column("A").to_vec(); // [1, 2, 3]
let initial_c_data = frame.column("C").to_vec(); // [7, 8, 9]
frame.swap_columns("A", "C");
// Check names order
assert_eq!(frame.column_names, vec!["C", "B", "A"]);
// Check lookup map
assert_eq!(frame.column_index("A"), Some(2));
assert_eq!(frame.column_index("B"), Some(1));
assert_eq!(frame.column_index("C"), Some(0));
// Check data using new names (should be swapped)
// Accessing by name "C" (now at index 0) should retrieve the data
// that was swapped INTO index 0, which was the *original C data*.
assert_eq!(
frame.column("C"),
initial_c_data.as_slice(),
"Data for name 'C' should be original C data"
);
// Accessing by name "A" (now at index 2) should retrieve the data
// that was swapped INTO index 2, which was the *original A data*.
assert_eq!(
frame.column("A"),
initial_a_data.as_slice(),
"Data for name 'A' should be original A data"
);
// Column "B" should remain unchanged in data and position.
assert_eq!(
frame.column("B"),
&[4, 5, 6],
"Column 'B' should be unchanged"
);
// Test swapping with self
let state_before_self_swap = frame.clone();
frame.swap_columns("B", "B");
assert_eq!(frame, state_before_self_swap);
}
}

171
src/matrix/boolops.rs
View File

@ -74,3 +74,174 @@ impl BoolOps for BoolMatrix {
}
}
// use macros to generate the implementations for BitAnd, BitOr, BitXor, and Not
#[cfg(test)]
mod tests {
use super::*;
// Helper function to create a BoolMatrix for BoolOps testing
fn create_bool_test_matrix() -> BoolMatrix {
// 3x3 matrix (column-major)
// T F T
// F T F
// T F F
let data = vec![true, false, true, false, true, false, true, false, false];
BoolMatrix::from_vec(data, 3, 3)
}
// --- Tests for BoolOps (BoolMatrix) ---
#[test]
fn test_bool_ops_any_vertical() {
let matrix = create_bool_test_matrix();
// Col 0: T | F | T = T
// Col 1: F | T | F = T
// Col 2: T | F | F = T
let expected = vec![true, true, true];
assert_eq!(matrix.any_vertical(), expected);
}
#[test]
fn test_bool_ops_any_horizontal() {
let matrix = create_bool_test_matrix();
// Row 0: T | F | T = T
// Row 1: F | T | F = T
// Row 2: T | F | F = T
let expected = vec![true, true, true];
assert_eq!(matrix.any_horizontal(), expected);
}
#[test]
fn test_bool_ops_all_vertical() {
let matrix = create_bool_test_matrix();
// Col 0: T & F & T = F
// Col 1: F & T & F = F
// Col 2: T & F & F = F
let expected = vec![false, false, false];
assert_eq!(matrix.all_vertical(), expected);
}
#[test]
fn test_bool_ops_all_horizontal() {
let matrix = create_bool_test_matrix();
// Row 0: T & F & T = F
// Row 1: F & T & F = F
// Row 2: T & F & F = F
let expected = vec![false, false, false];
assert_eq!(matrix.all_horizontal(), expected);
}
#[test]
fn test_bool_ops_count_vertical() {
let matrix = create_bool_test_matrix();
// Col 0: count true in [T, F, T] = 2
// Col 1: count true in [F, T, F] = 1
// Col 2: count true in [T, F, F] = 1
let expected = vec![2, 1, 1];
assert_eq!(matrix.count_vertical(), expected);
}
#[test]
fn test_bool_ops_count_horizontal() {
let matrix = create_bool_test_matrix();
// Row 0: count true in [T, F, T] = 2
// Row 1: count true in [F, T, F] = 1
// Row 2: count true in [T, F, F] = 1
let expected = vec![2, 1, 1];
assert_eq!(matrix.count_horizontal(), expected);
}
#[test]
fn test_bool_ops_any_overall() {
let matrix = create_bool_test_matrix(); // Has true values
assert!(matrix.any());
let matrix_all_false = BoolMatrix::from_vec(vec![false; 9], 3, 3);
assert!(!matrix_all_false.any());
}
#[test]
fn test_bool_ops_all_overall() {
let matrix = create_bool_test_matrix(); // Has false values
assert!(!matrix.all());
let matrix_all_true = BoolMatrix::from_vec(vec![true; 9], 3, 3);
assert!(matrix_all_true.all());
}
#[test]
fn test_bool_ops_count_overall() {
let matrix = create_bool_test_matrix(); // Data: [T, F, T, F, T, F, T, F, F]
// Count of true values: 4
assert_eq!(matrix.count(), 4);
let matrix_all_false = BoolMatrix::from_vec(vec![false; 5], 5, 1); // 5x1
assert_eq!(matrix_all_false.count(), 0);
let matrix_all_true = BoolMatrix::from_vec(vec![true; 4], 2, 2); // 2x2
assert_eq!(matrix_all_true.count(), 4);
}
// --- Edge Cases for BoolOps ---
#[test]
fn test_bool_ops_1x1() {
let matrix_t = BoolMatrix::from_vec(vec![true], 1, 1);
assert_eq!(matrix_t.any_vertical(), vec![true]);
assert_eq!(matrix_t.any_horizontal(), vec![true]);
assert_eq!(matrix_t.all_vertical(), vec![true]);
assert_eq!(matrix_t.all_horizontal(), vec![true]);
assert_eq!(matrix_t.count_vertical(), vec![1]);
assert_eq!(matrix_t.count_horizontal(), vec![1]);
assert!(matrix_t.any());
assert!(matrix_t.all());
assert_eq!(matrix_t.count(), 1);
let matrix_f = BoolMatrix::from_vec(vec![false], 1, 1);
assert_eq!(matrix_f.any_vertical(), vec![false]);
assert_eq!(matrix_f.any_horizontal(), vec![false]);
assert_eq!(matrix_f.all_vertical(), vec![false]);
assert_eq!(matrix_f.all_horizontal(), vec![false]);
assert_eq!(matrix_f.count_vertical(), vec![0]);
assert_eq!(matrix_f.count_horizontal(), vec![0]);
assert!(!matrix_f.any());
assert!(!matrix_f.all());
assert_eq!(matrix_f.count(), 0);
}
#[test]
fn test_bool_ops_1xn_matrix() {
let matrix = BoolMatrix::from_vec(vec![true, false, false, true], 1, 4); // 1 row, 4 cols
// Data: [T, F, F, T]
assert_eq!(matrix.any_vertical(), vec![true, false, false, true]);
assert_eq!(matrix.all_vertical(), vec![true, false, false, true]);
assert_eq!(matrix.count_vertical(), vec![1, 0, 0, 1]);
assert_eq!(matrix.any_horizontal(), vec![true]); // T | F | F | T = T
assert_eq!(matrix.all_horizontal(), vec![false]); // T & F & F & T = F
assert_eq!(matrix.count_horizontal(), vec![2]); // count true in [T, F, F, T] = 2
assert!(matrix.any());
assert!(!matrix.all());
assert_eq!(matrix.count(), 2);
}
#[test]
fn test_bool_ops_nx1_matrix() {
let matrix = BoolMatrix::from_vec(vec![true, false, false, true], 4, 1); // 4 rows, 1 col
// Data: [T, F, F, T]
assert_eq!(matrix.any_vertical(), vec![true]); // T|F|F|T = T
assert_eq!(matrix.all_vertical(), vec![false]); // T&F&F&T = F
assert_eq!(matrix.count_vertical(), vec![2]); // count true in [T, F, F, T] = 2
assert_eq!(matrix.any_horizontal(), vec![true, false, false, true]);
assert_eq!(matrix.all_horizontal(), vec![true, false, false, true]);
assert_eq!(matrix.count_horizontal(), vec![1, 0, 0, 1]);
assert!(matrix.any());
assert!(!matrix.all());
assert_eq!(matrix.count(), 2);
}
}

71
src/matrix/mat.rs
View File

@ -256,7 +256,6 @@ pub enum Axis {
Row,
}
#[cfg(test)]
mod tests {
use super::{BoolMatrix, FloatMatrix, Matrix, StringMatrix};
@ -1145,5 +1144,75 @@ mod tests {
assert!((div[(1, 1)] - 4.0 / 3.5).abs() < 1e-9); // 1.14...
}
fn create_test_matrix_i32() -> Matrix<i32> {
Matrix::from_cols(vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]])
}
#[test]
fn test_matrix_swap_columns_directly() {
let mut matrix = create_test_matrix_i32();
// Store the initial state of the columns we intend to swap AND one that shouldn't change
let initial_col0_data = matrix.column(0).to_vec(); // Should be [1, 2, 3]
let initial_col1_data = matrix.column(1).to_vec(); // Should be [4, 5, 6]
let initial_col2_data = matrix.column(2).to_vec(); // Should be [7, 8, 9]
// Perform the swap directly on the matrix
matrix.swap_columns(0, 2); // Swap column 0 and column 2
// --- Assertions ---
// 1. Verify the dimensions are unchanged
assert_eq!(matrix.rows(), 3, "Matrix rows should remain unchanged");
assert_eq!(matrix.cols(), 3, "Matrix cols should remain unchanged");
// 2. Verify the column that was NOT swapped is unchanged
assert_eq!(
matrix.column(1),
initial_col1_data.as_slice(), // Comparing slice to slice
"Column 1 data should be unchanged"
);
// 3. Verify the data swap occurred correctly using the COLUMN ACCESSOR
// The data originally at index 0 should now be at index 2
assert_eq!(
matrix.column(2),
initial_col0_data.as_slice(),
"Column 2 should now contain the original data from column 0"
);
// The data originally at index 2 should now be at index 0
assert_eq!(
matrix.column(0),
initial_col2_data.as_slice(),
"Column 0 should now contain the original data from column 2"
);
// 4. (Optional but useful) Verify the underlying raw data vector
// Original data: [1, 2, 3, 4, 5, 6, 7, 8, 9]
// Expected data after swapping col 0 and col 2: [7, 8, 9, 4, 5, 6, 1, 2, 3]
assert_eq!(
matrix.data(),
&[7, 8, 9, 4, 5, 6, 1, 2, 3],
"Underlying data vector is incorrect after swap"
);
// 5. Test swapping with self (should be a no-op)
let state_before_self_swap = matrix.clone();
matrix.swap_columns(1, 1);
assert_eq!(
matrix, state_before_self_swap,
"Swapping a column with itself should not change the matrix"
);
// 6. Test swapping adjacent columns
let mut matrix2 = create_test_matrix_i32();
let initial_col0_data_m2 = matrix2.column(0).to_vec();
let initial_col1_data_m2 = matrix2.column(1).to_vec();
matrix2.swap_columns(0, 1);
assert_eq!(matrix2.column(0), initial_col1_data_m2.as_slice());
assert_eq!(matrix2.column(1), initial_col0_data_m2.as_slice());
assert_eq!(matrix2.data(), &[4, 5, 6, 1, 2, 3, 7, 8, 9]);
}
// Axis enum doesn't have logic, no tests needed directly, but its presence is verified by compilation.
}

221
src/matrix/seriesops.rs
View File

@ -141,3 +141,224 @@ impl SeriesOps for FloatMatrix {
BoolMatrix::from_vec(data, self.rows(), self.cols())
}
}
#[cfg(test)]
mod tests {
use super::*;
// Helper function to create a FloatMatrix for SeriesOps testing
fn create_float_test_matrix() -> FloatMatrix {
// 3x3 matrix (column-major) with some NaNs
// 1.0 4.0 7.0
// 2.0 NaN 8.0
// 3.0 6.0 NaN
let data = vec![1.0, 2.0, 3.0, 4.0, f64::NAN, 6.0, 7.0, 8.0, f64::NAN];
FloatMatrix::from_vec(data, 3, 3)
}
// --- Tests for SeriesOps (FloatMatrix) ---
#[test]
fn test_series_ops_sum_vertical() {
let matrix = create_float_test_matrix();
// Col 0: 1.0 + 2.0 + 3.0 = 6.0
// Col 1: 4.0 + NaN + 6.0 = 10.0 (NaN ignored)
// Col 2: 7.0 + 8.0 + NaN = 15.0 (NaN ignored)
let expected = vec![6.0, 10.0, 15.0];
assert_eq!(matrix.sum_vertical(), expected);
}
#[test]
fn test_series_ops_sum_horizontal() {
let matrix = create_float_test_matrix();
// Row 0: 1.0 + 4.0 + 7.0 = 12.0
// Row 1: 2.0 + NaN + 8.0 = 10.0 (NaN ignored)
// Row 2: 3.0 + 6.0 + NaN = 9.0 (NaN ignored)
let expected = vec![12.0, 10.0, 9.0];
assert_eq!(matrix.sum_horizontal(), expected);
}
#[test]
fn test_series_ops_prod_vertical() {
let matrix = create_float_test_matrix();
// Col 0: 1.0 * 2.0 * 3.0 = 6.0
// Col 1: 4.0 * NaN * 6.0 = 24.0 (NaN ignored, starts with 1.0)
// Col 2: 7.0 * 8.0 * NaN = 56.0 (NaN ignored, starts with 1.0)
let expected = vec![6.0, 24.0, 56.0];
assert_eq!(matrix.prod_vertical(), expected);
}
#[test]
fn test_series_ops_prod_horizontal() {
let matrix = create_float_test_matrix();
// Row 0: 1.0 * 4.0 * 7.0 = 28.0
// Row 1: 2.0 * NaN * 8.0 = 16.0 (NaN ignored, starts with 1.0)
// Row 2: 3.0 * 6.0 * NaN = 18.0 (NaN ignored, starts with 1.0)
let expected = vec![28.0, 16.0, 18.0];
assert_eq!(matrix.prod_horizontal(), expected);
}
#[test]
fn test_series_ops_cumsum_vertical() {
let matrix = create_float_test_matrix();
// Col 0: [1.0, 1.0+2.0=3.0, 3.0+3.0=6.0]
// Col 1: [4.0, 4.0+NaN=4.0, 4.0+6.0=10.0] (NaN ignored, cumulative sum doesn't reset)
// Col 2: [7.0, 7.0+8.0=15.0, 15.0+NaN=15.0]
// Expected data (column-major): [1.0, 3.0, 6.0, 4.0, 4.0, 10.0, 7.0, 15.0, 15.0]
let expected_data = vec![1.0, 3.0, 6.0, 4.0, 4.0, 10.0, 7.0, 15.0, 15.0];
let expected_matrix = FloatMatrix::from_vec(expected_data, 3, 3);
assert_eq!(matrix.cumsum_vertical(), expected_matrix);
}
#[test]
fn test_series_ops_cumsum_horizontal() {
let matrix = create_float_test_matrix();
// Row 0: [1.0, 1.0+4.0=5.0, 5.0+7.0=12.0]
// Row 1: [2.0, 2.0+NaN=2.0, 2.0+8.0=10.0] (NaN ignored, cumulative sum doesn't reset)
// Row 2: [3.0, 3.0+6.0=9.0, 9.0+NaN=9.0]
// Expected data (column-major construction from row results):
// Col 0: (R0,C0)=1.0, (R1,C0)=2.0, (R2,C0)=3.0 => [1.0, 2.0, 3.0]
// Col 1: (R0,C1)=5.0, (R1,C1)=2.0, (R2,C1)=9.0 => [5.0, 2.0, 9.0]
// Col 2: (R0,C2)=12.0, (R1,C2)=10.0, (R2,C2)=9.0 => [12.0, 10.0, 9.0]
// Combined data: [1.0, 2.0, 3.0, 5.0, 2.0, 9.0, 12.0, 10.0, 9.0]
let expected_data = vec![1.0, 2.0, 3.0, 5.0, 2.0, 9.0, 12.0, 10.0, 9.0];
let expected_matrix = FloatMatrix::from_vec(expected_data, 3, 3);
assert_eq!(matrix.cumsum_horizontal(), expected_matrix);
}
#[test]
fn test_series_ops_count_nan_vertical() {
let matrix = create_float_test_matrix();
// Col 0: 0 NaNs
// Col 1: 1 NaN
// Col 2: 1 NaN
let expected = vec![0, 1, 1];
assert_eq!(matrix.count_nan_vertical(), expected);
}
#[test]
fn test_series_ops_count_nan_horizontal() {
let matrix = create_float_test_matrix();
// Row 0: 0 NaNs
// Row 1: 1 NaN
// Row 2: 1 NaN
let expected = vec![0, 1, 1];
assert_eq!(matrix.count_nan_horizontal(), expected);
}
#[test]
fn test_series_ops_is_nan() {
let matrix = create_float_test_matrix();
// Original data (col-major): [1.0, 2.0, 3.0, 4.0, NaN, 6.0, 7.0, 8.0, NaN]
// is_nan() applied: [F, F, F, F, T, F, F, F, T]
let expected_data = vec![false, false, false, false, true, false, false, false, true];
let expected_matrix = BoolMatrix::from_vec(expected_data, 3, 3);
assert_eq!(matrix.is_nan(), expected_matrix);
}
// --- Edge Cases for SeriesOps ---
#[test]
fn test_series_ops_1x1() {
let matrix = FloatMatrix::from_vec(vec![42.0], 1, 1);
assert_eq!(matrix.sum_vertical(), vec![42.0]);
assert_eq!(matrix.sum_horizontal(), vec![42.0]);
assert_eq!(matrix.prod_vertical(), vec![42.0]);
assert_eq!(matrix.prod_horizontal(), vec![42.0]);
assert_eq!(matrix.cumsum_vertical().data(), &[42.0]);
assert_eq!(matrix.cumsum_horizontal().data(), &[42.0]);
assert_eq!(matrix.count_nan_vertical(), vec![0]);
assert_eq!(matrix.count_nan_horizontal(), vec![0]);
assert_eq!(matrix.is_nan().data(), &[false]);
let matrix_nan = FloatMatrix::from_vec(vec![f64::NAN], 1, 1);
assert_eq!(matrix_nan.sum_vertical(), vec![0.0]); // sum of empty set is 0
assert_eq!(matrix_nan.sum_horizontal(), vec![0.0]);
assert_eq!(matrix_nan.prod_vertical(), vec![1.0]); // product of empty set is 1
assert_eq!(matrix_nan.prod_horizontal(), vec![1.0]);
assert_eq!(matrix_nan.cumsum_vertical().data(), &[0.0]); // cumsum starts at 0, nan ignored
assert_eq!(matrix_nan.cumsum_horizontal().data(), &[0.0]);
assert_eq!(matrix_nan.count_nan_vertical(), vec![1]);
assert_eq!(matrix_nan.count_nan_horizontal(), vec![1]);
assert_eq!(matrix_nan.is_nan().data(), &[true]);
}
#[test]
fn test_series_ops_1xn_matrix() {
let matrix = FloatMatrix::from_vec(vec![1.0, f64::NAN, 3.0, 4.0], 1, 4); // 1 row, 4 cols
// Data: [1.0, NaN, 3.0, 4.0]
// Vertical (sums/prods/counts per column - each col is just one element)
assert_eq!(matrix.sum_vertical(), vec![1.0, 0.0, 3.0, 4.0]); // NaN sum is 0
assert_eq!(matrix.prod_vertical(), vec![1.0, 1.0, 3.0, 4.0]); // NaN prod is 1
assert_eq!(matrix.count_nan_vertical(), vec![0, 1, 0, 0]);
assert_eq!(matrix.cumsum_vertical().data(), &[1.0, 0.0, 3.0, 4.0]); // Cumsum on single element column
// Horizontal (sums/prods/counts for the single row)
// Row 0: 1.0 + NaN + 3.0 + 4.0 = 8.0
// Row 0: 1.0 * NaN * 3.0 * 4.0 = 12.0
// Row 0: 1 NaN
assert_eq!(matrix.sum_horizontal(), vec![8.0]);
assert_eq!(matrix.prod_horizontal(), vec![12.0]);
assert_eq!(matrix.count_nan_horizontal(), vec![1]);
// Cumsum Horizontal
// Row 0: [1.0, 1.0+NaN=1.0, 1.0+3.0=4.0, 4.0+4.0=8.0]
// Data (col-major): [1.0, 1.0, 4.0, 8.0] (since it's 1 row, data is the same as the row result)
assert_eq!(matrix.cumsum_horizontal().data(), &[1.0, 1.0, 4.0, 8.0]);
// is_nan
// Data: [1.0, NaN, 3.0, 4.0]
// Expected: [F, T, F, F]
assert_eq!(matrix.is_nan().data(), &[false, true, false, false]);
}
#[test]
fn test_series_ops_nx1_matrix() {
let matrix = FloatMatrix::from_vec(vec![1.0, 2.0, f64::NAN, 4.0], 4, 1); // 4 rows, 1 col
// Data: [1.0, 2.0, NaN, 4.0]
// Vertical (sums/prods/counts for the single column)
// Col 0: 1.0 + 2.0 + NaN + 4.0 = 7.0
// Col 0: 1.0 * 2.0 * NaN * 4.0 = 8.0
// Col 0: 1 NaN
assert_eq!(matrix.sum_vertical(), vec![7.0]);
assert_eq!(matrix.prod_vertical(), vec![8.0]);
assert_eq!(matrix.count_nan_vertical(), vec![1]);
// Cumsum Vertical
// Col 0: [1.0, 1.0+2.0=3.0, 3.0+NaN=3.0, 3.0+4.0=7.0]
// Data (col-major): [1.0, 3.0, 3.0, 7.0] (since it's 1 col, data is the same as the col result)
assert_eq!(matrix.cumsum_vertical().data(), &[1.0, 3.0, 3.0, 7.0]);
// Horizontal (sums/prods/counts per row - each row is just one element)
assert_eq!(matrix.sum_horizontal(), vec![1.0, 2.0, 0.0, 4.0]); // NaN sum is 0
assert_eq!(matrix.prod_horizontal(), vec![1.0, 2.0, 1.0, 4.0]); // NaN prod is 1
assert_eq!(matrix.count_nan_horizontal(), vec![0, 0, 1, 0]);
assert_eq!(matrix.cumsum_horizontal().data(), &[1.0, 2.0, 0.0, 4.0]); // Cumsum on single element row
// is_nan
// Data: [1.0, 2.0, NaN, 4.0]
// Expected: [F, F, T, F]
assert_eq!(matrix.is_nan().data(), &[false, false, true, false]);
}
#[test]
fn test_series_ops_all_nan_matrix() {
let matrix = FloatMatrix::from_vec(vec![f64::NAN, f64::NAN, f64::NAN, f64::NAN], 2, 2);
// NaN NaN
// NaN NaN
// Data: [NaN, NaN, NaN, NaN]
assert_eq!(matrix.sum_vertical(), vec![0.0, 0.0]);
assert_eq!(matrix.sum_horizontal(), vec![0.0, 0.0]);
assert_eq!(matrix.prod_vertical(), vec![1.0, 1.0]);
assert_eq!(matrix.prod_horizontal(), vec![1.0, 1.0]);
assert_eq!(matrix.cumsum_vertical().data(), &[0.0, 0.0, 0.0, 0.0]);
assert_eq!(matrix.cumsum_horizontal().data(), &[0.0, 0.0, 0.0, 0.0]);
assert_eq!(matrix.count_nan_vertical(), vec![2, 2]);
assert_eq!(matrix.count_nan_horizontal(), vec![2, 2]);
assert_eq!(matrix.is_nan().data(), &[true, true, true, true]);
}
}

385
tests/mat_ops_tests.rs
View File

@ -1,385 +0,0 @@
#[cfg(test)]
mod tests {
use rustframe::matrix::*;
// Helper function to create a FloatMatrix for SeriesOps testing
fn create_float_test_matrix() -> FloatMatrix {
// 3x3 matrix (column-major) with some NaNs
// 1.0 4.0 7.0
// 2.0 NaN 8.0
// 3.0 6.0 NaN
let data = vec![1.0, 2.0, 3.0, 4.0, f64::NAN, 6.0, 7.0, 8.0, f64::NAN];
FloatMatrix::from_vec(data, 3, 3)
}
// Helper function to create a BoolMatrix for BoolOps testing
fn create_bool_test_matrix() -> BoolMatrix {
// 3x3 matrix (column-major)
// T F T
// F T F
// T F F
let data = vec![true, false, true, false, true, false, true, false, false];
BoolMatrix::from_vec(data, 3, 3)
}
// --- Tests for SeriesOps (FloatMatrix) ---
#[test]
fn test_series_ops_sum_vertical() {
let matrix = create_float_test_matrix();
// Col 0: 1.0 + 2.0 + 3.0 = 6.0
// Col 1: 4.0 + NaN + 6.0 = 10.0 (NaN ignored)
// Col 2: 7.0 + 8.0 + NaN = 15.0 (NaN ignored)
let expected = vec![6.0, 10.0, 15.0];
assert_eq!(matrix.sum_vertical(), expected);
}
#[test]
fn test_series_ops_sum_horizontal() {
let matrix = create_float_test_matrix();
// Row 0: 1.0 + 4.0 + 7.0 = 12.0
// Row 1: 2.0 + NaN + 8.0 = 10.0 (NaN ignored)
// Row 2: 3.0 + 6.0 + NaN = 9.0 (NaN ignored)
let expected = vec![12.0, 10.0, 9.0];
assert_eq!(matrix.sum_horizontal(), expected);
}
#[test]
fn test_series_ops_prod_vertical() {
let matrix = create_float_test_matrix();
// Col 0: 1.0 * 2.0 * 3.0 = 6.0
// Col 1: 4.0 * NaN * 6.0 = 24.0 (NaN ignored, starts with 1.0)
// Col 2: 7.0 * 8.0 * NaN = 56.0 (NaN ignored, starts with 1.0)
let expected = vec![6.0, 24.0, 56.0];
assert_eq!(matrix.prod_vertical(), expected);
}
#[test]
fn test_series_ops_prod_horizontal() {
let matrix = create_float_test_matrix();
// Row 0: 1.0 * 4.0 * 7.0 = 28.0
// Row 1: 2.0 * NaN * 8.0 = 16.0 (NaN ignored, starts with 1.0)
// Row 2: 3.0 * 6.0 * NaN = 18.0 (NaN ignored, starts with 1.0)
let expected = vec![28.0, 16.0, 18.0];
assert_eq!(matrix.prod_horizontal(), expected);
}
#[test]
fn test_series_ops_cumsum_vertical() {
let matrix = create_float_test_matrix();
// Col 0: [1.0, 1.0+2.0=3.0, 3.0+3.0=6.0]
// Col 1: [4.0, 4.0+NaN=4.0, 4.0+6.0=10.0] (NaN ignored, cumulative sum doesn't reset)
// Col 2: [7.0, 7.0+8.0=15.0, 15.0+NaN=15.0]
// Expected data (column-major): [1.0, 3.0, 6.0, 4.0, 4.0, 10.0, 7.0, 15.0, 15.0]
let expected_data = vec![1.0, 3.0, 6.0, 4.0, 4.0, 10.0, 7.0, 15.0, 15.0];
let expected_matrix = FloatMatrix::from_vec(expected_data, 3, 3);
assert_eq!(matrix.cumsum_vertical(), expected_matrix);
}
#[test]
fn test_series_ops_cumsum_horizontal() {
let matrix = create_float_test_matrix();
// Row 0: [1.0, 1.0+4.0=5.0, 5.0+7.0=12.0]
// Row 1: [2.0, 2.0+NaN=2.0, 2.0+8.0=10.0] (NaN ignored, cumulative sum doesn't reset)
// Row 2: [3.0, 3.0+6.0=9.0, 9.0+NaN=9.0]
// Expected data (column-major construction from row results):
// Col 0: (R0,C0)=1.0, (R1,C0)=2.0, (R2,C0)=3.0 => [1.0, 2.0, 3.0]
// Col 1: (R0,C1)=5.0, (R1,C1)=2.0, (R2,C1)=9.0 => [5.0, 2.0, 9.0]
// Col 2: (R0,C2)=12.0, (R1,C2)=10.0, (R2,C2)=9.0 => [12.0, 10.0, 9.0]
// Combined data: [1.0, 2.0, 3.0, 5.0, 2.0, 9.0, 12.0, 10.0, 9.0]
let expected_data = vec![1.0, 2.0, 3.0, 5.0, 2.0, 9.0, 12.0, 10.0, 9.0];
let expected_matrix = FloatMatrix::from_vec(expected_data, 3, 3);
assert_eq!(matrix.cumsum_horizontal(), expected_matrix);
}
#[test]
fn test_series_ops_count_nan_vertical() {
let matrix = create_float_test_matrix();
// Col 0: 0 NaNs
// Col 1: 1 NaN
// Col 2: 1 NaN
let expected = vec![0, 1, 1];
assert_eq!(matrix.count_nan_vertical(), expected);
}
#[test]
fn test_series_ops_count_nan_horizontal() {
let matrix = create_float_test_matrix();
// Row 0: 0 NaNs
// Row 1: 1 NaN
// Row 2: 1 NaN
let expected = vec![0, 1, 1];
assert_eq!(matrix.count_nan_horizontal(), expected);
}
#[test]
fn test_series_ops_is_nan() {
let matrix = create_float_test_matrix();
// Original data (col-major): [1.0, 2.0, 3.0, 4.0, NaN, 6.0, 7.0, 8.0, NaN]
// is_nan() applied: [F, F, F, F, T, F, F, F, T]
let expected_data = vec![false, false, false, false, true, false, false, false, true];
let expected_matrix = BoolMatrix::from_vec(expected_data, 3, 3);
assert_eq!(matrix.is_nan(), expected_matrix);
}
// --- Edge Cases for SeriesOps ---
#[test]
fn test_series_ops_1x1() {
let matrix = FloatMatrix::from_vec(vec![42.0], 1, 1);
assert_eq!(matrix.sum_vertical(), vec![42.0]);
assert_eq!(matrix.sum_horizontal(), vec![42.0]);
assert_eq!(matrix.prod_vertical(), vec![42.0]);
assert_eq!(matrix.prod_horizontal(), vec![42.0]);
assert_eq!(matrix.cumsum_vertical().data(), &[42.0]);
assert_eq!(matrix.cumsum_horizontal().data(), &[42.0]);
assert_eq!(matrix.count_nan_vertical(), vec![0]);
assert_eq!(matrix.count_nan_horizontal(), vec![0]);
assert_eq!(matrix.is_nan().data(), &[false]);
let matrix_nan = FloatMatrix::from_vec(vec![f64::NAN], 1, 1);
assert_eq!(matrix_nan.sum_vertical(), vec![0.0]); // sum of empty set is 0
assert_eq!(matrix_nan.sum_horizontal(), vec![0.0]);
assert_eq!(matrix_nan.prod_vertical(), vec![1.0]); // product of empty set is 1
assert_eq!(matrix_nan.prod_horizontal(), vec![1.0]);
assert_eq!(matrix_nan.cumsum_vertical().data(), &[0.0]); // cumsum starts at 0, nan ignored
assert_eq!(matrix_nan.cumsum_horizontal().data(), &[0.0]);
assert_eq!(matrix_nan.count_nan_vertical(), vec![1]);
assert_eq!(matrix_nan.count_nan_horizontal(), vec![1]);
assert_eq!(matrix_nan.is_nan().data(), &[true]);
}
#[test]
fn test_series_ops_1xn_matrix() {
let matrix = FloatMatrix::from_vec(vec![1.0, f64::NAN, 3.0, 4.0], 1, 4); // 1 row, 4 cols
// Data: [1.0, NaN, 3.0, 4.0]
// Vertical (sums/prods/counts per column - each col is just one element)
assert_eq!(matrix.sum_vertical(), vec![1.0, 0.0, 3.0, 4.0]); // NaN sum is 0
assert_eq!(matrix.prod_vertical(), vec![1.0, 1.0, 3.0, 4.0]); // NaN prod is 1
assert_eq!(matrix.count_nan_vertical(), vec![0, 1, 0, 0]);
assert_eq!(matrix.cumsum_vertical().data(), &[1.0, 0.0, 3.0, 4.0]); // Cumsum on single element column
// Horizontal (sums/prods/counts for the single row)
// Row 0: 1.0 + NaN + 3.0 + 4.0 = 8.0
// Row 0: 1.0 * NaN * 3.0 * 4.0 = 12.0
// Row 0: 1 NaN
assert_eq!(matrix.sum_horizontal(), vec![8.0]);
assert_eq!(matrix.prod_horizontal(), vec![12.0]);
assert_eq!(matrix.count_nan_horizontal(), vec![1]);
// Cumsum Horizontal
// Row 0: [1.0, 1.0+NaN=1.0, 1.0+3.0=4.0, 4.0+4.0=8.0]
// Data (col-major): [1.0, 1.0, 4.0, 8.0] (since it's 1 row, data is the same as the row result)
assert_eq!(matrix.cumsum_horizontal().data(), &[1.0, 1.0, 4.0, 8.0]);
// is_nan
// Data: [1.0, NaN, 3.0, 4.0]
// Expected: [F, T, F, F]
assert_eq!(matrix.is_nan().data(), &[false, true, false, false]);
}
#[test]
fn test_series_ops_nx1_matrix() {
let matrix = FloatMatrix::from_vec(vec![1.0, 2.0, f64::NAN, 4.0], 4, 1); // 4 rows, 1 col
// Data: [1.0, 2.0, NaN, 4.0]
// Vertical (sums/prods/counts for the single column)
// Col 0: 1.0 + 2.0 + NaN + 4.0 = 7.0
// Col 0: 1.0 * 2.0 * NaN * 4.0 = 8.0
// Col 0: 1 NaN
assert_eq!(matrix.sum_vertical(), vec![7.0]);
assert_eq!(matrix.prod_vertical(), vec![8.0]);
assert_eq!(matrix.count_nan_vertical(), vec![1]);
// Cumsum Vertical
// Col 0: [1.0, 1.0+2.0=3.0, 3.0+NaN=3.0, 3.0+4.0=7.0]
// Data (col-major): [1.0, 3.0, 3.0, 7.0] (since it's 1 col, data is the same as the col result)
assert_eq!(matrix.cumsum_vertical().data(), &[1.0, 3.0, 3.0, 7.0]);
// Horizontal (sums/prods/counts per row - each row is just one element)
assert_eq!(matrix.sum_horizontal(), vec![1.0, 2.0, 0.0, 4.0]); // NaN sum is 0
assert_eq!(matrix.prod_horizontal(), vec![1.0, 2.0, 1.0, 4.0]); // NaN prod is 1
assert_eq!(matrix.count_nan_horizontal(), vec![0, 0, 1, 0]);
assert_eq!(matrix.cumsum_horizontal().data(), &[1.0, 2.0, 0.0, 4.0]); // Cumsum on single element row
// is_nan
// Data: [1.0, 2.0, NaN, 4.0]
// Expected: [F, F, T, F]
assert_eq!(matrix.is_nan().data(), &[false, false, true, false]);
}
#[test]
fn test_series_ops_all_nan_matrix() {
let matrix = FloatMatrix::from_vec(vec![f64::NAN, f64::NAN, f64::NAN, f64::NAN], 2, 2);
// NaN NaN
// NaN NaN
// Data: [NaN, NaN, NaN, NaN]
assert_eq!(matrix.sum_vertical(), vec![0.0, 0.0]);
assert_eq!(matrix.sum_horizontal(), vec![0.0, 0.0]);
assert_eq!(matrix.prod_vertical(), vec![1.0, 1.0]);
assert_eq!(matrix.prod_horizontal(), vec![1.0, 1.0]);
assert_eq!(matrix.cumsum_vertical().data(), &[0.0, 0.0, 0.0, 0.0]);
assert_eq!(matrix.cumsum_horizontal().data(), &[0.0, 0.0, 0.0, 0.0]);
assert_eq!(matrix.count_nan_vertical(), vec![2, 2]);
assert_eq!(matrix.count_nan_horizontal(), vec![2, 2]);
assert_eq!(matrix.is_nan().data(), &[true, true, true, true]);
}
// --- Tests for BoolOps (BoolMatrix) ---
#[test]
fn test_bool_ops_any_vertical() {
let matrix = create_bool_test_matrix();
// Col 0: T | F | T = T
// Col 1: F | T | F = T
// Col 2: T | F | F = T
let expected = vec![true, true, true];
assert_eq!(matrix.any_vertical(), expected);
}
#[test]
fn test_bool_ops_any_horizontal() {
let matrix = create_bool_test_matrix();
// Row 0: T | F | T = T
// Row 1: F | T | F = T
// Row 2: T | F | F = T
let expected = vec![true, true, true];
assert_eq!(matrix.any_horizontal(), expected);
}
#[test]
fn test_bool_ops_all_vertical() {
let matrix = create_bool_test_matrix();
// Col 0: T & F & T = F
// Col 1: F & T & F = F
// Col 2: T & F & F = F
let expected = vec![false, false, false];
assert_eq!(matrix.all_vertical(), expected);
}
#[test]
fn test_bool_ops_all_horizontal() {
let matrix = create_bool_test_matrix();
// Row 0: T & F & T = F
// Row 1: F & T & F = F
// Row 2: T & F & F = F
let expected = vec![false, false, false];
assert_eq!(matrix.all_horizontal(), expected);
}
#[test]
fn test_bool_ops_count_vertical() {
let matrix = create_bool_test_matrix();
// Col 0: count true in [T, F, T] = 2
// Col 1: count true in [F, T, F] = 1
// Col 2: count true in [T, F, F] = 1
let expected = vec![2, 1, 1];
assert_eq!(matrix.count_vertical(), expected);
}
#[test]
fn test_bool_ops_count_horizontal() {
let matrix = create_bool_test_matrix();
// Row 0: count true in [T, F, T] = 2
// Row 1: count true in [F, T, F] = 1
// Row 2: count true in [T, F, F] = 1
let expected = vec![2, 1, 1];
assert_eq!(matrix.count_horizontal(), expected);
}
#[test]
fn test_bool_ops_any_overall() {
let matrix = create_bool_test_matrix(); // Has true values
assert!(matrix.any());
let matrix_all_false = BoolMatrix::from_vec(vec![false; 9], 3, 3);
assert!(!matrix_all_false.any());
}
#[test]
fn test_bool_ops_all_overall() {
let matrix = create_bool_test_matrix(); // Has false values
assert!(!matrix.all());
let matrix_all_true = BoolMatrix::from_vec(vec![true; 9], 3, 3);
assert!(matrix_all_true.all());
}
#[test]
fn test_bool_ops_count_overall() {
let matrix = create_bool_test_matrix(); // Data: [T, F, T, F, T, F, T, F, F]
// Count of true values: 4
assert_eq!(matrix.count(), 4);
let matrix_all_false = BoolMatrix::from_vec(vec![false; 5], 5, 1); // 5x1
assert_eq!(matrix_all_false.count(), 0);
let matrix_all_true = BoolMatrix::from_vec(vec![true; 4], 2, 2); // 2x2
assert_eq!(matrix_all_true.count(), 4);
}
// --- Edge Cases for BoolOps ---
#[test]
fn test_bool_ops_1x1() {
let matrix_t = BoolMatrix::from_vec(vec![true], 1, 1);
assert_eq!(matrix_t.any_vertical(), vec![true]);
assert_eq!(matrix_t.any_horizontal(), vec![true]);
assert_eq!(matrix_t.all_vertical(), vec![true]);
assert_eq!(matrix_t.all_horizontal(), vec![true]);
assert_eq!(matrix_t.count_vertical(), vec![1]);
assert_eq!(matrix_t.count_horizontal(), vec![1]);
assert!(matrix_t.any());
assert!(matrix_t.all());
assert_eq!(matrix_t.count(), 1);
let matrix_f = BoolMatrix::from_vec(vec![false], 1, 1);
assert_eq!(matrix_f.any_vertical(), vec![false]);
assert_eq!(matrix_f.any_horizontal(), vec![false]);
assert_eq!(matrix_f.all_vertical(), vec![false]);
assert_eq!(matrix_f.all_horizontal(), vec![false]);
assert_eq!(matrix_f.count_vertical(), vec![0]);
assert_eq!(matrix_f.count_horizontal(), vec![0]);
assert!(!matrix_f.any());
assert!(!matrix_f.all());
assert_eq!(matrix_f.count(), 0);
}
#[test]
fn test_bool_ops_1xn_matrix() {
let matrix = BoolMatrix::from_vec(vec![true, false, false, true], 1, 4); // 1 row, 4 cols
// Data: [T, F, F, T]
assert_eq!(matrix.any_vertical(), vec![true, false, false, true]);
assert_eq!(matrix.all_vertical(), vec![true, false, false, true]);
assert_eq!(matrix.count_vertical(), vec![1, 0, 0, 1]);
assert_eq!(matrix.any_horizontal(), vec![true]); // T | F | F | T = T
assert_eq!(matrix.all_horizontal(), vec![false]); // T & F & F & T = F
assert_eq!(matrix.count_horizontal(), vec![2]); // count true in [T, F, F, T] = 2
assert!(matrix.any());
assert!(!matrix.all());
assert_eq!(matrix.count(), 2);
}
#[test]
fn test_bool_ops_nx1_matrix() {
let matrix = BoolMatrix::from_vec(vec![true, false, false, true], 4, 1); // 4 rows, 1 col
// Data: [T, F, F, T]
assert_eq!(matrix.any_vertical(), vec![true]); // T|F|F|T = T
assert_eq!(matrix.all_vertical(), vec![false]); // T&F&F&T = F
assert_eq!(matrix.count_vertical(), vec![2]); // count true in [T, F, F, T] = 2
assert_eq!(matrix.any_horizontal(), vec![true, false, false, true]);
assert_eq!(matrix.all_horizontal(), vec![true, false, false, true]);
assert_eq!(matrix.count_horizontal(), vec![1, 0, 0, 1]);
assert!(matrix.any());
assert!(!matrix.all());
assert_eq!(matrix.count(), 2);
}
}

137
tests/matrix_col_swap_tests.rs
View File

@ -1,137 +0,0 @@
#[cfg(test)]
mod tests {
use rustframe::frame::*;
use rustframe::matrix::*;
// Or explicitly: use crate::matrix::Matrix;
// --- Include your other tests here ---
/// Creates a standard 3x3 matrix used in several tests.
/// Column 0: [1, 2, 3]
/// Column 1: [4, 5, 6]
/// Column 2: [7, 8, 9]
fn create_test_matrix_i32() -> Matrix<i32> {
Matrix::from_cols(vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]])
}
// --- The new test ---
#[test]
fn test_matrix_swap_columns_directly() {
let mut matrix = create_test_matrix_i32();
// Store the initial state of the columns we intend to swap AND one that shouldn't change
let initial_col0_data = matrix.column(0).to_vec(); // Should be [1, 2, 3]
let initial_col1_data = matrix.column(1).to_vec(); // Should be [4, 5, 6]
let initial_col2_data = matrix.column(2).to_vec(); // Should be [7, 8, 9]
// Perform the swap directly on the matrix
matrix.swap_columns(0, 2); // Swap column 0 and column 2
// --- Assertions ---
// 1. Verify the dimensions are unchanged
assert_eq!(matrix.rows(), 3, "Matrix rows should remain unchanged");
assert_eq!(matrix.cols(), 3, "Matrix cols should remain unchanged");
// 2. Verify the column that was NOT swapped is unchanged
assert_eq!(
matrix.column(1),
initial_col1_data.as_slice(), // Comparing slice to slice
"Column 1 data should be unchanged"
);
// 3. Verify the data swap occurred correctly using the COLUMN ACCESSOR
// The data originally at index 0 should now be at index 2
assert_eq!(
matrix.column(2),
initial_col0_data.as_slice(),
"Column 2 should now contain the original data from column 0"
);
// The data originally at index 2 should now be at index 0
assert_eq!(
matrix.column(0),
initial_col2_data.as_slice(),
"Column 0 should now contain the original data from column 2"
);
// 4. (Optional but useful) Verify the underlying raw data vector
// Original data: [1, 2, 3, 4, 5, 6, 7, 8, 9]
// Expected data after swapping col 0 and col 2: [7, 8, 9, 4, 5, 6, 1, 2, 3]
assert_eq!(
matrix.data(),
&[7, 8, 9, 4, 5, 6, 1, 2, 3],
"Underlying data vector is incorrect after swap"
);
// 5. Test swapping with self (should be a no-op)
let state_before_self_swap = matrix.clone();
matrix.swap_columns(1, 1);
assert_eq!(
matrix, state_before_self_swap,
"Swapping a column with itself should not change the matrix"
);
// 6. Test swapping adjacent columns
let mut matrix2 = create_test_matrix_i32();
let initial_col0_data_m2 = matrix2.column(0).to_vec();
let initial_col1_data_m2 = matrix2.column(1).to_vec();
matrix2.swap_columns(0, 1);
assert_eq!(matrix2.column(0), initial_col1_data_m2.as_slice());
assert_eq!(matrix2.column(1), initial_col0_data_m2.as_slice());
assert_eq!(matrix2.data(), &[4, 5, 6, 1, 2, 3, 7, 8, 9]);
}
// --- Include your failing Frame test_swap_columns here as well ---
#[test]
fn test_swap_columns() {
let mut frame = create_test_frame_i32();
let initial_a_data = frame.column("A").to_vec(); // [1, 2, 3]
let initial_c_data = frame.column("C").to_vec(); // [7, 8, 9]
frame.swap_columns("A", "C");
// Check names order
assert_eq!(frame.column_names, vec!["C", "B", "A"]);
// Check lookup map
assert_eq!(frame.column_index("A"), Some(2));
assert_eq!(frame.column_index("B"), Some(1));
assert_eq!(frame.column_index("C"), Some(0));
// Check data using new names (should be swapped)
// Accessing by name "C" (now at index 0) should retrieve the data
// that was swapped INTO index 0, which was the *original C data*.
assert_eq!(
frame.column("C"),
initial_c_data.as_slice(),
"Data for name 'C' should be original C data"
);
// Accessing by name "A" (now at index 2) should retrieve the data
// that was swapped INTO index 2, which was the *original A data*.
assert_eq!(
frame.column("A"),
initial_a_data.as_slice(),
"Data for name 'A' should be original A data"
);
// Column "B" should remain unchanged in data and position.
assert_eq!(
frame.column("B"),
&[4, 5, 6],
"Column 'B' should be unchanged"
);
// Test swapping with self
let state_before_self_swap = frame.clone();
frame.swap_columns("B", "B");
assert_eq!(frame, state_before_self_swap);
}
fn create_test_frame_i32() -> Frame<i32> {
// Ensure this uses the same logic/data as create_test_matrix_i32
let matrix = create_test_matrix_i32();
Frame::new(matrix, vec!["A", "B", "C"])
}
} // end mod tests