Run cargo fmt.

Author: ralfbiedert

benches/svm_dense.rs

@@ -20,7 +20,7 @@ mod svm_dense {
         let mut problem = FeatureVector::from(&svm);
         let problem_mut = problem.features();
 
-        for i in 0 .. num_attributes {
+        for i in 0..num_attributes {
             problem_mut[i as usize] = i as f32;
         }
 
@@ -30,44 +30,68 @@ mod svm_dense {
     // RBF
 
     #[bench]
-    fn predict_rbf_sv128_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "rbf", 128, 16)); }
+    fn predict_rbf_sv128_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "rbf", 128, 16));
+    }
 
     #[bench]
-    fn predict_rbf_sv1024_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "rbf", 1024, 16)); }
+    fn predict_rbf_sv1024_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "rbf", 1024, 16));
+    }
 
     #[bench]
-    fn predict_rbf_sv1024_attr1024(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "rbf", 1024, 1024)); }
+    fn predict_rbf_sv1024_attr1024(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "rbf", 1024, 1024));
+    }
 
     // Linear
 
     #[bench]
-    fn predict_linear_sv128_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "linear", 128, 16)); }
+    fn predict_linear_sv128_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "linear", 128, 16));
+    }
 
     #[bench]
-    fn predict_linear_sv1024_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "linear", 1024, 16)); }
+    fn predict_linear_sv1024_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "linear", 1024, 16));
+    }
 
     #[bench]
-    fn predict_linear_sv1024_attr1024(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "linear", 1024, 1024)); }
+    fn predict_linear_sv1024_attr1024(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "linear", 1024, 1024));
+    }
 
     // Poly
 
     #[bench]
-    fn predict_poly_sv128_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "polynomial", 128, 16)); }
+    fn predict_poly_sv128_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "polynomial", 128, 16));
+    }
 
     #[bench]
-    fn predict_poly_sv1024_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "polynomial", 1024, 16)); }
+    fn predict_poly_sv1024_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "polynomial", 1024, 16));
+    }
 
     #[bench]
-    fn predict_poly_sv1024_attr1024(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "polynomial", 1024, 1024)); }
+    fn predict_poly_sv1024_attr1024(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "polynomial", 1024, 1024));
+    }
 
     // Sigmoid
 
     #[bench]
-    fn predict_sigmoid_sv128_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "sigmoid", 128, 16)); }
+    fn predict_sigmoid_sv128_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "sigmoid", 128, 16));
+    }
 
     #[bench]
-    fn predict_sigmoid_sv1024_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "sigmoid", 1024, 16)); }
+    fn predict_sigmoid_sv1024_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "sigmoid", 1024, 16));
+    }
 
     #[bench]
-    fn predict_sigmoid_sv1024_attr1024(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "sigmoid", 1024, 1024)); }
+    fn predict_sigmoid_sv1024_attr1024(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "sigmoid", 1024, 1024));
+    }
 }

benches/svm_sparse.rs

@@ -9,7 +9,7 @@ mod util;
 
 mod svm_sparse {
     use crate::test::Bencher;
-    use ffsvm::{Predict, FeatureVector, SparseSVM};
+    use ffsvm::{FeatureVector, Predict, SparseSVM};
     use std::convert::TryFrom;
 
     /// Produces a test case run for benchmarking
@@ -20,7 +20,7 @@ mod svm_sparse {
         let mut problem = FeatureVector::from(&svm);
         let problem_mut = problem.features();
 
-        for i in 0 .. num_attributes {
+        for i in 0..num_attributes {
             problem_mut[i as usize] = i as f32;
         }
 
@@ -30,45 +30,68 @@ mod svm_sparse {
     // RBF
 
     #[bench]
-    fn predict_rbf_sv128_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "rbf", 128, 16)); }
+    fn predict_rbf_sv128_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "rbf", 128, 16));
+    }
 
     #[bench]
-    fn predict_rbf_sv1024_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "rbf", 1024, 16)); }
+    fn predict_rbf_sv1024_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "rbf", 1024, 16));
+    }
 
     #[bench]
-    fn predict_rbf_sv1024_attr1024(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "rbf", 1024, 1024)); }
+    fn predict_rbf_sv1024_attr1024(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "rbf", 1024, 1024));
+    }
 
     // Linear
 
     #[bench]
-    fn predict_linear_sv128_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "linear", 128, 16)); }
+    fn predict_linear_sv128_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "linear", 128, 16));
+    }
 
     #[bench]
-    fn predict_linear_sv1024_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "linear", 1024, 16)); }
+    fn predict_linear_sv1024_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "linear", 1024, 16));
+    }
 
     #[bench]
-    fn predict_linear_sv1024_attr1024(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "linear", 1024, 1024)); }
+    fn predict_linear_sv1024_attr1024(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "linear", 1024, 1024));
+    }
 
     // Poly
 
     #[bench]
