Julia Base.Matrix

Julia の Base.Matrix は、指定した型の要素を持つ2次元の密な配列で、Core.Array{T,2} の別名である。数学の行列を表現するためによく使われる。データフレーム (Dataframe) とは異なり、単一のデータ型のみ格納できる。

1 コレクション

Base.Matrix はコレクションの一種である。Julia 言語には、以下に示すコレクションがある。

Juliaのコレクション
コレクション	順序	名前	値の重複	要素の追加・変更
Core.Array	✓	✗	✓	✓
Core.NamedTuple	✓	✓	✓	✗
Core.Tuple	✓	✗	✓	✗
Base.Dict	✗	✓	✓	✓
Base.Matrix	✓	✗	✓	✓
Base.Set	✗	✗	✗	✗
Base.Vector	✓	✗	✓	✓

Base.Matrix は以下に示す特徴を持つ。

要素に順序性がある
要素に名前が無い
重複した値を持つことができる
要素の値を変更できる
要素を追加できる
２次元の要素を持つ

上記の特徴は Core.Array と同じである。実際、Base.Matrix は Core.Array{T,2} の別名である。Base.Matrixは、一般的に「行列」と呼ばれる。

2 定義

Matrix{T} <: AbstractMatrix{T}

3 行列の生成

(\begin{matrix} 1 & 2 \\ 3 & 4 \end{matrix})

行列の値は空白と改行で区切る。

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

改行の代わりにセミコロンでもよい。

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

要素の型を指定することができる。

julia> m = Int32[1 2;3 4]
2×2 Matrix{Int32}:
 1  2
 3  4

4 リスト内包表記

リスト内包表記とは、既存のリストから新たなリストを作成する表記法であり、数学における集合の内包的記法に準拠している。

集合の表し方には「外延的」と「内包的」という２種類の記法がある。

外延 (extension) 的な記法とは、すべての元（要素）を列挙して集合を表す方法である。Julia の Base.Matrix の場合、以下のように記述する。

julia> m = [2 3 4;3 4 5]
2×3 Matrix{Int64}:
 2  3  4
 3  4  5

内包 (intension) 的な記法とは、元が満たすべき条件を記述して集合を表す方法である。Julia の Base.Matrix の場合、以下のように記述する。

julia> m = [ x + y for x in 1:2, y in 1:3 ]
2×3 Matrix{Int64}:
 2  3  4
 3  4  5

5 行列の和

(\begin{matrix} 1 & 2 \\ 3 & 4 \end{matrix}) + (\begin{matrix} 1 & 3 \\ 2 & 4 \end{matrix}) = (\begin{matrix} 2 & 5 \\ 5 & 8 \end{matrix})

上記の行列加算式を Julia で行う例を以下に示す。

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

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

julia> x + y
2×2 Matrix{Int64}:
 2  5
 5  8

6 行列の差

(\begin{matrix} 1 & 2 \\ 3 & 4 \end{matrix}) - (\begin{matrix} 1 & 3 \\ 2 & 4 \end{matrix}) = (\begin{matrix} 0 & -1 \\ 1 & 0 \end{matrix})

上記の行列減算式を Julia で行う例を以下に示す。

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

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

julia> x - y
2×2 Matrix{Int64}:
 0  -1
 1   0

7 行列の積

(\begin{matrix} 1 & 2 \\ 3 & 4 \end{matrix}) (\begin{matrix} 1 & 3 \\ 2 & 4 \end{matrix}) = (\begin{matrix} 5 & 11 \\ 11 & 25 \end{matrix})

上記の行列乗算式を Julia で行う例を以下に示す。

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

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

julia> x * y
2×2 Matrix{Int64}:
  5  11
 11  25

8 Core.Array

Core.Array メソッドを使って配列を生成できる。

Array{T}(undef, dims)

Array{T,N}(undef, dims)

Array{T}(nothing, dims)

Array{T,N}(nothing, dims)

Array{T}(missing, dims)

Array{T,N}(missing, dims)

T

要素の型

N

配列の次元

undef

要素の初期値を undef とする。

julia> a = Array{Int32, 2}(undef, 2, 3)
2×3 Matrix{Int32}:
 0  0  0
 0  0  0

nothing

要素の初期値を nothing とする。要素の型 (T) に Core.Nothing を含める必要がある。

missing

要素の初期値を missing とする。要素の型 (T) に Base.Missing を含める必要がある。

dims

各次元の要素数

9 Core.isa

Core.isa 関数を使うことで、与えられた型であるかどうかを判定できる。Base.Matrix は Core.Array{T,2} の別名であるため、比較する型が Core.Array でも真 (true) と判定される。また、スーパータイプである Base.AbstractMatrix でも真 (true) と判定される。

isa(x, type) -> Bool

型の判定を行う例を以下に示す。

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

