配列

コンストラクタと型

Core.AbstractArray ──
AbstractArray{T,N}

T 型の要素を持つ N 次元の配列型 (および配列に近い型) を表す上位型です。Array などを部分型に持ちます。マニュアルの AbstractArray インターフェースの節も参照してください。

Base.AbstractVector ──
AbstractVector{T}

T 型の要素を持つ一次元の配列型 (および配列に似た型) を表す上位型です。AbstractArray{T,1} の別名です。

Base.AbstractMatrix ──
AbstractMatrix{T}

T 型の要素を持つ二次元の配列型 (および配列に似た型) を表す上位型です。AbstractArray{T,2} の別名です。

Base.AbstractVecOrMat ── 定数
AbstractVecOrMat{T}

AbstractVector{T}AbstractMatrix{T} からなる型共用体です。

Core.Array ──
Array{T,N} <: AbstractArray{T,N}

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

Core.Array ── メソッド
Array{T}(undef, dims)
Array{T,N}(undef, dims)

T 型の要素を持つ N 次元の Array を未初期化の状態で構築します。NArray{T,N}(undef, dims) とすれば明示的に指定でき、省略すれば dims の長さあるいは個数から決定されます。引数 dims はタプルまたは整数の列であり、各次元の長さに対応します。ランク N が直接与えられるときは、N の値と dims の長さあるいは個数が一致する必要があります。未初期化の値については undef を参照してください。

julia> A = Array{Float64,2}(undef, 2, 3) # N を直接与える
2×3 Array{Float64,2}:
 6.90198e-310  6.90198e-310  6.90198e-310
 6.90198e-310  6.90198e-310  0.0

julia> B = Array{Float64}(undef, 2) # N は他の引数から決まる
2-element Array{Float64,1}:
 1.87103e-320
 0.0
Core.Array ── メソッド
Array{T}(nothing, dims)
Array{T,N}(nothing, dims)

T 型の要素を持つ N 次元の Array を構築し、各要素を nothing で初期化します。要素型 Tnothing を保持できる必要があります。つまり Nothing <: T が要求されます。

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

julia> Array{Union{Nothing, Int}}(nothing, 2, 3)
2×3 Array{Union{Nothing, Int64},2}:
 nothing  nothing  nothing
 nothing  nothing  nothing
Core.Array ── メソッド
Array{T}(missing, dims)
Array{T,N}(missing, dims)

T 型の要素を持つ N 次元の Array を構築し、各要素を missing で初期化します。要素型 Tmissing を保持できる必要があります。つまり Missing <: T が要求されます。

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

julia> Array{Union{Missing, Int}}(missing, 2, 3)
2×3 Array{Union{Missing, Int64},2}:
 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
Core.undef ── 定数
undef

シングルトン型 UndefInitializer のインスタンス UndefInitializer() の別名です。配列の初期化で使われ、コンストラクタを呼び出したコードが未初期化の配列を要求しているという情報を伝えます。

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

T 型の要素を持つ一次元の密配列です。数学におけるベクトルを表すのによく使われます。この型は Array{T,1} の別名です。

Base.Vector ── メソッド
Vector{T}(undef, n)

長さ n の未初期化 Vector{T} を構築します。未初期化の値については undef を参照してください。

julia> Vector{Float64}(undef, 3)
3-element Array{Float64,1}:
 6.90966e-310
 6.90966e-310
 6.90966e-310
Base.Vector ── メソッド
Vector{T}(nothing, m)

長さ mVector{T} を構築し、各要素を nothing で初期化します。要素型 Tnothing を保持できる必要があります。つまり Nothing <: T が要求されます。

julia> Vector{Union{Nothing, String}}(nothing, 2)
2-element Array{Union{Nothing, String},1}:
 nothing
 nothing
Base.Vector ── メソッド
Vector{T}(missing, m)

長さ mVector{T} を構築し、各要素を missing で初期化します。要素型 Tmissing を保持できる必要があります。つまり Missing <: T が要求されます。

julia> Vector{Union{Missing, String}}(missing, 2)
2-element Array{Union{Missing, String},1}:
 missing
 missing
Base.Matrix ──
Matrix{T} <: AbstractMatrix{T}

T 型の要素を持つ二次元密配列です。数学における行列を表すのによく使われます。この型は Array{T,2} の別名です。

Base.Matrix ── メソッド
Matrix{T}(undef, m, n)

サイズ m×n の未初期化 Matrix{T} を構築します。未初期化の値については undef を参照してください。

julia> Matrix{Float64}(undef, 2, 3)
2×3 Array{Float64,2}:
 6.93517e-310  6.93517e-310  6.93517e-310
 6.93517e-310  6.93517e-310  1.29396e-320
Base.Matrix ── メソッド
Matrix{T}(nothing, m, n)

サイズ m×nMatrix{T} を構築し、各要素を nothing で初期化します。要素型 Tnothing を保持できる必要があります。つまり Nothing <: T が要求されます。

julia> Matrix{Union{Nothing, String}}(nothing, 2, 3)
2×3 Array{Union{Nothing, String},2}:
 nothing  nothing  nothing
 nothing  nothing  nothing
Base.Matrix ── メソッド
Matrix{T}(missing, m, n)

サイズ m×nMatrix{T} を構築し、各要素を missing で初期化します。要素型 Tmissing を保持できる必要があります。つまり Missing <: T が要求されます。

julia> Matrix{Union{Missing, String}}(missing, 2, 3)
2×3 Array{Union{Missing, String},2}:
 missing  missing  missing
 missing  missing  missing
Base.VecOrMat ── 定数
VecOrMat{T}

Vector{T}Matrix{T} からなる型共用体です。

Core.DenseArray ──
DenseArray{T, N} <: AbstractArray{T,N}

T 型の要素を持つ N 次元の密配列です。密配列の要素はメモリの連続領域に格納されます。

Base.DenseVector ──
DenseVector{T}

T 型の要素を持つ一次元の DenseArray です。DenseArray{T,1} の別名です。

Base.DenseMatrix ──
DenseMatrix{T}

T 型の要素を持つ二次元の DenseArray です。DenseArray{T,2} の別名です。

Base.DenseVecOrMat ── 定数
DenseVecOrMat{T}

DenseVector{T}DenseMatrix{T} からなる型共用体です。

Base.StridedArray ── 定数
StridedArray{T, N}

有歩長配列インターフェースを実装する組み込みの配列型からなるハードコードされた Union です。T 型の要素と N 個の次元を持ちます。

AStridedArray の部分型のとき、A の要素はメモリに等間隔に並びます。要素の間の間隔は次元ごとに変わっても構いませんが、一つの次元の中で変わっていはいけません。例えば A は一つ目の次元では 2 の歩長を持ち、二つ目の次元では 3 の歩長を持つかもしれません。d 番目の次元に沿って A の要素を進めると、メモリ上では stride(A, d) だけポインタが進みます。有歩長配列が特に重要かつ有用なのは、BLAS のような他の言語で書かれたライブラリにポインタとして直接渡せるためです。

Base.StridedVector ── 定数
StridedVector{T}

T 型の要素を持つ一次元の StridedArray です。

Base.StridedMatrix ── 定数
StridedMatrix{T}

T 型の要素を持つ二次元の StridedArray です。

Base.StridedVecOrMat ── 定数
StridedVecOrMat{T}

T 型の要素を持つ StridedVectorStridedMatrix からなる型共用体です。

Base.getindex ── メソッド
getindex(type[, elements...])

指定された型の一次元配列を構築します。このメソッドは通常 Type[] という構文を使って呼び出されます。要素の値は Type[a,b,c,...] と指定します。

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

julia> getindex(Int8, 1, 2, 3)
3-element Array{Int8,1}:
 1
 2
 3
