【Unity道場】ゲーム制作に使う数学を学習しよう

ゲーム制作に使う数学を学習しよう ユニティ・テクノロジーズ・ジャパン 安原 祐二

Part 1 数式とグラフ

指数のおさらい 2 10 = ? 1 2 10 = ? −2 10 = ?

指数のおさらい 2 10 = 100 1 2 10 = 10 1 −2 10 = 100 いずれにせよゼロより大きい

y = sin x ・・・と、言われましても。

y y = sin x x

y 出力 y = sin x x 入力

y = sin x f(x) = sin x

y = sin x yってなんなの f(x) = sin x 入力と出力が明らか

f(x) 出力 x 入力 f(x) = sin x

例１ f(x) 出力 突然この値が欲しい x 入力 f(x) = sin x

例２ f(x) 出力 ・・・ f(x) = sin x x 入力 単純な増加（等間隔など） でしか入力を得られない

プログレスバーの工夫 動画

f(x) = x 2 1 1 x

プログレスバーの工夫 動画 f(x) = x f(x) = x 2

逆関数 f(x) = x −1 2 f (x) = ?

逆関数 y=x 2 x= y (x > 0)

逆関数 y=x 2 x= y f(x) = x −1 f (x) = 2 x

逆関数 y = sin x x = ???

逆関数 y = sin x −1 y x = sin y x = arcsin y x = asin

逆関数 y = sin x x = asin y f(x) = sin x −1 f (x) = asin x

逆関数 y x f(x) = sin x

逆関数 y x f(x) = sin x

逆関数 f(x) = asin(x) x f(x) = sin x

逆関数 f(x) = asin(x) -1 f(x) = sin x 1 x

Part 1 数式とグラフ まとめ • f(x) という表記に慣れよう •グラフは入力と出力の関係 •逆関数を意識しよう

Part 2 式の読みかた

ϵ0 E ⋅ dA = Σq ∮ d B ⋅ ds = μ0 J ⋅ dA + μ0ϵ0 E ⋅ dA ∮ ∫ dt ∫ d E ⋅ ds = − B ⋅ dA ∮ dt ∫ ∮ B ⋅ dA = 0

足し算と引き算は似たようなもの a +b = c a −b = c b がどこかで定義されてる以上、 ＋もーもその定義次第

掛け算と割り算はカタマリ ab = c a b =c

足し算 掛け算 と には境界がある 引き算 割り算 ab + cd e = fg カタマリは混ざらない

等号の左右で単位は等しい a =b a が秒なら bも秒 a が距離なら b も距離

足し算と引き算と等号は似たようなもの a +b= c

足し算と引き算と等号は似たようなもの a +b= c a + b −c = 0 等号で結ばれているものは結局 足し算や引き算で結ばれている

足し算引き算および等号で 区切られたカタマリの単位は全部同じ cd ab + = fg e 単位の異なるものを足すことは ありえない

掛け算か割り算かは カタマリに対する影響を示す cd ab + = fg e e が増えれば減る d が増えれば増える

固定値はどれか？ ab + 例えば d cd e = fg だけが変化するなら f(x) = ab + cx e fgの値は という関数に従う

少しは読める（？） d B ⋅ ds = μ0 J ⋅ dA + μ0ϵ0 E ⋅ dA ∮ ∫ ∫ dt J が増加すれば 磁束密度B が増加する・・・っぽい？ 電流

漸化式 an+1= f(an) ひとつ前の値が式の中にある n ・ は自然数が基本 ・初期値がある a0 = 0 an+1= an+ 2n+ 1 例

漸化式はプログラミングでおなじみ int a = 0; void Update() { a += 1; } an+1 = an + 1

a0 = 0 an+1= an+ 2n+ 1 ・・・ a1 = a0 + 2× 0 +1 = a0 + 1 = 1 a2 = a1 + 2× 1 +1 = a1 + 3 = 4 a3 = a2 + 2× 2 +1 = a2 + 5 = 9

a0 = 0 an+1= an+ 2n+ 1 ・・・ a1 = a0 + 2× 0 +1 = a0 + 1 = 1 a2 = a1 + 2× 1 +1 = a1 + 3 = 4 a3 = a2 + 2× 2 +1 = a2 + 5 = 9 an = n 2 一般項（前回の値を使わない式）

