Format all

Author: termoshtt

examples/eigh.rs

@@ -1,4 +1,3 @@
-
 extern crate ndarray;
 extern crate ndarray_linalg;
 

examples/solve.rs

@@ -1,4 +1,3 @@
-
 extern crate ndarray;
 extern crate ndarray_linalg;
 

examples/solveh.rs

@@ -1,4 +1,3 @@
-
 extern crate ndarray;
 extern crate ndarray_linalg;
 

src/assert.rs

@@ -8,13 +8,21 @@ use super::types::*;
 /// check two values are close in terms of the relative torrence
 pub fn rclose<A: Scalar>(test: A, truth: A, rtol: A::Real) -> Result<A::Real, A::Real> {
     let dev = (test - truth).abs() / truth.abs();
-    if dev < rtol { Ok(dev) } else { Err(dev) }
+    if dev < rtol {
+        Ok(dev)
+    } else {
+        Err(dev)
+    }
 }
 
 /// check two values are close in terms of the absolute torrence
 pub fn aclose<A: Scalar>(test: A, truth: A, atol: A::Real) -> Result<A::Real, A::Real> {
     let dev = (test - truth).abs();
-    if dev < atol { Ok(dev) } else { Err(dev) }
+    if dev < atol {
+        Ok(dev)
+    } else {
+        Err(dev)
+    }
 }
 
 /// check two arrays are close in maximum norm
@@ -30,7 +38,11 @@ where
     D: Dimension,
 {
     let tol = (test - truth).norm_max();
-    if tol < atol { Ok(tol) } else { Err(tol) }
+    if tol < atol {
+        Ok(tol)
+    } else {
+        Err(tol)
+    }
 }
 
 /// check two arrays are close in L1 norm
@@ -46,7 +58,11 @@ where
     D: Dimension,
 {
     let tol = (test - truth).norm_l1() / truth.norm_l1();
-    if tol < rtol { Ok(tol) } else { Err(tol) }
+    if tol < rtol {
+        Ok(tol)
+    } else {
+        Err(tol)
+    }
 }
 
 /// check two arrays are close in L2 norm
@@ -62,21 +78,26 @@ where
     D: Dimension,
 {
     let tol = (test - truth).norm_l2() / truth.norm_l2();
-    if tol < rtol { Ok(tol) } else { Err(tol) }
+    if tol < rtol {
+        Ok(tol)
+    } else {
+        Err(tol)
+    }
 }
 
 macro_rules! generate_assert {
     ($assert:ident, $close:path) => {
-#[macro_export]
-macro_rules! $assert {
-    ($test:expr, $truth:expr, $tol:expr) => {
-        $crate::$close($test, $truth, $tol).unwrap();
+        #[macro_export]
+        macro_rules! $assert {
+            ($test: expr,$truth: expr,$tol: expr) => {
+                $crate::$close($test, $truth, $tol).unwrap();
+            };
+            ($test: expr,$truth: expr,$tol: expr; $comment: expr) => {
+                $crate::$close($test, $truth, $tol).expect($comment);
+            };
+        }
     };
-    ($test:expr, $truth:expr, $tol:expr; $comment:expr) => {
-        $crate::$close($test, $truth, $tol).expect($comment);
-    };
-}
-}} // generate_assert!
+} // generate_assert!
 
 generate_assert!(assert_rclose, rclose);
 generate_assert!(assert_aclose, aclose);

src/cholesky.rs

@@ -408,7 +408,6 @@ pub trait DeterminantC {
     fn ln_detc(&self) -> Self::Output;
 }
 
-
 /// Determinant of Hermitian (or real symmetric) positive definite matrix
 pub trait DeterminantCInto {
     type Output;

src/convert.rs

@@ -93,11 +93,7 @@ where
     } else {
         ArrayBase::from_shape_vec(a.dim().f(), a.into_raw_vec()).unwrap()
     };
-    assert_eq!(
-        new.strides(),
-        strides.as_slice(),
-        "Custom stride is not supported"
-    );
+    assert_eq!(new.strides(), strides.as_slice(), "Custom stride is not supported");
     new
 }
 

src/eigh.rs

@@ -2,12 +2,12 @@
 
 use ndarray::*;
 
-use super::UPLO;
 use super::diagonal::*;
 use super::error::*;
 use super::layout::*;
 use super::operator::*;
 use super::types::*;
