函数

func abs(Float16)

public func abs(x: Float16): Float16

功能：求一个半精度浮点数的绝对值。

参数：

• x: Float16 - 传入的半精度浮点数。

返回值：

• Float16 - 返回传入参数的绝对值。

示例：

import std.math.abs

main() {
    let n: Float16 = -23.0
    let abs = abs(n)
    println(abs)
}

运行结果:

23.000000

func abs(Float32)

public func abs(x: Float32): Float32

功能：求一个单精度浮点数的绝对值。

参数：

• x: Float32 - 传入的单精度浮点数。

返回值：

• Float32 - 返回传入参数的绝对值。

示例：

import std.math.abs

main() {
    let n: Float32 = -23.0
    let abs = abs(n)
    println(abs)
}

运行结果:

23.000000

func abs(Float64)

public func abs(x: Float64): Float64

功能：求一个双精度浮点数的绝对值。

参数：

• x: Float64 - 传入的双精度浮点数。

返回值：

• Float64 - 返回传入参数的绝对值。

示例：

import std.math.abs

main() {
    let n: Float64 = -23.0
    let abs = abs(n)
    println(abs)
}

运行结果:

23.000000

func abs(Int16)

public func abs(x: Int16): Int16

功能：求一个 16 位有符号整数的绝对值。

参数：

• x: Int16 - 传入的 16 位有符号整数。

返回值：

• Int16 - 返回传入参数的绝对值。

异常：

• OverflowException - 当输入参数是有符号整数的最小值，抛出异常。

示例：

import std.math.abs

main() {
    let n: Int16 = -23
    let abs = abs(n)
    println(abs)
}

运行结果:

23

func abs(Int32)

public func abs(x: Int32): Int32

功能：求一个 32 位有符号整数的绝对值。

参数：

• x: Int32 - 传入的 32 位有符号整数。

返回值：

• Int32 - 返回传入参数的绝对值。

异常：

• OverflowException - 当输入参数是有符号整数的最小值，抛出异常。

示例：

import std.math.abs

main() {
    let n: Int32 = -23
    let abs = abs(n)
    println(abs)
}

运行结果:

23

func abs(Int64)

public func abs(x: Int64): Int64

功能：求一个 64 位有符号整数的绝对值。

参数：

• x: Int64 - 传入的 64 位有符号整数。

返回值：

• Int64 - 返回传入参数的绝对值。

异常：

• OverflowException - 当输入参数是有符号整数的最小值，抛出异常。

示例：

import std.math.abs

main() {
    let n: Int64 = -23
    let abs = abs(n)
    println(abs)
}

运行结果:

23

func abs(Int8)

public func abs(x: Int8): Int8

功能：求一个 8 位有符号整数的绝对值。

参数：

• x: Int8 - 传入的 8 位有符号整数。

返回值：

• Int8 - 返回传入参数的绝对值。

异常：

• OverflowException - 当输入参数是有符号整数的最小值，抛出异常。

示例：

import std.math.abs

main() {
    let n: Int8 = -23
    let abs = abs(n)
    println(abs)
}

运行结果:

23

func acos(Float16)

public func acos(x: Float16): Float16

功能：计算半精度浮点数的反余弦函数值。

参数：

• x: Float16 - 传入的半精度浮点数。-1.0 <= x <= 1.0。

返回值：

• Float16 - 返回传入参数的反余弦函数值，单位为弧度。

异常：

• IllegalArgumentException - 当参数 x 大于 1.0 或小于 -1.0 时，抛出异常。

示例：

import std.math.acos

main() {
    let n: Float16 = 1.0
    let acos = acos(n)
    println(acos)
}

运行结果:

0.000000

func acos(Float32)

public func acos(x: Float32): Float32

功能：计算单精度浮点数的反余弦函数值。

参数：

• x: Float32 - 传入的单精度浮点数。-1.0 <= x <= 1.0。

返回值：

• Float32 - 返回传入参数的反余弦函数值，单位为弧度。

异常：

• IllegalArgumentException - 当参数 x 大于 1.0 或小于 -1.0 时，抛出异常。

示例：

import std.math.acos

main() {
    let n: Float32 = 1.0
    let acos = acos(n)
    println(acos)
}

运行结果:

0.000000

func acos(Float64)

public func acos(x: Float64): Float64

功能：计算双精度浮点数的反余弦函数值。

参数：

• x: Float64 - 传入的双精度浮点数。-1.0 <= x <= 1.0。

返回值：

• Float64 - 返回传入参数的反余弦函数值，单位为弧度。

异常：

• IllegalArgumentException - 当参数 x 大于 1.0 或小于 -1.0 时，抛出异常。

示例：

import std.math.acos

main() {
    let n: Float64 = 1.0
    let acos = acos(n)
    println(acos)
}

运行结果:

0.000000

func acosh(Float16)

public func acosh(x: Float16): Float16

功能：计算半精度浮点数的反双曲余弦函数值。

参数：

• x: Float16 - 传入的半精度浮点数。

返回值：

• Float16 - 返回传入参数的反双曲余弦函数值。x >= 1.0。

异常：

• IllegalArgumentException - 当参数 x 小于 1.0 时，抛出异常。

示例：

import std.math.acosh

main() {
    let n: Float16 = 1.0
    let acosh = acosh(n)
    println(acosh)
}

运行结果:

0.000000

func acosh(Float32)

public func acosh(x: Float32): Float32

功能：计算单精度浮点数的反双曲余弦函数值。

参数：

• x: Float32 - 传入的单精度浮点数。x >= 1.0。

返回值：

• Float32 - 返回传入参数的反双曲余弦函数值。

异常：

• IllegalArgumentException - 当参数 x 小于 1.0 时，抛出异常。

示例：

import std.math.acosh

main() {
    let n: Float32 = 1.0
    let acosh = acosh(n)
    println(acosh)
}

运行结果:

0.000000

func acosh(Float64)

public func acosh(x: Float64): Float64

功能：计算双精度浮点数的反双曲余弦函数值。

参数：

• x: Float64 - 传入的双精度浮点数。x >= 1.0。

返回值：

• Float64 - 返回传入参数的反双曲余弦函数值。

异常：

• IllegalArgumentException - 当参数 x 小于 1.0 时，抛出异常。

示例：

import std.math.acosh

main() {
    let n: Float64 = 1.0
    let acosh = acosh(n)
    println(acosh)
}

运行结果:

0.000000

func asin(Float16)

public func asin(x: Float16): Float16

功能：计算半精度浮点数的反正弦函数值。

参数：

• x: Float16 - 传入的半精度浮点数。-1.0 <= x <= 1.0。

返回值：

• Float16 - 返回传入参数的反正弦函数值，单位为弧度。

异常：

• IllegalArgumentException - 当参数 x 大于 1.0 或小于 -1.0 时，抛出异常。

示例：

import std.math.asin

main() {
    let n: Float16 = 0.0
    let asin = asin(n)
    println(asin)
}

运行结果:

0.000000

func asin(Float32)

public func asin(x: Float32): Float32

功能：计算单精度浮点数的反正弦函数值。

参数：

• x: Float32 - 传入的单精度浮点数。-1.0 <= x <= 1.0。

返回值：

• Float32 - 返回传入参数的反正弦函数值，单位为弧度。

异常：

• IllegalArgumentException - 当参数 x 大于 1.0 或小于 -1.0 时，抛出异常。

示例：

import std.math.asin

main() {
    let n: Float32 = 0.0
    let asin = asin(n)
    println(asin)
}

运行结果:

0.000000

func asin(Float64)

public func asin(x: Float64): Float64

功能：计算双精度浮点数的反正弦函数值。

参数：

• x: Float64 - 传入的双精度浮点数。-1.0 <= x <= 1.0。

返回值：

• Float64 - 返回传入参数的反正弦函数值，单位为弧度。

异常：

• IllegalArgumentException - 当参数 x 大于 1.0 或小于 -1.0 时，抛出异常。

示例：

import std.math.asin

main() {
    let n: Float64 = 0.0
    let asin = asin(n)
    println(asin)
}

运行结果:

0.000000

func asinh(Float16)

public func asinh(x: Float16): Float16

功能：计算半精度浮点数的反双曲正弦函数值。

参数：

• x: Float16 - 传入的半精度浮点数。

返回值：

• Float16 - 返回传入参数的反双曲正弦函数值。

示例：

import std.math.asinh

main() {
    let n: Float16 = 0.0
    let asinh = asinh(n)
    println(asinh)
}

运行结果:

0.000000

func asinh(Float32)

public func asinh(x: Float32): Float32

功能：计算单精度浮点数的反双曲正弦函数值。

参数：

• x: Float32 - 传入的单精度浮点数。

返回值：

• Float32 - 返回传入参数的反双曲正弦函数值。

示例：

import std.math.asinh

main() {
    let n: Float32 = 0.0
    let asinh = asinh(n)
    println(asinh)
}

运行结果:

0.000000

func asinh(Float64)

public func asinh(x: Float64): Float64

功能：计算双精度浮点数的反双曲正弦函数值。

参数：

• x: Float64 - 传入的双精度浮点数。

返回值：

• Float64 - 返回传入参数的反双曲正弦函数值。

示例：

import std.math.asinh

main() {
    let n: Float64 = 0.0
    let asinh = asinh(n)
    println(asinh)
}

运行结果:

0.000000

func atan(Float16)

public func atan(x: Float16): Float16

功能：计算半精度浮点数的反正切函数值。

参数：

• x: Float16 - 传入的半精度浮点数。

返回值：

• Float16 - 返回传入参数的反正切函数值，单位为弧度。

示例：

import std.math.atan

main() {
    let n: Float16 = 0.0
    let atan = atan(n)
    println(atan)
}

运行结果:

0.000000

func atan(Float32)

public func atan(x: Float32): Float32

功能：计算单精度浮点数的反正切函数值。

参数：

• x: Float32 - 传入的单精度浮点数。

返回值：

• Float32 - 返回传入参数的反正切函数值，单位为弧度。

示例：

import std.math.atan

main() {
    let n: Float32 = 0.0
    let atan = atan(n)
    println(atan)
}

运行结果:

0.000000

func atan(Float64)

public func atan(x: Float64): Float64

功能：计算双精度浮点数的反正切函数值。

参数：

• x: Float64 - 传入的双精度浮点数。

返回值：

• Float64 - 返回传入参数的反正切函数值，单位为弧度。

示例：

import std.math.atan

main() {
    let n: Float64 = 0.0
    let atan = atan(n)
    println(atan)
}

运行结果:

0.000000

func atanh(Float16)

public func atanh(x: Float16): Float16

功能：计算半精度浮点数的反双曲正切函数值。

参数：

• x: Float16 - 传入的半精度浮点数。-1.0 < x < 1.0。

返回值：

• Float16 - 返回传入参数的反双曲正切函数值。

异常：

• IllegalArgumentException - 当参数 x 大于等于 1.0 或小于等于 -1.0 时，抛出异常。

示例：

import std.math.atanh

main() {
    let n: Float16 = 0.0
    let atanh = atanh(n)
    println(atanh)
}

运行结果:

0.000000

func atanh(Float32)

public func atanh(x: Float32): Float32

功能：计算单精度浮点数的反双曲正切函数值。