Base.zeros ── 関数
zeros([T=Float64,] dims::Tuple)
zeros([T=Float64,] dims...)

要素型 T とサイズ dims を持つ、要素が全てゼロの Array を作成します。fillones も参照してください。

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

julia> zeros(Int8, 2, 3)
2×3 Array{Int8,2}:
 0  0  0
 0  0  0
Base.ones ── 関数
ones([T=Float64,] dims::Tuple)
ones([T=Float64,] dims...)

要素型 T とサイズ dims を持つ、要素が全て 1 の Array を作成します。fillzeros も参照してください。

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

julia> ones(ComplexF64, 2, 3)
2×3 Array{Complex{Float64},2}:
 1.0+0.0im  1.0+0.0im  1.0+0.0im
 1.0+0.0im  1.0+0.0im  1.0+0.0im
Base.BitArray ──
BitArray{N} <: AbstractArray{Bool, N}

空間効率に優れる N 次元の真偽値配列です。一つの真偽値に付き一ビットだけを占有します。

BitArray は 8 バイトに 64 個の値を詰めるので、Array{Bool, N} と比較して八倍の空間効率を達成できます。さらに一部の処理は 64 個の値に対して一度に行えます。

デフォルトでは、真偽値の要素を生成するブロードキャスト (例えば .== などのドット付きの比較) で Julia は BitArray を返します。また truesfalses といった関数でも同様です。

情報

要素を詰めて保存する格納形式が使われるので、BitArray の要素に対する少なくとも一つのスレッドが書き込み行う並列アクセスはスレッドセーフではありません。

Base.BitArray ── メソッド
BitArray(undef, dims::Integer...)
BitArray{N}(undef, dims::NTuple{N,Int})

指定された次元を持つ未初期化の BitArray を構築します。振る舞いは Array と同様です。未初期化の値については undef を参照してください。

julia> BitArray(undef, 2, 2)
2×2 BitArray{2}:
 0  0
 0  0

julia> BitArray(undef, (3, 1))
3×1 BitArray{2}:
 0
 0
 0
Base.BitArray ── メソッド
BitArray(itr)

反復可能オブジェクト itr が生成する値を使って BitArray を構築します。配列の形状は itr オブジェクトから推論されます。

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

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

julia> BitArray(x+y == 3 for x = 1:2 for y = 1:3)
6-element BitArray{1}:
 0
 1
 0
 1
 0
 0
Base.trues ── 関数
trues(dims)

全ての値が trueBitArray を作成します。

julia> trues(2,3)
2×3 BitArray{2}:
 1  1  1
 1  1  1
Base.falses ── 関数
falses(dims)

全ての値が falseBitArray を作成します。

julia> falses(2,3)
2×3 BitArray{2}:
 0  0  0
 0  0  0
Base.fill ── 関数
fill(x, dims::Tuple)
fill(x, dims...)

全ての値が x の配列を作成します。例えば fill(1.0, (5,5))Float64 の 5×5 配列を構築し、各要素を 1.0 に初期化して返します。

dims はタプルもしくは引数の列で指定できます。例えば fill(x)x を唯一の要素とするゼロ次元配列を作成します。

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

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

x がオブジェクトの参照なら、fill が返す配列の全ての要素は同じオブジェクトを指します:

julia> A = fill(zeros(2), 2);

julia> A[1][1] = 42; # A[1][1] と A[2][1] が両方とも変更される。

julia> A
2-element Array{Array{Float64,1},1}:
 [42.0, 0.0]
 [42.0, 0.0]
Base.fill! ── 関数
fill!(A, x)

配列 A を値 x で埋めます。x が参照オブジェクトなら、配列の全ての要素が同じオブジェクトを参照するようになります。fill!(A, Foo()) とした場合には、一度だけ Foo() を呼び出した結果が A の各要素に代入されます。

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