a0 = 0 an+1= an+ 2n+ 1 ・・・ a1 = a0 + 2× 0 +1 = a0 + 1 = 1 a2 = a1 + 2× 1 +1 = a1 + 3 = 4 a3 = a2 + 2× 2 +1 = a2 + 5 = 9 an = n 2

Part ２ 式の読みかた まとめ •数式を見たら足し算、引き算、等号に注目 •単位を意識しよう（物理の場合） •漸化式を理解しよう

Part 3 対数

指数関数 f(x) x =a a≥ 0

f(x) x =a a> 1 1 x

指数関数の逆関数 x f(x) = a x y=a x= ?

指数関数の逆関数 x f(x) = a x y=a x = loga y

指数関数の逆関数 x f(x) = a x y=a x = loga y −1 f (x) = loga x

f(x) 対数 x =a f(x) = loga x a> 1 1 x

logba bの何乗がa なのか

logba bの何乗がa なのか log10100 = 2 log216 = 4 1 log10010 = 2 100 1 2 = 100 = 10

底の交換 log ax 底 aを別の底 b にしたい logb x log a x = logba 超便利公式

底の交換 log 4x 底 4を別の底 2 にしたい log2 x 1 log 4 x = = log 2 x log24 2 = 2 公式より

対数のキモ 1 log4x= log2 x 2 交換したい底が定数なら 定数倍になる 底はどうでもいい あとで定数倍して調整可能

応用例： a 2 = 10 b a と b は比例関係にある 二進数と十進数の桁の数は 比例関係にある

a 2 = 10 b a と b は比例関係にある log210 = 3.321928094887362 log10 2 = 0.301029995663981 ざっくり言えば３倍と1/3倍の関係 32 32bitは 2 なので10進数だと10桁程度

文字64種、52文字で表現できるバイト数は？ あ か さ た な は い き し ち に ひ う く す つ ぬ ふ え け せ て ね へ お こ そ と の ほ ま ら が ざ ば ぱ み り ぎ じ び ぴ む る ぐ ず ぶ ぷ め れ げ ぜ べ ぺ も や ゆ ろ よ わ ご ぞ ぼ ぽ 1byte(256種)は256進数 例：4byteで 256 4の情報量

文字64種、52文字で表現できるバイト数は？ あ か さ た な は い き し ち に ひ う く す つ ぬ ふ え け せ て ね へ お こ そ と の ほ ま ら が ざ ば ぱ み り ぎ じ び ぴ む る ぐ ず ぶ ぷ め れ げ ぜ べ ぺ も や ゆ ろ よ わ ご ぞ ぼ ぽ 1byte(256種)は256進数 例：4byteで 256 64進数の数値を256進数で表現すると何桁か？ 4の情報量

文字64種、52文字で表現できるバイト数は？ あ か さ た な は い き し ち に ひ う く す つ ぬ ふ log256 64 = え け せ て ね へ 3 4 お こ そ と の ほ ま ら が ざ ば ぱ み り ぎ じ び ぴ む る ぐ ず ぶ ぷ め れ げ ぜ べ ぺ 52文字 × も や ゆ ろ よ わ ご ぞ ぼ ぽ 3 4 = 39 bytes

Part ３ 対数 まとめ •対数の底の交換は定数倍

Part 4 浮動小数点数

問題

問題 float a = 1f; Debug.Log(a); Consoleに出力されるのは？

問題 float a = 1f; Debug.Log(a); Consoleに出力されるのは？ 正解 1

問題 float a = 1/3; Debug.Log(a); Consoleに出力されるのは？

問題 float a = 1/3; Debug.Log(a); Consoleに出力されるのは？ 正解 0 float a = 1f/3f; で0.33333になる

問題 float a = 3e-1f; Debug.Log(a); Consoleに出力されるのは？

問題 float a = 3e-1f; Debug.Log(a); Consoleに出力されるのは？ 正解 0.3

float a = 3e-1f; × 3 10 0.3 −1

符号 指数部(8bits) 仮数部(23bits) 00111111100000000000000000000000

符号 指数部(8bits) 仮数部(23bits) 00111111100000000000000000000000 ±（仮数部）× 2 （指数部）

符号 指数部(8bits) 仮数部(23bits) 00111111100000000000000000000000 ±（仮数部+1.0）× 2 （指数部-127）

