soukouki’s diary

誰かの役に立つ記事をかけたらいいなあ

電卓をワンライナーで書きたい!

さて、4ヶ月ぶりの更新です。

まぁ、やることはタイトルのとおりです。

改行、セミコロンと、セミコロンに近いもの((a=2)&&([a,a]) #=>[2, 2])は縛っていきます。

まずは逆ポーランド式電卓から

f = ->(s){->(t){(t==s)? s : f[t]}[s.gsub(/(-?\d+) (-?\d+) ([-+\/*%])/){$1.to_i.send($3, $2.to_i)}]}

f["1 2 3 + *"] #=> "5"

アンダースタンディング コンピュテーションって本を読んでるとだんだんRubyラムダ式に慣れてくる・・

基本的に変数を使いたくなったらラムダ式に変換します。再帰でなければ・・・

仕組みは正規表現マッチとObject#sendを使って、正規表現にマッチしなくなるまで変換し続けていく形です。

このときは楽だった・・

そして、普通の電卓へ

f = ->(r){->(a){r[->(b){r[->(d){r[->(g){g.gsub(/(-?\d+)([*\/])(-?\d+)/){$1.to_i.send($2,$3.to_i)}},d].gsub(/(-?\d+)([-+])(-?\d+)(?![*\/])/){$1.to_i.send($2,$3.to_i)}},b].gsub(/\((-?\d+)\)/){$1}},a]}}[->(f,v){->(f){->(x){->(m){f[x[x]][m]}}[->(x){->(m){f[x[x]][m]}}]}[->(x){->(s){->(a){a==s ? a : x[a]}[f[s]]}}][v]}]

f["1*2/3"] #=> "0"
f["-1+2"] #=> "1"
f["1*2+3*4+5+6+7"] #=> "32"
f["-1*(2+3)"] #=> "-5"
f["1+2*(3+4)*5"] #=> "71"

お化けです。

このままじゃ読めないので、分解していきます。

r = ->(f,v){->(f){->(x){->(m){f[x[x]][m]}}[->(x){->(m){f[x[x]][m]}}]}[->(x){->(s){->(a){a==s ? a : x[a]}[f[s]]}}][v]}
f = ->(a){r[->(b){r[->(d){r[->(g){g.gsub(/(-?\d+)([*\/])(-?\d+)/){$1.to_i.send($2,$3.to_i)}},d].gsub(/(-?\d+)([-+])(-?\d+)(?![*\/])/){$1.to_i.send($2,$3.to_i)}},b].gsub(/\((-?\d+)\)/){$1}},a]}

まずは、rとfに分解します。

rの詳細とZコンビネータ

さらにrを分解します。

z = ->(f){->(x){->(m){f[x[x]][m]}}[->(x){->(m){f[x[x]][m]}}]}
r = ->(f,v){z[->(x){->(s){->(a){a==s ? a : x[a]}[f[s]]}}][v]}

(一つラムダ式とその呼出が増えていますが、動きは一緒です。)

元の形ではrの内部でrを呼び出して再帰をしていたのですが、この縛りだとrの名前がなくなるので、簡単に再帰はできません。

なので、Zコンビネータを使います。 obelisk.hatenablog.com(詳細は丸投げ!) (ぶっちゃけZコンビネータの中身は理解できてないし、これの使い方に試行錯誤する時間が多分一番長かった気がする)

fの詳細

ついでにfもわかりやすくしてみます。

# 参考用r(Zコンビネータ使用前)
r = ->(f,v){
    a=f[v]
    a==v ? a : r[f,a]
}
f = ->(a){
    r[
        ->(b){
            r[
                ->(d){
                    r[
                        ->(g){
                            g.gsub(/(-?\d+)([*\/])(-?\d+)/){$1.to_i.send($2,$3.to_i)}
                        },
                        d
                    ]
                        .gsub(/(-?\d+)([-+])(-?\d+)(?![*\/])/){$1.to_i.send($2,$3.to_i)}
                },
                b
            ]
                .gsub(/\((-?\d+)\)/){$1}
        },
        a
    ]
}

実はものすごいネストしています。

r(f,v)は値が変わらなくなるまでfを呼び続けます。逆ポーランド式電卓の方にもそんな感じの部分があります。

そしてそれをネストしながら呼び続けることによって、優先順位のある計算を行います。

括弧の処理は中の+-*/を計算し尽くしてできた(x)xに置き換えることによって行っています。

計算の様子

r内にp [f,v,a]を置いてみると、計算の様子がよくわかります。(Procの部分を置き換えています。)

(なんか括弧の優先順位が違うような気がするけど、とりあえず正常に動くので気にしない・・バグがあったらコメント等で教えてくれるとありがたいです。)

# f["1*2/3"]
[#<*/の処理>, "1*2/3", "2/3"]
[#<*/の処理>, "2/3", "0"]
[#<*/の処理>, "0", "0"]
[#<+-の処理>, "1*2/3", "0"]
[#<*/の処理>, "0", "0"]
[#<+-の処理>, "0", "0"]
[#<括弧の処理>, "1*2/3", "0"]
[#<*/の処理>, "0", "0"]
[#<+-の処理>, "0", "0"]
[#<括弧の処理>, "0", "0"]

# f["-1+2"]
[#<*/の処理>, "-1+2", "-1+2"]
[#<+-の処理>, "-1+2", "1"]
[#<*/の処理>, "1", "1"]
[#<+-の処理>, "1", "1"]
[#<括弧の処理>, "-1+2", "1"]
[#<*/の処理>, "1", "1"]
[#<+-の処理>, "1", "1"]
[#<括弧の処理>, "1", "1"]

# f["1*2+3*4+5+6+7"]
[#<*/の処理>, "1*2+3*4+5+6+7", "2+12+5+6+7"]
[#<*/の処理>, "2+12+5+6+7", "2+12+5+6+7"]
[#<+-の処理>, "1*2+3*4+5+6+7", "14+11+7"]
[#<*/の処理>, "14+11+7", "14+11+7"]
[#<+-の処理>, "14+11+7", "25+7"]
[#<*/の処理>, "25+7", "25+7"]
[#<+-の処理>, "25+7", "32"]
[#<*/の処理>, "32", "32"]
[#<+-の処理>, "32", "32"]
[#<括弧の処理>, "1*2+3*4+5+6+7", "32"]
[#<*/の処理>, "32", "32"]
[#<+-の処理>, "32", "32"]
[#<括弧の処理>, "32", "32"]

# f["-1*(2+3)"]
[#<*/の処理>, "-1*(2+3)", "-1*(2+3)"]
[#<+-の処理>, "-1*(2+3)", "-1*(5)"]
[#<*/の処理>, "-1*(5)", "-1*(5)"]
[#<+-の処理>, "-1*(5)", "-1*(5)"]
[#<括弧の処理>, "-1*(2+3)", "-1*5"]
[#<*/の処理>, "-1*5", "-5"]
[#<*/の処理>, "-5", "-5"]
[#<+-の処理>, "-1*5", "-5"]
[#<*/の処理>, "-5", "-5"]
[#<+-の処理>, "-5", "-5"]
[#<括弧の処理>, "-1*5", "-5"]
[#<*/の処理>, "-5", "-5"]
[#<+-の処理>, "-5", "-5"]
[#<括弧の処理>, "-5", "-5"]

# f["1+2*(3+4)*5"]
[#<*/の処理>, "1+2*(3+4)*5", "1+2*(3+4)*5"]
[#<+-の処理>, "1+2*(3+4)*5", "1+2*(7)*5"]
[#<*/の処理>, "1+2*(7)*5", "1+2*(7)*5"]
[#<+-の処理>, "1+2*(7)*5", "1+2*(7)*5"]
[#<括弧の処理>, "1+2*(3+4)*5", "1+2*7*5"]
[#<*/の処理>, "1+2*7*5", "1+14*5"]
[#<*/の処理>, "1+14*5", "1+70"]
[#<*/の処理>, "1+70", "1+70"]
[#<+-の処理>, "1+2*7*5", "71"]
[#<*/の処理>, "71", "71"]
[#<+-の処理>, "71", "71"]
[#<括弧の処理>, "1+2*7*5", "71"]
[#<*/の処理>, "71", "71"]
[#<+-の処理>, "71", "71"]
[#<括弧の処理>, "71", "71"]

おまけ

製作途中

r = ->(f,v){a=f[v];a==v ? a : r[f,a]}
f1 = ->(s){r[->(t){t.gsub(/(-?\d+)([*\/])(-?\d+)/){$1.to_i.send($2,$3.to_i)}},s]}
f2 = ->(s){r[->(t){f1[t].gsub(/(-?\d+)([-+])(-?\d+)(?![*\/])/){$1.to_i.send($2,$3.to_i)}},s]}
f = ->(s){r[->(t){f2[t].gsub(/\((-?\d+)\)/){$1}},s]}

ハマったところ

  • rの再帰の呼び出しr[f,a]f[a]にしていて、なんかおかしいなと思いつつも大体の式はうまく動いちゃうので微妙なバグでした。
  • f1は楽だけど、f2のf1を呼ぶ部分で迷った・・3重ループになるはずだから、多分ここで合ってるはず・・実際式を入れたら動くのだし()
  • Zコンビネータの使い方・・あれって2つの引数を持つ再帰はできないのかな・・?最初fも再帰の引数に入れてて詰まってました。

以上

秋の夜長にプログラミング!そして次の日の朝起きられなくなる・・・

Rubyで大きな値(数億桁)を扱うときのメモ

ある日。フィボナッチ数列の10億万番目とその前2つの値を計算して、割って黄金比を求めているときのメモ。

nilを代入しないとGCは片付けてくれない

まぁ、メモリがそこまで逼迫することはあまりないと思うけど。

割り算ができない

浮動小数点数に直すとInfinity行っちゃいます。

最初NaNを見た時は「えっ」ってなります。

小数を使いたい時は割られる側に大きな数を掛けておきましょう。

Integer#** の右側に大きな値を置けない

よく引っかかるやつ。

10**10_0000_0000 # なら
([10**(10_0000_0000/100)]*100).inject(:*) # 100の部分は適当に割り切れる数字で

計算に結構な時間がかかるのであれ(

右側の値は100万くらいなら大丈夫っぽい。

Integer(Bignum)#to_s でエラーが出る

to_s お前もか

`to_s': bignum too big to convert into `string' (RangeError) はえぇ・・

OKU = ([10**(100_0000)]*100).inject(:*) # ここだけで100秒かかります
def very_big_num_to_string n
    if n < OKU
        n.to_s
    else
        bottom = n % OKU
        top = n / OKU
        n = nil
        very_big_num_to_string(top) << bottom.to_s
    end
end

みたいなメソッドを作っておけばいいです。遅いけど...

file_nameとfilenameはどっちが多い?

ある時、ふと疑問に思ったのです。

file_nameと、filenameはどっちがいいのだろうかと。

ふつう単語の間にアンダーバーを入れる記法だと、file_nameです。

ですが、filenameの方をよく見かける気がします。

ってことで、githubで検索してみました。

filename Search · filename language:ruby · GitHub

file_name Search · file_name language:ruby · GitHub

結果は、

コードでの出現数
filename 2,951,932
file_name 804,566

と、Rubyではfilenameのほうがメジャーなようです。

ちなみに、いくつかのライブラリの結果です。 (CRubyは命名規則の違うC言語の部分があるのでやめておきました。)

rails rspec(組織全体で)
filename 129 70
file_name 50 35

filenameが多いですが、統一はされていないようです。

感想

Rubyではfilenameの方が多く使われてるっぽい。

とりあえずfilename使っとけばいいんじゃないかな。

english.stackexchange.com

コンパクトなRubyのREPLを作ったよ!

コンパクト。悪く言ったら低機能。

irbやpryとシェルの相性が悪かったので。

github.com (作ったよ!って言う割には別リポジトリに数か月前からあるのは内緒のお話)

対応してるもの

  • ローカル変数
  • マルチバイト文字

対応していないもの

  • 定義途中の改行(Enter押下)
  • ドキュメント等の読み込み
  • ステップ実行とか
  • などなど

23行のコンパクトなREPLです!

あ、最後に。

requireし直したい時は一回REPLを閉じてから開きます。

コマンドの引数にrequireするパスを指定できるのでうまく使ってくださいな。

Rubyのヒアドキュメントの配列の書き方

普通のヒアドキュメント

   <<-EOS
なんかいろいろ
  EOS

メソッドがついたヒアドキュメント

   <<-EOS.length
なんかいろいろ
  EOS

・・・配列のコンマはどこに置くんだ・・?

2回目のEOSの後ろ、2回目のEOSの次の行、3回目のEOSの前・・どれもうまくいかない

メソッドをそこに置くんだよな・・?もしや・・

ヒアドキュメントの配列

[
    <<-EOS,
なんかいろいろ
  EOS
    <<-EOS
なんかいろいろ
  EOS
]

できた!