Arrays

AbstractArray{T,N}

型 T の要素を持つ N 次元配列（または配列のような型）のスーパタイプ。 Array および他の型はこれのサブタイプです。 AbstractArray インターフェース に関するマニュアルのセクションを参照してください。

関連情報: AbstractVector, AbstractMatrix, eltype, ndims.

AbstractVector{T}

要素の型が T である一次元配列（または配列に似た型）のスーパークラス。 AbstractArray{T,1} のエイリアスです。

AbstractMatrix{T}

要素の型が T である二次元配列（または配列のような型）のスーパークラス。 AbstractArray{T,2} のエイリアスです。

AbstractVecOrMat{T}

AbstractVector{T} と AbstractMatrix{T} のユニオン型。

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

型 T の要素を持つ N 次元密な配列。

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

型 T の要素を含む初期化されていない N 次元の Array を構築します。N は Array{T,N}(undef, dims) のように明示的に指定することも、dims の長さまたは数によって決定されることもあります。dims はタプルまたは各次元の長さに対応する整数引数の系列である場合があります。ランク N が明示的に指定された場合、それは dims の長さまたは数と一致しなければなりません。ここで undef は UndefInitializer です。

例

julia> A = Array{Float64, 2}(undef, 2, 3) # N が明示的に指定されている
2×3 Matrix{Float64}:
 6.90198e-310  6.90198e-310  6.90198e-310
 6.90198e-310  6.90198e-310  0.0

julia> B = Array{Float64}(undef, 4) # N が入力によって決定される
4-element Vector{Float64}:
   2.360075077e-314
 NaN
   2.2671131793e-314
   2.299821756e-314

julia> similar(B, 2, 4, 1) # typeof(B) を使用し、指定されたサイズを使う
2×4×1 Array{Float64, 3}:
[:, :, 1] =
 2.26703e-314  2.26708e-314  0.0           2.80997e-314
 0.0           2.26703e-314  2.26708e-314  0.0

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

T型の要素を含むN次元のArrayを構築し、nothingエントリで初期化します。要素型Tはこれらの値を保持できる必要があります。すなわち、Nothing <: Tです。

例

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

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

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

T型の要素を含むN次元のArrayを構築し、missingエントリで初期化します。要素型Tはこれらの値を保持できる必要があります。すなわち、Missing <: Tです。

例

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

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

UndefInitializer

配列初期化に使用されるシングルトン型で、配列コンストラクタ呼び出し元が初期化されていない配列を希望していることを示します。undef[@ref]のエイリアスであるUndefInitializer()も参照してください。

例

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

undef

UndefInitializer()のエイリアスで、配列初期化に使用されるシングルトン型UndefInitializerのインスタンスを構築します。これは、配列コンストラクタ呼び出し元が初期化されていない配列を希望していることを示します。

関連情報: missing, similar.

例

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

Vector{T} <: AbstractVector{T}

要素の型が T の一次元密な配列で、数学的なベクトルを表すためにしばしば使用されます。 Array{T,1} のエイリアスです。

ベクトルを作成するための empty、similar、および zero も参照してください。

Vector{T}(undef, n)

長さ n の初期化されていない Vector{T} を構築します。

例

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

Vector{T}(nothing, m)

長さ m の Vector{T} を構築し、nothing エントリで初期化します。要素型 T はこれらの値を保持できる必要があります。すなわち、Nothing <: T です。

例

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

Vector{T}(missing, m)

長さ m の Vector{T} を構築し、missing エントリで初期化します。要素型 T はこれらの値を保持できる必要があります。すなわち、Missing <: T です。

例

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

Matrix{T} <: AbstractMatrix{T}

要素の型が T の二次元密な配列で、数学的な行列を表すためにしばしば使用されます。 Array{T,2} のエイリアスです。

行列を作成するための fill、zeros、undef、および similar も参照してください。

Matrix{T}(undef, m, n)

サイズ m×n の初期化されていない Matrix{T} を構築します。

例

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

Matrix{T}(nothing, m, n)

サイズ m×n の Matrix{T} を構築し、nothing エントリで初期化します。要素型 T はこれらの値を保持できる必要があります。すなわち、Nothing <: T です。

例

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

Matrix{T}(missing, m, n)

サイズ m×n の Matrix{T} を作成し、missing エントリで初期化します。要素型 T はこれらの値を保持できる必要があります。すなわち、Missing <: T です。

例

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

VecOrMat{T}

Vector{T} と Matrix{T} のユニオン型で、関数が行列またはベクトルのいずれかを受け入れることを可能にします。

例

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

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

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

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

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

DenseVector{T}

要素の型が T の一次元 DenseArray。DenseArray{T,1} のエイリアスです。

DenseMatrix{T}

要素の型が T の二次元 DenseArray。DenseArray{T,2} のエイリアスです。

DenseVecOrMat{T}

DenseVector{T} と DenseMatrix{T} のユニオン型。

StridedArray{T, N}

共通の配列型のハードコーディングされた Union で、ストライド配列インターフェース に従い、要素の型は T で次元は N です。

もし A が StridedArray であれば、その要素はメモリ内にオフセットで格納され、次元間で異なる場合がありますが、次元内では一定です。例えば、A は次元 1 でストライド 2 を持ち、次元 2 でストライド 3 を持つ可能性があります。次元 d に沿って A をインクリメントすると、メモリ内で [stride(A, d)] スロット分ジャンプします。ストライド配列は特に重要で便利であり、時には BLAS のような外国語ライブラリにポインタとして直接渡すことができます。

StridedVector{T}

要素の型が T の一次元 StridedArray です。

StridedMatrix{T}

要素の型が T の二次元 StridedArray です。

StridedVecOrMat{T}

要素の型が T の StridedVector と StridedMatrix のユニオン型。

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

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

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

固定サイズの DenseVector{T}。

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

メモリオブジェクトとオフセットインデックス（1ベース、負の値も可）からGenericMemoryRefを構築します。これは常に境界内のオブジェクトを返し、そうでない場合（インデックスが基盤となるメモリの境界を超えるシフトを引き起こす場合）にはエラーをスローします。

memoryref(::GenericMemory)

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

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

指定された次元に対する親配列へのスライスのAbstractArrayであり、他の次元からすべてのデータを選択するビューを返します。

これらは通常、eachslice、eachcolまたはeachrowによって構築されるべきです。

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

RowSlices{M,AX,S}

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

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

ColumnSlices{M,AX,S}

Slices の特別なケースで、行列の列スライスのベクトルであり、eachcol によって構築されます。

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

getindex(type[, elements...])

