Use convert::into_matrix

Author: termoshtt

ndarray-linalg/src/svddc.rs

@@ -1,11 +1,8 @@
 //! Singular-value decomposition (SVD) by divide-and-conquer (?gesdd)
 
+use super::{convert::*, error::*, layout::*, types::*};
 use ndarray::*;
 
-use super::error::*;
-use super::layout::*;
-use super::types::*;
-
 pub use lapack::svddc::UVTFlag;
 
 /// Singular-value decomposition of matrix (copying) by divide-and-conquer
@@ -84,35 +81,22 @@ where
     ) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)> {
         let l = self.layout()?;
         let svd_res = unsafe { A::svddc(l, uvt_flag, self.as_allocated_mut()?)? };
-        let (n, m) = l.size();
-        let k = std::cmp::min(n, m);
-        let n = n as usize;
-        let m = m as usize;
-        let k = k as usize;
+        let (m, n) = l.size();
+        let k = m.min(n);
 
         let (u_col, vt_row) = match uvt_flag {
-            UVTFlag::Full => (n, m),
+            UVTFlag::Full => (m, n),
             UVTFlag::Some => (k, k),
             UVTFlag::None => (0, 0),
         };
 
-        let u = svd_res.u.map(|u| {
-            assert_eq!(u.len(), n * u_col);
-            match l {
-                MatrixLayout::F { .. } => Array::from_shape_vec((n, u_col).f(), u),
-                MatrixLayout::C { .. } => Array::from_shape_vec((n, u_col), u),
-            }
-            .unwrap()
-        });
+        let u = svd_res
+            .u
+            .map(|u| into_matrix(l.resized(m, u_col), u).unwrap());
 
-        let vt = svd_res.vt.map(|vt| {
-            assert_eq!(vt.len(), m * vt_row);
-            match l {
-                MatrixLayout::F { .. } => Array::from_shape_vec((vt_row, m).f(), vt),
-                MatrixLayout::C { .. } => Array::from_shape_vec((vt_row, m), vt),
-            }
-            .unwrap()
-        });
+        let vt = svd_res
+            .vt
+            .map(|vt| into_matrix(l.resized(vt_row, n), vt).unwrap());
 
         let s = ArrayBase::from(svd_res.s);
         Ok((u, s, vt))