Run cargo fmt and cargo clippy

Author: cschwan

pineappl/src/boc.rs

@@ -26,7 +26,7 @@ pub enum Kinematics {
 
 /// TODO
 #[repr(C)]
-#[derive(Clone, Deserialize, PartialEq, Serialize)]
+#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)]
 pub enum ScaleFuncForm {
     /// TODO
     NoScale,
@@ -163,7 +163,7 @@ impl ScaleFuncForm {
 }
 
 /// TODO
-#[derive(Clone, Deserialize, PartialEq, Serialize)]
+#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)]
 pub struct Scales {
     /// TODO
     pub ren: ScaleFuncForm,
@@ -225,6 +225,7 @@ impl Bin {
     /// # Panics
     ///
     /// TODO
+    #[must_use]
     pub fn new(limits: Vec<(f64, f64)>, normalization: f64) -> Self {
         for limits in &limits {
             assert!(limits.1 >= limits.0);
@@ -237,21 +238,25 @@ impl Bin {
     }
 
     /// TODO
+    #[must_use]
     pub fn dimensions(&self) -> usize {
         self.limits.len()
     }
 
     /// TODO
-    pub fn normalization(&self) -> f64 {
+    #[must_use]
+    pub const fn normalization(&self) -> f64 {
         self.normalization
     }
 
     /// TODO
+    #[must_use]
     pub fn limits(&self) -> &[(f64, f64)] {
         &self.limits
     }
 
     /// TODO
+    #[must_use]
     pub fn partial_eq_with_ulps(&self, other: &Self, ulps: i64) -> bool {
         self.limits.iter().zip(other.limits()).all(|(&lhs, &rhs)| {
             approx_eq!(f64, lhs.0, rhs.0, ulps = ulps) && approx_eq!(f64, lhs.1, rhs.1, ulps = ulps)
@@ -267,6 +272,10 @@ pub struct BinsWithFillLimits {
 }
 
 impl BinsWithFillLimits {
+    /// TODO
+    ///
+    /// # Errors
+    ///
     /// TODO
     pub fn new(bins: Vec<Bin>, fill_limits: Vec<f64>) -> Result<Self, ()> {
         // TODO: validate the bins
@@ -284,6 +293,10 @@ impl BinsWithFillLimits {
         Ok(Self { bins, fill_limits })
     }
 
+    /// TODO
+    ///
+    /// # Errors
+    ///
     /// TODO
     pub fn from_fill_limits(fill_limits: Vec<f64>) -> Result<Self, ()> {
         let bins = fill_limits
@@ -294,6 +307,10 @@ impl BinsWithFillLimits {
         Self::new(bins, fill_limits)
     }
 
+    /// TODO
+    ///
+    /// # Errors
+    ///
     /// TODO
     ///
     /// # Panics
@@ -338,16 +355,19 @@ impl BinsWithFillLimits {
     }
 
     /// TODO
+    #[must_use]
     pub fn bins(&self) -> &[Bin] {
         &self.bins
     }
 
     /// TODO
+    #[must_use]
     pub fn len(&self) -> usize {
         self.bins.len()
     }
 
     /// TODO
+    #[must_use]
     pub fn dimensions(&self) -> usize {
         self.bins
             .first()
@@ -357,6 +377,7 @@ impl BinsWithFillLimits {
     }
 
     /// TODO
+    #[must_use]
     pub fn fill_index(&self, value: f64) -> Option<usize> {
         match self
             .fill_limits
@@ -371,6 +392,7 @@ impl BinsWithFillLimits {
     }
 
     /// TODO
+    #[must_use]
     pub fn fill_limits(&self) -> &[f64] {
         &self.fill_limits
     }
@@ -380,6 +402,10 @@ impl BinsWithFillLimits {
         self.bins.iter().map(Bin::normalization).collect()
     }
 
+    /// TODO
+    ///
+    /// # Errors
+    ///
     /// TODO
     pub fn subset(&self, range: impl RangeBounds<usize>) -> Result<Self, ()> {
         let range_plus_one = (
@@ -417,6 +443,10 @@ impl BinsWithFillLimits {
         )
     }
 
+    /// TODO
+    ///
+    /// # Errors
+    ///
     /// TODO
     // TODO: change range to `RangeBounds<usize>`
     pub fn merge(&self, range: Range<usize>) -> Result<Self, ()> {
@@ -435,11 +465,7 @@ impl BinsWithFillLimits {
         let mut fill_limits = self.fill_limits.clone();
         let dim = self.dimensions();
 
-        limits [range.start]
-        [dim - 1]
-        .1 = limits [range.end - 1]
-        [dim - 1]
-        .1;
+        limits[range.start][dim - 1].1 = limits[range.end - 1][dim - 1].1;
         normalizations[range.start] += normalizations[range.start + 1..range.end]
             .iter()
             .sum::<f64>();
@@ -458,17 +484,20 @@ impl BinsWithFillLimits {
         )
     }
 
+    /// TODO
+    ///
+    /// # Panics
+    ///
     /// TODO
     pub fn remove(&mut self, index: usize) -> Bin {
-        if self.len() == 1 {
-            panic!("TODO");
-        }
+        assert!(self.len() > 1);
 
         self.fill_limits.pop().unwrap();
         self.bins.remove(index)
     }
 
     /// TODO
+    #[must_use]
     pub fn bins_partial_eq_with_ulps(&self, other: &Self, ulps: i64) -> bool {
         self.bins
             .iter()
@@ -623,10 +652,9 @@ impl FromStr for BinsWithFillLimits {
             normalizations.push(normalization);
         }
 
-        Ok(BinsWithFillLimits::from_limits_and_normalizations(limits, normalizations)
-    // TODO: implement proper error handling
-    .unwrap()
-    )
+        Ok(Self::from_limits_and_normalizations(limits, normalizations)
+            // TODO: implement proper error handling
+            .unwrap())
     }
 }
 

pineappl/src/convolutions.rs

@@ -307,6 +307,7 @@ impl ConvType {
     }
 
     /// TODO
+    #[must_use]
     pub const fn is_pdf(&self) -> bool {
         matches!(self, Self::UnpolPDF | Self::PolPDF)
     }

pineappl/src/evolution.rs

@@ -66,7 +66,7 @@ pub struct OperatorSliceInfo {
     /// Particle ID basis for `FkTable`.
     pub pid_basis: PidBasis,
     /// Type of convolution which this operator evolves. This also determines whether [`fac0`]
-    /// and ['fac1`] is a factorization ([`ConvType::UnpolPDF`] or [`ConvType::PolPDF`]) or a
+    /// and [`fac1`] is a factorization ([`ConvType::UnpolPDF`] or [`ConvType::PolPDF`]) or a
     /// fragmentation ([`ConvType::UnpolFF`] or [`ConvType::PolFF`]) scale.
     pub conv_type: ConvType,
 }

pineappl/src/grid.rs

@@ -9,6 +9,7 @@ use super::import_subgrid::ImportSubgridV1;
 use super::interp_subgrid::InterpSubgridV1;
 use super::interpolation::Interp;
 use super::pids::PidBasis;
+use super::reference::Reference;
 use super::subgrid::{self, Subgrid, SubgridEnum};
 use super::v0;
 use bitflags::bitflags;
@@ -25,7 +26,6 @@ use std::io::{self, BufRead, BufReader, BufWriter, Read, Write};
 use std::ops::Range;
 use std::{iter, mem};
 use thiserror::Error;
-use super::reference::Reference;
 
 const BIN_AXIS: Axis = Axis(1);
 
@@ -502,7 +502,11 @@ impl Grid {
     /// When the given bins are non-consecutive, an error is returned.
     pub fn merge_bins(&mut self, range: Range<usize>) -> Result<(), GridError> {
         // check if the bins in `range` can be merged - if not return without changing `self`
-        self.bwfl = self.bwfl().merge(range.clone()).unwrap();
+        self.bwfl = self
+            .bwfl()
+            .merge(range.clone())
+            // TODO: use proper error handling
+            .unwrap_or_else(|_| unreachable!());
 
         let (intermediate, right) = self.subgrids.view().split_at(BIN_AXIS, range.end);
         let (left, merge) = intermediate.split_at(BIN_AXIS, range.start);
@@ -522,7 +526,7 @@ impl Grid {
 
         self.subgrids = ndarray::concatenate(BIN_AXIS, &[left, merged.view(), right])
             // UNWRAP: if this fails there's a bug
-            .unwrap();
+            .unwrap_or_else(|_| unreachable!());
 
         Ok(())
     }
@@ -594,7 +598,7 @@ impl Grid {
                     .collect(),
             )
             // TODO: do proper error handling
-            .unwrap();
+            .unwrap_or_else(|_| unreachable!());
             self.bwfl = new_bwfl;
         }
 
@@ -668,9 +672,19 @@ impl Grid {
             let other_order = &other.orders[i];
             let other_entry = &other.channels[k];
 
-            let self_i = self.orders.iter().position(|x| x == other_order).unwrap();
+            let self_i = self
+                .orders
+                .iter()
+                .position(|x| x == other_order)
+                // UNWRAP: we added the orders previously so we must find it
+                .unwrap_or_else(|| unreachable!());
             let self_j = bin_indices[j];
-            let self_k = self.channels.iter().position(|y| y == other_entry).unwrap();
+            let self_k = self
+                .channels
+                .iter()
+                .position(|y| y == other_entry)
+                // UNWRAP: we added the channels previously so we must find it
+                .unwrap_or_else(|| unreachable!());
 
             if self.subgrids[[self_i, self_j, self_k]].is_empty() {
                 mem::swap(&mut self.subgrids[[self_i, self_j, self_k]], subgrid);
@@ -798,6 +812,10 @@ impl Grid {
         self.subgrids.view_mut()
     }
 
+    /// TODO
+    ///
+    /// # Errors
+    ///
     /// TODO
     pub fn set_bwfl(&mut self, bwfl: BinsWithFillLimits) -> Result<(), GridError> {
         if bwfl.len() != self.bwfl().len() {
@@ -814,7 +832,8 @@ impl Grid {
     }
 
     /// TODO
-    pub fn bwfl(&self) -> &BinsWithFillLimits {
+    #[must_use]
+    pub const fn bwfl(&self) -> &BinsWithFillLimits {
         &self.bwfl
     }
 
@@ -1252,12 +1271,10 @@ impl Grid {
                 } else {
                     assert_approx_eq!(f64, fac0, info_0.fac0, ulps = 8);
                 }
+            } else if frg0 < 0.0 {
+                frg0 = info_0.fac0;
             } else {
-                if frg0 < 0.0 {
-                    frg0 = info_0.fac0;
-                } else {
-                    assert_approx_eq!(f64, frg0, info_0.fac0, ulps = 8);
-                }
+                assert_approx_eq!(f64, frg0, info_0.fac0, ulps = 8);
             }
 
             for (index, info) in infos_rest.iter().enumerate() {
@@ -1287,12 +1304,10 @@ impl Grid {
                     } else {
                         assert_approx_eq!(f64, fac0, info.fac0, ulps = 8);
                     }
+                } else if frg0 < 0.0 {
+                    frg0 = info.fac0;
                 } else {
-                    if frg0 < 0.0 {
-                        frg0 = info.fac0;
-                    } else {
-                        assert_approx_eq!(f64, frg0, info.fac0, ulps = 8);
-                    }
+                    assert_approx_eq!(f64, frg0, info.fac0, ulps = 8);
                 }
             }
 
@@ -1352,12 +1367,10 @@ impl Grid {
             };
             let (frg, scale_values) = if frg0 < 0.0 {
                 (ScaleFuncForm::NoScale, vec![fac0])
+            } else if fac0 < 0.0 || approx_eq!(f64, fac0, frg0, ulps = 8) {
+                (ScaleFuncForm::Scale(0), vec![frg0])
             } else {
-                if fac0 < 0.0 || approx_eq!(f64, fac0, frg0, ulps = 8) {
-                    (ScaleFuncForm::Scale(0), vec![frg0])
-                } else {
-                    (ScaleFuncForm::Scale(1), vec![fac0, frg0])
-                }
+                (ScaleFuncForm::Scale(1), vec![fac0, frg0])
             };
 
             let (subgrids, channels) = evolution::evolve_slice_with_many(

pineappl/src/interpolation.rs

@@ -62,7 +62,7 @@ fn lagrange_weights(i: usize, n: usize, u: f64) -> f64 {
 
 /// TODO
 #[repr(C)]
-#[derive(Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[derive(Clone, Copy, Deserialize, Eq, PartialEq, Serialize)]
 pub enum ReweightMeth {
     /// TODO
     ApplGridX,
@@ -72,7 +72,7 @@ pub enum ReweightMeth {
 
 /// TODO
 #[repr(C)]
-#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
 pub enum Map {
     /// TODO
     ApplGridF2,
@@ -82,7 +82,7 @@ pub enum Map {
 
 /// TODO
 #[repr(C)]
-#[derive(Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[derive(Clone, Copy, Deserialize, Eq, PartialEq, Serialize)]
 pub enum InterpMeth {
     /// TODO
     Lagrange,

pineappl/src/subgrid.rs

@@ -35,14 +35,18 @@ pub enum SubgridEnum {
 
 impl SubgridEnum {
     /// TODO
-    pub fn merge(&mut self, other: &SubgridEnum, transpose: Option<(usize, usize)>) {
+    pub fn merge(&mut self, other: &Self, transpose: Option<(usize, usize)>) {
         if other.is_empty() {
             return;
         }
-        if let SubgridEnum::EmptySubgridV1(_) = self {
-            if transpose.is_none() {*self = other.clone();} else {todo!();}
+        if let Self::EmptySubgridV1(_) = self {
+            if transpose.is_none() {
+                *self = other.clone();
+            } else {
+                todo!();
+            }
         } else {
-        self.merge_impl(other, transpose);
+            self.merge_impl(other, transpose);
         }
     }
 }