指定された型の1次元配列を構築します。これは通常、Type[]という構文で呼び出されます。要素の値はType[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

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

要素型 T のすべてのゼロからなる Array を、dims で指定されたサイズで作成します。詳細は fill、ones、zero を参照してください。

例

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

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

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

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

例

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

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

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

スペース効率の良い N 次元ブール配列で、各ブール値に対して1ビットのみを使用します。

BitArray は、64の値を8バイトごとにパックし、Array{Bool, N} に対して8倍のスペース効率を実現し、いくつかの操作が64の値に対して一度に動作することを可能にします。

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

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

与えられた次元を持つ未定義の BitArray を構築します。 Array コンストラクタと同様に動作します。 undef を参照してください。

例

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

julia> BitArray(undef, (3, 1))
3×1 BitMatrix:
 0
 0
 0

BitArray(itr)

与えられたイテラブルオブジェクトによって生成されたBitArrayを構築します。形状はitrオブジェクトから推測されます。

例

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

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

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

trues(dims)

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

例

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

falses(dims)

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

例

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

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

サイズ dims の配列を作成し、すべての位置を value に設定します。

例えば、fill(1.0, (5,5)) は、5×5 の浮動小数点数の配列を返し、配列のすべての位置に 1.0 が入ります。

次元の長さ dims は、タプルまたは引数のシーケンスとして指定できます。N 長のタプルまたは value に続く N の引数は、N 次元の配列を指定します。したがって、ゼロ次元の配列を作成し、その唯一の位置を x に設定する一般的な慣用句は 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.

例

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

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

julia> A = fill(zeros(2), 2) # 両方の要素を同じ [0.0, 0.0] ベクトルに設定
2-element Vector{Vector{Float64}}:
 [0.0, 0.0]
 [0.0, 0.0]

julia> A[1][1] = 42; # 塗りつぶされた値を [42.0, 0.0] に変更

julia> A # A[1] と A[2] はまったく同じベクトル
2-element Vector{Vector{Float64}}:
 [42.0, 0.0]
 [42.0, 0.0]

fill!(A, x)

配列 A を値 x で埋めます。x がオブジェクト参照の場合、すべての要素は同じオブジェクトを参照します。fill!(A, Foo()) は 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)])

空の AbstractDict コンテナを作成し、index_type 型のインデックスと value_type 型の値を受け入れることができます。第二および第三の引数はオプションで、入力の keytype と valtype にそれぞれデフォルト設定されています。（2つの型のうち1つだけが指定された場合、それは value_type と見なされ、index_type は keytype(a) にデフォルト設定されます）。

カスタム AbstractDict サブタイプは、与えられたインデックスおよび値の型に最適な辞書型を返すために、3引数のシグネチャに特化することができます。デフォルトは空の Dict を返すことです。

empty(v::AbstractVector, [eltype])

vに似た空のベクトルを作成し、オプションでeltypeを変更します。

参照: empty!, isempty, isassigned.

例

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}

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

出力行列は、入力と同じ位置にゼロを持ちますが、非ゼロの位置には初期化されていない値を持ちます。

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次元の論理配列を作成します。

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

指定された要素型とサイズを持つ初期化されていない可変配列を、指定されたソース配列に基づいて作成します。第二引数と第三引数はどちらもオプションで、指定された配列の 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.

ndims(A::AbstractArray) -> Integer

Aの次元数を返します。

関連: size, axes。

例

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

julia> ndims(A)
3

size(A::AbstractArray, [dim])

Aの次元を含むタプルを返します。オプションで、特定の次元を指定することで、その次元の長さを取得できます。

sizeは非標準インデックスを持つ配列に対して定義されていない場合があるため、その場合はaxesが役立つかもしれません。カスタムインデックスを持つ配列に関するマニュアルの章を参照してください。arrays with custom indices。

関連: length, ndims, eachindex, sizeof。

例

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

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

julia> size(A, 2)
3

axes(A)

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

参照: size, keys, eachindex.

例

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

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

axes(A, d)

配列 A の次元 d に沿った有効なインデックスの範囲を返します。

他にも size や、カスタムインデックスを持つ配列に関するマニュアルの章を参照してください。

例

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

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

julia> axes(A, 4) == 1:1  # ndims(A) より大きいすべての次元 d はサイズ 1
true

使用上の注意

各インデックスは AbstractUnitRange{<:Integer} でなければなりませんが、同時にカスタムインデックスを使用する型であることもできます。例えば、サブセットが必要な場合は、begin/end や firstindex/lastindex のような一般化されたインデクシング構文を使用してください：

ix = axes(v, 1)
ix[2:end]          # 例えばベクターには機能しますが、一般には失敗する可能性があります
ix[(begin+1):end]  # 一般化されたインデックスには機能します

length(A::AbstractArray)

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

例

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

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

keys(a::AbstractArray)

aの形状に配置されたすべての有効なインデックスを記述する効率的な配列を返します。

1次元配列（ベクトル）のキーは整数ですが、他のすべてのN次元配列はCartesianIndexを使用してその位置を記述します。特に、特別な配列タイプLinearIndicesとCartesianIndicesは、それぞれこれらの整数とCartesianIndexの配列を効率的に表現するために使用されます。

配列のkeysが最も効率的なインデックスタイプでない場合があることに注意してください。最大のパフォーマンスを得るには、代わりにeachindexを使用してください。

例

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

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

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

AbstractArray A の各インデックスを効率的に訪問するためのイテラブルオブジェクトを作成します。高速な線形インデックスを選択した配列タイプ（Array など）では、これは単に 1:length(A) の範囲になります（1ベースのインデックスを使用している場合）。高速な線形インデックスを選択していない配列タイプでは、通常、すべての次元に対して指定されたインデックスで配列に効率的にインデックスを付けるための特別なカートesian範囲が返されます。

一般に eachindex は任意のイテラブル（文字列や辞書を含む）を受け入れ、任意のインデックスタイプ（例えば、不均等に間隔を空けたインデックスや非整数インデックス）をサポートするイテレータオブジェクトを返します。

A が AbstractArray の場合、eachindex によって返されるインデックスのスタイルを明示的に指定することが可能で、最初の引数として IndexStyle 型の値を渡すことで行います（通常は線形インデックスが必要な場合は IndexLinear()、カートesian範囲が必要な場合は IndexCartesian()）。

複数の AbstractArray 引数を供給すると、eachindex はすべての引数に対して高速なイテラブルオブジェクトを作成します（通常はすべての入力が高速な線形インデックスを持つ場合は UnitRange、そうでない場合は CartesianIndices）。配列のサイズや次元が異なる場合、DimensionMismatch 例外がスローされます。

インデックスと値を一緒に反復するために pairs(A) を、1次元に沿った有効なインデックスのために axes(A, 2) を参照してください。

例

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