-    fn predict_poly_sv128_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "polynomial", 128, 16)); }
+    fn predict_poly_sv128_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "polynomial", 128, 16));
+    }
 
     #[bench]
-    fn predict_poly_sv1024_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "polynomial", 1024, 16)); }
+    fn predict_poly_sv1024_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "polynomial", 1024, 16));
+    }
 
     #[bench]
-    fn predict_poly_sv1024_attr1024(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "polynomial", 1024, 1024)); }
+    fn predict_poly_sv1024_attr1024(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "polynomial", 1024, 1024));
+    }
 
     // Sigmoid
 
     #[bench]
-    fn predict_sigmoid_sv128_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "sigmoid", 128, 16)); }
+    fn predict_sigmoid_sv128_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "sigmoid", 128, 16));
+    }
 
     #[bench]
-    fn predict_sigmoid_sv1024_attr16(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "sigmoid", 1024, 16)); }
+    fn predict_sigmoid_sv1024_attr16(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "sigmoid", 1024, 16));
+    }
 
     #[bench]
-    fn predict_sigmoid_sv1024_attr1024(b: &mut Bencher) { b.iter(produce_testcase("c_svc", "sigmoid", 1024, 1024)); }
-
+    fn predict_sigmoid_sv1024_attr1024(b: &mut Bencher) {
+        b.iter(produce_testcase("c_svc", "sigmoid", 1024, 1024));
+    }
 }

benches/util.rs

@@ -10,7 +10,7 @@ pub fn random_dense<'b>(svm_type: &'b str, kernel_type: &'b str, total_sv: u32,
         total_sv,
         gamma: Some(rng.gen::<f32>()),
         coef0: Some(rng.gen::<f32>()),
-        degree: Some(rng.gen_range(1 .. 10)),
+        degree: Some(rng.gen_range(1..10)),
         nr_class: 2,
         rho: vec![rng.gen::<f64>()],
         label: vec![0, 1],
@@ -19,10 +19,10 @@ pub fn random_dense<'b>(svm_type: &'b str, kernel_type: &'b str, total_sv: u32,
         nr_sv: vec![total_sv / 2, total_sv / 2],
     };
 
