Arrays

Constructors and Types

Core.Array — Type
Array{T,N} <: AbstractArray{T,N}

N次元の、要素の型がTである密な配列。

source
Core.Array — Method
Array{T}(undef, dims)
Array{T,N}(undef, dims)

型 T の要素を格納する、未初期化の N 次元の Array を構築します。N は、Array{T,N}(undef, dims) のように明示的に指定することも、dims の長さまたは個数から決定することもできます。dims には、各次元の長さを表すタプル、または複数の整数引数を指定できます。ランク N を明示的に指定する場合は、dims の長さまたは個数と一致していなければなりません。ここで、undef は UndefInitializer です。

Examples

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
source
Core.Array — Method
Array{T}(nothing, dims)
Array{T,N}(nothing, dims)

N次元のArrayを作成します。要素の型はTとし、nothingの値で初期化します。要素型のTは、これらの値を格納できる必要があります。つまり、Nothing <: Tです。

Examples

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
source
Core.Array — Method
Array{T}(missing, dims)
Array{T,N}(missing, dims)

N次元のArrayを構築します。要素の型はTで、missing個の要素で初期化します。要素型Tは、これらの値を格納できる必要があります。つまり、Missing <: Tです。

Examples

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
source
Core.UndefInitializer — Type
UndefInitializer

配列の初期化に使われるシングルトン型。配列コンストラクターの呼び出し元が未初期化の配列を要求していることを示します。undef(UndefInitializer()の別名)も参照してください。

Examples

julia> Array{Float64, 1}(UndefInitializer(), 3)
3-element Vector{Float64}:
 2.2752528595e-314
 2.202942107e-314
 2.275252907e-314
source
Core.undef — Constant
undef

UndefInitializer()の別名です。シングルトン型UndefInitializerのインスタンスを構築します。配列の初期化時に、配列コンストラクターの呼び出し元が未初期化の配列を要求していることを示すために使用します。

関連項目: missing、similar。

Examples

julia> Array{Float64, 1}(undef, 3)
3-element Vector{Float64}:
 2.2752528595e-314
 2.202942107e-314
 2.275252907e-314
source
Base.Vector — Type
Vector{T} <: AbstractVector{T}

要素の型が T の1次元密配列。数学的なベクトルを表すためによく使われます。Array{T,1} の別名です。

ベクトルの作成方法については、empty、similar、zero も参照してください。

source
Base.Vector — Method
Vector{T}(undef, n)

長さがnの未初期化のVector{T}を構築します。

Examples

julia> Vector{Float64}(undef, 3)
3-element Vector{Float64}:
 6.90966e-310
 6.90966e-310
 6.90966e-310
source
Base.Vector — Method
Vector{T}(nothing, m)

長さがmで、nothingの値で初期化されたVector{T}を構築します。要素型Tは、これらの値を格納できる必要があります。つまり、Nothing <: Tです。

Examples

julia> Vector{Union{Nothing, String}}(nothing, 2)
2-element Vector{Union{Nothing, String}}:
 nothing
 nothing
source
Base.Vector — Method
Vector{T}(missing, m)

長さがmで、missingの要素で初期化されたVector{T}を構築します。要素型Tは、これらの値を格納できる必要があります。つまり、Missing <: Tです。

Examples

julia> Vector{Union{Missing, String}}(missing, 2)
2-element Vector{Union{Missing, String}}:
 missing
 missing
source
Base.Matrix — Type
Matrix{T} <: AbstractMatrix{T}

要素の型が T の2次元密配列で、数学的な行列を表すためによく使われます。Array{T,2} の別名です。

行列の作成方法については、fill、zeros、undef、similar も参照してください。

source
Base.Matrix — Method
Matrix{T}(undef, m, n)

サイズがm×nの、未初期化のMatrix{T}を構築します。

Examples

julia> Matrix{Float64}(undef, 2, 3)
2×3 Matrix{Float64}:
 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
source
Base.Matrix — Method
Matrix{T}(nothing, m, n)

Matrix{T}をm×nのサイズで作成し、nothingの要素で初期化します。要素型Tは、これらの値を格納できる必要があります。つまり、Nothing <: Tです。

Examples

julia> Matrix{Union{Nothing, String}}(nothing, 2, 3)
2×3 Matrix{Union{Nothing, String}}:
 nothing  nothing  nothing
 nothing  nothing  nothing
source
Base.Matrix — Method
Matrix{T}(missing, m, n)

Matrix{T}をサイズm×nで構築し、missingの要素で初期化します。要素型Tは、これらの値を格納できる必要があります。つまり、Missing <: Tです。

Examples

julia> Matrix{Union{Missing, String}}(missing, 2, 3)
2×3 Matrix{Union{Missing, String}}:
 missing  missing  missing
 missing  missing  missing
source
Base.VecOrMat — Type
VecOrMat{T}

関数が行列またはベクトルのどちらかを受け取れるようにする、Vector{T}とMatrix{T}の共用体型。

Examples

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

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

julia> Array{Float64, 3} <: VecOrMat{Float64}
false
source
Core.DenseArray — Type
DenseArray{T, N} <: AbstractArray{T,N}

要素の型がTである、N次元の密な配列。密な配列の要素はメモリ上に連続して格納されます。

source
Base.StridedArray — Type
StridedArray{T, N}

Unionに従う一般的な配列型をハードコードしたstrided array interfaceで、要素の型はT、次元数はNです。

AがStridedArrayの場合、要素はメモリ上にオフセットを伴って格納されます。このオフセットは次元ごとに異なることがありますが、各次元内では一定です。たとえば、Aでは、第1次元のストライドが2、第2次元のストライドが3になることがあります。次元dに沿ってAを1つ進めると、メモリ上で[stride(A, d)]スロット分移動します。ストライド配列は、BLASなどの外部言語ライブラリにポインターとして直接渡せる場合があるため、特に重要で便利です。

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

固定サイズの DenseVector{T}。

kind は、現在 :not_atomic または :atomic のいずれかです。:atomic が意味する内容については、AtomicMemory を参照してください。

addrspace に現在設定できるのは、Core.CPU のみです。GPU などの他のシステムが、次のような値を定義して拡張できるように設計されています。

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

これらの他の addrspace の正確な意味は、各バックエンドによって定義されます。ただし、ユーザーが CPU 上でこれらにアクセスしようとするとエラーになります。

Julia 1.11

この型を使用するには、Julia 1.11 以降が必要です。

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

固定サイズの DenseVector{T}。

Julia 1.11

この型を使用するには、Julia 1.11 以降が必要です。

source
Core.Memory — Method
Memory{T}(undef, n)

長さがnの、未初期化のMemory{T}を構築します。長さが0のMemoryオブジェクトは、そこから到達可能な可変コンテンツが存在しないため、エイリアスになることがあります。

Examples

julia> Memory{Float64}(undef, 3)
3-element Memory{Float64}:
 6.90966e-310
 6.90966e-310
 6.90966e-310
source
Core.memoryref — Function
memoryref(::GenericMemory, index::Integer)
memoryref(::GenericMemoryRef, index::Integer)

メモリオブジェクトとオフセットインデックス(1始まり。負の値も指定可能)からGenericMemoryRefを構築します。常に範囲内のオブジェクトを返し、インデックスによって基盤となるメモリの範囲外へのシフトが生じる場合はエラーをスローします。

source
memoryref(::GenericMemory)

メモリオブジェクトからGenericMemoryRefを構築します。これは失敗しませんが、メモリが空の場合に限り、結果のメモリは範囲外を指します。

source
Base.memoryindex — Function
memoryindex(ref::GenericMemoryRef)::Int

ref の GenericMemory 内での 1 始まりのインデックスを取得します。

Examples

julia> mem = Memory{String}(undef, 10);

julia> ref = Base.memoryindex(memoryref(mem, 3))
3

julia> Base.memoryindex(memoryref(Memory{Nothing}(undef, 10), 8))
8
Julia 1.13

この関数を使用するには、Julia 1.13 以降が必要です。

source
Base.Slices — Type
Slices{P,SM,AX,S,N} <: AbstractSlices{S,N}

指定した次元に沿って親配列をスライスし、その他の次元のデータをすべて選択するビューを返す AbstractArray。

通常は eachslice、eachcol、または eachrow を使って構築します。

parent(s::Slices) は親配列を返します。

source
Base.RowSlices — Type
RowSlices{M,AX,S}

Slicesの特殊なケースで、eachrowによって構築される、行列の行スライスのベクトルです。

基になる行列を取得するには、parentを使用できます。

source
Base.ColumnSlices — Type
ColumnSlices{M,AX,S}

Slicesの特殊なケースで、eachcolによって構築される、行列の列スライスからなるベクトルです。

元の行列を取得するには、parentを使用できます。

source
Base.getindex — Method
getindex(type[, elements...])

指定した型の1次元配列を構築します。通常は、次の構文で呼び出します。Type[] 要素の値は、Type[a,b,c,...] を使って指定できます。

Examples

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
source
Base.zeros — Function
zeros([T=Float64,] dims::Tuple)
zeros([T=Float64,] dims...)

サイズをdimsで指定し、要素型がTの、すべてゼロのArrayを作成します。fill、ones、zeroも参照してください。

