Frequency Component Energy

easyFREEFourier TransformsSignal ProcessingCV: Image Processing

Implement a function to calculate the energy of a signal from its Discrete Fourier Transform (DFT) magnitudes. This task involves understanding the relationship between a signal's time-domain representation and its frequency-domain representation. The Fourier Transform is a mathematical tool used to decompose a signal into its constituent frequencies, and the DFT is a discrete-time equivalent.

The energy of a signal can be computed using the time-domain representation, but it can also be calculated using the frequency-domain representation, thanks to Parseval's theorem. This theorem states that the energy of a signal is equal to the sum of the squared magnitudes of its frequency components.

To compute the energy, follow these steps:

Square each magnitude of the DFT
Sum the squared magnitudes
Divide the sum by the total number of frequency components, $N$

E = \frac{1}{N}\sum_{k=0}^{N-1} |X[k]|^2

This technique is widely used in image processing to analyze the frequency components of an image.

Example

Input

signal_energy([2, 0, 2, 0])

Output

2.0

Reasoning

The input is a list of $N = 4$ DFT magnitudes, one per frequency bin $k = 0, 1, 2, 3$ : $|X[0]| = 2$ , $|X[1]| = 0$ , $|X[2]| = 2$ , $|X[3]| = 0$ . They are already magnitudes, so no complex arithmetic is needed.
Squaring each gives the power in that bin: $2^2 = 4$ , $0^2 = 0$ , $2^2 = 4$ , $0^2 = 0$ . Only bins 0 and 2 carry any energy.
Adding the bin powers: $4 + 0 + 4 + 0 = 8$ .
Normalising by the number of bins, as the formula requires: $E = \frac{1}{4} \cdot 8 = 2$ , which is 2.0 after rounding to 4 decimal places.
Notice that the zero bins still count toward $N$ : they add nothing to the sum but they do enlarge the denominator. Two magnitudes of 2 spread over 4 bins give $2.0$ , whereas one magnitude of 4 in 4 bins gives $\frac{16}{4} = 4.0$ . Concentrating the same total magnitude in a single bin produces more energy because the magnitudes are squared.

Constraints

Return energy rounded to 4 decimal places

Learn this in

Image ProcessingCV Study Plan

More from CV: Image Processing

Frequency Domain Filteringhard Separable Filter Optimizationhard Contrast Limited Adaptive Histogram Equalizationmedium Low-Pass Filter (Frequency)medium 1D DFTmedium

Concept primer

To solve this problem, you mainly need to understand what the DFT represents and how Parseval’s theorem lets you compute signal energy from its frequency-domain magnitudes.

1. Background Knowledge (Key Concepts)

DFT and Magnitude A discrete-time signal $x[n]$ , $n = 0,\dots,N-1$ , has a Discrete Fourier Transform (DFT) $X[k]$ , $k = 0,\dots,N-1$ . Each $X[k]$ is complex and can be written as $X[k] = a_k + j b_k$ , and its magnitude is $|X[k]| = \sqrt{a_k^2 + b_k^2}$ . The squared magnitude is $|X[k]|^2$ , which corresponds to the power (or energy contribution) at frequency bin $k$ .
Parseval’s Theorem (Discrete Form) For the DFT, Parseval’s theorem states that the total energy in time domain equals the total energy in frequency domain, up to a scaling factor that depends on the DFT normalization convention. For the common convention used in your problem:

E = \sum_{n=0}^{N-1} |x[n]|^2 = \frac{1}{N}\sum_{k=0}^{N-1} |X[k]|^2 You are given the right-hand side and asked to compute E from the |X[k]| values. ### 2. Algorithm / General Approach Given an array of **DFT magnitudes** (or squared magnitudes), the general pattern is: 1. For each frequency bin k, compute the **squared magnitude** |X[k]|^2. 2. Sum all these squared magnitudes over k = 0 to N-1. 3. Multiply the sum by the scaling factor \frac{1}{N} (as specified in the formula). 4. Return this value as the **signal energy**. This is essentially a **reduction** operation: transform each element (square it), then sum, then scale. ### 3. Step-by-Step Strategy Assume the input is: - N: length of the DFT - An array X of complex values or magnitudes. Steps: 1. **Initialize accumulator** ```python energy_sum = 0.0 ``` 2. **Loop over all frequency bins** - If X[k] is complex: ```python mag_sq = (X[k].real * X[k].real) + (X[k].imag * X[k].imag) ``` - If X[k] is already the magnitude: ```python mag_sq = X[k] * X[k] ``` - Accumulate: ```python energy_sum += mag_sq ``` 3. **Apply the 1/N factor** ```python E = energy_sum / N ``` 4. **Output** E as the energy. This is all that’s needed: one pass over the array and a final division. ### 4. Common Pitfalls - **Forgetting the 1/N factor** The problem explicitly gives:

E = $\frac{1}{N}$ \sum_{k=0}^{N-1} |X[k]|^2

Do not just return the raw sum. - **Using magnitude instead of squared magnitude** You must use $|X[k]|^2$, not $|X[k]|$. Make sure to square the magnitude. - **Confusion about input type** - If the input is complex DFT coefficients, compute $|X[k]|^2$ via real/imag parts. - If the input is already magnitudes, do **not** take another square root; just square the given value. - **Integer overflow or precision issues** Use a floating-point type (double / float64) for the accumulator, especially if values can be large or $N$ is big. - **Off-by-one in loops** Make sure you cover indices from 0 to N-1 inclusive. ### 5. Time & Space Complexity - **Time Complexity** - One loop over all $N$ frequency bins, each doing $O(1)$ work. - Total time: **$O(N)$**. - **Space Complexity** - If you process the given array in-place or read-only, you only need a constant number of extra variables. - Extra space: **$O(1)$**.

solution.py

Python 3.13

Test results