符号 指数部(8bits) 仮数部(23bits) 00111111100000000000000000000000 指数部 [-126, 127] 2 127 = 1.701411834604692e38

符号 指数部(8bits) 仮数部(23bits) 00111111100000000000000000000000 指数部 [-126, 127] 127 = 1.701411834604692e38 −126 2 = 1.175494350822288e − 38 2 超絶広い

2 127 = 1.701411834604692e38 億 兆 京 垓 𥝱 穣 溝 澗 正 おく ちょう けい がい じょ じょう こう かん せい １０８ １０１２ １０１６ １０２０ １０２４ １０２８ １０３２ １０３６ １０４０

2 127 = 1.701411834604692e38 −126 2 億 兆 京 垓 𥝱 穣 溝 澗 正 おく ちょう けい がい じょ じょう こう かん せい １０８ １０１２ １０１６ １０２０ １０２４ １０２８ １０３２ １０３６ １０４０ = 1.175494350822288e − 38 −24 10 ディラック定数 ℏ = 1.054571817e − 34 涅槃寂静(ねはんじゃくじょう)

符号 指数部(8bits) 仮数部(23bits) 00111111100000000000000000000000 仮数 23bits ここに限界がある 大きな数値の小さな桁がヤバイ 例：10000000.00000001

2 −23 = 1 23 (2) = 0.00000011920928955078125

−23 2 符号 = 1 23 (2) = 0.00000011920928955078125 指数部(8bits) 仮数部(23bits) 00111111100000000000000000000001 1.00000011920928955078125 ７桁

符号 指数部(8bits) 仮数部(23bits) 00111111100000000000000000000001 1.00000011920928955078125 ７桁 log10 2 = 0.301029995663981 23 × log10 2 = 6.923689900271563 ２進数の23桁は10進数の6.9桁

01000001001000000000000000000001 10.00000095367431640625 01000010110010000000000000000001 100.00000762939453125 01000100011110100000000000000001 1000.00006103515625 01000110000111000100000000000001 10000.0009765625

01000001001000000000000000000001 10.00000095367431640625 01000010110010000000000000000001 100.00000762939453125 0 1 0 0 0 1原点から10km離れた地点では 00011110100000000000000001 1000.00006103515625 約1mmの分解能が限界 01000110000111000100000000000001 10000.0009765625

01000111101010001100000000000001 86400.0078125 60秒×60分×24時間＝86400 24時間後には・・・ 7.8125ミリ秒が限界 time += Time.deltaTime; 16.6666ミリ秒を加算しても 15.625ミリ秒しか加算されない

動画

動画

doubleなら 仮数部は52bit 86400.0000000000145519... 24時間後でも0.014ナノ秒の分解能 31536000.000000003725290... 365日後でも3.7ナノ秒の分解能！

Part ４ 浮動小数点数 まとめ •floatの限界を具体的に知ろう •2進数と10進数の桁の関係を理解しよう ブログ：浮動小数点数の限界を把握する https://qiita.com/yuji_yasuhara/private/0f94f3b60b4525dd1e74

• https://qiita.com/yuji_yasuhara/private/0f94f3b60b4525dd1e74

Part 5 RPGで数列

適切な経験値は？ Lv.5 キビシイ 余裕 Lv.4 Lv.5 いい勝負 Lv.6

レベルアップ条件 レベル5 同じレベルの 敵を５体倒す レベル6 Lv.5

レベルアップ条件 レベル5 低いレベルの 敵を8体倒す 同じレベルの 敵を５体倒す レベル6 高いレベルの 敵を３体倒す Lv.4 Lv.5 Lv.6

レベルアップ条件 レベル5 同じレベルの 敵を５体倒す レベル6 レベル31 同じレベルの 敵を５体倒す レベル32 敵ごとに得られる経験値は固定とする

レベル１ レベル２ 10 レベル31 1.5倍 レベル32 レベル３ 15 レベル33 1917511 2876266 1.5倍 等比数列 初項10・公比1.5

等比数列 初項10・公比1.5 N1 = 10 N 2= 15 Nn = 10 × 1.5 n−1

I 等比数列 初項 ・公比 a N1 = I N 2= Ia Nn = I a n −1

