Fast Fourier Transform

Fra Wikipedia, den frie encyklopædi
Gå til: navigation, søg

FFT (eng. Fast Fourier Transform) er en algoritme til beregning af Fouriertransformationen af en diskret serie af værdier. Den anvendes til digital signalbehandling.

Et signal kan være en optagelse af lyd. Når lyden er digitaliseret, som den er på en musik-CD, kan den Fouriertransformeres med FFT. I den transformerede serie kan udvalgte frekvenser forstærkes eller dæmpes. Derefter kan serien transformeres tilbage og afspilles som lyd, hvor f.eks. diskant eller bas er hævet eller sænket.

Ved at fjerne frekvenser fra serien kan signalet komprimeres. Det således komprimerede signal kan overføres over langsomme dataforbindelser og efter modtagelsen transformeres tilbage. Det signal, som høres i den anden ende, er ikke identisk med det oprindelige signal, men hvis frekvenserne vælges rigtigt vil man kun kunne høre en mindre forskel.

Metoden anvendes også videnskabeligt. Det er muligt ved hjælp af FFT at sammenligne to signaler og identificere komponenter, som med en relativ tidsforskydning indgår i begge signaler. Det anvendes indenfor seismologi til at analysere seismiske signaler, som er registreret på forskellige geografiske positioner. De komponenter i signalerne, som stammer fra samme jordskælv, kan udskilles fordi de ligner hinanden. Tidsforskellen bruges til at fastslå hvor skælvet fandt sted.

Et digitalt foto kan opfattes som en todimensional serie af diskrete værdier. FFT kan også anvendes på todimensionale serier, og anvendes således til komprimering af billedet ved at fjerne frekvenser, som ikke indeholder væsentlig billedinformation.

Den første matematiker, som anvendte FFT, var Gauss omkring 1805. Pga. af hans store grundighed nåede han, som så meget andet, ikke at publicere sine resultater. Det medførte, at de gik i glemmebogen, indtil de genopdagedes af James W. Cooley og John W. Tukey i 1965.

Algoritme[redigér | redigér wikikode]

De hyppigst anvendte algoritmer bygger på et "del og hersk"-princip. I den såkaldte radix 2-FFT opdeles Serien i to mindre serier, som derefter hver især opdeles igen ved rekursion, indtil man når frem til så små serier, at de nemt kan transformeres. Metoden beskrives her ved pseudo-kode.

Serien udtrykkes ved en vektor af komplekse værdier:


  \vec f = [a_0 + i \cdot b_0,a_1 + i \cdot b_1,a_2 + i \cdot b_2, \ldots ,a_{n-1} + i \cdot b_{n-1}] = [f_0,f_1,f_2, \ldots , f_{n-1}]

\ \ i er det imaginære grundtal, og de indicerede værdier af \ \ a og \ \ b er målte serier. Det kunne være venstre og højre kanal i et stereosignal. Tidsforskellen mellem de målte værdier bestemmes af den ønskede øvre frekvens, og længden af serien bestemmes af den ønskede nedre frekvens; disse to størrelser bestemmer værdien af \ \ n, som i dette eksempel er en potens af 2:

\ n=2^k

hvor \ \ k er et naturligt tal.

FFT udføres ved hjælp af funktionen \ \operatorname{fft}:

   \mathrm{function}\ \operatorname{fft} (\vec f):

  \ \ n = \operatorname{length}(\vec f)
  \mathrm{if}\ (n == 1):
 \vec c\ = \vec f
  \ \ \mathrm{else}:
 \vec g = \operatorname{split}(even, \vec f))
 \vec u = \operatorname{split}(odd,  \vec f))
 \ \ \kappa = e^{-2 \pi \cdot i / n}
 \mathrm{for}\ k=0 \ \mathrm{to} \ n-1:
\ \ c_k     = g_k + u_k
\ \ c_{k+n/2} = g_k + u_k \cdot \kappa^k
  \mathrm{return}\ \vec c

Serien opdeles på denne måde:

   \mathrm{function}\ \operatorname{split}(\operatorname{eo},\vec f):

  \mathrm{switch}\ (eo)
 even : \vec c = [f_0,f_2, \ldots , f_{n-2}]
 odd : \vec c = [f_1,f_3, \ldots , f_{n-1}]
  \mathrm{return}\ \operatorname{fft}(\vec c)

Beregningstid[redigér | redigér wikikode]

Man kan beregne fouriertransformationen for en diskret serie ved at gå ud fra udtrykket:

F_m = \sum_{k=0}^{n-1} f_k \cdot e^{-2\pi \cdot i \cdot m \cdot k/n} \ \ ; m = 0,1,2, \ldots , n-1

Det vil kræve \ \ n^2 beregninger af den komplekse exponentialfunktion og det samme antal komplekse multiplikationer.
Ved at benytte FFT reduceres antallet af beregninger af exponentialfuktionen til \operatorname{log_2}(n) og antallet af multiplikationer til n \cdot \operatorname{log_2}(n).
Hvis n eksempelvis er 1024, så reduceres antallet af trigonometriske beregninger og multiplikationer fra 1.048.576 til 10 og 10240, hhv. Alt andet lige reducerer det beregningstiden med mindst en faktor 100.