参数：

• x: Float32 - 传入的单精度浮点数。-1.0 < x < 1.0。

返回值：

• Float32 - 返回传入参数的反双曲正切函数值。

异常：

• IllegalArgumentException - 当参数 x 大于等于 1.0 或小于等于 -1.0 时，抛出异常。

示例：

import std.math.atanh

main() {
    let n: Float32 = 0.0
    let atanh = atanh(n)
    println(atanh)
}

运行结果:

0.000000

func atanh(Float64)

public func atanh(x: Float64): Float64

功能：计算双精度浮点数的反双曲正切函数值。

参数：

• x: Float64 - 传入的双精度浮点数。-1.0 < x < 1.0。

返回值：

• Float64 - 返回传入参数的反双曲正切函数值。

异常：

• IllegalArgumentException - 当参数 x 大于等于 1.0 或小于等于 -1.0 时，抛出异常。

示例：

import std.math.atanh

main() {
    let n: Float64 = 0.0
    let atanh = atanh(n)
    println(atanh)
}

运行结果:

0.000000

func cbrt(Float16)

public func cbrt(x: Float16): Float16

功能：求半精度浮点数的立方根。

参数：

• x: Float16 - 传入的半精度浮点数。

返回值：

• Float16 - 返回传入参数的立方根。

示例：

import std.math.cbrt

main() {
    let n: Float16 = -1000.0
    let cbrt = cbrt(n)
    println(cbrt)
}

运行结果:

-10.000000

func cbrt(Float32)

public func cbrt(x: Float32): Float32

功能：求单精度浮点数的立方根。

参数：

• x: Float32 - 传入的单精度浮点数。

返回值：

• Float32 - 返回传入参数的立方根。

示例：

import std.math.cbrt

main() {
    let n: Float32 = -1000.0
    let cbrt = cbrt(n)
    println(cbrt)
}

运行结果:

-10.000000

func cbrt(Float64)

public func cbrt(x: Float64): Float64

功能：求双精度浮点数的立方根。

参数：

• x: Float64 - 传入的双精度浮点数。

返回值：

• Float64 - 返回传入参数的立方根。

示例：

import std.math.cbrt

main() {
    let n: Float64 = -1000.0
    let cbrt = cbrt(n)
    println(cbrt)
}

运行结果:

-10.000000

func ceil(Float16)

public func ceil(x: Float16): Float16

功能：求半精度浮点数的向上取整值。

参数：

• x: Float16 - 传入的半精度浮点数。

返回值：

• Float16 - 返回传入参数的向上取整值。

示例：

import std.math.ceil

main() {
    let n: Float16 = 0.7
    let ceil = ceil(n)
    println(ceil)
}

运行结果:

1.000000

func ceil(Float32)

public func ceil(x: Float32): Float32

功能：求单精度浮点数的向上取整值。

参数：

• x: Float32 - 传入的单精度浮点数。

返回值：

• Float32 - 返回传入参数的向上取整值。

示例：

import std.math.ceil

main() {
    let n: Float32 = 0.7
    let ceil = ceil(n)
    println(ceil)
}

运行结果:

1.000000

func ceil(Float64)

public func ceil(x: Float64): Float64

功能：求双精度浮点数的向上取整值。

参数：

• x: Float64 - 传入的双精度浮点数。

返回值：

• Float64 - 返回传入参数的向上取整值。

示例：

import std.math.ceil

main() {
    let n: Float64 = 0.7
    let ceil = ceil(n)
    println(ceil)
}

运行结果:

1.000000

func checkedAbs(Int16)

public func checkedAbs(x: Int16): Option<Int16>

功能：求一个 16 位有符号整数的绝对值。如果入参是 16 位有符号整数的最小值，函数返回 None；否则，返回 Some(abs(x))。

参数：

• x: Int16 - 传入的 16 位有符号整数。

返回值：

• Option<Int16> - 返回传入参数的绝对值的 Option 类型。

示例：

import std.math.checkedAbs

main() {
    let n: Int16 = -23
    let checkedAbs = checkedAbs(n)
    println(checkedAbs)
}

运行结果:

Some(23)

func checkedAbs(Int32)

public func checkedAbs(x: Int32): Option<Int32>

功能：求一个 32 位有符号整数的绝对值。如果入参是 32 位有符号整数的最小值，函数返回 None；否则，返回 Some(abs(x))。

参数：

• x: Int32 - 传入的 32 位有符号整数。

返回值：

• Option<Int32> - 返回传入参数的绝对值的 Option 类型。

示例：

import std.math.checkedAbs

main() {
    let n: Int32 = -23
    let checkedAbs = checkedAbs(n)
    println(checkedAbs)
}

运行结果:

Some(23)

func checkedAbs(Int64)

public func checkedAbs(x: Int64): Option<Int64>

功能：求一个 64 位有符号整数的绝对值。如果入参是 64 位有符号整数的最小值，函数返回 None；否则，返回 Some(abs(x))。

参数：

• x: Int64 - 传入的 64 位有符号整数。

返回值：

• Option<Int64> - 返回传入参数的绝对值的 Option 类型。

示例：

import std.math.checkedAbs

main() {
    let n: Int64 = -23
    let checkedAbs = checkedAbs(n)
    println(checkedAbs)
}

运行结果:

Some(23)

func checkedAbs(Int8)

public func checkedAbs(x: Int8): Option<Int8>

功能：求一个 8 位有符号整数的绝对值。如果入参是 8 位有符号整数的最小值，函数返回 None；否则，返回 Some(abs(x))。

参数：

• x: Int8 - 传入的 8 位有符号整数。

返回值：

• Option<Int8> - 返回传入参数的绝对值的 Option 类型。

示例：

import std.math.checkedAbs

main() {
    let n: Int8 = -23
    let checkedAbs = checkedAbs(n)
    println(checkedAbs)
}

运行结果:

Some(23)

func clamp(Float16, Float16, Float16)

public func clamp(v: Float16, min: Float16, max: Float16): Float16

功能：求浮点数的范围区间数。如果此浮点数在该范围区间则返回此浮点数；如果此浮点数小于这个范围区间，则返回该范围区间的最小值；如果此浮点数大于这个范围区间，则返回该范围区间的最大值；如果是 NaN 则返回 NaN。

参数：

• v: Float16 - 传入一个浮点数。
• min: Float16 - 指定的最小值。
• max: Float16 - 指定的最大值。

返回值：

• Float16 - 如果 v 在 min 与 max 之间则返回 v；如果 v 小于等于 min 则返回 min；如果 v 大于等于 max，则返回 max；如果是 NaN 则返回 NaN。

示例：

import std.math.clamp

main() {
    let n: Float16 = -23.0
    let clamp = clamp(n, -100.0, 100.0)
    println(clamp)
}

运行结果:

-23.000000

func clamp(Float32, Float32, Float32)

public func clamp(v: Float32, min: Float32, max: Float32): Float32

功能：求浮点数的范围区间数。如果此浮点数在该范围区间则返回此浮点数；如果此浮点数小于这个范围区间，则返回该范围区间的最小值；如果此浮点数大于这个范围区间，则返回该范围区间的最大值；如果是 NaN 则返回 NaN。

参数：

• v: Float32 - 传入一个浮点数。
• min: Float32 - 指定的最小值。
• max: Float32 - 指定的最大值。

返回值：

• Float32 - 如果 v 在 min 与 max 之间则返回 v；如果 v 小于等于 min 则返回 min；如果 v 大于等于 max，则返回 max；如果是 NaN 则返回 NaN。

示例：

import std.math.clamp

main() {
    let n: Float32 = -23.0
    let clamp = clamp(n, -100.0, 100.0)
    println(clamp)
}

运行结果:

-23.000000

func clamp(Float64, Float64, Float64)

public func clamp(v: Float64, min: Float64, max: Float64): Float64

功能：求浮点数的范围区间数。如果此浮点数在该范围区间则返回此浮点数；如果此浮点数小于这个范围区间，则返回该范围区间的最小值；如果此浮点数大于这个范围区间，则返回该范围区间的最大值；如果是 NaN 则返回 NaN。

参数：

• v: Float64 - 传入一个浮点数。
• min: Float64 - 指定的最小值。
• max: Float64 - 指定的最大值。

返回值：

• Float64 - 如果 v 在 min 与 max 之间则返回 v；如果 v 小于等于 min 则返回 min；如果 v 大于等于 max，则返回 max；如果是 NaN 则返回 NaN。

示例：

import std.math.clamp

main() {
    let n: Float64 = -23.0
    let clamp = clamp(n, -100.0, 100.0)
    println(clamp)
}

运行结果:

-23.000000

func cos(Float16)

public func cos(x: Float16): Float16

功能：计算半精度浮点数的余弦函数值。

参数：

• x: Float16 - 传入的半精度浮点数，入参单位为弧度。

返回值：

• Float16 - 返回传入参数的余弦函数值。

示例：

import std.math.cos

main() {
    let n: Float16 = 3.14159265
    let cos = cos(n)
    println(cos)
}

运行结果:

-1.000000

func cos(Float32)

public func cos(x: Float32): Float32

功能：计算单精度浮点数的余弦函数值。

参数：

• x: Float32 - 传入的单精度浮点数，入参单位为弧度。

返回值：

• Float32 - 返回传入参数的余弦函数值。

示例：

import std.math.cos

main() {
    let n: Float32 = 3.14159265
    let cos = cos(n)
    println(cos)
}

运行结果:

-1.000000

func cos(Float64)

public func cos(x: Float64): Float64

功能：计算双精度浮点数的余弦函数值。

参数：

• x: Float64 - 传入的双精度浮点数，入参单位为弧度。

返回值：

• Float64 - 返回传入参数的余弦函数值。

示例：

import std.math.cos

main() {
    let n: Float64 = 3.14159265
    let cos = cos(n)
    println(cos)
}

运行结果:

-1.000000

func cosh(Float16)

public func cosh(x: Float16): Float16

功能：计算半精度浮点数的双曲余弦函数值。

参数：

• x: Float16 - 传入的半精度浮点数。

返回值：

• Float16 - 返回传入参数的双曲余弦函数值。

示例：

import std.math.cosh

main() {
    let n: Float16 = 0.0
    let cosh = cosh(n)
    println(cosh)
}

运行结果:

1.000000

func cosh(Float32)

public func cosh(x: Float32): Float32

功能：计算单精度浮点数的双曲余弦函数值。

参数：

• x: Float32 - 传入的单精度浮点数。

返回值：

• Float32 - 返回传入参数的双曲余弦函数值。

示例：

import std.math.cosh

main() {
    let n: Float32 = 0.0
    let cosh = cosh(n)
    println(cosh)
}

运行结果:

1.000000

func cosh(Float64)

public func cosh(x: Float64): Float64

功能：计算双精度浮点数的双曲余弦函数值。

参数：

• x: Float64 - 传入的双精度浮点数。

返回值：

• Float64 - 返回传入参数的双曲余弦函数值。

示例：

import std.math.cosh

main() {
    let n: Float64 = 0.0
    let cosh = cosh(n)
    println(cosh)
}

运行结果:

1.000000

func countOne(Int16)

public func countOne(x: Int16): Int8

功能：求 16 位整型的二进制表达中 1 的个数。