レベル１ 0 レベル31 100 レベル２ 10 1.5倍 レベル32 150 レベル３ 25 レベル33 1917511 2876266 1.5倍 累積経験値は？ 等比数列の和

I a n −1 Nn = I a 等比数列 初項 ・公比 等比数列の和： n n a−1 k−1 Mn= I ∑a = I −1 a k=1 （公式より）

表1 初項10・公比1.5 レベル レベルアップ経験値 累積レベルアップ経験値 1 0 0 2 10 10 3 15 25 4 23 48 5 34 81 6 51 132 7 76 208 8 114 322 9 171 493 10 256 749 11 384 1133 12 577 1710 13 865 2575 14 1297 3872 15 1946 5819 … … … 38 21841644 65524912 39 32762466 98287378 40 49143699 147431078

I a n −1 Nn = I a 等比数列 初項 ・公比 等比数列の和： n n a−1 k−1 Mn= I ∑a = I −1 a k=1

2 x − 1 = (x − 1)(x + 1)

2 x − 1 = (x − 1)(x + 1) 3 2 4 3 x − 1 = (x − 1)(x + x + 1) 2 x − 1 = (x − 1)(x + x + x + 1)

2 x − 1 = (x − 1)(x + 1) 3 2 4 3 n n−1 x − 1 = (x − 1)(x + x + 1) 2 x − 1 = (x − 1)(x + x + x + 1) x − 1 = (x − 1)( x 2 + . . . + x + x + 1)

n x − 1= (x − 1)( x n−1 2 + . . . + x + x + 1) n x − 1 n−1 2 x + . . . + x + x + 1= x − 1

n x − 1= (x − 1)( x n−1 2 + . . . + x + x + 1) n x − 1 n−1 2 x + . . . + x + x + 1= x − 1 n ∑ k=1 x k−1 = n x −1 x−1

I a n −1 Nn = I a 等比数列 初項 ・公比 等比数列の和： n n a−1 k−1 Mn= I ∑a = I −1 a k=1

経験値からレベルを逆算 n a −1 Mn= I a−1 n= ?

経験値からレベルを逆算 n a −1 Mn= I a−1 n (a − 1) Mn = I(a − 1) M n n a = (a − 1) + 1 I Mn n = loga{ (a − 1) + 1} I

Part ５ RPGで数列 まとめ •経験値が指数関数になる例 •等比数列を扱えるようになろう •経験値からレベルを知るには対数が必要 ブログ：浮動小数点数の限界を把握する https://qiita.com/yuji_yasuhara/private/83a67a784d4d6152a2de

• https://qiita.com/yuji_yasuhara/private/83a67a784d4d6152a2de

Part 6 easing解析

動画

p = Mathf.Lerp(p, T, 0.1f);

p = Mathf.Lerp(p, T, 0.1f); p = Vector2.Lerp(p, T, 0.1f); p = Vector3.Lerp(p, T, 0.1f);

Lerp (Linear Interpolation) 線形補間 a (1− t ) a +bt b t = 0 のとき a に一致 t = 1 のとき b に一致

float Lerp(float a, float b, float t) { return (1f - t)*a + t*b; } ※最適化の余地あり void Update() { p = Mathf.Lerp(p, T, 0.1f); }

p = Mathf.Lerp(p, T, 0.1f); pn+1 = (1− 0.1) pn + 0.1T 漸化式 一般項 p = func(n, T, 0.1f); pn = f ( n )

問題 T , α を定数とし、漸化式 pn+1 = (1− α ) pn + α T p の一般項を求めよ。ただし 0 = 0 とする。

pn+1 = (1− α ) pn + T α

pn+1 = (1− α ) pn + T α s = (1− α ) s + T α を満たす s を考える

pn+1 = (1− α ) pn + T α s = (1− α ) s + T α pn+1 − s = ( pn− s )(1− α ) を満たす s を考える ２式の差を取って

pn+1 = (1− α ) pn + T α s = (1− α ) s + T α を満たす pn+1 − s = ( pn− s )(1− α ) q p s = − n n qn+1 = qn (1− α ) s を考える ２式の差を取って とおくと

pn+1 = (1− α ) pn + T α s = (1− α ) s + T α を満たす s を考える pn+1 − s = ( pn− s )(1− α ) q p とおくと s = − n n qn+1 = qn (1− α ) q p 初項 0 = 0 − s = −s n の等比数列なので qn = − s (1− α ) ２式の差を取って

