Go 语言标准库 —— math 包（数学运算）

🔹 常量

自然对数的底 e

math.E

值：2.718281828459045

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("e =", math.E) // 2.718281828459045
	fmt.Println(math.Exp(1))   // 2.718281828459045（e^1）
}

圆周率 π

math.Pi

值：3.141592653589793

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("π =", math.Pi) // 3.141592653589793
	
	// 计算圆面积
	radius := 5.0
	area := math.Pi * radius * radius
	fmt.Println("圆面积:", area) // 78.53981633974483
	
	// 角度转弧度
	degrees := 180.0
	radians := degrees * math.Pi / 180
	fmt.Println("180 度 =", radians, "弧度") // π 弧度
}

平方根 2

math.Sqrt2

值：1.4142135623730951

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("√2 =", math.Sqrt2) // 1.4142135623730951
	fmt.Println(math.Sqrt(2))       // 1.4142135623730951
}

平方根 1/2

math.SqrtE

值：0.7071067811865476

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("√(1/2) =", math.SqrtE) // 0.7071067811865476
	fmt.Println(1 / math.Sqrt2)         // 0.7071067811865476
}

平方根 10

math.Sqrt10

值：3.1622776601683795

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("√10 =", math.Sqrt10) // 3.1622776601683795
	fmt.Println(math.Sqrt(10))        // 3.1622776601683795
}

ln(2)

math.Ln2

值：0.6931471805599453

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("ln(2) =", math.Ln2) // 0.6931471805599453
	fmt.Println(math.Log(2))         // 0.6931471805599453
}

ln(10)

math.Ln10

值：2.302585092994046

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("ln(10) =", math.Ln10) // 2.302585092994046
	fmt.Println(math.Log(10))          // 2.302585092994046
}

log₂(e)

math.Log2E

值：1.4426950408889634

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("log₂(e) =", math.Log2E) // 1.4426950408889634
	fmt.Println(math.Log2(math.E))       // 1.4426950408889634
}

log₁₀(e)

math.Log10E

值：0.4342944819032518

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("log₁₀(e) =", math.Log10E) // 0.4342944819032518
	fmt.Println(math.Log10(math.E))        // 0.4342944819032518
}

最大 float64 值

math.MaxFloat64

值：1.7976931348623157e+308

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxFloat64 =", math.MaxFloat64) // 1.7976931348623157e+308
	
	// 溢出示例
	overflow := math.MaxFloat64 * 2
	fmt.Println("MaxFloat64 * 2 =", overflow) // +Inf
}

最小正 float64 值

math.SmallestNonzeroFloat64

值：5e-324

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("最小正 float64 =", math.SmallestNonzeroFloat64) // 5e-324
	
	// 下溢示例
	underflow := math.SmallestNonzeroFloat64 / 2
	fmt.Println("最小值/2 =", underflow) // 0
}

最大 int

math.MaxInt

值：平台相关（32 位系统为 2147483647，64 位系统为 9223372036854775807）

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt =", math.MaxInt)
	fmt.Println("MaxInt32 =", math.MaxInt32) // 2147483647
	fmt.Println("MaxInt64 =", math.MaxInt64) // 9223372036854775807
}

最小 int

math.MinInt

值：平台相关（32 位系统为 -2147483648，64 位系统为 -9223372036854775808）

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MinInt =", math.MinInt)
	fmt.Println("MinInt32 =", math.MinInt32) // -2147483648
	fmt.Println("MinInt64 =", math.MinInt64) // -9223372036854775808
}

最大 int8

math.MaxInt8

值：127

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt8 =", math.MaxInt8) // 127
	
	var x int8 = math.MaxInt8
	fmt.Println("x =", x) // 127
	
	// 溢出
	x++
	fmt.Println("x++ =", x) // -128
}

最小 int8

math.MinInt8

值：-128

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MinInt8 =", math.MinInt8) // -128
	
	var x int8 = math.MinInt8
	fmt.Println("x =", x) // -128
	
	// 下溢
	x--
	fmt.Println("x-- =", x) // 127
}

最大 int16

math.MaxInt16

值：32767

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt16 =", math.MaxInt16) // 32767
}

最小 int16

math.MinInt16

值：-32768

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MinInt16 =", math.MinInt16) // -32768
}

最大 int32

math.MaxInt32

值：2147483647

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt32 =", math.MaxInt32) // 2147483647
}

最小 int32

math.MinInt32

值：-2147483648

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MinInt32 =", math.MinInt32) // -2147483648
}

最大 int64

math.MaxInt64

值：9223372036854775807

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt64 =", math.MaxInt64) // 9223372036854775807
}

最小 int64

math.MinInt64

值：-9223372036854775808

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MinInt64 =", math.MinInt64) // -9223372036854775808
}

最大 uint

math.MaxUint

值：平台相关

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxUint =", math.MaxUint)
	fmt.Println("MaxUint32 =", math.MaxUint32) // 4294967295
	fmt.Println("MaxUint64 =", math.MaxUint64) // 18446744073709551615
}

最大 uint8

math.MaxUint8

值：255

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxUint8 =", math.MaxUint8) // 255
	
	var x uint8 = math.MaxUint8
	x++
	fmt.Println("255 + 1 =", x) // 0（溢出）
}

