Engee 文档

数字

标准数值类型

"Base"中"Number"所有子类型的类型树如下所示。 抽象类型被标记，其他类型是具体的。

Number  (Abstract Type)
├─ Complex
└─ Real  (Abstract Type)
   ├─ AbstractFloat  (Abstract Type)
   │  ├─ Float16
   │  ├─ Float32
   │  ├─ Float64
   │  └─ BigFloat
   ├─ Integer  (Abstract Type)
   │  ├─ Bool
   │  ├─ Signed  (Abstract Type)
   │  │  ├─ Int8
   │  │  ├─ Int16
   │  │  ├─ Int32
   │  │  ├─ Int64
   │  │  ├─ Int128
   │  │  └─ BigInt
   │  └─ Unsigned  (Abstract Type)
   │     ├─ UInt8
   │     ├─ UInt16
   │     ├─ UInt32
   │     ├─ UInt64
   │     └─ UInt128
   ├─ Rational
   └─ AbstractIrrational  (Abstract Type)
      └─ Irrational

抽象数字类型

Number

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

Real <: Number

所有实数的抽象超类型。

AbstractFloat <: Real

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

Integer <: Real

所有整数的抽象超类型（例如, '签名`, '未签名`和 'Bool'）。

另请参阅说明 'isinteger', '树干'和 'div'。

例子

julia> 42 isa Integer
true

julia> 1.0 isa Integer
false

julia> isinteger(1.0)
true
Signed <: Integer

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

Unsigned <: 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)其中 {F <: Union{BigFloat,Float32,Float64}}+.

如果子类型用于表示可以是理性的值（例如，对于整数`n`表示`√n`的平方根类型，如果`n`是一个完整的正方形，则会产生理性结果），那么它还必须实现’isinteger`，'iszero`，`isone’和'==' 'hash'等于相应的`Rational`的值。

特定数值类型

Float16 <: AbstractFloat <: Real

16位浮点数类型（IEEE754标准）。 二进制格式：符号的1位，指数的5位，小数部分的10位。

Float32 <: AbstractFloat <: Real

32位浮点数类型（IEEE754标准）。 二进制格式：符号的1位，指数的8位，小数部分的23位。

指数表示的指数应使用小写字母`f’输入，即'2f3===2.0f0*10^3===Float32(2_000)。 对于数组字面量和包含，元素类型可以在方括号之前指定’Float32[1,4,9]==Float32[i^2for i in1:3]。

另请参阅说明 'Inf32', 'NaN32', '浮16`, '指数', 'frexp'。

Float64 <: AbstractFloat <: Real

64位浮点数类型（IEEE754标准）。 二进制格式：符号的1位，指数的11位，小数部分的52位。 要访问各种位，请使用 'bitstring', '标志', '指数', 'frexp'和 '意义'。

默认情况下，它用于浮点文字'1.0isa 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', '南', 'floatmax', 'Float32`, '复杂'。

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', '虚假'和 'ifelse'。

Int8 <: Signed <: Integer

8位有符号整数类型。

表示数字’n∈-128:127'。 请注意，这样的整数在没有警告的情况下溢出，因此’typemax(Int8)+Int8(1)<0`。

另请参阅说明 'Int', `扩大'和 'BigInt'。

UInt8 <: Unsigned <: Integer

无符号的8位整数类型。

它以十六进制格式输出，即0x07==7。

Int16 <: Signed <: Integer

16位有符号整数类型。

表示数字’n∈-32768:32767'。 请注意，这样的整数在没有警告的情况下溢出，因此’typemax(Int16)+Int16(1)<0`。

另请参阅说明 'Int', `扩大'和 'BigInt'。

UInt16 <: Unsigned <: Integer

无符号的16位整数类型。

它以十六进制格式输出，即0x000f==15。

Int32 <: Signed <: Integer

32位有符号整数类型。

请注意，这样的整数在没有警告的情况下溢出，因此’typemax(Int32)+Int32(1)<0`。

另请参阅说明 'Int', `扩大'和 'BigInt'。

UInt32 <: Unsigned <: Integer

无符号32位整数类型。

它以十六进制格式输出，即0x0000001f==31。

Int64 <: Signed <: Integer

64位有符号整数类型。

请注意，这样的整数在没有警告的情况下溢出，因此’typemax(Int64)+Int64(1)<0`。

另请参阅说明 'Int', `扩大'和 'BigInt'。

UInt64 <: Unsigned <: Integer

无符号64位整数类型。

它以十六进制格式输出，即0x0000000000000003f==63。

Int128 <: Signed <: Integer

128位有符号整数类型。

请注意，这样的整数在没有警告的情况下溢出，因此’typemax(Int128)+Int128(1)<0`。

