C/C++ Arithmetic expression with double numbers - strange results - translating in java

Question

FIRST PROBLEM

In C code I have this expression:

double completeExpression  = x1 - h*exp(-lambda*t);

I have split it in two operations:

double value = h*exp(-lambda*t);
double subtraction = x1 - value;

The problem is that subtraction is different from completeExpression. What's the matter?

I have reproduced a strange results in my code with this lines:

const double TOLERANCE = 1e-16;
double h = 0.51152525298500628;
double lambda =0.99999999999999978;
double t=0.1;
double x1 =0.4628471891711442 ;

double completeExpression  = x1 - h*exp(-lambda*t);
double value = h*exp(-lambda*t);
double subtraction = x1 - value;

printf("x1 = %1.4e & value = %1.4e",x1,value);
printf("\ncompleteExpression = %1.4e",completeExpression);
printf("\nsubtraction = %1.4e",subtraction);

Results:

x1 = 4.6285e-001 & value = 4.6285e-001
completeExpression = 8.2779e-017
subtraction = 5.5511e-017

---

SECOND PROBLEM:

I have to translate the completeExpression in Java, and I have returned always the bad result (subtraction) and not completeExpression value:

Code:

 static double TOLERANCE = 1e-16;
   public static void main() {

        double h = 0.51152525298500628;
        double lambda =0.99999999999999978;
        double t=0.1;
        double x1 =0.4628471891711442 ;

        double completeExpression  = x1 - h*Math.exp(-lambda*t);
        double value = h*Math.exp(-lambda*t);
        double subtraction = x1 - value;

        System.out.println( "x1 = " + String.format("%1.4e", value) + "& value = " + String.format("%1.4e",x1) );
        System.out.println("\ncompleteExpression = " + String.format("%1.4e",completeExpression));
        System.out.println("\nsubtraction = " + String.format("%1.4e",subtraction));

---

#gcc --version

My Gcc Version:
$ gcc --version
gcc.exe (GCC) 4.8.1
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Answer 1

Floating-point numbers (unlike integers) are almost never exactly the same. The reason is in the way they are stored (with the mantissa and the exponent).

In the end you can never be sure that the two floating-point numbers are the same after performing the "same" operations on them. And more to the point - the if(subtraction!=completeExpression) is generally invalid. Instead you should be looking for a "close match":

if( abs(subtraction - completeExpression) < TOLERANCE )

where TOLERANCE is some constant you have, like const double TOLERANCE = 1e-16;

For more information on why are the floating-point numbers "approximate" you can read the Wiki on Floating point. But the basic reason is that the range of numbers represented by the floating-point values is far larger than the number of digits that can be encoded into a given space.

A 32-bit integer can encode values from -2GB to +2GB but a 32-bit float's range is all the way from -3.4e38 to +3.4e38. That is a range difference of over 20 digits!

For a 64-bit values the range difference is even bigger and is almost 300 digits.

That extended range comes at a price - a portion of that 32 or 64 bit space is used to represent the "precision" digits (in binary, not in decimal) and the number of those is what is limiting the final precision of your floating-point numbers.

Generally speaking two numbers 123e456 and 1.23e458 (when represented in floating-point IEEE 754 binary format) are still going to be different, even though mathematically they are absolutely equal.