[逆引きJulia] 配列要素の参照、色々

はじめに

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

末尾

書き漏らしている場合があれば、ご指摘下さい。