最大 uint16

math.MaxUint16

值：65535

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxUint16 =", math.MaxUint16) // 65535
}

最大 uint32

math.MaxUint32

值：4294967295

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxUint32 =", math.MaxUint32) // 4294967295
}

最大 uint64

math.MaxUint64

值：18446744073709551615

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxUint64 =", math.MaxUint64) // 18446744073709551615
}

🔹 特殊值

正无穷大

math.Inf(1)

说明：sign > 0 时返回正无穷

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	posInf := math.Inf(1)
	fmt.Println("正无穷:", posInf) // +Inf
	
	// 任何正数乘以正无穷仍是正无穷
	fmt.Println("10 * +Inf =", 10*posInf) // +Inf
	
	// 判断是否为正无穷
	fmt.Println("IsInf(+Inf, 1):", math.IsInf(posInf, 1)) // true
}

负无穷大

math.Inf(-1)

说明：sign < 0 时返回负无穷

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	negInf := math.Inf(-1)
	fmt.Println("负无穷:", negInf) // -Inf
	
	// 判断是否为负无穷
	fmt.Println("IsInf(-Inf, -1):", math.IsInf(negInf, -1)) // true
}

非数字（NaN）

math.NaN()

说明：Not a Number，表示未定义或不可表示的值

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	nan := math.NaN()
	fmt.Println("NaN:", nan) // NaN
	
	// NaN 不等于任何值，包括它自己
	fmt.Println("NaN == NaN:", nan == nan) // false
	
	// 产生 NaN 的运算
	fmt.Println("0/0:", 0.0/0.0)           // NaN
	fmt.Println("√(-1):", math.Sqrt(-1))   // NaN
	fmt.Println("Inf - Inf:", math.Inf(1)-math.Inf(1)) // NaN
}

判断是否为 NaN

math.IsNaN(f float64) bool

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("IsNaN(NaN):", math.IsNaN(math.NaN()))     // true
	fmt.Println("IsNaN(1.0):", math.IsNaN(1.0))            // false
	fmt.Println("IsNaN(Inf):", math.IsNaN(math.Inf(1)))    // false
	
	// 实际应用：检查计算结果
	result := math.Sqrt(-1)
	if math.IsNaN(result) {
		fmt.Println("计算结果为 NaN")
	}
}

判断是否为无穷大

math.IsInf(f float64, sign int) bool

说明：sign = 0 检查任意无穷，sign > 0 检查正无穷，sign < 0 检查负无穷

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	posInf := math.Inf(1)
	negInf := math.Inf(-1)
	
	// 检查正无穷
	fmt.Println("IsInf(+Inf, 1):", math.IsInf(posInf, 1))  // true
	fmt.Println("IsInf(+Inf, 0):", math.IsInf(posInf, 0))  // true
	fmt.Println("IsInf(+Inf, -1):", math.IsInf(posInf, -1)) // false
	
	// 检查负无穷
	fmt.Println("IsInf(-Inf, -1):", math.IsInf(negInf, -1)) // true
	fmt.Println("IsInf(-Inf, 0):", math.IsInf(negInf, 0))   // true
	
	// 检查有限值
	fmt.Println("IsInf(1.0, 0):", math.IsInf(1.0, 0))      // false
}

判断是否为有限值

math.IsFinite(f float64) bool

说明：Go 1.20+ 新增，检查是否为有限数（非无穷、非 NaN）

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("IsFinite(1.0):", math.IsFinite(1.0))        // true
	fmt.Println("IsFinite(0.0):", math.IsFinite(0.0))        // true
	fmt.Println("IsFinite(-100):", math.IsFinite(-100))      // true
	
	fmt.Println("IsFinite(Inf):", math.IsFinite(math.Inf(1))) // false
	fmt.Println("IsFinite(NaN):", math.IsFinite(math.NaN()))  // false
}

🔹 基本运算

绝对值

math.Abs(x float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Abs(-5.5))   // 5.5
	fmt.Println(math.Abs(5.5))    // 5.5
	fmt.Println(math.Abs(0))      // 0
	fmt.Println(math.Abs(-0.0))   // 0
	fmt.Println(math.Abs(-100))   // 100
	
	// 实际应用：计算距离
	point1 := -10.0
	point2 := 5.0
	distance := math.Abs(point2 - point1)
	fmt.Println("距离:", distance) // 15
}

向上取整

math.Ceil(x float64) float64

说明：返回不小于 x 的最小整数

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Ceil(3.14))   // 4
	fmt.Println(math.Ceil(3.99))   // 4
	fmt.Println(math.Ceil(3.0))    // 3
	fmt.Println(math.Ceil(-3.14))  // -3
	fmt.Println(math.Ceil(-3.99))  // -3
	
	// 实际应用：计算需要的页数
	totalItems := 100
	itemsPerPage := 15
	pages := math.Ceil(float64(totalItems) / float64(itemsPerPage))
	fmt.Println("需要页数:", int(pages)) // 7
}

向下取整

math.Floor(x float64) float64

