Re: float to string to float, with first float == second float

From:

James Kanze <james.kanze@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Thu, 8 Oct 2009 02:47:30 -0700 (PDT)

Message-ID:

<4df9f89f-ee79-462b-b0e2-b12b56a7f93d@b18g2000vbl.googlegroups.com>

On Oct 6, 3:48 pm, Rune Allnor <all...@tele.ntnu.no> wrote:

On 6 Okt, 15:47, Carsten Fuchs <CarstenFu...@T-Online.de> wrote:

Rune Allnor wrote:

1) Approximations might occur when the value is first loaded
2) Approximations might occur when the value is serialized
3) Approximations might occur when the value is de-serialized

The problem is steps 2) and 3): Unless you can guarantee
that either

a) No approximations occur in steps 2) and 3)
b) The approximation in 3) exactly cancels the
approximation introduced in 2)

Yes, agreed, one or both of a) and b is/are the implied
assumption.

I also should have mentioned in my original post where I got
the idea for all this
from:http://www.open-std.org/JTC1/sc22/wg21/docs/papers/2006/n2005.pdf

So if I understand this correctly, for step 2) there is a
certain number of digits (max_digits10 in the paper) that
express the original value in "equal or higher precision"
than was in the original float.

OK, so let's play with numbers:

The number D of digits needed to represent a number N in
base 10 notation is

D = ceil(log10(N)).

For a single-precision floating-point number, there are some
20 bits in the mantissa, so the number of digits D to represent
the mantissa becomes

D = ceil(log10(2^20))
  = ceil(20*log10(2))
  > 20*floor(log10(2))
  > 20*3
  > 60.

So one needs *at*least* 60 digits to represent the number.

Exactly. There's no requirement for an exact representation,
however; only one that guarantees a round trip conversion. For
that, 9 digits suffice, see the section "Binary to Decimal
Conversion" in http://www.validlab.com/goldberg/paper.pdf.
(Until you've read and understood this paper, you have no
business using floating point in a program.)

--
James Kanze.