Merge pull request #135 from termoshtt/rust2018

Rust2018 edition

Author: termoshtt

Cargo.toml

@@ -2,6 +2,7 @@
 name    = "ndarray-linalg"
 version = "0.10.1-alpha.0"
 authors = ["Toshiki Teramura <toshiki.teramura@gmail.com>"]
+edition = "2018"
 
 description   = "Linear algebra package for rust-ndarray using LAPACK"
 documentation = "https://docs.rs/ndarray-linalg/"

src/cholesky.rs

@@ -46,13 +46,13 @@
 use ndarray::*;
 use num_traits::Float;
 
-use super::convert::*;
-use super::error::*;
-use super::layout::*;
-use super::triangular::IntoTriangular;
-use super::types::*;
+use crate::convert::*;
+use crate::error::*;
+use crate::layout::*;
+use crate::triangular::IntoTriangular;
+use crate::types::*;
 
-pub use lapack_traits::UPLO;
+pub use crate::lapack_traits::UPLO;
 
 /// Cholesky decomposition of Hermitian (or real symmetric) positive definite matrix
 pub struct CholeskyFactorized<S: Data> {
@@ -194,7 +194,7 @@ pub trait Cholesky {
     /// Otherwise, if the argument is `UPLO::Lower`, computes the decomposition
     /// `A = L * L^H` using the lower triangular portion of `A` and returns
     /// `L`.
-    fn cholesky(&self, UPLO) -> Result<Self::Output>;
+    fn cholesky(&self, uplo: UPLO) -> Result<Self::Output>;
 }
 
 /// Cholesky decomposition of Hermitian (or real symmetric) positive definite matrix
@@ -208,7 +208,7 @@ pub trait CholeskyInto {
     /// Otherwise, if the argument is `UPLO::Lower`, computes the decomposition
     /// `A = L * L^H` using the lower triangular portion of `A` and returns
     /// `L`.
-    fn cholesky_into(self, UPLO) -> Result<Self::Output>;
+    fn cholesky_into(self, uplo: UPLO) -> Result<Self::Output>;
 }
 
 /// Cholesky decomposition of Hermitian (or real symmetric) positive definite mutable reference of matrix
@@ -221,7 +221,7 @@ pub trait CholeskyInplace {
     /// U^H * U` using the upper triangular portion of `A` and writes `U`.
     /// Otherwise, if the argument is `UPLO::Lower`, computes the decomposition
     /// `A = L * L^H` using the lower triangular portion of `A` and writes `L`.
-    fn cholesky_inplace(&mut self, UPLO) -> Result<&mut Self>;
+    fn cholesky_inplace(&mut self, uplo: UPLO) -> Result<&mut Self>;
 }
 
 impl<A, S> Cholesky for ArrayBase<S, Ix2>
@@ -271,7 +271,7 @@ pub trait FactorizeC<S: Data> {
     /// factorization containing `U`. Otherwise, if the argument is
     /// `UPLO::Lower`, computes the decomposition `A = L * L^H` using the lower
     /// triangular portion of `A` and returns the factorization containing `L`.
-    fn factorizec(&self, UPLO) -> Result<CholeskyFactorized<S>>;
+    fn factorizec(&self, uplo: UPLO) -> Result<CholeskyFactorized<S>>;
 }
 
 /// Cholesky decomposition of Hermitian (or real symmetric) positive definite matrix
@@ -284,7 +284,7 @@ pub trait FactorizeCInto<S: Data> {
     /// factorization containing `U`. Otherwise, if the argument is
     /// `UPLO::Lower`, computes the decomposition `A = L * L^H` using the lower
     /// triangular portion of `A` and returns the factorization containing `L`.
-    fn factorizec_into(self, UPLO) -> Result<CholeskyFactorized<S>>;
+    fn factorizec_into(self, uplo: UPLO) -> Result<CholeskyFactorized<S>>;
 }
 
 impl<A, S> FactorizeCInto<S> for ArrayBase<S, Ix2>
@@ -335,7 +335,10 @@ pub trait SolveC<A: Scalar> {
     /// symmetric) positive definite matrix `A`, where `A` is `self`, `b` is
     /// the argument, and `x` is the successful result. The value of `x` is
     /// also assigned to the argument.
-    fn solvec_inplace<'a, S: DataMut<Elem = A>>(&self, &'a mut ArrayBase<S, Ix1>) -> Result<&'a mut ArrayBase<S, Ix1>>;
+    fn solvec_inplace<'a, S: DataMut<Elem = A>>(
+        &self,
+        b: &'a mut ArrayBase<S, Ix1>,
+    ) -> Result<&'a mut ArrayBase<S, Ix1>>;
 }
 
 impl<A, S> SolveC<A> for ArrayBase<S, Ix2>