Examples

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

julia> zeros(Int8, 2, 3)
2×3 Matrix{Int8}:
 0  0  0
 0  0  0
source
Base.ones — Function
ones([T=Float64,] dims::Tuple)
ones([T=Float64,] dims...)

Arrayを作成します。要素型はTで、サイズはdimsで指定し、すべての要素を1にします。fill、zerosも参照してください。

Examples

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
source
Base.BitArray — Type
BitArray{N} <: AbstractArray{Bool, N}

各ブール値を1ビットだけで表す、省メモリなN次元ブール配列です。

BitArrayでは、8バイトごとに最大64個の値を格納します。そのため、Array{Bool, N}と比べてメモリ効率が8倍になり、一部の操作では64個の値を一度に処理できます。

デフォルトでは、ブール要素を生成するbroadcasting操作(.==のようなドット付き比較を含む)や、関数truesおよびfalsesは、BitArraysを返します。

Note

パック形式で格納されるため、BitArrayの要素に対する並行アクセスのうち、少なくとも1つが書き込みである場合、スレッドセーフではありません。

source
Base.BitArray — Method
BitArray(undef, dims::Integer...)
BitArray{N}(undef, dims::NTuple{N,Int})

指定された次元で未定義のBitArrayを構築します。Arrayコンストラクターと同じように動作します。undefを参照してください。

Examples

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

julia> BitArray(undef, (3, 1))
3×1 BitMatrix:
 0
 0
 0
source
Base.BitArray — Method
BitArray(itr)

指定された反復可能オブジェクトから生成されるBitArrayを構築します。形状はitrオブジェクトから推定されます。

Examples

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
source
Base.trues — Function
trues(dims)

すべての値をtrueに設定したBitArrayを作成します。

Examples

julia> trues(2,3)
2×3 BitMatrix:
 1  1  1
 1  1  1
source
Base.falses — Function
falses(dims)

すべての値をfalseに設定したBitArrayを作成します。

Examples

julia> falses(2,3)
2×3 BitMatrix:
 0  0  0
 0  0  0
source
Base.fill — Function
fill(value, dims::Tuple)
fill(value, dims...)

サイズが dims で、すべての要素が value に設定された配列を作成します。

たとえば、fill(1.0, (5,5)) は、すべての要素が 1.0 である 5×5 の浮動小数点数配列を返します。

次元の長さ dims は、タプルまたは引数列のどちらでも指定できます。value の後に、長さが N のタプル、または N 個の引数を指定すると、N 次元の配列が作成されます。そのため、唯一の要素が x である 0 次元配列を作成する一般的な書き方は、fill(x) です。

返される配列のすべての要素には、渡された value が設定されます(つまり、===)。そのため、value 自体が変更されると、fill 配列のすべての要素にその変更が反映されます。これは、どの要素も 依然として 同じ value だからです。fill(1.0, (5,5)) の場合は、value 1.0 が不変で、それ自体を変更できないため問題ありません。しかし、配列など、変更可能な値では予期しない結果になることがあります。たとえば、fill([], 3) は、返されるベクトルの 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]

独立した内部配列を複数作成するには、代わりに comprehension を使用します。これにより、ループの反復ごとに新しい別個の配列が作成されます。

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]
 []
 []

関連項目: fill!、zeros、ones、similar。

Examples

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]
source
Base.fill! — Function
fill!(A, x)

配列 A を値 x で埋めます。x がオブジェクト参照の場合、すべての要素が同じオブジェクトを参照します。fill!(A, Foo()) は、Foo() を一度評価した結果で埋められた A を返します。

Examples

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
source
Base.empty — Function
empty(a::AbstractDict, [index_type=keytype(a)], [value_type=valtype(a)])

index_type 型のインデックスと、value_type 型の値を格納できる、空の AbstractDict コンテナーを作成します。第2引数と第3引数は省略可能で、省略した場合はそれぞれ入力の keytype と valtype が使われます。(2つの型のうち一方だけを指定した場合、もう一方は value_type とみなされ、index_type の既定値は keytype(a) になります。)

カスタム AbstractDict サブタイプでは、3引数のシグネチャを特殊化することで、指定されたインデックス型と値型に最適な辞書型を選んで返すことができます。既定では、空の Dict を返します。

source
empty(v::AbstractVector, [eltype])

vに似た空のベクトルを作成します。必要に応じてeltypeを変更できます。

関連項目: empty!、isempty、isassigned。

Examples

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

julia> empty([1.0, 2.0, 3.0], String)
String[]
source
empty(x::Tuple)

空のタプルを返します。()

source
Base.similar — Function
similar(storagetype, axes)

storagetypeで指定したものと同様の、未初期化の可変配列を作成します。ただし、axesは最後の引数で指定します。

例:

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

これは、Array{Int}のように「振る舞う」(実際にそれを基盤としている場合もあります)配列を作成します。ただし、インデックスはAと同じです。Aが通常のインデックスを持つ場合、これはArray{Int}(undef, size(A))と同一になります。一方、Aが通常とは異なるインデックスを持つ場合、結果のインデックスはAと一致します。

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

これは、インデックスがAの列のインデックスと一致する、1次元の論理配列を作成します。

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

指定された要素型とサイズを持つ、未初期化の可変配列を、指定されたソース配列に基づいて作成します。第2引数と第3引数はどちらも省略可能で、省略した場合はソース配列の eltype と size がそれぞれ使われます。次元は、単一のタプル引数または複数の整数引数で指定できます。

カスタムの AbstractArray サブタイプでは、指定された要素型と次元数に最適な配列型を選んで返すことができます。このメソッドを特殊化しない場合、デフォルトでは Array{element_type}(undef, dims...) が使われます。

たとえば、similar(1:10, 1, 4) は未初期化の Array{Int,2} を返します。範囲は可変ではなく、2次元にも対応していないためです。

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

一方、similar(trues(10,10), 2) は、要素数が2の未初期化 BitVector を返します。BitArray は可変であり、1次元配列にも対応できるためです。

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

ただし、BitArray が格納できる要素の型は Bool に限られます。そのため、別の要素型を指定すると、代わりに通常の Array が作成されます。

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。

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

指定された要素型、インデックス型、サイズを持つ未初期化の可変配列を、指定されたソース SparseMatrixCSC に基づいて作成します。新しい疎行列は、出力行列の次元が異なる場合を除き、元の疎行列の構造を維持します。

出力行列では、入力行列と同じ位置がゼロとなり、非ゼロの位置には未初期化の値が格納されます。

source

Basic functions

Base.ndims — Function
ndims(A::AbstractArray)::Integer

Aの次元数を返します。

関連項目: size、axes。

Examples

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

julia> ndims(A)
3
source
Base.size — Function
size(A::AbstractArray, [dim])

Aの次元を含むタプルを返します。特定の次元の長さだけを取得するには、次元を指定します。

標準的でないインデックスを持つ配列では、sizeが定義されていない場合があります。その場合は、axesが役立ちます。詳しくは、マニュアルのarrays with custom indicesの章を参照してください。

関連項目: length、ndims、eachindex、sizeof。

Examples

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

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

julia> size(A, 2)
3
source
Base.axes — Method
axes(A)

配列 A の有効なインデックスをタプルで返します。

関連項目: size、keys、eachindex。

Examples

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

julia> axes(A)
(Base.OneTo(5), Base.OneTo(6), Base.OneTo(7))
source
Base.axes — Method
axes(A, d)

配列 A の次元 d における、有効なインデックスの範囲を返します。

size および、arrays with custom indices に関するマニュアルの章も参照してください。

Examples

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

Usage note

各インデックスは AbstractUnitRange{<:Integer} である必要がありますが、同時に、カスタムインデックスを使用する型でもかまいません。そのため、たとえば部分集合が必要な場合は、begin/end や firstindex/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
source
Base.length — Method
length(A::AbstractArray)

配列の要素数を返します。デフォルトはprod(size(A))です。

Examples

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

julia> length([1 2; 3 4])
4
source
Base.keys — Method
keys(a::AbstractArray)

a のすべての有効なインデックスを、a 自体と同じ形状で表す、効率的な配列を返します。

1 次元配列(ベクトル)のキーは整数ですが、それ以外の N 次元配列では、位置を表すために CartesianIndex を使用します。整数の配列や CartesianIndex の配列を効率的に表すには、特殊な配列型である LinearIndices と CartesianIndices がよく使われます。

配列の keys が、最も効率的なインデックス型とは限りません。最高のパフォーマンスを得るには、代わりに eachindex を使用してください。

Examples

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))
source
Base.eachindex — Function
eachindex(A...)
eachindex(::IndexStyle, A::AbstractArray...)

AbstractArray A の各インデックスを効率よく順にたどるための反復可能オブジェクトを作成します。Array のように高速な線形インデックスに対応した配列型では、1始まりのインデックスを使う場合、これは単に 1:length(A) となります。高速な線形インデックスに対応していない配列型では、通常、各次元のインデックスを指定して配列を効率よくインデックス付けできる、専用の直積範囲が返されます。

