Merge pull request #93 from jturner314/fix-warnings

Fix compiler warnings and most clippy warnings

Author: termoshtt

src/convert.rs

@@ -28,7 +28,7 @@ where
     S: Data,
 {
     let n = a.len();
-    a.into_shape((n)).unwrap()
+    a.into_shape(n).unwrap()
 }
 
 pub fn into_matrix<A, S>(l: MatrixLayout, a: Vec<A>) -> Result<ArrayBase<S, Ix2>>

src/diagonal.rs

@@ -15,7 +15,7 @@ pub trait IntoDiagonal<S: Data> {
 }
 
 pub trait AsDiagonal<A> {
-    fn as_diagonal<'a>(&'a self) -> Diagonal<ViewRepr<&'a A>>;
+    fn as_diagonal(&self) -> Diagonal<ViewRepr<&A>>;
 }
 
 impl<S: Data> IntoDiagonal<S> for ArrayBase<S, Ix1> {
@@ -25,7 +25,7 @@ impl<S: Data> IntoDiagonal<S> for ArrayBase<S, Ix1> {
 }
 
 impl<A, S: Data<Elem = A>> AsDiagonal<A> for ArrayBase<S, Ix1> {
-    fn as_diagonal<'a>(&'a self) -> Diagonal<ViewRepr<&'a A>> {
+    fn as_diagonal(&self) -> Diagonal<ViewRepr<&A>> {
         Diagonal { diag: self.view() }
     }
 }
@@ -36,7 +36,7 @@ where
     S: Data<Elem = A>,
     Sr: DataMut<Elem = A>,
 {
-    fn op_inplace<'a>(&self, mut a: &'a mut ArrayBase<Sr, Ix1>) -> &'a mut ArrayBase<Sr, Ix1> {
+    fn op_inplace<'a>(&self, a: &'a mut ArrayBase<Sr, Ix1>) -> &'a mut ArrayBase<Sr, Ix1> {
         for (val, d) in a.iter_mut().zip(self.diag.iter()) {
             *val = *val * *d;
         }
@@ -64,7 +64,7 @@ where
     Sr: DataOwned<Elem = A> + DataMut,
 {
     fn op_into(&self, mut a: ArrayBase<Sr, Ix1>) -> ArrayBase<Sr, Ix1> {
-        self.op(&mut a);
+        self.op_inplace(&mut a);
         a
     }
 }
@@ -75,8 +75,8 @@ where
     S: Data<Elem = A>,
     Sr: DataMut<Elem = A>,
 {
-    fn op_inplace<'a>(&self, mut a: &'a mut ArrayBase<Sr, Ix2>) -> &'a mut ArrayBase<Sr, Ix2> {
-        let ref d = self.diag;
+    fn op_inplace<'a>(&self, a: &'a mut ArrayBase<Sr, Ix2>) -> &'a mut ArrayBase<Sr, Ix2> {
+        let d = &self.diag;
         for ((i, _), val) in a.indexed_iter_mut() {
             *val = *val * d[i];
         }
@@ -104,7 +104,7 @@ where
     Sr: DataOwned<Elem = A> + DataMut,
 {
     fn op_into(&self, mut a: ArrayBase<Sr, Ix2>) -> ArrayBase<Sr, Ix2> {
-        self.op(&mut a);
+        self.op_inplace(&mut a);
         a
     }
 }

src/lapack_traits/cholesky.rs

