Julia1.4文档 —— 2. Julia的基本数值类型

整数和浮点数是算术和计算的基础。它们都是数字文本。例如 1 是整数文本， 1.0 是浮点数文本。

Julia 提供了丰富的基础数值类型，全部的算数运算符和位运算符，以及标准数学函数。这些数据和操作直接对应于现代计算机支持的操作。因此, Julia 能充分利用硬件的计算资源。另外, Julia 还从软件层面支持任意精度的算术，可以用于表示硬件不能原生支持的数值，当然，这牺牲了部分运算效率。

另外, 对复数和分数的支持建立在这些基础数据类型之上。所有的基础数据类型通过灵活用户可扩展的类型提升系统不需显式类型转换，就可以互相运算。

整数类型

类型	有符号	位数	最小值	最大值
Int8	✓	8	-2^7	2^7 - 1
UInt8		8	0	2^8 - 1
Int16	✓	16	-2^15	2^15 - 1
UInt16		16	0	2^16 - 1
Int32	✓	32	-2^31	2^31 - 1
UInt32		32	0	2^32 - 1
Int64	✓	64	-2^63	2^63 - 1
UInt64		64	0	2^64 - 1
Int128	✓	128	-2^127	2^127 - 1
UInt128		128	0	2^128 - 1
Bool	N/A	8	false (0)	true (1)

使用标准方式来表示文本化的整数：

julia> 1
1julia> 1234
1234

整数文本的默认类型，取决于目标系统是 32 位架构还是 64 位架构：

julia> typeof(1)
Int64# 通过 Sys.WORD_SIZE 来查看系统是32位还是64位
julia> Sys.WORD_SIZE
64

另外，Julia 定义了 Int 和 UInt类型，它们分别是系统原生的有符号和无符号整数类型的别名：

julia> Int
Int64julia> UInt
UInt64

对于不能用 32 位而只能用 64 位来表示的大整数文本，不管系统类型是什么，始终被认为是 64 位整数：

julia> typeof(3000000000)
Int64

无符号整数的输入和输出使用前缀 0x 和十六进制数字 0-9a-f （也可以使用 A-F ）。无符号数的位数大小，由十六进制数的位数决定：

julia> 0x1
0x01julia> typeof(ans)
UInt8julia> 0x123
0x0123julia> typeof(ans)
UInt16julia> 0x1234567
0x01234567julia> typeof(ans)
UInt32julia> 0x123456789abcdef
0x0123456789abcdefjulia> typeof(ans)
UInt64

二进制和八进制文本：

julia> 0b10
0x02julia> typeof(ans)
UInt8julia> 0o10
0x08julia> typeof(ans)
UInt8

基础数值类型的最小值和最大值，可由 typemin 和 typemax 函数查询：

julia> (typemin(Int32), typemax(Int32))
(-2147483648, 2147483647)julia> for T in [Int8,Int16,Int32,Int64,Int128,UInt8,UInt16,UInt32,UInt64,UInt128]println("$(lpad(T,7)): [$(typemin(T)),$(typemax(T))]")endInt8: [-128,127]Int16: [-32768,32767]Int32: [-2147483648,2147483647]Int64: [-9223372036854775808,9223372036854775807]Int128: [-170141183460469231731687303715884105728,170141183460469231731687303715884105727]UInt8: [0,255]UInt16: [0,65535]UInt32: [0,4294967295]UInt64: [0,18446744073709551615]
UInt128: [0,340282366920938463463374607431768211455]

typemin 和 typemax 的返回值，与所给的参数类型是同一类的。

溢出
在 Julia 中，如果计算结果超出数据类型所能代表的最大值，将会发生溢出：

julia> x = typemax(Int64)
9223372036854775807julia> x + 1
-9223372036854775808julia> x + 1 == typemin(Int64)
true

可见, Julia 中的算数运算其实是一种同余算术。它反映了现代计算机底层整数算术运算特性。如果有可能发生溢出，一定要显式的检查是否溢出；或者使用 BigInt 类型（详见任意精度的算术）。

为了减小溢出所带来的影响，整数加减法、乘法、指数运算都会把原先范围较小的整数类型提升到 Int 或 UInt 类型。（除法、求余、位运算则不提升类型）。

除法错误

整数除法（div 功能）有两个额外的样例：被 0 除，和被最低的负数（typemin）-1 除。两个例子都抛出了一个 DivideError。余数和模运算（rem 和 mod）当它们的第二个参数为 0 时，抛出了一个 DivideError。

浮点数类型

类型	精度	位数
`Float16`	半精度	16
`Float32`	单精度	32
`Float64`	双精度	64

使用标准格式来表示文本化的浮点数：

julia> 1.0
1.0julia> 1.
1.0julia> 0.5
0.5julia> .5
0.5julia> -1.23
-1.23julia> 1e10
1.0e10julia> 2.5e-4
0.00025

上述结果均为 Float64 值。文本化的 Float32 值也可以直接输入，这时使用 f 来替代 e ：

