多维数组

    数组是存储在多维网格中对象的集合。在最一般的情况下， 数组中的对象可能是 Any 类型。 对于大多数计算上的需求，数组中对象的类型应该更加具体，例如 Float64 或 。

    一般来说，与许多其他科学计算语言不同，Julia 不希望为了性能而以向量化的方式编写程序。Julia 的编译器使用类型推断，并为标量数组索引生成优化的代码，从而能够令用户方便地编写可读性良好的程序，而不牺牲性能，并且时常会减少内存使用。

    在 Julia 中，所有函数的参数都是 passed by sharing。一些科学计算语言用传值的方式传递数组，尽管这样做可以防止数组在被调函数中被意外地篡改，但这也会导致不必要的数组拷贝。通常，以一个 ! 结尾的函数名表示它会对自己的一个或者多个参数的值进行修改或者销毁（例如， 和 sort!）。被调函数必须进行显式拷贝，以确保它们不会无意中修改输入参数。很多 “non-mutating” 函数在实现的时候，都会先进行显式拷贝，然后调用一个以 ! 结尾的同名函数，最后返回之前拷贝的副本。

    构造和初始化

    Julia 提供了许多用于构造和初始化数组的函数。在下列函数中，参数 dims … 可以是一个包含维数大小的元组，也可以表示用任意个参数传递的一系列维数大小值。大部分函数的第一个参数都表示数组的元素类型 T 。如果类型 T 被省略，那么将默认为 Float64。


    iid，独立同分布

    用 [A，B，C，…] 来构造 1 维数组（向量）。如果所有参数有一个共同的提升类型（promotion type），那么它们会被 函数转换为该类型。

    要查看各种方法，我们可以将不同维数传递给这些构造函数，请考虑以下示例：

    这里的 (2, 2) 是一个 Tuple.

    拼接

    可以使用以下函数构造和拼接数组：

    传递给这些函数的标量值会被当作单元素数组。例如，

    1. julia> vcat([1, 2], 3)
    2. 3-element Array{Int64,1}:
    3.  1
    4.  2
    5.  3
    7. julia> hcat([1 2], 3)
    8. 1×3 Array{Int64,2}:
    9.  1  2  3

    这些拼接函数非常常用，因此它们有特殊的语法：

    hvcat 可以在第 1 维列数组（用分号分隔）和第 2 维行数组（用空格分隔）进行拼接。 请考虑以下语法示例：

    1. julia> [[1; 2]; [3, 4]]
    2. 4-element Array{Int64,1}:
    3.  1
    4.  2
    5.  3
    6.  4
    8. julia> [[1 2] [3 4]]
    9. 1×4 Array{Int64,2}:
    10.  1  2  3  4
    12. julia> [[1 2]; [3 4]]
    13. 2×2 Array{Int64,2}:
    14.  1  2
    15.  3  4

    限定类型数组的初始化

    可以用 T[A, B, C, …] 的方式声明一个元素为某种特定类型的数组。该方法定义一个元素类型为 T 的一维数组并且初始化元素为 A, B, C, ….。比如，Any[x, y, z] 会构建一个异构数组，该数组可以包含任意类型的元素。

    类似的，拼接也可以用类型为前缀来指定结果的元素类型。

    1. julia> [[1 2] [3 4]]
    2. 1×4 Array{Int64,2}:
    3.  1  2  3  4
    5. julia> Int8[[1 2] [3 4]]
    6. 1×4 Array{Int8,2}:
    7.  1  2  3  4

    （数组）推导提供了构造数组的通用且强大的方法。其语法类似于数学中的集合构造的写法：

    1. 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 等的维数串联。每次 FF(x,y,…) 计算返回一个标量。

    下面的示例计算当前元素和沿一维网格其左，右相邻元素的加权平均值：

    1. julia> x = rand(8)
    2. 8-element Array{Float64,1}:
    3.  0.843025
    4.  0.869052
    5.  0.365105
    6.  0.699456
    7.  0.977653
    8.  0.994953
    9.  0.41084
    10.  0.809411
    12. julia> [ 0.25*x[i-1] + 0.5*x[i] + 0.25*x[i+1] for i=2:length(x)-1 ]
    13. 6-element Array{Float64,1}:
    14.  0.736559
    15.  0.57468
    16.  0.685417
    17.  0.912429
    18.  0.8446
    19.  0.656511

    生成的数组类型取决于参与计算元素的类型。为了明确地控制类型，可以在（数组）推导之前添加类型。例如，我们可以要求结果为单精度类型：

    1. Float32[ 0.25*x[i-1] + 0.5*x[i] + 0.25*x[i+1] for i=2:length(x)-1 ]

    生成器表达式

    也可以在没有方括号的情况下编写（数组）推导，从而产生称为生成器的对象。可以迭代此对象以按需生成值，而不是预先分配数组并存储它们（请参阅 ）。例如，以下表达式在不分配内存的情况下对一个序列进行求和：

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

    在参数列表中使用具有多个维度的生成器表达式时，需要使用括号将生成器与后续参数分开：

    1. julia> map(tuple, 1/(i+j) for i=1:2, j=1:2, [1:4;])
    2. ERROR: syntax: invalid iteration specification

    for 后面所有逗号分隔的表达式都被解释为范围。 添加括号让我们可以向 map 中添加第三个参数：

    1. julia> map(tuple, (1/(i+j) for i=1:2, j=1:2), [1 3; 2 4])
    2. 2×2 Array{Tuple{Float64,Int64},2}:
    3.  (0.5, 1)       (0.333333, 3)
    4.  (0.333333, 2)  (0.25, 4)

    生成器是通过内部函数实现。 与语言中内部函数的其他情况一样，封闭作用域中的变量可以在内部函数中“捕获”。 例如，sum(p[i] - q[i] for i=1:n) 从封闭作用域中捕获三个变量 p，q 和 n。捕获的变量可能会出现中描述的性能问题。

    通过编写多个 for 关键字，生成器和推导中的范围可以取决于之前的范围：

    1. julia> [(i,j) for i=1:3 for j=1:i]
    2. 6-element Array{Tuple{Int64,Int64},1}:
    3.  (1, 1)
    4.  (2, 1)
    5.  (2, 2)
    6.  (3, 1)
    7.  (3, 2)
    8.  (3, 3)

    可以使用 if 关键字过滤生成的值：

    索引

    索引 n 维数组 A 的一般语法是：

    1. X = A[I_1, I_2, ..., I_n]

    其中每个 I_k 可以是标量整数，整数数组或任何其他。这包括 Colon (:) 来选择整个维度中的所有索引，形式为 a:c 或 a:b:c 的范围来选择连续或跨步的子区间，以及布尔数组以选择索引为 true 的元素。

    如果所有索引都是标量，则结果 X 是数组 A 中的单个元素。否则，X 是一个数组，其维数与所有索引的维数之和相同。

    如果所有索引都是向量，则 X 的形状将是 (length(I_1), length(I_2), …, length(I_n))，其中，X 中位于 (i_1, i_2, …, i_n) 处的元素为 A[I_1[i_1], I_2[i_2], …, I_n[i_n]]。

    例子：

    1. julia> A = reshape(collect(1:16), (2, 2, 2, 2))
    2. 2×2×2×2 Array{Int64,4}:
    3. [:, :, 1, 1] =
    4.  1  3
    5.  2  4
    7. [:, :, 2, 1] =
    8.  5  7
    9.  6  8
    11. [:, :, 1, 2] =
    12.   9  11
    13.  10  12
    15. [:, :, 2, 2] =
    17.  14  16
    19. julia> A[1, 2, 1, 1] # all scalar indices
    20. 3
    22. julia> A[[1, 2], [1], [1, 2], [1]] # all vector indices
    23. 2×1×2×1 Array{Int64,4}:
    24. [:, :, 1, 1] =
    25.  1
    26.  2
    28. [:, :, 2, 1] =
    29.  5
    30.  6
    32. julia> A[[1, 2], [1], [1, 2], 1] # a mix of index types
    33. 2×1×2 Array{Int64,3}:
    34. [:, :, 1] =
    35.  1
    36.  2
    38. [:, :, 2] =
    39.  6

    请注意最后两种情况下得到的数组大小为何是不同的。

    If I_1 is changed to a two-dimensional matrix, then X becomes an n+1-dimensional array of shape (size(I_1, 1), size(I_1, 2), length(I_2), …, length(I_n)). The matrix adds a dimension.

    例如：

    1. julia> A = reshape(collect(1:16), (2, 2, 2, 2));
    3. julia> A[[1 2; 1 2]]
    4. 2×2 Array{Int64,2}:
    5.  1  2
    6.  1  2
    8. julia> A[[1 2; 1 2], 1, 2, 1]
    9. 2×2 Array{Int64,2}:
    10.  5  6
    11.  5  6

    位于 (i1, i_2, i_3, …, i{n+1}) 处的元素值是 A[I1[i_1, i_2], I_2[i_3], …, I_n[i{n+1}]]。所有使用标量索引的维度都将被丢弃，例如，A[2，I，3] 的结果是一个大小为 size(I) 的数组，它的第 i 个元素由 A[2, I[i], 3] 填充。

    作为此语法的特殊部分，end 关键字可用于表示索引括号内每个维度的最后一个索引，由索引的最内层数组的大小决定。没有 end 关键字的索引语法相当于调用：

    1. X = getindex(A, I_1, I_2, ..., I_n)

    例如：

    1. julia> x = reshape(1:16, 4, 4)
    2. 4×4 reshape(::UnitRange{Int64}, 4, 4) with eltype Int64:
    3.  1  5   9  13
    4.  2  6  10  14
    5.  3  7  11  15
    6.  4  8  12  16
    8. julia> x[2:3, 2:end-1]
    9. 2×2 Array{Int64,2}:
    10.  6  10
    11.  7  11
    13. julia> x[1, [2 3; 4 1]]
    14. 2×2 Array{Int64,2}:
    15.   5  9
    16.  13  1

    形式为 n:n-1 的空范围有时用于表示 n-1 和 n 之间的索引间位置。例如，searchsorted 函数利用这个惯例来表示一个值的插入位置在有序数组中未找到：

    1. julia> a = [1,2,5,6,7];
    3. julia> searchsorted(a, 3)
    4. 3:2

    赋值

    在 n 维数组 A 中赋值的一般语法是：

    1. A[I_1, I_2, ..., I_n] = X

    其中每个I_k可以是标量整数，整数数组或任何其他支持的索引类型。 这包括 (:)来选择整个维度中的所有索引，形式为a:c或a:b:c的范围来选择连续或跨步的部分元素，以及布尔数组以true索引选择元素。

    如果X是一个数组，它必须具有与索引长度的乘积相同的元素数：prod(length(I_1), length(I_2), …, length(I_n))。 A在位置I_1[i_1], I_2[i_2], …, I_n[i_n]中的值被值X[i_1, i_2, …, i_n]覆盖。 如果X不是数组，则将其值写入A中所有引用的位置。

    就像在索引中一样，end关键字可用于表示索引括号中每个维度的最后一个索引，由被赋值的数组大小决定。 没有end关键字的索引赋值语法相当于调用">setindex！：

    1. setindex!(A, X, I_1, I_2, ..., I_n)

    例如：

    1. julia> x = collect(reshape(1:9, 3, 3))
    2. 3×3 Array{Int64,2}:
    3.  1  4  7
    4.  2  5  8
    5.  3  6  9
    7. julia> x[3, 3] = -9;
    9. julia> x[1:2, 1:2] = [-1 -4; -2 -5];
    11. julia> x
    12. 3×3 Array{Int64,2}:
    13.  -1  -4   7
    14.  -2  -5   8
    15.   3   6  -9

    在表达式 A[I_1, I_2, …, I_n] 中，每个 I_k 可以是标量索引，标量索引数组，或者用 to_indices 转换成的表示标量索引数组的对象：

    • 标量索引。默认情况下，这包括：
      • 非布尔的整数
      • @ref">@ref">CartesianIndex {N}s, which behave like an N-tuple of integers spanning multiple dimensions (see below for more details)
    • 标量索引数组。这包括：
      • 整数向量和多维整数数组
      • 像 [] 这样的空数组，它不选择任何元素
      • 如 a:c 或 a:b:c 的范围，从 a 到 c （包括）选择连续或间隔的部分元素
      • 任何自定义标量索引数组，它是 AbstractArray 的子类型
      • CartesianIndex{N} 数组（详见下文）
    • 一个表示标量索引数组的对象，可以通过转换为这样的对象。 默认情况下，这包括：
      • Colon() (:)，表示整个维度内或整个数组中的所有索引
      • 布尔数组，选择其中值为 true 的索引对应的元素（更多细节见下文）
        一些例子：
    1. julia> A = reshape(collect(1:2:18), (3, 3))
    2. 3×3 Array{Int64,2}:
    3.  1   7  13
    4.  3   9  15
    5.  5  11  17
    7. julia> A[4]
    8. 7
    10. julia> A[[2, 5, 8]]
    11. 3-element Array{Int64,1}:
    12.   3
    13.   9
    14.  15
    16. julia> A[[1 4; 3 8]]
    17. 2×2 Array{Int64,2}:
    18.  1   7
    19.  5  15
    21. julia> A[[]]
    22. 0-element Array{Int64,1}
    24. julia> A[1:2:5]
    25. 3-element Array{Int64,1}:
    26.  1
    27.  5
    28.  9
    30. julia> A[2, :]
    31. 3-element Array{Int64,1}:
    32.   3
    33.   9
    34.  15
    36. julia> A[:, 3]
    37. 3-element Array{Int64,1}:
    38.  13
    39.  15
    40.  17

    特殊的 CartesianIndex{N} 对象表示一个标量索引，其行为类似于张成多个维度的 N 维整数元组。例如：

    如果单独考虑，这可能看起来相对微不足道; CartesianIndex 只是将多个整数聚合成一个表示单个多维索引的对象。 但是，当与其他索引形式和迭代器组合产生多个 CartesianIndex 时，这可以直接形成非常优雅和高效的代码。请参阅下面的，有关更高级的示例，请参阅关于多维算法和迭代博客文章。

    也支持 CartesianIndex {N} 的数组。 它们代表一组标量索引，每个索引都跨越 N 个维度，从而实现一种有时也称为逐点索引的索引形式。例如，它可以从上面的 A 的第一“页”访问对角元素：

    1. julia> page = A[:,:,1]
    2. 4×4 Array{Int64,2}:
    3.  1  5   9  13
    4.  2  6  10  14
    5.  3  7  11  15
    6.  4  8  12  16
    8. julia> page[[CartesianIndex(1,1),
    9.              CartesianIndex(2,2),
    10.              CartesianIndex(3,3),
    11.              CartesianIndex(4,4)]]
    12. 4-element Array{Int64,1}:
    13.   1
    14.   6
    15.  11
    16.  16

    这可以通过 以及普通整数索引（而不是把从 A 中提取第一“页”作为单独的步骤）更加简单地表达。它甚至可以与 : 结合使用，同时从两个页面中提取两个对角线：

    1. julia> A[CartesianIndex.(axes(A, 1), axes(A, 2)), 1]
    2. 4-element Array{Int64,1}:
    3.   1
    4.   6
    5.  11
    7. julia> A[CartesianIndex.(axes(A, 1), axes(A, 2)), :]
    8. 4×2 Array{Int64,2}:
    9.   1  17
    10.   6  22
    11.  11  27
    12.  16  32

    CartesianIndex 和 CartesianIndex 数组与表示维度的最后一个索引的 end 关键字不兼容。 不要在可能包含 CartesianIndex 或其数组的索引表达式中使用 end。

    逻辑索引

    通常称为逻辑索引或使用逻辑掩码索引，通过布尔数组进行索引选择索引处其值为 true 的元素。 通过布尔向量 B 进行索引实际上与通过返回的整数向量进行索引相同。 类似地，通过 N 维布尔数组进行索引实际上与通过 CartesianIndex{N} 向量在值为 true 处进行索引相同。 逻辑索引必须是与其索引的维度长度相同的向量，或者它必须是提供的唯一索引，并且与索引的数组的大小和维度相匹配。 将布尔数组直接用作索引，通常比首先调用findall更有效。

    1. julia> x = reshape(1:16, 4, 4)
    2. 4×4 reshape(::UnitRange{Int64}, 4, 4) with eltype Int64:
    3.  1  5   9  13
    4.  2  6  10  14
    5.  3  7  11  15
    6.  4  8  12  16
    8. julia> x[[false, true, true, false], :]
    9. 2×4 Array{Int64,2}:
    10.  2  6  10  14
    11.  3  7  11  15
    14. 4×4 Array{Bool,2}:
    15.   true  false  false  false
    16.   true  false  false  false
    17.  false  false  false  false
    18.   true   true  false   true
    20. julia> x[mask]
    21. 5-element Array{Int64,1}:
    22.   1
    23.   2
    24.   4
    25.   8
    26.  16

    迭代

    迭代整个数组的推荐方法是

    1. for a in A
    2.     # Do something with the element a
    3. end
    5. for i in eachindex(A)
    6.     # Do something with i and/or A[i]
    7. end

    当你需要每个元素的值而不是索引时，使用第一个构造。 在第二个构造中，如果 A 是具有快速线性索引的数组类型，i 将是 Int; 否则，它将是一个 CartesianIndex：

    1. julia> A = rand(4,3);
    3. julia> B = view(A, 1:3, 2:3);
    5. julia> for i in eachindex(B)
    6.            @show i
    7.        end
    8. i = CartesianIndex(1, 1)
    9. i = CartesianIndex(2, 1)
    10. i = CartesianIndex(3, 1)
    11. i = CartesianIndex(1, 2)
    12. i = CartesianIndex(2, 2)
    13. i = CartesianIndex(3, 2)

    与 for i = 1:length(A) 相比，eachindex 提供了一种迭代任何数组类型的有效方法。

    Array traits

    如果你编写一个自定义的 AbstractArray 类型，你可以用以下代码指定它使用快速线性索引

    1. Base.IndexStyle(::Type{<:MyArray}) = IndexLinear()

    此设置将导致 myArray 上的 eachindex 迭代使用整数。如果未指定此特征，则使用默认值 IndexCartesian()。

    数组、向量化操作符及函数

    以下运算符支持对数组操作

    • 一元运算符 – -, +
    • 二元运算符 – -, +, *, /, \, ^
    • 比较操作符 – ==, !=, ≈ (isapprox), ≉
      当一个参数是标量时，上面列出的大多数二元算术运算符也可以按元素运行：当任一参数是标量时，-，+ 和 *；当分母是标量时，/ 和 \。例如，[1, 2] + 3 == [4, 5] 和 [6, 4] / 2 == [3, 2]。

    另外，为了便于数学上和其他运算的向量化，Julia f.(args…)，例如，sin.(x) 或 min.(x,y)，用于数组或数组和标量的混合上的按元素运算（@ref">Broadcasting运算）; 当与其他点调用（dot call）结合使用时，它们的额外优点是能“融合”到单个循环中，例如，sin.(cos.(x))。

    此外，每个二元运算符支持相应的，可以应用于此类融合 broadcasting 操作的数组（以及数组和标量的组合），例如 z .== sin.(x .* y)。

    请注意，类似 == 的比较运算在作用于整个数组时，得到一个布尔结果。使用像 .== 这样的点运算符进行按元素的比较。（对于像 < 这样的比较操作，只有按元素运算的版本 .< 适用于数组。）

    还要注意 max.(a,b) 和 之间的区别，max.(a,b) 对 a 和 b 的每个元素 broadcasts ，maximum(a) 寻找在 a 中的最大值。min.(a,b) 和 minimum(a) 也有同样的关系。

    有时需要在不同尺寸的数组上执行元素对元素的操作，例如将矩阵的每一列加一个向量。一种低效的方法是将向量复制成矩阵的大小：

    1. julia> a = rand(2,1); A = rand(2,3);
    3. julia> repeat(a,1,3)+A
    4. 2×3 Array{Float64,2}:
    5.  1.20813  1.82068  1.25387
    6.  1.56851  1.86401  1.67846

    当维度较大的时候，这种方法将会十分浪费，所以 Julia 提供了广播 ，它将会将参数中低维度的参数扩展，使得其与其他维度匹配，且不会使用额外的内存，并将所给的函数逐元素地应用。

    1. julia> broadcast(+, a, A)
    2. 2×3 Array{Float64,2}:
    3.  1.20813  1.82068  1.25387
    4.  1.56851  1.86401  1.67846
    6. julia> b = rand(1,2)
    7. 1×2 Array{Float64,2}:
    8.  0.867535  0.00457906
    10. julia> broadcast(+, a, b)
    11. 2×2 Array{Float64,2}:
    12.  1.71056  0.847604
    13.  1.73659  0.873631

    类似 .+ 和 .* 的点运算符 等同于 broadcast 调用（除了它们融合两种操作，如下所述）。还有一个 函数来指定一个显式目标（也可以通过 .= 赋值以融合的方式访问它）。而且，f.(args…) 等价于 broadcast(f, args…)，为广播任何函数提供了方便的语法（dot syntax）。嵌套的“点调用”f.(…)（包括调用 .+ 等）到一个 broadcast 调用。

    另外，broadcast 并不局限于数组（参见函数文档），对于元组依然有效。对于其他非数组，元组或引用 (除了指针 Ptr) 的参数，视作“标量”。

    1. julia> convert.(Float32, [1, 2])
    2. 2-element Array{Float32,1}:
    3.  1.0
    4.  2.0
    6. julia> ceil.((UInt8,), [1.2 3.4; 5.6 6.7])
    7. 2×2 Array{UInt8,2}:
    8.  0x02  0x04
    9.  0x06  0x07
    11. julia> string.(1:3, ". ", ["First", "Second", "Third"])
    12. 3-element Array{String,1}:
    13.  "1. First"
    14.  "2. Second"
    15.  "3. Third"

    实现

    Julia 中的基本数组类型是抽象类型 AbstractArray{T,N}。它通过维数 N 和元素类型 T 进行参数化。 和 AbstractMatrix 是一维和二维情况下的别名。AbstractArray 对象的操作是使用更高级别的运算符和函数定义的，其方式独立于底层存储。 这些操作通常能以任何特定数组实现的备选来正常工作。

    AbstractArray 类型包含任何模糊类似的东西，它的实现可能与传统数组完全不同。例如，可以根据请求而不是存储来计算元素。但是，任何具体的 AbstractArray{T,N} 类型通常应该至少实现 （返回 Int 元组），getindex(A,i) 和 ；可变数组也应该实现 setindex!。建议这些操作具有几乎恒定的时间复杂度，或严格说来 Õ(1) 复杂性，否则某些数组函数可能出乎意料的慢。具体类型通常还应提供 方法，用于为 copy 分配类似的数组和其他不正常的操作。无论在内部如何表示 AbstractArray{T,N}，T 是由 整数 索引返回的对象类型（A[1, …, 1]，当 A 不为空），N 应该是 返回的元组的长度。有关定义自定义 AbstractArray 实现的更多详细信息，请参阅@ref man-interface-array">接口章节中的数组接口导则。

    DenseArray 是 AbstractArray 的抽象子类型，旨在包含元素按列连续存储的所有数组（请参阅中的附加说明）。Array 类型是 DenseArray 的特定实例， 和 Matrix 是在一维和二维情况下的别名。除了所有 AbstractArray 所需的操作之外，很少有专门为 Array 实现的操作；大多数数组库都以通用方式实现，以保证所有自定义数组都具有相似功能。

    SubArray 是 AbstractArray 的特例，它通过与原始数组共享内存而不是复制它来执行索引。 使用 函数创建 SubArray，它的调用方式与getindex 相同（作用于数组和一系列索引参数）。 的结果看起来与 getindex 的结果相同，只是数据保持不变。 将输入索引向量存储在 SubArray 对象中，该对象稍后可用于间接索引原始数组。 通过将 @views"">@views 宏放在表达式或代码块之前，该表达式中的任何 array […] 切片将被转换为创建一个 SubArray 视图。

    是节省空间“压缩”的布尔数组，每个比特（bit）存储一个布尔值。 它们可以类似于 Array{Bool} 数组（每个字节（byte）存储一个布尔值），并且可以分别通过 Array(bitarray) 和 BitArray(array) 相互转换。

    “strided”数组存储在内存中，元素以常规偏移量排列，因此有 isbits 元素类型的实例可以被传递给期望此内存布局的外部C和Fortran函数。Strided arrays 必须定义一个 strides(A) 方法，该方法为每个维返回一个“strides”元组；提供 方法访问该元组中的第 k 个元素。将维数 k 的索引增加 1 应该把 getindex(A,i) 得到的索引 i 增加。如果提供了指针转换方法Base.unsafe_convert(Ptr{T}, A)，则内存布局必须以与这些间隔相同的方式对应。 DenseArray 是一个非常具体的 strided 数组示例，其中元素是连续排列的，因此它为子类提供了适当的 “strides” 定义。更多具体的例子可以在 man-interface-strided-arrays">strided arrays的接口指南 中找到。 StridedVector 和 是许多算是 strided arrays 的内置数组类型的便捷别名，允许它们只使用指针和stride派发，选择调用专业实现的，高度调试和优化的 BLAS 和 LAPACK 函数。

    接下来的例子计算一个大数组中一小部分的 QR 分解，不需要引入任何临时变量。通过正确的维度大小和偏移参数调用合适的 LAPACK 函数。

    1. julia> a = rand(10, 10)
    2. 10×10 Array{Float64,2}:
    3.  0.517515  0.0348206  0.749042   0.0979679  …  0.75984     0.950481   0.579513
    4.  0.901092  0.873479   0.134533   0.0697848     0.0586695   0.193254   0.726898
    5.  0.976808  0.0901881  0.208332   0.920358      0.288535    0.705941   0.337137
    6.  0.657127  0.0317896  0.772837   0.534457      0.0966037   0.700694   0.675999
    7.  0.471777  0.144969   0.0718405  0.0827916     0.527233    0.173132   0.694304
    8.  0.160872  0.455168   0.489254   0.827851   …  0.62226     0.0995456  0.946522
    9.  0.291857  0.769492   0.68043    0.629461      0.727558    0.910796   0.834837
    10.  0.775774  0.700731   0.700177   0.0126213     0.00822304  0.327502   0.955181
    11.  0.9715    0.64354    0.848441   0.241474      0.591611    0.792573   0.194357
    12.  0.646596  0.575456   0.0995212  0.038517      0.709233    0.477657   0.0507231
    14. julia> b = view(a, 2:2:8,2:2:4)
    15. 4×2 view(::Array{Float64,2}, 2:2:8, 2:2:4) with eltype Float64:
    16.  0.873479   0.0697848
    17.  0.0317896  0.534457
    18.  0.455168   0.827851
    19.  0.700731   0.0126213
    21. julia> (q, r) = qr(b);
    23. julia> q
    24. 4×4 LinearAlgebra.QRCompactWYQ{Float64,Array{Float64,2}}:
    25.  -0.722358    0.227524  -0.247784    -0.604181
    26.  -0.0262896  -0.575919  -0.804227     0.144377
    27.  -0.376419   -0.75072    0.540177    -0.0541979
    28.  -0.579497    0.230151  -0.00552346   0.781782
    30. julia> r
    31. 2×2 Array{Float64,2}:
    32.  -1.20921  -0.383393