はじめに
Julia は表現力の豊かな言語で、同じ処理を行うにも、いくつもの書き方があります。
配列の成分 (要素) を参照する方法について、まとめてみました。
おことわり： この記事は、拙記事 [Julia] 行列を高速に更新する を訂正する前に、自分の理解を再確認するための備忘録を兼ねています。
(やはり、例題2での LinearIndices(CartesianIndices(...))) の導入は誤りですね。 追って修正します)
以下、配列の「成分」は、配列の「要素」と同じ意味です。文体が「である」になります。
節・小節の見出しに付けた I, C, L の記号は、およそ以下のような分類です。
- I : 軸毎に添字を用いたによる記法
- L : 線形な添字を用いた記法
- C :
CartesianIndexまたはCartesianIndicesを用いた記法
行列の記述
成分を列挙して行列を定義する。
同じ行内の成分は空白で区切る。 ; で行を区切る。
julia> a=[1 4 7 10; 2 5 8 11; 3 6 9 12] * 1.0
3×4 Array{Float64,2}:
1.0 4.0 7.0 10.0
2.0 5.0 8.0 11.0
3.0 6.0 9.0 12.0
ベクトル、行列、テンソルなどは、(多次元)配列 (multi-dimensional array) の仲間である。
ベクトルは1次元の配列、行列は2次元の配列である。
関数 ndims(a) は、配列a の次元を返す。
julia> ndims(a)
2
関数 size(a)は、配列 a の寸法を返す。各々の軸の寸法からなるタプルを返す。
julia> size(a)
(3, 4)
次元を 1 から数えて、第1軸 (axis)、第2軸、等々と呼ぶ。
size(a)[d] は、配列 a の軸 d (整数)の寸法である。
julia> size(a)[1]
3
julia> size(a)[2]
4
julia> size(a)[3]
ERROR: BoundsError: a
関数 size(a,d) は、配列 a の軸 d (整数)の寸法を返す。
julia> size(a,1)
3
julia> size(a,2)
4
julia> size(a,3)
1
julia> size(a,4)
1
julia> size(a,0)
ERROR: arraysize: dimension out of range
関数 length(a) は、配列 a の大きさ (成分の総数) を返す。
julia> length(a)
12
1. 行列の全ての成分を選ぶ
1A. 配列そのもの
julia> a
3×4 Array{Float64,2}:
1.0 4.0 7.0 10.0
2.0 5.0 8.0 11.0
3.0 6.0 9.0 12.0
1I. 両方の添字に、コロンを用いる
julia> a[:,:]
3×4 Array{Float64,2}:
1.0 4.0 7.0 10.0
2.0 5.0 8.0 11.0
3.0 6.0 9.0 12.0
1C. CartesianIndices を用いる
CartesianIndices(a) は、配列 a の成分全てを参照する CartesianIndex を作る。
(CartesianIndex については、2C を参照)
これを、添字に入れると、全ての成分が得られる。
julia> CartesianIndices(a)
3×4 CartesianIndices{2,Tuple{Base.OneTo{Int64},Base.OneTo{Int64}}}:
CartesianIndex(1, 1) CartesianIndex(1, 2) … CartesianIndex(1, 4)
CartesianIndex(2, 1) CartesianIndex(2, 2) CartesianIndex(2, 4)
CartesianIndex(3, 1) CartesianIndex(3, 2) CartesianIndex(3, 4)
julia> a[CartesianIndices(a)]
3×4 Array{Float64,2}:
1.0 4.0 7.0 10.0
2.0 5.0 8.0 11.0
3.0 6.0 9.0 12.0
1L-1. 線形な添字にコロンを使う
結果はベクトルとなる。
julia> a[:]
12-element Array{Float64,1}:
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
10.0
11.0
12.0
1L-2. vec(a) を使う
結果はベクトルとなる。
julia> vec(a)
12-element Array{Float64,1}:
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
10.0
11.0
12.0
2. ただ一つの成分を読む
2I. 添字を用いる
a[i,j] は、配列 a の i,j 成分の値を返す。
i と j は、それぞれ、第1軸と第2軸の添字である。
添字は、1 から数える。
例: 成分 $a_{1,2}$ を読む。
julia> a[2,3]
8.0
2C. CartesianIndex を用いる
CartesianIndex(i,j) は、添字 (i,j) を参照する。
関数 Tuple() を、CartesianIndex(i,j) に適用すると、タプル (i,j) を返す。
a[CartesianIndex(i,j)] は、配列 a の i,j 成分の値を返す。
例: 成分 $a_{1,2}$ を読む。
julia> CartesianIndex(2,3)
CartesianIndex(2, 3)
julia> Tuple(CartesianIndex(2,3))
(2, 3)
julia> a[CartesianIndex(2,3)]
8.0
2L. 線形な添字を用いる
配列の成分は、整数のスカラー (「線形な添字」)でも指定できる。
「線形な添字」は、1 から始めて、第1軸が先に増やしていくように数えたメモリの格納の順番である。
LinearIndices(a) は、配列 a の「線形な添字」を成分とする配列を返す。
julia> li=LinearIndices(a)
3×4 LinearIndices{2,Tuple{Base.OneTo{Int64},Base.OneTo{Int64}}}:
1 4 7 10
2 5 8 11
3 6 9 12
添字 [2,3] に対応する「線形な添字」は 8 であるから
julia> li[2,3]
8
julia> a[8]
8.0
3. 特定の軸を読む
3a. 特定の第2軸について、第1軸を全部読む
3a-I1. コロンを使う
第2軸を 2 として、第1軸の全ての成分を読む。
結果はベクトルとなる。
julia> a[:,2]
3-element Array{Float64,1}:
4.0
5.0
6.0
3a-I2. axesを使う
axes(a,1) は、配列 a の第1軸に対するイテレータである。
結果はベクトルとなる。
julia> a[axes(a,1),2]
3-element Array{Float64,1}:
4.0
5.0
6.0
3a-I3. 範囲を使う
「範囲」 (Range) とは、2つ、または、3つの整数をコロン : で区切った式である。
-
2:5は、2から始めて1を順に加えて、5まで増やした数を表す。 -
3:2:7は、3から始めて2を順に加えて、7を超えるまで増やした数を表す。
第1軸の添字に範囲を使う。
結果はベクトルとなる。
julia> a[1:size(a,1),2]
3-element Array{Float64,1}:
4.0
5.0
6.0
3a-C. CartesianIndices を使う
結果は行列となる。
julia> a[CartesianIndices((axes(a,1),2))]
3×1 Array{Float64,2}:
4.0
5.0
6.0
3b. 特定の第2軸について、第2軸を全部読む
3b-I1. コロンを使う
第1軸の添字を 2 として、第2軸の全ての成分を読む。
結果はベクトルとなる。
julia> a[2,:]
4-element Array{Float64,1}:
2.0
5.0
8.0
11.0
3b-I2. axesを使う
axes(a,2) は、配列 a の第2軸に対するイテレータである。
結果はベクトルとなる。
julia> a[2,axes(a,2)]
4-element Array{Float64,1}:
2.0
5.0
8.0
11.0
3b-I3. 範囲を使う
結果はベクトルとなる。
julia> a[2,1:size(a,2)]
4-element Array{Float64,1}:
2.0
5.0
8.0
11.0
3b-C. CartesianIndices を使う
結果は行列となる。
julia> a[CartesianIndices((2,axes(a,2)))]
1×4 Array{Float64,2}:
2.0 5.0 8.0 11.0
4. 規則的に成分を読む
4a. 特定の第2軸について、第1軸を規則的に読む
4a-I. 第1軸に範囲を使う
julia> a[1:3,2]
3-element Array{Float64,1}:
4.0
5.0
6.0
4a-C. CartesianIndices で、第1軸に範囲を使う
julia> a[CartesianIndices((1:3,2))]
3×1 Array{Float64,2}:
4.0
5.0
6.0
4b. 特定の第1軸について、第2軸を規則的に読む
4b-I. 第2軸に範囲を使う
結果はベクトルとなる。
julia> a[2,1:4]
4-element Array{Float64,1}:
2.0
5.0
8.0
11.0
4a-C. CartesianIndices で、第2軸に範囲を使う
結果は行列となる。
julia> a[CartesianIndices((2,1:4))]
1×4 Array{Float64,2}:
2.0 5.0 8.0 11.0
4c. 第1軸と第2軸の両方を規則的に読む
4c-I. 両方の添字に、範囲を用いる
結果は行列となる。
行列の寸法が (1,1) となっても、スカラー型に変換されない。
julia> a[2:3,3:4]
2×2 Array{Float64,2}:
8.0 11.0
9.0 12.0
julia> a[2:2,3:3]
1×1 Array{Float64,2}:
8.0
4c-C. CartesianIndices で、両方の軸に範囲を使う
julia> m=CartesianIndices((2:3,2:3))
2×2 CartesianIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
CartesianIndex(2, 2) CartesianIndex(2, 3)
CartesianIndex(3, 2) CartesianIndex(3, 3)
julia> a[m]
2×2 Array{Float64,2}:
5.0 8.0
6.0 9.0
5. 任意の複数の成分を読む
5C. CartesianIndex を成分とする配列を用いる
CartesianIndex(i,j) を成分とする配列を、添字に用いる。
結果は、その配列と同じ形になる。
5C-1. 縦ベクトル (列ベクトル) の場合
julia> m=[CartesianIndex(3,4), CartesianIndex(2,3)]
2-element Array{CartesianIndex{2},1}:
CartesianIndex(3, 4)
CartesianIndex(2, 3)
julia> a[m]
2-element Array{Float64,1}:
12.0
8.0
5C-2. 横ベクトル (行ベクトル) の場合
julia> m=[CartesianIndex(3,4) CartesianIndex(2,3)]
1×2 Array{CartesianIndex{2},2}:
CartesianIndex(3, 4) CartesianIndex(2, 3)
julia> a[m]
1×2 Array{Float64,2}:
12.0 8.0
5C-3. 行列の場合
julia> m=[ CartesianIndex(3,4) CartesianIndex(2,3);
CartesianIndex(3,1) CartesianIndex(3,2)]
2×2 Array{CartesianIndex{2},2}:
CartesianIndex(3, 4) CartesianIndex(2, 3)
CartesianIndex(3, 1) CartesianIndex(3, 2)
julia> a[m]
2×2 Array{Float64,2}:
12.0 8.0
3.0 6.0
CartesianIndex(i,j) を成分とする配列を作るには、タプル (i,j) を成分とした配列を、関数 CartesianIndices に適用する。
julia> m=CartesianIndices( [ (3,4) (2,3); (3,1) (3,2)] )
2×2 CartesianIndices{2,Tuple{Base.OneTo{Int64},Base.OneTo{Int64}}}:
CartesianIndex(1, 1) CartesianIndex(1, 2)
CartesianIndex(2, 1) CartesianIndex(2, 2)
5L. 線形な添字を成分とする配列を用いる
線形な添字を成分とする配列を、添字に用いる。
結果は、その配列と同じ形になる。
5L-1. 縦ベクトル (列ベクトル)
結果は縦ベクトルとなる。
julia> a[[12, 8]]
2-element Array{Float64,1}:
12.0
8.0
5L-2. 横ベクトル (行ベクトル)
結果は行列(横ベクトルに相当)となる。
julia> a[[12 8]]
1×2 Array{Float64,2}:
12.0
8.0
5L-3. 行列
結果は行列となる。
julia> a[[12 8; 3 6]]
2×2 Array{Float64,2}:
12.0 8.0
3.0 6.0
6. 全ての成分を巡る
6L. eachindex(a) を用いる
イテレータ: eachindex(a)
julia> for i in eachindex(a)
@show i, a[i]
end
(i, a[i]) = (1, 1.0)
(i, a[i]) = (2, 2.0)
(i, a[i]) = (3, 3.0)
(i, a[i]) = (4, 4.0)
(i, a[i]) = (5, 5.0)
(i, a[i]) = (6, 6.0)
(i, a[i]) = (7, 7.0)
(i, a[i]) = (8, 8.0)
(i, a[i]) = (9, 9.0)
(i, a[i]) = (10, 10.0)
(i, a[i]) = (11, 11.0)
(i, a[i]) = (12, 12.0)
内包表現の中で使うと、a の寸法のベクトルができる
julia> [ a[i]-1.0 for i in eachindex(a) ]
12-element Array{Float64,1}:
0.0
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
10.0
11.0
6C. CartesianIndices(a) を用いる
1C. をイテレータとして使う。
julia> CartesianIndices(a)
3×4 CartesianIndices{2,Tuple{Base.OneTo{Int64},Base.OneTo{Int64}}}:
CartesianIndex(1, 1) CartesianIndex(1, 2) … CartesianIndex(1, 4)
CartesianIndex(2, 1) CartesianIndex(2, 2) CartesianIndex(2, 4)
CartesianIndex(3, 1) CartesianIndex(3, 2) CartesianIndex(3, 4)
julia> for i in CartesianIndices(a)
@show i, a[i]
end
(i, a[i]) = (CartesianIndex(1, 1), 1.0)
(i, a[i]) = (CartesianIndex(2, 1), 2.0)
(i, a[i]) = (CartesianIndex(3, 1), 3.0)
(i, a[i]) = (CartesianIndex(1, 2), 4.0)
(i, a[i]) = (CartesianIndex(2, 2), 5.0)
(i, a[i]) = (CartesianIndex(3, 2), 6.0)
(i, a[i]) = (CartesianIndex(1, 3), 7.0)
(i, a[i]) = (CartesianIndex(2, 3), 8.0)
(i, a[i]) = (CartesianIndex(3, 3), 9.0)
(i, a[i]) = (CartesianIndex(1, 4), 10.0)
(i, a[i]) = (CartesianIndex(2, 4), 11.0)
(i, a[i]) = (CartesianIndex(3, 4), 12.0)
内包表現の中で使うと、a と同じ形の行列ができる
julia> [ a[i]-1.0 for i in CartesianIndices(a) ]
3×4 Array{Float64,2}:
0.0 3.0 6.0 9.0
1.0 4.0 7.0 10.0
2.0 5.0 8.0 11.0
7. 特定の軸を巡る
「3. 特定の軸を読む」をイテレータにする
7a. 特定の第2軸について、第1軸を全部巡る
7a-I2. axes() を使う
3a-I2 のイテレータ版
julia> for i in axes(a,1)
@show i, a[i,2]
end
(i, a[i, 2]) = (1, 4.0)
(i, a[i, 2]) = (2, 5.0)
(i, a[i, 2]) = (3, 6.0)
julia> [ a[i,2] for i in axes(a,1) ]
3-element Array{Float64,1}:
4.0
5.0
6.0
7a-I3. 範囲を使う
3a-I3 のイテレータ版
julia> for i in 1:size(a,1)
@show i, a[i,2]
end
(i, a[i, 2]) = (1, 4.0)
(i, a[i, 2]) = (2, 5.0)
(i, a[i, 2]) = (3, 6.0)
julia> [ a[i,2] for i in 1:size(a,1) ]
3-element Array{Float64,1}:
4.0
5.0
6.0
7a-C. CartesianIndices を使う
イテレータからは CartesianIndex が得られる。
内包表現で使うと、結果は行列となる。
julia> for ij in CartesianIndices((axes(a,1),2))
@show ij, a[ij]
end
(ij, a[ij]) = (CartesianIndex(1, 2), 4.0)
(ij, a[ij]) = (CartesianIndex(2, 2), 5.0)
(ij, a[ij]) = (CartesianIndex(3, 2), 6.0)
julia> [ a[ij] for ij in CartesianIndices((axes(a,1),2)) ]
3×1 Array{Float64,2}:
4.0
5.0
6.0
7b. 特定の第1軸について、第2軸を全部巡る
7b-I2. axes() を使う
3b-I2 のイテレータ版
julia> for j in axes(a,2)
@show j, a[2,j]
end
(j, a[2, j]) = (1, 2.0)
(j, a[2, j]) = (2, 5.0)
(j, a[2, j]) = (3, 8.0)
(j, a[2, j]) = (4, 11.0)
julia> [ a[2,j] for j in axes(a,2) ]
4-element Array{Float64,1}:
2.0
5.0
8.0
11.0
7b-I3. 範囲を使う
3b-I3 のイテレータ版。
julia> for j in 1:size(a,2)
@show j, a[2,j]
end
(j, a[2, j]) = (1, 2.0)
(j, a[2, j]) = (2, 5.0)
(j, a[2, j]) = (3, 8.0)
(j, a[2, j]) = (4, 11.0)
julia> [ a[2,j] for j in 1:size(a,2) ]
4-element Array{Float64,1}:
2.0
5.0
8.0
11.0
7b-C. CartesianIndices を使う
3b-C のイテレータ版。
イテレータからは CartesianIndex が得られる。
内包表現で使うと、結果は行列となる。
julia> for ij in CartesianIndices((2,axes(a,2)))
@show ij, a[ij]
end
(ij, a[ij]) = (CartesianIndex(2, 1), 2.0)
(ij, a[ij]) = (CartesianIndex(2, 2), 5.0)
(ij, a[ij]) = (CartesianIndex(2, 3), 8.0)
(ij, a[ij]) = (CartesianIndex(2, 4), 11.0)
julia> [ a[ij] for ij in CartesianIndices((2,axes(a,2))) ]
1×4 Array{Float64,2}:
2.0 5.0 8.0 11.0
8. 規則的に成分を巡る
「4. 規則的に成分を選ぶ」をイテレータにする
8a. 特定の第2軸について、第1軸を規則的に巡る
8a-I. 第1軸に範囲を用いる
4a-I のイテレータ版
julia> [ a[i,2] for i in 2:3 ]
2-element Array{Float64,1}:
5.0
6.0
8a-C. CartesianIndices で、第1軸に範囲を使う
4a-C のイテレータ版。
内包表現に使うと、結果は行列となる。
julia> [ a[ij] for ij in CartesianIndices((2:3,2)) ]
2×1 Array{Float64,2}:
5.0
6.0
8b. 特定の第1軸について、第2軸を規則的に巡る
8b-I. 第2軸に範囲を用いる
4b-I のイテレータ版
julia> [ a[2,i] for i in 1:4 ]
4-element Array{Float64,1}:
2.0
5.0
8.0
11.0
8b-C. CartesianIndices で、第2軸に範囲を使う
4a-C のイテレータ版
内包表現に使うと、結果は行列となる。
julia> [ a[ij] for ij in CartesianIndices((2,1:4)) ]
1×4 Array{Float64,2}:
2.0 5.0 8.0 11.0
8c. 第1軸と第2軸の両方を規則的に巡る
8c-I. 両軸の添字の範囲を二重ループ
4c-I のイテレータ版
両軸に範囲を指定した内包表現では結果は行列となる。
どちらのループ変数を内側で回すか考慮すべき。
julia> [ a[i,j] for i in 2:3, j in 3:4 ]
2×2 Array{Float64,2}:
8.0 11.0
9.0 12.0
julia> [ a[i,j] for j in 3:4, i in 2:3 ]
2×2 Array{Float64,2}:
8.0 9.0
11.0 12.0
8c-C. CartesianIndices で、両方の軸に範囲を使う
4c-C のイテレータ版
内包表現に使うと、結果は行列となる。
julia> for ij in CartesianIndices((2:3,2:3))
@show ij, a[ij]
end
(ij, a[ij]) = (CartesianIndex(2, 2), 5.0)
(ij, a[ij]) = (CartesianIndex(3, 2), 6.0)
(ij, a[ij]) = (CartesianIndex(2, 3), 8.0)
(ij, a[ij]) = (CartesianIndex(3, 3), 9.0)
julia> [ a[ij] for ij in CartesianIndices((2:3,2:3)) ]
2×2 Array{Float64,2}:
5.0 8.0
6.0 9.0
9. 任意の特定の複数の成分を巡る
9C. CartesianIndex を成分とする配列を用いる
CartesianIndex() を成分とする配列は、イテレータとして使える。
これを内包表現で使うと、結果はイテレータと同じ形の配列となる。
9C-1. 縦ベクトル (列ベクトル)
5C-1. をイテレータにする。
内包表現に使うと、結果は縦ベクトルとなる。
julia> m=[CartesianIndex(3,4),CartesianIndex(2,3)]
2-element Array{CartesianIndex{2},1}:
CartesianIndex(3, 4)
CartesianIndex(2, 3)
julia> for i in m
@show i
end
i = CartesianIndex(3, 4)
i = CartesianIndex(2, 3)
julia> [ a[i] for i in m ]
2-element Array{Float64,1}:
12.0
8.0
9C-2. 横ベクトル (行ベクトル)
5C-2. をイテレータにする。
内包表現に使うと、結果は行列となる。
julia> m=[CartesianIndex(3,4) CartesianIndex(2,3)]
1×2 Array{CartesianIndex{2},2}:
CartesianIndex(3, 4) CartesianIndex(2, 3)
julia> for i in m
@show i
end
i = CartesianIndex(3, 4)
i = CartesianIndex(2, 3)
julia> [ a[i] for i in m ]
1×2 Array{Float64,2}:
12.0 8.0
9C-3. 行列
5C-3. をイテレータにする。
内包表現に使うと、結果は行列となる。
julia> m=[ CartesianIndex(3,4) CartesianIndex(2,3);
CartesianIndex(3,1) CartesianIndex(3,2)]
2×2 Array{CartesianIndex{2},2}:
CartesianIndex(3, 4) CartesianIndex(2, 3)
CartesianIndex(3, 1) CartesianIndex(3, 2)
julia> for i in m
@show i, Tuple(i)
end
(i, Tuple(i)) = (CartesianIndex(3, 4), (3, 4))
(i, Tuple(i)) = (CartesianIndex(3, 1), (3, 1))
(i, Tuple(i)) = (CartesianIndex(2, 3), (2, 3))
(i, Tuple(i)) = (CartesianIndex(3, 2), (3, 2))
julia> [ a[i] for i in m ]
2×2 Array{Float64,2}:
12.0 8.0
3.0 6.0
9L. 線形な添字を成分とする配列を用いる
5L をイテレータとする。
9L-1. 縦ベクトル (列ベクトル)
5L-1. をイテレータにする。
内包表現に使うと、結果は縦ベクトルとなる。
julia> m=[12,8]
2-element Array{Int64,1}:
12
8
julia> for i in m
@show i, a[i]
end
(i, a[i]) = (12, 12.0)
(i, a[i]) = (8, 8.0)
julia> [ a[i] for i in m ]
2-element Array{Float64,1}:
12.0
8.0
9L-2. 横ベクトル (行ベクトル)
5L-2. をイテレータにする。
内包表現に使うと、結果は行列(横ベクトルに相当)となる。
julia> m=[12 8]
1×2 Array{Int64,2}:
12 8
julia> for i in m
@show i, a[i]
end
(i, a[i]) = (12, 12.0)
(i, a[i]) = (8, 8.0)
julia> [ a[i] for i in m ]
1×2 Array{Float64,2}:
12.0 8.0
9L-3. 行列
5L-3. をイテレータにする。
内包表現に使うと、結果は行列となる。
julia> m=[12 8; 3 6]
2×2 Array{Int64,2}:
12 8
3 6
julia> for i in m
@show i, a[i]
end
(i, a[i]) = (12, 12.0)
(i, a[i]) = (3, 3.0)
(i, a[i]) = (8, 8.0)
(i, a[i]) = (6, 6.0)
julia> [ a[i] for i in m ]
2×2 Array{Float64,2}:
12.0 8.0
3.0 6.0
10. 論理値の行列を用いて選ぶ
10B 論理値行列を用いて、行列の成分を選ぶ
行列 a と同じ寸法の論理値行列を用意する。
この論理値行列を a の添字に入れると、true に対応する成分だけを抜き出すことができる。
julia> m=rand([false,true], size(a) )
3×4 Array{Bool,2}:
false true false true
false false true true
true false false false
julia> # true の添字を、CartesianIndex で列挙する
[ ij for ij in CartesianIndices(a) if m[ij]==true ]
5-element Array{CartesianIndex{2},1}:
CartesianIndex(3, 1)
CartesianIndex(1, 2)
CartesianIndex(2, 3)
CartesianIndex(1, 4)
CartesianIndex(2, 4)
julia> # true の添字を、線形な添字で列挙する
[ ij for ij in eachindex(a) if m[ij]==true ]
5-element Array{Int64,1}:
3
4
8
10
11
julia> # true の添字に対応する成分を抜き出す
a[m]
5-element Array{Float64,1}:
3.0
4.0
8.0
10.0
11.0
末尾
書き漏らしている場合があれば、ご指摘下さい。