Simplify SVD

Author: termoshtt

src/svd.rs

@@ -4,58 +4,69 @@ use ndarray::*;
 
 use super::convert::*;
 use super::error::*;
-use super::lapack_traits::LapackScalar;
 use super::layout::*;
+use super::types::*;
 
-pub trait SVD<U, S, VT> {
-    fn svd(self, calc_u: bool, calc_vt: bool) -> Result<(Option<U>, S, Option<VT>)>;
+pub trait SVD {
+    type U;
+    type VT;
+    type Sigma;
+    fn svd(&self, calc_u: bool, calc_vt: bool) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)>;
 }
 
-impl<A, S, Su, Svt, Ss> SVD<ArrayBase<Su, Ix2>, ArrayBase<Ss, Ix1>, ArrayBase<Svt, Ix2>> for ArrayBase<S, Ix2>
-    where A: LapackScalar,
-          S: DataMut<Elem = A>,
-          Su: DataOwned<Elem = A>,
-          Svt: DataOwned<Elem = A>,
-          Ss: DataOwned<Elem = A::Real>
+pub trait SVDInto {
+    type U;
+    type VT;
+    type Sigma;
+    fn svd_into(self, calc_u: bool, calc_vt: bool) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)>;
+}
+
+pub trait SVDMut {
+    type U;
+    type VT;
+    type Sigma;
+    fn svd_mut(&mut self, calc_u: bool, calc_vt: bool) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)>;
+}
+
+impl<A, S> SVDInto for ArrayBase<S, Ix2>
+where
+    A: Scalar,
+    S: DataMut<Elem = A>,
 {
-    fn svd(mut self,
-           calc_u: bool,
-           calc_vt: bool)
-           -> Result<(Option<ArrayBase<Su, Ix2>>, ArrayBase<Ss, Ix1>, Option<ArrayBase<Svt, Ix2>>)> {
-        (&mut self).svd(calc_u, calc_vt)
+    type U = Array2<A>;
+    type VT = Array2<A>;
+    type Sigma = Array1<A::Real>;
+
+    fn svd_into(mut self, calc_u: bool, calc_vt: bool) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)> {
+        self.svd_mut(calc_u, calc_vt)
     }
 }
 
-impl<'a, A, S, Su, Svt, Ss> SVD<ArrayBase<Su, Ix2>, ArrayBase<Ss, Ix1>, ArrayBase<Svt, Ix2>> for &'a ArrayBase<S, Ix2>
-    where A: LapackScalar + Clone,
-          S: Data<Elem = A>,
-          Su: DataOwned<Elem = A>,
-          Svt: DataOwned<Elem = A>,
-          Ss: DataOwned<Elem = A::Real>
+impl<A, S> SVD for ArrayBase<S, Ix2>
+where
+    A: Scalar,
+    S: Data<Elem = A>,
 {
-    fn svd(self,
-           calc_u: bool,
-           calc_vt: bool)
-           -> Result<(Option<ArrayBase<Su, Ix2>>, ArrayBase<Ss, Ix1>, Option<ArrayBase<Svt, Ix2>>)> {
+    type U = Array2<A>;
+    type VT = Array2<A>;
+    type Sigma = Array1<A::Real>;
+
+    fn svd(&self, calc_u: bool, calc_vt: bool) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)> {
         let a = self.to_owned();
-        a.svd(calc_u, calc_vt)
+        a.svd_into(calc_u, calc_vt)
     }
 }
 
-impl<'a, A, S, Su, Svt, Ss> SVD<ArrayBase<Su, Ix2>, ArrayBase<Ss, Ix1>, ArrayBase<Svt, Ix2>>
-    for &'a mut ArrayBase<S, Ix2>
+impl<A, S> SVDMut for ArrayBase<S, Ix2>
 where
-    A: LapackScalar,
+    A: Scalar,
     S: DataMut<Elem = A>,
-    Su: DataOwned<Elem = A>,
-    Svt: DataOwned<Elem = A>,
-    Ss: DataOwned<Elem = A::Real>,
 {
-    fn svd(
-        mut self,
-        calc_u: bool,
-        calc_vt: bool,
-    ) -> Result<(Option<ArrayBase<Su, Ix2>>, ArrayBase<Ss, Ix1>, Option<ArrayBase<Svt, Ix2>>)> {
+    type U = Array2<A>;
+    type VT = Array2<A>;
+    type Sigma = Array1<A::Real>;
+
+    fn svd_mut(&mut self, calc_u: bool, calc_vt: bool) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)> {
         let l = self.layout()?;
         let svd_res = A::svd(l, calc_u, calc_vt, self.as_allocated_mut()?)?;
         let (n, m) = l.size();