2

Today I find an interesting fact that the formula will influence the precision of the result. Please see the below code

double x = 7d
double y = 10d
​println(1-x/y​)
println((y-x)/y​)​

I wrote this code using groovy, you can just treat it as Java

The result is 

1-x/y: 0.30000000000000004
(y-x)/y: 0.3

It's interesting that the two formulas which should be equal have different result.

  • Can anyone explain it for me?
  • And can I apply the second formula to anywhere applicable as a valid solution for double precision issue?
Aiden Zhao
  • 564
  • 5
  • 24
  • 1
    This is important http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html – DejaVuSansMono Nov 04 '16 at 13:28
  • Try printing out all the intermediate results. One of them is probably slightly off, because it cannot be accurately represented in base-2. – Thilo Nov 04 '16 at 13:35
  • Not surprising at all: an extreme example is `1-sqr(cos(x))`, where sqr denotes squaring. This is mathematically equal to `sqr(sin(x))`. Now try to evaluate these formulas for `x` near to 0. – Henry Nov 04 '16 at 13:53

1 Answers1

0

To control the precision of floating point arithmetic, you should use java.math.BigDecimal. You can do something like this.

BigDecimal xBigdecimal = BigDecimal.valueOf(7d);
BigDecimal yBigdecimal = BigDecimal.valueOf(10d);
System.out.println(BigDecimal.valueOf(1).subtract(xBigdecimal.divide(yBigdecimal)));

Can anyone explain it for me?

The float and double primitive types in Java are floating point numbers, where the number is stored as a binary representation of a fraction and a exponent.

More specifically, a double-precision floating point value such as the double type is a 64-bit value, where:

1 bit denotes the sign (positive or negative). 11 bits for the exponent. 52 bits for the significant digits (the fractional part as a binary). These parts are combined to produce a double representation of a value.

Check this

For a detailed description of how floating point values are handled in Java, follow Floating-Point Types, Formats, and Values of the Java Language Specification.

The byte, char, int, long types are fixed-point numbers, which are exact representions of numbers. Unlike fixed point numbers, floating point numbers will some times (safe to assume "most of the time") not be able to return an exact representation of a number. This is the reason why you end up with 0.30000000000000004 in the result of 1 - (x / y​).

When requiring a value that is exact, such as 1.5 or 150.1005, you'll want to use one of the fixed-point types, which will be able to represent the number exactly.

As I've already showed in the above example, Java has a BigDecimal class which will handle very large numbers and very small numbers.

Shamsuddin Tibriz
  • 54
  • 1
  • 3
  • 13