数组

构造函数和类型

# ’核心。AbstractArray'*—Type

AbstractArray{T,N}

`N`维数组（或类数组类型）的超类型，元素类型为`T'。 'Array'和其他类型都是这种类型的子类型。请参阅手册的接口部分。 'AbstractArray'。

另请参阅说明 AbstractVector', 'AbstractMatrix, 'eltype', 'ndims'。

# '基。AbstractVector'—Type

AbstractVector{T}

具有`T’类型元素的一维数组（或类数组类型）的超类型。的别名 '抽象阵列{T,1}`.

# '基。AbstractMatrix'-Type

AbstractMatrix{T}

具有类型为`T’的元素的二维数组（或类数组类型）的超类型。的别名 '抽象阵列{T,2}`.

# '基。AbstractVecOrMat'-Type

AbstractVecOrMat{T}

协会类型 'AbstractVector{T}'和 'AbstractMatrix{T}`.

# ’核心。数组'*-Type</no-翻译>

Array{T,N} <: AbstractArray{T,N}

'N’是一个密集的三维数组，具有类型为`T`的元素。

# ’核心。数组'*-Method</no-翻译>

Array{T}(undef, dims)
Array{T,N}(undef, dims)

创建未初始化的’N’维数组 Array'包含类型为`T’的元素。 `N’可以显式提供，如’Array{T,N}(undef，dims)，或者由`dims’的长度或数量确定。 'dims’可以是元组或一系列与每个维度中的长度相对应的整数参数。如果显式指定了"N"的秩，则它必须与"dims"的长度或数量相匹配。这里 'undef'是一种类型 'UndefInitializer'。

例子

julia> A = Array{Float64, 2}(undef, 2, 3) # N задан явным образом
2×3 Matrix{Float64}:
 6.90198e-310  6.90198e-310  6.90198e-310
 6.90198e-310  6.90198e-310  0.0

julia> B = Array{Float64}(undef, 4) # N определен входными данными
4-element Vector{Float64}:
   2.360075077e-314
 NaN
   2.2671131793e-314
   2.299821756e-314

julia> similar(B, 2, 4, 1) # использовать typeof(B) и заданный размер
2×4×1 Array{Float64, 3}:
[:, :, 1] =
 2.26703e-314  2.26708e-314  0.0           2.80997e-314
 0.0           2.26703e-314  2.26708e-314  0.0

# ’核心。数组'*-Method</no-翻译>

Array{T}(nothing, dims)
Array{T,N}(nothing, dims)

创建一个`N’维数组 Array'包含用值初始化的类型为`T’的元素 '没什么。元素类型’T’必须能够存储这些值，即`Nothing<:T`。

例子

julia> Array{Union{Nothing, String}}(nothing, 2)
2-element Vector{Union{Nothing, String}}:
 nothing
 nothing

julia> Array{Union{Nothing, Int}}(nothing, 2, 3)
2×3 Matrix{Union{Nothing, Int64}}:
 nothing  nothing  nothing
 nothing  nothing  nothing

# ’核心。数组'*-Method</no-翻译>

Array{T}(missing, dims)
Array{T,N}(missing, dims)

创建一个`N’维数组 Array'包含用值初始化的类型为`T’的元素 '失踪。元素类型’T’必须能够存储这些值，即`Missing<:T`。

例子

julia> Array{Union{Missing, String}}(missing, 2)
2-element Vector{Union{Missing, String}}:
 missing
 missing

julia> Array{Union{Missing, Int}}(missing, 2, 3)
2×3 Matrix{Union{Missing, Int64}}:
 missing  missing  missing
 missing  missing  missing

# ’核心。UndefInitializer'*-Type

UndefInitializer

初始化数组并指示数组构造函数的调用方需要未初始化的数组时使用的单个类型。另请参阅说明 undef，'UndefInitializer()'的别名。

例子

julia> Array{Float64, 1}(UndefInitializer(), 3)
3-element Array{Float64, 1}:
 2.2752528595e-314
 2.202942107e-314
 2.275252907e-314

# '核心。undef'-Constant</no-翻译>

undef

'UndefInitializer(’的别名，它创建单个类型的实例 'UndefInitializer'，在数组初始化期间使用，用于指示数组构造函数的调用者需要未初始化的数组。

另请参阅说明 '失踪`, '相似`。

例子

julia> Array{Float64, 1}(undef, 3)
3-element Vector{Float64}:
 2.2752528595e-314
 2.202942107e-314
 2.275252907e-314

# '基。向量'-Type</no-翻译>

Vector{T} <: AbstractVector{T}

具有类型为`T’的元素的一维密集数组，通常用于表示数学向量。的别名 '阵列{T,1}`.

另请参阅功能说明 '空`, '相似`和 `零'创建向量。

# '基。向量'-Method

Vector{T}(undef, n)

创建未初始化的向量 '向量{T}'长度为’n'。

例子

julia> Vector{Float64}(undef, 3)
3-element Array{Float64, 1}:
 6.90966e-310
 6.90966e-310
 6.90966e-310

# '基。向量'-Method

Vector{T}(nothing, m)

创建向量 '向量{T}长度为`m`的'，用值初始化 '没什么`。元素类型’T’必须能够存储这些值，即`Nothing<:T`。

例子

julia> Vector{Union{Nothing, String}}(nothing, 2)
2-element Vector{Union{Nothing, String}}:
 nothing
 nothing

# '基。向量'-Method

Vector{T}(missing, m)

创建向量 '向量{T}长度为`m`的'，用值初始化 '失踪'。元素类型’T’必须能够存储这些值，即`Missing<:T`。

例子

julia> Vector{Union{Missing, String}}(missing, 2)
2-element Vector{Union{Missing, String}}:
 missing
 missing

# '基。矩阵'-Type

Matrix{T} <: AbstractMatrix{T}

具有类型为`T’的元素的二维密集数组，通常用于表示数学矩阵。的别名 '阵列{T,2}`.

另请参阅功能说明 '填充', '零`, 'undef'和 `类似'创建矩阵。

# '基。矩阵'-Method

Matrix{T}(undef, m, n)

创建未初始化的矩阵 '矩阵{T}'的大小`m'×'n'。

例子

julia> Matrix{Float64}(undef, 2, 3)
2×3 Array{Float64, 2}:
 2.36365e-314  2.28473e-314    5.0e-324
 2.26704e-314  2.26711e-314  NaN

julia> similar(ans, Int32, 2, 2)
2×2 Matrix{Int32}:
 490537216  1277177453
         1  1936748399

# '基。矩阵'-Method

Matrix{T}(nothing, m, n)

创建矩阵 '矩阵{T}'大小为’m`×'n'，用值初始化 '没什么`。元素类型’T’必须能够存储这些值，即`Nothing<:T`。

例子

julia> Matrix{Union{Nothing, String}}(nothing, 2, 3)
2×3 Matrix{Union{Nothing, String}}:
 nothing  nothing  nothing
 nothing  nothing  nothing

# '基。矩阵'-Method

Matrix{T}(missing, m, n)

创建矩阵 '矩阵{T}'大小为’m`×'n'，用值初始化 '失踪'。元素类型’T’必须能够存储这些值，即`Missing<:T`。

例子

julia> Matrix{Union{Missing, String}}(missing, 2, 3)
2×3 Matrix{Union{Missing, String}}:
 missing  missing  missing
 missing  missing  missing

# '基。VecOrMat'-Type

VecOrMat{T}

协会类型 '向量{T}'和 '矩阵{T}'，它允许函数接受矩阵或向量。

例子

julia> Vector{Float64} <: VecOrMat{Float64}
true

julia> Matrix{Float64} <: VecOrMat{Float64}
true

julia> Array{Float64, 3} <: VecOrMat{Float64}
false

# '核心。DenseArray'-Type

DenseArray{T, N} <: AbstractArray{T,N}

'N’是一个密集的三维数组，具有类型为`T`的元素。密集阵列的元素以连续序列存储在内存中。

# '基。DenseVector`-Type

DenseVector{T}

一维数组 DenseArray类型为’T’的元素。 'DenseArray的别名{T,1}`.

# '基。DenseMatrix'-Type

DenseMatrix{T}

二维数组 DenseArray类型为’T’的元素。 'DenseArray的别名{T,2}`.

# '基。DenseVecOrMat'-Type

DenseVecOrMat{T}

协会类型 'DenseVector{T}'和 'DenseMatrix{T}`.

# '基。StridedArray'-Type

StridedArray{T, N}

硬编码类型 `Union'后面常见的数组类型带步骤的数组接口，具有类型为`T`和`N`维的元素。

如果`A’是’StridedArray'，那么它的元素存储在内存中，偏移量可能在不同的维度上不同，但在相同的维度内是恒定的。例如，`A’可以在维度1中具有2的阵列步长，在维度2中具有3的阵列步长。当在维度`d`中递增`A`时，内存被切换到[`stride(A,d)']插槽。具有给定步骤的数组尤其重要和有用，因为有时它们可以直接作为指向其他语言（如BLAS）的库的指针传递。

# '基。StridedVector'—Type

StridedVector{T}

一维数组 StridedArray类型为’T’的元素。

# '基。StridedMatrix'-Type

StridedMatrix{T}

二维数组 StridedArray类型为’T’的元素。

# '基。StridedVecOrMat'-Type

StridedVecOrMat{T}

协会类型 StridedVector'和 `StridedMatrix类型为’T’的元素。

# ’核心。GenericMemory'*—Type

GenericMemory{kind::Symbol, T, addrspace=Core.CPU} <: DenseVector{T}

向量资料 'DenseVector{T}定尺寸的`。

目前，'kind’可以具有值`：not_atomic`或'：atomic'。有关`:atomic’值的更多信息，请参阅说明 '原子记忆`

目前，只有核心。CPU可以设置为"addrspace"。这个论点暗示了其他系统扩展的可能性，例如Gpu，它可以定义例如以下值:

module CUDA
const Generic = bitcast(Core.AddrSpace{CUDA}, 0)
const Global = bitcast(Core.AddrSpace{CUDA}, 1)
end

这些额外地址空间的确切含义由特定的后端决定，但如果用户在CPU上运行时尝试访问它们，则会发生错误。

兼容性：Julia1.11

这种类型要求Julia版本不低于1.11。

# ’核心。内存'*-Type</no-翻译>

Memory{T} == GenericMemory{:not_atomic, T, Core.CPU}

向量资料 'DenseVector{T}定尺寸的`。

兼容性：Julia1.11

这种类型要求Julia版本不低于1.11。

# ’核心。memoryref'*-Function

`memoryref(::GenericMemory)`

基于内存对象创建一个"GenericMemoryRef"。不会发生错误，但只有当内存为空时，生成的引用才会指向允许范围之外的内存区域。

memoryref(::GenericMemory, index::Integer)
memoryref(::GenericMemoryRef, index::Integer)

根据内存对象和偏移索引（从1开始）创建一个`GenericMemoryRef`，也可以是负数。它总是返回边界内的对象，如果这是不可能的，则返回错误（因为索引将导致基本内存之外的偏移）。

# '基。切片'-Type

Slices{P,SM,AX,S,N} <: AbstractSlices{S,N}

给定更改（维度）的父数组的`AbstractArray`切片数组，返回从另一个维度（维度）中选择所有数据的视图。

它们通常使用 '每个单子`, 'eachcol'或 'eachrow'。

`parent(s::Slices)'返回父数组。

# '基。RowSlices'-Type

RowSlices{M,AX,S}

一个特例 'Slices'，它是使用以下方法构造的矩阵行的切片的向量 'eachrow'。

'parent`可用于获取基矩阵。

# '基。ColumnSlices'-Type

ColumnSlices{M,AX,S}

一个特例 'Slices'，它是使用以下方法构造的矩阵列的切片的向量 'eachcol'。

'parent`可用于获取基矩阵。

# '基。getindex`-Method

getindex(type[, elements...])

创建指定类型的一维数组。它通常使用语法"Type[]"调用。元素的值可以使用`Type[a,b,c,...]`.

例子

julia> Int8[1, 2, 3]
3-element Vector{Int8}:
 1
 2
 3

julia>getindex(Int8,1,2,3)
3元素向量{Int8}:
 1
 2
 3

# '基。零`-Function

zeros([T=Float64,] dims::Tuple)
zeros([T=Float64,] dims...)

创建一个数组’Array'，元素类型为’T`，只包含零，大小为’dims'。另请参阅说明 '填充', 一'和 '零。

例子

julia> zeros(1)
1-element Vector{Float64}:
 0.0

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

# '基。ones'-Function

ones([T=Float64,] dims::Tuple)
ones([T=Float64,] dims...)

创建一个数组’Array'，元素类型为’T`，包含一个单元，大小为’dims'。另请参阅说明 '填充'和 '零`。

例子

julia> ones(1,2)
1×2 Matrix{Float64}:
 1.0  1.0

julia> ones(ComplexF64, 2, 3)
2×3 Matrix{ComplexF64}:
 1.0+0.0im  1.0+0.0im  1.0+0.0im
 1.0+0.0im  1.0+0.0im  1.0+0.0im

# '基。BitArray'-Type

BitArray{N} <: AbstractArray{Bool, N}

一个紧凑的’N’维逻辑数组，每个逻辑值只使用一个位。

"BitArray"将多达64个值打包到每8个字节中，与"数组"相比，这导致了8倍的空间效率{Bool, N}`并允许一些操作同时使用64个值。

默认情况下，Julia从操作返回’BitArrays 翻译（包括用虚线进行比较，类似于`。==`），以及从函数 `trues'和 '虚假'。

由于打包的存储格式，对"BitArray"元素的同时访问操作（其中至少有一个是写操作）不是线程安全的。

# '基。BitArray'—Method

BitArray(undef, dims::Integer...)
BitArray{N}(undef, dims::NTuple{N,Int})

创建未定义的数组 `BitArray'。它的工作原理类似于构造函数 '数组'。请参阅描述 'undef'。

例子

julia> BitArray(undef, 2, 2)
2×2 BitMatrix:
 0  0
 0  0

julia>BitArray（undef，（3，1））
3×1比特矩阵:
 0
 0
 0

# '基。BitArray'—Method

BitArray(itr)

创建数组 `BitArray'由指定的可迭代对象生成。表单派生自’itr’对象。

