CHAPTER 6 Efficient Computation of the DFT:

Fast Fourier Transform Algorithms

DFT plays an important role in many applications of
digital signal processing, including linear filtering,
correlation analysis, and spectrum analysis.

Two different approaches are described :

One is a divide-and-conquer approach : a DFT of
size N is reduced to the computation of smaller DFTs
from which the larger DFT is computed.

The second approach is based on the formulation of

the DFT as a linear filtering operation on the data.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
6.1 Efficient Computation of the DFT: FFT Algorithms

The computational problem for the DFT is to

compute the sequence { X(k) } of N complex-valued
numbers given another sequence of data { x(n) } of the
length N.

Where WN = e-j2π/N (6.1.2)

The IDFT becomes

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1 Effcient Computation of the DFT: FFT Algorithms

The efficient computational algorithms for the

DFT applies as well to the efficient computation of
the IDFT.
For each value of k, direct computation of X(k)
involves N complex multiplication (4N real
multiplications). and (N – 1) complex additions
(4N – 2 real additions).
To compute all N values of the DFT requires N2
complex multiplications and N2 – N complex
additions.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
6.1 Effcient Computation of the DFT: FFT Algorithms

Direct computation of the DFT is basically

inefficient primarily because it does not exploit
the symmetry and periodicity properties of
the phase factor WN.
Symmetry property :

Periodicity property :

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.1 Direct computation of the DFT.
For a complex-and-valued sequence x(n) of N
points, the DFT may be expressed as.

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.1 Direct computation of the DFT.

The direct computation of (6.1.6) and (6.1.7)

requires:

1. 2N2 evaluations of trigonometric functions.

2. 4N2 real multiplications.
3. 4N(N – 1 ) real additions.
4. A number of indexing and addressing
operations.

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.2 Divide-and-conquer approach to computation
of the DFT.
This approach is based on the decomposition of an
N-point DFT into successively smaller DFTs.
Let us consider the computation of an N-point DFT,
where N can be factored as a product of two
integers.
N = LM (6.1.8)
The sequence x(n), 0 ≤ n ≤ N – 1, can be stored in
either in a two-dimensional array indexed by l and m,
Where 0 ≤ l ≤ L – 1 (row index) and 0 ≤ m ≤ M – 1
(column index) as illustrated in Fig 6.1. We select
mapping : n = Ml + m (6.1.9) n = l + mL (6.1.10)
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.2 Divide-and-conquer approach to computation
of the DFT.
Figure 6.1 Two dimensional data array for storing the
sequence x(n), 0 ≤ n ≤ N – 1.
n 0 1 N-1

x (0) x (1) x (2) x (N - 1)

m column index (a)

row index l
0 1 M–1
0 x (0, 0) x (0, 1)
1 x (1, 0) x (1, 1)
2 x (2, 0) x (2, 1)

L–1
(b)
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
6.1.2 Divide-and-conquer approach to computation
of the DFT.
A similar arrangement can be used to store
the computed DFT values.
Where 0 ≤ p ≤ L – 1 and 0 ≤ p ≤ M – 1
If we select the mapping
k = Mp + q (6.1.11)
The DFT stored on a row-wise basis.
The mapping
k = qL + p (6.1.12)
results in a column-wise storage of X(k).
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.2 Divide-and-conquer approach to computation
of the DFT.
Let us adopt a column-wise mapping for x(n) and the
row-wise mapping for the DFT, then

With these simplications,

The computation of DFTs of length M and length L

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.2 Divide-and-conquer approach to computation
of the DFT.
Let us subdivide the computation into three steps:
1. First, we compute the M-point DFTs

for each the rows l = 0, 1, … , L – 1

2. Second, we compute a new rectangular array
G(l,q) defined as

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.2 Divide-and-conquer approach to computation
of the DFT.
3. Finally, we compute L-point DFTs

for each column q = 0, 1, … , M – 1, of the array G (l, q)