一般に、eachindex は文字列や辞書を含む任意の反復可能オブジェクトを受け取り、不均等間隔や非整数のインデックスなど、任意の型のインデックスをサポートするイテレーターオブジェクトを返します。

A が AbstractArray の場合、最初の引数に IndexStyle 型の値を渡すことで、eachindex が返すインデックスの形式を明示的に指定できます(線形インデックスが必要なら通常は IndexLinear()、直積範囲が必要なら IndexCartesian() を指定します)。

AbstractArray 引数を複数指定すると、eachindex はすべての引数に対して高速な反復可能オブジェクトを作成します(通常、すべての入力が高速な線形インデックスに対応していれば UnitRange、そうでなければ CartesianIndices)。配列のサイズや次元数が異なる場合は、DimensionMismatch 例外がスローされます。

インデックスと値をまとめて反復するには pairs(A) を、1つの次元における有効なインデックスについては axes(A, 2) を参照してください。

Examples

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)
source
Base.IndexStyle — Type
IndexStyle(A)
IndexStyle(typeof(A))

IndexStyleは、配列Aの「ネイティブなインデックス付けスタイル」を指定します。新しいAbstractArray型を定義する際は、線形インデックス付け(IndexLinearを使用)または直交インデックス付けのいずれかを実装できます。線形インデックス付けのみを実装する場合は、配列型に次のトレイトを設定する必要があります。

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

デフォルトはIndexCartesian()です。

Juliaの内部インデックス付け機構は、すべてのインデックス操作を優先スタイルに自動的に(かつ透過的に)変換します。そのため、明示的なメソッドが用意されていない場合でも、ユーザーは任意のインデックス付けスタイルで配列の要素にアクセスできます。

AbstractArrayに対して両方のインデックス付けスタイルを定義する場合、このトレイトを使って、最もパフォーマンスの高いスタイルを選択できます。いくつかのメソッドは入力のトレイトを確認し、最も効率的なアクセスパターンに応じて異なるアルゴリズムを呼び出します。特に、eachindexは、このトレイトの設定に応じて型が決まるイテレータを生成します。

source
Base.IndexLinear — Type
IndexLinear()

配列を最適な線形インデックスでインデックス付けする場合に使用する、IndexStyleのサブタイプです。

線形インデックス方式では、配列内の位置を1つの整数インデックスで表します(多次元配列の場合も同様)。要素への効率的なアクセスには列優先順序が使われます。そのため、IndexLinearである配列に対してeachindexを要求すると、多次元配列であっても単純な1次元の範囲が返されます。

IndexStyleがIndexLinearであると報告するカスタム配列では、単一のIntインデックスによるインデックス付け(およびインデックスを指定した代入)だけを実装すれば十分です。多次元アクセスを含むその他すべてのインデックス式は、線形インデックスに再計算されます。たとえば、線形インデックスを使う2×3のカスタム行列がAであり、A[1, 3]を参照した場合、これは対応する線形インデックスに再計算され、A[5]が呼び出されます。これは1 + 2*(3 - 1) = 5だからです。

IndexCartesianも参照してください。

source
Base.IndexCartesian — Type
IndexCartesian()

Cartesian インデックスで最適にインデックス付けできる配列を表すために使われる、IndexStyle のサブタイプです。新しいカスタム AbstractArray サブタイプでは、これがデフォルトです。

Cartesian インデックス方式では、多次元配列内の位置を表すために複数の整数インデックスを使い、各次元にインデックスを1つずつ指定します。そのため、IndexCartesian である配列に対して eachindex を要求すると、CartesianIndices の範囲が返されます。

IndexCartesian を IndexStyle として報告する N 次元のカスタム配列では、インデックスがちょうど N 個の Int である場合のインデックス付け(およびインデックス指定による代入)を実装する必要があります。それ以外のインデックス式(線形インデックスを含む)は、対応する Cartesian 位置に再計算されます。たとえば、2×3 が Cartesian インデックス方式の A 次元カスタム行列だとします。このとき A[5] を参照すると、対応する Cartesian インデックスに再計算され、A[1, 3] が呼び出されます。これは 5 = 1 + 2*(3 - 1) だからです。

線形インデックスから Cartesian インデックスを計算する処理は、その逆方向の計算よりも大幅にコストがかかります。前者では非常にコストの高い除算が必要ですが、後者で使うのは乗算と加算だけで、実質的にコストはかかりません。この非対称性により、IndexCartesian 配列で線形インデックスを使うほうが、IndexLinear 配列で Cartesian インデックスを使うよりも、はるかにコストが高くなります。

関連項目: IndexLinear。

source
Base.conj! — Function
conj!(A)

配列をその場で複素共役に変換します。

関連項目: conj。

Examples

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
source
Base.stride — Function
stride(A, k::Integer)

次元 k における隣接要素間のメモリ上の距離(要素数)を返します。

関連項目: strides。

Examples

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

julia> stride(A,2)
3

julia> stride(A,3)
12
source
Base.strides — Function
strides(A)

各次元のメモリストライドをタプルで返します。

関連項目: stride。

Examples

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

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

Broadcast and vectorization

dot syntax for vectorizing functionsも参照してください。たとえば、f.(args...)は暗黙的にbroadcast(f, args...)を呼び出します。sinのような関数の「ベクトル化」メソッドに配列を処理させるのではなく、sin.(a)を使ってbroadcast経由でベクトル化してください。

Base.Broadcast.broadcast — Function
broadcast(f, As...)

関数 f を、配列、タプル、コレクション、Ref、および/またはスカラー As に対してブロードキャストします。

ブロードキャストでは、コンテナー引数の各要素とスカラーそのものに対して、f の関数を As で適用します。要素数が 1 の次元や存在しない次元は、値を仮想的に繰り返すことで、ほかの引数の範囲に合うよう拡張されます。デフォルトでは、スカラーとみなされる型は限られており、Number、String、Symbol、Type、Function、および missing や nothing などの一般的なシングルトンが含まれます。それ以外の引数は、要素ごとに反復処理されるか、インデックスでアクセスされます。

結果のコンテナー型は、次の規則で決まります。

  • すべての引数がスカラーまたは 0 次元配列の場合、ラップされていないスカラーを返します。
  • 少なくとも 1 つの引数がタプルで、ほかのすべての引数がスカラーまたは 0 次元配列の場合、タプルを返します。
  • それ以外の組み合わせでは、デフォルトで Array を返します。ただし、カスタムコンテナー型は独自の実装や昇格に似た規則を定義し、引数として渡されたときの結果をカスタマイズできます。
  • 要素型は、collect と同じ方法で決まります。

ブロードキャストには特別な構文があります。f.(args...) は broadcast(f, args...) と同等であり、ネストされた f.(g.(args...)) の呼び出しは、単一のブロードキャストループに融合されます。

Examples

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"
source
Base.Broadcast.broadcast! — Function
broadcast!(f, dest, As...)

broadcastと同様ですが、broadcast(f, As...)の結果をdest配列に格納します。destは結果の格納にのみ使用され、Asにも記載されていない限り、fに引数を渡さない点に注意してください。たとえば、broadcast!(f, A, A, B)でA[:] = broadcast(f, A, B)を実行する場合がこれに当たります。

Examples

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
source
Base.Broadcast.@__dot__ — Macro
@. expr

expr 内のすべての関数呼び出しまたは演算子を「ドット呼び出し」に変換します(例:f(x) を f.(x) に変換)。また、expr 内のすべての代入を「ドット代入」に変換します(例:+= を .+= に変換)。

expr 内の特定の関数呼び出しにドットを付けたくない場合は、$ を使ってその関数呼び出しをスプライスします。たとえば、@. sqrt(abs($sort(x))) は sqrt.(abs.(sort(x))) と同等です(sort にはドットが付きません)。

(@. は、@__dot__ の呼び出しと同等です。)

Examples

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
source
Base.Broadcast.BroadcastFunction — Type
BroadcastFunction{F} <: Function

演算子の「ドット付き」バージョンを表します。引数に対して演算子をブロードキャストするため、BroadcastFunction(op) は機能的に (x...) -> (op).(x...) と同等です。

高階関数に、演算子の前にドットを付けて渡すだけで作成できます。

Examples

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
Julia 1.6

BroadcastFunction と、単独で使う .op 構文は、Julia 1.6 以降で利用できます。

source

カスタム型に対するブロードキャストの特殊化については、次を参照してください。

Base.Broadcast.BroadcastStyle — Type

BroadcastStyleは、ブロードキャスト時のオブジェクトの振る舞いを決定するために使われる抽象型およびトレイト関数です。BroadcastStyle(typeof(x))は、xに対応するスタイルを返します。型のブロードキャスト時の振る舞いをカスタマイズするには、型とメソッドの組を定義してスタイルを宣言します。

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

次に、Broadcasted{MyContainerStyle}を対象とするメソッド(少なくともsimilar)を記述します。また、活用できる可能性のある、あらかじめ定義されたBroadcastStyleのサブタイプもいくつかあります。詳しくはInterfaces chapterを参照してください。

source
Base.Broadcast.AbstractArrayStyle — Type

