数组
构造函数和类型
# *`核心。阵列`*-Method
Array{T}(undef, dims)
Array{T,N}(undef, dims)构造一个未初始化的 N-尺寸 阵列包含类型的元素 T. N 可以显式提供，如 阵列{T,N}（undef，dims），或由长度或数目决定 暗淡无光. 暗淡无光 可以是一个元组或一系列与每个维度中的长度相对应的整数参数。 如果排名 N 是显式提供的，那么它必须匹配的长度或数量 暗淡无光. 这里 unef是 UndefInitializer碌录潞陆.
*例子*
julia> A = Array{Float64, 2}(undef, 2, 3) # N given explicitly
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 determined by the input
4-element Vector{Float64}:
2.360075077e-314
NaN
2.2671131793e-314
2.299821756e-314
julia> similar(B, 2, 4, 1) # use typeof(B), and the given size
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
Array{T}(nothing, dims)
Array{T,N}(nothing, dims)*例子*
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
Array{T}(missing, dims)
Array{T,N}(missing, dims)*例子*
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# *`核心。unef`*-注册_
undef别名为 UndefInitializer（），它构造单例类型的实例 UndefInitializer碌录潞陆，在数组初始化中用于指示array-constructor-caller想要一个未初始化的数组。
*例子*
julia> Array{Float64, 1}(undef, 3)
3-element Vector{Float64}:
2.2752528595e-314
2.202942107e-314
2.275252907e-314# *`基地。StridedVecOrMat的`*-类型
StridedVecOrMat{T}联合类型的 StridedVector碌录潞陆和 StridedMatrix禄忙猫潞镁鹿芦掳戮掳与类型的元素 T.
# *`核心。通用记忆`*-类型
GenericMemory{kind::Symbol, T, addrspace=Core.CPU} <: DenseVector{T}固定尺寸 DenseVector{T}.
种 目前可以是 ：not_atomic 或 :原子. 有关详情 :原子 暗示，见 原子记忆
地址空间 目前只能设置为 核心。中央处理器. 它的设计是为了允许其他系统（如GPUs）扩展，这些系统可能定义如下的值:
module CUDA
const Generic = bitcast(Core.AddrSpace{CUDA}, 0)
const Global = bitcast(Core.AddrSpace{CUDA}, 1)
end这些其他addrspaces的确切语义由特定的后端定义，但如果用户试图在CPU上访问这些，则会出错。
|
兼容性
Julia1.11这种类型需要Julia1.11或更高版本。 |
# *`核心。记忆`*-类型
Memory{T} == GenericMemory{:not_atomic, T, Core.CPU}固定尺寸 DenseVector{T}.
|
兼容性
Julia1.11这种类型需要Julia1.11或更高版本。 |
# *`核心。memoryref`*-函数
memoryref(::GenericMemory, index::Integer)
memoryref(::GenericMemoryRef, index::Integer)构建一个 [医]泛型 从内存对象和偏移索引（基于1），也可以是负数。 这总是返回一个inbounds对象，如果这是不可能的，将抛出一个错误（因为索引将导致基础内存的移位越界）。
memoryref(::GenericMemory)构建一个 [医]泛型 从内存对象。 这不会失败，但当且仅当内存为空时，生成的内存才会指出越界。
# *`基地。getindex,getindex`*-Method
getindex(type[, elements...])构造指定类型的一维数组。 这通常与语法一起调用 类型[]. 可以使用以下方法指定元素值 类型[a,b,c,...].
*例子*
julia> Int8[1, 2, 3]
3-element Vector{Int8}:
1
2
3
julia> getindex(Int8, 1, 2, 3)
3-element Vector{Int8}:
1
2
3# *`基地。虚假`*-函数
falses(dims)创建一个 比特阵列 将所有值设置为 错误.
*例子*
julia> falses(2,3)
2×3 BitMatrix:
0 0 0
0 0 0# *`基地。填充`*-函数
fill(value, dims::Tuple)
fill(value, dims...)创建大小的数组 暗淡无光 每个位置都设置为 价值.
例如, 填充(1.0,(5,5)) 返回一个5×5的浮动数组， 1.0 在阵列的每个位置。
尺寸长度 暗淡无光 可以指定为元组或参数序列。 一个 N-长度元组或 N 以下的论点 价值 指定一个 N-维数组。 因此，创建零维数组的常见习惯用法，其唯一位置设置为 x 是 填充(x).
返回数组的每个位置都设置为（因此 ===至）的 价值 这是通过;这意味着，如果 价值 它本身被修改，所有的元素 填充ed数组将反映该修改，因为它们非常_still_ 价值. 这与我们无关 填充(1.0,(5,5)) 作为 价值 1.0 是不可变的，本身不能被修改，但是对于可变的值（最常见的是数组）来说可能是意想不到的。 例如, 填充([],3) 在返回向量的所有三个位置放置_the very same_空数组:
julia> v = fill([], 3)
3-element Vector{Vector{Any}}:
[]
[]
[]
julia> v[1] === v[2] === v[3]
true
julia> value = v[1]
Any[]
茱莉亚推！(值，867_5309)
1元素向量{Any}:
8675309
朱莉娅>v
3元素向量{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) # sets both elements to the same [0.0, 0.0] vector
2-element Vector{Vector{Float64}}:
[0.0, 0.0]
[0.0, 0.0]
julia> A[1][1] = 42; # modifies the filled value to be [42.0, 0.0]
julia> A # both A[1] and A[2] are the very same vector
2-element Vector{Vector{Float64}}:
[42.0, 0.0]
[42.0, 0.0]# *`基地。填满！`*-函数
fill!(A, x)填充数组 A 与值 x. 如果 x 是一个对象引用，所有元素都会引用同一个对象。 填满！（A，Foo（）） 会回来 A 充满了评估的结果 食物() 有一次。
*例子*
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# *`基地。空的`*-函数
empty(a::AbstractDict, [index_type=keytype(a)], [value_type=valtype(a)])创建一个空 摘要;摘要 可接受类型索引的容器 索引_类型 和类型的值 值_类型. 第二个和第三个参数是可选的，默认为输入的 密钥类型 和 [医]valtype，分别。 （如果只指定了两种类型中的一种，则假定为 值_类型，而 索引_类型 我们默认 键类型(a)).
海关规定 摘要;摘要 子类型可以选择哪个特定的字典类型最适合返回给定的索引和值类型，通过专门化三参数签名。 默认是返回一个空 Dict,Dict.
empty(v::AbstractVector, [eltype])创建一个类似于 v，可选地改变 eltype,eltype.
*例子*
julia> empty([1.0, 2.0, 3.0])
Float64[]
julia> empty([1.0, 2.0, 3.0], String)
String[]empty(x::Tuple)返回一个空元组, ().
# *`基地。类似的`*-函数
similar(A::AbstractSparseMatrixCSC{Tv,Ti}, [::Type{TvNew}, ::Type{TiNew}, m::Integer, n::Integer]) where {Tv,Ti}根据给定的源，使用给定的元素类型、索引类型和大小创建未初始化的可变数组 [医]麻雀. 新的稀疏矩阵保持原始稀疏矩阵的结构，除了在输出矩阵的维度与输出不同的情况下。
输出矩阵在与输入相同的位置上有零，但非零位置的值未初始化。
similar(storagetype, axes)创建一个未初始化的可变数组，类似于 存储类型，但与 轴心 由最后一个参数指定。
*例子*:
similar(Array{Int}, axes(A))创建一个"行为类似"的数组 数组{Int} （并且可能确实由一个支持），但是索引与 A. 如果 A 具有常规索引，这将与 数组{Int}(undef,尺寸(A))，但如果 A 具有非常规索引，然后结果的索引将匹配 A.
similar(BitArray, (axes(A, 2),))将创建一个一维逻辑数组，其索引与 A.
similar(array, [element_type=eltype(array)], [dims=size(array)])根据给定的源数组，使用给定的元素类型和大小创建一个未初始化的可变数组。 第二个和第三个参数都是可选的，默认为给定数组的 eltype,eltype 和 大小. 维度可以指定为单个元组参数或一系列整数参数。
自定义AbstractArray子类型可以选择哪种特定数组类型最适合为给定的元素类型和维度返回。 如果他们不专门化此方法，则默认为 数组{element_type}（undef，dims。..).
例如, 类似(1:10,1,4) 返回未初始化的 阵列{Int,2} 因为范围既不是可变的，也不支持二维:
julia> similar(1:10, 1, 4)
1×4 Matrix{Int64}:
4419743872 4374413872 4419743888 0反过来说, 类似(trues(10,10),2) 返回未初始化的 比特克托 由于有两个元素 比特阵列s都是可变的，可以支持一维数组:
julia> similar(trues(10,10), 2)
2-element BitVector:
0
0自 比特阵列s只能存储类型的元素 布尔，但是，如果您请求不同的元素类型，它将创建一个常规 阵列 相反，:
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基本功能
# *`基地。轴心`*-Method
axes(A, d)返回数组的有效索引范围 A 沿尺寸 d.
请参阅 大小，以及关于 带有自定义索引的数组。
*例子*
julia> A = fill(1, (5,6,7));
julia> axes(A, 2)
Base.OneTo(6)
julia> axes(A, 4) == 1:1 # all dimensions d > ndims(A) have size 1
true*使用说明*
每个指数都必须是 N.抽象,抽象{<:Integer}，但在同一时间可以是使用自定义索引的类型。 因此，例如，如果您需要一个子集，请使用广义索引构造，例如 開始啦。/结束 或 第一索引/lastindex,lastindex:
ix = axes(v, 1)
ix[2:end] # will work for eg Vector, but may fail in general
ix[(begin+1):end] # works for generalized indexes# *`基地。长度`*-Method
length(A::AbstractArray)返回数组中元素的个数，默认为 prod(尺寸(A)).
*例子*
julia> length([1, 2, 3, 4])
4
julia> length([1 2; 3 4])
4# *`基地。钥匙`*-Method
keys(a::AbstractArray)返回一个有效的数组，描述所有有效的索引 a 排列成 a 本身。
1维数组（向量）的键是整数，而所有其他N维数组使用 [医CartesianIndex]来描述它们的位置。 通常是特殊的数组类型 线性;线性和 [医笛卡尔]用于有效地表示这些整数数组和 [医]CartesianIndex分别为es。
请注意， 钥匙 数组可能不是最有效的索引类型；为了获得最大的性能使用 每个索引代替。
*例子*
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))# *`基地。每个索引`*-函数
eachindex(A...)
eachindex(::IndexStyle, A::AbstractArray...)创建一个可迭代对象，用于访问 抽象阵列 A 以有效的方式。 对于选择了快速线性索引的数组类型（如 阵列），这只是范围 1:长度(A) 如果他们使用基于1的索引。 对于没有选择快速线性索引的数组类型，通常会返回一个专门的笛卡尔范围，以有效地索引到数组中，并为每个维度指定索引。
一般说来 每个索引 接受任意迭代器，包括字符串和字典，并返回支持任意索引类型（例如，间距不均匀或非整数索引）的迭代器对象。
如果 A 是 抽象阵列 可以显式指定应由 每个索引 通过传递具有 索引样式 类型作为其第一个参数（通常 索引线() 如果需要线性指数或 IndexCartesian() 如果需要笛卡尔范围）。
如果您提供多个 抽象阵列 论点, 每个索引 将创建一个可迭代对象，该对象对所有参数都很快（通常是 单位范围如果所有输入都具有快速线性索引，则 [医笛卡尔]否则）。 如果数组具有不同的大小和/或维度，则 尺寸表 异常将被抛出。
*例子*
julia> A = [10 20; 30 40];
julia> for i in eachindex(A) # linear indexing
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)) # Cartesian indexing
println(i)
end
CartesianIndex(1, 1)
CartesianIndex(2, 1)# *`基地。索引样式`*-类型
IndexStyle(A)
IndexStyle(typeof(A))Base.IndexStyle(::Type{<:MyArray}) = IndexLinear()默认值为 IndexCartesian().
Julia的内部索引机制将自动（并且不可见地）将所有索引操作重新计算为首选样式。 这允许用户使用任何索引样式访问数组的元素，即使未提供显式方法也是如此。
如果您为您的 抽象阵列，此特性可用于选择性能最高的索引样式。 一些方法在其输入上检查此特性，并根据最有效的访问模式分配到不同的算法。 特别是, 每个索引创建一个迭代器，其类型取决于此特性的设置。
# *`基地。索引线`*-类型
IndexLinear()的亚型 索引样式用于描述由一个线性索引优化索引的数组。
线性索引样式使用一个整数索引来描述数组中的位置（即使它是一个多维数组），并且使用列主排序来有效地访问元素。 这意味着请求 每个索引从一个数组 索引线 将返回一个简单的一维范围，即使它是多维的。
一个自定义数组，报告其 索引样式 作为 索引线 只需要实现索引（和索引分配）与单个 Int型 索引；所有其他索引表达式—包括多维访问—将被重新计算到线性索引。 例如，如果 A 是一个 2×3 自定义矩阵与线性索引，我们参考 A[1,3]，这将被重新计算为等效的线性索引和调用 A[5] 自 1 + 2*(3 - 1) = 5.
请参阅 [医索引].
# *`基地。[医]索引`*-类型
IndexCartesian()A N-维自定义数组，报告其 索引样式 作为 [医]索引 需要精确地实现索引（和索引分配） N Int型 索引;所有其他索引表达式-包括线性索引-将重新计算到等效的笛卡尔位置。 例如，如果 A 是一个 2×3 自定义矩阵与笛卡尔索引，我们参考 A[5]，这将被重新计算为等价的笛卡尔指数和调用 A[1,3] 自 5 = 1 + 2*(3 - 1).
从线性索引计算笛卡尔指数比从另一个方向计算笛卡尔指数要昂贵得多。 前者操作需要除法-一个非常昂贵的操作-而后者只使用乘法和加法，并且基本上是免费的。 这种不对称意味着使用线性索引和 [医]索引 数组比使用笛卡尔索引与 索引线 阵列。
请参阅 [医索引线].
广播和矢量化
请参阅 矢量化函数的点语法；例如, f.(args...) 隐式调用 广播(f,args...). 而不是依赖于函数的"矢量化"方法，如 罪 要对数组进行操作，您应该使用 罪。(一) 通过矢量化 广播.
# *`基地。广播。广播`*-函数
broadcast(f, As...)广播功能 f 在数组、元组、集合上, 参考书s和/或标量 作为.
广播应用该功能 f 在容器参数和标量本身的元素上 作为. 单例和缺失维度通过虚拟重复该值来扩展以匹配其他参数的范围。 默认情况下，只有有限数量的类型被视为标量，包括 电话号码s, 字符串s, 符号s, 类型s, 功能s和一些常见的单例如 失踪和 什么都没有. 所有其他参数都被迭代或索引到elementwise中。
生成的容器类型由以下规则建立:
*如果所有参数都是标量或零维数组，则返回展开的标量。
*如果至少有一个参数是元组，而所有其他参数都是标量或零维数组，则返回元组。
*所有其他参数组合默认返回 阵列，但是自定义容器类型可以定义自己的实现和类似提升的规则，以便在它们作为参数显示时自定义结果。
*元素类型以与in相同的方式确定 收集资料.
存在用于广播的特殊语法: f.(args...) 相当于 广播(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"# *`基地。广播。广播！`*-函数
broadcast!(f, dest, As...)像 广播，但存储的结果 广播（f，As。..) 在 德斯特 阵列。 请注意 德斯特 仅用于存储结果，并且不向 f 除非它也列在 作为，如在 广播！（f，A，A，B） 要执行 A[:]=广播(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# *`基地。广播。@__点__`*-马科罗_
@. expr转换每个函数调用或运算符 expr 成"点调用"（例如转换 f(x) 到 f.(x)），并将每个赋值转换为 expr 到"点赋值"（例如转换 += 到 .+=).
如果你想_avoid_为选定的函数调用添加点 expr，将这些函数调用与 $. 例如, @. sqrt(abs($sort(x))) 相当于 sqrt的。（abs。(排序(x))) （没有点 排序).
(@. 相当于调用 @__点__.)
*例子*
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# *`基地。广播。广播功能`*-类型
BroadcastFunction{F} <: Function表示运算符的"虚线"版本，它通过其参数广播运算符，因此 广播功能(op) 在功能上等同于 (x．..）->（op）。(x．..).
可以通过将前面有一个点的运算符传递给高阶函数来创建。
*例子*
julia> a = [[1 3; 2 4], [5 7; 6 8]];
julia> b = [[9 11; 10 12], [13 15; 14 16]];
julia> map(.*, a, b)
2-element Vector{Matrix{Int64}}:
[9 33; 20 48]
[65 105; 84 128]
julia> Base.BroadcastFunction(+)(a, b) == a .+ b
true|
兼容性
朱莉娅1.6 |
有关在自定义类型上的特殊广播，请参阅
# *`基地。广播。广播电视`*-类型
广播电视 是一种抽象类型和特征函数，用于确定广播对象的行为。 BroadcastStyle(typeof(x)) 返回与之关联的样式 x. 要自定义类型的广播行为，可以通过定义类型/方法对来声明样式
struct MyContainerStyle <: BroadcastStyle end
Base.BroadcastStyle(::Type{<:MyContainer}) = MyContainerStyle()# *`基地。广播。[医]抽象派`*-类型
广播。[医]抽象派{N} <:BroadcastStyle 是任何与 抽象阵列 类型。 该 N parameter是维数，对于仅支持特定维数的AbstractArray类型来说，这很方便:
struct SparseMatrixStyle <: Broadcast.AbstractArrayStyle{2} end
Base.BroadcastStyle(::Type{<:SparseMatrixCSC}) = SparseMatrixStyle()为 抽象阵列 支持任意维数的类型, N 可以设置为 任何:
struct MyArrayStyle <: Broadcast.AbstractArrayStyle{Any} end
Base.BroadcastStyle(::Type{<:MyArray}) = MyArrayStyle()在您希望能够混合多个的情况下 [医]抽象派s并跟踪维度，你的风格需要支持一个 瓦尔构造函数:
struct MyArrayStyleDim{N} <: Broadcast.AbstractArrayStyle{N} end
(::Type{<:MyArrayStyleDim})(::Val{N}) where N = MyArrayStyleDim{N}()请注意，如果两个或更多 [医]抽象派 子类型冲突，广播机械将回落到生产 阵列s.如果这是不可取的，您可能需要定义二进制 广播电视控制输出类型的规则。
请参阅 广播。DefaultArrayStyle.
# *`基地。广播。广播电视`*-函数
Broadcast.broadcastable(x)如果 x 支持迭代，返回的值应该具有相同的 轴心 和索引行为作为 收集(x).
如果 x 不是一个 抽象阵列 但它支持 轴心、索引及其类型支持 ndims，则 broadcastable(::typeof(x)) 可以实现只是返回自己。 此外，如果 x 定义自己的 广播电视，那么它必须定义其 广播电视 自定义样式返回自己的方法有任何效果。
*例子*
julia> Broadcast.broadcastable([1,2,3]) # like `identity` since arrays already support axes and indexing
3-element Vector{Int64}:
1
2
3
julia> Broadcast.broadcastable(Int) # Types don't support axes, indexing, or iteration but are commonly used as scalars
Base.RefValue{Type{Int64}}(Int64)
julia> Broadcast.broadcastable("hello") # Strings break convention of matching iteration and act like a scalar instead
Base.RefValue{String}("hello")# *`基地。广播。组合/组合`*-函数
combine_axes(As...) -> Tuple确定在所有值之间广播的结果轴 作为.
julia> Broadcast.combine_axes([1], [1 2; 3 4; 5 6])
(Base.OneTo(3), Base.OneTo(2))
julia> Broadcast.combine_axes(1, 1, 1)
()# *`基地。广播。结果_style`*-函数
result_style(s1::BroadcastStyle[, s2::BroadcastStyle]) -> BroadcastStyle需要一两个 广播电视s并将它们组合使用 广播电视来确定一个共同的 广播电视.
*例子*
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,getindex`*-Method
getindex(A, inds...)返回数组的子集 A 由指数选择 inds.
每个索引可以是任何 支持的索引类型，例如 整数, [医CartesianIndex], 范围，或 数组。 A :可用于选择沿特定维度的所有元素，以及布尔数组（例如 数组{Bool} 或一个 比特阵列)可用于筛选对应索引为 真的.
何时 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元素向量{Int64}:
3
4
julia>getindex（A，A。> 2)
2元素向量{Int64}:
3
4# *`基地。setindex！`*-Method
setindex!(A, X, inds...)
A[inds...] = X存储数组中的值 X 在 A 由 inds. 语法 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(A, i)返回索引后 i 在 A. 返回的索引通常相当于 我+1 为整数 i. 此函数可用于泛型代码。
|
警告返回的索引可能超出范围。 考虑使用 |
请参阅: 上一页.
*例子*
julia> x = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> nextind(x, 1) # valid result
2
julia> nextind(x, 4) # invalid result
5
julia> nextind(x, CartesianIndex(1, 1)) # valid result
CartesianIndex(2, 1)
julia> nextind(x, CartesianIndex(2, 2)) # invalid result
CartesianIndex(1, 3)# *`基地。上一页`*-函数
prevind(A, i)返回索引之前 i 在 A. 返回的索引通常相当于 i-1 为整数 i. 此函数可用于泛型代码。
|
警告返回的索引可能超出范围。 考虑使用 |
请参阅: 下一篇.
*例子*
julia> x = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> prevind(x, 4) # valid result
3
julia> prevind(x, 1) # invalid result
0
julia> prevind(x, CartesianIndex(2, 2)) # valid result
CartesianIndex(1, 2)
julia> prevind(x, CartesianIndex(1, 1)) # invalid result
CartesianIndex(2, 0)# *`基地。收到！`*-Method
copyto!(dest, Rdest::CartesianIndices, src, Rsrc::CartesianIndices) -> dest复制 src公司 范围内的 Rsrc 到 德斯特 范围内的 最大的. 两个区域的大小必须匹配。
*例子*
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# *`基地。收到！`*-函数
copy!(dest::AbstractMatrix, src::UniformScaling)副本a 制服,制服到基质上。
|
兼容性
Julia1.12此方法自Julia1.12起可用。 |
copy!(dst, src) -> dst就地安置 副本的 src公司 进入 dst，丢弃任何预先存在的元素 dst. 如果 dst 和 src公司 是同一类型的, dst==src 应该在通话后保持。 如果 dst 和 src公司 是向量类型，它们必须具有相等的偏移量。 如果 dst 和 src公司 是多维数组，它们必须具有相等 轴心.
|
当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。 |
请参阅 收到！.
|
注意在对向量类型进行操作时，如果 |
|
兼容性
Julia1.1此方法至少需要Julia1.1。 在Julia1.0中，此方法可从 |
# *`基地。is分配`*-函数
isassigned(array, i) -> Bool测试给定数组是否具有与index关联的值 i. 回来吧 错误 如果索引超出范围，或者具有未定义的引用。
*例子*
julia> isassigned(rand(3, 3), 5)
true
julia> isassigned(rand(3, 3), 3 * 3 + 1)
false
julia> mutable struct Foo end
julia> v = similar(rand(3), Foo)
3-element Vector{Foo}:
#undef
#undef
#undef
julia> isassigned(v, 1)
false# *`基地。结肠`*-类型
Colon()冒号(:)用于表示一次索引整个对象或维度。
很少有操作直接在冒号上定义;相反，它们由 to_indices到内部向量类型(基地。切片）来表示它们在使用之前跨越的索引的集合。
的单例实例 结肠 也是用于构造范围的函数;请参阅 :.
# *`基地。IteratorsMD。[医]CartesianIndex`*-类型
CartesianIndex(i, j, k...) -> I
CartesianIndex((i, j, k...)) -> I创建多维索引 我，可用于对多维数组进行索引 A. 特别是, A[I] 相当于 A[i，j，k。..]. 人们可以自由地混合整数和 [医]CartesianIndex 指数；例如, A[Ipre，i，Ipost] （哪里 知识产权 和 Ipost的 是 [医]CartesianIndex 指数及 i 是一个 Int型 在编写沿着任意维数数组的单个维数工作的算法时，）可以是一个有用的表达式。
一个 I::CartesianIndex 被视为"标量"（而不是容器） 广播. 为了迭代一个组件 [医]CartesianIndex，将其转换为具有 元组(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|
兼容性
朱莉娅1.10使用 |
# *`基地。IteratorsMD。[医]笛卡尔`*-类型
CartesianIndices(sz::Dims) -> R
CartesianIndices((istart:[istep:]istop, jstart:[jstep:]jstop, ...)) -> R定义区域 R 跨越整数索引的多维矩形范围。 这些在迭代的上下文中最常见，其中 对于R中的I。.. 结束 会回来 [医CartesianIndex]指数 我 等效于嵌套循环
for j = jstart:jstep:jstop
for i = istart:istep:istop
...
end
end因此，这些对于编写在任意维度上工作的算法非常有用。
CartesianIndices(A::AbstractArray) -> R为方便起见，构建一个 [医]笛卡尔 从数组中生成一系列索引。
|
兼容性
Julia1.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))*线性和笛卡尔指数之间的转换*
线性索引到笛卡尔索引转换利用了一个事实，即 [医]笛卡尔 是一个 抽象阵列 并且可以线性索引:
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)*广播*
[医]笛卡尔 支持广播算术（+和-）与 [医]CartesianIndex.
|
兼容性
CartesianIndices的Julia1.1广播至少需要Julia1.1。 |
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(A::AbstractArray)返回a 线性;线性 具有相同形状的阵列和 轴心作为 A，持有每个条目的线性索引 A. 使用笛卡尔索引索引此数组允许将它们映射到线性索引。
对于具有常规索引（索引从1开始）的数组或任何多维数组，线性索引的范围从1到 长度(A). 然而，对于 [医]文摘s线性指数为 轴(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返回a 线性;线性 具有指定形状的数组或 轴心.
*例子*
此构造函数的主要目的是从笛卡尔到线性索引的直观转换:
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`*-函数
to_indices(A, I::Tuple)转换元组 我 用于索引到数组中的索引元组 A.
返回的元组只能包含 Int型s或 抽象阵列数组支持的标量索引的s A. 当遇到不知道如何处理的新颖索引类型时，它会出错。
对于简单的索引类型，它将推迟到未报告的索引类型 Base.to_index(A,i) 处理每个索引 i. 虽然这个内部函数并不打算直接调用, Base.to_index 可以通过自定义数组或索引类型进行扩展，以提供自定义索引行为。
更复杂的索引类型可能需要更多关于它们索引到的维度的上下文。 支持这些案件, to_indices(A,I) 电话 to_indices(A,轴(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)) # no bounds checking
(1, 1, 2, 20)
julia> to_indices(A, (CartesianIndex((1,)), 2, CartesianIndex((3,4)))) # exotic index
(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)) # no shape checking
(1, 2)# *`基地。支票/支票`*-函数
checkbounds(A, I...)如果指定的索引抛出一个错误 我 不在给定数组的范围内 A.
checkbounds(Bool, A, I...)回来吧 真的 如果指定的索引 我 给定数组的边界 A. 的亚型 抽象阵列 如果需要提供自定义边界检查行为，应该专门化此方法;但是，在许多情况下，可以依赖 A指数及 检查索引.
请参阅 检查索引.
*例子*
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# *`基地。埃尔斯特`*-函数
elsize(type)计算连续元素之间的内存步幅（以字节为单位） eltype,eltype存储在给定的内部 类型，如果数组元素以均匀的线性步幅密集存储。
*例子*
julia> Base.elsize(rand(Float32, 10))
4虽然大多数代码可以以与索引无关的方式编写（参见，例如, 每个索引），有时显式检查偏移轴是有用的:
# *`基地。需要_one_based_indexing`*-函数
require_one_based_indexing(A::AbstractArray)
require_one_based_indexing(A,B...)扔一个 [医]争论者 如果任何参数的索引以除 1 沿任意轴。 请参阅 has_offset_axes.
|
兼容性
Julia1.2此功能至少需要Julia1.2。 |
# *`基地。has_offset_axes`*-函数
has_offset_axes(A)
has_offset_axes(A, B, ...)回来吧 真的 如果指数 A 沿着任何轴从1以外的东西开始。 如果传递了多个参数，则等价于 has_offset_axes(A)||has_offset_axes(B)||。...
视图（子阵列和其他视图类型）
一个"`查看`"是一个像数组一样的数据结构（它是 抽象阵列），但底层数据实际上是另一个数组的一部分。
例如，如果 x 是一个数组和 v=@视图x[1:10]，则 v 行为像一个10元素数组，但它的数据实际上是访问的前10个元素 x. 写入视图，例如 v[3]=2，直接写入底层数组 x （在这种情况下） x[3]).
切片操作，如 x[1：10] 在Julia中默认创建一个副本。 @查看x[1:10] 更改它以创建视图。 该 @意见 宏可以用于整个代码块（例如 @views函数foo()。... 结束 或 @视图开始。.. 结束）将该块中的所有切片操作更改为使用视图。 有时制作数据的副本更快，有时使用视图更快，如 性能提示。
# *`基地。查看`*-函数
view(A, inds...)像 getindex,getindex，但返回一个轻量级数组，该数组懒惰地引用（或实际上是_view_到）父数组 A 在给定的指数或指数 inds 而不是急切地提取元素或构造复制的子集。 打电话来 getindex,getindex或 setindex！在返回的值（通常是一个 子阵列)计算索引以随时访问或修改父数组。 如果父数组的形状在之后更改，则行为未定义 查看 之所以被调用，是因为父数组没有绑定检查；例如，它可能导致分段错误。
一些不可变的父数组（如范围）可能会选择在某些情况下简单地重新计算一个新数组，而不是返回一个 子阵列 如果这样做是有效的，并提供兼容的语义。
|
兼容性
Julia1.6在Julia1.6或更高版本中, |
*例子*
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 # Note A has changed even though we modified b
2×2 Matrix{Int64}:
0 2
0 4
julia> view(2:5, 2:3) # returns a range as type is immutable
3:4# *`基地。@查看`*-马科罗_
@view A[inds...]转换索引表达式 A[inds...] 成等价物 查看呼叫。
这只能直接应用于单个索引表达式，对于包含特殊的表达式特别有用 開始啦。 或 结束 索引语法，如 A[开始,2:结束-1] （因为那些不受正常支持 查看功能）。
请注意 @查看 不能用作常规赋值的目标（例如, @view(A[1,2:end])=。..），没有装饰的人也不会 索引分配(A[1,2:结束]=。..）或广播索引分配（A[1,2:结束]。= ...）复制一份。 但是，对于_updating_broadcasted分配，它可能很有用，例如 @view(A[1,2:end])。+= 1 因为这是一个简单的语法 @view(A[1,2:end])。=@view(A[1,2:end])+1，而右边的索引表达式则会在没有 @查看.
请参阅 @意见将整个代码块切换为使用视图进行非标量索引。
|
兼容性
Julia1.5使用 |
*例子*
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 expression转换给定表达式中的每个数组切片操作（可能是 開始啦。/结束 块，循环，功能等。）返回视图。 标量索引、非数组类型和显式 getindex,getindex呼叫（而不是 数组[...]）不受影响。
同样地, @意见 将字符串切片转换为 子字符串意见。
|
注意 |
|
兼容性
朱莉娅1.5使用 |
*例子*
julia> A = zeros(3, 3);
julia> @views for row in 1:3
b = A[row, :] # b is a view, not a copy
b .= row # assign every element to the row index
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# *`基地。家长/家长`*-函数
parent(A)返回视图的底层父对象。 类型对象的父级 子阵列, 子字符串, 重新映射阵列 或 线性代数。转置,转置 是什么作为一个论点传递给 查看, 重塑形状, 转置,转置 等。 在对象创建期间。 如果输入不是包装对象，则返回输入本身。 如果输入被包装多次，则只会删除最外层的包装。
*例子*
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# *`基地。选择`*-函数
selectdim(A, d::Integer, i)返回所有数据的视图 A 维度索引的位置 d 平等 i.
相当于 视图(A,:,:,...,我,:,:,。..) 哪里 i 就位 d.
请参阅: 每张单张.
*例子*
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 view(::Matrix{Int64}, :, 3:4) with eltype Int64:
3 4
7 8# *`基地。重新诠释`*-函数
reinterpret(reshape, T, A::AbstractArray{S}) -> B更改类型-解释 A 在消费或添加"通道维度。"
如果 sizeof（T）=n*sizeof（S） 为 n>1, A第一个维度必须是大小 n 和 B 缺乏 A第一维度。 相反，如果 sizeof(S)=n*sizeof(T) 为 n>1, B 获取新的第一尺寸 n. 维数不变，如果 sizeof(T)==sizeof(S).
|
兼容性
Julia1.6此方法至少需要Julia1.6。 |
*例子*
julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> reinterpret(reshape, Complex{Int}, A) # the result is a vector
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) # the result is a matrix
3×2 reinterpret(reshape, Int64, ::Vector{Tuple{Int64, Int64, Int64}}) with eltype Int64:
1 4
2 5
3 6reinterpret(T::DataType, A::AbstractArray)用与给定数组相同的二进制数据构造数组的视图，但用 T 作为元素类型。
此函数也适用于"懒惰"数组，其元素在显式检索之前不会计算。 例如, 重新诠释 在范围内 1:6 与密集向量上的工作方式类似 收集(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)]); # showing will error
julia> b[1]
ERROR: Padding of type UInt32 is not compatible with type Tuple{UInt8, UInt32}.reinterpret(::Type{Out}, x::In)更改isbits值中二进制数据的类型解释 x 到isbit类型 出. 的大小（忽略填充） 出 必须与 x. 例如, 重新解释(Float32,UInt32(7)) 解释对应于4个字节 UInt32(7) 作为一个 漂浮物32. 请注意 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)。 |
|
警告如果某些位的组合在 |
# *`基地。重塑形状`*-函数
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# *`基地。插入,插入`*-函数
insertdims(A; dims)逆的 dropdims;返回一个数组，每个维度都有新的单例维度 暗淡无光.
禁止重复尺寸和最大的条目 暗淡无光 必须小于或等于 ndims(A)+长度(dims).
结果共享相同的基础数据 A，使得结果是可变的当且仅当 A 是可变的，设置一个元素会改变另一个元素的值。
*例子*
julia> x = [1 2 3; 4 5 6]
2×3 Matrix{Int64}:
1 2 3
4 5 6
julia> insertdims(x, dims=3)
2×3×1 Array{Int64, 3}:
[:, :, 1] =
1 2 3
4 5 6
julia> insertdims(x, dims=(1,2,5)) == reshape(x, 1, 1, 2, 3, 1)
true
julia> dropdims(insertdims(x, dims=(1,2,5)), dims=(1,2,5))
2×3 Matrix{Int64}:
1 2 3
4 5 6|
兼容性
Julia1.12需要Julia1.12或更高版本。 |
# *`基地。dropdims`*-函数
dropdims(A; dims)返回一个数据与 A，但尺寸由 暗淡无光 移走。 尺寸(A,d) 必须等于1为每 d 在 暗淡无光，以及外部重复的尺寸或数字 1：ndims（A） 是被禁止的。
结果共享相同的基础数据 A，使得结果是可变的当且仅当 A 是可变的，设置一个元素会改变另一个元素的值。
*例子*
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串联和排列
# *`Base.cat`*-函数
cat(A...; dims)将输入数组沿着指定的维度连接起来 暗淡无光.
沿着一个维度 d在dims，输出数组的大小为 sum(a中a的大小(a,d)). 沿着其他维度，所有输入数组都应该具有相同的大小，这也将是沿着这些维度的输出数组的大小。
如果 暗淡无光 是单个数字，不同的数组沿着该维度紧密包装。 如果 暗淡无光 是一个包含多个维度的迭代，每个输入数组沿这些维度的位置同时增加，在其他地方填充零。 这允许人们将块对角矩阵构造为 猫（矩阵。..;dims=(1,2))，以及它们的更高维度类似物。
关键字也接受 瓦尔(dims).
|
兼容性
Julia1.8用于多个维度 |
*例子*
连接两个不同维度的数组:
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*扩展帮助*
串联3D阵列:
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) # same as 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)) # block-diagonal
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 1julia> cat(1, [2], [3;;]; dims=Val(2))
1×3 Matrix{Int64}:
1 2 3|
注 |
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的`*-函数
vcat(A...)垂直连接数组或数字。 相当于 貓！(A．..;dims=1)，以及语法 [a;b;c].
连接数组的大向量, 减少(vcat,A) 调用一个有效的方法，当 一个isa AbstractVector{<:AbstractVecOrMat}，而不是两两工作。
*例子*
julia> v = vcat([1,2], [3,4])
4-element Vector{Int64}:
1
2
3
4
julia> v == vcat(1, 2, [3,4]) # accepts numbers
true
julia> v == [1; 2; [3,4]] # syntax for the same operation
true
julia> summary(ComplexF64[1; 2; [3,4]]) # syntax for supplying the element type
"4-element Vector{ComplexF64}"
julia> vcat(range(1, 2, length=3)) # collects lazy ranges
3-element Vector{Float64}:
1.0
1.5
2.0
julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9]) # row vector and a matrix
(adjoint([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) # more efficient than vcat(vs...)
6-element Vector{Int64}:
1
2
3
4
5
6
julia> ans == collect(Iterators.flatten(vs))
true# *`基地。hcat,hcat`*-函数
hcat(A...)水平连接数组或数字。 相当于 貓！(A．..;dims=2)，以及语法 [a b c] 或 [一;; b;; c].
对于数组的大向量, 减少(hcat,A) 调用一个有效的方法，当 一个isa AbstractVector{<:AbstractVecOrMat}. 对于一个向量的向量，这也可以写 堆叠(一).
*例子*
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]') # accepts numbers
1×7 Matrix{Int64}:
1 2 30 40 5 6 7
julia> ans == [1 2 [30 40] [5, 6, 7]'] # syntax for the same operation
true
julia> Float32[1 2 [30 40] [5, 6, 7]'] # syntax for supplying the eltype
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) # more efficient than 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 # disagrees on a vector of matrices
"2×2×3 Array{Float64, 3}"
julia> hcat(Int[], Int[], Int[]) # empty vectors, each of size (0,)
0×3 Matrix{Int64}
julia> hcat([1.1, 9.9], Matrix(undef, 2, 0)) # hcat with empty 2×0 Matrix
2×1 Matrix{Any}:
1.1
9.9# *`基地。[医]hvcat`*-函数
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`*-函数
hvncat(dim::Int, row_first, values...)
hvncat(dims::Tuple{Vararg{Int}}, row_first, values...)
hvncat(shape::Tuple{Vararg{Tuple}}, row_first, values...)许多的水平、垂直和n维连接 价值 在一个电话。
块矩阵语法调用此函数。 第一个参数指定连接的形状，类似于 [医]hvcat，作为元组的元组，或指定沿每个轴的元素的关键数量的维度，并用于确定输出维度。 该 暗淡无光 form性能更高，默认情况下，当串联操作沿每个轴具有相同数量的元素时使用（例如，[a b;c d;;;e f;g h]）。 该 形状 当沿每个轴的元素数量不平衡时（例如，[a b;c]）使用form。 不平衡的语法需要额外的验证开销。 该 昏暗 表单是仅沿一个维度连接的优化。 row_第一 指示如何 价值 是有序的。 的第一和第二要素的含义 形状 也交换基于 row_第一.
*例子*
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阵列{Int64, 3}:
[:, :, 1] =
1 2
[:, :, 2] =
3 4
[:, :, 3] =
5 6
朱莉娅>hvncat(((3, 3), (3, 3), (6,)), 真，a，b，c，d，e，f）
1×3×2阵列{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# *`基地。堆叠`*-函数
stack(f, args...; [dims])将函数应用于集合的每个元素，以及 堆叠 结果。 或到几个集合, 拉链ped在一起。
函数应该返回大小相同的数组（或元组或其他迭代器）。 这些成为结果的切片，每个切片沿着 暗淡无光 （如果给定）或默认情况下沿着最后一个维度。
*例子*
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.06stack(iter; [dims])通过沿一个或多个新维度排列数组，将大小相等的数组（或其他可迭代对象）集合合并到一个更大的数组中。
默认情况下，元素的轴放在第一位，给出 大小（结果）=（大小（第一（iter））。..，尺寸(iter)。..). 这与元素的顺序相同 迭代器。展平（iter）.
各种 貓！函数也组合数组。 但是，这些都扩展了数组的现有（可能是微不足道的）维度，而不是沿着新维度放置数组。 它们也接受数组作为单独的参数，而不是单个集合。
|
兼容性
Julia1.9此功能至少需要Julia1.9。 |
*例子*
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)) # accepts any iterators of iterators
2×4 Matrix{Int64}:
1 2 3 4
10 11 12 13
julia>vec（ans）==collect（迭代器。拉平(拉链)(1:4, 10:99)))
真的
julia>stack(vecs;dims=1)#与任何cat函数不同，vecs[1]的第一轴是结果的第二轴
3×2矩阵{Float32}:
1.0 2.0
30.0 40.0
500.0 600.0
朱莉娅>x=兰德（3,4）;
julia>x==stack(eachcol(x))==stack(eachrow(x),dims=1)#inverse of eachslice
真的更高维的例子:
julia> A = rand(5, 7, 11);
julia> E = eachslice(A, dims=2); # a vector of matrices
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 # keeps all dimensions
(2, 3, 5, 7)
julia> stack(M; dims=1) |> size # vec(container) along dims=1
(35, 2, 3)
julia> hvcat(5, M...) |> size # hvcat puts matrices next to each other
(14, 15)# *`基地。[医]循环换档`*-函数
circshift(A, shifts)循环移位，即旋转，数据在 A. 第二个参数是一个元组或向量，给出每个维度的移位量，或者一个仅在第一个维度上移位的整数。
在编译时已知移位量（即编译时常量）时，生成的代码效率最高。
请参阅: 循环换位！, 复印本！, 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矩阵{Int64}:
9 13 1 5
10 14 2 6
11 15 3 7
12 16 4 8
julia>circshift（b，（-1,0））
4×4矩阵{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元素BitVector:
1
1
0
0
1
朱莉娅>circshift（a，1）
5元素BitVector:
1
1
1
0
0
朱莉娅>circshift（a，-1）
5元素BitVector:
1
0
0
1
1
朱莉娅>x= (1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)
朱莉娅>circshift（x，4）
(2, 3, 4, 5, 1)
julia>z=(1,'a',-7.0,3)
(1,'a',-7.0,3)
朱莉娅>circshift（z，-1）
('a',-7.0,3,1)# *`基地。循环换位！`*-函数
circshift!(dest, src, shifts)循环移位，即旋转，数据在 src公司，将结果存储在 德斯特. 轮班 指定要在每个维度中移动的量。
|
当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。 |
请参阅 [医循环换档].
circshift!(a::AbstractVector, shift::Integer)在矢量中循环移位或旋转数据 a 由 轮班 各就各位。
*例子*
julia> circshift!([1, 2, 3, 4, 5], 2)
5-element Vector{Int64}:
4
5
1
2
3
julia> circshift!([1, 2, 3, 4, 5], -2)
5-element Vector{Int64}:
3
4
5
1
2# *`基地。复印本！`*-函数
circcopy!(dest, src)副本 src公司 到 德斯特，索引每个维度对其长度取模。 src公司 和 德斯特 必须具有相同的大小，但可以在它们的索引中偏移;任何偏移都会导致（循环）包装。 如果数组具有重叠索引，则在重叠的域上 德斯特 同意 src公司.
|
当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。 |
请参阅: [医循环换档].
*例子*
julia> src = 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> dest = OffsetArray{Int}(undef, (0:3,2:5));
julia> circcopy!(dest, src)
4×4 OffsetArray(::Matrix{Int64}, 0:3, 2:5) with eltype Int64 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]
真的# *`基地。芬德尔`*-Method
findall(A)返回向量 我 的 真的 索引或键 A. 如果没有这样的元素 A，返回一个空数组。 要搜索其他类型的值，请将谓词作为第一个参数传递。
*例子*
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[]# *`基地。芬德尔`*-Method
findall(f::Function, A)返回向量 我 的索引或键 A 哪里 f(A[I]) 申报表 真的. 如果没有这样的元素 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(≥(0), d)
2-element Vector{Symbol}:
:A
:C# *`基地。[医]芬迪斯特`*-Method
findfirst(A)返回第一个的索引或键 真的 价值 A. 回来吧 什么都没有 如果没有找到这样的值。 要搜索其他类型的值，请将谓词作为第一个参数传递。
*例子*
julia> A = [false, false, true, false]
4-element Vector{Bool}:
0
0
1
0
julia> findfirst(A)
3
julia> findfirst(falses(3)) # returns nothing, but not printed in the REPL
julia> A = [false false; true false]
2×2 Matrix{Bool}:
0 0
1 0
julia> findfirst(A)
CartesianIndex(2, 1)# *`基地。[医]芬迪斯特`*-Method
findfirst(predicate::Function, A)返回的第一个元素的索引或键 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) # returns nothing, but not printed in the 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)# *`基地。芬德拉斯特`*-Method
findlast(A)返回最后一个的索引或键 真的 价值 A. 回来吧 什么都没有 如果没有 真的 价值 A.
*例子*
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)#不返回任何内容，但不打印在REPL中
julia>A=[true false;true false]
2×2矩阵{Bool}:
1 0
1 0
朱莉娅>findlast（A）
CartesianIndex(2,1)# *`基地。芬德拉斯特`*-Method
findlast(predicate::Function, A)返回的最后一个元素的索引或键 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) # returns nothing, but not printed in the 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)在或包括后查找下一个索引 i 一个 真的 元素的 A，或 什么都没有 如果没有找到。
*例子*
julia> A = [false, false, true, false]
4-element Vector{Bool}:
0
0
1
0
julia> findnext(A, 1)
3
julia> findnext(A, 4) # returns nothing, but not printed in the 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 为其 谓词,谓词 申报表 真的，或 什么都没有 如果没有找到。 这适用于数组，字符串和支持的大多数其他集合 getindex,getindex, 钥匙(A)，和 下一篇.
*例子*
julia> A = [1, 4, 2, 2];
julia> findnext(isodd, A, 1)
1
julia> findnext(isodd, A, 2) # returns nothing, but not printed in the 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# *`基地。芬普雷夫`*-Method
findprev(A, i)查找之前的索引或包括 i 一个 真的 元素的 A，或 什么都没有 如果没有找到。
*例子*
julia> A = [false, false, true, true]
4-element Vector{Bool}:
0
0
1
1
julia> findprev(A, 3)
3
julia> findprev(A, 1) # returns nothing, but not printed in the REPL
julia> A = [false false; true true]
2×2 Matrix{Bool}:
0 0
1 1
julia> findprev(A, CartesianIndex(2, 1))
CartesianIndex(2, 1)# *`基地。芬普雷夫`*-Method
findprev(predicate::Function, A, i)查找之前的索引或包括 i 的元素的 A 为其 谓词,谓词 申报表 真的，或 什么都没有 如果没有找到。 这适用于数组，字符串和支持的大多数其他集合 getindex,getindex, 钥匙(A)，和 下一篇.
*例子*
julia> A = [4, 6, 1, 2]
4-element Vector{Int64}:
4
6
1
2
julia> findprev(isodd, A, 1) # returns nothing, but not printed in the 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(v::AbstractVector)重塑向量 v 成一个 1×长度(v) 行矩阵。 不同于 转置,转置因为操作不是递归的，这对于非数字值的数组特别有用（其中递归 转置,转置 可能会抛出错误）。
*例子*
不像 转置,转置, 排列,排列 可用于任意非数字元素的向量，如字符串:
julia> permutedims(["a", "b", "c"])
1×3 Matrix{String}:
"a" "b" "c"对于数字的向量, 排列(v) 工作原理很像 转置(v) 除了返回类型不同（它使用 重塑形状而不是一个 线性代数。转置,转置 视图，虽然两者都与原始数组共享内存 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; # mutating p or r also changes v
julia> v # shares memory with both p and r
4-element Vector{Int64}:
5
6
3
4然而, 排列,排列 产生不同于 转置,转置 对于元素本身是数字矩阵的向量:
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(A::AbstractArray, perm)
permutedims(A::AbstractMatrix)排列数组的尺寸（轴） A. 烫发,烫发 是元组或向量 ndims(A) 指定排列的整数。
如果 A 是一个2d数组（[医抽象矩阵])，则 烫发,烫发 默认值为 (2,1)，交换两个轴 A （矩阵的行和列）。 这与 转置,转置因为操作不是递归的，这对于非数字值的数组特别有用（其中递归 转置,转置 会抛出错误）和/或不表示线性算子的2d数组。
有关一维数组，请参阅 permutedims(v::AbstractVector)，它返回1行"`矩阵`".
请参阅 permutedims！, 排列,排列, 转置,转置, n.外阴,外阴.
*例子*
*二维阵列:*
不像 转置,转置, 排列,排列 可用于交换任意非数字元素（如字符串）的二维数组的行和列:
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"和 排列,排列 产生不同于 转置,转置 对于元素本身为数值矩阵的矩阵:
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); # put the last dimension first
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)) # the inverse permutation
true对于每个维度 i 的 B=permims（A，perm），其对应维数为 A 将是 烫发[i]. 这意味着平等 大小(B,i)==大小(A,烫发[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# *`基地。n.宣传品,宣传品`*-函数
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)数组函数
# *`基地。累积`*-函数
accumulate(op, A; dims::Integer, [init])累积操作 op的 沿维度 暗淡无光 的 A （提供 暗淡无光 对于向量是可选的）。 初始值 初始化 可以可选地由关键字参数提供。 请参阅 积累！使用预先分配的输出阵列，以提高性能和控制输出的精度（例如避免溢出）。
|
兼容性
朱莉娅1.5 |
*例子*
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# *`基地。积累！`*-函数
accumulate!(op, B, A; [dims], [init])累积操作 op的 上 A 沿维度 暗淡无光，将结果存储在 B. 提供服务 暗淡无光 对于向量是可选的。 如果关键字参数 初始化 被给定，其值用于实例化累积。
|
当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。 |
*例子*
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(itr)迭代器的累积积。
|
兼容性
朱莉娅1.5 |
*例子*
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(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# *`基地。[医]积姆`*-函数
cumsum(itr)迭代器的累积和。
请参阅 累积应用除此以外的功能 +.
|
兼容性
朱莉娅1.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]cumsum(A; dims::Integer)沿维度的累积和 暗淡无光. 请参阅 赞姆！使用预先分配的输出阵列，以提高性能和控制输出的精度（例如避免溢出）。
*例子*
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|
注意返回数组的 在前一种情况下，整数被扩大到系统字大小，因此结果是 |
# *`基地。差异,差异`*-函数
diff(A::AbstractVector)
diff(A::AbstractArray; dims::Integer)向量或多维数组上的有限差分运算符 A. 在后一种情况下，需要使用 暗淡无光 关键字参数。
|
兼容性
朱莉娅1.1 |
*例子*
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# *`基地。重复一遍`*-函数
repeat(c::AbstractChar, r::Integer) -> String重复一个字符 r 时代。 这可以等效地通过调用来完成 c^r.
*例子*
julia> repeat('A', 3)
"AAA"repeat(s::AbstractString, r::Integer)重复一个字符串 r 时代。 这可以写成 s^r.
*例子*
julia> repeat("ha", 3)
"hahaha"repeat(A::AbstractArray; inner=ntuple(Returns(1), ndims(A)), outer=ntuple(Returns(1), ndims(A)))通过重复的条目构造一个数组 A. 的第i元素 内 指定第i个维度的各个条目的次数 A 应重复。 的第i元素 外，外 指定沿第i个维度的切片的次数 A 应重复。 如果 内 或 外，外 被省略，不进行重复。
*例子*
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矩阵{Int64}:
1 2 1 2 1 2
1 2 1 2 1 2
3 4 3 4 3 4
3 4 3 4 3 4repeat(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# *`基地。腐烂180`*-函数
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 4rot180(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# *`基地。罗特尔90`*-函数
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 4rotl90(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# *`基地。rotr90`*-函数
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 4rotr90(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# *`基地。地图单`*-函数
mapslices(f, A; dims)变换数组的给定维度 A 通过应用函数 f 在表格的每个切片上 A[。.., :, ..., :, ...]，每个都有一个冒号 d 在 暗淡无光. 结果沿其余维度串联。
例如，如果 dims=[1,2] 和 A 是4维的，那么 f 被召唤 x=A[:,:,i,j] 为所有人 i 和 j，而 f(x) 成为 R[:,:,i,j] 在结果 R.
*例子*
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阵列{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))
真的
julia>g(x)=x[begin]//x[end-1];#返回一个数字
julia>mapslices(g,A,dims=[1,3])
1×5×1阵列{Rational{Int64}, 3}:
[:, :, 1] =
1//21 3//23 1//5 7//27 9//29
julia>地图(g,eachslice(A,dims=2))
5元素向量{Rational{Int64}}:
1//21
3//23
1//5
7//27
9//29
julia>mapslices(sum,A;dims=(1,3))==sum(A;dims=(1,3))
真的请注意，在 每个slice(A;dims=2)，指定的维度是切片中的一个冒号。 这是 视图(A,:,i,:)，而 mapslices(f,A;dims=(1,3)) 用途 A[:,i,:]. 的功能 f 可以在不影响的情况下改变切片中的值 A.
# *`基地。每个月`*-函数
eachrow(A::AbstractVecOrMat) <: AbstractVector创建一个 行距;行距是矩阵或向量的行的向量的对象 A. 行切片返回为 [医]文摘 的意见 A.
相反，请参阅 堆叠(行;dims=1).
|
兼容性
Julia1.1此功能至少需要Julia1.1。 |
|
兼容性
Julia1.9在Julia1.9之前，this返回了一个迭代器。 |
*例子*
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# *`基地。每个客户`*-函数
eachcol(A::AbstractVecOrMat) <: AbstractVector创建一个 专栏是矩阵或向量列的向量的对象 A. 列切片返回为 [医]文摘 的意见 A.
相反，请参阅 堆叠（cols） 或 减少(``hcat,hcat，cols）.
|
兼容性
Julia1.1此功能至少需要Julia1.1。 |
|
兼容性
Julia1.9在Julia1.9之前，this返回了一个迭代器。 |
*例子*
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# *`基地。每张单张`*-函数
eachslice(A::AbstractArray; dims, drop=true)创建一个 切片对象是维度上的切片数组 暗淡无光 的 A，返回从其他维度中选择所有数据的视图 A. 暗淡无光 可以是整数或整数元组。
如果 下降=真 （默认），外 切片 将下降内部尺寸，尺寸的顺序将匹配那些在 暗淡无光. 如果 下降=错误，则该 切片 将具有与底层数组相同的维数，内部尺寸为1。
见 堆叠（切片;dims） 对于逆 eachslice(a;dims::Integer).
|
兼容性
Julia1.1此功能至少需要Julia1.1。 |
|
兼容性
Julia1.9在Julia1.9之前，它返回了一个迭代器，并且只有一个维度 |
*例子*
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]组合学
# *`基地。n.外阴,外阴`*-函数
invperm(v)返回的逆置换 v. 如果 B=A[v]，则 A==B[invperm（v）].
请参阅 鹿sortperm, invpermute！, 伊斯珀姆, 排列,排列.
*例子*
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'];
朱莉娅>B=A[v]
4元素向量{Char}:
'b'：ASCII/Unicode U+0062（类别Ll：字母，小写）
'd'：ASCII/Unicode U+0064（类别Ll：字母，小写）
'c'：ASCII/Unicode U+0063（类别Ll：字母，小写）
'a'：ASCII/Unicode U+0061（类别Ll：字母，小写）
朱莉娅>B[invperm(v)]
4元素向量{Char}:
'a'：ASCII/Unicode U+0061（类别Ll：字母，小写）
'b'：ASCII/Unicode U+0062（类别Ll：字母，小写）
'c'：ASCII/Unicode U+0063（类别Ll：字母，小写）
'd'：ASCII/Unicode U+0064（类别Ll：字母，小写）# *`基地。伊斯珀姆`*-函数
isperm(v) -> Bool回来吧 真的 如果 v 是有效的置换。
*例子*
julia> isperm([1; 2])
true
julia> isperm([1; 3])
false# *`基地。胡说八道！`*-Method
permute!(v, p)排列向量 v 就地，根据排列 p. 没有检查来验证 p 是置换。
要返回新的排列，请使用 v[p]. 这通常比 胡说八道！（v，p）;写入预先分配的输出数组甚至更快 u.=@视图v[p]. （尽管 胡说八道！ 复盖 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# *`基地。反向`*-Method
reverse(A; 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，只有单整数 |