Let us evaluate the computational complexity of (6.1.15)
The first step requires LM2 Complex multiplications
and LM(M – 1) Complex additions.
The second step requires LM complex multiplications.
Finally, the third step requires LM2 complex
multiplications and ML(L -1) complex additions
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
6.1.2 Divide-and-conquer approach to computation
of the DFT.
Therefore, the computational complexity is :
Complex multiplications :
N( M + L + 1)
Complex additions:
N( M + L – 2) (6.1.19)
Where N = ML
Thus, the number of multiplications has been
reduced from, N2 to N( M + L +1), and the
number of additions has been reduced from
N(N – 1) to N(M + L – 2 ).
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.2 Divide-and-conquer approach to computation
of the DFT.
When N is a highly composite number, N can be
factored into a product of prime numbers of the form.
N = r1 r2 … rv (6.1.20)
then the decomposition above can be repeated ( v – 1)
more times.
Algorithm 1. (Algorithm 2. self-study )
1. Store the signal column-wise.
2. Compute the M-point DFT of each row.
3. Multiply the resulting array by the phase factors
4. Compute the L-point DFT of each column.
5. Read the resulting array row-wise.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.
The approach is very efficient where N is highly
composite, that is, when N can be factored as
N = r 1 r 2 r 3 … rv .
Where { rj } are prime
In the case r1 = r2 = … = rv ≡ r, so that N = rv, the
DFTs are of size r. The number r is called the
radix of the FFT algorithm.
We described radix-2 algorithms: the
computations of the N = 2v point DFT by the
divide-and-conquer approach specified by
(6.1.16) through (6.1.18).
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.

We select M = N/2 and L = 2 , thus

f1(n) = x(2n)
f2(n) = x(2n + 1) (6.1.23)
where n = 0, 1, …,N/2 + 1

f1(n) and f2(n) are obtained by decimating x(n)

by a factor of 2, and hence
the resulting FFT algorithm is called a
decimation-in-time algorithm.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.
Now the N-point DFT can be expressed

But , can be expressed

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.

where F1(k) and F2(k) are the N/2-point DFTs of the

sequence f1(m) and f2(m), respectively.

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.
Since F1(k) and F2(k) are periodic (N/2), thus

Hence the computation of X(k) requires :

N2/2 + N/2 complex multiplications.
We may define
G1 (k) = F1 (k) k = 0, 1,… , N/2 – 1

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.

Thus DFT X(k) may be expressed as

X(k) = G1(k) + G2(k) k = 0, 1, …, N /2 – 1

This computation is illustrated in Fig. 6.4

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.
Figure 6.4 First step in the decimation-in-time algorithm.
x(N – 2 )
x(4)
x(2) N/2 – Point G1 (k )
x(0)
DFT F1(2 )
x(3 )
x(1 ) F1(0 )F1(1 )
F2 (1 )
F2 (0 ) 2– Point X(1)
X(0)
X(N-1 )
DFT
Phase
factors
G2 (k )

For N = 2v, this decimation can be performed v = log2 N

times.
Thus, the total number of complex multiplications is
reduced to ( N/2) log2 N.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.
Table 6.1 Comparison of Computational Complexity
for the Direct Computation of the DFT Versus the FFT Algorithm
Number of Complex Multiplications in Complex Multiplications Speed
Points, Direct Computation, in FFT Algorithm, Improvement
N N2 (N/2) log2 N Factor
                 4 16 4 4.0
                 8 64 12 5.3
             16 256 32 8.0
             32 1,024 80 12.8
             64 4,096 192 21.3
         128 16,384 448 36.6
         256 65,53 6 1,024 64,0
         512 262,144 2,304 113,8
         1,024 1,048,576 5,120 204,8

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.

Figure 6.5 Three stages in the computation of an

N = 8-point DFT.
x(0) 2 -point
x(4) DFT Combine
X(0)
2 – point X(1)
x(2) 2 -point DFT’s X(2)
x(6) DFT X(3)
Combine
4 – point X(4)
x(1) 2 -point DFT’s X(5)
x(5) DFT Combine X(6)
2 – point X(7)
x(3) 2 -point DFT’s
x(7) DFT

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.
Figure 6.6 Eight-point decimation-in-time FFT algorithm.

Stage 1 Stage 2 Stage 3

x (0) X (0)

x (4) X (1)
-1
x (2) X (1)
-1

x (6) X (3)
-1 -1
x (1) X (4)
-1
x (5) X (5)
-1 -1
x (3) X (6)
-1

x (7) X (7)
-1 -1
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.
Figure 6.7 Basic butterfly computation in the
decimation-in-time FFT algorithm.
a

b
-1

In general, for N = 2v , there are N/2 butterfly per

