Discrete Fourier Transform and Fast Fourier

Transform Algorithms
Complete Study Notes for AKTU Engineering Semester 5th
Digital Signal Processing - Comprehensive Coverage

Table of Contents
1. Introduction to Discrete Fourier Transform (DFT)
2. Definitions and Mathematical Foundations
3. Relation between DTFT and DFT
4. Computational Problems in DFT
5. Properties of the DFT
6. Circular Convolution
7. Linear Convolution
8. Fast Fourier Transform Algorithms
9. Radix-2 Decimation in Time (DIT) Algorithm
10. Radix-2 Decimation in Frequency (DIF) Algorithm
11. Computational Efficiency Analysis
12. Solved Numerical Problems
13. Previous Year Questions (AKTU)
14. Practice Problems

1. Introduction to Discrete Fourier Transform (DFT)

1.1 Overview and Motivation

The Discrete Fourier Transform (DFT) is one of the most important tools in digital signal
processing, providing a bridge between the time domain and frequency domain representations
of discrete-time signals. Unlike its continuous counterpart, the Fourier Transform, the DFT deals
with finite-length discrete sequences, making it particularly suitable for digital computation and
analysis.
Historical Context:
The concept of frequency domain analysis dates back to Jean-Baptiste Joseph Fourier (1768-
1830), who introduced the idea that any periodic function can be represented as a sum of
sinusoidal functions. The discrete version was later developed to handle sampled signals in
digital systems.
Practical Significance:
Signal Analysis: Understanding frequency content of signals
System Design: Filter design and analysis
Image Processing: 2D DFT for image compression and enhancement
Communications: Modulation and demodulation schemes
Audio Processing: Music and speech analysis

1.2 Fundamental Concepts

Discrete-Time Signals:
A discrete-time signal x[n] is a sequence of values defined only at integer values of the
independent variable n. The signal can be:
Finite length: x[n] defined for n = 0, 1, 2, ..., N-1
Infinite length: x[n] defined for all integer values of n
Frequency Domain Representation:
The frequency domain provides an alternative representation of signals, showing how much of
each frequency component is present in the signal. This is crucial for:
Filter design
Spectral analysis
Signal compression
Noise removal

2. Definitions and Mathematical Foundations

2.1 Discrete Fourier Transform (DFT) Definition

For a finite-length sequence x[n] of length N, where n = 0, 1, 2, ..., N-1, the N-point Discrete
Fourier Transform (DFT) is defined as:
Forward DFT:

X[k] = Σ(n=0 to N-1) x[n] · W_N^(nk)

where:
X[k] is the k-th DFT coefficient (k = 0, 1, 2, ..., N-1)
x[n] is the input sequence
W_N = e^(-j2π/N) is the N-th root of unity
 W_N^(nk) = e^(-j2πnk/N) is the twiddle factor
Inverse DFT (IDFT):

x[n] = (1/N) · Σ(k=0 to N-1) X[k] · W_N^(-nk)

2.2 Twiddle Factors

The twiddle factor W_N^(nk) is fundamental to DFT computation:

W_N^(nk) = e^(-j2πnk/N) = cos(2πnk/N) - j·sin(2πnk/N)

Important Properties of Twiddle Factors:

1. Periodicity: W_N^(nk) = W_N^((n+N)k) = W_N^(n(k+N))
2. Symmetry: W_N^(nk) = W_N^(-n(-k))
3. Reciprocal: W_N^(-nk) = 1/W_N^(nk) = (W_N^(nk))*

2.3 Matrix Representation

The DFT can be represented in matrix form as:

[X[0]] [W_N^0 W_N^0 W_N^0 ... W_N^0 ] [x[0]]

[X[1]] [W_N^0 W_N^1 W_N^2 ... W_N^(N-1) ] [x[1]]
[X[2]] = [W_N^0 W_N^2 W_N^4 ... W_N^2(N-1)] [x[2]]
[...] [... ... ... ... ... ] [...]
[X[N-1]] [W_N^0 W_N^(N-1) W_N^2(N-1) ... W_N^(N-1)^2] [x[N-1]]

This can be written compactly as: X = W_N · x

where W_N is the N×N DFT matrix.

3. Relation between DTFT and DFT

3.1 Discrete-Time Fourier Transform (DTFT)

The DTFT of an infinite-length sequence x[n] is defined as:

X(e^jω) = Σ(n=-∞ to ∞) x[n] · e^(-jωn)

where ω is the continuous frequency variable.

3.2 Relationship between DTFT and DFT
The DFT can be viewed as samples of the DTFT at equally spaced frequencies:

X[k] = X(e^jω)|_{ω=2πk/N}

Key Differences:

Aspect DTFT DFT

Input Signal Infinite length Finite length (N samples)