参数：

• x: Int16 - 传入的 16 位有符号整数。

返回值：

• Int8 - 返回传入参数的二进制表达中的 1 的位的个数。

示例：

import std.math.countOne

main() {
    let n: Int16 = 15
    let countOne = countOne(n)
    println(countOne)
}

运行结果:

4

func countOne(Int32)

public func countOne(x: Int32): Int8

功能：求 32 位整型的二进制表达中 1 的个数。

参数：

• x: Int32 - 传入的 32 位有符号整数。

返回值：

• Int8 - 返回传入参数的二进制表达中的 1 的位的个数。

示例：

import std.math.countOne

main() {
    let n: Int32 = 15
    let countOne = countOne(n)
    println(countOne)
}

运行结果:

4

func countOne(Int64)

public func countOne(x: Int64): Int8

功能：求 64 位整型的二进制表达中 1 的个数。

参数：

• x: Int64 - 传入的 64 位有符号整数。

返回值：

• Int8 - 返回传入参数的二进制表达中的 1 的位的个数。

示例：

import std.math.countOne

main() {
    let n: Int64 = 15
    let countOne = countOne(n)
    println(countOne)
}

运行结果:

4

func countOne(Int8)

public func countOne(x: Int8): Int8

功能：求 8 位整型的二进制表达中 1 的个数。

参数：

• x: Int8 - 传入的 8 位有符号整数。

返回值：

• Int8 - 返回传入参数的二进制表达中的 1 的位的个数。

示例：

import std.math.countOne

main() {
    let n: Int8 = 15
    let countOne = countOne(n)
    println(countOne)
}

运行结果:

4

func countOne(UInt16)

public func countOne(x: UInt16): Int8

功能：求 16 位无符号整型的二进制表达中的 1 的位的个数。

参数：

• x: UInt16 - 传入的 16 位无符号整数。

返回值：

• Int8 - 返回传入参数的二进制表达中的 1 的位的个数。

示例：

import std.math.countOne

main() {
    let n: UInt16 = 15
    let countOne = countOne(n)
    println(countOne)
}

运行结果:

4

func countOne(UInt32)

public func countOne(x: UInt32): Int8

功能：求 32 位无符号整型的二进制表达中的 1 的位的个数。

参数：

• x: UInt32 - 传入的 32 位无符号整数。

返回值：

• Int8 - 返回传入参数的二进制表达中的 1 的位的个数。

示例：

import std.math.countOne

main() {
    let n: UInt32 = 15
    let countOne = countOne(n)
    println(countOne)
}

运行结果:

4

func countOne(UInt64)

public func countOne(x: UInt64): Int8

功能：求 64 位无符号整型的二进制表达中的 1 的位的个数。

参数：

• x: UInt64 - 传入的 64 位无符号整数。

返回值：

• Int8 - 返回传入参数的二进制表达中的 1 的位的个数。

示例：

import std.math.countOne

main() {
    let n: UInt64 = 15
    let countOne = countOne(n)
    println(countOne)
}

运行结果:

4

func countOne(UInt8)

public func countOne(x: UInt8): Int8

功能：求 8 位无符号整型的二进制表达中的 1 的位的个数。

参数：

• x: UInt8 - 传入的 8 位无符号整数。

返回值：

• Int8 - 返回传入参数的二进制表达中的 1 的位的个数。

示例：

import std.math.countOne

main() {
    let n: UInt8 = 15
    let countOne = countOne(n)
    println(countOne)
}

运行结果:

4

func erf(Float16)

public func erf(x: Float16): Float16

功能：求半精度浮点数的误差值。相关定义是：$$erf(x) = \frac{2}{\sqrt{\pi}}\int_0^xe^{-t^2}dt$$

参数：

• x: Float16 - 传入的半精度浮点数。

返回值：

• Float16 - 返回传入参数的半精度浮点数的误差值。

示例：

import std.math.erf

main() {
    let n: Float16 = 5.0
    let erf = erf(n)
    println(erf)
}

运行结果:

1.000000

func erf(Float32)

public func erf(x: Float32): Float32

功能：求单精度浮点数的误差值。相关定义是：$$erf(x) = \frac{2}{\sqrt{\pi}}\int_0^xe^{-t^2}dt$$

参数：

• x: Float32 - 传入的单精度浮点数。

返回值：

• Float32 - 返回传入参数的单精度浮点数的误差值。

示例：

import std.math.erf

main() {
    let n: Float32 = 5.0
    let erf = erf(n)
    println(erf)
}

运行结果:

1.000000

func erf(Float64)

public func erf(x: Float64): Float64

功能：求双精度浮点数的误差值。相关定义是：$$erf(x) = \frac{2}{\sqrt{\pi}}\int_0^xe^{-t^2}dt$$

参数：

• x: Float64 - 传入的双精度浮点数。

返回值：

• Float64 - 返回传入参数的双精度浮点数的误差值。

示例：

import std.math.erf

main() {
    let n: Float64 = 5.0
    let erf = erf(n)
    println(erf)
}

运行结果:

1.000000

func exp(Float16)

public func exp(x: Float16): Float16

功能：求自然常数 e 的 x 次幂。

参数：

• x: Float16 - 传入的半精度浮点数指数。

返回值：

• Float16 - 返回自然常数 e 的 x 次幂。

示例：

import std.math.exp

main() {
    let n: Float16 = 1.0
    let exp = exp(n)
    println(exp)
}

运行结果:

2.718750

func exp(Float32)

public func exp(x: Float32): Float32

功能：求自然常数 e 的 x 次幂。

参数：

• x: Float32 - 传入的单精度浮点数指数。

返回值：

• Float32 - 返回自然常数 e 的 x 次幂。

示例：

import std.math.exp

main() {
    let n: Float32 = 1.0
    let exp = exp(n)
    println(exp)
}

运行结果:

2.718282

func exp(Float64)

public func exp(x: Float64): Float64

功能：求自然常数 e 的 x 次幂。

参数：

• x: Float64 - 传入的双精度浮点数指数。

返回值：

• Float64 - 返回自然常数 e 的 x 次幂。

示例：

import std.math.exp

main() {
    let n: Float64 = 1.0
    let exp = exp(n)
    println(exp)
}

运行结果:

2.718282

func exp2(Float16)

public func exp2(x: Float16): Float16

功能：求 2 的 x 次幂。

参数：

• x: Float16 - 传入的半精度浮点数指数。

返回值：

• Float16 - 返回 2 的 x 次幂。

示例：

import std.math.exp2

main() {
    let n: Float16 = 10.0
    let exp2 = exp2(n)
    println(exp2)
}

运行结果:

1024.000000

func exp2(Float32)

public func exp2(x: Float32): Float32

功能：求 2 的 x 次幂。

参数：

• x: Float32 - 传入的单精度浮点数指数。

返回值：

• Float32 - 返回 2 的 x 次幂。

示例：

import std.math.exp2

main() {
    let n: Float32 = 10.0
    let exp2 = exp2(n)
    println(exp2)
}

运行结果:

1024.000000

func exp2(Float64)

public func exp2(x: Float64): Float64

功能：求 2 的 x 次幂。

参数：

• x: Float64 - 传入的双精度浮点数指数。

返回值：

• Float64 - 返回 2 的 x 次幂。

示例：

import std.math.exp2

main() {
    let n: Float64 = 10.0
    let exp = exp2(n)
    println(exp)
}

运行结果:

1024.000000

func floor(Float16)

public func floor(x: Float16): Float16

功能：求浮点数的向下取整值。

参数：

• x: Float16 - 传入的需要向下取整的半精度浮点数。

返回值：

• Float16 - 返回传入浮点数的向下取整值。

示例：

import std.math.floor

main() {
    let n: Float16 = 10.5
    let floor = floor(n)
    println(floor)
}

运行结果:

10.000000

func floor(Float32)

public func floor(x: Float32): Float32

功能：求浮点数的向下取整值。

参数：

• x: Float32 - 传入的需要向下取整的单精度浮点数。

返回值：

• Float32 - 返回传入浮点数的向下取整值。

示例：

import std.math.floor

main() {
    let n: Float32 = 10.5
    let floor = floor(n)
    println(floor)
}

运行结果:

10.000000

func floor(Float64)

public func floor(x: Float64): Float64

功能：求浮点数的向下取整值。

参数：

• x: Float64 - 传入的需要向下取整的双精度浮点数。

返回值：

• Float64 - 返回传入浮点数的向下取整值。

示例：

import std.math.floor

main() {
    let n: Float64 = 10.5
    let floor = floor(n)
    println(floor)
}

运行结果:

10.000000

func gamma(Float16)

public func gamma(x: Float16): Float16

功能：求浮点数的伽马函数值，该函数是阶乘概念在实数上的推广。

参数：

• x: Float16 - 传入的需要求伽马函数值的半精度浮点数。

返回值：

• Float16 - 返回传入浮点数的伽马函数值。

示例：

import std.math.gamma

main() {
    let n: Float16 = -1.1
    let gamma = gamma(n)
    println(gamma)
}

运行结果:

9.750000

func gamma(Float32)

public func gamma(x: Float32): Float32

功能：求浮点数的伽马函数值，该函数是阶乘概念在实数上的推广。

参数：

• x: Float32 - 传入的需要求伽马函数值的单精度浮点数。

返回值：

• Float32 - 返回传入浮点数的伽马函数值。

示例：

import std.math.gamma

main() {
    let n: Float32 = -1.1
    let gamma = gamma(n)
    println(gamma)
}

运行结果:

9.714804

func gamma(Float64)

public func gamma(x: Float64): Float64

功能：求浮点数的伽马函数值，该函数是阶乘概念在实数上的推广。

参数：

• x: Float64 - 传入的需要求伽马函数值的双精度浮点数。

返回值：

• Float64 - 返回传入浮点数的伽马函数值。

示例：

import std.math.gamma

main() {
    let n: Float64 = -1.1
    let gamma = gamma(n)
    println(gamma)
}

运行结果:

9.714806

func gcd(Int16, Int16)

public func gcd(x: Int16, y: Int16): Int16

功能：求两个 16 位有符号整数的最大公约数。

参数：

• x: Int16 - 传入的需要计算最大公约数的第一个整数。
• y: Int16 - 传入的需要计算最大公约数的第二个整数。

返回值：

• Int16 - 返回两个整数的最大公约数。

异常：

• IllegalArgumentException - 当两参数都为有符号整数最小值，或一个参数为有符号整数的最小值且另一个参数为 0 时，抛出异常。

示例：

import std.math.gcd

main() {
    let x: Int16 = 15
    let y: Int16 = 9
    let gcd = gcd(x, y)
    println(gcd)
}

运行结果:

3

func gcd(Int32, Int32)

public func gcd(x: Int32, y: Int32): Int32

功能：求两个 32 位有符号整数的最大公约数。

参数：

• x: Int32 - 传入的需要计算最大公约数的第一个整数。
• y: Int32 - 传入的需要计算最大公约数的第二个整数。

返回值：

• Int32 - 返回两个整数的最大公约数。

异常：

• IllegalArgumentException - 当两参数都为有符号整数最小值，或一个参数为有符号整数的最小值且另一个参数为 0 时，抛出异常。

示例：

import std.math.gcd