julia> fill!(A, 2.)
2×3 Array{Float64,2}:
 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 Array{Array{Int64,1},1}:
 [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 Array{Int64,1}:
 1
 1
 1
Base.similar ── 関数
similar(array, [element_type=eltype(array)], [dims=size(array)])

与えられた配列と同じ要素型とサイズを持つ未初期化の可変配列を作成します。二番目と三番目の引数はどちらも省略可能であり、デフォルトでは第一引数の配列の eltypesize が使われます。dims はタプルもしくは引数の列で指定できます。

AbstractArray の部分型に対して similar メソッドを特殊化するときは、指定された要素型と次元に最も適した配列型を選択できます。similar メソッドを特殊化しないときはデフォルトの Array{element_type}(undef, dims...) が使われます。

例えば similar(1:10, 1, 4) は未初期化の Array{Int,2} を返します。区間は可変ではなく、二次元配列として扱うこともできないからです:

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

これに対して、similar(trues(10,10), 2) は二つの要素を持つ未初期化の BitVector を返します。BitArray は可変であり、一次元配列として扱えるためです:

julia> similar(trues(10,10), 2)
2-element BitArray{1}:
 0
 0

BitArray に格納できるのは Bool 型の要素だけなので、Bool でない要素型を要求すると通常の Array が作成されます:

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

storagetype と同じ種類の可変配列型であって軸を最後の引数 axes に変更したものを、要素が未初期化の状態で作成します。storagetype には型または関数を指定できます。

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

この呼び出しは Array{Int} “のように振る舞う” 配列を作成します (内部で Array{Int} を使う型である可能性もあります)。返り値の配列には A と同じ添え字を使ったアクセスが可能です。A が慣習的な添え字を持つなら、この呼び出しは Array{Int}(undef, size(A)) と等価です。しかし A が非慣習的な添え字を持つなら、返り値の添え字は A のそれと一致します。

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

この呼び出しは一次元の真偽値配列を作成し、その添え字は A の行に対する添え字と一致します。

基礎的な関数

Base.ndims ── 関数
ndims(A::AbstractArray) -> Integer

A の次元数を返します。

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

julia> ndims(A)
3
Base.size ── 関数
size(A::AbstractArray, [dim])

A の各次元の大きさを表すタプルを返します。省略可能な引数 dim を指定すると、dim 番目の次元の長さが返ります。

size は非慣習的な添え字を持つ配列に対しては定義されないことがある点には注意が必要です。そのような場合には axes が利用できます。詳細は開発者向けドキュメントの独自の添え字を持つ配列の章を参照してください。

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

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

julia> size(A, 2)
3
Base.axes ── メソッド
axes(A)

配列 A に対する正当な添え字を表すタプルを返します。

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

julia> axes(A)
(Base.OneTo(5), Base.OneTo(6), Base.OneTo(7))
Base.axes ── メソッド
axes(A, d)

配列 Ad 番目の次元に対する正当な添え字の範囲を返します。

size および開発者向けドキュメントの独自の添え字を持った配列の章も参照してください。

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

julia> axes(A, 2)
Base.OneTo(6)
Base.length ── メソッド
length(A::AbstractArray)

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

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

julia> length([1 2; 3 4])
4
Base.eachindex ── 関数
eachindex(A...)

AbstractArray のインスタンス A の全ての添え字を効率的に生成する反復子オブジェクトを作成します。高速な線形添え字アクセスをサポートする配列型 (例えば Array) に対しては、この関数は単純に 1:length(A) を返します。それ以外の配列型に対しては特殊化された格子添え字の区間が返り、配列の全ての次元が指定された添え字を使った高速なアクセスが可能になります。文字列や辞書といったその他の反復可能オブジェクトに対しては、任意の型の添え字 (等間隔に並んでいない添え字あるいは整数でない添え字) をサポートする反復子オブジェクトが返ります。

eachindexAbstractArray の引数を複数渡すと、全ての配列に対して高速な反復可能オブジェクトが作成されます。具体的には、配列が全て線形添え字を持つなら UnitRange が、そうでないなら CartesianIndices が返ります。配列が同じ次元数やサイズを持つときは DimensionMismatch 例外が送出されます。

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

julia> for i in eachindex(A) # 線形添え字によるアクセス
           println(i)
       end
1
2
3
4

julia> for i in eachindex(view(A, 1:2, 1:1)) # 格子添え字によるアクセス
           println(i)
       end
CartesianIndex(1, 1)
CartesianIndex(2, 1)
Base.IndexStyle ──
IndexStyle(A)
IndexStyle(typeof(A))

配列 A の “ネイティブな” 添え字スタイルを指定します。新しい AbstractArray を作るときは、線形添え字 (IndexLinear) と格子添え字 (IndexCartesian) のどちらを実装するかを選択できます。もし線形添え字だけを実装すると決めた場合には、このトレイトを配列型に対して次のように定義する必要があります:

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

デフォルトで IndexStyle が返す値は IndexCartesian() です。

Julia 内部の添え字アクセス機構は全ての添え字操作で添え字を適切なスタイルへと自動的に (ユーザーに見えない形で) 再計算します。このため新しい配列に特定の添え字スタイルを使ったメソッドが用意されていない場合でも、ユーザーは任意の添え字形式を使ってその配列にアクセスできます。

新しい AbstractArray に対して両方のスタイルの添え字アクセスが定義されるなら、このトレイトには最も高速な添え字スタイルを指定します。一部のメソッドは入力に対するこのトレイトの値を確認し、最も高速なアクセスパターンに応じて異なるアルゴリズムのディスパッチを行います。特に eachindex が返す反復子の型は IndexStyle によって変わります。

Base.IndexLinear ──
IndexLinear()

単一の線形添え字を使うアクセスが最適であることを示すのに使われる IndexStyle の部分型です。

添え字スタイルが IndexLinear の配列では要素の位置が (多次元配列であっても) 単一の整数で表され、要素へ高速にアクセスするために列優先の順序が使われます。これは配列が多次元であっても添え字スタイルが IndexLinear なら、eachindex が単純な一次元区間を返すことを意味します。

IndexStyleIndexLinear と報告する独自の配列で実装が必要なのは、単一の Int を使った添え字アクセス (および添え字代入) のみです。それ以外の添え字 ──多次元なものを含む── は線形添え字に再計算されます。例えば A2×3 のサイズを持つ独自配列で IndexStyleIndexLinear なら、A[1,3] という参照は線形添え字を使った等価なアクセス A[5] に再計算されます (52*1 + 3 = 5 と計算されます)。

IndexCartesian も参照してください。

Base.IndexCartesian ──
IndexCartesian()

格子添え字を使うアクセスが最適であることを示すのに使われる IndexStyle の部分型です。この値は新しい独自の AbstractArray の部分型に対するデフォルト値です。

添え字スタイルが IndexCartesian の多次元配列では要素の位置を表すのに複数の整数が使われます。これは添え字スタイルが IndexCartesian である配列に対する eachindexCartesianIndices の区間を返すことを意味します。

IndexStyleIndexCartesian と報告する N 次元の独自配列では、ちょうど N 個の Int 型からなる添え字を使う添え字アクセス (および添え字代入) の実装が必要です。それ以外の添え字 ──線形添え字を含む── は等価な格子添え字に再計算されます。例えば A2×3 のサイズを持つ独自配列で添え字スタイルが IndexCartesian なら、A[5] という参照は (5 = 2*1 + 3 より) 格子添え字を使った等価なアクセス A[1, 3] に再計算されます。

線形添え字から格子添え字を計算するには、逆方向の計算を行うよりずっと時間がかかります。前者は除算 ──非常にコストがかかる演算── を必要としますが、後者は乗算と加算というコストが事実上ゼロの演算で行えるためです。この非対称性は、IndexCartesian の配列に対して線形添え字を使うと IndexLinear の配列に対して格子添え字を使うよりずっと大きなコストがかかることを意味します。

IndexLinear も参照してください。

Base.conj! ── 関数
conj!(A)

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

conj も参照してください。

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

julia> conj!(A);

julia> A
2×2 Array{Complex{Int64},2}:
 1-1im  2+1im
 2-2im  3-1im
Base.stride ── 関数
stride(A, k::Integer)

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

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

julia> stride(A,2)
3

julia> stride(A,3)
12
Base.strides ── 関数
strides(A)

各次元のメモリ上での歩長を表すタプルを返します。

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

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

ブロードキャストとベクトル化

マニュアルのベクトル化のためのドット構文の節も参照してください。例えば f.(args...) は自動的に broadcast(f, args...) を呼び出します。配列に対して操作を行う「ベクトル化された」バージョンの sin を用意するのではなく、sin.(a) として broadcast を通してベクトル化を行うべきです。

Base.Broadcast.broadcast ── 関数
broadcast(f, As...)

関数 fAs に対してブロードキャストします。As には配列・タプル・コレクション・Ref・スカラーを指定できます。

ブロードキャストは関数 f をコンテナ As の各要素またはスカラー As に適用します。シングルトン次元1や存在しない次元は他の引数と同じ次元まで拡張され (たものとして扱われ) ます。デフォルトでスカラーとみなされるのは特定の型の値だけであり、例えば Number, String, Symbol, Type, Function 型の値、および missing, nothing といったよく使われるシングルトンはスカラーとみなされます。他の全ての引数に対しては添え字によるアクセスあるいは反復が行われます。

返り値のコンテナ型は次の規則に従って構築されます:

  • 全ての引数がスカラーもしくはゼロ次元の配列なら、ラップされていないスカラーを返す。
  • 少なくとも一つの引数がタプルで、タプルでない引数が全てスカラーもしくはゼロ次元の配列なら、タプルを返す。
  • それ以外の引数の組み合わせでは Array を返す。ただし独自のコンテナ型では、個別の実装と昇格に似た規則を定義することでブロードキャストの引数として使われたときの振る舞いを変更できる。

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

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

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

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

julia> parse.(Int, ["1", "2"])
2-element Array{Int64,1}:
 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 Array{Array{Int64,1},1}:
 [1, 1]
 [2, 2]

julia> string.(("one","two","three","four"), ": ", 1:4)
4-element Array{String,1}:
 "one: 1"
 "two: 2"
 "three: 3"
 "four: 4"
broadcast!(f, dest, As...)

基本的に broadcast と同様ですが、broadcast(f, As...) の結果を配列 dest に格納します。dest は結果を格納するためだけに使われるので、As に含まれていない限り destf の引数にならないことに注意してください。例えば 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 Array{Float64,1}:
  1.0
 -2.0

julia> A
2-element Array{Float64,1}:
 1.0
 0.0

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

julia> A
2-element Array{Float64,1}:
  1.0
 -2.0
[email protected]__dot__ ── マクロ
@. 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 Array{Float64,1}:
 3.5244129544236893
 4.727892280477045
 3.4233600241796016

ブロードキャストを独自型に対して拡張する方法については、マニュアルのブロードキャストのカスタマイズの節を参照してください。

BroadcastStyle は抽象型兼トレイト関数であり、ブロードキャストにおけるオブジェクトの振る舞いを指定するのに使われます。BroadcastStyle(typeof(x))x に関連付いたブロードキャストスタイルを返します。ある型のブロードキャストの振る舞いをカスタマイズするには、まず次の型とメソッドの組を定義してください:

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

それから Broadcasted{MyContainerStyle} を利用するメソッドを (最低でも similar を) 書けばカスタマイズが完了します。事前に定義される BroadcastStyle の部分型もいくつかあるので、それを使っても構いません。詳細はマニュアルのインターフェースの章にあります。

Broadcast.AbstractArrayStyle{N} <: BroadcastStyleAbstractArray 型に関連付く任意のスタイルを表す抽象上位型です。パラメータ N は次元を表すので、特定の次元だけをサポートする AbstractArray 型の取り扱いが簡単に行えます:

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

任意の次元をサポートする AbstractArray では、NAny にできます:

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

二つ以上の AbstractArrayStyle の部分型が衝突すると、ブロードキャスト機構はフォールバックして Array を生成することに注意してください。この振る舞いが望ましくないなら、二項の BroadcastStyle 規則を定義して出力の型を制御する必要があるでしょう。

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

Broadcast.ArrayStyle{MyArrayType}() はオブジェクトがブロードキャストにおいて配列のように振る舞うことを示す BroadcastStyle です。ArrayStyle は特定の AbstractArray コンテナ型に対して AbstractArrayStyle を構築する簡単な手段を提供します。ArrayStyle を使って作成するブロードキャストスタイルは次元を追跡できません: 独自の型で次元の追跡が重要なら、独自の AbstractArrayStyle を作成するべきです。

Broadcast.DefaultArrayStyle{N}() はオブジェクトがブロードキャストにおいて N 次元配列と同じように振る舞うことを示す BroadcastStyle です。具体的に言うと、DefaultArrayStyle は特殊化されたスタイルを定義しない任意の AbstractArray で使われます。また broadcast の引数に対するオーバーライドが存在しない場合の出力型は Array となります。broadcast に複数の入力がある場合、DefaultArrayStyle は他の ArrayStyle に必ず “負け” ます。

Broadcast.broadcastable(x)

x または x に似たオブジェクトを返します。返り値は axes と添え字アクセスをサポートし、その型は ndims をサポートします。

x が反復をサポートするなら、broadcastable(x)axes と添え字アクセスにおいて collect(x) と同じ振る舞いをするべきです。

xAbstractArray でなかったとしても、xaxes と添え字アクセスをサポートし、x の型が ndims をサポートするなら、broadcastable(::typeof(x)) の実装は引数をそのまま返しても構いません。また x が独自の BroadcastStyle を定義するときは、そのスタイルに対する broadcastable メソッドを引数をそのまま返すように定義しないと効果がありません。

julia> # 配列は axes と添え字アクセスをサポートするので、identity と同じ振る舞いとなる。
       Broadcast.broadcastable([1,2,3])
3-element Array{Int64,1}:
 1
 2
 3

julia> # 型は axes も添え字アクセスも反復もサポートしないが、
       # ブロードキャストではスカラーとしてよく使われる。
       Broadcast.broadcastable(Int)
Base.RefValue{Type{Int64}}(Int64)

julia> # 文字列は反復をサポートするが、慣習に反してスカラーのように振る舞う。
       Broadcast.broadcastable("hello")
Base.RefValue{String}("hello")
combine_axes(As...) -> Tuple

As に含まれる全ての値に対するブロードキャスト結果が持つ axes を計算します。

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

一つまたは二つの 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}()

