math 包
介绍
math 包提供常见的数学运算，常数定义，浮点数处理等功能。包括了以下能力：
- 科学常数与类型常数定义；
- 浮点数的判断，规整；
- 常用的位运算；
- 通用的数学函数，如绝对值，三角函数，指数，对数计算；
- 最大公约数与最小公倍数。
主要接口
interface MathExtension
public interface MathExtension
为了导出 prop 而作辅助接口，内部为空。
extend Float64 <: MathExtension
extend Float64 <: MathExtension
拓展双精度浮点数以支持一些数学常数。
prop NaN
public static prop NaN: Float64
功能：获取双精度浮点数的非数。
prop Inf
public static prop Inf: Float64
功能：获取双精度浮点数的无穷数。
prop PI
public static prop PI: Float64
功能：获取双精度浮点数的圆周率常数。
prop E
public static prop E: Float64
功能：获取双精度浮点数的自然常数。
prop Max
public static prop Max: Float64
功能：获取双精度浮点数的最大值。
prop Min
public static prop Min: Float64
功能：获取双精度浮点数的最小值。
prop MinDenormal
public static prop MinDenormal: Float64
功能：获取双精度浮点数的最小次正规数。
prop MinNormal
public static prop MinNormal: Float64
功能：获取双精度浮点数的最小正规数。
func isInf
public func isInf(): Bool
功能：根据返回的 Bool 值，判断某个浮点数 Float64 是否为无穷数值。
返回值：如果 Float64 的值正无穷大或负无穷大，则返回 true；否则，返回 false
func isNaN
public func isNaN(): Bool
功能：根据返回的 Bool 值，判断某个浮点数 Float64 是否为非数值。
返回值：如果 Float64 的值为非数值，则返回 true；否则，返回 false
func isNormal
public func isNormal(): Bool
功能：根据返回的 Bool 值，判断某个浮点数 Float64 是否为常规数值。
返回值：如果 Float64 的值是正常的浮点数，返回 true；否则，返回 false
extend Float32 <: MathExtension
extend Float32 <: MathExtension
拓展单精度浮点数以支持一些数学常数。
prop NaN
public static prop NaN: Float32
功能：获取单精度浮点数的非数。
prop Inf
public static prop Inf: Float32
功能：获取单精度浮点数的无穷数。
prop PI
public static prop PI: Float32
功能：获取单精度浮点数的圆周率常数。
prop E
public static prop E: Float32
功能：获取单精度浮点数的自然常数。
prop Max
public static prop Max: Float32
功能：获取单精度浮点数的最大值。
prop Min
public static prop Min: Float32
功能：获取单精度浮点数的最小值。
prop MinDenormal
public static prop MinDenormal: Float32
功能：获取单精度浮点数的最小次正规数。
prop MinNormal
public static prop MinNormal: Float32
功能：获取单精度浮点数的最小正规数。
func isInf
public func isInf(): Bool
功能：根据返回的 Bool 值，判断某个浮点数 Float32 是否为无穷数值。
返回值：如果 Float32 的值正无穷大或负无穷大，则返回 true；否则，返回 false
func isNaN
public func isNaN(): Bool
功能：根据返回的 Bool 值，判断某个浮点数 Float32 是否为非数值。
返回值：如果 Float32 的值为非数值，则返回 true；否则，返回 false
func isNormal
public func isNormal(): Bool
功能：根据返回的 Bool 值，判断某个浮点数 Float32 是否为常规数值。
返回值：如果 Float32 的值是正常的浮点数，返回 true；否则，返回 false
extend Float16 <: MathExtension
extend Float16 <: MathExtension
拓展半精度浮点数以支持一些数学常数。
prop NaN
public static prop NaN: Float16
功能：获取半精度浮点数的非数。
prop Inf
public static prop Inf: Float16
功能：获取半精度浮点数的无穷数。
prop PI
public static prop PI: Float16
功能：获取半精度浮点数的圆周率常数。
prop E
public static prop E: Float16
功能：获取半精度浮点数的自然常数。
prop Max
public static prop Max: Float16
功能：获取半精度浮点数的最大值。
prop Min
public static prop Min: Float16
功能：获取半精度浮点数的最小值。
prop MinDenormal
public static prop MinDenormal: Float16
功能：获取半精度浮点数的最小次正规数。
prop MinNormal
public static prop MinNormal: Float16
功能：获取半精度浮点数的最小正规数。
func isInf
public func isInf(): Bool
功能：根据返回的 Bool 值，判断某个浮点数 Float16 是否为无穷数值。
返回值：如果 Float16 的值正无穷大或负无穷大，则返回 true；否则，返回 false
func isNaN
public func isNaN(): Bool
功能：根据返回的 Bool 值，判断某个浮点数 Float16 是否为非数值。
返回值：如果 Float16 的值为非数值，则返回 true；否则，返回 false
func isNormal
public func isNormal(): Bool
功能：根据返回的 Bool 值，判断某个浮点数 Float16 是否为常规数值。
返回值：如果 Float16 的值是正常的浮点数，返回 true；否则，返回 false
extend Int64 <: MathExtension
extend Int64 <: MathExtension
拓展 64 位有符号整数以支持一些数学常数。
prop Max
public static prop Max: Int64
功能：获取 64 位有符号整数的最大值。
prop Min
public static prop Min: Int64
功能：获取 64 位有符号整数的最小值。
extend Int32 <: MathExtension
extend Int32 <: MathExtension
拓展 32 位有符号整数以支持一些数学常数。
prop Max
public static prop Max: Int32
功能：获取 32 位有符号整数的最大值。
prop Min
public static prop Min: Int32
功能：获取 32 位有符号整数的最小值。
extend Int16 <: MathExtension
extend Int16 <: MathExtension
拓展 16 位有符号整数以支持一些数学常数。
prop Max
public static prop Max: Int16
功能：获取 16 位有符号整数的最大值。
prop Min
public static prop Min: Int16
功能：获取 16 位有符号整数的最小值。
extend Int8 <: MathExtension
extend Int8 <: MathExtension
拓展 8 位有符号整数以支持一些数学常数。
prop Max
public static prop Max: Int8
功能：获取 8 位有符号整数的最大值。
prop Min
public static prop Min: Int8
功能：获取 8 位有符号整数的最小值。
extend UInt64 <: MathExtension
extend UInt64 <: MathExtension
拓展 64 位无符号整数以支持一些数学常数。
prop Max
public static prop Max: UInt64
功能：获取 64 位无符号整数的最大值。
prop Min
public static prop Min: UInt64
功能：获取 64 位无符号整数的最小值。
extend UInt32 <: MathExtension
extend UInt32 <: MathExtension
拓展 32 位无符号整数以支持一些数学常数。
prop Max
public static prop Max: UInt32
功能：获取 32 位无符号整数的最大值。
prop Min
public static prop Min: UInt32
功能：获取 32 位无符号整数的最小值。
extend UInt16 <: MathExtension
extend UInt16 <: MathExtension
拓展 16 位无符号整数以支持一些数学常数。
prop Max
public static prop Max: UInt16
功能：获取 16 位无符号整数的最大值。
prop Min
public static prop Min: UInt16
功能：获取 16 位无符号整数的最小值。
extend UInt8 <: MathExtension
extend UInt8 <: MathExtension
拓展 8 位无符号整数以支持一些数学常数。
prop Max
public static prop Max: UInt8
功能：获取 8 位无符号整数的最大值。
prop Min
public static prop Min: UInt8
功能：获取 8 位无符号整数的最小值。
extend IntNative <: MathExtension
extend IntNative <: MathExtension
拓展平台相关有符号整数以支持一些数学常数。
prop Max
public static prop Max: IntNative
功能：获取平台相关有符号整数的最大值。
prop Min
public static prop Min: IntNative
功能：获取平台相关有符号整数的最小值。
extend UIntNative <: MathExtension
extend UIntNative <: MathExtension
拓展平台相关无符号整数以支持一些数学常数。
prop Max
public static prop Max: UIntNative
功能：获取平台相关无符号整数的最大值。
prop Min
public static prop Min: UIntNative
功能：获取平台相关无符号整数的最小值。
func throwIllegalArgumentException
public func throwIllegalArgumentException(): Int64
功能：此函数用于抛出非法参数异常。
func abs
public func abs(x: Int64): Int64
功能：此函数用于求一个 64 位有符号整数的绝对值。
参数：
x：传入的 64 位有符号整数
返回值：返回传入参数的绝对值
异常：
OverflowException：当输入参数是有符号整数的最小值，抛出异常
func abs
public func abs(x: Int32): Int32
功能：此函数用于求一个 32 位有符号整数的绝对值。
参数：
x：传入的 32 位有符号整数
返回值：返回传入参数的绝对值
异常：
OverflowException：当输入参数是有符号整数的最小值，抛出异常
func abs
public func abs(x: Int16): Int16
功能：此函数用于求一个 16 位有符号整数的绝对值。
参数：
x：传入的 16 位有符号整数
返回值：返回传入参数的绝对值
异常：
OverflowException：当输入参数是有符号整数的最小值，抛出异常
func abs
public func abs(x: Int8): Int8
功能：此函数用于求一个 8 位有符号整数的绝对值。
参数：
x：传入的 8 位有符号整数
返回值：返回传入参数的绝对值
异常：
OverflowException：当输入参数是有符号整数的最小值，抛出异常
func abs
public func abs(x: Float64): Float64
功能：此函数用于求一个双精度浮点数的绝对值。
参数：
x：传入的双精度浮点数
返回值：返回传入参数的绝对值
func abs
public func abs(x: Float32): Float32
功能：此函数用于求一个单精度浮点数的绝对值。
参数：
x：传入的单精度浮点数
返回值：返回传入参数的绝对值
func abs
public func abs(x: Float16): Float16
功能：此函数用于求一个半精度浮点数的绝对值。
参数：
x：传入的半精度浮点数
返回值：返回传入参数的绝对值
func checkedAbs
public func checkedAbs(x: Int64): Option<Int64>
功能：此函数检查并返回整数绝对值的 Option 类型，若参数是有符号整数的最小值，返回 None；否则，返回 Some(abs(x))
参数：
x：传入一个整数
返回值：若参数是有符号整数的最小值，返回 None；否则，返回 Some(abs(x))
func checkedAbs
public func checkedAbs(x: Int32): Option<Int32>
功能：此函数检查并返回整数绝对值的 Option 类型，若参数是有符号整数的最小值，返回 None；否则，返回 Some(abs(x))
参数：
x：传入一个整数
返回值：若参数是有符号整数的最小值，返回 None；否则，返回 Some(abs(x))
func checkedAbs
public func checkedAbs(x: Int16): Option<Int16>
功能：此函数检查并返回整数绝对值的 Option 类型，若参数是有符号整数的最小值，返回 None；否则，返回 Some(abs(x))
参数：
x：传入一个整数
返回值：若参数是有符号整数的最小值，返回 None；否则，返回 Some(abs(x))
func checkedAbs
public func checkedAbs(x: Int8): Option<Int8>
功能：此函数检查并返回整数绝对值的 Option 类型，若参数是有符号整数的最小值，返回 None；否则，返回 Some(abs(x))
参数：
x：传入一个整数
返回值：若参数是有符号整数的最小值，返回 None；否则，返回 Some(abs(x))
func cbrt
public func cbrt(x: Float64): Float64
功能：此函数用于求浮点数的立方根。
参数：
x：传入的浮点数
返回值：浮点数的立方根
func cbrt
public func cbrt(x: Float32): Float32
功能：此函数用于求浮点数的立方根。
参数：
x：传入的浮点数
返回值：浮点数的立方根
func cbrt
public func cbrt(x: Float16): Float16
功能：此函数用于求浮点数的立方根。
参数：
x：传入的浮点数
返回值：浮点数的立方根
func ceil
public func ceil(x: Float64): Float64
功能：此函数用于求浮点数的向上取整值。
参数：
x：传入的浮点数
返回值：返回传入浮点数的向上取整值
func ceil
public func ceil(x: Float32): Float32
功能：此函数用于求浮点数的向上取整值。
参数：
x：传入的浮点数
返回值：返回传入浮点数的向上取整值
func ceil
public func ceil(x: Float16): Float16
功能：此函数用于求浮点数的向上取整值。
参数：
x：传入的浮点数
返回值：返回传入浮点数的向上取整值
func clamp
public func clamp(v: Float64, min: Float64, max: Float64): Float64
功能：此函数用于求浮点数的范围区间数。如果此浮点数在该范围区间则返回此浮点数；如果此浮点数小于这个范围区间，则返回该范围区间的最小值；如果此浮点数大于这个范围区间，则返回该范围区间的最大值；如果是 NaN 则返回 NaN。
参数：
v：传入一个浮点数min：指定最小值max：指定最大值
返回值：如果 v 在 min 与 max 之间则返回 v，如果 v 小于 min 则返回 min，如果 v 大于 max，则返回 max，如果是 NaN 则需要返回 NaN
异常：
IllegalArgumentException：当参数min或参数max为NaN，或参数min大于参数max时，抛出异常
func clamp
public func clamp(v: Float32, min: Float32, max: Float32): Float32
功能：此函数用于求浮点数的范围区间数。如果此浮点数在该范围区间则返回此浮点数；如果此浮点数小于这个范围区间，则返回该范围区间的最小值；如果此浮点数大于这个范围区间，则返回该范围区间的最大值；如果是 NaN 则返回 NaN。
参数：
v：传入一个浮点数min：指定最小值max：指定最大值
返回值：如果 v 在 min 与 max 之间则返回 v，如果 v 小于 min 则返回 min，如果 v 大于 max，则返回 max，如果是 NaN 则需要返回 NaN
异常：
IllegalArgumentException：当参数min或参数max为NaN，或参数min大于参数max时，抛出异常
func clamp
public func clamp(v: Float16, min: Float16, max: Float16): Float16
功能：此函数用于求浮点数的范围区间数。如果此浮点数在该范围区间则返回此浮点数；如果此浮点数小于这个范围区间，则返回该范围区间的最小值；如果此浮点数大于这个范围区间，则返回该范围区间的最大值；如果是 NaN 则返回 NaN。
参数：
v：传入一个浮点数min：指定最小值max：指定最大值
返回值：如果 v 在 min 与 max 之间则返回 v，如果 v 小于 min 则返回 min，如果 v 大于 max，则返回 max，如果是 NaN 则需要返回 NaN
异常：
IllegalArgumentException：当参数min或参数max为NaN，或参数min大于参数max时，抛出异常
func countOne
public func countOne(x: Int64): Int8
功能：此函数用于求二进制表达中值为 1 的位的个数。
参数：
x：传入一个整数
返回值：返回值为 1 的位个数
func countOne
public func countOne(x: Int32): Int8
功能：此函数用于求二进制表达中值为 1 的位的个数。
参数：
x：传入一个整数
返回值：返回值为 1 的位个数
func countOne
public func countOne(x: Int16): Int8
功能：此函数用于求二进制表达中值为 1 的位的个数。
参数：
x：传入一个整数
返回值：返回值为 1 的位个数
func countOne
public func countOne(x: Int8): Int8
功能：此函数用于求二进制表达中值为 1 的位的个数。
参数：
x：传入一个整数
返回值：返回值为 1 的位个数
func countOne
public func countOne(x: UInt64): Int8
功能：此函数用于求二进制表达中值为 1 的位的个数。
参数：
x：传入一个整数
返回值：返回值为 1 的位个数
func countOne
public func countOne(x: UInt32): Int8
功能：此函数用于求二进制表达中值为 1 的位的个数。
参数：
x：传入一个整数
返回值：返回值为 1 的位个数
func countOne
public func countOne(x: UInt16): Int8
功能：此函数用于求二进制表达中值为 1 的位的个数。
参数：
x：传入一个整数
返回值：返回值为 1 的位个数
func countOne
public func countOne(x: UInt8): Int8
功能：此函数用于求二进制表达中值为 1 的位的个数。
参数：
x：传入一个整数
返回值：返回值为 1 的位个数
func erf
public func erf(x: Float64): Float64
功能：此函数用于求浮点数的误差值。相关定义是：$$erf(x) = \frac{2}{\sqrt{\pi}}\int_0^xe^{-t^2}dt$$
参数：
x：传入一个浮点数
返回值：返回传入浮点数的误差值
func erf
public func erf(x: Float32): Float32
功能：此函数用于求浮点数的误差值。相关定义是：$$erf(x) = \frac{2}{\sqrt{\pi}}\int_0^xe^{-t^2}dt$$
参数：
x：传入一个浮点数
返回值：返回传入浮点数的误差值
func erf
public func erf(x: Float16): Float16
功能：此函数用于求浮点数的误差值。相关定义是：$$erf(x) = \frac{2}{\sqrt{\pi}}\int_0^xe^{-t^2}dt$$
参数：
x：传入一个浮点数
返回值：返回传入浮点数的误差值
func pow
public func pow(base: Float64, exponent: Float64): Float64
功能：此函数用于求浮点数 base 的 exponent 次幂。
参数：
base：传入一个浮点数exponent：指定计算幂的次数
返回值：返回传入浮点数 base 的 exponent 次幂
func pow
public func pow(base: Float32, exponent: Float32): Float32
功能：此函数用于求浮点数 base 的 exponent 次幂。
参数：
base：传入一个浮点数exponent：指定计算幂的次数
返回值：返回传入浮点数 base 的 exponent 次幂
func pow
public func pow(base: Float64, exponent: Int64): Float64
功能：此函数用于求浮点数 base 的 exponent 次幂。
参数：
base：传入一个浮点数exponent：指定计算幂的次数
返回值：返回传入浮点数 base 的 exponent 次幂
func pow
public func pow(base: Float32, exponent: Int32): Float32
功能：此函数用于求浮点数 base 的 exponent 次幂。
参数：
base：传入一个浮点数exponent：指定计算幂的次数
返回值：返回传入浮点数 base 的 exponent 次幂
func exp
public func exp(x: Float64): Float64
功能：此函数用于求自然常数 e 的 x 次幂。
参数：
x：传入一个浮点数
返回值：返回自然常数 e 的 x 次幂
func exp
public func exp(x: Float32): Float32
功能：此函数用于求自然常数 e 的 x 次幂。
参数：
x：传入一个浮点数
返回值：返回自然常数 e 的 x 次幂
func exp
public func exp(x: Float16): Float16
功能：此函数用于求自然常数 e 的 x 次幂。
参数：
x：传入一个浮点数
返回值：返回自然常数 e 的 x 次幂
func exp2
public func exp2(x: Float64): Float64
功能：此函数用于求 2 的 x 次幂。
参数：
x：传入一个浮点数
返回值：返回 2 的 x 次幂
func exp2
public func exp2(x: Float32): Float32
功能：此函数用于求 2 的 x 次幂。
参数：
x：传入一个浮点数
返回值：返回 2 的 x 次幂
func exp2
public func exp2(x: Float16): Float16
功能：此函数用于求 2 的 x 次幂。
参数：
x：传入一个浮点数
返回值：返回 2 的 x 次幂
func floor
public func floor(x: Float64): Float64
功能：此函数用于求浮点数的向下取整值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的向下取整值
func floor
public func floor(x: Float32): Float32
功能：此函数用于求浮点数的向下取整值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的向下取整值
func floor
public func floor(x: Float16): Float16
功能：此函数用于求浮点数的向下取整值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的向下取整值
func gamma
public func gamma(x: Float64): Float64
功能：此函数用于求浮点数的 Gamma 值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的 Gamma 值
func gamma
public func gamma(x: Float32): Float32
功能：此函数用于求浮点数的 Gamma 值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的 Gamma 值
func gamma
public func gamma(x: Float16): Float16
功能：此函数用于求浮点数的 Gamma 值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的 Gamma 值
func gcd
public func gcd(x: Int64, y: Int64): Int64
功能：此函数用于求两数的最大公约数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最大公约数
异常：
IllegalArgumentException：当两参数为有符号整数最小值，或一个参数为有符号整数最小值且另一个参数为 0 时，抛出异常
func gcd
public func gcd(x: Int32, y: Int32): Int32
功能：此函数用于求两数的最大公约数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最大公约数
异常：
IllegalArgumentException：当两参数为有符号整数最小值，或一个参数为有符号整数最小值且另一个参数为 0 时，抛出异常
func gcd
public func gcd(x: Int16, y: Int16): Int16
功能：此函数用于求两数的最大公约数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最大公约数
异常：
IllegalArgumentException：当两参数为有符号整数最小值，或一个参数为有符号整数最小值且另一个参数为 0 时，抛出异常
func gcd
public func gcd(x: Int8, y: Int8): Int8
功能：此函数用于求两数的最大公约数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最大公约数
异常：
IllegalArgumentException：当两参数为有符号整数最小值，或一个参数为有符号整数最小值且另一个参数为 0 时，抛出异常
func gcd
public func gcd(x: UInt64, y: UInt64): UInt64
功能：此函数用于求两数的最大公约数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最大公约数
func gcd
public func gcd(x: UInt32, y: UInt32): UInt32
功能：此函数用于求两数的最大公约数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最大公约数
func gcd
public func gcd(x: UInt16, y: UInt16): UInt16
功能：此函数用于求两数的最大公约数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最大公约数
func gcd
public func gcd(x: UInt8, y: UInt8): UInt8
功能：此函数用于求两数的最大公约数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最大公约数
func lcm
public func lcm(x: Int64, y: Int64): Int64
功能：此函数用于求两数的最小公倍数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最小公倍数
异常：
IllegalArgumentException：当返回值超出有符号整数类型值对应范围
func lcm
public func lcm(x: Int32, y: Int32): Int32
功能：此函数用于求两数的最小公倍数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最小公倍数
异常：
IllegalArgumentException：当返回值超出有符号整数类型值对应范围
func lcm
public func lcm(x: Int16, y: Int16): Int16
功能：此函数用于求两数的最小公倍数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最小公倍数
异常：
IllegalArgumentException：当返回值超出有符号整数类型值对应范围
func lcm
public func lcm(x: Int8, y: Int8): Int8
功能：此函数用于求两数的最小公倍数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最小公倍数
异常：
IllegalArgumentException：当返回值超出有符号整数类型值对应范围
func lcm
public func lcm(x: UInt64, y: UInt64): UInt64
功能：此函数用于求两数的最小公倍数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最小公倍数
异常：
IllegalArgumentException：当返回值超出整数类型值对应范围时，抛出异常
func lcm
public func lcm(x: UInt32, y: UInt32): UInt32
功能：此函数用于求两数的最小公倍数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最小公倍数
异常：
IllegalArgumentException：当返回值超出整数类型值对应范围时，抛出异常
func lcm
public func lcm(x: UInt16, y: UInt16): UInt16
功能：此函数用于求两数的最小公倍数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最小公倍数
异常：
IllegalArgumentException：当返回值超出整数类型值对应范围时，抛出异常
func lcm
public func lcm(x: UInt8, y: UInt8): UInt8
功能：此函数用于求两数的最小公倍数。
参数：
x：传入第一个整数y：传入第二个整数
返回值：返回两个整数最小公倍数
异常：
IllegalArgumentException：当返回值超出整数类型值对应范围时，抛出异常
func leadingZeros
public func leadingZeros(x: Int64): Int8
功能：此函数用于返回整数的二进制表达中从最高位算起，连续为 0 的位数。如果最高位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回从最高位算起，连续 0 的位数
func leadingZeros
public func leadingZeros(x: Int32): Int8
功能：此函数用于返回整数的二进制表达中从最高位算起，连续为 0 的位数。如果最高位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回从最高位算起，连续 0 的位数
func leadingZeros
public func leadingZeros(x: Int16): Int8
功能：此函数用于返回整数的二进制表达中从最高位算起，连续为 0 的位数。如果最高位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回从最高位算起，连续 0 的位数
func leadingZeros
public func leadingZeros(x: Int8): Int8
功能：此函数用于返回整数的二进制表达中从最高位算起，连续为 0 的位数。如果最高位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回从最高位算起，连续 0 的位数
func leadingZeros
public func leadingZeros(x: UInt64): Int8
功能：此函数用于返回整数的二进制表达中从最高位算起，连续为 0 的位数。如果最高位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回从最高位算起，连续 0 的位数
func leadingZeros
public func leadingZeros(x: UInt32): Int8
功能：此函数用于返回整数的二进制表达中从最高位算起，连续为 0 的位数。如果最高位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回从最高位算起，连续 0 的位数
func leadingZeros
public func leadingZeros(x: UInt16): Int8
功能：此函数用于返回整数的二进制表达中从最高位算起，连续为 0 的位数。如果最高位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回从最高位算起，连续 0 的位数
func leadingZeros
public func leadingZeros(x: UInt8): Int8
功能：此函数用于返回整数的二进制表达中从最高位算起，连续为 0 的位数。如果最高位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回从最高位算起，连续 0 的位数
func log
public func log(x: Float64): Float64
功能：此函数用于求以 e 为底 x 的对数。
参数：
x：传入一个浮点数
返回值：返回以 e 为底 x 的对数
异常：
IllegalArgumentException：当输入值不为正时，抛出异常
func log
public func log(x: Float32): Float32
功能：此函数用于求以 e 为底 x 的对数。
参数：
x：传入一个浮点数
返回值：返回以 e 为底 x 的对数
异常：
IllegalArgumentException：当输入值不为正时，抛出异常
func log
public func log(x: Float16): Float16
功能：此函数用于求以 e 为底 x 的对数。
参数：
x：传入一个浮点数
返回值：返回以 e 为底 x 的对数
异常：
IllegalArgumentException：当输入值不为正时，抛出异常
func log2
public func log2(x: Float64): Float64
功能：此函数用于求以 2 为底 x 的对数。
参数：
x：传入一个浮点数
返回值：返回以 2 为底 x 的对数
异常：
IllegalArgumentException：当输入值不为正时，抛出异常
func log2
public func log2(x: Float32): Float32
功能：此函数用于求以 2 为底 x 的对数。
参数：
x：传入一个浮点数
返回值：返回以 2 为底 x 的对数
异常：
IllegalArgumentException：当输入值不为正时，抛出异常
func log2
public func log2(x: Float16): Float16
功能：此函数用于求以 2 为底 x 的对数。
参数：
x：传入一个浮点数
返回值：返回以 2 为底 x 的对数
异常：
IllegalArgumentException：当输入值不为正时，抛出异常
func log10
public func log10(x: Float64): Float64
功能：此函数用于求以 10 为底 x 的对数。
参数:
x：传入一个浮点数
返回值：返回以 10 为底 x 的对数
异常：
IllegalArgumentException：当输入值不为正时，抛出异常
func log10
public func log10(x: Float32): Float32
功能：此函数用于求以 10 为底 x 的对数。
参数:
x：传入一个浮点数
返回值：返回以 10 为底 x 的对数
异常：
IllegalArgumentException：当输入值不为正时，抛出异常
func log10
public func log10(x: Float16): Float16
功能：此函数用于求以 10 为底 x 的对数。
参数:
x：传入一个浮点数
返回值：返回以 10 为底 x 的对数
异常：
IllegalArgumentException：当输入值不为正时，抛出异常
func logBase
public func logBase(x: Float64, base: Float64): Float64
功能：此函数用于求以 e 为底 x 的对数与以 e 为底 base 的对数的商。
参数：
x：传入一个浮点数base：传入第二个浮点数
返回值：返回以 e 为底 x 的对数与以 e 为底 base 的对数的商
异常：
IllegalArgumentException：当参数x或参数base不为正，或参数base为 1.0 时，抛出异常
func logBase
public func logBase(x: Float32, base: Float32): Float32
功能：此函数用于求以 e 为底 x 的对数与以 e 为底 base 的对数的商。
参数：
x：传入一个浮点数base：传入第二个浮点数
返回值：返回以 e 为底 x 的对数与以 e 为底 base 的对数的商
异常：
IllegalArgumentException：当参数x或参数base不为正，或参数base为 1.0 时，抛出异常
func logBase
public func logBase(x: Float16, base: Float16): Float16
功能：此函数用于求以 e 为底 x 的对数与以 e 为底 base 的对数的商。
参数：
x：传入一个浮点数base：传入第二个浮点数
返回值：返回以 e 为底 x 的对数与以 e 为底 base 的对数的商
异常：
IllegalArgumentException：当参数x或参数base不为正，或参数base为 1.0 时，抛出异常
func max
public func max(a: Int64, b: Int64): Int64
功能：此函数用于求两个数的最大值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最大值
func max
public func max(a: Int32, b: Int32): Int32
功能：此函数用于求两个数的最大值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最大值
func max
public func max(a: Int16, b: Int16): Int16
功能：此函数用于求两个数的最大值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最大值
func max
public func max(a: Int8, b: Int8): Int8
功能：此函数用于求两个数的最大值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最大值
func max
public func max(a: UInt64, b: UInt64): UInt64
功能：此函数用于求两个数的最大值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最大值
func max
public func max(a: UInt32, b: UInt32): UInt32
功能：此函数用于求两个数的最大值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最大值
func max
public func max(a: UInt16, b: UInt16): UInt16
功能：此函数用于求两个数的最大值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最大值
func max
public func max(a: UInt8, b: UInt8): UInt8
功能：此函数用于求两个数的最大值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最大值
func max
public func max(a: Float64, b: Float64): Float64
功能：此函数用于求两个数的最大值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最大值
func max
public func max(a: Float32, b: Float32): Float32
功能：此函数用于求两个数的最大值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最大值
func max
public func max(a: Float16, b: Float16): Float16
功能：此函数用于求两个数的最大值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最大值
func maxNaN
public func maxNaN(a: Float64, b: Float64): Float64
功能：此函数用于求两个浮点数的最大值，有非数返回非数。
参数：
a：传入的第一个浮点数b: 传入的第二个浮点数
返回值：返回两个浮点数最大值, 有非数返回非数
func maxNaN
public func maxNaN(a: Float32, b: Float32): Float32
功能：此函数用于求两个浮点数的最大值，有非数返回非数。
参数：
a：传入的第一个浮点数b: 传入的第二个浮点数
返回值：返回两个浮点数最大值, 有非数返回非数
func maxNaN
public func maxNaN(a: Float16, b: Float16): Float16
功能：此函数用于求两个浮点数的最大值，有非数返回非数。
参数：
a：传入的第一个浮点数b: 传入的第二个浮点数
返回值：返回两个浮点数最大值, 有非数返回非数
func min
public func min(a: Int64, b: Int64): Int64
功能：此函数用于求两个数的最小值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最小值
func min
public func min(a: Int32, b: Int32): Int32
功能：此函数用于求两个数的最小值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最小值
func min
public func min(a: Int16, b: Int16): Int16
功能：此函数用于求两个数的最小值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最小值
func min
public func min(a: Int8, b: Int8): Int8
功能：此函数用于求两个数的最小值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最小值
func min
public func min(a: UInt64, b: UInt64): UInt64
功能：此函数用于求两个数的最小值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最小值
func min
public func min(a: UInt32, b: UInt32): UInt32
功能：此函数用于求两个数的最小值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最小值
func min
public func min(a: UInt16, b: UInt16): UInt16
功能：此函数用于求两个数的最小值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最小值
func min
public func min(a: UInt8, b: UInt8): UInt8
功能：此函数用于求两个数的最小值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最小值
func min
public func min(a: Float64, b: Float64): Float64
功能：此函数用于求两个数的最小值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最小值
func min
public func min(a: Float32, b: Float32): Float32
功能：此函数用于求两个数的最小值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最小值
func min
public func min(a: Float16, b: Float16): Float16
功能：此函数用于求两个数的最小值。
参数：
a：传入的第一个数b：传入的第二个数
返回值：返回两个数的最小值
func minNaN
public func minNaN(a: Float64, b: Float64): Float64
功能：此函数用于求两个浮点数的最小值, 有非数返回非数。
参数：
a：传入第一个浮点数b：传入第二个浮点数
返回值：返回两个浮点数最小值, 有非数返回非数
func minNaN
public func minNaN(a: Float32, b: Float32): Float32
功能：此函数用于求两个浮点数的最小值, 有非数返回非数。
参数：
a：传入第一个浮点数b：传入第二个浮点数
返回值：返回两个浮点数最小值, 有非数返回非数
func minNaN
public func minNaN(a: Float16, b: Float16): Float16
功能：此函数用于求两个浮点数的最小值, 有非数返回非数。
参数：
a：传入第一个浮点数b：传入第二个浮点数
返回值：返回两个浮点数最小值, 有非数返回非数
func reverse
public func reverse(x: UInt64): UInt64
功能：此函数用于无符号数的按位反转，返回反转结果对应的无符号数。
参数：
x：传入一个无符号整数
返回值：返回反转结果对应的无符号数
func reverse
public func reverse(x: UInt32): UInt32
功能：此函数用于无符号数的按位反转，返回反转结果对应的无符号数。
参数：
x：传入一个无符号整数
返回值：返回反转结果对应的无符号数
func reverse
public func reverse(x: UInt16): UInt16
功能：此函数用于无符号数的按位反转，返回反转结果对应的无符号数。
参数：
x：传入一个无符号整数
返回值：返回反转结果对应的无符号数
func reverse
public func reverse(x: UInt8): UInt8
功能：此函数用于无符号数的按位反转，返回反转结果对应的无符号数。
参数：
x：传入一个无符号整数
返回值：返回反转结果对应的无符号数
func rotate
public func rotate(num: Int64, d: Int8): Int64
功能：此函数用于整数的按位旋转，返回旋转结果对应的整数。
参数：
num：传入一个整数d：旋转位数，负数右移，正数左移
返回值：返回旋转后的整数
func rotate
public func rotate(num: Int32, d: Int8): Int32
功能：此函数用于整数的按位旋转，返回旋转结果对应的整数。
参数：
num：传入一个整数d：旋转位数，负数右移，正数左移
返回值：返回旋转后的整数
func rotate
public func rotate(num: Int16, d: Int8): Int16
功能：此函数用于整数的按位旋转，返回旋转结果对应的整数。
参数：
num：传入一个整数d：旋转位数，负数右移，正数左移
返回值：返回旋转后的整数
func rotate
public func rotate(num: Int8, d: Int8): Int8
功能：此函数用于整数的按位旋转，返回旋转结果对应的整数。
参数：
num：传入一个整数d：旋转位数，负数右移，正数左移
返回值：返回旋转后的整数
func rotate
public func rotate(num: UInt64, d: Int8): UInt64
功能：此函数用于整数的按位旋转，返回旋转结果对应的整数。
参数：
num：传入一个整数d：旋转位数，负数右移，正数左移
返回值：返回旋转后的整数
func rotate
public func rotate(num: UInt32, d: Int8): UInt32
功能：此函数用于整数的按位旋转，返回旋转结果对应的整数。
参数：
num：传入一个整数d：旋转位数，负数右移，正数左移
返回值：返回旋转后的整数
func rotate
public func rotate(num: UInt16, d: Int8): UInt16
功能：此函数用于整数的按位旋转，返回旋转结果对应的整数。
参数：
num：传入一个整数d：旋转位数，负数右移，正数左移
返回值：返回旋转后的整数
func rotate
public func rotate(num: UInt8, d: Int8): UInt8
功能：此函数用于整数的按位旋转，返回旋转结果对应的整数。
参数：
num：传入一个整数d：旋转位数，负数右移，正数左移
返回值：返回旋转后的整数
func sqrt
public func sqrt(x: Float64): Float64
功能：此函数用于求浮点数的算术平方根。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的算术平方根
异常：
IllegalArgumentException：当输入值为负数时，抛出异常
func sqrt
public func sqrt(x: Float32): Float32
功能：此函数用于求浮点数的算术平方根。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的算术平方根
异常：
IllegalArgumentException：当输入值为负数时，抛出异常
func sqrt
public func sqrt(x: Float16): Float16
功能：此函数用于求浮点数的算术平方根。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的算术平方根
异常：
IllegalArgumentException：当输入值为负数时，抛出异常
func trailingZeros
public func trailingZeros(x: Int64): Int8
功能：此函数用于返回整数的二进制表达中从最低位算起，连续 0 的个数。如果最低位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回最低位算起，有多少位连续为 0
func trailingZeros
public func trailingZeros(x: Int32): Int8
功能：此函数用于返回整数的二进制表达中从最低位算起，连续 0 的个数。如果最低位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回最低位算起，有多少位连续为 0
func trailingZeros
public func trailingZeros(x: Int16): Int8
功能：此函数用于返回整数的二进制表达中从最低位算起，连续 0 的个数。如果最低位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回最低位算起，有多少位连续为 0
func trailingZeros
public func trailingZeros(x: Int8): Int8
功能：此函数用于返回整数的二进制表达中从最低位算起，连续 0 的个数。如果最低位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回最低位算起，有多少位连续为 0
func trailingZeros
public func trailingZeros(x: UInt64): Int8
功能：此函数用于返回整数的二进制表达中从最低位算起，连续 0 的个数。如果最低位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回最低位算起，有多少位连续为 0
func trailingZeros
public func trailingZeros(x: UInt32): Int8
功能：此函数用于返回整数的二进制表达中从最低位算起，连续 0 的个数。如果最低位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回最低位算起，有多少位连续为 0
func trailingZeros
public func trailingZeros(x: UInt16): Int8
功能：此函数用于返回整数的二进制表达中从最低位算起，连续 0 的个数。如果最低位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回最低位算起，有多少位连续为 0
func trailingZeros
public func trailingZeros(x: UInt8): Int8
功能：此函数用于返回整数的二进制表达中从最低位算起，连续 0 的个数。如果最低位不是 0，则返回 0。
参数：
x：传入一个整数
返回值：返回最低位算起，有多少位连续为 0
func trunc
public func trunc(x: Float64): Float64
功能：此函数用于浮点数的截断取整。
参数：
x：传入一个浮点数
返回值：返回传入浮点数截断后取整值
func trunc
public func trunc(x: Float32): Float32
功能：此函数用于浮点数的截断取整。
参数：
x：传入一个浮点数
返回值：返回传入浮点数截断后取整值
func trunc
public func trunc(x: Float16): Float16
功能：此函数用于浮点数的截断取整。
参数：
x：传入一个浮点数
返回值：返回传入浮点数截断后取整值
func sin
public func sin(x: Float64): Float64
功能：此函数用于计算浮点数的正弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的正弦函数值
func sin
public func sin(x: Float32): Float32
功能：此函数用于计算浮点数的正弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的正弦函数值
func sin
public func sin(x: Float16): Float16
功能：此函数用于计算浮点数的正弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的正弦函数值
func cos
public func cos(x: Float64): Float64
功能：此函数用于计算浮点数的余弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的余弦函数值
func cos
public func cos(x: Float32): Float32
功能：此函数用于计算浮点数的余弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的余弦函数值
func cos
public func cos(x: Float16): Float16
功能：此函数用于计算浮点数的余弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的余弦函数值
func tan
public func tan(x: Float64): Float64
功能：此函数用于计算浮点数的正切函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的正切函数值
func tan
public func tan(x: Float32): Float32
功能：此函数用于计算浮点数的正切函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的正切函数值
func tan
public func tan(x: Float16): Float16
功能：此函数用于计算浮点数的正切函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的正切函数值
func asin
public func asin(x: Float64): Float64
功能：此函数用于计算浮点数的反正弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反正弦函数值
异常：
IllegalArgumentException：当参数x大于 1.0 或小于 -1.0 时，抛出异常
func asin
public func asin(x: Float32): Float32
功能：此函数用于计算浮点数的反正弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反正弦函数值
异常：
IllegalArgumentException：当参数x大于 1.0 或小于 -1.0 时，抛出异常
func asin
public func asin(x: Float16): Float16
功能：此函数用于计算浮点数的反正弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反正弦函数值
异常：
IllegalArgumentException：当参数x大于 1.0 或小于 -1.0 时，抛出异常
func acos
public func acos(x: Float64): Float64
功能：此函数用于计算浮点数的反余弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反余弦函数值
异常：
IllegalArgumentException：当参数x大于 1.0 或小于 -1.0 时，抛出异常
func acos
public func acos(x: Float32): Float32
功能：此函数用于计算浮点数的反余弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反余弦函数值
异常：
IllegalArgumentException：当参数x大于 1.0 或小于 -1.0 时，抛出异常
func acos
public func acos(x: Float16): Float16
功能：此函数用于计算浮点数的反余弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反余弦函数值
异常：
IllegalArgumentException：当参数x大于 1.0 或小于 -1.0 时，抛出异常
func atan
public func atan(x: Float64): Float64
功能：此函数用于计算浮点数的反正切函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反正切函数值
func atan
public func atan(x: Float32): Float32
功能：此函数用于计算浮点数的反正切函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反正切函数值
func atan
public func atan(x: Float16): Float16
功能：此函数用于计算浮点数的反正切函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反正切函数值
func sinh
public func sinh(x: Float64): Float64
功能：此函数用于计算浮点数的双曲正弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的双曲正弦函数值
func sinh
public func sinh(x: Float32): Float32
功能：此函数用于计算浮点数的双曲正弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的双曲正弦函数值
func sinh
public func sinh(x: Float16): Float16
功能：此函数用于计算浮点数的双曲正弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的双曲正弦函数值
func cosh
public func cosh(x: Float64): Float64
功能：此函数用于计算浮点数的双曲余弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的双曲余弦函数值
func cosh
public func cosh(x: Float32): Float32
功能：此函数用于计算浮点数的双曲余弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的双曲余弦函数值
func cosh
public func cosh(x: Float16): Float16
功能：此函数用于计算浮点数的双曲余弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的双曲余弦函数值
func tanh
public func tanh(x: Float64): Float64
功能：此函数用于计算浮点数的双曲正切函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的双曲正切函数值
func tanh
public func tanh(x: Float32): Float32
功能：此函数用于计算浮点数的双曲正切函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的双曲正切函数值
func tanh
public func tanh(x: Float16): Float16
功能：此函数用于计算浮点数的双曲正切函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的双曲正切函数值
func asinh
public func asinh(x: Float64): Float64
功能：此函数用于计算浮点数的反双曲正弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反双曲正弦函数值
func asinh
public func asinh(x: Float32): Float32
功能：此函数用于计算浮点数的反双曲正弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反双曲正弦函数值
func asinh
public func asinh(x: Float16): Float16
功能：此函数用于计算浮点数的反双曲正弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反双曲正弦函数值
func acosh
public func acosh(x: Float64): Float64
功能：此函数用于计算浮点数的反双曲余弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反双曲余弦函数值
异常：
IllegalArgumentException：当参数x小于 1.0 时，抛出异常
func acosh
public func acosh(x: Float32): Float32
功能：此函数用于计算浮点数的反双曲余弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反双曲余弦函数值
异常：
IllegalArgumentException：当参数x小于 1.0 时，抛出异常
func acosh
public func acosh(x: Float16): Float16
功能：此函数用于计算浮点数的反双曲余弦函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反双曲余弦函数值
异常：
IllegalArgumentException：当参数x小于 1.0 时，抛出异常
func atanh
public func atanh(x: Float64): Float64
功能：此函数用于计算浮点数的反双曲正切函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反双曲正切函数值
异常：
IllegalArgumentException：当参数x大于等于 1.0 或小于等于 -1.0 时，抛出异常
func atanh
public func atanh(x: Float32): Float32
功能：此函数用于计算浮点数的反双曲正切函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反双曲正切函数值
异常：
IllegalArgumentException：当参数x大于等于 1.0 或小于等于 -1.0 时，抛出异常
func atanh
public func atanh(x: Float16): Float16
功能：此函数用于计算浮点数的反双曲正切函数值。
参数：
x：传入一个浮点数
返回值：返回传入浮点数的反双曲正切函数值
异常：
IllegalArgumentException：当参数x大于等于 1.0 或小于等于 -1.0 时，抛出异常
func round
public func round(x: Float64): Float64
功能：此函数采用 IEEE-754 的向最近舍入规则，计算浮点数的舍入值。如果该浮点数有两个最近整数，则向偶数舍入。
参数：
x：传入一个浮点数
返回值：返回浮点数向最近整数方向的舍入值。如果该浮点数有两个最近整数，则向偶数舍入
func round
public func round(x: Float32): Float32
功能：此函数采用 IEEE-754 的向最近舍入规则，计算浮点数的舍入值。如果该浮点数有两个最近整数，则向偶数舍入。
参数：
x：传入一个浮点数
返回值：返回浮点数向最近整数方向的舍入值。如果该浮点数有两个最近整数，则向偶数舍入
func round
public func round(x: Float16): Float16
功能：此函数采用 IEEE-754 的向最近舍入规则，计算浮点数的舍入值。如果该浮点数有两个最近整数，则向偶数舍入。
参数：
x：传入一个浮点数
返回值：返回浮点数向最近整数方向的舍入值。如果该浮点数有两个最近整数，则向偶数舍入
示例
rotate 函数的位旋转运算 1
下面是 rotate 函数的位旋转运算示例:
代码如下：
from std import math.rotate
main(): Unit {
let a: Int8 = rotate(Int8(92), Int8(4))
/* a=-59 */
println("a=${a}")
}
运行结果如下:
a=-59
rotate 函数的位旋转运算 2
下面是 rotate 函数的位旋转运算示例：
代码如下：
from std import math.rotate
main(): Unit {
let a: Int32 = rotate(Int32(1), Int8(4))
/* a=16 */
println("a=${a}")
}
运行结果如下:
a=16
clamp 范围截断函数
下面是 clamp 范围截断函数示例：
代码如下：
from std import math.clamp
main(): Unit {
let min: Float16 = -0.123
let max: Float16 = 0.123
let v: Float16 = 0.121
let c = clamp(v, min, max)
/* true */
print("${c==v}")
let min2: Float16 = -0.999
let max2: Float16 = 10.123
let v2: Float16 = 11.121
let c2 = clamp(v2, min2, max2)
/* true */
print("${c2==max2}")
let min3: Float16 = -0.999
let max3: Float16 = 10.123
let v3: Float16 = -1.121
let c3 = clamp(v3, min3, max3)
/* true */
print("${c3==min3}")
}
运行结果如下:
truetruetrue
最小公倍数函数
下面是最小公倍数函数示例：
代码如下：
from std import math.lcm
main(): Unit {
let a: Int8 = lcm(Int8(-3), Int8(5))
/* a=15 */
println("a=${a}")
}
运行结果如下:
a=15
最大公约数函数
下面是最大公约数函数示例：
代码如下：
from std import math.gcd
main(): Unit {
let c2 = gcd(0, -60)
/* 60 */
println("c2=${c2}")
let c4 = gcd(-33, 27)
/* 3 */
print("c4=${c4}")
}
运行结果如下:
c2=60
c4=3
math.numeric 包
介绍
math.numeric 包对基础类型可表达范围之外提供扩展能力，当前支持大整数(BigInt)、高精度十进制数(Decimal)类型，提供常见的数学运算能力。
主要接口
struct BigInt
public struct BigInt <: Comparable<BigInt> & Hashable & ToString {
public init(bytes: Array<Byte>)
public init(sign: Bool, magnitude: Array<Byte>)
public init(n: Int8)
public init(n: Int16)
public init(n: Int32)
public init(n: Int64)
public init(n: IntNative)
public init(n: UInt8)
public init(n: UInt16)
public init(n: UInt32)
public init(n: UInt64)
public init(n: UIntNative)
public init(sign: Bool, bitLen: Int64, rand!: Random = Random())
public init(s: String, base!: Int64 = 10)
public static func randomProbablePrime(bitLen: Int64, certainty: UInt64, rand!: Random = Random()): BigInt
}
BigInt 定义为任意精度（二进制）的有符号整数。仓颉的 struct BigInt 用于任意精度有符号整数的计算，类型转换等。
init
public init(bytes: Array<Byte>)
功能： 通过大端的 Byte 数组以补码形式构建 BigInt。
参数：
- bytes：大端二进制补码数组，数组长度不能为空
异常：
- IllegalArgumentException：当传入空数组时，抛此异常
init
public init(sign: Bool, magnitude: Array<Byte>)
功能：通过符号位和真值的绝对值来构造 BigInt。视空数组为 0。
参数：
-
sign：符号。true 表示非负数，false 表示负数
-
magnitude：真值绝对值的二进制原码
异常：
- IllegalArgumentException：当 sign 为 false 且传入的数组为 0 时，抛此异常
init
public init(n: Int8)
功能：通过有符号整数来构建 BigInt。
参数：
- n：有符号整数
init
public init(n: Int16)
功能：通过有符号整数来构建 BigInt。
参数：
- n：有符号整数
init
public init(n: Int32)
功能：通过有符号整数来构建 BigInt。
参数：
- n：有符号整数
init
public init(n: Int64)
功能：通过有符号整数来构建 BigInt。
参数：
- n：有符号整数
init
public init(n: IntNative)
功能：通过有符号整数来构建 BigInt。
参数：
- n：有符号整数
init
public init(n: UInt8)
功能：通过无符号整数来构建 BigInt。
参数：
- n：无符号整数
init
public init(n: UInt16)
功能：通过无符号整数来构建 BigInt。
参数：
- n：无符号整数
init
public init(n: UInt32)
功能：通过无符号整数来构建 BigInt。
参数：
- n：无符号整数
init
public init(n: UInt64)
功能：通过无符号整数来构建 BigInt。
参数：
- n：无符号整数
init
public init(n: UIntNative)
功能：通过无符号整数来构建 BigInt。
参数：
- n：无符号整数
init
public init(sign: Bool, bitLen: Int64, rand!: Random = Random())
功能：通过指定正负，bit 长度，和随机数种子来构建一个随机的 BigInt。bit 长度需要大于 0。
参数：
-
sign：指定随机 BigInt 的正负
-
bitLen：指定随机 BigInt 的 bit 长度上限
-
rand：指定的随机数种子
异常：
- IllegalArgumentException：如果指定的 bit 长度小于等于 0，则抛此异常
init
public init(s: String, base!: Int64 = 10)
功能：通过字符串和进制来构建 BigInt。支持 2 进制到 36 进制。字符串的规则如下：
IntegerString : (SignString)? ValueString
SignString : + | -
ValueString : digit digits
digit : '0' ~ '9' | 'A' ~ 'Z' | 'a' ~ 'z'
如果 digit 在 '0' ~ '9' 内， 需要满足 (digit - '0') < base；
如果 digit 在 'A' ~ 'Z' 内， 需要满足 (digit - 'A') + 10 < base；
如果 digit 在 'a' ~ 'z' 内， 需要满足 (digit - 'A') + 10 < base。
参数：
-
s：字符串，用来构建 BigInt 的字符串。字符串规则为，开头可选一个正号（+）或者负号（-）。接下来必选非空阿拉伯数字或大小写拉丁字母的字符序列，大小写字符含义一样，'a' 和 'A' 的大小等于十进制的 10， 'b' 和 'B' 的大小等于十进制的 11， 以此类推。序列中的字符大小不得大于等于进制大小。如果入参字符串不符合上述要求，则抛出 IllegalArgumentException
-
base：进制，字符串所表示的进制，范围为 [2, 36]
异常：
- IllegalArgumentException：如果入参字符串不符合上述规则，或入参进制不在 [2, 36] 区间内，抛此异常
func randomProbablePrime
public static func randomProbablePrime(bitLen: Int64, certainty: UInt64, rand!: Random = Random()): BigInt
功能：通过可选的随机数种子构建一个随机的 BigInt 素数，素数的 bit 长度不超过入参 bitLen。显然，素数必定是大于等于 2 的整数，因此 bitLen 必须大于等于 2。素数检测使用 Miller-Rabin 素数测试算法。Miller-Rabin 测试会有概率将一个合数判定为素数，其出错概率随着入参 certainty 的增加而减少。
参数：
-
bitLen：所要生成的随机素数的 bit 长度的上限
-
certainty：生成的随机素数通过 Miller-Rabin 素数测试算法的次数，通过的次数越多，将合数误判为素数的概率越低
-
rand：指定的随机数种子
返回值：返回生成的随机素数
异常：
- IllegalArgumentException：如果指定的 bit 长度小于等于 1，则抛此异常
prop sign
public prop sign: Int64
功能：获取此 BigInt 的符号。如果此 BigInt 大于 0，则返回 1；等于 0，则返回 0；小于 0，则返回 -1。
prop bitLen
public prop bitLen: Int64
功能：获取此 BigInt 的最短 bit 长度。如 -3 (101) 返回 3，-1 (11) 返回 2，0 (0) 返回 1。
func testBit
public func testBit(index: Int64): Bool
功能：返回指定位置的 bit 信息。如果指定位置的 bit 为 0，则返回 false；为 1，则返回 true。
参数：
- index：需要知道的 bit 的索引。index 需要大于等于 0
返回值：指定位置的 bit 信息
异常：
- IllegalArgumentException：如果入参 index 小于 0，则抛此异常
func lowestOneBit
public func lowestOneBit(): Int64
功能：返回为 1 的最低位的 bit 的位置。
返回值：返回为 1 的最低位的 bit 的位置。如果 bit 全为 0，则返回 -1
func setBit
public func setBit(index: Int64): BigInt
功能：通过将指定索引位置的 bit 修改为 1 来构造一个新 BigInt。
参数：
- index：需要设置的 bit 位置的索引。index 需要大于等于 0
返回值：一个新的 BigInt，它是将原 BigInt index 处的 bit 改为 1 的产物
异常：
- IllegalArgumentException：如果入参 index 小于 0，则抛此异常
func clearBit
public func clearBit(index: Int64): BigInt
功能：通过将指定索引位置的 bit 修改为 0 来构造一个新 BigInt。
参数：
- index：需要设置的 bit 位置的索引。index 需要大于等于 0
返回值：一个新的 BigInt，它是将原 BigInt index 处的 bit 改为 0 的产物
异常：
- IllegalArgumentException：如果入参 index 小于 0，则抛此异常
func flipBit
public func flipBit(index: Int64): BigInt
功能：通过翻转指定索引位置的 bit 来构造一个新 BigInt。
参数：
- index：需要翻转的 bit 位置的索引。index 需要大于等于 0
返回值：一个新的 BigInt，它是将原 BigInt index 处的 bit 翻转后的产物
异常：
- IllegalArgumentException：如果入参 index 小于 0，则抛此异常
func isProbablePrime
public func isProbablePrime(certainty: UInt64): Bool
功能：判断一个数是不是素数，使用了 Miller-Rabin 测试算法，此算法的准确率会随着 certainty 参数的增加而增加。如果该数是素数，那么 Miller-Rabin 测试必定返回 true；如果该数是合数（期待返回 false），那么会有低于 $1/4^{certainty}$ 概率返回 true。注意，素数只对大于等于 2 的正整数有意义，即负数，0，1 都不是素数。
参数：
- certainty：需要执行 Miller-Rabin 测试的次数，注意，如果测试次数为 0，表示不测试，那么总是返回 true（即不是素数的数也必定返回 true）
返回值：测试该数是否是素数的结果，如果是，则返回 true；如果不是，则返回 false
operator func +
public operator func +(that: BigInt): BigInt
功能：与另一个 BigInt 相加，返回结果。
参数：
- that：另外一个 BigInt
返回值：一个新 BigInt，它是此 BigInt 与另外一个 BigInt 相加后的结果
operator func -
public operator func -(that: BigInt): BigInt
功能：与另一个 BigInt 相减，返回结果。
参数：
- that：另外一个 BigInt
返回值：一个新 BigInt，它是此 BigInt 与另外一个 BigInt 相减后的结果
operator func *
public operator func *(that: BigInt): BigInt
功能：与另一个 BigInt 相乘，返回结果。
参数：
- that：另外一个 BigInt
返回值：一个新 BigInt，它是此 BigInt 与另外一个 BigInt 相乘后的结果
operator func /
public operator func /(that: BigInt): BigInt
功能：与另一个 BigInt 相除，返回结果。此除法运算的行为与基础类型保持一致，即结果向靠近 0 的方向取整。
参数：
- that：另外一个 BigInt。入参不得为 0
返回值：一个新 BigInt，它是此 BigInt 与另外一个 BigInt 相除后的结果，结果向靠近 0 的方向取整
异常：
- ArithmeticException：除数为 0 抛此异常
operator func %
public operator func %(that: BigInt): BigInt
功能：与另一个 BigInt 相模，返回结果。此取模运算的行为与基础类型保持一致，即符号与被除数保持一致。
参数：
- that：另外一个 BigInt。入参不得为 0
返回值：一个新 BigInt，它是此 BigInt 与另外一个 BigInt 相模后的结果，其符号与被除数保持一致
异常：
- ArithmeticException：除数为 0 抛此异常
func divAndMod
public func divAndMod(that: BigInt): (BigInt, BigInt)
功能：与另一个 BigInt 相除，返回商和模。此除法运算的行为与基础类型保持一致，即商向靠近 0 的方向取整，模的符号与被除数保持一致。
参数：
- that：另外一个 BigInt。入参不得为 0
返回值：商和模
异常：
- ArithmeticException：除数为 0 抛此异常
func quo
public func quo(that: BigInt): BigInt
功能：与另一个 BigInt 相除，返回结果。此除法运算的行为与运算符重载函数区别于，如果被除数为负数，此函数的结果向着远离 0 的方向取整，保证余数大于等于 0。
参数：
- that：另外一个 BigInt。入参不得为 0
返回值：一个新 BigInt，它是此 BigInt 与另外一个 BigInt 相除后的结果
异常：
- ArithmeticException：除数为 0 抛此异常
func rem
public func rem(that: BigInt): BigInt
功能：与另一个 BigInt 相除，返回余数。余数的结果总是大于等于 0。
参数：
- that：另外一个 BigInt。入参不得为 0
返回值：一个新 BigInt，它是此 BigInt 与另外一个 BigInt 相除后的余数
异常：
- ArithmeticException：除数为 0 抛此异常
func quoAndRem
public func quoAndRem(that: BigInt): (BigInt, BigInt)
功能：与另一个 BigInt 相除，返回商和余数。此除法运算的行为与 divAndMod 函数区别于，如果被除数为负数，此函数的结果向着远离 0 的方向取整，保证余数总是大于等于 0。
参数：
- that：另外一个 BigInt。入参不得为 0
返回值：商和余数
异常：
- ArithmeticException：除数为 0 抛此异常
func modInverse
public func modInverse(that: BigInt): BigInt
功能：求模逆元，使得结果 r 满足 (this * r) % that == 1。显然，this 和 that 必须互质。当 that 为 正负 1 时，结果总是 0。
参数：
- that：另外一个 BigInt。入参不得为 0，且需要与 this 互质
返回值：返回模逆元
异常：
- IllegalArgumentException：当 this 和 that 不互质或 that 为 0 时，抛此异常
operator func -
public operator func -(): BigInt
功能：返回此 BigInt 的相反数。
返回值：此 BigInt 的相反数
operator func **
public operator func **(n: UInt64): BigInt
功能：计算此 BigInt 的 n 次幂，返回计算结果。
参数：
- n：指数参数
返回值：幂运算结果
func modPow
public func modPow(n: BigInt, m!: ?BigInt = None): BigInt
功能：计算此 BigInt 的 n 次幂模 m 的结果，并返回。模的规则与基础类型一致，即模的符号与被除数保持一致。
参数：
-
n：指数参数，必须为非负数
-
m：除数，此入参不得为 0
返回值：乘方后取模的运算结果
异常：
-
ArithmeticException：除数为 0 抛此异常
-
IllegalArgumentException：指数为负数时抛此异常
operator func &
public operator func &(that: BigInt): BigInt
功能：与另一个 BigInt 按位与，返回计算结果。
参数：
- that：另外一个 BigInt
返回值：返回与另一个 BigInt 的按位与的结果
operator func |
public operator func |(that: BigInt): BigInt
功能：与另一个 BigInt 按位或，返回计算结果。
参数：
- that：另外一个 BigInt
返回值：返回与另一个 BigInt 的按位或的结果
operator func ^
public operator func ^(that: BigInt): BigInt
功能：与另一个 BigInt 按位异或，返回计算结果。
参数：
- that：另外一个 BigInt
返回值：返回与另一个 BigInt 的按位异或的结果
operator func !
public operator func !(): BigInt
功能：按位非，返回结果。
返回值：返回此 BigInt 按位非的结果
operator func >>
public operator func >>(n: Int64): BigInt
功能：右移 n 位，并返回移位后的结果。
参数：
- n：右移 n 位，n 需要大于等于 0
返回值：返回此 BigInt 右移 n 位的结果
异常：
- ArithmeticException：入参小于 0 时抛此异常
operator func <<
public operator func <<(n: Int64): BigInt
功能：左移 n 位，并返回移位后的结果。
参数：
- n：左移 n 位，n 需要大于等于 0
返回值：返回此 BigInt 左移 n 位的结果
异常：
- ArithmeticException：入参小于 0 时抛此异常
operator func ==
public operator func ==(that: BigInt): Bool
功能：判断两个 BigInt 是否相等。
参数：
- that：另一个 BigInt
返回值：判等的结果。相等返回 true，不等返回 false
operator func !=
public operator func !=(that: BigInt): Bool
功能：判断两个 BigInt 是否不等。
参数：
- that：另一个 BigInt
返回值：判不等的结果。不等返回 true，相等返回 false
operator func >
public operator func >(that: BigInt): Bool
功能：判断此 BigInt 是否大于另一个 BigInt
参数：
- that：另一个 BigInt
返回值：比较的结果。大于返回 true，否则返回 false
operator func >=
public operator func >=(that: BigInt): Bool
功能：判断此 BigInt 是否大于等于另一个 BigInt
参数：
- that：另一个 BigInt
返回值：比较的结果。大于等于返回 true，否则返回 false
operator func <
public operator func <(that: BigInt): Bool
功能：判断此 BigInt 是否小于另一个 BigInt
参数：
- that：另一个 BigInt
返回值：比较的结果。小于返回 true，否则返回 false
operator func <=
public operator func <=(that: BigInt): Bool
功能：判断此 BigInt 是否小于等于另一个 BigInt
参数：
- that：另一个 BigInt
返回值：比较的结果。小于等于返回 true，否则返回 false
func compare
public func compare(that: BigInt): Ordering
功能：判断 BigInt 与另一个 BigInt 的关系。如果等于，返回 Ordering.EQ；如果小于，返回 Ordering.LT；如果大于，返回 Ordering.GT。
参数：
- that：另一个 BigInt 对象
返回值：返回此 BigInt 与另一个 BigInt 的关系。如果等于，返回 Ordering.EQ；如果小于，返回 Ordering.LT；如果大于，返回 Ordering.GT
func hashCode
public func hashCode(): Int64
功能：计算并返回此 BigInt 的哈希值。
返回值：返回此 BigInt 的哈希值
func toString
public func toString(): String
功能：计算并返回此 BigInt 的十进制字符串表示。
返回值：返回此 BigInt 的十进制字符串
func toBytes
public func toBytes(): Array<Byte>
功能：计算并返回此 BigInt 的大端补码字节数组。字节数组最低索引的最低位为符号位，如 128 返回 [0, 128]（符号位为 0），-128 返回 [128]（符号位为 1）。
返回值：返回此 BigInt 的大端补码字节数组
func toString
public func toString(base: Int64): String
功能：计算并返回此 BigInt 的任意进制字符串表示。
参数：
- base：进制，字符串所表示的进制，范围为 [2, 36]
返回值：返回此 BigInt 的 base 进制字符串
func toInt8
public func toInt8(overflowHandling!: OverflowStrategy = throwing): Int8
功能：将当前 BigInt 对象转化为 Int8 类型，支持自定义溢出策略。
参数：
- overflowHandling：转换溢出策略
返回值：返回转换后的 Int8 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toInt16
public func toInt16(overflowHandling!: OverflowStrategy = throwing): Int16
功能：将当前 BigInt 对象转化为 Int16 类型，支持自定义溢出策略。
参数：
- overflowHandling：转换溢出策略
返回值：返回转换后的 Int16 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toInt32
public func toInt32(overflowHandling!: OverflowStrategy = throwing): Int32
功能：将当前 BigInt 对象转化为 Int32 类型，支持自定义溢出策略。
参数：
- overflowHandling：转换溢出策略
返回值：返回转换后的 Int32 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toInt64
public func toInt64(overflowHandling!: OverflowStrategy = throwing): Int64
功能：将当前 BigInt 对象转化为 Int64 类型，支持自定义溢出策略。
参数：
- overflowHandling：转换溢出策略
返回值：返回转换后的 Int64 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toIntNative
public func toIntNative(overflowHandling!: OverflowStrategy = throwing): IntNative
功能：将当前 BigInt 对象转化为 IntNative 类型，支持自定义溢出策略。
参数：
- overflowHandling：转换溢出策略
返回值：返回转换后的 IntNative 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toUInt8
public func toUInt8(overflowHandling!: OverflowStrategy = throwing): UInt8
功能：将当前 BigInt 对象转化为 UInt8 类型，支持自定义溢出策略。
参数：
- overflowHandling：转换溢出策略
返回值：返回转换后的 UInt8 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toUInt16
public func toUInt16(overflowHandling!: OverflowStrategy = throwing): UInt16
功能：将当前 BigInt 对象转化为 UInt16 类型，支持自定义溢出策略。
参数：
- overflowHandling：转换溢出策略
返回值：返回转换后的 UInt16 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toUInt32
public func toUInt32(overflowHandling!: OverflowStrategy = throwing): UInt32
功能：将当前 BigInt 对象转化为 UInt32 类型，支持自定义溢出策略。
参数：
- overflowHandling：转换溢出策略
返回值：返回转换后的 UInt32 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toUInt64
public func toUInt64(overflowHandling!: OverflowStrategy = throwing): UInt64
功能：将当前 BigInt 对象转化为 UInt64 类型，支持自定义溢出策略。
参数：
- overflowHandling：转换溢出策略
返回值：返回转换后的 UInt64 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toUIntNative
public func toUIntNative(overflowHandling!: OverflowStrategy = throwing): UIntNative
功能：将当前 BigInt 对象转化为 UIntNative 类型，支持自定义溢出策略。
参数：
- overflowHandling：转换溢出策略
返回值：返回转换后的 UIntNative 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func abs
public func abs(i: BigInt): BigInt
功能：计算并返回入参 BigInt 的绝对值。
参数：
- i：需要计算绝对值的 BigInt
返回值：返回入参 BigInt 的绝对值
func sqrt
public func sqrt(i: BigInt): BigInt
功能：计算并返回入参 BigInt 的算数平方根，向下取整。
参数：
- i：需要计算算数平方根的 BigInt，入参需要非负
返回值：返回入参 BigInt 的算数平方根，向下取整
异常：
- IllegalArgumentException：如果入参为负数，则抛此异常
func gcd
public func gcd(i1: BigInt, i2: BigInt): BigInt
功能：计算并返回 i1 和 i2 的最大公约数，总是返回非负数（相当于绝对值的最大公约数）。
参数：
-
i1：需要计算最大公约数的第一个入参
-
i2：需要计算最大公约数的第二个入参
返回值：返回 i1 和 i2 的最大公约数，总是返回非负数（相当于绝对值的最大公约数）
func lcm
public func lcm(i1: BigInt, i2: BigInt): BigInt
功能：计算并返回 i1 和 i2 的最小公倍数，除了入参有 0 时返回 0 外，总是返回正数（相当于绝对值的最小公倍数）。
参数：
-
i1：需要计算最小公倍数的第一个入参
-
i2：需要计算最小公倍数的第二个入参
返回值：返回 i1 和 i2 的最小公倍数，当入参有 0 时返回 0，其余情况返回正数（相当于绝对值的最小公倍数）
func max
public func max(i1: BigInt, i2: BigInt): BigInt
功能：计算并返回两个 BigInt 中较大的那个。
参数：
-
i1：需要比较的 BigInt
-
i2：需要比较的 BigInt
返回值：返回 i1，i2 中较大的 BigInt
func min
public func min(i1: BigInt, i2: BigInt): BigInt
功能：计算并返回两个 BigInt 中较小的那个。
参数：
-
i1：需要比较的 BigInt
-
i2：需要比较的 BigInt
返回值：返回 i1，i2 中较小的 BigInt
func countOne
public func countOne(i: BigInt): Int64
功能：计算并返回入参 BigInt 的二进制补码中 1 的个数。
参数：
- i：需要计算二进制补码中 1 的个数的 BigInt
返回值：返回入参 BigInt 的二进制补码中 1 的个数
struct DecimalContext
public struct DecimalContext {
public init(precision: Int64, roundingMode: RoundingMode)
}
DecimalContext 对象作用于用户对 Decimal 操作过程中，对生成结果指定上下文，设定结果的精度与对应舍入规则。
init
public init(precision: Int64, roundingMode: RoundingMode)
功能：指定精度与舍入规则构建生成上下文对象，可作用于 Decimal 操作结果。
参数：
-
precision：精度值，限制
Decimal结果有效数值位数 -
roundingMode：舍入规则，
Decimal结果有效位超出精度限制时舍入操作遵循该指定规则
异常：
- IllegalArgumentException：当传入精度小于0时，抛出此异常
precision
public let precision: Int64
功能：获取上下文中指定的精度值。
roundingMode
public let roundingMode: RoundingMode
功能：获取上下文中指定的舍入规则。
enum RoundingMode
public enum RoundingMode {
| UP
| DOWN
| CEILING
| FLOOR
| HALF_UP
| HALF_EVEN
}
舍入规则枚举类，共包含 6 中舍入规则。除包含 IEEE 754 浮点数规定约定的 5 种舍入规则外，提供使用较多的 “四舍五入” 舍入规则。
| 十进制数 | UP | DOWN | CEILING | FLOOR | HALF_UP | HALF_EVEN |
|---|---|---|---|---|---|---|
| 7.5 | 8 | 7 | 8 | 7 | 8 | 8 |
| 4.5 | 5 | 4 | 5 | 4 | 5 | 4 |
| -1.1 | -2 | -1 | -1 | -2 | -1 | -1 |
| -4.5 | -5 | -4 | -4 | -5 | -5 | -4 |
| -7.5 | -8 | -7 | -7 | -8 | -8 | -8 |
UP
UP
功能：向远离零的方向舍入。
DOWN
DOWN
功能：向靠近零的方向舍入。
CEILING
CEILING
功能：向正无穷方向舍入。
FLOOR
FLOOR
功能：向负无穷方向舍入。
HALF_UP
HALF_UP
功能：四舍五入。
HALF_EVEN
HALF_EVEN
功能：四舍六入五取偶，又称 “银行家舍入”。
enum OverflowStrategy
public enum OverflowStrategy {
| throwing
| wrapping
| saturating
}
溢出策略枚举类，共包含 3 种溢出策略。BigInt 类型、Decimal 类型转换为整数类型时，允许指定不同的溢出处理策略。
throwing
throwing
功能：出现溢出，抛出异常。
wrapping
wrapping
功能：出现溢出，高位截断。
saturating
saturating
功能：出现溢出，当前值大于目标类型的 MAX 值，返回目标类型 MAX 值，当前值小于目标类型的 MIN 值，返回目标类型 MIN 值。
struct Decimal
public struct Decimal <: Comparable<Decimal> & Hashable & ToString {
public init(val: BigInt, scale: Int32, ctx!: DecimalContext = defaultDecimalContext)
public init(val: String, ctx!: DecimalContext = defaultDecimalContext)
public init(val: Int8, ctx!: DecimalContext = defaultDecimalContext)
public init(val: Int16, ctx!: DecimalContext = defaultDecimalContext)
public init(val: Int32, ctx!: DecimalContext = defaultDecimalContext)
public init(val: Int64, ctx!: DecimalContext = defaultDecimalContext)
public init(val: IntNative, ctx!: DecimalContext = defaultDecimalContext)
public init(val: UInt8, ctx!: DecimalContext = defaultDecimalContext)
public init(val: UInt16, ctx!: DecimalContext = defaultDecimalContext)
public init(val: UInt32, ctx!: DecimalContext = defaultDecimalContext)
public init(val: UInt64, ctx!: DecimalContext = defaultDecimalContext)
public init(val: UIntNative, ctx!: DecimalContext = defaultDecimalContext)
public init(val: Float16, ctx!: DecimalContext = defaultDecimalContext)
public init(val: Float32, ctx!: DecimalContext = defaultDecimalContext)
public init(val: Float64, ctx!: DecimalContext = defaultDecimalContext)
}
Decimal 用于表示任意精度的有符号的十进制数。允许操作过程指定上下文，指定结果精度及舍入规则。提供基础类型 (Int、UInt、String、Float等) 与 BigInt 类型互相转换能力，支持 Decimal 对象基本属性查询等能力，支持基础数学运算操作，提供对象比较、hash、字符串打印等基础能力。
init
public init(val: BigInt, scale: Int32, ctx!: DecimalContext = defaultDecimalContext)
功能：通过有符号大整数 BigInt 和标度值构建 Deciaml 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
参数：
-
val：有符号大整数值
-
scale：标度值
-
ctx：
Deciaml上下文
异常：
- OverflowException：当构建值范围超过
[-(maxValue(ctx.precision) * (10 ^ {Int32.MAX})), maxValue(ctx.precision) * (10 ^ {Int32.MAX})]时，抛出此异常
init
public init(val: String, ctx!: DecimalContext = defaultDecimalContext)
功能：通过规定格式字符串构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
字符串需满足格式如下：
Decimal 字符串: (SignString)? ValueString (ExponentString)?
SignString： + | -
ValueString：IntegerPart.(FractionPart)? | .FractionPart | IntegerPart
IntegerPart：Digits
FractionPart：Digits
ExponentString：ExponentIndicator (SignString)? IntegerPart
ExponentIndicator：e | E
Digits：Digit | Digit Digits
Digit：0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
参数：
-
val：规定格式字符串
-
ctx：
Deciaml上下文
异常：
-
IllegalArgumentException：当入参字符串不满足规定格式时，抛此异常
-
OverflowException：当构建值范围超过
[-(maxValue(ctx.precision) * (10 ^ {Int32.MAX})), maxValue(ctx.precision) * (10 ^ {Int32.MAX})]时，抛出此异常
init
public init(val: Int8, ctx!: DecimalContext = defaultDecimalContext)
功能：通过 8 位有符号整数构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
参数：
-
val：8 位有符号整数
-
ctx：
Decimal上下文
init
public init(val: Int16, ctx!: DecimalContext = defaultDecimalContext)
功能：通过 16 位有符号整数构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
参数：
-
val：16 位有符号整数
-
ctx：
Decimal上下文
init
public init(val: Int32, ctx!: DecimalContext = defaultDecimalContext)
功能：通过 32 位有符号整数构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
参数：
-
val：32 位有符号整数
-
ctx：
Decimal上下文
init
public init(val: Int64, ctx!: DecimalContext = defaultDecimalContext)
功能：通过 64 位有符号整数构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
参数：
-
val：64 位有符号整数
-
ctx：
Decimal上下文
init
public init(val: IntNative, ctx!: DecimalContext = defaultDecimalContext)
功能：通过 32 位或 64 位 (具体长度与平台相关) 有符号整数构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
参数：
-
val：32 位或 64位有符号整数
-
ctx：
Decimal上下文
init
public init(val: UInt8, ctx!: DecimalContext = defaultDecimalContext)
功能：通过 8 位无符号整数构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
参数：
-
val：8 位无符号整数
-
ctx：
Decimal上下文
init
public init(val: UInt16, ctx!: DecimalContext = defaultDecimalContext)
功能：通过 16 位无符号整数构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
参数：
-
val：16 位无符号整数
-
ctx：
Decimal上下文
init
public init(val: UInt32, ctx!: DecimalContext = defaultDecimalContext)
功能：通过 32 位无符号整数构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
参数：
-
val：32 位无符号整数
-
ctx：
Decimal上下文
init
public init(val: UInt64, ctx!: DecimalContext = defaultDecimalContext)
功能：通过 64 位无符号整数构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
参数：
-
val：64 位无符号整数
-
ctx：
Decimal上下文
init
public init(val: UIntNative, ctx!: DecimalContext = defaultDecimalContext)
功能：通过 32 位或 64 位 (具体长度与平台相关) 无符号整数构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
参数：
-
val：32 位或 64位无符号整数
-
ctx：
Decimal上下文
init
public init(val: Float16, ctx!: DecimalContext = defaultDecimalContext)
功能：通过 16 位有符号浮点数构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
注意：由于部分十进制小数无法通过二进制浮点数精确表示，此构造函数以精确值构建 Decimal 对象，传入浮点数值可能与最终构建 Decimal 对象字符串打印值不一致。
参数：
-
val：16 位有符号二进制浮点数
-
ctx：
Decimal上下文
异常：
- IllegalArgumentException：当入参为
inf、-inf或nan时，抛出此异常
init
public init(val: Float32, ctx!: DecimalContext = defaultDecimalContext)
功能：通过 32 位有符号浮点数构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
注意：由于部分十进制小数无法通过二进制浮点数精确表示，此构造函数以精确值构建 Decimal 对象，传入浮点数值可能与最终构建 Decimal 对象字符串打印值不一致。
参数：
-
val：32 位有符号二进制浮点数
-
ctx：
Decimal上下文
异常：
- IllegalArgumentException：当入参为
inf、-inf或nan时，抛出此异常
init
public init(val: Float64, ctx!: DecimalContext = defaultDecimalContext)
功能：通过 64 位有符号浮点数构建 Decimal 对象。允许自行指定上下文，对构建结果限制精度，按指定舍入规则进行舍入操作。默认采用 defaultDecimalContext 即无限精度进行构建。
注意：由于部分十进制小数无法通过二进制浮点数精确表示，此构造函数以精确值构建 Decimal 对象，传入浮点数值可能与最终构建 Decimal 对象字符串打印值不一致。
参数：
-
val：64 位有符号二进制浮点数
-
ctx：
Decimal上下文
异常：
- IllegalArgumentException：当入参为
inf、-inf或nan时，抛出此异常
defaultDecimalContext
public static let defaultDecimalContext
功能：默认上下文，精度值为 0，舍入规则为 “银行家舍入”。即无精度限制，保留操作结果实际精度，在操作结果为无限小数场景下，默认遵循 IEEE 754-2019 decimal128 规则，精度保留 34 位 “银行家” 规则舍入。
返回值：DecimalContext 默认值
prop sign
public prop sign: Int64
功能：获取 Decimal 实例符号值。
Decimal值大于 0，返回 1；Decimal值等于 0，返回 0；Decimal值小于 0，返回 -1。
prop scale
public prop scale: Int32
功能：获取 Decimal 标度值。
prop value
public prop value: BigInt
功能：获取 Decimal 无标度整数值，BigInt 承载。
prop precision
public prop precision: Int64
功能：获取 Decimal 精度值，即无标度整数部分十进制有效数字位数，非负数。
func add
public func add(d: Decimal): Decimal
功能：加法运算，加上入参 Decimal 对象，返回结果值。上下文默认 defaultDecimalContext 保留加合结果实际精度值。
参数：
- d：
Decimal加数对象
返回值：生成一个新的 Decimal 对象，用于存储两个加数的加合结果值
异常：
- OverflowException：当两个加数标度值相减值溢出时，抛出此异常
func add
public func add(d: Decimal, ctx: DecimalContext): Decimal
功能：加法运算，支持自定义运算上下文，加上入参 Decimal 对象，返回结果值，如果结果精度超过上下文指定精度，则根据指定的上下文对加合结果进行舍入。
参数：
-
d：
Decimal加数对象 -
ctx：
Decimal上下文
返回值：生成一个新的 Decimal 对象，用于存储两个加数的加合结果值
异常：
- OverflowException：当两个加数标度值相减值溢出时，抛出此异常
operator func +
public operator func +(d: Decimal): Decimal
功能：加法运算，加法运算符重载，行为与 add 函数相同，加上入参 Decimal 对象，返回结果值。上下文默认 defaultDecimalContext 保留加合结果实际精度值。
参数：
- d：
Decimal加数对象
返回值：生成一个新的 Decimal 对象，用于存储两个加数的加合结果值
异常：
- OverflowException：当两个加数标度值相减溢出时，抛出此异常
func sub
public func sub(d: Decimal): Decimal
功能：减法运算，减去入参 Decimal 对象，返回结果值。上下文默认 defaultDecimalContext 保留减法运算结果实际精度值。
参数：
- d：
Decimal减数对象
返回值：生成一个新的 Decimal 对象，用于存储减法运算结果值
异常：
- OverflowException：当被减数与减数标度值相减溢出时，抛出此异常
func sub
public func sub(d: Decimal, ctx: DecimalContext): Decimal
功能：减法运算，支持自定义运算上下文，减去入参 Decimal 对象，返回结果值，如果结果精度超过上下文指定精度，则根据指定的上下文对减法运算结果进行舍入。
参数：
-
d：
Decimal减数对象 -
ctx：
Decimal上下文
返回值：生成一个新的 Decimal 对象，用于存储减法运算结果值
异常：
- OverflowException：当被减数与减数标度值相减溢出时，抛出此异常
operator func -
public operator func -(d: Decimal): Decimal
功能：减法运算，减法运算符重载，行为与 sub 函数相同，减去入参 Decimal 对象，返回结果值。上下文默认 defaultDecimalContext 保留减法运算结果实际精度值。
参数：
- d：
Decimal减数对象
返回值：生成一个新的 Decimal 对象，用于存储减法运算结果值
异常：
- OverflowException：当被减数与减数标度值相减溢出时，抛出此异常
func mul
public func mul(d: Decimal): Decimal
功能：乘法运算，乘以入参 Decimal 对象，返回结果值。上下文默认 defaultDecimalContext 保留乘法运算结果实际精度值。
参数：
- d：
Decimal乘数对象
返回值：生产一个新的 Decimal 对象，用于存储乘法运算结果值
异常：
- OverflowException：当两个乘数标度值相加溢出时，抛出此异常
func mul
public func mul(d: Decimal, ctx: DecimalContext): Decimal
功能：乘法运算，支持自定义运算上下文，乘以入参 Decimal 对象，返回结果值，如果结果精度超过上下文指定精度，则根据指定的上下文对乘法运算结果进行舍入。
参数：
- d：
Decimal乘数对象
返回值：生成一个新的 Decimal 对象，用于存储乘法运算结果值
异常：
- OverflowException：当两个乘数标度值相加溢出时，抛出此异常
operator func *
public operator func *(d: Decimal): Decimal
功能：乘法运算，乘法运算符重载，行为与 mul 函数相同，乘以入参 Decimal 对象，返回结果值。上下文默认 defaultDecimalContext 保留乘法运算结果实际精度值。
参数：
- d：
Decimal乘数对象
返回值：生成一个新的 Decimal 对象，用于存储乘法运算结果值
异常：
- OverflowException：当两个乘数标度值相加溢出时，抛出此异常
func div
public func div(d: Decimal): Decimal
功能：除法运算，除以入参 Decimal 对象，返回结果值。上下文默认 defaultDecimalContext 保留除法运算结果实际精度值。
注意：结果为无限小数场景时，默认采用 IEEE 754-2019 decimal128 对结果进行舍入。
参数：
- d：
Decimal除数对象
返回值：生成一个新的 Decimal 对象，用于存储除法运算结果值
异常：
-
IllegalArgumentException：当除数为 0 时，抛出此异常
-
OverflowException：当除法结果值范围超过
[-(maxValue(ctx.precision) * (10 ^ {Int32.MAX})), maxValue(ctx.precision) * (10 ^ {Int32.MAX})]时，抛出此异常
func div
public func div(d: Decimal, ctx: DecimalContext): Decimal
功能：除法运算，支持自定义运算上下文，除以入参 Decimal 对象，返回结果值，如果结果精度超过上下文指定精度，则根据指定的上下文对除法运算结果进行舍入。
参数：
-
d：
Decimal除数对象 -
ctx：
Decimal上下文
返回值：生成一个新的 Decimal 对象，用于存储除法运算结果值
异常：
-
IllegalArgumentException：当除数为 0 时，抛出此异常
-
OverflowException：当除法结果值范围超过
[-(maxValue(ctx.precision) * (10 ^ {Int32.MAX})), maxValue(ctx.precision) * (10 ^ {Int32.MAX})]时，抛出此异常
operator func /
public operator func /(d: Decimal): Decimal
功能：除法运算，除法运算符重载，行为与 div 函数相同，除以入参 Decimal 对象，返回结果值。上下文默认 defaultDecimalContext 保留除法运算结果实际精度值。
注意：结果为无限小数场景时，默认采用 IEEE 754-2019 decimal128 对结果进行舍入。
参数：
- d：
Decimal除数对象
返回值：生成一个新的 Decimal 对象，用于存储除法运算结果值
异常：
-
IllegalArgumentException：当除数为 0 时，抛出此异常
-
OverflowException：当除法结果值范围超过
[-(maxValue(ctx.precision) * (10 ^ {Int32.MAX})), maxValue(ctx.precision) * (10 ^ {Int32.MAX})]时，抛出此异常
func divAndRem
public func divAndRem(d: Decimal): (BigInt, Decimal)
功能：除法取商和余数运算，除以入参 Decimal 对象，返回整数商值和余数值。上下文默认 defaultDecimalContext 保留结果实际精度值。
参数：
- d：
Decimal除数对象
返回值：生成一个元组对象，分别用于存储整数商值结果和余数结果值
异常：
-
IllegalArgumentException：当除数为 0 时，抛出此异常
-
OverflowException：当除法结果值范围超过
[-(maxValue(ctx.precision) * (10 ^ {Int32.MAX})), maxValue(ctx.precision) * (10 ^ {Int32.MAX})]时，抛出此异常
func divAndRem
public func divAndRem(d: Decimal, ctx: DecimalContext): (BigInt, Decimal)
功能：除法取商和余数运算，支持自定义运算上下文，除以入参 Decimal 对象，返回整数商值和余数值。如果结果精度超过上下文指定精度，则根据指定的上下文对除法运算结果进行舍入。特别注意，这里传入的舍入规则是无效的，默认使用 RoundingMode.DOWN。
参数：
-
d：
Decimal除数对象 -
ctx：
Decimal上下文
返回值：生成一个元组对象，分别用于存储整数商值结果和余数结果值
异常：
-
IllegalArgumentException：当除数为 0 时，抛出此异常
-
OverflowException：当除法结果值范围超过
[-(maxValue(ctx.precision) * (10 ^ {Int32.MAX})), maxValue(ctx.precision) * (10 ^ {Int32.MAX})]时，抛出此异常
func neg
public func neg(): Decimal
功能：取反运算，对当前 Decimal 对象取反，返回结果值。上下文默认 defaultDecimalContext 保留取反运算结果实际精度值。
返回值：生成一个新的 Decimal 对象，用于存储取反结果值
func neg
public func neg(ctx: DecimalContext): Decimal
功能：取反运算，支持自定义运算上下文，对当前 Decimal 对象取反，返回结果值。如果结果精度超过上下文指定精度，则根据指定的上下文对取反运算结果进行舍入。
参数：
- ctx：
Decimal上下文
返回值：生成一个新的 Decimal 对象，用于存储取反结果值
operator func -
public operator func -(): Decimal
功能：取反运算，一元负数运算符重载，行为与 neg 函数相同，对当前 Decimal 对象取反，返回结果值。上下文默认 defaultDecimalContext 保留取反运算结果实际精度值。
返回值：生成一个新的 Decimal 对象，用于存储取反结果值
operator func <
public operator func <(d: Decimal): Bool
功能：小于比较运算，小于运算符重载，判断入参 Decimal 对象是否小于当前对象，返回比较结果值。
参数：
- d：
Decimal待比较对象
返回值：返回小于比较运算结果。当前对象小于入参时，返回 true，否则返回 false
operator func >
public operator func >(d: Decimal): Bool
功能：大于比较运算，大于运算符重载，判断入参 Decimal 对象是否大于当前对象，返回比较结果值。
参数：
- d：
Decimal待比较对象
返回值：返回大于比较运算结果。当前对象大于入参时，返回 true，否则返回 false
operator func <=
public operator func <=(d: Decimal): Bool
功能：小于等于比较运算，小于等于运算符重载，判断入参 Decimal 对象是否小于等于当前对象，返回比较结果值。
参数：
- d：
Decimal待比较对象
返回值：返回小于等于比较运算结果。当前对象小于等于入参时，返回 true，否则返回 false
operator func >=
public operator func >=(d: Decimal): Bool
功能：大于等于比较运算，大于等于运算符重载，判断入参 Decimal 对象是否大于等于当前对象，返回比较结果值。
参数：
- d：
Decimal待比较对象
返回值：返回大于等于比较运算结果。当前对象大于等于入参时，返回 true，否则返回 false
operator func ==
public operator func ==(d: Decimal): Bool
功能：等于比较运算，等于运算符重载，判断入参 Decimal 对象与当前对象是否相等，返回比较结果值。
参数：
- d：
Decimal待比较对象
返回值：返回等于比较运算结果。当前对象等于入参时，返回 true，否则返回 false
operator func !=
public operator func !=(d: Decimal): Bool
功能：不等比较运算，不等运算符重载，判断入参 Decimal 对象与当前对象是否不相等，返回比较结果值。
参数：
- d：
Decimal待比较对象
返回值：返回不等比较运算结果。当前对象不等于入参时，返回 true，否则返回 false
func compare
public func compare(d: Decimal): Ordering
功能：比较当前对象与入参 Decimal 对象，返回比较结果值。
参数：
- d：
Decimal待比较对象
返回值：返回比较结果，当前对象小于入参时，返回 Ordering.LT，大于入参时，返回 Ordering.GT，否则返回 Ordering.EQ
func hashCode
public func hashCode(): Int64
功能：获取当前对象哈希值。
返回值：返回当前对象哈希值
func toString
public func toString(): String
功能：以不带指数形式打印输出 Decimal 对象，小于 0 时以 “-” 开头后跟十进制数字，大于等于 0 时，直接打印输出数字，不额外添加 “+”。
返回值：不带指数形式的 Decimal 字符串
func reScale
public func reScale(newScale: Int32, rm!: RoundingMode = HALF_EVEN): Decimal
功能：调整 Decimal 对象标度值，允许指定舍入规则，返回标度调整后新的 Decimal 对象。
参数：
-
newScale：新的标度值
-
rm：舍入规则
返回值：新的标度值的 Decimal 对象
func removeTrailingZeros
public func removeTrailingZeros(): Decimal
功能：对当前 Decimal 对象移除尾部零，不改变对象数值。
返回值：新的无尾部零的 Decimal 对象
func scaleUnit
public func scaleUnit(): Decimal
功能：对当前 Decimal 对象返回标度单位，即数值为 1 ，标度值与当前对象相等的 Decimal 对象。
返回值：标度单位 Decimal 对象
func isInteger
public func isInteger(): Bool
功能：判断当前 Decimal 对象是否为整数。
返回值：返回当前对象是否为整数判断结果。当前对象为整数时返回 true，否则返回 false
func pow
public func pow(n: Int64): Decimal
功能：乘方运算，获取当前对象为底数，入参 Int64 为指数的乘方运算结果。
注意：指数为负值且结果为无限小数场景时，默认采用 IEEE 754-2019 decimal128 对结果进行舍入。
参数：
- n：乘方运算的指数值
返回值：生成一个新的 Decimal 对象，用于存储乘方运算结果值
异常：
- OverflowException：当乘方运算结果标度值溢出时，抛出此异常
func pow
public func pow(n: Int64, ctx: DecimalContext): Decimal
功能：乘方运算，支持自定义运算上下文，获取当前对象为底数，入参 Int64 为指数的乘方运算结果，如果运算结果超过上下文指定精度，则根据指定的上下文对乘方结果进行舍入。
参数：
-
n：乘方运算的指数值
-
ctx：
Decimal上下文
返回值：生成一个新的 Decimal 对象，用于存储乘方运算结果值
异常：
- OverflowException：当乘方运算结果标度值溢出时，抛出此异常
operator func **
public operator func **(n: Int64): Decimal
功能：乘方运算，乘方运算符重载，行为与 pow 函数相同，获取当前对象为底数，入参 Int64 为指数的乘方运算结果，其中指数为入参 Decimal 对象的整数部分。
注意：指数为负值且结果为无限小数场景时，默认采用 IEEE 754-2019 decimal128 对结果进行舍入。
参数：
- n：乘方运算的指数值
返回值：生成一个新的 Decimal 对象，用于存储乘方运算结果值
异常：
- OverflowException：当乘方运算结果标度值溢出时，抛出此异常
func shiftPoint
public func shiftPoint(n: Int32): Decimal
功能：移动当前 Decimal 对象小数点 abs(n) 位返回结果对象，当 n 为正数时，左移小数点，n 为负数时，右移小数点，n 为零时，返回当前对象。
参数：
- n：指定小数点移动位数及方向
返回值：对当前对象小数点移动指定位数后生成新的 Decimal 对象
func round
public func round(ctx: DecimalContext): Decimal
功能：按照指定上下文（舍入精度、舍入规则）对当前 Decimal 对象进行舍入操作。
参数：
- ctx：
Decimal上下文
返回值：舍入操作生成的新的 Decimal 对象
异常：
- OverflowException：当舍入操作结果标度值溢出时，抛出此异常
func abs
public func abs(): Decimal
功能：获取当前 Decimal 对象的绝对值。
返回值：返回当前 Decimal 对象的绝对值
func sqrt
public func sqrt(ctx!: DecimalContext = defaultDecimalContext): Decimal
功能：开方运算，支持自定义运算上下文，获取当前对象开方结果，如果运算结果超过上下文指定精度，则根据指定的上下文对开方结果进行舍入。
入参：
- ctx：
Decimal上下文
返回值：生成一个新的 Decimal 对象，用于存储开方运算结果值
异常：
- IllegalArgumentException：当前
Decimal对象为负数时，抛出此异常
func toInt8
public func toInt8(overflowHandling!: OverflowStrategy = throwing): Int8
功能：将当前 Decimal 对象转化为 Int8 类型，支持自定义溢出策略。
入参：
- overflowHandling：转换溢出策略
返回值：转换后的 Int8 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toInt16
public func toInt16(overflowHandling!: OverflowStrategy = throwing): Int16
功能：将当前 Decimal 对象转化为 Int16 类型，支持自定义溢出策略。
入参：
- overflowHandling：转换溢出策略
返回值：转换后的 Int16 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toInt32
public func toInt32(overflowHandling!: OverflowStrategy = throwing): Int32
功能：将当前 Decimal 对象转化为 Int32 类型，支持自定义溢出策略。
入参：
- overflowHandling：转换溢出策略
返回值：转换后的 Int32 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toInt64
public func toInt64(overflowHandling!: OverflowStrategy = throwing): Int64
功能：将当前 Decimal 对象转化为 Int64 类型，支持自定义溢出策略。
入参：
- overflowHandling：转换溢出策略
返回值：转换后的 Int64 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toIntNative
public func toIntNative(overflowHandling!: OverflowStrategy = throwing): IntNative
功能：将当前 Decimal 对象转化为 IntNative 类型，支持自定义溢出策略。
入参：
- overflowHandling：转换溢出策略
返回值：转换后的 IntNative 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toUInt8
public func toUInt8(overflowHandling!: OverflowStrategy = throwing): UInt8
功能：将当前 Decimal 对象转化为 UInt8 类型，支持自定义溢出策略。
入参：
- overflowHandling：转换溢出策略
返回值：转换后的 UInt8 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toUInt16
public func toUInt16(overflowHandling!: OverflowStrategy = throwing): UInt16
功能：将当前 Decimal 对象转化为 UInt16 类型，支持自定义溢出策略。
入参：
- overflowHandling：转换溢出策略
返回值：转换后的 UInt16 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toUInt32
public func toUInt32(overflowHandling!: OverflowStrategy = throwing): UInt32
功能：将当前 Decimal 对象转化为 UInt32 类型，支持自定义溢出策略。
入参：
- overflowHandling：转换溢出策略
返回值：转换后的 UInt32 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toUInt64
public func toUInt64(overflowHandling!: OverflowStrategy = throwing): UInt64
功能：将当前 Decimal 对象转化为 UInt64 类型，支持自定义溢出策略。
入参：
- overflowHandling：转换溢出策略
返回值：转换后的 UInt64 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toUIntNative
public func toUIntNative(overflowHandling!: OverflowStrategy = throwing): UIntNative
功能：将当前 Decimal 对象转化为 UIntNative 类型，支持自定义溢出策略。
入参：
- overflowHandling：转换溢出策略
返回值：转换后的 UIntNative 值
异常：
- OverflowException：当不指定溢出策略或溢出策略为
throwing转换溢出时，抛出此异常
func toFloat16
public func toFloat16(): Float16
功能：将当前 Decimal 对象转化为 Float16 类型。
返回值：转换后的 Float16 值，溢出时，当前值为正数，返回 inf，当前值为负数，返回 -inf
func toFloat32
public func toFloat32(): Float32
功能：将当前 Decimal 对象转化为 Float32 类型。
返回值：转换后的 Float32 值，溢出时，当前值为正数，返回 inf，当前值为负数，返回 -inf
func toFloat64
public func toFloat64(): Float64
功能：将当前 Decimal 对象转化为 Float64 类型。
返回值：转换后的 Float64 值，溢出时，当前值为正数，返回 inf，当前值为负数，返回 -inf
func toBigInt
public func toBigInt(): BigInt
功能：将当前 Decimal 对象转化为 BigInt 类型。
返回值：转换后的 BigInt 值
func toEngString
public func toEngString(): String
功能：以工程计数法的形式打印输出 Decimal 对象，指数为 3 的倍数, 当值小于 0 时以 “-” 开头后跟十进制数字，大于等于 0 时，直接打印输出数字，不额外添加 “+”。指数小于 0 时同样遵循以上规则。
返回值：工程计数法形式的 Decimal 字符串
func toSciString
public func toSciString(): String
功能：以科学计数法的形式打印输出 Decimal 对象，当值小于 0 时以 “-” 开头后跟十进制数字，大于等于 0 时，直接打印输出数字，不额外添加 “+”。指数小于 0 时同样遵循以上规则。
返回值：科学计数法形式的 Decimal 字符串
示例
Decimal 基础运算操作
以下为通过不同构造函数初始化 Decimal 对象的，并进行基础数学运算示例：
代码如下：
from std import math.numeric.*
main() {
let decimal1: Decimal = Decimal("12345.6789")
let decimal2: Decimal = Decimal(BigInt("987654321"), 6)
println("without ctx:")
println("${decimal1} + ${decimal2} = ${decimal1 + decimal2}")
println("${decimal1} - ${decimal2} = ${decimal1 - decimal2}")
println("${decimal1} * ${decimal2} = ${decimal1 * decimal2}")
println("${decimal1} / ${decimal2} = ${decimal1 / decimal2}")
let (quo, rem) = decimal1.divAndRem(decimal2)
println("${decimal1} / ${decimal2} = ${quo} .. ${rem}")
println("with ctx(precision: 8, HALF_EVEN):")
let baseOperCtx = DecimalContext(8, HALF_EVEN)
println("${decimal1} + ${decimal2} = ${decimal1.add(decimal2, baseOperCtx)}")
println("${decimal1} - ${decimal2} = ${decimal1.sub(decimal2, baseOperCtx)}")
println("${decimal1} * ${decimal2} = ${decimal1.mul(decimal2, baseOperCtx)}")
println("${decimal1} / ${decimal2} = ${decimal1.div(decimal2, baseOperCtx)}")
let (quoWithCtx, remWithCtx) = decimal1.divAndRem(decimal2, baseOperCtx)
println("${decimal1} / ${decimal2} = ${quoWithCtx} .. ${remWithCtx}")
return 0
}
运行结果如下:
without ctx:
12345.6789 + 987.654321 = 13333.333221
12345.6789 - 987.654321 = 11358.024579
12345.6789 * 987.654321 = 12193263.1112635269
12345.6789 / 987.654321 = 12.49999988609375000142382812498220
12345.6789 / 987.654321 = 12 .. 493.827048
with ctx(precision: 8, HALF_EVEN):
12345.6789 + 987.654321 = 13333.333
12345.6789 - 987.654321 = 11358.025
12345.6789 * 987.654321 = 12193263
12345.6789 / 987.654321 = 12.500000
12345.6789 / 987.654321 = 12 .. 493.827048
Decimal 基本属性操作
以下为初始化 Decimal 对象的，并查询对象的基本属性的示例：
代码如下：
from std import math.numeric.*
main() {
let decimalProperties = Decimal("-123456.7890123456789")
println("deciaml: ${decimalProperties}")
println("decimal sign: ${decimalProperties.sign}")
println("decimal scale: ${decimalProperties.scale}")
println("decimal value: ${decimalProperties.value}")
println("decimal precision: ${decimalProperties.precision}")
return 0
}
运行结果如下:
deciaml: -123456.7890123456789
decimal sign: -1
decimal scale: 13
decimal value: -1234567890123456789
decimal precision: 19
Decimal 比较操作
以下为初始化多个 Decimal 对象，相互之间大小比较的示例：
代码如下：
from std import math.numeric.*
main() {
let decimal1 = Decimal("12345.6789")
let decimal2 = Decimal("987.654321")
println("${decimal1} > ${decimal2} = ${decimal1 > decimal2}")
println("${decimal1} < ${decimal2} = ${decimal1 < decimal2}")
println("${decimal1} == ${decimal2} = ${decimal1 == decimal2}")
println("${decimal1} != ${decimal2} = ${decimal1 != decimal2}")
println("${decimal1} <= ${decimal2} = ${decimal1 <= decimal2}")
println("${decimal1} >= ${decimal2} = ${decimal1 >= decimal2}")
println("${decimal1}.compare(${decimal2}) = ${decimal1.compare(decimal2)}")
return 0
}
运行结果如下:
12345.6789 > 987.654321 = true
12345.6789 < 987.654321 = false
12345.6789 == 987.654321 = false
12345.6789 != 987.654321 = true
12345.6789 <= 987.654321 = false
12345.6789 >= 987.654321 = true
12345.6789.compare(987.654321) = Ordering.GT
BigInt 基础运算操作
以下为通过不同构造函数初始化 BigInt 对象的，并进行基础数学运算示例：
代码如下：
from std import math.numeric.*
main() {
let int1: BigInt = BigInt("123456789")
let int2: BigInt = BigInt("987654321")
println("${int1} + ${int2} = ${int1 + int2}")
println("${int1} - ${int2} = ${int1 - int2}")
println("${int1} * ${int2} = ${int1 * int2}")
println("${int1} / ${int2} = ${int1 / int2}")
let (quo, mod) = int1.divAndMod(int2)
println("${int1} / ${int2} = ${quo} .. ${mod}")
return 0
}
运行结果如下:
123456789 + 987654321 = 1111111110
123456789 - 987654321 = -864197532
123456789 * 987654321 = 121932631112635269
123456789 / 987654321 = 0
123456789 / 987654321 = 0 .. 123456789
BigInt 基本属性操作
以下为初始化 BigInt 对象的，并查询对象的基本属性的示例：
代码如下：
from std import math.numeric.*
main() {
let int = BigInt("-123456")
println("BigInt: ${int}")
println("BigInt sign: ${int.sign}")
println("BigInt bitLen: ${int.bitLen}")
return 0
}
运行结果如下:
BigInt: -123456
BigInt sign: -1
BigInt bitLen: 18
BigInt 比较操作
以下为初始化多个 BigInt 对象，相互之间大小比较的示例：
代码如下：
from std import math.numeric.*
main() {
let int1 = BigInt("123456789")
let int2 = BigInt("987654321")
println("${int1} > ${int2} = ${int1 > int2}")
println("${int1} < ${int2} = ${int1 < int2}")
println("${int1} == ${int2} = ${int1 == int2}")
println("${int1} != ${int2} = ${int1 != int2}")
println("${int1} <= ${int2} = ${int1 <= int2}")
println("${int1} >= ${int2} = ${int1 >= int2}")
println("${int1}.compare(${int2}) = ${int1.compare(int2)}")
return 0
}
运行结果如下:
123456789 > 987654321 = false
123456789 < 987654321 = true
123456789 == 987654321 = false
123456789 != 987654321 = true
123456789 <= 987654321 = true
123456789 >= 987654321 = false
123456789.compare(987654321) = Ordering.LT