ruby の数値の等値

これは何？

https://qiita.com/scivola/items/8db8f88c9bb0ddcf41cd#comment-c26bb656a534b70ea86a
の続き。

等しいということ

たとえば float が普通の単精度、double が普通の倍精度である C言語（float が単精度で計算される環境の場合）で。

C

double d1 = 1.1;
float f1 = 1.1f;
puts( d1 == f1 ? "true" : "false" ); // A

double d2 = 99999999.0;
float f2 = 99999999.0f;
int32_t i2 = 99999999;
puts( d2==f2 ? "true" : "false" ); // B
puts( f2==i2 ? "true" : "false" ); // C
puts( i2==d2 ? "true" : "false" ); // D

とした場合。

A は、両辺 double に変換される。
d1 は 1.10000000000000009 ぐらい。
f1 は 1.10000002 ぐらいで、 double に変換すると 1.10000002384185791 ぐらいになるので等しくない。

B も、両辺 double に変換される。
d2 は、99999999.0 になるが、
f2 は、単精度では 99999999 を表現できないので、 100000000.0 になる。
なので、等しくない。

C は、両辺 float に変換されての比較になる。
i2 は 99999999 だが、比較に当たり float に変換されて 100000000.0 になる。
なので、等しい。

D は、両辺 double に変換されての比較になる。
i2 は 99999999 で、比較に当たり double に変換される。 double なので桁落ちせず、 99999999.0 になる。
なので、等しい。

見てのとおり、推移律が成立していない。
しかし。C や Java の場合、同じ == 演算子で、何と何を比較するのかが動的に決まることはない（ないよね？）ので、推移律が成立しないような気分にはあまりならないと思う。

で。

ruby の場合はどうかというのがこの記事の主題。

ruby の場合

ruby にもいくつかの数値型がある

名前	内部	特徴
Integer	略	整数ならメモリの許す限り何でもOK
Float	浮動小数点数の2進数	2進数なので、 0.1 のような値は正確に表現できない
Rational	Integer 2個	四則演算している限り誤差なし
BigDecimal	10進数(のような感じ)	10進数なので、1÷3 の値は正確に表現できない

Integer と Float の比較

想像より難しいことがわかった。

ruby3.0

p 1.1==1 #=> false
p 1.0==1 #=> true
p 1==1.0.next_float #=> false
p 1==1.0.prev_float #=> false

このあたりを見ると、ああ Float にしてから比較してるのかなと思ったんだけど

ruby3.0

s="7"*17
f = s.to_f
i = s.to_i
p [ f, i ] #=> [7.777777777777778e+16, 77777777777777777]
p [f==i, f.to_f==i.to_f, f-i==0, (f-i).class]
# => [false, true, true, Float]
p f.to_f==i.to_f #=> true

f==i と f.to_f == i.to_f の結果が異なるのでそうでもない。
何が起こっているのかわからない。

Float と Rational の比較

ruby3.0

p 1.1==1r #=> false
p 1.0==1r #=> true
p 1.0==1.000000000000001r #=> false
p 1.0==1.0000000000000001r #=> true
s="7"*17
f = s.to_f
r = s.to_r
p [ f, r ] #=> [7.777777777777778e+16, (77777777777777777/1)]
p [f==r, f.to_f==r.to_f, f-r==0, (f-r).class]
# => [true, true, true, Float]
p f.to_f==r.to_f #=> true

Float にしてから比較しているとしか言いようがない結果。

Float より Rational のほうが表現できる値が広いので、わりと予期せぬ結果になりがちだと思う。

Float と BigDecimal の比較

こちらは BigDecimal に変換してから比較している感じ。

rby3.0

p 1.1==BigDecimal("1") #=> false
p 1.0==BigDecimal("1") #=> true
p 1.0==BigDecimal("1.000000000000001") #=> false
p 1.0==BigDecimal("1."+"0"*200+"1") #=> false
p 1.0.next_float==BigDecimal("1")#=> true
p 1.0.prev_float==BigDecimal("1")#=> false

p 1.0.next_float==BigDecimal("1")#=> true が怪しげだが、これは coerce の実装がそうなっているから。

