Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Go math/cmplx 包详解

概述

math/cmplx 包提供了复数的基本常数和数学函数。该包专门用于处理复数运算，所有函数都接受 complex128 类型的参数并返回相应的结果。复数在信号处理、控制系统、电气工程和物理学等领域有广泛应用。

重要说明：

  • ✓ 所有函数操作 complex128 类型
  • ✓ 支持复数的三角函数、双曲函数、指数、对数等运算
  • ✓ 提供极坐标和直角坐标转换
  • ✓ 支持特殊值（NaN、Inf）检测

包导入

import "math/cmplx"

基本使用

1. 创建和操作复数

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    // 创建复数
    a := complex(3, 4)  // 3+4i
    b := complex(1, -2) // 1-2i
    
    // 基本运算
    sum := a + b
    diff := a - b
    product := a * b
    quotient := a / b
    
    fmt.Printf("和：%v\n", sum)
    fmt.Printf("差：%v\n", diff)
    fmt.Printf("积：%v\n", product)
    fmt.Printf("商：%v\n", quotient)
    
    // 使用 cmplx 包函数
    fmt.Printf("模：%v\n", cmplx.Abs(a))
    fmt.Printf("相位：%v\n", cmplx.Phase(a))
}

2. 极坐标转换

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // 直角坐标转极坐标
    z := complex(1, 1)
    r, theta := cmplx.Polar(z)
    fmt.Printf("极坐标：r=%v, θ=%v\n", r, theta)
    
    // 极坐标转直角坐标
    z2 := cmplx.Rect(r, theta)
    fmt.Printf("直角坐标：%v\n", z2)
}

3. 复数函数

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    z := complex(1, 1)
    
    // 指数和对数
    fmt.Printf("e^z = %v\n", cmplx.Exp(z))
    fmt.Printf("ln(z) = %v\n", cmplx.Log(z))
    
    // 三角函数
    fmt.Printf("sin(z) = %v\n", cmplx.Sin(z))
    fmt.Printf("cos(z) = %v\n", cmplx.Cos(z))
    
    // 平方根
    fmt.Printf("√z = %v\n", cmplx.Sqrt(z))
}

一、常量

数学常数

说明： math/cmplx 包使用 math 包中的数学常数：

常数值说明
math.Pi3.141592653589793…圆周率
math.E2.718281828459045…自然对数的底
math.Phi1.618033988749895…黄金比例
math.Sqrt21.414213562373095…√2
math.SqrtE1.648721270700128…√e
math.SqrtPi1.772453850905516…√π

示例：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // 使用 Pi 创建复数
    z := cmplx.Rect(1, math.Pi)
    fmt.Printf("e^(iπ) = %v\n", z) // -1+0i
    
    // 使用 E
    fmt.Printf("e = %v\n", math.E)
}

二、基础函数

Abs

定义：

func Abs(x complex128) float64

说明：

  • 功能：返回复数的模（绝对值）
  • 参数：x - 复数
  • 返回值：float64 - 模长
  • 公式：|a+bi| = √(a² + b²)

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    z := complex(3, 4)
    abs := cmplx.Abs(z)
    fmt.Printf("|3+4i| = %v\n", abs) // 5
    
    z2 := complex(1, 1)
    fmt.Printf("|1+i| = %v\n", cmplx.Abs(z2)) // 1.4142135623730951
}

Phase

定义：

func Phase(x complex128) float64

说明：

  • 功能：返回复数的相位（幅角）
  • 参数：x - 复数
  • 返回值：float64 - 相位（弧度）
  • 范围：[-π, π]

示例：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    z := complex(1, 1)
    phase := cmplx.Phase(z)
    fmt.Printf("arg(1+i) = %v rad = %v°\n", phase, phase*180/math.Pi)
    
    z2 := complex(-1, 0)
    fmt.Printf("arg(-1) = %v rad = %v°\n", cmplx.Phase(z2), cmplx.Phase(z2)*180/math.Pi)
}

Polar

定义：

func Polar(x complex128) (r, theta float64)