Frequency Domain Continuous (ω) Discrete (k = 0,1,...,N-1)

Computation Analytical Numerical

Periodicity 2π in ω N in k

3.3 Sampling in Frequency Domain

The DFT samples the DTFT at N equally spaced points:

ω_k = 2πk/N, k = 0, 1, 2, ..., N-1

This sampling in frequency domain has important implications:

Frequency Resolution: Δω = 2π/N
Aliasing: If the original sequence is longer than N, aliasing occurs in time domain

3.4 Zero-Padding Effect

Zero-padding a sequence (adding zeros) before computing DFT:
Increases the number of frequency samples
Provides better interpolation of the DTFT
Does not increase frequency resolution
Useful for FFT computation when N is not a power of 2
AKTU Previous Year Question (2019):
Q: Explain the relationship between DFT and DTFT. What happens when we zero-pad a
sequence before computing its DFT? (7 marks)
Answer Approach:
1. Define both DTFT and DFT
2. Show that DFT is sampled version of DTFT
3. Explain frequency sampling concept
4. Discuss zero-padding effects with example
4. Computational Problems in DFT

4.1 Direct Computation Complexity

The direct computation of DFT using the definition requires:
Multiplications: N² complex multiplications
Additions: N(N-1) complex additions
Total Operations: O(N²) complexity
For large values of N, this becomes computationally intensive:
N = 1024: ~1 million multiplications
N = 4096: ~16 million multiplications

4.2 Memory Requirements

Storage Requirements:
Input sequence: N complex numbers
Output sequence: N complex numbers
Twiddle factors: N complex numbers (can be precomputed)
Total: 3N complex numbers

4.3 Numerical Issues

Finite Word Length Effects:
1. Quantization Errors: Due to finite precision arithmetic
2. Roundoff Errors: Accumulate during computation
3. Overflow/Underflow: Possible with large dynamic range
Solutions:
Use floating-point arithmetic
Implement proper scaling
Use numerically stable algorithms

4.4 Real-Time Processing Constraints

For real-time applications, DFT computation must be completed within the sampling period:
Sampling Rate: f_s samples/second
Available Time: 1/f_s seconds per sample
Block Processing: Process N samples at a time
5. Properties of the DFT

5.1 Linearity
Property:

DFT{a·x₁[n] + b·x₂[n]} = a·X₁[k] + b·X₂[k]

Proof:
Let y[n] = a·x₁[n] + b·x₂[n], then:

Y[k] = Σ(n=0 to N-1) [a·x₁[n] + b·x₂[n]] · W_N^(nk)

= a·Σ(n=0 to N-1) x₁[n]·W_N^(nk) + b·Σ(n=0 to N-1) x₂[n]·W_N^(nk)
= a·X₁[k] + b·X₂[k]

5.2 Time Shifting (Circular Shift)

Property:

DFT{x[(n-m) mod N]} = W_N^(mk) · X[k]

Significance: A circular shift in time domain corresponds to multiplication by a linear phase

factor in frequency domain.

5.3 Frequency Shifting

Property:

DFT{W_N^(-mn) · x[n]} = X[(k-m) mod N]

Significance: Multiplication by a complex exponential in time domain corresponds to a circular

shift in frequency domain.

5.4 Time Reversal

Property:

DFT{x[(-n) mod N]} = X[(-k) mod N]

5.5 Conjugate Symmetry

Property:
For real-valued x[n]:
 X[k] = X*[(N-k) mod N]

Implication: Only N/2 + 1 unique frequency components for real signals.

5.6 Parseval's Theorem

Property:

Σ(n=0 to N-1) |x[n]|² = (1/N) · Σ(k=0 to N-1) |X[k]|²

Significance: Energy is conserved between time and frequency domains.

5.7 Convolution Property

Circular Convolution:

DFT{x[n] ⊛ h[n]} = X[k] · H[k]

where ⊛ denotes circular convolution.

