/* forward transform, sign = -1; transform length = 3 * 2^n */ int four_step_fnt(mpd_uint_t *a, mpd_size_t n, int modnum) { mpd_size_t R = 3; /* number of rows */ mpd_size_t C = n / 3; /* number of columns */ mpd_uint_t w3table[3]; mpd_uint_t kernel, w0, w1, wstep; mpd_uint_t *s, *p0, *p1, *p2; mpd_uint_t umod; #ifdef PPRO double dmod; uint32_t dinvmod[3]; #endif mpd_size_t i, k; assert(n >= 48); assert(n <= 3*MPD_MAXTRANSFORM_2N); SETMODULUS(modnum); _mpd_init_w3table(w3table, -1, modnum); /* size three ntt on the columns */ for (p0=a, p1=p0+C, p2=p0+2*C; p0<a+C; p0++,p1++,p2++) { SIZE3_NTT(p0, p1, p2, w3table); } kernel = _mpd_getkernel(n, -1, modnum); for (i = 1; i < R; i++) { w0 = 1; w1 = POWMOD(kernel, i); wstep = MULMOD(w1, w1); for (k = 0; k < C-1; k += 2) { mpd_uint_t x0 = a[i*C+k]; mpd_uint_t x1 = a[i*C+k+1]; MULMOD2(&x0, w0, &x1, w1); MULMOD2C(&w0, &w1, wstep); a[i*C+k] = x0; a[i*C+k+1] = x1; } } /* transform rows */ for (s = a; s < a+n; s += C) { if (!six_step_fnt(s, C, modnum)) { return 0; } } #if 0 /* An unordered transform is sufficient for convolution. */ if (ordered) { transpose_3xpow2(a, R, C); } #endif return 1; }
/* backward transform, sign = 1; transform length = 3 * 2**n */ int inv_four_step_fnt(const mpd_context_t *ctx, mpd_uint_t *a, mpd_size_t n, int modnum) { mpd_size_t R = 3; /* number of rows */ mpd_size_t C = n / 3; /* number of columns */ mpd_uint_t w3table[3]; mpd_uint_t kernel, w0, w1, wstep; mpd_uint_t *s, *p0, *p1, *p2; mpd_uint_t umod; #ifdef PPRO double dmod; uint32_t dinvmod[3]; #endif mpd_size_t i, k; assert(n >= 48); assert(n <= 3*MPD_MAXTRANSFORM_2N); #if 0 /* An unordered transform is sufficient for convolution. */ /* Transpose the matrix, producing an R*C matrix. */ transpose_3xpow2(a, C, R); #endif /* Length C transform on the rows. */ for (s = a; s < a+n; s += C) { if (!inv_six_step_fnt(ctx, s, C, modnum)) { return 0; } } /* Multiply each matrix element (addressed by i*C+k) by r**(i*k). */ SETMODULUS(modnum); kernel = _mpd_getkernel(n, 1, modnum); for (i = 1; i < R; i++) { w0 = 1; w1 = POWMOD(kernel, i); wstep = MULMOD(w1, w1); for (k = 0; k < C; k += 2) { mpd_uint_t x0 = a[i*C+k]; mpd_uint_t x1 = a[i*C+k+1]; MULMOD2(&x0, w0, &x1, w1); MULMOD2C(&w0, &w1, wstep); a[i*C+k] = x0; a[i*C+k+1] = x1; } } /* Length R transform on the columns. */ _mpd_init_w3table(w3table, 1, modnum); for (p0=a, p1=p0+C, p2=p0+2*C; p0<a+C; p0++,p1++,p2++) { SIZE3_NTT(p0, p1, p2, w3table); } return 1; }
/* initialize transform parameters */ struct fnt_params * _mpd_init_fnt_params(mpd_size_t n, int sign, int modnum) { struct fnt_params *tparams; mpd_uint_t umod; #ifdef PPRO double dmod; uint32_t dinvmod[3]; #endif mpd_uint_t kernel, imag, w; mpd_uint_t i; mpd_size_t nhalf; assert(ispower2(n)); assert(sign == -1 || sign == 1); assert(P1 <= modnum && modnum <= P3); nhalf = n/2; tparams = mpd_sh_alloc(sizeof *tparams, nhalf, sizeof (mpd_uint_t)); if (tparams == NULL) { return NULL; } SETMODULUS(modnum); kernel = _mpd_getkernel(n, sign, modnum); imag = _mpd_getkernel(4, -sign, modnum); tparams->modnum = modnum; tparams->modulus = umod; tparams->imag = imag; tparams->kernel = kernel; w = 1; for (i = 0; i < nhalf; i++) { tparams->wtable[i] = w; w = MULMOD(w, kernel); } return tparams; }
/* initialize wtable of size three */ void _mpd_init_w3table(mpd_uint_t w3table[3], int sign, int modnum) { mpd_uint_t umod; #ifdef PPRO double dmod; uint32_t dinvmod[3]; #endif mpd_uint_t kernel; SETMODULUS(modnum); kernel = _mpd_getkernel(3, sign, modnum); w3table[0] = 1; w3table[1] = kernel; w3table[2] = POWMOD(kernel, 2); }
/* forward transform with sign = -1 */ int six_step_fnt(mpd_uint_t *a, mpd_size_t n, int modnum) { struct fnt_params *tparams; mpd_size_t log2n, C, R; mpd_uint_t kernel; mpd_uint_t umod; #ifdef PPRO double dmod; uint32_t dinvmod[3]; #endif mpd_uint_t *x, w0, w1, wstep; mpd_size_t i, k; assert(ispower2(n)); assert(n >= 16); assert(n <= MPD_MAXTRANSFORM_2N); log2n = mpd_bsr(n); C = ((mpd_size_t)1) << (log2n / 2); /* number of columns */ R = ((mpd_size_t)1) << (log2n - (log2n / 2)); /* number of rows */ /* Transpose the matrix. */ if (!transpose_pow2(a, R, C)) { return 0; } /* Length R transform on the rows. */ if ((tparams = _mpd_init_fnt_params(R, -1, modnum)) == NULL) { return 0; } for (x = a; x < a+n; x += R) { fnt_dif2(x, R, tparams); } /* Transpose the matrix. */ if (!transpose_pow2(a, C, R)) { mpd_free(tparams); return 0; } /* Multiply each matrix element (addressed by i*C+k) by r**(i*k). */ SETMODULUS(modnum); kernel = _mpd_getkernel(n, -1, modnum); for (i = 1; i < R; i++) { w0 = 1; /* r**(i*0): initial value for k=0 */ w1 = POWMOD(kernel, i); /* r**(i*1): initial value for k=1 */ wstep = MULMOD(w1, w1); /* r**(2*i) */ for (k = 0; k < C; k += 2) { mpd_uint_t x0 = a[i*C+k]; mpd_uint_t x1 = a[i*C+k+1]; MULMOD2(&x0, w0, &x1, w1); MULMOD2C(&w0, &w1, wstep); /* r**(i*(k+2)) = r**(i*k) * r**(2*i) */ a[i*C+k] = x0; a[i*C+k+1] = x1; } } /* Length C transform on the rows. */ if (C != R) { mpd_free(tparams); if ((tparams = _mpd_init_fnt_params(C, -1, modnum)) == NULL) { return 0; } } for (x = a; x < a+n; x += C) { fnt_dif2(x, C, tparams); } mpd_free(tparams); #if 0 /* An unordered transform is sufficient for convolution. */ /* Transpose the matrix. */ if (!transpose_pow2(a, R, C)) { return 0; } #endif return 1; }