Julia 数组

数组，就是相同数据类型的元素按一定顺序排列的集合，可以是一维数组和多维数组。

Julia 支持数组数据结构，它可以存储一个大小不是固定的，类型可以相同也可以不同的顺序集合。

Julia 数组是可变类型集合，用于列表、向量、表格和矩阵。

Julia 数组的索引键值可以使用整数表示，数组的大小不是固定的。

Julia 提供了很多函数帮助我们来操作数组，比如数组添加元素，合并数组等。

Julia 数组用方括号 [...] 指定，多个元素使用逗号 , 分隔。

创建一个一维数组(即一个向量)语法为:

[A, B, C, ...]

创建一维数组

下面实例创建了一个简单的一维数组：

实例

julia> arr = [1,2,3]
3-element Vector{Int64}:
1
2
3

上面的实例中我们创建了一个包含 3 个元素的一维数组，每个元素都是一个 64 位整数，这个一维数组绑定到变量 arr 中。

数组元素的类型也可以不一样：

实例

julia> arr =[1, "RUNOOB", 2.5, pi]
4-element Vector{Any}:
1
"RUNOOB"
2.5
π = 3.1415926535897...

上面的实例中我们创建了一个包含 4 个元素不同类型的一维数组， pi 是常量 π，每个元素都是一个 64 位整数，这个一维数组绑定到变量 arr 中。

当然也可以强制指定类型：

实例

julia> arr = Int64[1,2,3]
3-element Vector{Int64}:
1
2
3
julia> arr2 = String["Taobao","RUNOOB","GOOGLE"]
3-element Vector{String}:
"Taobao"
"RUNOOB"
"GOOGLE"

以上实例数组 arr 限制只能输入整数，arr2 限制只能输入字符串。

我们也可以创建一个空数组：

实例

julia> arr = Int64[]
Int64[]

julia> arr2 = String[]
String[]

创建的数组可以直接使用索引值来访问，第一个值的索引为 1（不是 0），第二个值索引为 2，以此类推，最后一个可以使用 end 表示：

实例

julia> arr = Int64[1,2,3]
3-element Vector{Int64}:
1
2
3

julia> arr[2]
2
julia> arr2 = String["Taobao","RUNOOB","GOOGLE"]
3-element Vector{String}:
"Taobao"
"RUNOOB"
"GOOGLE"

julia> arr2[1]
"Taobao"

julia> arr2[end]
"GOOGLE"

指定数组类型及维度

我们还可以使用以下语法指定数组的类型和维度:

Array{type}(undef, dims...)

undef 表示数组未初始化。

dims... 可以是维度的单多元组，也可以是维度作为可变参数时的一组值。

dims... 数字表示元素个数，多个维度使用逗号 , 分隔。

实例

julia> array = Array{Int64}(undef, 3) # 表示一维数组，数组有 3 个元素
3-element Vector{Int64}:
4834342704
4377305096
0

julia> array = Array{Int64}(undef, 3, 3, 3) # 表示 3 维数组，每个维度数组有 3 个元素
3×3×3 Array{Int64, 3}:
[:, :, 1] =
4562265712 0 0
1 0 0
0 0 0

[:, :, 2] =
0 0 0
0 0 0
0 0 0

[:, :, 3] =
0 0 0
0 0 0
0 0 0

以上实例中，数组的类型我们放在花括号中 {}， undef 用于设置数组未初始化为任何已知值，这就是我们在输出中得到随机数的原因。

创建二维数组和矩阵

我们可以将数组元素中的逗号 , 省略掉或者使用两个冒号 ;;，这样就可以创建一个二维数组了，如下实例：

实例

julia> [1 2 3 4]
1×4 Matrix{Int64}:
1 2 3 4
julia> [1;; 2;; 3;; 4]
1×4 Matrix{Int64}:
1 2 3 4

注意：第一行输出的 1×4 Matrix{Int64}:，1x4 表示一行四列的矩阵。

虽然只有一行，也是二维数组，因为 Julia 只认可列向量，而不认可所谓的行向量。

要添加另一行，只需添加分号 ;，看以下实例：

实例