说明：

  • 功能：返回复数的极坐标表示
  • 参数：x - 复数
  • 返回值：
    • r - 模（绝对值）
    • theta - 相位（[-π, π]）
  • 关系：x = r × e^(i×theta)

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    z := complex(1, 1)
    r, theta := cmplx.Polar(z)
    fmt.Printf("1+i 的极坐标：r=%v, θ=%v\n", r, theta)
    
    z2 := complex(0, 1)
    r2, theta2 := cmplx.Polar(z2)
    fmt.Printf("i 的极坐标：r=%v, θ=%v\n", r2, theta2)
}

Rect

定义：

func Rect(r, theta float64) complex128

说明：

  • 功能：从极坐标创建复数
  • 参数：
    • r - 模
    • theta - 相位（弧度）
  • 返回值：complex128 - 复数
  • 公式：r × e^(i×theta) = r×(cos(theta) + i×sin(theta))

示例：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // 从极坐标创建复数
    z := cmplx.Rect(1, math.Pi/2)
    fmt.Printf("Rect(1, π/2) = %v\n", z) // 0+1i
    
    z2 := cmplx.Rect(2, math.Pi)
    fmt.Printf("Rect(2, π) = %v\n", z2) // -2+0i
}

Conj

定义：

func Conj(x complex128) complex128

说明：

  • 功能：返回复数的共轭
  • 参数：x - 复数
  • 返回值：complex128 - 共轭复数
  • 公式：conj(a+bi) = a-bi

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    z := complex(3, 4)
    conj := cmplx.Conj(z)
    fmt.Printf("conj(3+4i) = %v\n", conj) // 3-4i
    
    z2 := complex(1, -1)
    fmt.Printf("conj(1-i) = %v\n", cmplx.Conj(z2)) // 1+i
}

三、特殊值函数

NaN

定义：

func NaN() complex128

说明：

  • 功能：返回复数 “Not a Number” 值
  • 返回值：complex128 - NaN 复数
  • 用途：表示未定义或不可表示的值

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    nan := cmplx.NaN()
    fmt.Printf("NaN: %v\n", nan)
    fmt.Printf("IsNaN: %v\n", cmplx.IsNaN(nan))
}

IsNaN

定义：

func IsNaN(x complex128) bool

说明：

  • 功能：检查复数是否为 NaN
  • 参数：x - 复数
  • 返回值：bool - 如果实部或虚部为 NaN 返回 true
  • 注意：不检查无穷大

示例：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    nan := cmplx.NaN()
    fmt.Printf("IsNaN(NaN): %v\n", cmplx.IsNaN(nan)) // true
    
    z := complex(math.NaN(), 0)
    fmt.Printf("IsNaN(NaN+0i): %v\n", cmplx.IsNaN(z)) // true
    
    z2 := complex(1, 2)
    fmt.Printf("IsNaN(1+2i): %v\n", cmplx.IsNaN(z2)) // false
}

Inf

定义：

func Inf() complex128

说明：

  • 功能：返回复数无穷大
  • 返回值：complex128 - complex(+Inf, +Inf)
  • 用途：表示无穷大的值

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    inf := cmplx.Inf()
    fmt.Printf("Inf: %v\n", inf)
    fmt.Printf("IsInf: %v\n", cmplx.IsInf(inf))
}

IsInf

定义：

func IsInf(x complex128) bool

说明：

  • 功能：检查复数是否为无穷大
  • 参数：x - 复数
  • 返回值：bool - 如果实部或虚部为无穷大返回 true
  • 注意：包括正负无穷大

示例：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    inf := cmplx.Inf()
    fmt.Printf("IsInf(Inf): %v\n", cmplx.IsInf(inf)) // true
    
    z := complex(math.Inf(1), 0)
    fmt.Printf("IsInf(+Inf+0i): %v\n", cmplx.IsInf(z)) // true
    
    z2 := complex(0, math.Inf(-1))
    fmt.Printf("IsInf(0-Inf i): %v\n", cmplx.IsInf(z2)) // true
    
    z3 := complex(1, 2)
    fmt.Printf("IsInf(1+2i): %v\n", cmplx.IsInf(z3)) // false
}

四、幂和对数函数

Sqrt

定义：

func Sqrt(x complex128) complex128