添え字アクセスと代入

Base.getindex ── メソッド
getindex(A, inds...)

inds が指定する A の部分を返します。ind に指定できるのは Int, AbstractRange, Vector です。詳細はマニュアルの配列に対する添え字アクセスの節を参照してください。

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

julia> getindex(A, 1)
1

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

julia> getindex(A, 2:4)
3-element Array{Int64,1}:
 3
 2
 4
Base.setindex! ── メソッド
setindex!(A, X, inds...)
A[inds...] = X

配列 X の値を inds が指定する A の部分に格納します。構文 A[inds...] = Xsetindex!(A, X, inds...) と等価です。

julia> A = zeros(2,2);

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

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

julia> A
2×2 Array{Float64,2}:
 10.0  30.0
 20.0  40.0
Base.copyto! ── メソッド
copyto!(dest, Rdest::CartesianIndices, src, Rsrc::CartesianIndices) -> dest

Rsrc が表す src の領域を、区間 Rdest が表す dest の領域にコピーします。二つの領域のサイズは一致する必要があります。

Base.isassigned ── 関数
isassigned(array, i) -> Bool

与えられた配列が添え字 i に値を持つかどうかを判定します。添え字 i が境界外のとき、および添え字 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 Array{Foo,1}:
 #undef
 #undef
 #undef

julia> isassigned(v, 1)
false
Base.Colon ──
Colon()

コロン (:) はオブジェクトや次元全体に対するアクセスを表すために使われます。

コロンに対して直接定義される操作はほとんどありません。ほとんどの場合でコロンは内部で使われるベクトル型 (Base.Slice) に to_indices で変換され、使われる前に添え字の集合を表すようになります。

Colon のシングルトンインスタンスは区間を構築するための関数でもあります: : を参照してください。

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

多次元配列 A の添え字として利用できる多次元の添え字 I を返します。具体的に言うと A[I]A[i,j,k...] と等価です。引数では整数と CartesianIndex を混ぜて構いません: 例えば CartesianIndex である Ipre, IpostInt である i を使った A[Ipre, i, Ipost] という形の式を使うと、任意の次元を持つ配列の特定の次元を処理するアルゴリズムが簡単に書けます。

CartesianIndexeachindex によって生成される場合があります。CartesianIndices を使えば明示的に取得できます。

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:istop, jstart:jstop, ...)) -> R

整数の添え字からなる多次元に渡る長方形の領域 R を定義します。反復で使われることが多く、例えば for I in R ... end とすると ICartesianIndex 型の添え字となり、次のネストされたループと同様の値を取ります:

for j = jstart:jstop
    for i = istart:istop
        I = CartesianIndex(i,j)
        ...
    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)))
2×3 CartesianIndices{2,Tuple{Base.OneTo{Int64},Base.OneTo{Int64}}}:
 CartesianIndex(1, 1)  CartesianIndex(1, 2)  CartesianIndex(1, 3)
 CartesianIndex(2, 1)  CartesianIndex(2, 2)  CartesianIndex(2, 3)

線形添え字から格子添え字への変換

線形添え字を格子添え字に変換するには、CartesianIndicesAbstractArray であり、線形添え字を使って CartesianIndices にアクセスできるという事実を利用して次のようにします:

julia> cartesian = CartesianIndices((1:3, 1:2))
3×2 CartesianIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
 CartesianIndex(1, 1)  CartesianIndex(1, 2)
 CartesianIndex(2, 1)  CartesianIndex(2, 2)
 CartesianIndex(3, 1)  CartesianIndex(3, 2)

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

ブロードキャスト

CartesianIndicesCartesianIndex を使った算術 (+-) のブロードキャストをサポートします。

Julia 1.1

CartesianIndices のブロードキャストは Julia 1.1 以降でサポートされます。

julia> CIs = CartesianIndices((2:3, 5:6))
2×2 CartesianIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
 CartesianIndex(2, 5)  CartesianIndex(2, 6)
 CartesianIndex(3, 5)  CartesianIndex(3, 6)

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

julia> CIs .+ CI
2×2 CartesianIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
 CartesianIndex(5, 9)  CartesianIndex(5, 10)
 CartesianIndex(6, 9)  CartesianIndex(6, 10)

格子添え字から線形添え字への変換については LinearIndices を参照してください。

Base.Dims ──
Dims{N}

N 個の Int からなる NTuple です。AbstractArray の次元を表すのに使われます。

Base.LinearIndices ──
LinearIndices(A::AbstractArray)

A の各要素に対する線形添え字を持った LinearIndices 型の配列を返します。返り値の配列は A と同じ形状と axes を持ちます。格子添え字を使ってこの配列にアクセスすると、その添え字に対応する線形添え字を取得できます。

