1

I have read multiple articles regarding floating point variables comparison, but failed to understand and get the required knowledge from those articles. So, here I am posting this question.

What is the good way to compare two float variables? Below is the code snippet:

#define EPSILON_VALUE 0.0000000000000001

bool cmpf(float A, float B)
{
  return (fabs(A - B) < EPSILON_VALUE);
}

int main()
{
  float a = 1.012345679, b = 1.012345678;

  if(cmpf(a, b))cout<<"same"<<endl;
  else cout<<"different"<<endl;

  return 0;
}

The output: same although both the float variables hold different values.

Improve this question
19
  • all your code is only to make sure two floats that are not exactly the same are considered the same, hence I dont understand what else did you expect... What is the question? The one you asked you already answered yourself Commented May 8, 2019 at 11:27
  • 1
    @user463035818 as you can see that both float variables (a & b) hold different values, but the output printed by the code is 'same' instead of 'different'. Commented May 8, 2019 at 11:30
  • 1
    It is wholly dependent on context. Sometimes comparing with an additive tolerance is appropriate, sometimes a multiplicative one is better. Sometimes == will do the job. You need to study your algorithm and how the errors, if any, will accumulate. The linked duplicate is a good starting point. Commented May 8, 2019 at 11:33
  • 1
    @user463035818: 1 - 1.0 / 3 - 1.0 / 3 - 1.0 / 3 is perhaps a better one. Commented May 8, 2019 at 11:37
  • 1
    FWIW, the exact values 1.012345679 and 1.012345678, when stored as floats, are both stored as the approximated value 1.01234567165374755859375, so when stored as floats, they are the exact same values. They should return "same", even without the EPSILON_VALUE. Note that your epsilon is below the precision a float can give anyway. Also, when you subtract nearly equal values, you should expect catastrophic cancellation, which can be a problem too. Commented May 8, 2019 at 19:49

3 Answers 3

Reset to default
7

There is no general solution for comparing floating-point numbers that contain errors from previous operations. The code that must be used is application-specific. So, to get a proper answer, you must describe your situation more specifically.

The underlying problem is that performing a correct computation using incorrect data is in general impossible. If you want to compute some function of two exact mathematical values x and y but the only data you have is some inexactly computed values x and y, it is generally impossible to compute the exactly correct result. For example, suppose you want to know what the sum, x+y, is, but you only know x is 3 and y is 4, but you do not know what the true, exact x and y are. Then you cannot compute x+y.

If you know that x and y are approximately x and y, then you can compute an approximation of x+y by adding x and y. The works when the function being computed (+ in this example) has a reasonable derivative: Slightly changing the inputs of a function with a reasonable derivative slightly changes its outputs. This fails when the function you want to compute has a discontinuity or a large derivative. For example, if you want to compute the square root of x (in the real domain) using an approximation x but x might be negative due to previous rounding errors, then computing sqrt(x) may produce an exception. Similarly, comparing for inequality or order is a discontinuous function: A slight change in inputs can change the answer completely (from false to true or vice-versa).

The common bad advice is to compare with a “tolerance”. This method trades false negatives (incorrect rejections of numbers that would satisfy the comparison if the exact mathematical values were compared) for false positives (incorrect acceptance of numbers that would not satisfy the comparison).

Whether or not an applicable can tolerate false acceptance depends on the application. Therefore, there is no general solution.

The level of tolerance to set, and even the nature by which it is calculated, depend on the data, the errors, and the previous calculations. So, even when it is acceptable to compare with a tolerance, the amount of tolerance to use and how to calculate it depend on the application. There is no general solution.

Improve this answer
Sign up to request clarification or add additional context in comments.

22 Comments

@MichaelChourdakis: How do you compute a square root or a cosine with integers or fractions?
@MichaelChourdakis: “You don’t” is not an acceptable solution for many algorithms. Any VR, AR, or physics modeling needs square roots and trigonometric functions. Much scientific and mathematical work needs those and other mathematical functions which are not sufficiently served with integer or rational arithmetic. Dismissing floating-point is not practical.
@RudyVelthuis: With integer arithmetic, what is the square root of two? How is that more precise than with floating-point? With rational arithmetic, what is the cosine of 4/5?
@RudyVelthuis: Remember the context here— Michael Chourdakis’s comment to use integers or fractions. Using BigDecimal is floating-point arithmetic, regardless of whether it is implemented with integers. The issue is that integer or rational arithmetic is inadequate for many tasks for which floating-point is suitable.
@RudyVelthuis: See that “scale” you write of in BigDecimal? That is the “floating” of floating-point. It is not integer arithmetic. It is floating-point arithmetic.
|
1

The output: same although both the float variables hold different values.

"float variables hold different values." is unfounded.

same was printed because values a,b are the same even if the initialization constants differ.

Typical float is 32-bits and can represent about 232 different values such as 1.0, 1024.0, 0.5, 0.125. These values are all of the form: +/- some_integer*2some_integer

1.012345679 and 1.012345678 are not in that float set. @Rudy Velthuis.

1.012345 67165374755859375 // `float` member
1.012345 678
1.012345 679
1.012345 790863037109375   // `float` member

Similar applies for double, yet with more precision - commonly 64 bits.

1.012345679 and 1.012345678 are not in that double set either

1.012345 67799999997106397131574340164661407470703125    // `double` member
1.012345 678
1.012345 6780000001931085762407747097313404083251953125  // `double` member
...
1.012345 6789999998317597373898024670779705047607421875  // `double` member
1.012345 679
1.012345 67900000005380434231483377516269683837890625    // `double` member

It can be thought of as 2 steps of rounding. Code 1.012345679 is rounded to the nearest double 1.01234567900000005380434231483377516269683837890625. Then the assignment rounds the double to the nearest float 1.01234567165374755859375.

float a = 1.012345679;
// 'a' has the value of 1.01234567165374755859375

Likewise for b. Code 1.012345678 is rounded to the nearest double 1.01234567799999997106397131574340164661407470703125. Then the assignment rounds the double to the nearest float 1.01234567165374755859375.

flaot b = 1.012345678;
// 'b' has the value of 1.01234567165374755859375

a and b have the same value.

Improve this answer

Comments

-3

It's because floats have 7 digit precision. If you want better precision you need to use double or long double.

Improve this answer

4 Comments

Just blindly throwing more bits at the problem is not a solution
Why should I use double when not required. I am able to get the execution using float too, but due to precision, I am struggling. The same will be with the double when storing bigger. Is there any straight-forward solution to this?
Your problem comes from the fact that you need higher precision types. It make sense to use a data type which uses more bits. Care to explain why you are reluctant to use a different type?
"because floats have 7 digit precision" --> not always. Sample counter example: Both 8589973, 8589974 and covert to 8589974.0f

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.