use ::{Real, Dim, Matrix, VectorN, RowVectorN, DefaultAllocator, U1, VectorSliceN}; use storage::Storage; use allocator::Allocator; impl> Matrix { /// Returns a row vector where each element is the result of the application of `f` on the /// corresponding column of the original matrix. #[inline] pub fn compress_rows(&self, f: impl Fn(VectorSliceN) -> N) -> RowVectorN where DefaultAllocator: Allocator { let ncols = self.data.shape().1; let mut res = unsafe { RowVectorN::new_uninitialized_generic(U1, ncols) }; for i in 0..ncols.value() { // FIXME: avoid bound checking of column. unsafe { *res.get_unchecked_mut((0, i)) = f(self.column(i)); } } res } /// Returns a column vector where each element is the result of the application of `f` on the /// corresponding column of the original matrix. /// /// This is the same as `self.compress_rows(f).transpose()`. #[inline] pub fn compress_rows_tr(&self, f: impl Fn(VectorSliceN) -> N) -> VectorN where DefaultAllocator: Allocator { let ncols = self.data.shape().1; let mut res = unsafe { VectorN::new_uninitialized_generic(ncols, U1) }; for i in 0..ncols.value() { // FIXME: avoid bound checking of column. unsafe { *res.vget_unchecked_mut(i) = f(self.column(i)); } } res } /// Returns a column vector resulting from the folding of `f` on each column of this matrix. #[inline] pub fn compress_columns(&self, init: VectorN, f: impl Fn(&mut VectorN, VectorSliceN)) -> VectorN where DefaultAllocator: Allocator { let mut res = init; for i in 0..self.ncols() { f(&mut res, self.column(i)) } res } } impl> Matrix { /* * * Sum computation. * */ /// The sum of all the elements of this matrix. /// /// # Example /// /// ``` /// # use nalgebra::Matrix2x3; /// /// let m = Matrix2x3::new(1.0, 2.0, 3.0, /// 4.0, 5.0, 6.0); /// assert_eq!(m.sum(), 21.0); /// ``` #[inline] pub fn sum(&self) -> N { self.iter().cloned().fold(N::zero(), |a, b| a + b) } /// The sum of all the rows of this matrix. /// # Example /// /// ``` /// # use nalgebra::{Matrix2x3, RowVector3}; /// /// let m = Matrix2x3::new(1.0, 2.0, 3.0, /// 4.0, 5.0, 6.0); /// assert_eq!(m.row_sum(), RowVector3::new(5.0, 7.0, 9.0)); /// ``` #[inline] pub fn row_sum(&self) -> RowVectorN where DefaultAllocator: Allocator { self.compress_rows(|col| col.sum()) } /// The sum of all the rows of this matrix. The result is transposed and returned as a column vector. /// /// # Example /// /// ``` /// # use nalgebra::{Matrix2x3, Vector3}; /// /// let m = Matrix2x3::new(1.0, 2.0, 3.0, /// 4.0, 5.0, 6.0); /// assert_eq!(m.row_sum_tr(), Vector3::new(5.0, 7.0, 9.0)); /// ``` #[inline] pub fn row_sum_tr(&self) -> VectorN where DefaultAllocator: Allocator { self.compress_rows_tr(|col| col.sum()) } /// The sum of all the columns of this matrix. /// /// # Example /// /// ``` /// # use nalgebra::{Matrix2x3, Vector2}; /// /// let m = Matrix2x3::new(1.0, 2.0, 3.0, /// 4.0, 5.0, 6.0); /// assert_eq!(m.column_sum(), Vector2::new(6.0, 15.0)); /// ``` #[inline] pub fn column_sum(&self) -> VectorN where DefaultAllocator: Allocator { let nrows = self.data.shape().0; self.compress_columns(VectorN::zeros_generic(nrows, U1), |out, col| { out.axpy(N::one(), &col, N::one()) }) } /* * * Variance computation. * */ /// The variance of all the elements of this matrix. /// /// # Example /// /// ``` /// # use nalgebra::Matrix2x3; /// /// let m = Matrix2x3::new(1.0, 2.0, 3.0, /// 4.0, 5.0, 6.0); /// assert_eq!(m.variance(), 3.5); /// ``` #[inline] pub fn variance(&self) -> N { if self.len() == 0 { N::zero() } else { let val = self.iter().cloned().fold((N::zero(), N::zero()), |a, b| (a.0 + b * b, a.1 + b)); let denom = N::one() / ::convert::<_, N>(self.len() as f64); val.0 * denom - (val.1 * denom) * (val.1 * denom) } } /// The variance of all the rows of this matrix. /// # Example /// /// ``` /// # use nalgebra::{Matrix2x3, RowVector3}; /// /// let m = Matrix2x3::new(1.0, 2.0, 3.0, /// 4.0, 5.0, 6.0); /// assert_eq!(m.row_variance(), RowVector3::new(4.5, 4.5, 4.5)); /// ``` #[inline] pub fn row_variance(&self) -> RowVectorN where DefaultAllocator: Allocator { self.compress_rows(|col| col.variance()) } /// The variance of all the rows of this matrix. The result is transposed and returned as a column vector. /// /// # Example /// /// ``` /// # use nalgebra::{Matrix2x3, Vector3}; /// /// let m = Matrix2x3::new(1.0, 2.0, 3.0, /// 4.0, 5.0, 6.0); /// assert_eq!(m.row_variance_tr(), Vector3::new(4.5, 4.5, 4.5)); /// ``` #[inline] pub fn row_variance_tr(&self) -> VectorN where DefaultAllocator: Allocator { self.compress_rows_tr(|col| col.variance()) } /// The variance of all the columns of this matrix. /// /// # Example /// /// ``` /// # #[macro_use] extern crate approx; /// # use nalgebra::{Matrix2x3, Vector2}; /// /// let m = Matrix2x3::new(1.0, 2.0, 3.0, /// 4.0, 5.0, 6.0); /// assert_relative_eq!(m.column_variance(), Vector2::new(2.0 / 3.0, 2.0 / 3.0), epsilon = 1.0e-8); /// ``` #[inline] pub fn column_variance(&self) -> VectorN where DefaultAllocator: Allocator { let (nrows, ncols) = self.data.shape(); let mut mean = self.column_mean(); mean.apply(|e| -(e * e)); let denom = N::one() / ::convert::<_, N>(ncols.value() as f64); self.compress_columns(mean, |out, col| { for i in 0..nrows.value() { unsafe { let val = col.vget_unchecked(i); *out.vget_unchecked_mut(i) += denom * *val * *val } } }) } /* * * Mean computation. * */ /// The mean of all the elements of this matrix. /// /// # Example /// /// ``` /// # use nalgebra::Matrix2x3; /// /// let m = Matrix2x3::new(1.0, 2.0, 3.0, /// 4.0, 5.0, 6.0); /// assert_eq!(m.mean(), 3.5); /// ``` #[inline] pub fn mean(&self) -> N { if self.len() == 0 { N::zero() } else { self.sum() / ::convert(self.len() as f64) } } /// The mean of all the rows of this matrix. /// /// # Example /// /// ``` /// # use nalgebra::{Matrix2x3, RowVector3}; /// /// let m = Matrix2x3::new(1.0, 2.0, 3.0, /// 4.0, 5.0, 6.0); /// assert_eq!(m.row_mean(), RowVector3::new(2.5, 3.5, 4.5)); /// ``` #[inline] pub fn row_mean(&self) -> RowVectorN where DefaultAllocator: Allocator { self.compress_rows(|col| col.mean()) } /// The mean of all the rows of this matrix. The result is transposed and returned as a column vector. /// /// # Example /// /// ``` /// # use nalgebra::{Matrix2x3, Vector3}; /// /// let m = Matrix2x3::new(1.0, 2.0, 3.0, /// 4.0, 5.0, 6.0); /// assert_eq!(m.row_mean_tr(), Vector3::new(2.5, 3.5, 4.5)); /// ``` #[inline] pub fn row_mean_tr(&self) -> VectorN where DefaultAllocator: Allocator { self.compress_rows_tr(|col| col.mean()) } /// The mean of all the columns of this matrix. /// /// # Example /// /// ``` /// # use nalgebra::{Matrix2x3, Vector2}; /// /// let m = Matrix2x3::new(1.0, 2.0, 3.0, /// 4.0, 5.0, 6.0); /// assert_eq!(m.column_mean(), Vector2::new(2.0, 5.0)); /// ``` #[inline] pub fn column_mean(&self) -> VectorN where DefaultAllocator: Allocator { let (nrows, ncols) = self.data.shape(); let denom = N::one() / ::convert::<_, N>(ncols.value() as f64); self.compress_columns(VectorN::zeros_generic(nrows, U1), |out, col| { out.axpy(denom, &col, N::one()) }) } }