AKTU Previous Year Question (2020):
Q: State and prove any four properties of DFT. (10 marks)
Solution Approach:
1. Choose four properties (Linearity, Time Shifting, Parseval's Theorem, Convolution)
2. State each property clearly
3. Provide mathematical proof
4. Give practical significance

6. Circular Convolution

6.1 Definition
Circular convolution of two N-point sequences x[n] and h[n] is defined as:

y[n] = x[n] ⊛ h[n] = Σ(m=0 to N-1) x[m] · h[(n-m) mod N]

where n = 0, 1, 2, ..., N-1.

6.2 Circular Convolution vs Linear Convolution
Aspect Circular Convolution Linear Convolution

Sequence Length Fixed (N points) Variable (N+M-1 points)

Index Wrapping Yes (mod N) No

DFT Relationship Direct Requires zero-padding

Time-Aliasing Present Absent

6.3 Graphical Method for Circular Convolution

Steps:
1. Plot x[m] and h[m] for m = 0, 1, ..., N-1
2. Time-reverse h[m] to get h[-m]
3. Shift h[-m] by n positions to get h[(n-m) mod N]
4. Multiply x[m] and h[(n-m) mod N] point by point
5. Sum all products to get y[n]
6. Repeat for all values of n

6.4 Matrix Method

Circular convolution can be computed using a circulant matrix:

[y[0]] [h[0] h[N-1] h[N-2] ... h[1] ] [x[0]]

[y[1]] [h[1] h[0] h[N-1] ... h[2] ] [x[1]]
[y[2]] = [h[2] h[1] h[0] ... h[3] ] [x[2]]
[...] [... ... ... ... ... ] [...]
[y[N-1]] [h[N-1] h[N-2] h[N-3] ... h[0] ] [x[N-1]]

6.5 DFT Method for Circular Convolution

Algorithm:
1. Compute X[k] = DFT{x[n]}
2. Compute H[k] = DFT{h[n]}
3. Multiply: Y[k] = X[k] · H[k]
4. Compute y[n] = IDFT{Y[k]}
Numerical Example:
Let x[n] = {1, 2, 3, 4} and h[n] = {1, 1, 0, 0} for n = 0, 1, 2, 3.
Step 1: Compute DFT of x[n]
 X[0] = 1 + 2 + 3 + 4 = 10
X[1] = 1 + 2(-j) + 3(-1) + 4(j) = 1 - 2j - 3 + 4j = -2 + 2j
X[2] = 1 + 2(-1) + 3(1) + 4(-1) = 1 - 2 + 3 - 4 = -2
X[3] = 1 + 2(j) + 3(-1) + 4(-j) = 1 + 2j - 3 - 4j = -2 - 2j

Step 2: Compute DFT of h[n]

H[0] = 1 + 1 + 0 + 0 = 2
H[1] = 1 + 1(-j) + 0 + 0 = 1 - j
H[2] = 1 + 1(-1) + 0 + 0 = 0
H[3] = 1 + 1(j) + 0 + 0 = 1 + j

Step 3: Multiply Y[k] = X[k] · H[k]

Y[0] = 10 × 2 = 20
Y[1] = (-2 + 2j) × (1 - j) = -2 + 2j + 2j + 2 = 4j
Y[2] = (-2) × 0 = 0
Y[3] = (-2 - 2j) × (1 + j) = -2 - 2j - 2j + 2 = -4j

Step 4: Compute IDFT

y[0] = (1/4)[20 + 4j + 0 - 4j] = 5

y[1] = (1/4)[20 + 4j(-j) + 0 + (-4j)(j)] = (1/4)[20 + 4 + 4] = 7
y[2] = (1/4)[20 + 4j(-1) + 0 + (-4j)(-1)] = (1/4)[20 - 4j + 4j] = 5
y[3] = (1/4)[20 + 4j(j) + 0 + (-4j)(-j)] = (1/4)[20 - 4 - 4] = 3

Therefore, y[n] = {5, 7, 5, 3}.

7. Linear Convolution

7.1 Definition
Linear convolution of two sequences x[n] (length N) and h[n] (length M) is defined as:

y[n] = x[n] * h[n] = Σ(m=-∞ to ∞) x[m] · h[n-m]

For finite sequences, the result has length N + M - 1.

7.2 Linear Convolution using DFT

To compute linear convolution using DFT:
1. Zero-pad both sequences to length L ≥ N + M - 1
2. Compute DFTs: X[k] and H[k]
3. Multiply: Y[k] = X[k] · H[k]
 4. Compute IDFT: y[n] = IDFT{Y[k]}

7.3 Overlap-Add Method

For long sequences, the overlap-add method processes data in blocks:
Algorithm:
1. Divide long sequence x[n] into blocks of length L
2. Zero-pad each block to length L + M - 1
3. Compute linear convolution of each block with h[n]
4. Add overlapping portions of consecutive output blocks

7.4 Overlap-Save Method

Alternative method for block processing:
Algorithm:
1. Divide x[n] into overlapping blocks of length L + M - 1
2. Compute circular convolution using DFT
3. Discard first M - 1 samples of each output block
4. Concatenate remaining samples

7.5 Comparison: Linear vs Circular Convolution

Numerical Example:
Let x[n] = {1, 2, 3, 4} and h[n] = {1, 1, 0, 0}.
Linear Convolution:

y[0] = 1×1 = 1
y[1] = 1×1 + 2×1 = 3
y[2] = 2×1 + 3×1 = 5
y[3] = 3×1 + 4×1 = 7
y[4] = 4×1 = 4
y[5] = 0
y[6] = 0

Result: y[n] = {1, 3, 5, 7, 4, 0, 0} (length 7)

Circular Convolution (from previous example):
Result: y[n] = {5, 7, 5, 3} (length 4)
Observation: Circular convolution can be viewed as linear convolution with time-domain aliasing.
8. Fast Fourier Transform Algorithms

8.1 Introduction and Motivation

The Fast Fourier Transform (FFT) is not a different transform but rather an efficient algorithm to
compute the DFT. The key insight is to exploit the symmetry and periodicity of twiddle factors to
reduce computational complexity.
Computational Improvement:
Direct DFT: O(N²) multiplications
FFT: O(N log₂ N) multiplications
Efficiency Gain: For N = 1024, FFT is ~100 times faster

8.2 Basic Principle

The FFT algorithm is based on the divide-and-conquer approach:
1. Divide the N-point DFT into smaller DFTs
2. Conquer by computing smaller DFTs recursively
3. Combine results using twiddle factor multiplications

8.3 Cooley-Tukey Algorithm

The most common FFT algorithm, developed by Cooley and Tukey in 1965:
Requirement: N must be a power of 2 (N = 2ᵐ)
Radix: Refers to the factor by which sequence length is reduced at each stage
Radix-2: Most common, divides by 2 at each stage

8.4 Butterfly Operation

The basic building block of FFT is the butterfly operation:

A' = A + W × B
B' = A - W × B

where W is a twiddle factor.

Butterfly Diagram:

A ---->[+]----> A'
X
B --W->[−]----> B'
9. Radix-2 Decimation in Time (DIT) Algorithm

9.1 Algorithm Development

The DIT algorithm separates the input sequence x[n] into even and odd indexed subsequences.
For N-point DFT:

X[k] = Σ(n=0 to N-1) x[n] · W_N^(nk)

Separate into even and odd terms:

X[k] = Σ(n even) x[n] · W_N^(nk) + Σ(n odd) x[n] · W_N^(nk)

Let n = 2r for even terms and n = 2r + 1 for odd terms:

X[k] = Σ(r=0 to N/2-1) x[2r] · W_N^(2rk) + Σ(r=0 to N/2-1) x[2r+1] · W_N^((2r+1)k)

Simplify using W_N^(2rk) = W_{N/2}^(rk):

X[k] = Σ(r=0 to N/2-1) x[2r] · W_{N/2}^(rk) + W_N^k · Σ(r=0 to N/2-1) x[2r+1] · W_{N/2}^(

Define:
G[k] = DFT of even-indexed samples = Σ(r=0 to N/2-1) x[2r] · W_{N/2}^(rk)
H[k] = DFT of odd-indexed samples = Σ(r=0 to N/2-1) x[2r+1] · W_{N/2}^(rk)
Therefore:

X[k] = G[k] + W_N^k · H[k] for k = 0, 1, ..., N/2-1

X[k+N/2] = G[k] - W_N^k · H[k] for k = 0, 1, ..., N/2-1

9.2 Complete DIT Algorithm

8-Point DIT FFT Example:
Stage 1: Divide into even and odd
Even: x[0], x[2], x[4], x[6]
Odd: x[1], x[3], x[5], x[7]
Stage 2: Further divide
x[0], x[4] | x[2], x[6]
x[1], x[5] | x[3], x[7]
Stage 3: Individual points
 x[0] | x[4] | x[2] | x[6] | x[1] | x[5] | x[3] | x[7]
Input Order (Bit-Reversed):

Original: 0 1 2 3 4 5 6 7
Binary: 000 001 010 011 100 101 110 111
Reversed: 000 100 010 110 001 101 011 111
Decimal: 0 4 2 6 1 5 3 7

9.3 DIT Butterfly Computations

Stage 1 (3 stages total for 8-point FFT):

X₁[0] = x[0] + x[4] X₁[1] = x[0] - x[4]

X₁[2] = x[2] + x[6] X₁[3] = x[2] - x[6]
X₁[4] = x[1] + x[5] X₁[5] = x[1] - x[5]
X₁[6] = x[3] + x[7] X₁[7] = x[3] - x[7]

Stage 2:

X₂[0] = X₁[0] + X₁[2] X₂[1] = X₁[0] - X₁[2]

X₂[2] = X₁[1] + W₄¹ × X₁[3] X₂[3] = X₁[1] - W₄¹ × X₁[3]
X₂[4] = X₁[4] + X₁[6] X₂[5] = X₁[4] - X₁[6]
X₂[6] = X₁[5] + W₄¹ × X₁[7] X₂[7] = X₁[5] - W₄¹ × X₁[7]

Stage 3:

X[0] = X₂[0] + X₂[4] X[1] = X₂[0] - X₂[4]

X[2] = X₂[1] + W₈² × X₂[5] X[3] = X₂[1] - W₈² × X₂[5]
X[4] = X₂[2] + W₈¹ × X₂[6] X[5] = X₂[2] - W₈¹ × X₂[6]
X[6] = X₂[3] + W₈³ × X₂[7] X[7] = X₂[3] - W₈³ × X₂[7]

9.4 DIT Algorithm Properties

Advantages:
1. In-place computation: Can reuse input array
2. Regular structure: Easy to program
3. Bit-reversed input: Natural for some applications
Disadvantages:
1. Bit-reversal required: Input must be reordered
2. Memory access pattern: May not be cache-friendly
10. Radix-2 Decimation in Frequency (DIF) Algorithm

10.1 Algorithm Development

The DIF algorithm divides the output sequence X[k] into even and odd indexed subsequences.
Start with N-point DFT:

X[k] = Σ(n=0 to N-1) x[n] · W_N^(nk)

Split the summation:

X[k] = Σ(n=0 to N/2-1) x[n] · W_N^(nk) + Σ(n=N/2 to N-1) x[n] · W_N^(nk)

Substitute n = r + N/2 in second sum:

X[k] = Σ(n=0 to N/2-1) x[n] · W_N^(nk) + Σ(r=0 to N/2-1) x[r + N/2] · W_N^((r+N/2)k)

Use W_N^(N/2) = (-1):

X[k] = Σ(r=0 to N/2-1) [x[r] + (-1)^k · x[r + N/2]] · W_N^(rk)

10.2 Even and Odd Frequency Components

For even k (k = 2m):

X[2m] = Σ(r=0 to N/2-1) [x[r] + x[r + N/2]] · W_N^(2rm)

= Σ(r=0 to N/2-1) [x[r] + x[r + N/2]] · W_{N/2}^(rm)

For odd k (k = 2m + 1):

X[2m + 1] = Σ(r=0 to N/2-1) [x[r] - x[r + N/2]] · W_N^r · W_{N/2}^(rm)

10.3 DIF Butterfly Operation

Define:
a[r] = x[r] + x[r + N/2]
b[r] = (x[r] - x[r + N/2]) · W_N^r
Then:

X[2m] = (N/2)-point DFT of a[r]

X[2m + 1] = (N/2)-point DFT of b[r]
10.4 Complete DIF Algorithm
8-Point DIF FFT Example:
Stage 1: Combine first and second halves

a[0] = x[0] + x[4] b[0] = (x[0] - x[4]) · W₈⁰

a[1] = x[1] + x[5] b[1] = (x[1] - x[5]) · W₈¹
a[2] = x[2] + x[6] b[2] = (x[2] - x[6]) · W₈²
a[3] = x[3] + x[7] b[3] = (x[3] - x[7]) · W₈³

Stage 2: Further decomposition

a₁[0] = a[0] + a[2] b₁[0] = (a[0] - a[2]) · W₄⁰

a₁[1] = a[1] + a[3] b₁[1] = (a[1] - a[3]) · W₄¹
a₂[0] = b[0] + b[2] b₂[0] = (b[0] - b[2]) · W₄⁰
a₂[1] = b[1] + b[3] b₂[1] = (b[1] - b[3]) · W₄¹

Stage 3: Final butterflies

X[0] = a₁[0] + a₁[1] X[4] = a₁[0] - a₁[1]

X[2] = b₁[0] + b₁[1] X[6] = b₁[0] - b₁[1]
X[1] = a₂[0] + a₂[1] X[5] = a₂[0] - a₂[1]
X[3] = b₂[0] + b₂[1] X[7] = b₂[0] - b₂[1]

10.5 DIF Algorithm Properties

Advantages:
1. Natural output order: X[k] in correct sequence
2. In-place computation: Possible with proper indexing
3. Regular structure: Suitable for hardware implementation
Disadvantages:
1. Bit-reversed output (when not reordered)
2. Complex indexing for in-place computation

11. Computational Efficiency Analysis

11.1 Operation Count Comparison

Direct DFT:
Complex Multiplications: N²
Complex Additions: N(N-1) ≈ N²
 Total Operations: O(N²)
Radix-2 FFT:
Stages: log₂ N
Butterflies per stage: N/2
Operations per butterfly: 1 multiplication + 2 additions
Total Multiplications: (N/2) × log₂ N
Total Additions: N × log₂ N
Total Operations: O(N log₂ N)

11.2 Efficiency Gain

Multiplication Count:

N Direct DFT FFT Improvement Factor

8 64 12 5.33

64 4,096 192 21.33

1024 1,048,576 5,120 204.8

4096 16,777,216 24,576 682.67

11.3 Memory Requirements

Direct DFT:
Input storage: N complex numbers
Output storage: N complex numbers
Twiddle factors: N complex numbers
Total: 3N complex locations
FFT (in-place):
Data storage: N complex numbers
Twiddle factors: N/2 complex numbers
Total: 1.5N complex locations

11.4 Real-Time Performance

For real-time processing:
Sampling rate: f_s Hz
Block size: N samples
Available time: N/f_s seconds
FFT time: Proportional to N log₂ N
Example: For f_s = 44.1 kHz, N = 1024:
Available time: 1024/(44.1×10³) ≈ 23.2 ms
FFT requires much less time, leaving room for other processing

12. Solved Numerical Problems

Problem 1: 4-Point DFT Computation

Problem: Compute the 4-point DFT of x[n] = {1, 2, 3, 4}.
Solution:
Method 1: Direct Computation
W₄ = e^(-j2π/4) = e^(-jπ/2) = -j
Twiddle factors:
W₄⁰ = 1
W₄¹ = -j
W₄² = -1
W₄ ³ = j
X[0]:

X[0] = x[0]·W₄⁰ + x[1]·W₄⁰ + x[2]·W₄⁰ + x[3]·W₄⁰

= 1·1 + 2·1 + 3·1 + 4·1 = 10

X[1]:

X[1] = x[0]·W₄⁰ + x[1]·W₄¹ + x[2]·W₄² + x[3]·W₄³

= 1·1 + 2·(-j) + 3·(-1) + 4·j
= 1 - 2j - 3 + 4j = -2 + 2j

X[2]:

X[2] = x[0]·W₄⁰ + x[1]·W₄² + x[2]·W₄⁴ + x[3]·W₄⁶

= 1·1 + 2·(-1) + 3·1 + 4·(-1)
= 1 - 2 + 3 - 4 = -2

X[3]:

X[3] = x[0]·W₄⁰ + x[1]·W₄³ + x[2]·W₄⁶ + x[3]·W₄⁹

= 1·1 + 2·j + 3·(-1) + 4·(-j)
= 1 + 2j - 3 - 4j = -2 - 2j
Result: X[k] = {10, -2+2j, -2, -2-2j}
Verification using IDFT:

x[0] = (1/4)[10 + (-2+2j) + (-2) + (-2-2j)] = (1/4)×4 = 1 ✓

x[1] = (1/4)[10 + (-2+2j)(-j) + (-2)(-1) + (-2-2j)(j)]
= (1/4)[10 + (2+2j) + 2 + (-2j+2)] = (1/4)×8 = 2 ✓

Problem 2: Circular Convolution

Problem: Find the circular convolution of x[n] = {1, 2, 3, 4} and h[n] = {1, 1, 1, 1}.
Solution:
Method 1: Time Domain

y[0] = x[0]h[0] + x[1]h[3] + x[2]h[2] + x[3]h[1]

= 1×1 + 2×1 + 3×1 + 4×1 = 10

y[1] = x[0]h[1] + x[1]h[0] + x[2]h[3] + x[3]h[2]

= 1×1 + 2×1 + 3×1 + 4×1 = 10

y[2] = x[0]h[2] + x[1]h[1] + x[2]h[0] + x[3]h[3]

= 1×1 + 2×1 + 3×1 + 4×1 = 10

y[3] = x[0]h[3] + x[1]h[2] + x[2]h[1] + x[3]h[0]

= 1×1 + 2×1 + 3×1 + 4×1 = 10

Result: y[n] = {10, 10, 10, 10}

Method 2: Frequency Domain
From Problem 1: X[k] = {10, -2+2j, -2, -2-2j}
For h[n] = {1, 1, 1, 1}:

H[0] = 1 + 1 + 1 + 1 = 4
H[1] = 1 + 1(-j) + 1(-1) + 1(j) = 1 - j - 1 + j = 0
H[2] = 1 + 1(-1) + 1(1) + 1(-1) = 1 - 1 + 1 - 1 = 0
H[3] = 1 + 1(j) + 1(-1) + 1(-j) = 1 + j - 1 - j = 0

Y[k] = X[k] × H[k] = {10×4, (-2+2j)×0, (-2)×0, (-2-2j)×0} = {40, 0, 0, 0}

IDFT: y[n] = (1/4){40, 40, 40, 40} = {10, 10, 10, 10} ✓
Problem 3: 8-Point DIT FFT
Problem: Develop the signal flow graph for 8-point DIT FFT.
Solution:
Input Sequence (bit-reversed order):

Position: 0 1 2 3 4 5 6 7
Input: x[0] x[4] x[2] x[6] x[1] x[5] x[3] x[7]

Stage 1: 4 two-point DFTs

Butterfly 1: x[0], x[4] → X₁[0] = x[0] + x[4], X₁[1] = x[0] - x[4]

Butterfly 2: x[2], x[6] → X₁[2] = x[2] + x[6], X₁[3] = x[2] - x[6]
Butterfly 3: x[1], x[5] → X₁[4] = x[1] + x[5], X₁[5] = x[1] - x[5]
Butterfly 4: x[3], x[7] → X₁[6] = x[3] + x[7], X₁[7] = x[3] - x[7]

Stage 2: 2 four-point DFTs

Upper group:
X₂[0] = X₁[0] + X₁[2]
X₂[2] = X₁[0] - X₁[2]
X₂[1] = X₁[1] + X₁[3]·W₄¹ = X₁[1] + X₁[3]·(-j)
X₂[3] = X₁[1] - X₁[3]·W₄¹ = X₁[1] - X₁[3]·(-j)

Lower group:
X₂[4] = X₁[4] + X₁[6]
X₂[6] = X₁[4] - X₁[6]
X₂[5] = X₁[5] + X₁[7]·W₄¹ = X₁[5] + X₁[7]·(-j)
X₂[7] = X₁[5] - X₁[7]·W₄¹ = X₁[5] - X₁[7]·(-j)

Stage 3: 1 eight-point DFT

X[0] = X₂[0] + X₂[4]·W₈⁰ = X₂[0] + X₂[4]

X[4] = X₂[0] - X₂[4]·W₈⁰ = X₂[0] - X₂[4]

X[1] = X₂[1] + X₂[5]·W₈¹

X[5] = X₂[1] - X₂[5]·W₈¹

X[2] = X₂[2] + X₂[6]·W₈² = X₂[2] + X₂[6]·(-j)

X[6] = X₂[2] - X₂[6]·W₈² = X₂[2] - X₂[6]·(-j)

X[3] = X₂[3] + X₂[7]·W₈³

X[7] = X₂[3] - X₂[7]·W₈³

Where:
W₈¹ = e^(-jπ/4) = (1-j)/√2
W₈³ = e^(-j3π/4) = (-1-j)/√2
13. Previous Year Questions (AKTU)

Question 1 (AKTU 2019, 7 marks)

Q: Distinguish between linear convolution and circular convolution. Obtain circular
convolution of the sequences x[n] = {1, 2, 3, 4} and h[n] = {2, 1, 2, 1}.
Solution:
Distinction:

Aspect Linear Convolution Circular Convolution

Definition y[n] = Σ x[m]h[n-m] y[n] = Σ x[m]h[(n-m) mod N]

Sequence Length N+M-1 N (same as input)

Boundary Conditions Zero padding Periodic extension

Time Aliasing Absent Present

Circular Convolution Calculation:

Using time-domain method:

y[0] = 1×2 + 2×1 + 3×2 + 4×1 = 2 + 2 + 6 + 4 = 14

y[1] = 1×1 + 2×2 + 3×1 + 4×2 = 1 + 4 + 3 + 8 = 16
y[2] = 1×2 + 2×1 + 3×2 + 4×1 = 2 + 2 + 6 + 4 = 14
y[3] = 1×1 + 2×2 + 3×1 + 4×2 = 1 + 4 + 3 + 8 = 16

Answer: y[n] = {14, 16, 14, 16}

Question 2 (AKTU 2018, 10 marks)

Q: Explain Radix-2 DIT FFT algorithm. Find DFT of x[n] = {1, 1, 1, 1, 0, 0, 0, 0} using DIT
algorithm.
Solution:
Algorithm Explanation:
1. Divide: Split sequence into even and odd indexed samples
2. Conquer: Recursively compute smaller DFTs
3. Combine: Use butterfly operations with twiddle factors
4. Input: Requires bit-reversed ordering
8-Point DIT FFT Computation:
Input (bit-reversed): {1, 0, 1, 0, 1, 0, 1, 0}
Stage 1: 4 two-point DFTs
 X₁[0] = 1 + 1 = 2, X₁[1] = 1 - 1 = 0
X₁[2] = 1 + 1 = 2, X₁[3] = 1 - 1 = 0
X₁[4] = 0 + 0 = 0, X₁[5] = 0 - 0 = 0
X₁[6] = 0 + 0 = 0, X₁[7] = 0 - 0 = 0

Stage 2: 2 four-point DFTs

X₂[0] = 2 + 2 = 4, X₂[2] = 2 - 2 = 0
X₂[1] = 0 + 0×(-j) = 0, X₂[3] = 0 - 0×(-j) = 0
X₂[4] = 0 + 0 = 0, X₂[6] = 0 - 0 = 0
X₂[5] = 0 + 0×(-j) = 0, X₂[7] = 0 - 0×(-j) = 0

Stage 3: 1 eight-point DFT

X[0] = 4 + 0 = 4
X[1] = 0 + 0×W₈¹ = 0
X[2] = 0 + 0×(-j) = 0
X[3] = 0 + 0×W₈³ = 0
X[4] = 4 - 0 = 4
X[5] = 0 - 0×W₈¹ = 0
X[6] = 0 - 0×(-j) = 0
X[7] = 0 - 0×W₈³ = 0

Answer: X[k] = {4, 0, 0, 0, 4, 0, 0, 0}

Question 3 (AKTU 2020, 5 marks)

Q: State and prove the time shifting property of DFT.
Solution:
Property Statement:
If x[n] ↔ X[k], then x[(n-m) mod N] ↔ W_N^(mk) X[k]
Proof:
Let y[n] = x[(n-m) mod N]. Then:

Y[k] = Σ(n=0 to N-1) y[n] W_N^(nk)

= Σ(n=0 to N-1) x[(n-m) mod N] W_N^(nk)

Substitute r = (n-m) mod N, so n = (r+m) mod N:

Y[k] = Σ(r=0 to N-1) x[r] W_N^((r+m)k)

= Σ(r=0 to N-1) x[r] W_N^(rk) W_N^(mk)
= W_N^(mk) Σ(r=0 to N-1) x[r] W_N^(rk)
= W_N^(mk) X[k]
Physical Interpretation: A circular time shift by m samples corresponds to multiplication by a
linear phase factor W_N^(mk) in the frequency domain.

Question 4 (AKTU 2017, 7 marks)

Q: Compare the computational complexity of direct DFT and FFT algorithms. What is the
improvement achieved?
Solution:
Direct DFT Complexity:
Multiplications: N² complex multiplications
Additions: N(N-1) ≈ N² complex additions
Total: O(N²) operations
FFT Complexity (Radix-2):
Stages: log₂ N
Butterflies per stage: N/2
Operations per butterfly: 1 multiplication + 2 additions
Total Multiplications: (N/2) × log₂ N
Total Additions: N × log₂ N
Total: O(N log₂ N) operations
Improvement Factor:

Improvement = N²/[(N/2) × log₂ N] = 2N/log₂ N

Numerical Examples:

N Direct DFT FFT Improvement

16 256 32 8×

64 4,096 192 21×

256 65,536 1,024 64×

1024 1,048,576 5,120 205×

Significance: For large N, FFT provides dramatic computational savings, enabling real-time
signal processing applications.
14. Practice Problems

Practice Problem 1
Find the 4-point DFT of x[n] = {2, 1, 0, 1} using both direct method and DIT FFT.

Practice Problem 2
Compute the circular convolution of x[n] = {1, 2, 1, 2} and h[n] = {1, -1, 1, -1} using DFT
method.

Practice Problem 3
Draw the complete signal flow graph for 16-point DIT FFT showing all twiddle factors.

Practice Problem 4
Find the linear convolution of x[n] = {1, 2, 3} and h[n] = {1, 1} using:
a) Direct time-domain method
b) DFT method with zero padding