说明：返回不大于 x 的最大整数

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Floor(3.14))   // 3
	fmt.Println(math.Floor(3.99))   // 3
	fmt.Println(math.Floor(3.0))    // 3
	fmt.Println(math.Floor(-3.14))  // -4
	fmt.Println(math.Floor(-3.99))  // -4
	
	// 实际应用：计算完整组数
	total := 100
	groupSize := 15
	groups := math.Floor(float64(total) / float64(groupSize))
	fmt.Println("完整组数:", int(groups)) // 6
}

截断小数（向零取整）

math.Trunc(x float64) float64

说明：直接截断小数部分，向零方向取整

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Trunc(3.14))   // 3
	fmt.Println(math.Trunc(3.99))   // 3
	fmt.Println(math.Trunc(-3.14))  // -3
	fmt.Println(math.Trunc(-3.99))  // -3
	fmt.Println(math.Trunc(0.99))   // 0
	
	// 与 Floor 对比
	fmt.Println("\n对比 Floor:")
	fmt.Println("Trunc(-3.14):", math.Trunc(-3.14)) // -3
	fmt.Println("Floor(-3.14):", math.Floor(-3.14)) // -4
}

四舍五入

math.Round(x float64) float64

说明：四舍五入到最近的整数，0.5 向远离零的方向舍入

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Round(3.4))    // 3
	fmt.Println(math.Round(3.5))    // 4
	fmt.Println(math.Round(3.6))    // 4
	fmt.Println(math.Round(-3.4))   // -3
	fmt.Println(math.Round(-3.5))   // -4
	fmt.Println(math.Round(-3.6))   // -4
	fmt.Println(math.Round(0.5))    // 1
	fmt.Println(math.Round(-0.5))   // -1
	
	// 保留两位小数
	value := 3.14159
	rounded := math.Round(value*100) / 100
	fmt.Println("\n保留两位小数:", rounded) // 3.14
}

向最近偶数舍入

math.RoundToEven(x float64) float64

说明：银行家舍入法，0.5 时向最近的偶数舍入

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.RoundToEven(2.5)) // 2（向偶数舍入）
	fmt.Println(math.RoundToEven(3.5)) // 4（向偶数舍入）
	fmt.Println(math.RoundToEven(4.5)) // 4
	fmt.Println(math.RoundToEven(5.5)) // 6
	
	fmt.Println(math.RoundToEven(2.4)) // 2
	fmt.Println(math.RoundToEven(2.6)) // 3
	
	// 与 Round 对比
	fmt.Println("\n对比 Round:")
	fmt.Println("Round(2.5):", math.Round(2.5))         // 3
	fmt.Println("RoundToEven(2.5):", math.RoundToEven(2.5)) // 2
}

取余数

math.Mod(x, y float64) float64

说明：计算 x 除以 y 的余数，符号与 x 相同

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Mod(5.5, 2.0))   // 1.5
	fmt.Println(math.Mod(10.0, 3.0))  // 1
	fmt.Println(math.Mod(-10.0, 3.0)) // -1
	fmt.Println(math.Mod(10.0, -3.0)) // 1
	fmt.Println(math.Mod(-10.0, -3.0)) // -1
	
	// 实际应用：判断奇偶
	num := 7.0
	if math.Mod(num, 2.0) == 0 {
		fmt.Println("偶数")
	} else {
		fmt.Println("奇数") // 奇数
	}
}

浮点余数（IEEE 754）

math.Remainder(x, y float64) float64

说明：IEEE 754 标准余数，结果范围在 [-y/2, y/2]

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Remainder(5.5, 2.0))   // -0.5
	fmt.Println(math.Remainder(10.0, 3.0))  // 1
	fmt.Println(math.Remainder(7.0, 4.0))   // -1
	
	// 与 Mod 对比
	fmt.Println("\n对比 Mod:")
	fmt.Println("Mod(5.5, 2.0):", math.Mod(5.5, 2.0))         // 1.5
	fmt.Println("Remainder(5.5, 2.0):", math.Remainder(5.5, 2.0)) // -0.5
}

同时获取商和余数

math.Modf(f float64) (float64, float64)

返回：整数部分和小数部分

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	intpart, fracpart := math.Modf(3.14)
	fmt.Println("整数部分:", intpart)    // 3
	fmt.Println("小数部分:", fracpart)   // 0.14
	
	intpart, fracpart = math.Modf(-3.14)
	fmt.Println("\n负数:")
	fmt.Println("整数部分:", intpart)    // -3
	fmt.Println("小数部分:", fracpart)   // -0.14
	
	// 实际应用：分离度分秒
	degrees := 45.75
	d, m := math.Modf(degrees)
	fmt.Printf("\n%.2f 度 = %d 度 %.0f 分\n", degrees, int(d), m*60)
}

🔹 幂运算和对数

幂运算（x 的 y 次方）

math.Pow(x, y float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Pow(2, 3))    // 8
	fmt.Println(math.Pow(2, 10))   // 1024
	fmt.Println(math.Pow(10, 2))   // 100
	fmt.Println(math.Pow(2, -1))   // 0.5
	fmt.Println(math.Pow(4, 0.5))  // 2（平方根）
	fmt.Println(math.Pow(8, 1.0/3)) // 2（立方根）
	
	// 实际应用：复利计算
	principal := 1000.0
	rate := 0.05
	years := 10
	amount := principal * math.Pow(1+rate, float64(years))
	fmt.Printf("\n复利计算：%.2f 元\n", amount) // 1628.89
}

