Sparse poly implement poly (#117)

* Make SparsePolynomial implement Polynomial

Author: ValarDragon

CHANGELOG.md

@@ -14,6 +14,8 @@
 - #106 (ark-ff, ark-ec) Add `Zeroize` trait bound to `Field, ProjectiveGroup, AffineGroup` traits.
 - #108 (ark-ff) Add `extension_degree()` method to `Field`.
 - #110 (ark-ec) Change the trait bound on the scalar for `mul`, from (essentially) `Into<BigInt>` to `AsRef<[u64]>`
+- #117 (ark-poly) Make the univariate `SparsePolynomial` implement `Polynomial`. Make this change
+    by replacing `sparse_poly.evaluate(pt)` to `sparse_poly.evaluate(&pt)`.
 
 ### Features
 - #20 (ark-poly) Add structs/traits for multivariate polynomials
@@ -32,6 +34,7 @@
 - #115 (ark-poly) Add parallel implementation to operations on `Evaluations`.
 - #115 (ark-ff) Add parallel implementation of `batch_inversion`.
 - #122 (ark-poly) Add infrastructure for benchmarking `FFT`s.
+
 ### Bug fixes
 - #36 (ark-ec) In Short-Weierstrass curves, include an infinity bit in `ToConstraintField`.
 - #107 (ark-serialize) Fix handling of `(de)serialize_uncompressed/unchecked` in various impls of `CanonicalSerialize/Deserialize`.

poly/src/domain/general.rs

@@ -137,6 +137,7 @@ impl<F: FftField> Iterator for GeneralElements<F> {
 
 #[cfg(test)]
 mod tests {
+    use crate::polynomial::Polynomial;
     use crate::{EvaluationDomain, GeneralEvaluationDomain};
     use ark_ff::{test_rng, Zero};
     use ark_test_curves::bls12_381::Fr;
@@ -152,7 +153,7 @@ mod tests {
             for _ in 0..100 {
                 let point = rng.gen();
                 assert_eq!(
-                    z.evaluate(point),
+                    z.evaluate(&point),
                     domain.evaluate_vanishing_polynomial(point)
                 )
             }
@@ -164,7 +165,7 @@ mod tests {
             for _ in 0..100 {
                 let point = rng.gen();
                 assert_eq!(
-                    z.evaluate(point),
+                    z.evaluate(&point),
                     domain.evaluate_vanishing_polynomial(point)
                 )
             }
@@ -177,7 +178,7 @@ mod tests {
             let domain = GeneralEvaluationDomain::<Fr>::new(coeffs).unwrap();
             let z = domain.vanishing_polynomial();
             for point in domain.elements() {
-                assert!(z.evaluate(point).is_zero())
+                assert!(z.evaluate(&point).is_zero())
             }
         }
     }

poly/src/domain/mixed_radix.rs

@@ -398,6 +398,7 @@ pub(crate) fn serial_mixed_radix_fft<T: DomainCoeff<F>, F: FftField>(
 
 #[cfg(test)]
 mod tests {
+    use crate::polynomial::Polynomial;
     use crate::{EvaluationDomain, MixedRadixEvaluationDomain};
     use ark_ff::{test_rng, Field, Zero};
     use ark_test_curves::mnt4_753::Fq as Fr;
@@ -410,9 +411,9 @@ mod tests {
             let domain = MixedRadixEvaluationDomain::<Fr>::new(coeffs).unwrap();
             let z = domain.vanishing_polynomial();
             for _ in 0..100 {
-                let point = rng.gen();
+                let point: Fr = rng.gen();
                 assert_eq!(
-                    z.evaluate(point),
+                    z.evaluate(&point),
                     domain.evaluate_vanishing_polynomial(point)
                 )
             }
@@ -425,7 +426,7 @@ mod tests {
             let domain = MixedRadixEvaluationDomain::<Fr>::new(coeffs).unwrap();
             let z = domain.vanishing_polynomial();
             for point in domain.elements() {
-                assert!(z.evaluate(point).is_zero())
+                assert!(z.evaluate(&point).is_zero())
             }
         }
     }

poly/src/domain/radix2.rs

@@ -212,11 +212,14 @@ impl<F: FftField> EvaluationDomain<F> for Radix2EvaluationDomain<F> {
     }
 }
 
+// This implements the Cooley-Turkey FFT, derived from libfqfft
+// The libfqfft implementation uses pseudocode from [CLRS 2n Ed, pp. 864].
 pub(crate) fn serial_radix2_fft<T: DomainCoeff<F>, F: FftField>(a: &mut [T], omega: F, log_n: u32) {
     let n =
         u32::try_from(a.len()).expect("cannot perform FFTs larger on vectors of len > (1 << 32)");
     assert_eq!(n, 1 << log_n);
 
+    // swap coefficients in place
     for k in 0..n {
         let rk = bitreverse(k, log_n);
         if k < rk {
@@ -225,11 +228,13 @@ pub(crate) fn serial_radix2_fft<T: DomainCoeff<F>, F: FftField>(a: &mut [T], ome
     }
 
     let mut m = 1;
-    for _ in 0..log_n {
+    for _i in 1..=log_n {
+        // w_m is 2^i-th root of unity
         let w_m = omega.pow(&[(n / (2 * m)) as u64]);
 
         let mut k = 0;
         while k < n {
+            // w = w_m^j at the start of every loop iteration
             let mut w = F::one();
             for j in 0..m {
                 let mut t = a[(k + j + m) as usize];
@@ -251,6 +256,7 @@ pub(crate) fn serial_radix2_fft<T: DomainCoeff<F>, F: FftField>(a: &mut [T], ome
 #[cfg(test)]
 mod tests {
     use crate::domain::Vec;
+    use crate::polynomial::Polynomial;
     use crate::{EvaluationDomain, Radix2EvaluationDomain};
     use ark_ff::{test_rng, Field, One, UniformRand, Zero};
     use ark_test_curves::bls12_381::Fr;
@@ -263,9 +269,9 @@ mod tests {
             let domain = Radix2EvaluationDomain::<Fr>::new(coeffs).unwrap();
             let z = domain.vanishing_polynomial();
             for _ in 0..100 {
-                let point = rng.gen();
+                let point: Fr = rng.gen();
                 assert_eq!(
-                    z.evaluate(point),
+                    z.evaluate(&point),
                     domain.evaluate_vanishing_polynomial(point)
                 )
             }
@@ -278,7 +284,7 @@ mod tests {
             let domain = Radix2EvaluationDomain::<Fr>::new(coeffs).unwrap();
             let z = domain.vanishing_polynomial();
             for point in domain.elements() {
-                assert!(z.evaluate(point).is_zero())
+                assert!(z.evaluate(&point).is_zero())
             }
         }
     }

poly/src/polynomial/univariate/dense.rs

@@ -499,6 +499,23 @@ mod tests {
         assert_eq!(res1, -res2, "p2 - p1 = -(p1 - p2)");
     }
 
+    #[test]
+    fn polynomial_additive_identity() {
+        // Test adding polynomials with its negative equals 0
+        let mut rng = test_rng();
+        for degree in 0..70 {
+            let poly = DensePolynomial::<Fr>::rand(degree, &mut rng);
+            let neg = -poly.clone();
+            assert!((poly + neg).is_zero());
+
+            // Test with SubAssign trait
+            let poly = DensePolynomial::<Fr>::rand(degree, &mut rng);
+            let mut result = poly.clone();
+            result -= &poly;
+            assert!(result.is_zero());
+        }
+    }
+
     #[test]
     fn divide_polynomials_fixed() {
         let dividend = DensePolynomial::from_coefficients_slice(&[

poly/src/polynomial/univariate/mod.rs

@@ -145,11 +145,11 @@ impl<'a, F: 'a + FftField> DenseOrSparsePolynomial<'a, F> {
     fn eval_over_domain_helper<D: EvaluationDomain<F>>(self, domain: D) -> Evaluations<F, D> {
         match self {
             SPolynomial(Cow::Borrowed(s)) => {
-                let evals = domain.elements().map(|elem| s.evaluate(elem)).collect();
+                let evals = domain.elements().map(|elem| s.evaluate(&elem)).collect();
                 Evaluations::from_vec_and_domain(evals, domain)
             }
             SPolynomial(Cow::Owned(s)) => {
-                let evals = domain.elements().map(|elem| s.evaluate(elem)).collect();
+                let evals = domain.elements().map(|elem| s.evaluate(&elem)).collect();
                 Evaluations::from_vec_and_domain(evals, domain)
             }
             DPolynomial(Cow::Borrowed(d)) => {