慣習的な添え字 (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
Base.to_indices ── 関数
to_indices(A, I::Tuple)

タプル I を配列 A に対するアクセスに使える添え字のタプルに変換します。

返り値のタプルの要素は次のいずれかである必要があります:

  • Int
  • 配列 A がサポートするスカラー添え字を要素とする AbstractArray

to_indices は処理方法を知らない添え字型を受け取るとエラーを送出します。

単純な添え字型に対しては、to_indices は各添え字の処理を Base.to_index(A, i) という関数に委譲します。このエクスポートされない内部関数は直接呼ばれることを意図されていませんが、独自の配列型あるいは添え字型に対して Base.to_index を拡張して添え字アクセスの振る舞いを変えることはできます。

より複雑な添え字型 (コロンなど) はアクセスする次元に関する文脈を必要とする可能性があります。こういったケースに対応するために、to_indices(A, I)to_indices(A, axes(A), I) を呼び出し、与えられた添え字のタプルと A の次元の添え字の両方に関して再帰的に反復します。そのため、最終的な処理が Base.to_index で行われることが全ての添え字型に対して保証されているわけではありません。

Base.checkbounds ── 関数
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 の境界内でなければエラーを送出します。

Base.checkindex ── 関数
checkindex(Bool, inds::AbstractUnitRange, index)

indexinds の境界に含まれるなら true を返します。任意の配列に対する添え字として振る舞わせたい独自型があるなら、このメソッドを拡張することで特殊化された境界チェックの実装を提供できます。

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

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

ビュー (SubArrays など)

ビュー (view) は配列のように振る舞うデータ構造 (AbstractArray の部分型) ですが、ビューの内部データは他の配列の一部を参照します。

例えば配列 x に対して v = @view x[1:10] としたとき v は 10 要素の配列のように振る舞いますが、v のデータへのアクセスは x の最初の 10 要素へのアクセスとなります。つまり v[3] = 2 とすれば内部の配列 x への書き込みが起こり、x[3] が変更されます。

Julia で x[1:10] といったスライス操作はデフォルトでコピーを作成しますが、@view x[1:10] とすればビューを作成するようにできます。@views マクロを @views function foo() .... end あるいは @views begin ... end としてコードブロックに対して使えば、ブロックに含まれる全てのスライス操作を全てビューを使ったものに変更できます。なおパフォーマンス Tips でも説明した通り、ビューとコピーのどちらが高速かは場合によって異なります。

Base.view ── 関数
view(A, inds...)

getindex と同様の処理を行いますが、配列 A の添え字で指定された部分のコピーではなく、その部分を指すビューを返します。返される SubArray に対して getindex あるいは setindex! を呼び出すと、その場で親の配列への添え字が計算されます。添え字の計算で境界はチェックされません。

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

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

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

julia> A # b を変更したにもかかわらず A が変更される。
2×2 Array{Int64,2}:
 0  2
 0  4
[email protected] ── マクロ
@view A[inds...]

添え字アクセス式から SubArray を作成します。これは @view A[1,2:end] のような参照式に直接適用するべきであり、@view(A[1,2:end]) = ... のような範囲代入で使うべきではありません。コードブロック全体でスライスをビューに切り替えるには @views を使ってください。

Julia 1.5

添え字アクセスの式で begin を使って最初の添え字を表す機能は Julia 1.5 以降でサポートされます。

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

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

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

julia> A
2×2 Array{Int64,2}:
 0  2
 0  4
[email protected] ── マクロ
@views expression

与えられた式 (begin/end ブロック・ループ・関数など) に含まれる配列のスライス操作をビューを返すように変更します。影響を受けるのは array[...] という形をした式だけで、スカラーの添え字・配列でない型・明示的な getindex の呼び出しは影響を受けません。

情報

@views マクロの影響を受けるのは指定された expression で明示的に使われる array[...] という式だけです。expression で呼び出される関数で使われる配列スライスは影響を受けません。

Julia 1.5

添え字アクセスの式で begin を使って最初の添え字を表す機能は Julia 1.5 以降でサポートされます。

julia> A = zeros(3, 3);

julia> @views for row in 1:3
           b = A[row, :]
           b[:] .= row
       end

julia> A
3×3 Array{Float64,2}:
 1.0  1.0  1.0
 2.0  2.0  2.0
 3.0  3.0  3.0
Base.parent ── 関数
parent(A)

A が内部に持つ “親の” 配列を返します。SubArray, ReshapedArray, LinearAlgebra.Transpose 型のオブジェクトに対しては、view, reshape, transpose でオブジェクトを作るときに渡された引数が親の配列となります。もし入力がラップされたオブジェクトでなければ、入力がそのまま返されます。

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

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

julia> parent(V)
2×2 Array{Int64,2}:
 1  2
 3  4
Base.parentindices ── 関数
parentindices(A)

配列ビュー A に対して、parent(A) における A の添え字を返します。

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

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

julia> parentindices(V)
(1, Base.Slice(Base.OneTo(2)))
Base.selectdim ── 関数
selectdim(A, d::Integer, i)

d 番目の次元に対する添え字が i に等しい A のデータ全体に対するビューを返します。

d 番目に i を入れた view(A,:,:,...,i,:,:,...) と等価です。

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

julia> selectdim(A, 2, 3)
2-element view(::Array{Int64,2}, :, 3) with eltype Int64:
 3
 7
Base.reinterpret ── 関数
reinterpret(type, A)

メモリ領域をどの型として解釈するかを変更した値を返します。配列に対しては、指定された配列 A と同じバイナリデータを持った異なる要素型のビューを構築します。例えば reinterpret(Float32, UInt32(7))UInt32(7) に対応する 8 バイトを Float32 として再解釈します。

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

julia> reinterpret(Float32, UInt32[1 2 3 4 5])
1×5 reinterpret(Float32, ::Array{UInt32,2}):
 1.0f-45  3.0f-45  4.0f-45  6.0f-45  7.0f-45
Base.reshape ── 関数
reshape(A, dims...) -> AbstractArray
reshape(A, dims) -> AbstractArray

A と同じデータを持つ、次元のサイズあるいは次元数を変更した配列を作成します。二つの配列は内部データを共有するので、返り値は A が可変な場合に限って可変となり、そのとき片方のデータを書き換えるともう一方にも変更が伝わります。

新しい次元は引数のリストあるいはタプルとして指定します。最大で一つの次元を : にでき、そうすると元の配列 A の長さと新しい配列の次元の積が等しくなるような値でコロンが置き換わります。サイズ変更の前後で要素数が変わってはいけません。

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

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

julia> reshape(A, 2, :)
2×8 Array{Int64,2}:
 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
Base.dropdims ── 関数
dropdims(A; dims)

配列 A から dims で指定される次元を落とします。dims の要素はユニークな整数で、1:ndims(A) の範囲に収まる必要があります。さらに dims に含まれる任意の i に対して size(A,i)1 でなければなりません。

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

julia> dropdims(a; dims=3)
2×2×1 Array{Int64,3}:
[:, :, 1] =
 1  3
 2  4
Base.vec ── 関数
vec(a::AbstractArray) -> AbstractVector

a を一次元の列ベクトルに変形します。a が最初から AbstractVector なら a を返します。返り値の配列は a と同じ内部データを共有するので、a が可変であるときに限って可変となり、そのときは片方を変更するともう一方も変更されます。

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

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

julia> vec(1:3)
1:3

reshape も参照してください。

連結と置換

Base.cat ── 関数
cat(A...; dims=dims)

反復可能オブジェクト dims が指定する次元に沿って入力の配列を連結します。入力配列は dims に含まれない次元で同じサイズを持っている必要があり、返り値の配列でもその次元のサイズは変わりません。dims に含まれる次元に沿った返り値の配列のサイズは、入力配列のその次元のサイズの和となります。dims が単一の整数なら、異なる配列がその次元に沿って詰めて積み上げられます。

このため dims に複数の次元を持たせると、ブロック対角行列 (および高次元の同じような配列) を作成できます。つまり dims が指定する複数の次元の添え字を同時に大きくしながら入力の配列が出力の配列に代入され、それ以外の場所は全てゼロになるということです。例えば cat(matrices...; dims=(1,2)) とすると、matrices[1], matrices[2], ... というブロックが対角線上に並び、他の部分は全てゼロとなるブロック対角行列が作られます。

Base.vcat ── 関数
vcat(A...)

一番目の次元に沿った連結です。

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

julia> b = [6 7 8 9 10; 11 12 13 14 15]
2×5 Array{Int64,2}:
  6   7   8   9  10
 11  12  13  14  15

julia> vcat(a,b)
3×5 Array{Int64,2}:
  1   2   3   4   5
  6   7   8   9  10
 11  12  13  14  15

julia> c = ([1 2 3], [4 5 6])
([1 2 3], [4 5 6])

julia> vcat(c...)
2×3 Array{Int64,2}:
 1  2  3
 4  5  6
Base.hcat ── 関数
hcat(A...)

二番目の次元に沿った連結です。

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

julia> b = [6 7; 8 9; 10 11; 12 13; 14 15]
5×2 Array{Int64,2}:
  6   7
  8   9
 10  11
 12  13
 14  15

julia> hcat(a,b)
5×3 Array{Int64,2}:
 1   6   7
 2   8   9
 3  10  11
 4  12  13
 5  14  15

julia> c = ([1; 2; 3], [4; 5; 6])
([1, 2, 3], [4, 5, 6])

julia> hcat(c...)
3×2 Array{Int64,2}:
 1  4
 2  5
 3  6

julia> # Array{Any, 2} を作る。"x = []" は Array{Any, 1} となってしまうので使えない。
       x = Matrix(undef, 3, 0)
3×0 Array{Any,2}

julia> hcat(x, [1; 2; 3])
3×1 Array{Any,2}:
 1
 2
 3
Base.hvcat ── 関数
hvcat(rows::Tuple{Vararg{Int}}, values...)

水平方向および垂直方向の連結を一度の呼び出しで行います。この関数はブロック行列を作成する構文で呼び出されます。第一引数には行ごとにいくつの引数を連結するかを指定します。

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 Array{Int64,2}:
 1  2  3
 4  5  6

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

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

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

第一引数が単一の整数 n だと、全ての行は n 個のブロックからなると解釈されます。

Base.vect ── 関数
vect(X...)

引数リストの要素からなる Vector を作成します。要素型は引数から promote_typeof で計算されます。

julia> a = Base.vect(UInt8(1), 2.5, 1//2)
3-element Array{Float64,1}:
 1.0
 2.5
 0.5
Base.circshift ── 関数
circshift(A, shifts)

配列のデータに循環シフト (回転) を適用します。第二引数は各次元のシフト量を表すタプルまたはベクトル、あるいは一つ目の次元のシフト量を表す整数です。

julia> b = 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> circshift(b, (0,2))
4×4 Array{Int64,2}:
  9  13  1  5
 10  14  2  6
 11  15  3  7
 12  16  4  8

julia> circshift(b, (-1,0))
4×4 Array{Int64,2}:
 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 BitArray{1}:
 1
 1
 0
 0
 1

julia> circshift(a, 1)
5-element BitArray{1}:
 1
 1
 1
 0
 0

julia> circshift(a, -1)
5-element BitArray{1}:
 1
 0
 0
 1
 1

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

Base.circshift! ── 関数
circshift!(dest, src, shifts)

配列のデータに循環シフト (回転) を適用し、結果を dest に格納します。shifts は各次元のシフト量を表します。

destsrc と異なる配列である必要があります (片方がもう一方の別名であってはいけません)。

circshift も参照してください。

Base.circcopy! ── 関数
circcopy!(dest, src)

srcdest にコピーします。各次元の添え字は長さでモジュロが取られます。srcdest は同じサイズである必要がありますが、添え字がオフセットを持っていても構いません: オフセットがどんな値であれ、(環状の) ラップアラウンドが起こります。二つの配列の添え字に重複する部分があるなら、その部分では destsrc が一致します。

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
Base.findall ── メソッド
findall(A)

値 (またはバリュー) が true である A の添え字 (またはキー) からなるベクトルを返します。返り値は空配列である可能性もあります。他の種類の値やキーを検索するには、述語関数を第一引数に渡してください。

返り値は keys(A) または pairs(A) が返すオブジェクトの添え字あるいはキーと同じ型を持ちます。

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

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

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

julia> findall(A)
2-element Array{CartesianIndex{2},1}:
 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 Array{Int64,1}:
 1
 3
 4

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

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

julia> findall(!iszero, A)
4-element Array{CartesianIndex{2},1}:
 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 Array{Symbol,1}:
 :A
 :C

Base.findfirst ── メソッド
findfirst(A)

A に含まれる最初の true の添え字あるいはキーを返します。Atrue が含まれなければ nothing を返します。他の種類の値やキーを検索するには、第一引数に述語関数を渡してください。

返り値は keys(A) または pairs(A) が返すオブジェクトの添え字あるいはキーと同じ型を持ちます。

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

julia> findfirst(A)
3

julia> findfirst(falses(3)) # nothing を返すが、REPL には表示されない。

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

julia> findfirst(A)
CartesianIndex(2, 1)
findfirst(predicate::Function, A)

predicatetrue を返す最初の A の要素に対する添え字あるいはキーを返します。条件を満たす要素が無ければ nothing を返します。

返り値は keys(A) または pairs(A) が返すオブジェクトの添え字あるいはキーと同じ型を持ちます。

julia> A = [1, 4, 2, 2]
4-element Array{Int64,1}:
 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 Array{Int64,2}:
 1  4
 2  2

julia> findfirst(iseven, A)
CartesianIndex(2, 1)
Base.findlast ── メソッド
findlast(A)

A に含まれる最後の true の添え字あるいはキーを返します。Atrue が含まれなければ nothing を返します。他の種類の値やキーを検索するには、第一引数に述語関数を渡してください。

返り値は keys(A) または pairs(A) が返すオブジェクトの添え字あるいはキーと同じ型を持ちます。

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

julia> findlast(A)
3

julia> A = falses(2,2);

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

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

julia> findlast(A)
CartesianIndex(2, 1)
findlast(predicate::Function, A)

predicatetrue を返す最後の A の要素に対する添え字あるいはキーを返します。条件を満たす要素が無ければ nothing を返します。

返り値は keys(A) または pairs(A) が返すオブジェクトの添え字あるいはキーと同じ型を持ちます。

julia> A = [1, 2, 3, 4]
4-element Array{Int64,1}:
 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 Array{Int64,2}:
 1  2
 3  4

julia> findlast(isodd, A)
CartesianIndex(2, 1)
Base.findnext ── メソッド
findnext(A, i)

A の添え字 i 以降にある最初の true の添え字を返します。true が見つからなければ nothing を返します。

返り値は keys(A) または pairs(A) が返すオブジェクトの添え字と同じ型を持ちます。

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

julia> findnext(A, 1)
3

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

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

julia> findnext(A, CartesianIndex(1, 1))
CartesianIndex(2, 1)
findnext(predicate::Function, A, i)

A の添え字 i 以降に predicatetrue を返す要素があるかを調べ、もし見つかればその中で一番最初にある要素の添え字を返します。見つからなければ nothing を返します。

返り値は 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)
Base.findprev ── メソッド
findprev(A, i)

A の添え字 i 以前にある一番後ろの true の添え字を返します。true が見つからなければ nothing を返します。

返り値は keys(A) または pairs(A) が返すオブジェクトの添え字と同じ型を持ちます。

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

julia> findprev(A, 3)
3

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

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

julia> findprev(A, CartesianIndex(2, 1))
CartesianIndex(2, 1)
findprev(predicate::Function, A, i)

A の添え字 i 以前に predicatetrue を返す要素があるかを調べ、もし見つかればその中で一番後ろにある要素の添え字を返します。見つからなければ nothing を返します。

返り値は keys(A) または pairs(A) が返すオブジェクトの添え字と同じ型を持ちます。

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

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

julia> findprev(isodd, A, 3)
3

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

julia> findprev(isodd, A, CartesianIndex(1, 2))
CartesianIndex(2, 1)
Base.permutedims ── 関数
permutedims(A::AbstractArray, perm)

配列 A の次元を置換します。perm は置換を指定するベクトルで、ndims(A) と同じ長さを持ちます。

PermutedDimsArray も参照してください。

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> permutedims(A, [3, 2, 1])
2×2×2 Array{Int64,3}:
[:, :, 1] =
 1  3
 5  7

[:, :, 2] =
 2  4
 6  8
permutedims(m::AbstractMatrix)

行列 m の要素を対角線に関して反転させることで、m の次元を置換します。LinearAlgebratranspose と異なり、permutedims は再帰的ではありません。

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 Array{Array{Int64,2},2}:
 [1 2; 3 4]     [5 6; 7 8]
 [9 10; 11 12]  [13 14; 15 16]

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

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

ベクトル v1 × length(v) の行行列に変形します。LinearAlgebratranspose と異なり、permutedims は再帰的ではありません。

julia> permutedims([1, 2, 3, 4])
1×4 Array{Int64,2}:
 1  2  3  4

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

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

julia> transpose(V)
1×2 Transpose{Transpose{Int64,Array{Int64,2}},Array{Array{Int64,2},1}}:
 [1 3; 2 4]  [5 7; 6 8]
Base.permutedims! ── 関数
permutedims!(dest, src, perm)

配列 src の次元を置換し、結果を配列 dest に格納します。perm は置換を指定する長さ ndims(src) のベクトルです。事前にアロケートされた配列 destsize(dest) == size(src)[perm] を満たすべきであり、全ての要素が更新されます。インプレースな置換はサポートされておらず、srcdest の両方に含まれるメモリ領域が存在すると予期せぬ結果が生じます。

permutedims も参照してください。

PermutedDimsArray(A, perm) -> B

AbstractArray 型の A を受け取り、次元を置換したように扱えるビュー B を返します。permutedims と同様ですが、コピーは起こりません (BA と同じ格納場所を共有します)。

permutedims も参照してください。

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
Base.promote_shape ── 関数
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)

