Numeric type

Enables representation of numbers with real and imaginary parts for calculations that require complex arithmetic.

Signal processing: modeling phasors with amplitude and phase Physics simulation: handling wave functions with complex amplitudes Mathematics: solving quadratic equations with negative discriminants

Scientific computing libraries (NumPy, SciPy), audio processing applications, electrical engineering simulations, mathematical modeling codebases

Define a complex number → perform arithmetic operations → analyze results

z = a + b*i

• math.sqrt
• cmath module
• numpy.complex64
• complex literals

• Use separate real and imaginary float variables — more verbose
• Use polar representation (magnitude
• angle) — avoids complex arithmetic but adds conversion overhead
• Use third‑party libraries like mpmath for arbitrary‑precision complex numbers — higher performance cost

Treating a complex literal as a string, causing type errors; Forgetting to import the cmath module before using complex functions, leading to NameError; Assuming the imaginary part is always positive, which can produce incorrect sign handling; Mixing real and complex types in arithmetic without explicit conversion, resulting in unexpected casting behavior

float vs complex (float lacks an imaginary component); Polar coordinates vs rectangular representation (different parameterizations); numpy.ndarray of dtype=complex vs separate real and imaginary arrays (memory layout differences)

Coming from JavaScript: assuming complex numbers are built‑in — JavaScript lacks a native complex type; use a library instead.

• Complex numbers
• Numeric types
• Floating‑point arithmetic

Do not use Complex for simple real‑only calculations because it adds unnecessary overhead; Complex arithmetic incurs extra CPU cycles compared to pure float operations, especially in tight loops; Edge cases arise when the imaginary part is NaN or infinite, which can propagate silently through calculations.

Correct use of Complex ensures mathematically accurate results in signal transformations, physics simulations, and any domain requiring two‑dimensional numeric representations, preventing subtle bugs caused by real‑only approximations.

Think of a complex number as a point on a 2D plane: the x‑axis is the real part, the y‑axis is the imaginary part, and arithmetic moves you around that plane.

In Python, the built‑in complex type uses double‑precision floats for both real and imaginary parts, matching the IEEE‑754 double format.