ruby3.0

p BigDecimal("1").coerce( 1.0.next_float ) #=> [0.1e1, 0.1e1]
p BigDecimal("1").coerce( 1.0.prev_float ) #=> [0.9999999999999999e0, 0.1e1]

そうなってしまうのはなぜかというと、たぶん、 bigdecimal.h で
#define BIGDECIMAL_DOUBLE_FIGURES (1+DBL_DIG)
としているのが原因で
#define BIGDECIMAL_DOUBLE_FIGURES (2+DBL_DIG)
とすれば治るかも、と思っているけど、思っているだけで確かめてはいない。

Rational と BigDecimal の比較

こちらも BigDecimal に coerce しているけど、Float とはちょっと振る舞いがちがう。

ruby3.0

p 1.1r==BigDecimal("1") #=> false
p 1.0r==BigDecimal("1") #=> true
p 1.0r==BigDecimal("1.000000000000001") #=> false
p 1.0r==BigDecimal("1."+"0"*200+"1") #=> false
p 1.0.next_float.to_r==BigDecimal("1")#=> true
p 1.0.prev_float.to_r==BigDecimal("1")#=> true

next_float も prev_float も比較結果が true だが、これもそういう coerce だから。

ruby3.0

p BigDecimal("1").coerce( 1.0.next_float.to_r ) #=> [0.1e1, 0.1e1]
p BigDecimal("1").coerce( 1.0.prev_float.to_r ) #=> [0.1e1, 0.1e1]

ちなみに。 coerce で有理数を 10進数にまるめる桁数は、レシーバの桁数で決まるので

ruby3.0

s="1.00000000001000000000010000000000100000000001000000000010000000000100000000001"
BigDecimal(s[0,10])==s.to_r # => true
BigDecimal(s[0,20])==s.to_r # => false
BigDecimal(s[0,50])==s.to_r # => true
BigDecimal(s[0,60])==s.to_r # => false

と、奇妙なことが起こる。

様々な型で等値比較

BigDecimal(a)==Float(a) みたいなことを、 a を色々変えて試してみた。

全部 TRUE になっていないということは、推移律が成立していないということで、わりと気持ち悪いことではある。

"77777777777777777"

	Integer	Float	Rational	BigDecimal
Integer	TRUE	false	TRUE	TRUE
Float	false	TRUE	TRUE	false
Rational	TRUE	TRUE	TRUE	TRUE
BigDecimal	TRUE	false	TRUE	TRUE

前述のとおり、 Integer と Float の部分が謎。なんだろう。

"100..001" (400桁)

	Integer	Float	Rational	BigDecimal
Integer	TRUE	false	TRUE	TRUE
Float	false	TRUE	TRUE	false
Rational	TRUE	TRUE	TRUE	TRUE
BigDecimal	TRUE	false	TRUE	TRUE

Float は無限大になる。
にもかかわらず、 Float(略)==Rational(略) が true になるのは、右辺も Float に変換された結果無限大になってしまうから。

"1.0000000000000002"

この値は 1.0.next_float.to_s 。

	Float	Rational	BigDecimal
Float	TRUE	TRUE	false
Rational	TRUE	TRUE	TRUE
BigDecimal	false	TRUE	TRUE

次の "0.9999999999999999" と結果が違うところがおそろしい。

"0.9999999999999999"

この値は 1.0.prev_float.to_s 。

	Float	Rational	BigDecimal
Float	TRUE	false	TRUE
Rational	false	TRUE	TRUE
BigDecimal	TRUE	TRUE	TRUE

ちなみに、

ruby3.0

0.9999999999999999==0.9999999999999999.to_r
# => true
0.9999999999999999==0.9999999999999999r
# => false

である。

"1e-400"

	Float	Rational	BigDecimal
Float	TRUE	TRUE	false
Rational	TRUE	TRUE	TRUE
BigDecimal	false	TRUE	TRUE

Float("1e-400") は 0.0 なので、わかりやすく書くと下記のような感じ。

ruby3.0

r=Rational("1e-400");[r==0.0, r==0]
# => [true, false]

難しい。