Numbers

数字

所有数字类型的抽象超类型。

Real <: Number

所有实数的抽象超类型。

AbstractFloat <: Real

所有浮点数的抽象超类型。

Integer <: Real

所有整数的抽象超类型（例如 Signed、Unsigned 和 Bool）。

另请参见 isinteger、trunc、div。

示例

julia> 42 isa Integer
true

julia> 1.0 isa Integer
false

julia> isinteger(1.0)
true

Signed <: Integer

所有有符号整数的抽象超类型。

无符号 <: 整数

所有无符号整数的抽象超类型。

内置的无符号整数以十六进制形式打印，前缀为 0x，并且可以以相同的方式输入。

示例

julia> typemax(UInt8)
0xff

julia> Int(0x00d)
13

julia> unsigned(true)
0x0000000000000001

AbstractIrrational <: Real

表示精确无理值的数字类型，在与其他数值进行算术运算时会自动四舍五入到正确的精度。

子类型 MyIrrational <: AbstractIrrational 应至少实现 ==(::MyIrrational, ::MyIrrational)、hash(x::MyIrrational, h::UInt) 和 convert(::Type{F}, x::MyIrrational) where {F <: Union{BigFloat,Float32,Float64}}。

如果子类型用于表示可能偶尔为有理数的值（例如，表示 √n 的平方根类型，当整数 n 为完全平方时将给出有理结果），则还应实现 isinteger、iszero、isone 和与 Real 值的 ==（因为所有这些在 AbstractIrrational 类型中默认返回 false），并且定义 hash 使其等于相应的 Rational 的哈希值。

Float16 <: AbstractFloat <: Real

16位浮点数类型（IEEE 754标准）。二进制格式为1个符号位，5个指数位，10个小数位。

Float32 <: AbstractFloat <: Real

32位浮点数类型（IEEE 754标准）。二进制格式为1个符号位，8个指数位，23个小数位。

科学计数法的指数应以小写f输入，因此2f3 === 2.0f0 * 10^3 === Float32(2_000)。对于数组字面量和推导式，元素类型可以在方括号之前指定：Float32[1,4,9] == Float32[i^2 for i in 1:3]。

另见 Inf32, NaN32, Float16, exponent, frexp。

Float64 <: AbstractFloat <: Real

64位浮点数类型（IEEE 754标准）。二进制格式为1个符号位，11个指数位，52个小数位。请参见bitstring，signbit，exponent，frexp和significand以访问各种位。

这是浮点字面量的默认值，1.0 isa Float64，以及许多操作，如1/2, 2pi, log(2), range(0,90,length=4)。与整数不同，这个默认值不会随着Sys.WORD_SIZE的变化而改变。

科学记数法的指数可以用e或E输入，因此2e3 === 2.0E3 === 2.0 * 10^3。这样做比10^n更受推荐，因为整数会溢出，因此2.0 * 10^19 < 0但2e19 > 0。

另请参见Inf，NaN，floatmax，Float32，Complex。

BigFloat <: AbstractFloat

任意精度浮点数类型。

Bool <: Integer

布尔类型，包含值 true 和 false。

Bool 是一种数字：false 在数值上等于 0，而 true 在数值上等于 1。此外，false 在与 NaN 和 Inf 的乘法运算中表现为一种乘法“强零”：

julia> [true, false] == [1, 0]
true

julia> 42.0 + true
43.0

julia> 0 .* (NaN, Inf, -Inf)
(NaN, NaN, NaN)

julia> false .* (NaN, Inf, -Inf)
(0.0, 0.0, -0.0)

通过 if 和其他条件语句的分支仅接受 Bool。在 Julia 中没有“真值”。

比较通常返回 Bool，而广播的比较可能返回 BitArray 而不是 Array{Bool}。

julia> [1 2 3 4 5] .< pi
1×5 BitMatrix:
 1  1  1  0  0

julia> map(>(pi), [1 2 3 4 5])
1×5 Matrix{Bool}:
 0  0  0  1  1

另见 trues，falses，ifelse。

Int8 <: Signed <: Integer

8位有符号整数类型。

表示数字 n ∈ -128:127。请注意，这种整数在溢出时不会发出警告，因此 typemax(Int8) + Int8(1) < 0。

