Apply clippy

Author: GBathie

src/algos/beam_search/cache.rs

@@ -76,7 +76,7 @@ impl EnumFormulaCache<BoolCharac> for BeamSearchCache {
         let iter_size = size - 1;
         let iter_formulas = old_lines[iter_size].iter().map(|pf| &pf.f);
 
-        let iter_pairs_size = (size + 1) / 2;
+        let iter_pairs_size = size.div_ceil(2);
         let iter_pairs = old_lines
             .iter()
             .zip(old_lines.iter().rev())
@@ -120,7 +120,7 @@ pub(crate) struct BeamSearchBoolCacheLine<'a> {
     max_line_size: usize,
 }
 
-impl<'a> BeamSearchBoolCacheLine<'a> {
+impl BeamSearchBoolCacheLine<'_> {
     fn dominates(&self, f: &BoolFormula) -> Option<<BoolCharac as Hashed>::HashType> {
         self.line.iter().find_map(|sv| {
             if sv.dominates(f) {
@@ -132,7 +132,7 @@ impl<'a> BeamSearchBoolCacheLine<'a> {
     }
 }
 
-impl<'a> EnumFormulaCacheLine<BoolCharac> for BeamSearchBoolCacheLine<'a> {
+impl EnumFormulaCacheLine<BoolCharac> for BeamSearchBoolCacheLine<'_> {
     fn push(&mut self, f: BoolFormula) -> bool {
         if self.dominates(&f).is_some() {
             return false;

src/bool/cache.rs

@@ -90,7 +90,7 @@ impl EnumFormulaCache<BoolCharac> for BoolCache {
         let iter_size = size - 1;
         let iter_formulas = old_lines[iter_size].iter();
 
-        let iter_pairs_size = (size + 1) / 2;
+        let iter_pairs_size = size.div_ceil(2);
         let iter_pairs = old_lines
             .iter()
             .zip(old_lines.iter().rev())
@@ -141,7 +141,7 @@ pub(crate) struct BoolCacheLine<'a> {
     size_index: usize,
 }
 
-impl<'a> BoolCacheLine<'a> {
+impl BoolCacheLine<'_> {
     fn dominates(&self, f: &BoolFormula) -> Option<<BoolCharac as Hashed>::HashType> {
         // Iterate in reverse order to start with the densest formulas,
         // which are more likely to dominate.
@@ -162,7 +162,7 @@ impl<'a> BoolCacheLine<'a> {
     }
 }
 
-impl<'a> EnumFormulaCacheLine<BoolCharac> for BoolCacheLine<'a> {
+impl EnumFormulaCacheLine<BoolCharac> for BoolCacheLine<'_> {
     fn push(&mut self, f: BoolFormula) -> bool {
         assert_eq!(f.size, self.size_index);
         if self.dominates(&f).is_some() {

src/ltl/cache.rs

@@ -62,7 +62,7 @@ impl EnumFormulaCache<LtlCharac> for LtlCache {
         let iter_size = new_size - 1;
         let iter_formulas = old_lines[iter_size].iter();
 
-        let iter_pairs_size = (new_size + 1) / 2;
+        let iter_pairs_size = new_size.div_ceil(2);
         let iter_pairs = old_lines
             .iter()
             .zip(old_lines.iter().rev())
@@ -113,7 +113,7 @@ pub(crate) struct LtlCacheLine<'a> {
     hashes: &'a mut FxHashMap<LtlHash, (usize, usize)>,
 }
 
-impl<'a> EnumFormulaCacheLine<LtlCharac> for LtlCacheLine<'a> {
+impl EnumFormulaCacheLine<LtlCharac> for LtlCacheLine<'_> {
     fn push(&mut self, f: LtlFormula) -> bool {
         assert_eq!(f.size, self.size_index);
         match self.hashes.entry(f.hashed()) {

src/ops/binary.rs

@@ -27,10 +27,7 @@ impl LtlBinaryOp {
 
     /// Whether this LTL operator is boolean.
     pub(crate) fn is_boolean(&self) -> bool {
-        match self {
-            LtlBinaryOp::Or | LtlBinaryOp::And => true,
-            _ => false,
-        }
+        matches!(self, LtlBinaryOp::Or | LtlBinaryOp::And)
     }
 
     /// Apply the operator to two characteristic vectors.