julia> for i in eachindex(A) # 線形インデックス
           println("A[", i, "] == ", A[i])
       end
A[1] == 10
A[2] == 30
A[3] == 20
A[4] == 40

julia> for i in eachindex(view(A, 1:2, 1:1)) # カートesianインデックス
           println(i)
       end
CartesianIndex(1, 1)
CartesianIndex(2, 1)

IndexStyle(A)
IndexStyle(typeof(A))

IndexStyleは配列Aの「ネイティブインデックススタイル」を指定します。新しいAbstractArray型を定義する際には、線形インデックス（IndexLinearを使用）または直交インデックスのいずれかを実装することを選択できます。線形インデックスのみを実装することに決めた場合は、この特性を配列型に設定する必要があります：

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

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

Juliaの内部インデックス機構は、すべてのインデックス操作を自動的に（かつ目に見えない形で）好ましいスタイルに再計算します。これにより、ユーザーは明示的なメソッドが提供されていない場合でも、任意のインデックススタイルを使用して配列の要素にアクセスできます。

AbstractArrayの両方のインデックススタイルを定義した場合、この特性は最もパフォーマンスの良いインデックススタイルを選択するために使用できます。一部のメソッドはその入力に対してこの特性をチェックし、最も効率的なアクセスパターンに応じて異なるアルゴリズムにディスパッチします。特に、eachindexはこの特性の設定に依存するイテレータを作成します。

IndexLinear()

IndexStyle のサブタイプで、1つの線形インデックスで最適にインデックス付けされる配列を説明するために使用されます。

線形インデックススタイルは、配列内の位置を記述するために1つの整数インデックスを使用します（多次元配列であっても）および列優先順序を使用して要素に効率的にアクセスします。これは、IndexLinear の配列から eachindex を要求すると、たとえそれが多次元であっても、単純な1次元範囲が返されることを意味します。

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

IndexCartesian も参照してください。

IndexCartesian()

IndexStyle のサブタイプで、Cartesianインデックスによって最適にインデックス付けされる配列を説明するために使用されます。これは新しいカスタム AbstractArray サブタイプのデフォルトです。

Cartesianインデックススタイルは、複数の整数インデックスを使用して多次元配列内の位置を説明し、各次元に対して正確に1つのインデックスを持ちます。これは、IndexCartesian の配列から eachindex を要求すると、CartesianIndices の範囲が返されることを意味します。

IndexStyle を IndexCartesian として報告する N 次元のカスタム配列は、正確に N の Int インデックスでインデックス付け（およびインデックス付き代入）を実装する必要があります。他のすべてのインデックス式 — 線形インデックスを含む — は、同等のCartesian位置に再計算されます。たとえば、A がCartesianインデックスを持つ 2×3 のカスタム行列であり、A[5] を参照した場合、これは同等のCartesianインデックスに再計算され、A[1, 3] が呼び出されます。なぜなら、5 = 1 + 2*(3 - 1) だからです。

線形インデックスからCartesianインデックスを計算するのは、逆に行くよりもはるかに高コストです。前者の操作は割り算を必要とし — 非常にコストのかかる操作 — 後者は乗算と加算のみを使用し、基本的に無料です。この非対称性は、IndexCartesian 配列で線形インデックスを使用することが、IndexLinear 配列でCartesianインデックスを使用することよりもはるかに高コストであることを意味します。

IndexLinear も参照してください。

conj!(A)

配列をその複素共役にインプレースで変換します。

関連項目 conj。

例

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

julia> conj!(A);

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

stride(A, k::Integer)

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

関連情報: strides.

例

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

julia> stride(A,2)
3

julia> stride(A,3)
12

strides(A)

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

関連: stride.

例

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

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

broadcast(f, As...)

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

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

結果のコンテナ型は、以下のルールによって決定されます：

• すべての引数がスカラーまたはゼロ次元配列である場合、アンラップされたスカラーを返します。
• 1つ以上の引数がタプルであり、他のすべてがスカラーまたはゼロ次元配列である場合、タプルを返します。
• その他の引数の組み合わせはデフォルトで Array を返しますが、カスタムコンテナ型は引数として現れたときに結果をカスタマイズするための独自の実装および昇格のようなルールを定義できます。
• 要素型は collect と同様の方法で決定されます。

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

例

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

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

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

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

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

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

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

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

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

broadcastと同様ですが、broadcast(f, As...)の結果をdest配列に格納します。destは結果を格納するためだけに使用され、Asにリストされていない限り、fに引数を供給することはありません。例えば、broadcast!(f, A, A, B)はA[:] = broadcast(f, A, B)を実行します。

例

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

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

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

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

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

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

@. expr

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

expr内の特定の関数呼び出しに対してドットを追加したくない場合は、$でそれらの関数呼び出しをスパイスします。例えば、@. sqrt(abs($sort(x)))はsqrt.(abs.(sort(x)))と同等です（sortにはドットがありません）。

（@.は@__dot__への呼び出しと同等です。）

例

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

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

BroadcastFunction{F} <: Function