例子

julia> BitArray([1 0; 0 1])
2×2 BitMatrix:
 1  0
 0  1

julia> BitArray(x+y == 3 for x = 1:2, y = 1:3)
2×3 BitMatrix:
 0  1  0
 1  0  0

julia> BitArray(x+y == 3 for x = 1:2 for y = 1:3)
6-element BitVector:
 0
 1
 0
 1
 0
 0

# '基。trues'-Function

trues(dims)

创建一个’BitArray’数组，所有值都设置为’true'。

例子

julia> trues(2,3)
2×3 BitMatrix:
 1  1  1
 1  1  1

# '基。falses'-Function

falses(dims)

创建一个’BitArray’数组，所有值都设置为’false'。

例子

julia> falses(2,3)
2×3 BitMatrix:
 0  0  0
 0  0  0

# '基。填写'-Function

fill(value, dims::Tuple)
fill(value, dims...)

创建一个大小为"dims"的数组，其中每个位置都被分配一个值为"value"。

例如，'fill(1.0,(5.5))返回一个5×5的浮点数数组，每个位置的值为`1.0。

"Dims"维度的长度可以设置为元组或参数序列。在`value`之后的长度为`N`或`N’参数的元组设置一个’N’维数组。因此，创建具有指定为`x`的单个位置的零维数组的常用方法是’fill(x)'。

返回数组的每个位置都被分配传递的值’value`，该位置将与（===). 这意味着当您更改’值’本身时，此更改将反映在应用`fill`函数的数组的所有元素中，因为它们仍然是相同的`值'。这与`fill(1.0,(5.5))`无关，因为`value`1.0的值是不可变的，不能自己改变。但是，当使用可变值时，例如（最常见的）数组，结果可能是意外的。例如，调用’fill([],3)`将相同的空数组放在返回向量的所有三个位置。:

julia> v = fill([], 3)
3-element Vector{Vector{Any}}:
 []
 []
 []

julia> v[1] === v[2] === v[3]
true

julia> value = v[1]
Any[]

julia> push!(value, 867_5309)
1-element Vector{Any}:
 8675309

julia> v
3-element Vector{Vector{Any}}:
 [8675309]
 [8675309]
 [8675309]

要创建多个独立内部数组的数组，请使用启用。在这种情况下，在循环的每次迭代中创建一个新的单独数组。:

julia> v2 = [[] for _ in 1:3]
3-element Vector{Vector{Any}}:
 []
 []
 []

julia> v2[1] === v2[2] === v2[3]
false

julia> push!(v2[1], 8675309)
1-element Vector{Any}:
 8675309

julia> v2
3-element Vector{Vector{Any}}:
 [8675309]
 []
 []

另请参阅说明 '填充！, '零, '一`, '相似`。

例子

julia> fill(1.0, (2,3))
2×3 Matrix{Float64}:
 1.0  1.0  1.0
 1.0  1.0  1.0

julia> fill(42)
0-dimensional Array{Int64, 0}:
42

julia> A = fill(zeros(2), 2) # задает для обоих элементов один и тот же 向量 [0.0, 0.0]
2-element Vector{Vector{Float64}}:
 [0.0, 0.0]
 [0.0, 0.0]

julia> A[1][1] = 42; # изменяет заполненное значение на [42.0, 0.0]

julia> A # A[1] и A[2] являются одним и тем же 向量ом
2-element Vector{Vector{Float64}}:
 [42.0, 0.0]
 [42.0, 0.0]

# '基。填满！`-Function</no-翻译>

fill!(A, x)

用值"x"填充数组"A"。如果’x’是对一个对象的引用，则所有对象都将引用同一个对象。 "填满！(A,Foo())返回一个数组`A，其中填充了`Foo()'的单个计算结果。

例子

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

julia> fill!(A, 2.)
2×3 Matrix{Float64}:
 2.0  2.0  2.0
 2.0  2.0  2.0

julia> a = [1, 1, 1]; A = fill!(Vector{Vector{Int}}(undef, 3), a); a[1] = 2; A
3-element Vector{Vector{Int64}}:
 [2, 1, 1]
 [2, 1, 1]
 [2, 1, 1]

julia> x = 0; f() = (global x += 1; x); fill!(Vector{Int}(undef, 3), f())
3-element Vector{Int64}:
 1
 1
 1

# '基。空`-Function

empty(x::Tuple)

返回一个空元组`()`。

empty(v::AbstractVector, [eltype])

创建一个类似于`v’的空向量，必要时更改`eltype`。

另请参阅说明 '空！, '空位, 'isassigned'。

例子

julia> empty([1.0, 2.0, 3.0])
Float64[]

julia> empty([1.0, 2.0, 3.0], String)
String[]

empty(a::AbstractDict, [index_type=keytype(a)], [value_type=valtype(a)])

创建一个空容器"AbstractDict"，它可以接受类型为"index_type"的索引和类型为"value_type"的值。第二个和第三个参数是可选的，默认情况下分别具有输入数据的值"keytype"和"valtype"。（如果只指定了两种类型中的一种，则假设它是`value_type`，并且对于`index_type`，默认情况下将使用`keytype(a)`。)

'AbstractDict’的自定义子类型可以通过专门化三参数签名来选择哪种特定的字典类型最适合返回指定的索引和值类型。默认情况下，返回一个空的’Dict'。

# '基。类似`-Function

similar(A::AbstractSparseMatrixCSC{Tv,Ti}, [::Type{TvNew}, ::Type{TiNew}, m::Integer, n::Integer]) where {Tv,Ti}

根据指定的源对象`SparseMatrixCSC’创建具有指定元素类型、索引类型和大小的未初始化可变数组。新的稀疏矩阵保留原始稀疏矩阵的结构，除非输出矩阵的测量值与输出数据不同。

输出矩阵在与输入矩阵相同的位置具有零，但在非零位置具有未初始化的值。

similar(array, [element_type=eltype(array)], [dims=size(array)])

根据指定的源数组创建具有指定元素类型和大小的未初始化可变数组。第二个和第三个参数是可选的，并且具有指定数组的默认值`eltype`和`size'。维度既可以指定为单个元组参数，也可以指定为一系列整数参数。

自定义AbstractArray子类型可以选择哪种特定字典类型最适合返回给定元素类型和维度。如果他们没有专门化这个方法，默认情况下使用'Array'。{element_type}（undef，dims。..)`.

例如，'类似(1:10, 1, 4)` 返回未初始化数组的数组{Int,2}因为范围是不可更改的，并且不支持二维:

julia> similar(1:10, 1, 4)
1×4 Matrix{Int64}:
 4419743872  4374413872  4419743888  0

相反’similar(trues(10,10),2)`返回一个包含两个元素的未初始化的`BitVector`向量，因为`BitArray`是可变的并且可以支持一维数组。:

julia> similar(trues(10,10), 2)
2-element BitVector:
 0
 0

因为’BitArray’只能存储类型的元素 'Bool'，如果你请求一个不同类型的元素，一个常规的’数组`将被创建:

julia> similar(falses(10), Float64, 2, 4)
2×4 Matrix{Float64}:
 2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314
 2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314

另请参阅说明 'undef', 'isassigned'。

similar(storagetype, axes)

创建一个未初始化的可变数组，类似于使用`storagetype’指定的数组，但将`axes’设置为最后一个参数。

例子:

similar(Array{Int}, axes(A))

创建一个充当`数组的数组{Int}'（并且确实可以基于它），但索引与`A’相同。如果’A’具有常规索引，它将与`Array相同{Int}(undef,size(A))`，但如果`A`具有非传统索引，那么结果索引将与`A`匹配。

similar(BitArray, (axes(A, 2),))

创建一个一维逻辑数组，其索引与列`A’的索引匹配。

主要功能

# '基。ndims`-Function

ndims(A::AbstractArray) -> Integer

返回’a’的维数。

另请参阅说明 '尺寸', '轴'。

例子

julia> A = fill(1, (3,4,5));

julia> ndims(A)
3

# '基。尺寸'-Function

size(A::AbstractArray, [dim])

返回包含维度`A’的元组。如有必要，您可以指定一个维度以仅获取该维度的长度。

请注意，对于具有非标准索引的数组，可能未定义`size’函数。在这种情况下，该方法可能是有用的 '轴'。请参阅手册章节带有自定义索引的数组。

另请参阅说明 '长度', 'ndims', '每个索引`, 'sizeof'。

例子

julia> A = fill(1, (2,3,4));

julia> size(A)
(2, 3, 4)

julia> size(A, 2)
3

# '基。轴'-Method</no-翻译>

axes(A)

返回数组`A’的有效索引元组。

另请参阅说明 '尺寸', '钥匙`, 'eachindex'。

例子

julia> A = fill(1, (5,6,7));

julia> axes(A)
(Base.OneTo(5), Base.OneTo(6), Base.OneTo(7))

# '基。轴'-Method</no-翻译>

axes(A, d)

返回维度"d"中数组"A"允许的索引范围。

另请参阅功能说明 'size'和手册章节关于带有自定义索引的数组。

例子

julia> A = fill(1, (5,6,7));

julia> axes(A, 2)
Base.OneTo(6)

julia> axes(A, 4) == 1:1  # все измерения d > ndims(A) имеют размер, равный 1
true

使用须知

每个索引都应该是一个’AbstractUnitRange{<:Integer}`，但与此同时它可以有一个使用自定义索引的类型。因此，例如，如果您需要一个子集，请使用广义索引构造，如’begin'/'end’或 'firstindex'/'lastindex':

ix = axes(v, 1)
ix[2:end]          # будет работать для, например, 向量а, но может завершиться сбоем в общем случае
ix[(begin+1):end]  # работает для обобщенных индексов

# '基。长度'-Method

length(A::AbstractArray)

返回数组中元素的数量；默认情况下，使用’prod(size(A))`。

例子

julia> length([1, 2, 3, 4])
4

julia> length([1 2; 3 4])
4

# '基。键'-Method</no-翻译>

keys(a::AbstractArray)

返回一个高效数组，以`a`本身的形式描述`a`的所有有效索引。

一维数组（向量）的键是整数，而所有其他N维数组使用 'CartesianIndex'来描述你的立场。通常特殊类型的数组 'LinearIndices'和 'CartesianIndices`分别用于有效地表示这些整数数组和’CartesianIndex'。

请注意，数组的’键’可能不是最有效的索引类型。为了达到最大的性能，使用 'eachindex'。

例子

julia> keys([4, 5, 6])
3-element LinearIndices{1, Tuple{Base.OneTo{Int64}}}:
 1
 2
 3

julia> keys([4 5; 6 7])
CartesianIndices((2, 2))

# '基。每个索引'-Function</no-翻译>

eachindex(A...)
eachindex(::IndexStyle, A::AbstractArray...)

创建一个可迭代对象，以便高效遍历`AbstractArray``A’的每个索引。对于具有快速线性索引的数组类型（例如`Array'），如果它们使用从一个索引，则这只是范围`1：length（A）`。对于没有快速线性索引的数组类型，通常会返回专门的笛卡尔范围以进行有效的数组索引，并为每个维度指定索引。

通常’eachindex’接受任意可迭代对象，包括字符串和字典，并返回支持任意类型索引（例如，不均匀分布或非整数索引）的迭代器对象。

如果`A’是’AbstractArray`，则可以通过传递`IndexStyle`类型值作为第一个参数（如果需要线性索引，通常为`IndexLinear()，或者如果需要笛卡尔范围，则为`IndexCartesian()）来显式指定`eachindex`函数返回的索引的样式。

如果您为"AbstractArray"指定了多个参数，则"eachindex"将创建一个可迭代对象，该对象对所有参数都很快（通常 'UnitRange'，如果所有输入数据具有快速线性索引，或 'CartesianIndices'否则）。如果数组具有不同的大小和/或维度，则会发生’DimensionMismatch’异常。

另请参阅说明 pairs(A)'用于组合索引和值迭代和描述 `axes`(A,2)'表示一维中的有效索引。

例子

julia> A = [10 20; 30 40];

julia> for i in eachindex(A) # линейное индексирование
           println("A[", i, "] == ", A[i])
       end
A[1] == 10
A[2] == 30
A[3] == 20
A[4] == 40

julia> for i in eachindex(view(A, 1:2, 1:1)) # декартово индексирование
           println(i)
       end
CartesianIndex(1, 1)
CartesianIndex(2, 1)

# '基。IndexStyle'-Type

IndexStyle(A)
IndexStyle(typeof(A))

'IndexStyle`为数组’A’设置自定义索引样式。定义新类型时 'AbstractArray'可以实现为线性索引（使用 'IndexLinear')，或笛卡尔索引。如果决定仅实现线性索引，则必须为数组类型指定此点。:

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

默认情况下，它被使用 'IndexCartesian()`。

Julia的内部索引引擎会自动（并且在不知不觉中）将所有索引操作重新计算为您的首选样式。这允许用户使用任何索引样式访问数组的元素，即使未提供显式方法也是如此。

如果您已经为`AbstractArray`定义了两种索引样式，则可以使用此功能选择最有效的索引样式。一些方法在其输入数据中检查此功能，并根据最有效的访问方案执行调度到各种算法中。特别是, 'eachindex'创建一个迭代器，其类型取决于此属性的指示。

# '基。IndexLinear'-Type

IndexLinear()

子类型 'IndexStyle'，用于描述由单个线性索引优化索引的数组。

线性索引样式使用单个整数索引来描述数组中的位置（即使它是多维数组），并且使用列排序来有效地访问元素。这意味着当请求 'eachindex'一个简单的一维范围将从一个`IndexLinear`的数组返回，即使它是多维的。

将其`IndexStyle`报告为`IndexLinear`的自定义数组必须仅使用一个`Int`索引实现索引（和索引分配）。所有其他索引表达式（包括多维访问）都将转换为线性索引。例如，如果数组’A’是用户定义的具有线性索引的'2×3’矩阵，并且我们访问了索引’A[1,3]，则它将通过调用`A[5]'重新计算为等效的线性索引，因为`1 + 2*(3 - 1) = 5.

另请参阅说明 'IndexCartesian`。