main() {
    let x: Int32 = 15
    let y: Int32 = 9
    let gcd = gcd(x, y)
    println(gcd)
}

运行结果:

3

func gcd(Int64, Int64)

public func gcd(x: Int64, y: Int64): Int64

功能：求两个 64 位有符号整数的最大公约数。

参数：

• x: Int64 - 传入的需要计算最大公约数的第一个整数。
• y: Int64 - 传入的需要计算最大公约数的第二个整数。

返回值：

• Int64 - 返回两个整数的最大公约数。

异常：

• IllegalArgumentException - 当两参数都为有符号整数最小值，或一个参数为有符号整数的最小值且另一个参数为 0 时，抛出异常。

示例：

import std.math.gcd

main() {
    let x: Int64 = 15
    let y: Int64 = 9
    let gcd = gcd(x, y)
    println(gcd)
}

运行结果:

3

func gcd(Int8, Int8)

public func gcd(x: Int8, y: Int8): Int8

功能：求两个 8 位有符号整数的最大公约数。

参数：

• x: Int8 - 传入的需要计算最大公约数的第一个整数。
• y: Int8 - 传入的需要计算最大公约数的第二个整数。

返回值：

• Int8 - 返回两个整数的最大公约数。

异常：

• IllegalArgumentException - 当两参数都为有符号整数最小值，或一个参数为有符号整数的最小值且另一个参数为 0 时，抛出异常。

示例：

import std.math.gcd

main() {
    let x: Int8 = 15
    let y: Int8= 9
    let gcd = gcd(x, y)
    println(gcd)
}

运行结果:

3

func gcd(UInt16, UInt16)

public func gcd(x: UInt16, y: UInt16): UInt16

功能：求两个 16 位无符号整数的最大公约数。

参数：

• x: UInt16 - 传入的需要计算最大公约数的第一个整数。
• y: UInt16 - 传入的需要计算最大公约数的第二个整数。

返回值：

• UInt16 - 返回两个整数的最大公约数。

示例：

import std.math.gcd

main() {
    let x: UInt16 = 15
    let y: UInt16 = 9
    let gcd = gcd(x, y)
    println(gcd)
}

运行结果:

3

func gcd(UInt32, UInt32)

public func gcd(x: UInt32, y: UInt32): UInt32

功能：求两个 32 位无符号整数的最大公约数。

参数：

• x: UInt32 - 传入的需要计算最大公约数的第一个整数。
• y: UInt32 - 传入的需要计算最大公约数的第二个整数。

返回值：

• UInt32 - 返回两个整数的最大公约数。

示例：

import std.math.gcd

main() {
    let x: UInt32 = 15
    let y: UInt32 = 9
    let gcd = gcd(x, y)
    println(gcd)
}

运行结果:

3

func gcd(UInt64, UInt64)

public func gcd(x: UInt64, y: UInt64): UInt64

功能：求两个 64 位无符号整数的最大公约数。

参数：

• x: UInt64 - 传入的需要计算最大公约数的第一个整数。
• y: UInt64 - 传入的需要计算最大公约数的第二个整数。

返回值：

• UInt64 - 返回两个整数的最大公约数。

示例：

import std.math.gcd

main() {
    let x: UInt64 = 15
    let y: UInt64 = 9
    let gcd = gcd(x, y)
    println(gcd)
}

运行结果:

3

func gcd(UInt8, UInt8)

public func gcd(x: UInt8, y: UInt8): UInt8

功能：求两个 8 位无符号整数的最大公约数。

参数：

• x: UInt8 - 传入的需要计算最大公约数的第一个整数。
• y: UInt8 - 传入的需要计算最大公约数的第二个整数。

返回值：

• UInt8 - 返回两个整数的最大公约数。

示例：

import std.math.gcd

main() {
    let x: UInt8 = 15
    let y: UInt8= 9
    let gcd = gcd(x, y)
    println(gcd)
}

运行结果:

3

func lcm(Int16, Int16)

public func lcm(x: Int16, y: Int16): Int16

功能：求两个 16 位有符号整数的最小的非负的公倍数，当入参有 0 时才返回 0。

参数：

• x: Int16 - 传入的需要计算最小公倍数的第一个整数。
• y: Int16 - 传入的需要计算最小公倍数的第二个整数。

返回值：

• Int16 - 返回两个整数的最小的非负的公倍数，当入参有 0 时才返回 0。

异常：

• IllegalArgumentException - 当返回值超出 16 位有符号整数的最大值时抛出异常。

示例：

import std.math.lcm

main() {
    let x: Int16 = -15
    let y: Int16 = 9
    let lcm = lcm(x, y)
    println(lcm)
}

运行结果:

45

func lcm(Int32, Int32)

public func lcm(x: Int32, y: Int32): Int32

功能：求两个 32 位有符号整数的最小的非负的公倍数，当入参有 0 时才返回 0。

参数：

• x: Int32 - 传入的需要计算最小公倍数的第一个整数。
• y: Int32 - 传入的需要计算最小公倍数的第二个整数。

返回值：

• Int32 - 返回两个整数的最小的非负的公倍数，当入参有 0 时才返回 0。

异常：

• IllegalArgumentException - 当返回值超出 32 位有符号整数的最大值时抛出异常。

示例：

import std.math.lcm

main() {
    let x: Int32 = -15
    let y: Int32 = 9
    let lcm = lcm(x, y)
    println(lcm)
}

运行结果:

45

func lcm(Int64, Int64)

public func lcm(x: Int64, y: Int64): Int64

功能：求两个 64 位有符号整数的最小的非负的公倍数，当入参有 0 时才返回 0。

参数：

• x: Int64 - 传入的需要计算最小公倍数的第一个整数。
• y: Int64 - 传入的需要计算最小公倍数的第二个整数。

返回值：

• Int64 - 返回两个整数的最小的非负的公倍数，当入参有 0 时才返回 0。

异常：

• IllegalArgumentException - 当返回值超出 64 位有符号整数的最大值时抛出异常。

示例：

import std.math.lcm

main() {
    let x: Int64 = 15
    let y: Int64 = 9
    let lcm = lcm(x, y)
    println(lcm)
}

运行结果:

45

func lcm(Int8, Int8)

public func lcm(x: Int8, y: Int8): Int8

功能：求两个 8 位有符号整数的最小的非负的公倍数，当入参有 0 时才返回 0。

参数：

• x: Int8 - 传入的需要计算最小公倍数的第一个整数。
• y: Int8 - 传入的需要计算最小公倍数的第二个整数。

返回值：

• Int8 - 返回两个整数的最小的非负的公倍数，当入参有 0 时才返回 0。

异常：

• IllegalArgumentException - 当返回值超出 8 位有符号整数的最大值时抛出异常。

示例：

import std.math.lcm

main() {
    let x: Int8 = 15
    let y: Int8= 9
    let lcm = lcm(x, y)
    println(lcm)
}

运行结果:

45

func lcm(UInt16, UInt16)

public func lcm(x: UInt16, y: UInt16): UInt16

功能：求两个 16 位无符号整数的最小的非负的公倍数，当入参有 0 时才返回 0。

参数：

• x: UInt16 - 传入的需要计算最小公倍数的第一个整数。
• y: UInt16 - 传入的需要计算最小公倍数的第二个整数。

返回值：

• UInt16 - 返回两个整数的最小的非负的公倍数，当入参有 0 时才返回 0。

异常：

• IllegalArgumentException - 当返回值超出 16 位无符号整数的最大值时抛出异常。

示例：

import std.math.lcm

main() {
    let x: UInt16 = 15
    let y: UInt16 = 9
    let lcm = lcm(x, y)
    println(lcm)
}

运行结果:

45

func lcm(UInt32, UInt32)

public func lcm(x: UInt32, y: UInt32): UInt32

功能：求两个 32 位无符号整数的最小的非负的公倍数，当入参有 0 时才返回 0。

参数：

• x: UInt32 - 传入的需要计算最小公倍数的第一个整数。
• y: UInt32 - 传入的需要计算最小公倍数的第二个整数。

返回值：

• UInt32 - 返回两个整数的最小的非负的公倍数，当入参有 0 时才返回 0。

异常：

• IllegalArgumentException - 当返回值超出 32 位无符号整数的最大值时抛出异常。

示例：

import std.math.lcm

main() {
    let x: UInt32 = 15
    let y: UInt32 = 9
    let lcm = lcm(x, y)
    println(lcm)
}

运行结果:

45

func lcm(UInt64, UInt64)

public func lcm(x: UInt64, y: UInt64): UInt64

功能：求两个 64 位无符号整数的最小的非负的公倍数，当入参有 0 时才返回 0。

参数：

• x: UInt64 - 传入的需要计算最小公倍数的第一个整数。
• y: UInt64 - 传入的需要计算最小公倍数的第二个整数。

返回值：

• UInt64 - 返回两个整数的最小的非负的公倍数，当入参有 0 时才返回 0。

异常：

• IllegalArgumentException - 当返回值超出 64 位无符号整数的最大值时抛出异常。

示例：

import std.math.lcm

main() {
    let x: UInt64 = 15
    let y: UInt64 = 9
    let lcm = lcm(x, y)
    println(lcm)
}

运行结果:

45

func lcm(UInt8, UInt8)

public func lcm(x: UInt8, y: UInt8): UInt8

功能：求两个 8 位无符号整数的最小的非负的公倍数，当入参有 0 时才返回 0。

参数：

• x: UInt8 - 传入的需要计算最小公倍数的第一个整数。
• y: UInt8 - 传入的需要计算最小公倍数的第二个整数。

返回值：

• UInt8 - 返回两个整数的最小的非负的公倍数，当入参有 0 时才返回 0。

异常：

• IllegalArgumentException - 当返回值超出 8 位无符号整数的最大值时抛出异常。

示例：

import std.math.lcm

main() {
    let x: UInt8 = 15
    let y: UInt8= 9
    let lcm = lcm(x, y)
    println(lcm)
}

运行结果:

45

func leadingZeros(Int16)

public func leadingZeros(x: Int16): Int8

功能：求 16 位有符号整数的二进制表达中的从最高位算起，连续位为 0 的个数。如果最高位不是 0，则返回 0。

参数：

• x: Int16 - 需要求前导 0 的整数。

返回值：

• Int8 - 返回前导 0 的位数。

示例：

import std.math.leadingZeros

main() {
    let x: Int16 = 512
    let leadingZeros = leadingZeros(x)
    println(leadingZeros)
}

运行结果:

6

func leadingZeros(Int32)

public func leadingZeros(x: Int32): Int8

功能：求 32 位有符号整数的二进制表达中的从最高位算起，连续位为 0 的个数。如果最高位不是 0，则返回 0。

参数：

• x: Int32 - 需要求前导 0 的整数。

返回值：

• Int8 - 返回前导 0 的位数。

示例：

import std.math.leadingZeros

main() {
    let x: Int32 = 512
    let leadingZeros = leadingZeros(x)
    println(leadingZeros)
}

运行结果:

22

func leadingZeros(Int64)

public func leadingZeros(x: Int64): Int8

功能：求 64 位有符号整数的二进制表达中的从最高位算起，连续位为 0 的个数。如果最高位不是 0，则返回 0。

参数：

• x: Int64 - 需要求前导 0 的整数。

