In this article, we will see what is the problem in comparing floating-point numbers and we will discuss the correct way to compare two floating-point numbers.

**What is the problem in comparing Floating-Point Numbers usually?**

Let us first compare two floating-point numbers with the help of **relational operator (==)**.

**Example:** Using “==” for comparison

## CPP

`// C++ program to compare` `// floating point numbers` ` ` `#include <bits/stdc++.h>` `using` `namespace` `std;` ` ` `void` `compareFloatNum(` `double` `a, ` `double` `b)` `{` ` ` `if` `(a == b) {` ` ` `cout << ` `"The numbers are equal"` ` ` `<< endl;` ` ` `}` ` ` `else` `{` ` ` `cout << ` `"The numbers are not equal"` ` ` `<< endl;` ` ` `}` `}` ` ` `// Driver code` `int` `main()` `{` ` ` `double` `a = (0.3 * 3) + 0.1;` ` ` `double` `b = 1;` ` ` `compareFloatNum(a, b);` `}` |

## Java

`// Java program to compare` `// floating point numbers` `class` `GFG ` `{` ` ` ` ` `static` `void` `compareFloatNum(` `double` `a, ` `double` `b) ` ` ` `{` ` ` `if` `(a == b)` ` ` `{` ` ` `System.out.print(` `"The numbers are equal"` `+ ` `"\n"` `);` ` ` `} ` ` ` `else` ` ` `{` ` ` `System.out.print(` `"The numbers are not equal"` `+ ` `"\n"` `);` ` ` `}` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{` ` ` `double` `a = (` `0.3` `* ` `3` `) + ` `0.1` `;` ` ` `double` `b = ` `1` `;` ` ` `compareFloatNum(a, b);` ` ` `}` `}` ` ` `// This code is contributed by 29AjayKumar` |

## Python

`# Python program to compare` `# floating point numbers` `def` `compareFloatNum(a, b):` ` ` `if` `(a ` `=` `=` `b):` ` ` `print` `(` `"The numbers are equal"` `)` ` ` ` ` `else` `:` ` ` `print` `(` `"The numbers are not equal"` `)` ` ` `# Driver code` ` ` `a ` `=` `(` `0.3` `*` `3` `) ` `+` `0.1` `b ` `=` `1` `compareFloatNum(a, b)` ` ` `# This code is contributed by mohit kumar 29` |

## C#

`// C# program to compare` `// floating point numbers` `using` `System;` ` ` `class` `GFG ` `{` ` ` ` ` `static` `void` `comparefloatNum(` `double` `a, ` `double` `b) ` ` ` `{` ` ` `if` `(a == b)` ` ` `{` ` ` `Console.Write(` `"The numbers are equal"` `+ ` `"\n"` `);` ` ` `} ` ` ` `else` ` ` `{` ` ` `Console.Write(` `"The numbers are not equal"` `+ ` `"\n"` `);` ` ` `}` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `Main(String[] args) ` ` ` `{` ` ` `double` `a = (0.3 * 3) + 0.1;` ` ` `double` `b = 1;` ` ` `comparefloatNum(a, b);` ` ` `}` `}` ` ` `// This code is contributed by PrinciRaj1992` |

**Output:**

The numbers are not equal

**Why does this problem occur?**

In the case of floating-point numbers, the **relational operator (==)** does not produce correct output, this is due to the internal precision errors in rounding up floating-point numbers.

In the above example, we can see the inaccuracy in comparing two floating-point numbers using “==” operator. The two numbers ‘a’ and ‘b’ are equal ( as (0.3 * 3) + 0.1 = 1 ) but the program results in an incorrect output.

Let’s take a closer look at the numbers in the next snippet.

`// C++ program to compare` `// floating point numbers` ` ` `#include <bits/stdc++.h>` `using` `namespace` `std;` ` ` `void` `printFloatNum(` `double` `a, ` `double` `b)` `{` ` ` `// To print decimal numbers up to 20 digits` ` ` `cout << setprecision(20);` ` ` ` ` `cout << ` `"a is : "` `<< a << endl;` ` ` `cout << ` `"b is : "` `<< b << endl;` `}` ` ` `// Driver code` `int` `main()` `{` ` ` `double` `a = (0.3 * 3) + 0.1;` ` ` `double` `b = 1;` ` ` `printFloatNum(a, b);` `}` |

**Output:**

a is : 0.99999999999999988898 b is : 1

