avoid immutable borrow of copy-type BFieldElement

Author: jan-ferdinand

twenty-first/benches/lagrange_interpolation.rs

@@ -69,7 +69,7 @@ fn ntt_based_fast_interpolate(
     group.sample_size(10);
     group.throughput(Throughput::Elements(size as u64));
     group.bench_with_input(bench_id, &size, |b, _| {
-        b.iter(|| polynomial::Polynomial::fast_interpolate(&xs, &ys, &omega, size))
+        b.iter(|| polynomial::Polynomial::fast_interpolate(&xs, &ys, omega, size))
     });
 }
 
@@ -87,7 +87,7 @@ fn ntt_based_fast_interpolate_batched(
     group.sample_size(10);
     group.throughput(Throughput::Elements(size as u64));
     group.bench_with_input(bench_id, &size, |b, _| {
-        b.iter(|| polynomial::Polynomial::batch_fast_interpolate(&xs, &ys, &omega, size))
+        b.iter(|| polynomial::Polynomial::batch_fast_interpolate(&xs, &ys, omega, size))
     });
 }
 

twenty-first/src/shared_math/polynomial.rs

@@ -143,7 +143,7 @@ where
     // Given a polynomial P(x), produce P'(x) := P(alpha * x). Evaluating P'(x)
     // then corresponds to evaluating P(alpha * x).
     #[must_use]
