函数
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 位有符号整数。
返回值：
示例：
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 位有符号整数。
返回值：
示例：
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 位有符号整数。
返回值：
示例：
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 位有符号整数。
返回值：
示例：
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。
参数：
返回值：
- 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。
参数：
返回值：
- 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。
参数：
返回值：
- 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 位有符号整数的最大公约数。
参数：
返回值：
- 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 位有符号整数的最大公约数。
参数：
返回值：
- 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 位有符号整数的最大公约数。
参数：
返回值：
- 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 位有符号整数的最大公约数。
参数：
返回值：
- 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 位无符号整数的最大公约数。
参数：
返回值：
- 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 位无符号整数的最大公约数。
参数：
返回值：
- 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 位无符号整数的最大公约数。
参数：
返回值：
- 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 位无符号整数的最大公约数。
参数：
返回值：
- 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。
参数：
返回值：
- 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。
参数：
返回值：
- 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。
参数：
返回值：
- 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。
参数：
返回值：
- 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。
参数：
返回值：
- 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。
参数：
返回值：
- 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。
参数：
返回值：
- 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。
参数：
返回值：
- 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 - 真数。
返回值：
- Float16 - 返回以 e 为底
x的对数。
说明：
返回值存在如下特殊场景：
示例：
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 - 真数。
返回值：
- Float32 - 返回以 e 为底
x的对数。
说明：
返回值存在如下特殊场景：
示例：
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 - 真数。
返回值：
- Float64 - 返回以 e 为底
x的对数。
说明：
返回值存在如下特殊场景：
示例：
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 - 真数。
返回值：
- Float16 - 返回以 10 为底
x的对数。
说明：
返回值存在如下特殊场景：
示例：
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 - 真数。
返回值：
- Float32 - 返回以 10 为底
x的对数。
说明：
返回值存在如下特殊场景：
示例：
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 - 真数。
返回值：
- Float64 - 返回以 10 为底
x的对数。
说明：
返回值存在如下特殊场景：
示例：
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 - 真数。
返回值：
- Float16 - 返回以 2 为底
x的对数。
说明：
返回值存在如下特殊场景：
示例：
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 - 真数。
返回值：
- Float32 - 返回以 2 为底
x的对数。
说明：
返回值存在如下特殊场景：
示例：
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 - 真数。
返回值：
- Float64 - 返回以 2 为底
x的对数。
说明：
返回值存在如下特殊场景：
示例：
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 的对数。
参数：
返回值：
- 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 的对数。
参数：
返回值：
- 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 的对数。
参数：
返回值：
- 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
参数：
返回值：
示例：
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
参数：
返回值：
示例：
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
参数：
返回值：
示例：
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
功能：求两个数的最大值。
参数：
返回值：
- 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
功能：求两个数的最大值。
参数：
返回值：
- 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
功能：求两个数的最大值。
参数：
返回值：
- 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
功能：求两个数的最大值。
参数：
返回值：
- 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
功能：求两个数的最大值。
参数：
返回值：
- 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
功能：求两个数的最大值。
参数：
返回值：
- 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
功能：求两个数的最大值。
参数：
返回值：
- 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
功能：求两个数的最大值。
参数：
返回值：
- 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。
参数：
返回值：
示例：
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。
参数：
返回值：
示例：
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。
参数：
返回值：
示例：
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
参数：
返回值：
示例：
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
参数：
返回值：
示例：
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
参数：
返回值：
示例：
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
功能：求两个数的最小值。
参数：
返回值：
- 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
功能：求两个数的最小值。
参数：
返回值：
- 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
功能：求两个数的最小值。
参数：
返回值：
- 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
功能：求两个数的最小值。
参数：
返回值：
- 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
功能：求两个数的最小值。
参数：
返回值：
- 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
功能：求两个数的最小值。
参数：
返回值：
- 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
功能：求两个数的最小值。
参数：
返回值：
- 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
功能：求两个数的最小值。
参数：
返回值：
- 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。
参数：
返回值：
示例：
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。
参数：
返回值：
示例：
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。
参数：
返回值：
示例：
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 次幂。
参数：
返回值：
- 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 次幂。
参数：
返回值：
- 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 次幂。
参数：
返回值：
- 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 次幂。
参数：
返回值：
- 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
功能：求整数的按位旋转后的结果。
参数：
返回值：
- 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
功能：求整数的按位旋转后的结果。
参数：
返回值：
- 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
功能：求整数的按位旋转后的结果。
参数：
返回值：
- 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
功能：求整数的按位旋转后的结果。
参数：
返回值：
- 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
功能：求整数的按位旋转后的结果。
参数：
返回值：
- 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
功能：求整数的按位旋转后的结果。
参数：
返回值：
- 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
功能：求整数的按位旋转后的结果。
参数：
返回值：
- 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
功能：求整数的按位旋转后的结果。
参数：
返回值：
- 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