返回值：

• Int8 - 返回前导 0 的位数。

示例：

import std.math.leadingZeros

main() {
    let x: Int64 = 512
    let leadingZeros = leadingZeros(x)
    println(leadingZeros)
}

运行结果:

54

func leadingZeros(Int8)

public func leadingZeros(x: Int8): Int8

功能：求 8 位有符号整数的二进制表达中的从最高位算起，连续位为 0 的个数。如果最高位不是 0，则返回 0。

参数：

• x: Int8 - 需要求前导 0 的整数。

返回值：

• Int8 - 返回前导 0 的位数。

示例：

import std.math.leadingZeros

main() {
    let x: Int8 = 4
    let leadingZeros = leadingZeros(x)
    println(leadingZeros)
}

运行结果:

5

func leadingZeros(UInt16)

public func leadingZeros(x: UInt16): Int8

功能：求 16 位无符号整数的二进制表达中的从最高位算起，连续位为 0 的个数。如果最高位不是 0，则返回 0。

参数：

• x: UInt16 - 需要求前导 0 的整数。

返回值：

• Int8 - 返回前导 0 的位数。

示例：

import std.math.leadingZeros

main() {
    let x: UInt16 = 512
    let leadingZeros = leadingZeros(x)
    println(leadingZeros)
}

运行结果:

6

func leadingZeros(UInt32)

public func leadingZeros(x: UInt32): Int8

功能：求 32 位无符号整数的二进制表达中的从最高位算起，连续位为 0 的个数。如果最高位不是 0，则返回 0。

参数：

• x: UInt32 - 需要求前导 0 的整数。

返回值：

• Int8 - 返回前导 0 的位数。

示例：

import std.math.leadingZeros

main() {
    let x: UInt32 = 512
    let leadingZeros = leadingZeros(x)
    println(leadingZeros)
}

运行结果:

22

func leadingZeros(UInt64)

public func leadingZeros(x: UInt64): Int8

功能：求 64 位无符号整数的二进制表达中的从最高位算起，连续位为 0 的个数。如果最高位不是 0，则返回 0。

参数：

• x: UInt64 - 需要求前导 0 的整数。

返回值：

• Int8 - 返回前导 0 的位数。

示例：

import std.math.leadingZeros

main() {
    let x: UInt64 = 512
    let leadingZeros = leadingZeros(x)
    println(leadingZeros)
}

运行结果:

54

func leadingZeros(UInt8)

public func leadingZeros(x: UInt8): Int8

功能：求 8 位无符号整数的二进制表达中的从最高位算起，连续位为 0 的个数。如果最高位不是 0，则返回 0。

参数：

• x: UInt8 - 需要求前导 0 的整数。

返回值：

• Int8 - 返回前导 0 的位数。

示例：

import std.math.leadingZeros

main() {
    let x: UInt8 = 64
    let leadingZeros = leadingZeros(x)
    println(leadingZeros)
}

运行结果:

1

func log(Float16)

public func log(x: Float16): Float16

功能：求以 e 为底 x 的对数。

参数：

• x: Float16 - 真数。真数需要大于 0。

返回值：

• Float16 - 返回以 e 为底 x 的对数。

异常：

• IllegalArgumentException - 当输入值不为正时，抛出异常。

示例：

import std.math.log

main() {
    let x: Float16 = 2.718282
    let log = log(x)
    println(log)
}

运行结果:

1.000000

func log(Float32)

public func log(x: Float32): Float32

功能：求以 e 为底 x 的对数。

参数：

• x: Float32 - 真数。真数需要大于 0。

返回值：

• Float32 - 返回以 e 为底 x 的对数。

异常：

• IllegalArgumentException - 当输入值不为正时，抛出异常。

示例：

import std.math.log

main() {
    let x: Float32 = 2.718282
    let log = log(x)
    println(log)
}

运行结果:

1.000000

func log(Float64)

public func log(x: Float64): Float64

功能：求以 e 为底 x 的对数。

参数：

• x: Float64 - 真数。真数需要大于 0。

返回值：

• Float64 - 返回以 e 为底 x 的对数。

异常：

• IllegalArgumentException - 当输入值不为正时，抛出异常。

示例：

import std.math.log

main() {
    let x: Float64 = 2.718282
    let log = log(x)
    println(log)
}

运行结果:

1.000000

func log10(Float16)

public func log10(x: Float16): Float16

功能：求以 10 为底 x 的对数。

参数：

• x: Float16 - 真数。真数需要大于 0。

返回值：

• Float16 - 返回以 10 为底 x 的对数。

异常：

• IllegalArgumentException - 当输入值不为正时，抛出异常。

示例：

import std.math.log10

main() {
    let x: Float16 = 1000.0
    let log10 = log10(x)
    println(log10)
}

运行结果:

3.000000

func log10(Float32)

public func log10(x: Float32): Float32

功能：求以 10 为底 x 的对数。

参数：

• x: Float32 - 真数。真数需要大于 0。

返回值：

• Float32 - 返回以 10 为底 x 的对数。

异常：

• IllegalArgumentException - 当输入值不为正时，抛出异常。

示例：

import std.math.log10

main() {
    let x: Float32 = 1000.0
    let log10 = log10(x)
    println(log10)
}

运行结果:

3.000000

func log10(Float64)

public func log10(x: Float64): Float64

功能：求以 10 为底 x 的对数。

参数：

• x: Float64 - 真数。真数需要大于 0。

返回值：

• Float64 - 返回以 10 为底 x 的对数。

异常：

• IllegalArgumentException - 当输入值不为正时，抛出异常。

示例：

import std.math.log10

main() {
    let x: Float64 = 1000.0
    let log10 = log10(x)
    println(log10)
}

运行结果:

3.000000

func log2(Float16)

public func log2(x: Float16): Float16

功能：求以 2 为底 x 的对数。

参数：

• x: Float16 - 真数。真数需要大于 0。

返回值：

• Float16 - 返回以 2 为底 x 的对数。

异常：

• IllegalArgumentException - 当输入值不为正时，抛出异常。

示例：

import std.math.log2

main() {
    let x: Float16 = 1024.0
    let log2 = log2(x)
    println(log2)
}

运行结果:

10.000000

func log2(Float32)

public func log2(x: Float32): Float32

功能：求以 2 为底 x 的对数。

参数：

• x: Float32 - 真数。真数需要大于 0。

返回值：

• Float32 - 返回以 2 为底 x 的对数。

异常：

• IllegalArgumentException - 当输入值不为正时，抛出异常。

示例：

import std.math.log2

main() {
    let x: Float32 = 1024.0
    let log2 = log2(x)
    println(log2)
}

运行结果:

10.000000

func log2(Float64)

public func log2(x: Float64): Float64

功能：求以 2 为底 x 的对数。

参数：

• x: Float64 - 真数。真数需要大于 0。

返回值：

• Float64 - 返回以 2 为底 x 的对数。

异常：

• IllegalArgumentException - 当输入值不为正时，抛出异常。

示例：

import std.math.log2

main() {
    let x: Float64 = 1024.0
    let log2 = log2(x)
    println(log2)
}

运行结果:

10.000000

func logBase(Float16, Float16)

public func logBase(x: Float16, base: Float16): Float16

功能：求以 base 为底 x 的对数。

参数：

• x: Float16 - 真数。真数需要大于 0。
• base: Float16 - 底数。底数需要大于 0，且不能为 1。

返回值：

• Float16 - 返回以以 base 为底 x 的对数。

异常：

• IllegalArgumentException - 当真数或底数不为正，或底数为 1 时，抛出异常。

示例：

import std.math.logBase

main() {
    let x: Float16 = 512.0
    let base: Float16 = 2.0
    let logBase = logBase(x, base)
    println(logBase)
}

运行结果:

9.000000

func logBase(Float32, Float32)

public func logBase(x: Float32, base: Float32): Float32

功能：求以 base 为底 x 的对数。

参数：

• x: Float32 - 真数。真数需要大于 0。
• base: Float32 - 底数。底数需要大于 0，且不能为 1。

返回值：

• Float32 - 返回以以 base 为底 x 的对数。

异常：

• IllegalArgumentException - 当真数或底数不为正，或底数为 1 时，抛出异常。

示例：

import std.math.logBase

main() {
    let x: Float32 = 1024.0
    let base: Float32 = 2.0
    let logBase = logBase(x, base)
    println(logBase)
}

运行结果:

10.000000

func logBase(Float64, Float64)

public func logBase(x: Float64, base: Float64): Float64

功能：求以 base 为底 x 的对数。

参数：

• x: Float64 - 真数。真数需要大于 0。
• base: Float64 - 底数。底数需要大于 0，且不能为 1。

返回值：

• Float64 - 返回以以 base 为底 x 的对数。

异常：

• IllegalArgumentException - 当真数或底数不为正，或底数为 1 时，抛出异常。

示例：

import std.math.logBase

main() {
    let x: Float64 = 1024.0
    let base: Float64 = 2.0
    let logBase = logBase(x, base)
    println(logBase)
}

运行结果:

10.000000

func max(Float16, Float16)

public func max(a: Float16, b: Float16): Float16

功能：求两个数的最大值。若入参有 NaN，则返回 NaN。

参数：

• a: Float16 - 需要比较大小的第一个数。
• b: Float16 - 需要比较大小的第二个数。

返回值：

• Float16 - 返回两个数的最大值。若入参有 NaN，则返回 NaN。

示例：

import std.math.max

main() {
    let a: Float16 = 1.0
    let b: Float16 = 2.0
    let max = max(a, b)
    println(max)
}

运行结果:

2.000000

func max(Float32, Float32)

public func max(a: Float32, b: Float32): Float32

功能：求两个数的最大值。若入参有 NaN，则返回 NaN。

参数：

• a: Float32 - 需要比较大小的第一个数。
• b: Float32 - 需要比较大小的第二个数。

返回值：

• Float32 - 返回两个数的最大值。若入参有 NaN，则返回 NaN。

示例：

import std.math.max

main() {
    let a: Float32 = 1.0
    let b: Float32 = 2.0
    let max = max(a, b)
    println(max)
}

运行结果:

2.000000

func max(Float64, Float64)

public func max(a: Float64, b: Float64): Float64

功能：求两个数的最大值。若入参有 NaN，则返回 NaN。

参数：

• a: Float64 - 需要比较大小的第一个数。
• b: Float64 - 需要比较大小的第二个数。

返回值：

• Float64 - 返回两个数的最大值。若入参有 NaN，则返回 NaN。

示例：

import std.math.max

main() {
    let a: Float64 = 1.0
    let b: Float64 = 2.0
    let max = max(a, b)
    println(max)
}

运行结果:

2.000000

func max(Int16, Int16)

public func max(a: Int16, b: Int16): Int16

功能：求两个数的最大值。

参数：

• a: Int16 - 需要比较大小的第一个数。
• b: Int16 - 需要比较大小的第二个数。

返回值：

• Int16 - 返回两个数的最大值。

示例：

import std.math.max

main() {
    let a: Int16 = -1
    let b: Int16 = 2
    let max = max(a, b)
    println(max)
}

运行结果:

2

func max(Int32, Int32)

public func max(a: Int32, b: Int32): Int32

功能：求两个数的最大值。