演算子の「ドット」バージョンを表し、演算子をその引数に対してブロードキャストします。したがって、BroadcastFunction(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

BroadcastStyleは抽象型であり、ブロードキャスト時のオブジェクトの動作を決定するために使用されるトレイト関数です。BroadcastStyle(typeof(x))はxに関連付けられたスタイルを返します。型のブロードキャスト動作をカスタマイズするには、型/メソッドペアを定義することでスタイルを宣言できます。

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

その後、Broadcasted{MyContainerStyle}に対して動作するメソッド（少なくともsimilar）を書く必要があります。また、利用できるいくつかの事前定義されたBroadcastStyleのサブタイプもあります。詳細については、Interfaces chapterを参照してください。

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 も参照してください。

Broadcast.ArrayStyle{MyArrayType}() は、ブロードキャスト用にオブジェクトが配列として振る舞うことを示す BroadcastStyle です。これは、特定の AbstractArray コンテナタイプのための Broadcast.AbstractArrayStyle を構築するための簡単な方法を提供します。この方法で作成されたブロードキャストスタイルは、次元の追跡を失います。もしあなたのタイプにとって次元の追跡が重要であれば、独自のカスタム Broadcast.AbstractArrayStyle を作成するべきです。

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

Broadcast.broadcastable(x)

x または x のようなオブジェクトを返します。これにより axes、インデックス付けをサポートし、その型が ndims をサポートします。

x が反復をサポートする場合、返される値は collect(x) と同じ axes とインデックス付けの動作を持つべきです。

x が AbstractArray ではないが、axes、インデックス付けをサポートし、その型が ndims をサポートする場合、broadcastable(::typeof(x)) は単に自分自身を返すように実装されるかもしれません。さらに、x が独自の BroadcastStyle を定義している場合、カスタムスタイルに効果を持たせるためには broadcastable メソッドを自分自身を返すように定義しなければなりません。

例

julia> Broadcast.broadcastable([1,2,3]) # 配列はすでに axes とインデックス付けをサポートしているため、`identity` のよう
3-element Vector{Int64}:
 1
 2
 3

julia> Broadcast.broadcastable(Int) # 型は axes、インデックス付け、または反復をサポートしないが、スカラーとして一般的に使用される
Base.RefValue{Type{Int64}}(Int64)

julia> Broadcast.broadcastable("hello") # 文字列は反復の一致の慣例を破り、代わりにスカラーのように振る舞う
Base.RefValue{String}("hello")

combine_axes(As...) -> Tuple

As内のすべての値に対してブロードキャストを行うための結果の軸を決定します。

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

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

combine_styles(cs...) -> BroadcastStyle

任意の数の値引数に対して使用する BroadcastStyle を決定します。各引数のスタイルを取得するために BroadcastStyle を使用し、スタイルを組み合わせるために result_style を使用します。

例

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

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

1つまたは2つのBroadcastStyleを受け取り、BroadcastStyleを使用して共通のBroadcastStyleを決定します。

例

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

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

getindex(A, inds...)

インデックス inds によって選択された配列 A のサブセットを返します。

各インデックスは、Integer、CartesianIndex、range、またはサポートされているインデックスの配列など、任意のサポートされているインデックスタイプである可能性があります。特定の次元に沿ってすべての要素を選択するために、: を使用することができ、対応するインデックスが true である要素をフィルタリングするために、ブール配列（例：Array{Bool} または BitArray）を使用することができます。

inds が複数の要素を選択する場合、この関数は新しく割り当てられた配列を返します。コピーを作成せずに複数の要素にインデックスを付けるには、代わりに view を使用してください。

詳細については、配列インデックスに関するマニュアルセクションを参照してください。

例

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

julia> getindex(A, 1)
1

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

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

julia> getindex(A, 2, 1)
3

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

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

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

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

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

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

例

julia> A = zeros(2,2);

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

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

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

nextind(A, i)

iの後のA内のインデックスを返します。返されるインデックスは、整数iに対してしばしばi + 1と同等です。この関数は、汎用コードに役立ちます。

関連情報: prevind.

例

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

julia> nextind(x, 1) # 有効な結果
2

julia> nextind(x, 4) # 無効な結果
5

julia> nextind(x, CartesianIndex(1, 1)) # 有効な結果
CartesianIndex(2, 1)

julia> nextind(x, CartesianIndex(2, 2)) # 無効な結果
CartesianIndex(1, 3)

prevind(A, i)

Aのiの前のインデックスを返します。返されるインデックスは、整数iの場合、しばしばi - 1に相当します。この関数は、汎用コードに役立ちます。

関連情報: nextind.

例

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

julia> prevind(x, 4) # 有効な結果
3

julia> prevind(x, 1) # 無効な結果
0

julia> prevind(x, CartesianIndex(2, 2)) # 有効な結果
CartesianIndex(1, 2)

julia> prevind(x, CartesianIndex(1, 1)) # 無効な結果
CartesianIndex(2, 0)

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

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

例

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)

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

copy!(dst, src) -> dst

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

関連情報としてcopyto!も参照してください。

isassigned(array, i) -> Bool

与えられた配列にインデックス i に関連付けられた値があるかどうかをテストします。インデックスが範囲外であるか、未定義の参照を持つ場合は false を返します。

例

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 によって内部ベクター型 (Base.Slice) に変換され、インデックスのコレクションを表現します。

Colon のシングルトンインスタンスは、範囲を構築するために使用される関数でもあります。詳細は : を参照してください。

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

多次元インデックス I を作成します。これは多次元配列 A のインデックス付けに使用できます。特に、A[I] は A[i,j,k...] と同等です。整数と CartesianIndex インデックスを自由に混ぜることができます。例えば、A[Ipre, i, Ipost]（ここで Ipre と Ipost は CartesianIndex インデックスで、i は Int）は、任意の次元の配列の単一の次元に沿って動作するアルゴリズムを書く際に便利な表現です。

CartesianIndex は、eachindex によって生成されることがあり、明示的に CartesianIndices を使用して反復する際には常に生成されます。

I::CartesianIndex は broadcast のための「スカラー」（コンテナではない）として扱われます。CartesianIndex のコンポーネントを反復するには、Tuple(I) を使用してタプルに変換します。

例

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

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

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

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

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

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

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

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> foreach(println, CartesianIndices((2, 2, 2)))
CartesianIndex(1, 1, 1)
CartesianIndex(2, 1, 1)
CartesianIndex(1, 2, 1)
CartesianIndex(2, 2, 1)
CartesianIndex(1, 1, 2)
CartesianIndex(2, 1, 2)
CartesianIndex(1, 2, 2)
CartesianIndex(2, 2, 2)

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

線形インデックスとカーテシアンインデックスの変換

線形インデックスからカーテシアンインデックスへの変換は、CartesianIndices が AbstractArray であり、線形にインデックスできるという事実を利用します。

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

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

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

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

ブロードキャスティング

CartesianIndices は、CartesianIndex とのブロードキャスティング演算（+ と -）をサポートしています。

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

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

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

カーテシアンから線形インデックスへの変換については、LinearIndices を参照してください。

Dims{N}

N の Int の NTuple で、AbstractArray の次元を表すために使用されます。

LinearIndices(A::AbstractArray)

同じ形状とaxesを持つLinearIndices配列を返し、Aの各エントリの線形インデックスを保持します。この配列を直交インデックスでインデックス付けすることで、線形インデックスにマッピングできます。

従来のインデックス付け（インデックスは1から始まる）を持つ配列や任意の多次元配列の場合、線形インデックスは1からlength(A)までの範囲になります。しかし、AbstractVectorの場合、線形インデックスはaxes(A, 1)であり、したがって従来でないインデックス付けを持つベクトルでは1から始まりません。

この関数を呼び出すことは、線形インデックスを利用するアルゴリズムを書く「安全な」方法です。

例

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

julia> b = LinearIndices(A);

julia> extrema(b)
(1, 210)

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

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

例

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

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

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 に伝播することが保証されているわけではありません。

例

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

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

julia> to_indices(A, (1,1,2,20)) # 境界チェックなし
(1, 1, 2, 20)

julia> to_indices(A, (CartesianIndex((1,)), 2, CartesianIndex((3,4)))) # エキゾチックなインデックス
(1, 2, 3, 4)

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

julia> to_indices(A, (1,2)) # 形状チェックなし
(1, 2)

checkbounds(A, I...)

