数字

Number

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

Real <: Number

所有实数的抽象超类型。

AbstractFloat <: Real

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

Integer <: Real

所有整数的抽象超类型。

Signed <: Integer

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

Unsigned <: Integer

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

AbstractIrrational <: Real

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

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

如果子类型用于表示可能偶尔是有理数的值（例如，表示整数 n 的平方根类型的 √n 当 n 是完全平方时会给出有理数结果），那么它还应实现 isinteger、iszero、isone 和 == 以及 Real 值（因为所有这些对于 AbstractIrrational 类型默认为 false），以及定义 hash 等于相应的 Rational。

Float16 <: AbstractFloat

16 位浮点数类型（IEEE 754 标准）。

二进制格式：1 位符号位、5 位指数位、10 位尾数位。

Float32 <: AbstractFloat

32 位浮点数类型（IEEE 754 标准）。

二进制格式：1 位符号位、8 位指数位、23 位尾数位。

Float64 <: AbstractFloat

64 位浮点数类型（IEEE 754 标准）。

二进制格式：1 位符号位、11 位指数位、52 位尾数位。

BigFloat <: AbstractFloat

任意精度浮点数类型。

Bool <: Integer

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

Bool 是一种数字：false 在数值上等于 0，而 true 在数值上等于 1。此外，false 充当乘法“强零”。

julia> false == 0
true

julia> true == 1
true

julia> 0 * NaN
NaN

julia> false * NaN
0.0

另请参阅：digits、iszero、NaN。

Int8 <: Signed

8 位带符号整数类型。

UInt8 <: Unsigned

8 位无符号整数类型。

Int16 <: Signed

16 位带符号整数类型。

UInt16 <: Unsigned

16 位无符号整数类型。

Int32 <: Signed

32 位带符号整数类型。

UInt32 <: Unsigned

32 位无符号整数类型。

Int64 <: Signed

64 位带符号整数类型。

UInt64 <: Unsigned

64 位无符号整数类型。

Int128 <: Signed

128 位带符号整数类型。

UInt128 <: Unsigned

128 位无符号整数类型。

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=1:length(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{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, 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。

示例

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) -> Int

返回最大的整数 y，使得 2^y ≤ abs(x)。对于归一化的浮点数 x，这对应于 x 的指数。

示例

julia> exponent(8)
3

julia> exponent(64//1)
6

julia> exponent(6.5)
2

julia> exponent(16.0)
4

julia> exponent(3.142e-4)
-12

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)

给定一个十六进制数字序列的 ASCII 代码的可迭代对象 itr，返回一个 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 函数，以及 LinearAlgebra 中的 I 以获取单位矩阵。

示例

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。

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

另请参阅：sinpi、sincospi、deg2rad。

示例

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

ℯ
e

常数 ℯ。

在 Julia REPL 和许多编辑器中，可以通过键入 \euler 然后按 Tab 键入 Unicode ℯ。

另请参阅：exp、cis、cispi。

示例

julia> ℯ
ℯ = 2.7182818284590...

julia> log(ℯ)
1

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

catalan

卡塔兰常数。

示例

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

φ
golden

黄金分割率。

示例

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), NaN === NaN
(false, true, true)

NaN, NaN64

类型为 Float64 的非数字值。

另请参阅：isnan、missing、NaN32、Inf。

示例

julia> 0/0
NaN

julia> Inf - Inf
NaN

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

NaN32

类型为 Float32 的非数字值。

NaN16

类型为 Float16 的非数字值。

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 应用 nextfloat 函数 n 次的结果；如果 n < 0，则表示对 x 应用 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 应用 prevfloat 函数 n 次的结果；如果 n < 0，则表示对 x 应用 nextfloat 函数 -n 次的结果。

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 的二进制表示形式中 0 的数量。

示例

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

julia> count_zeros(-1)
0

leading_zeros(x::Integer) -> Integer

x 的二进制表示形式前导 0 的数量。

示例

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 的二进制表示形式尾随 0 的数量。

示例

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"
ERROR: LoadError: ArgumentError: invalid base 10 digit '-' in "-123456789123"
[...]

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 here is a Float64
2.100000000000000088817841970012523233890533447265625

julia> BigFloat("2.1") # the closest BigFloat to 2.1
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
[...]