参数：

• a: Int32 - 需要比较大小的第一个数。
• b: Int32 - 需要比较大小的第二个数。

返回值：

• Int32 - 返回两个数的最大值。

示例：

import std.math.max

main() {
    let a: Int32 = -1
    let b: Int32 = 2
    let max = max(a, b)
    println(max)
}

运行结果:

2

func max(Int64, Int64)

public func max(a: Int64, b: Int64): Int64

功能：求两个数的最大值。

参数：

• a: Int64 - 需要比较大小的第一个数。
• b: Int64 - 需要比较大小的第二个数。

返回值：

• Int64 - 返回两个数的最大值。

示例：

import std.math.max

main() {
    let a: Int64 = -1
    let b: Int64 = 2
    let max = max(a, b)
    println(max)
}

运行结果:

2

func max(Int8, Int8)

public func max(a: Int8, b: Int8): Int8

功能：求两个数的最大值。

参数：

• a: Int8 - 需要比较大小的第一个数。
• b: Int8 - 需要比较大小的第二个数。

返回值：

• Int8 - 返回两个数的最大值。

示例：

import std.math.max

main() {
    let a: Int8 = -1
    let b: Int8 = 2
    let max = max(a, b)
    println(max)
}

运行结果:

2

func max(UInt16, UInt16)

public func max(a: UInt16, b: UInt16): UInt16

功能：求两个数的最大值。

参数：

• a: UInt16 - 需要比较大小的第一个数。
• b: UInt16 - 需要比较大小的第二个数。

返回值：

• UInt16 - 返回两个数的最大值。

示例：

import std.math.max

main() {
    let a: UInt16 = 1
    let b: UInt16 = 2
    let max = max(a, b)
    println(max)
}

运行结果:

2

func max(UInt32, UInt32)

public func max(a: UInt32, b: UInt32): UInt32

功能：求两个数的最大值。

参数：

• a: UInt32 - 需要比较大小的第一个数。
• b: UInt32 - 需要比较大小的第二个数。

返回值：

• UInt32 - 返回两个数的最大值。

示例：

import std.math.max

main() {
    let a: UInt32 = 1
    let b: UInt32 = 2
    let max = max(a, b)
    println(max)
}

运行结果:

2

func max(UInt64, UInt64)

public func max(a: UInt64, b: UInt64): UInt64

功能：求两个数的最大值。

参数：

• a: UInt64 - 需要比较大小的第一个数。
• b: UInt64 - 需要比较大小的第二个数。

返回值：

• UInt64 - 返回两个数的最大值。

示例：

import std.math.max

main() {
    let a: UInt64 = 1
    let b: UInt64 = 2
    let max = max(a, b)
    println(max)
}

运行结果:

2

func max(UInt8, UInt8)

public func max(a: UInt8, b: UInt8): UInt8

功能：求两个数的最大值。

参数：

• a: UInt8 - 需要比较大小的第一个数。
• b: UInt8 - 需要比较大小的第二个数。

返回值：

• UInt8 - 返回两个数的最大值。

示例：

import std.math.max

main() {
    let a: UInt8 = 1
    let b: UInt8 = 2
    let max = max(a, b)
    println(max)
}

运行结果:

2

func maxNaN(Float16, Float16)

public func maxNaN(a: Float16, b: Float16): Float16

功能：求两个数的最大值。maxNaN 仅支持浮点数，若入参有 NaN，则返回 NaN。

参数：

• a: Float16 - 需要比较大小的第一个数。
• b: Float16 - 需要比较大小的第二个数。

返回值：

• Float16 - 返回两个数的最大值。若入参有 NaN，则返回 NaN。

示例：

import std.math.maxNaN

main() {
    let a: Float16 = 1.0
    let b: Float16 = 2.0
    let maxNaN = maxNaN(a, b)
    println(maxNaN)
}

运行结果:

2.000000

func maxNaN(Float32, Float32)

public func maxNaN(a: Float32, b: Float32): Float32

功能：求两个数的最大值。maxNaN 仅支持浮点数，若入参有 NaN，则返回 NaN。

参数：

• a: Float32 - 需要比较大小的第一个数。
• b: Float32 - 需要比较大小的第二个数。

返回值：

• Float32 - 返回两个数的最大值。若入参有 NaN，则返回 NaN。

示例：

import std.math.maxNaN

main() {
    let a: Float32 = 1.0
    let b: Float32 = 2.0
    let maxNaN = maxNaN(a, b)
    println(maxNaN)
}

运行结果:

2.000000

func maxNaN(Float64, Float64)

public func maxNaN(a: Float64, b: Float64): Float64

功能：求两个数的最大值。maxNaN 仅支持浮点数，若入参有 NaN，则返回 NaN。

参数：

• a: Float64 - 需要比较大小的第一个数。
• b: Float64 - 需要比较大小的第二个数。

返回值：

• Float64 - 返回两个数的最大值。若入参有 NaN，则返回 NaN。

示例：

import std.math.maxNaN

main() {
    let a: Float64 = 1.0
    let b: Float64 = 2.0
    let maxNaN = maxNaN(a, b)
    println(maxNaN)
}

运行结果:

2.000000

func min(Float16, Float16)

public func min(a: Float16, b: Float16): Float16

功能：求两个数的最小值。若入参有 NaN，则返回 NaN。

参数：

• a: Float16 - 需要比较大小的第一个数。
• b: Float16 - 需要比较大小的第二个数。

返回值：

• Float16 - 返回两个数的最小值。若入参有 NaN，则返回 NaN。

示例：

import std.math.min

main() {
    let a: Float16 = 1.0
    let b: Float16 = 2.0
    let min = min(a, b)
    println(min)
}

运行结果:

1.000000

func min(Float32, Float32)

public func min(a: Float32, b: Float32): Float32

功能：求两个数的最小值。若入参有 NaN，则返回 NaN。

参数：

• a: Float32 - 需要比较大小的第一个数。
• b: Float32 - 需要比较大小的第二个数。

返回值：

• Float32 - 返回两个数的最小值。若入参有 NaN，则返回 NaN。

示例：

import std.math.min

main() {
    let a: Float32 = 1.0
    let b: Float32 = 2.0
    let min = min(a, b)
    println(min)
}

运行结果:

1.000000

func min(Float64, Float64)

public func min(a: Float64, b: Float64): Float64

功能：求两个数的最小值。若入参有 NaN，则返回 NaN。

参数：

• a: Float64 - 需要比较大小的第一个数。
• b: Float64 - 需要比较大小的第二个数。

返回值：

• Float64 - 返回两个数的最小值。若入参有 NaN，则返回 NaN。

示例：

import std.math.min

main() {
    let a: Float64 = 1.0
    let b: Float64 = 2.0
    let min = min(a, b)
    println(min)
}

运行结果:

1.000000

func min(Int16, Int16)

public func min(a: Int16, b: Int16): Int16

功能：求两个数的最小值。

参数：

• a: Int16 - 需要比较大小的第一个数。
• b: Int16 - 需要比较大小的第一个数。

返回值：

• Int16 - 返回两个数的最小值。

示例：

import std.math.min

main() {
    let a: Int16 = -1
    let b: Int16 = 2
    let min = min(a, b)
    println(min)
}

运行结果:

-1

func min(Int32, Int32)

public func min(a: Int32, b: Int32): Int32

功能：求两个数的最小值。

参数：

• a: Int32 - 需要比较大小的第一个数。
• b: Int32 - 需要比较大小的第一个数。

返回值：

• Int32 - 返回两个数的最小值。

示例：

import std.math.min

main() {
    let a: Int32 = -1
    let b: Int32 = 2
    let min = min(a, b)
    println(min)
}

运行结果:

-1

func min(Int64, Int64)

public func min(a: Int64, b: Int64): Int64

功能：求两个数的最小值。

参数：

• a: Int64 - 需要比较大小的第一个数。
• b: Int64 - 需要比较大小的第一个数。

返回值：

• Int64 - 返回两个数的最小值。

示例：

import std.math.min

main() {
    let a: Int64 = -1
    let b: Int64 = 2
    let min = min(a, b)
    println(min)
}

运行结果:

-1

func min(Int8, Int8)

public func min(a: Int8, b: Int8): Int8

功能：求两个数的最小值。

参数：

• a: Int8 - 需要比较大小的第一个数。
• b: Int8 - 需要比较大小的第一个数。

返回值：

• Int8 - 返回两个数的最小值。

示例：

import std.math.min

main() {
    let a: Int8 = -1
    let b: Int8 = 2
    let min = min(a, b)
    println(min)
}

运行结果:

-1

func min(UInt16, UInt16)

public func min(a: UInt16, b: UInt16): UInt16

功能：求两个数的最小值。

参数：

• a: UInt16 - 需要比较大小的第一个数。
• b: UInt16 - 需要比较大小的第一个数。

返回值：

• UInt16 - 返回两个数的最小值。

示例：

import std.math.min

main() {
    let a: UInt16 = 1
    let b: UInt16 = 2
    let min = min(a, b)
    println(min)
}

运行结果:

1

func min(UInt32, UInt32)

public func min(a: UInt32, b: UInt32): UInt32

功能：求两个数的最小值。

参数：

• a: UInt32 - 需要比较大小的第一个数。
• b: UInt32 - 需要比较大小的第一个数。

返回值：

• UInt32 - 返回两个数的最小值。

示例：

import std.math.min

main() {
    let a: UInt32 = 1
    let b: UInt32 = 2
    let min = min(a, b)
    println(min)
}

运行结果:

1

func min(UInt64, UInt64)

public func min(a: UInt64, b: UInt64): UInt64

功能：求两个数的最小值。

参数：

• a: UInt64 - 需要比较大小的第一个数。
• b: UInt64 - 需要比较大小的第一个数。

返回值：

• UInt64 - 返回两个数的最小值。

示例：

import std.math.min

main() {
    let a: UInt64 = 1
    let b: UInt64 = 2
    let min = min(a, b)
    println(min)
}

运行结果:

1

func min(UInt8, UInt8)

public func min(a: UInt8, b: UInt8): UInt8

功能：求两个数的最小值。

参数：

• a: UInt8 - 需要比较大小的第一个数。
• b: UInt8 - 需要比较大小的第一个数。

返回值：

• UInt8 - 返回两个数的最小值。

示例：

import std.math.min

main() {
    let a: UInt8 = 1
    let b: UInt8 = 2
    let min = min(a, b)
    println(min)
}

运行结果:

1

func minNaN(Float16, Float16)

public func minNaN(a: Float16, b: Float16): Float16

功能：求两个数的最小值。minNaN 仅支持浮点数，若入参有 NaN，则返回 NaN。

参数：

• a: Float16 - 需要比较大小的第一个数。
• b: Float16 - 需要比较大小的第二个数。

返回值：

• Float16 - 返回两个数的最小值。若入参有 NaN，则返回 NaN。

示例：

import std.math.minNaN

main() {
    let a: Float16 = 1.0
    let b: Float16 = 2.0
    let minNaN = minNaN(a, b)
    println(minNaN)
}

运行结果:

1.000000

func minNaN(Float32, Float32)

public func minNaN(a: Float32, b: Float32): Float32

功能：求两个数的最小值。minNaN 仅支持浮点数，若入参有 NaN，则返回 NaN。