说明：

  • 功能：返回复数的平方根
  • 参数：x - 复数
  • 返回值：complex128 - 平方根
  • 特点：返回值的实部 ≥ 0，虚部符号与 x 的虚部相同

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    // 负数的平方根
    z := complex(-1, 0)
    sqrt := cmplx.Sqrt(z)
    fmt.Printf("√(-1) = %v\n", sqrt) // 0+1i
    
    // 复数的平方根
    z2 := complex(3, 4)
    sqrt2 := cmplx.Sqrt(z2)
    fmt.Printf("√(3+4i) = %v\n", sqrt2)
    
    // 验证
    fmt.Printf("验证：%v × %v = %v\n", sqrt2, sqrt2, sqrt2*sqrt2)
}

Exp

定义：

func Exp(x complex128) complex128

说明：

  • 功能：返回 e^x（e 的 x 次幂）
  • 参数：x - 复数
  • 返回值：complex128 - e^x
  • 公式：e^(a+bi) = e^a × (cos(b) + i×sin(b))

示例：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // 欧拉公式：e^(iπ) = -1
    z := complex(0, math.Pi)
    exp := cmplx.Exp(z)
    fmt.Printf("e^(iπ) = %v\n", exp) // -1+0i
    
    // e^(1+i)
    z2 := complex(1, 1)
    exp2 := cmplx.Exp(z2)
    fmt.Printf("e^(1+i) = %v\n", exp2)
}

Log

定义：

func Log(x complex128) complex128

说明：

  • 功能：返回复数的自然对数
  • 参数：x - 复数
  • 返回值：complex128 - ln(x)
  • 公式：ln(a+bi) = ln(|z|) + i×arg(z)

示例：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // ln(e) = 1
    z := complex(math.E, 0)
    log := cmplx.Log(z)
    fmt.Printf("ln(e) = %v\n", log) // 1+0i
    
    // ln(-1) = iπ
    z2 := complex(-1, 0)
    log2 := cmplx.Log(z2)
    fmt.Printf("ln(-1) = %v\n", log2) // 0+3.14159...i
    
    // ln(e^(1+i)) = 1+i
    z3 := complex(1, 1)
    exp := cmplx.Exp(z3)
    log3 := cmplx.Log(exp)
    fmt.Printf("ln(e^(1+i)) = %v\n", log3)
}

Log10

定义：

func Log10(x complex128) complex128

说明：

  • 功能：返回复数的常用对数（以 10 为底）
  • 参数：x - 复数
  • 返回值：complex128 - log₁₀(x)
  • 公式：log₁₀(x) = ln(x) / ln(10)

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    // log₁₀(100) = 2
    z := complex(100, 0)
    log10 := cmplx.Log10(z)
    fmt.Printf("log₁₀(100) = %v\n", log10) // 2+0i
    
    // log₁₀(1000) = 3
    z2 := complex(1000, 0)
    fmt.Printf("log₁₀(1000) = %v\n", cmplx.Log10(z2))
}

Pow

定义：

func Pow(x, y complex128) complex128

说明：

  • 功能：返回 x^y（x 的 y 次幂）
  • 参数：
    • x - 底数
    • y - 指数
  • 返回值：complex128 - x^y
  • 公式：x^y = e^(y×ln(x))
  • 特例：
    • Pow(0, ±0) = 1+0i
    • Pow(0, c) = 根据情况返回 Inf+0i 或 Inf+Infi

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    // 2^3 = 8
    base := complex(2, 0)
    exp := complex(3, 0)
    result := cmplx.Pow(base, exp)
    fmt.Printf("2^3 = %v\n", result)
    
    // i^2 = -1
    i := complex(0, 1)
    result2 := cmplx.Pow(i, complex(2, 0))
    fmt.Printf("i^2 = %v\n", result2)
    
    // (1+i)^2 = 2i
    z := complex(1, 1)
    result3 := cmplx.Pow(z, complex(2, 0))
    fmt.Printf("(1+i)^2 = %v\n", result3)
}

五、三角函数

Sin

定义：

func Sin(x complex128) complex128

说明：

  • 功能：返回复数的正弦
  • 参数：x - 复数
  • 返回值：complex128 - sin(x)
  • 公式：sin(a+bi) = sin(a)cosh(b) + i×cos(a)sinh(b)

示例：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // sin(π/2) = 1
    z := complex(math.Pi/2, 0)
    sin := cmplx.Sin(z)
    fmt.Printf("sin(π/2) = %v\n", sin)
    
    // sin(i) = i×sinh(1)
    z2 := complex(0, 1)
    sin2 := cmplx.Sin(z2)
    fmt.Printf("sin(i) = %v\n", sin2)
}

