ConvertSignedInt64ToDouble

// ConvertSignedInt64ToDouble(highWord, lowWord)
// NOTE: This routine has not been thoroughly tested.
// Converts a signed 64-bit integer expressed as two 32-bit words into a double.
// The two 32-bit words are typically read into Igor using FBinRead/F=3/U.
// Double-precision floating point can represent integer values up to 2^53 precisely.
// Above that integers are only approximated. Therefore this routine supports
// values up to +/- 2^53 and returns NaN for values that are too big.
// Examples:
//	Print ConvertInt64ToDouble(0x00000000, 0x00000001)	// Plus 1
//	Print ConvertInt64ToDouble(0xFFFFFFFF, 0xFFFFFFFE)		// Minus 1 in 2's complement
Function ConvertInt64ToDouble(highWord, lowWord)
	Variable highWord, lowWord

	Variable result
	if ((highWord & 0x80000000) == 0)
		// Positive number
		if ((highWord & 0xFFE0000) != 0)			// Check high order 11 bits
			result = NaN
		else
			result = lowWord + 2^32*highWord
		endif
	else
		// Negative number stored as 2's complement
		// Theoretically the conversion would be:
		//	result = 2^64 - lowWord + 2^32*highWord
		//	result = -result
		// However Igor calculations are done in double-precision floating point
		// and the largest integer that it can represent precisely is 2^53. Thus
		// we have to discard some of the high order bits to get the signed value
		// into a range were we can do the conversion precisely.
		if ((highWord & 0xFFE0000) != 0xFFE0000)	// Check high order 11 bits
			result = NaN
		else
			highWord = highWord & 0x001FFFFF		// Zap 11 most significant bits
			result = lowWord + 2^32*highWord
			result = 2^53 - result
			result = - result
		endif
	endif
	return result
End