Fixed-point arithmetic for embedded DSP in Signal Processing - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Fixed-Point Representation

Which statement correctly describes the main difference between fixed-point and floating-point number representations in embedded DSP?

A Fixed-point numbers have a fixed number of digits after the decimal point, while floating-point numbers have a variable number of digits before and after the decimal point.

B Fixed-point numbers can represent a wider range of values than floating-point numbers using the same number of bits.

C Floating-point numbers use integer arithmetic only, while fixed-point numbers use fractional arithmetic only.

D Fixed-point numbers always require more memory than floating-point numbers for the same precision.

💡 Hint

Think about how the decimal point is handled in fixed-point versus floating-point formats.

Fixed-point numbers have a fixed position for the decimal point, meaning the number of digits after it is constant. Floating-point numbers can shift the decimal point, allowing a wider dynamic range.

❓ Predict Output

intermediate

Fixed-Point Multiplication Result

What is the output of the following fixed-point multiplication simulation code?

Signal Processing

def fixed_point_multiply(a, b, fractional_bits=8):
    product = (a * b) >> fractional_bits
    return product

# Inputs are fixed-point numbers with 8 fractional bits
x = 300  # represents 1.171875 (300/256)
y = 512  # represents 2.0 (512/256)
result = fixed_point_multiply(x, y)
print(result)

A 256

B 600

C 150

D 1024

💡 Hint

Remember to shift right by the number of fractional bits after multiplication.

Multiplying 300 by 512 gives 153600. Shifting right by 8 bits (dividing by 256) results in 600.

❓ data_output

advanced

Detecting Overflow in Fixed-Point Addition

Given 16-bit signed fixed-point numbers with 12 fractional bits, what is the output of the following code that adds two numbers and detects overflow?

Signal Processing

def fixed_point_add(a, b, total_bits=16, fractional_bits=12):
    max_val = (1 << (total_bits - 1)) - 1
    min_val = -(1 << (total_bits - 1))
    result = a + b
    overflow = False
    if result > max_val or result < min_val:
        overflow = True
        # Saturate result
        result = max_val if result > max_val else min_val
    return result, overflow

# Inputs
num1 = 2048  # 0.5 in Q4.12 format (2048/4096)
num2 = 4096  # 1.0 in Q4.12 format (4096/4096)
res, ovf = fixed_point_add(num1, num2)
print(res, ovf)

A 6144 False

B 6144 True

C -32768 True

D 32767 True

💡 Hint

Check if the sum exceeds the 16-bit signed integer range.

The sum is 2048 + 4096 = 6144, which is within the 16-bit signed range (-32768 to 32767), so no overflow occurs.

❓ visualization

advanced

Visualizing Quantization Error in Fixed-Point Conversion

Which plot best represents the quantization error when converting a sine wave from floating-point to 8-bit fixed-point representation?

Signal Processing

import numpy as np
import matplotlib.pyplot as plt

# Generate sine wave
x = np.linspace(0, 2 * np.pi, 100)
sine_wave = np.sin(x)

# Convert to 8-bit fixed-point (Q0.7 format)
fixed_point = np.round(sine_wave * 127) / 127

# Calculate quantization error
error = sine_wave - fixed_point

plt.figure(figsize=(8,4))
plt.plot(x, error, label='Quantization Error')
plt.axhline(0, color='black', linewidth=0.5)
plt.title('Quantization Error of Sine Wave in 8-bit Fixed-Point')
plt.xlabel('Angle (radians)')
plt.ylabel('Error')
plt.legend()
plt.grid(True)
plt.show()

A Random noise scattered around zero with no clear pattern

B A constant zero line indicating no error

C A stair-step pattern with discrete jumps between error values

D A smooth sinusoidal curve oscillating between -0.01 and 0.01

💡 Hint

Think about how rounding affects the error values in fixed-point conversion.

The quantization error shows discrete jumps because fixed-point rounding maps continuous values to discrete levels, creating a stair-step error pattern.

🔧 Debug

expert

Identifying the Cause of Overflow in Fixed-Point DSP Filter

Given the following fixed-point DSP filter code, which option correctly identifies the cause of overflow during execution?

Signal Processing

def fixed_point_filter(input_signal, coeff, fractional_bits=15):
    acc = 0
    for x, c in zip(input_signal, coeff):
        acc += (x * c) >> fractional_bits
    # Saturate to 16-bit signed
    if acc > 32767:
        acc = 32767
    elif acc < -32768:
        acc = -32768
    return acc

input_signal = [30000, 30000, 30000]
coeff = [16384, 16384, 16384]  # 0.5 in Q1.15 format
output = fixed_point_filter(input_signal, coeff)
print(output)

A The saturation limits are set incorrectly for 16-bit unsigned integers.

B The right shift by fractional_bits is applied before multiplication, causing incorrect scaling.

C The coefficients are too small, resulting in underflow and zero output.

D The accumulator variable 'acc' is not large enough to hold intermediate sums, causing overflow.

💡 Hint

Consider the size of 'acc' and the range of intermediate multiplication results.

The accumulator 'acc' is a standard integer and can overflow because the sum of multiple large intermediate products exceeds 16-bit range before saturation.

Practice

1. What is the main reason to use fixed-point arithmetic in embedded DSP systems?

easy

A. To increase the precision beyond floating-point numbers

B. To perform fast math on devices without floating-point hardware

C. To simplify programming by avoiding scaling