Broadcast.AbstractArrayStyle{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()

複数のAbstractArrayStyleを混在させ、次元数を追跡できるようにするには、スタイルでValコンストラクターをサポートする必要があります。

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

2つ以上のAbstractArrayStyleサブタイプが競合すると、ブロードキャスト機構はArrayを生成するようにフォールバックします。これが望ましくない場合は、出力型を制御するために二項BroadcastStyleルールを定義する必要があるかもしれません。

Broadcast.DefaultArrayStyleも参照してください。

source
Base.Broadcast.ArrayStyle — Type

Broadcast.ArrayStyle{MyArrayType}()は、ブロードキャスト時にオブジェクトが配列として振る舞うことを示すBroadcastStyleです。特定のAbstractArrayコンテナ型向けのBroadcast.AbstractArrayStyleを簡単に作成できます。この方法で作成したブロードキャストスタイルでは次元数が保持されません。型で次元数を保持する必要がある場合は、独自のBroadcast.AbstractArrayStyleを作成してください。

source
Base.Broadcast.DefaultArrayStyle — Type

Broadcast.DefaultArrayStyle{N}()は、ブロードキャスト時にオブジェクトがN次元配列として振る舞うことを示すBroadcastStyleです。具体的には、DefaultArrayStyleは、専用のスタイルが定義されていないあらゆるAbstractArray型に使用されます。また、ほかのbroadcast引数によるオーバーライドがない場合、結果の出力型はArrayになります。broadcastに複数の入力がある場合、DefaultArrayStyleはほかのどのBroadcast.ArrayStyleにも「優先されません」。

source
Base.Broadcast.broadcastable — Function
Broadcast.broadcastable(x)

x、またはxのようなオブジェクトを返してください。このオブジェクトはaxesとインデックス指定をサポートし、その型はndimsをサポートする必要があります。

xが反復処理をサポートする場合、返される値はcollect(x)と同じaxesおよびインデックス指定の動作を備えている必要があります。

xがAbstractArrayではないものの、axesとインデックス指定をサポートし、その型がndimsをサポートする場合、broadcastable(::typeof(x))は単に自身を返すよう実装できます。さらに、xが独自のBroadcastStyleを定義する場合、カスタムスタイルを有効にするには、broadcastableメソッドが自身を返すよう定義する必要があります。

Examples

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")
source
Base.Broadcast.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)
()
source
Base.Broadcast.combine_styles — Function
combine_styles(cs...)::BroadcastStyle

任意個数の値引数に対して、どのBroadcastStyleを使用するかを決定します。各引数のスタイルを取得するにはBroadcastStyleを使用し、スタイルの結合にはresult_styleを使用します。

Examples

julia> Broadcast.combine_styles([1], [1 2; 3 4])
Base.Broadcast.DefaultArrayStyle{2}()
source
Base.Broadcast.result_style — Function
result_style(s1::BroadcastStyle[, s2::BroadcastStyle])::BroadcastStyle

1つまたは2つのBroadcastStyleを受け取り、BroadcastStyleを使ってそれらを組み合わせ、共通のBroadcastStyleを判定します。

Examples

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}()
source

Indexing and assignment

Base.getindex — Method
getindex(A, inds...)

配列 A から、インデックス inds で指定した要素を返します。

各インデックスには、サポートされているインデックスの supported index type、たとえば Integer、CartesianIndex、range、array のいずれかを指定できます。特定の次元のすべての要素を選択するには : を使用できます。また、ブール配列(例: Array{Bool} や BitArray)を使うと、対応するインデックスが true である要素を抽出できます。

inds で複数の要素を選択すると、この関数は新しい配列を割り当てて返します。コピーせずに複数の要素をインデックス指定するには、代わりに view を使用してください。

詳しくは、array indexing のマニュアルの節を参照してください。

Examples

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
source
Base.setindex! — Method
setindex!(A, X, inds...)
A[inds...] = X

配列 X の値を、inds で指定された A の部分集合に格納します。構文 A[inds...] = X は (setindex!(A, X, inds...); X) と同等です。

Warning

変更対象の引数が、ほかのいずれかの引数とメモリを共有している場合、予期しない動作が発生することがあります。

Examples

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
source
Base.nextind — Function
nextind(A, i)

i の後のインデックスを A で返します。整数の i に対しては、返されるインデックスは多くの場合 i + 1 と同等です。この関数は、汎用コードで役立つことがあります。

Warning

返されるインデックスは範囲外になる可能性があります。checkbounds の使用を検討してください。

関連項目: prevind。

Examples

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)
source
Base.prevind — Function
prevind(A, i)

A 内で i より前にあるインデックスを返します。整数 i の場合、返されるインデックスは多くの場合 i - 1 と同じです。この関数は汎用コードで役立つことがあります。

Warning

返されるインデックスが範囲外になる可能性があります。checkbounds の使用を検討してください。

関連項目: nextind。

Examples

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)
source
Base.copyto! — Method
copyto!(dest, Rdest::CartesianIndices, src, Rsrc::CartesianIndices) -> dest

srcのブロックを、Rsrcの範囲から、destのブロックへ、Rdestの範囲内でコピーします。2つの領域のサイズは一致している必要があります。

Examples

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
source
Base.copy! — Function
copy!(dst, src) -> dst

src の内容を dst にインプレースで copy します。このとき、dst に既存の要素があれば破棄されます。dst と src が同じ型であれば、呼び出し後も dst == src が成り立ちます。dst と src がベクトル型の場合、オフセットが等しくなければなりません。dst と src が多次元配列の場合、axes が等しくなければなりません。

Warning

変更対象の引数が、ほかのいずれかの引数とメモリを共有している場合、予期しない動作になることがあります。

関連項目: copyto!。

Note

ベクトル型を操作する際、dst と src の長さが異なる場合、copy の前に dst のサイズが length(src) に変更されます。

Julia 1.1

このメソッドを使用するには Julia 1.1 以降が必要です。Julia 1.0 では、このメソッドは Future 標準ライブラリの Future.copy! として利用できます。

source
copy!(dest::AbstractMatrix, src::UniformScaling)

UniformScalingを行列にコピーします。

Julia 1.12

このメソッドはJulia 1.12以降で利用できます。

source
Base.isassigned — Function
isassigned(array, i)::Bool

指定された配列に、インデックス i に対応する値があるかどうかを判定します。インデックスが範囲外の場合、または未定義の参照がある場合は、false を返します。

Examples

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
source
Base.isassigned — Method
isassigned(v::Tuple, i::Integer) -> Bool

true を返します。ただし、インデックス i がタプル v の範囲内にある場合、つまり 1 ≤ i ≤ length(v) の場合です。

Julia 1.13

このメソッドを使用するには、Julia 1.13 以降が必要です。

source
Base.Colon — Type
Colon()

コロン(:)は、オブジェクト全体または次元全体を一度にインデックス指定することを表します。

コロン自体に対して定義されている操作はごくわずかです。代わりに、使用前にto_indicesによって内部ベクトル型(Base.Slice)に変換され、コロンが表すインデックスの集合を表現します。

Colonのシングルトンインスタンスは、範囲を構築する関数としても使われます。詳しくは:を参照してください。

source
Base.IteratorsMD.CartesianIndex — Type
CartesianIndex(i, j, k...)   -> I
CartesianIndex((i, j, k...)) -> I

多次元配列 A のインデックスとして使用できる、多次元インデックス I を作成します。特に、A[I] は A[i,j,k...] と同等です。整数インデックスと CartesianIndex インデックスは自由に組み合わせられます。たとえば、A[Ipre, i, Ipost](Ipre と Ipost は CartesianIndex インデックス、i は Int)という式は、任意の次元数の配列について、単一の次元に沿って処理するアルゴリズムを書く際に役立ちます。

CartesianIndex は eachindex によって生成されることがあり、明示的な CartesianIndices を使って反復処理を行う場合には必ず生成されます。

I::CartesianIndex は、broadcast において「スカラー」(コンテナーではないもの)として扱われます。CartesianIndex の各要素を反復処理するには、Tuple(I) を使ってタプルに変換します。

Examples

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
Julia 1.10

CartesianIndex を broadcast の「スカラー」として扱うには Julia 1.10 が必要です。それ以前のリリースでは、Ref(I) を使用してください。

source
Base.IteratorsMD.CartesianIndices — Type
CartesianIndices(sz::Dims) -> R
CartesianIndices((istart:[istep:]istop, jstart:[jstep:]jstop, ...)) -> R

整数インデックスの多次元の矩形範囲にわたる領域 R を定義します。これは主に反復処理で使われ、for I in R ... end は、次の入れ子のループと同等の CartesianIndex インデックス I を返します。

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

このため、任意の次元で動作するアルゴリズムを記述する際に役立ちます。

CartesianIndices(A::AbstractArray) -> R

利便性のため、配列から CartesianIndices を構築すると、その配列のインデックスの範囲が作成されます。

Julia 1.6

ステップ付き範囲のメソッド CartesianIndices((istart:istep:istop, jstart:[jstep:]jstop, ...)) には、Julia 1.6 以降が必要です。

Examples

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))

Conversion between linear and cartesian indices

線形インデックスからデカルトインデックスへの変換では、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)

Broadcasting

CartesianIndices は、CartesianIndex との算術演算(+ および -)のブロードキャストをサポートします。