Et enkelt eksempel[redigér | redigér wikikode]

For at vise hvordan metoden virker er her et eksempel med en serie med længden 8.

I eksemplet benyttes størrelsen:

\kappa = e^{-2\pi\cdot i/8}

I beregningerne udnyttes at:

\kappa^8 = e^{-2\pi \cdot i} = 1

Det medfører yderligere at:

\kappa^{8 \cdot n + k} = \kappa^k

Her benyttes regnereglerne:

\kappa^n \cdot \kappa^m = \kappa^{n + m}

og:

\kappa^{n \cdot m} = (\kappa^n)^m

Skemaet illustrerer hvordan beregningerne udføres:

f0 f1 f2 f3 f4 f5 f6 f7 beregning
F0
f0•κ0=f0 f1•κ0=f1 f2•κ0=f2 f3•κ0=f3 f4•κ0=f4 f5•κ0=f5 f6•κ0=f6 f7•κ0=f7 ((f0+f4)+(f2+f6))+((f1+f5)+(f3+f7))
F1 f0•κ0=f0 f1•κ f2•κ² f3•κ3 f4•κ4 f5•κ5 f6•κ6 f7•κ7 ((f0+f4•κ4)+(f2+f6•κ4)•κ²)+((f1+f5•κ4)+(f3+f7•κ4)•κ²)•κ
F2 f0•κ0=f0 f1•κ² f2•κ4 f3•κ6 f4•κ8=f4 f5•κ10=f5•κ² f6•κ12=f6•κ4 f7•κ14=f7•κ6 ((f0+f4)+(f2+f6)•κ4)+((f1+f5)+(f3+f7)•κ4)•κ²
F3 f0•κ0=f0 f1•κ3 f2•κ6 f3•κ9=f3•κ f4•κ12=f4•κ4 f5•κ15=f5•κ7 f6•κ18=f6•κ² f7•κ21=f7•κ5 ((f0+f4•κ4)+(f2+f6•κ4)•κ6)+((f1+f5•κ4)+(f3+f7•κ4)•κ6)•κ3
F4 f0•κ0=f0 f1•κ4 f2•κ8=f2 f3•κ12=f3•κ4 f4•κ16=f4 f5•κ20=f5•κ4 f6•κ24=f6 f7•κ28=f7•κ4 ((f0+f4)+(f2+f6))+((f1+f5)+(f3+f7))•κ4
F5 f0•κ0=f0 f1•κ5 f2•κ10=f2•κ² f3•κ15=f3•κ7 f4•κ20=f4•κ4 f5•κ25=f5•κ f6•κ30=f6•κ6 f7•κ35=f7•κ3 ((f0+f4•κ4)+(f2+f6•κ4)•κ²)+((f1+f5•κ4)+(f3+f7•κ4)•κ²)•κ5
F6 f0•κ0=f0 f1•κ6 f2•κ12=f2•κ4 f3•κ18=f3•κ² f4•κ24=f4 f5•κ30=f5•κ6 f6•κ36=f6•κ4 f7•κ42=f7•κ² ((f0+f4)+(f2+f6)•κ4)+((f1+f5)+(f3+f7)•κ4)•κ6
F7 f0•κ0=f0 f1•κ7 f2•κ14=f2•κ6 f3•κ21=f3•κ5 f4•κ28=f4•κ4 f5•κ35= f5•κ3 f6•κ42=f6•κ² f7•κ49=f7•κ ((f0+f4•κ4)+(f2+f6•κ4)•κ6)+((f1+f5•κ4)+(f3+f7•κ4)•κ6)•κ7

Som det ses, er der mange udregninger, som kan genbruges. Eksempelvis indgår (f_0 + f_4 \cdot \kappa^4) flere steder. I algoritmen udregnes denne størrelse kun én gang, og derved spares en del regnetid.

I dette eksempel, hvor serien af hensyn til overskueligheden er ganske lille, er besparelsen også lille. Når serien bliver stor, bliver besparelsen større.

Alternative metoder[redigér | redigér wikikode]

Den her viste radix 2 FFT er den mest udbredte algoritme i DSP-kode. Den bygger på, at længden af serien reduceres ved at dele den lige over i to halvdele. Heraf kommer kravet om, at n skal være en potens af 2. Deles serien op i fire dele, kaldes algoritmen for en radix 4 FFT, og på en processor med mange dataregistre kan den være markant hurtigere end radix 2 FFT-algoritmen.

Der er senere udviklet metoder, hvor man udnytter primfaktoropløsning af n. Når m indgår som primfaktor i n, så kan serien opdeles i m mindre serier, som hver har længden n / m. Disse kan så igen opdeles, indtil længden af serierne selv bliver et primtal.

Se også[redigér | redigér wikikode]