#Julia Complex and Rational Numbers

# 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

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))

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

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

# 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)

# 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

# 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)

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

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

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)

# 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

# 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...

# 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

# 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)

# 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)

# 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)

# 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

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)

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

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")