Inconsistent Floating Point Math and NaNs on Windows Laptops?

Question

All -
I am seeing some very strange inconsistent floating point calculations on Windows Laptops, and I am wondering if anyone has any ideas. Read on, as (to me!) it's very interesting....
I have attached a segment of our code, along with some sample output. Looking at the code and the output, it seems like it's totally impossible.
With supposedly non-NaN and non-infinite double values, I am seeing unrepeatable and inconsistent math - the below example only illustrates one such case where we're seeing this behavior.
If you look at the code below, you will see that I do things like:
double rhoYo = ...  // some math
double rho = ...  // exact same mathStrangely enough, I might get rhoYo = 1.51231231 etc and rho = NaN.
If I reverse those lines (vertically), then again, rhoYo comes out good and rho comes out NaN; however, this is unpredictable and inconsistent. If I project a source point, get a destination point with NaNs as a result, and project the source again, the second destination point may be just fine. Matter of fact, i can put a loop in the code such as:
      double rho = Double.NaN;
      for( int i = 0; i < 10; i++ )
        rho = my_earthRad * my_F / Math.pow(Math.tan(Math.PI/4.0 + latRad/2.0), my_n);
        if( ! Double.isNaN( rho ) )
          break;
        System.out.println("NaN'ed rho");
      }and rho will eventually become non-NaN (random # of iterations)!!
How's that possible? Our code might be tromping on memory somewhere, but this sure seems crazy to me, especially considering that
we're only using local variables. Anyone know of floating point errors on Windows Laptops?
With the exact same codebase, this behavior ONLY happens on Windows Laptops, including brand new Dells, old Dells, IBM, Intel and AMD chips (I've tried several ;-). It does NOT happen on Mac or Linux, including the Linux side of a Linux/Windows dual-boot (where it does happen with the Windows side). Even more strangely, it does NOT happen with Windows desktops. I have tried several 1.5.x JVMs, webstart vs no webstart, etc, to no avail. Always and only on Windows Laptops.
Please help.... ;-) and thanks in advance.
Sample code:
public class Projection
  protected Point2D.Double _project(Point2D.Double srcPt, Point2D.Double dstPt) {
    final double my_degToRad = Math.PI / 180.0;
    final double my_originLon = -95.0;
    final double my_originLonRad = my_originLon * my_degToRad;
    final double my_originLat = 25.0;
    final double my_originLatRad = my_originLat * my_degToRad;;
    final double my_stdLat1 = 25.0;
    final double my_stdLat1Rad = my_stdLat1 * my_degToRad;
    final double my_earthRad = 6371.2;
    final double my_n = Math.sin( my_stdLat1Rad );
    final double my_F = Math.cos( my_stdLat1Rad ) * Math.pow( Math.tan( Math.PI / 4.0 + my_stdLat1Rad / 2.0 ), my_n ) / my_n;
    final double my_rhoZero = my_earthRad * my_F / Math.pow( Math.tan( Math.PI / 4.0 + my_originLatRad / 2.0 ), my_n );
    if ( Double.isNaN( my_n ) || Double.isNaN( my_F ) || Double.isNaN( my_rhoZero )) {
      return new Point2D.Double(Double.NaN, Double.NaN);
    if( Double.isNaN( srcPt.x ) || Double.isNaN( srcPt.y ) )
        System.out.println("======= _project received a srcPt with NaNs. Returning NaN point.");
        Point2D.Double nanPoint = new Point2D.Double();
        nanPoint.x = nanPoint.y = Double.NaN;
        return nanPoint;
    if( Double.isInfinite( srcPt.x ) || Double.isInfinite( srcPt.y ) )
        System.out.println("======= _project received a srcPt with isInfinite. Returning NaN point.");
        Point2D.Double nanPoint = new Point2D.Double();
        nanPoint.x = nanPoint.y = Double.NaN;
        return nanPoint;
    //  Inputs are lon, lat degrees.
    final double lonRad = srcPt.x * my_degToRad;
    final double latRad = srcPt.y * my_degToRad;
    final double theta = my_n * (lonRad - my_originLonRad);
    // One Std lat -- tangential cone.
    final double rhoYo = my_earthRad * my_F / Math.pow(Math.tan(Math.PI/4.0 + latRad/2.0), my_n);
    final double rho   = my_earthRad * my_F / Math.pow(Math.tan(Math.PI/4.0 + latRad/2.0), my_n);
    // Computes kilometers in lambert space.
    dstPt.x = rho * Math.sin(theta);
    dstPt.y = my_rhoZero - (rho * Math.cos(theta));
    // WANK - Here's the problem!  These values shouldnt be NaN!
    if( Double.isNaN( dstPt.x ) || Double.isNaN( dstPt.y ) )
        System.out.println("======= A _projected dstPt has NaNs. Dumping...vvvvvvvvvvvvvvvvvvvvvvvvvvvv");
        if( Double.isNaN( dstPt.x ) )
            System.out.println("======= dstPt.x is NaN");
        if( Double.isNaN( dstPt.y ) )
            System.out.println("======= dstPt.y is NaN");
        System.out.println("======= my_stdLat1 = " + my_stdLat1 );
        System.out.println("======= my_n = " + my_n );
        System.out.println("======= my_originLonRad = " + my_originLonRad );
        System.out.println("======= my_F = " + my_F );
        System.out.println("======= my_earthRad = " + my_earthRad );
        System.out.println("======= lonRad = " + lonRad );
        System.out.println("======= latRad = " + latRad );
        System.out.println("======= theta = " + theta );
        System.out.println("======= Math.tan(Math.PI/4.0 + latRad/2.0) = " + Math.tan(Math.PI/4.0 + latRad/2.0) );
        System.out.println("======= Math.pow(Math.tan(Math.PI/4.0 + latRad/2.0), my_n) = " + Math.pow(Math.tan(Math.PI/4.0 + latRad/2.0), my_n) );
        System.out.println("======= rho = " + rho );
        System.out.println("======= rhoYo = " + rhoYo );
        System.out.println("======= Math.sin(theta) = " + Math.sin(theta) );
        System.out.println("======= dstPt.x = " + dstPt.x );
        System.out.println("======= Math.cos(theta) = " + Math.cos(theta) );
        System.out.println("======= my_rhoZero = " + my_rhoZero );
        System.out.println("======= (rhoYo * Math.cos(theta)) = " + (rho * Math.cos(theta)) );
        System.out.println("======= my_rhoZero - (rhoYo * Math.cos(theta)) = " + (my_rhoZero - (rho * Math.cos(theta)) ));
        System.out.println("======= dstPt.y = " + dstPt.y );
        System.out.println("======= A _projected dstPt had NaNs. Done dumping. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
    return dstPt;
}And here's the sample output:
======= A _projected dstPt has NaNs. Dumping...vvvvvvvvvvvvvvvvvvvvvvvvvvvv
======= dstPt.x is NaN
======= dstPt.y is NaN
======= my_stdLat1 = 25.0
======= my_n = 0.42261826174069944
======= my_originLonRad = -1.6580627893946132
======= my_F = 2.5946660025799146
======= my_earthRad = 6371.2
======= lonRad = -2.7564670759053924
======= latRad = 0.3730758324037379
======= theta = -0.4642057102537187
======= Math.tan(Math.PI/4.0 + latRad/2.0) = 1.4652768116539785
======= Math.pow(Math.tan(Math.PI/4.0 + latRad/2.0), my_n) = 1.175224090766834
======= rho = NaN
======= rhoYo = 14066.369269924155
======= Math.sin(theta) = -0.44771270676160557
======= dstPt.x = NaN
======= Math.cos(theta) = 0.8941774612481554
======= my_rhoZero = 13663.082491950498
======= (rhoYo * Math.cos(theta)) = NaN
======= my_rhoZero - (rhoYo * Math.cos(theta)) = NaN
======= dstPt.y = NaN
======= A _projected dstPt had NaNs. Done dumping. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Answer 1

HI JSchell (and others?) -
I have created a simple example attached below, that when run repeatedly, does indeed generate spurious NaNs. I have made it as simple as possible. In the code, I use my own lon/lat binary data file, though I am sure any will do. Let me know if anyone wants that file.
So the deal is that (with my data at least) this program should never generate NaN results. And if one runs it 25432 (eg: random #) times, it wont, but then the 25433th time, it will create NaNs, etc. ie: inconsistent NaN math results.
As I said before, I have run this on old and new Dell laptops under Windows XP, using java 1.5_02, 1.5_04 and 1.5_08. The latest run was on a brand new Dell with a Intel Core Duo T2600 processor, running XP. If this is a result of the Pentium bug, one would think that would be fixed by now. I have NOT yet tested on AMD, though I will do that this afternoon.
Remember, this ONLY happens with Windows Laptops.
Any ideas anyone? Thanks in advance ;-)
Here's the code that produces spurious NaNs:
import java.awt.geom.Point2D;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
public class FloatingPointTest2 implements Runnable
  private static final int NUM_ITERATIONS = 100000;
  private double _degToRad = Math.PI / 180.0;
  private double _originLon = -95.0;
  private double _originLat = 25.0;
  private double _originLonRad = _originLon * _degToRad;
  private double _originLatRad = _originLat * _degToRad;;
  private double _stdLat1 = 25.0;
  private double _stdLat1Rad = _stdLat1 * _degToRad;
  private double _earthRad = 6371.2;
  private double _n = _n = Math.sin( _stdLat1Rad );
  private double _F = Math.cos( _stdLat1Rad ) * Math.pow( Math.tan( Math.PI / 4.0 + _stdLat1Rad / 2.0 ), _n ) / _n;
  private double _rhoZero = _earthRad * _F / Math.pow( Math.tan( Math.PI / 4.0 + _originLatRad / 2.0 ), _n );
  private Point2D.Double _project( Point2D.Double srcPt, Point2D.Double dstPt )
    if( Double.isNaN( srcPt.x ) || Double.isNaN( srcPt.y ) )
      System.out.println( "FloatingPointTest2: received a NaN srcPt.  Skipping." );
      return new Point2D.Double( Double.NaN, Double.NaN );
    //  Inputs are lon, lat degrees.
    final double lonRad = srcPt.x * _degToRad;
    final double latRad = srcPt.y * _degToRad;
    final double theta = _n * ( lonRad - _originLonRad );
    double rho = _earthRad * _F / Math.pow( Math.tan( Math.PI / 4.0 + latRad / 2.0 ), _n );
    dstPt.x = rho * Math.sin( theta );
    dstPt.y = _rhoZero - ( rho * Math.cos( theta ) );
    return dstPt;
  public void doTest()
    DataInputStream instream = null;
    int thisRunNaNCount = 0;
    Point2D.Double tempPt = new Point2D.Double();
    Point2D.Double dstPt = new Point2D.Double();
    try
      instream = new DataInputStream( new FileInputStream( System.getProperty(
        "user.home" ) + File.separatorChar + "lonLatBinaryData.bin" ) );
      try
        while( true )
          double lon = instream.readDouble();
          double lat = instream.readDouble();
          if( Double.isNaN( lon ) || Double.isNaN( lat ) )
            continue;
          tempPt.x = lon;
          tempPt.y = lat;
          dstPt = _project( tempPt, dstPt );
          if( Double.isNaN( dstPt.x ) || Double.isNaN( dstPt.y ) )
            thisRunNaNCount++;
      catch( EOFException e )
//        System.out.println( "End of file" );
      if( thisRunNaNCount > 0 )
        System.out.println( "thisRunNaNCount = " + thisRunNaNCount );
      instream.close();
    catch( Exception e )
      e.printStackTrace();
      System.exit( 1 );
  public void run()
    doTest();
  public static void main( String args[] )
    System.out.println( "Executing FloatingPointTest2." );
    for( int i = 0; i < NUM_ITERATIONS; i++ )
      FloatingPointTest2 test = new FloatingPointTest2();
      test.doTest();
}