-    let vectors = (0 .. total_sv)
+    let vectors = (0..total_sv)
         .map(|_| SupportVector {
             coefs: vec![rng.gen::<f32>()],
-            features: (0 .. attr)
+            features: (0..attr)
                 .map(|i| Attribute {
                     index: i,
                     value: rng.gen::<f32>(),

src/errors.rs

@@ -51,9 +51,13 @@ pub enum Error {
 // }
 
 impl From<ParseFloatError> for Error {
-    fn from(_e: ParseFloatError) -> Self { Self::Parsing("ParseFloatError".to_owned()) }
+    fn from(_e: ParseFloatError) -> Self {
+        Self::Parsing("ParseFloatError".to_owned())
+    }
 }
 
 impl From<ParseIntError> for Error {
-    fn from(_: ParseIntError) -> Self { Self::Parsing("ParseIntError".to_owned()) }
+    fn from(_: ParseIntError) -> Self {
+        Self::Parsing("ParseIntError".to_owned())
+    }
 }

src/parser.rs

@@ -61,15 +61,21 @@ pub struct ModelFile<'a> {
 impl<'a> ModelFile<'a> {
     #[doc(hidden)]
     #[must_use]
-    pub const fn new(header: Header<'a>, vectors: Vec<SupportVector>) -> Self { Self { header, vectors } }
+    pub const fn new(header: Header<'a>, vectors: Vec<SupportVector>) -> Self {
+        Self { header, vectors }
+    }
 
     #[doc(hidden)]
     #[must_use]
-    pub const fn header(&self) -> &Header { &self.header }
+    pub const fn header(&self) -> &Header {
+        &self.header
+    }
 
     #[doc(hidden)]
     #[must_use]
-    pub fn vectors(&self) -> &[SupportVector] { self.vectors.as_slice() }
+    pub fn vectors(&self) -> &[SupportVector] {
+        self.vectors.as_slice()
+    }
 }
 
 #[doc(hidden)]

src/sparse.rs

@@ -21,11 +21,17 @@ impl<T> SparseVector<T>
 where
     T: Clone + Copy + Default,
 {
-    pub const fn new() -> Self { Self { entries: Vec::new() } }
+    pub const fn new() -> Self {
+        Self { entries: Vec::new() }
+    }
 
-    pub fn clear(&mut self) { self.entries.clear(); }
+    pub fn clear(&mut self) {
+        self.entries.clear();
+    }
 
-    pub const fn iter(&self) -> SparseVectorIter<'_, T> { SparseVectorIter { vector: self, index: 0 } }
+    pub const fn iter(&self) -> SparseVectorIter<'_, T> {
+        SparseVectorIter { vector: self, index: 0 }
+    }
 }
 
 /// Basic iterator struct to go over matrix
@@ -120,10 +126,14 @@ where
         }
     }
 
-    pub fn row(&self, row: usize) -> &SparseVector<T> { &self.vectors[row] }
+    pub fn row(&self, row: usize) -> &SparseVector<T> {
+        &self.vectors[row]
+    }
 
     #[inline]
-    pub const fn row_iter(&self) -> SparseMatrixIter<'_, T> { SparseMatrixIter { matrix: self, index: 0 } }
+    pub const fn row_iter(&self) -> SparseMatrixIter<'_, T> {
+        SparseMatrixIter { matrix: self, index: 0 }
+    }
 }
 
 impl<T> Index<(usize, usize)> for SparseMatrix<T>
@@ -132,14 +142,18 @@ where
 {
     type Output = T;
 
-    fn index(&self, index: (usize, usize)) -> &T { &self.vectors[index.0][index.1] }
+    fn index(&self, index: (usize, usize)) -> &T {
+        &self.vectors[index.0][index.1]
+    }
 }
 
 impl<T> IndexMut<(usize, usize)> for SparseMatrix<T>
 where
     T: Copy + Sized + Default,
 {
-    fn index_mut(&mut self, index: (usize, usize)) -> &mut T { &mut self.vectors[index.0][index.1] }
+    fn index_mut(&mut self, index: (usize, usize)) -> &mut T {
+        &mut self.vectors[index.0][index.1]
+    }
 }
 
 /// Basic iterator struct to go over matrix

src/svm/core/dense.rs

@@ -60,7 +60,8 @@ impl DenseSVM {
     ///
     /// If the label was found its index returned in the [`Option`], otherwise `None`
     /// is returned.
-    #[must_use] pub fn class_index_for_label(&self, label: i32) -> Option<usize> {
+    #[must_use]
+    pub fn class_index_for_label(&self, label: i32) -> Option<usize> {
         for (i, class) in self.classes.iter().enumerate() {
             if class.label != label {
                 continue;
@@ -84,7 +85,8 @@ impl DenseSVM {
     ///
     /// If the index was found it is returned in the [`Option`], otherwise `None`
     /// is returned.
-    #[must_use] pub fn class_label_for_index(&self, index: usize) -> Option<i32> {
+    #[must_use]
+    pub fn class_label_for_index(&self, index: usize) -> Option<i32> {
         if index >= self.classes.len() {
             None
         } else {
@@ -116,7 +118,9 @@ impl DenseSVM {
     }
 
     /// Based on kernel values, computes the decision values for this problem.
-    pub(crate) fn compute_classification_values(&self, problem: &mut FeatureVector<VecSimd<f32x8>>) { compute_classification_values_impl!(self, problem) }
+    pub(crate) fn compute_classification_values(&self, problem: &mut FeatureVector<VecSimd<f32x8>>) {
+        compute_classification_values_impl!(self, problem)
+    }
 
     /// Based on kernel values, computes the decision values for this problem.
     pub(crate) fn compute_regression_values(&self, problem: &mut FeatureVector<VecSimd<f32x8>>) {
@@ -132,10 +136,16 @@ impl DenseSVM {
     }
 
     /// Returns number of attributes, reflecting the libSVM model.
-    #[must_use] pub const fn attributes(&self) -> usize { self.num_attributes }
+    #[must_use]
+    pub const fn attributes(&self) -> usize {
+        self.num_attributes
+    }
 
     /// Returns number of classes, reflecting the libSVM model.
-    #[must_use] pub fn classes(&self) -> usize { self.classes.len() }
+    #[must_use]
+    pub fn classes(&self) -> usize {
+        self.classes.len()
+    }
 }
 
 impl Predict<VecSimd<f32x8>> for DenseSVM {
@@ -161,7 +171,9 @@ impl Predict<VecSimd<f32x8>> for DenseSVM {
         }
     }
 
-    fn predict_probability(&self, problem: &mut FeatureVector<VecSimd<f32x8>>) -> Result<(), Error> { predict_probability_impl!(self, problem) }
+    fn predict_probability(&self, problem: &mut FeatureVector<VecSimd<f32x8>>) -> Result<(), Error> {
+        predict_probability_impl!(self, problem)
+    }
 }
 
 impl<'a> TryFrom<&'a str> for DenseSVM {
@@ -190,7 +202,7 @@ impl<'a> TryFrom<&'a ModelFile<'_>> for DenseSVM {
             let stop_offset = start_offset + *num_sv_per_class as usize;
 
             // Set support vector and coefficients
-            for (i_vector, vector) in vectors[start_offset .. stop_offset].iter().enumerate() {
+            for (i_vector, vector) in vectors[start_offset..stop_offset].iter().enumerate() {
                 let mut last_attribute = None;
 
                 // Set support vectors