feat: + cluster metrics

src/linalg/mod.rs

@@ -110,10 +110,20 @@ pub trait BaseMatrix<T: RealNumber>: Clone + Debug {
     /// * `row` - row number
     fn get_row_as_vec(&self, row: usize) -> Vec<T>;
 
+    /// Copies a vector with elements of the `row`'th row into `result`
+    /// * `row` - row number
+    /// * `result` - receiver for the row
+    fn copy_row_as_vec(&self, row: usize, result: &mut Vec<T>);
+
     /// Get a vector with elements of the `col`'th column
     /// * `col` - column number
     fn get_col_as_vec(&self, col: usize) -> Vec<T>;
 
+    /// Copies a vector with elements of the `col`'th column into `result`
+    /// * `col` - column number
+    /// * `result` - receiver for the col
+    fn copy_col_as_vec(&self, col: usize, result: &mut Vec<T>);
+
     /// Set an element at `col`, `row` to `x`
     fn set(&mut self, row: usize, col: usize, x: T);
 

src/linalg/naive/dense_matrix.rs

@@ -54,6 +54,16 @@ pub struct DenseMatrix<T: RealNumber> {
     values: Vec<T>,
 }
 
+/// Column-major, dense matrix. See [Simple Dense Matrix](../index.html).
+#[derive(Debug)]
+pub struct DenseMatrixIterator<'a, T: RealNumber> {
+    cur_c: usize,
+    cur_r: usize,
+    max_c: usize,
+    max_r: usize,
+    m: &'a DenseMatrix<T>,
+}
+
 impl<T: RealNumber> fmt::Display for DenseMatrix<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut rows: Vec<Vec<f64>> = Vec::new();
@@ -162,6 +172,36 @@ impl<T: RealNumber> DenseMatrix<T> {
             values: values,
         }
     }
+
+    /// Creates new column vector (_1xN_ matrix) from a vector.     
+    /// * `values` - values to initialize the matrix.
+    pub fn iter<'a>(&'a self) -> DenseMatrixIterator<'a, T> {
+        DenseMatrixIterator {
+            cur_c: 0,
+            cur_r: 0,
+            max_c: self.ncols,
+            max_r: self.nrows,
+            m: &self,
+        }
+    }
+}
+
+impl<'a, T: RealNumber> Iterator for DenseMatrixIterator<'a, T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<T> {
+        if self.cur_r * self.max_c + self.cur_c >= self.max_c * self.max_r {
+            None
+        } else {
+            let v = self.m.get(self.cur_r, self.cur_c);
+            self.cur_c += 1;
+            if self.cur_c >= self.max_c {
+                self.cur_c = 0;
+                self.cur_r += 1;
+            }
+            Some(v)
+        }
+    }
 }
 
 impl<'de, T: RealNumber + fmt::Debug + Deserialize<'de>> Deserialize<'de> for DenseMatrix<T> {
@@ -339,6 +379,12 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
         result
     }
 
+    fn copy_row_as_vec(&self, row: usize, result: &mut Vec<T>) {
+        for c in 0..self.ncols {
+            result[c] = self.get(row, c);
+        }
+    }
+
     fn get_col_as_vec(&self, col: usize) -> Vec<T> {
         let mut result = vec![T::zero(); self.nrows];
         for r in 0..self.nrows {
@@ -347,6 +393,12 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
         result
     }
 
+    fn copy_col_as_vec(&self, col: usize, result: &mut Vec<T>) {
+        for r in 0..self.nrows {
+            result[r] = self.get(r, col);
+        }
+    }
+
     fn set(&mut self, row: usize, col: usize, x: T) {
         self.values[col * self.nrows + row] = x;
     }
@@ -852,6 +904,13 @@ mod tests {
         );
     }
 
+    #[test]
+    fn iter() {
+        let vec = vec![1., 2., 3., 4., 5., 6.];
+        let m = DenseMatrix::from_array(3, 2, &vec);
+        assert_eq!(vec, m.iter().collect::<Vec<f32>>());
+    }
+
     #[test]
     fn v_stack() {
         let a = DenseMatrix::from_2d_array(&[&[1., 2., 3.], &[4., 5., 6.], &[7., 8., 9.]]);

src/linalg/nalgebra_bindings.rs

@@ -102,10 +102,26 @@ impl<T: RealNumber + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Su
         self.row(row).iter().map(|v| *v).collect()
     }
 
+    fn copy_row_as_vec(&self, row: usize, result: &mut Vec<T>) {
+        let mut r = 0;
+        for e in self.row(row).iter() {
+            result[r] = *e;
+            r += 1;
+        }
+    }
+
     fn get_col_as_vec(&self, col: usize) -> Vec<T> {
         self.column(col).iter().map(|v| *v).collect()
     }
 
+    fn copy_col_as_vec(&self, col: usize, result: &mut Vec<T>) {
+        let mut r = 0;
+        for e in self.column(col).iter() {
+            result[r] = *e;
+            r += 1;
+        }
+    }
+
     fn set(&mut self, row: usize, col: usize, x: T) {
         *self.get_mut((row, col)).unwrap() = x;
     }
@@ -563,6 +579,17 @@ mod tests {
         assert_eq!(m.get_col_as_vec(1), vec!(2., 5., 8.));
     }
 
+    #[test]
+    fn copy_row_col_as_vec() {
+        let m = DMatrix::from_row_slice(3, 3, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]);
+        let mut v = vec![0f32; 3];
+
+        m.copy_row_as_vec(1, &mut v);
+        assert_eq!(v, vec!(4., 5., 6.));
+        m.copy_col_as_vec(1, &mut v);
+        assert_eq!(v, vec!(2., 5., 8.));
+    }
+
     #[test]
     fn element_add_sub_mul_div() {
         let mut m = DMatrix::from_row_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);

src/linalg/ndarray_bindings.rs

@@ -109,10 +109,26 @@ impl<T: RealNumber + ScalarOperand + AddAssign + SubAssign + MulAssign + DivAssi
         self.row(row).to_vec()
     }
 
+    fn copy_row_as_vec(&self, row: usize, result: &mut Vec<T>) {
+        let mut r = 0;
+        for e in self.row(row).iter() {
+            result[r] = *e;
+            r += 1;
+        }
+    }
+
     fn get_col_as_vec(&self, col: usize) -> Vec<T> {
         self.column(col).to_vec()
     }
 
+    fn copy_col_as_vec(&self, col: usize, result: &mut Vec<T>) {
+        let mut r = 0;
+        for e in self.column(col).iter() {
+            result[r] = *e;
+            r += 1;
+        }
+    }
+
     fn set(&mut self, row: usize, col: usize, x: T) {
         self[[row, col]] = x;
     }
@@ -669,6 +685,17 @@ mod tests {
         assert_eq!(res, vec![2., 5., 8.]);
     }
 
+    #[test]
+    fn copy_row_col_as_vec() {
+        let m = arr2(&[[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]);
+        let mut v = vec![0f32; 3];
+
+        m.copy_row_as_vec(1, &mut v);
+        assert_eq!(v, vec!(4., 5., 6.));
+        m.copy_col_as_vec(1, &mut v);
+        assert_eq!(v, vec!(2., 5., 8.));
+    }
+
     #[test]
     fn col_mean() {
         let a = arr2(&[[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]);