julia> [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4

也可以使用冒号 : 和空格来实现，看以下实例：

实例

julia> [1:2 3:4]
2×2 Matrix{Int64}:
1 3
2 4

注意：第一行输出的 2×2 Matrix{Int64}:，2×2 表示两行两列的矩阵。

我们也可以在方括号 [] 中嵌入多个长度相同的一维数组，并用空格分隔来创建二维数组：

实例

julia> [[1,2] [3,4] [5,6]]
2×3 Matrix{Int64}:
1 3 5
2 4 6

2x3 表示两行三列的数组。

下面我们通过灵活运用分号 ; 和空格创建一个两行三列和三行两列的二维数组：

实例

julia> [[1;2] [3;4] [5;6]]
2×3 Matrix{Int64}:
1 3 5
2 4 6

julia> [[1 2]; [3 4]; [5 6]]
3×2 Matrix{Int64}:
1 2
3 4
5 6

使用范围函数来创建数组

省略号 ...

可以使用省略号 ... 来创建一个数组，实例如下：

实例

julia> [0:10...]
11-element Vector{Int64}:
0
1
2
3
4
5
6
7
8
9
10

collect() 函数

collect() 函数语法格式如下：

collect(start:step:stop)

start 为开始值，step 为步长，stop 为结束值。

该函数返回数组。

以下实例值为 1，步长为 2，结束值为 13：

实例

julia> collect(1:2:13)
7-element Vector{Int64}:
1
3
5
7
9
11
13

collect() 函数也可以指定类型，语法格式如下：

collect(element_type, start:step:stop)

以下实例创建一个浮点型数组：

实例

julia> collect(Float64, 1:2:5)
3-element Vector{Float64}:
1.0
3.0
5.0

range() 函数

range() 函数可以生存一个区间范围并指定步长，可以方便 collect() 函数调用。

range() 函数语法格式如下：

range(start, stop, length) range(start, stop; length, step) range(start; length, stop, step) range(;start, length, stop, step)

start 为开始值，step 为步长，stop 为结束值，length 为长度。

实例

julia> range(1, length=100)
1:100

julia> range(1, stop=100)
1:100

julia> range(1, step=5, length=100)
1:5:496

julia> range(1, step=5, stop=100)
1:5:96

julia> range(1, 10, length=101)
1.0:0.09:10.0

julia> range(1, 100, step=5)
1:5:96

julia> range(stop=10, length=5)
6:10

julia> range(stop=10, step=1, length=5)
6:1:10

julia> range(start=1, step=1, stop=10)
1:1:10

如果未指定长度 length，且 stop - start 不是 step 的整数倍，则将生成在 stop 之前结束的范围。

julia> range(1, 3.5, step=2)
1.0:2.0:3.0

使用 range() 和 collect() 创建数组：

实例

julia> collect(range(1,stop=10))
10-element Vector{Int64}:
1
2
3
4
5
6
7
8
9
10
julia> collect(range(1, length=15, stop=150))
15-element Vector{Float64}:
1.0
11.642857142857142
22.285714285714285
32.92857142857143
43.57142857142857
54.214285714285715
64.85714285714286
75.5
86.14285714285714
96.78571428571429
107.42857142857143
118.07142857142857
128.71428571428572
139.35714285714286
150.0

使用推导式和生成器创建数组

创建数组的另一种有用方法是使用推导。

数组推导式语法格式如下：

A = [ F(x,y,...) for x=rx, y=ry, ... ]

F(x,y,...) 取其给定列表中变量 x，y 等的每个值进行计算。值可以指定为任何可迭代对象，但通常是 1:n 或 2:(n-1) 之类的范围，或者像 [1.2, 3.4, 5.7] 这样的显式数组值。结果是一个 N 维密集数组，将变量范围 rx，ry 等的维数拼接起来得到其维数，并且每次 F(x,y,...) 计算返回一个标量。

实例

julia> [n^2 for n in 1:10]
10-element Vector{Int64}:
1
4
9
16
25
36
49
64
81
100

创建二维数组：

实例

julia> [n*m for n in 1:10, m in 1:10]
10×10 Matrix{Int64}:
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100

也可以在没有方括号的情况下编写（数组）推导，从而产生称为生成器的对象。

以下实例创建一个数组：

实例

julia> collect(n^2 for n in 1:5)
5-element Vector{Int64}:
1
4
9
16
25

以下表达式在不分配内存的情况下对一个序列进行求和：

实例

julia> sum(1/n^2 for n=1:1000)
1.6439345666815615

Julia 数组基本函数

函数	描述
`eltype(A)`	`A` 中元素的类型
`length(A)`	`A` 中元素的数量
`ndims(A)`	`A` 的维数
`size(A)`	一个包含 `A` 各个维度上元素数量的元组
`size(A,n)`	`A` 第 `n` 维中的元素数量
`axes(A)`	一个包含 `A` 有效索引的元组
`axes(A,n)`	第 `n` 维有效索引的范围
`eachindex(A)`	一个访问 `A` 中每一个位置的高效迭代器
`stride(A,k)`	在第 `k` 维上的间隔（stride）（相邻元素间的线性索引距离）
`strides(A)`	包含每一维上的间隔（stride）的元组

Julia构造和初始化

Julia 提供了许多用于构造和初始化数组的函数。在下列函数中，参数 dims ... 可以是一个元组 tuple 来表示维数，也可以是一个可变长度的整数值作为维数。大部分函数的第一个参数都表示数组的元素类型 T 。如果类型 T 被省略，那么将默认为 Float64。

函数	描述
`Array{T}(undef, dims...)`	一个没有初始化的密集 `Array`
`zeros(T, dims...)`	一个全零 `Array`
`ones(T, dims...)`	一个元素均为 1 的 `Array`
`trues(dims...)`	一个每个元素都为 `true` 的 `BitArray`
`falses(dims...)`	一个每个元素都为 `false` 的 `BitArray`
`reshape(A, dims...)`	一个包含跟 `A` 相同数据但维数不同的数组
`copy(A)`	拷贝 `A`
`deepcopy(A)`	深拷贝，即拷贝 `A`，并递归地拷贝其元素
`similar(A, T, dims...)`	一个与`A`具有相同类型（这里指的是密集，稀疏等）的未初始化数组，但具有指定的元素类型和维数。第二个和第三个参数都是可选的，如果省略则默认为元素类型和 `A` 的维数。
`reinterpret(T, A)`	与 `A` 具有相同二进制数据的数组，但元素类型为 `T`
`rand(T, dims...)`	一个随机 `Array`，元素值是 [0,1)[0,1) 半开区间中的均匀分布且服从一阶独立同分布 ^[1]
`randn(T, dims...)`	一个随机 `Array`，元素为标准正态分布，服从独立同分布
`Matrix{T}(I, m, n)`	`m` 行 `n` 列的单位矩阵（需要先执行 `using LinearAlgebra` 来才能使用 `I`）
`range(start, stop=stop, length=n)`	从 `start` 到 `stop` 的带有 `n` 个线性间隔元素的范围
`fill!(A, x)`	用值 `x` 填充数组 `A`
`fill(x, dims...)`	一个被值 `x` 填充的 `Array`

zeros() 创建数组实例，元素初始值都是 0:

实例

julia> zeros(Int8, 2, 3)
2×3 Matrix{Int8}:
0 0 0
0 0 0

julia> zeros(Int8, (2, 3))
2×3 Matrix{Int8}:
0 0 0
0 0 0

julia> zeros((2, 3))
2×3 Matrix{Float64}:
0.0 0.0 0.0
0.0 0.0 0.0

Julia 元组

Julia 的元组与数组类似，都是有序的元素集合，不同之处在于元组的元素不能修改。

另外元组使用小括号 (...)，数组使用方括号 [...]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可，数组中的很多函数也可以在元组中使用。

如下实例：

实例

julia> tupl=(5,10,15,20,25,30) # 创建一个元组
(5, 10, 15, 20, 25, 30)

julia> tupl
(5, 10, 15, 20, 25, 30)

julia> tupl[3:end] # 输出第三个到最后一个元素的元组
(15, 20, 25, 30)

julia> tupl = ((1,2),(3,4)) # 创建二维元组
((1, 2), (3, 4))

julia> tupl[1] # 访问二维元组元素，输出第一维元组
(1, 2)

julia> tupl[1][2] # 访问二维元组元素，输出第一维元组的第二个元素
2

元组的元素是不能修改，如果我们尝试修改它就回报错：

实例

julia> tupl2=(1,2,3,4)
(1, 2, 3, 4)

julia> tupl2[2]=0
ERROR: MethodError: no method matching setindex!(::NTuple{4, Int64}, ::Int64, ::Int64)
Stacktrace:
[1] top-level scope
@ REPL[8]:1

元组命名

我们可以为元组命名，从而可以更方便的访问它。

以下列出了几种不同元组的命名方式。

1、元组中的键(key)和值(value)分开命名

元组中的键(key)和值(value)可以分开独立命名，实例如下：

实例

julia> names_shape = (:corner1, :corner2)
(:corner1, :corner2)

julia> values_shape = ((100, 100), (200, 200))
((100, 100), (200, 200))

julia> shape_item2 = NamedTuple{names_shape}(values_shape)
(corner1 = (100, 100), corner2 = (200, 200))

我们可以使用 . 点号来访问元组：

实例

julia> shape_item2.corner1
(100, 100)

julia> shape_item2.corner2
(200, 200)

2、键(key)和值(value)同时在一个元组中

键(key)和值(value)可以同时在一个元组中，实例如下：

实例

julia> shape_item = (corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0))
(corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0))

