From: Benoit Daloze <eregontp@...>
Date: 2010-04-08T02:57:26+09:00
Subject: [ruby-core:29310] Re: [Feature #2152] Split functionality of 	Float#inspect and Float#to_s

--0016364d212f578ef20483a94b5e
Content-Type: text/plain; charset=ISO-8859-1

Hi,
On 7 April 2010 19:02, Yukihiro Matsumoto <matz@ruby-lang.org> wrote:

> Hi,
>
> As I stated in [ruby-core:27631], I don't object about having two
> string representation, one "human readable" and the other "more
> verbose".  Even though I am not fully against, it doesn't mean, I
> enjoy having two representation.  Float is float is float.  We should
> know about error when you treat with float, shouldn't we?
>
> Anyway, I feel like we still have two points:
>
> (1) We've got consensus which method to behave which so far.  Since
>    #inspect is a method for "human readable" string representation,
>    I think it is more suitable to get "human readable" float
>    representation.  Others want to #to_s to be "human readable" to
>    ease "Float #{f}".
>
> (2) Besides that, I am not sure whether the old behavior is the best
>    way to generate "human readable" representation.
>
>                                                        matz.
>
>
Then let's choose which representation is "human readable", maybe a third
one?

I spoke a bit about that in my last post, while I fear I'm more of a
beginner about technique:

So, double have a range (between two of them) of 2e-52 ~ 10e-16. Should we
then round at
15~16 digits ?

> n = 1.4 - 0.1 - 1.2
=> 0.09999999999999987
> "%.15f" % n
=> "0.100000000000000"
> "%.16f" % n
=> "0.0999999999999999"

So I think most people would agree with the "%.15f" result (without the
zeros of course).
The question is then: How to do it properly ?

P.S.: To my opinion, #inspect is usually more verbose than #to_s, so I
continue staying straight in my idea.
The bad thing with Float is you currently still need to "my Float: #{"%.2f"
% f}"
Inspect is, to my opinion, used mostly when debugging, almost never to print
result.
So if there is a verbose representation, I think it belongs to #inspect.
(I expect to have precise, even too verbose output when I 'p f')

--0016364d212f578ef20483a94b5e
Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable

<div class=3D"gmail_quote">Hi,</div><div class=3D"gmail_quote">On 7 April 2=
010 19:02, Yukihiro Matsumoto <span dir=3D"ltr">&lt;<a href=3D"mailto:matz@=
ruby-lang.org">matz@ruby-lang.org</a>&gt;</span> wrote:<br><blockquote clas=
s=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;pad=
ding-left:1ex;">

Hi,<br><br>As I stated in [ruby-core:27631], I don&#39;t object about havin=
g two<br>
string representation, one &quot;human readable&quot; and the other &quot;m=
ore<br>
verbose&quot;. =A0Even though I am not fully against, it doesn&#39;t mean, =
I<br>
enjoy having two representation. =A0Float is float is float. =A0We should<b=
r>
know about error when you treat with float, shouldn&#39;t we?<br>
<br>
Anyway, I feel like we still have two points:<br>
<br>
(1) We&#39;ve got consensus which method to behave which so far. =A0Since<b=
r>
 =A0 =A0#inspect is a method for &quot;human readable&quot; string represen=
tation,<br>
 =A0 =A0I think it is more suitable to get &quot;human readable&quot; float=
<br>
 =A0 =A0representation. =A0Others want to #to_s to be &quot;human readable&=
quot; to<br>
 =A0 =A0ease &quot;Float #{f}&quot;.<br>
<br>
(2) Besides that, I am not sure whether the old behavior is the best<br>
 =A0 =A0way to generate &quot;human readable&quot; representation.<br>
<br>
 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =
=A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0matz.<br>
<br></blockquote><div>=A0</div></div>Then let&#39;s choose which representa=
tion is &quot;human readable&quot;, maybe a third one?<div><br></div><div>I=
 spoke a bit about that in my last post, while I fear I&#39;m more of a beg=
inner about technique:</div>

<div><br></div><div><span class=3D"Apple-style-span" style=3D"font-family: =
arial, sans-serif; font-size: 13px; border-collapse: collapse; ">So, double=
 have a range (between two of them) of 2e-52 ~ 10e-16. Should we then round=
 at<br>

15~16 digits ?<br><br>&gt; n =3D 1.4 - 0.1 - 1.2<br>=3D&gt; 0.0999999999999=
9987<br>&gt; &quot;%.15f&quot; % n<br>=3D&gt; &quot;0.100000000000000&quot;=
<br>&gt; &quot;%.16f&quot; % n<br>=3D&gt; &quot;0.0999999999999999&quot;</s=
pan></div>

<div><br></div><div>So I think most people would agree with the &quot;%.15f=
&quot; result (without the zeros of course).</div><div>The question is then=
: How to do it properly ?</div><div><br></div><div>P.S.: To my opinion, #in=
spect is usually more verbose than #to_s, so I continue staying straight in=
 my idea.</div>

<div>The bad thing with Float is you currently still need to &quot;my Float=
: #{&quot;%.2f&quot; % f}&quot;</div><div>Inspect is, to my opinion, used m=
ostly when debugging, almost never to print result.</div><div>So if there i=
s a verbose representation, I think it belongs to #inspect.</div>

<div>(I expect to have precise, even too verbose output when I &#39;p f&#39=
;)</div>

--0016364d212f578ef20483a94b5e--