C ++ Precision使用long long with double

Question

I am experimenting with c++. I wrote a simple function that finds the area of a triangle using very large numbers.

I pass two large numbers into the function, and from a separate function, getValue() I return a separate value from a different equation. I'm curious why when I place the 1 on the line outside the parenthesis, like so:

return (long long)(a - b / 2.0) + b + 1;

I get the value 9007200509008001

And when I keep the 1 inside the parenthesis, like so:

return (long long)(a - b / 2.0 + 1) + b;

I get 9007200509008000

The second value is one less than the first, even though the computation should result in equal answers.

#include <iostream>

double triangleArea(int b, int h)
{
    long long bh = (long long)b * h;
    return 0.5 * bh;
}

long long getValue()
{
    int deltaY = 18014400;
    int deltaX = 1000000000;

    long b = deltaY + deltaX + 1600;
    double a = triangleArea(deltaX, deltaY);
    return (long long)(a - b / 2.0) + b + 1;
}

int main(int argc, char **argv) 
{
    std::cout << getValue() << std::endl;
}

I'm sure the answer is probably obvious to some people, but I can't wrap my head around it. Can someone explain?

Answer 1

When you divide by 2.0 you have an implicit conversion to double. Double accuracy is limited to about 15 decimal digits. So what happens to the 16 ^th digit is perfectly defined, but may not be what you expect.

If you need accuracy, try to use long long or unsigned long long and carefully control that you have no overflow. If it is not enough, you will have to use multi-precision arithmetic (for example GMP ). Because as soon as you use double floating points, you are limited to 53 binary digits of accuracy, or about 15-16 decimal digits.

Answer 2

The problem is an implicit cast to double at your division and the variable a .

Check out the following sample for clearance:

#include <iostream>

double triangleArea(int b, int h)
{
    long long bh = (long long)b * h;
    return 0.5 * bh;
}

long long getValue()
{
    int deltaY = 18014400;
    int deltaX = 1000000000;

    long b = deltaY + deltaX + 1600;
    double a = triangleArea(deltaX, deltaY);

    long long c = b / 2.0;

    long long d1 = a - c;
    long long d2 = ((long long)a) - c + 1;

    long long e1 = d1 + b + 1;
    long long e2 = d2 + b;

    return e1;
}

int main(int argc, char **argv)
{
    std::cout << getValue() << std::endl;
}

The explicit cast to long long is solving your special problem there.

Be aware of your variable accuracy and converting between them.

Answer 3

long long typically has a higher precision that double . For instance, if both are 64 bits, then long long has a precision of 64 bits, but double has only 53-bit precision (a 52-bit mantissa with implied msb=1).

In your case, what this means is that a - b / 2.0 + 1 is the same double constant as a - b / 2.0 , but (long long)(a - b / 2.0) + b + 1 is not the same long long constant as (long long)(a - b / 2.0) + b .