Julia Complex and Rational Numbers

Julia natively supports complex and rational number operations, making scientific computing and mathematical calculations more straightforward.

Complex Numbers

Creating Complex Numbers

Julia uses im to represent the imaginary unit (i = √-1):

# Basic creation
z1 = 3 + 4im
z2 = 1 - 2im

println(z1)  # 3 + 4im
println(typeof(z1))  # ComplexF64 or Complex{Int64}

# Using Complex constructor
z3 = Complex(3, 4)     # 3 + 4im
z4 = Complex(5.0, -2.0)  # 5.0 - 2.0im

# Pure imaginary
z5 = 2im               # 0 + 2im
z6 = Complex(0, 3)     # 0 + 3im

# From real number
z7 = Complex(5)        # 5 + 0im

Complex Number Properties

z = 3 + 4im

# Get real and imaginary parts
println(real(z))  # 3
println(imag(z))  # 4

# Complex conjugate
println(conj(z))  # 3 - 4im

# Modulus (absolute value)
println(abs(z))   # 5.0 (√(3² + 4²))

# Squared modulus
println(abs2(z))  # 25 (3² + 4², avoids square root)

# Argument (radians)
println(angle(z)) # 0.9272... (atan(4/3))

Complex Number Operations

z1 = 3 + 4im
z2 = 1 - 2im

# Addition
println(z1 + z2)  # 4 + 2im

# Subtraction
println(z1 - z2)  # 2 + 6im

# Multiplication
println(z1 * z2)  # 11 - 2im

# Division
println(z1 / z2)  # -1.0 + 2.0im

# Power
println(z1^2)     # -7 + 24im
println(z1^0.5)   # Square root

# Complex with real operations
println(z1 + 5)   # 8 + 4im
println(z1 * 2)   # 6 + 8im

Complex Functions

z = 1 + 1im

# Exponential and logarithm
println(exp(z))   # e^z
println(log(z))   # Natural logarithm

# Trigonometric functions
println(sin(z))
println(cos(z))
println(tan(z))

# Hyperbolic functions
println(sinh(z))
println(cosh(z))
println(tanh(z))

# Square root
println(sqrt(-1 + 0im))  # 0.0 + 1.0im
println(sqrt(Complex(-1)))  # Same as above

Polar Form

# Create complex number from polar coordinates
r = 5.0          # Modulus
θ = π/4          # Argument

z = r * exp(im * θ)  # Or r * cis(θ)
println(z)       # 3.5355... + 3.5355...im

# Using cis function (cos + i*sin)
z = 5 * cis(π/4)

# Extract polar coordinates
println(abs(z))    # Modulus: 5.0
println(angle(z))  # Argument: 0.785... (π/4)

Euler's Formula

# e^(iπ) + 1 ≈ 0 (Euler's identity)
result = exp(im * π) + 1
println(result)      # 0.0 + 1.2246...e-16im (approximately 0)
println(isapprox(result, 0, atol=1e-10))  # true

Rational Numbers

Creating Rational Numbers

Use the // operator to create rational numbers:

# Basic creation
r1 = 3//4
r2 = 2//3

println(r1)  # 3//4
println(typeof(r1))  # Rational{Int64}

# Automatic reduction
r3 = 6//8
println(r3)  # 3//4 (automatically reduced)

r4 = 10//15
println(r4)  # 2//3

# Negative rationals
r5 = -3//4
r6 = 3//-4
println(r5)  # -3//4
println(r6)  # -3//4 (sign moved to numerator)

Rational Number Properties

r = 3//4

# Get numerator and denominator
println(numerator(r))    # 3
println(denominator(r))  # 4

# Convert to float
println(float(r))        # 0.75
println(Float64(r))      # 0.75

Rational Number Operations

r1 = 3//4
r2 = 2//3

# Addition
println(r1 + r2)  # 17//12

# Subtraction
println(r1 - r2)  # 1//12

# Multiplication
println(r1 * r2)  # 1//2

# Division
println(r1 / r2)  # 9//8

# Power
println(r1^2)     # 9//16
println(r1^-1)    # 4//3 (reciprocal)

# With integers
println(r1 + 1)   # 7//4
println(r1 * 2)   # 3//2

Rational Number Comparison

r1 = 1//3
r2 = 2//6

# Equality comparison (compares after reduction)
println(r1 == r2)  # true

