What is the best way to compare decimals?

Question

What is the best way to compare decimals ?

lets say I have 2 values, like 3.45 and 3.44, what is the best way to reliably compare them ?

I was thinking of storing all numbers as 345 and 344 so that I am comparing whole numbers only, and only show to the user formatted numbers with the decimal point.

Another solution would be to use custom functions, to test of the difference, and when the difference is less than 0.01 the numbers should be equal.

What are other possible solutions (better solutions) ?

I would test the difference: if ((flOne - flTwo) < MY_TOLERANCE) ... — Leo Chapiro, Feb 07 '13 at 20:19
3.45 is not greater than 3.44? Why do you want them to be equal? — ogzd, Feb 07 '13 at 20:19
Can you use *fixed point* math instead? An example would be to convert from floating point meters to fixed point millimeters. — Thomas Matthews, Feb 07 '13 at 20:42
A lot depends on where these numbers are coming from, and what they mean. For example, if I might want to treat two numbers as being equal if they are the results of floating point calculations with rounding errors, but distinct if they are direct input. — Patricia Shanahan, Feb 07 '13 at 21:10

score 4 · Accepted Answer · answered Feb 07 '13 at 20:23

The most common technique is to use an epsilon (the second thing you described). It can be extremely difficult/impossible to make a generic epsilon that works for all input numbers nicely though. If you're dealing with numbers around 0.00001 or numbers around 1000000000 an epsilon of 0.01 would likely be horrible for you. Read this for a really comprehensive analysis of epsilon techniques.

The first solution you described is very common in time math. Everything is represented in an integer number of ticks. The ticks can represent 1 second, or 1 millisecond, or whatever you want. You can then convert them into a decimal of another unit if you like, or compare them. The only thing is that you do need to choose a tick size, and nothing can represent smaller than 1 tick unit.

leemes · Answer 2 · 2013-02-07T20:50:39.870

This is also known as "fuzzy comparison", allowing the two values to differ a little bit (tolerance, also known as "epsilon"). Typically, such an epsilon value is around 1E-6 to 1E-10, but you find applications in which smaller or greater values are better suitable: in your example the epsilon shouldn't be less than 1E-2 = 0.01.

Once you found an epsilon value which suits your needs, you could write the following set of comparison functions like the following (written in the common subset of C and C++; they should work for almost every object-oriented / procedural language with minor changes):

const double fuzzyEpsilon = 1E-6;  // just an example!

bool fuzzyEqual(double a, double b) {
    return (abs(a - b) <= fuzzyEpsilon);
}

bool fuzzyUnqual(double a, double b) {
    return (abs(a - b) > fuzzyEpsilon);
}

int fuzzyCompare(double a, double b) {
    return ((a - b) > fuzzyEpsilon) - ((b - a) > fuzzyEpsilon);
}

The third function returns a code of -1, 0, 1 if a < b, a == b, a > b respectively with fuzzy comparison (analogous to strcmp). The implementation assumes that the programming language implicitly converts boolean values to 0 (false) and 1 (true). If not, use the following:

int fuzzyCompare(double a, double b) {
    return (a - b) > fuzzyEpsilon ? 1 :
          ((b - a) > fuzzyEpsilon ? -1 : 0);
}

`strcmp` isn't something you should be modeling new code after, it's archaic. — David, Feb 07 '13 at 20:54
@Dave But it's one of only two good ways to indicate a comparison result. The other one being an enum. — leemes, Feb 07 '13 at 21:28
Why are you making that function in the first place? Why not have different functions for the 6 comparisons? To avoid a number being < and > another number (and other logic abnormalities) you'll have to add extra logic. — David, Feb 07 '13 at 21:33
@Dave Well, it can be implemented as required. I have written "you *could* write", so if one is interested in a "compare" method analogous to `strcmp`, there it is. Typically, you don't do fuzzy comparing if you're only interested in either less or greater (where equal values aren't really expected and thus just arbitrarily treated as either less or greater). — leemes, Feb 07 '13 at 21:36

score 0 · Answer 3 · answered Feb 07 '13 at 20:46

Representing decimal values in binary real is approximate, leading to a variety of odd behaviors. Accuracy often degrades with further arithmetic, particularly subtractions of nearby values. Individual values however can be cleaned up for comparison, by rounding to a minimum number of digits before comparing them. For example V = round (V * 1e14)/1e14 rounds any value V to 14 decimal digits. Two such values can be confidently compared for equality. 64-bit real has 15.65 deimal precision, so rounding to 14 digits (or less) provides some room for error.

Yes, the multiply, round( ) and divide sequence is expensive. However, decimal is a human interface, often used for monetary applications that cannot tolerate "funny" arithmetic. Being wrong is usually much worse than being slow.

What is the best way to compare decimals?

3 Answers3