另请参阅说明 'Int', `扩大'和 'BigInt'。

UInt128 <: Unsigned <: Integer

无符号的128位整数类型。

它以十六进制格式输出，即0x000000000000000000000000000000007f==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_000isa Int128'

整数除法使用别名执行 'div''÷'，而 `/'，应用于整数，返回 'Float64'。

另请参阅说明 'Int64`, '扩大', '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},'复杂{Float32}`和'复杂{Float64}分别为。

另请参阅说明 '真实`, '复杂', '真实`。

Rational{T<:Integer} <: Real

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

Irrational{sym} <: AbstractIrrational

表示精确非理性值的数字类型，由符号`sym’表示，例如 π, ℯ'和 `γ.

另请参阅说明 '抽象'。

数据格式

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

返回一个元素类型为"T"（默认为"Int"）的数组，其中包含指定数字系统中的数字"n"，可选地填充指定大小的零。 较高阶的数字位于较高的索引处，使得'n==sum(digits[k]*base^(k-1)for k in each index(digits))'。

另请参阅说明 'ndigits', '数字！'，而对于基数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'和 '数字'。

例子

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)

将字符串分析为数字。 可以为"整数"类型设置基数（默认值为10）。 对于浮点类型，字符串被解析为十进制浮点数。 '复杂’类型从形式为`"R±Iim"`的十进制字符串分析为请求类型的`复杂（R，I）;`"i"`或`"j"`也可以用来代替`"im"。 此外，`"R"`或`"Iim"'是允许的。 如果字符串不包含有效数字，则会发生错误。

兼容性：Julia1.1

对于’parse（Bool，str）`需要至少1.1的Julia版本。

例子

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’被解释为颜色的名称，并根据`符号`转换为`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)

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

另请参阅说明 '未签名`, '标志', 'signbit'。

unsigned(T::Integer)

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

例子

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

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

另请参阅说明 '复杂', '类型', '转换'。

例子

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

julia> float(typemax(Int32))
2.147483647e9
significand(x)

提取有效数字（尾数）浮点数。 如果’x’是一个非零的有限数，那么结果将是一个相同类型和具有相同符号（作为`x`）的数字，其绝对值在范围内 . 否则，返回’x'。

另请参阅说明 'frexp'和 '指数'。

例子

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"为零、无穷大或 '南'。 对于任何其他非非正规浮点数’x`，这对应于指数`x’的位。

另请参阅说明 '标志', '意义', 'frexp', '非正常', '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'，它描述了反转。

兼容性：Julia1.7

使用生成`UInt8`值的迭代器调用`hex2bytes’需要Julia至少1.7的版本。 在早期版本中，您可以在调用`hex2bytes`之前对迭代器执行`collect'。

例子

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’长度的一半。

兼容性：Julia1.7

调用hex2bytes！ 随着迭代器产生UInt8，版本1.7是必需的。 在早期版本中，您可以在调用之前组装可迭代对象。

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

通过使用`bytes2hex(itr)`返回`String`或使用`bytes2hex(io,itr)`将字符串写入`io`流，将字节迭代器`itr`转换为其十六进制字符串表示形式。 十六进制字符以小写给出。

兼容性：Julia1.7

使用产生`UInt8`值的任意迭代器调用`bytes2hex’需要Julia至少1.7的版本。 在早期版本中，您可以在调用`bytes2hex`之前对迭代器执行`collect'。

例子

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`。

另请参阅功能说明 '身份'和`我’在 '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`的加法操作返回null元素（`x`也可以直接指定类型）。

另请参阅说明 'iszero`, '一`, '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', '角度', '复杂'。

例子

julia> im * im
-1 + 0im

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

常数"pi"。

Unicode字符’pi’可以通过键入`\pi`然后在REPL Julia以及许多其他编辑器中按TAB键来输入。

另请参阅说明 '辛皮', 'sincospi`, 'deg2rad`。

例子

julia> pi
π = 3.1415926535897...

朱莉娅>1/2pi
0.15915494309189535
ℯ
e

的常数△。

Unicode字符’ℯ’可以通过键入`\euler`然后在REPL Julia以及许多其他编辑器中按TAB键来输入。

另请参阅说明 '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', '南', 'Inf32'。

例子

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0
Inf, Inf64

型的正无穷大 'Float64'。

另请参阅说明 'isfinite', 'typemax', '南', 'Inf32'。

例子

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0
Inf32

型的正无穷大 'Float32'。

Inf16

型的正无穷大 'Float16'。

NaN, NaN64

值是类型的"不是数字" 'Float64'。

另请参阅说明 '伊斯南`, '失踪`, '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> reinterpret(UInt32, NaN32)
    0x7fc00000

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

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

值是类型的"不是数字" 'Float64'。

另请参阅说明 '伊斯南`, '失踪`, '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> reinterpret(UInt32, NaN32)
    0x7fc00000

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

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