pn+1 = (1− α ) pn + T α s = (1− α ) s + T α を満たす s を考える pn+1 − s = ( pn− s )(1− α ) q p とおくと s = − n n qn+1 = qn (1− α ) q p 初項 0 = 0 − s = −s n の等比数列なので qn = − s (1− α ) q p より s = − n n n pn− s = − s (1− α ) ２式の差を取って

pn+1 = (1− α ) pn + T α s = (1− α ) s + T α を満たす s を考える pn+1 − s = ( pn− s )(1− α ) q p とおくと s = − n n qn+1 = qn (1− α ) q p 初項 0 = 0 − s = −s n の等比数列なので qn = − s (1− α ) q p より s = − n n n pn− s = − s (1− α ) より s T = n pn− T = − T (1− α ) ２式の差を取って

pn+1 = (1− α ) pn + T α s = (1− α ) s + T α を満たす s を考える pn+1 − s = ( pn− s )(1− α ) q p とおくと s = − n n qn+1 = qn (1− α ) q p 初項 0 = 0 − s = −s n の等比数列なので qn = − s (1− α ) q p より s = − n n n pn− s = − s (1− α ) より s T = n pn− T = − T (1− α ) ２式の差を取って n pn = T {1 − (1− α ) }

T n pn = T {1 − (1− α ) } 60 n

動的なターゲット変更 動画

Lerpの係数を一般化したい 60fps版 void Update() { p = Mathf.Lerp(p, T, 0.1f); } void Update() { 30fps版 } p = Mathf.Lerp(p, T, ？ );

60fpsのときの係数を 一般項 １秒後 n pn = T {1 − (1− α ) } p60 = T {1 − (1− α ) 60 30fpsのときの係数を １秒後 α とする β とする q30 = T {1 − (1−β ) 30 } }

60 (1− α) 一般化して n 30 = (1− β) (1− α ) = (1− β ) 1 − β = (1− α ) m n m n m = 1 − (1− ) α β n フレームレートの比 の関数をゲット m

60fps版 void Update() { p = Mathf.Lerp(p, T, 0.1f); }

60fps版 void Update() { p = Mathf.Lerp(p, T, 0.1f); } 30fps版 void Update() { var beta = 1f - Mathf.Pow(1f-0.1f, 60f/30f); p = Mathf.Lerp(p, T, beta); }

60fps版 void Update() { p = Mathf.Lerp(p, T, 0.1f); } 30fps版 void Update() { var beta = 1f - Mathf.Pow(1f-0.1f, 60f/30f); p = Mathf.Lerp(p, T, beta); } 汎用版 void Update() { var beta = 1f - Mathf.Pow(1f-0.1f, 60f*Time.deltaTime); p = Mathf.Lerp(p, T, beta); }

結果 動画 60fps 30fps

Part ６ easing解析 まとめ •Lerpの動きは等比数列で解ける •フレームレートの異なる環境に対応可能 ブログ：Lerpで作るアニメーション(easing)を解析する https://qiita.com/yuji_yasuhara/private/117b8559beed1a8d8377

• https://qiita.com/yuji_yasuhara/private/117b8559beed1a8d8377

Part 7 複素数

虚数単位 i

虚数単位 i = −1 2 i =−1 意味不明

複素数 a+ i b 実部 虚部 z = a + ib 複素数 z

z0 = a0+ i b0 足し算 z1 = a1+ i b1 z0 + z1 = ( a0 + a1) + i ( b0 + b1)

z0 = a0+ i b0 z1 = a1+ i b1 足し算 z0 + z1 = ( a0 + a1) + i ( b0 + b1) 掛け算 z0 z1= ( a0 +ib0)( a1 + ib1) 2 = a0 a1 + ia0b1 + ia1b0 + i b0b1 = (a0 a1− b0b1) + i (a0b1 + a1b0 )

