Algoritmo FFT Vector-radix - Vector-radix FFT algorithm

L' algoritmo FFT vettore-Radix , è un multidimensionale trasformata di Fourier veloce algoritmo (FFT), che è una generalizzazione del normale algoritmo di Cooley-Tukey FFT che divide la trasformazione dimensioni da radices arbitrarie. Romperà un multidimensionale (MD) trasformata di Fourier discreta (DFT) giù in sempre più piccoli fino DFTS MD, in ultima analisi, DFTS MD solo banali devono essere valutate.

Il più comune multidimensionale FFT algoritmo è l'algoritmo riga-colonna, che significa trasformare la matrice prima in un indice e poi nell'altro, vedere più nel FFT . Poi una radice-2 diretta 2-D FFT è stata sviluppata, e può eliminare il 25% dei moltiplica rispetto all'approccio riga-colonna convenzionale. E questo algoritmo è stato esteso a serie rettangolari e radices arbitrarie, che è l'algoritmo generico vettore-radice.

Algoritmo FFT vettore-Radix può ridurre il numero di moltiplicazioni complesse in modo significativo, rispetto a riga vettore algoritmo. Ad esempio, per una matrice elemento (dimensione M, e la dimensione N di ogni dimensione), il numero di multipli complessi di algoritmo FFT vettore-Radix per Radix-2 è , nel frattempo, per l'algoritmo riga-colonna, è . E generalmente, risparmi ancora più grandi moltiplica si ottengono quando questo algoritmo funziona a radices grandi e su array di dimensione superiore.${\ Displaystyle N ^ {M}}$${\ Displaystyle {\ frac {2 ^ {M} -1} {2 ^ {M}}} N ^ {M} \ log _ {2} N}$${\ Displaystyle {\ frac {MN ^ {M}} {2}} \ log _ {2} N}$

Nel complesso, l'algoritmo vettore-Radix riduce significativamente la complessità strutturale della tradizionale DFT avente uno schema di indicizzazione meglio, a scapito di un leggero aumento nelle operazioni aritmetiche. Quindi, questo algoritmo è ampiamente usato per molte applicazioni in ingegneria, scienze e la matematica, per esempio, le implementazioni di elaborazione delle immagini, e il processore FFT ad alta velocità di progettazione.

2-D caso DIT

Come con Cooley-Tukey algoritmo FFT , bidimensionale vettore-radice FFT deriva decomponendo regolare 2-D DFT in somme di minore DFT moltiplicato per "girarsi" fattore.

Una decimazione-in-time ( DIT algoritmo) significa che la decomposizione è basato sul dominio del tempo , vedere di più nel algoritmo di Cooley-Tukey FFT . ${\ Displaystyle x}$

Supponiamo il 2-D DFT

${\ Displaystyle X (k_ {1}, {2} k_) = \ sum _ {n_ {1} = 0} ^ {N_ {1}} -1 \ somma _ {n_ {2} = 0} ^ {N_ {2}} -1 x [n_ {1}, n_ {2}] \ cdot W_ {n_ {1}} ^ {k_ {1} n_ {1}} W_ {n_ {2}} ^ {{2 k_ } n_ {2}},}$

dove , e , ed è una matrice, e . ${\ Displaystyle k_ {1} = 0, \ dots, N_ {1}} -1$${\ Displaystyle k_ {2} = 0, \ dots, N_ {2}} -1$${\ Displaystyle x [n_ {1}, n_ {2}]}$${\ Displaystyle n_ {1} \ times N_ {2}}$${\ Displaystyle W_ {N} = \ exp (-j2 \ pi / N)}$

Per semplicità, supponiamo che , e radix- ( sono numeri interi). ${\ Displaystyle N_ {1} = N_ {2} = N}$${\ Displaystyle (r \ times r)}$${\ Displaystyle N / r}$

Utilizzando il cambiamento di variabili:

• ${\ Displaystyle n_ {i} = rp_ {i} + Q_ {i}}$, dove ${\ Displaystyle p_ {i} = 0, \ ldots, (N / R) -1; Q_ {i} = 0, \ ldots, r-1;}$
• ${\ Displaystyle k_ {i} = u_ {i} + V_ {i} N / r}$, dove ${\ Displaystyle u_ {i} = 0, \ ldots, (N / R) -1; v_ {i} = 0, \ ldots, r-1;}$

dove o , poi i due DFT dimensionale può essere scritta come:${\ Displaystyle i = 1}$${\ Displaystyle 2}$

${\ Displaystyle 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}},}$

Uno stadio "butterfly" per DIT vettore-Radix 2x2 FFT

L'equazione di cui sopra definisce la struttura di base del 2-D DIT radix- "butterfly". (Vedi 1-D "farfalla" in algoritmo di Cooley-Tukey FFT ) ${\ Displaystyle (r \ times r)}$

Quando , l'equazione può essere suddiviso in quattro sommatorie: uno sopra quei campioni di x per cui entrambi e sono anche, quello per il quale è pari e dispari, uno dei quali è dispari e è uniforme, e una per cui entrambi e sono dispari , e questo porta a: ${\ Displaystyle r = 2}$${\ Displaystyle n_ {1}}$${\ Displaystyle n_ {2}}$${\ Displaystyle n_ {1}}$${\ Displaystyle n_ {2}}$${\ Displaystyle n_ {1}}$${\ Displaystyle n_ {2}}$${\ Displaystyle n_ {1}}$${\ Displaystyle n_ {2}}$

