# Floating Point Operations & Associativity in C, C++ and Java

Do Floating point operations follow property of associativity? In other words, do we always get the same results for expressions “(A + B) + C” and “A + (B + C)” One may expect that floating numbers to follow the rule of associativity in programming languages as they are associative mathematically. However, this is not true in all cases. Consider below C/C++ program.

## C

 `// C/C++ program to demonstrate that floating point` `// addition may not be associative.` `#include `   `int` `main()` `{` `    ``// A and B have same values but opposite signs` `    ``float` `A = -500000000;` `    ``float` `B =  500000000;`   `    ``float` `C = 1;`   `    ``printf``(``"A + (B + C) is equal to %f \n"``, A + (B + C));` `    ``printf``(``"(A + B) + C is equal to %f"``, (A + B) + C);`   `    ``return` `0;` `}`

Output:

```A + (B + C) is equal to 0.000000
(A + B) + C is equal to 1.000000```

It is evident from the above-given output that the floating-point arithmetic may not follow the law of associativity in every case. This is due to the format in which the floating-point numbers are stored and represented, it rounds off the numbers during calculations, hence, the associative laws of algebra do not necessarily hold for floating-point numbers. In this case,

```Explanation for above output:

A + (B + C):
(B + C) = 500000000.0 + 1.0
= 500000000.0
(rounded off during floating point arithmetic)

A + (B + C) = -500000000.0 + 500000000.0
=  0.000000

(A + B) + C:
(A + B) = -500000000.0 + 500000000.0
= 0.000000

(A + B) + C = 0.000000 + 1
= 1.000000```

How about Java? We get the same results in Java as Java also uses similar representation for floating-point numbers.

## Java

 `// Java program to demonstrate that floating-point` `// addition may not be associative` `import` `java.io.*;`   `class` `Main` `{` `    ``public` `static` `void` `main (String[] args)` `    ``{` `        ``// A and B have same values but opposite signs` `        ``float` `A = -``500000000``;` `        ``float` `B =  ``500000000``;`   `        ``float` `C = ``1``;`   `        ``System.out.println("A + (B + C) is equal to " + ` `                          ``(A + (B + C)));` `        ``System.out.println("(A + B) + C is equal to " + ` `                          ``((A + B) + C));` `    ``}` `}`

Output:

```A + (B + C) is equal to 0.000000
(A + B) + C is equal to 1.000000```

How about integers? Now letâ€™s try the same calculations when the data type is integer. Here is a piece of code for your observation:

## C++

 `#include ` `using` `namespace` `std;`   `int` `main()` `{` `   ``// A and B have same values but opposite signs` `   ``int` `A = -500000000;` `   ``int` `B =  500000000;`   `   ``int` `C = 1;`   `   ``cout << ``" A + (B + C) is equal to "` `<< A + (B + C) << endl;` `   ``cout << ``"(A + B) + C is equal to "` `<< (A + B) + C << endl;`   `   ``return` `0;` `}`   `// This code is contributed by sarajadhav12052009`

## C

 `#include `   `int` `main()` `{` `   ``// A and B have same values but opposite signs` `   ``int` `A = -500000000;` `   ``int` `B =  500000000;`   `   ``int` `C = 1;`   `   ``printf``(``" A + (B + C) is equal to %d \n"``, A + (B + C));` `   ``printf``(``"(A + B) + C is equal to %d"``, (A + B) + C);`   `   ``return` `0;` `}`

## Java

 `import` `java.io.*;`   `class` `Main` `{` `    ``public` `static` `void` `main (String[] args)` `    ``{` `        ``// A and B have same values but opposite signs` `        ``int` `A = -``500000000``;` `        ``int` `B =  ``500000000``;`   `        ``int` `C = ``1``;`   `        ``System.out.println(``"A + (B + C) is equal to "` `+ ` `                          ``(A + (B + C)));` `        ``System.out.println(``"(A + B) + C is equal to "` `+ ` `                          ``((A + B) + C));` `    ``}` `}`   `// This code is contributed by sarajadhav12052009`

Output

``` A + (B + C) is equal to 1
(A + B) + C is equal to 1
```

Time Complexity: O(1).
Auxiliary Space: O(1).

If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Feeling lost in the vast world of Backend Development? It's time for a change! Join our Java Backend Development - Live Course and embark on an exciting journey to master backend development efficiently and on schedule.
What We Offer:
• Comprehensive Course
• Expert Guidance for Efficient Learning
• Hands-on Experience with Real-world Projects
• Proven Track Record with 100,000+ Successful Geeks

Previous
Next