複素数の実装 public class Complex { float re; float im;

複素数の足し算の実装 public class Complex { float re; float im; static Complex Add(Complex z0, Complex z1) { return new Complex() { re = z0.re + z1.re, im = z0.im + z1.im, }; }

複素数の掛け算の実装 public class Complex { float re; float im; static Complex Mul(Complex z0, Complex z1) { return new Complex() { re = z0.re*z1.re - z0.im*z1.im, im = z0.re*z1.im + z0.im*z1.re, }; }

複素数の掛け算の実装 public class Complex { float re; float im; static Complex Mul(Complex z0, Complex z1) { return new Complex() { re = z0.re*z1.re - z0.im*z1.im, im = z0.re*z1.im + z0.im*z1.re, }; } i は登場しない！ 「作用」と考える

複素平面 虚軸 b z = a + ib a 実軸

〜足し算〜 虚軸 z0 = a0+i b0 z1 実軸

〜足し算〜 虚軸 z0 z1 実軸

〜足し算〜 虚軸 z0 z1 (z0 + z1) 実軸 足し算は平行移動

〜掛け算〜 虚軸 z0 z1 実軸

〜掛け算〜 単位円 虚軸 z0 1 z1 実軸

〜掛け算〜 虚軸 r0 z0 θ0 z1 実軸

〜掛け算〜 虚軸 z0 θ1 r1 z1 実軸

〜掛け算〜 虚軸 z0 z0z1 z1 実軸 角度は加算 長さは乗算

参考：クォータニオンの解説動画 クォータニオン完全マスター https://youtu.be/uKWLPU8gfIY?t=1294 行列・複素数の解説あり

• https://youtu.be/uKWLPU8gfIY?t=1294

クォータニオンは複素数の拡張 複素数と同じ性質を持つ 拡大縮小も可能 が、Unityでは回転に限定している

極小コードでジェネラティブアート var z = new Complex(1f, 0f); [repeat] z += z * new Complex(0.01f, 0.25f);

マンデルブロ集合（Mandelbrot set) zn+1 = zn, c は複素数 2 zn + c

マンデルブロ集合（Mandelbrot set) zn+1 = zn, c は複素数 z0 = 0 2 zn + c c によって発散したり収束したりする

zn+1 = 2 zn + c 発散 収束 発散 収束 収束 発散 収束 収束 発散 収束 発散 発散 発散 画素数ぜんぶチェックする

zn+1 = 2 zn + c 発散 収束 すぐ発散 収束 収束 すぐ発散 収束 収束 発散 収束 発散 発散 すぐ発散 発散はループでチェック

zn+1 =

2
zn + c

int mandelblot(Complex c) {
var z = new Complex(0f, 0f);
int cnt = 0;
for (var i = 0; i < 100; ++i) {
z = z * z + c;
if (z.sqrMagnitude() > 100f)
return cnt;
++cnt;
}
return 0;
}

動画

Part 8 複素数列

自由研究：らせん状にマスを埋める 一般項はどうなる？

番号を振る

複素平面 虚軸 実軸

複素平面 虚軸 2 + 2i −i 実軸 ・・・ f(6) = − i f(13) = 2 + 2i

群数列で考える 第1群 1 1項 第2群 2 3 4 5 6 2項x4 第3群 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 4項x4

群の中で何番目なのか 第1群 1 1項 第2群 2 3 4 5 6 2項x4 第3群 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 4項x4 第15項は第３群の 15-9=6番目

r=1 r=0 l t r=2 r=3

虚軸 １ 2-i 実軸 3-2i

90度 90度

そんな感じで地道に 係数を確定していく・・

結果 an = [N − 1] + 2 − N + (n − (2N − 3) − 1) mod 2(N − 1) i i ) [( ] 2 n − (2N − 3)2 − 1 floor( 2(N − 1) ) ただし N = ceil( n+1 2 )

動画

第1群 1 1項 第2群 2 3 4 5 1項x6 第3群 6 7 8 第4群 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 2項x6 3項x6

結果 an = s + td ただし 1 (2 3 r+1 d = + 2 i) 3 1 r s = (N − 1)( 2 + 2 i) t = m mod l m r = floor( l ) 2 m = n − 3N + 9N − 8 l=N−1 3 1 N = ceil( 2 + 6 4n − 1)

動画

Part ８ 複素数列 まとめ ブログ：らせん状にマスを埋める複素数数列と戯れる https://qiita.com/yuji_yasuhara/private/23088d82a5c0ed8551bc

• https://qiita.com/yuji_yasuhara/private/23088d82a5c0ed8551bc

おしまい