Practice Problem 5
For the sequence x[n] = {4, 3, 2, 1}, verify Parseval's theorem using its 4-point DFT.

Practice Problem 6
Implement the overlap-add method to find the linear convolution of:
x[n] = {1, 2, 3, 4, 5, 6, 7, 8} (divide into blocks of length 4)
h[n] = {1, 1, 1}

Practice Problem 7
Compare the computational requirements for computing a 1024-point DFT using:
a) Direct DFT
b) Radix-2 DIT FFT
c) Mixed-radix FFT (if N is not power of 2)

Practice Problem 8
Develop the DIF FFT algorithm for 8-point DFT and compare with DIT in terms of:
a) Input/output ordering
b) Butterfly structure
c) Computational complexity
Summary and Key Takeaways

Mathematical Foundations
1. DFT Definition: X[k] = Σ(n=0 to N-1) x[n] W_N^(nk)
2. Twiddle Factors: W_N = e^(-j2π/N)
3. Periodicity: Both time and frequency domains are periodic with period N

Algorithm Efficiency
1. Direct DFT: O(N²) complexity
2. FFT: O(N log N) complexity
3. Improvement: Factor of 2N/log₂N for large N

Key Properties
1. Linearity: DFT of sum equals sum of DFTs
2. Time Shifting: Circular shift ↔ Linear phase
3. Convolution: Circular convolution ↔ Multiplication
4. Parseval's Theorem: Energy conservation

Practical Applications
1. Filter Design: Digital filter implementation
2. Spectral Analysis: Frequency content analysis
3. Image Processing: 2D FFT for image compression
4. Communications: OFDM, spread spectrum

Exam Strategy
1. Memorize: Key formulas and properties
2. Practice: Numerical computations by hand
3. Understand: Physical significance of each operation
4. Draw: Signal flow graphs for FFT algorithms
5. Compare: Different algorithms and their trade-offs
This comprehensive coverage should provide a solid foundation for understanding DFT and FFT
concepts, essential for success in AKTU engineering examinations and practical signal
processing applications.