field: add Powers iterator

This adds some new methods to Field, which have default impls and are
therefore non-breaking. (And they are general-purpose "field" things.)

src/primitives/field.rs

@@ -2,6 +2,7 @@
 
 //! Generic Field Traits
 
+use core::iter::{Skip, Take};
 use core::{fmt, hash, iter, ops};
 
 /// A generic field.
@@ -88,6 +89,20 @@ pub trait Field:
  "bug: `ExtensionField::MULTIPLICATIVE_ORDER_FACTORS` did not include full group order"
  );
  }
+
+ /// Constructs an iterator over all the powers of an element from 0 onward.
+ fn powers(self) -> Powers<Self> { Powers { base: self, next: Self::ONE } }
+
+ /// Constructs an iterator over all the powers of an element within a given range.
+ ///
+ /// # Panics
+ ///
+ /// Panics if given a range whose start is greater than its end, or whose range
+ /// is from 0 to `usize::MAX`. Its intended use is with [`crate::Checksum::ROOT_EXPONENTS`]
+ /// for which neither of these conditions should ever be true.
+ fn powers_range(self, range: ops::RangeInclusive<usize>) -> Take<Skip<Powers<Self>>> {
+ self.powers().skip(*range.start()).take(*range.end() - range.start() + 1)
+ }
 }
 
 /// Trait describing a simple extension field (field obtained from another by
@@ -338,3 +353,35 @@ macro_rules! impl_ops_for_fe {
  };
 }
 pub(super) use impl_ops_for_fe;
+
+/// An iterator over the powers of a field, starting from zero.
+///
+/// This iterator starts from 1, but has an optimized version of [`Iterator::nth`]
+/// which allows efficient construction.
+pub struct Powers<F: Field> {
+ base: F,
+ next: F,
+}
+
+impl<F: Field> Iterator for Powers<F> {
+ type Item = F;
+
+ fn next(&mut self) -> Option<F> {
+ let ret = Some(self.next.clone());
+ self.next *= &self.base;
+ ret
+ }
+
+ /// Compute next by calling `F::powi`.
+ ///
+ /// The default implementation of `nth` will simply call the iterator `n`
+ /// times, throwing away the result, which takes O(n) field multiplications.
+ /// For a power iterator we can do much better, taking O(log(n)) multiplications.
+ ///
+ /// This is important because this method is called internally by `Iterator::skip`.
+ fn nth(&mut self, n: usize) -> Option<F> {
+ let ni64 = (n % F::MULTIPLICATIVE_ORDER) as i64; // cast ok since modulus should be small
+ self.next *= self.base.powi(ni64);
+ self.next()
+ }
+}