Codecov Report

Merging #615 into master will decrease coverage by 0.06%.
The diff coverage is 72.09%.

@@            Coverage Diff             @@
##           master     #615      +/-   ##
==========================================
- Coverage   82.94%   82.88%   -0.07%     
==========================================
  Files          56       56              
  Lines        7501     7544      +43     
==========================================
+ Hits         6222     6253      +31     
- Misses       1027     1033       +6     
- Partials      252      258       +6

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update c52b53e...8146078. Read the comment docs.

@SD10 for test cases, can you include Ruby doc's examples? Like https://ruby-doc.org/core-2.4.0/Float.html#method-i-ceil

I'm implementing divmod now. All the others require NAN and INFINITE to be defined.

@st0012 How do you think we should implement these constants? We also need PI

I'm implementing divmod now. All the others require NAN and INFINITE to be defined.
@st0012 How do you think we should implement these constants? We also need PI

I had a look at the IEEE754 specification, the MRI source code, and the Golang API, and there are a few interesting points:

• Positive/negative infinity map to a single value each, different only in the sign. For this reason, Ruby has only a single Float::INFINITY constant, the positive infinity (the sign can be used in the language grammar for expressing the negative infinity, since it matches the binary representation)
• NaN is different, as there is no single value representing it. I'm a bit perplexed by the Ruby constant for it - notice that the documentation (Float::NAN [is] An expression representing a value which is “not a number”) in fact says a value, not the value. On the other hand, although Float::NaN can't be used in equality testing against itself, it can still be used in arithmetic, as it makes mathematical sense.

To summarize, based on my understanding, I think that:

• at least one Infinity constant, the positive one, is required; Go has APIs for getting the value (math.Inf);
• the Ruby Float#infinite? method is important;
• the Float#nan? method is required;
• I would leave the Float::NAN constant aside for now, waiting for somebody opening an issue with a use case.

• the Ruby Float#infinite? method is important;
• the Float#nan? method is required;

@saveriomiroddi Thanks for writing that up. I totally overlooked that we can still implement those methods.

@saveriomiraddi thanks for the information, learned a lot 🙇‍♂️

Float#nan? is pretty trivial to impliment.

a = Float::NAN
return a != a

NAN is the only float value for which this will be true.

@SD10 Is it ok if I take over this PR?

@st0012 Yes, no problems here 😓 Sorry

_{Sent with GitHawk}

@SD10 Since we have #664 for continuing the task, I'll close this