指定されたインデックス I が与えられた配列 A の範囲内でない場合、エラーをスローします。

checkbounds(Bool, A, I...)

指定されたインデックス I が与えられた配列 A の範囲内にある場合は true を返します。AbstractArray のサブタイプは、カスタムの範囲チェック動作を提供する必要がある場合、このメソッドを特化すべきですが、多くの場合、A のインデックスと checkindex に依存することができます。

また、checkindex も参照してください。

例

julia> A = rand(3, 3);

julia> checkbounds(Bool, A, 2)
true

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

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

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

checkindex(Bool, inds::AbstractUnitRange, index)

与えられた index が inds の範囲内にある場合は true を返します。すべての配列のインデックスとして動作したいカスタム型は、このメソッドを拡張して特化した境界チェックの実装を提供できます。

checkbounds も参照してください。

例

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

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

elsize(type)

与えられた type 内に格納されている eltype の連続する要素間のメモリストライドをバイト単位で計算します。配列要素が均一な線形ストライドで密に格納されている場合です。

例

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

require_one_based_indexing(A::AbstractArray)
require_one_based_indexing(A,B...)

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

has_offset_axes(A)
has_offset_axes(A, B, ...)

Aのインデックスが任意の軸に沿って1以外の値で始まる場合はtrueを返します。複数の引数が渡された場合、has_offset_axes(A) || has_offset_axes(B) || ...と同等です。

関連情報はrequire_one_based_indexingを参照してください。

view(A, inds...)

getindexと同様ですが、指定されたインデックスまたはインデックスの集合indsに対して親配列Aを遅延参照する軽量配列を返します。要素を即座に抽出したり、コピーされた部分集合を構築するのではありません。返された値（しばしばSubArray）に対してgetindexまたはsetindex!を呼び出すと、親配列にアクセスまたは変更するためのインデックスがその場で計算されます。viewが呼び出された後に親配列の形状が変更されると、動作は未定義になります。なぜなら、親配列に対する境界チェックがないからです。例えば、セグメンテーションフォルトを引き起こす可能性があります。

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

例

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 # bを変更したにもかかわらずAが変更されたことに注意
2×2 Matrix{Int64}:
 0  2
 0  4

julia> view(2:5, 2:3) # 型が不変であるため範囲を返す
3:4

@view A[inds...]

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

これは単一のインデックス式に直接適用でき、特に A[begin, 2:end-1] のような特別な begin または end インデックス構文を含む式に役立ちます（これらは通常の view 関数ではサポートされていません）。

@view は通常の代入のターゲットとして使用することはできません（例： @view(A[1, 2:end]) = ...）、また、装飾されていない インデックス代入 (A[1, 2:end] = ...) やブロードキャストされたインデックス代入 (A[1, 2:end] .= ...) はコピーを作成しません。しかし、@view(A[1, 2:end]) .+= 1 のようなブロードキャストされた代入を更新するためには便利です。これは @view(A[1, 2:end]) .= @view(A[1, 2:end]) + 1 の簡単な構文であり、右辺のインデックス式は @view がなければコピーを作成します。

非スカラーインデックスに対してビューを使用するためにコードの全ブロックを切り替えるには、@views も参照してください。

例

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

与えられた式（begin/end ブロック、ループ、関数などの可能性があります）内のすべての配列スライス操作をビューを返すように変換します。スカラーインデックス、非配列型、および明示的な getindex 呼び出し（array[...] とは対照的に）は影響を受けません。

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

例

julia> A = zeros(3, 3);

julia> @views for row in 1:3
           b = A[row, :] # b はコピーではなくビューです
           b .= row      # 各要素を行インデックスに割り当てる
       end

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

parent(A)

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

例

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

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

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

parentindices(A)

Aに対応するparentのインデックスを返します。

例

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

selectdim(A, d::Integer, i)

次元 d のインデックスが i に等しい A のすべてのデータのビューを返します。

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

参照: eachslice.

例

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

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

julia> selectdim(A, 2, 3:4)
2×2 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)の場合、次元数は変わりません。

例

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

julia> reinterpret(reshape, Complex{Int}, A)    # 結果はベクトルです
2-element reinterpret(reshape, Complex{Int64}, ::Matrix{Int64}) with eltype Complex{Int64}:
 1 + 3im
 2 + 4im

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

julia> reinterpret(reshape, Int, a)             # 結果は行列です
3×2 reinterpret(reshape, Int64, ::Vector{Tuple{Int64, Int64, Int64}}) with eltype Int64:
 1  4
 2  5
 3  6

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}.

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)

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

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

新しい次元は、引数のリストまたは形状タプルとして指定できます。最大1つの次元は:で指定でき、その場合はその長さが指定されたすべての次元との積が元の配列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 の逆; dims のすべての次元に新しい単一次元を持つ配列を返します。

繰り返しの次元は禁じられており、dims の最大エントリは ndims(A) + length(dims) 以下でなければなりません。

結果は A と同じ基礎データを共有し、したがって結果は A が可変である場合にのみ可変であり、一方の要素を設定すると他方の値が変更されます。

関連項目: dropdims, reshape, vec.

例

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

dropdims(A; dims)

Aと同じデータを持つ配列を返しますが、dimsで指定された次元が削除されます。size(A,d)は、dims内のすべてのdに対して1でなければならず、繰り返しの次元や1:ndims(A)の範囲外の数は許可されていません。

結果はAと同じ基礎データを共有しており、そのため結果はAが可変である場合にのみ可変であり、一方の要素を設定すると他方の値が変更されます。

参照: reshape, vec.

例

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

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

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

vec(a::AbstractArray) -> AbstractVector

配列 a を一次元の列ベクトルとして再形成します。a がすでに AbstractVector の場合は a を返します。結果の配列は a と同じ基礎データを共有するため、a が可変である場合にのみ可変であり、その場合、一方を変更するともう一方も変更されます。

例

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

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

julia> vec(1:3)
1:3

他にも reshape, dropdims を参照してください。

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

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

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

cat(A...; dims)

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

次元 d が 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) も受け入れます。

例

異なる次元で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

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)  # hcat と同じ
2×6×1 Array{Float64, 3}:
[:, :, 1] =
 1.0  2.0  3.14159  10.0  10.0  10.0
 3.0  4.0  3.14159  10.0  10.0  10.0

ブロック対角行列を構築します：