julia> 0.5f0
0.5f0julia> typeof(ans)
Float32julia> 2.5f-4
0.00025f0

浮点数也可以很容易地转换为 Float32 ：

julia> Float32(-1.5)
-1.5f0julia> typeof(ans)
Float32

十六进制浮点数的类型，只能为 Float64 ：

julia> 0x1p0
1.0julia> 0x1.8p3
12.0julia> 0x.4p-1
0.125julia> typeof(ans)
Float64

Julia 也支持半精度浮点数(Float16) ，但只用来存储。计算时，它们被转换为Float32 ：：

julia> sizeof(Float16(4.))
2julia> 2 * Float16(4.)
Float16(8.0)julia> typeof(ans)
Float16

下划线'_'可以用来作为数字位数之间的分隔符：

julia> 10_000, 0.000_000_005, 0xdead_beef, 0b1011_0010
(10000, 5.0e-9, 0xdeadbeef, 0xb2)

浮点数类型的零

浮点数类型中存在两个零，正数的零和负数的零。它们相等，但有着不同的二进制表示，可以使用 bitstring() 函数看出：

julia> 0.0 == -0.0
truejulia> bitstring(0.0)
"0000000000000000000000000000000000000000000000000000000000000000"julia> bitstring(-0.0)
"1000000000000000000000000000000000000000000000000000000000000000"

特殊的浮点数

有三个特殊的标准浮点数：

Float16	Float32	Float64	名称	描述
Inf16	Inft32	Inf	正无穷	比所有的有限的浮点数都大
-Inf16	-Inft32	-Inf	负无穷	比所有的有限的浮点数都小
NaN16	NaN32	NaN	不存在	不能和任意浮点数比较大小（包括它自己）

详见数值比较。按照 IEEE 754 标准，这几个值可如下获得：

julia> 1/Inf
0.0julia> 1/0
Infjulia> -5/0
-Infjulia> 0.000001/0
Infjulia> 0/0
NaNjulia> 500 + Inf
Infjulia> 500 - Inf
-Infjulia> Inf + Inf
Infjulia> Inf - Inf
NaNjulia> Inf * Inf
Infjulia> Inf / Inf
NaNjulia> 0 * Inf
NaN

typemin 和 typemax 函数也适用于浮点数类型：

julia> (typemin(Float16),typemax(Float16))
(-Inf16, Inf16)julia> (typemin(Float32),typemax(Float32))
(-Inf32, Inf32)julia> (typemin(Float64),typemax(Float64))
(-Inf, Inf)

精度

大多数的实数并不能用浮点数精确表示，因此有必要知道两个相邻浮点数间的间距，也即计算机的精度。

Julia 提供了 eps 函数，可以用来检查 1.0 和下一个可表示的浮点数之间的间距：

julia> eps(Float32)
1.1920929f-7julia> eps(Float64)
2.220446049250313e-16julia> eps() # same as eps(Float64)
2.220446049250313e-16

eps 函数也可以取浮点数作为参数，给出这个值和下一个可表示的浮点数的绝对差，即，eps(x) 的结果与 x同类型，且满足x + eps(x) 是下一个比 x稍大的、可表示的浮点数：

julia> eps(1.0)
2.220446049250313e-16julia> eps(1000.)
1.1368683772161603e-13julia> eps(1e-27)
1.793662034335766e-43julia> eps(0.0)
5.0e-324

相邻的两个浮点数之间的距离并不是固定的，数值越小，间距越小；数值越大, 间距越大。换句话说，浮点数在0附近最稠密，随着数值越来越大，数值越来越稀疏，数值间的距离呈指数增长。根据定义， eps(1.0) 与 eps(Float64) 相同，因为 1.0 是 64 位浮点数。

函数 nextfloat 和 prevfloat 可以用来获取下一个或上一个浮点数：

julia> x = 1.25f0
1.25f0julia> nextfloat(x)
1.2500001f0julia> prevfloat(x)
1.2499999f0julia> bitstring(prevfloat(x))
"00111111100111111111111111111111"julia> bitstring(x)
"00111111101000000000000000000000"julia> bitstring(nextfloat(x))
"00111111101000000000000000000001"

此例显示了邻接的浮点数和它们的二进制整数的表示。

舍入模型

如果一个数没有精确的浮点数表示，那就需要舍入了。可以根据 IEEE 754 标准来更改舍入的模型：

julia> 1.1 + 0.1
1.2000000000000002

默认舍入模型为 RoundNearest ，它舍入到最近的可表示的值，这个被舍入的值使用尽量少的有效数字。

背景和参考资料

浮点数的算术运算同人们的预期存在着许多差异，特别是对不了解底层实现的人。许多科学计算的书籍都会详细的解释这些差异。下面是一些参考资料：