stage of the computation process and log2N stages.
We can store the result (A, B) in the same locations
as (a, b). We require a fixed amount to store the
results ( N complex numbers) of the computations
at each stage.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.
Since the same 2N storage locations are used
throughout the computation of the N-point DFT we
say that the computations are done in place.
The order of the input data sequence after it is
decimated (v – 1) times.
This shuffling of the input data sequence has a
well-defined order as can be ascertained from
observing Fig 6.8.
Thus, we say that the data x(n) after decimation is
stored in bit-revered order.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.
Figure 6.8 Shuffling of the data and bit reversal
Data Data
Memory address decimation 1 decimation 2
(decimal) (binary) Memory
0 000 x(0) x(0) x(0)
1 001 x(1) x(2) x(4)
2 010 x(2) x(4) x(2)
3 011 x(3) x(6) x(6)
4 100 x(4) x(1) x(1)
5 101 x(5) x(3) x(5)
6 110 x(6) x(5) x(3)
7 111 x(7) x(7) x(7)

Natural (a) Bit-reversed

order order
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.

(n2n1n0) → (n0n2n1) → (n0n1n2)

(000) → (000) → (000)

(001) → (100) → (100)

(010) → (001) → (010)

(011) → (101) → (110)
(100) → (010) → (001)

(101) → (110) → (101)

(110) → (011) → (011)

(111) → (111) → (111)

(b)

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.

It is possible to arrange the FFT algorithm

such that the input is left in natural order and
the resulting output DFT will occur in bit-
reversed order.

We can impose the restriction that both the

input data x(n) and the output DFT X(k) be in
natural order, and derive an FFT algorithm in
which the computations are not done in
place.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.
The decimation-in-frequency algorithm is
obtained by using the divide-and-conquer
approach with the choice of M = 2 and L = N / 2
We obtain

Since
then

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.
let us split X(k)

and

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.
If we define:

then

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.
Figure 6.9 First stage of the decimation-in-frequency FFT
algorithm.
x(0) X(0)

x(1) X(2)
4-point
DFT
x(2) X(4)

x(3) X(6)

x(4) X(1)
-1
x(5) X(3)
-1 4-point
DFT
x(6) X(5)
-1
x(7) X(7)
-1
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
  
6.1.3 Radix-2 FFT Algorithm.
Figure 6.10 Basic butterfly computation in the
decimation-in-frequency FFT
algorithm.
a A =a+b

b
-1

The entire process involves v = log2 N stages of

decimation.
Each stage involves N/2 butterflies of the type in Fig
6.10.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.3 Radix-2 FFT Algorithm.

The computation of the N-point DFT via the

decimation-in-frequency FFT algorithm,
requires (N /2) log2N complex
multiplications and N log2N complex
additions, just as in the decimation-in-time
algorithm.

From fig.6.11 that the input data x(n) occurs

in natural order, but the output DFT occurs
in bit-reversed order.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.4. Radix-4 FFT algorithms
Figure 6.11 N = 8-point decimation-in- frequency FFT algorithm.
x(0) X(0)

x(1) X(4)
-1

x(2) X(2)
-1

x(3) X(6)
-1 -1

x(4) X(1)
-1

x(5) X(5)
-1 -1

x(6) X(3)
-1 -1
x(7) X(7)
-1 -1 -1
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.4. Radix-4 FFT algorithms
When the number data point N in the DFT is power
of 4, we can employ a radix-4 FFT algorithm.
Selecting L = 4 and M = N/4,
we have
n = 4m + l; m, q = 0, 1, …, N/4;
k = ( N/4) p + q; l, p = 0, 1, 2, 3;
Thus, we split the N-point input sequence into four
subsequences :
x(4n), x(4n+1), x(4n+2), x(4n+3)
n = 0, 1, …, N/4 -1.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.4. Radix-4 FFT algorithms
We obtain

and x (l, m) = x (4m + l) (6.1.41)

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.4. Radix-4 FFT algorithms
from (6.1.39) we have a radix-4 decimation-in-
time butterfly.

Since each butterfly involves three

complex multiplications, and 12 complex
additions.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.4. Radix-4 FFT algorithms
Figure 6.12 Basic butterfly computation in a radix-4
FFT algorithm.

0
-­‐j
-­‐1 q
j
-­‐1 2q
1
-­‐1 3q

j
-­‐1
-­‐j

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.4. Radix-4 FFT algorithms
This decimation-in-time procedure can be
repeated recursively v times.
The resulting FFT algorithm consists of v stages,
where each stage contains N/4 butterflies.
The computations burden for the algorithm is
3vN/4 = (3N/8) log2N complex additions.

The number of multiplications is reduced by 25%,

but the number of additions has increased by
50% from N log2N to (3N/2)log2N.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.4. Radix-4 FFT algorithms
It is possible to reduce the number of a additions per
butterfly from 12 to 8 by product of two matrices as
follows:

