# Be careful with floats!

Let's consider a simple example in C where we sum floating-point numbers and compare the result to what we might expect. This example will illustrate how floating-point precision issues can lead to unexpected results.

We will sum the floating point number `0.1`

ten times and compare the result to `1.0`

. Intuitively, one might expect that summing `0.1`

ten times should give exactly `1.0`

.

```
#include <stdio.h>
int main() {
double sum = 0.0;
for (int i = 0; i < 10; i++) {
sum += 0.1;
}
if (sum == 1.0) {
printf("Sum is exactly 1.0\n");
} else {
printf("Sum is not exactly 1.0, it is %f\n", sum);
}
return 0;
}
```

The code sums `0.1`

ten times and checks if the result is `1.0`

. Due to the way floating point numbers are represented, the sum might not be exactly `1.0`

.

The output will likely indicate that the sum is not exactly `1.0`

. The actual sum printed will be very close to `1.0`

, but not exactly `1.0`

, due to the precision issues with floating-point arithmetic.

Comparing floating point values in C can be tricky due to the way these values are represented and handled in computer systems. Here's an overview of the issues and best practices:

### Why Not Compare Floating Points Directly?

**Precision Issues**: Floating point numbers are represented in a format that cannot precisely represent all decimal numbers. This leads to small rounding errors. For example, the result of a computation like`0.1 + 0.2`

might not be exactly`0.3`

.**Representation**: Floating points are stored in a binary format that can result in unexpected differences even for seemingly identical values.

### What Can Go Wrong?

**False Mismatches**: Due to precision issues, two values that should be equal might not be the same in their binary representation. This can lead to incorrect comparison results.**Inaccurate Computations**: Operations involving floating points can accumulate errors, leading to significant discrepancies over time.

### How to compare:

**Use a Tolerance Value (Epsilon)**: Instead of checking for equality, check if the absolute difference between the numbers is less than a small threshold value.`#include <math.h> #define EPSILON 1e-9 int floatCompare(double a, double b) { return fabs(a - b) < EPSILON; }`

**Relative Comparison**: Sometimes it's better to use a relative difference comparison, especially when dealing with very large or very small numbers.`int relativeCompare(double a, double b) { return fabs(a - b) <= EPSILON * fmax(fabs(a), fabs(b)); }`

### Corner Cases and Sample Code:

**Zero Comparison**: Directly comparing to zero can be misleading due to precision errors.`if (fabs(myFloat) < EPSILON) { // Treat as zero }`

**Large Numbers**: For very large numbers, the epsilon value might need to be scaled accordingly.**Denormalized Numbers**: Very small floating point numbers can become 'denormalized', leading to a loss of precision. Be cautious when comparing values close to the limits of floating-point representation.**NaN and Infinity**: Be aware that floating points can represent 'Not a Number' (NaN) and infinity. Comparisons involving these special values need special handling.`if (isnan(myFloat) || isinf(myFloat)) { // Special handling for NaN and infinity }`

**Accumulated Errors in Loops**: Repeated operations can accumulate errors. Be careful when comparing the results of iterative processes.