From 1d81f7e72f41ee88545d5a27a083c28be36e188d Mon Sep 17 00:00:00 2001 From: Palash Tyagi <23239946+Magnus167@users.noreply.github.com> Date: Sun, 20 Apr 2025 01:46:57 +0100 Subject: [PATCH] moved tests out of tests directory --- src/frame/base.rs | 47 ++++ src/matrix/boolops.rs | 171 +++++++++++++++ src/matrix/mat.rs | 71 +++++- src/matrix/seriesops.rs | 221 +++++++++++++++++++ tests/mat_ops_tests.rs | 385 --------------------------------- tests/matrix_col_swap_tests.rs | 137 ------------ 6 files changed, 509 insertions(+), 523 deletions(-) delete mode 100644 tests/mat_ops_tests.rs delete mode 100644 tests/matrix_col_swap_tests.rs diff --git a/src/frame/base.rs b/src/frame/base.rs index 2f0f615..d80f9d9 100644 --- a/src/frame/base.rs +++ b/src/frame/base.rs @@ -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); + } } diff --git a/src/matrix/boolops.rs b/src/matrix/boolops.rs index 7037512..cb3c5e5 100644 --- a/src/matrix/boolops.rs +++ b/src/matrix/boolops.rs @@ -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); + } +} diff --git a/src/matrix/mat.rs b/src/matrix/mat.rs index 174204d..8186195 100644 --- a/src/matrix/mat.rs +++ b/src/matrix/mat.rs @@ -256,7 +256,6 @@ pub enum Axis { Row, } - #[cfg(test)] mod tests { use super::{BoolMatrix, FloatMatrix, Matrix, StringMatrix}; @@ -1144,6 +1143,76 @@ mod tests { assert!((div[(0, 1)] - 3.0 / 2.5).abs() < 1e-9); // 1.2 assert!((div[(1, 1)] - 4.0 / 3.5).abs() < 1e-9); // 1.14... } + + + fn create_test_matrix_i32() -> Matrix { + 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. } diff --git a/src/matrix/seriesops.rs b/src/matrix/seriesops.rs index b6853d3..763614c 100644 --- a/src/matrix/seriesops.rs +++ b/src/matrix/seriesops.rs @@ -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]); + } +} \ No newline at end of file diff --git a/tests/mat_ops_tests.rs b/tests/mat_ops_tests.rs deleted file mode 100644 index 150aa3a..0000000 --- a/tests/mat_ops_tests.rs +++ /dev/null @@ -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); - } -} diff --git a/tests/matrix_col_swap_tests.rs b/tests/matrix_col_swap_tests.rs deleted file mode 100644 index d0e3216..0000000 --- a/tests/matrix_col_swap_tests.rs +++ /dev/null @@ -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 { - 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 { - // 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