Complex number type in NumPy - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a complex number in numpy?

A complex number in numpy has a real part and an imaginary part. It is represented as a + bj, where a is the real part and b is the imaginary part.

beginner

How do you create a complex number array in numpy?

You can create a complex number array using numpy.array with complex values, for example: np.array([1+2j, 3+4j]).

intermediate

What numpy data types represent complex numbers?

Numpy uses complex64 and complex128 to represent complex numbers. complex64 uses 32 bits for real and 32 bits for imaginary parts, while complex128 uses 64 bits for real and 64 bits for imaginary parts.

beginner

How can you access the real and imaginary parts of a numpy complex array?

Use the .real attribute to get the real parts and .imag attribute to get the imaginary parts of a numpy complex array.

intermediate

Why are complex numbers useful in data science?

Complex numbers help in fields like signal processing, quantum computing, and electrical engineering where data has both magnitude and phase information.

Which numpy data type is used for complex numbers with 64-bit real and imaginary parts?

A complex64

B complex128

C float64

D int64

complex128 uses 64 bits for both real and imaginary parts.

How do you get the imaginary part of a numpy complex array named z?

A z.imag

B z.real

C imag(z)

D z.imaginary

The correct attribute to access the imaginary part is .imag.

What does the complex number 3 + 4j represent?

A Magnitude 3, phase 4

B Real part 4, imaginary part 3

C Imaginary part 3, real part 4

D Real part 3, imaginary part 4

In a + bj, a is real and b is imaginary.

Which numpy function can create an array of complex numbers?

A np.array

B np.complex

C np.complex_array

D np.complex64

You create complex arrays using np.array with complex values.

Why might data scientists use complex numbers?

A To store only real numbers

B To speed up sorting algorithms

C To represent data with magnitude and phase

D To reduce memory usage

Complex numbers represent data with both magnitude and phase, useful in many scientific fields.

Explain how to create and access parts of a complex number array in numpy.

Think about how you write complex numbers and how numpy stores them.

Describe the difference between complex64 and complex128 in numpy.

Consider how many bits are used for each part.

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