平方根

math.Sqrt(x float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Sqrt(16))     // 4
	fmt.Println(math.Sqrt(2))      // 1.4142135623730951
	fmt.Println(math.Sqrt(0))      // 0
	fmt.Println(math.Sqrt(-1))     // NaN
	
	// 实际应用：勾股定理
	a, b := 3.0, 4.0
	c := math.Sqrt(a*a + b*b)
	fmt.Println("斜边长度:", c) // 5
	
	// 实际应用：标准差计算
	values := []float64{2, 4, 4, 4, 5, 5, 7, 9}
	mean := 5.0
	variance := 4.0
	stdDev := math.Sqrt(variance)
	fmt.Println("标准差:", stdDev) // 2
}

立方根

math.Cbrt(x float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Cbrt(27))     // 3
	fmt.Println(math.Cbrt(8))      // 2
	fmt.Println(math.Cbrt(-8))     // -2
	fmt.Println(math.Cbrt(0))      // 0
	
	// 与 Pow 对比
	fmt.Println("\n对比 Pow(27, 1/3):")
	fmt.Println("Cbrt(27):", math.Cbrt(27))           // 3
	fmt.Println("Pow(27, 1/3):", math.Pow(27, 1.0/3)) // 3（但精度可能略低）
	
	// 实际应用：计算立方体边长
	volume := 64.0
	side := math.Cbrt(volume)
	fmt.Printf("\n体积 %.1f 的立方体边长为：%.1f\n", volume, side) // 4
}

自然对数（以 e 为底）

math.Log(x float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Log(math.E))  // 1
	fmt.Println(math.Log(1))       // 0
	fmt.Println(math.Log(10))      // 2.302585092994046
	fmt.Println(math.Log(0))       // -Inf
	fmt.Println(math.Log(-1))      // NaN
	
	// 验证：e^ln(x) = x
	x := 5.0
	result := math.Exp(math.Log(x))
	fmt.Printf("\ne^ln(%.1f) = %.1f\n", x, result) // 5
	
	// 实际应用：计算倍增时间
	rate := 0.05
	doublingTime := math.Log(2) / rate
	fmt.Printf("\n年增长率 %.0f%%，倍增时间：%.1f 年\n", rate*100, doublingTime) // 13.9 年
}

以 2 为底的对数

math.Log2(x float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Log2(8))      // 3
	fmt.Println(math.Log2(1024))   // 10
	fmt.Println(math.Log2(1))      // 0
	fmt.Println(math.Log2(0.5))    // -1
	
	// 实际应用：计算二进制位数
	n := 1024.0
	bits := math.Log2(n)
	fmt.Printf("%.0f 需要 %.0f 位二进制表示\n", n, bits) // 10 位
	
	// 实际应用：计算树的高度
	nodes := 1000.0
	height := math.Log2(nodes)
	fmt.Printf("%.0f 个节点的二叉树最小高度：%.0f\n", nodes, math.Ceil(height)) // 10
}

以 10 为底的对数

math.Log10(x float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Log10(100))    // 2
	fmt.Println(math.Log10(1000))   // 3
	fmt.Println(math.Log10(1))      // 0
	fmt.Println(math.Log10(0.1))    // -1
	
	// 实际应用：计算数字位数
	n := 1000.0
	digits := math.Floor(math.Log10(n)) + 1
	fmt.Printf("%.0f 是 %.0f 位数\n", n, digits) // 4 位数
	
	// 实际应用：里氏震级
	amplitude := 1000.0
	magnitude := math.Log10(amplitude)
	fmt.Printf("振幅 %.1f 对应的震级：%.1f\n", amplitude, magnitude) // 3
}

对数加法（精确计算）

math.Log1p(x float64) float64

说明：计算 ln(1+x)，适合 x 接近 0 的情况

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	x := 1e-10
	
	// 使用 Log1p（精确）
	result1 := math.Log1p(x)
	fmt.Println("Log1p(1e-10):", result1) // 9.99999999995e-11
	
	// 使用 Log（精度损失）
	result2 := math.Log(1 + x)
	fmt.Println("Log(1 + 1e-10):", result2) // 1.0000000827e-10（精度损失）
	
	// 实际应用：小利率计算
	interestRate := 0.0001
	logReturn := math.Log1p(interestRate)
	fmt.Printf("\n小利率 %.4f 的对数收益率：%.10f\n", interestRate, logReturn)
}

对数换底

math.Logb(x float64) int

说明：返回 x 的以 2 为底的对数的整数部分（指数）

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Logb(8))      // 3
	fmt.Println(math.Logb(1024))   // 10
	fmt.Println(math.Logb(1))      // 0
	fmt.Println(math.Logb(0.5))    // -1
	
	// 获取浮点数的指数部分
	x := 12.5
	exp := math.Logb(x)
	fmt.Printf("%.1f = mantissa × 2^%d\n", x, exp)
}

指数函数（e 的 x 次方）