配列関数

Base.accumulate ── 関数
accumulate(op, A; dims::Integer, [init])

演算 op を配列 Adims 番目の次元に沿って累積的に実行します。A がベクトルなら dims は省略できます。初期値はキーワード引数 init で指定できますが、省略もできます。性能の向上や出力の精度の制御 (オーバーフローを避けるなど) のために事前にアロケートされた出力配列を使うには accumulate! を利用してください。よく使われる演算に対しては accumulate を特殊化した関数が用意されています: cumsum, cumprod を参照してください。

Julia 1.5

配列でない反復子に対する accumulate は Julia 1.5 以降でサポートされます。

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

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

julia> accumulate(+, [1,2,3]; init=100)
3-element Array{Int64,1}:
 101
 103
 106

julia> accumulate(min, [1,2,-1]; init=0)
3-element Array{Int64,1}:
  0
  0
 -1

julia> accumulate(+, fill(1, 3, 3), dims=1)
3×3 Array{Int64,2}:
 1  1  1
 2  2  2
 3  3  3

julia> accumulate(+, fill(1, 3, 3), dims=2)
3×3 Array{Int64,2}:
 1  2  3
 1  2  3
 1  2  3
Base.accumulate! ── 関数
accumulate!(op, B, A; [dims], [init])

演算 cp を配列 Adims 番目の次元に沿って累積的に実行し、結果を B に格納します。A がベクトルなら dims は省略できます。キーワード引数 init が与えられると、その値が累積結果の初期値となります。accumulate も参照してください。

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