julia> cat(true, trues(2,2), trues(4)', dims=(1,2))  # ブロック対角
4×7 Matrix{Bool}:
 1  0  0  0  0  0  0
 0  1  1  0  0  0  0
 0  1  1  0  0  0  0
 0  0  0  1  1  1  1

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

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(A...)

配列または数値を垂直に連結します。cat(@ref)(A...; dims=1)と同等で、構文[a; b; c]とも同じです。

大きな配列のベクトルを連結するには、reduce(vcat, A)がA isa AbstractVector{<:AbstractVecOrMat}の場合に効率的な方法を呼び出し、ペアワイズで処理するのではありません。

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

例

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

julia> v == vcat(1, 2, [3,4])  # 数値を受け入れます
true

julia> v == [1; 2; [3,4]]  # 同じ操作のための構文
true

julia> summary(ComplexF64[1; 2; [3,4]])  # 要素型を指定するための構文
"4-element Vector{ComplexF64}"

julia> vcat(range(1, 2, length=3))  # 遅延範囲を収集します
3-element Vector{Float64}:
 1.0
 1.5
 2.0

julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9])  # 行ベクトルと行列
(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)  # vcat(vs...)よりも効率的です
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

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

hcat(A...)

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

大きな配列のベクトルに対して、reduce(hcat, A)はA isa AbstractVector{<:AbstractVecOrMat}の場合に効率的なメソッドを呼び出します。ベクトルのベクトルに対しては、これをstack(@ref)(A)と書くこともできます。

他にもvcat、hvcatがあります。

例

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

