/* * In-place transposition of a 2^n x 2^n or a 2^n x (2*2^n) * or a (2*2^n) x 2^n matrix. */ int transpose_pow2(mpd_uint_t *matrix, mpd_size_t rows, mpd_size_t cols) { mpd_size_t size = mul_size_t(rows, cols); assert(ispower2(rows)); assert(ispower2(cols)); if (cols == rows) { squaretrans_pow2(matrix, rows); } else if (cols == mul_size_t(2, rows)) { if (!swap_halfrows_pow2(matrix, rows, cols, FORWARD_CYCLE)) { return 0; } squaretrans_pow2(matrix, rows); squaretrans_pow2(matrix+(size/2), rows); } else if (rows == mul_size_t(2, cols)) { squaretrans_pow2(matrix, cols); squaretrans_pow2(matrix+(size/2), cols); if (!swap_halfrows_pow2(matrix, cols, rows, BACKWARD_CYCLE)) { return 0; } } else { abort(); /* GCOV_NOT_REACHED */ } return 1; }
/* * In-place transposition of a 2^n x 2^n or a 2^n x (2*2^n) * or a (2*2^n) x 2^n matrix. */ static int transpose_pow2_c(uint8_t *matrix, mpd_size_t rows, mpd_size_t cols) { mpd_size_t size = mul_size_t(rows, cols); assert(ispower2(rows)); assert(ispower2(cols)); if (cols == rows) { squaretrans_pow2_c(matrix, rows); } else if (cols == mul_size_t(2, rows)) { if (!swap_halfrows_pow2_c(matrix, rows, cols, FORWARD_CYCLE)) { return 0; } squaretrans_pow2_c(matrix, rows); squaretrans_pow2_c(matrix+(size/2), rows); } else if (rows == mul_size_t(2, cols)) { squaretrans_pow2_c(matrix, cols); squaretrans_pow2_c(matrix+(size/2), cols); if (!swap_halfrows_pow2_c(matrix, cols, rows, BACKWARD_CYCLE)) { return 0; } } else { mpd_err_fatal("transpose_pow2_c: illegal matrix size"); } 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; }
/* 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); }
/* reverse transform, sign = 1 */ int std_inv_fnt(mpd_uint_t *a, mpd_size_t n, int modnum) { struct fnt_params *tparams; assert(ispower2(n)); assert(n >= 4); assert(n <= 3*MPD_MAXTRANSFORM_2N); if ((tparams = _mpd_init_fnt_params(n, 1, modnum)) == NULL) { return 0; } fnt_dif2(a, n, tparams); mpd_free(tparams); return 1; }