julia> y = [0, 0, 0, 0, 0];

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

julia> y
5-element Array{Int64,1}:
 1
 1
 3
 3
 6

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

julia> B = [0 0; 0 0];

julia> accumulate!(-, B, A, dims=1);

julia> B
2×2 Array{Int64,2}:
  1   2
 -2  -2

julia> accumulate!(-, B, A, dims=2);

julia> B
2×2 Array{Int64,2}:
 1  -1
 3  -1
Base.cumprod ── 関数
cumprod(A; dims::Integer)

dim 番目の次元に沿った累積積を計算します。性能の向上や出力の精度の制御 (オーバーフローを避けるなど) のために事前にアロケートされた出力配列を使うには cumprod! を利用してください。

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

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

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

反復子の累積積を計算します。性能の向上や出力の精度の制御 (オーバーフローを避けるなど) のために事前にアロケートされた出力配列を使うには cumprod! を利用してください。

Julia 1.5

配列でない反復子に対する cumprod は Julia 1.5 以降でサポートされます。

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

julia> cumprod([fill(1//3, 2, 2) for i in 1:3])
3-element Array{Array{Rational{Int64},2},1}:
 [1//3 1//3; 1//3 1//3]
 [2//9 2//9; 2//9 2//9]
 [4//27 4//27; 4//27 4//27]

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

julia> cumprod(x^2 for x in 1:3)
3-element Array{Int64,1}:
  1
  4
 36
Base.cumprod! ── 関数
cumprod!(B, A; dims::Integer)

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

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

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

Base.cumsum ── 関数
cumsum(A; dims::Integer)

dim 番目の次元に沿った累積和を計算します。性能の向上や出力の精度の制御 (オーバーフローを避けるなど) のために事前にアロケートされた出力配列を使うには cumsum! を利用してください。

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

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

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

返り値の配列の eltype は、システムのワードサイズより小さい符号付き整数に対しては Int となり、システムのワードサイズより小さい符号無し整数に対しては UInt となります。小さい符号付き整数あるいは符号無し整数を出力配列の eltype にしたい場合は accumulate(+, A) を利用するべきです。

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

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

cumsum(Int8[100, 28]) では整数の型がシステムのワードサイズまで広げられるので、結果は Int64[100, 128] となります。しかし accumulate(+,Int8[100, 28]) では型が広げられないので、整数のオーバーフローが起こって Int8[100, -128] が結果となります。

cumsum(itr)

反復子 itr の累積和を計算します。性能の向上や出力の精度の制御 (オーバーフローを避けるなど) のために事前にアロケートされた出力配列を使うには cumsum! を利用してください。

Julia 1.5

配列でない反復子に対する cumsum は Julia 1.5 以降でサポートされます。

julia> cumsum([1, 1, 1])
3-element Array{Int64,1}:
 1
 2
 3

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

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

julia> cumsum(x^2 for x in 1:3)
3-element Array{Int64,1}:
  1
  5
 14
Base.cumsum! ── 関数
cumsum!(B, A; dims::Integer)

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

Base.diff ── 関数
diff(A::AbstractVector)
diff(A::AbstractArray; dims::Integer)

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

Julia 1.1

次元数が 2 より大きい配列に対する diff は Julia 1.1 以降でサポートされます。

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

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

julia> diff(vec(a))
3-element Array{Int64,1}:
  4
 -2
 12
Base.repeat ── 関数
repeat(A::AbstractArray, counts::Integer...)

配列 A を各次元に指定された回数だけ反復することで配列を構築します。次元ごとの反復回数は counts で指定されます。

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

julia> repeat([1, 2, 3], 2, 3)
6×3 Array{Int64,2}:
 1  1  1
 2  2  2
 3  3  3
 1  1  1
 2  2  2
 3  3  3
repeat(A::AbstractArray; inner=ntuple(x->1, ndims(A)), outer=ntuple(x->1, ndims(A)))

A の要素を反復させて配列を構築します。inneri 番目の要素は Ai 番目の次元の各要素を反復する回数を表し、outeri 番目の要素は Ai 番目の次元に沿ったスライスを反復する回数を表します。inner または outer を省略すると、それに対応する反復は行われません (1 とみなされます)。

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

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

julia> repeat([1 2; 3 4], inner=(2, 1), outer=(1, 3))
4×6 Array{Int64,2}:
 1  2  1  2  1  2
 1  2  1  2  1  2
 3  4  3  4  3  4
 3  4  3  4  3  4
Base.rot180 ── 関数
rot180(A)

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

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

julia> rot180(a)
2×2 Array{Int64,2}:
 4  3
 2  1
rot180(A, k)

行列 A に対して 180 度の回転を k 回適用します。k が偶数のとき、この関数は copy と等価です。

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

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

julia> rot180(a,2)
2×2 Array{Int64,2}:
 1  2
 3  4
Base.rotl90 ── 関数
rotl90(A)

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

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

julia> rotl90(a)
2×2 Array{Int64,2}:
 2  4
 1  3
rotl90(A, k)

行列 A に対して 90 度の左回転 (反時計回り) を k 回適用します。k が (0 を含む) 4 の倍数なら、この関数は copy と等価です。

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

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

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

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

julia> rotl90(a,4)
2×2 Array{Int64,2}:
 1  2
 3  4
Base.rotr90 ── 関数
rotr90(A)

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

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

julia> rotr90(a)
2×2 Array{Int64,2}:
 3  1
 4  2
rotr90(A, k)

行列 A に対して 90 度の右回転 (時計回り) を k 回適用します。k が (0 を含む) 4 の倍数なら、この関数は copy と等価です。

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

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

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

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

julia> rotr90(a,4)
2×2 Array{Int64,2}:
 1  2
 3  4
Base.mapslices ── 関数
mapslices(f, A; dims)

配列 A の指定された次元の要素を関数 f で変形します。fA[...,:,...,:,...] という形の A のスライスに対して呼ばれます。このスライスの中でコロンの入る位置が整数ベクトル dims によって指定されます。返り値は残りの次元に沿って連結されます。例えば dims[1,2]A が四次元配列なら、f は全ての A[:,:,i,j] に対して呼ばれます (i, j は次元全体を動きます)。

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> mapslices(sum, a, dims = [1,2])
1×1×2×2 Array{Int64,4}:
[:, :, 1, 1] =
 10

[:, :, 2, 1] =
 26

[:, :, 1, 2] =
 42

[:, :, 2, 2] =
 58
Base.eachrow ── 関数
eachrow(A::AbstractVecOrMat)

ベクトルまたは行列 A の一つ目の次元を反復し、各行を AbstractVector のビューとして返すジェネレータを作成します。

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

Julia 1.1

この関数は Julia 1.1 以降でサポートされます。

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

julia> first(eachrow(a))
2-element view(::Array{Int64,2}, 1, :) with eltype Int64:
 1
 2

julia> collect(eachrow(a))
2-element Array{SubArray{Int64,1,Array{Int64,2},Tuple{Int64,Base.Slice{Base.OneTo{Int64}}},true},1}:
 [1, 2]
 [3, 4]
Base.eachcol ── 関数
eachcol(A::AbstractVecOrMat)

ベクトルまたは行列 A の二つ目の次元を反復し、各列を AbstractVector のビューとして返すジェネレータを作成します。

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

Julia 1.1

この関数は Julia 1.1 以降でサポートされます。

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

julia> first(eachcol(a))
2-element view(::Array{Int64,2}, :, 1) with eltype Int64:
 1
 3

julia> collect(eachcol(a))
2-element Array{SubArray{Int64,1,Array{Int64,2},Tuple{Base.Slice{Base.OneTo{Int64}},Int64},true},1}:
 [1, 3]
 [2, 4]
Base.eachslice ── 関数
eachslice(A::AbstractArray; dims)

Adims が指定する次元を反復し、dims が指定しない次元のデータ全てを選択するビューを返すジェネレータを作成します。次のジェネレータと等価です:

# i は dims 番目の次元にある。
(view(A,:,:,...,i,:,: ...) for i in axes(A, dims))

現在 dims に指定できるのは一つの次元だけです。

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

Julia 1.1

この関数は Julia 1.1 以降でサポートされます。

組み合わせ論

Base.invperm ── 関数
invperm(v)

v の逆置換を返します。B = A[v] のとき A == B[invperm(v)] が成り立ちます。

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

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

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

julia> B = A[v]
4-element Array{Char,1}:
 '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 Array{Char,1}:
 '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)
Base.isperm ── 関数
isperm(v) -> Bool

v が正当な置換なら true を返します。

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false
Base.permute! ── メソッド
permute!(v, p)

置換 p を使ってベクトル v をインプレースに置換します。p が置換である確認は行われません。

置換後の配列を新しく作って返すには v[p] としてください。大きなベクトルに対しては、通常 permute!(v, p) より v[p] の方が高速です。

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

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

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

julia> permute!(A, perm);

julia> A
4-element Array{Int64,1}:
 1
 4
 3
 1
Base.invpermute! ── 関数
invpermute!(v, p)

permute! と同じ操作を、v の逆置換に対して適用します。

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

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

julia> invpermute!(A, perm);

julia> A
4-element Array{Int64,1}:
 4
 1
 3
 1
Base.reverse ── メソッド
reverse(v [, start=1 [, stop=length(v) ]] )

順序を逆転させた v のコピーを返します。Iterators.reverse を使うとコピーを作成しないで逆順の反復が行えます。

julia> A = Vector(1:5)
5-element Array{Int64,1}:
 1
 2
 3
 4
 5

julia> reverse(A)
5-element Array{Int64,1}:
 5
 4
 3
 2
 1

julia> reverse(A, 1, 4)
5-element Array{Int64,1}:
 4
 3
 2
 1
 5

julia> reverse(A, 3, 5)
5-element Array{Int64,1}:
 1
 2
 5
 4
 3
reverse(A; dims::Integer)

dims 番目の次元に関して A を反転させたものを返します。

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

julia> reverse(b, dims=2)
2×2 Array{Int64,2}:
 2  1
 4  3
Base.reverseind ── 関数
reverseind(v, i)

reverse(v) における添え字 i を受け取り、同じ要素を指す v における添え字を返します。つまり v[reverseind(v,i)] == reverse(v)[i] が成り立ちます。これは v が非 ASCII 文字を含む文字列のとき非自明な処理となります。

julia> r = reverse("Julia")
"ailuJ"

julia> for i in 1:length(r)
           print(r[reverseind("Julia", i)])
       end
Julia
Base.reverse! ── 関数
reverse!(v [, start=1 [, stop=length(v) ]]) -> v

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

julia> A = Vector(1:5)
5-element Array{Int64,1}:
 1
 2
 3
 4
 5

julia> reverse!(A);

julia> A
5-element Array{Int64,1}:
 5
 4
 3
 2
 1

  1. 訳注: シングルトン次元とは大きさが 1 の次元のこと。[return]

  2. 訳注: シングルトン次元とは大きさが 1 の次元のこと。[return]