参数：

• a: Float32 - 需要比较大小的第一个数。
• b: Float32 - 需要比较大小的第二个数。

返回值：

• Float32 - 返回两个数的最小值。若入参有 NaN，则返回 NaN。

示例：

import std.math.minNaN

main() {
    let a: Float32 = 1.0
    let b: Float32 = 2.0
    let minNaN = minNaN(a, b)
    println(minNaN)
}

运行结果:

1.000000

func minNaN(Float64, Float64)

public func minNaN(a: Float64, b: Float64): Float64

功能：求两个数的最小值。minNaN 仅支持浮点数，若入参有 NaN，则返回 NaN。

参数：

• a: Float64 - 需要比较大小的第一个数。
• b: Float64 - 需要比较大小的第二个数。

返回值：

• Float64 - 返回两个数的最小值。若入参有 NaN，则返回 NaN。

示例：

import std.math.minNaN

main() {
    let a: Float64 = 1.0
    let b: Float64 = 2.0
    let minNaN = minNaN(a, b)
    println(minNaN)
}

运行结果:

1.000000

func pow(Float32, Float32)

public func pow(base: Float32, exponent: Float32): Float32

功能：求浮点数 base 的 exponent 次幂。

参数：

• base: Float32 - 底数。
• exponent: Float32 - 指数。

返回值：

• Float32 - 返回传入浮点数 base 的 exponent 次幂。如果值不存在，则返回 nan。

示例：

import std.math.pow

main() {
    let base: Float32 = -1.0
    let exponent: Float32 = 0.5
    let pow = pow(base, exponent)
    println(pow)
}

运行结果:

nan

func pow(Float32, Int32)

public func pow(base: Float32, exponent: Int32): Float32

功能：求浮点数 base 的 exponent 次幂。

参数：

• base: Float32 - 底数。
• exponent: Int32 - 指数。

返回值：

• Float32 - 返回传入浮点数 base 的 exponent 次幂。

示例：

import std.math.pow

main() {
    let base: Float32 = -1.0
    let exponent: Int32 = 2
    let pow = pow(base, exponent)
    println(pow)
}

运行结果:

1.000000

func pow(Float64, Float64)

public func pow(base: Float64, exponent: Float64): Float64

功能：求浮点数 base 的 exponent 次幂。

参数：

• base: Float64 - 底数。
• exponent: Float64 - 指数。

返回值：

• Float64 - 返回传入浮点数 base 的 exponent 次幂。如果值不存在，则返回 nan。

示例：

import std.math.pow

main() {
    let base: Float64 = -1.0
    let exponent: Float64 = 0.5
    let pow = pow(base, exponent)
    println(pow)
}

运行结果:

nan

func pow(Float64, Int64)

public func pow(base: Float64, exponent: Int64): Float64

功能：求浮点数 base 的 exponent 次幂。

参数：

• base: Float64 - 底数。
• exponent: Int64 - 指数。

返回值：

• Float64 - 返回传入浮点数 base 的 exponent 次幂。

示例：

import std.math.pow

main() {
    let base: Float64 = -1.0
    let exponent: Int64 = 2
    let pow = pow(base, exponent)
    println(pow)
}

运行结果:

1.000000

func reverse(UInt16)

public func reverse(x: UInt16): UInt16

功能：求无符号整数按位反转后的数。

参数：

• x: UInt16 - 需要进行反转的无符号整数。

返回值：

• UInt16 - 返回反转后的无符号数。

示例：

import std.math.reverse

main() {
    let n: UInt16 = 0x8000
    let reverse = reverse(n)
    println(reverse)
}

运行结果:

1

func reverse(UInt32)

public func reverse(x: UInt32): UInt32

功能：求无符号整数按位反转后的数。

参数：

• x: UInt32 - 需要进行反转的无符号整数。

返回值：

• UInt32 - 返回反转后的无符号数。

示例：

import std.math.reverse

main() {
    let n: UInt32 = 0x8000_0000
    let reverse = reverse(n)
    println(reverse)
}

运行结果:

1

func reverse(UInt64)

public func reverse(x: UInt64): UInt64

功能：求无符号整数按位反转后的数。

参数：

• x: UInt64 - 需要进行反转的无符号整数。

返回值：

• UInt64 - 返回反转后的无符号数。

示例：

import std.math.reverse

main() {
    let n: UInt64 = 0x8000_0000_0000_0000
    let reverse = reverse(n)
    println(reverse)
}

运行结果:

1

func reverse(UInt8)

public func reverse(x: UInt8): UInt8

功能：求无符号整数按位反转后的数。

参数：

• x: UInt8 - 需要进行反转的无符号整数。

返回值：

• UInt8 - 返回反转后的无符号数。

示例：

import std.math.reverse

main() {
    let n: UInt8 = 0x80
    let reverse = reverse(n)
    println(reverse)
}

运行结果:

1

func rotate(Int16, Int8)

public func rotate(num: Int16, d: Int8): Int16

功能：求整数的按位旋转后的结果。

参数：

• num: Int16 - 传入一个整数。
• d: Int8 - 旋转位数，负数右移，正数左移。

返回值：

• Int16 - 返回旋转后的整数。

示例：

import std.math.rotate

main() {
    let n: Int16 = 1
    let rotate = rotate(n, 2)
    println(rotate)
}

运行结果:

4

func rotate(Int32, Int8)

public func rotate(num: Int32, d: Int8): Int32

功能：求整数的按位旋转后的结果。

参数：

• num: Int32 - 传入一个整数。
• d: Int8 - 旋转位数，负数右移，正数左移。

返回值：

• Int32 - 返回旋转后的整数。

示例：

import std.math.rotate

main() {
    let n: Int32 = 1
    let rotate = rotate(n, 2)
    println(rotate)
}

运行结果:

4

func rotate(Int64, Int8)

public func rotate(num: Int64, d: Int8): Int64

功能：求整数的按位旋转后的结果。

参数：

• num: Int64 - 传入一个整数。
• d: Int8 - 旋转位数，负数右移，正数左移。

返回值：

• Int64 - 返回旋转后的整数。

示例：

import std.math.rotate

main() {
    let n: Int64 = 1
    let rotate = rotate(n, 2)
    println(rotate)
}

运行结果:

4

func rotate(Int8, Int8)

public func rotate(num: Int8, d: Int8): Int8

功能：求整数的按位旋转后的结果。

参数：

• num: Int8 - 传入一个整数。
• d: Int8 - 旋转位数，负数右移，正数左移。

返回值：

• Int8 - 返回旋转后的整数。

示例：

import std.math.rotate

main() {
    let n: Int8 = 1
    let rotate = rotate(n, 2)
    println(rotate)
}

运行结果:

4

func rotate(UInt16, Int8)

public func rotate(num: UInt16, d: Int8): UInt16

功能：求整数的按位旋转后的结果。

参数：

• num: UInt16 - 传入一个整数。
• d: Int8 - 旋转位数，负数右移，正数左移。

返回值：

• UInt16 - 返回旋转后的整数。

示例：

import std.math.rotate

main() {
    let n: UInt16 = 1
    let rotate = rotate(n, 2)
    println(rotate)
}

运行结果:

4

func rotate(UInt32, Int8)

public func rotate(num: UInt32, d: Int8): UInt32

功能：求整数的按位旋转后的结果。

参数：

• num: UInt32 - 传入一个整数。
• d: Int8 - 旋转位数，负数右移，正数左移。

返回值：

• UInt32 - 返回旋转后的整数。

示例：

import std.math.rotate

main() {
    let n: UInt32 = 1
    let rotate = rotate(n, 2)
    println(rotate)
}

运行结果:

4

func rotate(UInt64, Int8)

public func rotate(num: UInt64, d: Int8): UInt64

功能：求整数的按位旋转后的结果。

参数：

• num: UInt64 - 传入一个整数。
• d: Int8 - 旋转位数，负数右移，正数左移。

返回值：

• UInt64 - 返回旋转后的整数。

示例：

import std.math.rotate

main() {
    let n: UInt64 = 1
    let rotate = rotate(n, 2)
    println(rotate)
}

运行结果:

4

func rotate(UInt8, Int8)

public func rotate(num: UInt8, d: Int8): UInt8

功能：求整数的按位旋转后的结果。

参数：

• num: UInt8 - 传入一个整数。
• d: Int8 - 旋转位数，负数右移，正数左移。

返回值：

• UInt8 - 返回旋转后的整数。

示例：

import std.math.rotate

main() {
    let n: UInt8 = 1
    let rotate = rotate(n, 2)
    println(rotate)
}

运行结果:

4

func round(Float16)

public func round(x: Float16): Float16

功能：此函数采用 IEEE-754 的向最近舍入规则，计算浮点数的舍入值。如果该浮点数有两个最近整数，则向偶数舍入。

参数：

• x: Float16 - 需要计算舍入值的浮点数。

返回值：

• Float16 - 返回浮点数向最近整数方向的舍入值。如果该浮点数有两个最近整数，则返回向偶数舍入值。

示例：

import std.math.round

main() {
    let n: Float16 = 1.5
    let round = round(n)
    println(round)
}

运行结果:

2.000000

func round(Float32)

public func round(x: Float32): Float32

功能：此函数采用 IEEE-754 的向最近舍入规则，计算浮点数的舍入值。如果该浮点数有两个最近整数，则向偶数舍入。

参数：

• x: Float32 - 需要计算舍入值的浮点数。

返回值：

• Float32 - 返回浮点数向最近整数方向的舍入值。如果该浮点数有两个最近整数，则返回向偶数舍入值。

示例：

import std.math.round

main() {
    let n: Float32 = 1.5
    let round = round(n)
    println(round)
}

运行结果:

2.000000

func round(Float64)

public func round(x: Float64): Float64

功能：此函数采用 IEEE-754 的向最近舍入规则，计算浮点数的舍入值。如果该浮点数有两个最近整数，则向偶数舍入。

参数：

• x: Float64 - 需要计算舍入值的浮点数。

返回值：

• Float64 - 返回浮点数向最近整数方向的舍入值。如果该浮点数有两个最近整数，则返回向偶数舍入值。

示例：

import std.math.round

main() {
    let n: Float64 = 1.5
    let round = round(n)
    println(round)
}

运行结果:

2.000000

func sin(Float16)

public func sin(x: Float16): Float16

功能：计算半精度浮点数的正弦函数值。

参数：

• x: Float16 - 传入的半精度浮点数，入参单位为弧度。

返回值：

• Float16 - 返回传入参数的正弦函数值。

示例：

import std.math.sin

main() {
    let n: Float16 = 3.1415926/2.0
    let sin = sin(n)
    println(sin)
}

运行结果:

1.000000

func sin(Float32)

public func sin(x: Float32): Float32

功能：计算单精度浮点数的正弦函数值。

参数：

• x: Float32 - 传入的单精度浮点数，入参单位为弧度。

返回值：

• Float32 - 返回传入参数的正弦函数值。

示例：

import std.math.sin

main() {
    let n: Float32 = 3.1415926/2.0
    let sin = sin(n)
    println(sin)
}

运行结果:

1.000000

func sin(Float64)

public func sin(x: Float64): Float64

功能：计算双精度浮点数的正弦函数值。

