2

when I use fmod(0.6,0.2) in c++ it returns 0.2

I know this is caused by floating point accuracy but it seems I have to get remainder of two double this moment

thanks very much for any solutions for this kind of problem

Aillieo
  • 43
  • 7

3 Answers3

3

The mathematical values 0.6 and 0.2 cannot be represented exactly in binary floating-point.

This demo program will show you what's going on:

#include <iostream>
#include <iomanip>
#include <cmath>
int main() {
    const double x = 0.6;
    const double y = 0.2;
    std::cout << std::setprecision(60)
              << "x          = " << x << "\n"
              << "y          = " << y << "\n"
              << "fmod(x, y) = " << fmod(x, y) << "\n";
}

The output on my system (and very likely on yours) is:

x          = 0.59999999999999997779553950749686919152736663818359375
y          = 0.200000000000000011102230246251565404236316680908203125
fmod(x, y) = 0.1999999999999999555910790149937383830547332763671875

The result returned by fmod() is correct given the arguments you passed it.

If you need some other result (I presume you were expecting 0.0), you'll have to do something different. There are a number of possibilities. You can check whether the result differs from 0.2 by some very small amount, or perhaps you can do the computation using integer arithmetic (if, for example, all the numbers you're dealing with are multiples of 0.1 or of 0.01).

Keith Thompson
  • 254,901
  • 44
  • 429
  • 631
  • yes I finally added a judgement statement after fmod to check if the returned value differs from 0.2 very small and it works well since then. I m not sure about the decimal digits before function called so now I can't find good way to adopt your second solution but it's helpful maybe I will try it later – Aillieo Jul 20 '16 at 07:25
1

I think your best bet here would be to use the remainder function instead of fmod. For the given example, it will return a very small number rather than 0.2. You can use this fact to assume a remainder of 0 by rounding to a certain level of precision.

VortixDev
  • 965
  • 1
  • 10
  • 23
  • remainder function returns negtive value in some cases that's not what i need but your answer really helps .Now I added a judgement after fmod if it returns a value very close to 0.2(certain level precision) it will return 0 – Aillieo Jul 20 '16 at 07:07
0

You're right, the problem is a rounding error. Try this code:

#include <stdio.h>
#include <math.h>
int main()
{
    double d6 = 0.6;
    double d2 = 0.2;
    double d = fmod (d6, d2);
    printf ("%30.20e %30.20e %30.20e\n", d6, d2, d);

}

When I run it in gcc 4.4.7 the output is:

5.99999999999999977796e-01     2.00000000000000011102e-01     1.99999999999999955591e-01

As for how to "fix" it, I don't know enough about exactly what you are trying to do to know what to suggest. There will always be numbers that cannot be exactly represented in floating point, so this kind of behavior is unavoidable.

More information about the problem domain would be helpful to get better suggestions. For example, if the numbers you are working with always just have one digit after the decimal point, and are small enough, just multiply by 10, round to the nearest integer (or long or long long), and use the % operator rather than the fmod function. If you are trying to see whether the result of fmod is 0.0, simply accept a result that is close to 0.2 (in this case) as if it were close to 0.

Michael Rodby
  • 336
  • 4
  • 6