math.Exp(x float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Exp(0))       // 1
	fmt.Println(math.Exp(1))       // 2.718281828459045
	fmt.Println(math.Exp(2))       // 7.38905609893065
	fmt.Println(math.Exp(-1))      // 0.36787944117144233
	
	// 验证：ln(e^x) = x
	x := 5.0
	result := math.Log(math.Exp(x))
	fmt.Printf("\nln(e^%.1f) = %.1f\n", x, result) // 5
	
	// 实际应用：指数增长
	P0 := 100.0  // 初始人口
	r := 0.02    // 增长率
	t := 10.0    // 时间
	P := P0 * math.Exp(r*t)
	fmt.Printf("\n指数增长：%.1f 年后人口：%.1f\n", t, P) // 122.1
}

2 的 x 次方

math.Exp2(x float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Exp2(3))      // 8
	fmt.Println(math.Exp2(10))     // 1024
	fmt.Println(math.Exp2(0))      // 1
	fmt.Println(math.Exp2(-1))     // 0.5
	
	// 与 Pow 对比
	fmt.Println("\n对比 Pow(2, 10):")
	fmt.Println("Exp2(10):", math.Exp2(10))     // 1024
	fmt.Println("Pow(2, 10):", math.Pow(2, 10)) // 1024
	
	// 实际应用：计算存储容量
	gb := 16
	bytes := math.Exp2(30) * float64(gb)
	fmt.Printf("\n%d GB = %.0f 字节\n", gb, bytes)
}

10 的 x 次方

math.Exp10(x float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Exp10(2))     // 100
	fmt.Println(math.Exp10(3))     // 1000
	fmt.Println(math.Exp10(0))     // 1
	fmt.Println(math.Exp10(-1))    // 0.1
	
	// 与 Pow 对比
	fmt.Println("\n对比 Pow(10, 3):")
	fmt.Println("Exp10(3):", math.Exp10(3))     // 1000
	fmt.Println("Pow(10, 3):", math.Pow(10, 3)) // 1000
}

指数减 1

math.Expm1(x float64) float64

说明：计算 e^x - 1，适合 x 接近 0 的情况

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	x := 1e-10
	
	// 使用 Expm1（精确）
	result1 := math.Expm1(x)
	fmt.Println("Expm1(1e-10):", result1) // 1.0000000827e-10
	
	// 使用 Exp（精度损失）
	result2 := math.Exp(x) - 1
	fmt.Println("Exp(1e-10) - 1:", result2) // 0（精度损失）
	
	// 实际应用：小利率的复利计算
	r := 0.0001
	futureValue := 1000 * math.Expm1(r)
	fmt.Printf("\n小利率 %.4f 的利息：%.4f\n", r, futureValue)
}

🔹 三角函数

正弦

math.Sin(x float64) float64

说明：x 为弧度

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	// 特殊角度
	fmt.Println("sin(0):", math.Sin(0))              // 0
	fmt.Println("sin(π/6):", math.Sin(math.Pi/6))    // 0.5
	fmt.Println("sin(π/4):", math.Sin(math.Pi/4))    // 0.707...
	fmt.Println("sin(π/2):", math.Sin(math.Pi/2))    // 1
	fmt.Println("sin(π):", math.Sin(math.Pi))        // 0
	
	// 角度转弧度
	degrees := 30.0
	radians := degrees * math.Pi / 180
	fmt.Printf("\nsin(%.0f°) = %.4f\n", degrees, math.Sin(radians)) // 0.5
	
	// 实际应用：简谐振动
	amplitude := 10.0
	frequency := 2.0
	t := 0.25
	displacement := amplitude * math.Sin(2*math.Pi*frequency*t)
	fmt.Printf("\n位移：%.2f\n", displacement)
}

余弦

math.Cos(x float64) float64

说明：x 为弧度

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("cos(0):", math.Cos(0))              // 1
	fmt.Println("cos(π/6):", math.Cos(math.Pi/6))    // 0.866...
	fmt.Println("cos(π/4):", math.Cos(math.Pi/4))    // 0.707...
	fmt.Println("cos(π/2):", math.Cos(math.Pi/2))    // 0
	fmt.Println("cos(π):", math.Cos(math.Pi))        // -1
	
	// 验证：sin²(x) + cos²(x) = 1
	x := math.Pi / 5
	result := math.Pow(math.Sin(x), 2) + math.Pow(math.Cos(x), 2)
	fmt.Printf("\nsin²(π/5) + cos²(π/5) = %.10f\n", result) // 1
	
	// 实际应用：向量投影
	magnitude := 10.0
	angle := math.Pi / 6
	xComponent := magnitude * math.Cos(angle)
	fmt.Printf("\n向量投影：x 分量 = %.2f\n", xComponent) // 8.66
}

正切

math.Tan(x float64) float64