Cos

定义：

func Cos(x complex128) complex128

说明：

  • 功能：返回复数的余弦
  • 参数：x - 复数
  • 返回值：complex128 - cos(x)
  • 公式：cos(a+bi) = cos(a)cosh(b) - i×sin(a)sinh(b)

示例：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // cos(π) = -1
    z := complex(math.Pi, 0)
    cos := cmplx.Cos(z)
    fmt.Printf("cos(π) = %v\n", cos)
    
    // cos(i) = cosh(1)
    z2 := complex(0, 1)
    cos2 := cmplx.Cos(z2)
    fmt.Printf("cos(i) = %v\n", cos2)
}

Tan

定义：

func Tan(x complex128) complex128

说明：

  • 功能：返回复数的正切
  • 参数：x - 复数
  • 返回值：complex128 - tan(x)
  • 公式：tan(x) = sin(x) / cos(x)

示例：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // tan(π/4) = 1
    z := complex(math.Pi/4, 0)
    tan := cmplx.Tan(z)
    fmt.Printf("tan(π/4) = %v\n", tan)
}

Cot

定义：

func Cot(x complex128) complex128

说明：

  • 功能：返回复数的余切
  • 参数：x - 复数
  • 返回值：complex128 - cot(x)
  • 公式：cot(x) = 1 / tan(x) = cos(x) / sin(x)

示例：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // cot(π/4) = 1
    z := complex(math.Pi/4, 0)
    cot := cmplx.Cot(z)
    fmt.Printf("cot(π/4) = %v\n", cot)
}

六、反三角函数

Asin

定义：

func Asin(x complex128) complex128

说明：

  • 功能：返回复数的反正弦
  • 参数：x - 复数
  • 返回值：complex128 - arcsin(x)

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    // arcsin(1) = π/2
    z := complex(1, 0)
    asin := cmplx.Asin(z)
    fmt.Printf("arcsin(1) = %v\n", asin)
    
    // arcsin(i)
    z2 := complex(0, 1)
    asin2 := cmplx.Asin(z2)
    fmt.Printf("arcsin(i) = %v\n", asin2)
}

Acos

定义：

func Acos(x complex128) complex128

说明：

  • 功能：返回复数的反余弦
  • 参数：x - 复数
  • 返回值：complex128 - arccos(x)

示例：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // arccos(1) = 0
    z := complex(1, 0)
    acos := cmplx.Acos(z)
    fmt.Printf("arccos(1) = %v\n", acos)
    
    // arccos(-1) = π
    z2 := complex(-1, 0)
    acos2 := cmplx.Acos(z2)
    fmt.Printf("arccos(-1) = %v\n", acos2)
}

Atan

定义：

func Atan(x complex128) complex128

说明：

  • 功能：返回复数的反正切
  • 参数：x - 复数
  • 返回值：complex128 - arctan(x)

示例：

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // arctan(1) = π/4
    z := complex(1, 0)
    atan := cmplx.Atan(z)
    fmt.Printf("arctan(1) = %v\n", atan)
}

七、双曲函数

Sinh

定义：

func Sinh(x complex128) complex128

说明：

  • 功能：返回复数的双曲正弦
  • 参数：x - 复数
  • 返回值：complex128 - sinh(x)
  • 公式：sinh(x) = (e^x - e^(-x)) / 2

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    // sinh(0) = 0
    z := complex(0, 0)
    sinh := cmplx.Sinh(z)
    fmt.Printf("sinh(0) = %v\n", sinh)
    
    // sinh(1)
    z2 := complex(1, 0)
    sinh2 := cmplx.Sinh(z2)
    fmt.Printf("sinh(1) = %v\n", sinh2)
}

Cosh

定义：

func Cosh(x complex128) complex128

说明：

  • 功能：返回复数的双曲余弦
  • 参数：x - 复数
  • 返回值：complex128 - cosh(x)
  • 公式：cosh(x) = (e^x + e^(-x)) / 2

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    // cosh(0) = 1
    z := complex(0, 0)
    cosh := cmplx.Cosh(z)
    fmt.Printf("cosh(0) = %v\n", cosh)
    
    // cosh(1)
    z2 := complex(1, 0)
    cosh2 := cmplx.Cosh(z2)
    fmt.Printf("cosh(1) = %v\n", cosh2)
}