Now we can see the internal rounding error in floating-point numbers. Number ‘a’ is not correctly rounded up to 1,

there is an internal error in rounding up, a very small error but makes a huge difference when we are comparing the numbers.

**How to compare floating-point numbers correctly?**

If we do have to compare two floating-point numbers then rather than using “==” operator we will find the absolute difference between the numbers (which if were correctly represented, the difference would have been 0) and compare it with a very small number 1e-9 (i.e 10^-9, this number is very small) and if the difference is less than this number, we can safely say that the two floating-point numbers are equal.

**Example:**

## C++

`// C++ program to compare` `// floating point numbers correctly` ` ` `#include <bits/stdc++.h>` `using` `namespace` `std;` ` ` `void` `compareFloatNum(` `double` `a, ` `double` `b)` `{` ` ` ` ` `// Correct method to compare` ` ` `// floating-point numbers` ` ` `if` `(` `abs` `(a - b) < 1e-9) {` ` ` `cout << ` `"The numbers are equal "` ` ` `<< endl;` ` ` `}` ` ` `else` `{` ` ` `cout << ` `"The numbers are not equal "` ` ` `<< endl;` ` ` `}` `}` ` ` `// Driver code` `int` `main()` `{` ` ` `double` `a = (0.3 * 3) + 0.1;` ` ` `double` `b = 1;` ` ` `compareFloatNum(a, b);` `}` |

## Java

`// Java program to compare` `// floating point numbers correctly` `class` `GFG` `{` ` ` `static` `void` `compareFloatNum(` `double` `a, ` `double` `b)` `{` ` ` ` ` `// Correct method to compare` ` ` `// floating-point numbers` ` ` `if` `(Math.abs(a - b) < 1e-` `9` `)` ` ` `{` ` ` `System.out.print(` `"The numbers are equal "` ` ` `+` `"\n"` `);` ` ` `}` ` ` `else` ` ` `{` ` ` `System.out.print(` `"The numbers are not equal "` ` ` `+` `"\n"` `);` ` ` `}` `}` ` ` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `double` `a = (` `0.3` `* ` `3` `) + ` `0.1` `;` ` ` `double` `b = ` `1` `;` ` ` `compareFloatNum(a, b);` `}` `}` ` ` `// This code is contributed by Rajput-Ji` |

## Python3

`# Python program to compare` `# floating ponumbers correctly` ` ` `def` `compareFloatNum(a, b):` ` ` ` ` `# Correct method to compare` ` ` `# floating-ponumbers` ` ` `if` `(` `abs` `(a ` `-` `b) < ` `1e` `-` `9` `):` ` ` `print` `(` `"The numbers are equal "` `);` ` ` `else` `:` ` ` `print` `(` `"The numbers are not equal "` `);` ` ` `# Driver code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `a ` `=` `(` `0.3` `*` `3` `) ` `+` `0.1` `;` ` ` `b ` `=` `1` `;` ` ` `compareFloatNum(a, b);` ` ` `# This code is contributed by PrinciRaj1992` |

## C#

` ` `// C# program to compare` `// floating point numbers correctly` `using` `System;` ` ` `class` `GFG` `{` ` ` `static` `void` `comparefloatNum(` `double` `a, ` `double` `b)` `{` ` ` ` ` `// Correct method to compare` ` ` `// floating-point numbers` ` ` `if` `(Math.Abs(a - b) < 1e-9)` ` ` `{` ` ` `Console.Write(` `"The numbers are equal "` ` ` `+` `"\n"` `);` ` ` `}` ` ` `else` ` ` `{` ` ` `Console.Write(` `"The numbers are not equal "` ` ` `+` `"\n"` `);` ` ` `}` `}` ` ` `// Driver code` `public` `static` `void` `Main(String[] args)` `{` ` ` `double` `a = (0.3 * 3) + 0.1;` ` ` `double` `b = 1;` ` ` `comparefloatNum(a, b);` `}` `}` ` ` `// This code is contributed by 29AjayKumar` |

**Output:**

The numbers are equal

This code results in the correct output, so whenever two floating point numbers are two be compared then rather than using “==” operator, we will use the above technique.

**C++ Foundation Course**for Basic to Advanced C++ and

**C++ STL Course**for foundation plus STL. To complete your preparation from learning a language to DS Algo and many more, please refer

**Complete Interview Preparation Course**

**.**