chaKrystian Stański

Nr indeksu: 210941

Algorytm dziel I zwyciężaj, szybka transformata

Fouriera (FFT)
% GENERACJA SYGNAŁU
N=8; % liczba próbek sygnału
x=0:N-1; % przykładowe wartości próbek
typBitReverse=1; % 1 lub 2 - wybór algorytmu przestawiania próbek (wolna,
szybka)
typFFT=1; % 1 lub 2 - wybór właściwej pętli FFT (wolna, szybka)
xc = x; % kopia sygnału x
Linia 2: Ustala liczbę próbek sygnału na 8 (N=8). FFT jest algorytmem używanym do analizy
sygnałów o określonej liczbie próbek.

Linia 3: Tworzy wektor próbek sygnału od 0 do N-1 (x=0:N-1). Jest to podstawowy sygnał, na którym
zostanie przeprowadzona transformacja Fouriera.

Linia 4: Określa, czy algorytm ma używać wolnej czy szybkiej metody przestawiania próbek. Bit-
reversal jest używany do odpowiedniego ułożenia próbek przed wykonaniem FFT
(typBitReverse=1).

Linia 5: Określa, czy algorytm ma używać wolnej czy szybkiej pętli FFT. Szybkie pętle FFT
wykorzystują fakt, że DFT sygnałów o określonych właściwościach można obliczyć szybciej niż
tradycyjnymi metodami (typFFT=1).

Linia 6: Tworzy kopię wektora próbek sygnału. Wartości te zostaną zmienione w trakcie obliczeń
FFT, dlatego oryginalny sygnał jest kopiowany (xc = x). Ta kopia będzie używana do
przeprowadzenia transformacji Fouriera, zachowując oryginalne wartości sygnału.

Takim sposobem przygotujemy się do generacji sygnału i będziemy mieli możliwość wyboru
pomiędzy szybką, a wolną wersją algorytmu.
% PRZESTAWIENIE KOLEJNOŚCI PRÓBEK: wersja 1 wolna ---------------------------
------------------------
if (typBitReverse==1)
MSB=log2(N); % liczba bitów numerów próbek %
for n=0:N-1; % kolejne próbki %
ncopy=n; % stary numer próbki (kopia) %
nr=0; % nowy numer próbki (inicjalizacja) %
for m=1:MSB % po wszystkich bitach %
if (rem(n,2)==0) % czy jedynka na LSB %
n=n/2; % jeśli nie, przesuń w prawo %
else
nr=nr+2^(MSB-m); % dodaj 2^(MSB-m) %
n=(n-1)/2; % odejmij jedynkę, przesuń w prawo %
end
end
y(nr+1)=x(ncopy+1); % skopiuj we właściwe miejsce %
end
x = y; % podstaw wynik pod x %
end

Bit-Reversal, znany również jako "Bit-Reversal Permutation", jest kluczowym krokiem w

algorytmach szybkiej transformacji Fouriera (FFT). Jest to technika, która zmienia kolejność próbek
sygnału w taki sposób, że pozwala na efektywne przeprowadzenie transformacji Fouriera.

W pierwszym kroku algorytmu, sprawdzamy, ile bitów potrzebujemy, aby zapisywać

numery próbek sygnału. Nazywamy to najbardziej znaczącym bitem (MSB). Następnie, iterując
przez wszystkie próbki, dla każdej próbki obliczamy nowy numer, przemieszczając bity w odwrotnej
kolejności. Główna logika polega na dzieleniu numeru próbki przez 2 i dodawaniu odpowiednich
potęg dwójki, aby uzyskać nowy numer w odpowiedniej kolejności bitów. Ten proces jest
powtarzany dla każdej próbki, a ich nowe numery są przechowywane w osobnej tablicy. Po
zakończeniu tego procesu, przestawione próbki sygnału są gotowe do dalszych obliczeń FFT. Ta
technika ma kluczowe znaczenie dla efektywnego przeprowadzania transformacji Fouriera na
dyskretnych próbkach sygnału.
 Teraz możemy rozpocząć procedury obliczania FFT, czyli szybkiej transformacji Fouriera.
Wykorzystujemy podczas niej tak zwane „motyle”, by w jednym kroku łączyć dwa punkty.

if (typFFT==1)
for e = 1 : log2(N) % KOLEJNE ETAPY
SM = 2^(e-1); % szerokoĞü motylka
LB = N/(2^e); % liczba bloków
LMB = 2^(e-1); % liczba motylków w bloku
OMB = 2^e; % odlegáoĞü miĊdzy blokami
W = exp(-j*2*pi/2^e); % podstawa bazy Fouriera
for b = 1 : LB % KOLEJNE BLOKI
for m = 1 : LMB % KOLEJNE MOTYLKI
g = (b-1)*OMB + m; % indeks górnej próbki motylka
d = g + SM; % indeks dolnej próbki motylka
xgora = x(g); % skopiowanie górnej próbki
xdol = x(d)*W^(m-1); % korekta dolnej próbki
x(g) = xgora + xdol; % nowa górna próbka: górna plus dolna po
korekcie
x(d) = xgora - xdol; % nowa dolna próbka: górna minus dolna po
korekcie
end % koniec pętli motylków
end % koniec pętli bloków
end % koniec pętli etapów
end
1. Iteracja po Etapach FFT (for e = 1 : log2(N))