我们可以使用 . 点号来访问元组：

实例

julia> shape_item.corner1
(1, 1)

julia> shape_item.corner2
(-1, -1)

julia> shape_item.center
(0, 0)

julia> (shape_item.center,shape_item.corner2)
((0, 0), (-1, -1))

我们还可以像使用普通元组一样访问所有值，如下所示：

实例

julia> c1, c2, center = shape_item
(corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0))

julia> c1
(1, 1)

3、合并两个已命名的元组

我们可以使用 merge() 函数来合并两个已命名的元组，实例如下：

实例

julia> colors_shape = (top = "red", bottom = "green")
(top = "red", bottom = "green")

julia> shape_item = (corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0))
(corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0))

julia> merge(shape_item, colors_shape)
(corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0), top = "red", bottom = "green")

元组作为函数参数

以下实例我们创建一个 testFunc 函数，并将元组 options 作为参数传入：

实例：test.jl 文件代码

# 创建函数
function testFunc(x, y, z; a=10, b=20, c=30)
println("x =x, y = y, z =z; a = a, b =b, c = c")
end

# 创建元组
options = (b = 200, c = 300)

# 执行函数，元组作为参数传入
testFunc(1, 2, 3; options...)

使用 julia 命令执行以上文件，输出结果为：