Now, each matrix multiplication involves four additions

for a total of eight additions.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.4. Radix-4 FFT algorithms

Thus the total number of complex additions is

reduced to N log2N.

An illustration of a radix-4 decimation-in-time

FFT algorithm is shown in Fig 6.13 for N =16.
Figure 6.13 Sixteen-point radix-4 decimation-
in-time algorithm with input in normal order and
output in digit-reversed order.
The integer multipliers shown on the graph
represent the exponents on W16
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.4. Radix-4 FFT algorithms
x(0) Figure 6.13
x(1) 0 X(0)
0 X(4)
x(2) 0
X(8)
x(3) 0 X(12)
x(4)
0 0 X(1)
x(5)
0 1 X(5)
x(6) 2
0 X(9)
x(7) 0 X(13)
0
x(8) 0
0 X(2)
0
x(9) 0 2 X(6)
x(10) 4
0 X(10)
x(11) 6
X(14)
x(12) 0
0 X(3)
x(13) 0 3 X(7)
0 6
x(14) X(11)
0 9
x(15) X(15)
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.4. Radix-4 FFT algorithms
A radix-4 decimation-in-frequency FFT algorithm
can be obtained by selecting
L = N / 4, M = 4,
l,p = 0, 1, …, N / 4 – 1 ; m, q = 0, 1, 2, 3;
n = (N / 4) m + l ; and k = 4p + q
From (6.1.15), we express as

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.4. Radix-4 FFT algorithms
where

and

The computation in (6.1.46) and (6.1.47) define

the basic radix-4 butterfly for the decimation-in-
frequency algorithm.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.4. Radix-4 FFT algorithms
Figure 6.14 Sixteen-point radix-4 decimation-in-frequency algorithm
with
x(0)
input in normal order and output in digit-reversed order
X(0)
x(1) 0 0
0 X(4)
x(2) 0 0
X(8)
x(3) 0 0
X(12)
x(4) 0
0 X(1)
x(5) 0
1 0 X(5)
x(6) 0
2 X(9)
x(7) 0
3 X(13)
x(8) 0
X(2)
2 0
x(9)
0 X(6)
4
x(10) 0
X(10)
6 0
x(11)
0 X(14)
x(12) 3 X(3)
0
x(13) 6 0 X(7)
9 0
x(14) X(11)
0
x(15) X(15)
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.4. Radix-4 FFT algorithms
It has exactly the same computational complexity
as the decimation-in-time radix-4 FFT algorithm.

In this algorithm, the input sequence is in normal

order while the output DFT is shuffled.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
6.1.4. Radix-4 FFT algorithms

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.5 Split-Radix FFT Algorithm

The split-radix FFT (SRFFT) algorithms use

both a radix-2 and radix-4 decomposition in the
same FFT algorithm.

The even-numbered samples of the N-point DFT

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.5 Split-Radix FFT Algorithm.
The odd-numbered samples of the N-point DFT :

The N-point DFT is decomposed into one N/2-point

DFT without additional twiddle factors and two N/4-
point DFTs with twiddle factors
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.5 Split-Radix FFT Algorithm

Figure 6.16 Butterfly for SRFFT algorithm

x (n)

Use for X(2k)

x (n+ N/4)

Use for
x (n+ N/2)
-1 -j X(4k + 1)

Use for
x (n+ 3N/2)
-1 j X(4k + 3)

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.1.5 Split-Radix FFT Algorithm.
Table 6.2 Number of Nontrivial Real multiplication
and addition to compute an N-point complex DFT.
Real multiplications Real additions
Radix Radix Radix Split Radix Radix Radix Split
N 2 4 8 Radix 2 4 8 Radix

   16 24 20 20 152 148 148

   32 88 68 408 388
   64 264 280 204 196 1,032 976 972 964
128 712 516 2,504 2,308
     256 1,800 1,392 1,284 5,896 5,488 5,380
         512 4,360 3,204 3,076 13,566 12,420 12,292
1,024 10,248 7,856 7,172 30,728 28,336 27,652
Source: Extracted from Duhamel (1986)

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
6.1.6 Implementation of FFT Algorithms.

The butterfly computations is repeated many

times ((Nlog2 N) /2 time) for the computation
of an N-point DFT.
The phase factors are computed once and
stored in the table.
The number of memory locations required is
2N since the numbers are complex.
We can instead double the memory to 4N,
thus simplifying the indexing and control
operations in the FFT algorithms.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
6.1.6 Implementation of FFT Algorithms.
We can convert to an FFT algorithm for
computing the IDFT by changing the sign on
all the phase factors and dividing the final
output of the algorithm by N.