# '基。IndexCartesian`-Type

IndexCartesian()

子类型 'IndexStyle'，用于描述由单个笛卡尔索引优化索引的数组。默认情况下用于新的自定义子类型。 'AbstractArray'。

笛卡尔索引样式使用多个整数索引来描述多维数组中的位置，每个维度只有一个索引。这意味着当请求 eachindex将从一个`IndexCartesian’的数组返回一个范围 'CartesianIndices'。

将其`IndexStyle`报告为`IndexCartesian`的自定义`N’维数组必须使用`Int`的`N’索引实现索引（和索引分配）。所有其他索引表达式，包括线性索引，都将重新计算为等效的笛卡尔布局。例如，如果数组’A’是一个带有笛卡尔索引的自定义2×3矩阵，并且我们访问了索引’A[5]，则它将被重新计算为调用`A[1,3]'的等效笛卡尔索引，因为`5 = 1 + 2*(3 - 1).

从线性索引计算笛卡尔索引要昂贵得多。第一个操作需要除法（一个非常昂贵的操作），而第二个只使用乘法和加法，所以它本质上是免费的。这种不对称性意味着使用`IndexCartesian`数组使用线性索引比使用`IndexLinear`数组使用笛卡尔索引要昂贵得多。

另请参阅说明 'IndexLinear'。

# '基。conj！`-Function</no-翻译>

conj!(A)

将数组转换为其复共轭值。

另请参阅说明 'conj'。

例子

julia> A = [1+im 2-im; 2+2im 3+im]
2×2 Matrix{Complex{Int64}}:
 1+1im  2-1im
 2+2im  3+1im

julia> conj!(A);

julia> A
2×2 Matrix{Complex{Int64}}:
 1-1im  2+1im
 2-2im  3-1im

# '基。stride'-Function

stride(A, k::Integer)

返回维度`k’中相邻元素之间的内存距离（以元素数量的形式）。

另请参阅说明 '大步'。

例子

julia> A = fill(1, (3,4,5));

julia> stride(A,2)
3

julia> stride(A,3)
12

# '基。strides`-Function

strides(A)

返回每个维度中的内存步长元组。

另请参阅说明 '大步'。

例子

julia> A = fill(1, (3,4,5));

julia> strides(A)
(1, 3, 12)

翻译和矢量化

另请参阅该部分矢量化函数的点分隔语法。例如，f.(args...）+`隐式调用'+广播（f，args。..). 而不是依靠"矢量化"函数方法，如`sin`来处理数组，你应该使用`sin。(a)`通过`广播’进行矢量化。

# '基。广播。广播`-Function

broadcast(f, As...)

在数组，元组，集合，类型中翻译函数`f` `Ref'和（或）标量’As'。

转换将函数`f’应用于容器参数的元素和`As’中的标量本身。单个维度和缺失维度根据其他参数的大小进行扩展，实际上重复了该值。默认情况下，只有有限数量的类型被视为标量，包括`Number`，'String`，'Symbol`，'Type'，'Function’和其他一些常见的单一类型，例如 '失踪'和 '没什么`。所有其他参数都是逐元素迭代或索引的。

生成的容器类型由以下规则确定。

如果所有参数都是标量或零维数组，则返回没有shell的标量。
如果至少有一个参数是元组，而所有其他参数都是标量或零维数组，则返回一个元组。
所有其他参数组合默认返回’Array`，但自定义容器类型可以定义自己的实现和提升规则，以便在它们用作参数时自定义结果。

翻译有一个特殊的语法’f.(args...)'相当于'broadcast(f,args...)`，以及嵌套调用'f.(g.(args...))'合并为一个广播周期。

例子

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

julia> B = [1 2; 3 4; 5 6; 7 8; 9 10]
5×2 Matrix{Int64}:
 1   2
 3   4
 5   6
 7   8
 9  10

julia> broadcast(+, A, B)
5×2 Matrix{Int64}:
  2   3
  5   6
  8   9
 11  12
 14  15

julia> parse.(Int, ["1", "2"])
2-element Vector{Int64}:
 1
 2

julia> abs.((1, -2))
(1, 2)

julia> broadcast(+, 1.0, (0, -2.0))
(1.0, -1.0)

julia> (+).([[0,2], [1,3]], Ref{Vector{Int}}([1,-1]))
2-element Vector{Vector{Int64}}:
 [1, 1]
 [2, 2]

julia> string.(("one","two","three","four"), ": ", 1:4)
4-element Vector{String}:
 "one: 1"
 "two: 2"
 "three: 3"
 "four: 4"

# '基。广播。广播！`-Function</no-翻译>

broadcast!(f, dest, As...)

同样地 'broadcast'，但存储结果'broadcast(f,As。..）在’dest’数组中。请注意，`dest’数组仅用于存储结果，并且不为`f`提供参数，除非在`As’中指定，例如’broadcast！(f,A,A,B)，执行`A[:]=broadcast(f,A,B)`。

例子

julia> A = [1.0; 0.0]; B = [0.0; 0.0];

julia> broadcast!(+, B, A, (0, -2.0));

julia> B
2-element Vector{Float64}:
  1.0
 -2.0

julia> A
2-element Vector{Float64}:
 1.0
 0.0

julia> broadcast!(+, A, A, (0, -2.0));

julia> A
2-element Vector{Float64}:
  1.0
 -2.0

# '基。广播。@__dot__`-Macro

@. expr

将`expr’中的每个函数调用或语句转换为’点调用`（例如，将`f(x)转换为`f.(x)），并将`expr’中的每个赋值转换为’点赋值`（例如，将`=`转换为'。=`).

要_not_将选定函数调用的这些点添加到’expr`，请在调用中使用'$'。例如，调用'@。 sqrt(abs($sort(x)))相当于`sqrt。（abs。(sort(x)))(`sort’没有点)。

('@.'相当于调用'@__dot__'。)

例子

julia> x = 1.0:3.0; y = similar(x);

julia> @. y = x + 3 * sin(x)
3-element Vector{Float64}:
 3.5244129544236893
 4.727892280477045
 3.4233600241796016

有关用户定义类型的专用转换的信息，请参阅以下类型的描述:

# '基。广播。BroadcastStyle'-Type

'BroadcastStyle’是一种抽象类型和跟踪函数，用于确定广播期间对象的行为。 'BroadcastStyle(typeof(x))`返回与’x’关联的样式。要在翻译过程中自定义类型行为，可以通过定义类型/方法对来声明样式。

struct MyContainerStyle <: BroadcastStyle end
Base.BroadcastStyle(::Type{<:MyContainer}) = MyContainerStyle()

然后创建方法（至少 类似)在'广播中工作{MyContainerStyle}`. 有几个预定义的"BroadcastStyle"子类型可供使用。有关详细信息，请参阅到"接口"一章。

# '基。广播。AbstractArrayStyle'-Type

'广播。[医]抽象派{N} <:BroadcastStyle'是与`AbstractArray`类型关联的任何样式的抽象超类型。 `N’参数表示一个维度，可以方便地处理仅支持特定维度的AbstractArray类型。:

struct SparseMatrixStyle <: Broadcast.AbstractArrayStyle{2} end
Base.BroadcastStyle(::Type{<:SparseMatrixCSC}) = SparseMatrixStyle()

对于支持任意维度的’AbstractArray’类型，N’参数可以设置为’Any:

struct MyArrayStyle <: Broadcast.AbstractArrayStyle{Any} end Base.BroadcastStyle(::Type{<:MyArray}) = MyArrayStyle()

如果您希望能够混合多个"abstractarraystyles"并控制维度，则构造函数必须支持您的样式。 '瓦尔':

struct MyArrayStyleDim{N} <: Broadcast.AbstractArrayStyle{N} end (::Type{<:MyArrayStyleDim})(::Val{N}) where N = MyArrayStyleDim{N}()

请注意，如果"AbstractArrayStyle"的两个或多个子类型冲突，翻译引擎将恢复为创建"数组"。如果这是不可取的，则可能需要定义二进制规则。 `BroadcastStyle'控制输出类型。

另请参阅说明 '广播。DefaultArrayStyle'。

# '基。广播。ArrayStyle'-Type

'广播。[医]阵列式{MyArrayType}()'是一种类型 'BroadcastStyle'，表示对象充当广播的数组。这是一个简单的构建方法 '广播。AbstractArrayStyle'用于特定容器类型’AbstractArray'。以这种方式创建的翻译样式会失去对维度的控制。如果保持控制对您的类型很重要，则应创建自定义类型。 '广播。AbstractArrayStyle'。

# '基。广播。DefaultArrayStyle'-Type

'广播。DefaultArrayStyle{N}()'是一种类型 'BroadcastStyle'，表示对象作为’N`维数组进行广播。特别是，"DefaultArrayStyle"用于任何类型的"AbstractArray"，这些"AbstractArray"缺少专门的样式，并且在没有来自其他"广播"参数的复盖的情况下，生成的输出类型是"Array"。如果有多个输入`广播`，'DefaultArrayStyle’不如任何其他 '广播。ArrayStyle'。

# '基。广播。broadcastable`-Function

Broadcast.broadcastable(x)

返回"x"或支持"x"类型的对象 `axes'、索引及其类型支持 'ndims'。

如果’x’支持迭代，则返回值必须具有与之相同的axes方法和索引行为 '收集(x’。

如果’x’不是’AbstractArray`，但支持’axes`，索引，并且其类型支持`ndims'，则可以实现函数`broadcastable(::typeof(x))'，以便它简单地返回对象本身。此外，如果’x’有自己的定义 'BroadcastStyle'，'broadcastable’方法也必须定义为返回自己，以便自定义样式具有任何效果。

例子

julia> Broadcast.broadcastable([1,2,3]) # аналогично идентификатору, поскольку массивы уже поддерживают оси и индексирование
3-element Vector{Int64}:
 1
 2
 3

julia> Broadcast.broadcastable(Int) # Типы не поддерживают оси, индексирование или итерацию, но обычно используются как 标量ы
Base.RefValue{Type{Int64}}(Int64)

julia> Broadcast.broadcastable("hello") # Строки нарушают конвенцию итерации соответствия и действуют как 标量ы
Base.RefValue{String}("hello")

# '基。广播。combine_axes'-Function

combine_axes(As...) -> Tuple

定义在`As’中的所有值之间平移的结果轴。

julia> Broadcast.combine_axes([1], [1 2; 3 4; 5 6])
(Base.OneTo(3), Base.OneTo(2))

julia> Broadcast.combine_axes(1, 1, 1)
()

# '基。广播。combine_styles'-Function

combine_styles(cs...) -> BroadcastStyle

决定对任意数量的值参数使用哪种类型的"BroadcastStyle"。用途 'BroadcastStyle'为每个参数和函数获取样式 `result_style'用于组合样式。

例子

julia> Broadcast.combine_styles([1], [1 2; 3 4])
Base.Broadcast.DefaultArrayStyle{2}()

# '基。广播。result_style'-Function

result_style(s1::BroadcastStyle[, s2::BroadcastStyle]) -> BroadcastStyle

需要一个或两个’broadcaststyles'，并使用 BroadcastStyle定义一个通用的’BroadcastStyle'。

例子

julia> Broadcast.result_style(Broadcast.DefaultArrayStyle{0}(), Broadcast.DefaultArrayStyle{3}())
Base.Broadcast.DefaultArrayStyle{3}()

julia> Broadcast.result_style(Broadcast.Unknown(), Broadcast.DefaultArrayStyle{1}())
Base.Broadcast.DefaultArrayStyle{1}()

索引和分配

# '基。getindex`-Method

getindex(A, inds...)

返回数组`A`的子集，使用索引`inds’选择。

每个索引可以有任何支持的类型，例如 '整数', 'CartesianIndex`, 'AbstractRange'或数组支持的索引。要选择特定维度中的所有元素，可以使用 ':'，并且要过滤相应索引为’true`的元素，可以使用逻辑数组（例如，'Array{Bool}'或 'BitArray')。

如果’inds’选择多个元素，则此函数返回一个新的分配数组。要在不创建副本的情况下索引多个项目，请使用 '视图'。

有关更多信息，请参阅手册的部分索引数组。

例子

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

julia> getindex(A, 1)
1

julia> getindex(A, [2, 1])
2-element Vector{Int64}:
 3
 1

julia> getindex(A, 2:4)
3-element Vector{Int64}:
 3
 2
 4

julia> getindex(A, 2, 1)
3

julia> getindex(A, CartesianIndex(2, 1))
3

julia> getindex(A, :, 2)
2-element Vector{Int64}:
 2
 4

julia> getindex(A, 2, :)
2-element Vector{Int64}:
 3
 4

julia> getindex(A, A .> 2)
2-element Vector{Int64}:
 3
 4

# '基。setindex！`-Method</no-翻译>

setindex!(A, X, inds...)
A[inds...] = X

将数组"X"中的值存储在使用"inds"指定的"a"子集中。语法'a[inds...]=X'相当于'(setindex!（A，X，inds。..);X)`。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

例子

julia> A = zeros(2,2);

julia> setindex!(A, [10, 20], [1, 2]);

julia> A[[3, 4]] = [30, 40];

julia> A
2×2 Matrix{Float64}:
 10.0  30.0
 20.0  40.0

# '基。nextind'-Function

nextind(A, i)

返回’A’中`i’之后的索引。返回的索引通常相当于整数"i"的"i+1"。此功能可用于通用代码。

返回的索引可能在可接受的范围之外。建议使用 'checkbounds'。

另请参阅说明 'prevind'。

例子

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

julia> nextind(x, 1) # допустимый результат
2

julia> nextind(x, 4) # недопустимый результат
5

julia> nextind(x, CartesianIndex(1, 1)) # допустимый результат
CartesianIndex(2, 1)

julia> nextind(x, CartesianIndex(2, 2)) # недопустимый результат
CartesianIndex(1, 3)

# '基。prevind'-Function</no-翻译>

prevind(A, i)

返回’A’中`i’之前的索引。对于整数"i"，返回的索引通常等同于"i-1"。此功能可用于通用代码。