julia> hcat(1, 2, [30 40], [5, 6, 7]')  # 数値を受け入れます
1×7 Matrix{Int64}:
 1  2  30  40  5  6  7

julia> ans == [1 2 [30 40] [5, 6, 7]']  # 同じ操作の構文
true

julia> Float32[1 2 [30 40] [5, 6, 7]']  # 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)  # hcat(ms...)よりも効率的
2×6 Matrix{Float64}:
 0.0  0.0  1.0  2.0  50.0  60.0
 0.0  0.0  3.0  4.0  70.0  80.0

julia> stack(ms) |> summary  # 行列のベクトルに対して不一致
"2×2×3 Array{Float64, 3}"

julia> hcat(Int[], Int[], Int[])  # サイズ(0,)の空のベクトル
0×3 Matrix{Int64}

julia> hcat([1.1, 9.9], Matrix(undef, 2, 0))  # 空の2×0行列でのhcat
2×1 Matrix{Any}:
 1.1
 9.9

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

1回の呼び出しでの水平および垂直の連結。この関数はブロック行列構文のために呼び出されます。最初の引数は、各ブロック行に連結する引数の数を指定します。最初の引数が単一の整数 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(dim::Int, row_first, values...)
hvncat(dims::Tuple{Vararg{Int}}, row_first, values...)
hvncat(shape::Tuple{Vararg{Tuple}}, row_first, values...)

多くの values を1回の呼び出しで水平方向、垂直方向、n次元で連結します。

この関数はブロック行列構文のために呼び出されます。最初の引数は、hvcat に似た連結の形状をタプルのタプルとして指定するか、各軸に沿った要素の数を指定する次元を指定し、出力の次元を決定するために使用されます。dims 形式はよりパフォーマンスが良く、連結操作が各軸に沿った要素の数が同じ場合（例: [a b; c d;;; e f ; g h]）にデフォルトで使用されます。shape 形式は、各軸に沿った要素の数が不均衡な場合（例: [a b ; c]）に使用されます。不均衡な構文は追加の検証オーバーヘッドが必要です。dim 形式は、1次元に沿った連結の最適化です。row_first は values の順序を示します。shape の最初と2番目の要素の意味も row_first に基づいて入れ替えられます。

例

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

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

[:, :, 2] =
 4  5  6

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

[:, :, 2] =
 3
 4

[:, :, 3] =
 5
 6

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

[:, :, 2] =
 3  4

[:, :, 3] =
 5  6

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

[:, :, 2] =
 4  5  6

引数の構築の例

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

[a b ; c ;;; d ;;;;]
 ___   _     _
 2     1     1 = 各行の要素数 (2, 1, 1)
 _______     _
 3           1 = 各列の要素数 (3, 1)
 _____________
 4             = 各3dスライスの要素数 (4,)
 _____________
 4             = 各4dスライスの要素数 (4,)
⇒ shape = ((2, 1, 1), (3, 1), (4,), (4,)) with `row_first` = true

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

コレクションの各要素に関数を適用し、その結果を stack します。または、いくつかのコレクションを zip して一緒に処理します。

関数はすべて同じサイズの配列（またはタプル、または他のイテレータ）を返す必要があります。これらは結果のスライスとなり、dims（指定されている場合）に沿って、またはデフォルトで最後の次元に沿って区切られます。

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

例

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

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

stack(iter; [dims])

同じサイズの配列（または他の反復可能なオブジェクト）のコレクションを、1つ以上の新しい次元に沿って配置することによって、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> vecs = (1:2, [30, 40], Float32[500, 600]);

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

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

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

julia> stack(zip(1:4, 10:99))  # 任意の反復可能なオブジェクトの反復子を受け入れます
2×4 Matrix{Int64}:
  1   2   3   4
 10  11  12  13

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

julia> stack(vecs; dims=1)  # どの cat 関数とも異なり、vecs[1] の 1 番目の軸は結果の 2 番目の軸です
3×2 Matrix{Float32}:
   1.0    2.0
  30.0   40.0
 500.0  600.0

julia> x = rand(3,4);

julia> x == stack(eachcol(x)) == stack(eachrow(x), dims=1)  # eachslice の逆
true

高次元の例:

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

julia> E = eachslice(A, dims=2);  # 行列のベクトル

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

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

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

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

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

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

julia> stack(M) |> size  # すべての次元を保持
(2, 3, 5, 7)

julia> stack(M; dims=1) |> size  # dims=1 に沿った vec(container)
(35, 2, 3)

julia> hvcat(5, M...) |> size  # hvcat は行列を隣接させます
(14, 15)

vect(X...)

引数の promote_typeof から計算された要素型を持つ Vector を作成し、引数リストを含みます。

例

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

circshift(A, shifts)

データ A を円形にシフト、すなわち回転させます。第二引数は、各次元でのシフト量を指定するタプルまたはベクトル、または最初の次元のみをシフトする整数です。

生成されたコードは、シフト量がコンパイル時に知られている場合、すなわちコンパイル時定数であるときに最も効率的です。

参照: circshift!, circcopy!, bitrotate, <<.

例

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

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

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

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

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

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

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)

circshift!(dest, src, shifts)

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

関連情報はcircshiftを参照してください。

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

ベクトル a のデータを shift ポジションだけ円環的にシフトまたは回転します。

例

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をdestにコピーし、各次元をその長さでモジュロインデックスします。srcとdestは同じサイズでなければなりませんが、インデックスにオフセットを持つことができます。オフセットがある場合、(円形の)ラップアラウンドが発生します。配列が重複するインデックスを持つ場合、重複の領域ではdestはsrcと一致します。

参照: circshift.

例

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

findall(A)

ベクトル I を返し、A の true インデックスまたはキーを含みます。A にそのような要素がない場合は、空の配列を返します。他の種類の値を検索するには、最初の引数として述語を渡します。

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

他にも: findfirst, searchsorted.

例

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

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

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

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

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

findall(f::Function, A)

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

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

例

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

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

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

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

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

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

findfirst(A)

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

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

他にも: findall, findnext, findlast, searchsortedfirst.

例

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

julia> findfirst(A)
3

julia> findfirst(falses(3)) # 何も返さないが、REPLには表示されない

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

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

findfirst(predicate::Function, A)

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

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

例

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

julia> findfirst(iseven, A)
2

julia> findfirst(x -> x>10, A) # nothing を返しますが、REPL には表示されません

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

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

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

findlast(A)

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

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

他にも: findfirst, findprev, findallがあります。

例

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

julia> findlast(A)
3

julia> A = falses(2,2);

julia> findlast(A) # 何も返さないが、REPLには表示されない

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

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

findlast(predicate::Function, A)

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

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

例

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

julia> findlast(isodd, A)
3

julia> findlast(x -> x > 5, A) # nothingを返しますが、REPLには表示されません

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

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

findnext(A, i)

Aのtrue要素のi以降の次のインデックスを見つけるか、見つからなければnothingを返します。

インデックスはkeys(A)およびpairs(A)によって返されるものと同じ型です。

例

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

julia> findnext(A, 1)
3

julia> findnext(A, 4) # nothingを返しますが、REPLには表示されません

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

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

findnext(predicate::Function, A, i)

predicateがtrueを返すAの要素のi以降の次のインデックスを見つけるか、見つからなければnothingを返します。これは、getindex、keys(A)、およびnextindをサポートする配列、文字列、およびほとんどの他のコレクションで機能します。

インデックスは、keys(A)およびpairs(A)によって返されるものと同じ型です。

例

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

julia> findnext(isodd, A, 1)
1

julia> findnext(isodd, A, 2) # nothingを返しますが、REPLには表示されません

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

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

julia> findnext(isspace, "a b c", 3)
4

findprev(A, i)

Aのtrue要素のiの前またはiを含む前のインデックスを見つける。見つからない場合はnothingを返す。

インデックスはkeys(A)およびpairs(A)によって返されるものと同じ型である。

関連: findnext, findfirst, findall。

例

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

julia> findprev(A, 3)
3

julia> findprev(A, 1) # nothingを返すが、REPLには表示されない

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

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

findprev(predicate::Function, A, i)

predicate が true を返す A の要素の、i の前または i を含む前のインデックスを見つけます。見つからない場合は nothing を返します。これは、getindex、keys(A)、および nextind をサポートする配列、文字列、およびほとんどの他のコレクションで機能します。

インデックスは、keys(A) および pairs(A) によって返されるものと同じ型です。

例

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

julia> findprev(isodd, A, 1) # 何も返さないが、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 × length(v) の行行列に変形します。操作が再帰的でないため、transpose とは異なり、特に非数値の値の配列に対して便利です（再帰的な transpose はエラーを引き起こす可能性があります）。

例

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; # p または r を変更すると v も変わります

julia> v # p と r の両方とメモリを共有
4-element Vector{Int64}:
 5
 6
 3
 4

しかし、permutedims は、要素が数値行列であるベクトルに対しては transpose とは異なる結果を生成します：

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

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

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

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

配列 A の次元（軸）を入れ替えます。perm は、置換を指定する ndims(A) の整数のタプルまたはベクターです。

A が 2 次元配列（AbstractMatrix）の場合、perm はデフォルトで (2,1) となり、A の 2 つの軸（行と列）を入れ替えます。これは、操作が再帰的でないため、特に数値以外の値の配列（再帰的な transpose がエラーを引き起こす場合）や線形演算子を表さない 2 次元配列に対して便利です。

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

他にも permutedims!、PermutedDimsArray、transpose、invperm があります。

例

2 次元配列:

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]

多次元配列

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

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

julia> perm = (3, 1, 2); # 最後の次元を最初に置く

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

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

julia> A == permutedims(B, invperm(perm)) # 逆置換
true

B = permutedims(A, perm) の各次元 i に対して、その対応する次元は A の perm[i] になります。これは、等式 size(B, i) == size(A, perm[i]) が成り立つことを意味します。

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

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

julia> B = permutedims(A, perm);

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

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

permutedims!(dest, src, perm)

配列 src の次元を入れ替え、その結果を配列 dest に格納します。perm は ndims(src) の長さを持つ順列を指定するベクターです。事前に割り当てられた配列 dest は size(dest) == size(src)[perm] である必要があり、完全に上書きされます。インプレースの入れ替えはサポートされておらず、src と dest が重複するメモリ領域を持つ場合、予期しない結果が生じる可能性があります。

関連情報は permutedims を参照してください。

PermutedDimsArray(A, perm) -> B

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

参照: permutedims, invperm。

例

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

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

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

julia> B[3,1,2] == A[1,2,3]
true

promote_shape(s1, s2)

2つの配列の形状が互換性があるかを確認し、末尾の単一次元を許可し、より多くの次元を持つ形状を返します。

例

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 の次元 dims に沿って実行します（dims はベクトルの場合はオプションです）。初期値 init はキーワード引数としてオプションで提供できます。出力の精度を制御し（例えば、オーバーフローを避けるために）、パフォーマンスのために事前に割り当てられた出力配列を使用するには、accumulate! も参照してください。

一般的な操作には、cumsum や cumprod のような専門的なバリアントがあります。遅延バージョンについては、Iterators.accumulate を参照してください。

例

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 の次元 dims に沿って行い、結果を B に格納します。ベクトルの場合、dims を指定することはオプションです。キーワード引数 init が指定されている場合、その値が累積の初期値として使用されます。

関連情報としては accumulate、cumsum!、cumprod! を参照してください。

例

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

julia> y = rand(5);

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

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

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

julia> B = similar(A);

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

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

cumprod(itr)

イテレータの累積積。

他にも cumprod!、accumulate、cumsum を参照してください。

例

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)

次元 dim に沿った累積積。パフォーマンスのために事前に割り当てられた出力配列を使用するには、cumprod! も参照してください。また、出力の精度を制御するためにも使用できます（例：オーバーフローを避けるため）。

例

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

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

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

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

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

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

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

cumsum(itr)

イテレータの累積和。

他の関数を適用するには、accumulateを参照してください。

例

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)

次元 dims に沿った累積和。パフォーマンスのため、また出力の精度を制御するため（例えば、オーバーフローを避けるため）に、事前に割り当てられた出力配列を使用するには、cumsum! も参照してください。