For DSP processors, radix-2 or radix-4

decimation-in-frequency FFT algorithms, are
preferable in terms of speed and accuracy.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
  6.2  Applica9ons  of  FFT  Algorithms

The FFT algorithms find application in a

variety of areas, including linear filtering,
correlation, and spectrum analysis.

We only consider the use of the FFT

algorithms in linear filtering and in the
computation of the crosscorrelation of two
sequences.

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.2.1 Efficient computation of the DFT of two real
sequences.
Suppose that: x1(n) and x2(n) are two real-valued
sequences of length N, and let x(n) be a complex-
valued sequence defined as
x(n) = x1(n) + jx2(n) 0≤n≤N–1 (6.2.1)

The DFT operations is linear and hence:

X(k) = X1(k) + jX2(k) (6.2.2)

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.2.1 Efficient computation of the DFT of two real
sequences.
Therefore,

Thus, by performing a single DFT on the complex-

valued sequence x(n), we have obtained the DFT of the
two real sequences with only a small amount of
additional computation.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
6.2.2 Efficient computation of the DFT of a
2N-Point Real Sequences
Suppose that g(n) is a real-valued sequence of 2N
point, First we define
x1(n) = g(2n) (6.2.9)
x2(n) = g(2n + 1)
Let x(n) be the N-point complex-valued
sequence
x(n) = x1(n) + jx2(n) (6.2.10)
We have

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.2.2 Efficient computation of the DFT of a
2N- point two real sequences

Finally

Consequently

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.2.3 Use of the FFT Algorithm in Linear
Filtering and Correlation
Let h(n), 0 ≤ n ≤ M – 1, be the unit sample response of
the FIR filter.
x(n) denotes the input data sequence
The block size of the FFT algorithm is N
where N=L+M–1
L – the number of new data samples being processed
by the filter.
M – any giver value so that N is a power of 2.
The N-point DFT of h(n), which is padded by L – 1 zero,
is denoted as H(k), and use the
decimation-in-frequency FFT algorithm to compute H(k)
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.2.3 Use of the FFT algorithm in linear
filtering and correlation.
In the overlap-save method, the first M – 1 data
point of each data block are the last M – 1 data
points of the previous data block.
The N-point DFT of each data block is performed
by the FFT algorithm.
Since this is exactly the order of H(k), we can
multiply the DFT of the data, say Xm(k), with H(k)
and thus the result
Ym(k) = H(k) Xm(k)
is also in bit-reversed order.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.2.3 Use of the FFT algorithm in linear
filtering and correlation

The inverse DFT can be computed by use an

FFT algorithm that takes the input in bit-reversed
and produces an output in normal order.

The computational burden is Nlog2N complex

multiplications and 2Nlog2N additions.

We have (N log22N)/L complex multiplications

per output data point and approximately
(2Nlog22N) / L additions per output data point.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.2.3 Use of the FFT algorithm in linear
filtering and correlation

It is interesting to compare the efficiency of

the FFT algorithm with the direct form
realization of the FIR filter.
suppose that M = 128 = 27 and N = 2v
The number of complex multiplications per
output for an FFT size of N = 2v is

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.2.3 Use of the FFT algorithm in linear
filtering and correlation
Table 6.3 Computational complexity
Size of FFT c (v) number of complex
v = log2N multiplication per output point

                     9 13.3

                 10 12.6

                 11 12.8

                 12 13.4

                 14 15.1

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
6.3 A Linear Filtering Approach To Computation of
The DFT.

The FFT algorithm takes N points of input

data and produces an output sequence of
N points corresponding to the DFT of the
input data.

The radix-2 FFT algorithm performs the

computation of the DFT in (N / 2) log2N
multiplications and N log2N additions for
N-point sequence.
CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department
 6.3 A linear filtering approach to computation of
the DFT.
When the desired number of values of the DFT is
less than log2N, a direct computation of the
desired values is more efficient.
There are two algorithms:
The Goertzel Algorithm is particularly attractive
where the DFT is to be computed at a relatively
small number M of values, where M ≤ log2 N.
The clip-z transform algorithm.

Problems: 6.8, 6.11, 6.12, 6.13, 6.20, 6.27, 6.28

CuuDuongThanCong.com https://fb.com/tailieudientucntt
©2013, CE Department