0

I'm looking to convert a string to a float with out loss of data; for example if I use istringstream or ::atof(x.c_str()) I loose data due to rounding I guess.

Normally this isn't a issue for me but I'm using data that has to be the same as its read. Here's a example of a number and what it's converted to.

-8.000001 -> -8
-0.6257381 -> -0.625738
12.0 -> 12 (drops the .0)

If anyone could help me out I'd be very grateful

Thanks Matt

Makka
  • 234
  • 4
  • 13
  • 5
    Are you sure you're not just printing them with less precision? And I'd recommend using something to convert whose error is not a valid result. – chris Jun 24 '13 at 13:45
  • 5
    Generally, that's not possible as you will have always rounding errors due to the limited amount of bits a float/double has. Also, there are rounding errors that are different in Base 10 as in Base 2. Plus, 12.0 is the same as 12 in the binary representation, so you can't differ between them – bennofs Jun 24 '13 at 13:46
  • Think your right there Bennofs – Makka Jun 24 '13 at 14:00
  • For starters, you are making base 10 assumptions using base 2 math. computers generally dont do base 10 math. If you want base 10 math then you need to do it yourself, string based or whatever. – old_timer Jun 24 '13 at 14:24

3 Answers3

5

There are three potential issues in your question:

  1. The amount of precision displayed. To control the precision used, include #include <iomanip> and use std::cout << std::setprecision(17); to set the number of digits to use.

  2. Formatting. In the case of wanting “12.0” for “12.0”, you should be aware that “.0” is not stored in a float or double. The double just contains the value 12; it does not contain any information about the original precision or an error interval. It is exactly 12 and nothing else. If you want it formatted in a particular way, you must either use the format flags for the I/O stream or write your own code to do the formatting.

  3. Accuracy. The common float and double types cannot exactly represent 8.000001 or 0.6257381. They use binary to represent floating-point values, and there will be slight errors when decimal numerals are converted to binary. If you have very simple uses of floating-point and are working with significantly fewer digits than the limits of float and double, then you might be able to ignore this and simply format numbers with your limited numbers of digits. If you exceed simple cases, you would need to do error analysis, which can be quite complicated.

Eric Postpischil
  • 195,579
  • 13
  • 168
  • 312
1

You're going to need a different data type.

A floating-point decimal type will allow you to store the number exactly the way you want. In such a type, numbers are stored as a pair ( mantissa, exponent ) just like scientific notation and much like IEEE binary floating point.

Your examples would be stored as

(-8000001, -6)
(-6257381, -7)
(120, -1)

For example, the ISO 11073 standard for medical device communications uses such a format.

The downside is that arithmetic will be quite slow, since all the floating-point arithmetic hardware is designed to work with number using an exponent with base-2.

Ben Voigt
  • 277,958
  • 43
  • 419
  • 720
0

As a rule of thumb, a float is only precise to 6 significant figures. So if your string has more digits in that you'll hit the precision limit.

A double will give you, not surprisingly, about double this precision; i.e. 12 significant figures.

See Number of significant digits for a floating point type for further remarks.

Community
  • 1
  • 1
Bathsheba
  • 231,907
  • 34
  • 361
  • 483
  • I thaught this could be the issue, but I checked it out online and came to the conclusion the double I'm using should be ok, I think it's just c++ rounding issues that cannot be solved :/ – Makka Jun 24 '13 at 13:59
  • Oh, if you're using a double, then something else is awry for sure. I'd look into the printing precision; see @chris' comments. – Bathsheba Jun 24 '13 at 14:04