Update to Rust 2018 and replace quickcheck! with #[quickcheck]

.travis.yml

@@ -7,7 +7,7 @@ addons:
       - libssl-dev
 cache: cargo
 rust:
-  - 1.31.0
+  - 1.34.0
   - stable
   - beta
   - nightly

Cargo.toml

@@ -2,6 +2,7 @@
 name = "ndarray-stats"
 version = "0.1.0"
 authors = ["Jim Turner <ndarray-stats@turner.link>", "LukeMathWalker <rust@lpalmieri.com>"]
+edition = "2018"
 
 license = "MIT/Apache-2.0"
 

benches/sort.rs

@@ -1,8 +1,3 @@
-extern crate criterion;
-extern crate ndarray;
-extern crate ndarray_stats;
-extern crate rand;
-
 use criterion::{
     black_box, criterion_group, criterion_main, AxisScale, BatchSize, Criterion,
     ParameterizedBenchmark, PlotConfiguration,

src/correlation.rs

@@ -49,8 +49,6 @@ where
     /// # Example
     ///
     /// ```
-    /// extern crate ndarray;
-    /// extern crate ndarray_stats;
     /// use ndarray::{aview2, arr2};
     /// use ndarray_stats::CorrelationExt;
     ///
@@ -98,8 +96,6 @@ where
     ///
     /// variables is zero and division by zero panics for type A.
     /// ```
-    /// extern crate ndarray;
-    /// extern crate ndarray_stats;
     /// use ndarray::arr2;
     /// use ndarray_stats::CorrelationExt;
     ///
@@ -175,31 +171,31 @@ mod cov_tests {
     use super::*;
     use ndarray::array;
     use ndarray_rand::RandomExt;
-    use quickcheck::quickcheck;
+    use quickcheck_macros::quickcheck;
     use rand;
     use rand::distributions::Uniform;
 
-    quickcheck! {
-        fn constant_random_variables_have_zero_covariance_matrix(value: f64) -> bool {
-            let n_random_variables = 3;
-            let n_observations = 4;
-            let a = Array::from_elem((n_random_variables, n_observations), value);
-            a.cov(1.).all_close(
-                &Array::zeros((n_random_variables, n_random_variables)),
-                1e-8
-            )
-        }
+    #[quickcheck]
+    fn constant_random_variables_have_zero_covariance_matrix(value: f64) -> bool {
+        let n_random_variables = 3;
+        let n_observations = 4;
+        let a = Array::from_elem((n_random_variables, n_observations), value);
+        a.cov(1.).all_close(
+            &Array::zeros((n_random_variables, n_random_variables)),
+            1e-8,
+        )
+    }
 
-        fn covariance_matrix_is_symmetric(bound: f64) -> bool {
-            let n_random_variables = 3;
-            let n_observations = 4;
-            let a = Array::random(
-                (n_random_variables, n_observations),
-                Uniform::new(-bound.abs(), bound.abs())
-            );
-            let covariance = a.cov(1.);
-            covariance.all_close(&covariance.t(), 1e-8)
-        }
+    #[quickcheck]
+    fn covariance_matrix_is_symmetric(bound: f64) -> bool {
+        let n_random_variables = 3;
+        let n_observations = 4;
+        let a = Array::random(
+            (n_random_variables, n_observations),
+            Uniform::new(-bound.abs(), bound.abs()),
+        );
+        let covariance = a.cov(1.);
+        covariance.all_close(&covariance.t(), 1e-8)
     }
 
     #[test]
@@ -277,28 +273,31 @@ mod pearson_correlation_tests {
     use super::*;
     use ndarray::array;
     use ndarray_rand::RandomExt;
-    use quickcheck::quickcheck;
+    use quickcheck_macros::quickcheck;
     use rand::distributions::Uniform;
 
-    quickcheck! {
-        fn output_matrix_is_symmetric(bound: f64) -> bool {
-            let n_random_variables = 3;
-            let n_observations = 4;
-            let a = Array::random(
-                (n_random_variables, n_observations),
-                Uniform::new(-bound.abs(), bound.abs())
-            );
-            let pearson_correlation = a.pearson_correlation();
-            pearson_correlation.all_close(&pearson_correlation.t(), 1e-8)
-        }
+    #[quickcheck]
+    fn output_matrix_is_symmetric(bound: f64) -> bool {
+        let n_random_variables = 3;
+        let n_observations = 4;
+        let a = Array::random(
+            (n_random_variables, n_observations),
+            Uniform::new(-bound.abs(), bound.abs()),
+        );
+        let pearson_correlation = a.pearson_correlation();
+        pearson_correlation.all_close(&pearson_correlation.t(), 1e-8)
+    }
 
-        fn constant_random_variables_have_nan_correlation(value: f64) -> bool {
-            let n_random_variables = 3;
-            let n_observations = 4;
-            let a = Array::from_elem((n_random_variables, n_observations), value);
-            let pearson_correlation = a.pearson_correlation();
-            pearson_correlation.iter().map(|x| x.is_nan()).fold(true, |acc, flag| acc & flag)
-        }
+    #[quickcheck]
+    fn constant_random_variables_have_nan_correlation(value: f64) -> bool {
+        let n_random_variables = 3;
+        let n_observations = 4;
+        let a = Array::from_elem((n_random_variables, n_observations), value);
+        let pearson_correlation = a.pearson_correlation();
+        pearson_correlation
+            .iter()
+            .map(|x| x.is_nan())
+            .fold(true, |acc, flag| acc & flag)
     }
 
     #[test]

src/entropy.rs

@@ -221,8 +221,8 @@ where
 #[cfg(test)]
 mod tests {
     use super::EntropyExt;
+    use crate::errors::{EmptyInput, MultiInputError};
     use approx::assert_abs_diff_eq;
-    use errors::{EmptyInput, MultiInputError};
     use ndarray::{array, Array1};
     use noisy_float::types::n64;
     use std::f64;

src/errors.rs

@@ -8,7 +8,7 @@ use std::fmt;
 pub struct EmptyInput;
 
 impl fmt::Display for EmptyInput {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Empty input.")
     }
 }
@@ -25,7 +25,7 @@ pub enum MinMaxError {
 }
 
 impl fmt::Display for MinMaxError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             MinMaxError::EmptyInput => write!(f, "Empty input."),
             MinMaxError::UndefinedOrder => {
@@ -53,7 +53,7 @@ pub struct ShapeMismatch {
 }
 
 impl fmt::Display for ShapeMismatch {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
             "Array shapes do not match: {:?} and {:?}.",
@@ -92,7 +92,7 @@ impl MultiInputError {
 }
 
 impl fmt::Display for MultiInputError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             MultiInputError::EmptyInput => write!(f, "Empty input."),
             MultiInputError::ShapeMismatch(e) => write!(f, "Shape mismatch: {}", e),
@@ -124,7 +124,7 @@ pub enum QuantileError {
 }
 
 impl fmt::Display for QuantileError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             QuantileError::EmptyInput => write!(f, "Empty input."),
             QuantileError::InvalidQuantile(q) => {