Add mutable and parallel iteration to Matrix trait

- Add `cells_mut` to the `Matrix<T>` trait
- Add `par_cells` and `par_cells_mut` under `parallel` feature
- Implement `as_rows_par` and `as_rows_mut_par` for `DenseRowMatrix`

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: amit0365

Cargo.toml

@@ -27,6 +27,7 @@ num-bigint = { version = "0.4", default-features = false, optional = true }
 
 # Optional utility for which implementations are provided
 rand = { workspace = true, optional = true }
+rayon = { version = "1", optional = true }
 serde = { version = "1", default-features = false, optional = true }
 zeroize = { version = "1", default-features = false, optional = true }
 
@@ -39,6 +40,7 @@ rand = { workspace = true, features = ["std_rng"] }
 [features]
 default = ["std"]
 
+parallel = ["dep:rayon"]
 rand = ["dep:rand", "crypto-bigint/rand_core"]
 serde = ["dep:serde", "crypto-bigint/serde"]
 zeroize = ["dep:zeroize", "crypto-bigint/zeroize"]

src/matrix.rs

@@ -1,6 +1,9 @@
 use alloc::vec::Vec;
 use core::mem::{ManuallyDrop, MaybeUninit};
 
+#[cfg(feature = "parallel")]
+use rayon::prelude::*;
+
 /// A matrix, rectangular table of values
 pub trait Matrix<T> {
     /// Number of rows in this matrix
@@ -13,9 +16,29 @@ pub trait Matrix<T> {
     where
         T: 'a;
 
+    fn cells_mut<'a>(
+        &'a mut self,
+    ) -> impl Iterator<Item = impl Iterator<Item = (usize, &'a mut T)>>
+    where
+        T: 'a;
+
     fn is_empty(&self) -> bool {
         self.num_rows() == 0 || self.num_cols() == 0
     }
+
+    #[cfg(feature = "parallel")]
+    fn par_cells<'a>(
+        &'a self,
+    ) -> impl ParallelIterator<Item = impl Iterator<Item = (usize, &'a T)>>
+    where
+        T: 'a + Send + Sync;
+
+    #[cfg(feature = "parallel")]
+    fn par_cells_mut<'a>(
+        &'a mut self,
+    ) -> impl ParallelIterator<Item = impl Iterator<Item = (usize, &'a mut T)>>
+    where
+        T: 'a + Send + Sync;
 }
 
 /// Sparse matrix is a matrix with a fixed number non-zero of elements per row
@@ -56,6 +79,37 @@ impl<T> Matrix<T> for SparseMatrix<T> {
             .chunks(self.density)
             .map(|chunk| chunk.iter().map(|v| (v.0, &v.1)))
     }
+
+    fn cells_mut<'a>(&'a mut self) -> impl Iterator<Item = impl Iterator<Item = (usize, &'a mut T)>>
+    where
+        T: 'a,
+    {
+        self.cells
+            .chunks_mut(self.density)
+            .map(|chunk| chunk.iter_mut().map(|v| (v.0, &mut v.1)))
+    }
+
+    #[cfg(feature = "parallel")]
+    fn par_cells<'a>(&'a self) -> impl ParallelIterator<Item = impl Iterator<Item = (usize, &'a T)>>
+    where
+        T: 'a + Send + Sync,
+    {
+        self.cells
+            .par_chunks(self.density)
+            .map(|chunk| chunk.iter().map(|v| (v.0, &v.1)))
+    }
+
+    #[cfg(feature = "parallel")]
+    fn par_cells_mut<'a>(
+        &'a mut self,
+    ) -> impl ParallelIterator<Item = impl Iterator<Item = (usize, &'a mut T)>>
+    where
+        T: 'a + Send + Sync,
+    {
+        self.cells
+            .par_chunks_mut(self.density)
+            .map(|chunk| chunk.iter_mut().map(|v| (v.0, &mut v.1)))
+    }
 }
 
 impl<T, T2> From<&SparseMatrix<T2>> for SparseMatrix<T>
@@ -111,6 +165,22 @@ impl<T: Clone> DenseRowMatrix<T> {
         self.data.chunks_exact_mut(self.num_cols)
     }
 
+    #[cfg(feature = "parallel")]
+    pub fn as_rows_par(&self) -> impl ParallelIterator<Item = &[T]>
+    where
+        T: Send + Sync,
+    {
+        self.data.par_chunks_exact(self.num_cols)
+    }
+
+    #[cfg(feature = "parallel")]
+    pub fn as_rows_mut_par(&mut self) -> impl ParallelIterator<Item = &mut [T]>
+    where
+        T: Send + Sync,
+    {
+        self.data.par_chunks_exact_mut(self.num_cols)
+    }
+
     pub fn to_rows_slices(&self) -> Vec<&[T]> {
         self.as_rows().collect()
     }
@@ -167,6 +237,37 @@ impl<T> Matrix<T> for DenseRowMatrix<T> {
             .chunks_exact(self.num_cols)
             .map(|row| row.iter().enumerate())
     }
+
+    fn cells_mut<'a>(&'a mut self) -> impl Iterator<Item = impl Iterator<Item = (usize, &'a mut T)>>
+    where
+        T: 'a,
+    {
+        self.data
+            .chunks_exact_mut(self.num_cols)
+            .map(|row| row.iter_mut().enumerate())
+    }
+
+    #[cfg(feature = "parallel")]
+    fn par_cells<'a>(&'a self) -> impl ParallelIterator<Item = impl Iterator<Item = (usize, &'a T)>>
+    where
+        T: 'a + Send + Sync,
+    {
+        self.data
+            .par_chunks_exact(self.num_cols)
+            .map(|row| row.iter().enumerate())
+    }
+
+    #[cfg(feature = "parallel")]
+    fn par_cells_mut<'a>(
+        &'a mut self,
+    ) -> impl ParallelIterator<Item = impl Iterator<Item = (usize, &'a mut T)>>
+    where
+        T: 'a + Send + Sync,
+    {
+        self.data
+            .par_chunks_exact_mut(self.num_cols)
+            .map(|row| row.iter_mut().enumerate())
+    }
 }
 
 impl<T> From<Vec<Vec<T>>> for DenseRowMatrix<T> {