A complex number is created from two real numbers. Python complex number can be created using complex() function as well as using direct assignment statement.
Complex numbers are mostly used where we define something using two real numbers. For example, a circuit element that is defined by Voltage (V) and Current (I). They are mostly used in geometry, calculus and scientific calculations.
Python Complex Numbers
Let’s first learn how to create complex numbers in python.
|
1 2 3 4 5 6 7 8 |
c = 1 + 2j print(type(c)) print(c) c1 = complex(2, 4) print(type(c1)) print(c1) |
Output:
|
1 2 3 4 5 6 |
<class 'complex'> (1+2j) <class 'complex'> (2+4j) |
Python complex numbers are of type complex. Every complex number contains one real part and one imaginary part.
Python Complex Numbers Attributes and Functions
Let’s look at some attributes and instance functions of complex numbers.
|
1 2 3 4 5 6 |
c = 1 + 2j print('Real Part=", c.real) print("Imaginary Part=", c.imag) print("Complex conjugate=", c.conjugate()) |
Output:
|
1 2 3 4 5 |
Real Part = 1.0 Imaginary Part = 2.0 Complex conjugate = (1-2j) |
Complex Numbers Mathematical Calculations
Complex numbers support mathematical caluclations such as addition, subtraction, multiplication and division.
|
1 2 3 4 5 6 7 8 |
c = 1 + 2j c1 = 2 + 4j print("Addition =', c + c1) print('Subtraction =', c - c1) print('Multiplication =', c * c1) print('Division =', c1 / c) |
Output:
|
1 2 3 4 5 6 |
Addition = (3+6j) Subtraction = (-1-2j) Multiplication = (-6+8j) Division = (2+0j) |
Complex numbers don’t support comparison operators. If we try to execute c < c1 then the error message will be thrown as TypeError: '<' not supported between instances of 'complex' and 'complex'.
Python cmath module
Python cmath module provides access to mathematical functions for complex numbers. Let’s look at some of the important features of complex numbers and how we can use cmath module function to calculate them.
Phase of Complex Number
The phase of a complex number is the angle between the real axis and the vector representing the imaginary part. Below image illustrates the phase of a complex number and how to get this value using cmath and math modules.
Note that the phase returned by math and cmath modules are in radians, we can use numpy.degrees() function to convert it to degrees. The range of phase is from -π to +π (-pi to +pi) in radians and it’s equivalent to -180 to +180 degrees.
|
1 2 3 4 5 6 7 8 9 10 11 |
import cmath, math, numpy c = 2 + 2j # phase phase = cmath.phase(c) print('2 + 2j Phase=", phase) print("Phase in Degrees=", numpy.degrees(phase)) print("-2 - 2j Phase=", cmath.phase(-2 - 2j), "radians. Degrees=", numpy.degrees(cmath.phase(-2 - 2j))) # we can get phase using math.atan2() function too print("Complex number phase using math.atan2() =', math.atan2(2, 1)) |
Output:
|
1 2 3 4 5 6 |
2 + 2j Phase = 0.7853981633974483 Phase in Degrees = 45.0 -2 - 2j Phase = -2.356194490192345 radians. Degrees = -135.0 Complex number phase using math.atan2() = 1.1071487177940904 |
Polar and Rectangular Coordinates
We can write a complex number in polar coordinates, which is a tuple of modulus and phase of the complex number.
We can use cmath.rect() function to create a complex number in rectangular format by passing modulus and phase as arguments.
|
1 2 3 4 5 6 7 8 9 10 |
c = 1 + 2j modulus = abs(c) phase = cmath.phase(c) polar = cmath.polar(c) print('Modulus=", modulus) print("Phase=", phase) print("Polar Coordinates=", polar) print("Rectangular Coordinates=", cmath.rect(modulus, phase)) |
Output:
|
1 2 3 4 5 6 |
Modulus = 2.23606797749979 Phase = 1.1071487177940904 Polar Coordinates = (2.23606797749979, 1.1071487177940904) Rectangular Coordinates = (1.0000000000000002+2j) |
cmath module constants
There are a bunch of constants in cmath module that are used in the complex number calculations.
|
1 2 3 4 5 6 7 8 9 |
print("π =', cmath.pi) print('e=", cmath.e) print("tau =', cmath.tau) print('Positive infinity =', cmath.inf) print('Positive Complex infinity =', cmath.infj) print('NaN =', cmath.nan) print('NaN Complex =', cmath.nanj) |
Output:
|
1 2 3 4 5 6 7 8 9 |
π = 3.141592653589793 e = 2.718281828459045 tau = 6.283185307179586 Positive infinity = inf Positive Complex infinity = infj NaN = nan NaN Complex = nanj |
Power and Log Functions
There are some useful functions for logarithmic and power operations.
|
1 2 3 4 5 6 7 |
c = 2 + 2j print('e^c=", cmath.exp(c)) print("log2(c) =', cmath.log(c, 2)) print('log10(c) =', cmath.log10(c)) print('sqrt(c) =', cmath.sqrt(c)) |
Output:
|
1 2 3 4 5 6 |
e^c = (-3.074932320639359+6.71884969742825j) log2(c) = (1.5000000000000002+1.1330900354567985j) log10(c) = (0.4515449934959718+0.3410940884604603j) sqrt(c) = (1.5537739740300374+0.6435942529055826j) |
Trigonometric Functions
|
1 2 3 4 5 6 7 8 9 |
c = 2 + 2j print('arc sine=", cmath.asin(c)) print("arc cosine=", cmath.acos(c)) print("arc tangent=", cmath.atan(c)) print("sine=", cmath.sin(c)) print("cosine=", cmath.cos(c)) print("tangent=", cmath.tan(c)) |
Output:
|
1 2 3 4 5 6 7 8 |
arc sine = (0.7542491446980459+1.7343245214879666j) arc cosine = (0.8165471820968505-1.7343245214879666j) arc tangent = (1.311223269671635+0.2388778612568591j) sine = (3.4209548611170133-1.5093064853236156j) cosine = (-1.5656258353157435-3.2978948363112366j) tangent = (-0.028392952868232294+1.0238355945704727j) |
Hyperbolic Functions
|
1 2 3 4 5 6 7 8 9 |
c = 2 + 2j print("inverse hyperbolic sine=", cmath.asinh(c)) print("inverse hyperbolic cosine=", cmath.acosh(c)) print("inverse hyperbolic tangent=", cmath.atanh(c)) print("hyperbolic sine=", cmath.sinh(c)) print("hyperbolic cosine=", cmath.cosh(c)) print("hyperbolic tangent=", cmath.tanh(c)) |
Output:
|
1 2 3 4 5 6 7 8 |
inverse hyperbolic sine = (1.7343245214879666+0.7542491446980459j) inverse hyperbolic cosine = (1.7343245214879666+0.8165471820968505j) inverse hyperbolic tangent = (0.2388778612568591+1.311223269671635j) hyperbolic sine = (-1.5093064853236156+3.4209548611170133j) hyperbolic cosine = (-1.5656258353157435+3.2978948363112366j) hyperbolic tangent = (1.0238355945704727-0.028392952868232294j) |
Classification Functions
There are some miscellaneous functions to check if the complex number is finite, infinite or nan. There is also a function to check if two complex numbers are close.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
print(cmath.isfinite(2 + 2j)) # True print(cmath.isfinite(cmath.inf + 2j)) # False print(cmath.isinf(2 + 2j)) # False print(cmath.isinf(cmath.inf + 2j)) # True print(cmath.isinf(cmath.nan + 2j)) # False print(cmath.isnan(2 + 2j)) # False print(cmath.isnan(cmath.inf + 2j)) # False print(cmath.isnan(cmath.nan + 2j)) # True print(cmath.isclose(2+2j, 2.01+1.9j, rel_tol=0.05)) # True print(cmath.isclose(2+2j, 2.01+1.9j, abs_tol=0.005)) # False |
The output of each statement is provided in the comments.
Reference: API Doc