另请参见 Int、widen、BigInt。

UInt8 <: Unsigned <: Integer

8位无符号整数类型。

以十六进制打印，因此 0x07 == 7。

Int16 <: Signed <: Integer

16位有符号整数类型。

表示数字 n ∈ -32768:32767。请注意，这种整数在溢出时不会发出警告，因此 typemax(Int16) + Int16(1) < 0。

另请参见 Int、widen、BigInt。

UInt16 <: Unsigned <: Integer

16位无符号整数类型。

以十六进制打印，因此 0x000f == 15。

Int32 <: Signed <: Integer

32位有符号整数类型。

请注意，这种整数在溢出时不会发出警告，因此 typemax(Int32) + Int32(1) < 0。

另请参见 Int, widen, BigInt。

UInt32 <: Unsigned <: Integer

32位无符号整数类型。

以十六进制打印，因此 0x0000001f == 31。

Int64 <: Signed <: Integer

64位有符号整数类型。

请注意，这种整数在溢出时不会发出警告，因此 typemax(Int64) + Int64(1) < 0。

另请参见 Int, widen, BigInt.

UInt64 <: Unsigned <: Integer

64位无符号整数类型。

以十六进制打印，因此 0x000000000000003f == 63。

Int128 <: Signed <: Integer

128位有符号整数类型。

请注意，这种整数在溢出时不会发出警告，因此 typemax(Int128) + Int128(1) < 0。

另请参见 Int, widen, BigInt。

UInt128 <: Unsigned <: Integer

128位无符号整数类型。

以十六进制打印，因此 0x0000000000000000000000000000007f == 127。

Int

Sys.WORD_SIZE 位的有符号整数类型，Int <: Signed <: Integer <: Real。

这是大多数整数字面量的默认类型，并且是 Int32 或 Int64 的别名，具体取决于 Sys.WORD_SIZE。它是由诸如 length 的函数返回的类型，也是索引数组的标准类型。

请注意，整数在溢出时不会发出警告，因此 typemax(Int) + 1 < 0 和 10^19 < 0。可以通过使用 BigInt 来避免溢出。非常大的整数字面量将使用更宽的类型，例如 10_000_000_000_000_000_000 isa Int128。

整数除法是 div 别名 ÷，而对整数执行的 / 返回 Float64。

另请参见 Int64，widen，typemax，bitstring。

UInt

Sys.WORD_SIZE位无符号整数类型，UInt <: Unsigned <: Integer。

像Int一样，别名UInt可能指向UInt32或UInt64，具体取决于给定计算机上Sys.WORD_SIZE的值。

以十六进制打印和解析：UInt(15) === 0x000000000000000f。

BigInt <: Signed

任意精度整数类型。

Complex{T<:Real} <: Number

复数类型，其实部和虚部的类型为 T。

ComplexF16、ComplexF32 和 ComplexF64 分别是 Complex{Float16}、Complex{Float32} 和 Complex{Float64} 的别名。

另见: Real, complex, real.

Rational{T<:Integer} <: Real

有理数类型，分子和分母的类型为 T。有理数会检查溢出。

Irrational{sym} <: AbstractIrrational

表示由符号 sym 表示的确切无理值的数字类型，例如 π、ℯ 和 γ。

另见 AbstractIrrational。

digits([T<:Integer], n::Integer; base::T = 10, pad::Integer = 1)

返回一个元素类型为 T（默认为 Int）的数组，包含 n 在给定进制下的数字，选项上可以用零填充到指定大小。更重要的数字位于更高的索引，因此 n == sum(digits[k]*base^(k-1) for k in eachindex(digits))。

另请参见 ndigits，digits!，以及对于基数 2 还可以查看 bitstring，count_ones。

示例

julia> digits(10)
2-element Vector{Int64}:
 0
 1