值是类型的"不是数字" 'Float32'。

另请参阅说明 '南'。

NaN16

值是类型的"不是数字" 'Float16'。

另请参阅说明 '南'。

issubnormal(f) -> Bool

检查浮点数是否为非正规。

IEEE浮点数为https://en.wikipedia.org/wiki/Subnormal_number [subnormal]当指数的位为零且其有效数不为零时。

例子

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

检查数字的值是否属于"not a number"类型，这是一个既不是无穷大也不是有限数（"not a number"）的不定值。

另请参阅说明 'iszero`, 'isone`, 'isinf', 'ismissing'。

iszero(x)

返回’true’if’x==zero(x)如果’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)

返回’true’if’x==one(x)如果’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’迭代应用’nextfloat’到’x’的结果，如果’n>=0'，或-n’应用 `prevfloat'如果’n<0'。

nextfloat(x::AbstractFloat)

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

另请参阅说明 'prevfloat`, "eps", 'issubnormal'。

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

N`迭代应用’prevfloat’到’x’的结果，如果’n>=0'，或-n`应用 `nextfloat'如果’n<0'。

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’或其所有元素是否在数值上等于一些实数，包括无穷大和"非数字"类型。 如果`isequal(x,real(x))`等于true，则`isreal(x)'为true。

例子

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')和类型转换。 如果使用默认模式以外的舍入模式，则其他数值函数可能会给出不正确或无效的值。 '最圆的'。

请注意，此功能仅支持`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’的二进制表示中的单位数。

例子

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’的二进制表示中的初始单位数。

例子

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’的二进制表示中的有限单元的数量。

例子

julia> trailing_ones(3)
2
isodd(x::Number) -> Bool

如果`x’是奇数整数（即不能被2整除的整数），则返回`true`，否则返回`false`。

兼容性：Julia1.7

除"Integer"以外的参数要求Julia的版本至少为1.7。

例子

julia> isodd(9)
true

julia> isodd(10)
false
iseven(x::Number) -> Bool

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

兼容性：Julia1.7

除"Integer"以外的参数要求Julia的版本至少为1.7。

例子

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

朱莉娅>uint128"-123456789123"
错误：LoadError：ArgumentError：无效基数10位'-'in"-123456789123"
[...]

BigFloats和Bigint的数值类型

类别 BigFloat'和 'BigInt'分别实现任意精度浮点算术和整数算术。 为 'BigFloat正在使用中https://www.mpfr.org /[GNU MPFR库]，并为 'BigInt'--https://gmplib.org [GNU多精度算术库（GMP）]。

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

创建一个基于"x"的任意精度浮点数，精度为"精度"。 如果无法准确执行转换，则"舍入"参数指示结果的舍入方向。 如果未设置，则应用当前全局值。

'BigFloat(x::Real)'--与`convert(BigFloat,x)`相同，除非`x`已经是`BigFloat'。 在这种情况下，返回精度等于当前全局精度的值;'convert’总是返回’x'。

'BigFloat(x::AbstractString)'是相同的 '解析'。 提供此函数是为了方便，因为十进制文字在分析期间转换为`Float64`，因此`BigFloat(2.1)'可能不会产生预期的结果。

另请参阅说明

兼容性：Julia1.1

命名参数"precision"要求Julia版本至少为1.1。 在Julia1.0中，'precision’是第二个位置参数(`BigFloat(x,precision)')。

例子

julia> BigFloat(2.1) # 2.1 здесь является Float64
2.100000000000000088817841970012523233890533447265625

julia> BigFloat("2.1") # самый близкий BigFloat для 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'）。

如果设置了"基数"，则返回该基数的有效部分的最大对应位数。

兼容性：Julia1.8

命名的"base"参数需要至少1.8的Julia版本。

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

指定用于与`T’进行算术运算的精度（默认情况下，以位为单位）。 如果设置了"base"，则精度将是为该"base"输出至少"precision"数字所需的最小值。

此函数不是线程安全的。 它会影响在所有线程中执行的代码，但如果它与使用参数的计算同时调用，则其行为未定义。
兼容性：Julia1.8

命名的’base’参数需要至少1.8的Julia版本。

 
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)'。.. 结束`

注意。 'nextfloat()`,`prevfloat()`不使用’setprecision’中指定的精度。

兼容性：Julia1.8

命名的"base"参数需要至少1.8的Julia版本。

 
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
[...]

使用'@big_str’创建值时 BigFloat'行为可能与自然预期的不同：作为宏，'@big_str’考虑到全局精度设置（'setprecision')和舍入模式(`setting')，在_启动时设置。 因此，像+()→precision(big"0.3")+`这样的函数返回一个常量，其值取决于函数定义时的精度值，而*不是*调用时。