Julia -- 4（ベクトル，行列）

データ構造

行ベクトル

julia> [1 2 3 4 5]
1×5 Array{Int64,2}:
 1  2  3  4  5

列ベクトル

julia> [2, 4, 6]
3-element Array{Int64,1}:
 2
 4
 6

julia> [2; 4; 6] # 列ベクトルの場合には，このように書いても同じ。
3-element Array{Int64,1}:
 2
 4
 6

行列 「行ベクトルを束ねたもの」という定義

julia> [1 2 3 4; 5 6 7 8]
2×4 Array{Int64,2}:
 1  2  3  4
 5  6  7  8

行列乗算 (a x b 行列) * (b x c 行列）

julia> ab = [1 2 3; 4 5 6] # a x b 行列
2×3 Array{Int64,2}:
 1  2  3
 4  5  6

julia> bc = [11 12 13 14; 21 22 23 24; 31 32 33 34] # b x c 行列
3×4 Array{Int64,2}:
 11  12  13  14
 21  22  23  24
 31  32  33  34

julia> ab * bc # 行列の掛算
2×4 Array{Int64,2}:
 146  152  158  164
 335  350  365  380

ちょっと回り道

左辺乗算演算子

  \(x, y)

  Left division operator: multiplication of y by the inverse of x on the left.
  Gives floating-point results for integer arguments.

  左辺除算演算子：x の逆（逆数）と y の乗算を行う。
  整数引数に対しても実数の結果を与える。
 
例

julia> 3 \ 6
2.0
 
これは， x = 3 の逆数 1/3（inv(3) である）と y = 6 の乗算ということで，(1/3) * 6 = 2.0 という計算を行うということである。

julia> inv(3) # 「3 の逆数 = 1/3」ということ
0.3333333333333333

julia> inv(3) * 6
2.0

スカラーの逆数

julia> inv(2)
0.5

julia> inv(33)
0.030303030303030304

行列の逆 -- 逆行列

julia> x = [4 3; 2 1]; y = [5, 6]; # 式が ; で終わっている場合には，式の評価結果は表示されない。

julia> inv(x) 
2×2 Array{Float64,2}:
 -0.5   1.5
  1.0  -2.0

一元連立方程式の解

\(x, y) で，x が行列なら inv(x) は「逆行列」。
逆行列と一元連立方程式の右辺ベクトル y を掛ければ，連立方程式の解になる。

julia> x \ y # \(x, y) と書いても同じ結果が得られる。
2-element Array{Float64,1}:
  6.5
 -7.0

明示的に inv(x) を使って連立方程式の解を求めるならば以下のようにする。

julia> inv(x) * y
2-element Array{Float64,1}:
  6.5
 -7.0

np.nan == np.nan は？ (Python)

import numpy as np
print(np.nan == np.nan)
print(np.nan != np.nan)

の結果がどうなるか答えよ

 

答えは，スクロールした，ずーーーと下の方にある

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

print(np.nan == np.nan) は False
print(np.nan != np.nan) は True

正しくは is, is not を使うべきなのだ

print(np.nan is np.nan) は True
print(np.nan is not np.nan) は False

Julia -- 3（算術演算子，数学関数，文字関数）

算術演算子

和　　+, +(x, y, ...)

julia> 1 + 2
3

julia> +(1, 2)
3

julia> 1 + 2 + 3 + 4 + 5
15

julia> +(1, 2, 3, 4, 5) # 累和
15

差　　-, -(x, y)

julia> 10 - 3
7

julia> -(10, 3)
7

積　　*, *(x, y, ...)

julia> 2 * 3
6

julia> *(2, 3)
6

julia> 1 * 2 * 3 * 4 * 5 # 累積
120

julia> *(1, 2, 3, 4, 5)
120

商　　/, /(x, y)

julia> 15 / 4
3.75

julia> /(15, 4)
3.75

整数除算　　÷, div(x, y)

julia> 15 ÷ 4 # '÷' は Unicode U+00F7 (category Sm: Symbol, math)
3

÷ を 入力するのは '\div' の後に tab キーを押す。

すなわち，15 ÷ 4 は '15 \div[tab] 4[return]' と入力する。

julia> 15.0 ÷ 4
3.0

julia> div(15, 4)
3

julia> div(15.0, 4)
3.0

剰余　　%, rem(x, y)

julia> 15 % 4
3

julia> 15.0 % 4
3.0

julia> 23.1 % 4.2
2.1000000000000005

julia> rem(15, 4)
3

julia> rem(15.0, 4)
3.0

julia> rem(23.1, 4.2)
2.1000000000000005

 

分数（有理数表現）　　//

julia> 22 // 7
22//7

julia> 22 / 7 # 実数除算
3.142857142857143

julia> float(22 // 7) # 実数に変換する
3.142857142857143

julia> 22 // 7 + 0 # 0 を足しても表示は不変
22//7

julia> 22 // 7 + 0.0 # 0.0 を足すと実数になる
3.142857142857143

演算子の省略（数学的表記）

乗算記号の省略

julia> x = 1; y = 2; z = 4 # 最後の評価結果のみが表示される
4

julia> x = 1; y = 2; z = 4; # 最後も ; をつければ，何も表示されない

julia> xyz = 12345; # ; をつければ，何も表示されない

julia> 2*(x + y)
6

julia> 2(x + y)
6

julia> 3.5(x+y)
10.5

julia> z(x + y)
ERROR: MethodError: objects of type Int64 are not callable

julia> z*(x + y)
12

julia> x = 3;

julia> 2^3x # 下に示すようにこれは 2 ^ (3 * x) を意味する。
512

julia> 2^9
512

julia> 6 // 2(2 + 1)　# 上の例でも同じだが，他の演算子より優先順位が高い。
1//1

数学関数

絶対値　　abs()

julia> abs(-123)
123

平方根　　sqrt()

julia> sqrt(3)
1.7320508075688772

立方根　　cbrt()

julia> cbrt(10)
2.154434690031884

julia> 10^(1/3) # cbrt(10) と同じ結果になる。
2.154434690031884

丸め　　round()

julia> round(1.5)
2.0

julia> round(2.5) # 注意！！ 単なる四捨五入ではない！！
2.0

julia> round(1.23456, digits=2) # 小数点以下を指定して丸める。
1.23

julia> round(1234, digits=-2) # 小数点の左でも丸められる。
1200.0

床　　floor()

julia> floor(3.145)
3.0

julia> floor(-3.145) # 引数を越えない整数！
-4.0

天井　　ceil()

julia> ceil(3.145)
4.0

julia> ceil(-3.145) # 引数より大きいか等しい数
-3.0

切り捨て　　trunc()

julia> trunc(1.3)
1.0

julia> trunc(-1.3) # 0 方向への丸め
-1.0

絶対値　　abs()

julia> abs(-12)
12

符号　　sign(x)

julia> sign(-1.2)
-1.0

julia> sign(0)
0

julia> sign(10.4)
1.0

符号付け　　copysign(x, y)

x の絶対値に y の符号を付けたものを返す。

julia> copysign(10, -23)
-10

最大公約数　　gcd()

julia> gcd(36, 96)
12

最小公倍数　　lcm()

julia> lcm(36, 96)
288

指数関数　　exp() exp10(), exp2(),

julia> exp(1) # e^1 = ネイピア数
2.718281828459045

julia> exp(2.32) # == e ^ 2.32
10.175674306073333

julia> exp10(1.23) # == 10^1.23
16.982436524617444

julia> exp2(5) # == 2 ^ 5
32.0

対数関数　　log(), log10(), log2()

julia> log(2) # 自然対数
0.6931471805599453

julia> log10(2) # 常用対数
0.3010299956639812

julia> log2(2) # 底が 2 の定数
1.0

三角関数　　sin(), cos(), tan()

sind(), cosd(), tand() は引数が「度」である。

julia> x = pi / 3 # 角度60度
1.0471975511965976

julia> sin(x) # sqrt(3)/2
0.8660254037844386

julia> sind(60)　# 60度
0.8660254037844386

julia> cos(x) # 1/2
0.5000000000000001

julia> tan(x) # sqrt(3)/1
1.7320508075688767

逆三角関数　　asin(), acos(), atan()

julia> asin(sin(1.2))
1.1999999999999997

julia> acos(cos(1.2))
1.2

julia> atan(tan(1.2))
1.2

双曲線関数　　sinh(), cosh(), tanh()

julia> sinh(2)
3.626860407847019

julia> cosh(2)
3.7621956910836314

julia> tanh(2)
0.9640275800758169

逆双曲線関数　　asinh(), acosh(), atanh()

julia> asinh(sinh(2))
2.0

julia> acosh(cosh(2))
2.0

julia> atanh(tanh(2))
2.0000000000000004

その他，特別な関数がある。SpecialFunctions.jl.

文字に対する関数

文字のコード

julia> Int('a')
97

コードから文字

julia> Char(97)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

文字に対する演算

julia> 'A' < 'B'
true

julia> 'C' - 'A'
2

julia> 'A' + 5
'F': ASCII/Unicode U+0046 (category Lu: Letter, uppercase)

文字列に対する操作

julia> str = "Hello, world.\n"
"Hello, world.\n"

文字（列）の取り出し

julia> str[1]
'H': ASCII/Unicode U+0048 (category Lu: Letter, uppercase)

julia> str[begin]
'H': ASCII/Unicode U+0048 (category Lu: Letter, uppercase)

julia> str[end]
'\n': ASCII/Unicode U+000A (category Cc: Other, control)

julia> str[end - 1]
'.': ASCII/Unicode U+002E (category Po: Punctuation, other)

julia> str[4:9]
"lo, wo"

julia> str[6]
',': ASCII/Unicode U+002C (category Po: Punctuation, other)

julia> str[6:6]
","

文字列抽出関数　　SubString()

julia> SubString(str, 1, 4)
"Hell"

文字列連結　　string()

julia> greet = "Hello"
"Hello"

julia> whom = "world"
"world"

julia> string(greet, ", ", whom, ".\n")
"Hello, world.\n"

'$変数' を '変数の値' で置き換える

julia> "$greet, $whom.\n"
"Hello, world.\n"

julia> print("I have \$100 in my account.\n")　# $ のエスケープ
I have $100 in my account.

文字連結演算子　　*

julia> greet * ", " * whom * ".\n"
"Hello, world.\n"

文字列の長さ　　length()

julia> length(str)
14

文字列の比較

julia> "abc" < "abcd"
true

julia> "abc" != "def"
true

トリプルクオートで囲まれたテキスト

julia> str = """
       Hello,
       World.
       """
"Hello,\nWorld.\n"

文字の位置　　findfirst(), findlast(), findnext(), findprev()

julia> findfirst(isequal('o'), "xylophone")
4

julia> findlast(isequal('o'), "xylophone")
7

julia> indfirst(isequal('z'), "xylophone")
ERROR: UndefVarError: indfirst not defined
Stacktrace:
 [1] top-level scope at REPL[81]:1

第 3 引数でオフセットを指定できる。

julia> findnext(isequal('o'), "xylophone", 1)
4

julia> findnext(isequal('o'), "xylophone", 5)
7

julia> findprev(isequal('o'), "xylophone", 5)
4

julia> findnext(isequal('o'), "xylophone", 8)

文字（列）が含まれるか　　occursin()

julia> occursin("world", "Hello, world.")
true

julia> occursin("l", "Hello, world.")
true

julia> occursin("q", "Hello, world.")
false

julia> occursin('q', "Hello, world.")
false

文字列の繰り返し　　repeat()

julia> repeat(".:Z:.", 10)
".:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:."

文字列連結（区切り文字指定）　　join()

julia> join(["apples", "bananas", "pineapples"], ", ", " and ")
"apples, bananas and pineapples"

 

 

Julia -- 2（注釈，出力，データ型，定数，変数）

注釈

'#' 以下が注釈になる。
複数行の注釈は '#=' 行で始まり '=#' 行で終わる。

出力

println() # 出力後改行する。
print()   # 出力後改行しない。

データ型　　typeof(arg)

文字列

ダブルクオートでくくる。

julia> println("Hello, world!")
Hello, world!

シングルクオートでくくると，「文字列ではない！」と言われる。

julia> println('Hello.world!')
ERROR: syntax: character literal contains multiple characters

julia> typeof("qwerty")
String

文字

シングルクオートでくくれるのは 1 文字のみ。それは「文字」である。

julia> 'A'
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)

julia> typeof('a')
Char

julia> '9'
'9': ASCII/Unicode U+0039 (category Nd: Number, decimal digit)

julia> '/'
'/': ASCII/Unicode U+002F (category Po: Punctuation, other)

ちなみに，後で出てくる割り算演算子「÷」は

julia> '÷'
'÷': Unicode U+00F7 (category Sm: Symbol, math)

数

整数

julia> 123
123

julia> typeof(123)
Int64

julia> typeof(1234567890000000)
Int64

julia> typeof(12345678900000000000000)
Int128

julia> typeof(123456789000000000000000000000000000000000000000000)
BigInt

julia> for T in [Int8,Int16,Int32,Int64,Int128,UInt8,UInt16,UInt32,UInt64,UInt128] println("$(lpad(T,7)): [$(typemin(T)),$(typemax(T))]")
       end
   Int8: [-128,127]
  Int16: [-32768,32767]
  Int32: [-2147483648,2147483647]
  Int64: [-9223372036854775808,9223372036854775807]
 Int128: [-170141183460469231731687303715884105728,170141183460469231731687303715884105727]
  UInt8: [0,255]
 UInt16: [0,65535]
 UInt32: [0,4294967295]
 UInt64: [0,18446744073709551615]
UInt128: [0,340282366920938463463374607431768211455]

実数

julia> 1.234
1.234

julia> 1.234e2 # 指数表記の場合には x.xxxe±yy のみ x.xxxd±yy はエラー（e のほか，E も可）
123.4

julia> typeof(1.234)
Float64

julia> Inf # ∞
Inf

julia> -Inf # -∞
-Inf

julia> eps(Float64) # Machine epsilon
2.220446049250313e-16

julia> eps(1.0)
2.220446049250313e-16

虚数　　実部 ± 虚部im で表す。

julia> 7 + 2im
7 + 2im

julia> typeof(7 + 2im)
Complex{Int64}

定数

円周率

julia> π
π = 3.1415926535897...

julia> pi
π = 3.1415926535897...

julia> 1pi # こうすれば "π = " はつかない

3.141592653589793

julia> 2π # 2 * π と同じ（* が省略できる）
6.283185307179586

julia> 2 * pi
6.283185307179586

julia> "2pi" # 単なる文字列
"2pi"

ネイピア数　　e

julia> ℯ # アルファベットの e ではない。FEP で入力する。
ℯ = 2.7182818284590...

julia> 1ℯ # こうすれば "ℯ = " はつかない
2.718281828459045

julia> MathConstants.e # または，このように書く
ℯ = 2.7182818284590...

julia> 1MathConstants.e
2.718281828459045

julia> exp(1) # どこかで定数を指定しておくのが最も簡単か？
2.718281828459045

julia> napier_constant = exp(1)
2.718281828459045

julia> napier_constant 
2.718281828459045

変数

日本語の変数名も使える（非推奨）

julia> 我が輩 = "猫"
"猫"

julia> 我が輩
"猫"

★★ 物知り博士 ★★

バックスラッシュに続いて LaTeX のシンボル名などを入力し，そのまま続けて キーを押すと，ギリシア文字の変数名を入力できる。

julia> α  = 1.5 # \ alpaha の順に入力
1.5

julia> Γ = 5.7 # \ Gamma の順に入力
5.7

たとえば，'Γ' ってどうやって入力するのか？と思ったら，'?' に続いて（help モードになってから）'Γ' をコピーペーストすると入力方法を教えてくれる。

"Γ" can be typed by \Gamma

"\alpha\hat2" を入力してみよ。その後で "?" を入力後，示された文字をコピー・ペーストしてみよ。

出力 -- 2

文字列内で "$" に続けて変数名を書くと，変数展開される。

julia> 我が輩 = "猫"
"猫"

julia> println("我が輩は$(我が輩)である")
我が輩は猫である

julia> "$(2pi)"
"6.283185307179586"

julia> "2π = $(2pi)"
"2π = 6.283185307179586"

julia> x = 123
123

julia> println("answer = $x")
answer = 123

julia> println("answer = $(x + 100).") # 一般的には式は (...) でくくる。
answer = 223.

Julia を始める！！

Julia を始めるぞ 2020/12/24/ 14:57:09

ダウンロード・インストール

https://julialang.org/downloads/ から，julia-1.5.3-mac64.dmg をダウンロードする。
ダブルクリックで Julia-1.5.3 というインストールディスクイメージができる。
Julia-1.5.app を Applications フォルダにコピーする（ドックにも入れておくとよい）。

起動と終了

起動の前に書いておく。終了はプロンプトに対して exit() とタイプする。

Applications フォルダの Julia-1.5.app をダブルクリックで起動する（ドックのアイコンはシングルクリック）。

ダブルクリックは exec '/Applications/Julia-1.5.app/Contents/Resources/julia/bin/julia' を実行することになり，ターミナルで以下のように Julia のインタープリタ画面が開く。

なお，ターミナルから julia とタイプすることで起動するようにするには，一度以下の手順を踏む。

　/usr/local/bin へ移動し，もしそこに既に julia があれば消去（確認の上で）し，symlink を作る。

　$ cd /usr/local/bin
　$ ln -s /Applications/Julia-1.5.app/Contents/Resources/julia/bin/julia /usr/local/bin/julia

 $ exec '/Applications/Julia-1.5.app/Contents/Resources/julia/bin/julia'
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.5.3 (2020-11-09)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia> 

Type "?" for help
ヘルプは "?" とタイプせよ

とあるので，言われているように "?" を入力してみと，以下が表示される。
なお，"?" を入力すると，プロンプトが "help?> " になる。

help?> 
search:  ] [ = $ ; ( { ) ? . } ⊻ ⊋ ⊊ ⊉ ⊈ ⊇ ⊆ ≥ ≤ ≢ ≡ ≠ ≉ ≈ ∪ ∩ ∛ √ ∘ ∌ ∋ ∉ ∈ ℯ π ÷ ~ | ^ \ > < : / - + * ' & % ! && if

  Welcome to Julia 1.5.3. The full manual is available at
  Julia 1.5.3 へようこそ。完全なマニュアルは以下で得られる。
  https://docs.julialang.org

  as well as many great tutorials and learning resources:
  たくさんの優れたチュートリアルや学習リソースは，以下で得られる。
  https://julialang.org/learning/

  For help on a specific function or macro, type ? followed by its name, e.g. ?cos, or ?@time, and press enter.
  特定の関数やマクロのヘルプは ? に続いてその名前をタイプせよ。たとえば，?cos, ?@time, とタイプしてエンターキーを押す。

  Type ; to enter shell mode, ] to enter package mode.
  ";" とタイプすればシェル・モード(shell mode)，"]" でパッケージ・モード(package mode) に入る。

  プロンプトは，シェル・モードのときには"shell> "，パッケージ・モードのときには "(@v1.5) pkg " になる。
  それぞれの意味は後ほど。
  対話モードに戻るときは delete キーを押す。