D. To use more memory for storing numbers

Solution

1. Step 1: Understand fixed-point arithmetic purpose

   Fixed-point arithmetic is used to perform calculations efficiently on devices that lack floating-point hardware.

2. Step 2: Compare options with this purpose

   To perform fast math on devices without floating-point hardware correctly states the main reason: fast math on devices without floating-point units. Other options are incorrect because fixed-point does not increase precision beyond floating-point, does not simplify programming by avoiding scaling, and does not use more memory.

3. Final Answer:

   To perform fast math on devices without floating-point hardware -> Option B

4. Quick Check:

   Fixed-point speeds math on limited hardware = A [OK]

Hint: Fixed-point is for speed on limited hardware [OK]

Common Mistakes:

• Thinking fixed-point increases precision beyond floating-point
• Assuming fixed-point uses more memory
• Believing fixed-point avoids scaling complexity

2. Which of the following is the correct way to represent a fixed-point number with 8 fractional bits in C?

easy

A. int16_t fixed = value << 8;

B. int16_t fixed = value >> 8;

C. int16_t fixed = value * 8;

D. int16_t fixed = value / 8;

Solution

1. Step 1: Understand fixed-point scaling

   For 8 fractional bits, multiply the integer value by 2^8 (which is shifting left by 8) to convert to fixed-point.

2. Step 2: Match with options

   int16_t fixed = value << 8; shifts left by 8 bits, correctly scaling the value. int16_t fixed = value >> 8; shifts right (wrong direction), A divides by 8 (wrong), C multiplies by 8 (not 256).

3. Final Answer:

   int16_t fixed = value << 8; -> Option A

4. Quick Check:

   Shift left by fractional bits to scale = D [OK]

Hint: Shift left by fractional bits to convert to fixed-point [OK]

Common Mistakes:

• Shifting right instead of left
• Multiplying/dividing by wrong powers of two
• Confusing fractional bits with decimal places

3. Given two fixed-point numbers with 8 fractional bits: a = 0x0100 (1.0) and b = 0x0200 (2.0), what is the fixed-point result of c = (a * b) >> 8;?

medium

A. 0x0400 (4.0)

B. 0x0300 (3.0)

C. 0x0200 (2.0)

D. 0x0100 (1.0)

Solution

1. Step 1: Multiply fixed-point values

   a * b = 0x0100 * 0x0200 = 256 * 512 = 131072 (decimal)

2. Step 2: Adjust scale by shifting right 8 bits

   c = 131072 >> 8 = 131072 / 256 = 512 decimal = 0x0200

3. Step 3: Recalculate carefully

   Wait, 0x0100 = 256 decimal, 0x0200 = 512 decimal. Multiplying: 256 * 512 = 131072 decimal. Shifting right 8 bits divides by 256: 131072 / 256 = 512 decimal = 0x0200. So c = 0x0200 (2.0).

4. Final Answer:

   0x0200 (2.0) -> Option C

5. Quick Check:

   (1.0 * 2.0) = 2.0 fixed-point = 0x0200 [OK]

Hint: Multiply then shift right by fractional bits to rescale [OK]

Common Mistakes:

• Forgetting to shift right after multiplication
• Misinterpreting hex values as decimal
• Incorrect bit shift amount

4. Identify the error in this fixed-point multiplication code snippet with 8 fractional bits:

int16_t a = 0x0100; // 1.0
int16_t b = 0x0200; // 2.0
int16_t c = a * b;

medium

A. Missing right shift to rescale after multiplication

B. Variables should be float, not int16_t

C. Should shift left before multiplication

D. No error, code is correct

Solution

1. Step 1: Understand fixed-point multiplication scaling

   Multiplying two fixed-point numbers doubles the fractional bits, so the result must be shifted right by the fractional bit count to rescale.

2. Step 2: Analyze given code

   The code multiplies a and b but does not shift right by 8 bits, so the scale is incorrect.

3. Final Answer:

   Missing right shift to rescale after multiplication -> Option A

4. Quick Check:

   Shift right after multiply to fix scale = C [OK]

Hint: Always shift right after fixed-point multiply [OK]

Common Mistakes:

• Not shifting right after multiplication
• Using float instead of fixed-point on embedded
• Shifting left instead of right

5. You have a fixed-point format with 12 fractional bits. You want to multiply two numbers and keep the result in the same format without overflow. Which approach is best?

hard

A. Multiply, then shift left by 12 bits, and store in a 16-bit integer

B. Shift right by 12 bits before multiplying, store in 16-bit integer

C. Multiply without shifting, store in 16-bit integer

D. Multiply, then shift right by 12 bits, and store in a 32-bit integer

Solution

1. Step 1: Understand fixed-point multiplication with 12 fractional bits

   Multiplying two fixed-point numbers doubles fractional bits (24 bits), so shifting right by 12 bits rescales back to 12 fractional bits.

2. Step 2: Prevent overflow by using wider integer

   Multiplying two 16-bit numbers can overflow 16 bits, so use a 32-bit integer to hold the intermediate product safely.

3. Final Answer:

   Multiply, then shift right by 12 bits, and store in a 32-bit integer -> Option D

4. Quick Check:

   Shift right after multiply and use wider int = B [OK]

Hint: Use wider int and shift right after multiply [OK]

Common Mistakes:

• Not using wider integer causing overflow
• Shifting left instead of right after multiply
• Shifting before multiply losing precision