返回的索引可能在可接受的范围之外。建议使用 'checkbounds'。

另请参阅说明 '下一个'。

例子

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

julia> prevind(x, 4) # допустимый результат
3

julia> prevind(x, 1) # недопустимый результат
0

julia> prevind(x, CartesianIndex(2, 2)) # допустимый результат
CartesianIndex(1, 2)

julia> prevind(x, CartesianIndex(1, 1)) # недопустимый результат
CartesianIndex(2, 0)

# '基。收到！`-Method</no-翻译>

copyto!(dest, Rdest::CartesianIndices, src, Rsrc::CartesianIndices) -> dest

将`rsrc`范围内的`src`块复制到`Rdest`范围内的`dest’块。两个区域的大小必须匹配。

例子

julia> A = zeros(5, 5);

julia> B = [1 2; 3 4];

julia> Ainds = CartesianIndices((2:3, 2:3));

julia> Binds = CartesianIndices(B);

julia> copyto!(A, Ainds, B, Binds)
5×5 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0
 0.0  1.0  2.0  0.0  0.0
 0.0  3.0  4.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0

# '基。收到！`-Function</no-翻译>

copy!(dst, src) -> dst

复制`src`到位到`dst’使用 'copy'删除’dst’中的所有现有元素。如果’dst’和`src’具有相同的类型，则应在调用后保存’dst==src'。如果’dst’和`src’是多维数组，则它们必须相等 '轴'。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

另请参阅说明 '复制！`.

兼容性：Julia1.1

此方法需要至少1.1的Julia版本。在Julia1.0中，此方法在标准库"Future"中可用，如"Future"。收到！`.

# '基。isassigned'-Function

isassigned(array, i) -> Bool

检查指定数组中是否存在与索引`i`关联的值。如果索引超出范围或具有未定义的引用，则返回`false'。

例子

julia> isassigned(rand(3, 3), 5)
true

julia> isassigned(rand(3, 3), 3 * 3 + 1)
false

julia>可变结构Foo end

julia>v=类似（rand（3），Foo）
3元素向量{Foo}:
 #undef
 #undef
 #undef

julia>isassigned(v,1)
错误

# '基。冒号'-Type

Colon()

冒号(:)用于指示整个对象或维度的索引。

很少有操作是直接为冒号定义的。但功能 'to_indices`将它们转换为内部向量类型（'Base。Slice`)来表示它们在使用之前复盖的索引的集合。

'冒号’的单个实例也是用于构建范围的函数。请参阅说明 :.

# '基。IteratorsMD。CartesianIndex'-Type

CartesianIndex(i, j, k...)   -> I
CartesianIndex((i, j, k...)) -> I

创建多维索引’I`，可用于索引多维数组’A'。特别是，A[I]`相当于'+a[i,j,k。..]+. 您可以轻松地混合整数索引和’CartesianIndex’索引。例如，A[Ipre,i,Ipost]（其中`Ipre`和`Ipost`是’CartesianIndex`的索引，`i`是`Int'）在编写在任意维度数组的单个维度中工作的算法时可能是一个有用的表达式。

有时使用函数创建`CartesianIndex' `eachindex'并且总是在使用显式迭代时 'CartesianIndices'。 `I::CartesianIndex’被视为`广播’的"标量"（而不是容器）。要遍历’CartesianIndex’的组件，请使用`Tuple(I)'将其转换为元组。

例子

julia> A = reshape(Vector(1:16), (2, 2, 2, 2))
2×2×2×2 Array{Int64, 4}:
[:, :, 1, 1] =
 1  3
 2  4

[:, :, 2, 1] =
 5  7
 6  8

[:, :, 1, 2] =
  9  11
 10  12

[:, :, 2, 2] =
 13  15
 14  16

julia> A[CartesianIndex((1, 1, 1, 1))]
1

julia> A[CartesianIndex((1, 1, 1, 2))]
9

julia> A[CartesianIndex((1, 1, 2, 1))]
5

兼容性：Julia1.10

要使用’CartesianIndex’作为`broadcast`的"标量"，需要Julia1.10;在以前的版本中，使用’Ref（I’。

# '基。IteratorsMD。CartesianIndices'-Type

CartesianIndices(sz::Dims) -> R
CartesianIndices((istart:[istep:]istop, jstart:[jstep:]jstop, ...)) -> R

定义复盖整数索引的多维矩形范围的区域`R`。它们最常见于迭代的上下文中，其中`为R中的I。.. end'返回索引。 'CartesianIndex`'I'，相当于嵌套循环。

for j = jstart:jstep:jstop for i = istart:istep:istop ... end end

因此，它们对于编写在任意维度上工作的算法非常有用。

CartesianIndices(A::AbstractArray) -> R

为方便起见，在创建’CartesianIndices’时，从数组中形成其索引的范围。

兼容性：Julia1.6

对于步长范围方法'CartesianIndices((istart:istep:istop,jstart:[jstep:]jstop,。..))'要求Julia版本不低于1.6。

例子

julia> foreach(println, CartesianIndices((2, 2, 2)))
CartesianIndex(1, 1, 1)
CartesianIndex(2, 1, 1)
CartesianIndex(1, 2, 1)
CartesianIndex(2, 2, 1)
CartesianIndex(1, 1, 2)
CartesianIndex(2, 1, 2)
CartesianIndex(1, 2, 2)
CartesianIndex(2, 2, 2)

julia> CartesianIndices(fill(1, (2,3)))
CartesianIndices((2, 3))

线性索引到笛卡尔索引的转换

当将线性索引转换为笛卡尔时，使用`CartesianIndices`是`AbstractArray`并且可以线性索引的事实。:

julia> cartesian = CartesianIndices((1:3, 1:2))
CartesianIndices((1:3, 1:2))

julia> cartesian[4]
CartesianIndex(1, 2)

julia> cartesian = CartesianIndices((1:2:5, 1:2))
CartesianIndices((1:2:5, 1:2))

julia> cartesian[2, 2]
CartesianIndex(3, 2)

广播

'CartesianIndices`支持使用`CartesianIndex’进行算术转换（+和--）。

兼容性：Julia1.1

CartesianIndices广播需要至少1.1的Julia版本。

julia> CIs = CartesianIndices((2:3, 5:6))
CartesianIndices((2:3, 5:6))

julia> CI = CartesianIndex(3, 4)
CartesianIndex(3, 4)

julia> CIs .+ CI
CartesianIndices((5:6, 9:10))

有关将笛卡尔索引转换为线性索引的信息，请参阅说明 'LinearIndices'。

# '基。Dims'-Type

Dims{N}

N`元素的`NTuple，'Int’类型用于表示维度 'AbstractArray'。

# '基。LinearIndices'-Type

LinearIndices(A::AbstractArray)

返回一个具有相同形状和 'axes'，至于`A`，其中每个记录的线性索引都在’A’中。使用笛卡尔索引对此数组进行索引允许您将它们映射到线性索引。

对于具有常规索引（索引以1开头）的数组或任何多维数组，线性索引的范围从1到`length(A)'。但是，对于`AbstractVector`，线性索引是`axes(A,1)'，因此对于具有非传统索引的向量，不以1开头。

调用此函数是编写使用线性索引的算法的安全方法。

例子

julia> A = fill(1, (5,6,7));

julia> b = LinearIndices(A);

julia> extrema(b)
(1, 210)

LinearIndices(inds::CartesianIndices) -> R LinearIndices(sz::Dims) -> R LinearIndices((istart:istop, jstart:jstop, ...)) -> R

返回具有指定形状或 '轴'。

例子

此构造函数的主要目的是将笛卡尔索引直观地转换为线性索引。:

julia> linear = LinearIndices((1:3, 1:2))
3×2 LinearIndices{2, Tuple{UnitRange{Int64}, UnitRange{Int64}}}:
 1  4
 2  5
 3  6

julia> linear[1,2]
4

# ’Base.to_indices'*-Function

to_indices(A, I::Tuple)

将元组`I`转换为索引元组，以便在通过索引访问数组`A`时使用。

返回的元组必须仅包含数组’A’支持的’Int’或’AbstractArray’标量索引。如果检测到新类型的索引，其处理方法未知，则会发生错误。

使用简单索引类型时，将切换到非导出的’Base.to_index(A,i)`以处理每个索引`i'。虽然此内部函数不打算直接调用，但可以使用自定义数组或索引类型扩展`Base.to_index’以实现自定义索引行为。

更复杂类型的索引可能需要有关它们索引的维度的更多信息。为了支持这种情况，'to_indices(A,I)调用`to_indices(A,axes(A),I)，然后递归遍历`A`的索引和维度索引的指定元组。因此，并非所有类型的索引都保证扩展到’Base.to_index'。

例子

julia> A = zeros(1,2,3,4);

julia> to_indices(A, (1,1,2,2))
(1, 1, 2, 2)

julia> to_indices(A, (1,1,2,20)) # без проверки границ
(1, 1, 2, 20)

julia> to_indices(A, (CartesianIndex((1,)), 2, CartesianIndex((3,4)))) # необычный индекс
(1, 2, 3, 4)

julia> to_indices(A, ([1,1], 1:2, 3, 4))
([1, 1], 1:2, 3, 4)

julia> to_indices(A, (1,2)) # без проверки формы
(1, 2)

# '基。checkbounds'-Function

checkbounds(Bool, A, I...)

如果指定的索引`I`位于指定数组`A`的边界内，则返回`true'。如果需要实现自定义边界检查行为，`AbstractArray`的子类型应该专门化此方法。但是，在许多情况下，您可以使用索引’A’和函数 'checkindex'。

另请参阅说明 'checkindex'。

例子

julia> A = rand(3, 3);

julia> checkbounds(Bool, A, 2)
true

julia> checkbounds(Bool, A, 3, 4)
false

julia> checkbounds(Bool, A, 1:3)
true

julia> checkbounds(Bool, A, 1:3, 2:4)
false

checkbounds(A, I...)

如果指定的索引`I`在指定数组`A’的边界之外，则返回错误。

# '基。checkindex'-Function

checkindex(Bool, inds::AbstractUnitRange, index)

如果指定的"索引"在"inds"的范围内，则返回"true"。可以充当所有数组索引的自定义类型可以扩展此方法以引入边界检查的专用实现。

另请参阅说明 'checkbounds'。

例子

julia> checkindex(Bool, 1:20, 8)
true

julia> checkindex(Bool, 1:20, 21)
false

# '基。elsize'-Function

elsize(type)

计算连续元素之间以字节为单位的内存步长 'eltype'，如果数组元素以均匀的线性步长密集存储，则存储在指定的`type`内部。

例子

julia> Base.elsize(rand(Float32, 10))
4

表示（子阵列和其他类型的表示）

"视图"是一个作为数组工作的数据结构（它是"AbstractArray"的子类型），尽管数据实际上是从另一个数组中获取的。

例如，如果’x’是一个数组，并且给出了表达式`v=@view x[1:10]，那么`v`作为10个元素的数组工作，尽管在访问数据时，实际上访问了`x`的前10个元素。当写入表示时，例如`v[3]=2，数据直接写入基数组`x`（在这种情况下，元素`x[3]`被更改）。

当您收到一个切片时，例如`x[1:10]'，默认情况下会在Julia中创建一个副本。表达式'@view x[1:10]'允许您更改此行为并创建视图。宏'@views’可以应用于整个代码块（例如，@views function foo()。... 结束+'或'+@视图开始。.. 端)。与此同时，在这个块中取一个切片的所有操作都被改变，以便创建表示。有时创建副本可能会更快，有时使用视图可能会更快，如中所述性能提示。

# '基。查看'-Function

view(A, inds...)

类似于 'getindex'，但返回一个简化数组，该数组"懒惰地"引用（或实际上是_representation_）给定索引处的父数组`A`或索引`inds'，而不是主动提取元素或构建复制的子集。打电话时 'getindex'或 'setindex！'为返回值（常 `SubArray')索引的计算是为了访问或动态修改父数组。如果在调用`view`后更改父数组的形状，则行为将是未定义的，因为不执行检查父数组的边界。例如，可能发生分段故障。

某些不可变的父数组（如范围）在某些情况下可能会简单地重新计算新数组，而不是返回"子数组"，如果这是有效的并提供兼容的语义。

兼容性：Julia1.6

在Julia1.6或更高版本中，可以为`AbstractString`调用`view`，它返回’SubString'。

例子

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

julia> b = view(A, :, 1)
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3

julia> fill!(b, 0)
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 0
 0

julia> A # Обратите внимание, что A изменился, хотя был изменен b
2×2 Matrix{Int64}:
 0  2
 0  4

julia> view(2:5, 2:3) # возвращает диапазон, так как тип является неизменяемым
3:4

# '基。@view`-Macro

@view A[inds...]

转换索引表达式'a[inds...]'在等效调用 '视图'。

它只能直接应用于一个索引表达式。它对于包含特殊索引语法"begin"或"end"的表达式特别有用，例如`a[begin,2:end-1]"（因为通常的函数 'view'不支持它们）。

请注意，'@view’不能用作常规赋值目标（例如，@view(a[1,2:end])=。..），以及未装饰索引赋值('A[1,2:end]=...'）或翻译索引赋值（'A[1,2:end]。= ...）不会创建副本。但是，它对于更新已翻译的作业非常有用，例如@view(A[1,2:end])。+=1`，因为这是`@view(A[1,2:end])的简单语法。=@view(a[1,2:end])+1`，否则右侧的索引表达式将创建一个没有`@view`的副本。

