Complex number type in NumPy - Mini Project: Build & Apply

Working with Complex Numbers using NumPy

📖 Scenario: Imagine you are working with signals in engineering or physics. Signals often have two parts: one part that shows the main value and another part that shows a shift or delay. These two parts can be represented as complex numbers.

🎯 Goal: You will create a NumPy array of complex numbers, set a threshold for the imaginary part, filter the numbers based on this threshold, and then print the filtered results.

📋 What You'll Learn

Create a NumPy array called complex_numbers with specific complex values

Create a variable called imag_threshold to hold a numeric threshold

Use a list comprehension to filter complex_numbers for numbers with imaginary part greater than imag_threshold

Print the filtered list of complex numbers

💡 Why This Matters

🌍 Real World

Complex numbers are used in signal processing, electrical engineering, and physics to represent waves, oscillations, and other phenomena with two components.

💼 Career

Understanding how to manipulate complex numbers with NumPy is useful for data scientists and engineers working with signals, control systems, or any domain involving complex data.

1

Create a NumPy array of complex numbers

Import NumPy as np and create a NumPy array called complex_numbers with these exact complex values: 3+4j, 1+2j, 5+0j, 0+3j, and 2+1j.

NumPy

import numpy as np
# Create the NumPy array complex_numbers with the given complex values
# Your code here

Hint

Use np.array and list the complex numbers inside square brackets.

2

Set the imaginary part threshold

Create a variable called imag_threshold and set it to the number 2.

NumPy

import numpy as np
complex_numbers = np.array([3+4j, 1+2j, 5+0j, 0+3j, 2+1j])
# Create imag_threshold and set it to 2
# Your code here

Hint

Just assign the number 2 to the variable imag_threshold.

3

Filter complex numbers by imaginary part

Use a list comprehension to create a list called filtered_numbers that contains only the numbers from complex_numbers whose imaginary part is greater than imag_threshold. Use num.imag to get the imaginary part of each number.

NumPy

import numpy as np
complex_numbers = np.array([3+4j, 1+2j, 5+0j, 0+3j, 2+1j])
imag_threshold = 2
# Create filtered_numbers with numbers having imaginary part > imag_threshold
# Your code here

Hint

Use a list comprehension with num.imag > imag_threshold as the condition.

4

Print the filtered complex numbers

Print the variable filtered_numbers to display the filtered complex numbers.

NumPy

import numpy as np
complex_numbers = np.array([3+4j, 1+2j, 5+0j, 0+3j, 2+1j])
imag_threshold = 2
filtered_numbers = [num for num in complex_numbers if num.imag > imag_threshold]
# Print filtered_numbers
# Your code here

Hint

The output should show only the complex numbers with imaginary parts greater than 2.

Practice

1. What does the numpy.complex128 data type represent?

easy

A. A string representing a complex number

B. A real number with 128 bits precision

C. An integer number with 128 bits

D. A complex number with double precision for real and imaginary parts

Solution

1. Step 1: Understand the data type name

   The name complex128 indicates a complex number type with 128 bits total.

2. Step 2: Recall complex number structure in numpy

   In numpy, complex128 stores two 64-bit floats: one for real and one for imaginary parts.

3. Final Answer:

   A complex number with double precision for real and imaginary parts -> Option D

4. Quick Check:

   complex128 = complex number with 128 bits [OK]

Hint: Look for 'complex' and bit size meaning real+imag parts [OK]

Common Mistakes:

• Confusing complex128 with real number types
• Thinking complex128 stores integers
• Assuming complex128 is a string type

2. Which of the following is the correct way to create a numpy array of complex numbers with type complex64?

easy

A. np.array([1+2j, 3+4j], dtype='complex64')

B. np.array([1+2j, 3+4j], dtype='int64')

C. np.array([1, 2, 3], dtype='complex64')

D. np.array([1+2, 3+4], dtype='complex64')

Solution

1. Step 1: Check the array elements

   The elements must be complex numbers, so they need an imaginary part like 1+2j.

2. Step 2: Check the dtype argument

   Using dtype='complex64' correctly sets the array to complex numbers with 64-bit precision.

3. Final Answer:

   np.array([1+2j, 3+4j], dtype='complex64') -> Option A

4. Quick Check:

   Complex elements + complex64 dtype = correct array [OK]

Hint: Use complex literals with 'j' and set dtype to complex64 [OK]

Common Mistakes:

• Using integer dtype with complex numbers
• Missing imaginary part in elements
• Using invalid dtype strings

3. What is the output of this code?

import numpy as np
z = np.array([3+4j, 1-1j], dtype=np.complex128)
magnitudes = np.abs(z)
print(magnitudes)

medium

A. [5. 1.41421356]

B. [7.+0.j 0.+0.j]

C. [3.+4.j 1.-1.j]

D. [0.6 0.8]

Solution

1. Step 1: Understand np.abs on complex array

   np.abs returns the magnitude (distance from origin) of each complex number.

2. Step 2: Calculate magnitudes manually

   For 3+4j, magnitude = sqrt(3^2 + 4^2) = 5. For 1-1j, magnitude = sqrt(1^2 + (-1)^2) = sqrt(2) ≈ 1.41421356.

3. Final Answer:

   [5. 1.41421356] -> Option A

4. Quick Check:

   Magnitude = sqrt(real² + imag²) [OK]

Hint: Magnitude = sqrt(real² + imag²) using np.abs [OK]

Common Mistakes:

• Confusing magnitude with real or imaginary parts
• Expecting complex output instead of float magnitudes
• Using np.angle instead of np.abs

4. The following code throws an error. What is the cause?

import numpy as np
z = np.array([1+2j, 3+4j], dtype='complex64')
angle = np.angle(z, deg=True)
print(angle)

medium

A. np.angle does not support degree output

B. No error; code runs fine

C. Missing import for np.angle function

D. dtype 'complex64' is invalid for np.angle

Solution

1. Step 1: Check dtype compatibility

   np.angle works with complex arrays of any valid complex dtype including complex64.

2. Step 2: Check np.angle parameters

   The parameter deg=True is valid and returns angle in degrees.

3. Final Answer:

   No error; code runs fine -> Option B

4. Quick Check:

   np.angle supports complex64 and deg=True [OK]

Hint: np.angle supports complex64 and degree output [OK]

Common Mistakes:

• Assuming complex64 is unsupported by np.angle
• Thinking deg=True is invalid
• Expecting import error for np.angle

5. You have a numpy array z = np.array([1+1j, 0+0j, -1-1j], dtype=np.complex128). You want to create a new array that contains the magnitudes but replaces zeros with the string 'zero'. Which code correctly does this?

hard

A. np.array([str(m) if m == 0 else m for m in np.abs(z)])

B. np.abs(z).replace(0, 'zero')

C. np.where(np.abs(z) == 0, 'zero', np.abs(z))

D. np.abs(z).astype(str).replace('0.0', 'zero')

Solution

1. Step 1: Calculate magnitudes with np.abs

   np.abs(z) returns an array of magnitudes as floats.

2. Step 2: Replace zeros with 'zero' using np.where

   np.where(condition, value_if_true, value_if_false) replaces elements where magnitude is 0 with string 'zero', else keeps magnitude.

3. Final Answer:

   np.where(np.abs(z) == 0, 'zero', np.abs(z)) -> Option C

4. Quick Check:

   Use np.where for conditional replacement in arrays [OK]

Hint: Use np.where(condition, 'zero', values) for replacements [OK]

Common Mistakes:

• Trying to use .replace on numpy arrays (not supported)
• Converting all to strings unnecessarily
• Using list comprehension without numpy benefits