Bug fix of ldvt

Author: termoshtt

src/lapack/svd.rs

@@ -47,10 +47,11 @@ macro_rules! impl_svd {
                 let (jvt, ldvt, mut vt) = if calc_vt {
                     (FlagSVD::All, n, vec![Self::zero(); (n * n) as usize])
                 } else {
-                    (FlagSVD::No, 1, Vec::new())
+                    (FlagSVD::No, n, Vec::new())
                 };
                 let mut s = vec![Self::Real::zero(); k as usize];
                 let mut superb = vec![Self::Real::zero(); (k - 1) as usize];
+                dbg!(ldvt);
                 let info = $gesvd(
                     l.lapacke_layout(),
                     ju as u8,
@@ -70,8 +71,8 @@ macro_rules! impl_svd {
                     info,
                     SVDOutput {
                         s: s,
-                        u: if ldu > 0 { Some(u) } else { None },
-                        vt: if ldvt > 0 { Some(vt) } else { None },
+                        u: if calc_u { Some(u) } else { None },
+                        vt: if calc_vt { Some(vt) } else { None },
                     },
                 )
             }

src/svd.rs

@@ -75,8 +75,12 @@ where
         let l = self.layout()?;
         let svd_res = unsafe { A::svd(l, calc_u, calc_vt, self.as_allocated_mut()?)? };
         let (n, m) = l.size();
-        let u = svd_res.u.map(|u| into_matrix(l.resized(n, n), u).unwrap());
-        let vt = svd_res.vt.map(|vt| into_matrix(l.resized(m, m), vt).unwrap());
+        let u = svd_res
+            .u
+            .map(|u| into_matrix(l.resized(n, n), u).expect("Size of U mismatches"));
+        let vt = svd_res
+            .vt
+            .map(|vt| into_matrix(l.resized(m, m), vt).expect("Size of VT mismatches"));
         let s = ArrayBase::from_vec(svd_res.s);
         Ok((u, s, vt))
     }

tests/svd.rs

@@ -19,7 +19,7 @@ fn test(a: &Array2<f64>) {
     assert_close_l2!(&u.dot(&sm).dot(&vt), &answer, 1e-7);
 }
 
-fn test_u(a: &Array2<f64>) {
+fn test_no_vt(a: &Array2<f64>) {
     let (n, _m) = a.dim();
     println!("a = \n{:?}", a);
     let (u, _s, vt): (_, Array1<_>, _) = a.svd(true, false).unwrap();
@@ -30,7 +30,7 @@ fn test_u(a: &Array2<f64>) {
     assert_eq!(u.dim().1, n);
 }
 
-fn test_vt(a: &Array2<f64>) {
+fn test_no_u(a: &Array2<f64>) {
     let (_n, m) = a.dim();
     println!("a = \n{:?}", a);
     let (u, _s, vt): (_, Array1<_>, _) = a.svd(false, true).unwrap();
@@ -60,11 +60,11 @@ macro_rules! test_svd_impl {
 }
 
 test_svd_impl!(test, 3, 3);
-test_svd_impl!(test_u, 3, 3);
-test_svd_impl!(test_vt, 3, 3);
+test_svd_impl!(test_no_vt, 3, 3);
+test_svd_impl!(test_no_u, 3, 3);
 test_svd_impl!(test, 4, 3);
-test_svd_impl!(test_u, 4, 3);
-test_svd_impl!(test_vt, 4, 3);
+test_svd_impl!(test_no_vt, 4, 3);
+test_svd_impl!(test_no_u, 4, 3);
 test_svd_impl!(test, 3, 4);
-test_svd_impl!(test_u, 3, 4);
-test_svd_impl!(test_vt, 3, 4);
+test_svd_impl!(test_no_vt, 3, 4);
+test_svd_impl!(test_no_u, 3, 4);