另请参阅说明 `@views'有关将整个代码块切换为使用视图进行非标量索引的信息。

兼容性：Julia1.5

要在索引表达式中使用’begin’来引用第一个索引，需要至少1.5的Julia版本。

例子

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

julia> b = @view A[:, 1]
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3

julia> fill!(b, 0)
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 0
 0

julia> A
2×2 Matrix{Int64}:
 0  2
 0  4

# '基。@views'-Macro

@views expression

将每个数组切片操作转换为给定的表达式（可以是`begin`/end`块，循环，函数等。)来返回表示。标量索引、非数组类型和显式调用 'getindex（而不是'array[。..]`)不受影响。

同样’@views’将字符串切片转换为视图。 '子字符串'。

宏'@views’只影响表达式'array[。..]`，在指定的`表达式’中显式使用，而不是在此代码调用的函数中发生的数组切片操作。

兼容性：Julia1.5

在索引表达式中使用`begin’来引用第一个索引是在Julia1.4中实现的，但是自Julia1.5以来才支持`@views`。

例子

julia> A = zeros(3, 3);

julia> @views for row in 1:3
           b = A[row, :] # b — это представление, а не копия
           b .= row      # присваиваем каждый элемент индексу строки
       end

julia> A
3×3 Matrix{Float64}:
 1.0  1.0  1.0
 2.0  2.0  2.0
 3.0  3.0  3.0

# '基。父'-Function

parent(A)

返回视图的基父对象。这是`SubArray`，SubString，ReshapedArray`或`LinearAlgebra类型的对象的父对象。Transpose’是作为参数传递给`view，reshape，`transpose`等的内容。创建对象时。如果输入对象不是封闭对象，它会自行返回。如果输入对象被多次封装，则只会移除最外层。

例子

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

julia> V = view(A, 1:2, :)
2×2 view(::Matrix{Int64}, 1:2, :) with eltype Int64:
 1  2
 3  4

julia> parent(V)
2×2 Matrix{Int64}:
 1  2
 3  4

# '基。parentindices'-Function

parentindices(A)

返回索引 'parent'，它对应于数组`A`的表示。

例子

julia> A = [1 2; 3 4];

julia> V = view(A, 1, :)
2-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2

julia> parentindices(V)
(1, Base.Slice(Base.OneTo(2)))

# '基。选择dim'-Function

selectdim(A, d::Integer, i)

返回所有数据`A`的表示，其中维度`d`的索引等于`i`。

相当于'view(A,:,:,。..,我,:,:,。..）`，其中’i’位于位置’d'。

另请参阅说明 'eachslice'。

例子

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

julia> selectdim(A, 2, 3)
2-element view(::Matrix{Int64}, :, 3) with eltype Int64:
 3
 7

julia>selectdim（A，2，3：4）
2×2视图(::矩阵{Int64},:,3:4)与eltype Int64:
 3  4
 7  8

# '基。重新解释'-Function

reinterpret(::Type{Out}, x::In)

将值isbits`x`中的二进制数据类型的解释更改为类型isbits`Out’的解释。 Out（不包括填充）的大小必须与`x`类型的大小相同。例如，'reinterpret(Float32,UInt32(7)`将与’UInt32(7)'相关的4个字节解释为 'Float32'。注意’reinterpret(In,reinterpret(Out,x))===x

julia> reinterpret(Float32, UInt32(7))
1.0f-44

julia> reinterpret(NTuple{2, UInt8}, 0x1234)
(0x34, 0x12)

julia> reinterpret(UInt16, (0x34, 0x12))
0x1234

julia> reinterpret(Tuple{UInt16, UInt8}, (0x01, 0x0203))
(0x0301, 0x02)

填充的处理方式与使用reinterpret(::DataType,::AbstractArray)时不同。

如果`Out`中的某些位组合不被认为是有效的，并且被类型的构造函数和方法禁止，请小心。如果没有额外的验证，行为可能是意外的。

reinterpret(T::DataType, A::AbstractArray)

使用与指定数组中相同的二进制数据创建数组的表示形式，但元素类型为`T`。

此函数也适用于"延迟"数组，其元素在显式提取之前不会计算。例如，`1:6`范围内的’reinterpret`的工作方式与密集向量`collect(1:6)'的工作方式相同:

julia> reinterpret(Float32, UInt32[1 2 3 4 5])
1×5 reinterpret(Float32, ::Matrix{UInt32}):
 1.0f-45  3.0f-45  4.0f-45  6.0f-45  7.0f-45

julia> reinterpret(Complex{Int}, 1:6)
3-element reinterpret(Complex{Int64}, ::UnitRange{Int64}):
 1 + 2im
 3 + 4im
 5 + 6im

如果`T`和`eltype(A)`的填充位的位置不匹配，则生成的数组将分别为只读或只写，以防止无效位被写入或读取。

julia> a = reinterpret(Tuple{UInt8, UInt32}, UInt32[1, 2])
1-element reinterpret(Tuple{UInt8, UInt32}, ::Vector{UInt32}):
 (0x01, 0x00000002)

julia> a[1] = 3
ERROR: Padding of type Tuple{UInt8, UInt32} is not compatible with type UInt32.

julia> b = reinterpret(UInt32, Tuple{UInt8, UInt32}[(0x01, 0x00000002)]); # при отображении будет выдана ошибка

julia> b[1]
ERROR: Padding of type UInt32 is not compatible with type Tuple{UInt8, UInt32}.

reinterpret(reshape, T, A::AbstractArray{S}) -> B

在使用或添加"通道维度"时更改类型`A`的解释。

如果`sizeof(T)=n*sizeof(S)for`n>1，那么`A`的第一维应该有大小`n`，而`B`中缺少`A’的第一维。相反，如果`sizeof(S)=n*sizeof(T)为`n>1，B`得到大小`n’的新的第一维。如果`sizeof(T)==sizeof(S)，则维度不会更改。

兼容性：Julia1.6

此方法需要至少1.6的Julia版本。

例子

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

julia> reinterpret(reshape, Complex{Int}, A)    # результатом является 向量
2-element reinterpret(reshape, Complex{Int64}, ::Matrix{Int64}) with eltype Complex{Int64}:
 1 + 3im
 2 + 4im

julia> a = [(1,2,3), (4,5,6)]
2-element Vector{Tuple{Int64, Int64, Int64}}:
 (1, 2, 3)
 (4, 5, 6)

