CODEWITHSUNDEEP
c++floating-point
user1739750
user1739750

Reputation: 37

Weird Rounding Occurs in C++ Function

I am writing a function in c++ that is supposed to find the largest single digit in the number passed (inputValue). For example, the answer for .345 is 5. However, after a while, the program is changing the inputValue to something along the lines of .3449 (and the largest digit is then set to 9). I have no idea why this is happening. Any help to resolve this problem would be greatly appreciated.

This is the function in my .hpp file

void LargeInput(const double inputValue)
//Function to find the largest value of the input
{
  int tempMax = 0,//Value that the temporary max number is in loop
  digit = 0,//Value of numbers after the decimal place
  test = 0,
  powerOten = 10;//Number multiplied by so that the next digit can be checked
  double number = inputValue;//A variable that can be changed in the function
  cout << "The number is still " << number << endl;
  for (int k = 1; k <= 6; k++)
  {
    test = (number*powerOten);
    cout << "test: " << test << endl;
    digit = test % 10;
    cout << (static_cast<int>(number*powerOten)) << endl;
    if (tempMax < digit)
      tempMax = digit;
    powerOten *= 10;
  }
  return;
}

Upvotes: 1

Views: 1279

Answers (4)

Eric Postpischil
Eric Postpischil

Reputation: 224335

As other answers have indicated, binary floating-point is incapable of representing most decimal numbers exactly. Therefore, you must reconsider your problem statement. Some alternatives are:

  • The number is passed as a double (specifically, a 64-bit IEEE-754 binary floating-point value), and you wish to find the largest digit in the decimal representation of the exact value passed. In this case, the solution suggested by user millimoose will work (provided the asprintf or snprintf function used is of good quality, so that it does not incur rounding errors that prevent it from producing correctly rounded output).
  • The number is passed as a double but is intended to represent a number that is exactly representable as a decimal numeral with a known number of digits. In this case, the solution suggested by user millimoose again works, with the format specification altered to convert the double to decimal with the desired number of digits (e.g., instead of “%.64f”, you could use “%.6f”).
  • The function is changed to pass the number in another way, such as with decimal floating-point, as a scaled integer, or as a string containing a decimal numeral.

Once you have clarified the problem statement, it may be interesting to consider how to solve it with floating-point arithmetic, rather than calling library functions for formatted output. This is likely to have pedagogical value (and incidentally might produce a solution that is computationally more efficient than calling a library function).

Upvotes: 0

user1520427
user1520427

Reputation: 1365

You cannot represent real numbers (doubles) precisely in a computer - they need to be approximated. If you change your function to work on longs or ints there won't be any inaccuracies. That seems natural enough for the context of your question, you're just looking at the digits and not the number, so .345 can be 345 and get the same result.

Try this:

int get_largest_digit(int n) {
  int largest = 0;

  while (n > 0) {
    int x = n % 10;
    if (x > largest) largest = x;
     n /= 10;
  }
  return largest;
}

Upvotes: 1

Steve K
Steve K

Reputation: 2202

This is how floating point number work, unfortunately. The core of the problem is that there are an infinite number of floating point numbers. More specifically, there are an infinite number of values between 0.1 and 0.2 and there are an infinite number of values between 0.01 and 0.02. Computers, however, have a finite number of bits to represent a floating point number (64 bits for a double precision number). Therefore, most floating point numbers have to be approximated. After any floating point operation, the processor has to round the result to a value it can represent in 64 bits.

Another property of floating point numbers is that as number get bigger they get less and less precise. This is because the same 64 bits have to be able to represent very big numbers (1,000,000,000) and very small numbers (0.000,000,000,001). Therefore, the rounding error gets larger when working with bigger numbers.

The other issue here is that you are converting from floating point to integer. This introduces even more rounding error. It appears that when (0.345 * 10000) is converted to an integer, the result is closer to 3449 than 3450.

I suggest you don't convert your numbers to integers. Write your program in terms of floating point numbers. You can't use the modulus (%) operator on floating point numbers to get a value for digit. Instead use the fmod function in the C math library (cmath.h).

Upvotes: 0

evanmcdonnal
evanmcdonnal

Reputation: 48134

This is because the fractional component of real numbers is in the form of 1/2^n. As a result you can get values very close to what you want but you can never achieve exact values like 1/3.

It's common to instead use integers and have a conversion (like 1000 = 1) so if you had the number 1333 you would do printf("%d.%d", 1333/1000, 1333 % 1000) to print out 1.333.

By the way the first sentence is a simplification of how floating point numbers are actually represented. For more information check out; http://en.wikipedia.org/wiki/Floating_point#Representable_numbers.2C_conversion_and_rounding

Upvotes: 0

Related Questions