+use super::UPLO;
 
 /// Eigenvalue decomposition of Hermite matrix reference
 pub trait Eigh {

src/lapack_traits/cholesky.rs

@@ -6,7 +6,7 @@ use error::*;
 use layout::MatrixLayout;
 use types::*;
 
-use super::{UPLO, into_result};
+use super::{into_result, UPLO};
 
 pub trait Cholesky_: Sized {
     /// Cholesky: wrapper of `*potrf`
@@ -23,28 +23,29 @@ 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, a: &mut [Self]) -> Result<()> {
-        let (n, _) = l.size();
-        let info = $trf(l.lapacke_layout(), uplo as u8, n, a, n);
-        into_result(info, ())
-    }
-
-    unsafe fn inv_cholesky(l: MatrixLayout, uplo: UPLO, a: &mut [Self]) -> Result<()> {
-        let (n, _) = l.size();
-        let info = $tri(l.lapacke_layout(), uplo as u8, n, a, l.lda());
-        into_result(info, ())
-    }
-
-    unsafe fn solve_cholesky(l: MatrixLayout, uplo: UPLO, a: &[Self], b: &mut [Self]) -> Result<()> {
-        let (n, _) = l.size();
-        let nrhs = 1;
-        let ldb = 1;
-        let info = $trs(l.lapacke_layout(), uplo as u8, n, nrhs, a, l.lda(), b, ldb);
-        into_result(info, ())
-    }
-}
-}} // end macro_rules
+        impl Cholesky_ for $scalar {
+            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, ())
+            }
+
+            unsafe fn inv_cholesky(l: MatrixLayout, uplo: UPLO, a: &mut [Self]) -> Result<()> {
+                let (n, _) = l.size();
+                let info = $tri(l.lapacke_layout(), uplo as u8, n, a, l.lda());
+                into_result(info, ())
+            }
+
+            unsafe fn solve_cholesky(l: MatrixLayout, uplo: UPLO, a: &[Self], b: &mut [Self]) -> Result<()> {
+                let (n, _) = l.size();
+                let nrhs = 1;
+                let ldb = 1;
+                let info = $trs(l.lapacke_layout(), uplo as u8, n, nrhs, a, l.lda(), b, ldb);
+                into_result(info, ())
+            }
+        }
+    };
+} // end macro_rules
 
 impl_cholesky!(f64, lapacke::dpotrf, lapacke::dpotri, lapacke::dpotrs);
 impl_cholesky!(f32, lapacke::spotrf, lapacke::spotri, lapacke::spotrs);

src/lapack_traits/eigh.rs

@@ -7,7 +7,7 @@ use error::*;
 use layout::MatrixLayout;
 use types::*;
 
-use super::{UPLO, into_result};
+use super::{into_result, UPLO};
 
 /// Wraps `*syev` for real and `*heev` for complex
 pub trait Eigh_: AssociatedReal {
@@ -16,16 +16,17 @@ pub trait Eigh_: AssociatedReal {
 
 macro_rules! impl_eigh {
     ($scalar:ty, $ev:path) => {
-impl Eigh_ for $scalar {
-    unsafe fn eigh(calc_v: bool, l: MatrixLayout, uplo: UPLO, mut a: &mut [Self]) -> Result<Vec<Self::Real>> {
-        let (n, _) = l.size();
-        let jobz = if calc_v { b'V' } else { b'N' };
-        let mut w = vec![Self::Real::zero(); n as usize];
-        let info = $ev(l.lapacke_layout(), jobz, uplo as u8, n, &mut a, n, &mut w);
-        into_result(info, w)
-    }
-}
-}} // impl_eigh!
+        impl Eigh_ for $scalar {
+            unsafe fn eigh(calc_v: bool, l: MatrixLayout, uplo: UPLO, mut a: &mut [Self]) -> Result<Vec<Self::Real>> {
+                let (n, _) = l.size();
+                let jobz = if calc_v { b'V' } else { b'N' };
+                let mut w = vec![Self::Real::zero(); n as usize];
+                let info = $ev(l.lapacke_layout(), jobz, uplo as u8, n, &mut a, n, &mut w);
+                into_result(info, w)
+            }
+        }
+    };
+} // impl_eigh!
 
 impl_eigh!(f64, lapacke::dsyev);
 impl_eigh!(f32, lapacke::ssyev);

src/lapack_traits/mod.rs

@@ -1,12 +1,12 @@
 //! Define traits wrapping LAPACK routines
 
+pub mod cholesky;
+pub mod eigh;
 pub mod opnorm;
 pub mod qr;
-pub mod svd;
 pub mod solve;
 pub mod solveh;
-pub mod cholesky;
-pub mod eigh;
+pub mod svd;
 pub mod triangular;
 
 pub use self::cholesky::*;
@@ -23,10 +23,7 @@ use super::types::*;
 
 pub type Pivot = Vec<i32>;
 
-pub trait LapackScalar
-    : OperatorNorm_ + QR_ + SVD_ + Solve_ + Solveh_ + Cholesky_ + Eigh_ + Triangular_
-    {
-}
+pub trait LapackScalar: OperatorNorm_ + QR_ + SVD_ + Solve_ + Solveh_ + Cholesky_ + Eigh_ + Triangular_ {}
 
 impl LapackScalar for f32 {}
 impl LapackScalar for f64 {}