C Floating-Point == Comparison Accuracy with 0.1 Steps

The == operator in C compares the exact binary values stored in the floating‑point representation — it does not “round” decimal-looking input like 0.1 to a neat decimal; 0.1 is not exactly representable in binary, so straight == comparisons will often fail. Use an epsilon-based comparison or, better, integer/fixed‑point scaling or rounding (or use double precision) to test “equality to one decimal place”; for robust solving prefer algebraic rearrangement or a numeric library such as GSL.

Contents

• Floating-Point Precision in C
• Does == check exact binary representation?
• Reliable equality detection: epsilon, rounding and integer scaling
• Better numerical practices and using GSL
• Practical fixes and corrected C code
• Sources
• Conclusion

Floating-Point Precision in C

Floating-point types (float, double) store numbers in binary with a finite mantissa and exponent, so many base‑10 fractions — 0.1, 0.2, 0.3 — have no exact binary representation. That means the value you write in source code (for example 0.1) becomes a nearby binary fraction when stored. Single precision (float) has about 24 bits of precision; double has about 53 bits. See a clear explanation and the practical pitfalls at GeeksforGeeks and the deeper discussion at the Floating-Point Guide.

A small demonstration: printing a float with high precision reveals the stored value — try:

float a = 0.1f;
printf("%.17g\n", (double)a); // prints the actual binary->decimal approximation

You’ll see extra digits like 0.10000000149011612 for single precision. Why? Because the compiler converts the decimal literal to the nearest representable binary fraction and that stored bit pattern is what comparisons use.

Does == check exact binary representation?

Yes — the == operator compares the numeric values as represented in memory. If two floats hold different bit patterns (even if they look like the same decimal when printed to one decimal place), == will usually return false. There’s no automatic “rounding to human decimals” in the equality operator.

Two additional pitfalls in your original code:

• Using float loop counters with x += 0.1 accumulates rounding error, so x may become 0.30000001 instead of exactly 0.3. Don’t rely on repeated floating increments for exact decimal steps.
• Decimal literals without an f suffix (0.1) are double constants; comparing a float to a double causes the float to be promoted for the comparison, which can change the result. Community discussions and recommended practices are summarized on Stack Overflow and elsewhere; see Stack Overflow discussion on float comparison.

Reliable equality detection: epsilon, rounding, and integer scaling

There are three practical ways to handle “equality to one decimal place” reliably.

1. Absolute / relative epsilon

• Use a small tolerance: if |a − b| < epsilon treat them as equal.
• For fixed small values (you only care about 1 decimal), an absolute epsilon is fine. For values that vary in magnitude, use a combined absolute+relative test.

Example (hybrid test taken from community best practice):

#include <math.h>
#include <stdbool.h>

bool nearly_equal(double a, double b, double rel_eps, double abs_eps) {
 double diff = fabs(a - b);
 if (diff <= abs_eps) return true;
 return diff <= fmax(fabs(a), fabs(b)) * rel_eps;
}

/* usage */
if (nearly_equal(k6, eqrounded, 1e-9, 1e-12)) { /* equal */ }

References and more robust forms are discussed on Stack Overflow and in the Floating-Point Guide.

2. Round both values to the desired decimal place (tenth) then compare

• Use roundf/round/lround/lrint to round to the nearest tenth before comparing.

double round_tenth(double v) { return round(v * 10.0) / 10.0; }

double left = round_tenth(k6);
double right = round_tenth(equation);
if (fabs(left - right) < 1e-12) { /* equal to 0.1 precision */ }

Be careful: avoid truncation (int cast) if you intended to round.

3. Integer / fixed-point scaling (most robust for discrete steps)

• Represent values in tenths as integers and compare integers — this removes the floating increment error entirely.

long k6_tenths = i * 10 + xi; // xi is 0..9
long eq_tenths = lround(equation * 10.0); // nearest tenth as integer
if (k6_tenths == eq_tenths) { /* match */ }

This method also lets you avoid using float loop counters like x += 0.1 (which accumulates error). The Book of C and other references discuss machine epsilon and rounding behavior; see The Book of C.

Better numerical practices and using GSL

Before brute-force searching with nested loops, ask: can the equation be rearranged? Your equation is linear in K7:
K6 = A - K7 / xs, where
A = (C1/(jj))(sin(xs/j))/xs + (C2/(jj))(cos(xs/j))/xs - (Wjj/2)/xs.

So you can compute A once, then for any candidate K6 compute the exact K7 required:
K7 = (A - K6) * xs.
That eliminates the inner loop entirely and is exact up to floating precision. Why do all three loops when algebra gives you K7 directly?