说明：x 为弧度

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("tan(0):", math.Tan(0))              // 0
	fmt.Println("tan(π/4):", math.Tan(math.Pi/4))    // 1
	fmt.Println("tan(π/6):", math.Tan(math.Pi/6))    // 0.577...
	fmt.Println("tan(π/3):", math.Tan(math.Pi/3))    // 1.732...
	
	// 验证：tan(x) = sin(x) / cos(x)
	x := math.Pi / 6
	tan1 := math.Tan(x)
	tan2 := math.Sin(x) / math.Cos(x)
	fmt.Printf("\ntan(π/6) = %.6f, sin/cos = %.6f\n", tan1, tan2)
	
	// 实际应用：计算斜率
	angle := 45.0 * math.Pi / 180
	slope := math.Tan(angle)
	fmt.Printf("\n%.0f° 角的斜率：%.2f\n", 45.0, slope) // 1
}

反正弦

math.Asin(x float64) float64

说明：返回弧度值，范围 [-π/2, π/2]

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("asin(0):", math.Asin(0))              // 0
	fmt.Println("asin(0.5):", math.Asin(0.5))          // π/6
	fmt.Println("asin(1):", math.Asin(1))              // π/2
	fmt.Println("asin(-1):", math.Asin(-1))            // -π/2
	
	// 弧度转角度
	result := math.Asin(0.5)
	degrees := result * 180 / math.Pi
	fmt.Printf("\narcsin(0.5) = %.2f°\n", degrees) // 30°
	
	// 验证：sin(asin(x)) = x
	x := 0.7
	fmt.Printf("\nsin(asin(%.1f)) = %.1f\n", x, math.Sin(math.Asin(x)))
}

反余弦

math.Acos(x float64) float64

说明：返回弧度值，范围 [0, π]

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("acos(1):", math.Acos(1))              // 0
	fmt.Println("acos(0.5):", math.Acos(0.5))          // π/3
	fmt.Println("acos(0):", math.Acos(0))              // π/2
	fmt.Println("acos(-1):", math.Acos(-1))            // π
	
	// 弧度转角度
	result := math.Acos(0.5)
	degrees := result * 180 / math.Pi
	fmt.Printf("\narccos(0.5) = %.2f°\n", degrees) // 60°
	
	// 实际应用：计算向量夹角
	dot := 0.5
	angle := math.Acos(dot)
	fmt.Printf("\n向量夹角：%.2f°\n", angle*180/math.Pi)
}

反正切

math.Atan(x float64) float64

说明：返回弧度值，范围 [-π/2, π/2]

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("atan(0):", math.Atan(0))              // 0
	fmt.Println("atan(1):", math.Atan(1))              // π/4
	fmt.Println("atan(-1):", math.Atan(-1))            // -π/4
	
	// 弧度转角度
	result := math.Atan(1)
	degrees := result * 180 / math.Pi
	fmt.Printf("\narctan(1) = %.2f°\n", degrees) // 45°
	
	// 验证：tan(atan(x)) = x
	x := 2.0
	fmt.Printf("\ntan(atan(%.1f)) = %.1f\n", x, math.Tan(math.Atan(x)))
}

反正切（四象限）

math.Atan2(y, x float64) float64

说明：考虑象限，返回弧度值，范围 [-π, π]

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	// 四个象限
	fmt.Println("atan2(1, 1):", math.Atan2(1, 1))      // π/4 (第一象限)
	fmt.Println("atan2(1, -1):", math.Atan2(1, -1))    // 3π/4 (第二象限)
	fmt.Println("atan2(-1, -1):", math.Atan2(-1, -1))  // -3π/4 (第三象限)
	fmt.Println("atan2(-1, 1):", math.Atan2(-1, 1))    // -π/4 (第四象限)
	
	// 实际应用：计算两点间的角度
	x1, y1 := 0.0, 0.0
	x2, y2 := 3.0, 4.0
	angle := math.Atan2(y2-y1, x2-x1)
	degrees := angle * 180 / math.Pi
	fmt.Printf("\n从 (%.1f, %.1f) 到 (%.1f, %.1f) 的角度：%.2f°\n", 
		x1, y1, x2, y2, degrees) // 53.13°
	
	// 计算距离
	distance := math.Sqrt(math.Pow(x2-x1, 2) + math.Pow(y2-y1, 2))
	fmt.Println("距离:", distance) // 5
}

双曲正弦

math.Sinh(x float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("sinh(0):", math.Sinh(0))        // 0
	fmt.Println("sinh(1):", math.Sinh(1))        // 1.1752011936438014
	fmt.Println("sinh(-1):", math.Sinh(-1))      // -1.1752011936438014
	
	// 定义：sinh(x) = (e^x - e^-x) / 2
	x := 1.0
	definition := (math.Exp(x) - math.Exp(-x)) / 2
	fmt.Printf("\n定义计算 sinh(1): %.10f\n", definition)
}

双曲余弦

math.Cosh(x float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("cosh(0):", math.Cosh(0))        // 1
	fmt.Println("cosh(1):", math.Cosh(1))        // 1.5430806348152437
	fmt.Println("cosh(-1):", math.Cosh(-1))      // 1.5430806348152437
	
	// 定义：cosh(x) = (e^x + e^-x) / 2
	x := 1.0
	definition := (math.Exp(x) + math.Exp(-x)) / 2
	fmt.Printf("\n定义计算 cosh(1): %.10f\n", definition)
	
	// 实际应用：悬链线
	a := 2.0
	x := 1.0
	y := a * math.Cosh(x/a)
	fmt.Printf("\n悬链线 y(%.1f) = %.4f\n", x, y)
}