julia>reinterpret(reshape,Int,a)#结果是
一个3x2矩阵重新解释(reshape,Int64,::Vector{Tuple{Int64, Int64, Int64}}）与eltype Int64:
 1  4
 2  5
 3  6

# '基。重塑'-Function

reshape(A, dims...) -> AbstractArray
reshape(A, dims) -> AbstractArray

返回一个数组，其数据与`A’中的数据相同，但具有不同的维度大小或维度数。两个数组使用相同的基础数据，因此当且仅当`A`是可变的并且指定一个数组的元素会更改另一个数组的值时，结果才是可变的。

新维度既可以指定为参数列表，也可以指定为表单的元组。使用`:'只能指定一个维度。在这种情况下，其长度的计算方式是，其具有所有指定维度的乘积等于原始数组`A`的长度。项目总数不应改变。

例子

julia> A = Vector(1:16)
16-element Vector{Int64}:
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16

julia> reshape(A, (4, 4))
4×4 Matrix{Int64}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> reshape(A, 2, :)
2×8 Matrix{Int64}:
 1  3  5  7   9  11  13  15
 2  4  6  8  10  12  14  16

julia> reshape(1:6, 2, 3)
2×3 reshape(::UnitRange{Int64}, 2, 3) with eltype Int64:
 1  3  5
 2  4  6

# '基。dropdims'-Function

dropdims(A; dims)

返回具有与`A`中相同数据的数组，但具有在`dims`中指定的已删除维度。 "dims"中每个"d"的"size(a,d)"必须等于1，并且禁止重复尺寸或超出"1:ndims(a)"的数字。

结果使用与’A`相同的基本数据，因此当且仅当`A`是可变的并且指定一个数组的元素会更改另一个数组的值时，它才是可变的。

另请参阅说明 '重塑', 'vec'。

例子

julia> a = reshape(Vector(1:4),(2,2,1,1))
2×2×1×1 Array{Int64, 4}:
[:, :, 1, 1] =
 1  3
 2  4

julia> b = dropdims(a; dims=3)
2×2×1 Array{Int64, 3}:
[:, :, 1] =
 1  3
 2  4

julia> b[1,1,1] = 5; a
2×2×1×1 Array{Int64, 4}:
[:, :, 1, 1] =
 5  3
 2  4

# '基。vec'-Function

vec(a::AbstractArray) -> AbstractVector

将数组`a’转换为一维列向量。返回’a`，即使它已经是’AbstractVector'。结果数组具有与`a’相同的底层数据，因此只有当`a`是可变的时，它才是可变的。在这种情况下，当您更改一个数组时，另一个数组也会更改。

例子

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

julia> vec(a)
6-element Vector{Int64}:
 1
 4
 2
 5
 3
 6

julia> vec(1:3)
1:3

另请参阅说明 '重塑'和 'dropdims'。

# '基。子数组'-Type</no-翻译>

SubArray{T,N,P,I,L} <: AbstractArray{T,N}

父数组的`N`维表示（类型为`P`），元素类型为`T`，受索引元组（类型为`I'）的限制。对于支持快速线性索引的类型，'L’值为true，否则值为’false'。

使用函数创建"子数组" '视图'。

串联和排列

# <无翻译>*Base.cat*-Function</no-翻译>

cat(A...; dims)

在"dims"中指定的维度中执行输入数组的串联。

在`d in dims’维度中，输出数组的大小为’sum(size(a,d)for a in a)'。在其他维度中，所有输入数组必须具有相同的大小，这也将是这些维度中输出数组的大小。

如果’dims’是一个数字，则各种数组在该维度中紧密贴合。如果’dims’是一个包含多个维度的可迭代对象，那么每个输入数组沿着这些维度的位置同时增加，用零填充所有其他位置。这允许您以`cat（矩阵的形式构建块对角矩阵。..;dims=(1,2))`及其具有更高维度的类似物。

'Dims=1`的特例是 'vcat'，和’dims=2` — 'hcat'。另请参阅说明 'hvcat', 'hvncat', '堆栈'和 '重复'。

命名参数也接受’Val(dims)`。

兼容性：Julia1.8

对于多个维度，在Julia1.8中添加了`dims=Val(::Tuple)`。

例子

连接两个不同维度的数组:

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

julia> b = [4 5 6]
1×3 Matrix{Int64}:
 4  5  6

julia> cat(a, b; dims=1)
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> cat(a, b; dims=2)
1×6 Matrix{Int64}:
 1  2  3  4  5  6

julia> cat(a, b; dims=(1, 2))
2×6 Matrix{Int64}:
 1  2  3  0  0  0
 0  0  0  4  5  6

高级帮助

三维数组的串联:

julia> a = ones(2, 2, 3);

julia> b = ones(2, 2, 4);

julia> c = cat(a, b; dims=3);

julia> size(c) == (2, 2, 7)
true

串联不同大小的数组:

julia> cat([1 2; 3 4], [pi, pi], fill(10, 2,3,1); dims=2)  # то же, что и hcat
2×6×1 Array{Float64, 3}:
[:, :, 1] =
 1.0  2.0  3.14159  10.0  10.0  10.0
 3.0  4.0  3.14159  10.0  10.0  10.0

构建块对角矩阵:

julia> cat(true, trues(2,2), trues(4)', dims=(1,2))  # блочно-диагональная
4×7 Matrix{Bool}:
 1  0  0  0  0  0  0
 0  1  1  0  0  0  0
 0  1  1  0  0  0  0
 0  0  0  1  1  1  1

julia> cat(1, [2], [3;;]; dims=Val(2))
1×3 Matrix{Int64}:
 1  2  3

'cat`不结合两个字符串;为此，您可以使用`*`.

julia> a = "aaa";

julia> b = "bbb";

julia> cat(a, b; dims=1)
2-element Vector{String}:
 "aaa"
 "bbb"

julia> cat(a, b; dims=2)
1×2 Matrix{String}:
 "aaa"  "bbb"

julia> a * b
"aaabbb"

# '基。vcat`-Function

vcat(A...)

垂直连接数组或数字。相当于 '猫''(A．..;dims=1)和[a;b;c]`的语法。

为了连接一个大的数组向量，当"isa AbstractVector"调用一个有效的方法时，"reduce(vcat,A)"会调用一个有效的方法{<:AbstractVecOrMat}`，而不是成对工作。

另请参阅说明 'hcat', '迭代器。展平'和 '堆栈'。

例子

julia> v = vcat([1,2], [3,4])
4-element Vector{Int64}:
 1
 2
 3
 4

julia> v == vcat(1, 2, [3,4])  # принимает числа
true

julia> v == [1; 2; [3,4]]  # синтаксис для той же операции
true

julia> summary(ComplexF64[1; 2; [3,4]])  # синтаксис для указания типа элемента
"4-element Vector{ComplexF64}"

julia> vcat(range(1, 2, length=3))  # собирает «ленивые» диапазоны
3-element Vector{Float64}:
 1.0
 1.5
 2.0

julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9])  # 向量 строки и 矩阵
([10 20 30], [4.0 5.0 6.0; 7.0 8.0 9.0])

julia> vcat(two...)
3×3 Matrix{Float64}:
 10.0  20.0  30.0
  4.0   5.0   6.0
  7.0   8.0   9.0

julia> vs = [[1, 2], [3, 4], [5, 6]];

julia> reduce(vcat, vs)  # эффективнее, чем vcat(vs...)
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

julia> ans == collect(Iterators.flatten(vs))
true

# '基。hcat'-Function

hcat(A...)

执行水平连接数组或数字。相当于 '猫''(A．..;dims=2)'和`[a b c]`或'[a;; b;; c]'。

要连接一大组数组，'reduce(hcat,A’调用一个有效的方法if’a isa AbstractVector{<:AbstractVecOrMat}`. 对于一个向量的向量，也可以写成 '堆栈'`(A)'。

另请参阅说明 'vcat'和 'hvcat'。

例子

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

julia> hcat(1, 2, [30 40], [5, 6, 7]')  # принимает числа
1×7 Matrix{Int64}:
 1  2  30  40  5  6  7

julia> ans == [1 2 [30 40] [5, 6, 7]']  # синтаксис для той же операции
true

julia> Float32[1 2 [30 40] [5, 6, 7]']  # синтаксис для указания типа элемента
1×7 Matrix{Float32}:
 1.0  2.0  30.0  40.0  5.0  6.0  7.0

julia> ms = [zeros(2,2), [1 2; 3 4], [50 60; 70 80]];

julia> reduce(hcat, ms)  # эффективнее, чем hcat(ms...)
2×6 Matrix{Float64}:
 0.0  0.0  1.0  2.0  50.0  60.0
 0.0  0.0  3.0  4.0  70.0  80.0

julia> stack(ms) |> summary  # отличается от 向量а матриц
"2×2×3 Array{Float64, 3}"

julia> hcat(Int[], Int[], Int[])  # пустые 向量ы, каждый размером (0,)
0×3 Matrix{Int64}

julia> hcat([1.1, 9.9], Matrix(undef, 2, 0))  # hcat с пустой матрицей 2×0
2×1 Matrix{Any}:
 1.1
 9.9

# '基。hvcat'-Function

hvcat(blocks_per_row::Union{Tuple{Vararg{Int}}, Int}, values...)

水平和垂直连接在一个调用. 块矩阵语法调用此函数。第一个参数指定要在块的每一行中连接的参数的数量。如果第一个参数是单个整数’n`，则假定所有块行都有’n`块列。

例子

julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
(1, 2, 3, 4, 5, 6)

julia> [a b c; d e f]
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> hvcat((3,3), a,b,c,d,e,f)
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> [a b; c d; e f]
3×2 Matrix{Int64}:
 1  2
 3  4
 5  6

julia> hvcat((2,2,2), a,b,c,d,e,f)
3×2 Matrix{Int64}:
 1  2
 3  4
 5  6
julia> hvcat((2,2,2), a,b,c,d,e,f) == hvcat(2, a,b,c,d,e,f)
true

# '基。hvncat'-Function

hvncat(dim::Int, row_first, values...)
hvncat(dims::Tuple{Vararg{Int}}, row_first, values...)
hvncat(shape::Tuple{Vararg{Tuple}}, row_first, values...)

在单个"值"调用中进行水平、垂直和n维连接。

块矩阵语法调用此函数。第一个参数要么指定连接的形式，类似于`hvcat`，以元组的元组的形式，要么确定每个轴上元素的关键数量的维度，并用于确定输出维度。 "Dims"形式更具生产力，默认情况下，当串联操作在每个轴上包含相同数量的元素（例如，[a b;c d;;;e f;g h]）时使用。当每个轴上的元素数量不均衡（例如，[a b;c]）时，将使用该形状。不平衡的语法需要额外的验证成本。 "暗淡"形状是仅在一个维度上连接的优化。 'row_first’指定’values’的排序方法。第一个和第二个`shape’元素的值也基于`row_first’交换。

例子

julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
(1, 2, 3, 4, 5, 6)

julia> [a b c;;; d e f]
1×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  2  3

[:, :, 2] =
 4  5  6

julia> hvncat((2,1,3), false, a,b,c,d,e,f)
2×1×3 Array{Int64, 3}:
[:, :, 1] =
 1
 2

[:, :, 2] =
 3
 4

[:, :, 3] =
 5
 6

julia> [a b;;; c d;;; e f]
1×2×3 Array{Int64, 3}:
[:, :, 1] =
 1  2

[:, :, 2] =
 3  4

[:, :, 3] =
 5  6

julia> hvncat(((3, 3), (3, 3), (6,)), true, a, b, c, d, e, f)
1×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  2  3

[:, :, 2] =
 4  5  6

构造参数的例子

[a b c ; d e f ;;;
 g h i ; j k l ;;;
 m n o ; p q r ;;;
 s t u ; v w x]
⇒ dims = (2, 3, 4)

[a b ; c ;;; d ;;;;]
 ___   _     _
 2     1     1 = elements in each row (2, 1, 1)
 _______     _
 3           1 = elements in each column (3, 1)
 _____________
 4             = elements in each 3d slice (4,)
 _____________
 4             = elements in each 4d slice (4,)
⇒ shape = ((2, 1, 1), (3, 1), (4,), (4,)) with `row_first` = true

# '基。堆栈'-Function

stack(iter; [dims])

将相同大小的数组（或其他可迭代对象）的集合组合到一个更大的数组中，将它们排列在一个或多个新维度中。

默认情况下，元素的轴首先定位，这给出了'size(result)=(size(first(iter))。..，尺寸(iter)。..). 在这种情况下，形成与使用时相同的元素顺序 '迭代器。展平'(iter)'。

当使用命名参数’dims::Integer’时’i’th迭代元素（iter'）变成一个切片。 'selectdim''(result,dims,i)，这样`size(result,dims)==length(iter)'。在这种情况下，'堆栈’会更改函数操作。 eachslice用相同的’dims’反转。

各种功能 'cat'也可以组合数组。但是，它们都扩展了现有的（可能是微不足道的）数组维度，而不是将数组放置在新的维度中。它们也接受数组作为单独的参数，而不是作为单个集合。

兼容性：Julia1.9

此功能需要至少1.9的Julia版本。

例子

julia> vecs = (1:2, [30, 40], Float32[500, 600]);

julia> mat = stack(vecs)
2×3 Matrix{Float32}:
 1.0  30.0  500.0
 2.0  40.0  600.0

julia> mat == hcat(vecs...) == reduce(hcat, collect(vecs))
true

julia> vec(mat) == vcat(vecs...) == reduce(vcat, collect(vecs))
true

julia> stack(zip(1:4, 10:99))  # принимает любые итераторы итераторов
2×4 Matrix{Int64}:
  1   2   3   4
 10  11  12  13

julia> vec(ans) == collect(Iterators.flatten(zip(1:4, 10:99)))
true

julia> stack(vecs; dims=1)  # В отличие от любой функции cat, 1-я ось vecs[1] является 2-й осью результата
3×2 Matrix{Float32}:
   1.0    2.0
  30.0   40.0
 500.0  600.0

julia> x = rand(3,4);

julia>x==stack(eachcol(x))==stack(eachrow(x),dims=1)#每个切片值的倒数
真的

更高维度的例子:

julia> A = rand(5, 7, 11);

julia> E = eachslice(A, dims=2);  # 向量 матриц

julia> (element = size(first(E)), container = size(E))
(element = (5, 11), container = (7,))

julia> stack(E) |> size
(5, 11, 7)

julia> stack(E) == stack(E; dims=3) == cat(E...; dims=3)
true

julia> A == stack(E; dims=2)
true

julia> M = (fill(10i+j, 2, 3) for i in 1:5, j in 1:7);

julia> (element = size(first(M)), container = size(M))
(element = (2, 3), container = (5, 7))

julia> stack(M) |> size  # все измерения сохраняются
(2, 3, 5, 7)

julia> stack(M; dims=1) |> size  # vec(container) в dims=1
(35, 2, 3)

julia> hvcat(5, M...) |> size  # hvcat размещает матрицы рядом друг с другом
(14, 15)

stack(f, args...; [dims])

将函数应用于集合的每个元素，并将结果放在堆栈上。或到多个集合组合（`zip')一起。

该函数必须返回相同大小的数组（或元组或其他迭代器）。它们成为结果的切片，每个切片都由"dims"（如果指定）或默认情况下由最后一个维度划分。

另请参阅说明 'mapslices'和 'eachcol'。

例子

julia> stack(c -> (c, c-32), "julia")
2×5 Matrix{Char}:
 'j'  'u'  'l'  'i'  'a'
 'J'  'U'  'L'  'I'  'A'

julia> stack(eachrow([1 2 3; 4 5 6]), (10, 100); dims=1) do row, n
         vcat(row, row .* n, row ./ n)
       end
2×9 Matrix{Float64}:
 1.0  2.0  3.0   10.0   20.0   30.0  0.1   0.2   0.3
 4.0  5.0  6.0  400.0  500.0  600.0  0.04  0.05  0.06

# '基。vect'-Function

vect(X...)

创建 Vector使用从包含参数列表的`promote_typeof’参数计算的元素类型。

例子

julia> a = Base.vect(UInt8(1), 2.5, 1//2)
3-element Vector{Float64}:
 1.0
 2.5
 0.5

# '基。circshift'-Function

circshift(A, shifts)

对数组中的数据执行循环移位，即旋转。第二个参数是指定每个维度中的移位量的元组或向量，或者仅用于在第一个维度中移位的整数。

另请参阅说明 'circshift！, 'circcopy！, 'bitrotate', <<.

例子

julia> b = reshape(Vector(1:16), (4,4))
4×4 Matrix{Int64}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> circshift(b, (0,2))
4×4 Matrix{Int64}:
  9  13  1  5
 10  14  2  6
 11  15  3  7
 12  16  4  8

julia> circshift(b, (-1,0))
4×4 Matrix{Int64}:
 2  6  10  14
 3  7  11  15
 4  8  12  16
 1  5   9  13

julia> a = BitArray([true, true, false, false, true])
5-element BitVector:
 1
 1
 0
 0
 1

julia> circshift(a, 1)
5-element BitVector:
 1
 1
 1
 0
 0

julia> circshift(a, -1)
5-element BitVector:
 1
 0
 0
 1
 1

# '基。循环换位！`-Function</no-翻译>

circshift!(dest, src, shifts)

在’src’中执行循环移位，即旋转，同时将结果保存在’dest’中。 "移位"设置每个维度的移位量。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

另请参阅说明 'circshift'。

# '基。复印本！`-Function</no-翻译>

circcopy!(dest, src)

复制’src’到’dest'，索引每个维度以其长度为模。 'src’和`dest’必须具有相同的大小，但可以在索引中移位;任何移位都会导致（循环）包装。如果数组具有重叠索引，则在重叠区域`dest`中匹配`src'。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

另请参阅说明 'circshift'。

例子

julia> src = reshape(Vector(1:16), (4,4))
4×4 Array{Int64,2}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> dest = OffsetArray{Int}(undef, (0:3,2:5))

julia> circcopy!(dest, src)
OffsetArrays.OffsetArray{Int64,2,Array{Int64,2}} with indices 0:3×2:5:
 8  12  16  4
 5   9  13  1
 6  10  14  2
 7  11  15  3

julia> dest[1:3,2:4] == src[1:3,2:4]
true

# '基。findall'—Method

findall(A)

返回`true`索引或`a`键的向量`I'。如果`A’没有这样的元素，则返回一个空数组。要搜索其他类型的值，请将谓词作为第一个参数传递。

索引或键与方法返回的索引和键的类型相同。 '钥匙(A)`及 `pairs(A)'。

另请参阅说明 'findfirst`, 'searchsorted`。

例子

julia> A = [true, false, false, true]
4-element Vector{Bool}:
 1
 0
 0
 1

julia> findall(A)
2-element Vector{Int64}:
 1
 4

julia> A = [true false; false true]
2×2 Matrix{Bool}:
 1  0
 0  1

julia> findall(A)
2-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 2)

julia> findall(falses(3))
Int64[]

# '基。findall'—Method

findall(f::Function, A)

返回索引或键`A`的向量`I`，其中`f(a[I])`返回`true'。如果`A’没有这样的元素，则返回一个空数组。

索引或键与方法返回的索引和键的类型相同。 '钥匙(A)`及 `pairs(A)'。

例子

julia> x = [1, 3, 4]
3-element Vector{Int64}:
 1
 3
 4

julia> findall(isodd, x)
2-element Vector{Int64}:
 1
 2

julia> A = [1 2 0; 3 4 0]
2×3 Matrix{Int64}:
 1  2  0
 3  4  0
julia> findall(isodd, A)
2-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)

julia> findall(!iszero, A)
4-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)
 CartesianIndex(1, 2)
 CartesianIndex(2, 2)

julia> d = Dict(:A => 10, :B => -1, :C => 0)
Dict{Symbol, Int64} with 3 entries:
  :A => 10
  :B => -1
  :C => 0

julia> findall(x -> x >= 0, d)
2-element Vector{Symbol}:
 :A
 :C

# '基。findfirst'-Method

findfirst(A)

返回’a`中第一个`true’值的索引或键。如果没有找到这样的值，则返回"nothing"。要搜索其他类型的值，请将谓词作为第一个参数传递。

索引或键与方法返回的索引和键的类型相同。 '钥匙(A)`及 `pairs(A)'。

另请参阅说明 'findall', 'findnext', 'findlast`, 'searchsortedfirst'。

例子

julia> A = [false, false, true, false]
4-element Vector{Bool}:
 0
 0
 1
 0

julia> findfirst(A)
3

julia>findfirst(falses(3))#不返回任何内容，但不输出到REPL

julia>A=[false false;true false]
2×2矩阵{Bool}:
 0  0
 1  0

julia>findfirst(一)
CartesianIndex(2,1)

# '基。findfirst'-Method

findfirst(predicate::Function, A)

返回第一个元素`A`的索引或键，`predict`返回`true'。如果没有这样的元素，则返回"nothing"。

索引或键与方法返回的索引和键的类型相同。 '钥匙(A)`及 `pairs(A)'。

例子

julia> A = [1, 4, 2, 2]
4-element Vector{Int64}:
 1
 4
 2
 2

julia> findfirst(iseven, A)
2

julia> findfirst(x -> x>10, A) # возвращает nothing, но не выводится в REPL

julia> findfirst(isequal(4), A)
2

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

julia> findfirst(iseven, A)
CartesianIndex(2, 1)

# '基。findlast'-Method

findlast(A)

返回’a`中最后一个’true’值的索引或键。如果`a’中没有’true`值，则返回`nothing'。

索引或键与方法返回的索引和键的类型相同。 '钥匙(A)`及 `pairs(A)'。

另请参阅说明 'findfirst`, 'findprev', 'findall'。

例子

julia> A = [true, false, true, false]
4-element Vector{Bool}:
 1
 0
 1
 0

julia> findlast(A)
3

julia> A = falses(2,2);

julia> findlast(A) # возвращает nothing, но не выводится в REPL

julia> A = [true false; true false]
2×2 Matrix{Bool}:
 1  0
 1  0

julia> findlast(A)
CartesianIndex(2, 1)

