/* 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 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); }
/* transform kernel */ mpd_uint_t _mpd_getkernel(mpd_uint_t n, int sign, int modnum) { mpd_uint_t umod, p, r, xi; #ifdef PPRO double dmod; uint32_t dinvmod[3]; #endif SETMODULUS(modnum); r = mpd_roots[modnum]; p = umod; xi = (p-1) / n; if (sign == -1) return POWMOD(r, (p-1-xi)); else return POWMOD(r, xi); }
/* 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; }
/* 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; }
/* Fast Number Theoretic Transform, decimation in frequency. */ void fnt_dif2(mpd_uint_t a[], mpd_size_t n, struct fnt_params *tparams) { mpd_uint_t *wtable = tparams->wtable; mpd_uint_t umod; #ifdef PPRO double dmod; uint32_t dinvmod[3]; #endif mpd_uint_t u0, u1, v0, v1; mpd_uint_t w, w0, w1, wstep; mpd_size_t m, mhalf; mpd_size_t j, r; assert(ispower2(n)); assert(n >= 4); SETMODULUS(tparams->modnum); /* m == n */ mhalf = n / 2; for (j = 0; j < mhalf; j += 2) { w0 = wtable[j]; w1 = wtable[j+1]; u0 = a[j]; v0 = a[j+mhalf]; u1 = a[j+1]; v1 = a[j+1+mhalf]; a[j] = addmod(u0, v0, umod); v0 = submod(u0, v0, umod); a[j+1] = addmod(u1, v1, umod); v1 = submod(u1, v1, umod); MULMOD2(&v0, w0, &v1, w1); a[j+mhalf] = v0; a[j+1+mhalf] = v1; } wstep = 2; for (m = n/2; m >= 2; m>>=1, wstep<<=1) { mhalf = m / 2; /* j == 0 */ for (r = 0; r < n; r += 2*m) { u0 = a[r]; v0 = a[r+mhalf]; u1 = a[m+r]; v1 = a[m+r+mhalf]; a[r] = addmod(u0, v0, umod); v0 = submod(u0, v0, umod); a[m+r] = addmod(u1, v1, umod); v1 = submod(u1, v1, umod); a[r+mhalf] = v0; a[m+r+mhalf] = v1; } for (j = 1; j < mhalf; j++) { w = wtable[j*wstep]; for (r = 0; r < n; r += 2*m) { u0 = a[r+j]; v0 = a[r+j+mhalf]; u1 = a[m+r+j]; v1 = a[m+r+j+mhalf]; a[r+j] = addmod(u0, v0, umod); v0 = submod(u0, v0, umod); a[m+r+j] = addmod(u1, v1, umod); v1 = submod(u1, v1, umod); MULMOD2C(&v0, &v1, w); a[r+j+mhalf] = v0; a[m+r+j+mhalf] = v1; } } } bitreverse_permute(a, n); }