Tanh

定义：

func Tanh(x complex128) complex128

说明：

  • 功能：返回复数的双曲正切
  • 参数：x - 复数
  • 返回值：complex128 - tanh(x)
  • 公式：tanh(x) = sinh(x) / cosh(x)

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    // tanh(0) = 0
    z := complex(0, 0)
    tanh := cmplx.Tanh(z)
    fmt.Printf("tanh(0) = %v\n", tanh)
}

八、反双曲函数

Asinh

定义：

func Asinh(x complex128) complex128

说明：

  • 功能：返回复数的反双曲正弦
  • 参数：x - 复数
  • 返回值：complex128 - arcsinh(x)

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    // arcsinh(0) = 0
    z := complex(0, 0)
    asinh := cmplx.Asinh(z)
    fmt.Printf("arcsinh(0) = %v\n", asinh)
}

Acosh

定义：

func Acosh(x complex128) complex128

说明：

  • 功能：返回复数的反双曲余弦
  • 参数：x - 复数
  • 返回值：complex128 - arccosh(x)

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    // arccosh(1) = 0
    z := complex(1, 0)
    acosh := cmplx.Acosh(z)
    fmt.Printf("arccosh(1) = %v\n", acosh)
}

Atanh

定义：

func Atanh(x complex128) complex128

说明：

  • 功能：返回复数的反双曲正切
  • 参数：x - 复数
  • 返回值：complex128 - arctanh(x)

示例：

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    // arctanh(0) = 0
    z := complex(0, 0)
    atanh := cmplx.Atanh(z)
    fmt.Printf("arctanh(0) = %v\n", atanh)
}

九、典型示例

示例 1：复数的基本运算

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    a := complex(3, 4)
    b := complex(1, -2)
    
    fmt.Printf("a = %v\n", a)
    fmt.Printf("b = %v\n", b)
    fmt.Printf("a + b = %v\n", a+b)
    fmt.Printf("a - b = %v\n", a-b)
    fmt.Printf("a × b = %v\n", a*b)
    fmt.Printf("a ÷ b = %v\n", a/b)
    
    fmt.Printf("|a| = %v\n", cmplx.Abs(a))
    fmt.Printf("conj(a) = %v\n", cmplx.Conj(a))
    fmt.Printf("arg(a) = %v rad\n", cmplx.Phase(a))
}

运行：

$ ./program
a = (3+4i)
b = (1-2i)
a + b = (4+2i)
a - b = (2+6i)
a × b = (11-2i)
a ÷ b = (-1+2i)
|a| = 5
conj(a) = (3-4i)
arg(a) = 0.9272952180016122 rad

示例 2：欧拉公式验证

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // 欧拉公式：e^(iθ) = cos(θ) + i×sin(θ)
    theta := math.Pi / 4 // 45 度
    
    // 方法 1：使用 Exp
    z1 := cmplx.Exp(complex(0, theta))
    
    // 方法 2：使用 Rect
    z2 := cmplx.Rect(1, theta)
    
    // 方法 3：使用欧拉公式
    z3 := complex(math.Cos(theta), math.Sin(theta))
    
    fmt.Printf("e^(iπ/4) = %v\n", z1)
    fmt.Printf("Rect(1, π/4) = %v\n", z2)
    fmt.Printf("cos(π/4) + i×sin(π/4) = %v\n", z3)
    
    // 验证 e^(iπ) = -1
    euler := cmplx.Exp(complex(0, math.Pi))
    fmt.Printf("\ne^(iπ) = %v\n", euler)
    fmt.Printf("实部接近 -1: %v\n", math.Abs(real(euler)+1) < 1e-10)
}

示例 3：复数的极坐标表示

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // 创建几个复数
    numbers := []complex128{
        complex(1, 0),
        complex(0, 1),
        complex(-1, 0),
        complex(0, -1),
        complex(1, 1),
        complex(-1, -1),
    }
    
    fmt.Println("复数\t\t模\t\t相位 (rad)\t相位 (°)")
    fmt.Println("---------------------------------------------------")
    
    for _, z := range numbers {
        r, theta := cmplx.Polar(z)
        deg := theta * 180 / math.Pi
        fmt.Printf("%v\t%.4f\t\t%.4f\t\t%.2f\n", z, r, theta, deg)
    }
}

