Simplify Cholesky

Author: termoshtt

src/cholesky.rs

@@ -1,49 +1,58 @@
 //! Cholesky decomposition
 
 use ndarray::*;
-use num_traits::Zero;
 
 use super::convert::*;
 use super::error::*;
 use super::layout::*;
 use super::triangular::IntoTriangular;
+use super::types::*;
 
-use lapack_traits::LapackScalar;
 pub use lapack_traits::UPLO;
 
-pub trait Cholesky<K> {
-    fn cholesky(self, UPLO) -> Result<K>;
+pub trait Cholesky {
+    type Output;
+    fn cholesky(&self, UPLO) -> Result<Self::Output>;
 }
 
-impl<A, S> Cholesky<ArrayBase<S, Ix2>> for ArrayBase<S, Ix2>
+pub trait CholeskyInto: Sized {
+    fn cholesky_into(self, UPLO) -> Result<Self>;
+}
+
+pub trait CholeskyMut {
+    fn cholesky_mut(&mut self, UPLO) -> Result<&mut Self>;
+}
+
+impl<A, S> CholeskyInto for ArrayBase<S, Ix2>
 where
-    A: LapackScalar + Zero,
+    A: Scalar,
     S: DataMut<Elem = A>,
 {
-    fn cholesky(mut self, uplo: UPLO) -> Result<ArrayBase<S, Ix2>> {
+    fn cholesky_into(mut self, uplo: UPLO) -> Result<Self> {
         A::cholesky(self.square_layout()?, uplo, self.as_allocated_mut()?)?;
         Ok(self.into_triangular(uplo))
     }
 }
 
-impl<'a, A, S> Cholesky<&'a mut ArrayBase<S, Ix2>> for &'a mut ArrayBase<S, Ix2>
+impl<A, S> CholeskyMut for ArrayBase<S, Ix2>
 where
-    A: LapackScalar + Zero,
+    A: Scalar,
     S: DataMut<Elem = A>,
 {
-    fn cholesky(mut self, uplo: UPLO) -> Result<&'a mut ArrayBase<S, Ix2>> {
+    fn cholesky_mut(&mut self, uplo: UPLO) -> Result<&mut Self> {
         A::cholesky(self.square_layout()?, uplo, self.as_allocated_mut()?)?;
         Ok(self.into_triangular(uplo))
     }
 }
 
-impl<'a, A, Si, So> Cholesky<ArrayBase<So, Ix2>> for &'a ArrayBase<Si, Ix2>
+impl<A, S> Cholesky for ArrayBase<S, Ix2>
 where
-    A: LapackScalar + Copy + Zero,
-    Si: Data<Elem = A>,
-    So: DataMut<Elem = A> + DataOwned,
+    A: Scalar,
+    S: Data<Elem = A>,
 {
-    fn cholesky(self, uplo: UPLO) -> Result<ArrayBase<So, Ix2>> {
+    type Output = Array2<A>;
+
+    fn cholesky(&self, uplo: UPLO) -> Result<Self::Output> {
         let mut a = replicate(self);
         A::cholesky(a.square_layout()?, uplo, a.as_allocated_mut()?)?;
         Ok(a.into_triangular(uplo))