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


# はじめに

Julia は表現力の豊かな言語で、同じ処理を行うにも、いくつもの書き方があります。
配列の成分 (要素) を参照する方法について、まとめてみました。

おことわり： この記事は、拙記事 [[Julia] 行列を高速に更新する](https://qiita.com/tenfu2tea/items/b63f2c62d194f4294a76) を訂正する前に、自分の理解を再確認するための備忘録を兼ねています。
(やはり、例題2での `LinearIndices(CartesianIndices(...)))` の導入は誤りですね。 追って修正します) 

以下、配列の「成分」は、配列の「要素」と同じ意味です。文体が「である」になります。

節・小節の見出しに付けた I, C, L の記号は、およそ以下のような分類です。
- I : 軸毎に添字を用いたによる記法
- L : 線形な添字を用いた記法
- C : `CartesianIndex` または `CartesianIndices` を用いた記法


# 行列の記述

成分を列挙して行列を定義する。
同じ行内の成分は空白で区切る。 `;` で行を区切る。

```julia
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
julia> ndims(a)
2
```

関数 `size(a)`は、配列 `a` の寸法を返す。各々の軸の寸法からなるタプルを返す。

```julia
julia> size(a)
(3, 4)
```

次元を 1 から数えて、第1軸 (axis)、第2軸、等々と呼ぶ。

`size(a)[d]` は、配列 `a` の軸 `d` (整数)の寸法である。

```julia
julia> size(a)[1]
3

julia> size(a)[2]
4

julia> size(a)[3]
ERROR: BoundsError: a
```

関数 `size(a,d)` は、配列 `a` の軸 `d` (整数)の寸法を返す。

```julia
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
julia> length(a)
12
```

# 1. 行列の全ての成分を選ぶ

## 1A. 配列そのもの

```julia
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
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](#2c-cartesianindex-%E3%82%92%E7%94%A8%E3%81%84%E3%82%8B) を参照) 
これを、添字に入れると、全ての成分が得られる。 

```julia
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
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
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
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
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
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

julia> li[2,3]
8

julia> a[8]
8.0
```

# 3. 特定の軸を読む

## 3a. 特定の第2軸について、第1軸を全部読む

### 3a-I1. コロンを使う

第2軸を 2 として、第1軸の全ての成分を読む。
結果はベクトルとなる。

```Julia
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
julia> a[1:size(a,1),2]
3-element Array{Float64,1}:
 4.0
 5.0
 6.0
```

### 3a-C. CartesianIndices を使う

結果は行列となる。

```julia
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
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
julia> a[2,axes(a,2)]
4-element Array{Float64,1}:
  2.0
  5.0
  8.0
 11.0
```

### 3b-I3. 範囲を使う

結果はベクトルとなる。

```julia
julia> a[2,1:size(a,2)]
4-element Array{Float64,1}:
  2.0
  5.0
  8.0
 11.0
```

### 3b-C. CartesianIndices を使う

結果は行列となる。

```julia
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
julia> a[1:3,2]
3-element Array{Float64,1}:
 4.0
 5.0
 6.0
```

### 4a-C. CartesianIndices で、第1軸に範囲を使う

```julia
julia> a[CartesianIndices((1:3,2))]
3×1 Array{Float64,2}:
 4.0
 5.0
 6.0
```

## 4b. 特定の第1軸について、第2軸を規則的に読む

### 4b-I. 第2軸に範囲を使う

結果はベクトルとなる。

```julia
julia> a[2,1:4]
4-element Array{Float64,1}:
  2.0
  5.0
  8.0
 11.0
```

### 4a-C. CartesianIndices で、第2軸に範囲を使う

結果は行列となる。

```julia
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
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
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
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
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
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
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
julia> a[[12, 8]]
2-element Array{Float64,1}:
 12.0
  8.0
```

### 5L-2. 横ベクトル (行ベクトル)

結果は行列(横ベクトルに相当)となる。

```julia
julia> a[[12 8]]
1×2 Array{Float64,2}:
 12.0  
  8.0
```

### 5L-3. 行列

結果は行列となる。

```julia
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
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
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
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](#3b-i2-axes%E3%82%92%E4%BD%BF%E3%81%86) のイテレータ版

```julia
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](#3b-i3-%E7%AF%84%E5%9B%B2%E3%82%92%E4%BD%BF%E3%81%86) のイテレータ版。

```julia
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](#3b-c-cartesianindices-%E3%82%92%E4%BD%BF%E3%81%86) のイテレータ版。
イテレータからは `CartesianIndex` が得られる。

内包表現で使うと、結果は行列となる。

```julia
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](#4a-i-%E7%AC%AC1%E8%BB%B8%E3%81%AB%E7%AF%84%E5%9B%B2%E3%82%92%E4%BD%BF%E3%81%86) のイテレータ版

```julia
julia> [ a[i,2] for i in 2:3 ]
2-element Array{Float64,1}:
 5.0
 6.0
```

### 8a-C. CartesianIndices で、第1軸に範囲を使う

[4a-C](#4a-c-cartesianindices-%E3%81%A7%E7%AC%AC1%E8%BB%B8%E3%81%AB%E7%AF%84%E5%9B%B2%E3%82%92%E4%BD%BF%E3%81%86) のイテレータ版。
内包表現に使うと、結果は行列となる。

```julia
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
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
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
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
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
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
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

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

# 末尾

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