Use move in TriangularMatrix

Author: termoshtt

src/square.rs

@@ -30,6 +30,12 @@ pub trait SquareMatrix: Matrix {
             })
         }
     }
+    /// test matrix is square and return its size
+    fn square_size(&self) -> Result<usize, NotSquareError> {
+        self.check_square()?;
+        let (n, _) = self.size();
+        Ok(n)
+    }
 }
 
 fn trace<A: MFloat, S>(a: &ArrayBase<S, Ix2>) -> A

src/triangular.rs

@@ -1,5 +1,5 @@
 
-use ndarray::{Data, Ix1, Ix2, Array, RcArray, NdFloat, ArrayBase, DataMut};
+use ndarray::{Ix1, Ix2, Array, RcArray, NdFloat, ArrayBase, DataMut};
 
 use matrix::{Matrix, MFloat};
 use square::SquareMatrix;
@@ -9,49 +9,39 @@ use solve::ImplSolve;
 pub trait TriangularMatrix<Rhs>: Matrix + SquareMatrix {
     type Output;
     /// solve a triangular system with upper triangular matrix
-    fn solve_upper(&self, &Rhs) -> Result<Self::Output, LinalgError>;
+    fn solve_upper(&self, Rhs) -> Result<Self::Output, LinalgError>;
     /// solve a triangular system with lower triangular matrix
-    fn solve_lower(&self, &Rhs) -> Result<Self::Output, LinalgError>;
+    fn solve_lower(&self, Rhs) -> Result<Self::Output, LinalgError>;
 }
 
-impl<A, S> TriangularMatrix<ArrayBase<S, Ix1>> for Array<A, Ix2>
-    where A: MFloat,
-          S: Data<Elem = A>
-{
+impl<A: MFloat> TriangularMatrix<Array<A, Ix1>> for Array<A, Ix2> {
     type Output = Array<A, Ix1>;
-
-    fn solve_upper(&self, b: &ArrayBase<S, Ix1>) -> Result<Self::Output, LinalgError> {
-        self.check_square()?;
-        let (n, _) = self.size();
+    fn solve_upper(&self, b: Array<A, Ix1>) -> Result<Self::Output, LinalgError> {
+        let n = self.square_size()?;
         let layout = self.layout()?;
         let a = self.as_slice_memory_order().unwrap();
-        let x = ImplSolve::solve_triangle(layout, 'U' as u8, n, a, b.to_owned().into_raw_vec(), 1)?;
+        let x = ImplSolve::solve_triangle(layout, 'U' as u8, n, a, b.into_raw_vec(), 1)?;
         Ok(Array::from_vec(x))
     }
-    fn solve_lower(&self, b: &ArrayBase<S, Ix1>) -> Result<Self::Output, LinalgError> {
-        self.check_square()?;
-        let (n, _) = self.size();
+    fn solve_lower(&self, b: Array<A, Ix1>) -> Result<Self::Output, LinalgError> {
+        let n = self.square_size()?;
         let layout = self.layout()?;
         let a = self.as_slice_memory_order().unwrap();
-        let x = ImplSolve::solve_triangle(layout, 'L' as u8, n, a, b.to_owned().into_raw_vec(), 1)?;
+        let x = ImplSolve::solve_triangle(layout, 'L' as u8, n, a, b.into_raw_vec(), 1)?;
         Ok(Array::from_vec(x))
     }
 }
 
-impl<A, S> TriangularMatrix<ArrayBase<S, Ix1>> for RcArray<A, Ix2>
-    where A: MFloat,
-          S: Data<Elem = A>
-{
+impl<A: MFloat> TriangularMatrix<RcArray<A, Ix1>> for RcArray<A, Ix2> {
     type Output = RcArray<A, Ix1>;
-
-    fn solve_upper(&self, b: &ArrayBase<S, Ix1>) -> Result<Self::Output, LinalgError> {
+    fn solve_upper(&self, b: RcArray<A, Ix1>) -> Result<Self::Output, LinalgError> {
         // XXX unnecessary clone
-        let x = self.to_owned().solve_upper(&b)?;
+        let x = self.to_owned().solve_upper(b.into_owned())?;
         Ok(x.into_shared())
     }
-    fn solve_lower(&self, b: &ArrayBase<S, Ix1>) -> Result<Self::Output, LinalgError> {
+    fn solve_lower(&self, b: RcArray<A, Ix1>) -> Result<Self::Output, LinalgError> {
         // XXX unnecessary clone
-        let x = self.to_owned().solve_lower(&b)?;
+        let x = self.to_owned().solve_lower(b.into_owned())?;
         Ok(x.into_shared())
     }
 }