数字
标准数值类型
所有子类型的类型树 电话号码 在 基地 如下所示。 抽象类型已被标记，其余为具体类型。
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
抽象数字类型
# *`核心。未签名`*-类型
Unsigned <: Integer所有无符号整数的抽象超类型。
内置无符号整数以十六进制打印，带有前缀 0x，并且可以以相同的方式输入。
*例子*
julia> typemax(UInt8)
0xff
julia> Int(0x00d)
13
julia> unsigned(true)
0x0000000000000001# *`基地。抽象的,抽象的`*-类型
AbstractIrrational <: Real数字类型表示一个精确的非理性值，它在与其他数字量的算术运算中自动舍入到正确的精度。
亚型 MyIrrational<:抽象的 应实施至少 ==(::MyIrrational,::MyIrrational), 哈希(x::MyIrrational,h::UInt)，而 转换(::类型{F},x::MyIrrational)其中 {F <: Union{BigFloat,Float32,Float64}}.
如果子类型用于表示偶尔可能是合理的值（例如表示的平方根类型 √n 对于整数 n 会给出一个理性的结果时 n 是一个完美的正方形），那么它也应该实现 伊辛特格, 伊泽罗, 伊松，而 == 与 真实的 值（因为所有这些都默认为 错误 为 抽象的,抽象的 类型），以及定义 哈希等于相应的 理性的.
混凝土编号类型
# *`核心。漂浮64`*-类型
Float64 <: AbstractFloat <: Real这是浮点文字的默认值, 1.0isa Float64，并为许多操作，如 1/2,2pi,log(2),范围(0,90,长度=4). 与整数不同，此默认值不会随 系统。字_大小.
科学记数法的指数可以输入为 e 或 E，因此 2e3===2.0E3===2.0*10^3. 这样做是强烈优先于 10^n 由于整数溢出，因此 2.0 * 10^19 < 0 但是 2e19＞0.
# *`核心。布尔`*-类型
Bool <: Integer布尔类型，包含值 真的 和 错误.
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)经 如果和其他条件只接受 布尔. 朱莉娅没有"真实"的价值观。
比较通常返回 布尔，并且广播比较可能会返回 比特阵列而不是一个 数组{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# *`核心。UInt128`*-类型
UInt128 <: Unsigned <: Integer128位无符号整数类型。
以十六进制打印，因此0x0000000000000000000000000000007f==127。
数据格式
# *`基地。数字`*-函数
digits([T<:Integer], n::Integer; base::T = 10, pad::Integer = 1)返回元素类型的数组 T （默认 Int型)的数字 n 在给定的基础上，可选地用零填充到指定的大小。 更多的有效数字位于更高的指数，这样 n==sum(digits[k]*base^(k-1)for k in1:length(digits)).
*例子*
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# *`基地。解析,解析`*-函数
parse(::Type{SimpleColor}, rgb::String)的类似物 tryparse（SimpleColor，rgb::String） （见），这引发了一个错误，而不是返回 什么都没有.
parse(::Type{Platform}, triplet::AbstractString)将一个字符串平台三元组解析回一个 平台 对象。
parse(type, str; base)将字符串解析为数字。 为 整数 类型，可以指定一个base（默认为10）。 对于浮点类型，字符串被解析为十进制浮点数。 综合体 类型从形式的十进制字符串解析 "R±Iim" 作为一个 复杂(R,I) 所要求的类型; "我" 或 "j" 也可以用来代替 "我"，而 "R" 或 "我" 也是允许的。 如果字符串不包含有效数字，则会引发错误。
|
兼容性
朱莉娅1.1 |
*例子*
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,rgb 作为一个 [医]单纯色. 如果 rgb,rgb 开始于 # 并具有7的长度，它被转换成一个 [医]研资局-支持 [医]单纯色. 如果 rgb,rgb 开始于 a-z, rgb,rgb 被解释为颜色名称并转换为 符号-支持 [医]单纯色.
否则的话, 什么都没有 被退回。
*例子*
julia> tryparse(SimpleColor, "blue")
SimpleColor(blue)
julia> tryparse(SimpleColor, "#9558b2")
SimpleColor(#9558b2)
julia> tryparse(SimpleColor, "#nocolor")tryparse(type, str; base)# *`基地。未签名`*-函数
unsigned(T::Integer)将整数bitstype转换为相同大小的无符号类型。
*例子*
julia> unsigned(Int16)
UInt16
julia> unsigned(UInt64)
UInt64# *`基地。数学。n.意义,意义`*-函数
significand(x)提取浮点数的有效数(a.k.a.尾数). 如果 x 是一个非零的有限数，那么结果将是一个相同类型和符号的数字 x，且其绝对值在区间上 . 否则的话 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::Real) -> Int返回最大整数 y 这样， 2^y≤abs(x). 对于归一化浮点数 x，这对应于指数 x.
抛出一个 N.域名,域名 何时 x 是零，无限，或 南. 对于任何其他非非正规浮点数 x，这对应于指数位 x.
*例子*
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.
[...]# *`基地。综合体`*-Method
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# *`基地。hex2bytes`*-函数
hex2bytes(itr)给定一个可迭代 itr 对于十六进制数字序列的ASCII码，返回一个 向量{UInt8} 对应于二进制表示的字节：每个连续的十六进制数字对 itr 给出返回向量中一个字节的值。
的长度 itr 必须是偶数，返回的数组长度为 itr. 请参阅 hex2bytes！对于就地版本，以及 字节2hex为逆。
|
兼容性
朱莉娅1.7呼叫 |
*例子*
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# *`基地。字节2hex`*-函数
bytes2hex(itr) -> String
bytes2hex(io::IO, itr)转换迭代器 itr 字节到它的十六进制字符串表示形式，或者返回一个 字符串 经 字节2hex(itr) 或者将字符串写入 伊俄 经流经 bytes2hex（io，itr）. 十六进制字符均为小写。
|
兼容性
朱莉娅1.7呼叫 |
*例子*
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：这样的值 一(x)*x==x*一(x)==x. 如果乘性身份可以从单独的类型推导出来，那么一个类型可以作为一个参数给出 一个 （例如 一(Int) 将工作，因为乘法身份是相同的所有实例 Int型，但是 一个（矩阵{Int}) 没有定义，因为不同形状的矩阵具有不同的乘法身份。)
如果可能的话, 一(x) 返回与以下类型相同的值 x，而 一(T) 返回类型的值 T. 但是，对于表示维度量的类型（例如以天为单位的时间），情况可能并非如此，因为乘法身份必须是无量纲的。 那样的话, 一(x) 应该返回一个相同精度（和形状，对于矩阵）的标识值 x.
如果你想要一个与……类型相同的数量。 x，或类型 T，即使 x 是有尺寸的，使用 一个单位代替。
*例子*
julia> one(3.7)
1.0
julia> one(Int)
1
julia> import Dates; one(Dates.Day(1))
1# *`基地。零`*-函数
zero(x)
zero(::Type)获取additive identity元素 x. 如果加性标识可以单独从类型中推导出来，那么可以给出一个类型作为参数 零.
例如, 零(Int) 将工作，因为添加剂标识是相同的所有实例 Int型，但是 零（矢量{Int}) 没有定义，因为不同长度的向量具有不同的加性身份。
*例子*
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# *`基地。数学专家。加泰罗尼亚语`*-注册_
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# *`基地。[医]正常`*-函数
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# *`基地。伊松`*-函数
isone(x)回来吧 真的 如果 x==一(x);如果 x 是一个数组，这检查是否 x 是单位矩阵。
*例子*
julia> isone(1.0)
true
julia> isone([1 0; 0 2])
false
julia> isone([1 0; 0 true])
true# *`基地。伊斯雷亚尔`*-函数
isreal(x) -> Bool测试是否 x 或者它的所有元素在数值上等于一些实数，包括无穷大和NaNs。 isreal(x) 如果是真的 等距(x,真实(x)) 是真的。
*例子*
julia> isreal(5.)
true
julia> isreal(1 - 3im)
false
julia> isreal(Inf + 0im)
true
julia> isreal([4.; complex(0,1)])
false# *`基地。四舍五入。get_zero_subnormals`*-函数
get_zero_subnormals() -> Bool回来吧 错误 如果对非正规浮点值（"非正规值"）的操作遵守IEEE算术规则，并且 真的 如果它们可能被转换为零。
|
警告此函数仅影响当前线程。 |
# *`基地。四舍五入。set_zero_subnormals`*-函数
set_zero_subnormals(yes::Bool) -> Bool如果 是的 是 错误，随后的浮点运算遵循关于非正规值（"非正规值"）的IEEE算术规则。 否则，允许浮点运算（但不是必需的）将非正规输入或输出转换为零。 申报表 真的 除非 是==真 但硬件不支持非正规数的归零。
set_zero_subnormals(true) 可以加快一些硬件上的一些计算。 但是，它可以打破身份，例如 (x-y==0)==(x==y).
|
警告此函数仅影响当前线程。 |
整数
# *`基地。n.计数,计数`*-函数
count_ones(x::Integer) -> Integer二进制表示中的一个数 x.
*例子*
julia> count_ones(7)
3
julia> count_ones(Int32(-1))
32# *`基地。n.计数,计数`*-函数
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_泽罗斯`*-函数
trailing_zeros(x::Integer) -> Integer二进制表示后面的零个数 x.
*例子*
julia> trailing_zeros(2)
1# *`基地。[医]跟踪`*-函数
trailing_ones(x::Integer) -> Integer的二进制表示形式后面的一个数 x.
*例子*
julia> trailing_ones(3)
2# *`基地。isodd`*-函数
isodd(x::Number) -> Bool回来吧 真的 如果 x 是奇数整数（即不能被2整除的整数），并且 错误 否则。
|
兼容性
朱莉娅1.7非- |
*例子*
julia> isodd(9)
true
julia> isodd(10)
false# *`基地。伊塞文`*-函数
iseven(x::Number) -> Bool回来吧 真的 如果 x 是偶数整数（即可被2整除的整数），并且 错误 否则。
|
兼容性
朱莉娅1.7非- |
*例子*
julia> iseven(9)
false
julia> iseven(10)
true大块头和大块头
该 [医大块头]和 比金特类型分别实现任意精度浮点和整数算术。 为 [医大块头]的https://www.mpfr.org/[GNU MPFR库]使用，并为 比金特[GNU多精度算术库(GMP)(https://gmplib.org)被使用。
# *`基地。MPFR。[医]大块头`*-Method
BigFloat(x::Union{Real, AbstractString} [, rounding::RoundingMode=rounding(BigFloat)]; [precision::Integer=precision(BigFloat)])从创建任意精度浮点数 x，精度 精密度. 该 四舍五入 参数指定如果转换不能准确完成，结果应该舍入的方向。 如果未提供，则由当前全局值设置。
BigFloat(X::真实) 是一样的 转换(BigFloat,x)，除非 x 本身已经 [医]大块头，在这种情况下，它将返回一个精度设置为当前全局精度的值; 转换/转换 总会回来的 x.
BigFloat(x::AbstractString) 是相同的 解析,解析. 这是为了方便起见，因为十进制文字被转换为 漂浮64 当解析，所以 大浮(2.1) 可能不会产生你所期望的。
请参阅:
|
兼容性
朱莉娅1.1 |
*例子*
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# *`基地。MPFR。精确的,精确的`*-函数
setprecision(f::Function, [T=BigFloat,] precision::Integer; base=2)更改 T 算术精度（在给定的 基地）的持续时间 f. 它在逻辑上等同于:
old = precision(BigFloat)
setprecision(BigFloat, precision)
f()
setprecision(BigFloat, old)常用作 setprecision(T,precision)做... 结束
注意事项: 下一个(), 普雷弗洛特() 不要使用由 精确的,精确的.
|
警告此方法有一个回退实现，它调用 |
|
兼容性
朱莉娅1.8 |
setprecision([T=BigFloat,] precision::Int; base=2)设置要用于的精度（默认情况下，以位为单位） T 算术。 如果 基地 被指定，那么精度是至少给出所需的最小值 精密度 给定的数字 基地.
|
警告此函数不是线程安全的。 它将影响在所有线程上运行的代码，但如果与使用该设置的计算同时调用，则其行为未定义。 |
|
兼容性
朱莉娅1.8 |
# *`核心。@big_str`*-马科罗_
@big_str str*例子*
julia> big"123_456"
123456
julia> big"7891.5"
7891.5
julia> big"_"
ERROR: ArgumentError: invalid number format _ for BigInt or BigFloat
[...]