# '基。findlast'-Method

findlast(predicate::Function, A)

返回`a`最后一个元素的索引或键，`predict’返回’true'。如果没有这样的元素，则返回"nothing"。

索引或键与方法返回的索引和键的类型相同。 '钥匙(A)`及 `pairs(A)'。

例子

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

julia> findlast(isodd, A)
3

julia> findlast(x -> x > 5, A) # возвращает nothing, но не выводится в REPL

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

julia> findlast(isodd, A)
CartesianIndex(2, 1)

# '基。findnext'-Method

findnext(A, i)

在数组`a`中查找`i`元素`true`之后的下一个索引，或者包括它，或者如果找不到索引，则查找`nothing`。

索引与方法返回的索引的类型相同。 '钥匙(A)`及 `pairs(A)'。

例子

julia> A = [false, false, true, false]
4-element Vector{Bool}:
 0
 0
 1
 0

julia> findnext(A, 1)
3

julia> findnext(A, 4) # возвращает nothing, но не выводится в REPL

julia> A = [false false; true false]
2×2 Matrix{Bool}:
 0  0
 1  0

julia> findnext(A, CartesianIndex(1, 1))
CartesianIndex(2, 1)

# '基。findnext'-Method

findnext(predicate::Function, A, i)

查找"i"元素"a"之后或包含"i"元素的下一个索引，如果找不到索引，则"predict"返回"true"或"nothing"。适用于数组，字符串和大多数其他支持的集合 'getindex', '钥匙(A)`及 '下一个'。

索引与方法返回的索引的类型相同。 '钥匙(A)`及 `pairs(A)'。

例子

julia> A = [1, 4, 2, 2];

julia> findnext(isodd, A, 1)
1

julia> findnext(isodd, A, 2) # возвращает nothing, но не выводится в REPL

julia>A=[1 4;2 2];

julia>findnext（isodd，A，CartesianIndex（1，1））
CartesianIndex(1,1)

julia>findnext（isspace，"a b c"，3）
4

# '基。findprev'-Method

findprev(A, i)

查找数组"a"中包含"i"元素"true"的前一个索引，如果找不到索引，则查找"nothing"。

索引与方法返回的索引的类型相同。 '钥匙(A)`及 `pairs(A)'。

另请参阅说明 'findnext', 'findfirst`, 'findall'。

例子

julia> A = [false, false, true, true]
4-element Vector{Bool}:
 0
 0
 1
 1

julia> findprev(A, 3)
3

julia> findprev(A, 1) # возвращает nothing, но не выводится в REPL

julia> A = [false false; true true]
2×2 Matrix{Bool}:
 0  0
 1  1

julia> findprev(A, CartesianIndex(2, 1))
CartesianIndex(2, 1)

# '基。findprev'-Method

findprev(predicate::Function, A, i)

查找元素"A"的"i"之前的索引，"predict"返回"true"，或将其包含在内，如果找不到索引，则返回"nothing"。适用于数组，字符串和大多数其他支持的集合 'getindex', '钥匙(A)`及 '下一个'。

索引与方法返回的索引的类型相同。 '钥匙(A)`及 `pairs(A)'。

例子

julia> A = [4, 6, 1, 2]
4-element Vector{Int64}:
 4
 6
 1
 2

julia> findprev(isodd, A, 1) # возвращает nothing, но не выводится в REPL

julia> findprev(isodd, A, 3)
3

julia> A = [4 6; 1 2]
2×2 Matrix{Int64}:
 4  6
 1  2

julia> findprev(isodd, A, CartesianIndex(1, 2))
CartesianIndex(2, 1)

julia> findprev(isspace, "a b c", 3)
2

# '基。permutedims'-Function

permutedims(A::AbstractArray, perm)
permutedims(A::AbstractMatrix)

重置数组`A’的维度（轴）。 'perm’是定义置换的`ndims(A)`整数的元组或向量。

如果`A’是一个二维数组（'AbstractMatrix'），然后`perm`默认为`（2,1），交换两个轴`A（矩阵的行和列）。与……的区别 'transpose'是此操作不是递归的，这在非数字值数组（递归函数`transpose`返回错误）和/或不表示线性算子的二维数组的情况下特别有用。

对于一维数组，使用方法 `permutedims(v::AbstractVector)'，它返回一行"矩阵"。

另请参阅说明 'mims！`, 'PermutedDimsArray', '转置'和 'invperm'。

例子

二维数组:

与`transpose’不同’permutedims’可用于排列任意非数字元素（如字符串）的二维数组的行和列:

julia> A = ["a" "b" "c"
            "d" "e" "f"]
2×3 Matrix{String}:
 "a"  "b"  "c"
 "d"  "e"  "f"

julia> permutedims(A)
3×2 Matrix{String}:
 "a"  "d"
 "b"  "e"
 "c"  "f"

对于元素本身是数字矩阵的矩阵，`permutedims`产生的结果与`transpose’的结果不同。:

julia> a = [1 2; 3 4];

julia> b = [5 6; 7 8];

julia> c = [9 10; 11 12];

julia> d = [13 14; 15 16];

julia> X = [[a] [b]; [c] [d]]
2×2 Matrix{Matrix{Int64}}:
 [1 2; 3 4]     [5 6; 7 8]
 [9 10; 11 12]  [13 14; 15 16]

julia> permutedims(X)
2×2 Matrix{Matrix{Int64}}:
 [1 2; 3 4]  [9 10; 11 12]
 [5 6; 7 8]  [13 14; 15 16]

julia> transpose(X)
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 3; 2 4]  [9 11; 10 12]
 [5 7; 6 8]  [13 15; 14 16]

多维数组

julia> A = reshape(Vector(1:8), (2,2,2))
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  3
 2  4

[:, :, 2] =
 5  7
 6  8

julia> perm = (3, 1, 2); # последнее измерение размещается первым

julia> B = permutedims(A, perm)
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  2
 5  6

[:, :, 2] =
 3  4
 7  8

julia> A == permutedims(B, invperm(perm)) # обратная перестановка
true

对于`B=permutedims(A,perm)中的每个维度`i，A`的相应维度将是`perm[i]。这意味着相等的’size(B,i)==size(A,perm[i])'成立。

julia> A = randn(5, 7, 11, 13);

julia> perm = [4, 1, 3, 2];

julia> B = permutedims(A, perm);

julia> size(B)
(13, 5, 11, 7)

julia> size(A)[perm] == ans
true

permutedims(v::AbstractVector)

将向量’v’的形状更改为小写矩阵'1×length(v)'。与……的区别 'transpose'是这个操作不是递归的，这在非数字值数组的情况下特别有用（递归函数`transpose’可能会抛出错误）。

例子

与`transpose’不同’permutedims’可用于任意非数字元素的向量，例如字符串:

julia> permutedims(["a", "b", "c"])
1×3 Matrix{String}:
 "a"  "b"  "c"

对于数字向量’permutedims(v)`的工作方式与`transpose(v)'大致相同，只是返回类型不同（使用 'reshape'，而不是’LinearAlgebra的表示。转置'，尽管在这两种情况下使用与原始数组’v`相同的内存区域）:

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

julia> p = permutedims(v)
1×4 Matrix{Int64}:
 1  2  3  4

julia> r = transpose(v)
1×4 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3  4

julia> p == r
true

julia> typeof(r)
Transpose{Int64, Vector{Int64}}

julia> p[1] = 5; r[2] = 6; # при изменении p или r также изменяется v

julia> v # размещается в одной области памяти с p и r
4-element Vector{Int64}:
 5
 6
 3
 4

然而，对于元素本身是数字矩阵的向量，`permutedims`产生的结果与’transpose’的结果不同。:

julia> V = [[[1 2; 3 4]]; [[5 6; 7 8]]]
2-element Vector{Matrix{Int64}}:
 [1 2; 3 4]
 [5 6; 7 8]

julia> permutedims(V)
1×2 Matrix{Matrix{Int64}}:
 [1 2; 3 4]  [5 6; 7 8]

julia> transpose(V)
1×2 transpose(::Vector{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 3; 2 4]  [5 7; 6 8]

# '基。permutedims！`-Function</no-翻译>

permutedims!(dest, src, perm)

停止测量’src’数组并将结果保存在’dest’数组中。 'perm’是表示长度`ndims(src)'的置换的向量。预先分配的`dest`数组必须具有`size(dest)==size(src)[perm]'并被完全复盖。不支持就地置换，如果’src’和’dest’具有重叠的内存区域，则应该预期意外的结果。

另请参阅说明 'permutedims'。

# '基。PermutedDimsArrays.PermutedDimsArray'-Type

PermutedDimsArray(A, perm) -> B

对于给定的AbstractArray’A’创建`B`的表示形式，使维度看起来重新排列。类似于’permutedims'，除了不执行复制（`B`使用与’A’相同的内存区域）。

另请参阅说明 'permutedims'和 'invperm'。

例子

julia> A = rand(3,5,4);

julia> B = PermutedDimsArray(A, (3,1,2));

julia>尺寸(B)
(4, 3, 5)

julia>B[3,1,2]==A[1,2,3]
真的

# '基。promote_shape'-Function

promote_shape(s1, s2)

检查两个数组形状的兼容性，允许有限的单个维度，并返回具有更多维度的形状。

例子

julia> a = fill(1, (3,4,1,1,1));

julia> b = fill(1, (3,4));

julia> promote_shape(a,b)
(Base.OneTo(3), Base.OneTo(4), Base.OneTo(1), Base.OneTo(1), Base.OneTo(1))

julia> promote_shape((2,3,1,4), (2, 3, 1, 4, 1))
(2, 3, 1, 4, 1)

处理数组的函数

# '基。累积`-Function

accumulate(op, A; dims::Integer, [init])

数组`A`的`dims`维度中的累积操作`op`（为向量提供`dims`是可选的）。如有必要，您可以使用命名参数指定`init`的初始值。另请参阅说明 '积累！`具有关于使用预先分配的输出阵列以确保适当的性能和控制输出数据的准确性（例如，避免溢出）的信息。

常见操作有专门的"累积"选项。请参阅说明 cumsum'和 'cumprod'。有关延迟版本的信息，请参阅说明 '迭代器。累加。

兼容性：Julia1.5

要将`accumulate’用于与数组无关的迭代器，需要至少1.5的Julia版本。

例子

julia> accumulate(+, [1,2,3])
3-element Vector{Int64}:
 1
 3
 6

julia> accumulate(min, (1, -2, 3, -4, 5), init=0)
(0, -2, -2, -4, -4)

julia> accumulate(/, (2, 4, Inf), init=100)
(50.0, 12.5, 0.0)

julia> accumulate(=>, i^2 for i in 1:3)
3-element Vector{Any}:
          1
        1 => 4
 (1 => 4) => 9

julia> accumulate(+, fill(1, 3, 4))
3×4 Matrix{Int64}:
 1  4  7  10
 2  5  8  11
 3  6  9  12

julia> accumulate(+, fill(1, 2, 5), dims=2, init=100.0)
2×5 Matrix{Float64}:
 101.0  102.0  103.0  104.0  105.0
 101.0  102.0  103.0  104.0  105.0

# '基。积累！`-Function</no-翻译>

accumulate!(op, B, A; [dims], [init])

在`dims`的维度中与`a`进行`op’的累积操作，同时将结果存储在’B’中。没有必要为载体提供`dims'。如果指定了命名参数’init`，则其值用于创建累积。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

另请参阅说明 '积累', 'cumsum！和 'cumprod！.

例子

julia> x = [1, 0, 2, 0, 3];

julia> y = rand(5);

julia> accumulate!(+, y, x);

julia> y
5-element Vector{Float64}:
 1.0
 1.0
 3.0
 3.0
 6.0

julia> A = [1 2 3; 4 5 6];

julia> B = similar(A);

julia> accumulate!(-, B, A, dims=1)
2×3 Matrix{Int64}:
  1   2   3
 -3  -3  -3

julia> accumulate!(*, B, A, dims=2, init=10)
2×3 Matrix{Int64}:
 10   20    60
 40  200  1200

# '基。cumprod'-Function

cumprod(A; dims::Integer)

"暗淡"维度中的累积积。另请参阅说明 'cumprod！`具有关于使用预先分配的输出阵列以确保适当的性能和控制输出数据的精度（例如，避免溢出）的信息。

例子

julia> a = Int8[1 2 3; 4 5 6];

julia> cumprod(a, dims=1)
2×3 Matrix{Int64}:
 1   2   3
 4  10  18

julia> cumprod(a, dims=2)
2×3 Matrix{Int64}:
 1   2    6
 4  20  120

cumprod(itr)

迭代器的累积积。

另请参阅说明 'cumprod！`, '积累'和 'cumsum'。

兼容性：Julia1.5

要将`cumprod’用于与数组无关的迭代器，需要至少1.5的Julia版本。

例子

julia> cumprod(fill(1//2, 3))
3-element Vector{Rational{Int64}}:
 1//2
 1//4
 1//8

julia> cumprod((1, 2, 1, 3, 1))
(1, 2, 2, 6, 6)

julia> cumprod("julia")
5-element Vector{String}:
 "j"
 "ju"
 "jul"
 "juli"
 "julia"

# '基。cumprod！`-Function</no-翻译>

cumprod!(B, A; dims::Integer)

`Dims`维度中`A`的累积乘积，结果存储在’B’中。另请参阅说明 'cumprod'。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

cumprod!(y::AbstractVector, x::AbstractVector)

向量`x`与结果存储在`y`中的累积积。另请参阅说明 'cumprod'。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

# '基。cumsum'-Function

cumsum(A; dims::Integer)

"Dims"维度中的累积总和。另请参阅说明 'cumsum！`具有关于使用预先分配的输出阵列以确保适当的性能和控制输出数据的准确性（例如，避免溢出）的信息。

例子

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

julia> cumsum(a, dims=1)
2×3 Matrix{Int64}:
 1  2  3
 5  7  9

julia> cumsum(a, dims=2)
2×3 Matrix{Int64}:
 1  3   6
 4  9  15

