学校に通わずに学ぶログ

Geany 2.0でAdaプログラミング中にクラッシュする症状

2026-02-27T10:42:00.003+09:00

Debian GNU/Linux 13 (Trixie)にインストールしたソースコード・エディタGeany 2.0を使ってプログラミング言語Adaのコードを入力していたら、特定のステートメントを入力するたびにそのGeanyが強制終了する症状に遭遇した。特定のコードというのはAdaではお決まりの次のステートメント。

procedure Main is

トップメニューから「設定」->「インターフェース」->「インターフェース」タブで「サイドバーを表示」や「シンボルリストを表示」のチェックを外してもこの症状は解消しなかった。

トップメニューから「ツール」->「設定ファイル」->「ファイル種類の設定」->「プログラミング言語」のfiletypes.adaを開いてみた。設定のすべての項目はコメントアウトされていた。

procedureMainisでもprocedure MainisでもprocedureMain isでもクラッシュしない。procedure Main isと入力された時点でその瞬間に必ずクラッシュした。タグ・パーサー（タグ解析機）の不具合が強く疑われた。

けっきょくfiletypes.adaの[settings]に次のように記述してタグ・パーサーの働きを無効にすることでしか解決できなかった。

[settings]
# procedure ... is というコードを入力するとgeanyが落ちる問題を回避
tag_parser=

ちなみに、Debian GNU/Linux 13 (Trixie)ではfiletypes.adaファイルはホーム・ディレクトリ内の.config/geany/filedefsディレクトリ内に保存される。

Debian GNU/Linux 13 trixieでスワップファイルを作ってみた

2025-11-02T13:18:00.001+09:00

古くて低スペックになったパソコンにDebian 13 (trixie)をインストールしてみた。けれどもその際のパーティション作成でスワップ領域を作らなかった。その代わりにスワップ・ファイルを作成することにした。

インストールしたOSは次のとおり。

$ lsb_release -a
No LSB modules are available.
Distributor ID: Debian
Description:    Debian GNU/Linux 13 (trixie)
Release:        13
Codename:       trixie

lsb_releaseはディストリビューション固有の情報を教えてくれる外部コマンド。そのオプションの-aは出力可能な全て表示することを指示している。

メモリ(RAM)のサイズは次のとおり。

$ cat /proc/meminfo | grep -ie memtotal -e swaptotal
MemTotal:        7810932 kB
SwapTotal:             0 kB

コマンドcatによって/proc/meminfoファイルを参照し、その出力内容を|（パイプ）によってコマンドgrepに渡し、memtotalとswaptotalの文字列のパターンを持つ行だけを表示させている。grepの-eはパターンを指定するオプションで、-iは大文字と小文字を区別しないように指示するオプション。

16GBが最低と言われている時代に8GB弱というのはかなり低スペックのパソコン。それでもネットサーフィンをしたりSNSを利用するのには使えているし、YouTubeの動画も解像度を落として見ることができている。それでもスワップ領域がないのは心配だ。

スワップ・ファイルを作成

スワップ・ファイルを作成する際にその領域を確保するためにはddというプログラム（外部コマンド）を使う方法とfallocateというプログラム（外部コマンド）を使う方法がある。

ddのほうが細かい設定ができるが、ddはfallocateよりもその処理に時間が長くかかる。ファイル・システムにBtrfsや暗号化fsを利用している場合、ddのほうが安全である利点がある。ただしHDDでなくSSDの使っている場合には必要な領域を予約するだけである理由からfallocateのほうが推奨されている。

まずはfallocateを使った場合から。ハイバネートを利用しないつもりなのでRAMの大きさより若干多めに8GiBギビバイトを確保することにした。ハイバネートを利用する場合にはRAMサイズの1.5倍から2倍のスワップ領域がおおよそ必要になる。この操作にはオペレーティング・システムの管理者権限が必要。

# fallocate -l 8GiB /swapfile

ハイバネートを利用したい場合には例えば次のように指定する。

# fallocate -l 12GiB /swapfile

ddの場合、if=で入力ファイルとして/dev/zeroという特殊なデバイス・ファイル（ゼロ・デバイス）を指定し、of=で出力ファイルとして/swapfileを指定した。bs=で一度に読み書きする情報量（ブロック・サイズ）をビット単位で$ (2^{10})^2 = 1024^2 $ = 1M(1Mibit)と指定し、count=でスワップ・ファイルの総量をbs=で指定したブロック単位で$ 2^{10} \times 8 = 8192 $と指定した。この操作にも管理者権限が必要となる。

# dd if=/dev/zero of=/swapfile bs=1M count=8192

bs=1Mはbs=1048576と指定しても同じ。ただしbs=1MBと指定すると1048576ではなく1000000を意味する。

ルート・ディレクトリ直下にスワップ・ファイルswapfileが作成されたかどうかをコマンドlsを使って確認。オプションの-lによってファイル・パーミッション（ファイルのアクセス許可）も一緒に確認することがきる。

$ ls -al /swapfile
-rw-rw-r-- 1 root root 16777216000 10月 17 11:28 /swapfile

rw-rw-r--の部分がパーミッション情報。左から最初のrw-（読み書き許可）が所有者のアクセス権限、次のrw-（読み書き許可）がグループのアクセス権限、最後のr--（読み込み許可）がその他のユーザーのアクセス権限を意味している。

この状態ではファイルの所有者であるrootのみならずrootというグループに属するユーザーでも読み書きでき、その上、所有者でもなくてグループにも属していないその他のユーザーの権限でも読み込みができてしまうので安全でない。安全性を確保するためにファイル・パーミッション（許可）の設定を変更する必要があった。

ファイルのアクセス許可を変更

ファイル・パーミッションを変更するには/swapfileを対象に外部コマンドchmodを使う。この操作には管理者権限が必要。

# chmod 600 /swapfile
$ ls -al /swapfile
-rw------- 1 root root 16777216000 10月 17 11:28 /swapfile

chmodの第一引数600はパーミッションを8進数で表したもの。

ちなみにパーミッションを8進数で表すための対応表は次のとおり。

ファイルのパーミッションと8進数の対応表
パーミッション	8進数
---	0
--x	1
-w-	2
-wx	3
r--	4
r-x	5
rw-	6
rwx	7

/etc/fstabを編集

次に/etc/fstabファイルを編集する。重要な設定ファイルなので編集する前にcpコマンドによってコピーを作成しておいた。編集のためにここではGNU nanoというエディタを利用した。管理者権限でfeatherpadを利用してもいいと思う。

# cp /etc/fstab /etc/fstab.bak
# nano /etc/fstab

ここでやったのは/etc/fstabファイルの最終行に次の行を追加すること。#が行頭にある行はコメント行であることを意味している。2行目の各項目の間がタブキーで区切ってあることに注意。

# Swap file created on DATE
/swapfile       none    swap    sw      0       0

エディタGnu nanoの操作はキーボードの[Ctrl]キーと何らかの文字キーを組み合わせて行う。GNU nanoを起動すると画面の下のほうに^Gや^Xといったキーとそれがどんな処理を意味するかが表示される。それに基づいて操作すればいい。それ以外の操作は一般的なテキスト・エディタと同様。ちなみに^Gは[Ctrl]キーを押したまま[G]キーを押すことを意味している。

スワップ領域を準備してから有効化

最後の手順としてスワップファイルを有効にするために/swapfileを対象にして外部コマンドの/sbin/swaponを実行する。この操作にも管理者権限が必要。

# /sbin/swapon /swapfile
swapon: /swapfile: スワップヘッダの読み込みに失敗しました

ところがここでエラーが生じた。どうやらその前に外部コマンドの/sbin/mkswapによってスワップの領域の準備する手順が必要だったようだ。この操作にも管理者権限が必要となる。

# /sbin/mkswap /swapfile
スワップ空間バージョン 1 を設定します。サイズ = 15.6 GiB (16777211904 バイト)
ラベルはありません, UUID=**********************************

再び/sbin/swaponを実行。

# /sbin/swapon /swapfile

オプションの-aを使うと/etc/fstabファイルにswapマークとともに記述されているスワップ・デバイスの全てが対象になる。ただしnoautoと記述されているスワップ・デバイスは除く。

# /sbin/swapon -a

で、メモリを確認してみた。

$ free
               total        used        free      shared  buff/cache   available
Mem:         7810936     4680752      451496      371720     3331768     3130184
Swap:        8388604           0     8388604

Swap:行のtotal列がスワップ領域のメモリ・サイズ。これでうまくいったようだ。

スワップ領域を無効化

/sbin/swaponでスワップを有効にした後、/swapfileファイル作成からこれらの作業をやり直すにはスワップを無効化する必要がある。スワップを無効化するには外部コマンドの/sbin/swapoffを使う。この際にも管理者権限が必要。

# /sbin/swapoff /swapfile

オプションの-aを指定すると/etc/fstabファイルに記述されているswapマークを付けられているスワップ・デバイスの全てが対象になる。ただしnoautoと記述されているスワップ・デバイスは除く。

# /sbin/swapoff -a

スワップ・ファイル/swapfileを削除するには外部コマンドrmを使って次のようにする。これにも管理者権限が必要。

# rm -f /swapfile

ここでオプションの-fは存在しないファイルを無視するための指定。

参考にしたサイトや利用したソフトウェア

Debian公式サイトのWikiのSwap領域に関するページ

GNU nanoの公式サイト

n進数と基数変換

2025-08-11T03:28:00.010+09:00

10進数

0から9までの数字を使い、1から9まで数えたら位を1つ上げて（桁を1つ増やして）10にする数え方が一般に行われている。こうした数え方は10進法（しんほう）と呼ばれ、それらの数は10進数（しんすう）と呼ばれている。この数え方は、人が自分の手の指を使って物を数えるのに適していたため、そこから生まれたと考えらている。

0, 1, 2, 3, 4, 5, 6, 7, 8, 9まで数えたらその次が10となり、11, 12, ..., 19まで数えたらその次が20となり、99まで数えたらその次が100となり、999まで数えたらその次が1000となる。桁をこのように増やしてゆくことで限られた数字で無限の数を表現することができる。このような記数法は10進の位取（くらいど）り記数法（きすうほう）と呼ばれている。

\begin{align*} 1 + 9 &= 10 \\ \vdots \\ 19 + 1 &= 20 \\ \vdots \\ 29 + 1 &= 30 \\ \vdots \\ 99 + 1 &= 100 \\ \vdots \\ 199 + 1 &= 200 \\ \vdots \\ 999 + 1 &= 1000 \\ \vdots \end{align*}

漢字で二千四百六十八という数は、一の位が8つで、十の位が6つで、百の位が4つで、千の位が2つであることを意味している。アラビア数字による位取り記数法では2468のように記され、漢字では記されていた千、百、十という各位を表す文字が記されない。しかし、例えば2468は$ 2 + 4 + 6 + 8 $であることを意味しているわけではなく$ 2000 + 400 + 60 + 8 $であることを意味している。

\[ 2468 \neq 2 + 4 + 6 + 8 \]

\begin{align*} 2468 &= 2000 + 400 + 60 + 8 \\ &= 2 \times 1000 + 4 \times 100 + 6 \times 10 + 8 \times 1 \\ &= 2 \times 10^3 + 4 \times 10^2 + 6 \times 10^1 + 8 \times 10^0 \end{align*}

$ \neq $は等しくないという意味である。この二つ目の数式にある$ 10^3 = 1000,\ 10^2 = 100,\ 10^1 = 10,\ 10^0 = 1 $が各桁の数字が属している位（くらい）であり、それらはそれぞれ千の位、百の位、十の位、一の位または桁けたと呼ばれている。各位が持っている千、百、十、一という値を数学では桁値（けたち）と呼ぶが、計算機科学の世界では重みと呼ばれている。桁のそれぞれの数字はその桁値だけ倍にした数を表している。

2進数

電子計算機やコンピュータの内部では、電圧の高低差を利用した2進法による計算が行わている。2進法は0と1という2つの数字だけを使って表されている。2進法では、0, 1, 10, 11, 100, 101, 110, 111, 1000, ...のように桁が増えてゆく。これは2進の位取り記数法である。

\begin{align*} 1 + 1 &= 10 \\ 10 + 1 &= 11 \\ 11 + 1 &= 100 \\ 101 + 1 &= 110 \\ 110 + 1 &= 111 \\ 111 + 1 &= 1000 \\ \vdots \end{align*}

2進法では、10は「ジュー」と読むのではなく「イチゼロ」と読む。同様に11は「ジューイチ」ではなく「イチイチ」、100は「ヒャク」ではなく「イチゼロゼロ」、111は「イチイチイチ」と電話番号のように読む。

例えば、2進数の1101「イチイチゼロイチ」を多項式にして表せば、次のような数であることを意味している。

\begin{align*} 1101 &= 1 \times 10^3 + 1 \times 10^2 + 0 \times 10^1 + 1 \times 10^0 \\ &= 1 \times 1000 + 1 \times 100 + 0 \times 10 + 1 \times 1 \\ &= 1000 + 10 + 0 + 1 \end{align*}

ただし、2進法での桁値である例えば1000, 100, 10は、漢字でいうところの千、百、十を意味するのではない。2進数での1000は「イチゼロゼロゼロ」、100は「イチゼロゼロ」、10は「イチゼロ」という桁値を持っていることになる。

2進数の1桁は、計算機科学、情報数学、情報工学の分野ではビットという単位で呼ばれている。C言語などのプログラミング言語では1011BのようにBを添えて2進数であることを示す。Bは2進数を表す英語binary numberの頭文字bによる。

2進数を10進数への変換

桁値を理解することが10進数へと他の進数を変換するために役立つ。次の数式は2進数である1101をそれに対応する10進数へと変換している多項式である。ここでは$ = $の代わりに$ \rightarrow $という記号を使って2進数と10進数との間の対応関係を表している。下の式の計算結果から2進数の1101が10進数では13に対応していることが分かる。

\begin{align*} (1101)_2 & \rightarrow (1 \times 2^3 + 1 \times 2^2 + 0 \times 2^1 + 1 \times 2^0)_{10} \\ & \rightarrow (1 \times 8 + 1 \times 4 + 0 \times 2 + 1 \times 1)_{10} \\ & \rightarrow (1 \times 8 + 1 \times 4 + 0 + 1 \times 1)_{10} \\ & \rightarrow (8 + 4 + 0 + 1)_{10} \\ & \rightarrow (13)_{10} \end{align*}

上の数式では、$ \rightarrow $の左辺が2進数であり、$ \rightarrow $の右辺が10進数である。2進数であることを$ (...)_2 $と表し、10進数であることを$ (...)_{10} $と表している。2進数である1101は10進数では13に対応している。2進数のそれぞれの位の重み、すなわち桁値を10進数で表すと、$ 2^3 = 8,\ 2^2 = 4,\ 2^1 = 2,\ 2^0 = 1$になることが分かる。2進数でのそれぞれの桁が10進数ではこのような重みを持っていることを理解していれば、2進数から10進数への変換は簡単な算術でたやすく行える。

2進数と10進数の対応表

次の表は2進数と10進数の対応関係を示している。この表から2進数の1101が10進数の13に対応することが見て取れる。

2進数と10進数の対応関係
2進数	10進数
0	0
1	1
10	2
11	3
100	4
101	5
110	6
111	7
1000	8
1001	9
1010	10
1011	11
1100	12
1101	13
1110	14
1111	15
10000	16
10001	17
10010	18
10011	19
10100	20
10101	21
10110	22
10111	23
11000	24
11001	25
11010	26
11011	27
11100	28
11101	29
11110	30
11111	31
100000	32
100001	33
100010	34
100011	35
100100	36
100101	37
100110	38
100111	39
101000	40
101001	41
101010	42
101011	43
101100	44
101101	45
101110	46
101111	47
110000	48
110001	49
110010	50
110011	51
110100	52
110101	53
110110	54
110111	55
111000	56
111001	57
111010	58
111011	59
111100	60
111101	61
111110	62
111111	63
1000000	64
1000001	65
1000010	66
1000011	67
1000100	68
1000101	69
1000110	70
1000111	71
1001000	72
1001001	73
1001010	74
1001011	75
1001100	76
1001101	77
1001110	78
1001111	79
1010000	80
1010001	81
1010010	82
1010011	83
1010100	84
1010101	85
1010110	86
1010111	87
1011000	88
1011001	89
1011010	90
1011011	91
1011100	92
1011101	93
1011110	94
1011111	95
1100000	96
1100001	97
1100010	98
1100011	99
1100100	100
1100101	101
1100110	102
1100111	103
1101000	104
1101001	105
1101010	106
1101011	107
1101100	108
1101101	109
1101110	110
1101111	111
1110000	112
1110001	113
1110010	114
1110011	115
1110100	116
1110101	117
1110110	118
1110111	119
1111000	120
1111001	121
1111010	122
1111011	123
1111100	124
1111101	125
1111110	126
1111111	127
10000000	128

上の表においてもう一つ注目すべき点は、この表から2進数の桁値を10進数で表したときの値が見て取れることである。2進数の1が10進数では1、2進数の10が10進数では2、2進数の100が10進数では4、2進数の1000が10進数では8になっている。2進数で桁が増えているところでの10進数の値を見れば、2進数のそれぞれの位を10進数で表した場合の桁値が判断できる。その対応関係は次の表の通りになる。

2進数の位を10進数での桁値で表すと
2進数	10進数	10進冪乗
1	1	$ 2^0 $
10	2	$ 2^1 $
100	4	$ 2^2 $
1000	8	$ 2^3 $
10000	16	$ 2^4 $
100000	32	$ 2^5 $
1000000	64	$ 2^6 $
10000000	128	$ 2^7 $

2進数で位が増えたところの10進数での値を見ると、2進数の各位の重み（桁値）を10進数で表した値が直前の数の2倍ずつ増えていることが、この表から見て取れる。これは初項（しょこう）が1、公比（こうひ）が2の等比数列である。初項は最初の数、公比の2はこの数列が常に2倍ずつ増えていることによる。

\[ \begin{array}{c} & 1 & 2 & 4 & 8 & 16 & 32 & 64 & 128 & ... \\ & 2^0 & 2^1 & 2^2 & 2^3 & 2^4 & 2^5 & 2^6 & 2^7 & ... \end{array} \]

冪乗（べきじょう）で表したとき、全ての桁値に共通する2の数字は基底（きてい）または単に底（そこ）と呼ばれている。計算機科学ではこれを基数（きすう）と呼ぶことが多いが、数学でいう集合数のことではない。英語ではbaseまたはradix。2進数の2はここから来ている。10進数は10を基底とする進法である。さらに、等比数列の特徴として、基数の右上の指数（しすう）が0から順に0, 1, 2, 3, 4, 5, ...と増えていることがこの表から見て取れる。

ちなみに、$ a = b^i $と表されるとき、指数の形で表されているこのiの値はbを基底とするaの値の対数（たいすう）とも呼ばれている。例えば$ 2^7 $の指数7は2を基底とする128の対数と呼び、$ 2^5 $の指数5は2を基底とする32の対数と呼ぶ。それぞれ次のように書く。

\[ \log_2 128 = 7,\ \log_2 32 = 5 \]

冪乗に関するちょっとした注意

冪乗べきじょうは基底部（きていぶ）と指数部（しすうぶ）から成っている。基底部の数を$ r $としたとき、冪乗とは次のような演算を簡略に表記したものである。ちなみにrは基数を意味するradixの頭文字。

\begin{align*} r^2 &= r \times r \\ r^4 &= r \times r \times r \times r \end{align*}

ただし、$ r $の0乗と$ r $の1乗はそれぞれ次のようになることに注意が必要である。

\begin{align*} r^0 &= 1 \\ r^1 &= r \end{align*}

なぜなら、冪乗は厳密には次のような演算を意味するからである。

\begin{align*} r^0 &= 1 \\ r^1 &= 1 \times r = r \\ r^2 &= 1 \times r \times r \\ r^3 &= 1 \times r \times r \times r \\ r^4 &= 1 \times r \times r \times r \times r \end{align*}

累乗るいじょうと冪乗の違いは累乗の指数部が0を含まない自然数に限られること。冪乗には指数部が小数や分数である分数乗や指数部が円周率である無理数乗までもが含まれる。冪乗は累乗を拡張したものだと言えるのかもしれない。

8進数や12進数を10進数へと変換

例えば8進法や12進数でも同様のことが成り立つ。8進法は0から7までの数字で表す位取り記数法であり、12進法は0から9、そしてTとEまでの英数字で表す位取り記数法である。TはtenのTで10進数で10に対応し、EはelevenのEで10進数で11に対応する。

2進数の場合と同様の方法で8進数や12進数を10進数へと変換することができる。ここでは$ (...)_r $という形でr進数であることを示す。rはradixのrで、rには任意の自然数（しぜんすう）が入る。ここでは例として8進数と12進数を表すので、それぞれのrに8と12が入っている。

\begin{align*} (2308)_8 & \rightarrow (2 \times 8^3 + 3 \times 8^2 + 0 \times 8^1 + 8 \times 8^0)_{10} \\ & \rightarrow (2 \times 512 + 3 \times 64 + 0 \times 8 + 8 \times 1)_{10} \\ & \rightarrow (1024 + 192 + 0 + 8)_{10} \\ & \rightarrow (1216 + 8)_{10} \\ & \rightarrow (1224)_{10} \end{align*}

\begin{align*} (3TE)_{12} & \rightarrow (3 \times 12^2 + 10 \times 12^1 + 11 \times 12^0)_{10} \\ & \rightarrow (3 \times 144 + 10 \times 12 + 11 \times 1)_{10} \\ & \rightarrow (432 + 120 + 11)_{10} \\ & \rightarrow (552 + 11)_{10} \\ & \rightarrow (563)_{10} \\ \end{align*}

これらの計算のとおり、、8進数の2308を10進数に変換すると10進数の1224になり、12進数の3TEを10進数に変換すると10進数の563になることが分かる。

8進数と12進数の桁値は次のような対応表になる。

8進数の位を10進数での桁値で表すと
8進数	10進数	10進冪乗	10進対数
1	1	$ 8^0 $	0
10	8	$ 8^1 $	1
100	64	$ 8^2 $	2
1000	512	$ 8^3 $	3
10000	4096	$ 8^4 $	4
100000	32768	$ 8^5 $	5
1000000	262144	$ 8^6 $	6
10000000	2097152	$ 8^7 $	7
100000000	16777216	$ 8^8 $	8

12進数の位を10進数での桁値で表すと
12進数	10進数	10進冪乗	10進対数
1	1	$ 12^0 $	0
10	12	$ 12^1 $	1
100	144	$ 12^2 $	2
1000	1728	$ 12^3 $	3
10000	20736	$ 12^4 $	4
100000	248832	$ 12^5 $	5
1000000	2985984	$ 12^6 $	6
10000000	35831808	$ 12^7 $	7
100000000	429981696	$ 12^8 $	8

小数の場合

小数ではどうか。例えば10進数の小数0.123は次のような多項式に表すことができる。マイナスの指数を持つ冪乗は小数を表している。

\begin{align*} 0.123 &= 0.1 + 0.02 + 0.003 \\ &= \dfrac{1}{10} + \dfrac{2}{100} + \dfrac{3}{1000} \\ &= 1 \times 0.1 + 2 \times 0.01 + 3 \times 0.001 \\ &= 1 \times \dfrac{1}{10} + 2 \times \dfrac{1}{100} + 3 \times \dfrac{1}{1000} \\ &= 1 \times \dfrac{1}{10} + 2 \times \dfrac{1}{10^2} + 3 \times \dfrac{1}{10^3} \\ &= 1 \times 10^{-1} + 2 \times 10^{-2} + 3 \times 10^{-3} \end{align*}

10進数の整数＋小数の数75.29を多項式に表すと次のようになる。

\begin{align*} 75.29 &= 70 + 5 + 0.2 + 0.09 \\ &= 7 \times 10 + 5 \times 1 + 2 \times 0.1 + 9 \times 0.01 \\ &= 7 \times 10 + 5 \times 1 + 2 \times \dfrac{1}{10} + 9 \times \dfrac{1}{100} \\ &= 7 \times 10 + 5 \times 1 + 2 \times \dfrac{1}{10^1} + 9 \times \dfrac{1}{10^2} \\ &= 7 \times 10^1 + 5 \times 10^0 + 2 \times 10^{-1} + 9 \times 10^{-2} \end{align*}

したがって、2進数の小数0.101を10進数に変換するには次のように計算すればよい。2進数の各桁値を10進数の冪乗で表したとき、基底の数（基数）は10ではなく2になる。この計算結果から、2進数の0.101は10進数では0.625だと分かる。

\begin{align*} (0.101)_2 & \rightarrow (1 \times 2^{-1} + 0 \times 2^{-2} + 1 \times 2^{-3})_{10} \\ & \rightarrow \left(1 \times \dfrac{1}{2} + 0 \times \dfrac{1}{2^2} + 1 \times \dfrac{1}{2^3} \right)_{10} \\ & \rightarrow (1 \times 0.5 + 0 \times 0.25 + 1 \times 0.125)_{10} \\ & \rightarrow (0.5 + 0 + 0.125)_{10} \\ & \rightarrow (0.625)_{10} \end{align*}

2進数の小数の各桁値を表にしてみるとこうなる。

2進小数の各位の10進数での桁値
2進数	10進数	10進冪乗	10進分数	10進対数
0.1	0.5	$ 2^{-1} = 0.5^1 $	$ \dfrac{1}{2^1} $	-1
0.01	0.25	$ 2^{-2} = 0.5^2 $	$ \dfrac{1}{2^2} $	-2
0.001	0.125	$ 2^{-3} = 0.5^3 $	$ \dfrac{1}{2^3} $	-3
0.0001	0.0625	$ 2^{-4} = 0.5^4 $	$ \dfrac{1}{2^4} $	-4
0.00001	0.03125	$ 2^{-5} = 0.5^5 $	$ \dfrac{1}{2^5} $	-5
0.000001	0.015625	$ 2^{-6} = 0.5^6 $	$ \dfrac{1}{2^6} $	-6
0.0000001	0.0078125	$ 2^{-7} = 0.5^7 $	$ \dfrac{1}{2^7} $	-7
0.00000001	0.00390625	$ 2^{-8} = 0.5^8 $	$ \dfrac{1}{2^8} $	-8

マイナスの指数を持つ冪乗

$ r $のマイナス$ i $乗は次のような意味を表している。$ = $は左右が互いに等しいことを示す。$ r $は基底を意味する英語radix――base of numberとも言う――のr、$ i $は指数を意味する英語indexのi。

\[ r^{-i} = \dfrac{1}{r^i} = 1 \div r^i \]

$ i $に具体的な数を代入（だいにゅうして表すとこうなる。

\begin{align*} r^{-1} &= \dfrac{1}{r} = 1 \div r \\ r^{-2} &= \dfrac{1}{r^2} = 1 \div r^2 \\ r^{-3} &= \dfrac{1}{r^3} = 1 \div r^3 \\ r^{-4} &= \dfrac{1}{r^4} = 1 \div r^4 \\ r^{-5} &= \dfrac{1}{r^5} = 1 \div r^5 \\ r^{-6} &= \dfrac{1}{r^6} = 1 \div r^6 \\ r^{-7} &= \dfrac{1}{r^7} = 1 \div r^7 \\ & \hspace{2em} \vdots \end{align*}

指数部がマイナスになっている冪乗は、1以下0以上の数、すなわち小数を表している。

r進数から10進数への変換

r進数からその数に対応する10進数への数の変換は、一般に次のようにして計算することができる。見やすくするために各位の計算を表している各項を括弧（かっこ）でくくった。

\begin{align*} I_n \rightarrow \sum_{i=0}^{n-1} (a_i \times r^{i}) &= (a_0 \times r^0) + (a_1 \times r^1) + (a_2 \times r^2) + ... + (a_n \times r^{n-1}) \end{align*}

$ I_n $のIは整数を表す英語integerの頭文字、添え字のnは桁数を表す。$ r $とは基底を表す英語radixの頭文字（かしらもじ）であり、2進数の場合は2、5進数の場合は5が入る。その添え字のnは与えられた数の桁数を表している。$ \sum $はサメーション、つまり合計のことであり、ギリシア文字でシグマと読む。$ a $は与えられた数の各位にある数字、$ n $は与えられた数の桁の数のことで、0から数えるので$ n $から1を引いてある。$ k $は桁値を冪乗で表したときの指数を表し、低い位から何桁目かを指している。サメーションの下の$ k=0 $は0から始まることを表し、サメーションの上の$ n $（任意の自然数）はその数の桁数回足し算が続くことを意味している。足し算なので交換法則（こうかんほうそく）、すなわち足す順番が自由でよいという法則が成り立ち、計算の順番を逆にしても同じ値が得られる。

小数の場合は次のようになる。

\begin{align*} \sum_{j=1}^{m} (a_{-j} \times r^{-j}) &= (a_{-1} \times r^{-1}) + (a_{-2} \times r^{-2}) + (a_{-3} \times r^{-3}) + ... + (a_{-m} \times r^{-m}) \\ &= \left(a_{-1} \times \dfrac{1}{r} \right) + \left(a_{-2} \times \dfrac{1}{r^2} \right) + \left(a_{-3} \times \dfrac{1}{r^3} \right) + ... + \left(a_{-m} \times \dfrac{1}{r^m} \right) \end{align*}

整数部と小数部を両方持つ数の場合はこう一般化できる。

\[ \sum_{i=0}^{n-1} (a_i \times r^{i}) + \sum_{j=1}^{m} (a_{-j} \times r^{-j}) \]

数学の文字式では普通、掛け算の演算記号$ \times $または$ \cdot $を省略するので次のように書ける。

\begin{align*} \sum_{i=0}^{n-1} a_i r^{i} &= a_0 r^0 + a_1 r^1 + a_2 r^2 + ... + a_n r^{n-1} \end{align*}

\begin{align*} \sum_{j=1}^{m} a_{-j} r^{-j} &= a_{-1} r^{-1} + a_{-2} r^{-2} + a_{-3} r^{-3} + \dots + a_{-m} r^{-m} \\ &= a_{-1} \dfrac{1}{r} + a_{-2} \dfrac{1}{r^2} + a_{-3} \dfrac{1}{r^3} + \dots + a_{-m} \dfrac{1}{r^m} \end{align*}

整数部と小数部を両方持つ数の場合は次のとおり。

\[ \sum_{i=0}^{n-1} a_i r^{i} + \sum_{j=1}^{m} a_{-j} r^{-j} = \sum_{k=-m}^{n-1} a_k r^k \]

数学記号と数式で表現するとなんだか難しく見えてしまうけれども、その変換規則は各桁を表す定数（係数）にr進数の基数の冪乗を掛けてそれらの値の合計を求める式だから簡単。

ちなみに、この文字式は多項式のように見えるが、小数部の変数rの指数に正数でなく負数が使われているために通常の多項式の条件を満たさない。したがって通常の多項式とは区別されてローラン多項式と呼ばれている。

\[ \begin{array}{r:l} i & \text{番号を表す変数} \\ i = 1 & \text{下限値} \\ n & \text{上限値} \\ a_i & \text{i番目の係数（定数）} \\ r^{-i} & \text{負数の指数を持つ変数} \\ \end{array} \] \[ \sum_{i=1}^n a_i r^{-i} \]

したがって位取り記数法によって表された数値は、整数部は多項式として展開できるが、小数部はローラン多項式として展開できる。

あるr進数から別のr進数への変換は基数変換（きすうへんかん）と呼ばれている。

16進数

計算機科学の中では、2進数を人がより扱いやすくするために16進数を用いて表すことが多い。16進数の表記にはアラビア数字の0〜9とローマ字の大文字A〜Fか小文字a〜fが使われている。

2/4/8/16進数と10進数の対応関係
2進数	4進数	8進数	16進数	10進数
0	0	0	0	0
1	1	1	1	1
10	2	2	2	2
11	3	3	3	3
100	10	4	4	4
101	11	5	5	5
110	12	6	6	6
111	13	7	7	7
1000	20	10	8	8
1001	21	11	9	9
1010	22	12	A	10
1011	23	13	B	11
1100	30	14	C	12
1101	31	15	D	13
1110	32	16	E	14
1111	33	17	F	15
10000	40	20	10	16
10001	41	21	11	17
10010	42	22	12	18
10011	43	23	13	19
10100	50	24	14	20
10101	51	25	15	21
10110	52	26	16	22
10111	53	27	17	23
11000	60	30	18	24
11001	61	31	19	25
11010	62	32	1A	26
11011	63	33	1B	27
11100	70	34	1C	28
11101	71	35	1D	29
11110	72	36	1E	30
11111	73	37	1F	31
100000	80	40	20	32

16進数を10進数へ基数変換

例えば16進数の数8C1を10進数へと基数変換してみる。16進数なので基底16、8C1なので3桁。これらを先程の公式$ \sum_{i=0}^{n-1} x_i r^{i} $の変数$ r $と$ n $にそれぞれ代入すると、$ r = 16 $、$ n = 3 $となる。16進数のCは10進数では12に当たるので12として計算する。したがって次のように計算することができる。この計算結果から、16進数の8C1が10進数では2257に対応することが分かる。

\begin{align*} (8C1)_{16} & \rightarrow (1 \times 16^0 + 12 \times 16^1 + 8 \times 16^2)_{10} \\ & \rightarrow (1 \times 1 + 12 \times 16 + 8 \times 256)_{10} \\ & \rightarrow (1 + 192 + 2048)_{10} \\ & \rightarrow (193 + 2048)_{10} \\ & \rightarrow (2241)_{10} \end{align*}

小数点を持つ16進数の2F.5Aを10進数に基数変換するには、次のように計算することができる。16進数のFは10進数では15、16進数のAは10進数では10なので、その数に置き換えて計算する。

\begin{align*} (2F.5A)_{16} & \rightarrow (2 \times 16^1 + 15 \times 16^0 + 5 \times 16^{-1} + 10 \times 16^{-2})_{10} \\ & \rightarrow \left(2 \times 16 + 15 \times 1 + 5 \times \dfrac{1}{16} + 10 \times \dfrac{1}{16^2} \right)_{10} \\ & \rightarrow \left(32 + 15 + 5 \times 0.0625 + 10 \times \dfrac{1}{256} \right)_{10} \\ & \rightarrow (47 + 0.3125 + 10 \times 0.00390625)_{10} \\ & \rightarrow (47.3125 + 0.0390625)_{10} \\ & \rightarrow (47.3515625)_{10} \end{align*}

16進数の位を10進数での桁値で表すと
16進数	10進数	10進冪乗	10進対数
0.0001	0.00001525879	$ 16^{-4} $	-4
0.001	0.0002441406	$ 16^{-3} $	-3
0.01	0.00390625	$ 16^{-2} $	-2
0.1	0.0625	$ 16^{-1} $	-1
1	1	$ 16^0 $	0
10	16	$ 16^1 $	1
100	256	$ 16^2 $	2
1000	4096	$ 16^3 $	3
10000	65536	$ 16^4 $	4
100000	1048576	$ 16^5 $	5
1000000	16777216	$ 16^6 $	6
10000000	268435456	$ 16^7 $	7
100000000	4294967296	$ 16^8 $	8

10進数から16進数への基数変換

上の二つの計算が正しかったかどうか検算（けんざん）するために10進数から16進数への基数変換をしてみる。

10進数からr進数への基数変換には剰余演算を用いることができる。剰余演算は計算機科学ではモジュロ演算とも呼ばれている。

10進数の数を変換したい16進数の基数（基底）である16で割っていき、答が0になるまで繰り返せば、それらの余りが対応する16進数の各桁の値になる。この計算から10進数の2241は16進数の8C1に対応することが分かる。この計算法は連続除法や剰余法と呼ばれることがある。

\begin{align*} (2241 \div 16 \rightarrow \colorbox{yellow}{140} \text{ 余り} \colorbox{cyan}{1})_{10} & \rightarrow (\colorbox{cyan}{1} \times 1 = \colorbox{lime}{1})_{16} \\ (\colorbox{yellow}{140} \div 16 \rightarrow \colorbox{yellow}{8} \text{ 余り} \colorbox{cyan}{12})_{10} & \rightarrow (\colorbox{cyan}{C} \times 10 = \colorbox{lime}{C0})_{16} \\ (\colorbox{yellow}{8} \div 16 \rightarrow 0 \text{ 余り} \colorbox{cyan}{8})_{10} & \rightarrow (\colorbox{cyan}{8} \times 100 = \colorbox{lime}{800})_{16} \end{align*} \[ \therefore (2241)_{10} \rightarrow (\colorbox{lime}{1} + \colorbox{lime}{C0} + \colorbox{lime}{800} = 8C1)_{16} \]

上の式ではちょっとわかりにくいので計算の手続きを筆算風の表にしてみた。最初の余りが16進数の1の位に、2番目の余りが16進数の10の位に、3番目の余りが16進数の100の位に、それぞれ対応している。

\[ \begin{array}{r|l:l} \text{割る数} & \text{割られる数} & \text{余り} \\ 16 & 2241 & \\ \hline 16 & 140 & 1 \\ \hline 16 & 8 & 12 \rightarrow C \\ \hline & 0 & 8 \end{array} \] \[ \therefore (8C1)_{16} \]

次に、10進数の47.3515625を16進数に基数変換する。この場合、整数部と小数部を分けて考え、それぞれ別の方法で求める。整数部は16進数の基底である16で割る計算を繰り返し、それぞれの余りの値が16進数に変換したときの各桁の値になる。

小数部は逆に16を掛ける計算をする。その答えから整数部を取り除いた値にさらに16を掛ける。そしてその計算を繰り返す。答えの値から小数部がなくなれば計算を終了。それらの答えの整数部の値が16進数に変換したときの各桁の値になる。桁の並べ方が整数部とは逆順（上から下へ）になるので要注意。

まずは整数部から。10進数の15は16進数ではF。整数部は16進数で2Fと求まる。

\begin{align*} (47 \div 16 = \colorbox{yellow}{2} \text{ 余り} \colorbox{cyan}{15})_{10} & \rightarrow (\colorbox{cyan}{F} \times 1 = \colorbox{lime}{F})_{16}\} \\ (\colorbox{yellow}{2} \div 16 = 0 \text{ 余り} \colorbox{cyan}{2})_{10} & \rightarrow (\colorbox{cyan}{2} \times 10 = \colorbox{lime}{20})_{16} \end{align*} \[ \therefore (47)_{10} \rightarrow (\colorbox{lime}{F} + \colorbox{lime}{20} = 2F)_{16} \]

筆算風の表にして表すと次のように計算できる。

\[ \begin{array}{r|l:l} \text{割る数} & \text{割られる数} & \text{余り} \\ \hline 16 & 47 & \\ \hline 16 & 2 & 15 \rightarrow F \\ \hline & 0 & 2 \end{array} \] \[ \therefore (2F)_{16} \]

そして小数部。10進数の10は16進数ではA。小数部は16進数でA5と求まる。

\begin{align*} (0.3515625 \times 16 = \colorbox{cyan}{5}\colorbox{yellow}{.625})_{10} & \rightarrow (\colorbox{cyan}{5} \times \dfrac{1}{16^1} = \colorbox{lime}{0.5})_{16} \\ (\colorbox{yellow}{0.625} \times 16 = \colorbox{cyan}{10}.0)_{10} & \rightarrow (\colorbox{cyan}{10} \times \dfrac{1}{16^2} = \colorbox{lime}{0.0A})_{16} \end{align*} \[ \therefore (0.3515625)_{10} \rightarrow (\colorbox{lime}{0.5} + \colorbox{lime}{0.0A} = 0.5A)_{16} \]

筆算風の表で表すと次のようになる。

\[ \begin{array}{r|l:l} 掛ける数 & 掛けられる数 & 差し引いた整数部 \\ \hline 16 & 0.3515625 \\ \hline 16 & 0.625 & 5 \\ \hline 16 & 0 & 10 \rightarrow A \end{array} \] \[ \therefore (0.5A)_{16} \]

整数部の計算結果と小数部の計算結果を足し合わせると、16進数の2F.A5が求まることが分かる。

\[ \therefore (2F + 0.5A = 2F.5A)_{16} \]

10進数から2進数への基数変換

10進数から2進数への基数変換も、整数部、小数部ともに同様の方法で計算することができる。例えば、10進数の87.53を2進数に基数変換するには、次のように計算する。整数部と小数部でそれぞれ別々の計算方法を用いる。

10進数の整数部を変換したい2進数の基底数である2で割り、その答えを更に2で割る。この計算を答えが0になるまで繰り返す。このときの余りの値は0か1のいずれかになる。それらの余りの値を小さい桁から順番に並べれば2進数へと変換した整数部の値になる。

10進数の小数部には変換したい2進数の基底数である2を掛け、その答えの小数部だけを取り出し、その小数に更に2を掛ける。この計算を答えが整数部だけになるまで繰り返す。掛け算の各計算の答えの整数部は0か1のいずれかになる。この整数部を大きい桁から順番に並べていけば2進数へと変換された小数部になる。最後に整数部と小数部を足しあわせれば計算が完了する。

\begin{align*} (87 \div 2 \rightarrow \colorbox{yellow}{43} \text{ 余り} \colorbox{cyan}{1})_{10} & \rightarrow (\colorbox{cyan}{1} \times 10^0 = \colorbox{lime}{1})_2 \\ (\colorbox{yellow}{43} \div 2 \rightarrow \colorbox{yellow}{21} \text{ 余り} \colorbox{cyan}{1})_{10} & \rightarrow (\colorbox{cyan}{1} \times 10^1 = \colorbox{lime}{10})_2 \\ (\colorbox{yellow}{21} \div 2 \rightarrow \colorbox{yellow}{10} \text{ 余り} \colorbox{cyan}{1})_{10} & \rightarrow (\colorbox{cyan}{1} \times 10^2 = \colorbox{lime}{100})_2 \\ (\colorbox{yellow}{10} \div 2 \rightarrow \colorbox{yellow}{5} \text{ 余り} \colorbox{cyan}{0})_{10} & \rightarrow (\colorbox{cyan}{0} \times 10^3 = 0)_2 \\ (\colorbox{yellow}{5} \div 2 \rightarrow \colorbox{yellow}{2} \text{ 余り} \colorbox{cyan}{1})_{10} & \rightarrow (\colorbox{cyan}{1} \times 10^4 = \colorbox{lime}{10000})_2 \\ (\colorbox{yellow}{2} \div 2 \rightarrow \colorbox{yellow}{1} \text{ 余り} \colorbox{cyan}{0})_{10} & \rightarrow (\colorbox{cyan}{0} \times 10^5 = 0)_2 \\ (\colorbox{yellow}{1} \div 2 \rightarrow 0 \text{ 余り} \colorbox{cyan}{1})_{10} & \rightarrow (\colorbox{cyan}{1} \times 10^6 = \colorbox{lime}{1000000})_2 \end{align*} \[ \therefore (87)_{10} \rightarrow (\colorbox{lime}{1} + \colorbox{lime}{10} + \colorbox{lime}{100} + \colorbox{lime}{10000} + \colorbox{lime}{1000000} = 1010111)_2 \]

筆算風に表すと次のように書ける。

\[ \begin{array}{r|l:l} \text{割る数} & \text{割られる数} & \text{余り} \\ \hline 2 & 87 \\ \hline 2 & 43 & 1 \\ \hline 2 & 21 & 1 \\ \hline 2 & 10 & 1 \\ \hline 2 & 5 & 0 \\ \hline 2 & 2 & 1 \\ \hline 2 & 1 & 0 \\ \hline & 0 & 1 \end{array} \] \[ \therefore (1010111)_{2} \]

次は小数部の計算。

\begin{align*} (0.53 \times 2 = \colorbox{cyan}{1}\colorbox{yellow}{.06})_{10} & \rightarrow (\colorbox{cyan}{1} \times 0.1^1 = \colorbox{lime}{0.1})_2 \\ (\colorbox{yellow}{0.06} \times 2 = \colorbox{cyan}{0}\colorbox{yellow}{.12})_{10} & \rightarrow (\colorbox{cyan}{0} \times 0.1^2 = 0)_2 \\ (\colorbox{yellow}{0.12} \times 2 = \colorbox{cyan}{0}\colorbox{yellow}{.24})_{10} & \rightarrow (\colorbox{cyan}{0} \times 0.1^3 = 0)_2 \\ (\colorbox{yellow}{0.24} \times 2 = \colorbox{cyan}{0}\colorbox{yellow}{.48})_{10} & \rightarrow (\colorbox{cyan}{0} \times 0.1^4 = 0)_2 \\ (\colorbox{yellow}{0.48} \times 2 = \colorbox{cyan}{0}\colorbox{yellow}{.96})_{10} & \rightarrow (\colorbox{cyan}{0} \times 0.1^5 = 0)_2 \\ (\colorbox{yellow}{0.96} \times 2 = \colorbox{cyan}{1}\colorbox{yellow}{.92})_{10} & \rightarrow (\colorbox{cyan}{1} \times 0.1^6 = \colorbox{lime}{0.00001})_2 \\ (\colorbox{yellow}{0.92} \times 2 = \colorbox{cyan}{1}\colorbox{yellow}{.84})_{10} & \rightarrow (\colorbox{cyan}{1} \times 0.1^7 = \colorbox{lime}{0.000001})_2 \\ (\colorbox{yellow}{0.84} \times 2 = \colorbox{cyan}{1}\colorbox{yellow}{.68})_{10} & \rightarrow (\colorbox{cyan}{1} \times 0.1^8 = \colorbox{lime}{0.0000001})_2 \\ (\colorbox{yellow}{0.68} \times 2 = \colorbox{cyan}{1}\colorbox{yellow}{.36})_{10} & \rightarrow (\colorbox{cyan}{1} \times 0.1^9 = \colorbox{lime}{0.00000001})_2 \\ (\colorbox{yellow}{0.36} \times 2 = \colorbox{cyan}{0}\colorbox{yellow}{.72})_{10} & \rightarrow (\colorbox{cyan}{0} \times 0.1^{10} = 0)_2 \\ (\colorbox{yellow}{0.72} \times 2 = \colorbox{cyan}{1}\colorbox{yellow}{.44})_{10} & \rightarrow (\colorbox{cyan}{1} \times 0.1^{11} = \colorbox{lime}{0.0000000001})_2 \\ (\colorbox{yellow}{0.44} \times 2 = \colorbox{cyan}{0}\colorbox{yellow}{.88})_{10} & \rightarrow (\colorbox{cyan}{0} \times 0.1^{12} = 0)_2 \\ (\colorbox{yellow}{0.88} \times 2 = \colorbox{cyan}{1}\colorbox{yellow}{.76})_{10} & \rightarrow (\colorbox{cyan}{1} \times 0.1^{13} = \colorbox{lime}{0.000000000001})_2 \\ (\colorbox{yellow}{0.76} \times 2 = \colorbox{cyan}{1}\colorbox{yellow}{.52})_{10} & \rightarrow (\colorbox{cyan}{1} \times 0.1^{14} = \colorbox{lime}{0.0000000000001})_2 \\ (\colorbox{yellow}{0.52} \times 2 = \colorbox{cyan}{1}\colorbox{yellow}{.04})_{10} & \rightarrow (\colorbox{cyan}{1} \times 0.1^{15} = \colorbox{lime}{0.00000000000001})_2 \\ (\colorbox{yellow}{0.04} \times 2 = \colorbox{cyan}{0}\colorbox{yellow}{.08})_{10} & \rightarrow (\colorbox{cyan}{0} \times 0.1^{16} = 0)_2 \\ (\colorbox{yellow}{0.08} \times 2 = \colorbox{cyan}{0}\colorbox{yellow}{.16})_{10} & \rightarrow (\colorbox{cyan}{0} \times 0.1^{17} = 0)_2 \\ (\colorbox{yellow}{0.16} \times 2 = \colorbox{cyan}{0}\colorbox{yellow}{.32})_{10} & \rightarrow (\colorbox{cyan}{0} \times 0.1^{18} = 0)_2 \\ & \vdots & \end{align*} \begin{align*} \therefore (0.53)_{10} & \rightarrow (\colorbox{lime}{0.1} + \colorbox{lime}{0.00001} \\ & + \colorbox{lime}{0.000001} + \colorbox{lime}{0.0000001} \\ & + \colorbox{lime}{0.0000000001} + \colorbox{lime}{0.000000000001} \\ & + \colorbox{lime}{0.0000000000001} + \colorbox{lime}{0.000000000000001} \\ & + \cdots = 0.100001111010111000...)_{2} \end{align*}

筆算表を使うと次のようになる。

\[ \begin{array}{r|l:l} 掛ける数 & 掛けられる数 & 差し引いた整数部 \\ \hline 2 & 0.53 \\ \hline 2 & 0.06 & 1 \\ \hline 2 & 0.12 & 0 \\ \hline 2 & 0.24 & 0 \\ \hline 2 & 0.48 & 0 \\ \hline 2 & 0.96 & 0 \\ \hline 2 & 0.92 & 1 \\ \hline 2 & 0.84 & 1 \\ \hline 2 & 0.68 & 1 \\ \hline 2 & 0.36 & 1 \\ \hline 2 & 0.72 & 0 \\ \hline 2 & 0.44 & 1 \\ \hline 2 & 0.88 & 0 \\ \hline 2 & 0.76 & 1 \\ \hline 2 & 0.52 & 1 \\ \hline 2 & 0.04 & 1 \\ \hline 2 & 0.08 & 0 \\ \hline 2 & 0.16 & 0 \\ \hline 2 & 0.32 & 0 \\ \hline \vdots & \vdots & \vdots \end{array} \] \[ \therefore (0.100001111010111000 \dots)_2 \]

この場合、小数部は計算を繰り返しても繰り返しても答えの小数部が0にならず、おそらくは無限に続く小数になってしまう。そうした場合は途中で中断するよりほかない。

最後に整数部と小数部を足し合わせる。

\begin{align*} \therefore (87.53)_{10} & \rightarrow (1010111 + 0.100001111010111000... \\ &= 1010111.100001111010111000...)_{2} \end{align*}

10進数からr進数への基数変換のアルゴリズム

整数部については一般に次のように求めることができる。xが変換元である10進数の任意の整数、rが変換先の数の基数、yが商、aが余り。

\begin{align*} (x \div r = y_1\ \mathrm{余り} a_1)_{10} & \rightarrow (1 \times a_1)_r \\ (y_1 \div r = y_2\ \mathrm{余り} a_2)_{10} & \rightarrow (10 \times a_2)_r \\ (y_2 \div r = y_3\ \mathrm{余り} a_3)_{10} & \rightarrow (100 \times a_3)_r \\ (y_3 \div r = y_4\ \mathrm{余り} a_4)_{10} & \rightarrow (1000 \times a_4)_r \\ & \vdots \\ (y_n \div r = 0\ \mathrm{余り} a_n)_{10} & \rightarrow (10^m \times a_n)_r \end{align*} \[ \therefore (10^m \times a_n + \dots + 100 \times a_3 + 10 \times a_2 + 1 \times a_1)_r \]

代数的な表し方をすると次のようになる。

\begin{align*} (x = ry_1 + a_1)_{10} & \rightarrow (10^0 \cdot a_1)_r \\ (y_1 = ry_2 + a_2)_{10} & \rightarrow (10^1 \cdot a_2)_r \\ (y_2 = ry_3 + a_3)_{10} & \rightarrow (10^2 \cdot a_3)_r \\ (y_3 = ry_4 + a_4)_{10} & \rightarrow (10^3 \cdot a_4)_r \\ & \vdots \\ (y_n = 0 + a_n)_{10} & \rightarrow (10^m \cdot a_n)_r \end{align*} \[ \therefore (10^m \cdot a_n + \dots + 100a_3 + 10a_2 + a_1)_r \]

小数部については次のように計算することができる。ここで$ a.b $のaは小数の整数部、bは小数部を表す。

\begin{align*} (0.x \times r = a_1.b_1)_{10} & \rightarrow \left(\dfrac{1}{10} \times a_1 \right)_r \\ (b_1 \times r = a_2.b_2)_{10} & \rightarrow \left(\dfrac{1}{100} \times a_2 \right)_r \\ (b_2 \times r = a_3.b_3)_{10} & \rightarrow \left(\dfrac{1}{1000} \times a_3 \right)_r \\ & \vdots & \\ (b_n \times r = a_n.0)_{10} & \rightarrow \left(\dfrac{1}{10^m} \times a_n \right)_r \end{align*} \[ \therefore \left(\dfrac{1}{10} \times a_1 + \dfrac{1}{100} \times a_2 + \dfrac{1}{1000} \times a_3 + \dots + \dfrac{1}{10^m} \times a_n \right)_r \]

スクリプティング言語の関数やメソッドを利用した基数変換

Python 3では、2進数・8進数・16進数から10進数へ基数変換するためにint()関数を利用することができる。int()関数の第1引数に、変換したい数値を一重引用符か二重引用符で挟んで指定し、第2引数にその基数の値を指定する。

$ python3
>>> int("1111",2)
15
>>> int("16",8)
14
>>> int("1E",16)
30
>>> exit

変換前の数値にプレフィックス（接頭辞）が付けられていても大丈夫。

>>> int("0b10101",2)
21
>>> int("0o37",8)
31
>>> int("0x9",16)
9
>>> exit

10進数から2進数へ、10進数から8進数へ、10進数から16進数へ基数変換したいときにはそれぞれに専用の関数が用意されている。2進数へ変換する場合にはbin()関数、8進数へ変換する場合にはoct()関数、16進数へ変換する場合にはhex()関数を利用する。

>>> bin(125)
'0b1111101'
>>> bin(125)[2:]
'1111101'
>>> oct(56)
'0o70'
>>> oct(56)[2:]
'70'
>>> hex(64)
'0x40'
>>> hex(64)[2:]
'40'
>>> exit

これらの関数の出力値にはプレフィックス（接頭辞）が付いてくるが、[2:]によってそれを除去することができる。

Python 3では、format()関数やstr.format()メソッドにも10進数を2進数ないしは8進数ないしは16進数に基数変換する能力がある。format()関数とstr.format()メソッドでは次の書式指定子を利用する。

2進数はb、
8進数はo、
16進数の小文字はx、16進数の大文字はX。

次の例では10進数の30を2進数・8進数・16進数にそれぞれ基数変換している。

$ python3
Python 3.13.5
>>> format(30,'b')
'11110'
>>> "{:b}".format(30)
'11110'
>>> format(30,'o')
'36'
>>> "{:o}".format(30)
'36'
>>> format(30,'x')
'1e'
>>> "{:x}".format(30)
'1e'
>>> format(30,'X')
'1E'
>>> "{:X}".format(30)
'1E'
>>> exit

Python 3ではそのうえさらにf-stringsという文字列リテラルを利用する方法がある。次の例では10進数の31を2進数・8進数・16進数にそれぞれ基数変換している。

$ python3
Python 3.13.5
>>> f"{31:b}"
'11111'
>>> f"{31:o}"
'37'
>>> f"{31:x}"
'1f'
>>> f"{31:X}"
'1F'
>>> exit

R言語では2進数・8進数・16進数から10進数への基数変換にstrtoi()関数を利用できる。第1引数には引用符付きで数字を指定し、第2引数にはbase=の後にその数字の基数を指定する。2進数ならば2が基数、8進数ならば8が基数、16進数ならば16が基数。

$ R
R version 4.5.0
> strtoi("11111",base=2)
[1] 31
> strtoi("37",base=8)
[1] 31
> strtoi("1F",base=16)
[1] 31
> q()
Save workspace image? [y/n/c]: n

R言語で10進数から2進数へ基数変換するにはintToBits()関数を利用できる。ただしこの関数はスペースで区切られた2桁の2進法表現をraw型で返す。しかも桁は逆順に並んでいる。そのため、この関数によって返されたデータを整形する処理も一緒に必要になる。

次に10進数の35を2進数に基数変換する処理の例を示す。

$ R
R version 4.5.0
> bin1 = intToBits(35L)
> bin1
 [1] 01 01 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
[26] 00 00 00 00 00 00 00
> typeof(bin1)
[1] "raw"
> bin2 = as.integer(bin1)
> bin2
 [1] 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
> bin3 = rev(bin2)
> bin3
 [1] 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1
> bin4 = paste(bin3,collapse="")
> bin4
[1] "00000000000000000000000000100011"
> bin5 = sub("^0+","",bin4)
> bin5
[1] "100011"
> q()
Save workspace image? [y/n/c]: n

数値リテラルの35Lは35がInteger型の数値であることを表している。それをintToBits()関数に入力して出力された値を変数bin1に代入。しかし出力された値をtypeof()関数で調べてみるとraw型になってしまっている。as.integer()関数によってそれを再びInteger型に戻して変数bin2に代入。次にrev()関数で桁順を反転させて変数bin3に代入。次にpaste()関数によって数字間の空白を取り除いて変数bin4に代入。次にsub()関数によって余分な0を取り除いて最終的な結果を変数bin5に代入している。ただしrev()関数はpaste()関数より前で使う必要があることに要注意。

ちなみに、R言語の代入演算子は<-のはずだと思われたかもしれが、左辺への代入ならば=が使える。

R言語で10進数から16進数へ基数変換するにはas.hexmode()関数が便利。

$ R
R version 4.5.0
> as.hexmode(35L)
[1] "23"
> q()
Save workspace image? [y/n/c]: n

R言語で10進数を8進数へと基数変換する便利な方法はどうもないらしい。上述したアルゴリズムをコード化してちょっとしたスクリプトを組むしかないと思う。

GNU Octaveではbase2dec()関数とdec2base()関数を利用できる。base2dec()関数はr進数から10進数への基数変換をしてくれ、dec2base()関数は10進数からr進数への基数変換をしてくれる。

base2dec()関数では第1引数に変換したい数値を引用符で挟んで指定し、第2引数には第1引数で指定した数値の基数（何進数か）を指定する。dec2base()関数では第1引数に変換したい10進数の数値を指定し、第2引数に変換後の数値の基数（何進数へ変換したいか）を指定する。引数の指定方法が異なることに要注意。

$ octave
GNU Octave, version 9.4.0
octave:1> base2dec("11011",2)
ans = 27
octave:2> dec2base(27,2)
ans = 11011
octave:3> base2dec("33",8)
ans = 27
octave:4> dec2base(27,8)
ans = 33
octave:5> base2dec("1b",16)
ans = 27
octave:6> dec2base(27,16)
ans = 1B
octave:7> exit

Juliaではstring()関数とparse()関数を利用できる。string()関数は10進数からr進数へ基数変換してくれ、parse()関数はr進数から10進数へ基数変換してくれる。

string()関数の第1引数には10進数を指定して第2引数にはbase=で変換先の基数を指定する。parse()関数の第1引数にはデータ型名を指定し、第2引数に文字列リテラルとして変換前の数値を指定し、第3引数では第2引数で指定した数値の基数を指定する。

$ julia
Version 1.11.6
julia> string(8,base=2)
"1000"

julia> parse(Int,"1000",base=2)
8

julia> string(12,base=8)
"14"

julia> parse(Int,"14",base=8)
12

julia> string(13,base=16)
"d"

julia> parse(Int,"d",base=16)
13

julia> exit()

Rubyでは基数変換のために整数オブジェクトの.to_s()メソッドと文字列オブジェクトの.to_i()メソッドを利用することができる。.to_s()メソッドは10進数をr進数へ基数変換するために利用でき、.to_i()メソッドはr進数を10進数に基数変換するために利用できる。

整数オブジェクトの.to_s()メソッドでは()に変換先の基数を指定するが、文字列オブジェクトの.to_i()メソッドでは()に変換元の基数を指定するという違いがある。

ここではRubyのREPL（レプル）であるIRBを利用した。

$ ruby -v
ruby 3.3.8
$ irb -v
irb 1.13.1
$ irb
irb(main):001> 52.to_s(2)
=> "110100"
irb(main):002> "110100".to_i(2)
=> 52
irb(main):003> 37.to_s(8)
=> "45"
irb(main):004> "45".to_i(8)
=> 37
irb(main):005> 29.to_s(16)
=> "1d"
irb(main):006> "1D".to_i(16)
=> 29
irb(main):007> exit

Javaで基数変換をするにはIntegerクラスやLongクラスの.toString()メソッドと.parseInt()メソッドを利用することができる。.toString()メソッドは10進数からr進数への基数変換に利用でき、.parseInt()メソッドはr進数から10進数への基数変換に利用できる。

.toString()メソッドでは第1引数にint型の10進数を指定し、第2引数に変換先の基数を指定する。.parseInt()メソッドでは第1引数にn進数をstring型で指定し、第2引数にその基数を指定する。

JavaにはJShellというREPL（レプル）があるのでここではそれを利用した。

$ jshell
|  JShellへようこそ -- バージョン21.0.8
|  概要については、次を入力してください: /help intro

jshell> Integer.toString(25,2);
$1 ==> "11001"

jshell> Integer.parseInt("11001",2);
$2 ==> 25

jshell> Integer.toString(25,8);
$3 ==> "31"

jshell> Integer.parseInt("31",8);
$4 ==> 25

jshell> Integer.toString(28,16);
$5 ==> "1c"

jshell> Integer.parseInt("1c",16);
$6 ==> 28

jshell> /exit
|  終了します

ScalaでもJavaとまったく同じやり方でIntegerクラスやLongクラスの.toString()メソッドとparseInt()メソッドを使って基数変換を行うことができる。

$ scala
Welcome to Scala 2.11.12 (OpenJDK 64-Bit Server VM, Java 21.0.8).
Type in expressions for evaluation. Or try :help.

scala> Integer.toString(31,2)
res0: String = 11111

scala> Integer.parseInt("11111",2)
res1: Int = 31

scala> Integer.toString(31,8)
res2: String = 37

scala> Integer.parseInt("37",8)
res3: Int = 31

scala> Integer.toString(31,16)
res4: String = 1f

scala> Integer.parseInt("1f",16)
res5: Int = 31

scala> sys.exit

また、BigIntクラスを利用して大きい数値を扱うこともできる。

scala> var bigHex = BigInt("ffffff",16)
bigHex: scala.math.BigInt = 16777215

scala> bigHex.toString(2)
res9: String = 111111111111111111111111

scala> bigHex.toString(8)
res10: String = 77777777

scala> bigHex.toString(10)
res11: String = 16777215

scala> sys.exit

残念ながらここで挙げたいくつかのスクリプティング言語の関数やメソッドはすべて整数部の基数変換にしか対応していない。小数部はアルゴリズムが異なるため、それ向けのスクリプトを書く必要がある。

まとめ

r進数

10進数(decimal numbers): 10を基底とする位取り記数法。0, 1, 2, 3, 4, 5, 6, ..., 9, 10, 11 , 12, ...19, 20, 21, ..., 99, 100, 101, ...のように位を上げてゆく数え方。

2進数(binary numbers): 2を基底とする位取り記数法。0と1の数字だけを用いて、0, 1, 10, 11, 100, 101, 110, 111, 1000, ...のように位を上げてゆく数え方。

16進数(hexadecimal numbers): 16を基底とする位取り記数法。0〜9の次はA, B, C, D, E, F 10, 11, 12, ..., 19, 1A, 1B,..., 1F, 20, 21, ...のように位を上げてゆく数え方。

位取り記数法: 数に位（くらい）という概念を導入し、1つ下の位で数字がひと通り数えられるごとに1つ上の位に1つずつ繰り上がってゆく数え方およびその記数法。位は桁（けた）とも呼ぶ。

桁値（重み）: 位取り記数法において各桁（各位）はそれぞれ異なる数の単位を表している。その単位は桁値または重みと呼ばれている。それぞれの桁の数字はその桁値だけ倍にした数であることを意味している。例えば10進法では、10の位は10倍を意味し、100の位は100倍を意味している。2進法では、10（イチゼロ）の位は10進法での2倍に相当し、100（イチゼロゼロ）の位は10進法での4倍に相当している。

r進数から10進数への基数変換のアルゴリズム

与えられた数値を整数部と小数部とに分ける。

16進数を10進数へ基数変換する例を挙げてみた。

\[ (E941.0F5)_{16} = (E941)_{16} + (0.0F5)_{16} \]
整数部の各桁を10進数における「各桁の値×桁値」に基数変換し、それらすべての桁を表す項を足し合わせた総和の式にする。

\[ (E941)_{16} \rightarrow (14 \times 16^3 + 9 \times 16^2 + 4 \times 16^1 + 1 \times 16^0)_{10} \]

Eは10進数では14に当たる。整数部では1の位の桁値の指数が0から始まることに要注意。
小数部の各桁を10進数における「各桁の値×桁値」に基数変換し、それらすべての桁を表す項を足し合わせた総和の式にする。

\[ (0.0F5)_{16} \rightarrow (0 \times \dfrac{1}{16} + 15 \times \dfrac{1}{16^2} + 5 \times \dfrac{1}{16^3})_{10} \]

Fは10進数では15に当たる。
整数部を計算する。

\begin{align*} & (14 \times 16^3 + 9 \times 16^2 + 4 \times 16^1 + 1 \times 16^0)_{10} \\ & = (14 \times 4096 + 9 \times 256 + 4 \times 16 + 1 \times 1)_{10} \\ & = (57344 + 2304 + 64 + 1)_{10} \\ & = (59713)_{10} \end{align*}
小数部を計算する。

\begin{align*} & (0 \times \dfrac{1}{16} + 15 \times \dfrac{1}{16^2} + 5 \times \dfrac{1}{16^3})_{10} \\ & = (0 \times 0.0625 + 15 \times 0.00390625 + 5 \times 0.000244140625)_{10} \\ & = (0 + 0.05859375 + 0.001220703125)_{10} \\ & = (0.059814453125)_{10} \end{align*}
整数部の計算結果と小数部の計算結果を足し合わせる。

\[ (59713 + 0.059814453125)_{10} = (59713.059814453125)_{10} \]

10進数・2進数・8進数・16進数の桁値（各々の位の重み）

10進数とその桁値
10進数の桁	桁値
0.0000000001	$ \dfrac{1}{10^{10}} $
0.000000001	$ \dfrac{1}{10^9} $
0.00000001	$ \dfrac{1}{10^8} $
0.0000001	$ \dfrac{1}{10^7} $
0.000001	$ \dfrac{1}{10^6} $
0.00001	$ \dfrac{1}{10^5} $
0.0001	$ \dfrac{1}{10^4} $
0.001	$ \dfrac{1}{10^3} $
0.01	$ \dfrac{1}{10^2} $
0.1	$ \dfrac{1}{10^1} $
1	$ 10^0 $
10	$ 10^1 $
100	$ 10^2 $
1000	$ 10^3 $
10000	$ 10^4 $
100000	$ 10^5 $
1000000	$ 10^6 $
10000000	$ 10^7 $
100000000	$ 10^8 $
1000000000	$ 10^9 $
10000000000	$ 10^{10} $

2進数とその桁値（10進数表記）
2進数の桁	対応する10進数	桁値
0.00000000001	0.0009765625	$ \dfrac{1}{2^{10}} $
0.0000000001	0.001953125	$ \dfrac{1}{2^9} $
0.000000001	0.00390625	$ \dfrac{1}{2^8} $
0.00000001	0.0078125	$ \dfrac{1}{2^7} $
0.0000001	0.015625	$ \dfrac{1}{2^6} $
0.000001	0.03125	$ \dfrac{1}{2^5} $
0.00001	0.0625	$ \dfrac{1}{2^4} $
0.0001	0.125	$ \dfrac{1}{2^3} $
0.01	0.25	$ \dfrac{1}{2^2} $
0.1	0.5	$ \dfrac{1}{2^1} $
1	1	$ 2^0 $
10	2	$ 2^1 $
100	4	$ 2^2 $
1000	8	$ 2^3 $
10000	16	$ 2^4 $
100000	32	$ 2^5 $
1000000	64	$ 2^6 $
10000000	128	$ 2^7 $
100000000	256	$ 2^8 $
1000000000	512	$ 2^9 $
10000000000	1024	$ 2^{10} $

8進数とその桁値（10進数表記）
8進数の桁	対応する10進数	桁値
0.0000000001	0.0000000009313226	$ \dfrac{1}{8^{10}} $
0.000000001	0.000000007450581	$ \dfrac{1}{8^9} $
0.00000001	0.00000005960464	$ \dfrac{1}{8^8} $
0.0000001	0.0000004768372	$ \dfrac{1}{8^7} $
0.000001	0.000003814697	$ \dfrac{1}{8^6} $
0.00001	0.00003051758	$ \dfrac{1}{8^5} $
0.0001	0.0002441406	$ \dfrac{1}{8^4} $
0.001	0.001953125	$ \dfrac{1}{8^3} $
0.01	0.015625	$ \dfrac{1}{8^2} $
0.1	0.125	$ \dfrac{1}{8^1} $
1	1	$ 8^0 $
10	8	$ 8^1 $
100	64	$ 8^2 $
1000	512	$ 8^3 $
10000	4096	$ 8^4 $
100000	32768	$ 8^5 $
1000000	262144	$ 8^6 $
10000000	2097152	$ 8^7 $
100000000	16777216	$ 8^8 $
1000000000	134217728	$ 8^9 $
10000000000	1073741824	$ 8^{10} $

16進数とその桁値（10進数表記）
16進数の桁	対応する10進数	桁値
0.0000000001	0.0000000000009094947	$ \dfrac{1}{16^{10}} $
0.000000001	0.00000000001455192	$ \dfrac{1}{16^9} $
0.00000001	0.0000000002328306	$ \dfrac{1}{16^8} $
0.0000001	0.00000000372529	$ \dfrac{1}{16^7} $
0.000001	0.00000005960464	$ \dfrac{1}{16^6} $
0.00001	0.0000009536743	$ \dfrac{1}{16^5} $
0.0001	0.00001525879	$ \dfrac{1}{16^4} $
0.001	0.0002441406	$ \dfrac{1}{16^3} $
0.01	0.00390625	$ \dfrac{1}{16^2} $
0.1	0.0625	$ \dfrac{1}{16^1} $
1	1	$ 16^0 $
10	16	$ 16^1 $
100	256	$ 16^2 $
1000	4096	$ 16^3 $
10000	65536	$ 16^4 $
100000	1048576	$ 16^5 $
1000000	16777216	$ 16^6 $
10000000	268435456	$ 16^7 $
100000000	4294967296	$ 16^8 $
1000000000	68719476736	$ 16^9 $
100000000000	1099511627776	$ 16^{10} $

10進数からr進数への基数変換のアルゴリズム

与えられた数値を整数部と小数部とに分かる。

ここでは10進数の59713.059814453125を16進数へ基数変換する例を挙げる。

\[ (59713.059814453125)_{10} = (59713)_{10} + (0.059814453125)_{10} \]
整数部に連続除法（剰余法）を適用する。

ここで連続除法（剰余法）とは次のことを指す。各桁の値を変換したい基数で割り算し、その余りを記録し、そして割り算の答えの整数部を更に基数で割り算し、その余りを記録し、これを答えがゼロに達するまで繰り返す。答えが循環小数になる場合は適当なところで計算を打ち切る。

\[ \begin{array}{r|l:l} \text{割る数} & \text{割られる数} & \text{余り} \\ \hline 16 & 59713 \\ \hline 16 & 3732 & 1 \\ \hline 16 & 233 & 4 \\ \hline 16 & 14 & 9 \\ \hline & 0 & 14 \rightarrow E \end{array} \] \[ \therefore E941 \]
小数部に乗算法を適用する。

ここで乗算法とは次のことを指す。各桁の値（小数）を変換したい基数で掛け算し、その答えから整数部を差し引いた値を更に基数で掛け算し、小数部がゼロになるまでこの計算を繰り返す。その際、各桁の乗算ごとに得られた整数部の値を記録する。掛けても掛けても小数部が無くならない場合は適当なところで計算を打ち切る。

\[ \begin{array}{r|l:l} \text{掛ける数} & \text{掛けられる数} & \text{差し引いた整数部}\\ \hline 16 & 0.059814453125 \\ \hline 16 & 0.95703125 & 0 \\ \hline 16 & 0.3125 & 15 \rightarrow F \\ \hline 16 & 0 & 5 \end{array} \] \[ \therefore 0.0F5 \]

$ 16 \times 0.95703125 = 15.3125 $になるが、そこから整数部である15を差し引いて$ 15.3125 - 15 = 0.3125 $、小数部の0.3125だけを次の「掛けられる数」にする点に要注意。
得られた数値の整数部と小数部を足し合わせる。

\[ (E941)_{16} + (0.0F5)_{16} = (E941.0F5)_{16} \]

テキストエディタ、GeanyとjEditのエディタの行間の大きさを設定

2025-04-03T11:08:00.004+09:00

使っているテキスト・エディタ、GeanyとjEditの行間が狭すぎて見にくいので変更してみた。フォントやフォントの大きさの設定と比べて分かりにくかったのでブログに記しておく。

GeanyとjEditのバージョンを確認。

ソフトウェアのバージョン

$ geany -V
geany 2.0
$ jedit -version
jEdit 5.5.0

まずはGeanyでの手順。

Geanyを起動。
```
$ geany &
```
メニュー・バー（トップ・メニュー）の「ツール」-「設定ファイル」-「filetypes.common」
[styling]と共に「line_height=上の行間の値;下の行間の値;」という書式で次のようなコードを追加する。ただし「」は無視。
```
[styling]
line_height=3;3;
```
メニュー・バー（トップ・メニュー）の「ファイル」-「保存」か[Ctrl]+sで上書き保存。

次にjEditでの手順。

jEditを起動。
```
$ jedit &
```
メニュー・バー（トップ・メニュー）の「ユーティリティ」-「グローバルオプション」
「Global Options」タブの「jEdit」ディレクトリの「テキストエリア」を選ぶ。
「追加の水平行間隔（ピクセル単位）にピクセル単位で数値（6あたりが丁度いいと思った）を入力して「OK」ボタンか「適用」ボタンを押す。

LXQtとOpenboxのショートカットキー

2025-03-05T12:42:00.006+09:00

LXQt/Openboxのショートカット・キーの一覧であるけれどもLXDE/Openboxでも通用するものが多いはず。ただしLXDEでは有効に機能するはずの一部のショートカット・キーがLXQtでは機能しないようなので要注意。

ちなみにショートカット・キーはキーボード・ショートカットともホットキーともキーバインディングとも呼ばれている。

パソコンの種類によってキーボードの配列が異なることがあるので、それについて予め言及しておく必要があると思う。

WindowsパソコンではCtrキーとAltキーの間に挟まれたWindowsキー（Winキー）がMetaキーの役目を果たす。AppleのパソコンではAltキーがOptionキーに当たり、MetaキーはCommandキーに当たる。Chromebookではctrlキーとaltキーがあるが、metaキーがない。その代わりにChromebookの仮想Linux OS環境であるCrostiniでは虫眼鏡のアイコンが描かれた検索キーにMetaキーの機能が割り当てられることが多いようだ。

ちなみにMetaキーはSuperキーともHyperキーとも呼ばれている。

用語の説明も若干必要かもしれない。

「アクティブなウィンドウ」とは操作対象になっている最中のウィンドウのこと。「アクティブなデスクトップ」とは画面に表示中のデスクトップのこと。

LxPanelのメニューを表示する: Alt + F1

メニューを順番に選ぶには矢印キーを利用する。選んだメニューを実行するにはEnterキーを使う。

LxPanelのメニューを閉じる: Esc

コマンド入力によるアプリの起動: Alt + F2

実行コマンド・ダイアログには履歴機能があり、コマンドにオプションや引数も付け加えられる。アプリの起動の際にオプションや引数を添えて実行したい場合には便利。実行コマンド・ダイアログを閉じるためにはもう一度Alt + F2を押すかEscキーを使う。

アクティブなウィンドウを切り替える

Alt + tab

または

Alt + Esc

または

Meta + Shift + 任意の矢印キー

アクティブなウィンドウを逆順で切り替える: Alt + Shift + tab

アクティブなデスクトップを右向きに順番に切り替える: Ctrl + Alt + →

アクティブなデスクトップを左向きに順番に切り替える: Ctrl + Alt + ←

デスクトップ1へとアクティブなデスクトップを切り替える: Meta + F1

デスクトップ2へとアクティブなデスクトップを切り替える: Meta + F2

アクティブなウィンドウを全画面化する（すでに全画面化している場合は元に戻す）: F11

アクティブなウィンドウを閉じる: Alt + F4

アクティブなウィンドウの操作メニューを表示する: Alt + Space

アクティブなウィンドウの操作メニューを順番に選ぶには矢印キーを使う。割り当てられたキーバインディング（カッコ内に示されている）を利用して選ぶこともできる。選んだメニューの実行にはEnterキーを使う。

ウィンドウの操作メニューを閉じる: Esc

アクティブのウィンドウのデスクトップ上の位置を移動する

Alt + Spaceでアクティブなウィンドウの操作メニューを表示する。
Mキーを押すか「移動」というメニューを矢印キーで選んでEnterキーを押す。
矢印キーを使って任意の位置へ移動する。
移動先の位置が確定したらEnterキーを押す。移動を取り消したいときにはEscキーを押す。

または

Alt + マウスをクリックして移動

Mキーは「M」と書かれてあるキーのこと。「Mキーを押す」とは小文字のmをキーボードで入力することと同じ。

アクティブなウィンドウを別のディスクトップへ送る

Alt + Spaceでアクティブなウィンドウの操作メニューを表示する。
Sキーを押すか矢印キーを使って「デスクトップに送る」からデスクトップ名を選んでEnterキーを押す。

アクティブなウィンドウを最小化する

Alt + Spaceでアクティブなウィンドウの操作メニューを表示する。
Nキーを押すか矢印キーを使って「最小化」を選んでEnterキーを押す。

アクティブなウィンドウを最大化する

Alt + Spaceでアクティブなウィンドウの操作メニューを表示する。
Xキーを押すか矢印キーを使って「最大化」を選んでEnterキーを押す。

デスクトップを表示・非表示する: Meta + d

設定ファイルはホーム・ディレクトリの.config/openbox/にあるrc.xmlがそれ。ショートカット・キーはその中のkeyboard要素に挟まれたkeybind要素のname属性で定義されている。

Debian 13へのEPSON GT-S600のデバイスドライバのインストールに失敗

2025-01-17T22:02:00.004+09:00

Debian GNU/Linux 13 (trixie)でEPSON GT-S600というスキャナーを動作させるには次のウェブ・ページからdebパッケージになったデバイス・ドライバーをダウンロードしてインストールする必要がある。

EPSONドライバーダウンロード

そこの検索フォームに製品名としてGT-S600を入力し、OSとしてLinuxを選んで検索すると1件のヒットがある。その「ダウンロード』ボタンをクリックした後、ダウンロードする前に「エプソンのソフトウエア使用許諾契約」に同意する必要がある。

debパッケージの他にrpmパッケージとデバイス・ドライバーのソース・コードとインストール方法などが記されたPDFファイルも用意されている。アーキテクチャは32ビットと64ビットのどちらも選ぶことができる。

debパッケージとrpmパッケージとソース・コードはtar形式に書庫化された上でgzip形式で圧縮されている。そのため、拡張子がtar.gzとある。

tar.gzファイルを伸長（解凍）するにはLinux OSではtarコマンドを利用することができる。

$ tar -xzvf iscan-gt-s600-bundle-2.30.4.x64.deb.tar

tarコマンドのオプションについて説明すると、-xは書庫からファイルを取り出すための--extractか--getを意味し、-zはgzip形式の圧縮ファイルを伸長するための--gzipか--gunzipか--ungzipを意味し、-vは処理されたファイルを詳細にリストするための--verboseを意味する。

圧縮された書庫ファイルが伸長されて中のファイルが取り出されるとそのファイル名からtar.gzを覗いた名前のディレクトリー（フォルダー）が出力される。そのディレクトリーの中にinstall.shというシェル・スクリプトのファイルがあるので、これを実行するとインストールが開始される。

$ su
# ./install.sh

しかし、Debian GNU/Linux 13 (trixie)では依存関係にあるlibsaneが見つからず、次のようなエラー・メッセージを吐いてインストールに失敗してしまった。

E: Unable to locate package libsane

この問題の原因はどうやらライブラリーの1つであるかつてのlibsaneが現在ではlibsane1へと変更されたことにあるようだ。Debian 12 (bookworm)までは移行用のdebパッケージとしてlibsaneが残っていたが、Debian 13からは公式のリポジトリには存在していない。

シェル・スクリプトのインストーラーに頼らず、debパッケージをdpkgコマンドを利用して直接インストールすることにした。3つのdebパッケージをそれぞれインストールする必要があり、それらは次のような順番でインストールする必要がある。

# dpkg -i iscan-data_1.39.2-1_all.deb
# dpkg -i iscan_2.30.4-2_amd64.deb
# dpkg -i iscan-plugin-gt-s600_2.1.3-1_amd64.deb

2つめのdebパッケージのインストールでやはり同じエラーが生じてしまった。そこで、依存関係を無視させて強制的にインストールする--force-dependsオプションを付けてインストールしてみた。

# dpkg -i --force-depends iscan_2.30.4-2_amd64.deb

これでデバイス・ドライバーはインストールされ、エプソンのスキャナーをLinux OSが認識してくれるようになった。

ところがその結果、壊れたパッケージがあるとAPTが警告してくるようになった。Debianのマニュアルによれば--force-dependsを使うことは極力避けるべき乱暴な手段であるようだ。パッケージ管理システムのデータベースに不整合が生じてしまったら面倒なことになる。

この問題を回避する他の方法があるのか、インターネット上を探してみた。いくつか見つかったが、それらの多くもやや離れ業のように思われた。

見つかった解決法の中でもっとも合理的で正当だと思われたのがdebパッケージを再編集してビルドし直すこと。その方法に挑戦してみたらうまく行ったので、この投稿ではその手順を示したいと思う。

ここでやることは、dpkg-debと呼ばれているDebianパッケージ・アーカイブの操作ツールを使い、問題のあるiscan_2.30.4-2_amd64.debというdebパッケージから中身を取り出し、依存関係に関する設定を修正した上でdpkgコマンドを使ってdebパッケージを再構築すること。これはそれほど難しくなかった。

ターミナル・エミュレーターを起動してcdコマンドでiscan_2.30.4-2_amd64.debがあるディレクトリに移動する。

$ cd iscan-gt-s600-bundle-2.30.4.x64.deb/core

dpkg-debコマンドに-Rというオプションを付けてdebパッケージ名と任意の名前の作業ディレクトリー名を引数として渡してそのdebパッケージの中身を取り出す。
```
$ dpkg-deb -R iscan_2.30.4-2_amd64.deb debtemp
```
debtempディレクトリー下のDEBIANディレクトリー内にcontrolというテキスト・ファイルがあるはずなので、そのディレクトリーに移動し、編集するためにテキスト・エディター（nanoやvimやMousepadなど）でそのテキスト・ファイルを開く。
```
$ cd debtemp/DEBIAN
nano control
```
Depends:という項目の中にlibsaneが見つかったら、その名前をlibsane1に書き換える。書き換えたら保存してテキスト・エディターを終了する。
```
Depends:（中略）, libsane1 (>= 1.0.11-3),...
```
元のディレクトリに戻る。
```
cd ../..
```
dpkg-debコマンドに-bというオプションを付け、作業ディレクトリdebtempとiscan_2.30.4-2_amd64.debを引数として渡して実行し、debパッケージを再構築する。
```
$ dpkg-deb -b debtemp iscan_2.30.4-2_amd64.deb
dpkg-deb: building package 'iscan' in 'iscan_2.30.4-2_amd64.deb'.
```
debtempディレクトリーとそれ以下を丸ごと削除するために-rオプションを付けてrmコマンドを実行する。
```
$ rm -r debtemp
```
coreディレクトリーの上のディレクトリーに移動し、suコマンドでスーパーユーザー権限を得るかsudoコマンドとともにシェル・スクリプトのinstall.shを実行し、デバイス・ドライバーをインストールする。
```
$ cd ..
$ su
# ./install.sh
```

作業ディレクトリーとして作ったdebtempを削除しておかないとinstall.shがうまく機能しないことに要注意。

デバイス・ドライバーのインストールが無事に完了したら、スキャナーがパソコンに接続されて電源が入っている状態でXSaneを起動する。インストールに成功していればスキャナーが検出されてXSaneが起動するはず。

Debian 13にMetaTrader 5をインストールしてみた

2024-09-27T23:48:00.007+09:00

インストール対象: Debian GNU/Linux 13 Trixie 64ビット版

インストールするアプリ: MetaTrader 5

FXや株式のトレーダー向けに最適化された取引プラットフォームの1つにMetaTraderという名のソフトウェアがある。

MetaTrader 5のWindows版はMetaQuotesからダウンロードして無料で利用できる。Linux OS版は用意されていないが、Wineを利用するとWindows版のMetaTrader 5をLinux OSにインストールして使うことができるらしい。

DebianとUbuntuにはシェル・スクリプトでできたインストーラーが用意されている。

Debian向けのインストーラーを利用してMetaTrader 5をDebian 13にインストールしてみることにした。

このインストーラーを利用するにはDebianにwgetとsudoとWineが予めインストールされている必要がある。そしてsudoの設定ファイル/etc/sudoersにはログイン中のユーザー権限の指定が例えば次のように記述されている必要がある。

ユーザー名    ALL=(ALL) ALL

Debianの場合、次のコマンドを実行すればMetaTrader 5がインストールされる。

$ wget https://download.mql5.com/cdn/web/metaquotes.software.corp/mt5/mt5debian.sh ; chmod +x mt5debian.sh ; ./mt5debian.sh

wgetでdownload.mql5.comというサイトからmt5debian.shというインストーラーをダウンロードし、chmodというコマンドを使ってそのインストーラー（シェル・スクリプト）のファイルに実行権を与え、そして実行する。

Ubuntuの場合にはdebianというところをすべてubuntuにすればいい。

$ wget https://download.mql5.com/cdn/web/metaquotes.software.corp/mt5/mt5ubuntu.sh ; chmod +x mt5ubuntu.sh ; ./mt5ubuntu.sh

インストールの際にはsudoを利用するのでスーパーユーザー権限は必要ない。ただしインストールの途中で利用中の一般ユーザーのパスワードを求められる。

インストール中には、winehq-stableが見つからないだの0除算だの、エラー・メッセージがいくつか表示されたので心配したが、MetaTrader 5のインストーラーがなんとか起動してくれた。

デフォルトのインストール先はログイン中の一般ユーザーのホーム・ディレクトリ内に自動的に作られる隠しディレクトリ.mt5となる。

インストールは無事に成功した模様でMetaTrader 5が起動したものの、一部は日本語がちゃんと表示されているが、メニューが□□□□のように文字化けしていた。

この解決法の1つとしてWindowsから日本語フォントを借りてくる手を使った。同じパソコンにインストールしてあるWindowsのパーティションにアクセスして/Windows/Fonts内からmsjh.ttcとmsjhl.ttcというファイルをLinux OS側の.met5/drive_c/windows/Fonts内に複製した。

そうしておいてMetaTrader 5を再起動。すると日本語メニューが表示されるようになった。一件落着。

円周、円弧、扇の面積、円の面積、球体の表面積、球体の体積、円柱と円錐の体積

2022-11-13T13:16:00.006+09:00

円周

\begin{align*} C &:= 円周 \\ r &:= 円の半径 \\ \pi &:= 円周率 \\ \pi &= 3.141593... \\ C &= 2 \pi r \\ &= 2 \times 3.141593... \times r \end{align*}

円周えんしゅうとは円の周りの長さのこと。英語では円周のことをcircumference（サーカムフレンス）と呼んでいる。-cum-に発音上の強勢がある。

円の半径はんけいは円の中心から周りまでの長さのこと。英語では円の半径のことをradius（レイディアス）と呼んでいる。

円の半径は円の直径の半分。半径をrとし、直径(diameter)をdとすると、$ r = \dfrac{d}{2} $と表わすことができる。

円ではその半径がどこを測っても等しい。

円周率えんしゅうりつはギリシア文字の$ \Pi $（ピ）の小文字である$ \pi $を用いて表され、英語式にパイと呼ぶ慣わしがある。

円周率は数学定数と呼ばれている定まった数。ただしそれを10進法で表わすと3.141593...のように無限に続く可能性がある。円の直径(diameter)をdとし、円周をCとすると、円周率$ \pi = \dfrac{C}{d} $と定義されている。

円周率は分数の形では表わすことができないことが分かっているために無理数むりすうとして知られている。円周率は代数的な数として表わすことができないことが分かっているために超越数ちょうえつすうにも分類されている。

円弧

円弧えんこは円周の任意の部分、したがって円周の一部、言い換えれば円の断片を指す。閉じていない円周とも開いた円周とも見なすことができる。

単に弧こと呼んだ場合には円の一部ではなく、任意の2点間を結ぶ曲線一般のことを指している。

英語では円弧も単なる弧もこのどちらもan arc（アーク）と呼ばれている。特に円弧を表す場合にはthe arc of a circleのように言うことができる。

円弧は円の中心から任意に伸びた半直線によって切断された円周の一部として定義でき、その半径と中心角ちゅうしんかうによってその大きさを求めることができる。

円弧の長さ(the arc length)は次のような関係式によって計算できる。ただし中心角ちゅうしんかくの大きさが弧度法こどほうによって測られることに要注意。

\begin{align*} L &:= 円弧 \\ r &:= 半径 \\ \theta &:= 中心角の大きさ（ラジアン） \\ L &= r\theta \end{align*}

度数法どすうほうを弧度法に直すには度数法の値を$ \dfrac{\pi}{180} $倍する。

度数法による中心角θで円弧を計算する場合には次のような関係式を用いることができる。

\begin{align*} \theta &:= 中心角の大きさ（度数法） \\ L &= \theta \times \dfrac{\pi}{180} \times r \\ &= \dfrac{\pi}{180}r\theta \end{align*}

扇形おうぎがたの面積

扇形は英語ではa circular sectorやa circle sectorやthe sector of a circleなどと呼ばれている。扇形の面積は英語でthe area of a circular sectorなどと言うことができる。

扇形の面積は円の中心から放射状に外に伸びる半直線に挟まれた円弧によって閉じられた平面領域を指している。

扇形の面積は次の関係式によって計算することができる。ただし中心角はラジアンでなくてはならない。

\begin{align*} A &:= 扇形の面積 \\ \theta &:= 中心角の大きさ（ラジアン） \\ \pi &:= 3.14159265...（円周率） \\ r &:= 半径 \\ A &= \dfrac{\theta}{2\pi} \pi r^2 \\ &= \dfrac{\theta}{2}r^2 \end{align*}

度数法をラジアン（弧度法）に変換するには度数法の値を$ \dfrac{\pi}{180} $倍する。

\begin{align*} \theta &:= 中心角の大きさ（度数法） \\ A &= \dfrac{\dfrac{\pi}{180}\theta}{2}r^2 \\ &= \dfrac{\pi}{180}\theta \times \dfrac{1}{2}r^2 \\ &= \dfrac{\pi}{180 \times 2}\theta r^2 \\ &= \dfrac{\pi}{360}\theta r^2 \end{align*}

円の面積

\begin{align*} A_{ci} &:= 円の面積 \\ r &:= 円の半径 \\ \pi &:= 円周率 \\ \pi &= 3.141593... \\ A_{ci} &= \pi r^2 \\ &= 3.141593... \times (r \times r) \end{align*}

円の面積は英語ではarea of a circleと呼ばれている。

公式を見ると、円の面積は、一辺がr（円の半径）の長さを持つ正方形の面積の円周率(3.141593...)倍であることが分かる。

\[ A_{ci} = 3.141593... \times 一辺がrの正方形の面積 \]

球体の表面積（球面積）

\begin{align*} SA_{sp} &:= 球体の表面積 \\ r &:= 球体の半径 \\ \pi &:= 円周率 \\ \pi &= 3.141593... \\ SA_{sp} &= 4 \pi r^2 \\ &= 4 \times 3.141593... \times (r \times r) \end{align*}

球体の表面積ひょうめんせきは英語ではsurface area of a sphereと呼ばれている。

球体の半径とは球体の中心から表面までの長さ。球体ではその半径がどこを測っても等しい。

公式を見ると、球体の表面積は、その球体の中心部を通るように真っ二つに切断したときの断面の面積（円の面積）の4倍であることが分かる。

\[ 球体の表面積 = 4 \times 同じ半径を持つ円の面積 \]

球体の表面積はそれと外側に接する円柱の上下の円を取り除いた側面だけの表面積、つまり長方形の面積と等しい。要するに、この円柱の高さは球体の半径の2倍なので$ 2r $となり、円柱の長さは球体の円周になるので$ 2 \pi r $となる。よってこの円柱の側面の広さは次のようになり、球体の表面積と同じ式で計算することができる。

\begin{align*} 円柱の側面の面積 &= 2r \times 2 \pi r \\ &= 2^2 \pi r^2 \\ &= 4 \pi r^2 \\ &= 4 \times 3.141593... \times (r \times r) \\ &= 球体の表面積 \end{align*}

球体の体積

\begin{align*} V_{sp} &:= 球体の体積 \\ r &:= 球体の半径 \\ \pi &:= 円周率 \\ \pi &= 3.141593... \\ V_{sp} &= \dfrac{4}{3} \pi r^3 \\ &= \dfrac{4 \times 3.141793...}{3} \times (r \times r \times r) \\ &= \dfrac{4 \times (r \times r \times r)}{3} \times 3.141593... \\ &= 1.333333... \times 3.141593... \times (r \times r \times r) \end{align*}

球体の体積たいせきは英語ではvolume of a sphereと呼ばれている。

面積では半径の2乗じょうであったのに対して体積では半径が3乗になっているのが分かる。半径の2乗に立体の奥行きが加わって3乗になった。

4分の3は小数として表わすと1.33333...になる。掛け算の単位元たんいげん1に加えて小数点以下に3が繰り返す循環じゅんかん小数。

球体の体積はその外側にぴったりと接する円柱えんちゅうの体積の3分の2であることが知られている。

\begin{align*} V_{sp} &:= 球体の体積 \\ V_{cy} &:= 円柱の体積 \\ V_{sp} &= \dfrac{2}{3}V_{cy} \\ &= 0.66666... \times V_{cy} \end{align*}

円柱は英語ではcylinderと呼ばれている。日本語読みをすればシリンダー。

3分の2を小数に直すと0.66666...という循環小数になる。

円柱の体積

円柱の体積は次の式によって得ることができる。

\begin{align*} V_{cy} &:= 円柱の体積 \\ h &:= 円柱の高さ \\ r &:= 円柱の半径 \\ 円周率 &:= \pi \\ \pi &= 3.141593... \\ V_{cy} &= \pi r^2 h \\ &= 3.141593... \times (r \times r) \times h \\ \end{align*}

ちなみに、円錐えんすいの体積はその外側にぴったりと接する円柱の体積の3分の1であることが知られている。

そしてこれらのことから次のことが明らかになる。

\begin{align*} V_{cy}&:= 円柱の体積 \\ h_{cy} &:= 円柱の高さ \\ V_{sp} &:= 球体の体積 \\ r_{sp} &:= 球体の半径 \\ V_{co} &:= 円錐の体積 \\ h_{co} &:= 円錐の高さ \\ h_{cy} &= h_{co} = r_{ci}^2 \\ V_{cy} &= \pi r^2 h = 2 \pi r^3 \\ V_{cy} &= V_{sp} + V_{co} \\ 2 \pi r^3 &= \dfrac{4}{3}\pi r^3 + 2 \times \dfrac{1}{3}\pi r^3 \\ &= \dfrac{4}{3}\pi r^3 + \dfrac{2}{3}\pi r^3 \end{align*}

円柱の体積は、その円柱の内側にぴったりと接する円錐の体積と、その円柱の内側にぴったりと接する球体の体積との合計。円柱の内側にぴったりと接する円錐とは、その底辺の円の半径が円柱のそれと同じで、かつ、その高さも円柱と同じもの。円柱の内側にぴったりと接する球体とは、その球体の半径が円柱の半径と同じで、かつ、その球体の直径がその円柱の高さと同じもの。

円柱状の鉄の固まりが一つあったとすると、それを溶かし、同じ半径と同じ高さを持つ円錐一つと、円柱の高さと同じ直径と同じ半径を持つ球体一つを作ることができる。

円柱と円錐の表面積、そしてまた、楕円と（回転）楕円体についてはまたの機会に。

角度とそれを測る単位系（度数法や弧度法等）を理解する

2022-09-20T11:05:00.020+09:00

角度

平面上の角度は時計の針のようにモデル化することができる。つまり、1つの回転軸を共有する2本の半直線の回転量の差として表せる。

半直線は矢印の方向に無限に伸びる光線のようなイメージ。この2本の半直線は角度のアームと呼ばれることがある。

2本のアームの回転軸は頂点と呼ばれている。頂点はOやPやQなどの文字で表されることが多い。

角度それ自身は$ \theta $スモールシータや$ \varphi $スモールファイもしくは$ \alpha $スモールアルファや$ \beta $スモールベータといったギリシア文字で表されることが多い。スモールシータは数学でよく用いられており、スモールファイは工学でよく用いられる。

ちなみに、3次元の極座標系の1つである球面座標系では極角（緯度）がスモールシータで、方位角（経度）がスモールファイで表されていることが多い。

角度を記号によって表すには角を表す$ \angle ABC $の前にmeasureのmを添えて$ m \angle ABC $と記すことができる。

角度が度数法で0°から90°の範囲にあるとき、その角度は鋭角えいかくと呼ばれている。角度が度数法で90°から180°の範囲にあるとき、その角度は鈍角どんかくと呼ばれている。

下の図では青が鋭角、赤が鈍角。下の図では青い角と赤い角は互いに補角ほかくの関係にもある。

2つの角度の合計が180°のとき、それらの角度は互いに補角の関係にある。英語ではsupplementary anglesと呼ばれている。2つの角度の合計が90°であるとき、それらの角度は互いに余角よかくの関係にある。英語ではcomplementary anglesと呼ばれている。したがって上の図が補角(a supplementary angle)で下の図が余角(a complementary angle)の関係を表している。

頂点を共有して対称関係にある反対側の角は対頂角たいちょうかくと呼ばれている。対頂角の角度は等しい。

\[ \alpha = \beta \] \[ \theta = \varphi \]

また、頂点を共有する隣同士の角は線形ペアと呼ばれることがある。上の図で言えば次のペアが線形ペア。

\[ (\alpha,\theta) \] \[ (\alpha,\varphi) \] \[ (\beta,\theta) \] \[ (\beta,\varphi) \]

2本のアーム（半直線）が水平または垂直に連なり、角度が180°であるとき、その角度は特に平角へいかくと呼ばれている。

角度のアームが右に水平、言い換えると時計で言うところの3時（15時）の時点にあるとき、それを標準位置と呼ぶことがある。

その標準位置が角度のちょうど0に当たる。

平面の角度を計測するための物差し、つまり角度の単位系たんいけいにはいくつかある。ここでは度数法どすうほうと弧度法こどほうと回転法とに言及する。

度数法

一般に馴染みのある度数法では$ \dfrac{1}{4} $回転で90°、$ \dfrac{1}{2} $回転で180°、$ \dfrac{3}{4} $回転で270°、1回転すると360°になり、0°に戻ってくる。

水平の角度を時計のように幾何学的なモデルにすると次のように描くことができるかもしれない。目盛りは度数法に従っている。0°は時計の3時（15時）を指す標準位置に定めてある。

度数法は古代の天文学に基づいているという説がある。360度は地球の公転周期のおよそ365日に近い。Wikipediaによれば、古代のバビロニア暦やペルシア暦では1年を360日と見なしていたらしい。

ちなみに、地球の公転周期はより正しくは365.242199日。

10進法が人の両手の指の標準的な数の合計に由来するように、度数法は地球の公転周期に由来する。

同じくWikipediaによれば、古代バビロニア人は数のシステムとして60進法を用いていた。更に正三角形で円を分割し、正三角形の内角を60進法で分割することで60分の1を角度1（すなわち1°）と見なしていたとする説もあるらしい。

つまり、1角を60とする正三角形を6つ組み合わせると角度は1周し、$ 60 \times 6 = 360 $になる。

正三角形と60進法の考え方を使うと、正三角形の内角を1°と見なし、それが3つで半回転することになり、それを3°と見なせたし、それが6つで1回転して6°と見なすことができたかもしれない。そうすると次に挙げる弧度法に近い角度の値になっていた。

この考え方に基づくと、1周を6等分し、その1角を60進法に従って60等分し、その60分の1を更に60等分する。それが度数法であると見なすことができる。

しかし実際の度数法は1回転で360°なので、正凸360角形であると考えることができるかもしれない。

正凸360角形をコンピューター・グラーフィクスによって描いてみた。それが次の図形。ディスプレイの解像度によるだろうけれども、この図形の大きさだと人の視覚では円とほとんど等しく見える。

※3から360までの整数値をフォームに入力して描画ボタンを押すと正凸n角形が作図される。この値が50以下でないと放射状に描いた線分なしには多角形であると判別し難い。

360分の1である1°よりも更に小さい値は、度数法では60進法に基づいて60分の1に分割され、分ふんと呼ばれている。そしてそのまた更に小さい単位も60分の1に分割され、秒びょうと呼ばれている。

1°（1度）は60′（60分）、1°の半分は30′（30分）というようにプライム記号を付けて記されており、1′（1分）は60″（60秒）、1′の半分は30″（30秒）というようにダブル・プライム記号を付けて記されている。HTMLではこれらは特殊文字なので、プライム記号は′と記し、ダブル・プライム記号は″と記す必要がある。

1.5°は1°30′（1度30分）と等しく、3.75°は3°30′15″（3度30分15秒）と等しい。

度数法は時間の測定と似ている。時間における1周が12時間60分60秒であるのに対して角度の度数法では360度60分60秒となる。

しかし角度に60進法の分や秒を用いるのはややこしくて不便であり、時間と違って現在では廃れた用法であるように思う。

弧度法（ラジアン法）

弧度法は微分積分学で重宝されている角度の測り方（単位系）。

円の半径の長さrと円弧の長さaが等しいとき、その中心角の角度θを1と定めるのが弧度法の考え方。

\[ (r = a) \Rightarrow \theta = 1^c \]

弧度法での角度の値は、単に数値だけが記されることが多いが、意味を明確にするために数値の後にradを添えたり数値の右肩に$ ^c $を付けて記されることも少なくない。

したがって1ラジアンは、単に1、もしくは1 rad、または$ 1^c $のように書かれるかもしれない。

弧度法ではこのように線分の長さの測定と角度の測定とを結び付けている。

ちなみに、中心角の角度θと円弧の長さsと半径の長さrとの間には次の等式に示す関係がある。

\[ \theta = \dfrac{s}{r} \] \[ s = r\theta \] \[ r = \dfrac{s}{\theta} \]

ただしこの式での角度θはラジアン。角度θが度数法のときにはその値に$ \dfrac{\pi}{180} $を掛けてラジアンに直す必要がある。

弧度法は自然な測定単位であり、度数法は恣意的であると言われることが多いが、正三角形の内角60°を利用した度数法の考え方では、半周の180°は内角が60°となる正三角形が3つ分なので60°を1と定めると円周率である3.1415926535897...に近くなる。1周の360°は正三角形が6つ分であるので円周率の2倍である6.283185307179586...とそれほど大きく隔たっていない。

1 rad刻みの弧度法と60°刻みの度数法とを重ねて作図してみた。度数法が青い矢印、弧度法が赤い矢印。

このように見てみると、60°は弧度法の1 rad = 57.29577951308232...に近いので、正三角形に基づいた度数法の考え方は惜しいところまで来ていた。

もっとも角度の場合、半径が大きくなるほど誤差によって生ずる距離が拡がってゆくので、たとえ僅かな誤差であっても無視できなくなる。

ラジアンは円の半径の長さrに対する円弧の長さaの比率（割合）であると言うこともできる。この観点は三角比と似ている。この比率を中心角の大きさとして定めるのが弧度法であるというわけだ。

\[ \theta = \dfrac{a}{r} \]

例えば円の半径の長さrが1の場合、次のような式になるから円弧の長さaがそのまま角度の値になる。

\[ \theta = \dfrac{a}{1} = a \]

このため、半径1の円を用いた幾何学的モデルを考えると便利。半径が1の円は単位円たんいえんと呼ばれている。

単位円という名称は単位元たんいげんを連想させる。

弧度法では円の半径rに対する円周の長さcの比率（割合）が円周率πの2倍と等しくなる。

\[ 円周率の2倍 = \dfrac{円周}{円の半径} \] \[ 2\pi = \dfrac{c}{r} \]

円周率(π)とは円の直径と比べた円周の比率（割合）のこと。

\[ 円周率 = \dfrac{円周}{円の直径} = \dfrac{円周}{円の半径の2倍} \] \[ \pi = \dfrac{c}{d} = \dfrac{c}{2r} \]

弧度法では、30°は円周率πの6分の1、45°は円周率πの4分の1、60°は円周率πの3分の1、90°は円周率πの2分の1、120°は円周率πの3分の2、135°は円周率πの4分の3、150°は円周率πの6分の5、180°は円周率πと一致し、210°は円周率πの6分の7、225°は円周率πの4分の5、240°は円周率πの3分の4、270°は円周率πの2分の3、300°は円周率πの3分の5、315°は円周率πの4分の7、330°は円周率πの6分の11、360°は円周率πのちょうど2倍になる。

1 radの更に1000分の1はミリラジアンないしミルと呼ばれている。その単位の記号はmradまたはmil。1 mradは小数点が左に3桁移動するので0.001 radに当たる。

ターン法（回転法）

ターンとは英語の綴りではturnであり、日本語では一回りや一周のことを意味する。ターン法は英語でrotationと呼ばれていることもあり、回転を意味する。したがってこれを回転法と呼ぶことができるかもしれない。

ターン法（回転法）の単位記号にはturnが一般的に使われているが、revolutionのrevやrotationのrot、またはrやtrが用いられていることもある。

ちなみに、πに代わってギリシャ文字のτタウを幾何学定数の円周率として再定義しようという提案がある。この提案に倣うと円周率は3.1415926...ではなくてその倍である6.2831853...となり、ちょうど1回転(1 turn)した回転角かいてんかくを意味することになる。したがって幾何学定数のτを使ってちょうど1回転した角度を1τと表すこともできる。

ターン法では角度が1回転（1周）すると1 turnターンとなる。

グラジアン法

角度を表す単位系としてこの他にも例えばグラジアン法(Gradians)がある。その単位記号にはgonゴンまたは$ ^g $グラードが使われている。グラジアン法では直角を100分の1に分割する100進法を用いている。よってグラジアン法での1周は400 gonまたは$ 400^g $となる。

1 gonを更に細分化したdgonは0.1 gonを意味しており、更に細分化したcgonは0.01 gonを意味しており、mgonは0.001 gonを意味している。

度数法による値dとグラジアン法による値gとを相互変換するには次のような計算をする。

\begin{align} g &= \dfrac{100}{90}d \\ &= d \times 100 \div 90 \end{align} \begin{align} d &= \dfrac{90}{100}g \\ &= g \times 90 \div 100 \end{align}

英語では、度数法がsexagesimal systemまたはsexagesimal measure、弧度法がcircular systemまたはcircular measure、グラジアン法がcentesimal systemまたはcentesimal measureとも呼ばれていることがある。

sexagesimalは「60進法の」、circularは「円形の」、centesimalは「100進法の」という意味。measureは「尺度」「計量法」を意味しており、数学用語では「測度そくど」を意味している。

度数法は英国式とも呼ばれており、グラジアン法はフランス式とも呼ばれている。

角度が1周するといくつになるか、度数法と弧度法とターン法とグラジアン法とを比較してみた。

1周（1回転）の角度
測定法	数値
度数法	360°
弧度法（π表記）	2π = 6.283185...
弧度法（τ表記）	τ = 6.283185...
ターン法	1 turn
グラジアン法	400 gon

度数法に対する各種角度単位系の関係表

度とその他の単位との関係表を作ってみた。ただし15°毎。分数は便宜上約分していない。πは円周率。$ \cdot $は乗算記号。


°	rad	turn	gon
0	0	0	0
15	$ \dfrac{15}{180}\pi $	$ \dfrac{15}{360} $	$ \dfrac{15}{90} \cdot 100 $
30	$ \dfrac{30}{180}\pi $	$ \dfrac{30}{360} $	$ \dfrac{30}{90} \cdot 100 $
45	$ \dfrac{45}{180}\pi $	$ \dfrac{45}{360} $	$ \dfrac{45}{90} \cdot 100 $
60	$ \dfrac{60}{180}\pi $	$ \dfrac{60}{360} $	$ \dfrac{60}{90} \cdot 100 $
75	$ \dfrac{75}{180}\pi $	$ \dfrac{75}{360} $	$ \dfrac{75}{90} \cdot 100 $
90	$ \dfrac{90}{180}\pi $	$ \dfrac{90}{360} $	$ \dfrac{90}{90} \cdot 100 $
105	$ \dfrac{105}{180}\pi $	$ \dfrac{105}{360} $	$ \dfrac{105}{90} \cdot 100 $
120	$ \dfrac{120}{180}\pi $	$ \dfrac{120}{360} $	$ \dfrac{120}{90} \cdot 100 $
135	$ \dfrac{135}{180}\pi $	$ \dfrac{135}{360} $	$ \dfrac{135}{90} \cdot 100 $
150	$ \dfrac{150}{180}\pi $	$ \dfrac{150}{360} $	$ \dfrac{150}{90} \cdot 100 $
165	$ \dfrac{165}{180}\pi $	$ \dfrac{165}{360} $	$ \dfrac{165}{90} \cdot 100 $
180	$ \dfrac{180}{180}\pi $	$ \dfrac{180}{360} $	$ \dfrac{180}{90} \cdot 100 $
195	$ \dfrac{195}{180}\pi $	$ \dfrac{195}{360} $	$ \dfrac{195}{90} \cdot 100 $
210	$ \dfrac{210}{180}\pi $	$ \dfrac{210}{360} $	$ \dfrac{210}{90} \cdot 100 $
225	$ \dfrac{225}{180}\pi $	$ \dfrac{225}{360} $	$ \dfrac{225}{90} \cdot 100 $
240	$ \dfrac{240}{180}\pi $	$ \dfrac{240}{360} $	$ \dfrac{240}{90} \cdot 100 $
255	$ \dfrac{255}{180}\pi $	$ \dfrac{255}{360} $	$ \dfrac{255}{90} \cdot 100 $
270	$ \dfrac{270}{180}\pi $	$ \dfrac{270}{360} $	$ \dfrac{270}{90} \cdot 100 $
285	$ \dfrac{285}{180}\pi $	$ \dfrac{285}{360} $	$ \dfrac{285}{90} \cdot 100 $
300	$ \dfrac{300}{180}\pi $	$ \dfrac{300}{360} $	$ \dfrac{300}{90} \cdot 100 $
315	$ \dfrac{315}{180}\pi $	$ \dfrac{315}{360} $	$ \dfrac{315}{90} \cdot 100 $
330	$ \dfrac{330}{180}\pi $	$ \dfrac{330}{360} $	$ \dfrac{330}{90} \cdot 100 $
345	$ \dfrac{345}{180}\pi $	$ \dfrac{345}{360} $	$ \dfrac{345}{90} \cdot 100 $
360	$ \dfrac{360}{180}\pi $	$ \dfrac{360}{360} $	$ \dfrac{360}{90} \cdot 100 $

度数法と弧度法との相互変換

度数法での角度の値dと弧度法での角度の値rとの関係は次の式で表すことができる。このrは半径のことではなくラジアンのこと。

\begin{align} d &= \dfrac{180}{\pi}r \\ &= r \times 180 \div \pi \end{align} \begin{align} r &= \dfrac{\pi}{180}d \\ &= d \times \pi \div 180 \end{align}

ラジアンrに180を掛けて円周率πで割ると度dが求まり、度dに円周率πを掛けて180で割るとラジアンrが求まる。この計算には円周率が絡むので計算機や計算機言語などを利用すると便利。

例えば度数法での60°が弧度法では何radになるかをMaximaを使って計算してみた。その逆も。

$ maxima
Maxima 5.42.1 http://maxima.sourceforge.net
using Lisp GNU Common Lisp (GCL) GCL 2.6.12
Distributed under the GNU Public License. See the file COPYING.
Dedicated to the memory of William Schelter.
The function bug_report() provides bug reporting information.
(%i1) 60*%pi/180;
                                      %pi
(%o1)                                 ---
                                       3
(%i2) float(%o1);
(%o2)                          1.047197551196597
(%i3) %o2*180/%pi;
                               188.4955592153875
(%o3)                          -----------------
                                      %pi
(%i4) float(%o3);
(%o4)                                60.0
(%i5) quit();

このとおり、60°はおよそ1.047197551196597 radだった。逆演算をしてみると60.0°に戻った。

60°は1 radよりも僅かに大きい。

Rでも同様に計算してみた。<-はR言語での代入演算子。左へ代入するなら=も代入演算子として使えることはあまり知られていない。

$ R
R version 3.5.2 (2018-12-20) -- "Eggshell Igloo"
Copyright (C) 2018 The R Foundation for Statistical Computing
（中略）
> radian <- 60*pi/180
> radian
[1] 1.047198
> degree <- radian*180/pi
> degree
[1] 60
> q();
Save workspace image? [y/n/c]: n

Rでも同じ結果が得られた。

1 radは何°だろうか。Maximaで計算してみた。

$ maxima
Maxima 5.42.1 http://maxima.sourceforge.net
（中略）
(%i1) float(1*180/%pi);
(%o1)                          57.29577951308232
(%i2) float(%o1*%pi/180);
(%o2)                                 1.0
(%i3) quit();

1 radはおよそ57.29577951308232°だった。60°よりも僅かに小さい。

1°は何radだろうか。

$ maxima
Maxima 5.42.1 http://maxima.sourceforge.net
（中略）
(%i1) float(1*%pi/180);
(%o1)                         0.01745329251994329
(%i2) float(%o1*180/%pi);
(%o2)                                 1.0
(%i3) quit();

1°はおよそ0.01745329251994329 radだった。

度数法とターン法との相互変換

度数法による値をdとし、ターン法による値をtとすると、それらは次のような計算によって相互変換できる。

\begin{align} t &= \dfrac{1}{360}d \\ &= \dfrac{d}{360} \\ &= d \div 360 \end{align} \begin{align} d &= \dfrac{360}{1}t \\ &= t \times 360 \end{align}

要するに、度をターンに変換するには度の値を360で割り、ターンを度に変換するにはターンの値を360倍する。

弧度法とターン法との相互変換

弧度法の値rとターン法の値tとの相互変換は次のように計算できそう。

\begin{align} r &= 2\pi t \\ &= t \times 2 \times \pi \end{align} \begin{align} t &= \dfrac{r}{2\pi} \\ &= r \div (2 \times \pi) \end{align}

ターンからラジアンを求めるにはターンを2π倍する。ラジアンからターンを求めるにはラジアンを2πで割る。2πはπの2倍のこと。

各種計算機言語での度数法・弧度法変換

Juliaでの度数法と弧度法の相互変換はdeg2rad()とrad2deg()という2つの組み込みメソッドを利用することで可能。deg2rad()は度からラジアンへの変換を行ってくれ、rad2deg()はラジアンから度への変換を行ってくれる。

$ julia
（中略）
julia> deg2rad(1)
0.017453292519943295

julia> rad2deg(1)
57.29577951308232

julia> exit()

Python3ではmathをimportしてmath.radians()とmath.degrees()を利用できる。

$ python3
Python 3.7.3
（中略）
>>> import math
>>> math.radians(180)
3.141592653589793
>>> math.degrees(math.pi)
180.0

Numpyをimportすればnumpy.deg2rad()とnumpy.rad2deg()を利用できる。

>>> import numpy as np
>>> np.deg2rad(360)
6.283185307179586
>>> np.rad2deg(2*math.pi)
360.0
>>> exit()

R言語ではNISTunitsというパッケージを利用できる。NISTunitsをインストールし、ライブラリーとして読み込んでNISTdegTOradian()とNISTradianTOdeg()を呼び出す。

$ R
R version 3.5.2 (2018-12-20) -- "Eggshell Igloo"
（中略）
> install.packages("NISTunits",dependencies=T)
（中略）
> library(NISTunits)
> NISTdegTOradian(1)
[1] 0.01745329
> NISTradianTOdeg(1)
[1] 57.29579

Rではunitsというパッケージを利用することもできる。

unitsをインストールし、ライブラリーとして読み込む。そしてas_units()の第1引数に数値、第2引数に単位を付加することによりその数値に単位を付けてそれを変数に代入し、今度はset_units()の第1引数にその変数を指定して第2引数に変換したい単位を指定してやると変換後の値が返ってくる。

> install.packages('units')
（中略）
> library(units)
udunits database from /usr/share/xml/udunits/udunits2.xml
> deg <- as_units(1,"degrees")
> rad <- set_units(deg,"radians")
> rad
0.01745329 [rad]
> rad <- as_units(1,"radians")
> deg <- set_units(rad,"degrees")
> deg
57.29578 [°]
> q()
Save workspace image? [y/n/c]: n

unitsのインストールでコンフィギュレーションに失敗することがある。そのときはエラー・メッセージに指示されているとおりにする。例えばUbuntuやDebianではlibudunits2-devというdebパッケージをインストールする必要があるかもしれない。

GNU Octaveではdeg2rad()とrad2deg()を利用できる。

$ octave
GNU Octave, version 4.4.1
Copyright (C) 2018 John W. Eaton and others
（中略）
octave:1> deg2rad([1,90,180,360])
ans =

   0.017453   1.570796   3.141593   6.283185

octave:2> rad2deg([1,pi,2*pi])
ans =

    57.296   180.000   360.000

octave:3> quit

LibreOffice CalcにはDEGREES()という函数とRADIANS()という函数がある。これらを利用するとラジアン単位と度単位を相互に変換することができる。1 radはGEGREES(1) ≒ 57.2957795130823°、1°はRADIANS(1) ≒ 0.0174532925199433 radという結果が得られた。

分数の約分をコンピューターで行う便利な方法についてここでちょっとしたメモ書き。

各種計算機言語での約分

分数の分母と分子を共に同じ整数で割るとき、1でしか割り切れない場合にはその分数は既約分数と呼ばれる。例えば$ \dfrac{2}{3} $は$ \dfrac{2\div1}{3\div1} $のように1でしか割り切れないので既約分数。例えば$ \dfrac{2}{4} $のような分数は$ \dfrac{2\div2}{4\div2} $のように2で割り切れるので既約分数ではない。

既約分数でない分数を既約分数にすることを約分すると言う。英語ではReducing fractions to lowest termsと表現されたりする。

約分のアルゴリズムとしては素因数分解が有用。このアルゴリズムとプログラミングについてはまた別の機会に。

ここではいくつかの計算機言語で約分を行う簡単な方法を記しておく。

Python3で分数を約分して既約分数に直すには有理数演算を支援するfractionsモジュールからFractionをインポートし、Fraction(分子,分母)を利用する。有理数とは分数によって表せる数の総称。

$ python3
Python 3.7.3（中略）
>>> from fractions import Fraction
>>> Fraction(15,180)
Fraction(1, 12)
>>> quit()
$

Maximaでは割り算の形で分数を入力してEnterを押すだけで既約分数を表示してくれる。Maximaでは式の終わりにセミコロンが必要であることに要注意。

$ maxima

Maxima 5.42.1 http://maxima.sourceforge.net
（中略）
(%i1) 90/360;
                                       1
(%o1)                                  -
                                       4
(%i2) quit();
$

Juliaで分数（有理数）を扱うには//演算子を用いる。分子//分母を入力してEnterキーを押すと既約分数を自動的に表示してくれる。次の例で使用しているJuliaはバージョン1.0.3。

$ julia
（中略）
julia> 75//180
5//12

julia> exit()
$

RubyではRationalクラスのRational(分子,分母)メソッドを利用して分数（有理数）を表せる。更に、分子/分母rという表記によっても分数を表すことができる。irb上でこれらを入力してEnterキーを押すと既約分数を自動的に表示してくれる。

$ irb
irb(main):001:0> Rational(270,180)
=> (3/2)
irb(main):002:0> 315/360r
=> (7/8)
irb(main):003:0> quit
$

R言語では例えば音声および音響分析用ツールが収められているphonToolsパッケージをインストールし、それをライブラリーとして読み込んだ上でreduce.fraction()を利用する。

reduce.fraction()の引数には2つの整数の要素を持つベクトルを与える。

$ R
R version 3.5.2 (2018-12-20) -- "Eggshell Igloo"
Copyright (C) 2018 The R Foundation for Statistical Computing
（中略）
> install.packages('phonTools',dependencies=T)
（中略）
> library(phonTools)
> reduce.fraction(c(140,203))
[1] 20 29
> reduce.fraction(c(15,360))
[1]  1 24
> q()

install.packages()の第2引数dependencies=Tは依存関係を解決してくれるもの。

JavaScriptで幾何学模様を描いてみた

2022-09-19T21:35:00.020+09:00

14個とも全て同じコードによって描いた。たった1つのパラメーターの値を変えるだけで同じコードから様々な幾何学的模様が作図できた。これらはその一部の例。

なんで同一コードからこのように異なる模様が出来上がるのかは理解できない。ちょっと不思議。

幾何学模様を描く

LibreOffice Basic ユーザーが定義するデータ型（構造体）

2022-06-29T21:27:00.004+09:00

ユーザー定義のデータ型（構造体）

この投稿ではLibreOfficeかApache OpenOfficeのマクロ言語であるBasicにおいてユーザー定義のデータ型を宣言する2種類の方法について記す。

ユーザー定義のデータ型はカスタム・データ型と呼ばれていることもある。それは型の違いに関わらず1つ以上の変数をまとめて1つのデータ型とし、そのデータ型に名前を付けたもの。その要素となる変数はメンバーと呼ばれている。

ユーザー定義のデータ型はC言語で言うところの構造体、Pascalで言うところのレコードによく似ている。Pythonの辞書にも似ているが、辞書はハッシュ・テーブルの一種であると解釈されるものかもしれない。

構造体やレコードとクラスとの違いは、構造体やレコードがデータ・プロパティだけを持ち、コード・プロパティを持たないこと。データ・プロパティとは単にプロパティと呼ばれていたりメンバー変数と呼ばれていたりするもの。コード・プロパティとはメソッドと呼ばれていたりメンバー函数と呼ばれていたりするもの。

LibreOffice BasicまたはApache OpenOffice Basicでは、ユーザー定義のデー型（構造体）を次のような2種類の方法で定義することができる。

Type宣言を用いる方法。
UNO(Universal Network Objects)を利用する方法。

Type宣言を用いて構造体を定義

モジュール内のサブルーチンの外にType宣言を記述することによって構造体を定義することができる。

Type宣言はサブルーチンの外側に置く必要があり、Typeというキーワードによって始まり、End Typeというキーワードによって終わる。

次の例では出版物の属性をひとまとまりにしたBooksという構造体を定義している。

REM  ***** 構造体を定義 *****

'VBA拡張
Option Compatible

'Typeを用いた構造体宣言
Type Books
  BookTitle As String
  Subtitle As String
  Author As String
  Translator As String
  Publisher As String
  PublicationDate As Date
  PrintLength As Integer
  PriceYen As Integer
End Type
 
Sub Main
  'インスタンス変数を宣言
  Dim books1 As Books
  'データを代入
  books1.BookTitle = "科学と仮説"
  books1.Subtitle = void
  books1.Author = "ポアンカレ"
  books1.Translator = "伊藤邦武"
  books1.Publisher = "岩波書店"
  books1.PublicationDate = "2021/12/17"
  books1.PrintLength = 494
  books1.PriceYen = 1320

  'メッセージボックスへ表示
  MsgBox("書籍：" & books1.BookTitle & vbNewLine & _
   "副題：" & books1.Subtitle & vbNewLine & _
   "著者：" & books1.Author & vbNewLine & _
   "翻訳：" & books1.Translator & vbNewLine & _
   "出版社：" & books1.Publisher & vbNewLine & _
   "発行日：" & books1.PublicationDate & vbNewLine & _
   "頁数：" & books1.PrintLength & vbNewLine & _
   "価格：" & books1.PriceYen)
End Sub

Option Compatibleという宣言はvbNewLineという文字列定数を使うために必要だった。

Booksと名付けた構造体をType宣言によって定義した。

例えば「Dim BookTitle As String」という文はString型としてBookTitleという名のメンバー変数（データ・プロパティ）を定義する」というような意味。

Type宣言の後に置かれたMainというサブルーチンでは、まず構造体のBooksからbooks1というインスタンス変数を宣言し、次にその構造体の各メンバー（データ・プロパティ）に値を代入した。ここでは岩波書店から出版されているポアンカレの『科学と仮説』を例に挙げさせていただいた。

voidは空の値を意味する。

構造体に値を設定し終わったら、メッセージボックスにそれらを表示するようにした。文字列定数のvbNewLineは改行を意味している。

ちなみにこのMainサブルーチンは、C言語のmain函数と違い、プログラムの開始点を必ずしも意味しない。つまりその存在は必須ではない。

改行前のアンダーバー(_)はこの文が改行後も続くという意味。ただしこの例の場合、アンダーバーの前に空白を入れる必要があることに要注意。

PropertyValue UNO構造体を用いる方法

サブルーチンの外でType宣言を行う代わりにユニバーサル・ネットワーク・オブジェクト(UNO)のサービスであるcom.sun.star.beans.PropertyValueを利用しても構造体を定義することができる。

ただし構造体のメンバーが複数ある場合、構造体に番号を振って順序付構造体にする必要がある。

次の例では上述のコードと同様にBooksという構造体を定義した。

Booksには配列のように8つの番号を付けて順序付構造体にした。0から数えるのでBooks(7)となる。

REM ***** UNO構造体を定義 *****

Sub Main
  'UNOを利用した構造体宣言
  Dim Books(7) As New com.sun.star.beans.PropertyValue
  '各データ名を代入
  Books(0).Name = "書籍"
  Books(1).Name = "副題"
  Books(2).Name = "著者"
  Books(3).Name = "翻訳者"
  Books(4).Name = "出版社"
  Books(5).Name = "発行日"
  Books(6).Name = "頁数"
  Books(7).Name = "価格"

  '各データを代入
  Books(0).Value = "論理哲学論考"
  Books(1).Value = void
  Books(2).Value = "ウィトゲンシュタイン"
  Books(3).Value = "野矢茂樹"
  Books(4).Value = "岩波書店"
  Books(5).Value = "2003/8/20"
  Books(6).Value = 256
  Books(7).Value = 858
  
  'オブジェクト型変数を宣言
  Dim Doc,Sheet As Object
  Dim Cell1,Cell2 As Object
  
  '現在のドキュメントのインスタンス変数
  Doc = ThisComponent
  'シート"Sheet1"のインスタンス変数
  Sheet = Doc.Sheets.getByName("Sheet1")

  Dim i As Integer
  'セルに1つずつ書き込むループ
  For i=0 To 7
    Cell1 = Sheet.getCellByPosition(0,i)  
    Cell1.String = Books(i).Name
    
    If i > 6 Then
      'セルのインスタンス変数
      Cell2 = Sheet.getCellByPosition(1,i)
      'データをセルに入力
      Cell2.string = Books(i).Value
    Else
      'セルのインスタンス変数
      Cell2 = Sheet.getCellByPosition(1,i)
      'データをセルに入力  
      Cell2.Value = Books(i).Value
    End If
  Next i
End Sub

UNOからインスタンス変数を宣言するためにはAsだけでなくNew演算子が必要。したがってAs Newとする必要がある。次のように代入演算子とNew演算子の組み合わせでも同じことができる。

Books(7) = New com.sun.star.beans.PropertyValue

そして作成したインスタンス変数から.Nameに構造体の要素となるデータ・プロパティの識別子（名前）を代入した。

その後に.Valueに各々のデータ・プロパティの値を代入した。ここでは岩波書店から出版されているウィトゲンシュタインの『論理哲学論考』を例に挙げさせていただいた。

Calcの現在開いているドキュメントのシート"Sheet1"のセルに構造体の各データを入力するFor文を最後に記述した。

現在のドキュメントと"Sheet1"というシートのインスタンス変数をそれぞれ宣言しておき、For文の中ではCell1とCell2というインスタンス変数を宣言してBooks(7)の.Nameと.Valueの値をそれらのセルに順番に入力していくコードを書いた。

For文の中で用いたIf文は、文字列や日付の値をStringとして数値をValueとして区別してセルに入力するために使った。

順序付構造体にしないと次のようなコードになってしまうかもしれない。やや冗長であり、エレガントではない。

REM  ***** UNO構造体を定義 *****

Sub Main
  'オブジェクト変数
  Dim BookTitle As New com.sun.star.beans.PropertyValue
  Dim BookSubtitle As New com.sun.star.beans.PropertyValue
  Dim BookAuthor As New com.sun.star.beans.PropertyValue
  Dim BookTranslator As New com.sun.star.beans.PropertyValue
  Dim Publisher As New com.sun.star.beans.PropertyValue
  Dim PublicationDate As New com.sun.star.beans.PropertyValue
  Dim PrintLength As New com.sun.star.beans.PropertyValue
  Dim PriceYen As New com.sun.star.beans.PropertyValue
  
  'プロパティ名を定義
  BookTitle.Name = "書籍"
  BookSubtitle.Name = "副題"
  BookAuthor.Name = "著者"
  BookTranslator.Name = "翻訳者"
  Publisher.Name = "岩波書店"
  PublicationDate.Name = "発行日"
  PrintLength.Name = "頁数"
  PriceYen.Name = "価格"
  
  '値を代入
  BookTitle.Value = "科学と仮説"
  BookSubtitle.Value = void
  BookAuthor.Value = "ポアンカレ"
  BookTranslator.Value = "伊藤邦武"
  Publisher.Value = "岩波書店"
  PublicationDate.Value = "2021/12/17" 
  PrintLength.Value = 494
  PriceYen.Value = 1320

  'オブジェクト型変数を宣言
  Dim Doc,Sheet As Object
  Dim Cell1,Cell2 As Object
  
  '現在のドキュメントのインスタンス変数
  Doc = ThisComponent
  'シート"Sheet1"のインスタンス変数
  Sheet = Doc.Sheets.getByName("Sheet1")

  'セルにプロパティ名を入力
  With Sheet
    .getCellByPosition(3,0).String = BookTitle.Name
    .getCellByPosition(3,1).String = BookSubtitle.Name
    .getCellByPosition(3,2).String = BookAuthor.Name
    .getCellByPosition(3,3).String = BookTranslator.Name
    .getCellByPosition(3,4).String = Publisher.Name
    .getCellByPosition(3,5).String = PublicationDate.Name
    .getCellByPosition(3,6).String = PrintLength.Name
    .getCellByPosition(3,7).String = PriceYen.Name
  End With
  'セルに値を入力
  With Sheet
    .getCellByPosition(4,0).String = BookTitle.Value
    .getCellByPosition(4,1).String = BookSubtitle.Value
    .getCellByPosition(4,2).String = BookAuthor.Value
    .getCellByPosition(4,3).String = BookTranslator.Value
    .getCellByPosition(4,4).String = Publisher.Value
    .getCellByPosition(4,5).String = PublicationDate.Value
    .getCellByPosition(4,6).Value = PrintLength.Value
    .getCellByPosition(4,7).Value = PriceYen.Value
  End With
End Sub

LibreOffice Basic 変数データ型スコープ定数演算子配列構造体

HTML5 Canvasで矢印を描いてみた（三角関数を利用）

2022-06-23T19:54:00.011+09:00

この投稿ではHTML5 Canvasの2次元コンテキストのAPIを利用して矢印を描くJavaScriptのコードを書いてみた。

ここで描く図は次のようなもの。

たったこれだけ。にもかかわらずコードのほうはオブジェクト指向の体裁になるように汎用性を多少持たせてやや大げさに設計してみた。これを更に発展させれば低次元のベクトル空間を描けるものになるかもしれない。

HTMLのCanvas要素

矢印を描くためにHTML5 Canvasの2次元コンテキストのAPIを利用するので、HTML文書のbody要素内にCanvas要素を記述しておく必要があった。それは例えば次のようになる。

<canvas id="arrow" width="250" height="250">
このブラウザはHTML5 CanvasかJavaScritが有効ではありません。
</canvas>

Canvasタグのid属性にはこのCanvas要素を一意に特定するための名前を指定する。ここではarrowとした。

widthはキャンバスの幅。heightはキャンバスの高さ。

HTML5 Canvasが有効でないときにはCanvasタグに挟まれた部分の文字列が表示される。

JavaScriptのコード

JavaScriptのコードはscriptタグで挟んだscript要素内に記述する。script要素はHTML文章のbody要素の後に置くことが望ましい。少なくともCanvas要素の後である必要がある。

</body>
<script>
// JavaScriptのコード
</script>
</html>

そうでなければ、例えばCanvas.jsと名付けた別のファイルに保存し、HTML文書内から次のように呼び出すこともできる。

<script type="text/javascript" src="arrow.js"></script>

矢印オブジェクトを返すファクトリ函数

まず矢印オブジェクトを設計した。オブジェクト・リテラルを返すファクトリ函数かんすうによって矢印オブジェクトを量産できるようにした。ファクトリ函数とはそれが呼び出されるとreturn文によってオブジェクト・リテラルを出力する特別な函数のこと。

ファクトリ函数ではreturn文にオブジェクト・リテラルないしはオブジェクト・リテラルを指し示す変数を記述する。

//arrowオブジェクトを返すファクトリ函数
function arrow(){
   //プライベートなプロパティ
   return //オブジェクト・リテラル
}

オブジェクト・リテラルとは1つまたは複数のプロパティをその値と共に波括弧によって挟む記法。JavaScriptにはクラスの概念がなく、オブジェクトをリテラルとして直接表記することができる。その記法はPythonの辞書に近い。

{プロパティ名:値, プロパティ名:値, メソッド名:匿名函数, メソッド名:匿名函数}

プロパティはその値に匿名の函数を持つこともできる。値に函数を持つプロパティはコード・プロパティやメソッドと呼ばれている。メソッドも函数を値として持つプロパティの一種。

プライベートなプロパティ

JavaScriptにはprivateやpublicやprotectedといったアクセス修飾子がこれまでのところない。アクセス修飾子はオブジェクトや函数の外からのアクセスを許可するかどうかを決めるキーワード。

その代わりにファクトリ函数ではreturn文によって返されるオブジェクト・リテラルの外に通常のローカル変数としてプロパティを記すことにより、それらのプロパティに対してオブジェクトの外から直接アクセスできないようにすることができる。

次のコードは矢印オブジェクトを返すファクトリ函数のローカル変数として指定したプロパティ。これらのローカル変数はその函数（ファクトリ函数では結果的にオブジェクト）の外から直接アクセスできないため、プライベートなプロパティとして働く。

function arrow(){

   //プライベートなプロパティとその値
  const ShaftTailX = 0; //幹末端の水平座標
  const ShaftTailY = 0; //幹末端の垂直座標
  let ShaftHeadX = 100; //幹先端の水平座標
  const ShaftHeadY = 0; //幹先端の垂直座標
  let headLength = 7; //鏃の長さ
  let headAngle = 160; //鏃の角度
  let arrowWidth = 1; //矢印の太さ
  let color = "black" //矢の色

  return //オブジェクト・リテラル
}

ShaftTailXプロパティとShaftTailYプロパティは矢印の幹の末端部分のそれぞれ水平座標Xと垂直座標Yを表している。

ShaftHeadXプロパティとShaftHeadYプロパティは矢印の幹の先端部分のそれぞれ水平座標Xと垂直座標Yを表している。

ここで言うところの先端とは矢印の方向を指し示す鏃やじりがあるほうの端点を表し、末端とは鏃がないほうの端点を表している。

それぞれの初期値はShaftTailXとShaftTailYを(0,0)とし、ShaftHeadXとShaftHeadYを(100,0)とした。

ShaftHeadXプロパティの値が矢印の幹の長さを事実上決める。それ以外の座標を表すプロパティ（ローカル変数）は変更されては困る設計にしたので、constをそれらの前に置いて定数化した。

ちなみにJavaScriptで変数の宣言を表すletとvarは函数の内部では同じ働きをするのでどちらを用いても構わない。

これらのプロパティの初期値によって矢印の幹の部分だけを描くと次のように水平な直線になる。

headLengthプロパティは矢印の鏃やじりの部分を構成する折れ曲がった2つの線分の長さを表すもの。

headAngleプロパティは矢印の鏃を構成する折れ曲がった2つの線分の角度を表すもの。

ただし鏃のこの角度の概念は常識的な直感にやや反しているかもしれないので、分かりやすくするために次の図によって角度ごとの鏃の状態の違いをならべて示してみた。

余談だけれど、Y字に似た二股の鏃を持った矢は実際に存在する。例えば音を出す鏑かぶらが付いた鏑矢という狩りや儀式に用いられる矢があるが、その鏃にY字の形がよく見られる。

arrowWidthプロパティは矢印の線の太さを表している。ただしこの値を大きくしすぎると、特に最後の例ではっきり分かるように鏃部分の形が崩れてしまう。矢印オブジェクト（を返すファクトリ函数）を設計する段階での改善の余地があるが、今回はこのまま。

colorプロパティは文字通り矢印の色を表すもの。

オブジェクト・リテラルを返すreturn文

ファクトリ函数のローカル変数として記したプライベートなプロパティの後にはreturn文を置く。

//Arrowオブジェクトを返すファクトリ函数
function Arrow(){
   //プライベートなプロパティ

   //return文
   return{
     //プロパティ名:値,
     //プロパティ名:値,
     //メソッド名:匿名函数
   };
}

return文に置かれたプロパティとメソッドは、ファクトリ函数を介して作成されたオブジェクトの外部から直接アクセスすることができるので、オブジェクトの外に公開されたパブリックなものになる。

オブジェクト・リテラルにはまず、オブジェクト指向プログラミングらしくアクセサー・メソッドを記した。アクセサー・メソッドとはプライベートなプロパティにアクセスするために専用に設けるメソッドのこと。ここでは設定用のアクセサー、すなわちセッターだけを記述した。

function Arrow(){
  //プライベートなプロパティ

  //オブジェクト・リテラルを返す
  return {
    //パブリックなアクセサーメソッド（セッター）
    setArrowLength : function(arg){ShaftHeadX = arg},
    setHeadLength : function(arg){headLength = arg},
    setHeadAngle : function(arg){headAngle = arg},
    setArrowWidth : function(arg){arrowWidth = arg},
    setColor : function(arg){color = arg},
  };
}

ShaftHeadXプロパティの値が矢印の幹の長さを決めるため、そのアクセサー名はsetArrowLengthにした。

アクセサー・メソッドの名前（識別子）はもちろん任意だけれども、セッターの場合は「setプロパティ名」と名付けられていることが多い。ちなみに取得用のゲッターの場合は「getプロパティ名」と名付けられていることが多い。

各々の匿名函数の仮引数に指定したargはargumentの略で任意。parameterのparaとしても良かったのかもしれない。

オブジェクト・リテラルのコーディングで間違え易いのはイコールではなくコロンでプロパティと値との間を区切ることと、文の終わりがセミコロンではなくカンマで区切ること。これらを間違えていたり忘れていたりすることがよくある。その際、文法エラーとなる。

これらのアクセサー・メソッド（セッター）には見ての通り、値を外から受け取ってプライベートなプロパティに渡す以上の機能を持たせていない。

描画メソッド

アクセサー・メソッドの次に記したのは描画メソッド。メソッドの各々の仮引数にもコメントを付けるためにここではインデントと改行を使ったブロック記法で記述してみた。

return{
  //アクセサー・メソッド
   
  draw : function(
    CanvasId, //Canvas要素のID属性
     x, //座標系の原点の水平座標
     y, //座標系の原点の垂直座標
     angle //座標系の回転角度
   ){
      //...
  }

このメソッドは引数としてHTMLのCanvas要素に設定したID属性と座標系の原点となる水平座標xと垂直座標y、そしてその座標系を原点を軸に回転させたときの角度angleを受け取ることにした。

スクリーン座標系

矢印を描く上で方眼紙として働く座標系の原点と角度については少し説明を要すると思う。

HTML5 Canvasの2次元コンテキストで用いられる座標系はいわゆるスクリーン座標系と呼ばれているもの。スクリーン座標系はデフォルトでは左上端が(0,0)になり、下に向かうほど、または右に向かうほどそれらの値が大きくなる。

スクリーン座標系は次のようにデカルト座標系が逆立ちしたような構造になっている。

HTML5 Canvasのtranslate()というメソッドを使うとスクリーン座標系の原点(0,0)を移動できる。

HTML5 Canvasのrotate()というメソッドを使えば引数に角度を指定することによってそのスクリーン座標系をその原点を軸にして回転移動させることができる。ただし角度は弧度法（ラジアン）で指定する必要がある。

スクリーン座標系の原点の位置が動くとその上に描かれた矢印も動くので、これによって矢印を描く位置を変えることができる。スクリーン座標系を回転移動させるとその上に描かれた矢印も回転移動するので、これによって矢印の向きを変えることができる。

描画メソッドdraw()の仮引数にあるxとyは座標系の原点の位置を決め、translate()メソッドの引数として使う。

描画メソッドdraw()の仮引数にあるangleは座標系の角度を決め、rotate()メソッドの引数として使う。

次に描画メソッドdraw()の中身について記す。

まずはHTML5 Canvasの2次元コンテキストのAPIを利用するためのお決まりの文。描画メソッドの仮引数の1つCanvasIdはHTMLの特定のCanvas要素を取得するためにここで使う。

//HTML5 Canvas 2DのAPIを利用する準備
const Canvas = document.getElementById(CanvasId);
const Ctx = Canvas.getContext("2d");

スクリーン座標系の状態の保存と復元

translate()を使って原点を移動させる前にスクリーン座標系のデフォルト状態を保存しておく必要がある。それにはHTML5 Canvasのsave()というメソッドを利用する。そして描画メソッドの終わりでrestore()というメソッドを呼び出し、save()メソッドによって保存しておいた状態を復元する。

この保存と復元の手続きを省くと描画メソッドを繰り返し呼び出したときに想定外の副作用が生じてしまう。

draw : function(CanvasId,x,y,angle){
  //HTML5 Canvas 2DのAPIを利用する準備
  const Canvas = document.getElementById(CanvasId);
  const Ctx = Canvas.getContext("2d");

  //この時点の状態を保存
  Ctx.save();

  //...

  //save()で保存した状態を復元 
  Ctx.restore();
}

save()メソッドでスクリーン座標系のデフォルト状態を保存した後、translate()メソッドによって原点を移動させる処理をする。その仮引数となるx（水平座標）とy（垂直座標）にはこの描画メソッドであるdraw()を呼び出すときに受け取る引数の水平座標xと垂直座標yが収まる。

そしてrotate()メソッドによって原点を軸にしてスクリーン座標系を回転移動させる。draw()を呼び出すときに受け取る引数のangleがrotate()メソッドの引数に収まる。

//この時点の状態を保存
Ctx.save();

//スクリーン座標系の原点を移動
Ctx.translate(x,y);
//スクリーン座標系を回転移動
Ctx.rotate(-1 * toRadians(angle));

rotate()メソッドの引数に与える角度はラジアンという単位である必要があるのでtoRadians()函数を呼び出して度数法を弧度法に変換させるようにした。このtoRadians()函数は自作したもの。

更にそこで-1を掛けているのは、角度の値の正負の符号を反転させ、角度が反時計回りに計られるようにしたため。これをしないと反時計回りに計られる通常の角度とは違い、なぜだか時計回りに角度が計られてしまうので、angleに値を渡すときに混乱すると思う。

次にHTML5 Canvasの2次元コンテキストのAPIを利用して矢印の幹に当たる直線を描くコードを書く。

//矢印の幹の直線を描く
Ctx.beginPath(); //パスの初期化
Ctx.lineWidth = arrowWidth; //線の太さ
Ctx.strokeStyle = color; //線の色
Ctx.moveTo(shaftTailX, shaftTailY); //線の始点座標
Ctx.lineTo(ShaftHeadX, ShaftHeadY); //線の終点座標
Ctx.stroke(); //パスに従って直線を描く

線を描く通り道（パス）をbeginPath()メソッドによってまずは初期化しておく必要がある。

HTML5 CanvasのlineWidthプロパティに線の太さを表すために用意しておいたarrowWidthプロパティの値を代入。

HTML5 CanvasのstrokeStyleプロパティに線の色を表すために用意しておいたcolorプロパティの値を代入。

線の始点となる水平座標と垂直座標をHTML5 CanvasのmoveTo()メソッドの引数に代入。

線の終点となる水平座標と垂直座標をHTML5 CanvasのlineTo()メソッドの引数に代入。

線の通り道（パス）が決まったところでHTML5 Canvasのstroke()メソッドを呼び出して直線を描く。

次に描くのは矢印の鏃を形作るために矢印の先端から少し角度を変えて伸びる2つの線分。

この鏃の部分を描くのに今回は数学的な技術をちょっとだけ使ってみた。こうする必要はなかったのだけれども数学的技術を導入することで鏃の長さや角度を自由に変えられるように汎用性を多少与えてみた。

数学的な変換を行う函数

数学的手続き（アルゴリズム）に汎用性を持たせるためにそれらを独立した3つの函数として宣言した。

その1つが角度を度数法の単位から弧度法の単位へと変換する函数であるtoRadians()。度数法の値dを弧度法の値rへ変換するための公式は例えば次のとおり。

\[ r = \dfrac{\pi d}{180} \]

度数法の値に円周率πを掛けてその解を180で割るという簡単な計算。

ラジアンは弧度法という角度の測定法に基づいた角度の単位のこと。弧度法では円の半径の長さを1ラジアンとして円弧の距離を測り、反時計回りに半回転するとちょうど円周率πと同じ値になる。反時計回りに一回転するとちょうど円周率πの2倍になる。つまり度数法での180度がπになり、360度が2πになる。

この函数は入力値として度数法の値degreeを受け取り、上の式による計算をした後、その解である弧度法の値radianを出力する。

\[ rdian = f(degree) \]

この函数をJavaScriptで表すと例えば次のようになる。

//度数法を弧度法に変換する函数
function toRadians(degree){
  return degree * (Math.PI/180.0);
}

残りの2つの函数は2次元平面の極座標系である円座標系を直交座標系に変換するもの。円座標系は半径の長さと角度で定義された座標系であるので、この座標系を直交座標系に変換すれば線分の長さと角度から直交座標系での座標(x,y)を得ることができる。

線分の長さをr、水平座標をx、垂直座標をy、角度をθシータとすると、円座標から直交座標への変換は次のような式に表すことができる。

\[ x = r \cos\theta \] \[ y = r \sin\theta \]

要するに、直交座標系での水平座標xは原点までの直線距離を斜辺rとする直角三角形の余弦函数$ \cos\theta $の出力値をr倍したものに等しく、垂直座標yはその正弦函数$ \sin\theta $の出力値をr倍したものに等しい。

ここで三角函数（三角比）についてのちょっとしたおさらい。

三角函数と呼ばれているものは実は三角法函数のことであり、その言葉通りに三角法に基づいている。語源を辿ると三角形測量函数と呼ぶこともできる。

三角法を用いると直接には測量できない物の長さや区間の距離を推定することができる。

三角法を理解するためには次のように半径を1とする単位円に基づいて描いた座標系を理解するのが良い方法であると思う。次の図は2次元平面の直交座標系と2次元平面の極座標系である円座標系とを重ね合わせるように描いたもの。

\[ r = \overline{PO} \] \[ \angle{PHO} = 90^\circ \]

上の図では点線の$ \overline{PH} $が直角三角形の対辺であると同時に直交座標系のy座標に相当し、$ \overline{OH} $が直角三角形の隣辺であると同時に直交座標系のx座標に相当することに注目。

三角法で重要なのは時計の針が時刻3時の始点から反時計回りにどれだけ回転移動した位置にあるかということ。その角度θが常に直角三角形の内角になるとは限らない。角度θが度数法で90度を超えると、すなわち鈍角どんかくになると、直角三角形の内角ではなくなる。

三角法は直角三角形によって特徴付けられているよりは直交座標系と極座標系（円座標系）との互換性によって特徴付けられている。

ちなみに極座標系とは半径rと角度座標θから位置を定める次のような座標系のこと。極座標系では原点は極と呼ばれており、半径rは動径どうけいと呼ばれている。

三角法函数とは、角度θの値を決めてやると、点Pのx座標とy座標と半径（動径）rの長さとのいずれかの2対を取り出したときのその比率が一意に定まる関係を意味している。

各々の入力の値の集合に応じて出力の値が常に一定になるので函数と見なすことができる。同じ入力値を与えているのにその度に一定しない気まぐれな出力値が返ってくるようだとそれを函数と見なすことはできない。函数とは入力値と出力値との間の因果関係がはっきりしている関係であると考えることができる。

頻繁に使われる最も代表的でかつ汎用性を持った三角法函数は3種類あり、ここではその内の2種類を利用する。その2種類とは正弦せいげん函数（サイン）と余弦よげん函数（コサイン）。ちなみに残りの1種類は正接せいせつ函数（タンジェント）。

数学的な表記法では、正弦函数は$ \sin\theta $、余弦函数は$ \cos\theta $、正接函数は$ \tan\theta $と表されることが多いが、角度θは三角法函数の仮引数となる変数であるので、コンピューター・プログラミングに馴染みのある人にとってはsin(θ)、cos(θ)、tan(θ)と表記したほうが分かりやすい。

正弦函数は角度θが与えられたときに斜辺に対して対辺がどのくらいの比率になるのかを示している。余弦函数は角度θが与えられたときに斜辺に対して隣辺がどのくらいの比率になるのかを示している。

正弦函数 $ \sin\theta $: 角度θを引数として入力したとき、正弦函数は直角三角形の斜辺の長さに対する対辺の長さの割合（比率）を出力する。\[ \sin\theta = \dfrac{\text{対辺}}{\text{斜辺}} \]; もしくは円の半径rに対する点Pのy座標の割合（比率）を出力する。\[ \sin\theta = \dfrac{y座標}{半径r} \]; したがってこのことは、正弦函数が出力した比率に斜辺の長さ（半径r）を掛ければ対辺の長さ（y座標）が得られることを意味している。\[ \text{対辺} = \text{斜辺} \times \sin\theta \] \[ y\text{座標} = \text{半径}r \times \sin\theta \]

余弦函数 $ \cos\theta $: 角度θを引数として入力したとき、余弦函数は直角三角形の斜辺の長さに対する隣辺の長さの割合（比率）を出力する。\[ \cos\theta = \dfrac{\text{隣辺}}{\text{斜辺}} \]; もしくは円の半径rに対する点Pのx座標の割合（比率）を出力する。\[ \cos\theta = \dfrac{x座標}{半径r} \]; したがってこのことは、余弦函数が出力した比率に斜辺の長さ（半径r）を掛ければ隣辺の長さ（x座標）が得られることを意味している。\[ \text{隣辺} = \text{斜辺} \times \cos\theta \] \[ x\text{座標} = \text{半径}r \times \cos\theta \]

正接函数 $ \tan\theta $: 角度θを引数として入力したとき、正接函数は直角三角形の隣辺の長さに対する対辺の長さの割合（比率）を出力する。\[ \tan\theta = \dfrac{\text{対辺}}{\text{隣辺}} \]; もしくは点Pのx座標に対するy座標の割合（比率）を出力する。\[ \tan\theta = \dfrac{y\text{座標}}{x\text{座標}} \]; したがってこのことは、正接函数が出力した比率に隣辺の長さ（x座標）を掛ければ対辺の長さ（y座標）が得られることを意味している。\[ \text{対辺} = \text{隣辺} \times \tan\theta \] \[ y\text{座標} = x\text{座標} \times \tan\theta \]

要するに、斜辺の長さ（半径rまたは動径r）と角度θが分かっているとき、正弦函数によって対辺の長さ（y座標）を計算でき、余弦函数によって隣辺の長さ（x座標）を計算することができる。

そういう訳で正弦函数と余弦函数を利用すると極座標系（円座標系）を直交座標系に変換することができる。

極座標から直交座標への変換を式にして表すと例えば次のようになる。

\begin{align} (r,\theta) \rightarrow (x,y) &= \left( r \times \dfrac{\overline{OH}}{\overline{OP}}, r \times \dfrac{\overline{PH}}{\overline{OP}} \right) \\ &= (r\cos\theta,r\sin\theta) \end{align}

これをJavaScriptの函数にしてみると次のように書けると思う。

/* 極座標（円座標）を直交座標へ変換する函数
引数は極座標r,θ（θの単位はラジアン） */
function polarToCartesianX(r,radian){
  return r * Math.cos(radian);
}
function polarToCartesianY(r,radian){
  return r * Math.sin(radian);
}

x座標（水平座標）を返す函数とy座標（垂直座標）を返す函数の2つを宣言した。それぞれpolarToCartesianX()とpolarToCartesianY()と名付けた。

これらの函数内では余弦函数と正弦函数を記すためにJavaScriptの組み込みメソッドであるMath.cos()とMath.sin()を利用した。

以上の3つの函数はどこからでも自由に呼び出せるように特定の函数や特定のオブジェクトの内部に閉じ込めず、外に置いてグローバル・スコープにした。

矢印の鏃の部分を描く方法

矢印オブジェクトを返すファクトリ函数に話を戻す。そのreturn文によって返すオブジェクト・リテラルの中に記したdrawという描画メソッドの続き。

HTML5 Canvasの2次元コンテキストのAPIを利用して矢印の幹の部分の次に描くのは鏃やじりの部分。その線分の長さと角度を変えられるように汎用性を若干与える設計をした。

矢の幹の先端から上下対称（左右対称）に両側に伸びる2つの線分を描く。始点は矢の幹の先端だとして、終点になる座標はそれらの線分の長さと角度から相対的に計算するようにした。

それらのコードは次のようになった。

draw : function(CanvasId,x,y,angle){
  //...

  //鏃の相対的座標を計算して各変数に代入
  const HeadLeftWingX = polarToCartesianX(headLength,
    toRadians(headAngle)) + ShaftHeadX;
  const HeadLeftWingY = polarToCartesianY(headLength,
    toRadians(headAngle)) + ShaftHeadY;
  const HeadRightWingX = polarToCartesianX(headLength,
    toRadians(-1 * headAngle)) + ShaftHeadX;
  const HeadRightWingY = polarToCartesianY(headLength,
    toRadians(-1 * headAngle)) + ShaftHeadY;

//...
}

鏃を形作る2本の線分のそれぞれ終点を表す座標を入れるために、HeadLeftWingXとHeadLeftWingY、そしてHeadRightWingXとHeadRightWingYという4つの変数を用意した。Xが水平座標、Yが垂直座標。

鏃を形作る2本の線分の終点を表す座標をその角度とその長さから相対的に決めるために極座標系（円座標系）を直交座標系に変換する2つの函数を呼び出して利用した。線分の長さと角度を引数として渡すと水平座標xを出力するpolarToCartesianX()と、同様に引数を与えると垂直座標yを出力するpolarToCartesianY()がそれら。

極座標系（円座標系）を直交座標系に変換するこれら2つの函数には鏃を形作る線分の長さを表すheadLengthと角度を表すheadAngleという引数を変数で与えている。ただし線分のもう片方に与える角度には-1を掛けて負数し、時計回りに角度を指定する必要があった。

これらの2つの函数に与える角度は弧度法で指定する必要があるので、同じく自作したtoRadians()函数を呼び出して利用した。

しかしこれだけだとまだ思ったところに鏃が描画されず、鏃が異常に伸びてしまったので、極座標を直交座標に変換する函数が返した値に矢印の幹の先端の水平座標を表すShaftHeadXの値を更に加算する必要があった。

これで鏃を描く準備が整った。

次のコードは鏃の部分をHTML5 Canvasの2次元コテンテキストのAIPを利用して描画するもの。

draw : function(CanvasId,x,y,angle){
  //...

  //鏃を描く
  Ctx.beginPath(); //パスの初期化

  //パスの指定
  Ctx.moveTo(ShaftHeadX, ShaftHeadY);
  Ctx.lineTo(HeadLeftWingX, HeadLeftWingY);
  Ctx.moveTo(ShaftHeadX, ShaftHeadY);
  Ctx.lineTo(HeadRightWingX, HeadRightWingY);

  Ctx.stroke(); //描画

  //...
}

まずHTML5 CanvasのbeginPath()メソッドによってパスを初期化。

次にHTML5 CanvasのmoveTo()メソッドに鏃を形作る線分の始点となる座標を与えた。つまり鏃の幹の先端の座標が入ることになるShaftHeadXとShaftHeadY。

HTML5 CanvasのlineTo()メソッドの引数には鏃を形作る線分の終点となる座標を与えた。極座標を直交座標に変換する2つの函数であるpolarToCartesianX()またはpolarToCartesianY()を呼び出して計算する相対的座標を入れる4つの変数はここで使った。

こうしておいてHTML5 Canvasのstroke()メソッドを呼び出して鏃を描画させるようにした。

最後にrestore()メソッドを呼び出してsave()メソッドで保存しておいたスクリーン座標系の元の状態を復元すれば波括弧でブロックを閉じてdrawメソッドは完成。

//save()で保存した状態を復元
Ctx.restore();

これで矢印オブジェクトを返すファクトリ函数も波括弧でブロックを閉じれば完成する。

矢印オブジェクト・リテラルを返すファクトリ函数Arrowのコード全体は次のようになる。

//Arrowオブジェクトを返すファクトリ函数
function Arrow(){

  //プライベートなプロパティ
  const shaftTailX = 0; //幹末端の水平座標
  const shaftTailY = 0; //幹末端の垂直座標
  let ShaftHeadX = 100; //幹先端の水平座標
  const ShaftHeadY = 0; //幹先端の垂直座標
  let headLength = 7; //鏃の長さ
  let headAngle = 160; //鏃の角度
  let arrowWidth = 1; //矢印の太さ
  let color = "black" //矢の色

  //オブジェクト・リテラルを返す
  return{
    //パブリックなアクセサーメソッド（セッター）
    setArrowLength : function(arg){ShaftHeadX = arg},
    setHeadLength : function(arg){headLength = arg},
    setHeadAngle : function(arg){headAngle = arg},
    setArrowWidth : function(arg){arrowWidth = arg},
    setColor : function(arg){color = arg},

    /*描画メソッド：
    引数はCanvas要素のIDと描画座標と描画角度*/
    draw : function(CanvasId,x,y,angle){

      //HTML5Canvas2DのAPIを利用する準備
      const Canvas = document.getElementById(CanvasId);
      const Ctx = Canvas.getContext("2d");

      //この時点の状態を保存
      Ctx.save();

      //座標系の原点を移動
      Ctx.translate(x,y);
      /* 座標系を原点を軸に回転移動
        かつ正負を反転させて反時計回りに */
      Ctx.rotate(toRadians(-1 * angle));

      //矢印の幹の直線を描く
      Ctx.beginPath();
      Ctx.lineWidth = arrowWidth;
      Ctx.strokeStyle = color;
      Ctx.moveTo(shaftTailX,shaftTailY);
      Ctx.lineTo(ShaftHeadX,ShaftHeadY);
      Ctx.stroke();

      //鏃の部分を描く

      //鏃の相対的座標を計算して各変数に代入
      const HeadLeftWingX = polarToCartesianX(headLength,
        toRadians(headAngle)) + ShaftHeadX;
      const HeadLeftWingY = polarToCartesianY(headLength,
        toRadians(headAngle)) + ShaftHeadY;
      const HeadRightWingX = polarToCartesianX(headLength,
        toRadians(-1 * headAngle)) + ShaftHeadX;
      const HeadRightWingY = polarToCartesianY(headLength,
        toRadians(-1 * headAngle)) + ShaftHeadY;

      //鏃を描く
      Ctx.beginPath();
      Ctx.moveTo(ShaftHeadX,ShaftHeadY);
      Ctx.lineTo(HeadLeftWingX,HeadLeftWingY);
      Ctx.moveTo(ShaftHeadX,ShaftHeadY);
      Ctx.lineTo(HeadRightWingX,HeadRightWingY);
      Ctx.stroke();

      //save()で保存した状態を復元
      Ctx.restore();
    }
  };
}

ラベル・オブジェクトを返すファクトリ函数

矢印になんらかのラベル付けを行いたかったのでラベル・オブジェクトを返すファクトリ函数も作ってみた。

//ラベル・オブジェクトを返すファクトリ函数
function Label(){

  //プライベートなプロパティ
  let font = "15px serif"; //フォント属性
  let color = "black"; //文字の色
  let align = "center"; //文字の水平位置
  let baseline = "middle"; //文字の垂直位置

  //オブジェクト・リテラルを返す
  return {

    //アクセサー（セッター）
    setFont : function(arg){font = arg;},
    setColor : function(arg){color = arg;},
    setAlign : function(arg){align = arg;},
    setBaseline : function(arg){baseline = arg;},

    //描画メソッド（ID,文字,x座標,y座標,最大文字幅）
    draw : function(CanvasId,text,x,y,largestWidth){

    //HTML5 Canvas 2DのAPIを利用するための準備
    const Canvas = document.getElementById(CanvasId);
    const Ctx = Canvas.getContext("2d");

    //文字列を描画する
    Ctx.font = font; //フォント
    Ctx.strokeStyle = color; //色
    Ctx.textAlign = align; //文字の整列
    Ctx.textBaseline = baseline; //
     //文字を描画
    Ctx.fillText(text,x,y,largestWidth);
    }
  };
}

fontプロパティの15pxが文字の大きさを意味している。

それらのプロパティはプライベート領域に置いてローカル変数にし、アクセサー・メソッドのセッターを介して値を変更できるようにした。

そしてdrawメソッドではHTML5 Canvasの2次元コンテキストのAPIを呼び出して指定した座標にラベル付けする文字列を描画できるようにした。

オブジェクトの生産と利用

ファクトリ函数はオブジェクト量産機なので、これを呼び出して任意の変数に代入すれば、オブジェクト（インスタンス変数）を次々に作り出すことができる。

描きたいのは色違いの3つの矢印なので、3つのインスタンス変数を宣言して3つの矢印オブジェクトを生産することにした。

//矢印オブジェクトを生産
const arrow1 = Arrow();
const arrow2 = Arrow();
const arrow3 = Arrow();

ファクトリ函数が返すのはオブジェクト・リテラルであるので、コンストラクター函数やクラス函数と違い、new演算子を代入演算子と一緒にそこで用いないことに注意。

で、ここで生産した矢印オブジェクトのインスタンス変数のdrawメソッドを呼び出して矢印を描いてみた。

drawメソッドの引数には、第1にCanvas要素のID属性、第2に描画位置を表すx座標、第3に描画一を表すy座標、第3にその角度を渡す必要がある。

ただし描画位置の座標は矢印の末端（尾部）の位置を表す。

角度の値を正数にすると反時計回りに角度を計り、負数にすると時計回りに角度を計る。

//矢印オブジェクトの生産
const arrow5 = Arrow();
const arrow6 = Arrow();
const arrow7 = Arrow();

//セッターを呼び出して色を設定
arrow5.setColor("green");
arrow6.setColor("#ff00ff");
arrow7.setColor("rgb(0,128,128)");

//描画メソッドを呼び出して描画
//引数はCanvas要素ID,x座標,y座標,角度
arrow5.draw("arrow",100,100,0);
arrow6.draw("arrow",100,100,150);
arrow7.draw("arrow",100,100,-90);

矢印の長さを変更するには矢印オブジェクトのセッターsetArrowLength()メソッドを呼び出す。

//矢印の長さを変更
arrow5.setArrowLength(200);
arrow6.setArrowLength(200);

//描画メソッドdrawを呼び出して矢印を描画
arrow5.draw("arrow",0,100,0);
arrow6.draw("arrow",100,200,90);
arrow7.draw("arrow",100,100,45);

鏃の長さを変更するには矢印オブジェクトのセッターsetHeadlength()を呼び出す。

鏃の角度を変更するには矢印オブジェクトのセッターsetHeadAngle()を呼び出す。

//矢印オブジェクトを生産
const arrow8 = Arrow();
const arrow9 = Arrow();
const arrow10 = Arrow();

//鏃の長さを変更
arrow8.setHeadLength(20);
arrow9.setHeadLength(30);
arrow10.setHeadLength(50);
  
//鏃の角度を変更
arrow8.setHeadAngle(45);
arrow9.setHeadAngle(90);
arrow10.setHeadAngle(150);

//矢印を描画
arrow8.draw("arrow",0,30,0);
arrow9.draw("arrow",0,100,0);
arrow10.draw("arrow",0,180,0);

各々の矢印にx,y,zのラベル付けを行いたい場合、ラベル・オブジェクトを返すファクトリ函数Levelを呼び出して利用する。

ラベル・オブジェクトの描画メソッドdrawの引数には、第1にCanvas要素のID、第2にラベルの文字列、第3にラベルを描く位置のx座標、第4にラベルを描く位置のy座標、第5にラベルの最大幅を渡す。

//矢印オブジェクトを生産
const arrow11 = Arrow();
const arrow12 = Arrow();
const arrow13 = Arrow();

/* 色設定メソッドを呼び出して矢の色を指定し、
  描画メソッドを呼び出して矢印を描く */
arrow11.setColor("red");
arrow11.draw("arrow",75,115,90);
arrow12.setColor("blue");
arrow12.draw("arrow",75,115,0);
arrow13.setColor("green");
arrow13.draw("arrow",75,115,230);

//ラベル・オブジェクトを作成
const label1 = Label();
//drawメソッドを呼び出して描く
label1.draw("arrow","x",5,200,10);
label1.draw("arrow","y",185,115,10);
label1.draw("arrow","z",75,5,10);

Lxdeの基本的なショートカットキー（快速鍵）／ホットキー

2022-04-16T22:57:00.004+09:00

私は普段使用しているLinux機に軽快なGUIインターフェイスを望んでいるので標準のデスクトップ環境（KDEやXfce等）でなくLxdeをインストールして使っている。さらに入力インターフェイスとしてはキーボードでの操作を好む。なぜだか最近のマウスはチャタリングを起こしやすく故障しやすいので。

キーボードでの操作には、ショートカットキー、またはキーボード・ショートカット、ホットキー、漢字では快速鍵と呼ばれているものがある。そこでそれらの基本的なものを表にしてみた。

働き	快速鍵
Lxpanelメニューを表示	[Alt]+[F1]
Lxpanelメニューを表示	[Ctrl]+[Esc]
Lxpanelメニューを閉じる	[Esc]
コマンド入力でアプリを起動	[Alt]+[F2]
コマンド入力でアプリを起動	[Windows]+[R]
ウィンドウを切り替える	[Alt]+[Tab]
デスクトップを切り替える	[Ctrl]+[Alt]+[←]/[→]
デスクトップ1へ	[Windows]+[F1]
デスクトップ2へ	[Windows]+[F2]
デスクトップ3へ	[Windows]+[F3]
ウィンドウを閉じる	[Alt]+[F4]
ウィンドウを全画面表示	[F11]
ウインドウごとデスクトップ移動	[Alt]+[Shift]+[←]/[→]
全てのウィンドウを表示／非表示	[Ctril]+[Alt]+[D]
ウィンドウの操作メニューを表示	[Alt]+[Space]
ウィンドウの操作メニューを閉じる	[Esc]
タスクマネージャーを起動	[Ctrl]+[Alt]+[Delete]
タスクマネージャーを終了	[Esc]
ファイルマネージャーPCManFMを起動	[Windows]+[E]
ファイルマネージャーPCManFMを終了	[Ctrl]+[Q]
ファイル検索ダイアログを起動	[Windows]+[F]

[Space]はスペースキー。
[Windows]はWindowsキーのこと。それは[Alt]の左隣または右隣にある。
ファイル検索のダイアログはファイルマネージャーPCManFMのものなので、それが表示されているデスクトップに表示される。それとは異なるデスクトップで起動した場合、起動してないように見えるので要注意。
ウィンドウ操作メニューは矢印キー（[↑][↓][←][→]）で移動、[Enter]キーで確定、[Esc]キーで取り消し。

JavaScriptでオブジェクトを作成する方法

2022-03-20T14:27:00.004+09:00

オブジェクト指向言語には大きく分けてクラス・ベースのものとプロトタイプ・ベースのものとがある。JavaScriptはプロトタイプ・ベースのオブジェクト指向としての特徴を備えているとされている。

オブジェクトとは、関連する変数や函数をまとめて名前を付けた参照型の変数のことであり、オブジェクト型変数とも呼ばれている。

JavaScriptでプログラマーが独自にオブジェクトを作るには、

オブジェクト・リテラル、
ファクトリ函数、
Object()コンストラクター、
コンストラクター函数、
クラス構文、
継承

などを用いる方法がある。それぞれについて見ていく。ただし継承についてはこの投稿では触れない。

オブジェクト・リテラル

関連する変数や函数であるプロパティの定義を列挙したオブジェクト・リテラルを変数に代入するとJavaScriptでは簡単にオブジェクトを作ることができる。この方法はオブジェクト・イニシャライザーとも呼ばれている。

ただしこの方法では1つのオブジェクト・リテラルから1つのオブジェクトしか作ることができない。

オブジェクト・リテラルの構文はJSON(JavaScript Object Notation)やPythonの辞書型のそれに似ている。すなわち「{キー:値,キー:値,...}」のようにコーディングし、そのオブジェクト・リテラルを変数に代入するだけでオブジェクトが1つ作られる。オブジェクト・リテラルではこのキーがプロパティ名やメソッド名になる。

オブジェクト・リテラルは次のようにコーディングする。

キーワード 変数名 = {
   プロパティ名1 : 値,
   プロパティ名2 : 値,
   プロパティ名3 : 値
};

キーワードにはletかconstかvarを指定することができる。

プロパティの値に函数式を与えるとそのプロパティはメソッドになる。メソッドは特別な値を持ったプロパティ。メソッドはコード・プロパティとも呼ばれることがある。

キーワード 変数名 = {
   プロパティ名 : 値,
   メソッド名 : function(仮引数){} // 函数式
};

変数に代入されるかプロパティの値に与えられる函数の定義方法は函数式とか函数リテラルと呼ばれている。それに対して独立した函数の定義方法は函数宣言とか函数文と呼ばれている。函数式の式は英語ではan expression。

函数宣言ではその函数に固有の名前（識別子）を付けるが、函数式に使われるのは名前を付けない匿名函数か矢印函数。ただし函数ブロック内でその函数を再帰的に呼び出すために匿名函数に便宜的に名前を付けることがある。

仮引数というのはその函数が呼び出されるときに一緒に括弧内に渡す値を受け取るように定義された変数であり、パラメーターとも呼ばれている。数学と違って計算機科学での変数はデータを保存する記憶領域を暗に指している。

オブジェクト・リテラルによって作成したオブジェクトはプレイン・オブジェクトと呼ばれることがある。

オブジェクトを定義しているコード・ブロックの中で定義したプロパティをその外から参照するには「オブジェクト名.プロパティ名」のようにドット演算子を用いる。

プロパティに値を設定するには次のようにコーディングする。

オブジェクト名.プロパティ名 = 値;

メソッドを呼び出すには次のようにする。

オブジェクト名.メソッド名(引数);

次に例として挙げるコードは、オブジェクト・リテラルによってオブジェクトを定義し、それをcircleという変数に代入してcircleというオブジェクトを作成し、そのオブジェクトの構成要素であるプロパティとメソッドにメッセージを送り、色違いの3つの円をHTMLドキュメント上に描くもの。

<canvas id="ol_circle" width="300" height="150"></canvas>
<script>
// オブジェクトを作成
const circle = {
   radius : 30, // 半径
   line_width : 5, // 線の太さ
   stroke_color : 'blue', // 線の色
   fill_color : 'skyblue', // 塗りつぶす色
   // 円を描くメソッド（canvas要素ID、水平座標、垂直座標）
   draw : function(canvas_id,x,y) {
      // HTML5 Canvasの2DコンテキストのAPIを利用
      const canvas = document.getElementById(canvas_id);
      const ctx = canvas.getContext('2d');
      ctx.beginPath(); // パスを初期化
      // 円のパス（水平座標、垂直座標、半径、始点、終点）
      ctx.arc(x,y,circle.radius,0,Math.PI*2);
      ctx.closePath(); // パスを閉じる
      ctx.lineWidth = circle.line_width; // 線の太さ
      ctx.strokeStyle = circle.stroke_color; // 線の色
      ctx.stroke(); // 線を描く
      ctx.fillStyle = circle.fill_color; // 塗りつぶす色
      ctx.fill(); // 塗りつぶす
   }
};

// メソッドを呼び出す
circle.draw('ol_circle',60,70);
   
// 円の色を再設定
circle.stroke_color = 'orange'; // 線の色
circle.fill_color = 'yellow'; // 塗りつぶす色

// その右に円を更に描く
circle.draw('ol_circle',130,70);

// 円の色を再々設定
circle.stroke_color = 'red'; // 線の色
circle.fill_color = 'pink'; // 塗りつぶす色

// 更にその右に円を描く
circle.draw('ol_circle',200,70);
</script>

このコードをHTMLのbody要素の間に埋め込んでウェブ・ブラウザで読み込むと次のような3つの円が描かれるはず。

描かれた円は3つだが、作ったオブジェクトはただ1つ。定義したcircleオブジェトのdrawメソッドを呼び出して1つの円を描いた後、色のプロパティを設定し直して再度drawメソッドを呼び出して描画することによって異なる色の3つの円を描いた。

ちなみに、HTML5 Canvasでは.clearRect()メソッドを用いて明示的に消去しないかぎり、何度描き直しても前に描いたものはクリアされずに残る。

ファクトリ函数

ファクトリ函数はオブジェクトを返り値に持つ函数であり、オブジェクト・リテラルをその返り値に与える構文によって定義される。

オブジェクト・リテラルでは単体のオブジェクトしか作成することができないのに対し、ファクトリ函数ではオブジェクトを量産することができる。

同じオブジェクトを複数作成したい場合、その数だけオブジェクト・リテラルを記述しなくてもその作業を函数にやらせてしまえばいいというのがファクトリ函数の考え方。

ファクトリ函数の構文は次のとおり。函数がオブジェクト・リテラルを包み込むような構造をしている。

function 函数名(仮引数){
   キーワード 変数名 = {
      プロパティ名1 : 値,
      プロパティ名2 : 値,
      プロパティ名3 : 値
   };
   return 変数名;
}

キーワードにはletかconstかvarを指定することができる。

次のようにコーディングすることもできる。こちらのほうが一般的。

function 函数名(仮引数){
   return {
      プロパティ名1 : 値,
      プロパティ名2 : 値,
      プロパティ名3 : 値
   };
}

C++やJavaのような言語にはオブジェクトのプロパティへのアクセス制御を行うアクセス修飾子と呼ばれるものがある。

アクセス演算子にはprivateとpublicとprotectedとが一般的にある。private（プライベート）は外部からのアクセスを禁じ、public（パブリック）は外部からのアクセスを許可する。protected（プロテクテド）は継承されたオブジェクトからのアクセスだけを許可する。

ところが、JavaScriptにはアクセスを制御するためのアクセス修飾子がない。けれども、ファクトリ函数では次のようにすることによってプロパティのアクセス制御を可能にし、オブジェクトのカプセル化を実装することができる。

そのためにはプロパティを函数内の通常の変数として扱い、letやvarというキーワードを付けてreturnキーワードより前に並べ、returnキーワード後のオブジェクト・リテラルのコード・ブロック内には各変数にアクセスするためのゲッター（取得者）とセッター（設定者）と呼ばれるメソッドの定義を並べる。例えば次のように。

function 函数名(仮引数){
   // プライベート
   let 変数名1 = 値;
   let 変数名2 = 値;
   let 変数名3 = 値;
   return {
      // パブリック
      ゲッター名1 : () => 変数名1,
      ゲッター名2 : () => 変数名2,
      ゲッター名3 : () => 変数名3,
      セッター名1 : 仮引数1 => 変数名1 = 仮引数1,
      セッター名2 : 仮引数2 => 変数名2 = 仮引数2,
      セッター名3 : 仮引数3 => 変数名3 = 仮引数3,
      メソッド名 : function(仮引数){}
   };
}

このようにすると、returnキーワードの後のオブジェクト・リテラルの部分だけがパブリックになって外部からアクセスでき、そうでないローカル変数の分はプライベートになって外部からは隠蔽される。

このコードで用いた「() =>」は矢印函数とも呼ばれているもの。アロー函数とも呼ばれている。通常の匿名函数「function(){}」よりも簡略にコーディングできるけれども動作する上で制約がある。矢印函数ではthisキーワードが有効でないので要注意。

矢印函数を使わずに匿名函数を使った場合には次のようになる。

function 函数名(仮引数){
   // プライベート
   let 変数名1 = 値;
   let 変数名2 = 値;
   let 変数名3 = 値;
   return {
      // パブリック
      ゲッター名1 : function(){return 変数名1},
      ゲッター名2 : function(){return 変数名2},
      ゲッター名3 : function(){return 変数名3},
      セッター名1 : function(仮引数1){変数名1 = 仮引数1},
      セッター名2 : function(仮引数2){変数名2 = 仮引数2},
      セッター名3 : function(仮引数3){変数名3 = 仮引数3},
      メソッド名 : function(仮引数){}
   };
}

ここで用語について少し注釈。JavaScriptではゲッターとセッターというメソッドが共にアクセサー・プロパティと呼ばれている。通常のプロパティはデータ・プロパティとも呼ばれており、メソッドはコード・プロパティと呼ばれることがある。いずれも広義のオブジェクト・プロパティ。

ファクトリ函数を呼び出してオブジェクトを作成する際にはnewキーワードを用いない。ファクトリ函数を呼び出してその返り値を変数に代入するだけで複数のオブジェクトを作り出すことができる。この変数名がオブジェクト名になる。

キーワード 変数名 = ファクトリ関数名(引数1,引数2);

次のコードではCircleと名付けたファクトリ函数を用いて円を描くためのオブジェクトを定義している。円を描く線の色と円を塗りつぶす色を引数にしてこのファクトリ函数を呼び出すと、円を描くためのプロパティとメソッドを持ったオブジェクトが出力される仕組み。

<canvas id="ff_circle" width="300" height="200"></canvas>
<script>
// Circleオブジェクトを定義するファクトリ函数
function Circle(strokeColor,fillColor){
   // プライベートなプロパティ（ローカル変数）
   let radius = 30; // 円の半径
   let line_width = 5; // 線の太さ
   let stroke_color = strokeColor || 'blue'; // 線の色
   let fill_color = fillColor || 'skyblue'; // 塗りつぶす色
   
   // オブジェクト・リテラルを返す
   return {
      // パブリックなゲッター
      getRadius : () => radius,
      getLineWidth : () => line_width,
      getStrokeColor : () => stroke_color,
      getFillColor : () => return fill_color,
      
      // パブリックなセッター
      setRadius : arg => radius = arg,
      setLineWidth : arg => line_width = arg,
      setStrokeColor : arg => stroke_color = arg,
      setFillColor : arg => fill_color = arg,
         
      // 円を描くパブリックなメソッド
      //（canvas要素ID、水平座標、垂直座標）
      draw : function(canvas_id,x,y){
         // HTML5 Canvasの2DコンテキストのAPIを利用
         const canvas = document.getElementById(canvas_id);
         const ctx = canvas.getContext('2d');
         ctx.beginPath(); // パスの初期化
         // 円のパス(水平座標、垂直座標、半径、始点、終点)
         ctx.arc(x,y,radius,0,Math.PI*2);
         ctx.closePath(); // パスを閉じる
         ctx.lineWidth = line_width; // 線の太さ
         ctx.strokeStyle = stroke_color; // 線の色
         ctx.stroke(); // 線を描く
         ctx.fillStyle = fill_color; // 塗りつぶす色
         ctx.fill(); // 塗りつぶす
      }
   };
}

// ファクトリ函数を呼び出してオブジェクトを作成
const circle1 = Circle(); // 引数なし
const circle2 = Circle('orange','yellow');
const circle3 = Circle('red','pink');

// drawメソッドを呼び出して円を描く
circle1.draw('ff_circle',60,60);
circle2.draw('ff_circle',130,60);
circle3.draw('ff_circle',200,60);

// 線の色と塗りつぶす色をセッターで再設定
circle1.setStrokeColor('black');
circle2.setStrokeColor('green');
circle3.setStrokeColor('saddlebrown');
circle1.setFillColor('grey');
circle2.setFillColor('lightgreen');
circle3.setFillColor('peru');

// 下隣の座標に円を描画
circle1.draw('ff_circle',60,130);
circle2.draw('ff_circle',130,130);
circle3.draw('ff_circle',200,130);
</script>

ファクトリ函数はそれを呼び出すごとにいくつでもオブジェクトを生成できるので、このコードでは3つのオブジェクトを生み出し、その上で円を塗りつぶす色のプロパティの値をアクセサーを用いて変えることにより色違いの計6つの円を描くようにコーディングした。

プロパティは外部から直接アクセスできないようにletキーワードを用いてオブジェクト・リテラルの外側で定義することによってプライベートにした。そしてgetとsetという接頭辞を付けた名前のアクセサーを各々のデータ・プロパティのために用意し、それらアクセサーを介してのみ各々のデータ・プロパティに外部からアクセスできるようにした。

このコードをHTMLのbody要素の間に埋め込んでウェブ・ブラウザで読み込むと次のように色違いの6つの円が描かれるはず。

Object()コンストラクター

newキーワードと共にObject()を用いるとオブジェクトを作ることができる。Object()の括弧内の引数に何も指定しないかnullやundefinedを指定した場合には空のオブジェクトが生み出される。

キーワード 変数名 = new Object();

キーワードにはletかconstかvarを用いる。

この手続きは他のオブジェクト指向言語では一般にインスタンス化と呼ばれている。例えばJavaでもこの際にnewキーワードを用いる。

コンストラクターとはインスタンス化と共に自動的に実行される特別な函数のこと。JavaScriptではコンストラクターとnewキーワードとは不可分の関係にある。

空のオブジェクトには次のようにしてプロパティとその値とを後から追加することができる。

変数名.プロパティ名 = 値;

プロパティの値に匿名函数や矢印函数の定義を与えるとそれはメソッドになる。

次のコードでは、circleという空のオブジェクトを作成し、その後にcircleオブジェクトのプロパティとメソッドを設定している。メソッドの定義では矢印函数を用いた。

<canvas id="ol_circle" width="300" height="150"></canvas>
<script>
// 空のオブジェクトを生成
const circle = new Object();

// 円の各種プロパティを設定
circle.radius = 30; // 円の半径
circle.line_width = 5; // 線の太さ
circle.stroke_color = 'blue'; // 線の色
circle.fill_color = 'skyblue'; // 塗りつぶす色
//円を描くメソッド（矢印函数）
circle.draw = (canvasId,x,y) => {
   // HTML5 Canvasの2DコンテキストのAPIを利用
   const canvas = document.getElementById(canvasId);
   const ctx = canvas.getContext('2d');
   ctx.beginPath(); // パスの初期化
   // 円のパス（水平座標、垂直座標、半径、始点、終点）
   ctx.arc(x,y,circle.radius,0,Math.PI*2);
   // 線の太さ
   ctx.lineWidth = circle.line_width;
   // 線の色
   ctx.strokeStyle = circle.stroke_color;
   ctx.stroke(); // 線を描く
   // 塗りつぶす色
   ctx.fillStyle = circle.fill_color;
   ctx.fill(); // 塗りつぶす
};

// drawメソッドを呼び出して円を1つ描く
circle.draw('oc_circle',60,60);

// 円の色を再設定
circle.stroke_color = 'orange';
circle.fill_color = 'yellow';

// 右隣に円を1つ描く
circle.draw('oc_circle',130,60);

// 円の色を再々設定
circle.stroke_color = 'red';
circle.fill_color = 'pink';

// その右隣に円を1つ描く
circle.draw('oc_circle',200,60);
</script>

作成したオブジェクトは1つだが、HTML5 Canvasを利用して円を描くdrawメソッドを3回呼び出し、プロパティを設定し直すことで色違いの円を3つ描くようにした。

このコードをHTMLのbody要素の間に埋め込んでウェブ・ブラウザに読み込むと次のように表示されるはず。

コンストラクター函数

コンストラクター函数も量産型のオブジェクトを定義する場合に用いることができる。コンストラクター函数ではパブリックなプロパティとパブリックなメソッドにthis.を付けて定義する必要がある。

function 函数名(仮引数){
   this.プロパティ名1 = 値;
   this.プロパティ名2 = 値;
   this.プロパティ名3 = 値;
   this.メソッド名 = function(仮引数){}
}

プロパティに外から直接アクセスできないようにするには、ファクトリ函数のときと同様にプロパティを通常のローカル変数にするためにその前にletかvarかconstかいずれかのキーワードを付ける必要がある。そしてその代わりにゲッターとセッターというアクセス用のメソッド（アクセサー）を定義し、それらのメソッド（アクセサー）を介してプロパティの参照と設定を行う。

function 函数名(仮引数){
   // プライベート
   let 変数名1 = 値;
   let 変数名2 = 値;
   let 変数名3 = 値;
   
   // パブリック
   this.ゲッター名1 () => 変数名1;
   this.ゲッター名2 () => 変数名2;
   this.ゲッター名3 () => 変数名3;
   this.セッター名1 (仮引数a) => 変数名1 = 仮引数a;
   this.セッター名2 (仮引数b) => 変数名2 = 仮引数b;
   this.セッター名3 (仮引数c) => 変数名3 = 仮引数c;
   this.メソッド名 = function(仮引数){}
}

letというキーワードと共に定義されているローカル変数は外から直接アクセスできないためにプライベートになる。このことはキーワードにvarやconstを用いても同様。

this.によって定義されているプロパティやアクセサーやメソッドは外から直接アクセスできるためにパブリックになる。

コンストラクター函数を定義したら、newキーワードと一緒に呼び出して変数に代入することでオブジェクトを作成できる。いわゆるインスタンス化。コンストラクター函数の定義内で用いられたthisキーワードが指し示すのがこの変数名であり、この変数名がオブジェクト名となる。

キーワード 変数名 = new コンストラクター関数名(引数1,引数2);

アクセサーなどのメソッドを呼び出す方法はこれまでと同様。

オブジェクト名.メソッド名(引数1,引数2);

次のコードではコンストラクター函数によってHTMLドキュメント上に円を描くためのオブジェクトの定義と作成を行っている。

<canvas id="cf_circle" width="300" height="120"></canvas>
<script>
// オブジェクトを定義
function Circle(strokeColor,fillColor){
   // プライベートな変数
   let radius = 30; // 円の半径
   let line_width = 5; // 線の太さ
   let stroke_color = strokeColor || 'blue'; // 線の色
   let fill_color = fillColor || 'skyblue'; // 塗りつぶす色

   // パブリックなゲッター
   this.getRadius = () => radius;
   this.getLineWidth = () => line_width;
   this.getStrokeColor = () => stroke_color;
   this.getFillColor = () => fill_color;

   // パブリックなセッター
   this.setRadius = arg => radius = arg;
   this.setLineWidth = arg => line_width = arg;
   this.setStrokeColor = arg => stroke_color = arg;
   this.setFillColor = arg => fill_color = arg;
      
   // 円を描くパブリックなメソッド
   //（canvas要素のID、水平座標、垂直座標）
   this.draw = function(canvasId,x,y,){
      // HTML5 Canvasの2DコンテキストのAPIを使う
      const canvas = document.getElementById(canvasId);
      const ctx = canvas.getContext('2d');
      ctx.beginPath(); // パスを初期化
      // 円のパス（水平座標、垂直座標、半径、始点、終点）
      ctx.arc(x,y,radius,0,Math.PI*2);
      ctx.lineWidth = line_width; // 線の太さ
      ctx.strokeStyle = stroke_color; // 線の色
      ctx.stroke(); // 線を描く
      ctx.fillStyle = fill_color; // 塗りつぶす色
      ctx.fill(); // 塗りつぶす
   }
}

// 個々のオブジェクトを作成（インスタンス化）
const circle1 = new Circle()
const circle2 = new Circle('orange','yellow');
const circle3 = new Circle('red','pink');

// 円を描くメソッドを使う
circle1.draw('cf_circle',60,60);
circle2.draw('cf_circle',130,60);
circle3.draw('cf_circle',200,60);

// 円の半径を再設定
circle1.setRadius(20);
circle2.setRadius(20);
circle3.setRadius(20);

// 少し下の座標に円を描画
circle1.draw('cf_circle',60,130);
circle2.draw('cf_circle',130,130);
circle3.draw('cf_circle',200,130);
</script>

コンストラクター函数の名前（函数の識別子）は通常の函数と見分けるために先頭を大文字にする慣例がある。したがってCircleとした。

コンストラクター関数の冒頭でletキーワードと共に宣言してあるローカル変数はプライベート。それらは外部からアクセスできない。そのことはvarやconstをキーワードに選んでも同じ。

this.が付けられているメソッドはパブリック。それらには外部からアクセスすることができる。

上記のコードでは円の半径を再設定するためにそのプロパティに直接アクセスするのではなくセッターというメソッドを利用している。

このコードをHTMLドキュメントのbody要素間に埋め込んでウェブ・ブラウザで読み込むと次のように色や大きさの異なる円が6つ描かれるはず。

クラス構文

クラス構文の実体はコンストラクター函数であるが、クラス・ベースのオブジェクト指向言語に慣れ親しんでいる人たち向けに採用された構文。

クラス構文は次のような書式に従う。

class クラス名{
   constructor(仮引数){
      this.プロパティ名 = 値;
      this.プロパティ名 = 値;
   }
   this.メソッド名 = function(仮引数){}
}

クラス構文でカプセル化を実装するには、すなわちデータ・プロパティへの直接のアクセスを禁じるには、次のようにデータ・プロパティ名に接頭辞として#（ハッシュ）を付けるハッシュ名を利用できる。

class クラス名{
   #プロパティ名1;
   #プロパティ名2;

   constructor(仮引数){
      this.#プロパティ名1 = 値;
      this.#プロパティ名2 = 値;
   }

   ゲッター名1(){return this.#プロパティ名1;}
   ゲッター名2(){return this.#プロパティ名2;}

   セッター名1(仮引数1){this.#プロパティ名1 = 仮引数1;}
   セッター名2(仮引数2){this.#プロパティ名2 = 仮引数2;}

   メソッド名(仮引数){}
}

クラス構文は内部的にはコンストラクター函数であるのでnewキーワードと共に呼び出してオブジェクトを作る。

キーワード 変数名 = new クラス名(引数);

クラス構文を用いてCircleオブジェクトを定義してインスタンス化した1例が次のコード。

<canvas id="cd_circle" width="300" height="120"></canvas>
<script>
// クラスを定義
class Circle{
   // 各種プロパティを宣言
   #radius; // 円の半径
   #line_width; // 線の太さ
   #stroke_color; // 線の色
   #fill_color; // 塗りつぶす色
      
   // コンストラクター（初期値を代入する函数）
   constructor(strokeColor,fillColor){
      this.#radius = 30;
      this.#line_width = 5;
      this.#stroke_color = strokeColor || 'blue';
      this.#fill_color = fillColor || 'skyblue';
   }

   // 各プロパティの値を取得するメソッド
   getRadius(){return this.#radius;}
   getLineWidth(){return this.#line_width;}
   getStrokeColor(){return this.#stroke_color;}
   getFillColor(){return this.#fill_color;}

   // 各プロパティの値を設定するメソッド
   setRadius(arg){this.#radius = arg;}
   setLineWidth(arg){this.#line_width = arg;}
   setStrokeColor(arg){this.#stroke_color = arg;}
   setFillColor(arg){this.#fill_color = arg;}

   // 円を描くメソッド（canvas要素のID、水平座標、垂直座標）
   draw(canvasId,x,y){
      // HTML5 Canvasの2DコンテキストのAPIを使う
      const canvas = document.getElementById(canvasId);
      const ctx = canvas.getContext('2d');
      ctx.beginPath(); // パスの初期化
      // 円のパス（水平座標、垂直座標、半径、始点、終点）
      ctx.arc(x,y,this.#radius,0,Math.PI*2);
      ctx.lineWidth = this.#line_width; // 線の太さ
      ctx.strokeStyle = this.#stroke_color; // 線の色
      ctx.stroke(); // 円を描く
      ctx.fillStyle = this.#fill_color; // 塗りつぶす色
      ctx.fill(); // 塗りつぶす
   }
}

// Circleクラスから個々の円オブジェクトを作成
const circle1 = new Circle();
const circle2 = new Circle('orange','yellow');
const circle3 = new Circle('red','pink');

// 円を描くメソッドを呼び出す
circle1.draw('cd_circle',60,60);
circle2.draw('cd_circle',130,60);
circle3.draw('cd_circle',200,60);

// 円の線の太さを再設定
circle1.setLineWidth(8);
circle2.setLineWidth(8);
circle3.setLineWidth(8);

// 少し下の座標に円を描く
circle1.draw('cd_circle',60,130);
circle2.draw('cd_circle',130,130);
circle3.draw('cd_circle',200,130);
</script>

クラス構文はC++やJavaのクラス宣言に近い。コンストラクターと呼ばれるメンバ函数はC++やJavaではクラス名と同じ名前を使う決まりがあるが、JavaScriptのクラス構文ではconstructorキーワードを用いる。

このコードをHTMLドキュメントのbody要素の間に埋め込んでウェブ・ブラウザで読み込むと色や線の太さが異なる6つの円が次のように描かれるはず。

getキーワードとsetキーワード

ECMAScript 2015（ES6）からgetとsetというキーワードを用いてゲッターとセッターを記述できるようになっている。例えば次のような書式によって。

get ゲッター名(){
   return this.#プロパティ名;
}

set セッター名(仮引数){
   this.#プロパティ名 = 仮引数;
}

getとsetを用いた際に気をつけるべき点としてこの構文がメソッドの定義ではないということ。したがってgetやsetを使って定義されたゲッターとセッターをメソッドのように呼び出すとエラーが生じてしまう。

getとsetを用いて定義されたゲッターとセッターは通常のデータ・プロパティのようにアクセスする必要がある。

const 変数名 = オブジェクト名.ゲッター名; // 取得する
オブジェクト名.セッター名 = 値; // 設定する

HTML5 Canvasで写像ダイアグラム（写像図）を描く

2022-02-02T19:06:00.013+09:00

HTML5 CanvasとJavaScriptを用いてHTMLドキュメントに数学の写像ダイアグラム（写像図）を描いてみた。この投稿はその備忘録。

写像ダイアグラムを描きたいHTMLドキュメント内の場所にcanvas要素を埋め込む必要がある。そのcanvas要素は例えば次のように記す。その際にid属性を指定することを忘れずに。HTML5 Canvasはこのidを受け取る。

<canvas id="mapping" width="200" height="200">
HTML5 CanvasかJavaScriptに未対応か無効になっています。
</canvas>

canvas要素のwidthとheightという属性はキャンバスの幅と高さを指定するもの。このサイズを適切に指定しないと描かれたオブジェクトがはみ出して見えなくなってしまうことがある。

楕円オブジェクト

HTML5 Canvasを使って楕円を描くためにはellipse()というメソッドを用いることができる。このメソッドの引数は次の順番に指定する。オプションは省略することができる。

ellipse(1,2,3,4,5,6,7,8);

楕円の中心の水平座標を指定。
楕円の中心の垂直座標を指定。
楕円の水平軸半径を非負の値で指定。
楕円の垂直軸半径を非負の値で指定。
楕円の水平軸の傾きを弧度法で指定。
パスの始点を弧度法で指定。
パスの終点を弧度法で指定。
【オプション】楕円を描くパスの方向を反時計回りにしたい場合にtrueと指定。

ただしellipse()メソッドは古いウェブブラウザでは対応していない場合があるので要注意。

次のJavaScriptのコードではコンストラクタ函数によって楕円クラスのようなものを定義している。そしてそれをインスタンス化して各々の楕円オブジェクトを作成し、コンストラクタ函数の中で定義した描画メソッドを呼び出すことで楕円を描くようにしている。

<script>
// 楕円のコンストラクタ函数を定義
function ellipse(radiusX,radiusY,rotation,
   lineWidth,stColor,flColor){

    // プロパティを定義
   this.radiusX = radiusX; // 楕円の水平軸半径
   this.radiusY = radiusY; // 楕円の垂直軸半径
   this.rotation = rotation; // 楕円の水平軸の傾き
   this.startAngle = 0; // 線の始点
   this.endAngle = Math.PI / 180 * 360; // 線の終点
   this.lineWidth = lineWidth; // 線の太さ
   this.stColor = stColor; // 線の色
   this.flColor = flColor; // 塗りつぶす色

    // 楕円を描くメソッドを定義
   this.draw = function(canvasId,x,y){
      // HTML5 Canvasを利用する
      const Canvas = document.getElementById(canvasId)
      const Ctx = Canvas.getContext("2d");

      Ctx.beginPath(); // パスの初期化
      // ellipse()メソッドを利用
      Ctx.ellipse(x,y,this.radiusX,this.radiusY,
         this.rotation,this.startAngle,this.endAngle);
      Ctx.lineWidth = this.lineWidth; // 線の太さ
      Ctx.strokeStyle = this.stColor; // 線の色
      Ctx.stroke(); // 線を描く
      Ctx.fillStyle = this.flColor; // 塗りつぶす色
      Ctx.fill(); // 塗りつぶす
   }
}

// 各々のオブジェクトを作成（インスタンス化）
const Ellipse1 = new ellipse(50,80,0,2,'blue','skyblue');
const Ellipse2 = new ellipse(50,80,0,2,'red','pink');

// 定義したメソッドを呼び出して楕円を描画
Ellipse1.draw(mapping,60,110);
Ellipse2.draw(mapping,190,110);
</script>

コンストラクタ函数を利用してクラスのようなものを定義することができる。コンストラクタ函数が普通の函数と違うところは「this.変数名」によって変数を宣言しているところ。これによって「コンストラクタ函数名.変数名」という書式でコンストラクタ函数の外からアクセスできるようになる。これはすなわちオブジェクト指向言語のプロパティ（メンバ変数）のように機能する。プロパティに値を代入するには「コンストラクタ函数名.変数名 = リテラル;」という書式を使う。

コンストラクタ函数は擬似的なクラスとして働くので、インスタンス化によって複数のオブジェクトをこれに基づいて作成することができる。そのためにはnewというキーワードを使って変数に代入する。

コンストラクタ函数内では「this.メソッド名 = function(引数){...}」という書式を用いてメソッド（メンバ函数）のようなものを定義することができる。これも「コンストラクタ函数名.メソッド名();」という書式を用いてコンストラクタ函数の外から呼び出すことができる。

楕円を定義したコンストラクタ函数では、それがインスタンス化されて各々のオブジェクトが作られるときに、楕円の中心点の水平座標と垂直座標、楕円の水平軸の傾き（ラジアン）、線の太さ、線の色、そして塗りつぶす色を引数として受け取るように定義した。

楕円を定義したコンストラクタ函数の中で定義したdrawメソッドは、HTML5 Canvasによって楕円を描画するためのもの。このメソッドではそれが呼び出される際にcanvas要素のIDと楕円の中心点の座標を受け取るようにした。

楕円を定義したコンストラクタ函数の中で「線の終点」を示すプロパティに代入されている「Math.PI / 180 * 360」という計算は、度数法の値360を弧度法の値に変換するためのもの。HTML5 Canvasのほうのellipse()メソッドは角度をラジアンで受け取るため。

ラベル・オブジェクト

ラベルのオブジェクトを定義するコンストラクタ函数が次のコード。

<script>
// 楕円のコンストラクタ函数を省略

// ラベルのコンストラクタ函数を定義
function lavel(text,color){

   // プロパティを定義
   this.text = text; // 文字列
   this.color = color; // 文字列の色

   // ラベルを描くメソッドを定義
   this.draw = function(canvasId,x,y){
      // HTML5 Canvasを利用する
      const Canvas = document.getElementById(canvasId);
      const Ctx = Canvas.getContext("2d");

     // フォントを設定
     Ctx.font = '15px sans-serif';
     // 文字の水平位置を設定
     Ctx.textAlign = "start";
     // 文字の垂直位置を設定
     Ctx.textBaseline = "middle";
     // 塗りつぶしの色を設定
     Ctx.fillStyle = this.color;
     // 塗りつぶしの文字を描画、(文字列, x軸, y軸, 最大幅)
     Ctx.fillText(this.text,x,y,500);
   }
}

// 楕円をインスタンス化
const Ellipse1 = new ellipse(50,80,0,2,'blue','skyblue');
const Ellipse2 = new ellipse(50,80,0,2,'red','pink');

// ラベルをインスタンス化
const Lavel1 = new lavel('定義域','black');
const Lavel2 = new lavel('終域','black');

// 楕円を描くメソッドを使う
Ellipse1.draw(mapping,60,100);
Ellipse2.draw(mapping,190,100);

// ラベルを描くメソッドを使う
Lavel1.draw(mapping,35,10);
Lavel2.draw(mapping,175,10);
</script>

ラベルを定義したコンストラクタ函数では、それがインスタンス化されるときにラベルの文字列とその文字の色を引数として受け取るようにした。

ラベルを定義したコンストラクタ函数の中で定義したdrawメソッドでは、それが呼び出される際にcanvas要素のIDとラベルが描かれる場所を示す座標を受け取るようにした。

要素オブジェクト

要素のオブジェクトを定義するコンストラクタ函数が次のコード。

<script>
// 楕円のコンストラクタ函数を省略

// ラベルのコンストラクタ函数を省略

// 要素のコンストラクタ函数を定義
function element(text,color){

   // プロパティを定義
   this.text = text; // 文字列
   this.color = color; // 文字列の色

   // 要素を描くメソッドを定義
   this.draw = function(canvasId,x,y){

      // 座標プロパティ
      this.x = x; // 水平座標
      this.y = y; // 垂直座標

      // HTML5 Canvasを利用する
      const Canvas = document.getElementById(canvasId);
      const Ctx = Canvas.getContext("2d");        

      // フォントを設定
      Ctx.font = 'bold 15px sans-serif';
      // 文字の水平位置を設定
      Ctx.textAlign = "start";
      // 文字の垂直位置を設定
      Ctx.textBaseline = "middle";
      // 塗りつぶしの色を設定
      Ctx.fillStyle = this.color;
      // 塗りつぶしの文字を描画、(文字列,x軸,y軸,最大幅)
      Ctx.fillText(this.text,x,y,500);
   }
}

// 楕円をインスタンス化
const Ellipse1 = new ellipse(50,80,0,2,'blue','skyblue');
const Ellipse2 = new ellipse(50,80,0,2,'red','pink');

// ラベルをインスタンス化
const Lavel1 = new lavel('定義域','black');
const Lavel2 = new lavel('終域','black');

// 要素をインスタンス化
const Element1 = new element('a','black');
const Element2 = new element('b','black');
const Element3 = new element('d','black');
const Element4 = new element('e','black');
const Element5 = new element('f','black');
const Element6 = new eElement('α','black');
const Element7 = new element('β','black');
const Element8 = new element('γ','black');
const Element9 = new element('δ','black');
const Element10 = new element('ε','black');

// 楕円を描くメソッドを使う
Ellipse1.draw(mapping,60,100);
Ellipse2.draw(mapping,190,100);

// ラベルを描くメソッドを使う
Lavel1.draw(mapping,35,10);
Lavel2.draw(mapping,175,10);

// 要素を描くメソッドを使う
Element1.draw(mapping,55,40);
Element2.draw(mapping,55,70);
Element3.draw(mapping,55,100);
Element4.draw(mapping,55,130);
Element5.draw(mapping,55,160);
Element6.draw(mapping,185,40);
Element7.draw(mapping,185,70);
Element8.draw(mapping,185,100);
Element9.draw(mapping,185,130);
Element10.draw(mapping,185,160);
</script>

要素を定義したコンストラクタ函数では、それがインスタンス化されるときに文字列と文字列の色をその引数として受け取るようにした。

要素を定義したコンストラクタ函数の中で定義したdrawメソッドでは、それが呼び出される際にcanvas要素のIDと要素が描かれる場所を示す座標を受け取るようにした。

射オブジェクト

射のオブジェクトを定義するコンストラクタ函数が次のコード。

<script>
// 楕円のコンストラクタ函数を省略

// ラベルのコンストラクタ函数を省略

// 要素のコンストラクタ函数を省略

// 射のコンストラクタ函数を定義
function arrow(alength,width,color){

   // プロパティを定義
  this.length = alength; // 長さ
  this.width = width; // 太さ
  this.color = color; // 色

   // 射を描くメソッドを定義
   this.draw = function(canvasId,tailX,tailY,headX,headY){
      // HTML5 Canvasを利用する
      const Canvas = document.getElementById(canvasId);
      const Ctx = Canvas.getContext("2d");

      Ctx.beginPath(); // パスを初期化
      Ctx.lineWidth =  this.width; // 線の幅
      Ctx.moveTo(tailX + 15, tailY); // 線の始点
      Ctx.lineTo(headX + -5, headY); // 線の終点
      Ctx.strokeStyle = this.color; // 線の色
      Ctx.stroke(); // 線を描く
   }
}

// 楕円をインスタンス化
const Ellipse1 = new ellipse(50,80,0,2,'blue','skyblue');
const Ellipse2 = new ellipse(50,80,0,2,'red','pink');

// ラベルをインスタンス化
const Lavel1 = new lavel('定義域','black');
const Lavel2 = new lavel('終域','black');

// 要素をインスタンス化
const Element1 = new element('a','black');
const Element2 = new element('b','black');
const Element3 = new element('d','black');
const Element4 = new element('e','black');
const Element5 = new element('f','black');
const Element6 = new element('α','black');
const Element7 = new element('β','black');
const Element8 = new element('γ','black');
const Element9 = new element('δ','black');
const Element10 = new element('ε','black');

// 射クラスのインスタンス化
const Arrow1 = new arrow(10,1,'black');

// 楕円を描くメソッドを使う
Ellipse1.draw(mapping,60,100);
Ellipse2.draw(mapping,190,100);

// ラベルを描くメソッドを使う
Lavel1.draw(mapping,35,10);
Lavel2.draw(mapping,175,10);

// 要素を描くメソッドを使う
Element1.draw(mapping,55,40);
Element2.draw(mapping,55,70);
Element3.draw(mapping,55,100);
Element4.draw(mapping,55,130);
Element5.draw(mapping,55,160);
Element6.draw(mapping,185,40);
Element7.draw(mapping,185,70);
Element8.draw(mapping,185,100);
Element9.draw(mapping,185,130);
Element10.draw(mapping,185,160);

// 射を描くメソッドを使う
Arrow1.draw(mapping,Element1.x,Element1.y,
   Element6.x,Element6.y);
Arrow1.draw(mapping,Element2.x,Element2.y,
   Element6.x,Element6.y);
Arrow1.draw(mapping,Element3.x,Element3.y,
   Element7.x,Element7.y);
Arrow1.draw(mapping,Element4.x,Element4.y,
   Element9.x,Element9.y);
Arrow1.draw(mapping,Element5.x,Element5.y,
   Element10.x,Element10.y);
</script>

射を定義したコンストラクタ函数では、それがインスタンス化されるときに射の線の長さと太さと色を引数として受け取るようにした。

射を定義したコンストラクタ函数の中で定義したdrawメソッドでは、それが呼び出される際にcanvas要素のID、そして始点となる部分の水平座標と垂直座標、さらに終点となる部分の水平座標と垂直座標を受け取るようにした。

射の始点と終点の座標を指定するdrawメソッドの引数では要素オブジェクトのプロパティを利用している。

名前空間

最後に、変数名や函数名などが他のJavaSprictのコードと衝突しないように名前空間を作成した。JavaScriptでは正式に名前空間をサポートしていないけれども、函数や匿名函数やオブジェクト・リテラルを用いることでスコープを閉じることができるようなので、ここではそのために匿名函数を利用した。つまり、匿名函数でこれまで作成したコードをまるごと袋とじにした。

(function(){ // 匿名函数を使う
// ここにこれまで作成した一連のコードを置く。
})();

これは特に即時実行函数式とか即時呼び出し函数式と呼ばれることがある。

HTML5 Canvasで楕円を描く

2022-02-02T19:04:00.004+09:00

この投稿ではHTML5 CanvasとJavaScriptを用いてHTMLドキュメントに楕円を描くスクリプティング方法について記す。

楕円形を描く

HTML5 Canvasの2Dを使って楕円を描くにはellipse()というメソッドを用いることができる。このメソッドの引数は次の順番に指定する。最後のオプションは反時計回りに描きたい場合にだけ指定するもの。

ellipse(1,2,3,4,5,6,7,8);

楕円の中心の水平座標を指定。
楕円の中心の垂直座標を指定。
楕円の長軸半径を非負の値で指定。
楕円の短軸半径を非負の値で指定。
楕円の長軸の傾きを弧度法で指定。
パスの始点を弧度法で指定。
パスの終点を弧度法で指定。
【オプション】楕円を描くパスの方向を反時計回りにしたい場合にtrueと指定。

ただしHTML5 Canvasの2Dのellipse()メソッドは古いウェブブラウザでは対応していない場合があるので要注意。

楕円を描くためのHTMLとJavaScriptのソースコードは次のとおり。

<!DOCTYPE html>
<html lang="ja">
<head>
<meta charset="UTF-8">
<title>楕円を描く</title>
</head>
<Canvas id="myEllipse" width="200" height="200">
HTML5 CanvasかJavaScriptに未対応か無効になっています。
</Canvas>
<script>
// 角度をラジアンに変換する函数
function toRadian(degrees){
   return Math.PI / 180 * degrees;
}

// HTML5 Canvasを利用する手続き
const Canvas = document.getElementById("myEllipse")
const Ctx = Canvas.getContext("2d");

// 楕円を描く
Ctx.beginPath(); // パスの初期化
// 楕円メソッド(中心x,中心y,長軸半径,短軸半径,傾き,始点,終点)
Ctx.ellipse(100,60,80,50,toRadian(15),0,toRadian(360));
Ctx.lineWidth = 2; // 線の太さ
Ctx.strokeStyle = 'blue'; // 枠の色
Ctx.stroke(); // 線を描く
Ctx.fillStyle = 'skyblue'; // 塗りつぶす色
Ctx.fill(); // 塗りつぶす
</script>
</body>
</html>

上の楕円は楕円の長軸を右下に15度傾けたのでellipse()の第5引数に15と指定した。ただしellipse()の引数には角度を弧度法による単位ラジアンで指定する必要があるため、この15度を弧度法での値に直す必要があった。

toRadian()という函数は度数法の値を弧度法の値に変換するためのもの。度数法から弧度法への変換公式は次のとおり。

\[ ラジアン = \dfrac{\pi}{180} \times 角度 \]

線の色はstrokeStyleというプロパティに=演算子を用いてカラーコードを代入することで指定することができる。塗りつぶす色はfillStyleというプロパティに代入して指定することができる。

次の楕円は傾きを0度にしたもの。枠の色は赤、塗りつぶす色は桃色にしてみた。

// 楕円を描く
Ctx.beginPath(); // パスの初期化
// 楕円メソッド(中心x,中心y,長軸半径,短軸半径,傾き,始点,終点)
Ctx.ellipse(100,100,80,50,toRadian(0),0,toRadian(360));
Ctx.lineWidth = 2; // 線の太さ
Ctx.strokeStyle = 'red'; // 枠の色
Ctx.stroke(); // 線を描く
Ctx.fillStyle = 'pink'; // 塗りつぶす色
Ctx.fill(); // 塗りつぶす

ellipse()の引数の値をいろいろ変えてみて楕円の描画がどのように変化するか試してみると引数がどのように機能するかを掴むことができる。

次の楕円は長軸の半径をもう少し長くしてみた。傾きには負の値-15度を指定してみた。枠の色は緑、塗りつぶす色は黄色とした。

// 楕円を描く
Ctx.beginPath(); // パスの初期化
// 楕円メソッド(中心x,中心y,長軸半径,短軸半径,傾き,始点,終点)
Ctx.ellipse(100,60,100,50,toRadian(-15),0,toRadian(360));
Ctx.lineWidth = 2; // 線の太さ
Ctx.strokeStyle = 'green'; // 線の色
Ctx.stroke(); // 線を描く
Ctx.fillStyle = 'yellow'; // 塗りつぶす色
Ctx.fill(); // 塗りつぶす

ガウスの消去法（掃き出し法）行基本変形行簡約階段形

2021-12-11T13:21:00.018+09:00

この投稿は連立n元一次方程式を解くためのアルゴリズムの1つであるガウスの消去法（通称：掃き出し法）について簡単にまとめたもの。逆行列を用いた解法にも若干触れた。また、R言語、GNU Octave、Maxima、Python 3、Juliaを用いた連立一次方程式の解き方についても記した。

ガウスの消去法をプログラミング言語でコーディングすることについてはこの投稿では扱わなかった。それについてはまた別の機会に。

連立n元一次方程式とは

連立一次方程式は英語ではa system of linear equationsと呼ばれている。日本語に直訳すると線形方程式系。

n元とは変数（未知数）がn個あること。一次とは代数式の次数が1つのこと。つまり方程式を構成する代数式の各項が最大で1つの変数しか持っていないこと。代数式とは数学のお馴染みの文字式のこと。代数式には単項式と二項式と多項式がある。

\[ 2x + 3y \quad 1次式 \] \[ 2x + y^2 \quad 2次式 \] \[ 2x^2y + 5y \quad 3次式 \]

方程式とは2つの代数式の等しい関係を等号で表したもの。

一次方程式を直交座標系に描くと直線になる。したがって線形方程式とも呼ばれている。

連立一次方程式は一次方程式の集合なので、同じ直交座標系に直線に複数描かれ、それらの直線同士が交わるところがあればそこが連立一次方程式の解になる。

例えばGeoGebraというアプリケーション・ソフトウェアを使うと、これを視覚化してくれる。GeoGebraの入力欄に連立一次方程式を構成している各々の一次方程式を入力すると直交座標系に直線を描いてくれる。

描かれた直線同士が互いに交わった点の座標がその連立一次方程式の解。

直線同士が完全に平行になって交わるところがなければその連立一次方程式は解を持たない。

直線同士が完全に重なっている場合はその連立一次方程式は無数の解を持つ。

ちなみにGeoGebraはJava言語の仮想マシンがインストールされた複数のプラットフォームで動作し、オープンソースでかつ多言語対応。

連立n元一次方程式を行列で表す

例えば次のような連立3元一次方程式があったとする。$ a_1, a_2, \cdots, a_8 $は係数、$ x_1, x_2, x_3 $は変数、$ b_1, b_2, b_3 $は定数。

\[ \begin{cases} a_1x_1 &+& a_2x_2 &+& a_3x_3 &=& b_1 \\ a_4x_1 &+& a_5x_2 &+& a_6x_3 &=& b_2 \\ && a_7x_2 &+& a_8x_3 &=& b_3 \end{cases} \tag{1} \]

この連立一次方程式(1)の係数だけを取り出し、それを行列にして表現してみる。各変数に掛けられてある各係数を連立一次方程式の並び順とまったく同じ順番に並べればよい。そうすると次のような行列ができあがる。

\[ \begin{cases} a_1x_1 &+& a_2x_2 &+& a_3x_3 &=& b_1 \\ a_4x_1 &+& a_5x_2 &+& a_6x_3 &=& b_2 \\ && a_7x_2 &+& a_8x_3 &=& b_3 \end{cases} \] \[ \updownarrow \] \[ A = \begin{pmatrix} a_1 & a_2 & a_3 \\ a_4 & a_5 & a_6 \\ 0 & a_7 & a_8 \end{pmatrix} \]

この$ A $という行列は係数行列と呼ばれているもの。その第1列が変数$ x $の係数、第2列が変数$ y $の係数、第3列が変数$ z $の係数。また、係数と変数（未知数）共に欠けている項が0になることに要注意。

この係数行列$ A $に連立一次方程式の右辺にある定数を更に含めると次のような行列ができあがる。

\[ \begin{cases} a_1x_1 &+& a_2x_2 &+& a_3x_3 &=& b_1 \\ a_4x_1 &+& a_5x_2 &+& a_6x_3 &=& b_2 \\ && a_7x_2 &+& a_8x_3 &=& b_3 \end{cases} \] \[ \updownarrow \] \[ \tilde{A} = \left(\begin{array}{ccc|c} a_1 & a_2 & a_3 & b_1 \\ a_4 & a_5 & a_6 & b_2 \\ 0 & a_7 & a_8 & b_3 \end{array}\right) \]

この$ \tilde{A} $という行列は拡大係数行列または拡大行列と呼ばれているもの。|（パイプ）の右側にある列ベクトル$ (b_1\ b_2\ b_3) $は連立一次方程式の右辺ベクトルまたは定数項べクトルと呼ばれることがある。

上記の連立一次方程式(1)を係数行列と列ベクトルを用いて行列方程式$ A\vec{x} = \vec{b} $として表すと、次のようになる。

\[ \begin{cases} a_1x_1 &+& a_2x_2 &+& a_3x_3 &=& b_1 \\ a_4x_1 &+& a_5x_2 &+& a_6x_3 &=& b_2 \\ && a_7x_2 &+& a_8x_3 &=& b_3 \end{cases} \] \[ \updownarrow \] \[ \begin{pmatrix} a_1 & a_2 & a_3 \\ a_4 & a_5 & a_6 \\ 0 & a_7 & a_8 \end{pmatrix} \begin{pmatrix} x_1 \\ x_2 \\ x_3 \end{pmatrix} = \begin{pmatrix} b_1 \\ b_2 \\ b_3 \end{pmatrix} \]

同様にしてベクトル方程式として表すと次のようになる。

\[ \begin{cases} a_1x_1 &+& a_2x_2 &+& a_3x_3 &=& b_1 \\ a_4x_1 &+& a_5x_2 &+& a_6x_3 &=& b_2 \\ && a_7x_2 &+& a_8x_3 &=& b_3 \end{cases} \] \[ \updownarrow \] \[ x_1 \begin{pmatrix} a_1 \\ a_4 \\ 0 \end{pmatrix} + x_2 \begin{pmatrix} a_2 \\ a_5 \\ a_7 \end{pmatrix} + x_3 \begin{pmatrix} a_3 \\ a_6 \\ a_8 \end{pmatrix} = \begin{pmatrix} b_1 \\ b_2 \\ b_3 \end{pmatrix} \]

ちなみに、各変数項に定数を乗算してそれらを加算した式は線形結合と呼ばれている。またの名を一次結合。

\[ \sum_{i=1}^n a_ix_i = a_1x_1 + a_2x_2 + a_3x_3 + \cdots + a_nx_n \]

では以上の操作の具体例を挙げてみる。例えば次のような連立一次方程式があったとする。xとyがその値を知りたい変数、つまり未知数。

\[ \begin{cases} 2x - y = 5 \\ x - y = 3 \end{cases} \tag{2} \]

数学の表記上の理由で言うまでもなく次の2つの連立一次方程式が等しいことは自明。

\[ \begin{cases} 2x - y = 5 \\ x - y = 3 \end{cases} \leftrightarrow \begin{cases} 2x + (-1y) = 5 \\ 1x + (-1y) = 3 \end{cases} \]

連立一次方程式(2)の係数行列Aと拡大係数行列$ \tilde{A} $はそれぞれ次のように表すことができる。

\[ A = \begin{pmatrix} 2 & -1 \\ 1 & -1 \end{pmatrix} \] \[ \tilde{A} = \left(\begin{array}{cc|c} 2 & -1 & 5 \\ 1 & -1 & 3 \end{array}\right) \]

係数行列と列ベクトルを用いて行列方程式$ A\vec{x} = \vec{b} $として表すと次のようになる。

\[ \begin{pmatrix} 2 & -1 \\ 1 & -1 \end{pmatrix} \begin{pmatrix} x \\ y \end{pmatrix} = \begin{pmatrix} 5 \\ 3 \end{pmatrix} \]

次のように線形結合のベクトル方程式としても表現できる。

\[ x \begin{pmatrix} 2 \\ 1 \end{pmatrix} + y \begin{pmatrix} -1 \\ -1 \end{pmatrix} = \begin{pmatrix} 5 \\ 3 \end{pmatrix} \]

掃き出し法、ガウスの消去法

連立一次方程式を解くためのアルゴリズムにガウスの消去法と呼ばれているものがある。ガウスの消去法は日本では掃き出し法という通称で呼ばれていることが多い。

連立一次方程式の解を掃き出し法によって求めるには、まず連立一次方程式を拡大係数行列の形に直した後、その拡大係数行列が行簡約階段形と呼ばれる形になるように行基本変形と呼ばれる操作を繰り返す。

行簡約階段形は行既約階段形とも呼ばれている。

拡大係数行列の左辺、つまり係数行列の部分が正方行列であるとき、行簡約階段形は単位行列の形になる。正方行列とは行列の列と行とが同じ数であること。

行簡約階段形や単位行列がどういう行列の形であるかについては後ほど詳しく記す。

行基本変形と呼ばれている操作には次の3種類がある。ただしここでの表記の順番はその手順とは無関係。

ある行を別の行と交換すること、
ある行の全成分に0でない定数を掛けること、
ある行を定数倍した値を別の行に加えること。

次のようなバージョンもある。

ある行を別の行と交換すること、
ある行の全成分を0でない定数で割ること、
ある行を定数倍した値を別の行から引くこと。

掛け算が割り算に、足し算が引き算に置き換わっているが、割り算が分数を掛けることであり引き算が負数を足すことであることを思い起こせば、掛け算と割り算、足し算と引き算とが互換性を持つことを理解できる。

例題1.

次のような連立一次方程式があったとする。

\[ \begin{cases} 2x - y = 5 \\ x - y = 3 \end{cases} \tag{2} \]

この連立一次方程式(2)を掃き出し法によって解くと次のようになる。

連立一次方程式(2)を拡大係数行列として表す。
\[ \begin{cases} 2x - y = 5 \\ x - y = 3 \end{cases} \leftrightarrow \left(\begin{array}{cc|c} 2 & -1 & 5 \\ 1 & -1 & 3 \end{array}\right) \]
拡大係数行列の変数項の部分、つまり係数行列の部分を上記の3種類の行基本変形を用いて次のような形にするにはどうしたらよいかを考える。
\[ \left(\begin{array}{cc|c} 1 & 0 & ? \\ 0 & 1 & ? \end{array}\right) \]
拡大係数行列の左上端の成分（この例題では2）はピボットと呼ばれている。このピボットをとにかく1にすると便利なので、行基本変形1を適用して第1行と第2行を交換してみる。$ R_n $は拡大係数行列の第n行を指している。
\[ R_1 \leftrightarrows R_2 \] \[ \left(\begin{array}{cc|c} 2 & -1 & 5 \\ 1 & -1 & 3 \end{array}\right) \rightarrow \left(\begin{array}{cc|c} 1 & -1 & 3 \\ 2 & -1 & 5 \end{array}\right) \]
ピボットを1にすることができた。
行基本変形3を適用し、第1行を-2倍し、第2行に加算してみる。
\[ \left(\begin{array}{cc|c} 1 & -1 & 3 \\ 2 & -1 & 5 \end{array}\right) \] \[ \downarrow \] \[ -2R_1 + R_2 \rightarrow R_2 \] \[ \left(\begin{array}{cc|c} 1 & -1 & 3 \\ -2 \cdot 1 + 2 & -2 \cdot -1 + (-1) & -2 \cdot 3 + 5 \end{array}\right) \] \[ \downarrow \] \[ \left(\begin{array}{cc|c} 1 & -1 & 3 \\ 0 & 1 & -1 \end{array}\right) \]
第2行第2列の成分もこれで1にすることができた。
行基本変形3を適用し、第2行を1倍し、つまりそのまま第1行に加算してみる。
\[ \left(\begin{array}{cc|c} 1 & -1 & 3 \\ 0 & 1 & -1 \end{array}\right) \] \[ \downarrow \] \[ R_2 + R_1 \rightarrow R_1 \] \[ \left(\begin{array}{cc|c} 0 + 1 & 1 + (-1) & -1 + 3 \\ 0 & 1 & -1 \end{array}\right) \] \[ \downarrow \] \[ \left(\begin{array}{cc|c} 1 & 0 & 2 \\ 0 & 1 & -1 \end{array}\right) \]
拡大係数行列の左辺、つまり係数行列の部分が、対角線上に1が並ぶ単位行列の形になったのでこれで完了。連立一次方程式(2)の解は
\[ \left(\begin{array}{cc|c} 1 & 0 & 2 \\ 0 & 1 & -1 \end{array}\right) \leftrightarrow \begin{cases} x = 2 \\ y = -1 \end{cases} \]
と求まった。

R言語で連立一次方程式を解く

Rで答え合わせをしてみる。Rで連立一次方程式を解くためには、matrix()とc()とで係数行列と定数項の列ベクトルをまず作成する。そしてsolve()に両者を渡せばその連立一次方程式の解が返ってくる。

> A = matrix(c(2,-1,1,-1),nrow=2,ncol=2,byrow=T)
> A
     [,1] [,2]
[1,]    2   -1
[2,]    1   -1
> b = matrix(c(5,3),nrow=2,ncol=1,byrow=T)
> b
     [,1]
[1,]    5
[2,]    3
> solve(A,b)
     [,1]
[1,]    2
[2,]   -1
> q()

2と-1が返ってきた。

rref()を利用することもできる。MATLABの函数を利用するため、pracmaというパッケージが必要。Debian GNU/Linuxではr-cran-pracmaというdebパッケージをインストールする必要があった。

> A = matrix(c(2,-1,5,1,-1,3),nrow=2,ncol=3,byrow=T)
> A
     [,1] [,2] [,3]
[1,]    2   -1    5
[2,]    1   -1    3
> library(pracma)
> rref(A)
     [,1] [,2] [,3]
[1,]    1    0    2
[2,]    0    1   -1
> q()

GNU Octaveで連立一次方程式を解く

GNU Octaveでは係数行列Aと定数項の列ベクトルbを作成してlinsolve()に渡せば連立一次方程式の解が返ってくる。

octave:1> A = [2 -1; 1 -1]
A =

   2  -1
   1  -1

octave:2> b = [5;3]
b =

   5
   3

octave:3> linsolve(A,b)
ans =

   2
  -1

octave:4> quit

やはり同様に2と-1が返ってきた。

MATLAB互換なのでGNU Octaveには標準でrref()がある。拡大係数行列を作ってrref()に渡せば、ガウス＝ジョルダンの消去法によって拡大係数行列からその行簡約階段形を生成してくれる。

>> A = [2 -1 5; 1 -1 3]
A =

   2  -1   5
   1  -1   3

>> rref(A)
ans =

   1   0   2
   0   1  -1

>> quit

第3列、つまり連立一次方程式の定数項によって構成された列ベクトルの部分が2と-1であることが分かる。この方法でも同じ解を得ることができた。

Python3で連立一次方程式を解く

Python 3ではnumpy.linalg.solve()を利用する。そのためにはNumpyをimportする必要がある。Python3で連立一次方程式を解く手順は次のとおり。

>>> import numpy as np
>>> A = np.matrix('2,-1; 1,-1')
>>> print(A)
[[ 2 -1]
 [ 1 -1]]
>>> b = np.matrix('5; 3')
>>> print(b)
[[5]
 [3]]
>>> x = np.linalg.solve(A,b)
>>> print(x)
[[ 2.]
 [-1.]]
>>> quit()

Python 3でも同じく2と-1となった。

Maximaで連立一次方程式を解く

Maximaで連立一次方程式を解くには、各々の変数に連立一次方程式を構成する各々の一次方程式を割り当て、その各々の変数とその連立一次方程式の未知数をsolve()に次のようにして共に渡す。eqn1とeqn2は方程式を割り当てた任意の変数名。乗法の演算子*はMaximaでは入力時に省略できないので忘れずに。

(%i1) eqn1: 2*x - y = 5;
(%o1)                             2 x - y = 5
(%i2) eqn2: x - y = 3;
(%o2)                              x - y = 3
(%i3) solve([eqn1,eqn2],[x,y]);
(%o3)                         [[x = 2, y = - 1]]
(%i4) quit();

Juliaで連立一次方程式を解く

Juliaでは係数行列の逆行列を用いて連立一次方程式を解いてみる。inv()に行列を渡すとその逆行列が返ってくる。そして係数行列の逆行列と定数項の列ベクトルの内積を求めるか、\という演算子を使う。つまり次のようにして連立一次方程式を解くことができる。

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

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

julia> inv(A) * b
2-element Array{Float64,1}:
  2.0
 -1.0

julia> A \ b
2-element Array{Float64,1}:
  2.0
 -1.0

julia> exit()

いずれの計算でも2.0と-1.0が得られた。したがって逆行列を利用した場合にも連立一次方程式(2)の解は同じになった。

逆行列を利用した連立一次方程式の解法

連立一次方程式を係数行列と列ベクトルとの積の形をした行列方程式$ A\vec{x} = \vec{b} $に直してみると、逆行列には次のような関係があることが分かる。行列の右肩に乗っている指数-1がその行列の逆行列であることを示す目印。

\[ \begin{pmatrix} 2 & -1 \\ 1 & -1 \end{pmatrix} \begin{pmatrix} x \\ y \end{pmatrix} = \begin{pmatrix} 5 \\ 3 \end{pmatrix} \] \[ \begin{pmatrix} 2 & -1 \\ 1 & -1 \end{pmatrix}^{-1} \begin{pmatrix} 5 \\ 3 \end{pmatrix} = \begin{pmatrix} x \\ y \end{pmatrix} \]

行列演算における逆行列はスカラー演算における逆数と同じ役割を持っている。3の逆数は3分の1。3分の1は指数を用いて$ 3^{-1} $とも書くことができる。

\[ 3 \times 5 = 15 \] \[ \dfrac{1}{3} \times 15 = 5 \] \[ \dfrac{1}{3} = 3^{-1} \]

掃き出し法（ガウスの消去法）を利用すると、ある行列からその逆行列を求めることもできる。その方法についてはまたの機会に。

係数行列が逆行列を持つ場合、したがってその行列式が0にならない場合、もとの連立一次方程式は必ず解を持つことが知られている。逆行列を持つ行列のことを正則行列と呼ぶので、係数行列が正則行列であるときにはガウスの消去法が適用できる。

ちなみに、行列式を求めるには、RとGNU Octaveではdet()、Python3ではnumpyをimportしてlinalg.det()、Maximaではdeterminant()、Juliaではusing LinearAlgebraを実行してからdet()のそれぞれ()内に行列を渡す。

例題2.

もう1つ、次の連立一次方程式を解いてみる。

\[ \begin{cases} -\dfrac{5}{7} - \dfrac{11}{7}x = -y \\ 2y = 7 + 5x \end{cases} \]

この連立一次方程式は変数項と定数項が上下に揃っていないので、それらを整頓して標準形にすることから始める必要がある。標準形というのは例えば次のような連立一次方程式の形のこと。aからdが係数、xとyが変数（未知数）、mとnが定数。

\[ \begin{cases} ax + by = m \\ cx + dy = n \end{cases} \]

左辺の変数xの項と変数yの項と右辺の定数項がそれぞれ列方向に揃っていることが見て取れる。この形が連立一次方程式の標準形。

連立一次方程式の項に分数がある場合には計算をしやすくするために分数の分母を取り払っておくと便利。分母と同じ数をその分数に掛けるか、同じ方程式に複数の分数があればその最小公倍数を掛ける。

方程式には等号を挟んだ両辺に同じ数による同じ演算を常に施して両辺の均衡を保つ必要があることを忘れずに。

分数を持つ一次方程式を7倍して分母の7を取り払っておく。
\[ \begin{cases} -\dfrac{5}{7} - \dfrac{11}{7}x = -y \\ 2y = 7 + 5x \end{cases} \] \[ \downarrow \] \[ \begin{cases} 7 \cdot -\dfrac{5}{7} - 7 \cdot \dfrac{11}{7}x = 7 \cdot -y \\ 2y = 7 + 5x \end{cases} \] \[ = \begin{cases} -5 - 11x = -7y \\ 2y = 7 + 5x \end{cases} \]
移項によって各項の配置換えをして式を変形し、連立一次方程式を標準形を作る。移項とは方程式の特定の項を消すために両辺に同じ数の同じ演算を行い、その結果としてその項が等号の右辺と左辺の間を符号の反転を伴って移動したように見える操作。
\[ \begin{cases} \colorbox{yellow}{$-5$} - 11x = \colorbox{cyan}{$-7y$} \\ 2y = 7 + \colorbox{pink}{$5x$} \end{cases} \] \[ \downarrow \] \[ \begin{cases} -5 + 5 - 11x + 7y = -7y + 7y + 5 \\ -5x + 2y = 7 + 5x - 5x \end{cases} \] \[ = \begin{cases} -11x + \colorbox{cyan}{$7y$} = \colorbox{yellow}{$5$} \\ \colorbox{pink}{$-5x$} + 2y = 7 \end{cases} \]
上段の方程式の左辺にある-5に5を足して-5を消し、方程式の均衡を保つためにその右辺にも5を足した。上段の方程式の右辺にある-7yに7yを足して-7yを消し、方程式の均衡を保つためにその左辺にも7yを足した。さらに、下段の方程式の右辺の5xを消すために5xを引き、方程式の均衡を保つためにその左辺に-5xを加えた。これで連立一次方程式の標準形が完成した。
標準形から拡大係数行列を作成する。
\[ \begin{cases} -11x + 7y = 5 \\ -5x + 2y = 7 \end{cases} \leftrightarrow \left( \begin{array}{cc|c} -11 & 7 & 5 \\ -5 & 2 & 7 \end{array} \right) \]
0でない行頭（ピボット）の絶対値が最大のものが第1行目にあることが望ましいのでそうなっていない場合は行交換をする必要があったが、この場合はその必要がない。
行基本変形3を適用し、第1行を-1倍して第2行に足してみる。$ R_1, R_2, \cdots $は行列の各行を指している。例えば$ R_2 $は第2行。
\[ \left( \begin{array}{cc|c} -11 & 7 & 5 \\ -5 & 2 & 7 \end{array} \right) \] \[ \downarrow \] \[ -R_1 + R_2 \rightarrow R_2 \] \[ \left( \begin{array}{cc|c} -11 & 7 & 5 \\ -1 \cdot -11 + (-5) & -1 \cdot 7 + 2 & -1 \cdot 5 + 7 \end{array} \right) \] \[ = \left( \begin{array}{cc|c} -11 & 7 & 5 \\ 6 & -5 & 2 \end{array} \right) \]
行基本変形3を適用し、第2行を2倍して第1行に足してみる。
\[ \left( \begin{array}{cc|c} -11 & 7 & 5 \\ 6 & -5 & 2 \end{array} \right) \] \[ \downarrow \] \[ 2R_2 + R_1 \rightarrow R_1 \] \[ \left( \begin{array}{cc|c} 2 \cdot 6 + (-11) & 2 \cdot -5 + 7 & 2 \cdot 2 + 5 \\ 6 & -5 & 2 \end{array} \right) \] \[ = \left( \begin{array}{cc|c} 1 & -3 & 9 \\ 6 & -5 & 2 \end{array} \right) \]
ピボットを1にすることができた。
行基本変形3を適用し、第1行を-6倍して第2行に足してみる。
\[ \left( \begin{array}{cc|c} 1 & -3 & 9 \\ 6 & -5 & 2 \end{array} \right) \] \[ \downarrow \] \[ -6R_1 + R_2 \rightarrow R_2 \] \[ \left( \begin{array}{cc|c} 1 & -3 & 9 \\ -6 \cdot 1 + 6 & -6 \cdot -3 + (-5) & -6 \cdot 9 + 2 \\ \end{array} \right) \] \[ = \left( \begin{array}{cc|c} 1 & -3 & 9 \\ 0 & 13 & -52 \end{array} \right) \]
行基本変形2を適用し、第2行を13分の1倍する。つまり13で割ってみる。
\[ \left( \begin{array}{cc|c} 1 & -3 & 9 \\ 0 & 13 & -52 \end{array} \right) \] \[ \downarrow \] \[ \dfrac{1}{13}R_2 \rightarrow R_2 \] \[ \left( \begin{array}{cc|c} 1 & -3 & 9 \\ \dfrac{1}{13} \cdot 0 & \dfrac{1}{13} \cdot 13 & \dfrac{1}{13} \cdot -52 \end{array} \right) \] \[ = \left( \begin{array}{cc|c} 1 & -3 & 9 \\ 0 & 1 & -4 \end{array} \right) \]
これで拡大係数行列の左辺の係数行列の部分が行階段形になった。ここまでの処理は狭義でのガウスの消去法。ここまでの処理はガウスの消去法において前進消去と呼ばれている。ここから先はガウス＝ジョーダンの消去法。
第1行第2列の-3を消すために行基本変形3を適用し、第2行を3倍して第1行に足してみる。
\[ \left( \begin{array}{cc|c} 1 & -3 & 9 \\ 0 & 1 & -4 \end{array} \right) \] \[ \downarrow \] \[ 3R_2 + R_1 \rightarrow R_1 \] \[ \left( \begin{array}{cc|c} 3 \cdot 0 + 1 & 3 \cdot 1 + (-3) & 3 \cdot -4 + 9 \\ 0 & 1 & -4 \end{array} \right) \] \[ = \left( \begin{array}{cc|c} 1 & 0 & -3 \\ 0 & 1 & -4 \end{array} \right) \]
これで拡大係数行列が行簡約階段形、したがって係数行列の部分が単位行列の形になった。ここでガウス＝ジョーダンの消去法が完了。
あとは拡大係数行列を連立一次方程式の形に戻せば、
\[ \left( \begin{array}{cc|c} 1 & 0 & -3 \\ 0 & 1 & -4 \end{array} \right) \leftrightarrow \begin{cases} x = -3 \\ y = -4 \end{cases} \]
と求まったことが分かる。

ガウスの消去法では、行階段形になったところで行基本変形を中断し、連立一次方程式の形に戻し、代入法によってその解を求めることもできる。この代入は後退代入と呼ばれている。それは次のようにする。

\[ \left( \begin{array}{cc|c} 1 & -3 & 9 \\ 0 & 1 & -4 \end{array} \right) \leftrightarrow \begin{cases} x - 3y = 9 \\ y = \colorbox{yellow}{-4} \end{cases} \] \[ \downarrow \] \begin{align*} x - 3 \cdot \colorbox{yellow}{-4} &= 9 \\ x &= \dfrac{9 + 3}{-4} \\ x &= -\dfrac{12}{4} \\ x &= -3 \end{align*}

これは移項ではないので符号は変わらない。

そんなわけで狭義でのガウスの消去法には前進消去と後退代入との2段階がある。

Maximaで答え合わせをしてみる。

(%i1) eqn1: -(5/7) - (11/7)*x = -y;
                                 11 x    5
(%o1)                         (- ----) - - = - y
                                  7      7
(%i2) eqn2: 2*y = 7 + 5*x;
(%o2)                            2 y = 5 x + 7
(%i3) solve([eqn1,eqn2],[x,y]);
(%o3)                        [[x = - 3, y = - 4]]
(%i4) quit();

Maximaで計算してもxが-3でyが-4になった。

行階段形と行簡約階段形とピボット

ここでは、ガウスの消去法で重要な役割を果たす行階段形という概念と、ガウス＝ジョーダンの消去法で重要な役割を果たす行簡約階段形という概念について直感的に記す。

典型的な行階段形は次のような形をした行列。ただし$ a_1, a_2, \cdots $は0以外の成分。

\[ \begin{pmatrix} 1 & a_1 & a_2 & a_3 & a_4 & a_5 \\ 0 & 1 & a_6 & a_7 & a_8 & a_9 \\ 0 & 0 & 1 & a_{10} & a_{11} & a_{12} \\ 0 & 0 & 0 & 1 & a_{13} & a_{14} \\ 0 & 0 & 0 & 0 & 1 & a_{15} \end{pmatrix} \]

次のような行列も行階段形。

\[ \begin{pmatrix} 1 & a_1 & a_2 & a_3 & a_4 & a_5 \\ 0 & 0 & 1 & a_5 & a_6 & a_8 \\ 0 & 0 & 0 & 1 & a_7 & a_{10} \\ 0 & 0 & 0 & 0 & 1 & a_{11}\\ \end{pmatrix} \]

1が対角線上に綺麗に並んでいなくても行階段形が成り立つ。

次のような行列も行階段形。

\[ \begin{pmatrix} 0 & 1 & a_1 & a_2 & a_3 & a_4 \\ 0 & 0 & 1 & a_5 & a_6 & a_8 \\ 0 & 0 & 0 & 1 & a_7 & a_{10} \\ 0 & 0 & 0 & 0 & 1 & a_{11}\\ \end{pmatrix} \]

次のような行列は行階段形でない。

\[ \begin{pmatrix} 1 & a_1 & a_2 & a_3 & a_4 & a_5 \\ 0 & 1 & a_6 & a_7 & a_8 & a_9 \\ 0 & 0 & 0 & \colorbox{pink}{$a_{10}$} & a_{11} & a_{12} \\ 0 & 0 & 0 & 0 & 1 & a_{13}\\ \end{pmatrix} \]

各行の先頭が1でない行列は行階段形であるとは言えない。

次のような行列も行階段形ではない。

\[ \begin{pmatrix} 1 & a_1 & a_2 & a_3 & a_4 \\ 0 & 0 & 1 & a_5 & a_6 \\ 0 & 0 & \colorbox{pink}{1} & a_7 & a_8 \\ 0 & 0 & 0 & 1 & a_9 \\ 0 & 0 & 0 & \colorbox{pink}{1} & a_{10} \end{pmatrix} \]

行の先頭の1はその上の行の先頭の1よりも常に右の列に位置していなければ行階段形の条件を満たさない。

ちなみに、行頭が1でない場合、同様の形をした行列は上三角行列と呼ばれている。

行簡約階段形は次のような形をした行列。つまり、行階段形の右上の成分が更に0へと削減され、行頭の1がある列がその1以外すべて0になった形。

\[ \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & a_1 \\ 0 & 1 & 0 & 0 & 0 & a_2 \\ 0 & 0 & 1 & 0 & 0 & a_3 \\ 0 & 0 & 0 & 1 & 0 & a_4 \\ 0 & 0 & 0 & 0 & 1 & a_5 \end{pmatrix} \]

次のような行列も行簡約階段形。

\[ \begin{pmatrix} 1 & 0 & a_1 & 0 & 0 & a_2 \\ 0 & 1 & a_3 & 0 & 0 & a_4 \\ 0 & 0 & 0 & 1 & 0 & a_5 \\ 0 & 0 & 0 & 0 & 1 & a_6 \\ \end{pmatrix} \]

各行の先頭の成分が1であり、第2行以下の先頭の1はその上の行の先頭の1よりもすべて右側の列にあり、先頭の1がある列はその1以外すべて0なので、行簡約階段形の条件を満たしている。

次のような行列は行簡約階段形ではない。

\[ \begin{pmatrix} 1 & 0 & a_1 & 0 & 0 & a_2 \\ 0 & 1 & a_3 & 0 & 0 & a_4 \\ 0 & 0 & 0 & 1 & \colorbox{pink}{$a_5$} & a_6 \\ 0 & 0 & 0 & 0 & 1 & a_7 \\ \end{pmatrix} \]

第4行の先頭の1と同じ列に0以外の成分が含まれているので行簡約階段形の条件を満たすことができない。

0を除外して見たとき、各行の先頭の成分はピボットとも呼ばれている。ガウスの消去法においてピボットをいかに選択するかが演算の効率を決める。コンピュータで連立一次方程式の数値計算を行う場合、ピボットを適切に選択することが丸め誤差の問題を回避するために特に重要になる。

まとめ

ガウスの消去法: 英語ではGaussian Elimination。連立一次方程式（線形方程式系とも呼ばれている）を行列を用いて解く方法。; 連立一次方程式の左辺の共通する変数項と右辺の定数項を揃え、その係数と定数をその順番のとおりに行列として並べて連立一次方程式の標準形を作り、そこから係数と定数を取り出し、標準形の並び順の通りに並べて拡大係数行列を作る。そしてその拡大係数行列が行階段形になるように3種類の行基本変形を選んで行う。; ガウス＝ジョーダンの消去法と区別して称した場合のガウス消去法は、拡大係数行列が行階段形になるまで行基本変形を繰り返すものを指し、これを前進消去と呼ぶことがある。行階段形になった時点で拡大係数行列を連立一次方程式に戻し、そこから後退代入による計算を行ってその連立一次方程式の解を最終的に得る。; 計算機科学の数値計算プログラミングにおいてよく例示されているアルゴリズムはこれ。

ガウス＝ジョーダンの消去法（ガウス＝ジョルダンの消去法）: 英語ではGaussian-Jordan Elimination。日本語では掃き出し法とも呼ばれている。連立一次方程式（線形方程式系とも呼ばれている）を行列を用いて解く方法。掃き出し法やガウスの消去法と言えば数学では通常こちらを指すことが多い。; ガウスの消去法では拡大係数行列が行階段形になるまで行基本変形を繰り返すのに対し、ガウス＝ジョーダンの消去法では拡大係数行列が行簡約階段形（行既約階段形とも呼ばれている）になるまで行基本変形を繰り返す。; ガウス＝ジョーダンの消去法を選ぶかガウスの消去法を選ぶかは場合によりけり。

係数行列: 英語ではCoefficient Matrices。連立一次方程式を標準形に変形し、その左辺にある係数すべてを同じ変数同士で列を構成するように並べて行列にしたもの。$ a_{11}, \cdots, a_{mn} $は係数、$ x_1, \cdots, x_n $は未知の変数（未知数）、$ b_1, \cdots, b_n $は定数。
\[ \begin{cases} a_{11}x_1 + a_{12}x_2 + a_{13}x_3 + \cdots + a_{1n}x_n = b_1 \\ a_{21}x_1 + a_{22}x_2 + a_{23}x_3 + \cdots + a_{2n}x_n = b_2 \\ a_{31}x_1 + a_{32}x_2 + a_{33}x_3 + \cdots + a_{3n}x_n = b_3 \\ \hspace{9em} \vdots \\ a_{m1}x_1 + a_{m2}x_2 + a_{m3}x_3 + \cdots + a_{mn}x_n = b_n \end{cases} \] \[ \updownarrow \] \[ \begin{pmatrix} a_{11} & a_{12} & a_{13} & \cdots & a_{1n} \\ a_{21} & a_{22} & a_{23} & \cdots & a_{2n} \\ a_{31} & a_{32} & a_{33} & \cdots & a_{3n} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & a_{m3} & \cdots & a_{mn} \end{pmatrix} \]

拡大係数行列: 英語ではAugmented Matrices。単に拡大行列とも呼ばれている。連立一次方程式の標準形の右辺にある定数項の列を係数行列の右側に追加した行列のこと。$ a_{11}, \cdots, a_{mn} $は係数、$ x_1, \cdots, x_n $は未知の変数（未知数）、$ b_1, \cdots, b_n $は定数。
\[ \begin{cases} a_{11}x_1 + a_{12}x_2 + a_{13}x_3 + \cdots + a_{1n}x_n = b_1 \\ a_{21}x_1 + a_{22}x_2 + a_{23}x_3 + \cdots + a_{2n}x_n = b_2 \\ a_{31}x_1 + a_{32}x_2 + a_{33}x_3 + \cdots + a_{3n}x_n = b_3 \\ \hspace{9em} \vdots \\ a_{m1}x_1 + a_{m2}x_2 + a_{m3}x_3 + \cdots + a_{mn}x_n = b_n \end{cases} \] \[ \updownarrow \] \[ \left( \begin{array}{ccccc|c} a_{11} & a_{12} & a_{13} & \cdots & a_{1n} & b_1 \\ a_{21} & a_{22} & a_{23} & \cdots & a_{2n} & b_2 \\ a_{31} & a_{32} & a_{33} & \cdots & a_{3n} & b_3 \\ \vdots & \vdots & \vdots & \ddots & \vdots & \vdots \\ a_{m1} & a_{m2} & a_{m3} & \cdots & a_{mn} & b_n \end{array} \right) \]

行基本変形

英語ではElementary Row Operations。拡大係数行列を構成する行に対し、3種類の操作を用いて行列の成分を0に、もしくは行列の成分の係数を1にもってゆく方法。3種類の操作とは、

ある2つの行同士の位置を置き換えること（$ R_1 \leftrightarrows R_2 $）、
ある行の各成分を共通の値で定数倍すること（$ rR_i $）、
ある行の各成分を共通の値で定数倍した各値をもう1つの行の同の一列の各成分に加算すること（$ rR_1 + R_2 \rightarrow R_2 $）

を指している。$ R_1, R_2, \cdots, R_i $は各行または任意の行、rはなんらかの実数。行基本変形では同一行の全ての成分に同じ演算を行う必要がある。

単位行列: 英語ではIdentity Matrices。正方行列であり、かつ、対角行列であり、かつ、対角線上の成分が1のみで構成された行列のこと。行列の演算においてスカラーの1と同様の働きを持つ。; 例えば次の行列は4列4行の、つまり4次の単位行列。
\[ I_4 = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \\ \end{pmatrix} \]

行列の行階段形: 英語ではRow Echelon Formと呼ばれており、頭文字を使ってREFと略されることが多い。次のような行列のこと。ただし$ a_1, a_2, a_3, \cdots $は0でない成分。
\[ REF = \begin{pmatrix} 1 & a_1 & a_2 & a_3 & a_4 \\ 0 & 1 & a_5 & a_6 & a_7 \\ 0 & 0 & 1 & a_8 & a_9 \\ 0 & 0 & 0 & 1 & a_{10} \\ \end{pmatrix} \] \[ REF = \begin{pmatrix} 0 & 1 & a_1 & a_2 & a_3 & a_4 \\ 0 & 0 & 1 & a_5 & a_6 & a_7 \\ 0 & 0 & 0 & 0 & 1 & a_8 \\ \end{pmatrix} \]

行簡約階段形: 英語ではReduced Row Echelon Form。頭字語ではRREF。行列の行簡約階段形は行列の行階段形であり、かつ、行頭の1がある列がその1以外全て0になっているもの。典型的には次のような形をしている。$ a_1, \cdots, a_4 $は0でない成分。
\[ RREF = \begin{pmatrix} 1 & 0 & 0 & 0 & a_1 \\ 0 & 1 & 0 & 0 & a_2 \\ 0 & 0 & 1 & 0 & a_3 \\ 0 & 0 & 0 & 1 & a_4 \\ \end{pmatrix} \]

連立n元一次方程式の標準形: 連立一次方程式を拡大係数行列に転記するためには連立一次方程式が標準形になっている必要がある。そうなっていなければ移項を使って標準形になるように式を変形することができる。; 連立n元一次方程式の標準形を一般形として記すと次のようになる。ただし$ a_{11}, \cdots, a_{mn} $は係数、$ x_1, \cdots, x_n $は未知の変数（未知数）、$ b_1, \cdots, b_n $は定数。
\[ \begin{cases} a_{11}x_1 + a_{12}x_2 + a_{13}x_3 + \cdots + a_{1n}x_n = b_1 \\ a_{21}x_1 + a_{22}x_2 + a_{23}x_3 + \cdots + a_{2n}x_n = b_2 \\ a_{31}x_1 + a_{32}x_2 + a_{33}x_3 + \cdots + a_{3n}x_n = b_3 \\ \hspace{9em} \vdots \\ a_{m1}x_1 + a_{m2}x_2 + a_{m3}x_3 + \cdots + a_{mn}x_n = b_n \end{cases} \]; これを行列方程式$ A\vec{x} = \vec{b} $として一般的に表すと次のようになる。
\[ \begin{pmatrix} a_{11} & a_{12} & a_{13} & \cdots & a_{1n} \\ a_{21} & a_{22} & a_{23} & \cdots & a_{2n} \\ a_{31} & a_{32} & a_{33} & \cdots & a_{3n} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & a_{m3} & \cdots & a_{mn} \end{pmatrix} \begin{pmatrix} x_1 \\ x_2 \\ x_3 \\ \vdots \\ x_n \end{pmatrix} = \begin{pmatrix} b_1 \\ b_2 \\ b_3 \\ \vdots \\ b_n \end{pmatrix} \]; これをベクトル方程式として一般的に表すと次のようになる。
\[ x_1 \begin{pmatrix} a_{11} \\ a_{21} \\ a_{31} \\ \vdots \\ a_{m1} \end{pmatrix} x_2 \begin{pmatrix} a_{12} \\ a_{22} \\ a_{32} \\ \vdots \\ a_{m2} \end{pmatrix} x_3 \begin{pmatrix} a_{13} \\ a_{23} \\ a_{33} \\ \vdots \\ a_{m3} \end{pmatrix} \cdots x_n \begin{pmatrix} a_{1n} \\ a_{2n} \\ a_{3n} \\ \vdots \\ a_{mn} \end{pmatrix} = \begin{pmatrix} b_1 \\ b_2 \\ b_3 \\ \vdots \\ b_n \end{pmatrix} \]
各列ベクトルが各未知数（各変数）によって重み付けされている関係がこの式から見て取れる。

R言語で連立一次方程式を解くには: matrix()とc()で係数行列と定数項の列ベクトルを用意し、solve()の引数として渡す。あるいはまた、pracmaというパッケージを利用してMATLAB互換のrref()を用いることができる。その際にlibrary(pracma)を実行しておく必要がある。

Python3で連立一次方程式を解くには: Numpyをimportし、numpy.matrix()で係数行列と定数項の列ベクトルを作成した後、それらをnumpy.linalg.solve()の引数として渡す。

GNU Octaveで連立一次方程式を解くには: 係数行列と定数項の列ベクトルを作成した後、linsolve()の引数としてそれらを渡す。

Maximaで連立一次方程式を解くには: 連立一次方程式を構成する各々の一次方程式をeqn1,eqn2,eqn3とし、各々の未知の変数をx,y,zとした場合、solve([eqn1,eqn2,eqn3],[x,y,z])とすることによってその解を求めることができる。

Juliaで連立一次方程式を解くには: 係数行列と定数項の列ベクトルを作成した後、演算子の\を用いるか、inv()で係数行列の逆行列を作って列ベクトルとの内積を求める。

逆行列: 英語ではMatrix InversesとかInverse Matricesなどと呼ばれることがある。ある行列の余因子行列と行列式を導き出し、それら余因子行列と行列式分の1との定数倍を求めると逆行列が出来上がる。通常のスカラー代数で言うところの逆数に当たる。逆行列は右肩に-1を添えて表されることが多い。; $ a_{11}, \cdots, a_{22} $は任意の成分。
\begin{align*} \begin{pmatrix} a_{11} & a_{12} \\ a_{21} & a_{22} \end{pmatrix}^{-1} &= \dfrac{1}{a_{11}a_{22} - a_{12}a_{21}} \begin{pmatrix} a_{22} & -a_{12} \\ -a_{21} & a_{11} \end{pmatrix} \end{align*}; detはその行列の行列式を表す目印。
\[ a_{11}a_{22} - a_{12}a_{21} = det \begin{pmatrix} a_{11} & a_{12} \\ a_{21} & a_{22} \end{pmatrix}\]; ちなみに、逆行列を持つ行列は正則行列と呼ばれている。

連立一次方程式が解を持つための必要十分条件は: その係数行列が正則行列であるとき。正則行列とは行列式が0でない行列のこと。行列式が0でない行列はその逆行列を持っている。

移項: 方程式を解くための方法の1つ。方程式において等号を境とした一方の辺からもう一方の辺へとある項を移動させるとき、その項の正負の符号を反転させなくてはならない操作。項が等号を跳び越えるときにその項に-1を掛けなければいけない操作であると言い換えることもできる。
\[ a = -b \] \[ \updownarrow \] \[ b = -a \]
左辺のaが右辺に移ると-aになり、左辺の-bが右辺に移るとbになる。右辺から左辺に移る場合も同様に正負が反転する。; 英語ではTranspositionとかTransposingと呼ばれていることがあるが、こちらの用語はもっと広い意味を持っているかもしれない。方程式の式変形に限ってみても係数を消す操作がTranspositionに含まれているかもしれない。この場合には逆演算の関係にある乗法と除法が反転する。
\begin{align*} ax &= b \\ x &= b \cdot \dfrac{1}{a} = \dfrac{b}{a} \end{align*}
つまり、この方程式の左辺のaが等号を跳び越えて右辺の末尾に移動すると、逆数のa分の1を掛ける形に変わる。

DebianユーザーがNLTKで自然言語処理の初歩の初歩を試してみた

2021-10-05T22:34:00.002+09:00

この投稿は自然言語処理の中で一番初歩的なテキスト分析（字句解析）についての事始め。

ダウンロードとインストール

Python 3のdebパッケージとPython3用のNLTK(Natural Language Toolkit)のdebパッケージを公式のリポジトリからダウンロードしてインストールした。

$ su
# apt install python3 python3-nltk

python3-nltkというdebパッケージは、Debianのバージョンのbusterにもbullseyeにもbookwormにも存在する。

NLTKは、そのホームページの説明等によれば、自然言語処理に必要な道具類をまとめたプラットフォームなのだそうで、しかもオープンソースの企画らしい。

ダウンロードとインストールがうまくいったのでPython3を早速起動し、NLTKのホームページに掲載されている簡単なコードを試してみた。

まずはPython3をターミナル・エミュレーター上で起動。

$ python3
Python 3.7.3 （省略）

次にNLTKをインポート。

>>> import nltk

適当に選んだ文字列をsentenceに代入した。sentenceは任意の識別子。

>>> sentence = """A similar argument applies
...  to any other a priori judgement."""
>>> print(sentence)
A similar argument applies
 to any other a priori judgement.

Python 3ではヒアドキュメントを3つの二重引用符号(""")で囲む。こうした場合、/nなどによって改行を明示せずとも複数行に渡って文字列を入力できる。ヒアドキュメントとはHTMLのpre要素のようなもの。

文字列として選んだのはバートランド・ラッセル著の『哲学の問題』からの一節。

Russell, Bertrand. The Problems of Philosophy. p.140
epub形式のファイルはLinuxではCalibreなどで読むことができる。

そしてNLTKのword_tokenize()に引数としてその文字列を渡してトークンを抽出。

>>> tokens = nltk.word_tokenize(sentence)
Traceback (most recent call last):
（中略）
LookupError: 
**********************************************************************
  Resource punkt not found.
  Please use the NLTK Downloader to obtain the resource:

  >>> import nltk
  >>> nltk.download('punkt')
  
  Attempted to load tokenizers/punkt/PY3/english.pickle
（以下省略）

ここでいきなりエラーが生じた。リソースのpunktが見つからないと言われた。エラーのメッセージにあるとおり、NLTKのdownload()によってpunktをダウンロードしたみた。

>>> nltk.download('punkt')
[nltk_data] Downloading package punkt to（中略）
[nltk_data]   Unzipping tokenizers/punkt.zip.
True

こうしたリソースはNLTK Dataと呼ばれていてnltk.download()によってダウンロードすることができる。

もう一度やり直し。キーボードの上矢印キーを押すと前に入力したコードを順番に出力してくれるので、その機能を利用すると便利。

>>> tokens = nltk.word_tokenize(sentence)
>>> print(tokens)
['A', 'similar', 'argument', 'applies', 'to', 'any', 'other', 'a', 'priori', 'judgement', '.']

うまくいった。個々の単語や符号に分割してくれているのが見て取れる。この処理はトークン化と呼ばれているらしい。英語ではtokenization。

英文の場合はそのほとんどが分ち書きされるので、このメソッドの内部コードは簡単そうだ。日本語や中国語やタイ語だと複雑になりそう。

トークン化で生成したtokensをNLTKのpos_tag()に渡して単語に品詞タグを付ける処理を行うコードが次。ただしこの処理にはaveraged_perceptron_taggerというリソースが必要になるので先ほどと同じようにダウンロードした。

>>> nltk.download('averaged_perceptron_tagger')
[nltk_data] Downloading package averaged_perceptron_tagger to（中略）
[nltk_data]   Unzipping taggers/averaged_perceptron_tagger.zip.
True
>>> tagged = nltk.pos_tag(tokens)
>>> print(tagged)
[('A', 'DT'), ('similar', 'JJ'), ('argument', 'NN'), ('applies', 'NNS'), ('to', 'TO'), ('any', 'DT'), ('other', 'JJ'), ('a', 'DT'), ('priori', 'JJ'), ('judgement', 'NN'), ('.', '.')]

この処理は品詞タグ付けと呼ばれているらしい。英語ではpart-of-speech tagging、略してPOS tagging。

DTは決定詞、JJは形容詞、NNは名詞の単数形、NNSは名詞の複数形、TOはtoを直接指す。

タグがどの品詞を意味しているかについて知りたい場合は「part-of-speech tagging tagset NLTK」などの文字列でインターネット上を検索してみれば見つかる。英文だけど。

よく見ると、appliesを名詞の複数形(NNS)と判断している。これは誤りだと思う。appliesは動詞applyの三人称単数現在(VBZ)が正しいはず。

次に行う処理はチャンキングと呼ばれていること。英語ではchunking。「分割すること」というような意味。この処理にはmaxent_ne_chunker とwordsというリソースが必要になるので予めダウンロードする。

>>> nltk.download('maxent_ne_chunker')
[nltk_data] Downloading package maxent_ne_chunker to（中略）
[nltk_data]   Unzipping chunkers/maxent_ne_chunker.zip.
True
>>> nltk.download('words')
[nltk_data] Downloading package words to
（中略）
[nltk_data]   Unzipping corpora/words.zip.
True

品詞タグ付けで生成したtaggedを与えてNLTKのchunk.ne_chunk()を実行する。

>>> entities = nltk.chunk.ne_chunk(tagged)
>>> print(entities)
(S
  A/DT
  similar/JJ
  argument/NN
  applies/NNS
  to/TO
  any/DT
  other/JJ
  a/DT
  priori/JJ
  judgement/NN
  ./.)

チャンキングの処理結果を見ると、ディレクトリ状にまとめられ、その先頭には'S'という文字があるのが見て取れる。前者をセグメント化と呼び、後者をラベル付けと呼ぶらしい。

名詞句のルールを追加

名詞句(NP)を分類するために更に文法ルールを適用する。NPは名詞句を表すタグ名。波括弧内では正規表現を用いて名詞句の構造を定義している。

>>> grammar = "NP: {<DT>?<JJ>*<NN>}

波括弧内の正規表現が意味するのは、DT（決定詞）かJJ（形容詞）で始まり、NN（名詞）で終わるもの。?がorを表し、*が任意の文字列を表している。

これをRegexpParser()に引数として渡してチャンキングのルールを追加する。

>>> cp = nltk.RegexpParser(grammar)

追加したこのルールに基づいて構文解析を行う。

>>> result = cp.parse(entities)
>>> print(result)
(S
  (NP A/DT similar/JJ argument/NN)
  applies/NNS
  to/TO
  any/DT
  other/JJ
  (NP a/DT priori/JJ judgement/NN)
  ./.)

決定詞と形容詞と名詞から成る2つの名詞句が分類されているのが見て取れる。

これを構文木として視覚化するにはdraw()を実行する。

>>> result.draw()

別ウィンドウが開いてその中に構文木が表示された。

正規表現は本当ならば"NP: {<DT>?<JJ>?<JJR>?<JJS>*<NN>?<NNS>?<NNP>?<NNPS>}"としたかったが、appliesを名詞の複数形と認識してしまっているので誤った結果になってしまう。この修正ができるかどうかについてはまたの機会に。

Google Chartsを利用してHPやブログにチャート（グラフ等）を描く方法

2021-09-21T12:13:00.014+09:00

ブログなどのウェブ・ページに自分の意見や主張や考えを掲載するときにそれを裏付けるデータがあると説得力が増すかもしれない。そのデータをチャートとして描いて視覚化できれば尚更。

その場合、一般的なのはそれを専門にしている表計算アプリを使うこと。表計算ソフトウェアにはデータを各種チャートの形にして視覚化してくれる機能が大抵備わっている。LibreOfficeのCalcの場合、そのチャートをコピーしてInkscape上に貼り付けることができる。それをPNG形式の画像やSVG形式の画像として保存し、それをウェブ・ページに掲載する方法がある。

他の選択肢としては、HTML5 CanvasやJavaScriptのライブラリを使う手がある。データを視覚化してくれるJavaScriptのライブラリが最近では数え切れないくらい多くある。

今回はGoogle Chartsのライブラリを利用させていただいた。その手順についてこの投稿に書き留める。

2種類のチャートの完成図

同じデータ・セットで2種類のチャートを作ってみた。その完成図が次のとおり。

Google Chartsが有効ではありません。このページを再読み込みをすると有効になることがあります。

1つ目のチャートは日本のマクロ経済のインフレ率の時系列データを折線グラフにしたもの。

2つ目のチャートは同じ時系列データを縦の棒グラフにしたもの。棒グラフだと0に近い値が見えなくなってしまっているためか、そこにマウスのポインタを合わせても値を表示してくれるイベント処理が機能しない。

Google Chartsが有効ではありません。このページを再読み込みすると有効になることがあります。

これらのチャートを描くためのコードをHTMLから順に説明する。

HTMLのコード

<!DOCTYPE html>
<html lang="ja">
<head>
<meta charset="UTF-8">
<title>Google Chartでチャートを描いてみた</title>
<!-- loader.jsを読み込む -->
<script src="https://www.gstatic.com/charts/loader.js"></script>
</head>
<body>
<!-- -->
<div id="chartA">Google Chartsが有効ではありません。</div>
<div id="chartB">Google Chartsが有効ではありません。</div>
</body>
<script defer>
<!-- ここにJavaScriptのソースコードを記述 -->
</script>
</html>

チャートを埋め込むHTML文書を用意。
div要素にid属性を与えてbody要素内のチャートを埋め込みたい場所に置く。
loader.jsの場所をsrc属性に持つ1つ目のscript要素をhead要素内に置く。
JavaScriptのコードをHTMLのソース内に埋め込むための2つ目のscript要素をhead要素内に置く。

JavaScriptのコードが最後に読み込まれることを期待してここでは2つ目のscript要素をbody要素の下に置くことにした。

script要素のtype属性はデフォルトで"text/javascript"なのでtype属性を省略した。

JavaScriptのコードをHTML文書の中に直接埋め込まずに別のファイルに分離してもオーケー。その場合にはscript要素にsrc属性を設けてその値としてJavaScriptのソースコードの場所とそのファイル名（拡張子は.js）を指定する必要がある。

チャートを貼り付ける場所はHTML文書のbody要素の中にdiv要素を用いて指定する。チャートの数だけ用意し、それぞれにid属性を割り振っておく。

今回は2つのチャートを描画するため、2つのdiv要素を記した。それぞれに異なるidを持つ。

JavaScriptのコード

ここで使用したJavaScriptのコードの内容は次のとおり。

<script defer>
// 匿名関数でコード全体を袋とじ
(function() {

   // データセットを連想配列として定義
   const dataSet = [
      {"年":"1960","インフレ率":3.57},
      {"年":"1961","インフレ率":5.36},
      {"年":"1962","インフレ率":6.83},
      {"年":"1963","インフレ率":6.7},
      {"年":"1964","インフレ率":3.8},
      {"年":"1965","インフレ率":6.65},
      {"年":"1966","インフレ率":5.04},
      {"年":"1967","インフレ率":3.98},
      {"年":"1968","インフレ率":5.33},
      {"年":"1969","インフレ率":5.24},
      {"年":"1970","インフレ率":6.92},
      {"年":"1971","インフレ率":6.39},
      {"年":"1972","インフレ率":4.84},
      {"年":"1973","インフレ率":11.6},
      {"年":"1974","インフレ率":23.22},
      {"年":"1975","インフレ率":11.73},
      {"年":"1976","インフレ率":9.37},
      {"年":"1977","インフレ率":8.16},
      {"年":"1978","インフレ率":4.2},
      {"年":"1979","インフレ率":3.7},
      {"年":"1980","インフレ率":7.77},
      {"年":"1981","インフレ率":4.91},
      {"年":"1982","インフレ率":2.74},
      {"年":"1983","インフレ率":1.89},
      {"年":"1984","インフレ率":2.26},
      {"年":"1985","インフレ率":2.03},
      {"年":"1986","インフレ率":0.59},
      {"年":"1987","インフレ率":0.12},
      {"年":"1988","インフレ率":0.67},
      {"年":"1989","インフレ率":2.27},
      {"年":"1990","インフレ率":3.07},
      {"年":"1991","インフレ率":3.25},
      {"年":"1992","インフレ率":1.76},
      {"年":"1993","インフレ率":1.24},
      {"年":"1994","インフレ率":0.69},
      {"年":"1995","インフレ率":-0.12},
      {"年":"1996","インフレ率":0.13},
      {"年":"1997","インフレ率":1.74},
      {"年":"1998","インフレ率":0.66},
      {"年":"1999","インフレ率":-0.34},
      {"年":"2000","インフレ率":-0.67},
      {"年":"2001","インフレ率":-0.74},
      {"年":"2002","インフレ率":-0.92},
      {"年":"2003","インフレ率":-0.25},
      {"年":"2004","インフレ率":0},
      {"年":"2005","インフレ率":-0.28},
      {"年":"2006","インフレ率":0.24},
      {"年":"2007","インフレ率":0.06},
      {"年":"2008","インフレ率":1.38},
      {"年":"2009","インフレ率":1.35},
      {"年":"2010","インフレ率":-0.71},
      {"年":"2011","インフレ率":-0.26},
      {"年":"2012","インフレ率":-0.05},
      {"年":"2013","インフレ率":0.34},
      {"年":"2014","インフレ率":2.76},
      {"年":"2015","インフレ率":0.78},
      {"年":"2016","インフレ率":-0.11},
      {"年":"2017","インフレ率":0.46},
      {"年":"2018","インフレ率":0.97},
      {"年":"2019","インフレ率":0.47},
      {"年":"2020","インフレ率":-0.01}
   ]

   // 配列dataSetの第1要素の2つのキー名を取得
   const dataKey = Object.keys(dataSet[0]);
   const dataKey1 = dataKey[0];
   const dataKey2 = dataKey[1];

   // オブジェクト定数
   const cht = google.charts;

   // Google Chartsのパッケージを読み込む
   cht.load(
      'current', // バージョン
      {'packages':['corechart'], // パッケージ名
      'language':'ja',} // ロケール
   );

   // パッケージの読込完了後に呼び出す匿名函数を定義
   cht.setOnLoadCallback(
      function() {
         // 函数を呼び出す（引数はデータセットと標題）
         drawChartA('chartA', 'LineChart',
            dataSet, '日本のインフレ率 1960-2020');
         drawChartB('chartB', 'ColumnChart',
            'dataSet, '日本のインフレ率 1960-2020');
      }
   );

   // チャートを描く函数A（引数はデータセットと標題）
   function drawChartA(div, chartType, data, title) {
      // データ表のオブジェクトを作成
      const dTable = new google.visualization.DataTable();

      // データ表の列のデータ型と列名を定義 
      dTable.addColumn(typeof data[0][dataKey1], dataKey1);
      dTable.addColumn(typeof data[0][dataKey2], dataKey2);
   
      // データセットから値を順番に取り出してデータ表の行に入力
      for (let i = 0; i < data.length; i++) {
         dTable.addRow( [data[i][dataKey1], data[i][dataKey2]] );
      }

      // チャートの標題などのオプションを定義
      const options = {
         'title': title, // チャートの標題
         'width':670, // 幅
         'height':500 // 高さ
      };

      // 折線グラフのオブジェクトを作成
      const chart = new google.visualization[chartType](
         document.getElementById(div)); // div要素を取得

      // チャートを描く（引数はデータ表とオプション）
      chart.draw(dTable, options);
   
   }

})(); // 袋とじのための匿名函数の終わり
</script>

以下はJavaScriptのコードについての説明。

まず、インフレ率の数値とその年を時系列に並べたデータ・セットを連想配列オブジェクトとして定義した。

// データ・セットを連想配列として定義
const dataSet = [
   {"年":"1960","インフレ率":3.57},
   {"年":"1961","インフレ率":5.36},
   {"年":"1962","インフレ率":6.83},
   {"年":"1963","インフレ率":6.7},
   {"年":"1964","インフレ率":3.8},
   {"年":"1965","インフレ率":6.65},
   {"年":"1966","インフレ率":5.04},
   {"年":"1967","インフレ率":3.98},
   {"年":"1968","インフレ率":5.33},
   {"年":"1969","インフレ率":5.24},
   {"年":"1970","インフレ率":6.92},
   {"年":"1971","インフレ率":6.39},
   {"年":"1972","インフレ率":4.84},
   {"年":"1973","インフレ率":11.6},
   {"年":"1974","インフレ率":23.22},
   {"年":"1975","インフレ率":11.73},
   {"年":"1976","インフレ率":9.37},
   {"年":"1977","インフレ率":8.16},
   {"年":"1978","インフレ率":4.2},
   {"年":"1979","インフレ率":3.7},
   {"年":"1980","インフレ率":7.77},
   {"年":"1981","インフレ率":4.91},
   {"年":"1982","インフレ率":2.74},
   {"年":"1983","インフレ率":1.89},
   {"年":"1984","インフレ率":2.26},
   {"年":"1985","インフレ率":2.03},
   {"年":"1986","インフレ率":0.59},
   {"年":"1987","インフレ率":0.12},
   {"年":"1988","インフレ率":0.67},
   {"年":"1989","インフレ率":2.27},
   {"年":"1990","インフレ率":3.07},
   {"年":"1991","インフレ率":3.25},
   {"年":"1992","インフレ率":1.76},
   {"年":"1993","インフレ率":1.24},
   {"年":"1994","インフレ率":0.69},
   {"年":"1995","インフレ率":-0.12},
   {"年":"1996","インフレ率":0.13},
   {"年":"1997","インフレ率":1.74},
   {"年":"1998","インフレ率":0.66},
   {"年":"1999","インフレ率":-0.34},
   {"年":"2000","インフレ率":-0.67},
   {"年":"2001","インフレ率":-0.74},
   {"年":"2002","インフレ率":-0.92},
   {"年":"2003","インフレ率":-0.25},
   {"年":"2004","インフレ率":0},
   {"年":"2005","インフレ率":-0.28},
   {"年":"2006","インフレ率":0.24},
   {"年":"2007","インフレ率":0.06},
   {"年":"2008","インフレ率":1.38},
   {"年":"2009","インフレ率":1.35},
   {"年":"2010","インフレ率":-0.71},
   {"年":"2011","インフレ率":-0.26},
   {"年":"2012","インフレ率":-0.05},
   {"年":"2013","インフレ率":0.34},
   {"年":"2014","インフレ率":2.76},
   {"年":"2015","インフレ率":0.78},
   {"年":"2016","インフレ率":-0.11},
   {"年":"2017","インフレ率":0.46},
   {"年":"2018","インフレ率":0.97},
   {"年":"2019","インフレ率":0.47},
   {"年":"2020","インフレ率":-0.01}
]

この連想配列オブジェクトは"年"と"インフレ率"という2つのキーとその値を持っている。"年"の値がstring型で"インフレ率"の値がnumber型。

Object.keysメソッドを使ってこの連想配列の第1要素から2つのキーを取り出す処理が次のコード。

// 配列dataSetの第1要素の2つのキー名を取得
const dataKey = Object.keys(dataSet[0]);
const dataKey1 = dataKey[0];
const dataKey2 = dataKey[1];

Object.keysメソッドの引数に連想配列の第1要素を指し示すdataSet[0]を与えた。これによってdataKeyには"年"と"インフレ率"という2つのキーが代入された。そしてそれらをそれぞれ取り出し、dataKey1に"年"を、dataKey2に"インフレ率"を割り当てた。いずれもstring型。

google.charts.loadメソッドを用いてGoogle Chartsのライブラリを読み込むように指示するのが次のコード。

const cht = google.charts;
// パッケージを読み込む
cht.load('current', // バージョン
    {packages:['corechart'], // パッケージ
    'language':'ja'} // ロケール
);

loadメソッドの第1引数にはバージョンを指定。'current'は公式にリリースされている最新のバージョンを意味している。'upcoming'とすると、公式にまだリリースされていないテスト・バージョンを指定したことになる。

バージョンを固定したい場合にはバージョン番号を直接指定する。

loadメソッドの第2引数はいくつかの設定をするためにあり、波括弧の中に複数の項目をカンマで区切って指定できる。そのうちpackageは必須。'corechart'を指定すると、用意されている基本的なチャート・クラスをインスタンス化して利用できるようになる。

packageの値は角括弧の中にカンマで区切って複数指定できる。例えば次のように。

cht.load('current',
    // 複数のパッケージを読み込む
    {packages:['corechart','table',''geochart'],
    'language':'ja'}
);

loadメソッドの第2引数の2つ目には'language'としてロケールを指定した。これは言語や通貨単位などを特定するためのもの。jaが日本語や日本の通貨単位（円）を意味する。チャートに日本語の文字列を描画したければ指定しておいたほうがよいかもしれない。

次にコールバック函数を登録する。この函数はパッケージの読み込みが完了した後に呼び出されるためのもの。C言語で言えばmain函数に当たるようなものだろうか。

これを行うにはsetOnLoadCallbackメソッドを用いてその引数に匿名函数を与える方法がある。例えば次のように。

// パッケージの読込完了後に呼び出す匿名函数を定義
cht.setOnLoadCallback(
   function() {
      // 函数を呼び出す（引数はデータ・セットと標題）
      drawChartA('chartA', 'LineChart',
         dataSet, '日本のインフレ率 1960-2020');
      drawChartB('chartB', 'ColumnChart',
         dataSet, '日本のインフレ率 1960-2020');
   }
);

この匿名函数の中には、各々のチャートを作成するためにこれから定義する函数を呼び出すステートメントが2つある。それらの引数には、HTMLのdiv要素のid、チャートのタイプ名、データ・セット、チャートの標題を与える必要があるようにしてある。

各々のチャートを作成する函数を定義

チャートを描くための函数を1つ定義した。函数名はdrawChart。この函数はdiv要素のid名(div)とチャートのタイプ名(chartType)とデータ・セット(data)とチャートの標題(title)の4つの引数を受け取るようにした。函数呼び出すステートメントでこれらの引数の値を具体的に指定する。

function drawChartA(div, chartType, data, title) {
// ここのブロックに函数の内容をコーディング
}

この函数のブロックの中ではまずデータ・テーブルを作成する。データ・テーブルとは列(a column)と行(a row)の形式にデータを並べた表のこと。作成するチャートに適合したデータ・テーブルを用意する必要がある。

そのためにデータ・テーブルのコンストラクタ函数（クラス）からオブジェクトを作成。いわゆるインスタンス化。

const dTable = new google.visualization.DataTable();

次にaddColumnメソッドを用いてデータ・テーブルの各列のデータ型とラベル名を設定。

dTable.addColumn(typeof data[0][dataKey1], dataKey1);
dTable.addColumn(typeof data[0][dataKey2], dataKey2);

addColumnメソッドの第1引数にはデータ型を、その第2引数には列名を指定する。値の指定に定数を使っているので分かりにくいが、要するに次のように指定したことと同じこと。

dTable.addColumn('string', '年');
dTable.addColumn('number', 'インフレ率');

定数を用いることで別のデータ・セットにしたときにも対応できるコードにした。ただしそのデータ・セットは同じ形式の連想配列である必要がある。

addRowメソッドを用いてデータ・テーブルに値を追加していく処理が次のコード。

for (let i = 0; i < data.length; i++) {
   dTable.addRow( [data[i][dataKey1], data[i][dataKey2]] );
}

その引数に定数を指定しているので分かりにくいが、要するに、addRowメソッドの第1引数に"年"の値を、その第2引数に"インフレ率"の値をそれぞれ指定していることと同じ。

for文なのでカウンター変数iが0から順番に1つずつ増えていきながら連想配列の長さぶんだけこの処理が繰り返される。こうして連想配列の値がデータ・テーブルに転記されるようになるはず。

JavaScriptでの連想配列（オブジェクトの一種）の取扱いについての詳細はまたの機会に。

次のコードではオプションを指定している。オプションとはこのチャートに与える様々な属性のこと。プロパティか。あるいは引数か。

const options = {
   'title': title, // チャートの標題
   'width':670, // 幅
   'height':500 // 高さ
};

最初は文字通りこのチャートのタイトル(title)。2つめはチャートの幅(width)。3つめはチャートの高さ(height)。

次のコードではライン・チャート（折線グラフ）のコンストラクタ函数（クラス）からオブジェクト（インスタンス）を作成している。その引数にはgetElementByIdメソッドを使ってdiv要素を取得して与えている。

const chart = new google.visualization[chartType](
   document.getElementById(div));

このコードは本来は次のようなものだが、チャート・タイプ名の部分とdiv要素のidの部分をこの函数が引数として受け取るようにした。

const chart = new google.visualization.チャート・タイプ名(
   document.getElementById('div要素のid'));

Google Chartsにはどのようなチャート・クラスが用意されているかを知るには、Google Chartsのウェブ・サイトを開き、ナビゲート・メニューの「Guides」から「Chart Types」の一覧を参照する。「Chart Gallery」を見ると各種チャートの完成図を見ながら選びやすい。そこにそれぞれのチャートの利用方法が（英文だけど）書かれてある。

最後にdrawメソッドを使ってその引数にデータ・テーブルと先ほど定義したoptionsを指定し、チャートを描けばこの函数は終わり。

chart.draw(dTable, options);

JavaScriptのコード全体を匿名函数で袋とじした。こうすることで擬似的な名前空間になり、函数名、変数名、定数名などの識別子の競合（上書きなど）を防ぐことができるはず。

(function() {
// ここにコード全体を記述
})();

このコードを基盤にすれば、データ・セットを与えればそれをチャートとして視覚化してくれるウェブ・アプリを作ることができるかもしれない。その試みはまたの機会に。

参照元：

Google Chartsの公式ページ

LibreOfficeで列と行を置き換える（転置）

2021-09-20T20:51:00.004+09:00

使用したLibreOfficeのバージョンは6.1。現時点の最新版が7.2なので少し古い。

列方向に並んでいる値を行方向に並ぶように置き換えたい。行方向に並んでいる値を列方向に並ぶように置き換えたい。この投稿では、いわゆる「行列の転置」をLibreOffice Calcで行う2つの方法について書き留めておく。

例えば次のように値がセルに入力されているとする。

	A	B	C	D
1	a	b	c	d
2	1	2	3	4
3
4
5

これを次のようにしたい。

	A	B
1	a	1
2	b	2
3	c	3
4	d	4
5

1つめの方法

まず、変換したい値全体を選んでアクティブセルにする。そしてトップメニューの「編集」などから「切り取り」または「コピー」を選ぶ。

	A	B	C	D
1	a	b	c	d
2	1	2	3	4
3
4
5

転置後の値が入るセルの範囲の一番左上端になるセルを選んでアクティブにする。

	A	B	C	D	E
1
2
3
4
5

トップメニューの「編集」などから「形式を選択して貼り付け」を選ぶ。

このバージョン(6.1.5.2)のLibreOffice Calcではこの操作でLibreOffice Calc自体が固まってしまう現象が環境によっては起こるので要注意。

「形式を選択して貼り付け」というダイアログボックスが開くのでその中の「行と列を入れ替える」というボタンを押す。

	A	B
1	a	1
2	b	2
3	c	3
4	d	4
5

2つめの方法

2つめの方法はLibreOffice Calcに組み込まれている函数を使うこと。LibreOffice CalcにもMS Excel同様に転置行列を生成してくれる函数がある。

転置後の値を入れたいセルの内で一番左上端のセルを選んでアクティブにする。
トップメニューの「挿入」などから「関数」を選んで「関数ウィザード」を表示させる。
「関数ウィザード」の「分類項目」で「行列」を選ぶ。
「TRANSPOSE」という関数を選んで「次へ」を押す。
この時点で「結果」というフォームに「エラー:511」と表示されてしまうが気にしない。
「行列」という項目の入力フォームの右側にあるボタンを押す。
転置したい値が入るセル全体を選んでアクティブにする。例えばA1からC2まで。そうしておいてEnterキーを押す。
そうすると関数ウィザードの数式のフォームに例えば「=TRANSPOSE(A1:C2)」と表示されるはず。それを確認してOKボタンを押す。

これで行列の転置が行われるはず。

LibreOffice Calcを使った行列の各種演算についてはまたの機会に。

HTML5 CanvasとJavaScriptで折線グラフを描いてみた

2021-09-15T22:01:00.038+09:00

使用した環境は次のとおり。

Chromium Version 90.0
Firefox Browser 78.13.0esr
ECMAScript 6 (2015)以降

ECMAScriptはJavaScriptの標準規格。そのバージョンの6以降または2015以降では変数の宣言にletというキーワードが導入された。定数の宣言にはconstというキーワードが導入された。ただしletは予約語ではない。この投稿で掲載するJavaScriptのコードではletとconstを用いた。

JavaScriptにおける変数の詳細についてはまた別の機会に。

HTML5 Canvasで描いた折線グラフ

日本のマクロ経済データの1つであるインフレ率を1960年から2020年まで時系列に折線グラフにしたものが次の図。

スクリプト言語JavaScriptとHTML5 Canvasの2次元用レンダリングのAPIを利用して今回はこの折線グラフを描いてみた。

HTML

HTML5 Canvasを表示するために用意しておくHTML文書の基本的内容は次のとおり。

<!DOCTYPE html>
<html>
<head>
<title>日本のインフレ率の折線グラフ</title>
</head>
<body>
<!-- canvas要素にはid属性と幅と高さを設定する -->
<canvas id="JapanInflationRateTimeSeries" width="700" height="400">
このブラウザはHTML5 CanvasかJavaScriptをサポートしていません。
</canvas>
</body>
<script>
<!-- ここにJavaScriptのコードを書く -->
</script>
</html>

ウェブ・ブラウザによってscript要素が最後に読み込まれることを期待してscript要素をbody要素の後に置くことにした。

HTML文書内にスクリプト（JavaScriptのソースコード）を直接埋め込まずに別ファイルに分離させる場合には、HTMLのscript要素のsrc属性にそのソースコードのファイル名とパス名を指定する。例えば次のように。

<script src="./script/JapanInflationRateTimeSeries.js"></script>

body要素内に置いたcanvas要素にはそのcanvas要素固有のidを付けておく必要がある。なぜならばJavaScriptからこのcanvas要素を呼び出すためにこのid属性を用いるので。

canvas要素のwidth属性にはCanvasの広さを決めるための幅の値を指定する。ここでは700とした。hight属性は高さ。ここでは400とした。描かれた図の一部がはみ出して隠れてしまわないようにその都度これらを調整する。

HTMLのhead要素内のstyle要素内にCSSを記述してcanvas要素の背景色やら余白やらを設定する方法もあるが、今回はJavaScriptのコードにそれらの設定と描画を任せてみることにした。

HTML5 CanvasのAPIが用いる座標系では左上端が原点の(0,0)となる。しかしここで描こうとするグラフの座標系は通常のデカルト座標系に基づくものなので、HTML5 Canvas APIが用いる座標系とは上下の向きが逆になる。

次にJavaScriptのソースコードの内容について説明する。

このスクリプトの設計思想とコードの全体像

このスクリプトは大規模でも複雑でもないので、その設計手法はオブジェクト指向的ではなく、C言語の古典的な流儀に近いものにした。

ただし、函数の定義の中に別の函数の定義が入っている入れ子構造はC言語の古典的な流儀とは異なるかもしれない。函数の定義の中で更に定義された入れ子の函数はクロージャと呼ばれているらしい。

ソースコードの内容は、函数外の各定数、各変数、そして複数の各函数によって構成されている。

(function() {
/* 各種定数の定義
   各種変数の宣言と値の割り当て
   各種函数の定義
   各種函数の呼び出し */
})();

コードを函数に分けることの利点は、コードの見通しがよくなるだけでなく、識別子の名前が重複して上書きされてしまったりするのを函数のブロックを名前空間として使用して防ぐことができること。

他のスクリプトとの競合を防ぐためにコード全体を匿名函数で更に袋とじにすることにした。(function(){...})();の部分がそれ。

変数の宣言にはvarキーワードの代わりにconstキーワードとletキーワードを用いることにした。これらのキーワードはECMAScript 2015 (ES6)から採用されたらしい。ただしletは予約語ではないようだ。

constで定義した変数は定数であるかのように機能し、letで宣言した変数は全てのブロック内でローカル変数として機能するようになるらしい。

constキーワードで定義される定数は厳密には定数とは異なるらしい。その詳細についてはまたの機会に。

for文とif文だけを制御構文として用いた。

残念ながら汎用性や拡張性が低いコードになっている。機会があれば修正するかもしれない。

函数外の定数を宣言

まずは函数の間を跨いで働く各種の定数を函数外で宣言した。定数の宣言にはconstキーワードを用いる。定数の宣言と同時にその値を代入する必要がある。

// 方眼紙の属性定数
const topMargin = 35; // 上余白
const leftMargin = 30; // 左余白
const verticalGridNum = 65; // 方眼紙の垂直線数
const horizontalGridNum = 30; // 方眼紙の水平線数
const gridSize = 10; // 方眼紙の線間の幅

// 座標系の原点位置を決める定数
const originX = leftMargin + (gridSize * 0); // x座標
const originY = topMargin + (gridSize * 25); // y座標

// 横軸線の始点
const xAxisSX = originX;
const xAxisSY = topMargin;
// 横軸線の終点
const xAxisLX = originX;
const xAxisLY = topMargin + (gridSize * horizontalGridNum);

// 縦軸線の始点
const yAxisSX = leftMargin;
const yAxisSY = originY;
// 縦軸線の終点
const yAxisLX = leftMargin + (gridSize * verticalGridNum);
const yAxisLY = originY;

// インフレ率の数値データ配列定数
const dataSet = [3.57,5.36,6.83,6.7,3.8,6.65,5.04,3.98,5.33,
   5.24,6.92,6.39,4.84,11.6,23.22,11.73,9.37,8.16,
   4.2,3.7,7.77,4.91,2.74,1.89,2.26,2.03,0.59,0.12,
   0.67,2.27,3.07,3.25,1.76,1.24,0.69,-0.12,0.13,
   1.74,0.66,-0.34,-0.67,-0.74,-0.92,-0.25,0,-0.28,
   0.24,0.06,1.38,-1.35,-0.71,-0.26,-0.05,0.34,2.76,
   0.78,-0.11,0.46,0.97,0.47,-0.01];

// データをプロットした座標を保管する配列定数
const plotXSet = [];
const plotYSet = [];

各定数の意味は次のとおり。

topMargin: 方眼紙の上側の余白の広さ。

leftMargin: 方眼紙の左側の余白の広さ。

verticalGridNum: 方眼紙を構成する垂直の線の数。

horizontalGridNum: 方眼紙を構成する水平の線の数。

gridSize: 方眼紙を構成する格子状の線と線の間の広さ。

originX: グラフの座標系の原点を表すx座標。

originY: グラフの座標系の原点を表すy座標。

xAxisSX: グラフの座標系の横軸（x軸）の始点を表すx座標。

xAxisSY: グラフの座標系の横軸（x軸）の始点を表すy座標。

xAxisLX: グラフの座標系の横軸（x軸）の終点を表すx座標。

xAxisLY: グラフの座標系の横軸（x軸）の終点を表すy座標。

yAxisSX: グラフの座標系の縦軸（y軸）の始点を表すx座標。

yAxisSY: グラフの座標系の縦軸（y軸）の始点を表すy座標。

yAxisLX: グラフの座標系の縦軸（y軸）の終点を表すx座標。

yAxisLY: グラフの座標系の縦軸（y軸）の終点を表すy座標。

dataSet: インフレ率の各値が時系列に並んだ配列定数。

plotXSet: インフレ率の各値をプロットした位置のx座標を入れる配列定数。

plotYSet: インフレ率の各値をプロットした位置のy座標を入れる配列定数。

函数外の変数を宣言して値を代入

プログラムの実行途上で値が変化する場合はletキーワードを使って変数として宣言した。

// 垂直方向の方眼線の始点
let verticalLineSX = leftMargin; // x座標
let verticalLineSY = topMargin; // y座標

// 垂直方向の方眼線の終点
let verticalLineLX = leftMargin; // x座標
let verticalLineLY = topMargin +
   (gridSize * horizontalGridNum); // y座標

// 水平方向の方眼線の始点
let horizontalLineSX = leftMargin; // x座標
let horizontalLineSY = topMargin; // y座標

// 水平方向の方眼線の終点
let horizontalLineLX = leftMargin +
   (gridSize * verticalGridNum); // x座標
let horizontalLineLY = topMargin; // y座標

これらをconstキーワードで定義した場合、コンソール上にエラーが表示されてしまう。

各変数の意味は次のとおり。

verticalLineSX: 垂直方向に伸びる方眼線の始点を表すx座標。

verticalLineSY: 垂直方向に伸びる方眼線の始点を表すy座標。

verticalLineLX: 垂直方向に伸びる方眼線の終点を表すx座標。

verticalLineLY: 垂直方向に伸びる方眼線の終点を表すy座標。

horizontalLineSX: 水平方向に伸びる方眼線の始点を表すx座標。

horizontalLineSY: 水平方向に伸びる方眼線の始点を表すy座標。

horizontalLineLX: 水平方向に伸びる方眼線の終点を表すx座標。

horizontalLineLY: 水平方向に伸びる方眼線の終点を表すy座標。

canvasの背景色を描く函数

canvasの背景色を白にするための函数を定義した。

/* Canvasの背景色を描画する函数 */
function drawBackgroundOfCanvas(canvasID) {
   const canvas = document.getElementById(canvasID);
   const ctx = canvas.getContext("2d");

   // canvasの背景色設定
   ctx.fillStyle = "white"; // 背景の色
   ctx.fillRect(0, 0, canvas.width, canvas.height); // 長方形
}

函数の定義はfunction 函数名(引数){ステートメント1; ステートメント2}のような構成になる。

この函数はHTMLのcanvas要素のid属性をその引数に受け取る。

この函数ブロック内の始めの2行はHTML5 Canvasの2次元のAPIを利用するときにお馴染みのステートメント。getElementByIdメソッドで特定のid属性を持つcanvas要素を取得し、getContextメソッドで2次元のCanvas APIを利用できるようにするもの。

いずれもconstキーワードを使ってオブジェクト定数のようなものにした。こうすることでctxという名前を与えたオブジェクトが提供するメソッドやプロパティを利用してcanvasに2次元の図を描けるようになった。

fillStyleプロパティには塗りつぶすときの色を指定する。ここでは白色にした。

fillRectメソッドは長方形の面を塗りつぶしてくれるもの。その引数には長方形の左上端と右下端の座標を指定する。canvasオブジェクトの座標系の原点となる0,0とcanvasオブジェクトの幅(width)と高さ(height)の座標を表すプロパティをここでは指定した。

方眼線を描く函数を定義

次に方眼線を描く函数を定義した。この函数が受け取る引数もHTMLのcanvas要素のid。

/* 方眼紙を描く函数 */
function drawGraphPaper(canvasID) {
   const canvas = document.getElementById(canvasID);
   const ctx = canvas.getContext("2d");

   // 垂直方向の方眼線を描く
   for (let i = 0; i <= verticalGridNum; i++) {
      const remainder = i % 5; // 剰余計算
      if (remainder == 1) {
          // 方眼線のパスの初期化と線の属性
          ctx.beginPath(); // パスの初期化
          ctx.lineWidth = 1; // 方眼線の太さ
          ctx.strokeStyle = "silver"; // 方眼線の色
      } else {
          // 方眼線のパスの初期化と線の属性
          ctx.beginPath(); // パスの初期化
          ctx.lineWidth = 1; // 方眼線の太さ
          ctx.strokeStyle = "lightgrey"; // 方眼線の色
      }
      ctx.moveTo(verticalLineSX, verticalLineSY); // 方眼線の始点
      ctx.lineTo(verticalLineLX, verticalLineLY); // 方眼線の終点
      ctx.stroke(); // 方眼線の描画
      // 方眼線の幅だけ始点と終点を移動
      verticalLineSX = verticalLineSX + gridSize;
      verticalLineLX = verticalLineLX + gridSize;
   }
   // 水平方向の方眼線を描く
   for (let i = 0; i <= horizontalGridNum; i++) {
      const remainder = i % 2;
      if (remainder == 1) {
          // 方眼線のパスの初期化と線の属性
          ctx.beginPath(); // パスの初期化
          ctx.lineWidth = 1; // 方眼線の太さ
          ctx.strokeStyle = "silver"; // 方眼線の色
      } else {
          // 方眼線のパスの初期化と線の属性
          ctx.beginPath(); // パスの初期化
          ctx.lineWidth = 1; // 方眼線の太さ
          ctx.strokeStyle = "lightgrey"; // 方眼線の色
      }
      ctx.moveTo(horizontalLineSX, horizontalLineSY); // 方眼線の始点
      ctx.lineTo(horizontalLineLX, horizontalLineLY); // 方眼線の終点
      ctx.stroke(); // 描画
      // 方眼線の幅だけ始点と終点を移動
      horizontalLineSY = horizontalLineSY + gridSize;
      horizontalLineLY = horizontalLineLY + gridSize;
   }
   
   // 垂直方向の方眼線の始点
   verticalLineSX = leftMargin; // x座標
   verticalLineSY = topMargin; // y座標

   // 垂直方向の方眼線の終点
   verticalLineLX = leftMargin; // x座標
   verticalLineLY = topMargin +
      (gridSize * horizontalGridNum); // y座標

   // 水平方向の方眼線の始点
   horizontalLineSX = leftMargin; // x座標
   horizontalLineSY = topMargin; // y座標

   // 水平方向の方眼線の終点
   horizontalLineLX = leftMargin +
      (gridSize * verticalGridNum); // x座標
   horizontalLineLY = topMargin; // y座標
}

函数のブロック内の始めのコードはHTML5 Canvasの2次元用のAPIを利用するためのお決まりのステートメント2行。ちなみに1行で表す記法もある。

垂直方向と水平方向の方眼線を1本ずつ描くためにそれぞれにfor文を使った。カウンター用の変数iが0からverticalGridNum（垂直方向の方眼線の総数）またはhorizontalGridNum（水平方向の方眼線の総数）に達するまで同じ処理を繰り返すようにした。

方眼線の色を一定間隔で使い分けるためにfor文のブロック内に更にif文を設けて処理を分岐させた。分岐の条件は、垂直方向の方眼線を描くfor文では5で割った余りが1に等しいかそうでないか、水平方向の方眼線を描くfor文では2で割った余りが1に等しいかそうでないか。

beginPathメソッドはパスの初期化のためのもの。パスとは線や面をどこにどのように描くかを決める属性値の総称のようなもの。lineWidthプロパティは線の太さ。strokeStyleプロパティは線の色を決める。

moveToメソッドで線の始点となる座標を指定し、lineToメソッドで線の終点となる座標を指定し、strokeメソッドで線を描く。垂直方向の方眼線の始点と終点を決める各々の座標、水平方向の方眼線の始点と終点を決める各々の座標が入っている各変数を、これらのメソッドの引数として指定した。

このようにして方眼線を描くコードが完成。

最後に方眼線の座標を決める各変数の値を初期値に戻す必要があったので、for文のブロックから脱け出た後にそのためのコードが記述してある。

ここまでのコードを仮に実行した場合の結果は次のとおり。

方眼線が微妙に色分けされていることが分かるはず。

座標系の横軸と縦軸を描く函数を定義

次の函数はグラフの座標系の原点を通る横軸（x軸）と縦軸（y軸）を描くためのもの。この函数もその引数にHTMLのcanvas要素のidを受け取る。

/* 座標系の縦軸と横軸を描く函数 */
function drawAxis(canvasID) {
   const canvas = document.getElementById(canvasID);
   const ctx = canvas.getContext("2d");

   // パスの初期化と軸線の属性
   ctx.beginPath(); // パスの初期化
   ctx.lineWidth = 1; // 方眼線の太さ
   ctx.strokeStyle = "black"; // 方眼線の色

   // 横軸線と縦軸線のパス
   ctx.moveTo(xAxisSX, xAxisSY); // 横軸開始位置
   ctx.lineTo(xAxisLX, xAxisLY); // 横軸終了位置
   ctx.moveTo(yAxisSX, yAxisSY); // 縦軸開始位置
   ctx.lineTo(yAxisLX, yAxisLY); // 縦軸終了位置
   ctx.stroke(); // 縦軸線と横軸線の描画
}

moveToメソッドとlineToメソッドの引数には、縦軸と横軸の各々の始点と終点を表す座標が定義されている定数を指定した。

ここまでのコードを仮に実行した場合の結果は次のとおり。

座標系の横軸と縦軸の目盛りを割り振る函数を定義

座標系の横軸と縦軸に方眼線と一致するように目盛りを割り振る函数が次のコード。この函数もHTMLのcanvas要素のidをその引数として受け取る。

/* 横軸と縦軸の目盛項目を書き込む函数 */
function drawScaleItems(canvasID) {
   const canvas = document.getElementById(canvasID);
   const ctx = canvas.getContext("2d");

   // 横軸線の項目（年）が入った配列データの作成
   const scaleX = []; // 定数を配列として定義
   let year = 1960; // 開始年を格納
   const finalCount = 2020 - 1960; // 回数の計算
   for (let i = 0; i <= finalCount; i++) {
      scaleX[i] = year; // 1960から順に配列に格納
      year = year + 1; // 変数yearに1を加える
   }

   // 横軸線の項目を描画する
   ctx.font = "12px sans-serif"; // フォント
   ctx.textBaseline = "middle"; // 文字の垂直位置
   ctx.fillStyle = "black"; // 文字の色
   ctx.direction = "ltr"; // 文字列の向き
   ctx.textAlign = "center"; // 文字の水平位置
   for (let i = 0; i < scaleX.length; i++) {
      // 変数iに1を加えることでx軸を1升右へ移動
      let x = leftMargin + (gridSize * (i + 1));
      let y = verticalLineLY + 10;
      ctx.fillText(scaleX[i], x, y); // 文字列の描画
      i = i + 4; // 配列番号を4つずつ跳ばして描くため
   }

   // 座標系の原点から上方向への方眼線数
   const positiveScaleCount = (originY - topMargin) / gridSize;
   // 座標系の原点から下方向への方眼線数
   const negativeScaleCount = horizontalGridNum - positiveScaleCount;

   // 縦軸線の項目を描画する
   ctx.textAlign = "right"; // 文字の水平位置
   for (let i = 0; i < positiveScaleCount; i++) {
      const x = originX - 5;
      const y = originY - (gridSize * i);
      ctx.fillText(i, x, y); // 正数の描画
      i = i + 1; // 偶数だけ描画するため
   }
   for (let i = 2; i < negativeScaleCount; i++) {
      const x = originX - 5;
      const y = originY + (gridSize * i);
      ctx.fillText(-1 * i, x, y); // 負数の描画
      i = i + 1; // 偶数だけ描画するため
   }
}

このコードで使った配列、定数、変数は次のとおり。

scaleX[]: 年を順番に保存しておく配列定数。

year: 年を保存しておく変数。初期値として1960を代入。

finalCount: 1960から2020までを配列に入れるために処理を何回繰り返す必要があるかを計算してその結果を入れる定数。

positiveScaleCount: 縦軸の正の目盛り（方眼紙の升目）がいくつあるかを計算して入れておく定数。

negativeScaleCount: 縦軸の負の目盛り（方眼紙の升目）がいくつあるかを計算して入れておく定数。

この折れ線グラフではその横軸の目盛りとして1960から2020までの年単位を時系列として取るので、この函数ブロック内の最初のfor文で1960から2020までの数を生成して配列定数として定義した。

そして文字に関する様々なプロパティに値を代入して文字の属性を指定しているのがその次のコード。

fontプロパティにはフォントの属性を指定する。12pxはフォントのサイズが12ピクセルということ。sans-serifはフォント・ファミリー名。

textBaselineプロパティは文字列の垂直方向の配置。ここでは中間(middle)とした。fillStyleプロパティは文字を塗りつぶす色。directionプロパティは文字列の向き。ここでは左から右へ書くことを表すltrと指定した。rtlと指定すれば右から左へ書くことを意味する。textAlignプロパティは水平方向の文字列の配置。ここでは中央(center)とした。

for文とfillTextメソッドを使って文字列を描画するコードがそれに続く。

for文の引数にあるscaleX.lengthはscaleXという配列の要素数を知ることができるプロパティ。ここでは配列の長さと同じ値になるまでfor文を繰り返すための条件式（比較演算）にこのプロパティを用いた。

positiveScaleCountとnegativeScaleCountという変数には正の目盛りの数と負の目盛りの数を計算して定義した。これらの定数を条件にして正方向（上方向）と負方向（下方向）の目盛りをfor文を用いてそれぞれ描くコードがこの函数の後半部分。

縦軸（y軸）の目盛りは、textAlignプロパティをrightに設定して文字列を右揃えにした。そして方眼紙の色分けに合わせて偶数だけを表示させるようにした。

ここまでのコードを仮に実行した場合の結果が次のとおり。

方眼線の色分けと目盛りの文字の位置が一致するように配置できているはず。

グラフの表題を書き込む函数を定義

次の函数はグラフの上に表題、グラフの下に参照元や説明のための文字列を書き込むもの。この函数もその引数にHTMLのcanvas要素のidを受け取る。

/* グラフに文字列を書き込む函数 */
function writeString(canvasID) {
   const canvas = document.getElementById(canvasID);
   const ctx = canvas.getContext("2d");

   // グラフの表題
   ctx.font = "bold 15px sans-serif"; // フォント
   ctx.textAlign = "start"; // 文字の水平位置
   ctx.textBaseline = "middle"; // 文字の垂直位置
   ctx.fillStyle = "black"; // 文字の色
   ctx.direction = "ltr"; // 文字列の向き
   ctx.fillText("図1 日本のインフレ率の時系列 1960-2020 (横軸 : 年, 縦軸 : %)",
      leftMargin + 0, verticalLineSY - 15); // 文字列の描画

   // グラフの参照元を記す文字列
   ctx.font = "italic 12px sans-serif"; // フォント
   ctx.fillText("参照元 : ",
      leftMargin + 0, verticalLineLY + 40); // 文字列の描画
}

fontプロパティのboldは太字、italicはイタリック体。textAlignプロパティのstartは書き始めの位置へ文字列を寄せること。

fillTextメソッドの引数は左から、表示する文字列、x座標、y座標、文字列表示の最大許容幅。最後の引数は省略可能なのでこのコードでは省略してある。

ここまでのコードを仮に実行したとすると次のようになるはず。

データを座標系にプロットする函数を定義

次のコードはインフレ率の数値データを座標系にプロットする函数。この函数もHTMLのcanvas要素のidをその引数に取る。

/* データを座標系にプロットする函数 */
function plotData(canvasID) {
   const canvas = document.getElementById(canvasID);
   const ctx = canvas.getContext("2d");

   // インフレ率のデータを座標上にプロットする
   for (let i = 0; i < dataSet.length; i++) {
      // プロットする位置を示す座標を入れる変数
      let plotX;
      let plotY;
      plotX = originX + (gridSize * (i + 1));
      // Canvasの座標系はy軸が逆向きなので-1を掛けて正負を反転
      plotY = originY + (-1 * gridSize * dataSet[i]);

      // プロットしたデータの座標を配列定数に記録
      plotXSet[i] = plotX;
      plotYSet[i] = plotY;

      // パスの設定と描画
      ctx.beginPath(); // パスを初期化    
      ctx.arc(plotX, plotY, 1.5,
         (Math.PI/180)*0, (Math.PI/180)*360); // 円のパス
      ctx.closePath(); // パスを閉じる
      ctx.fillStyle = "blue"; // 点の色
      ctx.fill(); // 点を塗りつぶす
   }
}

配列定数にしたインフレ率のデータを順番に取り出して座標系にプロットするためにfor文を用いた。

for文のブロック中では、x座標とy座標を計算して入れる変数plotXとplotYを設けた。y座標はHTML5 Canvasの座標系とこのグラフで用いる座標系では逆向きになるため、-1を掛けて符号を反転させることでその問題に対処した。

函数の外であらかじめ宣言しておいた配列定数であるplotXSetとplotYSetに、プロットした各点の座標を順番に入れて保存した。この配列定数は函数外で定義しておいたグローバル定数なので、折線グラフを描くために定義したこの次の函数で利用することができる。

beginPathメソッドでパスを初期化し、arcメソッドでしかるべき座標に点を描画する指示をしてfillメソッドで塗りつぶすようにした。

closePathメソッドはパスを閉じるためのもの。円弧を描くarcメソッドを用いて円を描くので円弧を閉じる必要があり、そのためにarcメソッドの後にclosePathメソッドを用いた。

インフレ率のデータをプロットした結果は次のようになるはず。

プロットした点を繋いで折線グラフを描く函数を定義

インフレ率のデータをプロットした点を線で結び折線グラフを作る函数のコードは次のとおり。この函数もHTMLのcanvas要素のidをその引数に取る。

/* 折線グラフを描く函数 */
function drawLineGraph(canvasID) {
   const canvas = document.getElementById(canvasID);
   const ctx = canvas.getContext("2d");

   // プロットした点を折線で結ぶ
   for (let i = 0; i < plotXSet.length; i++) {
      ctx.beginPath(); // パスを初期化
      ctx.moveTo(plotXSet[i], plotYSet[i]); // 折線の始点
      ctx.lineTo(plotXSet[i + 1], plotYSet[i + 1]); // 折線の終点
      ctx.strokeStyle = "red"; // 折線の色
      ctx.stroke(); // 折線の描画
   }
}

プロットした各点の座標を保存しておいたplotXSetとplotYSetという配列を利用し、for文の中でmoveToメソッドとlineToメソッドとstrokeメソッドを使って各点を繋ぐと折れ線グラフが完成する。

for文では配列定数の要素数を示すlengthプロパティをその条件式の比較演算で用いた。

strokeStyleプロパティに赤色を指定することで折れ線の色を赤にした。

ここまでのコードを仮に実行した場合の結果は次のとおり。

函数を呼び出すステートメント

これまでは各々の函数の定義をしただけなのでそれを呼び出して実行するコードが必要。

// 各函数を呼び出す
let canvasID = "JapanInflationRateTimeSeries";

// 各函数を呼び出す
drawBackgroundOfCanvas(canvasID)
drawGraphPaper(canvasID);
drawAxis(canvasID);
drawScaleItems(canvasID);
writeString(canvasID);
plotData(canvasID);
drawLineGraph(canvasID);

函数を呼び出すステートメントを記述した順番に各函数は実行される。

スクリプト全体を匿名函数で袋とじ

これまでのコードを全てまとめると次のようになる。その際、このスクリプト全体を匿名函数によって袋とじにした。こうしておけばこのスクリプトの影響が外部に副作用として及ばないはず。

<script>
// このスクリプト全体を匿名函数で袋とじ
(function() {

   // 方眼紙の属性定数
   const topMargin = 35; // 上余白
   const leftMargin = 30; // 左余白
   const verticalGridNum = 65; // 方眼紙の垂直線数
   const horizontalGridNum = 30; // 方眼紙の水平線数
   const gridSize = 10; // 方眼紙の線間の幅
   
   // 座標系の原点位置を決める定数
   const originX = leftMargin + (gridSize * 0); // x座標
   const originY = topMargin + (gridSize * 25); // y座標
   
   // 横軸線の始点
   const xAxisSX = originX;
   const xAxisSY = topMargin;
   // 横軸線の終点
   const xAxisLX = originX;
   const xAxisLY = topMargin + (gridSize * horizontalGridNum);
   
   // 縦軸線の始点
   const yAxisSX = leftMargin;
   const yAxisSY = originY;
   // 縦軸線の終点
   const yAxisLX = leftMargin + (gridSize * verticalGridNum);
   const yAxisLY = originY;
   
   // インフレ率の数値データ配列定数
   const dataSet = [3.57,5.36,6.83,6.7,3.8,6.65,5.04,3.98,5.33,
      5.24,6.92,6.39,4.84,11.6,23.22,11.73,9.37,8.16,
      4.2,3.7,7.77,4.91,2.74,1.89,2.26,2.03,0.59,0.12,
      0.67,2.27,3.07,3.25,1.76,1.24,0.69,-0.12,0.13,
      1.74,0.66,-0.34,-0.67,-0.74,-0.92,-0.25,0,-0.28,
      0.24,0.06,1.38,-1.35,-0.71,-0.26,-0.05,0.34,2.76,
      0.78,-0.11,0.46,0.97,0.47,-0.01];

   // データをプロットした座標を保管する配列定数
   const plotXSet = [];
   const plotYSet = [];
   
   // 垂直方向の方眼線の始点
   let verticalLineSX = leftMargin; // x座標
   let verticalLineSY = topMargin; // y座標
   
   // 垂直方向の方眼線の終点
   let verticalLineLX = leftMargin; // x座標
   let verticalLineLY = topMargin +
      (gridSize * horizontalGridNum); // y座標
   
   // 水平方向の方眼線の始点
   let horizontalLineSX = leftMargin; // x座標
   let horizontalLineSY = topMargin; // y座標
   
   // 水平方向の方眼線の終点
   let horizontalLineLX = leftMargin +
      (gridSize * verticalGridNum); // x座標
   let horizontalLineLY = topMargin; // y座標

   /* Canvasの背景色を描画する函数 */
   function drawBackgroundOfCanvas(canvasID) {
      const canvas = document.getElementById(canvasID);
      const ctx = canvas.getContext("2d");

      // canvasの背景色設定
      ctx.fillStyle = "white"; // 背景の色
      ctx.fillRect(0, 0, canvas.width, canvas.height); // 長方形
   }
   
   /* 方眼紙を描く函数 */
   function drawGraphPaper(canvasID) {
      const canvas = document.getElementById(canvasID);
      const ctx = canvas.getContext("2d");
   
      // 垂直方向の方眼線を描く
      for (let i = 0; i <= verticalGridNum; i++) {
         const remainder = i % 5; // 剰余計算
         if (remainder == 1) {
             // 方眼線のパスの初期化と線の属性
             ctx.beginPath(); // パスの初期化
             ctx.lineWidth = 1; // 方眼線の太さ
             ctx.strokeStyle = "silver"; // 方眼線の色
         } else {
             // 方眼線のパスの初期化と線の属性
             ctx.beginPath(); // パスの初期化
             ctx.lineWidth = 1; // 方眼線の太さ
             ctx.strokeStyle = "lightgrey"; // 方眼線の色
         }
         ctx.moveTo(verticalLineSX, verticalLineSY); // 方眼線の始点
         ctx.lineTo(verticalLineLX, verticalLineLY); // 方眼線の終点
         ctx.stroke(); // 方眼線の描画
         // 方眼線の幅だけ始点と終点を移動
         verticalLineSX = verticalLineSX + gridSize;
         verticalLineLX = verticalLineLX + gridSize;
      }
      // 水平方向の方眼線を描く
      for (let i = 0; i <= horizontalGridNum; i++) {
         const remainder = i % 2;
         if (remainder == 1) {
             // 方眼線のパスの初期化と線の属性
             ctx.beginPath(); // パスの初期化
             ctx.lineWidth = 1; // 方眼線の太さ
             ctx.strokeStyle = "silver"; // 方眼線の色
         } else {
             // 方眼線のパスの初期化と線の属性
             ctx.beginPath(); // パスの初期化
             ctx.lineWidth = 1; // 方眼線の太さ
             ctx.strokeStyle = "lightgrey"; // 方眼線の色
         }
         ctx.moveTo(horizontalLineSX, horizontalLineSY); // 方眼線の始点
         ctx.lineTo(horizontalLineLX, horizontalLineLY); // 方眼線の終点
         ctx.stroke(); // 描画
         // 方眼線の幅だけ始点と終点を移動
         horizontalLineSY = horizontalLineSY + gridSize;
         horizontalLineLY = horizontalLineLY + gridSize;
      }
      
      // 垂直方向の方眼線の始点
      verticalLineSX = leftMargin; // x座標
      verticalLineSY = topMargin; // y座標
   
      // 垂直方向の方眼線の終点
      verticalLineLX = leftMargin; // x座標
      verticalLineLY = topMargin +
         (gridSize * horizontalGridNum); // y座標
   
      // 水平方向の方眼線の始点
      horizontalLineSX = leftMargin; // x座標
      horizontalLineSY = topMargin; // y座標
   
      // 水平方向の方眼線の終点
      horizontalLineLX = leftMargin +
         (gridSize * verticalGridNum); // x座標
      horizontalLineLY = topMargin; // y座標
   }
   
   /* 座標系の縦軸と横軸を描く函数 */
   function drawAxis(canvasID) {
      const canvas = document.getElementById(canvasID);
      const ctx = canvas.getContext("2d");
   
      // パスの初期化と軸線の属性
      ctx.beginPath(); // パスの初期化
      ctx.lineWidth = 1; // 方眼線の太さ
      ctx.strokeStyle = "black"; // 方眼線の色
   
      // 横軸線と縦軸線のパス
      ctx.moveTo(xAxisSX, xAxisSY); // 横軸開始位置
      ctx.lineTo(xAxisLX, xAxisLY); // 横軸終了位置
      ctx.moveTo(yAxisSX, yAxisSY); // 縦軸開始位置
      ctx.lineTo(yAxisLX, yAxisLY); // 縦軸終了位置
      ctx.stroke(); // 縦軸線と横軸線の描画
   }
   
   /* x軸とy軸の目盛項目を書き込む函数 */
   function drawScaleItems(canvasID) {
      const canvas = document.getElementById(canvasID);
      const ctx = canvas.getContext("2d");
   
      // 横軸線の項目（年）が入った配列データの作成
      const scaleX = []; // 定数を配列として定義
      let year = 1960; // 開始年を格納
      const finalCount = 2020 - 1960; // 回数の計算
      for (let i = 0; i <= finalCount; i++) {
         scaleX[i] = year; // 1960から順に配列に格納
         year = year + 1; // 変数yearに1を加える
      }
   
      // 横軸線の項目を描画する
      ctx.font = "12px sans-serif"; // フォント
      ctx.textBaseline = "middle"; // 文字の垂直位置
      ctx.fillStyle = "black"; // 文字の色
      ctx.direction = "ltr"; // 文字列の向き
      ctx.textAlign = "center"; // 文字の水平位置
      for (let i = 0; i < scaleX.length; i++) {
         // 変数iに1を加えることでx軸を1升右へ移動
         let x = leftMargin + (gridSize * (i + 1));
         let y = verticalLineLY + 10;
         ctx.fillText(scaleX[i], x, y); // 文字列の描画
         i = i + 4; // 配列番号を4つずつ跳ばして描くため
      }
   
      // 座標系の原点から上方向への方眼線数
      const positiveScaleCount = (originY - topMargin) / gridSize;
      // 座標系の原点から下方向への方眼線数
      const negativeScaleCount = horizontalGridNum - positiveScaleCount;
   
      // 縦軸線の項目を描画する
      ctx.textAlign = "right"; // 文字の水平位置
      for (let i = 0; i < positiveScaleCount; i++) {
         const x = originX - 5;
         const y = originY - (gridSize * i);
         ctx.fillText(i, x, y); // 正数の描画
         i = i + 1; // 偶数だけ描画するため
      }
      for (let i = 2; i < negativeScaleCount; i++) {
         const x = originX - 5;
         const y = originY + (gridSize * i);
         ctx.fillText(-1 * i, x, y); // 負数の描画
         i = i + 1; // 偶数だけ描画するため
      }
   }
   
   /* グラフに文字列を書き込む函数 */
   function writeString(canvasID) {
      const canvas = document.getElementById(canvasID);
      const ctx = canvas.getContext("2d");
   
      // グラフの表題
      ctx.font = "bold 15px sans-serif"; // フォント
      ctx.textAlign = "start"; // 文字の水平位置
      ctx.textBaseline = "middle"; // 文字の垂直位置
      ctx.fillStyle = "black"; // 文字の色
      ctx.direction = "ltr"; // 文字列の向き
      ctx.fillText("図1 日本のインフレ率の時系列 1960-2020 (横軸 : 年, 縦軸 : %)",
         leftMargin + 0, verticalLineSY - 15); // 文字列の描画
   
      // グラフの参照元を記す文字列
      ctx.font = "italic 12px sans-serif"; // フォント
      ctx.fillText("参照元：",
         leftMargin + 0, verticalLineLY + 40); // 文字列の描画
   }
   
   /* データを座標系に描画する函数 */
   function plotData(canvasID) {
      const canvas = document.getElementById(canvasID);
      const ctx = canvas.getContext("2d");
   
      // インフレ率のデータを座標上にプロットする
      for (let i = 0; i < dataSet.length; i++) {
         // プロットする位置を示す座標を入れる変数
         let plotX = originX + (gridSize * (i + 1));
         // Canvasの座標系はy軸が逆向きなので-1を掛けて正負を反転
         let plotY = originY + (-1 * gridSize * dataSet[i]);
   
         // プロットしたデータの座標を配列定数に記録
         plotXSet[i] = plotX;
         plotYSet[i] = plotY;
   
         // パスの設定と描画
         ctx.beginPath(); // パスを初期化    
         ctx.arc(plotX, plotY, 1.5,
            (Math.PI/180)*0, (Math.PI/180)*360); // 円のパス
         ctx.closePath(); // パスを閉じる
         ctx.fillStyle = "blue"; // 点の色
         ctx.fill(); // 点を塗りつぶす
      }
   }
   
   /* 折線グラフを描く函数 */
   function drawLineGraph(canvasID) {
      const canvas = document.getElementById(canvasID);
      const ctx = canvas.getContext("2d");
   
      // プロットした点を折線で結ぶ
      for (let i = 0; i < plotXSet.length; i++) {
         ctx.beginPath(); // パスを初期化
         ctx.moveTo(plotXSet[i], plotYSet[i]); // 折線の始点
         ctx.lineTo(plotXSet[i + 1], plotYSet[i + 1]); // 折線の終点
         ctx.strokeStyle = "red"; // 折線の色
         ctx.stroke(); // 折線の描画
      }
   }

   // 各函数を呼び出す
   let canvasID = "JapanInflationRateTimeSeries";

   drawBackgroundOfCanvas(canvasID)
   drawGraphPaper(canvasID);
   drawAxis(canvasID);
   drawScaleItems(canvasID);
   writeString(canvasID);
   plotData(canvasID);
   drawLineGraph(canvasID);

})(); // 袋とじ用の匿名函数の終わり
</script>

このスクリプトには異なるデータセットに対応できるような汎用性や拡張性がまだ考慮されていない。少しずつ改良して汎用性のあるものにしていきたい。例えばJSON形式のデータを受け取ってそれを折線グラフに表現するように最終的にはしたい。

データの視覚化を行うJavaScriptのライブラリはすでに数多くあるので、そちらを利用する方法についてはまたの機会に。

指数表記、科学的記数法、工学的記数法、浮動小数点数

2021-08-24T21:33:00.002+09:00

科学雑誌や理系の教科書やコンピュータ・プログラミングの書物で次のような数値表記を目にすることがよくある。

\[ 5.972 \times 10^{24} \] \[ 6.62607015 \times 10^{−34} \] \[ 6.02214076 \times 10^{23} \]

これらは日本語では指数しすう表記という名前で知られている。英語ではscientific notation（科学的記数法）やstandard index form（標準指数形）と呼ばれている。

指数表記では0以外の数値を次のように10の累乗を掛けた式にして表す。

\[ m \times 10^n \]

以下、mを仮数部、10を基数部、nを指数部と呼ぶことにする。

コンピュータ科学の分野ではEまたはeを使って指数部を表記する。

\[ mEn \] \[ men \]

指数表記を通常の記数法へ変換

指数表記を通常の記数法に変換する方法はその指数部が正の数か負の数かで異なる。

指数部が正の数である場合、仮数部（かけられる数）の小数点を指数部の数だけ右へ移動させる。そして空白の桁には0を与える。例えば次のように。

\[ 4.9 \times 10^6 = 4900000.0 = 4900000 \]

4.9の小数点を右へ6桁移動させると0の桁が5つ加わって4900000になる。これで変換完了。

指数部が負の数である場合、仮数部の小数点を指数部の数だけ左へ移動させる。そして空白の桁には0を与える。例えば次のように。

\[ 4.9 \times 10^{-6} = 0.0000049 \]

4.9の小数点を左へ6桁移動させると$ \dfrac{1}{1000000} $になって0.0000049になる。これで変換完了。

指数表記へ変換

通常の記数法で表されている数値を指数表記に変換するには次のようにする。

ここでは203000000を例に挙げる。

小数点を最大桁の右隣りまで左へ移動させる。 \[ 203000000 \Rightarrow 2.03000000 \]
その小数点から右に何桁あるか数える。この例では8桁。指数部が8と決まる。
有効数字（この例では2.03）を残して残りの0の桁を削除。 \[ 2.03000000 \Rightarrow 2.03 \] これで仮数部が決まる。
最後に仮数部と基数部と指数部とを組み合わせて式にすれば指数表記への変換が完了。 \[ 203000000 = 2.03 \times 10^8 \]

ここで言うところの有効数字とは、0以外の数がある桁とそれらに挟まれた0の桁を残してそれ以外の0の桁を省いた数のこと。7036000なら7036が有効数字、0.030052なら30052が有効数字。

小数の場合は次のように変換する。ここでは0.0000683を例に挙げる。

小数点より左の0を取り除く。 \[ 0.0000683 \Rightarrow .0000683 \]
小数点を有効数字の中で最大の桁の右隣りまで移動させる。 \[ .0000683 \Rightarrow 00006.83 \]
0の桁を含めて小数点よりも左に何桁あるかを数える。この例では5桁あることが分かる。
5に-1を掛けて-5にすると、この-5が指数部の値になる。
有効数字以外の左側の0の桁をすべて取り除く。この値が仮数部になる。 \[ 00006.83 \Rightarrow 6.83 \]
最後に仮数部と基数部と指数部とを組み合わせる。これで指数表記への変換が完了。 \[ 0.0000683 = 6.83 \times 10^{-5} \]

計算機（電卓やコンピュータ）での指数表記

主要な電卓や主要なコンピュータ・プログラミング言語での指数表記では、10の累乗を掛ける代わりにEもしくはeが用いられていることが多い。

\[ mEn \]

例えば次の表記は等式で並べられたもの同士がそれぞれ等しい数を表している。

4900000 = 4.9 * 10^6 = 4.9E6 = 4.9e6 = 4.9e+6 = 4.9e+06
0.0000049 = 4.9 * 10^-6 = 4.9E-6 = 4.9e-6 = 4.9e-06
203000000 = 2.03 * 10^8 = 2.03E8 = 2.03e8 = 2.03e+8 = 2.03e+08
0.0000683 = 6.83 * 10^-5 = 6.83E-5 = 6.83e-5 = 6.83e-05

プログラミング言語の種類によってはこれらと異なる表記法が使われている。

工学的記数法

指数表記の指数部を3の倍数で表す工学的記数法というものがある。英語ではengineering notationとかengineering formと呼ばれているらしい。

指数部が3の倍数となる累乗は単位名称によく使われる接頭辞に次のように対応している。

$ m \times 10^3 $	mE3	キロ (k)
$ m \times 10^6 $	mE6	メガ (M)
$ m \times 10^9 $	mE9	ギガ (G)
$ m \times 10^{12} $	mE12	テラ (T)
$ m \times 10^{15} $	mE15	ペタ (P)

浮動小数点数

計算機で用いられ、プログラミング言語でもお馴染みの浮動小数点数は、指数表記と同じ構造を持っている。

\[ S \times B^e \]

Sの部分は日本語で仮数部、英語ではsignificandと呼ばれ、Bの部分は日本語で基数部、英語ではbaseと呼ばれ、eは日本語で指数部、英語ではexponentと呼ばれている。

ちなみに浮動小数点数は英語ではa floating-point numberと呼ばれている。

浮動小数点数は計算機内ではバイナリーナンバー、つまり2進数として扱われる。2進数の場合、基数部が10ではなく2になり、仮数部と指数部のすべての桁が0か1になる。

行列式、ラプラス展開、逆行列、行列の割り算

2021-07-18T06:40:00.017+09:00

この投稿では行列の除法じょほうとそのために前提となるいくつかの予備知識について記した。ただし行列同士の非可換かかん的な乗法についての基礎知識があることを前提にしている。非可換というのは交換法則が成り立たないこと。

逆数

分数の割り算では後者の分数の分母と分子をひっくり返して掛け算をすることがよく知られている。

\[ \dfrac{a}{b} \div \dfrac{\colorbox{yellow}{c}}{\colorbox{cyan}{d}} = \dfrac{a}{b} \cdot \dfrac{\colorbox{cyan}{d}}{\colorbox{yellow}{c}} = \dfrac{ad}{bc} \]

分子と分母をひっくり返した分数は元の分数の逆数ぎゃくすうと呼ばれている。英語で逆数はthe multiplicative inverseと呼ばれている。

例えば6の逆数は6分の1となる。

\[ 6 = \dfrac{6}{1} \rightarrow \dfrac{1}{6} \]

ある数をaとし、その逆数をxとすると、aとxを掛け算すると1になるという関係が成り立つ。

\[ ax = xa = 1 \]

$ x $を未知の逆数としてこの方程式を解くとa分の1が得られる。そのために両辺をaで割っている。

\[ \begin{align} ax &= 1 \\ \dfrac{\cancel{a}x}{\cancel{a}} &= \dfrac{1}{a} \\ x &= \dfrac{1}{a} \end{align} \]

aとその逆数であるa分の1とを掛け算すると、その答えは1になることが分かる。

\[ a \cdot \dfrac{1}{a} = \dfrac{a}{1} \cdot \dfrac{1}{a} = \dfrac{a \cdot 1}{1 \cdot a} = \dfrac{a}{a} = 1 \]

例えば次のように。

\[ 3 \cdot \dfrac{1}{3} = \dfrac{3 \cdot 1}{1 \cdot 3} = \dfrac{3}{3} = 1 \] \[ 1.5 \cdot \dfrac{10}{15} = \dfrac{15 \cdot 10}{10 \cdot 15} = \dfrac{150}{150} = 1 \] \[ \dfrac{2}{5} \cdot \dfrac{5}{2} = \dfrac{2 \cdot 5}{5 \cdot 2} = \dfrac{10}{10} = 1 \] \[ \dfrac{5}{7} \cdot \dfrac{7}{5} = \dfrac{5 \cdot 7}{7 \cdot 5} = \dfrac{35}{35} = 1 \]

単位行列

次のような行列は単位たんい行列と呼ばれている。説明するよりもぱっと見たほうが分かりやすい。

\[ \begin{align} I_2 &= \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} \\\\ I_3 &= \begin{pmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix} \\\\ I_4 &= \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{pmatrix} \end{align} \]

行列の左上端から右下端へと対角線上に1が並び、それ以外は0によって満たされていることが見て取れる。これらが単位行列。単位行列は対角行列の一種。

$ I $の右下添字は行列の成分である1の数に対応している。$ I_2 $は2次の単位行列、$ I_3 $は3次の単位行列、$ I_4 $は4次の単位行列。$ I $は単位行列のことを英語でan identity matrixと呼ぶので、その頭文字。日本では$ I_n $ではなく$ E_n $と書かれていることもある。

単位行列はその名のとおり単位元たんいげんの行列バージョン。単位行列は行列同士の掛け算において単位元として機能する。

単位元とは、ある演算の中で値をいつも変化させることがない数のこと。例えば実数の掛け算では1がそれに当たる。1にどんな実数のrを掛けても、どんな実数のrに1を掛けても、rの値は変わらない。

例えば$ f(x) = x \times 1 $のような函数かんすうを考えてみる。この函数が出力する値は入力する値に等しく、いつも$ x $になる。その意味で中立元ちゅうりつげんや英語のように同一元どういつげんと呼んでもいい。

\[ \begin{align} x \cdot 1 &= x \\ 1 \cdot x &= x \end{align} \]

行列の掛け算では単位行列が単位元の役割を果たしている。

\[ \begin{pmatrix} a & b \\ c & d \end{pmatrix} \cdot \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} = \begin{pmatrix} a & b \\ c & d \end{pmatrix} \] \[ \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} \cdot \begin{pmatrix} a & b \\ c & d \end{pmatrix} = \begin{pmatrix} a & b \\ c & d \end{pmatrix} \]

この性質は2次に限らず、n次の正方せいほう行列とそれと同じn次の単位行列の間でも成り立つ。行の数mと列の数nが等しい行列、つまり（$ m = n $）行列は正方行列と呼ばれている。

$ A_n $はn次の正方行列、$ I_n $はn次の単位行列。

\[ \begin{align} A_n \cdot I_n = A_n I_n &= A_n \\ I_n \cdot A_n = I_n A_n &= A_n \end{align} \]

ただし、行列の掛け算で重要な点は交換法則が通常成り立たないこと。この性質は非可換かかん性と呼ばれている。AとBが共に行列だとし、その非可換性を式で表すと次のようになる。

\[ A \cdot B \neq B \cdot A \] \[ A \cdot B \neq B \cdot A \] \[ AB \neq BA \]

逆行列

行列の割り算も分数の割り算のときに逆数を掛けることと同様の方法でその答えを求めることができる。

行列の逆数とは何か。それが逆ぎゃく行列というもの。英語では逆行列の一様な呼び方がない。「逆の」を意味する形容詞のinverseを使ってthe inverse of a matrixと呼ばれていたりa matrix inverseやa matrix inversionと呼ばれていたりする。

逆行列は逆数と共に逆元ぎゃくげんとして一般化できるもの。逆元は英語でan inverse element。

$ A_n $をn次の正方せいほう行列、$ I_n $をn次の単位行列としたとき、次のような関係が成り立てば$ X $は$ A $の逆行列。正方行列とは列数と行数とが等しい行列のこと。

\[ \begin{align} A_n &= \begin{pmatrix} a_{11} & a_{12} & a_{13} & \cdots & a_{1n} \\ a_{21} & a_{22} & a_{23} & \cdots & a_{2n} \\ a_{31} & a_{32} & a_{33} & \cdots & a_{3n} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ a_{n1} & a_{n2} & a_{n3} & \cdots & a_{nn} \end{pmatrix} \\\\ I_n &= \begin{pmatrix} 1 & 0 & 0 & \cdots & 0 \\ 0 & 1 & 0 & \cdots & 0 \\ 0 & 0 & 1 & \cdots & 0 \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 0 & 0 & 0 & \cdots & 1 \end{pmatrix} \end{align} \]

\[ \begin{align} A_n \cdot X = A_n X &= I_n \\ X \cdot A_n = X A_n &= I_n \end{align} \]

このことは実数の掛け算においてaとその逆数xと掛け算の単位元である1との関係と同じ。

\[ ax = xa = 1 \]

逆行列は負の指数しすうを使って$ A^{-1} $と表されることがある。これは$ \dfrac{1}{a} = a^{-1} $と表すことに倣ならっている。

\[ \begin{align} a^{-0} &= \dfrac{1}{a^0} = \dfrac{1}{1} \\ a^{-1} &= \dfrac{1}{a^1} = \dfrac{1}{a} \\ a^{-2} &= \dfrac{1}{a^2} \\ a^{-3} &= \dfrac{1}{a^3} \\ & \vdots & \\ a^{-n} &= \dfrac{1}{a^n} \end{align} \]

この$ A^{-1} $を先程の関係式のXに代入すると次の式が得られる。

\[ \begin{align} A \cdot A^{-1} = A A^{-1} &= I \\ A^{-1} \cdot A = A^{^1} A &= I \end{align} \]

これは正方行列にその逆行列を掛けると単位行列が得られることを示している。しかもこの場合にかぎって交換法則が成り立つ。

行列式

行列式ぎょうれつしきは正方行列を実数や複素数ふくそすうなどのスカラーに変換するもの。スカラーとは行列と区別される単独の実数や複素数のこと。

n次の正方行列を入力すると、ある決まった実数や複素数を出力するような函数かんすうとして行列式を考えることができる。

行列式は正方行列からその逆行列を導き出すために役に立つ。ただし、全ての正方行列が逆行列を持つわけではない。正方行列の行列式を計算することでその正方行列が逆行列を持つかどうかを確かめることができる。逆行列を持つことができる正方行列は行列式の値が0以外になる。そのような正方行列は特に正則せいそく行列と呼ばれている。

Aが正方行列だとするとその行列式は$ |A| $や$ det\ A $やdet(A)と表すことができる。detというのは行列式の英語の呼び方であるa determinantの略記。

2次の正方行列の行列式が最も簡単で、しかも行列式の基本となるもの。ここではAの添字の2によって2次の正方行列を表すことにする。

\[ A_2 = \begin{pmatrix} a & b \\ c & d \end{pmatrix} \]

2次正方行列を次のように展開することによってその行列式を計算することができる。

\[ \begin{align} det\ A_2 &= |A_2| \\ &= \begin{vmatrix} \colorbox{yellow}{$ a $} & \colorbox{cyan}{$ b $} \\ \colorbox{cyan}{$ c $} & \colorbox{yellow}{$ d $} \end{vmatrix} \\ &= \colorbox{yellow}{$ a \cdot d $} - \colorbox{cyan}{$ b \cdot c $} \\ &= \colorbox{yellow}{$ ad $} - \colorbox{cyan}{$ bc $} \end{align} \]

$ ad - bc $が2次正方行列の行列式。2次正方行列の対角線上の成分同士を掛けたadとbcとの差になっていることが分かる。$ ad + (-bc) $と理解することもできる。

3次の正方行列の行列式はやや複雑。3次以上の正方行列ではラプラス展開を用いることによって行列式を求めることができる。ラプラス展開は余因子よいんし展開とも呼ばれている。

\[ A_3 = \begin{pmatrix} a & b & c \\ d & e & f \\ g & h & i \end{pmatrix} \]

\[ \begin{align} det\ A_3 &= |A_3| \\\\ &= \begin{vmatrix} a & b & c \\ d & e & f \\ g & h & i \end{vmatrix} \\\\ &= a \left( \begin{vmatrix} e & f \\ h & i \end{vmatrix} \right) + b \left( -\begin{vmatrix} d & f \\ g & i \end{vmatrix} \right) + c \left( \begin{vmatrix} d & e \\ g & h \end{vmatrix} \right) \\\\ &= a \begin{vmatrix} e & f \\ h & i \end{vmatrix} - b \begin{vmatrix} d & f \\ g & i \end{vmatrix} + c \begin{vmatrix} d & e \\ g & h \end{vmatrix} \\\\ &= a(ei - fh) - b(di - fg) + c(dh - eg) \end{align} \]

$ \begin{vmatrix} a & b & c \\ d & e & f \\ g & h & i \end{vmatrix} $を3つの$ \begin{vmatrix} e & f \\ h & i \end{vmatrix} $と$ \begin{vmatrix} d & f \\ g & i \end{vmatrix} $と$ \begin{vmatrix} d & e \\ g & h \end{vmatrix} $とに分けているところに注目。

これらの3つの部分は行列$ A_3 $の1番目の行に沿ったa, b, cのそれぞれ小行列式しょうぎょうれつしきと呼ばれている。小行列式はスカラー（実数か複素数）であり、$ ei - fh $と$ di - fg $と$ dh - eg $で表すことができる。

各々の小行列式に対し、一定の規則と順番に従って1か-1を交互に掛けたものは、これらa, b, cのそれぞれ余因子よいんしと呼ばれている。

ここではaの$ \begin{vmatrix} e & f \\ h & i \end{vmatrix} = ei - fh $、そしてbの$ -\begin{vmatrix} d & f \\ g & i \end{vmatrix} = -(di - fg) $、そしてcの$ \begin{vmatrix} d & e \\ g & h \end{vmatrix} = dh - eg $がそれぞれ余因子。

ラプラス展開ではこれらの余因子にそれらの元の成分の値であるa, b, cを掛ける手続きが必要になる。ただし、行列とスカラーである行列式とは異なるので、表記法が似ているからと言って、例えば$ a \begin{vmatrix} b & c \\ d & e \end{vmatrix} $を行列のスカラー倍であると勘違いして$ \begin{vmatrix} a b & a c \\ a d & a e \end{vmatrix} $と計算してしまうのは間違い。$a (b e - c d) $と計算するのが正しい。||で挟んだ小行列式の表記法では丸括弧が省略されてしまっているので要注意。

小行列式は行列の前にdetを添えて次のように表記されることもある。

\[ det \begin{pmatrix} a & b & c \\ d & e & f \\ g & h & i \end{pmatrix} = a \cdot det \begin{pmatrix} e & f \\ h & i \end{pmatrix} - b \cdot det \begin{pmatrix} d & f \\ g & i \end{pmatrix} + c \cdot det \begin{pmatrix} d & e \\ g & h \end{pmatrix} \]

ラプラス展開のアルゴリズムは一見すると複雑そうに見えるが、次の表を見れば一目瞭然。

ラプラス展開のアルゴリズム

次のような3次の正方行列があるとする。
\[ A = \begin{pmatrix} a & b & c \\ d & e & f \\ g & h & i \end{pmatrix} \]
そのうちの行か列のいずれか1つを選ぶ。ここでは1番目の行（その成分はa, b, c）を選んだ。どの行、どの列を選んでも同じ計算結果が得られる。
\[ \begin{pmatrix} \colorbox{yellow}{$ a $} & \colorbox{yellow}{$ b $} & \colorbox{yellow}{$ c $} \\ d & e & f \\ g & h & i \end{pmatrix} \]

a b c

d e f

g h i
選んだ行の成分a, b, cについて、次のようにして各々の小行列式を求める。
\[ \begin{pmatrix} \cancel{\colorbox{yellow}{$ a $}} & \cancel{b} & \cancel{c} \\ \cancel{d} & e & f \\ \cancel{g} & h & i \end{pmatrix} \]

a

e f

h i

aが属す列と行を消した残り、したがって$ a \cdot \begin{vmatrix} e & f \\ h & i \end{vmatrix} = a(ei - fh) $が得られる。

\[ \begin{pmatrix} \cancel{a} & \cancel{\colorbox{yellow}{$ b $}} & \cancel{c} \\ d & \cancel{e} & f \\ g & \cancel{h} & i \end{pmatrix} \]

b

d f

g i

bが属す列と行を消した残り、したがって$ b \cdot \begin{vmatrix} d & f \\ g & i \end{vmatrix} = b(di - fg) $が得られる。

\[ \begin{pmatrix} \cancel{a} & \cancel{b} & \cancel{\colorbox{yellow}{$ c $}} \\ d & e & \cancel{f} \\ g & h & \cancel{i} \end{pmatrix} \]

c

d e

g h

cが属す列と行を消した残り、したがって$ c \cdot \begin{vmatrix} d & e \\ g & h \end{vmatrix} = c(dh - eg) $が得られる。
小行列式に順番に正負の符号をそれぞれ割り振る。
符号の割り振り方は次のような規則に従う。ラプラス展開のために2.で選んだ任意の行ないし任意の列が奇数番目にあるときには「正負正負」という順番に交互に符号を割り振り、偶数番目にあるときには「負正負正」という順番に交互に符号を割り振る。

ここで選んだa, b, cは1番目の行なので、すなわち奇数番目の行なので、正負正負という順番で符号を小行列式に割り振ると、$ a \cdot \begin{vmatrix} e & f \\ h & i \end{vmatrix} $と$ b \cdot -\begin{vmatrix} d & f \\ g & i \end{vmatrix} $と$ c \cdot \begin{vmatrix} d & e \\ g & h \end{vmatrix} $が得られることになる。
符号付きの小行列式（これを余因子よいんしと呼ぶ）同士を合計する。つまり足し算で繋ぐ。
\[ +a \cdot \begin{vmatrix} e & f \\ h & i \end{vmatrix} + b \cdot -\begin{vmatrix} d & f \\ g & i \end{vmatrix} + c \cdot \begin{vmatrix} d & e \\ g & h \end{vmatrix} \]

これらの符号及び演算子を整理すると次のようになる。

\[ a \begin{vmatrix} e & f \\ h & i \end{vmatrix} - b \begin{vmatrix} d & f \\ g & i \end{vmatrix} + c \begin{vmatrix} d & e \\ g & h \end{vmatrix} \]
2次の正方行列の行列式を求めるときと同様のやり方によって更に展開すると、次のような行列式が最終的に得られることになる。
\[ \begin{align} |A| &= a \begin{vmatrix} \colorbox{yellow}{$ e $} & \colorbox{cyan}{$ f $} \\ \colorbox{cyan}{$ h $} & \colorbox{yellow}{$ i $} \end{vmatrix} - b \begin{vmatrix} \colorbox{yellow}{$ d $} & \colorbox{cyan}{$ f $} \\ \colorbox{cyan}{$ g $} & \colorbox{yellow}{$ i $} \end{vmatrix} + c \begin{vmatrix} \colorbox{yellow}{$ d $} & \colorbox{cyan}{$ e $} \\ \colorbox{cyan}{$ g $} & \colorbox{yellow}{$ h $} \end{vmatrix} \\ &= a(\colorbox{yellow}{$ ei $} - \colorbox{cyan}{$ fh $}) - b(\colorbox{yellow}{$ di $} - \colorbox{cyan}{$ fg $}) + c(\colorbox{yellow}{$ dh $} - \colorbox{cyan}{$ eg $}) \end{align} \]

ラプラス展開は3次以上のn次（n行n列）の正方行列にそのまま単純に拡張して応用することができる。基本形となる2次の小行列式になるまで展開し、それらの総和を計算すればいい。

ラプラス展開について具体例を挙げてみる。例えば次のような3次の正方行列があったとする。

\[ A_3 = \begin{pmatrix} -2 & 5 & 10 \\ 12 & 7 & -11 \\ 3 & -6 & 15 \end{pmatrix} \]

この行列式はラプラス展開によって次のようになるはず。

\[ \begin{align} det\ A_3 &= |A_3| \\\\ &= -2 \cdot \begin{vmatrix} 7 & -11 \\ -6 & 15 \end{vmatrix} + 5 \cdot -\begin{vmatrix} 12 & -11 \\ 3 & 15 \end{vmatrix} + 10 \cdot \begin{vmatrix} 12 & 7 \\ 3 & -6 \end{vmatrix} \\\\ &= -2 \cdot \begin{vmatrix} 7 & -11 \\ -6 & 15 \end{vmatrix} - 5 \cdot \begin{vmatrix} 12 & -11 \\ 3 & 15 \end{vmatrix} + 10 \cdot \begin{vmatrix} 12 & 7 \\ 3 & -6 \end{vmatrix} \\\\ &= -2 \cdot (7 \cdot 15 + 11 \cdot -6) - 5 \cdot (12 \cdot 15 + 11 \cdot 3) \\\\ & \hspace{1em} + 10 \cdot (12 \cdot -6 - 7 \cdot 3) \\\\ &= -2 \cdot (105 - 66) - 5 \cdot (180 + 33) + 10 \cdot (-72 - 21) \\\\ &= -2 \cdot 39 - 5 \cdot 213 + 10 \cdot -93 \\\\ &= -78 - 1065 + (-930) \\\\ &= -2073 \end{align} \]

やや入り組んだ計算だったのでMaximaを使って答え合わせをしてみた。Maximaではdeterminant()函数が行列式の役割を果たしてくれる。

$ maxima
Maxima 5.42.1 http://maxima.sourceforge.net
（中略）
(%i1) A: matrix([-2,5,10],[12,7,-11],[3,-6,15]);
                              [ - 2   5    10  ]
                              [                ]
(%o1)                         [ 12    7   - 11 ]
                              [                ]
                              [  3   - 6   15  ]
(%i2) determinant(A);
(%o2)                               - 2073
(%i3) quit();

-2073というスカラーが得られた。

GNU Octaveでもdet()函数を用いて同じ結果が得られた。

$ octave
GNU Octave, version 4.4.1
（中略）
>> A_3 = [-2,5,10;12,7,-11;3,-6,15]
A_3 =

   -2    5   10
   12    7  -11
    3   -6   15

>> det(A_3)
ans = -2073
>> quit()

R言語でも確かめてみる。R言語でもdet()函数が行列式の役目を果たしてくれる。ちなみに、R言語のmatrix()函数は列順序で値を配列してゆくので、c()函数の引数を行順序で指定した場合にはbyrow=Tの指定が必要になることに要注意。

$ R
R version 3.5.2 (2018-12-20) -- "Eggshell Igloo"
（中略）
> A = matrix(c(-2,5,10,12,7,-11,3,-6,15),3,3)
> A
     [,1] [,2] [,3]
[1,]   -2   12    3
[2,]    5    7   -6
[3,]   10  -11   15
> A = matrix(c(-2,5,10,12,7,-11,3,-6,15),3,3,byrow=T)
> A
     [,1] [,2] [,3]
[1,]   -2    5   10
[2,]   12    7  -11
[3,]    3   -6   15
> det(A)
[1] -2073
> q()
Save workspace image? [y/n/c]: n

やはり-2073というスカラーが得られた。

Juliaではどうか。Juliaで行列式を求めるにはdet()函数を用いることができる。

$ julia
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.0.3
 _/ |\__'_|_|_|\__'_|  |  Debian ⛬  julia/1.0.3+dfsg-4
|__/                   |

julia> A = [-2 5 10;12 7 -11;3 -6 15]
3×3 Array{Int64,2}:
 -2   5   10
 12   7  -11
  3  -6   15

julia> det(A)
ERROR: UndefVarError: det not defined
Stacktrace:
 [1] top-level scope at none:0

det()函数が見つからないとエラーが生じてしまった。線形代数を使うことをusingで明示的に指定する必要があるようだ。

julia> using LinearAlgebra

julia> det(A)
-2073.0

julia> exit()

Python 3でも試してみる。Python 3の場合にはNumpyをインポートしてnumpy.linalg.det()函数を呼び出す。

$ python3
Python 3.7.3
（中略）
>>> import numpy as np
>>> A = np.matrix('-2,5,10;12,7,-11;3,-6,15')
>>> A
matrix([[ -2,   5,  10],
        [ 12,   7, -11],
        [  3,  -6,  15]])
>>> i = np.linalg.det(A)
>>> i
-2072.9999999999995
>>> exit()

誤差がやや生じたけれどもPython3でも同様のスカラーが得られた。

ラプラス展開では、必ずしも行列の最上部の行を用いる必要はない。計算が最も簡単そうな任意の行や任意の列を選ぶことができる。どの行やどの列を選んでもラプラス展開によって同じ行列式の値が得られることは、ラプラス展開の定理のひとつとして知られている。

例えば次のような4次の正方行列があったとする。

\[ A_4 = \begin{pmatrix} -2 & 5 & -3 & 1 \\ 0 & -5 & 0 & 10 \\ 4 & 7 & -6 & 2 \\ 10 & -6 & 1 & 4 \end{pmatrix} \]

この正方行列をラプラス展開する場合、0が2つある2行目を選ぶことは計算量を減らす点でより賢い道であるかもしれない。

\[ \begin{align} |A_4| &= -5 \cdot \begin{vmatrix} -2 & -3 & 1 \\ 4 & -6 & 2 \\ 10 & 1 & 4 \end{vmatrix} + 10 \cdot \begin{vmatrix} -2 & 5 & -3 \\ 4 & 7 & -6 \\ 10 & -6 & 1 \end{vmatrix} \end{align} \]

各々の小行列式について更に展開する。2次正方行列の行列式と最終的に同じ形になるまで。

\[ \begin{align} \begin{vmatrix} -2 & -3 & 1 \\ 4 & -6 & 2 \\ 10 & 1 & 4 \end{vmatrix} &= 10 \cdot \begin{vmatrix} -3 & 1 \\ -6 & 2 \end{vmatrix} + 1 \cdot -\begin{vmatrix} -2 & 1 \\ 4 & 2 \end{vmatrix} + 4 \cdot \begin{vmatrix} -2 & -3 \\ 4 & -6 \end{vmatrix} \\ &= 10 \cdot (-3 \cdot 2 - 1 \cdot -6) - 1 \cdot (-2 \cdot 2 - 1 \cdot 4) \\ & \hspace{1em} + 4 \cdot (-2 \cdot -6 + 3 \cdot 4) \\ &= 10 \cdot (-6 + 6) - 1 \cdot (-4 - 4) + 4 \cdot (12 + 12) \\ &= 10 \cdot 0 + 8 + 4 \cdot 24 \\ &= 104 \end{align} \]

\[ \begin{align} \begin{vmatrix} -2 & 5 & -3 \\ 4 & 7 & -6 \\ 10 & -6 & 1 \end{vmatrix} &= 10 \cdot \begin{vmatrix} 5 & -3 \\ 7 & -6 \end{vmatrix} + (-6) \cdot -\begin{vmatrix} -2 & -3 \\ 4 & -6 \end{vmatrix} + 1 \cdot \begin{vmatrix} -2 & 5 \\ 4 & 7 \end{vmatrix} \\ &= 10 \cdot (5 \cdot -6 + 3 \cdot 7) + 6 \cdot (-2 \cdot -6 + 3 \cdot 4) \\ & \hspace{1em} + (-2 \cdot 7 - 5 \cdot 4) \\ &= 10 \cdot (-30 + 21) + 6 \cdot(12 + 12) + (-14 - 20) \\ &= 10 \cdot -9 + 6 \cdot 24 - 34 \\ &= -90 + 144 - 34 \\ &= -90 + 110 \\ &= 20 \end{align} \]

計算結果を元の式に代入して2次正方行列のときと同様の形の行列式を得ることができる。

\[ \begin{align} |A_4| &= - 5 \cdot 104 + 10 \cdot 20 \\ &= -520 + 200 \\ &= -320 \end{align} \]

このようにして-320という計算結果が最終的に得られた。

R言語で答え合わせ。det()函数で行列式を計算できる。

$ R
R version 3.5.2 (2018-12-20) -- "Eggshell Igloo"
（中略）
> ele = c(-2,0,4,10,5,-5,7,-6,-3,0,-6,1,1,10,2,4)
> A = matrix(ele,4,4)
> A
     [,1] [,2] [,3] [,4]
[1,]   -2    5   -3    1
[2,]    0   -5    0   10
[3,]    4    7   -6    2
[4,]   10   -6    1    4
> det(A)
[1] -320
> q()
Save workspace image? [y/n/c]: n

n次の正方行列のラプラス展開

n次の正方行列のラプラス展開についておおざっぱに一般化してみた。

ある正方行列Aの中の各々の成分は$ a_{ij} $か$ a_{i,j} $と書かれる。aの添字のiは列番号を意味し、jは行番号を意味する。nを列か行の最終番号とする。

正方行列ではその定義からして列数mと行数nが等しいので$ m = n $となる。したがって正方行列では列も行もその最終番号を共にnだけで示すことにする。

行列A
i\j	1	2	3	$ \cdots $	n
1	$ a_{11} $	$ a_{12} $	$ a_{13} $	$ \cdots $	$ a_{1n} $
2	$ a_{21} $	$ a_{22} $	$ a_{23} $	$ \cdots $	$ a_{2n} $
3	$ a_{31} $	$ a_{32} $	$ a_{33} $	$ \cdots $	$ a_{3n} $
$ \vdots $	$ \vdots $	$ \vdots $	$ \vdots $	$ \ddots $	$ \vdots $
n	$ a_{n1} $	$ a_{n2} $	$ a_{n3} $	$ \cdots $	$ a_{nn} $

正方行列Aから$ a_{ij} $が属す列iと行jとをすべて削除して残った部分の行列は小行列と呼ばれ、$ A_{ij} $や$ A_{i,j} $やA(i,j)などと書かれる。

例えば行列Aの成分の一つである$ a_{22} $が属す行と列とを削除して残った部分、つまり色付けされているところがその小行列$ A_{22} $を意味する。

行列Aと小行列A(2,2)
i\j	1	2	3	$ \cdots $	n
1	$ a_{11} $	$ a_{12} $	$ a_{13} $	$ \cdots $	$ a_{1n} $
2	$ a_{21} $	$ a_{22} $	$ a_{23} $	$ \cdots $	$ a_{2n} $
3	$ a_{31} $	$ a_{32} $	$ a_{33} $	$ \cdots $	$ a_{3n} $
$ \vdots $	$ \vdots $	$ \vdots $	$ \vdots $	$ \ddots $	$ \vdots $
n	$ a_{n1} $	$ a_{n2} $	$ a_{n3} $	$ \cdots $	$ a_{nn} $

このようにして得られた小行列$ A_{ij} $の行列式は小行列式と呼ばれ、$ M_{ij} $と書かれる。Mは英語で小行列式を意味するa minorに由来。$ minor(A)_{ij} $のように書かれることもある。

\[ minor(A)_{ij} = M_{ij} \]

小行列式$ M_{ij} $に$ (-1)^{i+j} $を掛けたものは余因子よいんしと呼ばれ、$ C_{ij} $と書かれる。$ cof(A)_{ij} $とも書かれる。Cとconfは英語で余因子を意味するa cofactorから来ている。

\[ C_{ij} = cof(A)_{ij} = (-1)^{i+j} M_{ij} \]

iは列番号、jは行番号。$ (-1)^{i+j} $の指数部の$ i + j $が何を意味しているのか直感的に分かりにくいかもしれないので、具体的に計算例をいくつか示してみる。

\[ \begin{align} (-1)^{1+1} &= (-1)^2 = \hspace{1em} 1 \\ (-1)^{1+2} &= (-1)^3 = -1 \\ (-1)^{1+3} &= (-1)^4 = \hspace{1em} 1 \\ (-1)^{1+4} &= (-1)^5 = -1 \\ \vdots \\ (-1)^{2+1} &= (-1)^3 = -1 \\ (-1)^{2+2} &= (-1)^4 = \hspace{1em} 1 \\ (-1)^{2+3} &= (-1)^5 = -1 \\ (-1)^{2+4} &= (-1)^6 = \hspace{1em} 1 \\ \vdots \\ (-1)^{3+1} &= (-1)^4 = \hspace{1em} 1 \\ (-1)^{3+2} &= (-1)^5 = -1 \\ (-1)^{3+3} &= (-1)^6 = \hspace{1em} 1 \\ (-1)^{3+4} &= (-1)^7 = -1 \\ \vdots \\ (-1)^{4+1} &= (-1)^5 = -1 \\ (-1)^{4+2} &= (-1)^6 = \hspace{1em} 1 \\ (-1)^{4+3} &= (-1)^7 = -1 \\ (-1)^{4+4} &= (-1)^8 = \hspace{1em} 1 \\ \end{align} \]

奇数列だと1, -1, 1, -1, ...となり、偶数列だと-1, 1, -1, 1, ...となっているのが見て取れる。このことは行を選んだ場合も同じ。

$ (-1)^{i+j} $を掛けるということは、ある行列の成分の余因子によって作られる余因子行列の符号がちょうどチェッカーフラック状の幾何学的模様のように分布することに等しい。

$ +M_{11} $	$ -M_{12} $	$ +M_{13} $	$ -M_{14} $	$ +M_{15} $	$ -M_{16} $
$ -M_{21} $	$ +M_{22} $	$ -M_{23} $	$ +M_{24} $	$ -M_{25} $	$ +M_{26} $
$ +M_{31} $	$ -M_{32} $	$ +M_{33} $	$ -M_{34} $	$ +M_{35} $	$ -M_{36} $
$ -M_{41} $	$ +M_{42} $	$ -M_{43} $	$ +M_{44} $	$ -M_{45} $	$ +M_{46} $
$ +M_{51} $	$ -M_{52} $	$ +M_{53} $	$ -M_{54} $	$ +M_{55} $	$ -M_{56} $
$ -M_{61} $	$ +M_{62} $	$ -M_{63} $	$ +M_{64} $	$ -M_{65} $	$ +M_{66} $

1は掛け算における単位元なので、1をある数に掛けるとその数は変化しない。-1をある数に掛けるとその数の符号が変わる。正の数ならば負の数に、負の数ならば正の数に。

\[ \begin{align} 1 \cdot M_{11} &= \hspace{1em} M_{11} = C_{11} \\ -1 \cdot M_{12} &= -M_{12} = C_{12} \\ 1 \cdot M_{13} &= \hspace{1em} M_{13} = C_{13} \\ -1 \cdot M_{14} &= -M_{14} = C_{14} \\ \vdots \\ -1 \cdot M_{21} &= -M_{21} = C_{21} \\ 1 \cdot M_{22} &= \hspace{1em} M_{22} = C_{22} \\ -1 \cdot M_{23} &= -M_{23} = C_{23} \\ 1 \cdot M_{24} &= \hspace{1em} M_{24} = C_{24} \\ \vdots \\ 1 \cdot M_{31} &= \hspace{1em} M_{31} = C_{31} \\ -1 \cdot M_{32} &= -M_{32} = C_{32} \\ 1 \cdot M_{33} &= \hspace{1em} M_{33} = C_{33} \\ -1 \cdot M_{34} &= -M_{34} = C_{34} \\ \vdots \\ \end{align} \]

というわけで、n次の正方行列$ A_n $の行列式は次のような多項式として定式化することができる。Cは符号付きの小行列式である余因子。iは列番号、jは行番号。

ラプラス展開のために任意の行$ a_{i1}, a_{i2}, \cdots, a_{in} $を選ぶ場合は次のとおり。

\[ \begin{align} |A_n| &= a_{i1}C_{i1} + a_{i2}C_{i2} + a_{i3}C_{i3} + \cdots + a_{in}C_{in} \\ &= \sum_{j=1}^n a_{ij}C_{ij} \\ &= \sum_{j=1}^n a_{ij} (-1)^{i+j} M_{ij} \\ &= a_{i1} (-1)^{i+1} M_{i1} + a_{i2} (-1)^{i+2} M_{i2} \\ & + a_{i3} (-1)^{i+3} M_{i3} + \cdots + a_{in} (-1)^{i+n} M_{in} \end{align} \]

ラプラス展開のために任意の列$ a_{1j}, a_{2j},\cdots, a_{nj} $を選ぶ場合は次のとおり。

\[ \begin{align} |A_n| &= a_{1j}C_{1j} + a_{2j}C_{2j} + a_{3j}C_{3j} + \cdots + a_{nj}C_{nj} \\ &= \sum_{i=1}^n a_{ij}C_{ij} \\ &= \sum_{i=1}^n a_{ij} (-1)^{i+j} M_{ij} \\ &= a_{1j} (-1)^{1+j} M_{1j} + a_{2j} (-1)^{2+j} M_{2j} \\ & + a_{3j} (-1)^{3+j} M_{3j} + \cdots + a_{nj} (-1)^{n+j} M_{nj} \end{align} \]

n次の正方行列の特定の行、もしくは特定の列を任意に選び、選んだ行ないし列の各成分とその小行列式と余因子とを掛け合わせ、そうして求めた各々の項をすべて合計する総和が、その正方行列の行列式と等しくなる。そしてその値はスカラー。

ラプラス展開では、行を選んでも列を選んでもその結果は等しいことが証明されている。

\[ \sum_{j=1}^n a_{ij}C_{ij} = \sum_{i=1}^n a_{ij}C_{ij} \hspace{1cm} \]

2次の正方行列のラプラス展開（？）

次のような2次正方行列があるとする。

\[ A_2 = \begin{pmatrix} a & b \\ c & d \end{pmatrix} \]

これをラプラス展開してみる。例えばこの正方行列の1行目を選んでラプラス展開する場合は次のとおり。

aと同じ行と列にある成分を全て取り除き、残ったdがaについての小行列式。

\[ \begin{pmatrix} \cancel{\colorbox{yellow}{$ a $}} & \cancel{b} \\ \cancel{c} & d \end{pmatrix} \rightarrow |d| \]

a
	d

bと同じ行と列にある成分を全て取り除き、残ったcがbについての小行列式。

\[ \begin{pmatrix} \cancel{a} & \cancel{\colorbox{yellow}{$ b $}} \\ c & \cancel{d} \end{pmatrix} \rightarrow |c| \]

	b
c

2行目を選んでラプラス展開する場合は次のとおり。

cが属す行と列の成分を全て取り除き、残ったbがcについての小行列式。

\[ \begin{pmatrix} \cancel{a} & b \\ \cancel{\colorbox{yellow}{$ c $}} & \cancel{d} \end{pmatrix} \rightarrow |b| \]

	b
c

dが属す行と列の成分を全て取り除き、残ったaがdについての小行列式。

\[ \begin{pmatrix} a & \cancel{b} \\ \cancel{c} & \cancel{\colorbox{yellow}{$ d $}} \end{pmatrix} \rightarrow |a| \]

a
	d

ラプラス展開によって得られた小行列式に符号を適用して余因子を作る。この処理では1か-1を小行列式に交互に掛ける。1を掛けるか-1を掛けるかは、$ (-1)^{i + j} $（iは列番号、jは行番号）によって決まる。列を選んだ場合にも同じ理屈が成り立つ。

\[ \begin{eqnarray} (-1)^{1+1} \cdot |d| &=& 1 \cdot |d| &=& |d| \\\\ (-1)^{1+2} \cdot |c| &=& -1 \cdot |c| &=& -|c| \\\\ (-1)^{2+2} \cdot |b| &=& -1 \cdot |b| &=& -|b| \\\\ (-1)^{2+1} \cdot |a| &=& 1 \cdot |a| &=& |a| \end{eqnarray} \]

正方行列$ A_2 $の行列式は次のように計算される。成分aとその余因子dを掛け、成分bとその余因子-cを掛け、そしてそれらを足し合わせる。

\[ \begin{align} det(A_2) = |A_2| &= a \cdot (+d) + b \cdot (-c) \\ &= ad + (-bc) \\ &= ad - bc \end{align} \]

あるいは、成分cとその余因子-bを掛け、成分dとその余因子aを掛け、そしてそれらを足し合わせる。

\[ \begin{align} det(A_2) = |A_2| &= c \cdot (-b) + d \cdot a \\ &= -(bc) + ad \\ &= ad - bc \end{align} \]

サラスのルール（3次正方行列限定）

行列式を求めるやり方にはラプラス展開を用いること以外にも、連立方程式で用いられるガウスの消去法（掃き出し法）など、様々な方法が開発されている。ガウスの消去法についてはまた別の機会に。

ここで取り上げるのは、3次の正方行列限定の方法として知られているサラスのルール。これはバスケット織りのメソッドという別名を持っている。たすき掛け法もこれとほぼ同様のやり方。

例えば次のような3次正方行列があるとする。

\[ A_3 = \begin{pmatrix} -2 & 5 & 10 \\ 12 & 7 & -11 \\ 3 & -6 & 15 \end{pmatrix} \]

この正方行列の左から2列をこの正方行列の右に追加して拡張する。次のように。

-2 5 10 -2 5

12 7 -11 12 7

3 -6 15 3 -6
-2から斜め右下の15へ向けて対角線上に並んでいる数を掛け算する。この掛け算は行列同士の掛け算ではなく可換性の通常の掛け算のこと。

-2 5 10 -2 5

12 7 -11 12 7

3 -6 15 3 -6

\[ -2 \cdot 7 \cdot 15 = -210 \]
5から斜め右下の3へ向けて対角線上に並んでいる数を掛け算する。

-2 5 10 -2 5

12 7 -11 12 7

3 -6 15 3 -6

\[ 5 \cdot -11 \cdot 3 = -165 \]
10から斜め右下の-6へ向けて対角線上に並んでいる数を掛け算する。

-2 5 10 -2 5

12 7 -11 12 7

3 -6 15 3 -6

\[ 10 \cdot 12 \cdot -6 = -720 \]
左上から右下への対角線上の数を掛け算することによって得られた積を足し算で繋ぐ。
\[ -210 + (-165) + (-720) \]
今度は逆方向。左下の3から斜め右上の10に向けて対角線上に並んでいる数を掛け算する。

-2 5 10 -2 5

12 7 -11 12 7

3 -6 15 3 -6

\[ 3 \cdot 7 \cdot 10 = 210 \]
-6から斜め右上の-2へ向けて対角線上に並んでいる数を掛け算する。

-2 5 10 -2 5

12 7 -11 12 7

3 -6 15 3 -6

\[ -6 \cdot -11 \cdot -2 = -132 \]
15から斜め右上の5まで対角線上に並んでいる数を掛け算する。

-2 5 10 -2 5

12 7 -11 12 7

3 -6 15 3 -6

\[ 15 \cdot 12 \cdot 5 = 900 \]
左下から右上へ（右上から左下へでもいい）の対角線上の数を掛け算して得られた積を今度は引き算で繋ぐ。
\[ 210 - (-132) - 900 \]
足し算で繋いだ式と引き算で繋いだ式とを引き算で繋ぎ合わせる。その際に足し算で繋いだ式が前に来る。こうして最終的な行列式が得られる。
\[ |A_3| = -210 + (-165) + (-720) - 210 - (-132) - 900 \]

この行列式を計算してみると、-2073というスカラーが得られた。ラプラス展開によって求めた場合と同じ数になることが分かる。

逆行列を求める

正方行列からその逆行列を見つけるにはどうするのか。

例えばAという2次正方行列があったとする。

\[ A = \begin{pmatrix} a & b \\ c & d \end{pmatrix} \]

Aの逆行列は$ A^{-1} $と記すのが慣例。$ A^{-1} $は次のような式によって表すことができる。

\[ \begin{align} A^{-1} &= \begin{pmatrix} a & b \\ c & d \end{pmatrix}^{-1} \\ &= \dfrac{1}{ad - bc} \begin{pmatrix} d & -b \\ -c & a \end{pmatrix} \\ &= \begin{pmatrix} \dfrac{d}{ad-bc} & -\dfrac{b}{ad-bc} \\ -\dfrac{c}{ad-bc} & \dfrac{a}{ad-bc} \end{pmatrix} \end{align} \]

分数のところの分母の$ ad - bc $の部分がこの2次正方行列Aの行列式。そしてその分数の右の行列の部分はaとdとが置き換わり、bとcの符号が反転していることが見て取れる。この行列の部分は（転置てんちされた）余因子行列と呼ばれ、adj\ Aやadj(A)と書かれることがある。

\[ A^{-1} = \dfrac{1}{det\ A} adj\ A \]

上の式は、Aの逆行列がAの（転置された）余因子行列をAの行列式で割ったものに等しいことを意味している。割り算が逆数による掛け算でもあることを思い出して。

これを先程の方程式に代入すると次のような関係式が完成する。

\[ \begin{align} \begin{pmatrix} a & b \\ c & d \end{pmatrix} \left( \dfrac{1}{ad - bc} \begin{pmatrix} d & -b \\ -c & a \end{pmatrix} \right) &= \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} \end{align} \] \[ \begin{align} \left( \dfrac{1}{ad - bc} \begin{pmatrix} d & -b \\ -c & a \end{pmatrix} \right) \begin{pmatrix} a & b \\ c & d \end{pmatrix} &= \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} \end{align} \] \[ ただし ad - bc \neq 0 \]

正方行列にその逆行列を掛ければ単位行列が得られることをこの関係式は意味している。この関係式は逆行列にその正方行列を掛けても成り立つ。

ただし、行列式が$ ad - bc = 0 $のときにはこの関係式が成り立たないことに要注意。その場合、その正方行列には逆行列が存在しないことを意味している。

逆行列の定理：正方行列はその行列式の解が0以外の場合だけその逆行列を持つ。

逆行列を持つ正方行列は可逆かぎゃくであると言い、逆行列を持っていない正方行列は特異とくいであると言う。正方行列以外の行列は逆行列を持っていない。逆行列を持っている正方行列は特に正則せいそく行列と呼ばれている。

正則行列Aの逆行列がAの（転置された）余因子行列をAの行列式で割ったものに等しいことを示した先ほどの関係式に、実際の正則行列の各成分を代入してやれば、その正則行列の逆行列が得られることになる。

具体例を挙げてみる。次のような2次正方行列があったとする。

\[ A = \begin{pmatrix} 8 & 5 \\ 3 & 2\end{pmatrix} \]

この正方行列の成分を逆行列に変換すると次のようになるはず。

\[ A^{-1} = \dfrac{1}{8 \cdot 2 - 5 \cdot 3} \cdot \begin{pmatrix} 2 & -5 \\ -3 & 8 \end{pmatrix} \]

これが正しいかどうかは、正則行列とその逆行列とを掛け算し、その答えが単位行列になるかどうかを確かめることで分かるはず。

\[ \begin{align} A \cdot A^{-1} &= \begin{pmatrix} 8 & 5 \\ 3 & 2\end{pmatrix} \cdot \left( \dfrac{1}{8 \cdot 2 - 5 \cdot 3} \cdot \begin{pmatrix} 2 & -5 \\ -3 & 8 \end{pmatrix} \right) \\ &= \begin{pmatrix} 8 & 5 \\ 3 & 2\end{pmatrix} \cdot \left( \dfrac{1}{16 - 15} \cdot \begin{pmatrix} 2 & -5 \\ -3 & 8 \end{pmatrix} \right) \\ &= \begin{pmatrix} 8 & 5 \\ 3 & 2\end{pmatrix} \cdot \left( \dfrac{1}{1} \cdot \begin{pmatrix} 2 & -5 \\ -3 & 8 \end{pmatrix} \right) \\ &= \begin{pmatrix} 8 & 5 \\ 3 & 2\end{pmatrix} \cdot \left( 1 \cdot \begin{pmatrix} 2 & -5 \\ -3 & 8 \end{pmatrix} \right) \\ &= \begin{pmatrix} 8 & 5 \\ 3 & 2\end{pmatrix} \cdot \begin{pmatrix} 1 \cdot 2 & 1 \cdot -5 \\ 1 \cdot -3 & 1 \cdot 8 \end{pmatrix} \\ &= \begin{pmatrix} 8 & 5 \\ 3 & 2\end{pmatrix} \cdot \begin{pmatrix} 2 & -5 \\ -3 & 8 \end{pmatrix} \\ &= \begin{pmatrix} 8 \cdot 2 + 5 \cdot (-3) & 8 \cdot (-5) + 5 \cdot 8 \\ 3 \cdot 2 + 2 \cdot (-3) & 3 \cdot (-5) + 2 \cdot 8 \end{pmatrix} \\ &= \begin{pmatrix} 16 + (-15) & (-40) + 40 \\ 6 + (-6) & (-15) + 16 \end{pmatrix} \\ &= \begin{pmatrix}1 & 0 \\ 0 & 1 \end{pmatrix} \end{align} \]

行列の掛け算では交換法則が成り立たないので、正方行列とその逆行列を交換しても単位行列が得られるかどうかを確かめてみる。

\[ \begin{align} A^{-1} \cdot A &= \begin{pmatrix} 2 & -5 \\ -3 & 8 \end{pmatrix} \cdot \begin{pmatrix} 8 & 5 \\ 3 & 2\end{pmatrix} \\ &= \begin{pmatrix} 2 \cdot 8 + (-5) \cdot 3 & 2 \cdot 5 + (-5) \cdot 2 \\ (-3) \cdot 8 + 8 \cdot 3 & (-3) \cdot 5 + 8 \cdot 2 \end{pmatrix} \\ &= \begin{pmatrix} 16 + (-15) & 10 + (-10) \\ (-24) + 24 & (-15) + 16 \end{pmatrix} \\ &= \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} \end{align} \]

いずれの場合も単位行列を得ることができた。

Maximanによって確かめてみる。Maximaで逆行列を得るにはinvert()函数を用いるか、Aが正則行列ならばA^^(-1);と入力する。

$ maxima
Maxima 5.42.1 http://maxima.sourceforge.net
（中略）
(%i1) A: matrix([8,5],[3,2]);
                                   [ 8  5 ]
(%o1)                              [      ]
                                   [ 3  2 ]
(%i2) B: invert(A);
                                 [  2   - 5 ]
(%o2)                            [          ]
                                 [ - 3   8  ]
(%i3) A.B;
                                   [ 1  0 ]
(%o3)                              [      ]
                                   [ 0  1 ]
(%i4) B.A;
                                   [ 1  0 ]
(%o4)                              [      ]
                                   [ 0  1 ]
(%i5) quit();

いずれも単位行列を得ることができた。

行列同士の乗法では交換法則が成り立たないので、Maximaを使って行列同士の掛け算を行うには非可換乗算演算子であるドット（.）演算子を用いる必要がある。乗算演算子としてアスタリスク（*）を用いると誤った結果を得るので要注意。

Juliaで逆行列を得るにはinv()函数を用いることができる。Juliaでは行列同士の掛け算にアスタリスク(*)を用いる必要がある。ドット(.)を用いると文法エラーが生じてしまう。

$ julia
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.0.3
 _/ |\__'_|_|_|\__'_|  |  Debian ⛬  julia/1.0.3+dfsg-4
|__/                   |

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

julia> B = inv(A)
2×2 Array{Float64,2}:
  2.0  -5.0
 -3.0   8.0

julia> A * B
2×2 Array{Float64,2}:
 1.0  0.0
 0.0  1.0

julia> B * A
2×2 Array{Float64,2}:
 1.0  0.0
 0.0  1.0

julia> exit()

Juliaでdet()函数を使うにはusing LinearAlgebraの指定が必要だが、inv()函数ではなぜかそれが不要。

Python3ではNumpyをインポートしてnumpy.linalg.inv()函数を用いることで逆行列を作成できる。

$ python3
Python 3.7.3
（中略）
>>> import numpy as np
>>> A = np.matrix('8,5;3,2')
>>> print(A)
[[8 5]
 [3 2]]
>>> B = np.linalg.inv(A)
>>> print(B)
[[ 2. -5.]
 [-3.  8.]]
>>> print(A @ B)
[[1. 0.]
 [0. 1.]]
>>> print(B @ A)
>>> quit()

Python3の場合、行列同士の掛け算にはアットマーク(@)演算子を用いる。

逆行列を見つけるアルゴリズム

具体例をもう一つ挙げてみる。今度は3次の正方行列。

\[ A_3 = \begin{pmatrix} -2 & 0 & -5 \\ 4 & -6 & 2 \\ -1 & 1 & 3 \end{pmatrix} \]

ラプラス展開によって正方行列の全ての成分について各々の小行列式を求め、それらの小行列式の計算結果から小行列式の行列を作る。
\[ minor(A_3) = M = \begin{pmatrix} M_{11} & M_{12} & M_{13} \\ M_{21} & M_{22} & M_{23} \\ M_{31} & M_{32} & M_{33} \end{pmatrix} \]

$ M_{ij} $は行列$ A_3 $の各成分である$ a_{ij} $をラプラス展開して得られた小行列式、そしてその計算結果であるスカラー。

\[ \begin{align} M_{11} &= \begin{vmatrix} -6 & 2 \\ 1 & 3 \end{vmatrix} \\ &= -6 \cdot 3 - 2 \cdot 1 \\ &= -18 - 2 \\ &= -20 \\\\ M_{12} &= \begin{vmatrix} 4 & 2 \\ -1 & 3 \end{vmatrix} \\ &= 4 \cdot 3 - 2 \cdot -1 \\ &= 12 - (-2) = 12 + 2 \\ &= 14 \\\\ M_{13} &= \begin{vmatrix} 4 & -6 \\ -1 & 1 \end{vmatrix} \\ &= 4 \cdot 1 - (-6) \cdot -1 \\ &= 4 - 6 \\ &= -2 \\\\ M_{21} &= \begin{vmatrix} 0 & -5 \\ 1 & 3 \end{vmatrix} \\ &= 0 \cdot 3 - (-5) \cdot 1 \\ &= 0 - (-5) = 0 + 5 \\ &= 5 \\\\ M_{22} &= \begin{vmatrix} -2 & -5 \\ -1 & 3 \end{vmatrix} \\ &= -2 \cdot 3 - (-5) \cdot -1 \\ &= -6 - 5 \\ &= -11 \\\\ M_{23} &= \begin{vmatrix} -2 & 0 \\ -1 & 1 \end{vmatrix} \\ &= -2 \cdot 1 - 0 \cdot -1 \\ &= -2 \\\\ M_{31} &= \begin{vmatrix} 0 & -5 \\ -6 & 2 \end{vmatrix} \\ &= 0 \cdot 2 - (-5) \cdot -6 \\ &= 0 - 30 \\ &= -30 \\\\ M_{32} &= \begin{vmatrix} -2 & -5 \\ 4 & 2 \end{vmatrix} \\ &= -2 \cdot 2 - (-5) \cdot 4 \\ &= -4 - (-20) = -4 + 20 \\ &= 16 \\\\ M_{33} &= \begin{vmatrix} -2 & 0 \\ 4 & -6 \end{vmatrix} \\ &= -2 \cdot -6 - 0 \cdot 4 \\ &= 12 \end{align} \]

これらの小行列式の計算結果から得られたスカラーから、次のような行列を作ることができる。これが小行列式の行列。

\[ minor(A_3) = M = \begin{pmatrix} -20 & 14 & -2 \\ 5 & -11 & -2 \\ -30 & 16 & 12 \end{pmatrix} \]
小行列式の行列に対して正負の符号を規則どおりに適用して余因子行列を作る。
正負の符号は$ M_{11} $が正になるところから始まり、行列の最後の成分$ M_{nn} $まで正負正負の順番で互い違いに適用される。

このことは小行列式の行列を構成する各々のスカラーに対して1と-1を交互に掛けてゆく処理と等しい。このような掛け算はアダマール積と呼ばれることがある。行列同士の通常の掛け算と異なるので要注意。アダマール積の演算子は$ \circ $か$ \odot $。

\[ \begin{align} cof(A_3) = C &= \begin{pmatrix} -20 & 14 & -2 \\ 5 & -11 & -2 \\ -30 & 16 & 12 \end{pmatrix} \circ \begin{pmatrix} 1 & -1 & 1 \\ -1 & 1 & -1 \\ 1 & -1 & 1 \end{pmatrix} \\\\ &= \begin{pmatrix} -20 \cdot 1 & 14 \cdot -1 & -2 \cdot 1 \\ 5 \cdot -1 & -11 \cdot 1 & -2 \cdot -1 \\ -30 \cdot 1 & 16 \cdot -1 & 12 \cdot 1 \end{pmatrix} \\\\ &= \begin{pmatrix} -20 & -14 & -2 \\ -5 & -11 & 2 \\ -30 & -16 & 12 \end{pmatrix} \end{align} \]

こうして得られた行列は余因子行列と呼ばれているもの。英語ではa cofactor matrixのこと。
その余因子行列を転置てんちして余因子行列の転置行列を作る。これは$ adj\ A $とかadj(A)とか$ C^T $などと表される。
\[ adj(A_3) = C^T = (-1)^{i+j} M_{ji} \]

転置とは列(i)と行(j)とを次のように交替させること。つまり$ C_{ij} \rightarrow C_{ji} $にする。

\[ C = \begin{pmatrix} \colorbox{yellow}{-20} & \colorbox{yellow}{-15} & \colorbox{yellow}{-2} \\ \colorbox{cyan}{-5} & \colorbox{cyan}{-11} & \colorbox{cyan}{2} \\ \colorbox{pink}{-30} & \colorbox{pink}{-16} & \colorbox{pink}{12} \end{pmatrix} \rightarrow C^T = \begin{pmatrix} \colorbox{yellow}{-20} & \colorbox{cyan}{-5} & \colorbox{pink}{-30} \\ \colorbox{yellow}{-15} & \colorbox{cyan}{-11} & \colorbox{pink}{-16} \\ \colorbox{yellow}{-2} & \colorbox{cyan}{2} & \colorbox{pink}{12} \end{pmatrix} \]

a cofactor matrixを転置した行列も実は余因子行列と呼ばれている。転置された余因子行列は英語ではan adjugate matrixなので、adjはその略記。

以下、転置された余因子行列のことをここでは転置余因子行列と呼ぶことにする。
行列$ A_3 $をラプラス展開して行列式を計算する。
この計算は、例えば元の行列の一行目の成分$ a_{11}\ a_{12}\ a_{13} $とそれと同じ位置にある余因子行列の成分$ C_{11}\ C_{12}\ C_{13} $とを利用し、次のように簡単に行うことができる。

\[ A_3 = \begin{pmatrix} \colorbox{yellow} {-2} & \colorbox{yellow}{0} & \colorbox{yellow}{-5} \\ 4 & -6 & 2 \\ -1 & 1 & 3 \end{pmatrix} \] \[ C = \begin{pmatrix} \colorbox{yellow}{-20} & \colorbox{yellow}{-14} & \colorbox{yellow}{-2} \\ -5 & -11 & 2 \\ -30 & -16 & 12 \end{pmatrix} \]

\[ \begin{align} |A_3| &= a_{11}C_{11} + a_{12}C_{12} + a_{13}C_{13} \\ &= -2 \cdot -20 + 0 \cdot -14 + (-5) \cdot -2 \\ &= 40 + 0 + 10 \\ &= 50 \end{align} \]

2列目を選んだ場合は次のように計算できる。

\[ A_3 = \begin{pmatrix} -2 & \colorbox{yellow}{0} & -5 \\ 4 & \colorbox{yellow}{-6} & 2 \\ -1 & \colorbox{yellow}{1} & 3 \end{pmatrix} \] \[ C = \begin{pmatrix} -20 & \colorbox{yellow}{-14} & -2 \\ -5 & \colorbox{yellow}{-11} & 2 \\ -30 & \colorbox{yellow}{-16} & 12 \end{pmatrix} \]

\[ \begin{align} |A_3| &= a_{12}C_{12} + a_{22}C_{22} + a_{32}C_{32} \\ &= 0 \cdot -14 + -6 \cdot -11 + 1 \cdot -16 \\ &= 0 + 66 + (-16) = 0 + 66 - 16 \\ &= 50 \end{align} \]

どの行、またはどの列を選んでも、その成分を合計すれば、50というスカラーが得られるはず。
3.で得られた転置余因子行列と4.で得られた行列式のスカラーによって逆行列が次のとおりに定まる。
\[ \begin{align} A_3^{-1} &= \dfrac{1}{50} \cdot \begin{pmatrix} -20 & -5 & -30 \\ -14 & -11 & -16 \\ -2 & 2 & 12 \end{pmatrix} \\\\ &= \begin{pmatrix} -\dfrac{20}{50} & -\dfrac{5}{50} & -\dfrac{30}{50} \\ -\dfrac{14}{50} & -\dfrac{11}{50} & -\dfrac{16}{50} \\ -\dfrac{2}{50} & \dfrac{2}{50} & \dfrac{12}{50} \end{pmatrix} \\\\ &= \begin{pmatrix} -\dfrac{2}{5} & -\dfrac{1}{10} & -\dfrac{3}{5} \\ -\dfrac{7}{25} & -\dfrac{11}{50} & -\dfrac{8}{25} \\ -\dfrac{1}{25} & \dfrac{1}{25} & \dfrac{6}{25} \end{pmatrix} \end{align} \]

約分しているがしなくてもいい。正則行列の逆行列がその正則行列の転置余因子行列をその正則行列の行列式で割ったものであることが見て取れる。
元の正則行列と逆行列との掛け算をして単位行列が得られるかどうかを確認してみる。
この掛け算は行列同士の通常どおりの非可換性の乗法に従う。というわけで行列同士の掛け算では交換法則が通常は成り立たない。しかし、逆行列であることを確認するためには、掛けられる行列と掛ける行列を置き換えても単位行列が得られる必要があることに要注意。

\[ \begin{align} \begin{pmatrix} -2 & 0 & -5 \\ 4 & -6 & 2 \\ -1 & 1 & 3 \end{pmatrix} \cdot \begin{pmatrix} -\dfrac{2}{5} & -\dfrac{1}{10} & -\dfrac{3}{5} \\ -\dfrac{7}{25} & -\dfrac{11}{50} & -\dfrac{8}{25} \\ -\dfrac{1}{25} & \dfrac{1}{25} & \dfrac{6}{25} \end{pmatrix} &= \begin{pmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix} \end{align} \] \[ \begin{align} \begin{pmatrix} -\dfrac{2}{5} & -\dfrac{1}{10} & -\dfrac{3}{5} \\ -\dfrac{7}{25} & -\dfrac{11}{50} & -\dfrac{8}{25} \\ -\dfrac{1}{25} & \dfrac{1}{25} & \dfrac{6}{25} \end{pmatrix} \cdot \begin{pmatrix} -2 & 0 & -5 \\ 4 & -6 & 2 \\ -1 & 1 & 3 \end{pmatrix} &= \begin{pmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix} \end{align} \]

\[ \begin{align} \end{align} \]

この計算はやややっかいなのでMaximaに任せよう。

matrix()函数で行列を作り、invert()函数で逆行列を得る。ドット演算子(.)を用いて非可換性の乗法を行うと、いずれも単位行列が得られることが分かる。コロン(:)はMaximaでは変数への代入演算子。

$ maxima
Maxima 5.42.1 http://maxima.sourceforge.net
（中略）
(%i1) A: matrix([-2,0,-5],[4,-6,2],[-1,1,3]);
                               [ - 2   0   - 5 ]
                               [               ]
(%o1)                          [  4   - 6   2  ]
                               [               ]
                               [ - 1   1    3  ]
(%i2) IA: invert(A);
                             [   2     1     3  ]
                             [ - -   - --  - -  ]
                             [   5     10    5  ]
                             [                  ]
                             [   7     11    8  ]
(%o2)                        [ - --  - --  - -- ]
                             [   25    50    25 ]
                             [                  ]
                             [   1    1     6   ]
                             [ - --   --    --  ]
                             [   25   25    25  ]
(%i3) A.IA;
                                  [ 1  0  0 ]
                                  [         ]
(%o3)                             [ 0  1  0 ]
                                  [         ]
                                  [ 0  0  1 ]
(%i4) IA.A;
                                  [ 1  0  0 ]
                                  [         ]
(%o4)                             [ 0  1  0 ]
                                  [         ]
                                  [ 0  0  1 ]
(%i5) quit();

ちなみに、余因子行列の転置行列$ C^T $をMaximaで得るにはadjoint()函数を用いる。単位行列を作るにはident()函数を用いる。ident()函数の括弧内の引数には次数（n次の正方行列のnの数）を指定する。

Maximaで小行列式を得るにはminor(正方行列,列番号,行番号)函数を利用できる。

$ maxima
Maxima 5.42.1 http://maxima.sourceforge.net
（中略）
(%i1) A: matrix([-2,0,5],[4,-6,2],[-1,1,3]);
                                [ - 2   0   5 ]
                                [             ]
(%o1)                           [  4   - 6  2 ]
                                [             ]
                                [ - 1   1   3 ]
(%i2) minor(A,1,1);
                                  [ - 6  2 ]
(%o2)                             [        ]
                                  [  1   3 ]
(%i3) minor(A,1,2);
                                  [  4   2 ]
(%o3)                             [        ]
                                  [ - 1  3 ]
(%i4) minor(A,1,3);
                                 [  4   - 6 ]
(%o4)                            [          ]
                                 [ - 1   1  ]
(%i5) quit();

GNU Octaveではinv()函数を使うと逆行列を生成することができる。

$ octave
GNU Octave, version 4.4.1
Copyright (C) 2018 John W. Eaton and others.
（中略）
>> A = [-2,0,-5;4,-6,2;-1,1,3]
A =

  -2   0  -5
   4  -6   2
  -1   1   3

>> B = inv(A)
B =

  -0.400000  -0.100000  -0.600000
  -0.280000  -0.220000  -0.320000
  -0.040000   0.040000   0.240000

>> A*B
ans =

   1.00000   0.00000   0.00000
  -0.00000   1.00000  -0.00000
   0.00000   0.00000   1.00000

>> B*A
ans =

   1.00000   0.00000   0.00000
   0.00000   1.00000   0.00000
   0.00000   0.00000   1.00000

>> quit()

行列同士の割り算（除法）

行列同士の割り算は通常は定義されていないようだ。ただし、スカラー同士の割り算が割る数の逆数を掛けることに等しかったように、行列にもいくつかの条件の下でそのことを応用できる。

AとBが共に行列であるとき、その割り算を次のように定義できる。$ B^{-1} $はBという行列の逆行列を意味している。

\[ A \div B = A \cdot B^{-1} \]

割られる行列であるAは被除算ひじょさん行列、割る行列であるBは除算じょさん行列と呼ばれている。

行列同士の割り算が成り立つためには除算行列がその逆行列を持つ必要があるので、Bは正則行列である必要がある。

正則行列とは、列数と行数が同じこと、つまり正方行列であることと、その行列式が0でないこと、つまり可逆であることとが共に満たされた行列のこと。

さらに、AとBの逆行列$ B^{-1} $が掛け算可能である必要がある。行列同士の通常の掛け算が可能になるのは、Bの次元とAの列の数ないしAの行の数が一致している場合。

例として2列の行ベクトルと2次の正方行列の割り算を試してみる。

\[ \begin{align} \begin{pmatrix} -1 & 3 \end{pmatrix} \div \begin{pmatrix} 1 & 4 \\ -2 & 5 \end{pmatrix} &= \begin{pmatrix} -1 & 3 \end{pmatrix} \cdot \left( \dfrac{1}{(1 \cdot 5) - (-4 \cdot 2)} \cdot \begin{pmatrix} 5 & -4 \\ 2 & 1 \end{pmatrix} \right) \\\\ &= \begin{pmatrix} -1 & 3 \end{pmatrix} \cdot \left( \dfrac{1}{5 + 8} \cdot \begin{pmatrix} 5 & -4 \\ 2 & 1 \end{pmatrix} \right) \\\\ &= \begin{pmatrix} -1 & 3 \end{pmatrix} \cdot \left( \dfrac{1}{13} \cdot \begin{pmatrix} 5 & -4 \\ 2 & 1 \end{pmatrix} \right) \\\\ &= \begin{pmatrix} -1 & 3 \end{pmatrix} \cdot \begin{pmatrix} \dfrac{5}{13} & -\dfrac{4}{13} \\ \dfrac{2}{13} & \dfrac{1}{13} \end{pmatrix} \\\\ &= \begin{pmatrix} -1 \cdot \dfrac{5}{13} + 3 \cdot \dfrac{4}{13} & -1 \cdot -\dfrac{4}{13} + 3 \cdot \dfrac{1}{13} \end{pmatrix} \\\\ &= \begin{pmatrix} -\dfrac{5}{13} + \dfrac{6}{13} & \dfrac{4}{13} + \dfrac{3}{13} \end{pmatrix} \\\\ &= \begin{pmatrix} \dfrac{1}{13} & \dfrac{7}{13} \end{pmatrix} \end{align} \]

Juliaを用いて答え合わせ。

$ julia
（中略）
julia> A = [-1 3]
1×2 Array{Int64,2}:
 -1  3

julia> B = [1 4; -2 5]
2×2 Array{Int64,2}:
  1  4
 -2  5

julia> invB = inv(B)
2×2 Array{Float64,2}:
 0.384615  -0.307692 
 0.153846   0.0769231

julia> A * invB
1×2 Array{Float64,2}:
 0.0769231  0.538462

julia> 1/13
0.07692307692307693

julia> 7/13
0.5384615384615384

julia> exit()

分数と小数との違いはあるが、ほぼ同じ計算結果が得られた。

行列同士の割り算のアルゴリズム

割られる行列（被除算行列）と割る行列（除算行列）の行数と列数、列数と行数とが、共に等しいか、あるいはどちらか一方が等しいことを確認する。つまり、行列同士の掛け算が可能かどうかを確かめる。
行列同士の割り算は結局は行列同士の掛け算をする処理になるので、それが成り立つ条件を満たさなければいけない。

\[ \begin{pmatrix} \colorbox{yellow}{-1} & \colorbox{yellow}{3} \end{pmatrix} \div \begin{pmatrix} \colorbox{yellow}{1} & 4 \\ \colorbox{yellow}{-2} & 5 \end{pmatrix} \]

これらは行数と列数とが等しいのでその条件を満たしている。
除算行列の行数と列数とが等しいことを確認。つまり除算行列が正方行列であるという条件を満たすかどうかを見定める。
\[ \begin{pmatrix} 1 & 4 \\ -2 & 5 \end{pmatrix} \]

この除算行列は$ 2 \times 2 $の正方行列であるのでその条件を満たしている。
除算行列が正則行列であること、つまりその行列式が0でないこと、すなわち逆行列を持つことを確かめる。そのためには除算行列の行列式を解く。
\[ \begin{align} \begin{vmatrix} 1 & 4 \\ -2 & 5 \end{vmatrix} &= (1 \cdot 5) - (-4 \cdot 2) \\ &= 5 - (-8) \\ &= 5 + 8 \\ &= 13 \end{align} \]

除算行列の行列式は13。0でないので可逆、つまり逆行列を持つ。正則行列であるという条件を満たしていることが分かる。
除算行列の転置余因子行列を求める。
2次の場合は簡単。

\[ cof \begin{pmatrix} 1 & 4 \\ -2 & 5 \end{pmatrix} = \begin{pmatrix} 5 & -2 \\ 4 & 1 \end{pmatrix} \]

除算行列の成分1の小行列は5、成分4の小行列は-2、成分-2の小行列は4、成分5の小行列は1。

これにお約束どおりに正負正負という符号を適用する（アダマール積を取る）と次のようになる。

\[ \begin{align} adj \begin{pmatrix} 1 & 4 \\ -2 & 5 \end{pmatrix} &= \begin{pmatrix} 5 & -2 \\ 4 & 1 \end{pmatrix} \circ \begin{pmatrix} 1 & -1 \\ -1 & 1 \end{pmatrix} \\\\ &= \begin{pmatrix} 1 \cdot 5 & -1 \cdot -2 \\ -1 \cdot 4 & 1 \cdot 1 \end{pmatrix} \\\\ &= \begin{pmatrix} 5 & 2 \\ -4 & 1 \end{pmatrix} \end{align} \]

これを転置すると転置余因子行列の出来上がり。

\[ \begin{pmatrix} 5 & 2 \\ -4 & 1 \end{pmatrix}^T = \begin{pmatrix} 5 & -4 \\ 2 & 1 \end{pmatrix} \]
除算行列の行列式と除算行列の転置余因子行列とを材料にして除算行列の逆行列を作る。
\[ \begin{pmatrix} 1 & 4 \\ -2 & 5 \end{pmatrix}^{-1} = \dfrac{1}{13} \cdot \begin{pmatrix} 5 & -4 \\ 2 & 1 \end{pmatrix} = \begin{pmatrix} \dfrac{5}{13} & -\dfrac{4}{13} \\ \dfrac{2}{13} & \dfrac{1}{13} \end{pmatrix} \]
被除算行列と除算行列の逆行列とで行列同士の通常の乗算、つまり非可換性の掛け算をする。
\[ \begin{align} \begin{pmatrix} -1 & 3 \end{pmatrix} \cdot \begin{pmatrix} \dfrac{5}{13} & -\dfrac{4}{13} \\ \dfrac{2}{13} & \dfrac{1}{13} \end{pmatrix} &= \begin{pmatrix} -1 \cdot \dfrac{5}{13} + 3 \cdot \dfrac{4}{13} & -1 \cdot -\dfrac{4}{13} + 3 \cdot \dfrac{1}{13} \end{pmatrix} \\ &= \begin{pmatrix} -\dfrac{5}{13} + \dfrac{6}{13} & \dfrac{4}{13} + \dfrac{3}{13} \end{pmatrix} \\ &= \begin{pmatrix} \dfrac{1}{13} & \dfrac{7}{13} \end{pmatrix} \end{align} \]

コンピュータで答え合わせ。

GNU Octaveでは次のように計算することができる。det()関数は行列式を出力し、inv()関数は逆行列を出力する。

$ octave
GNU Octave, version 4.4.1
（中略）
>> A = [-1,3]
A =

  -1   3

>> B = [1,4;-2,5]
B =

   1   4
  -2   5

>> det(B)
ans =  13
>> B * inv(B)
ans =

   1   0
   0   1

>> inv(B) * B
ans =

   1   0
   0   1

>> A * inv(B)
ans =

   0.076923   0.538462

>> 1 / 13
ans =  0.076923
>> 7 / 13
ans =  0.53846
>> quit()

Maximaでは次のように計算できる。Maximaでは非可換性乗法にはドット演算子を使う。

$ maxima
Maxima 5.42.1 http://maxima.sourceforge.net
（中略）
(%i1) A: matrix([-1,3]);
(%o1)                             [ - 1  3 ]
(%i2) B: matrix([1,4],[-2,5]);
                                  [  1   4 ]
(%o2)                             [        ]
                                  [ - 2  5 ]
(%i3) B . invert(B);
                                   [ 1  0 ]
(%o3)                              [      ]
                                   [ 0  1 ]
(%i4) invert(B) . B;
                                   [ 1  0 ]
(%o4)                              [      ]
                                   [ 0  1 ]
(%i5) A . invert(B);
                                  [ 1   7  ]
(%o5)                             [ --  -- ]
                                  [ 13  13 ]
(%i6) float(A . invert(B));
(%o6)             [ 0.07692307692307693  0.5384615384615384 ]
(%i7) quit();

まとめ

逆数: 英語でa multiplicative inverseのこと。aの逆数xは$ x = 1 \div a $によって得られる。aを分数に直してその分母と分子をひっくり返しても得られる。; \[ a = \dfrac{a}{1} \rightarrow \dfrac{1}{a} \]

単位元: ある演算システムにおいて他の数を変化させることがない数。中立元とも同一元とも言える数。英語ではan identity elementのこと。足し算では0が単位元。英語ではthe additive identity。掛け算では1が単位元。英語ではthe multiplicative identity。; \[ a + 0 = 0 + a = a \] \[ a \times 1 = 1 \times a = a \]

正方行列: 列の数と行の数とが等しい行列。正方形のような形をしている。英語ではa square matrix。; \[ A = \begin{pmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ a_{31} & a_{32} & \cdots & a_{3n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{n1} & a_{n2} & \cdots & a_{nn} \end{pmatrix} \]; 行列を表すときに通常は、最終の列番号をmで、最終の行番号をnで表すことが多いが、正方行列では$ m = n $となるので、ここではどちらもnで表している。

n次の正方行列: 列数がnで、行数がnの正方行列は、n次の正方行列と呼ばれている。Aを正方行列とすると、$ A_n $のように添字で表記されることがある。

行列式: 各々の正方行列から計算することができる一意のスカラー。その値が0の場合もある。ある正方行列を与えるとそれに対応する一意の実数か一意の複素数を出力する函数であると考えることができる。; 正方行列を$ A $とすると、その行列式は$ |A| $や$ det\ A $やdet(A)のように表記されることがある。detは英語のa determinantの略記。; 2次の正方行列$ A = \begin{pmatrix} a_{11} & a_{12} \\ a_{21} & a_{22} \end{pmatrix} $の行列式は$ A^{-1} = a_{11}a_{22} - a_{12}a_{21} $と計算することができ、これが行列式の基本となる。; Maximaではdeterminant()函数に、GNU Octaveではdet()函数に、Juliaではusing LinearAlgebraを宣言しておいてdet()函数に、R言語ではdet()函数に、Python3ではnumpyをインポートしておいてnumpy.linalg.det()函数に、正方行列を渡せば行列式を出力してくれる。

スカラー: 線形代数においてベクトルや行列やテンソルでない単独の数の総称。英語ではa scalar。実数か複素数。行列式や行列のスカラー倍で使われる。

ラプラス展開（線形代数における）: 3次以上の正方行列の行列式を計算するために2次の正方行列の行列式の形になるまでそれを展開してゆく方法。余因子展開とも呼ばれている。英語ではthe Laplace expansion、もしくはthe cofactor expansion。; 正方行列のどれか1つの行か列を選んでその各成分についての小行列式$ M_{ij} $を求め、その小行列式に1か-1を一定の規則に従って掛けること（$ (-1)^{i+j} M_{ij} $）によって正負の符号を持つ余因子$ C_{ij} $を作り、その余因子に元の成分を掛ける（$ a_{ij}C_{ij} $）。1つの実数か複素数の値が得られるまでそれらの処理を繰り返しながら次々と合計してゆく。何番目の列または行に沿った小行列による行列式のラプラス展開と言い表したりする。; \[ |A| = \sum_{j=1}^n a_{ij} (-1)^{i+j} M_{ij} = \sum_{i=1}^n a_{ij} (-1)^{i+j} M_{ij} \]; どの列またはどの行を選んでも同じ計算結果が得られることが定理として証明されている。

サラスのルール

3次の正方行列限定の行列式計算法。サラスの規則、サラスの法則、サラスの方法などとも呼ばれている。英語ではthe rule of SarrusないしSarrus' rule。日本でよく目にする「たすき掛け」と呼ばれている方法もこれの一種。

3次の正方行列の1列目と2列目をコピーして3列目の右隣に貼り付ける。
左上から右下への対角線上の成分を掛けて3つの項を作る。
次に右上から左下への対角線上の成分を掛けて3つの項を作る。
前者の3つの項に正の符号を与え、後者の3つの項には負の符号を与える。
それらを合計すると、その3次正方行列の行列式が求まる。

これを修正してn次の正方行列にも応用できるようにする試みがあるようだ。

逆行列: 逆数の行列版のようなもの。英語ではan inverse matrixと呼ばれている。; 全ての正則行列にはその逆行列がある。逆行列は正則行列の転置後の余因子行列の各成分を正則行列の行列式で割ったもの。つまり、正則行列をAとし、Aの逆行列を$ A^{-1} $とし、転置された余因子行列を$ adj\ A $とし、Aの行列式を$ det\ A $とすると次の関係が成り立つ。; \[ A^{-1} = \dfrac{adj\ A}{det\ A} = \dfrac{1}{det\ A} adj\ A \]; Maximaではinvert()函数に、GNU Octaveではinv()函数に、Juliaではinv()函数に、Python3ではNumpyをインポートしてからnumpy.linalg.inv()函数に、R言語ではinv()函数に、正則行列を渡せばその逆行列を出力してくれる。ただしR言語ではmatlibというライブラリが必要になる。

正則行列: 正方行列で、かつ、その行列式の値が0でない行列のこと。可逆であるとか非特異であるとも呼ばれている。正則行列だけがその逆行列を持っている。英語ではan invertible matrix。

単位行列: 対角行列の内のひとつ。行列の成分の主対角線上、つまり$ a_{11} $から$ a_{nn} $にかけて1が並び、その他の成分が0であるような正方行列のこと。$ I $で表す。次元数は$ I_n $のnに数を代入して表す。英語ではan identity matrixと呼ばれている。; \[ I_n = \begin{pmatrix} 1 & 0 & 0 & 0 & \cdots & 0 \\ 0 & 1 & 0 & 0 & \cdots & 0 \\ 0 & 0 & 1 & 0 & \cdots & 0 \\ 0 & 0 & 0 & 1 & \cdots & 0 \\ \vdots & \vdots & \vdots & \vdots & \ddots & \vdots \\ 0 & 0 & 0 & 0 & \cdots & 1 \end{pmatrix} \]; 単位行列は行列同士の非可換性の乗法における単位元に当たる行列。; 正則行列にその逆行列を掛けると単位行列が得られ、この場合に限って交換法則が成り立つことから、逆行列の検算に用いることができる。正則行列をAとし、Aの逆行列を$ A^{-1} $とし、単位行列を$ I $とすると次の関係が成り立つ。; \[ A A^{-1} = A^{-1} A = I \]

余因子: 正方行列の成分をラプラス展開して得られた小行列式$ M_{ij} $に1または-1のいずれかを規則に従って掛けたもの。英語ではa cofactor。; 1を掛けるか-1を掛けるかは$ (-1)^{i+j} $によって定まる。iは列番号、jは行番号。1を掛けても小行列式の正負の符号はそのままだが、-1を掛けると小行列式の正負の符号が反転することに注目。; 余因子は、Aを正方行列だとすると、$ cof\ A $やcof(A)、またはCと表記されることがある。; \[ \begin{align} cof\ A = C = (-1)^{i + j} M_ij \end{align} \]

余因子行列: 2つの意味がある。1つは正方行列の各成分をその余因子（小行列式に1か-1を掛けたもの）によって置き換えた行列のこと。これは英語でa cofactor matrixと呼ばれているもの。もう1つの意味はa cofactor matrixを転置した行列のこと。転置は英語でtranspose。転置後の余因子行列は英語ではan adjugate matrixと呼ばれている。; An adjugate matrixはa classical adjoint matrixとも呼ばれていることがある。数式処理システムのMaxiamではこの意味で函数名としてadjointという呼び名が使われている。; 転置した後の余因子行列の各成分を元の正方行列の行列式で割ると逆行列が得られる。転置前の余因子行列は$ cof\ A $やcof(A)、または$ C $と記すことができ、転置後の余因子行列は$ adj\ A $やadj(A)、または$ C^T $と記すことができる。; 例えば、2次の正方行列の余因子行列は次のようになる。; \[ \begin{align} cof \begin{pmatrix} a_{11} & a_{12} \\ a_{21} & a_{22} \end{pmatrix} &= C_2 \\ &= \begin{pmatrix} a_{22} & a_{21} \\ a_{12} & a_{11} \end{pmatrix} \circ \begin{pmatrix} 1 & -1 \\ -1 & 1 \end{pmatrix} \\ &= \begin{pmatrix} 1 \cdot a_{22} & -1 \cdot a_{21} \\ -1 \cdot a_{12} & 1 \cdot a_{11} \end{pmatrix} \\ &= \begin{pmatrix} a_{22} & -a_{21} \\ -a_{12} & a_{11} \end{pmatrix} \end{align} \]; 小行列式からなる行列から余因子の行列を求める場合、小行列の行列の各成分と1と-1とがチェッカー・フラック状に並ぶ行列の各成分とを成分ごとにスカラー倍するアダマール積を用いることができる。アダマール積の演算子は$ \circ $か$ \odot $。; これを転置すると次のようになる。; \[ adj \begin{pmatrix} a_{11} & a_{12} \\ a_{21} & a_{22} \end{pmatrix} = C^T_2 = \begin{pmatrix} a_{22} & -a_{12} \\ -a_{21} & a_{11} \end{pmatrix} \]; 転置された余因子行列は、数式処理システムMaximaではadjoint()函数で得られ、GNU OctaveとJuliaではAが正方行列の場合にdet(A) * inv(A)という式で得られるが、Juliaではdet()函数を使うためにusing LinearAlgebraの指定が必要。R言語ではadjoint()函数を用いることができるが、そのためにはmatlibというパッケージが必要になる。; det(A) * inv(A)により、転置された余因子行列がなぜ得られるかは、逆行列を導く演算の逆演算だと考えればいいかもしれない。

小行列: ラプラス展開（別名：余因子展開）の手続きの途中で得られる行列の中の部分行列のこと。

小行列式: 小行列の行列式。英語ではa minor。ラプラス展開の過程で生ずる部分行列の行列式。; Maximaで小行列式を求めるには例えばminor(A,1,1)函数を利用できる。第1引数のAは行列、第2引数の1は列番号、第3引数の1は行番号。この例ではAという正方行列の$ a_{11} $の小行列式を求めている。

行列同士の除法: 行列同士の除法は未定義とされることがあるが、特定の条件の下では成り立つ。除算行列に逆行列があれば、つまり除算行列が正則行列であるならばその除算行列を逆行列に変換し、逆行列の乗法に直して計算することができる。; \[ A \div B = A \cdot B^{-1} \]

速さ、時間、距離の関係、及び除数や分母が未知数の方程式

2021-04-14T19:47:00.011+09:00

速さの平均へいきん、距離きょり、時間じかんの関係は次のとおり。距離は道のりと呼ばれることもある。

\begin{align*} 速さの平均 &= 距離 \div 時間 \\ 時間 &= 距離 \div 速さの平均 \\ 距離 &= 速さの平均 \times 時間 \end{align*}

速さの平均とは？: 距離をかかった時間で割ったもの。時間分の距離。

かかった時間とは？: 距離を速さの平均で割ったもの。速さの平均分の距離。

距離とは？: 速さの平均をかかった時間倍ばいしたもの、または、かかった時間を速さの平均倍したもの。

ただし、速さの平均、時間、距離には、その計り方の目盛りになる各々の単位がそれぞれ付く。時間の単位は例えば秒(s)、分(m)、時間(h)など。距離の単位はメートル法を用いるならば例えばメートル(m)とかキロメートル(km)など。速さの平均の単位は例えば時速何キロメートル（km/h）、秒速何メートル(m/s)など。

方程式を使って代数的に解く

方程式ほうていしきの解き方が分かっている場合、これら3つの関係式を3つとも覚える必要はないかもしれない。方程式とは式の答えは分かっているがその式の一部の数が欠けているような式のこと。欠けている数は未知数みちすうと呼ばれ、それを文字に置き換えて代数だいすう的なやり方で解く。

例えば次のような式が方程式。$ x $が未知数。

\[ x + 5 = 10 \] \[ \colorbox{yellow}{$10 - x = 5$} \] \[ 2x = 10 \] \[ \dfrac{x}{2} = \dfrac{5}{2} \] \[ \colorbox{yellow}{$\dfrac{25}{x} = 5$} \]

黄色く色付けされている方程式は少し見馴れないかもしれない。1つは引き算の引く数が未知数であり、もう1つは分母が未知数である方程式。

黄色く色付けされていない方程式は移項いこうという方法によって解くことができる。これは未知数が属す辺から未知数以外の定数を取り除くために逆演算を使う。逆演算とは足し算に対する引き算、引き算に対する足し算、掛け算に対する割り算、割り算に対する足し算のこと。

方程式は両辺が常に等しくなる必要があるので両辺に必ず同じ演算を施す。この処理を簡略化したものが移項。定数とその演算が片方の辺からもう片方の辺に移動したときに逆演算になることに注目。

では上記の方程式を移項という方法を使って具体的に解いてみる。

左辺では5を足しているので右辺では5を引く。

\begin{align*} x \colorbox{cyan}{+ 5} &= 10 \\ x &= 10 \colorbox{pink}{- 5} \\ x &= 5 \end{align*}

左辺では2を掛けているので右辺では2で割る。

\begin{align*} \colorbox{cyan}{2}x &= 10 \\ x &= 10 \colorbox{pink}{$ \div 2 $} \\ x &= 5 \end{align*}

左辺では2で割っているので右辺では2を掛ける。

\begin{align*} \dfrac{x}{2} &= \dfrac{5}{2} \\ x \colorbox{cyan}{$ \div 2 $} &= \dfrac{5}{2} \\ x &= \dfrac{5 \colorbox{pink}{$ \cdot 2 $}}{2} \\ x &= \dfrac{10}{2} \\ x &= \dfrac{5}{1} = 5 \end{align*}

黄色く色付けされた方程式では移項を用いない。xと右辺の値をただ交換するだけ。

\begin{align*} 10 - \colorbox{cyan}{$ x $} &= \colorbox{pink}{5} \\ 10 - \colorbox{pink}{5} &= \colorbox{cyan}{$ x $} \\ 5 &= x \end{align*}

\begin{align*} \dfrac{25}{\colorbox{cyan}{$ x $}} &= \colorbox{pink}{5} \\ \dfrac{25}{\colorbox{pink}{5}} &= \colorbox{cyan}{$ x $} \\ \dfrac{5}{1} &= x \\ 5 &= x \end{align*}

数式処理システムMaximaでこれらの方程式を解くにはsolve(方程式,未知数)函数かんすうを用いることができる。

$ maxima
Maxima 5.42.1 http://maxima.sourceforge.net
（中略）
(%i1) solve(x+5=10,x);
(%o1)                               [x = 5]
(%i2) solve(10-x=5,x);
(%o2)                               [x = 5]
(%i3) solve(2*x=10,x);
(%o3)                               [x = 5]
(%i4) solve(x/2=5/2,x);
(%o4)                               [x = 5]
(%i5) solve(25/x=5,x);
(%o5)                               [x = 5]
(%i6) quit();

いずれも$ x = 5 $であることが分かった。

方程式の解き方を分かっていれば、例えば速さの平均が次のような関係を持っていることを知っているだけで十分。

\[ 速さの平均 = \dfrac{距離}{時間} \]

速さの平均が毎時4kmで5時間歩いたとき、どれだけの距離を歩いたか知るためには方程式に次のように値を代入してそれを解く。距離を未知数のdで表すことにする。

\begin{align*} 4 &= \dfrac{d}{\colorbox{cyan}{5}} \\ 4 \colorbox{pink}{$\times$ 5} &= d \\ 20 &= d \end{align*}

この方程式の右辺の5を左辺に移項することによって$ d = 20 $という解が得られた。よって距離は20km。

速さの平均が毎時15kmで300kmの距離を移動したとき、どれだけの時間tを要したかを知りたければ、方程式に次のように値を代入してそれを解く。時間を未知数のtで表すことにする。

\begin{align*} 15 &= \dfrac{300}{t} \\ t &= \dfrac{300}{15} \\ t &= \dfrac{20}{1} \\ t &= 20 \end{align*}

これは分母に未知数がある方程式なので移項を用いないで解くことができた。かかる時間は20時間。

MariaDBかMySQLでSELECTステートメント色々 - その1

2021-02-07T04:02:00.006+09:00

この記事で使用しているソフトウェア環境は、OSとしてDebian GNU/Linux 10を使用し、その公式リポジトリからMariaDBというデータベースをインストールしてある。

$ cat /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
...
$ mariadb --version
mariadb  Ver 15.1 Distrib 10.3.27-MariaDB, for debian-linux-gnu (x86_64) using readline 5.2

しかし、記事内容のほとんどはSQLに関するものであり、オペレーティング・システムの環境には依存しないはず。

データを選び出すSELECT構文

SELECT構文はその名のとおり、1つまたは2つ以上のデータベース・テーブルからデータを選択して取得するために用いることができる。FROM句ではその対象とするテーブル名を1つまたは2つ以上指定することができる。

SELECT構文のもっとも単純な形式は次のようになる。

SELECT レコード名1,レコード名2,...
FROM テーブル名1,テーブル名2,...;

SELECT構文はSQLなので構文の終わりに文末を示す;（セミコロン）が必要。

多くの場合、テーブル全体を選択するためにレコード名の代わりに*（アスタリスク）が用いられている。

SELECT * FROM テーブル名;

レコードを絞り込んで選ぶにはWHERE句に条件式を指定する。

SELECT レコード名1,レコード名2,...
FROM テーブル名1,テーブル名2,...
WHERE 条件式;

等価演算子

もっとも単純な条件式は「レコード名 = 値」のようなものになる。*（アスタリスク）は全てを意味する。SELECT *は全ての列（レコード）。

SELECT *
FROM テーブル名
WHERE レコード名 = 値;

=（イコール）は等価演算子と呼ばれている。値が数値型以外では'（一重引用符）で挟む必要がある。

MariaDB [mydatabase]> SELECT * FROM persons;
+----+-----------+-----------+--------+------------+--------+--------+
| id | 姓        | 名        | 性別   | 生年月日   | 身長   | 体重   |
+----+-----------+-----------+--------+------------+--------+--------+
|  1 | 足利      | 直美      | 女     | 1997-10-11 |  164.7 |     55 |
|  2 | 大岩      | 舞        | 女     | 2002-03-23 |  158.4 |   43.5 |
|  3 | 木下      | 誠一      | 男     | 1995-07-15 |  168.5 |   65.5 |
|  4 | 伊藤      | エリナ    | 女     | 1996-09-29 |    162 |   50.5 |
|  5 | 野村      | 一樹      | 男     | 1999-05-20 |  172.5 |   68.7 |
|  6 | 山本      | 花梨      | 女     | 2005-12-03 |  158.8 |   42.5 |
|  7 | 小野田    | 真司      | 男     | 1988-11-12 |  165.5 |     64 |
|  8 | 的山      | 美麗      | 女     | 1985-07-02 |  164.5 |   50.5 |
|  9 | 桑村      | 涼        | 男     | 1993-03-18 |    165 |   60.3 |
| 10 | 新見      | 康隆      | 男     | 1989-06-30 |  177.6 |   70.6 |
| 11 | 山田      | 真理子    | 女     | 1991-01-03 |  155.8 |   40.8 |
| 12 | 田辺      | 春        | 男     | 2000-03-15 |    182 |   78.5 |
+----+-----------+-----------+--------+------------+--------+--------+
12 rows in set (0.000 sec)

MariaDB [mydatabase]> SELECT * FROM persons
    -> WHERE 性別 = '女';
+----+--------+-----------+--------+------------+--------+--------+
| id | 姓     | 名        | 性別   | 生年月日   | 身長   | 体重   |
+----+--------+-----------+--------+------------+--------+--------+
|  1 | 足利   | 直美      | 女     | 1997-10-11 |  164.7 |     55 |
|  2 | 大岩   | 舞        | 女     | 2002-03-23 |  158.4 |   43.5 |
|  4 | 伊藤   | エリナ    | 女     | 1996-09-29 |    162 |   50.5 |
|  6 | 山本   | 花梨      | 女     | 2005-12-03 |  158.8 |   42.5 |
|  8 | 的山   | 美麗      | 女     | 1985-07-02 |  164.5 |   50.5 |
| 11 | 山田   | 真理子    | 女     | 1991-01-03 |  155.8 |   40.8 |
+----+--------+-----------+--------+------------+--------+--------+
6 rows in set (0.000 sec)

不等価演算子

WHERE句の条件式のところで=という演算子の代わりに!=もしくは<>という演算子を用いると、その値を除くという意味になる。これらは不等価演算子と呼ばれている。下の例では「性別が女に等しくない」という条件を表している。

MariaDB [mydatabase]> SELECT * FROM persons
    -> WHERE 性別 != '女';
+----+-----------+--------+--------+------------+--------+--------+
| id | 姓        | 名     | 性別   | 生年月日   | 身長   | 体重   |
+----+-----------+--------+--------+------------+--------+--------+
|  3 | 木下      | 誠一   | 男     | 1995-07-15 |  168.5 |   65.5 |
|  5 | 野村      | 一樹   | 男     | 1999-05-20 |  172.5 |   68.7 |
|  7 | 小野田    | 真司   | 男     | 1988-11-12 |  165.5 |     64 |
|  9 | 桑村      | 涼     | 男     | 1993-03-18 |    165 |   60.3 |
| 10 | 新見      | 康隆   | 男     | 1989-06-30 |  177.6 |   70.6 |
| 12 | 田辺      | 春     | 男     | 2000-03-15 |    182 |   78.5 |
+----+-----------+--------+--------+------------+--------+--------+
6 rows in set (0.000 sec)

MariaDB [mydatabase]> SELECT * FROM persons
    -> WHERE 性別 <> '男';
+----+--------+-----------+--------+------------+--------+--------+
| id | 姓     | 名        | 性別   | 生年月日   | 身長   | 体重   |
+----+--------+-----------+--------+------------+--------+--------+
|  1 | 足利   | 直美      | 女     | 1997-10-11 |  164.7 |     55 |
|  2 | 大岩   | 舞        | 女     | 2002-03-23 |  158.4 |   43.5 |
|  4 | 伊藤   | エリナ    | 女     | 1996-09-29 |    162 |   50.5 |
|  6 | 山本   | 花梨      | 女     | 2005-12-03 |  158.8 |   42.5 |
|  8 | 的山   | 美麗      | 女     | 1985-07-02 |  164.5 |   50.5 |
| 11 | 山田   | 真理子    | 女     | 1991-01-03 |  155.8 |   40.8 |
+----+--------+-----------+--------+------------+--------+--------+
6 rows in set (0.000 sec)

IN()函数とNOT IN()函数

等価演算子の=（イコール）の右辺を複数の値にしたい場合、等価演算子の代わりにIN()函数を用いることができる。下の例では、「名」として「舞」「エリナ」「真司」「春」を指定しているので、そのいずれかと一致する名を持つ列（レコード）が全て選び出されている。

MariaDB [mydatabase]> SELECT * FROM persons
    -> WHERE 名 IN('舞','エリナ','真司','春');
+----+-----------+-----------+--------+------------+--------+--------+
| id | 姓        | 名        | 性別   | 生年月日   | 身長   | 体重   |
+----+-----------+-----------+--------+------------+--------+--------+
|  2 | 大岩      | 舞        | 女     | 2002-03-23 |  158.4 |   43.5 |
|  4 | 伊藤      | エリナ    | 女     | 1996-09-29 |    162 |   50.5 |
|  7 | 小野田    | 真司      | 男     | 1988-11-12 |  165.5 |     64 |
| 12 | 田辺      | 春        | 男     | 2000-03-15 |    182 |   78.5 |
+----+-----------+-----------+--------+------------+--------+--------+
4 rows in set (0.000 sec)

IN()函数の代わりにNOT IN()函数を用いるとその引数に指定した値を除くという条件になる。

MariaDB [mydatabase]> SELECT * FROM persons;
+----+-----------+-----------+--------+------------+--------+--------+
| id | 姓        | 名        | 性別   | 生年月日   | 身長   | 体重   |
+----+-----------+-----------+--------+------------+--------+--------+
|  1 | 足利      | 直美      | 女     | 1997-10-11 |  164.7 |     55 |
|  2 | 大岩      | 舞        | 女     | 2002-03-23 |  158.4 |   43.5 |
|  3 | 木下      | 誠一      | 男     | 1995-07-15 |  168.5 |   65.5 |
|  4 | 伊藤      | エリナ    | 女     | 1996-09-29 |    162 |   50.5 |
|  5 | 野村      | 一樹      | 男     | 1999-05-20 |  172.5 |   68.7 |
|  6 | 山本      | 花梨      | 女     | 2005-12-03 |  158.8 |   42.5 |
|  7 | 小野田    | 真司      | 男     | 1988-11-12 |  165.5 |     64 |
|  8 | 的山      | 美麗      | 女     | 1985-07-02 |  164.5 |   50.5 |
|  9 | 桑村      | 涼        | 男     | 1993-03-18 |    165 |   60.3 |
| 10 | 新見      | 康隆      | 男     | 1989-06-30 |  177.6 |   70.6 |
| 11 | 山田      | 真理子    | 女     | 1991-01-03 |  155.8 |   40.8 |
| 12 | 田辺      | 春        | 男     | 2000-03-15 |    182 |   78.5 |
+----+-----------+-----------+--------+------------+--------+--------+
12 rows in set (0.000 sec)

MariaDB [mydatabase]> SELECT * FROM persons
    -> WHERE 姓 NOT IN('大岩','伊藤','山本','桑村','田辺');
+----+-----------+-----------+--------+------------+--------+--------+
| id | 姓        | 名        | 性別   | 生年月日   | 身長   | 体重   |
+----+-----------+-----------+--------+------------+--------+--------+
|  1 | 足利      | 直美      | 女     | 1997-10-11 |  164.7 |     55 |
|  3 | 木下      | 誠一      | 男     | 1995-07-15 |  168.5 |   65.5 |
|  5 | 野村      | 一樹      | 男     | 1999-05-20 |  172.5 |   68.7 |
|  7 | 小野田    | 真司      | 男     | 1988-11-12 |  165.5 |     64 |
|  8 | 的山      | 美麗      | 女     | 1985-07-02 |  164.5 |   50.5 |
| 10 | 新見      | 康隆      | 男     | 1989-06-30 |  177.6 |   70.6 |
| 11 | 山田      | 真理子    | 女     | 1991-01-03 |  155.8 |   40.8 |
+----+-----------+-----------+--------+------------+--------+--------+
7 rows in set (0.000 sec)

左不等価演算子と右不等価演算子

次の例ではWHERE句の条件式に小なり（<）／大なり（>）を利用している。<は左不等価演算子と呼ばれ、>は右不等価演算子と呼ばれている。

MariaDB [mydatabase]> SELECT * FROM persons
    -> WHERE 身長 < 165;
+----+--------+-----------+--------+------------+--------+--------+
| id | 姓     | 名        | 性別   | 生年月日   | 身長   | 体重   |
+----+--------+-----------+--------+------------+--------+--------+
|  1 | 足利   | 直美      | 女     | 1997-10-11 |  164.7 |     55 |
|  2 | 大岩   | 舞        | 女     | 2002-03-23 |  158.4 |   43.5 |
|  4 | 伊藤   | エリナ    | 女     | 1996-09-29 |    162 |   50.5 |
|  6 | 山本   | 花梨      | 女     | 2005-12-03 |  158.8 |   42.5 |
|  8 | 的山   | 美麗      | 女     | 1985-07-02 |  164.5 |   50.5 |
| 11 | 山田   | 真理子    | 女     | 1991-01-03 |  155.8 |   40.8 |
+----+--------+-----------+--------+------------+--------+--------+
6 rows in set (0.000 sec)

MariaDB [mydatabase]> SELECT * FROM persons
    -> WHERE 生年月日 > '1999-12-31';
+----+--------+--------+--------+------------+--------+--------+
| id | 姓     | 名     | 性別   | 生年月日   | 身長   | 体重   |
+----+--------+--------+--------+------------+--------+--------+
|  2 | 大岩   | 舞     | 女     | 2002-03-23 |  158.4 |   43.5 |
|  6 | 山本   | 花梨   | 女     | 2005-12-03 |  158.8 |   42.5 |
| 12 | 田辺   | 春     | 男     | 2000-03-15 |    182 |   78.5 |
+----+--------+--------+--------+------------+--------+--------+
3 rows in set (0.000 sec)

以上演算子と以下演算子

<=（以下）または>=（以上）もある。前者は以下演算子、後者は以上演算子。

MariaDB [mydatabase]> SELECT * FROM persons
    -> WHERE 体重 >= 55;
+----+-----------+--------+--------+------------+--------+--------+
| id | 姓        | 名     | 性別   | 生年月日   | 身長   | 体重   |
+----+-----------+--------+--------+------------+--------+--------+
|  1 | 足利      | 直美   | 女     | 1997-10-11 |  164.7 |     55 |
|  3 | 木下      | 誠一   | 男     | 1995-07-15 |  168.5 |   65.5 |
|  5 | 野村      | 一樹   | 男     | 1999-05-20 |  172.5 |   68.7 |
|  7 | 小野田    | 真司   | 男     | 1988-11-12 |  165.5 |     64 |
|  9 | 桑村      | 涼     | 男     | 1993-03-18 |    165 |   60.3 |
| 10 | 新見      | 康隆   | 男     | 1989-06-30 |  177.6 |   70.6 |
| 12 | 田辺      | 春     | 男     | 2000-03-15 |    182 |   78.5 |
+----+-----------+--------+--------+------------+--------+--------+
7 rows in set (0.000 sec)

>= 55は55を含むので体重が55であるIDが1の名簿も選ばれている。

論理演算子

論理演算子としてANDまたは&&、ORまたは||、そしてXORがある。

次の例では、女であることと生年月日が2000-01-01以降であることを共に満たすことを条件にしている。

MariaDB [mydatabase]> SELECT * FROM persons
    -> WHERE 性別 = '女' AND 生年月日 >= '2000-01-01';
+----+--------+--------+--------+------------+--------+--------+
| id | 姓     | 名     | 性別   | 生年月日   | 身長   | 体重   |
+----+--------+--------+--------+------------+--------+--------+
|  2 | 大岩   | 舞     | 女     | 2002-03-23 |  158.4 |   43.5 |
|  6 | 山本   | 花梨   | 女     | 2005-12-03 |  158.8 |   42.5 |
+----+--------+--------+--------+------------+--------+--------+
2 rows in set (0.001 sec)

次の例では、身長が150より低いか、生年月日が1989-12-31以前か、いずれかを満たせばよいことを条件にしている。

MariaDB [mydatabase]> SELECT * FROM persons
    -> WHERE 身長 < 150 OR 生年月日 <= '1989-12-31';
+----+-----------+--------+--------+------------+--------+--------+
| id | 姓        | 名     | 性別   | 生年月日   | 身長   | 体重   |
+----+-----------+--------+--------+------------+--------+--------+
|  7 | 小野田    | 真司   | 男     | 1988-11-12 |  165.5 |     64 |
|  8 | 的山      | 美麗   | 女     | 1985-07-02 |  164.5 |   50.5 |
| 10 | 新見      | 康隆   | 男     | 1989-06-30 |  177.6 |   70.6 |
+----+-----------+--------+--------+------------+--------+--------+
3 rows in set (0.000 sec)

次の例では、男でかつ生年月日が1990-01-01以前でないか、生年月日が1990-01-01以前でかつ男でないか、いずれかを満たすことを条件にしている。

MariaDB [mydatabase]> SELECT * FROM persons
    -> WHERE 性別 = '男' XOR 生年月日 < '1990-01-01';
+----+--------+--------+--------+------------+--------+--------+
| id | 姓     | 名     | 性別   | 生年月日   | 身長   | 体重   |
+----+--------+--------+--------+------------+--------+--------+
|  3 | 木下   | 誠一   | 男     | 1995-07-15 |  168.5 |   65.5 |
|  5 | 野村   | 一樹   | 男     | 1999-05-20 |  172.5 |   68.7 |
|  8 | 的山   | 美麗   | 女     | 1985-07-02 |  164.5 |   50.5 |
|  9 | 桑村   | 涼     | 男     | 1993-03-18 |    165 |   60.3 |
| 12 | 田辺   | 春     | 男     | 2000-03-15 |    182 |   78.5 |
+----+--------+--------+--------+------------+--------+--------+
5 rows in set (0.000 sec)

XORとは「XOR部分 = OR部分 - AND部分」に相当する。

特定の列（カラム）だけを選び出す

SELECTの後を*（アスタリスク）でなく具体的な列名にすれば、特定の列名だけを選んで出力することができる。

MariaDB [mydatabase]> SELECT 姓,名,性別,生年月日
    -> FROM persons
    -> WHERE 生年月日 < '2000-01-01'
    -> AND 性別 = '男';
+-----------+--------+--------+------------+
| 姓        | 名     | 性別   | 生年月日   |
+-----------+--------+--------+------------+
| 木下      | 誠一   | 男     | 1995-07-15 |
| 野村      | 一樹   | 男     | 1999-05-20 |
| 小野田    | 真司   | 男     | 1988-11-12 |
| 桑村      | 涼     | 男     | 1993-03-18 |
| 新見      | 康隆   | 男     | 1989-06-30 |
+-----------+--------+--------+------------+
5 rows in set (0.000 sec)

BETWEEN...AND...演算子

ある区間を条件にしたいときにはBETWEEN演算子を用いる。次の例では、WHERE句に身長が160から170までの間を条件に指定している。

MariaDB [mydatabase]> SELECT 姓,名,身長
    -> FROM persons
    -> WHERE 身長
    -> BETWEEN 160 AND 170;
+-----------+-----------+--------+
| 姓        | 名        | 身長   |
+-----------+-----------+--------+
| 足利      | 直美      |  164.7 |
| 木下      | 誠一      |  168.5 |
| 伊藤      | エリナ    |    162 |
| 小野田    | 真司      |  165.5 |
| 的山      | 美麗      |  164.5 |
| 桑村      | 涼        |    165 |
+-----------+-----------+--------+
6 rows in set (0.000 sec)

並べ替え（ソート）

SELECT構文にORDER BY句と特定の列名を追加することにより、その列（カラム）を基準に行（レコード）を並べ替えて出力することができる。通常はその列の昇順に並べ替えが行われる。

次の例では、生年月日が古い順（昇順）に名簿を並べ替えている。

MariaDB [mydatabase]> SELECT 姓,名,生年月日
    -> FROM persons
    -> ORDER BY 生年月日;
+-----------+-----------+------------+
| 姓        | 名        | 生年月日   |
+-----------+-----------+------------+
| 的山      | 美麗      | 1985-07-02 |
| 小野田    | 真司      | 1988-11-12 |
| 新見      | 康隆      | 1989-06-30 |
| 山田      | 真理子    | 1991-01-03 |
| 桑村      | 涼        | 1993-03-18 |
| 木下      | 誠一      | 1995-07-15 |
| 伊藤      | エリナ    | 1996-09-29 |
| 足利      | 直美      | 1997-10-11 |
| 野村      | 一樹      | 1999-05-20 |
| 田辺      | 春        | 2000-03-15 |
| 大岩      | 舞        | 2002-03-23 |
| 山本      | 花梨      | 2005-12-03 |
+-----------+-----------+------------+
12 rows in set (0.000 sec)

降順に並べ替えるにはORDER BY句の列名にDESCというキーワードを添える。

MariaDB [mydatabase]> SELECT 姓,名,生年月日
    -> FROM persons
    -> ORDER BY 生年月日DESC;
+-----------+-----------+------------+
| 姓        | 名        | 生年月日   |
+-----------+-----------+------------+
| 山本      | 花梨      | 2005-12-03 |
| 大岩      | 舞        | 2002-03-23 |
| 田辺      | 春        | 2000-03-15 |
| 野村      | 一樹      | 1999-05-20 |
| 足利      | 直美      | 1997-10-11 |
| 伊藤      | エリナ    | 1996-09-29 |
| 木下      | 誠一      | 1995-07-15 |
| 桑村      | 涼        | 1993-03-18 |
| 山田      | 真理子    | 1991-01-03 |
| 新見      | 康隆      | 1989-06-30 |
| 小野田    | 真司      | 1988-11-12 |
| 的山      | 美麗      | 1985-07-02 |
+-----------+-----------+------------+
12 rows in set (0.000 sec)

出力行数を制限する

SELECT構文にLIMIT句を設けることにより、出力される行数（レコード数）を制限することができる。

次の例では、出力行数を20行までとしている。ORDER BY句には総人口の値を指定しているので、昇順、つまり総人口が少ない順に20位まで都道府県が出力される。ただし2019年の時点の値。

MariaDB [mydatabase]> SELECT 男女別,人口,全国都道府県,
    -> 時間軸（年）,value
    -> FROM popu_jp
    -> WHERE 時間軸（年） = '2019年'
    -> AND 人口 = '総人口'
    -> AND 男女別 = '男女計'
    -> ORDER BY value
    -> LIMIT 20;
+-----------+-----------+--------------------+--------------------+-------+
| 男女別    | 人口      | 全国都道府県       | 時間軸（年）       | value |
+-----------+-----------+--------------------+--------------------+-------+
| 男女計    | 総人口    | 鳥取県             | 2019年             |   556 |
| 男女計    | 総人口    | 島根県             | 2019年             |   674 |
| 男女計    | 総人口    | 高知県             | 2019年             |   698 |
| 男女計    | 総人口    | 徳島県             | 2019年             |   728 |
| 男女計    | 総人口    | 福井県             | 2019年             |   768 |
| 男女計    | 総人口    | 山梨県             | 2019年             |   811 |
| 男女計    | 総人口    | 佐賀県             | 2019年             |   815 |
| 男女計    | 総人口    | 和歌山県           | 2019年             |   925 |
| 男女計    | 総人口    | 香川県             | 2019年             |   956 |
| 男女計    | 総人口    | 秋田県             | 2019年             |   966 |
| 男女計    | 総人口    | 富山県             | 2019年             |  1044 |
| 男女計    | 総人口    | 宮崎県             | 2019年             |  1073 |
| 男女計    | 総人口    | 山形県             | 2019年             |  1078 |
| 男女計    | 総人口    | 大分県             | 2019年             |  1135 |
| 男女計    | 総人口    | 石川県             | 2019年             |  1138 |
| 男女計    | 総人口    | 岩手県             | 2019年             |  1227 |
| 男女計    | 総人口    | 青森県             | 2019年             |  1246 |
| 男女計    | 総人口    | 長崎県             | 2019年             |  1327 |
| 男女計    | 総人口    | 奈良県             | 2019年             |  1330 |
| 男女計    | 総人口    | 愛媛県             | 2019年             |  1339 |
+-----------+-----------+--------------------+--------------------+-------+
20 rows in set (0.016 sec)

都道府県の総人口のデータセットは、政府統計のポータルサイトe-Statから借りている。出典は「人口推計 / 2019年10月1日現在」の「都道府県，男女別人口－総人口，日本人人口」。

次の例では、総人口の多い都道府県の順（降順）に10位から30位までを出力している。LIMIT句に10,30と指定することによってそれを実現できる。

MariaDB [mydatabase]> SELECT 男女別,人口,全国都道府県,
    -> 時間軸（年）,value
    -> FROM popu_jp
    -> WHERE 時間軸（年） = '2019年'
    -> AND 人口 = '総人口'
    -> AND 男女別 = '男女計'
    -> ORDER BY value DESC
    -> LIMIT 10,30;
+-----------+-----------+--------------------+--------------------+-------+
| 男女別    | 人口      | 全国都道府県       | 時間軸（年）       | value |
+-----------+-----------+--------------------+--------------------+-------+
| 男女計    | 総人口    | 静岡県             | 2019年             |  3644 |
| 男女計    | 総人口    | 茨城県             | 2019年             |  2860 |
| 男女計    | 総人口    | 広島県             | 2019年             |  2804 |
| 男女計    | 総人口    | 京都府             | 2019年             |  2583 |
| 男女計    | 総人口    | 宮城県             | 2019年             |  2306 |
| 男女計    | 総人口    | 新潟県             | 2019年             |  2223 |
| 男女計    | 総人口    | 長野県             | 2019年             |  2049 |
| 男女計    | 総人口    | 岐阜県             | 2019年             |  1987 |
| 男女計    | 総人口    | 群馬県             | 2019年             |  1942 |
| 男女計    | 総人口    | 栃木県             | 2019年             |  1934 |
| 男女計    | 総人口    | 岡山県             | 2019年             |  1890 |
| 男女計    | 総人口    | 福島県             | 2019年             |  1846 |
| 男女計    | 総人口    | 三重県             | 2019年             |  1781 |
| 男女計    | 総人口    | 熊本県             | 2019年             |  1748 |
| 男女計    | 総人口    | 鹿児島県           | 2019年             |  1602 |
| 男女計    | 総人口    | 沖縄県             | 2019年             |  1453 |
| 男女計    | 総人口    | 滋賀県             | 2019年             |  1414 |
| 男女計    | 総人口    | 山口県             | 2019年             |  1358 |
| 男女計    | 総人口    | 愛媛県             | 2019年             |  1339 |
| 男女計    | 総人口    | 奈良県             | 2019年             |  1330 |
| 男女計    | 総人口    | 長崎県             | 2019年             |  1327 |
| 男女計    | 総人口    | 青森県             | 2019年             |  1246 |
| 男女計    | 総人口    | 岩手県             | 2019年             |  1227 |
| 男女計    | 総人口    | 石川県             | 2019年             |  1138 |
| 男女計    | 総人口    | 大分県             | 2019年             |  1135 |
| 男女計    | 総人口    | 山形県             | 2019年             |  1078 |
| 男女計    | 総人口    | 宮崎県             | 2019年             |  1073 |
| 男女計    | 総人口    | 富山県             | 2019年             |  1044 |
| 男女計    | 総人口    | 秋田県             | 2019年             |   966 |
| 男女計    | 総人口    | 香川県             | 2019年             |   956 |
+-----------+-----------+--------------------+--------------------+-------+
30 rows in set (0.001 sec)

今回はここまで。

まとめ

SELECT構文の基本: SELECT 列名 FROM テーブル名;; SELECT 列名1,列名2,... FROM テーブル名1,テーブル名2,...;; 例えば列名にワイルドカードとして*（アスタリスク）を用いると、全ての列が選択される。この用法はもっとも多く用いられている。; SELECT * FROM テーブル名;

条件句を設ける: SELECT 列名 FROM テーブル名 WHERE 列名 = 値;; 値が数値型以外の場合は'（一重引用符）で挟む必要がある。; SELECT 列名 FROM テーブル名 WHERE 列名 = '値';; !（感嘆符）によって等価演算子=を否定することができる。; SELECT 列名 FROM テーブル名 WHERE 列名 != '値';

「列名 = 複数の値」を指定したいとき: 等価演算子の代わりにIN()函数を使う。; SELECT 列名 FROM テーブル名 WHERE 列名 IN(値1,値2,...);; NOT IN()函数を用いると「それらを除く」という条件を指定できる。; SELECT 列名 FROM テーブル名 WHERE 列名 NOT IN(値1,値2,...);

条件式に比較演算子を使うことができる: SELECT 列名 FROM テーブル名 WHERE 列名 > 値;; SELECT 列名 FROM テーブル名 WHERE 列名 < 値;; >=は以上を意味し、<=は以下を意味する。; SELECT 列名 FROM テーブル名 WHERE 列名 >= 値;; SELECT 列名 FROM テーブル名 WHERE 列名 <= 値;

値が数値型でない場合は'値'のように一重引用符を使って挟む必要がある。

条件式は論理演算子を使って複数指定可能: SELECT 列名 FROM テーブル名 WHERE 条件1 AND 条件2 AND ...;; SELECT 列名 FROM テーブル名 WHERE 条件1 OR 条件2 OR ...;; SELECT 列名 FROM テーブル名 WHERE 条件1 AND 条件2 OR ...;; XOR演算子は排他的なOR演算子。ORの集合からANDの集合を差し引いた残りがXORの集合になる。XOR = OR - AND。; SELECT 列名 FROM テーブル名 WHERE 条件1 XOR 条件2;

ある値から別の値までを条件式にする: SELECT 列名 FROM テーブル名 WHERE BETWEEN 値1 AND 値2;

特定の列に基づく行（レコード）の並べ替え（昇順）: SELECT 列名 FROM テーブル名 ORDER BY 列名;

特定の列に基づく行（レコード）の並べ替え（降順）: SELECT 列名 FROM テーブル名 ORDER BY 列名 DESC;

出力行数を制限する: SELECT 列名 FROM テーブル名 LIMIT 最大行数;; カンマで区切って2つ数値を並べると「何行目から何行目まで」という意味になる。; SELECT 列名 FROM テーブル名 LIMIT 行目1, 行目2;

MariaDBをDebian GNU/Linux 10にインストールして使うまでの準備
MariaDBかMySQLでmysqlシェルを用いてテーブル作成
e-Statの統計データをデータベース（MariaDB）に取り込む

°	rad	turn	gon
0	0	0	0
15	\( \dfrac{15}{180}\pi \)	\( \dfrac{15}{360} \)	\( \dfrac{15}{90} \cdot 100 \)
30	\( \dfrac{30}{180}\pi \)	\( \dfrac{30}{360} \)	\( \dfrac{30}{90} \cdot 100 \)
45	\( \dfrac{45}{180}\pi \)	\( \dfrac{45}{360} \)	\( \dfrac{45}{90} \cdot 100 \)
60	\( \dfrac{60}{180}\pi \)	\( \dfrac{60}{360} \)	\( \dfrac{60}{90} \cdot 100 \)
75	\( \dfrac{75}{180}\pi \)	\( \dfrac{75}{360} \)	\( \dfrac{75}{90} \cdot 100 \)
90	\( \dfrac{90}{180}\pi \)	\( \dfrac{90}{360} \)	\( \dfrac{90}{90} \cdot 100 \)
105	\( \dfrac{105}{180}\pi \)	\( \dfrac{105}{360} \)	\( \dfrac{105}{90} \cdot 100 \)
120	\( \dfrac{120}{180}\pi \)	\( \dfrac{120}{360} \)	\( \dfrac{120}{90} \cdot 100 \)
135	\( \dfrac{135}{180}\pi \)	\( \dfrac{135}{360} \)	\( \dfrac{135}{90} \cdot 100 \)
150	\( \dfrac{150}{180}\pi \)	\( \dfrac{150}{360} \)	\( \dfrac{150}{90} \cdot 100 \)
165	\( \dfrac{165}{180}\pi \)	\( \dfrac{165}{360} \)	\( \dfrac{165}{90} \cdot 100 \)
180	\( \dfrac{180}{180}\pi \)	\( \dfrac{180}{360} \)	\( \dfrac{180}{90} \cdot 100 \)
195	\( \dfrac{195}{180}\pi \)	\( \dfrac{195}{360} \)	\( \dfrac{195}{90} \cdot 100 \)
210	\( \dfrac{210}{180}\pi \)	\( \dfrac{210}{360} \)	\( \dfrac{210}{90} \cdot 100 \)
225	\( \dfrac{225}{180}\pi \)	\( \dfrac{225}{360} \)	\( \dfrac{225}{90} \cdot 100 \)
240	\( \dfrac{240}{180}\pi \)	\( \dfrac{240}{360} \)	\( \dfrac{240}{90} \cdot 100 \)
255	\( \dfrac{255}{180}\pi \)	\( \dfrac{255}{360} \)	\( \dfrac{255}{90} \cdot 100 \)
270	\( \dfrac{270}{180}\pi \)	\( \dfrac{270}{360} \)	\( \dfrac{270}{90} \cdot 100 \)
285	\( \dfrac{285}{180}\pi \)	\( \dfrac{285}{360} \)	\( \dfrac{285}{90} \cdot 100 \)
300	\( \dfrac{300}{180}\pi \)	\( \dfrac{300}{360} \)	\( \dfrac{300}{90} \cdot 100 \)
315	\( \dfrac{315}{180}\pi \)	\( \dfrac{315}{360} \)	\( \dfrac{315}{90} \cdot 100 \)
330	\( \dfrac{330}{180}\pi \)	\( \dfrac{330}{360} \)	\( \dfrac{330}{90} \cdot 100 \)
345	\( \dfrac{345}{180}\pi \)	\( \dfrac{345}{360} \)	\( \dfrac{345}{90} \cdot 100 \)
360	\( \dfrac{360}{180}\pi \)	\( \dfrac{360}{360} \)	\( \dfrac{360}{90} \cdot 100 \)

i\j	1	2	3	\( \cdots \)	n
1	\( a_{11} \)	\( a_{12} \)	\( a_{13} \)	\( \cdots \)	\( a_{1n} \)
2	\( a_{21} \)	\( a_{22} \)	\( a_{23} \)	\( \cdots \)	\( a_{2n} \)
3	\( a_{31} \)	\( a_{32} \)	\( a_{33} \)	\( \cdots \)	\( a_{3n} \)
\( \vdots \)	\( \vdots \)	\( \vdots \)	\( \vdots \)	\( \ddots \)	\( \vdots \)
n	\( a_{n1} \)	\( a_{n2} \)	\( a_{n3} \)	\( \cdots \)	\( a_{nn} \)

i\j	1	2	3	\( \cdots \)	n
1	\( a_{11} \)	\( a_{12} \)	\( a_{13} \)	\( \cdots \)	\( a_{1n} \)
2	\( a_{21} \)	\( a_{22} \)	\( a_{23} \)	\( \cdots \)	\( a_{2n} \)
3	\( a_{31} \)	\( a_{32} \)	\( a_{33} \)	\( \cdots \)	\( a_{3n} \)
\( \vdots \)	\( \vdots \)	\( \vdots \)	\( \vdots \)	\( \ddots \)	\( \vdots \)
n	\( a_{n1} \)	\( a_{n2} \)	\( a_{n3} \)	\( \cdots \)	\( a_{nn} \)

\( +M_{11} \)	\( -M_{12} \)	\( +M_{13} \)	\( -M_{14} \)	\( +M_{15} \)	\( -M_{16} \)
\( -M_{21} \)	\( +M_{22} \)	\( -M_{23} \)	\( +M_{24} \)	\( -M_{25} \)	\( +M_{26} \)
\( +M_{31} \)	\( -M_{32} \)	\( +M_{33} \)	\( -M_{34} \)	\( +M_{35} \)	\( -M_{36} \)
\( -M_{41} \)	\( +M_{42} \)	\( -M_{43} \)	\( +M_{44} \)	\( -M_{45} \)	\( +M_{46} \)
\( +M_{51} \)	\( -M_{52} \)	\( +M_{53} \)	\( -M_{54} \)	\( +M_{55} \)	\( -M_{56} \)
\( -M_{61} \)	\( +M_{62} \)	\( -M_{63} \)	\( +M_{64} \)	\( -M_{65} \)	\( +M_{66} \)

2進数	10進数	10進冪乗
1	1	\( 2^0 \)
10	2	\( 2^1 \)
100	4	\( 2^2 \)
1000	8	\( 2^3 \)
10000	16	\( 2^4 \)
100000	32	\( 2^5 \)
1000000	64	\( 2^6 \)
10000000	128	\( 2^7 \)

8進数	10進数	10進冪乗	10進対数
1	1	\( 8^0 \)	0
10	8	\( 8^1 \)	1
100	64	\( 8^2 \)	2
1000	512	\( 8^3 \)	3
10000	4096	\( 8^4 \)	4
100000	32768	\( 8^5 \)	5
1000000	262144	\( 8^6 \)	6
10000000	2097152	\( 8^7 \)	7
100000000	16777216	\( 8^8 \)	8

12進数	10進数	10進冪乗	10進対数
1	1	\( 12^0 \)	0
10	12	\( 12^1 \)	1
100	144	\( 12^2 \)	2
1000	1728	\( 12^3 \)	3
10000	20736	\( 12^4 \)	4
100000	248832	\( 12^5 \)	5
1000000	2985984	\( 12^6 \)	6
10000000	35831808	\( 12^7 \)	7
100000000	429981696	\( 12^8 \)	8

2進数	10進数	10進冪乗	10進分数	10進対数
0.1	0.5	\( 2^{-1} = 0.5^1 \)	\( \dfrac{1}{2^1} \)	-1
0.01	0.25	\( 2^{-2} = 0.5^2 \)	\( \dfrac{1}{2^2} \)	-2
0.001	0.125	\( 2^{-3} = 0.5^3 \)	\( \dfrac{1}{2^3} \)	-3
0.0001	0.0625	\( 2^{-4} = 0.5^4 \)	\( \dfrac{1}{2^4} \)	-4
0.00001	0.03125	\( 2^{-5} = 0.5^5 \)	\( \dfrac{1}{2^5} \)	-5
0.000001	0.015625	\( 2^{-6} = 0.5^6 \)	\( \dfrac{1}{2^6} \)	-6
0.0000001	0.0078125	\( 2^{-7} = 0.5^7 \)	\( \dfrac{1}{2^7} \)	-7
0.00000001	0.00390625	\( 2^{-8} = 0.5^8 \)	\( \dfrac{1}{2^8} \)	-8

16進数	10進数	10進冪乗	10進対数
0.0001	0.00001525879	\( 16^{-4} \)	-4
0.001	0.0002441406	\( 16^{-3} \)	-3
0.01	0.00390625	\( 16^{-2} \)	-2
0.1	0.0625	\( 16^{-1} \)	-1
1	1	\( 16^0 \)	0
10	16	\( 16^1 \)	1
100	256	\( 16^2 \)	2
1000	4096	\( 16^3 \)	3
10000	65536	\( 16^4 \)	4
100000	1048576	\( 16^5 \)	5
1000000	16777216	\( 16^6 \)	6
10000000	268435456	\( 16^7 \)	7
100000000	4294967296	\( 16^8 \)	8

10進数の桁	桁値
0.0000000001	\( \dfrac{1}{10^{10}} \)
0.000000001	\( \dfrac{1}{10^9} \)
0.00000001	\( \dfrac{1}{10^8} \)
0.0000001	\( \dfrac{1}{10^7} \)
0.000001	\( \dfrac{1}{10^6} \)
0.00001	\( \dfrac{1}{10^5} \)
0.0001	\( \dfrac{1}{10^4} \)
0.001	\( \dfrac{1}{10^3} \)
0.01	\( \dfrac{1}{10^2} \)
0.1	\( \dfrac{1}{10^1} \)
1	\( 10^0 \)
10	\( 10^1 \)
100	\( 10^2 \)
1000	\( 10^3 \)
10000	\( 10^4 \)
100000	\( 10^5 \)
1000000	\( 10^6 \)
10000000	\( 10^7 \)
100000000	\( 10^8 \)
1000000000	\( 10^9 \)
10000000000	\( 10^{10} \)

2進数の桁	対応する10進数	桁値
0.00000000001	0.0009765625	\( \dfrac{1}{2^{10}} \)
0.0000000001	0.001953125	\( \dfrac{1}{2^9} \)
0.000000001	0.00390625	\( \dfrac{1}{2^8} \)
0.00000001	0.0078125	\( \dfrac{1}{2^7} \)
0.0000001	0.015625	\( \dfrac{1}{2^6} \)
0.000001	0.03125	\( \dfrac{1}{2^5} \)
0.00001	0.0625	\( \dfrac{1}{2^4} \)
0.0001	0.125	\( \dfrac{1}{2^3} \)
0.01	0.25	\( \dfrac{1}{2^2} \)
0.1	0.5	\( \dfrac{1}{2^1} \)
1	1	\( 2^0 \)
10	2	\( 2^1 \)
100	4	\( 2^2 \)
1000	8	\( 2^3 \)
10000	16	\( 2^4 \)
100000	32	\( 2^5 \)
1000000	64	\( 2^6 \)
10000000	128	\( 2^7 \)
100000000	256	\( 2^8 \)
1000000000	512	\( 2^9 \)
10000000000	1024	\( 2^{10} \)

8進数の桁	対応する10進数	桁値
0.0000000001	0.0000000009313226	\( \dfrac{1}{8^{10}} \)
0.000000001	0.000000007450581	\( \dfrac{1}{8^9} \)
0.00000001	0.00000005960464	\( \dfrac{1}{8^8} \)
0.0000001	0.0000004768372	\( \dfrac{1}{8^7} \)
0.000001	0.000003814697	\( \dfrac{1}{8^6} \)
0.00001	0.00003051758	\( \dfrac{1}{8^5} \)
0.0001	0.0002441406	\( \dfrac{1}{8^4} \)
0.001	0.001953125	\( \dfrac{1}{8^3} \)
0.01	0.015625	\( \dfrac{1}{8^2} \)
0.1	0.125	\( \dfrac{1}{8^1} \)
1	1	\( 8^0 \)
10	8	\( 8^1 \)
100	64	\( 8^2 \)
1000	512	\( 8^3 \)
10000	4096	\( 8^4 \)
100000	32768	\( 8^5 \)
1000000	262144	\( 8^6 \)
10000000	2097152	\( 8^7 \)
100000000	16777216	\( 8^8 \)
1000000000	134217728	\( 8^9 \)
10000000000	1073741824	\( 8^{10} \)

16進数の桁	対応する10進数	桁値
0.0000000001	0.0000000000009094947	\( \dfrac{1}{16^{10}} \)
0.000000001	0.00000000001455192	\( \dfrac{1}{16^9} \)
0.00000001	0.0000000002328306	\( \dfrac{1}{16^8} \)
0.0000001	0.00000000372529	\( \dfrac{1}{16^7} \)
0.000001	0.00000005960464	\( \dfrac{1}{16^6} \)
0.00001	0.0000009536743	\( \dfrac{1}{16^5} \)
0.0001	0.00001525879	\( \dfrac{1}{16^4} \)
0.001	0.0002441406	\( \dfrac{1}{16^3} \)
0.01	0.00390625	\( \dfrac{1}{16^2} \)
0.1	0.0625	\( \dfrac{1}{16^1} \)
1	1	\( 16^0 \)
10	16	\( 16^1 \)
100	256	\( 16^2 \)
1000	4096	\( 16^3 \)
10000	65536	\( 16^4 \)
100000	1048576	\( 16^5 \)
1000000	16777216	\( 16^6 \)
10000000	268435456	\( 16^7 \)
100000000	4294967296	\( 16^8 \)
1000000000	68719476736	\( 16^9 \)
100000000000	1099511627776	\( 16^{10} \)

\( m \times 10^3 \)	mE3	キロ (k)
\( m \times 10^6 \)	mE6	メガ (M)
\( m \times 10^9 \)	mE9	ギガ (G)
\( m \times 10^{12} \)	mE12	テラ (T)
\( m \times 10^{15} \)	mE15	ペタ (P)