双曲正切

math.Tanh(x float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("tanh(0):", math.Tanh(0))        // 0
	fmt.Println("tanh(1):", math.Tanh(1))        // 0.7615941559557649
	fmt.Println("tanh(-1):", math.Tanh(-1))      // -0.7615941559557649
	
	// 定义：tanh(x) = sinh(x) / cosh(x)
	x := 1.0
	definition := math.Sinh(x) / math.Cosh(x)
	fmt.Printf("\n定义计算 tanh(1): %.10f\n", definition)
	
	// 实际应用：激活函数
	inputs := []float64{-2, -1, 0, 1, 2}
	fmt.Println("\nTanh 激活函数:")
	for _, x := range inputs {
		fmt.Printf("tanh(%.0f) = %.4f\n", x, math.Tanh(x))
	}
}

反双曲正弦

math.Asinh(x float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("asinh(0):", math.Asinh(0))        // 0
	fmt.Println("asinh(1):", math.Asinh(1))        // 0.881373587019543
	
	// 验证：sinh(asinh(x)) = x
	x := 2.0
	result := math.Sinh(math.Asinh(x))
	fmt.Printf("\nsinh(asinh(%.1f)) = %.1f\n", x, result)
}

反双曲余弦

math.Acosh(x float64) float64

说明：x 必须 >= 1

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("acosh(1):", math.Acosh(1))        // 0
	fmt.Println("acosh(2):", math.Acosh(2))        // 1.3169578969248166
	
	// 验证：cosh(acosh(x)) = x
	x := 3.0
	result := math.Cosh(math.Acosh(x))
	fmt.Printf("\ncosh(acosh(%.1f)) = %.1f\n", x, result)
}

反双曲正切

math.Atanh(x float64) float64

说明：|x| < 1

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("atanh(0):", math.Atanh(0))        // 0
	fmt.Println("atanh(0.5):", math.Atanh(0.5))    // 0.5493061443340549
	
	// 验证：tanh(atanh(x)) = x
	x := 0.7
	result := math.Tanh(math.Atanh(x))
	fmt.Printf("\ntanh(atanh(%.1f)) = %.1f\n", x, result)
}

🔹 角度转换

角度转弧度

弧度 = 角度 × π / 180

示例

package main

import (
	"fmt"
	"math"
)

// 辅助函数：角度转弧度
func degreesToRadians(degrees float64) float64 {
	return degrees * math.Pi / 180
}

func main() {
	// 常见角度
	angles := []float64{0, 30, 45, 60, 90, 180, 270, 360}
	
	fmt.Println("角度转弧度:")
	for _, deg := range angles {
		rad := degreesToRadians(deg)
		fmt.Printf("%.0f° = %.4f 弧度\n", deg, rad)
	}
	
	// 实际应用：三角函数计算
	angle := 60.0
	rad := degreesToRadians(angle)
	fmt.Printf("\nsin(%.0f°) = %.4f\n", angle, math.Sin(rad))
}

弧度转角度

角度 = 弧度 × 180 / π

示例

package main

import (
	"fmt"
	"math"
)

// 辅助函数：弧度转角度
func radiansToDegrees(radians float64) float64 {
	return radians * 180 / math.Pi
}

func main() {
	// 常见弧度
	radians := []float64{0, math.Pi / 6, math.Pi / 4, math.Pi / 3, math.Pi / 2, math.Pi}
	
	fmt.Println("弧度转角度:")
	for _, rad := range radians {
		deg := radiansToDegrees(rad)
		fmt.Printf("%.4f 弧度 = %.0f°\n", rad, deg)
	}
	
	// 实际应用：反正切结果转换
	x, y := 3.0, 4.0
	angle := math.Atan2(y, x)
	degrees := radiansToDegrees(angle)
	fmt.Printf("\natan2(%.1f, %.1f) = %.2f°\n", x, y, degrees)
}

🔹 最大值和最小值

两个数的最大值

math.Max(x, y float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Max(3.5, 2.1))    // 3.5
	fmt.Println(math.Max(-1, -5))      // -1
	fmt.Println(math.Max(0, -1))       // 0
	fmt.Println(math.Max(10, 10))      // 10
	
	// 实际应用：找出最高分
	scores := []float64{85.5, 92.0, 78.5, 96.5, 88.0}
	maxScore := scores[0]
	for _, score := range scores[1:] {
		maxScore = math.Max(maxScore, score)
	}
	fmt.Println("\n最高分:", maxScore) // 96.5
}

两个数的最小值

math.Min(x, y float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Min(3.5, 2.1))    // 2.1
	fmt.Println(math.Min(-1, -5))      // -5
	fmt.Println(math.Min(0, 1))        // 0
	fmt.Println(math.Min(10, 10))      // 10
	
	// 实际应用：找出最低温度
	temperatures := []float64{-5.0, 2.0, -8.0, 0.0, 3.0}
	minTemp := temperatures[0]
	for _, temp := range temperatures[1:] {
		minTemp = math.Min(minTemp, temp)
	}
	fmt.Println("\n最低温度:", minTemp) // -8.0
}

