User:An unused username/sandbox

The Vector-Radix FFT algorithm, is a multidimensional Fast Fourier transform (FFT) algorithm, which is a generalization of the ordinary Cooley–Tukey FFT algorithm that divides the transform dimensions by arbitrary radices. It breaks a multidimensional (MD) discrete Fourier transform (DFT) down into successively smaller MD DFTs until, ultimately, only trivial MD DFTs need to be evaluated.

The most common multidimensional FFT algorithm is row-column algorithm, which means transforming the array first in one index and then in the other, see more in FFT. Then a radix-2 direct 2-D FFT has been developed, and it can eliminate 25% of the multiplies by the conventional row-column approach. And this algorithm has been extended to rectangular arrays and arbitrary radices, which is the general Vector-Radix algorithm. Perhaps it is the simplest non-row-column FFT algorithm.

Vector-radix FFT algorithm can reduce the number of complex multiplications significantly, compared to row-vector algorithm. For example, for a $$N^M$$ time matrix (M dimensions, and size N on each dimension), the number of complex multiples of vector-radix FFT algorithm is $$\frac{2^M -1}{2^M} N^M log_2 N$$, meanwhile, for row-column algorithm, it is $$\frac{M N^M}{2} log_2 N$$. And generally, even larger savings in multiplies are obtained when this algorithm is operated on larger radices and on higher dimensional arrays.

2-D DIT case
As with Cooley–Tukey FFT algorithm, two dimensional vector-radix FFT is derived by decomposing the regular 2-D DFT into sums of smaller DFT's multiplied by "twiddle" factor.

A decimation-in-time (DIT) algorithm means the decomposition is based on time domain $$x$$, see more in Cooley–Tukey FFT algorithm.

We suppose the 2-D DFT
 * $$X(k_1,k_2) = \sum_{n_1=0}^{N_1-1} \sum_{n_2=0}^{N_2-1} x[n_1, n_2] \cdot W_{N_1}^{k_1 n_1} W_{N_2}^{k_2 n_2}, $$

where $$k_1 = 0,\dots,N_1-1$$,and $$k_2 = 0,\dots,N_2-1$$, and $$x[n_1, n_2]$$ is a $$N_1 \times N_2$$ matrix, and $$W_{N}^{k n} = exp(-j 2\pi /N)$$.

For simplicity, let us assume that $$N_1=N_2=N$$, and radix-$$(r\times r)$$($$N/r$$ are integers).

Using the change of variables: where $$i = 1$$ or $$2$$.
 * $$n_i=rp_i+q_i$$, where $$p_i=0,\cdots,(N/r)-1; q_i = 0,\cdots,r-1;$$
 * $$k_i=u_i+v_i N/r$$, where $$u_i=0,\cdots,(N/r)-1; v_i = 0,\cdots,r-1;$$

Then, the two dimensional DFT can be written as:
 * $$ X(u_1+v_1 N/r,u_2+v_2 N/r)=\sum_{q_1=0}^{r-1} \sum_{q_2=0}^{r-1} \left[ \sum_{p_1=0}^{N/r-1} \sum_{p_2=0}^{N/r-1} x[rp_1+q_1, rp_1+q_1] W_{N/r}^{p_1 u_1} W_{N/r}^{p_2 u_2} \right] \cdot W_{N}^{q_1 u_1+q_2 u_2} W_{r}^{q_1 v_1} W_{r}^{q_2 v_2},$$



The equation above defines the basic structure of the 2-D DIT radix-$$(r\times r)$$ "butterfly". (See 1-D "butterfly" in Cooley–Tukey FFT algorithm)

When $$r=2$$, the equation can be broken into four summations: one over those samples of x for which both $$n_1$$ and $$n_2$$ are even, one for which $$n_1$$ is even and $$n_2$$ is odd, one of which $$n_1$$ is odd and $$n_2$$ is even, and one for which both $$n_1$$ and $$n_2$$ are odd, and this leads to:
 * $$ X(k_1,k_2) = S_{00}(k_1,k_2) + S_{01}(k_1,k_2) W_{N}^{k_2} +S_{10}(k_1,k_2) W_{N}^{k_1} + S_{11}(k_1,k_2) W_{N}^{k_1+k_2}$$,

