From e7b4e9f06db9c5743c71ddddb4fdaf86b7846913 Mon Sep 17 00:00:00 2001 From: Ben Edgington Date: Mon, 8 Mar 2021 12:06:25 +0000 Subject: [PATCH] Rename shift_poly to scale_poly --- src/recover.c | 58 +++++++++++++++++++++++++-------------------------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/src/recover.c b/src/recover.c index 5c5aab1..a5c9409 100644 --- a/src/recover.c +++ b/src/recover.c @@ -27,21 +27,21 @@ #include "zero_poly.h" /** 5 is a primitive element, but actually this can be pretty much anything not 0 or a low-degree root of unity */ -#define SHIFT_FACTOR 5 +#define SCALE_FACTOR 5 /** - * Shift a polynomial in place. + * Scale a polynomial in place. * - * Multiplies each coefficient by `1 / shift_factor ^ i`. Equivalent to creating a polynomial that evaluates at `x * k` + * Multiplies each coefficient by `1 / scale_factor ^ i`. Equivalent to creating a polynomial that evaluates at `x * k` * rather than `x`. * - * @param[out,in] p The polynomial coefficients to be shifted + * @param[out,in] p The polynomial coefficients to be scaled * @param[in] len_p Length of the polynomial coefficients */ -void shift_poly(fr_t *p, uint64_t len_p) { - fr_t shift_factor, factor_power, inv_factor; - fr_from_uint64(&shift_factor, SHIFT_FACTOR); - fr_inv(&inv_factor, &shift_factor); +void scale_poly(fr_t *p, uint64_t len_p) { + fr_t scale_factor, factor_power, inv_factor; + fr_from_uint64(&scale_factor, SCALE_FACTOR); + fr_inv(&inv_factor, &scale_factor); factor_power = fr_one; for (uint64_t i = 1; i < len_p; i++) { @@ -51,21 +51,21 @@ void shift_poly(fr_t *p, uint64_t len_p) { } /** - * Unshift a polynomial in place. + * Unscale a polynomial in place. * - * Multiplies each coefficient by `shift_factor ^ i`. Equivalent to creating a polynomial that evaluates at `x / k` + * Multiplies each coefficient by `scale_factor ^ i`. Equivalent to creating a polynomial that evaluates at `x / k` * rather than `x`. * - * @param[out,in] p The polynomial coefficients to be unshifted + * @param[out,in] p The polynomial coefficients to be unscaled * @param[in] len_p Length of the polynomial coefficients */ -void unshift_poly(fr_t *p, uint64_t len_p) { - fr_t shift_factor, factor_power; - fr_from_uint64(&shift_factor, SHIFT_FACTOR); +void unscale_poly(fr_t *p, uint64_t len_p) { + fr_t scale_factor, factor_power; + fr_from_uint64(&scale_factor, SCALE_FACTOR); factor_power = fr_one; for (uint64_t i = 1; i < len_p; i++) { - fr_mul(&factor_power, &factor_power, &shift_factor); + fr_mul(&factor_power, &factor_power, &scale_factor); fr_mul(&p[i], &p[i], &factor_power); } } @@ -111,9 +111,9 @@ C_KZG_RET recover_poly_from_samples(fr_t *reconstructed_data, fr_t *samples, uin fr_t *zero_eval = scratch0; fr_t *poly_evaluations_with_zero = scratch2; fr_t *poly_with_zero = scratch0; - fr_t *eval_shifted_poly_with_zero = scratch2; - fr_t *eval_shifted_zero_poly = scratch0; - fr_t *shifted_reconstructed_poly = scratch1; + fr_t *eval_scaled_poly_with_zero = scratch2; + fr_t *eval_scaled_zero_poly = scratch0; + fr_t *scaled_reconstructed_poly = scratch1; poly zero_poly; zero_poly.length = len_samples; @@ -139,31 +139,31 @@ C_KZG_RET recover_poly_from_samples(fr_t *reconstructed_data, fr_t *samples, uin TRY(fft_fr(poly_with_zero, poly_evaluations_with_zero, true, len_samples, fs)); // x -> k * x - shift_poly(poly_with_zero, len_samples); - shift_poly(zero_poly.coeffs, zero_poly.length); + scale_poly(poly_with_zero, len_samples); + scale_poly(zero_poly.coeffs, zero_poly.length); // Q1 = (D * Z_r,I)(k * x) - fr_t *shifted_poly_with_zero = poly_with_zero; // Renaming + fr_t *scaled_poly_with_zero = poly_with_zero; // Renaming // Q2 = Z_r,I(k * x) - fr_t *shifted_zero_poly = zero_poly.coeffs; // Renaming + fr_t *scaled_zero_poly = zero_poly.coeffs; // Renaming // Polynomial division by convolution: Q3 = Q1 / Q2 - TRY(fft_fr(eval_shifted_poly_with_zero, shifted_poly_with_zero, false, len_samples, fs)); - TRY(fft_fr(eval_shifted_zero_poly, shifted_zero_poly, false, len_samples, fs)); + TRY(fft_fr(eval_scaled_poly_with_zero, scaled_poly_with_zero, false, len_samples, fs)); + TRY(fft_fr(eval_scaled_zero_poly, scaled_zero_poly, false, len_samples, fs)); - fr_t *eval_shifted_reconstructed_poly = eval_shifted_poly_with_zero; + fr_t *eval_scaled_reconstructed_poly = eval_scaled_poly_with_zero; for (uint64_t i = 0; i < len_samples; i++) { - fr_div(&eval_shifted_reconstructed_poly[i], &eval_shifted_poly_with_zero[i], &eval_shifted_zero_poly[i]); + fr_div(&eval_scaled_reconstructed_poly[i], &eval_scaled_poly_with_zero[i], &eval_scaled_zero_poly[i]); } // The result of the division is D(k * x): - TRY(fft_fr(shifted_reconstructed_poly, eval_shifted_reconstructed_poly, true, len_samples, fs)); + TRY(fft_fr(scaled_reconstructed_poly, eval_scaled_reconstructed_poly, true, len_samples, fs)); // k * x -> x - unshift_poly(shifted_reconstructed_poly, len_samples); + unscale_poly(scaled_reconstructed_poly, len_samples); // Finally we have D(x) which evaluates to our original data at the powers of roots of unity - fr_t *reconstructed_poly = shifted_reconstructed_poly; // Renaming + fr_t *reconstructed_poly = scaled_reconstructed_poly; // Renaming // The evaluation polynomial for D(x) is the reconstructed data: TRY(fft_fr(reconstructed_data, reconstructed_poly, false, len_samples, fs));