オンライン・ヘルプ

?cos で，以下が示される。"search:" の後には，その他にこんなものもあるよというサジェスチョン（当然ながら，全部ではない。たとえば sin はその中にない）。

help?> cos
search: cos cosh cosd cosc cospi acos acosh acosd sincos sincosd const close isconst copysign MathConstants coalesce

  cos(x)

  Compute cosine of x, where x is in radians.

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

  cos(A::AbstractMatrix)

  Compute the matrix cosine of a square matrix A.

  If A is symmetric or Hermitian, its eigendecomposition (eigen) is used to compute the cosine. Otherwise, the cosine is determined by calling exp.

  Examples
  ≡≡≡≡≡≡≡≡≡≡

  julia> cos(fill(1.0, (2,2)))
  2×2 Array{Float64,2}:
    0.291927  -0.708073
   -0.708073   0.291927

算術演算子
とにかくやってみようと足し算，引き算，...。

四則演算　+, -, *, /

羃乗は ** か ^ かと思って，まず 3**2 をやると，「エラー:x^y を使え」とのこと
ERROR: syntax: use "x^y" instead of "x**y" for exponentiation, and "x..." instead of "**x" for splatting.
念のため，オンラインヘルプを見ると，長い説明があるが取りあえず必要な最初の部分だけを見ると，