${\ Displaystyle 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}},}$

dove ${\ Displaystyle S_ {ij} (k_ {1}, {2} k_) = \ sum _ {n_ {1} = 0} ^ {N / 2-1} \ somma _ {n_ {2} = 0} ^ {N} / 2-1 x [2n_ {1} + i, 2n_ {2} + j] \ cdot W_ {N / 2} ^ {n_ {1} k_ {1}} {W_ N / 2} ^ { n_ {2} k_ {2}}.}$

2-D caso DIF

Analogamente, una decimazione-in-frequenza ( DIF , chiamato anche l'algoritmo Sande-Tukey) algoritmo s'intende la decomposizione si riferiscono al dominio di frequenza , vedere più nel algoritmo Cooley-Tukey FFT . ${\ Displaystyle X}$

Utilizzando il cambiamento di variabili:

• ${\ Displaystyle n_ {i} = p_ {i} + Q_ {i} N / r}$, dove ${\ Displaystyle p_ {i} = 0, \ ldots, (N / R) -1; Q_ {i} = 0, \ ldots, r-1;}$
• ${\ Displaystyle k_ {i} = ru_ {i} + V_ {i}}$, dove ${\ Displaystyle u_ {i} = 0, \ ldots, (N / R) -1; v_ {i} = 0, \ ldots, r-1;}$

dove o , e l'equazione DFT può essere scritta come:${\ Displaystyle i = 1}$${\ Displaystyle 2}$

${\ Displaystyle X (ru_ {1} + V_ {1}, ru_ {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}},}$

altri approcci

L' algoritmo FFT split-radice è stato dimostrato di essere un metodo utile per 1-D DFT. E questo metodo è stato applicato alla FFT vettoriale Radix ottenere una FFT scissione vettore-radice.

In algoritmo vettore-Radix 2-D convenzionale, scomponiamo gli indici in 4 gruppi: ${\ Displaystyle k_ {1}, k_ {2}}$

${\ Displaystyle {\ begin {array} {} LCL X (2k_ {1}, {2} 2k_) &: & {\ text {pari-pari}} \\ X (2k_ {1}, {2} 2k_ + 1) &: & {\ text {pari-dispari}} \\ X (2k_ {1} + 1,2k_ {2}) &: & {\ text {pari-dispari}} \\ X (2k_ {1} + 1,2k_ {2} +1) &: & {\ text {dispari-dispari}} \ end {array}}}$

Dall'algoritmo vettore-Radix spaccato, i primi tre gruppi rimangono invariati, il quarto gruppo dispari-dispari è ulteriormente scomposto in altri quattro sottogruppi, e sette gruppi in totale:

${\ Displaystyle {\ begin {array} {} LCL X (2k_ {1}, {2} 2k_) &: & {\ text {pari-pari}} \\ X (2k_ {1}, {2} 2k_ + 1) &: & {\ text {pari-dispari}} \\ X (2k_ {1} + 1,2k_ {2}) &: & {\ text {pari-dispari}} \\ X (4k_ {1} + 1,4k_ {2} +1) &: & {\ text {dispari-dispari}} \\ X (4k_ {1} + 1,4k_ {2} 3) &: & {\ text {dispari-dispari }} \\ X (4k_ {1} + 3,4k_ {2} +1) &: & {\ text {dispari-dispari}} \\ X (4k_ {1} + 3,4k_ {2} 3) &: & {\ text {dispari-dispari}} \ end {array}}}$

Ciò significa che il quarto termine in 2-D DIT radix- equazione diventa:${\ Displaystyle (2 \ 2 volte)}$${\ Displaystyle S_ {11} (k_ {1}, {2} k_) W_ {N} ^ {k_ {1} + k_ {2}}}$

${\ Displaystyle A_ {11} (k_ {1}, k_ {2}) W_ {N} ^ {k_ {1} + k_ {2}} + A_ {13} (k_ {1}, k_ {2}) W_ {N} ^ {k_ {1} + 3k_ {2}} + A_ {31} (k_ {1}, k_ {2}) W_ {N} ^ {3k_ {1} + k_ {2}} + A_ {33} (k_ {1}, {2} k_) W_ {N} ^ {3 (k_ {1} + k_ {2})},}$

dove ${\ Displaystyle A_ {ij} (k_ {1}, {2} k_) = \ sum _ {n_ {1} = 0} ^ {N / 4-1} \ somma _ {n_ {2} = 0} ^ {N} / 4-1 x [4n_ {1} + i, 4n_ {2} + j] \ cdot W_ {N / 4} ^ {n_ {1} k_ {1}} W_ {N / 4} ^ { n_ {2} k_ {2}}}$

Il 2-DN da N DFT viene ottenuta mediante l'uso successivo della decomposizione sopra, fino all'ultima fase.

E 'stato dimostrato che l'algoritmo vettore radice scissione ha salvato circa il 30% delle moltiplicazioni complesse e circa lo stesso numero dei complessi aggiunte per tipica matrice, rispetto l'algoritmo vettore-radice.${\ Displaystyle 1024 \ 1024 volte}$

Riferimenti