参数：

• x: Float64 - 传入的双精度浮点数，入参单位为弧度。

返回值：

• Float64 - 返回传入参数的正弦函数值。

示例：

import std.math.sin

main() {
    let n: Float64 = 3.1415926/2.0
    let sin = sin(n)
    println(sin)
}

运行结果:

1.000000

func sinh(Float16)

public func sinh(x: Float16): Float16

功能：计算半精度浮点数的双曲正弦函数值。

参数：

• x: Float16 - 传入的半精度浮点数。

返回值：

• Float16 - 返回传入参数的双曲正弦函数值。

示例：

import std.math.sinh

main() {
    let n: Float16 = 0.0
    let sinh = sinh(n)
    println(sinh)
}

运行结果:

0.000000

func sinh(Float32)

public func sinh(x: Float32): Float32

功能：计算单精度浮点数的双曲正弦函数值。

参数：

• x: Float32 - 传入的单精度浮点数。

返回值：

• Float32 - 返回传入参数的双曲正弦函数值。

示例：

import std.math.sinh

main() {
    let n: Float32 = 0.0
    let sinh = sinh(n)
    println(sinh)
}

运行结果:

0.000000

func sinh(Float64)

public func sinh(x: Float64): Float64

功能：计算双精度浮点数的双曲正弦函数值。

参数：

• x: Float64 - 传入的双精度浮点数。

返回值：

• Float64 - 返回传入参数的双曲正弦函数值。

示例：

import std.math.sinh

main() {
    let n: Float64 = 0.0
    let sinh = sinh(n)
    println(sinh)
}

运行结果:

0.000000

func sqrt(Float16)

public func sqrt(x: Float16): Float16

功能：求浮点数的算术平方根。

参数：

• x: Float16 - 需要计算算数平方根的浮点数。x 需要大于等于 0。

返回值：

• Float16 - 返回传入的浮点数的算术平方根。

异常：

• IllegalArgumentException - 当参数为负数时，抛出异常。

示例：

import std.math.sqrt

main() {
    let n: Float16 = 16.0
    let sqrt = sqrt(n)
    println(sqrt)
}

运行结果:

4.000000

func sqrt(Float32)

public func sqrt(x: Float32): Float32

功能：求浮点数的算术平方根。

参数：

• x: Float32 - 需要计算算数平方根的浮点数。x 需要大于等于 0。

返回值：

• Float32 - 返回传入的浮点数的算术平方根。

异常：

• IllegalArgumentException - 当参数为负数时，抛出异常。

示例：

import std.math.sqrt

main() {
    let n: Float32 = 16.0
    let sqrt = sqrt(n)
    println(sqrt)
}

运行结果:

4.000000

func sqrt(Float64)

public func sqrt(x: Float64): Float64

功能：求浮点数的算术平方根。

参数：

• x: Float64 - 需要计算算数平方根的浮点数。x 需要大于等于 0。

返回值：

• Float64 - 返回传入的浮点数的算术平方根。

异常：

• IllegalArgumentException - 当参数为负数时，抛出异常。

示例：

import std.math.sqrt

main() {
    let n: Float64 = 16.0
    let sqrt = sqrt(n)
    println(sqrt)
}

运行结果:

4.000000

func tan(Float16)

public func tan(x: Float16): Float16

功能：计算半精度浮点数的正切函数值。

参数：

• x: Float16 - 传入的半精度浮点数，入参单位为弧度。

返回值：

• Float16 - 返回传入参数的正切函数值。

示例：

import std.math.tan

main() {
    let n: Float16 = 0.0
    let tan = tan(n)
    println(tan)
}

运行结果:

0.000000

func tan(Float32)

public func tan(x: Float32): Float32

功能：计算单精度浮点数的正切函数值。

参数：

• x: Float32 - 传入的单精度浮点数，入参单位为弧度。

返回值：

• Float32 - 返回传入参数的正切函数值。

示例：

import std.math.tan

main() {
    let n: Float32 = 0.0
    let tan = tan(n)
    println(tan)
}

运行结果:

0.000000

func tan(Float64)

public func tan(x: Float64): Float64

功能：计算双精度浮点数的正切函数值。

参数：

• x: Float64 - 传入的双精度浮点数，入参单位为弧度。

返回值：

• Float64 - 返回传入参数的正切函数值。

示例：

import std.math.tan

main() {
    let n: Float64 = 0.0
    let tan = tan(n)
    println(tan)
}

运行结果:

0.000000

func tanh(Float16)

public func tanh(x: Float16): Float16

功能：计算半精度浮点数的双曲正切函数值。

参数：

• x: Float16 - 传入的半精度浮点数。

返回值：

• Float16 - 返回传入参数的双曲正切函数值。

示例：

import std.math.tanh

main() {
    let n: Float16 = 0.0
    let tanh = tanh(n)
    println(tanh)
}

运行结果:

0.000000

func tanh(Float32)

public func tanh(x: Float32): Float32

功能：计算单精度浮点数的双曲正切函数值。

参数：

• x: Float32 - 传入的单精度浮点数。

返回值：

• Float32 - 返回传入参数的双曲正切函数值。

示例：

import std.math.tanh

main() {
    let n: Float32 = 0.0
    let tanh = tanh(n)
    println(tanh)
}

运行结果:

0.000000

func tanh(Float64)

public func tanh(x: Float64): Float64

功能：计算双精度浮点数的双曲正切函数值。

参数：

• x: Float64 - 传入的双精度浮点数。

返回值：

• Float64 - 返回传入参数的双曲正切函数值。

示例：

import std.math.tanh

main() {
    let n: Float64 = 0.0
    let tanh = tanh(n)
    println(tanh)
}

运行结果:

0.000000

func throwIllegalArgumentException()

public func throwIllegalArgumentException(): Int64

功能：此函数用于抛出非法参数异常。

返回值：

• Int64 - 返回 0。

异常：

• IllegalArgumentException - 当函数被调用时，抛出异常。

func trailingZeros(Int16)

public func trailingZeros(x: Int16): Int8

功能：求 16 位有符号整数的二进制表达中的从最低位算起，连续位为 0 的个数。如果最低位不是 0，则返回 0。

参数：

• x: Int16 - 需要求后置 0 的整数。

返回值：

• Int8 - 后置 0 的位数。

示例：

import std.math.trailingZeros

main() {
    let x: Int16 = 512
    let trailingZeros = trailingZeros(x)
    println(trailingZeros)
}

运行结果:

9

func trailingZeros(Int32)

public func trailingZeros(x: Int32): Int8

功能：求 32 位有符号整数的二进制表达中的从最低位算起，连续位为 0 的个数。如果最低位不是 0，则返回 0。

参数：

• x: Int32 - 需要求后置 0 的整数。

返回值：

• Int8 - 后置 0 的位数。

示例：

import std.math.trailingZeros

main() {
    let x: Int32 = 512
    let trailingZeros = trailingZeros(x)
    println(trailingZeros)
}

运行结果:

9

func trailingZeros(Int64)

public func trailingZeros(x: Int64): Int8

功能：求 64 位有符号整数的二进制表达中的从最低位算起，连续位为 0 的个数。如果最低位不是 0，则返回 0。

参数：

• x: Int64 - 需要求后置 0 的整数。

返回值：

• Int8 - 后置 0 的位数。

示例：

import std.math.trailingZeros

main() {
    let x: Int64 = 512
    let trailingZeros = trailingZeros(x)
    println(trailingZeros)
}

运行结果:

9

func trailingZeros(Int8)

public func trailingZeros(x: Int8): Int8

功能：求 16 位有符号整数的二进制表达中的从最低位算起，连续位为 0 的个数。如果最低位不是 0，则返回 0。

参数：

• x: Int8 - 需要求后置 0 的整数。

返回值：

• Int8 - 后置 0 的位数。

示例：

import std.math.trailingZeros

main() {
    let x: Int8 = 64
    let trailingZeros = trailingZeros(x)
    println(trailingZeros)
}

运行结果:

6

func trailingZeros(UInt16)

public func trailingZeros(x: UInt16): Int8

功能：求 16 位无符号整数的二进制表达中的从最低位算起，连续位为 0 的个数。如果最低位不是 0，则返回 0。

参数：

• x: UInt16 - 需要求后置 0 的整数。

返回值：

• Int8 - 后置 0 的位数。

示例：

import std.math.trailingZeros

main() {
    let x: UInt16 = 512
    let trailingZeros = trailingZeros(x)
    println(trailingZeros)
}

运行结果:

9

func trailingZeros(UInt32)

public func trailingZeros(x: UInt32): Int8

功能：求 32 位无符号整数的二进制表达中的从最低位算起，连续位为 0 的个数。如果最低位不是 0，则返回 0。

参数：

• x: UInt32 - 需要求后置 0 的整数。

返回值：

• Int8 - 后置 0 的位数。

示例：

import std.math.trailingZeros

main() {
    let x: UInt32 = 512
    let trailingZeros = trailingZeros(x)
    println(trailingZeros)
}

运行结果:

9

func trailingZeros(UInt64)

public func trailingZeros(x: UInt64): Int8

功能：求 64 位无符号整数的二进制表达中的从最低位算起，连续位为 0 的个数。如果最低位不是 0，则返回 0。

参数：

• x: UInt64 - 需要求后置 0 的整数。

返回值：

• Int8 - 后置 0 的位数。

示例：

import std.math.trailingZeros

main() {
    let x: UInt64 = 512
    let trailingZeros = trailingZeros(x)
    println(trailingZeros)
}

运行结果:

9

func trailingZeros(UInt8)

public func trailingZeros(x: UInt8): Int8

功能：求 8 位无符号整数的二进制表达中的从最低位算起，连续位为 0 的个数。如果最低位不是 0，则返回 0。

参数：

• x: UInt8 - 需要求后置 0 的整数。

返回值：

• Int8 - 后置 0 的位数。

示例：

import std.math.trailingZeros

main() {
    let x: UInt8 = 64
    let trailingZeros = trailingZeros(x)
    println(trailingZeros)
}

运行结果:

6

func trunc(Float16)

public func trunc(x: Float16): Float16

功能：求浮点数的截断取整值。

参数：

• x: Float16 - 需要截断取整的浮点数。

返回值：

• Float16 - 返回传入浮点数截断取整后的值。

示例：

import std.math.trunc

main() {
    let x: Float16 = 64.555566
    let trunc = trunc(x)
    println(trunc)
}

运行结果:

64.000000

func trunc(Float32)

public func trunc(x: Float32): Float32

功能：求浮点数的截断取整值。

参数：

• x: Float32 - 需要截断取整的浮点数。

返回值：

• Float32 - 返回传入浮点数截断取整后的值。

示例：

import std.math.trunc

main() {
    let x: Float32 = 64.555566
    let trunc = trunc(x)
    println(trunc)
}

运行结果:

64.000000

func trunc(Float64)

public func trunc(x: Float64): Float64

功能：求浮点数的截断取整值。

参数：

• x: Float64 - 需要截断取整的浮点数。

返回值：

• Float64 - 返回传入浮点数截断取整后的值。

示例：

import std.math.trunc

main() {
    let x: Float64 = 64.555566
    let trunc = trunc(x)
    println(trunc)
}

运行结果:

64.000000