Merge pull request #21 from SingleRust/feature-correction

Add batch processing and masked operations

Author: ianfd

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "single_algebra"
-version = "0.2.1-alpha.0"
+version = "0.2.2-alpha.0"
 edition = "2021"
 license-file = "LICENSE.md"
 description = "A linear algebra convenience library for the single-rust library. Can be used externally as well."
@@ -26,6 +26,7 @@ clustering = ["network", "local_moving", "dep:kiddo"]
 network = []
 local_moving = ["network", "dep:ahash"]
 statistics = ["dep:statrs"]
+# correction = []
 
 [dependencies]
 anyhow = "1.0.95"

Cargo.toml

@@ -7,35 +7,72 @@ The companion algebra library for single-rust, providing powerful matrix operati
 - Efficient operations on sparse and dense matrices
 - Dimensionality reduction techniques
 - Clustering algorithms including Louvain community detection
+- Batch processing utilities with masking support
+- Statistical analysis and inference
 - More features planned!
 
 ## Matrix Operations 📊
 
 - SVD decomposition with parallel and LAPACK implementations
 - Matrix convenience functions for statistical operations
 - Support for both CSR and CSC sparse matrix formats
+- Masked operations for selective data processing
+- Batch-wise statistics (mean, variance) with flexible batch identifiers
 
 ## Clustering 🔍
 
 - Louvain community detection
 - Similarity network construction
 - K-nearest neighbors graph building
 - Local moving algorithm for community refinement
+- Leiden clustering implementation (work in progress)
 
 ## Dimensionality Reduction ⬇️
 
 - Incremental PCA implementation
 - Support for sparse matrices in dimensionality reduction
+- SVD-based compression and analysis
 
-## Acknowledgments 🙏
+## Statistical Analysis 📈
 
-The Louvain clustering implementation was adapted from [louvain-rs](https://github.com/graphext/louvain-rs/tree/master) written by Juan Morales (crispamares@gmail.com). The original implementation has been modified to better suit the needs of single-algebra.
+- Multiple testing correction methods
+- Parametric and non-parametric hypothesis testing
+- Effect size calculations
+- Batch-wise statistical comparisons
 
 ## Installation
 
 Add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-single-algebra = "0.2.0-alpha.0"
-```
+single-algebra = "0.2.2-alpha.0"
+```
+
+## Batch Processing
+
+The library now includes flexible batch processing capabilities with the `BatchIdentifier` trait, which supports common identifier types:
+
+- String and string slices
+- Integer types (i32, u32, usize)
+- Custom types (by implementing the trait)
+
+```rust
+// Example of batch-wise statistics
+let batches = vec!["batch1", "batch2", "batch3"];
+let batch_means = matrix.mean_batch_col(&batches)?;
+```
+
+## Masked Operations
+
+Selective processing is now available through masked operations:
+
+```rust
+// Only process selected columns
+let mask = vec![true, false, true, true, false];
+let masked_sums = matrix.sum_col_masked(&mask)?;
+```
+
+## Acknowledgments 🙏
+
+The Louvain clustering implementation was adapted from [louvain-rs](https://github.com/graphext/louvain-rs/tree/master) written by Juan Morales (crispamares@gmail.com). The original implementation has been modified to better suit the needs of single-algebra.

README.md

@@ -0,0 +1,59 @@
+use crate::utils::BatchIdentifier;
+use crate::NumericOps;
+use anyhow::Result;
+use std::hash::Hash;
+use std::ops::AddAssign;
+use num_traits::{Float, NumCast};
+
+/// Core trait for batch correction algorithms
+pub trait BatchCorrection<T, B>
+where
+    T: NumericOps,
+    B: BatchIdentifier,
+{
+    /// Fit the correction model to the data and batches
+    fn fit(&mut self, data: &impl CorrectionMatrix<Item = T>, batches: &[B]) -> Result<()>;
+
+    /// Apply correction to data using a previously fitted model
+    fn transform(
+        &self,
+        data: &impl CorrectionMatrix<Item = T>,
+    ) -> Result<impl CorrectionMatrix<Item = T>>;
+
+    /// Fit the model and transform the data in a single operation
+    fn fit_transform(
+        &mut self,
+        data: &impl CorrectionMatrix<Item = T>,
+        batches: &[B],
+    ) -> Result<impl CorrectionMatrix<Item = T>> {
+        self.fit(data, batches)?;
+        self.transform(data)
+    }
+}
+
+pub trait CorrectionMatrix: Sized {
+    type Item: NumericOps + NumCast;
+
+    /// Center columns by subtracting column means
+    fn center_columns<T>(&mut self, means: &[T]) -> anyhow::Result<()>
+    where
+        T: Float + NumCast + AddAssign + std::iter::Sum;
+
+    /// Center rows by subtracting row means
+    fn center_rows<T>(&mut self, means: &[T]) -> anyhow::Result<()>
+    where
+        T: Float + NumCast + AddAssign + std::iter::Sum;
+
+    /// Scale columns by dividing by column scaling factors
+    fn scale_columns<T>(&mut self, factors: &[T]) -> anyhow::Result<()>
+    where
+        T: Float + NumCast + AddAssign + std::iter::Sum;
+
+    /// Scale rows by dividing by row scaling factors
+    fn scale_rows<T>(&mut self, factors: &[T]) -> anyhow::Result<()>
+    where
+        T: Float + NumCast + AddAssign + std::iter::Sum;
+
+    /// Create a new matrix with the same dimensions and structure
+    fn like(&self) -> Self;
+}

src/correction/mod.rs

@@ -8,6 +8,9 @@ pub mod statistics;
 
 pub mod dimred;
 
+//#[cfg(feature="correction")]
+//pub mod correction;
+
 #[cfg(feature = "clustering")]
 pub mod clustering;