Eltype’数组的返回类型对于小于系统字大小的有符号整数为’Int，对于小于系统字大小的无符号整数为`UInt'。要使用小的有符号或无符号整数存储`eltype`数组，请使用’accumulate(+,A)'。

julia>cumsum(Int8[100,28])
2元素向量{Int64}:
 100
 128
julia>accumulate(+,Int8[100,28])2元素向量{Int8}: 100 -128

在前一种情况下，整数被扩大到系统字大小，因此结果是’Int64[100,128]'。在后一种情况下，没有发生这种扩展，整数溢出导致’Int8[100，-128]'。

cumsum(itr)

迭代器的累积和。

请参阅 `accumulate'应用'+'以外的函数。

兼容性：Julia1.5

非数组迭代器上的’cumsum’至少需要Julia1.5。

例子

julia> cumsum(1:3)
3-element Vector{Int64}:
 1
 3
 6

julia> cumsum((true, false, true, false, true))
(1, 1, 2, 2, 3)

julia> cumsum(fill(1, 2) for i in 1:3)
3-element Vector{Vector{Int64}}:
 [1, 1]
 [2, 2]
 [3, 3]

# '基。赞姆！`-Function</no-翻译>

cumsum!(B, A; dims::Integer)

"Dims"维度中"a"的累积总和，结果存储在"B"中。另请参阅说明 'cumsum'。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

# '基。diff'-Function

diff(A::AbstractVector)
diff(A::AbstractArray; dims::Integer)

向量或多维数组`A’的有限差分运算符。在后一种情况下，应该使用命名参数"dims"指定要执行操作的维度。

兼容性：Julia1.1

要对维度高于2的数组使用’diff'，需要至少1.1的Julia版本。

例子

julia> a = [2 4; 6 16]
2×2 Matrix{Int64}:
 2   4
 6  16

julia> diff(a, dims=2)
2×1 Matrix{Int64}:
  2
 10

julia> diff(vec(a))
3-element Vector{Int64}:
  4
 -2
 12

# '基。重复'-Function

repeat(A::AbstractArray, counts::Integer...)

通过在每个维度中重复数组"A"设定次数（使用"计数"指定）来创建数组。

另请参阅说明 '填充', '迭代器。重复', '迭代器。循环'。

例子

julia> repeat([1, 2, 3], 2)
6-element Vector{Int64}:
 1
 2
 3
 1
 2
 3

julia> repeat([1, 2, 3], 2, 3)
6×3 Matrix{Int64}:
 1  1  1
 2  2  2
 3  3  3
 1  1  1
 2  2  2
 3  3  3

repeat(A::AbstractArray; inner=ntuple(Returns(1), ndims(A)), outer=ntuple(Returns(1), ndims(A)))

通过重复条目"A"创建一个数组。第i个元素`inner’设置数组`A’的第i维的单个条目的重复次数。第i个元素`outer’设置数组’A’的第i维切片的重复次数。如果省略’inner’或’outer`，则不执行重复。

例子

julia> repeat(1:2, inner=2)
4-element Vector{Int64}:
 1
 1
 2
 2

julia> repeat(1:2, outer=2)
4-element Vector{Int64}:
 1
 2
 1
 2

julia> repeat([1 2; 3 4], inner=(2, 1), outer=(1, 3))
4×6 Matrix{Int64}:
 1  2  1  2  1  2
 1  2  1  2  1  2
 3  4  3  4  3  4
 3  4  3  4  3  4

repeat(s::AbstractString, r::Integer)

重复字符串’r’次。这可以写成's^r'。

另请参阅方法的描述 ^.

例子

julia> repeat("ha", 3)
"hahaha"

repeat(c::AbstractChar, r::Integer) -> String

重复字符’r’一次。这也可以通过调用 'c^r'。

例子

julia> repeat('A', 3)
"AAA"

# '基。rot180'-Function

rot180(A)

将矩阵’A’旋转180度。

例子

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

julia> rot180(a)
2×2 Matrix{Int64}:
 4  3
 2  1

rot180(A, k)

将矩阵`A’旋转180度整数次’k'。如果’k’是偶数，则相当于’复制'。

例子

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

julia> rot180(a,1)
2×2 Matrix{Int64}:
 4  3
 2  1

julia> rot180(a,2)
2×2 Matrix{Int64}:
 1  2
 3  4

# '基。rotl90'-Function

rotl90(A)

将矩阵`A`向左旋转90度。

例子

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

julia> rotl90(a)
2×2 Matrix{Int64}:
 2  4
 1  3

rotl90(A, k)

将矩阵`A`向左逆时针旋转90度整数次`k'。如果’k’是四的倍数（包括零），则相当于`复制`。

例子

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

julia> rotl90(a,1)
2×2 Matrix{Int64}:
 2  4
 1  3

julia> rotl90(a,2)
2×2 Matrix{Int64}:
 4  3
 2  1

julia> rotl90(a,3)
2×2 Matrix{Int64}:
 3  1
 4  2

julia> rotl90(a,4)
2×2 Matrix{Int64}:
 1  2
 3  4

# '基。rotr90'-Function

rotr90(A)

将矩阵’A’向右旋转90度。

例子

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

julia> rotr90(a)
2×2 Matrix{Int64}:
 3  1
 4  2

rotr90(A, k)

将矩阵`A`向右顺时针旋转90度整数次`k'。如果’k’是四的倍数（包括零），则相当于`复制`。

例子

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

julia> rotr90(a,1)
2×2 Matrix{Int64}:
 3  1
 4  2

julia> rotr90(a,2)
2×2 Matrix{Int64}:
 4  3
 2  1

julia> rotr90(a,3)
2×2 Matrix{Int64}:
 2  4
 1  3

julia> rotr90(a,4)
2×2 Matrix{Int64}:
 1  2
 3  4

# '基。mapslices'-Function

mapslices(f, A; dims)

通过将函数`f`应用于形状`a[的每个切片来转换数组`A`的指定维度。.., :, ..., :, ...]`，在`dims`中每个`d’都有一个冒号。结果在其余维度中串联。

例如，如果’dims=和`A`是四维的，则在`x=a[:,:,i,j]`中调用`f，因为所有`i`和`j`和`f（x）`变成`R[:,:,i,j]`作为`R’的结果。

另请参阅说明 'eachcol'或 `eachslice'，与 '地图'或 '堆栈'。

例子

julia> A = reshape(1:30,(2,5,3))
2×5×3 reshape(::UnitRange{Int64}, 2, 5, 3) with eltype Int64:
[:, :, 1] =
 1  3  5  7   9
 2  4  6  8  10

[:, :, 2] =
 11  13  15  17  19
 12  14  16  18  20

[:, :, 3] =
 21  23  25  27  29
 22  24  26  28  30

julia> f(x::Matrix) = fill(x[1,1], 1,4);  # возвращает матрицу 1×4

julia> B = mapslices(f, A, dims=(1,2))
1×4×3 Array{Int64, 3}:
[:, :, 1] =
 1  1  1  1

[:, :, 2] =
 11  11  11  11

[:, :, 3] =
 21  21  21  21

julia> f2(x::AbstractMatrix) = fill(x[1,1], 1,4);

julia> B == stack(f2, eachslice(A, dims=3))
true

julia> g(x) = x[begin] // x[end-1];  # возвращает число

julia> mapslices(g, A, dims=[1,3])
1×5×1 Array{Rational{Int64}, 3}:
[:, :, 1] =
 1//21  3//23  1//5  7//27  9//29

julia> map(g, eachslice(A, dims=2))
5-element Vector{Rational{Int64}}:
 1//21
 3//23
 1//5
 7//27
 9//29

julia> mapslices(sum, A; dims=(1,3)) == sum(A; dims=(1,3))
true

请注意，在’eachslice(A;dims=2)'中指定的维度_在切片中没有冒号。这是`view(a,:,i,:)，而`mapslices(f,A;dims=(1,3))`使用’a[:,i,:]。函数’f’可以在不影响`A`的情况下更改切片中的值。

# '基。eachrow'-Function

eachrow(A::AbstractVecOrMat) <: AbstractVector

创建对象 'RowSlices'，它是矩阵或向量`A’的行向量。线切片作为`AbstractVector``A`的表示形式返回。

有关反向操作，请参阅说明 '堆栈''（行;dims=1）'。

另请参阅说明 '每个', `eachslice'和 'mapslices'。

兼容性：Julia1.1

此功能需要至少1.1的Julia版本。

兼容性：Julia1.9

在Julia1.9版本之前，返回了迭代器。

例子

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

julia> s = eachrow(a)
2-element RowSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}}:
 [1, 2]
 [3, 4]

julia> s[1]
2-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2

# *'基。每个'`-Function

eachcol(A::AbstractVecOrMat) <: AbstractVector

创建对象 'ColumnSlices'，它是矩阵或向量`A’的列向量。列切片作为`AbstractVector``A`的表示形式返回。

有关反向操作，请参阅说明 'stack'`(cols)'或`reduce(''hcat''，cols)'。

另请参阅说明 '每个月`, `eachslice'和 'mapslices'。

兼容性：Julia1.1

此功能需要至少1.1的Julia版本。

兼容性：Julia1.9

在Julia1.9版本之前，返回了迭代器。

例子

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

julia> s = eachcol(a)
2-element ColumnSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}}:
 [1, 3]
 [2, 4]

julia> s[1]
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3

# '基。每个slice'-Function

eachslice(A::AbstractArray; dims, drop=true)

创建对象 'Slices'，它是对象`a`的`dims`维度中的切片数组，返回从`A’中的其他维度中选择所有数据的视图。 'dims’可以是整数或整数元组。

如果’drop=true'（默认），'Slices’的外部切片将丢弃内部尺寸，并且测量的顺序将与`dims’中的顺序匹配。如果’drop=false'，切片将具有与基数组相同的维度，并且内部维度的大小将为1。 Eachslice(A;dims::Integer)'的反向动作参见说明 '堆栈'（切片;暗淡）'。

另请参阅说明 '每个月`, '每个', 'mapslices'和 'selectdim'。

兼容性：Julia1.1

此功能需要至少1.1的Julia版本。

兼容性：Julia1.9

在Julia1.9之前，返回迭代器，dims中仅支持一个维度。

例子

julia> m = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
 1  2  3
 4  5  6
 7  8  9

julia> s = eachslice(m, dims=1)
3-element RowSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}}:
 [1, 2, 3]
 [4, 5, 6]
 [7, 8, 9]

julia> s[1]
3-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2
 3

julia> eachslice(m, dims=1, drop=false)
3×1 Slices{Matrix{Int64}, Tuple{Int64, Colon}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}, 2}:
 [1, 2, 3]
 [4, 5, 6]
 [7, 8, 9]

组合学

# '基。invperm'-Function

invperm(v)

返回`v’的反向排列。如果’B=A[v]'，则’A==B[invperm(v)]`。

另请参阅说明 'sortperm', 'invpermute！`, `isperm'和 'permutedims'。

例子

julia> p = (2, 3, 1);

julia> invperm(p)
(3, 1, 2)

julia> v = [2; 4; 3; 1];

julia> invperm(v)
4-element Vector{Int64}:
 4
 1
 3
 2

julia> A = ['a','b','c','d'];

julia> B = A[v]
4-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> B[invperm(v)]
4-element Vector{Char}:
 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)

# '基。isperm'-Function

isperm(v) -> Bool

如果"v"是有效的置换，则返回"true"。

例子

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

# '基。胡说八道！`-Method</no-翻译>

permute!(v, p)

根据置换`p`将向量`v’重置到位。不执行`p`是置换的检查。

要返回新的排列，请使用’v[p]'。它通常比`permute！(v,p)`;当使用’u将数据写入预先分配的输出数组时，将获得更快的结果。=@view v[p]'。（虽然’permute！"复盖"v"到位，需要内部内存分配来跟踪哪些元素已被移动。)

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

另请参阅说明 'invpermute！`.

例子

julia> A = [1, 1, 3, 4];

julia> perm = [2, 4, 3, 1];

julia> permute!(A, perm);

julia> A
4-element Vector{Int64}:
 1
 4
 3
 1

# '基。invpermute！`-Function</no-翻译>

invpermute!(v, p)

同样地 'permute！`，但应用反向置换。

请注意，对于预先分配的输出数组（例如，u=similar(v)），使用`u[p]=v`会更快。（'invpermute！'自动为数据副本分配内存。)

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

例子

julia> A = [1, 1, 3, 4];

julia> perm = [2, 4, 3, 1];

julia> invpermute!(A, perm);

julia> A
4-element Vector{Int64}:
 4
 1
 3
 1

# '基。反向`-Method</no-翻译>

reverse(A; dims=:)

在维度`dims`中执行`A’的反转，它可以是整数值（一维），整数值元组（维度元组）或`：（在所有维度中反转，默认情况下使用）。另请参阅说明 '反转！进行现场逆转。

例子

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

julia> reverse(b, dims=2)
2×2 Matrix{Int64}:
 2  1
 4  3

julia> reverse(b)
2×2 Matrix{Int64}:
 4  3
 2  1

兼容性：Julia1.6

在Julia1.6之前，'reverse’只支持单个整数’dims'。

# '基。reverseind'-Function

reverseind(v, i)

考虑到索引’i’在 'reverse(v’返回`v’中的相应索引，以便’v[reverse(v,i)]==reverse(v)[i]`。（在`v`包含非ASCII字符的情况下，这可能是非平凡的。)

例子

julia> s = "Julia🚀"
"Julia🚀"

julia> r = reverse(s)
"🚀ailuJ"

julia> for i in eachindex(s)
           print(r[reverseind(r, i)])
       end
Julia🚀

# '基。倒过来！`-Function</no-翻译>

reverse!(v [, start=firstindex(v) [, stop=lastindex(v) ]]) -> v

版本 '反向'，现场表演。

例子

julia> A = Vector(1:5)
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia> reverse!(A);

julia> A
5-element Vector{Int64}:
 5
 4
 3
 2
 1

reverse!(A; dims=:)

同样地 '反向'，但在`A’中工作到位。

兼容性：Julia1.6

对于多维函数’反向！'需要至少1.6的Julia版本。