Julia 1.1

CartesianIndices のブロードキャストには、Julia 1.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 を参照してください。

source
Base.LinearIndices — Type
LinearIndices(A::AbstractArray)

LinearIndices 配列を返します。この配列は A と同じ形状と axes を持ち、A の各要素の線形インデックスを格納します。この配列を直積インデックスでインデックス付けすると、それらを線形インデックスに対応付けられます。

通常のインデックス(インデックスが 1 から始まる)を持つ配列、または任意の多次元配列では、線形インデックスは 1 から length(A) までの範囲になります。ただし、AbstractVector の線形インデックスは axes(A, 1) であるため、通常とは異なるインデックスを持つベクトルでは 1 から始まりません。

この関数を呼び出すことが、線形インデックスを利用するアルゴリズムを安全に記述する方法です。

Examples

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

指定した形状または axes を持つ LinearIndices 配列を返します。

Examples

このコンストラクターの主な目的は、直積インデックスから線形インデックスへの直感的な変換です。

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
source
Base.to_indices — Function
to_indices(A, I::Tuple)

タプル I を、配列 A のインデックス指定に使うインデックスのタプルに変換します。

返されるタプルに含められるのは、配列 A がサポートするスカラーインデックスの Int または AbstractArray のみです。処理方法が分からない新しいインデックス型に遭遇すると、エラーになります。

単純なインデックス型の場合、各インデックス i の処理は、非公開の Base.to_index(A, i) に委譲されます。この内部関数を直接呼び出すことは想定されていませんが、カスタム配列型やカスタムインデックス型では、独自のインデックス処理を提供するために Base.to_index を拡張できます。

より複雑なインデックス型では、インデックスを適用する次元について、さらに多くの情報が必要になる場合があります。こうしたケースに対応するため、to_indices(A, I) は to_indices(A, axes(A), I) を呼び出します。後者は、与えられたインデックスのタプルと A の次元インデックスを対応させながら、両方を再帰的にたどります。そのため、すべてのインデックス型が Base.to_index に引き継がれるとは限りません。

Examples

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)
source
Base.checkbounds — Function
checkbounds(A, I...)

指定されたインデックス I が、指定された配列 A の範囲外である場合は、エラーをスローします。

source
checkbounds(Bool, A, I...)

指定されたインデックス I が配列 A の範囲内にある場合は、true を返します。独自の境界チェック動作を提供する必要がある場合は、AbstractArray のサブタイプでこのメソッドを特殊化してください。ただし、多くの場合は A のインデックスと checkindex を利用できます。

checkindex も参照してください。

Examples

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
source
Base.checkindex — Function
checkindex(Bool, inds::AbstractUnitRange, index)

指定されたindexがindsの範囲内にある場合は、trueを返します。すべての配列のインデックスとして機能させたいカスタム型は、このメソッドを拡張して、専用の境界チェック処理を実装できます。

checkboundsも参照してください。

Examples

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

julia> checkindex(Bool, 1:20, 21)
false
source
Base.elsize — Function
elsize(type)

指定された type 内に格納された eltype について、配列要素が均一な線形ストライドで密に格納されている場合、隣接する要素間のメモリ上のストライドをバイト単位で求めてください。

Examples

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

ほとんどのコードはインデックスに依存しない形で記述できます(例:eachindex)。ただし、オフセット軸を明示的に確認すると便利な場合もあります。

Base.require_one_based_indexing — Function
require_one_based_indexing(A::AbstractArray)
require_one_based_indexing(A,B...)

いずれかの引数のインデックスが、どの軸でも1以外から始まる場合は、ArgumentErrorをスローします。has_offset_axesも参照してください。

Julia 1.2

この関数を使用するには、Julia 1.2以降が必要です。

source
Base.has_offset_axes — Function
has_offset_axes(A)
has_offset_axes(A, B, ...)

いずれかの軸でAのインデックスが1以外から始まる場合は、trueを返します。複数の引数が渡された場合は、has_offset_axes(A) || has_offset_axes(B) || ...と同等です。

require_one_based_indexingも参照してください。

source

Views (SubArrays and other view types)

「ビュー」とは、配列のように振る舞うデータ構造(AbstractArrayのサブタイプ)ですが、実際のデータは別の配列の一部です。

たとえば、xが配列で、v = @view x[1:10]の場合、vは10要素の配列のように振る舞いますが、そのデータは実際にはxの先頭10要素にアクセスしています。ビューへの書き込み(例:v[3] = 2)は、基になる配列xに直接書き込みます(この場合、x[3]が変更されます)。

Juliaでは、x[1:10]のようなスライス操作は、デフォルトでコピーを作成します。@view x[1:10]を使うと、ビューを作成するように変更できます。@viewsマクロは、コードブロック全体(例:@views function foo() .... endまたは@views begin ... end)に適用して、そのブロック内のすべてのスライス操作でビューを使うようにできます。データのコピーを作成するほうが速い場合もあれば、ビューを使うほうが速い場合もあります。詳しくはperformance tipsを参照してください。

Base.view — Function
view(A, inds...)

getindexと同様ですが、要素をその場で取り出したり、コピーした部分配列を作成したりする代わりに、指定したインデックスindsで親配列Aを遅延参照する(実質的に親配列のビューとなる)軽量な配列を返します。返された値(多くの場合、SubArray)に対してgetindexまたはsetindex!を呼び出すと、親配列にアクセスまたは変更するためのインデックスがその都度計算されます。親配列の形状をviewの呼び出し後に変更した場合の動作は未定義です。親配列に対する境界チェックが行われないため、たとえばセグメンテーション違反が発生する可能性があります。また、ビューの作成後にinds配列を変更することも、動作未定義です。

範囲など一部の不変な親配列では、効率的で互換性のあるセマンティクスが得られる場合、SubArrayを返す代わりに、新しい配列を再計算することがあります。

Julia 1.6

Julia 1.6以降では、viewをAbstractStringに対して呼び出すと、SubStringが返されます。

Examples

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
source
Base.@view — Macro
@view A[inds...]

インデックス式 A[inds...] を、同等の view 呼び出しに変換します。

これは単一のインデックス式に対してのみ直接適用できます。特に、通常の view 関数ではサポートされない、begin や end などの特殊なインデックス構文(たとえば A[begin, 2:end-1])を含む式で役立ちます。

@view は通常の代入(例: @view(A[1, 2:end]) = ...)の左辺には使えません。また、装飾のない indexed assignment(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 も参照してください。

Julia 1.5

インデックス式で begin を使って最初のインデックスを参照するには、Julia 1.5 以降が必要です。

Examples

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
source
Base.@views — Macro
@views expression

与えられた式(begin/endブロック、ループ、関数など)に含まれるすべての配列スライス操作を、ビューを返すように変換します。スカラーインデックス、配列以外の型、および明示的なgetindex呼び出し(array[...]とは異なります)は対象外です。

同様に、@viewsは文字列スライスをSubStringビューに変換します。

Note

@viewsマクロの影響を受けるのは、与えられたexpression内に明示的に記述されたarray[...]式だけです。そのコードから呼び出される関数内で行われる配列スライスには影響しません。

Julia 1.5

インデックス式で最初のインデックスを参照するためにbeginを使う機能はJulia 1.4で実装されましたが、@viewsでサポートされたのはJulia 1.5からです。

Examples

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
source
Base.parent — Function
parent(A)

ビューの基になる親オブジェクトを返します。SubArray、SubString、ReshapedArray、LinearAlgebra.Transpose型のオブジェクトでは、この親オブジェクトは、オブジェクトの作成時に引数としてview、reshape、transposeなどに渡されたものです。入力がラップされたオブジェクトでない場合は、入力自体を返します。入力が複数回ラップされている場合、取り除かれるのは最外層のラッパーだけです。

Examples

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
source
Base.parentindices — Function
parentindices(A)

parent に含まれる、A に対応するインデックスを返してください。

Examples

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)))
source
Base.selectdim — Function
selectdim(A, d::Integer, i)

d の次元のインデックスが i である、A のすべてのデータを返します。

i が位置 d にある場合の view(A,:,:,...,i,:,:,...) と同等です。

関連項目: eachslice。

Examples

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
source
Base.reinterpret — Function
reinterpret(reshape, T, A::AbstractArray{S}) -> B

「チャネル次元」を消費または追加する際に、Aの型解釈を変更します。

n>1に対してsizeof(T) = n*sizeof(S)の場合、Aの第1次元のサイズはnでなければならず、BにはAの第1次元がありません。逆に、n>1に対してsizeof(S) = n*sizeof(T)の場合、Bにはサイズnの新しい第1次元が追加されます。sizeof(T) == sizeof(S)の場合、次元数は変わりません。

Julia 1.6

このメソッドを使用するには、Julia 1.6以降が必要です。

Examples

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  6
source
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)]); # showing will error

julia> b[1]
ERROR: Padding of type UInt32 is not compatible with type Tuple{UInt8, UInt32}.
source
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)
Note

パディングの扱いは、reinterpret(::DataType, ::AbstractArray) の場合とは異なります。

Warning

