Rename UVTFlag to JobSvd, and Full to All

Author: termoshtt

lax/src/flags.rs

@@ -95,26 +95,26 @@ impl JobEv {
 /// For an input array of shape *m*×*n*, the following are computed:
 #[derive(Clone, Copy, Eq, PartialEq)]
 #[repr(u8)]
-pub enum UVTFlag {
+pub enum JobSvd {
     /// All *m* columns of *U* and all *n* rows of *V*ᵀ.
-    Full = b'A',
+    All = b'A',
     /// The first min(*m*,*n*) columns of *U* and the first min(*m*,*n*) rows of *V*ᵀ.
     Some = b'S',
     /// No columns of *U* or rows of *V*ᵀ.
     None = b'N',
 }
 
-impl UVTFlag {
+impl JobSvd {
     pub fn from_bool(calc_uv: bool) -> Self {
         if calc_uv {
-            UVTFlag::Full
+            JobSvd::All
         } else {
-            UVTFlag::None
+            JobSvd::None
         }
     }
 
     pub fn as_ptr(&self) -> *const i8 {
-        self as *const UVTFlag as *const i8
+        self as *const JobSvd as *const i8
     }
 }
 

lax/src/svd.rs

@@ -32,25 +32,25 @@ macro_rules! impl_svd {
         impl SVD_ for $scalar {
             fn svd(l: MatrixLayout, calc_u: bool, calc_vt: bool, a: &mut [Self],) -> Result<SVDOutput<Self>> {
                 let ju = match l {
-                    MatrixLayout::F { .. } => UVTFlag::from_bool(calc_u),
-                    MatrixLayout::C { .. } => UVTFlag::from_bool(calc_vt),
+                    MatrixLayout::F { .. } => JobSvd::from_bool(calc_u),
+                    MatrixLayout::C { .. } => JobSvd::from_bool(calc_vt),
                 };
                 let jvt = match l {
-                    MatrixLayout::F { .. } => UVTFlag::from_bool(calc_vt),
-                    MatrixLayout::C { .. } => UVTFlag::from_bool(calc_u),
+                    MatrixLayout::F { .. } => JobSvd::from_bool(calc_vt),
+                    MatrixLayout::C { .. } => JobSvd::from_bool(calc_u),
                 };
 
                 let m = l.lda();
                 let mut u = match ju {
-                    UVTFlag::Full => Some(unsafe { vec_uninit( (m * m) as usize) }),
-                    UVTFlag::None => None,
+                    JobSvd::All => Some(unsafe { vec_uninit( (m * m) as usize) }),
+                    JobSvd::None => None,
                     _ => unimplemented!("SVD with partial vector output is not supported yet")
                 };
 
                 let n = l.len();
                 let mut vt = match jvt {
-                    UVTFlag::Full => Some(unsafe { vec_uninit( (n * n) as usize) }),
-                    UVTFlag::None => None,
+                    JobSvd::All => Some(unsafe { vec_uninit( (n * n) as usize) }),
+                    JobSvd::None => None,
                     _ => unimplemented!("SVD with partial vector output is not supported yet")
                 };
 

lax/src/svddc.rs

@@ -3,7 +3,7 @@ use cauchy::*;
 use num_traits::{ToPrimitive, Zero};
 
 pub trait SVDDC_: Scalar {
-    fn svddc(l: MatrixLayout, jobz: UVTFlag, a: &mut [Self]) -> Result<SVDOutput<Self>>;
+    fn svddc(l: MatrixLayout, jobz: JobSvd, a: &mut [Self]) -> Result<SVDOutput<Self>>;
 }
 
 macro_rules! impl_svddc {
@@ -15,33 +15,33 @@ macro_rules! impl_svddc {
     };
     (@body, $scalar:ty, $gesdd:path, $($rwork_ident:ident),*) => {
         impl SVDDC_ for $scalar {
-            fn svddc(l: MatrixLayout, jobz: UVTFlag, a: &mut [Self],) -> Result<SVDOutput<Self>> {
+            fn svddc(l: MatrixLayout, jobz: JobSvd, a: &mut [Self],) -> Result<SVDOutput<Self>> {
                 let m = l.lda();
                 let n = l.len();
                 let k = m.min(n);
                 let mut s = unsafe { vec_uninit( k as usize) };
 
                 let (u_col, vt_row) = match jobz {
-                    UVTFlag::Full | UVTFlag::None => (m, n),
-                    UVTFlag::Some => (k, k),
+                    JobSvd::All | JobSvd::None => (m, n),
+                    JobSvd::Some => (k, k),
                 };
                 let (mut u, mut vt) = match jobz {
-                    UVTFlag::Full => (
+                    JobSvd::All => (
                         Some(unsafe { vec_uninit( (m * m) as usize) }),
                         Some(unsafe { vec_uninit( (n * n) as usize) }),
                     ),
-                    UVTFlag::Some => (
+                    JobSvd::Some => (
                         Some(unsafe { vec_uninit( (m * u_col) as usize) }),
                         Some(unsafe { vec_uninit( (n * vt_row) as usize) }),
                     ),
-                    UVTFlag::None => (None, None),
+                    JobSvd::None => (None, None),
                 };
 
                 $( // for complex only
                 let mx = n.max(m) as usize;
                 let mn = n.min(m) as usize;
                 let lrwork = match jobz {
-                    UVTFlag::None => 7 * mn,
+                    JobSvd::None => 7 * mn,
                     _ => std::cmp::max(5*mn*mn + 5*mn, 2*mx*mn + 2*mn*mn + mn),
                 };
                 let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit( lrwork) };

ndarray-linalg/src/svddc.rs

@@ -3,14 +3,14 @@
 use super::{convert::*, error::*, layout::*, types::*};
 use ndarray::*;
 
-pub use lax::UVTFlag;
+pub use lax::JobSvd;
 
 /// Singular-value decomposition of matrix (copying) by divide-and-conquer
 pub trait SVDDC {
     type U;
     type VT;
     type Sigma;
-    fn svddc(&self, uvt_flag: UVTFlag) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)>;
+    fn svddc(&self, uvt_flag: JobSvd) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)>;
 }
 
 /// Singular-value decomposition of matrix by divide-and-conquer
@@ -20,7 +20,7 @@ pub trait SVDDCInto {
     type Sigma;
     fn svddc_into(
         self,
-        uvt_flag: UVTFlag,
+        uvt_flag: JobSvd,
     ) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)>;
 }
 
@@ -31,7 +31,7 @@ pub trait SVDDCInplace {
     type Sigma;
     fn svddc_inplace(
         &mut self,
-        uvt_flag: UVTFlag,
+        uvt_flag: JobSvd,
     ) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)>;
 }
 
@@ -44,7 +44,7 @@ where
     type VT = Array2<A>;
     type Sigma = Array1<A::Real>;
 
-    fn svddc(&self, uvt_flag: UVTFlag) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)> {
+    fn svddc(&self, uvt_flag: JobSvd) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)> {
         self.to_owned().svddc_into(uvt_flag)
     }
 }
@@ -60,7 +60,7 @@ where
 
     fn svddc_into(
         mut self,
-        uvt_flag: UVTFlag,
+        uvt_flag: JobSvd,
     ) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)> {
         self.svddc_inplace(uvt_flag)
     }
@@ -77,17 +77,17 @@ where
 
     fn svddc_inplace(
         &mut self,
-        uvt_flag: UVTFlag,
+        uvt_flag: JobSvd,
     ) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)> {
         let l = self.layout()?;
         let svd_res = A::svddc(l, uvt_flag, self.as_allocated_mut()?)?;
         let (m, n) = l.size();
         let k = m.min(n);
 
         let (u_col, vt_row) = match uvt_flag {
-            UVTFlag::Full => (m, n),
-            UVTFlag::Some => (k, k),
-            UVTFlag::None => (0, 0),
+            JobSvd::All => (m, n),
+            JobSvd::Some => (k, k),
+            JobSvd::None => (0, 0),
         };
 
         let u = svd_res

ndarray-linalg/tests/svddc.rs

@@ -1,16 +1,16 @@
 use ndarray::*;
 use ndarray_linalg::*;
 
-fn test<T: Scalar + Lapack>(a: &Array2<T>, flag: UVTFlag) {
+fn test<T: Scalar + Lapack>(a: &Array2<T>, flag: JobSvd) {
     let (n, m) = a.dim();
     let k = n.min(m);
     let answer = a.clone();
     println!("a = \n{:?}", a);
     let (u, s, vt): (_, Array1<_>, _) = a.svddc(flag).unwrap();
     let mut sm: Array2<T> = match flag {
-        UVTFlag::Full => Array::zeros((n, m)),
-        UVTFlag::Some => Array::zeros((k, k)),
-        UVTFlag::None => {
+        JobSvd::All => Array::zeros((n, m)),
+        JobSvd::Some => Array::zeros((k, k)),
+        JobSvd::None => {
             assert!(u.is_none());
             assert!(vt.is_none());
             return;
@@ -33,37 +33,37 @@ macro_rules! test_svd_impl {
             #[test]
             fn [<svddc_ $scalar _full_ $n x $m>]() {
                 let a = random(($n, $m));
-                test::<$scalar>(&a, UVTFlag::Full);
+                test::<$scalar>(&a, JobSvd::All);
             }
 
             #[test]
             fn [<svddc_ $scalar _some_ $n x $m>]() {
                 let a = random(($n, $m));
-                test::<$scalar>(&a, UVTFlag::Some);
+                test::<$scalar>(&a, JobSvd::Some);
             }
 
             #[test]
             fn [<svddc_ $scalar _none_ $n x $m>]() {
                 let a = random(($n, $m));
-                test::<$scalar>(&a, UVTFlag::None);
+                test::<$scalar>(&a, JobSvd::None);
             }
 
             #[test]
             fn [<svddc_ $scalar _full_ $n x $m _t>]() {
                 let a = random(($n, $m).f());
-                test::<$scalar>(&a, UVTFlag::Full);
+                test::<$scalar>(&a, JobSvd::All);
             }
 
             #[test]
             fn [<svddc_ $scalar _some_ $n x $m _t>]() {
                 let a = random(($n, $m).f());
-                test::<$scalar>(&a, UVTFlag::Some);
+                test::<$scalar>(&a, JobSvd::Some);
             }
 
             #[test]
             fn [<svddc_ $scalar _none_ $n x $m _t>]() {
                 let a = random(($n, $m).f());
-                test::<$scalar>(&a, UVTFlag::None);
+                test::<$scalar>(&a, JobSvd::None);
             }
         }
     };