关于浮点数算数运算最权威的指南是 IEEE 754-2008 标准；然而，该指南没有免费的网络版
一个简短但是清晰地解释了浮点数是怎么表示的, 请参考 John D. Cook 的文章。它还简述了由于浮点- 数的表示方法不同于理想的实数会带来怎样的问题
推荐 Bruce Dawson 的关于浮点数的博客
David Goldberg 的每个计算机科学家都需要了解的浮点数算术计算，是一篇非常精彩的文章，深入讨论了浮点数和浮点数的精度问题
更深入的文档, 请参考“浮点数之父” William Kahan 的 collected writings ，其中详细记录了浮点数的历史、理论依据、问题，还有其它很多的数值计算方面的内容。更有兴趣的可以读采访浮点数之父

任意精度的算术

为保证整数和浮点数计算的精度，Julia 打包了 GNU Multiple Precision Arithmetic Library(GMP) 和 GNU MPFR Library。Julia 相应提供了 BigInt 和 BigFloat 类型。

可以通过基础数值类型或 String 类型来构造：

julia> BigInt(typemax(Int64)) + 1
9223372036854775808julia> big"123456789012345678901234567890" + 1
123456789012345678901234567891julia> parse(BigInt, "123456789012345678901234567890") + 1
123456789012345678901234567891julia> big"1.23456789012345678901"
1.234567890123456789010000000000000000000000000000000000000000000000000000000004julia> parse(BigFloat, "1.23456789012345678901")
1.234567890123456789010000000000000000000000000000000000000000000000000000000004julia> BigFloat(2.0^66) / 3
2.459565876494606882133333333333333333333333333333333333333333333333333333333344e+19julia> factorial(BigInt(40))
815915283247897734345611269596115894272000000000

然而，基础数据类型和 BigInt/BigFloat 不能自动进行类型转换，需要明确指定：

julia> x = typemin(Int64)
-9223372036854775808julia> x = x - 1
9223372036854775807julia> typeof(x)
Int64julia> y = BigInt(typemin(Int64))
-9223372036854775808julia> y = y - 1
-9223372036854775809julia> typeof(y)
BigInt

BigFloat 运算的默认精度（有效数字的位数）和舍入模型，是可以改的。然后，计算就都按照更改之后的设置来运行了：

julia> setrounding(BigFloat, RoundUp) doBigFloat(1) + parse(BigFloat, "0.1")end
1.100000000000000000000000000000000000000000000000000000000000000000000000000003julia> setrounding(BigFloat, RoundDown) doBigFloat(1) + parse(BigFloat, "0.1")end
1.099999999999999999999999999999999999999999999999999999999999999999999999999986julia> setprecision(40) doBigFloat(1) + parse(BigFloat, "0.1")end
1.1000000000004

代数系数

Julia 允许在变量前紧跟着数值文本，来表示乘法。这有助于写多项式表达式：

julia> x = 3
3julia> 2x^2 - 3x + 1
10julia> 1.5x^2 - .5x + 1
13.0

指数函数也更好看：

julia> 2^2x
64

数值文本系数同单目运算符一样。因此 2^3x 被解析为 2^(3x)，2x^3被解析为 2*(x^3) 。

数值文本也可以作为括号表达式的因子：

julia> 2(x-1)^2 - 3(x-1) + 1
3

括号表达式可作为变量的因子：

julia> (x-1)x
6

不要接着写两个变量括号表达式，也不要把变量放在括号表达式之前。它们不能被用来指代乘法运算：

julia> (x-1)(x+1)
ERROR: MethodError: objects of type Int64 are not callable
Stacktrace:[1] top-level scope at REPL[149]:1julia> x(x+1)
ERROR: MethodError: objects of type Int64 are not callable
Stacktrace:[1] top-level scope at REPL[150]:1

这两个表达式都被解析为函数调用：任何非数值文本的表达式，如果后面跟着括号，代表调用函数来处理括号内的数值（详见函数）。因此，由于左面的值不是函数，这两个例子都出错了。

需要注意，代数因子和变量或括号表达式之间不能有空格。

语法冲突

文本因子与两个数值表达式语法冲突: 十六进制整数文本和浮点数文本的科学计数法：

十六进制整数文本表达式 0xff 可以被解析为数值文本 0 乘以变量 xff
浮点数文本表达式 1e10 可以被解析为数值文本 1 乘以变量 e10 。E 格式也同样。

这两种情况下，我们都把表达式解析为数值文本：

以 0x 开头的表达式，都被解析为十六进制文本
以数字文本开头，后面跟着 e 或 E ，都被解析为浮点数文本

零和一

Julia 提供了一些函数, 用以得到特定数据类型的零和一文本。

函数	说明
`zero(x)`	类型 `x` 或变量 `x` 的类型下的文本零
`one(x)`	类型 `x` 或变量 `x` 的类型下的文本一

这俩函数在数值比较中可用来避免额外的类型转换。
例如：

julia> zero(Float32)
0.0f0julia> zero(1.0)
0.0julia> one(Int32)
1julia> one(BigFloat)
1.0