多个数的最大值（Go 1.21+）

math.Max(x, y, zs... float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	// Go 1.21+ 新特性
	max := math.Max(1.0, 5.0, 3.0, 9.0, 2.0)
	fmt.Println("最大值:", max) // 9
	
	// 实际应用：找出比赛最高分
	scores := []float64{88.5, 92.0, 95.5, 89.0, 91.5}
	maxScore := math.Max(scores[0], scores[1], scores[2:]...)
	fmt.Println("比赛最高分:", maxScore)
}

多个数的最小值（Go 1.21+）

math.Min(x, y, zs... float64) float64

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	// Go 1.21+ 新特性
	min := math.Min(10.0, 5.0, 3.0, 9.0, 2.0)
	fmt.Println("最小值:", min) // 2
	
	// 实际应用：找出最低价格
	prices := []float64{99.99, 79.99, 89.99, 69.99, 59.99}
	minPrice := math.Min(prices[0], prices[1], prices[2:]...)
	fmt.Println("最低价格:", minPrice)
}

🔹 符号操作

复制符号

math.Copysign(x, y float64) float64

说明：返回 x 的大小和 y 的符号

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Copysign(5, -1))    // -5
	fmt.Println(math.Copysign(-5, 1))    // 5
	fmt.Println(math.Copysign(0, -1))    // -0
	fmt.Println(math.Copysign(-0, 1))    // 0
	
	// 实际应用：确保符号一致
	force := 10.0
	direction := -1.0
	result := math.Copysign(force, direction)
	fmt.Printf("\n力的大小：%.1f, 方向：%.1f, 结果：%.1f\n", force, direction, result)
}

获取符号

math.Signbit(x float64) bool

说明：判断 x 是否为负数（包括 -0）

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Signbit(5.0))     // false
	fmt.Println(math.Signbit(-5.0))    // true
	fmt.Println(math.Signbit(0.0))     // false
	fmt.Println(math.Signbit(-0.0))    // true
	fmt.Println(math.Signbit(math.Inf(-1))) // true
	
	// 实际应用：根据符号分类
	numbers := []float64{-5, 3, 0, -0.5, 10}
	fmt.Println("\n数字分类:")
	for _, n := range numbers {
		if math.Signbit(n) {
			fmt.Printf("%.1f 是负数\n", n)
		} else {
			fmt.Printf("%.1f 是非负数\n", n)
		}
	}
}

获取符号值

math.Sign(x float64) int

返回：-1（负数）、0（零）、1（正数）

示例

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Sign(5.0))      // 1
	fmt.Println(math.Sign(-5.0))     // -1
	fmt.Println(math.Sign(0.0))      // 0
	fmt.Println(math.Sign(-0.0))     // 0
	
	// 实际应用：比较函数
	compare := func(a, b float64) int {
		return math.Sign(a - b)
	}
	
	fmt.Println("\n比较结果:")
	fmt.Println("compare(5, 3):", compare(5, 3))   // 1
	fmt.Println("compare(3, 5):", compare(3, 5))   // -1
	fmt.Println("compare(5, 5):", compare(5, 5))   // 0
}

🔥 总结

常用函数速查

常量：math.E, math.Pi, math.MaxInt, math.MaxUint64
特殊值：math.Inf(), math.NaN(), math.IsNaN(), math.IsInf(), math.IsFinite()
基本运算：math.Abs(), math.Ceil(), math.Floor(), math.Round(), math.Mod()
幂运算：math.Pow(), math.Sqrt(), math.Cbrt(), math.Exp(), math.Log()
三角函数：math.Sin(), math.Cos(), math.Tan(), math.Atan2()
双曲函数：math.Sinh(), math.Cosh(), math.Tanh()
最值：math.Max(), math.Min()
符号：math.Copysign(), math.Signbit(), math.Sign()
整数运算：math.GCD(), math.LCM()
位操作：math.LeadingZeros(), math.OnesCount(), math.RotateLeft()

实际应用示例

package main

import (
	"fmt"
	"math"
)

func main() {
	// 1. 复利计算
	principal := 1000.0
	rate := 0.05
	years := 10
	amount := principal * math.Pow(1+rate, float64(years))
	fmt.Printf("复利计算：%.2f 元\n", amount)
	
	// 2. 距离计算
	x1, y1 := 0.0, 0.0
	x2, y2 := 3.0, 4.0
	distance := math.Sqrt(math.Pow(x2-x1, 2) + math.Pow(y2-y1, 2))
	fmt.Printf("距离：%.2f\n", distance)
	
	// 3. 角度计算
	angle := math.Atan2(y2-y1, x2-x1) * 180 / math.Pi
	fmt.Printf("角度：%.2f°\n", angle)
	
	// 4. 三角函数
	radians := 60.0 * math.Pi / 180
	fmt.Printf("sin(60°) = %.4f\n", math.Sin(radians))
	
	// 5. 对数计算
	fmt.Printf("ln(10) = %.4f\n", math.Log(10))
	fmt.Printf("log₂(8) = %.0f\n", math.Log2(8))
	fmt.Printf("log₁₀(100) = %.0f\n", math.Log10(100))
}

Keyboard shortcuts

Go 标准包使用指南