例

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

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

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

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

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

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

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

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

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

例

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 のエントリを繰り返すことによって配列を構築します。inner の i 番目の要素は、A の i 番目の次元の個々のエントリを繰り返す回数を指定します。outer の i 番目の要素は、A の i 番目の次元に沿ったスライスを繰り返す回数を指定します。inner または outer が省略された場合、繰り返しは行われません。

例

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

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

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

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

配列 A を各次元で指定された回数 counts だけ繰り返すことによって配列を構築します。

関連情報: fill, Iterators.repeated, Iterators.cycle.

例

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

rot180(A, k)

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

例

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

rot180(A)

行列 A を180度回転させます。

例

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

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

rotl90(A, k)

行列 A を整数 k 回 90 度反時計回りに左回転させます。k が 4 の倍数（ゼロを含む）の場合、これは copy と同等です。

例

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

rotl90(A)

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

例

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

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

rotr90(A, k)

行列 A を整数 k 回、時計回りに90度回転させます。k が4の倍数（ゼロを含む）の場合、これは copy と同等です。

例

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

rotr90(A)

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

例

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

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

mapslices(f, A; dims)

与えられた配列 A の次元を、各スライス A[..., :, ..., :, ...] に関数 f を適用することで変換します。dims の各 d にはコロンが入ります。結果は残りの次元に沿って連結されます。

例えば、dims = [1,2] で A が4次元の場合、f はすべての i と j に対して x = A[:,:,i,j] に対して呼び出され、f(x) は結果 R の中で R[:,:,i,j] になります。

eachcol や eachslice も参照してください。これらは map や stack と一緒に使用されます。

例

julia> A = reshape(1:30,(2,5,3))
2×5×3 reshape(::UnitRange{Int64}, 2, 5, 3) with eltype Int64:
[:, :, 1] =
 1  3  5  7   9
 2  4  6  8  10

[:, :, 2] =
 11  13  15  17  19
 12  14  16  18  20

[:, :, 3] =
 21  23  25  27  29
 22  24  26  28  30

julia> f(x::Matrix) = fill(x[1,1], 1,4);  # 1×4 行列を返す

julia> B = mapslices(f, A, dims=(1,2))
1×4×3 Array{Int64, 3}:
[:, :, 1] =
 1  1  1  1

[:, :, 2] =
 11  11  11  11

[:, :, 3] =
 21  21  21  21

julia> f2(x::AbstractMatrix) = fill(x[1,1], 1,4);

julia> B == stack(f2, eachslice(A, dims=3))
true

julia> g(x) = x[begin] // x[end-1];  # 数値を返す

julia> mapslices(g, A, dims=[1,3])
1×5×1 Array{Rational{Int64}, 3}:
[:, :, 1] =
 1//21  3//23  1//5  7//27  9//29

julia> map(g, eachslice(A, dims=2))
5-element Vector{Rational{Int64}}:
 1//21
 3//23
 1//5
 7//27
 9//29

julia> mapslices(sum, A; dims=(1,3)) == sum(A; dims=(1,3))
true

eachslice(A; dims=2) では、指定された次元はスライス内でコロンがない次元です。これは view(A,:,i,:) ですが、mapslices(f, A; dims=(1,3)) は A[:,i,:] を使用します。関数 f はスライス内の値を変更することができますが、A には影響を与えません。

eachrow(A::AbstractVecOrMat) <: AbstractVector

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

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

他にも eachcol、eachslice、および mapslices を参照してください。

例

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 の列のベクトルである ColumnSlices オブジェクトを作成します。列スライスは A の AbstractVector ビューとして返されます。

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

他にも eachrow、eachslice、および mapslices を参照してください。

例

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)

Slices オブジェクトを作成し、A の次元 dims に対するスライスの配列を返し、A の他の次元からすべてのデータを選択するビューを返します。dims は整数または整数のタプルであることができます。

drop = true（デフォルト）の場合、外側の Slices は内側の次元を削除し、次元の順序は dims の順序に一致します。drop = false の場合、Slices は基になる配列と同じ次元を持ち、内側の次元はサイズ 1 になります。

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

また、eachrow、eachcol、mapslices、および selectdim も参照してください。

例

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

julia> s = eachslice(m, dims=1)
3-element RowSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}}:
 [1, 2, 3]
 [4, 5, 6]
 [7, 8, 9]

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

julia> eachslice(m, dims=1, drop=false)
3×1 Slices{Matrix{Int64}, Tuple{Int64, Colon}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}, 2}:
 [1, 2, 3]
 [4, 5, 6]
 [7, 8, 9]

invperm(v)

vの逆順列を返します。もしB = A[v]であれば、A == B[invperm(v)]です。

関連項目 sortperm, invpermute!, isperm, permutedims.

例

julia> p = (2, 3, 1);

julia> invperm(p)
(3, 1, 2)

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

julia> invperm(v)
4-element Vector{Int64}:
 4
 1
 3
 2

julia> A = ['a','b','c','d'];

julia> B = A[v]
4-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> B[invperm(v)]
4-element Vector{Char}:
 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)

isperm(v) -> Bool

v が有効な置換であれば true を返します。

例

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

permute!(v, p)

ベクトル v を、順列 p に従ってインプレースで並べ替えます。p が順列であることを確認するチェックは行われません。

新しい順列を返すには、v[p] を使用します。これは一般的に permute!(v, p) よりも速いです。u .= @view v[p] を使って事前に割り当てられた出力配列に書き込む方がさらに速いです。（permute! は v をインプレースで上書きしますが、内部的にはどの要素が移動されたかを追跡するためにいくつかの割り当てが必要です。）

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

例

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

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

julia> permute!(A, perm);

julia> A
4-element Vector{Int64}:
 1
 4
 3
 1

invpermute!(v, p)

permute!と同様ですが、与えられた置換の逆が適用されます。

事前に割り当てられた出力配列（例：u = similar(v)）がある場合は、代わりにu[p] = vを使用する方が速いです。(invpermute!は内部でデータのコピーを割り当てます。)

例

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

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

julia> invpermute!(A, perm);

julia> A
4-element Vector{Int64}:
 4
 1
 3
 1

reverse(A; dims=:)

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

例

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

reverseind(v, i)

与えられたインデックス i に対して reverse(v) の中で、v[reverseind(v,i)] == reverse(v)[i] となる v 内の対応するインデックスを返します。 （v に非ASCII文字が含まれる場合、これは非自明な場合があります。）

例

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

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

julia> for i in eachindex(s)
           print(r[reverseind(r, i)])
       end
Julia🚀

reverse!(A; dims=:)

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

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

reverse のインプレースバージョンです。

例

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