feat(deep_causality_algorithms): Generic MRMR

Refactored the mRMR (Maximum Relevance, Minimum Redundancy) feature selection algorithm to be generic over float types and their optional variants. This change eliminates code duplication by unifying the `f64` and `Option<f64>` implementations into a single generic version.

The refactoring leverages the newly introduced `FloatOption` trait from the `deep_causality_num` crate, allowing `mrmr_features_selector`  and its utility functions (`pearson_correlation`, `f_statistic`) to  operate on any type `T` that implements `FloatOption<F>`, where `F` is a float type (`f32` or `f64`).

Signed-off-by: Marvin Hansen <[email protected]>

Author: marvin-hansen

Cargo.lock

@@ -36,6 +36,10 @@ path = "../deep_causality_tensor"
 version = "0.1.4"
 
 
+[dependencies.deep_causality_num]
+path = "../deep_causality_num"
+version = "0.1.4"
+
 [dependencies.rayon]
 version = "1.11"
 optional = true

deep_causality_algorithms/Cargo.toml

@@ -4,7 +4,7 @@
  */
 
 use criterion::{Criterion, criterion_group, criterion_main};
-use deep_causality_algorithms::mrmr::{mrmr_features_selector, mrmr_features_selector_cdl};
+use deep_causality_algorithms::mrmr::mrmr_features_selector;
 use deep_causality_tensor::CausalTensor;
 
 fn generate_test_tensor(rows: usize, cols: usize) -> CausalTensor<f64> {
@@ -38,17 +38,17 @@ fn mrmr_benchmark(c: &mut Criterion) {
 
     // Benchmark the standard implementation
     group.bench_function("mrmr_features_selector", |b| {
-        let mut tensor = generate_test_tensor(rows, cols);
+        let tensor = generate_test_tensor(rows, cols);
         b.iter(|| {
-            mrmr_features_selector(&mut tensor, num_features_to_select, target_col).unwrap();
+            mrmr_features_selector(&tensor, num_features_to_select, target_col).unwrap();
         });
     });
 
     // Benchmark the cdl implementation
     group.bench_function("mrmr_features_selector_cdl", |b| {
         let tensor = generate_test_tensor_cdl(rows, cols);
         b.iter(|| {
-            mrmr_features_selector_cdl(&tensor, num_features_to_select, target_col).unwrap();
+            mrmr_features_selector(&tensor, num_features_to_select, target_col).unwrap();
         });
     });
 

deep_causality_algorithms/benches/mrmr_benchmark.rs

@@ -14,11 +14,11 @@ fn main() {
         11.0, // F0 is close to Target, F1 is also somewhat close, F2 is random
         20.0, 21.0, 5.0, 22.0, 30.0, 33.0, 2.0, 31.0, 40.0, 40.0, 8.0, 43.0, 50.0, 55.0, 3.0, 52.0,
     ];
-    let mut tensor = CausalTensor::new(data, vec![5, 4]).unwrap();
+    let tensor = CausalTensor::new(data, vec![5, 4]).unwrap();
 
     // 2. Run the feature selector
     // Select 2 features, with the target variable in column 3.
-    let selected_features_with_scores = mrmr_features_selector(&mut tensor, 3, 3).unwrap();
+    let selected_features_with_scores = mrmr_features_selector(&tensor, 3, 3).unwrap();
 
     // 3. Interpret the results
     println!("Selected features and their scores:");

deep_causality_algorithms/examples/example_mrmr.rs

@@ -3,7 +3,7 @@
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
 
-use deep_causality_algorithms::mrmr::mrmr_features_selector_cdl;
+use deep_causality_algorithms::mrmr::mrmr_features_selector;
 use deep_causality_tensor::CausalTensor;
 
 fn main() {
@@ -33,12 +33,12 @@ fn main() {
     ];
     let tensor = CausalTensor::new(data, vec![5, 4]).unwrap();
 
-    // 2. Run the feature selector for CDL version
+    // 2. Run the feature selector
     // Select 2 features, with the target variable in column 3.
-    let selected_features_with_scores = mrmr_features_selector_cdl(&tensor, 3, 3).unwrap();
+    let selected_features_with_scores = mrmr_features_selector(&tensor, 3, 3).unwrap();
 
     // 3. Interpret the results
-    println!("Selected features and their normalized scores (CDL):");
+    println!("Selected features and their normalized scores (Generic MRMR):");
     for (index, score) in selected_features_with_scores {
         println!("- Feature Index: {}, Importance Score: {:.4}", index, score);
     }

deep_causality_algorithms/examples/example_mrmr_cdl.rs

@@ -7,11 +7,7 @@ pub mod mrmr_algo;
 pub mod mrmr_error;
 pub mod mrmr_utils;
 
-pub mod mrmr_algo_cdl;
-pub mod mrmr_utils_cdl;
-
 pub use mrmr_algo::*;
-pub use mrmr_algo_cdl::*;
 pub use mrmr_error::MrmrError;
 
 #[cfg(test)]

deep_causality_algorithms/src/feature_selection/mrmr/mod.rs

@@ -1,10 +1,6 @@
-/*
- * SPDX-License-Identifier: MIT
- * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
- */
-
 use crate::feature_selection::mrmr::mrmr_error::MrmrError;
 use crate::mrmr::mrmr_utils;
+use deep_causality_num::{Float, FloatOption};
 use deep_causality_tensor::CausalTensor;
 use std::collections::HashSet;
 
@@ -21,7 +17,8 @@ use rayon::prelude::*;
 /// When compiled with the `parallel` feature flag, the main feature selection loops are parallelized using `rayon`
 /// to accelerate computation on multi-core systems.
 ///
-/// Missing values in the input `CausalTensor` are handled by column-mean imputation prior to feature selection.
+/// Missing values in the input `CausalTensor` are handled by pairwise deletion. `NaN` values
+/// in float types and `None` values in `Option<float>` types are treated as missing.
 ///
 /// The algorithm iteratively selects features based on a score that balances relevance and redundancy.
 /// The scoring mechanism is as follows:
@@ -45,12 +42,10 @@ use rayon::prelude::*;
 ///
 /// # Arguments
 ///
-/// * `tensor` - A mutable reference to a 2-dimensional `CausalTensor<f64>` containing the features and the target variable.
+/// * `tensor` - A reference to a 2-dimensional `CausalTensor<T>` containing the features and the target variable.
 /// * `num_features` - The desired number of features to select.
 /// * `target_col` - The column index of the target variable within the `tensor`.
 ///
-///  Missing values (NaN) in the input tensor will be imputed.
-///
 /// # Returns
 ///
 /// A `Result` containing:
@@ -78,21 +73,25 @@ use rayon::prelude::*;
 ///     3.0, 6.2, 9.0, 5.5,
 ///     4.0, 8.1, 12.0, 7.5,
 /// ];
-/// let mut tensor = CausalTensor::new(data, vec![4, 4]).unwrap();
+/// let tensor = CausalTensor::new(data, vec![4, 4]).unwrap();
 ///
 /// // Select 2 features, with the target variable in column 3.
-/// let selected_features_with_scores = mrmr_features_selector(&mut tensor, 2, 3).unwrap();
+/// let selected_features_with_scores = mrmr_features_selector(&tensor, 2, 3).unwrap();
 /// // The exact output may vary slightly based on floating-point precision and data, but for this example,
 /// // it typically selects features 2 and 0 (indices of the original columns).
 /// assert_eq!(selected_features_with_scores.len(), 2);
 /// // assert_eq!(selected_features_with_scores[0].0, 2); // Example expected output for index
 /// // assert!(selected_features_with_scores[0].1.is_finite()); // Example expected output for score
 /// ```
-pub fn mrmr_features_selector(
-    tensor: &mut CausalTensor<f64>,
+pub fn mrmr_features_selector<T, F>(
+    tensor: &CausalTensor<T>,
     num_features: usize,
     target_col: usize,
-) -> Result<Vec<(usize, f64)>, MrmrError> {
+) -> Result<Vec<(usize, f64)>, MrmrError>
+where
+    T: FloatOption<F>,
+    F: Float,
+{
     let shape = tensor.shape();
     if shape.len() != 2 {
         return Err(MrmrError::InvalidInput(
@@ -119,8 +118,6 @@ pub fn mrmr_features_selector(
         ));
     }
 
-    mrmr_utils::impute_missing_values(tensor);
-
     let mut all_features: HashSet<usize> = (0..n_cols).collect();
     all_features.remove(&target_col);
 
@@ -207,8 +204,14 @@ pub fn mrmr_features_selector(
                     let redundancy: f64 = selected_indices
                         .par_iter()
                         .map(|&selected_idx| {
-                            mrmr_utils::pearson_correlation(tensor, feature_idx, selected_idx)
-                                .map(|v| v.abs())
+                            let (correlation, _) = mrmr_utils::pearson_correlation(tensor, feature_idx, selected_idx)?;
+                            if !correlation.is_finite() {
+                                return Err(MrmrError::FeatureScoreError(format!(
+                                    "Correlation for feature {} and selected feature {} is not finite: {}",
+                                    feature_idx, selected_idx, correlation
+                                )))
+                            }
+                            Ok(correlation.abs())
                         })
                         .sum::<Result<f64, _>>()?;
 
@@ -281,7 +284,7 @@ pub fn mrmr_features_selector(
                     .collect();
 
                 for &selected_idx in &selected_indices {
-                    let correlation =
+                    let (correlation, _) =
                         mrmr_utils::pearson_correlation(tensor, feature_idx, selected_idx)?;
                     if !correlation.is_finite() {
                         return Err(MrmrError::FeatureScoreError(format!(