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}

N次元の密な配列で、要素の型は T です。

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

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

例

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

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

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

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

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

例

julia> Array{Float64, 1}(UndefInitializer(), 3)
3-element Array{Float64, 1}:
 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 Array{Float64, 1}:
 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)

Vector{T} を長さ m で構築し、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 Array{Float64, 2}:
 2.36365e-314  2.28473e-314    5.0e-324
 2.26704e-314  2.26711e-314  NaN

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

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)

Matrix{T} をサイズ m×n で構築し、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

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

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

固定サイズの DenseVector{T}。

`memoryref(::GenericMemory)`

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

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

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

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

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

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

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

RowSlices{M,AX,S}

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

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

指定されたサイズ dims のすべての要素がゼロの、要素型 T の Array を作成します。詳細は 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の 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(x::Tuple)

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

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(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 を返すことです。

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

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

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

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

与えられた要素型とサイズに基づいて、指定されたソース配列から初期化されていない可変配列を作成します。第二および第三の引数はどちらもオプションで、指定された配列の eltype と size にデフォルト設定されています。次元は、単一のタプル引数または一連の整数引数として指定できます。

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

例えば、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.

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

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次元範囲が返されることを意味します。

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

IndexCartesian も参照してください。

IndexCartesian()

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

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

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

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

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 を配列、タプル、コレクション、Ref および/またはスカラー As に対してブロードキャストします。

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

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

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

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

例

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

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

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

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

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

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

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

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

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

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

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

各インデックスは、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)

Aのiの後のインデックスを返します。返されるインデックスは、整数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!(dst, src) -> dst

srcをdstにインプレースでcopyし、dst内の既存の要素は破棄されます。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)

Aと同じ形状と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(Bool, A, I...)

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

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

例

julia> A = rand(3, 3);

julia> checkbounds(Bool, A, 2)
true

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

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

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

checkbounds(A, I...)

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

checkindex(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

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(::Type{Out}, x::In)

isbits値xのバイナリデータの型解釈をisbits型Outのそれに変更します。Outのサイズ（パディングを無視）は、xの型のサイズと同じでなければなりません。例えば、reinterpret(Float32, UInt32(7))は、UInt32(7)に対応する4バイトをFloat32として解釈します。reinterpret(In, reinterpret(Out, x)) === xであることに注意してください。

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

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

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

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

reinterpret(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(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

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

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

例

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

拡張ヘルプ

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(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])  # 行ベクトルと行列
([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(A...; dims=2)と同等であり、構文[a b c]または[a;; b;; c]とも同じです。

大きな配列のベクトルに対しては、reduce(hcat, A)は、A isa AbstractVector{<:AbstractVecOrMat}の場合に効率的なメソッドを呼び出します。ベクトルのベクトルに対しては、これをstack(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...)

一度の呼び出しでの水平および垂直の連結。この関数はブロック行列構文のために呼び出されます。最初の引数は、各ブロック行に連結する引数の数を指定します。最初の引数が単一の整数 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(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  # vec(container) が dims=1 に沿って
(35, 2, 3)

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

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

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)

配列内のデータを円環的にシフト（回転）します。第二引数は、各次元でのシフト量を示すタプルまたはベクトル、または最初の次元のみをシフトする整数です。

関連項目: 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

circshift!(dest, src, shifts)

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

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

circcopy!(dest, src)

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

参照: circshift.

例

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

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

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

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

findall(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(x -> x >= 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) # 何も返さないが、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の後または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) # 何も返さないが、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(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(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!(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(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(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!(B, A; dims::Integer)

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

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

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

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

配列 A を各次元で指定された回数だけ繰り返して新しい配列を構築します。

関連項目: 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

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(s::AbstractString, r::Integer)

文字列を r 回繰り返します。これは s^r として書くことができます。

関連項目 ^。

例

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

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

文字を r 回繰り返します。これは、c^r を呼び出すことによって同等に達成できます。

例

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

rot180(A)

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

例

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

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

rot180(A, k)

行列 A を 180 度、整数 k 回回転させます。k が偶数の場合、これは 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

rotl90(A)

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

例

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

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

rotl90(A, k)

行列 A を整数 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

rotr90(A)

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

例

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

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

rotr90(A, k)

行列 A を整数 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

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

RowSlices オブジェクトを作成し、行列またはベクトル A の行のベクトルを返します。行スライスは 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

ColumnSlices オブジェクトを作成し、行列またはベクトル A の列のベクトルを返します。列スライスは 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!(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

reverse!(A; dims=:)

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