函数
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
。
异常:
- IllegalArgumentException - 当参数
min
大于参数max
或者min
和max
是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
。
异常:
- IllegalArgumentException - 当参数
min
大于参数max
或者min
和max
是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
。
异常:
- IllegalArgumentException - 当参数
min
大于参数max
或者min
和max
是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 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 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