Out のビットの組み合わせの中に無効とみなされるものがあり、それが型のコンストラクターやメソッドによって通常は防がれる場合は、注意してください。追加の検証を行わないと、予期しない動作が発生する可能性があります。

source
Base.reshape — Function
reshape(A, dims...)::AbstractArray
reshape(A, dims)::AbstractArray

Aと同じデータを持ち、次元のサイズまたは次元数が異なる配列を返します。2つの配列は同じ基底データを共有するため、結果が変更可能であるのはAが変更可能な場合に限られます。また、一方の要素を設定すると、もう一方の値も変わります。

新しい次元は、引数のリストまたは形状タプルで指定できます。:で指定できる次元は最大1つで、その場合、その長さは、指定されたすべての次元との積が元の配列Aの長さと等しくなるように計算されます。要素の総数は変わりません。

Examples

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
source
Base.insertdims — Function
insertdims(A; dims)

dropdims の逆関数です。dims の各次元に新しいサイズ1の次元を追加した配列を返します。

次元の重複は許可されません。また、dims の最大の要素は ndims(A) + length(dims) 以下でなければなりません。

結果は A と同じ基底データを共有します。そのため、結果が変更可能であるのは A が変更可能な場合に限られ、一方の要素を設定すると、もう一方の値も変わります。

関連項目: dropdims、reshape、vec。

Examples

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
Julia 1.12

Julia 1.12 以降が必要です。

source
Base.dropdims — Function
dropdims(A; dims)

Aと同じデータを持つ配列を返します。ただし、dimsで指定された次元は削除されます。dims内のすべてのdについて、size(A,d)は1でなければならず、1:ndims(A)の範囲外にある次元や数値の重複は禁止されています。

結果はAと同じ基底データを共有します。そのため、Aが変更可能である場合に限り結果も変更可能であり、一方の要素を設定すると、もう一方の値も変わります。

関連項目: reshape、vec。

Examples

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
source
Base.vec — Function
vec(a::AbstractArray)::AbstractVector

配列 a を1次元の列ベクトルに変形します。すでに AbstractVector である場合は、a を返します。結果の配列は a と同じ基になるデータを共有するため、変更可能なのは a が変更可能な場合に限られます。その場合、一方を変更すると、もう一方にも変更が反映されます。

Examples

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

関連項目: reshape、dropdims。

source
Base.SubArray — Type
SubArray{T,N,P,I,L} <: AbstractArray{T,N}

要素型が T で、インデックスのタプル(型 I)によって制限された、親配列(型 P)への N 次元ビューです。高速な線形インデックス付けをサポートする型では L が true になり、それ以外の型では false になります。

view 関数を使って SubArray を構築します。

source

Concatenation and permutation

Base.cat — Function
cat(A...; dims)

入力配列を、dimsで指定した次元に沿って連結します。

次元d in dimsにおける出力配列のサイズはsum(size(a,d) for a in A)です。それ以外の次元では、すべての入力配列のサイズが同じである必要があり、そのサイズが出力配列の該当する次元のサイズになります。

dimsが単一の数値の場合、各配列はその次元に沿って隙間なく配置されます。dimsが複数の次元を含む反復可能オブジェクトの場合、各入力配列について、これらの次元に沿った位置が同時に進み、それ以外の位置はゼロで埋められます。これにより、ブロック対角行列をcat(matrices...; dims=(1,2))として構築できるほか、その高次元の類似物も構築できます。

特殊なケースとして、dims=1はvcatであり、dims=2はhcatです。hvcat、hvncat、stack、repeatも参照してください。

このキーワードはVal(dims)も受け取ります。

Julia 1.8

複数の次元を指定するdims = Val(::Tuple)は、Julia 1.8で追加されました。

Examples

異なる次元に沿って2つの配列を連結します。

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

Extended Help

3次元配列を連結します。

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  1
julia> cat(1, [2], [3;;]; dims=Val(2))
1×3 Matrix{Int64}:
 1  2  3
Note

catは2つの文字列を連結しません。文字列の連結には*を使用してください。

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"
source
Base.vcat — Function
vcat(A...)

配列または数値を縦方向に連結します。cat(A...; dims=1)および構文[a; b; c]と同等です。

配列の大きなベクトルを連結する場合、reduce(vcat, A)は、A isa AbstractVector{<:AbstractVecOrMat}のときに、ペアごとに処理するのではなく、効率的なメソッドを呼び出します。

hcat、Iterators.flatten、stackも参照してください。

Examples

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
source
Base.hcat — Function
hcat(A...)

配列または数値を水平方向に連結します。cat(A...; dims=2)と同等で、構文[a b c]または[a;; b;; c]でも表せます。

配列を多数含むベクトルの場合、reduce(hcat, A)はA isa AbstractVector{<:AbstractVecOrMat}のときに効率的なメソッドを呼び出します。ベクトルのベクトルの場合は、stack(A)とも書けます。

関連項目: vcat、hvcat。

Examples

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
source
Base.hvcat — Function
hvcat(blocks_per_row::Union{Tuple{Vararg{Int}}, Int}, values...)

1回の呼び出しで、水平連結と垂直連結を行います。この関数は、ブロック行列構文で呼び出されます。最初の引数には、各ブロック行で連結する引数の数を指定します。最初の引数が単一の整数 n の場合、すべてのブロック行のブロック列数は n であるとみなされます。

Examples

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
source
Base.hvncat — Function
hvncat(dim::Int, row_first, values...)
hvncat(dims::Tuple{Vararg{Int}}, row_first, values...)
hvncat(shape::Tuple{Vararg{Tuple}}, row_first, values...)

複数の values を、1 回の呼び出しで水平方向、垂直方向、および n 次元に連結します。

この関数は、ブロック行列構文で呼び出されます。第 1 引数には、タプルのタプルとして連結の形状を指定する方法(hvcat と同様)と、各軸に沿った要素数を決める次元を指定する方法があります。この引数を使って出力の次元が決まります。dims 形式はより高性能で、連結操作において各軸に沿った要素数が同じ場合(例: [a b; c d;;; e f ; g h])にデフォルトで使われます。各軸に沿った要素数が不均衡な場合(例: [a b ; c])は、shape 形式が使われます。不均衡な構文では、追加の検証処理が必要です。dim 形式は、1 つの次元に沿って連結する場合に限った最適化です。row_first は、values の順序を指定します。shape の第 1 要素と第 2 要素の意味も、row_first に応じて入れ替わります。

Examples

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

Examples for construction of the arguments

[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
source
Base.stack — Function
stack(f, args...; [dims])

コレクションの各要素に関数を適用し、stack結果を返します。複数のコレクションを指定する場合は、zipして適用します。

関数は、すべて同じサイズの配列(またはタプル、その他のイテレータ)を返す必要があります。これらは結果のスライスとなり、それぞれdimsに沿って(指定されている場合)、指定がなければ最後の次元に沿って分割されます。

mapslices、eachcolも参照してください。

Examples

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
source
stack(iter; [dims])

同じサイズの配列(またはその他の反復可能オブジェクト)のコレクションを、新しい次元を1つ以上追加して並べることで、より大きな配列にまとめます。

デフォルトでは、要素の軸が先に配置され、size(result) = (size(first(iter))..., size(iter)...)となります。これは、Iterators.flatten(iter)と同じ要素順になります。

キーワードdims::Integerを指定すると、代わりにiterのi番目の要素がスライスselectdim(result, dims, i)となり、size(result, dims) == length(iter)となります。この場合、stackは、同じdimsを指定したeachsliceの逆の操作を行います。

catの各種関数も配列を結合します。ただし、これらの関数は配列を新しい次元に沿って配置するのではなく、既存の(場合によっては自明な)次元を拡張します。また、単一のコレクションではなく、個別の引数として配列を受け取ります。

Julia 1.9

この関数を使用するには、Julia 1.9以降が必要です。

Examples

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(Iterators.flatten(zip(1:4, 10:99)))
true

julia> stack(vecs; dims=1)  # unlike any cat function, 1st axis of vecs[1] is 2nd axis of result
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)  # inverse of eachslice
true

高次元の例:

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)
source
Base.vect — Function
vect(X...)

引数のpromote_typeofから要素型を計算し、引数リストを格納するVectorを作成します。

Examples

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

A 内のデータを循環シフト(回転)します。第2引数には、各次元のシフト量を指定するタプルまたはベクトルを渡します。整数を渡した場合は、第1次元のみをシフトします。

シフト量がコンパイル時に既知、つまりコンパイル時定数である場合、生成されるコードは最も効率的になります。

関連項目: circshift!、circcopy!、bitrotate、<<。

Examples

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

julia> x = (1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)

julia> circshift(x, 4)
(2, 3, 4, 5, 1)

julia> z = (1, 'a', -7.0, 3)
(1, 'a', -7.0, 3)

julia> circshift(z, -1)
('a', -7.0, 3, 1)
source
Base.circshift! — Function
circshift!(dest, src, shifts)

src のデータを循環シフト(回転)し、その結果を dest に格納します。shifts は、各次元でのシフト量を指定します。

Warning

変更される引数がほかの引数とメモリを共有している場合、予期しない動作になることがあります。

関連項目: circshift。

source
circshift!(a::AbstractVector, shift::Integer)

