Julia 复数和有理数

Julia 原生支持复数和有理数运算，这使得科学计算和数学运算变得更加简单直观。

复数

创建复数

Julia 使用 im 表示虚数单位（i = √-1）：

# 基本创建
z1 = 3 + 4im
z2 = 1 - 2im

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

# 使用 Complex 构造函数
z3 = Complex(3, 4)     # 3 + 4im
z4 = Complex(5.0, -2.0)  # 5.0 - 2.0im

# 纯虚数
z5 = 2im               # 0 + 2im
z6 = Complex(0, 3)     # 0 + 3im

# 从实数创建
z7 = Complex(5)        # 5 + 0im

复数属性

z = 3 + 4im

# 获取实部和虚部
println(real(z))  # 3
println(imag(z))  # 4

# 复共轭
println(conj(z))  # 3 - 4im

# 模（绝对值）
println(abs(z))   # 5.0（√(3² + 4²)）

# 模的平方
println(abs2(z))  # 25（3² + 4²，避免开方）

# 辐角（弧度）
println(angle(z)) # 0.9272...（atan(4/3)）

复数运算

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

# 加法
println(z1 + z2)  # 4 + 2im

# 减法
println(z1 - z2)  # 2 + 6im

# 乘法
println(z1 * z2)  # 11 - 2im

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

# 幂运算
println(z1^2)     # -7 + 24im
println(z1^0.5)   # 平方根

# 复数与实数运算
println(z1 + 5)   # 8 + 4im
println(z1 * 2)   # 6 + 8im

复数函数

z = 1 + 1im

# 指数和对数
println(exp(z))   # e^z
println(log(z))   # 自然对数

# 三角函数
println(sin(z))
println(cos(z))
println(tan(z))

# 双曲函数
println(sinh(z))
println(cosh(z))
println(tanh(z))

# 平方根
println(sqrt(-1 + 0im))  # 0.0 + 1.0im
println(sqrt(Complex(-1)))  # 同上

极坐标形式

# 从极坐标创建复数
r = 5.0          # 模
θ = π/4          # 辐角

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

# 使用 cis 函数（cos + i*sin）
z = 5 * cis(π/4)

# 提取极坐标
println(abs(z))    # 模: 5.0
println(angle(z))  # 辐角: 0.785...（π/4）

欧拉公式

# e^(iπ) + 1 ≈ 0（欧拉恒等式）
result = exp(im * π) + 1
println(result)      # 0.0 + 1.2246...e-16im（约等于0）
println(isapprox(result, 0, atol=1e-10))  # true

有理数

创建有理数

使用 // 运算符创建有理数：

# 基本创建
r1 = 3//4
r2 = 2//3

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

# 自动约分
r3 = 6//8
println(r3)  # 3//4（自动约分）

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

# 负有理数
r5 = -3//4
r6 = 3//-4
println(r5)  # -3//4
println(r6)  # -3//4（符号移到分子）

有理数属性

r = 3//4

# 获取分子和分母
println(numerator(r))    # 3
println(denominator(r))  # 4

# 转换为浮点数
println(float(r))        # 0.75
println(Float64(r))      # 0.75

有理数运算

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

# 加法
println(r1 + r2)  # 17//12

# 减法
println(r1 - r2)  # 1//12

# 乘法
println(r1 * r2)  # 1//2

# 除法
println(r1 / r2)  # 9//8

# 幂运算
println(r1^2)     # 9//16
println(r1^-1)    # 4//3（倒数）

# 与整数运算
println(r1 + 1)   # 7//4
println(r1 * 2)   # 3//2

有理数比较

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

# 相等比较（自动约分后比较）
println(r1 == r2)  # true

# 大小比较
println(1//3 < 1//2)  # true
println(2//3 > 1//2)  # true

# 与浮点数比较
println(1//2 == 0.5)  # true
println(1//3 == 1/3)  # false（浮点精度问题）

有理数的优势

有理数可以精确表示分数，避免浮点数精度问题：

# 浮点数精度问题
a = 0.1 + 0.2
println(a == 0.3)  # false！
println(a)         # 0.30000000000000004

# 有理数精确计算
b = 1//10 + 2//10
println(b == 3//10)  # true
println(b)           # 3//10

从浮点数创建有理数

# rationalize 将浮点数转为有理数
r = rationalize(0.75)
println(r)  # 3//4

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

# 指定容差
r = rationalize(π, tol=1e-3)
println(r)  # 201//64
println(float(r))  # 3.140625

r = rationalize(π, tol=1e-6)
println(r)  # 355//113（更精确）
println(float(r))  # 3.1415929...

复数与有理数结合

# 复数可以使用有理数
z = (1//2) + (3//4)im
println(z)  # 1//2 + 3//4*im

# 运算
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

数值精度

BigInt 和 BigFloat

# 大整数
big_int = big(10)^100
println(big_int)

# 大浮点数
big_float = big(π)
println(big_float)  # 高精度 π

# 设置精度
setprecision(256) do
    println(big(π))  # 256位精度
end

# 大整数有理数
big_rational = big(1) // big(7)
println(big_rational)

精度控制

# 检查精度
println(precision(BigFloat))  # 当前精度（位数）

# 设置全局精度
setprecision(128)
x = big(1.0) / big(3.0)
println(x)

# 恢复默认精度
setprecision(256)

实用函数

类型转换

# 复数相关
z = 3 + 4im
println(Complex{Float64}(z))  # 转为 ComplexF64
println(real(z))              # 实部
println(imag(z))              # 虚部

# 有理数相关
r = 3//4
println(float(r))             # 转为浮点数
println(Int(2//1))            # 转为整数（必须是整数值）

类型检查

# 复数检查
z = 3 + 4im
println(isa(z, Complex))  # true
println(isreal(z))        # false
println(isreal(3 + 0im))  # true

# 有理数检查
r = 3//4
println(isa(r, Rational))  # true
println(isinteger(r))      # false
println(isinteger(4//2))   # true

应用示例

示例1：求解二次方程

function solve_quadratic(a, b, c)
    discriminant = b^2 - 4*a*c
    
    if discriminant < 0
        # 复数根
        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

# 实根
println(solve_quadratic(1, -5, 6))  # (3.0, 2.0)

# 复根
println(solve_quadratic(1, 2, 5))   # (-1.0 + 2.0im, -1.0 - 2.0im)

示例2：分数计算器

function fraction_calc()
    # 使用有理数进行精确计算
    result = 1//2 + 1//3 + 1//4 + 1//5 + 1//6
    
    println("1/2 + 1/3 + 1/4 + 1/5 + 1/6 = $result")
    println("约等于 $(float(result))")
end

fraction_calc()
# 输出：
# 1/2 + 1/3 + 1/4 + 1/5 + 1/6 = 29//20
# 约等于 1.45

示例3：复数绘图（需要 Plots 包）

using Plots

# 绘制单位圆上的复数
θ = range(0, 2π, length=100)
z = cis.(θ)  # e^(iθ)

plot(real.(z), imag.(z), 
     aspect_ratio=:equal,
     xlabel="实部", 
     ylabel="虚部",
     title="单位圆")

下一步

学习完复数和有理数后，请继续学习：

• 基本运算符 - 算术运算符详解
• 数学函数 - 内置数学函数
• 数组 - 复数数组操作