According to The Java Language Specification (JLS), §4.2.3, "Floating-Point Types, Formats, and Values" [JLS 2015]:
NaN
(not-a-number) is unordered, so the numerical comparison operators<
,<=
,>
, and>=
returnfalse
if either or both operands areNaN
. The equality operator==
returnsfalse
if either operand isNaN
, and the inequality operator!=
returnstrue
if either operand isNaN
.
Because this unordered property is often unexpected, direct comparisons with NaN
must not be performed. Problems can arise when programmers write code that compares floating-point values without considering the semantics of NaN
. For example, input validation checks that fail to consider the possibility of a NaN
value as input can produce unexpected results (see NUM08-J. Check floating-point inputs for exceptional values for additional information).
Noncompliant Code Example
This noncompliant code example attempts a direct comparison with NaN
. In accordance with the semantics of NaN
, all comparisons with NaN
yield false (with the exception of the !=
operator, which returns true). Consequently, this comparison always return false
, and the "result is NaN"
message is never printed.
public class NaNComparison { public static void main(String[] args) { double x = 0.0; double result = Math.cos(1/x); // Returns NaN if input is infinity if (result == Double.NaN) { // Comparison is always false! System.out.println("result is NaN"); } } }
Compliant Solution
This compliant solution uses the method Double.isNaN()
to check whether the expression corresponds to a NaN
value:
public class NaNComparison { public static void main(String[] args) { double x = 0.0; double result = Math.cos(1/x); // Returns NaN when input is infinity if (Double.isNaN(result)) { System.out.println("result is NaN"); } } }
Risk Assessment
Comparisons with NaN
values can lead to unexpected results.
Rule | Severity | Likelihood | Remediation Cost | Priority | Level |
---|---|---|---|---|---|
NUM07-J | Low | Probable | Medium | P4 | L3 |
Automated Detection
Automated detection of comparison with NaN
is straightforward. Sound determination of whether the possibility of an unordered result has been correctly handled is not feasible in the general case. Heuristic checks could be useful.
Tool | Version | Checker | Description |
---|---|---|---|
CodeSonar | PMD.Design.BadComparison FB.CORRECTNESS.FE_TEST_IF_EQUAL_TO_NOT_A_NUMBER | Bad comparison Doomed test for equality to NaN | |
Parasoft Jtest | 10.3 | PB.NUM.NAN | Implemented |
Bibliography
[JLS 2015] | |
[Seacord 2015] | NUM07-J. Do not attempt comparisons with NaN LiveLesson |