fixed several clippy issues

Author: ohad-agadi

src/algorithms/convolution/mod.rs

@@ -454,7 +454,6 @@ pub mod generic_tests {
 
     use super::*;
     use crate::homomorphism::*;
-    use crate::ring::*;
 
     pub fn test_convolution<C, R>(convolution: C, ring: R, scale: El<R>)
     where

src/algorithms/fft/factor_fft.rs

@@ -408,8 +408,6 @@ use crate::algorithms::fft::bluestein::BluesteinFFT;
 #[cfg(test)]
 use crate::algorithms::unity_root::*;
 #[cfg(test)]
-use crate::rings::zn::ZnRingStore;
-#[cfg(test)]
 use crate::rings::zn::zn_64;
 #[cfg(test)]
 use crate::rings::zn::zn_static::{Fp, Zn};

src/algorithms/splitting_field.rs

@@ -623,9 +623,8 @@ fn test_extend_field() {
 }
 
 #[test]
-#[ignore]
+#[ignore = "slow. TODO: Introduce a slow test suite."]
 fn test_variety_from_lex_gb() {
-    unimplemented!("Currently super slow");
     let ZZX = DensePolyRing::new(BigIntRing::RING, "X");
     let [f] = ZZX.with_wrapped_indeterminate(|X| [X - 1]);
     let QQ = NumberField::new(ZZX, &f);

src/computation.rs

@@ -217,7 +217,7 @@ where
                 }
             } else {
                 let mid = (from + to) / 2;
-                controller.join(
+                let _ = controller.join(
                     move |controller| join_many_internal(controller, executor, tasks, from, mid, batch_tasks),
                     move |controller| join_many_internal(controller, executor, tasks, mid, to, batch_tasks),
                 );
@@ -240,7 +240,7 @@ where
             self.executor.finished.store(true, Ordering::Relaxed);
             self.executor.abort.store(Some(Box::new(abort)), Ordering::AcqRel);
         };
-        self.controller.join(
+        let _ = self.controller.join(
             |controller| {
                 if self.executor.finished.load(Ordering::Relaxed) {
                     return;

src/rings/approx_real/float.rs

@@ -1,5 +1,4 @@
 use core::f64;
-use std::f64::EPSILON;
 
 use crate::algorithms::convolution::KaratsubaHint;
 use crate::algorithms::matmul::StrassenHint;
@@ -61,7 +60,7 @@ impl Real64Base {
         rhs: <Self as RingBase>::Element,
         precision: u64,
     ) -> bool {
-        let scaled_precision = precision as f64 * EPSILON;
+        let scaled_precision = precision as f64 * f64::EPSILON;
         if self.is_absolute_approx_eq(lhs, self.zero(), scaled_precision) {
             self.is_absolute_approx_eq(rhs, self.zero(), scaled_precision)
         } else {

src/rings/direct_power.rs

@@ -138,16 +138,13 @@ impl<R: RingStore, const N: usize> RingBase for DirectPowerRingBase<R, N> {
         _env: EnvBindingStrength,
     ) -> std::fmt::Result {
         write!(out, "(")?;
-        for i in 0..N {
-            self.base
-                .get_ring()
-                .dbg_within(&value[i], out, EnvBindingStrength::Weakest)?;
-            if i + 1 != N {
+        for (i, v) in value.iter().enumerate() {
+            if i > 0 {
                 write!(out, ", ")?;
             }
+            self.base.get_ring().dbg_within(v, out, EnvBindingStrength::Weakest)?;
         }
-        write!(out, ")")?;
-        return Ok(());
+        write!(out, ")")
     }
 
     fn square(&self, value: &mut Self::Element) {
@@ -354,9 +351,9 @@ where
     }
 }
 
-impl<'a, 'b, R: RingStore, const N: usize> Copy for DirectPowerRingElCreator<'a, R, N> {}
+impl<'a, R: RingStore, const N: usize> Copy for DirectPowerRingElCreator<'a, R, N> {}
 
-impl<'a, 'b, R: RingStore, const N: usize> Clone for DirectPowerRingElCreator<'a, R, N> {
+impl<'a, R: RingStore, const N: usize> Clone for DirectPowerRingElCreator<'a, R, N> {
     fn clone(&self) -> Self { *self }
 }
 

src/rings/extension/extension_impl.rs

@@ -234,7 +234,7 @@ where
             base_ring: self.base_ring(),
             data,
         });
-        if was_sparse.is_err() {
+        if was_sparse.is_none() {
             for i in (self.rank()..(2 * self.rank())).rev() {
                 for j in 0..self.x_pow_rank.len() {
                     let add = self.base_ring.mul_ref(self.x_pow_rank.at(j), &data[i]);

src/rings/multivariate/mod.rs

@@ -72,8 +72,8 @@ pub trait MultivariatePolyRing: RingExtension {
     /// every `i` in `0..self.indeterminate_count()`.
     fn expand_monomial_to(&self, m: &Self::Monomial, out: &mut [usize]) {
         assert_eq!(out.len(), self.indeterminate_count());
-        for i in 0..self.indeterminate_count() {
-            out[i] = self.exponent_at(m, i)
+        for (i, out) in out.iter_mut().enumerate() {
+            *out = self.exponent_at(m, i);
         }
     }
 
@@ -158,8 +158,8 @@ pub trait MultivariatePolyRing: RingExtension {
     fn appearing_indeterminates(&self, f: &Self::Element) -> Vec<(usize, usize)> {
         let mut result = (0..self.indeterminate_count()).map(|_| 0).collect::<Vec<_>>();
         for (_, m) in self.terms(f) {
-            for i in 0..self.indeterminate_count() {
-                result[i] = max(result[i], self.exponent_at(m, i));
+            for (i, result) in result.iter_mut().enumerate() {
+                *result = max(*result, self.exponent_at(m, i));
             }
         }
         return result.into_iter().enumerate().filter(|(_, e)| *e > 0).collect();

src/seq/map.rs

@@ -110,7 +110,7 @@ impl<
 pub struct VectorFnMap<V: VectorFn<T>, T, U, F: Fn(T) -> U> {
     base: V,
     mapping_fn: F,
-    elements: PhantomData<(fn(T), fn() -> U)>,
+    elements: PhantomData<(T, U)>,
 }
 
 impl<V: Clone + VectorFn<T>, T, U, F: Clone + Fn(T) -> U> Clone for VectorFnMap<V, T, U, F> {

src/seq/mod.rs

@@ -61,6 +61,7 @@ pub mod sparse;
 /// ```
 pub trait VectorView<T: ?Sized> {
     fn len(&self) -> usize;
+    fn is_empty(&self) -> bool { self.len() == 0 }
     fn at(&self, i: usize) -> &T;
 
     /// Returns a refernce to the `i`-th entry of the vector view, causing
@@ -70,16 +71,16 @@ pub trait VectorView<T: ?Sized> {
     ///
     /// Same as for [`slice::get_unchecked()`]. More concretely, calling this method with an
     /// out-of-bounds index is undefined behavior even if the resulting reference is not used.
-    unsafe fn at_unchecked<'a>(&self, i: usize) -> &T { self.at(i) }
+    unsafe fn at_unchecked(&self, i: usize) -> &T { self.at(i) }
 
     /// Calls `op` with `self` if this vector view supports sparse access.
     /// Otherwise, `()` is returned.
     ///
     /// This is basically a workaround that enables users to specialize on
     /// `V: VectorViewSparse`, even though specialization currently does not support
     /// this.
-    fn specialize_sparse<'a, Op: SparseVectorViewOperation<T>>(&'a self, _op: Op) -> Result<Op::Output<'a>, ()> {
-        Err(())
+    fn specialize_sparse<'a, Op: SparseVectorViewOperation<T>>(&'a self, _op: Op) -> Option<Op::Output<'a>> {
+        None
     }
 
     /// Returns an iterator over all elements in this vector.
@@ -341,7 +342,7 @@ impl<T: ?Sized, V: ?Sized + VectorView<T>> VectorView<T> for Box<V> {
 
     unsafe fn at_unchecked(&self, i: usize) -> &T { unsafe { (**self).at_unchecked(i) } }
 
-    fn specialize_sparse<'a, Op: SparseVectorViewOperation<T>>(&'a self, op: Op) -> Result<Op::Output<'a>, ()> {
+    fn specialize_sparse<'a, Op: SparseVectorViewOperation<T>>(&'a self, op: Op) -> Option<Op::Output<'a>> {
         (**self).specialize_sparse(op)
     }
 
@@ -383,7 +384,7 @@ impl<T: ?Sized, V: ?Sized + VectorView<T>> VectorView<T> for &V {
 
     unsafe fn at_unchecked(&self, i: usize) -> &T { unsafe { (**self).at_unchecked(i) } }
 
-    fn specialize_sparse<'b, Op: SparseVectorViewOperation<T>>(&'b self, op: Op) -> Result<Op::Output<'b>, ()> {
+    fn specialize_sparse<'b, Op: SparseVectorViewOperation<T>>(&'b self, op: Op) -> Option<Op::Output<'b>> {
         (**self).specialize_sparse(op)
     }
 
@@ -412,7 +413,7 @@ impl<T: ?Sized, V: ?Sized + VectorView<T>> VectorView<T> for &mut V {
 
     unsafe fn at_unchecked(&self, i: usize) -> &T { unsafe { (**self).at_unchecked(i) } }
 
-    fn specialize_sparse<'b, Op: SparseVectorViewOperation<T>>(&'b self, op: Op) -> Result<Op::Output<'b>, ()> {
+    fn specialize_sparse<'b, Op: SparseVectorViewOperation<T>>(&'b self, op: Op) -> Option<Op::Output<'b>> {
         (**self).specialize_sparse(op)
     }
 
@@ -488,7 +489,7 @@ pub trait VectorViewMut<T: ?Sized>: VectorView<T> {
     ///
     /// Same as for [`slice::get_unchecked_mut()`]. More concretely, calling this method with an
     /// out-of-bounds index is undefined behavior even if the resulting reference is not used.
-    unsafe fn at_unchecked_mut<'a>(&mut self, i: usize) -> &mut T { self.at_mut(i) }
+    unsafe fn at_unchecked_mut(&mut self, i: usize) -> &mut T { self.at_mut(i) }
 }
 
 /// A trait for [`VectorViewMut`]s that support swapping of two elements.
@@ -533,6 +534,7 @@ pub trait SwappableVectorViewMut<T: ?Sized>: VectorViewMut<T> {
 /// ```
 pub trait VectorFn<T> {
     fn len(&self) -> usize;
+    fn is_empty(&self) -> bool { self.len() == 0 }
     fn at(&self, i: usize) -> T;
 
     /// Produces an iterator over the elements of this [`VectorFn`].