src/eigh.rs

@@ -2,30 +2,30 @@
 
 use ndarray::*;
 
-use super::diagonal::*;
-use super::error::*;
-use super::layout::*;
-use super::operator::*;
-use super::types::*;
-use super::UPLO;
+use crate::diagonal::*;
+use crate::error::*;
+use crate::layout::*;
+use crate::operator::Operator;
+use crate::types::*;
+use crate::UPLO;
 
 /// Eigenvalue decomposition of Hermite matrix reference
 pub trait Eigh {
     type EigVal;
     type EigVec;
-    fn eigh(&self, UPLO) -> Result<(Self::EigVal, Self::EigVec)>;
+    fn eigh(&self, uplo: UPLO) -> Result<(Self::EigVal, Self::EigVec)>;
 }
 
 /// Eigenvalue decomposition of mutable reference of Hermite matrix
 pub trait EighInplace {
     type EigVal;
-    fn eigh_inplace(&mut self, UPLO) -> Result<(Self::EigVal, &mut Self)>;
+    fn eigh_inplace(&mut self, uplo: UPLO) -> Result<(Self::EigVal, &mut Self)>;
 }
 
 /// Eigenvalue decomposition of Hermite matrix
 pub trait EighInto: Sized {
     type EigVal;
-    fn eigh_into(self, UPLO) -> Result<(Self::EigVal, Self)>;
+    fn eigh_into(self, uplo: UPLO) -> Result<(Self::EigVal, Self)>;
 }
 
 impl<A, S> EighInto for ArrayBase<S, Ix2>
@@ -71,19 +71,19 @@ where
 /// Calculate eigenvalues without eigenvectors
 pub trait EigValsh {
     type EigVal;
-    fn eigvalsh(&self, UPLO) -> Result<Self::EigVal>;
+    fn eigvalsh(&self, uplo: UPLO) -> Result<Self::EigVal>;
 }
 
 /// Calculate eigenvalues without eigenvectors
 pub trait EigValshInto {
     type EigVal;
-    fn eigvalsh_into(self, UPLO) -> Result<Self::EigVal>;
+    fn eigvalsh_into(self, uplo: UPLO) -> Result<Self::EigVal>;
 }
 
 /// Calculate eigenvalues without eigenvectors
 pub trait EigValshInplace {
     type EigVal;
-    fn eigvalsh_inplace(&mut self, UPLO) -> Result<Self::EigVal>;
+    fn eigvalsh_inplace(&mut self, uplo: UPLO) -> Result<Self::EigVal>;
 }
 
 impl<A, S> EigValshInto for ArrayBase<S, Ix2>
@@ -127,7 +127,7 @@ where
 /// Calculate symmetric square-root matrix using `eigh`
 pub trait SymmetricSqrt {
     type Output;
-    fn ssqrt(&self, UPLO) -> Result<Self::Output>;
+    fn ssqrt(&self, uplo: UPLO) -> Result<Self::Output>;
 }
 
 impl<A, S> SymmetricSqrt for ArrayBase<S, Ix2>
@@ -146,7 +146,7 @@ where
 /// Calculate symmetric square-root matrix using `eigh`
 pub trait SymmetricSqrtInto {
     type Output;
-    fn ssqrt_into(self, UPLO) -> Result<Self::Output>;
+    fn ssqrt_into(self, uplo: UPLO) -> Result<Self::Output>;
 }
 
 impl<A, S> SymmetricSqrtInto for ArrayBase<S, Ix2>

src/lapack_traits/cholesky.rs

@@ -2,23 +2,23 @@
 
 use lapacke;
 