where $$S_{ij}(k_1,k_2)=\sum_{n_1=0}^{N/2-1} \sum_{n_2=0}^{N/2-1} x[2 n_1 + i, 2 n_2 + j] \cdot W_{N/2}^{n_1 k_1} W_{N/2}^{n_2 k_2}$$.

2-D DIF case
Similarly, a decimation-in-frequency (DIF, also called the Sande-Tukey algorithm) algorithm means the decomposition is based on frequency domain $$X$$, see more in Cooley–Tukey FFT algorithm.

Using the change of variables: where $$i = 1$$ or $$2$$.
 * $$n_i=p_i+q_i N/r$$, where $$p_i=0,\cdots,(N/r)-1; q_i = 0,\cdots,r-1;$$
 * $$k_i=r u_i+v_i$$, where $$u_i=0,\cdots,(N/r)-1; v_i = 0,\cdots,r-1;$$

And the DFT equation can be written as:
 * $$ X(r u_1+v_1,r u_2+v_2)=\sum_{p_1=0}^{N/r-1} \sum_{p_2=0}^{N/r-1} \left[ \sum_{q_1=0}^{r-1} \sum_{q_2=0}^{r-1} x[p_1+q_1 N/r, p_1+q_1 N/r] W_{r}^{q_1 v_1} W_{r}^{q_2 v_2} \right] \cdot W_{N}^{p_1 v_1+p_2 v_2} W_{N/r}^{p_1 u_1} W_{N/r}^{p_2 u_2},$$

Other approaches
The Split-radix FFT algorithm has been proved to be a useful method for 1-D DFT. And this method has been applied to the vector-radix FFT to obtain a split vector-radix FFT.

In conventional 2-D vector-radix algorithm, we decompose the incident $$k_1,k_2$$ into 4 groups:

$$ \begin{array}{lcl} X(2 k_1, 2 k_2) & : & even-even \\ X(2 k_1, 2 k_2 +1) & : & even-odd \\ X(2 k_1 +1, 2 k_2) & : & odd-even \\ X(2 k_1+1, 2 k_2+1) & : & odd-odd \end{array} $$

By the split vector-radix algorithm, the first three groups remain unchanged, the fourth odd-odd group is further decomposed into another four sub-groups, and seven groups in total:

$$ \begin{array}{lcl} X(2 k_1, 2 k_2) & : & even-even \\ X(2 k_1, 2 k_2 +1) & : & even-odd \\ X(2 k_1 +1, 2 k_2) & : & odd-even \\ X(4 k_1+1, 4 k_2+1) & : & odd-odd \\ X(4 k_1+1, 4 k_2+3) & : & odd-odd \\ X(4 k_1+3, 4 k_2+1) & : & odd-odd \\ X(4 k_1+3, 4 k_2+3) & : & odd-odd \end{array} $$

That means the fourth term in 2-D DIT radix-$$(2\times 2)$$ equation, $$S_{11}(k_1,k_2) W_{N}^{k_1+k_2}$$ becomes:


 * $$ A_{11}(k_1,k_2) W_{N}^{k_1+k_2} + A_{13}(k_1,k_2) W_{N}^{k_1+3 k_2} +A_{31}(k_1,k_2) W_{N}^{3 k_1+k_2} + A_{33}(k_1,k_2) W_{N}^{3(k_1+k_2)}$$,

where $$A_{ij}(k_1,k_2)=\sum_{n_1=0}^{N/4-1} \sum_{n_2=0}^{N/4-1} x[4 n_1 + i, 4 n_2 + j] \cdot W_{N/4}^{n_1 k_1} W_{N/4}^{n_2 k_2}$$

The 2-D N by N DFT is then obtained by successive use of the above decomposition, up to the last stage.

It has been shown that the split vector radix algorithm has saved about 30% of the complex multiplications and about the same number of the complex additions for typical $$1024\times 1024$$ array, compared with the vector-radix algorithm.