Comparison of 0.0 and -0.0
Due to the peculiarities of working with data in EO, an interesting quirk had been arising when comparing 0.0 and
-0.0. The fact is that in EO, these two values were not considered equal until we made changes.
Until recently, the comparison of 0.0 and -0.0 in EO didn’t work like in other languages, but we changed that. This
short blog post provides a simplified explanation of number encodings, how such comparison takes place in popular
programming languages, and how we changed this comparison in EO to meet the standard.
Why do we have two zeros?
Without delving into the intricacies of number encoding and standards, let’s briefly understand why this happens.
The familiar signed int works based on the two’s complement
principle, in which zero has a unique representation (all bits are 0).
On the other hand, float operates differently, using the IEEE 754 standard
for encoding and arithmetic operations. In this standard, numbers have a sign bit. If the sign bit is 1, the number is
negative; if it’s 0, the number is positive. As a result, we have two different binary representations of float
zero: 0.0 has all zeros in its binary representation, while -0.0 has all zeros except for the sign bit.
Comparison of 0.0 and -0.0 in EO before the changes
EO comparison used to work as follows:
0.0.eq -0.0 # FALSE
0.0.gt -0.0 # FALSE
0.0.lt -0.0 # FALSE
0.0.gte -0.0 # FALSE
0.0.lte -0.0 # FALSE
This happened because the eq attribute compared data within objects bitwise. In simpler terms, regardless of the data
being compared, it was first interpreted as a set of bits and then compared.
Thus, due to the fact that numbers 0.0 and -0.0, as previously determined, have different bitwise representations,
when compared in EO using eq, they turned out to be not equal.
Comparison of 0.0 and -0.0 in other languages
In most mainstream programming languages 0.0 is considered equal to -0.0 in basic equality comparisons. For
example, in Java, C++, JavaScript, and Python, the comparison of these values works as follows:
0.0 == -0.0 // true
0.0 < -0.0 // false
0.0 > -0.0 // false
0.0 <= -0.0 // true
0.0 >= -0.0 // true
Why do these languages consider 0.0 and -0.0 as equal, even though they have different bitwise representations? The
same IEEE 754 standard states that “negative zero and positive zero should compare as equal with the usual (numerical)
comparison operators” (referencing the standard in the blog post isn’t possible as it’s a paid document, but you can
find this information here).
Thus, this behavior for float numbers is built into most CPUs and works at the assembler level. Comparison operators,
such as ==, in the languages discussed above, correspond to how it is implemented in the hardware. This is indeed the
case in most languages.
Comparison of 0.0 and -0.0 in EO now
In order for the floating-point comparison in EO to comply with the standard, we have changed the behavior of the eq
attribute for float. After these changes the comparison of 0.0 and -0.0 behaves as follows:
0.0.eq -0.0 # TRUE
0.0.gt -0.0 # FALSE
0.0.lt -0.0 # FALSE
0.0.gte -0.0 # TRUE
0.0.lte -0.0 # TRUE
Now it works like in all popular programming languages. It’s worth noting that we didn’t add extra atoms (you can read
more about atoms in this blog post). The eq attribute still
compares floats bitwise; we simply added a special condition for zeros.
Conclusion
We changed eq attribute of float to meet the IEEE 754 standard. Significant reasons are needed to deviate from the
standard, so we decided that it would be more correct to do as in other programming languages.