-    pub fn scale(&self, &alpha: &BFieldElement) -> Self {
+    pub fn scale(&self, alpha: BFieldElement) -> Self {
         let mut acc = FF::one();
         let mut return_coefficients = self.coefficients.clone();
         for elem in return_coefficients.iter_mut() {
@@ -263,7 +263,7 @@ where
     pub fn fast_multiply(
         lhs: &Self,
         rhs: &Self,
-        primitive_root: &BFieldElement,
+        primitive_root: BFieldElement,
         root_order: usize,
     ) -> Self {
         assert!(
@@ -324,7 +324,7 @@ where
     }
 
     // domain: polynomial roots
-    pub fn fast_zerofier(domain: &[FF], primitive_root: &BFieldElement, root_order: usize) -> Self {
+    pub fn fast_zerofier(domain: &[FF], primitive_root: BFieldElement, root_order: usize) -> Self {
         debug_assert_eq!(
             primitive_root.mod_pow_u32(root_order as u32),
             BFieldElement::one(),
@@ -364,7 +364,7 @@ where
     pub fn fast_evaluate(
         &self,
         domain: &[FF],
-        primitive_root: &BFieldElement,
+        primitive_root: BFieldElement,
         root_order: usize,
     ) -> Vec<FF> {
         if domain.is_empty() {
@@ -398,7 +398,7 @@ where
     pub fn fast_interpolate(
         domain: &[FF],
         values: &[FF],
-        primitive_root: &BFieldElement,
+        primitive_root: BFieldElement,
         root_order: usize,
     ) -> Self {
         assert_eq!(
@@ -470,7 +470,7 @@ where
     pub fn batch_fast_interpolate(
         domain: &[FF],
         values_matrix: &Vec<Vec<FF>>,
-        primitive_root: &BFieldElement,
+        primitive_root: BFieldElement,
         root_order: usize,
     ) -> Vec<Self> {
         debug_assert_eq!(
@@ -502,7 +502,7 @@ where
     fn batch_fast_interpolate_with_memoization(
         domain: &[FF],
         values_matrix: &Vec<Vec<FF>>,
-        primitive_root: &BFieldElement,
+        primitive_root: BFieldElement,
         root_order: usize,
         zerofier_dictionary: &mut HashMap<(FF, FF), Polynomial<FF>>,
         offset_inverse_dictionary: &mut HashMap<(FF, FF), Vec<FF>>,
@@ -638,7 +638,7 @@ where
     /// Fast evaluate on a coset domain, which is the group generated by `generator^i * offset`
     pub fn fast_coset_evaluate(
         &self,
-        offset: &BFieldElement,
+        offset: BFieldElement,
         generator: BFieldElement,
         order: usize,
     ) -> Vec<FF> {
@@ -651,7 +651,7 @@ where
 
     /// The inverse of `fast_coset_evaluate`
     pub fn fast_coset_interpolate(
-        offset: &BFieldElement,
+        offset: BFieldElement,
         generator: BFieldElement,
         values: &[FF],
     ) -> Self {
@@ -664,7 +664,7 @@ where
         );
         let poly = Polynomial::new(mut_values);
 
-        poly.scale(&offset.inverse())
+        poly.scale(offset.inverse())
     }
 
     /// Divide two polynomials under the homomorphism of evaluation for a N^2 -> N*log(N) speedup
@@ -714,10 +714,10 @@ where
             order /= 2;
         }
 
-        let mut scaled_lhs_coefficients: Vec<FF> = lhs.scale(&offset).coefficients;
+        let mut scaled_lhs_coefficients: Vec<FF> = lhs.scale(offset).coefficients;
         scaled_lhs_coefficients.append(&mut vec![zero; order - scaled_lhs_coefficients.len()]);
 
-        let mut scaled_rhs_coefficients: Vec<FF> = rhs.scale(&offset).coefficients;
+        let mut scaled_rhs_coefficients: Vec<FF> = rhs.scale(offset).coefficients;
         scaled_rhs_coefficients.append(&mut vec![zero; order - scaled_rhs_coefficients.len()]);
 
         let lhs_log_2_of_n = log_2_floor(scaled_lhs_coefficients.len() as u128) as u32;
@@ -740,7 +740,7 @@ where
             coefficients: quotient_codeword,
         };
 
-        scaled_quotient.scale(&offset.inverse())
+        scaled_quotient.scale(offset.inverse())
     }
 }
 
@@ -2215,45 +2215,45 @@ mod test_polynomials {
                 BFieldElement::from(17u64),
             ],
         };
-        let c_fast = Polynomial::fast_multiply(&a, &b, &primitive_root, 32);
+        let c_fast = Polynomial::fast_multiply(&a, &b, primitive_root, 32);
         let c_normal = a.clone() * b.clone();
         println!("c_normal = {c_normal}");
         println!("c_fast = {c_fast}");
         assert_eq!(c_normal, c_fast);
         assert_eq!(
             Polynomial::zero(),
-            Polynomial::fast_multiply(&Polynomial::zero(), &b, &primitive_root, 32)
+            Polynomial::fast_multiply(&Polynomial::zero(), &b, primitive_root, 32)
         );
         assert_eq!(
             Polynomial::zero(),
-            Polynomial::fast_multiply(&a, &Polynomial::zero(), &primitive_root, 32)
+            Polynomial::fast_multiply(&a, &Polynomial::zero(), primitive_root, 32)
         );
 
         let one: Polynomial<BFieldElement> = Polynomial {
             coefficients: vec![BFieldElement::from(1u64)],
         };
-        assert_eq!(a, Polynomial::fast_multiply(&a, &one, &primitive_root, 32));
-        assert_eq!(a, Polynomial::fast_multiply(&one, &a, &primitive_root, 32));
-        assert_eq!(b, Polynomial::fast_multiply(&b, &one, &primitive_root, 32));
-        assert_eq!(b, Polynomial::fast_multiply(&one, &b, &primitive_root, 32));
+        assert_eq!(a, Polynomial::fast_multiply(&a, &one, primitive_root, 32));
+        assert_eq!(a, Polynomial::fast_multiply(&one, &a, primitive_root, 32));
+        assert_eq!(b, Polynomial::fast_multiply(&b, &one, primitive_root, 32));
+        assert_eq!(b, Polynomial::fast_multiply(&one, &b, primitive_root, 32));
         let x: Polynomial<BFieldElement> = Polynomial {
             coefficients: vec![BFieldElement::from(0u64), BFieldElement::from(1u64)],
         };
         assert_eq!(
             a.shift_coefficients(1),
-            Polynomial::fast_multiply(&x, &a, &primitive_root, 32)
+            Polynomial::fast_multiply(&x, &a, primitive_root, 32)
         );
         assert_eq!(
             a.shift_coefficients(1),
-            Polynomial::fast_multiply(&a, &x, &primitive_root, 32)
+            Polynomial::fast_multiply(&a, &x, primitive_root, 32)
         );
         assert_eq!(
             b.shift_coefficients(1),
-            Polynomial::fast_multiply(&x, &b, &primitive_root, 32)
+            Polynomial::fast_multiply(&x, &b, primitive_root, 32)
         );
         assert_eq!(
             b.shift_coefficients(1),
-            Polynomial::fast_multiply(&b, &x, &primitive_root, 32)
+            Polynomial::fast_multiply(&b, &x, primitive_root, 32)
         );
     }
 
@@ -2264,7 +2264,7 @@ mod test_polynomials {
         let root_order: usize = 8;
         let omega = BFieldElement::primitive_root_of_unity(root_order as u64).unwrap();
         let domain = vec![_1_17, _5_17];
-        let actual = Polynomial::<BFieldElement>::fast_zerofier(&domain, &omega, root_order);
+        let actual = Polynomial::<BFieldElement>::fast_zerofier(&domain, omega, root_order);
         assert!(
             actual.evaluate(&_1_17).is_zero(),
             "expecting {actual} = 0 when x = 1"
@@ -2283,7 +2283,7 @@ mod test_polynomials {
         let root_order_2 = 16;
         let omega2 = BFieldElement::primitive_root_of_unity(root_order_2 as u64).unwrap();
         let domain_2 = vec![_7_17, _10_17];
-        let actual_2 = Polynomial::<BFieldElement>::fast_zerofier(&domain_2, &omega2, root_order_2);
+        let actual_2 = Polynomial::<BFieldElement>::fast_zerofier(&domain_2, omega2, root_order_2);
         assert!(
             actual_2.evaluate(&_7_17).is_zero(),
             "expecting {actual_2} = 0 when x = 7"
@@ -2316,7 +2316,7 @@ mod test_polynomials {
             let omega = maybe_omega.unwrap();
 
             // compute zerofier
-            let zerofier = Polynomial::<BFieldElement>::fast_zerofier(&domain, &omega, order);
+            let zerofier = Polynomial::<BFieldElement>::fast_zerofier(&domain, omega, order);
 
             // evaluate in all domain points and match against zero
             for d in domain.iter() {
@@ -2353,7 +2353,7 @@ mod test_polynomials {
         let _12_17 = BFieldElement::from(12u64);
         let domain = vec![_6_17, _12_17];
 
-        let actual = poly.fast_evaluate(&domain, &omega, 16);
+        let actual = poly.fast_evaluate(&domain, omega, 16);
         let expected_6 = _6_17.mod_pow(5u64) + _6_17.mod_pow(3u64);
         assert_eq!(expected_6, actual[0]);
 
@@ -2391,7 +2391,7 @@ mod test_polynomials {
             let omega = maybe_omega.unwrap();
 
             // fast evaluate
-            let fast_eval = poly.fast_evaluate(&domain, &omega, order);
+            let fast_eval = poly.fast_evaluate(&domain, omega, order);
 
             // match evaluations
             assert_eq!(slow_eval, fast_eval);
@@ -2414,12 +2414,12 @@ mod test_polynomials {
         let _9_17 = BFieldElement::from(9u64);
         let domain = vec![_6_17, _7_17, _8_17, _9_17];
 
-        let evals = poly.fast_evaluate(&domain, &omega, 4);
-        let reinterp = Polynomial::fast_interpolate(&domain, &evals, &omega, 4);
+        let evals = poly.fast_evaluate(&domain, omega, 4);
+        let reinterp = Polynomial::fast_interpolate(&domain, &evals, omega, 4);
         assert_eq!(poly, reinterp);
 
         let reinterps_batch: Vec<Polynomial<BFieldElement>> =
-            Polynomial::batch_fast_interpolate(&domain, &vec![evals], &omega, 4);
+            Polynomial::batch_fast_interpolate(&domain, &vec![evals], omega, 4);
         assert_eq!(poly, reinterps_batch[0]);
     }
 
@@ -2432,8 +2432,7 @@ mod test_polynomials {
             let omega = BFieldElement::primitive_root_of_unity(order_of_omega as u64).unwrap();
 
             // Unbatched fast interpolation
-            let interpolant =
-                Polynomial::fast_interpolate(&domain, &values, &omega, order_of_omega);
+            let interpolant = Polynomial::fast_interpolate(&domain, &values, omega, order_of_omega);
 
             for (x, y) in domain.iter().zip(values) {
                 assert_eq!(y, interpolant.evaluate(x));
@@ -2449,7 +2448,7 @@ mod test_polynomials {
             ];
 
             let batch_interpolated =
-                Polynomial::batch_fast_interpolate(&domain, &values_vec, &omega, order_of_omega);
+                Polynomial::batch_fast_interpolate(&domain, &values_vec, omega, order_of_omega);
             for (y_values, interpolant_from_batch_function) in
                 values_vec.into_iter().zip(batch_interpolated.into_iter())
             {
@@ -2499,10 +2498,10 @@ mod test_polynomials {
 
             // use NTT-based interpolation
             let interpolant =
-                Polynomial::<BFieldElement>::fast_interpolate(&domain, &values, &omega, order);
+                Polynomial::<BFieldElement>::fast_interpolate(&domain, &values, omega, order);
 
             // re-evaluate and match against sampled values
-            let re_eval = interpolant.fast_evaluate(&domain, &omega, order);
+            let re_eval = interpolant.fast_evaluate(&domain, omega, order);
             for (v, r) in values.iter().zip(re_eval.iter()) {
                 assert_eq!(v, r);
             }
@@ -2514,7 +2513,7 @@ mod test_polynomials {
             let batched_interpolants = Polynomial::<BFieldElement>::batch_fast_interpolate(
                 &domain,
                 &vec![values],
-                &omega,
+                omega,
                 order,
             );
 
@@ -2535,18 +2534,18 @@ mod test_polynomials {
         let offset = BFieldElement::generator();
         let omega = BFieldElement::primitive_root_of_unity(8).unwrap();
 
-        let values = poly.fast_coset_evaluate(&offset, omega, 8);
+        let values = poly.fast_coset_evaluate(offset, omega, 8);
 
         let mut domain = vec![_0; 8];
         domain[0] = offset;
         for i in 1..8 {
             domain[i] = domain[i - 1].to_owned() * omega.to_owned();
         }
 
-        let reinterp = Polynomial::fast_interpolate(&domain, &values, &omega, 8);
+        let reinterp = Polynomial::fast_interpolate(&domain, &values, omega, 8);
         assert_eq!(reinterp, poly);
 
-        let poly_interpolated = Polynomial::fast_coset_interpolate(&offset, omega, &values);
+        let poly_interpolated = Polynomial::fast_coset_interpolate(offset, omega, &values);
         assert_eq!(poly, poly_interpolated);
     }
 
@@ -2583,7 +2582,7 @@ mod test_polynomials {
                 BFieldElement::from(17u64),
             ],
         };
-        let c_fast = Polynomial::fast_multiply(&a, &b, &primitive_root, 32);
+        let c_fast = Polynomial::fast_multiply(&a, &b, primitive_root, 32);
 
         let mut quotient = Polynomial::fast_coset_divide(&c_fast, &b, offset, primitive_root, 32);
         assert_eq!(a, quotient);
@@ -3011,7 +3010,7 @@ mod test_polynomials {
             let omega = BFieldElement::primitive_root_of_unity(next_po2 as u64).unwrap();
 
             let fast_zerofier_polynomial =
-                Polynomial::<BFieldElement>::fast_zerofier(&domain, &omega, next_po2);
+                Polynomial::<BFieldElement>::fast_zerofier(&domain, omega, next_po2);
 
             assert_eq!(zerofier_polynomial, fast_zerofier_polynomial);
         }