@@ -24,7 +24,7 @@ pub trait Cholesky_: Sized {
 macro_rules! impl_cholesky {
     ($scalar:ty, $trf:path, $tri:path, $trs:path) => {
 impl Cholesky_ for $scalar {
-    unsafe fn cholesky(l: MatrixLayout, uplo: UPLO, mut a: &mut [Self]) -> Result<()> {
+    unsafe fn cholesky(l: MatrixLayout, uplo: UPLO, a: &mut [Self]) -> Result<()> {
         let (n, _) = l.size();
         let info = $trf(l.lapacke_layout(), uplo as u8, n, a, n);
         into_result(info, ())

src/lapack_traits/qr.rs

@@ -35,7 +35,7 @@ impl QR_ for $scalar {
         into_result(info, ())
     }
 
-    unsafe fn qr(l: MatrixLayout, mut a: &mut [Self]) -> Result<Vec<Self>> {
+    unsafe fn qr(l: MatrixLayout, a: &mut [Self]) -> Result<Vec<Self>> {
         let tau = Self::householder(l, a)?;
         let r = Vec::from(&*a);
         Self::q(l, a, &tau)?;

src/layout.rs

@@ -33,8 +33,7 @@ impl MatrixLayout {
 
     pub fn lda(&self) -> LDA {
         match *self {
-            MatrixLayout::C((_, lda)) => lda,
-            MatrixLayout::F((_, lda)) => lda,
+            MatrixLayout::C((_, lda)) | MatrixLayout::F((_, lda)) => lda,
         }
     }
 
@@ -123,7 +122,7 @@ where
     }
 
     fn as_allocated(&self) -> Result<&[A]> {
-        Ok(self.as_slice_memory_order().ok_or(MemoryContError::new())?)
+        Ok(self.as_slice_memory_order().ok_or_else(MemoryContError::new)?)
     }
 }
 
@@ -132,8 +131,8 @@ where
     S: DataMut<Elem = A>,
 {
     fn as_allocated_mut(&mut self) -> Result<&mut [A]> {
-        Ok(self.as_slice_memory_order_mut().ok_or(
-            MemoryContError::new(),
+        Ok(self.as_slice_memory_order_mut().ok_or_else(
+            MemoryContError::new,
         )?)
     }
 }

src/operator.rs

@@ -95,7 +95,7 @@ where
     D: Dimension + RemoveAxis,
     for<'a> T: OperatorInplace<ViewRepr<&'a mut A>, D::Smaller>,
 {
-    fn op_multi_inplace<'a>(&self, mut a: &'a mut ArrayBase<S, D>) -> &'a mut ArrayBase<S, D> {
+    fn op_multi_inplace<'a>(&self, a: &'a mut ArrayBase<S, D>) -> &'a mut ArrayBase<S, D> {
         let n = a.ndim();
         for mut col in a.axis_iter_mut(Axis(n - 1)) {
             self.op_inplace(&mut col);

src/opnorm.rs

@@ -10,7 +10,7 @@ pub use lapack_traits::NormType;
 
 /// Operator norm using `*lange` LAPACK routines
 ///
-/// https://en.wikipedia.org/wiki/Operator_norm
+/// [Wikipedia article on operator norm](https://en.wikipedia.org/wiki/Operator_norm)
 pub trait OperationNorm {
     /// the value of norm
     type Output: RealScalar;

src/qr.rs

@@ -1,6 +1,6 @@
 //! QR decomposition
 //!
-//! https://en.wikipedia.org/wiki/QR_decomposition
+//! [Wikipedia article on QR decomposition](https://en.wikipedia.org/wiki/QR_decomposition)
 
 use ndarray::*;
 use num_traits::Zero;
@@ -49,7 +49,7 @@ pub trait QRSquareInto: Sized {
 /// QR decomposition for mutable reference of square matrix
 pub trait QRSquareInplace: Sized {
     type R;
-    fn qr_square_inplace<'a>(&'a mut self) -> Result<(&'a mut Self, Self::R)>;
+    fn qr_square_inplace(&mut self) -> Result<(&mut Self, Self::R)>;
 }
 
 impl<A, S> QRSquareInplace for ArrayBase<S, Ix2>
@@ -59,7 +59,7 @@ where
 {
     type R = Array2<A>;
 
-    fn qr_square_inplace<'a>(&'a mut self) -> Result<(&'a mut Self, Self::R)> {
+    fn qr_square_inplace(&mut self) -> Result<(&mut Self, Self::R)> {
         let l = self.square_layout()?;
         let r = unsafe { A::qr(l, self.as_allocated_mut()?)? };
         let r: Array2<_> = into_matrix(l, r)?;

src/solve.rs

@@ -141,7 +141,7 @@ where
     A: Scalar,
     S: Data<Elem = A>,
 {
-    fn solve_inplace<'a, Sb>(&self, mut rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
+    fn solve_inplace<'a, Sb>(&self, rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
     where
         Sb: DataMut<Elem = A>,
     {
@@ -156,7 +156,7 @@ where
         };
         Ok(rhs)
     }
-    fn solve_t_inplace<'a, Sb>(&self, mut rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
+    fn solve_t_inplace<'a, Sb>(&self, rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
     where
         Sb: DataMut<Elem = A>,
     {
@@ -171,7 +171,7 @@ where
         };
         Ok(rhs)
     }
-    fn solve_h_inplace<'a, Sb>(&self, mut rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
+    fn solve_h_inplace<'a, Sb>(&self, rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
     where
         Sb: DataMut<Elem = A>,
     {
@@ -193,21 +193,21 @@ where
     A: Scalar,
     S: Data<Elem = A>,
 {
-    fn solve_inplace<'a, Sb>(&self, mut rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
+    fn solve_inplace<'a, Sb>(&self, rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
     where
         Sb: DataMut<Elem = A>,
     {
         let f = self.factorize()?;
         f.solve_inplace(rhs)
     }
-    fn solve_t_inplace<'a, Sb>(&self, mut rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
+    fn solve_t_inplace<'a, Sb>(&self, rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
     where
         Sb: DataMut<Elem = A>,
     {
         let f = self.factorize()?;
         f.solve_t_inplace(rhs)
     }
-    fn solve_h_inplace<'a, Sb>(&self, mut rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
+    fn solve_h_inplace<'a, Sb>(&self, rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
     where
         Sb: DataMut<Elem = A>,
     {

src/solveh.rs

@@ -122,7 +122,7 @@ where
     A: Scalar,
     S: Data<Elem = A>,
 {
-    fn solveh_inplace<'a, Sb>(&self, mut rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
+    fn solveh_inplace<'a, Sb>(&self, rhs: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
     where
         Sb: DataMut<Elem = A>,
     {