# Magnitude comparison
println(1//3 < 1//2)  # true
println(2//3 > 1//2)  # true

# Compare with floats
println(1//2 == 0.5)  # true
println(1//3 == 1/3)  # false (floating point precision issue)

Advantages of Rational Numbers

Rational numbers can exactly represent fractions, avoiding floating point precision issues:

# Floating point precision issue
a = 0.1 + 0.2
println(a == 0.3)  # false!
println(a)         # 0.30000000000000004

# Exact calculation with rationals
b = 1//10 + 2//10
println(b == 3//10)  # true
println(b)           # 3//10

Creating Rationals from Floats

# rationalize converts float to rational
r = rationalize(0.75)
println(r)  # 3//4

r = rationalize(0.333333)
println(r)  # 1//3

# Specify tolerance
r = rationalize(π, tol=1e-3)
println(r)  # 201//64
println(float(r))  # 3.140625

r = rationalize(π, tol=1e-6)
println(r)  # 355//113 (more precise)
println(float(r))  # 3.1415929...

Combining Complex and Rational Numbers

# Complex numbers can use rationals
z = (1//2) + (3//4)im
println(z)  # 1//2 + 3//4*im

# Operations
z1 = (1//2) + (1//3)im
z2 = (1//4) + (1//6)im

println(z1 + z2)  # 3//4 + 1//2*im
println(z1 * z2)  # 7//72 + 1//6*im

Numerical Precision

BigInt and BigFloat

# Big integers
big_int = big(10)^100
println(big_int)

# Big floats
big_float = big(π)
println(big_float)  # High precision π

# Set precision
setprecision(256) do
    println(big(π))  # 256-bit precision
end

# Big integer rationals
big_rational = big(1) // big(7)
println(big_rational)

Precision Control

# Check precision
println(precision(BigFloat))  # Current precision (bits)

# Set global precision
setprecision(128)
x = big(1.0) / big(3.0)
println(x)

# Restore default precision
setprecision(256)

Utility Functions

Type Conversion

# Complex related
z = 3 + 4im
println(Complex{Float64}(z))  # Convert to ComplexF64
println(real(z))              # Real part
println(imag(z))              # Imaginary part

# Rational related
r = 3//4
println(float(r))             # Convert to float
println(Int(2//1))            # Convert to integer (must be integer value)

Type Checking

# Complex checking
z = 3 + 4im
println(isa(z, Complex))  # true
println(isreal(z))        # false
println(isreal(3 + 0im))  # true

# Rational checking
r = 3//4
println(isa(r, Rational))  # true
println(isinteger(r))      # false
println(isinteger(4//2))   # true

Application Examples

Example 1: Solving Quadratic Equations

function solve_quadratic(a, b, c)
    discriminant = b^2 - 4*a*c
    
    if discriminant < 0
        # Complex roots
        sqrt_d = sqrt(Complex(discriminant))
    else
        sqrt_d = sqrt(discriminant)
    end
    
    x1 = (-b + sqrt_d) / (2a)
    x2 = (-b - sqrt_d) / (2a)
    
    return (x1, x2)
end

# Real roots
println(solve_quadratic(1, -5, 6))  # (3.0, 2.0)

# Complex roots
println(solve_quadratic(1, 2, 5))   # (-1.0 + 2.0im, -1.0 - 2.0im)

Example 2: Fraction Calculator

function fraction_calc()
    # Exact calculation using rationals
    result = 1//2 + 1//3 + 1//4 + 1//5 + 1//6
    
    println("1/2 + 1/3 + 1/4 + 1/5 + 1/6 = $result")
    println("Approximately $(float(result))")
end

fraction_calc()
# Output:
# 1/2 + 1/3 + 1/4 + 1/5 + 1/6 = 29//20
# Approximately 1.45

Example 3: Complex Number Plotting (requires Plots package)

using Plots

# Plot complex numbers on unit circle
θ = range(0, 2π, length=100)
z = cis.(θ)  # e^(iθ)

plot(real.(z), imag.(z), 
     aspect_ratio=:equal,
     xlabel="Real", 
     ylabel="Imaginary",
     title="Unit Circle")

Next Steps

After learning complex and rational numbers, continue with:

• Basic Operators - Arithmetic operators in detail
• Math Functions - Built-in math functions
• Arrays - Complex number array operations