• Obliczenie Szerokości Motylka (SM = 2^(e-1)): Szerokość motylka w każdym etapie FFT
wynosi połowę szerokości motylka z poprzedniego etapu.
• Obliczenie Liczby Bloków (LB = N/(2^e)): Podział sygnału na odpowiednią liczbę bloków na
tym etapie FFT.
• Obliczenie Liczby Motylków w Bloku (LMB = 2^(e-1)): Liczba motylków (par próbek do
przekształcenia) w każdym bloku.
• Obliczenie Odległości Między Blokami (OMB = 2^e): Odległość między początkami kolejnych
bloków.
• Obliczenie Podstawy Bazy Fouriera (W = exp(-j*2*pi/2^e)): Wartość rotacji używanej do
obliczenia motylków na tym etapie FFT.

2. Iteracja po Blokach (for b = 1 : LB)

• Iteracja po Motylkach (for m = 1 : LMB)

o Obliczenie Górnego i Dolnego Indeksu Motylka (g i d): Indeks górnej próbki
motylka to (b-1)*OMB + m, a dolnej próbki to g + SM.
o Kopiowanie Górnej Próbki (xgora = x(g)): Zapisuje wartość górnej próbki
motylka.
o Obliczenie Korekty Dolnej Próbki (xdol = x(d)*W^(m-1)): Oblicza korektę
dolnej próbki motylka za pomocą rotacji bazowej Fouriera.
o Aktualizacja Górnej i Dolnej Próbki Motylka (x(g) i x(d)): Aktualizuje
wartości górnej i dolnej próbki motylka, sumując i różniąc odpowiednio
wartości z korektą.
 Metodę obliczania FFT, czyli szybkiej transformacji Fouriera można poprowadzić w zgoła
odmienny sposób, który będzie szybszy oraz bardziej wydajny.

if (typFFT==2)
for e = 1 : log2(N) % KOLEJNE ETAPY
L = 2^e; % dáugoĞü bloków DFT, przesuniĊcie bloków
M = 2^(e-1); % liczba motylków w bloku, szerokoĞü kaĪdego motylka
Wi = 1;
W = cos(2*pi/L)-j*sin(2*pi/L); % mnoĪnik bazy Fouriera 1
for m = 1 : M % KOLEJNE MOTYLKI
for g = m : L : N % W KOLEJNYCH BLOKACH
d = g+M; % g „górny”, d „dolny” indeks próbki motylka
T = x(d)*Wi; % „serce” FFT
x(d) = x(g)-T; % nowa dolna próbka: górna minus „serce”
x(g) = x(g)+T; % nowa górna próbka: górna plus „serce”
end % koniec pętli bloków
Wi=Wi*W; % kolejna wartoĞü bazy Fouriera l l WL W k
end % koniec pętli motylków
end % koniec pętli etapów
end
1. Iteracja po Etapach FFT (for e = 1 : log2(N))
• Obliczenie Długości Bloków DFT (L = 2^e): Długość bloków przekształcenia Fouriera
na tym etapie. Każdy blok jest przesunięciem innych bloków.
• Obliczenie Liczby Motylków w Bloku (M = 2^(e-1)): Każdy blok jest podzielony na M
motylków, które są przekształcane niezależnie.
• Inicjalizacja Wartości Mnożnika Bazy Fouriera (Wi = 1)
• Obliczenie Mnożnika Bazy Fouriera (W = cos(2*pi/L) - j*sin(2*pi/L)): Mnożnik bazy
Fouriera, który jest używany do obrotu próbek na każdym etapie FFT.
2. Iteracja po Motylkach (for m = 1 : M)
• Iteracja po Próbki w Blokach (for g = m : L : N)
o Obliczenie Dolnego Indeksu Motylka (d = g + M)
o Obliczenie "Serca" FFT (T = x(d)*Wi): Próbka, która zostanie przemnożona przez
wartość rotacji Fouriera.
o Aktualizacja Górnej i Dolnej Próbki Motylka:
▪ Aktualizacja Dolnej Próbki (x(d) = x(g) - T): Nowa dolna próbka to różnica
między górną próbką a wartością "serca" FFT.
▪ Aktualizacja Górnej Próbki (x(g) = x(g) + T): Nowa górna próbka to suma
starej górnej próbki i wartości "serca" FFT
o Aktualizacja Wartości Mnożnika Bazy Fouriera (Wi = Wi * W): Przesunięcie
mnożnika bazy Fouriera do następnej wartości dla kolejnego motylka.
3. Zakończenie Pętli Motylków
4. Zakończenie Pętli Bloków
5. Zakończenie Pętli Etapów

Próbki sygnału są podzielone na bloki, a następnie przekształcane w kolejnych etapach FFT,

zwiększając długość bloków i zmieniając wartość mnożnika bazy Fouriera na każdym etapie. Proces
ten prowadzi do pełnej transformacji sygnału wejściowego.