ベクトル a のデータを、shift 個分だけ循環シフト(回転)します。

Examples

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
source
Base.circcopy! — Function
circcopy!(dest, src)

src を dest にコピーします。各次元のインデックスは、その次元の長さを法として扱われます。src と dest は同じサイズである必要がありますが、インデックスのオフセットは異なっていてもかまいません。オフセットがある場合、インデックスは循環的に折り返されます。配列のインデックスが重複する場合、重複部分の範囲では dest と src は一致します。

Warning

変更対象の引数がほかの引数とメモリを共有している場合、予期しない動作になることがあります。

関連項目: circshift。

Examples

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]
true
source
Base.findall — Method
findall(A)

A の true インデックスまたはキーのベクトル I を返します。該当する A 要素がない場合は、空の配列を返します。他の種類の値を検索するには、述語を第1引数として渡してください。

インデックスまたはキーの型は、keys(A) および pairs(A) が返すものと同じです。

関連項目: findfirst、searchsorted。

Examples

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[]
source
Base.findall — Method
findall(f::Function, A)

A の要素のうち、f(A[I]) が true を返すものについて、そのインデックスまたはキーのベクトル I を返します。A に該当する要素がない場合は、空の配列を返します。

インデックスまたはキーの型は、keys(A) および pairs(A) が返すものと同じです。

Examples

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
source
Base.findfirst — Method
findfirst(A)

true の値が A 内で最初に見つかった位置のインデックスまたはキーを返します。そのような値が見つからない場合は、nothing を返します。他の種類の値を検索するには、述語を第1引数として渡します。

インデックスまたはキーの型は、keys(A) および pairs(A) が返すものと同じです。

関連項目: findall、findnext、findlast、searchsortedfirst。

Examples

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)
source
Base.findfirst — Method
findfirst(predicate::Function, A)

Aの最初の要素のうち、predicateがtrueを返す要素のインデックスまたはキーを返します。そのような要素がない場合は、nothingを返します。

インデックスまたはキーの型は、keys(A)およびpairs(A)が返す型と同じです。

Examples

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)
source
Base.findlast — Method
findlast(A)

A 内の最後の true 値のインデックスまたはキーを返します。A に true 値がない場合は、nothing を返します。

インデックスまたはキーの型は、keys(A) および pairs(A) が返す型と同じです。

関連項目: findfirst、findprev、findall。

Examples

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) # returns nothing, but not printed in the REPL

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

julia> findlast(A)
CartesianIndex(2, 1)
source
Base.findlast — Method
findlast(predicate::Function, A)

predicate が true を返す、A の最後の要素のインデックスまたはキーを返します。そのような要素がない場合は、nothing を返します。

インデックスまたはキーの型は、keys(A) および pairs(A) が返す値と同じです。

Examples

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)
source
Base.findnext — Method
findnext(A, i)

i以降(またはそれを含む位置)で、A型の要素のうち、trueを満たす次のインデックスを返します。見つからない場合はnothingを返します。

インデックスの型は、keys(A)およびpairs(A)が返すものと同じです。

Examples

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)
source
Base.findnext — Method
findnext(predicate::Function, A, i)

i以降(そのインデックスを含む)の要素のうち、A型で、predicateがtrueを返す要素の次のインデックスを検索します。見つからない場合はnothingを返します。これは、getindex、keys(A)、nextindをサポートするArray、String、およびその他のほとんどのコレクションで使用できます。

インデックスの型は、keys(A)およびpairs(A)が返す型と同じです。

Examples

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
source
Base.findprev — Method
findprev(A, i)

i以前または同じ位置にある、Aの要素trueの直前のインデックスを返します。見つからない場合はnothingを返します。

インデックスの型は、keys(A)およびpairs(A)が返す型と同じです。

関連項目: findnext、findfirst、findall。

Examples

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)
source
Base.findprev — Method
findprev(predicate::Function, A, i)

i以前または同じ位置にある要素のうち、Aに対してpredicateを適用した結果がtrueとなる要素のインデックスを返します。見つからない場合はnothingを返します。これは、getindex、keys(A)、nextindをサポートするArray、String、およびその他のほとんどのコレクションで動作します。

インデックスの型は、keys(A)およびpairs(A)が返す型と同じです。

Examples

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
source
Base.permutedims — Function
permutedims(v::AbstractVector)

ベクトル v を 1 × length(v) の行列に変換します。transpose と異なり、この操作は再帰的ではありません。そのため、数値以外の値を含む配列に特に便利です(再帰的な transpose ではエラーが発生する場合があります)。

Examples

transpose とは異なり、permutedims は、文字列など、任意の数値以外の要素を含むベクトルにも使用できます。

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

数値のベクトルに対しては、permutedims(v) は transpose(v) とほぼ同じように動作しますが、戻り値の型が異なります(LinearAlgebra.Transpose のビューではなく、reshape を使用します。ただし、どちらも元の配列 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

ただし、要素自体が数値行列であるベクトルでは、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]
source
permutedims(A::AbstractArray, perm)
permutedims(A::AbstractMatrix)

配列 A の次元(軸)を並べ替えます。perm は、並べ替えを指定する ndims(A) 整数のタプルまたはベクトルです。

A が2次元配列(AbstractMatrix)の場合、perm の既定値は (2,1) で、A の2つの軸(行と列)を入れ替えます。この操作は transpose と異なり、再帰的ではありません。そのため、数値以外の値を含む配列(再帰的な transpose ではエラーになる)や、線形作用素を表さない2次元配列に特に便利です。

1次元配列については、1行の「行列」を返す permutedims(v::AbstractVector) を参照してください。

関連項目: permutedims!、PermutedDimsArray、transpose、invperm。

Examples

2d arrays:

transpose とは異なり、permutedims は、文字列など、数値以外の任意の要素を含む2次元配列の行と列を入れ替えるために使用できます。

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]

Multi-dimensional arrays

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

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
source
Base.permutedims! — Function
permutedims!(dest, src, perm)

配列 src の次元を並べ替え、その結果を配列 dest に格納します。perm は、長さ ndims(src) の置換を指定するベクトルです。事前に確保した配列 dest は size(dest) == size(src)[perm] を持つ必要があり、内容はすべて上書きされます。インプレースでの置換はサポートされていません。また、src と dest のメモリ領域が重なっている場合、予期しない結果が生じます。

permutedims も参照してください。

source
Base.PermutedDimsArrays.PermutedDimsArray — Type
PermutedDimsArray(A, perm) -> B

AbstractArray A が与えられたとき、次元が並べ替えられているように見えるビュー B を作成します。permutedims と似ていますが、コピーは行われません(B は A とストレージを共有します)。

関連項目: permutedims、invperm。

Examples

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

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

julia> size(B)
(4, 3, 5)

julia> B[3,1,2] == A[1,2,3]
true
source
Base.promote_shape — Function
promote_shape(s1, s2)

末尾の次元が 1 である場合はそれを許容して、2 つの配列の形状に互換性があるか確認し、次元数の多い方の形状を返します。

Examples

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)
source

Array functions

Base.accumulate — Function
accumulate(op, A; dims::Integer, [init])

op を A の dims 次元に沿って累積します(ベクトルの場合、dims は省略可能です)。キーワード引数で初期値 init を指定することもできます。パフォーマンスの向上や、出力の精度を制御する(たとえばオーバーフローを避ける)ために、事前に確保した出力配列を使う方法については accumulate! も参照してください。

一般的な操作には、accumulate の専用バリアントがあります。cumsum、cumprod を参照してください。遅延評価版については Iterators.accumulate を参照してください。

Julia 1.5

配列ではないイテレータに対する accumulate の使用には、Julia 1.5 以降が必要です。

Examples

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
source
Base.accumulate! — Function
accumulate!(op, B, A; [dims], [init])

Aに沿って、次元dims方向に累積演算opを行い、その結果をBに格納します。ベクトルの場合、dimsの指定は省略できます。キーワード引数initを指定すると、その値を使って累積処理が初期化されます。

Warning

変更される引数がほかの引数とメモリを共有している場合、予期しない動作が起こることがあります。

関連項目: accumulate、cumsum!、cumprod!。

Examples

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
source
Base.cumprod — Function
cumprod(itr)

イテレータの累積積。

関連項目: cumprod!、accumulate、cumsum。

Julia 1.5

配列以外のイテレータに対する cumprod の使用には、Julia 1.5 以降が必要です。

Examples

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"
source
cumprod(A; dims::Integer)

次元 dim に沿った累積積。パフォーマンスの向上や、出力の精度を制御する(たとえばオーバーフローを避ける)ために、事前に確保した出力配列を使う方法については cumprod! も参照してください。

Examples

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
source
Base.cumprod! — Function
cumprod!(y::AbstractVector, x::AbstractVector)

ベクトル x の累積積を計算し、結果を y に格納します。cumprod も参照してください。

Warning

変更される引数がほかの引数とメモリを共有している場合、予期しない動作になることがあります。

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

Aの累積積を次元dimsに沿って計算し、結果をBに格納します。cumprodも参照してください。

Warning

変更される引数がほかの引数とメモリを共有している場合、予期しない動作が起こることがあります。

source
Base.cumsum — Function
cumsum(itr)