示例 4：复数幂运算

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    // 计算 i 的幂
    i := complex(0, 1)
    
    fmt.Println("i 的幂：")
    for n := 1; n <= 8; n++ {
        result := cmplx.Pow(i, complex(float64(n), 0))
        fmt.Printf("i^%d = %v\n", n, result)
    }
    
    // 计算 (1+i) 的幂
    fmt.Println("\n(1+i) 的幂：")
    z := complex(1, 1)
    for n := 1; n <= 5; n++ {
        result := cmplx.Pow(z, complex(float64(n), 0))
        fmt.Printf("(1+i)^%d = %v\n", n, result)
    }
}

示例 5：复数对数和指数

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // 验证：ln(e^z) = z
    z := complex(1, 1)
    exp := cmplx.Exp(z)
    log := cmplx.Log(exp)
    
    fmt.Printf("z = %v\n", z)
    fmt.Printf("e^z = %v\n", exp)
    fmt.Printf("ln(e^z) = %v\n", log)
    fmt.Printf("验证：z == ln(e^z) ? %v\n", cmplx.Abs(z-log) < 1e-10)
    
    // 特殊值
    fmt.Println("\n特殊值：")
    fmt.Printf("ln(-1) = %v\n", cmplx.Log(complex(-1, 0)))
    fmt.Printf("ln(i) = %v\n", cmplx.Log(complex(0, 1)))
    fmt.Printf("e^(iπ) = %v\n", cmplx.Exp(complex(0, math.Pi)))
}

示例 6：复数三角函数

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // 验证三角恒等式：sin²(x) + cos²(x) = 1
    x := complex(0.5, 0.3)
    sin := cmplx.Sin(x)
    cos := cmplx.Cos(x)
    
    sin2 := sin * sin
    cos2 := cos * cos
    sum := sin2 + cos2
    
    fmt.Printf("x = %v\n", x)
    fmt.Printf("sin(x) = %v\n", sin)
    fmt.Printf("cos(x) = %v\n", cos)
    fmt.Printf("sin²(x) + cos²(x) = %v\n", sum)
    fmt.Printf("接近 1 ? %v\n", cmplx.Abs(sum-1) < 1e-10)
    
    // 验证：tan(x) = sin(x) / cos(x)
    tan := cmplx.Tan(x)
    tan2 := sin / cos
    fmt.Printf("\ntan(x) = %v\n", tan)
    fmt.Printf("sin(x)/cos(x) = %v\n", tan2)
    fmt.Printf("相等？%v\n", cmplx.Abs(tan-tan2) < 1e-10)
}

示例 7：信号处理中的复数应用

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

// 表示交流电信号
func ACSignal(amplitude, frequency, phase float64, t float64) complex128 {
    // V(t) = Vm × e^(j(ωt + φ))
    omega := 2 * math.Pi * frequency
    return cmplx.Rect(amplitude, omega*t+phase)
}

func main() {
    // 50Hz 交流电，振幅 220V，初相位 0
    amplitude := 220.0
    frequency := 50.0
    phase := 0.0
    
    t := 0.01 // 10ms
    
    signal := ACSignal(amplitude, frequency, phase, t)
    
    fmt.Printf("交流电信号分析：\n")
    fmt.Printf("时间：%.4f s\n", t)
    fmt.Printf("复数形式：%v V\n", signal)
    fmt.Printf("振幅：%.2f V\n", cmplx.Abs(signal))
    fmt.Printf("相位：%.4f rad (%.2f°)\n", cmplx.Phase(signal), cmplx.Phase(signal)*180/math.Pi)
    fmt.Printf("实部（瞬时值）：%.2f V\n", real(signal))
}

示例 8：复数在电路分析中的应用

package main

import (
    "fmt"
    "math"
    "math/cmplx"
)

