Math problems in Java; uncanny NaN from a calculation

Question

Hi, I am working on a project that does a lot of querying and the some mathematical modeling based on results from these queries, and finally some scoring (read: "execution time too long to test thoroughly").

Recently I have realized a rather new problem/bug in my code; some of the results get NaN values for score! Here's how the scores are calculated:

Note that pfound, psig are doubles that are always positive or 0

Double  score1 = (pfound!=0) ? (Math.log(factorial((int)psig + 1))/pfound) : 0;

score1 = score1 * alpha_coeff[0];
if (score1.isInfinite())
    throw new RuntimeException(p.getName() + " score1 = Inf");
else if(score1.isNaN())
    throw new RuntimeException(p.getName() + " score1 = NaN");

I have checked the possible causes triggering NaN, but I believe it should be safe from most of those:

1. I am already checking for pfound == 0 (so no divide by zero)

2. Argument to Math.log() cannot have a negative value

What I suspect is whether or not factorial() (a custom function which return the factorial as a long) returns a long so big that it can't be cast into a double without loss of precision or something like that. I checked Long.doubleValue(), and apparently it generates NaN if it's argument results in NaN.

Any comments? Am I missing something fundamental here?

Answer 1

You shouldn't compare doubles against zero explicitly - it almost never works. Better do something like this:

double EPS = 0.0000001;
if (Math.abs (pfound) < EPS) { //pfound is null } 

The only place I see which can produce NaN is Math.log. From its documentation:

1. If the argument is NaN or less than zero, then the result is NaN.
2. If the argument is positive infinity, then the result is positive infinity.
3. If the argument is positive zero or negative zero, then the result is negative infinity.

I think pfound contains negative value neer zero and that's why you get NaN. Try to track variable values in a debugger.

Answer 2

NaNs propagate through various arithmetic operations so even if you are checking the conditions here correctly they could be getting introduced from elsewhere.

I'd suspect either alpha_coeff[0] or pfound - try checking these for NaN.

NaN could also be a result from your factorial function, depending on how this is defined. EDIT: just noticed that you specified that this produces a long, so factorial can't produce a NaN, on the other hand it could produce a negative result if it overflows which would cause a NaN from the log().

Answer 3

If your factorial is doing the naive evaluation of x! = 1*2*3..., I'll bet you're asking for a factorial of a number that can't fit into the reference you're using.

Two pieces of advice:

1. Try BigDecimal if that's the case
2. Use gamma function instead of naive implementation.

Recursion for factorial(n) where n > 12 is a very bad, naive idea. You weren't seriously thinking about going forward with something like this, were you?