Essential traits (rust-ml#221)

* Add traits

* Add traits and autotraits to bayes crate

* Add traits and autotrait test to clustering crate

* Add traits and autotraits test to elasticnet crate

* Add traits and autotraits test to ftrl crate

* Add traits and autotraits test to hierarchical crate

* Add traits and autotraits test to ica crate

* Add traits and autotraits test to kernel crate

* Add traits and autotraits test to linear crate

* Add traits and autotraits test to logistic crate

* Add traits and autotraits test to nn crate

* Add traits and autotraits test to pls crate

* Add traits and autotraits test to preprocessing crate

* Add traits and autotraits test to reduction crate

* Add traits and autotraits test to svm crate

* Add traits and autotraits test to trees crate

* Add traits and autotraits test to tsne crate

* Remove PartialOrd in SvmValidParams

* Remove extra traits in errors. Leave Hash for simple enums. Fix some traits

* Remove PartialOrd. Minor changes

* Add bounds to Iter, GaussianNb, MultinomialNb, OpticsAnalysis

Author: MilaKyr

algorithms/linfa-bayes/src/gaussian_nb.rs

@@ -4,6 +4,7 @@ use linfa::{Float, Label};
 use ndarray::{Array1, ArrayBase, ArrayView2, Axis, Data, Ix2};
 use ndarray_stats::QuantileExt;
 use std::collections::HashMap;
+use std::hash::Hash;
 
 use crate::base_nb::{filter, NaiveBayes, NaiveBayesValidParams};
 use crate::error::{NaiveBayesError, Result};
@@ -225,12 +226,12 @@ where
 /// let model = checked_params.fit_with(Some(model), &ds)?;
 /// # Result::Ok(())
 /// ```
-#[derive(Debug, Clone)]
-pub struct GaussianNb<F, L> {
+#[derive(Debug, Clone, PartialEq)]
+pub struct GaussianNb<F: PartialEq, L: Eq + Hash> {
     class_info: HashMap<L, GaussianClassInfo<F>>,
 }
 
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, PartialEq)]
 struct GaussianClassInfo<F> {
     class_count: usize,
     prior: F,
@@ -284,10 +285,22 @@ mod tests {
         DatasetView,
     };
 
+    use crate::gaussian_nb::GaussianClassInfo;
+    use crate::{GaussianNbParams, GaussianNbValidParams, NaiveBayesError};
     use approx::assert_abs_diff_eq;
     use ndarray::{array, Axis};
     use std::collections::HashMap;
 
+    #[test]
+    fn autotraits() {
+        fn has_autotraits<T: Send + Sync + Sized + Unpin>() {}
+        has_autotraits::<GaussianNb<f64, usize>>();
+        has_autotraits::<GaussianClassInfo<f64>>();
+        has_autotraits::<GaussianNbParams<f64, usize>>();
+        has_autotraits::<GaussianNbValidParams<f64, usize>>();
+        has_autotraits::<NaiveBayesError>();
+    }
+
     #[test]
     fn test_gaussian_nb() -> Result<()> {
         let x = array![

algorithms/linfa-bayes/src/hyperparams.rs

@@ -5,7 +5,7 @@ use std::marker::PhantomData;
 /// A verified hyper-parameter set ready for the estimation of a [Gaussian Naive Bayes model](crate::gaussian_nb::GaussianNb).
 ///
 /// See [`GaussianNb`](crate::gaussian_nb::GaussianNb) for information on the model and [`GaussianNbParams`](crate::hyperparams::GaussianNbParams) for information on hyperparameters.
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct GaussianNbValidParams<F, L> {
     // Required for calculation stability
     var_smoothing: F,
@@ -43,6 +43,7 @@ impl<F: Float, L> GaussianNbValidParams<F, L> {
 /// Returns [`InvalidSmoothing`](NaiveBayesError::InvalidSmoothing) if the smoothing
 /// parameter is negative.
 ///
+#[derive(Debug, Clone, PartialEq)]
 pub struct GaussianNbParams<F, L>(GaussianNbValidParams<F, L>);
 
 impl<F: Float, L> Default for GaussianNbParams<F, L> {
@@ -91,7 +92,7 @@ impl<F: Float, L> ParamGuard for GaussianNbParams<F, L> {
 /// A verified hyper-parameter set ready for the estimation of a [Multinomial Naive Bayes model](crate::multinomial_nb::MultinomialNb).
 ///
 /// See [`MultinomialNb`](crate::multinomial_nb::MultinomialNb) for information on the model and [`MultinomialNbParams`](crate::hyperparams::MultinomialNbParams) for information on hyperparameters.
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct MultinomialNbValidParams<F, L> {
     // Required for calculation stability
     alpha: F,
@@ -129,6 +130,7 @@ impl<F: Float, L> MultinomialNbValidParams<F, L> {
 /// Returns [`InvalidSmoothing`](NaiveBayesError::InvalidSmoothing) if the smoothing
 /// parameter is negative.
 ///
+#[derive(Debug, Clone, PartialEq)]
 pub struct MultinomialNbParams<F, L>(MultinomialNbValidParams<F, L>);
 
 impl<F: Float, L> Default for MultinomialNbParams<F, L> {

algorithms/linfa-bayes/src/multinomial_nb.rs

@@ -3,6 +3,7 @@ use linfa::traits::{Fit, FitWith, PredictInplace};
 use linfa::{Float, Label};
 use ndarray::{Array1, ArrayBase, ArrayView2, Axis, Data, Ix2};
 use std::collections::HashMap;
+use std::hash::Hash;
 
 use crate::base_nb::{filter, NaiveBayes, NaiveBayesValidParams};
 use crate::error::{NaiveBayesError, Result};
@@ -195,12 +196,12 @@ where
 /// let model = checked_params.fit_with(Some(model), &ds)?;
 /// # Result::Ok(())
 /// ```
-#[derive(Debug, Clone)]
-pub struct MultinomialNb<F, L> {
+#[derive(Debug, Clone, PartialEq)]
+pub struct MultinomialNb<F: PartialEq, L: Eq + Hash> {
     class_info: HashMap<L, MultinomialClassInfo<F>>,
 }
 
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, PartialEq)]
 struct MultinomialClassInfo<F> {
     class_count: usize,
     prior: F,
@@ -242,10 +243,21 @@ mod tests {
         DatasetView,
     };
 
+    use crate::multinomial_nb::MultinomialClassInfo;
+    use crate::{MultinomialNbParams, MultinomialNbValidParams};
     use approx::assert_abs_diff_eq;
     use ndarray::{array, Axis};
     use std::collections::HashMap;
 
+    #[test]
+    fn autotraits() {
+        fn has_autotraits<T: Send + Sync + Sized + Unpin>() {}
+        has_autotraits::<MultinomialNb<f64, usize>>();
+        has_autotraits::<MultinomialClassInfo<f64>>();
+        has_autotraits::<MultinomialNbValidParams<f64, usize>>();
+        has_autotraits::<MultinomialNbParams<f64, usize>>();
+    }
+
     #[test]
     fn test_multinomial_nb() -> Result<()> {
         let x = array![[1., 0.], [2., 0.], [3., 0.], [0., 1.], [0., 2.], [0., 3.]];

algorithms/linfa-clustering/src/appx_dbscan/algorithm.rs

@@ -12,7 +12,7 @@ use super::cells_grid::CellsGrid;
     derive(Serialize, Deserialize),
     serde(crate = "serde_crate")
 )]
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 /// DBSCAN (Density-based Spatial Clustering of Applications with Noise)
 /// clusters together neighbouring points, while points in sparse regions are labelled
 /// as noise. Since points may be part of a cluster or noise the transform method returns

algorithms/linfa-clustering/src/appx_dbscan/cells_grid/cell.rs

@@ -5,7 +5,7 @@ use linfa_nn::distance::{Distance, L2Dist};
 use ndarray::{Array1, ArrayView1, ArrayView2, ArrayViewMut1};
 use partitions::PartitionVec;
 
-#[derive(Clone)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 /// A point in a D dimensional euclidean space that memorizes its
 /// status: 'core' or 'non core'
 pub struct StatusPoint {
@@ -31,7 +31,7 @@ impl StatusPoint {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug, PartialEq)]
 /// Informations regarding the cell used in various stages of the approximate DBSCAN
 /// algorithm if it is a core cell
 pub struct CoreCellInfo<F: Float> {
@@ -41,7 +41,7 @@ pub struct CoreCellInfo<F: Float> {
     i_cluster: usize,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug, PartialEq)]
 /// A cell from a grid that partitions the D dimensional euclidean space.
 pub struct Cell<F: Float> {
     /// The index of the intervals of the D dimensional axes where this cell lies

algorithms/linfa-clustering/src/appx_dbscan/cells_grid/mod.rs

@@ -15,6 +15,7 @@ pub type CellVector<F> = PartitionVec<Cell<F>>;
 /// A structure that memorizes all non empty cells by their index's hash
 pub type CellTable = HashMap<Array1<i64>, usize>;
 
+#[derive(Debug, Clone, PartialEq)]
 pub struct CellsGrid<F: Float> {
     table: CellTable,
     cells: CellVector<F>,

algorithms/linfa-clustering/src/appx_dbscan/cells_grid/tests.rs

@@ -1,9 +1,19 @@
 use crate::AppxDbscan;
 
 use super::*;
+use crate::appx_dbscan::cells_grid::cell::CoreCellInfo;
 use linfa::prelude::ParamGuard;
 use ndarray::{arr2, Array2};
 
+#[test]
+fn autotraits() {
+    fn has_autotraits<T: Send + Sync + Sized + Unpin>() {}
+    has_autotraits::<AppxDbscan>();
+    has_autotraits::<StatusPoint>();
+    has_autotraits::<CoreCellInfo<f64>>();
+    has_autotraits::<Cell<f64>>();
+}
+
 #[test]
 fn find_cells_test() {
     let params = AppxDbscan::params(2)

algorithms/linfa-clustering/src/appx_dbscan/counting_tree/mod.rs

@@ -4,14 +4,14 @@ use linfa_nn::distance::{Distance, L2Dist};
 use ndarray::{Array1, Array2, ArrayView1, Axis};
 use std::collections::HashMap;
 
-#[derive(PartialEq, Debug)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum IntersectionType {
     FullyCovered,
     Disjoint,
     Intersecting,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug, PartialEq)]
 /// Tree structure that divides the space in nested cells to perform approximate range counting
 /// Each member of this structure is a node in the tree
 pub struct TreeStructure<F: Float> {

algorithms/linfa-clustering/src/appx_dbscan/counting_tree/tests.rs

@@ -6,6 +6,13 @@ use approx::assert_abs_diff_eq;
 use linfa::ParamGuard;
 use ndarray::{arr1, ArrayView};
 
+#[test]
+fn autotraits() {
+    fn has_autotraits<T: Send + Sync + Sized + Unpin>() {}
+    has_autotraits::<IntersectionType>();
+    has_autotraits::<TreeStructure<f64>>();
+}
+
 #[test]
 fn counting_test() {
     let params = AppxDbscan::params(2)

algorithms/linfa-clustering/src/appx_dbscan/hyperparams.rs

@@ -21,7 +21,7 @@ pub struct AppxDbscanValidParams<F: Float, N> {
     pub(crate) nn_algo: N,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq)]
 /// Helper struct for building a set of [Approximated DBSCAN
 /// hyperparameters](struct.AppxDbscanParams.html)
 pub struct AppxDbscanParams<F: Float, N>(AppxDbscanValidParams<F, N>);

algorithms/linfa-clustering/src/appx_dbscan/tests.rs

@@ -1,13 +1,23 @@
-use crate::{AppxDbscan, AppxDbscanParamsError, Dbscan};
+use crate::{AppxDbscan, AppxDbscanParams, AppxDbscanParamsError, AppxDbscanValidParams, Dbscan};
 use linfa::traits::Transformer;
 use linfa::ParamGuard;
 use linfa_datasets::generate;
+use linfa_nn::distance::L2Dist;
 use ndarray::{arr1, arr2, concatenate, s, Array1, Array2};
 use ndarray_rand::rand::SeedableRng;
 use ndarray_rand::rand_distr::Uniform;
 use rand_xoshiro::Xoshiro256Plus;
 use std::collections::HashMap;
 
+#[test]
+fn autotraits() {
+    fn has_autotraits<T: Send + Sync + Sized + Unpin>() {}
+    has_autotraits::<AppxDbscan>();
+    has_autotraits::<Dbscan>();
+    has_autotraits::<AppxDbscanValidParams<f64, L2Dist>>();
+    has_autotraits::<AppxDbscanParams<f64, L2Dist>>();
+}
+
 #[test]
 fn appx_dbscan_parity() {
     let mut rng = Xoshiro256Plus::seed_from_u64(40);

algorithms/linfa-clustering/src/dbscan/algorithm.rs

@@ -9,7 +9,7 @@ use std::collections::VecDeque;
 use linfa::Float;
 use linfa::{traits::Transformer, DatasetBase};
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 /// DBSCAN (Density-based Spatial Clustering of Applications with Noise)
 /// clusters together points which are close together with enough neighbors
 /// labelled points which are sparsely neighbored as noise. As points may be

algorithms/linfa-clustering/src/dbscan/hyperparams.rs

@@ -9,7 +9,7 @@ use thiserror::Error;
     derive(Serialize, Deserialize),
     serde(crate = "serde_crate")
 )]
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq)]
 /// The set of hyperparameters that can be specified for the execution of
 /// the [DBSCAN algorithm](struct.Dbscan.html).
 pub struct DbscanValidParams<F: Float, D: Distance<F>, N: NearestNeighbour> {
@@ -19,7 +19,7 @@ pub struct DbscanValidParams<F: Float, D: Distance<F>, N: NearestNeighbour> {
     pub(crate) nn_algo: N,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq)]
 /// Helper struct for building a set of [DBSCAN hyperparameters](struct.DbscanParams.html)
 pub struct DbscanParams<F: Float, D: Distance<F>, N: NearestNeighbour>(DbscanValidParams<F, D, N>);
 
@@ -106,10 +106,18 @@ impl<F: Float, D: Distance<F>, N: NearestNeighbour> DbscanValidParams<F, D, N> {
 
 #[cfg(test)]
 mod tests {
-    use linfa_nn::{distance::L2Dist, CommonNearestNeighbour};
+    use linfa_nn::{distance::L2Dist, CommonNearestNeighbour, KdTree};
 
     use super::*;
 
+    #[test]
+    fn autotraits() {
+        fn has_autotraits<T: Send + Sync + Sized + Unpin>() {}
+        has_autotraits::<DbscanParamsError>();
+        has_autotraits::<DbscanParams<f64, L2Dist, KdTree>>();
+        has_autotraits::<DbscanValidParams<f64, L2Dist, KdTree>>();
+    }
+
     #[test]
     fn tolerance_cannot_be_zero() {
         let res = DbscanParams::new(2, L2Dist, CommonNearestNeighbour::KdTree)

algorithms/linfa-clustering/src/gaussian_mixture/algorithm.rs

@@ -495,6 +495,17 @@ mod tests {
     use ndarray_rand::rand::SeedableRng;
     use ndarray_rand::rand_distr::{Distribution, StandardNormal};
 
+    #[test]
+    fn autotraits() {
+        fn has_autotraits<T: Send + Sync + Sized + Unpin>() {}
+        has_autotraits::<GaussianMixtureModel<f64>>();
+        has_autotraits::<GmmError>();
+        has_autotraits::<GmmParams<f64, Xoshiro256Plus>>();
+        has_autotraits::<GmmValidParams<f64, Xoshiro256Plus>>();
+        has_autotraits::<GmmInitMethod>();
+        has_autotraits::<GmmCovarType>();
+    }
+
     pub struct MultivariateNormal {
         pub mean: Array1<f64>,
         pub covariance: Array2<f64>,

algorithms/linfa-clustering/src/gaussian_mixture/hyperparams.rs

@@ -11,7 +11,7 @@ use linfa::{Float, ParamGuard};
     derive(Serialize, Deserialize),
     serde(crate = "serde_crate")
 )]
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 /// A specifier for the type of the relation between components' covariances.
 pub enum GmmCovarType {
     /// each component has its own general covariance matrix
@@ -23,7 +23,7 @@ pub enum GmmCovarType {
     derive(Serialize, Deserialize),
     serde(crate = "serde_crate")
 )]
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 /// A specifier for the method used for the initialization of the fitting algorithm of GMM
 pub enum GmmInitMethod {
     /// GMM fitting algorithm is initalized with the esult of the [KMeans](struct.KMeans.html) clustering.
@@ -37,7 +37,7 @@ pub enum GmmInitMethod {
     derive(Serialize, Deserialize),
     serde(crate = "serde_crate")
 )]
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 /// The set of hyperparameters that can be specified for the execution of
 /// the [GMM algorithm](struct.GaussianMixtureModel.html).
 pub struct GmmValidParams<F: Float, R: Rng> {
@@ -90,7 +90,7 @@ impl<F: Float, R: Rng + Clone> GmmValidParams<F, R> {
     derive(Serialize, Deserialize),
     serde(crate = "serde_crate")
 )]
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 /// The set of hyperparameters that can be specified for the execution of
 /// the [GMM algorithm](struct.GaussianMixtureModel.html).
 pub struct GmmParams<F: Float, R: Rng>(GmmValidParams<F, R>);

algorithms/linfa-clustering/src/k_means/algorithm.rs

@@ -587,6 +587,7 @@ pub(crate) fn closest_centroid<F: Float, D: Distance<F>>(
 mod tests {
     use super::super::KMeansInit;
     use super::*;
+    use crate::KMeansParamsError;
     use approx::assert_abs_diff_eq;
     use linfa_nn::distance::L1Dist;
     use ndarray::{array, concatenate, Array, Array1, Array2, Axis};
@@ -595,6 +596,15 @@ mod tests {
     use ndarray_rand::rand_distr::Uniform;
     use ndarray_rand::RandomExt;
 
+    #[test]
+    fn autotraits() {
+        fn has_autotraits<T: Send + Sync + Sized + Unpin>() {}
+        has_autotraits::<KMeans<f64, L2Dist>>();
+        has_autotraits::<KMeansParamsError>();
+        has_autotraits::<KMeansError>();
+        has_autotraits::<IncrKMeansError<String>>();
+    }
+
     fn function_test_1d(x: &Array2<f64>) -> Array2<f64> {
         let mut y = Array2::zeros(x.dim());
         Zip::from(&mut y).and(x).for_each(|yi, &xi| {