func main() {
    // RLC 串联电路的阻抗计算
    // Z = R + j(ωL - 1/(ωC))
    
    R := 100.0          // 电阻 100Ω
    L := 0.1            // 电感 0.1H
    C := 10e-6          // 电容 10μF
    f := 50.0           // 频率 50Hz
    omega := 2 * math.Pi * f
    
    // 感抗和容抗
    XL := omega * L
    XC := 1 / (omega * C)
    
    // 复阻抗
    Z := complex(R, XL-XC)
    
    fmt.Printf("RLC 串联电路分析：\n")
    fmt.Printf("频率：%.2f Hz\n", f)
    fmt.Printf("电阻：%.2f Ω\n", R)
    fmt.Printf("感抗：%.2f Ω\n", XL)
    fmt.Printf("容抗：%.2f Ω\n", XC)
    fmt.Printf("\n复阻抗：%v Ω\n", Z)
    fmt.Printf("阻抗模：%.2f Ω\n", cmplx.Abs(Z))
    fmt.Printf("阻抗角：%.4f rad (%.2f°)\n", cmplx.Phase(Z), cmplx.Phase(Z)*180/math.Pi)
    
    // 假设电压 220V
    V := complex(220, 0)
    I := V / Z
    
    fmt.Printf("\n电压：%v V\n", V)
    fmt.Printf("电流：%v A\n", I)
    fmt.Printf("电流大小：%.4f A\n", cmplx.Abs(I))
}

十、最佳实践

1. 使用合适的精度

// ✓ 好的做法：使用 complex128
z := complex(1.0, 2.0)

// 注意：cmplx 包只支持 complex128
// complex64 需要转换为 complex128

2. 检查特殊值

// ✓ 好的做法：检查 NaN 和 Inf
result := cmplx.Sqrt(z)
if cmplx.IsNaN(result) || cmplx.IsInf(result) {
    // 处理特殊情况
}

3. 极坐标和直角坐标转换

// ✓ 好的做法：使用 Polar 和 Rect
r, theta := cmplx.Polar(z)
z2 := cmplx.Rect(r, theta)

// 验证转换
fmt.Println(cmplx.Abs(z - z2) < 1e-10)

4. 使用共轭简化计算

// 复数除法：a/b = a×conj(b) / |b|²
a := complex(3, 4)
b := complex(1, 2)
quotient := a * cmplx.Conj(b) / cmplx.Abs(b)*cmplx.Abs(b)

十一、与其他包配合

1. 与 math 包配合

import (
    "math"
    "math/cmplx"
)

// 使用 math 包的常数
z := cmplx.Rect(1, math.Pi)

// 使用 math 包的函数处理实部虚部
real_part := math.Sin(real(z))
imag_part := math.Cos(imag(z))

2. 与 fmt 包配合

import "fmt"

z := complex(1, 2)
fmt.Printf("复数：%v\n", z)
fmt.Printf("实部：%.2f, 虚部：%.2f\n", real(z), imag(z))

十二、快速参考

基础函数

函数参数返回值功能
Abscomplex128float64模
Phasecomplex128float64相位
Polarcomplex128(r, θ float64)极坐标
Rect(r, θ float64)complex128直角坐标
Conjcomplex128complex128共轭

特殊值

函数返回值功能
NaNcomplex128NaN 值
IsNaNbool检查 NaN
Infcomplex128无穷大
IsInfbool检查无穷大

幂和对数

函数功能
Sqrt平方根
Expe^x
Log自然对数
Log10常用对数
Powx^y

三角函数

函数功能
Sin正弦
Cos余弦
Tan正切
Cot余切

反三角函数

函数功能
Asin反正弦
Acos反余弦
Atan反正切

双曲函数

函数功能
Sinh双曲正弦
Cosh双曲余弦
Tanh双曲正切

反双曲函数

函数功能
Asinh反双曲正弦
Acosh反双曲余弦
Atanh反双曲正切

十三、注意事项

1. 精度问题

// 浮点数运算有精度误差
z := cmplx.Exp(complex(0, math.Pi))
fmt.Println(real(z)) // -1 + 很小的误差

2. 分支切割

// 复数函数有分支切割
// Log、Sqrt 等函数在负实轴上不连续

3. 定义域

// 某些函数在某些点无定义
// 如：Log(0)、Pow(0, 负数)

4. 性能考虑

// 复数运算比实数运算慢
// 大量计算时考虑优化算法

最后更新: 2026-04-05
Go 版本: Go 1.21+
包文档: https://pkg.go.dev/math/cmplx