help?> ^
search: ^

  ^(x, y)

  Exponentiation operator. If x is a matrix, computes matrix exponentiation.

  If y is an Int literal (e.g. 2 in x^2 or -3 in x^-3), the Julia code x^y is transformed by the compiler to
  Base.literal_pow(^, x, Val(y)), to enable compile-time specialization on the value of the exponent. (As a default
  fallback we have Base.literal_pow(^, x, Val(y)) = ^(x,y), where usually ^ == Base.^ unless ^ has been defined in the
  calling namespace.)

羃乗演算子は ^(x, y) と書いてある。その後で x^y でもいいよとも書いてある。 

julia> ^(2, 0.5)
1.4142135623730951

julia> 2^0.5
1.4142135623730951

ここでピン！とくる。「Julia って関数言語？」"+(12, 34)" を入力してみる。
思った通り，

julia> +(12, 34)
46

"//" は，

  //(num, den)

  Divide two integers or rational numbers, giving a Rational result.
  整数または有理数の商

  Examples
  ≡≡≡≡≡≡≡≡≡≡

  julia> 3 // 5
  3//5
  
  julia> (3 // 5) // (2 // 1)
  3//10

"%" は，

  rem(x, y)
  %(x, y)

  Remainder from Euclidean division, returning a value of the same sign as x, and smaller in magnitude than y. This
  value is always exact.
  通常の剰余。結果は，x と同じ符号で，y より小さい数になる。常に正確な値である。

  Examples
  ≡≡≡≡≡≡≡≡≡≡

  julia> x = 15; y = 4;
  
  julia> x % y
  3
  
  julia> x == div(x, y) * y + rem(x, y)
  true

例に出てきた，"div" は,

help?> div
search: div divrem DivideError splitdrive code_native @code_native

  div(x, y)
  ÷(x, y)

  The quotient from Euclidean division. Computes x/y, truncated to an integer.
  整数除算。割り算の結果の小数点以下を切り捨てて整数になる。

  "÷" は FEP で入力可。
 
  Examples
  ≡≡≡≡≡≡≡≡≡≡

  julia> 9 ÷ 4
  2
  
  julia> -5 ÷ 3
  -1
  
  julia> 5.0 ÷ 2
  2.0

あれこれ試行錯誤していても切りがないので，ひとまず Julia を終了させようとして，さて，なんと入力する。

quit はエラーになった。

julia> quit
ERROR: UndefVarError: quit not defined

オンライン・ヘルプは以下のように言う。

help?> quit
search: QuickSort PartialQuickSort

Couldn't find quit
Perhaps you meant quote, edit, Cuint, exit, wait, sqrt, Main, @edit, Cint, Dict, Pair, Set, Text, acot, asin, big or cat
  No documentation found.

  Binding quit does not exist.

多分 exit と，オンライン・ヘルプに聞き直す。

help?> exit
search: exit atexit textwidth process_exited indexin nextind IndexLinear TextDisplay istextmime Exception

  exit(code=0)

  Stop the program with an exit code.
  プログラムを終了コードで終了する。
  The default exit code is zero, indicating that the program completed successfully.
  デフォルトの終了コードは 0 で，プログラムが正常終了（成功裏に終了）したことを表す。
  In an interactive session, exit() can be called with the keyboard shortcut ^D.
  対話セッションの場合には exit() はキーボードショートカット '^D' (control + D) でもよい。

さて，うろうろしていないで，本格的に Julia を学ぼう。

Julia 1.5 Documentation
https://docs.julialang.org/

次回に続く（多分すぐに）

単項演算子（-）を知らないのか

> scikit-learn の cross_val_score はMAE を マイナスで返す ので、-1 がかけられています。(※理由はよく分かりませんでした※)

>    scores = -1 * cross_val_score(my_pipeline,  X,  y, cv=3, scoring='neg_mean_absolute_error')

この人は，変数 x の符号を変えるとき，-1 * x と書くのだろうか（たしかにそのように書く人を何人か見たけど）