$ julia test.jl
x = 1, y = 2, z = 3; a = 10, b = 200, c = 300

如果指定的参数在元组后面，则会覆盖元组中已有的参数：

实例

# 创建函数
function testFunc(x, y, z; a=10, b=20, c=30)
println("x =x, y = y, z =z; a = a, b =b, c = c")
end

# 创建元组
options = (b = 200, c = 300)

# 执行函数，元组作为参数传入，指定参数在元组前，不会覆盖
testFunc(1, 2, 3; b = 1000_000, options...)

# 执行函数，元组作为参数传入，指定参数在元组后，会覆盖
testFunc(1, 2, 3; options..., b= 1000_000)

使用 julia 命令执行以上文件，输出结果为：

$ julia test.jl
x = 1, y = 2, z = 3; a = 10, b = 200, c = 300
x = 1, y = 2, z = 3; a = 10, b = 1000000, c = 300

Julia 数据类型

在编程语言中，都有基本的数学运算和科学计算，它们常用的数据类型为整数和浮点数。

另外还有一个"字面量"的术语，字面量（literal）用于表达源代码中一个固定值的表示法（notation），整数、浮点数以及字符串等等都是字面量。

例如：

a=1 // a 是变量，1 是整型字面量 b=1.0 // b 是变量，1.0 是浮点型字面量

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
1

julia> 1234
1234

整型字面量的默认类型取决于目标系统是 32 位还是 64 位架构（目前大部分系统都是 64 位）：

实例

# 32 位系统：
julia> typeof(1)
Int32

# 64 位系统：
julia> typeof(1)
Int64

Julia 的内置变量 Sys.WORD_SIZE 表明了目标系统是 32 位还是 64 位架构：

实例

# 32 位系统：
julia> Sys.WORD_SIZE
32

# 64 位系统：
julia> Sys.WORD_SIZE
64

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

实例

# 32 位系统：
julia> Int
Int32
julia> UInt
UInt32

# 64 位系统：
julia> Int
Int64
julia> UInt
UInt64

溢出行为

在 Julia 里，超出一个类型可表示的最大值会导致环绕 (wraparound) 行为：

实例

julia> x = typemax(Int64)
9223372036854775807

julia> x + 1
-9223372036854775808

julia> x + 1 == typemin(Int64)
true