julia> isa(m, Matrix)
true

julia> isa(m, Array)
true

julia> isa(m, AbstractMatrix)
true

julia> isa(m, Vector)
false

Core.isa 関数は「x isa type」のように、劣等演算子としても使用できる。

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

julia> m isa Matrix
true

julia> m isa Array
true

julia> m isa AbstractMatrix
true

julia> m isa Vector
false

10 Core.typeof

Core.typeof 関数を使って、行列の要素の型を確認できる。

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

julia> typeof(m)
Matrix{Int64} (alias for Array{Int64, 2})

julia> m = Float32[1 2;3 4]
2×2 Matrix{Float32}:
 1.0  2.0
 3.0  4.0

julia> typeof(m)
Matrix{Float32} (alias for Array{Float32, 2})

11 Base.falses

Base.falses 関数を使うことで、すべての要素が false (0) である行列を生成できる。

julia> m = falses(3, 2)
3×2 BitMatrix:
 0  0
 0  0
 0  0

12 Base.fill

Base.fill 関数を使うことで、すべての要素が同じ値である行列を生成できる。

julia> m = fill(-1, 2, 3)
2×3 Matrix{Int64}:
 -1  -1  -1
 -1  -1  -1

13 Base.findall

Base.findall メソッドを使うことで、Base.Matrix に含まれる true の要素だけを抽出することができる。

julia> m = [true false;true true]
2×2 Matrix{Bool}:
 1  0
 1  1

julia> findall(m)
3-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)
 CartesianIndex(2, 2)

Base.findall メソッドを使うことで、Base.Matrix に含まれる要素のうち、引数に渡した関数の戻り値が true になる要素だけを抽出することができる。

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

julia> findall(isodd, m)
2-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)

julia> findall(iseven, m)
2-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 2)
 CartesianIndex(2, 2)

14 Base.ones

Base.ones 関数を使うことで、すべての要素が 1 である行列を生成できる。

julia> m = ones(Float32, 3, 2)
3×2 Matrix{Float32}:
 1.0  1.0
 1.0  1.0
 1.0  1.0

15 Base.sum

Base.sum 関数を使って、Base.Matrix 各要素の合計値を求めることができる。

julia> sum([1 2;3 4])
10

16 Base.trues

Base.trues 関数を使うことで、すべての要素が true (1) である行列を生成できる。

julia> m = trues(2, 3)
2×3 BitMatrix:
 1  1  1
 1  1  1

17 Base.zeros

Base.zeros 関数を使うことで、すべての要素が 0 である行列を生成できる。

julia> m = zeros(Float32, 2, 3)
2×3 Matrix{Float32}:
 0.0  0.0  0.0
 0.0  0.0  0.0

18 ヘルプ

Julia の REPL で ? キーを押すと、HELP モードになる。HELP モードの REPL で Matrix と入力すると、ヘルプが表示される。

julia> ?
help?> Matrix
search: Matrix BitMatrix DenseMatrix StridedMatrix AbstractMatrix

  Matrix{T} <: AbstractMatrix{T}

  Two-dimensional dense array with elements of type T, often used to represent a mathematical matrix. Alias
  for Array{T,2}.

  See also fill, zeros, undef and similar for creating matrices.

  ──────────────────────────────────────────────────────────────────────────────────────────────────────────

  Matrix{T}(undef, m, n)

  Construct an uninitialized Matrix{T} of size m×n.

  Examples
  ≡≡≡≡≡≡≡≡≡≡

  julia> Matrix{Float64}(undef, 2, 3)
  2×3 Array{Float64, 2}:
   2.36365e-314  2.28473e-314    5.0e-324
   2.26704e-314  2.26711e-314  NaN

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

  ──────────────────────────────────────────────────────────────────────────────────────────────────────────

  Matrix{T}(nothing, m, n)

  Construct a Matrix{T} of size m×n, initialized with nothing entries. Element type T must be able to hold
  these values, i.e. Nothing <: T.

  Examples
  ≡≡≡≡≡≡≡≡≡≡

  julia> Matrix{Union{Nothing, String}}(nothing, 2, 3)
  2×3 Matrix{Union{Nothing, String}}:
   nothing  nothing  nothing
   nothing  nothing  nothing

  ──────────────────────────────────────────────────────────────────────────────────────────────────────────

  Matrix{T}(missing, m, n)

  Construct a Matrix{T} of size m×n, initialized with missing entries. Element type T must be able to hold
  these values, i.e. Missing <: T.

  Examples
  ≡≡≡≡≡≡≡≡≡≡

  julia> Matrix{Union{Missing, String}}(missing, 2, 3)
  2×3 Matrix{Union{Missing, String}}:
   missing  missing  missing
   missing  missing  missing

19 参考文献

JuliaLang.org contributors 2023. Julia Documentation