remove: legacy comments & code

privacy-scaling-explorations · Feb 28, 2023 · 0ff0396 · 0ff0396
1 parent 61bc9c8
commit 0ff0396
Show file tree

Hide file tree

Showing 3 changed files with 5 additions and 19 deletions.
diff --git a/halo2_proofs/benches/commit_zk.rs b/halo2_proofs/benches/commit_zk.rs
@@ -2,32 +2,30 @@ extern crate criterion;
 
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use group::ff::Field;
-use halo2_proofs::poly::{LagrangeCoeff, Polynomial};
 use halo2_proofs::*;
 use halo2curves::pasta::pallas::Scalar;
 use rand_chacha::rand_core::RngCore;
 use rand_chacha::ChaCha20Rng;
 use rand_core::SeedableRng;
 use rayon::{current_num_threads, prelude::*};
 
-fn rand_poly_serial(mut rng: ChaCha20Rng, domain: usize) -> Polynomial<Scalar, LagrangeCoeff> {
+fn rand_poly_serial(mut rng: ChaCha20Rng, domain: usize) -> Vec<Scalar> {
     // Sample a random polynomial of degree n - 1
     let mut random_poly = vec![Scalar::zero(); 1 << domain];
     for coeff in random_poly.iter_mut() {
         *coeff = Scalar::random(&mut rng);
     }
-    assert_eq!(random_poly.len(), 1 << domain);
-    Polynomial::from_evals(random_poly)
+
+    random_poly
 }
 
-fn rand_poly_par(mut rng: ChaCha20Rng, domain: usize) -> Polynomial<Scalar, LagrangeCoeff> {
+fn rand_poly_par(mut rng: ChaCha20Rng, domain: usize) -> Vec<Scalar> {
     // Sample a random polynomial of degree n - 1
     let n_threads = current_num_threads();
     let n = 1usize << domain;
     let n_chunks = n_threads + if n % n_threads != 0 { 1 } else { 0 };
     let mut rand_vec = vec![Scalar::zero(); n];
 
-    // We always round up the division by adding 1 extra seed.
     let mut thread_seeds: Vec<ChaCha20Rng> = (0..n_chunks)
         .into_iter()
         .map(|_| {
@@ -42,7 +40,7 @@ fn rand_poly_par(mut rng: ChaCha20Rng, domain: usize) -> Polynomial<Scalar, Lagr
         .zip_eq(rand_vec.par_chunks_mut(n / n_threads))
         .for_each(|(mut rng, chunk)| chunk.iter_mut().for_each(|v| *v = Scalar::random(&mut rng)));
 
-    Polynomial::from_evals(rand_vec)
+    rand_vec
 }
 
 fn bench_commit(c: &mut Criterion) {

diff --git a/halo2_proofs/src/plonk/vanishing/prover.rs b/halo2_proofs/src/plonk/vanishing/prover.rs
@@ -54,7 +54,6 @@ impl<C: CurveAffine> Argument<C> {
         let n_chunks = n_threads + if n % n_threads != 0 { 1 } else { 0 };
         let mut rand_vec = vec![C::Scalar::zero(); n];
 
-        // We always round up the division by adding 1 extra seed.
         let mut thread_seeds: Vec<ChaCha20Rng> = (0..n_chunks)
             .into_iter()
             .map(|_| {
@@ -73,9 +72,6 @@ impl<C: CurveAffine> Argument<C> {
                     .for_each(|v| *v = C::Scalar::random(&mut rng))
             });
 
-        // Truncate the leftover elements of the Vec (if any).
-        rand_vec.truncate(1usize << domain.k() as usize);
-
         let random_poly: Polynomial<C::Scalar, Coeff> = domain.coeff_from_vec(rand_vec);
 
         // Sample a random blinding factor

diff --git a/halo2_proofs/src/poly.rs b/halo2_proofs/src/poly.rs
@@ -145,14 +145,6 @@ impl<F, B> Polynomial<F, B> {
     pub fn num_coeffs(&self) -> usize {
         self.values.len()
     }
-
-    /// Allows to create a Polynomial from a Vec.
-    pub fn from_evals(vector: Vec<F>) -> Self {
-        Polynomial {
-            values: vector,
-            _marker: PhantomData,
-        }
-    }
 }
 
 impl<F: SerdePrimeField, B> Polynomial<F, B> {