因此，Julia 的整数算术实际上是模算数的一种形式，它反映了现代计算机实现底层算术的特点。在可能有溢出产生的程序中，对最值边界出现循环进行显式检查是必要的。否则，推荐使用任意精度算术中的 BigInt 类型作为替代。

下面是溢出行为的一个例子以及如何解决溢出：

实例

julia> 10^19
-8446744073709551616

julia> big(10)^19
10000000000000000000

除法错误

在以下两种例外情况下，整数除法会触发 DivideError 错误：

除以零
除以最小的负数

rem 取余函数和 mod 取模函数在除零时抛出 DivideError 错误，实例如下：

实例

julia> mod(1, 0)
ERROR: DivideError: integer division error
Stacktrace:
[1] div at .\int.jl:260 [inlined]
[2] div at .\div.jl:217 [inlined]
[3] div at .\div.jl:262 [inlined]
[4] fld at .\div.jl:228 [inlined]
[5] mod(::Int64, ::Int64) at .\int.jl:252
[6] top-level scope at REPL[52]:1

julia> rem(1, 0)
ERROR: DivideError: integer division error
Stacktrace:
[1] rem(::Int64, ::Int64) at .\int.jl:261
[2] top-level scope at REPL[54]:1

浮点类型

下表列出来 Julia 支持的浮点类型:

类型	精度	比特数
Float16	半精度	16
Float32	单精度	32
Float64	双精度	64

此外，对复数和有理数的完整支持是在这些原始数据类型之上建立起来的。

浮点数字面量格式表示如下，必要时可使用 E 来表示。

实例

julia> 1.0
1.0

julia> 1.
1.0

julia> 0.5
0.5

julia> .5
0.5

julia> -1.23
-1.23

julia> 1e10
1.0e10

julia> 2.5e-4
0.00025

注：
在科学计数法中，为了使公式简便，可以用带 E 的格式表示。例如 1.03乘10的8次方，可简写为 "1.03E+08" 的形式，其中 "E" 是 exponent(指数) 的缩写。

上面的结果都是 Float64 类型的值。使用 f 替代 e 可以得到 Float32 类型的字面量：

实例

julia> x = 0.5f0
0.5f0

julia> typeof(x)
Float32

julia> 2.5f-4
0.00025f0
数值可以很容易地转换为 Float32 类型：

julia> x = Float32(-1.5)
-1.5f0

julia> typeof(x)
Float32

也存在十六进制的浮点数字面量，但只适用于 Float64 类型的值。一般使用 p 前缀及以 2 为底的指数来表示：

实例

julia> 0x1p0
1.0

julia> 0x1.8p3
12.0

julia> x = 0x.4p-1
0.125

julia> typeof(x)
Float64
Julia 也支持半精度浮点数（Float16），但它们是使用 Float32 进行软件模拟实现的。

julia> sizeof(Float16(4.))
2

julia> 2*Float16(4.)
Float16(8.0)

下划线 _ 可用作数字分隔符：

实例

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

浮点数中的零

浮点数有两种零，正零和负零。它们相互相等但有着不同的二进制表示，可以使用 bitstring 函数来查看：

实例

julia> 0.0 == -0.0
true

julia> bitstring(0.0)
"0000000000000000000000000000000000000000000000000000000000000000"

julia> bitstring(-0.0)
"1000000000000000000000000000000000000000000000000000000000000000"

特殊的浮点值

有三种特定的标准浮点值不和实数轴上任何一点对应：

Float16	Float32	Float64	名称	描述
Inf16	Inf32	Inf	正无穷	一个大于所有有限浮点数的数
-Inf16	-Inf32	-Inf	负无穷	一个小于所有有限浮点数的数
NaN16	NaN32	NaN	不是一个数	一个不和任何浮点值（包括自己）相等（==）的值

以下列举了一些浮点数的运算实例：

实例

julia> 1/Inf
0.0

julia> 1/0
Inf

julia> -5/0
-Inf

julia> 0.000001/0
Inf

julia> 0/0
NaN

julia> 500 + Inf
Inf

julia> 500 - Inf
-Inf

julia> Inf + Inf
Inf

julia> Inf - Inf
NaN

julia> Inf Inf
Inf

julia> Inf / Inf
NaN

julia> 0 Inf
NaN

julia> NaN == NaN
false

julia> NaN != NaN
true

julia> NaN < NaN
false

julia> NaN > NaN
false