If the system were genuinely nonlinear in both unknowns, use numerical solvers rather than blind nested loops. The GNU Scientific Library (GSL) provides robust solvers for ODEs and root-finding and is well documented — see the GSL docs on initialization and methods at GSL ODE initval and notes on numeric stability at GSL polynomials. Community examples show how to move from naive loops to GSL solvers for reliability and speed.

Other recommendations:

• Use double for intermediate calculations unless memory/performance forces single precision.
• Choose epsilon based on expected magnitudes (don’t fudge epsilons to make tests pass).
• Prefer integer/fixed-point when your domain is discrete (tenths in your case).

Practical fixes and corrected C code

Below are two compact fixes: (A) algebraic direct solve with integer tenths; (B) corrected brute-force style with integer loops and rounding. Both use double.

A) Direct/computed K7 (fast and exact up to FP rounding)

#include <stdio.h>
#include <math.h>

int main(void) {
 double C1 = -2783.02, C2 = -3921.87, j = 2.33, W = 801.15, xs = 1.04;
 double A = (C1/(j*j)) * sin(xs/j) / xs
 + (C2/(j*j)) * cos(xs/j) / xs
 - (W*j*j/2.0) / xs;

 for (int i = 0; i < 1000000; ++i) {
 for (int xi = 0; xi <= 9; ++xi) { // xi = 0..9 -> 0.0 .. 0.9
 double k6 = i + xi / 10.0;
 double k7 = (A - k6) * xs; // exact required K7
 long k7_tenths = lround(k7 * 10.0); // nearest tenth
 // check if k7 rounded to tenths equals the exact value
 if (fabs(k7 - (k7_tenths / 10.0)) < 1e-8) {
 printf("Found K6 = %.1f K7 = %.1f\n", k6, k7_tenths / 10.0);
 return 0;
 }
 }
 }
 printf("No match found\n");
 return 0;
}

B) If you must brute-force the original way, use integer counters and integer tenths comparison:

for (int i = 0; i < MAX_I; ++i) {
 for (int k = 0; k < MAX_K; ++k) {
 for (int xi = 0; xi <= 9; ++xi) {
 double x = xi / 10.0;
 double k6 = i + x;
 double equation = /* compute RHS for this k */ ;
 long eq_tenths = lround(equation * 10.0);
 long k6_tenths = i * 10 + xi;
 if (eq_tenths == k6_tenths) { /* match */ }
 }
 }
}

Notes:

• Use int/long for counters; avoid float loop variables.
• Use lround/lrint to round to nearest integer, not simple cast which truncates.
• Choose tolerances consistent with double precision (1e-8 or smaller for tenths is usually safe when working with doubles).

Compile with math library: gcc -std=c11 -O2 -Wall -lm.

Sources

• https://stackoverflow.com/questions/9850663/comparing-same-float-values-in-c
• https://www.geeksforgeeks.org/c/comparison-float-value-c/
• https://www.reddit.com/r/C_Programming/comments/ql90ji/c_cant-detect_when_floating_point_number_equals/
• https://www.reddit.com/r/cprogramming/comments/1kxptm8/why_does_this-comparison_fail_with_float_in_c_but_work_with_double/
• https://how-to.fandom.com/wiki/Howto_compare_floating_point_numbers_in_the_C_programming_language
• https://floating-point-gui.de/errors/comparison/
• https://stackoverflow.com/questions/4915462/how-should-i-do-floating-point-comparison
• https://www.thebookofc.com/floating-point/comparing-floats-using-epsilon/
• https://www.reddit.com/r/cpp_questions/comments/1ap668e/float_comparison/
• https://softwareengineering.stackexchange.com/questions/323668/choosing-an-epsilon-when-comparing-floating-point-numbers-across-different-syste
• https://sites.google.com/a/phys.buruniv.ac.in/numerical/laboratory/example-codes/ordinary-differential-equations-in-gsl
• https://sites.google.com/a/phys.buruniv.ac.in/numerical/laboratory/example-codes/systems-of-linear-equations-in-gsl
• https://www.gnu.org/software/gsl/doc/html/ode-initval.html
• https://www.gnu.org/software/gsl/doc/html/poly.html
• https://stackoverflow.com/questions/40949616/gsl-gnu-solving-first-order-ordinary-differential-equation

Conclusion

The == operator tests exact stored binary equality in C, so decimal steps like 0.1 will rarely compare equal because 0.1 isn’t stored exactly. Use an epsilon-based test, rounding to tenths, or — best for discrete tenths — integer/fixed‑point scaling to compare reliably; and avoid float loop counters (use integer counters or compute K7 analytically). For robust numerical work or nonlinear systems, move to double precision and consider numeric libraries such as GSL.