-use error::*;
-use layout::MatrixLayout;
-use types::*;
+use crate::error::*;
+use crate::layout::MatrixLayout;
+use crate::types::*;
 
 use super::{into_result, UPLO};
 
 pub trait Cholesky_: Sized {
     /// Cholesky: wrapper of `*potrf`
     ///
     /// **Warning: Only the portion of `a` corresponding to `UPLO` is written.**
-    unsafe fn cholesky(MatrixLayout, UPLO, a: &mut [Self]) -> Result<()>;
+    unsafe fn cholesky(l: MatrixLayout, uplo: UPLO, a: &mut [Self]) -> Result<()>;
     /// Wrapper of `*potri`
     ///
     /// **Warning: Only the portion of `a` corresponding to `UPLO` is written.**
-    unsafe fn inv_cholesky(MatrixLayout, UPLO, a: &mut [Self]) -> Result<()>;
+    unsafe fn inv_cholesky(l: MatrixLayout, uplo: UPLO, a: &mut [Self]) -> Result<()>;
     /// Wrapper of `*potrs`
-    unsafe fn solve_cholesky(MatrixLayout, UPLO, a: &[Self], b: &mut [Self]) -> Result<()>;
+    unsafe fn solve_cholesky(l: MatrixLayout, uplo: UPLO, a: &[Self], b: &mut [Self]) -> Result<()>;
 }
 
 macro_rules! impl_cholesky {

src/lapack_traits/eigh.rs

@@ -3,15 +3,15 @@
 use lapacke;
 use num_traits::Zero;
 
-use error::*;
-use layout::MatrixLayout;
-use types::*;
+use crate::error::*;
+use crate::layout::MatrixLayout;
+use crate::types::*;
 
 use super::{into_result, UPLO};
 
 /// Wraps `*syev` for real and `*heev` for complex
 pub trait Eigh_: AssociatedReal {
-    unsafe fn eigh(calc_eigenvec: bool, MatrixLayout, UPLO, a: &mut [Self]) -> Result<Vec<Self::Real>>;
+    unsafe fn eigh(calc_eigenvec: bool, l: MatrixLayout, uplo: UPLO, a: &mut [Self]) -> Result<Vec<Self::Real>>;
 }
 
 macro_rules! impl_eigh {

src/lapack_traits/opnorm.rs

@@ -3,13 +3,13 @@
 use lapacke;
 use lapacke::Layout::ColumnMajor as cm;
 
-use layout::MatrixLayout;
-use types::*;
+use crate::layout::MatrixLayout;
+use crate::types::*;
 
 pub use super::NormType;
 
 pub trait OperatorNorm_: AssociatedReal {
-    unsafe fn opnorm(NormType, MatrixLayout, &[Self]) -> Self::Real;
+    unsafe fn opnorm(t: NormType, l: MatrixLayout, a: &[Self]) -> Self::Real;
 }
 
 macro_rules! impl_opnorm {

src/lapack_traits/qr.rs

@@ -4,17 +4,17 @@ use lapacke;
 use num_traits::Zero;
 use std::cmp::min;
 
-use error::*;
-use layout::MatrixLayout;
-use types::*;
+use crate::error::*;
+use crate::layout::MatrixLayout;
+use crate::types::*;
 
 use super::into_result;
 
 /// Wraps `*geqrf` and `*orgqr` (`*ungqr` for complex numbers)
 pub trait QR_: Sized {
-    unsafe fn householder(MatrixLayout, a: &mut [Self]) -> Result<Vec<Self>>;
-    unsafe fn q(MatrixLayout, a: &mut [Self], tau: &[Self]) -> Result<()>;
-    unsafe fn qr(MatrixLayout, a: &mut [Self]) -> Result<Vec<Self>>;
+    unsafe fn householder(l: MatrixLayout, a: &mut [Self]) -> Result<Vec<Self>>;
+    unsafe fn q(l: MatrixLayout, a: &mut [Self], tau: &[Self]) -> Result<()>;
+    unsafe fn qr(l: MatrixLayout, a: &mut [Self]) -> Result<Vec<Self>>;
 }
 
 macro_rules! impl_qr {

src/lapack_traits/solve.rs

@@ -1,11 +1,11 @@
 //! Solve linear problem using LU decomposition
 
 use lapacke;
-
-use error::*;
-use layout::MatrixLayout;
 use num_traits::Zero;
-use types::*;
+
+use crate::error::*;
+use crate::layout::MatrixLayout;
+use crate::types::*;
 
 use super::NormType;
 use super::{into_result, Pivot, Transpose};
@@ -20,13 +20,13 @@ pub trait Solve_: AssociatedReal + Sized {
     /// return_code-1)]` is exactly zero. The factorization has been completed,
     /// but the factor `U` is exactly singular, and division by zero will occur
     /// if it is used to solve a system of equations.
-    unsafe fn lu(MatrixLayout, a: &mut [Self]) -> Result<Pivot>;
-    unsafe fn inv(MatrixLayout, a: &mut [Self], &Pivot) -> Result<()>;
+    unsafe fn lu(l: MatrixLayout, a: &mut [Self]) -> Result<Pivot>;
+    unsafe fn inv(l: MatrixLayout, a: &mut [Self], p: &Pivot) -> Result<()>;
     /// Estimates the the reciprocal of the condition number of the matrix in 1-norm.
     ///
     /// `anorm` should be the 1-norm of the matrix `a`.
-    unsafe fn rcond(MatrixLayout, a: &[Self], anorm: Self::Real) -> Result<Self::Real>;
-    unsafe fn solve(MatrixLayout, Transpose, a: &[Self], &Pivot, b: &mut [Self]) -> Result<()>;
+    unsafe fn rcond(l: MatrixLayout, a: &[Self], anorm: Self::Real) -> Result<Self::Real>;
+    unsafe fn solve(l: MatrixLayout, t: Transpose, a: &[Self], p: &Pivot, b: &mut [Self]) -> Result<()>;
 }
 
 macro_rules! impl_solve {

src/lapack_traits/solveh.rs

@@ -4,19 +4,19 @@
 
 use lapacke;
 
-use error::*;
-use layout::MatrixLayout;
-use types::*;
+use crate::error::*;
+use crate::layout::MatrixLayout;
+use crate::types::*;
 
 use super::{into_result, Pivot, UPLO};
 
 pub trait Solveh_: Sized {
     /// Bunch-Kaufman: wrapper of `*sytrf` and `*hetrf`
-    unsafe fn bk(MatrixLayout, UPLO, a: &mut [Self]) -> Result<Pivot>;
+    unsafe fn bk(l: MatrixLayout, uplo: UPLO, a: &mut [Self]) -> Result<Pivot>;
     /// Wrapper of `*sytri` and `*hetri`
-    unsafe fn invh(MatrixLayout, UPLO, a: &mut [Self], &Pivot) -> Result<()>;
+    unsafe fn invh(l: MatrixLayout, uplo: UPLO, a: &mut [Self], ipiv: &Pivot) -> Result<()>;
     /// Wrapper of `*sytrs` and `*hetrs`
-    unsafe fn solveh(MatrixLayout, UPLO, a: &[Self], &Pivot, b: &mut [Self]) -> Result<()>;
+    unsafe fn solveh(l: MatrixLayout, uplo: UPLO, a: &[Self], ipiv: &Pivot, b: &mut [Self]) -> Result<()>;
 }
 
 macro_rules! impl_solveh {

src/lapack_traits/svd.rs

@@ -3,9 +3,9 @@
 use lapacke;
 use num_traits::Zero;
 
-use error::*;
-use layout::MatrixLayout;
-use types::*;
+use crate::error::*;
+use crate::layout::MatrixLayout;
+use crate::types::*;
 
 use super::into_result;
 
@@ -29,7 +29,7 @@ pub struct SVDOutput<A: AssociatedReal> {
 
 /// Wraps `*gesvd`
 pub trait SVD_: AssociatedReal {
-    unsafe fn svd(MatrixLayout, calc_u: bool, calc_vt: bool, a: &mut [Self]) -> Result<SVDOutput<Self>>;
+    unsafe fn svd(l: MatrixLayout, calc_u: bool, calc_vt: bool, a: &mut [Self]) -> Result<SVDOutput<Self>>;
 }
 
 macro_rules! impl_svd {