我们还可以使用 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 能表示的浮点数之间的差值：

实例

julia> eps(Float32)
1.1920929f-7

julia> eps(Float64)
2.220446049250313e-16

julia> eps() # 与 eps(Float64) 相同
2.220446049250313e-16

这些值分别是 Float32 中的 2.0^-23 和 Float64 中的 2.0^-52。eps 函数也可以接受一个浮点值作为参数，然后给出这个值与下一个可表示的浮点数值之间的绝对差。也就是说，eps(x) 产生一个和 x 类型相同的值，并且 x + eps(x) 恰好是比 x 更大的下一个可表示的浮点值：

实例

julia> eps(1.0)
2.220446049250313e-16

julia> eps(1000.)
1.1368683772161603e-13

julia> eps(1e-27)
1.793662034335766e-43

julia> eps(0.0)
5.0e-324

两个相邻可表示的浮点数之间的距离并不是常数，数值越小，间距越小，数值越大，间距越大。换句话说，可表示的浮点数在实数轴上的零点附近最稠密，并沿着远离零点的方向以指数型的速度变得越来越稀疏。根据定义，eps(1.0) 与 eps(Float64) 相等，因为 1.0 是个 64 位浮点值。

Julia 也提供了 nextfloat 和 prevfloat 两个函数分别返回基于参数的下一个更大或更小的可表示的浮点数：

实例

julia> x = 1.25f0
1.25f0

julia> nextfloat(x)
1.2500001f0

julia> prevfloat(x)
1.2499999f0

julia> bitstring(prevfloat(x))
"00111111100111111111111111111111"

julia> bitstring(x)
"00111111101000000000000000000000"

julia> bitstring(nextfloat(x))
"00111111101000000000000000000001"

这个例子体现了一般原则，即相邻可表示的浮点数也有着相邻的二进制整数表示。

舍入模式

一个数如果没有精确的浮点表示，就必须被舍入到一个合适的可表示的值。

Julia 所使用的默认模式总是 RoundNearest，指舍入到最接近的可表示的值，这个被舍入的值会使用尽量少的有效位数。

实例

julia> BigFloat("1.510564889",2,RoundNearest)
1.5

julia> BigFloat("1.550564889",2,RoundNearest)
1.5

julia> BigFloat("1.560564889",2,RoundNearest)
1.5

0 和 1 的字面量

Julia 提供了 0 和 1 的字面量函数，可以返回特定类型或所给变量的类型。

函数	描述
zero(x)	x 类型或变量 x 的类型的零字面量
one(x)	x 类型或变量 x 的类型的一字面量

这些函数在数值比较中可以用来避免不必要的类型转换带来的开销。

例如：

实例

julia> zero(Float32)
0.0f0

julia> zero(1.0)
0.0

julia> one(Int32)
1

julia> one(BigFloat)
1.0

类型转换

类型转换是把变量从一种类型转换为另一种数据类型。例如，如果您想存储一个 float 类型的值到一个简单的整型中，您需要把 float 类型强制转换为 int 类型。您可以使用强制类型转换运算符来把值显式地从一种类型转换为另一种类型，如下所示：

Julia 支持三种数值转换，它们在处理不精确转换上有所不同。

第一种：

T(x) 
或
convert(T,x)

以上都会把 x 转换为 T 类型。

如果 T 是浮点类型，转换的结果就是最近的可表示值，可能会是正负无穷大。
如果 T 为整数类型，当 x 不能由 T 类型表示时，会抛出 InexactError。

第二种：

x % T 也可以将整数 x 转换为整型 T，与 x 模 2^n 的结果一致，其中 n 是 T 的位数。

第三种：

舍入函数接收一个 T 类型的可选参数。比如，round(Int,x) 是 Int(round(x)) 的简写版。

实例

julia> Int8(127)
127

julia> Int8(128)
ERROR: InexactError: trunc(Int8, 128)
Stacktrace:
[...]

julia> Int8(127.0)
127

julia> Int8(3.14)
ERROR: InexactError: Int8(3.14)
Stacktrace:
[...]

julia> Int8(128.0)
ERROR: InexactError: Int8(128.0)
Stacktrace:
[...]

julia> 127 % Int8
127

julia> 128 % Int8
-128

julia> round(Int8,127.4)
127

julia> round(Int8,127.6)
ERROR: InexactError: trunc(Int8, 128.0)
Stacktrace:
[...]

每日一图