julia> digits(10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits(-256, base = 10, pad = 5)
5-element Vector{Int64}:
 -6
 -5
 -2
  0
  0

julia> n = rand(-999:999);

julia> n == evalpoly(13, digits(n, base = 13))
true

digits!(array, n::Integer; base::Integer = 10)

填充一个数组，包含在给定进制下 n 的数字。更高位的数字位于更高的索引。如果数组长度不足，则填充最不重要的数字直到数组长度。如果数组长度过长，则多余的部分用零填充。

示例

julia> digits!([2, 2, 2, 2], 10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits!([2, 2, 2, 2, 2, 2], 10, base = 2)
6-element Vector{Int64}:
 0
 1
 0
 1
 0
 0

bitstring(n)

一个字符串，给出原始类型的字面位表示。

另见 count_ones, count_zeros, digits.

示例

julia> bitstring(Int32(4))
"00000000000000000000000000000100"

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

parse(::Type{SimpleColor}, rgb::String)

tryparse(SimpleColor, rgb::String) 的一个类似功能（见该函数），它会抛出错误而不是返回 nothing。

parse(::Type{Platform}, triplet::AbstractString)

将字符串平台三元组解析回 Platform 对象。

parse(type, str; base)

将字符串解析为数字。对于 Integer 类型，可以指定基数（默认是 10）。对于浮点类型，字符串被解析为十进制浮点数。 Complex 类型从形式为 "R±Iim" 的十进制字符串解析为请求类型的 Complex(R,I)；可以使用 "i" 或 "j" 替代 "im"，并且 "R" 或 "Iim" 也是允许的。如果字符串不包含有效数字，则会引发错误。

示例

julia> parse(Int, "1234")
1234

julia> parse(Int, "1234", base = 5)
194

julia> parse(Int, "afc", base = 16)
2812

julia> parse(Float64, "1.2e-3")
0.0012

julia> parse(Complex{Float64}, "3.2e-1 + 4.5im")
0.32 + 4.5im

tryparse(::Type{SimpleColor}, rgb::String)

尝试将 rgb 解析为 SimpleColor。如果 rgb 以 # 开头并且长度为 7，则将其转换为以 RGBTuple 为基础的 SimpleColor。如果 rgb 以 a-z 开头，则将 rgb 解释为颜色名称并转换为以 Symbol 为基础的 SimpleColor。

否则，返回 nothing。

示例

julia> tryparse(SimpleColor, "blue")
SimpleColor(blue)

julia> tryparse(SimpleColor, "#9558b2")
SimpleColor(#9558b2)

julia> tryparse(SimpleColor, "#nocolor")

tryparse(type, str; base)

与 parse 类似，但如果字符串不包含有效数字，则返回请求类型的值或 nothing。

big(x)

将数字转换为最大精度表示（通常是 BigInt 或 BigFloat）。有关浮点数的一些陷阱，请参见 BigFloat。

signed(T::Integer)

将整数位类型转换为相同大小的有符号类型。

示例

julia> signed(UInt16)
Int16
julia> signed(UInt64)
Int64

signed(x)

将数字转换为有符号整数。如果参数是无符号的，则在不检查溢出的情况下将其重新解释为有符号。

另请参见: unsigned, sign, signbit.

unsigned(T::Integer)

将整数位类型转换为相同大小的无符号类型。

示例

julia> unsigned(Int16)
UInt16
julia> unsigned(UInt64)
UInt64

float(x)

将数字或数组转换为浮点数据类型。

另见：complex, oftype, convert。

示例

julia> float(1:1000)
1.0:1.0:1000.0

julia> float(typemax(Int32))
2.147483647e9

significand(x)

提取浮点数的有效数字（也称为尾数）。如果 x 是一个非零有限数，则结果将是与 x 相同类型和符号的数字，其绝对值在区间 $[1,2)$ 上。否则返回 x。

另请参见 frexp, exponent。

示例

julia> significand(15.2)
1.9

julia> significand(-15.2)
-1.9

julia> significand(-15.2) * 2^3
-15.2

julia> significand(-Inf), significand(Inf), significand(NaN)
(-Inf, Inf, NaN)

exponent(x::Real) -> Int

返回最大的整数 y，使得 2^y ≤ abs(x)。

当 x 为零、无穷大或 NaN 时抛出 DomainError。对于任何其他非次正常浮点数 x，这对应于 x 的指数位。

另请参见 signbit, significand, frexp, issubnormal, log2, ldexp。

示例

julia> exponent(8)
3

julia> exponent(6.5)
2

julia> exponent(-1//4)
-2

julia> exponent(3.142e-4)
-12

julia> exponent(floatmin(Float32)), exponent(nextfloat(0.0f0))
(-126, -149)

julia> exponent(0.0)
ERROR: DomainError with 0.0:
Cannot be ±0.0.
[...]

complex(r, [i])

将实数或数组转换为复数。i 默认为零。

示例

julia> complex(7)
7 + 0im

julia> complex([1, 2, 3])
3-element Vector{Complex{Int64}}:
 1 + 0im
 2 + 0im
 3 + 0im

bswap(n)

反转 n 的字节顺序。

（另见 ntoh 和 hton 以在当前本机字节顺序和大端字节顺序之间转换。）

示例

julia> a = bswap(0x10203040)
0x40302010

julia> bswap(a)
0x10203040

julia> string(1, base = 2)
"1"

julia> string(bswap(1), base = 2)
"100000000000000000000000000000000000000000000000000000000"

hex2bytes(itr)

给定一个可迭代的 itr，其中包含一系列十六进制数字的 ASCII 码，返回一个 Vector{UInt8} 的字节，对应于二进制表示：itr 中每对连续的十六进制数字给出返回向量中一个字节的值。

itr 的长度必须是偶数，返回的数组长度是 itr 的一半。另请参见 hex2bytes! 的就地版本，以及 bytes2hex 的逆操作。

示例

julia> s = string(12345, base = 16)
"3039"

julia> hex2bytes(s)
2-element Vector{UInt8}:
 0x30
 0x39

julia> a = b"01abEF"
6-element Base.CodeUnits{UInt8, String}:
 0x30
 0x31
 0x61
 0x62
 0x45
 0x46

julia> hex2bytes(a)
3-element Vector{UInt8}:
 0x01
 0xab
 0xef

hex2bytes!(dest::AbstractVector{UInt8}, itr)

将表示十六进制字符串的字节可迭代对象 itr 转换为其二进制表示，类似于 hex2bytes，但输出是就地写入 dest。dest 的长度必须是 itr 长度的一半。

bytes2hex(itr) -> String
bytes2hex(io::IO, itr)

将字节迭代器 itr 转换为其十六进制字符串表示，可以通过 bytes2hex(itr) 返回一个 String，或者通过 bytes2hex(io, itr) 将字符串写入 io 流。十六进制字符均为小写。

示例

julia> a = string(12345, base = 16)
"3039"

julia> b = hex2bytes(a)
2-element Vector{UInt8}:
 0x30
 0x39

julia> bytes2hex(b)
"3039"

one(x)
one(T::type)

返回 x 的乘法单位元：一个值，使得 one(x)*x == x*one(x) == x。或者 one(T) 可以接受一个类型 T，在这种情况下，one 返回任何类型为 T 的 x 的乘法单位元。

如果可能，one(x) 返回与 x 相同类型的值，而 one(T) 返回类型为 T 的值。然而，对于表示有维度量的类型（例如，天数的时间），这可能不成立，因为乘法单位元必须是无维的。在这种情况下，one(x) 应该返回与 x 相同精度（以及形状，对于矩阵）的单位值。

如果你想要一个与 x 相同类型的量，或者类型为 T，即使 x 是有维度的，请使用 oneunit 替代。

另请参见 identity 函数，以及 I 在 LinearAlgebra 中的单位矩阵。

示例

julia> one(3.7)
1.0

julia> one(Int)
1

julia> import Dates; one(Dates.Day(1))
1

oneunit(x::T)
oneunit(T::Type)

返回 T(one(x))，其中 T 是参数的类型，或者（如果传递了类型）是参数。这与 one 对于具有维度的量不同：one 是无维的（一个乘法单位），而 oneunit 是有维的（与 x 的类型相同，或类型为 T）。

示例

julia> oneunit(3.7)
1.0

julia> import Dates; oneunit(Dates.Day)
1 day

zero(x)
zero(::Type)

获取类型 x 的加法单位元素（x 也可以指定类型本身）。

另见 iszero, one, oneunit, oftype.

示例

julia> zero(1)
0

julia> zero(big"2.0")
0.0

julia> zero(rand(2,2))
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

im

虚数单位。

另见：imag, angle, complex。

示例

julia> im * im
-1 + 0im

julia> (2.0 + 3im)^2
-5.0 + 12.0im

π
pi

常数 pi。

Unicode π 可以通过在 Julia REPL 中输入 \pi 然后按下 tab 键，以及在许多编辑器中输入。

另请参见: sinpi, sincospi, deg2rad。

示例

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

ℯ
e

常数 ℯ。

Unicode ℯ 可以通过在 Julia REPL 中输入 \euler 并按下 tab 键来输入，在许多编辑器中也是如此。

另请参见: exp, cis, cispi。

示例

julia> ℯ
ℯ = 2.7182818284590...

julia> log(ℯ)
1

julia> ℯ^(im)π ≈ -1
true

卡塔兰常数。

# 示例

jldoctest julia> Base.MathConstants.catalan catalan = 0.9159655941772...

julia> sum(log(x)/(1+x^2) for x in 1:0.01:10^6) * 0.01 0.9159466120554123 ```

γ
eulergamma

欧拉常数。

示例

julia> Base.MathConstants.eulergamma
γ = 0.5772156649015...

julia> dx = 10^-6;

julia> sum(-exp(-x) * log(x) for x in dx:dx:100) * dx
0.5772078382499133

φ
黄金

黄金比例。

示例

julia> Base.MathConstants.golden
φ = 1.6180339887498...

julia> (2ans - 1)^2 ≈ 5
true

Inf, Inf64

类型为 Float64 的正无穷。

另请参见：isfinite, typemax, NaN, Inf32。

示例

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf, Inf64

类型为 Float64 的正无穷。

另请参见：isfinite, typemax, NaN, Inf32。

示例

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf32

类型为 Float32 的正无穷大。

Inf16

类型为 Float16 的正无穷大。

NaN, NaN64

一个类型为 Float64 的非数字值。

另请参见：isnan, missing, NaN32, Inf。

示例

julia> 0/0
NaN

julia> Inf - Inf
NaN

julia> NaN == NaN, isequal(NaN, NaN), isnan(NaN)
(false, true, true)

!!! 注意 始终使用 isnan 或 isequal 来检查 NaN。使用 x === NaN 可能会给出意外的结果：

```julia-repl
julia> reinterpret(UInt32, NaN32)
0x7fc00000

julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
NaN32

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)
```

NaN, NaN64

一个类型为 Float64 的非数字值。

另请参见：isnan, missing, NaN32, Inf。

示例

julia> 0/0
NaN

julia> Inf - Inf
NaN

julia> NaN == NaN, isequal(NaN, NaN), isnan(NaN)
(false, true, true)

!!! 注意 始终使用 isnan 或 isequal 来检查 NaN。使用 x === NaN 可能会给出意外的结果：

```julia-repl
julia> reinterpret(UInt32, NaN32)
0x7fc00000

julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
NaN32

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)
```

NaN32

一种类型为 Float32 的非数字值。

另请参见：NaN。

NaN16

一种类型为 Float16 的非数字值。

另请参见：NaN。

issubnormal(f) -> Bool

测试一个浮点数是否是次正规数。

当一个IEEE浮点数的指数位为零且其有效数字不为零时，它是次正规的。

示例

julia> floatmin(Float32)
1.1754944f-38

julia> issubnormal(1.0f-37)
false

julia> issubnormal(1.0f-38)
true

isfinite(f) -> Bool

测试一个数字是否是有限的。

示例

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

isinf(f) -> Bool

测试一个数字是否为无穷大。

另见: Inf, iszero, isfinite, isnan.

isnan(f) -> Bool

测试一个数值是否为 NaN，这是一种不确定的值，既不是无穷大也不是有限数（“不是一个数字”）。

另请参见：iszero, isone, isinf, ismissing.

iszero(x)

如果 x == zero(x)，则返回 true；如果 x 是一个数组，则检查 x 的所有元素是否为零。

另请参见: isone, isinteger, isfinite, isnan.

示例

julia> iszero(0.0)
true

julia> iszero([1, 9, 0])
false

julia> iszero([false, 0, 0])
true

isone(x)

如果 x == one(x)，则返回 true；如果 x 是一个数组，则检查 x 是否是单位矩阵。

示例

julia> isone(1.0)
true

julia> isone([1 0; 0 2])
false

julia> isone([1 0; 0 true])
true

nextfloat(x::AbstractFloat, n::Integer)

如果 n >= 0，则返回对 x 进行 n 次迭代应用 nextfloat 的结果；如果 n < 0，则返回对 prevfloat 进行 -n 次应用的结果。

nextfloat(x::AbstractFloat)

返回与 x 相同类型的最小浮点数 y，使得 x < y。如果不存在这样的 y（例如，如果 x 是 Inf 或 NaN），则返回 x。

另请参见：prevfloat，eps，issubnormal。

prevfloat(x::AbstractFloat, n::Integer)

如果 n >= 0，则对 x 进行 n 次迭代应用 prevfloat 的结果；如果 n < 0，则进行 -n 次 nextfloat 的应用。

prevfloat(x::AbstractFloat)

返回与 x 相同类型的最大浮点数 y，使得 y < x。如果不存在这样的 y（例如，如果 x 是 -Inf 或 NaN），则返回 x。

isinteger(x) -> Bool

测试 x 是否在数值上等于某个整数。

示例

julia> isinteger(4.0)
true

isreal(x) -> Bool

测试 x 或其所有元素是否在数值上等于某个实数，包括无穷大和 NaN。如果 isequal(x, real(x)) 为真，则 isreal(x) 为真。

示例

julia> isreal(5.)
true

julia> isreal(1 - 3im)
false

julia> isreal(Inf + 0im)
true

julia> isreal([4.; complex(0,1)])
false

Float32(x [, mode::RoundingMode])

从 x 创建一个 Float32。如果 x 不能被精确表示，则 mode 决定 x 的舍入方式。

示例

julia> Float32(1/3, RoundDown)
0.3333333f0

julia> Float32(1/3, RoundUp)
0.33333334f0

有关可用舍入模式，请参见 RoundingMode。

Float64(x [, mode::RoundingMode])

从 x 创建一个 Float64。如果 x 不能被精确表示，则 mode 决定 x 的舍入方式。

示例

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

有关可用舍入模式，请参见 RoundingMode。

rounding(T)

获取类型 T 的当前浮点数舍入模式，控制基本算术函数的舍入（+, -, *, / 和 sqrt）以及类型转换。

有关可用模式，请参见 RoundingMode。

setrounding(T, mode)

设置浮点类型 T 的舍入模式，控制基本算术函数的舍入（+, -, *, / 和 sqrt）以及类型转换。当使用非默认的 RoundNearest 舍入模式时，其他数值函数可能会给出不正确或无效的值。

请注意，目前仅支持 T == BigFloat。

setrounding(f::Function, T, mode)

在 f 的持续时间内更改浮点类型 T 的舍入模式。它在逻辑上等同于：

old = rounding(T)
setrounding(T, mode)
f()
setrounding(T, old)

有关可用舍入模式，请参见 RoundingMode。

get_zero_subnormals() -> Bool

如果对非标准浮点值（“非正规数”）的操作遵循 IEEE 算术规则，则返回 false；如果它们可能被转换为零，则返回 true。

set_zero_subnormals(yes::Bool) -> Bool

如果 yes 为 false，后续的浮点运算将遵循 IEEE 对于次正规值（“非正规数”）的算术规则。否则，浮点运算被允许（但不要求）将次正规输入或输出转换为零。除非 yes==true 但硬件不支持将次正规数归零，否则返回 true。

set_zero_subnormals(true) 可以加速某些硬件上的一些计算。然而，它可能会破坏诸如 (x-y==0) == (x==y) 的恒等式。

count_ones(x::Integer) -> Integer

x 的二进制表示中 1 的数量。

示例

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32

count_zeros(x::Integer) -> Integer

x 的二进制表示中零的数量。

示例

julia> count_zeros(Int32(2 ^ 16 - 1))
16

julia> count_zeros(-1)
0

leading_zeros(x::Integer) -> Integer

x 的二进制表示前导零的数量。

示例

julia> leading_zeros(Int32(1))
31

leading_ones(x::Integer) -> Integer

x 的二进制表示中前导的 1 的数量。

示例

julia> leading_ones(UInt32(2 ^ 32 - 2))
31

trailing_zeros(x::Integer) -> Integer

x 的二进制表示中尾随的零的数量。

示例

julia> trailing_zeros(2)
1

trailing_ones(x::Integer) -> Integer

x 的二进制表示中尾随的 1 的数量。

示例

julia> trailing_ones(3)
2

isodd(x::Number) -> Bool

如果 x 是一个奇数整数（即，不可被 2 整除的整数），则返回 true，否则返回 false。

示例

julia> isodd(9)
true

julia> isodd(10)
false

iseven(x::Number) -> Bool

如果 x 是一个偶数整数（即，可以被 2 整除的整数），则返回 true，否则返回 false。

示例

julia> iseven(9)
false

julia> iseven(10)
true

@int128_str str

将 str 解析为 Int128。如果字符串不是有效的整数，则抛出 ArgumentError。

示例

julia> int128"123456789123"
123456789123

julia> int128"123456789123.4"
ERROR: LoadError: ArgumentError: invalid base 10 digit '.' in "123456789123.4"
[...]

@uint128_str str

将 str 解析为 UInt128。如果字符串不是有效的整数，则抛出 ArgumentError。

示例

julia> uint128"123456789123"
0x00000000000000000000001cbe991a83

julia> uint128"-123456789123"
错误：LoadError: ArgumentError: 在 "-123456789123" 中的无效基数 10 数字 '-'
[...]

BigFloat(x::Union{Real, AbstractString} [, rounding::RoundingMode=rounding(BigFloat)]; [precision::Integer=precision(BigFloat)])

从 x 创建一个任意精度的浮点数，精度为 precision。rounding 参数指定如果转换不能精确完成，结果应朝哪个方向舍入。如果未提供，这些值将由当前全局值设置。

BigFloat(x::Real) 与 convert(BigFloat,x) 相同，除非 x 本身已经是 BigFloat，在这种情况下，它将返回一个精度设置为当前全局精度的值；convert 将始终返回 x。

BigFloat(x::AbstractString) 与 parse 相同。提供此功能是为了方便，因为在解析时十进制字面量会被转换为 Float64，因此 BigFloat(2.1) 可能不会产生您预期的结果。

另请参见：

• @big_str
• rounding 和 setrounding
• precision 和 setprecision

示例

julia> BigFloat(2.1) # 这里的 2.1 是 Float64
2.100000000000000088817841970012523233890533447265625

julia> BigFloat("2.1") # 最接近 2.1 的 BigFloat
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

julia> BigFloat("2.1", RoundUp)
2.100000000000000000000000000000000000000000000000000000000000000000000000000021

julia> BigFloat("2.1", RoundUp, precision=128)
2.100000000000000000000000000000000000007

precision(num::AbstractFloat; base::Integer=2)
precision(T::Type; base::Integer=2)

获取浮点数的精度，定义为有效数字的位数，或浮点类型 T 的精度（如果 T 是像 BigFloat 这样的可变精度类型，则为其当前默认值）。

如果指定了 base，则返回该基数下相应的最大有效数字位数。

setprecision([T=BigFloat,] precision::Int; base=2)

设置用于 T 算术的精度（默认为位数）。如果指定了 base，则精度是给定 base 中至少提供 precision 位所需的最小值。

setprecision(f::Function, [T=BigFloat,] precision::Integer; base=2)

在 f 的持续时间内更改 T 的算术精度（在给定的 base 中）。这在逻辑上等同于：

old = precision(BigFloat)
setprecision(BigFloat, precision)
f()
setprecision(BigFloat, old)

通常用作 setprecision(T, precision) do ... end

注意：nextfloat()、prevfloat() 不使用 setprecision 提到的精度。

BigInt(x)

创建一个任意精度的整数。x 可以是一个 Int（或任何可以转换为 Int 的东西）。对于这种类型，定义了通常的数学运算符，结果会提升为 BigInt。

可以通过 parse 从字符串构造实例，或使用 big 字符串字面量。

示例

julia> parse(BigInt, "42")
42

julia> big"313"
313

julia> BigInt(10)^19
10000000000000000000

@big_str str

将字符串解析为 BigInt 或 BigFloat，如果字符串不是有效的数字，则抛出 ArgumentError。对于整数，字符串中允许使用 _ 作为分隔符。

示例

julia> big"123_456"
123456

julia> big"7891.5"
7891.5

julia> big"_"
ERROR: ArgumentError: invalid number format _ for BigInt or BigFloat
[...]