イテレータの累積和。

accumulateを使うと、+以外の関数を適用できます。

Julia 1.5

配列以外のイテレータに対するcumsumの使用には、Julia 1.5以降が必要です。

Examples

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]
source
cumsum(A; dims::Integer)

次元 dims に沿った累積和です。パフォーマンスの向上や、出力の精度を制御する(たとえばオーバーフローを避ける)目的で、事前に確保した出力配列を使う場合は cumsum! も参照してください。

Examples

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
Note

戻り値の配列の eltype は、システムのワードサイズ未満の符号付き整数では Int、符号なし整数では UInt です。小さい符号付きまたは符号なし整数型の配列で eltype を保つには、accumulate(+, A) を使用してください。

julia> cumsum(Int8[100, 28])
2-element Vector{Int64}:
 100
 128

julia> accumulate(+,Int8[100, 28])
2-element Vector{Int8}:
  100
 -128

前者の場合、整数はシステムのワードサイズに拡張されるため、結果は Int64[100, 128] になります。後者の場合は拡張されず、整数オーバーフローが発生すると Int8[100, -128] になります。

source
Base.cumsum! — Function
cumsum!(B, A; dims::Integer)

Aを次元dimsに沿って累積加算し、結果をBに格納します。cumsumも参照してください。

Warning

変更される引数がほかの引数とメモリを共有している場合、予期しない動作になることがあります。

source
Base.diff — Function
diff(A::AbstractVector)
diff(A::AbstractArray; dims::Integer)

ベクトルまたは多次元配列に対する有限差分演算子 A。多次元配列の場合は、演算対象の次元をキーワード引数 dims で指定する必要があります。

Julia 1.1

次元が2を超える配列に対する diff の使用には、Julia 1.1以降が必要です。

Examples

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
source
Base.repeat — Function
repeat(A::AbstractArray; inner=ntuple(Returns(1), ndims(A)), outer=ntuple(Returns(1), ndims(A)))

A の各要素を繰り返して配列を構築します。inner の i 番目の要素は、A の i 番目の次元にある各要素を繰り返す回数を指定します。outer の i 番目の要素は、A の i 番目の次元に沿ったスライスを繰り返す回数を指定します。inner または outer を省略した場合、繰り返しは行われません。

Examples

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
source
repeat(A::AbstractArray, counts::Integer...)

配列 A を、counts で指定した各次元の回数だけ繰り返して配列を構築します。

関連項目: fill、Iterators.repeated、Iterators.cycle。

Examples

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
source
repeat(c::AbstractChar, r::Integer)::String

文字をr回繰り返します。これは、c^rを呼び出すことでも同様に実現できます。

Examples

julia> repeat('A', 3)
"AAA"
source
repeat(s::AbstractString, r::Integer)

文字列をr回繰り返します。これはs^rと記述できます。

^も参照してください。

Examples

julia> repeat("ha", 3)
"hahaha"
source
Base.rot180 — Function
rot180(A, k)

行列 A を 180 度回転させます。回転回数は整数 k 回です。k が偶数の場合、これは copy と同等です。

Examples

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
source
rot180(A)

行列 A を180度回転します。

Examples

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
source
Base.rotl90 — Function
rotl90(A, k)

行列 A を反時計回りに90度、整数 k 回左回転します。k が4の倍数(0を含む)の場合、これは copy と同等です。

Examples

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
source
rotl90(A)

行列 A を左に90度回転します。

Examples

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
source
Base.rotr90 — Function
rotr90(A, k)

行列 A を時計回りに 90 度、整数 k 回右回転します。k が 4 の倍数(0 を含む)の場合、これは copy と同等です。

Examples

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
source
rotr90(A)

行列 A を右に90度回転します。

Examples

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
source
Base.mapslices — Function
mapslices(f, A; dims)

配列 A の指定した次元を変換します。dims の各 d にコロンを置いたときのスライス A[..., :, ..., :, ...] ごとに関数 f を適用し、その結果を残りの次元に沿って連結します。

たとえば、dims = [1,2] と A が4次元の場合、f は、すべての i と j について x = A[:,:,i,j] に適用されます。その結果、f(x) は R[:,:,i,j] となり、結果の R に含まれます。

eachcol または eachslice も参照してください。これらは map または stack と併用します。

Examples

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);  # returns a 1×4 matrix

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];  # returns a number

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 に影響を与えない場合があります。

source
Base.eachrow — Function
eachrow(A::AbstractVecOrMat) <: AbstractVector

行列またはベクトルAの行を要素とするベクトルであるRowSlicesオブジェクトを作成します。行のスライスは、AのAbstractVectorビューとして返されます。

逆の操作については、stack(rows; dims=1)を参照してください。

eachcol、eachslice、mapslicesも参照してください。

Julia 1.1

この関数を使用するには、Julia 1.1以降が必要です。

Julia 1.9

Julia 1.9より前のバージョンでは、これはイテレーターを返していました。

Examples

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
source
Base.eachcol — Function
eachcol(A::AbstractVecOrMat) <: AbstractVector

行列またはベクトル A の列をベクトルとしてまとめた ColumnSlices オブジェクトを作成します。列のスライスは、A の AbstractVector ビューとして返されます。

逆の操作については、stack(cols) または reduce(hcat, cols) を参照してください。

eachrow、eachslice、mapslices も参照してください。

Julia 1.1

この関数を使用するには、Julia 1.1 以降が必要です。

Julia 1.9

Julia 1.9 より前のバージョンでは、イテレーターを返していました。

Examples

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
source
Base.eachslice — Function
eachslice(A::AbstractArray; dims, drop=true)

スライスされたオブジェクトを作成します。通常はSlicesで、Aの次元dimsに沿ったスライスの配列です。各スライスは、Aにおける他の次元のデータをすべて選択するビューを返します。dimsには、整数または整数のタプルを指定できます。

drop = true(デフォルト)の場合、外側のスライスでは内側の次元が削除され、次元の順序はdimsの順序と一致します。drop = falseの場合、スライスオブジェクトの次元数は元の配列と同じになり、内側の次元のサイズは1になります。

eachslice(A; dims::Integer)の逆の操作については、stack(slices; dims)を参照してください。

eachrow、eachcol、mapslices、selectdimも参照してください。

Julia 1.1

この関数を使用するには、Julia 1.1以降が必要です。

Julia 1.9

Julia 1.9より前のバージョンでは、これはイテレータを返し、単一の次元dimsのみがサポートされていました。

Examples

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]
source

Combinatorics

Base.invperm — Function
invperm(v)

v の逆置換を返します。B = A[v] の場合は、A == B[invperm(v)] です。

関連項目: sortperm、invpermute!、isperm、permutedims。

Examples

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)
source
Base.isperm — Function
isperm(v)::Bool

trueを返してください。ただし、vが有効な順列である場合に限ります。

Examples

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false
source
Base.permute! — Method
permute!(v, p)

ベクトル v を置換 p に従って並べ替え、結果を v に書き戻します。p が置換であるかどうかの検証は行われません。

新しい置換を返すには、v[p] を使用してください。通常、これは permute!(v, p) より高速です。事前に確保した出力配列に u .= @view v[p] を使って書き込むと、さらに高速になります。(permute! は v をインプレースで上書きしますが、内部では一部のメモリ確保が必要です。)

Warning

変更対象の引数が、ほかのいずれかの引数とメモリを共有している場合、予期しない動作になることがあります。

invpermute! も参照してください。

Examples

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
source
Base.invpermute! — Function
invpermute!(v, p)

permute!と同様ですが、指定された置換の逆置換を適用します。

あらかじめ出力配列を確保してある場合(例:u = similar(v))は、代わりにu[p] = vを使うほうが高速です。(invpermute!は内部でデータのコピーを確保します。)

Warning

変更される引数がほかの引数とメモリを共有している場合、予期しない動作になることがあります。

Examples

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
source
Base.reverse — Method
reverse(A; dims=:)

A を、dims で指定した次元に沿って反転します。指定できるのは、整数(単一の次元)、整数のタプル(複数の次元)、または :(すべての次元に沿って反転するデフォルト値)です。インプレースでの反転については、reverse! も参照してください。

Examples

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
Julia 1.6

Julia 1.6 より前のバージョンでは、reverse でサポートされる dims は単一の整数のみです。

source
Base.reverseind — Function
reverseind(v, i)

reverse(v) 内のインデックス i が与えられたとき、v 内で対応するインデックスを返します。これにより、v[reverseind(v,i)] == reverse(v)[i] が成り立ちます。(v に非 ASCII 文字が含まれる場合、これは単純ではありません。)

Examples

julia> s = "Julia🚀"
"Julia🚀"

julia> r = reverse(s)
"🚀ailuJ"

julia> for i in eachindex(s)
           print(r[reverseind(r, i)])
       end
Julia🚀
source
Base.reverse! — Function
reverse!(A; dims=:)

reverseと同様ですが、A内でインプレースに動作します。

Julia 1.6

多次元のreverse!にはJulia 1.6が必要です。

source
reverse!(v [, start=firstindex(v) [, stop=lastindex(v) ]]) -> v

reverseのインプレース版。

Examples

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
source